root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Corretta formattazione

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@1317 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
alex 1995-05-02 07:49:17 +00:00
parent 6b65f69796
commit 8d5bb8cd57
1 changed files with 924 additions and 924 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

616
include/ccustio.c
View File

@ -1,22 +1,22 @@
/* /*
@(SH) Funzioni per la gestione dei file a record. @(SH) Funzioni per la gestione dei file a record.
@(M$) PRIVATE @(M$) PRIVATE
CalcPos(Rec,Len,Base) : Calcola la posizione del record nel file CalcPos(Rec,Len,Base) : Calcola la posizione del record nel file
@(C$) PRIVATE @(C$) PRIVATE
LOCKSEM : 'locksem' ; nome del semaforo utilizzato per il lock LOCKSEM : 'locksem' ; nome del semaforo utilizzato per il lock
@(VG$) PRIVATE @(VG$) PRIVATE
ld : struttura su disco che contien i dati per i lock sui file ld : struttura su disco che contien i dati per i lock sui file
sizeld : numero di byte occupati dalla struttura ld sizeld : numero di byte occupati dalla struttura ld
semres : flag per l'ok delle operazioni sui semafori semres : flag per l'ok delle operazioni sui semafori
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
*/ */
#include "ccustio.h" #include "ccustio.h"
#include "checks.h" #include "checks.h"
@ -40,26 +40,26 @@ semres : flag per l'ok delle operazioni sui semafori
#define LOCK_OFF 1200000000L #define LOCK_OFF 1200000000L
#ifndef DOS #ifndef DOS
#define LOCKSEM "locksem" #define LOCKSEM "locksem"
/* extern long lseek(int, long, int);*/ /* extern long lseek(int, long, int);*/
extern int chsize(int, long); extern int chsize(int, long);
extern int lockf(int, int, long); extern int lockf(int, int, long);
#endif #endif
unsigned setlock(unsigned); unsigned setlock(unsigned);
int seeklk(SecDef *, long, unsigned, unsigned, long); int seeklk(SecDef *, long, unsigned, unsigned, long);
#ifndef DOS #ifndef DOS
int semtran(char *); int semtran(char *);
static void semcall(int, int); static void semcall(int, int);
void PS(int); void PS(int);
void VS(int); void VS(int);
#endif #endif
/* /*
BOOLEAN test_share() BOOLEAN test_share()
{ {
#ifdef DOS #ifdef DOS
static BOOLEAN share_active = 2; static BOOLEAN share_active = 2;
if (share_active == 2) if (share_active == 2)
@ -74,35 +74,35 @@ BOOLEAN test_share()
} }
} }
return share_active; return share_active;
#else #else
return TRUE; return TRUE;
#endif #endif
} }
*/ */
/* /*
@($) setlock CUSTIO @($) setlock CUSTIO
@(ID) @(ID)
Trasforma il modo di lock utente in modo lock XENIX. Trasforma il modo di lock utente in modo lock XENIX.
@(FD) @(FD)
@(ISV) @(ISV)
Nella versione XENIX : Nella versione XENIX :
lm = numero lock xenix. lm = numero lock xenix.
@(FSV) @(FSV)
@(IN) @(IN)
Restituisce il comando XENIX. Restituisce il comando XENIX.
@(FN) @(FN)
*/ */
unsigned setlock(LockMode) unsigned setlock(LockMode)
unsigned LockMode; /* Tipo di lock */ unsigned LockMode; /* Tipo di lock */
{ {
int lm; int lm;
@ -119,34 +119,34 @@ Restituisce il comando XENIX.
else lm = F_ULOCK ; else lm = F_ULOCK ;
#endif #endif
return(lm) ; return(lm) ;
} }
/* /*
@($) seeklk CUSTIO @($) seeklk CUSTIO
@(ID) @(ID)
Effettua una seek. Effettua una seek.
@(FD) @(FD)
@(ISV) @(ISV)
junk = variabile di lavoro. junk = variabile di lavoro.
lock = variabile per eseguire comandi di lock. lock = variabile per eseguire comandi di lock.
@(FSV) @(FSV)
*/ */
int seeklk(S, pos, lm, LockMode, rec) int seeklk(S, pos, lm, LockMode, rec)
SecDef *S ; /* Descrittore file */ SecDef *S ; /* Descrittore file */
long pos ; /* posizione all'interno del file */ long pos ; /* posizione all'interno del file */
unsigned lm ; /* comando di lock per XENIX */ unsigned lm ; /* comando di lock per XENIX */
unsigned LockMode; /* comando di lock utente */ unsigned LockMode; /* comando di lock utente */
long rec; /* n.ro di record */ long rec; /* n.ro di record */
{ {
if (LockMode != NoLock && S->LockMode != ExclLock) if (LockMode != NoLock && S->LockMode != ExclLock)
{ {
#ifdef DOS #ifdef DOS
/* if (test_share()) */ /* if (test_share()) */
{ {
if (_lseek(S->F, LOCK_OFF + rec, SEEK_SET) == -1L) if (_lseek(S->F, LOCK_OFF + rec, SEEK_SET) == -1L)
if ((S->IOR = CIOResult()) != NoErr) return(-1); if ((S->IOR = CIOResult()) != NoErr) return(-1);
@ -166,7 +166,7 @@ lock = variabile per eseguire comandi di lock.
if (lockf(S->F,lm, 1L) == -1) if (lockf(S->F,lm, 1L) == -1)
if ((S->IOR = CIOResult()) != NoErr) return(-1) ; if ((S->IOR = CIOResult()) != NoErr) return(-1) ;
#endif #endif
} }
#ifdef DOS #ifdef DOS
if (_lseek(S->F, pos, SEEK_SET) == -1L) if (_lseek(S->F, pos, SEEK_SET) == -1L)
#else #else
@ -174,46 +174,46 @@ lock = variabile per eseguire comandi di lock.
#endif #endif
if ((S->IOR = CIOResult()) != NoErr) return(-1) ; if ((S->IOR = CIOResult()) != NoErr) return(-1) ;
return(0) ; return(0) ;
} }
/* /*
@(#) CLockRec CUSTIO @(#) CLockRec CUSTIO
@(ID) @(ID)
Esegue un comando lock sul record nro. "rec" del file descritto da "s". Esegue un comando lock sul record nro. "rec" del file descritto da "s".
@(FD) @(FD)
@(ISV) @(ISV)
Solo versione XENIX. Solo versione XENIX.
@(FSV) @(FSV)
*/ */
void CLockRec(s, rec, lockmode) void CLockRec(s, rec, lockmode)
SecDef *s ; /* descrittore del file */ SecDef *s ; /* descrittore del file */
RecNoType rec ; /* numero record su cui effettuare il lock */ RecNoType rec ; /* numero record su cui effettuare il lock */
unsigned lockmode;/* operazione lock da effettuare */ unsigned lockmode;/* operazione lock da effettuare */
{ {
seeklk(s, CalcPos(rec, s->LenRec, s->BaseFil), setlock(lockmode), lockmode, rec); seeklk(s, CalcPos(rec, s->LenRec, s->BaseFil), setlock(lockmode), lockmode, rec);
} }
/* /*
@(#) CVerify CUSTIO @(#) CVerify CUSTIO
@(ID) @(ID)
Verifica che il file "name" esista. Verifica che il file "name" esista.
@(FD) @(FD)
@(ISV) @(ISV)
junk = variabile di lavoro. junk = variabile di lavoro.
@(FSV) @(FSV)
*/ */
void CVerify(S, Name) void CVerify(S, Name)
SecDef *S; /* descrittore File */ SecDef *S; /* descrittore File */
FileName Name; /* nome file */ FileName Name; /* nome file */
{ {
int junk ; int junk ;
S->IOR = NoErr; S->IOR = NoErr;
@ -229,28 +229,28 @@ junk = variabile di lavoro.
junk = CIOResult(); junk = CIOResult();
if (!S->IOR) S->IOR = junk; if (!S->IOR) S->IOR = junk;
} }
} }
/* /*
@(#) COpen CUSTIO @(#) COpen CUSTIO
@(ID) @(ID)
Apre un file di record. Apre un file di record.
@(FD) @(FD)
@(ISV) @(ISV)
junk = variabile di lavoro. junk = variabile di lavoro.
@(FSV) @(FSV)
*/ */
void COpen(S, Name, Len, Base, LockMode) void COpen(S, Name, Len, Base, LockMode)
SecDef *S; /* descrittore file */ SecDef *S; /* descrittore file */
FileName Name; /* nome del file */ FileName Name; /* nome del file */
unsigned Len; /* lunghezza record */ unsigned Len; /* lunghezza record */
unsigned Base; /* offset dall'inizio del file fisico; e' sempre 0 per i file dati */ unsigned Base; /* offset dall'inizio del file fisico; e' sempre 0 per i file dati */
unsigned LockMode;/* lock di apertura del file */ unsigned LockMode;/* lock di apertura del file */
{ {
int junk; int junk;
S->IOR = NoErr; S->IOR = NoErr;
@ -274,27 +274,27 @@ junk = variabile di lavoro.
S->IOR = CIOResult(); S->IOR = CIOResult();
if (close(S->F) == -1) junk = CIOResult(); if (close(S->F) == -1) junk = CIOResult();
} }
} }
/* /*
@(#) CCreate CUSTIO @(#) CCreate CUSTIO
@(ID) @(ID)
Crea un nuovo file di record. Crea un nuovo file di record.
@(FD) @(FD)
@(ISV) @(ISV)
junk = variabile di lavoro. junk = variabile di lavoro.
@(FSV) @(FSV)
*/ */
void CCreate(S, Name, Len, Base, MaxSec) void CCreate(S, Name, Len, Base, MaxSec)
SecDef *S; /* descrittore del file */ SecDef *S; /* descrittore del file */
FileName Name; /* nome del file */ FileName Name; /* nome del file */
unsigned Len; /* lunghezza del record */ unsigned Len; /* lunghezza del record */
unsigned Base; /* offset dall'inizio del file fisico */ unsigned Base; /* offset dall'inizio del file fisico */
RecNoType MaxSec; /* Numero di blocchi di disco da allocare */ RecNoType MaxSec; /* Numero di blocchi di disco da allocare */
{ {
int junk; int junk;
S->IOR = NoErr; S->IOR = NoErr;
@ -311,28 +311,28 @@ junk = variabile di lavoro.
junk = CIOResult(); junk = CIOResult();
if (!S->IOR) S->IOR = junk; if (!S->IOR) S->IOR = junk;
} }
} }
/* /*
@(#) CChsize CUSTIO @(#) CChsize CUSTIO
@(ID) @(ID)
Cambia la dimensione di un file di record. Cambia la dimensione di un file di record.
@(FD) @(FD)
@(ISV) @(ISV)
junk = variabile di lavoro. junk = variabile di lavoro.
@(FSV) @(FSV)
*/ */
void CChsize(S, Name, Len, Base, MaxSec) void CChsize(S, Name, Len, Base, MaxSec)
SecDef *S; /* descrittore del file */ SecDef *S; /* descrittore del file */
FileName Name; /* nome del file */ FileName Name; /* nome del file */
unsigned Len; /* lunghezza del record */ unsigned Len; /* lunghezza del record */
unsigned Base; /* offset dall'inizio del file fisico */ unsigned Base; /* offset dall'inizio del file fisico */
RecNoType MaxSec; /* numero di blocchi del file modificati */ RecNoType MaxSec; /* numero di blocchi del file modificati */
{ {
int junk; int junk;
S->IOR = NoErr; S->IOR = NoErr;
@ -349,21 +349,21 @@ junk = variabile di lavoro.
junk = CIOResult(); junk = CIOResult();
if (!S->IOR) S->IOR = junk; if (!S->IOR) S->IOR = junk;
} }
} }
/* /*
@(#) CClose CUSTIO @(#) CClose CUSTIO
@(ID) @(ID)
Chiude un file di record. Chiude un file di record.
@(FD) @(FD)
*/ */
void CClose(S) void CClose(S)
SecDef *S; /* descrittore del file da chiudere */ SecDef *S; /* descrittore del file da chiudere */
{ {
S->IOR = NoErr; S->IOR = NoErr;
#ifdef DOS #ifdef DOS
if (close(S->F) == -1) S->IOR = CIOResult(); if (close(S->F) == -1) S->IOR = CIOResult();
@ -382,53 +382,53 @@ Chiude un file di record.
if (exclunlock(S->name, (S->LockMode == ExclLock)) == -1) if (exclunlock(S->name, (S->LockMode == ExclLock)) == -1)
S->IOR = CIOResult(); S->IOR = CIOResult();
#endif #endif
} }
/* /*
@(#) CDelete CUSTIO @(#) CDelete CUSTIO
@(ID) @(ID)
Cancella un file di record. Cancella un file di record.
@(FD) @(FD)
*/ */
void CDelete(S, Name) void CDelete(S, Name)
SecDef *S; /* descrittore del file */ SecDef *S; /* descrittore del file */
FileName Name; /* Nome del file */ FileName Name; /* Nome del file */
{ {
if (unlink(Name) == -1) if (unlink(Name) == -1)
S->IOR = CIOResult(); S->IOR = CIOResult();
else else
S->IOR = NoErr; S->IOR = NoErr;
} }
/* /*
@(#) CRead CUSTIO @(#) CRead CUSTIO
@(ID) @(ID)
Legge un record del file. Legge un record del file.
@(FD) @(FD)
@(ISV) @(ISV)
junk = variabile di lavoro. junk = variabile di lavoro.
fpos = contiene la posizione del record all'interno del file. fpos = contiene la posizione del record all'interno del file.
@(FSV) @(FSV)
@(IN) @(IN)
Lo spazio necessario a contenere il record letto deve essere stato allocato in precedenza. Lo spazio necessario a contenere il record letto deve essere stato allocato in precedenza.
@(FN) @(FN)
*/ */
void CRead(S, RecBuf, Rec, LockMode) void CRead(S, RecBuf, Rec, LockMode)
SecDef *S; /* descrittore del file */ SecDef *S; /* descrittore del file */
RecType RecBuf; /* spazio per contenere il record */ RecType RecBuf; /* spazio per contenere il record */
RecNoType Rec; /* Record da leggere */ RecNoType Rec; /* Record da leggere */
unsigned LockMode; /* lock sul record */ unsigned LockMode; /* lock sul record */
{ {
int junk; int junk;
register RecNoType fpos; register RecNoType fpos;
@ -454,33 +454,33 @@ Lo spazio necessario a contenere il record letto deve essere stato allocato in p
} }
} }
else S->IOR = 3; else S->IOR = 3;
} }
/* /*
@(#) CWrite CUSTIO @(#) CWrite CUSTIO
@(ID) @(ID)
Scrive un record nel file. Scrive un record nel file.
@(FD) @(FD)
@(ISV) @(ISV)
junk = variabile di lavoro. junk = variabile di lavoro.
fpos = contiene la posizione del record all'interno del file. fpos = contiene la posizione del record all'interno del file.
@(FSV) @(FSV)
@(IN) @(IN)
Lo spazio necessario a contenere il record letto deve essere stato allocato in precedenza. Lo spazio necessario a contenere il record letto deve essere stato allocato in precedenza.
@(FN) @(FN)
*/ */
void CWrite(S, RecBuf, Rec, LockMode) void CWrite(S, RecBuf, Rec, LockMode)
SecDef *S; /* descrittore del file */ SecDef *S; /* descrittore del file */
RecType RecBuf; /* spazio che contiene il record da scrivere */ RecType RecBuf; /* spazio che contiene il record da scrivere */
RecNoType Rec; /* numero del record da scrivere */ RecNoType Rec; /* numero del record da scrivere */
unsigned LockMode; /* lock sul record */ unsigned LockMode; /* lock sul record */
{ {
int junk; int junk;
register RecNoType fpos; register RecNoType fpos;
@ -506,68 +506,68 @@ Lo spazio necessario a contenere il record letto deve essere stato allocato in p
} }
} }
else S->IOR = 3; else S->IOR = 3;
} }
/* /*
@(#) IDeleteRec CUSTIO @(#) IDeleteRec CUSTIO
@(ID) @(ID)
Cancellazione logica di un record. Cancellazione logica di un record.
@(FD) @(FD)
*/ */
void IDeleteRec(RecBuf) void IDeleteRec(RecBuf)
RecType RecBuf; /* record da cancellare */ RecType RecBuf; /* record da cancellare */
{ {
RecBuf[0] = Deleted; RecBuf[0] = Deleted;
} }
/* /*
@(#) IRecallRec CUSTIO @(#) IRecallRec CUSTIO
@(ID) @(ID)
Recupero logico di un record. Recupero logico di un record.
@(FD) @(FD)
*/ */
void IRecallRec(RecBuf) void IRecallRec(RecBuf)
RecType RecBuf; /* record da recuperare logicamente */ RecType RecBuf; /* record da recuperare logicamente */
{ {
RecBuf[0] = Valid; RecBuf[0] = Valid;
} }
/* /*
@(#) IRecIsDeleted CUSTIO @(#) IRecIsDeleted CUSTIO
@(ID) @(ID)
Controlla se il record in "RecBuf" e' cancellato oppure no. Controlla se il record in "RecBuf" e' cancellato oppure no.
@(FD) @(FD)
*/ */
BOOLEAN IRecIsDeleted(RecBuf) BOOLEAN IRecIsDeleted(RecBuf)
RecType RecBuf; /* record da controllare */ RecType RecBuf; /* record da controllare */
{ {
return (RecBuf[0] == Deleted); return (RecBuf[0] == Deleted);
} }
/* /*
@(#) ITestLock CUSTIO @(#) ITestLock CUSTIO
@(ID) @(ID)
Controlla se l'errore "err" e' dovuto ad un lock. Controlla se l'errore "err" e' dovuto ad un lock.
@(FD) @(FD)
@(ISV) @(ISV)
Versione DOS e XENIX. Versione DOS e XENIX.
@(FSV) @(FSV)
*/ */
BOOLEAN ITestLock(err) BOOLEAN ITestLock(err)
int err; /* codice di errore */ int err; /* codice di errore */
{ {
return(TESTLOCK(err)) ; return(TESTLOCK(err)) ;
@ -575,33 +575,33 @@ int err; /* codice di errore */
#ifndef DOS #ifndef DOS
struct lockdata struct lockdata
{ {
int users; int users;
int excl; int excl;
} ld; } ld;
int sizeld = sizeof(struct lockdata); int sizeld = sizeof(struct lockdata);
/* /*
@($) lockpath CUSTIO @($) lockpath CUSTIO
@(ID) @(ID)
Restituisce il nome del file di lock per il file "name". Restituisce il nome del file di lock per il file "name".
@(FD) @(FD)
@(ISV) @(ISV)
path = percorso per il file (/usr/tmp/....). path = percorso per il file (/usr/tmp/....).
s1,s,s2 = stringhe di lavoro (nomi file). s1,s,s2 = stringhe di lavoro (nomi file).
Solo versione XENIX. Solo versione XENIX.
@(FSV) @(FSV)
*/ */
char *lockpath(name) char *lockpath(name)
char *name; /* stringa nome file */ char *name; /* stringa nome file */
{ {
static char path[200]; static char path[200];
char *s1 = name, *s = name, *s2 = name; char *s1 = name, *s = name, *s2 = name;
@ -612,28 +612,28 @@ char *name; /* stringa nome file */
} }
sprintf(path, "/usr/tmp/%s", s2); sprintf(path, "/usr/tmp/%s", s2);
return(path); return(path);
} }
/* /*
@($) dirname CUSTIO @($) dirname CUSTIO
@(ID) @(ID)
Estrae dal path il nome del direttorio. Estrae dal path il nome del direttorio.
@(FD) @(FD)
@(ISV) @(ISV)
path = percorso per il file . path = percorso per il file .
s = stringa di lavoro. s = stringa di lavoro.
Solo versione XENIX. Solo versione XENIX.
@(FSV) @(FSV)
*/ */
char *dirname(name) char *dirname(name)
char *name; /* stringa contenente il path */ char *name; /* stringa contenente il path */
{ {
static char path[200]; static char path[200];
char *s; char *s;
@ -641,31 +641,31 @@ char *name; /* stringa contenente il path */
if ((s = strrchr(path, DIRSEP)) == NULL) strcpy(path, "."); if ((s = strrchr(path, DIRSEP)) == NULL) strcpy(path, ".");
else *s = '\0'; else *s = '\0';
return(path); return(path);
} }
static int semres = 0; static int semres = 0;
/* /*
@($) semtran CUSTIO @($) semtran CUSTIO
@(ID) @(ID)
Trasforma il nome di un semaforo in un identificatore poi lo crea o lo apre. Trasforma il nome di un semaforo in un identificatore poi lo crea o lo apre.
@(FD) @(FD)
@(ISV) @(ISV)
key = chiave corrispondente al nome semaforo. key = chiave corrispondente al nome semaforo.
id = identificatore del semaforo. id = identificatore del semaforo.
Solo versione XENIX. Solo versione XENIX.
La semget fa una open sul semaforo; se non lo trova lo crea e poi lo libera. La semget fa una open sul semaforo; se non lo trova lo crea e poi lo libera.
@(FSV) @(FSV)
*/ */
int semtran(s) int semtran(s)
char *s; /* stringa nome del semaforo */ char *s; /* stringa nome del semaforo */
{ {
register int key = 0, sid; register int key = 0, sid;
semres = 0 ; semres = 0 ;
@ -677,33 +677,33 @@ char *s; /* stringa nome del semaforo */
VS(sid); VS(sid);
} }
return(sid); return(sid);
} }
/* /*
@($) semcall CUSTIO @($) semcall CUSTIO
@(ID) @(ID)
Chiama il semaforo "sid" e su di esso svolge "op". Chiama il semaforo "sid" e su di esso svolge "op".
@(FD) @(FD)
@(ISV) @(ISV)
sb = struttura necessaria per la chiamata a "semop". sb = struttura necessaria per la chiamata a "semop".
Solo versione XENIX. Solo versione XENIX.
@(FSV) @(FSV)
@(IN) @(IN)
se op = -1 il semaforo viene occupato. se op = -1 il semaforo viene occupato.
se op = +1 il semaforo viene liberato. se op = +1 il semaforo viene liberato.
@(FN) @(FN)
*/ */
static void semcall(sid, op) static void semcall(sid, op)
int sid; /* identificatore semaforo */ int sid; /* identificatore semaforo */
int op; /* operazione da effettuare sul semaforo: libero/occupato */ int op; /* operazione da effettuare sul semaforo: libero/occupato */
{ {
struct sembuf sb; struct sembuf sb;
semres = 0 ; semres = 0 ;
@ -712,79 +712,79 @@ int op; /* operazione da effettuare sul semaforo: libero/occupato */
sb.sem_flg = 0; sb.sem_flg = 0;
if (semop(sid, &sb, 1) == -1) if (semop(sid, &sb, 1) == -1)
semres = -1; semres = -1;
} }
/* /*
@($) PS CUSTIO @($) PS CUSTIO
@(ID) @(ID)
Acquisisce il semaforo "sid". Acquisisce il semaforo "sid".
@(FD) @(FD)
@(ISV) @(ISV)
Solo versione XENIX. Solo versione XENIX.
@(FSV) @(FSV)
*/ */
void PS(sid) void PS(sid)
int sid; /* identificatore semaforo */ int sid; /* identificatore semaforo */
{ {
semcall(sid, -1); semcall(sid, -1);
} }
/* /*
@($) VS CUSTIO @($) VS CUSTIO
@(ID) @(ID)
Rilascia il semaforo "sid". Rilascia il semaforo "sid".
@(FD) @(FD)
@(ISV) @(ISV)
Solo versione XENIX. Solo versione XENIX.
@(FSV) @(FSV)
*/ */
void VS(sid) void VS(sid)
int sid; int sid;
{ {
semcall(sid, 1); semcall(sid, 1);
} }
#endif #endif
/* /*
@(#) excllock CUSTIO @(#) excllock CUSTIO
@(ID) @(ID)
Funzione per la gestione di un lock esclusivo su tutto il file. Funzione per la gestione di un lock esclusivo su tutto il file.
@(FD) @(FD)
@(ISV) @(ISV)
Nella versione XENIX: Nella versione XENIX:
path = contiene il file di lock. path = contiene il file di lock.
dir = contiene la directory. dir = contiene la directory.
fd = identificatore restituito dalla "open". fd = identificatore restituito dalla "open".
junk = variabile di lavoro. junk = variabile di lavoro.
sid = identificatore del semaforo su locksem. sid = identificatore del semaforo su locksem.
errno = numero errore. errno = numero errore.
sb = struttura che contiene informazioni sullo stato del file (vedi "stat"). sb = struttura che contiene informazioni sullo stato del file (vedi "stat").
@(FSV) @(FSV)
*/ */
int excllock(name,excl) int excllock(name,excl)
char *name; /* nome del file */ char *name; /* nome del file */
BOOLEAN excl; /* se true deve fare il lock ex. altrimenti no */ BOOLEAN excl; /* se true deve fare il lock ex. altrimenti no */
{ {
#ifndef DOS #ifndef DOS
char path[200], dir[200]; char path[200], dir[200];
int fd, junk, sid; int fd, junk, sid;
@ -850,33 +850,33 @@ BOOLEAN excl; /* se true deve fare il lock ex. altrimenti no */
if (semres == -1) return(-1); if (semres == -1) return(-1);
#endif #endif
return(0); return(0);
} }
/* /*
@(#) exclunlock CUSTIO @(#) exclunlock CUSTIO
@(ID) @(ID)
Gestisce un unlock esclusivo su tutto il file. Gestisce un unlock esclusivo su tutto il file.
@(FD) @(FD)
@(ISV) @(ISV)
Nella versione XENIX: Nella versione XENIX:
path = contiene il file di lock. path = contiene il file di lock.
fd = identificatore restituito dalla "open". fd = identificatore restituito dalla "open".
junk = variabile di lavoro. junk = variabile di lavoro.
sid = identificatore del semaforo su locksem. sid = identificatore del semaforo su locksem.
@(FSV) @(FSV)
*/ */
int exclunlock(name,excl) int exclunlock(name,excl)
char *name; /* nome file */ char *name; /* nome file */
BOOLEAN excl; /* se true esegue un unlock sul file */ BOOLEAN excl; /* se true esegue un unlock sul file */
{ {
#ifndef DOS #ifndef DOS
int fd, junk, sid; int fd, junk, sid;
char path[200]; char path[200];
@ -921,4 +921,4 @@ BOOLEAN excl; /* se true esegue un unlock sul file */
if (semres == -1) return(-1); if (semres == -1) return(-1);
#endif #endif
return(0); return(0);
} }