开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
savemail.c
资源名称：sendmail.8.10.0.Beta10.tar.Z　[点击查看]
上传用户：xu_441
上传日期：2007-01-04
资源大小：1640k
文件大小：36k
源码类别：

Email客户端

开发平台：

Unix_Linux

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