![[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 [Research Unix] / researchv10no / cmd / uucp|
Return to ulockf.c CVS log | Up to [Research Unix] / researchv10no / cmd / uucp |
1.1 root 1: /* %W%
2: */
3: #include "uucp.h"
4: VERSION(%W%);
5:
6: #ifdef V7
7: #define O_RDONLY 0
8: #endif
9:
10: static void stlock();
11: static int onelock();
12:
13: #ifdef ATTSVKILL
14: /*
15: * create a lock file (file).
16: * If one already exists, send a signal 0 to the process--if
17: * it fails, then unlink it and make a new one.
18: *
19: * input:
20: * file - name of the lock file
21: * atime - is unused, but we keep it for lint compatibility with non-ATTSVKILL
22: *
23: * return:
24: * 0 -> success
25: * FAIL -> failure
26: */
27: ulockf(file, atime)
28: register char *file;
29: time_t atime;
30: {
31: #ifdef ASCIILOCKS
32: static char pid[SIZEOFPID+2] = { '\0' }; /* +2 for '\n' and NULL */
33: #else
34: static int pid = -1;
35: #endif
36:
37: static char tempfile[MAXNAMESIZE];
38:
39: #ifdef V8
40: char *cp;
41: #endif
42:
43: #ifdef ASCIILOCKS
44: if (pid[0] == '\0') {
45: (void) sprintf(pid, "%*d\n", SIZEOFPID, getpid());
46: #else
47: if (pid < 0) {
48: pid = getpid();
49: #endif
50: (void) sprintf(tempfile, "%s/LTMP.%d", X_LOCKDIR, getpid());
51: }
52:
53: #ifdef V8 /* this wouldn't be a problem if we used lock directories */
54: /* some day the truncation of system names will bite us */
55: cp = strrchr(file, '/');
56: if (cp++ != CNULL)
57: if (strlen(cp) > V8DIRSIZ)
58: *(cp+V8DIRSIZ) = NULLCHAR;
59: #endif V8
60: if (onelock(pid, tempfile, file) == -1) {
61: (void) unlink(tempfile);
62: if (checkLock(file))
63: return(FAIL);
64: else {
65: if (onelock(pid, tempfile, file)) {
66: (void) unlink(tempfile);
67: DEBUG(4,"ulockf failed in onelock()\n","");
68: return(FAIL);
69: }
70: }
71: }
72:
73: stlock(file);
74: return(0);
75: }
76:
77: /*
78: * check to see if the lock file exists and is still active
79: * - use kill(pid,0) - (this only works on ATTSV and some hacked
80: * BSD systems at this time)
81: * return:
82: * 0 -> success (lock file removed - no longer active
83: * FAIL -> lock file still active
84: */
85: checkLock(file)
86: register char *file;
87: {
88: register int ret;
89: int lpid = -1;
90: #ifdef ASCIILOCKS
91: char alpid[SIZEOFPID+2]; /* +2 for '\n' and NULL */
92: #endif
93: int fd;
94: extern int errno;
95:
96: fd = open(file, O_RDONLY);
97: DEBUG(4, "ulockf file %s\n", file);
98: if (fd == -1) {
99: if (errno == ENOENT) /* file does not exist -- OK */
100: return(0);
101: DEBUG(4,"Lock File--can't read (errno %d) --remove it!\n", errno);
102: goto unlk;
103: }
104: #ifdef ASCIILOCKS
105: ret = read(fd, (char *) alpid, SIZEOFPID+1); /* +1 for '\n' */
106: (void) close(fd);
107: if (ret != (SIZEOFPID+1)) {
108: #else
109: ret = read(fd, (char *) &lpid, sizeof(int));
110: (void) close(fd);
111: if (ret != sizeof(int)) {
112: #endif
113:
114: DEBUG(4, "Lock File--bad format--remove it!\n", "");
115: goto unlk;
116: }
117: #ifdef ASCIILOCKS
118: lpid = atoi(alpid);
119: #endif
120: if ((ret=kill(lpid, 0)) == 0 || errno == EPERM) {
121: DEBUG(4, "Lock File--process still active--not removed\n","");
122: return(FAIL);
123: }
124: else { /* process no longer active */
125: DEBUG(4, "kill pid (%d), ", lpid);
126: DEBUG(4, "returned %d", ret);
127: DEBUG(4, "--ok to remove lock file (%s)\n", file);
128: }
129: unlk:
130:
131: if (unlink(file) != 0) {
132: DEBUG(4,"ulockf failed in unlink()\n","");
133: return(FAIL);
134: }
135: return(0);
136: }
137: #else
138:
139: /*
140: * check to see if the lock file exists and is still active
141: * - consider the lock expired after SLCKTIME seconds.
142: * return:
143: * 0 -> success (lock file removed - no longer active
144: * FAIL -> lock file still active
145: */
146: checkLock(file)
147: register char *file;
148: {
149: register int ret;
150: int lpid = -1;
151: int fd;
152: extern int errno;
153: struct stat stbuf;
154: time_t ptime, time();
155:
156: fd = open(file, 0);
157: DEBUG(4, "ulockf file %s\n", file);
158: if (fd == -1) {
159: if (errno == ENOENT) /* file does not exist -- OK */
160: return(0);
161: DEBUG(4,"Lock File--can't read (errno %d) --remove it!\n", errno);
162: goto unlk;
163: }
164: ret = stat(file, &stbuf);
165: if (ret != -1) {
166: (void) time(&ptime);
167: if ((ptime - stbuf.st_ctime) < SLCKTIME) {
168:
169: /*
170: * file not old enough to delete
171: */
172: return(FAIL);
173: }
174: }
175: unlk:
176: DEBUG(4, "--ok to remove lock file (%s)\n", file);
177:
178: if (unlink(file) != 0) {
179: DEBUG(4,"ulockf failed in unlink()\n","");
180: return(FAIL);
181: }
182: return(0);
183: }
184:
185:
186: /*
187: * create a lock file (file).
188: * If one already exists, the create time is checked for
189: * older than the age time (atime).
190: * If it is older, an attempt will be made to unlink it
191: * and create a new one.
192: * return:
193: * 0 -> success
194: * FAIL -> failure
195: */
196: ulockf(file, atime)
197: register char *file;
198: time_t atime;
199: {
200: register int ret;
201: struct stat stbuf;
202: #ifdef ASCIILOCKS
203: static char pid[SIZEOFPID+2] = { '\0' }; /* +2 for '\n' and null */
204: #else
205: static int pid = -1;
206: #endif
207: static char tempfile[MAXNAMESIZE];
208: time_t ptime, time();
209: #ifdef V8
210: char *cp;
211: #endif
212:
213:
214: #ifdef ASCIILOCKS
215: if (pid[0] == '\0') {
216: (void) sprintf(pid, "%*d\n", SIZEOFPID, getpid());
217: #else
218: if (pid < 0) {
219: pid = getpid();
220: #endif
221: (void) sprintf(tempfile, "%s/LTMP.%d", X_LOCKDIR, getpid());
222: }
223: #ifdef V8 /* this wouldn't be a problem if we used lock directories */
224: /* some day the truncation of system names will bite us */
225: cp = strrchr(file, '/');
226: if (cp++ != CNULL)
227: if (strlen(cp) > V8DIRSIZ)
228: *(cp+V8DIRSIZ) = NULLCHAR;
229: #endif V8
230: if (onelock(pid, tempfile, file) == -1) {
231:
232: /*
233: * lock file exists
234: * get status to check age of the lock file
235: */
236: (void) unlink(tempfile);
237: ret = stat(file, &stbuf);
238: if (ret != -1) {
239: (void) time(&ptime);
240: if ((ptime - stbuf.st_ctime) < atime) {
241:
242: /*
243: * file not old enough to delete
244: */
245: return(FAIL);
246: }
247: }
248: ret = unlink(file);
249: ret = onelock(pid, tempfile, file);
250: if (ret != 0)
251: return(FAIL);
252: }
253: stlock(file);
254: return(0);
255: }
256: #endif
257:
258: #define MAXLOCKS 10 /* maximum number of lock files */
259: char *Lockfile[MAXLOCKS];
260: int Nlocks = 0;
261:
262: /*
263: * put name in list of lock files
264: * return:
265: * none
266: */
267: static
268: void
269: stlock(name)
270: char *name;
271: {
272: register int i;
273: char *p;
274:
275: for (i = 0; i < Nlocks; i++) {
276: if (Lockfile[i] == NULL)
277: break;
278: }
279: ASSERT(i < MAXLOCKS, "TOO MANY LOCKS", "", i);
280: if (i >= Nlocks)
281: i = Nlocks++;
282: p = calloc((unsigned) strlen(name) + 1, sizeof (char));
283: ASSERT(p != NULL, "CAN NOT ALLOCATE FOR", name, 0);
284: (void) strcpy(p, name);
285: Lockfile[i] = p;
286: return;
287: }
288:
289: /*
290: * remove all lock files in list
291: * return:
292: * none
293: */
294: void
295: rmlock(name)
296: register char *name;
297: {
298: register int i;
299: #ifdef V8
300: char *cp;
301:
302: if (name != CNULL) {
303: cp = strrchr(name, '/');
304: if (cp++ != CNULL)
305: if (strlen(cp) > V8DIRSIZ)
306: *(cp+V8DIRSIZ) = NULLCHAR;
307: }
308: #endif V8
309:
310:
311: for (i = 0; i < Nlocks; i++) {
312: if (Lockfile[i] == NULL)
313: continue;
314: if (name == NULL || EQUALS(name, Lockfile[i])) {
315: (void) unlink(Lockfile[i]);
316: (void) free(Lockfile[i]);
317: Lockfile[i] = NULL;
318: }
319: }
320: return;
321: }
322:
323:
324:
325: /*
326: * remove a lock file
327: * return:
328: * 0 -> success
329: * FAIL -> failure
330: */
331: delock(s)
332: char *s;
333: {
334: char ln[MAXNAMESIZE];
335:
336: (void) sprintf(ln, "%s.%s", LOCKPRE, s);
337: BASENAME(ln, '/')[MAXBASENAME] = '\0';
338: rmlock(ln);
339: }
340:
341:
342: /*
343: * create system lock
344: * return:
345: * 0 -> success
346: * FAIL -> failure
347: */
348: mlock(sys)
349: char *sys;
350: {
351: char lname[MAXNAMESIZE];
352:
353: (void) sprintf(lname, "%s.%s", LOCKPRE, sys);
354: BASENAME(lname, '/')[MAXBASENAME] = '\0';
355: return(ulockf(lname, SLCKTIME) < 0 ? FAIL : 0);
356: }
357:
358:
359: /*
360: * update access and modify times for lock files
361: * return:
362: * none
363: */
364: void
365: ultouch()
366: {
367: register int i;
368: time_t time();
369:
370: struct ut {
371: time_t actime;
372: time_t modtime;
373: } ut;
374:
375: ut.actime = time(&ut.modtime);
376: for (i = 0; i < Nlocks; i++) {
377: if (Lockfile[i] == NULL)
378: continue;
379: utime(Lockfile[i], &ut);
380: }
381: return;
382: }
383:
384: /*
385: * makes a lock on behalf of pid.
386: * input:
387: * pid - process id
388: * tempfile - name of a temporary in the same file system
389: * name - lock file name (full path name)
390: * return:
391: * -1 - failed
392: * 0 - lock made successfully
393: */
394: static
395: onelock(pid,tempfile,name)
396: #ifdef ASCIILOCKS
397: char *pid;
398: #else
399: int pid;
400: #endif
401: char *tempfile, *name;
402: {
403: register int fd;
404: char cb[100];
405:
406: fd=creat(tempfile, 0444);
407: if(fd < 0){
408: (void) sprintf(cb, "%s %s %d",tempfile, name, errno);
409: logent("ULOCKC", cb);
410: if((errno == EMFILE) || (errno == ENFILE))
411: (void) unlink(tempfile);
412: return(-1);
413: }
414: #ifdef ASCIILOCKS
415: (void) write(fd, pid, SIZEOFPID+1); /* +1 for '\n' */
416: #else
417: (void) write(fd,(char *) &pid,sizeof(int));
418: #endif
419: (void) chmod(tempfile,0444); /* silly */
420: (void) chown(tempfile, UUCPUID, UUCPGID);
421: (void) close(fd);
422: if(link(tempfile,name)<0){
423: DEBUG(4, "%s: ", sys_errlist[errno]);
424: DEBUG(4, "link(%s, ", tempfile);
425: DEBUG(4, "%s)\n", name);
426: if(unlink(tempfile)< 0){
427: (void) sprintf(cb, "ULK err %s %d", tempfile, errno);
428: logent("ULOCKLNK", cb);
429: }
430: return(-1);
431: }
432: if(unlink(tempfile)<0){
433: (void) sprintf(cb, "%s %d",tempfile,errno);
434: logent("ULOCKF", cb);
435: }
436: return(0);
437: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.