contrib/sendmail/src/savemail.c

   1 /*
   2  * Copyright (c) 1998-2003, 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: savemail.c,v 8.315 2012/02/27 17:43:03 gshapiro Exp $")
  17
  18 static bool     errbody __P((MCI *, ENVELOPE *, char *));
  19 static bool     pruneroute __P((char *));
  20
  21 /*
  22 **  SAVEMAIL -- Save mail on error
  23 **
  24 **      If mailing back errors, mail it back to the originator
  25 **      together with an error message; otherwise, just put it in
  26 **      dead.letter in the user's home directory (if he exists on
  27 **      this machine).
  28 **
  29 **      Parameters:
  30 **              e -- the envelope containing the message in error.
  31 **              sendbody -- if true, also send back the body of the
  32 **                      message; otherwise just send the header.
  33 **
  34 **      Returns:
  35 **              true if savemail panic'ed, (i.e., the data file should
  36 **              be preserved by dropenvelope())
  37 **
  38 **      Side Effects:
  39 **              Saves the letter, by writing or mailing it back to the
  40 **              sender, or by putting it in dead.letter in her home
  41 **              directory.
  42 */
  43
  44 /* defines for state machine */
  45 #define ESM_REPORT              0       /* report to sender's terminal */
  46 #define ESM_MAIL                1       /* mail back to sender */
  47 #define ESM_QUIET               2       /* mail has already been returned */
  48 #define ESM_DEADLETTER          3       /* save in ~/dead.letter */
  49 #define ESM_POSTMASTER          4       /* return to postmaster */
  50 #define ESM_DEADLETTERDROP      5       /* save in DeadLetterDrop */
  51 #define ESM_PANIC               6       /* call loseqfile() */
  52 #define ESM_DONE                7       /* message is successfully delivered */
  53
  54 bool
  55 savemail(e, sendbody)
  56         register ENVELOPE *e;
  57         bool sendbody;
  58 {
  59         register SM_FILE_T *fp;
  60         bool panic = false;
  61         int state;
  62         auto ADDRESS *q = NULL;
  63         register char *p;
  64         MCI mcibuf;
  65         int flags;
  66         long sff;
  67         char buf[MAXLINE + 1];
  68         char dlbuf[MAXPATHLEN];
  69         SM_MBDB_T user;
  70
  71
  72         if (tTd(6, 1))
  73         {
  74                 sm_dprintf("\nsavemail, errormode = %c, id = %s, ExitStat = %d\n  e_from=",
  75                         e->e_errormode, e->e_id == NULL ? "NONE" : e->e_id,
  76                         ExitStat);
  77                 printaddr(sm_debug_file(), &e->e_from, false);
  78         }
  79
  80         if (e->e_id == NULL)
  81         {
  82                 /* can't return a message with no id */
  83                 return panic;
  84         }
  85
  86         /*
  87         **  In the unhappy event we don't know who to return the mail
  88         **  to, make someone up.
  89         */
  90
  91         if (e->e_from.q_paddr == NULL)
  92         {
  93                 e->e_sender = "Postmaster";
  94                 if (parseaddr(e->e_sender, &e->e_from,
  95                               RF_COPYPARSE|RF_SENDERADDR,
  96                               '\0', NULL, e, false) == NULL)
  97                 {
  98                         syserr("553 5.3.5 Cannot parse Postmaster!");
  99                         finis(true, true, EX_SOFTWARE);
 100                 }
 101         }
 102         e->e_to = NULL;
 103
 104         /*
 105         **  Basic state machine.
 106         **
 107         **      This machine runs through the following states:
 108         **
 109         **      ESM_QUIET       Errors have already been printed iff the
 110         **                      sender is local.
 111         **      ESM_REPORT      Report directly to the sender's terminal.
 112         **      ESM_MAIL        Mail response to the sender.
 113         **      ESM_DEADLETTER  Save response in ~/dead.letter.
 114         **      ESM_POSTMASTER  Mail response to the postmaster.
 115         **      ESM_DEADLETTERDROP
 116         **                      If DeadLetterDrop set, save it there.
 117         **      ESM_PANIC       Save response anywhere possible.
 118         */
 119
 120         /* determine starting state */
 121         switch (e->e_errormode)
 122         {
 123           case EM_WRITE:
 124                 state = ESM_REPORT;
 125                 break;
 126
 127           case EM_BERKNET:
 128           case EM_MAIL:
 129                 state = ESM_MAIL;
 130                 break;
 131
 132           case EM_PRINT:
 133           case '\0':
 134                 state = ESM_QUIET;
 135                 break;
 136
 137           case EM_QUIET:
 138                 /* no need to return anything at all */
 139                 return panic;
 140
 141           default:
 142                 syserr("554 5.3.0 savemail: bogus errormode x%x",
 143                        e->e_errormode);
 144                 state = ESM_MAIL;
 145                 break;
 146         }
 147
 148         /* if this is already an error response, send to postmaster */
 149         if (bitset(EF_RESPONSE, e->e_flags))
 150         {
 151                 if (e->e_parent != NULL &&
 152                     bitset(EF_RESPONSE, e->e_parent->e_flags))
 153                 {
 154                         /* got an error sending a response -- can it */
 155                         return panic;
 156                 }
 157                 state = ESM_POSTMASTER;
 158         }
 159
 160         while (state != ESM_DONE)
 161         {
 162                 if (tTd(6, 5))
 163                         sm_dprintf("  state %d\n", state);
 164
 165                 switch (state)
 166                 {
 167                   case ESM_QUIET:
 168                         if (bitnset(M_LOCALMAILER, e->e_from.q_mailer->m_flags))
 169                                 state = ESM_DEADLETTER;
 170                         else
 171                                 state = ESM_MAIL;
 172                         break;
 173
 174                   case ESM_REPORT:
 175
 176                         /*
 177                         **  If the user is still logged in on the same terminal,
 178                         **  then write the error messages back to hir (sic).
 179                         */
 180
 181 #if USE_TTYPATH
 182                         p = ttypath();
 183 #else /* USE_TTYPATH */
 184                         p = NULL;
 185 #endif /* USE_TTYPATH */
 186
 187                         if (p == NULL || sm_io_reopen(SmFtStdio,
 188                                                       SM_TIME_DEFAULT,
 189                                                       p, SM_IO_WRONLY, NULL,
 190                                                       smioout) == NULL)
 191                         {
 192                                 state = ESM_MAIL;
 193                                 break;
 194                         }
 195
 196                         expand("\201n", buf, sizeof(buf), e);
 197                         (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
 198                                              "\r\nMessage from %s...\r\n", buf);
 199                         (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
 200                                              "Errors occurred while sending mail.\r\n");
 201                         if (e->e_xfp != NULL)
 202                         {
 203                                 (void) bfrewind(e->e_xfp);
 204                                 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
 205                                                      "Transcript follows:\r\n");
 206                                 while (sm_io_fgets(e->e_xfp, SM_TIME_DEFAULT,
 207                                                    buf, sizeof(buf)) != NULL &&
 208                                        !sm_io_error(smioout))
 209                                         (void) sm_io_fputs(smioout,
 210                                                            SM_TIME_DEFAULT,
 211                                                            buf);
 212                         }
 213                         else
 214                         {
 215                                 syserr("Cannot open %s",
 216                                        queuename(e, XSCRPT_LETTER));
 217                                 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
 218                                                      "Transcript of session is unavailable.\r\n");
 219                         }
 220                         (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
 221                                              "Original message will be saved in dead.letter.\r\n");
 222                         state = ESM_DEADLETTER;
 223                         break;
 224
 225                   case ESM_MAIL:
 226                         /*
 227                         **  If mailing back, do it.
 228                         **      Throw away all further output.  Don't alias,
 229                         **      since this could cause loops, e.g., if joe
 230                         **      mails to joe@x, and for some reason the network
 231                         **      for @x is down, then the response gets sent to
 232                         **      joe@x, which gives a response, etc.  Also force
 233                         **      the mail to be delivered even if a version of
 234                         **      it has already been sent to the sender.
 235                         **
 236                         **  If this is a configuration or local software
 237                         **      error, send to the local postmaster as well,
 238                         **      since the originator can't do anything
 239                         **      about it anyway.  Note that this is a full
 240                         **      copy of the message (intentionally) so that
 241                         **      the Postmaster can forward things along.
 242                         */
 243
 244                         if (ExitStat == EX_CONFIG || ExitStat == EX_SOFTWARE)
 245                         {
 246                                 (void) sendtolist("postmaster", NULLADDR,
 247                                                   &e->e_errorqueue, 0, e);
 248                         }
 249                         if (!emptyaddr(&e->e_from))
 250                         {
 251                                 char from[TOBUFSIZE];
 252
 253                                 if (sm_strlcpy(from, e->e_from.q_paddr,
 254                                                 sizeof(from)) >= sizeof(from))
 255                                 {
 256                                         state = ESM_POSTMASTER;
 257                                         break;
 258                                 }
 259
 260                                 if (!DontPruneRoutes)
 261                                         (void) pruneroute(from);
 262
 263                                 (void) sendtolist(from, NULLADDR,
 264                                                   &e->e_errorqueue, 0, e);
 265                         }
 266
 267                         /*
 268                         **  Deliver a non-delivery report to the
 269                         **  Postmaster-designate (not necessarily
 270                         **  Postmaster).  This does not include the
 271                         **  body of the message, for privacy reasons.
 272                         **  You really shouldn't need this.
 273                         */
 274
 275                         e->e_flags |= EF_PM_NOTIFY;
 276
 277                         /* check to see if there are any good addresses */
 278                         for (q = e->e_errorqueue; q != NULL; q = q->q_next)
 279                         {
 280                                 if (QS_IS_SENDABLE(q->q_state))
 281                                         break;
 282                         }
 283                         if (q == NULL)
 284                         {
 285                                 /* this is an error-error */
 286                                 state = ESM_POSTMASTER;
 287                                 break;
 288                         }
 289                         if (returntosender(e->e_message, e->e_errorqueue,
 290                                            sendbody ? RTSF_SEND_BODY
 291                                                     : RTSF_NO_BODY,
 292                                            e) == 0)
 293                         {
 294                                 state = ESM_DONE;
 295                                 break;
 296                         }
 297
 298                         /* didn't work -- return to postmaster */
 299                         state = ESM_POSTMASTER;
 300                         break;
 301
 302                   case ESM_POSTMASTER:
 303                         /*
 304                         **  Similar to previous case, but to system postmaster.
 305                         */
 306
 307                         q = NULL;
 308                         expand(DoubleBounceAddr, buf, sizeof(buf), e);
 309
 310                         /*
 311                         **  Just drop it on the floor if DoubleBounceAddr
 312                         **  expands to an empty string.
 313                         */
 314
 315                         if (*buf == '\0')
 316                         {
 317                                 state = ESM_DONE;
 318                                 break;
 319                         }
 320                         if (sendtolist(buf, NULLADDR, &q, 0, e) <= 0)
 321                         {
 322                                 syserr("553 5.3.0 cannot parse %s!", buf);
 323                                 ExitStat = EX_SOFTWARE;
 324                                 state = ESM_DEADLETTERDROP;
 325                                 break;
 326                         }
 327                         flags = RTSF_PM_BOUNCE;
 328                         if (sendbody)
 329                                 flags |= RTSF_SEND_BODY;
 330                         if (returntosender(e->e_message, q, flags, e) == 0)
 331                         {
 332                                 state = ESM_DONE;
 333                                 break;
 334                         }
 335
 336                         /* didn't work -- last resort */
 337                         state = ESM_DEADLETTERDROP;
 338                         break;
 339
 340                   case ESM_DEADLETTER:
 341                         /*
 342                         **  Save the message in dead.letter.
 343                         **      If we weren't mailing back, and the user is
 344                         **      local, we should save the message in
 345                         **      ~/dead.letter so that the poor person doesn't
 346                         **      have to type it over again -- and we all know
 347                         **      what poor typists UNIX users are.
 348                         */
 349
 350                         p = NULL;
 351                         if (bitnset(M_HASPWENT, e->e_from.q_mailer->m_flags))
 352                         {
 353                                 if (e->e_from.q_home != NULL)
 354                                         p = e->e_from.q_home;
 355                                 else if (sm_mbdb_lookup(e->e_from.q_user, &user)
 356                                          == EX_OK &&
 357                                          *user.mbdb_homedir != '\0')
 358                                         p = user.mbdb_homedir;
 359                         }
 360                         if (p == NULL || e->e_dfp == NULL)
 361                         {
 362                                 /* no local directory or no data file */
 363                                 state = ESM_MAIL;
 364                                 break;
 365                         }
 366
 367                         /* we have a home directory; write dead.letter */
 368                         macdefine(&e->e_macro, A_TEMP, 'z', p);
 369
 370                         /* get the sender for the UnixFromLine */
 371                         p = macvalue('g', e);
 372                         macdefine(&e->e_macro, A_PERM, 'g', e->e_sender);
 373
 374                         expand("\201z/dead.letter", dlbuf, sizeof(dlbuf), e);
 375                         sff = SFF_CREAT|SFF_REGONLY|SFF_RUNASREALUID;
 376                         if (RealUid == 0)
 377                                 sff |= SFF_ROOTOK;
 378                         e->e_to = dlbuf;
 379                         if (writable(dlbuf, NULL, sff) &&
 380                             mailfile(dlbuf, FileMailer, NULL, sff, e) == EX_OK)
 381                         {
 382                                 int oldverb = Verbose;
 383
 384                                 if (OpMode != MD_DAEMON && OpMode != MD_SMTP)
 385                                         Verbose = 1;
 386                                 if (Verbose > 0)
 387                                         message("Saved message in %s", dlbuf);
 388                                 Verbose = oldverb;
 389                                 macdefine(&e->e_macro, A_PERM, 'g', p);
 390                                 state = ESM_DONE;
 391                                 break;
 392                         }
 393                         macdefine(&e->e_macro, A_PERM, 'g', p);
 394                         state = ESM_MAIL;
 395                         break;
 396
 397                   case ESM_DEADLETTERDROP:
 398                         /*
 399                         **  Log the mail in DeadLetterDrop file.
 400                         */
 401
 402                         if (e->e_class < 0)
 403                         {
 404                                 state = ESM_DONE;
 405                                 break;
 406                         }
 407
 408                         if ((SafeFileEnv != NULL && SafeFileEnv[0] != '\0') ||
 409                             DeadLetterDrop == NULL ||
 410                             DeadLetterDrop[0] == '\0')
 411                         {
 412                                 state = ESM_PANIC;
 413                                 break;
 414                         }
 415
 416                         sff = SFF_CREAT|SFF_REGONLY|SFF_ROOTOK|SFF_OPENASROOT|SFF_MUSTOWN;
 417                         if (!writable(DeadLetterDrop, NULL, sff) ||
 418                             (fp = safefopen(DeadLetterDrop, O_WRONLY|O_APPEND,
 419                                             FileMode, sff)) == NULL)
 420                         {
 421                                 state = ESM_PANIC;
 422                                 break;
 423                         }
 424
 425                         memset(&mcibuf, '\0', sizeof(mcibuf));
 426                         mcibuf.mci_out = fp;
 427                         mcibuf.mci_mailer = FileMailer;
 428                         if (bitnset(M_7BITS, FileMailer->m_flags))
 429                                 mcibuf.mci_flags |= MCIF_7BIT;
 430
 431                         /* get the sender for the UnixFromLine */
 432                         p = macvalue('g', e);
 433                         macdefine(&e->e_macro, A_PERM, 'g', e->e_sender);
 434
 435                         if (!putfromline(&mcibuf, e) ||
 436                             !(*e->e_puthdr)(&mcibuf, e->e_header, e,
 437                                         M87F_OUTER) ||
 438                             !(*e->e_putbody)(&mcibuf, e, NULL) ||
 439                             !putline("\n", &mcibuf) ||
 440                             sm_io_flush(fp, SM_TIME_DEFAULT) == SM_IO_EOF ||
 441                             sm_io_error(fp) ||
 442                             sm_io_close(fp, SM_TIME_DEFAULT) < 0)
 443                                 state = ESM_PANIC;
 444                         else
 445                         {
 446                                 int oldverb = Verbose;
 447
 448                                 if (OpMode != MD_DAEMON && OpMode != MD_SMTP)
 449                                         Verbose = 1;
 450                                 if (Verbose > 0)
 451                                         message("Saved message in %s",
 452                                                 DeadLetterDrop);
 453                                 Verbose = oldverb;
 454                                 if (LogLevel > 3)
 455                                         sm_syslog(LOG_NOTICE, e->e_id,
 456                                                   "Saved message in %s",
 457                                                   DeadLetterDrop);
 458                                 state = ESM_DONE;
 459                         }
 460                         macdefine(&e->e_macro, A_PERM, 'g', p);
 461                         break;
 462
 463                   default:
 464                         syserr("554 5.3.5 savemail: unknown state %d", state);
 465                         /* FALLTHROUGH */
 466
 467                   case ESM_PANIC:
 468                         /* leave the locked queue & transcript files around */
 469                         loseqfile(e, "savemail panic");
 470                         panic = true;
 471                         errno = 0;
 472                         syserr("554 savemail: cannot save rejected email anywhere");
 473                         state = ESM_DONE;
 474                         break;
 475                 }
 476         }
 477         return panic;
 478 }
 479 /*
 480 **  RETURNTOSENDER -- return a message to the sender with an error.
 481 **
 482 **      Parameters:
 483 **              msg -- the explanatory message.
 484 **              returnq -- the queue of people to send the message to.
 485 **              flags -- flags tweaking the operation:
 486 **                      RTSF_SENDBODY -- include body of message (otherwise
 487 **                              just send the header).
 488 **                      RTSF_PMBOUNCE -- this is a postmaster bounce.
 489 **              e -- the current envelope.
 490 **
 491 **      Returns:
 492 **              zero -- if everything went ok.
 493 **              else -- some error.
 494 **
 495 **      Side Effects:
 496 **              Returns the current message to the sender via mail.
 497 */
 498
 499 #define MAXRETURNS      6       /* max depth of returning messages */
 500 #define ERRORFUDGE      1024    /* nominal size of error message text */
 501
 502 int
 503 returntosender(msg, returnq, flags, e)
 504         char *msg;
 505         ADDRESS *returnq;
 506         int flags;
 507         register ENVELOPE *e;
 508 {
 509         int ret;
 510         register ENVELOPE *ee;
 511         ENVELOPE *oldcur = CurEnv;
 512         ENVELOPE errenvelope;
 513         static int returndepth = 0;
 514         register ADDRESS *q;
 515         char *p;
 516         char buf[MAXNAME + 1];
 517
 518         if (returnq == NULL)
 519                 return -1;
 520
 521         if (msg == NULL)
 522                 msg = "Unable to deliver mail";
 523
 524         if (tTd(6, 1))
 525         {
 526                 sm_dprintf("\n*** Return To Sender: msg=\"%s\", depth=%d, e=%p, returnq=",
 527                         msg, returndepth, e);
 528                 printaddr(sm_debug_file(), returnq, true);
 529                 if (tTd(6, 20))
 530                 {
 531                         sm_dprintf("Sendq=");
 532                         printaddr(sm_debug_file(), e->e_sendqueue, true);
 533                 }
 534         }
 535
 536         if (++returndepth >= MAXRETURNS)
 537         {
 538                 if (returndepth != MAXRETURNS)
 539                         syserr("554 5.3.0 returntosender: infinite recursion on %s",
 540                                returnq->q_paddr);
 541                 /* don't "unrecurse" and fake a clean exit */
 542                 /* returndepth--; */
 543                 return 0;
 544         }
 545
 546         macdefine(&e->e_macro, A_PERM, 'g', e->e_sender);
 547         macdefine(&e->e_macro, A_PERM, 'u', NULL);
 548
 549         /* initialize error envelope */
 550         ee = newenvelope(&errenvelope, e, sm_rpool_new_x(NULL));
 551         macdefine(&ee->e_macro, A_PERM, 'a', "\201b");
 552         macdefine(&ee->e_macro, A_PERM, 'r', "");
 553         macdefine(&ee->e_macro, A_PERM, 's', "localhost");
 554         macdefine(&ee->e_macro, A_PERM, '_', "localhost");
 555         clrsessenvelope(ee);
 556
 557         ee->e_puthdr = putheader;
 558         ee->e_putbody = errbody;
 559         ee->e_flags |= EF_RESPONSE|EF_METOO;
 560         if (!bitset(EF_OLDSTYLE, e->e_flags))
 561                 ee->e_flags &= ~EF_OLDSTYLE;
 562         if (bitset(EF_DONT_MIME, e->e_flags))
 563         {
 564                 ee->e_flags |= EF_DONT_MIME;
 565
 566                 /*
 567                 **  If we can't convert to MIME and we don't pass
 568                 **  8-bit, we can't send the body.
 569                 */
 570
 571                 if (bitset(EF_HAS8BIT, e->e_flags) &&
 572                     !bitset(MM_PASS8BIT, MimeMode))
 573                         flags &= ~RTSF_SEND_BODY;
 574         }
 575
 576         ee->e_sendqueue = returnq;
 577         ee->e_msgsize = 0;
 578         if (bitset(RTSF_SEND_BODY, flags) &&
 579             !bitset(PRIV_NOBODYRETN, PrivacyFlags))
 580                 ee->e_msgsize = ERRORFUDGE + e->e_msgsize;
 581         else
 582                 ee->e_flags |= EF_NO_BODY_RETN;
 583
 584         if (!setnewqueue(ee))
 585         {
 586                 syserr("554 5.3.0 returntosender: cannot select queue for %s",
 587                                returnq->q_paddr);
 588                 ExitStat = EX_UNAVAILABLE;
 589                 returndepth--;
 590                 return -1;
 591         }
 592         initsys(ee);
 593
 594 #if NAMED_BIND
 595         _res.retry = TimeOuts.res_retry[RES_TO_FIRST];
 596         _res.retrans = TimeOuts.res_retrans[RES_TO_FIRST];
 597 #endif /* NAMED_BIND */
 598         for (q = returnq; q != NULL; q = q->q_next)
 599         {
 600                 if (QS_IS_BADADDR(q->q_state))
 601                         continue;
 602
 603                 q->q_flags &= ~(QHASNOTIFY|Q_PINGFLAGS);
 604                 q->q_flags |= QPINGONFAILURE;
 605
 606                 if (!QS_IS_DEAD(q->q_state))
 607                         ee->e_nrcpts++;
 608
 609                 if (q->q_alias == NULL)
 610                         addheader("To", q->q_paddr, 0, ee, true);
 611         }
 612
 613         if (LogLevel > 5)
 614         {
 615                 if (bitset(EF_RESPONSE, e->e_flags))
 616                         p = "return to sender";
 617                 else if (bitset(EF_WARNING, e->e_flags))
 618                         p = "sender notify";
 619                 else if (bitset(RTSF_PM_BOUNCE, flags))
 620                         p = "postmaster notify";
 621                 else
 622                         p = "DSN";
 623                 sm_syslog(LOG_INFO, e->e_id, "%s: %s: %s",
 624                           ee->e_id, p, shortenstring(msg, MAXSHORTSTR));
 625         }
 626
 627         if (SendMIMEErrors)
 628         {
 629                 addheader("MIME-Version", "1.0", 0, ee, true);
 630                 (void) sm_snprintf(buf, sizeof(buf), "%s.%ld/%.100s",
 631                                 ee->e_id, (long)curtime(), MyHostName);
 632                 ee->e_msgboundary = sm_rpool_strdup_x(ee->e_rpool, buf);
 633                 (void) sm_snprintf(buf, sizeof(buf),
 634 #if DSN
 635                                 "multipart/report; report-type=delivery-status;\n\tboundary=\"%s\"",
 636 #else /* DSN */
 637                                 "multipart/mixed; boundary=\"%s\"",
 638 #endif /* DSN */
 639                                 ee->e_msgboundary);
 640                 addheader("Content-Type", buf, 0, ee, true);
 641
 642                 p = hvalue("Content-Transfer-Encoding", e->e_header);
 643                 if (p != NULL && sm_strcasecmp(p, "binary") != 0)
 644                         p = NULL;
 645                 if (p == NULL && bitset(EF_HAS8BIT, e->e_flags))
 646                         p = "8bit";
 647                 if (p != NULL)
 648                         addheader("Content-Transfer-Encoding", p, 0, ee, true);
 649         }
 650         if (strncmp(msg, "Warning:", 8) == 0)
 651         {
 652                 addheader("Subject", msg, 0, ee, true);
 653                 p = "warning-timeout";
 654         }
 655         else if (strncmp(msg, "Postmaster warning:", 19) == 0)
 656         {
 657                 addheader("Subject", msg, 0, ee, true);
 658                 p = "postmaster-warning";
 659         }
 660         else if (strcmp(msg, "Return receipt") == 0)
 661         {
 662                 addheader("Subject", msg, 0, ee, true);
 663                 p = "return-receipt";
 664         }
 665         else if (bitset(RTSF_PM_BOUNCE, flags))
 666         {
 667                 (void) sm_snprintf(buf, sizeof(buf),
 668                          "Postmaster notify: see transcript for details");
 669                 addheader("Subject", buf, 0, ee, true);
 670                 p = "postmaster-notification";
 671         }
 672         else
 673         {
 674                 (void) sm_snprintf(buf, sizeof(buf),
 675                          "Returned mail: see transcript for details");
 676                 addheader("Subject", buf, 0, ee, true);
 677                 p = "failure";
 678         }
 679         (void) sm_snprintf(buf, sizeof(buf), "auto-generated (%s)", p);
 680         addheader("Auto-Submitted", buf, 0, ee, true);
 681
 682         /* fake up an address header for the from person */
 683         expand("\201n", buf, sizeof(buf), e);
 684         if (parseaddr(buf, &ee->e_from,
 685                       RF_COPYALL|RF_SENDERADDR, '\0', NULL, e, false) == NULL)
 686         {
 687                 syserr("553 5.3.5 Can't parse myself!");
 688                 ExitStat = EX_SOFTWARE;
 689                 returndepth--;
 690                 return -1;
 691         }
 692         ee->e_from.q_flags &= ~(QHASNOTIFY|Q_PINGFLAGS);
 693         ee->e_from.q_flags |= QPINGONFAILURE;
 694         ee->e_sender = ee->e_from.q_paddr;
 695
 696         /* push state into submessage */
 697         CurEnv = ee;
 698         macdefine(&ee->e_macro, A_PERM, 'f', "\201n");
 699         macdefine(&ee->e_macro, A_PERM, 'x', "Mail Delivery Subsystem");
 700         eatheader(ee, true, true);
 701
 702         /* mark statistics */
 703         markstats(ee, NULLADDR, STATS_NORMAL);
 704
 705         /* actually deliver the error message */
 706         sendall(ee, SM_DELIVER);
 707         (void) dropenvelope(ee, true, false);
 708
 709         /* check for delivery errors */
 710         ret = -1;
 711         if (ee->e_parent == NULL ||
 712             !bitset(EF_RESPONSE, ee->e_parent->e_flags))
 713         {
 714                 ret = 0;
 715         }
 716         else
 717         {
 718                 for (q = ee->e_sendqueue; q != NULL; q = q->q_next)
 719                 {
 720                         if (QS_IS_ATTEMPTED(q->q_state))
 721                         {
 722                                 ret = 0;
 723                                 break;
 724                         }
 725                 }
 726         }
 727
 728         /* restore state */
 729         sm_rpool_free(ee->e_rpool);
 730         CurEnv = oldcur;
 731         returndepth--;
 732
 733         return ret;
 734 }
 735
 736 /*
 737 **  ERRBODY -- output the body of an error message.
 738 **
 739 **      Typically this is a copy of the transcript plus a copy of the
 740 **      original offending message.
 741 **
 742 **      Parameters:
 743 **              mci -- the mailer connection information.
 744 **              e -- the envelope we are working in.
 745 **              separator -- any possible MIME separator (unused).
 746 **
 747 **      Returns:
 748 **              true iff body was written successfully
 749 **
 750 **      Side Effects:
 751 **              Outputs the body of an error message.
 752 */
 753
 754 /* ARGSUSED2 */
 755 static bool
 756 errbody(mci, e, separator)
 757         register MCI *mci;
 758         register ENVELOPE *e;
 759         char *separator;
 760 {
 761         bool printheader;
 762         bool sendbody;
 763         bool pm_notify;
 764         int save_errno;
 765         register SM_FILE_T *xfile;
 766         char *p;
 767         register ADDRESS *q = NULL;
 768         char actual[MAXLINE];
 769         char buf[MAXLINE];
 770
 771         if (bitset(MCIF_INHEADER, mci->mci_flags))
 772         {
 773                 if (!putline("", mci))
 774                         goto writeerr;
 775                 mci->mci_flags &= ~MCIF_INHEADER;
 776         }
 777         if (e->e_parent == NULL)
 778         {
 779                 syserr("errbody: null parent");
 780                 if (!putline("   ----- Original message lost -----\n", mci))
 781                         goto writeerr;
 782                 return true;
 783         }
 784
 785         /*
 786         **  Output MIME header.
 787         */
 788
 789         if (e->e_msgboundary != NULL)
 790         {
 791                 (void) sm_strlcpyn(buf, sizeof(buf), 2, "--", e->e_msgboundary);
 792                 if (!putline("This is a MIME-encapsulated message", mci) ||
 793                     !putline("", mci) ||
 794                     !putline(buf, mci) ||
 795                     !putline("", mci))
 796                         goto writeerr;
 797         }
 798
 799         /*
 800         **  Output introductory information.
 801         */
 802
 803         pm_notify = false;
 804         p = hvalue("subject", e->e_header);
 805         if (p != NULL && strncmp(p, "Postmaster ", 11) == 0)
 806                 pm_notify = true;
 807         else
 808         {
 809                 for (q = e->e_parent->e_sendqueue; q != NULL; q = q->q_next)
 810                 {
 811                         if (QS_IS_BADADDR(q->q_state))
 812                                 break;
 813                 }
 814         }
 815         if (!pm_notify && q == NULL &&
 816             !bitset(EF_FATALERRS|EF_SENDRECEIPT, e->e_parent->e_flags))
 817         {
 818                 if (!putline("    **********************************************",
 819                         mci) ||
 820                     !putline("    **      THIS IS A WARNING MESSAGE ONLY      **",
 821                         mci) ||
 822                     !putline("    **  YOU DO NOT NEED TO RESEND YOUR MESSAGE  **",
 823                         mci) ||
 824                     !putline("    **********************************************",
 825                         mci) ||
 826                     !putline("", mci))
 827                         goto writeerr;
 828         }
 829         (void) sm_snprintf(buf, sizeof(buf),
 830                 "The original message was received at %s",
 831                 arpadate(ctime(&e->e_parent->e_ctime)));
 832         if (!putline(buf, mci))
 833                 goto writeerr;
 834         expand("from \201_", buf, sizeof(buf), e->e_parent);
 835         if (!putline(buf, mci))
 836                 goto writeerr;
 837
 838         /* include id in postmaster copies */
 839         if (pm_notify && e->e_parent->e_id != NULL)
 840         {
 841                 (void) sm_strlcpyn(buf, sizeof(buf), 2, "with id ",
 842                         e->e_parent->e_id);
 843                 if (!putline(buf, mci))
 844                         goto writeerr;
 845         }
 846         if (!putline("", mci))
 847                 goto writeerr;
 848
 849         /*
 850         **  Output error message header (if specified and available).
 851         */
 852
 853         if (ErrMsgFile != NULL &&
 854             !bitset(EF_SENDRECEIPT, e->e_parent->e_flags))
 855         {
 856                 if (*ErrMsgFile == '/')
 857                 {
 858                         long sff = SFF_ROOTOK|SFF_REGONLY;
 859
 860                         if (DontLockReadFiles)
 861                                 sff |= SFF_NOLOCK;
 862                         if (!bitnset(DBS_ERRORHEADERINUNSAFEDIRPATH,
 863                                      DontBlameSendmail))
 864                                 sff |= SFF_SAFEDIRPATH;
 865                         xfile = safefopen(ErrMsgFile, O_RDONLY, 0444, sff);
 866                         if (xfile != NULL)
 867                         {
 868                                 while (sm_io_fgets(xfile, SM_TIME_DEFAULT, buf,
 869                                                    sizeof(buf)) != NULL)
 870                                 {
 871                                         int lbs;
 872                                         bool putok;
 873                                         char *lbp;
 874
 875                                         lbs = sizeof(buf);
 876                                         lbp = translate_dollars(buf, buf, &lbs);
 877                                         expand(lbp, lbp, lbs, e);
 878                                         putok = putline(lbp, mci);
 879                                         if (lbp != buf)
 880                                                 sm_free(lbp);
 881                                         if (!putok)
 882                                                 goto writeerr;
 883                                 }
 884                                 (void) sm_io_close(xfile, SM_TIME_DEFAULT);
 885                                 if (!putline("\n", mci))
 886                                         goto writeerr;
 887                         }
 888                 }
 889                 else
 890                 {
 891                         expand(ErrMsgFile, buf, sizeof(buf), e);
 892                         if (!putline(buf, mci) || !putline("", mci))
 893                                 goto writeerr;
 894                 }
 895         }
 896
 897         /*
 898         **  Output message introduction
 899         */
 900
 901         /* permanent fatal errors */
 902         printheader = true;
 903         for (q = e->e_parent->e_sendqueue; q != NULL; q = q->q_next)
 904         {
 905                 if (!QS_IS_BADADDR(q->q_state) ||
 906                     !bitset(QPINGONFAILURE, q->q_flags))
 907                         continue;
 908
 909                 if (printheader)
 910                 {
 911                         if (!putline("   ----- The following addresses had permanent fatal errors -----",
 912                                         mci))
 913                                 goto writeerr;
 914                         printheader = false;
 915                 }
 916
 917                 (void) sm_strlcpy(buf, shortenstring(q->q_paddr, MAXSHORTSTR),
 918                                   sizeof(buf));
 919                 if (!putline(buf, mci))
 920                         goto writeerr;
 921                 if (q->q_rstatus != NULL)
 922                 {
 923                         (void) sm_snprintf(buf, sizeof(buf),
 924                                 "    (reason: %s)",
 925                                 shortenstring(exitstat(q->q_rstatus),
 926                                               MAXSHORTSTR));
 927                         if (!putline(buf, mci))
 928                                 goto writeerr;
 929                 }
 930                 if (q->q_alias != NULL)
 931                 {
 932                         (void) sm_snprintf(buf, sizeof(buf),
 933                                 "    (expanded from: %s)",
 934                                 shortenstring(q->q_alias->q_paddr,
 935                                               MAXSHORTSTR));
 936                         if (!putline(buf, mci))
 937                                 goto writeerr;
 938                 }
 939         }
 940         if (!printheader && !putline("", mci))
 941                 goto writeerr;
 942
 943         /* transient non-fatal errors */
 944         printheader = true;
 945         for (q = e->e_parent->e_sendqueue; q != NULL; q = q->q_next)
 946         {
 947                 if (QS_IS_BADADDR(q->q_state) ||
 948                     !bitset(QPRIMARY, q->q_flags) ||
 949                     !bitset(QBYNDELAY, q->q_flags) ||
 950                     !bitset(QDELAYED, q->q_flags))
 951                         continue;
 952
 953                 if (printheader)
 954                 {
 955                         if (!putline("   ----- The following addresses had transient non-fatal errors -----",
 956                                         mci))
 957                                 goto writeerr;
 958                         printheader = false;
 959                 }
 960
 961                 (void) sm_strlcpy(buf, shortenstring(q->q_paddr, MAXSHORTSTR),
 962                                   sizeof(buf));
 963                 if (!putline(buf, mci))
 964                         goto writeerr;
 965                 if (q->q_alias != NULL)
 966                 {
 967                         (void) sm_snprintf(buf, sizeof(buf),
 968                                 "    (expanded from: %s)",
 969                                 shortenstring(q->q_alias->q_paddr,
 970                                               MAXSHORTSTR));
 971                         if (!putline(buf, mci))
 972                                 goto writeerr;
 973                 }
 974         }
 975         if (!printheader && !putline("", mci))
 976                 goto writeerr;
 977
 978         /* successful delivery notifications */
 979         printheader = true;
 980         for (q = e->e_parent->e_sendqueue; q != NULL; q = q->q_next)
 981         {
 982                 if (QS_IS_BADADDR(q->q_state) ||
 983                     !bitset(QPRIMARY, q->q_flags) ||
 984                     bitset(QBYNDELAY, q->q_flags) ||
 985                     bitset(QDELAYED, q->q_flags))
 986                         continue;
 987                 else if (bitset(QBYNRELAY, q->q_flags))
 988                         p = "Deliver-By notify: relayed";
 989                 else if (bitset(QBYTRACE, q->q_flags))
 990                         p = "Deliver-By trace: relayed";
 991                 else if (!bitset(QPINGONSUCCESS, q->q_flags))
 992                         continue;
 993                 else if (bitset(QRELAYED, q->q_flags))
 994                         p = "relayed to non-DSN-aware mailer";
 995                 else if (bitset(QDELIVERED, q->q_flags))
 996                 {
 997                         if (bitset(QEXPANDED, q->q_flags))
 998                                 p = "successfully delivered to mailing list";
 999                         else
1000                                 p = "successfully delivered to mailbox";
1001                 }
1002                 else if (bitset(QEXPANDED, q->q_flags))
1003                         p = "expanded by alias";
1004                 else
1005                         continue;
1006
1007                 if (printheader)
1008                 {
1009                         if (!putline("   ----- The following addresses had successful delivery notifications -----",
1010                                         mci))
1011                                 goto writeerr;
1012                         printheader = false;
1013                 }
1014
1015                 (void) sm_snprintf(buf, sizeof(buf), "%s  (%s)",
1016                          shortenstring(q->q_paddr, MAXSHORTSTR), p);
1017                 if (!putline(buf, mci))
1018                         goto writeerr;
1019                 if (q->q_alias != NULL)
1020                 {
1021                         (void) sm_snprintf(buf, sizeof(buf),
1022                                 "    (expanded from: %s)",
1023                                 shortenstring(q->q_alias->q_paddr,
1024                                               MAXSHORTSTR));
1025                         if (!putline(buf, mci))
1026                                 goto writeerr;
1027                 }
1028         }
1029         if (!printheader && !putline("", mci))
1030                 goto writeerr;
1031
1032         /*
1033         **  Output transcript of errors
1034         */
1035
1036         (void) sm_io_flush(smioout, SM_TIME_DEFAULT);
1037         if (e->e_parent->e_xfp == NULL)
1038         {
1039                 if (!putline("   ----- Transcript of session is unavailable -----\n",
1040                                 mci))
1041                         goto writeerr;
1042         }
1043         else
1044         {
1045                 printheader = true;
1046                 (void) bfrewind(e->e_parent->e_xfp);
1047                 if (e->e_xfp != NULL)
1048                         (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT);
1049                 while (sm_io_fgets(e->e_parent->e_xfp, SM_TIME_DEFAULT, buf,
1050                                    sizeof(buf)) != NULL)
1051                 {
1052                         if (printheader && !putline("   ----- Transcript of session follows -----\n",
1053                                                 mci))
1054                                 goto writeerr;
1055                         printheader = false;
1056                         if (!putline(buf, mci))
1057                                 goto writeerr;
1058                 }
1059         }
1060         errno = 0;
1061
1062 #if DSN
1063         /*
1064         **  Output machine-readable version.
1065         */
1066
1067         if (e->e_msgboundary != NULL)
1068         {
1069                 (void) sm_strlcpyn(buf, sizeof(buf), 2, "--", e->e_msgboundary);
1070                 if (!putline("", mci) ||
1071                     !putline(buf, mci) ||
1072                     !putline("Content-Type: message/delivery-status", mci) ||
1073                     !putline("", mci))
1074                         goto writeerr;
1075
1076                 /*
1077                 **  Output per-message information.
1078                 */
1079
1080                 /* original envelope id from MAIL FROM: line */
1081                 if (e->e_parent->e_envid != NULL)
1082                 {
1083                         (void) sm_snprintf(buf, sizeof(buf),
1084                                         "Original-Envelope-Id: %.800s",
1085                                         xuntextify(e->e_parent->e_envid));
1086                         if (!putline(buf, mci))
1087                                 goto writeerr;
1088                 }
1089
1090                 /* Reporting-MTA: is us (required) */
1091                 (void) sm_snprintf(buf, sizeof(buf),
1092                                    "Reporting-MTA: dns; %.800s", MyHostName);
1093                 if (!putline(buf, mci))
1094                         goto writeerr;
1095
1096                 /* DSN-Gateway: not relevant since we are not translating */
1097
1098                 /* Received-From-MTA: shows where we got this message from */
1099                 if (RealHostName != NULL)
1100                 {
1101                         /* XXX use $s for type? */
1102                         if (e->e_parent->e_from.q_mailer == NULL ||
1103                             (p = e->e_parent->e_from.q_mailer->m_mtatype) == NULL)
1104                                 p = "dns";
1105                         (void) sm_snprintf(buf, sizeof(buf),
1106                                         "Received-From-MTA: %s; %.800s",
1107                                         p, RealHostName);
1108                         if (!putline(buf, mci))
1109                                 goto writeerr;
1110                 }
1111
1112                 /* Arrival-Date: -- when it arrived here */
1113                 (void) sm_strlcpyn(buf, sizeof(buf), 2, "Arrival-Date: ",
1114                                 arpadate(ctime(&e->e_parent->e_ctime)));
1115                 if (!putline(buf, mci))
1116                         goto writeerr;
1117
1118                 /* Deliver-By-Date: -- when it should have been delivered */
1119                 if (IS_DLVR_BY(e->e_parent))
1120                 {
1121                         time_t dbyd;
1122
1123                         dbyd = e->e_parent->e_ctime + e->e_parent->e_deliver_by;
1124                         (void) sm_strlcpyn(buf, sizeof(buf), 2,
1125                                         "Deliver-By-Date: ",
1126                                         arpadate(ctime(&dbyd)));
1127                         if (!putline(buf, mci))
1128                                 goto writeerr;
1129                 }
1130
1131                 /*
1132                 **  Output per-address information.
1133                 */
1134
1135                 for (q = e->e_parent->e_sendqueue; q != NULL; q = q->q_next)
1136                 {
1137                         char *action;
1138
1139                         if (QS_IS_BADADDR(q->q_state))
1140                         {
1141                                 /* RFC 1891, 6.2.6 (b) */
1142                                 if (bitset(QHASNOTIFY, q->q_flags) &&
1143                                     !bitset(QPINGONFAILURE, q->q_flags))
1144                                         continue;
1145                                 action = "failed";
1146                         }
1147                         else if (!bitset(QPRIMARY, q->q_flags))
1148                                 continue;
1149                         else if (bitset(QDELIVERED, q->q_flags))
1150                         {
1151                                 if (bitset(QEXPANDED, q->q_flags))
1152                                         action = "delivered (to mailing list)";
1153                                 else
1154                                         action = "delivered (to mailbox)";
1155                         }
1156                         else if (bitset(QRELAYED, q->q_flags))
1157                                 action = "relayed (to non-DSN-aware mailer)";
1158                         else if (bitset(QEXPANDED, q->q_flags))
1159                                 action = "expanded (to multi-recipient alias)";
1160                         else if (bitset(QDELAYED, q->q_flags))
1161                                 action = "delayed";
1162                         else if (bitset(QBYTRACE, q->q_flags))
1163                                 action = "relayed (Deliver-By trace mode)";
1164                         else if (bitset(QBYNDELAY, q->q_flags))
1165                                 action = "delayed (Deliver-By notify mode)";
1166                         else if (bitset(QBYNRELAY, q->q_flags))
1167                                 action = "relayed (Deliver-By notify mode)";
1168                         else
1169                                 continue;
1170
1171                         if (!putline("", mci))
1172                                 goto writeerr;
1173
1174                         /* Original-Recipient: -- passed from on high */
1175                         if (q->q_orcpt != NULL)
1176                         {
1177                                 (void) sm_snprintf(buf, sizeof(buf),
1178                                                 "Original-Recipient: %.800s",
1179                                                 q->q_orcpt);
1180                                 if (!putline(buf, mci))
1181                                         goto writeerr;
1182                         }
1183
1184                         /* Figure out actual recipient */
1185                         actual[0] = '\0';
1186                         if (q->q_user[0] != '\0')
1187                         {
1188                                 if (q->q_mailer != NULL &&
1189                                     q->q_mailer->m_addrtype != NULL)
1190                                         p = q->q_mailer->m_addrtype;
1191                                 else
1192                                         p = "rfc822";
1193
1194                                 if (sm_strcasecmp(p, "rfc822") == 0 &&
1195                                     strchr(q->q_user, '@') == NULL)
1196                                 {
1197                                         (void) sm_snprintf(actual,
1198                                                            sizeof(actual),
1199                                                            "%s; %.700s@%.100s",
1200                                                            p, q->q_user,
1201                                                            MyHostName);
1202                                 }
1203                                 else
1204                                 {
1205                                         (void) sm_snprintf(actual,
1206                                                            sizeof(actual),
1207                                                            "%s; %.800s",
1208                                                            p, q->q_user);
1209                                 }
1210                         }
1211
1212                         /* Final-Recipient: -- the name from the RCPT command */
1213                         if (q->q_finalrcpt == NULL)
1214                         {
1215                                 /* should never happen */
1216                                 sm_syslog(LOG_ERR, e->e_id,
1217                                           "returntosender: q_finalrcpt is NULL");
1218
1219                                 /* try to fall back to the actual recipient */
1220                                 if (actual[0] != '\0')
1221                                         q->q_finalrcpt = sm_rpool_strdup_x(e->e_rpool,
1222                                                                            actual);
1223                         }
1224
1225                         if (q->q_finalrcpt != NULL)
1226                         {
1227                                 (void) sm_snprintf(buf, sizeof(buf),
1228                                                    "Final-Recipient: %s",
1229                                                    q->q_finalrcpt);
1230                                 if (!putline(buf, mci))
1231                                         goto writeerr;
1232                         }
1233
1234                         /* X-Actual-Recipient: -- the real problem address */
1235                         if (actual[0] != '\0' &&
1236                             q->q_finalrcpt != NULL &&
1237                             !bitset(PRIV_NOACTUALRECIPIENT, PrivacyFlags) &&
1238                             strcmp(actual, q->q_finalrcpt) != 0)
1239                         {
1240                                 (void) sm_snprintf(buf, sizeof(buf),
1241                                                    "X-Actual-Recipient: %s",
1242                                                    actual);
1243                                 if (!putline(buf, mci))
1244                                         goto writeerr;
1245                         }
1246
1247                         /* Action: -- what happened? */
1248                         (void) sm_strlcpyn(buf, sizeof(buf), 2, "Action: ",
1249                                 action);
1250                         if (!putline(buf, mci))
1251                                 goto writeerr;
1252
1253                         /* Status: -- what _really_ happened? */
1254                         if (q->q_status != NULL)
1255                                 p = q->q_status;
1256                         else if (QS_IS_BADADDR(q->q_state))
1257                                 p = "5.0.0";
1258                         else if (QS_IS_QUEUEUP(q->q_state))
1259                                 p = "4.0.0";
1260                         else
1261                                 p = "2.0.0";
1262                         (void) sm_strlcpyn(buf, sizeof(buf), 2, "Status: ", p);
1263                         if (!putline(buf, mci))
1264                                 goto writeerr;
1265
1266                         /* Remote-MTA: -- who was I talking to? */
1267                         if (q->q_statmta != NULL)
1268                         {
1269                                 if (q->q_mailer == NULL ||
1270                                     (p = q->q_mailer->m_mtatype) == NULL)
1271                                         p = "dns";
1272                                 (void) sm_snprintf(buf, sizeof(buf),
1273                                                 "Remote-MTA: %s; %.800s",
1274                                                 p, q->q_statmta);
1275                                 p = &buf[strlen(buf) - 1];
1276                                 if (*p == '.')
1277                                         *p = '\0';
1278                                 if (!putline(buf, mci))
1279                                         goto writeerr;
1280                         }
1281
1282                         /* Diagnostic-Code: -- actual result from other end */
1283                         if (q->q_rstatus != NULL)
1284                         {
1285                                 if (q->q_mailer == NULL ||
1286                                     (p = q->q_mailer->m_diagtype) == NULL)
1287                                         p = "smtp";
1288                                 (void) sm_snprintf(buf, sizeof(buf),
1289                                                 "Diagnostic-Code: %s; %.800s",
1290                                                 p, q->q_rstatus);
1291                                 if (!putline(buf, mci))
1292                                         goto writeerr;
1293                         }
1294
1295                         /* Last-Attempt-Date: -- fine granularity */
1296                         if (q->q_statdate == (time_t) 0L)
1297                                 q->q_statdate = curtime();
1298                         (void) sm_strlcpyn(buf, sizeof(buf), 2,
1299                                         "Last-Attempt-Date: ",
1300                                         arpadate(ctime(&q->q_statdate)));
1301                         if (!putline(buf, mci))
1302                                 goto writeerr;
1303
1304                         /* Will-Retry-Until: -- for delayed messages only */
1305                         if (QS_IS_QUEUEUP(q->q_state))
1306                         {
1307                                 time_t xdate;
1308
1309                                 xdate = e->e_parent->e_ctime +
1310                                         TimeOuts.to_q_return[e->e_parent->e_timeoutclass];
1311                                 (void) sm_strlcpyn(buf, sizeof(buf), 2,
1312                                          "Will-Retry-Until: ",
1313                                          arpadate(ctime(&xdate)));
1314                                 if (!putline(buf, mci))
1315                                         goto writeerr;
1316                         }
1317                 }
1318         }
1319 #endif /* DSN */
1320
1321         /*
1322         **  Output text of original message
1323         */
1324
1325         if (!putline("", mci))
1326                 goto writeerr;
1327         if (bitset(EF_HAS_DF, e->e_parent->e_flags))
1328         {
1329                 sendbody = !bitset(EF_NO_BODY_RETN, e->e_parent->e_flags) &&
1330                            !bitset(EF_NO_BODY_RETN, e->e_flags);
1331
1332                 if (e->e_msgboundary == NULL)
1333                 {
1334                         if (!putline(
1335                                 sendbody
1336                                 ? "   ----- Original message follows -----\n"
1337                                 : "   ----- Message header follows -----\n",
1338                                 mci))
1339                         {
1340                                 goto writeerr;
1341                         }
1342                 }
1343                 else
1344                 {
1345                         (void) sm_strlcpyn(buf, sizeof(buf), 2, "--",
1346                                         e->e_msgboundary);
1347
1348                         if (!putline(buf, mci))
1349                                 goto writeerr;
1350                         (void) sm_strlcpyn(buf, sizeof(buf), 2, "Content-Type: ",
1351                                         sendbody ? "message/rfc822"
1352                                                  : "text/rfc822-headers");
1353                         if (!putline(buf, mci))
1354                                 goto writeerr;
1355
1356                         p = hvalue("Content-Transfer-Encoding",
1357                                    e->e_parent->e_header);
1358                         if (p != NULL && sm_strcasecmp(p, "binary") != 0)
1359                                 p = NULL;
1360                         if (p == NULL &&
1361                             bitset(EF_HAS8BIT, e->e_parent->e_flags))
1362                                 p = "8bit";
1363                         if (p != NULL)
1364                         {
1365                                 (void) sm_snprintf(buf, sizeof(buf),
1366                                                 "Content-Transfer-Encoding: %s",
1367                                                 p);
1368                                 if (!putline(buf, mci))
1369                                         goto writeerr;
1370                         }
1371                 }
1372                 if (!putline("", mci))
1373                         goto writeerr;
1374                 save_errno = errno;
1375                 if (!putheader(mci, e->e_parent->e_header, e->e_parent,
1376                                 M87F_OUTER))
1377                         goto writeerr;
1378                 errno = save_errno;
1379                 if (sendbody)
1380                 {
1381                         if (!putbody(mci, e->e_parent, e->e_msgboundary))
1382                                 goto writeerr;
1383                 }
1384                 else if (e->e_msgboundary == NULL)
1385                 {
1386                         if (!putline("", mci) ||
1387                             !putline("   ----- Message body suppressed -----",
1388                                         mci))
1389                         {
1390                                 goto writeerr;
1391                         }
1392                 }
1393         }
1394         else if (e->e_msgboundary == NULL)
1395         {
1396                 if (!putline("  ----- No message was collected -----\n", mci))
1397                         goto writeerr;
1398         }
1399
1400         if (e->e_msgboundary != NULL)
1401         {
1402                 (void) sm_strlcpyn(buf, sizeof(buf), 3, "--", e->e_msgboundary,
1403                                    "--");
1404                 if (!putline("", mci) || !putline(buf, mci))
1405                         goto writeerr;
1406         }
1407         if (!putline("", mci) ||
1408             sm_io_flush(mci->mci_out, SM_TIME_DEFAULT) == SM_IO_EOF)
1409                         goto writeerr;
1410
1411         /*
1412         **  Cleanup and exit
1413         */
1414
1415         if (errno != 0)
1416         {
1417   writeerr:
1418                 syserr("errbody: I/O error");
1419                 return false;
1420         }
1421         return true;
1422 }
1423
1424 /*
1425 **  SMTPTODSN -- convert SMTP to DSN status code
1426 **
1427 **      Parameters:
1428 **              smtpstat -- the smtp status code (e.g., 550).
1429 **
1430 **      Returns:
1431 **              The DSN version of the status code.
1432 **
1433 **      Storage Management:
1434 **              smtptodsn() returns a pointer to a character string literal,
1435 **              which will remain valid forever, and thus does not need to
1436 **              be copied.  Current code relies on this property.
1437 */
1438
1439 char *
1440 smtptodsn(smtpstat)
1441         int smtpstat;
1442 {
1443         if (smtpstat < 0)
1444                 return "4.4.2";
1445
1446         switch (smtpstat)
1447         {
1448           case 450:     /* Req mail action not taken: mailbox unavailable */
1449                 return "4.2.0";
1450
1451           case 451:     /* Req action aborted: local error in processing */
1452                 return "4.3.0";
1453
1454           case 452:     /* Req action not taken: insufficient sys storage */
1455                 return "4.3.1";
1456
1457           case 500:     /* Syntax error, command unrecognized */
1458                 return "5.5.2";
1459
1460           case 501:     /* Syntax error in parameters or arguments */
1461                 return "5.5.4";
1462
1463           case 502:     /* Command not implemented */
1464                 return "5.5.1";
1465
1466           case 503:     /* Bad sequence of commands */
1467                 return "5.5.1";
1468
1469           case 504:     /* Command parameter not implemented */
1470                 return "5.5.4";
1471
1472           case 550:     /* Req mail action not taken: mailbox unavailable */
1473                 return "5.2.0";
1474
1475           case 551:     /* User not local; please try <...> */
1476                 return "5.1.6";
1477
1478           case 552:     /* Req mail action aborted: exceeded storage alloc */
1479                 return "5.2.2";
1480
1481           case 553:     /* Req action not taken: mailbox name not allowed */
1482                 return "5.1.0";
1483
1484           case 554:     /* Transaction failed */
1485                 return "5.0.0";
1486         }
1487
1488         if (REPLYTYPE(smtpstat) == 2)
1489                 return "2.0.0";
1490         if (REPLYTYPE(smtpstat) == 4)
1491                 return "4.0.0";
1492         return "5.0.0";
1493 }
1494 /*
1495 **  XTEXTIFY -- take regular text and turn it into DSN-style xtext
1496 **
1497 **      Parameters:
1498 **              t -- the text to convert.
1499 **              taboo -- additional characters that must be encoded.
1500 **
1501 **      Returns:
1502 **              The xtext-ified version of the same string.
1503 */
1504
1505 char *
1506 xtextify(t, taboo)
1507         register char *t;
1508         char *taboo;
1509 {
1510         register char *p;
1511         int l;
1512         int nbogus;
1513         static char *bp = NULL;
1514         static int bplen = 0;
1515
1516         if (taboo == NULL)
1517                 taboo = "";
1518
1519         /* figure out how long this xtext will have to be */
1520         nbogus = l = 0;
1521         for (p = t; *p != '\0'; p++)
1522         {
1523                 register int c = (*p & 0xff);
1524
1525                 /* ASCII dependence here -- this is the way the spec words it */
1526                 if (c < '!' || c > '~' || c == '+' || c == '\\' || c == '(' ||
1527                     strchr(taboo, c) != NULL)
1528                         nbogus++;
1529                 l++;
1530         }
1531         if (nbogus < 0)
1532         {
1533                 /* since nbogus is ssize_t and wrapped, 2 * size_t would wrap */
1534                 syserr("!xtextify string too long");
1535         }
1536         if (nbogus == 0)
1537                 return t;
1538         l += nbogus * 2 + 1;
1539
1540         /* now allocate space if necessary for the new string */
1541         if (l > bplen)
1542         {
1543                 if (bp != NULL)
1544                         sm_free(bp); /* XXX */
1545                 bp = sm_pmalloc_x(l);
1546                 bplen = l;
1547         }
1548
1549         /* ok, copy the text with byte expansion */
1550         for (p = bp; *t != '\0'; )
1551         {
1552                 register int c = (*t++ & 0xff);
1553
1554                 /* ASCII dependence here -- this is the way the spec words it */
1555                 if (c < '!' || c > '~' || c == '+' || c == '\\' || c == '(' ||
1556                     strchr(taboo, c) != NULL)
1557                 {
1558                         *p++ = '+';
1559                         *p++ = "0123456789ABCDEF"[c >> 4];
1560                         *p++ = "0123456789ABCDEF"[c & 0xf];
1561                 }
1562                 else
1563                         *p++ = c;
1564         }
1565         *p = '\0';
1566         return bp;
1567 }
1568 /*
1569 **  XUNTEXTIFY -- take xtext and turn it into plain text
1570 **
1571 **      Parameters:
1572 **              t -- the xtextified text.
1573 **
1574 **      Returns:
1575 **              The decoded text.  No attempt is made to deal with
1576 **              null strings in the resulting text.
1577 */
1578
1579 char *
1580 xuntextify(t)
1581         register char *t;
1582 {
1583         register char *p;
1584         int l;
1585         static char *bp = NULL;
1586         static int bplen = 0;
1587
1588         /* heuristic -- if no plus sign, just return the input */
1589         if (strchr(t, '+') == NULL)
1590                 return t;
1591
1592         /* xtext is always longer than decoded text */
1593         l = strlen(t);
1594         if (l > bplen)
1595         {
1596                 if (bp != NULL)
1597                         sm_free(bp); /* XXX */
1598                 bp = xalloc(l);
1599                 bplen = l;
1600         }
1601
1602         /* ok, copy the text with byte compression */
1603         for (p = bp; *t != '\0'; t++)
1604         {
1605                 register int c = *t & 0xff;
1606
1607                 if (c != '+')
1608                 {
1609                         *p++ = c;
1610                         continue;
1611                 }
1612
1613                 c = *++t & 0xff;
1614                 if (!isascii(c) || !isxdigit(c))
1615                 {
1616                         /* error -- first digit is not hex */
1617                         usrerr("bogus xtext: +%c", c);
1618                         t--;
1619                         continue;
1620                 }
1621                 if (isdigit(c))
1622                         c -= '0';
1623                 else if (isupper(c))
1624                         c -= 'A' - 10;
1625                 else
1626                         c -= 'a' - 10;
1627                 *p = c << 4;
1628
1629                 c = *++t & 0xff;
1630                 if (!isascii(c) || !isxdigit(c))
1631                 {
1632                         /* error -- second digit is not hex */
1633                         usrerr("bogus xtext: +%x%c", *p >> 4, c);
1634                         t--;
1635                         continue;
1636                 }
1637                 if (isdigit(c))
1638                         c -= '0';
1639                 else if (isupper(c))
1640                         c -= 'A' - 10;
1641                 else
1642                         c -= 'a' - 10;
1643                 *p++ |= c;
1644         }
1645         *p = '\0';
1646         return bp;
1647 }
1648 /*
1649 **  XTEXTOK -- check if a string is legal xtext
1650 **
1651 **      Xtext is used in Delivery Status Notifications.  The spec was
1652 **      taken from RFC 1891, ``SMTP Service Extension for Delivery
1653 **      Status Notifications''.
1654 **
1655 **      Parameters:
1656 **              s -- the string to check.
1657 **
1658 **      Returns:
1659 **              true -- if 's' is legal xtext.
1660 **              false -- if it has any illegal characters in it.
1661 */
1662
1663 bool
1664 xtextok(s)
1665         char *s;
1666 {
1667         int c;
1668
1669         while ((c = *s++) != '\0')
1670         {
1671                 if (c == '+')
1672                 {
1673                         c = *s++;
1674                         if (!isascii(c) || !isxdigit(c))
1675                                 return false;
1676                         c = *s++;
1677                         if (!isascii(c) || !isxdigit(c))
1678                                 return false;
1679                 }
1680                 else if (c < '!' || c > '~' || c == '=')
1681                         return false;
1682         }
1683         return true;
1684 }
1685 /*
1686 **  PRUNEROUTE -- prune an RFC-822 source route
1687 **
1688 **      Trims down a source route to the last internet-registered hop.
1689 **      This is encouraged by RFC 1123 section 5.3.3.
1690 **
1691 **      Parameters:
1692 **              addr -- the address
1693 **
1694 **      Returns:
1695 **              true -- address was modified
1696 **              false -- address could not be pruned
1697 **
1698 **      Side Effects:
1699 **              modifies addr in-place
1700 */
1701
1702 static bool
1703 pruneroute(addr)
1704         char *addr;
1705 {
1706 #if NAMED_BIND
1707         char *start, *at, *comma;
1708         char c;
1709         int braclev;
1710         int rcode;
1711         int i;
1712         char hostbuf[BUFSIZ];
1713         char *mxhosts[MAXMXHOSTS + 1];
1714
1715         /* check to see if this is really a route-addr */
1716         if (*addr != '<' || addr[1] != '@' || addr[strlen(addr) - 1] != '>')
1717                 return false;
1718
1719         /*
1720         **  Can't simply find the first ':' is the address might be in the
1721         **  form:  "<@[IPv6:::1]:user@host>" and the first ':' in inside
1722         **  the IPv6 address.
1723         */
1724
1725         start = addr;
1726         braclev = 0;
1727         while (*start != '\0')
1728         {
1729                 if (*start == ':' && braclev <= 0)
1730                         break;
1731                 else if (*start == '[')
1732                         braclev++;
1733                 else if (*start == ']' && braclev > 0)
1734                         braclev--;
1735                 start++;
1736         }
1737         if (braclev > 0 || *start != ':')
1738                 return false;
1739
1740         at = strrchr(addr, '@');
1741         if (at == NULL || at < start)
1742                 return false;
1743
1744         /* slice off the angle brackets */
1745         i = strlen(at + 1);
1746         if (i >= sizeof(hostbuf))
1747                 return false;
1748         (void) sm_strlcpy(hostbuf, at + 1, sizeof(hostbuf));
1749         hostbuf[i - 1] = '\0';
1750
1751         while (start != NULL)
1752         {
1753                 if (getmxrr(hostbuf, mxhosts, NULL, false,
1754                             &rcode, true, NULL) > 0)
1755                 {
1756                         (void) sm_strlcpy(addr + 1, start + 1,
1757                                           strlen(addr) - 1);
1758                         return true;
1759                 }
1760                 c = *start;
1761                 *start = '\0';
1762                 comma = strrchr(addr, ',');
1763                 if (comma != NULL && comma[1] == '@' &&
1764                     strlen(comma + 2) < sizeof(hostbuf))
1765                         (void) sm_strlcpy(hostbuf, comma + 2, sizeof(hostbuf));
1766                 else
1767                         comma = NULL;
1768                 *start = c;
1769                 start = comma;
1770         }
1771 #endif /* NAMED_BIND */
1772         return false;
1773 }