1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
12 /* Options specific to the smtp transport. This transport also supports LMTP
13 over TCP/IP. The options must be in alphabetic order (note that "_" comes
14 before the lower case letters). Some live in the transport_instance block so as
15 to be publicly visible; these are flagged with opt_public. */
17 optionlist smtp_transport_options[] = {
18 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
19 (void *)offsetof(transport_instance, expand_multi_domain) },
20 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
21 (void *)(offsetof(smtp_transport_options_block, expand_retry_include_ip_address)) },
23 { "address_retry_include_sender", opt_bool,
24 (void *)offsetof(smtp_transport_options_block, address_retry_include_sender) },
25 { "allow_localhost", opt_bool,
26 (void *)offsetof(smtp_transport_options_block, allow_localhost) },
27 #ifdef EXPERIMENTAL_ARC
28 { "arc_sign", opt_stringptr,
29 (void *)offsetof(smtp_transport_options_block, arc_sign) },
31 { "authenticated_sender", opt_stringptr,
32 (void *)offsetof(smtp_transport_options_block, authenticated_sender) },
33 { "authenticated_sender_force", opt_bool,
34 (void *)offsetof(smtp_transport_options_block, authenticated_sender_force) },
35 { "command_timeout", opt_time,
36 (void *)offsetof(smtp_transport_options_block, command_timeout) },
37 { "connect_timeout", opt_time,
38 (void *)offsetof(smtp_transport_options_block, connect_timeout) },
39 { "connection_max_messages", opt_int | opt_public,
40 (void *)offsetof(transport_instance, connection_max_messages) },
42 { "dane_require_tls_ciphers", opt_stringptr,
43 (void *)offsetof(smtp_transport_options_block, dane_require_tls_ciphers) },
45 { "data_timeout", opt_time,
46 (void *)offsetof(smtp_transport_options_block, data_timeout) },
47 { "delay_after_cutoff", opt_bool,
48 (void *)offsetof(smtp_transport_options_block, delay_after_cutoff) },
50 { "dkim_canon", opt_stringptr,
51 (void *)offsetof(smtp_transport_options_block, dkim.dkim_canon) },
52 { "dkim_domain", opt_stringptr,
53 (void *)offsetof(smtp_transport_options_block, dkim.dkim_domain) },
54 { "dkim_hash", opt_stringptr,
55 (void *)offsetof(smtp_transport_options_block, dkim.dkim_hash) },
56 { "dkim_identity", opt_stringptr,
57 (void *)offsetof(smtp_transport_options_block, dkim.dkim_identity) },
58 { "dkim_private_key", opt_stringptr,
59 (void *)offsetof(smtp_transport_options_block, dkim.dkim_private_key) },
60 { "dkim_selector", opt_stringptr,
61 (void *)offsetof(smtp_transport_options_block, dkim.dkim_selector) },
62 { "dkim_sign_headers", opt_stringptr,
63 (void *)offsetof(smtp_transport_options_block, dkim.dkim_sign_headers) },
64 { "dkim_strict", opt_stringptr,
65 (void *)offsetof(smtp_transport_options_block, dkim.dkim_strict) },
66 { "dkim_timestamps", opt_stringptr,
67 (void *)offsetof(smtp_transport_options_block, dkim.dkim_timestamps) },
69 { "dns_qualify_single", opt_bool,
70 (void *)offsetof(smtp_transport_options_block, dns_qualify_single) },
71 { "dns_search_parents", opt_bool,
72 (void *)offsetof(smtp_transport_options_block, dns_search_parents) },
73 { "dnssec_request_domains", opt_stringptr,
74 (void *)offsetof(smtp_transport_options_block, dnssec.request) },
75 { "dnssec_require_domains", opt_stringptr,
76 (void *)offsetof(smtp_transport_options_block, dnssec.require) },
77 { "dscp", opt_stringptr,
78 (void *)offsetof(smtp_transport_options_block, dscp) },
79 { "fallback_hosts", opt_stringptr,
80 (void *)offsetof(smtp_transport_options_block, fallback_hosts) },
81 { "final_timeout", opt_time,
82 (void *)offsetof(smtp_transport_options_block, final_timeout) },
83 { "gethostbyname", opt_bool,
84 (void *)offsetof(smtp_transport_options_block, gethostbyname) },
85 { "helo_data", opt_stringptr,
86 (void *)offsetof(smtp_transport_options_block, helo_data) },
87 { "hosts", opt_stringptr,
88 (void *)offsetof(smtp_transport_options_block, hosts) },
89 { "hosts_avoid_esmtp", opt_stringptr,
90 (void *)offsetof(smtp_transport_options_block, hosts_avoid_esmtp) },
91 { "hosts_avoid_pipelining", opt_stringptr,
92 (void *)offsetof(smtp_transport_options_block, hosts_avoid_pipelining) },
94 { "hosts_avoid_tls", opt_stringptr,
95 (void *)offsetof(smtp_transport_options_block, hosts_avoid_tls) },
97 { "hosts_max_try", opt_int,
98 (void *)offsetof(smtp_transport_options_block, hosts_max_try) },
99 { "hosts_max_try_hardlimit", opt_int,
100 (void *)offsetof(smtp_transport_options_block, hosts_max_try_hardlimit) },
102 { "hosts_nopass_tls", opt_stringptr,
103 (void *)offsetof(smtp_transport_options_block, hosts_nopass_tls) },
104 { "hosts_noproxy_tls", opt_stringptr,
105 (void *)offsetof(smtp_transport_options_block, hosts_noproxy_tls) },
107 { "hosts_override", opt_bool,
108 (void *)offsetof(smtp_transport_options_block, hosts_override) },
109 { "hosts_randomize", opt_bool,
110 (void *)offsetof(smtp_transport_options_block, hosts_randomize) },
111 #if defined(SUPPORT_TLS) && !defined(DISABLE_OCSP)
112 { "hosts_request_ocsp", opt_stringptr,
113 (void *)offsetof(smtp_transport_options_block, hosts_request_ocsp) },
115 { "hosts_require_auth", opt_stringptr,
116 (void *)offsetof(smtp_transport_options_block, hosts_require_auth) },
119 { "hosts_require_dane", opt_stringptr,
120 (void *)offsetof(smtp_transport_options_block, hosts_require_dane) },
122 # ifndef DISABLE_OCSP
123 { "hosts_require_ocsp", opt_stringptr,
124 (void *)offsetof(smtp_transport_options_block, hosts_require_ocsp) },
126 { "hosts_require_tls", opt_stringptr,
127 (void *)offsetof(smtp_transport_options_block, hosts_require_tls) },
129 { "hosts_try_auth", opt_stringptr,
130 (void *)offsetof(smtp_transport_options_block, hosts_try_auth) },
131 { "hosts_try_chunking", opt_stringptr,
132 (void *)offsetof(smtp_transport_options_block, hosts_try_chunking) },
133 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
134 { "hosts_try_dane", opt_stringptr,
135 (void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
137 { "hosts_try_fastopen", opt_stringptr,
138 (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
140 { "hosts_try_prdr", opt_stringptr,
141 (void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
144 { "hosts_verify_avoid_tls", opt_stringptr,
145 (void *)offsetof(smtp_transport_options_block, hosts_verify_avoid_tls) },
147 { "interface", opt_stringptr,
148 (void *)offsetof(smtp_transport_options_block, interface) },
149 { "keepalive", opt_bool,
150 (void *)offsetof(smtp_transport_options_block, keepalive) },
151 { "lmtp_ignore_quota", opt_bool,
152 (void *)offsetof(smtp_transport_options_block, lmtp_ignore_quota) },
153 { "max_rcpt", opt_int | opt_public,
154 (void *)offsetof(transport_instance, max_addresses) },
155 { "multi_domain", opt_expand_bool | opt_public,
156 (void *)offsetof(transport_instance, multi_domain) },
157 { "port", opt_stringptr,
158 (void *)offsetof(smtp_transport_options_block, port) },
159 { "protocol", opt_stringptr,
160 (void *)offsetof(smtp_transport_options_block, protocol) },
161 { "retry_include_ip_address", opt_expand_bool,
162 (void *)offsetof(smtp_transport_options_block, retry_include_ip_address) },
163 { "serialize_hosts", opt_stringptr,
164 (void *)offsetof(smtp_transport_options_block, serialize_hosts) },
165 { "size_addition", opt_int,
166 (void *)offsetof(smtp_transport_options_block, size_addition) },
168 { "socks_proxy", opt_stringptr,
169 (void *)offsetof(smtp_transport_options_block, socks_proxy) },
172 { "tls_certificate", opt_stringptr,
173 (void *)offsetof(smtp_transport_options_block, tls_certificate) },
174 { "tls_crl", opt_stringptr,
175 (void *)offsetof(smtp_transport_options_block, tls_crl) },
176 { "tls_dh_min_bits", opt_int,
177 (void *)offsetof(smtp_transport_options_block, tls_dh_min_bits) },
178 { "tls_privatekey", opt_stringptr,
179 (void *)offsetof(smtp_transport_options_block, tls_privatekey) },
180 { "tls_require_ciphers", opt_stringptr,
181 (void *)offsetof(smtp_transport_options_block, tls_require_ciphers) },
182 { "tls_sni", opt_stringptr,
183 (void *)offsetof(smtp_transport_options_block, tls_sni) },
184 { "tls_tempfail_tryclear", opt_bool,
185 (void *)offsetof(smtp_transport_options_block, tls_tempfail_tryclear) },
186 { "tls_try_verify_hosts", opt_stringptr,
187 (void *)offsetof(smtp_transport_options_block, tls_try_verify_hosts) },
188 { "tls_verify_cert_hostnames", opt_stringptr,
189 (void *)offsetof(smtp_transport_options_block,tls_verify_cert_hostnames)},
190 { "tls_verify_certificates", opt_stringptr,
191 (void *)offsetof(smtp_transport_options_block, tls_verify_certificates) },
192 { "tls_verify_hosts", opt_stringptr,
193 (void *)offsetof(smtp_transport_options_block, tls_verify_hosts) },
196 { "utf8_downconvert", opt_stringptr,
197 (void *)offsetof(smtp_transport_options_block, utf8_downconvert) },
201 /* Size of the options list. An extern variable has to be used so that its
202 address can appear in the tables drtables.c. */
204 int smtp_transport_options_count = nelem(smtp_transport_options);
210 smtp_transport_options_block smtp_transport_option_defaults = {0};
211 void smtp_transport_init(transport_instance *tblock) {}
212 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
213 void smtp_transport_closedown(transport_instance *tblock) {}
215 #else /*!MACRO_PREDEF*/
218 /* Default private options block for the smtp transport. */
220 smtp_transport_options_block smtp_transport_option_defaults = {
222 .fallback_hosts = NULL,
224 .fallback_hostlist = NULL,
225 .helo_data = US"$primary_hostname",
228 .protocol = US"smtp",
230 .serialize_hosts = NULL,
231 .hosts_try_auth = NULL,
232 .hosts_require_auth = NULL,
233 .hosts_try_chunking = US"*",
235 .hosts_try_dane = NULL,
236 .hosts_require_dane = NULL,
237 .dane_require_tls_ciphers = NULL,
239 .hosts_try_fastopen = NULL,
241 .hosts_try_prdr = US"*",
244 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
245 .hosts_require_ocsp = NULL,
247 .hosts_require_tls = NULL,
248 .hosts_avoid_tls = NULL,
249 .hosts_verify_avoid_tls = NULL,
250 .hosts_avoid_pipelining = NULL,
251 .hosts_avoid_esmtp = NULL,
253 .hosts_nopass_tls = NULL,
254 .hosts_noproxy_tls = US"*",
256 .command_timeout = 5*60,
257 .connect_timeout = 5*60,
258 .data_timeout = 5*60,
259 .final_timeout = 10*60,
260 .size_addition = 1024,
262 .hosts_max_try_hardlimit = 50,
263 .address_retry_include_sender = TRUE,
264 .allow_localhost = FALSE,
265 .authenticated_sender_force = FALSE,
266 .gethostbyname = FALSE,
267 .dns_qualify_single = TRUE,
268 .dns_search_parents = FALSE,
269 .dnssec = { .request=NULL, .require=NULL },
270 .delay_after_cutoff = TRUE,
271 .hosts_override = FALSE,
272 .hosts_randomize = FALSE,
274 .lmtp_ignore_quota = FALSE,
275 .expand_retry_include_ip_address = NULL,
276 .retry_include_ip_address = TRUE,
281 .tls_certificate = NULL,
283 .tls_privatekey = NULL,
284 .tls_require_ciphers = NULL,
286 .tls_verify_certificates = US"system",
287 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
288 .tls_tempfail_tryclear = TRUE,
289 .tls_verify_hosts = NULL,
290 .tls_try_verify_hosts = US"*",
291 .tls_verify_cert_hostnames = US"*",
294 .utf8_downconvert = NULL,
298 {.dkim_domain = NULL,
299 .dkim_identity = NULL,
300 .dkim_private_key = NULL,
301 .dkim_selector = NULL,
303 .dkim_sign_headers = NULL,
305 .dkim_hash = US"sha256",
306 .dkim_timestamps = NULL,
307 .dot_stuffed = FALSE,
308 .force_bodyhash = FALSE,
309 # ifdef EXPERIMENTAL_ARC
310 .arc_signspec = NULL,
313 # ifdef EXPERIMENTAL_ARC
319 /* some DSN flags for use later */
321 static int rf_list[] = {rf_notify_never, rf_notify_success,
322 rf_notify_failure, rf_notify_delay };
324 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
330 static uschar *smtp_command; /* Points to last cmd for error messages */
331 static uschar *mail_command; /* Points to MAIL cmd for error messages */
332 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
333 static BOOL update_waiting; /* TRUE to update the "wait" database */
335 /*XXX move to smtp_context */
336 static BOOL pipelining_active; /* current transaction is in pipe mode */
339 /*************************************************
340 * Setup entry point *
341 *************************************************/
343 /* This function is called when the transport is about to be used,
344 but before running it in a sub-process. It is used for two things:
346 (1) To set the fallback host list in addresses, when delivering.
347 (2) To pass back the interface, port, protocol, and other options, for use
348 during callout verification.
351 tblock pointer to the transport instance block
352 addrlist list of addresses about to be transported
353 tf if not NULL, pointer to block in which to return options
354 uid the uid that will be set (not used)
355 gid the gid that will be set (not used)
356 errmsg place for error message (not used)
358 Returns: OK always (FAIL, DEFER not used)
362 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
363 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
365 smtp_transport_options_block *ob =
366 (smtp_transport_options_block *)(tblock->options_block);
368 errmsg = errmsg; /* Keep picky compilers happy */
372 /* Pass back options if required. This interface is getting very messy. */
376 tf->interface = ob->interface;
378 tf->protocol = ob->protocol;
379 tf->hosts = ob->hosts;
380 tf->hosts_override = ob->hosts_override;
381 tf->hosts_randomize = ob->hosts_randomize;
382 tf->gethostbyname = ob->gethostbyname;
383 tf->qualify_single = ob->dns_qualify_single;
384 tf->search_parents = ob->dns_search_parents;
385 tf->helo_data = ob->helo_data;
388 /* Set the fallback host list for all the addresses that don't have fallback
389 host lists, provided that the local host wasn't present in the original host
392 if (!testflag(addrlist, af_local_host_removed))
393 for (; addrlist; addrlist = addrlist->next)
394 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
401 /*************************************************
402 * Initialization entry point *
403 *************************************************/
405 /* Called for each instance, after its options have been read, to
406 enable consistency checks to be done, or anything else that needs
409 Argument: pointer to the transport instance block
414 smtp_transport_init(transport_instance *tblock)
416 smtp_transport_options_block *ob =
417 (smtp_transport_options_block *)(tblock->options_block);
419 /* Retry_use_local_part defaults FALSE if unset */
421 if (tblock->retry_use_local_part == TRUE_UNSET)
422 tblock->retry_use_local_part = FALSE;
424 /* Set the default port according to the protocol */
426 if (ob->port == NULL)
427 ob->port = (strcmpic(ob->protocol, US"lmtp") == 0)? US"lmtp" :
428 (strcmpic(ob->protocol, US"smtps") == 0)? US"smtps" : US"smtp";
430 /* Set up the setup entry point, to be called before subprocesses for this
433 tblock->setup = smtp_transport_setup;
435 /* Complain if any of the timeouts are zero. */
437 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
438 ob->final_timeout <= 0)
439 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
440 "command, data, or final timeout value is zero for %s transport",
443 /* If hosts_override is set and there are local hosts, set the global
444 flag that stops verify from showing router hosts. */
446 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
448 /* If there are any fallback hosts listed, build a chain of host items
449 for them, but do not do any lookups at this time. */
451 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
458 /*************************************************
459 * Set delivery info into all active addresses *
460 *************************************************/
462 /* Only addresses whose status is >= PENDING are relevant. A lesser
463 status means that an address is not currently being processed.
466 addrlist points to a chain of addresses
467 errno_value to put in each address's errno field
468 msg to put in each address's message field
469 rc to put in each address's transport_return field
470 pass_message if TRUE, set the "pass message" flag in the address
471 host if set, mark addrs as having used this host
472 smtp_greeting from peer
473 helo_response from peer
475 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
476 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
477 this particular type of timeout.
483 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
484 BOOL pass_message, host_item * host
485 #ifdef EXPERIMENTAL_DSN_INFO
486 , const uschar * smtp_greeting, const uschar * helo_response
492 if (errno_value == ERRNO_CONNECTTIMEOUT)
494 errno_value = ETIMEDOUT;
495 orvalue = RTEF_CTOUT;
497 for (addr = addrlist; addr; addr = addr->next)
498 if (addr->transport_return >= PENDING)
500 addr->basic_errno = errno_value;
501 addr->more_errno |= orvalue;
505 if (pass_message) setflag(addr, af_pass_message);
507 addr->transport_return = rc;
510 addr->host_used = host;
511 #ifdef EXPERIMENTAL_DSN_INFO
513 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
514 addr->smtp_greeting = smtp_greeting;
517 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
518 addr->helo_response = helo_response;
525 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
528 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
529 #ifdef EXPERIMENTAL_DSN_INFO
536 /*************************************************
537 * Check an SMTP response *
538 *************************************************/
540 /* This function is given an errno code and the SMTP response buffer
541 to analyse, together with the host identification for generating messages. It
542 sets an appropriate message and puts the first digit of the response code into
543 the yield variable. If no response was actually read, a suitable digit is
547 host the current host, to get its name for messages
548 errno_value pointer to the errno value
549 more_errno from the top address for use with ERRNO_FILTER_FAIL
550 buffer the SMTP response buffer
551 yield where to put a one-digit SMTP response code
552 message where to put an error message
553 pass_message set TRUE if message is an SMTP response
555 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
559 check_response(host_item *host, int *errno_value, int more_errno,
560 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
562 uschar * pl = pipelining_active ? US"pipelined " : US"";
565 *yield = '4'; /* Default setting is to give a temporary error */
569 case ETIMEDOUT: /* Handle response timeout */
570 *message = US string_sprintf("SMTP timeout after %s%s",
572 if (transport_count > 0)
573 *message = US string_sprintf("%s (%d bytes written)", *message,
577 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
578 s = string_printing(buffer);
579 while (isspace(*s)) s++;
581 ? string_sprintf("Malformed SMTP reply (an empty line) "
582 "in response to %s%s", pl, smtp_command)
583 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
584 pl, smtp_command, s);
587 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
588 can't send QUIT as we mustn't end the DATA. */
589 *message = string_sprintf("transport filter process failed (%d)%s",
591 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
594 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
595 can't send QUIT as we mustn't end the DATA. */
597 string_sprintf("failed to expand headers_add or headers_remove: %s",
598 expand_string_message);
601 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
602 *message = string_sprintf("failed to write a data block");
606 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
607 *message = US"utf8 support required but not offered for forwarding";
608 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
613 /* Handle error responses from the remote mailer. */
617 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
618 "%s", pl, smtp_command, s = string_printing(buffer));
619 *pass_message = TRUE;
624 /* No data was read. If there is no errno, this must be the EOF (i.e.
625 connection closed) case, which causes deferral. An explicit connection reset
626 error has the same effect. Otherwise, put the host's identity in the message,
627 leaving the errno value to be interpreted as well. In all cases, we have to
628 assume the connection is now dead. */
630 if (*errno_value == 0 || *errno_value == ECONNRESET)
632 *errno_value = ERRNO_SMTPCLOSED;
633 *message = US string_sprintf("Remote host closed connection "
634 "in response to %s%s", pl, smtp_command);
637 *message = US string_sprintf("%s [%s]", host->name, host->address);
644 /*************************************************
645 * Write error message to logs *
646 *************************************************/
648 /* This writes to the main log and to the message log.
651 host the current host
652 detail the current message (addr_item->message)
653 basic_errno the errno (addr_item->basic_errno)
659 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
663 uschar *message = LOGGING(outgoing_port)
664 ? string_sprintf("H=%s [%s]:%d", host->name, host->address,
665 host->port == PORT_NONE ? 25 : host->port)
666 : string_sprintf("H=%s [%s]", host->name, host->address);
670 message = string_sprintf("%s: %s", message, suffix);
672 message = string_sprintf("%s: %s", message, strerror(basic_errno));
675 message = string_sprintf("%s %s", message, exim_errstr(basic_errno));
677 log_write(0, LOG_MAIN, "%s", message);
678 deliver_msglog("%s %s\n", tod_stamp(tod_log), message);
682 msglog_line(host_item * host, uschar * message)
684 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
685 host->name, host->address, message);
690 #ifndef DISABLE_EVENT
691 /*************************************************
692 * Post-defer action *
693 *************************************************/
695 /* This expands an arbitrary per-transport string.
696 It might, for example, be used to write to the database log.
699 addr the address item containing error information
700 host the current host
706 deferred_event_raise(address_item *addr, host_item *host)
708 uschar * action = addr->transport->event_action;
709 const uschar * save_domain;
715 save_domain = deliver_domain;
716 save_local = deliver_localpart;
718 /*XXX would ip & port already be set up? */
719 deliver_host_address = string_copy(host->address);
720 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
721 event_defer_errno = addr->basic_errno;
723 router_name = addr->router->name;
724 transport_name = addr->transport->name;
725 deliver_domain = addr->domain;
726 deliver_localpart = addr->local_part;
728 (void) event_raise(action, US"msg:host:defer",
730 ? addr->basic_errno > 0
731 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
732 : string_copy(addr->message)
733 : addr->basic_errno > 0
734 ? string_copy(US strerror(addr->basic_errno))
737 deliver_localpart = save_local;
738 deliver_domain = save_domain;
739 router_name = transport_name = NULL;
743 /*************************************************
744 * Synchronize SMTP responses *
745 *************************************************/
747 /* This function is called from smtp_deliver() to receive SMTP responses from
748 the server, and match them up with the commands to which they relate. When
749 PIPELINING is not in use, this function is called after every command, and is
750 therefore somewhat over-engineered, but it is simpler to use a single scheme
751 that works both with and without PIPELINING instead of having two separate sets
754 The set of commands that are buffered up with pipelining may start with MAIL
755 and may end with DATA; in between are RCPT commands that correspond to the
756 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
757 etc.) are never buffered.
759 Errors after MAIL or DATA abort the whole process leaving the response in the
760 buffer. After MAIL, pending responses are flushed, and the original command is
761 re-instated in big_buffer for error messages. For RCPT commands, the remote is
762 permitted to reject some recipient addresses while accepting others. However
763 certain errors clearly abort the whole process. Set the value in
764 transport_return to PENDING_OK if the address is accepted. If there is a
765 subsequent general error, it will get reset accordingly. If not, it will get
766 converted to OK at the end.
769 sx smtp connection context
770 count the number of responses to read
771 pending_DATA 0 if last command sent was not DATA
772 +1 if previously had a good recipient
773 -1 if not previously had a good recipient
775 Returns: 3 if at least one address had 2xx and one had 5xx
776 2 if at least one address had 5xx but none had 2xx
777 1 if at least one host had a 2xx response, but none had 5xx
778 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
779 -1 timeout while reading RCPT response
780 -2 I/O or other non-response error for RCPT
781 -3 DATA or MAIL failed - errno and buffer set
785 sync_responses(smtp_context * sx, int count, int pending_DATA)
787 address_item *addr = sx->sync_addr;
788 smtp_transport_options_block *ob =
789 (smtp_transport_options_block *)sx->tblock->options_block;
792 /* Handle the response for a MAIL command. On error, reinstate the original
793 command in big_buffer for error message use, and flush any further pending
794 responses before returning, except after I/O errors and timeouts. */
796 if (sx->pending_MAIL)
798 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
800 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
801 '2', ob->command_timeout))
803 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
804 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
805 if (errno == 0 && sx->buffer[0] != 0)
807 uschar flushbuffer[4096];
809 if (sx->buffer[0] == '4')
811 save_errno = ERRNO_MAIL4XX;
812 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
816 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
817 '2', ob->command_timeout)
818 && (errno != 0 || flushbuffer[0] == 0))
824 if (pending_DATA) count--; /* Number of RCPT responses to come */
825 while (count-- > 0) /* Mark any pending addrs with the host used */
827 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
828 addr->host_used = sx->host;
835 if (pending_DATA) count--; /* Number of RCPT responses to come */
837 /* Read and handle the required number of RCPT responses, matching each one up
838 with an address by scanning for the next address whose status is PENDING_DEFER.
843 while (addr->transport_return != PENDING_DEFER)
844 if (!(addr = addr->next))
847 /* The address was accepted */
848 addr->host_used = sx->host;
850 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
851 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
852 '2', ob->command_timeout))
855 addr->transport_return = PENDING_OK;
857 /* If af_dr_retry_exists is set, there was a routing delay on this address;
858 ensure that any address-specific retry record is expunged. We do this both
859 for the basic key and for the version that also includes the sender. */
861 if (testflag(addr, af_dr_retry_exists))
863 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
865 retry_add_item(addr, altkey, rf_delete);
866 retry_add_item(addr, addr->address_retry_key, rf_delete);
870 /* Timeout while reading the response */
872 else if (errno == ETIMEDOUT)
874 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
875 transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes));
876 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
877 retry_add_item(addr, addr->address_retry_key, 0);
878 update_waiting = FALSE;
882 /* Handle other errors in obtaining an SMTP response by returning -1. This
883 will cause all the addresses to be deferred. Restore the SMTP command in
884 big_buffer for which we are checking the response, so the error message
887 else if (errno != 0 || sx->buffer[0] == 0)
889 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
890 transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes));
894 /* Handle SMTP permanent and temporary response codes. */
899 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
900 "%s", transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes),
901 string_printing(sx->buffer));
902 setflag(addr, af_pass_message);
904 msglog_line(sx->host, addr->message);
906 /* The response was 5xx */
908 if (sx->buffer[0] == '5')
910 addr->transport_return = FAIL;
914 /* The response was 4xx */
918 addr->transport_return = DEFER;
919 addr->basic_errno = ERRNO_RCPT4XX;
920 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
924 #ifndef DISABLE_EVENT
925 event_defer_errno = addr->more_errno;
926 msg_event_raise(US"msg:rcpt:host:defer", addr);
929 /* Log temporary errors if there are more hosts to be tried.
930 If not, log this last one in the == line. */
933 log_write(0, LOG_MAIN, "H=%s [%s]: %s",
934 sx->host->name, sx->host->address, addr->message);
936 #ifndef DISABLE_EVENT
938 msg_event_raise(US"msg:rcpt:defer", addr);
941 /* Do not put this message on the list of those waiting for specific
942 hosts, as otherwise it is likely to be tried too often. */
944 update_waiting = FALSE;
946 /* Add a retry item for the address so that it doesn't get tried again
947 too soon. If address_retry_include_sender is true, add the sender address
951 ob->address_retry_include_sender
952 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
953 : addr->address_retry_key,
958 } /* Loop for next RCPT response */
960 /* Update where to start at for the next block of responses, unless we
961 have already handled all the addresses. */
963 if (addr) sx->sync_addr = addr->next;
965 /* Handle a response to DATA. If we have not had any good recipients, either
966 previously or in this block, the response is ignored. */
968 if (pending_DATA != 0)
970 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
971 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
972 '3', ob->command_timeout))
977 if (pending_DATA > 0 || (yield & 1) != 0)
979 if (errno == 0 && sx->buffer[0] == '4')
981 errno = ERRNO_DATA4XX;
982 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
986 (void)check_response(sx->host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
987 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
988 "is in use and there were no good recipients\n", msg);
992 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
993 present) received 3xx. If any RCPTs were handled and yielded anything other
994 than 4xx, yield will be set non-zero. */
1001 /* Do the client side of smtp-level authentication */
1005 buffer EHLO response from server (gets overwritten)
1008 OK Success, or failed (but not required): global "smtp_authenticated" set
1009 DEFER Failed authentication (and was required)
1010 ERROR Internal problem
1012 FAIL_SEND Failed communications - transmit
1017 smtp_auth(smtp_context * sx, uschar * buffer, unsigned bufsize)
1019 smtp_transport_options_block * ob = sx->ob;
1021 uschar *fail_reason = US"server did not advertise AUTH support";
1023 f.smtp_authenticated = FALSE;
1024 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1025 require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, sx->host);
1027 if (sx->esmtp && !regex_AUTH) regex_AUTH =
1028 regex_must_compile(US"\\n250[\\s\\-]AUTH\\s+([\\-\\w\\s]+)(?:\\n|$)",
1031 if (sx->esmtp && regex_match_and_setup(regex_AUTH, buffer, 0, -1))
1033 uschar *names = string_copyn(expand_nstring[1], expand_nlength[1]);
1034 expand_nmax = -1; /* reset */
1036 /* Must not do this check until after we have saved the result of the
1037 regex match above. */
1039 if (require_auth == OK ||
1040 verify_check_given_host(CUSS &ob->hosts_try_auth, sx->host) == OK)
1043 fail_reason = US"no common mechanisms were found";
1045 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1047 /* Scan the configured authenticators looking for one which is configured
1048 for use as a client, which is not suppressed by client_condition, and
1049 whose name matches an authentication mechanism supported by the server.
1050 If one is found, attempt to authenticate by calling its client function.
1053 for (au = auths; !f.smtp_authenticated && au; au = au->next)
1057 (au->client_condition != NULL &&
1058 !expand_check_condition(au->client_condition, au->name,
1059 US"client authenticator")))
1061 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1063 (au->client)? "client_condition is false" :
1064 "not configured as a client");
1068 /* Loop to scan supported server mechanisms */
1073 int len = Ustrlen(au->public_name);
1074 while (isspace(*p)) p++;
1076 if (strncmpic(au->public_name, p, len) != 0 ||
1077 (p[len] != 0 && !isspace(p[len])))
1079 while (*p != 0 && !isspace(*p)) p++;
1083 /* Found data for a listed mechanism. Call its client entry. Set
1084 a flag in the outblock so that data is overwritten after sending so
1085 that reflections don't show it. */
1087 fail_reason = US"authentication attempt(s) failed";
1088 sx->outblock.authenticating = TRUE;
1089 rc = (au->info->clientcode)(au, sx,
1090 ob->command_timeout, buffer, bufsize);
1091 sx->outblock.authenticating = FALSE;
1092 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n",
1095 /* A temporary authentication failure must hold up delivery to
1096 this host. After a permanent authentication failure, we carry on
1097 to try other authentication methods. If all fail hard, try to
1098 deliver the message unauthenticated unless require_auth was set. */
1103 f.smtp_authenticated = TRUE; /* stops the outer loop */
1104 client_authenticator = au->name;
1105 if (au->set_client_id != NULL)
1106 client_authenticated_id = expand_string(au->set_client_id);
1109 /* Failure after writing a command */
1114 /* Failure after reading a response */
1117 if (errno != 0 || buffer[0] != '5') return FAIL;
1118 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1119 au->name, sx->host->name, sx->host->address, buffer);
1122 /* Failure by some other means. In effect, the authenticator
1123 decided it wasn't prepared to handle this case. Typically this
1124 is the result of "fail" in an expansion string. Do we need to
1125 log anything here? Feb 2006: a message is now put in the buffer
1126 if logging is required. */
1130 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1131 "authentication H=%s [%s] %s", au->name, sx->host->name,
1132 sx->host->address, buffer);
1135 /* Internal problem, message in buffer. */
1138 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(buffer),
1143 break; /* If not authenticated, try next authenticator */
1144 } /* Loop for scanning supported server mechanisms */
1145 } /* Loop for further authenticators */
1149 /* If we haven't authenticated, but are required to, give up. */
1151 if (require_auth == OK && !f.smtp_authenticated)
1153 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1154 string_sprintf("authentication required but %s", fail_reason), DEFER,
1163 /* Construct AUTH appendix string for MAIL TO */
1166 buffer to build string
1167 addrlist chain of potential addresses to deliver
1168 ob transport options
1170 Globals f.smtp_authenticated
1171 client_authenticated_sender
1172 Return True on error, otherwise buffer has (possibly empty) terminated string
1176 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1177 smtp_transport_options_block *ob)
1179 uschar *local_authenticated_sender = authenticated_sender;
1182 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1185 if (ob->authenticated_sender != NULL)
1187 uschar *new = expand_string(ob->authenticated_sender);
1190 if (!f.expand_string_forcedfail)
1192 uschar *message = string_sprintf("failed to expand "
1193 "authenticated_sender: %s", expand_string_message);
1194 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1198 else if (new[0] != 0) local_authenticated_sender = new;
1201 /* Add the authenticated sender address if present */
1203 if ((f.smtp_authenticated || ob->authenticated_sender_force) &&
1204 local_authenticated_sender != NULL)
1206 string_format(buffer, bufsize, " AUTH=%s",
1207 auth_xtextencode(local_authenticated_sender,
1208 Ustrlen(local_authenticated_sender)));
1209 client_authenticated_sender = string_copy(local_authenticated_sender);
1220 /* Lookup TLSA record for host/port.
1221 Return: OK success with dnssec; DANE mode
1222 DEFER Do not use this host now, may retry later
1223 FAIL_FORCED No TLSA record; DANE not usable
1224 FAIL Do not use this connection
1228 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1230 /* move this out to host.c given the similarity to dns_lookup() ? */
1232 const uschar * fullname = buffer;
1236 /* TLSA lookup string */
1237 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1239 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1240 sec = dns_is_secure(dnsa);
1242 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1247 return DEFER; /* just defer this TLS'd conn */
1256 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1257 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1258 if (rr->type == T_TLSA && rr->size > 3)
1260 uint16_t payload_length = rr->size - 3;
1261 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1263 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1264 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1265 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1266 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1267 sp += sprintf(CS sp, "%02x", *p++);
1269 debug_printf(" %s\n", s);
1274 log_write(0, LOG_MAIN,
1275 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1278 case DNS_NODATA: /* no TLSA RR for this lookup */
1279 case DNS_NOMATCH: /* no records at all for this lookup */
1280 return dane_required ? FAIL : FAIL_FORCED;
1284 return dane_required ? FAIL : DEFER;
1291 typedef struct smtp_compare_s
1293 uschar *current_sender_address;
1294 struct transport_instance *tblock;
1298 /* Create a unique string that identifies this message, it is based on
1299 sender_address, helo_data and tls_certificate if enabled.
1303 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1305 address_item * addr1;
1306 uschar * if1 = US"";
1307 uschar * helo1 = US"";
1309 uschar * tlsc1 = US"";
1311 uschar * save_sender_address = sender_address;
1312 uschar * local_identity = NULL;
1313 smtp_transport_options_block * ob =
1314 (smtp_transport_options_block *)tblock->options_block;
1316 sender_address = sender;
1318 addr1 = deliver_make_addr (sender, TRUE);
1319 deliver_set_expansions(addr1);
1322 if1 = expand_string(ob->interface);
1325 helo1 = expand_string(ob->helo_data);
1328 if (ob->tls_certificate)
1329 tlsc1 = expand_string(ob->tls_certificate);
1330 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1332 local_identity = string_sprintf ("%s^%s", if1, helo1);
1335 deliver_set_expansions(NULL);
1336 sender_address = save_sender_address;
1338 return local_identity;
1343 /* This routine is a callback that is called from transport_check_waiting.
1344 This function will evaluate the incoming message versus the previous
1345 message. If the incoming message is using a different local identity then
1346 we will veto this new message. */
1349 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1351 uschar * message_local_identity,
1352 * current_local_identity,
1353 * new_sender_address;
1355 current_local_identity =
1356 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1358 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1361 message_local_identity =
1362 smtp_local_identity(new_sender_address, s_compare->tblock);
1364 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1370 ehlo_response(uschar * buf, unsigned checks)
1372 size_t bsize = Ustrlen(buf);
1375 if ( checks & OPTION_TLS
1376 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1377 checks &= ~OPTION_TLS;
1379 # ifdef EXPERIMENTAL_REQUIRETLS
1380 if ( checks & OPTION_REQUIRETLS
1381 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1382 checks &= ~OPTION_REQUIRETLS;
1386 if ( checks & OPTION_IGNQ
1387 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1388 PCRE_EOPT, NULL, 0) < 0)
1389 checks &= ~OPTION_IGNQ;
1391 if ( checks & OPTION_CHUNKING
1392 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1393 checks &= ~OPTION_CHUNKING;
1395 #ifndef DISABLE_PRDR
1396 if ( checks & OPTION_PRDR
1397 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1398 checks &= ~OPTION_PRDR;
1402 if ( checks & OPTION_UTF8
1403 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1404 checks &= ~OPTION_UTF8;
1407 if ( checks & OPTION_DSN
1408 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1409 checks &= ~OPTION_DSN;
1411 if ( checks & OPTION_PIPE
1412 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1413 PCRE_EOPT, NULL, 0) < 0)
1414 checks &= ~OPTION_PIPE;
1416 if ( checks & OPTION_SIZE
1417 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1418 checks &= ~OPTION_SIZE;
1425 /* Callback for emitting a BDAT data chunk header.
1427 If given a nonzero size, first flush any buffered SMTP commands
1428 then emit the command.
1430 Reap previous SMTP command responses if requested, and always reap
1431 the response from a previous BDAT command.
1434 tctx transport context
1435 chunk_size value for SMTP BDAT command
1437 tc_chunk_last add LAST option to SMTP BDAT command
1438 tc_reap_prev reap response to previous SMTP commands
1440 Returns: OK or ERROR
1444 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1447 smtp_transport_options_block * ob =
1448 (smtp_transport_options_block *)(tctx->tblock->options_block);
1449 smtp_context * sx = tctx->smtp_context;
1453 /* Write SMTP chunk header command. If not reaping responses, note that
1454 there may be more writes (like, the chunk data) done soon. */
1458 if((cmd_count = smtp_write_command(sx,
1459 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1460 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1461 ) < 0) return ERROR;
1462 if (flags & tc_chunk_last)
1463 data_command = string_copy(big_buffer); /* Save for later error message */
1466 prev_cmd_count = cmd_count += sx->cmd_count;
1468 /* Reap responses for any previous, but not one we just emitted */
1472 if (sx->pending_BDAT)
1475 if (flags & tc_reap_prev && prev_cmd_count > 0)
1477 DEBUG(D_transport) debug_printf("look for %d responses"
1478 " for previous pipelined cmds\n", prev_cmd_count);
1480 switch(sync_responses(sx, prev_cmd_count, 0))
1482 case 1: /* 2xx (only) => OK */
1483 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1484 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1485 case 0: break; /* No 2xx or 5xx, but no probs */
1487 case -1: /* Timeout on RCPT */
1488 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1491 if (!sx->pending_BDAT)
1492 pipelining_active = FALSE;
1495 /* Reap response for an outstanding BDAT */
1497 if (sx->pending_BDAT)
1499 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1501 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1502 ob->command_timeout))
1504 if (errno == 0 && sx->buffer[0] == '4')
1506 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1507 sx->addrlist->more_errno |=
1508 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1513 sx->pending_BDAT = FALSE;
1514 pipelining_active = FALSE;
1516 else if (chunk_size > 0)
1517 sx->pending_BDAT = TRUE;
1520 sx->cmd_count = cmd_count;
1526 /*************************************************
1527 * Make connection for given message *
1528 *************************************************/
1532 ctx connection context
1533 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1534 a second attempt after TLS initialization fails
1536 Returns: OK - the connection was made and the delivery attempted;
1537 fd is set in the conn context, tls_out set up.
1538 DEFER - the connection could not be made, or something failed
1539 while setting up the SMTP session, or there was a
1540 non-message-specific error, such as a timeout.
1541 ERROR - helo_data or add_headers or authenticated_sender is
1542 specified for this transport, and the string failed
1546 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1548 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1549 dns_answer tlsa_dnsa;
1551 BOOL pass_message = FALSE;
1552 uschar * message = NULL;
1556 sx->ob = (smtp_transport_options_block *) sx->tblock->options_block;
1558 sx->lmtp = strcmpic(sx->ob->protocol, US"lmtp") == 0;
1559 sx->smtps = strcmpic(sx->ob->protocol, US"smtps") == 0;
1561 sx->send_rset = TRUE;
1562 sx->send_quit = TRUE;
1563 sx->setting_up = TRUE;
1565 sx->esmtp_sent = FALSE;
1567 sx->utf8_needed = FALSE;
1569 sx->dsn_all_lasthop = TRUE;
1570 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1573 verify_check_given_host(CUSS &sx->ob->hosts_require_dane, sx->host) == OK;
1576 if ((sx->max_rcpt = sx->tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1577 sx->peer_offered = 0;
1578 sx->avoid_option = 0;
1579 sx->igquotstr = US"";
1580 if (!sx->helo_data) sx->helo_data = sx->ob->helo_data;
1581 #ifdef EXPERIMENTAL_DSN_INFO
1582 sx->smtp_greeting = NULL;
1583 sx->helo_response = NULL;
1586 smtp_command = US"initial connection";
1587 sx->buffer[0] = '\0';
1589 /* Set up the buffer for reading SMTP response packets. */
1591 sx->inblock.buffer = sx->inbuffer;
1592 sx->inblock.buffersize = sizeof(sx->inbuffer);
1593 sx->inblock.ptr = sx->inbuffer;
1594 sx->inblock.ptrend = sx->inbuffer;
1596 /* Set up the buffer for holding SMTP commands while pipelining */
1598 sx->outblock.buffer = sx->outbuffer;
1599 sx->outblock.buffersize = sizeof(sx->outbuffer);
1600 sx->outblock.ptr = sx->outbuffer;
1601 sx->outblock.cmd_count = 0;
1602 sx->outblock.authenticating = FALSE;
1604 /* Reset the parameters of a TLS session. */
1607 tls_out.cipher = NULL; /* the one we may use for this transport */
1608 tls_out.ourcert = NULL;
1609 tls_out.peercert = NULL;
1610 tls_out.peerdn = NULL;
1611 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1614 tls_out.ocsp = OCSP_NOT_REQ;
1616 /* Flip the legacy TLS-related variables over to the outbound set in case
1617 they're used in the context of the transport. Don't bother resetting
1618 afterward (when being used by a transport) as we're in a subprocess.
1619 For verify, unflipped once the callout is dealt with */
1621 tls_modify_variables(&tls_out);
1626 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
1632 /* Make a connection to the host if this isn't a continued delivery, and handle
1633 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
1634 specially so they can be identified for retries. */
1636 if (!continue_hostname)
1639 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->interface, sx->port);
1641 /* Get the actual port the connection will use, into sx->host */
1643 smtp_port_for_connect(sx->host, sx->port);
1645 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1646 /* Do TLSA lookup for DANE */
1648 tls_out.dane_verified = FALSE;
1649 tls_out.tlsa_usage = 0;
1651 if (sx->host->dnssec == DS_YES)
1653 if( sx->dane_required
1654 || verify_check_given_host(CUSS &sx->ob->hosts_try_dane, sx->host) == OK
1656 switch (rc = tlsa_lookup(sx->host, &tlsa_dnsa, sx->dane_required))
1658 case OK: sx->dane = TRUE;
1659 sx->ob->tls_tempfail_tryclear = FALSE;
1661 case FAIL_FORCED: break;
1662 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
1663 string_sprintf("DANE error: tlsa lookup %s",
1664 rc == DEFER ? "DEFER" : "FAIL"),
1666 # ifndef DISABLE_EVENT
1667 (void) event_raise(sx->tblock->event_action,
1668 US"dane:fail", sx->dane_required
1669 ? US"dane-required" : US"dnssec-invalid");
1674 else if (sx->dane_required)
1676 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
1677 string_sprintf("DANE error: %s lookup not DNSSEC", sx->host->name),
1679 # ifndef DISABLE_EVENT
1680 (void) event_raise(sx->tblock->event_action,
1681 US"dane:fail", US"dane-required");
1688 /* Make the TCP connection */
1691 smtp_connect(sx->host, sx->host_af, sx->interface,
1692 sx->ob->connect_timeout, sx->tblock);
1693 sx->cctx.tls_ctx = NULL;
1694 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
1696 if (sx->cctx.sock < 0)
1698 uschar * msg = NULL;
1701 msg = US strerror(errno);
1702 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
1704 set_errno_nohost(sx->addrlist,
1705 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
1706 sx->verify ? string_sprintf("could not connect: %s", msg)
1709 sx->send_quit = FALSE;
1713 /* Expand the greeting message while waiting for the initial response. (Makes
1714 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
1715 delayed till here so that $sending_interface and $sending_port are set. */
1718 if (!(sx->helo_data = expand_string(sx->helo_data)))
1720 log_write(0, LOG_MAIN|LOG_PANIC,
1721 "<%s>: failed to expand transport's helo_data value for callout: %s",
1722 sx->addrlist->address, expand_string_message);
1727 expand_string_message = NULL;
1728 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
1729 &expand_string_message)),
1730 expand_string_message)
1732 log_write(0, LOG_MAIN|LOG_PANIC,
1733 "<%s>: failed to expand transport's helo_data value for callout: %s",
1734 sx->addrlist->address, expand_string_message);
1736 sx->helo_data = NULL;
1740 /* The first thing is to wait for an initial OK response. The dreaded "goto"
1741 is nevertheless a reasonably clean way of programming this kind of logic,
1742 where you want to escape on any error. */
1749 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
1751 good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1752 '2', sx->ob->command_timeout);
1753 #ifdef EXPERIMENTAL_DSN_INFO
1754 sx->smtp_greeting = string_copy(sx->buffer);
1756 if (!good_response) goto RESPONSE_FAILED;
1758 #ifndef DISABLE_EVENT
1761 lookup_dnssec_authenticated = sx->host->dnssec==DS_YES ? US"yes"
1762 : sx->host->dnssec==DS_NO ? US"no" : NULL;
1763 s = event_raise(sx->tblock->event_action, US"smtp:connect", sx->buffer);
1766 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
1767 string_sprintf("deferred by smtp:connect event expansion: %s", s),
1775 /* Now check if the helo_data expansion went well, and sign off cleanly if
1780 message = string_sprintf("failed to expand helo_data: %s",
1781 expand_string_message);
1782 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1788 /** Debugging without sending a message
1789 sx->addrlist->transport_return = DEFER;
1793 /* Errors that occur after this point follow an SMTP command, which is
1794 left in big_buffer by smtp_write_command() for use in error messages. */
1796 smtp_command = big_buffer;
1798 /* Tell the remote who we are...
1800 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
1801 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
1802 greeting is of this form. The assumption was that the far end supports it
1803 properly... but experience shows that there are some that give 5xx responses,
1804 even though the banner includes "ESMTP" (there's a bloody-minded one that
1805 says "ESMTP not spoken here"). Cope with that case.
1807 September 2000: Time has passed, and it seems reasonable now to always send
1808 EHLO at the start. It is also convenient to make the change while installing
1811 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
1812 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
1813 would be no way to send out the mails, so there is now a host list
1814 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
1815 PIPELINING problem as well. Maybe it can also be useful to cure other
1816 problems with broken servers.
1818 Exim originally sent "Helo" at this point and ran for nearly a year that way.
1819 Then somebody tried it with a Microsoft mailer... It seems that all other
1820 mailers use upper case for some reason (the RFC is quite clear about case
1821 independence) so, for peace of mind, I gave in. */
1823 sx->esmtp = verify_check_given_host(CUSS &sx->ob->hosts_avoid_esmtp, sx->host) != OK;
1825 /* Alas; be careful, since this goto is not an error-out, so conceivably
1826 we might set data between here and the target which we assume to exist
1827 and be usable. I can see this coming back to bite us. */
1831 smtp_peer_options |= OPTION_TLS;
1832 suppress_tls = FALSE;
1833 sx->ob->tls_tempfail_tryclear = FALSE;
1834 smtp_command = US"SSL-on-connect";
1841 if (smtp_write_command(sx, SCMD_FLUSH, "%s %s\r\n",
1842 sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
1844 sx->esmtp_sent = TRUE;
1845 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1846 sx->ob->command_timeout))
1848 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
1850 #ifdef EXPERIMENTAL_DSN_INFO
1851 sx->helo_response = string_copy(sx->buffer);
1853 goto RESPONSE_FAILED;
1857 #ifdef EXPERIMENTAL_DSN_INFO
1858 sx->helo_response = string_copy(sx->buffer);
1863 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
1868 int n = sizeof(sx->buffer);
1869 uschar * rsp = sx->buffer;
1871 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
1872 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
1874 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
1876 good_response = smtp_read_response(sx, rsp, n, '2', sx->ob->command_timeout);
1877 #ifdef EXPERIMENTAL_DSN_INFO
1878 sx->helo_response = string_copy(rsp);
1882 /* Handle special logging for a closed connection after HELO
1883 when had previously sent EHLO */
1885 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
1887 errno = ERRNO_SMTPCLOSED;
1888 goto EHLOHELO_FAILED;
1890 memmove(sx->buffer, rsp, Ustrlen(rsp));
1891 goto RESPONSE_FAILED;
1895 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
1897 if (sx->esmtp || sx->lmtp)
1899 sx->peer_offered = ehlo_response(sx->buffer,
1900 OPTION_TLS /* others checked later */
1903 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
1906 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
1911 /* For continuing deliveries down the same channel, having re-exec'd the socket
1912 is the standard input; for a socket held open from verify it is recorded
1913 in the cutthrough context block. Either way we don't need to redo EHLO here
1914 (but may need to do so for TLS - see below).
1915 Set up the pointer to where subsequent commands will be left, for
1916 error messages. Note that smtp_peer_options will have been
1917 set from the command line if they were set in the process that passed the
1920 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
1921 as the continue goes via transport_pass_socket() and doublefork and exec.
1922 It does not wait. Unclear how we keep separate host's responses
1923 separate - we could match up by host ip+port as a bodge. */
1927 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
1929 sx->cctx = cutthrough.cctx;
1930 sx->host->port = sx->port = cutthrough.host.port;
1934 sx->cctx.sock = 0; /* stdin */
1935 sx->cctx.tls_ctx = NULL;
1936 smtp_port_for_connect(sx->host, sx->port); /* Record the port that was used */
1938 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
1939 smtp_command = big_buffer;
1940 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
1942 /* For a continued connection with TLS being proxied for us, or a
1943 held-open verify connection with TLS, nothing more to do. */
1945 if ( continue_proxy_cipher
1946 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
1947 && cutthrough.is_tls)
1950 sx->peer_offered = smtp_peer_options;
1951 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
1952 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
1953 continue_proxy_cipher ? "proxied" : "verify conn with");
1956 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
1959 /* If TLS is available on this connection, whether continued or not, attempt to
1960 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
1961 send another EHLO - the server may give a different answer in secure mode. We
1962 use a separate buffer for reading the response to STARTTLS so that if it is
1963 negative, the original EHLO data is available for subsequent analysis, should
1964 the client not be required to use TLS. If the response is bad, copy the buffer
1965 for error analysis. */
1968 if ( smtp_peer_options & OPTION_TLS
1970 && verify_check_given_host(CUSS &sx->ob->hosts_avoid_tls, sx->host) != OK
1972 || verify_check_given_host(CUSS &sx->ob->hosts_verify_avoid_tls, sx->host) != OK
1975 uschar buffer2[4096];
1976 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
1979 /* If there is an I/O error, transmission of this message is deferred. If
1980 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
1981 false, we also defer. However, if there is a temporary rejection of STARTTLS
1982 and tls_tempfail_tryclear is true, or if there is an outright rejection of
1983 STARTTLS, we carry on. This means we will try to send the message in clear,
1984 unless the host is in hosts_require_tls (tested below). */
1986 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2',
1987 sx->ob->command_timeout))
1991 || (buffer2[0] == '4' && !sx->ob->tls_tempfail_tryclear)
1994 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
1995 sx->buffer[sizeof(sx->buffer)-1] = '\0';
1996 goto RESPONSE_FAILED;
2000 /* STARTTLS accepted: try to negotiate a TLS session. */
2005 address_item * addr;
2007 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->host,
2008 sx->addrlist, sx->tblock,
2009 # ifdef SUPPORT_DANE
2010 sx->dane ? &tlsa_dnsa : NULL,
2014 if (!sx->cctx.tls_ctx)
2016 /* TLS negotiation failed; give an error. From outside, this function may
2017 be called again to try in clear on a new connection, if the options permit
2018 it for this host. */
2019 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", errstr);
2021 # ifdef SUPPORT_DANE
2024 log_write(0, LOG_MAIN,
2025 "DANE attempt failed; TLS connection to %s [%s]: %s",
2026 sx->host->name, sx->host->address, errstr);
2027 # ifndef DISABLE_EVENT
2028 (void) event_raise(sx->tblock->event_action,
2029 US"dane:fail", US"validation-failure"); /* could do with better detail */
2034 errno = ERRNO_TLSFAILURE;
2035 message = string_sprintf("TLS session: %s", errstr);
2036 sx->send_quit = FALSE;
2040 /* TLS session is set up */
2042 smtp_peer_options_wrap = smtp_peer_options;
2043 for (addr = sx->addrlist; addr; addr = addr->next)
2044 if (addr->transport_return == PENDING_DEFER)
2046 addr->cipher = tls_out.cipher;
2047 addr->ourcert = tls_out.ourcert;
2048 addr->peercert = tls_out.peercert;
2049 addr->peerdn = tls_out.peerdn;
2050 addr->ocsp = tls_out.ocsp;
2055 /* if smtps, we'll have smtp_command set to something else; always safe to
2057 smtp_command = big_buffer;
2059 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2060 helo_data is null, we are dealing with a connection that was passed from
2061 another process, and so we won't have expanded helo_data above. We have to
2062 expand it here. $sending_ip_address and $sending_port are set up right at the
2063 start of the Exim process (in exim.c). */
2065 if (tls_out.active.sock >= 0)
2070 if (!sx->helo_data && !(sx->helo_data = expand_string(sx->ob->helo_data)))
2072 uschar *message = string_sprintf("failed to expand helo_data: %s",
2073 expand_string_message);
2074 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2079 /* For SMTPS we need to wait for the initial OK response. */
2082 good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
2083 '2', sx->ob->command_timeout);
2084 #ifdef EXPERIMENTAL_DSN_INFO
2085 sx->smtp_greeting = string_copy(sx->buffer);
2087 if (!good_response) goto RESPONSE_FAILED;
2091 greeting_cmd = "EHLO";
2094 greeting_cmd = "HELO";
2096 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2099 if (smtp_write_command(sx, SCMD_FLUSH, "%s %s\r\n",
2100 sx->lmtp ? "LHLO" : greeting_cmd, sx->helo_data) < 0)
2102 good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
2103 '2', sx->ob->command_timeout);
2104 #ifdef EXPERIMENTAL_DSN_INFO
2105 sx->helo_response = string_copy(sx->buffer);
2107 if (!good_response) goto RESPONSE_FAILED;
2108 smtp_peer_options = 0;
2111 /* If the host is required to use a secure channel, ensure that we
2115 # ifdef SUPPORT_DANE
2118 # ifdef EXPERIMENTAL_REQUIRETLS
2119 || tls_requiretls & REQUIRETLS_MSG
2121 || verify_check_given_host(CUSS &sx->ob->hosts_require_tls, sx->host) == OK
2125 # ifdef EXPERIMENTAL_REQUIRETLS
2126 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2129 message = string_sprintf("a TLS session is required, but %s",
2130 smtp_peer_options & OPTION_TLS
2131 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2132 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2134 (void) event_raise(sx->tblock->event_action, US"dane:fail",
2135 smtp_peer_options & OPTION_TLS
2136 ? US"validation-failure" /* could do with better detail */
2137 : US"starttls-not-supported");
2141 #endif /*SUPPORT_TLS*/
2143 /* If TLS is active, we have just started it up and re-done the EHLO command,
2144 so its response needs to be analyzed. If TLS is not active and this is a
2145 continued session down a previously-used socket, we haven't just done EHLO, so
2148 if (continue_hostname == NULL
2150 || tls_out.active.sock >= 0
2154 if (sx->esmtp || sx->lmtp)
2156 sx->peer_offered = ehlo_response(sx->buffer,
2158 | (sx->lmtp && sx->ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2162 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2163 /*XXX if we hand peercaps on to continued-conn processes,
2164 must not depend on this addr */
2168 | (sx->ob->size_addition >= 0 ? OPTION_SIZE : 0)
2169 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2170 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2174 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2175 lmtp_ignore_quota option was set. */
2177 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2179 /* If the response to EHLO specified support for the SIZE parameter, note
2180 this, provided size_addition is non-negative. */
2182 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2184 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2185 the current host, esmtp will be false, so PIPELINING can never be used. If
2186 the current host matches hosts_avoid_pipelining, don't do it. */
2188 if ( sx->peer_offered & OPTION_PIPE
2189 && verify_check_given_host(CUSS &sx->ob->hosts_avoid_pipelining, sx->host) != OK)
2190 smtp_peer_options |= OPTION_PIPE;
2192 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2193 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2195 if ( sx->peer_offered & OPTION_CHUNKING
2196 && verify_check_given_host(CUSS &sx->ob->hosts_try_chunking, sx->host) != OK)
2197 sx->peer_offered &= ~OPTION_CHUNKING;
2199 if (sx->peer_offered & OPTION_CHUNKING)
2200 {DEBUG(D_transport) debug_printf("CHUNKING usable\n");}
2202 #ifndef DISABLE_PRDR
2203 if ( sx->peer_offered & OPTION_PRDR
2204 && verify_check_given_host(CUSS &sx->ob->hosts_try_prdr, sx->host) != OK)
2205 sx->peer_offered &= ~OPTION_PRDR;
2207 if (sx->peer_offered & OPTION_PRDR)
2208 {DEBUG(D_transport) debug_printf("PRDR usable\n");}
2211 /* Note if the server supports DSN */
2212 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2213 DEBUG(D_transport) debug_printf("%susing DSN\n",
2214 sx->peer_offered & OPTION_DSN ? "" : "not ");
2216 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2217 if (sx->peer_offered & OPTION_REQUIRETLS)
2219 smtp_peer_options |= OPTION_REQUIRETLS;
2220 DEBUG(D_transport) debug_printf(
2221 tls_requiretls & REQUIRETLS_MSG
2222 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2226 /* Note if the response to EHLO specifies support for the AUTH extension.
2227 If it has, check that this host is one we want to authenticate to, and do
2228 the business. The host name and address must be available when the
2229 authenticator's client driver is running. */
2231 switch (yield = smtp_auth(sx, sx->buffer, sizeof(sx->buffer)))
2233 default: goto SEND_QUIT;
2235 case FAIL_SEND: goto SEND_FAILED;
2236 case FAIL: goto RESPONSE_FAILED;
2240 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2242 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2243 message-specific. */
2245 sx->setting_up = FALSE;
2248 if (sx->addrlist->prop.utf8_msg)
2252 /* If the transport sets a downconversion mode it overrides any set by ACL
2255 if ((s = sx->ob->utf8_downconvert))
2257 if (!(s = expand_string(s)))
2259 message = string_sprintf("failed to expand utf8_downconvert: %s",
2260 expand_string_message);
2261 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2267 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2268 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2270 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2271 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2273 case '-': if (s[1] == '1')
2275 sx->addrlist->prop.utf8_downcvt = FALSE;
2276 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2282 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2283 && !sx->addrlist->prop.utf8_downcvt_maybe;
2284 DEBUG(D_transport) if (!sx->utf8_needed)
2285 debug_printf("utf8: %s downconvert\n",
2286 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2289 /* If this is an international message we need the host to speak SMTPUTF8 */
2290 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2292 errno = ERRNO_UTF8_FWD;
2293 goto RESPONSE_FAILED;
2295 #endif /*SUPPORT_I18N*/
2297 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2298 /*XXX should tls_requiretls actually be per-addr? */
2300 if ( tls_requiretls & REQUIRETLS_MSG
2301 && !(sx->peer_offered & OPTION_REQUIRETLS)
2304 sx->setting_up = TRUE;
2305 errno = ERRNO_REQUIRETLS;
2306 message = US"REQUIRETLS support is required from the server"
2307 " but it was not offered";
2308 DEBUG(D_transport) debug_printf("%s\n", message);
2321 sx->send_quit = check_response(sx->host, &errno, sx->addrlist->more_errno,
2322 sx->buffer, &code, &message, &pass_message);
2328 message = US string_sprintf("send() to %s [%s] failed: %s",
2329 sx->host->name, sx->host->address, strerror(errno));
2330 sx->send_quit = FALSE;
2336 message = string_sprintf("Remote host closed connection in response to %s"
2337 " (EHLO response was: %s)", smtp_command, sx->buffer);
2338 sx->send_quit = FALSE;
2342 /* This label is jumped to directly when a TLS negotiation has failed,
2343 or was not done for a host for which it is required. Values will be set
2344 in message and errno, and setting_up will always be true. Treat as
2345 a temporary error. */
2349 # ifdef EXPERIMENTAL_REQUIRETLS
2350 if (errno == ERRNO_REQUIRETLS)
2351 code = '5', yield = FAIL;
2352 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2355 code = '4', yield = DEFER;
2359 /* The failure happened while setting up the call; see if the failure was
2360 a 5xx response (this will either be on connection, or following HELO - a 5xx
2361 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2362 fail all addresses, as this host is never going to accept them. For other
2363 errors during setting up (timeouts or whatever), defer all addresses, and
2364 yield DEFER, so that the host is not tried again for a while.
2366 XXX This peeking for another host feels like a layering violation. We want
2367 to note the host as unusable, but down here we shouldn't know if this was
2368 the last host to try for the addr(list). Perhaps the upper layer should be
2369 the one to do set_errno() ? The problem is that currently the addr is where
2370 errno etc. are stashed, but until we run out of hosts to try the errors are
2371 host-specific. Maybe we should enhance the host_item definition? */
2374 sx->ok = FALSE; /* For when reached by GOTO */
2375 set_errno(sx->addrlist, errno, message,
2380 || errno == ERRNO_UTF8_FWD
2383 pass_message, sx->host
2384 #ifdef EXPERIMENTAL_DSN_INFO
2385 , sx->smtp_greeting, sx->helo_response
2394 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2397 if (sx->cctx.tls_ctx)
2399 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2400 sx->cctx.tls_ctx = NULL;
2404 /* Close the socket, and return the appropriate value, first setting
2405 works because the NULL setting is passed back to the calling process, and
2406 remote_max_parallel is forced to 1 when delivering over an existing connection,
2409 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2412 shutdown(sx->cctx.sock, SHUT_WR);
2413 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2414 for (rc = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && rc > 0;)
2415 rc--; /* drain socket */
2416 sx->send_quit = FALSE;
2418 (void)close(sx->cctx.sock);
2421 #ifndef DISABLE_EVENT
2422 (void) event_raise(sx->tblock->event_action, US"tcp:close", NULL);
2425 continue_transport = NULL;
2426 continue_hostname = NULL;
2433 /* Create the string of options that will be appended to the MAIL FROM:
2434 in the connection context buffer */
2437 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2439 uschar * p = sx->buffer;
2440 address_item * addr;
2445 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2446 send it, adding something to the message size to allow for imprecision
2447 and things that get added en route. Exim keeps the number of lines
2448 in a message, so we can give an accurate value for the original message, but we
2449 need some additional to handle added headers. (Double "." characters don't get
2450 included in the count.) */
2452 if ( message_size > 0
2453 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2455 /*XXX problem here under spool_files_wireformat?
2456 Or just forget about lines? Or inflate by a fixed proportion? */
2458 sprintf(CS p, " SIZE=%d", message_size+message_linecount+sx->ob->size_addition);
2462 #ifndef DISABLE_PRDR
2463 /* If it supports Per-Recipient Data Reponses, and we have omre than one recipient,
2466 sx->prdr_active = FALSE;
2467 if (sx->peer_offered & OPTION_PRDR)
2468 for (addr = addrlist; addr; addr = addr->next)
2469 if (addr->transport_return == PENDING_DEFER)
2471 for (addr = addr->next; addr; addr = addr->next)
2472 if (addr->transport_return == PENDING_DEFER)
2473 { /* at least two recipients to send */
2474 sx->prdr_active = TRUE;
2475 sprintf(CS p, " PRDR"); p += 5;
2483 /* If it supports internationalised messages, and this meesage need that,
2486 if ( sx->peer_offered & OPTION_UTF8
2487 && addrlist->prop.utf8_msg
2488 && !addrlist->prop.utf8_downcvt
2490 Ustrcpy(p, " SMTPUTF8"), p += 9;
2493 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2494 if (tls_requiretls & REQUIRETLS_MSG)
2495 Ustrcpy(p, " REQUIRETLS") , p += 11;
2498 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
2499 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
2500 addr && address_count < sx->max_rcpt;
2501 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
2504 if (!(addr->dsn_flags & rf_dsnlasthop))
2506 sx->dsn_all_lasthop = FALSE;
2511 /* Add any DSN flags to the mail command */
2513 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
2515 if (dsn_ret == dsn_ret_hdrs)
2516 { Ustrcpy(p, " RET=HDRS"); p += 9; }
2517 else if (dsn_ret == dsn_ret_full)
2518 { Ustrcpy(p, " RET=FULL"); p += 9; }
2522 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
2527 /* If an authenticated_sender override has been specified for this transport
2528 instance, expand it. If the expansion is forced to fail, and there was already
2529 an authenticated_sender for this message, the original value will be used.
2530 Other expansion failures are serious. An empty result is ignored, but there is
2531 otherwise no check - this feature is expected to be used with LMTP and other
2532 cases where non-standard addresses (e.g. without domains) might be required. */
2534 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->ob))
2542 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
2544 uschar * p = sx->buffer;
2547 /* Add any DSN flags to the rcpt command */
2549 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
2551 if (addr->dsn_flags & rf_dsnflags)
2556 Ustrcpy(p, " NOTIFY=");
2558 for (i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
2560 if (!first) *p++ = ',';
2562 Ustrcpy(p, rf_names[i]);
2567 if (addr->dsn_orcpt)
2569 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
2580 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
2581 -1 MAIL response error
2582 -2 any non-MAIL read i/o error
2583 -3 non-MAIL response timeout
2584 -4 internal error; channel still usable
2589 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
2591 address_item * addr;
2595 if (build_mailcmd_options(sx, sx->first_addr) != OK)
2601 /* From here until we send the DATA command, we can make use of PIPELINING
2602 if the server host supports it. The code has to be able to check the responses
2603 at any point, for when the buffer fills up, so we write it totally generally.
2604 When PIPELINING is off, each command written reports that it has flushed the
2607 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
2610 uschar * s = sx->from_addr;
2612 uschar * errstr = NULL;
2614 /* If we must downconvert, do the from-address here. Remember we had to
2615 for the to-addresses (done below), and also (ugly) for re-doing when building
2616 the delivery log line. */
2618 if ( sx->addrlist->prop.utf8_msg
2619 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
2622 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
2624 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
2628 setflag(sx->addrlist, af_utf8_downcvt);
2632 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
2633 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
2636 mail_command = string_copy(big_buffer); /* Save for later error message */
2640 case -1: /* Transmission error */
2643 case +1: /* Cmd was sent */
2644 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
2645 sx->ob->command_timeout))
2647 if (errno == 0 && sx->buffer[0] == '4')
2649 errno = ERRNO_MAIL4XX;
2650 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
2654 sx->pending_MAIL = FALSE;
2657 /* otherwise zero: command queued for pipeline */
2660 /* Pass over all the relevant recipient addresses for this host, which are the
2661 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
2662 several before we have to read the responses for those seen so far. This
2663 checking is done by a subroutine because it also needs to be done at the end.
2664 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
2665 the next one if not all are sent.
2667 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
2668 last address because we want to abort if any recipients have any kind of
2669 problem, temporary or permanent. We know that all recipient addresses will have
2670 the PENDING_DEFER status, because only one attempt is ever made, and we know
2671 that max_rcpt will be large, so all addresses will be done at once.
2673 For verify we flush the pipeline after any (the only) rcpt address. */
2675 for (addr = sx->first_addr, address_count = 0;
2676 addr && address_count < sx->max_rcpt;
2677 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
2683 if (tcp_out_fastopen != TFO_NOT_USED && !f.tcp_out_fastopen_logged)
2685 setflag(addr, af_tcp_fastopen_conn);
2686 if (tcp_out_fastopen >= TFO_USED) setflag(addr, af_tcp_fastopen);
2689 addr->dsn_aware = sx->peer_offered & OPTION_DSN
2690 ? dsn_support_yes : dsn_support_no;
2693 no_flush = pipelining_active && !sx->verify
2694 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
2696 build_rcptcmd_options(sx, addr);
2698 /* Now send the RCPT command, and process outstanding responses when
2699 necessary. After a timeout on RCPT, we just end the function, leaving the
2700 yield as OK, because this error can often mean that there is a problem with
2701 just one address, so we don't want to delay the host. */
2703 rcpt_addr = transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes);
2706 if ( testflag(sx->addrlist, af_utf8_downcvt)
2707 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
2710 /*XXX could we use a per-address errstr here? Not fail the whole send? */
2711 errno = ERRNO_EXPANDFAIL;
2712 return -5; /*XXX too harsh? */
2716 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
2717 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
2719 if (count < 0) return -5;
2722 switch(sync_responses(sx, count, 0))
2724 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
2725 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
2728 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
2729 if (!sx->lmtp) /* can't tell about progress yet */
2730 sx->completed_addr = TRUE;
2731 case 0: /* No 2xx or 5xx, but no probs */
2734 case -1: return -3; /* Timeout on RCPT */
2735 case -2: return -2; /* non-MAIL read i/o error */
2736 default: return -1; /* any MAIL error */
2738 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
2740 } /* Loop for next address */
2742 f.tcp_out_fastopen_logged = TRUE;
2743 sx->next_addr = addr;
2749 /*****************************************************
2750 * Proxy TLS connection for another transport process *
2751 ******************************************************/
2753 Close the unused end of the pipe, fork once more, then use the given buffer
2754 as a staging area, and select on both the given fd and the TLS'd client-fd for
2755 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
2756 Do blocking full-size writes, and reads under a timeout. Once both input
2757 channels are closed, exit the process.
2761 buf space to use for buffering
2762 bufsiz size of buffer
2763 pfd pipe filedescriptor array; [0] is comms to proxied process
2764 timeout per-read timeout, seconds
2768 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
2772 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
2773 int rc, i, fd_bits, nbytes;
2778 DEBUG(D_transport) debug_printf("proxy-proc final-pid %d\n", rc);
2779 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
2782 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
2783 set_process_info("proxying TLS connection for continued transport");
2785 FD_SET(tls_out.active.sock, &rfds);
2786 FD_SET(pfd[0], &rfds);
2788 for (fd_bits = 3; fd_bits; )
2790 time_t time_left = timeout;
2791 time_t time_start = time(NULL);
2797 struct timeval tv = { time_left, 0 };
2800 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
2802 if (rc < 0 && errno == EINTR)
2803 if ((time_left -= time(NULL) - time_start) > 0) continue;
2807 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
2811 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
2813 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
2814 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
2818 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
2820 /* handle inbound data */
2821 if (FD_ISSET(tls_out.active.sock, &rfds))
2822 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
2825 FD_CLR(tls_out.active.sock, &rfds);
2826 shutdown(pfd[0], SHUT_WR);
2831 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
2832 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
2834 else if (fd_bits & 1)
2835 FD_SET(tls_out.active.sock, &rfds);
2837 /* handle outbound data */
2838 if (FD_ISSET(pfd[0], &rfds))
2839 if ((rc = read(pfd[0], buf, bsize)) <= 0)
2842 tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
2847 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
2848 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
2851 else if (fd_bits & 2)
2852 FD_SET(pfd[0], &rfds);
2856 if (f.running_in_test_harness) millisleep(100); /* let logging complete */
2857 exim_exit(0, US"TLS proxy");
2862 /*************************************************
2863 * Deliver address list to given host *
2864 *************************************************/
2866 /* If continue_hostname is not null, we get here only when continuing to
2867 deliver down an existing channel. The channel was passed as the standard
2868 input. TLS is never active on a passed channel; the previous process always
2869 closes it down before passing the connection on.
2871 Otherwise, we have to make a connection to the remote host, and do the
2872 initial protocol exchange.
2874 When running as an MUA wrapper, if the sender or any recipient is rejected,
2875 temporarily or permanently, we force failure for all recipients.
2878 addrlist chain of potential addresses to deliver; only those whose
2879 transport_return field is set to PENDING_DEFER are currently
2880 being processed; others should be skipped - they have either
2881 been delivered to an earlier host or IP address, or been
2882 failed by one of them.
2883 host host to deliver to
2884 host_af AF_INET or AF_INET6
2885 defport default TCP/IP port to use if host does not specify, in host
2887 interface interface to bind to, or NULL
2888 tblock transport instance block
2889 message_defer set TRUE if yield is OK, but all addresses were deferred
2890 because of a non-recipient, non-host failure, that is, a
2891 4xx response to MAIL FROM, DATA, or ".". This is a defer
2892 that is specific to the message.
2893 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
2894 a second attempt after TLS initialization fails
2896 Returns: OK - the connection was made and the delivery attempted;
2897 the result for each address is in its data block.
2898 DEFER - the connection could not be made, or something failed
2899 while setting up the SMTP session, or there was a
2900 non-message-specific error, such as a timeout.
2901 ERROR - a filter command is specified for this transport,
2902 and there was a problem setting it up; OR helo_data
2903 or add_headers or authenticated_sender is specified
2904 for this transport, and the string failed to expand
2908 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
2909 uschar *interface, transport_instance *tblock,
2910 BOOL *message_defer, BOOL suppress_tls)
2916 struct timeval start_delivery_time;
2918 BOOL pass_message = FALSE;
2919 uschar *message = NULL;
2920 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
2924 gettimeofday(&start_delivery_time, NULL);
2925 suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
2926 *message_defer = FALSE;
2928 sx.addrlist = addrlist;
2930 sx.host_af = host_af,
2932 sx.interface = interface;
2933 sx.helo_data = NULL;
2937 /* Get the channel set up ready for a message (MAIL FROM being the next
2938 SMTP command to send */
2940 if ((rc = smtp_setup_conn(&sx, suppress_tls)) != OK)
2943 /* If there is a filter command specified for this transport, we can now
2944 set it up. This cannot be done until the identify of the host is known. */
2946 if (tblock->filter_command)
2948 transport_filter_timeout = tblock->filter_timeout;
2950 /* On failure, copy the error to all addresses, abandon the SMTP call, and
2953 if (!transport_set_up_command(&transport_filter_argv,
2954 tblock->filter_command, TRUE, DEFER, addrlist,
2955 string_sprintf("%.50s transport", tblock->name), NULL))
2957 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
2963 if ( transport_filter_argv
2964 && *transport_filter_argv
2965 && **transport_filter_argv
2966 && sx.peer_offered & OPTION_CHUNKING
2969 sx.peer_offered &= ~OPTION_CHUNKING;
2970 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
2974 sx.first_addr = addrlist;
2976 /* For messages that have more than the maximum number of envelope recipients,
2977 we want to send several transactions down the same SMTP connection. (See
2978 comments in deliver.c as to how this reconciles, heuristically, with
2979 remote_max_parallel.) This optimization was added to Exim after the following
2980 code was already working. The simplest way to put it in without disturbing the
2981 code was to use a goto to jump back to this point when there is another
2982 transaction to handle. */
2985 sx.from_addr = return_path;
2986 sx.sync_addr = sx.first_addr;
2988 sx.send_rset = TRUE;
2989 sx.completed_addr = FALSE;
2992 /* If we are a continued-connection-after-verify the MAIL and RCPT
2993 commands were already sent; do not re-send but do mark the addrs as
2994 having been accepted up to RCPT stage. A traditional cont-conn
2995 always has a sequence number greater than one. */
2997 if (continue_hostname && continue_sequence == 1)
2999 address_item * addr;
3001 sx.peer_offered = smtp_peer_options;
3002 sx.pending_MAIL = FALSE;
3004 sx.next_addr = NULL;
3006 for (addr = addrlist; addr; addr = addr->next)
3007 addr->transport_return = PENDING_OK;
3011 /* Initiate a message transfer. */
3013 switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
3016 case -1: case -2: goto RESPONSE_FAILED;
3017 case -3: goto END_OFF;
3018 case -4: goto SEND_QUIT;
3019 default: goto SEND_FAILED;
3022 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3023 permanently or temporarily. We should have flushed and synced after the last
3031 for (a = sx.first_addr, cnt = 0; a && cnt < sx.max_rcpt; a = a->next, cnt++)
3032 if (a->transport_return != PENDING_OK)
3034 /*XXX could we find a better errno than 0 here? */
3035 set_errno_nohost(addrlist, 0, a->message, FAIL,
3036 testflag(a, af_pass_message));
3043 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3044 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3045 have a good recipient buffered up if we are pipelining. We don't want to waste
3046 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3047 are pipelining. The responses are all handled by sync_responses().
3048 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3051 if ( !(sx.peer_offered & OPTION_CHUNKING)
3052 && (sx.ok || (pipelining_active && !mua_wrapper)))
3054 int count = smtp_write_command(&sx, SCMD_FLUSH, "DATA\r\n");
3056 if (count < 0) goto SEND_FAILED;
3057 switch(sync_responses(&sx, count, sx.ok ? +1 : -1))
3059 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3060 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3063 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3064 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3065 case 0: break; /* No 2xx or 5xx, but no probs */
3067 case -1: goto END_OFF; /* Timeout on RCPT */
3068 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3070 pipelining_active = FALSE;
3071 data_command = string_copy(big_buffer); /* Save for later error message */
3074 /* If there were no good recipients (but otherwise there have been no
3075 problems), just set ok TRUE, since we have handled address-specific errors
3076 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3077 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3078 well as body. Set the appropriate timeout value to be used for each chunk.
3079 (Haven't been able to make it work using select() for writing yet.) */
3081 if (!(sx.peer_offered & OPTION_CHUNKING) && !sx.ok)
3083 /* Save the first address of the next batch. */
3084 sx.first_addr = sx.next_addr;
3090 transport_ctx tctx = {
3091 {sx.cctx.sock}, /*XXX will this need TLS info? */
3094 US".", US"..", /* Escaping strings */
3095 topt_use_crlf | topt_escape_headers
3096 | (tblock->body_only ? topt_no_headers : 0)
3097 | (tblock->headers_only ? topt_no_body : 0)
3098 | (tblock->return_path_add ? topt_add_return_path : 0)
3099 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3100 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3103 /* If using CHUNKING we need a callback from the generic transport
3104 support to us, for the sending of BDAT smtp commands and the reaping
3105 of responses. The callback needs a whole bunch of state so set up
3106 a transport-context structure to be passed around. */
3108 if (sx.peer_offered & OPTION_CHUNKING)
3110 tctx.check_string = tctx.escape_string = NULL;
3111 tctx.options |= topt_use_bdat;
3112 tctx.chunk_cb = smtp_chunk_cmd_callback;
3113 sx.pending_BDAT = FALSE;
3114 sx.good_RCPT = sx.ok;
3116 tctx.smtp_context = &sx;
3119 tctx.options |= topt_end_dot;
3121 /* Save the first address of the next batch. */
3122 sx.first_addr = sx.next_addr;
3124 /* Responses from CHUNKING commands go in buffer. Otherwise,
3125 there has not been a response. */
3129 sigalrm_seen = FALSE;
3130 transport_write_timeout = sx.ob->data_timeout;
3131 smtp_command = US"sending data block"; /* For error messages */
3132 DEBUG(D_transport|D_v)
3133 if (sx.peer_offered & OPTION_CHUNKING)
3134 debug_printf(" will write message using CHUNKING\n");
3136 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3137 transport_count = 0;
3139 #ifndef DISABLE_DKIM
3140 dkim_exim_sign_init();
3141 # ifdef EXPERIMENTAL_ARC
3143 uschar * s = sx.ob->arc_sign;
3146 if (!(sx.ob->dkim.arc_signspec = s = expand_string(s)))
3148 if (!f.expand_string_forcedfail)
3150 message = US"failed to expand arc_sign";
3157 /* Ask dkim code to hash the body for ARC */
3158 (void) arc_ams_setup_sign_bodyhash();
3159 sx.ob->dkim.force_bodyhash = TRUE;
3164 sx.ok = dkim_transport_write_message(&tctx, &sx.ob->dkim, CUSS &message);
3166 sx.ok = transport_write_message(&tctx, 0);
3169 /* transport_write_message() uses write() because it is called from other
3170 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3171 it can exit with "Broken pipe" as its error. This really means that the
3172 socket got closed at the far end. */
3174 transport_write_timeout = 0; /* for subsequent transports */
3176 /* Failure can either be some kind of I/O disaster (including timeout),
3177 or the failure of a transport filter or the expansion of added headers.
3178 Or, when CHUNKING, it can be a protocol-detected failure. */
3181 if (message) goto SEND_FAILED;
3182 else goto RESPONSE_FAILED;
3184 /* We used to send the terminating "." explicitly here, but because of
3185 buffering effects at both ends of TCP/IP connections, you don't gain
3186 anything by keeping it separate, so it might as well go in the final
3187 data buffer for efficiency. This is now done by setting the topt_end_dot
3190 smtp_command = US"end of data";
3192 if (sx.peer_offered & OPTION_CHUNKING && sx.cmd_count > 1)
3194 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3195 switch(sync_responses(&sx, sx.cmd_count-1, 0))
3197 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3198 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3201 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3202 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3203 case 0: break; /* No 2xx or 5xx, but no probs */
3205 case -1: goto END_OFF; /* Timeout on RCPT */
3206 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3210 #ifndef DISABLE_PRDR
3211 /* For PRDR we optionally get a partial-responses warning
3212 * followed by the individual responses, before going on with
3213 * the overall response. If we don't get the warning then deal
3214 * with per non-PRDR. */
3217 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '3',
3218 sx.ob->final_timeout);
3219 if (!sx.ok && errno == 0) switch(sx.buffer[0])
3221 case '2': sx.prdr_active = FALSE;
3224 case '4': errno = ERRNO_DATA4XX;
3225 addrlist->more_errno |=
3226 ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3233 /* For non-PRDR SMTP, we now read a single response that applies to the
3234 whole message. If it is OK, then all the addresses have been delivered. */
3238 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3239 sx.ob->final_timeout);
3240 if (!sx.ok && errno == 0 && sx.buffer[0] == '4')
3242 errno = ERRNO_DATA4XX;
3243 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3247 /* For LMTP, we get back a response for every RCPT command that we sent;
3248 some may be accepted and some rejected. For those that get a response, their
3249 status is fixed; any that are accepted have been handed over, even if later
3250 responses crash - at least, that's how I read RFC 2033.
3252 If all went well, mark the recipient addresses as completed, record which
3253 host/IPaddress they were delivered to, and cut out RSET when sending another
3254 message down the same channel. Write the completed addresses to the journal
3255 now so that they are recorded in case there is a crash of hardware or
3256 software before the spool gets updated. Also record the final SMTP
3257 confirmation if needed (for SMTP only). */
3262 struct timeval delivery_time;
3264 uschar * conf = NULL;
3266 timesince(&delivery_time, &start_delivery_time);
3267 sx.send_rset = FALSE;
3268 pipelining_active = FALSE;
3270 /* Set up confirmation if needed - applies only to SMTP */
3273 #ifdef DISABLE_EVENT
3274 LOGGING(smtp_confirmation) &&
3279 const uschar *s = string_printing(sx.buffer);
3280 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3281 conf = (s == sx.buffer)? US string_copy(s) : US s;
3284 /* Process all transported addresses - for LMTP or PRDR, read a status for
3287 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3289 if (addr->transport_return != PENDING_OK) continue;
3291 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3292 remaining addresses. Otherwise, it's a return code for just the one
3293 address. For temporary errors, add a retry item for the address so that
3294 it doesn't get tried again too soon. */
3296 #ifndef DISABLE_PRDR
3297 if (sx.lmtp || sx.prdr_active)
3302 if (!smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3303 sx.ob->final_timeout))
3305 if (errno != 0 || sx.buffer[0] == 0) goto RESPONSE_FAILED;
3306 addr->message = string_sprintf(
3307 #ifndef DISABLE_PRDR
3308 "%s error after %s: %s", sx.prdr_active ? "PRDR":"LMTP",
3310 "LMTP error after %s: %s",
3312 data_command, string_printing(sx.buffer));
3313 setflag(addr, af_pass_message); /* Allow message to go to user */
3314 if (sx.buffer[0] == '5')
3315 addr->transport_return = FAIL;
3318 errno = ERRNO_DATA4XX;
3319 addr->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3320 addr->transport_return = DEFER;
3321 #ifndef DISABLE_PRDR
3322 if (!sx.prdr_active)
3324 retry_add_item(addr, addr->address_retry_key, 0);
3328 sx.completed_addr = TRUE; /* NOW we can set this flag */
3329 if (LOGGING(smtp_confirmation))
3331 const uschar *s = string_printing(sx.buffer);
3332 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3333 conf = (s == sx.buffer) ? US string_copy(s) : US s;
3337 /* SMTP, or success return from LMTP for this address. Pass back the
3338 actual host that was used. */
3340 addr->transport_return = OK;
3341 addr->more_errno = delivery_time.tv_sec;
3342 addr->delivery_usec = delivery_time.tv_usec;
3343 addr->host_used = host;
3344 addr->special_action = flag;
3345 addr->message = conf;
3347 if (sx.pipelining_used) setflag(addr, af_pipelining);
3348 #ifndef DISABLE_PRDR
3349 if (sx.prdr_active) setflag(addr, af_prdr_used);
3351 if (sx.peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3354 #ifndef DISABLE_PRDR
3355 if (!sx.prdr_active)
3358 /* Update the journal. For homonymic addresses, use the base address plus
3359 the transport name. See lots of comments in deliver.c about the reasons
3360 for the complications when homonyms are involved. Just carry on after
3361 write error, as it may prove possible to update the spool file later. */
3363 if (testflag(addr, af_homonym))
3364 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3366 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3368 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx.buffer);
3369 len = Ustrlen(CS sx.buffer);
3370 if (write(journal_fd, sx.buffer, len) != len)
3371 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3372 "%s: %s", sx.buffer, strerror(errno));
3376 #ifndef DISABLE_PRDR
3379 const uschar * overall_message;
3381 /* PRDR - get the final, overall response. For any non-success
3382 upgrade all the address statuses. */
3384 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3385 sx.ob->final_timeout);
3388 if(errno == 0 && sx.buffer[0] == '4')
3390 errno = ERRNO_DATA4XX;
3391 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3393 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3394 if (sx.buffer[0] == '5' || addr->transport_return == OK)
3395 addr->transport_return = PENDING_OK; /* allow set_errno action */
3396 goto RESPONSE_FAILED;
3399 /* Append the overall response to the individual PRDR response for logging
3400 and update the journal, or setup retry. */
3402 overall_message = string_printing(sx.buffer);
3403 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3404 if (addr->transport_return == OK)
3405 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
3407 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3408 if (addr->transport_return == OK)
3410 if (testflag(addr, af_homonym))
3411 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3413 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3415 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx.buffer);
3416 len = Ustrlen(CS sx.buffer);
3417 if (write(journal_fd, sx.buffer, len) != len)
3418 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3419 "%s: %s", sx.buffer, strerror(errno));
3421 else if (addr->transport_return == DEFER)
3422 retry_add_item(addr, addr->address_retry_key, -2);
3426 /* Ensure the journal file is pushed out to disk. */
3428 if (EXIMfsync(journal_fd) < 0)
3429 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
3435 /* Handle general (not specific to one address) failures here. The value of ok
3436 is used to skip over this code on the falling through case. A timeout causes a
3437 deferral. Other errors may defer or fail according to the response code, and
3438 may set up a special errno value, e.g. after connection chopped, which is
3439 assumed if errno == 0 and there is no text in the buffer. If control reaches
3440 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
3441 the problem is not related to this specific message. */
3446 uschar * set_message;
3452 sx.send_quit = check_response(host, &save_errno, addrlist->more_errno,
3453 sx.buffer, &code, &message, &pass_message);
3461 message = string_sprintf("send() to %s [%s] failed: %s",
3462 host->name, host->address, message ? message : US strerror(save_errno));
3463 sx.send_quit = FALSE;
3471 sx.ok = FALSE; /* For when reached by GOTO */
3472 set_message = message;
3474 /* We want to handle timeouts after MAIL or "." and loss of connection after
3475 "." specially. They can indicate a problem with the sender address or with
3476 the contents of the message rather than a real error on the connection. These
3477 cases are treated in the same way as a 4xx response. This next bit of code
3478 does the classification. */
3485 message_error = TRUE;
3489 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
3490 Ustrncmp(smtp_command,"end ",4) == 0;
3493 case ERRNO_SMTPCLOSED:
3494 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
3498 message_error = FALSE;
3502 /* Handle the cases that are treated as message errors. These are:
3504 (a) negative response or timeout after MAIL
3505 (b) negative response after DATA
3506 (c) negative response or timeout or dropped connection after "."
3507 (d) utf8 support required and not offered
3509 It won't be a negative response or timeout after RCPT, as that is dealt
3510 with separately above. The action in all cases is to set an appropriate
3511 error code for all the addresses, but to leave yield set to OK because the
3512 host itself has not failed. Of course, it might in practice have failed
3513 when we've had a timeout, but if so, we'll discover that at the next
3514 delivery attempt. For a temporary error, set the message_defer flag, and
3515 write to the logs for information if this is not the last host. The error
3516 for the last host will be logged as part of the address's log line. */
3520 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
3522 /* If there's an errno, the message contains just the identity of
3527 else /* Anything other than 5 is treated as temporary */
3531 message = US string_sprintf("%s: %s", message, strerror(save_errno));
3533 write_logs(host, message, sx.first_addr ? sx.first_addr->basic_errno : 0);
3535 *message_defer = TRUE;
3539 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
3540 ".", or some other transportation error. We defer all addresses and yield
3541 DEFER, except for the case of failed add_headers expansion, or a transport
3542 filter failure, when the yield should be ERROR, to stop it trying other
3548 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
3549 save_errno == ERRNO_FILTER_FAIL)? ERROR : DEFER;
3553 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
3554 #ifdef EXPERIMENTAL_DSN_INFO
3555 , sx.smtp_greeting, sx.helo_response
3561 /* If all has gone well, send_quit will be set TRUE, implying we can end the
3562 SMTP session tidily. However, if there were too many addresses to send in one
3563 message (indicated by first_addr being non-NULL) we want to carry on with the
3564 rest of them. Also, it is desirable to send more than one message down the SMTP
3565 connection if there are several waiting, provided we haven't already sent so
3566 many as to hit the configured limit. The function transport_check_waiting looks
3567 for a waiting message and returns its id. Then transport_pass_socket tries to
3568 set up a continued delivery by passing the socket on to another process. The
3569 variable send_rset is FALSE if a message has just been successfully transfered.
3571 If we are already sending down a continued channel, there may be further
3572 addresses not yet delivered that are aimed at the same host, but which have not
3573 been passed in this run of the transport. In this case, continue_more will be
3574 true, and all we should do is send RSET if necessary, and return, leaving the
3577 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
3578 do not want to continue with other messages down the same channel, because that
3579 can lead to looping between two or more messages, all with the same,
3580 temporarily failing address(es). [The retry information isn't updated yet, so
3581 new processes keep on trying.] We probably also don't want to try more of this
3582 message's addresses either.
3584 If we have started a TLS session, we have to end it before passing the
3585 connection to a new process. However, not all servers can handle this (Exim
3586 can), so we do not pass such a connection on if the host matches
3587 hosts_nopass_tls. */
3590 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
3591 "yield=%d first_address is %sNULL\n", sx.ok, sx.send_quit,
3592 sx.send_rset, f.continue_more, yield, sx.first_addr ? "not " : "");
3594 if (sx.completed_addr && sx.ok && sx.send_quit)
3597 smtp_compare_t t_compare;
3599 t_compare.tblock = tblock;
3600 t_compare.current_sender_address = sender_address;
3602 if ( sx.first_addr != NULL
3606 ( tls_out.active.sock < 0 && !continue_proxy_cipher
3607 || verify_check_given_host(CUSS &sx.ob->hosts_nopass_tls, host) != OK
3611 transport_check_waiting(tblock->name, host->name,
3612 tblock->connection_max_messages, new_message_id, &more,
3613 (oicf)smtp_are_same_identities, (void*)&t_compare)
3620 if (! (sx.ok = smtp_write_command(&sx, SCMD_FLUSH, "RSET\r\n") >= 0))
3622 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
3623 host->address, strerror(errno));
3624 sx.send_quit = FALSE;
3626 else if (! (sx.ok = smtp_read_response(&sx, sx.buffer,
3627 sizeof(sx.buffer), '2', sx.ob->command_timeout)))
3630 sx.send_quit = check_response(host, &errno, 0, sx.buffer, &code, &msg,
3634 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
3635 host->name, host->address, msg);
3639 /* Either RSET was not needed, or it succeeded */
3646 int socket_fd = sx.cctx.sock;
3649 if (sx.first_addr != NULL) /* More addresses still to be sent */
3650 { /* in this run of the transport */
3651 continue_sequence++; /* Causes * in logging */
3655 /* Unless caller said it already has more messages listed for this host,
3656 pass the connection on to a new Exim process (below, the call to
3657 transport_pass_socket). If the caller has more ready, just return with
3658 the connection still open. */
3661 if (tls_out.active.sock >= 0)
3662 if ( f.continue_more
3663 || verify_check_given_host(CUSS &sx.ob->hosts_noproxy_tls, host) == OK)
3665 /* Before passing the socket on, or returning to caller with it still
3666 open, we must shut down TLS. Not all MTAs allow for the continuation
3667 of the SMTP session when TLS is shut down. We test for this by sending
3668 a new EHLO. If we don't get a good response, we don't attempt to pass
3671 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
3672 sx.cctx.tls_ctx = NULL;
3673 smtp_peer_options = smtp_peer_options_wrap;
3675 && smtp_write_command(&sx, SCMD_FLUSH, "EHLO %s\r\n", sx.helo_data)
3677 && smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
3678 '2', sx.ob->command_timeout);
3680 if (sx.ok && f.continue_more)
3681 return yield; /* More addresses for another run */
3685 /* Set up a pipe for proxying TLS for the new transport process */
3687 smtp_peer_options |= OPTION_TLS;
3688 if (sx.ok = (socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
3691 set_errno(sx.first_addr, errno, US"internal allocation problem",
3693 # ifdef EXPERIMENTAL_DSN_INFO
3694 , sx.smtp_greeting, sx.helo_response
3700 if (f.continue_more)
3701 return yield; /* More addresses for another run */
3703 /* If the socket is successfully passed, we mustn't send QUIT (or
3704 indeed anything!) from here. */
3706 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
3707 propagate it from the initial
3709 if (sx.ok && transport_pass_socket(tblock->name, host->name,
3710 host->address, new_message_id, socket_fd))
3712 sx.send_quit = FALSE;
3714 /* We have passed the client socket to a fresh transport process.
3715 If TLS is still active, we need to proxy it for the transport we
3716 just passed the baton to. Fork a child to to do it, and return to
3717 get logging done asap. Which way to place the work makes assumptions
3718 about post-fork prioritisation which may not hold on all platforms. */
3720 if (tls_out.active.sock >= 0)
3723 if (pid == 0) /* child; fork again to disconnect totally */
3725 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
3726 /* does not return */
3727 smtp_proxy_tls(sx.cctx.tls_ctx, sx.buffer, sizeof(sx.buffer), pfd,
3728 sx.ob->command_timeout);
3731 if (pid > 0) /* parent */
3733 DEBUG(D_transport) debug_printf("proxy-proc inter-pid %d\n", pid);
3735 /* tidy the inter-proc to disconn the proxy proc */
3736 waitpid(pid, NULL, 0);
3737 tls_close(sx.cctx.tls_ctx, TLS_NO_SHUTDOWN);
3738 sx.cctx.tls_ctx = NULL;
3739 (void)close(sx.cctx.sock);
3741 continue_transport = NULL;
3742 continue_hostname = NULL;
3745 log_write(0, LOG_PANIC_DIE, "fork failed");
3751 /* If RSET failed and there are addresses left, they get deferred. */
3753 set_errno(sx.first_addr, errno, msg, DEFER, FALSE, host
3754 #ifdef EXPERIMENTAL_DSN_INFO
3755 , sx.smtp_greeting, sx.helo_response
3761 /* End off tidily with QUIT unless the connection has died or the socket has
3762 been passed to another process. There has been discussion on the net about what
3763 to do after sending QUIT. The wording of the RFC suggests that it is necessary
3764 to wait for a response, but on the other hand, there isn't anything one can do
3765 with an error response, other than log it. Exim used to do that. However,
3766 further discussion suggested that it is positively advantageous not to wait for
3767 the response, but to close the session immediately. This is supposed to move
3768 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
3769 load from the server. (Hosts that are both servers and clients may not see much
3770 difference, of course.) Further discussion indicated that this was safe to do
3771 on Unix systems which have decent implementations of TCP/IP that leave the
3772 connection around for a while (TIME_WAIT) after the application has gone away.
3773 This enables the response sent by the server to be properly ACKed rather than
3774 timed out, as can happen on broken TCP/IP implementations on other OS.
3776 This change is being made on 31-Jul-98. After over a year of trouble-free
3777 operation, the old commented-out code was removed on 17-Sep-99. */
3780 if (sx.send_quit) (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
3785 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
3786 sx.cctx.tls_ctx = NULL;
3789 /* Close the socket, and return the appropriate value, first setting
3790 works because the NULL setting is passed back to the calling process, and
3791 remote_max_parallel is forced to 1 when delivering over an existing connection,
3793 If all went well and continue_more is set, we shouldn't actually get here if
3794 there are further addresses, as the return above will be taken. However,
3795 writing RSET might have failed, or there may be other addresses whose hosts are
3796 specified in the transports, and therefore not visible at top level, in which
3797 case continue_more won't get set. */
3799 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
3802 shutdown(sx.cctx.sock, SHUT_WR);
3803 if (fcntl(sx.cctx.sock, F_SETFL, O_NONBLOCK) == 0)
3804 for (rc = 16; read(sx.cctx.sock, sx.inbuffer, sizeof(sx.inbuffer)) > 0 && rc > 0;)
3805 rc--; /* drain socket */
3807 (void)close(sx.cctx.sock);
3809 #ifndef DISABLE_EVENT
3810 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
3813 continue_transport = NULL;
3814 continue_hostname = NULL;
3821 /*************************************************
3822 * Closedown entry point *
3823 *************************************************/
3825 /* This function is called when exim is passed an open smtp channel
3826 from another incarnation, but the message which it has been asked
3827 to deliver no longer exists. The channel is on stdin.
3829 We might do fancy things like looking for another message to send down
3830 the channel, but if the one we sought has gone, it has probably been
3831 delivered by some other process that itself will seek further messages,
3832 so just close down our connection.
3834 Argument: pointer to the transport instance block
3839 smtp_transport_closedown(transport_instance *tblock)
3841 smtp_transport_options_block *ob =
3842 (smtp_transport_options_block *)tblock->options_block;
3843 client_conn_ctx cctx;
3846 uschar inbuffer[4096];
3847 uschar outbuffer[16];
3849 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
3850 cctx.sock = fileno(stdin);
3851 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
3853 sx.inblock.cctx = &cctx;
3854 sx.inblock.buffer = inbuffer;
3855 sx.inblock.buffersize = sizeof(inbuffer);
3856 sx.inblock.ptr = inbuffer;
3857 sx.inblock.ptrend = inbuffer;
3859 sx.outblock.cctx = &cctx;
3860 sx.outblock.buffersize = sizeof(outbuffer);
3861 sx.outblock.buffer = outbuffer;
3862 sx.outblock.ptr = outbuffer;
3863 sx.outblock.cmd_count = 0;
3864 sx.outblock.authenticating = FALSE;
3866 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
3867 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
3868 (void)close(cctx.sock);
3873 /*************************************************
3874 * Prepare addresses for delivery *
3875 *************************************************/
3877 /* This function is called to flush out error settings from previous delivery
3878 attempts to other hosts. It also records whether we got here via an MX record
3879 or not in the more_errno field of the address. We are interested only in
3880 addresses that are still marked DEFER - others may have got delivered to a
3881 previously considered IP address. Set their status to PENDING_DEFER to indicate
3882 which ones are relevant this time.
3885 addrlist the list of addresses
3886 host the host we are delivering to
3888 Returns: the first address for this delivery
3891 static address_item *
3892 prepare_addresses(address_item *addrlist, host_item *host)
3894 address_item *first_addr = NULL;
3896 for (addr = addrlist; addr; addr = addr->next)
3897 if (addr->transport_return == DEFER)
3899 if (!first_addr) first_addr = addr;
3900 addr->transport_return = PENDING_DEFER;
3901 addr->basic_errno = 0;
3902 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
3903 addr->message = NULL;
3905 addr->cipher = NULL;
3906 addr->ourcert = NULL;
3907 addr->peercert = NULL;
3908 addr->peerdn = NULL;
3909 addr->ocsp = OCSP_NOT_REQ;
3911 #ifdef EXPERIMENTAL_DSN_INFO
3912 addr->smtp_greeting = NULL;
3913 addr->helo_response = NULL;
3921 /*************************************************
3922 * Main entry point *
3923 *************************************************/
3925 /* See local README for interface details. As this is a remote transport, it is
3926 given a chain of addresses to be delivered in one connection, if possible. It
3927 always returns TRUE, indicating that each address has its own independent
3928 status set, except if there is a setting up problem, in which case it returns
3932 smtp_transport_entry(
3933 transport_instance *tblock, /* data for this instantiation */
3934 address_item *addrlist) /* addresses we are working on */
3938 int hosts_defer = 0;
3940 int hosts_looked_up = 0;
3941 int hosts_retry = 0;
3942 int hosts_serial = 0;
3943 int hosts_total = 0;
3944 int total_hosts_tried = 0;
3946 BOOL expired = TRUE;
3947 uschar *expanded_hosts = NULL;
3949 uschar *tid = string_sprintf("%s transport", tblock->name);
3950 smtp_transport_options_block *ob =
3951 (smtp_transport_options_block *)(tblock->options_block);
3952 host_item *hostlist = addrlist->host_list;
3957 debug_printf("%s transport entered\n", tblock->name);
3958 for (addr = addrlist; addr; addr = addr->next)
3959 debug_printf(" %s\n", addr->address);
3962 debug_printf("hostlist:\n");
3963 for (host = hostlist; host; host = host->next)
3964 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
3966 if (continue_hostname)
3967 debug_printf("already connected to %s [%s] (on fd %d)\n",
3968 continue_hostname, continue_host_address,
3969 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
3972 /* Set the flag requesting that these hosts be added to the waiting
3973 database if the delivery fails temporarily or if we are running with
3974 queue_smtp or a 2-stage queue run. This gets unset for certain
3975 kinds of error, typically those that are specific to the message. */
3977 update_waiting = TRUE;
3979 /* If a host list is not defined for the addresses - they must all have the
3980 same one in order to be passed to a single transport - or if the transport has
3981 a host list with hosts_override set, use the host list supplied with the
3982 transport. It is an error for this not to exist. */
3984 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3985 if (tls_requiretls & REQUIRETLS_MSG)
3986 ob->tls_tempfail_tryclear = FALSE; /*XXX surely we should have a local for this
3987 rather than modifying the transport? */
3990 if (!hostlist || (ob->hosts_override && ob->hosts))
3994 addrlist->message = string_sprintf("%s transport called with no hosts set",
3996 addrlist->transport_return = PANIC;
3997 return FALSE; /* Only top address has status */
4000 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4003 /* If the transport's host list contains no '$' characters, and we are not
4004 randomizing, it is fixed and therefore a chain of hosts can be built once
4005 and for all, and remembered for subsequent use by other calls to this
4006 transport. If, on the other hand, the host list does contain '$', or we are
4007 randomizing its order, we have to rebuild it each time. In the fixed case,
4008 as the hosts string will never be used again, it doesn't matter that we
4009 replace all the : characters with zeros. */
4013 uschar *s = ob->hosts;
4015 if (Ustrchr(s, '$') != NULL)
4017 if (!(expanded_hosts = expand_string(s)))
4019 addrlist->message = string_sprintf("failed to expand list of hosts "
4020 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4021 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4022 return FALSE; /* Only top address has status */
4024 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4025 "\"%s\"\n", s, expanded_hosts);
4029 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4031 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4033 /* Check that the expansion yielded something useful. */
4037 string_sprintf("%s transport has empty hosts setting", tblock->name);
4038 addrlist->transport_return = PANIC;
4039 return FALSE; /* Only top address has status */
4042 /* If there was no expansion of hosts, save the host list for
4045 if (!expanded_hosts) ob->hostlist = hostlist;
4048 /* This is not the first time this transport has been run in this delivery;
4049 the host list was built previously. */
4052 hostlist = ob->hostlist;
4055 /* The host list was supplied with the address. If hosts_randomize is set, we
4056 must sort it into a random order if it did not come from MX records and has not
4057 already been randomized (but don't bother if continuing down an existing
4060 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4062 host_item *newlist = NULL;
4065 host_item *h = hostlist;
4066 hostlist = hostlist->next;
4068 h->sort_key = random_number(100);
4075 else if (h->sort_key < newlist->sort_key)
4082 host_item *hh = newlist;
4085 if (h->sort_key < hh->next->sort_key) break;
4093 hostlist = addrlist->host_list = newlist;
4096 /* Sort out the default port. */
4098 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4100 /* For each host-plus-IP-address on the list:
4102 . If this is a continued delivery and the host isn't the one with the
4103 current connection, skip.
4105 . If the status is unusable (i.e. previously failed or retry checked), skip.
4107 . If no IP address set, get the address, either by turning the name into
4108 an address, calling gethostbyname if gethostbyname is on, or by calling
4109 the DNS. The DNS may yield multiple addresses, in which case insert the
4110 extra ones into the list.
4112 . Get the retry data if not previously obtained for this address and set the
4113 field which remembers the state of this address. Skip if the retry time is
4114 not reached. If not, remember whether retry data was found. The retry string
4115 contains both the name and the IP address.
4117 . Scan the list of addresses and mark those whose status is DEFER as
4118 PENDING_DEFER. These are the only ones that will be processed in this cycle
4121 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4122 Some addresses may be successfully delivered, others may fail, and yet
4123 others may get temporary errors and so get marked DEFER.
4125 . The return from the delivery attempt is OK if a connection was made and a
4126 valid SMTP dialogue was completed. Otherwise it is DEFER.
4128 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4130 . If fail to connect, or other defer state, add a retry item.
4132 . If there are any addresses whose status is still DEFER, carry on to the
4133 next host/IPaddress, unless we have tried the number of hosts given
4134 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4135 there is some fancy logic for hosts_max_try that means its limit can be
4136 overstepped in some circumstances.
4138 If we get to the end of the list, all hosts have deferred at least one address,
4139 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4140 delivery attempt to those hosts whose last try was before the arrival time of
4141 the current message. To cope with this, we have to go round the loop a second
4142 time. After that, set the status and error data for any addresses that haven't
4143 had it set already. */
4145 for (cutoff_retry = 0;
4146 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4149 host_item *nexthost = NULL;
4150 int unexpired_hosts_tried = 0;
4151 BOOL continue_host_tried = FALSE;
4153 retry_non_continued:
4154 for (host = hostlist;
4156 && unexpired_hosts_tried < ob->hosts_max_try
4157 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4163 BOOL host_is_expired = FALSE;
4164 BOOL message_defer = FALSE;
4165 BOOL some_deferred = FALSE;
4166 address_item *first_addr = NULL;
4167 uschar *interface = NULL;
4168 uschar *retry_host_key = NULL;
4169 uschar *retry_message_key = NULL;
4170 uschar *serialize_key = NULL;
4172 /* Default next host is next host. :-) But this can vary if the
4173 hosts_max_try limit is hit (see below). It may also be reset if a host
4174 address is looked up here (in case the host was multihomed). */
4176 nexthost = host->next;
4178 /* If the address hasn't yet been obtained from the host name, look it up
4179 now, unless the host is already marked as unusable. If it is marked as
4180 unusable, it means that the router was unable to find its IP address (in
4181 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4182 the lookup failed last time. We don't get this far if *all* MX records
4183 point to non-existent hosts; that is treated as a hard error.
4185 We can just skip this host entirely. When the hosts came from the router,
4186 the address will timeout based on the other host(s); when the address is
4187 looked up below, there is an explicit retry record added.
4189 Note that we mustn't skip unusable hosts if the address is not unset; they
4190 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4194 int new_port, flags;
4197 if (host->status >= hstatus_unusable)
4199 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4204 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4206 /* The host name is permitted to have an attached port. Find it, and
4207 strip it from the name. Just remember it for now. */
4209 new_port = host_item_get_port(host);
4211 /* Count hosts looked up */
4215 /* Find by name if so configured, or if it's an IP address. We don't
4216 just copy the IP address, because we need the test-for-local to happen. */
4218 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4219 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4220 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4222 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4223 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4225 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4226 &ob->dnssec, /* domains for request/require */
4229 /* Update the host (and any additional blocks, resulting from
4230 multihoming) with a host-specific port, if any. */
4232 for (hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4234 /* Failure to find the host at this time (usually DNS temporary failure)
4235 is really a kind of routing failure rather than a transport failure.
4236 Therefore we add a retry item of the routing kind, not to stop us trying
4237 to look this name up here again, but to ensure the address gets timed
4238 out if the failures go on long enough. A complete failure at this point
4239 commonly points to a configuration error, but the best action is still
4240 to carry on for the next host. */
4242 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4244 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4246 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4247 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4248 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4249 host->status = hstatus_unusable;
4251 for (addr = addrlist; addr; addr = addr->next)
4253 if (addr->transport_return != DEFER) continue;
4254 addr->basic_errno = ERRNO_UNKNOWNHOST;
4255 addr->message = string_sprintf(
4256 rc == HOST_FIND_SECURITY
4257 ? "lookup of IP address for %s was insecure"
4258 : "failed to lookup IP address for %s",
4264 /* If the host is actually the local host, we may have a problem, or
4265 there may be some cunning configuration going on. In the problem case,
4266 log things and give up. The default transport status is already DEFER. */
4268 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4270 for (addr = addrlist; addr; addr = addr->next)
4272 addr->basic_errno = 0;
4273 addr->message = string_sprintf("%s transport found host %s to be "
4274 "local", tblock->name, host->name);
4278 } /* End of block for IP address lookup */
4280 /* If this is a continued delivery, we are interested only in the host
4281 which matches the name of the existing open channel. The check is put
4282 here after the local host lookup, in case the name gets expanded as a
4283 result of the lookup. Set expired FALSE, to save the outer loop executing
4286 if (continue_hostname)
4287 if ( Ustrcmp(continue_hostname, host->name) != 0
4288 || Ustrcmp(continue_host_address, host->address) != 0
4292 continue; /* With next host */
4295 continue_host_tried = TRUE;
4297 /* Reset the default next host in case a multihomed host whose addresses
4298 are not looked up till just above added to the host list. */
4300 nexthost = host->next;
4302 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4303 domain is in queue_smtp_domains, we don't actually want to attempt any
4304 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4305 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4306 were not in it. We don't want to hold up all SMTP deliveries! Except when
4307 doing a two-stage queue run, don't do this if forcing. */
4309 if ((!f.deliver_force || f.queue_2stage) && (f.queue_smtp ||
4310 match_isinlist(addrlist->domain,
4311 (const uschar **)&queue_smtp_domains, 0,
4312 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
4315 for (addr = addrlist; addr; addr = addr->next)
4316 if (addr->transport_return == DEFER)
4317 addr->message = US"domain matches queue_smtp_domains, or -odqs set";
4318 continue; /* With next host */
4321 /* Count hosts being considered - purely for an intelligent comment
4322 if none are usable. */
4326 /* Set $host and $host address now in case they are needed for the
4327 interface expansion or the serialize_hosts check; they remain set if an
4328 actual delivery happens. */
4330 deliver_host = host->name;
4331 deliver_host_address = host->address;
4332 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
4333 : host->dnssec == DS_NO ? US"no"
4336 /* Set up a string for adding to the retry key if the port number is not
4337 the standard SMTP port. A host may have its own port setting that overrides
4340 pistring = string_sprintf(":%d", host->port == PORT_NONE
4341 ? defport : host->port);
4342 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
4344 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4345 string is set, even if constant (as different transports can have different
4346 constant settings), we must add it to the key that is used for retries,
4347 because connections to the same host from a different interface should be
4348 treated separately. */
4350 host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
4351 if ((rs = ob->interface) && *rs)
4353 if (!smtp_get_interface(rs, host_af, addrlist, &interface, tid))
4355 pistring = string_sprintf("%s/%s", pistring, interface);
4358 /* The first time round the outer loop, check the status of the host by
4359 inspecting the retry data. The second time round, we are interested only
4360 in expired hosts that haven't been tried since this message arrived. */
4362 if (cutoff_retry == 0)
4365 /* Ensure the status of the address is set by checking retry data if
4366 necessary. There may be host-specific retry data (applicable to all
4367 messages) and also data for retries of a specific message at this host.
4368 If either of these retry records are actually read, the keys used are
4369 returned to save recomputing them later. */
4371 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4372 US"retry_include_ip_address", ob->retry_include_ip_address,
4373 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4374 continue; /* with next host */
4376 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
4377 incl_ip, &retry_host_key, &retry_message_key);
4379 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
4380 (host->address == NULL)? US"" : host->address, pistring,
4381 (host->status == hstatus_usable)? "usable" :
4382 (host->status == hstatus_unusable)? "unusable" :
4383 (host->status == hstatus_unusable_expired)? "unusable (expired)" : "?");
4385 /* Skip this address if not usable at this time, noting if it wasn't
4386 actually expired, both locally and in the address. */
4388 switch (host->status)
4390 case hstatus_unusable:
4392 setflag(addrlist, af_retry_skipped);
4395 case hstatus_unusable_expired:
4398 case hwhy_retry: hosts_retry++; break;
4399 case hwhy_failed: hosts_fail++; break;
4401 case hwhy_deferred: hosts_defer++; break;
4404 /* If there was a retry message key, implying that previously there
4405 was a message-specific defer, we don't want to update the list of
4406 messages waiting for these hosts. */
4408 if (retry_message_key) update_waiting = FALSE;
4409 continue; /* With the next host or IP address */
4413 /* Second time round the loop: if the address is set but expired, and
4414 the message is newer than the last try, let it through. */
4419 || host->status != hstatus_unusable_expired
4420 || host->last_try > received_time.tv_sec)
4422 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
4423 host->name, host->address, pistring);
4424 host_is_expired = TRUE;
4427 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
4428 it remains TRUE only if all hosts are expired and none are actually tried.
4433 /* If this host is listed as one to which access must be serialized,
4434 see if another Exim process has a connection to it, and if so, skip
4435 this host. If not, update the database to record our connection to it
4436 and remember this for later deletion. Do not do any of this if we are
4437 sending the message down a pre-existing connection. */
4439 if ( !continue_hostname
4440 && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
4442 serialize_key = string_sprintf("host-serialize-%s", host->name);
4443 if (!enq_start(serialize_key, 1))
4446 debug_printf("skipping host %s because another Exim process "
4447 "is connected to it\n", host->name);
4453 /* OK, we have an IP address that is not waiting for its retry time to
4454 arrive (it might be expired) OR (second time round the loop) we have an
4455 expired host that hasn't been tried since the message arrived. Have a go
4456 at delivering the message to it. First prepare the addresses by flushing
4457 out the result of previous attempts, and finding the first address that
4458 is still to be delivered. */
4460 first_addr = prepare_addresses(addrlist, host);
4462 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
4463 message_id, host->name, host->address, addrlist->address,
4464 addrlist->next ? ", ..." : "");
4466 set_process_info("delivering %s to %s [%s] (%s%s)",
4467 message_id, host->name, host->address, addrlist->address,
4468 addrlist->next ? ", ..." : "");
4470 /* This is not for real; don't do the delivery. If there are
4471 any remaining hosts, list them. */
4476 set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
4477 for (addr = addrlist; addr; addr = addr->next)
4479 addr->host_used = host;
4480 addr->special_action = '*';
4481 addr->message = US"delivery bypassed by -N option";
4485 debug_printf("*** delivery by %s transport bypassed by -N option\n"
4486 "*** host and remaining hosts:\n", tblock->name);
4487 for (host2 = host; host2; host2 = host2->next)
4488 debug_printf(" %s [%s]\n", host2->name,
4489 host2->address ? host2->address : US"unset");
4494 /* This is for real. If the host is expired, we don't count it for
4495 hosts_max_retry. This ensures that all hosts must expire before an address
4496 is timed out, unless hosts_max_try_hardlimit (which protects against
4497 lunatic DNS configurations) is reached.
4499 If the host is not expired and we are about to hit the hosts_max_retry
4500 limit, check to see if there is a subsequent hosts with a different MX
4501 value. If so, make that the next host, and don't count this one. This is a
4502 heuristic to make sure that different MXs do get tried. With a normal kind
4503 of retry rule, they would get tried anyway when the earlier hosts were
4504 delayed, but if the domain has a "retry every time" type of rule - as is
4505 often used for the the very large ISPs, that won't happen. */
4510 /* Make a copy of the host if it is local to this invocation
4511 of the transport. */
4515 thost = store_get(sizeof(host_item));
4517 thost->name = string_copy(host->name);
4518 thost->address = string_copy(host->address);
4523 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
4527 debug_printf("hosts_max_try limit reached with this host\n");
4528 for (h = host; h; h = h->next) if (h->mx != host->mx)
4531 unexpired_hosts_tried--;
4532 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
4533 "and will be tried\n");
4538 /* Attempt the delivery. */
4540 total_hosts_tried++;
4541 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
4542 &message_defer, FALSE);
4545 OK => connection made, each address contains its result;
4546 message_defer is set for message-specific defers (when all
4547 recipients are marked defer)
4548 DEFER => there was a non-message-specific delivery problem;
4549 ERROR => there was a problem setting up the arguments for a filter,
4550 or there was a problem with expanding added headers
4553 /* If the result is not OK, there was a non-message-specific problem.
4554 If the result is DEFER, we need to write to the logs saying what happened
4555 for this particular host, except in the case of authentication and TLS
4556 failures, where the log has already been written. If all hosts defer a
4557 general message is written at the end. */
4559 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
4560 && first_addr->basic_errno != ERRNO_TLSFAILURE)
4561 write_logs(host, first_addr->message, first_addr->basic_errno);
4563 #ifndef DISABLE_EVENT
4565 deferred_event_raise(first_addr, host);
4568 /* If STARTTLS was accepted, but there was a failure in setting up the
4569 TLS session (usually a certificate screwup), and the host is not in
4570 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
4571 TLS forcibly turned off. We have to start from scratch with a new SMTP
4572 connection. That's why the retry is done from here, not from within
4573 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
4574 session, so the in-clear transmission after those errors, if permitted,
4575 happens inside smtp_deliver().] */
4579 && first_addr->basic_errno == ERRNO_TLSFAILURE
4580 && ob->tls_tempfail_tryclear
4581 && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
4584 log_write(0, LOG_MAIN,
4585 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
4586 first_addr->message, host->name, host->address);
4587 first_addr = prepare_addresses(addrlist, host);
4588 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
4589 &message_defer, TRUE);
4590 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
4591 write_logs(host, first_addr->message, first_addr->basic_errno);
4592 # ifndef DISABLE_EVENT
4594 deferred_event_raise(first_addr, host);
4597 #endif /*SUPPORT_TLS*/
4600 /* Delivery attempt finished */
4602 rs = rc == OK ? US"OK"
4603 : rc == DEFER ? US"DEFER"
4604 : rc == ERROR ? US"ERROR"
4607 set_process_info("delivering %s: just tried %s [%s] for %s%s: result %s",
4608 message_id, host->name, host->address, addrlist->address,
4609 addrlist->next ? " (& others)" : "", rs);
4611 /* Release serialization if set up */
4613 if (serialize_key) enq_end(serialize_key);
4615 /* If the result is DEFER, or if a host retry record is known to exist, we
4616 need to add an item to the retry chain for updating the retry database
4617 at the end of delivery. We only need to add the item to the top address,
4618 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
4619 for any other delivery attempts using the same address. (It is copied into
4620 the unusable tree at the outer level, so even if different address blocks
4621 contain the same address, it still won't get tried again.) */
4623 if (rc == DEFER || retry_host_key)
4625 int delete_flag = rc != DEFER ? rf_delete : 0;
4626 if (!retry_host_key)
4629 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4630 US"retry_include_ip_address", ob->retry_include_ip_address,
4631 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4632 incl_ip = TRUE; /* error; use most-specific retry record */
4634 retry_host_key = incl_ip
4635 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
4636 : string_sprintf("T:%S%s", host->name, pistring);
4639 /* If a delivery of another message over an existing SMTP connection
4640 yields DEFER, we do NOT set up retry data for the host. This covers the
4641 case when there are delays in routing the addresses in the second message
4642 that are so long that the server times out. This is alleviated by not
4643 routing addresses that previously had routing defers when handling an
4644 existing connection, but even so, this case may occur (e.g. if a
4645 previously happily routed address starts giving routing defers). If the
4646 host is genuinely down, another non-continued message delivery will
4647 notice it soon enough. */
4649 if (delete_flag != 0 || !continue_hostname)
4650 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
4652 /* We may have tried an expired host, if its retry time has come; ensure
4653 the status reflects the expiry for the benefit of any other addresses. */
4657 host->status = host_is_expired
4658 ? hstatus_unusable_expired : hstatus_unusable;
4659 host->why = hwhy_deferred;
4663 /* If message_defer is set (host was OK, but every recipient got deferred
4664 because of some message-specific problem), or if that had happened
4665 previously so that a message retry key exists, add an appropriate item
4666 to the retry chain. Note that if there was a message defer but now there is
4667 a host defer, the message defer record gets deleted. That seems perfectly
4668 reasonable. Also, stop the message from being remembered as waiting
4669 for specific hosts. */
4671 if (message_defer || retry_message_key)
4673 int delete_flag = message_defer ? 0 : rf_delete;
4674 if (!retry_message_key)
4677 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4678 US"retry_include_ip_address", ob->retry_include_ip_address,
4679 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4680 incl_ip = TRUE; /* error; use most-specific retry record */
4682 retry_message_key = incl_ip
4683 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
4685 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
4687 retry_add_item(addrlist, retry_message_key,
4688 rf_message | rf_host | delete_flag);
4689 update_waiting = FALSE;
4692 /* Any return other than DEFER (that is, OK or ERROR) means that the
4693 addresses have got their final statuses filled in for this host. In the OK
4694 case, see if any of them are deferred. */
4697 for (addr = addrlist; addr; addr = addr->next)
4698 if (addr->transport_return == DEFER)
4700 some_deferred = TRUE;
4704 /* If no addresses deferred or the result was ERROR, return. We do this for
4705 ERROR because a failing filter set-up or add_headers expansion is likely to
4706 fail for any host we try. */
4708 if (rc == ERROR || (rc == OK && !some_deferred))
4710 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
4711 return TRUE; /* Each address has its status */
4714 /* If the result was DEFER or some individual addresses deferred, let
4715 the loop run to try other hosts with the deferred addresses, except for the
4716 case when we were trying to deliver down an existing channel and failed.
4717 Don't try any other hosts in this case. */
4719 if (continue_hostname) break;
4721 /* If the whole delivery, or some individual addresses, were deferred and
4722 there are more hosts that could be tried, do not count this host towards
4723 the hosts_max_try limit if the age of the message is greater than the
4724 maximum retry time for this host. This means we may try try all hosts,
4725 ignoring the limit, when messages have been around for some time. This is
4726 important because if we don't try all hosts, the address will never time
4727 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
4729 if ((rc == DEFER || some_deferred) && nexthost)
4732 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
4734 if (retry && retry->rules)
4736 retry_rule *last_rule;
4737 for (last_rule = retry->rules;
4739 last_rule = last_rule->next);
4740 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
4742 else timedout = TRUE; /* No rule => timed out */
4746 unexpired_hosts_tried--;
4747 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
4748 "hosts_max_try (message older than host's retry time)\n");
4751 if (f.running_in_test_harness) millisleep(500); /* let server debug out */
4752 } /* End of loop for trying multiple hosts. */
4754 /* If we failed to find a matching host in the list, for an already-open
4755 connection, just close it and start over with the list. This can happen
4756 for routing that changes from run to run, or big multi-IP sites with
4759 if (continue_hostname && !continue_host_tried)
4761 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
4763 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
4765 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
4767 /*XXX doublecheck that! */
4769 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
4771 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
4772 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4773 cutthrough.cctx.tls_ctx = NULL;
4774 cutthrough.is_tls = FALSE;
4778 (void) write(fd, US"QUIT\r\n", 6);
4781 cutthrough.cctx.sock = -1;
4782 continue_hostname = NULL;
4783 goto retry_non_continued;
4786 /* This is the end of the loop that repeats iff expired is TRUE and
4787 ob->delay_after_cutoff is FALSE. The second time round we will
4788 try those hosts that haven't been tried since the message arrived. */
4792 debug_printf("all IP addresses skipped or deferred at least one address\n");
4793 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
4794 debug_printf("retrying IP addresses not tried since message arrived\n");
4799 /* Get here if all IP addresses are skipped or defer at least one address. In
4800 MUA wrapper mode, this will happen only for connection or other non-message-
4801 specific failures. Force the delivery status for all addresses to FAIL. */
4805 for (addr = addrlist; addr; addr = addr->next)
4806 addr->transport_return = FAIL;
4810 /* In the normal, non-wrapper case, add a standard message to each deferred
4811 address if there hasn't been an error, that is, if it hasn't actually been
4812 tried this time. The variable "expired" will be FALSE if any deliveries were
4813 actually tried, or if there was at least one host that was not expired. That
4814 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
4815 a delivery has been tried, an error code will be set, and the failing of the
4816 message is handled by the retry code later.
4818 If queue_smtp is set, or this transport was called to send a subsequent message
4819 down an existing TCP/IP connection, and something caused the host not to be
4820 found, we end up here, but can detect these cases and handle them specially. */
4822 for (addr = addrlist; addr; addr = addr->next)
4824 /* If host is not NULL, it means that we stopped processing the host list
4825 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
4826 means we need to behave as if some hosts were skipped because their retry
4827 time had not come. Specifically, this prevents the address from timing out.
4828 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
4829 hosts were tried. */
4832 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
4835 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
4836 "hosts were tried\n");
4841 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
4842 setflag(addr, af_retry_skipped);
4845 if (f.queue_smtp) /* no deliveries attempted */
4847 addr->transport_return = DEFER;
4848 addr->basic_errno = 0;
4849 addr->message = US"SMTP delivery explicitly queued";
4852 else if ( addr->transport_return == DEFER
4853 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
4857 addr->basic_errno = ERRNO_HRETRY;
4858 if (continue_hostname)
4859 addr->message = US"no host found for existing SMTP connection";
4862 setflag(addr, af_pass_message); /* This is not a security risk */
4863 addr->message = string_sprintf(
4864 "all hosts%s have been failing for a long time %s",
4865 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
4866 ob->delay_after_cutoff
4867 ? US"(and retry time not reached)"
4868 : US"and were last tried after this message arrived");
4870 /* If we are already using fallback hosts, or there are no fallback hosts
4871 defined, convert the result to FAIL to cause a bounce. */
4873 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
4874 addr->transport_return = FAIL;
4879 if (hosts_retry == hosts_total)
4880 s = "retry time not reached for any host%s";
4881 else if (hosts_fail == hosts_total)
4882 s = "all host address lookups%s failed permanently";
4883 else if (hosts_defer == hosts_total)
4884 s = "all host address lookups%s failed temporarily";
4885 else if (hosts_serial == hosts_total)
4886 s = "connection limit reached for all hosts%s";
4887 else if (hosts_fail+hosts_defer == hosts_total)
4888 s = "all host address lookups%s failed";
4890 s = "some host address lookups failed and retry time "
4891 "not reached for other hosts or connection limit reached%s";
4893 addr->message = string_sprintf(s,
4894 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
4899 /* Update the database which keeps information about which messages are waiting
4900 for which hosts to become available. For some message-specific errors, the
4901 update_waiting flag is turned off because we don't want follow-on deliveries in
4902 those cases. If this transport instance is explicitly limited to one message
4903 per connection then follow-on deliveries are not possible and there's no need
4904 to create/update the per-transport wait-<transport_name> database. */
4906 if (update_waiting && tblock->connection_max_messages != 1)
4907 transport_update_waiting(hostlist, tblock->name);
4911 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
4913 return TRUE; /* Each address has its status */
4916 #endif /*!MACRO_PREDEF*/
4919 /* End of transport/smtp.c */