![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to headers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src|
Return to headers.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src |
1.1 root 1: # include <errno.h>
2: # include "sendmail.h"
3:
4: SCCSID(@(#)headers.c 4.3 8/21/83);
5:
6: /*
7: ** CHOMPHEADER -- process and save a header line.
8: **
9: ** Called by collect and by readcf to deal with header lines.
10: **
11: ** Parameters:
12: ** line -- header as a text line.
13: ** def -- if set, this is a default value.
14: **
15: ** Returns:
16: ** flags for this header.
17: **
18: ** Side Effects:
19: ** The header is saved on the header list.
20: ** Contents of 'line' are destroyed.
21: */
22:
23: chompheader(line, def)
24: char *line;
25: bool def;
26: {
27: register char *p;
28: register HDR *h;
29: HDR **hp;
30: char *fname;
31: char *fvalue;
32: struct hdrinfo *hi;
33: bool cond = FALSE;
34: BITMAP mopts;
35: extern char *crackaddr();
36:
37: # ifdef DEBUG
38: if (tTd(31, 6))
39: printf("chompheader: %s\n", line);
40: # endif DEBUG
41:
42: /* strip off options */
43: clrbitmap(mopts);
44: p = line;
45: if (*p == '?')
46: {
47: /* have some */
48: register char *q = index(p + 1, *p);
49:
50: if (q != NULL)
51: {
52: *q++ = '\0';
53: while (*++p != '\0')
54: setbitn(*p, mopts);
55: p = q;
56: }
57: else
58: syserr("chompheader: syntax error, line \"%s\"", line);
59: cond = TRUE;
60: }
61:
62: /* find canonical name */
63: fname = p;
64: p = index(p, ':');
65: if (p == NULL)
66: {
67: syserr("chompheader: syntax error, line \"%s\"", line);
68: return (0);
69: }
70: fvalue = &p[1];
71: while (isspace(*--p))
72: continue;
73: *++p = '\0';
74: makelower(fname);
75:
76: /* strip field value on front */
77: if (*fvalue == ' ')
78: fvalue++;
79:
80: /* see if it is a known type */
81: for (hi = HdrInfo; hi->hi_field != NULL; hi++)
82: {
83: if (strcmp(hi->hi_field, fname) == 0)
84: break;
85: }
86:
87: /* see if this is a resent message */
88: if (!def && bitset(H_RESENT, hi->hi_flags))
89: CurEnv->e_flags |= EF_RESENT;
90:
91: /* if this means "end of header" quit now */
92: if (bitset(H_EOH, hi->hi_flags))
93: return (hi->hi_flags);
94:
95: /* drop explicit From: if same as what we would generate -- for MH */
96: p = "resent-from";
97: if (!bitset(EF_RESENT, CurEnv->e_flags))
98: p += 7;
99: if (!def && !QueueRun && strcmp(fname, p) == 0)
100: {
101: ADDRESS fromaddr;
102:
103: if (strcmp(fvalue, CurEnv->e_from.q_paddr) == 0)
104: return (hi->hi_flags);
105: }
106:
107: /* delete default value for this header */
108: for (hp = &CurEnv->e_header; (h = *hp) != NULL; hp = &h->h_link)
109: {
110: if (strcmp(fname, h->h_field) == 0 &&
111: bitset(H_DEFAULT, h->h_flags) &&
112: !bitset(H_FORCE, h->h_flags))
113: h->h_value = NULL;
114: }
115:
116: /* create a new node */
117: h = (HDR *) xalloc(sizeof *h);
118: h->h_field = newstr(fname);
119: h->h_value = NULL;
120: h->h_link = NULL;
121: bcopy(mopts, h->h_mflags, sizeof mopts);
122: *hp = h;
123: h->h_flags = hi->hi_flags;
124: if (def)
125: h->h_flags |= H_DEFAULT;
126: if (cond)
127: h->h_flags |= H_CHECK;
128: if (h->h_value != NULL)
129: free((char *) h->h_value);
130: h->h_value = newstr(fvalue);
131:
132: /* hack to see if this is a new format message */
133: if (!def && bitset(H_RCPT|H_FROM, h->h_flags) &&
134: (index(fvalue, ',') != NULL || index(fvalue, '(') != NULL ||
135: index(fvalue, '<') != NULL || index(fvalue, ';') != NULL))
136: {
137: CurEnv->e_flags &= ~EF_OLDSTYLE;
138: }
139:
140: return (h->h_flags);
141: }
142: /*
143: ** ADDHEADER -- add a header entry to the end of the queue.
144: **
145: ** This bypasses the special checking of chompheader.
146: **
147: ** Parameters:
148: ** field -- the name of the header field.
149: ** value -- the value of the field. It must be lower-cased.
150: ** e -- the envelope to add them to.
151: **
152: ** Returns:
153: ** none.
154: **
155: ** Side Effects:
156: ** adds the field on the list of headers for this envelope.
157: */
158:
159: addheader(field, value, e)
160: char *field;
161: char *value;
162: ENVELOPE *e;
163: {
164: register HDR *h;
165: register struct hdrinfo *hi;
166: HDR **hp;
167:
168: /* find info struct */
169: for (hi = HdrInfo; hi->hi_field != NULL; hi++)
170: {
171: if (strcmp(field, hi->hi_field) == 0)
172: break;
173: }
174:
175: /* find current place in list -- keep back pointer? */
176: for (hp = &e->e_header; (h = *hp) != NULL; hp = &h->h_link)
177: {
178: if (strcmp(field, h->h_field) == 0)
179: break;
180: }
181:
182: /* allocate space for new header */
183: h = (HDR *) xalloc(sizeof *h);
184: h->h_field = field;
185: h->h_value = newstr(value);
186: h->h_link = *hp;
187: h->h_flags = hi->hi_flags | H_DEFAULT;
188: clrbitmap(h->h_mflags);
189: *hp = h;
190: }
191: /*
192: ** HVALUE -- return value of a header.
193: **
194: ** Only "real" fields (i.e., ones that have not been supplied
195: ** as a default) are used.
196: **
197: ** Parameters:
198: ** field -- the field name.
199: **
200: ** Returns:
201: ** pointer to the value part.
202: ** NULL if not found.
203: **
204: ** Side Effects:
205: ** none.
206: */
207:
208: char *
209: hvalue(field)
210: char *field;
211: {
212: register HDR *h;
213:
214: for (h = CurEnv->e_header; h != NULL; h = h->h_link)
215: {
216: if (!bitset(H_DEFAULT, h->h_flags) && strcmp(h->h_field, field) == 0)
217: return (h->h_value);
218: }
219: return (NULL);
220: }
221: /*
222: ** ISHEADER -- predicate telling if argument is a header.
223: **
224: ** A line is a header if it has a single word followed by
225: ** optional white space followed by a colon.
226: **
227: ** Parameters:
228: ** s -- string to check for possible headerness.
229: **
230: ** Returns:
231: ** TRUE if s is a header.
232: ** FALSE otherwise.
233: **
234: ** Side Effects:
235: ** none.
236: */
237:
238: bool
239: isheader(s)
240: register char *s;
241: {
242: while (*s > ' ' && *s != ':' && *s != '\0')
243: s++;
244:
245: /* following technically violates RFC822 */
246: while (isspace(*s))
247: s++;
248:
249: return (*s == ':');
250: }
251: /*
252: ** EATHEADER -- run through the stored header and extract info.
253: **
254: ** Parameters:
255: ** e -- the envelope to process.
256: **
257: ** Returns:
258: ** none.
259: **
260: ** Side Effects:
261: ** Sets a bunch of global variables from information
262: ** in the collected header.
263: ** Aborts the message if the hop count is exceeded.
264: */
265:
266: eatheader(e)
267: register ENVELOPE *e;
268: {
269: register HDR *h;
270: register char *p;
271: int hopcnt = 0;
272:
273: #ifdef DEBUG
274: if (tTd(32, 1))
275: printf("----- collected header -----\n");
276: #endif DEBUG
277: for (h = e->e_header; h != NULL; h = h->h_link)
278: {
279: #ifdef DEBUG
280: extern char *capitalize();
281:
282: if (tTd(32, 1))
283: printf("%s: %s\n", capitalize(h->h_field), h->h_value);
284: #endif DEBUG
285: /* count the number of times it has been processed */
286: if (bitset(H_TRACE, h->h_flags))
287: hopcnt++;
288:
289: /* send to this person if we so desire */
290: if (GrabTo && bitset(H_RCPT, h->h_flags) &&
291: !bitset(H_DEFAULT, h->h_flags) &&
292: (!bitset(EF_RESENT, CurEnv->e_flags) || bitset(H_RESENT, h->h_flags)))
293: {
294: sendtolist(h->h_value, (ADDRESS *) NULL, &CurEnv->e_sendqueue);
295: }
296:
297: /* log the message-id */
298: #ifdef LOG
299: if (!QueueRun && LogLevel > 8 && h->h_value != NULL &&
300: strcmp(h->h_field, "message-id") == 0)
301: {
302: char buf[MAXNAME];
303:
304: p = h->h_value;
305: if (bitset(H_DEFAULT, h->h_flags))
306: {
307: expand(p, buf, &buf[sizeof buf], e);
308: p = buf;
309: }
310: syslog(LOG_INFO, "%s: message-id=%s", e->e_id, p);
311: }
312: #endif LOG
313: }
314: #ifdef DEBUG
315: if (tTd(32, 1))
316: printf("----------------------------\n");
317: #endif DEBUG
318:
319: /* store hop count */
320: if (hopcnt > e->e_hopcount)
321: e->e_hopcount = hopcnt;
322:
323: /* message priority */
324: p = hvalue("precedence");
325: if (p != NULL)
326: e->e_class = priencode(p);
327: if (!QueueRun)
328: e->e_msgpriority = e->e_msgsize - e->e_class * WKPRIFACT;
329:
330: /* return receipt to */
331: p = hvalue("return-receipt-to");
332: if (p != NULL)
333: e->e_receiptto = p;
334:
335: /* errors to */
336: p = hvalue("errors-to");
337: if (p != NULL)
338: sendtolist(p, (ADDRESS *) NULL, &e->e_errorqueue);
339:
340: /* from person */
341: if (OpMode == MD_ARPAFTP)
342: {
343: register struct hdrinfo *hi = HdrInfo;
344:
345: for (p = NULL; p == NULL && hi->hi_field != NULL; hi++)
346: {
347: if (bitset(H_FROM, hi->hi_flags))
348: p = hvalue(hi->hi_field);
349: }
350: if (p != NULL)
351: setsender(p);
352: }
353:
354: /* full name of from person */
355: p = hvalue("full-name");
356: if (p != NULL)
357: define('x', p, e);
358:
359: /* date message originated */
360: p = hvalue("posted-date");
361: if (p == NULL)
362: p = hvalue("date");
363: if (p != NULL)
364: {
365: define('a', p, e);
366: /* we don't have a good way to do canonical conversion ....
367: define('d', newstr(arpatounix(p)), e);
368: .... so we will ignore the problem for the time being */
369: }
370:
371: /*
372: ** Log collection information.
373: */
374:
375: # ifdef LOG
376: if (!QueueRun && LogLevel > 1)
377: {
378: syslog(LOG_INFO, "%s: from=%s, size=%ld, class=%d\n",
379: CurEnv->e_id, CurEnv->e_from.q_paddr, CurEnv->e_msgsize,
380: CurEnv->e_class);
381: }
382: # endif LOG
383: }
384: /*
385: ** PRIENCODE -- encode external priority names into internal values.
386: **
387: ** Parameters:
388: ** p -- priority in ascii.
389: **
390: ** Returns:
391: ** priority as a numeric level.
392: **
393: ** Side Effects:
394: ** none.
395: */
396:
397: priencode(p)
398: char *p;
399: {
400: register int i;
401: extern bool sameword();
402:
403: for (i = 0; i < NumPriorities; i++)
404: {
405: if (sameword(p, Priorities[i].pri_name))
406: return (Priorities[i].pri_val);
407: }
408:
409: /* unknown priority */
410: return (0);
411: }
412: /*
413: ** CRACKADDR -- parse an address and turn it into a macro
414: **
415: ** This doesn't actually parse the address -- it just extracts
416: ** it and replaces it with "$g". The parse is totally ad hoc
417: ** and isn't even guaranteed to leave something syntactically
418: ** identical to what it started with. However, it does leave
419: ** something semantically identical.
420: **
421: ** The process is kind of strange. There are a number of
422: ** interesting cases:
423: ** 1. comment <address> comment ==> comment <$g> comment
424: ** 2. address ==> address
425: ** 3. address (comment) ==> $g (comment)
426: ** 4. (comment) address ==> (comment) $g
427: ** And then there are the hard cases....
428: ** 5. add (comment) ress ==> $g (comment)
429: ** 6. comment <address (comment)> ==> comment <$g (comment)>
430: ** 7. .... etc ....
431: **
432: ** Parameters:
433: ** addr -- the address to be cracked.
434: **
435: ** Returns:
436: ** a pointer to the new version.
437: **
438: ** Side Effects:
439: ** none.
440: **
441: ** Warning:
442: ** The return value is saved in local storage and should
443: ** be copied if it is to be reused.
444: */
445:
446: char *
447: crackaddr(addr)
448: register char *addr;
449: {
450: register char *p;
451: register int i;
452: static char buf[MAXNAME];
453: char *rhs;
454: bool gotaddr;
455: register char *bp;
456:
457: # ifdef DEBUG
458: if (tTd(33, 1))
459: printf("crackaddr(%s)\n", addr);
460: # endif DEBUG
461:
462: strcpy(buf, "");
463: rhs = NULL;
464:
465: /* strip leading spaces */
466: while (*addr != '\0' && isspace(*addr))
467: addr++;
468:
469: /*
470: ** See if we have anything in angle brackets. If so, that is
471: ** the address part, and the rest is the comment.
472: */
473:
474: p = index(addr, '<');
475: if (p != NULL)
476: {
477: /* copy the beginning of the addr field to the buffer */
478: *p = '\0';
479: strcpy(buf, addr);
480: strcat(buf, "<");
481: *p++ = '<';
482:
483: /* skip spaces */
484: while (isspace(*p))
485: p++;
486:
487: /* find the matching right angle bracket */
488: addr = p;
489: for (i = 0; *p != '\0'; p++)
490: {
491: switch (*p)
492: {
493: case '<':
494: i++;
495: break;
496:
497: case '>':
498: i--;
499: break;
500: }
501: if (i < 0)
502: break;
503: }
504:
505: /* p now points to the closing quote (or a null byte) */
506: if (*p != '\0')
507: {
508: /* make rhs point to the extra stuff at the end */
509: rhs = p;
510: *p++ = '\0';
511: }
512: }
513:
514: /*
515: ** Now parse the real address part. "addr" points to the (null
516: ** terminated) version of what we are inerested in; rhs points
517: ** to the extra stuff at the end of the line, if any.
518: */
519:
520: p = addr;
521:
522: /* now strip out comments */
523: bp = &buf[strlen(buf)];
524: gotaddr = FALSE;
525: for (; *p != '\0'; p++)
526: {
527: if (*p == '(')
528: {
529: /* copy to matching close paren */
530: *bp++ = *p++;
531: for (i = 0; *p != '\0'; p++)
532: {
533: *bp++ = *p;
534: switch (*p)
535: {
536: case '(':
537: i++;
538: break;
539:
540: case ')':
541: i--;
542: break;
543: }
544: if (i < 0)
545: break;
546: }
547: continue;
548: }
549:
550: /*
551: ** If this is the first "real" character we have seen,
552: ** then we put the "$g" in the buffer now.
553: */
554:
555: if (isspace(*p))
556: *bp++ = *p;
557: else if (!gotaddr)
558: {
559: strcpy(bp, "$g");
560: bp += 2;
561: gotaddr = TRUE;
562: }
563: }
564:
565: /* hack, hack.... strip trailing blanks */
566: do
567: {
568: *bp-- = '\0';
569: } while (isspace(*bp));
570: bp++;
571:
572: /* put any right hand side back on */
573: if (rhs != NULL)
574: {
575: *rhs = '>';
576: strcpy(bp, rhs);
577: }
578:
579: # ifdef DEBUG
580: if (tTd(33, 1))
581: printf("crackaddr=>`%s'\n", buf);
582: # endif DEBUG
583:
584: return (buf);
585: }
586: /*
587: ** PUTHEADER -- put the header part of a message from the in-core copy
588: **
589: ** Parameters:
590: ** fp -- file to put it on.
591: ** m -- mailer to use.
592: ** e -- envelope to use.
593: **
594: ** Returns:
595: ** none.
596: **
597: ** Side Effects:
598: ** none.
599: */
600:
601: putheader(fp, m, e)
602: register FILE *fp;
603: register MAILER *m;
604: register ENVELOPE *e;
605: {
606: char buf[BUFSIZ];
607: register HDR *h;
608: extern char *arpadate();
609: extern char *capitalize();
610: char obuf[MAXLINE];
611:
612: for (h = e->e_header; h != NULL; h = h->h_link)
613: {
614: register char *p;
615: extern bool bitintersect();
616:
617: if (bitset(H_CHECK|H_ACHECK, h->h_flags) &&
618: !bitintersect(h->h_mflags, m->m_flags))
619: continue;
620:
621: /* handle Resent-... headers specially */
622: if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags))
623: continue;
624:
625: p = h->h_value;
626: if (bitset(H_DEFAULT, h->h_flags))
627: {
628: /* macro expand value if generated internally */
629: expand(p, buf, &buf[sizeof buf], e);
630: p = buf;
631: if (p == NULL || *p == '\0')
632: continue;
633: }
634:
635: if (bitset(H_FROM|H_RCPT, h->h_flags))
636: {
637: /* address field */
638: bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
639:
640: if (bitset(H_FROM, h->h_flags))
641: oldstyle = FALSE;
642: commaize(h, p, fp, oldstyle, m);
643: }
644: else
645: {
646: /* vanilla header line */
647: register char *nlp;
648:
649: (void) sprintf(obuf, "%s: ", capitalize(h->h_field));
650: while ((nlp = index(p, '\n')) != NULL)
651: {
652: *nlp = '\0';
653: (void) strcat(obuf, p);
654: *nlp = '\n';
655: putline(obuf, fp, m);
656: p = ++nlp;
657: obuf[0] = '\0';
658: }
659: (void) strcat(obuf, p);
660: putline(obuf, fp, m);
661: }
662: }
663: }
664: /*
665: ** COMMAIZE -- output a header field, making a comma-translated list.
666: **
667: ** Parameters:
668: ** h -- the header field to output.
669: ** p -- the value to put in it.
670: ** fp -- file to put it to.
671: ** oldstyle -- TRUE if this is an old style header.
672: ** m -- a pointer to the mailer descriptor. If NULL,
673: ** don't transform the name at all.
674: **
675: ** Returns:
676: ** none.
677: **
678: ** Side Effects:
679: ** outputs "p" to file "fp".
680: */
681:
682: commaize(h, p, fp, oldstyle, m)
683: register HDR *h;
684: register char *p;
685: FILE *fp;
686: bool oldstyle;
687: register MAILER *m;
688: {
689: register char *obp;
690: int opos;
691: bool firstone = TRUE;
692: char obuf[MAXLINE + 3];
693:
694: /*
695: ** Output the address list translated by the
696: ** mailer and with commas.
697: */
698:
699: # ifdef DEBUG
700: if (tTd(14, 2))
701: printf("commaize(%s: %s)\n", h->h_field, p);
702: # endif DEBUG
703:
704: obp = obuf;
705: (void) sprintf(obp, "%s: ", capitalize(h->h_field));
706: opos = strlen(h->h_field) + 2;
707: obp += opos;
708:
709: /*
710: ** Run through the list of values.
711: */
712:
713: while (*p != '\0')
714: {
715: register char *name;
716: char savechar;
717: extern char *remotename();
718: extern char *DelimChar; /* defined in prescan */
719:
720: /*
721: ** Find the end of the name. New style names
722: ** end with a comma, old style names end with
723: ** a space character. However, spaces do not
724: ** necessarily delimit an old-style name -- at
725: ** signs mean keep going.
726: */
727:
728: /* find end of name */
729: while (isspace(*p) || *p == ',')
730: p++;
731: name = p;
732: for (;;)
733: {
734: char *oldp;
735: extern bool isatword();
736: extern char **prescan();
737:
738: (void) prescan(p, oldstyle ? ' ' : ',');
739: p = DelimChar;
740:
741: /* look to see if we have an at sign */
742: oldp = p;
743: while (*p != '\0' && isspace(*p))
744: p++;
745:
746: if (*p != '@' && !isatword(p))
747: {
748: p = oldp;
749: break;
750: }
751: p += *p == '@' ? 1 : 2;
752: while (*p != '\0' && isspace(*p))
753: p++;
754: }
755: /* at the end of one complete name */
756:
757: /* strip off trailing white space */
758: while (p >= name && (isspace(*p) || *p == ',' || *p == '\0'))
759: p--;
760: if (++p == name)
761: continue;
762: savechar = *p;
763: *p = '\0';
764:
765: /* translate the name to be relative */
766: name = remotename(name, m, bitset(H_FROM, h->h_flags), FALSE);
767: if (*name == '\0')
768: {
769: *p = savechar;
770: continue;
771: }
772:
773: /* output the name with nice formatting */
774: opos += qstrlen(name);
775: if (!firstone)
776: opos += 2;
777: if (opos > 78 && !firstone)
778: {
779: (void) strcpy(obp, ",\n");
780: putline(obuf, fp, m);
781: obp = obuf;
782: (void) sprintf(obp, " ");
783: opos = strlen(obp);
784: obp += opos;
785: opos += qstrlen(name);
786: }
787: else if (!firstone)
788: {
789: (void) sprintf(obp, ", ");
790: obp += 2;
791: }
792:
793: /* strip off quote bits as we output */
794: while (*name != '\0' && obp < &obuf[MAXLINE])
795: {
796: if (bitset(0200, *name))
797: *obp++ = '\\';
798: *obp++ = *name++ & ~0200;
799: }
800: firstone = FALSE;
801: *p = savechar;
802: }
803: (void) strcpy(obp, "\n");
804: putline(obuf, fp, m);
805: }
806: /*
807: ** ISATWORD -- tell if the word we are pointing to is "at".
808: **
809: ** Parameters:
810: ** p -- word to check.
811: **
812: ** Returns:
813: ** TRUE -- if p is the word at.
814: ** FALSE -- otherwise.
815: **
816: ** Side Effects:
817: ** none.
818: */
819:
820: bool
821: isatword(p)
822: register char *p;
823: {
824: extern char lower();
825:
826: if (lower(p[0]) == 'a' && lower(p[1]) == 't' &&
827: p[2] != '\0' && isspace(p[2]))
828: return (TRUE);
829: return (FALSE);
830: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.