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

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

Email客户端

开发平台：

Unix_Linux

deliver.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: deliver.c,v 8.565 1999/12/10 18:54:04 ca Exp $";
  16. #endif /* ! lint */
  18. #include <sendmail.h>
  20. #if HASSETUSERCONTEXT
  21. # include <login_cap.h>
  22. #endif /* HASSETUSERCONTEXT */
  25. #if SMTP
  26. extern char SmtpError[];
  27. #endif /* SMTP */
  29. static int deliver __P((ENVELOPE *, ADDRESS *));
  30. static void dup_queue_file __P((ENVELOPE *, ENVELOPE *, int));
  31. static void mailfiletimeout __P((void));
  32. static void markfailure __P((ENVELOPE *, ADDRESS *, MCI *, int, bool));
  33. static int parse_hostsignature __P((char *, char **, MAILER *));
  34. static void sendenvelope __P((ENVELOPE *, int));
  35. static char *hostsignature __P((MAILER *, char *));
  37. #if SMTP
  38. #endif /* SMTP */
  40. /*
  41. **  SENDALL -- actually send all the messages.
  42. **
  43. ** Parameters:
  44. ** e -- the envelope to send.
  45. ** mode -- the delivery mode to use.  If SM_DEFAULT, use
  46. ** the current e->e_sendmode.
  47. **
  48. ** Returns:
  49. ** none.
  50. **
  51. ** Side Effects:
  52. ** Scans the send lists and sends everything it finds.
  53. ** Delivers any appropriate error messages.
  54. ** If we are running in a non-interactive mode, takes the
  55. ** appropriate action.
  56. */
  58. void
  59. sendall(e, mode)
  60. ENVELOPE *e;
  61. int mode;
  62. {
  63. register ADDRESS *q;
  64. char *owner;
  65. int otherowners;
  66. int save_errno;
  67. register ENVELOPE *ee;
  68. ENVELOPE *splitenv = NULL;
  69. int oldverbose = Verbose;
  70. bool somedeliveries = FALSE, expensive = FALSE;
  71. pid_t pid;
  73. /*
  74. **  If this message is to be discarded, don't bother sending
  75. **  the message at all.
  76. */
  78. if (bitset(EF_DISCARD, e->e_flags))
  79. {
  80. if (tTd(13, 1))
  81. dprintf("sendall: discarding id %sn", e->e_id);
  82. e->e_flags |= EF_CLRQUEUE;
  83. if (LogLevel > 4)
  84. sm_syslog(LOG_INFO, e->e_id, "discarded");
  85. markstats(e, NULL, TRUE);
  86. return;
  87. }
  89. /*
  90. **  If we have had global, fatal errors, don't bother sending
  91. **  the message at all if we are in SMTP mode.  Local errors
  92. **  (e.g., a single address failing) will still cause the other
  93. **  addresses to be sent.
  94. */
  96. if (bitset(EF_FATALERRS, e->e_flags) &&
  97.     (OpMode == MD_SMTP || OpMode == MD_DAEMON))
  98. {
  99. e->e_flags |= EF_CLRQUEUE;
  100. return;
  101. }
  103. /* determine actual delivery mode */
  104. if (mode == SM_DEFAULT)
  105. {
  106. mode = e->e_sendmode;
  107. if (mode != SM_VERIFY && mode != SM_DEFER &&
  108.     shouldqueue(e->e_msgpriority, e->e_ctime))
  109. mode = SM_QUEUE;
  110. }
  112. if (tTd(13, 1))
  113. {
  114. dprintf("n===== SENDALL: mode %c, id %s, e_from ",
  115. mode, e->e_id);
  116. printaddr(&e->e_from, FALSE);
  117. dprintf("te_flags = ");
  118. printenvflags(e);
  119. dprintf("sendqueue:n");
  120. printaddr(e->e_sendqueue, TRUE);
  121. }
  123. /*
  124. **  Do any preprocessing necessary for the mode we are running.
  125. ** Check to make sure the hop count is reasonable.
  126. ** Delete sends to the sender in mailing lists.
  127. */
  129. CurEnv = e;
  130. if (tTd(62, 1))
  131. checkfds(NULL);
  133. if (e->e_hopcount > MaxHopCount)
  134. {
  135. errno = 0;
  136. #if QUEUE
  137. queueup(e, mode == SM_QUEUE || mode == SM_DEFER);
  138. #endif /* QUEUE */
  139. e->e_flags |= EF_FATALERRS|EF_PM_NOTIFY|EF_CLRQUEUE;
  140. ExitStat = EX_UNAVAILABLE;
  141. syserr("554 5.0.0 Too many hops %d (%d max): from %s via %s, to %s",
  142. e->e_hopcount, MaxHopCount, e->e_from.q_paddr,
  143. RealHostName == NULL ? "localhost" : RealHostName,
  144. e->e_sendqueue->q_paddr);
  145. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  146. {
  147. if (QS_IS_DEAD(q->q_state))
  148. continue;
  149. q->q_status = "5.4.6";
  150. }
  151. return;
  152. }
  154. /*
  155. **  Do sender deletion.
  156. **
  157. ** If the sender should be queued up, skip this.
  158. ** This can happen if the name server is hosed when you
  159. ** are trying to send mail.  The result is that the sender
  160. ** is instantiated in the queue as a recipient.
  161. */
  163. if (!bitset(EF_METOO, e->e_flags) &&
  164.     !QS_IS_QUEUEUP(e->e_from.q_state))
  165. {
  166. if (tTd(13, 5))
  167. {
  168. dprintf("sendall: QS_SENDER ");
  169. printaddr(&e->e_from, FALSE);
  170. }
  171. e->e_from.q_state = QS_SENDER;
  172. (void) recipient(&e->e_from, &e->e_sendqueue, 0, e);
  173. }
  175. /*
  176. **  Handle alias owners.
  177. **
  178. ** We scan up the q_alias chain looking for owners.
  179. ** We discard owners that are the same as the return path.
  180. */
  182. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  183. {
  184. register struct address *a;
  186. for (a = q; a != NULL && a->q_owner == NULL; a = a->q_alias)
  187. continue;
  188. if (a != NULL)
  189. q->q_owner = a->q_owner;
  191. if (q->q_owner != NULL &&
  192.     !QS_IS_DEAD(q->q_state) &&
  193.     strcmp(q->q_owner, e->e_from.q_paddr) == 0)
  194. q->q_owner = NULL;
  195. }
  197. if (tTd(13, 25))
  198. {
  199. dprintf("nAfter first owner pass, sendq =n");
  200. printaddr(e->e_sendqueue, TRUE);
  201. }
  203. owner = "";
  204. otherowners = 1;
  205. while (owner != NULL && otherowners > 0)
  206. {
  207. if (tTd(13, 28))
  208. dprintf("owner = "%s", otherowners = %dn",
  209. owner, otherowners);
  210. owner = NULL;
  211. otherowners = bitset(EF_SENDRECEIPT, e->e_flags) ? 1 : 0;
  213. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  214. {
  215. if (tTd(13, 30))
  216. {
  217. dprintf("Checking ");
  218. printaddr(q, FALSE);
  219. }
  220. if (QS_IS_DEAD(q->q_state))
  221. {
  222. if (tTd(13, 30))
  223. dprintf("    ... QS_IS_DEADn");
  224. continue;
  225. }
  226. if (tTd(13, 29) && !tTd(13, 30))
  227. {
  228. dprintf("Checking ");
  229. printaddr(q, FALSE);
  230. }
  232. if (q->q_owner != NULL)
  233. {
  234. if (owner == NULL)
  235. {
  236. if (tTd(13, 40))
  237. dprintf("    ... First owner = "%s"n",
  238. q->q_owner);
  239. owner = q->q_owner;
  240. }
  241. else if (owner != q->q_owner)
  242. {
  243. if (strcmp(owner, q->q_owner) == 0)
  244. {
  245. if (tTd(13, 40))
  246. dprintf("    ... Same owner = "%s"n",
  247. owner);
  249. /* make future comparisons cheap */
  250. q->q_owner = owner;
  251. }
  252. else
  253. {
  254. if (tTd(13, 40))
  255. dprintf("    ... Another owner "%s"n",
  256. q->q_owner);
  257. otherowners++;
  258. }
  259. owner = q->q_owner;
  260. }
  261. else if (tTd(13, 40))
  262. dprintf("    ... Same owner = "%s"n",
  263. owner);
  264. }
  265. else
  266. {
  267. if (tTd(13, 40))
  268. dprintf("    ... Null ownern");
  269. otherowners++;
  270. }
  272. if (QS_IS_BADADDR(q->q_state))
  273. {
  274. if (tTd(13, 30))
  275. dprintf("    ... QS_IS_BADADDRn");
  276. continue;
  277. }
  279. if (QS_IS_QUEUEUP(q->q_state))
  280. {
  281. MAILER *m = q->q_mailer;
  283. /*
  284. **  If we have temporary address failures
  285. **  (e.g., dns failure) and a fallback MX is
  286. **  set, send directly to the fallback MX host.
  287. */
  289. if (FallBackMX != NULL &&
  290.     !wordinclass(FallBackMX, 'w') &&
  291.     mode != SM_VERIFY &&
  292.     (strcmp(m->m_mailer, "[IPC]") == 0 ||
  293.      strcmp(m->m_mailer, "[TCP]") == 0) &&
  294.     m->m_argv[0] != NULL &&
  295.     (strcmp(m->m_argv[0], "TCP") == 0 ||
  296.      strcmp(m->m_argv[0], "IPC") == 0))
  297. {
  298. int len;
  299. char *p;
  301. if (tTd(13, 30))
  302. dprintf("    ... FallBackMXn");
  304. len = strlen(FallBackMX) + 3;
  305. p = xalloc(len);
  306. snprintf(p, len, "[%s]", FallBackMX);
  307. q->q_state = QS_OK;
  308. q->q_host = p;
  309. }
  310. else
  311. {
  312. if (tTd(13, 30))
  313. dprintf("    ... QS_IS_QUEUEUPn");
  314. continue;
  315. }
  316. }
  318. /*
  319. **  If this mailer is expensive, and if we don't
  320. **  want to make connections now, just mark these
  321. **  addresses and return.  This is useful if we
  322. **  want to batch connections to reduce load.  This
  323. **  will cause the messages to be queued up, and a
  324. **  daemon will come along to send the messages later.
  325. */
  327. if (NoConnect && !Verbose &&
  328.     bitnset(M_EXPENSIVE, q->q_mailer->m_flags))
  329. {
  330. if (tTd(13, 30))
  331. dprintf("    ... expensiven");
  332. q->q_state = QS_QUEUEUP;
  333. expensive = TRUE;
  334. }
  335. else if (bitnset(M_HOLD, q->q_mailer->m_flags) &&
  336.  QueueLimitId == NULL &&
  337.  QueueLimitSender == NULL &&
  338.  QueueLimitRecipient == NULL)
  339. {
  340. if (tTd(13, 30))
  341. dprintf("    ... holdn");
  342. q->q_state = QS_QUEUEUP;
  343. expensive = TRUE;
  344. }
  345. else
  346. {
  347. if (tTd(13, 30))
  348. dprintf("    ... deliverablen");
  349. somedeliveries = TRUE;
  350. }
  351. }
  353. if (owner != NULL && otherowners > 0)
  354. {
  355. /*
  356. **  Split this envelope into two.
  357. */
  359. ee = (ENVELOPE *) xalloc(sizeof *ee);
  360. *ee = *e;
  361. ee->e_message = NULL;
  362. ee->e_id = NULL;
  363. assign_queueid(ee);
  365. if (tTd(13, 1))
  366. dprintf("sendall: split %s into %s, owner = "%s", otherowners = %dn",
  367. e->e_id, ee->e_id, owner, otherowners);
  369. ee->e_header = copyheader(e->e_header);
  370. ee->e_sendqueue = copyqueue(e->e_sendqueue);
  371. ee->e_errorqueue = copyqueue(e->e_errorqueue);
  372. ee->e_flags = e->e_flags & ~(EF_INQUEUE|EF_CLRQUEUE|EF_FATALERRS|EF_SENDRECEIPT|EF_RET_PARAM);
  373. ee->e_flags |= EF_NORECEIPT;
  374. setsender(owner, ee, NULL, '', TRUE);
  375. if (tTd(13, 5))
  376. {
  377. dprintf("sendall(split): QS_SENDER ");
  378. printaddr(&ee->e_from, FALSE);
  379. }
  380. ee->e_from.q_state = QS_SENDER;
  381. ee->e_dfp = NULL;
  382. ee->e_lockfp = NULL;
  383. ee->e_xfp = NULL;
  384. ee->e_queuedir = e->e_queuedir;
  385. ee->e_errormode = EM_MAIL;
  386. ee->e_sibling = splitenv;
  387. ee->e_statmsg = NULL;
  388. splitenv = ee;
  390. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  391. {
  392. if (q->q_owner == owner)
  393. {
  394. q->q_state = QS_CLONED;
  395. if (tTd(13, 6))
  396. dprintf("t... stripping %s from original envelopen",
  397. q->q_paddr);
  398. }
  399. }
  400. for (q = ee->e_sendqueue; q != NULL; q = q->q_next)
  401. {
  402. if (q->q_owner != owner)
  403. {
  404. q->q_state = QS_CLONED;
  405. if (tTd(13, 6))
  406. dprintf("t... dropping %s from cloned envelopen",
  407. q->q_paddr);
  408. }
  409. else
  410. {
  411. /* clear DSN parameters */
  412. q->q_flags &= ~(QHASNOTIFY|Q_PINGFLAGS);
  413. q->q_flags |= DefaultNotify & ~QPINGONSUCCESS;
  414. if (tTd(13, 6))
  415. dprintf("t... moving %s to cloned envelopen",
  416. q->q_paddr);
  417. }
  418. }
  420. if (mode != SM_VERIFY && bitset(EF_HAS_DF, e->e_flags))
  421. dup_queue_file(e, ee, 'd');
  423. /*
  424. **  Give the split envelope access to the parent
  425. **  transcript file for errors obtained while
  426. **  processing the recipients (done before the
  427. **  envelope splitting).
  428. */
  430. if (e->e_xfp != NULL)
  431. ee->e_xfp = bfdup(e->e_xfp);
  433. /* failed to dup e->e_xfp, start a new transcript */
  434. if (ee->e_xfp == NULL)
  435. openxscript(ee);
  437. if (mode != SM_VERIFY && LogLevel > 4)
  438. sm_syslog(LOG_INFO, ee->e_id,
  439.   "clone %s, owner=%s",
  440.   e->e_id, owner);
  441. }
  442. }
  444. if (owner != NULL)
  445. {
  446. setsender(owner, e, NULL, '', TRUE);
  447. if (tTd(13, 5))
  448. {
  449. dprintf("sendall(owner): QS_SENDER ");
  450. printaddr(&e->e_from, FALSE);
  451. }
  452. e->e_from.q_state = QS_SENDER;
  453. e->e_errormode = EM_MAIL;
  454. e->e_flags |= EF_NORECEIPT;
  455. e->e_flags &= ~EF_FATALERRS;
  456. }
  458. /* if nothing to be delivered, just queue up everything */
  459. if (!somedeliveries && mode != SM_QUEUE && mode != SM_DEFER &&
  460.     mode != SM_VERIFY)
  461. {
  462. if (tTd(13, 29))
  463. dprintf("No deliveries: auto-queuingn");
  464. mode = SM_QUEUE;
  466. /* treat this as a delivery in terms of counting tries */
  467. e->e_dtime = curtime();
  468. if (!expensive)
  469. e->e_ntries++;
  470. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  471. {
  472. ee->e_dtime = curtime();
  473. if (!expensive)
  474. ee->e_ntries++;
  475. }
  476. }
  478. #if QUEUE
  479. if ((mode == SM_QUEUE || mode == SM_DEFER || mode == SM_FORK ||
  480.      (mode != SM_VERIFY && SuperSafe)) &&
  481.     (!bitset(EF_INQUEUE, e->e_flags) || splitenv != NULL))
  482. {
  483. /* be sure everything is instantiated in the queue */
  484. queueup(e, mode == SM_QUEUE || mode == SM_DEFER);
  485. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  486. queueup(ee, mode == SM_QUEUE || mode == SM_DEFER);
  487. }
  488. #endif /* QUEUE */
  490. if (tTd(62, 10))
  491. checkfds("after envelope splitting");
  493. /*
  494. **  If we belong in background, fork now.
  495. */
  497. if (tTd(13, 20))
  498. {
  499. dprintf("sendall: final mode = %cn", mode);
  500. if (tTd(13, 21))
  501. {
  502. dprintf("n================ Final Send Queue(s) =====================n");
  503. dprintf("n  *** Envelope %s, e_from=%s ***n",
  504. e->e_id, e->e_from.q_paddr);
  505. printaddr(e->e_sendqueue, TRUE);
  506. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  507. {
  508. dprintf("n  *** Envelope %s, e_from=%s ***n",
  509. ee->e_id, ee->e_from.q_paddr);
  510. printaddr(ee->e_sendqueue, TRUE);
  511. }
  512. dprintf("==========================================================nn");
  513. }
  514. }
  515. switch (mode)
  516. {
  517.   case SM_VERIFY:
  518. Verbose = 2;
  519. break;
  521.   case SM_QUEUE:
  522.   case SM_DEFER:
  523. #if HASFLOCK
  524.   queueonly:
  525. #endif /* HASFLOCK */
  526. if (e->e_nrcpts > 0)
  527. e->e_flags |= EF_INQUEUE;
  528. dropenvelope(e, splitenv != NULL);
  529. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  530. {
  531. if (ee->e_nrcpts > 0)
  532. ee->e_flags |= EF_INQUEUE;
  533. dropenvelope(ee, FALSE);
  534. }
  535. return;
  537.   case SM_FORK:
  538. if (e->e_xfp != NULL)
  539. (void) fflush(e->e_xfp);
  541. #if !HASFLOCK
  542. /*
  543. **  Since fcntl locking has the interesting semantic that
  544. **  the lock is owned by a process, not by an open file
  545. **  descriptor, we have to flush this to the queue, and
  546. **  then restart from scratch in the child.
  547. */
  549. {
  550. /* save id for future use */
  551. char *qid = e->e_id;
  553. /* now drop the envelope in the parent */
  554. e->e_flags |= EF_INQUEUE;
  555. dropenvelope(e, splitenv != NULL);
  557. /* arrange to reacquire lock after fork */
  558. e->e_id = qid;
  559. }
  561. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  562. {
  563. /* save id for future use */
  564. char *qid = ee->e_id;
  566. /* drop envelope in parent */
  567. ee->e_flags |= EF_INQUEUE;
  568. dropenvelope(ee, FALSE);
  570. /* and save qid for reacquisition */
  571. ee->e_id = qid;
  572. }
  574. #endif /* !HASFLOCK */
  576. /*
  577. **  Since the delivery may happen in a child and the parent
  578. **  does not wait, the parent may close the maps thereby
  579. **  removing any shared memory used by the map.  Therefore,
  580. **  close the maps now so the child will dynamically open
  581. **  them if necessary.
  582. */
  584. closemaps();
  586. pid = fork();
  587. if (pid < 0)
  588. {
  589. syserr("deliver: fork 1");
  590. #if HASFLOCK
  591. goto queueonly;
  592. #else /* HASFLOCK */
  593. e->e_id = NULL;
  594. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  595. ee->e_id = NULL;
  596. return;
  597. #endif /* HASFLOCK */
  598. }
  599. else if (pid > 0)
  600. {
  601. #if HASFLOCK
  602. /* be sure we leave the temp files to our child */
  603. /* close any random open files in the envelope */
  604. closexscript(e);
  605. if (e->e_dfp != NULL)
  606. (void) bfclose(e->e_dfp);
  607. e->e_dfp = NULL;
  608. e->e_flags &= ~EF_HAS_DF;
  610. /* can't call unlockqueue to avoid unlink of xfp */
  611. if (e->e_lockfp != NULL)
  612. (void) fclose(e->e_lockfp);
  613. else
  614. syserr("%s: sendall: null lockfp", e->e_id);
  615. e->e_lockfp = NULL;
  616. #endif /* HASFLOCK */
  618. /* make sure the parent doesn't own the envelope */
  619. e->e_id = NULL;
  621. /* catch intermediate zombie */
  622. (void) waitfor(pid);
  623. return;
  624. }
  626. /* double fork to avoid zombies */
  627. pid = fork();
  628. if (pid > 0)
  629. exit(EX_OK);
  630. save_errno = errno;
  632. /* be sure we are immune from the terminal */
  633. disconnect(2, e);
  634. clearstats();
  636. /* prevent parent from waiting if there was an error */
  637. if (pid < 0)
  638. {
  639. errno = save_errno;
  640. syserr("deliver: fork 2");
  641. #if HASFLOCK
  642. e->e_flags |= EF_INQUEUE;
  643. #else /* HASFLOCK */
  644. e->e_id = NULL;
  645. #endif /* HASFLOCK */
  646. finis(TRUE, ExitStat);
  647. }
  649. /* be sure to give error messages in child */
  650. QuickAbort = FALSE;
  652. /*
  653. **  Close any cached connections.
  654. **
  655. ** We don't send the QUIT protocol because the parent
  656. ** still knows about the connection.
  657. **
  658. ** This should only happen when delivering an error
  659. ** message.
  660. */
  662. mci_flush(FALSE, NULL);
  664. #if HASFLOCK
  665. break;
  666. #else /* HASFLOCK */
  668. /*
  669. **  Now reacquire and run the various queue files.
  670. */
  672. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  673. {
  674. ENVELOPE *sibling = ee->e_sibling;
  676. (void) dowork(ee->e_queuedir, ee->e_id,
  677.       FALSE, FALSE, ee);
  678. ee->e_sibling = sibling;
  679. }
  680. (void) dowork(e->e_queuedir, e->e_id,
  681.       FALSE, FALSE, e);
  682. finis(TRUE, ExitStat);
  683. #endif /* HASFLOCK */
  684. }
  686. sendenvelope(e, mode);
  687. dropenvelope(e, TRUE);
  688. for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
  689. {
  690. CurEnv = ee;
  691. if (mode != SM_VERIFY)
  692. openxscript(ee);
  693. sendenvelope(ee, mode);
  694. dropenvelope(ee, TRUE);
  695. }
  696. CurEnv = e;
  698. Verbose = oldverbose;
  699. if (mode == SM_FORK)
  700. finis(TRUE, ExitStat);
  701. }
  703. static void
  704. sendenvelope(e, mode)
  705. register ENVELOPE *e;
  706. int mode;
  707. {
  708. register ADDRESS *q;
  709. bool didany;
  711. if (tTd(13, 10))
  712. dprintf("sendenvelope(%s) e_flags=0x%lxn",
  713. e->e_id == NULL ? "[NOQUEUE]" : e->e_id,
  714. e->e_flags);
  715. if (LogLevel > 80)
  716. sm_syslog(LOG_DEBUG, e->e_id,
  717.   "sendenvelope, flags=0x%lx",
  718.   e->e_flags);
  720. /*
  721. **  If we have had global, fatal errors, don't bother sending
  722. **  the message at all if we are in SMTP mode.  Local errors
  723. **  (e.g., a single address failing) will still cause the other
  724. **  addresses to be sent.
  725. */
  727. if (bitset(EF_FATALERRS, e->e_flags) &&
  728.     (OpMode == MD_SMTP || OpMode == MD_DAEMON))
  729. {
  730. e->e_flags |= EF_CLRQUEUE;
  731. return;
  732. }
  734. /* Don't attempt deliveries if we want to bounce now */
  735. if (!bitset(EF_RESPONSE, e->e_flags) &&
  736.     TimeOuts.to_q_return[e->e_timeoutclass] == NOW)
  737. return;
  739. /*
  740. **  Run through the list and send everything.
  741. **
  742. ** Set EF_GLOBALERRS so that error messages during delivery
  743. ** result in returned mail.
  744. */
  746. e->e_nsent = 0;
  747. e->e_flags |= EF_GLOBALERRS;
  749. define(macid("{envid}", NULL), e->e_envid, e);
  750. define(macid("{bodytype}", NULL), e->e_bodytype, e);
  751. didany = FALSE;
  753. /* now run through the queue */
  754. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  755. {
  756. #if XDEBUG
  757. char wbuf[MAXNAME + 20];
  759. (void) snprintf(wbuf, sizeof wbuf, "sendall(%.*s)",
  760. MAXNAME, q->q_paddr);
  761. checkfd012(wbuf);
  762. #endif /* XDEBUG */
  763. if (mode == SM_VERIFY)
  764. {
  765. e->e_to = q->q_paddr;
  766. if (QS_IS_SENDABLE(q->q_state))
  767. {
  768. if (q->q_host != NULL && q->q_host[0] != '')
  769. message("deliverable: mailer %s, host %s, user %s",
  770. q->q_mailer->m_name,
  771. q->q_host,
  772. q->q_user);
  773. else
  774. message("deliverable: mailer %s, user %s",
  775. q->q_mailer->m_name,
  776. q->q_user);
  777. }
  778. }
  779. else if (QS_IS_OK(q->q_state))
  780. {
  781. #if QUEUE
  782. /*
  783. **  Checkpoint the send list every few addresses
  784. */
  786. if (e->e_nsent >= CheckpointInterval)
  787. {
  788. queueup(e, FALSE);
  789. e->e_nsent = 0;
  790. }
  791. #endif /* QUEUE */
  792. (void) deliver(e, q);
  793. didany = TRUE;
  794. }
  795. }
  796. if (didany)
  797. {
  798. e->e_dtime = curtime();
  799. e->e_ntries++;
  800. }
  802. #if XDEBUG
  803. checkfd012("end of sendenvelope");
  804. #endif /* XDEBUG */
  805. }
  806. /*
  807. **  DUP_QUEUE_FILE -- duplicate a queue file into a split queue
  808. **
  809. ** Parameters:
  810. ** e -- the existing envelope
  811. ** ee -- the new envelope
  812. ** type -- the queue file type (e.g., 'd')
  813. **
  814. ** Returns:
  815. ** none
  816. */
  818. static void
  819. dup_queue_file(e, ee, type)
  820. struct envelope *e, *ee;
  821. int type;
  822. {
  823. char f1buf[MAXPATHLEN], f2buf[MAXPATHLEN];
  825. ee->e_dfp = NULL;
  826. ee->e_xfp = NULL;
  828. /*
  829. **  Make sure both are in the same directory.
  830. */
  832. snprintf(f1buf, sizeof f1buf, "%s", queuename(e, type));
  833. snprintf(f2buf, sizeof f2buf, "%s", queuename(ee, type));
  834. if (link(f1buf, f2buf) < 0)
  835. {
  836. int save_errno = errno;
  838. syserr("sendall: link(%s, %s)", f1buf, f2buf);
  839. if (save_errno == EEXIST)
  840. {
  841. if (unlink(f2buf) < 0)
  842. {
  843. syserr("!sendall: unlink(%s): permanent",
  844. f2buf);
  845. /* NOTREACHED */
  846. }
  847. if (link(f1buf, f2buf) < 0)
  848. {
  849. syserr("!sendall: link(%s, %s): permanent",
  850. f1buf, f2buf);
  851. /* NOTREACHED */
  852. }
  853. }
  854. }
  855. }
  856. /*
  857. **  DOFORK -- do a fork, retrying a couple of times on failure.
  858. **
  859. ** This MUST be a macro, since after a vfork we are running
  860. ** two processes on the same stack!!!
  861. **
  862. ** Parameters:
  863. ** none.
  864. **
  865. ** Returns:
  866. ** From a macro???  You've got to be kidding!
  867. **
  868. ** Side Effects:
  869. ** Modifies the ==> LOCAL <== variable 'pid', leaving:
  870. ** pid of child in parent, zero in child.
  871. ** -1 on unrecoverable error.
  872. **
  873. ** Notes:
  874. ** I'm awfully sorry this looks so awful.  That's
  875. ** vfork for you.....
  876. */
  878. #define NFORKTRIES 5
  880. #ifndef FORK
  881. # define FORK fork
  882. #endif /* ! FORK */
  884. #define DOFORK(fORKfN) 
  885. {
  886. register int i;
  888. for (i = NFORKTRIES; --i >= 0; )
  889. {
  890. pid = fORKfN();
  891. if (pid >= 0)
  892. break;
  893. if (i > 0)
  894. (void) sleep((unsigned) NFORKTRIES - i);
  895. }
  896. }
  897. /*
  898. **  DOFORK -- simple fork interface to DOFORK.
  899. **
  900. ** Parameters:
  901. ** none.
  902. **
  903. ** Returns:
  904. ** pid of child in parent.
  905. ** zero in child.
  906. ** -1 on error.
  907. **
  908. ** Side Effects:
  909. ** returns twice, once in parent and once in child.
  910. */
  912. int
  913. dofork()
  914. {
  915. register pid_t pid = -1;
  917. DOFORK(fork);
  918. return pid;
  919. }
  920. /*
  921. **  DELIVER -- Deliver a message to a list of addresses.
  922. **
  923. ** This routine delivers to everyone on the same host as the
  924. ** user on the head of the list.  It is clever about mailers
  925. ** that don't handle multiple users.  It is NOT guaranteed
  926. ** that it will deliver to all these addresses however -- so
  927. ** deliver should be called once for each address on the
  928. ** list.
  929. **
  930. ** Parameters:
  931. ** e -- the envelope to deliver.
  932. ** firstto -- head of the address list to deliver to.
  933. **
  934. ** Returns:
  935. ** zero -- successfully delivered.
  936. ** else -- some failure, see ExitStat for more info.
  937. **
  938. ** Side Effects:
  939. ** The standard input is passed off to someone.
  940. */
  942. #ifndef NO_UID
  943. # define NO_UID -1
  944. #endif /* ! NO_UID */
  945. #ifndef NO_GID
  946. # define NO_GID -1
  947. #endif /* ! NO_GID */
  949. static int
  950. deliver(e, firstto)
  951. register ENVELOPE *e;
  952. ADDRESS *firstto;
  953. {
  954. char *host; /* host being sent to */
  955. char *user; /* user being sent to */
  956. char **pvp;
  957. register char **mvp;
  958. register char *p;
  959. register MAILER *m; /* mailer for this recipient */
  960. ADDRESS *volatile ctladdr;
  961. ADDRESS *volatile contextaddr = NULL;
  962. register MCI *volatile mci;
  963. register ADDRESS *to = firstto;
  964. volatile bool clever = FALSE; /* running user smtp to this mailer */
  965. ADDRESS *volatile tochain = NULL; /* users chain in this mailer call */
  966. int rcode; /* response code */
  967. int lmtp_rcode = EX_OK;
  968. int nummxhosts = 0; /* number of MX hosts available */
  969. int hostnum = 0; /* current MX host index */
  970. char *firstsig; /* signature of firstto */
  971. pid_t pid = -1;
  972. char *volatile curhost;
  973. register u_short port = 0;
  974. #if NETUNIX
  975. char *mux_path = NULL; /* path to UNIX domain socket */
  976. #endif /* NETUNIX */
  977. time_t xstart;
  978. bool suidwarn;
  979. bool anyok; /* at least one address was OK */
  980. bool goodmxfound = FALSE; /* at least one MX was OK */
  981. bool ovr;
  982. int mpvect[2];
  983. int rpvect[2];
  984. char *mxhosts[MAXMXHOSTS + 1];
  985. char *pv[MAXPV + 1];
  986. char tobuf[TOBUFSIZE]; /* text line of to people */
  987. char buf[MAXNAME + 1];
  988. char rpathbuf[MAXNAME + 1]; /* translated return path */
  990. errno = 0;
  991. if (!QS_IS_OK(to->q_state))
  992. return 0;
  994. suidwarn = geteuid() == 0;
  996. m = to->q_mailer;
  997. host = to->q_host;
  998. CurEnv = e; /* just in case */
  999. e->e_statmsg = NULL;
  1000. #if SMTP
  1001. SmtpError[0] = '';
  1002. #endif /* SMTP */
  1003. xstart = curtime();
  1005. if (tTd(10, 1))
  1006. dprintf("n--deliver, id=%s, mailer=%s, host=`%s', first user=`%s'n",
  1007. e->e_id, m->m_name, host, to->q_user);
  1008. if (tTd(10, 100))
  1009. printopenfds(FALSE);
  1011. /*
  1012. **  Clear $&{client_*} macros if this is a bounce message to
  1013. **  prevent rejection by check_compat ruleset.
  1014. */
  1016. if (bitset(EF_RESPONSE, e->e_flags))
  1017. {
  1018. define(macid("{client_name}", NULL), "", e);
  1019. define(macid("{client_addr}", NULL), "", e);
  1020. define(macid("{client_port}", NULL), "", e);
  1021. }
  1023. /*
  1024. **  Do initial argv setup.
  1025. ** Insert the mailer name.  Notice that $x expansion is
  1026. ** NOT done on the mailer name.  Then, if the mailer has
  1027. ** a picky -f flag, we insert it as appropriate.  This
  1028. ** code does not check for 'pv' overflow; this places a
  1029. ** manifest lower limit of 4 for MAXPV.
  1030. ** The from address rewrite is expected to make
  1031. ** the address relative to the other end.
  1032. */
  1034. /* rewrite from address, using rewriting rules */
  1035. rcode = EX_OK;
  1036. if (bitnset(M_UDBENVELOPE, e->e_from.q_mailer->m_flags))
  1037. p = e->e_sender;
  1038. else
  1039. p = e->e_from.q_paddr;
  1040. p = remotename(p, m, RF_SENDERADDR|RF_CANONICAL, &rcode, e);
  1041. if (strlen(p) >= (SIZE_T) sizeof rpathbuf)
  1042. {
  1043. p = shortenstring(p, MAXSHORTSTR);
  1044. syserr("remotename: huge return %s", p);
  1045. }
  1046. snprintf(rpathbuf, sizeof rpathbuf, "%s", p);
  1047. define('g', rpathbuf, e); /* translated return path */
  1048. define('h', host, e); /* to host */
  1049. Errors = 0;
  1050. pvp = pv;
  1051. *pvp++ = m->m_argv[0];
  1053. /* insert -f or -r flag as appropriate */
  1054. if (FromFlag &&
  1055.     (bitnset(M_FOPT, m->m_flags) ||
  1056.      bitnset(M_ROPT, m->m_flags)))
  1057. {
  1058. if (bitnset(M_FOPT, m->m_flags))
  1059. *pvp++ = "-f";
  1060. else
  1061. *pvp++ = "-r";
  1062. *pvp++ = newstr(rpathbuf);
  1063. }
  1065. /*
  1066. **  Append the other fixed parts of the argv.  These run
  1067. **  up to the first entry containing "$u".  There can only
  1068. **  be one of these, and there are only a few more slots
  1069. **  in the pv after it.
  1070. */
  1072. for (mvp = m->m_argv; (p = *++mvp) != NULL; )
  1073. {
  1074. /* can't use strchr here because of sign extension problems */
  1075. while (*p != '')
  1076. {
  1077. if ((*p++ & 0377) == MACROEXPAND)
  1078. {
  1079. if (*p == 'u')
  1080. break;
  1081. }
  1082. }
  1084. if (*p != '')
  1085. break;
  1087. /* this entry is safe -- go ahead and process it */
  1088. expand(*mvp, buf, sizeof buf, e);
  1089. *pvp++ = newstr(buf);
  1090. if (pvp >= &pv[MAXPV - 3])
  1091. {
  1092. syserr("554 5.3.5 Too many parameters to %s before $u",
  1093.        pv[0]);
  1094. return -1;
  1095. }
  1096. }
  1098. /*
  1099. **  If we have no substitution for the user name in the argument
  1100. **  list, we know that we must supply the names otherwise -- and
  1101. **  SMTP is the answer!!
  1102. */
  1104. if (*mvp == NULL)
  1105. {
  1106. /* running SMTP */
  1107. #if SMTP
  1108. clever = TRUE;
  1109. *pvp = NULL;
  1110. #else /* SMTP */
  1111. /* oops!  we don't implement SMTP */
  1112. syserr("554 5.3.5 SMTP style mailer not implemented");
  1113. return EX_SOFTWARE;
  1114. #endif /* SMTP */
  1115. }
  1117. /*
  1118. **  At this point *mvp points to the argument with $u.  We
  1119. **  run through our address list and append all the addresses
  1120. **  we can.  If we run out of space, do not fret!  We can
  1121. **  always send another copy later.
  1122. */
  1124. tobuf[0] = '';
  1125. e->e_to = tobuf;
  1126. ctladdr = NULL;
  1127. firstsig = hostsignature(firstto->q_mailer, firstto->q_host);
  1128. for (; to != NULL; to = to->q_next)
  1129. {
  1130. /* avoid sending multiple recipients to dumb mailers */
  1131. if (tobuf[0] != '' && !bitnset(M_MUSER, m->m_flags))
  1132. break;
  1134. /* if already sent or not for this host, don't send */
  1135. if (!QS_IS_OK(to->q_state) ||
  1136.     to->q_mailer != firstto->q_mailer ||
  1137.     strcmp(hostsignature(to->q_mailer, to->q_host),
  1138.    firstsig) != 0)
  1139. continue;
  1141. /* avoid overflowing tobuf */
  1142. if (sizeof tobuf < (strlen(to->q_paddr) + strlen(tobuf) + 2))
  1143. break;
  1145. if (tTd(10, 1))
  1146. {
  1147. dprintf("nsend to ");
  1148. printaddr(to, FALSE);
  1149. }
  1151. /* compute effective uid/gid when sending */
  1152. if (bitnset(M_RUNASRCPT, to->q_mailer->m_flags))
  1153. contextaddr = ctladdr = getctladdr(to);
  1155. if (tTd(10, 2))
  1156. {
  1157. dprintf("ctladdr=");
  1158. printaddr(ctladdr, FALSE);
  1159. }
  1161. user = to->q_user;
  1162. e->e_to = to->q_paddr;
  1164. /*
  1165. **  Check to see that these people are allowed to
  1166. **  talk to each other.
  1167. */
  1169. if (m->m_maxsize != 0 && e->e_msgsize > m->m_maxsize)
  1170. {
  1171. e->e_flags |= EF_NO_BODY_RETN;
  1172. if (bitnset(M_LOCALMAILER, to->q_mailer->m_flags))
  1173. to->q_status = "5.2.3";
  1174. else
  1175. to->q_status = "5.3.4";
  1176. /* set to->q_rstatus = NULL; or to the following? */
  1177. usrerrenh(to->q_status,
  1178.        "552 Message is too large; %ld bytes max",
  1179.        m->m_maxsize);
  1180. markfailure(e, to, NULL, EX_UNAVAILABLE, FALSE);
  1181. giveresponse(EX_UNAVAILABLE, m, NULL, ctladdr, xstart,
  1182.      e);
  1183. continue;
  1184. }
  1185. #if NAMED_BIND
  1186. h_errno = 0;
  1187. #endif /* NAMED_BIND */
  1189. ovr = TRUE;
  1190. /* do config file checking of compatibility */
  1191. rcode = rscheck("check_compat",
  1192. e->e_from.q_paddr, to->q_paddr, e, TRUE, TRUE);
  1193. if (rcode == EX_OK)
  1194. {
  1195. /* do in-code checking if not discarding */
  1196. if (!bitset(EF_DISCARD, e->e_flags))
  1197. {
  1198. rcode = checkcompat(to, e);
  1199. ovr = FALSE;
  1200. }
  1201. }
  1202. if (rcode != EX_OK)
  1203. {
  1204. markfailure(e, to, NULL, rcode, ovr);
  1205. giveresponse(rcode, m, NULL, ctladdr, xstart, e);
  1206. continue;
  1207. }
  1208. if (bitset(EF_DISCARD, e->e_flags))
  1209. {
  1210. if (tTd(10, 5))
  1211. {
  1212. dprintf("deliver: discarding recipient ");
  1213. printaddr(to, FALSE);
  1214. }
  1216. /* pretend the message was sent */
  1217. /* XXX should we log something here? */
  1218. to->q_state = QS_DISCARDED;
  1220. /*
  1221. **  Remove discard bit to prevent discard of
  1222. **  future recipients.  This is safe because the
  1223. **  true "global discard" has been handled before
  1224. **  we get here.
  1225. */
  1227. e->e_flags &= ~EF_DISCARD;
  1228. continue;
  1229. }
  1231. /*
  1232. **  Strip quote bits from names if the mailer is dumb
  1233. ** about them.
  1234. */
  1236. if (bitnset(M_STRIPQ, m->m_flags))
  1237. {
  1238. stripquotes(user);
  1239. stripquotes(host);
  1240. }
  1242. /* hack attack -- delivermail compatibility */
  1243. if (m == ProgMailer && *user == '|')
  1244. user++;
  1246. /*
  1247. **  If an error message has already been given, don't
  1248. ** bother to send to this address.
  1249. **
  1250. ** >>>>>>>>>> This clause assumes that the local mailer
  1251. ** >> NOTE >> cannot do any further aliasing; that
  1252. ** >>>>>>>>>> function is subsumed by sendmail.
  1253. */
  1255. if (!QS_IS_OK(to->q_state))
  1256. continue;
  1258. /*
  1259. **  See if this user name is "special".
  1260. ** If the user name has a slash in it, assume that this
  1261. ** is a file -- send it off without further ado.  Note
  1262. ** that this type of addresses is not processed along
  1263. ** with the others, so we fudge on the To person.
  1264. */
  1266. if (strcmp(m->m_mailer, "[FILE]") == 0)
  1267. {
  1268. define('u', user, e); /* to user */
  1269. p = to->q_home;
  1270. if (p == NULL && ctladdr != NULL)
  1271. p = ctladdr->q_home;
  1272. define('z', p, e); /* user's home */
  1273. expand(m->m_argv[1], buf, sizeof buf, e);
  1274. if (strlen(buf) > 0)
  1275. rcode = mailfile(buf, m, ctladdr, SFF_CREAT, e);
  1276. else
  1277. {
  1278. syserr("empty filename specification for mailer %s",
  1279.        m->m_name);
  1280. rcode = EX_CONFIG;
  1281. }
  1282. giveresponse(rcode, m, NULL, ctladdr, xstart, e);
  1283. markfailure(e, to, NULL, rcode, TRUE);
  1284. e->e_nsent++;
  1285. if (rcode == EX_OK)
  1286. {
  1287. to->q_state = QS_SENT;
  1288. if (bitnset(M_LOCALMAILER, m->m_flags) &&
  1289.     bitset(QPINGONSUCCESS, to->q_flags))
  1290. {
  1291. to->q_flags |= QDELIVERED;
  1292. to->q_status = "2.1.5";
  1293. fprintf(e->e_xfp, "%s... Successfully deliveredn",
  1294. to->q_paddr);
  1295. }
  1296. }
  1297. to->q_statdate = curtime();
  1298. markstats(e, to, FALSE);
  1299. continue;
  1300. }
  1302. /*
  1303. **  Address is verified -- add this user to mailer
  1304. **  argv, and add it to the print list of recipients.
  1305. */
  1307. /* link together the chain of recipients */
  1308. to->q_tchain = tochain;
  1309. tochain = to;
  1311. /* create list of users for error messages */
  1312. (void) strlcat(tobuf, ",", sizeof tobuf);
  1313. (void) strlcat(tobuf, to->q_paddr, sizeof tobuf);
  1314. define('u', user, e); /* to user */
  1315. p = to->q_home;
  1316. if (p == NULL && ctladdr != NULL)
  1317. p = ctladdr->q_home;
  1318. define('z', p, e); /* user's home */
  1320. /* set the ${dsn_notify} macro if applicable */
  1321. if (bitset(QHASNOTIFY, to->q_flags))
  1322. {
  1323. char notify[MAXLINE];
  1325. notify[0] = '';
  1326. if (bitset(QPINGONSUCCESS, to->q_flags))
  1327. (void) strlcat(notify, "SUCCESS,",
  1328.        sizeof notify);
  1329. if (bitset(QPINGONFAILURE, to->q_flags))
  1330. (void) strlcat(notify, "FAILURE,",
  1331.        sizeof notify);
  1332. if (bitset(QPINGONDELAY, to->q_flags))
  1333. (void) strlcat(notify, "DELAY,", sizeof notify);
  1335. /* Set to NEVER or drop trailing comma */
  1336. if (notify[0] == '')
  1337. (void) strlcat(notify, "NEVER", sizeof notify);
  1338. else
  1339. notify[strlen(notify) - 1] = '';
  1341. define(macid("{dsn_notify}", NULL), newstr(notify), e);
  1342. }
  1343. else
  1344. define(macid("{dsn_notify}", NULL), NULL, e);
  1346. /*
  1347. **  Expand out this user into argument list.
  1348. */
  1350. if (!clever)
  1351. {
  1352. expand(*mvp, buf, sizeof buf, e);
  1353. *pvp++ = newstr(buf);
  1354. if (pvp >= &pv[MAXPV - 2])
  1355. {
  1356. /* allow some space for trailing parms */
  1357. break;
  1358. }
  1359. }
  1360. }
  1362. /* see if any addresses still exist */
  1363. if (tobuf[0] == '')
  1364. {
  1365. define('g', (char *) NULL, e);
  1366. return 0;
  1367. }
  1369. /* print out messages as full list */
  1370. e->e_to = tobuf + 1;
  1372. /*
  1373. **  Fill out any parameters after the $u parameter.
  1374. */
  1376. while (!clever && *++mvp != NULL)
  1377. {
  1378. expand(*mvp, buf, sizeof buf, e);
  1379. *pvp++ = newstr(buf);
  1380. if (pvp >= &pv[MAXPV])
  1381. syserr("554 5.3.0 deliver: pv overflow after $u for %s",
  1382.        pv[0]);
  1383. }
  1384. *pvp++ = NULL;
  1386. /*
  1387. **  Call the mailer.
  1388. ** The argument vector gets built, pipes
  1389. ** are created as necessary, and we fork & exec as
  1390. ** appropriate.
  1391. ** If we are running SMTP, we just need to clean up.
  1392. */
  1394. /* XXX this seems a bit wierd */
  1395. if (ctladdr == NULL && m != ProgMailer && m != FileMailer &&
  1396.     bitset(QGOODUID, e->e_from.q_flags))
  1397. ctladdr = &e->e_from;
  1399. #if NAMED_BIND
  1400. if (ConfigLevel < 2)
  1401. _res.options &= ~(RES_DEFNAMES | RES_DNSRCH); /* XXX */
  1402. #endif /* NAMED_BIND */
  1404. if (tTd(11, 1))
  1405. {
  1406. dprintf("openmailer:");
  1407. printav(pv);
  1408. }
  1409. errno = 0;
  1410. #if NAMED_BIND
  1411. h_errno = 0;
  1412. #endif /* NAMED_BIND */
  1414. CurHostName = NULL;
  1416. /*
  1417. **  Deal with the special case of mail handled through an IPC
  1418. **  connection.
  1419. ** In this case we don't actually fork.  We must be
  1420. ** running SMTP for this to work.  We will return a
  1421. ** zero pid to indicate that we are running IPC.
  1422. **  We also handle a debug version that just talks to stdin/out.
  1423. */
  1425. curhost = NULL;
  1426. SmtpPhase = NULL;
  1427. mci = NULL;
  1429. #if XDEBUG
  1430. {
  1431. char wbuf[MAXLINE];
  1433. /* make absolutely certain 0, 1, and 2 are in use */
  1434. snprintf(wbuf, sizeof wbuf, "%s... openmailer(%s)",
  1435. shortenstring(e->e_to, MAXSHORTSTR), m->m_name);
  1436. checkfd012(wbuf);
  1437. }
  1438. #endif /* XDEBUG */
  1440. /* check for 8-bit available */
  1441. if (bitset(EF_HAS8BIT, e->e_flags) &&
  1442.     bitnset(M_7BITS, m->m_flags) &&
  1443.     (bitset(EF_DONT_MIME, e->e_flags) ||
  1444.      !(bitset(MM_MIME8BIT, MimeMode) ||
  1445.        (bitset(EF_IS_MIME, e->e_flags) &&
  1446. bitset(MM_CVTMIME, MimeMode)))))
  1447. {
  1448. e->e_status = "5.6.3";
  1449. usrerrenh(e->e_status,
  1450.        "554 Cannot send 8-bit data to 7-bit destination");
  1451. rcode = EX_DATAERR;
  1452. goto give_up;
  1453. }
  1455. if (tTd(62, 8))
  1456. checkfds("before delivery");
  1458. /* check for Local Person Communication -- not for mortals!!! */
  1459. if (strcmp(m->m_mailer, "[LPC]") == 0)
  1460. {
  1461. mci = (MCI *) xalloc(sizeof *mci);
  1462. memset((char *) mci, '', sizeof *mci);
  1463. mci->mci_in = stdin;
  1464. mci->mci_out = stdout;
  1465. mci->mci_state = clever ? MCIS_OPENING : MCIS_OPEN;
  1466. mci->mci_mailer = m;
  1467. }
  1468. else if (strcmp(m->m_mailer, "[IPC]") == 0 ||
  1469.  strcmp(m->m_mailer, "[TCP]") == 0)
  1470. {
  1471. #if DAEMON
  1472. register int i;
  1474. if (pv[0] == NULL || pv[1] == NULL || pv[1][0] == '')
  1475. {
  1476. syserr("null destination for %s mailer", m->m_mailer);
  1477. rcode = EX_CONFIG;
  1478. goto give_up;
  1479. }
  1481. # if NETUNIX
  1482. if (strcmp(pv[0], "FILE") == 0)
  1483. {
  1484. curhost = CurHostName = "localhost";
  1485. mux_path = pv[1];
  1486. }
  1487. else
  1488. # endif /* NETUNIX */
  1489. {
  1490. CurHostName = pv[1];
  1491. curhost = hostsignature(m, pv[1]);
  1492. }
  1494. if (curhost == NULL || curhost[0] == '')
  1495. {
  1496. syserr("null host signature for %s", pv[1]);
  1497. rcode = EX_CONFIG;
  1498. goto give_up;
  1499. }
  1501. if (!clever)
  1502. {
  1503. syserr("554 5.3.5 non-clever IPC");
  1504. rcode = EX_CONFIG;
  1505. goto give_up;
  1506. }
  1507. if (pv[2] != NULL
  1508. # if NETUNIX
  1509.     && mux_path == NULL
  1510. # endif /* NETUNIX */
  1511.     )
  1512. {
  1513. port = htons(atoi(pv[2]));
  1514. if (port == 0)
  1515. {
  1516. # ifdef NO_GETSERVBYNAME
  1517. syserr("Invalid port number: %s", pv[2]);
  1518. # else /* NO_GETSERVBYNAME */
  1519. struct servent *sp = getservbyname(pv[2], "tcp");
  1521. if (sp == NULL)
  1522. syserr("Service %s unknown", pv[2]);
  1523. else
  1524. port = sp->s_port;
  1525. # endif /* NO_GETSERVBYNAME */
  1526. }
  1527. }
  1529. nummxhosts = parse_hostsignature(curhost, mxhosts, m);
  1530. tryhost:
  1531. while (hostnum < nummxhosts)
  1532. {
  1533. char sep = ':';
  1534. char *endp;
  1535. static char hostbuf[MAXNAME + 1];
  1537. # if NETINET6
  1538. if (*mxhosts[hostnum] == '[')
  1539. {
  1540. endp = strchr(mxhosts[hostnum] + 1, ']');
  1541. if (endp != NULL)
  1542. endp = strpbrk(endp + 1, ":,");
  1543. }
  1544. else
  1545. endp = strpbrk(mxhosts[hostnum], ":,");
  1546. # else /* NETINET6 */
  1547. endp = strpbrk(mxhosts[hostnum], ":,");
  1548. # endif /* NETINET6 */
  1549. if (endp != NULL)
  1550. {
  1551. sep = *endp;
  1552. *endp = '';
  1553. }
  1555. if (*mxhosts[hostnum] == '')
  1556. {
  1557. syserr("deliver: null host name in signature");
  1558. hostnum++;
  1559. if (endp != NULL)
  1560. *endp = sep;
  1561. continue;
  1562. }
  1563. (void) strlcpy(hostbuf, mxhosts[hostnum],
  1564.        sizeof hostbuf);
  1565. hostnum++;
  1566. if (endp != NULL)
  1567. *endp = sep;
  1569. /* see if we already know that this host is fried */
  1570. CurHostName = hostbuf;
  1571. mci = mci_get(hostbuf, m);
  1572. if (mci->mci_state != MCIS_CLOSED)
  1573. {
  1574. if (tTd(11, 1))
  1575. {
  1576. dprintf("openmailer: ");
  1577. mci_dump(mci, FALSE);
  1578. }
  1579. CurHostName = mci->mci_host;
  1580. message("Using cached %sSMTP connection to %s via %s...",
  1581. bitset(MCIF_ESMTP, mci->mci_flags) ? "E" : "",
  1582. hostbuf, m->m_name);
  1583. mci->mci_deliveries++;
  1584. break;
  1585. }
  1586. mci->mci_mailer = m;
  1587. if (mci->mci_exitstat != EX_OK)
  1588. {
  1589. if (mci->mci_exitstat == EX_TEMPFAIL)
  1590. goodmxfound = TRUE;
  1591. continue;
  1592. }
  1594. if (mci_lock_host(mci) != EX_OK)
  1595. {
  1596. mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
  1597. goodmxfound = TRUE;
  1598. continue;
  1599. }
  1601. /* try the connection */
  1602. sm_setproctitle(TRUE, e, "%s %s: %s",
  1603. qid_printname(e),
  1604. hostbuf, "user open");
  1605. # if NETUNIX
  1606. if (mux_path != NULL)
  1607. {
  1608. message("Connecting to %s via %s...",
  1609. mux_path, m->m_name);
  1610. i = makeconnection_ds(mux_path, mci);
  1611. }
  1612. else
  1613. # endif /* NETUNIX */
  1614. {
  1615. if (port == 0)
  1616. message("Connecting to %s via %s...",
  1617. hostbuf, m->m_name);
  1618. else
  1619. message("Connecting to %s port %d via %s...",
  1620. hostbuf, ntohs(port),
  1621. m->m_name);
  1622. i = makeconnection(hostbuf, port, mci, e);
  1623. }
  1624. mci->mci_lastuse = curtime();
  1625. mci->mci_deliveries = 0;
  1626. mci->mci_exitstat = i;
  1627. mci->mci_errno = errno;
  1628. # if NAMED_BIND
  1629. mci->mci_herrno = h_errno;
  1630. # endif /* NAMED_BIND */
  1631. if (i == EX_OK)
  1632. {
  1633. goodmxfound = TRUE;
  1634. mci->mci_state = MCIS_OPENING;
  1635. mci_cache(mci);
  1636. if (TrafficLogFile != NULL)
  1637. fprintf(TrafficLogFile, "%05d === CONNECT %sn",
  1638. (int) getpid(), hostbuf);
  1639. break;
  1640. }
  1641. else
  1642. {
  1643. if (tTd(11, 1))
  1644. dprintf("openmailer: makeconnection => stat=%d, errno=%dn",
  1645. i, errno);
  1646. if (i == EX_TEMPFAIL)
  1647. goodmxfound = TRUE;
  1648. mci_unlock_host(mci);
  1649. }
  1651. /* enter status of this host */
  1652. setstat(i);
  1654. /* should print some message here for -v mode */
  1655. }
  1656. if (mci == NULL)
  1657. {
  1658. syserr("deliver: no host name");
  1659. rcode = EX_SOFTWARE;
  1660. goto give_up;
  1661. }
  1662. mci->mci_pid = 0;
  1663. #else /* DAEMON */
  1664. syserr("554 5.3.5 openmailer: no IPC");
  1665. if (tTd(11, 1))
  1666. dprintf("openmailer: NULLn");
  1667. rcode = EX_UNAVAILABLE;
  1668. goto give_up;
  1669. #endif /* DAEMON */
  1670. }
  1671. else
  1672. {
  1673. /* flush any expired connections */
  1674. (void) mci_scan(NULL);
  1675. mci = NULL;
  1677. #if SMTP
  1678. if (bitnset(M_LMTP, m->m_flags))
  1679. {
  1680. /* try to get a cached connection */
  1681. mci = mci_get(m->m_name, m);
  1682. if (mci->mci_host == NULL)
  1683. mci->mci_host = m->m_name;
  1684. CurHostName = mci->mci_host;
  1685. if (mci->mci_state != MCIS_CLOSED)
  1686. {
  1687. message("Using cached LMTP connection for %s...",
  1688. m->m_name);
  1689. mci->mci_deliveries++;
  1690. goto do_transfer;
  1691. }
  1692. }
  1693. #endif /* SMTP */
  1695. /* announce the connection to verbose listeners */
  1696. if (host == NULL || host[0] == '')
  1697. message("Connecting to %s...", m->m_name);
  1698. else
  1699. message("Connecting to %s via %s...", host, m->m_name);
  1700. if (TrafficLogFile != NULL)
  1701. {
  1702. char **av;
  1704. fprintf(TrafficLogFile, "%05d === EXEC", (int) getpid());
  1705. for (av = pv; *av != NULL; av++)
  1706. fprintf(TrafficLogFile, " %s", *av);
  1707. fprintf(TrafficLogFile, "n");
  1708. }
  1710. #if XDEBUG
  1711. checkfd012("before creating mail pipe");
  1712. #endif /* XDEBUG */
  1714. /* create a pipe to shove the mail through */
  1715. if (pipe(mpvect) < 0)
  1716. {
  1717. syserr("%s... openmailer(%s): pipe (to mailer)",
  1718. shortenstring(e->e_to, MAXSHORTSTR), m->m_name);
  1719. if (tTd(11, 1))
  1720. dprintf("openmailer: NULLn");
  1721. rcode = EX_OSERR;
  1722. goto give_up;
  1723. }
  1725. #if XDEBUG
  1726. /* make sure we didn't get one of the standard I/O files */
  1727. if (mpvect[0] < 3 || mpvect[1] < 3)
  1728. {
  1729. syserr("%s... openmailer(%s): bogus mpvect %d %d",
  1730. shortenstring(e->e_to, MAXSHORTSTR), m->m_name,
  1731. mpvect[0], mpvect[1]);
  1732. printopenfds(TRUE);
  1733. if (tTd(11, 1))
  1734. dprintf("openmailer: NULLn");
  1735. rcode = EX_OSERR;
  1736. goto give_up;
  1737. }
  1739. /* make sure system call isn't dead meat */
  1740. checkfdopen(mpvect[0], "mpvect[0]");
  1741. checkfdopen(mpvect[1], "mpvect[1]");
  1742. if (mpvect[0] == mpvect[1] ||
  1743.     (e->e_lockfp != NULL &&
  1744.      (mpvect[0] == fileno(e->e_lockfp) ||
  1745.       mpvect[1] == fileno(e->e_lockfp))))
  1746. {
  1747. if (e->e_lockfp == NULL)
  1748. syserr("%s... openmailer(%s): overlapping mpvect %d %d",
  1749. shortenstring(e->e_to, MAXSHORTSTR),
  1750. m->m_name, mpvect[0], mpvect[1]);
  1751. else
  1752. syserr("%s... openmailer(%s): overlapping mpvect %d %d, lockfp = %d",
  1753. shortenstring(e->e_to, MAXSHORTSTR),
  1754. m->m_name, mpvect[0], mpvect[1],
  1755. fileno(e->e_lockfp));
  1756. }
  1757. #endif /* XDEBUG */
  1759. /* create a return pipe */
  1760. if (pipe(rpvect) < 0)
  1761. {
  1762. syserr("%s... openmailer(%s): pipe (from mailer)",
  1763. shortenstring(e->e_to, MAXSHORTSTR),
  1764. m->m_name);
  1765. (void) close(mpvect[0]);
  1766. (void) close(mpvect[1]);
  1767. if (tTd(11, 1))
  1768. dprintf("openmailer: NULLn");
  1769. rcode = EX_OSERR;
  1770. goto give_up;
  1771. }
  1772. #if XDEBUG
  1773. checkfdopen(rpvect[0], "rpvect[0]");
  1774. checkfdopen(rpvect[1], "rpvect[1]");
  1775. #endif /* XDEBUG */
  1777. /*
  1778. **  Actually fork the mailer process.
  1779. ** DOFORK is clever about retrying.
  1780. **
  1781. ** Dispose of SIGCHLD signal catchers that may be laying
  1782. ** around so that endmailer will get it.
  1783. */
  1785. if (e->e_xfp != NULL)
  1786. (void) fflush(e->e_xfp); /* for debugging */
  1787. (void) fflush(stdout);
  1788. (void) setsignal(SIGCHLD, SIG_DFL);
  1789. DOFORK(FORK);
  1790. /* pid is set by DOFORK */
  1791. if (pid < 0)
  1792. {
  1793. /* failure */
  1794. syserr("%s... openmailer(%s): cannot fork",
  1795. shortenstring(e->e_to, MAXSHORTSTR), m->m_name);
  1796. (void) close(mpvect[0]);
  1797. (void) close(mpvect[1]);
  1798. (void) close(rpvect[0]);
  1799. (void) close(rpvect[1]);
  1800. if (tTd(11, 1))
  1801. dprintf("openmailer: NULLn");
  1802. rcode = EX_OSERR;
  1803. goto give_up;
  1804. }
  1805. else if (pid == 0)
  1806. {
  1807. int i;
  1808. int save_errno;
  1809. int new_euid = NO_UID;
  1810. int new_ruid = NO_UID;
  1811. int new_gid = NO_GID;
  1812. struct stat stb;
  1813. extern int DtableSize;
  1815. if (e->e_lockfp != NULL)
  1816. (void) close(fileno(e->e_lockfp));
  1818. /* child -- set up input & exec mailer */
  1819. (void) setsignal(SIGINT, SIG_IGN);
  1820. (void) setsignal(SIGHUP, SIG_IGN);
  1821. (void) setsignal(SIGTERM, SIG_DFL);
  1823. if (m != FileMailer || stat(tochain->q_user, &stb) < 0)
  1824. stb.st_mode = 0;
  1826. #if HASSETUSERCONTEXT
  1827. /*
  1828. **  Set user resources.
  1829. */
  1831. if (contextaddr != NULL)
  1832. {
  1833. struct passwd *pwd;
  1835. if (contextaddr->q_ruser != NULL)
  1836. pwd = sm_getpwnam(contextaddr->q_ruser);
  1837. else
  1838. pwd = sm_getpwnam(contextaddr->q_user);
  1839. if (pwd != NULL)
  1840. (void) setusercontext(NULL,
  1841. pwd, pwd->pw_uid,
  1842. LOGIN_SETRESOURCES|LOGIN_SETPRIORITY);
  1843. }
  1844. #endif /* HASSETUSERCONTEXT */
  1846. /* tweak niceness */
  1847. if (m->m_nice != 0)
  1848. (void) nice(m->m_nice);
  1850. /* reset group id */
  1851. if (bitnset(M_SPECIFIC_UID, m->m_flags))
  1852. new_gid = m->m_gid;
  1853. else if (bitset(S_ISGID, stb.st_mode))
  1854. new_gid = stb.st_gid;
  1855. else if (ctladdr != NULL && ctladdr->q_gid != 0)
  1856. {
  1857. if (!DontInitGroups)
  1858. {
  1859. char *u = ctladdr->q_ruser;
  1861. if (u == NULL)
  1862. u = ctladdr->q_user;
  1864. if (initgroups(u, ctladdr->q_gid) == -1 && suidwarn)
  1865. syserr("openmailer: initgroups(%s, %d) failed",
  1866. u, ctladdr->q_gid);
  1867. }
  1868. else
  1869. {
  1870. GIDSET_T gidset[1];
  1872. gidset[0] = ctladdr->q_gid;
  1873. if (setgroups(1, gidset) == -1 && suidwarn)
  1874. syserr("openmailer: setgroups() failed");
  1875. }
  1876. new_gid = ctladdr->q_gid;
  1877. }
  1878. else
  1879. {
  1880. if (!DontInitGroups)
  1881. {
  1882. if (initgroups(DefUser, DefGid) == -1 && suidwarn)
  1883. syserr("openmailer: initgroups(%s, %d) failed",
  1884. DefUser, DefGid);
  1885. }
  1886. else
  1887. {
  1888. GIDSET_T gidset[1];
  1890. gidset[0] = DefGid;
  1891. if (setgroups(1, gidset) == -1 && suidwarn)
  1892. syserr("openmailer: setgroups() failed");
  1893. }
  1894. if (m->m_gid == 0)
  1895. new_gid = DefGid;
  1896. else
  1897. new_gid = m->m_gid;
  1898. }
  1899. if (new_gid != NO_GID && setgid(new_gid) < 0 && suidwarn)
  1900. syserr("openmailer: setgid(%ld) failed",
  1901. (long) new_gid);
  1903. /* change root to some "safe" directory */
  1904. if (m->m_rootdir != NULL)
  1905. {
  1906. expand(m->m_rootdir, buf, sizeof buf, e);
  1907. if (tTd(11, 20))
  1908. dprintf("openmailer: chroot %sn",
  1909. buf);
  1910. if (chroot(buf) < 0)
  1911. syserr("openmailer: Cannot chroot(%s)",
  1912.        buf);
  1913. if (chdir("/") < 0)
  1914. syserr("openmailer: cannot chdir(/)");
  1915. }
  1917. /* reset user id */
  1918. endpwent();
  1919. if (bitnset(M_SPECIFIC_UID, m->m_flags))
  1920. new_euid = m->m_uid;
  1921. else if (bitset(S_ISUID, stb.st_mode))
  1922. new_ruid = stb.st_uid;
  1923. else if (ctladdr != NULL && ctladdr->q_uid != 0)
  1924. new_ruid = ctladdr->q_uid;
  1925. else if (m->m_uid != 0)
  1926. new_ruid = m->m_uid;
  1927. else
  1928. new_ruid = DefUid;
  1929. if (new_euid != NO_UID)
  1930. {
  1931. vendor_set_uid(new_euid);
  1932. #if MAILER_SETUID_METHOD == USE_SETEUID
  1933. if (seteuid(new_euid) < 0 && suidwarn)
  1934. syserr("openmailer: seteuid(%ld) failed",
  1935. (long) new_euid);
  1936. #endif /* MAILER_SETUID_METHOD == USE_SETEUID */
  1937. #if MAILER_SETUID_METHOD == USE_SETREUID
  1938. if (setreuid(new_ruid, new_euid) < 0 && suidwarn)
  1939. syserr("openmailer: setreuid(%ld, %ld) failed",
  1940. (long) new_ruid, (long) new_euid);
  1941. #endif /* MAILER_SETUID_METHOD == USE_SETREUID */
  1942. #if MAILER_SETUID_METHOD == USE_SETUID
  1943. if (new_euid != geteuid() && setuid(new_euid) < 0 && suidwarn)
  1944. syserr("openmailer: setuid(%ld) failed",
  1945. (long) new_euid);
  1946. #endif /* MAILER_SETUID_METHOD == USE_SETUID */
  1947. }
  1948. else if (new_ruid != NO_UID)
  1949. {
  1950. vendor_set_uid(new_ruid);
  1951. if (setuid(new_ruid) < 0 && suidwarn)
  1952. syserr("openmailer: setuid(%ld) failed",
  1953. (long) new_ruid);
  1954. }
  1956. if (tTd(11, 2))
  1957. dprintf("openmailer: running as r/euid=%d/%d, r/egid=%d/%dn",
  1958. (int) getuid(), (int) geteuid(),
  1959. (int) getgid(), (int) getegid());
  1961. /* move into some "safe" directory */
  1962. if (m->m_execdir != NULL)
  1963. {
  1964. char *q;
  1966. for (p = m->m_execdir; p != NULL; p = q)
  1967. {
  1968. q = strchr(p, ':');
  1969. if (q != NULL)
  1970. *q = '';
  1971. expand(p, buf, sizeof buf, e);
  1972. if (q != NULL)
  1973. *q++ = ':';
  1974. if (tTd(11, 20))
  1975. dprintf("openmailer: trydir %sn",
  1976. buf);
  1977. if (buf[0] != '' && chdir(buf) >= 0)
  1978. break;
  1979. }
  1980. }
  1982. /* arrange to filter std & diag output of command */
  1983. (void) close(rpvect[0]);
  1984. if (dup2(rpvect[1], STDOUT_FILENO) < 0)
  1985. {
  1986. syserr("%s... openmailer(%s): cannot dup pipe %d for stdout",
  1987.        shortenstring(e->e_to, MAXSHORTSTR),
  1988.        m->m_name, rpvect[1]);
  1989. _exit(EX_OSERR);
  1990. }
  1991. (void) close(rpvect[1]);
  1993. if (dup2(STDOUT_FILENO, STDERR_FILENO) < 0)
  1994. {
  1995. syserr("%s... openmailer(%s): cannot dup stdout for stderr",
  1996. shortenstring(e->e_to, MAXSHORTSTR),
  1997. m->m_name);
  1998. _exit(EX_OSERR);
  1999. }
  2001. /* arrange to get standard input */
  2002. (void) close(mpvect[1]);
  2003. if (dup2(mpvect[0], STDIN_FILENO) < 0)
  2004. {
  2005. syserr("%s... openmailer(%s): cannot dup pipe %d for stdin",
  2006. shortenstring(e->e_to, MAXSHORTSTR),
  2007. m->m_name, mpvect[0]);
  2008. _exit(EX_OSERR);
  2009. }
  2010. (void) close(mpvect[0]);
  2012. /* arrange for all the files to be closed */
  2013. for (i = 3; i < DtableSize; i++)
  2014. {
  2015. register int j;
  2017. if ((j = fcntl(i, F_GETFD, 0)) != -1)
  2018. (void) fcntl(i, F_SETFD,
  2019.      j | FD_CLOEXEC);
  2020. }
  2022. /* run disconnected from terminal */
  2023. (void) setsid();
  2025. /* try to execute the mailer */
  2026. (void) execve(m->m_mailer, (ARGV_T) pv,
  2027.       (ARGV_T) UserEnviron);
  2028. save_errno = errno;
  2029. syserr("Cannot exec %s", m->m_mailer);
  2030. if (bitnset(M_LOCALMAILER, m->m_flags) ||
  2031.     transienterror(save_errno))
  2032. _exit(EX_OSERR);
  2033. _exit(EX_UNAVAILABLE);
  2034. }
  2036. /*
  2037. **  Set up return value.
  2038. */
  2040. if (mci == NULL)
  2041. {
  2042. mci = (MCI *) xalloc(sizeof *mci);
  2043. memset((char *) mci, '', sizeof *mci);
  2044. }
  2045. mci->mci_mailer = m;
  2046. if (clever)
  2047. {
  2048. mci->mci_state = MCIS_OPENING;
  2049. mci_cache(mci);
  2050. }
  2051. else
  2052. {
  2053. mci->mci_state = MCIS_OPEN;
  2054. }
  2055. mci->mci_pid = pid;
  2056. (void) close(mpvect[0]);
  2057. mci->mci_out = fdopen(mpvect[1], "w");
  2058. if (mci->mci_out == NULL)
  2059. {
  2060. syserr("deliver: cannot create mailer output channel, fd=%d",
  2061. mpvect[1]);
  2062. (void) close(mpvect[1]);
  2063. (void) close(rpvect[0]);
  2064. (void) close(rpvect[1]);
  2065. rcode = EX_OSERR;
  2066. goto give_up;
  2067. }
  2069. (void) close(rpvect[1]);
  2070. mci->mci_in = fdopen(rpvect[0], "r");
  2071. if (mci->mci_in == NULL)
  2072. {
  2073. syserr("deliver: cannot create mailer input channel, fd=%d",
  2074.        mpvect[1]);
  2075. (void) close(rpvect[0]);
  2076. (void) fclose(mci->mci_out);
  2077. mci->mci_out = NULL;
  2078. rcode = EX_OSERR;
  2079. goto give_up;
  2080. }
  2082. /* Don't cache non-clever connections */
  2083. if (!clever)
  2084. mci->mci_flags |= MCIF_TEMP;
  2085. }
  2087. /*
  2088. **  If we are in SMTP opening state, send initial protocol.
  2089. */
  2091. if (bitnset(M_7BITS, m->m_flags) &&
  2092.     (!clever || mci->mci_state == MCIS_OPENING))
  2093. mci->mci_flags |= MCIF_7BIT;
  2094. #if SMTP
  2095. if (clever && mci->mci_state != MCIS_CLOSED)
  2096. {
  2097. static u_short again = 0;
  2098. # define ONLY_HELO_B 0x04
  2099. # define ONLY_HELO bitset(ONLY_HELO_B, again)
  2100. # define SET_HELO again |= ONLY_HELO_B
  2101. # define CLR_HELO again &= ~ONLY_HELO_B
  2104. # if SASL
  2105. mci->mci_saslcap = NULL;
  2106. # endif /* SASL */
  2107. smtpinit(m, mci, e, ONLY_HELO);
  2108. CLR_HELO;
  2110. # if SASL
  2111. /* if other server supports authentication let's authenticate */
  2112. if (mci->mci_state != MCIS_CLOSED &&
  2113.     mci->mci_saslcap != NULL &&
  2114.     SASLInfo != NULL)
  2115. {
  2116. /*
  2117. **  should we require some minimum authentication?
  2118. **  XXX ignore result?
  2119. */
  2120. if (smtpauth(m, mci, e) == EX_OK)
  2121. {
  2123. }
  2124. }
  2125. # endif /* SASL */
  2126. }
  2128. #endif /* SMTP */
  2130. do_transfer:
  2131. /* clear out per-message flags from connection structure */
  2132. mci->mci_flags &= ~(MCIF_CVT7TO8|MCIF_CVT8TO7);
  2134. if (bitset(EF_HAS8BIT, e->e_flags) &&
  2135.     !bitset(EF_DONT_MIME, e->e_flags) &&
  2136.     bitnset(M_7BITS, m->m_flags))
  2137. mci->mci_flags |= MCIF_CVT8TO7;
  2139. #if MIME7TO8
  2140. if (bitnset(M_MAKE8BIT, m->m_flags) &&
  2141.     !bitset(MCIF_7BIT, mci->mci_flags) &&
  2142.     (p = hvalue("Content-Transfer-Encoding", e->e_header)) != NULL &&
  2143.      (strcasecmp(p, "quoted-printable") == 0 ||
  2144.       strcasecmp(p, "base64") == 0) &&
  2145.     (p = hvalue("Content-Type", e->e_header)) != NULL)
  2146. {
  2147. /* may want to convert 7 -> 8 */
  2148. /* XXX should really parse it here -- and use a class XXX */
  2149. if (strncasecmp(p, "text/plain", 10) == 0 &&
  2150.     (p[10] == '' || p[10] == ' ' || p[10] == ';'))
  2151. mci->mci_flags |= MCIF_CVT7TO8;
  2152. }
  2153. #endif /* MIME7TO8 */
  2155. if (tTd(11, 1))
  2156. {
  2157. dprintf("openmailer: ");
  2158. mci_dump(mci, FALSE);
  2159. }
  2161. if (mci->mci_state != MCIS_OPEN)
  2162. {
  2163. /* couldn't open the mailer */
  2164. rcode = mci->mci_exitstat;
  2165. errno = mci->mci_errno;
  2166. #if NAMED_BIND
  2167. h_errno = mci->mci_herrno;
  2168. #endif /* NAMED_BIND */
  2169. if (rcode == EX_OK)
  2170. {
  2171. /* shouldn't happen */
  2172. syserr("554 5.3.5 deliver: mci=%lx rcode=%d errno=%d state=%d sig=%s",
  2173. (u_long) mci, rcode, errno, mci->mci_state,
  2174. firstsig);
  2175. mci_dump_all(TRUE);
  2176. rcode = EX_SOFTWARE;
  2177. }
  2178. #if DAEMON
  2179. else if (nummxhosts > hostnum)
  2180. {
  2181. /* try next MX site */
  2182. goto tryhost;
  2183. }
  2184. #endif /* DAEMON */
  2185. }
  2186. else if (!clever)
  2187. {
  2188. /*
  2189. **  Format and send message.
  2190. */
  2192. putfromline(mci, e);
  2193. (*e->e_puthdr)(mci, e->e_header, e, M87F_OUTER);
  2194. (*e->e_putbody)(mci, e, NULL);
  2196. /* get the exit status */
  2197. rcode = endmailer(mci, e, pv);
  2198. }
  2199. else
  2200. #if SMTP
  2201. {
  2202. /*
  2203. **  Send the MAIL FROM: protocol
  2204. */
  2206. rcode = smtpmailfrom(m, mci, e);
  2207. if (rcode == EX_OK)
  2208. {
  2209. register char *t = tobuf;
  2210. register int i;
  2212. /* send the recipient list */
  2213. tobuf[0] = '';
  2214. for (to = tochain; to != NULL; to = to->q_tchain)
  2215. {
  2216. e->e_to = to->q_paddr;
  2217. if (strlen(to->q_paddr) +
  2218.     (t - tobuf) + 2 > sizeof tobuf)
  2219. {
  2220. /* not enough room */
  2221. continue;
  2222. }
  2223. else if ((i = smtprcpt(to, m, mci, e)) != EX_OK)
  2224. {
  2225. markfailure(e, to, mci, i, FALSE);
  2226. giveresponse(i, m, mci, ctladdr,
  2227.      xstart, e);
  2228. }
  2229. else
  2230. {
  2231. *t++ = ',';
  2232. for (p = to->q_paddr; *p; *t++ = *p++)
  2233. continue;
  2234. *t = '';
  2235. }
  2236. }
  2238. /* now send the data */
  2239. if (tobuf[0] == '')
  2240. {
  2241. rcode = EX_OK;
  2242. e->e_to = NULL;
  2243. if (bitset(MCIF_CACHED, mci->mci_flags))
  2244. smtprset(m, mci, e);
  2245. }
  2246. else
  2247. {
  2248. e->e_to = tobuf + 1;
  2249. rcode = smtpdata(m, mci, e);
  2250. }
  2251. }
  2252. # if DAEMON
  2253. if (rcode == EX_TEMPFAIL && nummxhosts > hostnum)
  2254. {
  2255. /* try next MX site */
  2256. goto tryhost;
  2257. }
  2258. # endif /* DAEMON */
  2259. }
  2260. #else /* SMTP */
  2261. {
  2262. syserr("554 5.3.5 deliver: need SMTP compiled to use clever mailer");
  2263. rcode = EX_CONFIG;
  2264. goto give_up;
  2265. }
  2266. #endif /* SMTP */
  2267. #if NAMED_BIND
  2268. if (ConfigLevel < 2)
  2269. _res.options |= RES_DEFNAMES | RES_DNSRCH; /* XXX */
  2270. #endif /* NAMED_BIND */
  2272. if (tTd(62, 1))
  2273. checkfds("after delivery");
  2275. /*
  2276. **  Do final status disposal.
  2277. ** We check for something in tobuf for the SMTP case.
  2278. ** If we got a temporary failure, arrange to queue the
  2279. ** addressees.
  2280. */
  2282.   give_up:
  2283. #if SMTP
  2284. if (bitnset(M_LMTP, m->m_flags))
  2285. {
  2286. lmtp_rcode = rcode;
  2287. tobuf[0] = '';
  2288. anyok = FALSE;
  2289. }
  2290. else
  2291. #endif /* SMTP */
  2292. anyok = rcode == EX_OK;
  2294. for (to = tochain; to != NULL; to = to->q_tchain)
  2295. {
  2296. /* see if address already marked */
  2297. if (!QS_IS_OK(to->q_state))
  2298. continue;
  2300. #if SMTP
  2301. /* if running LMTP, get the status for each address */
  2302. if (bitnset(M_LMTP, m->m_flags))
  2303. {
  2304. if (lmtp_rcode == EX_OK)
  2305. rcode = smtpgetstat(m, mci, e);
  2306. if (rcode == EX_OK)
  2307. {
  2308. if (strlen(to->q_paddr) +
  2309.     strlen(tobuf) + 2 > sizeof tobuf)
  2310. {
  2311. syserr("LMTP tobuf overflow");
  2312. }
  2313. else
  2314. {
  2315. (void) strlcat(tobuf, ",",
  2316.        sizeof tobuf);
  2317. (void) strlcat(tobuf, to->q_paddr,
  2318.        sizeof tobuf);
  2319. }
  2320. anyok = TRUE;
  2321. }
  2322. else
  2323. {
  2324. e->e_to = to->q_paddr;
  2325. markfailure(e, to, mci, rcode, TRUE);
  2326. giveresponse(rcode, m, mci, ctladdr, xstart, e);
  2327. e->e_to = tobuf + 1;
  2328. continue;
  2329. }
  2330. }
  2331. else
  2332. #endif /* SMTP */
  2333. {
  2334. /* mark bad addresses */
  2335. if (rcode != EX_OK)
  2336. {
  2337. if (goodmxfound && rcode == EX_NOHOST)
  2338. rcode = EX_TEMPFAIL;
  2339. markfailure(e, to, mci, rcode, TRUE);
  2340. continue;
  2341. }
  2342. }
  2344. /* successful delivery */
  2345. to->q_state = QS_SENT;
  2346. to->q_statdate = curtime();
  2347. e->e_nsent++;
  2349. #if QUEUE
  2350. /*
  2351. **  Checkpoint the send list every few addresses
  2352. */
  2354. if (e->e_nsent >= CheckpointInterval)
  2355. {
  2356. queueup(e, FALSE);
  2357. e->e_nsent = 0;
  2358. }
  2359. #endif /* QUEUE */
  2361. if (bitnset(M_LOCALMAILER, m->m_flags) &&
  2362.     bitset(QPINGONSUCCESS, to->q_flags))
  2363. {
  2364. to->q_flags |= QDELIVERED;
  2365. to->q_status = "2.1.5";
  2366. fprintf(e->e_xfp, "%s... Successfully deliveredn",
  2367. to->q_paddr);
  2368. }
  2369. else if (bitset(QPINGONSUCCESS, to->q_flags) &&
  2370.  bitset(QPRIMARY, to->q_flags) &&
  2371.  !bitset(MCIF_DSN, mci->mci_flags))
  2372. {
  2373. to->q_flags |= QRELAYED;
  2374. fprintf(e->e_xfp, "%s... relayed; expect no further notificationsn",
  2375. to->q_paddr);
  2376. }
  2377. }
  2379. #if SMTP
  2380. if (bitnset(M_LMTP, m->m_flags))
  2381. {
  2382. /*
  2383. **  Global information applies to the last recipient only;
  2384. **  clear it out to avoid bogus errors.
  2385. */
  2387. rcode = EX_OK;
  2388. e->e_statmsg = NULL;
  2390. /* reset the mci state for the next transaction */
  2391. if (mci != NULL && mci->mci_state == MCIS_ACTIVE)
  2392. mci->mci_state = MCIS_OPEN;
  2393. }
  2394. #endif /* SMTP */
  2396. if (tobuf[0] != '')
  2397. giveresponse(rcode, m, mci, ctladdr, xstart, e);
  2398. if (anyok)
  2399. markstats(e, tochain, FALSE);
  2400. mci_store_persistent(mci);
  2402. #if SMTP
  2403. /* now close the connection */
  2404. if (clever && mci != NULL && mci->mci_state != MCIS_CLOSED &&
  2405.     !bitset(MCIF_CACHED, mci->mci_flags))
  2406. smtpquit(m, mci, e);
  2407. #endif /* SMTP */
  2409. /*
  2410. **  Restore state and return.
  2411. */
  2413. #if XDEBUG
  2414. {
  2415. char wbuf[MAXLINE];
  2417. /* make absolutely certain 0, 1, and 2 are in use */
  2418. snprintf(wbuf, sizeof wbuf, "%s... end of deliver(%s)",
  2419. e->e_to == NULL ? "NO-TO-LIST"
  2420. : shortenstring(e->e_to, MAXSHORTSTR),
  2421. m->m_name);
  2422. checkfd012(wbuf);
  2423. }
  2424. #endif /* XDEBUG */
  2426. errno = 0;
  2427. define('g', (char *) NULL, e);
  2428. return rcode;
  2429. }
  2431. /*
  2432. **  MARKFAILURE -- mark a failure on a specific address.
  2433. **
  2434. ** Parameters:
  2435. ** e -- the envelope we are sending.
  2436. ** q -- the address to mark.
  2437. ** mci -- mailer connection information.
  2438. ** rcode -- the code signifying the particular failure.
  2439. ** ovr -- override an existing code?
  2440. **
  2441. ** Returns:
  2442. ** none.
  2443. **
  2444. ** Side Effects:
  2445. ** marks the address (and possibly the envelope) with the
  2446. ** failure so that an error will be returned or
  2447. ** the message will be queued, as appropriate.
  2448. */
  2450. static void
  2451. markfailure(e, q, mci, rcode, ovr)
  2452. register ENVELOPE *e;
  2453. register ADDRESS *q;
  2454. register MCI *mci;
  2455. int rcode;
  2456. bool ovr;
  2457. {
  2458. char *status = NULL;
  2459. char *rstatus = NULL;
  2461. switch (rcode)
  2462. {
  2463.   case EX_OK:
  2464. break;
  2466.   case EX_TEMPFAIL:
  2467.   case EX_IOERR:
  2468.   case EX_OSERR:
  2469. q->q_state = QS_QUEUEUP;
  2470. break;
  2472.   default:
  2473. q->q_state = QS_BADADDR;
  2474. break;
  2475. }
  2477. /* find most specific error code possible */
  2478. if (mci != NULL && mci->mci_status != NULL)
  2479. {
  2480. status = mci->mci_status;
  2481. if (mci->mci_rstatus != NULL)
  2482. rstatus = newstr(mci->mci_rstatus);
  2483. else
  2484. rstatus = NULL;
  2485. }
  2486. else if (e->e_status != NULL)
  2487. {
  2488. status = e->e_status;
  2489. rstatus = NULL;
  2490. }
  2491. else
  2492. {
  2493. switch (rcode)
  2494. {
  2495.   case EX_USAGE:
  2496. status = "5.5.4";
  2497. break;
  2499.   case EX_DATAERR:
  2500. status = "5.5.2";
  2501. break;
  2503.   case EX_NOUSER:
  2504. status = "5.1.1";
  2505. break;
  2507.   case EX_NOHOST:
  2508. status = "5.1.2";
  2509. break;
  2511.   case EX_NOINPUT:
  2512.   case EX_CANTCREAT:
  2513.   case EX_NOPERM:
  2514. status = "5.3.0";
  2515. break;
  2517.   case EX_UNAVAILABLE:
  2518.   case EX_SOFTWARE:
  2519.   case EX_OSFILE:
  2520.   case EX_PROTOCOL:
  2521.   case EX_CONFIG:
  2522. status = "5.5.0";
  2523. break;
  2525.   case EX_OSERR:
  2526.   case EX_IOERR:
  2527. status = "4.5.0";
  2528. break;
  2530.   case EX_TEMPFAIL:
  2531. status = "4.2.0";
  2532. break;
  2533. }
  2534. }
  2536. /* new status? */
  2537. if (status != NULL && *status != '' && (ovr || q->q_status == NULL ||
  2538.     *q->q_status == '' || *q->q_status < *status))
  2539. {
  2540. q->q_status = status;
  2541. q->q_rstatus = rstatus;
  2542. }
  2543. if (rcode != EX_OK && q->q_rstatus == NULL &&
  2544.     q->q_mailer != NULL && q->q_mailer->m_diagtype != NULL &&
  2545.     strcasecmp(q->q_mailer->m_diagtype, "X-UNIX") == 0)
  2546. {
  2547. char buf[16];
  2549. (void) snprintf(buf, sizeof buf, "%d", rcode);
  2550. q->q_rstatus = newstr(buf);
  2551. }
  2553. q->q_statdate = curtime();
  2554. if (CurHostName != NULL && CurHostName[0] != '' &&
  2555.     mci != NULL && !bitset(M_LOCALMAILER, mci->mci_flags))
  2556. q->q_statmta = newstr(CurHostName);
  2557. }
  2558. /*
  2559. **  ENDMAILER -- Wait for mailer to terminate.
  2560. **
  2561. ** We should never get fatal errors (e.g., segmentation
  2562. ** violation), so we report those specially.  For other
  2563. ** errors, we choose a status message (into statmsg),
  2564. ** and if it represents an error, we print it.
  2565. **
  2566. ** Parameters:
  2567. ** pid -- pid of mailer.
  2568. ** e -- the current envelope.
  2569. ** pv -- the parameter vector that invoked the mailer
  2570. ** (for error messages).
  2571. **
  2572. ** Returns:
  2573. ** exit code of mailer.
  2574. **
  2575. ** Side Effects:
  2576. ** none.
  2577. */
  2579. static jmp_buf EndWaitTimeout;
  2581. static void
  2582. endwaittimeout()
  2583. {
  2584. errno = ETIMEDOUT;
  2585. longjmp(EndWaitTimeout, 1);
  2586. }
  2588. int
  2589. endmailer(mci, e, pv)
  2590. register MCI *mci;
  2591. register ENVELOPE *e;
  2592. char **pv;
  2593. {
  2594. int st;
  2595. int save_errno = errno;
  2596. char buf[MAXLINE];
  2597. EVENT *ev = NULL;
  2599. mci_unlock_host(mci);
  2601. /* close output to mailer */
  2602. if (mci->mci_out != NULL)
  2603. (void) fclose(mci->mci_out);
  2605. /* copy any remaining input to transcript */
  2606. if (mci->mci_in != NULL && e->e_xfp != NULL)
  2607. {
  2608. while (sfgets(buf, sizeof buf, mci->mci_in,
  2609.        TimeOuts.to_quit, "Draining Input") != NULL)
  2610. /* while (fgets(buf, sizeof buf, mci->mci_in) != NULL) */
  2611. (void) fputs(buf, e->e_xfp);
  2612. }
  2614. /* now close the input */
  2615. if (mci->mci_in != NULL)
  2616. (void) fclose(mci->mci_in);
  2617. mci->mci_in = mci->mci_out = NULL;
  2618. mci->mci_state = MCIS_CLOSED;
  2620. errno = save_errno;
  2622. /* in the IPC case there is nothing to wait for */
  2623. if (mci->mci_pid == 0)
  2624. return EX_OK;
  2626. /* put a timeout around the wait */
  2627. if (mci->mci_mailer->m_wait > 0)
  2628. {
  2629. if (setjmp(EndWaitTimeout) == 0)
  2630. ev = setevent(mci->mci_mailer->m_wait,
  2631.       endwaittimeout, 0);
  2632. else
  2633. {
  2634. syserr("endmailer %s: wait timeout (%d)",
  2635.        mci->mci_mailer->m_name,
  2636.        mci->mci_mailer->m_wait);
  2637. return EX_TEMPFAIL;
  2638. }
  2639. }
  2641. /* wait for the mailer process, collect status */
  2642. st = waitfor(mci->mci_pid);
  2643. save_errno = errno;
  2644. if (ev != NULL)
  2645. clrevent(ev);
  2646. errno = save_errno;
  2648. if (st == -1)
  2649. {
  2650. syserr("endmailer %s: wait", mci->mci_mailer->m_name);
  2651. return EX_SOFTWARE;
  2652. }
  2654. if (WIFEXITED(st))
  2655. {
  2656. /* normal death -- return status */
  2657. return (WEXITSTATUS(st));
  2658. }
  2660. /* it died a horrid death */
  2661. syserr("451 4.3.0 mailer %s died with signal %d%s",
  2662. mci->mci_mailer->m_name, WTERMSIG(st),
  2663. WCOREDUMP(st) ? " (core dumped)" :
  2664. (WIFSTOPPED(st) ? " (stopped)" : ""));
  2666. /* log the arguments */
  2667. if (pv != NULL && e->e_xfp != NULL)
  2668. {
  2669. register char **av;
  2671. fprintf(e->e_xfp, "Arguments:");
  2672. for (av = pv; *av != NULL; av++)
  2673. fprintf(e->e_xfp, " %s", *av);
  2674. fprintf(e->e_xfp, "n");
  2675. }
  2677. ExitStat = EX_TEMPFAIL;
  2678. return EX_TEMPFAIL;
  2679. }
  2680. /*
  2681. **  GIVERESPONSE -- Interpret an error response from a mailer
  2682. **
  2683. ** Parameters:
  2684. ** status -- the status code from the mailer (high byte
  2685. ** only; core dumps must have been taken care of
  2686. ** already).
  2687. ** m -- the mailer info for this mailer.
  2688. ** mci -- the mailer connection info -- can be NULL if the
  2689. ** response is given before the connection is made.
  2690. ** ctladdr -- the controlling address for the recipient
  2691. ** address(es).
  2692. ** xstart -- the transaction start time, for computing
  2693. ** transaction delays.
  2694. ** e -- the current envelope.
  2695. **
  2696. ** Returns:
  2697. ** none.
  2698. **
  2699. ** Side Effects:
  2700. ** Errors may be incremented.
  2701. ** ExitStat may be set.
  2702. */
  2704. void
  2705. giveresponse(status, m, mci, ctladdr, xstart, e)
  2706. int status;
  2707. register MAILER *m;
  2708. register MCI *mci;
  2709. ADDRESS *ctladdr;
  2710. time_t xstart;
  2711. ENVELOPE *e;
  2712. {
  2713. register const char *statmsg;
  2714. extern char *SysExMsg[];
  2715. register int i;
  2716. int errnum = errno;
  2717. int off = 4;
  2718. extern int N_SysEx;
  2719. char buf[MAXLINE];
  2721. if (e == NULL)
  2722. syserr("giveresponse: null envelope");
  2724. /*
  2725. **  Compute status message from code.
  2726. */
  2728. i = status - EX__BASE;
  2729. if (status == 0)
  2730. {
  2731. statmsg = "250 2.0.0 Sent";
  2732. if (e->e_statmsg != NULL)
  2733. {
  2734. (void) snprintf(buf, sizeof buf, "%s (%s)",
  2735. statmsg, shortenstring(e->e_statmsg, 403));
  2736. statmsg = buf;
  2737. }
  2738. }
  2739. else if (i < 0 || i >= N_SysEx)
  2740. {
  2741. (void) snprintf(buf, sizeof buf, "554 5.3.0 unknown mailer error %d",
  2742. status);
  2743. status = EX_UNAVAILABLE;
  2744. statmsg = buf;
  2745. }
  2746. else if (status == EX_TEMPFAIL)
  2747. {
  2748. char *bp = buf;
  2750. snprintf(bp, SPACELEFT(buf, bp), "%s", SysExMsg[i] + 1);
  2751. bp += strlen(bp);
  2752. #if NAMED_BIND
  2753. if (h_errno == TRY_AGAIN)
  2754. statmsg = errstring(h_errno+E_DNSBASE);
  2755. else
  2756. #endif /* NAMED_BIND */
  2757. {
  2758. if (errnum != 0)
  2759. statmsg = errstring(errnum);
  2760. else
  2761. {
  2762. #if SMTP
  2763. statmsg = SmtpError;
  2764. #else /* SMTP */
  2765. statmsg = NULL;
  2766. #endif /* SMTP */
  2767. }
  2768. }
  2769. if (statmsg != NULL && statmsg[0] != '')
  2770. {
  2771. switch (errnum)
  2772. {
  2773. #ifdef ENETDOWN
  2774.   case ENETDOWN: /* Network is down */
  2775. #endif /* ENETDOWN */
  2776. #ifdef ENETUNREACH
  2777.   case ENETUNREACH: /* Network is unreachable */
  2778. #endif /* ENETUNREACH */
  2779. #ifdef ENETRESET
  2780.   case ENETRESET: /* Network dropped connection on reset */
  2781. #endif /* ENETRESET */
  2782. #ifdef ECONNABORTED
  2783.   case ECONNABORTED: /* Software caused connection abort */
  2784. #endif /* ECONNABORTED */
  2785. #ifdef EHOSTDOWN
  2786.   case EHOSTDOWN: /* Host is down */
  2787. #endif /* EHOSTDOWN */
  2788. #ifdef EHOSTUNREACH
  2789.   case EHOSTUNREACH: /* No route to host */
  2790. #endif /* EHOSTUNREACH */
  2791. if (mci->mci_host != NULL)
  2792. {
  2793. snprintf(bp, SPACELEFT(buf, bp),
  2794.  ": %s", mci->mci_host);
  2795. bp += strlen(bp);
  2796. }
  2797. break;
  2798. }
  2799. snprintf(bp, SPACELEFT(buf, bp), ": %s", statmsg);
  2800. }
  2801. statmsg = buf;
  2802. }
  2803. #if NAMED_BIND
  2804. else if (status == EX_NOHOST && h_errno != 0)
  2805. {
  2806. statmsg = errstring(h_errno + E_DNSBASE);
  2807. (void) snprintf(buf, sizeof buf, "%s (%s)",
  2808. SysExMsg[i] + 1, statmsg);
  2809. statmsg = buf;
  2810. }
  2811. #endif /* NAMED_BIND */
  2812. else
  2813. {
  2814. statmsg = SysExMsg[i];
  2815. if (*statmsg++ == ':' && errnum != 0)
  2816. {
  2817. (void) snprintf(buf, sizeof buf, "%s: %s",
  2818. statmsg, errstring(errnum));
  2819. statmsg = buf;
  2820. }
  2821. }
  2823. /*
  2824. **  Print the message as appropriate
  2825. */
  2827. if (status == EX_OK || status == EX_TEMPFAIL)
  2828. {
  2829. extern char MsgBuf[];
  2831. if ((off = isenhsc(statmsg + 4, ' ')) > 0)
  2832. off += 5;
  2833. else
  2834. off = 4;
  2835. message("%s", statmsg + off);
  2836. if (status == EX_TEMPFAIL && e->e_xfp != NULL)
  2837. fprintf(e->e_xfp, "%sn", &MsgBuf[4]);
  2838. }
  2839. else
  2840. {
  2841. char mbuf[ENHSCLEN + 4];
  2843. Errors++;
  2844. if ((off = isenhsc(statmsg + 4, ' ')) > 0 &&
  2845.     off < sizeof mbuf - 4)
  2846. {
  2847. off += 5;
  2848. (void) strlcpy(mbuf, statmsg, off);
  2849. (void) strlcat(mbuf, " %s", sizeof mbuf);
  2850. }
  2851. else
  2852. {
  2853. (void) snprintf(mbuf, sizeof mbuf, "%.3s %%s", statmsg);
  2854. off = 4;
  2855. }
  2856. usrerr(mbuf, &statmsg[off]);
  2857. }
  2859. /*
  2860. **  Final cleanup.
  2861. ** Log a record of the transaction.  Compute the new
  2862. ** ExitStat -- if we already had an error, stick with
  2863. ** that.
  2864. */
  2866. if (OpMode != MD_VERIFY && !bitset(EF_VRFYONLY, e->e_flags) &&
  2867.     LogLevel > ((status == EX_TEMPFAIL) ? 8 : (status == EX_OK) ? 7 : 6))
  2868. logdelivery(m, mci, statmsg, ctladdr, xstart, e);
  2870. if (tTd(11, 2))
  2871. dprintf("giveresponse: status=%d, e->e_message=%sn",
  2872. status, e->e_message == NULL ? "<NULL>" : e->e_message);
  2874. if (status != EX_TEMPFAIL)
  2875. setstat(status);
  2876. if (status != EX_OK && (status != EX_TEMPFAIL || e->e_message == NULL))
  2877. {
  2878. if (e->e_message != NULL)
  2879. free(e->e_message);
  2880. e->e_message = newstr(statmsg);
  2881. }
  2882. errno = 0;
  2883. #if NAMED_BIND
  2884. h_errno = 0;
  2885. #endif /* NAMED_BIND */
  2886. }
  2887. /*
  2888. **  LOGDELIVERY -- log the delivery in the system log
  2889. **
  2890. ** Care is taken to avoid logging lines that are too long, because
  2891. ** some versions of syslog have an unfortunate proclivity for core
  2892. ** dumping.  This is a hack, to be sure, that is at best empirical.
  2893. **
  2894. ** Parameters:
  2895. ** m -- the mailer info.  Can be NULL for initial queue.
  2896. ** mci -- the mailer connection info -- can be NULL if the
  2897. ** log is occurring when no connection is active.
  2898. ** status -- the message to print for the status.
  2899. ** ctladdr -- the controlling address for the to list.
  2900. ** xstart -- the transaction start time, used for
  2901. ** computing transaction delay.
  2902. ** e -- the current envelope.
  2903. **
  2904. ** Returns:
  2905. ** none
  2906. **
  2907. ** Side Effects:
  2908. ** none
  2909. */
  2911. void
  2912. logdelivery(m, mci, status, ctladdr, xstart, e)
  2913. MAILER *m;
  2914. register MCI *mci;
  2915. const char *status;
  2916. ADDRESS *ctladdr;
  2917. time_t xstart;
  2918. register ENVELOPE *e;
  2919. {
  2920. register char *bp;
  2921. register char *p;
  2922. int l;
  2923. char buf[1024];
  2925. #if (SYSLOG_BUFSIZE) >= 256
  2926. /* ctladdr: max 106 bytes */
  2927. bp = buf;
  2928. if (ctladdr != NULL)
  2929. {
  2930. snprintf(bp, SPACELEFT(buf, bp), ", ctladdr=%s",
  2931.  shortenstring(ctladdr->q_paddr, 83));
  2932. bp += strlen(bp);
  2933. if (bitset(QGOODUID, ctladdr->q_flags))
  2934. {
  2935. (void) snprintf(bp, SPACELEFT(buf, bp), " (%d/%d)",
  2936. (int) ctladdr->q_uid,
  2937. (int) ctladdr->q_gid);
  2938. bp += strlen(bp);
  2939. }
  2940. }
  2942. /* delay & xdelay: max 41 bytes */
  2943. snprintf(bp, SPACELEFT(buf, bp), ", delay=%s",
  2944.  pintvl(curtime() - e->e_ctime, TRUE));
  2945. bp += strlen(bp);
  2947. if (xstart != (time_t) 0)
  2948. {
  2949. snprintf(bp, SPACELEFT(buf, bp), ", xdelay=%s",
  2950.  pintvl(curtime() - xstart, TRUE));
  2951. bp += strlen(bp);
  2952. }
  2954. /* mailer: assume about 19 bytes (max 10 byte mailer name) */
  2955. if (m != NULL)
  2956. {
  2957. snprintf(bp, SPACELEFT(buf, bp), ", mailer=%s", m->m_name);
  2958. bp += strlen(bp);
  2959. }
  2961. /* pri: changes with each delivery attempt */
  2962. snprintf(bp, SPACELEFT(buf, bp), ", pri=%ld", e->e_msgpriority);
  2963. bp += strlen(bp);
  2965. /* relay: max 66 bytes for IPv4 addresses */
  2966. if (mci != NULL && mci->mci_host != NULL)
  2967. {
  2968. # if DAEMON
  2969. extern SOCKADDR CurHostAddr;
  2970. # endif /* DAEMON */
  2972. snprintf(bp, SPACELEFT(buf, bp), ", relay=%s",
  2973.  shortenstring(mci->mci_host, 40));
  2974. bp += strlen(bp);
  2976. # if DAEMON
  2977. if (CurHostAddr.sa.sa_family != 0)
  2978. {
  2979. snprintf(bp, SPACELEFT(buf, bp), " [%s]",
  2980.  anynet_ntoa(&CurHostAddr));
  2981. }
  2982. # endif /* DAEMON */
  2983. }
  2984. else if (strcmp(status, "queued") != 0)
  2985. {
  2986. p = macvalue('h', e);
  2987. if (p != NULL && p[0] != '')
  2988. {
  2989. snprintf(bp, SPACELEFT(buf, bp), ", relay=%s",
  2990.  shortenstring(p, 40));
  2991. }
  2992. }
  2993. bp += strlen(bp);
  2995. # define STATLEN (((SYSLOG_BUFSIZE) - 100) / 4)
  2996. # if (STATLEN) < 63
  2997. #  undef STATLEN
  2998. #  define STATLEN 63
  2999. # endif /* (STATLEN) < 63 */
  3000. # if (STATLEN) > 203
  3001. #  undef STATLEN
  3002. #  define STATLEN 203
  3003. # endif /* (STATLEN) > 203 */
  3005. /* stat: max 210 bytes */
  3006. if ((bp - buf) > (sizeof buf - ((STATLEN) + 20)))
  3007. {
  3008. /* desperation move -- truncate data */
  3009. bp = buf + sizeof buf - ((STATLEN) + 17);
  3010. (void) strlcpy(bp, "...", SPACELEFT(buf, bp));
  3011. bp += 3;
  3012. }
  3014. (void) strlcpy(bp, ", stat=", SPACELEFT(buf, bp));
  3015. bp += strlen(bp);
  3017. (void) strlcpy(bp, shortenstring(status, STATLEN), SPACELEFT(buf, bp));
  3019. /* id, to: max 13 + TOBUFSIZE bytes */
  3020. l = SYSLOG_BUFSIZE - 100 - strlen(buf);
  3021. p = e->e_to;
  3022. while (strlen(p) >= (SIZE_T) l)
  3023. {
  3024. register char *q = strchr(p + l, ',');
  3026. if (q == NULL)
  3027. break;
  3028. sm_syslog(LOG_INFO, e->e_id,
  3029.   "to=%.*s [more]%s",
  3030.   ++q - p, p, buf);
  3031. p = q;
  3032. }
  3033. sm_syslog(LOG_INFO, e->e_id, "to=%s%s", p, buf);
  3035. #else /* (SYSLOG_BUFSIZE) >= 256 */
  3037. l = SYSLOG_BUFSIZE - 85;
  3038. p = e->e_to;
  3039. while (strlen(p) >= (SIZE_T) l)
  3040. {
  3041. register char *q = strchr(p + l, ',');
  3043. if (q == NULL)
  3044. break;
  3045. sm_syslog(LOG_INFO, e->e_id,
  3046.   "to=%.*s [more]",
  3047.   ++q - p, p);
  3048. p = q;
  3049. }
  3050. sm_syslog(LOG_INFO, e->e_id, "to=%s", p);
  3052. if (ctladdr != NULL)
  3053. {
  3054. bp = buf;
  3055. snprintf(bp, SPACELEFT(buf, bp), "ctladdr=%s",
  3056.  shortenstring(ctladdr->q_paddr, 83));
  3057. bp += strlen(bp);
  3058. if (bitset(QGOODUID, ctladdr->q_flags))
  3059. {
  3060. (void) snprintf(bp, SPACELEFT(buf, bp), " (%d/%d)",
  3061. ctladdr->q_uid, ctladdr->q_gid);
  3062. bp += strlen(bp);
  3063. }
  3064. sm_syslog(LOG_INFO, e->e_id, "%s", buf);
  3065. }
  3066. bp = buf;
  3067. snprintf(bp, SPACELEFT(buf, bp), "delay=%s",
  3068.  pintvl(curtime() - e->e_ctime, TRUE));
  3069. bp += strlen(bp);
  3070. if (xstart != (time_t) 0)
  3071. {
  3072. snprintf(bp, SPACELEFT(buf, bp), ", xdelay=%s",
  3073.  pintvl(curtime() - xstart, TRUE));
  3074. bp += strlen(bp);
  3075. }
  3077. if (m != NULL)
  3078. {
  3079. snprintf(bp, SPACELEFT(buf, bp), ", mailer=%s", m->m_name);
  3080. bp += strlen(bp);
  3081. }
  3082. sm_syslog(LOG_INFO, e->e_id, "%.1000s", buf);
  3084. buf[0] = '';
  3085. bp = buf;
  3086. if (mci != NULL && mci->mci_host != NULL)
  3087. {
  3088. # if DAEMON
  3089. extern SOCKADDR CurHostAddr;
  3090. # endif /* DAEMON */
  3092. snprintf(bp, SPACELEFT(buf, bp), "relay=%.100s", mci->mci_host);
  3093. bp += strlen(bp);
  3095. # if DAEMON
  3096. if (CurHostAddr.sa.sa_family != 0)
  3097. snprintf(bp, SPACELEFT(buf, bp), " [%.100s]",
  3098. anynet_ntoa(&CurHostAddr));
  3099. # endif /* DAEMON */
  3100. }
  3101. else if (strcmp(status, "queued") != 0)
  3102. {
  3103. p = macvalue('h', e);
  3104. if (p != NULL && p[0] != '')
  3105. snprintf(buf, sizeof buf, "relay=%.100s", p);
  3106. }
  3107. if (buf[0] != '')
  3108. sm_syslog(LOG_INFO, e->e_id, "%.1000s", buf);
  3110. sm_syslog(LOG_INFO, e->e_id, "stat=%s", shortenstring(status, 63));
  3111. #endif /* (SYSLOG_BUFSIZE) >= 256 */
  3112. }
  3113. /*
  3114. **  PUTFROMLINE -- output a UNIX-style from line (or whatever)
  3115. **
  3116. ** This can be made an arbitrary message separator by changing $l
  3117. **
  3118. ** One of the ugliest hacks seen by human eyes is contained herein:
  3119. ** UUCP wants those stupid "remote from <host>" lines.  Why oh why
  3120. ** does a well-meaning programmer such as myself have to deal with
  3121. ** this kind of antique garbage????
  3122. **
  3123. ** Parameters:
  3124. ** mci -- the connection information.
  3125. ** e -- the envelope.
  3126. **
  3127. ** Returns:
  3128. ** none
  3129. **
  3130. ** Side Effects:
  3131. ** outputs some text to fp.
  3132. */
  3134. void
  3135. putfromline(mci, e)
  3136. register MCI *mci;
  3137. ENVELOPE *e;
  3138. {
  3139. char *template = UnixFromLine;
  3140. char buf[MAXLINE];
  3141. char xbuf[MAXLINE];
  3143. if (bitnset(M_NHDR, mci->mci_mailer->m_flags))
  3144. return;
  3146. mci->mci_flags |= MCIF_INHEADER;
  3148. if (bitnset(M_UGLYUUCP, mci->mci_mailer->m_flags))
  3149. {
  3150. char *bang;
  3152. expand("201g", buf, sizeof buf, e);
  3153. bang = strchr(buf, '!');
  3154. if (bang == NULL)
  3155. {
  3156. char *at;
  3157. char hname[MAXNAME];
  3159. /*
  3160. **  If we can construct a UUCP path, do so
  3161. */
  3163. at = strrchr(buf, '@');
  3164. if (at == NULL)
  3165. {
  3166. expand("201k", hname, sizeof hname, e);
  3167. at = hname;
  3168. }
  3169. else
  3170. *at++ = '';
  3171. (void) snprintf(xbuf, sizeof xbuf,
  3172. "From %.800s  201d remote from %.100sn",
  3173. buf, at);
  3174. }
  3175. else
  3176. {
  3177. *bang++ = '';
  3178. (void) snprintf(xbuf, sizeof xbuf,
  3179. "From %.800s  201d remote from %.100sn",
  3180. bang, buf);
  3181. template = xbuf;
  3182. }
  3183. }
  3184. expand(template, buf, sizeof buf, e);
  3185. putxline(buf, strlen(buf), mci, PXLF_HEADER);
  3186. }
  3187. /*
  3188. **  PUTBODY -- put the body of a message.
  3189. **
  3190. ** Parameters:
  3191. ** mci -- the connection information.
  3192. ** e -- the envelope to put out.
  3193. ** separator -- if non-NULL, a message separator that must
  3194. ** not be permitted in the resulting message.
  3195. **
  3196. ** Returns:
  3197. ** none.
  3198. **
  3199. ** Side Effects:
  3200. ** The message is written onto fp.
  3201. */
  3203. /* values for output state variable */
  3204. #define OS_HEAD 0 /* at beginning of line */
  3205. #define OS_CR 1 /* read a carriage return */
  3206. #define OS_INLINE 2 /* putting rest of line */
  3208. void
  3209. putbody(mci, e, separator)
  3210. register MCI *mci;
  3211. register ENVELOPE *e;
  3212. char *separator;
  3213. {
  3214. bool dead = FALSE;
  3215. char buf[MAXLINE];
  3216. char *boundaries[MAXMIMENESTING + 1];
  3218. /*
  3219. **  Output the body of the message
  3220. */
  3222. if (e->e_dfp == NULL && bitset(EF_HAS_DF, e->e_flags))
  3223. {
  3224. char *df = queuename(e, 'd');
  3226. e->e_dfp = fopen(df, "r");
  3227. if (e->e_dfp == NULL)
  3228. syserr("putbody: Cannot open %s for %s from %s",
  3229. df, e->e_to, e->e_from.q_paddr);
  3230. }
  3231. if (e->e_dfp == NULL)
  3232. {
  3233. if (bitset(MCIF_INHEADER, mci->mci_flags))
  3234. {
  3235. putline("", mci);
  3236. mci->mci_flags &= ~MCIF_INHEADER;
  3237. }
  3238. putline("<<< No Message Collected >>>", mci);
  3239. goto endofmessage;
  3240. }
  3241. if (e->e_dfino == (ino_t) 0)
  3242. {
  3243. struct stat stbuf;
  3245. if (fstat(fileno(e->e_dfp), &stbuf) < 0)
  3246. e->e_dfino = -1;
  3247. else
  3248. {
  3249. e->e_dfdev = stbuf.st_dev;
  3250. e->e_dfino = stbuf.st_ino;
  3251. }
  3252. }
  3254. /* paranoia: the df file should always be in a rewound state */
  3255. (void) bfrewind(e->e_dfp);
  3257. #if MIME8TO7
  3258. if (bitset(MCIF_CVT8TO7, mci->mci_flags))
  3259. {
  3260. /*
  3261. **  Do 8 to 7 bit MIME conversion.
  3262. */
  3264. /* make sure it looks like a MIME message */
  3265. if (hvalue("MIME-Version", e->e_header) == NULL)
  3266. putline("MIME-Version: 1.0", mci);
  3268. if (hvalue("Content-Type", e->e_header) == NULL)
  3269. {
  3270. snprintf(buf, sizeof buf,
  3271. "Content-Type: text/plain; charset=%s",
  3272. defcharset(e));
  3273. putline(buf, mci);
  3274. }
  3276. /* now do the hard work */
  3277. boundaries[0] = NULL;
  3278. mci->mci_flags |= MCIF_INHEADER;
  3279. (void) mime8to7(mci, e->e_header, e, boundaries, M87F_OUTER);
  3280. }
  3281. # if MIME7TO8
  3282. else if (bitset(MCIF_CVT7TO8, mci->mci_flags))
  3283. {
  3284. (void) mime7to8(mci, e->e_header, e);
  3285. }
  3286. # endif /* MIME7TO8 */
  3287. else if (MaxMimeHeaderLength > 0 || MaxMimeFieldLength > 0)
  3288. {
  3289. bool oldsuprerrs = SuprErrs;
  3291. /* Use mime8to7 to check multipart for MIME header overflows */
  3292. boundaries[0] = NULL;
  3293. mci->mci_flags |= MCIF_INHEADER;
  3295. /*
  3296. **  If EF_DONT_MIME is set, we have a broken MIME message
  3297. **  and don't want to generate a new bounce message whose
  3298. **  body propagates the broken MIME.  We can't just not call
  3299. **  mime8to7() as is done above since we need the security
  3300. **  checks.  The best we can do is suppress the errors.
  3301. */
  3303. if (bitset(EF_DONT_MIME, e->e_flags))
  3304. SuprErrs = TRUE;
  3306. (void) mime8to7(mci, e->e_header, e, boundaries,
  3307. M87F_OUTER|M87F_NO8TO7);
  3309. /* restore SuprErrs */
  3310. SuprErrs = oldsuprerrs;
  3311. }
  3312. else
  3313. #endif /* MIME8TO7 */
  3314. {
  3315. int ostate;
  3316. register char *bp;
  3317. register char *pbp;
  3318. register int c;
  3319. register char *xp;
  3320. int padc;
  3321. char *buflim;
  3322. int pos = 0;
  3323. char peekbuf[10];
  3325. if (bitset(MCIF_INHEADER, mci->mci_flags))
  3326. {
  3327. putline("", mci);
  3328. mci->mci_flags &= ~MCIF_INHEADER;
  3329. }
  3331. /* determine end of buffer; allow for short mailer lines */
  3332. buflim = &buf[sizeof buf - 1];
  3333. if (mci->mci_mailer->m_linelimit > 0 &&
  3334.     mci->mci_mailer->m_linelimit < sizeof buf - 1)
  3335. buflim = &buf[mci->mci_mailer->m_linelimit - 1];
  3337. /* copy temp file to output with mapping */
  3338. ostate = OS_HEAD;
  3339. bp = buf;
  3340. pbp = peekbuf;
  3341. while (!ferror(mci->mci_out))
  3342. {
  3343. if (pbp > peekbuf)
  3344. c = *--pbp;
  3345. else if ((c = getc(e->e_dfp)) == EOF)
  3346. break;
  3347. if (bitset(MCIF_7BIT, mci->mci_flags))
  3348. c &= 0x7f;
  3349. switch (ostate)
  3350. {
  3351.   case OS_HEAD:
  3352. #if _FFR_NONULLS
  3353. if (c == '' &&
  3354.     bitnset(M_NONULLS, mci->mci_mailer->m_flags))
  3355. break;
  3356. #endif /* _FFR_NONULLS */
  3357. if (c != 'r' && c != 'n' && bp < buflim)
  3358. {
  3359. *bp++ = c;
  3360. break;
  3361. }
  3363. /* check beginning of line for special cases */
  3364. *bp = '';
  3365. pos = 0;
  3366. padc = EOF;
  3367. if (buf[0] == 'F' &&
  3368.     bitnset(M_ESCFROM, mci->mci_mailer->m_flags) &&
  3369.     strncmp(buf, "From ", 5) == 0)
  3370. {
  3371. padc = '>';
  3372. }
  3373. if (buf[0] == '-' && buf[1] == '-' &&
  3374.     separator != NULL)
  3375. {
  3376. /* possible separator */
  3377. int sl = strlen(separator);
  3379. if (strncmp(&buf[2], separator, sl) == 0)
  3380. padc = ' ';
  3381. }
  3382. if (buf[0] == '.' &&
  3383.     bitnset(M_XDOT, mci->mci_mailer->m_flags))
  3384. {
  3385. padc = '.';
  3386. }
  3388. /* now copy out saved line */
  3389. if (TrafficLogFile != NULL)
  3390. {
  3391. fprintf(TrafficLogFile, "%05d >>> ",
  3392. (int) getpid());
  3393. if (padc != EOF)
  3394. (void) putc(padc,
  3395.     TrafficLogFile);
  3396. for (xp = buf; xp < bp; xp++)
  3397. (void) putc(*xp, TrafficLogFile);
  3398. if (c == 'n')
  3399. (void) fputs(mci->mci_mailer->m_eol,
  3400.       TrafficLogFile);
  3401. }
  3402. if (padc != EOF)
  3403. {
  3404. if (putc(padc, mci->mci_out) == EOF)
  3405. continue;
  3406. pos++;
  3407. }
  3408. for (xp = buf; xp < bp; xp++)
  3409. {
  3410. if (putc(*xp, mci->mci_out) == EOF)
  3411. {
  3412. dead = TRUE;
  3413. break;
  3414. }
  3416. /* record progress for DATA timeout */
  3417. DataProgress = TRUE;
  3418. }
  3419. if (dead)
  3420. continue;
  3421. if (c == 'n')
  3422. {
  3423. if (fputs(mci->mci_mailer->m_eol,
  3424.   mci->mci_out) == EOF)
  3425. break;
  3426. pos = 0;
  3427. }
  3428. else
  3429. {
  3430. pos += bp - buf;
  3431. if (c != 'r')
  3432. *pbp++ = c;
  3433. }
  3435. /* record progress for DATA timeout */
  3436. DataProgress = TRUE;
  3437. bp = buf;
  3439. /* determine next state */
  3440. if (c == 'n')
  3441. ostate = OS_HEAD;
  3442. else if (c == 'r')
  3443. ostate = OS_CR;
  3444. else
  3445. ostate = OS_INLINE;
  3446. continue;
  3448.   case OS_CR:
  3449. if (c == 'n')
  3450. {
  3451. /* got CRLF */
  3452. if (fputs(mci->mci_mailer->m_eol,
  3453.   mci->mci_out) == EOF)
  3454. continue;
  3456. /* record progress for DATA timeout */
  3457. DataProgress = TRUE;
  3459. if (TrafficLogFile != NULL)
  3460. {
  3461. (void) fputs(mci->mci_mailer->m_eol,
  3462.      TrafficLogFile);
  3463. }
  3464. ostate = OS_HEAD;
  3465. continue;
  3466. }
  3468. /* had a naked carriage return */
  3469. *pbp++ = c;
  3470. c = 'r';
  3471. ostate = OS_INLINE;
  3472. goto putch;
  3474.   case OS_INLINE:
  3475. if (c == 'r')
  3476. {
  3477. ostate = OS_CR;
  3478. continue;
  3479. }
  3480. #if _FFR_NONULLS
  3481. if (c == '' &&
  3482.     bitnset(M_NONULLS, mci->mci_mailer->m_flags))
  3483. break;
  3484. #endif /* _FFR_NONULLS */
  3485. putch:
  3486. if (mci->mci_mailer->m_linelimit > 0 &&
  3487.     pos > mci->mci_mailer->m_linelimit &&
  3488.     c != 'n')
  3489. {
  3490. if (putc('!', mci->mci_out) == EOF ||
  3491.     fputs(mci->mci_mailer->m_eol,
  3492.   mci->mci_out) == EOF)
  3493. continue;
  3495. /* record progress for DATA timeout */
  3496. DataProgress = TRUE;
  3498. if (TrafficLogFile != NULL)
  3499. {
  3500. fprintf(TrafficLogFile, "!%s",
  3501. mci->mci_mailer->m_eol);
  3502. }
  3503. ostate = OS_HEAD;
  3504. *pbp++ = c;
  3505. continue;
  3506. }
  3507. if (c == 'n')
  3508. {
  3509. if (TrafficLogFile != NULL)
  3510. (void) fputs(mci->mci_mailer->m_eol,
  3511.       TrafficLogFile);
  3512. if (fputs(mci->mci_mailer->m_eol,
  3513.   mci->mci_out) == EOF)
  3514. continue;
  3515. pos = 0;
  3516. ostate = OS_HEAD;
  3517. }
  3518. else
  3519. {
  3520. if (TrafficLogFile != NULL)
  3521. (void) putc(c, TrafficLogFile);
  3522. if (putc(c, mci->mci_out) == EOF)
  3523. continue;
  3524. pos++;
  3525. ostate = OS_INLINE;
  3526. }
  3528. /* record progress for DATA timeout */
  3529. DataProgress = TRUE;
  3530. break;
  3531. }
  3532. }
  3534. /* make sure we are at the beginning of a line */
  3535. if (bp > buf)
  3536. {
  3537. if (TrafficLogFile != NULL)
  3538. {
  3539. for (xp = buf; xp < bp; xp++)
  3540. (void) putc(*xp, TrafficLogFile);
  3541. }
  3542. for (xp = buf; xp < bp; xp++)
  3543. {
  3544. if (putc(*xp, mci->mci_out) == EOF)
  3545. {
  3546. dead = TRUE;
  3547. break;
  3548. }
  3550. /* record progress for DATA timeout */
  3551. DataProgress = TRUE;
  3552. }
  3553. pos += bp - buf;
  3554. }
  3555. if (!dead && pos > 0)
  3556. {
  3557. if (TrafficLogFile != NULL)
  3558. (void) fputs(mci->mci_mailer->m_eol,
  3559.      TrafficLogFile);
  3560. (void) fputs(mci->mci_mailer->m_eol, mci->mci_out);
  3562. /* record progress for DATA timeout */
  3563. DataProgress = TRUE;
  3564. }
  3565. }
  3567. if (ferror(e->e_dfp))
  3568. {
  3569. syserr("putbody: %s/df%s: read error",
  3570.        qid_printqueue(e->e_queuedir), e->e_id);
  3571. ExitStat = EX_IOERR;
  3572. }
  3574. endofmessage:
  3575. /*
  3576. **  Since mailfile() uses e_dfp in a child process,
  3577. **  the file offset in the stdio library for the
  3578. **  parent process will not agree with the in-kernel
  3579. **  file offset since the file descriptor is shared
  3580. **  between the processes.  Therefore, it is vital
  3581. **  that the file always be rewound.  This forces the
  3582. **  kernel offset (lseek) and stdio library (ftell)
  3583. **  offset to match.
  3584. */
  3586. (void) bfrewind(e->e_dfp);
  3588. /* some mailers want extra blank line at end of message */
  3589. if (bitnset(M_BLANKEND, mci->mci_mailer->m_flags) &&
  3590.     buf[0] != '' && buf[0] != 'n')
  3591. putline("", mci);
  3593. (void) fflush(mci->mci_out);
  3594. if (ferror(mci->mci_out) && errno != EPIPE)
  3595. {
  3596. syserr("putbody: write error");
  3597. ExitStat = EX_IOERR;
  3598. }
  3600. errno = 0;
  3601. }
  3602. /*
  3603. **  MAILFILE -- Send a message to a file.
  3604. **
  3605. ** If the file has the setuid/setgid bits set, but NO execute
  3606. ** bits, sendmail will try to become the owner of that file
  3607. ** rather than the real user.  Obviously, this only works if
  3608. ** sendmail runs as root.
  3609. **
  3610. ** This could be done as a subordinate mailer, except that it
  3611. ** is used implicitly to save messages in ~/dead.letter.  We
  3612. ** view this as being sufficiently important as to include it
  3613. ** here.  For example, if the system is dying, we shouldn't have
  3614. ** to create another process plus some pipes to save the message.
  3615. **
  3616. ** Parameters:
  3617. ** filename -- the name of the file to send to.
  3618. ** mailer -- mailer definition for recipient -- if NULL,
  3619. ** use FileMailer.
  3620. ** ctladdr -- the controlling address header -- includes
  3621. ** the userid/groupid to be when sending.
  3622. ** sfflags -- flags for opening.
  3623. ** e -- the current envelope.
  3624. **
  3625. ** Returns:
  3626. ** The exit code associated with the operation.
  3627. **
  3628. ** Side Effects:
  3629. ** none.
  3630. */
  3632. static jmp_buf CtxMailfileTimeout;
  3634. int
  3635. mailfile(filename, mailer, ctladdr, sfflags, e)
  3636. char *volatile filename;
  3637. MAILER *volatile mailer;
  3638. ADDRESS *ctladdr;
  3639. volatile long sfflags;
  3640. register ENVELOPE *e;
  3641. {
  3642. register FILE *f;
  3643. register pid_t pid = -1;
  3644. volatile int mode;
  3645. int len;
  3646. off_t curoff;
  3647. bool suidwarn = geteuid() == 0;
  3648. char *p;
  3649. char *volatile realfile;
  3650. EVENT *ev;
  3651. char buf[MAXLINE + 1];
  3652. char targetfile[MAXPATHLEN + 1];
  3654. if (tTd(11, 1))
  3655. {
  3656. dprintf("mailfile %sn  ctladdr=", filename);
  3657. printaddr(ctladdr, FALSE);
  3658. }
  3660. if (mailer == NULL)
  3661. mailer = FileMailer;
  3663. if (e->e_xfp != NULL)
  3664. (void) fflush(e->e_xfp);
  3666. /*
  3667. **  Special case /dev/null.  This allows us to restrict file
  3668. **  delivery to regular files only.
  3669. */
  3671. if (strcmp(filename, "/dev/null") == 0)
  3672. return EX_OK;
  3674. /* check for 8-bit available */
  3675. if (bitset(EF_HAS8BIT, e->e_flags) &&
  3676.     bitnset(M_7BITS, mailer->m_flags) &&
  3677.     (bitset(EF_DONT_MIME, e->e_flags) ||
  3678.      !(bitset(MM_MIME8BIT, MimeMode) ||
  3679.        (bitset(EF_IS_MIME, e->e_flags) &&
  3680. bitset(MM_CVTMIME, MimeMode)))))
  3681. {
  3682. e->e_status = "5.6.3";
  3683. usrerrenh(e->e_status,
  3684.        "554 Cannot send 8-bit data to 7-bit destination");
  3685. return EX_DATAERR;
  3686. }
  3688. /* Find the actual file */
  3689. if (SafeFileEnv != NULL && SafeFileEnv[0] != '')
  3690. {
  3691. len = strlen(SafeFileEnv);
  3693. if (strncmp(SafeFileEnv, filename, len) == 0)
  3694. filename += len;
  3696. if (len + strlen(filename) + 1 > MAXPATHLEN)
  3697. {
  3698. syserr("mailfile: filename too long (%s/%s)",
  3699.        SafeFileEnv, filename);
  3700. return EX_CANTCREAT;
  3701. }
  3702. (void) strlcpy(targetfile, SafeFileEnv, sizeof targetfile);
  3703. realfile = targetfile + len;
  3704. if (targetfile[len - 1] != '/')
  3705. (void) strlcat(targetfile, "/", sizeof targetfile);
  3706. if (*filename == '/')
  3707. filename++;
  3708. (void) strlcat(targetfile, filename, sizeof targetfile);
  3709. }
  3710. else if (mailer->m_rootdir != NULL)
  3711. {
  3712. expand(mailer->m_rootdir, targetfile, sizeof targetfile, e);
  3713. len = strlen(targetfile);
  3715. if (strncmp(targetfile, filename, len) == 0)
  3716. filename += len;
  3718. if (len + strlen(filename) + 1 > MAXPATHLEN)
  3719. {
  3720. syserr("mailfile: filename too long (%s/%s)",
  3721.        targetfile, filename);
  3722. return EX_CANTCREAT;
  3723. }
  3724. realfile = targetfile + len;
  3725. if (targetfile[len - 1] != '/')
  3726. (void) strlcat(targetfile, "/", sizeof targetfile);
  3727. if (*filename == '/')
  3728. (void) strlcat(targetfile, filename + 1,
  3729.        sizeof targetfile);
  3730. else
  3731. (void) strlcat(targetfile, filename, sizeof targetfile);
  3732. }
  3733. else
  3734. {
  3735. if (strlen(filename) > MAXPATHLEN)
  3736. {
  3737. syserr("mailfile: filename too long (%s)", filename);
  3738. return EX_CANTCREAT;
  3739. }
  3740. (void) strlcpy(targetfile, filename, sizeof targetfile);
  3741. realfile = targetfile;
  3742. }
  3744. /*
  3745. **  Fork so we can change permissions here.
  3746. ** Note that we MUST use fork, not vfork, because of
  3747. ** the complications of calling subroutines, etc.
  3748. */
  3750. DOFORK(fork);
  3752. if (pid < 0)
  3753. return EX_OSERR;
  3754. else if (pid == 0)
  3755. {
  3756. /* child -- actually write to file */
  3757. struct stat stb;
  3758. MCI mcibuf;
  3759. int err;
  3760. volatile int oflags = O_WRONLY|O_APPEND;
  3762. if (e->e_lockfp != NULL)
  3763. (void) close(fileno(e->e_lockfp));
  3765. (void) setsignal(SIGINT, SIG_DFL);
  3766. (void) setsignal(SIGHUP, SIG_DFL);
  3767. (void) setsignal(SIGTERM, SIG_DFL);
  3768. (void) umask(OldUmask);
  3769. e->e_to = filename;
  3770. ExitStat = EX_OK;
  3772. if (setjmp(CtxMailfileTimeout) != 0)
  3773. {
  3774. exit(EX_TEMPFAIL);
  3775. }
  3777. if (TimeOuts.to_fileopen > 0)
  3778. ev = setevent(TimeOuts.to_fileopen, mailfiletimeout, 0);
  3779. else
  3780. ev = NULL;
  3782. /* check file mode to see if setuid */
  3783. if (stat(targetfile, &stb) < 0)
  3784. mode = FileMode;
  3785. else
  3786. mode = stb.st_mode;
  3788. /* limit the errors to those actually caused in the child */
  3789. errno = 0;
  3790. ExitStat = EX_OK;
  3792. if (ctladdr != NULL || bitset(SFF_RUNASREALUID, sfflags))
  3793. {
  3794. /* ignore setuid and setgid bits */
  3795. mode &= ~(S_ISGID|S_ISUID);
  3796. }
  3798. /* we have to open the dfile BEFORE setuid */
  3799. if (e->e_dfp == NULL && bitset(EF_HAS_DF, e->e_flags))
  3800. {
  3801. char *df = queuename(e, 'd');
  3803. e->e_dfp = fopen(df, "r");
  3804. if (e->e_dfp == NULL)
  3805. {
  3806. syserr("mailfile: Cannot open %s for %s from %s",
  3807. df, e->e_to, e->e_from.q_paddr);
  3808. }
  3809. }
  3811. /* select a new user to run as */
  3812. if (!bitset(SFF_RUNASREALUID, sfflags))
  3813. {
  3814. if (bitnset(M_SPECIFIC_UID, mailer->m_flags))
  3815. {
  3816. RealUserName = NULL;
  3817. RealUid = mailer->m_uid;
  3818. }
  3819. else if (bitset(S_ISUID, mode))
  3820. {
  3821. RealUserName = NULL;
  3822. RealUid = stb.st_uid;
  3823. }
  3824. else if (ctladdr != NULL && ctladdr->q_uid != 0)
  3825. {
  3826. if (ctladdr->q_ruser != NULL)
  3827. RealUserName = ctladdr->q_ruser;
  3828. else
  3829. RealUserName = ctladdr->q_user;
  3830. RealUid = ctladdr->q_uid;
  3831. }
  3832. else if (mailer != NULL && mailer->m_uid != 0)
  3833. {
  3834. RealUserName = DefUser;
  3835. RealUid = mailer->m_uid;
  3836. }
  3837. else
  3838. {
  3839. RealUserName = DefUser;
  3840. RealUid = DefUid;
  3841. }
  3843. /* select a new group to run as */
  3844. if (bitnset(M_SPECIFIC_UID, mailer->m_flags))
  3845. RealGid = mailer->m_gid;
  3846. else if (bitset(S_ISGID, mode))
  3847. RealGid = stb.st_gid;
  3848. else if (ctladdr != NULL && ctladdr->q_uid != 0)
  3849. RealGid = ctladdr->q_gid;
  3850. else if (ctladdr != NULL &&
  3851.  ctladdr->q_uid == DefUid &&
  3852.  ctladdr->q_gid == 0)
  3853. RealGid = DefGid;
  3854. else if (mailer != NULL && mailer->m_gid != 0)
  3855. RealGid = mailer->m_gid;
  3856. else
  3857. RealGid = DefGid;
  3858. }
  3860. /* last ditch */
  3861. if (!bitset(SFF_ROOTOK, sfflags))
  3862. {
  3863. if (RealUid == 0)
  3864. RealUid = DefUid;
  3865. if (RealGid == 0)
  3866. RealGid = DefGid;
  3867. }
  3869. /* set group id list (needs /etc/group access) */
  3870. if (RealUserName != NULL && !DontInitGroups)
  3871. {
  3872. if (initgroups(RealUserName, RealGid) == -1 && suidwarn)
  3873. syserr("mailfile: initgroups(%s, %d) failed",
  3874. RealUserName, RealGid);
  3875. }
  3876. else
  3877. {
  3878. GIDSET_T gidset[1];
  3880. gidset[0] = RealGid;
  3881. if (setgroups(1, gidset) == -1 && suidwarn)
  3882. syserr("mailfile: setgroups() failed");
  3883. }
  3885. /*
  3886. **  If you have a safe environment, go into it.
  3887. */
  3889. if (realfile != targetfile)
  3890. {
  3891. *realfile = '';
  3892. if (tTd(11, 20))
  3893. dprintf("mailfile: chroot %sn", targetfile);
  3894. if (chroot(targetfile) < 0)
  3895. {
  3896. syserr("mailfile: Cannot chroot(%s)",
  3897.        targetfile);
  3898. exit(EX_CANTCREAT);
  3899. }
  3900. *realfile = '/';
  3901. }
  3903. if (tTd(11, 40))
  3904. dprintf("mailfile: deliver to %sn", realfile);
  3906. if (chdir("/") < 0)
  3907. syserr("mailfile: cannot chdir(/)");
  3909. /* now reset the group and user ids */
  3910. endpwent();
  3911. if (setgid(RealGid) < 0 && suidwarn)
  3912. syserr("mailfile: setgid(%ld) failed", (long) RealGid);
  3913. vendor_set_uid(RealUid);
  3914. if (setuid(RealUid) < 0 && suidwarn)
  3915. syserr("mailfile: setuid(%ld) failed", (long) RealUid);
  3917. if (tTd(11, 2))
  3918. dprintf("mailfile: running as r/euid=%d/%d, r/egid=%d/%dn",
  3919. (int) getuid(), (int) geteuid(),
  3920. (int) getgid(), (int) getegid());
  3923. /* move into some "safe" directory */
  3924. if (mailer->m_execdir != NULL)
  3925. {
  3926. char *q;
  3928. for (p = mailer->m_execdir; p != NULL; p = q)
  3929. {
  3930. q = strchr(p, ':');
  3931. if (q != NULL)
  3932. *q = '';
  3933. expand(p, buf, sizeof buf, e);
  3934. if (q != NULL)
  3935. *q++ = ':';
  3936. if (tTd(11, 20))
  3937. dprintf("mailfile: trydir %sn", buf);
  3938. if (buf[0] != '' && chdir(buf) >= 0)
  3939. break;
  3940. }
  3941. }
  3943. /*
  3944. **  Recheck the file after we have assumed the ID of the
  3945. **  delivery user to make sure we can deliver to it as
  3946. **  that user.  This is necessary if sendmail is running
  3947. **  as root and the file is on an NFS mount which treats
  3948. **  root as nobody.
  3949. */
  3951. #if HASLSTAT
  3952. if (bitnset(DBS_FILEDELIVERYTOSYMLINK, DontBlameSendmail))
  3953. err = stat(realfile, &stb);
  3954. else
  3955. err = lstat(realfile, &stb);
  3956. #else /* HASLSTAT */
  3957. err = stat(realfile, &stb);
  3958. #endif /* HASLSTAT */
  3960. if (err < 0)
  3961. {
  3962. stb.st_mode = ST_MODE_NOFILE;
  3963. mode = FileMode;
  3964. oflags |= O_CREAT|O_EXCL;
  3965. }
  3966. else if (bitset(S_IXUSR|S_IXGRP|S_IXOTH, mode) ||
  3967.  (!bitnset(DBS_FILEDELIVERYTOHARDLINK,
  3968.    DontBlameSendmail) &&
  3969.   stb.st_nlink != 1) ||
  3970.  (realfile != targetfile && !S_ISREG(mode)))
  3971. exit(EX_CANTCREAT);
  3972. else
  3973. mode = stb.st_mode;
  3975. if (!bitnset(DBS_FILEDELIVERYTOSYMLINK, DontBlameSendmail))
  3976. sfflags |= SFF_NOSLINK;
  3977. if (!bitnset(DBS_FILEDELIVERYTOHARDLINK, DontBlameSendmail))
  3978. sfflags |= SFF_NOHLINK;
  3979. sfflags &= ~SFF_OPENASROOT;
  3980. f = safefopen(realfile, oflags, mode, sfflags);
  3981. if (f == NULL)
  3982. {
  3983. if (transienterror(errno))
  3984. {
  3985. usrerr("454 4.3.0 cannot open %s: %s",
  3986.        shortenstring(realfile, MAXSHORTSTR),
  3987.        errstring(errno));
  3988. exit(EX_TEMPFAIL);
  3989. }
  3990. else
  3991. {
  3992. usrerr("554 5.3.0 cannot open %s: %s",
  3993.        shortenstring(realfile, MAXSHORTSTR),
  3994.        errstring(errno));
  3995. exit(EX_CANTCREAT);
  3996. }
  3997. }
  3998. if (filechanged(realfile, fileno(f), &stb))
  3999. {
  4000. syserr("554 5.3.0 file changed after open");
  4001. exit(EX_CANTCREAT);
  4002. }
  4003. if (fstat(fileno(f), &stb) < 0)
  4004. {
  4005. syserr("554 5.3.0 cannot fstat %s", errstring(errno));
  4006. exit(EX_CANTCREAT);
  4007. }
  4009. curoff = stb.st_size;
  4011. if (ev != NULL)
  4012. clrevent(ev);
  4014. memset(&mcibuf, '', sizeof mcibuf);
  4015. mcibuf.mci_mailer = mailer;
  4016. mcibuf.mci_out = f;
  4017. if (bitnset(M_7BITS, mailer->m_flags))
  4018. mcibuf.mci_flags |= MCIF_7BIT;
  4020. /* clear out per-message flags from connection structure */
  4021. mcibuf.mci_flags &= ~(MCIF_CVT7TO8|MCIF_CVT8TO7);
  4023. if (bitset(EF_HAS8BIT, e->e_flags) &&
  4024.     !bitset(EF_DONT_MIME, e->e_flags) &&
  4025.     bitnset(M_7BITS, mailer->m_flags))
  4026. mcibuf.mci_flags |= MCIF_CVT8TO7;
  4028. #if MIME7TO8
  4029. if (bitnset(M_MAKE8BIT, mailer->m_flags) &&
  4030.     !bitset(MCIF_7BIT, mcibuf.mci_flags) &&
  4031.     (p = hvalue("Content-Transfer-Encoding", e->e_header)) != NULL &&
  4032.     (strcasecmp(p, "quoted-printable") == 0 ||
  4033.      strcasecmp(p, "base64") == 0) &&
  4034.     (p = hvalue("Content-Type", e->e_header)) != NULL)
  4035. {
  4036. /* may want to convert 7 -> 8 */
  4037. /* XXX should really parse it here -- and use a class XXX */
  4038. if (strncasecmp(p, "text/plain", 10) == 0 &&
  4039.     (p[10] == '' || p[10] == ' ' || p[10] == ';'))
  4040. mcibuf.mci_flags |= MCIF_CVT7TO8;
  4041. }
  4042. #endif /* MIME7TO8 */
  4044. putfromline(&mcibuf, e);
  4045. (*e->e_puthdr)(&mcibuf, e->e_header, e, M87F_OUTER);
  4046. (*e->e_putbody)(&mcibuf, e, NULL);
  4047. putline("n", &mcibuf);
  4048. if (fflush(f) < 0 ||
  4049.     (SuperSafe && fsync(fileno(f)) < 0) ||
  4050.     ferror(f))
  4051. {
  4052. setstat(EX_IOERR);
  4053. #if !NOFTRUNCATE
  4054. (void) ftruncate(fileno(f), curoff);
  4055. #endif /* !NOFTRUNCATE */
  4056. }
  4058. /* reset ISUID & ISGID bits for paranoid systems */
  4059. #if HASFCHMOD
  4060. (void) fchmod(fileno(f), (MODE_T) mode);
  4061. #else /* HASFCHMOD */
  4062. (void) chmod(filename, (MODE_T) mode);
  4063. #endif /* HASFCHMOD */
  4064. if (fclose(f) < 0)
  4065. setstat(EX_IOERR);
  4066. (void) fflush(stdout);
  4067. (void) setuid(RealUid);
  4068. exit(ExitStat);
  4069. /* NOTREACHED */
  4070. }
  4071. else
  4072. {
  4073. /* parent -- wait for exit status */
  4074. int st;
  4076. st = waitfor(pid);
  4077. if (st == -1)
  4078. {
  4079. syserr("mailfile: %s: wait", mailer->m_name);
  4080. return EX_SOFTWARE;
  4081. }
  4082. if (WIFEXITED(st))
  4083. return (WEXITSTATUS(st));
  4084. else
  4085. {
  4086. syserr("mailfile: %s: child died on signal %d",
  4087.        mailer->m_name, st);
  4088. return EX_UNAVAILABLE;
  4089. }
  4090. /* NOTREACHED */
  4091. }
  4092. return EX_UNAVAILABLE; /* avoid compiler warning on IRIX */
  4093. }
  4095. static void
  4096. mailfiletimeout()
  4097. {
  4098. longjmp(CtxMailfileTimeout, 1);
  4099. }
  4100. /*
  4101. **  HOSTSIGNATURE -- return the "signature" for a host.
  4102. **
  4103. ** The signature describes how we are going to send this -- it
  4104. ** can be just the hostname (for non-Internet hosts) or can be
  4105. ** an ordered list of MX hosts.
  4106. **
  4107. ** Parameters:
  4108. ** m -- the mailer describing this host.
  4109. ** host -- the host name.
  4110. **
  4111. ** Returns:
  4112. ** The signature for this host.
  4113. **
  4114. ** Side Effects:
  4115. ** Can tweak the symbol table.
  4116. */
  4117. #define MAXHOSTSIGNATURE 8192 /* max len of hostsignature */
  4119. static char *
  4120. hostsignature(m, host)
  4121. register MAILER *m;
  4122. char *host;
  4123. {
  4124. register char *p;
  4125. register STAB *s;
  4126. #if NAMED_BIND
  4127. char sep = ':';
  4128. char prevsep = ':';
  4129. int i;
  4130. int len;
  4131. int nmx;
  4132. int hl;
  4133. char *hp;
  4134. char *endp;
  4135. int oldoptions = _res.options;
  4136. char *mxhosts[MAXMXHOSTS + 1];
  4137. u_short mxprefs[MAXMXHOSTS + 1];
  4138. #endif /* NAMED_BIND */
  4140. if (tTd(17, 3))
  4141. dprintf("hostsignature(%s)n", host);
  4143. /*
  4144. **  If local delivery, just return a constant.
  4145. */
  4147. if (bitnset(M_LOCALMAILER, m->m_flags))
  4148. return "localhost";
  4150. /*
  4151. **  Check to see if this uses IPC -- if not, it can't have MX records.
  4152. */
  4154. p = m->m_mailer;
  4155. if (strcmp(p, "[IPC]") != 0 &&
  4156.     strcmp(p, "[TCP]") != 0)
  4157. {
  4158. /* just an ordinary mailer */
  4159. return host;
  4160. }
  4161. #if NETUNIX
  4162. else
  4163. {
  4164. if (m->m_argv[0] != NULL &&
  4165.     strcmp(m->m_argv[0], "FILE") == 0)
  4166. {
  4167. /* rendezvous in the file system, no MX records */
  4168. return host;
  4169. }
  4170. }
  4171. #endif /* NETUNIX */
  4173. /*
  4174. **  Look it up in the symbol table.
  4175. */
  4177. s = stab(host, ST_HOSTSIG, ST_ENTER);
  4178. if (s->s_hostsig != NULL)
  4179. {
  4180. if (tTd(17, 3))
  4181. dprintf("hostsignature(): stab(%s) found %sn", host,
  4182. s->s_hostsig);
  4183. return s->s_hostsig;
  4184. }
  4186. /*
  4187. **  Not already there -- create a signature.
  4188. */
  4190. #if NAMED_BIND
  4191. if (ConfigLevel < 2)
  4192. _res.options &= ~(RES_DEFNAMES | RES_DNSRCH); /* XXX */
  4194. for (hp = host; hp != NULL; hp = endp)
  4195. {
  4196. #if NETINET6
  4197. if (*hp == '[')
  4198. {
  4199. endp = strchr(hp + 1, ']');
  4200. if (endp != NULL)
  4201. endp = strpbrk(endp + 1, ":,");
  4202. }
  4203. else
  4204. endp = strpbrk(hp, ":,");
  4205. #else /* NETINET6 */
  4206. endp = strpbrk(hp, ":,");
  4207. #endif /* NETINET6 */
  4208. if (endp != NULL)
  4209. {
  4210. sep = *endp;
  4211. *endp = '';
  4212. }
  4214. if (bitnset(M_NOMX, m->m_flags))
  4215. {
  4216. /* skip MX lookups */
  4217. nmx = 1;
  4218. mxhosts[0] = hp;
  4219. }
  4220. else
  4221. {
  4222. auto int rcode;
  4224. nmx = getmxrr(hp, mxhosts, mxprefs, TRUE, &rcode);
  4225. if (nmx <= 0)
  4226. {
  4227. register MCI *mci;
  4229. /* update the connection info for this host */
  4230. mci = mci_get(hp, m);
  4231. mci->mci_errno = errno;
  4232. mci->mci_herrno = h_errno;
  4233. mci->mci_lastuse = curtime();
  4234. if (rcode == EX_NOHOST)
  4235. mci_setstat(mci, rcode, "5.1.2",
  4236. "550 Host unknown");
  4237. else
  4238. mci_setstat(mci, rcode, NULL, NULL);
  4240. /* use the original host name as signature */
  4241. nmx = 1;
  4242. mxhosts[0] = hp;
  4243. }
  4244. if (tTd(17, 3))
  4245. dprintf("hostsignature(): getmxrr() returned %d, mxhosts[0]=%sn",
  4246. nmx, mxhosts[0]);
  4247. }
  4249. len = 0;
  4250. for (i = 0; i < nmx; i++)
  4251. len += strlen(mxhosts[i]) + 1;
  4252. if (s->s_hostsig != NULL)
  4253. len += strlen(s->s_hostsig) + 1;
  4254. if (len >= MAXHOSTSIGNATURE)
  4255. {
  4256. sm_syslog(LOG_WARNING, NOQID, "hostsignature for host '%s' exceeds maxlen (%d): %d",
  4257.   host, MAXHOSTSIGNATURE, len);
  4258. len = MAXHOSTSIGNATURE;
  4259. }
  4260. p = xalloc(len);
  4261. if (s->s_hostsig != NULL)
  4262. {
  4263. (void) strlcpy(p, s->s_hostsig, len);
  4264. free(s->s_hostsig);
  4265. s->s_hostsig = p;
  4266. hl = strlen(p);
  4267. p += hl;
  4268. *p++ = prevsep;
  4269. len -= hl + 1;
  4270. }
  4271. else
  4272. s->s_hostsig = p;
  4273. for (i = 0; i < nmx; i++)
  4274. {
  4275. hl = strlen(mxhosts[i]);
  4276. if (len - 1 < hl || len <= 1)
  4277. {
  4278. /* force to drop out of outer loop */
  4279. len = -1;
  4280. break;
  4281. }
  4282. if (i != 0)
  4283. {
  4284. if (mxprefs[i] == mxprefs[i - 1])
  4285. *p++ = ',';
  4286. else
  4287. *p++ = ':';
  4288. len--;
  4289. }
  4290. (void) strlcpy(p, mxhosts[i], len);
  4291. p += hl;
  4292. len -= hl;
  4293. }
  4295. /*
  4296. **  break out of loop if len exceeded MAXHOSTSIGNATURE
  4297. **  because we won't have more space for further hosts
  4298. **  anyway (separated by : in the .cf file).
  4299. */
  4301. if (len < 0)
  4302. break;
  4303. if (endp != NULL)
  4304. *endp++ = sep;
  4305. prevsep = sep;
  4306. }
  4307. makelower(s->s_hostsig);
  4308. if (ConfigLevel < 2)
  4309. _res.options = oldoptions;
  4310. #else /* NAMED_BIND */
  4311. /* not using BIND -- the signature is just the host name */
  4312. s->s_hostsig = host;
  4313. #endif /* NAMED_BIND */
  4314. if (tTd(17, 1))
  4315. dprintf("hostsignature(%s) = %sn", host, s->s_hostsig);
  4316. return s->s_hostsig;
  4317. }
  4318. /*
  4319. **  PARSE_HOSTSIGNATURE -- parse the "signature" and return MX host array.
  4320. **
  4321. ** The signature describes how we are going to send this -- it
  4322. ** can be just the hostname (for non-Internet hosts) or can be
  4323. ** an ordered list of MX hosts which must be randomized for equal
  4324. ** MX preference values.
  4325. **
  4326. ** Parameters:
  4327. ** sig -- the host signature.
  4328. ** mxhosts -- array to populate.
  4329. **
  4330. ** Returns:
  4331. ** The number of hosts inserted into mxhosts array.
  4332. **
  4333. ** Side Effects:
  4334. ** Randomizes equal MX preference hosts in mxhosts.
  4335. */
  4337. static int
  4338. parse_hostsignature(sig, mxhosts, mailer)
  4339. char *sig;
  4340. char **mxhosts;
  4341. MAILER *mailer;
  4342. {
  4343. int nmx = 0;
  4344. int curpref = 0;
  4345. int i, j;
  4346. char *hp, *endp;
  4347. u_short prefer[MAXMXHOSTS];
  4348. long rndm[MAXMXHOSTS];
  4350. for (hp = sig; hp != NULL; hp = endp)
  4351. {
  4352. char sep = ':';
  4354. #if NETINET6
  4355. if (*hp == '[')
  4356. {
  4357. endp = strchr(hp + 1, ']');
  4358. if (endp != NULL)
  4359. endp = strpbrk(endp + 1, ":,");
  4360. }
  4361. else
  4362. endp = strpbrk(hp, ":,");
  4363. #else /* NETINET6 */
  4364. endp = strpbrk(hp, ":,");
  4365. #endif /* NETINET6 */
  4366. if (endp != NULL)
  4367. {
  4368. sep = *endp;
  4369. *endp = '';
  4370. }
  4372. mxhosts[nmx] = hp;
  4373. prefer[nmx] = curpref;
  4374. if (mci_match(hp, mailer))
  4375. rndm[nmx] = 0;
  4376. else
  4377. rndm[nmx] = get_random();
  4379. if (endp != NULL)
  4380. {
  4381. /*
  4382. **  Since we don't have the original MX prefs,
  4383. **  make our own.  If the separator is a ':', that
  4384. **  means the preference for the next host will be
  4385. **  higher than this one, so simply increment curpref.
  4386. */
  4388. if (sep == ':')
  4389. curpref++;
  4391. *endp++ = sep;
  4392. }
  4393. if (++nmx >= MAXMXHOSTS)
  4394. break;
  4395. }
  4397. /* sort the records using the random factor for equal preferences */
  4398. for (i = 0; i < nmx; i++)
  4399. {
  4400. for (j = i + 1; j < nmx; j++)
  4401. {
  4402. /*
  4403. **  List is already sorted by MX preference, only
  4404. **  need to look for equal preference MX records
  4405. */
  4407. if (prefer[i] < prefer[j])
  4408. break;
  4410. if (prefer[i] > prefer[j] ||
  4411.     (prefer[i] == prefer[j] && rndm[i] > rndm[j]))
  4412. {
  4413. register u_short tempp;
  4414. register long tempr;
  4415. register char *temp1;
  4417. tempp = prefer[i];
  4418. prefer[i] = prefer[j];
  4419. prefer[j] = tempp;
  4420. temp1 = mxhosts[i];
  4421. mxhosts[i] = mxhosts[j];
  4422. mxhosts[j] = temp1;
  4423. tempr = rndm[i];
  4424. rndm[i] = rndm[j];
  4425. rndm[j] = tempr;
  4426. }
  4427. }
  4428. }
  4429. return nmx;
  4430. }
  4432. #if SMTP
  4433. #endif /* SMTP */