2 * Copyright (c) 1998-2007 Sendmail, Inc. and its suppliers.
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.
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.
17 SM_RCSID("@(#)$Id: deliver.c,v 8.1012 2007/03/29 21:20:15 ca Exp $")
20 # include <login_cap.h>
21 #endif /* HASSETUSERCONTEXT */
23 #if NETINET || NETINET6
24 # include <arpa/inet.h>
25 #endif /* NETINET || NETINET6 */
29 #endif /* STARTTLS || SASL */
31 static int deliver __P((ENVELOPE *, ADDRESS *));
32 static void dup_queue_file __P((ENVELOPE *, ENVELOPE *, int));
33 static void mailfiletimeout __P((int));
34 static void endwaittimeout __P((int));
35 static int parse_hostsignature __P((char *, char **, MAILER *));
36 static void sendenvelope __P((ENVELOPE *, int));
37 static int coloncmp __P((const char *, const char *));
40 static int starttls __P((MAILER *, MCI *, ENVELOPE *));
41 static int endtlsclt __P((MCI *));
44 static bool iscltflgset __P((ENVELOPE *, int));
45 # endif /* STARTTLS || SASL */
48 ** SENDALL -- actually send all the messages.
51 ** e -- the envelope to send.
52 ** mode -- the delivery mode to use. If SM_DEFAULT, use
53 ** the current e->e_sendmode.
59 ** Scans the send lists and sends everything it finds.
60 ** Delivers any appropriate error messages.
61 ** If we are running in a non-interactive mode, takes the
62 ** appropriate action.
74 register ENVELOPE *ee;
75 ENVELOPE *splitenv = NULL;
76 int oldverbose = Verbose;
77 bool somedeliveries = false, expensive = false;
81 ** If this message is to be discarded, don't bother sending
82 ** the message at all.
85 if (bitset(EF_DISCARD, e->e_flags))
88 sm_dprintf("sendall: discarding id %s\n", e->e_id);
89 e->e_flags |= EF_CLRQUEUE;
91 logundelrcpts(e, "discarded", 9, true);
92 else if (LogLevel > 4)
93 sm_syslog(LOG_INFO, e->e_id, "discarded");
94 markstats(e, NULL, STATS_REJECT);
99 ** If we have had global, fatal errors, don't bother sending
100 ** the message at all if we are in SMTP mode. Local errors
101 ** (e.g., a single address failing) will still cause the other
102 ** addresses to be sent.
105 if (bitset(EF_FATALERRS, e->e_flags) &&
106 (OpMode == MD_SMTP || OpMode == MD_DAEMON))
108 e->e_flags |= EF_CLRQUEUE;
112 /* determine actual delivery mode */
113 if (mode == SM_DEFAULT)
115 mode = e->e_sendmode;
116 if (mode != SM_VERIFY && mode != SM_DEFER &&
117 shouldqueue(e->e_msgpriority, e->e_ctime))
123 sm_dprintf("\n===== SENDALL: mode %c, id %s, e_from ",
125 printaddr(sm_debug_file(), &e->e_from, false);
126 sm_dprintf("\te_flags = ");
128 sm_dprintf("sendqueue:\n");
129 printaddr(sm_debug_file(), e->e_sendqueue, true);
133 ** Do any preprocessing necessary for the mode we are running.
134 ** Check to make sure the hop count is reasonable.
135 ** Delete sends to the sender in mailing lists.
142 if (e->e_hopcount > MaxHopCount)
146 if (e->e_sendqueue != NULL &&
147 e->e_sendqueue->q_paddr != NULL)
148 recip = e->e_sendqueue->q_paddr;
153 queueup(e, WILL_BE_QUEUED(mode), false);
154 e->e_flags |= EF_FATALERRS|EF_PM_NOTIFY|EF_CLRQUEUE;
155 ExitStat = EX_UNAVAILABLE;
156 syserr("554 5.4.6 Too many hops %d (%d max): from %s via %s, to %s",
157 e->e_hopcount, MaxHopCount, e->e_from.q_paddr,
158 RealHostName == NULL ? "localhost" : RealHostName,
160 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
162 if (QS_IS_DEAD(q->q_state))
164 q->q_state = QS_BADADDR;
165 q->q_status = "5.4.6";
166 q->q_rstatus = "554 5.4.6 Too many hops";
172 ** Do sender deletion.
174 ** If the sender should be queued up, skip this.
175 ** This can happen if the name server is hosed when you
176 ** are trying to send mail. The result is that the sender
177 ** is instantiated in the queue as a recipient.
180 if (!bitset(EF_METOO, e->e_flags) &&
181 !QS_IS_QUEUEUP(e->e_from.q_state))
185 sm_dprintf("sendall: QS_SENDER ");
186 printaddr(sm_debug_file(), &e->e_from, false);
188 e->e_from.q_state = QS_SENDER;
189 (void) recipient(&e->e_from, &e->e_sendqueue, 0, e);
193 ** Handle alias owners.
195 ** We scan up the q_alias chain looking for owners.
196 ** We discard owners that are the same as the return path.
199 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
201 register struct address *a;
203 for (a = q; a != NULL && a->q_owner == NULL; a = a->q_alias)
206 q->q_owner = a->q_owner;
208 if (q->q_owner != NULL &&
209 !QS_IS_DEAD(q->q_state) &&
210 strcmp(q->q_owner, e->e_from.q_paddr) == 0)
216 sm_dprintf("\nAfter first owner pass, sendq =\n");
217 printaddr(sm_debug_file(), e->e_sendqueue, true);
222 while (owner != NULL && otherowners > 0)
225 sm_dprintf("owner = \"%s\", otherowners = %d\n",
228 otherowners = bitset(EF_SENDRECEIPT, e->e_flags) ? 1 : 0;
230 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
234 sm_dprintf("Checking ");
235 printaddr(sm_debug_file(), q, false);
237 if (QS_IS_DEAD(q->q_state))
240 sm_dprintf(" ... QS_IS_DEAD\n");
243 if (tTd(13, 29) && !tTd(13, 30))
245 sm_dprintf("Checking ");
246 printaddr(sm_debug_file(), q, false);
249 if (q->q_owner != NULL)
254 sm_dprintf(" ... First owner = \"%s\"\n",
258 else if (owner != q->q_owner)
260 if (strcmp(owner, q->q_owner) == 0)
263 sm_dprintf(" ... Same owner = \"%s\"\n",
266 /* make future comparisons cheap */
272 sm_dprintf(" ... Another owner \"%s\"\n",
278 else if (tTd(13, 40))
279 sm_dprintf(" ... Same owner = \"%s\"\n",
285 sm_dprintf(" ... Null owner\n");
289 if (QS_IS_BADADDR(q->q_state))
292 sm_dprintf(" ... QS_IS_BADADDR\n");
296 if (QS_IS_QUEUEUP(q->q_state))
298 MAILER *m = q->q_mailer;
301 ** If we have temporary address failures
302 ** (e.g., dns failure) and a fallback MX is
303 ** set, send directly to the fallback MX host.
306 if (FallbackMX != NULL &&
307 !wordinclass(FallbackMX, 'w') &&
309 !bitnset(M_NOMX, m->m_flags) &&
310 strcmp(m->m_mailer, "[IPC]") == 0 &&
311 m->m_argv[0] != NULL &&
312 strcmp(m->m_argv[0], "TCP") == 0)
318 sm_dprintf(" ... FallbackMX\n");
320 len = strlen(FallbackMX) + 1;
321 p = sm_rpool_malloc_x(e->e_rpool, len);
322 (void) sm_strlcpy(p, FallbackMX, len);
329 sm_dprintf(" ... QS_IS_QUEUEUP\n");
335 ** If this mailer is expensive, and if we don't
336 ** want to make connections now, just mark these
337 ** addresses and return. This is useful if we
338 ** want to batch connections to reduce load. This
339 ** will cause the messages to be queued up, and a
340 ** daemon will come along to send the messages later.
343 if (NoConnect && !Verbose &&
344 bitnset(M_EXPENSIVE, q->q_mailer->m_flags))
347 sm_dprintf(" ... expensive\n");
348 q->q_state = QS_QUEUEUP;
351 else if (bitnset(M_HOLD, q->q_mailer->m_flags) &&
352 QueueLimitId == NULL &&
353 QueueLimitSender == NULL &&
354 QueueLimitRecipient == NULL)
357 sm_dprintf(" ... hold\n");
358 q->q_state = QS_QUEUEUP;
361 else if (QueueMode != QM_QUARANTINE &&
362 e->e_quarmsg != NULL)
365 sm_dprintf(" ... quarantine: %s\n",
367 q->q_state = QS_QUEUEUP;
373 sm_dprintf(" ... deliverable\n");
374 somedeliveries = true;
378 if (owner != NULL && otherowners > 0)
381 ** Split this envelope into two.
384 ee = (ENVELOPE *) sm_rpool_malloc_x(e->e_rpool,
387 ee->e_message = NULL;
392 sm_dprintf("sendall: split %s into %s, owner = \"%s\", otherowners = %d\n",
393 e->e_id, ee->e_id, owner,
396 ee->e_header = copyheader(e->e_header, ee->e_rpool);
397 ee->e_sendqueue = copyqueue(e->e_sendqueue,
399 ee->e_errorqueue = copyqueue(e->e_errorqueue,
401 ee->e_flags = e->e_flags & ~(EF_INQUEUE|EF_CLRQUEUE|EF_FATALERRS|EF_SENDRECEIPT|EF_RET_PARAM);
402 ee->e_flags |= EF_NORECEIPT;
403 setsender(owner, ee, NULL, '\0', true);
406 sm_dprintf("sendall(split): QS_SENDER ");
407 printaddr(sm_debug_file(), &ee->e_from, false);
409 ee->e_from.q_state = QS_SENDER;
413 ee->e_qgrp = e->e_qgrp;
414 ee->e_qdir = e->e_qdir;
415 ee->e_errormode = EM_MAIL;
416 ee->e_sibling = splitenv;
417 ee->e_statmsg = NULL;
418 if (e->e_quarmsg != NULL)
419 ee->e_quarmsg = sm_rpool_strdup_x(ee->e_rpool,
423 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
425 if (q->q_owner == owner)
427 q->q_state = QS_CLONED;
429 sm_dprintf("\t... stripping %s from original envelope\n",
433 for (q = ee->e_sendqueue; q != NULL; q = q->q_next)
435 if (q->q_owner != owner)
437 q->q_state = QS_CLONED;
439 sm_dprintf("\t... dropping %s from cloned envelope\n",
444 /* clear DSN parameters */
445 q->q_flags &= ~(QHASNOTIFY|Q_PINGFLAGS);
446 q->q_flags |= DefaultNotify & ~QPINGONSUCCESS;
448 sm_dprintf("\t... moving %s to cloned envelope\n",
453 if (mode != SM_VERIFY && bitset(EF_HAS_DF, e->e_flags))
454 dup_queue_file(e, ee, DATAFL_LETTER);
457 ** Give the split envelope access to the parent
458 ** transcript file for errors obtained while
459 ** processing the recipients (done before the
460 ** envelope splitting).
463 if (e->e_xfp != NULL)
464 ee->e_xfp = sm_io_dup(e->e_xfp);
466 /* failed to dup e->e_xfp, start a new transcript */
467 if (ee->e_xfp == NULL)
470 if (mode != SM_VERIFY && LogLevel > 4)
471 sm_syslog(LOG_INFO, e->e_id,
472 "%s: clone: owner=%s",
479 setsender(owner, e, NULL, '\0', true);
482 sm_dprintf("sendall(owner): QS_SENDER ");
483 printaddr(sm_debug_file(), &e->e_from, false);
485 e->e_from.q_state = QS_SENDER;
486 e->e_errormode = EM_MAIL;
487 e->e_flags |= EF_NORECEIPT;
488 e->e_flags &= ~EF_FATALERRS;
491 /* if nothing to be delivered, just queue up everything */
492 if (!somedeliveries && !WILL_BE_QUEUED(mode) &&
498 sm_dprintf("No deliveries: auto-queuing\n");
502 /* treat this as a delivery in terms of counting tries */
506 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
514 if ((WILL_BE_QUEUED(mode) || mode == SM_FORK ||
515 (mode != SM_VERIFY &&
516 (SuperSafe == SAFE_REALLY ||
517 SuperSafe == SAFE_REALLY_POSTMILTER))) &&
518 (!bitset(EF_INQUEUE, e->e_flags) || splitenv != NULL))
523 ** Be sure everything is instantiated in the queue.
524 ** Split envelopes first in case the machine crashes.
525 ** If the original were done first, we may lose
531 #else /* !HASFLOCK */
532 msync = mode == SM_FORK;
533 #endif /* !HASFLOCK */
535 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
536 queueup(ee, WILL_BE_QUEUED(mode), msync);
537 queueup(e, WILL_BE_QUEUED(mode), msync);
541 checkfds("after envelope splitting");
544 ** If we belong in background, fork now.
549 sm_dprintf("sendall: final mode = %c\n", mode);
552 sm_dprintf("\n================ Final Send Queue(s) =====================\n");
553 sm_dprintf("\n *** Envelope %s, e_from=%s ***\n",
554 e->e_id, e->e_from.q_paddr);
555 printaddr(sm_debug_file(), e->e_sendqueue, true);
556 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
558 sm_dprintf("\n *** Envelope %s, e_from=%s ***\n",
559 ee->e_id, ee->e_from.q_paddr);
560 printaddr(sm_debug_file(), ee->e_sendqueue, true);
562 sm_dprintf("==========================================================\n\n");
575 #endif /* HASFLOCK */
577 e->e_flags |= EF_INQUEUE;
578 dropenvelope(e, splitenv != NULL, true);
579 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
581 if (ee->e_nrcpts > 0)
582 ee->e_flags |= EF_INQUEUE;
583 dropenvelope(ee, false, true);
588 if (e->e_xfp != NULL)
589 (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT);
593 ** Since fcntl locking has the interesting semantic that
594 ** the lock is owned by a process, not by an open file
595 ** descriptor, we have to flush this to the queue, and
596 ** then restart from scratch in the child.
600 /* save id for future use */
603 /* now drop the envelope in the parent */
604 e->e_flags |= EF_INQUEUE;
605 dropenvelope(e, splitenv != NULL, false);
607 /* arrange to reacquire lock after fork */
611 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
613 /* save id for future use */
614 char *qid = ee->e_id;
616 /* drop envelope in parent */
617 ee->e_flags |= EF_INQUEUE;
618 dropenvelope(ee, false, false);
620 /* and save qid for reacquisition */
624 #endif /* !HASFLOCK */
627 ** Since the delivery may happen in a child and the parent
628 ** does not wait, the parent may close the maps thereby
629 ** removing any shared memory used by the map. Therefore,
630 ** close the maps now so the child will dynamically open
631 ** them if necessary.
639 syserr("deliver: fork 1");
644 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
647 #endif /* HASFLOCK */
652 /* be sure we leave the temp files to our child */
653 /* close any random open files in the envelope */
655 if (e->e_dfp != NULL)
656 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
658 e->e_flags &= ~EF_HAS_DF;
660 /* can't call unlockqueue to avoid unlink of xfp */
661 if (e->e_lockfp != NULL)
662 (void) sm_io_close(e->e_lockfp, SM_TIME_DEFAULT);
664 syserr("%s: sendall: null lockfp", e->e_id);
666 #endif /* HASFLOCK */
668 /* make sure the parent doesn't own the envelope */
672 /* catch intermediate zombie */
674 #endif /* USE_DOUBLE_FORK */
678 /* Reset global flags */
679 RestartRequest = NULL;
680 RestartWorkGroup = false;
681 ShutdownRequest = NULL;
685 ** Initialize exception stack and default exception
686 ** handler for child process.
689 sm_exc_newthread(fatal_error);
692 ** Since we have accepted responsbility for the message,
693 ** change the SIGTERM handler. intsig() (the old handler)
694 ** would remove the envelope if this was a command line
695 ** message submission.
698 (void) sm_signal(SIGTERM, SIG_DFL);
701 /* double fork to avoid zombies */
706 #endif /* USE_DOUBLE_FORK */
708 CurrentPid = getpid();
710 /* be sure we are immune from the terminal */
714 /* prevent parent from waiting if there was an error */
718 syserr("deliver: fork 2");
720 e->e_flags |= EF_INQUEUE;
723 #endif /* HASFLOCK */
724 finis(true, true, ExitStat);
727 /* be sure to give error messages in child */
731 ** Close any cached connections.
733 ** We don't send the QUIT protocol because the parent
734 ** still knows about the connection.
736 ** This should only happen when delivering an error
740 mci_flush(false, NULL);
747 ** Now reacquire and run the various queue files.
750 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
752 ENVELOPE *sibling = ee->e_sibling;
754 (void) dowork(ee->e_qgrp, ee->e_qdir, ee->e_id,
756 ee->e_sibling = sibling;
758 (void) dowork(e->e_qgrp, e->e_qdir, e->e_id,
760 finis(true, true, ExitStat);
761 #endif /* HASFLOCK */
764 sendenvelope(e, mode);
765 dropenvelope(e, true, true);
766 for (ee = splitenv; ee != NULL; ee = ee->e_sibling)
769 if (mode != SM_VERIFY)
771 sendenvelope(ee, mode);
772 dropenvelope(ee, true, true);
776 Verbose = oldverbose;
778 finis(true, true, ExitStat);
782 sendenvelope(e, mode)
783 register ENVELOPE *e;
790 sm_dprintf("sendenvelope(%s) e_flags=0x%lx\n",
791 e->e_id == NULL ? "[NOQUEUE]" : e->e_id,
794 sm_syslog(LOG_DEBUG, e->e_id,
795 "sendenvelope, flags=0x%lx",
799 ** If we have had global, fatal errors, don't bother sending
800 ** the message at all if we are in SMTP mode. Local errors
801 ** (e.g., a single address failing) will still cause the other
802 ** addresses to be sent.
805 if (bitset(EF_FATALERRS, e->e_flags) &&
806 (OpMode == MD_SMTP || OpMode == MD_DAEMON))
808 e->e_flags |= EF_CLRQUEUE;
813 ** Don't attempt deliveries if we want to bounce now
814 ** or if deliver-by time is exceeded.
817 if (!bitset(EF_RESPONSE, e->e_flags) &&
818 (TimeOuts.to_q_return[e->e_timeoutclass] == NOW ||
819 (IS_DLVR_RETURN(e) && e->e_deliver_by > 0 &&
820 curtime() > e->e_ctime + e->e_deliver_by)))
824 ** Run through the list and send everything.
826 ** Set EF_GLOBALERRS so that error messages during delivery
827 ** result in returned mail.
831 e->e_flags |= EF_GLOBALERRS;
833 macdefine(&e->e_macro, A_PERM, macid("{envid}"), e->e_envid);
834 macdefine(&e->e_macro, A_PERM, macid("{bodytype}"), e->e_bodytype);
837 if (!bitset(EF_SPLIT, e->e_flags))
843 ** Save old sibling and set it to NULL to avoid
844 ** queueing up the same envelopes again.
845 ** This requires that envelopes in that list have
846 ** been take care of before (or at some other place).
849 oldsib = e->e_sibling;
851 if (!split_by_recipient(e) &&
852 bitset(EF_FATALERRS, e->e_flags))
854 if (OpMode == MD_SMTP || OpMode == MD_DAEMON)
855 e->e_flags |= EF_CLRQUEUE;
858 for (ee = e->e_sibling; ee != NULL; ee = ee->e_sibling)
859 queueup(ee, false, true);
862 for (ee = e->e_sibling; ee != NULL; ee = ee->e_sibling)
864 /* now unlock the job */
868 /* this envelope is marked unused */
869 if (ee->e_dfp != NULL)
871 (void) sm_io_close(ee->e_dfp, SM_TIME_DEFAULT);
875 ee->e_flags &= ~EF_HAS_DF;
877 e->e_sibling = oldsib;
880 /* now run through the queue */
881 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
884 char wbuf[MAXNAME + 20];
886 (void) sm_snprintf(wbuf, sizeof(wbuf), "sendall(%.*s)",
887 MAXNAME, q->q_paddr);
890 if (mode == SM_VERIFY)
892 e->e_to = q->q_paddr;
893 if (QS_IS_SENDABLE(q->q_state))
895 if (q->q_host != NULL && q->q_host[0] != '\0')
896 message("deliverable: mailer %s, host %s, user %s",
901 message("deliverable: mailer %s, user %s",
906 else if (QS_IS_OK(q->q_state))
909 ** Checkpoint the send list every few addresses
912 if (CheckpointInterval > 0 &&
913 e->e_nsent >= CheckpointInterval)
915 queueup(e, false, false);
918 (void) deliver(e, q);
924 e->e_dtime = curtime();
929 checkfd012("end of sendenvelope");
933 #if REQUIRES_DIR_FSYNC
935 ** SYNC_DIR -- fsync a directory based on a filename
938 ** filename -- path of file
946 sync_dir(filename, panic)
952 char dir[MAXPATHLEN];
954 if (!RequiresDirfsync)
957 /* filesystems which require the directory be synced */
958 dirp = strrchr(filename, '/');
961 if (sm_strlcpy(dir, filename, sizeof(dir)) >= sizeof(dir))
963 dir[dirp - filename] = '\0';
968 dirfd = open(dirp, O_RDONLY, 0700);
970 sm_syslog(LOG_INFO, NOQID, "sync_dir: %s: fsync(%d)",
974 if (fsync(dirfd) < 0)
977 syserr("!sync_dir: cannot fsync directory %s",
979 else if (LogLevel > 1)
980 sm_syslog(LOG_ERR, NOQID,
981 "sync_dir: cannot fsync directory %s: %s",
982 dirp, sm_errstring(errno));
987 #endif /* REQUIRES_DIR_FSYNC */
989 ** DUP_QUEUE_FILE -- duplicate a queue file into a split queue
992 ** e -- the existing envelope
993 ** ee -- the new envelope
994 ** type -- the queue file type (e.g., DATAFL_LETTER)
1001 dup_queue_file(e, ee, type)
1005 char f1buf[MAXPATHLEN], f2buf[MAXPATHLEN];
1011 ** Make sure both are in the same directory.
1014 (void) sm_strlcpy(f1buf, queuename(e, type), sizeof(f1buf));
1015 (void) sm_strlcpy(f2buf, queuename(ee, type), sizeof(f2buf));
1017 /* Force the df to disk if it's not there yet */
1018 if (type == DATAFL_LETTER && e->e_dfp != NULL &&
1019 sm_io_setinfo(e->e_dfp, SM_BF_COMMIT, NULL) < 0 &&
1022 syserr("!dup_queue_file: can't commit %s", f1buf);
1026 if (link(f1buf, f2buf) < 0)
1028 int save_errno = errno;
1030 syserr("sendall: link(%s, %s)", f1buf, f2buf);
1031 if (save_errno == EEXIST)
1033 if (unlink(f2buf) < 0)
1035 syserr("!sendall: unlink(%s): permanent",
1039 if (link(f1buf, f2buf) < 0)
1041 syserr("!sendall: link(%s, %s): permanent",
1047 SYNC_DIR(f2buf, true);
1050 ** DOFORK -- do a fork, retrying a couple of times on failure.
1052 ** This MUST be a macro, since after a vfork we are running
1053 ** two processes on the same stack!!!
1059 ** From a macro??? You've got to be kidding!
1062 ** Modifies the ==> LOCAL <== variable 'pid', leaving:
1063 ** pid of child in parent, zero in child.
1064 ** -1 on unrecoverable error.
1067 ** I'm awfully sorry this looks so awful. That's
1068 ** vfork for you.....
1071 #define NFORKTRIES 5
1077 #define DOFORK(fORKfN) \
1081 for (i = NFORKTRIES; --i >= 0; )\
1087 (void) sleep((unsigned) NFORKTRIES - i);\
1091 ** DOFORK -- simple fork interface to DOFORK.
1097 ** pid of child in parent.
1102 ** returns twice, once in parent and once in child.
1108 register pid_t pid = -1;
1115 ** COLONCMP -- compare host-signatures up to first ':' or EOS
1117 ** This takes two strings which happen to be host-signatures and
1118 ** compares them. If the lowest preference portions of the MX-RR's
1119 ** match (up to ':' or EOS, whichever is first), then we have
1120 ** match. This is used for coattail-piggybacking messages during
1121 ** message delivery.
1122 ** If the signatures are the same up to the first ':' the remainder of
1123 ** the signatures are then compared with a normal strcmp(). This saves
1124 ** re-examining the first part of the signatures.
1127 ** a - first host-signature
1128 ** b - second host-signature
1131 ** HS_MATCH_NO -- no "match".
1132 ** HS_MATCH_FIRST -- "match" for the first MX preference
1133 ** (up to the first colon (':')).
1134 ** HS_MATCH_FULL -- match for the entire MX record.
1140 #define HS_MATCH_NO 0
1141 #define HS_MATCH_FIRST 1
1142 #define HS_MATCH_FULL 2
1146 register const char *a;
1147 register const char *b;
1149 int ret = HS_MATCH_NO;
1154 /* Need to account for IPv6 bracketed addresses */
1157 else if (*a == ']' && braclev > 0)
1159 else if (*a == ':' && braclev <= 0)
1161 ret = HS_MATCH_FIRST;
1165 else if (*a == '\0')
1166 return HS_MATCH_FULL; /* a full match */
1169 if (ret == HS_MATCH_NO &&
1171 ((*a == '\0' && *(b - 1) == ':') ||
1172 (*a == ':' && *(b - 1) == '\0')))
1173 return HS_MATCH_FIRST;
1174 if (ret == HS_MATCH_FIRST && strcmp(a, b) == 0)
1175 return HS_MATCH_FULL;
1181 ** SHOULD_TRY_FBSH -- Should try FallbackSmartHost?
1185 ** tried_fallbacksmarthost -- has been tried already? (in/out)
1186 ** hostbuf -- buffer for hostname (expand FallbackSmartHost) (out)
1187 ** hbsz -- size of hostbuf
1188 ** status -- current delivery status
1191 ** true iff FallbackSmartHost should be tried.
1194 static bool should_try_fbsh __P((ENVELOPE *, bool *, char *, size_t, int));
1197 should_try_fbsh(e, tried_fallbacksmarthost, hostbuf, hbsz, status)
1199 bool *tried_fallbacksmarthost;
1205 ** If the host was not found or a temporary failure occurred
1206 ** and a FallbackSmartHost is defined (and we have not yet
1207 ** tried it), then make one last try with it as the host.
1210 if ((status == EX_NOHOST || status == EX_TEMPFAIL) &&
1211 FallbackSmartHost != NULL && !*tried_fallbacksmarthost)
1213 *tried_fallbacksmarthost = true;
1214 expand(FallbackSmartHost, hostbuf, hbsz, e);
1215 if (!wordinclass(hostbuf, 'w'))
1218 sm_dprintf("one last try with FallbackSmartHost %s\n",
1226 ** DELIVER -- Deliver a message to a list of addresses.
1228 ** This routine delivers to everyone on the same host as the
1229 ** user on the head of the list. It is clever about mailers
1230 ** that don't handle multiple users. It is NOT guaranteed
1231 ** that it will deliver to all these addresses however -- so
1232 ** deliver should be called once for each address on the
1234 ** Deliver tries to be as opportunistic as possible about piggybacking
1235 ** messages. Some definitions to make understanding easier follow below.
1236 ** Piggybacking occurs when an existing connection to a mail host can
1237 ** be used to send the same message to more than one recipient at the
1238 ** same time. So "no piggybacking" means one message for one recipient
1239 ** per connection. "Intentional piggybacking" happens when the
1240 ** recipients' host address (not the mail host address) is used to
1241 ** attempt piggybacking. Recipients with the same host address
1242 ** have the same mail host. "Coincidental piggybacking" relies on
1243 ** piggybacking based on all the mail host addresses in the MX-RR. This
1244 ** is "coincidental" in the fact it could not be predicted until the
1245 ** MX Resource Records for the hosts were obtained and examined. For
1246 ** example (preference order and equivalence is important, not values):
1247 ** domain1 IN MX 10 mxhost-A
1248 ** IN MX 20 mxhost-B
1249 ** domain2 IN MX 4 mxhost-A
1251 ** Domain1 and domain2 can piggyback the same message to mxhost-A or
1252 ** mxhost-B (if mxhost-A cannot be reached).
1253 ** "Coattail piggybacking" relaxes the strictness of "coincidental
1254 ** piggybacking" in the hope that most significant (lowest value)
1255 ** MX preference host(s) can create more piggybacking. For example
1256 ** (again, preference order and equivalence is important, not values):
1257 ** domain3 IN MX 100 mxhost-C
1258 ** IN MX 100 mxhost-D
1259 ** IN MX 200 mxhost-E
1260 ** domain4 IN MX 50 mxhost-C
1261 ** IN MX 50 mxhost-D
1262 ** IN MX 80 mxhost-F
1263 ** A message for domain3 and domain4 can piggyback to mxhost-C if mxhost-C
1264 ** is available. Same with mxhost-D because in both RR's the preference
1265 ** value is the same as mxhost-C, respectively.
1266 ** So deliver attempts coattail piggybacking when possible. If the
1267 ** first MX preference level hosts cannot be used then the piggybacking
1268 ** reverts to coincidental piggybacking. Using the above example you
1269 ** cannot deliver to mxhost-F for domain3 regardless of preference value.
1270 ** ("Coattail" from "riding on the coattails of your predecessor" meaning
1271 ** gaining benefit from a predecessor effort with no or little addition
1272 ** effort. The predecessor here being the preceding MX RR).
1275 ** e -- the envelope to deliver.
1276 ** firstto -- head of the address list to deliver to.
1279 ** zero -- successfully delivered.
1280 ** else -- some failure, see ExitStat for more info.
1283 ** The standard input is passed off to someone.
1288 register ENVELOPE *e;
1291 char *host; /* host being sent to */
1292 char *user; /* user being sent to */
1294 register char **mvp;
1296 register MAILER *m; /* mailer for this recipient */
1297 ADDRESS *volatile ctladdr;
1298 #if HASSETUSERCONTEXT
1299 ADDRESS *volatile contextaddr = NULL;
1300 #endif /* HASSETUSERCONTEXT */
1301 register MCI *volatile mci;
1302 register ADDRESS *SM_NONVOLATILE to = firstto;
1303 volatile bool clever = false; /* running user smtp to this mailer */
1304 ADDRESS *volatile tochain = NULL; /* users chain in this mailer call */
1305 int rcode; /* response code */
1306 SM_NONVOLATILE int lmtp_rcode = EX_OK;
1307 SM_NONVOLATILE int nummxhosts = 0; /* number of MX hosts available */
1308 SM_NONVOLATILE int hostnum = 0; /* current MX host index */
1309 char *firstsig; /* signature of firstto */
1310 volatile pid_t pid = -1;
1311 char *volatile curhost;
1312 SM_NONVOLATILE unsigned short port = 0;
1313 SM_NONVOLATILE time_t enough = 0;
1315 char *SM_NONVOLATILE mux_path = NULL; /* path to UNIX domain socket */
1316 #endif /* NETUNIX */
1319 bool anyok; /* at least one address was OK */
1320 SM_NONVOLATILE bool goodmxfound = false; /* at least one MX was OK */
1326 static int tobufsize = 0;
1327 static char *tobuf = NULL;
1328 char *rpath; /* translated return path */
1331 char *mxhosts[MAXMXHOSTS + 1];
1332 char *pv[MAXPV + 1];
1333 char buf[MAXNAME + 1];
1334 char cbuf[MAXPATHLEN];
1337 SM_REQUIRE(firstto != NULL); /* same as to */
1338 if (!QS_IS_OK(to->q_state))
1341 suidwarn = geteuid() == 0;
1343 SM_REQUIRE(e != NULL);
1346 CurEnv = e; /* just in case */
1347 e->e_statmsg = NULL;
1348 SmtpError[0] = '\0';
1352 sm_dprintf("\n--deliver, id=%s, mailer=%s, host=`%s', first user=`%s'\n",
1353 e->e_id, m->m_name, host, to->q_user);
1355 printopenfds(false);
1358 ** Clear {client_*} macros if this is a bounce message to
1359 ** prevent rejection by check_compat ruleset.
1362 if (bitset(EF_RESPONSE, e->e_flags))
1364 macdefine(&e->e_macro, A_PERM, macid("{client_name}"), "");
1365 macdefine(&e->e_macro, A_PERM, macid("{client_ptr}"), "");
1366 macdefine(&e->e_macro, A_PERM, macid("{client_addr}"), "");
1367 macdefine(&e->e_macro, A_PERM, macid("{client_port}"), "");
1368 macdefine(&e->e_macro, A_PERM, macid("{client_resolve}"), "");
1373 ADDRESS *skip_back = NULL;
1376 ** Do initial argv setup.
1377 ** Insert the mailer name. Notice that $x expansion is
1378 ** NOT done on the mailer name. Then, if the mailer has
1379 ** a picky -f flag, we insert it as appropriate. This
1380 ** code does not check for 'pv' overflow; this places a
1381 ** manifest lower limit of 4 for MAXPV.
1382 ** The from address rewrite is expected to make
1383 ** the address relative to the other end.
1386 /* rewrite from address, using rewriting rules */
1388 SM_ASSERT(e->e_from.q_mailer != NULL);
1389 if (bitnset(M_UDBENVELOPE, e->e_from.q_mailer->m_flags))
1392 p = e->e_from.q_paddr;
1393 rpath = remotename(p, m, RF_SENDERADDR|RF_CANONICAL, &rcode, e);
1394 if (strlen(rpath) > MAXSHORTSTR)
1396 rpath = shortenstring(rpath, MAXSHORTSTR);
1398 /* avoid bogus errno */
1400 syserr("remotename: huge return path %s", rpath);
1402 rpath = sm_rpool_strdup_x(e->e_rpool, rpath);
1403 macdefine(&e->e_macro, A_PERM, 'g', rpath);
1404 macdefine(&e->e_macro, A_PERM, 'h', host);
1407 *pvp++ = m->m_argv[0];
1409 /* ignore long term host status information if mailer flag W is set */
1410 if (bitnset(M_NOHOSTSTAT, m->m_flags))
1411 IgnoreHostStatus = true;
1413 /* insert -f or -r flag as appropriate */
1415 (bitnset(M_FOPT, m->m_flags) ||
1416 bitnset(M_ROPT, m->m_flags)))
1418 if (bitnset(M_FOPT, m->m_flags))
1426 ** Append the other fixed parts of the argv. These run
1427 ** up to the first entry containing "$u". There can only
1428 ** be one of these, and there are only a few more slots
1429 ** in the pv after it.
1432 for (mvp = m->m_argv; (p = *++mvp) != NULL; )
1434 /* can't use strchr here because of sign extension problems */
1437 if ((*p++ & 0377) == MACROEXPAND)
1447 /* this entry is safe -- go ahead and process it */
1448 expand(*mvp, buf, sizeof(buf), e);
1449 *pvp++ = sm_rpool_strdup_x(e->e_rpool, buf);
1450 if (pvp >= &pv[MAXPV - 3])
1452 syserr("554 5.3.5 Too many parameters to %s before $u",
1460 ** If we have no substitution for the user name in the argument
1461 ** list, we know that we must supply the names otherwise -- and
1462 ** SMTP is the answer!!
1467 /* running LMTP or SMTP */
1471 else if (bitnset(M_LMTP, m->m_flags))
1473 /* not running LMTP */
1474 sm_syslog(LOG_ERR, NULL,
1475 "Warning: mailer %s: LMTP flag (F=z) turned off",
1477 clrbitn(M_LMTP, m->m_flags);
1481 ** At this point *mvp points to the argument with $u. We
1482 ** run through our address list and append all the addresses
1483 ** we can. If we run out of space, do not fret! We can
1484 ** always send another copy later.
1491 if (firstto->q_signature == NULL)
1492 firstto->q_signature = hostsignature(firstto->q_mailer,
1494 firstsig = firstto->q_signature;
1496 for (; to != NULL; to = to->q_next)
1498 /* avoid sending multiple recipients to dumb mailers */
1499 if (tochain != NULL && !bitnset(M_MUSER, m->m_flags))
1502 /* if already sent or not for this host, don't send */
1503 if (!QS_IS_OK(to->q_state)) /* already sent; look at next */
1507 ** Must be same mailer to keep grouping rcpts.
1508 ** If mailers don't match: continue; sendqueue is not
1509 ** sorted by mailers, so don't break;
1512 if (to->q_mailer != firstto->q_mailer)
1515 if (to->q_signature == NULL) /* for safety */
1516 to->q_signature = hostsignature(to->q_mailer,
1520 ** This is for coincidental and tailcoat piggybacking messages
1521 ** to the same mail host. While the signatures are identical
1522 ** (that's the MX-RR's are identical) we can do coincidental
1523 ** piggybacking. We try hard for coattail piggybacking
1524 ** with the same mail host when the next recipient has the
1525 ** same host at lowest preference. It may be that this
1526 ** won't work out, so 'skip_back' is maintained if a backup
1527 ** to coincidental piggybacking or full signature must happen.
1530 ret = firstto == to ? HS_MATCH_FULL :
1531 coloncmp(to->q_signature, firstsig);
1532 if (ret == HS_MATCH_FULL)
1534 else if (ret == HS_MATCH_NO)
1539 /* avoid overflowing tobuf */
1540 strsize += strlen(to->q_paddr) + 1;
1541 if (strsize > TOBUFSIZE)
1545 if (++rcptcount > to->q_mailer->m_maxrcpt)
1550 sm_dprintf("\nsend to ");
1551 printaddr(sm_debug_file(), to, false);
1554 /* compute effective uid/gid when sending */
1555 if (bitnset(M_RUNASRCPT, to->q_mailer->m_flags))
1556 # if HASSETUSERCONTEXT
1557 contextaddr = ctladdr = getctladdr(to);
1558 # else /* HASSETUSERCONTEXT */
1559 ctladdr = getctladdr(to);
1560 # endif /* HASSETUSERCONTEXT */
1564 sm_dprintf("ctladdr=");
1565 printaddr(sm_debug_file(), ctladdr, false);
1569 e->e_to = to->q_paddr;
1572 ** Check to see that these people are allowed to
1573 ** talk to each other.
1574 ** Check also for overflow of e_msgsize.
1577 if (m->m_maxsize != 0 &&
1578 (e->e_msgsize > m->m_maxsize || e->e_msgsize < 0))
1580 e->e_flags |= EF_NO_BODY_RETN;
1581 if (bitnset(M_LOCALMAILER, to->q_mailer->m_flags))
1582 to->q_status = "5.2.3";
1584 to->q_status = "5.3.4";
1586 /* set to->q_rstatus = NULL; or to the following? */
1587 usrerrenh(to->q_status,
1588 "552 Message is too large; %ld bytes max",
1590 markfailure(e, to, NULL, EX_UNAVAILABLE, false);
1591 giveresponse(EX_UNAVAILABLE, to->q_status, m,
1592 NULL, ctladdr, xstart, e, to);
1598 /* do config file checking of compatibility */
1599 quarantine = (e->e_quarmsg != NULL);
1600 rcode = rscheck("check_compat", e->e_from.q_paddr, to->q_paddr,
1601 e, RSF_RMCOMM|RSF_COUNT, 3, NULL,
1605 /* do in-code checking if not discarding */
1606 if (!bitset(EF_DISCARD, e->e_flags))
1608 rcode = checkcompat(to, e);
1614 markfailure(e, to, NULL, rcode, ovr);
1615 giveresponse(rcode, to->q_status, m,
1616 NULL, ctladdr, xstart, e, to);
1619 if (!quarantine && e->e_quarmsg != NULL)
1622 ** check_compat or checkcompat() has tried
1623 ** to quarantine but that isn't supported.
1624 ** Revert the attempt.
1627 e->e_quarmsg = NULL;
1628 macdefine(&e->e_macro, A_PERM,
1629 macid("{quarantine}"), "");
1631 if (bitset(EF_DISCARD, e->e_flags))
1635 sm_dprintf("deliver: discarding recipient ");
1636 printaddr(sm_debug_file(), to, false);
1639 /* pretend the message was sent */
1640 /* XXX should we log something here? */
1641 to->q_state = QS_DISCARDED;
1644 ** Remove discard bit to prevent discard of
1645 ** future recipients. This is safe because the
1646 ** true "global discard" has been handled before
1650 e->e_flags &= ~EF_DISCARD;
1655 ** Strip quote bits from names if the mailer is dumb
1659 if (bitnset(M_STRIPQ, m->m_flags))
1666 ** Strip all leading backslashes if requested and the
1667 ** next character is alphanumerical (the latter can
1668 ** probably relaxed a bit, see RFC2821).
1671 if (bitnset(M_STRIPBACKSL, m->m_flags) && user[0] == '\\')
1672 stripbackslash(user);
1674 /* hack attack -- delivermail compatibility */
1675 if (m == ProgMailer && *user == '|')
1679 ** If an error message has already been given, don't
1680 ** bother to send to this address.
1682 ** >>>>>>>>>> This clause assumes that the local mailer
1683 ** >> NOTE >> cannot do any further aliasing; that
1684 ** >>>>>>>>>> function is subsumed by sendmail.
1687 if (!QS_IS_OK(to->q_state))
1691 ** See if this user name is "special".
1692 ** If the user name has a slash in it, assume that this
1693 ** is a file -- send it off without further ado. Note
1694 ** that this type of addresses is not processed along
1695 ** with the others, so we fudge on the To person.
1698 if (strcmp(m->m_mailer, "[FILE]") == 0)
1700 macdefine(&e->e_macro, A_PERM, 'u', user);
1702 if (p == NULL && ctladdr != NULL)
1703 p = ctladdr->q_home;
1704 macdefine(&e->e_macro, A_PERM, 'z', p);
1705 expand(m->m_argv[1], buf, sizeof(buf), e);
1706 if (strlen(buf) > 0)
1707 rcode = mailfile(buf, m, ctladdr, SFF_CREAT, e);
1710 syserr("empty filename specification for mailer %s",
1714 giveresponse(rcode, to->q_status, m, NULL,
1715 ctladdr, xstart, e, to);
1716 markfailure(e, to, NULL, rcode, true);
1720 to->q_state = QS_SENT;
1721 if (bitnset(M_LOCALMAILER, m->m_flags) &&
1722 bitset(QPINGONSUCCESS, to->q_flags))
1724 to->q_flags |= QDELIVERED;
1725 to->q_status = "2.1.5";
1726 (void) sm_io_fprintf(e->e_xfp,
1728 "%s... Successfully delivered\n",
1732 to->q_statdate = curtime();
1733 markstats(e, to, STATS_NORMAL);
1738 ** Address is verified -- add this user to mailer
1739 ** argv, and add it to the print list of recipients.
1742 /* link together the chain of recipients */
1743 to->q_tchain = tochain;
1745 e->e_to = "[CHAIN]";
1747 macdefine(&e->e_macro, A_PERM, 'u', user); /* to user */
1749 if (p == NULL && ctladdr != NULL)
1750 p = ctladdr->q_home;
1751 macdefine(&e->e_macro, A_PERM, 'z', p); /* user's home */
1753 /* set the ${dsn_notify} macro if applicable */
1754 if (bitset(QHASNOTIFY, to->q_flags))
1756 char notify[MAXLINE];
1759 if (bitset(QPINGONSUCCESS, to->q_flags))
1760 (void) sm_strlcat(notify, "SUCCESS,",
1762 if (bitset(QPINGONFAILURE, to->q_flags))
1763 (void) sm_strlcat(notify, "FAILURE,",
1765 if (bitset(QPINGONDELAY, to->q_flags))
1766 (void) sm_strlcat(notify, "DELAY,",
1769 /* Set to NEVER or drop trailing comma */
1770 if (notify[0] == '\0')
1771 (void) sm_strlcat(notify, "NEVER",
1774 notify[strlen(notify) - 1] = '\0';
1776 macdefine(&e->e_macro, A_TEMP,
1777 macid("{dsn_notify}"), notify);
1780 macdefine(&e->e_macro, A_PERM,
1781 macid("{dsn_notify}"), NULL);
1784 ** Expand out this user into argument list.
1789 expand(*mvp, buf, sizeof(buf), e);
1790 *pvp++ = sm_rpool_strdup_x(e->e_rpool, buf);
1791 if (pvp >= &pv[MAXPV - 2])
1793 /* allow some space for trailing parms */
1799 /* see if any addresses still exist */
1800 if (tochain == NULL)
1806 /* print out messages as full list */
1808 for (to = tochain; to != NULL; to = to->q_tchain)
1809 strsize += strlen(to->q_paddr) + 1;
1810 if (strsize < TOBUFSIZE)
1811 strsize = TOBUFSIZE;
1812 if (strsize > tobufsize)
1815 tobuf = sm_pmalloc_x(strsize);
1816 tobufsize = strsize;
1820 for (to = tochain; to != NULL; to = to->q_tchain)
1822 (void) sm_strlcpyn(p, tobufsize - (p - tobuf), 2,
1826 e->e_to = tobuf + 1;
1829 ** Fill out any parameters after the $u parameter.
1834 while (*++mvp != NULL)
1836 expand(*mvp, buf, sizeof(buf), e);
1837 *pvp++ = sm_rpool_strdup_x(e->e_rpool, buf);
1838 if (pvp >= &pv[MAXPV])
1839 syserr("554 5.3.0 deliver: pv overflow after $u for %s",
1847 ** The argument vector gets built, pipes
1848 ** are created as necessary, and we fork & exec as
1850 ** If we are running SMTP, we just need to clean up.
1853 /* XXX this seems a bit wierd */
1854 if (ctladdr == NULL && m != ProgMailer && m != FileMailer &&
1855 bitset(QGOODUID, e->e_from.q_flags))
1856 ctladdr = &e->e_from;
1859 if (ConfigLevel < 2)
1860 _res.options &= ~(RES_DEFNAMES | RES_DNSRCH); /* XXX */
1861 #endif /* NAMED_BIND */
1865 sm_dprintf("openmailer:");
1866 printav(sm_debug_file(), pv);
1873 ** Deal with the special case of mail handled through an IPC
1875 ** In this case we don't actually fork. We must be
1876 ** running SMTP for this to work. We will return a
1877 ** zero pid to indicate that we are running IPC.
1878 ** We also handle a debug version that just talks to stdin/out.
1889 /* make absolutely certain 0, 1, and 2 are in use */
1890 (void) sm_snprintf(wbuf, sizeof(wbuf), "%s... openmailer(%s)",
1891 shortenstring(e->e_to, MAXSHORTSTR),
1897 /* check for 8-bit available */
1898 if (bitset(EF_HAS8BIT, e->e_flags) &&
1899 bitnset(M_7BITS, m->m_flags) &&
1900 (bitset(EF_DONT_MIME, e->e_flags) ||
1901 !(bitset(MM_MIME8BIT, MimeMode) ||
1902 (bitset(EF_IS_MIME, e->e_flags) &&
1903 bitset(MM_CVTMIME, MimeMode)))))
1905 e->e_status = "5.6.3";
1906 usrerrenh(e->e_status,
1907 "554 Cannot send 8-bit data to 7-bit destination");
1913 checkfds("before delivery");
1915 /* check for Local Person Communication -- not for mortals!!! */
1916 if (strcmp(m->m_mailer, "[LPC]") == 0)
1920 /* flush any expired connections */
1921 (void) mci_scan(NULL);
1923 /* try to get a cached connection or just a slot */
1924 mci = mci_get(m->m_name, m);
1925 if (mci->mci_host == NULL)
1926 mci->mci_host = m->m_name;
1927 CurHostName = mci->mci_host;
1928 if (mci->mci_state != MCIS_CLOSED)
1930 message("Using cached SMTP/LPC connection for %s...",
1932 mci->mci_deliveries++;
1938 mci = mci_new(e->e_rpool);
1940 mci->mci_in = smioin;
1941 mci->mci_out = smioout;
1942 mci->mci_mailer = m;
1943 mci->mci_host = m->m_name;
1946 mci->mci_state = MCIS_OPENING;
1950 mci->mci_state = MCIS_OPEN;
1952 else if (strcmp(m->m_mailer, "[IPC]") == 0)
1956 if (pv[0] == NULL || pv[1] == NULL || pv[1][0] == '\0')
1958 syserr("null destination for %s mailer", m->m_mailer);
1964 if (strcmp(pv[0], "FILE") == 0)
1966 curhost = CurHostName = "localhost";
1970 # endif /* NETUNIX */
1972 CurHostName = pv[1];
1973 curhost = hostsignature(m, pv[1]);
1976 if (curhost == NULL || curhost[0] == '\0')
1978 syserr("null host signature for %s", pv[1]);
1985 syserr("554 5.3.5 non-clever IPC");
1992 # endif /* NETUNIX */
1995 port = htons((unsigned short) atoi(pv[2]));
1998 # ifdef NO_GETSERVBYNAME
1999 syserr("Invalid port number: %s", pv[2]);
2000 # else /* NO_GETSERVBYNAME */
2001 struct servent *sp = getservbyname(pv[2], "tcp");
2004 syserr("Service %s unknown", pv[2]);
2007 # endif /* NO_GETSERVBYNAME */
2011 nummxhosts = parse_hostsignature(curhost, mxhosts, m);
2012 if (TimeOuts.to_aconnect > 0)
2013 enough = curtime() + TimeOuts.to_aconnect;
2015 while (hostnum < nummxhosts)
2019 static char hostbuf[MAXNAME + 1];
2020 bool tried_fallbacksmarthost = false;
2023 if (*mxhosts[hostnum] == '[')
2025 endp = strchr(mxhosts[hostnum] + 1, ']');
2027 endp = strpbrk(endp + 1, ":,");
2030 endp = strpbrk(mxhosts[hostnum], ":,");
2031 # else /* NETINET6 */
2032 endp = strpbrk(mxhosts[hostnum], ":,");
2033 # endif /* NETINET6 */
2040 if (hostnum == 1 && skip_back != NULL)
2043 ** Coattail piggybacking is no longer an
2044 ** option with the mail host next to be tried
2045 ** no longer the lowest MX preference
2046 ** (hostnum == 1 meaning we're on the second
2047 ** preference). We do not try to coattail
2048 ** piggyback more than the first MX preference.
2049 ** Revert 'tochain' to last location for
2050 ** coincidental piggybacking. This works this
2051 ** easily because the q_tchain kept getting
2052 ** added to the top of the linked list.
2055 tochain = skip_back;
2058 if (*mxhosts[hostnum] == '\0')
2060 syserr("deliver: null host name in signature");
2066 (void) sm_strlcpy(hostbuf, mxhosts[hostnum],
2073 /* see if we already know that this host is fried */
2074 CurHostName = hostbuf;
2075 mci = mci_get(hostbuf, m);
2076 if (mci->mci_state != MCIS_CLOSED)
2082 sm_dprintf("openmailer: ");
2083 mci_dump(sm_debug_file(), mci, false);
2085 CurHostName = mci->mci_host;
2086 if (bitnset(M_LMTP, m->m_flags))
2088 else if (bitset(MCIF_ESMTP, mci->mci_flags))
2092 message("Using cached %sMTP connection to %s via %s...",
2093 type, hostbuf, m->m_name);
2094 mci->mci_deliveries++;
2097 mci->mci_mailer = m;
2098 if (mci->mci_exitstat != EX_OK)
2100 if (mci->mci_exitstat == EX_TEMPFAIL)
2103 /* Try FallbackSmartHost? */
2104 if (should_try_fbsh(e, &tried_fallbacksmarthost,
2105 hostbuf, sizeof(hostbuf),
2112 if (mci_lock_host(mci) != EX_OK)
2114 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2119 /* try the connection */
2120 sm_setproctitle(true, e, "%s %s: %s",
2122 hostbuf, "user open");
2124 if (mux_path != NULL)
2126 message("Connecting to %s via %s...",
2127 mux_path, m->m_name);
2128 i = makeconnection_ds((char *) mux_path, mci);
2131 # endif /* NETUNIX */
2134 message("Connecting to %s via %s...",
2135 hostbuf, m->m_name);
2137 message("Connecting to %s port %d via %s...",
2138 hostbuf, ntohs(port),
2140 i = makeconnection(hostbuf, port, mci, e,
2143 mci->mci_errno = errno;
2144 mci->mci_lastuse = curtime();
2145 mci->mci_deliveries = 0;
2146 mci->mci_exitstat = i;
2148 mci->mci_herrno = h_errno;
2149 # endif /* NAMED_BIND */
2152 ** Have we tried long enough to get a connection?
2153 ** If yes, skip to the fallback MX hosts
2157 if (enough > 0 && mci->mci_lastuse >= enough)
2161 extern int NumFallbackMXHosts;
2162 # else /* NAMED_BIND */
2163 const int NumFallbackMXHosts = 0;
2164 # endif /* NAMED_BIND */
2166 if (hostnum < nummxhosts && LogLevel > 9)
2167 sm_syslog(LOG_INFO, e->e_id,
2168 "Timeout.to_aconnect occurred before exhausting all addresses");
2170 /* turn off timeout if fallback available */
2171 if (NumFallbackMXHosts > 0)
2174 /* skip to a fallback MX host */
2175 h = nummxhosts - NumFallbackMXHosts;
2182 markstats(e, firstto, STATS_CONNECT);
2183 mci->mci_state = MCIS_OPENING;
2185 if (TrafficLogFile != NULL)
2186 (void) sm_io_fprintf(TrafficLogFile,
2188 "%05d === CONNECT %s\n",
2195 /* Try FallbackSmartHost? */
2196 if (should_try_fbsh(e, &tried_fallbacksmarthost,
2197 hostbuf, sizeof(hostbuf), i))
2201 sm_dprintf("openmailer: makeconnection => stat=%d, errno=%d\n",
2203 if (i == EX_TEMPFAIL)
2205 mci_unlock_host(mci);
2208 /* enter status of this host */
2211 /* should print some message here for -v mode */
2215 syserr("deliver: no host name");
2216 rcode = EX_SOFTWARE;
2223 /* flush any expired connections */
2224 (void) mci_scan(NULL);
2227 if (bitnset(M_LMTP, m->m_flags))
2229 /* try to get a cached connection */
2230 mci = mci_get(m->m_name, m);
2231 if (mci->mci_host == NULL)
2232 mci->mci_host = m->m_name;
2233 CurHostName = mci->mci_host;
2234 if (mci->mci_state != MCIS_CLOSED)
2236 message("Using cached LMTP connection for %s...",
2238 mci->mci_deliveries++;
2243 /* announce the connection to verbose listeners */
2244 if (host == NULL || host[0] == '\0')
2245 message("Connecting to %s...", m->m_name);
2247 message("Connecting to %s via %s...", host, m->m_name);
2248 if (TrafficLogFile != NULL)
2252 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
2253 "%05d === EXEC", (int) CurrentPid);
2254 for (av = pv; *av != NULL; av++)
2255 (void) sm_io_fprintf(TrafficLogFile,
2256 SM_TIME_DEFAULT, " %s",
2258 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
2263 checkfd012("before creating mail pipe");
2266 /* create a pipe to shove the mail through */
2267 if (pipe(mpvect) < 0)
2269 syserr("%s... openmailer(%s): pipe (to mailer)",
2270 shortenstring(e->e_to, MAXSHORTSTR), m->m_name);
2272 sm_dprintf("openmailer: NULL\n");
2278 /* make sure we didn't get one of the standard I/O files */
2279 if (mpvect[0] < 3 || mpvect[1] < 3)
2281 syserr("%s... openmailer(%s): bogus mpvect %d %d",
2282 shortenstring(e->e_to, MAXSHORTSTR), m->m_name,
2283 mpvect[0], mpvect[1]);
2286 sm_dprintf("openmailer: NULL\n");
2291 /* make sure system call isn't dead meat */
2292 checkfdopen(mpvect[0], "mpvect[0]");
2293 checkfdopen(mpvect[1], "mpvect[1]");
2294 if (mpvect[0] == mpvect[1] ||
2295 (e->e_lockfp != NULL &&
2296 (mpvect[0] == sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD,
2298 mpvect[1] == sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD,
2301 if (e->e_lockfp == NULL)
2302 syserr("%s... openmailer(%s): overlapping mpvect %d %d",
2303 shortenstring(e->e_to, MAXSHORTSTR),
2304 m->m_name, mpvect[0], mpvect[1]);
2306 syserr("%s... openmailer(%s): overlapping mpvect %d %d, lockfp = %d",
2307 shortenstring(e->e_to, MAXSHORTSTR),
2308 m->m_name, mpvect[0], mpvect[1],
2309 sm_io_getinfo(e->e_lockfp,
2310 SM_IO_WHAT_FD, NULL));
2314 /* create a return pipe */
2315 if (pipe(rpvect) < 0)
2317 syserr("%s... openmailer(%s): pipe (from mailer)",
2318 shortenstring(e->e_to, MAXSHORTSTR),
2320 (void) close(mpvect[0]);
2321 (void) close(mpvect[1]);
2323 sm_dprintf("openmailer: NULL\n");
2328 checkfdopen(rpvect[0], "rpvect[0]");
2329 checkfdopen(rpvect[1], "rpvect[1]");
2333 ** Actually fork the mailer process.
2334 ** DOFORK is clever about retrying.
2336 ** Dispose of SIGCHLD signal catchers that may be laying
2337 ** around so that endmailer will get it.
2340 if (e->e_xfp != NULL) /* for debugging */
2341 (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT);
2342 (void) sm_io_flush(smioout, SM_TIME_DEFAULT);
2343 (void) sm_signal(SIGCHLD, SIG_DFL);
2347 /* pid is set by DOFORK */
2352 syserr("%s... openmailer(%s): cannot fork",
2353 shortenstring(e->e_to, MAXSHORTSTR), m->m_name);
2354 (void) close(mpvect[0]);
2355 (void) close(mpvect[1]);
2356 (void) close(rpvect[0]);
2357 (void) close(rpvect[1]);
2359 sm_dprintf("openmailer: NULL\n");
2367 int new_euid = NO_UID;
2368 int new_ruid = NO_UID;
2369 int new_gid = NO_GID;
2372 extern int DtableSize;
2374 CurrentPid = getpid();
2376 /* clear the events to turn off SIGALRMs */
2379 /* Reset global flags */
2380 RestartRequest = NULL;
2381 RestartWorkGroup = false;
2382 ShutdownRequest = NULL;
2385 if (e->e_lockfp != NULL)
2386 (void) close(sm_io_getinfo(e->e_lockfp,
2390 /* child -- set up input & exec mailer */
2391 (void) sm_signal(SIGALRM, sm_signal_noop);
2392 (void) sm_signal(SIGCHLD, SIG_DFL);
2393 (void) sm_signal(SIGHUP, SIG_IGN);
2394 (void) sm_signal(SIGINT, SIG_IGN);
2395 (void) sm_signal(SIGTERM, SIG_DFL);
2397 (void) sm_signal(SIGUSR1, sm_signal_noop);
2398 # endif /* SIGUSR1 */
2400 if (m != FileMailer || stat(tochain->q_user, &stb) < 0)
2403 # if HASSETUSERCONTEXT
2405 ** Set user resources.
2408 if (contextaddr != NULL)
2413 if (contextaddr->q_ruser != NULL)
2414 pwd = sm_getpwnam(contextaddr->q_ruser);
2416 pwd = sm_getpwnam(contextaddr->q_user);
2417 sucflags = LOGIN_SETRESOURCES|LOGIN_SETPRIORITY;
2419 sucflags |= LOGIN_SETMAC;
2420 #endif /* LOGIN_SETMAC */
2422 setusercontext(NULL, pwd, pwd->pw_uid,
2426 syserr("openmailer: setusercontext() failed");
2430 # endif /* HASSETUSERCONTEXT */
2433 /* tweak niceness */
2435 (void) nice(m->m_nice);
2436 #endif /* HASNICE */
2438 /* reset group id */
2439 if (bitnset(M_SPECIFIC_UID, m->m_flags))
2441 if (m->m_gid == NO_GID)
2446 else if (bitset(S_ISGID, stb.st_mode))
2447 new_gid = stb.st_gid;
2448 else if (ctladdr != NULL && ctladdr->q_gid != 0)
2450 if (!DontInitGroups)
2452 user = ctladdr->q_ruser;
2454 user = ctladdr->q_user;
2456 if (initgroups(user,
2457 ctladdr->q_gid) == -1
2460 syserr("openmailer: initgroups(%s, %d) failed",
2461 user, ctladdr->q_gid);
2469 gidset[0] = ctladdr->q_gid;
2470 if (setgroups(1, gidset) == -1
2473 syserr("openmailer: setgroups() failed");
2477 new_gid = ctladdr->q_gid;
2481 if (!DontInitGroups)
2484 if (initgroups(DefUser, DefGid) == -1 &&
2487 syserr("openmailer: initgroups(%s, %d) failed",
2497 if (setgroups(1, gidset) == -1
2500 syserr("openmailer: setgroups() failed");
2504 if (m->m_gid == NO_GID)
2509 if (new_gid != NO_GID)
2511 if (RunAsUid != 0 &&
2512 bitnset(M_SPECIFIC_UID, m->m_flags) &&
2513 new_gid != getgid() &&
2514 new_gid != getegid())
2516 /* Only root can change the gid */
2517 syserr("openmailer: insufficient privileges to change gid, RunAsUid=%d, new_gid=%d, gid=%d, egid=%d",
2518 (int) RunAsUid, (int) new_gid,
2519 (int) getgid(), (int) getegid());
2523 if (setgid(new_gid) < 0 && suidwarn)
2525 syserr("openmailer: setgid(%ld) failed",
2531 /* change root to some "safe" directory */
2532 if (m->m_rootdir != NULL)
2534 expand(m->m_rootdir, cbuf, sizeof(cbuf), e);
2536 sm_dprintf("openmailer: chroot %s\n",
2538 if (chroot(cbuf) < 0)
2540 syserr("openmailer: Cannot chroot(%s)",
2546 syserr("openmailer: cannot chdir(/)");
2553 sm_mbdb_terminate();
2554 if (bitnset(M_SPECIFIC_UID, m->m_flags))
2556 if (m->m_uid == NO_UID)
2557 new_euid = RunAsUid;
2559 new_euid = m->m_uid;
2562 ** Undo the effects of the uid change in main
2563 ** for signal handling. The real uid may
2564 ** be used by mailer in adding a "From "
2568 if (RealUid != 0 && RealUid != getuid())
2570 # if MAILER_SETUID_METHOD == USE_SETEUID
2572 if (setreuid(RealUid, geteuid()) < 0)
2574 syserr("openmailer: setreuid(%d, %d) failed",
2575 (int) RealUid, (int) geteuid());
2578 # endif /* HASSETREUID */
2579 # endif /* MAILER_SETUID_METHOD == USE_SETEUID */
2580 # if MAILER_SETUID_METHOD == USE_SETREUID
2582 # endif /* MAILER_SETUID_METHOD == USE_SETREUID */
2585 else if (bitset(S_ISUID, stb.st_mode))
2586 new_ruid = stb.st_uid;
2587 else if (ctladdr != NULL && ctladdr->q_uid != 0)
2588 new_ruid = ctladdr->q_uid;
2589 else if (m->m_uid != NO_UID)
2590 new_ruid = m->m_uid;
2594 # if _FFR_USE_SETLOGIN
2595 /* run disconnected from terminal and set login name */
2596 if (setsid() >= 0 &&
2597 ctladdr != NULL && ctladdr->q_uid != 0 &&
2598 new_euid == ctladdr->q_uid)
2602 pwd = sm_getpwuid(ctladdr->q_uid);
2603 if (pwd != NULL && suidwarn)
2604 (void) setlogin(pwd->pw_name);
2607 # endif /* _FFR_USE_SETLOGIN */
2609 if (new_euid != NO_UID)
2611 if (RunAsUid != 0 && new_euid != RunAsUid)
2613 /* Only root can change the uid */
2614 syserr("openmailer: insufficient privileges to change uid, new_euid=%d, RunAsUid=%d",
2615 (int) new_euid, (int) RunAsUid);
2619 vendor_set_uid(new_euid);
2620 # if MAILER_SETUID_METHOD == USE_SETEUID
2621 if (seteuid(new_euid) < 0 && suidwarn)
2623 syserr("openmailer: seteuid(%ld) failed",
2627 # endif /* MAILER_SETUID_METHOD == USE_SETEUID */
2628 # if MAILER_SETUID_METHOD == USE_SETREUID
2629 if (setreuid(new_ruid, new_euid) < 0 && suidwarn)
2631 syserr("openmailer: setreuid(%ld, %ld) failed",
2632 (long) new_ruid, (long) new_euid);
2635 # endif /* MAILER_SETUID_METHOD == USE_SETREUID */
2636 # if MAILER_SETUID_METHOD == USE_SETUID
2637 if (new_euid != geteuid() && setuid(new_euid) < 0 && suidwarn)
2639 syserr("openmailer: setuid(%ld) failed",
2643 # endif /* MAILER_SETUID_METHOD == USE_SETUID */
2645 else if (new_ruid != NO_UID)
2647 vendor_set_uid(new_ruid);
2648 if (setuid(new_ruid) < 0 && suidwarn)
2650 syserr("openmailer: setuid(%ld) failed",
2657 sm_dprintf("openmailer: running as r/euid=%d/%d, r/egid=%d/%d\n",
2658 (int) getuid(), (int) geteuid(),
2659 (int) getgid(), (int) getegid());
2661 /* move into some "safe" directory */
2662 if (m->m_execdir != NULL)
2666 for (p = m->m_execdir; p != NULL; p = q)
2671 expand(p, cbuf, sizeof(cbuf), e);
2675 sm_dprintf("openmailer: trydir %s\n",
2677 if (cbuf[0] != '\0' &&
2683 /* Check safety of program to be run */
2684 sff = SFF_ROOTOK|SFF_EXECOK;
2685 if (!bitnset(DBS_RUNWRITABLEPROGRAM,
2687 sff |= SFF_NOGWFILES|SFF_NOWWFILES;
2688 if (bitnset(DBS_RUNPROGRAMINUNSAFEDIRPATH,
2690 sff |= SFF_NOPATHCHECK;
2692 sff |= SFF_SAFEDIRPATH;
2693 ret = safefile(m->m_mailer, getuid(), getgid(),
2694 user, sff, 0, NULL);
2696 sm_syslog(LOG_INFO, e->e_id,
2697 "Warning: program %s unsafe: %s",
2698 m->m_mailer, sm_errstring(ret));
2700 /* arrange to filter std & diag output of command */
2701 (void) close(rpvect[0]);
2702 if (dup2(rpvect[1], STDOUT_FILENO) < 0)
2704 syserr("%s... openmailer(%s): cannot dup pipe %d for stdout",
2705 shortenstring(e->e_to, MAXSHORTSTR),
2706 m->m_name, rpvect[1]);
2709 (void) close(rpvect[1]);
2711 if (dup2(STDOUT_FILENO, STDERR_FILENO) < 0)
2713 syserr("%s... openmailer(%s): cannot dup stdout for stderr",
2714 shortenstring(e->e_to, MAXSHORTSTR),
2719 /* arrange to get standard input */
2720 (void) close(mpvect[1]);
2721 if (dup2(mpvect[0], STDIN_FILENO) < 0)
2723 syserr("%s... openmailer(%s): cannot dup pipe %d for stdin",
2724 shortenstring(e->e_to, MAXSHORTSTR),
2725 m->m_name, mpvect[0]);
2728 (void) close(mpvect[0]);
2730 /* arrange for all the files to be closed */
2731 sm_close_on_exec(STDERR_FILENO + 1, DtableSize);
2733 # if !_FFR_USE_SETLOGIN
2734 /* run disconnected from terminal */
2736 # endif /* !_FFR_USE_SETLOGIN */
2738 /* try to execute the mailer */
2739 (void) execve(m->m_mailer, (ARGV_T) pv,
2740 (ARGV_T) UserEnviron);
2742 syserr("Cannot exec %s", m->m_mailer);
2743 if (bitnset(M_LOCALMAILER, m->m_flags) ||
2744 transienterror(save_errno))
2746 _exit(EX_UNAVAILABLE);
2750 ** Set up return value.
2758 ** Allocate from general heap, not
2759 ** envelope rpool, because this mci
2760 ** is going to be cached.
2763 mci = mci_new(NULL);
2768 ** Prevent a storage leak by allocating
2769 ** this from the envelope rpool.
2772 mci = mci_new(e->e_rpool);
2775 mci->mci_mailer = m;
2778 mci->mci_state = MCIS_OPENING;
2783 mci->mci_state = MCIS_OPEN;
2786 (void) close(mpvect[0]);
2787 mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2788 (void *) &(mpvect[1]), SM_IO_WRONLY_B,
2790 if (mci->mci_out == NULL)
2792 syserr("deliver: cannot create mailer output channel, fd=%d",
2794 (void) close(mpvect[1]);
2795 (void) close(rpvect[0]);
2796 (void) close(rpvect[1]);
2801 (void) close(rpvect[1]);
2802 mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2803 (void *) &(rpvect[0]), SM_IO_RDONLY_B,
2805 if (mci->mci_in == NULL)
2807 syserr("deliver: cannot create mailer input channel, fd=%d",
2809 (void) close(rpvect[0]);
2810 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
2811 mci->mci_out = NULL;
2818 ** If we are in SMTP opening state, send initial protocol.
2821 if (bitnset(M_7BITS, m->m_flags) &&
2822 (!clever || mci->mci_state == MCIS_OPENING))
2823 mci->mci_flags |= MCIF_7BIT;
2824 if (clever && mci->mci_state != MCIS_CLOSED)
2826 # if STARTTLS || SASL
2829 extern SOCKADDR CurHostAddr;
2830 # endif /* STARTTLS || SASL */
2833 # define DONE_AUTH(f) bitset(MCIF_AUTHACT, f)
2836 # define DONE_STARTTLS(f) bitset(MCIF_TLSACT, f)
2837 # endif /* STARTTLS */
2838 # define ONLY_HELO(f) bitset(MCIF_ONLY_EHLO, f)
2839 # define SET_HELO(f) f |= MCIF_ONLY_EHLO
2840 # define CLR_HELO(f) f &= ~MCIF_ONLY_EHLO
2842 # if STARTTLS || SASL
2843 /* don't use CurHostName, it is changed in many places */
2844 if (mci->mci_host != NULL)
2846 srvname = mci->mci_host;
2847 dotpos = strlen(srvname) - 1;
2850 if (srvname[dotpos] == '.')
2851 srvname[dotpos] = '\0';
2856 else if (mci->mci_mailer != NULL)
2858 srvname = mci->mci_mailer->m_name;
2867 /* don't set {server_name} to NULL or "": see getauth() */
2868 macdefine(&mci->mci_macro, A_TEMP, macid("{server_name}"),
2871 /* CurHostAddr is set by makeconnection() and mci_get() */
2872 if (CurHostAddr.sa.sa_family != 0)
2874 macdefine(&mci->mci_macro, A_TEMP,
2875 macid("{server_addr}"),
2876 anynet_ntoa(&CurHostAddr));
2878 else if (mci->mci_mailer != NULL)
2880 /* mailer name is unique, use it as address */
2881 macdefine(&mci->mci_macro, A_PERM,
2882 macid("{server_addr}"),
2883 mci->mci_mailer->m_name);
2887 /* don't set it to NULL or "": see getauth() */
2888 macdefine(&mci->mci_macro, A_PERM,
2889 macid("{server_addr}"), "0");
2892 /* undo change of srvname (mci->mci_host) */
2894 srvname[dotpos] = '.';
2896 reconnect: /* after switching to an encrypted connection */
2897 # endif /* STARTTLS || SASL */
2899 /* set the current connection information */
2902 mci->mci_saslcap = NULL;
2904 smtpinit(m, mci, e, ONLY_HELO(mci->mci_flags));
2905 CLR_HELO(mci->mci_flags);
2907 if (IS_DLVR_RETURN(e))
2910 ** Check whether other side can deliver e-mail
2914 if (!bitset(MCIF_DLVR_BY, mci->mci_flags))
2916 e->e_status = "5.4.7";
2917 usrerrenh(e->e_status,
2918 "554 Server does not support Deliver By");
2919 rcode = EX_UNAVAILABLE;
2922 if (e->e_deliver_by > 0 &&
2923 e->e_deliver_by - (curtime() - e->e_ctime) <
2926 e->e_status = "5.4.7";
2927 usrerrenh(e->e_status,
2928 "554 Message can't be delivered in time; %ld < %ld",
2929 e->e_deliver_by - (curtime() - e->e_ctime),
2931 rcode = EX_UNAVAILABLE;
2937 /* first TLS then AUTH to provide a security layer */
2938 if (mci->mci_state != MCIS_CLOSED &&
2939 !DONE_STARTTLS(mci->mci_flags))
2943 bool saveQuickAbort = QuickAbort;
2944 bool saveSuprErrs = SuprErrs;
2948 usetls = bitset(MCIF_TLS, mci->mci_flags);
2950 usetls = !iscltflgset(e, D_NOTLS);
2952 host = macvalue(macid("{server_name}"), e);
2958 if (rscheck("try_tls", host, NULL, e,
2959 RSF_RMCOMM, 7, host, NOQID, NULL)
2961 || Errors > olderrors)
2965 SuprErrs = saveSuprErrs;
2966 QuickAbort = saveQuickAbort;
2971 if ((rcode = starttls(m, mci, e)) == EX_OK)
2973 /* start again without STARTTLS */
2974 mci->mci_flags |= MCIF_TLSACT;
2981 ** TLS negotation failed, what to do?
2982 ** fall back to unencrypted connection
2983 ** or abort? How to decide?
2984 ** set a macro and call a ruleset.
2987 mci->mci_flags &= ~MCIF_TLS;
3002 case EX_UNAVAILABLE:
3006 /* everything else is a failure */
3009 rcode = EX_TEMPFAIL;
3011 macdefine(&e->e_macro, A_PERM,
3012 macid("{verify}"), s);
3016 macdefine(&e->e_macro, A_PERM,
3017 macid("{verify}"), "NONE");
3023 ** rcode == EX_SOFTWARE is special:
3024 ** the TLS negotation failed
3025 ** we have to drop the connection no matter what
3026 ** However, we call tls_server to give it the chance
3027 ** to log the problem and return an appropriate
3031 if (rscheck("tls_server",
3032 macvalue(macid("{verify}"), e),
3033 NULL, e, RSF_RMCOMM|RSF_COUNT, 5,
3034 host, NOQID, NULL) != EX_OK ||
3035 Errors > olderrors ||
3036 rcode == EX_SOFTWARE)
3038 char enhsc[ENHSCLEN];
3039 extern char MsgBuf[];
3041 if (ISSMTPCODE(MsgBuf) &&
3042 extenhsc(MsgBuf + 4, ' ', enhsc) > 0)
3044 p = sm_rpool_strdup_x(e->e_rpool,
3049 p = "403 4.7.0 server not authenticated.";
3050 (void) sm_strlcpy(enhsc, "4.7.0",
3053 SuprErrs = saveSuprErrs;
3054 QuickAbort = saveQuickAbort;
3056 if (rcode == EX_SOFTWARE)
3058 /* drop the connection */
3059 mci->mci_state = MCIS_QUITING;
3060 if (mci->mci_in != NULL)
3062 (void) sm_io_close(mci->mci_in,
3066 mci->mci_flags &= ~MCIF_TLSACT;
3067 (void) endmailer(mci, e, pv);
3071 /* abort transfer */
3072 smtpquit(m, mci, e);
3075 /* avoid bogus error msg */
3078 /* temp or permanent failure? */
3079 rcode = (*p == '4') ? EX_TEMPFAIL
3081 mci_setstat(mci, rcode, enhsc, p);
3084 ** hack to get the error message into
3085 ** the envelope (done in giveresponse())
3088 (void) sm_strlcpy(SmtpError, p,
3091 else if (mci->mci_state == MCIS_CLOSED)
3093 /* connection close caused by 421 */
3095 rcode = EX_TEMPFAIL;
3096 mci_setstat(mci, rcode, NULL, "421");
3101 QuickAbort = saveQuickAbort;
3102 SuprErrs = saveSuprErrs;
3103 if (DONE_STARTTLS(mci->mci_flags) &&
3104 mci->mci_state != MCIS_CLOSED)
3106 SET_HELO(mci->mci_flags);
3107 mci->mci_flags &= ~MCIF_EXTENS;
3111 # endif /* STARTTLS */
3113 /* if other server supports authentication let's authenticate */
3114 if (mci->mci_state != MCIS_CLOSED &&
3115 mci->mci_saslcap != NULL &&
3116 !DONE_AUTH(mci->mci_flags) && !iscltflgset(e, D_NOAUTH))
3118 /* Should we require some minimum authentication? */
3119 if ((ret = smtpauth(m, mci, e)) == EX_OK)
3122 sasl_ssf_t *ssf = NULL;
3124 /* Get security strength (features) */
3125 result = sasl_getprop(mci->mci_conn, SASL_SSF,
3127 (const void **) &ssf);
3128 # else /* SASL >= 20000 */
3130 # endif /* SASL >= 20000 */
3134 sm_syslog(LOG_INFO, NOQID,
3135 "AUTH=client, relay=%.100s, mech=%.16s, bits=%d",
3137 macvalue(macid("{auth_type}"), e),
3138 result == SASL_OK ? *ssf : 0);
3141 ** Only switch to encrypted connection
3142 ** if a security layer has been negotiated
3145 if (result == SASL_OK && *ssf > 0)
3150 ** Convert I/O layer to use SASL.
3151 ** If the call fails, the connection
3155 tmo = DATA_PROGRESS_TIMEOUT * 1000;
3156 if (sfdcsasl(&mci->mci_in,
3158 mci->mci_conn, tmo) == 0)
3160 mci->mci_flags &= ~MCIF_EXTENS;
3161 mci->mci_flags |= MCIF_AUTHACT|
3165 syserr("AUTH TLS switch failed in client");
3168 mci->mci_flags |= MCIF_AUTHACT;
3171 else if (ret == EX_TEMPFAIL)
3174 sm_syslog(LOG_ERR, NOQID,
3175 "AUTH=client, relay=%.100s, temporary failure, connection abort",
3177 smtpquit(m, mci, e);
3179 /* avoid bogus error msg */
3181 rcode = EX_TEMPFAIL;
3182 mci_setstat(mci, rcode, "4.3.0", p);
3185 ** hack to get the error message into
3186 ** the envelope (done in giveresponse())
3189 (void) sm_strlcpy(SmtpError,
3190 "Temporary AUTH failure",
3199 /* clear out per-message flags from connection structure */
3200 mci->mci_flags &= ~(MCIF_CVT7TO8|MCIF_CVT8TO7);
3202 if (bitset(EF_HAS8BIT, e->e_flags) &&
3203 !bitset(EF_DONT_MIME, e->e_flags) &&
3204 bitnset(M_7BITS, m->m_flags))
3205 mci->mci_flags |= MCIF_CVT8TO7;
3208 if (bitnset(M_MAKE8BIT, m->m_flags) &&
3209 !bitset(MCIF_7BIT, mci->mci_flags) &&
3210 (p = hvalue("Content-Transfer-Encoding", e->e_header)) != NULL &&
3211 (sm_strcasecmp(p, "quoted-printable") == 0 ||
3212 sm_strcasecmp(p, "base64") == 0) &&
3213 (p = hvalue("Content-Type", e->e_header)) != NULL)
3215 /* may want to convert 7 -> 8 */
3216 /* XXX should really parse it here -- and use a class XXX */
3217 if (sm_strncasecmp(p, "text/plain", 10) == 0 &&
3218 (p[10] == '\0' || p[10] == ' ' || p[10] == ';'))
3219 mci->mci_flags |= MCIF_CVT7TO8;
3221 #endif /* MIME7TO8 */
3225 sm_dprintf("openmailer: ");
3226 mci_dump(sm_debug_file(), mci, false);
3229 #if _FFR_CLIENT_SIZE
3231 ** See if we know the maximum size and
3232 ** abort if the message is too big.
3234 ** NOTE: _FFR_CLIENT_SIZE is untested.
3237 if (bitset(MCIF_SIZE, mci->mci_flags) &&
3238 mci->mci_maxsize > 0 &&
3239 e->e_msgsize > mci->mci_maxsize)
3241 e->e_flags |= EF_NO_BODY_RETN;
3242 if (bitnset(M_LOCALMAILER, m->m_flags))
3243 e->e_status = "5.2.3";
3245 e->e_status = "5.3.4";
3247 usrerrenh(e->e_status,
3248 "552 Message is too large; %ld bytes max",
3252 /* Need an e_message for error */
3253 (void) sm_snprintf(SmtpError, sizeof(SmtpError),
3254 "Message is too large; %ld bytes max",
3258 #endif /* _FFR_CLIENT_SIZE */
3260 if (mci->mci_state != MCIS_OPEN)
3262 /* couldn't open the mailer */
3263 rcode = mci->mci_exitstat;
3264 errno = mci->mci_errno;
3265 SM_SET_H_ERRNO(mci->mci_herrno);
3268 /* shouldn't happen */
3269 syserr("554 5.3.5 deliver: mci=%lx rcode=%d errno=%d state=%d sig=%s",
3270 (unsigned long) mci, rcode, errno,
3271 mci->mci_state, firstsig);
3272 mci_dump_all(smioout, true);
3273 rcode = EX_SOFTWARE;
3275 else if (nummxhosts > hostnum)
3277 /* try next MX site */
3286 ** Format and send message.
3291 ok = putfromline(mci, e);
3293 ok = (*e->e_puthdr)(mci, e->e_header, e, M87F_OUTER);
3295 ok = (*e->e_putbody)(mci, e, NULL);
3298 ** Ignore an I/O error that was caused by EPIPE.
3299 ** Some broken mailers don't read the entire body
3300 ** but just exit() thus causing an I/O error.
3303 if (!ok && (sm_io_error(mci->mci_out) && errno == EPIPE))
3306 /* (always) get the exit status */
3307 rcode = endmailer(mci, e, pv);
3309 rcode = EX_TEMPFAIL;
3310 if (rcode == EX_TEMPFAIL && SmtpError[0] == '\0')
3313 ** Need an e_message for mailq display.
3314 ** We set SmtpError as
3317 (void) sm_snprintf(SmtpError, sizeof(SmtpError),
3318 "%s mailer (%s) exited with EX_TEMPFAIL",
3319 m->m_name, m->m_mailer);
3325 ** Send the MAIL FROM: protocol
3328 /* XXX this isn't pipelined... */
3329 rcode = smtpmailfrom(m, mci, e);
3334 ADDRESS *volatile pchain;
3335 # endif /* PIPELINING */
3337 /* send the recipient list */
3339 mci->mci_retryrcpt = false;
3340 mci->mci_tolist = tobuf;
3343 mci->mci_nextaddr = NULL;
3344 # endif /* PIPELINING */
3346 for (to = tochain; to != NULL; to = to->q_tchain)
3348 if (!QS_IS_UNMARKED(to->q_state))
3351 /* mark recipient state as "ok so far" */
3352 to->q_state = QS_OK;
3353 e->e_to = to->q_paddr;
3355 i = rscheck("tls_rcpt", to->q_user, NULL, e,
3356 RSF_RMCOMM|RSF_COUNT, 3,
3357 mci->mci_host, e->e_id, NULL);
3360 markfailure(e, to, mci, i, false);
3361 giveresponse(i, to->q_status, m, mci,
3362 ctladdr, xstart, e, to);
3363 if (i == EX_TEMPFAIL)
3365 mci->mci_retryrcpt = true;
3366 to->q_state = QS_RETRY;
3370 # endif /* STARTTLS */
3372 i = smtprcpt(to, m, mci, e, ctladdr, xstart);
3375 bitset(MCIF_PIPELINED, mci->mci_flags))
3378 ** Add new element to list of
3379 ** recipients for pipelining.
3382 to->q_pchain = NULL;
3383 if (mci->mci_nextaddr == NULL)
3384 mci->mci_nextaddr = to;
3389 pchain->q_pchain = to;
3390 pchain = pchain->q_pchain;
3393 # endif /* PIPELINING */
3396 markfailure(e, to, mci, i, false);
3397 giveresponse(i, to->q_status, m, mci,
3398 ctladdr, xstart, e, to);
3399 if (i == EX_TEMPFAIL)
3400 to->q_state = QS_RETRY;
3404 /* No recipients in list and no missing responses? */
3405 if (tobuf[0] == '\0'
3407 && mci->mci_nextaddr == NULL
3408 # endif /* PIPELINING */
3413 if (bitset(MCIF_CACHED, mci->mci_flags))
3414 smtprset(m, mci, e);
3418 e->e_to = tobuf + 1;
3419 rcode = smtpdata(m, mci, e, ctladdr, xstart);
3422 if (rcode == EX_TEMPFAIL && nummxhosts > hostnum)
3424 /* try next MX site */
3429 if (ConfigLevel < 2)
3430 _res.options |= RES_DEFNAMES | RES_DNSRCH; /* XXX */
3431 #endif /* NAMED_BIND */
3434 checkfds("after delivery");
3437 ** Do final status disposal.
3438 ** We check for something in tobuf for the SMTP case.
3439 ** If we got a temporary failure, arrange to queue the
3444 if (bitnset(M_LMTP, m->m_flags))
3452 anyok = rcode == EX_OK;
3454 for (to = tochain; to != NULL; to = to->q_tchain)
3456 /* see if address already marked */
3457 if (!QS_IS_OK(to->q_state))
3460 /* if running LMTP, get the status for each address */
3461 if (bitnset(M_LMTP, m->m_flags))
3463 if (lmtp_rcode == EX_OK)
3464 rcode = smtpgetstat(m, mci, e);
3467 strsize += sm_strlcat2(tobuf + strsize, ",",
3469 tobufsize - strsize);
3470 SM_ASSERT(strsize < tobufsize);
3475 e->e_to = to->q_paddr;
3476 markfailure(e, to, mci, rcode, true);
3477 giveresponse(rcode, to->q_status, m, mci,
3478 ctladdr, xstart, e, to);
3479 e->e_to = tobuf + 1;
3485 /* mark bad addresses */
3488 if (goodmxfound && rcode == EX_NOHOST)
3489 rcode = EX_TEMPFAIL;
3490 markfailure(e, to, mci, rcode, true);
3495 /* successful delivery */
3496 to->q_state = QS_SENT;
3497 to->q_statdate = curtime();
3501 ** Checkpoint the send list every few addresses
3504 if (CheckpointInterval > 0 && e->e_nsent >= CheckpointInterval)
3506 queueup(e, false, false);
3510 if (bitnset(M_LOCALMAILER, m->m_flags) &&
3511 bitset(QPINGONSUCCESS, to->q_flags))
3513 to->q_flags |= QDELIVERED;
3514 to->q_status = "2.1.5";
3515 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
3516 "%s... Successfully delivered\n",
3519 else if (bitset(QPINGONSUCCESS, to->q_flags) &&
3520 bitset(QPRIMARY, to->q_flags) &&
3521 !bitset(MCIF_DSN, mci->mci_flags))
3523 to->q_flags |= QRELAYED;
3524 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
3525 "%s... relayed; expect no further notifications\n",
3528 else if (IS_DLVR_NOTIFY(e) &&
3529 !bitset(MCIF_DLVR_BY, mci->mci_flags) &&
3530 bitset(QPRIMARY, to->q_flags) &&
3531 (!bitset(QHASNOTIFY, to->q_flags) ||
3532 bitset(QPINGONSUCCESS, to->q_flags) ||
3533 bitset(QPINGONFAILURE, to->q_flags) ||
3534 bitset(QPINGONDELAY, to->q_flags)))
3536 /* RFC 2852, 4.1.4.2: no NOTIFY, or not NEVER */
3537 to->q_flags |= QBYNRELAY;
3538 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
3539 "%s... Deliver-by notify: relayed\n",
3542 else if (IS_DLVR_TRACE(e) &&
3543 (!bitset(QHASNOTIFY, to->q_flags) ||
3544 bitset(QPINGONSUCCESS, to->q_flags) ||
3545 bitset(QPINGONFAILURE, to->q_flags) ||
3546 bitset(QPINGONDELAY, to->q_flags)) &&
3547 bitset(QPRIMARY, to->q_flags))
3549 /* RFC 2852, 4.1.4: no NOTIFY, or not NEVER */
3550 to->q_flags |= QBYTRACE;
3551 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
3552 "%s... Deliver-By trace: relayed\n",
3557 if (bitnset(M_LMTP, m->m_flags))
3560 ** Global information applies to the last recipient only;
3561 ** clear it out to avoid bogus errors.
3565 e->e_statmsg = NULL;
3567 /* reset the mci state for the next transaction */
3569 (mci->mci_state == MCIS_MAIL ||
3570 mci->mci_state == MCIS_RCPT ||
3571 mci->mci_state == MCIS_DATA))
3573 mci->mci_state = MCIS_OPEN;
3574 SmtpPhase = mci->mci_phase = "idle";
3575 sm_setproctitle(true, e, "%s: %s", CurHostName,
3580 if (tobuf[0] != '\0')
3582 giveresponse(rcode, NULL, m, mci, ctladdr, xstart, e, tochain);
3585 ** This code is disabled for now because I am not
3586 ** sure that copying status from the first recipient
3587 ** to all non-status'ed recipients is a good idea.
3590 if (tochain->q_message != NULL &&
3591 !bitnset(M_LMTP, m->m_flags) && rcode != EX_OK)
3593 for (to = tochain->q_tchain; to != NULL;
3596 /* see if address already marked */
3597 if (QS_IS_QUEUEUP(to->q_state) &&
3598 to->q_message == NULL)
3599 to->q_message = sm_rpool_strdup_x(e->e_rpool,
3600 tochain->q_message);
3606 markstats(e, tochain, STATS_NORMAL);
3607 mci_store_persistent(mci);
3609 /* Some recipients were tempfailed, try them on the next host */
3610 if (mci != NULL && mci->mci_retryrcpt && nummxhosts > hostnum)
3612 /* try next MX site */
3616 /* now close the connection */
3617 if (clever && mci != NULL && mci->mci_state != MCIS_CLOSED &&
3618 !bitset(MCIF_CACHED, mci->mci_flags))
3619 smtpquit(m, mci, e);
3626 ** Restore state and return.
3631 /* make absolutely certain 0, 1, and 2 are in use */
3632 (void) sm_snprintf(wbuf, sizeof(wbuf),
3633 "%s... end of deliver(%s)",
3634 e->e_to == NULL ? "NO-TO-LIST"
3635 : shortenstring(e->e_to,
3644 ** It was originally necessary to set macro 'g' to NULL
3645 ** because it previously pointed to an auto buffer.
3646 ** We don't do this any more, so this may be unnecessary.
3649 macdefine(&e->e_macro, A_PERM, 'g', (char *) NULL);
3657 ** MARKFAILURE -- mark a failure on a specific address.
3660 ** e -- the envelope we are sending.
3661 ** q -- the address to mark.
3662 ** mci -- mailer connection information.
3663 ** rcode -- the code signifying the particular failure.
3664 ** ovr -- override an existing code?
3670 ** marks the address (and possibly the envelope) with the
3671 ** failure so that an error will be returned or
3672 ** the message will be queued, as appropriate.
3676 markfailure(e, q, mci, rcode, ovr)
3677 register ENVELOPE *e;
3678 register ADDRESS *q;
3683 int save_errno = errno;
3684 char *status = NULL;
3685 char *rstatus = NULL;
3695 q->q_state = QS_QUEUEUP;
3699 q->q_state = QS_BADADDR;
3703 /* find most specific error code possible */
3704 if (mci != NULL && mci->mci_status != NULL)
3706 status = sm_rpool_strdup_x(e->e_rpool, mci->mci_status);
3707 if (mci->mci_rstatus != NULL)
3708 rstatus = sm_rpool_strdup_x(e->e_rpool,
3713 else if (e->e_status != NULL)
3715 status = e->e_status;
3744 case EX_UNAVAILABLE:
3764 if (status != NULL && *status != '\0' && (ovr || q->q_status == NULL ||
3765 *q->q_status == '\0' || *q->q_status < *status))
3767 q->q_status = status;
3768 q->q_rstatus = rstatus;
3770 if (rcode != EX_OK && q->q_rstatus == NULL &&
3771 q->q_mailer != NULL && q->q_mailer->m_diagtype != NULL &&
3772 sm_strcasecmp(q->q_mailer->m_diagtype, "X-UNIX") == 0)
3776 (void) sm_snprintf(buf, sizeof(buf), "%d", rcode);
3777 q->q_rstatus = sm_rpool_strdup_x(e->e_rpool, buf);
3780 q->q_statdate = curtime();
3781 if (CurHostName != NULL && CurHostName[0] != '\0' &&
3782 mci != NULL && !bitset(M_LOCALMAILER, mci->mci_flags))
3783 q->q_statmta = sm_rpool_strdup_x(e->e_rpool, CurHostName);
3789 ** ENDMAILER -- Wait for mailer to terminate.
3791 ** We should never get fatal errors (e.g., segmentation
3792 ** violation), so we report those specially. For other
3793 ** errors, we choose a status message (into statmsg),
3794 ** and if it represents an error, we print it.
3797 ** mci -- the mailer connection info.
3798 ** e -- the current envelope.
3799 ** pv -- the parameter vector that invoked the mailer
3800 ** (for error messages).
3803 ** exit code of mailer.
3809 static jmp_buf EndWaitTimeout;
3812 endwaittimeout(ignore)
3816 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
3817 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
3822 longjmp(EndWaitTimeout, 1);
3826 endmailer(mci, e, pv)
3828 register ENVELOPE *e;
3832 int save_errno = errno;
3834 SM_EVENT *ev = NULL;
3837 mci_unlock_host(mci);
3839 /* close output to mailer */
3840 if (mci->mci_out != NULL)
3842 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
3843 mci->mci_out = NULL;
3846 /* copy any remaining input to transcript */
3847 if (mci->mci_in != NULL && mci->mci_state != MCIS_ERROR &&
3850 while (sfgets(buf, sizeof(buf), mci->mci_in,
3851 TimeOuts.to_quit, "Draining Input") != NULL)
3852 (void) sm_io_fputs(e->e_xfp, SM_TIME_DEFAULT, buf);
3856 /* close SASL connection */
3857 if (bitset(MCIF_AUTHACT, mci->mci_flags))
3859 sasl_dispose(&mci->mci_conn);
3860 mci->mci_flags &= ~MCIF_AUTHACT;
3866 (void) endtlsclt(mci);
3867 #endif /* STARTTLS */
3869 /* now close the input */
3870 if (mci->mci_in != NULL)
3872 (void) sm_io_close(mci->mci_in, SM_TIME_DEFAULT);
3875 mci->mci_state = MCIS_CLOSED;
3879 /* in the IPC case there is nothing to wait for */
3880 if (mci->mci_pid == 0)
3883 /* put a timeout around the wait */
3884 if (mci->mci_mailer->m_wait > 0)
3886 if (setjmp(EndWaitTimeout) == 0)
3887 ev = sm_setevent(mci->mci_mailer->m_wait,
3891 syserr("endmailer %s: wait timeout (%ld)",
3892 mci->mci_mailer->m_name,
3893 (long) mci->mci_mailer->m_wait);
3898 /* wait for the mailer process, collect status */
3899 st = waitfor(mci->mci_pid);
3907 syserr("endmailer %s: wait", mci->mci_mailer->m_name);
3913 /* normal death -- return status */
3914 return (WEXITSTATUS(st));
3917 /* it died a horrid death */
3918 syserr("451 4.3.0 mailer %s died with signal %d%s",
3919 mci->mci_mailer->m_name, WTERMSIG(st),
3920 WCOREDUMP(st) ? " (core dumped)" :
3921 (WIFSTOPPED(st) ? " (stopped)" : ""));
3923 /* log the arguments */
3924 if (pv != NULL && e->e_xfp != NULL)
3928 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, "Arguments:");
3929 for (av = pv; *av != NULL; av++)
3930 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, " %s",
3932 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, "\n");
3935 ExitStat = EX_TEMPFAIL;
3939 ** GIVERESPONSE -- Interpret an error response from a mailer
3942 ** status -- the status code from the mailer (high byte
3943 ** only; core dumps must have been taken care of
3945 ** dsn -- the DSN associated with the address, if any.
3946 ** m -- the mailer info for this mailer.
3947 ** mci -- the mailer connection info -- can be NULL if the
3948 ** response is given before the connection is made.
3949 ** ctladdr -- the controlling address for the recipient
3951 ** xstart -- the transaction start time, for computing
3952 ** transaction delays.
3953 ** e -- the current envelope.
3954 ** to -- the current recipient (NULL if none).
3960 ** Errors may be incremented.
3961 ** ExitStat may be set.
3965 giveresponse(status, dsn, m, mci, ctladdr, xstart, e, to)
3975 register const char *statmsg;
3978 bool usestat = false;
3979 char dsnbuf[ENHSCLEN];
3985 syserr("giveresponse: null envelope");
3991 ** Compute status message from code.
3994 exmsg = sm_sysexmsg(status);
3997 statmsg = "250 2.0.0 Sent";
3998 if (e->e_statmsg != NULL)
4000 (void) sm_snprintf(buf, sizeof(buf), "%s (%s)",
4002 shortenstring(e->e_statmsg, 403));
4006 else if (exmsg == NULL)
4008 (void) sm_snprintf(buf, sizeof(buf),
4009 "554 5.3.0 unknown mailer error %d",
4011 status = EX_UNAVAILABLE;
4015 else if (status == EX_TEMPFAIL)
4019 (void) sm_strlcpy(bp, exmsg + 1, SPACELEFT(buf, bp));
4022 if (h_errno == TRY_AGAIN)
4023 statmsg = sm_errstring(h_errno + E_DNSBASE);
4025 #endif /* NAMED_BIND */
4028 statmsg = sm_errstring(errnum);
4030 statmsg = SmtpError;
4032 if (statmsg != NULL && statmsg[0] != '\0')
4037 case ENETDOWN: /* Network is down */
4038 #endif /* ENETDOWN */
4040 case ENETUNREACH: /* Network is unreachable */
4041 #endif /* ENETUNREACH */
4043 case ENETRESET: /* Network dropped connection on reset */
4044 #endif /* ENETRESET */
4046 case ECONNABORTED: /* Software caused connection abort */
4047 #endif /* ECONNABORTED */
4049 case EHOSTDOWN: /* Host is down */
4050 #endif /* EHOSTDOWN */
4052 case EHOSTUNREACH: /* No route to host */
4053 #endif /* EHOSTUNREACH */
4054 if (mci != NULL && mci->mci_host != NULL)
4056 (void) sm_strlcpyn(bp,
4064 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ": ",
4071 else if (status == EX_NOHOST && h_errno != 0)
4073 statmsg = sm_errstring(h_errno + E_DNSBASE);
4074 (void) sm_snprintf(buf, sizeof(buf), "%s (%s)", exmsg + 1,
4079 #endif /* NAMED_BIND */
4083 if (*statmsg++ == ':' && errnum != 0)
4085 (void) sm_snprintf(buf, sizeof(buf), "%s: %s", statmsg,
4086 sm_errstring(errnum));
4090 else if (bitnset(M_LMTP, m->m_flags) && e->e_statmsg != NULL)
4092 (void) sm_snprintf(buf, sizeof(buf), "%s (%s)", statmsg,
4093 shortenstring(e->e_statmsg, 403));
4100 ** Print the message as appropriate
4103 if (status == EX_OK || status == EX_TEMPFAIL)
4105 extern char MsgBuf[];
4107 if ((off = isenhsc(statmsg + 4, ' ')) > 0)
4111 (void) sm_snprintf(dsnbuf, sizeof(dsnbuf),
4112 "%.*s", off, statmsg + 4);
4121 message("%s", statmsg + off);
4122 if (status == EX_TEMPFAIL && e->e_xfp != NULL)
4123 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, "%s\n",
4128 char mbuf[ENHSCLEN + 4];
4131 if ((off = isenhsc(statmsg + 4, ' ')) > 0 &&
4132 off < sizeof(mbuf) - 4)
4136 (void) sm_snprintf(dsnbuf, sizeof(dsnbuf),
4137 "%.*s", off, statmsg + 4);
4142 /* copy only part of statmsg to mbuf */
4143 (void) sm_strlcpy(mbuf, statmsg, off);
4144 (void) sm_strlcat(mbuf, " %s", sizeof(mbuf));
4149 (void) sm_snprintf(mbuf, sizeof(mbuf), "%.3s %%s",
4153 usrerr(mbuf, &statmsg[off]);
4158 ** Log a record of the transaction. Compute the new
4159 ** ExitStat -- if we already had an error, stick with
4163 if (OpMode != MD_VERIFY && !bitset(EF_VRFYONLY, e->e_flags) &&
4164 LogLevel > ((status == EX_TEMPFAIL) ? 8 : (status == EX_OK) ? 7 : 6))
4165 logdelivery(m, mci, dsn, statmsg + off, ctladdr, xstart, e);
4168 sm_dprintf("giveresponse: status=%d, dsn=%s, e->e_message=%s, errnum=%d\n",
4170 dsn == NULL ? "<NULL>" : dsn,
4171 e->e_message == NULL ? "<NULL>" : e->e_message,
4174 if (status != EX_TEMPFAIL)
4176 if (status != EX_OK && (status != EX_TEMPFAIL || e->e_message == NULL))
4177 e->e_message = sm_rpool_strdup_x(e->e_rpool, statmsg + off);
4178 if (status != EX_OK && to != NULL && to->q_message == NULL)
4180 if (!usestat && e->e_message != NULL)
4181 to->q_message = sm_rpool_strdup_x(e->e_rpool,
4184 to->q_message = sm_rpool_strdup_x(e->e_rpool,
4191 ** LOGDELIVERY -- log the delivery in the system log
4193 ** Care is taken to avoid logging lines that are too long, because
4194 ** some versions of syslog have an unfortunate proclivity for core
4195 ** dumping. This is a hack, to be sure, that is at best empirical.
4198 ** m -- the mailer info. Can be NULL for initial queue.
4199 ** mci -- the mailer connection info -- can be NULL if the
4200 ** log is occurring when no connection is active.
4201 ** dsn -- the DSN attached to the status.
4202 ** status -- the message to print for the status.
4203 ** ctladdr -- the controlling address for the to list.
4204 ** xstart -- the transaction start time, used for
4205 ** computing transaction delay.
4206 ** e -- the current envelope.
4216 logdelivery(m, mci, dsn, status, ctladdr, xstart, e)
4223 register ENVELOPE *e;
4228 time_t now = curtime();
4231 #if (SYSLOG_BUFSIZE) >= 256
4232 /* ctladdr: max 106 bytes */
4234 if (ctladdr != NULL)
4236 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", ctladdr=",
4237 shortenstring(ctladdr->q_paddr, 83));
4239 if (bitset(QGOODUID, ctladdr->q_flags))
4241 (void) sm_snprintf(bp, SPACELEFT(buf, bp), " (%d/%d)",
4242 (int) ctladdr->q_uid,
4243 (int) ctladdr->q_gid);
4248 /* delay & xdelay: max 41 bytes */
4249 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", delay=",
4250 pintvl(now - e->e_ctime, true));
4253 if (xstart != (time_t) 0)
4255 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", xdelay=",
4256 pintvl(now - xstart, true));
4260 /* mailer: assume about 19 bytes (max 10 byte mailer name) */
4263 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", mailer=",
4268 /* pri: changes with each delivery attempt */
4269 (void) sm_snprintf(bp, SPACELEFT(buf, bp), ", pri=%ld",
4273 /* relay: max 66 bytes for IPv4 addresses */
4274 if (mci != NULL && mci->mci_host != NULL)
4276 extern SOCKADDR CurHostAddr;
4278 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", relay=",
4279 shortenstring(mci->mci_host, 40));
4282 if (CurHostAddr.sa.sa_family != 0)
4284 (void) sm_snprintf(bp, SPACELEFT(buf, bp), " [%s]",
4285 anynet_ntoa(&CurHostAddr));
4288 else if (strcmp(status, "quarantined") == 0)
4290 if (e->e_quarmsg != NULL)
4291 (void) sm_snprintf(bp, SPACELEFT(buf, bp),
4293 shortenstring(e->e_quarmsg, 40));
4295 else if (strcmp(status, "queued") != 0)
4297 p = macvalue('h', e);
4298 if (p != NULL && p[0] != '\0')
4300 (void) sm_snprintf(bp, SPACELEFT(buf, bp),
4301 ", relay=%s", shortenstring(p, 40));
4307 if (dsn != NULL && *dsn != '\0')
4309 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", dsn=",
4310 shortenstring(dsn, ENHSCLEN));
4316 if (e->e_ntries >= 0)
4318 (void) sm_snprintf(bp, SPACELEFT(buf, bp),
4319 ", ntries=%d", e->e_ntries + 1);
4322 #endif /* _FFR_LOG_NTRIES */
4324 # define STATLEN (((SYSLOG_BUFSIZE) - 100) / 4)
4328 # endif /* (STATLEN) < 63 */
4329 # if (STATLEN) > 203
4331 # define STATLEN 203
4332 # endif /* (STATLEN) > 203 */
4334 /* stat: max 210 bytes */
4335 if ((bp - buf) > (sizeof(buf) - ((STATLEN) + 20)))
4337 /* desperation move -- truncate data */
4338 bp = buf + sizeof(buf) - ((STATLEN) + 17);
4339 (void) sm_strlcpy(bp, "...", SPACELEFT(buf, bp));
4343 (void) sm_strlcpy(bp, ", stat=", SPACELEFT(buf, bp));
4346 (void) sm_strlcpy(bp, shortenstring(status, STATLEN),
4347 SPACELEFT(buf, bp));
4349 /* id, to: max 13 + TOBUFSIZE bytes */
4350 l = SYSLOG_BUFSIZE - 100 - strlen(buf);
4353 p = e->e_to == NULL ? "NO-TO-LIST" : e->e_to;
4354 while (strlen(p) >= l)
4358 for (q = p + l; q > p; q--)
4365 sm_syslog(LOG_INFO, e->e_id, "to=%.*s [more]%s",
4366 (int) (++q - p), p, buf);
4369 sm_syslog(LOG_INFO, e->e_id, "to=%.*s%s", l, p, buf);
4371 #else /* (SYSLOG_BUFSIZE) >= 256 */
4373 l = SYSLOG_BUFSIZE - 85;
4376 p = e->e_to == NULL ? "NO-TO-LIST" : e->e_to;
4377 while (strlen(p) >= l)
4381 for (q = p + l; q > p; q--)
4389 sm_syslog(LOG_INFO, e->e_id, "to=%.*s [more]",
4390 (int) (++q - p), p);
4393 sm_syslog(LOG_INFO, e->e_id, "to=%.*s", l, p);
4395 if (ctladdr != NULL)
4398 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, "ctladdr=",
4399 shortenstring(ctladdr->q_paddr, 83));
4401 if (bitset(QGOODUID, ctladdr->q_flags))
4403 (void) sm_snprintf(bp, SPACELEFT(buf, bp), " (%d/%d)",
4404 ctladdr->q_uid, ctladdr->q_gid);
4407 sm_syslog(LOG_INFO, e->e_id, "%s", buf);
4410 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, "delay=",
4411 pintvl(now - e->e_ctime, true));
4413 if (xstart != (time_t) 0)
4415 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", xdelay=",
4416 pintvl(now - xstart, true));
4422 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", mailer=",
4426 sm_syslog(LOG_INFO, e->e_id, "%.1000s", buf);
4430 if (mci != NULL && mci->mci_host != NULL)
4432 extern SOCKADDR CurHostAddr;
4434 (void) sm_snprintf(bp, SPACELEFT(buf, bp), "relay=%.100s",
4438 if (CurHostAddr.sa.sa_family != 0)
4439 (void) sm_snprintf(bp, SPACELEFT(buf, bp),
4441 anynet_ntoa(&CurHostAddr));
4443 else if (strcmp(status, "quarantined") == 0)
4445 if (e->e_quarmsg != NULL)
4446 (void) sm_snprintf(bp, SPACELEFT(buf, bp),
4447 ", quarantine=%.100s",
4450 else if (strcmp(status, "queued") != 0)
4452 p = macvalue('h', e);
4453 if (p != NULL && p[0] != '\0')
4454 (void) sm_snprintf(buf, sizeof(buf), "relay=%.100s", p);
4457 sm_syslog(LOG_INFO, e->e_id, "%.1000s", buf);
4459 sm_syslog(LOG_INFO, e->e_id, "stat=%s", shortenstring(status, 63));
4460 #endif /* (SYSLOG_BUFSIZE) >= 256 */
4463 ** PUTFROMLINE -- output a UNIX-style from line (or whatever)
4465 ** This can be made an arbitrary message separator by changing $l
4467 ** One of the ugliest hacks seen by human eyes is contained herein:
4468 ** UUCP wants those stupid "remote from <host>" lines. Why oh why
4469 ** does a well-meaning programmer such as myself have to deal with
4470 ** this kind of antique garbage????
4473 ** mci -- the connection information.
4474 ** e -- the envelope.
4477 ** true iff line was written successfully
4480 ** outputs some text to fp.
4488 char *template = UnixFromLine;
4492 if (bitnset(M_NHDR, mci->mci_mailer->m_flags))
4495 mci->mci_flags |= MCIF_INHEADER;
4497 if (bitnset(M_UGLYUUCP, mci->mci_mailer->m_flags))
4501 expand("\201g", buf, sizeof(buf), e);
4502 bang = strchr(buf, '!');
4506 char hname[MAXNAME];
4509 ** If we can construct a UUCP path, do so
4512 at = strrchr(buf, '@');
4515 expand("\201k", hname, sizeof(hname), e);
4520 (void) sm_snprintf(xbuf, sizeof(xbuf),
4521 "From %.800s \201d remote from %.100s\n",
4527 (void) sm_snprintf(xbuf, sizeof(xbuf),
4528 "From %.800s \201d remote from %.100s\n",
4533 expand(template, buf, sizeof(buf), e);
4534 return putxline(buf, strlen(buf), mci, PXLF_HEADER);
4538 ** PUTBODY -- put the body of a message.
4541 ** mci -- the connection information.
4542 ** e -- the envelope to put out.
4543 ** separator -- if non-NULL, a message separator that must
4544 ** not be permitted in the resulting message.
4547 ** true iff message was written successfully
4550 ** The message is written onto fp.
4553 /* values for output state variable */
4554 #define OSTATE_HEAD 0 /* at beginning of line */
4555 #define OSTATE_CR 1 /* read a carriage return */
4556 #define OSTATE_INLINE 2 /* putting rest of line */
4559 putbody(mci, e, separator)
4561 register ENVELOPE *e;
4569 char *boundaries[MAXMIMENESTING + 1];
4570 #endif /* MIME8TO7 */
4573 ** Output the body of the message
4576 if (e->e_dfp == NULL && bitset(EF_HAS_DF, e->e_flags))
4578 char *df = queuename(e, DATAFL_LETTER);
4580 e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, df,
4581 SM_IO_RDONLY_B, NULL);
4582 if (e->e_dfp == NULL)
4584 char *msg = "!putbody: Cannot open %s for %s from %s";
4586 if (errno == ENOENT)
4588 syserr(msg, df, e->e_to, e->e_from.q_paddr);
4592 if (e->e_dfp == NULL)
4594 if (bitset(MCIF_INHEADER, mci->mci_flags))
4596 if (!putline("", mci))
4598 mci->mci_flags &= ~MCIF_INHEADER;
4600 if (!putline("<<< No Message Collected >>>", mci))
4605 if (e->e_dfino == (ino_t) 0)
4609 if (fstat(sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL), &stbuf)
4614 e->e_dfdev = stbuf.st_dev;
4615 e->e_dfino = stbuf.st_ino;
4619 /* paranoia: the data file should always be in a rewound state */
4620 (void) bfrewind(e->e_dfp);
4622 /* simulate an I/O timeout when used as source */
4627 if (bitset(MCIF_CVT8TO7, mci->mci_flags))
4630 ** Do 8 to 7 bit MIME conversion.
4633 /* make sure it looks like a MIME message */
4634 if (hvalue("MIME-Version", e->e_header) == NULL &&
4635 !putline("MIME-Version: 1.0", mci))
4638 if (hvalue("Content-Type", e->e_header) == NULL)
4640 (void) sm_snprintf(buf, sizeof(buf),
4641 "Content-Type: text/plain; charset=%s",
4643 if (!putline(buf, mci))
4647 /* now do the hard work */
4648 boundaries[0] = NULL;
4649 mci->mci_flags |= MCIF_INHEADER;
4650 if (mime8to7(mci, e->e_header, e, boundaries, M87F_OUTER, 0) ==
4655 else if (bitset(MCIF_CVT7TO8, mci->mci_flags))
4657 if (!mime7to8(mci, e->e_header, e))
4660 # endif /* MIME7TO8 */
4661 else if (MaxMimeHeaderLength > 0 || MaxMimeFieldLength > 0)
4663 bool oldsuprerrs = SuprErrs;
4665 /* Use mime8to7 to check multipart for MIME header overflows */
4666 boundaries[0] = NULL;
4667 mci->mci_flags |= MCIF_INHEADER;
4670 ** If EF_DONT_MIME is set, we have a broken MIME message
4671 ** and don't want to generate a new bounce message whose
4672 ** body propagates the broken MIME. We can't just not call
4673 ** mime8to7() as is done above since we need the security
4674 ** checks. The best we can do is suppress the errors.
4677 if (bitset(EF_DONT_MIME, e->e_flags))
4680 if (mime8to7(mci, e->e_header, e, boundaries,
4681 M87F_OUTER|M87F_NO8TO7, 0) == SM_IO_EOF)
4684 /* restore SuprErrs */
4685 SuprErrs = oldsuprerrs;
4688 #endif /* MIME8TO7 */
4700 if (bitset(MCIF_INHEADER, mci->mci_flags))
4702 if (!putline("", mci))
4704 mci->mci_flags &= ~MCIF_INHEADER;
4707 /* determine end of buffer; allow for short mailer lines */
4708 buflim = &buf[sizeof(buf) - 1];
4709 if (mci->mci_mailer->m_linelimit > 0 &&
4710 mci->mci_mailer->m_linelimit < sizeof(buf) - 1)
4711 buflim = &buf[mci->mci_mailer->m_linelimit - 1];
4713 /* copy temp file to output with mapping */
4714 ostate = OSTATE_HEAD;
4717 while (!sm_io_error(mci->mci_out) && !dead)
4721 else if ((c = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT))
4724 if (bitset(MCIF_7BIT, mci->mci_flags))
4731 mci->mci_mailer->m_flags))
4733 if (c != '\r' && c != '\n' && bp < buflim)
4739 /* check beginning of line for special cases */
4743 if (buf[0] == 'F' &&
4744 bitnset(M_ESCFROM, mci->mci_mailer->m_flags)
4745 && strncmp(buf, "From ", 5) == 0)
4749 if (buf[0] == '-' && buf[1] == '-' &&
4752 /* possible separator */
4753 int sl = strlen(separator);
4755 if (strncmp(&buf[2], separator, sl)
4759 if (buf[0] == '.' &&
4760 bitnset(M_XDOT, mci->mci_mailer->m_flags))
4765 /* now copy out saved line */
4766 if (TrafficLogFile != NULL)
4768 (void) sm_io_fprintf(TrafficLogFile,
4772 if (padc != SM_IO_EOF)
4773 (void) sm_io_putc(TrafficLogFile,
4776 for (xp = buf; xp < bp; xp++)
4777 (void) sm_io_putc(TrafficLogFile,
4779 (unsigned char) *xp);
4781 (void) sm_io_fputs(TrafficLogFile,
4783 mci->mci_mailer->m_eol);
4785 if (padc != SM_IO_EOF)
4787 if (sm_io_putc(mci->mci_out,
4788 SM_TIME_DEFAULT, padc)
4796 for (xp = buf; xp < bp; xp++)
4798 if (sm_io_putc(mci->mci_out,
4800 (unsigned char) *xp)
4811 if (sm_io_fputs(mci->mci_out,
4813 mci->mci_mailer->m_eol)
4823 SM_ASSERT(pbp < peekbuf +
4831 /* determine next state */
4833 ostate = OSTATE_HEAD;
4837 ostate = OSTATE_INLINE;
4844 if (sm_io_fputs(mci->mci_out,
4846 mci->mci_mailer->m_eol)
4850 if (TrafficLogFile != NULL)
4852 (void) sm_io_fputs(TrafficLogFile,
4854 mci->mci_mailer->m_eol);
4857 ostate = OSTATE_HEAD;
4861 /* had a naked carriage return */
4862 SM_ASSERT(pbp < peekbuf + sizeof(peekbuf));
4865 ostate = OSTATE_INLINE;
4876 mci->mci_mailer->m_flags))
4879 if (mci->mci_mailer->m_linelimit > 0 &&
4880 pos >= mci->mci_mailer->m_linelimit - 1 &&
4885 /* check next character for EOL */
4888 else if ((d = sm_io_getc(e->e_dfp,
4892 SM_ASSERT(pbp < peekbuf +
4897 if (d == '\n' || d == SM_IO_EOF)
4899 if (TrafficLogFile != NULL)
4900 (void) sm_io_putc(TrafficLogFile,
4903 if (sm_io_putc(mci->mci_out,
4915 if (sm_io_putc(mci->mci_out,
4916 SM_TIME_DEFAULT, '!')
4918 sm_io_fputs(mci->mci_out,
4920 mci->mci_mailer->m_eol)
4927 if (TrafficLogFile != NULL)
4929 (void) sm_io_fprintf(TrafficLogFile,
4932 mci->mci_mailer->m_eol);
4934 ostate = OSTATE_HEAD;
4935 SM_ASSERT(pbp < peekbuf +
4942 if (TrafficLogFile != NULL)
4943 (void) sm_io_fputs(TrafficLogFile,
4945 mci->mci_mailer->m_eol);
4946 if (sm_io_fputs(mci->mci_out,
4948 mci->mci_mailer->m_eol)
4952 ostate = OSTATE_HEAD;
4956 if (TrafficLogFile != NULL)
4957 (void) sm_io_putc(TrafficLogFile,
4960 if (sm_io_putc(mci->mci_out,
4969 ostate = OSTATE_INLINE;
4975 /* make sure we are at the beginning of a line */
4978 if (TrafficLogFile != NULL)
4980 for (xp = buf; xp < bp; xp++)
4981 (void) sm_io_putc(TrafficLogFile,
4983 (unsigned char) *xp);
4985 for (xp = buf; xp < bp; xp++)
4987 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
4988 (unsigned char) *xp)
4997 if (!dead && pos > 0)
4999 if (TrafficLogFile != NULL)
5000 (void) sm_io_fputs(TrafficLogFile,
5002 mci->mci_mailer->m_eol);
5003 if (sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT,
5004 mci->mci_mailer->m_eol) == SM_IO_EOF)
5009 if (sm_io_error(e->e_dfp))
5011 syserr("putbody: %s/%cf%s: read error",
5012 qid_printqueue(e->e_dfqgrp, e->e_dfqdir),
5013 DATAFL_LETTER, e->e_id);
5014 ExitStat = EX_IOERR;
5020 ** Since mailfile() uses e_dfp in a child process,
5021 ** the file offset in the stdio library for the
5022 ** parent process will not agree with the in-kernel
5023 ** file offset since the file descriptor is shared
5024 ** between the processes. Therefore, it is vital
5025 ** that the file always be rewound. This forces the
5026 ** kernel offset (lseek) and stdio library (ftell)
5031 if (e->e_dfp != NULL)
5032 (void) bfrewind(e->e_dfp);
5034 /* some mailers want extra blank line at end of message */
5035 if (!dead && bitnset(M_BLANKEND, mci->mci_mailer->m_flags) &&
5036 buf[0] != '\0' && buf[0] != '\n')
5038 if (!putline("", mci))
5043 (sm_io_flush(mci->mci_out, SM_TIME_DEFAULT) == SM_IO_EOF ||
5044 (sm_io_error(mci->mci_out) && errno != EPIPE)))
5047 syserr("putbody: write error");
5048 ExitStat = EX_IOERR;
5053 return !dead && !ioerr;
5060 ** MAILFILE -- Send a message to a file.
5062 ** If the file has the set-user-ID/set-group-ID bits set, but NO
5063 ** execute bits, sendmail will try to become the owner of that file
5064 ** rather than the real user. Obviously, this only works if
5065 ** sendmail runs as root.
5067 ** This could be done as a subordinate mailer, except that it
5068 ** is used implicitly to save messages in ~/dead.letter. We
5069 ** view this as being sufficiently important as to include it
5070 ** here. For example, if the system is dying, we shouldn't have
5071 ** to create another process plus some pipes to save the message.
5074 ** filename -- the name of the file to send to.
5075 ** mailer -- mailer definition for recipient -- if NULL,
5077 ** ctladdr -- the controlling address header -- includes
5078 ** the userid/groupid to be when sending.
5079 ** sfflags -- flags for opening.
5080 ** e -- the current envelope.
5083 ** The exit code associated with the operation.
5089 # define RETURN(st) exit(st);
5091 static jmp_buf CtxMailfileTimeout;
5094 mailfile(filename, mailer, ctladdr, sfflags, e)
5095 char *volatile filename;
5096 MAILER *volatile mailer;
5098 volatile long sfflags;
5099 register ENVELOPE *e;
5101 register SM_FILE_T *f;
5102 register pid_t pid = -1;
5106 bool suidwarn = geteuid() == 0;
5108 char *volatile realfile;
5110 char buf[MAXPATHLEN];
5111 char targetfile[MAXPATHLEN];
5115 sm_dprintf("mailfile %s\n ctladdr=", filename);
5116 printaddr(sm_debug_file(), ctladdr, false);
5120 mailer = FileMailer;
5122 if (e->e_xfp != NULL)
5123 (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT);
5126 ** Special case /dev/null. This allows us to restrict file
5127 ** delivery to regular files only.
5130 if (sm_path_isdevnull(filename))
5133 /* check for 8-bit available */
5134 if (bitset(EF_HAS8BIT, e->e_flags) &&
5135 bitnset(M_7BITS, mailer->m_flags) &&
5136 (bitset(EF_DONT_MIME, e->e_flags) ||
5137 !(bitset(MM_MIME8BIT, MimeMode) ||
5138 (bitset(EF_IS_MIME, e->e_flags) &&
5139 bitset(MM_CVTMIME, MimeMode)))))
5141 e->e_status = "5.6.3";
5142 usrerrenh(e->e_status,
5143 "554 Cannot send 8-bit data to 7-bit destination");
5148 /* Find the actual file */
5149 if (SafeFileEnv != NULL && SafeFileEnv[0] != '\0')
5151 len = strlen(SafeFileEnv);
5153 if (strncmp(SafeFileEnv, filename, len) == 0)
5156 if (len + strlen(filename) + 1 >= sizeof(targetfile))
5158 syserr("mailfile: filename too long (%s/%s)",
5159 SafeFileEnv, filename);
5160 return EX_CANTCREAT;
5162 (void) sm_strlcpy(targetfile, SafeFileEnv, sizeof(targetfile));
5163 realfile = targetfile + len;
5164 if (*filename == '/')
5166 if (*filename != '\0')
5168 /* paranoia: trailing / should be removed in readcf */
5169 if (targetfile[len - 1] != '/')
5170 (void) sm_strlcat(targetfile,
5171 "/", sizeof(targetfile));
5172 (void) sm_strlcat(targetfile, filename,
5173 sizeof(targetfile));
5176 else if (mailer->m_rootdir != NULL)
5178 expand(mailer->m_rootdir, targetfile, sizeof(targetfile), e);
5179 len = strlen(targetfile);
5181 if (strncmp(targetfile, filename, len) == 0)
5184 if (len + strlen(filename) + 1 >= sizeof(targetfile))
5186 syserr("mailfile: filename too long (%s/%s)",
5187 targetfile, filename);
5188 return EX_CANTCREAT;
5190 realfile = targetfile + len;
5191 if (targetfile[len - 1] != '/')
5192 (void) sm_strlcat(targetfile, "/", sizeof(targetfile));
5193 if (*filename == '/')
5194 (void) sm_strlcat(targetfile, filename + 1,
5195 sizeof(targetfile));
5197 (void) sm_strlcat(targetfile, filename,
5198 sizeof(targetfile));
5202 if (sm_strlcpy(targetfile, filename, sizeof(targetfile)) >=
5205 syserr("mailfile: filename too long (%s)", filename);
5206 return EX_CANTCREAT;
5208 realfile = targetfile;
5212 ** Fork so we can change permissions here.
5213 ** Note that we MUST use fork, not vfork, because of
5214 ** the complications of calling subroutines, etc.
5219 ** Dispose of SIGCHLD signal catchers that may be laying
5220 ** around so that the waitfor() below will get it.
5223 (void) sm_signal(SIGCHLD, SIG_DFL);
5231 /* child -- actually write to file */
5235 volatile int oflags = O_WRONLY|O_APPEND;
5237 /* Reset global flags */
5238 RestartRequest = NULL;
5239 RestartWorkGroup = false;
5240 ShutdownRequest = NULL;
5242 CurrentPid = getpid();
5244 if (e->e_lockfp != NULL)
5248 fd = sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL);
5249 /* SM_ASSERT(fd >= 0); */
5254 (void) sm_signal(SIGINT, SIG_DFL);
5255 (void) sm_signal(SIGHUP, SIG_DFL);
5256 (void) sm_signal(SIGTERM, SIG_DFL);
5257 (void) umask(OldUmask);
5261 if (setjmp(CtxMailfileTimeout) != 0)
5263 RETURN(EX_TEMPFAIL);
5266 if (TimeOuts.to_fileopen > 0)
5267 ev = sm_setevent(TimeOuts.to_fileopen, mailfiletimeout,
5272 /* check file mode to see if set-user-ID */
5273 if (stat(targetfile, &stb) < 0)
5278 /* limit the errors to those actually caused in the child */
5282 /* Allow alias expansions to use the S_IS{U,G}ID bits */
5283 if ((ctladdr != NULL && !bitset(QALIAS, ctladdr->q_flags)) ||
5284 bitset(SFF_RUNASREALUID, sfflags))
5286 /* ignore set-user-ID and set-group-ID bits */
5287 mode &= ~(S_ISGID|S_ISUID);
5289 sm_dprintf("mailfile: ignoring set-user-ID/set-group-ID bits\n");
5292 /* we have to open the data file BEFORE setuid() */
5293 if (e->e_dfp == NULL && bitset(EF_HAS_DF, e->e_flags))
5295 char *df = queuename(e, DATAFL_LETTER);
5297 e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, df,
5298 SM_IO_RDONLY_B, NULL);
5299 if (e->e_dfp == NULL)
5301 syserr("mailfile: Cannot open %s for %s from %s",
5302 df, e->e_to, e->e_from.q_paddr);
5306 /* select a new user to run as */
5307 if (!bitset(SFF_RUNASREALUID, sfflags))
5309 if (bitnset(M_SPECIFIC_UID, mailer->m_flags))
5311 RealUserName = NULL;
5312 if (mailer->m_uid == NO_UID)
5315 RealUid = mailer->m_uid;
5316 if (RunAsUid != 0 && RealUid != RunAsUid)
5318 /* Only root can change the uid */
5319 syserr("mailfile: insufficient privileges to change uid, RunAsUid=%d, RealUid=%d",
5320 (int) RunAsUid, (int) RealUid);
5321 RETURN(EX_TEMPFAIL);
5324 else if (bitset(S_ISUID, mode))
5326 RealUserName = NULL;
5327 RealUid = stb.st_uid;
5329 else if (ctladdr != NULL && ctladdr->q_uid != 0)
5331 if (ctladdr->q_ruser != NULL)
5332 RealUserName = ctladdr->q_ruser;
5334 RealUserName = ctladdr->q_user;
5335 RealUid = ctladdr->q_uid;
5337 else if (mailer != NULL && mailer->m_uid != NO_UID)
5339 RealUserName = DefUser;
5340 RealUid = mailer->m_uid;
5344 RealUserName = DefUser;
5348 /* select a new group to run as */
5349 if (bitnset(M_SPECIFIC_UID, mailer->m_flags))
5351 if (mailer->m_gid == NO_GID)
5354 RealGid = mailer->m_gid;
5355 if (RunAsUid != 0 &&
5356 (RealGid != getgid() ||
5357 RealGid != getegid()))
5359 /* Only root can change the gid */
5360 syserr("mailfile: insufficient privileges to change gid, RealGid=%d, RunAsUid=%d, gid=%d, egid=%d",
5361 (int) RealGid, (int) RunAsUid,
5362 (int) getgid(), (int) getegid());
5363 RETURN(EX_TEMPFAIL);
5366 else if (bitset(S_ISGID, mode))
5367 RealGid = stb.st_gid;
5368 else if (ctladdr != NULL &&
5369 ctladdr->q_uid == DefUid &&
5370 ctladdr->q_gid == 0)
5373 ** Special case: This means it is an
5374 ** alias and we should act as DefaultUser.
5375 ** See alias()'s comments.
5379 RealUserName = DefUser;
5381 else if (ctladdr != NULL && ctladdr->q_uid != 0)
5382 RealGid = ctladdr->q_gid;
5383 else if (mailer != NULL && mailer->m_gid != NO_GID)
5384 RealGid = mailer->m_gid;
5390 if (!bitset(SFF_ROOTOK, sfflags))
5398 /* set group id list (needs /etc/group access) */
5399 if (RealUserName != NULL && !DontInitGroups)
5401 if (initgroups(RealUserName, RealGid) == -1 && suidwarn)
5403 syserr("mailfile: initgroups(%s, %d) failed",
5404 RealUserName, RealGid);
5405 RETURN(EX_TEMPFAIL);
5412 gidset[0] = RealGid;
5413 if (setgroups(1, gidset) == -1 && suidwarn)
5415 syserr("mailfile: setgroups() failed");
5416 RETURN(EX_TEMPFAIL);
5421 ** If you have a safe environment, go into it.
5424 if (realfile != targetfile)
5431 sm_dprintf("mailfile: chroot %s\n", targetfile);
5432 if (chroot(targetfile) < 0)
5434 syserr("mailfile: Cannot chroot(%s)",
5436 RETURN(EX_CANTCREAT);
5442 sm_dprintf("mailfile: deliver to %s\n", realfile);
5446 syserr("mailfile: cannot chdir(/)");
5447 RETURN(EX_CANTCREAT);
5450 /* now reset the group and user ids */
5452 sm_mbdb_terminate();
5453 if (setgid(RealGid) < 0 && suidwarn)
5455 syserr("mailfile: setgid(%ld) failed", (long) RealGid);
5456 RETURN(EX_TEMPFAIL);
5458 vendor_set_uid(RealUid);
5459 if (setuid(RealUid) < 0 && suidwarn)
5461 syserr("mailfile: setuid(%ld) failed", (long) RealUid);
5462 RETURN(EX_TEMPFAIL);
5466 sm_dprintf("mailfile: running as r/euid=%d/%d, r/egid=%d/%d\n",
5467 (int) getuid(), (int) geteuid(),
5468 (int) getgid(), (int) getegid());
5471 /* move into some "safe" directory */
5472 if (mailer->m_execdir != NULL)
5476 for (p = mailer->m_execdir; p != NULL; p = q)
5481 expand(p, buf, sizeof(buf), e);
5485 sm_dprintf("mailfile: trydir %s\n",
5487 if (buf[0] != '\0' && chdir(buf) >= 0)
5493 ** Recheck the file after we have assumed the ID of the
5494 ** delivery user to make sure we can deliver to it as
5495 ** that user. This is necessary if sendmail is running
5496 ** as root and the file is on an NFS mount which treats
5501 if (bitnset(DBS_FILEDELIVERYTOSYMLINK, DontBlameSendmail))
5502 err = stat(realfile, &stb);
5504 err = lstat(realfile, &stb);
5505 #else /* HASLSTAT */
5506 err = stat(realfile, &stb);
5507 #endif /* HASLSTAT */
5511 stb.st_mode = ST_MODE_NOFILE;
5513 oflags |= O_CREAT|O_EXCL;
5515 else if (bitset(S_IXUSR|S_IXGRP|S_IXOTH, mode) ||
5516 (!bitnset(DBS_FILEDELIVERYTOHARDLINK,
5517 DontBlameSendmail) &&
5518 stb.st_nlink != 1) ||
5519 (realfile != targetfile && !S_ISREG(mode)))
5524 if (!bitnset(DBS_FILEDELIVERYTOSYMLINK, DontBlameSendmail))
5525 sfflags |= SFF_NOSLINK;
5526 if (!bitnset(DBS_FILEDELIVERYTOHARDLINK, DontBlameSendmail))
5527 sfflags |= SFF_NOHLINK;
5528 sfflags &= ~SFF_OPENASROOT;
5529 f = safefopen(realfile, oflags, mode, sfflags);
5532 if (transienterror(errno))
5534 usrerr("454 4.3.0 cannot open %s: %s",
5535 shortenstring(realfile, MAXSHORTSTR),
5536 sm_errstring(errno));
5537 RETURN(EX_TEMPFAIL);
5541 usrerr("554 5.3.0 cannot open %s: %s",
5542 shortenstring(realfile, MAXSHORTSTR),
5543 sm_errstring(errno));
5544 RETURN(EX_CANTCREAT);
5547 if (filechanged(realfile, sm_io_getinfo(f, SM_IO_WHAT_FD, NULL),
5550 syserr("554 5.3.0 file changed after open");
5551 RETURN(EX_CANTCREAT);
5553 if (fstat(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL), &stb) < 0)
5555 syserr("554 5.3.0 cannot fstat %s",
5556 sm_errstring(errno));
5557 RETURN(EX_CANTCREAT);
5560 curoff = stb.st_size;
5565 memset(&mcibuf, '\0', sizeof(mcibuf));
5566 mcibuf.mci_mailer = mailer;
5568 if (bitnset(M_7BITS, mailer->m_flags))
5569 mcibuf.mci_flags |= MCIF_7BIT;
5571 /* clear out per-message flags from connection structure */
5572 mcibuf.mci_flags &= ~(MCIF_CVT7TO8|MCIF_CVT8TO7);
5574 if (bitset(EF_HAS8BIT, e->e_flags) &&
5575 !bitset(EF_DONT_MIME, e->e_flags) &&
5576 bitnset(M_7BITS, mailer->m_flags))
5577 mcibuf.mci_flags |= MCIF_CVT8TO7;
5580 if (bitnset(M_MAKE8BIT, mailer->m_flags) &&
5581 !bitset(MCIF_7BIT, mcibuf.mci_flags) &&
5582 (p = hvalue("Content-Transfer-Encoding", e->e_header)) != NULL &&
5583 (sm_strcasecmp(p, "quoted-printable") == 0 ||
5584 sm_strcasecmp(p, "base64") == 0) &&
5585 (p = hvalue("Content-Type", e->e_header)) != NULL)
5587 /* may want to convert 7 -> 8 */
5588 /* XXX should really parse it here -- and use a class XXX */
5589 if (sm_strncasecmp(p, "text/plain", 10) == 0 &&
5590 (p[10] == '\0' || p[10] == ' ' || p[10] == ';'))
5591 mcibuf.mci_flags |= MCIF_CVT7TO8;
5593 #endif /* MIME7TO8 */
5595 if (!putfromline(&mcibuf, e) ||
5596 !(*e->e_puthdr)(&mcibuf, e->e_header, e, M87F_OUTER) ||
5597 !(*e->e_putbody)(&mcibuf, e, NULL) ||
5598 !putline("\n", &mcibuf) ||
5599 (sm_io_flush(f, SM_TIME_DEFAULT) != 0 ||
5600 (SuperSafe != SAFE_NO &&
5601 fsync(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL)) < 0) ||
5606 (void) ftruncate(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL),
5608 #endif /* !NOFTRUNCATE */
5611 /* reset ISUID & ISGID bits for paranoid systems */
5613 (void) fchmod(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL),
5615 #else /* HASFCHMOD */
5616 (void) chmod(filename, (MODE_T) mode);
5617 #endif /* HASFCHMOD */
5618 if (sm_io_close(f, SM_TIME_DEFAULT) < 0)
5620 (void) sm_io_flush(smioout, SM_TIME_DEFAULT);
5621 (void) setuid(RealUid);
5627 /* parent -- wait for exit status */
5633 syserr("mailfile: %s: wait", mailer->m_name);
5639 return (WEXITSTATUS(st));
5643 syserr("mailfile: %s: child died on signal %d",
5644 mailer->m_name, st);
5645 return EX_UNAVAILABLE;
5649 return EX_UNAVAILABLE; /* avoid compiler warning on IRIX */
5653 mailfiletimeout(ignore)
5657 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
5658 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
5663 longjmp(CtxMailfileTimeout, 1);
5666 ** HOSTSIGNATURE -- return the "signature" for a host.
5668 ** The signature describes how we are going to send this -- it
5669 ** can be just the hostname (for non-Internet hosts) or can be
5670 ** an ordered list of MX hosts.
5673 ** m -- the mailer describing this host.
5674 ** host -- the host name.
5677 ** The signature for this host.
5680 ** Can tweak the symbol table.
5683 #define MAXHOSTSIGNATURE 8192 /* max len of hostsignature */
5686 hostsignature(m, host)
5702 int oldoptions = _res.options;
5703 char *mxhosts[MAXMXHOSTS + 1];
5704 unsigned short mxprefs[MAXMXHOSTS + 1];
5705 #endif /* NAMED_BIND */
5708 sm_dprintf("hostsignature(%s)\n", host);
5711 ** If local delivery (and not remote), just return a constant.
5714 if (bitnset(M_LOCALMAILER, m->m_flags) &&
5715 strcmp(m->m_mailer, "[IPC]") != 0 &&
5716 !(m->m_argv[0] != NULL && strcmp(m->m_argv[0], "TCP") == 0))
5719 /* an empty host does not have MX records */
5724 ** Check to see if this uses IPC -- if not, it can't have MX records.
5727 if (strcmp(m->m_mailer, "[IPC]") != 0 ||
5728 CurEnv->e_sendmode == SM_DEFER)
5730 /* just an ordinary mailer or deferred mode */
5734 else if (m->m_argv[0] != NULL &&
5735 strcmp(m->m_argv[0], "FILE") == 0)
5737 /* rendezvous in the file system, no MX records */
5740 #endif /* NETUNIX */
5743 ** Look it up in the symbol table.
5747 s = stab(host, ST_HOSTSIG, ST_ENTER);
5748 if (s->s_hostsig.hs_sig != NULL)
5750 if (s->s_hostsig.hs_exp >= now)
5753 sm_dprintf("hostsignature(): stab(%s) found %s\n", host,
5754 s->s_hostsig.hs_sig);
5755 return s->s_hostsig.hs_sig;
5758 /* signature is expired: clear it */
5759 sm_free(s->s_hostsig.hs_sig);
5760 s->s_hostsig.hs_sig = NULL;
5763 /* set default TTL */
5764 s->s_hostsig.hs_exp = now + SM_DEFAULT_TTL;
5767 ** Not already there or expired -- create a signature.
5771 if (ConfigLevel < 2)
5772 _res.options &= ~(RES_DEFNAMES | RES_DNSRCH); /* XXX */
5774 for (hp = host; hp != NULL; hp = endp)
5779 endp = strchr(hp + 1, ']');
5781 endp = strpbrk(endp + 1, ":,");
5784 endp = strpbrk(hp, ":,");
5785 #else /* NETINET6 */
5786 endp = strpbrk(hp, ":,");
5787 #endif /* NETINET6 */
5794 if (bitnset(M_NOMX, m->m_flags))
5796 /* skip MX lookups */
5805 nmx = getmxrr(hp, mxhosts, mxprefs, true, &rcode, true,
5812 /* update the connection info for this host */
5814 mci = mci_get(hp, m);
5815 mci->mci_errno = save_errno;
5816 mci->mci_herrno = h_errno;
5817 mci->mci_lastuse = now;
5818 if (rcode == EX_NOHOST)
5819 mci_setstat(mci, rcode, "5.1.2",
5820 "550 Host unknown");
5822 mci_setstat(mci, rcode, NULL, NULL);
5824 /* use the original host name as signature */
5829 sm_dprintf("hostsignature(): getmxrr() returned %d, mxhosts[0]=%s\n",
5833 ** Set new TTL: we use only one!
5834 ** We could try to use the minimum instead.
5837 s->s_hostsig.hs_exp = now + SM_MIN(ttl, SM_DEFAULT_TTL);
5841 for (i = 0; i < nmx; i++)
5842 len += strlen(mxhosts[i]) + 1;
5843 if (s->s_hostsig.hs_sig != NULL)
5844 len += strlen(s->s_hostsig.hs_sig) + 1;
5845 if (len < 0 || len >= MAXHOSTSIGNATURE)
5847 sm_syslog(LOG_WARNING, NOQID, "hostsignature for host '%s' exceeds maxlen (%d): %d",
5848 host, MAXHOSTSIGNATURE, len);
5849 len = MAXHOSTSIGNATURE;
5851 p = sm_pmalloc_x(len);
5852 if (s->s_hostsig.hs_sig != NULL)
5854 (void) sm_strlcpy(p, s->s_hostsig.hs_sig, len);
5855 sm_free(s->s_hostsig.hs_sig); /* XXX */
5856 s->s_hostsig.hs_sig = p;
5863 s->s_hostsig.hs_sig = p;
5864 for (i = 0; i < nmx; i++)
5866 hl = strlen(mxhosts[i]);
5867 if (len - 1 < hl || len <= 1)
5869 /* force to drop out of outer loop */
5875 if (mxprefs[i] == mxprefs[i - 1])
5881 (void) sm_strlcpy(p, mxhosts[i], len);
5887 ** break out of loop if len exceeded MAXHOSTSIGNATURE
5888 ** because we won't have more space for further hosts
5889 ** anyway (separated by : in the .cf file).
5898 makelower(s->s_hostsig.hs_sig);
5899 if (ConfigLevel < 2)
5900 _res.options = oldoptions;
5901 #else /* NAMED_BIND */
5902 /* not using BIND -- the signature is just the host name */
5904 ** 'host' points to storage that will be freed after we are
5905 ** done processing the current envelope, so we copy it.
5907 s->s_hostsig.hs_sig = sm_pstrdup_x(host);
5908 #endif /* NAMED_BIND */
5910 sm_dprintf("hostsignature(%s) = %s\n", host, s->s_hostsig.hs_sig);
5911 return s->s_hostsig.hs_sig;
5914 ** PARSE_HOSTSIGNATURE -- parse the "signature" and return MX host array.
5916 ** The signature describes how we are going to send this -- it
5917 ** can be just the hostname (for non-Internet hosts) or can be
5918 ** an ordered list of MX hosts which must be randomized for equal
5919 ** MX preference values.
5922 ** sig -- the host signature.
5923 ** mxhosts -- array to populate.
5924 ** mailer -- mailer.
5927 ** The number of hosts inserted into mxhosts array.
5930 ** Randomizes equal MX preference hosts in mxhosts.
5934 parse_hostsignature(sig, mxhosts, mailer)
5939 unsigned short curpref = 0;
5940 int nmx = 0, i, j; /* NOTE: i, j, and nmx must have same type */
5942 unsigned short prefer[MAXMXHOSTS];
5943 long rndm[MAXMXHOSTS];
5945 for (hp = sig; hp != NULL; hp = endp)
5952 endp = strchr(hp + 1, ']');
5954 endp = strpbrk(endp + 1, ":,");
5957 endp = strpbrk(hp, ":,");
5958 #else /* NETINET6 */
5959 endp = strpbrk(hp, ":,");
5960 #endif /* NETINET6 */
5968 prefer[nmx] = curpref;
5969 if (mci_match(hp, mailer))
5972 rndm[nmx] = get_random();
5977 ** Since we don't have the original MX prefs,
5978 ** make our own. If the separator is a ':', that
5979 ** means the preference for the next host will be
5980 ** higher than this one, so simply increment curpref.
5988 if (++nmx >= MAXMXHOSTS)
5992 /* sort the records using the random factor for equal preferences */
5993 for (i = 0; i < nmx; i++)
5995 for (j = i + 1; j < nmx; j++)
5998 ** List is already sorted by MX preference, only
5999 ** need to look for equal preference MX records
6002 if (prefer[i] < prefer[j])
6005 if (prefer[i] > prefer[j] ||
6006 (prefer[i] == prefer[j] && rndm[i] > rndm[j]))
6008 register unsigned short tempp;
6009 register long tempr;
6010 register char *temp1;
6013 prefer[i] = prefer[j];
6016 mxhosts[i] = mxhosts[j];
6028 static SSL_CTX *clt_ctx = NULL;
6029 static bool tls_ok_clt = true;
6032 ** SETCLTTLS -- client side TLS: allow/disallow.
6035 ** tls_ok -- should tls be done?
6041 ** sets tls_ok_clt (static variable in this module)
6048 tls_ok_clt = tls_ok;
6052 ** INITCLTTLS -- initialize client side TLS
6055 ** tls_ok -- should tls initialization be done?
6061 ** sets tls_ok_clt (static variable in this module)
6070 tls_ok_clt = tls_ok;
6073 if (clt_ctx != NULL)
6074 return true; /* already done */
6075 tls_ok_clt = inittls(&clt_ctx, TLS_I_CLT, false, CltCertFile,
6076 CltKeyFile, CACertPath, CACertFile, DHParams);
6081 ** STARTTLS -- try to start secure connection (client side)
6085 ** mci -- the mailer connection info.
6086 ** e -- the envelope.
6090 ** (maybe this should be some other code than EX_
6091 ** that denotes which stage failed.)
6103 SSL *clt_ssl = NULL;
6106 if (clt_ctx == NULL && !initclttls(true))
6108 smtpmessage("STARTTLS", m, mci);
6111 smtpresult = reply(m, mci, e, TimeOuts.to_starttls, NULL, NULL,
6114 /* check return code from server */
6115 if (REPLYTYPE(smtpresult) == 4)
6117 if (smtpresult == 501)
6119 if (smtpresult == -1)
6122 /* not an expected reply but we have to deal with it */
6123 if (REPLYTYPE(smtpresult) == 5)
6124 return EX_UNAVAILABLE;
6125 if (smtpresult != 220)
6129 sm_syslog(LOG_INFO, NOQID, "STARTTLS=client, start=ok");
6131 /* start connection */
6132 if ((clt_ssl = SSL_new(clt_ctx)) == NULL)
6136 sm_syslog(LOG_ERR, NOQID,
6137 "STARTTLS=client, error: SSL_new failed");
6139 tlslogerr("client");
6144 rfd = sm_io_getinfo(mci->mci_in, SM_IO_WHAT_FD, NULL);
6145 wfd = sm_io_getinfo(mci->mci_out, SM_IO_WHAT_FD, NULL);
6147 /* SSL_clear(clt_ssl); ? */
6148 if (rfd < 0 || wfd < 0 ||
6149 (result = SSL_set_rfd(clt_ssl, rfd)) != 1 ||
6150 (result = SSL_set_wfd(clt_ssl, wfd)) != 1)
6154 sm_syslog(LOG_ERR, NOQID,
6155 "STARTTLS=client, error: SSL_set_xfd failed=%d",
6158 tlslogerr("client");
6162 SSL_set_connect_state(clt_ssl);
6163 tlsstart = curtime();
6166 if ((result = SSL_connect(clt_ssl)) <= 0)
6170 ssl_err = SSL_get_error(clt_ssl, result);
6171 i = tls_retry(clt_ssl, rfd, wfd, tlsstart,
6172 TimeOuts.to_starttls, ssl_err, "client");
6178 sm_syslog(LOG_WARNING, NOQID,
6179 "STARTTLS=client, error: connect failed=%d, SSL_error=%d, errno=%d, retry=%d",
6180 result, ssl_err, errno, i);
6182 tlslogerr("client");
6189 mci->mci_ssl = clt_ssl;
6190 result = tls_get_info(mci->mci_ssl, false, mci->mci_host,
6191 &mci->mci_macro, true);
6193 /* switch to use TLS... */
6194 if (sfdctls(&mci->mci_in, &mci->mci_out, mci->mci_ssl) == 0)
6203 ** ENDTLSCLT -- shutdown secure connection (client side)
6206 ** mci -- the mailer connection info.
6218 if (!bitset(MCIF_TLSACT, mci->mci_flags))
6220 r = endtls(mci->mci_ssl, "client");
6221 mci->mci_flags &= ~MCIF_TLSACT;
6224 # endif /* STARTTLS */
6225 # if STARTTLS || SASL
6227 ** ISCLTFLGSET -- check whether client flag is set.
6231 ** flag -- flag to check in {client_flags}
6234 ** true iff flag is set.
6238 iscltflgset(e, flag)
6244 p = macvalue(macid("{client_flags}"), e);
6247 for (; *p != '\0'; p++)
6249 /* look for just this one flag */
6250 if (*p == (char) flag)
6255 # endif /* STARTTLS || SASL */