![[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] / 42BSD / usr.bin / uucp|
Return to anlwrk.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)anlwrk.c 5.2 (Berkeley) 7/2/83";
3: #endif
4:
5: #include "uucp.h"
6: #include <sys/types.h>
7: #include <sys/stat.h>
8: #ifdef NDIR
9: #include "ndir.h"
10: #else
11: #include <sys/dir.h>
12: #endif
13:
14: /* Re-written to be reasonable
15: * Mon Nov 15 17:19:52 EST 1982
16: * Alan S. Watt (ittvax!swatt)
17: *
18: * Tom Truscott (rti!trt):
19: * Priority ordering cleaned up. New 'pcompar' subroutine.
20: * 'stat' removed (speeds things up).
21: * Possible infinite loop in gtwvec defended against.
22: * Feb 23, 1983
23: *
24: * Changes:
25: *
26: * 1) The check for work is much faster; the first filename
27: * that matches the prefix causes a "yes" return.
28: *
29: * 2) The filename is not "stat" ed , so
30: * there is no massive delay while the list of potential
31: * names is built.
32: *
33: * 3) Requesting work for a new system is now detected so
34: * internal variables are re-initialized properly. In
35: * particular, the stream pointer for the current work
36: * file is properly closed so work for a system which
37: * hangs up will not be sent to the next system called.
38: *
39: * Fri Dec 3 09:31:45 EST 1982
40: *
41: * 5) As new work files are requested, a check is made
42: * every TLIMIT seconds (5 minutes at present) to see
43: * if new files have entered the spool area. Since
44: * work file names are now cached up to LLEN, this can
45: * represent a very long transmission time before new
46: * work enters the list to be processed. If people want
47: * to use the "grade" character to specify a higher
48: * priority, the list must be re-built and re-sorted for
49: * higher priority stuff to have an immediate effect.
50: */
51:
52:
53: #define LLEN 20
54: #define MAXRQST 250
55: #define TLIMIT (5*60L)
56: #define NITEMS(X) (sizeof (X) / sizeof ((X)[0]))
57:
58: /* These are all used only locally
59: */
60: static int Nfiles = 0;
61: static char Filent[LLEN][NAMESIZE];
62:
63: /*******
64: * anlwrk(file, wvec) create a vector of command arguments
65: * char *file, **wvec;
66: *
67: * return codes:
68: * 0 - no more work in this file
69: * positive number - number of arguments
70: */
71:
72: /* LOCAL only */
73: int
74: anlwrk(file, wvec)
75: register char *file, **wvec;
76: {
77: static char str[MAXRQST];
78: static FILE *fp = NULL;
79:
80: /* If called with a null string, force a shutdown
81: * of the current work file.
82: * John Levine, ima.247, related change in cntl.c
83: */
84: if (file[0] == '\0') {
85: if (fp != NULL)
86: fclose (fp);
87: fp = NULL;
88: return(0);
89: }
90: if (fp == NULL) {
91: fp = fopen(subfile(file), "r");
92: if (fp == NULL) {
93: unlink(subfile(file)); /* Try to zap the thing. rti!trt */
94: return(0);
95: }
96: }
97:
98: /* This is what deletes the current work file when EOF
99: * is reached. As this is called from gtwvec, which is
100: * in turn called externally, it is not possible to save
101: * "C." files in case of error, except for line errors,
102: * which shuts down the whole system.
103: */
104: if (fgets(str, MAXRQST, fp) == NULL) {
105: fclose(fp);
106: unlink(subfile(file));
107: file[0] = '\0';
108: fp = NULL;
109: return(0);
110: }
111: return(getargs(str, wvec));
112: }
113:
114:
115: /***
116: * bldflst - build list of work files for given system
117: * Nfiles, Filent are global
118: *
119: * return value - 1 if work was found, else 0
120: *
121: * Jul 26 19:17 1982 (ittvax!swatt). fixed this obnoxious
122: * routine to NOT read all the way through the damned directory
123: * "stat"'ing every file in sight just to get 10 names!!!
124: *
125: * It still reads through the directory from the beginning until
126: * the list is filled, but this is only once every LLEN names.
127: */
128:
129: /* LOCAL only */
130: int
131: bldflst (reqst, dir, pre)
132: char *reqst;
133: register char *dir, *pre;
134: {
135: static DIR *dirp = NULL;
136: register nfound;
137: char filename[NAMESIZE]; /* @@@ NB: this needs new dir stuff */
138: int plen = strlen (pre);
139:
140: if (dirp == NULL) {
141: if ((dirp = opendir(subdir(dir,pre[0]), "r")) == NULL)
142: return(0);
143: }
144: else
145: rewinddir(dirp);
146: for (nfound = 0, Nfiles = 0; gnamef(dirp, filename);) {
147: /* Check for two systems with the same prefix.
148: * Magic number "5" is 1 for "grade" character plus
149: * 4 for sequence number. The point here is to not
150: * send work for a system which has as a prefix the
151: * name of the system called for.
152: * Special case: prefix "X." does not do this check
153: * so uuxqt can use bldflst.
154: */
155: if (!prefix(pre, filename)
156: || (plen != 2 && strlen(filename)-plen != 5))
157: continue;
158: nfound++;
159: if (*reqst == 'c')
160: return (1);
161: entflst(filename);
162: }
163: return (nfound? 1: 0);
164: }
165:
166: /***
167: * entflst - put new name if list is not full
168: * or new name is less than the MAX
169: * now in the list.
170: * Nfiles, Filent[] are modified.
171: * return value - none
172: *
173: */
174:
175: /* LOCAL only */
176: int
177: entflst(file)
178: char *file;
179: {
180: register int i;
181: register char *p;
182:
183: /* If there is room in the table, just add it. */
184: if (Nfiles < LLEN) {
185: strcpy(Filent[Nfiles++], file);
186: return;
187: }
188:
189: /* Find lowest priority file in table */
190: p = Filent[0];
191: for (i = 1; i < Nfiles; i++)
192: if (pcompar(Filent[i], p) < 0)
193: p = Filent[i];
194:
195: /*
196: * If new candidate is of higher priority
197: * that the lowest priority file in the table,
198: * replace the table entry.
199: */
200: if (pcompar(p, file) < 0)
201: strcpy(p, file);
202: }
203:
204: /*
205: Compare priority of filenames p1 and p2. Return:
206: * < 0 if p1 "has lower priority than" p2.
207: * = 0 if p1 "has priority equal to" p2.
208: * > 0 if p1 "has greater priority than" p2.
209: * Priority:
210: * lower grade wins.
211: * lower sequence number wins (unless wrap-around is suspected).
212: *
213: */
214: /* LOCAL only */
215: int
216: pcompar(p1, p2)
217: register char *p1, *p2;
218: {
219: register int rc;
220:
221: /* assert: strlen(p1) and strlen(p2) are >= 5 */
222: p1 += strlen(p1)-5;
223: p2 += strlen(p2)-5;
224: /* check 'grade' */
225: if (rc = *p2++ - *p1++)
226: return(rc);
227: /* check for sequence wrap-around */
228: if (rc = *p2++ - *p1++)
229: if (rc < -10 || rc > 10)
230: return(-rc);
231: else
232: return(rc);
233: /* check remaining digits */
234: return(strcmp(p2, p1));
235: }
236:
237: /***
238: * gtwrkf - get next work file
239: * Nfiles, Filent[] are modified.
240: *
241: * return value:
242: *
243: * 0 - No file gotten
244: * 1 - File successfully gotten.
245: *
246: */
247:
248: /* LOCAL only */
249: gtwrkf(dir, file)
250: char *file, *dir;
251: {
252: register char *p;
253: register int i;
254:
255: if (Nfiles == 0)
256: return(0);
257: /* Find highest priority file in table */
258: p = Filent[0];
259: for (i = 1; i < Nfiles; i++)
260: if (pcompar(Filent[i], p) > 0)
261: p = Filent[i];
262: sprintf(file, "%s/%s", dir, p);
263: strcpy(p, Filent[--Nfiles]);
264: return(1);
265: }
266:
267: /***
268: * gtwvec(file, dir, wkpre, wrkvec) get work vector
269: * char *file, *dir, *wkpre, **wrkvec;
270: *
271: * return codes:
272: * positive number - number of arguments
273: * 0 - no arguments - fail
274: */
275:
276: /* EXTERNALLY CALLED */
277: int
278: gtwvec(file, dir, wkpre, wrkvec)
279: char *dir, *wkpre, **wrkvec;
280: register char *file;
281: {
282: register int nargs, n;
283:
284: n = 0; /* Break possible infinite loop. rti!trt */
285: while ((nargs = anlwrk(file, wrkvec)) == 0) {
286: if (++n > 3 || !iswrk(file, "get", dir, wkpre))
287: return(0);
288: }
289: return(nargs);
290: }
291:
292: /***
293: * iswrk(file, reqst, dir, pre)
294: * char *file, *reqst, *dir, *pre;
295: *
296: * iswrk - this routine will check the work list (list).
297: * If it is empty or the present work is exhausted, it
298: * will call bldflst to generate a new list.
299: * The "reqst" field will be the string "chk" or "get" to
300: * check for work, or get the next work file respectively.
301: *
302: * return codes:
303: * 0 - no more work (or some error)
304: * 1 - there is work
305: *
306: */
307:
308: /* EXTERNALLY CALLED */
309: int
310: iswrk(file, reqst, dir, pre)
311: register char *file, *reqst, *dir, *pre;
312: {
313: static char *lastpre = 0;
314: register ret;
315:
316: /* Starting new system; re-init */
317: if (lastpre == 0 || strcmp(lastpre,pre) != 0) {
318: anlwrk ("", (char **)0); /* Force close of work file */
319:
320: /* Save last worked-on prefix */
321: if (lastpre != 0)
322: free (lastpre);
323: lastpre = malloc((unsigned)(strlen(pre)+1));
324: strcpy (lastpre, pre);
325:
326: /* Set the external indexes properly
327: */
328: Nfiles = 0;
329: }
330:
331: /* If the list is empty or new files have entered
332: * the spool area, call "bldflst" to read
333: * some file names into it. Because names can
334: * be put in the list that later turn out to
335: * be unusable (from "gtwrkf"), this operation
336: * continues until either "bldflst" can't find
337: * any new files, or "gtwrkf" signals success.
338: */
339: for (;;) {
340: ret = 0;
341: if (Nfiles == 0 || newspool((time_t)TLIMIT))
342: ret = bldflst (reqst, dir, pre);
343:
344: /* If they only wanted to check, return
345: * boolean list not empty. NB: the list
346: * will be forcibly emptied as soon as
347: * a new system name is mentioned.
348: */
349: if (*reqst == 'c')
350: return (ret);
351:
352: if (Nfiles == 0)
353: return(0);
354:
355: if (gtwrkf(dir, file))
356: return (1);
357: }
358: }
359:
360: /* Return non-zero if there is new work in the spool
361: * area since last check. Assumes that if the sequence
362: * file has been modified, there is new work. This is
363: * not absolutely correct, but should be close enough.
364: * Only checks every <limit> seconds at most. Called
365: * from "iswrk()" when a new work file is requested.
366: */
367: /* LOCAL only */
368: int
369: newspool(limit)
370: time_t limit;
371: {
372: static time_t lastcheck = 0, lastmod = 0;
373: time_t check;
374: struct stat mod;
375: register int ret = 0;
376:
377: /* (void) */ time (&check);
378: if (check - lastcheck > limit || lastcheck - check > limit) {
379: mod.st_mtime = 0;
380: /* (void) */ stat (SEQFILE, &mod);
381: if (mod.st_mtime != lastmod)
382: ret = 1;
383: lastmod = mod.st_mtime;
384: }
385: lastcheck = check;
386: return (ret);
387: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.