![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uucplock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / tip|
Return to uucplock.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / tip |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)uucplock.c 5.2 (Berkeley) 11/29/85";
9: #endif not lint
10:
11: /*
12: * defs that come from uucp.h
13: */
14: #define NAMESIZE 32
15: #define FAIL -1
16: #define SAME 0
17: #define SLCKTIME 28800 /* system/device timeout (LCK.. files) in seconds (8 hours) */
18: #define ASSERT(e, f, v) if (!(e)) {\
19: fprintf(stderr, "AERROR - (%s) ", "e");\
20: fprintf(stderr, f, v);\
21: finish(FAIL);\
22: }
23:
24: #define LOCKPRE "/usr/spool/uucp/LCK."
25:
26: /*
27: * This code is taken almost directly from uucp and follows the same
28: * conventions. This is important since uucp and tip should
29: * respect each others locks.
30: */
31:
32: /* ulockf 3.2 10/26/79 11:40:29 */
33: /* #include "uucp.h" */
34: #include <sys/types.h>
35: #include <sys/stat.h>
36: #include <stdio.h>
37:
38: /*******
39: * ulockf(file, atime)
40: * char *file;
41: * time_t atime;
42: *
43: * ulockf - this routine will create a lock file (file).
44: * If one already exists, the create time is checked for
45: * older than the age time (atime).
46: * If it is older, an attempt will be made to unlink it
47: * and create a new one.
48: *
49: * return codes: 0 | FAIL
50: */
51:
52: static
53: ulockf(file, atime)
54: char *file;
55: time_t atime;
56: {
57: struct stat stbuf;
58: time_t ptime;
59: int ret;
60: static int pid = -1;
61: static char tempfile[NAMESIZE];
62:
63: if (pid < 0) {
64: pid = getpid();
65: sprintf(tempfile, "/usr/spool/uucp/LTMP.%d", pid);
66: }
67: if (onelock(pid, tempfile, file) == -1) {
68: /* lock file exists */
69: /* get status to check age of the lock file */
70: ret = stat(file, &stbuf);
71: if (ret != -1) {
72: time(&ptime);
73: if ((ptime - stbuf.st_ctime) < atime) {
74: /* file not old enough to delete */
75: return (FAIL);
76: }
77: }
78: ret = unlink(file);
79: ret = onelock(pid, tempfile, file);
80: if (ret != 0)
81: return (FAIL);
82: }
83: stlock(file);
84: return (0);
85: }
86:
87: #define MAXLOCKS 10 /* maximum number of lock files */
88: char *Lockfile[MAXLOCKS];
89: int Nlocks = 0;
90:
91: /***
92: * stlock(name) put name in list of lock files
93: * char *name;
94: *
95: * return codes: none
96: */
97:
98: static
99: stlock(name)
100: char *name;
101: {
102: char *p;
103: extern char *calloc();
104: int i;
105:
106: for (i = 0; i < Nlocks; i++) {
107: if (Lockfile[i] == NULL)
108: break;
109: }
110: ASSERT(i < MAXLOCKS, "TOO MANY LOCKS %d", i);
111: if (i >= Nlocks)
112: i = Nlocks++;
113: p = calloc(strlen(name) + 1, sizeof (char));
114: ASSERT(p != NULL, "CAN NOT ALLOCATE FOR %s", name);
115: strcpy(p, name);
116: Lockfile[i] = p;
117: return;
118: }
119:
120: /***
121: * rmlock(name) remove all lock files in list
122: * char *name; or name
123: *
124: * return codes: none
125: */
126:
127: static
128: rmlock(name)
129: char *name;
130: {
131: int i;
132:
133: for (i = 0; i < Nlocks; i++) {
134: if (Lockfile[i] == NULL)
135: continue;
136: if (name == NULL || strcmp(name, Lockfile[i]) == SAME) {
137: unlink(Lockfile[i]);
138: free(Lockfile[i]);
139: Lockfile[i] = NULL;
140: }
141: }
142: }
143:
144: /*
145: * this stuff from pjw
146: * /usr/pjw/bin/recover - check pids to remove unnecessary locks
147: *
148: * isalock(name) returns 0 if the name is a lock
149: *
150: * onelock(pid,tempfile,name) makes lock a name
151: * on behalf of pid. Tempfile must be in the same
152: * file system as name.
153: *
154: * lock(pid,tempfile,names) either locks all the
155: * names or none of them
156: */
157: static
158: isalock(name)
159: char *name;
160: {
161: struct stat xstat;
162:
163: if (stat(name, &xstat) < 0)
164: return (0);
165: if (xstat.st_size != sizeof(int))
166: return (0);
167: return (1);
168: }
169:
170: static
171: onelock(pid, tempfile, name)
172: char *tempfile, *name;
173: {
174: int fd;
175:
176: fd = creat(tempfile, 0444);
177: if (fd < 0)
178: return (-1);
179: write(fd,(char *)&pid, sizeof(int));
180: close(fd);
181: if (link(tempfile, name) < 0) {
182: unlink(tempfile);
183: return (-1);
184: }
185: unlink(tempfile);
186: return (0);
187: }
188:
189: /***
190: * delock(s) remove a lock file
191: * char *s;
192: *
193: * return codes: 0 | FAIL
194: */
195:
196: delock(s)
197: char *s;
198: {
199: char ln[30];
200:
201: sprintf(ln, "%s.%s", LOCKPRE, s);
202: rmlock(ln);
203: }
204:
205: /***
206: * mlock(sys) create system lock
207: * char *sys;
208: *
209: * return codes: 0 | FAIL
210: */
211:
212: mlock(sys)
213: char *sys;
214: {
215: char lname[30];
216: sprintf(lname, "%s.%s", LOCKPRE, sys);
217: return (ulockf(lname, (time_t) SLCKTIME ) < 0 ? FAIL : 0);
218: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.