![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to anlwrk.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 / uucp|
Return to anlwrk.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)anlwrk.c 5.5 (Berkeley) 6/19/85";
3: #endif
4:
5: #include "uucp.h"
6: #include <sys/stat.h>
7: #include "uust.h"
8: #ifdef NDIR
9: #include "ndir.h"
10: #else
11: #include <sys/dir.h>
12: #endif
13: #include <ctype.h>
14:
15: #define TLIMIT (5*60L)
16: #define NITEMS(X) (sizeof (X) / sizeof ((X)[0]))
17:
18: int Nfiles = 0;
19: char Filent[LLEN][NAMESIZE];
20: long fseek(), ftell();
21: extern int TransferSucceeded;
22:
23: /*LINTLIBRARY*/
24:
25: /*
26: * create a vector of command arguments
27: *
28: * return codes:
29: * 0 - no more work in this file
30: * positive number - number of arguments
31: */
32:
33: /* LOCAL only */
34: int
35: anlwrk(file, wvec)
36: register char *file, **wvec;
37: {
38: static char str[MAXRQST], nstr[MAXRQST], lastfile[MAXFULLNAME] = "";
39: static FILE *fp = NULL;
40: static long nextread, nextwrite;
41:
42: /*
43: * If called with a null string, force a shutdown
44: * of the current work file.
45: */
46: if (file[0] == '\0') {
47: if (fp != NULL)
48: fclose (fp);
49: fp = NULL;
50: return 0;
51: }
52: if (fp == NULL) {
53: if (strncmp(file, lastfile, MAXFULLNAME) == 0) {
54: DEBUG(5,"Workfilename repeated: %s\n", file);
55: return 0;
56: }
57: strncpy(lastfile, file, MAXFULLNAME);
58: fp = fopen(subfile(file), "r+w");
59: if (fp == NULL) {
60: char *bnp, rqstr[MAXFULLNAME];
61: bnp = rindex(file, '/');
62: sprintf(rqstr, "%s/%s", CORRUPT, bnp ? bnp + 1 : file);
63: xmv(file, rqstr);
64: logent(subfile(file), "CMD FILE UNREADABLE");
65: unlink(subfile(file));
66: return 0;
67: }
68: Usrf = 0;
69: nstr[0] = '\0';
70: nextread = nextwrite = 0L;
71: }
72:
73: if (nstr[0] != '\0' && TransferSucceeded) {
74: fseek(fp, nextwrite, 0);
75: fputs(nstr, fp);
76: fseek(fp, nextread, 0);
77: }
78:
79: do {
80: nextwrite = ftell(fp);
81: if (fgets(str, MAXRQST, fp) == NULL) {
82: fclose(fp);
83: if (TransferSucceeded)
84: unlink(subfile(file));
85: USRF(USR_COMP);
86: US_RRS(file, Usrf);
87: Usrf = 0;
88: file[0] = '\0';
89: nstr[0] = '\0';
90: fp = NULL;
91: return 0;
92: }
93: } while (!isupper(str[0]));
94:
95: nextread = ftell(fp);
96: strncpy(nstr, str, MAXRQST);
97: nstr[0] = tolower(nstr[0]);
98: return getargs(str, wvec, 20);
99: }
100:
101:
102: /*
103: * build list of work files for given system
104: *
105: * return value - 1 if work was found, else 0
106: *
107: */
108:
109: /* LOCAL only */
110: int
111: bldflst (reqst, dir, pre)
112: char *reqst;
113: register char *dir, *pre;
114: {
115: static DIR *dirp = NULL;
116: register nfound;
117: char filename[NAMESIZE];
118: int plen = strlen (pre);
119: int flen;
120: extern char MaxGrade;
121:
122: if (dirp == NULL) {
123: if ((dirp = opendir(subdir(dir,pre[0]))) == NULL) {
124: DEBUG(1,"opendir(%s) FAILS\n",subdir(dir,pre[0]));
125: return 0;
126: }
127: }
128: else
129: rewinddir(dirp);
130: for (nfound = 0, Nfiles = 0; gnamef(dirp, filename);) {
131: /* Check for two systems with the same prefix.
132: * Magic number "5" is 1 for "grade" character plus
133: * 4 for sequence number. The point here is to not
134: * send work for a system which has as a prefix the
135: * name of the system called for.
136: * Special case: prefix "X." does not do this check
137: * so uuxqt can use bldflst.
138: */
139: flen = strlen(filename);
140: if (!prefix(pre, filename) || (plen != 2 && flen-plen != 5)) {
141: DEBUG(99,"bldflst rejects %s\n",filename);
142: continue;
143: }
144: if (filename[flen-5] > MaxGrade ) {
145: DEBUG(8,"bldflst rejects %s, grade too low\n",filename);
146: continue;
147: }
148: nfound++;
149: if (*reqst == 'c')
150: return 1;
151: entflst(filename);
152: }
153: return nfound? 1: 0;
154: }
155:
156: /*
157: * put new name if list is not full or new name is less than the MAX
158: * now in the list.
159: *
160: */
161:
162: /* LOCAL only */
163: int
164: entflst(file)
165: register char *file;
166: {
167: register int i;
168:
169: /* locate position for the new file and make room for it */
170: for (i = Nfiles; i > 0; i--) {
171: if (pcompar(file, Filent[i-1]) <= 0)
172: break;
173: if (i <LLEN)
174: strcpy(Filent[i], Filent[i-1]);
175: }
176:
177: /* add new file (if there is room), and increase Nfiles if need be */
178: if (i < LLEN) {
179: strcpy(Filent[i], file);
180: if (Nfiles < LLEN)
181: Nfiles++;
182: }
183: }
184:
185: /*
186: Compare priority of filenames p1 and p2. Return:
187: * < 0 if p1 "has lower priority than" p2.
188: * = 0 if p1 "has priority equal to" p2.
189: * > 0 if p1 "has greater priority than" p2.
190: * Priority:
191: * lower grade wins.
192: * lower sequence number wins (unless wrap-around is suspected).
193: *
194: */
195: /* LOCAL only */
196: int
197: pcompar(p1, p2)
198: register char *p1, *p2;
199: {
200: register int rc;
201:
202: /* assert: strlen(p1) and strlen(p2) are >= 5 */
203: p1 += strlen(p1)-5;
204: p2 += strlen(p2)-5;
205: /* check 'grade' */
206: if (rc = *p2++ - *p1++)
207: return rc;
208: /* check for sequence wrap-around */
209: if (rc = *p2++ - *p1++)
210: if (rc < -10 || rc > 10)
211: return -rc;
212: else
213: return rc;
214: /* check remaining digits */
215: return strcmp(p2, p1);
216: }
217:
218: /*
219: * get next work file
220: *
221: * return value:
222: *
223: * 0 - No file gotten
224: * 1 - File successfully gotten.
225: *
226: */
227:
228: /* LOCAL only */
229: gtwrkf(dir, file)
230: char *file, *dir;
231: {
232: register int i;
233:
234: if (Nfiles-- <= 0) {
235: Nfiles = 0;
236: return 0;
237: }
238: sprintf(file, "%s/%s", dir, Filent[0]);
239: for (i=0; i<Nfiles;i++)
240: strcpy(Filent[i], Filent[i+1]);
241: return 1;
242: }
243:
244: /*
245: * get work vector
246: *
247: * return codes:
248: * positive number - number of arguments
249: * 0 - no arguments - fail
250: */
251:
252: /* EXTERNALLY CALLED */
253: int
254: gtwvec(file, dir, wkpre, wrkvec)
255: char *dir, *wkpre, **wrkvec;
256: register char *file;
257: {
258: register int nargs, n;
259:
260: n = 0;
261: while ((nargs = anlwrk(file, wrkvec)) == 0) {
262: if (++n > 3 || !iswrk(file, "get", dir, wkpre))
263: return 0;
264: }
265: return nargs;
266: }
267:
268: /*
269: * iswrk - this routine will check the work list (list).
270: * If it is empty or the present work is exhausted, it
271: * will call bldflst to generate a new list.
272: * The "reqst" field will be the string "chk" or "get" to
273: * check for work, or get the next work file respectively.
274: *
275: * return codes:
276: * 0 - no more work (or some error)
277: * 1 - there is work
278: *
279: */
280:
281: /* EXTERNALLY CALLED */
282: int
283: iswrk(file, reqst, dir, pre)
284: register char *file, *reqst, *dir, *pre;
285: {
286: static char *lastpre = 0;
287: register ret;
288:
289: /* Starting new system; re-init */
290: if (lastpre == 0 || strcmp(lastpre,pre) != 0) {
291: anlwrk ("", (char **)0); /* Force close of work file */
292:
293: /* Save last worked-on prefix */
294: if (lastpre != 0)
295: free (lastpre);
296: lastpre = malloc((unsigned)(strlen(pre)+1));
297: strcpy (lastpre, pre);
298:
299: /* Set the external indexes properly
300: */
301: Nfiles = 0;
302: }
303:
304: /* If the list is empty or new files have entered
305: * the spool area, call "bldflst" to read
306: * some file names into it. Because names can
307: * be put in the list that later turn out to
308: * be unusable (from "gtwrkf"), this operation
309: * continues until either "bldflst" can't find
310: * any new files, or "gtwrkf" signals success.
311: */
312: for (;;) {
313: ret = 0;
314: if (Nfiles <= 0 || newspool((time_t)TLIMIT)) {
315: ret = bldflst (reqst, dir, pre);
316: DEBUG(99,"bldflst returns %d\n",ret);
317: }
318:
319: /* If they only wanted to check, return
320: * boolean list not empty. NB: the list
321: * will be forcibly emptied as soon as
322: * a new system name is mentioned.
323: */
324: if (*reqst == 'c')
325: return ret;
326:
327: if (Nfiles <= 0)
328: return 0;
329:
330: if (gtwrkf(dir, file))
331: return 1;
332: }
333: }
334:
335: /* Return non-zero if there is new work in the spool
336: * area since last check. Assumes that if the sequence
337: * file has been modified, there is new work. This is
338: * not absolutely correct, but should be close enough.
339: * Only checks every <limit> seconds at most. Called
340: * from "iswrk()" when a new work file is requested.
341: */
342: /* LOCAL only */
343: int
344: newspool(limit)
345: time_t limit;
346: {
347: static time_t lastcheck = 0, lastmod = 0;
348: time_t check;
349: struct stat mod;
350: register int ret = 0;
351:
352: /* (void) */ time (&check);
353: if (check - lastcheck > limit || lastcheck - check > limit) {
354: mod.st_mtime = 0;
355: /* (void) */ stat (SEQFILE, &mod);
356: if (mod.st_mtime != lastmod)
357: ret = 1;
358: lastmod = mod.st_mtime;
359: }
360: lastcheck = check;
361: return ret;
362: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.