?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import sendmail 8.13.7
[dragonfly.git] / contrib / sendmail-8.13.7 / sendmail / headers.c
blob8a142d20576a2d9392a831d88be8d92cee326f1c
1 /*
2 * Copyright (c) 1998-2004, 2006 Sendmail, Inc. and its suppliers.
3 * All rights reserved.
4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
5 * Copyright (c) 1988, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * By using this file, you agree to the terms and conditions set
9 * forth in the LICENSE file which can be found at the top level of
10 * the sendmail distribution.
11 *
12 */
13
14 #include <sendmail.h>
15
16 SM_RCSID("@(#)$Id: headers.c,v 8.291 2006/03/24 01:01:56 ca Exp $")
17
18 static HDR *allocheader __P((char *, char *, int, SM_RPOOL_T *));
19 static size_t fix_mime_header __P((HDR *, ENVELOPE *));
20 static int priencode __P((char *));
21 static bool put_vanilla_header __P((HDR *, char *, MCI *));
22
23 /*
24 ** SETUPHEADERS -- initialize headers in symbol table
25 **
26 ** Parameters:
27 ** none
28 **
29 ** Returns:
30 ** none
31 */
32
33 void
34 setupheaders()
35 {
36 struct hdrinfo *hi;
37 STAB *s;
38
39 for (hi = HdrInfo; hi->hi_field != NULL; hi++)
40 {
41 s = stab(hi->hi_field, ST_HEADER, ST_ENTER);
42 s->s_header.hi_flags = hi->hi_flags;
43 s->s_header.hi_ruleset = NULL;
44 }
45 }
46 /*
47 ** CHOMPHEADER -- process and save a header line.
48 **
49 ** Called by collect, readcf, and readqf to deal with header lines.
50 **
51 ** Parameters:
52 ** line -- header as a text line.
53 ** pflag -- flags for chompheader() (from sendmail.h)
54 ** hdrp -- a pointer to the place to save the header.
55 ** e -- the envelope including this header.
56 **
57 ** Returns:
58 ** flags for this header.
59 **
60 ** Side Effects:
61 ** The header is saved on the header list.
62 ** Contents of 'line' are destroyed.
63 */
64
65 static struct hdrinfo NormalHeader = { NULL, 0, NULL };
66
67 unsigned long
68 chompheader(line, pflag, hdrp, e)
69 char *line;
70 int pflag;
71 HDR **hdrp;
72 register ENVELOPE *e;
73 {
74 unsigned char mid = '\0';
75 register char *p;
76 register HDR *h;
77 HDR **hp;
78 char *fname;
79 char *fvalue;
80 bool cond = false;
81 bool dropfrom;
82 bool headeronly;
83 STAB *s;
84 struct hdrinfo *hi;
85 bool nullheader = false;
86 BITMAP256 mopts;
87
88 if (tTd(31, 6))
89 {
90 sm_dprintf("chompheader: ");
91 xputs(sm_debug_file(), line);
92 sm_dprintf("\n");
93 }
94
95 headeronly = hdrp != NULL;
96 if (!headeronly)
97 hdrp = &e->e_header;
98
99 /* strip off options */
100 clrbitmap(mopts);
101 p = line;
102 if (!bitset(pflag, CHHDR_USER) && *p == '?')
103 {
104 int c;
105 register char *q;
106
107 q = strchr(++p, '?');
108 if (q == NULL)
109 goto hse;
110
111 *q = '\0';
112 c = *p & 0377;
113
114 /* possibly macro conditional */
115 if (c == MACROEXPAND)
116 {
117 /* catch ?$? */
118 if (*++p == '\0')
119 {
120 *q = '?';
121 goto hse;
122 }
123
124 mid = (unsigned char) *p++;
125
126 /* catch ?$abc? */
127 if (*p != '\0')
128 {
129 *q = '?';
130 goto hse;
131 }
132 }
133 else if (*p == '$')
134 {
135 /* catch ?$? */
136 if (*++p == '\0')
137 {
138 *q = '?';
139 goto hse;
140 }
141
142 mid = (unsigned char) macid(p);
143 if (bitset(0200, mid))
144 {
145 p += strlen(macname(mid)) + 2;
146 SM_ASSERT(p <= q);
147 }
148 else
149 p++;
150
151 /* catch ?$abc? */
152 if (*p != '\0')
153 {
154 *q = '?';
155 goto hse;
156 }
157 }
158 else
159 {
160 while (*p != '\0')
161 {
162 if (!isascii(*p))
163 {
164 *q = '?';
165 goto hse;
166 }
167
168 setbitn(bitidx(*p), mopts);
169 cond = true;
170 p++;
171 }
172 }
173 p = q + 1;
174 }
175
176 /* find canonical name */
177 fname = p;
178 while (isascii(*p) && isgraph(*p) && *p != ':')
179 p++;
180 fvalue = p;
181 while (isascii(*p) && isspace(*p))
182 p++;
183 if (*p++ != ':' || fname == fvalue)
184 {
185 hse:
186 syserr("553 5.3.0 header syntax error, line \"%s\"", line);
187 return 0;
188 }
189 *fvalue = '\0';
190
191 /* strip field value on front */
192 if (*p == ' ')
193 p++;
194 fvalue = p;
195
196 /* if the field is null, go ahead and use the default */
197 while (isascii(*p) && isspace(*p))
198 p++;
199 if (*p == '\0')
200 nullheader = true;
201
202 /* security scan: long field names are end-of-header */
203 if (strlen(fname) > 100)
204 return H_EOH;
205
206 /* check to see if it represents a ruleset call */
207 if (bitset(pflag, CHHDR_DEF))
208 {
209 char hbuf[50];
210
211 (void) expand(fvalue, hbuf, sizeof hbuf, e);
212 for (p = hbuf; isascii(*p) && isspace(*p); )
213 p++;
214 if ((*p++ & 0377) == CALLSUBR)
215 {
216 auto char *endp;
217 bool strc;
218
219 strc = *p == '+'; /* strip comments? */
220 if (strc)
221 ++p;
222 if (strtorwset(p, &endp, ST_ENTER) > 0)
223 {
224 *endp = '\0';
225 s = stab(fname, ST_HEADER, ST_ENTER);
226 if (LogLevel > 9 &&
227 s->s_header.hi_ruleset != NULL)
228 sm_syslog(LOG_WARNING, NOQID,
229 "Warning: redefined ruleset for header=%s, old=%s, new=%s",
230 fname,
231 s->s_header.hi_ruleset, p);
232 s->s_header.hi_ruleset = newstr(p);
233 if (!strc)
234 s->s_header.hi_flags |= H_STRIPCOMM;
235 }
236 return 0;
237 }
238 }
239
240 /* see if it is a known type */
241 s = stab(fname, ST_HEADER, ST_FIND);
242 if (s != NULL)
243 hi = &s->s_header;
244 else
245 hi = &NormalHeader;
246
247 if (tTd(31, 9))
248 {
249 if (s == NULL)
250 sm_dprintf("no header flags match\n");
251 else
252 sm_dprintf("header match, flags=%lx, ruleset=%s\n",
253 hi->hi_flags,
254 hi->hi_ruleset == NULL ? "<NULL>"
255 : hi->hi_ruleset);
256 }
257
258 /* see if this is a resent message */
259 if (!bitset(pflag, CHHDR_DEF) && !headeronly &&
260 bitset(H_RESENT, hi->hi_flags))
261 e->e_flags |= EF_RESENT;
262
263 /* if this is an Errors-To: header keep track of it now */
264 if (UseErrorsTo && !bitset(pflag, CHHDR_DEF) && !headeronly &&
265 bitset(H_ERRORSTO, hi->hi_flags))
266 (void) sendtolist(fvalue, NULLADDR, &e->e_errorqueue, 0, e);
267
268 /* if this means "end of header" quit now */
269 if (!headeronly && bitset(H_EOH, hi->hi_flags))
270 return hi->hi_flags;
271
272 /*
273 ** Horrible hack to work around problem with Lotus Notes SMTP
274 ** mail gateway, which generates From: headers with newlines in
275 ** them and the <address> on the second line. Although this is
276 ** legal RFC 822, many MUAs don't handle this properly and thus
277 ** never find the actual address.
278 */
279
280 if (bitset(H_FROM, hi->hi_flags) && SingleLineFromHeader)
281 {
282 while ((p = strchr(fvalue, '\n')) != NULL)
283 *p = ' ';
284 }
285
286 /*
287 ** If there is a check ruleset, verify it against the header.
288 */
289
290 if (bitset(pflag, CHHDR_CHECK))
291 {
292 int rscheckflags;
293 char *rs;
294
295 rscheckflags = RSF_COUNT;
296 if (!bitset(hi->hi_flags, H_FROM|H_RCPT))
297 rscheckflags |= RSF_UNSTRUCTURED;
298
299 /* no ruleset? look for default */
300 rs = hi->hi_ruleset;
301 if (rs == NULL)
302 {
303 s = stab("*", ST_HEADER, ST_FIND);
304 if (s != NULL)
305 {
306 rs = (&s->s_header)->hi_ruleset;
307 if (bitset((&s->s_header)->hi_flags,
308 H_STRIPCOMM))
309 rscheckflags |= RSF_RMCOMM;
310 }
311 }
312 else if (bitset(hi->hi_flags, H_STRIPCOMM))
313 rscheckflags |= RSF_RMCOMM;
314 if (rs != NULL)
315 {
316 int l, k;
317 char qval[MAXNAME];
318
319 l = 0;
320 qval[l++] = '"';
321
322 /* - 3 to avoid problems with " at the end */
323 /* should be sizeof(qval), not MAXNAME */
324 for (k = 0; fvalue[k] != '\0' && l < MAXNAME - 3; k++)
325 {
326 switch (fvalue[k])
327 {
328 /* XXX other control chars? */
329 case '\011': /* ht */
330 case '\012': /* nl */
331 case '\013': /* vt */
332 case '\014': /* np */
333 case '\015': /* cr */
334 qval[l++] = ' ';
335 break;
336 case '"':
337 qval[l++] = '\\';
338 /* FALLTHROUGH */
339 default:
340 qval[l++] = fvalue[k];
341 break;
342 }
343 }
344 qval[l++] = '"';
345 qval[l] = '\0';
346 k += strlen(fvalue + k);
347 if (k >= MAXNAME)
348 {
349 if (LogLevel > 9)
350 sm_syslog(LOG_WARNING, e->e_id,
351 "Warning: truncated header '%s' before check with '%s' len=%d max=%d",
352 fname, rs, k, MAXNAME - 1);
353 }
354 macdefine(&e->e_macro, A_TEMP,
355 macid("{currHeader}"), qval);
356 macdefine(&e->e_macro, A_TEMP,
357 macid("{hdr_name}"), fname);
358
359 (void) sm_snprintf(qval, sizeof qval, "%d", k);
360 macdefine(&e->e_macro, A_TEMP, macid("{hdrlen}"), qval);
361 #if _FFR_HDR_TYPE
362 if (bitset(H_FROM, hi->hi_flags))
363 macdefine(&e->e_macro, A_PERM,
364 macid("{addr_type}"), "h s");
365 else if (bitset(H_RCPT, hi->hi_flags))
366 macdefine(&e->e_macro, A_PERM,
367 macid("{addr_type}"), "h r");
368 else
369 #endif /* _FFR_HDR_TYPE */
370 macdefine(&e->e_macro, A_PERM,
371 macid("{addr_type}"), "h");
372 (void) rscheck(rs, fvalue, NULL, e, rscheckflags, 3,
373 NULL, e->e_id);
374 }
375 }
376
377 /*
378 ** Drop explicit From: if same as what we would generate.
379 ** This is to make MH (which doesn't always give a full name)
380 ** insert the full name information in all circumstances.
381 */
382
383 dropfrom = false;
384 p = "resent-from";
385 if (!bitset(EF_RESENT, e->e_flags))
386 p += 7;
387 if (!bitset(pflag, CHHDR_DEF) && !headeronly &&
388 !bitset(EF_QUEUERUN, e->e_flags) && sm_strcasecmp(fname, p) == 0)
389 {
390 if (tTd(31, 2))
391 {
392 sm_dprintf("comparing header from (%s) against default (%s or %s)\n",
393 fvalue, e->e_from.q_paddr, e->e_from.q_user);
394 }
395 if (e->e_from.q_paddr != NULL &&
396 e->e_from.q_mailer != NULL &&
397 bitnset(M_LOCALMAILER, e->e_from.q_mailer->m_flags) &&
398 (strcmp(fvalue, e->e_from.q_paddr) == 0 ||
399 strcmp(fvalue, e->e_from.q_user) == 0))
400 dropfrom = true;
401 }
402
403 /* delete default value for this header */
404 for (hp = hdrp; (h = *hp) != NULL; hp = &h->h_link)
405 {
406 if (sm_strcasecmp(fname, h->h_field) == 0 &&
407 !bitset(H_USER, h->h_flags) &&
408 !bitset(H_FORCE, h->h_flags))
409 {
410 if (nullheader)
411 {
412 /* user-supplied value was null */
413 return 0;
414 }
415 if (dropfrom)
416 {
417 /* make this look like the user entered it */
418 h->h_flags |= H_USER;
419 return hi->hi_flags;
420 }
421 h->h_value = NULL;
422 if (!cond)
423 {
424 /* copy conditions from default case */
425 memmove((char *) mopts, (char *) h->h_mflags,
426 sizeof mopts);
427 }
428 h->h_macro = mid;
429 }
430 }
431
432 /* create a new node */
433 h = (HDR *) sm_rpool_malloc_x(e->e_rpool, sizeof *h);
434 h->h_field = sm_rpool_strdup_x(e->e_rpool, fname);
435 h->h_value = sm_rpool_strdup_x(e->e_rpool, fvalue);
436 h->h_link = NULL;
437 memmove((char *) h->h_mflags, (char *) mopts, sizeof mopts);
438 h->h_macro = mid;
439 *hp = h;
440 h->h_flags = hi->hi_flags;
441 if (bitset(pflag, CHHDR_USER) || bitset(pflag, CHHDR_QUEUE))
442 h->h_flags |= H_USER;
443
444 /* strip EOH flag if parsing MIME headers */
445 if (headeronly)
446 h->h_flags &= ~H_EOH;
447 if (bitset(pflag, CHHDR_DEF))
448 h->h_flags |= H_DEFAULT;
449 if (cond || mid != '\0')
450 h->h_flags |= H_CHECK;
451
452 /* hack to see if this is a new format message */
453 if (!bitset(pflag, CHHDR_DEF) && !headeronly &&
454 bitset(H_RCPT|H_FROM, h->h_flags) &&
455 (strchr(fvalue, ',') != NULL || strchr(fvalue, '(') != NULL ||
456 strchr(fvalue, '<') != NULL || strchr(fvalue, ';') != NULL))
457 {
458 e->e_flags &= ~EF_OLDSTYLE;
459 }
460
461 return h->h_flags;
462 }
463 /*
464 ** ALLOCHEADER -- allocate a header entry
465 **
466 ** Parameters:
467 ** field -- the name of the header field.
468 ** value -- the value of the field.
469 ** flags -- flags to add to h_flags.
470 ** rp -- resource pool for allocations
471 **
472 ** Returns:
473 ** Pointer to a newly allocated and populated HDR.
474 */
475
476 static HDR *
477 allocheader(field, value, flags, rp)
478 char *field;
479 char *value;
480 int flags;
481 SM_RPOOL_T *rp;
482 {
483 HDR *h;
484 STAB *s;
485
486 /* find info struct */
487 s = stab(field, ST_HEADER, ST_FIND);
488
489 /* allocate space for new header */
490 h = (HDR *) sm_rpool_malloc_x(rp, sizeof *h);
491 h->h_field = field;
492 h->h_value = sm_rpool_strdup_x(rp, value);
493 h->h_flags = flags;
494 if (s != NULL)
495 h->h_flags |= s->s_header.hi_flags;
496 clrbitmap(h->h_mflags);
497 h->h_macro = '\0';
498
499 return h;
500 }
501 /*
502 ** ADDHEADER -- add a header entry to the end of the queue.
503 **
504 ** This bypasses the special checking of chompheader.
505 **
506 ** Parameters:
507 ** field -- the name of the header field.
508 ** value -- the value of the field.
509 ** flags -- flags to add to h_flags.
510 ** e -- envelope.
511 **
512 ** Returns:
513 ** none.
514 **
515 ** Side Effects:
516 ** adds the field on the list of headers for this envelope.
517 */
518
519 void
520 addheader(field, value, flags, e)
521 char *field;
522 char *value;
523 int flags;
524 ENVELOPE *e;
525 {
526 register HDR *h;
527 HDR **hp;
528 HDR **hdrlist = &e->e_header;
529
530 /* find current place in list -- keep back pointer? */
531 for (hp = hdrlist; (h = *hp) != NULL; hp = &h->h_link)
532 {
533 if (sm_strcasecmp(field, h->h_field) == 0)
534 break;
535 }
536
537 /* allocate space for new header */
538 h = allocheader(field, value, flags, e->e_rpool);
539 h->h_link = *hp;
540 *hp = h;
541 }
542 /*
543 ** INSHEADER -- insert a header entry at the specified index
544 **
545 ** This bypasses the special checking of chompheader.
546 **
547 ** Parameters:
548 ** idx -- index into the header list at which to insert
549 ** field -- the name of the header field.
550 ** value -- the value of the field.
551 ** flags -- flags to add to h_flags.
552 ** e -- envelope.
553 **
554 ** Returns:
555 ** none.
556 **
557 ** Side Effects:
558 ** inserts the field on the list of headers for this envelope.
559 */
560
561 void
562 insheader(idx, field, value, flags, e)
563 int idx;
564 char *field;
565 char *value;
566 int flags;
567 ENVELOPE *e;
568 {
569 HDR *h, *srch, *last = NULL;
570
571 /* allocate space for new header */
572 h = allocheader(field, value, flags, e->e_rpool);
573
574 /* find insertion position */
575 for (srch = e->e_header; srch != NULL && idx > 0;
576 srch = srch->h_link, idx--)
577 last = srch;
578
579 if (e->e_header == NULL)
580 {
581 e->e_header = h;
582 h->h_link = NULL;
583 }
584 else if (srch == NULL)
585 {
586 SM_ASSERT(last != NULL);
587 last->h_link = h;
588 h->h_link = NULL;
589 }
590 else
591 {
592 h->h_link = srch->h_link;
593 srch->h_link = h;
594 }
595 }
596 /*
597 ** HVALUE -- return value of a header.
598 **
599 ** Only "real" fields (i.e., ones that have not been supplied
600 ** as a default) are used.
601 **
602 ** Parameters:
603 ** field -- the field name.
604 ** header -- the header list.
605 **
606 ** Returns:
607 ** pointer to the value part.
608 ** NULL if not found.
609 **
610 ** Side Effects:
611 ** none.
612 */
613
614 char *
615 hvalue(field, header)
616 char *field;
617 HDR *header;
618 {
619 register HDR *h;
620
621 for (h = header; h != NULL; h = h->h_link)
622 {
623 if (!bitset(H_DEFAULT, h->h_flags) &&
624 sm_strcasecmp(h->h_field, field) == 0)
625 return h->h_value;
626 }
627 return NULL;
628 }
629 /*
630 ** ISHEADER -- predicate telling if argument is a header.
631 **
632 ** A line is a header if it has a single word followed by
633 ** optional white space followed by a colon.
634 **
635 ** Header fields beginning with two dashes, although technically
636 ** permitted by RFC822, are automatically rejected in order
637 ** to make MIME work out. Without this we could have a technically
638 ** legal header such as ``--"foo:bar"'' that would also be a legal
639 ** MIME separator.
640 **
641 ** Parameters:
642 ** h -- string to check for possible headerness.
643 **
644 ** Returns:
645 ** true if h is a header.
646 ** false otherwise.
647 **
648 ** Side Effects:
649 ** none.
650 */
651
652 bool
653 isheader(h)
654 char *h;
655 {
656 register char *s = h;
657
658 if (s[0] == '-' && s[1] == '-')
659 return false;
660
661 while (*s > ' ' && *s != ':' && *s != '\0')
662 s++;
663
664 if (h == s)
665 return false;
666
667 /* following technically violates RFC822 */
668 while (isascii(*s) && isspace(*s))
669 s++;
670
671 return (*s == ':');
672 }
673 /*
674 ** EATHEADER -- run through the stored header and extract info.
675 **
676 ** Parameters:
677 ** e -- the envelope to process.
678 ** full -- if set, do full processing (e.g., compute
679 ** message priority). This should not be set
680 ** when reading a queue file because some info
681 ** needed to compute the priority is wrong.
682 ** log -- call logsender()?
683 **
684 ** Returns:
685 ** none.
686 **
687 ** Side Effects:
688 ** Sets a bunch of global variables from information
689 ** in the collected header.
690 */
691
692 void
693 eatheader(e, full, log)
694 register ENVELOPE *e;
695 bool full;
696 bool log;
697 {
698 register HDR *h;
699 register char *p;
700 int hopcnt = 0;
701 char buf[MAXLINE];
702
703 /*
704 ** Set up macros for possible expansion in headers.
705 */
706
707 macdefine(&e->e_macro, A_PERM, 'f', e->e_sender);
708 macdefine(&e->e_macro, A_PERM, 'g', e->e_sender);
709 if (e->e_origrcpt != NULL && *e->e_origrcpt != '\0')
710 macdefine(&e->e_macro, A_PERM, 'u', e->e_origrcpt);
711 else
712 macdefine(&e->e_macro, A_PERM, 'u', NULL);
713
714 /* full name of from person */
715 p = hvalue("full-name", e->e_header);
716 if (p != NULL)
717 {
718 if (!rfc822_string(p))
719 {
720 /*
721 ** Quote a full name with special characters
722 ** as a comment so crackaddr() doesn't destroy
723 ** the name portion of the address.
724 */
725
726 p = addquotes(p, e->e_rpool);
727 }
728 macdefine(&e->e_macro, A_PERM, 'x', p);
729 }
730
731 if (tTd(32, 1))
732 sm_dprintf("----- collected header -----\n");
733 e->e_msgid = NULL;
734 for (h = e->e_header; h != NULL; h = h->h_link)
735 {
736 if (tTd(32, 1))
737 sm_dprintf("%s: ", h->h_field);
738 if (h->h_value == NULL)
739 {
740 if (tTd(32, 1))
741 sm_dprintf("<NULL>\n");
742 continue;
743 }
744
745 /* do early binding */
746 if (bitset(H_DEFAULT, h->h_flags) &&
747 !bitset(H_BINDLATE, h->h_flags))
748 {
749 if (tTd(32, 1))
750 {
751 sm_dprintf("(");
752 xputs(sm_debug_file(), h->h_value);
753 sm_dprintf(") ");
754 }
755 expand(h->h_value, buf, sizeof buf, e);
756 if (buf[0] != '\0')
757 {
758 if (bitset(H_FROM, h->h_flags))
759 expand(crackaddr(buf, e),
760 buf, sizeof buf, e);
761 h->h_value = sm_rpool_strdup_x(e->e_rpool, buf);
762 h->h_flags &= ~H_DEFAULT;
763 }
764 }
765 if (tTd(32, 1))
766 {
767 xputs(sm_debug_file(), h->h_value);
768 sm_dprintf("\n");
769 }
770
771 /* count the number of times it has been processed */
772 if (bitset(H_TRACE, h->h_flags))
773 hopcnt++;
774
775 /* send to this person if we so desire */
776 if (GrabTo && bitset(H_RCPT, h->h_flags) &&
777 !bitset(H_DEFAULT, h->h_flags) &&
778 (!bitset(EF_RESENT, e->e_flags) ||
779 bitset(H_RESENT, h->h_flags)))
780 {
781 #if 0
782 int saveflags = e->e_flags;
783 #endif /* 0 */
784
785 (void) sendtolist(denlstring(h->h_value, true, false),
786 NULLADDR, &e->e_sendqueue, 0, e);
787
788 #if 0
789 /*
790 ** Change functionality so a fatal error on an
791 ** address doesn't affect the entire envelope.
792 */
793
794 /* delete fatal errors generated by this address */
795 if (!bitset(EF_FATALERRS, saveflags))
796 e->e_flags &= ~EF_FATALERRS;
797 #endif /* 0 */
798 }
799
800 /* save the message-id for logging */
801 p = "resent-message-id";
802 if (!bitset(EF_RESENT, e->e_flags))
803 p += 7;
804 if (sm_strcasecmp(h->h_field, p) == 0)
805 {
806 e->e_msgid = h->h_value;
807 while (isascii(*e->e_msgid) && isspace(*e->e_msgid))
808 e->e_msgid++;
809 macdefine(&e->e_macro, A_PERM, macid("{msg_id}"),
810 e->e_msgid);
811 }
812 }
813 if (tTd(32, 1))
814 sm_dprintf("----------------------------\n");
815
816 /* if we are just verifying (that is, sendmail -t -bv), drop out now */
817 if (OpMode == MD_VERIFY)
818 return;
819
820 /* store hop count */
821 if (hopcnt > e->e_hopcount)
822 {
823 e->e_hopcount = hopcnt;
824 (void) sm_snprintf(buf, sizeof buf, "%d", e->e_hopcount);
825 macdefine(&e->e_macro, A_TEMP, 'c', buf);
826 }
827
828 /* message priority */
829 p = hvalue("precedence", e->e_header);
830 if (p != NULL)
831 e->e_class = priencode(p);
832 if (e->e_class < 0)
833 e->e_timeoutclass = TOC_NONURGENT;
834 else if (e->e_class > 0)
835 e->e_timeoutclass = TOC_URGENT;
836 if (full)
837 {
838 e->e_msgpriority = e->e_msgsize
839 - e->e_class * WkClassFact
840 + e->e_nrcpts * WkRecipFact;
841 }
842
843 /* check for DSN to properly set e_timeoutclass */
844 p = hvalue("content-type", e->e_header);
845 if (p != NULL)
846 {
847 bool oldsupr;
848 char **pvp;
849 char pvpbuf[MAXLINE];
850 extern unsigned char MimeTokenTab[256];
851
852 /* tokenize header */
853 oldsupr = SuprErrs;
854 SuprErrs = true;
855 pvp = prescan(p, '\0', pvpbuf, sizeof pvpbuf, NULL,
856 MimeTokenTab, false);
857 SuprErrs = oldsupr;
858
859 /* Check if multipart/report */
860 if (pvp != NULL && pvp[0] != NULL &&
861 pvp[1] != NULL && pvp[2] != NULL &&
862 sm_strcasecmp(*pvp++, "multipart") == 0 &&
863 strcmp(*pvp++, "/") == 0 &&
864 sm_strcasecmp(*pvp++, "report") == 0)
865 {
866 /* Look for report-type=delivery-status */
867 while (*pvp != NULL)
868 {
869 /* skip to semicolon separator */
870 while (*pvp != NULL && strcmp(*pvp, ";") != 0)
871 pvp++;
872
873 /* skip semicolon */
874 if (*pvp++ == NULL || *pvp == NULL)
875 break;
876
877 /* look for report-type */
878 if (sm_strcasecmp(*pvp++, "report-type") != 0)
879 continue;
880
881 /* skip equal */
882 if (*pvp == NULL || strcmp(*pvp, "=") != 0)
883 continue;
884
885 /* check value */
886 if (*++pvp != NULL &&
887 sm_strcasecmp(*pvp,
888 "delivery-status") == 0)
889 e->e_timeoutclass = TOC_DSN;
890
891 /* found report-type, no need to continue */
892 break;
893 }
894 }
895 }
896
897 /* message timeout priority */
898 p = hvalue("priority", e->e_header);
899 if (p != NULL)
900 {
901 /* (this should be in the configuration file) */
902 if (sm_strcasecmp(p, "urgent") == 0)
903 e->e_timeoutclass = TOC_URGENT;
904 else if (sm_strcasecmp(p, "normal") == 0)
905 e->e_timeoutclass = TOC_NORMAL;
906 else if (sm_strcasecmp(p, "non-urgent") == 0)
907 e->e_timeoutclass = TOC_NONURGENT;
908 else if (bitset(EF_RESPONSE, e->e_flags))
909 e->e_timeoutclass = TOC_DSN;
910 }
911 else if (bitset(EF_RESPONSE, e->e_flags))
912 e->e_timeoutclass = TOC_DSN;
913
914 /* date message originated */
915 p = hvalue("posted-date", e->e_header);
916 if (p == NULL)
917 p = hvalue("date", e->e_header);
918 if (p != NULL)
919 macdefine(&e->e_macro, A_PERM, 'a', p);
920
921 /* check to see if this is a MIME message */
922 if ((e->e_bodytype != NULL &&
923 sm_strcasecmp(e->e_bodytype, "8BITMIME") == 0) ||
924 hvalue("MIME-Version", e->e_header) != NULL)
925 {
926 e->e_flags |= EF_IS_MIME;
927 if (HasEightBits)
928 e->e_bodytype = "8BITMIME";
929 }
930 else if ((p = hvalue("Content-Type", e->e_header)) != NULL)
931 {
932 /* this may be an RFC 1049 message */
933 p = strpbrk(p, ";/");
934 if (p == NULL || *p == ';')
935 {
936 /* yep, it is */
937 e->e_flags |= EF_DONT_MIME;
938 }
939 }
940
941 /*
942 ** From person in antiquated ARPANET mode
943 ** required by UK Grey Book e-mail gateways (sigh)
944 */
945
946 if (OpMode == MD_ARPAFTP)
947 {
948 register struct hdrinfo *hi;
949
950 for (hi = HdrInfo; hi->hi_field != NULL; hi++)
951 {
952 if (bitset(H_FROM, hi->hi_flags) &&
953 (!bitset(H_RESENT, hi->hi_flags) ||
954 bitset(EF_RESENT, e->e_flags)) &&
955 (p = hvalue(hi->hi_field, e->e_header)) != NULL)
956 break;
957 }
958 if (hi->hi_field != NULL)
959 {
960 if (tTd(32, 2))
961 sm_dprintf("eatheader: setsender(*%s == %s)\n",
962 hi->hi_field, p);
963 setsender(p, e, NULL, '\0', true);
964 }
965 }
966
967 /*
968 ** Log collection information.
969 */
970
971 if (log && bitset(EF_LOGSENDER, e->e_flags) && LogLevel > 4)
972 {
973 logsender(e, e->e_msgid);
974 e->e_flags &= ~EF_LOGSENDER;
975 }
976 }
977 /*
978 ** LOGSENDER -- log sender information
979 **
980 ** Parameters:
981 ** e -- the envelope to log
982 ** msgid -- the message id
983 **
984 ** Returns:
985 ** none
986 */
987
988 void
989 logsender(e, msgid)
990 register ENVELOPE *e;
991 char *msgid;
992 {
993 char *name;
994 register char *sbp;
995 register char *p;
996 char hbuf[MAXNAME + 1];
997 char sbuf[MAXLINE + 1];
998 char mbuf[MAXNAME + 1];
999
1000 /* don't allow newlines in the message-id */
1001 /* XXX do we still need this? sm_syslog() replaces control chars */
1002 if (msgid != NULL)
1003 {
1004 size_t l;
1005
1006 l = strlen(msgid);
1007 if (l > sizeof mbuf - 1)
1008 l = sizeof mbuf - 1;
1009 memmove(mbuf, msgid, l);
1010 mbuf[l] = '\0';
1011 p = mbuf;
1012 while ((p = strchr(p, '\n')) != NULL)
1013 *p++ = ' ';
1014 }
1015
1016 if (bitset(EF_RESPONSE, e->e_flags))
1017 name = "[RESPONSE]";
1018 else if ((name = macvalue('_', e)) != NULL)
1019 /* EMPTY */
1020 ;
1021 else if (RealHostName == NULL)
1022 name = "localhost";
1023 else if (RealHostName[0] == '[')
1024 name = RealHostName;
1025 else
1026 {
1027 name = hbuf;
1028 (void) sm_snprintf(hbuf, sizeof hbuf, "%.80s", RealHostName);
1029 if (RealHostAddr.sa.sa_family != 0)
1030 {
1031 p = &hbuf[strlen(hbuf)];
1032 (void) sm_snprintf(p, SPACELEFT(hbuf, p),
1033 " (%.100s)",
1034 anynet_ntoa(&RealHostAddr));
1035 }
1036 }
1037
1038 /* some versions of syslog only take 5 printf args */
1039 #if (SYSLOG_BUFSIZE) >= 256
1040 sbp = sbuf;
1041 (void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
1042 "from=%.200s, size=%ld, class=%d, nrcpts=%d",
1043 e->e_from.q_paddr == NULL ? "<NONE>" : e->e_from.q_paddr,
1044 e->e_msgsize, e->e_class, e->e_nrcpts);
1045 sbp += strlen(sbp);
1046 if (msgid != NULL)
1047 {
1048 (void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
1049 ", msgid=%.100s", mbuf);
1050 sbp += strlen(sbp);
1051 }
1052 if (e->e_bodytype != NULL)
1053 {
1054 (void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
1055 ", bodytype=%.20s", e->e_bodytype);
1056 sbp += strlen(sbp);
1057 }
1058 p = macvalue('r', e);
1059 if (p != NULL)
1060 {
1061 (void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
1062 ", proto=%.20s", p);
1063 sbp += strlen(sbp);
1064 }
1065 p = macvalue(macid("{daemon_name}"), e);
1066 if (p != NULL)
1067 {
1068 (void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
1069 ", daemon=%.20s", p);
1070 sbp += strlen(sbp);
1071 }
1072 sm_syslog(LOG_INFO, e->e_id, "%.850s, relay=%s", sbuf, name);
1073
1074 #else /* (SYSLOG_BUFSIZE) >= 256 */
1075
1076 sm_syslog(LOG_INFO, e->e_id,
1077 "from=%s",
1078 e->e_from.q_paddr == NULL ? "<NONE>"
1079 : shortenstring(e->e_from.q_paddr,
1080 83));
1081 sm_syslog(LOG_INFO, e->e_id,
1082 "size=%ld, class=%ld, nrcpts=%d",
1083 e->e_msgsize, e->e_class, e->e_nrcpts);
1084 if (msgid != NULL)
1085 sm_syslog(LOG_INFO, e->e_id,
1086 "msgid=%s",
1087 shortenstring(mbuf, 83));
1088 sbp = sbuf;
1089 *sbp = '\0';
1090 if (e->e_bodytype != NULL)
1091 {
1092 (void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
1093 "bodytype=%.20s, ", e->e_bodytype);
1094 sbp += strlen(sbp);
1095 }
1096 p = macvalue('r', e);
1097 if (p != NULL)
1098 {
1099 (void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
1100 "proto=%.20s, ", p);
1101 sbp += strlen(sbp);
1102 }
1103 sm_syslog(LOG_INFO, e->e_id,
1104 "%.400srelay=%s", sbuf, name);
1105 #endif /* (SYSLOG_BUFSIZE) >= 256 */
1106 }
1107 /*
1108 ** PRIENCODE -- encode external priority names into internal values.
1109 **
1110 ** Parameters:
1111 ** p -- priority in ascii.
1112 **
1113 ** Returns:
1114 ** priority as a numeric level.
1115 **
1116 ** Side Effects:
1117 ** none.
1118 */
1119
1120 static int
1121 priencode(p)
1122 char *p;
1123 {
1124 register int i;
1125
1126 for (i = 0; i < NumPriorities; i++)
1127 {
1128 if (sm_strcasecmp(p, Priorities[i].pri_name) == 0)
1129 return Priorities[i].pri_val;
1130 }
1131
1132 /* unknown priority */
1133 return 0;
1134 }
1135 /*
1136 ** CRACKADDR -- parse an address and turn it into a macro
1137 **
1138 ** This doesn't actually parse the address -- it just extracts
1139 ** it and replaces it with "$g". The parse is totally ad hoc
1140 ** and isn't even guaranteed to leave something syntactically
1141 ** identical to what it started with. However, it does leave
1142 ** something semantically identical if possible, else at least
1143 ** syntactically correct.
1144 **
1145 ** For example, it changes "Real Name <real@example.com> (Comment)"
1146 ** to "Real Name <$g> (Comment)".
1147 **
1148 ** This algorithm has been cleaned up to handle a wider range
1149 ** of cases -- notably quoted and backslash escaped strings.
1150 ** This modification makes it substantially better at preserving
1151 ** the original syntax.
1152 **
1153 ** Parameters:
1154 ** addr -- the address to be cracked.
1155 ** e -- the current envelope.
1156 **
1157 ** Returns:
1158 ** a pointer to the new version.
1159 **
1160 ** Side Effects:
1161 ** none.
1162 **
1163 ** Warning:
1164 ** The return value is saved in local storage and should
1165 ** be copied if it is to be reused.
1166 */
1167
1168 #define SM_HAVE_ROOM ((bp < buflim) && (buflim <= bufend))
1169
1170 /*
1171 ** Append a character to bp if we have room.
1172 ** If not, punt and return $g.
1173 */
1174
1175 #define SM_APPEND_CHAR(c) \
1176 do \
1177 { \
1178 if (SM_HAVE_ROOM) \
1179 *bp++ = (c); \
1180 else \
1181 goto returng; \
1182 } while (0)
1183
1184 #if MAXNAME < 10
1185 ERROR MAXNAME must be at least 10
1186 #endif /* MAXNAME < 10 */
1187
1188 char *
1189 crackaddr(addr, e)
1190 register char *addr;
1191 ENVELOPE *e;
1192 {
1193 register char *p;
1194 register char c;
1195 int cmtlev; /* comment level in input string */
1196 int realcmtlev; /* comment level in output string */
1197 int anglelev; /* angle level in input string */
1198 int copylev; /* 0 == in address, >0 copying */
1199 int bracklev; /* bracket level for IPv6 addr check */
1200 bool addangle; /* put closing angle in output */
1201 bool qmode; /* quoting in original string? */
1202 bool realqmode; /* quoting in output string? */
1203 bool putgmac = false; /* already wrote $g */
1204 bool quoteit = false; /* need to quote next character */
1205 bool gotangle = false; /* found first '<' */
1206 bool gotcolon = false; /* found a ':' */
1207 register char *bp;
1208 char *buflim;
1209 char *bufhead;
1210 char *addrhead;
1211 char *bufend;
1212 static char buf[MAXNAME + 1];
1213
1214 if (tTd(33, 1))
1215 sm_dprintf("crackaddr(%s)\n", addr);
1216
1217 /* strip leading spaces */
1218 while (*addr != '\0' && isascii(*addr) && isspace(*addr))
1219 addr++;
1220
1221 /*
1222 ** Start by assuming we have no angle brackets. This will be
1223 ** adjusted later if we find them.
1224 */
1225
1226 buflim = bufend = &buf[sizeof(buf) - 1];
1227 bp = bufhead = buf;
1228 p = addrhead = addr;
1229 copylev = anglelev = cmtlev = realcmtlev = 0;
1230 bracklev = 0;
1231 qmode = realqmode = addangle = false;
1232
1233 while ((c = *p++) != '\0')
1234 {
1235 /*
1236 ** Try to keep legal syntax using spare buffer space
1237 ** (maintained by buflim).
1238 */
1239
1240 if (copylev > 0)
1241 SM_APPEND_CHAR(c);
1242
1243 /* check for backslash escapes */
1244 if (c == '\\')
1245 {
1246 /* arrange to quote the address */
1247 if (cmtlev <= 0 && !qmode)
1248 quoteit = true;
1249
1250 if ((c = *p++) == '\0')
1251 {
1252 /* too far */
1253 p--;
1254 goto putg;
1255 }
1256 if (copylev > 0)
1257 SM_APPEND_CHAR(c);
1258 goto putg;
1259 }
1260
1261 /* check for quoted strings */
1262 if (c == '"' && cmtlev <= 0)
1263 {
1264 qmode = !qmode;
1265 if (copylev > 0 && SM_HAVE_ROOM)
1266 {
1267 if (realqmode)
1268 buflim--;
1269 else
1270 buflim++;
1271 realqmode = !realqmode;
1272 }
1273 continue;
1274 }
1275 if (qmode)
1276 goto putg;
1277
1278 /* check for comments */
1279 if (c == '(')
1280 {
1281 cmtlev++;
1282
1283 /* allow space for closing paren */
1284 if (SM_HAVE_ROOM)
1285 {
1286 buflim--;
1287 realcmtlev++;
1288 if (copylev++ <= 0)
1289 {
1290 if (bp != bufhead)
1291 SM_APPEND_CHAR(' ');
1292 SM_APPEND_CHAR(c);
1293 }
1294 }
1295 }
1296 if (cmtlev > 0)
1297 {
1298 if (c == ')')
1299 {
1300 cmtlev--;
1301 copylev--;
1302 if (SM_HAVE_ROOM)
1303 {
1304 realcmtlev--;
1305 buflim++;
1306 }
1307 }
1308 continue;
1309 }
1310 else if (c == ')')
1311 {
1312 /* syntax error: unmatched ) */
1313 if (copylev > 0 && SM_HAVE_ROOM && bp > bufhead)
1314 bp--;
1315 }
1316
1317 /* count nesting on [ ... ] (for IPv6 domain literals) */
1318 if (c == '[')
1319 bracklev++;
1320 else if (c == ']')
1321 bracklev--;
1322
1323 /* check for group: list; syntax */
1324 if (c == ':' && anglelev <= 0 && bracklev <= 0 &&
1325 !gotcolon && !ColonOkInAddr)
1326 {
1327 register char *q;
1328
1329 /*
1330 ** Check for DECnet phase IV ``::'' (host::user)
1331 ** or DECnet phase V ``:.'' syntaxes. The latter
1332 ** covers ``user@DEC:.tay.myhost'' and
1333 ** ``DEC:.tay.myhost::user'' syntaxes (bletch).
1334 */
1335
1336 if (*p == ':' || *p == '.')
1337 {
1338 if (cmtlev <= 0 && !qmode)
1339 quoteit = true;
1340 if (copylev > 0)
1341 {
1342 SM_APPEND_CHAR(c);
1343 SM_APPEND_CHAR(*p);
1344 }
1345 p++;
1346 goto putg;
1347 }
1348
1349 gotcolon = true;
1350
1351 bp = bufhead;
1352 if (quoteit)
1353 {
1354 SM_APPEND_CHAR('"');
1355
1356 /* back up over the ':' and any spaces */
1357 --p;
1358 while (p > addr &&
1359 isascii(*--p) && isspace(*p))
1360 continue;
1361 p++;
1362 }
1363 for (q = addrhead; q < p; )
1364 {
1365 c = *q++;
1366 if (quoteit && c == '"')
1367 SM_APPEND_CHAR('\\');
1368 SM_APPEND_CHAR(c);
1369 }
1370 if (quoteit)
1371 {
1372 if (bp == &bufhead[1])
1373 bp--;
1374 else
1375 SM_APPEND_CHAR('"');
1376 while ((c = *p++) != ':')
1377 SM_APPEND_CHAR(c);
1378 SM_APPEND_CHAR(c);
1379 }
1380
1381 /* any trailing white space is part of group: */
1382 while (isascii(*p) && isspace(*p))
1383 {
1384 SM_APPEND_CHAR(*p);
1385 p++;
1386 }
1387 copylev = 0;
1388 putgmac = quoteit = false;
1389 bufhead = bp;
1390 addrhead = p;
1391 continue;
1392 }
1393
1394 if (c == ';' && copylev <= 0 && !ColonOkInAddr)
1395 SM_APPEND_CHAR(c);
1396
1397 /* check for characters that may have to be quoted */
1398 if (strchr(MustQuoteChars, c) != NULL)
1399 {
1400 /*
1401 ** If these occur as the phrase part of a <>
1402 ** construct, but are not inside of () or already
1403 ** quoted, they will have to be quoted. Note that
1404 ** now (but don't actually do the quoting).
1405 */
1406
1407 if (cmtlev <= 0 && !qmode)
1408 quoteit = true;
1409 }
1410
1411 /* check for angle brackets */
1412 if (c == '<')
1413 {
1414 register char *q;
1415
1416 /* assume first of two angles is bogus */
1417 if (gotangle)
1418 quoteit = true;
1419 gotangle = true;
1420
1421 /* oops -- have to change our mind */
1422 anglelev = 1;
1423 if (SM_HAVE_ROOM)
1424 {
1425 if (!addangle)
1426 buflim--;
1427 addangle = true;
1428 }
1429
1430 bp = bufhead;
1431 if (quoteit)
1432 {
1433 SM_APPEND_CHAR('"');
1434
1435 /* back up over the '<' and any spaces */
1436 --p;
1437 while (p > addr &&
1438 isascii(*--p) && isspace(*p))
1439 continue;
1440 p++;
1441 }
1442 for (q = addrhead; q < p; )
1443 {
1444 c = *q++;
1445 if (quoteit && c == '"')
1446 {
1447 SM_APPEND_CHAR('\\');
1448 SM_APPEND_CHAR(c);
1449 }
1450 else
1451 SM_APPEND_CHAR(c);
1452 }
1453 if (quoteit)
1454 {
1455 if (bp == &buf[1])
1456 bp--;
1457 else
1458 SM_APPEND_CHAR('"');
1459 while ((c = *p++) != '<')
1460 SM_APPEND_CHAR(c);
1461 SM_APPEND_CHAR(c);
1462 }
1463 copylev = 0;
1464 putgmac = quoteit = false;
1465 continue;
1466 }
1467
1468 if (c == '>')
1469 {
1470 if (anglelev > 0)
1471 {
1472 anglelev--;
1473 if (SM_HAVE_ROOM)
1474 {
1475 if (addangle)
1476 buflim++;
1477 addangle = false;
1478 }
1479 }
1480 else if (SM_HAVE_ROOM)
1481 {
1482 /* syntax error: unmatched > */
1483 if (copylev > 0 && bp > bufhead)
1484 bp--;
1485 quoteit = true;
1486 continue;
1487 }
1488 if (copylev++ <= 0)
1489 SM_APPEND_CHAR(c);
1490 continue;
1491 }
1492
1493 /* must be a real address character */
1494 putg:
1495 if (copylev <= 0 && !putgmac)
1496 {
1497 if (bp > buf && bp[-1] == ')')
1498 SM_APPEND_CHAR(' ');
1499 SM_APPEND_CHAR(MACROEXPAND);
1500 SM_APPEND_CHAR('g');
1501 putgmac = true;
1502 }
1503 }
1504
1505 /* repair any syntactic damage */
1506 if (realqmode && bp < bufend)
1507 *bp++ = '"';
1508 while (realcmtlev-- > 0 && bp < bufend)
1509 *bp++ = ')';
1510 if (addangle && bp < bufend)
1511 *bp++ = '>';
1512 *bp = '\0';
1513 if (bp < bufend)
1514 goto success;
1515
1516 returng:
1517 /* String too long, punt */
1518 buf[0] = '<';
1519 buf[1] = MACROEXPAND;
1520 buf[2]= 'g';
1521 buf[3] = '>';
1522 buf[4]= '\0';
1523 sm_syslog(LOG_ALERT, e->e_id,
1524 "Dropped invalid comments from header address");
1525
1526 success:
1527 if (tTd(33, 1))
1528 {
1529 sm_dprintf("crackaddr=>`");
1530 xputs(sm_debug_file(), buf);
1531 sm_dprintf("'\n");
1532 }
1533 return buf;
1534 }
1535 /*
1536 ** PUTHEADER -- put the header part of a message from the in-core copy
1537 **
1538 ** Parameters:
1539 ** mci -- the connection information.
1540 ** hdr -- the header to put.
1541 ** e -- envelope to use.
1542 ** flags -- MIME conversion flags.
1543 **
1544 ** Returns:
1545 ** true iff header part was written successfully
1546 **
1547 ** Side Effects:
1548 ** none.
1549 */
1550
1551 bool
1552 putheader(mci, hdr, e, flags)
1553 register MCI *mci;
1554 HDR *hdr;
1555 register ENVELOPE *e;
1556 int flags;
1557 {
1558 register HDR *h;
1559 char buf[SM_MAX(MAXLINE,BUFSIZ)];
1560 char obuf[MAXLINE];
1561
1562 if (tTd(34, 1))
1563 sm_dprintf("--- putheader, mailer = %s ---\n",
1564 mci->mci_mailer->m_name);
1565
1566 /*
1567 ** If we're in MIME mode, we're not really in the header of the
1568 ** message, just the header of one of the parts of the body of
1569 ** the message. Therefore MCIF_INHEADER should not be turned on.
1570 */
1571
1572 if (!bitset(MCIF_INMIME, mci->mci_flags))
1573 mci->mci_flags |= MCIF_INHEADER;
1574
1575 for (h = hdr; h != NULL; h = h->h_link)
1576 {
1577 register char *p = h->h_value;
1578 char *q;
1579
1580 if (tTd(34, 11))
1581 {
1582 sm_dprintf(" %s: ", h->h_field);
1583 xputs(sm_debug_file(), p);
1584 }
1585
1586 /* Skip empty headers */
1587 if (h->h_value == NULL)
1588 continue;
1589
1590 /* heuristic shortening of MIME fields to avoid MUA overflows */
1591 if (MaxMimeFieldLength > 0 &&
1592 wordinclass(h->h_field,
1593 macid("{checkMIMEFieldHeaders}")))
1594 {
1595 size_t len;
1596
1597 len = fix_mime_header(h, e);
1598 if (len > 0)
1599 {
1600 sm_syslog(LOG_ALERT, e->e_id,
1601 "Truncated MIME %s header due to field size (length = %ld) (possible attack)",
1602 h->h_field, (unsigned long) len);
1603 if (tTd(34, 11))
1604 sm_dprintf(" truncated MIME %s header due to field size (length = %ld) (possible attack)\n",
1605 h->h_field,
1606 (unsigned long) len);
1607 }
1608 }
1609
1610 if (MaxMimeHeaderLength > 0 &&
1611 wordinclass(h->h_field,
1612 macid("{checkMIMETextHeaders}")))
1613 {
1614 size_t len;
1615
1616 len = strlen(h->h_value);
1617 if (len > (size_t) MaxMimeHeaderLength)
1618 {
1619 h->h_value[MaxMimeHeaderLength - 1] = '\0';
1620 sm_syslog(LOG_ALERT, e->e_id,
1621 "Truncated long MIME %s header (length = %ld) (possible attack)",
1622 h->h_field, (unsigned long) len);
1623 if (tTd(34, 11))
1624 sm_dprintf(" truncated long MIME %s header (length = %ld) (possible attack)\n",
1625 h->h_field,
1626 (unsigned long) len);
1627 }
1628 }
1629
1630 if (MaxMimeHeaderLength > 0 &&
1631 wordinclass(h->h_field,
1632 macid("{checkMIMEHeaders}")))
1633 {
1634 size_t len;
1635
1636 len = strlen(h->h_value);
1637 if (shorten_rfc822_string(h->h_value,
1638 MaxMimeHeaderLength))
1639 {
1640 if (len < MaxMimeHeaderLength)
1641 {
1642 /* we only rebalanced a bogus header */
1643 sm_syslog(LOG_ALERT, e->e_id,
1644 "Fixed MIME %s header (possible attack)",
1645 h->h_field);
1646 if (tTd(34, 11))
1647 sm_dprintf(" fixed MIME %s header (possible attack)\n",
1648 h->h_field);
1649 }
1650 else
1651 {
1652 /* we actually shortened header */
1653 sm_syslog(LOG_ALERT, e->e_id,
1654 "Truncated long MIME %s header (length = %ld) (possible attack)",
1655 h->h_field,
1656 (unsigned long) len);
1657 if (tTd(34, 11))
1658 sm_dprintf(" truncated long MIME %s header (length = %ld) (possible attack)\n",
1659 h->h_field,
1660 (unsigned long) len);
1661 }
1662 }
1663 }
1664
1665 /*
1666 ** Suppress Content-Transfer-Encoding: if we are MIMEing
1667 ** and we are potentially converting from 8 bit to 7 bit
1668 ** MIME. If converting, add a new CTE header in
1669 ** mime8to7().
1670 */
1671
1672 if (bitset(H_CTE, h->h_flags) &&
1673 bitset(MCIF_CVT8TO7|MCIF_CVT7TO8|MCIF_INMIME,
1674 mci->mci_flags) &&
1675 !bitset(M87F_NO8TO7, flags))
1676 {
1677 if (tTd(34, 11))
1678 sm_dprintf(" (skipped (content-transfer-encoding))\n");
1679 continue;
1680 }
1681
1682 if (bitset(MCIF_INMIME, mci->mci_flags))
1683 {
1684 if (tTd(34, 11))
1685 sm_dprintf("\n");
1686 if (!put_vanilla_header(h, p, mci))
1687 goto writeerr;
1688 continue;
1689 }
1690
1691 if (bitset(H_CHECK|H_ACHECK, h->h_flags) &&
1692 !bitintersect(h->h_mflags, mci->mci_mailer->m_flags) &&
1693 (h->h_macro == '\0' ||
1694 (q = macvalue(bitidx(h->h_macro), e)) == NULL ||
1695 *q == '\0'))
1696 {
1697 if (tTd(34, 11))
1698 sm_dprintf(" (skipped)\n");
1699 continue;
1700 }
1701
1702 /* handle Resent-... headers specially */
1703 if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags))
1704 {
1705 if (tTd(34, 11))
1706 sm_dprintf(" (skipped (resent))\n");
1707 continue;
1708 }
1709
1710 /* suppress return receipts if requested */
1711 if (bitset(H_RECEIPTTO, h->h_flags) &&
1712 (RrtImpliesDsn || bitset(EF_NORECEIPT, e->e_flags)))
1713 {
1714 if (tTd(34, 11))
1715 sm_dprintf(" (skipped (receipt))\n");
1716 continue;
1717 }
1718
1719 /* macro expand value if generated internally */
1720 if (bitset(H_DEFAULT, h->h_flags) ||
1721 bitset(H_BINDLATE, h->h_flags))
1722 {
1723 expand(p, buf, sizeof buf, e);
1724 p = buf;
1725 if (*p == '\0')
1726 {
1727 if (tTd(34, 11))
1728 sm_dprintf(" (skipped -- null value)\n");
1729 continue;
1730 }
1731 }
1732
1733 if (bitset(H_BCC, h->h_flags))
1734 {
1735 /* Bcc: field -- either truncate or delete */
1736 if (bitset(EF_DELETE_BCC, e->e_flags))
1737 {
1738 if (tTd(34, 11))
1739 sm_dprintf(" (skipped -- bcc)\n");
1740 }
1741 else
1742 {
1743 /* no other recipient headers: truncate value */
1744 (void) sm_strlcpyn(obuf, sizeof obuf, 2,
1745 h->h_field, ":");
1746 if (!putline(obuf, mci))
1747 goto writeerr;
1748 }
1749 continue;
1750 }
1751
1752 if (tTd(34, 11))
1753 sm_dprintf("\n");
1754
1755 if (bitset(H_FROM|H_RCPT, h->h_flags))
1756 {
1757 /* address field */
1758 bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
1759
1760 if (bitset(H_FROM, h->h_flags))
1761 oldstyle = false;
1762 commaize(h, p, oldstyle, mci, e);
1763 }
1764 else
1765 {
1766 if (!put_vanilla_header(h, p, mci))
1767 goto writeerr;
1768 }
1769 }
1770
1771 /*
1772 ** If we are converting this to a MIME message, add the
1773 ** MIME headers (but not in MIME mode!).
1774 */
1775
1776 #if MIME8TO7
1777 if (bitset(MM_MIME8BIT, MimeMode) &&
1778 bitset(EF_HAS8BIT, e->e_flags) &&
1779 !bitset(EF_DONT_MIME, e->e_flags) &&
1780 !bitnset(M_8BITS, mci->mci_mailer->m_flags) &&
1781 !bitset(MCIF_CVT8TO7|MCIF_CVT7TO8|MCIF_INMIME, mci->mci_flags) &&
1782 hvalue("MIME-Version", e->e_header) == NULL)
1783 {
1784 if (!putline("MIME-Version: 1.0", mci))
1785 goto writeerr;
1786 if (hvalue("Content-Type", e->e_header) == NULL)
1787 {
1788 (void) sm_snprintf(obuf, sizeof obuf,
1789 "Content-Type: text/plain; charset=%s",
1790 defcharset(e));
1791 if (!putline(obuf, mci))
1792 goto writeerr;
1793 }
1794 if (hvalue("Content-Transfer-Encoding", e->e_header) == NULL
1795 && !putline("Content-Transfer-Encoding: 8bit", mci))
1796 goto writeerr;
1797 }
1798 #endif /* MIME8TO7 */
1799 return true;
1800
1801 writeerr:
1802 return false;
1803 }
1804 /*
1805 ** PUT_VANILLA_HEADER -- output a fairly ordinary header
1806 **
1807 ** Parameters:
1808 ** h -- the structure describing this header
1809 ** v -- the value of this header
1810 ** mci -- the connection info for output
1811 **
1812 ** Returns:
1813 ** true iff header was written successfully
1814 */
1815
1816 static bool
1817 put_vanilla_header(h, v, mci)
1818 HDR *h;
1819 char *v;
1820 MCI *mci;
1821 {
1822 register char *nlp;
1823 register char *obp;
1824 int putflags;
1825 char obuf[MAXLINE + 256]; /* additional length for h_field */
1826
1827 putflags = PXLF_HEADER;
1828 if (bitnset(M_7BITHDRS, mci->mci_mailer->m_flags))
1829 putflags |= PXLF_STRIP8BIT;
1830 (void) sm_snprintf(obuf, sizeof obuf, "%.200s: ", h->h_field);
1831 obp = obuf + strlen(obuf);
1832 while ((nlp = strchr(v, '\n')) != NULL)
1833 {
1834 int l;
1835
1836 l = nlp - v;
1837
1838 /*
1839 ** XXX This is broken for SPACELEFT()==0
1840 ** However, SPACELEFT() is always > 0 unless MAXLINE==1.
1841 */
1842
1843 if (SPACELEFT(obuf, obp) - 1 < (size_t) l)
1844 l = SPACELEFT(obuf, obp) - 1;
1845
1846 (void) sm_snprintf(obp, SPACELEFT(obuf, obp), "%.*s", l, v);
1847 if (!putxline(obuf, strlen(obuf), mci, putflags))
1848 goto writeerr;
1849 v += l + 1;
1850 obp = obuf;
1851 if (*v != ' ' && *v != '\t')
1852 *obp++ = ' ';
1853 }
1854
1855 /* XXX This is broken for SPACELEFT()==0 */
1856 (void) sm_snprintf(obp, SPACELEFT(obuf, obp), "%.*s",
1857 (int) (SPACELEFT(obuf, obp) - 1), v);
1858 return putxline(obuf, strlen(obuf), mci, putflags);
1859
1860 writeerr:
1861 return false;
1862 }
1863 /*
1864 ** COMMAIZE -- output a header field, making a comma-translated list.
1865 **
1866 ** Parameters:
1867 ** h -- the header field to output.
1868 ** p -- the value to put in it.
1869 ** oldstyle -- true if this is an old style header.
1870 ** mci -- the connection information.
1871 ** e -- the envelope containing the message.
1872 **
1873 ** Returns:
1874 ** true iff header field was written successfully
1875 **
1876 ** Side Effects:
1877 ** outputs "p" to file "fp".
1878 */
1879
1880 bool
1881 commaize(h, p, oldstyle, mci, e)
1882 register HDR *h;
1883 register char *p;
1884 bool oldstyle;
1885 register MCI *mci;
1886 register ENVELOPE *e;
1887 {
1888 register char *obp;
1889 int opos;
1890 int omax;
1891 bool firstone = true;
1892 int putflags = PXLF_HEADER;
1893 char **res;
1894 char obuf[MAXLINE + 3];
1895
1896 /*
1897 ** Output the address list translated by the
1898 ** mailer and with commas.
1899 */
1900
1901 if (tTd(14, 2))
1902 sm_dprintf("commaize(%s: %s)\n", h->h_field, p);
1903
1904 if (bitnset(M_7BITHDRS, mci->mci_mailer->m_flags))
1905 putflags |= PXLF_STRIP8BIT;
1906
1907 obp = obuf;
1908 (void) sm_snprintf(obp, SPACELEFT(obuf, obp), "%.200s: ",
1909 h->h_field);
1910
1911 /* opos = strlen(obp); */
1912 opos = strlen(h->h_field) + 2;
1913 if (opos > 202)
1914 opos = 202;
1915 obp += opos;
1916 omax = mci->mci_mailer->m_linelimit - 2;
1917 if (omax < 0 || omax > 78)
1918 omax = 78;
1919
1920 /*
1921 ** Run through the list of values.
1922 */
1923
1924 while (*p != '\0')
1925 {
1926 register char *name;
1927 register int c;
1928 char savechar;
1929 int flags;
1930 auto int status;
1931
1932 /*
1933 ** Find the end of the name. New style names
1934 ** end with a comma, old style names end with
1935 ** a space character. However, spaces do not
1936 ** necessarily delimit an old-style name -- at
1937 ** signs mean keep going.
1938 */
1939
1940 /* find end of name */
1941 while ((isascii(*p) && isspace(*p)) || *p == ',')
1942 p++;
1943 name = p;
1944 res = NULL;
1945 for (;;)
1946 {
1947 auto char *oldp;
1948 char pvpbuf[PSBUFSIZE];
1949
1950 res = prescan(p, oldstyle ? ' ' : ',', pvpbuf,
1951 sizeof pvpbuf, &oldp, NULL, false);
1952 p = oldp;
1953 #if _FFR_IGNORE_BOGUS_ADDR
1954 /* ignore addresses that can't be parsed */
1955 if (res == NULL)
1956 {
1957 name = p;
1958 continue;
1959 }
1960 #endif /* _FFR_IGNORE_BOGUS_ADDR */
1961
1962 /* look to see if we have an at sign */
1963 while (*p != '\0' && isascii(*p) && isspace(*p))
1964 p++;
1965
1966 if (*p != '@')
1967 {
1968 p = oldp;
1969 break;
1970 }
1971 ++p;
1972 while (*p != '\0' && isascii(*p) && isspace(*p))
1973 p++;
1974 }
1975 /* at the end of one complete name */
1976
1977 /* strip off trailing white space */
1978 while (p >= name &&
1979 ((isascii(*p) && isspace(*p)) || *p == ',' || *p == '\0'))
1980 p--;
1981 if (++p == name)
1982 continue;
1983
1984 /*
1985 ** if prescan() failed go a bit backwards; this is a hack,
1986 ** there should be some better error recovery.
1987 */
1988
1989 if (res == NULL && p > name &&
1990 !((isascii(*p) && isspace(*p)) || *p == ',' || *p == '\0'))
1991 --p;
1992 savechar = *p;
1993 *p = '\0';
1994
1995 /* translate the name to be relative */
1996 flags = RF_HEADERADDR|RF_ADDDOMAIN;
1997 if (bitset(H_FROM, h->h_flags))
1998 flags |= RF_SENDERADDR;
1999 #if USERDB
2000 else if (e->e_from.q_mailer != NULL &&
2001 bitnset(M_UDBRECIPIENT, e->e_from.q_mailer->m_flags))
2002 {
2003 char *q;
2004
2005 q = udbsender(name, e->e_rpool);
2006 if (q != NULL)
2007 name = q;
2008 }
2009 #endif /* USERDB */
2010 status = EX_OK;
2011 name = remotename(name, mci->mci_mailer, flags, &status, e);
2012 if (*name == '\0')
2013 {
2014 *p = savechar;
2015 continue;
2016 }
2017 name = denlstring(name, false, true);
2018
2019 /* output the name with nice formatting */
2020 opos += strlen(name);
2021 if (!firstone)
2022 opos += 2;
2023 if (opos > omax && !firstone)
2024 {
2025 (void) sm_strlcpy(obp, ",\n", SPACELEFT(obuf, obp));
2026 if (!putxline(obuf, strlen(obuf), mci, putflags))
2027 goto writeerr;
2028 obp = obuf;
2029 (void) sm_strlcpy(obp, " ", sizeof obuf);
2030 opos = strlen(obp);
2031 obp += opos;
2032 opos += strlen(name);
2033 }
2034 else if (!firstone)
2035 {
2036 (void) sm_strlcpy(obp, ", ", SPACELEFT(obuf, obp));
2037 obp += 2;
2038 }
2039
2040 while ((c = *name++) != '\0' && obp < &obuf[MAXLINE])
2041 *obp++ = c;
2042 firstone = false;
2043 *p = savechar;
2044 }
2045 if (obp < &obuf[sizeof obuf])
2046 *obp = '\0';
2047 else
2048 obuf[sizeof obuf - 1] = '\0';
2049 return putxline(obuf, strlen(obuf), mci, putflags);
2050
2051 writeerr:
2052 return false;
2053 }
2054
2055 /*
2056 ** COPYHEADER -- copy header list
2057 **
2058 ** This routine is the equivalent of newstr for header lists
2059 **
2060 ** Parameters:
2061 ** header -- list of header structures to copy.
2062 ** rpool -- resource pool, or NULL
2063 **
2064 ** Returns:
2065 ** a copy of 'header'.
2066 **
2067 ** Side Effects:
2068 ** none.
2069 */
2070
2071 HDR *
2072 copyheader(header, rpool)
2073 register HDR *header;
2074 SM_RPOOL_T *rpool;
2075 {
2076 register HDR *newhdr;
2077 HDR *ret;
2078 register HDR **tail = &ret;
2079
2080 while (header != NULL)
2081 {
2082 newhdr = (HDR *) sm_rpool_malloc_x(rpool, sizeof *newhdr);
2083 STRUCTCOPY(*header, *newhdr);
2084 *tail = newhdr;
2085 tail = &newhdr->h_link;
2086 header = header->h_link;
2087 }
2088 *tail = NULL;
2089
2090 return ret;
2091 }
2092 /*
2093 ** FIX_MIME_HEADER -- possibly truncate/rebalance parameters in a MIME header
2094 **
2095 ** Run through all of the parameters of a MIME header and
2096 ** possibly truncate and rebalance the parameter according
2097 ** to MaxMimeFieldLength.
2098 **
2099 ** Parameters:
2100 ** h -- the header to truncate/rebalance
2101 ** e -- the current envelope
2102 **
2103 ** Returns:
2104 ** length of last offending field, 0 if all ok.
2105 **
2106 ** Side Effects:
2107 ** string modified in place
2108 */
2109
2110 static size_t
2111 fix_mime_header(h, e)
2112 HDR *h;
2113 ENVELOPE *e;
2114 {
2115 char *begin = h->h_value;
2116 char *end;
2117 size_t len = 0;
2118 size_t retlen = 0;
2119
2120 if (begin == NULL || *begin == '\0')
2121 return 0;
2122
2123 /* Split on each ';' */
2124 /* find_character() never returns NULL */
2125 while ((end = find_character(begin, ';')) != NULL)
2126 {
2127 char save = *end;
2128 char *bp;
2129
2130 *end = '\0';
2131
2132 len = strlen(begin);
2133
2134 /* Shorten individual parameter */
2135 if (shorten_rfc822_string(begin, MaxMimeFieldLength))
2136 {
2137 if (len < MaxMimeFieldLength)
2138 {
2139 /* we only rebalanced a bogus field */
2140 sm_syslog(LOG_ALERT, e->e_id,
2141 "Fixed MIME %s header field (possible attack)",
2142 h->h_field);
2143 if (tTd(34, 11))
2144 sm_dprintf(" fixed MIME %s header field (possible attack)\n",
2145 h->h_field);
2146 }
2147 else
2148 {
2149 /* we actually shortened the header */
2150 retlen = len;
2151 }
2152 }
2153
2154 /* Collapse the possibly shortened string with rest */
2155 bp = begin + strlen(begin);
2156 if (bp != end)
2157 {
2158 char *ep = end;
2159
2160 *end = save;
2161 end = bp;
2162
2163 /* copy character by character due to overlap */
2164 while (*ep != '\0')
2165 *bp++ = *ep++;
2166 *bp = '\0';
2167 }
2168 else
2169 *end = save;
2170 if (*end == '\0')
2171 break;
2172
2173 /* Move past ';' */
2174 begin = end + 1;
2175 }
2176 return retlen;
2177 }
DragonFly BSD