1 /* 2 * Copyright (c) 1983 Eric P. Allman 3 * Copyright (c) 1988, 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * %sccs.include.redist.c% 7 */ 8 9 #ifndef lint 10 static char sccsid[] = "@(#)savemail.c 8.2 (Berkeley) 07/11/93"; 11 #endif /* not lint */ 12 13 # include <pwd.h> 14 # include "sendmail.h" 15 16 /* 17 ** SAVEMAIL -- Save mail on error 18 ** 19 ** If mailing back errors, mail it back to the originator 20 ** together with an error message; otherwise, just put it in 21 ** dead.letter in the user's home directory (if he exists on 22 ** this machine). 23 ** 24 ** Parameters: 25 ** e -- the envelope containing the message in error. 26 ** 27 ** Returns: 28 ** none 29 ** 30 ** Side Effects: 31 ** Saves the letter, by writing or mailing it back to the 32 ** sender, or by putting it in dead.letter in her home 33 ** directory. 34 */ 35 36 /* defines for state machine */ 37 # define ESM_REPORT 0 /* report to sender's terminal */ 38 # define ESM_MAIL 1 /* mail back to sender */ 39 # define ESM_QUIET 2 /* messages have already been returned */ 40 # define ESM_DEADLETTER 3 /* save in ~/dead.letter */ 41 # define ESM_POSTMASTER 4 /* return to postmaster */ 42 # define ESM_USRTMP 5 /* save in /usr/tmp/dead.letter */ 43 # define ESM_PANIC 6 /* leave the locked queue/transcript files */ 44 # define ESM_DONE 7 /* the message is successfully delivered */ 45 46 47 savemail(e) 48 register ENVELOPE *e; 49 { 50 register struct passwd *pw; 51 register FILE *fp; 52 int state; 53 auto ADDRESS *q = NULL; 54 char buf[MAXLINE+1]; 55 extern struct passwd *getpwnam(); 56 register char *p; 57 extern char *ttypath(); 58 typedef int (*fnptr)(); 59 60 if (tTd(6, 1)) 61 { 62 printf("\nsavemail, errormode = %c, id = %s\n e_from=", 63 e->e_errormode, e->e_id == NULL ? "NONE" : e->e_id); 64 printaddr(&e->e_from, FALSE); 65 } 66 67 if (e->e_id == NULL) 68 { 69 /* can't return a message with no id */ 70 return; 71 } 72 73 e->e_flags &= ~EF_FATALERRS; 74 75 /* 76 ** In the unhappy event we don't know who to return the mail 77 ** to, make someone up. 78 */ 79 80 if (e->e_from.q_paddr == NULL) 81 { 82 e->e_sender = "Postmaster"; 83 if (parseaddr(e->e_sender, &e->e_from, 0, '\0', NULL, e) == NULL) 84 { 85 syserr("553 Cannot parse Postmaster!"); 86 ExitStat = EX_SOFTWARE; 87 finis(); 88 } 89 } 90 e->e_to = NULL; 91 92 /* 93 ** Basic state machine. 94 ** 95 ** This machine runs through the following states: 96 ** 97 ** ESM_QUIET Errors have already been printed iff the 98 ** sender is local. 99 ** ESM_REPORT Report directly to the sender's terminal. 100 ** ESM_MAIL Mail response to the sender. 101 ** ESM_DEADLETTER Save response in ~/dead.letter. 102 ** ESM_POSTMASTER Mail response to the postmaster. 103 ** ESM_PANIC Save response anywhere possible. 104 */ 105 106 /* determine starting state */ 107 switch (e->e_errormode) 108 { 109 case EM_WRITE: 110 state = ESM_REPORT; 111 break; 112 113 case EM_BERKNET: 114 /* mail back, but return o.k. exit status */ 115 ExitStat = EX_OK; 116 117 /* fall through.... */ 118 119 case EM_MAIL: 120 state = ESM_MAIL; 121 break; 122 123 case EM_PRINT: 124 case '\0': 125 state = ESM_QUIET; 126 break; 127 128 case EM_QUIET: 129 /* no need to return anything at all */ 130 return; 131 132 default: 133 syserr("554 savemail: bogus errormode x%x\n", e->e_errormode); 134 state = ESM_MAIL; 135 break; 136 } 137 138 /* if this is already an error response, send to postmaster */ 139 if (bitset(EF_RESPONSE, e->e_flags)) 140 { 141 if (e->e_parent != NULL && 142 bitset(EF_RESPONSE, e->e_parent->e_flags)) 143 { 144 /* got an error sending a response -- can it */ 145 return; 146 } 147 state = ESM_POSTMASTER; 148 } 149 150 while (state != ESM_DONE) 151 { 152 if (tTd(6, 5)) 153 printf(" state %d\n", state); 154 155 switch (state) 156 { 157 case ESM_QUIET: 158 if (e->e_from.q_mailer == LocalMailer) 159 state = ESM_DEADLETTER; 160 else 161 state = ESM_MAIL; 162 break; 163 164 case ESM_REPORT: 165 166 /* 167 ** If the user is still logged in on the same terminal, 168 ** then write the error messages back to hir (sic). 169 */ 170 171 p = ttypath(); 172 if (p == NULL || freopen(p, "w", stdout) == NULL) 173 { 174 state = ESM_MAIL; 175 break; 176 } 177 178 expand("\201n", buf, &buf[sizeof buf - 1], e); 179 printf("\r\nMessage from %s...\r\n", buf); 180 printf("Errors occurred while sending mail.\r\n"); 181 if (e->e_xfp != NULL) 182 { 183 (void) fflush(e->e_xfp); 184 fp = fopen(queuename(e, 'x'), "r"); 185 } 186 else 187 fp = NULL; 188 if (fp == NULL) 189 { 190 syserr("Cannot open %s", queuename(e, 'x')); 191 printf("Transcript of session is unavailable.\r\n"); 192 } 193 else 194 { 195 printf("Transcript follows:\r\n"); 196 while (fgets(buf, sizeof buf, fp) != NULL && 197 !ferror(stdout)) 198 fputs(buf, stdout); 199 (void) xfclose(fp, "savemail transcript", e->e_id); 200 } 201 printf("Original message will be saved in dead.letter.\r\n"); 202 state = ESM_DEADLETTER; 203 break; 204 205 case ESM_MAIL: 206 /* 207 ** If mailing back, do it. 208 ** Throw away all further output. Don't alias, 209 ** since this could cause loops, e.g., if joe 210 ** mails to joe@x, and for some reason the network 211 ** for @x is down, then the response gets sent to 212 ** joe@x, which gives a response, etc. Also force 213 ** the mail to be delivered even if a version of 214 ** it has already been sent to the sender. 215 */ 216 217 if (strcmp(e->e_from.q_paddr, "<>") != 0) 218 (void) sendtolist(e->e_from.q_paddr, 219 (ADDRESS *) NULL, 220 &e->e_errorqueue, e); 221 222 /* deliver a cc: to the postmaster if desired */ 223 if (PostMasterCopy != NULL) 224 { 225 auto ADDRESS *rlist = NULL; 226 227 (void) sendtolist(PostMasterCopy, 228 (ADDRESS *) NULL, 229 &rlist, e); 230 (void) returntosender(e->e_message, 231 rlist, FALSE, e); 232 } 233 q = e->e_errorqueue; 234 if (q == NULL) 235 { 236 /* this is an error-error */ 237 state = ESM_POSTMASTER; 238 break; 239 } 240 if (returntosender(e->e_message, 241 q, (e->e_class >= 0), e) == 0) 242 { 243 state = ESM_DONE; 244 break; 245 } 246 247 /* didn't work -- return to postmaster */ 248 state = ESM_POSTMASTER; 249 break; 250 251 case ESM_POSTMASTER: 252 /* 253 ** Similar to previous case, but to system postmaster. 254 */ 255 256 q = NULL; 257 if (sendtolist("postmaster", NULL, &q, e) <= 0) 258 { 259 syserr("553 cannot parse postmaster!"); 260 ExitStat = EX_SOFTWARE; 261 state = ESM_USRTMP; 262 break; 263 } 264 if (returntosender(e->e_message, 265 q, (e->e_class >= 0), e) == 0) 266 { 267 state = ESM_DONE; 268 break; 269 } 270 271 /* didn't work -- last resort */ 272 state = ESM_USRTMP; 273 break; 274 275 case ESM_DEADLETTER: 276 /* 277 ** Save the message in dead.letter. 278 ** If we weren't mailing back, and the user is 279 ** local, we should save the message in 280 ** ~/dead.letter so that the poor person doesn't 281 ** have to type it over again -- and we all know 282 ** what poor typists UNIX users are. 283 */ 284 285 p = NULL; 286 if (e->e_from.q_mailer == LocalMailer) 287 { 288 if (e->e_from.q_home != NULL) 289 p = e->e_from.q_home; 290 else if ((pw = getpwnam(e->e_from.q_user)) != NULL) 291 p = pw->pw_dir; 292 } 293 if (p == NULL) 294 { 295 /* no local directory */ 296 state = ESM_MAIL; 297 break; 298 } 299 if (e->e_dfp != NULL) 300 { 301 bool oldverb = Verbose; 302 303 /* we have a home directory; open dead.letter */ 304 define('z', p, e); 305 expand("\201z/dead.letter", buf, &buf[sizeof buf - 1], e); 306 Verbose = TRUE; 307 message("Saving message in %s", buf); 308 Verbose = oldverb; 309 e->e_to = buf; 310 q = NULL; 311 (void) sendtolist(buf, &e->e_from, &q, e); 312 if (deliver(e, q) == 0) 313 state = ESM_DONE; 314 else 315 state = ESM_MAIL; 316 } 317 else 318 { 319 /* no data file -- try mailing back */ 320 state = ESM_MAIL; 321 } 322 break; 323 324 case ESM_USRTMP: 325 /* 326 ** Log the mail in /usr/tmp/dead.letter. 327 */ 328 329 if (e->e_class < 0) 330 { 331 state = ESM_DONE; 332 break; 333 } 334 335 fp = dfopen("/usr/tmp/dead.letter", 336 O_WRONLY|O_CREAT|O_APPEND, FileMode); 337 if (fp == NULL) 338 { 339 state = ESM_PANIC; 340 break; 341 } 342 343 putfromline(fp, FileMailer, e); 344 (*e->e_puthdr)(fp, FileMailer, e); 345 putline("\n", fp, FileMailer); 346 (*e->e_putbody)(fp, FileMailer, e, NULL); 347 putline("\n", fp, FileMailer); 348 (void) fflush(fp); 349 state = ferror(fp) ? ESM_PANIC : ESM_DONE; 350 (void) xfclose(fp, "savemail", "/usr/tmp/dead.letter"); 351 break; 352 353 default: 354 syserr("554 savemail: unknown state %d", state); 355 356 /* fall through ... */ 357 358 case ESM_PANIC: 359 /* leave the locked queue & transcript files around */ 360 syserr("554 savemail: cannot save rejected email anywhere"); 361 exit(EX_SOFTWARE); 362 } 363 } 364 } 365 /* 366 ** RETURNTOSENDER -- return a message to the sender with an error. 367 ** 368 ** Parameters: 369 ** msg -- the explanatory message. 370 ** returnq -- the queue of people to send the message to. 371 ** sendbody -- if TRUE, also send back the body of the 372 ** message; otherwise just send the header. 373 ** e -- the current envelope. 374 ** 375 ** Returns: 376 ** zero -- if everything went ok. 377 ** else -- some error. 378 ** 379 ** Side Effects: 380 ** Returns the current message to the sender via 381 ** mail. 382 */ 383 384 static bool SendBody; 385 386 #define MAXRETURNS 6 /* max depth of returning messages */ 387 #define ERRORFUDGE 100 /* nominal size of error message text */ 388 389 returntosender(msg, returnq, sendbody, e) 390 char *msg; 391 ADDRESS *returnq; 392 bool sendbody; 393 register ENVELOPE *e; 394 { 395 char buf[MAXNAME]; 396 extern putheader(), errbody(); 397 register ENVELOPE *ee; 398 ENVELOPE *oldcur = CurEnv; 399 ENVELOPE errenvelope; 400 static int returndepth; 401 register ADDRESS *q; 402 403 if (returnq == NULL) 404 return (-1); 405 406 if (msg == NULL) 407 msg = "Unable to deliver mail"; 408 409 if (tTd(6, 1)) 410 { 411 printf("Return To Sender: msg=\"%s\", depth=%d, e=%x, returnq=", 412 msg, returndepth, e); 413 printaddr(returnq, TRUE); 414 } 415 416 if (++returndepth >= MAXRETURNS) 417 { 418 if (returndepth != MAXRETURNS) 419 syserr("554 returntosender: infinite recursion on %s", returnq->q_paddr); 420 /* don't "unrecurse" and fake a clean exit */ 421 /* returndepth--; */ 422 return (0); 423 } 424 425 SendBody = sendbody; 426 define('g', e->e_from.q_paddr, e); 427 ee = newenvelope(&errenvelope, e); 428 define('a', "\201b", ee); 429 define('r', "internal", ee); 430 define('s', "localhost", ee); 431 define('_', "localhost", ee); 432 ee->e_puthdr = putheader; 433 ee->e_putbody = errbody; 434 ee->e_flags |= EF_RESPONSE; 435 if (!bitset(EF_OLDSTYLE, e->e_flags)) 436 ee->e_flags &= ~EF_OLDSTYLE; 437 ee->e_sendqueue = returnq; 438 ee->e_msgsize = e->e_msgsize + ERRORFUDGE; 439 openxscript(ee); 440 for (q = returnq; q != NULL; q = q->q_next) 441 { 442 if (bitset(QBADADDR, q->q_flags)) 443 continue; 444 445 if (!bitset(QDONTSEND, q->q_flags)) 446 ee->e_nrcpts++; 447 448 if (!DontPruneRoutes && pruneroute(q->q_paddr)) 449 parseaddr(q->q_paddr, q, 0, '\0', NULL, e); 450 451 if (q->q_alias == NULL) 452 addheader("To", q->q_paddr, ee); 453 } 454 455 # ifdef LOG 456 if (LogLevel > 5) 457 syslog(LOG_INFO, "%s: %s: return to sender: %s", 458 e->e_id, ee->e_id, msg); 459 # endif 460 461 (void) sprintf(buf, "Returned mail: %s", msg); 462 addheader("Subject", buf, ee); 463 if (SendMIMEErrors) 464 { 465 addheader("MIME-Version", "1.0", ee); 466 (void) sprintf(buf, "%s.%ld/%s", 467 ee->e_id, curtime(), MyHostName); 468 ee->e_msgboundary = newstr(buf); 469 (void) sprintf(buf, "multipart/mixed; boundary=\"%s\"", 470 ee->e_msgboundary); 471 addheader("Content-Type", buf, ee); 472 } 473 474 /* fake up an address header for the from person */ 475 expand("\201n", buf, &buf[sizeof buf - 1], e); 476 if (parseaddr(buf, &ee->e_from, 1, '\0', NULL, e) == NULL) 477 { 478 syserr("553 Can't parse myself!"); 479 ExitStat = EX_SOFTWARE; 480 returndepth--; 481 return (-1); 482 } 483 ee->e_sender = ee->e_from.q_paddr; 484 485 /* push state into submessage */ 486 CurEnv = ee; 487 define('f', "\201n", ee); 488 define('x', "Mail Delivery Subsystem", ee); 489 eatheader(ee, TRUE); 490 491 /* mark statistics */ 492 markstats(ee, (ADDRESS *) NULL); 493 494 /* actually deliver the error message */ 495 sendall(ee, SM_DEFAULT); 496 497 /* restore state */ 498 dropenvelope(ee); 499 CurEnv = oldcur; 500 returndepth--; 501 502 /* should check for delivery errors here */ 503 return (0); 504 } 505 /* 506 ** ERRBODY -- output the body of an error message. 507 ** 508 ** Typically this is a copy of the transcript plus a copy of the 509 ** original offending message. 510 ** 511 ** Parameters: 512 ** fp -- the output file. 513 ** m -- the mailer to output to. 514 ** e -- the envelope we are working in. 515 ** 516 ** Returns: 517 ** none 518 ** 519 ** Side Effects: 520 ** Outputs the body of an error message. 521 */ 522 523 errbody(fp, m, e) 524 register FILE *fp; 525 register struct mailer *m; 526 register ENVELOPE *e; 527 { 528 register FILE *xfile; 529 char *p; 530 register ADDRESS *q; 531 bool printheader; 532 char buf[MAXLINE]; 533 534 if (e->e_parent == NULL) 535 { 536 syserr("errbody: null parent"); 537 putline(" ----- Original message lost -----\n", fp, m); 538 return; 539 } 540 541 /* 542 ** Output MIME header. 543 */ 544 545 if (e->e_msgboundary != NULL) 546 { 547 putline("This is a MIME-encapsulated message", fp, m); 548 putline("", fp, m); 549 (void) sprintf(buf, "--%s", e->e_msgboundary); 550 putline(buf, fp, m); 551 putline("", fp, m); 552 } 553 554 /* 555 ** Output error message header (if specified and available). 556 */ 557 558 if (ErrMsgFile != NULL) 559 { 560 if (*ErrMsgFile == '/') 561 { 562 xfile = fopen(ErrMsgFile, "r"); 563 if (xfile != NULL) 564 { 565 while (fgets(buf, sizeof buf, xfile) != NULL) 566 { 567 expand(buf, buf, &buf[sizeof buf - 1], e); 568 putline(buf, fp, m); 569 } 570 (void) fclose(xfile); 571 putline("\n", fp, m); 572 } 573 } 574 else 575 { 576 expand(ErrMsgFile, buf, &buf[sizeof buf - 1], e); 577 putline(buf, fp, m); 578 putline("", fp, m); 579 } 580 } 581 582 /* 583 ** Output message introduction 584 */ 585 586 printheader = TRUE; 587 for (q = e->e_parent->e_sendqueue; q != NULL; q = q->q_next) 588 { 589 if (bitset(QBADADDR, q->q_flags)) 590 { 591 if (printheader) 592 { 593 putline(" ----- The following addresses failed -----", 594 fp, m); 595 printheader = FALSE; 596 } 597 if (q->q_alias != NULL) 598 putline(q->q_alias->q_paddr, fp, m); 599 else 600 putline(q->q_paddr, fp, m); 601 } 602 } 603 if (!printheader) 604 putline("\n", fp, m); 605 606 /* 607 ** Output transcript of errors 608 */ 609 610 (void) fflush(stdout); 611 p = queuename(e->e_parent, 'x'); 612 if ((xfile = fopen(p, "r")) == NULL) 613 { 614 syserr("Cannot open %s", p); 615 putline(" ----- Transcript of session is unavailable -----\n", fp, m); 616 } 617 else 618 { 619 putline(" ----- Transcript of session follows -----\n", fp, m); 620 if (e->e_xfp != NULL) 621 (void) fflush(e->e_xfp); 622 while (fgets(buf, sizeof buf, xfile) != NULL) 623 putline(buf, fp, m); 624 (void) xfclose(xfile, "errbody xscript", p); 625 } 626 errno = 0; 627 628 /* 629 ** Output text of original message 630 */ 631 632 if (NoReturn) 633 SendBody = FALSE; 634 putline("", fp, m); 635 if (e->e_parent->e_df != NULL) 636 { 637 if (SendBody) 638 putline(" ----- Unsent message follows -----\n", fp, m); 639 else 640 putline(" ----- Message header follows -----\n", fp, m); 641 (void) fflush(fp); 642 643 if (e->e_msgboundary != NULL) 644 { 645 putline("", fp, m); 646 (void) sprintf(buf, "--%s", e->e_msgboundary); 647 putline(buf, fp, m); 648 putline("Content-Type: message/rfc822", fp, m); 649 putline("", fp, m); 650 } 651 putheader(fp, m, e->e_parent); 652 putline("", fp, m); 653 if (SendBody) 654 putbody(fp, m, e->e_parent, e->e_msgboundary); 655 else 656 putline(" ----- Message body suppressed -----", fp, m); 657 } 658 else 659 { 660 putline(" ----- No message was collected -----\n", fp, m); 661 } 662 663 if (e->e_msgboundary != NULL) 664 { 665 putline("", fp, m); 666 (void) sprintf(buf, "--%s--", e->e_msgboundary); 667 putline(buf, fp, m); 668 } 669 putline("", fp, m); 670 671 /* 672 ** Cleanup and exit 673 */ 674 675 if (errno != 0) 676 syserr("errbody: I/O error"); 677 } 678 /* 679 ** PRUNEROUTE -- prune an RFC-822 source route 680 ** 681 ** Trims down a source route to the last internet-registered hop. 682 ** This is encouraged by RFC 1123 section 5.3.3. 683 ** 684 ** Parameters: 685 ** addr -- the address 686 ** 687 ** Returns: 688 ** TRUE -- address was modified 689 ** FALSE -- address could not be pruned 690 ** 691 ** Side Effects: 692 ** modifies addr in-place 693 */ 694 695 pruneroute(addr) 696 char *addr; 697 { 698 #ifdef NAMED_BIND 699 char *start, *at, *comma; 700 char c; 701 int rcode; 702 char hostbuf[BUFSIZ]; 703 char *mxhosts[MAXMXHOSTS + 1]; 704 705 /* check to see if this is really a route-addr */ 706 if (*addr != '<' || addr[1] != '@' || addr[strlen(addr) - 1] != '>') 707 return FALSE; 708 start = strchr(addr, ':'); 709 at = strrchr(addr, '@'); 710 if (start == NULL || at == NULL || at < start) 711 return FALSE; 712 713 /* slice off the angle brackets */ 714 strcpy(hostbuf, at + 1); 715 hostbuf[strlen(hostbuf) - 1] = '\0'; 716 717 while (start) 718 { 719 if (getmxrr(hostbuf, mxhosts, FALSE, &rcode) > 0) 720 { 721 strcpy(addr + 1, start + 1); 722 return TRUE; 723 } 724 c = *start; 725 *start = '\0'; 726 comma = strrchr(addr, ','); 727 if (comma && comma[1] == '@') 728 strcpy(hostbuf, comma + 2); 729 else 730 comma = 0; 731 *start = c; 732 start = comma; 733 } 734 #endif 735 return FALSE; 736 } 737