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.1015 2007/10/17 21:35:30 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-queueing\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
);
3296 if (ok
&& bitset(MCIF_INLONGLINE
, mci
->mci_flags
))
3297 ok
= putline("", mci
);
3300 ** Ignore an I/O error that was caused by EPIPE.
3301 ** Some broken mailers don't read the entire body
3302 ** but just exit() thus causing an I/O error.
3305 if (!ok
&& (sm_io_error(mci
->mci_out
) && errno
== EPIPE
))
3308 /* (always) get the exit status */
3309 rcode
= endmailer(mci
, e
, pv
);
3311 rcode
= EX_TEMPFAIL
;
3312 if (rcode
== EX_TEMPFAIL
&& SmtpError
[0] == '\0')
3315 ** Need an e_message for mailq display.
3316 ** We set SmtpError as
3319 (void) sm_snprintf(SmtpError
, sizeof(SmtpError
),
3320 "%s mailer (%s) exited with EX_TEMPFAIL",
3321 m
->m_name
, m
->m_mailer
);
3327 ** Send the MAIL FROM: protocol
3330 /* XXX this isn't pipelined... */
3331 rcode
= smtpmailfrom(m
, mci
, e
);
3336 ADDRESS
*volatile pchain
;
3337 # endif /* PIPELINING */
3339 /* send the recipient list */
3341 mci
->mci_retryrcpt
= false;
3342 mci
->mci_tolist
= tobuf
;
3345 mci
->mci_nextaddr
= NULL
;
3346 # endif /* PIPELINING */
3348 for (to
= tochain
; to
!= NULL
; to
= to
->q_tchain
)
3350 if (!QS_IS_UNMARKED(to
->q_state
))
3353 /* mark recipient state as "ok so far" */
3354 to
->q_state
= QS_OK
;
3355 e
->e_to
= to
->q_paddr
;
3357 i
= rscheck("tls_rcpt", to
->q_user
, NULL
, e
,
3358 RSF_RMCOMM
|RSF_COUNT
, 3,
3359 mci
->mci_host
, e
->e_id
, NULL
);
3362 markfailure(e
, to
, mci
, i
, false);
3363 giveresponse(i
, to
->q_status
, m
, mci
,
3364 ctladdr
, xstart
, e
, to
);
3365 if (i
== EX_TEMPFAIL
)
3367 mci
->mci_retryrcpt
= true;
3368 to
->q_state
= QS_RETRY
;
3372 # endif /* STARTTLS */
3374 i
= smtprcpt(to
, m
, mci
, e
, ctladdr
, xstart
);
3377 bitset(MCIF_PIPELINED
, mci
->mci_flags
))
3380 ** Add new element to list of
3381 ** recipients for pipelining.
3384 to
->q_pchain
= NULL
;
3385 if (mci
->mci_nextaddr
== NULL
)
3386 mci
->mci_nextaddr
= to
;
3391 pchain
->q_pchain
= to
;
3392 pchain
= pchain
->q_pchain
;
3395 # endif /* PIPELINING */
3398 markfailure(e
, to
, mci
, i
, false);
3399 giveresponse(i
, to
->q_status
, m
, mci
,
3400 ctladdr
, xstart
, e
, to
);
3401 if (i
== EX_TEMPFAIL
)
3402 to
->q_state
= QS_RETRY
;
3406 /* No recipients in list and no missing responses? */
3407 if (tobuf
[0] == '\0'
3409 && bitset(MCIF_PIPELINED
, mci
->mci_flags
)
3410 && mci
->mci_nextaddr
== NULL
3411 # endif /* PIPELINING */
3416 if (bitset(MCIF_CACHED
, mci
->mci_flags
))
3417 smtprset(m
, mci
, e
);
3421 e
->e_to
= tobuf
+ 1;
3422 rcode
= smtpdata(m
, mci
, e
, ctladdr
, xstart
);
3425 if (rcode
== EX_TEMPFAIL
&& nummxhosts
> hostnum
)
3427 /* try next MX site */
3432 if (ConfigLevel
< 2)
3433 _res
.options
|= RES_DEFNAMES
| RES_DNSRCH
; /* XXX */
3434 #endif /* NAMED_BIND */
3437 checkfds("after delivery");
3440 ** Do final status disposal.
3441 ** We check for something in tobuf for the SMTP case.
3442 ** If we got a temporary failure, arrange to queue the
3447 if (bitnset(M_LMTP
, m
->m_flags
))
3455 anyok
= rcode
== EX_OK
;
3457 for (to
= tochain
; to
!= NULL
; to
= to
->q_tchain
)
3459 /* see if address already marked */
3460 if (!QS_IS_OK(to
->q_state
))
3463 /* if running LMTP, get the status for each address */
3464 if (bitnset(M_LMTP
, m
->m_flags
))
3466 if (lmtp_rcode
== EX_OK
)
3467 rcode
= smtpgetstat(m
, mci
, e
);
3470 strsize
+= sm_strlcat2(tobuf
+ strsize
, ",",
3472 tobufsize
- strsize
);
3473 SM_ASSERT(strsize
< tobufsize
);
3478 e
->e_to
= to
->q_paddr
;
3479 markfailure(e
, to
, mci
, rcode
, true);
3480 giveresponse(rcode
, to
->q_status
, m
, mci
,
3481 ctladdr
, xstart
, e
, to
);
3482 e
->e_to
= tobuf
+ 1;
3488 /* mark bad addresses */
3491 if (goodmxfound
&& rcode
== EX_NOHOST
)
3492 rcode
= EX_TEMPFAIL
;
3493 markfailure(e
, to
, mci
, rcode
, true);
3498 /* successful delivery */
3499 to
->q_state
= QS_SENT
;
3500 to
->q_statdate
= curtime();
3504 ** Checkpoint the send list every few addresses
3507 if (CheckpointInterval
> 0 && e
->e_nsent
>= CheckpointInterval
)
3509 queueup(e
, false, false);
3513 if (bitnset(M_LOCALMAILER
, m
->m_flags
) &&
3514 bitset(QPINGONSUCCESS
, to
->q_flags
))
3516 to
->q_flags
|= QDELIVERED
;
3517 to
->q_status
= "2.1.5";
3518 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
,
3519 "%s... Successfully delivered\n",
3522 else if (bitset(QPINGONSUCCESS
, to
->q_flags
) &&
3523 bitset(QPRIMARY
, to
->q_flags
) &&
3524 !bitset(MCIF_DSN
, mci
->mci_flags
))
3526 to
->q_flags
|= QRELAYED
;
3527 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
,
3528 "%s... relayed; expect no further notifications\n",
3531 else if (IS_DLVR_NOTIFY(e
) &&
3532 !bitset(MCIF_DLVR_BY
, mci
->mci_flags
) &&
3533 bitset(QPRIMARY
, to
->q_flags
) &&
3534 (!bitset(QHASNOTIFY
, to
->q_flags
) ||
3535 bitset(QPINGONSUCCESS
, to
->q_flags
) ||
3536 bitset(QPINGONFAILURE
, to
->q_flags
) ||
3537 bitset(QPINGONDELAY
, to
->q_flags
)))
3539 /* RFC 2852, 4.1.4.2: no NOTIFY, or not NEVER */
3540 to
->q_flags
|= QBYNRELAY
;
3541 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
,
3542 "%s... Deliver-by notify: relayed\n",
3545 else if (IS_DLVR_TRACE(e
) &&
3546 (!bitset(QHASNOTIFY
, to
->q_flags
) ||
3547 bitset(QPINGONSUCCESS
, to
->q_flags
) ||
3548 bitset(QPINGONFAILURE
, to
->q_flags
) ||
3549 bitset(QPINGONDELAY
, to
->q_flags
)) &&
3550 bitset(QPRIMARY
, to
->q_flags
))
3552 /* RFC 2852, 4.1.4: no NOTIFY, or not NEVER */
3553 to
->q_flags
|= QBYTRACE
;
3554 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
,
3555 "%s... Deliver-By trace: relayed\n",
3560 if (bitnset(M_LMTP
, m
->m_flags
))
3563 ** Global information applies to the last recipient only;
3564 ** clear it out to avoid bogus errors.
3568 e
->e_statmsg
= NULL
;
3570 /* reset the mci state for the next transaction */
3572 (mci
->mci_state
== MCIS_MAIL
||
3573 mci
->mci_state
== MCIS_RCPT
||
3574 mci
->mci_state
== MCIS_DATA
))
3576 mci
->mci_state
= MCIS_OPEN
;
3577 SmtpPhase
= mci
->mci_phase
= "idle";
3578 sm_setproctitle(true, e
, "%s: %s", CurHostName
,
3583 if (tobuf
[0] != '\0')
3585 giveresponse(rcode
, NULL
, m
, mci
, ctladdr
, xstart
, e
, tochain
);
3588 ** This code is disabled for now because I am not
3589 ** sure that copying status from the first recipient
3590 ** to all non-status'ed recipients is a good idea.
3593 if (tochain
->q_message
!= NULL
&&
3594 !bitnset(M_LMTP
, m
->m_flags
) && rcode
!= EX_OK
)
3596 for (to
= tochain
->q_tchain
; to
!= NULL
;
3599 /* see if address already marked */
3600 if (QS_IS_QUEUEUP(to
->q_state
) &&
3601 to
->q_message
== NULL
)
3602 to
->q_message
= sm_rpool_strdup_x(e
->e_rpool
,
3603 tochain
->q_message
);
3609 markstats(e
, tochain
, STATS_NORMAL
);
3610 mci_store_persistent(mci
);
3612 /* Some recipients were tempfailed, try them on the next host */
3613 if (mci
!= NULL
&& mci
->mci_retryrcpt
&& nummxhosts
> hostnum
)
3615 /* try next MX site */
3619 /* now close the connection */
3620 if (clever
&& mci
!= NULL
&& mci
->mci_state
!= MCIS_CLOSED
&&
3621 !bitset(MCIF_CACHED
, mci
->mci_flags
))
3622 smtpquit(m
, mci
, e
);
3629 ** Restore state and return.
3634 /* make absolutely certain 0, 1, and 2 are in use */
3635 (void) sm_snprintf(wbuf
, sizeof(wbuf
),
3636 "%s... end of deliver(%s)",
3637 e
->e_to
== NULL
? "NO-TO-LIST"
3638 : shortenstring(e
->e_to
,
3647 ** It was originally necessary to set macro 'g' to NULL
3648 ** because it previously pointed to an auto buffer.
3649 ** We don't do this any more, so this may be unnecessary.
3652 macdefine(&e
->e_macro
, A_PERM
, 'g', (char *) NULL
);
3660 ** MARKFAILURE -- mark a failure on a specific address.
3663 ** e -- the envelope we are sending.
3664 ** q -- the address to mark.
3665 ** mci -- mailer connection information.
3666 ** rcode -- the code signifying the particular failure.
3667 ** ovr -- override an existing code?
3673 ** marks the address (and possibly the envelope) with the
3674 ** failure so that an error will be returned or
3675 ** the message will be queued, as appropriate.
3679 markfailure(e
, q
, mci
, rcode
, ovr
)
3680 register ENVELOPE
*e
;
3681 register ADDRESS
*q
;
3686 int save_errno
= errno
;
3687 char *status
= NULL
;
3688 char *rstatus
= NULL
;
3698 q
->q_state
= QS_QUEUEUP
;
3702 q
->q_state
= QS_BADADDR
;
3706 /* find most specific error code possible */
3707 if (mci
!= NULL
&& mci
->mci_status
!= NULL
)
3709 status
= sm_rpool_strdup_x(e
->e_rpool
, mci
->mci_status
);
3710 if (mci
->mci_rstatus
!= NULL
)
3711 rstatus
= sm_rpool_strdup_x(e
->e_rpool
,
3716 else if (e
->e_status
!= NULL
)
3718 status
= e
->e_status
;
3747 case EX_UNAVAILABLE
:
3767 if (status
!= NULL
&& *status
!= '\0' && (ovr
|| q
->q_status
== NULL
||
3768 *q
->q_status
== '\0' || *q
->q_status
< *status
))
3770 q
->q_status
= status
;
3771 q
->q_rstatus
= rstatus
;
3773 if (rcode
!= EX_OK
&& q
->q_rstatus
== NULL
&&
3774 q
->q_mailer
!= NULL
&& q
->q_mailer
->m_diagtype
!= NULL
&&
3775 sm_strcasecmp(q
->q_mailer
->m_diagtype
, "X-UNIX") == 0)
3779 (void) sm_snprintf(buf
, sizeof(buf
), "%d", rcode
);
3780 q
->q_rstatus
= sm_rpool_strdup_x(e
->e_rpool
, buf
);
3783 q
->q_statdate
= curtime();
3784 if (CurHostName
!= NULL
&& CurHostName
[0] != '\0' &&
3785 mci
!= NULL
&& !bitset(M_LOCALMAILER
, mci
->mci_flags
))
3786 q
->q_statmta
= sm_rpool_strdup_x(e
->e_rpool
, CurHostName
);
3792 ** ENDMAILER -- Wait for mailer to terminate.
3794 ** We should never get fatal errors (e.g., segmentation
3795 ** violation), so we report those specially. For other
3796 ** errors, we choose a status message (into statmsg),
3797 ** and if it represents an error, we print it.
3800 ** mci -- the mailer connection info.
3801 ** e -- the current envelope.
3802 ** pv -- the parameter vector that invoked the mailer
3803 ** (for error messages).
3806 ** exit code of mailer.
3812 static jmp_buf EndWaitTimeout
;
3815 endwaittimeout(ignore
)
3819 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
3820 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
3825 longjmp(EndWaitTimeout
, 1);
3829 endmailer(mci
, e
, pv
)
3831 register ENVELOPE
*e
;
3835 int save_errno
= errno
;
3837 SM_EVENT
*ev
= NULL
;
3840 mci_unlock_host(mci
);
3842 /* close output to mailer */
3843 if (mci
->mci_out
!= NULL
)
3845 (void) sm_io_close(mci
->mci_out
, SM_TIME_DEFAULT
);
3846 mci
->mci_out
= NULL
;
3849 /* copy any remaining input to transcript */
3850 if (mci
->mci_in
!= NULL
&& mci
->mci_state
!= MCIS_ERROR
&&
3853 while (sfgets(buf
, sizeof(buf
), mci
->mci_in
,
3854 TimeOuts
.to_quit
, "Draining Input") != NULL
)
3855 (void) sm_io_fputs(e
->e_xfp
, SM_TIME_DEFAULT
, buf
);
3859 /* close SASL connection */
3860 if (bitset(MCIF_AUTHACT
, mci
->mci_flags
))
3862 sasl_dispose(&mci
->mci_conn
);
3863 mci
->mci_flags
&= ~MCIF_AUTHACT
;
3869 (void) endtlsclt(mci
);
3870 #endif /* STARTTLS */
3872 /* now close the input */
3873 if (mci
->mci_in
!= NULL
)
3875 (void) sm_io_close(mci
->mci_in
, SM_TIME_DEFAULT
);
3878 mci
->mci_state
= MCIS_CLOSED
;
3882 /* in the IPC case there is nothing to wait for */
3883 if (mci
->mci_pid
== 0)
3886 /* put a timeout around the wait */
3887 if (mci
->mci_mailer
->m_wait
> 0)
3889 if (setjmp(EndWaitTimeout
) == 0)
3890 ev
= sm_setevent(mci
->mci_mailer
->m_wait
,
3894 syserr("endmailer %s: wait timeout (%ld)",
3895 mci
->mci_mailer
->m_name
,
3896 (long) mci
->mci_mailer
->m_wait
);
3901 /* wait for the mailer process, collect status */
3902 st
= waitfor(mci
->mci_pid
);
3910 syserr("endmailer %s: wait", mci
->mci_mailer
->m_name
);
3916 /* normal death -- return status */
3917 return (WEXITSTATUS(st
));
3920 /* it died a horrid death */
3921 syserr("451 4.3.0 mailer %s died with signal %d%s",
3922 mci
->mci_mailer
->m_name
, WTERMSIG(st
),
3923 WCOREDUMP(st
) ? " (core dumped)" :
3924 (WIFSTOPPED(st
) ? " (stopped)" : ""));
3926 /* log the arguments */
3927 if (pv
!= NULL
&& e
->e_xfp
!= NULL
)
3931 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
, "Arguments:");
3932 for (av
= pv
; *av
!= NULL
; av
++)
3933 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
, " %s",
3935 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
, "\n");
3938 ExitStat
= EX_TEMPFAIL
;
3942 ** GIVERESPONSE -- Interpret an error response from a mailer
3945 ** status -- the status code from the mailer (high byte
3946 ** only; core dumps must have been taken care of
3948 ** dsn -- the DSN associated with the address, if any.
3949 ** m -- the mailer info for this mailer.
3950 ** mci -- the mailer connection info -- can be NULL if the
3951 ** response is given before the connection is made.
3952 ** ctladdr -- the controlling address for the recipient
3954 ** xstart -- the transaction start time, for computing
3955 ** transaction delays.
3956 ** e -- the current envelope.
3957 ** to -- the current recipient (NULL if none).
3963 ** Errors may be incremented.
3964 ** ExitStat may be set.
3968 giveresponse(status
, dsn
, m
, mci
, ctladdr
, xstart
, e
, to
)
3978 register const char *statmsg
;
3981 bool usestat
= false;
3982 char dsnbuf
[ENHSCLEN
];
3988 syserr("giveresponse: null envelope");
3994 ** Compute status message from code.
3997 exmsg
= sm_sysexmsg(status
);
4000 statmsg
= "250 2.0.0 Sent";
4001 if (e
->e_statmsg
!= NULL
)
4003 (void) sm_snprintf(buf
, sizeof(buf
), "%s (%s)",
4005 shortenstring(e
->e_statmsg
, 403));
4009 else if (exmsg
== NULL
)
4011 (void) sm_snprintf(buf
, sizeof(buf
),
4012 "554 5.3.0 unknown mailer error %d",
4014 status
= EX_UNAVAILABLE
;
4018 else if (status
== EX_TEMPFAIL
)
4022 (void) sm_strlcpy(bp
, exmsg
+ 1, SPACELEFT(buf
, bp
));
4025 if (h_errno
== TRY_AGAIN
)
4026 statmsg
= sm_errstring(h_errno
+ E_DNSBASE
);
4028 #endif /* NAMED_BIND */
4031 statmsg
= sm_errstring(errnum
);
4033 statmsg
= SmtpError
;
4035 if (statmsg
!= NULL
&& statmsg
[0] != '\0')
4040 case ENETDOWN
: /* Network is down */
4041 #endif /* ENETDOWN */
4043 case ENETUNREACH
: /* Network is unreachable */
4044 #endif /* ENETUNREACH */
4046 case ENETRESET
: /* Network dropped connection on reset */
4047 #endif /* ENETRESET */
4049 case ECONNABORTED
: /* Software caused connection abort */
4050 #endif /* ECONNABORTED */
4052 case EHOSTDOWN
: /* Host is down */
4053 #endif /* EHOSTDOWN */
4055 case EHOSTUNREACH
: /* No route to host */
4056 #endif /* EHOSTUNREACH */
4057 if (mci
!= NULL
&& mci
->mci_host
!= NULL
)
4059 (void) sm_strlcpyn(bp
,
4067 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ": ",
4074 else if (status
== EX_NOHOST
&& h_errno
!= 0)
4076 statmsg
= sm_errstring(h_errno
+ E_DNSBASE
);
4077 (void) sm_snprintf(buf
, sizeof(buf
), "%s (%s)", exmsg
+ 1,
4082 #endif /* NAMED_BIND */
4086 if (*statmsg
++ == ':' && errnum
!= 0)
4088 (void) sm_snprintf(buf
, sizeof(buf
), "%s: %s", statmsg
,
4089 sm_errstring(errnum
));
4093 else if (bitnset(M_LMTP
, m
->m_flags
) && e
->e_statmsg
!= NULL
)
4095 (void) sm_snprintf(buf
, sizeof(buf
), "%s (%s)", statmsg
,
4096 shortenstring(e
->e_statmsg
, 403));
4103 ** Print the message as appropriate
4106 if (status
== EX_OK
|| status
== EX_TEMPFAIL
)
4108 extern char MsgBuf
[];
4110 if ((off
= isenhsc(statmsg
+ 4, ' ')) > 0)
4114 (void) sm_snprintf(dsnbuf
, sizeof(dsnbuf
),
4115 "%.*s", off
, statmsg
+ 4);
4124 message("%s", statmsg
+ off
);
4125 if (status
== EX_TEMPFAIL
&& e
->e_xfp
!= NULL
)
4126 (void) sm_io_fprintf(e
->e_xfp
, SM_TIME_DEFAULT
, "%s\n",
4131 char mbuf
[ENHSCLEN
+ 4];
4134 if ((off
= isenhsc(statmsg
+ 4, ' ')) > 0 &&
4135 off
< sizeof(mbuf
) - 4)
4139 (void) sm_snprintf(dsnbuf
, sizeof(dsnbuf
),
4140 "%.*s", off
, statmsg
+ 4);
4145 /* copy only part of statmsg to mbuf */
4146 (void) sm_strlcpy(mbuf
, statmsg
, off
);
4147 (void) sm_strlcat(mbuf
, " %s", sizeof(mbuf
));
4152 (void) sm_snprintf(mbuf
, sizeof(mbuf
), "%.3s %%s",
4156 usrerr(mbuf
, &statmsg
[off
]);
4161 ** Log a record of the transaction. Compute the new
4162 ** ExitStat -- if we already had an error, stick with
4166 if (OpMode
!= MD_VERIFY
&& !bitset(EF_VRFYONLY
, e
->e_flags
) &&
4167 LogLevel
> ((status
== EX_TEMPFAIL
) ? 8 : (status
== EX_OK
) ? 7 : 6))
4168 logdelivery(m
, mci
, dsn
, statmsg
+ off
, ctladdr
, xstart
, e
);
4171 sm_dprintf("giveresponse: status=%d, dsn=%s, e->e_message=%s, errnum=%d\n",
4173 dsn
== NULL
? "<NULL>" : dsn
,
4174 e
->e_message
== NULL
? "<NULL>" : e
->e_message
,
4177 if (status
!= EX_TEMPFAIL
)
4179 if (status
!= EX_OK
&& (status
!= EX_TEMPFAIL
|| e
->e_message
== NULL
))
4180 e
->e_message
= sm_rpool_strdup_x(e
->e_rpool
, statmsg
+ off
);
4181 if (status
!= EX_OK
&& to
!= NULL
&& to
->q_message
== NULL
)
4183 if (!usestat
&& e
->e_message
!= NULL
)
4184 to
->q_message
= sm_rpool_strdup_x(e
->e_rpool
,
4187 to
->q_message
= sm_rpool_strdup_x(e
->e_rpool
,
4194 ** LOGDELIVERY -- log the delivery in the system log
4196 ** Care is taken to avoid logging lines that are too long, because
4197 ** some versions of syslog have an unfortunate proclivity for core
4198 ** dumping. This is a hack, to be sure, that is at best empirical.
4201 ** m -- the mailer info. Can be NULL for initial queue.
4202 ** mci -- the mailer connection info -- can be NULL if the
4203 ** log is occurring when no connection is active.
4204 ** dsn -- the DSN attached to the status.
4205 ** status -- the message to print for the status.
4206 ** ctladdr -- the controlling address for the to list.
4207 ** xstart -- the transaction start time, used for
4208 ** computing transaction delay.
4209 ** e -- the current envelope.
4219 logdelivery(m
, mci
, dsn
, status
, ctladdr
, xstart
, e
)
4226 register ENVELOPE
*e
;
4231 time_t now
= curtime();
4234 #if (SYSLOG_BUFSIZE) >= 256
4235 /* ctladdr: max 106 bytes */
4237 if (ctladdr
!= NULL
)
4239 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", ctladdr=",
4240 shortenstring(ctladdr
->q_paddr
, 83));
4242 if (bitset(QGOODUID
, ctladdr
->q_flags
))
4244 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
), " (%d/%d)",
4245 (int) ctladdr
->q_uid
,
4246 (int) ctladdr
->q_gid
);
4251 /* delay & xdelay: max 41 bytes */
4252 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", delay=",
4253 pintvl(now
- e
->e_ctime
, true));
4256 if (xstart
!= (time_t) 0)
4258 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", xdelay=",
4259 pintvl(now
- xstart
, true));
4263 /* mailer: assume about 19 bytes (max 10 byte mailer name) */
4266 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", mailer=",
4271 /* pri: changes with each delivery attempt */
4272 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
), ", pri=%ld",
4276 /* relay: max 66 bytes for IPv4 addresses */
4277 if (mci
!= NULL
&& mci
->mci_host
!= NULL
)
4279 extern SOCKADDR CurHostAddr
;
4281 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", relay=",
4282 shortenstring(mci
->mci_host
, 40));
4285 if (CurHostAddr
.sa
.sa_family
!= 0)
4287 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
), " [%s]",
4288 anynet_ntoa(&CurHostAddr
));
4291 else if (strcmp(status
, "quarantined") == 0)
4293 if (e
->e_quarmsg
!= NULL
)
4294 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
),
4296 shortenstring(e
->e_quarmsg
, 40));
4298 else if (strcmp(status
, "queued") != 0)
4300 p
= macvalue('h', e
);
4301 if (p
!= NULL
&& p
[0] != '\0')
4303 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
),
4304 ", relay=%s", shortenstring(p
, 40));
4310 if (dsn
!= NULL
&& *dsn
!= '\0')
4312 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", dsn=",
4313 shortenstring(dsn
, ENHSCLEN
));
4319 if (e
->e_ntries
>= 0)
4321 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
),
4322 ", ntries=%d", e
->e_ntries
+ 1);
4325 #endif /* _FFR_LOG_NTRIES */
4327 # define STATLEN (((SYSLOG_BUFSIZE) - 100) / 4)
4331 # endif /* (STATLEN) < 63 */
4332 # if (STATLEN) > 203
4334 # define STATLEN 203
4335 # endif /* (STATLEN) > 203 */
4337 /* stat: max 210 bytes */
4338 if ((bp
- buf
) > (sizeof(buf
) - ((STATLEN
) + 20)))
4340 /* desperation move -- truncate data */
4341 bp
= buf
+ sizeof(buf
) - ((STATLEN
) + 17);
4342 (void) sm_strlcpy(bp
, "...", SPACELEFT(buf
, bp
));
4346 (void) sm_strlcpy(bp
, ", stat=", SPACELEFT(buf
, bp
));
4349 (void) sm_strlcpy(bp
, shortenstring(status
, STATLEN
),
4350 SPACELEFT(buf
, bp
));
4352 /* id, to: max 13 + TOBUFSIZE bytes */
4353 l
= SYSLOG_BUFSIZE
- 100 - strlen(buf
);
4356 p
= e
->e_to
== NULL
? "NO-TO-LIST" : e
->e_to
;
4357 while (strlen(p
) >= l
)
4361 for (q
= p
+ l
; q
> p
; q
--)
4368 sm_syslog(LOG_INFO
, e
->e_id
, "to=%.*s [more]%s",
4369 (int) (++q
- p
), p
, buf
);
4372 sm_syslog(LOG_INFO
, e
->e_id
, "to=%.*s%s", l
, p
, buf
);
4374 #else /* (SYSLOG_BUFSIZE) >= 256 */
4376 l
= SYSLOG_BUFSIZE
- 85;
4379 p
= e
->e_to
== NULL
? "NO-TO-LIST" : e
->e_to
;
4380 while (strlen(p
) >= l
)
4384 for (q
= p
+ l
; q
> p
; q
--)
4392 sm_syslog(LOG_INFO
, e
->e_id
, "to=%.*s [more]",
4393 (int) (++q
- p
), p
);
4396 sm_syslog(LOG_INFO
, e
->e_id
, "to=%.*s", l
, p
);
4398 if (ctladdr
!= NULL
)
4401 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, "ctladdr=",
4402 shortenstring(ctladdr
->q_paddr
, 83));
4404 if (bitset(QGOODUID
, ctladdr
->q_flags
))
4406 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
), " (%d/%d)",
4407 ctladdr
->q_uid
, ctladdr
->q_gid
);
4410 sm_syslog(LOG_INFO
, e
->e_id
, "%s", buf
);
4413 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, "delay=",
4414 pintvl(now
- e
->e_ctime
, true));
4416 if (xstart
!= (time_t) 0)
4418 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", xdelay=",
4419 pintvl(now
- xstart
, true));
4425 (void) sm_strlcpyn(bp
, SPACELEFT(buf
, bp
), 2, ", mailer=",
4429 sm_syslog(LOG_INFO
, e
->e_id
, "%.1000s", buf
);
4433 if (mci
!= NULL
&& mci
->mci_host
!= NULL
)
4435 extern SOCKADDR CurHostAddr
;
4437 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
), "relay=%.100s",
4441 if (CurHostAddr
.sa
.sa_family
!= 0)
4442 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
),
4444 anynet_ntoa(&CurHostAddr
));
4446 else if (strcmp(status
, "quarantined") == 0)
4448 if (e
->e_quarmsg
!= NULL
)
4449 (void) sm_snprintf(bp
, SPACELEFT(buf
, bp
),
4450 ", quarantine=%.100s",
4453 else if (strcmp(status
, "queued") != 0)
4455 p
= macvalue('h', e
);
4456 if (p
!= NULL
&& p
[0] != '\0')
4457 (void) sm_snprintf(buf
, sizeof(buf
), "relay=%.100s", p
);
4460 sm_syslog(LOG_INFO
, e
->e_id
, "%.1000s", buf
);
4462 sm_syslog(LOG_INFO
, e
->e_id
, "stat=%s", shortenstring(status
, 63));
4463 #endif /* (SYSLOG_BUFSIZE) >= 256 */
4466 ** PUTFROMLINE -- output a UNIX-style from line (or whatever)
4468 ** This can be made an arbitrary message separator by changing $l
4470 ** One of the ugliest hacks seen by human eyes is contained herein:
4471 ** UUCP wants those stupid "remote from <host>" lines. Why oh why
4472 ** does a well-meaning programmer such as myself have to deal with
4473 ** this kind of antique garbage????
4476 ** mci -- the connection information.
4477 ** e -- the envelope.
4480 ** true iff line was written successfully
4483 ** outputs some text to fp.
4491 char *template = UnixFromLine
;
4495 if (bitnset(M_NHDR
, mci
->mci_mailer
->m_flags
))
4498 mci
->mci_flags
|= MCIF_INHEADER
;
4500 if (bitnset(M_UGLYUUCP
, mci
->mci_mailer
->m_flags
))
4504 expand("\201g", buf
, sizeof(buf
), e
);
4505 bang
= strchr(buf
, '!');
4509 char hname
[MAXNAME
];
4512 ** If we can construct a UUCP path, do so
4515 at
= strrchr(buf
, '@');
4518 expand("\201k", hname
, sizeof(hname
), e
);
4523 (void) sm_snprintf(xbuf
, sizeof(xbuf
),
4524 "From %.800s \201d remote from %.100s\n",
4530 (void) sm_snprintf(xbuf
, sizeof(xbuf
),
4531 "From %.800s \201d remote from %.100s\n",
4536 expand(template, buf
, sizeof(buf
), e
);
4537 return putxline(buf
, strlen(buf
), mci
, PXLF_HEADER
);
4541 ** PUTBODY -- put the body of a message.
4544 ** mci -- the connection information.
4545 ** e -- the envelope to put out.
4546 ** separator -- if non-NULL, a message separator that must
4547 ** not be permitted in the resulting message.
4550 ** true iff message was written successfully
4553 ** The message is written onto fp.
4556 /* values for output state variable */
4557 #define OSTATE_HEAD 0 /* at beginning of line */
4558 #define OSTATE_CR 1 /* read a carriage return */
4559 #define OSTATE_INLINE 2 /* putting rest of line */
4562 putbody(mci
, e
, separator
)
4564 register ENVELOPE
*e
;
4572 char *boundaries
[MAXMIMENESTING
+ 1];
4573 #endif /* MIME8TO7 */
4576 ** Output the body of the message
4579 if (e
->e_dfp
== NULL
&& bitset(EF_HAS_DF
, e
->e_flags
))
4581 char *df
= queuename(e
, DATAFL_LETTER
);
4583 e
->e_dfp
= sm_io_open(SmFtStdio
, SM_TIME_DEFAULT
, df
,
4584 SM_IO_RDONLY_B
, NULL
);
4585 if (e
->e_dfp
== NULL
)
4587 char *msg
= "!putbody: Cannot open %s for %s from %s";
4589 if (errno
== ENOENT
)
4591 syserr(msg
, df
, e
->e_to
, e
->e_from
.q_paddr
);
4595 if (e
->e_dfp
== NULL
)
4597 if (bitset(MCIF_INHEADER
, mci
->mci_flags
))
4599 if (!putline("", mci
))
4601 mci
->mci_flags
&= ~MCIF_INHEADER
;
4603 if (!putline("<<< No Message Collected >>>", mci
))
4608 if (e
->e_dfino
== (ino_t
) 0)
4612 if (fstat(sm_io_getinfo(e
->e_dfp
, SM_IO_WHAT_FD
, NULL
), &stbuf
)
4617 e
->e_dfdev
= stbuf
.st_dev
;
4618 e
->e_dfino
= stbuf
.st_ino
;
4622 /* paranoia: the data file should always be in a rewound state */
4623 (void) bfrewind(e
->e_dfp
);
4625 /* simulate an I/O timeout when used as source */
4630 if (bitset(MCIF_CVT8TO7
, mci
->mci_flags
))
4633 ** Do 8 to 7 bit MIME conversion.
4636 /* make sure it looks like a MIME message */
4637 if (hvalue("MIME-Version", e
->e_header
) == NULL
&&
4638 !putline("MIME-Version: 1.0", mci
))
4641 if (hvalue("Content-Type", e
->e_header
) == NULL
)
4643 (void) sm_snprintf(buf
, sizeof(buf
),
4644 "Content-Type: text/plain; charset=%s",
4646 if (!putline(buf
, mci
))
4650 /* now do the hard work */
4651 boundaries
[0] = NULL
;
4652 mci
->mci_flags
|= MCIF_INHEADER
;
4653 if (mime8to7(mci
, e
->e_header
, e
, boundaries
, M87F_OUTER
, 0) ==
4658 else if (bitset(MCIF_CVT7TO8
, mci
->mci_flags
))
4660 if (!mime7to8(mci
, e
->e_header
, e
))
4663 # endif /* MIME7TO8 */
4664 else if (MaxMimeHeaderLength
> 0 || MaxMimeFieldLength
> 0)
4666 bool oldsuprerrs
= SuprErrs
;
4668 /* Use mime8to7 to check multipart for MIME header overflows */
4669 boundaries
[0] = NULL
;
4670 mci
->mci_flags
|= MCIF_INHEADER
;
4673 ** If EF_DONT_MIME is set, we have a broken MIME message
4674 ** and don't want to generate a new bounce message whose
4675 ** body propagates the broken MIME. We can't just not call
4676 ** mime8to7() as is done above since we need the security
4677 ** checks. The best we can do is suppress the errors.
4680 if (bitset(EF_DONT_MIME
, e
->e_flags
))
4683 if (mime8to7(mci
, e
->e_header
, e
, boundaries
,
4684 M87F_OUTER
|M87F_NO8TO7
, 0) == SM_IO_EOF
)
4687 /* restore SuprErrs */
4688 SuprErrs
= oldsuprerrs
;
4691 #endif /* MIME8TO7 */
4703 if (bitset(MCIF_INHEADER
, mci
->mci_flags
))
4705 if (!putline("", mci
))
4707 mci
->mci_flags
&= ~MCIF_INHEADER
;
4710 /* determine end of buffer; allow for short mailer lines */
4711 buflim
= &buf
[sizeof(buf
) - 1];
4712 if (mci
->mci_mailer
->m_linelimit
> 0 &&
4713 mci
->mci_mailer
->m_linelimit
< sizeof(buf
) - 1)
4714 buflim
= &buf
[mci
->mci_mailer
->m_linelimit
- 1];
4716 /* copy temp file to output with mapping */
4717 ostate
= OSTATE_HEAD
;
4720 while (!sm_io_error(mci
->mci_out
) && !dead
)
4724 else if ((c
= sm_io_getc(e
->e_dfp
, SM_TIME_DEFAULT
))
4727 if (bitset(MCIF_7BIT
, mci
->mci_flags
))
4734 mci
->mci_mailer
->m_flags
))
4736 if (c
!= '\r' && c
!= '\n' && bp
< buflim
)
4742 /* check beginning of line for special cases */
4746 if (buf
[0] == 'F' &&
4747 bitnset(M_ESCFROM
, mci
->mci_mailer
->m_flags
)
4748 && strncmp(buf
, "From ", 5) == 0)
4752 if (buf
[0] == '-' && buf
[1] == '-' &&
4755 /* possible separator */
4756 int sl
= strlen(separator
);
4758 if (strncmp(&buf
[2], separator
, sl
)
4762 if (buf
[0] == '.' &&
4763 bitnset(M_XDOT
, mci
->mci_mailer
->m_flags
))
4768 /* now copy out saved line */
4769 if (TrafficLogFile
!= NULL
)
4771 (void) sm_io_fprintf(TrafficLogFile
,
4775 if (padc
!= SM_IO_EOF
)
4776 (void) sm_io_putc(TrafficLogFile
,
4779 for (xp
= buf
; xp
< bp
; xp
++)
4780 (void) sm_io_putc(TrafficLogFile
,
4782 (unsigned char) *xp
);
4784 (void) sm_io_fputs(TrafficLogFile
,
4786 mci
->mci_mailer
->m_eol
);
4788 if (padc
!= SM_IO_EOF
)
4790 if (sm_io_putc(mci
->mci_out
,
4791 SM_TIME_DEFAULT
, padc
)
4799 for (xp
= buf
; xp
< bp
; xp
++)
4801 if (sm_io_putc(mci
->mci_out
,
4803 (unsigned char) *xp
)
4814 if (sm_io_fputs(mci
->mci_out
,
4816 mci
->mci_mailer
->m_eol
)
4826 SM_ASSERT(pbp
< peekbuf
+
4834 /* determine next state */
4836 ostate
= OSTATE_HEAD
;
4840 ostate
= OSTATE_INLINE
;
4847 if (sm_io_fputs(mci
->mci_out
,
4849 mci
->mci_mailer
->m_eol
)
4853 if (TrafficLogFile
!= NULL
)
4855 (void) sm_io_fputs(TrafficLogFile
,
4857 mci
->mci_mailer
->m_eol
);
4860 ostate
= OSTATE_HEAD
;
4864 /* had a naked carriage return */
4865 SM_ASSERT(pbp
< peekbuf
+ sizeof(peekbuf
));
4868 ostate
= OSTATE_INLINE
;
4879 mci
->mci_mailer
->m_flags
))
4882 if (mci
->mci_mailer
->m_linelimit
> 0 &&
4883 pos
>= mci
->mci_mailer
->m_linelimit
- 1 &&
4888 /* check next character for EOL */
4891 else if ((d
= sm_io_getc(e
->e_dfp
,
4895 SM_ASSERT(pbp
< peekbuf
+
4900 if (d
== '\n' || d
== SM_IO_EOF
)
4902 if (TrafficLogFile
!= NULL
)
4903 (void) sm_io_putc(TrafficLogFile
,
4906 if (sm_io_putc(mci
->mci_out
,
4918 if (sm_io_putc(mci
->mci_out
,
4919 SM_TIME_DEFAULT
, '!')
4921 sm_io_fputs(mci
->mci_out
,
4923 mci
->mci_mailer
->m_eol
)
4930 if (TrafficLogFile
!= NULL
)
4932 (void) sm_io_fprintf(TrafficLogFile
,
4935 mci
->mci_mailer
->m_eol
);
4937 ostate
= OSTATE_HEAD
;
4938 SM_ASSERT(pbp
< peekbuf
+
4945 if (TrafficLogFile
!= NULL
)
4946 (void) sm_io_fputs(TrafficLogFile
,
4948 mci
->mci_mailer
->m_eol
);
4949 if (sm_io_fputs(mci
->mci_out
,
4951 mci
->mci_mailer
->m_eol
)
4955 ostate
= OSTATE_HEAD
;
4959 if (TrafficLogFile
!= NULL
)
4960 (void) sm_io_putc(TrafficLogFile
,
4963 if (sm_io_putc(mci
->mci_out
,
4972 ostate
= OSTATE_INLINE
;
4978 /* make sure we are at the beginning of a line */
4981 if (TrafficLogFile
!= NULL
)
4983 for (xp
= buf
; xp
< bp
; xp
++)
4984 (void) sm_io_putc(TrafficLogFile
,
4986 (unsigned char) *xp
);
4988 for (xp
= buf
; xp
< bp
; xp
++)
4990 if (sm_io_putc(mci
->mci_out
, SM_TIME_DEFAULT
,
4991 (unsigned char) *xp
)
5000 if (!dead
&& pos
> 0)
5002 if (TrafficLogFile
!= NULL
)
5003 (void) sm_io_fputs(TrafficLogFile
,
5005 mci
->mci_mailer
->m_eol
);
5006 if (sm_io_fputs(mci
->mci_out
, SM_TIME_DEFAULT
,
5007 mci
->mci_mailer
->m_eol
) == SM_IO_EOF
)
5012 if (sm_io_error(e
->e_dfp
))
5014 syserr("putbody: %s/%cf%s: read error",
5015 qid_printqueue(e
->e_dfqgrp
, e
->e_dfqdir
),
5016 DATAFL_LETTER
, e
->e_id
);
5017 ExitStat
= EX_IOERR
;
5023 ** Since mailfile() uses e_dfp in a child process,
5024 ** the file offset in the stdio library for the
5025 ** parent process will not agree with the in-kernel
5026 ** file offset since the file descriptor is shared
5027 ** between the processes. Therefore, it is vital
5028 ** that the file always be rewound. This forces the
5029 ** kernel offset (lseek) and stdio library (ftell)
5034 if (e
->e_dfp
!= NULL
)
5035 (void) bfrewind(e
->e_dfp
);
5037 /* some mailers want extra blank line at end of message */
5038 if (!dead
&& bitnset(M_BLANKEND
, mci
->mci_mailer
->m_flags
) &&
5039 buf
[0] != '\0' && buf
[0] != '\n')
5041 if (!putline("", mci
))
5046 (sm_io_flush(mci
->mci_out
, SM_TIME_DEFAULT
) == SM_IO_EOF
||
5047 (sm_io_error(mci
->mci_out
) && errno
!= EPIPE
)))
5050 syserr("putbody: write error");
5051 ExitStat
= EX_IOERR
;
5056 return !dead
&& !ioerr
;
5063 ** MAILFILE -- Send a message to a file.
5065 ** If the file has the set-user-ID/set-group-ID bits set, but NO
5066 ** execute bits, sendmail will try to become the owner of that file
5067 ** rather than the real user. Obviously, this only works if
5068 ** sendmail runs as root.
5070 ** This could be done as a subordinate mailer, except that it
5071 ** is used implicitly to save messages in ~/dead.letter. We
5072 ** view this as being sufficiently important as to include it
5073 ** here. For example, if the system is dying, we shouldn't have
5074 ** to create another process plus some pipes to save the message.
5077 ** filename -- the name of the file to send to.
5078 ** mailer -- mailer definition for recipient -- if NULL,
5080 ** ctladdr -- the controlling address header -- includes
5081 ** the userid/groupid to be when sending.
5082 ** sfflags -- flags for opening.
5083 ** e -- the current envelope.
5086 ** The exit code associated with the operation.
5092 # define RETURN(st) exit(st);
5094 static jmp_buf CtxMailfileTimeout
;
5097 mailfile(filename
, mailer
, ctladdr
, sfflags
, e
)
5098 char *volatile filename
;
5099 MAILER
*volatile mailer
;
5101 volatile long sfflags
;
5102 register ENVELOPE
*e
;
5104 register SM_FILE_T
*f
;
5105 register pid_t pid
= -1;
5109 bool suidwarn
= geteuid() == 0;
5111 char *volatile realfile
;
5113 char buf
[MAXPATHLEN
];
5114 char targetfile
[MAXPATHLEN
];
5118 sm_dprintf("mailfile %s\n ctladdr=", filename
);
5119 printaddr(sm_debug_file(), ctladdr
, false);
5123 mailer
= FileMailer
;
5125 if (e
->e_xfp
!= NULL
)
5126 (void) sm_io_flush(e
->e_xfp
, SM_TIME_DEFAULT
);
5129 ** Special case /dev/null. This allows us to restrict file
5130 ** delivery to regular files only.
5133 if (sm_path_isdevnull(filename
))
5136 /* check for 8-bit available */
5137 if (bitset(EF_HAS8BIT
, e
->e_flags
) &&
5138 bitnset(M_7BITS
, mailer
->m_flags
) &&
5139 (bitset(EF_DONT_MIME
, e
->e_flags
) ||
5140 !(bitset(MM_MIME8BIT
, MimeMode
) ||
5141 (bitset(EF_IS_MIME
, e
->e_flags
) &&
5142 bitset(MM_CVTMIME
, MimeMode
)))))
5144 e
->e_status
= "5.6.3";
5145 usrerrenh(e
->e_status
,
5146 "554 Cannot send 8-bit data to 7-bit destination");
5151 /* Find the actual file */
5152 if (SafeFileEnv
!= NULL
&& SafeFileEnv
[0] != '\0')
5154 len
= strlen(SafeFileEnv
);
5156 if (strncmp(SafeFileEnv
, filename
, len
) == 0)
5159 if (len
+ strlen(filename
) + 1 >= sizeof(targetfile
))
5161 syserr("mailfile: filename too long (%s/%s)",
5162 SafeFileEnv
, filename
);
5163 return EX_CANTCREAT
;
5165 (void) sm_strlcpy(targetfile
, SafeFileEnv
, sizeof(targetfile
));
5166 realfile
= targetfile
+ len
;
5167 if (*filename
== '/')
5169 if (*filename
!= '\0')
5171 /* paranoia: trailing / should be removed in readcf */
5172 if (targetfile
[len
- 1] != '/')
5173 (void) sm_strlcat(targetfile
,
5174 "/", sizeof(targetfile
));
5175 (void) sm_strlcat(targetfile
, filename
,
5176 sizeof(targetfile
));
5179 else if (mailer
->m_rootdir
!= NULL
)
5181 expand(mailer
->m_rootdir
, targetfile
, sizeof(targetfile
), e
);
5182 len
= strlen(targetfile
);
5184 if (strncmp(targetfile
, filename
, len
) == 0)
5187 if (len
+ strlen(filename
) + 1 >= sizeof(targetfile
))
5189 syserr("mailfile: filename too long (%s/%s)",
5190 targetfile
, filename
);
5191 return EX_CANTCREAT
;
5193 realfile
= targetfile
+ len
;
5194 if (targetfile
[len
- 1] != '/')
5195 (void) sm_strlcat(targetfile
, "/", sizeof(targetfile
));
5196 if (*filename
== '/')
5197 (void) sm_strlcat(targetfile
, filename
+ 1,
5198 sizeof(targetfile
));
5200 (void) sm_strlcat(targetfile
, filename
,
5201 sizeof(targetfile
));
5205 if (sm_strlcpy(targetfile
, filename
, sizeof(targetfile
)) >=
5208 syserr("mailfile: filename too long (%s)", filename
);
5209 return EX_CANTCREAT
;
5211 realfile
= targetfile
;
5215 ** Fork so we can change permissions here.
5216 ** Note that we MUST use fork, not vfork, because of
5217 ** the complications of calling subroutines, etc.
5222 ** Dispose of SIGCHLD signal catchers that may be laying
5223 ** around so that the waitfor() below will get it.
5226 (void) sm_signal(SIGCHLD
, SIG_DFL
);
5234 /* child -- actually write to file */
5238 volatile int oflags
= O_WRONLY
|O_APPEND
;
5240 /* Reset global flags */
5241 RestartRequest
= NULL
;
5242 RestartWorkGroup
= false;
5243 ShutdownRequest
= NULL
;
5245 CurrentPid
= getpid();
5247 if (e
->e_lockfp
!= NULL
)
5251 fd
= sm_io_getinfo(e
->e_lockfp
, SM_IO_WHAT_FD
, NULL
);
5252 /* SM_ASSERT(fd >= 0); */
5257 (void) sm_signal(SIGINT
, SIG_DFL
);
5258 (void) sm_signal(SIGHUP
, SIG_DFL
);
5259 (void) sm_signal(SIGTERM
, SIG_DFL
);
5260 (void) umask(OldUmask
);
5264 if (setjmp(CtxMailfileTimeout
) != 0)
5266 RETURN(EX_TEMPFAIL
);
5269 if (TimeOuts
.to_fileopen
> 0)
5270 ev
= sm_setevent(TimeOuts
.to_fileopen
, mailfiletimeout
,
5275 /* check file mode to see if set-user-ID */
5276 if (stat(targetfile
, &stb
) < 0)
5281 /* limit the errors to those actually caused in the child */
5285 /* Allow alias expansions to use the S_IS{U,G}ID bits */
5286 if ((ctladdr
!= NULL
&& !bitset(QALIAS
, ctladdr
->q_flags
)) ||
5287 bitset(SFF_RUNASREALUID
, sfflags
))
5289 /* ignore set-user-ID and set-group-ID bits */
5290 mode
&= ~(S_ISGID
|S_ISUID
);
5292 sm_dprintf("mailfile: ignoring set-user-ID/set-group-ID bits\n");
5295 /* we have to open the data file BEFORE setuid() */
5296 if (e
->e_dfp
== NULL
&& bitset(EF_HAS_DF
, e
->e_flags
))
5298 char *df
= queuename(e
, DATAFL_LETTER
);
5300 e
->e_dfp
= sm_io_open(SmFtStdio
, SM_TIME_DEFAULT
, df
,
5301 SM_IO_RDONLY_B
, NULL
);
5302 if (e
->e_dfp
== NULL
)
5304 syserr("mailfile: Cannot open %s for %s from %s",
5305 df
, e
->e_to
, e
->e_from
.q_paddr
);
5309 /* select a new user to run as */
5310 if (!bitset(SFF_RUNASREALUID
, sfflags
))
5312 if (bitnset(M_SPECIFIC_UID
, mailer
->m_flags
))
5314 RealUserName
= NULL
;
5315 if (mailer
->m_uid
== NO_UID
)
5318 RealUid
= mailer
->m_uid
;
5319 if (RunAsUid
!= 0 && RealUid
!= RunAsUid
)
5321 /* Only root can change the uid */
5322 syserr("mailfile: insufficient privileges to change uid, RunAsUid=%d, RealUid=%d",
5323 (int) RunAsUid
, (int) RealUid
);
5324 RETURN(EX_TEMPFAIL
);
5327 else if (bitset(S_ISUID
, mode
))
5329 RealUserName
= NULL
;
5330 RealUid
= stb
.st_uid
;
5332 else if (ctladdr
!= NULL
&& ctladdr
->q_uid
!= 0)
5334 if (ctladdr
->q_ruser
!= NULL
)
5335 RealUserName
= ctladdr
->q_ruser
;
5337 RealUserName
= ctladdr
->q_user
;
5338 RealUid
= ctladdr
->q_uid
;
5340 else if (mailer
!= NULL
&& mailer
->m_uid
!= NO_UID
)
5342 RealUserName
= DefUser
;
5343 RealUid
= mailer
->m_uid
;
5347 RealUserName
= DefUser
;
5351 /* select a new group to run as */
5352 if (bitnset(M_SPECIFIC_UID
, mailer
->m_flags
))
5354 if (mailer
->m_gid
== NO_GID
)
5357 RealGid
= mailer
->m_gid
;
5358 if (RunAsUid
!= 0 &&
5359 (RealGid
!= getgid() ||
5360 RealGid
!= getegid()))
5362 /* Only root can change the gid */
5363 syserr("mailfile: insufficient privileges to change gid, RealGid=%d, RunAsUid=%d, gid=%d, egid=%d",
5364 (int) RealGid
, (int) RunAsUid
,
5365 (int) getgid(), (int) getegid());
5366 RETURN(EX_TEMPFAIL
);
5369 else if (bitset(S_ISGID
, mode
))
5370 RealGid
= stb
.st_gid
;
5371 else if (ctladdr
!= NULL
&&
5372 ctladdr
->q_uid
== DefUid
&&
5373 ctladdr
->q_gid
== 0)
5376 ** Special case: This means it is an
5377 ** alias and we should act as DefaultUser.
5378 ** See alias()'s comments.
5382 RealUserName
= DefUser
;
5384 else if (ctladdr
!= NULL
&& ctladdr
->q_uid
!= 0)
5385 RealGid
= ctladdr
->q_gid
;
5386 else if (mailer
!= NULL
&& mailer
->m_gid
!= NO_GID
)
5387 RealGid
= mailer
->m_gid
;
5393 if (!bitset(SFF_ROOTOK
, sfflags
))
5401 /* set group id list (needs /etc/group access) */
5402 if (RealUserName
!= NULL
&& !DontInitGroups
)
5404 if (initgroups(RealUserName
, RealGid
) == -1 && suidwarn
)
5406 syserr("mailfile: initgroups(%s, %d) failed",
5407 RealUserName
, RealGid
);
5408 RETURN(EX_TEMPFAIL
);
5415 gidset
[0] = RealGid
;
5416 if (setgroups(1, gidset
) == -1 && suidwarn
)
5418 syserr("mailfile: setgroups() failed");
5419 RETURN(EX_TEMPFAIL
);
5424 ** If you have a safe environment, go into it.
5427 if (realfile
!= targetfile
)
5434 sm_dprintf("mailfile: chroot %s\n", targetfile
);
5435 if (chroot(targetfile
) < 0)
5437 syserr("mailfile: Cannot chroot(%s)",
5439 RETURN(EX_CANTCREAT
);
5445 sm_dprintf("mailfile: deliver to %s\n", realfile
);
5449 syserr("mailfile: cannot chdir(/)");
5450 RETURN(EX_CANTCREAT
);
5453 /* now reset the group and user ids */
5455 sm_mbdb_terminate();
5456 if (setgid(RealGid
) < 0 && suidwarn
)
5458 syserr("mailfile: setgid(%ld) failed", (long) RealGid
);
5459 RETURN(EX_TEMPFAIL
);
5461 vendor_set_uid(RealUid
);
5462 if (setuid(RealUid
) < 0 && suidwarn
)
5464 syserr("mailfile: setuid(%ld) failed", (long) RealUid
);
5465 RETURN(EX_TEMPFAIL
);
5469 sm_dprintf("mailfile: running as r/euid=%d/%d, r/egid=%d/%d\n",
5470 (int) getuid(), (int) geteuid(),
5471 (int) getgid(), (int) getegid());
5474 /* move into some "safe" directory */
5475 if (mailer
->m_execdir
!= NULL
)
5479 for (p
= mailer
->m_execdir
; p
!= NULL
; p
= q
)
5484 expand(p
, buf
, sizeof(buf
), e
);
5488 sm_dprintf("mailfile: trydir %s\n",
5490 if (buf
[0] != '\0' && chdir(buf
) >= 0)
5496 ** Recheck the file after we have assumed the ID of the
5497 ** delivery user to make sure we can deliver to it as
5498 ** that user. This is necessary if sendmail is running
5499 ** as root and the file is on an NFS mount which treats
5504 if (bitnset(DBS_FILEDELIVERYTOSYMLINK
, DontBlameSendmail
))
5505 err
= stat(realfile
, &stb
);
5507 err
= lstat(realfile
, &stb
);
5508 #else /* HASLSTAT */
5509 err
= stat(realfile
, &stb
);
5510 #endif /* HASLSTAT */
5514 stb
.st_mode
= ST_MODE_NOFILE
;
5516 oflags
|= O_CREAT
|O_EXCL
;
5518 else if (bitset(S_IXUSR
|S_IXGRP
|S_IXOTH
, mode
) ||
5519 (!bitnset(DBS_FILEDELIVERYTOHARDLINK
,
5520 DontBlameSendmail
) &&
5521 stb
.st_nlink
!= 1) ||
5522 (realfile
!= targetfile
&& !S_ISREG(mode
)))
5527 if (!bitnset(DBS_FILEDELIVERYTOSYMLINK
, DontBlameSendmail
))
5528 sfflags
|= SFF_NOSLINK
;
5529 if (!bitnset(DBS_FILEDELIVERYTOHARDLINK
, DontBlameSendmail
))
5530 sfflags
|= SFF_NOHLINK
;
5531 sfflags
&= ~SFF_OPENASROOT
;
5532 f
= safefopen(realfile
, oflags
, mode
, sfflags
);
5535 if (transienterror(errno
))
5537 usrerr("454 4.3.0 cannot open %s: %s",
5538 shortenstring(realfile
, MAXSHORTSTR
),
5539 sm_errstring(errno
));
5540 RETURN(EX_TEMPFAIL
);
5544 usrerr("554 5.3.0 cannot open %s: %s",
5545 shortenstring(realfile
, MAXSHORTSTR
),
5546 sm_errstring(errno
));
5547 RETURN(EX_CANTCREAT
);
5550 if (filechanged(realfile
, sm_io_getinfo(f
, SM_IO_WHAT_FD
, NULL
),
5553 syserr("554 5.3.0 file changed after open");
5554 RETURN(EX_CANTCREAT
);
5556 if (fstat(sm_io_getinfo(f
, SM_IO_WHAT_FD
, NULL
), &stb
) < 0)
5558 syserr("554 5.3.0 cannot fstat %s",
5559 sm_errstring(errno
));
5560 RETURN(EX_CANTCREAT
);
5563 curoff
= stb
.st_size
;
5568 memset(&mcibuf
, '\0', sizeof(mcibuf
));
5569 mcibuf
.mci_mailer
= mailer
;
5571 if (bitnset(M_7BITS
, mailer
->m_flags
))
5572 mcibuf
.mci_flags
|= MCIF_7BIT
;
5574 /* clear out per-message flags from connection structure */
5575 mcibuf
.mci_flags
&= ~(MCIF_CVT7TO8
|MCIF_CVT8TO7
);
5577 if (bitset(EF_HAS8BIT
, e
->e_flags
) &&
5578 !bitset(EF_DONT_MIME
, e
->e_flags
) &&
5579 bitnset(M_7BITS
, mailer
->m_flags
))
5580 mcibuf
.mci_flags
|= MCIF_CVT8TO7
;
5583 if (bitnset(M_MAKE8BIT
, mailer
->m_flags
) &&
5584 !bitset(MCIF_7BIT
, mcibuf
.mci_flags
) &&
5585 (p
= hvalue("Content-Transfer-Encoding", e
->e_header
)) != NULL
&&
5586 (sm_strcasecmp(p
, "quoted-printable") == 0 ||
5587 sm_strcasecmp(p
, "base64") == 0) &&
5588 (p
= hvalue("Content-Type", e
->e_header
)) != NULL
)
5590 /* may want to convert 7 -> 8 */
5591 /* XXX should really parse it here -- and use a class XXX */
5592 if (sm_strncasecmp(p
, "text/plain", 10) == 0 &&
5593 (p
[10] == '\0' || p
[10] == ' ' || p
[10] == ';'))
5594 mcibuf
.mci_flags
|= MCIF_CVT7TO8
;
5596 #endif /* MIME7TO8 */
5598 if (!putfromline(&mcibuf
, e
) ||
5599 !(*e
->e_puthdr
)(&mcibuf
, e
->e_header
, e
, M87F_OUTER
) ||
5600 !(*e
->e_putbody
)(&mcibuf
, e
, NULL
) ||
5601 !putline("\n", &mcibuf
) ||
5602 (sm_io_flush(f
, SM_TIME_DEFAULT
) != 0 ||
5603 (SuperSafe
!= SAFE_NO
&&
5604 fsync(sm_io_getinfo(f
, SM_IO_WHAT_FD
, NULL
)) < 0) ||
5609 (void) ftruncate(sm_io_getinfo(f
, SM_IO_WHAT_FD
, NULL
),
5611 #endif /* !NOFTRUNCATE */
5614 /* reset ISUID & ISGID bits for paranoid systems */
5616 (void) fchmod(sm_io_getinfo(f
, SM_IO_WHAT_FD
, NULL
),
5618 #else /* HASFCHMOD */
5619 (void) chmod(filename
, (MODE_T
) mode
);
5620 #endif /* HASFCHMOD */
5621 if (sm_io_close(f
, SM_TIME_DEFAULT
) < 0)
5623 (void) sm_io_flush(smioout
, SM_TIME_DEFAULT
);
5624 (void) setuid(RealUid
);
5630 /* parent -- wait for exit status */
5636 syserr("mailfile: %s: wait", mailer
->m_name
);
5642 return (WEXITSTATUS(st
));
5646 syserr("mailfile: %s: child died on signal %d",
5647 mailer
->m_name
, st
);
5648 return EX_UNAVAILABLE
;
5652 return EX_UNAVAILABLE
; /* avoid compiler warning on IRIX */
5656 mailfiletimeout(ignore
)
5660 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
5661 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
5666 longjmp(CtxMailfileTimeout
, 1);
5669 ** HOSTSIGNATURE -- return the "signature" for a host.
5671 ** The signature describes how we are going to send this -- it
5672 ** can be just the hostname (for non-Internet hosts) or can be
5673 ** an ordered list of MX hosts.
5676 ** m -- the mailer describing this host.
5677 ** host -- the host name.
5680 ** The signature for this host.
5683 ** Can tweak the symbol table.
5686 #define MAXHOSTSIGNATURE 8192 /* max len of hostsignature */
5689 hostsignature(m
, host
)
5705 int oldoptions
= _res
.options
;
5706 char *mxhosts
[MAXMXHOSTS
+ 1];
5707 unsigned short mxprefs
[MAXMXHOSTS
+ 1];
5708 #endif /* NAMED_BIND */
5711 sm_dprintf("hostsignature(%s)\n", host
);
5714 ** If local delivery (and not remote), just return a constant.
5717 if (bitnset(M_LOCALMAILER
, m
->m_flags
) &&
5718 strcmp(m
->m_mailer
, "[IPC]") != 0 &&
5719 !(m
->m_argv
[0] != NULL
&& strcmp(m
->m_argv
[0], "TCP") == 0))
5722 /* an empty host does not have MX records */
5727 ** Check to see if this uses IPC -- if not, it can't have MX records.
5730 if (strcmp(m
->m_mailer
, "[IPC]") != 0 ||
5731 CurEnv
->e_sendmode
== SM_DEFER
)
5733 /* just an ordinary mailer or deferred mode */
5737 else if (m
->m_argv
[0] != NULL
&&
5738 strcmp(m
->m_argv
[0], "FILE") == 0)
5740 /* rendezvous in the file system, no MX records */
5743 #endif /* NETUNIX */
5746 ** Look it up in the symbol table.
5750 s
= stab(host
, ST_HOSTSIG
, ST_ENTER
);
5751 if (s
->s_hostsig
.hs_sig
!= NULL
)
5753 if (s
->s_hostsig
.hs_exp
>= now
)
5756 sm_dprintf("hostsignature(): stab(%s) found %s\n", host
,
5757 s
->s_hostsig
.hs_sig
);
5758 return s
->s_hostsig
.hs_sig
;
5761 /* signature is expired: clear it */
5762 sm_free(s
->s_hostsig
.hs_sig
);
5763 s
->s_hostsig
.hs_sig
= NULL
;
5766 /* set default TTL */
5767 s
->s_hostsig
.hs_exp
= now
+ SM_DEFAULT_TTL
;
5770 ** Not already there or expired -- create a signature.
5774 if (ConfigLevel
< 2)
5775 _res
.options
&= ~(RES_DEFNAMES
| RES_DNSRCH
); /* XXX */
5777 for (hp
= host
; hp
!= NULL
; hp
= endp
)
5782 endp
= strchr(hp
+ 1, ']');
5784 endp
= strpbrk(endp
+ 1, ":,");
5787 endp
= strpbrk(hp
, ":,");
5788 #else /* NETINET6 */
5789 endp
= strpbrk(hp
, ":,");
5790 #endif /* NETINET6 */
5797 if (bitnset(M_NOMX
, m
->m_flags
))
5799 /* skip MX lookups */
5808 nmx
= getmxrr(hp
, mxhosts
, mxprefs
, true, &rcode
, true,
5815 /* update the connection info for this host */
5817 mci
= mci_get(hp
, m
);
5818 mci
->mci_errno
= save_errno
;
5819 mci
->mci_herrno
= h_errno
;
5820 mci
->mci_lastuse
= now
;
5821 if (rcode
== EX_NOHOST
)
5822 mci_setstat(mci
, rcode
, "5.1.2",
5823 "550 Host unknown");
5825 mci_setstat(mci
, rcode
, NULL
, NULL
);
5827 /* use the original host name as signature */
5832 sm_dprintf("hostsignature(): getmxrr() returned %d, mxhosts[0]=%s\n",
5836 ** Set new TTL: we use only one!
5837 ** We could try to use the minimum instead.
5840 s
->s_hostsig
.hs_exp
= now
+ SM_MIN(ttl
, SM_DEFAULT_TTL
);
5844 for (i
= 0; i
< nmx
; i
++)
5845 len
+= strlen(mxhosts
[i
]) + 1;
5846 if (s
->s_hostsig
.hs_sig
!= NULL
)
5847 len
+= strlen(s
->s_hostsig
.hs_sig
) + 1;
5848 if (len
< 0 || len
>= MAXHOSTSIGNATURE
)
5850 sm_syslog(LOG_WARNING
, NOQID
, "hostsignature for host '%s' exceeds maxlen (%d): %d",
5851 host
, MAXHOSTSIGNATURE
, len
);
5852 len
= MAXHOSTSIGNATURE
;
5854 p
= sm_pmalloc_x(len
);
5855 if (s
->s_hostsig
.hs_sig
!= NULL
)
5857 (void) sm_strlcpy(p
, s
->s_hostsig
.hs_sig
, len
);
5858 sm_free(s
->s_hostsig
.hs_sig
); /* XXX */
5859 s
->s_hostsig
.hs_sig
= p
;
5866 s
->s_hostsig
.hs_sig
= p
;
5867 for (i
= 0; i
< nmx
; i
++)
5869 hl
= strlen(mxhosts
[i
]);
5870 if (len
- 1 < hl
|| len
<= 1)
5872 /* force to drop out of outer loop */
5878 if (mxprefs
[i
] == mxprefs
[i
- 1])
5884 (void) sm_strlcpy(p
, mxhosts
[i
], len
);
5890 ** break out of loop if len exceeded MAXHOSTSIGNATURE
5891 ** because we won't have more space for further hosts
5892 ** anyway (separated by : in the .cf file).
5901 makelower(s
->s_hostsig
.hs_sig
);
5902 if (ConfigLevel
< 2)
5903 _res
.options
= oldoptions
;
5904 #else /* NAMED_BIND */
5905 /* not using BIND -- the signature is just the host name */
5907 ** 'host' points to storage that will be freed after we are
5908 ** done processing the current envelope, so we copy it.
5910 s
->s_hostsig
.hs_sig
= sm_pstrdup_x(host
);
5911 #endif /* NAMED_BIND */
5913 sm_dprintf("hostsignature(%s) = %s\n", host
, s
->s_hostsig
.hs_sig
);
5914 return s
->s_hostsig
.hs_sig
;
5917 ** PARSE_HOSTSIGNATURE -- parse the "signature" and return MX host array.
5919 ** The signature describes how we are going to send this -- it
5920 ** can be just the hostname (for non-Internet hosts) or can be
5921 ** an ordered list of MX hosts which must be randomized for equal
5922 ** MX preference values.
5925 ** sig -- the host signature.
5926 ** mxhosts -- array to populate.
5927 ** mailer -- mailer.
5930 ** The number of hosts inserted into mxhosts array.
5933 ** Randomizes equal MX preference hosts in mxhosts.
5937 parse_hostsignature(sig
, mxhosts
, mailer
)
5942 unsigned short curpref
= 0;
5943 int nmx
= 0, i
, j
; /* NOTE: i, j, and nmx must have same type */
5945 unsigned short prefer
[MAXMXHOSTS
];
5946 long rndm
[MAXMXHOSTS
];
5948 for (hp
= sig
; hp
!= NULL
; hp
= endp
)
5955 endp
= strchr(hp
+ 1, ']');
5957 endp
= strpbrk(endp
+ 1, ":,");
5960 endp
= strpbrk(hp
, ":,");
5961 #else /* NETINET6 */
5962 endp
= strpbrk(hp
, ":,");
5963 #endif /* NETINET6 */
5971 prefer
[nmx
] = curpref
;
5972 if (mci_match(hp
, mailer
))
5975 rndm
[nmx
] = get_random();
5980 ** Since we don't have the original MX prefs,
5981 ** make our own. If the separator is a ':', that
5982 ** means the preference for the next host will be
5983 ** higher than this one, so simply increment curpref.
5991 if (++nmx
>= MAXMXHOSTS
)
5995 /* sort the records using the random factor for equal preferences */
5996 for (i
= 0; i
< nmx
; i
++)
5998 for (j
= i
+ 1; j
< nmx
; j
++)
6001 ** List is already sorted by MX preference, only
6002 ** need to look for equal preference MX records
6005 if (prefer
[i
] < prefer
[j
])
6008 if (prefer
[i
] > prefer
[j
] ||
6009 (prefer
[i
] == prefer
[j
] && rndm
[i
] > rndm
[j
]))
6011 register unsigned short tempp
;
6012 register long tempr
;
6013 register char *temp1
;
6016 prefer
[i
] = prefer
[j
];
6019 mxhosts
[i
] = mxhosts
[j
];
6031 static SSL_CTX
*clt_ctx
= NULL
;
6032 static bool tls_ok_clt
= true;
6035 ** SETCLTTLS -- client side TLS: allow/disallow.
6038 ** tls_ok -- should tls be done?
6044 ** sets tls_ok_clt (static variable in this module)
6051 tls_ok_clt
= tls_ok
;
6055 ** INITCLTTLS -- initialize client side TLS
6058 ** tls_ok -- should tls initialization be done?
6064 ** sets tls_ok_clt (static variable in this module)
6073 tls_ok_clt
= tls_ok
;
6076 if (clt_ctx
!= NULL
)
6077 return true; /* already done */
6078 tls_ok_clt
= inittls(&clt_ctx
, TLS_I_CLT
, false, CltCertFile
,
6079 CltKeyFile
, CACertPath
, CACertFile
, DHParams
);
6084 ** STARTTLS -- try to start secure connection (client side)
6088 ** mci -- the mailer connection info.
6089 ** e -- the envelope.
6093 ** (maybe this should be some other code than EX_
6094 ** that denotes which stage failed.)
6106 SSL
*clt_ssl
= NULL
;
6109 if (clt_ctx
== NULL
&& !initclttls(true))
6111 smtpmessage("STARTTLS", m
, mci
);
6114 smtpresult
= reply(m
, mci
, e
, TimeOuts
.to_starttls
, NULL
, NULL
,
6117 /* check return code from server */
6118 if (REPLYTYPE(smtpresult
) == 4)
6120 if (smtpresult
== 501)
6122 if (smtpresult
== -1)
6125 /* not an expected reply but we have to deal with it */
6126 if (REPLYTYPE(smtpresult
) == 5)
6127 return EX_UNAVAILABLE
;
6128 if (smtpresult
!= 220)
6132 sm_syslog(LOG_INFO
, NOQID
, "STARTTLS=client, start=ok");
6134 /* start connection */
6135 if ((clt_ssl
= SSL_new(clt_ctx
)) == NULL
)
6139 sm_syslog(LOG_ERR
, NOQID
,
6140 "STARTTLS=client, error: SSL_new failed");
6142 tlslogerr("client");
6147 rfd
= sm_io_getinfo(mci
->mci_in
, SM_IO_WHAT_FD
, NULL
);
6148 wfd
= sm_io_getinfo(mci
->mci_out
, SM_IO_WHAT_FD
, NULL
);
6150 /* SSL_clear(clt_ssl); ? */
6151 if (rfd
< 0 || wfd
< 0 ||
6152 (result
= SSL_set_rfd(clt_ssl
, rfd
)) != 1 ||
6153 (result
= SSL_set_wfd(clt_ssl
, wfd
)) != 1)
6157 sm_syslog(LOG_ERR
, NOQID
,
6158 "STARTTLS=client, error: SSL_set_xfd failed=%d",
6161 tlslogerr("client");
6165 SSL_set_connect_state(clt_ssl
);
6166 tlsstart
= curtime();
6169 if ((result
= SSL_connect(clt_ssl
)) <= 0)
6173 ssl_err
= SSL_get_error(clt_ssl
, result
);
6174 i
= tls_retry(clt_ssl
, rfd
, wfd
, tlsstart
,
6175 TimeOuts
.to_starttls
, ssl_err
, "client");
6181 sm_syslog(LOG_WARNING
, NOQID
,
6182 "STARTTLS=client, error: connect failed=%d, SSL_error=%d, errno=%d, retry=%d",
6183 result
, ssl_err
, errno
, i
);
6185 tlslogerr("client");
6192 mci
->mci_ssl
= clt_ssl
;
6193 result
= tls_get_info(mci
->mci_ssl
, false, mci
->mci_host
,
6194 &mci
->mci_macro
, true);
6196 /* switch to use TLS... */
6197 if (sfdctls(&mci
->mci_in
, &mci
->mci_out
, mci
->mci_ssl
) == 0)
6206 ** ENDTLSCLT -- shutdown secure connection (client side)
6209 ** mci -- the mailer connection info.
6221 if (!bitset(MCIF_TLSACT
, mci
->mci_flags
))
6223 r
= endtls(mci
->mci_ssl
, "client");
6224 mci
->mci_flags
&= ~MCIF_TLSACT
;
6227 # endif /* STARTTLS */
6228 # if STARTTLS || SASL
6230 ** ISCLTFLGSET -- check whether client flag is set.
6234 ** flag -- flag to check in {client_flags}
6237 ** true iff flag is set.
6241 iscltflgset(e
, flag
)
6247 p
= macvalue(macid("{client_flags}"), e
);
6250 for (; *p
!= '\0'; p
++)
6252 /* look for just this one flag */
6253 if (*p
== (char) flag
)
6258 # endif /* STARTTLS || SASL */