1 /* 2 * Copyright (c) 1998-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: collect.c,v 8.273 2006/03/31 18:51:47 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); 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); 148 break; 149 150 case NRA_ADD_TO_UNDISCLOSED: 151 addheader("To", "undisclosed-recipients:;", 0, e); 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); 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 unsigned char *pbp; 301 unsigned char peekbuf[8]; 302 char bufbuf[MAXLINE]; 303 304 df = NULL; 305 ignrdot = smtpmode ? false : IgnrDot; 306 307 /* timeout for I/O functions is in milliseconds */ 308 dbto = smtpmode ? ((int) TimeOuts.to_datablock * 1000) 309 : SM_TIME_FOREVER; 310 sm_io_setinfo(fp, SM_IO_WHAT_TIMEOUT, &dbto); 311 c = SM_IO_EOF; 312 inputerr = false; 313 headeronly = hdrp != NULL; 314 hdrslen = 0; 315 numhdrs = 0; 316 HasEightBits = false; 317 buf = bp = bufbuf; 318 buflen = sizeof bufbuf; 319 pbp = peekbuf; 320 istate = IS_BOL; 321 mstate = SaveFrom ? MS_HEADER : MS_UFROM; 322 323 /* 324 ** Tell ARPANET to go ahead. 325 */ 326 327 if (smtpmode) 328 message("354 Enter mail, end with \".\" on a line by itself"); 329 330 /* simulate an I/O timeout when used as sink */ 331 if (tTd(83, 101)) 332 sleep(319); 333 334 if (tTd(30, 2)) 335 sm_dprintf("collect\n"); 336 337 /* 338 ** Read the message. 339 ** 340 ** This is done using two interleaved state machines. 341 ** The input state machine is looking for things like 342 ** hidden dots; the message state machine is handling 343 ** the larger picture (e.g., header versus body). 344 */ 345 346 if (rsetsize) 347 e->e_msgsize = 0; 348 for (;;) 349 { 350 if (tTd(30, 35)) 351 sm_dprintf("top, istate=%d, mstate=%d\n", istate, 352 mstate); 353 for (;;) 354 { 355 if (pbp > peekbuf) 356 c = *--pbp; 357 else 358 { 359 while (!sm_io_eof(fp) && !sm_io_error(fp)) 360 { 361 errno = 0; 362 c = sm_io_getc(fp, SM_TIME_DEFAULT); 363 if (c == SM_IO_EOF && errno == EINTR) 364 { 365 /* Interrupted, retry */ 366 sm_io_clearerr(fp); 367 continue; 368 } 369 370 /* timeout? */ 371 if (c == SM_IO_EOF && errno == EAGAIN 372 && smtpmode) 373 { 374 /* 375 ** Override e_message in 376 ** usrerr() as this is the 377 ** reason for failure that 378 ** should be logged for 379 ** undelivered recipients. 380 */ 381 382 e->e_message = NULL; 383 errno = 0; 384 inputerr = true; 385 goto readabort; 386 } 387 break; 388 } 389 if (TrafficLogFile != NULL && !headeronly) 390 { 391 if (istate == IS_BOL) 392 (void) sm_io_fprintf(TrafficLogFile, 393 SM_TIME_DEFAULT, 394 "%05d <<< ", 395 (int) CurrentPid); 396 if (c == SM_IO_EOF) 397 (void) sm_io_fprintf(TrafficLogFile, 398 SM_TIME_DEFAULT, 399 "[EOF]\n"); 400 else 401 (void) sm_io_putc(TrafficLogFile, 402 SM_TIME_DEFAULT, 403 c); 404 } 405 if (c == SM_IO_EOF) 406 goto readerr; 407 if (SevenBitInput) 408 c &= 0x7f; 409 else 410 HasEightBits |= bitset(0x80, c); 411 } 412 if (tTd(30, 94)) 413 sm_dprintf("istate=%d, c=%c (0x%x)\n", 414 istate, (char) c, c); 415 switch (istate) 416 { 417 case IS_BOL: 418 if (c == '.') 419 { 420 istate = IS_DOT; 421 continue; 422 } 423 break; 424 425 case IS_DOT: 426 if (c == '\n' && !ignrdot && 427 !bitset(EF_NL_NOT_EOL, e->e_flags)) 428 goto readerr; 429 else if (c == '\r' && 430 !bitset(EF_CRLF_NOT_EOL, e->e_flags)) 431 { 432 istate = IS_DOTCR; 433 continue; 434 } 435 else if (ignrdot || 436 (c != '.' && 437 OpMode != MD_SMTP && 438 OpMode != MD_DAEMON && 439 OpMode != MD_ARPAFTP)) 440 441 { 442 SM_ASSERT(pbp < peekbuf + 443 sizeof(peekbuf)); 444 *pbp++ = c; 445 c = '.'; 446 } 447 break; 448 449 case IS_DOTCR: 450 if (c == '\n' && !ignrdot) 451 goto readerr; 452 else 453 { 454 /* push back the ".\rx" */ 455 SM_ASSERT(pbp < peekbuf + 456 sizeof(peekbuf)); 457 *pbp++ = c; 458 if (OpMode != MD_SMTP && 459 OpMode != MD_DAEMON && 460 OpMode != MD_ARPAFTP) 461 { 462 SM_ASSERT(pbp < peekbuf + 463 sizeof(peekbuf)); 464 *pbp++ = '\r'; 465 c = '.'; 466 } 467 else 468 c = '\r'; 469 } 470 break; 471 472 case IS_CR: 473 if (c == '\n') 474 istate = IS_BOL; 475 else 476 { 477 (void) sm_io_ungetc(fp, SM_TIME_DEFAULT, 478 c); 479 c = '\r'; 480 istate = IS_NORM; 481 } 482 goto bufferchar; 483 } 484 485 if (c == '\r' && !bitset(EF_CRLF_NOT_EOL, e->e_flags)) 486 { 487 istate = IS_CR; 488 continue; 489 } 490 else if (c == '\n' && !bitset(EF_NL_NOT_EOL, 491 e->e_flags)) 492 istate = IS_BOL; 493 else 494 istate = IS_NORM; 495 496 bufferchar: 497 if (!headeronly) 498 { 499 /* no overflow? */ 500 if (e->e_msgsize >= 0) 501 { 502 e->e_msgsize++; 503 if (MaxMessageSize > 0 && 504 !bitset(EF_TOOBIG, e->e_flags) && 505 e->e_msgsize > MaxMessageSize) 506 e->e_flags |= EF_TOOBIG; 507 } 508 } 509 switch (mstate) 510 { 511 case MS_BODY: 512 /* just put the character out */ 513 if (!bitset(EF_TOOBIG, e->e_flags)) 514 (void) sm_io_putc(df, SM_TIME_DEFAULT, 515 c); 516 517 /* FALLTHROUGH */ 518 519 case MS_DISCARD: 520 continue; 521 } 522 523 SM_ASSERT(mstate == MS_UFROM || mstate == MS_HEADER); 524 525 /* header -- buffer up */ 526 if (bp >= &buf[buflen - 2]) 527 { 528 char *obuf; 529 530 /* out of space for header */ 531 obuf = buf; 532 if (buflen < MEMCHUNKSIZE) 533 buflen *= 2; 534 else 535 buflen += MEMCHUNKSIZE; 536 if (buflen <= 0) 537 { 538 sm_syslog(LOG_NOTICE, e->e_id, 539 "header overflow from %s during message collect", 540 CURHOSTNAME); 541 errno = 0; 542 e->e_flags |= EF_CLRQUEUE; 543 e->e_status = "5.6.0"; 544 usrerrenh(e->e_status, 545 "552 Headers too large"); 546 goto discard; 547 } 548 buf = xalloc(buflen); 549 memmove(buf, obuf, bp - obuf); 550 bp = &buf[bp - obuf]; 551 if (obuf != bufbuf) 552 sm_free(obuf); /* XXX */ 553 } 554 555 /* 556 ** XXX Notice: the logic here is broken. 557 ** An input to sendmail that doesn't contain a 558 ** header but starts immediately with the body whose 559 ** first line contain characters which match the 560 ** following "if" will cause problems: those 561 ** characters will NOT appear in the output... 562 ** Do we care? 563 */ 564 565 if (c >= 0200 && c <= 0237) 566 { 567 #if 0 /* causes complaints -- figure out something for 8.n+1 */ 568 usrerr("Illegal character 0x%x in header", c); 569 #else /* 0 */ 570 /* EMPTY */ 571 #endif /* 0 */ 572 } 573 else if (c != '\0') 574 { 575 *bp++ = c; 576 ++hdrslen; 577 if (!headeronly && 578 MaxHeadersLength > 0 && 579 hdrslen > MaxHeadersLength) 580 { 581 sm_syslog(LOG_NOTICE, e->e_id, 582 "headers too large (%d max) from %s during message collect", 583 MaxHeadersLength, 584 CURHOSTNAME); 585 errno = 0; 586 e->e_flags |= EF_CLRQUEUE; 587 e->e_status = "5.6.0"; 588 usrerrenh(e->e_status, 589 "552 Headers too large (%d max)", 590 MaxHeadersLength); 591 discard: 592 mstate = MS_DISCARD; 593 } 594 } 595 if (istate == IS_BOL) 596 break; 597 } 598 *bp = '\0'; 599 600 nextstate: 601 if (tTd(30, 35)) 602 sm_dprintf("nextstate, istate=%d, mstate=%d, line = \"%s\"\n", 603 istate, mstate, buf); 604 switch (mstate) 605 { 606 case MS_UFROM: 607 mstate = MS_HEADER; 608 #ifndef NOTUNIX 609 if (strncmp(buf, "From ", 5) == 0) 610 { 611 bp = buf; 612 eatfrom(buf, e); 613 continue; 614 } 615 #endif /* ! NOTUNIX */ 616 /* FALLTHROUGH */ 617 618 case MS_HEADER: 619 if (!isheader(buf)) 620 { 621 mstate = MS_BODY; 622 goto nextstate; 623 } 624 625 /* check for possible continuation line */ 626 do 627 { 628 sm_io_clearerr(fp); 629 errno = 0; 630 c = sm_io_getc(fp, SM_TIME_DEFAULT); 631 632 /* timeout? */ 633 if (c == SM_IO_EOF && errno == EAGAIN 634 && smtpmode) 635 { 636 /* 637 ** Override e_message in 638 ** usrerr() as this is the 639 ** reason for failure that 640 ** should be logged for 641 ** undelivered recipients. 642 */ 643 644 e->e_message = NULL; 645 errno = 0; 646 inputerr = true; 647 goto readabort; 648 } 649 } while (c == SM_IO_EOF && errno == EINTR); 650 if (c != SM_IO_EOF) 651 (void) sm_io_ungetc(fp, SM_TIME_DEFAULT, c); 652 if (c == ' ' || c == '\t') 653 { 654 /* yep -- defer this */ 655 continue; 656 } 657 658 SM_ASSERT(bp > buf); 659 660 /* guaranteed by isheader(buf) */ 661 SM_ASSERT(*(bp - 1) != '\n' || bp > buf + 1); 662 663 /* trim off trailing CRLF or NL */ 664 if (*--bp != '\n' || *--bp != '\r') 665 bp++; 666 *bp = '\0'; 667 668 if (bitset(H_EOH, chompheader(buf, 669 CHHDR_CHECK | CHHDR_USER, 670 hdrp, e))) 671 { 672 mstate = MS_BODY; 673 goto nextstate; 674 } 675 numhdrs++; 676 break; 677 678 case MS_BODY: 679 if (tTd(30, 1)) 680 sm_dprintf("EOH\n"); 681 682 if (headeronly) 683 goto readerr; 684 685 df = collect_eoh(e, numhdrs, hdrslen); 686 if (df == NULL) 687 e->e_flags |= EF_TOOBIG; 688 689 bp = buf; 690 691 /* toss blank line */ 692 if ((!bitset(EF_CRLF_NOT_EOL, e->e_flags) && 693 bp[0] == '\r' && bp[1] == '\n') || 694 (!bitset(EF_NL_NOT_EOL, e->e_flags) && 695 bp[0] == '\n')) 696 { 697 break; 698 } 699 700 /* if not a blank separator, write it out */ 701 if (!bitset(EF_TOOBIG, e->e_flags)) 702 { 703 while (*bp != '\0') 704 (void) sm_io_putc(df, SM_TIME_DEFAULT, 705 *bp++); 706 } 707 break; 708 } 709 bp = buf; 710 } 711 712 readerr: 713 if ((sm_io_eof(fp) && smtpmode) || sm_io_error(fp)) 714 { 715 const char *errmsg; 716 717 if (sm_io_eof(fp)) 718 errmsg = "unexpected close"; 719 else 720 errmsg = sm_errstring(errno); 721 if (tTd(30, 1)) 722 sm_dprintf("collect: premature EOM: %s\n", errmsg); 723 if (LogLevel > 1) 724 sm_syslog(LOG_WARNING, e->e_id, 725 "collect: premature EOM: %s", errmsg); 726 inputerr = true; 727 } 728 729 if (headeronly) 730 return; 731 732 if (mstate != MS_BODY) 733 { 734 /* no body or discard, so we never opened the data file */ 735 SM_ASSERT(df == NULL); 736 df = collect_eoh(e, numhdrs, hdrslen); 737 } 738 739 if (df == NULL) 740 { 741 /* skip next few clauses */ 742 /* EMPTY */ 743 } 744 else if (sm_io_flush(df, SM_TIME_DEFAULT) != 0 || sm_io_error(df)) 745 { 746 dferror(df, "sm_io_flush||sm_io_error", e); 747 flush_errors(true); 748 finis(true, true, ExitStat); 749 /* NOTREACHED */ 750 } 751 else if (SuperSafe == SAFE_NO || 752 SuperSafe == SAFE_INTERACTIVE || 753 (SuperSafe == SAFE_REALLY_POSTMILTER && smtpmode)) 754 { 755 /* skip next few clauses */ 756 /* EMPTY */ 757 /* Note: updfs() is not called in this case! */ 758 } 759 else if (sm_io_setinfo(df, SM_BF_COMMIT, NULL) < 0 && errno != EINVAL) 760 { 761 int save_errno = errno; 762 763 if (save_errno == EEXIST) 764 { 765 char *dfile; 766 struct stat st; 767 int dfd; 768 769 dfile = queuename(e, DATAFL_LETTER); 770 if (stat(dfile, &st) < 0) 771 st.st_size = -1; 772 errno = EEXIST; 773 syserr("@collect: bfcommit(%s): already on disk, size=%ld", 774 dfile, (long) st.st_size); 775 dfd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL); 776 if (dfd >= 0) 777 dumpfd(dfd, true, true); 778 } 779 errno = save_errno; 780 dferror(df, "bfcommit", e); 781 flush_errors(true); 782 finis(save_errno != EEXIST, true, ExitStat); 783 } 784 else if ((afd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL)) < 0) 785 { 786 dferror(df, "sm_io_getinfo", e); 787 flush_errors(true); 788 finis(true, true, ExitStat); 789 /* NOTREACHED */ 790 } 791 else if (fsync(afd) < 0) 792 { 793 dferror(df, "fsync", e); 794 flush_errors(true); 795 finis(true, true, ExitStat); 796 /* NOTREACHED */ 797 } 798 else if (sm_io_close(df, SM_TIME_DEFAULT) < 0) 799 { 800 dferror(df, "sm_io_close", e); 801 flush_errors(true); 802 finis(true, true, ExitStat); 803 /* NOTREACHED */ 804 } 805 else 806 { 807 /* everything is happily flushed to disk */ 808 df = NULL; 809 810 /* remove from available space in filesystem */ 811 updfs(e, 0, 1, "collect"); 812 } 813 814 /* An EOF when running SMTP is an error */ 815 readabort: 816 if (inputerr && (OpMode == MD_SMTP || OpMode == MD_DAEMON)) 817 { 818 char *host; 819 char *problem; 820 ADDRESS *q; 821 822 host = RealHostName; 823 if (host == NULL) 824 host = "localhost"; 825 826 if (sm_io_eof(fp)) 827 problem = "unexpected close"; 828 else if (sm_io_error(fp)) 829 problem = "I/O error"; 830 else 831 problem = "read timeout"; 832 if (LogLevel > 0 && sm_io_eof(fp)) 833 sm_syslog(LOG_NOTICE, e->e_id, 834 "collect: %s on connection from %.100s, sender=%s", 835 problem, host, 836 shortenstring(e->e_from.q_paddr, MAXSHORTSTR)); 837 if (sm_io_eof(fp)) 838 usrerr("421 4.4.1 collect: %s on connection from %s, from=%s", 839 problem, host, 840 shortenstring(e->e_from.q_paddr, MAXSHORTSTR)); 841 else 842 syserr("421 4.4.1 collect: %s on connection from %s, from=%s", 843 problem, host, 844 shortenstring(e->e_from.q_paddr, MAXSHORTSTR)); 845 flush_errors(true); 846 847 /* don't return an error indication */ 848 e->e_to = NULL; 849 e->e_flags &= ~EF_FATALERRS; 850 e->e_flags |= EF_CLRQUEUE; 851 852 /* Don't send any message notification to sender */ 853 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 854 { 855 if (QS_IS_DEAD(q->q_state)) 856 continue; 857 q->q_state = QS_FATALERR; 858 } 859 860 (void) sm_io_close(df, SM_TIME_DEFAULT); 861 df = NULL; 862 finis(true, true, ExitStat); 863 /* NOTREACHED */ 864 } 865 866 /* Log collection information. */ 867 if (bitset(EF_LOGSENDER, e->e_flags) && LogLevel > 4) 868 { 869 logsender(e, e->e_msgid); 870 e->e_flags &= ~EF_LOGSENDER; 871 } 872 873 /* check for message too large */ 874 if (bitset(EF_TOOBIG, e->e_flags)) 875 { 876 e->e_flags |= EF_NO_BODY_RETN|EF_CLRQUEUE; 877 if (!bitset(EF_FATALERRS, e->e_flags)) 878 { 879 e->e_status = "5.2.3"; 880 usrerrenh(e->e_status, 881 "552 Message exceeds maximum fixed size (%ld)", 882 MaxMessageSize); 883 if (LogLevel > 6) 884 sm_syslog(LOG_NOTICE, e->e_id, 885 "message size (%ld) exceeds maximum (%ld)", 886 e->e_msgsize, MaxMessageSize); 887 } 888 } 889 890 /* check for illegal 8-bit data */ 891 if (HasEightBits) 892 { 893 e->e_flags |= EF_HAS8BIT; 894 if (!bitset(MM_PASS8BIT|MM_MIME8BIT, MimeMode) && 895 !bitset(EF_IS_MIME, e->e_flags)) 896 { 897 e->e_status = "5.6.1"; 898 usrerrenh(e->e_status, "554 Eight bit data not allowed"); 899 } 900 } 901 else 902 { 903 /* if it claimed to be 8 bits, well, it lied.... */ 904 if (e->e_bodytype != NULL && 905 sm_strcasecmp(e->e_bodytype, "8BITMIME") == 0) 906 e->e_bodytype = "7BIT"; 907 } 908 909 if (SuperSafe == SAFE_REALLY && !bitset(EF_FATALERRS, e->e_flags)) 910 { 911 char *dfname = queuename(e, DATAFL_LETTER); 912 if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname, 913 SM_IO_RDONLY_B, NULL)) == NULL) 914 { 915 /* we haven't acked receipt yet, so just chuck this */ 916 syserr("@Cannot reopen %s", dfname); 917 finis(true, true, ExitStat); 918 /* NOTREACHED */ 919 } 920 } 921 else 922 e->e_dfp = df; 923 924 /* collect statistics */ 925 if (OpMode != MD_VERIFY) 926 { 927 /* 928 ** Recalculate e_msgpriority, it is done at in eatheader() 929 ** which is called (in 8.12) after the header is collected, 930 ** hence e_msgsize is (most likely) incorrect. 931 */ 932 933 e->e_msgpriority = e->e_msgsize 934 - e->e_class * WkClassFact 935 + e->e_nrcpts * WkRecipFact; 936 markstats(e, (ADDRESS *) NULL, STATS_NORMAL); 937 } 938 } 939 940 /* 941 ** DFERROR -- signal error on writing the data file. 942 ** 943 ** Called by collect(). Collect() always terminates the process 944 ** immediately after calling dferror(), which means that the SMTP 945 ** session will be terminated, which means that any error message 946 ** issued by dferror must be a 421 error, as per RFC 821. 947 ** 948 ** Parameters: 949 ** df -- the file pointer for the data file. 950 ** msg -- detailed message. 951 ** e -- the current envelope. 952 ** 953 ** Returns: 954 ** none. 955 ** 956 ** Side Effects: 957 ** Gives an error message. 958 ** Arranges for following output to go elsewhere. 959 */ 960 961 void 962 dferror(df, msg, e) 963 SM_FILE_T *volatile df; 964 char *msg; 965 register ENVELOPE *e; 966 { 967 char *dfname; 968 969 dfname = queuename(e, DATAFL_LETTER); 970 setstat(EX_IOERR); 971 if (errno == ENOSPC) 972 { 973 #if STAT64 > 0 974 struct stat64 st; 975 #else /* STAT64 > 0 */ 976 struct stat st; 977 #endif /* STAT64 > 0 */ 978 long avail; 979 long bsize; 980 981 e->e_flags |= EF_NO_BODY_RETN; 982 983 if ( 984 #if STAT64 > 0 985 fstat64(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st) 986 #else /* STAT64 > 0 */ 987 fstat(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st) 988 #endif /* STAT64 > 0 */ 989 < 0) 990 st.st_size = 0; 991 (void) sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, dfname, 992 SM_IO_WRONLY_B, NULL, df); 993 if (st.st_size <= 0) 994 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 995 "\n*** Mail could not be accepted"); 996 else 997 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 998 "\n*** Mail of at least %llu bytes could not be accepted\n", 999 (ULONGLONG_T) st.st_size); 1000 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 1001 "*** at %s due to lack of disk space for temp file.\n", 1002 MyHostName); 1003 avail = freediskspace(qid_printqueue(e->e_qgrp, e->e_qdir), 1004 &bsize); 1005 if (avail > 0) 1006 { 1007 if (bsize > 1024) 1008 avail *= bsize / 1024; 1009 else if (bsize < 1024) 1010 avail /= 1024 / bsize; 1011 (void) sm_io_fprintf(df, SM_TIME_DEFAULT, 1012 "*** Currently, %ld kilobytes are available for mail temp files.\n", 1013 avail); 1014 } 1015 #if 0 1016 /* Wrong response code; should be 421. */ 1017 e->e_status = "4.3.1"; 1018 usrerrenh(e->e_status, "452 Out of disk space for temp file"); 1019 #else /* 0 */ 1020 syserr("421 4.3.1 Out of disk space for temp file"); 1021 #endif /* 0 */ 1022 } 1023 else 1024 syserr("421 4.3.0 collect: Cannot write %s (%s, uid=%d, gid=%d)", 1025 dfname, msg, (int) geteuid(), (int) getegid()); 1026 if (sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, SM_PATH_DEVNULL, 1027 SM_IO_WRONLY, NULL, df) == NULL) 1028 sm_syslog(LOG_ERR, e->e_id, 1029 "dferror: sm_io_reopen(\"/dev/null\") failed: %s", 1030 sm_errstring(errno)); 1031 } 1032 /* 1033 ** EATFROM -- chew up a UNIX style from line and process 1034 ** 1035 ** This does indeed make some assumptions about the format 1036 ** of UNIX messages. 1037 ** 1038 ** Parameters: 1039 ** fm -- the from line. 1040 ** e -- envelope 1041 ** 1042 ** Returns: 1043 ** none. 1044 ** 1045 ** Side Effects: 1046 ** extracts what information it can from the header, 1047 ** such as the date. 1048 */ 1049 1050 #ifndef NOTUNIX 1051 1052 static char *DowList[] = 1053 { 1054 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL 1055 }; 1056 1057 static char *MonthList[] = 1058 { 1059 "Jan", "Feb", "Mar", "Apr", "May", "Jun", 1060 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", 1061 NULL 1062 }; 1063 1064 static void 1065 eatfrom(fm, e) 1066 char *volatile fm; 1067 register ENVELOPE *e; 1068 { 1069 register char *p; 1070 register char **dt; 1071 1072 if (tTd(30, 2)) 1073 sm_dprintf("eatfrom(%s)\n", fm); 1074 1075 /* find the date part */ 1076 p = fm; 1077 while (*p != '\0') 1078 { 1079 /* skip a word */ 1080 while (*p != '\0' && *p != ' ') 1081 p++; 1082 while (*p == ' ') 1083 p++; 1084 if (strlen(p) < 17) 1085 { 1086 /* no room for the date */ 1087 return; 1088 } 1089 if (!(isascii(*p) && isupper(*p)) || 1090 p[3] != ' ' || p[13] != ':' || p[16] != ':') 1091 continue; 1092 1093 /* we have a possible date */ 1094 for (dt = DowList; *dt != NULL; dt++) 1095 if (strncmp(*dt, p, 3) == 0) 1096 break; 1097 if (*dt == NULL) 1098 continue; 1099 1100 for (dt = MonthList; *dt != NULL; dt++) 1101 { 1102 if (strncmp(*dt, &p[4], 3) == 0) 1103 break; 1104 } 1105 if (*dt != NULL) 1106 break; 1107 } 1108 1109 if (*p != '\0') 1110 { 1111 char *q, buf[25]; 1112 1113 /* we have found a date */ 1114 (void) sm_strlcpy(buf, p, sizeof(buf)); 1115 q = arpadate(buf); 1116 macdefine(&e->e_macro, A_TEMP, 'a', q); 1117 } 1118 } 1119 #endif /* ! NOTUNIX */ 1120