1 # include <pwd.h> 2 # include "sendmail.h" 3 4 SCCSID(@(#)savemail.c 4.1 07/25/83); 5 6 /* 7 ** SAVEMAIL -- Save mail on error 8 ** 9 ** If mailing back errors, mail it back to the originator 10 ** together with an error message; otherwise, just put it in 11 ** dead.letter in the user's home directory (if he exists on 12 ** this machine). 13 ** 14 ** Parameters: 15 ** e -- the envelope containing the message in error. 16 ** 17 ** Returns: 18 ** none 19 ** 20 ** Side Effects: 21 ** Saves the letter, by writing or mailing it back to the 22 ** sender, or by putting it in dead.letter in her home 23 ** directory. 24 */ 25 26 savemail(e) 27 register ENVELOPE *e; 28 { 29 register struct passwd *pw; 30 register FILE *xfile; 31 char buf[MAXLINE+1]; 32 extern struct passwd *getpwnam(); 33 register char *p; 34 extern char *ttypath(); 35 typedef int (*fnptr)(); 36 37 # ifdef DEBUG 38 if (tTd(6, 1)) 39 printf("\nsavemail\n"); 40 # endif DEBUG 41 42 if (bitset(EF_RESPONSE, e->e_flags)) 43 return; 44 if (e->e_class < 0) 45 { 46 message(Arpa_Info, "Dumping junk mail"); 47 return; 48 } 49 ForceMail = TRUE; 50 e->e_flags &= ~EF_FATALERRS; 51 52 /* 53 ** In the unhappy event we don't know who to return the mail 54 ** to, make someone up. 55 */ 56 57 if (e->e_from.q_paddr == NULL) 58 { 59 if (parseaddr("root", &e->e_from, 0, '\0') == NULL) 60 { 61 syserr("Cannot parse root!"); 62 ExitStat = EX_SOFTWARE; 63 finis(); 64 } 65 } 66 e->e_to = NULL; 67 68 /* 69 ** If called from Eric Schmidt's network, do special mailback. 70 ** Fundamentally, this is the mailback case except that 71 ** it returns an OK exit status (assuming the return 72 ** worked). 73 ** Also, if the from address is not local, mail it back. 74 */ 75 76 if (ErrorMode == EM_BERKNET) 77 { 78 ExitStat = EX_OK; 79 ErrorMode = EM_MAIL; 80 } 81 if (!bitnset(M_LOCAL, e->e_from.q_mailer->m_flags)) 82 ErrorMode = EM_MAIL; 83 84 /* 85 ** If writing back, do it. 86 ** If the user is still logged in on the same terminal, 87 ** then write the error messages back to hir (sic). 88 ** If not, mail back instead. 89 */ 90 91 if (ErrorMode == EM_WRITE) 92 { 93 p = ttypath(); 94 if (p == NULL || freopen(p, "w", stdout) == NULL) 95 { 96 ErrorMode = EM_MAIL; 97 errno = 0; 98 } 99 else 100 { 101 expand("$n", buf, &buf[sizeof buf - 1], e); 102 printf("\r\nMessage from %s...\r\n", buf); 103 printf("Errors occurred while sending mail.\r\n"); 104 if (e->e_xfp != NULL) 105 { 106 (void) fflush(e->e_xfp); 107 xfile = fopen(queuename(e, 'x'), "r"); 108 } 109 else 110 xfile = NULL; 111 if (xfile == NULL) 112 { 113 syserr("Cannot open %s", queuename(e, 'x')); 114 printf("Transcript of session is unavailable.\r\n"); 115 } 116 else 117 { 118 printf("Transcript follows:\r\n"); 119 while (fgets(buf, sizeof buf, xfile) != NULL && 120 !ferror(stdout)) 121 fputs(buf, stdout); 122 (void) fclose(xfile); 123 } 124 if (ferror(stdout)) 125 (void) syserr("savemail: stdout: write err"); 126 } 127 } 128 129 /* 130 ** If mailing back, do it. 131 ** Throw away all further output. Don't do aliases, since 132 ** this could cause loops, e.g., if joe mails to x:joe, 133 ** and for some reason the network for x: is down, then 134 ** the response gets sent to x:joe, which gives a 135 ** response, etc. Also force the mail to be delivered 136 ** even if a version of it has already been sent to the 137 ** sender. 138 */ 139 140 if (ErrorMode == EM_MAIL) 141 { 142 if (e->e_errorqueue == NULL) 143 sendtolist(e->e_from.q_paddr, (ADDRESS *) NULL, 144 &e->e_errorqueue); 145 if (returntosender(e->e_message != NULL ? e->e_message : 146 "Unable to deliver mail", 147 e->e_errorqueue, TRUE) == 0) 148 return; 149 } 150 151 /* 152 ** Save the message in dead.letter. 153 ** If we weren't mailing back, and the user is local, we 154 ** should save the message in dead.letter so that the 155 ** poor person doesn't have to type it over again -- 156 ** and we all know what poor typists programmers are. 157 */ 158 159 p = NULL; 160 if (e->e_from.q_mailer == LocalMailer) 161 { 162 if (e->e_from.q_home != NULL) 163 p = e->e_from.q_home; 164 else if ((pw = getpwnam(e->e_from.q_user)) != NULL) 165 p = pw->pw_dir; 166 } 167 if (p == NULL) 168 { 169 syserr("Can't return mail to %s", e->e_from.q_paddr); 170 # ifdef DEBUG 171 p = "/usr/tmp"; 172 # endif 173 } 174 if (p != NULL && e->e_dfp != NULL) 175 { 176 auto ADDRESS *q; 177 bool oldverb = Verbose; 178 179 /* we have a home directory; open dead.letter */ 180 define('z', p, e); 181 expand("$z/dead.letter", buf, &buf[sizeof buf - 1], e); 182 Verbose = TRUE; 183 message(Arpa_Info, "Saving message in %s", buf); 184 Verbose = oldverb; 185 e->e_to = buf; 186 q = NULL; 187 sendtolist(buf, (ADDRESS *) NULL, &q); 188 (void) deliver(e, q); 189 } 190 191 /* add terminator to writeback message */ 192 if (ErrorMode == EM_WRITE) 193 printf("-----\r\n"); 194 } 195 /* 196 ** RETURNTOSENDER -- return a message to the sender with an error. 197 ** 198 ** Parameters: 199 ** msg -- the explanatory message. 200 ** returnto -- the queue of people to send the message to. 201 ** sendbody -- if TRUE, also send back the body of the 202 ** message; otherwise just send the header. 203 ** 204 ** Returns: 205 ** zero -- if everything went ok. 206 ** else -- some error. 207 ** 208 ** Side Effects: 209 ** Returns the current message to the sender via 210 ** mail. 211 */ 212 213 static bool SendBody; 214 215 #define MAXRETURNS 6 /* max depth of returning messages */ 216 217 returntosender(msg, returnto, sendbody) 218 char *msg; 219 ADDRESS *returnto; 220 bool sendbody; 221 { 222 char buf[MAXNAME]; 223 extern putheader(), errbody(); 224 register ENVELOPE *ee; 225 extern ENVELOPE *newenvelope(); 226 ENVELOPE errenvelope; 227 static int returndepth; 228 register ADDRESS *q; 229 230 # ifdef DEBUG 231 if (tTd(6, 1)) 232 { 233 printf("Return To Sender: msg=\"%s\", depth=%d, CurEnv=%x,\n", 234 msg, returndepth, CurEnv); 235 printf("\treturnto="); 236 printaddr(returnto, TRUE); 237 } 238 # endif DEBUG 239 240 if (++returndepth >= MAXRETURNS) 241 { 242 if (returndepth != MAXRETURNS) 243 syserr("returntosender: infinite recursion on %s", returnto->q_paddr); 244 /* don't "unrecurse" and fake a clean exit */ 245 /* returndepth--; */ 246 return (0); 247 } 248 249 SendBody = sendbody; 250 define('g', "$f", CurEnv); 251 ee = newenvelope(&errenvelope); 252 ee->e_puthdr = putheader; 253 ee->e_putbody = errbody; 254 ee->e_flags |= EF_RESPONSE; 255 ee->e_sendqueue = returnto; 256 openxscript(ee); 257 for (q = returnto; q != NULL; q = q->q_next) 258 { 259 if (q->q_alias == NULL) 260 addheader("to", q->q_paddr, ee); 261 } 262 (void) sprintf(buf, "Returned mail: %s", msg); 263 addheader("subject", buf, ee); 264 265 /* fake up an address header for the from person */ 266 expand("$n", buf, &buf[sizeof buf - 1], CurEnv); 267 if (parseaddr(buf, &ee->e_from, -1, '\0') == NULL) 268 { 269 syserr("Can't parse myself!"); 270 ExitStat = EX_SOFTWARE; 271 returndepth--; 272 return (-1); 273 } 274 275 /* push state into submessage */ 276 CurEnv = ee; 277 define('f', "$n", ee); 278 define('x', "Mail Delivery Subsystem", ee); 279 eatheader(ee); 280 281 /* actually deliver the error message */ 282 sendall(ee, SendMode); 283 284 /* restore state */ 285 dropenvelope(ee); 286 CurEnv = CurEnv->e_parent; 287 returndepth--; 288 289 /* should check for delivery errors here */ 290 return (0); 291 } 292 /* 293 ** ERRBODY -- output the body of an error message. 294 ** 295 ** Typically this is a copy of the transcript plus a copy of the 296 ** original offending message. 297 ** 298 ** Parameters: 299 ** fp -- the output file. 300 ** m -- the mailer to output to. 301 ** e -- the envelope we are working in. 302 ** 303 ** Returns: 304 ** none 305 ** 306 ** Side Effects: 307 ** Outputs the body of an error message. 308 */ 309 310 errbody(fp, m, e) 311 register FILE *fp; 312 register struct mailer *m; 313 register ENVELOPE *e; 314 { 315 register FILE *xfile; 316 char buf[MAXLINE]; 317 char *p; 318 319 /* 320 ** Output transcript of errors 321 */ 322 323 (void) fflush(stdout); 324 p = queuename(e->e_parent, 'x'); 325 if ((xfile = fopen(p, "r")) == NULL) 326 { 327 syserr("Cannot open %s", p); 328 fprintf(fp, " ----- Transcript of session is unavailable -----\n"); 329 } 330 else 331 { 332 fprintf(fp, " ----- Transcript of session follows -----\n"); 333 if (e->e_xfp != NULL) 334 (void) fflush(e->e_xfp); 335 while (fgets(buf, sizeof buf, xfile) != NULL) 336 putline(buf, fp, m); 337 (void) fclose(xfile); 338 } 339 errno = 0; 340 341 /* 342 ** Output text of original message 343 */ 344 345 if (NoReturn) 346 fprintf(fp, "\n ----- Return message suppressed -----\n\n"); 347 else if (e->e_parent->e_dfp != NULL) 348 { 349 if (SendBody) 350 { 351 putline("\n", fp, m); 352 putline(" ----- Unsent message follows -----\n", fp, m); 353 (void) fflush(fp); 354 putheader(fp, m, e->e_parent); 355 putline("\n", fp, m); 356 putbody(fp, m, e->e_parent); 357 } 358 else 359 { 360 putline("\n", fp, m); 361 putline(" ----- Message header follows -----\n", fp, m); 362 (void) fflush(fp); 363 putheader(fp, m, e->e_parent); 364 } 365 } 366 else 367 { 368 putline("\n", fp, m); 369 putline(" ----- No message was collected -----\n", fp, m); 370 putline("\n", fp, m); 371 } 372 373 /* 374 ** Cleanup and exit 375 */ 376 377 if (errno != 0) 378 syserr("errbody: I/O error"); 379 } 380