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