1 /* 2 * Copyright (c) 1998-2006, 2008 Proofpoint, 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: collect.c,v 8.287 2013-11-22 20:51:55 ca Exp $") 17 18 static void eatfrom __P((char *volatile, ENVELOPE *)); 19 static void collect_doheader __P((ENVELOPE *)); 20 static SM_FILE_T *collect_dfopen __P((ENVELOPE *)); 21 static SM_FILE_T *collect_eoh __P((ENVELOPE *, int, int)); 22 23 /* 24 ** COLLECT_EOH -- end-of-header processing in collect() 25 ** 26 ** Called by collect() when it encounters the blank line 27 ** separating the header from the message body, or when it 28 ** encounters EOF in a message that contains only a header. 29 ** 30 ** Parameters: 31 ** e -- envelope 32 ** numhdrs -- number of headers 33 ** hdrslen -- length of headers 34 ** 35 ** Results: 36 ** NULL, or handle to open data file 37 ** 38 ** Side Effects: 39 ** end-of-header check ruleset is invoked. 40 ** envelope state is updated. 41 ** headers may be added and deleted. 42 ** selects the queue. 43 ** opens the data file. 44 */ 45 46 static SM_FILE_T * 47 collect_eoh(e, numhdrs, hdrslen) 48 ENVELOPE *e; 49 int numhdrs; 50 int hdrslen; 51 { 52 char hnum[16]; 53 char hsize[16]; 54 55 /* call the end-of-header check ruleset */ 56 (void) sm_snprintf(hnum, sizeof(hnum), "%d", numhdrs); 57 (void) sm_snprintf(hsize, sizeof(hsize), "%d", hdrslen); 58 if (tTd(30, 10)) 59 sm_dprintf("collect: rscheck(\"check_eoh\", \"%s $| %s\")\n", 60 hnum, hsize); 61 (void) rscheck("check_eoh", hnum, hsize, e, RSF_UNSTRUCTURED|RSF_COUNT, 62 3, NULL, e->e_id, NULL, NULL); 63 64 /* 65 ** Process the header, 66 ** select the queue, open the data file. 67 */ 68 69 collect_doheader(e); 70 return collect_dfopen(e); 71 } 72 73 /* 74 ** COLLECT_DOHEADER -- process header in collect() 75 ** 76 ** Called by collect() after it has finished parsing the header, 77 ** but before it selects the queue and creates the data file. 78 ** The results of processing the header will affect queue selection. 79 ** 80 ** Parameters: 81 ** e -- envelope 82 ** 83 ** Results: 84 ** none. 85 ** 86 ** Side Effects: 87 ** envelope state is updated. 88 ** headers may be added and deleted. 89 */ 90 91 static void 92 collect_doheader(e) 93 ENVELOPE *e; 94 { 95 /* 96 ** Find out some information from the headers. 97 ** Examples are who is the from person & the date. 98 */ 99 100 eatheader(e, true, false); 101 102 if (GrabTo && e->e_sendqueue == NULL) 103 usrerr("No recipient addresses found in header"); 104 105 /* 106 ** If we have a Return-Receipt-To:, turn it into a DSN. 107 */ 108 109 if (RrtImpliesDsn && hvalue("return-receipt-to", e->e_header) != NULL) 110 { 111 ADDRESS *q; 112 113 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 114 if (!bitset(QHASNOTIFY, q->q_flags)) 115 q->q_flags |= QHASNOTIFY|QPINGONSUCCESS; 116 } 117 118 /* 119 ** Add an appropriate recipient line if we have none. 120 */ 121 122 if (hvalue("to", e->e_header) != NULL || 123 hvalue("cc", e->e_header) != NULL || 124 hvalue("apparently-to", e->e_header) != NULL) 125 { 126 /* have a valid recipient header -- delete Bcc: headers */ 127 e->e_flags |= EF_DELETE_BCC; 128 } 129 else if (hvalue("bcc", e->e_header) == NULL) 130 { 131 /* no valid recipient headers */ 132 register ADDRESS *q; 133 char *hdr = NULL; 134 135 /* create a recipient field */ 136 switch (NoRecipientAction) 137 { 138 case NRA_ADD_APPARENTLY_TO: 139 hdr = "Apparently-To"; 140 break; 141 142 case NRA_ADD_TO: 143 hdr = "To"; 144 break; 145 146 case NRA_ADD_BCC: 147 addheader("Bcc", " ", 0, e, true); 148 break; 149 150 case NRA_ADD_TO_UNDISCLOSED: 151 addheader("To", "undisclosed-recipients:;", 0, e, true); 152 break; 153 } 154 155 if (hdr != NULL) 156 { 157 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 158 { 159 if (q->q_alias != NULL) 160 continue; 161 if (tTd(30, 3)) 162 sm_dprintf("Adding %s: %s\n", 163 hdr, q->q_paddr); 164 addheader(hdr, q->q_paddr, 0, e, true); 165 } 166 } 167 } 168 } 169 170 /* 171 ** COLLECT_DFOPEN -- open the message data file 172 ** 173 ** Called by collect() after it has finished processing the header. 174 ** Queue selection occurs at this point, possibly based on the 175 ** envelope's recipient list and on header information. 176 ** 177 ** Parameters: 178 ** e -- envelope 179 ** 180 ** Results: 181 ** NULL, or a pointer to an open data file, 182 ** into which the message body will be written by collect(). 183 ** 184 ** Side Effects: 185 ** Calls syserr, sets EF_FATALERRS and returns NULL 186 ** if there is insufficient disk space. 187 ** Aborts process if data file could not be opened. 188 ** Otherwise, the queue is selected, 189 ** e->e_{dfino,dfdev,msgsize,flags} are updated, 190 ** and a pointer to an open data file is returned. 191 */ 192 193 static SM_FILE_T * 194 collect_dfopen(e) 195 ENVELOPE *e; 196 { 197 MODE_T oldumask = 0; 198 int dfd; 199 struct stat stbuf; 200 SM_FILE_T *df; 201 char *dfname; 202 203 if (!setnewqueue(e)) 204 return NULL; 205 206 dfname = queuename(e, DATAFL_LETTER); 207 if (bitset(S_IWGRP, QueueFileMode)) 208 oldumask = umask(002); 209 df = bfopen(dfname, QueueFileMode, DataFileBufferSize, 210 SFF_OPENASROOT); 211 if (bitset(S_IWGRP, QueueFileMode)) 212 (void) umask(oldumask); 213 if (df == NULL) 214 { 215 syserr("@Cannot create %s", dfname); 216 e->e_flags |= EF_NO_BODY_RETN; 217 flush_errors(true); 218 finis(false, true, ExitStat); 219 /* NOTREACHED */ 220 } 221 dfd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL); 222 if (dfd < 0 || fstat(dfd, &stbuf) < 0) 223 e->e_dfino = -1; 224 else 225 { 226 e->e_dfdev = stbuf.st_dev; 227 e->e_dfino = stbuf.st_ino; 228 } 229 e->e_flags |= EF_HAS_DF; 230 return df; 231 } 232 233 /* 234 ** COLLECT -- read & parse message header & make temp file. 235 ** 236 ** Creates a temporary file name and copies the standard 237 ** input to that file. Leading UNIX-style "From" lines are 238 ** stripped off (after important information is extracted). 239 ** 240 ** Parameters: 241 ** fp -- file to read. 242 ** smtpmode -- if set, we are running SMTP: give an RFC821 243 ** style message to say we are ready to collect 244 ** input, and never ignore a single dot to mean 245 ** end of message. 246 ** hdrp -- the location to stash the header. 247 ** e -- the current envelope. 248 ** rsetsize -- reset e_msgsize? 249 ** 250 ** Returns: 251 ** none. 252 ** 253 ** Side Effects: 254 ** If successful, 255 ** - Data file is created and filled, and e->e_dfp is set. 256 ** - The from person may be set. 257 ** If the "enough disk space" check fails, 258 ** - syserr is called. 259 ** - e->e_dfp is NULL. 260 ** - e->e_flags & EF_FATALERRS is set. 261 ** - collect() returns. 262 ** If data file cannot be created, the process is terminated. 263 */ 264 265 /* values for input state machine */ 266 #define IS_NORM 0 /* middle of line */ 267 #define IS_BOL 1 /* beginning of line */ 268 #define IS_DOT 2 /* read a dot at beginning of line */ 269 #define IS_DOTCR 3 /* read ".\r" at beginning of line */ 270 #define IS_CR 4 /* read a carriage return */ 271 272 /* values for message state machine */ 273 #define MS_UFROM 0 /* reading Unix from line */ 274 #define MS_HEADER 1 /* reading message header */ 275 #define MS_BODY 2 /* reading message body */ 276 #define MS_DISCARD 3 /* discarding rest of message */ 277 278 void 279 collect(fp, smtpmode, hdrp, e, rsetsize) 280 SM_FILE_T *fp; 281 bool smtpmode; 282 HDR **hdrp; 283 register ENVELOPE *e; 284 bool rsetsize; 285 { 286 register SM_FILE_T *df; 287 bool ignrdot; 288 int dbto; 289 register char *bp; 290 int c; 291 bool inputerr; 292 bool headeronly; 293 char *buf; 294 int buflen; 295 int istate; 296 int mstate; 297 int hdrslen; 298 int numhdrs; 299 int afd; 300 int old_rd_tmo; 301 unsigned char *pbp; 302 unsigned char peekbuf[8]; 303 char bufbuf[MAXLINE]; 304 #if _FFR_REJECT_NUL_BYTE 305 bool hasNUL; /* has at least one NUL input byte */ 306 #endif 307 308 df = NULL; 309 ignrdot = smtpmode ? false : IgnrDot; 310 311 /* timeout for I/O functions is in milliseconds */ 312 dbto = smtpmode ? ((int) TimeOuts.to_datablock * 1000) 313 : SM_TIME_FOREVER; 314 sm_io_setinfo(fp, SM_IO_WHAT_TIMEOUT, &dbto); 315 old_rd_tmo = set_tls_rd_tmo(TimeOuts.to_datablock); 316 c = SM_IO_EOF; 317 inputerr = false; 318 headeronly = hdrp != NULL; 319 hdrslen = 0; 320 numhdrs = 0; 321 HasEightBits = false; 322 #if _FFR_REJECT_NUL_BYTE 323 hasNUL = false; 324 #endif 325 buf = bp = bufbuf; 326 buflen = sizeof(bufbuf); 327 pbp = peekbuf; 328 istate = IS_BOL; 329 mstate = SaveFrom ? MS_HEADER : MS_UFROM; 330 331 /* 332 ** Tell ARPANET to go ahead. 333 */ 334 335 if (smtpmode) 336 message("354 Enter mail, end with \".\" on a line by itself"); 337 338 /* simulate an I/O timeout when used as sink */ 339 if (tTd(83, 101)) 340 sleep(319); 341 342 if (tTd(30, 2)) 343 sm_dprintf("collect\n"); 344 345 /* 346 ** Read the message. 347 ** 348 ** This is done using two interleaved state machines. 349 ** The input state machine is looking for things like 350 ** hidden dots; the message state machine is handling 351 ** the larger picture (e.g., header versus body). 352 */ 353 354 if (rsetsize) 355 e->e_msgsize = 0; 356 for (;;) 357 { 358 if (tTd(30, 35)) 359 sm_dprintf("top, istate=%d, mstate=%d\n", istate, 360 mstate); 361 for (;;) 362 { 363 if (pbp > peekbuf) 364 c = *--pbp; 365 else 366 { 367 while (!sm_io_eof(fp) && !sm_io_error(fp)) 368 { 369 errno = 0; 370 c = sm_io_getc(fp, SM_TIME_DEFAULT); 371 if (c == SM_IO_EOF && errno == EINTR) 372 { 373 /* Interrupted, retry */ 374 sm_io_clearerr(fp); 375 continue; 376 } 377 378 /* timeout? */ 379 if (c == SM_IO_EOF && errno == EAGAIN 380 && smtpmode) 381 { 382 /* 383 ** Override e_message in 384 ** usrerr() as this is the 385 ** reason for failure that 386 ** should be logged for 387 ** undelivered recipients. 388 */ 389 390 e->e_message = NULL; 391 errno = 0; 392 inputerr = true; 393 goto readabort; 394 } 395 break; 396 } 397 if (TrafficLogFile != NULL && !headeronly) 398 { 399 if (istate == IS_BOL) 400 (void) sm_io_fprintf(TrafficLogFile, 401 SM_TIME_DEFAULT, 402 "%05d <<< ", 403 (int) CurrentPid); 404 if (c == SM_IO_EOF) 405 (void) sm_io_fprintf(TrafficLogFile, 406 SM_TIME_DEFAULT, 407 "[EOF]\n"); 408 else 409 (void) sm_io_putc(TrafficLogFile, 410 SM_TIME_DEFAULT, 411 c); 412 } 413 #if _FFR_REJECT_NUL_BYTE 414 if (c == '\0') 415 hasNUL = true; 416 #endif 417 if (c == SM_IO_EOF) 418 goto readerr; 419 if (SevenBitInput) 420 c &= 0x7f; 421 else 422 HasEightBits |= bitset(0x80, c); 423 } 424 if (tTd(30, 94)) 425 sm_dprintf("istate=%d, c=%c (0x%x)\n", 426 istate, (char) c, c); 427 switch (istate) 428 { 429 case IS_BOL: 430 if (c == '.') 431 { 432 istate = IS_DOT; 433 continue; 434 } 435 break; 436 437 case IS_DOT: 438 if (c == '\n' && !ignrdot) 439 goto readerr; 440 else if (c == '\r') 441 { 442 istate = IS_DOTCR; 443 continue; 444 } 445 else if (ignrdot || 446 (c != '.' && 447 OpMode != MD_SMTP && 448 OpMode != MD_DAEMON && 449 OpMode != MD_ARPAFTP)) 450 451 { 452 SM_ASSERT(pbp < peekbuf + 453 sizeof(peekbuf)); 454 *pbp++ = c; 455 c = '.'; 456 } 457 break; 458 459 case IS_DOTCR: 460 if (c == '\n' && !ignrdot) 461 goto readerr; 462 else 463 { 464 /* push back the ".\rx" */ 465 SM_ASSERT(pbp < peekbuf + 466 sizeof(peekbuf)); 467 *pbp++ = c; 468 if (OpMode != MD_SMTP && 469 OpMode != MD_DAEMON && 470 OpMode != MD_ARPAFTP) 471 { 472 SM_ASSERT(pbp < peekbuf + 473 sizeof(peekbuf)); 474 *pbp++ = '\r'; 475 c = '.'; 476 } 477 else 478 c = '\r'; 479 } 480 break; 481 482 case IS_CR: 483 if (c == '\n') 484 istate = IS_BOL; 485 else 486 { 487 (void) sm_io_ungetc(fp, SM_TIME_DEFAULT, 488 c); 489 c = '\r'; 490 istate = IS_NORM; 491 } 492 goto bufferchar; 493 } 494 495 if (c == '\r') 496 { 497 istate = IS_CR; 498 continue; 499 } 500 else if (c == '\n') 501 istate = IS_BOL; 502 else 503 istate = IS_NORM; 504 505 bufferchar: 506 if (!headeronly) 507 { 508 /* no overflow? */ 509 if (e->e_msgsize >= 0) 510 { 511 e->e_msgsize++; 512 if (MaxMessageSize > 0 && 513 !bitset(EF_TOOBIG, e->e_flags) && 514 e->e_msgsize > MaxMessageSize) 515 e->e_flags |= EF_TOOBIG; 516 } 517 } 518 switch (mstate) 519 { 520 case MS_BODY: 521 /* just put the character out */ 522 if (!bitset(EF_TOOBIG, e->e_flags)) 523 (void) sm_io_putc(df, SM_TIME_DEFAULT, 524 c); 525 526 /* FALLTHROUGH */ 527 528 case MS_DISCARD: 529 continue; 530 } 531 532 SM_ASSERT(mstate == MS_UFROM || mstate == MS_HEADER); 533 534 /* header -- buffer up */ 535 if (bp >= &buf[buflen - 2]) 536 { 537 char *obuf; 538 539 /* out of space for header */ 540 obuf = buf; 541 if (buflen < MEMCHUNKSIZE) 542 buflen *= 2; 543 else 544 buflen += MEMCHUNKSIZE; 545 if (buflen <= 0) 546 { 547 sm_syslog(LOG_NOTICE, e->e_id, 548 "header overflow from %s during message collect", 549 CURHOSTNAME); 550 errno = 0; 551 e->e_flags |= EF_CLRQUEUE; 552 e->e_status = "5.6.0"; 553 usrerrenh(e->e_status, 554 "552 Headers too large"); 555 goto discard; 556 } 557 buf = xalloc(buflen); 558 memmove(buf, obuf, bp - obuf); 559 bp = &buf[bp - obuf]; 560 if (obuf != bufbuf) 561 sm_free(obuf); /* XXX */ 562 } 563 564 if (c != '\0') 565 { 566 *bp++ = c; 567 ++hdrslen; 568 if (!headeronly && 569 MaxHeadersLength > 0 && 570 hdrslen > MaxHeadersLength) 571 { 572 sm_syslog(LOG_NOTICE, e->e_id, 573 "headers too large (%d max) from %s during message collect", 574 MaxHeadersLength, 575 CURHOSTNAME); 576 errno = 0; 577 e->e_flags |= EF_CLRQUEUE; 578 e->e_status = "5.6.0"; 579 usrerrenh(e->e_status, 580 "552 Headers too large (%d max)", 581 MaxHeadersLength); 582 discard: 583 mstate = MS_DISCARD; 584 } 585 } 586 if (istate == IS_BOL) 587 break; 588 } 589 *bp = '\0'; 590 591 nextstate: 592 if (tTd(30, 35)) 593 sm_dprintf("nextstate, istate=%d, mstate=%d, line=\"%s\"\n", 594 istate, mstate, buf); 595 switch (mstate) 596 { 597 case MS_UFROM: 598 mstate = MS_HEADER; 599 #ifndef NOTUNIX 600 if (strncmp(buf, "From ", 5) == 0) 601 { 602 bp = buf; 603 eatfrom(buf, e); 604 continue; 605 } 606 #endif /* ! NOTUNIX */ 607 /* FALLTHROUGH */ 608 609 case MS_HEADER: 610 if (!isheader(buf)) 611 { 612 mstate = MS_BODY; 613 goto nextstate; 614 } 615 616 /* check for possible continuation line */ 617 do 618 { 619 sm_io_clearerr(fp); 620 errno = 0; 621 c = sm_io_getc(fp, SM_TIME_DEFAULT); 622 623 /* timeout? */ 624 if (c == SM_IO_EOF && errno == EAGAIN 625 && smtpmode) 626 { 627 /* 628 ** Override e_message in 629 ** usrerr() as this is the 630 ** reason for failure that 631 ** should be logged for 632 ** undelivered recipients. 633 */ 634 635 e->e_message = NULL; 636 errno = 0; 637 inputerr = true; 638 goto readabort; 639 } 640 } while (c == SM_IO_EOF && errno == EINTR); 641 if (c != SM_IO_EOF) 642 (void) sm_io_ungetc(fp, SM_TIME_DEFAULT, c); 643 if (c == ' ' || c == '\t') 644 { 645 /* yep -- defer this */ 646 continue; 647 } 648 649 SM_ASSERT(bp > buf); 650 651 /* guaranteed by isheader(buf) */ 652 SM_ASSERT(*(bp - 1) != '\n' || bp > buf + 1); 653 654 /* trim off trailing CRLF or NL */ 655 if (*--bp != '\n' || *--bp != '\r') 656 bp++; 657 *bp = '\0'; 658 659 if (bitset(H_EOH, chompheader(buf, 660 CHHDR_CHECK | CHHDR_USER, 661 hdrp, e))) 662 { 663 mstate = MS_BODY; 664 goto nextstate; 665 } 666 numhdrs++; 667 break; 668 669 case MS_BODY: 670 if (tTd(30, 1)) 671 sm_dprintf("EOH\n"); 672 673 if (headeronly) 674 goto readerr; 675 676 df = collect_eoh(e, numhdrs, hdrslen); 677 if (df == NULL) 678 e->e_flags |= EF_TOOBIG; 679 680 bp = buf; 681 682 /* toss blank line */ 683 if ((bp[0] == '\r' && bp[1] == '\n') || 684 (bp[0] == '\n')) 685 { 686 break; 687 } 688 689 /* if not a blank separator, write it out */ 690 if (!bitset(EF_TOOBIG, e->e_flags)) 691 { 692 while (*bp != '\0') 693 (void) sm_io_putc(df, SM_TIME_DEFAULT, 694 *bp++); 695 } 696 break; 697 } 698 bp = buf; 699 } 700 701 readerr: 702 if ((sm_io_eof(fp) && smtpmode) || sm_io_error(fp)) 703 { 704 const char *errmsg; 705 706 if (sm_io_eof(fp)) 707 errmsg = "unexpected close"; 708 else 709 errmsg = sm_errstring(errno); 710 if (tTd(30, 1)) 711 sm_dprintf("collect: premature EOM: %s\n", errmsg); 712 if (LogLevel > 1) 713 sm_syslog(LOG_WARNING, e->e_id, 714 "collect: premature EOM: %s", errmsg); 715 inputerr = true; 716 } 717 718 if (headeronly) 719 goto end; 720 721 if (mstate != MS_BODY) 722 { 723 /* no body or discard, so we never opened the data file */ 724 SM_ASSERT(df == NULL); 725 df = collect_eoh(e, numhdrs, hdrslen); 726 } 727 728 if (df == NULL) 729 { 730 /* skip next few clauses */ 731 /* EMPTY */ 732 } 733 else if (sm_io_flush(df, SM_TIME_DEFAULT) != 0 || sm_io_error(df)) 734 { 735 dferror(df, "sm_io_flush||sm_io_error", e); 736 flush_errors(true); 737 finis(true, true, ExitStat); 738 /* NOTREACHED */ 739 } 740 else if (SuperSafe == SAFE_NO || 741 SuperSafe == SAFE_INTERACTIVE || 742 (SuperSafe == SAFE_REALLY_POSTMILTER && smtpmode)) 743 { 744 /* skip next few clauses */ 745 /* EMPTY */ 746 /* Note: updfs() is not called in this case! */ 747 } 748 else if (sm_io_setinfo(df, SM_BF_COMMIT, NULL) < 0 && errno != EINVAL) 749 { 750 int save_errno = errno; 751 752 if (save_errno == EEXIST) 753 { 754 char *dfile; 755 struct stat st; 756 int dfd; 757 758 dfile = queuename(e, DATAFL_LETTER); 759 if (stat(dfile, &st) < 0) 760 st.st_size = -1; 761 errno = EEXIST; 762 syserr("@collect: bfcommit(%s): already on disk, size=%ld", 763 dfile, (long) st.st_size); 764 dfd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL); 765 if (dfd >= 0) 766 dumpfd(dfd, true, true); 767 } 768 errno = save_errno; 769 dferror(df, "bfcommit", e); 770 flush_errors(true); 771 finis(save_errno != EEXIST, true, ExitStat); 772 } 773 else if ((afd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL)) < 0) 774 { 775 dferror(df, "sm_io_getinfo", e); 776 flush_errors(true); 777 finis(true, true, ExitStat); 778 /* NOTREACHED */ 779 } 780 else if (fsync(afd) < 0) 781 { 782 dferror(df, "fsync", e); 783 flush_errors(true); 784 finis(true, true, ExitStat); 785 /* NOTREACHED */ 786 } 787 else if (sm_io_close(df, SM_TIME_DEFAULT) < 0) 788 { 789 dferror(df, "sm_io_close", e); 790 flush_errors(true); 791 finis(true, true, ExitStat); 792 /* NOTREACHED */ 793 } 794 else 795 { 796 /* everything is happily flushed to disk */ 797 df = NULL; 798 799 /* remove from available space in filesystem */ 800 updfs(e, 0, 1, "collect"); 801 } 802 803 /* An EOF when running SMTP is an error */ 804 readabort: 805 if (inputerr && (OpMode == MD_SMTP || OpMode == MD_DAEMON)) 806 { 807 char *host; 808 char *problem; 809 ADDRESS *q; 810 811 host = RealHostName; 812 if (host == NULL) 813 host = "localhost"; 814 815 if (sm_io_eof(fp)) 816 problem = "unexpected close"; 817 else if (sm_io_error(fp)) 818 problem = "I/O error"; 819 else 820 problem = "read timeout"; 821 if (LogLevel > 0 && sm_io_eof(fp)) 822 sm_syslog(LOG_NOTICE, e->e_id, 823 "collect: %s on connection from %.100s, sender=%s", 824 problem, host, 825 shortenstring(e->e_from.q_paddr, MAXSHORTSTR)); 826 if (sm_io_eof(fp)) 827 usrerr("421 4.4.1 collect: %s on connection from %s, from=%s", 828 problem, host, 829 shortenstring(e->e_from.q_paddr, MAXSHORTSTR)); 830 else 831 syserr("421 4.4.1 collect: %s on connection from %s, from=%s", 832 problem, host, 833 shortenstring(e->e_from.q_paddr, MAXSHORTSTR)); 834 flush_errors(true); 835 836 /* don't return an error indication */ 837 e->e_to = NULL; 838 e->e_flags &= ~EF_FATALERRS; 839 e->e_flags |= EF_CLRQUEUE; 840 841 /* Don't send any message notification to sender */ 842 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 843 { 844 if (QS_IS_DEAD(q->q_state)) 845 continue; 846 q->q_state = QS_FATALERR; 847 } 848 849 (void) sm_io_close(df, SM_TIME_DEFAULT); 850 df = NULL; 851 finis(true, true, ExitStat); 852 /* NOTREACHED */ 853 } 854 855 /* Log collection information. */ 856 if (tTd(92, 2)) 857 sm_dprintf("collect: e_id=%s, EF_LOGSENDER=%d, LogLevel=%d\n", 858 e->e_id, bitset(EF_LOGSENDER, e->e_flags), LogLevel); 859 if (bitset(EF_LOGSENDER, e->e_flags) && LogLevel > 4) 860 { 861 logsender(e, e->e_msgid); 862 e->e_flags &= ~EF_LOGSENDER; 863 } 864 865 /* check for message too large */ 866 if (bitset(EF_TOOBIG, e->e_flags)) 867 { 868 e->e_flags |= EF_NO_BODY_RETN|EF_CLRQUEUE; 869 if (!bitset(EF_FATALERRS, e->e_flags)) 870 { 871 e->e_status = "5.2.3"; 872 usrerrenh(e->e_status, 873 "552 Message exceeds maximum fixed size (%ld)", 874 MaxMessageSize); 875 if (LogLevel > 6) 876 sm_syslog(LOG_NOTICE, e->e_id, 877 "message size (%ld) exceeds maximum (%ld)", 878 PRT_NONNEGL(e->e_msgsize), 879 MaxMessageSize); 880 } 881 } 882 883 /* check for illegal 8-bit data */ 884 if (HasEightBits) 885 { 886 e->e_flags |= EF_HAS8BIT; 887 if (!bitset(MM_PASS8BIT|MM_MIME8BIT, MimeMode) && 888 !bitset(EF_IS_MIME, e->e_flags)) 889 { 890 e->e_status = "5.6.1"; 891 usrerrenh(e->e_status, "554 Eight bit data not allowed"); 892 } 893 } 894 else 895 { 896 /* if it claimed to be 8 bits, well, it lied.... */ 897 if (e->e_bodytype != NULL && 898 sm_strcasecmp(e->e_bodytype, "8BITMIME") == 0) 899 e->e_bodytype = "7BIT"; 900 } 901 902 #if _FFR_REJECT_NUL_BYTE 903 if (hasNUL && RejectNUL) 904 { 905 e->e_status = "5.6.1"; 906 usrerrenh(e->e_status, "554 NUL byte not allowed"); 907 } 908 #endif /* _FFR_REJECT_NUL_BYTE */ 909 910 if (SuperSafe == SAFE_REALLY && !bitset(EF_FATALERRS, e->e_flags)) 911 { 912 char *dfname = queuename(e, DATAFL_LETTER); 913 if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname, 914 SM_IO_RDONLY_B, NULL)) == NULL) 915 { 916 /* we haven't acked receipt yet, so just chuck this */ 917 syserr("@Cannot reopen %s", dfname); 918 finis(true, true, ExitStat); 919 /* NOTREACHED */ 920 } 921 } 922 else 923 e->e_dfp = df; 924 925 /* collect statistics */ 926 if (OpMode != MD_VERIFY) 927 { 928 /* 929 ** Recalculate e_msgpriority, it is done at in eatheader() 930 ** which is called (in 8.12) after the header is collected, 931 ** hence e_msgsize is (most likely) incorrect. 932 */ 933 934 e->e_msgpriority = e->e_msgsize 935 - e->e_class * WkClassFact 936 + e->e_nrcpts * WkRecipFact; 937 markstats(e, (ADDRESS *) NULL, STATS_NORMAL); 938 } 939 940 end: 941 (void) set_tls_rd_tmo(old_rd_tmo); 942 } 943 944 /* 945 ** DFERROR -- signal error on writing the data file. 946 ** 947 ** Called by collect(). Collect() always terminates the process 948 ** immediately after calling dferror(), which means that the SMTP 949 ** session will be terminated, which means that any error message 950 ** issued by dferror must be a 421 error, as per RFC 821. 951 ** 952 ** Parameters: 953 ** df -- the file pointer for the data file. 954 ** msg -- detailed message. 955 ** e -- the current envelope. 956 ** 957 ** Returns: 958 ** none. 959 ** 960 ** Side Effects: 961 ** Gives an error message. 962 ** Arranges for following output to go elsewhere. 963 */ 964 965 void 966 dferror(df, msg, e) 967 SM_FILE_T *volatile df; 968 char *msg; 969 register ENVELOPE *e; 970 { 971 char *dfname; 972 973 dfname = queuename(e, DATAFL_LETTER); 974 setstat(EX_IOERR); 975 if (errno == ENOSPC) 976 { 977 #if STAT64 > 0 978 struct stat64 st; 979 #else 980 struct stat st; 981 #endif 982 long avail; 983 long bsize; 984 985 e->e_flags |= EF_NO_BODY_RETN; 986 987 if ( 988 #if STAT64 > 0 989 fstat64(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st) 990 #else 991 fstat(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st) 992 #endif 993 < 0) 994 st.st_size = 0; 995 (void) sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, dfname, 996 SM_IO_WRONLY_B, NULL, df); 997 if (st.st_size <= 0) 998 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 999 "\n*** Mail could not be accepted"); 1000 else 1001 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 1002 "\n*** Mail of at least %llu bytes could not be accepted\n", 1003 (ULONGLONG_T) st.st_size); 1004 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 1005 "*** at %s due to lack of disk space for temp file.\n", 1006 MyHostName); 1007 avail = freediskspace(qid_printqueue(e->e_qgrp, e->e_qdir), 1008 &bsize); 1009 if (avail > 0) 1010 { 1011 if (bsize > 1024) 1012 avail *= bsize / 1024; 1013 else if (bsize < 1024) 1014 avail /= 1024 / bsize; 1015 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 1016 "*** Currently, %ld kilobytes are available for mail temp files.\n", 1017 avail); 1018 } 1019 #if 0 1020 /* Wrong response code; should be 421. */ 1021 e->e_status = "4.3.1"; 1022 usrerrenh(e->e_status, "452 Out of disk space for temp file"); 1023 #else /* 0 */ 1024 syserr("421 4.3.1 Out of disk space for temp file"); 1025 #endif /* 0 */ 1026 } 1027 else 1028 syserr("421 4.3.0 collect: Cannot write %s (%s, uid=%ld, gid=%ld)", 1029 dfname, msg, (long) geteuid(), (long) getegid()); 1030 if (sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, SM_PATH_DEVNULL, 1031 SM_IO_WRONLY, NULL, df) == NULL) 1032 sm_syslog(LOG_ERR, e->e_id, 1033 "dferror: sm_io_reopen(\"/dev/null\") failed: %s", 1034 sm_errstring(errno)); 1035 } 1036 /* 1037 ** EATFROM -- chew up a UNIX style from line and process 1038 ** 1039 ** This does indeed make some assumptions about the format 1040 ** of UNIX messages. 1041 ** 1042 ** Parameters: 1043 ** fm -- the from line. 1044 ** e -- envelope 1045 ** 1046 ** Returns: 1047 ** none. 1048 ** 1049 ** Side Effects: 1050 ** extracts what information it can from the header, 1051 ** such as the date. 1052 */ 1053 1054 #ifndef NOTUNIX 1055 1056 static char *DowList[] = 1057 { 1058 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL 1059 }; 1060 1061 static char *MonthList[] = 1062 { 1063 "Jan", "Feb", "Mar", "Apr", "May", "Jun", 1064 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", 1065 NULL 1066 }; 1067 1068 static void 1069 eatfrom(fm, e) 1070 char *volatile fm; 1071 register ENVELOPE *e; 1072 { 1073 register char *p; 1074 register char **dt; 1075 1076 if (tTd(30, 2)) 1077 sm_dprintf("eatfrom(%s)\n", fm); 1078 1079 /* find the date part */ 1080 p = fm; 1081 while (*p != '\0') 1082 { 1083 /* skip a word */ 1084 while (*p != '\0' && *p != ' ') 1085 p++; 1086 while (*p == ' ') 1087 p++; 1088 if (strlen(p) < 17) 1089 { 1090 /* no room for the date */ 1091 return; 1092 } 1093 if (!(isascii(*p) && isupper(*p)) || 1094 p[3] != ' ' || p[13] != ':' || p[16] != ':') 1095 continue; 1096 1097 /* we have a possible date */ 1098 for (dt = DowList; *dt != NULL; dt++) 1099 if (strncmp(*dt, p, 3) == 0) 1100 break; 1101 if (*dt == NULL) 1102 continue; 1103 1104 for (dt = MonthList; *dt != NULL; dt++) 1105 { 1106 if (strncmp(*dt, &p[4], 3) == 0) 1107 break; 1108 } 1109 if (*dt != NULL) 1110 break; 1111 } 1112 1113 if (*p != '\0') 1114 { 1115 char *q, buf[25]; 1116 1117 /* we have found a date */ 1118 (void) sm_strlcpy(buf, p, sizeof(buf)); 1119 q = arpadate(buf); 1120 macdefine(&e->e_macro, A_TEMP, 'a', q); 1121 } 1122 } 1123 #endif /* ! NOTUNIX */ 1124