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