![[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] / 43BSDTahoe / usr.bin / uucp|
Return to anlwrk.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)anlwrk.c 5.7 (Berkeley) 4/5/88";
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 (15*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: syslog(LOG_WARNING, "fopen(%s) failed: %m",
65: subfile(file));
66: unlink(subfile(file));
67: return 0;
68: }
69: Usrf = 0;
70: nstr[0] = '\0';
71: nextread = nextwrite = 0L;
72: }
73:
74: if (nstr[0] != '\0' && TransferSucceeded) {
75: fseek(fp, nextwrite, 0);
76: fputs(nstr, fp);
77: fseek(fp, nextread, 0);
78: }
79:
80: do {
81: nextwrite = ftell(fp);
82: if (fgets(str, MAXRQST, fp) == NULL) {
83: fclose(fp);
84: if (TransferSucceeded)
85: unlink(subfile(file));
86: USRF(USR_COMP);
87: US_RRS(file, Usrf);
88: Usrf = 0;
89: file[0] = '\0';
90: nstr[0] = '\0';
91: fp = NULL;
92: return 0;
93: }
94: } while (!isupper(str[0]));
95:
96: nextread = ftell(fp);
97: strncpy(nstr, str, MAXRQST);
98: nstr[0] = tolower(nstr[0]);
99: return getargs(str, wvec, 20);
100: }
101:
102:
103: /*
104: * build list of work files for given system
105: *
106: * return value - 1 if work was found, else 0
107: *
108: */
109:
110: /* LOCAL only */
111: int
112: bldflst (reqst, dir, pre)
113: char *reqst;
114: register char *dir, *pre;
115: {
116: static DIR *dirp = NULL;
117: register struct direct *dentp;
118: register int i;
119: int plen = strlen(pre);
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: } else
128: rewinddir(dirp);
129:
130: Nfiles = 0;
131: while ((dentp = readdir(dirp)) != NULL && Nfiles < LLEN) {
132: /* Check for two systems with the same prefix.
133: * Magic number "5" is 1 for "grade" character plus
134: * 4 for sequence number. The point here is to not
135: * send work for a system which has as a prefix the
136: * name of the system called for.
137: * Special case: prefix "X." does not do this check
138: * so uuxqt can use bldflst.
139: */
140: if (!prefix(pre, dentp->d_name) ||
141: (plen != 2 && (dentp->d_namlen-plen) != 5)) {
142: DEBUG(99,"bldflst rejects %s\n",dentp->d_name);
143: continue;
144: }
145: if (dentp->d_name[dentp->d_namlen-5] > MaxGrade) {
146: DEBUG(8, "bldflst rejects %s, grade too low\n",
147: dentp->d_name);
148: continue;
149: }
150: if (*reqst == 'c')
151: return 1;
152:
153: /* locate position for the new file and make room for it */
154: for (i = Nfiles; i > 0; i--) {
155: if (pcompar(dentp->d_name, Filent[i-1]) <= 0)
156: break;
157: if (i <LLEN)
158: strcpy(Filent[i], Filent[i-1]);
159: }
160:
161: /* add new file (if there is room), and increase Nfiles if need be */
162: if (i < LLEN) {
163: DEBUG(99,"bldflst accepts %s",dentp->d_name);
164: DEBUG(99," as Filent[%d]\n", i);
165: strcpy(Filent[i], dentp->d_name);
166: if (Nfiles < LLEN)
167: Nfiles++;
168: } else
169: DEBUG(99,"Filent full, %s rejected by bldflst\n", dentp->d_name);
170:
171:
172: }
173: if (Debug >99)
174: for(i=0;i<Nfiles;i++)
175: fprintf(stderr,"Filent[%d]=%s\n",i,Filent[i]);
176:
177: return Nfiles > 0;
178: }
179:
180: /*
181: Compare priority of filenames p1 and p2. Return:
182: * < 0 if p1 "has lower priority than" p2.
183: * = 0 if p1 "has priority equal to" p2.
184: * > 0 if p1 "has greater priority than" p2.
185: * Priority:
186: * lower grade wins.
187: * lower sequence number wins (unless wrap-around is suspected).
188: *
189: */
190: /* LOCAL only */
191: pcompar(p1, p2)
192: register char *p1, *p2;
193: {
194: register int rc;
195:
196: /* strlen(p1) and strlen(p2) are >= 5 */
197: p1 += strlen(p1)-5;
198: p2 += strlen(p2)-5;
199: /* check 'grade' */
200: if (rc = *p2++ - *p1++)
201: return rc;
202: /* check for sequence wrap-around */
203: if (rc = *p2++ - *p1++)
204: if (rc < -10 || rc > 10)
205: return -rc;
206: else
207: return rc;
208: /* check remaining digits */
209: return strcmp(p2, p1);
210: }
211:
212: /*
213: * get work vector
214: *
215: * return codes:
216: * positive number - number of arguments
217: * 0 - no arguments - fail
218: */
219:
220: /* EXTERNALLY CALLED */
221: int
222: gtwvec(file, dir, wkpre, wrkvec)
223: char *dir, *wkpre, **wrkvec;
224: register char *file;
225: {
226: register int nargs, n;
227:
228: n = 0;
229: while ((nargs = anlwrk(file, wrkvec)) == 0) {
230: if (++n > 3 || !iswrk(file, "get", dir, wkpre))
231: return 0;
232: }
233: return nargs;
234: }
235:
236: /*
237: * iswrk - this routine will check the work list (list).
238: * If it is empty or the present work is exhausted, it
239: * will call bldflst to generate a new list.
240: * The "reqst" field will be the string "chk" or "get" to
241: * check for work, or get the next work file respectively.
242: *
243: * return codes:
244: * 0 - no more work (or some error)
245: * 1 - there is work
246: *
247: */
248:
249: /* EXTERNALLY CALLED */
250: int
251: iswrk(file, reqst, dir, pre)
252: register char *file, *reqst, *dir, *pre;
253: {
254: static char *lastpre = 0;
255: register ret = 0;
256: int i;
257:
258: /* Starting new system; re-init */
259: if (lastpre == 0 || strcmp(lastpre, pre) != SAME) {
260: /* Force close of work file */
261: anlwrk("", (char **)0);
262:
263: /* Save last worked-on prefix */
264: if (lastpre != 0)
265: free(lastpre);
266: lastpre = malloc((unsigned)(strlen(pre)+1));
267: strcpy(lastpre, pre);
268:
269: /* Set the external indexes properly */
270: Nfiles = 0;
271: }
272:
273: /*
274: * If the list is empty or new files have entered
275: * the spool area, call "bldflst" to read
276: * some file names into it.
277: */
278: if (Nfiles <= 0 || newspool((time_t)TLIMIT)) {
279: ret = bldflst(reqst, dir, pre);
280: DEBUG(99, "bldflst returns %d\n", ret);
281: }
282:
283: /* If they only wanted to check, return
284: * boolean list not empty. NB: the list
285: * will be forcibly emptied as soon as
286: * a new system name is mentioned.
287: */
288: if (*reqst == 'c')
289: return ret;
290:
291: if (Nfiles-- <= 0) {
292: /* Didn't find any files in the spool area */
293: Nfiles = 0;
294: return 0;
295: }
296: /* Found some files, return the first one */
297: sprintf(file, "%s/%s", dir, Filent[0]);
298: for (i = 0; i < Nfiles; i++)
299: strcpy(Filent[i], Filent[i+1]);
300: return 1;
301: }
302:
303: /* Return non-zero if there is new work in the spool
304: * area since last check. Assumes that if the sequence
305: * file has been modified, there is new work. This is
306: * not absolutely correct, but should be close enough.
307: * Only checks every <limit> seconds at most. Called
308: * from "iswrk()" when a new work file is requested.
309: */
310: /* LOCAL only */
311: int
312: newspool(limit)
313: time_t limit;
314: {
315: static time_t lastcheck = 0, lastmod = 0;
316: time_t check;
317: struct stat mod;
318: register int ret = 0;
319:
320: /* (void) */ time (&check);
321: if (check - lastcheck > limit || lastcheck - check > limit) {
322: mod.st_mtime = 0;
323: /* (void) */ stat (SEQFILE, &mod);
324: if (mod.st_mtime != lastmod)
325: ret = 1;
326: lastmod = mod.st_mtime;
327: }
328: lastcheck = check;
329: return ret;
330: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.