1 /* 2 * Copyright (c) 1983 Eric P. Allman 3 * Copyright (c) 1988 Regents of the University of California. 4 * All rights reserved. 5 * 6 * %sccs.include.redist.c% 7 */ 8 9 #ifndef lint 10 static char sccsid[] = "@(#)savemail.c 6.3 (Berkeley) 01/21/93"; 11 #endif /* not lint */ 12 13 # include <sys/types.h> 14 # include <pwd.h> 15 # include "sendmail.h" 16 17 /* 18 ** SAVEMAIL -- Save mail on error 19 ** 20 ** If mailing back errors, mail it back to the originator 21 ** together with an error message; otherwise, just put it in 22 ** dead.letter in the user's home directory (if he exists on 23 ** this machine). 24 ** 25 ** Parameters: 26 ** e -- the envelope containing the message in error. 27 ** 28 ** Returns: 29 ** none 30 ** 31 ** Side Effects: 32 ** Saves the letter, by writing or mailing it back to the 33 ** sender, or by putting it in dead.letter in her home 34 ** directory. 35 */ 36 37 /* defines for state machine */ 38 # define ESM_REPORT 0 /* report to sender's terminal */ 39 # define ESM_MAIL 1 /* mail back to sender */ 40 # define ESM_QUIET 2 /* messages have already been returned */ 41 # define ESM_DEADLETTER 3 /* save in ~/dead.letter */ 42 # define ESM_POSTMASTER 4 /* return to postmaster */ 43 # define ESM_USRTMP 5 /* save in /usr/tmp/dead.letter */ 44 # define ESM_PANIC 6 /* leave the locked queue/transcript files */ 45 # define ESM_DONE 7 /* the message is successfully delivered */ 46 47 48 savemail(e) 49 register ENVELOPE *e; 50 { 51 register struct passwd *pw; 52 register FILE *fp; 53 int state; 54 auto ADDRESS *q; 55 char buf[MAXLINE+1]; 56 extern struct passwd *getpwnam(); 57 register char *p; 58 extern char *ttypath(); 59 typedef int (*fnptr)(); 60 61 if (tTd(6, 1)) 62 printf("\nsavemail, ErrorMode = %c\n", ErrorMode); 63 64 if (bitset(EF_RESPONSE, e->e_flags)) 65 return; 66 ForceMail = TRUE; 67 e->e_flags &= ~EF_FATALERRS; 68 69 /* 70 ** In the unhappy event we don't know who to return the mail 71 ** to, make someone up. 72 */ 73 74 if (e->e_from.q_paddr == NULL) 75 { 76 if (parseaddr("root", &e->e_from, 0, '\0', e) == NULL) 77 { 78 syserr("Cannot parse root!"); 79 ExitStat = EX_SOFTWARE; 80 finis(); 81 } 82 } 83 e->e_to = NULL; 84 85 /* 86 ** Basic state machine. 87 ** 88 ** This machine runs through the following states: 89 ** 90 ** ESM_QUIET Errors have already been printed iff the 91 ** sender is local. 92 ** ESM_REPORT Report directly to the sender's terminal. 93 ** ESM_MAIL Mail response to the sender. 94 ** ESM_DEADLETTER Save response in ~/dead.letter. 95 ** ESM_POSTMASTER Mail response to the postmaster. 96 ** ESM_PANIC Save response anywhere possible. 97 */ 98 99 /* determine starting state */ 100 switch (ErrorMode) 101 { 102 case EM_WRITE: 103 state = ESM_REPORT; 104 break; 105 106 case EM_BERKNET: 107 /* mail back, but return o.k. exit status */ 108 ExitStat = EX_OK; 109 110 /* fall through.... */ 111 112 case EM_MAIL: 113 state = ESM_MAIL; 114 break; 115 116 case EM_PRINT: 117 case '\0': 118 state = ESM_QUIET; 119 break; 120 121 case EM_QUIET: 122 /* no need to return anything at all */ 123 return; 124 125 default: 126 syserr("savemail: ErrorMode x%x\n"); 127 state = ESM_MAIL; 128 break; 129 } 130 131 while (state != ESM_DONE) 132 { 133 if (tTd(6, 5)) 134 printf(" state %d\n", state); 135 136 switch (state) 137 { 138 case ESM_QUIET: 139 if (e->e_from.q_mailer == LocalMailer) 140 state = ESM_DEADLETTER; 141 else 142 state = ESM_MAIL; 143 break; 144 145 case ESM_REPORT: 146 147 /* 148 ** If the user is still logged in on the same terminal, 149 ** then write the error messages back to hir (sic). 150 */ 151 152 p = ttypath(); 153 if (p == NULL || freopen(p, "w", stdout) == NULL) 154 { 155 state = ESM_MAIL; 156 break; 157 } 158 159 expand("\001n", buf, &buf[sizeof buf - 1], e); 160 printf("\r\nMessage from %s...\r\n", buf); 161 printf("Errors occurred while sending mail.\r\n"); 162 if (e->e_xfp != NULL) 163 { 164 (void) fflush(e->e_xfp); 165 fp = fopen(queuename(e, 'x'), "r"); 166 } 167 else 168 fp = NULL; 169 if (fp == NULL) 170 { 171 syserr("Cannot open %s", queuename(e, 'x')); 172 printf("Transcript of session is unavailable.\r\n"); 173 } 174 else 175 { 176 printf("Transcript follows:\r\n"); 177 while (fgets(buf, sizeof buf, fp) != NULL && 178 !ferror(stdout)) 179 fputs(buf, stdout); 180 (void) fclose(fp); 181 } 182 printf("Original message will be saved in dead.letter.\r\n"); 183 state = ESM_DEADLETTER; 184 break; 185 186 case ESM_MAIL: 187 case ESM_POSTMASTER: 188 /* 189 ** If mailing back, do it. 190 ** Throw away all further output. Don't alias, 191 ** since this could cause loops, e.g., if joe 192 ** mails to joe@x, and for some reason the network 193 ** for @x is down, then the response gets sent to 194 ** joe@x, which gives a response, etc. Also force 195 ** the mail to be delivered even if a version of 196 ** it has already been sent to the sender. 197 */ 198 199 if (state == ESM_MAIL) 200 { 201 if (e->e_errorqueue == NULL) 202 sendtolist(e->e_from.q_paddr, 203 (ADDRESS *) NULL, 204 &e->e_errorqueue, e); 205 206 /* deliver a cc: to the postmaster if desired */ 207 if (PostMasterCopy != NULL) 208 sendtolist(PostMasterCopy, 209 (ADDRESS *) NULL, 210 &e->e_errorqueue, e); 211 q = e->e_errorqueue; 212 } 213 else 214 { 215 if (parseaddr("postmaster", q, 0, '\0', e) == NULL) 216 { 217 syserr("cannot parse postmaster!"); 218 ExitStat = EX_SOFTWARE; 219 state = ESM_USRTMP; 220 break; 221 } 222 } 223 if (returntosender(e->e_message != NULL ? e->e_message : 224 "Unable to deliver mail", 225 q, (e->e_class >= 0), e) == 0) 226 { 227 state = ESM_DONE; 228 break; 229 } 230 231 state = state == ESM_MAIL ? ESM_POSTMASTER : ESM_USRTMP; 232 break; 233 234 case ESM_DEADLETTER: 235 /* 236 ** Save the message in dead.letter. 237 ** If we weren't mailing back, and the user is 238 ** local, we should save the message in 239 ** ~/dead.letter so that the poor person doesn't 240 ** have to type it over again -- and we all know 241 ** what poor typists UNIX users are. 242 */ 243 244 p = NULL; 245 if (e->e_from.q_mailer == LocalMailer) 246 { 247 if (e->e_from.q_home != NULL) 248 p = e->e_from.q_home; 249 else if ((pw = getpwnam(e->e_from.q_user)) != NULL) 250 p = pw->pw_dir; 251 } 252 if (p == NULL) 253 { 254 syserr("Can't return mail to %s", e->e_from.q_paddr); 255 state = ESM_MAIL; 256 break; 257 } 258 if (e->e_dfp != NULL) 259 { 260 auto ADDRESS *q; 261 bool oldverb = Verbose; 262 263 /* we have a home directory; open dead.letter */ 264 define('z', p, e); 265 expand("\001z/dead.letter", buf, &buf[sizeof buf - 1], e); 266 Verbose = TRUE; 267 message(Arpa_Info, "Saving message in %s", buf); 268 Verbose = oldverb; 269 e->e_to = buf; 270 q = NULL; 271 sendtolist(buf, (ADDRESS *) NULL, &q, e); 272 if (deliver(e, q) == 0) 273 state = ESM_DONE; 274 else 275 state = ESM_MAIL; 276 } 277 else 278 { 279 /* no data file -- try mailing back */ 280 state = ESM_MAIL; 281 } 282 break; 283 284 case ESM_USRTMP: 285 /* 286 ** Log the mail in /usr/tmp/dead.letter. 287 */ 288 289 if (e->e_class < 0) 290 { 291 state = ESM_DONE; 292 break; 293 } 294 295 fp = dfopen("/usr/tmp/dead.letter", "a"); 296 if (fp == NULL) 297 { 298 state = ESM_PANIC; 299 break; 300 } 301 302 putfromline(fp, ProgMailer, e); 303 (*e->e_puthdr)(fp, ProgMailer, e); 304 putline("\n", fp, ProgMailer); 305 (*e->e_putbody)(fp, ProgMailer, e); 306 putline("\n", fp, ProgMailer); 307 (void) fflush(fp); 308 state = ferror(fp) ? ESM_PANIC : ESM_DONE; 309 (void) fclose(fp); 310 break; 311 312 default: 313 syserr("savemail: unknown state %d", state); 314 315 /* fall through ... */ 316 317 case ESM_PANIC: 318 /* leave the locked queue & transcript files around */ 319 syserr("savemail: cannot save rejected email anywhere"); 320 exit(EX_SOFTWARE); 321 } 322 } 323 } 324 /* 325 ** RETURNTOSENDER -- return a message to the sender with an error. 326 ** 327 ** Parameters: 328 ** msg -- the explanatory message. 329 ** returnq -- the queue of people to send the message to. 330 ** sendbody -- if TRUE, also send back the body of the 331 ** message; otherwise just send the header. 332 ** e -- the current envelope. 333 ** 334 ** Returns: 335 ** zero -- if everything went ok. 336 ** else -- some error. 337 ** 338 ** Side Effects: 339 ** Returns the current message to the sender via 340 ** mail. 341 */ 342 343 static bool SendBody; 344 345 #define MAXRETURNS 6 /* max depth of returning messages */ 346 347 returntosender(msg, returnq, sendbody, e) 348 char *msg; 349 ADDRESS *returnq; 350 bool sendbody; 351 register ENVELOPE *e; 352 { 353 char buf[MAXNAME]; 354 extern putheader(), errbody(); 355 register ENVELOPE *ee; 356 extern ENVELOPE *newenvelope(); 357 ENVELOPE errenvelope; 358 static int returndepth; 359 register ADDRESS *q; 360 361 if (tTd(6, 1)) 362 { 363 printf("Return To Sender: msg=\"%s\", depth=%d, e=%x,\n", 364 msg, returndepth, e); 365 printf("\treturnq="); 366 printaddr(returnq, TRUE); 367 } 368 369 if (++returndepth >= MAXRETURNS) 370 { 371 if (returndepth != MAXRETURNS) 372 syserr("returntosender: infinite recursion on %s", returnq->q_paddr); 373 /* don't "unrecurse" and fake a clean exit */ 374 /* returndepth--; */ 375 return (0); 376 } 377 378 SendBody = sendbody; 379 define('g', "\001f", e); 380 define('<', "\001f", e); 381 ee = newenvelope(&errenvelope); 382 define('a', "\001b", ee); 383 ee->e_puthdr = putheader; 384 ee->e_putbody = errbody; 385 ee->e_flags |= EF_RESPONSE; 386 if (!bitset(EF_OLDSTYLE, e->e_flags)) 387 ee->e_flags &= ~EF_OLDSTYLE; 388 ee->e_sendqueue = returnq; 389 openxscript(ee); 390 for (q = returnq; q != NULL; q = q->q_next) 391 { 392 if (q->q_alias == NULL) 393 addheader("to", q->q_paddr, ee); 394 } 395 396 # ifdef LOG 397 if (LogLevel >= 3) 398 syslog(LOG_INFO, "%s: %s: return to sender: %s", 399 e->e_id, ee->e_id, msg); 400 # endif 401 402 (void) sprintf(buf, "Returned mail: %s", msg); 403 addheader("subject", buf, ee); 404 405 /* fake up an address header for the from person */ 406 expand("\001n", buf, &buf[sizeof buf - 1], e); 407 ee->e_sender = ee->e_returnpath = newstr(buf); 408 if (parseaddr(buf, &ee->e_from, -1, '\0', e) == NULL) 409 { 410 syserr("Can't parse myself!"); 411 ExitStat = EX_SOFTWARE; 412 returndepth--; 413 return (-1); 414 } 415 loweraddr(&ee->e_from); 416 417 /* push state into submessage */ 418 CurEnv = ee; 419 define('f', "\001n", ee); 420 define('x', "Mail Delivery Subsystem", ee); 421 eatheader(ee, FALSE); 422 423 /* actually deliver the error message */ 424 sendall(ee, SM_DEFAULT); 425 426 /* restore state */ 427 dropenvelope(ee); 428 CurEnv = CurEnv->e_parent; 429 returndepth--; 430 431 /* should check for delivery errors here */ 432 return (0); 433 } 434 /* 435 ** ERRBODY -- output the body of an error message. 436 ** 437 ** Typically this is a copy of the transcript plus a copy of the 438 ** original offending message. 439 ** 440 ** Parameters: 441 ** fp -- the output file. 442 ** m -- the mailer to output to. 443 ** e -- the envelope we are working in. 444 ** 445 ** Returns: 446 ** none 447 ** 448 ** Side Effects: 449 ** Outputs the body of an error message. 450 */ 451 452 errbody(fp, m, e) 453 register FILE *fp; 454 register struct mailer *m; 455 register ENVELOPE *e; 456 { 457 register FILE *xfile; 458 char buf[MAXLINE]; 459 char *p; 460 461 /* 462 ** Output error message header (if specified and available). 463 */ 464 465 if (ErrMsgFile != NULL) 466 { 467 if (*ErrMsgFile == '/') 468 { 469 xfile = fopen(ErrMsgFile, "r"); 470 if (xfile != NULL) 471 { 472 while (fgets(buf, sizeof buf, xfile) != NULL) 473 { 474 expand(buf, buf, &buf[sizeof buf - 1], e); 475 putline(buf, fp, m); 476 } 477 (void) fclose(xfile); 478 fprintf(fp, "\n"); 479 } 480 } 481 else 482 { 483 expand(ErrMsgFile, buf, &buf[sizeof buf - 1], e); 484 putline(buf, fp, m); 485 fprintf(fp, "\n"); 486 } 487 } 488 489 /* 490 ** Output transcript of errors 491 */ 492 493 (void) fflush(stdout); 494 p = queuename(e->e_parent, 'x'); 495 if ((xfile = fopen(p, "r")) == NULL) 496 { 497 syserr("Cannot open %s", p); 498 fprintf(fp, " ----- Transcript of session is unavailable -----\n"); 499 } 500 else 501 { 502 fprintf(fp, " ----- Transcript of session follows -----\n"); 503 if (e->e_xfp != NULL) 504 (void) fflush(e->e_xfp); 505 while (fgets(buf, sizeof buf, xfile) != NULL) 506 putline(buf, fp, m); 507 (void) fclose(xfile); 508 } 509 errno = 0; 510 511 /* 512 ** Output text of original message 513 */ 514 515 if (NoReturn) 516 fprintf(fp, "\n ----- Return message suppressed -----\n\n"); 517 else if (e->e_parent->e_dfp != NULL) 518 { 519 if (SendBody) 520 { 521 putline("\n", fp, m); 522 putline(" ----- Unsent message follows -----\n", fp, m); 523 (void) fflush(fp); 524 putheader(fp, m, e->e_parent); 525 putline("\n", fp, m); 526 putbody(fp, m, e->e_parent); 527 } 528 else 529 { 530 putline("\n", fp, m); 531 putline(" ----- Message header follows -----\n", fp, m); 532 (void) fflush(fp); 533 putheader(fp, m, e->e_parent); 534 } 535 } 536 else 537 { 538 putline("\n", fp, m); 539 putline(" ----- No message was collected -----\n", fp, m); 540 putline("\n", fp, m); 541 } 542 543 /* 544 ** Cleanup and exit 545 */ 546 547 if (errno != 0) 548 syserr("errbody: I/O error"); 549 } 550