![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to newnews.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / nntp / server|
Return to newnews.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / nntp / server |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)newnews.c 1.5 (Berkeley) 3/20/86";
3: #endif
4:
5: #include "common.h"
6:
7: long gmt_to_local();
8:
9: /*
10: * NEWNEWS newsgroups date time ["GMT"] [<distributions>]
11: *
12: * Return the message-id's of any news articles past
13: * a certain date and time, within the specified distributions.
14: *
15: */
16:
17: newnews(argc, argv)
18: int argc;
19: char *argv[];
20: {
21: char *cp, *ngp;
22: char *key;
23: char datebuf[32];
24: char line[MAX_STRLEN];
25: char **distlist, **nglist, **histlist;
26: int distcount, ngcount, histcount;
27: int all;
28: FILE *fp;
29: long date;
30: long dtol();
31: char *ltod();
32:
33: if (argc < 4) {
34: printf("%d NEWNEWS requires at least three arguments.\r\n",
35: ERR_CMDSYN);
36: (void) fflush(stdout);
37: return;
38: }
39:
40: all = streql(argv[1], "*");
41: if (!all) {
42: ngcount = get_nglist(&nglist, argv[1]);
43: if (ngcount == 0) {
44: printf("%d Bogus newsgroup specifier: %s\r\n",
45: ERR_CMDSYN);
46: (void) fflush(stdout);
47: return;
48: }
49: }
50:
51: /* YYMMDD HHMMSS */
52: if (strlen(argv[2]) != 6 || strlen(argv[3]) != 6) {
53: printf("%d Date/time must be in form YYMMDD HHMMSS.\r\n",
54: ERR_CMDSYN);
55: (void) fflush(stdout);
56: return;
57: }
58:
59: (void) strcpy(datebuf, argv[2]);
60: (void) strcat(datebuf, argv[3]);
61:
62: argc -= 4;
63: argv += 4;
64:
65: /*
66: * Flame on. The history file is not stored in GMT, but
67: * in local time. So we have to convert GMT to local time
68: * if we're given GMT, otherwise we need only chop off the
69: * the seconds. Such braindamage.
70: */
71:
72: key = datebuf; /* Unless they specify GMT */
73:
74: if (argc > 0) {
75: if (streql(*argv, "GMT")) { /* Which we handle here */
76: date = dtol(datebuf);
77: if (date < 0) {
78: printf("%d Invalid date specification.\r\n",
79: ERR_CMDSYN);
80: (void) fflush(stdout);
81: return;
82: }
83: date = gmt_to_local(date);
84: key = ltod(date);
85: ++argv;
86: --argc;
87: }
88: }
89:
90: /* So, key now points to the local time, but we need to zap secs */
91:
92: key[10] = '\0';
93:
94: distcount = 0;
95: if (argc > 0) {
96: distcount = get_distlist(&distlist, *argv);
97: if (distcount < 0) {
98: printf("%d Bad distribution list: %s\r\n", ERR_CMDSYN,
99: *argv);
100: (void) fflush(stdout);
101: return;
102: }
103: }
104:
105: fp = fopen(HISTORY_FILE, "r");
106: if (fp == NULL) {
107: syslog(LOG_ERR, "newnews: fopen %s: %m", HISTORY_FILE);
108: printf("%d Cannot open history file.\r\n", ERR_FAULT);
109: (void) fflush(stdout);
110: return;
111: }
112:
113: printf("%d New news by message id follows.\r\n", OK_NEWNEWS);
114:
115: if (seekuntil(fp, key, line, sizeof (line)) < 0) {
116: printf(".\r\n");
117: (void) fflush(stdout);
118: (void) fclose(fp);
119: return;
120: }
121:
122: /*
123: * History file looks like:
124: *
125: * <[email protected]> 01/22/86 09:19 net.micro.att/899 ucb.general/2545
126: * ^--tab ^--tab ^--space ^sp\0
127: * Sometimes the newsgroups are missing; we try to be robust and
128: * ignore such bogosity. We tackle this by our usual parse routine,
129: * and break the list of articles in the history file into an argv
130: * array with one newsgroup per entry.
131: */
132:
133: do {
134: if ((cp = index(line, '\t')) == NULL)
135: continue;
136:
137: if ((ngp = index(cp+1, '\t')) == NULL) /* 2nd tab */
138: continue;
139: ++ngp; /* Points at newsgroup list */
140: if (*ngp == '\n')
141: continue;
142: histcount = get_histlist(&histlist, ngp);
143: if (histcount == 0)
144: continue;
145:
146: /*
147: * For each newsgroup on this line in the history
148: * file, check it against the newsgroup names we're given.
149: * If it matches, then see if we're hacking distributions.
150: * If so, open the file and match the distribution line.
151: */
152:
153: if (!all)
154: if (!ngmatch(nglist, ngcount, histlist, histcount))
155: continue;
156:
157: if (distcount)
158: if (!distmatch(distlist, distcount, histlist, histcount))
159: continue;
160:
161: *cp = '\0';
162: printf("%s\r\n", line);
163: } while (fgets(line, sizeof(line), fp) != NULL);
164:
165: printf(".\r\n");
166: (void) fflush(stdout);
167: (void) fclose(fp);
168: }
169:
170:
171: /*
172: * seekuntil -- seek through the history file looking for
173: * a line with date "key". Get that line, and return.
174: *
175: * Parameters: "fp" is the active file.
176: * "key" is the date, in form YYMMDDHHMM (no SS)
177: * "line" is storage for the first line we find.
178: *
179: * Returns: -1 on error, 0 otherwise.
180: *
181: * Side effects: Seeks in history file, modifies line.
182: */
183:
184: seekuntil(fp, key, line, linesize)
185: FILE *fp;
186: char *key;
187: char *line;
188: int linesize;
189: {
190: char datetime[32];
191: int c;
192: long top, bot, mid;
193:
194: bot = 0;
195: (void) fseek(fp, 0L, 2);
196: top = ftell(fp);
197: for(;;) {
198: mid = (top+bot)/2;
199: (void) fseek(fp, mid, 0);
200: do {
201: c = getc(fp);
202: mid++;
203: } while (c != EOF && c!='\n');
204: if (!getword(fp, datetime, line, linesize)) {
205: return (-1);
206: }
207: switch (compare(key, datetime)) {
208: case -2:
209: case -1:
210: case 0:
211: if (top <= mid)
212: break;
213: top = mid;
214: continue;
215: case 1:
216: case 2:
217: bot = mid;
218: continue;
219: }
220: break;
221: }
222: (void) fseek(fp, bot, 0);
223: while(ftell(fp) < top) {
224: if (!getword(fp, datetime, line, linesize)) {
225: return (-1);
226: }
227: switch(compare(key, datetime)) {
228: case -2:
229: case -1:
230: case 0:
231: break;
232: case 1:
233: case 2:
234: continue;
235: }
236: break;
237: }
238:
239: return (0);
240: }
241:
242: compare(s, t)
243: register char *s, *t;
244: {
245: for (; *s == *t; s++, t++)
246: if (*s == 0)
247: return(0);
248: return (*s == 0 ? -1:
249: *t == 0 ? 1:
250: *s < *t ? -2:
251: 2);
252: }
253:
254: getword(fp, w, line, linesize)
255: FILE *fp;
256: char *w;
257: char *line;
258: int linesize;
259: {
260: register char *cp;
261:
262: if (fgets(line, linesize, fp) == NULL)
263: return (0);
264: if (cp = index(line, '\t')) {
265: /*
266: * The following gross hack is present because the history file date
267: * format is braindamaged. They like "mm/dd/yy hh:mm", which is useless
268: * for relative comparisons of dates using something like atoi() or
269: * strcmp. So, this changes their format into yymmddhhmm. Sigh.
270: *
271: * 12345678901234 ("x" for cp[x])
272: * mm/dd/yy hh:mm (their lousy representation)
273: * yymmddhhmm (our good one)
274: * 0123456789 ("x" for w[x])
275: */
276: *cp = '\0';
277: (void) strncpy(w, cp+1, 15);
278: w[0] = cp[7]; /* Years */
279: w[1] = cp[8];
280: w[2] = cp[1]; /* Months */
281: w[3] = cp[2];
282: w[4] = cp[4]; /* Days */
283: w[5] = cp[5];
284: w[6] = cp[10]; /* Hours */
285: w[7] = cp[11];
286: w[8] = cp[13]; /* Minutes */
287: w[9] = cp[14];
288: w[10] = '\0';
289: } else
290: w[0] = '\0';
291: return (1);
292: }
293:
294: /*
295: * ngmatch -- match a list of newsgroups, with possible wildcard
296: * expansion (i.e., *) with a list of newsgroups.
297: * Both the newsgroups we're to match against (regexps) and
298: * the list of newsgroups for this line in the history file are
299: * in argc/argv format.
300: *
301: * Parameters: "nglist" is the list of group specifiers to match
302: * against.
303: * "ngcount" is the number of groups in nglist.
304: * "matchlist" is the list of newsgroups to match against.
305: * "matchcount" is number of groups in matchlist.
306: *
307: * Returns: 1 if the named newsgroup is in the list.
308: * 0 otherwise.
309: *
310: * Side effects: Terminates \n on end of grlist.
311: *
312: * Note: This ain't the same routine as "ngmatch"
313: * in the normal news software, although it
314: * probably should be.
315: */
316:
317: ngmatch(nglist, ngcount, matchlist, matchcount)
318: char **nglist;
319: int ngcount;
320: char **matchlist;
321: int matchcount;
322: {
323: int i, j;
324: int match;
325: register char *cp;
326:
327: match = 0;
328:
329: for (i = 0; i < matchcount; ++i) {
330: if (cp = index(matchlist[i], '/'))
331: *cp = '\0';
332: for (j = 0; j < ngcount; ++j) {
333: if (nglist[j][0] == '!') { /* Handle negation */
334: if (restreql(nglist[j]+1, matchlist[i]))
335: return (0); /* Hit a matching '!' */
336: } else {
337: if (restreql(nglist[j], matchlist[i]))
338: match = 1;
339: }
340: }
341: }
342:
343: return (match);
344: }
345:
346:
347: /*
348: * restreql -- regular expression string equivalnce routine,
349: * but not really full fledged. Thanks and a tip of the hat to
350: * Nick Lai, <[email protected]> for this time saving device.
351: *
352: * Parameters: "w" is an asterisk-broadened regexp,
353: * "s" is a non-regexp string.
354: * Returns: 1 if match, 0 otherwise.
355: *
356: * Side effects: None.
357: */
358:
359: restreql(w, s)
360: register char *w;
361: register char *s;
362: {
363:
364: while (*s && *w) {
365: switch (*w) {
366: case '*':
367: for (w++; *s; s++)
368: if (restreql(w, s))
369: return 1;
370: break;
371: default:
372: if (*w != *s)
373: return 0;
374: w++, s++;
375: break;
376: }
377: }
378: if (*s)
379: return 0;
380: while (*w)
381: if (*w++ != '*')
382: return 0;
383:
384: return 1;
385: }
386:
387:
388: /*
389: * distmatch -- see if a file matches a set of distributions.
390: * We have to do this by (yech!) opening the file, finding
391: * the Distribution: line, if it has one, and seeing if the
392: * things match.
393: *
394: * Parameters: "distlist" is the distribution list
395: * we want.
396: * "distcount" is the count of distributions in it.
397: * "grouplist" is the list of groups (articles)
398: * for this line of the history file.
399: * "groupcount" is the count of groups in it.
400: *
401: * Returns: 1 if the article is in the given distribution.
402: * 0 otherwise.
403: */
404:
405: distmatch(distlist, distcount, grouplist, groupcount)
406: char *distlist[];
407: int distcount;
408: char *grouplist[];
409: int groupcount;
410: {
411: register char *cp;
412: register FILE *fp;
413: register int i, j;
414: char buf[MAX_STRLEN];
415:
416: fp = fopen(grouplist[0], "r");
417: if (fp == NULL) {
418: syslog(LOG_ERR, "distmatch: fopen %s: %m", buf);
419: return (0);
420: }
421:
422: while (fgets(buf, sizeof (buf), fp) != NULL) {
423: cp = index(buf, '\n');
424: if (cp)
425: *cp = '\0';
426: if (buf[0] == '\0') /* End of header */
427: break;
428: cp = index(buf, ':');
429: if (cp == NULL)
430: continue;
431: *cp = '\0';
432: if (streql(buf, "distribution")) {
433: for (i = 0; i < distcount; ++i) {
434: if (streql(cp + 2, distlist[i])) {
435: (void) fclose(fp);
436: return (1);
437: }
438: }
439: return (0);
440: }
441: }
442:
443: (void) fclose(fp);
444:
445: /*
446: * We've finished the header with no distribution field.
447: * So we'll assume that the distribution is the characters
448: * up to the first dot in the newsgroup name.
449: */
450:
451: for (i = 0; i < groupcount; ++i) {
452: cp = index(grouplist[i], '.');
453: if (cp)
454: *cp = '\0';
455: for (j = 0; j < distcount; ++i)
456: if (streql(grouplist[i], distlist[i]))
457: return (1);
458: }
459:
460: return (0);
461: }
462:
463:
464: /*
465: * get_histlist -- return a nicely set up array of newsgroups
466: * (actually, net.foo.bar/article_num) along with a count.
467: *
468: * Parameters: "array" is storage for our array,
469: * set to point at some static data.
470: * "list" is the history file newsgroup list.
471: *
472: * Returns: Number of group specs found.
473: *
474: * Side effects: Changes static data area.
475: */
476:
477: get_histlist(array, list)
478: char ***array;
479: char *list;
480: {
481: register int histcount;
482: register char *cp;
483: static char **hist_list = (char **) NULL;
484:
485: cp = index(list, '\n');
486: if (cp)
487: *cp-- = '\0';
488: histcount = parsit(list, &hist_list);
489: *array = hist_list;
490: return (histcount);
491: }
492:
493:
494: /*
495: * get_nglist -- return a nicely set up array of newsgroups
496: * along with a count, when given an NNTP-spec newsgroup list
497: * in the form ng1,ng2,ng...
498: *
499: * Parameters: "array" is storage for our array,
500: * set to point at some static data.
501: * "list" is the NNTP newsgroup list.
502: *
503: * Returns: Number of group specs found.
504: *
505: * Side effects: Changes static data area.
506: */
507:
508: get_nglist(array, list)
509: char ***array;
510: char *list;
511: {
512: register char *cp;
513: register int ngcount;
514: static char **ng_list = (char **) NULL;
515:
516: for (cp = list; *cp != '\0'; ++cp)
517: if (*cp == ',')
518: *cp = ' ';
519: ngcount = parsit(list, &ng_list);
520: *array = ng_list;
521: return (ngcount);
522: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.