1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
12 #if defined(SUPPORT_DANE) && defined(DISABLE_TLS)
13 # error TLS is required for DANE
17 /* Options specific to the smtp transport. This transport also supports LMTP
18 over TCP/IP. The options must be in alphabetic order (note that "_" comes
19 before the lower case letters). Some live in the transport_instance block so as
20 to be publicly visible; these are flagged with opt_public. */
22 #define LOFF(field) OPT_OFF(smtp_transport_options_block, field)
24 optionlist smtp_transport_options[] = {
25 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
26 OPT_OFF(transport_instance, expand_multi_domain) },
27 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
28 LOFF(expand_retry_include_ip_address) },
30 { "address_retry_include_sender", opt_bool,
31 LOFF(address_retry_include_sender) },
32 { "allow_localhost", opt_bool, LOFF(allow_localhost) },
33 #ifdef EXPERIMENTAL_ARC
34 { "arc_sign", opt_stringptr, LOFF(arc_sign) },
36 { "authenticated_sender", opt_stringptr, LOFF(authenticated_sender) },
37 { "authenticated_sender_force", opt_bool, LOFF(authenticated_sender_force) },
38 { "command_timeout", opt_time, LOFF(command_timeout) },
39 { "connect_timeout", opt_time, LOFF(connect_timeout) },
40 { "connection_max_messages", opt_int | opt_public,
41 OPT_OFF(transport_instance, connection_max_messages) },
43 { "dane_require_tls_ciphers", opt_stringptr, LOFF(dane_require_tls_ciphers) },
45 { "data_timeout", opt_time, LOFF(data_timeout) },
46 { "delay_after_cutoff", opt_bool, LOFF(delay_after_cutoff) },
48 { "dkim_canon", opt_stringptr, LOFF(dkim.dkim_canon) },
49 { "dkim_domain", opt_stringptr, LOFF(dkim.dkim_domain) },
50 { "dkim_hash", opt_stringptr, LOFF(dkim.dkim_hash) },
51 { "dkim_identity", opt_stringptr, LOFF(dkim.dkim_identity) },
52 { "dkim_private_key", opt_stringptr, LOFF(dkim.dkim_private_key) },
53 { "dkim_selector", opt_stringptr, LOFF(dkim.dkim_selector) },
54 { "dkim_sign_headers", opt_stringptr, LOFF(dkim.dkim_sign_headers) },
55 { "dkim_strict", opt_stringptr, LOFF(dkim.dkim_strict) },
56 { "dkim_timestamps", opt_stringptr, LOFF(dkim.dkim_timestamps) },
58 { "dns_qualify_single", opt_bool, LOFF(dns_qualify_single) },
59 { "dns_search_parents", opt_bool, LOFF(dns_search_parents) },
60 { "dnssec_request_domains", opt_stringptr, LOFF(dnssec.request) },
61 { "dnssec_require_domains", opt_stringptr, LOFF(dnssec.require) },
62 { "dscp", opt_stringptr, LOFF(dscp) },
63 { "fallback_hosts", opt_stringptr, LOFF(fallback_hosts) },
64 { "final_timeout", opt_time, LOFF(final_timeout) },
65 { "gethostbyname", opt_bool, LOFF(gethostbyname) },
66 { "helo_data", opt_stringptr, LOFF(helo_data) },
67 { "hosts", opt_stringptr, LOFF(hosts) },
68 { "hosts_avoid_esmtp", opt_stringptr, LOFF(hosts_avoid_esmtp) },
69 { "hosts_avoid_pipelining", opt_stringptr, LOFF(hosts_avoid_pipelining) },
71 { "hosts_avoid_tls", opt_stringptr, LOFF(hosts_avoid_tls) },
73 { "hosts_max_try", opt_int, LOFF(hosts_max_try) },
74 { "hosts_max_try_hardlimit", opt_int, LOFF(hosts_max_try_hardlimit) },
76 { "hosts_nopass_tls", opt_stringptr, LOFF(hosts_nopass_tls) },
77 { "hosts_noproxy_tls", opt_stringptr, LOFF(hosts_noproxy_tls) },
79 { "hosts_override", opt_bool, LOFF(hosts_override) },
80 #ifndef DISABLE_PIPE_CONNECT
81 { "hosts_pipe_connect", opt_stringptr, LOFF(hosts_pipe_connect) },
83 { "hosts_randomize", opt_bool, LOFF(hosts_randomize) },
84 #if !defined(DISABLE_TLS) && !defined(DISABLE_OCSP)
85 { "hosts_request_ocsp", opt_stringptr, LOFF(hosts_request_ocsp) },
87 { "hosts_require_auth", opt_stringptr, LOFF(hosts_require_auth) },
90 { "hosts_require_dane", opt_stringptr, LOFF(hosts_require_dane) },
93 { "hosts_require_ocsp", opt_stringptr, LOFF(hosts_require_ocsp) },
95 { "hosts_require_tls", opt_stringptr, LOFF(hosts_require_tls) },
97 { "hosts_try_auth", opt_stringptr, LOFF(hosts_try_auth) },
98 { "hosts_try_chunking", opt_stringptr, LOFF(hosts_try_chunking) },
100 { "hosts_try_dane", opt_stringptr, LOFF(hosts_try_dane) },
102 { "hosts_try_fastopen", opt_stringptr, LOFF(hosts_try_fastopen) },
104 { "hosts_try_prdr", opt_stringptr, LOFF(hosts_try_prdr) },
107 { "hosts_verify_avoid_tls", opt_stringptr, LOFF(hosts_verify_avoid_tls) },
109 { "interface", opt_stringptr, LOFF(interface) },
110 { "keepalive", opt_bool, LOFF(keepalive) },
111 { "lmtp_ignore_quota", opt_bool, LOFF(lmtp_ignore_quota) },
112 { "max_rcpt", opt_int | opt_public,
113 OPT_OFF(transport_instance, max_addresses) },
114 { "message_linelength_limit", opt_int, LOFF(message_linelength_limit) },
115 { "multi_domain", opt_expand_bool | opt_public,
116 OPT_OFF(transport_instance, multi_domain) },
117 { "port", opt_stringptr, LOFF(port) },
118 { "protocol", opt_stringptr, LOFF(protocol) },
119 { "retry_include_ip_address", opt_expand_bool, LOFF(retry_include_ip_address) },
120 { "serialize_hosts", opt_stringptr, LOFF(serialize_hosts) },
121 { "size_addition", opt_int, LOFF(size_addition) },
123 { "socks_proxy", opt_stringptr, LOFF(socks_proxy) },
126 { "tls_certificate", opt_stringptr, LOFF(tls_certificate) },
127 { "tls_crl", opt_stringptr, LOFF(tls_crl) },
128 { "tls_dh_min_bits", opt_int, LOFF(tls_dh_min_bits) },
129 { "tls_privatekey", opt_stringptr, LOFF(tls_privatekey) },
130 { "tls_require_ciphers", opt_stringptr, LOFF(tls_require_ciphers) },
131 # ifndef DISABLE_TLS_RESUME
132 { "tls_resumption_hosts", opt_stringptr, LOFF(tls_resumption_hosts) },
134 { "tls_sni", opt_stringptr, LOFF(tls_sni) },
135 { "tls_tempfail_tryclear", opt_bool, LOFF(tls_tempfail_tryclear) },
136 { "tls_try_verify_hosts", opt_stringptr, LOFF(tls_try_verify_hosts) },
137 { "tls_verify_cert_hostnames", opt_stringptr, LOFF(tls_verify_cert_hostnames)},
138 { "tls_verify_certificates", opt_stringptr, LOFF(tls_verify_certificates) },
139 { "tls_verify_hosts", opt_stringptr, LOFF(tls_verify_hosts) },
142 { "utf8_downconvert", opt_stringptr, LOFF(utf8_downconvert) },
146 /* Size of the options list. An extern variable has to be used so that its
147 address can appear in the tables drtables.c. */
149 int smtp_transport_options_count = nelem(smtp_transport_options);
155 smtp_transport_options_block smtp_transport_option_defaults = {0};
156 void smtp_transport_init(transport_instance *tblock) {}
157 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
158 void smtp_transport_closedown(transport_instance *tblock) {}
160 #else /*!MACRO_PREDEF*/
163 /* Default private options block for the smtp transport. */
165 smtp_transport_options_block smtp_transport_option_defaults = {
166 /* All non-mentioned elements 0/NULL/FALSE */
167 .helo_data = US"$primary_hostname",
168 .protocol = US"smtp",
169 .hosts_try_chunking = US"*",
171 .hosts_try_dane = US"*",
173 .hosts_try_fastopen = US"*",
175 .hosts_try_prdr = US"*",
178 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
180 .command_timeout = 5*60,
181 .connect_timeout = 5*60,
182 .data_timeout = 5*60,
183 .final_timeout = 10*60,
184 .size_addition = 1024,
186 .hosts_max_try_hardlimit = 50,
187 .message_linelength_limit = 998,
188 .address_retry_include_sender = TRUE,
189 .dns_qualify_single = TRUE,
190 .dnssec = { .request= US"*", .require=NULL },
191 .delay_after_cutoff = TRUE,
193 .retry_include_ip_address = TRUE,
195 # if defined(SUPPORT_SYSDEFAULT_CABUNDLE) || !defined(USE_GNUTLS)
196 .tls_verify_certificates = US"system",
198 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
199 .tls_tempfail_tryclear = TRUE,
200 .tls_try_verify_hosts = US"*",
201 .tls_verify_cert_hostnames = US"*",
204 .utf8_downconvert = US"-1",
208 { .dkim_hash = US"sha256", },
212 /* some DSN flags for use later */
214 static int rf_list[] = {rf_notify_never, rf_notify_success,
215 rf_notify_failure, rf_notify_delay };
217 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
223 static uschar *smtp_command; /* Points to last cmd for error messages */
224 static uschar *mail_command; /* Points to MAIL cmd for error messages */
225 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
226 static BOOL update_waiting; /* TRUE to update the "wait" database */
228 /*XXX move to smtp_context */
229 static BOOL pipelining_active; /* current transaction is in pipe mode */
232 static unsigned ehlo_response(uschar * buf, unsigned checks);
235 /******************************************************************************/
238 smtp_deliver_init(void)
240 if (!regex_PIPELINING) regex_PIPELINING =
241 regex_must_compile(US"\\n250[\\s\\-]PIPELINING(\\s|\\n|$)", FALSE, TRUE);
243 if (!regex_SIZE) regex_SIZE =
244 regex_must_compile(US"\\n250[\\s\\-]SIZE(\\s|\\n|$)", FALSE, TRUE);
246 if (!regex_AUTH) regex_AUTH =
247 regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
250 if (!regex_STARTTLS) regex_STARTTLS =
251 regex_must_compile(US"\\n250[\\s\\-]STARTTLS(\\s|\\n|$)", FALSE, TRUE);
254 if (!regex_CHUNKING) regex_CHUNKING =
255 regex_must_compile(US"\\n250[\\s\\-]CHUNKING(\\s|\\n|$)", FALSE, TRUE);
258 if (!regex_PRDR) regex_PRDR =
259 regex_must_compile(US"\\n250[\\s\\-]PRDR(\\s|\\n|$)", FALSE, TRUE);
263 if (!regex_UTF8) regex_UTF8 =
264 regex_must_compile(US"\\n250[\\s\\-]SMTPUTF8(\\s|\\n|$)", FALSE, TRUE);
267 if (!regex_DSN) regex_DSN =
268 regex_must_compile(US"\\n250[\\s\\-]DSN(\\s|\\n|$)", FALSE, TRUE);
270 if (!regex_IGNOREQUOTA) regex_IGNOREQUOTA =
271 regex_must_compile(US"\\n250[\\s\\-]IGNOREQUOTA(\\s|\\n|$)", FALSE, TRUE);
273 #ifndef DISABLE_PIPE_CONNECT
274 if (!regex_EARLY_PIPE) regex_EARLY_PIPE =
275 regex_must_compile(US"\\n250[\\s\\-]" EARLY_PIPE_FEATURE_NAME "(\\s|\\n|$)", FALSE, TRUE);
280 /*************************************************
281 * Setup entry point *
282 *************************************************/
284 /* This function is called when the transport is about to be used,
285 but before running it in a sub-process. It is used for two things:
287 (1) To set the fallback host list in addresses, when delivering.
288 (2) To pass back the interface, port, protocol, and other options, for use
289 during callout verification.
292 tblock pointer to the transport instance block
293 addrlist list of addresses about to be transported
294 tf if not NULL, pointer to block in which to return options
295 uid the uid that will be set (not used)
296 gid the gid that will be set (not used)
297 errmsg place for error message (not used)
299 Returns: OK always (FAIL, DEFER not used)
303 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
304 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
306 smtp_transport_options_block *ob = SOB tblock->options_block;
308 /* Pass back options if required. This interface is getting very messy. */
312 tf->interface = ob->interface;
314 tf->protocol = ob->protocol;
315 tf->hosts = ob->hosts;
316 tf->hosts_override = ob->hosts_override;
317 tf->hosts_randomize = ob->hosts_randomize;
318 tf->gethostbyname = ob->gethostbyname;
319 tf->qualify_single = ob->dns_qualify_single;
320 tf->search_parents = ob->dns_search_parents;
321 tf->helo_data = ob->helo_data;
324 /* Set the fallback host list for all the addresses that don't have fallback
325 host lists, provided that the local host wasn't present in the original host
328 if (!testflag(addrlist, af_local_host_removed))
329 for (; addrlist; addrlist = addrlist->next)
330 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
337 /*************************************************
338 * Initialization entry point *
339 *************************************************/
341 /* Called for each instance, after its options have been read, to
342 enable consistency checks to be done, or anything else that needs
345 Argument: pointer to the transport instance block
350 smtp_transport_init(transport_instance *tblock)
352 smtp_transport_options_block *ob = SOB tblock->options_block;
354 /* Retry_use_local_part defaults FALSE if unset */
356 if (tblock->retry_use_local_part == TRUE_UNSET)
357 tblock->retry_use_local_part = FALSE;
359 /* Set the default port according to the protocol */
362 ob->port = strcmpic(ob->protocol, US"lmtp") == 0
364 : strcmpic(ob->protocol, US"smtps") == 0
365 ? US"smtps" : US"smtp";
367 /* Set up the setup entry point, to be called before subprocesses for this
370 tblock->setup = smtp_transport_setup;
372 /* Complain if any of the timeouts are zero. */
374 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
375 ob->final_timeout <= 0)
376 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
377 "command, data, or final timeout value is zero for %s transport",
380 /* If hosts_override is set and there are local hosts, set the global
381 flag that stops verify from showing router hosts. */
383 if (ob->hosts_override && ob->hosts) tblock->overrides_hosts = TRUE;
385 /* If there are any fallback hosts listed, build a chain of host items
386 for them, but do not do any lookups at this time. */
388 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
395 /*************************************************
396 * Set delivery info into all active addresses *
397 *************************************************/
399 /* Only addresses whose status is >= PENDING are relevant. A lesser
400 status means that an address is not currently being processed.
403 addrlist points to a chain of addresses
404 errno_value to put in each address's errno field
405 msg to put in each address's message field
406 rc to put in each address's transport_return field
407 pass_message if TRUE, set the "pass message" flag in the address
408 host if set, mark addrs as having used this host
409 smtp_greeting from peer
410 helo_response from peer
411 start points to timestamp of delivery start
413 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
414 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
415 this particular type of timeout.
421 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
422 BOOL pass_message, host_item * host,
423 #ifdef EXPERIMENTAL_DSN_INFO
424 const uschar * smtp_greeting, const uschar * helo_response,
426 struct timeval * start
430 struct timeval deliver_time;
432 if (errno_value == ERRNO_CONNECTTIMEOUT)
434 errno_value = ETIMEDOUT;
435 orvalue = RTEF_CTOUT;
437 timesince(&deliver_time, start);
439 for (address_item * addr = addrlist; addr; addr = addr->next)
440 if (addr->transport_return >= PENDING)
442 addr->basic_errno = errno_value;
443 addr->more_errno |= orvalue;
444 addr->delivery_time = deliver_time;
448 if (pass_message) setflag(addr, af_pass_message);
450 addr->transport_return = rc;
453 addr->host_used = host;
454 #ifdef EXPERIMENTAL_DSN_INFO
456 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
457 addr->smtp_greeting = smtp_greeting;
460 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
461 addr->helo_response = helo_response;
468 set_errno_nohost(address_item * addrlist, int errno_value, uschar * msg, int rc,
469 BOOL pass_message, struct timeval * start)
471 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL,
472 #ifdef EXPERIMENTAL_DSN_INFO
479 /*************************************************
480 * Check an SMTP response *
481 *************************************************/
483 /* This function is given an errno code and the SMTP response buffer
484 to analyse, together with the host identification for generating messages. It
485 sets an appropriate message and puts the first digit of the response code into
486 the yield variable. If no response was actually read, a suitable digit is
490 host the current host, to get its name for messages
491 errno_value pointer to the errno value
492 more_errno from the top address for use with ERRNO_FILTER_FAIL
493 buffer the SMTP response buffer
494 yield where to put a one-digit SMTP response code
495 message where to put an error message
496 pass_message set TRUE if message is an SMTP response
498 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
502 check_response(host_item *host, int *errno_value, int more_errno,
503 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
505 uschar * pl = pipelining_active ? US"pipelined " : US"";
508 *yield = '4'; /* Default setting is to give a temporary error */
512 case ETIMEDOUT: /* Handle response timeout */
513 *message = US string_sprintf("SMTP timeout after %s%s",
515 if (transport_count > 0)
516 *message = US string_sprintf("%s (%d bytes written)", *message,
520 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
521 s = string_printing(buffer);
522 while (isspace(*s)) s++;
524 ? string_sprintf("Malformed SMTP reply (an empty line) "
525 "in response to %s%s", pl, smtp_command)
526 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
527 pl, smtp_command, s);
530 case ERRNO_TLSFAILURE: /* Handle bad first read; can happen with
532 *message = US"bad first read from TLS conn";
535 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
536 can't send QUIT as we mustn't end the DATA. */
537 *message = string_sprintf("transport filter process failed (%d)%s",
539 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
542 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
543 can't send QUIT as we mustn't end the DATA. */
545 string_sprintf("failed to expand headers_add or headers_remove: %s",
546 expand_string_message);
549 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
550 *message = US"failed to write a data block";
554 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
555 *message = US"utf8 support required but not offered for forwarding";
556 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
561 /* Handle error responses from the remote mailer. */
565 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
566 "%s", pl, smtp_command, s = string_printing(buffer));
567 *pass_message = TRUE;
572 /* No data was read. If there is no errno, this must be the EOF (i.e.
573 connection closed) case, which causes deferral. An explicit connection reset
574 error has the same effect. Otherwise, put the host's identity in the message,
575 leaving the errno value to be interpreted as well. In all cases, we have to
576 assume the connection is now dead. */
578 if (*errno_value == 0 || *errno_value == ECONNRESET)
580 *errno_value = ERRNO_SMTPCLOSED;
581 *message = US string_sprintf("Remote host closed connection "
582 "in response to %s%s", pl, smtp_command);
585 *message = US string_sprintf("%s [%s]", host->name, host->address);
592 /*************************************************
593 * Write error message to logs *
594 *************************************************/
596 /* This writes to the main log and to the message log.
599 host the current host
600 detail the current message (addr_item->message)
601 basic_errno the errno (addr_item->basic_errno)
607 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
609 gstring * message = LOGGING(outgoing_port)
610 ? string_fmt_append(NULL, "H=%s [%s]:%d", host->name, host->address,
611 host->port == PORT_NONE ? 25 : host->port)
612 : string_fmt_append(NULL, "H=%s [%s]", host->name, host->address);
616 message = string_fmt_append(message, ": %s", suffix);
618 message = string_fmt_append(message, ": %s", strerror(basic_errno));
621 message = string_fmt_append(message, " %s", exim_errstr(basic_errno));
623 log_write(0, LOG_MAIN, "%s", string_from_gstring(message));
624 deliver_msglog("%s %s\n", tod_stamp(tod_log), message->s);
628 msglog_line(host_item * host, uschar * message)
630 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
631 host->name, host->address, message);
636 #ifndef DISABLE_EVENT
637 /*************************************************
638 * Post-defer action *
639 *************************************************/
641 /* This expands an arbitrary per-transport string.
642 It might, for example, be used to write to the database log.
645 addr the address item containing error information
646 host the current host
653 deferred_event_raise(address_item * addr, host_item * host, uschar * evstr)
655 uschar * action = addr->transport->event_action;
656 const uschar * save_domain;
662 save_domain = deliver_domain;
663 save_local = deliver_localpart;
665 /*XXX would ip & port already be set up? */
666 deliver_host_address = string_copy(host->address);
667 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
668 event_defer_errno = addr->basic_errno;
670 router_name = addr->router->name;
671 transport_name = addr->transport->name;
672 deliver_domain = addr->domain;
673 deliver_localpart = addr->local_part;
675 (void) event_raise(action, evstr,
677 ? addr->basic_errno > 0
678 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
679 : string_copy(addr->message)
680 : addr->basic_errno > 0
681 ? string_copy(US strerror(addr->basic_errno))
684 deliver_localpart = save_local;
685 deliver_domain = save_domain;
686 router_name = transport_name = NULL;
690 /*************************************************
691 * Reap SMTP specific responses *
692 *************************************************/
694 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
697 uschar flushbuffer[4096];
701 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
702 '2', ob->command_timeout)
703 && (errno != 0 || flushbuffer[0] == 0))
710 /* Return boolean success */
713 smtp_reap_banner(smtp_context * sx)
716 #if defined(__linux__) && defined(TCP_QUICKACK)
717 { /* Hack to get QUICKACK disabled; has to be right after 3whs, and has to on->off */
718 int sock = sx->cctx.sock;
719 struct pollfd p = {.fd = sock, .events = POLLOUT};
720 int rc = poll(&p, 1, 1000);
721 (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &on, sizeof(on));
722 (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
725 good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
726 '2', (SOB sx->conn_args.ob)->command_timeout);
727 #ifdef EXPERIMENTAL_DSN_INFO
728 sx->smtp_greeting = string_copy(sx->buffer);
730 return good_response;
734 smtp_reap_ehlo(smtp_context * sx)
736 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
737 (SOB sx->conn_args.ob)->command_timeout))
739 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
741 #ifdef EXPERIMENTAL_DSN_INFO
742 sx->helo_response = string_copy(sx->buffer);
748 #ifdef EXPERIMENTAL_DSN_INFO
749 sx->helo_response = string_copy(sx->buffer);
751 #ifndef DISABLE_EVENT
752 (void) event_raise(sx->conn_args.tblock->event_action,
753 US"smtp:ehlo", sx->buffer);
760 #ifndef DISABLE_PIPE_CONNECT
762 ehlo_cache_key(const smtp_context * sx)
764 host_item * host = sx->conn_args.host;
765 return Ustrchr(host->address, ':')
766 ? string_sprintf("[%s]:%d.EHLO", host->address,
767 host->port == PORT_NONE ? sx->port : host->port)
768 : string_sprintf("%s:%d.EHLO", host->address,
769 host->port == PORT_NONE ? sx->port : host->port);
773 write_ehlo_cache_entry(const smtp_context * sx)
775 open_db dbblock, * dbm_file;
777 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
779 uschar * ehlo_resp_key = ehlo_cache_key(sx);
780 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
782 HDEBUG(D_transport) debug_printf("writing clr %04x/%04x cry %04x/%04x\n",
783 sx->ehlo_resp.cleartext_features, sx->ehlo_resp.cleartext_auths,
784 sx->ehlo_resp.crypted_features, sx->ehlo_resp.crypted_auths);
786 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
787 dbfn_close(dbm_file);
792 invalidate_ehlo_cache_entry(smtp_context * sx)
794 open_db dbblock, * dbm_file;
796 if ( sx->early_pipe_active
797 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
799 uschar * ehlo_resp_key = ehlo_cache_key(sx);
800 dbfn_delete(dbm_file, ehlo_resp_key);
801 dbfn_close(dbm_file);
806 read_ehlo_cache_entry(smtp_context * sx)
811 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE, TRUE)))
812 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
815 uschar * ehlo_resp_key = ehlo_cache_key(sx);
816 dbdata_ehlo_resp * er;
818 if (!(er = dbfn_read_enforce_length(dbm_file, ehlo_resp_key, sizeof(dbdata_ehlo_resp))))
819 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
820 else if (time(NULL) - er->time_stamp > retry_data_expire)
822 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
823 dbfn_close(dbm_file);
824 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
825 dbfn_delete(dbm_file, ehlo_resp_key);
829 sx->ehlo_resp = er->data;
830 dbfn_close(dbm_file);
831 DEBUG(D_transport) debug_printf(
832 "EHLO response bits from cache: cleartext 0x%04x/0x%04x crypted 0x%04x/0x%04x\n",
833 er->data.cleartext_features, er->data.cleartext_auths,
834 er->data.crypted_features, er->data.crypted_auths);
837 dbfn_close(dbm_file);
844 /* Return an auths bitmap for the set of AUTH methods offered by the server
845 which match our authenticators. */
847 static unsigned short
848 study_ehlo_auths(smtp_context * sx)
853 unsigned short authbits = 0;
855 if (!sx->esmtp) return 0;
856 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
857 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
858 expand_nmax = -1; /* reset */
859 names = string_copyn(expand_nstring[1], expand_nlength[1]);
861 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
863 const uschar * list = names;
865 for (int sep = ' '; s = string_nextinlist(&list, &sep, NULL, 0); )
866 if (strcmpic(au->public_name, s) == 0)
867 { authbits |= BIT(authnum); break; }
871 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
872 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
874 if (tls_out.active.sock >= 0)
875 sx->ehlo_resp.crypted_auths = authbits;
877 sx->ehlo_resp.cleartext_auths = authbits;
884 /* Wait for and check responses for early-pipelining.
886 Called from the lower-level smtp_read_response() function
887 used for general code that assume synchronisation, if context
888 flags indicate outstanding early-pipelining commands. Also
889 called fom sync_responses() which handles pipelined commands.
892 sx smtp connection context
893 countp number of outstanding responses, adjusted on return
897 DEFER error on first read of TLS'd conn
898 FAIL SMTP error in response
901 smtp_reap_early_pipe(smtp_context * sx, int * countp)
903 BOOL pending_BANNER = sx->pending_BANNER;
904 BOOL pending_EHLO = sx->pending_EHLO;
907 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
908 sx->pending_EHLO = FALSE;
912 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
914 if (!smtp_reap_banner(sx))
916 DEBUG(D_transport) debug_printf("bad banner\n");
917 if (tls_out.active.sock >= 0) rc = DEFER;
924 unsigned peer_offered;
925 unsigned short authbits = 0, * ap;
927 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
929 if (!smtp_reap_ehlo(sx))
931 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
932 if (tls_out.active.sock >= 0) rc = DEFER;
936 /* Compare the actual EHLO response to the cached value we assumed;
937 on difference, dump or rewrite the cache and arrange for a retry. */
939 ap = tls_out.active.sock < 0
940 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
942 peer_offered = ehlo_response(sx->buffer,
943 (tls_out.active.sock < 0 ? OPTION_TLS : 0)
944 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
945 | OPTION_UTF8 | OPTION_EARLY_PIPE
947 if ( peer_offered != sx->peer_offered
948 || (authbits = study_ehlo_auths(sx)) != *ap)
951 debug_printf("EHLO %s extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
952 tls_out.active.sock < 0 ? "cleartext" : "crypted",
953 sx->peer_offered, *ap, peer_offered, authbits);
954 *(tls_out.active.sock < 0
955 ? &sx->ehlo_resp.cleartext_features : &sx->ehlo_resp.crypted_features) = peer_offered;
957 if (peer_offered & OPTION_EARLY_PIPE)
958 write_ehlo_cache_entry(sx);
960 invalidate_ehlo_cache_entry(sx);
962 return OK; /* just carry on */
968 invalidate_ehlo_cache_entry(sx);
969 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
972 #endif /*!DISABLE_PIPE_CONNECT*/
975 /*************************************************
976 * Synchronize SMTP responses *
977 *************************************************/
979 /* This function is called from smtp_deliver() to receive SMTP responses from
980 the server, and match them up with the commands to which they relate. When
981 PIPELINING is not in use, this function is called after every command, and is
982 therefore somewhat over-engineered, but it is simpler to use a single scheme
983 that works both with and without PIPELINING instead of having two separate sets
986 The set of commands that are buffered up with pipelining may start with MAIL
987 and may end with DATA; in between are RCPT commands that correspond to the
988 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
989 etc.) are never buffered.
991 Errors after MAIL or DATA abort the whole process leaving the response in the
992 buffer. After MAIL, pending responses are flushed, and the original command is
993 re-instated in big_buffer for error messages. For RCPT commands, the remote is
994 permitted to reject some recipient addresses while accepting others. However
995 certain errors clearly abort the whole process. Set the value in
996 transport_return to PENDING_OK if the address is accepted. If there is a
997 subsequent general error, it will get reset accordingly. If not, it will get
998 converted to OK at the end.
1001 sx smtp connection context
1002 count the number of responses to read
1003 pending_DATA 0 if last command sent was not DATA
1004 +1 if previously had a good recipient
1005 -1 if not previously had a good recipient
1007 Returns: 3 if at least one address had 2xx and one had 5xx
1008 2 if at least one address had 5xx but none had 2xx
1009 1 if at least one host had a 2xx response, but none had 5xx
1010 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1011 -1 timeout while reading RCPT response
1012 -2 I/O or other non-response error for RCPT
1013 -3 DATA or MAIL failed - errno and buffer set
1014 -4 banner or EHLO failed (early-pipelining)
1015 -5 banner or EHLO failed (early-pipelining, TLS)
1019 sync_responses(smtp_context * sx, int count, int pending_DATA)
1021 address_item * addr = sx->sync_addr;
1022 smtp_transport_options_block * ob = sx->conn_args.ob;
1025 #ifndef DISABLE_PIPE_CONNECT
1027 if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
1028 return rc == FAIL ? -4 : -5;
1031 /* Handle the response for a MAIL command. On error, reinstate the original
1032 command in big_buffer for error message use, and flush any further pending
1033 responses before returning, except after I/O errors and timeouts. */
1035 if (sx->pending_MAIL)
1037 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1039 sx->pending_MAIL = sx->RCPT_452 = FALSE;
1040 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1041 '2', ob->command_timeout))
1043 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1044 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1045 if (errno == ERRNO_TLSFAILURE)
1047 if (errno == 0 && sx->buffer[0] != 0)
1050 if (sx->buffer[0] == '4')
1052 save_errno = ERRNO_MAIL4XX;
1053 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1055 count = smtp_discard_responses(sx, ob, count);
1059 if (pending_DATA) count--; /* Number of RCPT responses to come */
1060 while (count-- > 0) /* Mark any pending addrs with the host used */
1062 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1063 addr->host_used = sx->conn_args.host;
1070 if (pending_DATA) count--; /* Number of RCPT responses to come */
1072 /* Read and handle the required number of RCPT responses, matching each one up
1073 with an address by scanning for the next address whose status is PENDING_DEFER.
1078 while (addr->transport_return != PENDING_DEFER)
1079 if (!(addr = addr->next))
1082 /* The address was accepted */
1083 addr->host_used = sx->conn_args.host;
1085 DEBUG(D_transport) debug_printf("%s expect rcpt for %s\n", __FUNCTION__, addr->address);
1086 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1087 '2', ob->command_timeout))
1090 addr->transport_return = PENDING_OK;
1092 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1093 ensure that any address-specific retry record is expunged. We do this both
1094 for the basic key and for the version that also includes the sender. */
1096 if (testflag(addr, af_dr_retry_exists))
1098 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1100 retry_add_item(addr, altkey, rf_delete);
1101 retry_add_item(addr, addr->address_retry_key, rf_delete);
1105 /* Error on first TLS read */
1107 else if (errno == ERRNO_TLSFAILURE)
1110 /* Timeout while reading the response */
1112 else if (errno == ETIMEDOUT)
1114 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1115 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1116 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE, &sx->delivery_start);
1117 retry_add_item(addr, addr->address_retry_key, 0);
1118 update_waiting = FALSE;
1122 /* Handle other errors in obtaining an SMTP response by returning -1. This
1123 will cause all the addresses to be deferred. Restore the SMTP command in
1124 big_buffer for which we are checking the response, so the error message
1127 else if (errno != 0 || sx->buffer[0] == 0)
1129 gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer }, * g = &gs;
1131 /* Use taint-unchecked routines for writing into big_buffer, trusting
1132 that we'll never expand it. */
1134 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "RCPT TO:<%s>",
1135 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1136 string_from_gstring(g);
1140 /* Handle SMTP permanent and temporary response codes. */
1145 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1146 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1147 string_printing(sx->buffer));
1148 setflag(addr, af_pass_message);
1150 msglog_line(sx->conn_args.host, addr->message);
1152 /* The response was 5xx */
1154 if (sx->buffer[0] == '5')
1156 addr->transport_return = FAIL;
1160 /* The response was 4xx */
1164 addr->transport_return = DEFER;
1165 addr->basic_errno = ERRNO_RCPT4XX;
1166 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1170 #ifndef DISABLE_EVENT
1171 event_defer_errno = addr->more_errno;
1172 msg_event_raise(US"msg:rcpt:host:defer", addr);
1174 /* If a 452 and we've had at least one 2xx or 5xx, set next_addr to the
1175 start point for another MAIL command. */
1177 if (addr->more_errno >> 8 == 52 && yield & 3)
1179 if (!sx->RCPT_452) /* initialised at MAIL-ack above */
1182 debug_printf("%s: seen first 452 too-many-rcpts\n", __FUNCTION__);
1183 sx->RCPT_452 = TRUE;
1184 sx->next_addr = addr;
1186 addr->transport_return = PENDING_DEFER;
1187 addr->basic_errno = 0;
1191 /* Log temporary errors if there are more hosts to be tried.
1192 If not, log this last one in the == line. */
1194 if (sx->conn_args.host->next)
1195 if (LOGGING(outgoing_port))
1196 log_write(0, LOG_MAIN, "H=%s [%s]:%d %s", sx->conn_args.host->name,
1197 sx->conn_args.host->address,
1198 sx->port == PORT_NONE ? 25 : sx->port, addr->message);
1200 log_write(0, LOG_MAIN, "H=%s [%s]: %s", sx->conn_args.host->name,
1201 sx->conn_args.host->address, addr->message);
1203 #ifndef DISABLE_EVENT
1205 msg_event_raise(US"msg:rcpt:defer", addr);
1208 /* Do not put this message on the list of those waiting for specific
1209 hosts, as otherwise it is likely to be tried too often. */
1211 update_waiting = FALSE;
1213 /* Add a retry item for the address so that it doesn't get tried again
1214 too soon. If address_retry_include_sender is true, add the sender address
1215 to the retry key. */
1217 retry_add_item(addr,
1218 ob->address_retry_include_sender
1219 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1220 : addr->address_retry_key,
1226 if (count && !(addr = addr->next))
1228 } /* Loop for next RCPT response */
1230 /* Update where to start at for the next block of responses, unless we
1231 have already handled all the addresses. */
1233 if (addr) sx->sync_addr = addr->next;
1235 /* Handle a response to DATA. If we have not had any good recipients, either
1236 previously or in this block, the response is ignored. */
1238 if (pending_DATA != 0)
1240 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1241 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1242 '3', ob->command_timeout))
1248 if (errno == ERRNO_TLSFAILURE) /* Error on first TLS read */
1251 if (pending_DATA > 0 || (yield & 1) != 0)
1253 if (errno == 0 && sx->buffer[0] == '4')
1255 errno = ERRNO_DATA4XX;
1256 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1260 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1261 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1262 "is in use and there were no good recipients\n", msg);
1266 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1267 present) received 3xx. If any RCPTs were handled and yielded anything other
1268 than 4xx, yield will be set non-zero. */
1277 /* Try an authenticator's client entry */
1280 try_authenticator(smtp_context * sx, auth_instance * au)
1282 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1283 host_item * host = sx->conn_args.host; /* host to deliver to */
1286 sx->outblock.authenticating = TRUE;
1287 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1288 sx->buffer, sizeof(sx->buffer));
1289 sx->outblock.authenticating = FALSE;
1290 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1292 /* A temporary authentication failure must hold up delivery to
1293 this host. After a permanent authentication failure, we carry on
1294 to try other authentication methods. If all fail hard, try to
1295 deliver the message unauthenticated unless require_auth was set. */
1300 f.smtp_authenticated = TRUE; /* stops the outer loop */
1301 client_authenticator = au->name;
1302 if (au->set_client_id)
1303 client_authenticated_id = expand_string(au->set_client_id);
1306 /* Failure after writing a command */
1311 /* Failure after reading a response */
1314 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1315 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1316 au->name, host->name, host->address, sx->buffer);
1319 /* Failure by some other means. In effect, the authenticator
1320 decided it wasn't prepared to handle this case. Typically this
1321 is the result of "fail" in an expansion string. Do we need to
1322 log anything here? Feb 2006: a message is now put in the buffer
1323 if logging is required. */
1326 if (*sx->buffer != 0)
1327 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1328 "authentication H=%s [%s] %s", au->name, host->name,
1329 host->address, sx->buffer);
1332 /* Internal problem, message in buffer. */
1335 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1336 DEFER, FALSE, &sx->delivery_start);
1345 /* Do the client side of smtp-level authentication.
1348 sx smtp connection context
1350 sx->buffer should have the EHLO response from server (gets overwritten)
1353 OK Success, or failed (but not required): global "smtp_authenticated" set
1354 DEFER Failed authentication (and was required)
1355 ERROR Internal problem
1357 FAIL_SEND Failed communications - transmit
1362 smtp_auth(smtp_context * sx)
1364 host_item * host = sx->conn_args.host; /* host to deliver to */
1365 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1366 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1367 #ifndef DISABLE_PIPE_CONNECT
1368 unsigned short authbits = tls_out.active.sock >= 0
1369 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1371 uschar * fail_reason = US"server did not advertise AUTH support";
1373 f.smtp_authenticated = FALSE;
1374 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1377 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1379 /* Is the server offering AUTH? */
1383 #ifndef DISABLE_PIPE_CONNECT
1384 sx->early_pipe_active ? authbits
1387 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1390 uschar * names = NULL;
1391 expand_nmax = -1; /* reset */
1393 #ifndef DISABLE_PIPE_CONNECT
1394 if (!sx->early_pipe_active)
1396 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1398 /* Must not do this check until after we have saved the result of the
1399 regex match above as the check could be another RE. */
1401 if ( require_auth == OK
1402 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1404 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1405 fail_reason = US"no common mechanisms were found";
1407 #ifndef DISABLE_PIPE_CONNECT
1408 if (sx->early_pipe_active)
1410 /* Scan our authenticators (which support use by a client and were offered
1411 by the server (checked at cache-write time)), not suppressed by
1412 client_condition. If one is found, attempt to authenticate by calling its
1413 client function. We are limited to supporting up to 16 authenticator
1414 public-names by the number of bits in a short. */
1420 for (bitnum = 0, au = auths;
1421 !f.smtp_authenticated && au && bitnum < 16;
1422 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1424 if ( au->client_condition
1425 && !expand_check_condition(au->client_condition, au->name,
1426 US"client authenticator"))
1428 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1429 au->name, "client_condition is false");
1433 /* Found data for a listed mechanism. Call its client entry. Set
1434 a flag in the outblock so that data is overwritten after sending so
1435 that reflections don't show it. */
1437 fail_reason = US"authentication attempt(s) failed";
1439 if ((rc = try_authenticator(sx, au)) != OK)
1446 /* Scan the configured authenticators looking for one which is configured
1447 for use as a client, which is not suppressed by client_condition, and
1448 whose name matches an authentication mechanism supported by the server.
1449 If one is found, attempt to authenticate by calling its client function.
1452 for (auth_instance * au = auths; !f.smtp_authenticated && au; au = au->next)
1457 || ( au->client_condition
1458 && !expand_check_condition(au->client_condition, au->name,
1459 US"client authenticator")))
1461 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1463 (au->client)? "client_condition is false" :
1464 "not configured as a client");
1468 /* Loop to scan supported server mechanisms */
1472 int len = Ustrlen(au->public_name);
1475 while (isspace(*p)) p++;
1477 if (strncmpic(au->public_name, p, len) != 0 ||
1478 (p[len] != 0 && !isspace(p[len])))
1480 while (*p != 0 && !isspace(*p)) p++;
1484 /* Found data for a listed mechanism. Call its client entry. Set
1485 a flag in the outblock so that data is overwritten after sending so
1486 that reflections don't show it. */
1488 fail_reason = US"authentication attempt(s) failed";
1490 if ((rc = try_authenticator(sx, au)) != OK)
1493 break; /* If not authenticated, try next authenticator */
1494 } /* Loop for scanning supported server mechanisms */
1495 } /* Loop for further authenticators */
1499 /* If we haven't authenticated, but are required to, give up. */
1501 if (require_auth == OK && !f.smtp_authenticated)
1503 #ifndef DISABLE_PIPE_CONNECT
1504 invalidate_ehlo_cache_entry(sx);
1506 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1507 string_sprintf("authentication required but %s", fail_reason), DEFER,
1508 FALSE, &sx->delivery_start);
1516 /* Construct AUTH appendix string for MAIL TO */
1519 sx context for smtp connection
1520 p point in sx->buffer to build string
1521 addrlist chain of potential addresses to deliver
1523 Globals f.smtp_authenticated
1524 client_authenticated_sender
1525 Return True on error, otherwise buffer has (possibly empty) terminated string
1529 smtp_mail_auth_str(smtp_context * sx, uschar * p, address_item * addrlist)
1531 smtp_transport_options_block * ob = sx->conn_args.ob;
1532 uschar * local_authenticated_sender = authenticated_sender;
1535 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n",
1536 authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1539 if (ob->authenticated_sender)
1541 uschar * new = expand_string(ob->authenticated_sender);
1544 if (!f.expand_string_forcedfail)
1546 uschar *message = string_sprintf("failed to expand "
1547 "authenticated_sender: %s", expand_string_message);
1548 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
1553 local_authenticated_sender = new;
1556 /* Add the authenticated sender address if present */
1558 if ( (f.smtp_authenticated || ob->authenticated_sender_force)
1559 && local_authenticated_sender)
1561 string_format_nt(p, sizeof(sx->buffer) - (p-sx->buffer), " AUTH=%s",
1562 auth_xtextencode(local_authenticated_sender,
1563 Ustrlen(local_authenticated_sender)));
1564 client_authenticated_sender = string_copy(local_authenticated_sender);
1574 typedef struct smtp_compare_s
1576 uschar * current_sender_address;
1577 struct transport_instance * tblock;
1581 /* Create a unique string that identifies this message, it is based on
1582 sender_address, helo_data and tls_certificate if enabled.
1586 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1588 address_item * addr1;
1589 uschar * if1 = US"";
1590 uschar * helo1 = US"";
1592 uschar * tlsc1 = US"";
1594 uschar * save_sender_address = sender_address;
1595 uschar * local_identity = NULL;
1596 smtp_transport_options_block * ob = SOB tblock->options_block;
1598 sender_address = sender;
1600 addr1 = deliver_make_addr (sender, TRUE);
1601 deliver_set_expansions(addr1);
1604 if1 = expand_string(ob->interface);
1607 helo1 = expand_string(ob->helo_data);
1610 if (ob->tls_certificate)
1611 tlsc1 = expand_string(ob->tls_certificate);
1612 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1614 local_identity = string_sprintf ("%s^%s", if1, helo1);
1617 deliver_set_expansions(NULL);
1618 sender_address = save_sender_address;
1620 return local_identity;
1625 /* This routine is a callback that is called from transport_check_waiting.
1626 This function will evaluate the incoming message versus the previous
1627 message. If the incoming message is using a different local identity then
1628 we will veto this new message. */
1631 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1633 uschar * message_local_identity,
1634 * current_local_identity,
1635 * new_sender_address;
1637 current_local_identity =
1638 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1640 if (!(new_sender_address = spool_sender_from_msgid(message_id)))
1644 message_local_identity =
1645 smtp_local_identity(new_sender_address, s_compare->tblock);
1647 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1653 ehlo_response(uschar * buf, unsigned checks)
1655 size_t bsize = Ustrlen(buf);
1657 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1660 if ( checks & OPTION_TLS
1661 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1663 checks &= ~OPTION_TLS;
1665 if ( checks & OPTION_IGNQ
1666 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1667 PCRE_EOPT, NULL, 0) < 0)
1668 checks &= ~OPTION_IGNQ;
1670 if ( checks & OPTION_CHUNKING
1671 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1672 checks &= ~OPTION_CHUNKING;
1674 #ifndef DISABLE_PRDR
1675 if ( checks & OPTION_PRDR
1676 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1678 checks &= ~OPTION_PRDR;
1681 if ( checks & OPTION_UTF8
1682 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1684 checks &= ~OPTION_UTF8;
1686 if ( checks & OPTION_DSN
1687 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1688 checks &= ~OPTION_DSN;
1690 if ( checks & OPTION_PIPE
1691 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1692 PCRE_EOPT, NULL, 0) < 0)
1693 checks &= ~OPTION_PIPE;
1695 if ( checks & OPTION_SIZE
1696 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1697 checks &= ~OPTION_SIZE;
1699 #ifndef DISABLE_PIPE_CONNECT
1700 if ( checks & OPTION_EARLY_PIPE
1701 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1702 PCRE_EOPT, NULL, 0) < 0)
1704 checks &= ~OPTION_EARLY_PIPE;
1706 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1712 /* Callback for emitting a BDAT data chunk header.
1714 If given a nonzero size, first flush any buffered SMTP commands
1715 then emit the command.
1717 Reap previous SMTP command responses if requested, and always reap
1718 the response from a previous BDAT command.
1721 tctx transport context
1722 chunk_size value for SMTP BDAT command
1724 tc_chunk_last add LAST option to SMTP BDAT command
1725 tc_reap_prev reap response to previous SMTP commands
1729 DEFER TLS error on first read (EHLO-resp); errno set
1733 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1736 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1737 smtp_context * sx = tctx->smtp_context;
1741 /* Write SMTP chunk header command. If not reaping responses, note that
1742 there may be more writes (like, the chunk data) done soon. */
1746 #ifndef DISABLE_PIPE_CONNECT
1747 BOOL new_conn = !!(sx->outblock.conn_args);
1749 if((cmd_count = smtp_write_command(sx,
1750 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1751 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1752 ) < 0) return ERROR;
1753 if (flags & tc_chunk_last)
1754 data_command = string_copy(big_buffer); /* Save for later error message */
1755 #ifndef DISABLE_PIPE_CONNECT
1756 /* That command write could have been the one that made the connection.
1757 Copy the fd from the client conn ctx (smtp transport specific) to the
1758 generic transport ctx. */
1761 tctx->u.fd = sx->outblock.cctx->sock;
1765 prev_cmd_count = cmd_count += sx->cmd_count;
1767 /* Reap responses for any previous, but not one we just emitted */
1771 if (sx->pending_BDAT)
1774 if (flags & tc_reap_prev && prev_cmd_count > 0)
1776 DEBUG(D_transport) debug_printf("look for %d responses"
1777 " for previous pipelined cmds\n", prev_cmd_count);
1779 switch(sync_responses(sx, prev_cmd_count, 0))
1781 case 1: /* 2xx (only) => OK */
1782 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1783 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1784 case 0: break; /* No 2xx or 5xx, but no probs */
1786 case -5: errno = ERRNO_TLSFAILURE;
1788 #ifndef DISABLE_PIPE_CONNECT
1789 case -4: /* non-2xx for pipelined banner or EHLO */
1791 case -1: /* Timeout on RCPT */
1792 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1795 if (!sx->pending_BDAT)
1796 pipelining_active = FALSE;
1799 /* Reap response for an outstanding BDAT */
1801 if (sx->pending_BDAT)
1803 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1805 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1806 ob->command_timeout))
1808 if (errno == 0 && sx->buffer[0] == '4')
1810 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1811 sx->addrlist->more_errno |=
1812 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1817 sx->pending_BDAT = FALSE;
1818 pipelining_active = FALSE;
1820 else if (chunk_size > 0)
1821 sx->pending_BDAT = TRUE;
1824 sx->cmd_count = cmd_count;
1830 /*************************************************
1831 * Make connection for given message *
1832 *************************************************/
1836 sx connection context
1837 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1838 a second attempt after TLS initialization fails
1840 Returns: OK - the connection was made and the delivery attempted;
1841 fd is set in the conn context, tls_out set up.
1842 DEFER - the connection could not be made, or something failed
1843 while setting up the SMTP session, or there was a
1844 non-message-specific error, such as a timeout.
1845 ERROR - helo_data or add_headers or authenticated_sender is
1846 specified for this transport, and the string failed
1850 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1852 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1853 BOOL pass_message = FALSE;
1854 uschar * message = NULL;
1857 uschar * tls_errstr;
1860 sx->conn_args.ob = ob;
1862 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1863 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1864 /* sx->ok = FALSE; */
1865 sx->send_rset = TRUE;
1866 sx->send_quit = TRUE;
1867 sx->setting_up = TRUE;
1869 /* sx->esmtp_sent = FALSE; */
1871 /* sx->utf8_needed = FALSE; */
1873 sx->dsn_all_lasthop = TRUE;
1875 /* sx->conn_args.dane = FALSE; */
1877 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1879 #ifndef DISABLE_PIPE_CONNECT
1880 /* sx->early_pipe_active = sx->early_pipe_ok = FALSE; */
1881 /* sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0; */
1882 /* sx->pending_BANNER = sx->pending_EHLO = sx->pending_MAIL = FALSE; */
1885 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1886 /* sx->peer_offered = 0; */
1887 /* sx->avoid_option = 0; */
1888 sx->igquotstr = US"";
1889 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1890 #ifdef EXPERIMENTAL_DSN_INFO
1891 /* sx->smtp_greeting = NULL; */
1892 /* sx->helo_response = NULL; */
1895 smtp_command = US"initial connection";
1896 /* sx->buffer[0] = '\0'; */
1898 /* Set up the buffer for reading SMTP response packets. */
1900 sx->inblock.buffer = sx->inbuffer;
1901 sx->inblock.buffersize = sizeof(sx->inbuffer);
1902 sx->inblock.ptr = sx->inbuffer;
1903 sx->inblock.ptrend = sx->inbuffer;
1905 /* Set up the buffer for holding SMTP commands while pipelining */
1907 sx->outblock.buffer = sx->outbuffer;
1908 sx->outblock.buffersize = sizeof(sx->outbuffer);
1909 sx->outblock.ptr = sx->outbuffer;
1910 /* sx->outblock.cmd_count = 0; */
1911 /* sx->outblock.authenticating = FALSE; */
1912 /* sx->outblock.conn_args = NULL; */
1914 /* Reset the parameters of a TLS session. */
1917 tls_out.cipher = NULL; /* the one we may use for this transport */
1918 tls_out.ourcert = NULL;
1919 tls_out.peercert = NULL;
1920 tls_out.peerdn = NULL;
1924 tls_out.ocsp = OCSP_NOT_REQ;
1925 #ifndef DISABLE_TLS_RESUME
1926 tls_out.resumption = 0;
1930 /* Flip the legacy TLS-related variables over to the outbound set in case
1931 they're used in the context of the transport. Don't bother resetting
1932 afterward (when being used by a transport) as we're in a subprocess.
1933 For verify, unflipped once the callout is dealt with */
1935 tls_modify_variables(&tls_out);
1940 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
1941 DEFER, FALSE, &sx->delivery_start);
1946 /* If we have a proxied TLS connection, check usability for this message */
1948 if (continue_hostname && continue_proxy_cipher)
1951 const uschar * sni = US"";
1953 # ifdef SUPPORT_DANE
1954 /* Check if the message will be DANE-verified; if so force its SNI */
1956 tls_out.dane_verified = FALSE;
1957 smtp_port_for_connect(sx->conn_args.host, sx->port);
1958 if ( sx->conn_args.host->dnssec == DS_YES
1959 && ( sx->dane_required
1960 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
1962 switch (rc = tlsa_lookup(sx->conn_args.host, &sx->conn_args.tlsa_dnsa, sx->dane_required))
1964 case OK: sx->conn_args.dane = TRUE;
1965 ob->tls_tempfail_tryclear = FALSE; /* force TLS */
1966 ob->tls_sni = sx->first_addr->domain; /* force SNI */
1968 case FAIL_FORCED: break;
1969 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
1970 string_sprintf("DANE error: tlsa lookup %s",
1972 rc, FALSE, &sx->delivery_start);
1973 # ifndef DISABLE_EVENT
1974 (void) event_raise(sx->conn_args.tblock->event_action,
1975 US"dane:fail", sx->dane_required
1976 ? US"dane-required" : US"dnssec-invalid");
1982 /* If the SNI or the DANE status required for the new message differs from the
1983 existing conn drop the connection to force a new one. */
1985 if (ob->tls_sni && !(sni = expand_cstring(ob->tls_sni)))
1986 log_write(0, LOG_MAIN|LOG_PANIC,
1987 "<%s>: failed to expand transport's tls_sni value: %s",
1988 sx->addrlist->address, expand_string_message);
1990 # ifdef SUPPORT_DANE
1991 if ( (continue_proxy_sni ? (Ustrcmp(continue_proxy_sni, sni) == 0) : !*sni)
1992 && continue_proxy_dane == sx->conn_args.dane)
1994 tls_out.sni = US sni;
1995 if ((tls_out.dane_verified = continue_proxy_dane))
1996 sx->conn_args.host->dnssec = DS_YES;
1999 if ((continue_proxy_sni ? (Ustrcmp(continue_proxy_sni, sni) == 0) : !*sni))
2000 tls_out.sni = US sni;
2005 debug_printf("Closing proxied-TLS connection due to SNI mismatch\n");
2007 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP>> QUIT\n");
2008 write(0, "QUIT\r\n", 6);
2010 continue_hostname = continue_proxy_cipher = NULL;
2011 f.continue_more = FALSE;
2012 continue_sequence = 1; /* Unfortunately, this process cannot affect success log
2013 which is done by delivery proc. Would have to pass this
2014 back through reporting pipe. */
2017 #endif /*!DISABLE_TLS*/
2019 /* Make a connection to the host if this isn't a continued delivery, and handle
2020 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2021 specially so they can be identified for retries. */
2023 if (!continue_hostname)
2026 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2028 /* Arrange to report to calling process this is a new connection */
2030 clearflag(sx->first_addr, af_cont_conn);
2031 setflag(sx->first_addr, af_new_conn);
2033 /* Get the actual port the connection will use, into sx->conn_args.host */
2035 smtp_port_for_connect(sx->conn_args.host, sx->port);
2038 /* Do TLSA lookup for DANE */
2040 tls_out.dane_verified = FALSE;
2041 tls_out.tlsa_usage = 0;
2043 if (sx->conn_args.host->dnssec == DS_YES)
2046 if( sx->dane_required
2047 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2049 switch (rc = tlsa_lookup(sx->conn_args.host, &sx->conn_args.tlsa_dnsa, sx->dane_required))
2051 case OK: sx->conn_args.dane = TRUE;
2052 ob->tls_tempfail_tryclear = FALSE; /* force TLS */
2053 ob->tls_sni = sx->first_addr->domain; /* force SNI */
2055 case FAIL_FORCED: break;
2056 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2057 string_sprintf("DANE error: tlsa lookup %s",
2059 rc, FALSE, &sx->delivery_start);
2060 # ifndef DISABLE_EVENT
2061 (void) event_raise(sx->conn_args.tblock->event_action,
2062 US"dane:fail", sx->dane_required
2063 ? US"dane-required" : US"dnssec-invalid");
2068 else if (sx->dane_required)
2070 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2071 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2072 FAIL, FALSE, &sx->delivery_start);
2073 # ifndef DISABLE_EVENT
2074 (void) event_raise(sx->conn_args.tblock->event_action,
2075 US"dane:fail", US"dane-required");
2082 /* Make the TCP connection */
2084 sx->cctx.tls_ctx = NULL;
2085 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2086 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2088 #ifndef DISABLE_PIPE_CONNECT
2089 if ( verify_check_given_host(CUSS &ob->hosts_pipe_connect,
2090 sx->conn_args.host) == OK)
2092 /* We don't find out the local ip address until the connect, so if
2093 the helo string might use it avoid doing early-pipelining. */
2096 || !Ustrstr(sx->helo_data, "$sending_ip_address")
2097 || Ustrstr(sx->helo_data, "def:sending_ip_address")
2100 sx->early_pipe_ok = TRUE;
2101 if ( read_ehlo_cache_entry(sx)
2102 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2105 debug_printf("Using cached cleartext PIPE_CONNECT\n");
2106 sx->early_pipe_active = TRUE;
2107 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2110 else DEBUG(D_transport)
2111 debug_printf("helo needs $sending_ip_address\n");
2114 if (sx->early_pipe_active)
2115 sx->outblock.conn_args = &sx->conn_args;
2119 blob lazy_conn = {.data = NULL};
2120 /* For TLS-connect, a TFO lazy-connect is useful since the Client Hello
2121 can go on the TCP SYN. */
2123 if ((sx->cctx.sock = smtp_connect(&sx->conn_args,
2124 sx->smtps ? &lazy_conn : NULL)) < 0)
2126 set_errno_nohost(sx->addrlist,
2127 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2128 sx->verify ? US strerror(errno) : NULL,
2129 DEFER, FALSE, &sx->delivery_start);
2130 sx->send_quit = FALSE;
2134 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2138 /* Expand the greeting message while waiting for the initial response. (Makes
2139 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2140 delayed till here so that $sending_interface and $sending_port are set. */
2141 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2142 will be? Somehow I doubt it. */
2145 if (!(sx->helo_data = expand_string(sx->helo_data)))
2147 log_write(0, LOG_MAIN|LOG_PANIC,
2148 "<%s>: failed to expand transport's helo_data value for callout: %s",
2149 sx->addrlist->address, expand_string_message);
2154 expand_string_message = NULL;
2155 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2156 &expand_string_message)),
2157 expand_string_message)
2159 log_write(0, LOG_MAIN|LOG_PANIC,
2160 "<%s>: failed to expand transport's helo_data value for callout: %s",
2161 sx->addrlist->address, expand_string_message);
2163 sx->helo_data = NULL;
2167 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2168 is nevertheless a reasonably clean way of programming this kind of logic,
2169 where you want to escape on any error. */
2173 #ifndef DISABLE_PIPE_CONNECT
2174 if (sx->early_pipe_active)
2176 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2177 sx->outblock.cmd_count = 1;
2182 if (!smtp_reap_banner(sx))
2183 goto RESPONSE_FAILED;
2186 #ifndef DISABLE_EVENT
2189 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2190 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2191 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2194 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2195 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2196 DEFER, FALSE, &sx->delivery_start);
2203 /* Now check if the helo_data expansion went well, and sign off cleanly if
2208 message = string_sprintf("failed to expand helo_data: %s",
2209 expand_string_message);
2210 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
2216 /** Debugging without sending a message
2217 sx->addrlist->transport_return = DEFER;
2221 /* Errors that occur after this point follow an SMTP command, which is
2222 left in big_buffer by smtp_write_command() for use in error messages. */
2224 smtp_command = big_buffer;
2226 /* Tell the remote who we are...
2228 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2229 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2230 greeting is of this form. The assumption was that the far end supports it
2231 properly... but experience shows that there are some that give 5xx responses,
2232 even though the banner includes "ESMTP" (there's a bloody-minded one that
2233 says "ESMTP not spoken here"). Cope with that case.
2235 September 2000: Time has passed, and it seems reasonable now to always send
2236 EHLO at the start. It is also convenient to make the change while installing
2239 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2240 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2241 would be no way to send out the mails, so there is now a host list
2242 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2243 PIPELINING problem as well. Maybe it can also be useful to cure other
2244 problems with broken servers.
2246 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2247 Then somebody tried it with a Microsoft mailer... It seems that all other
2248 mailers use upper case for some reason (the RFC is quite clear about case
2249 independence) so, for peace of mind, I gave in. */
2251 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2253 /* Alas; be careful, since this goto is not an error-out, so conceivably
2254 we might set data between here and the target which we assume to exist
2255 and be usable. I can see this coming back to bite us. */
2259 smtp_peer_options |= OPTION_TLS;
2260 suppress_tls = FALSE;
2261 ob->tls_tempfail_tryclear = FALSE;
2262 smtp_command = US"SSL-on-connect";
2269 if (smtp_write_command(sx,
2270 #ifndef DISABLE_PIPE_CONNECT
2271 sx->early_pipe_active ? SCMD_BUFFER :
2274 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2276 sx->esmtp_sent = TRUE;
2278 #ifndef DISABLE_PIPE_CONNECT
2279 if (sx->early_pipe_active)
2281 sx->pending_EHLO = TRUE;
2283 /* If we have too many authenticators to handle and might need to AUTH
2284 for this transport, pipeline no further as we will need the
2285 list of auth methods offered. Reap the banner and EHLO. */
2287 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2288 && f.smtp_in_early_pipe_no_auth)
2290 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2291 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2293 if (sync_responses(sx, 2, 0) != 0)
2296 debug_printf("failed reaping pipelined cmd responses\n");
2297 goto RESPONSE_FAILED;
2299 sx->early_pipe_active = FALSE;
2304 if (!smtp_reap_ehlo(sx))
2305 goto RESPONSE_FAILED;
2309 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2311 #ifndef DISABLE_PIPE_CONNECT
2312 if (!sx->early_pipe_active)
2317 int n = sizeof(sx->buffer);
2318 uschar * rsp = sx->buffer;
2320 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2321 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2323 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2325 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2326 #ifdef EXPERIMENTAL_DSN_INFO
2327 sx->helo_response = string_copy(rsp);
2331 /* Handle special logging for a closed connection after HELO
2332 when had previously sent EHLO */
2334 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2336 errno = ERRNO_SMTPCLOSED;
2337 goto EHLOHELO_FAILED;
2339 memmove(sx->buffer, rsp, Ustrlen(rsp));
2340 goto RESPONSE_FAILED;
2344 if (sx->esmtp || sx->lmtp)
2346 #ifndef DISABLE_PIPE_CONNECT
2347 if (!sx->early_pipe_active)
2350 sx->peer_offered = ehlo_response(sx->buffer,
2351 OPTION_TLS /* others checked later */
2352 #ifndef DISABLE_PIPE_CONNECT
2353 | (sx->early_pipe_ok
2355 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2364 #ifndef DISABLE_PIPE_CONNECT
2365 if (sx->early_pipe_ok)
2367 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2369 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2370 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2372 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2373 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2374 write_ehlo_cache_entry(sx);
2380 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2383 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2388 /* For continuing deliveries down the same channel, having re-exec'd the socket
2389 is the standard input; for a socket held open from verify it is recorded
2390 in the cutthrough context block. Either way we don't need to redo EHLO here
2391 (but may need to do so for TLS - see below).
2392 Set up the pointer to where subsequent commands will be left, for
2393 error messages. Note that smtp_peer_options will have been
2394 set from the command line if they were set in the process that passed the
2397 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2398 as the continue goes via transport_pass_socket() and doublefork and exec.
2399 It does not wait. Unclear how we keep separate host's responses
2400 separate - we could match up by host ip+port as a bodge. */
2404 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2406 sx->cctx = cutthrough.cctx;
2407 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2411 sx->cctx.sock = 0; /* stdin */
2412 sx->cctx.tls_ctx = NULL;
2413 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2415 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2416 smtp_command = big_buffer;
2417 sx->peer_offered = smtp_peer_options;
2418 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2420 /* For a continued connection with TLS being proxied for us, or a
2421 held-open verify connection with TLS, nothing more to do. */
2423 if ( continue_proxy_cipher
2424 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2425 && cutthrough.is_tls)
2428 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2429 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2430 continue_proxy_cipher ? "proxied" : "verify conn with");
2433 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2436 /* If TLS is available on this connection, whether continued or not, attempt to
2437 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2438 send another EHLO - the server may give a different answer in secure mode. We
2439 use a separate buffer for reading the response to STARTTLS so that if it is
2440 negative, the original EHLO data is available for subsequent analysis, should
2441 the client not be required to use TLS. If the response is bad, copy the buffer
2442 for error analysis. */
2445 if ( smtp_peer_options & OPTION_TLS
2447 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2449 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2452 uschar buffer2[4096];
2454 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2457 #ifndef DISABLE_PIPE_CONNECT
2458 /* If doing early-pipelining reap the banner and EHLO-response but leave
2459 the response for the STARTTLS we just sent alone. */
2461 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2464 debug_printf("failed reaping pipelined cmd responses\n");
2465 close(sx->cctx.sock);
2467 sx->early_pipe_active = FALSE;
2468 goto PIPE_CONNECT_RETRY;
2472 /* If there is an I/O error, transmission of this message is deferred. If
2473 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2474 false, we also defer. However, if there is a temporary rejection of STARTTLS
2475 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2476 STARTTLS, we carry on. This means we will try to send the message in clear,
2477 unless the host is in hosts_require_tls (tested below). */
2479 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2483 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2486 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2487 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2488 goto RESPONSE_FAILED;
2492 /* STARTTLS accepted: try to negotiate a TLS session. */
2497 if (!tls_client_start(&sx->cctx, &sx->conn_args, sx->addrlist, &tls_out, &tls_errstr))
2499 /* TLS negotiation failed; give an error. From outside, this function may
2500 be called again to try in clear on a new connection, if the options permit
2501 it for this host. */
2503 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", tls_errstr);
2505 # ifdef SUPPORT_DANE
2506 if (sx->conn_args.dane)
2508 log_write(0, LOG_MAIN,
2509 "DANE attempt failed; TLS connection to %s [%s]: %s",
2510 sx->conn_args.host->name, sx->conn_args.host->address, tls_errstr);
2511 # ifndef DISABLE_EVENT
2512 (void) event_raise(sx->conn_args.tblock->event_action,
2513 US"dane:fail", US"validation-failure"); /* could do with better detail */
2518 errno = ERRNO_TLSFAILURE;
2519 message = string_sprintf("TLS session: %s", tls_errstr);
2520 sx->send_quit = FALSE;
2523 sx->send_tlsclose = TRUE;
2525 /* TLS session is set up. Check the inblock fill level. If there is
2526 content then as we have not yet done a tls read it must have arrived before
2527 the TLS handshake, in-clear. That violates the sync requirement of the
2528 STARTTLS RFC, so fail. */
2530 if (sx->inblock.ptr != sx->inblock.ptrend)
2534 int i = sx->inblock.ptrend - sx->inblock.ptr;
2535 debug_printf("unused data in input buffer after ack for STARTTLS:\n"
2537 i > 100 ? 100 : i, sx->inblock.ptr, i > 100 ? "..." : "");
2539 tls_errstr = US"synch error before connect";
2540 goto TLS_CONN_FAILED;
2543 smtp_peer_options_wrap = smtp_peer_options;
2544 for (address_item * addr = sx->addrlist; addr; addr = addr->next)
2545 if (addr->transport_return == PENDING_DEFER)
2547 addr->cipher = tls_out.cipher;
2548 addr->ourcert = tls_out.ourcert;
2549 addr->peercert = tls_out.peercert;
2550 addr->peerdn = tls_out.peerdn;
2551 addr->ocsp = tls_out.ocsp;
2552 addr->tlsver = tls_out.ver;
2557 /* if smtps, we'll have smtp_command set to something else; always safe to
2559 smtp_command = big_buffer;
2561 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2562 helo_data is null, we are dealing with a connection that was passed from
2563 another process, and so we won't have expanded helo_data above. We have to
2564 expand it here. $sending_ip_address and $sending_port are set up right at the
2565 start of the Exim process (in exim.c). */
2567 if (tls_out.active.sock >= 0)
2569 uschar * greeting_cmd;
2571 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2573 uschar *message = string_sprintf("failed to expand helo_data: %s",
2574 expand_string_message);
2575 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
2580 #ifndef DISABLE_PIPE_CONNECT
2581 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2582 We're unlikely to get the group sent and delivered before the server sends its
2583 banner, but it's still worth sending as a group.
2584 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2587 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2589 sx->peer_offered = sx->ehlo_resp.crypted_features;
2590 if ((sx->early_pipe_active =
2591 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2592 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2596 /* For SMTPS we need to wait for the initial OK response. */
2598 #ifndef DISABLE_PIPE_CONNECT
2599 if (sx->early_pipe_active)
2601 sx->pending_BANNER = TRUE;
2602 sx->outblock.cmd_count = 1;
2606 if (!smtp_reap_banner(sx))
2607 goto RESPONSE_FAILED;
2610 greeting_cmd = US"LHLO";
2612 greeting_cmd = US"EHLO";
2615 greeting_cmd = US"HELO";
2617 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2620 if (smtp_write_command(sx,
2621 #ifndef DISABLE_PIPE_CONNECT
2622 sx->early_pipe_active ? SCMD_BUFFER :
2625 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2628 #ifndef DISABLE_PIPE_CONNECT
2629 if (sx->early_pipe_active)
2630 sx->pending_EHLO = TRUE;
2634 if (!smtp_reap_ehlo(sx))
2637 /* The GnuTLS layer in Exim only spots a server-rejection of a client
2638 cert late, under TLS1.3 - which means here; the first time we try to
2639 receive crypted data. Treat it as if it was a connect-time failure.
2640 See also the early-pipe equivalent... which will be hard; every call
2641 to sync_responses will need to check the result.
2642 It would be nicer to have GnuTLS check the cert during the handshake.
2643 Can it do that, with all the flexibility we need? */
2645 tls_errstr = US"error on first read";
2646 goto TLS_CONN_FAILED;
2649 goto RESPONSE_FAILED;
2651 smtp_peer_options = 0;
2655 /* If the host is required to use a secure channel, ensure that we
2659 # ifdef SUPPORT_DANE
2660 || sx->conn_args.dane
2662 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2665 errno = ERRNO_TLSREQUIRED;
2666 message = string_sprintf("a TLS session is required, but %s",
2667 smtp_peer_options & OPTION_TLS
2668 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2669 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2670 if (sx->conn_args.dane)
2671 (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2672 smtp_peer_options & OPTION_TLS
2673 ? US"validation-failure" /* could do with better detail */
2674 : US"starttls-not-supported");
2678 #endif /*DISABLE_TLS*/
2680 /* If TLS is active, we have just started it up and re-done the EHLO command,
2681 so its response needs to be analyzed. If TLS is not active and this is a
2682 continued session down a previously-used socket, we haven't just done EHLO, so
2685 if ( !continue_hostname
2687 || tls_out.active.sock >= 0
2691 if (sx->esmtp || sx->lmtp)
2693 #ifndef DISABLE_PIPE_CONNECT
2694 if (!sx->early_pipe_active)
2697 sx->peer_offered = ehlo_response(sx->buffer,
2699 #ifndef DISABLE_PIPE_CONNECT
2700 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2701 | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2702 | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8
2703 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2707 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2710 # ifdef SUPPORT_I18N
2711 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2712 /*XXX if we hand peercaps on to continued-conn processes,
2713 must not depend on this addr */
2717 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2720 #ifndef DISABLE_PIPE_CONNECT
2721 if (tls_out.active.sock >= 0)
2722 sx->ehlo_resp.crypted_features = sx->peer_offered;
2726 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2727 lmtp_ignore_quota option was set. */
2729 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2731 /* If the response to EHLO specified support for the SIZE parameter, note
2732 this, provided size_addition is non-negative. */
2734 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2736 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2737 the current host, esmtp will be false, so PIPELINING can never be used. If
2738 the current host matches hosts_avoid_pipelining, don't do it. */
2740 if ( sx->peer_offered & OPTION_PIPE
2741 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2742 smtp_peer_options |= OPTION_PIPE;
2744 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2745 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2747 if ( sx->peer_offered & OPTION_CHUNKING
2748 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2749 sx->peer_offered &= ~OPTION_CHUNKING;
2751 if (sx->peer_offered & OPTION_CHUNKING)
2752 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2754 #ifndef DISABLE_PRDR
2755 if ( sx->peer_offered & OPTION_PRDR
2756 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2757 sx->peer_offered &= ~OPTION_PRDR;
2759 if (sx->peer_offered & OPTION_PRDR)
2760 DEBUG(D_transport) debug_printf("PRDR usable\n");
2763 /* Note if the server supports DSN */
2764 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2765 DEBUG(D_transport) debug_printf("%susing DSN\n",
2766 sx->peer_offered & OPTION_DSN ? "" : "not ");
2768 #ifndef DISABLE_PIPE_CONNECT
2769 if ( sx->early_pipe_ok
2770 && !sx->early_pipe_active
2771 && tls_out.active.sock >= 0
2772 && smtp_peer_options & OPTION_PIPE
2773 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2774 & OPTION_EARLY_PIPE)
2776 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2777 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2778 write_ehlo_cache_entry(sx);
2782 /* Note if the response to EHLO specifies support for the AUTH extension.
2783 If it has, check that this host is one we want to authenticate to, and do
2784 the business. The host name and address must be available when the
2785 authenticator's client driver is running. */
2787 switch (yield = smtp_auth(sx))
2789 default: goto SEND_QUIT;
2791 case FAIL_SEND: goto SEND_FAILED;
2792 case FAIL: goto RESPONSE_FAILED;
2796 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2798 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2799 message-specific. */
2801 sx->setting_up = FALSE;
2804 if (sx->addrlist->prop.utf8_msg)
2808 /* If the transport sets a downconversion mode it overrides any set by ACL
2811 if ((s = ob->utf8_downconvert))
2813 if (!(s = expand_string(s)))
2815 message = string_sprintf("failed to expand utf8_downconvert: %s",
2816 expand_string_message);
2817 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
2823 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2824 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2826 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2827 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2829 case '-': if (s[1] == '1')
2831 sx->addrlist->prop.utf8_downcvt = FALSE;
2832 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2838 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2839 && !sx->addrlist->prop.utf8_downcvt_maybe;
2840 DEBUG(D_transport) if (!sx->utf8_needed)
2841 debug_printf("utf8: %s downconvert\n",
2842 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2845 /* If this is an international message we need the host to speak SMTPUTF8 */
2846 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2848 errno = ERRNO_UTF8_FWD;
2849 goto RESPONSE_FAILED;
2851 #endif /*SUPPORT_I18N*/
2860 if (errno == ECONNREFUSED) /* first-read error on a TFO conn */
2862 /* There is a testing facility for simulating a connection timeout, as I
2863 can't think of any other way of doing this. It converts a connection
2864 refused into a timeout if the timeout is set to 999999. This is done for
2865 a 3whs connection in ip_connect(), but a TFO connection does not error
2866 there - instead it gets ECONNREFUSED on the first data read. Tracking
2867 that a TFO really was done is too hard, or we would set a
2868 sx->pending_conn_done bit and test that in smtp_reap_banner() and
2869 smtp_reap_ehlo(). That would let us also add the conn-timeout to the
2872 if (f.running_in_test_harness && ob->connect_timeout == 999999)
2874 set_errno_nohost(sx->addrlist,
2875 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2876 sx->verify ? US strerror(errno) : NULL,
2877 DEFER, FALSE, &sx->delivery_start);
2878 sx->send_quit = FALSE;
2882 /* really an error on an SMTP read */
2884 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2885 sx->buffer, &code, &message, &pass_message);
2891 message = US string_sprintf("send() to %s [%s] failed: %s",
2892 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2893 sx->send_quit = FALSE;
2899 message = string_sprintf("Remote host closed connection in response to %s"
2900 " (EHLO response was: %s)", smtp_command, sx->buffer);
2901 sx->send_quit = FALSE;
2905 /* This label is jumped to directly when a TLS negotiation has failed,
2906 or was not done for a host for which it is required. Values will be set
2907 in message and errno, and setting_up will always be true. Treat as
2908 a temporary error. */
2912 code = '4', yield = DEFER;
2916 /* The failure happened while setting up the call; see if the failure was
2917 a 5xx response (this will either be on connection, or following HELO - a 5xx
2918 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2919 fail all addresses, as this host is never going to accept them. For other
2920 errors during setting up (timeouts or whatever), defer all addresses, and
2921 yield DEFER, so that the host is not tried again for a while.
2923 XXX This peeking for another host feels like a layering violation. We want
2924 to note the host as unusable, but down here we shouldn't know if this was
2925 the last host to try for the addr(list). Perhaps the upper layer should be
2926 the one to do set_errno() ? The problem is that currently the addr is where
2927 errno etc. are stashed, but until we run out of hosts to try the errors are
2928 host-specific. Maybe we should enhance the host_item definition? */
2931 sx->ok = FALSE; /* For when reached by GOTO */
2932 set_errno(sx->addrlist, errno, message,
2933 sx->conn_args.host->next
2937 || errno == ERRNO_UTF8_FWD
2941 errno == ECONNREFUSED ? NULL : sx->conn_args.host,
2942 #ifdef EXPERIMENTAL_DSN_INFO
2943 sx->smtp_greeting, sx->helo_response,
2945 &sx->delivery_start);
2952 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2955 if (sx->cctx.tls_ctx)
2957 if (sx->send_tlsclose)
2959 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2960 sx->send_tlsclose = FALSE;
2962 sx->cctx.tls_ctx = NULL;
2966 /* Close the socket, and return the appropriate value, first setting
2967 works because the NULL setting is passed back to the calling process, and
2968 remote_max_parallel is forced to 1 when delivering over an existing connection,
2971 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2974 shutdown(sx->cctx.sock, SHUT_WR);
2975 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2976 for (int i = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && i > 0;)
2977 i--; /* drain socket */
2978 sx->send_quit = FALSE;
2980 (void)close(sx->cctx.sock);
2983 #ifndef DISABLE_EVENT
2984 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2987 continue_transport = NULL;
2988 continue_hostname = NULL;
2995 /* Create the string of options that will be appended to the MAIL FROM:
2996 in the connection context buffer */
2999 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
3001 uschar * p = sx->buffer;
3002 address_item * addr;
3007 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
3008 send it, adding something to the message size to allow for imprecision
3009 and things that get added en route. Exim keeps the number of lines
3010 in a message, so we can give an accurate value for the original message, but we
3011 need some additional to handle added headers. (Double "." characters don't get
3012 included in the count.) */
3014 if ( message_size > 0
3015 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
3017 /*XXX problem here under spool_files_wireformat?
3018 Or just forget about lines? Or inflate by a fixed proportion? */
3020 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
3024 #ifndef DISABLE_PRDR
3025 /* If it supports Per-Recipient Data Responses, and we have more than one recipient,
3028 sx->prdr_active = FALSE;
3029 if (sx->peer_offered & OPTION_PRDR)
3030 for (address_item * addr = addrlist; addr; addr = addr->next)
3031 if (addr->transport_return == PENDING_DEFER)
3033 for (addr = addr->next; addr; addr = addr->next)
3034 if (addr->transport_return == PENDING_DEFER)
3035 { /* at least two recipients to send */
3036 sx->prdr_active = TRUE;
3037 sprintf(CS p, " PRDR"); p += 5;
3045 /* If it supports internationalised messages, and this meesage need that,
3048 if ( sx->peer_offered & OPTION_UTF8
3049 && addrlist->prop.utf8_msg
3050 && !addrlist->prop.utf8_downcvt
3052 Ustrcpy(p, US" SMTPUTF8"), p += 9;
3055 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3056 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3057 addr && address_count < sx->max_rcpt;
3058 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3061 if (!(addr->dsn_flags & rf_dsnlasthop))
3063 sx->dsn_all_lasthop = FALSE;
3068 /* Add any DSN flags to the mail command */
3070 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3072 if (dsn_ret == dsn_ret_hdrs)
3073 { Ustrcpy(p, US" RET=HDRS"); p += 9; }
3074 else if (dsn_ret == dsn_ret_full)
3075 { Ustrcpy(p, US" RET=FULL"); p += 9; }
3079 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3084 /* If an authenticated_sender override has been specified for this transport
3085 instance, expand it. If the expansion is forced to fail, and there was already
3086 an authenticated_sender for this message, the original value will be used.
3087 Other expansion failures are serious. An empty result is ignored, but there is
3088 otherwise no check - this feature is expected to be used with LMTP and other
3089 cases where non-standard addresses (e.g. without domains) might be required. */
3091 return smtp_mail_auth_str(sx, p, addrlist) ? ERROR : OK;
3096 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3098 uschar * p = sx->buffer;
3101 /* Add any DSN flags to the rcpt command */
3103 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3105 if (addr->dsn_flags & rf_dsnflags)
3109 Ustrcpy(p, US" NOTIFY=");
3111 for (int i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3113 if (!first) *p++ = ',';
3115 Ustrcpy(p, rf_names[i]);
3120 if (addr->dsn_orcpt)
3122 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3133 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3134 -1 MAIL response error
3135 -2 any non-MAIL read i/o error
3136 -3 non-MAIL response timeout
3137 -4 internal error; channel still usable
3142 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3144 address_item * addr;
3145 int address_count, pipe_limit;
3148 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3154 /* From here until we send the DATA command, we can make use of PIPELINING
3155 if the server host supports it. The code has to be able to check the responses
3156 at any point, for when the buffer fills up, so we write it totally generally.
3157 When PIPELINING is off, each command written reports that it has flushed the
3160 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3163 uschar * s = sx->from_addr;
3165 uschar * errstr = NULL;
3167 /* If we must downconvert, do the from-address here. Remember we had to
3168 for the to-addresses (done below), and also (ugly) for re-doing when building
3169 the delivery log line. */
3171 if ( sx->addrlist->prop.utf8_msg
3172 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3175 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3177 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE, &sx->delivery_start);
3181 setflag(sx->addrlist, af_utf8_downcvt);
3185 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3186 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3189 mail_command = string_copy(big_buffer); /* Save for later error message */
3193 case -1: /* Transmission error */
3196 case +1: /* Cmd was sent */
3197 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3198 (SOB sx->conn_args.ob)->command_timeout))
3200 if (errno == 0 && sx->buffer[0] == '4')
3202 errno = ERRNO_MAIL4XX;
3203 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3207 sx->pending_MAIL = FALSE;
3210 /* otherwise zero: command queued for pipeline */
3213 /* Pass over all the relevant recipient addresses for this host, which are the
3214 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3215 several before we have to read the responses for those seen so far. This
3216 checking is done by a subroutine because it also needs to be done at the end.
3217 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3218 the next one if not all are sent.
3220 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3221 last address because we want to abort if any recipients have any kind of
3222 problem, temporary or permanent. We know that all recipient addresses will have
3223 the PENDING_DEFER status, because only one attempt is ever made, and we know
3224 that max_rcpt will be large, so all addresses will be done at once.
3226 For verify we flush the pipeline after any (the only) rcpt address. */
3228 for (addr = sx->first_addr, address_count = 0, pipe_limit = 100;
3229 addr && address_count < sx->max_rcpt;
3230 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3236 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3237 ? dsn_support_yes : dsn_support_no;
3240 if (pipe_limit-- <= 0)
3241 { no_flush = FALSE; pipe_limit = 100; }
3243 no_flush = pipelining_active && !sx->verify
3244 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3246 build_rcptcmd_options(sx, addr);
3248 /* Now send the RCPT command, and process outstanding responses when
3249 necessary. After a timeout on RCPT, we just end the function, leaving the
3250 yield as OK, because this error can often mean that there is a problem with
3251 just one address, so we don't want to delay the host. */
3253 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3256 if ( testflag(sx->addrlist, af_utf8_downcvt)
3257 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3260 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3261 errno = ERRNO_EXPANDFAIL;
3262 return -5; /*XXX too harsh? */
3266 cmds_sent = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3267 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3269 if (cmds_sent < 0) return -5;
3272 switch(sync_responses(sx, cmds_sent, 0))
3274 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3275 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3278 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3279 if (!sx->lmtp) /* can't tell about progress yet */
3280 sx->completed_addr = TRUE;
3281 case 0: /* No 2xx or 5xx, but no probs */
3282 /* If any RCPT got a 452 response then next_addr has been updated
3283 for restarting with a new MAIL on the same connection. Send no more
3284 RCPTs for this MAIL. */
3288 DEBUG(D_transport) debug_printf("seen 452 too-many-rcpts\n");
3289 sx->RCPT_452 = FALSE;
3290 /* sx->next_addr has been reset for fast_retry */
3295 case -1: return -3; /* Timeout on RCPT */
3296 case -2: return -2; /* non-MAIL read i/o error */
3297 default: return -1; /* any MAIL error */
3299 #ifndef DISABLE_PIPE_CONNECT
3300 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3301 case -5: return -1; /* TLS first-read error */
3305 } /* Loop for next address */
3307 sx->next_addr = addr;
3313 /*****************************************************
3314 * Proxy TLS connection for another transport process *
3315 ******************************************************/
3317 Close the unused end of the pipe, fork once more, then use the given buffer
3318 as a staging area, and select on both the given fd and the TLS'd client-fd for
3319 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3320 Do blocking full-size writes, and reads under a timeout. Once both input
3321 channels are closed, exit the process.
3325 buf space to use for buffering
3326 bufsiz size of buffer
3327 pfd pipe filedescriptor array; [0] is comms to proxied process
3328 timeout per-read timeout, seconds
3334 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3338 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3340 BOOL send_tls_shutdown = TRUE;
3343 if ((rc = exim_fork(US"tls-proxy")))
3344 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3346 set_process_info("proxying TLS connection for continued transport");
3348 FD_SET(tls_out.active.sock, &rfds);
3349 FD_SET(pfd[0], &rfds);
3351 for (int fd_bits = 3; fd_bits; )
3353 time_t time_left = timeout;
3354 time_t time_start = time(NULL);
3360 struct timeval tv = { time_left, 0 };
3363 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
3365 if (rc < 0 && errno == EINTR)
3366 if ((time_left -= time(NULL) - time_start) > 0) continue;
3370 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
3374 /* For errors where not readable, bomb out */
3376 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
3378 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
3379 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
3380 if (!(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)))
3382 DEBUG(D_transport) debug_printf("- but also readable; no exit yet\n");
3385 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
3387 /* handle inbound data */
3388 if (FD_ISSET(tls_out.active.sock, &rfds))
3389 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0) /* Expect -1 for EOF; */
3390 { /* that reaps the TLS Close Notify record */
3392 FD_CLR(tls_out.active.sock, &rfds);
3393 shutdown(pfd[0], SHUT_WR);
3398 for (int nbytes = 0; rc - nbytes > 0; nbytes += i)
3399 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
3402 /* Handle outbound data. We cannot combine payload and the TLS-close
3403 due to the limitations of the (pipe) channel feeding us. */
3404 if (FD_ISSET(pfd[0], &rfds))
3405 if ((rc = read(pfd[0], buf, bsize)) <= 0)
3408 FD_CLR(pfd[0], &rfds);
3410 # ifdef EXIM_TCP_CORK /* Use _CORK to get TLS Close Notify in FIN segment */
3411 (void) setsockopt(tls_out.active.sock, IPPROTO_TCP, EXIM_TCP_CORK, US &on, sizeof(on));
3413 tls_shutdown_wr(ct_ctx);
3414 send_tls_shutdown = FALSE;
3415 shutdown(tls_out.active.sock, SHUT_WR);
3419 for (int nbytes = 0; rc - nbytes > 0; nbytes += i)
3420 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
3424 if (fd_bits & 1) FD_SET(tls_out.active.sock, &rfds);
3425 if (fd_bits & 2) FD_SET(pfd[0], &rfds);
3429 if (send_tls_shutdown) tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
3431 testharness_pause_ms(100); /* let logging complete */
3432 exim_exit(EXIT_SUCCESS);
3437 /*************************************************
3438 * Deliver address list to given host *
3439 *************************************************/
3441 /* If continue_hostname is not null, we get here only when continuing to
3442 deliver down an existing channel. The channel was passed as the standard
3443 input. TLS is never active on a passed channel; the previous process either
3444 closes it down before passing the connection on, or inserts a TLS-proxy
3445 process and passes on a cleartext conection.
3447 Otherwise, we have to make a connection to the remote host, and do the
3448 initial protocol exchange.
3450 When running as an MUA wrapper, if the sender or any recipient is rejected,
3451 temporarily or permanently, we force failure for all recipients.
3454 addrlist chain of potential addresses to deliver; only those whose
3455 transport_return field is set to PENDING_DEFER are currently
3456 being processed; others should be skipped - they have either
3457 been delivered to an earlier host or IP address, or been
3458 failed by one of them.
3459 host host to deliver to
3460 host_af AF_INET or AF_INET6
3461 defport default TCP/IP port to use if host does not specify, in host
3463 interface interface to bind to, or NULL
3464 tblock transport instance block
3465 message_defer set TRUE if yield is OK, but all addresses were deferred
3466 because of a non-recipient, non-host failure, that is, a
3467 4xx response to MAIL FROM, DATA, or ".". This is a defer
3468 that is specific to the message.
3469 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
3470 a second attempt after TLS initialization fails
3472 Returns: OK - the connection was made and the delivery attempted;
3473 the result for each address is in its data block.
3474 DEFER - the connection could not be made, or something failed
3475 while setting up the SMTP session, or there was a
3476 non-message-specific error, such as a timeout.
3477 ERROR - a filter command is specified for this transport,
3478 and there was a problem setting it up; OR helo_data
3479 or add_headers or authenticated_sender is specified
3480 for this transport, and the string failed to expand
3482 For all non-OK returns the first addr of the list carries the
3483 time taken for the attempt.
3487 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
3488 uschar *interface, transport_instance *tblock,
3489 BOOL *message_defer, BOOL suppress_tls)
3491 smtp_transport_options_block * ob = SOB tblock->options_block;
3496 BOOL pass_message = FALSE;
3497 uschar *message = NULL;
3498 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
3499 smtp_context * sx = store_get(sizeof(*sx), TRUE); /* tainted, for the data buffers */
3503 BOOL tcw_done = FALSE, tcw = FALSE;
3505 *message_defer = FALSE;
3507 memset(sx, 0, sizeof(*sx));
3508 sx->addrlist = addrlist;
3509 sx->conn_args.host = host;
3510 sx->conn_args.host_af = host_af,
3512 sx->conn_args.interface = interface;
3513 sx->helo_data = NULL;
3514 sx->conn_args.tblock = tblock;
3515 /* sx->verify = FALSE; */
3516 gettimeofday(&sx->delivery_start, NULL);
3517 sx->sync_addr = sx->first_addr = addrlist;
3524 /* Get the channel set up ready for a message, MAIL FROM being the next
3525 SMTP command to send. */
3527 if ((rc = smtp_setup_conn(sx, suppress_tls)) != OK)
3529 timesince(&addrlist->delivery_time, &sx->delivery_start);
3535 /* If the connection used DANE, ignore for now any addresses with incompatible
3536 domains. The SNI has to be the domain. Arrange a whole new TCP conn later,
3537 just in case only TLS isn't enough. */
3539 if (sx->conn_args.dane)
3541 const uschar * dane_domain = sx->first_addr->domain;
3543 for (address_item * a = sx->first_addr->next; a; a = a->next)
3544 if ( a->transport_return == PENDING_DEFER
3545 && Ustrcmp(dane_domain, a->domain) != 0)
3547 DEBUG(D_transport) debug_printf("DANE: holding %s for later\n", a->domain);
3549 a->transport_return = DANE;
3554 /* If there is a filter command specified for this transport, we can now
3555 set it up. This cannot be done until the identity of the host is known. */
3557 if (tblock->filter_command)
3559 transport_filter_timeout = tblock->filter_timeout;
3561 /* On failure, copy the error to all addresses, abandon the SMTP call, and
3564 if (!transport_set_up_command(&transport_filter_argv,
3565 tblock->filter_command, TRUE, DEFER, addrlist,
3566 string_sprintf("%.50s transport", tblock->name), NULL))
3568 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
3569 FALSE, &sx->delivery_start);
3574 if ( transport_filter_argv
3575 && *transport_filter_argv
3576 && **transport_filter_argv
3577 && sx->peer_offered & OPTION_CHUNKING
3578 #ifndef DISABLE_DKIM
3579 /* When dkim signing, chunking is handled even with a transport-filter */
3580 && !(ob->dkim.dkim_private_key && ob->dkim.dkim_domain && ob->dkim.dkim_selector)
3581 && !ob->dkim.force_bodyhash
3585 sx->peer_offered &= ~OPTION_CHUNKING;
3586 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
3590 /* For messages that have more than the maximum number of envelope recipients,
3591 we want to send several transactions down the same SMTP connection. (See
3592 comments in deliver.c as to how this reconciles, heuristically, with
3593 remote_max_parallel.) This optimization was added to Exim after the following
3594 code was already working. The simplest way to put it in without disturbing the
3595 code was to use a goto to jump back to this point when there is another
3596 transaction to handle. */
3599 sx->from_addr = return_path;
3600 sx->sync_addr = sx->first_addr;
3602 sx->send_rset = TRUE;
3603 sx->completed_addr = FALSE;
3606 /* If we are a continued-connection-after-verify the MAIL and RCPT
3607 commands were already sent; do not re-send but do mark the addrs as
3608 having been accepted up to RCPT stage. A traditional cont-conn
3609 always has a sequence number greater than one. */
3611 if (continue_hostname && continue_sequence == 1)
3613 /* sx->pending_MAIL = FALSE; */
3615 /* sx->next_addr = NULL; */
3617 for (address_item * addr = addrlist; addr; addr = addr->next)
3618 addr->transport_return = PENDING_OK;
3622 /* Initiate a message transfer. */
3624 switch(smtp_write_mail_and_rcpt_cmds(sx, &yield))
3627 case -1: case -2: goto RESPONSE_FAILED;
3628 case -3: goto END_OFF;
3629 case -4: goto SEND_QUIT;
3630 default: goto SEND_FAILED;
3633 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3634 permanently or temporarily. We should have flushed and synced after the last
3642 for (a = sx->first_addr, cnt = 0; a && cnt < sx->max_rcpt; a = a->next, cnt++)
3643 if (a->transport_return != PENDING_OK)
3645 /*XXX could we find a better errno than 0 here? */
3646 set_errno_nohost(addrlist, 0, a->message, FAIL,
3647 testflag(a, af_pass_message), &sx->delivery_start);
3654 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3655 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3656 have a good recipient buffered up if we are pipelining. We don't want to waste
3657 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3658 are pipelining. The responses are all handled by sync_responses().
3659 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3662 if ( !(sx->peer_offered & OPTION_CHUNKING)
3663 && (sx->ok || (pipelining_active && !mua_wrapper)))
3665 int count = smtp_write_command(sx, SCMD_FLUSH, "DATA\r\n");
3667 if (count < 0) goto SEND_FAILED;
3668 switch(sync_responses(sx, count, sx->ok ? +1 : -1))
3670 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3671 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3674 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3675 if (!sx->lmtp) sx->completed_addr = TRUE; /* can't tell about progress yet */
3676 case 0: break; /* No 2xx or 5xx, but no probs */
3678 case -1: goto END_OFF; /* Timeout on RCPT */
3680 #ifndef DISABLE_PIPE_CONNECT
3681 case -5: /* TLS first-read error */
3682 case -4: HDEBUG(D_transport)
3683 debug_printf("failed reaping pipelined cmd responses\n");
3685 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3687 pipelining_active = FALSE;
3688 data_command = string_copy(big_buffer); /* Save for later error message */
3691 /* If there were no good recipients (but otherwise there have been no
3692 problems), just set ok TRUE, since we have handled address-specific errors
3693 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3694 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3695 well as body. Set the appropriate timeout value to be used for each chunk.
3696 (Haven't been able to make it work using select() for writing yet.) */
3699 && (!(sx->peer_offered & OPTION_CHUNKING) || !pipelining_active))
3701 /* Save the first address of the next batch. */
3702 sx->first_addr = sx->next_addr;
3708 transport_ctx tctx = {
3709 .u = {.fd = sx->cctx.sock}, /*XXX will this need TLS info? */
3712 .check_string = US".",
3713 .escape_string = US"..", /* Escaping strings */
3715 topt_use_crlf | topt_escape_headers
3716 | (tblock->body_only ? topt_no_headers : 0)
3717 | (tblock->headers_only ? topt_no_body : 0)
3718 | (tblock->return_path_add ? topt_add_return_path : 0)
3719 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3720 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3723 /* If using CHUNKING we need a callback from the generic transport
3724 support to us, for the sending of BDAT smtp commands and the reaping
3725 of responses. The callback needs a whole bunch of state so set up
3726 a transport-context structure to be passed around. */
3728 if (sx->peer_offered & OPTION_CHUNKING)
3730 tctx.check_string = tctx.escape_string = NULL;
3731 tctx.options |= topt_use_bdat;
3732 tctx.chunk_cb = smtp_chunk_cmd_callback;
3733 sx->pending_BDAT = FALSE;
3734 sx->good_RCPT = sx->ok;
3736 tctx.smtp_context = sx;
3739 tctx.options |= topt_end_dot;
3741 /* Save the first address of the next batch. */
3742 sx->first_addr = sx->next_addr;
3744 /* Responses from CHUNKING commands go in buffer. Otherwise,
3745 there has not been a response. */
3749 sigalrm_seen = FALSE;
3750 transport_write_timeout = ob->data_timeout;
3751 smtp_command = US"sending data block"; /* For error messages */
3752 DEBUG(D_transport|D_v)
3753 if (sx->peer_offered & OPTION_CHUNKING)
3754 debug_printf(" will write message using CHUNKING\n");
3756 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3757 transport_count = 0;
3759 #ifndef DISABLE_DKIM
3761 # ifdef MEASURE_TIMING
3763 gettimeofday(&t0, NULL);
3765 dkim_exim_sign_init();
3766 # ifdef EXPERIMENTAL_ARC
3768 uschar * s = ob->arc_sign;
3771 if (!(ob->dkim.arc_signspec = s = expand_string(s)))
3773 if (!f.expand_string_forcedfail)
3775 message = US"failed to expand arc_sign";
3782 /* Ask dkim code to hash the body for ARC */
3783 (void) arc_ams_setup_sign_bodyhash();
3784 ob->dkim.force_bodyhash = TRUE;
3789 # ifdef MEASURE_TIMING
3790 report_time_since(&t0, US"dkim_exim_sign_init (delta)");
3795 /* See if we can pipeline QUIT. Reasons not to are
3796 - pipelining not active
3797 - not ok to send quit
3798 - errors in amtp transation responses
3799 - more addrs to send for this message or this host
3800 - this message was being retried
3801 - more messages for this host
3802 If we can, we want the message-write to not flush (the tail end of) its data out. */
3804 if ( sx->pipelining_used
3805 && (sx->ok && sx->completed_addr || sx->peer_offered & OPTION_CHUNKING)
3807 && !(sx->first_addr || f.continue_more)
3808 && f.deliver_firsttime
3811 smtp_compare_t t_compare =
3812 {.tblock = tblock, .current_sender_address = sender_address};
3817 ( tls_out.active.sock < 0 && !continue_proxy_cipher
3818 || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
3822 transport_check_waiting(tblock->name, host->name,
3823 tblock->connection_max_messages, new_message_id,
3824 (oicf)smtp_are_same_identities, (void*)&t_compare);
3827 HDEBUG(D_transport) debug_printf("will pipeline QUIT\n");
3828 tctx.options |= topt_no_flush;
3832 #ifndef DISABLE_DKIM
3833 sx->ok = dkim_transport_write_message(&tctx, &ob->dkim, CUSS &message);
3835 sx->ok = transport_write_message(&tctx, 0);
3838 /* transport_write_message() uses write() because it is called from other
3839 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3840 it can exit with "Broken pipe" as its error. This really means that the
3841 socket got closed at the far end. */
3843 transport_write_timeout = 0; /* for subsequent transports */
3845 /* Failure can either be some kind of I/O disaster (including timeout),
3846 or the failure of a transport filter or the expansion of added headers.
3847 Or, when CHUNKING, it can be a protocol-detected failure. */
3850 if (message) goto SEND_FAILED;
3851 else goto RESPONSE_FAILED;
3853 /* We used to send the terminating "." explicitly here, but because of
3854 buffering effects at both ends of TCP/IP connections, you don't gain
3855 anything by keeping it separate, so it might as well go in the final
3856 data buffer for efficiency. This is now done by setting the topt_end_dot
3859 smtp_command = US"end of data";
3861 /* If we can pipeline a QUIT with the data them send it now. If a new message
3862 for this host appeared in the queue while data was being sent, we will not see
3863 it and it will have to wait for a queue run. If there was one but another
3864 thread took it, we might attempt to send it - but locking of spoolfiles will
3865 detect that. Use _MORE to get QUIT in FIN segment. */
3867 if (tcw_done && !tcw)
3869 /*XXX jgh 2021/03/10 google et. al screwup. G, at least, sends TCP FIN in response to TLS
3870 close-notify. Under TLS 1.3, violating RFC.
3871 However, TLS 1.2 does not have half-close semantics. */
3873 if ( sx->cctx.tls_ctx
3874 #if 0 && !defined(DISABLE_TLS)
3875 && Ustrcmp(tls_out.ver, "TLS1.3") != 0
3877 || !f.deliver_firsttime
3879 { /* Send QUIT now and not later */
3880 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
3881 sx->send_quit = FALSE;
3884 { /* add QUIT to the output buffer */
3885 (void)smtp_write_command(sx, SCMD_MORE, "QUIT\r\n");
3886 sx->send_quit = FALSE; /* avoid sending it later */
3889 if (sx->cctx.tls_ctx) /* need to send TLS Cloe Notify */
3891 # ifdef EXIM_TCP_CORK /* Use _CORK to get Close Notify in FIN segment */
3892 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, EXIM_TCP_CORK, US &on, sizeof(on));
3894 tls_shutdown_wr(sx->cctx.tls_ctx);
3895 sx->send_tlsclose = FALSE; /* avoid later repeat */
3898 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(shutdown)>>\n");
3899 shutdown(sx->cctx.sock, SHUT_WR); /* flush output buffer, with TCP FIN */
3903 if (sx->peer_offered & OPTION_CHUNKING && sx->cmd_count > 1)
3905 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3906 switch(sync_responses(sx, sx->cmd_count-1, 0))
3908 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3909 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3912 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3913 if (!sx->lmtp) sx->completed_addr = TRUE; /* can't tell about progress yet */
3914 case 0: break; /* No 2xx or 5xx, but no probs */
3916 case -1: goto END_OFF; /* Timeout on RCPT */
3918 #ifndef DISABLE_PIPE_CONNECT
3919 case -5: /* TLS first-read error */
3920 case -4: HDEBUG(D_transport)
3921 debug_printf("failed reaping pipelined cmd responses\n");
3923 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3927 #ifndef DISABLE_PRDR
3928 /* For PRDR we optionally get a partial-responses warning followed by the
3929 individual responses, before going on with the overall response. If we don't
3930 get the warning then deal with per non-PRDR. */
3934 sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '3', ob->final_timeout);
3935 if (!sx->ok && errno == 0) switch(sx->buffer[0])
3937 case '2': sx->prdr_active = FALSE;
3940 case '4': errno = ERRNO_DATA4XX;
3941 addrlist->more_errno |=
3942 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3949 /* For non-PRDR SMTP, we now read a single response that applies to the
3950 whole message. If it is OK, then all the addresses have been delivered. */
3954 sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3956 if (!sx->ok && errno == 0 && sx->buffer[0] == '4')
3958 errno = ERRNO_DATA4XX;
3959 addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3963 /* For LMTP, we get back a response for every RCPT command that we sent;
3964 some may be accepted and some rejected. For those that get a response, their
3965 status is fixed; any that are accepted have been handed over, even if later
3966 responses crash - at least, that's how I read RFC 2033.
3968 If all went well, mark the recipient addresses as completed, record which
3969 host/IPaddress they were delivered to, and cut out RSET when sending another
3970 message down the same channel. Write the completed addresses to the journal
3971 now so that they are recorded in case there is a crash of hardware or
3972 software before the spool gets updated. Also record the final SMTP
3973 confirmation if needed (for SMTP only). */
3978 struct timeval delivery_time;
3980 uschar * conf = NULL;
3982 timesince(&delivery_time, &sx->delivery_start);
3983 sx->send_rset = FALSE;
3984 pipelining_active = FALSE;
3986 /* Set up confirmation if needed - applies only to SMTP */
3989 #ifdef DISABLE_EVENT
3990 LOGGING(smtp_confirmation) &&
3995 const uschar * s = string_printing(sx->buffer);
3996 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3997 conf = s == sx->buffer ? US string_copy(s) : US s;
4000 /* Process all transported addresses - for LMTP or PRDR, read a status for
4001 each one. We used to drop out at first_addr, until someone returned a 452
4002 followed by a 250... and we screwed up the accepted addresses. */
4004 for (address_item * addr = addrlist; addr; addr = addr->next)
4006 if (addr->transport_return != PENDING_OK) continue;
4008 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
4009 remaining addresses. Otherwise, it's a return code for just the one
4010 address. For temporary errors, add a retry item for the address so that
4011 it doesn't get tried again too soon. */
4013 #ifndef DISABLE_PRDR
4014 if (sx->lmtp || sx->prdr_active)
4019 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
4022 if (errno != 0 || sx->buffer[0] == 0) goto RESPONSE_FAILED;
4023 addr->message = string_sprintf(
4024 #ifndef DISABLE_PRDR
4025 "%s error after %s: %s", sx->prdr_active ? "PRDR":"LMTP",
4027 "LMTP error after %s: %s",
4029 data_command, string_printing(sx->buffer));
4030 setflag(addr, af_pass_message); /* Allow message to go to user */
4031 if (sx->buffer[0] == '5')
4032 addr->transport_return = FAIL;
4035 errno = ERRNO_DATA4XX;
4036 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
4037 addr->transport_return = DEFER;
4038 #ifndef DISABLE_PRDR
4039 if (!sx->prdr_active)
4041 retry_add_item(addr, addr->address_retry_key, 0);
4045 sx->completed_addr = TRUE; /* NOW we can set this flag */
4046 if (LOGGING(smtp_confirmation))
4048 const uschar *s = string_printing(sx->buffer);
4049 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
4050 conf = (s == sx->buffer) ? US string_copy(s) : US s;
4054 /* SMTP, or success return from LMTP for this address. Pass back the
4055 actual host that was used. */
4057 addr->transport_return = OK;
4058 addr->host_used = host;
4059 addr->delivery_time = delivery_time;
4060 addr->special_action = flag;
4061 addr->message = conf;
4063 if (tcp_out_fastopen)
4065 setflag(addr, af_tcp_fastopen_conn);
4066 if (tcp_out_fastopen >= TFO_USED_NODATA) setflag(addr, af_tcp_fastopen);
4067 if (tcp_out_fastopen >= TFO_USED_DATA) setflag(addr, af_tcp_fastopen_data);
4069 if (sx->pipelining_used) setflag(addr, af_pipelining);
4070 #ifndef DISABLE_PIPE_CONNECT
4071 if (sx->early_pipe_active) setflag(addr, af_early_pipe);
4073 #ifndef DISABLE_PRDR
4074 if (sx->prdr_active) setflag(addr, af_prdr_used);
4076 if (sx->peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
4079 #ifndef DISABLE_PRDR
4080 if (!sx->prdr_active)
4083 /* Update the journal. For homonymic addresses, use the base address plus
4084 the transport name. See lots of comments in deliver.c about the reasons
4085 for the complications when homonyms are involved. Just carry on after
4086 write error, as it may prove possible to update the spool file later. */
4088 if (testflag(addr, af_homonym))
4089 sprintf(CS sx->buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
4091 sprintf(CS sx->buffer, "%.500s\n", addr->unique);
4093 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx->buffer);
4094 len = Ustrlen(CS sx->buffer);
4095 if (write(journal_fd, sx->buffer, len) != len)
4096 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
4097 "%s: %s", sx->buffer, strerror(errno));
4101 #ifndef DISABLE_PRDR
4102 if (sx->prdr_active)
4104 const uschar * overall_message;
4106 /* PRDR - get the final, overall response. For any non-success
4107 upgrade all the address statuses. */
4109 sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
4113 if(errno == 0 && sx->buffer[0] == '4')
4115 errno = ERRNO_DATA4XX;
4116 addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
4118 for (address_item * addr = addrlist; addr != sx->first_addr; addr = addr->next)
4119 if (sx->buffer[0] == '5' || addr->transport_return == OK)
4120 addr->transport_return = PENDING_OK; /* allow set_errno action */
4121 goto RESPONSE_FAILED;
4124 /* Append the overall response to the individual PRDR response for logging
4125 and update the journal, or setup retry. */
4127 overall_message = string_printing(sx->buffer);
4128 for (address_item * addr = addrlist; addr != sx->first_addr; addr = addr->next)
4129 if (addr->transport_return == OK)
4130 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
4132 for (address_item * addr = addrlist; addr != sx->first_addr; addr = addr->next)
4133 if (addr->transport_return == OK)
4135 if (testflag(addr, af_homonym))
4136 sprintf(CS sx->buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
4138 sprintf(CS sx->buffer, "%.500s\n", addr->unique);
4140 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx->buffer);
4141 len = Ustrlen(CS sx->buffer);
4142 if (write(journal_fd, sx->buffer, len) != len)
4143 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
4144 "%s: %s", sx->buffer, strerror(errno));
4146 else if (addr->transport_return == DEFER)
4147 retry_add_item(addr, addr->address_retry_key, -2);
4151 /* Ensure the journal file is pushed out to disk. */
4153 if (EXIMfsync(journal_fd) < 0)
4154 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
4160 /* Handle general (not specific to one address) failures here. The value of ok
4161 is used to skip over this code on the falling through case. A timeout causes a
4162 deferral. Other errors may defer or fail according to the response code, and
4163 may set up a special errno value, e.g. after connection chopped, which is
4164 assumed if errno == 0 and there is no text in the buffer. If control reaches
4165 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
4166 the problem is not related to this specific message. */
4171 uschar * set_message;
4177 /* Clear send_quit flag if needed. Do not set. */
4178 sx->send_quit &= check_response(host, &save_errno, addrlist->more_errno,
4179 sx->buffer, &code, &message, &pass_message);
4187 message = string_sprintf("send() to %s [%s] failed: %s",
4188 host->name, host->address, message ? message : US strerror(save_errno));
4189 sx->send_quit = FALSE;
4197 sx->ok = FALSE; /* For when reached by GOTO */
4198 set_message = message;
4200 /* We want to handle timeouts after MAIL or "." and loss of connection after
4201 "." specially. They can indicate a problem with the sender address or with
4202 the contents of the message rather than a real error on the connection. These
4203 cases are treated in the same way as a 4xx response. This next bit of code
4204 does the classification. */
4211 message_error = TRUE;
4215 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
4216 Ustrncmp(smtp_command,"end ",4) == 0;
4219 case ERRNO_SMTPCLOSED:
4220 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
4224 message_error = FALSE;
4228 /* Handle the cases that are treated as message errors. These are:
4230 (a) negative response or timeout after MAIL
4231 (b) negative response after DATA
4232 (c) negative response or timeout or dropped connection after "."
4233 (d) utf8 support required and not offered
4235 It won't be a negative response or timeout after RCPT, as that is dealt
4236 with separately above. The action in all cases is to set an appropriate
4237 error code for all the addresses, but to leave yield set to OK because the
4238 host itself has not failed. Of course, it might in practice have failed
4239 when we've had a timeout, but if so, we'll discover that at the next
4240 delivery attempt. For a temporary error, set the message_defer flag, and
4241 write to the logs for information if this is not the last host. The error
4242 for the last host will be logged as part of the address's log line. */
4246 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
4248 /* If there's an errno, the message contains just the identity of
4253 else /* Anything other than 5 is treated as temporary */
4257 message = US string_sprintf("%s: %s", message, strerror(save_errno));
4259 write_logs(host, message, sx->first_addr ? sx->first_addr->basic_errno : 0);
4261 *message_defer = TRUE;
4264 DEBUG(D_transport) if (sx->cctx.sock >= 0)
4267 if (ioctl(sx->cctx.sock, TIOCOUTQ, &n) == 0)
4268 debug_printf("%d bytes remain in socket output buffer\n", n);
4272 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4273 ".", or some other transportation error. We defer all addresses and yield
4274 DEFER, except for the case of failed add_headers expansion, or a transport
4275 filter failure, when the yield should be ERROR, to stop it trying other
4280 #ifndef DISABLE_PIPE_CONNECT
4281 /* If we were early-pipelinng and the actual EHLO response did not match
4282 the cached value we assumed, we could have detected it and passed a
4283 custom errno through to here. It would be nice to RSET and retry right
4284 away, but to reliably do that we eould need an extra synch point before
4285 we committed to data and that would discard half the gained roundrips.
4286 Or we could summarily drop the TCP connection. but that is also ugly.
4287 Instead, we ignore the possibility (having freshened the cache) and rely
4288 on the server telling us with a nonmessage error if we have tried to
4289 do something it no longer supports. */
4292 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
4293 save_errno == ERRNO_FILTER_FAIL) ? ERROR : DEFER;
4297 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host,
4298 #ifdef EXPERIMENTAL_DSN_INFO
4299 sx->smtp_greeting, sx->helo_response,
4301 &sx->delivery_start);
4304 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4305 SMTP session tidily. However, if there were too many addresses to send in one
4306 message (indicated by first_addr being non-NULL) we want to carry on with the
4307 rest of them. Also, it is desirable to send more than one message down the SMTP
4308 connection if there are several waiting, provided we haven't already sent so
4309 many as to hit the configured limit. The function transport_check_waiting looks
4310 for a waiting message and returns its id. Then transport_pass_socket tries to
4311 set up a continued delivery by passing the socket on to another process. The
4312 variable send_rset is FALSE if a message has just been successfully transferred.
4314 If we are already sending down a continued channel, there may be further
4315 addresses not yet delivered that are aimed at the same host, but which have not
4316 been passed in this run of the transport. In this case, continue_more will be
4317 true, and all we should do is send RSET if necessary, and return, leaving the
4320 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4321 do not want to continue with other messages down the same channel, because that
4322 can lead to looping between two or more messages, all with the same,
4323 temporarily failing address(es). [The retry information isn't updated yet, so
4324 new processes keep on trying.] We probably also don't want to try more of this
4325 message's addresses either.
4327 If we have started a TLS session, we have to end it before passing the
4328 connection to a new process. However, not all servers can handle this (Exim
4329 can), so we do not pass such a connection on if the host matches
4330 hosts_nopass_tls. */
4333 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4334 "yield=%d first_address is %sNULL\n", sx->ok, sx->send_quit,
4335 sx->send_rset, f.continue_more, yield, sx->first_addr ? "not " : "");
4337 if (sx->completed_addr && sx->ok && sx->send_quit)
4339 smtp_compare_t t_compare =
4340 {.tblock = tblock, .current_sender_address = sender_address};
4342 if ( sx->first_addr /* more addrs for this message */
4343 || f.continue_more /* more addrs for continued-host */
4344 || tcw_done && tcw /* more messages for host */
4347 ( tls_out.active.sock < 0 && !continue_proxy_cipher
4348 || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
4352 transport_check_waiting(tblock->name, host->name,
4353 tblock->connection_max_messages, new_message_id,
4354 (oicf)smtp_are_same_identities, (void*)&t_compare)
4361 if (! (sx->ok = smtp_write_command(sx, SCMD_FLUSH, "RSET\r\n") >= 0))
4363 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
4364 host->address, strerror(errno));
4365 sx->send_quit = FALSE;
4367 else if (! (sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
4368 '2', ob->command_timeout)))
4371 sx->send_quit = check_response(host, &errno, 0, sx->buffer, &code, &msg,
4375 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
4376 host->name, host->address, msg);
4380 /* Either RSET was not needed, or it succeeded */
4387 int socket_fd = sx->cctx.sock;
4389 if (sx->first_addr) /* More addresses still to be sent */
4390 { /* for this message */
4391 continue_sequence++; /* for consistency */
4392 clearflag(sx->first_addr, af_new_conn);
4393 setflag(sx->first_addr, af_cont_conn); /* Causes * in logging */
4394 pipelining_active = sx->pipelining_used; /* was cleared at DATA */
4398 /* Unless caller said it already has more messages listed for this host,
4399 pass the connection on to a new Exim process (below, the call to
4400 transport_pass_socket). If the caller has more ready, just return with
4401 the connection still open. */
4404 if (tls_out.active.sock >= 0)
4405 if ( f.continue_more
4406 || verify_check_given_host(CUSS &ob->hosts_noproxy_tls, host) == OK)
4408 /* Before passing the socket on, or returning to caller with it still
4409 open, we must shut down TLS. Not all MTAs allow for the continuation
4410 of the SMTP session when TLS is shut down. We test for this by sending
4411 a new EHLO. If we don't get a good response, we don't attempt to pass
4414 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4415 sx->send_tlsclose = FALSE;
4416 sx->cctx.tls_ctx = NULL;
4417 tls_out.active.sock = -1;
4418 smtp_peer_options = smtp_peer_options_wrap;
4420 && smtp_write_command(sx, SCMD_FLUSH, "EHLO %s\r\n", sx->helo_data)
4422 && smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
4423 '2', ob->command_timeout);
4425 if (sx->ok && f.continue_more)
4426 goto TIDYUP; /* More addresses for another run */
4430 /* Set up a pipe for proxying TLS for the new transport process */
4432 smtp_peer_options |= OPTION_TLS;
4433 if ((sx->ok = socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
4436 set_errno(sx->first_addr, errno, US"internal allocation problem",
4438 # ifdef EXPERIMENTAL_DSN_INFO
4439 sx->smtp_greeting, sx->helo_response,
4441 &sx->delivery_start);
4445 if (f.continue_more)
4446 goto TIDYUP; /* More addresses for another run */
4448 /* If the socket is successfully passed, we mustn't send QUIT (or
4449 indeed anything!) from here. */
4451 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4452 propagate it from the initial
4454 if (sx->ok && transport_pass_socket(tblock->name, host->name,
4455 host->address, new_message_id, socket_fd))
4457 sx->send_quit = FALSE;
4459 /* We have passed the client socket to a fresh transport process.
4460 If TLS is still active, we need to proxy it for the transport we
4461 just passed the baton to. Fork a child to to do it, and return to
4462 get logging done asap. Which way to place the work makes assumptions
4463 about post-fork prioritisation which may not hold on all platforms. */
4465 if (tls_out.active.sock >= 0)
4467 int pid = exim_fork(US"tls-proxy-interproc");
4468 if (pid == 0) /* child; fork again to disconnect totally */
4470 /* does not return */
4471 smtp_proxy_tls(sx->cctx.tls_ctx, sx->buffer, sizeof(sx->buffer), pfd,
4472 ob->command_timeout);
4475 if (pid > 0) /* parent */
4478 /* tidy the inter-proc to disconn the proxy proc */
4479 waitpid(pid, NULL, 0);
4480 tls_close(sx->cctx.tls_ctx, TLS_NO_SHUTDOWN);
4481 sx->cctx.tls_ctx = NULL;
4482 (void)close(sx->cctx.sock);
4484 continue_transport = NULL;
4485 continue_hostname = NULL;
4488 log_write(0, LOG_PANIC_DIE, "fork failed");
4494 /* If RSET failed and there are addresses left, they get deferred. */
4496 set_errno(sx->first_addr, errno, msg, DEFER, FALSE, host,
4497 #ifdef EXPERIMENTAL_DSN_INFO
4498 sx->smtp_greeting, sx->helo_response,
4500 &sx->delivery_start);
4504 /* End off tidily with QUIT unless the connection has died or the socket has
4505 been passed to another process. */
4509 { /* Use _MORE to get QUIT in FIN segment */
4510 (void)smtp_write_command(sx, SCMD_MORE, "QUIT\r\n");
4512 if (sx->cctx.tls_ctx)
4514 # ifdef EXIM_TCP_CORK /* Use _CORK to get TLS Close Notify in FIN segment */
4515 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, EXIM_TCP_CORK, US &on, sizeof(on));
4517 tls_shutdown_wr(sx->cctx.tls_ctx);
4518 sx->send_tlsclose = FALSE;
4525 /* Close the socket, and return the appropriate value, first setting
4526 works because the NULL setting is passed back to the calling process, and
4527 remote_max_parallel is forced to 1 when delivering over an existing connection,
4529 If all went well and continue_more is set, we shouldn't actually get here if
4530 there are further addresses, as the return above will be taken. However,
4531 writing RSET might have failed, or there may be other addresses whose hosts are
4532 specified in the transports, and therefore not visible at top level, in which
4533 case continue_more won't get set. */
4537 /* This flushes data queued in the socket, being the QUIT and any TLS Close,
4538 sending them along with the client FIN flag. Us (we hope) sending FIN first
4539 means we (client) take the TIME_WAIT state, so the server (which likely has a
4540 higher connection rate) does not have to. */
4542 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(shutdown)>>\n");
4543 shutdown(sx->cctx.sock, SHUT_WR);
4546 if (sx->send_quit || tcw_done && !tcw)
4548 /* Wait for (we hope) ack of our QUIT, and a server FIN. Discard any data
4549 received, then discard the socket. Any packet received after then, or receive
4550 data still in the socket, will get a RST - hence the pause/drain. */
4552 /* Reap the response to QUIT, timing out after one second */
4553 (void) smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2', 1);
4555 if (sx->cctx.tls_ctx)
4559 /* Reap the TLS Close Notify from the server, timing out after one second */
4560 sigalrm_seen = FALSE;
4563 n = tls_read(sx->cctx.tls_ctx, sx->inbuffer, sizeof(sx->inbuffer));
4564 while (!sigalrm_seen && n > 0);
4567 # ifdef EXIM_TCP_CORK
4568 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, EXIM_TCP_CORK, US &on, sizeof(on));
4570 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4571 sx->cctx.tls_ctx = NULL;
4575 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
4576 for (int i = 16, n; /* drain socket */
4577 (n = read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer))) > 0 && i > 0;
4578 i--) HDEBUG(D_transport|D_acl|D_v)
4581 debug_printf_indent(" SMTP(drain %d bytes)<< %.*s\n", n, m, sx->inbuffer);
4582 for (m = 0; m < n; m++)
4583 debug_printf("0x%02x\n", sx->inbuffer[m]);
4586 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
4587 (void)close(sx->cctx.sock);
4589 continue_transport = NULL;
4590 continue_hostname = NULL;
4592 #ifndef DISABLE_EVENT
4593 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
4599 sx->first_addr = NULL;
4600 for (address_item * a = sx->addrlist->next; a; a = a->next)
4601 if (a->transport_return == DANE)
4603 a->transport_return = PENDING_DEFER;
4604 if (!sx->first_addr)
4606 /* Remember the new start-point in the addrlist, for smtp_setup_conn()
4607 to get the domain string for SNI */
4610 clearflag(a, af_cont_conn);
4611 setflag(a, af_new_conn); /* clear * from logging */
4612 DEBUG(D_transport) debug_printf("DANE: go-around for %s\n", a->domain);
4615 continue_sequence = 1; /* for consistency */
4620 continue_transport = NULL;
4621 continue_hostname = NULL;
4626 if (dane_held) for (address_item * a = sx->addrlist->next; a; a = a->next)
4627 if (a->transport_return == DANE)
4628 a->transport_return = PENDING_DEFER;
4636 /*************************************************
4637 * Closedown entry point *
4638 *************************************************/
4640 /* This function is called when exim is passed an open smtp channel
4641 from another incarnation, but the message which it has been asked
4642 to deliver no longer exists. The channel is on stdin.
4644 We might do fancy things like looking for another message to send down
4645 the channel, but if the one we sought has gone, it has probably been
4646 delivered by some other process that itself will seek further messages,
4647 so just close down our connection.
4649 Argument: pointer to the transport instance block
4654 smtp_transport_closedown(transport_instance *tblock)
4656 smtp_transport_options_block * ob = SOB tblock->options_block;
4657 client_conn_ctx cctx;
4660 uschar inbuffer[4096];
4661 uschar outbuffer[16];
4663 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4664 cctx.sock = fileno(stdin);
4665 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
4667 sx.inblock.cctx = &cctx;
4668 sx.inblock.buffer = inbuffer;
4669 sx.inblock.buffersize = sizeof(inbuffer);
4670 sx.inblock.ptr = inbuffer;
4671 sx.inblock.ptrend = inbuffer;
4673 sx.outblock.cctx = &cctx;
4674 sx.outblock.buffersize = sizeof(outbuffer);
4675 sx.outblock.buffer = outbuffer;
4676 sx.outblock.ptr = outbuffer;
4677 sx.outblock.cmd_count = 0;
4678 sx.outblock.authenticating = FALSE;
4680 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4681 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
4682 (void)close(cctx.sock);
4687 /*************************************************
4688 * Prepare addresses for delivery *
4689 *************************************************/
4691 /* This function is called to flush out error settings from previous delivery
4692 attempts to other hosts. It also records whether we got here via an MX record
4693 or not in the more_errno field of the address. We are interested only in
4694 addresses that are still marked DEFER - others may have got delivered to a
4695 previously considered IP address. Set their status to PENDING_DEFER to indicate
4696 which ones are relevant this time.
4699 addrlist the list of addresses
4700 host the host we are delivering to
4702 Returns: the first address for this delivery
4705 static address_item *
4706 prepare_addresses(address_item *addrlist, host_item *host)
4708 address_item *first_addr = NULL;
4709 for (address_item * addr = addrlist; addr; addr = addr->next)
4710 if (addr->transport_return == DEFER)
4712 if (!first_addr) first_addr = addr;
4713 addr->transport_return = PENDING_DEFER;
4714 addr->basic_errno = 0;
4715 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
4716 addr->message = NULL;
4718 addr->cipher = NULL;
4719 addr->ourcert = NULL;
4720 addr->peercert = NULL;
4721 addr->peerdn = NULL;
4722 addr->ocsp = OCSP_NOT_REQ;
4723 addr->tlsver = NULL;
4725 #ifdef EXPERIMENTAL_DSN_INFO
4726 addr->smtp_greeting = NULL;
4727 addr->helo_response = NULL;
4735 /*************************************************
4736 * Main entry point *
4737 *************************************************/
4739 /* See local README for interface details. As this is a remote transport, it is
4740 given a chain of addresses to be delivered in one connection, if possible. It
4741 always returns TRUE, indicating that each address has its own independent
4742 status set, except if there is a setting up problem, in which case it returns
4746 smtp_transport_entry(
4747 transport_instance *tblock, /* data for this instantiation */
4748 address_item *addrlist) /* addresses we are working on */
4751 int hosts_defer = 0;
4753 int hosts_looked_up = 0;
4754 int hosts_retry = 0;
4755 int hosts_serial = 0;
4756 int hosts_total = 0;
4757 int total_hosts_tried = 0;
4758 BOOL expired = TRUE;
4759 uschar *expanded_hosts = NULL;
4761 uschar *tid = string_sprintf("%s transport", tblock->name);
4762 smtp_transport_options_block *ob = SOB tblock->options_block;
4763 host_item *hostlist = addrlist->host_list;
4764 host_item *host = NULL;
4768 debug_printf("%s transport entered\n", tblock->name);
4769 for (address_item * addr = addrlist; addr; addr = addr->next)
4770 debug_printf(" %s\n", addr->address);
4773 debug_printf("hostlist:\n");
4774 for (host_item * host = hostlist; host; host = host->next)
4775 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
4777 if (continue_hostname)
4778 debug_printf("already connected to %s [%s] (on fd %d)\n",
4779 continue_hostname, continue_host_address,
4780 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
4783 /* Check the restrictions on line length */
4785 if (max_received_linelength > ob->message_linelength_limit)
4788 gettimeofday(&now, NULL);
4790 for (address_item * addr = addrlist; addr; addr = addr->next)
4791 if (addr->transport_return == DEFER)
4792 addr->transport_return = PENDING_DEFER;
4794 set_errno_nohost(addrlist, ERRNO_SMTPFORMAT,
4795 US"message has lines too long for transport", FAIL, TRUE, &now);
4799 /* Set the flag requesting that these hosts be added to the waiting
4800 database if the delivery fails temporarily or if we are running with
4801 queue_smtp or a 2-stage queue run. This gets unset for certain
4802 kinds of error, typically those that are specific to the message. */
4804 update_waiting = TRUE;
4806 /* If a host list is not defined for the addresses - they must all have the
4807 same one in order to be passed to a single transport - or if the transport has
4808 a host list with hosts_override set, use the host list supplied with the
4809 transport. It is an error for this not to exist. */
4811 if (!hostlist || (ob->hosts_override && ob->hosts))
4815 addrlist->message = string_sprintf("%s transport called with no hosts set",
4817 addrlist->transport_return = PANIC;
4818 return FALSE; /* Only top address has status */
4821 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4824 /* If the transport's host list contains no '$' characters, and we are not
4825 randomizing, it is fixed and therefore a chain of hosts can be built once
4826 and for all, and remembered for subsequent use by other calls to this
4827 transport. If, on the other hand, the host list does contain '$', or we are
4828 randomizing its order, we have to rebuild it each time. In the fixed case,
4829 as the hosts string will never be used again, it doesn't matter that we
4830 replace all the : characters with zeros. */
4834 uschar *s = ob->hosts;
4836 if (Ustrchr(s, '$'))
4838 if (!(expanded_hosts = expand_string(s)))
4840 addrlist->message = string_sprintf("failed to expand list of hosts "
4841 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4842 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4843 return FALSE; /* Only top address has status */
4845 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4846 "\"%s\"\n", s, expanded_hosts);
4850 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4854 log_write(0, LOG_MAIN|LOG_PANIC,
4855 "attempt to use tainted host list '%s' from '%s' in transport %s",
4856 s, ob->hosts, tblock->name);
4857 /* Avoid leaking info to an attacker */
4858 addrlist->message = US"internal configuration error";
4859 addrlist->transport_return = PANIC;
4863 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4865 /* Check that the expansion yielded something useful. */
4869 string_sprintf("%s transport has empty hosts setting", tblock->name);
4870 addrlist->transport_return = PANIC;
4871 return FALSE; /* Only top address has status */
4874 /* If there was no expansion of hosts, save the host list for
4877 if (!expanded_hosts) ob->hostlist = hostlist;
4880 /* This is not the first time this transport has been run in this delivery;
4881 the host list was built previously. */
4884 hostlist = ob->hostlist;
4887 /* The host list was supplied with the address. If hosts_randomize is set, we
4888 must sort it into a random order if it did not come from MX records and has not
4889 already been randomized (but don't bother if continuing down an existing
4892 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4894 host_item *newlist = NULL;
4897 host_item *h = hostlist;
4898 hostlist = hostlist->next;
4900 h->sort_key = random_number(100);
4907 else if (h->sort_key < newlist->sort_key)
4914 host_item *hh = newlist;
4917 if (h->sort_key < hh->next->sort_key) break;
4925 hostlist = addrlist->host_list = newlist;
4928 /* Sort out the default port. */
4930 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4932 /* For each host-plus-IP-address on the list:
4934 . If this is a continued delivery and the host isn't the one with the
4935 current connection, skip.
4937 . If the status is unusable (i.e. previously failed or retry checked), skip.
4939 . If no IP address set, get the address, either by turning the name into
4940 an address, calling gethostbyname if gethostbyname is on, or by calling
4941 the DNS. The DNS may yield multiple addresses, in which case insert the
4942 extra ones into the list.
4944 . Get the retry data if not previously obtained for this address and set the
4945 field which remembers the state of this address. Skip if the retry time is
4946 not reached. If not, remember whether retry data was found. The retry string
4947 contains both the name and the IP address.
4949 . Scan the list of addresses and mark those whose status is DEFER as
4950 PENDING_DEFER. These are the only ones that will be processed in this cycle
4953 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4954 Some addresses may be successfully delivered, others may fail, and yet
4955 others may get temporary errors and so get marked DEFER.
4957 . The return from the delivery attempt is OK if a connection was made and a
4958 valid SMTP dialogue was completed. Otherwise it is DEFER.
4960 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4962 . If fail to connect, or other defer state, add a retry item.
4964 . If there are any addresses whose status is still DEFER, carry on to the
4965 next host/IPaddress, unless we have tried the number of hosts given
4966 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4967 there is some fancy logic for hosts_max_try that means its limit can be
4968 overstepped in some circumstances.
4970 If we get to the end of the list, all hosts have deferred at least one address,
4971 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4972 delivery attempt to those hosts whose last try was before the arrival time of
4973 the current message. To cope with this, we have to go round the loop a second
4974 time. After that, set the status and error data for any addresses that haven't
4975 had it set already. */
4977 for (int cutoff_retry = 0;
4978 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4981 host_item *nexthost = NULL;
4982 int unexpired_hosts_tried = 0;
4983 BOOL continue_host_tried = FALSE;
4985 retry_non_continued:
4986 for (host = hostlist;
4988 && unexpired_hosts_tried < ob->hosts_max_try
4989 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4994 BOOL host_is_expired = FALSE;
4995 BOOL message_defer = FALSE;
4996 BOOL some_deferred = FALSE;
4997 address_item *first_addr = NULL;
4998 uschar *interface = NULL;
4999 uschar *retry_host_key = NULL;
5000 uschar *retry_message_key = NULL;
5001 uschar *serialize_key = NULL;
5003 /* Default next host is next host. :-) But this can vary if the
5004 hosts_max_try limit is hit (see below). It may also be reset if a host
5005 address is looked up here (in case the host was multihomed). */
5007 nexthost = host->next;
5009 /* If the address hasn't yet been obtained from the host name, look it up
5010 now, unless the host is already marked as unusable. If it is marked as
5011 unusable, it means that the router was unable to find its IP address (in
5012 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
5013 the lookup failed last time. We don't get this far if *all* MX records
5014 point to non-existent hosts; that is treated as a hard error.
5016 We can just skip this host entirely. When the hosts came from the router,
5017 the address will timeout based on the other host(s); when the address is
5018 looked up below, there is an explicit retry record added.
5020 Note that we mustn't skip unusable hosts if the address is not unset; they
5021 may be needed as expired hosts on the 2nd time round the cutoff loop. */
5025 int new_port, flags;
5027 if (host->status >= hstatus_unusable)
5029 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
5034 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
5036 /* The host name is permitted to have an attached port. Find it, and
5037 strip it from the name. Just remember it for now. */
5039 new_port = host_item_get_port(host);
5041 /* Count hosts looked up */
5045 /* Find by name if so configured, or if it's an IP address. We don't
5046 just copy the IP address, because we need the test-for-local to happen. */
5048 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
5049 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
5050 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
5052 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
5053 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
5055 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
5056 &ob->dnssec, /* domains for request/require */
5059 /* Update the host (and any additional blocks, resulting from
5060 multihoming) with a host-specific port, if any. */
5062 for (host_item * hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
5064 /* Failure to find the host at this time (usually DNS temporary failure)
5065 is really a kind of routing failure rather than a transport failure.
5066 Therefore we add a retry item of the routing kind, not to stop us trying
5067 to look this name up here again, but to ensure the address gets timed
5068 out if the failures go on long enough. A complete failure at this point
5069 commonly points to a configuration error, but the best action is still
5070 to carry on for the next host. */
5072 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
5074 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
5076 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
5077 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
5078 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
5079 host->status = hstatus_unusable;
5081 for (address_item * addr = addrlist; addr; addr = addr->next)
5083 if (addr->transport_return != DEFER) continue;
5084 addr->basic_errno = ERRNO_UNKNOWNHOST;
5085 addr->message = string_sprintf(
5086 rc == HOST_FIND_SECURITY
5087 ? "lookup of IP address for %s was insecure"
5088 : "failed to lookup IP address for %s",
5094 /* If the host is actually the local host, we may have a problem, or
5095 there may be some cunning configuration going on. In the problem case,
5096 log things and give up. The default transport status is already DEFER. */
5098 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
5100 for (address_item * addr = addrlist; addr; addr = addr->next)
5102 addr->basic_errno = ERRNO_HOST_IS_LOCAL;
5103 addr->message = string_sprintf("%s transport found host %s to be "
5104 "local", tblock->name, host->name);
5108 } /* End of block for IP address lookup */
5110 /* If this is a continued delivery, we are interested only in the host
5111 which matches the name of the existing open channel. The check is put
5112 here after the local host lookup, in case the name gets expanded as a
5113 result of the lookup. Set expired FALSE, to save the outer loop executing
5116 if (continue_hostname)
5117 if ( Ustrcmp(continue_hostname, host->name) != 0
5118 || Ustrcmp(continue_host_address, host->address) != 0
5122 continue; /* With next host */
5125 continue_host_tried = TRUE;
5127 /* Reset the default next host in case a multihomed host whose addresses
5128 are not looked up till just above added to the host list. */
5130 nexthost = host->next;
5132 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
5133 domain is in queue_smtp_domains, we don't actually want to attempt any
5134 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
5135 there is a lookup defer in queue_smtp_domains, proceed as if the domain
5136 were not in it. We don't want to hold up all SMTP deliveries! Except when
5137 doing a two-stage queue run, don't do this if forcing. */
5139 if ( (!f.deliver_force || f.queue_2stage)
5141 || match_isinlist(addrlist->domain,
5142 CUSS &queue_smtp_domains, 0,
5143 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK)
5146 DEBUG(D_transport) debug_printf("first-pass routing only\n");
5148 for (address_item * addr = addrlist; addr; addr = addr->next)
5149 if (addr->transport_return == DEFER)
5150 addr->message = US"first-pass only routing due to -odqs, "
5151 "queue_smtp_domains or control=queue";
5152 continue; /* With next host */
5155 /* Count hosts being considered - purely for an intelligent comment
5156 if none are usable. */
5160 /* Set $host and $host address now in case they are needed for the
5161 interface expansion or the serialize_hosts check; they remain set if an
5162 actual delivery happens. */
5164 deliver_host = host->name;
5165 deliver_host_address = host->address;
5166 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
5167 : host->dnssec == DS_NO ? US"no"
5170 /* Set up a string for adding to the retry key if the port number is not
5171 the standard SMTP port. A host may have its own port setting that overrides
5174 pistring = string_sprintf(":%d", host->port == PORT_NONE
5175 ? defport : host->port);
5176 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
5178 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
5179 string is set, even if constant (as different transports can have different
5180 constant settings), we must add it to the key that is used for retries,
5181 because connections to the same host from a different interface should be
5182 treated separately. */
5184 host_af = Ustrchr(host->address, ':') ? AF_INET6 : AF_INET;
5186 uschar * s = ob->interface;
5189 if (!smtp_get_interface(s, host_af, addrlist, &interface, tid))
5191 pistring = string_sprintf("%s/%s", pistring, interface);
5195 /* The first time round the outer loop, check the status of the host by
5196 inspecting the retry data. The second time round, we are interested only
5197 in expired hosts that haven't been tried since this message arrived. */
5199 if (cutoff_retry == 0)
5202 /* Ensure the status of the address is set by checking retry data if
5203 necessary. There may be host-specific retry data (applicable to all
5204 messages) and also data for retries of a specific message at this host.
5205 If either of these retry records are actually read, the keys used are
5206 returned to save recomputing them later. */
5208 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5209 US"retry_include_ip_address", ob->retry_include_ip_address,
5210 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5211 continue; /* with next host */
5213 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
5214 incl_ip, &retry_host_key, &retry_message_key);
5216 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
5217 host->address ? host->address : US"", pistring,
5218 host->status == hstatus_usable ? "usable"
5219 : host->status == hstatus_unusable ? "unusable"
5220 : host->status == hstatus_unusable_expired ? "unusable (expired)" : "?");
5222 /* Skip this address if not usable at this time, noting if it wasn't
5223 actually expired, both locally and in the address. */
5225 switch (host->status)
5227 case hstatus_unusable:
5229 setflag(addrlist, af_retry_skipped);
5232 case hstatus_unusable_expired:
5235 case hwhy_retry: hosts_retry++; break;
5236 case hwhy_failed: hosts_fail++; break;
5238 case hwhy_deferred: hosts_defer++; break;
5241 /* If there was a retry message key, implying that previously there
5242 was a message-specific defer, we don't want to update the list of
5243 messages waiting for these hosts. */
5245 if (retry_message_key) update_waiting = FALSE;
5246 continue; /* With the next host or IP address */
5250 /* Second time round the loop: if the address is set but expired, and
5251 the message is newer than the last try, let it through. */
5256 || host->status != hstatus_unusable_expired
5257 || host->last_try > received_time.tv_sec)
5259 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
5260 host->name, host->address, pistring);
5261 host_is_expired = TRUE;
5264 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
5265 it remains TRUE only if all hosts are expired and none are actually tried.
5270 /* If this host is listed as one to which access must be serialized,
5271 see if another Exim process has a connection to it, and if so, skip
5272 this host. If not, update the database to record our connection to it
5273 and remember this for later deletion. Do not do any of this if we are
5274 sending the message down a pre-existing connection. */
5276 if ( !continue_hostname
5277 && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
5279 serialize_key = string_sprintf("host-serialize-%s", host->name);
5280 if (!enq_start(serialize_key, 1))
5283 debug_printf("skipping host %s because another Exim process "
5284 "is connected to it\n", host->name);
5290 /* OK, we have an IP address that is not waiting for its retry time to
5291 arrive (it might be expired) OR (second time round the loop) we have an
5292 expired host that hasn't been tried since the message arrived. Have a go
5293 at delivering the message to it. First prepare the addresses by flushing
5294 out the result of previous attempts, and finding the first address that
5295 is still to be delivered. */
5297 first_addr = prepare_addresses(addrlist, host);
5299 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5300 message_id, host->name, host->address, addrlist->address,
5301 addrlist->next ? ", ..." : "");
5303 set_process_info("delivering %s to %s [%s]%s (%s%s)",
5304 message_id, host->name, host->address, pistring, addrlist->address,
5305 addrlist->next ? ", ..." : "");
5307 /* This is not for real; don't do the delivery. If there are
5308 any remaining hosts, list them. */
5313 gettimeofday(&now, NULL);
5314 set_errno_nohost(addrlist, 0, NULL, OK, FALSE, &now);
5315 for (address_item * addr = addrlist; addr; addr = addr->next)
5317 addr->host_used = host;
5318 addr->special_action = '*';
5319 addr->message = US"delivery bypassed by -N option";
5323 debug_printf("*** delivery by %s transport bypassed by -N option\n"
5324 "*** host and remaining hosts:\n", tblock->name);
5325 for (host_item * host2 = host; host2; host2 = host2->next)
5326 debug_printf(" %s [%s]\n", host2->name,
5327 host2->address ? host2->address : US"unset");
5332 /* This is for real. If the host is expired, we don't count it for
5333 hosts_max_retry. This ensures that all hosts must expire before an address
5334 is timed out, unless hosts_max_try_hardlimit (which protects against
5335 lunatic DNS configurations) is reached.
5337 If the host is not expired and we are about to hit the hosts_max_retry
5338 limit, check to see if there is a subsequent hosts with a different MX
5339 value. If so, make that the next host, and don't count this one. This is a
5340 heuristic to make sure that different MXs do get tried. With a normal kind
5341 of retry rule, they would get tried anyway when the earlier hosts were
5342 delayed, but if the domain has a "retry every time" type of rule - as is
5343 often used for the the very large ISPs, that won't happen. */
5348 /* Make a copy of the host if it is local to this invocation
5349 of the transport. */
5353 thost = store_get(sizeof(host_item), FALSE);
5355 thost->name = string_copy(host->name);
5356 thost->address = string_copy(host->address);
5361 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
5364 debug_printf("hosts_max_try limit reached with this host\n");
5365 for (host_item * h = host; h; h = h->next) if (h->mx != host->mx)
5368 unexpired_hosts_tried--;
5369 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
5370 "and will be tried\n");
5375 /* Attempt the delivery. */
5377 total_hosts_tried++;
5378 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5379 &message_defer, FALSE);
5382 OK => connection made, each address contains its result;
5383 message_defer is set for message-specific defers (when all
5384 recipients are marked defer)
5385 DEFER => there was a non-message-specific delivery problem;
5386 ERROR => there was a problem setting up the arguments for a filter,
5387 or there was a problem with expanding added headers
5390 /* If the result is not OK, there was a non-message-specific problem.
5391 If the result is DEFER, we need to write to the logs saying what happened
5392 for this particular host, except in the case of authentication and TLS
5393 failures, where the log has already been written. If all hosts defer a
5394 general message is written at the end. */
5396 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
5397 && first_addr->basic_errno != ERRNO_TLSFAILURE)
5398 write_logs(host, first_addr->message, first_addr->basic_errno);
5400 #ifndef DISABLE_EVENT
5402 deferred_event_raise(first_addr, host, US"msg:host:defer");
5405 /* If STARTTLS was accepted, but there was a failure in setting up the
5406 TLS session (usually a certificate screwup), and the host is not in
5407 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5408 TLS forcibly turned off. We have to start from scratch with a new SMTP
5409 connection. That's why the retry is done from here, not from within
5410 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5411 session, so the in-clear transmission after those errors, if permitted,
5412 happens inside smtp_deliver().] */
5416 && first_addr->basic_errno == ERRNO_TLSFAILURE
5417 && ob->tls_tempfail_tryclear
5418 && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
5421 log_write(0, LOG_MAIN,
5422 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5423 first_addr->message, host->name, host->address);
5424 first_addr = prepare_addresses(addrlist, host);
5425 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5426 &message_defer, TRUE);
5427 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
5428 write_logs(host, first_addr->message, first_addr->basic_errno);
5429 # ifndef DISABLE_EVENT
5431 deferred_event_raise(first_addr, host, US"msg:host:defer");
5434 #endif /*DISABLE_TLS*/
5436 #ifndef DISABLE_EVENT
5437 /* If the last host gave a defer raise a per-message event */
5440 && unexpired_hosts_tried < ob->hosts_max_try
5441 && total_hosts_tried < ob->hosts_max_try_hardlimit
5443 && (message_defer || rc == DEFER)
5445 deferred_event_raise(first_addr, host, US"msg:defer");
5449 /* Delivery attempt finished */
5451 set_process_info("delivering %s: just tried %s [%s]%s for %s%s: result %s",
5452 message_id, host->name, host->address, pistring, addrlist->address,
5453 addrlist->next ? " (& others)" : "", rc_to_string(rc));
5455 /* Release serialization if set up */
5457 if (serialize_key) enq_end(serialize_key);
5459 /* If the result is DEFER, or if a host retry record is known to exist, we
5460 need to add an item to the retry chain for updating the retry database
5461 at the end of delivery. We only need to add the item to the top address,
5462 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5463 for any other delivery attempts using the same address. (It is copied into
5464 the unusable tree at the outer level, so even if different address blocks
5465 contain the same address, it still won't get tried again.) */
5467 if (rc == DEFER || retry_host_key)
5469 int delete_flag = rc != DEFER ? rf_delete : 0;
5470 if (!retry_host_key)
5473 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5474 US"retry_include_ip_address", ob->retry_include_ip_address,
5475 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5476 incl_ip = TRUE; /* error; use most-specific retry record */
5478 retry_host_key = incl_ip
5479 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
5480 : string_sprintf("T:%S%s", host->name, pistring);
5483 /* If a delivery of another message over an existing SMTP connection
5484 yields DEFER, we do NOT set up retry data for the host. This covers the
5485 case when there are delays in routing the addresses in the second message
5486 that are so long that the server times out. This is alleviated by not
5487 routing addresses that previously had routing defers when handling an
5488 existing connection, but even so, this case may occur (e.g. if a
5489 previously happily routed address starts giving routing defers). If the
5490 host is genuinely down, another non-continued message delivery will
5491 notice it soon enough. */
5493 if (delete_flag != 0 || !continue_hostname)
5494 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
5496 /* We may have tried an expired host, if its retry time has come; ensure
5497 the status reflects the expiry for the benefit of any other addresses. */
5501 host->status = host_is_expired
5502 ? hstatus_unusable_expired : hstatus_unusable;
5503 host->why = hwhy_deferred;
5507 /* If message_defer is set (host was OK, but every recipient got deferred
5508 because of some message-specific problem), or if that had happened
5509 previously so that a message retry key exists, add an appropriate item
5510 to the retry chain. Note that if there was a message defer but now there is
5511 a host defer, the message defer record gets deleted. That seems perfectly
5512 reasonable. Also, stop the message from being remembered as waiting
5513 for specific hosts. */
5515 if (message_defer || retry_message_key)
5517 int delete_flag = message_defer ? 0 : rf_delete;
5518 if (!retry_message_key)
5521 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5522 US"retry_include_ip_address", ob->retry_include_ip_address,
5523 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5524 incl_ip = TRUE; /* error; use most-specific retry record */
5526 retry_message_key = incl_ip
5527 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
5529 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
5531 retry_add_item(addrlist, retry_message_key,
5532 rf_message | rf_host | delete_flag);
5533 update_waiting = FALSE;
5536 /* Any return other than DEFER (that is, OK or ERROR) means that the
5537 addresses have got their final statuses filled in for this host. In the OK
5538 case, see if any of them are deferred. */
5541 for (address_item * addr = addrlist; addr; addr = addr->next)
5542 if (addr->transport_return == DEFER)
5544 some_deferred = TRUE;
5548 /* If no addresses deferred or the result was ERROR, return. We do this for
5549 ERROR because a failing filter set-up or add_headers expansion is likely to
5550 fail for any host we try. */
5552 if (rc == ERROR || (rc == OK && !some_deferred))
5554 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5555 return TRUE; /* Each address has its status */
5558 /* If the result was DEFER or some individual addresses deferred, let
5559 the loop run to try other hosts with the deferred addresses, except for the
5560 case when we were trying to deliver down an existing channel and failed.
5561 Don't try any other hosts in this case. */
5563 if (continue_hostname) break;
5565 /* If the whole delivery, or some individual addresses, were deferred and
5566 there are more hosts that could be tried, do not count this host towards
5567 the hosts_max_try limit if the age of the message is greater than the
5568 maximum retry time for this host. This means we may try try all hosts,
5569 ignoring the limit, when messages have been around for some time. This is
5570 important because if we don't try all hosts, the address will never time
5571 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5573 if ((rc == DEFER || some_deferred) && nexthost)
5576 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
5578 if (retry && retry->rules)
5580 retry_rule *last_rule;
5581 for (last_rule = retry->rules;
5583 last_rule = last_rule->next);
5584 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
5586 else timedout = TRUE; /* No rule => timed out */
5590 unexpired_hosts_tried--;
5591 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
5592 "hosts_max_try (message older than host's retry time)\n");
5598 if (unexpired_hosts_tried >= ob->hosts_max_try)
5599 debug_printf("reached transport hosts_max_try limit %d\n",
5601 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5602 debug_printf("reached transport hosts_max_try_hardlimit limit %d\n",
5603 ob->hosts_max_try_hardlimit);
5606 testharness_pause_ms(500); /* let server debug out */
5607 } /* End of loop for trying multiple hosts. */
5609 /* If we failed to find a matching host in the list, for an already-open
5610 connection, just close it and start over with the list. This can happen
5611 for routing that changes from run to run, or big multi-IP sites with
5614 if (continue_hostname && !continue_host_tried)
5616 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
5618 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
5620 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5622 /*XXX doublecheck that! */
5624 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
5626 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
5627 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
5628 cutthrough.cctx.tls_ctx = NULL;
5629 cutthrough.is_tls = FALSE;
5633 (void) write(fd, US"QUIT\r\n", 6);
5636 cutthrough.cctx.sock = -1;
5637 continue_hostname = NULL;
5638 goto retry_non_continued;
5641 /* This is the end of the loop that repeats iff expired is TRUE and
5642 ob->delay_after_cutoff is FALSE. The second time round we will
5643 try those hosts that haven't been tried since the message arrived. */
5647 debug_printf("all IP addresses skipped or deferred at least one address\n");
5648 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
5649 debug_printf("retrying IP addresses not tried since message arrived\n");
5654 /* Get here if all IP addresses are skipped or defer at least one address. In
5655 MUA wrapper mode, this will happen only for connection or other non-message-
5656 specific failures. Force the delivery status for all addresses to FAIL. */
5660 for (address_item * addr = addrlist; addr; addr = addr->next)
5661 addr->transport_return = FAIL;
5665 /* In the normal, non-wrapper case, add a standard message to each deferred
5666 address if there hasn't been an error, that is, if it hasn't actually been
5667 tried this time. The variable "expired" will be FALSE if any deliveries were
5668 actually tried, or if there was at least one host that was not expired. That
5669 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5670 a delivery has been tried, an error code will be set, and the failing of the
5671 message is handled by the retry code later.
5673 If queue_smtp is set, or this transport was called to send a subsequent message
5674 down an existing TCP/IP connection, and something caused the host not to be
5675 found, we end up here, but can detect these cases and handle them specially. */
5677 for (address_item * addr = addrlist; addr; addr = addr->next)
5679 /* If host is not NULL, it means that we stopped processing the host list
5680 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5681 means we need to behave as if some hosts were skipped because their retry
5682 time had not come. Specifically, this prevents the address from timing out.
5683 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5684 hosts were tried. */
5687 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5690 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5691 "hosts were tried\n");
5696 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5697 setflag(addr, af_retry_skipped);
5700 if (f.queue_smtp) /* no deliveries attempted */
5702 addr->transport_return = DEFER;
5703 addr->basic_errno = 0;
5704 addr->message = US"SMTP delivery explicitly queued";
5707 else if ( addr->transport_return == DEFER
5708 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
5712 addr->basic_errno = ERRNO_HRETRY;
5713 if (continue_hostname)
5714 addr->message = US"no host found for existing SMTP connection";
5717 setflag(addr, af_pass_message); /* This is not a security risk */
5718 addr->message = string_sprintf(
5719 "all hosts%s have been failing for a long time %s",
5720 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
5721 ob->delay_after_cutoff
5722 ? US"(and retry time not reached)"
5723 : US"and were last tried after this message arrived");
5725 /* If we are already using fallback hosts, or there are no fallback hosts
5726 defined, convert the result to FAIL to cause a bounce. */
5728 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
5729 addr->transport_return = FAIL;
5734 if (hosts_retry == hosts_total)
5735 s = "retry time not reached for any host%s";
5736 else if (hosts_fail == hosts_total)
5737 s = "all host address lookups%s failed permanently";
5738 else if (hosts_defer == hosts_total)
5739 s = "all host address lookups%s failed temporarily";
5740 else if (hosts_serial == hosts_total)
5741 s = "connection limit reached for all hosts%s";
5742 else if (hosts_fail+hosts_defer == hosts_total)
5743 s = "all host address lookups%s failed";
5745 s = "some host address lookups failed and retry time "
5746 "not reached for other hosts or connection limit reached%s";
5748 addr->message = string_sprintf(s,
5749 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
5754 /* Update the database which keeps information about which messages are waiting
5755 for which hosts to become available. For some message-specific errors, the
5756 update_waiting flag is turned off because we don't want follow-on deliveries in
5757 those cases. If this transport instance is explicitly limited to one message
5758 per connection then follow-on deliveries are not possible and there's no need
5759 to create/update the per-transport wait-<transport_name> database. */
5761 if (update_waiting && tblock->connection_max_messages != 1)
5762 transport_update_waiting(hostlist, tblock->name);
5766 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5768 return TRUE; /* Each address has its status */
5771 #endif /*!MACRO_PREDEF*/
5774 /* End of transport/smtp.c */