![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bnewshead.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / notes / src|
Return to bnewshead.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / notes / src |
1.1 root 1: /*
2: * header.c - header functions plus some other goodies
3: *
4: * TAKEN FROM BNEWS 2.10 6/24/83
5: *
6: */
7:
8: #ifdef RCSIDENT
9: static char *SccsId = "@(#)header.c 2.20 6/24/83";
10: static char *RCSid = "$Header: bnewshead.c,v 1.7.0.1 85/03/06 20:03:00 notes Rel $";
11: #endif RCSIDENT
12:
13: #include <stdio.h>
14: #include <sys/types.h>
15: #include "parms.h" /* from notes */
16: #include "structs.h" /* ditto */
17: /* above maybe unused */
18: #include "newsgate.h"
19:
20:
21: char *hfgets ();
22:
23: static int seenrelay;
24: static char bfr[PATHLEN]; /* header buffer */
25:
26: /*
27: * Read header from file fp into *hp. If wholething is FALSE,
28: * it's an incremental read, otherwise start from scratch.
29: * Return (FILE *) if header okay, else NULL.
30: */
31:
32: newsheader (hp, fp, wholething)
33: register struct hbuf *hp;
34: FILE * fp;
35: int wholething;
36: {
37: register int len;
38:
39: if (wholething) /* from scratch */
40: bclear ((char *) hp, sizeof (*hp));
41:
42: seenrelay = 0;
43:
44: /*
45: * Check that it's a B news style header.
46: */
47: if (((hfgets (bfr, PATHLEN, fp) != NULL &&
48: *bfr >= 'A' && *bfr <= 'Z') && index (bfr, ':')))
49: if (frmread (fp, hp))
50: goto strip;
51:
52: /*
53: * It's not. Try A news (begins with PROTO).
54: */
55: if (*bfr != PROTO)
56: return (0);
57:
58: /*
59: * Read in an A news format article.
60: */
61: strncpy (hp -> oident, &(bfr[1]), NAMELEN); /* file name */
62: if (!nstrip (hp -> oident))
63: return (0);
64: hfgets (hp -> nbuf, BUFLEN, fp); /* newsgroup list */
65: if (!nstrip (hp -> nbuf))
66: return (0);
67: ngcat (hp -> nbuf); /* trailing delim */
68: hfgets (hp -> path, PATHLEN, fp); /* source path */
69: if (!nstrip (hp -> path))
70: return (0);
71: hfgets (hp -> subdate, DATELEN, fp); /* date */
72: if (!nstrip (hp -> subdate))
73: return (0);
74: hfgets (hp -> title, BUFLEN, fp); /* title */
75: if (!nstrip (hp -> title))
76: return (0);
77:
78: /*
79: * strip off sys! from front of path.
80: */
81: strip:
82: strcpy (bfr, System);
83: if (strncmp (bfr, hp -> path, (len = strlen (bfr))) == 0
84: && index (NETCHRS, hp -> path[len]))
85: strcpy (hp -> path, &(hp -> path[len + 1]));
86:
87: if (wholething && hp -> from[0] == '\0') /* intuit the from: */
88: intuitfrom (hp); /* if wasn't there */
89:
90: if (wholething) /* Get message ID's. */
91: fixid (hp);
92: return (1);
93: }
94:
95:
96: /*
97: * Get header info from mail-format file.
98: * Return non-zero on success.
99: */
100:
101: #include <ctype.h>
102: #define FROM 1
103: #define NEWSGROUP 2
104: #define TITLE 3
105: #define SUBMIT 4
106: #define RECEIVE 5
107: #define EXPIRE 6
108: #define ARTICLEID 7
109: #define MESSAGEID 8
110: #define REPLYTO 9
111: #define FOLLOWID 10
112: #define CONTROL 11
113: #define SENDER 12
114: #define FOLLOWTO 13
115: #define PATH 14
116: #define POSTVERSION 15
117: #define RELAYVERSION 16
118: #define DISTRIBUTION 17
119: #define ORGANIZATION 18
120: #define NUMLINES 19
121: #define KEYWORDS 20
122: #define APPROVED 21
123:
124: #define NLINE1 22
125: #define NLINE2 23
126:
127: #define OTHER 99
128:
129:
130: char *malloc ();
131:
132: frmread (fp, hp)
133: register FILE * fp;
134: register struct hbuf *hp;
135: {
136: int unreccnt = 0;
137: register int i;
138: long curpos;
139: int hdrlineno = 0;
140: int iu;
141:
142: for (iu = 0; iu < NUNREC; iu++)
143: hp -> unrec[iu] = NULL;
144:
145: i = type (bfr);
146: do
147: {
148: curpos = ftell (fp);
149: hdrlineno++;
150: switch (i)
151: {
152: case PATH:
153: getfield (hp -> path);
154: break;
155: case FROM:
156: getfield (hp -> from);
157: break;
158: case NEWSGROUP:
159: getfield (hp -> nbuf);
160: break;
161: case TITLE:
162: getfield (hp -> title);
163: break;
164: case SUBMIT:
165: getfield (hp -> subdate);
166: break;
167: case RECEIVE:
168: getfield (hp -> recdate);
169: break;
170: case EXPIRE:
171: getfield (hp -> expdate);
172: break;
173: case ARTICLEID:
174: getfield (hp -> oident);
175: break;
176: case MESSAGEID:
177: getfield (hp -> ident);
178: break;
179: case REPLYTO:
180: getfield (hp -> replyto);
181: break;
182: case FOLLOWID:
183: getfield (hp -> followid);
184: break;
185: case SENDER:
186: getfield (hp -> sender);
187: break;
188: case FOLLOWTO:
189: getfield (hp -> followto);
190: break;
191: case CONTROL:
192: getfield (hp -> ctlmsg);
193: break;
194: case POSTVERSION:
195: getfield (hp -> postversion);
196: break;
197: case DISTRIBUTION:
198: getfield (hp -> distribution);
199: break;
200: case ORGANIZATION:
201: getfield (hp -> organization);
202: break;
203: case NUMLINES:
204: getfield (hp -> numlines);
205: hp -> intnumlines = atoi (hp -> numlines);
206: break;
207: case KEYWORDS:
208: getfield (hp -> keywords);
209: break;
210: case APPROVED:
211: getfield (hp -> approved);
212: break;
213: case NLINE1: /* notes-specific */
214: getfield (hp -> nline1);
215: break;
216: case NLINE2: /* notes-specific */
217: getfield (hp -> nline2);
218: break;
219: case RELAYVERSION:
220: /*
221: * Only believe a relay version if it's the first
222: * line, otherwise it probably got passed through
223: * by some old neighbor.
224: */
225: if (hdrlineno == 1)
226: {
227: getfield (hp -> relayversion);
228: seenrelay = 1;
229: }
230: break;
231: case OTHER:
232: if (unreccnt < NUNREC)
233: {
234: hp -> unrec[unreccnt] = malloc (strlen (bfr) + 1);
235: strcpy (hp -> unrec[unreccnt], bfr);
236: unreccnt++;
237: }
238: break;
239: }
240: } while ((i = type (hfgets (bfr, LBUFLEN, fp))) > 0);
241:
242: if (*bfr != '\n')
243: {
244: printf ("Bizzaro header line: %s\n", bfr);
245: return (0);
246: }
247:
248: /*
249: * Check to see if the REQUIRED headers are present. If so, return
250: * that we found a message. Otherwise barf.
251: */
252: if ((hp -> from[0] || hp -> path[0]) &&
253: hp -> subdate[0] &&
254: (hp -> ident[0] || hp -> oident[0]))
255: {
256: return TRUE;
257: }
258: return FALSE;
259: }
260:
261: /*
262: * There was no From: line in the message (because it was generated by
263: * an old news program). Guess what it should have been and create it.
264: */
265:
266: intuitfrom (hp)
267: register struct hbuf *hp;
268: {
269: char *tp;
270: char *user,
271: *host,
272: *fullname;
273: char *tailpath ();
274: char *at,
275: *dot;
276:
277: tp = tailpath (hp);
278: user = rindex (tp, '!');
279: if (user == NULL)
280: user = tp;
281: else
282: *user++ = '\0';
283:
284: /* Check for an existing Internet address on the end. */
285: at = index (user, '@');
286: if (at)
287: {
288: dot = index (at, '.');
289: if (dot)
290: {
291: strcpy (hp -> from, user);
292: return;
293: }
294: /* @ signs are illegal except for the biggie, so */
295: *at = '%';
296: }
297:
298: if (tp[0] == '.')
299: host = index (tp, '!') + 1;
300: else
301: if (user == tp)
302: host = System;
303: else
304: host = tp;
305:
306: tp = index (host, '@');
307: if (tp != NULL)
308: *tp = 0;
309: sprintf (hp -> from, "%s@%s.%s", user, host, DFLTDOMAIN);
310:
311: fullname = index (hp -> path, '(');
312: if (fullname != NULL)
313: {
314: fullname--;
315: strcat (hp -> from, fullname);
316: *fullname = 0;
317: }
318: }
319:
320: /*
321: * If the message has only one of ident/oident, guess what
322: * the other one should be and fill them both in.
323: */
324:
325: fixid (hp)
326: register struct hbuf *hp;
327: {
328: char lbuf[100];
329: char *p;
330: #ifdef OLD
331: char *q;
332: #endif OLD
333:
334: if (hp -> ident[0] == '\0' && hp -> oident[0] != '\0')
335: {
336: strcpy (lbuf, hp -> oident);
337: p = index (lbuf, '.');
338: if (p == 0)
339: {
340: strcpy (hp -> ident, hp -> oident);
341: return;
342: }
343: *p++ = '\0';
344: /*
345: * It may seem strange that we hardwire ".UUCP" in
346: * here instead of DFLTDOMAIN. However, we are trying
347: * to guess what the domain was on the posting system,
348: * not the local system. Since we don't really know
349: * what the posting system does, we just go with the
350: * majority - almost everyone will be a .UUCP if they
351: * didn't fill in their Message-ID.
352: */
353: sprintf (hp -> ident, "<%s@%s%s>", p, lbuf, ".UUCP");
354: }
355:
356: #ifdef OLD
357: if (hp -> oident[0] == '\0' && hp -> ident[0] != '\0')
358: {
359: strcpy (lbuf, hp -> ident);
360: p = index (lbuf, '@');
361: if (p == 0)
362: {
363: strcpy (hp -> oident, hp -> ident);
364: return;
365: }
366: *p++ = '\0';
367: q = index (p, '.');
368: if (!q)
369: q = index (p, '>');
370: if (q)
371: *q++ = '\0';
372: p[SNLN] = '\0';
373: sprintf (hp -> oident, "%s.%s", p, lbuf + 1);
374: }
375: #endif
376: }
377:
378: /*
379: * Get the given field of a header (char * parm) from bfr, but only
380: * if there's something actually there (after the colon). Don't
381: * bother if we already have an entry for this field.
382: */
383:
384: getfield (hpfield)
385: char *hpfield;
386: {
387: char *ptr;
388:
389: if (hpfield[0])
390: return;
391: for (ptr = index (bfr, ':'); isspace (*++ptr);)
392: ;
393: if (*ptr != '\0')
394: {
395: strcpy (hpfield, ptr);
396: nstrip (hpfield);
397: }
398: return;
399: }
400:
401:
402: /*
403: * Determine the type of the header
404: */
405:
406: #define its(type) (!strncmp(ptr,type,strlen(type)))
407:
408: type (ptr)
409: char *ptr;
410: {
411: char *colon,
412: *space;
413:
414: if (!isalpha (*ptr) && strncmp (ptr, "From ", 5))
415: return FALSE;
416: colon = index (ptr, ':');
417: space = index (ptr, ' ');
418: if (!colon || colon + 1 != space)
419: return FALSE;
420: if (its ("From: "))
421: if (index (ptr, '@') && !index (ptr, '!') && seenrelay)
422: return FROM;
423: else
424: return PATH;
425: if (its ("Path: "))
426: return PATH;
427: if (its ("Newsgroups: "))
428: return NEWSGROUP;
429: if (its ("Subject: ") || its ("Title: "))
430: return TITLE;
431: if (its ("Posted: ") || its ("Date: "))
432: return SUBMIT;
433: if (its ("Date-Received: ") || its ("Received: "))
434: return RECEIVE;
435: if (its ("Expires: "))
436: return EXPIRE;
437: if (its ("Article-I.D.: "))
438: return ARTICLEID;
439: if (its ("Message-ID: "))
440: return MESSAGEID;
441: if (its ("Reply-To: "))
442: return REPLYTO;
443: if (its ("References: "))
444: return FOLLOWID;
445: if (its ("Control: "))
446: return CONTROL;
447: if (its ("Sender: "))
448: return SENDER;
449: if (its ("Followup-To: "))
450: return FOLLOWTO;
451: if (its ("Posting-Version: "))
452: return POSTVERSION;
453: if (its ("Relay-Version: "))
454: return RELAYVERSION;
455: if (its ("Distribution: "))
456: return DISTRIBUTION;
457: if (its ("Organization: "))
458: return ORGANIZATION;
459: if (its ("Lines: "))
460: return NUMLINES;
461: if (its ("Keywords: "))
462: return KEYWORDS;
463: if (its ("Approved: "))
464: return APPROVED;
465: if (its ("Nf-ID: "))
466: return NLINE1;
467: if (its ("Nf-From: "))
468: return NLINE2;
469: return OTHER;
470: }
471:
472: /*
473: * Set nc bytes, starting at cp, to zero.
474: */
475:
476: bclear (cp, nc)
477: register char *cp;
478: register int nc;
479: {
480: while (nc--)
481: *cp++ = 0;
482: }
483:
484: /*
485: * Strip trailing newlines, blanks, and tabs from 's'.
486: * Return TRUE if newline was found, else FALSE.
487: */
488:
489: nstrip (s)
490: register char *s;
491: {
492: register char *p;
493: register int rc;
494:
495: rc = FALSE;
496: p = s;
497: while (*p)
498: if (*p++ == '\n')
499: rc = TRUE;
500: while (--p >= s && (*p == '\n' || *p == ' ' || *p == '\t'));
501: *++p = '\0';
502: return (rc);
503: }
504:
505: /*
506: * Append NGDELIM to string.
507: */
508:
509: ngcat (s)
510: register char *s;
511: {
512: if (*s)
513: {
514: while (*s++);
515: s -= 2;
516: if (*s++ == NGDELIM)
517: return;
518: }
519: *s++ = NGDELIM;
520: *s = '\0';
521: }
522:
523: /*
524: * Return a compact representation of the person who posted the given
525: * message. A sender or internet name will be used, otherwise
526: * the last part of the path is used preceeded by an optional ".."
527: */
528: char *
529: tailpath (hp)
530: struct hbuf *hp;
531: {
532: char *p,
533: *r;
534: static char resultbuf[BUFLEN];
535: char pathbuf[PATHLEN];
536: char *malloc ();
537:
538: /*
539: * This only happens for articles posted by old news software
540: * in non-internet format.
541: */
542: resultbuf[0] = '\0';
543: strcpy (pathbuf, hp -> path);
544: p = index (pathbuf, ' ');
545: if (p)
546: *p = '\0'; /* Chop off trailing " (name)" */
547: r = rindex (pathbuf, '!');
548: if (r == 0)
549: {
550: r = pathbuf;
551: }
552: else
553: {
554: while (r > pathbuf && *--r != '!')
555: ;
556: if (r > pathbuf)
557: {
558: r++;
559: strcpy (resultbuf, "..!");
560: }
561: }
562: strcat (resultbuf, r);
563: return resultbuf;
564: }
565:
566:
567:
568: /*
569: * hfgets is like fgets, but deals with continuation lines.
570: * It also ensures that even if a line that is too long is
571: * received, the remainder of the line is thrown away
572: * instead of treated like a second line.
573: */
574:
575: char *hfgets (buf, len, fp)
576: char *buf;
577: int len;
578: FILE * fp;
579: {
580: register int c;
581: register char *cp,
582: *tp;
583:
584: cp = fgets (buf, len, fp);
585: if (cp == NULL)
586: return NULL;
587:
588: tp = cp + strlen (cp);
589: if (tp[-1] != '\n')
590: {
591: /*
592: * Line too long - part read didn't fit into a newline
593: */
594: while ((c = getc (fp)) != '\n' && c != EOF)
595: ;
596: }
597: else
598: *--tp = '\0'; /* clobber newline */
599:
600: while ((c = getc (fp)) == ' ' || c == '\t') /* continuation */
601: {
602: /*
603: * Continuation line.
604: */
605: while ((c = getc (fp)) == ' ' || c == '\t') /* skip white space */
606: ;
607: if (tp - cp < len)
608: {
609: *tp++ = ' ';
610: *tp++ = c;
611: }
612: while ((c = getc (fp)) != '\n' && c != EOF)
613: if (tp - cp < len)
614: *tp++ = c;
615: }
616: *tp++ = '\n';
617: *tp++ = '\0';
618: if (c != EOF)
619: ungetc (c, fp); /* push back char */
620: return cp;
621: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.