![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ulockf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp|
Return to ulockf.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)ulockf.c 5.1 (Berkeley) 7/2/83";
3: #endif
4:
5: #include "uucp.h"
6: #include <sys/types.h>
7: #include <sys/stat.h>
8:
9:
10: extern time_t time();
11:
12: /* File mode for lock files */
13: #define LCKMODE 0444
14:
15: /*******
16: * ulockf(file, atime)
17: * char *file;
18: * time_t atime;
19: *
20: * ulockf - this routine will create a lock file (file).
21: * If one already exists, the create time is checked for
22: * older than the age time (atime).
23: * If it is older, an attempt will be made to unlink it
24: * and create a new one.
25: *
26: * return codes: 0 | FAIL
27: */
28:
29: ulockf(file, atime)
30: register char *file;
31: time_t atime;
32: {
33: struct stat stbuf;
34: time_t ptime;
35: register int ret;
36: static int pid = -1;
37: static char tempfile[NAMESIZE];
38:
39: if (pid < 0) {
40: pid = getpid();
41: sprintf(tempfile, "LTMP.%d", pid);
42: }
43: if (onelock(pid, tempfile, file) == -1) {
44: /* lock file exists */
45: /* get status to check age of the lock file */
46: ret = stat(file, &stbuf);
47: if (ret != -1) {
48: time(&ptime);
49: if ((ptime - stbuf.st_ctime) < atime) {
50: /* file not old enough to delete */
51: return(FAIL);
52: }
53: }
54: ret = unlink(file);
55: ret = onelock(pid, tempfile, file);
56: if (ret != 0)
57: return(FAIL);
58: }
59: stlock(file);
60: return(0);
61: }
62:
63:
64: #define MAXLOCKS 10 /* maximum number of lock files */
65: char *Lockfile[MAXLOCKS];
66: int Nlocks = 0;
67:
68: /***
69: * stlock(name) put name in list of lock files
70: * char *name;
71: *
72: * return codes: none
73: */
74:
75: stlock(name)
76: register char *name;
77: {
78: register char *p;
79: register int i;
80:
81: for (i = 0; i < Nlocks; i++) {
82: if (Lockfile[i] == NULL)
83: break;
84: }
85: ASSERT(i < MAXLOCKS, "TOO MANY LOCKS", "", i);
86: if (i >= Nlocks)
87: i = Nlocks++;
88: p = calloc((unsigned)(strlen(name)+1), sizeof (char));
89: ASSERT(p != NULL, "CAN NOT ALLOCATE FOR", name, 0);
90: strcpy(p, name);
91: Lockfile[i] = p;
92: return;
93: }
94:
95:
96: /***
97: * rmlock(name) remove all lock files in list
98: * char *name; or name
99: *
100: * return codes: none
101: */
102:
103: rmlock(name)
104: register char *name;
105: {
106: register int i;
107:
108: for (i = 0; i < Nlocks; i++) {
109: if (Lockfile[i] == NULL)
110: continue;
111: if (name == NULL
112: || strcmp(name, Lockfile[i]) == SAME) {
113: unlink(Lockfile[i]);
114: free(Lockfile[i]);
115: Lockfile[i] = NULL;
116: }
117: }
118: return;
119: }
120:
121:
122: /*
123: * this stuff from pjw
124: * /usr/pjw/bin/recover - Check pids to remove unnecessary locks.
125: * isalock(name) returns 0 if the name is a lock.
126: * unlock(name) unlocks name if it is a lock.
127: * onelock(pid,tempfile,name) makes lock a name
128: * on behalf of pid. Tempfile must be in the same
129: * file system as name.
130: * lock(pid,tempfile,names) either locks all the
131: * names or none of them.
132: */
133: isalock(name) char *name;
134: {
135: struct stat xstat;
136: if(stat(name,&xstat)<0) return(0);
137: if(xstat.st_size!=sizeof(int)) return(0);
138: return(1);
139: }
140: unlock(name) char *name;
141: {
142: if(isalock(name)) return(unlink(name));
143: else return(-1);
144: }
145: onelock(pid,tempfile,name) char *tempfile,*name;
146: { register int fd;
147: fd=creat(tempfile,LCKMODE);
148: if(fd<0) return(-1);
149: write(fd,(char *) &pid,sizeof(int));
150: close(fd);
151: if(link(tempfile,name)<0)
152: { unlink(tempfile);
153: return(-1);
154: }
155: unlink(tempfile);
156: return(0);
157: }
158: lock(pid,tempfile,names) char *tempfile;
159: register char **names;
160: { register int i,j;
161: for(i=0;names[i]!=0;i++)
162: { if(onelock(pid,tempfile,names[i])==0) continue;
163: for(j=0;j<i;j++) unlink(names[j]);
164: return(-1);
165: }
166: return(0);
167: }
168:
169: #define LOCKPRE "LCK."
170:
171: /***
172: * delock(s) remove a lock file
173: * char *s;
174: *
175: * return codes: 0 | FAIL
176: */
177:
178: delock(s)
179: char *s;
180: {
181: char ln[30];
182:
183: sprintf(ln, "%s.%s", LOCKPRE, s);
184: rmlock(ln);
185: }
186:
187:
188: /***
189: * mlock(sys) create system lock
190: * char *sys;
191: *
192: * return codes: 0 | FAIL
193: */
194:
195: mlock(sys)
196: char *sys;
197: {
198: char lname[30];
199: sprintf(lname, "%s.%s", LOCKPRE, sys);
200: return(ulockf(lname, (time_t) SLCKTIME ) < 0 ? FAIL : 0);
201: }
202:
203:
204: /***
205: * ultouch() update 'change' time for lock files
206: *
207: * -- mod by rti!trt --
208: * Only update ctime, not mtime or atime.
209: * The 'chmod' method permits cu(I)-like programs
210: * to determine how long uucp has been on the line.
211: * The old "change access, mod, and change time" method
212: * can be had by defining OLDTOUCH
213: *
214: * return code - none
215: */
216:
217: ultouch()
218: {
219: time_t time();
220: static time_t lasttouch = 0;
221: register int i;
222: struct ut {
223: time_t actime;
224: time_t modtime;
225: } ut;
226:
227: ut.actime = time(&ut.modtime);
228: /* Do not waste time touching locking files too often */
229: /* (But, defend against backward time changes) */
230: if (ut.actime >= lasttouch && ut.actime < lasttouch+60)
231: return;
232: lasttouch = ut.actime;
233: DEBUG(4, "ultouch\n", 0);
234:
235: for (i = 0; i < Nlocks; i++) {
236: if (Lockfile[i] == NULL)
237: continue;
238: #ifdef OLDTOUCH
239: utime(Lockfile[i], &ut);
240: #else
241: chmod(Lockfile[i], LCKMODE);
242: #endif
243: }
244: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.