1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
12 /* Options specific to the smtp transport. This transport also supports LMTP
13 over TCP/IP. The options must be in alphabetic order (note that "_" comes
14 before the lower case letters). Some live in the transport_instance block so as
15 to be publicly visible; these are flagged with opt_public. */
17 optionlist smtp_transport_options[] = {
18 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
19 (void *)offsetof(transport_instance, expand_multi_domain) },
20 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
21 (void *)(offsetof(smtp_transport_options_block, expand_retry_include_ip_address)) },
23 { "address_retry_include_sender", opt_bool,
24 (void *)offsetof(smtp_transport_options_block, address_retry_include_sender) },
25 { "allow_localhost", opt_bool,
26 (void *)offsetof(smtp_transport_options_block, allow_localhost) },
27 #ifdef EXPERIMENTAL_ARC
28 { "arc_sign", opt_stringptr,
29 (void *)offsetof(smtp_transport_options_block, arc_sign) },
31 { "authenticated_sender", opt_stringptr,
32 (void *)offsetof(smtp_transport_options_block, authenticated_sender) },
33 { "authenticated_sender_force", opt_bool,
34 (void *)offsetof(smtp_transport_options_block, authenticated_sender_force) },
35 { "command_timeout", opt_time,
36 (void *)offsetof(smtp_transport_options_block, command_timeout) },
37 { "connect_timeout", opt_time,
38 (void *)offsetof(smtp_transport_options_block, connect_timeout) },
39 { "connection_max_messages", opt_int | opt_public,
40 (void *)offsetof(transport_instance, connection_max_messages) },
42 { "dane_require_tls_ciphers", opt_stringptr,
43 (void *)offsetof(smtp_transport_options_block, dane_require_tls_ciphers) },
45 { "data_timeout", opt_time,
46 (void *)offsetof(smtp_transport_options_block, data_timeout) },
47 { "delay_after_cutoff", opt_bool,
48 (void *)offsetof(smtp_transport_options_block, delay_after_cutoff) },
50 { "dkim_canon", opt_stringptr,
51 (void *)offsetof(smtp_transport_options_block, dkim.dkim_canon) },
52 { "dkim_domain", opt_stringptr,
53 (void *)offsetof(smtp_transport_options_block, dkim.dkim_domain) },
54 { "dkim_hash", opt_stringptr,
55 (void *)offsetof(smtp_transport_options_block, dkim.dkim_hash) },
56 { "dkim_identity", opt_stringptr,
57 (void *)offsetof(smtp_transport_options_block, dkim.dkim_identity) },
58 { "dkim_private_key", opt_stringptr,
59 (void *)offsetof(smtp_transport_options_block, dkim.dkim_private_key) },
60 { "dkim_selector", opt_stringptr,
61 (void *)offsetof(smtp_transport_options_block, dkim.dkim_selector) },
62 { "dkim_sign_headers", opt_stringptr,
63 (void *)offsetof(smtp_transport_options_block, dkim.dkim_sign_headers) },
64 { "dkim_strict", opt_stringptr,
65 (void *)offsetof(smtp_transport_options_block, dkim.dkim_strict) },
66 { "dkim_timestamps", opt_stringptr,
67 (void *)offsetof(smtp_transport_options_block, dkim.dkim_timestamps) },
69 { "dns_qualify_single", opt_bool,
70 (void *)offsetof(smtp_transport_options_block, dns_qualify_single) },
71 { "dns_search_parents", opt_bool,
72 (void *)offsetof(smtp_transport_options_block, dns_search_parents) },
73 { "dnssec_request_domains", opt_stringptr,
74 (void *)offsetof(smtp_transport_options_block, dnssec.request) },
75 { "dnssec_require_domains", opt_stringptr,
76 (void *)offsetof(smtp_transport_options_block, dnssec.require) },
77 { "dscp", opt_stringptr,
78 (void *)offsetof(smtp_transport_options_block, dscp) },
79 { "fallback_hosts", opt_stringptr,
80 (void *)offsetof(smtp_transport_options_block, fallback_hosts) },
81 { "final_timeout", opt_time,
82 (void *)offsetof(smtp_transport_options_block, final_timeout) },
83 { "gethostbyname", opt_bool,
84 (void *)offsetof(smtp_transport_options_block, gethostbyname) },
85 { "helo_data", opt_stringptr,
86 (void *)offsetof(smtp_transport_options_block, helo_data) },
87 { "hosts", opt_stringptr,
88 (void *)offsetof(smtp_transport_options_block, hosts) },
89 { "hosts_avoid_esmtp", opt_stringptr,
90 (void *)offsetof(smtp_transport_options_block, hosts_avoid_esmtp) },
91 { "hosts_avoid_pipelining", opt_stringptr,
92 (void *)offsetof(smtp_transport_options_block, hosts_avoid_pipelining) },
94 { "hosts_avoid_tls", opt_stringptr,
95 (void *)offsetof(smtp_transport_options_block, hosts_avoid_tls) },
97 { "hosts_max_try", opt_int,
98 (void *)offsetof(smtp_transport_options_block, hosts_max_try) },
99 { "hosts_max_try_hardlimit", opt_int,
100 (void *)offsetof(smtp_transport_options_block, hosts_max_try_hardlimit) },
102 { "hosts_nopass_tls", opt_stringptr,
103 (void *)offsetof(smtp_transport_options_block, hosts_nopass_tls) },
104 { "hosts_noproxy_tls", opt_stringptr,
105 (void *)offsetof(smtp_transport_options_block, hosts_noproxy_tls) },
107 { "hosts_override", opt_bool,
108 (void *)offsetof(smtp_transport_options_block, hosts_override) },
109 #ifdef EXPERIMENTAL_PIPE_CONNECT
110 { "hosts_pipe_connect", opt_stringptr,
111 (void *)offsetof(smtp_transport_options_block, hosts_pipe_connect) },
113 { "hosts_randomize", opt_bool,
114 (void *)offsetof(smtp_transport_options_block, hosts_randomize) },
115 #if defined(SUPPORT_TLS) && !defined(DISABLE_OCSP)
116 { "hosts_request_ocsp", opt_stringptr,
117 (void *)offsetof(smtp_transport_options_block, hosts_request_ocsp) },
119 { "hosts_require_auth", opt_stringptr,
120 (void *)offsetof(smtp_transport_options_block, hosts_require_auth) },
123 { "hosts_require_dane", opt_stringptr,
124 (void *)offsetof(smtp_transport_options_block, hosts_require_dane) },
126 # ifndef DISABLE_OCSP
127 { "hosts_require_ocsp", opt_stringptr,
128 (void *)offsetof(smtp_transport_options_block, hosts_require_ocsp) },
130 { "hosts_require_tls", opt_stringptr,
131 (void *)offsetof(smtp_transport_options_block, hosts_require_tls) },
133 { "hosts_try_auth", opt_stringptr,
134 (void *)offsetof(smtp_transport_options_block, hosts_try_auth) },
135 { "hosts_try_chunking", opt_stringptr,
136 (void *)offsetof(smtp_transport_options_block, hosts_try_chunking) },
137 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
138 { "hosts_try_dane", opt_stringptr,
139 (void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
141 { "hosts_try_fastopen", opt_stringptr,
142 (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
144 { "hosts_try_prdr", opt_stringptr,
145 (void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
148 { "hosts_verify_avoid_tls", opt_stringptr,
149 (void *)offsetof(smtp_transport_options_block, hosts_verify_avoid_tls) },
151 { "interface", opt_stringptr,
152 (void *)offsetof(smtp_transport_options_block, interface) },
153 { "keepalive", opt_bool,
154 (void *)offsetof(smtp_transport_options_block, keepalive) },
155 { "lmtp_ignore_quota", opt_bool,
156 (void *)offsetof(smtp_transport_options_block, lmtp_ignore_quota) },
157 { "max_rcpt", opt_int | opt_public,
158 (void *)offsetof(transport_instance, max_addresses) },
159 { "multi_domain", opt_expand_bool | opt_public,
160 (void *)offsetof(transport_instance, multi_domain) },
161 { "port", opt_stringptr,
162 (void *)offsetof(smtp_transport_options_block, port) },
163 { "protocol", opt_stringptr,
164 (void *)offsetof(smtp_transport_options_block, protocol) },
165 { "retry_include_ip_address", opt_expand_bool,
166 (void *)offsetof(smtp_transport_options_block, retry_include_ip_address) },
167 { "serialize_hosts", opt_stringptr,
168 (void *)offsetof(smtp_transport_options_block, serialize_hosts) },
169 { "size_addition", opt_int,
170 (void *)offsetof(smtp_transport_options_block, size_addition) },
172 { "socks_proxy", opt_stringptr,
173 (void *)offsetof(smtp_transport_options_block, socks_proxy) },
176 { "tls_certificate", opt_stringptr,
177 (void *)offsetof(smtp_transport_options_block, tls_certificate) },
178 { "tls_crl", opt_stringptr,
179 (void *)offsetof(smtp_transport_options_block, tls_crl) },
180 { "tls_dh_min_bits", opt_int,
181 (void *)offsetof(smtp_transport_options_block, tls_dh_min_bits) },
182 { "tls_privatekey", opt_stringptr,
183 (void *)offsetof(smtp_transport_options_block, tls_privatekey) },
184 { "tls_require_ciphers", opt_stringptr,
185 (void *)offsetof(smtp_transport_options_block, tls_require_ciphers) },
186 { "tls_sni", opt_stringptr,
187 (void *)offsetof(smtp_transport_options_block, tls_sni) },
188 { "tls_tempfail_tryclear", opt_bool,
189 (void *)offsetof(smtp_transport_options_block, tls_tempfail_tryclear) },
190 { "tls_try_verify_hosts", opt_stringptr,
191 (void *)offsetof(smtp_transport_options_block, tls_try_verify_hosts) },
192 { "tls_verify_cert_hostnames", opt_stringptr,
193 (void *)offsetof(smtp_transport_options_block,tls_verify_cert_hostnames)},
194 { "tls_verify_certificates", opt_stringptr,
195 (void *)offsetof(smtp_transport_options_block, tls_verify_certificates) },
196 { "tls_verify_hosts", opt_stringptr,
197 (void *)offsetof(smtp_transport_options_block, tls_verify_hosts) },
200 { "utf8_downconvert", opt_stringptr,
201 (void *)offsetof(smtp_transport_options_block, utf8_downconvert) },
205 /* Size of the options list. An extern variable has to be used so that its
206 address can appear in the tables drtables.c. */
208 int smtp_transport_options_count = nelem(smtp_transport_options);
214 smtp_transport_options_block smtp_transport_option_defaults = {0};
215 void smtp_transport_init(transport_instance *tblock) {}
216 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
217 void smtp_transport_closedown(transport_instance *tblock) {}
219 #else /*!MACRO_PREDEF*/
222 /* Default private options block for the smtp transport. */
224 smtp_transport_options_block smtp_transport_option_defaults = {
226 .fallback_hosts = NULL,
228 .fallback_hostlist = NULL,
229 .helo_data = US"$primary_hostname",
232 .protocol = US"smtp",
234 .serialize_hosts = NULL,
235 .hosts_try_auth = NULL,
236 .hosts_require_auth = NULL,
237 .hosts_try_chunking = US"*",
239 .hosts_try_dane = NULL,
240 .hosts_require_dane = NULL,
241 .dane_require_tls_ciphers = NULL,
243 .hosts_try_fastopen = NULL,
245 .hosts_try_prdr = US"*",
248 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
249 .hosts_require_ocsp = NULL,
251 .hosts_require_tls = NULL,
252 .hosts_avoid_tls = NULL,
253 .hosts_verify_avoid_tls = NULL,
254 .hosts_avoid_pipelining = NULL,
255 #ifdef EXPERIMENTAL_PIPE_CONNECT
256 .hosts_pipe_connect = NULL,
258 .hosts_avoid_esmtp = NULL,
260 .hosts_nopass_tls = NULL,
261 .hosts_noproxy_tls = US"*",
263 .command_timeout = 5*60,
264 .connect_timeout = 5*60,
265 .data_timeout = 5*60,
266 .final_timeout = 10*60,
267 .size_addition = 1024,
269 .hosts_max_try_hardlimit = 50,
270 .address_retry_include_sender = TRUE,
271 .allow_localhost = FALSE,
272 .authenticated_sender_force = FALSE,
273 .gethostbyname = FALSE,
274 .dns_qualify_single = TRUE,
275 .dns_search_parents = FALSE,
276 .dnssec = { .request=NULL, .require=NULL },
277 .delay_after_cutoff = TRUE,
278 .hosts_override = FALSE,
279 .hosts_randomize = FALSE,
281 .lmtp_ignore_quota = FALSE,
282 .expand_retry_include_ip_address = NULL,
283 .retry_include_ip_address = TRUE,
288 .tls_certificate = NULL,
290 .tls_privatekey = NULL,
291 .tls_require_ciphers = NULL,
293 .tls_verify_certificates = US"system",
294 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
295 .tls_tempfail_tryclear = TRUE,
296 .tls_verify_hosts = NULL,
297 .tls_try_verify_hosts = US"*",
298 .tls_verify_cert_hostnames = US"*",
301 .utf8_downconvert = NULL,
305 {.dkim_domain = NULL,
306 .dkim_identity = NULL,
307 .dkim_private_key = NULL,
308 .dkim_selector = NULL,
310 .dkim_sign_headers = NULL,
312 .dkim_hash = US"sha256",
313 .dkim_timestamps = NULL,
314 .dot_stuffed = FALSE,
315 .force_bodyhash = FALSE,
316 # ifdef EXPERIMENTAL_ARC
317 .arc_signspec = NULL,
320 # ifdef EXPERIMENTAL_ARC
326 /* some DSN flags for use later */
328 static int rf_list[] = {rf_notify_never, rf_notify_success,
329 rf_notify_failure, rf_notify_delay };
331 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
337 static uschar *smtp_command; /* Points to last cmd for error messages */
338 static uschar *mail_command; /* Points to MAIL cmd for error messages */
339 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
340 static BOOL update_waiting; /* TRUE to update the "wait" database */
342 /*XXX move to smtp_context */
343 static BOOL pipelining_active; /* current transaction is in pipe mode */
346 static unsigned ehlo_response(uschar * buf, unsigned checks);
349 /*************************************************
350 * Setup entry point *
351 *************************************************/
353 /* This function is called when the transport is about to be used,
354 but before running it in a sub-process. It is used for two things:
356 (1) To set the fallback host list in addresses, when delivering.
357 (2) To pass back the interface, port, protocol, and other options, for use
358 during callout verification.
361 tblock pointer to the transport instance block
362 addrlist list of addresses about to be transported
363 tf if not NULL, pointer to block in which to return options
364 uid the uid that will be set (not used)
365 gid the gid that will be set (not used)
366 errmsg place for error message (not used)
368 Returns: OK always (FAIL, DEFER not used)
372 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
373 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
375 smtp_transport_options_block *ob = SOB tblock->options_block;
377 errmsg = errmsg; /* Keep picky compilers happy */
381 /* Pass back options if required. This interface is getting very messy. */
385 tf->interface = ob->interface;
387 tf->protocol = ob->protocol;
388 tf->hosts = ob->hosts;
389 tf->hosts_override = ob->hosts_override;
390 tf->hosts_randomize = ob->hosts_randomize;
391 tf->gethostbyname = ob->gethostbyname;
392 tf->qualify_single = ob->dns_qualify_single;
393 tf->search_parents = ob->dns_search_parents;
394 tf->helo_data = ob->helo_data;
397 /* Set the fallback host list for all the addresses that don't have fallback
398 host lists, provided that the local host wasn't present in the original host
401 if (!testflag(addrlist, af_local_host_removed))
402 for (; addrlist; addrlist = addrlist->next)
403 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
410 /*************************************************
411 * Initialization entry point *
412 *************************************************/
414 /* Called for each instance, after its options have been read, to
415 enable consistency checks to be done, or anything else that needs
418 Argument: pointer to the transport instance block
423 smtp_transport_init(transport_instance *tblock)
425 smtp_transport_options_block *ob = SOB tblock->options_block;
427 /* Retry_use_local_part defaults FALSE if unset */
429 if (tblock->retry_use_local_part == TRUE_UNSET)
430 tblock->retry_use_local_part = FALSE;
432 /* Set the default port according to the protocol */
435 ob->port = strcmpic(ob->protocol, US"lmtp") == 0
437 : strcmpic(ob->protocol, US"smtps") == 0
438 ? US"smtps" : US"smtp";
440 /* Set up the setup entry point, to be called before subprocesses for this
443 tblock->setup = smtp_transport_setup;
445 /* Complain if any of the timeouts are zero. */
447 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
448 ob->final_timeout <= 0)
449 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
450 "command, data, or final timeout value is zero for %s transport",
453 /* If hosts_override is set and there are local hosts, set the global
454 flag that stops verify from showing router hosts. */
456 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
458 /* If there are any fallback hosts listed, build a chain of host items
459 for them, but do not do any lookups at this time. */
461 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
468 /*************************************************
469 * Set delivery info into all active addresses *
470 *************************************************/
472 /* Only addresses whose status is >= PENDING are relevant. A lesser
473 status means that an address is not currently being processed.
476 addrlist points to a chain of addresses
477 errno_value to put in each address's errno field
478 msg to put in each address's message field
479 rc to put in each address's transport_return field
480 pass_message if TRUE, set the "pass message" flag in the address
481 host if set, mark addrs as having used this host
482 smtp_greeting from peer
483 helo_response from peer
485 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
486 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
487 this particular type of timeout.
493 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
494 BOOL pass_message, host_item * host
495 #ifdef EXPERIMENTAL_DSN_INFO
496 , const uschar * smtp_greeting, const uschar * helo_response
501 if (errno_value == ERRNO_CONNECTTIMEOUT)
503 errno_value = ETIMEDOUT;
504 orvalue = RTEF_CTOUT;
506 for (address_item * addr = addrlist; addr; addr = addr->next)
507 if (addr->transport_return >= PENDING)
509 addr->basic_errno = errno_value;
510 addr->more_errno |= orvalue;
514 if (pass_message) setflag(addr, af_pass_message);
516 addr->transport_return = rc;
519 addr->host_used = host;
520 #ifdef EXPERIMENTAL_DSN_INFO
522 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
523 addr->smtp_greeting = smtp_greeting;
526 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
527 addr->helo_response = helo_response;
534 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
537 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
538 #ifdef EXPERIMENTAL_DSN_INFO
545 /*************************************************
546 * Check an SMTP response *
547 *************************************************/
549 /* This function is given an errno code and the SMTP response buffer
550 to analyse, together with the host identification for generating messages. It
551 sets an appropriate message and puts the first digit of the response code into
552 the yield variable. If no response was actually read, a suitable digit is
556 host the current host, to get its name for messages
557 errno_value pointer to the errno value
558 more_errno from the top address for use with ERRNO_FILTER_FAIL
559 buffer the SMTP response buffer
560 yield where to put a one-digit SMTP response code
561 message where to put an error message
562 pass_message set TRUE if message is an SMTP response
564 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
568 check_response(host_item *host, int *errno_value, int more_errno,
569 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
571 uschar * pl = pipelining_active ? US"pipelined " : US"";
574 *yield = '4'; /* Default setting is to give a temporary error */
578 case ETIMEDOUT: /* Handle response timeout */
579 *message = US string_sprintf("SMTP timeout after %s%s",
581 if (transport_count > 0)
582 *message = US string_sprintf("%s (%d bytes written)", *message,
586 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
587 s = string_printing(buffer);
588 while (isspace(*s)) s++;
590 ? string_sprintf("Malformed SMTP reply (an empty line) "
591 "in response to %s%s", pl, smtp_command)
592 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
593 pl, smtp_command, s);
596 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
597 can't send QUIT as we mustn't end the DATA. */
598 *message = string_sprintf("transport filter process failed (%d)%s",
600 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
603 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
604 can't send QUIT as we mustn't end the DATA. */
606 string_sprintf("failed to expand headers_add or headers_remove: %s",
607 expand_string_message);
610 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
611 *message = string_sprintf("failed to write a data block");
615 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
616 *message = US"utf8 support required but not offered for forwarding";
617 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
622 /* Handle error responses from the remote mailer. */
626 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
627 "%s", pl, smtp_command, s = string_printing(buffer));
628 *pass_message = TRUE;
633 /* No data was read. If there is no errno, this must be the EOF (i.e.
634 connection closed) case, which causes deferral. An explicit connection reset
635 error has the same effect. Otherwise, put the host's identity in the message,
636 leaving the errno value to be interpreted as well. In all cases, we have to
637 assume the connection is now dead. */
639 if (*errno_value == 0 || *errno_value == ECONNRESET)
641 *errno_value = ERRNO_SMTPCLOSED;
642 *message = US string_sprintf("Remote host closed connection "
643 "in response to %s%s", pl, smtp_command);
646 *message = US string_sprintf("%s [%s]", host->name, host->address);
653 /*************************************************
654 * Write error message to logs *
655 *************************************************/
657 /* This writes to the main log and to the message log.
660 host the current host
661 detail the current message (addr_item->message)
662 basic_errno the errno (addr_item->basic_errno)
668 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
670 gstring * message = LOGGING(outgoing_port)
671 ? string_fmt_append(NULL, "H=%s [%s]:%d", host->name, host->address,
672 host->port == PORT_NONE ? 25 : host->port)
673 : string_fmt_append(NULL, "H=%s [%s]", host->name, host->address);
677 message = string_fmt_append(message, ": %s", suffix);
679 message = string_fmt_append(message, ": %s", strerror(basic_errno));
682 message = string_fmt_append(message, " %s", exim_errstr(basic_errno));
684 log_write(0, LOG_MAIN, "%s", string_from_gstring(message));
685 deliver_msglog("%s %s\n", tod_stamp(tod_log), message->s);
689 msglog_line(host_item * host, uschar * message)
691 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
692 host->name, host->address, message);
697 #ifndef DISABLE_EVENT
698 /*************************************************
699 * Post-defer action *
700 *************************************************/
702 /* This expands an arbitrary per-transport string.
703 It might, for example, be used to write to the database log.
706 addr the address item containing error information
707 host the current host
713 deferred_event_raise(address_item *addr, host_item *host)
715 uschar * action = addr->transport->event_action;
716 const uschar * save_domain;
722 save_domain = deliver_domain;
723 save_local = deliver_localpart;
725 /*XXX would ip & port already be set up? */
726 deliver_host_address = string_copy(host->address);
727 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
728 event_defer_errno = addr->basic_errno;
730 router_name = addr->router->name;
731 transport_name = addr->transport->name;
732 deliver_domain = addr->domain;
733 deliver_localpart = addr->local_part;
735 (void) event_raise(action, US"msg:host:defer",
737 ? addr->basic_errno > 0
738 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
739 : string_copy(addr->message)
740 : addr->basic_errno > 0
741 ? string_copy(US strerror(addr->basic_errno))
744 deliver_localpart = save_local;
745 deliver_domain = save_domain;
746 router_name = transport_name = NULL;
750 /*************************************************
751 * Reap SMTP specific responses *
752 *************************************************/
754 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
757 uschar flushbuffer[4096];
761 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
762 '2', ob->command_timeout)
763 && (errno != 0 || flushbuffer[0] == 0))
770 /* Return boolean success */
773 smtp_reap_banner(smtp_context * sx)
775 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
776 '2', (SOB sx->conn_args.ob)->command_timeout);
777 #ifdef EXPERIMENTAL_DSN_INFO
778 sx->smtp_greeting = string_copy(sx->buffer);
780 return good_response;
784 smtp_reap_ehlo(smtp_context * sx)
786 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
787 (SOB sx->conn_args.ob)->command_timeout))
789 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
791 #ifdef EXPERIMENTAL_DSN_INFO
792 sx->helo_response = string_copy(sx->buffer);
798 #ifdef EXPERIMENTAL_DSN_INFO
799 sx->helo_response = string_copy(sx->buffer);
806 #ifdef EXPERIMENTAL_PIPE_CONNECT
808 ehlo_cache_key(const smtp_context * sx)
810 host_item * host = sx->conn_args.host;
811 return Ustrchr(host->address, ':')
812 ? string_sprintf("[%s]:%d.EHLO", host->address,
813 host->port == PORT_NONE ? sx->port : host->port)
814 : string_sprintf("%s:%d.EHLO", host->address,
815 host->port == PORT_NONE ? sx->port : host->port);
819 write_ehlo_cache_entry(const smtp_context * sx)
821 open_db dbblock, * dbm_file;
823 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
825 uschar * ehlo_resp_key = ehlo_cache_key(sx);
826 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
828 HDEBUG(D_transport) debug_printf("writing clr %04x/%04x cry %04x/%04x\n",
829 sx->ehlo_resp.cleartext_features, sx->ehlo_resp.cleartext_auths,
830 sx->ehlo_resp.crypted_features, sx->ehlo_resp.crypted_auths);
832 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
833 dbfn_close(dbm_file);
838 invalidate_ehlo_cache_entry(smtp_context * sx)
840 open_db dbblock, * dbm_file;
842 if ( sx->early_pipe_active
843 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
845 uschar * ehlo_resp_key = ehlo_cache_key(sx);
846 dbfn_delete(dbm_file, ehlo_resp_key);
847 dbfn_close(dbm_file);
852 read_ehlo_cache_entry(smtp_context * sx)
857 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE)))
858 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
861 uschar * ehlo_resp_key = ehlo_cache_key(sx);
862 dbdata_ehlo_resp * er;
864 if (!(er = dbfn_read(dbm_file, ehlo_resp_key)))
865 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
866 else if (time(NULL) - er->time_stamp > retry_data_expire)
868 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
869 dbfn_close(dbm_file);
870 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
871 dbfn_delete(dbm_file, ehlo_resp_key);
875 sx->ehlo_resp = er->data;
876 dbfn_close(dbm_file);
877 DEBUG(D_transport) debug_printf(
878 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
879 er->data.cleartext_features, er->data.crypted_features);
882 dbfn_close(dbm_file);
889 /* Return an auths bitmap for the set of AUTH methods offered by the server
890 which match our authenticators. */
892 static unsigned short
893 study_ehlo_auths(smtp_context * sx)
898 unsigned short authbits = 0;
900 if (!sx->esmtp) return 0;
901 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
902 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
903 expand_nmax = -1; /* reset */
904 names = string_copyn(expand_nstring[1], expand_nlength[1]);
906 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
908 const uschar * list = names;
912 while (string_nextinlist(&list, &sep, name, sizeof(name)))
913 if (strcmpic(au->public_name, name) == 0)
914 { authbits |= BIT(authnum); break; }
918 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
919 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
921 if (tls_out.active.sock >= 0)
922 sx->ehlo_resp.crypted_auths = authbits;
924 sx->ehlo_resp.cleartext_auths = authbits;
931 /* Wait for and check responses for early-pipelining.
933 Called from the lower-level smtp_read_response() function
934 used for general code that assume synchronisation, if context
935 flags indicate outstanding early-pipelining commands. Also
936 called fom sync_responses() which handles pipelined commands.
939 sx smtp connection context
940 countp number of outstanding responses, adjusted on return
944 FAIL SMTP error in response
947 smtp_reap_early_pipe(smtp_context * sx, int * countp)
949 BOOL pending_BANNER = sx->pending_BANNER;
950 BOOL pending_EHLO = sx->pending_EHLO;
952 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
953 sx->pending_EHLO = FALSE;
957 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
959 if (!smtp_reap_banner(sx))
961 DEBUG(D_transport) debug_printf("bad banner\n");
968 unsigned peer_offered;
969 unsigned short authbits = 0, * ap;
971 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
973 if (!smtp_reap_ehlo(sx))
975 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
979 /* Compare the actual EHLO response to the cached value we assumed;
980 on difference, dump or rewrite the cache and arrange for a retry. */
982 ap = tls_out.active.sock < 0
983 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
985 peer_offered = ehlo_response(sx->buffer,
986 (tls_out.active.sock < 0 ? OPTION_TLS : OPTION_REQUIRETLS)
987 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
988 | OPTION_UTF8 | OPTION_EARLY_PIPE
990 if ( peer_offered != sx->peer_offered
991 || (authbits = study_ehlo_auths(sx)) != *ap)
994 debug_printf("EHLO %s extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
995 tls_out.active.sock < 0 ? "cleartext" : "crypted",
996 sx->peer_offered, *ap, peer_offered, authbits);
997 *(tls_out.active.sock < 0
998 ? &sx->ehlo_resp.cleartext_features : &sx->ehlo_resp.crypted_features) = peer_offered;
1000 if (peer_offered & OPTION_EARLY_PIPE)
1001 write_ehlo_cache_entry(sx);
1003 invalidate_ehlo_cache_entry(sx);
1005 return OK; /* just carry on */
1011 invalidate_ehlo_cache_entry(sx);
1012 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
1018 /*************************************************
1019 * Synchronize SMTP responses *
1020 *************************************************/
1022 /* This function is called from smtp_deliver() to receive SMTP responses from
1023 the server, and match them up with the commands to which they relate. When
1024 PIPELINING is not in use, this function is called after every command, and is
1025 therefore somewhat over-engineered, but it is simpler to use a single scheme
1026 that works both with and without PIPELINING instead of having two separate sets
1029 The set of commands that are buffered up with pipelining may start with MAIL
1030 and may end with DATA; in between are RCPT commands that correspond to the
1031 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1032 etc.) are never buffered.
1034 Errors after MAIL or DATA abort the whole process leaving the response in the
1035 buffer. After MAIL, pending responses are flushed, and the original command is
1036 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1037 permitted to reject some recipient addresses while accepting others. However
1038 certain errors clearly abort the whole process. Set the value in
1039 transport_return to PENDING_OK if the address is accepted. If there is a
1040 subsequent general error, it will get reset accordingly. If not, it will get
1041 converted to OK at the end.
1044 sx smtp connection context
1045 count the number of responses to read
1046 pending_DATA 0 if last command sent was not DATA
1047 +1 if previously had a good recipient
1048 -1 if not previously had a good recipient
1050 Returns: 3 if at least one address had 2xx and one had 5xx
1051 2 if at least one address had 5xx but none had 2xx
1052 1 if at least one host had a 2xx response, but none had 5xx
1053 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1054 -1 timeout while reading RCPT response
1055 -2 I/O or other non-response error for RCPT
1056 -3 DATA or MAIL failed - errno and buffer set
1057 -4 banner or EHLO failed (early-pipelining)
1061 sync_responses(smtp_context * sx, int count, int pending_DATA)
1063 address_item * addr = sx->sync_addr;
1064 smtp_transport_options_block * ob = sx->conn_args.ob;
1067 #ifdef EXPERIMENTAL_PIPE_CONNECT
1068 if (smtp_reap_early_pipe(sx, &count) != OK)
1072 /* Handle the response for a MAIL command. On error, reinstate the original
1073 command in big_buffer for error message use, and flush any further pending
1074 responses before returning, except after I/O errors and timeouts. */
1076 if (sx->pending_MAIL)
1078 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1080 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1081 '2', ob->command_timeout))
1083 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1084 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1085 if (errno == 0 && sx->buffer[0] != 0)
1088 if (sx->buffer[0] == '4')
1090 save_errno = ERRNO_MAIL4XX;
1091 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1093 count = smtp_discard_responses(sx, ob, count);
1097 if (pending_DATA) count--; /* Number of RCPT responses to come */
1098 while (count-- > 0) /* Mark any pending addrs with the host used */
1100 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1101 addr->host_used = sx->conn_args.host;
1108 if (pending_DATA) count--; /* Number of RCPT responses to come */
1110 /* Read and handle the required number of RCPT responses, matching each one up
1111 with an address by scanning for the next address whose status is PENDING_DEFER.
1116 while (addr->transport_return != PENDING_DEFER)
1117 if (!(addr = addr->next))
1120 /* The address was accepted */
1121 addr->host_used = sx->conn_args.host;
1123 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1124 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1125 '2', ob->command_timeout))
1128 addr->transport_return = PENDING_OK;
1130 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1131 ensure that any address-specific retry record is expunged. We do this both
1132 for the basic key and for the version that also includes the sender. */
1134 if (testflag(addr, af_dr_retry_exists))
1136 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1138 retry_add_item(addr, altkey, rf_delete);
1139 retry_add_item(addr, addr->address_retry_key, rf_delete);
1143 /* Timeout while reading the response */
1145 else if (errno == ETIMEDOUT)
1147 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1148 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1149 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
1150 retry_add_item(addr, addr->address_retry_key, 0);
1151 update_waiting = FALSE;
1155 /* Handle other errors in obtaining an SMTP response by returning -1. This
1156 will cause all the addresses to be deferred. Restore the SMTP command in
1157 big_buffer for which we are checking the response, so the error message
1160 else if (errno != 0 || sx->buffer[0] == 0)
1162 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
1163 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1167 /* Handle SMTP permanent and temporary response codes. */
1172 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1173 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1174 string_printing(sx->buffer));
1175 setflag(addr, af_pass_message);
1177 msglog_line(sx->conn_args.host, addr->message);
1179 /* The response was 5xx */
1181 if (sx->buffer[0] == '5')
1183 addr->transport_return = FAIL;
1187 /* The response was 4xx */
1191 addr->transport_return = DEFER;
1192 addr->basic_errno = ERRNO_RCPT4XX;
1193 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1197 #ifndef DISABLE_EVENT
1198 event_defer_errno = addr->more_errno;
1199 msg_event_raise(US"msg:rcpt:host:defer", addr);
1202 /* Log temporary errors if there are more hosts to be tried.
1203 If not, log this last one in the == line. */
1205 if (sx->conn_args.host->next)
1206 if (LOGGING(outgoing_port))
1207 log_write(0, LOG_MAIN, "H=%s [%s]:%d %s", sx->conn_args.host->name,
1208 sx->conn_args.host->address,
1209 sx->port == PORT_NONE ? 25 : sx->port, addr->message);
1211 log_write(0, LOG_MAIN, "H=%s [%s]: %s", sx->conn_args.host->name,
1212 sx->conn_args.host->address, addr->message);
1214 #ifndef DISABLE_EVENT
1216 msg_event_raise(US"msg:rcpt:defer", addr);
1219 /* Do not put this message on the list of those waiting for specific
1220 hosts, as otherwise it is likely to be tried too often. */
1222 update_waiting = FALSE;
1224 /* Add a retry item for the address so that it doesn't get tried again
1225 too soon. If address_retry_include_sender is true, add the sender address
1226 to the retry key. */
1228 retry_add_item(addr,
1229 ob->address_retry_include_sender
1230 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1231 : addr->address_retry_key,
1236 } /* Loop for next RCPT response */
1238 /* Update where to start at for the next block of responses, unless we
1239 have already handled all the addresses. */
1241 if (addr) sx->sync_addr = addr->next;
1243 /* Handle a response to DATA. If we have not had any good recipients, either
1244 previously or in this block, the response is ignored. */
1246 if (pending_DATA != 0)
1248 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1249 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1250 '3', ob->command_timeout))
1255 if (pending_DATA > 0 || (yield & 1) != 0)
1257 if (errno == 0 && sx->buffer[0] == '4')
1259 errno = ERRNO_DATA4XX;
1260 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1264 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1265 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1266 "is in use and there were no good recipients\n", msg);
1270 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1271 present) received 3xx. If any RCPTs were handled and yielded anything other
1272 than 4xx, yield will be set non-zero. */
1281 /* Try an authenticator's client entry */
1284 try_authenticator(smtp_context * sx, auth_instance * au)
1286 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1287 host_item * host = sx->conn_args.host; /* host to deliver to */
1290 sx->outblock.authenticating = TRUE;
1291 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1292 sx->buffer, sizeof(sx->buffer));
1293 sx->outblock.authenticating = FALSE;
1294 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1296 /* A temporary authentication failure must hold up delivery to
1297 this host. After a permanent authentication failure, we carry on
1298 to try other authentication methods. If all fail hard, try to
1299 deliver the message unauthenticated unless require_auth was set. */
1304 f.smtp_authenticated = TRUE; /* stops the outer loop */
1305 client_authenticator = au->name;
1306 if (au->set_client_id)
1307 client_authenticated_id = expand_string(au->set_client_id);
1310 /* Failure after writing a command */
1315 /* Failure after reading a response */
1318 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1319 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1320 au->name, host->name, host->address, sx->buffer);
1323 /* Failure by some other means. In effect, the authenticator
1324 decided it wasn't prepared to handle this case. Typically this
1325 is the result of "fail" in an expansion string. Do we need to
1326 log anything here? Feb 2006: a message is now put in the buffer
1327 if logging is required. */
1330 if (*sx->buffer != 0)
1331 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1332 "authentication H=%s [%s] %s", au->name, host->name,
1333 host->address, sx->buffer);
1336 /* Internal problem, message in buffer. */
1339 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1349 /* Do the client side of smtp-level authentication.
1352 sx smtp connection context
1354 sx->buffer should have the EHLO response from server (gets overwritten)
1357 OK Success, or failed (but not required): global "smtp_authenticated" set
1358 DEFER Failed authentication (and was required)
1359 ERROR Internal problem
1361 FAIL_SEND Failed communications - transmit
1366 smtp_auth(smtp_context * sx)
1368 host_item * host = sx->conn_args.host; /* host to deliver to */
1369 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1370 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1371 #ifdef EXPERIMENTAL_PIPE_CONNECT
1372 unsigned short authbits = tls_out.active.sock >= 0
1373 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1375 uschar * fail_reason = US"server did not advertise AUTH support";
1377 f.smtp_authenticated = FALSE;
1378 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1381 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1383 /* Is the server offering AUTH? */
1387 #ifdef EXPERIMENTAL_PIPE_CONNECT
1388 sx->early_pipe_active ? authbits
1391 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1394 uschar * names = NULL;
1395 expand_nmax = -1; /* reset */
1397 #ifdef EXPERIMENTAL_PIPE_CONNECT
1398 if (!sx->early_pipe_active)
1400 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1402 /* Must not do this check until after we have saved the result of the
1403 regex match above as the check could be another RE. */
1405 if ( require_auth == OK
1406 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1410 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1411 fail_reason = US"no common mechanisms were found";
1413 #ifdef EXPERIMENTAL_PIPE_CONNECT
1414 if (sx->early_pipe_active)
1416 /* Scan our authenticators (which support use by a client and were offered
1417 by the server (checked at cache-write time)), not suppressed by
1418 client_condition. If one is found, attempt to authenticate by calling its
1419 client function. We are limited to supporting up to 16 authenticator
1420 public-names by the number of bits in a short. */
1425 for (bitnum = 0, au = auths;
1426 !f.smtp_authenticated && au && bitnum < 16;
1427 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1429 if ( au->client_condition
1430 && !expand_check_condition(au->client_condition, au->name,
1431 US"client authenticator"))
1433 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1434 au->name, "client_condition is false");
1438 /* Found data for a listed mechanism. Call its client entry. Set
1439 a flag in the outblock so that data is overwritten after sending so
1440 that reflections don't show it. */
1442 fail_reason = US"authentication attempt(s) failed";
1444 if ((rc = try_authenticator(sx, au)) != OK)
1451 /* Scan the configured authenticators looking for one which is configured
1452 for use as a client, which is not suppressed by client_condition, and
1453 whose name matches an authentication mechanism supported by the server.
1454 If one is found, attempt to authenticate by calling its client function.
1457 for (auth_instance * au = auths; !f.smtp_authenticated && au; au = au->next)
1462 || ( au->client_condition
1463 && !expand_check_condition(au->client_condition, au->name,
1464 US"client authenticator")))
1466 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1468 (au->client)? "client_condition is false" :
1469 "not configured as a client");
1473 /* Loop to scan supported server mechanisms */
1477 int len = Ustrlen(au->public_name);
1480 while (isspace(*p)) p++;
1482 if (strncmpic(au->public_name, p, len) != 0 ||
1483 (p[len] != 0 && !isspace(p[len])))
1485 while (*p != 0 && !isspace(*p)) p++;
1489 /* Found data for a listed mechanism. Call its client entry. Set
1490 a flag in the outblock so that data is overwritten after sending so
1491 that reflections don't show it. */
1493 fail_reason = US"authentication attempt(s) failed";
1495 if ((rc = try_authenticator(sx, au)) != OK)
1498 break; /* If not authenticated, try next authenticator */
1499 } /* Loop for scanning supported server mechanisms */
1500 } /* Loop for further authenticators */
1504 /* If we haven't authenticated, but are required to, give up. */
1506 if (require_auth == OK && !f.smtp_authenticated)
1508 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1509 string_sprintf("authentication required but %s", fail_reason), DEFER,
1518 /* Construct AUTH appendix string for MAIL TO */
1521 buffer to build string
1522 addrlist chain of potential addresses to deliver
1523 ob transport options
1525 Globals f.smtp_authenticated
1526 client_authenticated_sender
1527 Return True on error, otherwise buffer has (possibly empty) terminated string
1531 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1532 smtp_transport_options_block *ob)
1534 uschar *local_authenticated_sender = authenticated_sender;
1537 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1540 if (ob->authenticated_sender != NULL)
1542 uschar *new = expand_string(ob->authenticated_sender);
1545 if (!f.expand_string_forcedfail)
1547 uschar *message = string_sprintf("failed to expand "
1548 "authenticated_sender: %s", expand_string_message);
1549 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1553 else if (new[0] != 0) 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 != NULL)
1561 string_format(buffer, bufsize, " AUTH=%s",
1562 auth_xtextencode(local_authenticated_sender,
1563 Ustrlen(local_authenticated_sender)));
1564 client_authenticated_sender = string_copy(local_authenticated_sender);
1575 /* Lookup TLSA record for host/port.
1576 Return: OK success with dnssec; DANE mode
1577 DEFER Do not use this host now, may retry later
1578 FAIL_FORCED No TLSA record; DANE not usable
1579 FAIL Do not use this connection
1583 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1585 /* move this out to host.c given the similarity to dns_lookup() ? */
1587 const uschar * fullname = buffer;
1591 /* TLSA lookup string */
1592 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1594 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1595 sec = dns_is_secure(dnsa);
1597 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1602 return DEFER; /* just defer this TLS'd conn */
1610 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1611 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1612 if (rr->type == T_TLSA && rr->size > 3)
1614 uint16_t payload_length = rr->size - 3;
1615 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1617 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1618 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1619 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1620 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1621 sp += sprintf(CS sp, "%02x", *p++);
1623 debug_printf(" %s\n", s);
1628 log_write(0, LOG_MAIN,
1629 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1632 case DNS_NODATA: /* no TLSA RR for this lookup */
1633 case DNS_NOMATCH: /* no records at all for this lookup */
1634 return dane_required ? FAIL : FAIL_FORCED;
1638 return dane_required ? FAIL : DEFER;
1645 typedef struct smtp_compare_s
1647 uschar *current_sender_address;
1648 struct transport_instance *tblock;
1652 /* Create a unique string that identifies this message, it is based on
1653 sender_address, helo_data and tls_certificate if enabled.
1657 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1659 address_item * addr1;
1660 uschar * if1 = US"";
1661 uschar * helo1 = US"";
1663 uschar * tlsc1 = US"";
1665 uschar * save_sender_address = sender_address;
1666 uschar * local_identity = NULL;
1667 smtp_transport_options_block * ob = SOB tblock->options_block;
1669 sender_address = sender;
1671 addr1 = deliver_make_addr (sender, TRUE);
1672 deliver_set_expansions(addr1);
1675 if1 = expand_string(ob->interface);
1678 helo1 = expand_string(ob->helo_data);
1681 if (ob->tls_certificate)
1682 tlsc1 = expand_string(ob->tls_certificate);
1683 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1685 local_identity = string_sprintf ("%s^%s", if1, helo1);
1688 deliver_set_expansions(NULL);
1689 sender_address = save_sender_address;
1691 return local_identity;
1696 /* This routine is a callback that is called from transport_check_waiting.
1697 This function will evaluate the incoming message versus the previous
1698 message. If the incoming message is using a different local identity then
1699 we will veto this new message. */
1702 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1704 uschar * message_local_identity,
1705 * current_local_identity,
1706 * new_sender_address;
1708 current_local_identity =
1709 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1711 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1714 message_local_identity =
1715 smtp_local_identity(new_sender_address, s_compare->tblock);
1717 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1723 ehlo_response(uschar * buf, unsigned checks)
1725 size_t bsize = Ustrlen(buf);
1727 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1730 # ifdef EXPERIMENTAL_REQUIRETLS
1731 if ( checks & OPTION_REQUIRETLS
1732 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1734 checks &= ~OPTION_REQUIRETLS;
1736 if ( checks & OPTION_TLS
1737 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1739 checks &= ~OPTION_TLS;
1741 if ( checks & OPTION_IGNQ
1742 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1743 PCRE_EOPT, NULL, 0) < 0)
1744 checks &= ~OPTION_IGNQ;
1746 if ( checks & OPTION_CHUNKING
1747 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1748 checks &= ~OPTION_CHUNKING;
1750 #ifndef DISABLE_PRDR
1751 if ( checks & OPTION_PRDR
1752 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1754 checks &= ~OPTION_PRDR;
1757 if ( checks & OPTION_UTF8
1758 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1760 checks &= ~OPTION_UTF8;
1762 if ( checks & OPTION_DSN
1763 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1764 checks &= ~OPTION_DSN;
1766 if ( checks & OPTION_PIPE
1767 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1768 PCRE_EOPT, NULL, 0) < 0)
1769 checks &= ~OPTION_PIPE;
1771 if ( checks & OPTION_SIZE
1772 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1773 checks &= ~OPTION_SIZE;
1775 #ifdef EXPERIMENTAL_PIPE_CONNECT
1776 if ( checks & OPTION_EARLY_PIPE
1777 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1778 PCRE_EOPT, NULL, 0) < 0)
1780 checks &= ~OPTION_EARLY_PIPE;
1782 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1788 /* Callback for emitting a BDAT data chunk header.
1790 If given a nonzero size, first flush any buffered SMTP commands
1791 then emit the command.
1793 Reap previous SMTP command responses if requested, and always reap
1794 the response from a previous BDAT command.
1797 tctx transport context
1798 chunk_size value for SMTP BDAT command
1800 tc_chunk_last add LAST option to SMTP BDAT command
1801 tc_reap_prev reap response to previous SMTP commands
1803 Returns: OK or ERROR
1807 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1810 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1811 smtp_context * sx = tctx->smtp_context;
1815 /* Write SMTP chunk header command. If not reaping responses, note that
1816 there may be more writes (like, the chunk data) done soon. */
1820 #ifdef EXPERIMENTAL_PIPE_CONNECT
1821 BOOL new_conn = !!(sx->outblock.conn_args);
1823 if((cmd_count = smtp_write_command(sx,
1824 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1825 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1826 ) < 0) return ERROR;
1827 if (flags & tc_chunk_last)
1828 data_command = string_copy(big_buffer); /* Save for later error message */
1829 #ifdef EXPERIMENTAL_PIPE_CONNECT
1830 /* That command write could have been the one that made the connection.
1831 Copy the fd from the client conn ctx (smtp transport specific) to the
1832 generic transport ctx. */
1835 tctx->u.fd = sx->outblock.cctx->sock;
1839 prev_cmd_count = cmd_count += sx->cmd_count;
1841 /* Reap responses for any previous, but not one we just emitted */
1845 if (sx->pending_BDAT)
1848 if (flags & tc_reap_prev && prev_cmd_count > 0)
1850 DEBUG(D_transport) debug_printf("look for %d responses"
1851 " for previous pipelined cmds\n", prev_cmd_count);
1853 switch(sync_responses(sx, prev_cmd_count, 0))
1855 case 1: /* 2xx (only) => OK */
1856 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1857 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1858 case 0: break; /* No 2xx or 5xx, but no probs */
1860 case -1: /* Timeout on RCPT */
1861 #ifdef EXPERIMENTAL_PIPE_CONNECT
1862 case -4: /* non-2xx for pipelined banner or EHLO */
1864 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1867 if (!sx->pending_BDAT)
1868 pipelining_active = FALSE;
1871 /* Reap response for an outstanding BDAT */
1873 if (sx->pending_BDAT)
1875 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1877 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1878 ob->command_timeout))
1880 if (errno == 0 && sx->buffer[0] == '4')
1882 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1883 sx->addrlist->more_errno |=
1884 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1889 sx->pending_BDAT = FALSE;
1890 pipelining_active = FALSE;
1892 else if (chunk_size > 0)
1893 sx->pending_BDAT = TRUE;
1896 sx->cmd_count = cmd_count;
1904 /*************************************************
1905 * Make connection for given message *
1906 *************************************************/
1910 ctx connection context
1911 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1912 a second attempt after TLS initialization fails
1914 Returns: OK - the connection was made and the delivery attempted;
1915 fd is set in the conn context, tls_out set up.
1916 DEFER - the connection could not be made, or something failed
1917 while setting up the SMTP session, or there was a
1918 non-message-specific error, such as a timeout.
1919 ERROR - helo_data or add_headers or authenticated_sender is
1920 specified for this transport, and the string failed
1924 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1926 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1927 dns_answer tlsa_dnsa;
1929 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1930 BOOL pass_message = FALSE;
1931 uschar * message = NULL;
1935 sx->conn_args.ob = ob;
1937 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1938 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1940 sx->send_rset = TRUE;
1941 sx->send_quit = TRUE;
1942 sx->setting_up = TRUE;
1944 sx->esmtp_sent = FALSE;
1946 sx->utf8_needed = FALSE;
1948 sx->dsn_all_lasthop = TRUE;
1949 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1952 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1954 #ifdef EXPERIMENTAL_PIPE_CONNECT
1955 sx->early_pipe_active = sx->early_pipe_ok = FALSE;
1956 sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0;
1957 sx->pending_BANNER = sx->pending_EHLO = FALSE;
1960 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1961 sx->peer_offered = 0;
1962 sx->avoid_option = 0;
1963 sx->igquotstr = US"";
1964 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1965 #ifdef EXPERIMENTAL_DSN_INFO
1966 sx->smtp_greeting = NULL;
1967 sx->helo_response = NULL;
1970 smtp_command = US"initial connection";
1971 sx->buffer[0] = '\0';
1973 /* Set up the buffer for reading SMTP response packets. */
1975 sx->inblock.buffer = sx->inbuffer;
1976 sx->inblock.buffersize = sizeof(sx->inbuffer);
1977 sx->inblock.ptr = sx->inbuffer;
1978 sx->inblock.ptrend = sx->inbuffer;
1980 /* Set up the buffer for holding SMTP commands while pipelining */
1982 sx->outblock.buffer = sx->outbuffer;
1983 sx->outblock.buffersize = sizeof(sx->outbuffer);
1984 sx->outblock.ptr = sx->outbuffer;
1985 sx->outblock.cmd_count = 0;
1986 sx->outblock.authenticating = FALSE;
1987 sx->outblock.conn_args = NULL;
1989 /* Reset the parameters of a TLS session. */
1992 tls_out.cipher = NULL; /* the one we may use for this transport */
1993 tls_out.ourcert = NULL;
1994 tls_out.peercert = NULL;
1995 tls_out.peerdn = NULL;
1996 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1999 tls_out.ocsp = OCSP_NOT_REQ;
2001 /* Flip the legacy TLS-related variables over to the outbound set in case
2002 they're used in the context of the transport. Don't bother resetting
2003 afterward (when being used by a transport) as we're in a subprocess.
2004 For verify, unflipped once the callout is dealt with */
2006 tls_modify_variables(&tls_out);
2011 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
2017 /* Make a connection to the host if this isn't a continued delivery, and handle
2018 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2019 specially so they can be identified for retries. */
2021 if (!continue_hostname)
2024 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2026 /* Get the actual port the connection will use, into sx->conn_args.host */
2028 smtp_port_for_connect(sx->conn_args.host, sx->port);
2030 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
2031 /* Do TLSA lookup for DANE */
2033 tls_out.dane_verified = FALSE;
2034 tls_out.tlsa_usage = 0;
2036 if (sx->conn_args.host->dnssec == DS_YES)
2038 if( sx->dane_required
2039 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2041 switch (rc = tlsa_lookup(sx->conn_args.host, &tlsa_dnsa, sx->dane_required))
2043 case OK: sx->dane = TRUE;
2044 ob->tls_tempfail_tryclear = FALSE;
2046 case FAIL_FORCED: break;
2047 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2048 string_sprintf("DANE error: tlsa lookup %s",
2051 # ifndef DISABLE_EVENT
2052 (void) event_raise(sx->conn_args.tblock->event_action,
2053 US"dane:fail", sx->dane_required
2054 ? US"dane-required" : US"dnssec-invalid");
2059 else if (sx->dane_required)
2061 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2062 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2064 # ifndef DISABLE_EVENT
2065 (void) event_raise(sx->conn_args.tblock->event_action,
2066 US"dane:fail", US"dane-required");
2073 /* Make the TCP connection */
2075 sx->cctx.tls_ctx = NULL;
2076 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2077 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2079 #ifdef EXPERIMENTAL_PIPE_CONNECT
2080 if (verify_check_given_host(CUSS &ob->hosts_pipe_connect, sx->conn_args.host) == OK)
2082 sx->early_pipe_ok = TRUE;
2083 if ( read_ehlo_cache_entry(sx)
2084 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2086 DEBUG(D_transport) debug_printf("Using cached cleartext PIPE_CONNECT\n");
2087 sx->early_pipe_active = TRUE;
2088 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2092 if (sx->early_pipe_active)
2093 sx->outblock.conn_args = &sx->conn_args;
2097 if ((sx->cctx.sock = smtp_connect(&sx->conn_args, NULL)) < 0)
2099 uschar * msg = NULL;
2102 msg = US strerror(errno);
2103 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
2105 set_errno_nohost(sx->addrlist,
2106 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2107 sx->verify ? string_sprintf("could not connect: %s", msg)
2110 sx->send_quit = FALSE;
2114 /* Expand the greeting message while waiting for the initial response. (Makes
2115 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2116 delayed till here so that $sending_interface and $sending_port are set. */
2117 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2118 will be? Somehow I doubt it. */
2121 if (!(sx->helo_data = expand_string(sx->helo_data)))
2123 log_write(0, LOG_MAIN|LOG_PANIC,
2124 "<%s>: failed to expand transport's helo_data value for callout: %s",
2125 sx->addrlist->address, expand_string_message);
2130 expand_string_message = NULL;
2131 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2132 &expand_string_message)),
2133 expand_string_message)
2135 log_write(0, LOG_MAIN|LOG_PANIC,
2136 "<%s>: failed to expand transport's helo_data value for callout: %s",
2137 sx->addrlist->address, expand_string_message);
2139 sx->helo_data = NULL;
2143 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2144 is nevertheless a reasonably clean way of programming this kind of logic,
2145 where you want to escape on any error. */
2149 #ifdef EXPERIMENTAL_PIPE_CONNECT
2150 if (sx->early_pipe_active)
2152 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2153 sx->outblock.cmd_count = 1;
2159 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2162 if (!smtp_reap_banner(sx))
2163 goto RESPONSE_FAILED;
2166 #ifndef DISABLE_EVENT
2169 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2170 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2171 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2174 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2175 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2183 /* Now check if the helo_data expansion went well, and sign off cleanly if
2188 message = string_sprintf("failed to expand helo_data: %s",
2189 expand_string_message);
2190 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2196 /** Debugging without sending a message
2197 sx->addrlist->transport_return = DEFER;
2201 /* Errors that occur after this point follow an SMTP command, which is
2202 left in big_buffer by smtp_write_command() for use in error messages. */
2204 smtp_command = big_buffer;
2206 /* Tell the remote who we are...
2208 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2209 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2210 greeting is of this form. The assumption was that the far end supports it
2211 properly... but experience shows that there are some that give 5xx responses,
2212 even though the banner includes "ESMTP" (there's a bloody-minded one that
2213 says "ESMTP not spoken here"). Cope with that case.
2215 September 2000: Time has passed, and it seems reasonable now to always send
2216 EHLO at the start. It is also convenient to make the change while installing
2219 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2220 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2221 would be no way to send out the mails, so there is now a host list
2222 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2223 PIPELINING problem as well. Maybe it can also be useful to cure other
2224 problems with broken servers.
2226 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2227 Then somebody tried it with a Microsoft mailer... It seems that all other
2228 mailers use upper case for some reason (the RFC is quite clear about case
2229 independence) so, for peace of mind, I gave in. */
2231 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2233 /* Alas; be careful, since this goto is not an error-out, so conceivably
2234 we might set data between here and the target which we assume to exist
2235 and be usable. I can see this coming back to bite us. */
2239 smtp_peer_options |= OPTION_TLS;
2240 suppress_tls = FALSE;
2241 ob->tls_tempfail_tryclear = FALSE;
2242 smtp_command = US"SSL-on-connect";
2249 if (smtp_write_command(sx,
2250 #ifdef EXPERIMENTAL_PIPE_CONNECT
2251 sx->early_pipe_active ? SCMD_BUFFER :
2254 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2256 sx->esmtp_sent = TRUE;
2258 #ifdef EXPERIMENTAL_PIPE_CONNECT
2259 if (sx->early_pipe_active)
2261 sx->pending_EHLO = TRUE;
2263 /* If we have too many authenticators to handle and might need to AUTH
2264 for this transport, pipeline no further as we will need the
2265 list of auth methods offered. Reap the banner and EHLO. */
2267 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2268 && f.smtp_in_early_pipe_no_auth)
2270 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2271 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2273 if (sync_responses(sx, 2, 0) != 0)
2276 debug_printf("failed reaping pipelined cmd responses\n");
2277 goto RESPONSE_FAILED;
2279 sx->early_pipe_active = FALSE;
2284 if (!smtp_reap_ehlo(sx))
2285 goto RESPONSE_FAILED;
2289 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2291 #ifdef EXPERIMENTAL_PIPE_CONNECT
2292 if (!sx->early_pipe_active)
2297 int n = sizeof(sx->buffer);
2298 uschar * rsp = sx->buffer;
2300 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2301 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2303 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2305 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2306 #ifdef EXPERIMENTAL_DSN_INFO
2307 sx->helo_response = string_copy(rsp);
2311 /* Handle special logging for a closed connection after HELO
2312 when had previously sent EHLO */
2314 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2316 errno = ERRNO_SMTPCLOSED;
2317 goto EHLOHELO_FAILED;
2319 memmove(sx->buffer, rsp, Ustrlen(rsp));
2320 goto RESPONSE_FAILED;
2324 if (sx->esmtp || sx->lmtp)
2326 #ifdef EXPERIMENTAL_PIPE_CONNECT
2327 if (!sx->early_pipe_active)
2330 sx->peer_offered = ehlo_response(sx->buffer,
2331 OPTION_TLS /* others checked later */
2332 #ifdef EXPERIMENTAL_PIPE_CONNECT
2333 | (sx->early_pipe_ok
2335 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2344 #ifdef EXPERIMENTAL_PIPE_CONNECT
2345 if (sx->early_pipe_ok)
2347 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2349 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2350 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2352 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2353 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2354 write_ehlo_cache_entry(sx);
2360 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2363 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2368 /* For continuing deliveries down the same channel, having re-exec'd the socket
2369 is the standard input; for a socket held open from verify it is recorded
2370 in the cutthrough context block. Either way we don't need to redo EHLO here
2371 (but may need to do so for TLS - see below).
2372 Set up the pointer to where subsequent commands will be left, for
2373 error messages. Note that smtp_peer_options will have been
2374 set from the command line if they were set in the process that passed the
2377 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2378 as the continue goes via transport_pass_socket() and doublefork and exec.
2379 It does not wait. Unclear how we keep separate host's responses
2380 separate - we could match up by host ip+port as a bodge. */
2384 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2386 sx->cctx = cutthrough.cctx;
2387 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2391 sx->cctx.sock = 0; /* stdin */
2392 sx->cctx.tls_ctx = NULL;
2393 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2395 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2396 smtp_command = big_buffer;
2397 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2399 /* For a continued connection with TLS being proxied for us, or a
2400 held-open verify connection with TLS, nothing more to do. */
2402 if ( continue_proxy_cipher
2403 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2404 && cutthrough.is_tls)
2407 sx->peer_offered = smtp_peer_options;
2408 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2409 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2410 continue_proxy_cipher ? "proxied" : "verify conn with");
2413 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2416 /* If TLS is available on this connection, whether continued or not, attempt to
2417 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2418 send another EHLO - the server may give a different answer in secure mode. We
2419 use a separate buffer for reading the response to STARTTLS so that if it is
2420 negative, the original EHLO data is available for subsequent analysis, should
2421 the client not be required to use TLS. If the response is bad, copy the buffer
2422 for error analysis. */
2425 if ( smtp_peer_options & OPTION_TLS
2427 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2429 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2432 uschar buffer2[4096];
2434 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2437 #ifdef EXPERIMENTAL_PIPE_CONNECT
2438 /* If doing early-pipelining reap the banner and EHLO-response but leave
2439 the response for the STARTTLS we just sent alone. */
2441 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2444 debug_printf("failed reaping pipelined cmd responses\n");
2445 goto RESPONSE_FAILED;
2449 /* If there is an I/O error, transmission of this message is deferred. If
2450 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2451 false, we also defer. However, if there is a temporary rejection of STARTTLS
2452 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2453 STARTTLS, we carry on. This means we will try to send the message in clear,
2454 unless the host is in hosts_require_tls (tested below). */
2456 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2460 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2463 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2464 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2465 goto RESPONSE_FAILED;
2469 /* STARTTLS accepted: try to negotiate a TLS session. */
2475 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->conn_args.host,
2476 sx->addrlist, sx->conn_args.tblock,
2477 # ifdef SUPPORT_DANE
2478 sx->dane ? &tlsa_dnsa : NULL,
2482 if (!sx->cctx.tls_ctx)
2484 /* TLS negotiation failed; give an error. From outside, this function may
2485 be called again to try in clear on a new connection, if the options permit
2486 it for this host. */
2487 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", errstr);
2489 # ifdef SUPPORT_DANE
2492 log_write(0, LOG_MAIN,
2493 "DANE attempt failed; TLS connection to %s [%s]: %s",
2494 sx->conn_args.host->name, sx->conn_args.host->address, errstr);
2495 # ifndef DISABLE_EVENT
2496 (void) event_raise(sx->conn_args.tblock->event_action,
2497 US"dane:fail", US"validation-failure"); /* could do with better detail */
2502 errno = ERRNO_TLSFAILURE;
2503 message = string_sprintf("TLS session: %s", errstr);
2504 sx->send_quit = FALSE;
2508 /* TLS session is set up */
2510 smtp_peer_options_wrap = smtp_peer_options;
2511 for (address_item * addr = sx->addrlist; addr; addr = addr->next)
2512 if (addr->transport_return == PENDING_DEFER)
2514 addr->cipher = tls_out.cipher;
2515 addr->ourcert = tls_out.ourcert;
2516 addr->peercert = tls_out.peercert;
2517 addr->peerdn = tls_out.peerdn;
2518 addr->ocsp = tls_out.ocsp;
2523 /* if smtps, we'll have smtp_command set to something else; always safe to
2525 smtp_command = big_buffer;
2527 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2528 helo_data is null, we are dealing with a connection that was passed from
2529 another process, and so we won't have expanded helo_data above. We have to
2530 expand it here. $sending_ip_address and $sending_port are set up right at the
2531 start of the Exim process (in exim.c). */
2533 if (tls_out.active.sock >= 0)
2535 uschar * greeting_cmd;
2537 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2539 uschar *message = string_sprintf("failed to expand helo_data: %s",
2540 expand_string_message);
2541 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2546 #ifdef EXPERIMENTAL_PIPE_CONNECT
2547 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2548 We're unlikely to get the group sent and delivered before the server sends its
2549 banner, but it's still worth sending as a group.
2550 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2553 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2555 sx->peer_offered = sx->ehlo_resp.crypted_features;
2556 if ((sx->early_pipe_active =
2557 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2558 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2562 /* For SMTPS we need to wait for the initial OK response. */
2564 #ifdef EXPERIMENTAL_PIPE_CONNECT
2565 if (sx->early_pipe_active)
2567 sx->pending_BANNER = TRUE;
2568 sx->outblock.cmd_count = 1;
2572 if (!smtp_reap_banner(sx))
2573 goto RESPONSE_FAILED;
2576 greeting_cmd = US"LHLO";
2578 greeting_cmd = US"EHLO";
2581 greeting_cmd = US"HELO";
2583 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2586 if (smtp_write_command(sx,
2587 #ifdef EXPERIMENTAL_PIPE_CONNECT
2588 sx->early_pipe_active ? SCMD_BUFFER :
2591 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2594 #ifdef EXPERIMENTAL_PIPE_CONNECT
2595 if (sx->early_pipe_active)
2596 sx->pending_EHLO = TRUE;
2600 if (!smtp_reap_ehlo(sx))
2601 goto RESPONSE_FAILED;
2602 smtp_peer_options = 0;
2606 /* If the host is required to use a secure channel, ensure that we
2610 # ifdef SUPPORT_DANE
2613 # ifdef EXPERIMENTAL_REQUIRETLS
2614 || tls_requiretls & REQUIRETLS_MSG
2616 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2620 # ifdef EXPERIMENTAL_REQUIRETLS
2621 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2624 message = string_sprintf("a TLS session is required, but %s",
2625 smtp_peer_options & OPTION_TLS
2626 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2627 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2629 (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2630 smtp_peer_options & OPTION_TLS
2631 ? US"validation-failure" /* could do with better detail */
2632 : US"starttls-not-supported");
2636 #endif /*SUPPORT_TLS*/
2638 /* If TLS is active, we have just started it up and re-done the EHLO command,
2639 so its response needs to be analyzed. If TLS is not active and this is a
2640 continued session down a previously-used socket, we haven't just done EHLO, so
2643 if (continue_hostname == NULL
2645 || tls_out.active.sock >= 0
2649 if (sx->esmtp || sx->lmtp)
2651 #ifdef EXPERIMENTAL_PIPE_CONNECT
2652 if (!sx->early_pipe_active)
2655 sx->peer_offered = ehlo_response(sx->buffer,
2657 #ifdef EXPERIMENTAL_PIPE_CONNECT
2658 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2659 | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2660 | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8 | OPTION_REQUIRETLS
2661 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2665 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2668 # ifdef SUPPORT_I18N
2669 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2670 /*XXX if we hand peercaps on to continued-conn processes,
2671 must not depend on this addr */
2675 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2676 # if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2677 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2681 #ifdef EXPERIMENTAL_PIPE_CONNECT
2682 if (tls_out.active.sock >= 0)
2683 sx->ehlo_resp.crypted_features = sx->peer_offered;
2687 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2688 lmtp_ignore_quota option was set. */
2690 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2692 /* If the response to EHLO specified support for the SIZE parameter, note
2693 this, provided size_addition is non-negative. */
2695 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2697 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2698 the current host, esmtp will be false, so PIPELINING can never be used. If
2699 the current host matches hosts_avoid_pipelining, don't do it. */
2701 if ( sx->peer_offered & OPTION_PIPE
2702 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2703 smtp_peer_options |= OPTION_PIPE;
2705 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2706 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2708 if ( sx->peer_offered & OPTION_CHUNKING
2709 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2710 sx->peer_offered &= ~OPTION_CHUNKING;
2712 if (sx->peer_offered & OPTION_CHUNKING)
2713 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2715 #ifndef DISABLE_PRDR
2716 if ( sx->peer_offered & OPTION_PRDR
2717 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2718 sx->peer_offered &= ~OPTION_PRDR;
2720 if (sx->peer_offered & OPTION_PRDR)
2721 DEBUG(D_transport) debug_printf("PRDR usable\n");
2724 /* Note if the server supports DSN */
2725 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2726 DEBUG(D_transport) debug_printf("%susing DSN\n",
2727 sx->peer_offered & OPTION_DSN ? "" : "not ");
2729 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2730 if (sx->peer_offered & OPTION_REQUIRETLS)
2732 smtp_peer_options |= OPTION_REQUIRETLS;
2733 DEBUG(D_transport) debug_printf(
2734 tls_requiretls & REQUIRETLS_MSG
2735 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2739 #ifdef EXPERIMENTAL_PIPE_CONNECT
2740 if ( sx->early_pipe_ok
2741 && !sx->early_pipe_active
2742 && tls_out.active.sock >= 0
2743 && smtp_peer_options & OPTION_PIPE
2744 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2745 & OPTION_EARLY_PIPE)
2747 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2748 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2749 write_ehlo_cache_entry(sx);
2753 /* Note if the response to EHLO specifies support for the AUTH extension.
2754 If it has, check that this host is one we want to authenticate to, and do
2755 the business. The host name and address must be available when the
2756 authenticator's client driver is running. */
2758 switch (yield = smtp_auth(sx))
2760 default: goto SEND_QUIT;
2762 case FAIL_SEND: goto SEND_FAILED;
2763 case FAIL: goto RESPONSE_FAILED;
2767 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2769 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2770 message-specific. */
2772 sx->setting_up = FALSE;
2775 if (sx->addrlist->prop.utf8_msg)
2779 /* If the transport sets a downconversion mode it overrides any set by ACL
2782 if ((s = ob->utf8_downconvert))
2784 if (!(s = expand_string(s)))
2786 message = string_sprintf("failed to expand utf8_downconvert: %s",
2787 expand_string_message);
2788 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2794 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2795 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2797 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2798 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2800 case '-': if (s[1] == '1')
2802 sx->addrlist->prop.utf8_downcvt = FALSE;
2803 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2809 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2810 && !sx->addrlist->prop.utf8_downcvt_maybe;
2811 DEBUG(D_transport) if (!sx->utf8_needed)
2812 debug_printf("utf8: %s downconvert\n",
2813 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2816 /* If this is an international message we need the host to speak SMTPUTF8 */
2817 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2819 errno = ERRNO_UTF8_FWD;
2820 goto RESPONSE_FAILED;
2822 #endif /*SUPPORT_I18N*/
2824 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2825 /*XXX should tls_requiretls actually be per-addr? */
2827 if ( tls_requiretls & REQUIRETLS_MSG
2828 && !(sx->peer_offered & OPTION_REQUIRETLS)
2831 sx->setting_up = TRUE;
2832 errno = ERRNO_REQUIRETLS;
2833 message = US"REQUIRETLS support is required from the server"
2834 " but it was not offered";
2835 DEBUG(D_transport) debug_printf("%s\n", message);
2848 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2849 sx->buffer, &code, &message, &pass_message);
2855 message = US string_sprintf("send() to %s [%s] failed: %s",
2856 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2857 sx->send_quit = FALSE;
2863 message = string_sprintf("Remote host closed connection in response to %s"
2864 " (EHLO response was: %s)", smtp_command, sx->buffer);
2865 sx->send_quit = FALSE;
2869 /* This label is jumped to directly when a TLS negotiation has failed,
2870 or was not done for a host for which it is required. Values will be set
2871 in message and errno, and setting_up will always be true. Treat as
2872 a temporary error. */
2876 # ifdef EXPERIMENTAL_REQUIRETLS
2877 if (errno == ERRNO_REQUIRETLS)
2878 code = '5', yield = FAIL;
2879 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2882 code = '4', yield = DEFER;
2886 /* The failure happened while setting up the call; see if the failure was
2887 a 5xx response (this will either be on connection, or following HELO - a 5xx
2888 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2889 fail all addresses, as this host is never going to accept them. For other
2890 errors during setting up (timeouts or whatever), defer all addresses, and
2891 yield DEFER, so that the host is not tried again for a while.
2893 XXX This peeking for another host feels like a layering violation. We want
2894 to note the host as unusable, but down here we shouldn't know if this was
2895 the last host to try for the addr(list). Perhaps the upper layer should be
2896 the one to do set_errno() ? The problem is that currently the addr is where
2897 errno etc. are stashed, but until we run out of hosts to try the errors are
2898 host-specific. Maybe we should enhance the host_item definition? */
2901 sx->ok = FALSE; /* For when reached by GOTO */
2902 set_errno(sx->addrlist, errno, message,
2903 sx->conn_args.host->next
2907 || errno == ERRNO_UTF8_FWD
2910 pass_message, sx->conn_args.host
2911 #ifdef EXPERIMENTAL_DSN_INFO
2912 , sx->smtp_greeting, sx->helo_response
2921 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2924 if (sx->cctx.tls_ctx)
2926 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2927 sx->cctx.tls_ctx = NULL;
2931 /* Close the socket, and return the appropriate value, first setting
2932 works because the NULL setting is passed back to the calling process, and
2933 remote_max_parallel is forced to 1 when delivering over an existing connection,
2936 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2939 shutdown(sx->cctx.sock, SHUT_WR);
2940 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2941 for (int i = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && i > 0;)
2942 i--; /* drain socket */
2943 sx->send_quit = FALSE;
2945 (void)close(sx->cctx.sock);
2948 #ifndef DISABLE_EVENT
2949 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2952 continue_transport = NULL;
2953 continue_hostname = NULL;
2960 /* Create the string of options that will be appended to the MAIL FROM:
2961 in the connection context buffer */
2964 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2966 uschar * p = sx->buffer;
2967 address_item * addr;
2972 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2973 send it, adding something to the message size to allow for imprecision
2974 and things that get added en route. Exim keeps the number of lines
2975 in a message, so we can give an accurate value for the original message, but we
2976 need some additional to handle added headers. (Double "." characters don't get
2977 included in the count.) */
2979 if ( message_size > 0
2980 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2982 /*XXX problem here under spool_files_wireformat?
2983 Or just forget about lines? Or inflate by a fixed proportion? */
2985 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
2989 #ifndef DISABLE_PRDR
2990 /* If it supports Per-Recipient Data Responses, and we have more than one recipient,
2993 sx->prdr_active = FALSE;
2994 if (sx->peer_offered & OPTION_PRDR)
2995 for (address_item * addr = addrlist; addr; addr = addr->next)
2996 if (addr->transport_return == PENDING_DEFER)
2998 for (addr = addr->next; addr; addr = addr->next)
2999 if (addr->transport_return == PENDING_DEFER)
3000 { /* at least two recipients to send */
3001 sx->prdr_active = TRUE;
3002 sprintf(CS p, " PRDR"); p += 5;
3010 /* If it supports internationalised messages, and this meesage need that,
3013 if ( sx->peer_offered & OPTION_UTF8
3014 && addrlist->prop.utf8_msg
3015 && !addrlist->prop.utf8_downcvt
3017 Ustrcpy(p, " SMTPUTF8"), p += 9;
3020 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3021 if (tls_requiretls & REQUIRETLS_MSG)
3022 Ustrcpy(p, " REQUIRETLS") , p += 11;
3025 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3026 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3027 addr && address_count < sx->max_rcpt;
3028 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3031 if (!(addr->dsn_flags & rf_dsnlasthop))
3033 sx->dsn_all_lasthop = FALSE;
3038 /* Add any DSN flags to the mail command */
3040 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3042 if (dsn_ret == dsn_ret_hdrs)
3043 { Ustrcpy(p, " RET=HDRS"); p += 9; }
3044 else if (dsn_ret == dsn_ret_full)
3045 { Ustrcpy(p, " RET=FULL"); p += 9; }
3049 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3054 /* If an authenticated_sender override has been specified for this transport
3055 instance, expand it. If the expansion is forced to fail, and there was already
3056 an authenticated_sender for this message, the original value will be used.
3057 Other expansion failures are serious. An empty result is ignored, but there is
3058 otherwise no check - this feature is expected to be used with LMTP and other
3059 cases where non-standard addresses (e.g. without domains) might be required. */
3061 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->conn_args.ob))
3069 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3071 uschar * p = sx->buffer;
3074 /* Add any DSN flags to the rcpt command */
3076 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3078 if (addr->dsn_flags & rf_dsnflags)
3082 Ustrcpy(p, " NOTIFY=");
3084 for (int i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3086 if (!first) *p++ = ',';
3088 Ustrcpy(p, rf_names[i]);
3093 if (addr->dsn_orcpt)
3095 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3106 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3107 -1 MAIL response error
3108 -2 any non-MAIL read i/o error
3109 -3 non-MAIL response timeout
3110 -4 internal error; channel still usable
3115 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3117 address_item * addr;
3121 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3127 /* From here until we send the DATA command, we can make use of PIPELINING
3128 if the server host supports it. The code has to be able to check the responses
3129 at any point, for when the buffer fills up, so we write it totally generally.
3130 When PIPELINING is off, each command written reports that it has flushed the
3133 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3136 uschar * s = sx->from_addr;
3138 uschar * errstr = NULL;
3140 /* If we must downconvert, do the from-address here. Remember we had to
3141 for the to-addresses (done below), and also (ugly) for re-doing when building
3142 the delivery log line. */
3144 if ( sx->addrlist->prop.utf8_msg
3145 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3148 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3150 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3154 setflag(sx->addrlist, af_utf8_downcvt);
3158 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3159 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3162 mail_command = string_copy(big_buffer); /* Save for later error message */
3166 case -1: /* Transmission error */
3169 case +1: /* Cmd was sent */
3170 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3171 (SOB sx->conn_args.ob)->command_timeout))
3173 if (errno == 0 && sx->buffer[0] == '4')
3175 errno = ERRNO_MAIL4XX;
3176 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3180 sx->pending_MAIL = FALSE;
3183 /* otherwise zero: command queued for pipeline */
3186 /* Pass over all the relevant recipient addresses for this host, which are the
3187 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3188 several before we have to read the responses for those seen so far. This
3189 checking is done by a subroutine because it also needs to be done at the end.
3190 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3191 the next one if not all are sent.
3193 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3194 last address because we want to abort if any recipients have any kind of
3195 problem, temporary or permanent. We know that all recipient addresses will have
3196 the PENDING_DEFER status, because only one attempt is ever made, and we know
3197 that max_rcpt will be large, so all addresses will be done at once.
3199 For verify we flush the pipeline after any (the only) rcpt address. */
3201 for (addr = sx->first_addr, address_count = 0;
3202 addr && address_count < sx->max_rcpt;
3203 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3209 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3210 ? dsn_support_yes : dsn_support_no;
3213 no_flush = pipelining_active && !sx->verify
3214 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3216 build_rcptcmd_options(sx, addr);
3218 /* Now send the RCPT command, and process outstanding responses when
3219 necessary. After a timeout on RCPT, we just end the function, leaving the
3220 yield as OK, because this error can often mean that there is a problem with
3221 just one address, so we don't want to delay the host. */
3223 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3226 if ( testflag(sx->addrlist, af_utf8_downcvt)
3227 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3230 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3231 errno = ERRNO_EXPANDFAIL;
3232 return -5; /*XXX too harsh? */
3236 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3237 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3239 if (count < 0) return -5;
3242 switch(sync_responses(sx, count, 0))
3244 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3245 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3248 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3249 if (!sx->lmtp) /* can't tell about progress yet */
3250 sx->completed_addr = TRUE;
3251 case 0: /* No 2xx or 5xx, but no probs */
3254 case -1: return -3; /* Timeout on RCPT */
3255 case -2: return -2; /* non-MAIL read i/o error */
3256 default: return -1; /* any MAIL error */
3258 #ifdef EXPERIMENTAL_PIPE_CONNECT
3259 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3262 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
3264 } /* Loop for next address */
3266 sx->next_addr = addr;
3272 /*****************************************************
3273 * Proxy TLS connection for another transport process *
3274 ******************************************************/
3276 Close the unused end of the pipe, fork once more, then use the given buffer
3277 as a staging area, and select on both the given fd and the TLS'd client-fd for
3278 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3279 Do blocking full-size writes, and reads under a timeout. Once both input
3280 channels are closed, exit the process.
3284 buf space to use for buffering
3285 bufsiz size of buffer
3286 pfd pipe filedescriptor array; [0] is comms to proxied process
3287 timeout per-read timeout, seconds
3291 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3295 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3301 DEBUG(D_transport) debug_printf("proxy-proc final-pid %d\n", rc);
3302 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3305 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
3306 set_process_info("proxying TLS connection for continued transport");
3308 FD_SET(tls_out.active.sock, &rfds);
3309 FD_SET(pfd[0], &rfds);
3311 for (int fd_bits = 3; fd_bits; )
3313 time_t time_left = timeout;
3314 time_t time_start = time(NULL);
3320 struct timeval tv = { time_left, 0 };
3323 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
3325 if (rc < 0 && errno == EINTR)
3326 if ((time_left -= time(NULL) - time_start) > 0) continue;
3330 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
3334 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
3336 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
3337 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
3341 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
3343 /* handle inbound data */
3344 if (FD_ISSET(tls_out.active.sock, &rfds))
3345 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
3348 FD_CLR(tls_out.active.sock, &rfds);
3349 shutdown(pfd[0], SHUT_WR);
3354 for (int nbytes = 0; rc - nbytes > 0; nbytes += i)
3355 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
3357 else if (fd_bits & 1)
3358 FD_SET(tls_out.active.sock, &rfds);
3360 /* handle outbound data */
3361 if (FD_ISSET(pfd[0], &rfds))
3362 if ((rc = read(pfd[0], buf, bsize)) <= 0)
3365 tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
3370 for (int nbytes = 0; rc - nbytes > 0; nbytes += i)
3371 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
3374 else if (fd_bits & 2)
3375 FD_SET(pfd[0], &rfds);
3379 if (f.running_in_test_harness) millisleep(100); /* let logging complete */
3380 exim_exit(0, US"TLS proxy");
3385 /*************************************************
3386 * Deliver address list to given host *
3387 *************************************************/
3389 /* If continue_hostname is not null, we get here only when continuing to
3390 deliver down an existing channel. The channel was passed as the standard
3391 input. TLS is never active on a passed channel; the previous process always
3392 closes it down before passing the connection on.
3394 Otherwise, we have to make a connection to the remote host, and do the
3395 initial protocol exchange.
3397 When running as an MUA wrapper, if the sender or any recipient is rejected,
3398 temporarily or permanently, we force failure for all recipients.
3401 addrlist chain of potential addresses to deliver; only those whose
3402 transport_return field is set to PENDING_DEFER are currently
3403 being processed; others should be skipped - they have either
3404 been delivered to an earlier host or IP address, or been
3405 failed by one of them.
3406 host host to deliver to
3407 host_af AF_INET or AF_INET6
3408 defport default TCP/IP port to use if host does not specify, in host
3410 interface interface to bind to, or NULL
3411 tblock transport instance block
3412 message_defer set TRUE if yield is OK, but all addresses were deferred
3413 because of a non-recipient, non-host failure, that is, a
3414 4xx response to MAIL FROM, DATA, or ".". This is a defer
3415 that is specific to the message.
3416 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
3417 a second attempt after TLS initialization fails
3419 Returns: OK - the connection was made and the delivery attempted;
3420 the result for each address is in its data block.
3421 DEFER - the connection could not be made, or something failed
3422 while setting up the SMTP session, or there was a
3423 non-message-specific error, such as a timeout.
3424 ERROR - a filter command is specified for this transport,
3425 and there was a problem setting it up; OR helo_data
3426 or add_headers or authenticated_sender is specified
3427 for this transport, and the string failed to expand
3431 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
3432 uschar *interface, transport_instance *tblock,
3433 BOOL *message_defer, BOOL suppress_tls)
3435 smtp_transport_options_block * ob = SOB tblock->options_block;
3439 struct timeval start_delivery_time;
3441 BOOL pass_message = FALSE;
3442 uschar *message = NULL;
3443 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
3447 gettimeofday(&start_delivery_time, NULL);
3448 suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
3449 *message_defer = FALSE;
3451 sx.addrlist = addrlist;
3452 sx.conn_args.host = host;
3453 sx.conn_args.host_af = host_af,
3455 sx.conn_args.interface = interface;
3456 sx.helo_data = NULL;
3457 sx.conn_args.tblock = tblock;
3459 sx.sync_addr = sx.first_addr = addrlist;
3461 /* Get the channel set up ready for a message (MAIL FROM being the next
3462 SMTP command to send */
3464 if ((rc = smtp_setup_conn(&sx, suppress_tls)) != OK)
3467 /* If there is a filter command specified for this transport, we can now
3468 set it up. This cannot be done until the identify of the host is known. */
3470 if (tblock->filter_command)
3472 transport_filter_timeout = tblock->filter_timeout;
3474 /* On failure, copy the error to all addresses, abandon the SMTP call, and
3477 if (!transport_set_up_command(&transport_filter_argv,
3478 tblock->filter_command, TRUE, DEFER, addrlist,
3479 string_sprintf("%.50s transport", tblock->name), NULL))
3481 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
3487 if ( transport_filter_argv
3488 && *transport_filter_argv
3489 && **transport_filter_argv
3490 && sx.peer_offered & OPTION_CHUNKING
3493 sx.peer_offered &= ~OPTION_CHUNKING;
3494 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
3498 /* For messages that have more than the maximum number of envelope recipients,
3499 we want to send several transactions down the same SMTP connection. (See
3500 comments in deliver.c as to how this reconciles, heuristically, with
3501 remote_max_parallel.) This optimization was added to Exim after the following
3502 code was already working. The simplest way to put it in without disturbing the
3503 code was to use a goto to jump back to this point when there is another
3504 transaction to handle. */
3507 sx.from_addr = return_path;
3508 sx.sync_addr = sx.first_addr;
3510 sx.send_rset = TRUE;
3511 sx.completed_addr = FALSE;
3514 /* If we are a continued-connection-after-verify the MAIL and RCPT
3515 commands were already sent; do not re-send but do mark the addrs as
3516 having been accepted up to RCPT stage. A traditional cont-conn
3517 always has a sequence number greater than one. */
3519 if (continue_hostname && continue_sequence == 1)
3521 sx.peer_offered = smtp_peer_options;
3522 sx.pending_MAIL = FALSE;
3524 sx.next_addr = NULL;
3526 for (address_item * addr = addrlist; addr; addr = addr->next)
3527 addr->transport_return = PENDING_OK;
3531 /* Initiate a message transfer. */
3533 switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
3536 case -1: case -2: goto RESPONSE_FAILED;
3537 case -3: goto END_OFF;
3538 case -4: goto SEND_QUIT;
3539 default: goto SEND_FAILED;
3542 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3543 permanently or temporarily. We should have flushed and synced after the last
3551 for (a = sx.first_addr, cnt = 0; a && cnt < sx.max_rcpt; a = a->next, cnt++)
3552 if (a->transport_return != PENDING_OK)
3554 /*XXX could we find a better errno than 0 here? */
3555 set_errno_nohost(addrlist, 0, a->message, FAIL,
3556 testflag(a, af_pass_message));
3563 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3564 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3565 have a good recipient buffered up if we are pipelining. We don't want to waste
3566 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3567 are pipelining. The responses are all handled by sync_responses().
3568 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3571 if ( !(sx.peer_offered & OPTION_CHUNKING)
3572 && (sx.ok || (pipelining_active && !mua_wrapper)))
3574 int count = smtp_write_command(&sx, SCMD_FLUSH, "DATA\r\n");
3576 if (count < 0) goto SEND_FAILED;
3577 switch(sync_responses(&sx, count, sx.ok ? +1 : -1))
3579 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3580 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3583 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3584 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3585 case 0: break; /* No 2xx or 5xx, but no probs */
3587 case -1: goto END_OFF; /* Timeout on RCPT */
3589 #ifdef EXPERIMENTAL_PIPE_CONNECT
3590 case -4: HDEBUG(D_transport)
3591 debug_printf("failed reaping pipelined cmd responses\n");
3593 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3595 pipelining_active = FALSE;
3596 data_command = string_copy(big_buffer); /* Save for later error message */
3599 /* If there were no good recipients (but otherwise there have been no
3600 problems), just set ok TRUE, since we have handled address-specific errors
3601 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3602 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3603 well as body. Set the appropriate timeout value to be used for each chunk.
3604 (Haven't been able to make it work using select() for writing yet.) */
3606 if (!(sx.peer_offered & OPTION_CHUNKING) && !sx.ok)
3608 /* Save the first address of the next batch. */
3609 sx.first_addr = sx.next_addr;
3615 transport_ctx tctx = {
3616 .u = {.fd = sx.cctx.sock}, /*XXX will this need TLS info? */
3619 .check_string = US".",
3620 .escape_string = US"..", /* Escaping strings */
3622 topt_use_crlf | topt_escape_headers
3623 | (tblock->body_only ? topt_no_headers : 0)
3624 | (tblock->headers_only ? topt_no_body : 0)
3625 | (tblock->return_path_add ? topt_add_return_path : 0)
3626 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3627 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3630 /* If using CHUNKING we need a callback from the generic transport
3631 support to us, for the sending of BDAT smtp commands and the reaping
3632 of responses. The callback needs a whole bunch of state so set up
3633 a transport-context structure to be passed around. */
3635 if (sx.peer_offered & OPTION_CHUNKING)
3637 tctx.check_string = tctx.escape_string = NULL;
3638 tctx.options |= topt_use_bdat;
3639 tctx.chunk_cb = smtp_chunk_cmd_callback;
3640 sx.pending_BDAT = FALSE;
3641 sx.good_RCPT = sx.ok;
3643 tctx.smtp_context = &sx;
3646 tctx.options |= topt_end_dot;
3648 /* Save the first address of the next batch. */
3649 sx.first_addr = sx.next_addr;
3651 /* Responses from CHUNKING commands go in buffer. Otherwise,
3652 there has not been a response. */
3656 sigalrm_seen = FALSE;
3657 transport_write_timeout = ob->data_timeout;
3658 smtp_command = US"sending data block"; /* For error messages */
3659 DEBUG(D_transport|D_v)
3660 if (sx.peer_offered & OPTION_CHUNKING)
3661 debug_printf(" will write message using CHUNKING\n");
3663 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3664 transport_count = 0;
3666 #ifndef DISABLE_DKIM
3667 dkim_exim_sign_init();
3668 # ifdef EXPERIMENTAL_ARC
3670 uschar * s = ob->arc_sign;
3673 if (!(ob->dkim.arc_signspec = s = expand_string(s)))
3675 if (!f.expand_string_forcedfail)
3677 message = US"failed to expand arc_sign";
3684 /* Ask dkim code to hash the body for ARC */
3685 (void) arc_ams_setup_sign_bodyhash();
3686 ob->dkim.force_bodyhash = TRUE;
3691 sx.ok = dkim_transport_write_message(&tctx, &ob->dkim, CUSS &message);
3693 sx.ok = transport_write_message(&tctx, 0);
3696 /* transport_write_message() uses write() because it is called from other
3697 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3698 it can exit with "Broken pipe" as its error. This really means that the
3699 socket got closed at the far end. */
3701 transport_write_timeout = 0; /* for subsequent transports */
3703 /* Failure can either be some kind of I/O disaster (including timeout),
3704 or the failure of a transport filter or the expansion of added headers.
3705 Or, when CHUNKING, it can be a protocol-detected failure. */
3708 if (message) goto SEND_FAILED;
3709 else goto RESPONSE_FAILED;
3711 /* We used to send the terminating "." explicitly here, but because of
3712 buffering effects at both ends of TCP/IP connections, you don't gain
3713 anything by keeping it separate, so it might as well go in the final
3714 data buffer for efficiency. This is now done by setting the topt_end_dot
3717 smtp_command = US"end of data";
3719 if (sx.peer_offered & OPTION_CHUNKING && sx.cmd_count > 1)
3721 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3722 switch(sync_responses(&sx, sx.cmd_count-1, 0))
3724 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3725 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3728 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3729 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3730 case 0: break; /* No 2xx or 5xx, but no probs */
3732 case -1: goto END_OFF; /* Timeout on RCPT */
3734 #ifdef EXPERIMENTAL_PIPE_CONNECT
3735 case -4: HDEBUG(D_transport)
3736 debug_printf("failed reaping pipelined cmd responses\n");
3738 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3742 #ifndef DISABLE_PRDR
3743 /* For PRDR we optionally get a partial-responses warning followed by the
3744 individual responses, before going on with the overall response. If we don't
3745 get the warning then deal with per non-PRDR. */
3749 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '3', ob->final_timeout);
3750 if (!sx.ok && errno == 0) switch(sx.buffer[0])
3752 case '2': sx.prdr_active = FALSE;
3755 case '4': errno = ERRNO_DATA4XX;
3756 addrlist->more_errno |=
3757 ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3764 /* For non-PRDR SMTP, we now read a single response that applies to the
3765 whole message. If it is OK, then all the addresses have been delivered. */
3769 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3771 if (!sx.ok && errno == 0 && sx.buffer[0] == '4')
3773 errno = ERRNO_DATA4XX;
3774 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3778 /* For LMTP, we get back a response for every RCPT command that we sent;
3779 some may be accepted and some rejected. For those that get a response, their
3780 status is fixed; any that are accepted have been handed over, even if later
3781 responses crash - at least, that's how I read RFC 2033.
3783 If all went well, mark the recipient addresses as completed, record which
3784 host/IPaddress they were delivered to, and cut out RSET when sending another
3785 message down the same channel. Write the completed addresses to the journal
3786 now so that they are recorded in case there is a crash of hardware or
3787 software before the spool gets updated. Also record the final SMTP
3788 confirmation if needed (for SMTP only). */
3793 struct timeval delivery_time;
3795 uschar * conf = NULL;
3797 timesince(&delivery_time, &start_delivery_time);
3798 sx.send_rset = FALSE;
3799 pipelining_active = FALSE;
3801 /* Set up confirmation if needed - applies only to SMTP */
3804 #ifdef DISABLE_EVENT
3805 LOGGING(smtp_confirmation) &&
3810 const uschar *s = string_printing(sx.buffer);
3811 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3812 conf = (s == sx.buffer)? US string_copy(s) : US s;
3815 /* Process all transported addresses - for LMTP or PRDR, read a status for
3818 for (address_item * addr = addrlist; addr != sx.first_addr; addr = addr->next)
3820 if (addr->transport_return != PENDING_OK) continue;
3822 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3823 remaining addresses. Otherwise, it's a return code for just the one
3824 address. For temporary errors, add a retry item for the address so that
3825 it doesn't get tried again too soon. */
3827 #ifndef DISABLE_PRDR
3828 if (sx.lmtp || sx.prdr_active)
3833 if (!smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3836 if (errno != 0 || sx.buffer[0] == 0) goto RESPONSE_FAILED;
3837 addr->message = string_sprintf(
3838 #ifndef DISABLE_PRDR
3839 "%s error after %s: %s", sx.prdr_active ? "PRDR":"LMTP",
3841 "LMTP error after %s: %s",
3843 data_command, string_printing(sx.buffer));
3844 setflag(addr, af_pass_message); /* Allow message to go to user */
3845 if (sx.buffer[0] == '5')
3846 addr->transport_return = FAIL;
3849 errno = ERRNO_DATA4XX;
3850 addr->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3851 addr->transport_return = DEFER;
3852 #ifndef DISABLE_PRDR
3853 if (!sx.prdr_active)
3855 retry_add_item(addr, addr->address_retry_key, 0);
3859 sx.completed_addr = TRUE; /* NOW we can set this flag */
3860 if (LOGGING(smtp_confirmation))
3862 const uschar *s = string_printing(sx.buffer);
3863 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3864 conf = (s == sx.buffer) ? US string_copy(s) : US s;
3868 /* SMTP, or success return from LMTP for this address. Pass back the
3869 actual host that was used. */
3871 addr->transport_return = OK;
3872 addr->more_errno = delivery_time.tv_sec;
3873 addr->delivery_usec = delivery_time.tv_usec;
3874 addr->host_used = host;
3875 addr->special_action = flag;
3876 addr->message = conf;
3878 if (tcp_out_fastopen)
3880 setflag(addr, af_tcp_fastopen_conn);
3881 if (tcp_out_fastopen >= TFO_USED_NODATA) setflag(addr, af_tcp_fastopen);
3882 if (tcp_out_fastopen >= TFO_USED_DATA) setflag(addr, af_tcp_fastopen_data);
3884 if (sx.pipelining_used) setflag(addr, af_pipelining);
3885 #ifdef EXPERIMENTAL_PIPE_CONNECT
3886 if (sx.early_pipe_active) setflag(addr, af_early_pipe);
3888 #ifndef DISABLE_PRDR
3889 if (sx.prdr_active) setflag(addr, af_prdr_used);
3891 if (sx.peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3894 #ifndef DISABLE_PRDR
3895 if (!sx.prdr_active)
3898 /* Update the journal. For homonymic addresses, use the base address plus
3899 the transport name. See lots of comments in deliver.c about the reasons
3900 for the complications when homonyms are involved. Just carry on after
3901 write error, as it may prove possible to update the spool file later. */
3903 if (testflag(addr, af_homonym))
3904 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3906 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3908 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx.buffer);
3909 len = Ustrlen(CS sx.buffer);
3910 if (write(journal_fd, sx.buffer, len) != len)
3911 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3912 "%s: %s", sx.buffer, strerror(errno));
3916 #ifndef DISABLE_PRDR
3919 const uschar * overall_message;
3921 /* PRDR - get the final, overall response. For any non-success
3922 upgrade all the address statuses. */
3924 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3928 if(errno == 0 && sx.buffer[0] == '4')
3930 errno = ERRNO_DATA4XX;
3931 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3933 for (address_item * addr = addrlist; addr != sx.first_addr; addr = addr->next)
3934 if (sx.buffer[0] == '5' || addr->transport_return == OK)
3935 addr->transport_return = PENDING_OK; /* allow set_errno action */
3936 goto RESPONSE_FAILED;
3939 /* Append the overall response to the individual PRDR response for logging
3940 and update the journal, or setup retry. */
3942 overall_message = string_printing(sx.buffer);
3943 for (address_item * addr = addrlist; addr != sx.first_addr; addr = addr->next)
3944 if (addr->transport_return == OK)
3945 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
3947 for (address_item * addr = addrlist; addr != sx.first_addr; addr = addr->next)
3948 if (addr->transport_return == OK)
3950 if (testflag(addr, af_homonym))
3951 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3953 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3955 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx.buffer);
3956 len = Ustrlen(CS sx.buffer);
3957 if (write(journal_fd, sx.buffer, len) != len)
3958 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3959 "%s: %s", sx.buffer, strerror(errno));
3961 else if (addr->transport_return == DEFER)
3962 retry_add_item(addr, addr->address_retry_key, -2);
3966 /* Ensure the journal file is pushed out to disk. */
3968 if (EXIMfsync(journal_fd) < 0)
3969 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
3975 /* Handle general (not specific to one address) failures here. The value of ok
3976 is used to skip over this code on the falling through case. A timeout causes a
3977 deferral. Other errors may defer or fail according to the response code, and
3978 may set up a special errno value, e.g. after connection chopped, which is
3979 assumed if errno == 0 and there is no text in the buffer. If control reaches
3980 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
3981 the problem is not related to this specific message. */
3986 uschar * set_message;
3992 sx.send_quit = check_response(host, &save_errno, addrlist->more_errno,
3993 sx.buffer, &code, &message, &pass_message);
4001 message = string_sprintf("send() to %s [%s] failed: %s",
4002 host->name, host->address, message ? message : US strerror(save_errno));
4003 sx.send_quit = FALSE;
4011 sx.ok = FALSE; /* For when reached by GOTO */
4012 set_message = message;
4014 /* We want to handle timeouts after MAIL or "." and loss of connection after
4015 "." specially. They can indicate a problem with the sender address or with
4016 the contents of the message rather than a real error on the connection. These
4017 cases are treated in the same way as a 4xx response. This next bit of code
4018 does the classification. */
4025 message_error = TRUE;
4029 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
4030 Ustrncmp(smtp_command,"end ",4) == 0;
4033 case ERRNO_SMTPCLOSED:
4034 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
4038 message_error = FALSE;
4042 /* Handle the cases that are treated as message errors. These are:
4044 (a) negative response or timeout after MAIL
4045 (b) negative response after DATA
4046 (c) negative response or timeout or dropped connection after "."
4047 (d) utf8 support required and not offered
4049 It won't be a negative response or timeout after RCPT, as that is dealt
4050 with separately above. The action in all cases is to set an appropriate
4051 error code for all the addresses, but to leave yield set to OK because the
4052 host itself has not failed. Of course, it might in practice have failed
4053 when we've had a timeout, but if so, we'll discover that at the next
4054 delivery attempt. For a temporary error, set the message_defer flag, and
4055 write to the logs for information if this is not the last host. The error
4056 for the last host will be logged as part of the address's log line. */
4060 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
4062 /* If there's an errno, the message contains just the identity of
4067 else /* Anything other than 5 is treated as temporary */
4071 message = US string_sprintf("%s: %s", message, strerror(save_errno));
4073 write_logs(host, message, sx.first_addr ? sx.first_addr->basic_errno : 0);
4075 *message_defer = TRUE;
4079 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4080 ".", or some other transportation error. We defer all addresses and yield
4081 DEFER, except for the case of failed add_headers expansion, or a transport
4082 filter failure, when the yield should be ERROR, to stop it trying other
4087 #ifdef EXPERIMENTAL_PIPE_CONNECT
4088 /* If we were early-pipelinng and the actual EHLO response did not match
4089 the cached value we assumed, we could have detected it and passed a
4090 custom errno through to here. It would be nice to RSET and retry right
4091 away, but to reliably do that we eould need an extra synch point before
4092 we committed to data and that would discard half the gained roundrips.
4093 Or we could summarily drop the TCP connection. but that is also ugly.
4094 Instead, we ignore the possibility (having freshened the cache) and rely
4095 on the server telling us with a nonmessage error if we have tried to
4096 do something it no longer supports. */
4099 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
4100 save_errno == ERRNO_FILTER_FAIL) ? ERROR : DEFER;
4104 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
4105 #ifdef EXPERIMENTAL_DSN_INFO
4106 , sx.smtp_greeting, sx.helo_response
4112 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4113 SMTP session tidily. However, if there were too many addresses to send in one
4114 message (indicated by first_addr being non-NULL) we want to carry on with the
4115 rest of them. Also, it is desirable to send more than one message down the SMTP
4116 connection if there are several waiting, provided we haven't already sent so
4117 many as to hit the configured limit. The function transport_check_waiting looks
4118 for a waiting message and returns its id. Then transport_pass_socket tries to
4119 set up a continued delivery by passing the socket on to another process. The
4120 variable send_rset is FALSE if a message has just been successfully transferred.
4122 If we are already sending down a continued channel, there may be further
4123 addresses not yet delivered that are aimed at the same host, but which have not
4124 been passed in this run of the transport. In this case, continue_more will be
4125 true, and all we should do is send RSET if necessary, and return, leaving the
4128 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4129 do not want to continue with other messages down the same channel, because that
4130 can lead to looping between two or more messages, all with the same,
4131 temporarily failing address(es). [The retry information isn't updated yet, so
4132 new processes keep on trying.] We probably also don't want to try more of this
4133 message's addresses either.
4135 If we have started a TLS session, we have to end it before passing the
4136 connection to a new process. However, not all servers can handle this (Exim
4137 can), so we do not pass such a connection on if the host matches
4138 hosts_nopass_tls. */
4141 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4142 "yield=%d first_address is %sNULL\n", sx.ok, sx.send_quit,
4143 sx.send_rset, f.continue_more, yield, sx.first_addr ? "not " : "");
4145 if (sx.completed_addr && sx.ok && sx.send_quit)
4148 smtp_compare_t t_compare;
4150 t_compare.tblock = tblock;
4151 t_compare.current_sender_address = sender_address;
4153 if ( sx.first_addr != NULL
4157 ( tls_out.active.sock < 0 && !continue_proxy_cipher
4158 || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
4162 transport_check_waiting(tblock->name, host->name,
4163 tblock->connection_max_messages, new_message_id, &more,
4164 (oicf)smtp_are_same_identities, (void*)&t_compare)
4171 if (! (sx.ok = smtp_write_command(&sx, SCMD_FLUSH, "RSET\r\n") >= 0))
4173 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
4174 host->address, strerror(errno));
4175 sx.send_quit = FALSE;
4177 else if (! (sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4178 '2', ob->command_timeout)))
4181 sx.send_quit = check_response(host, &errno, 0, sx.buffer, &code, &msg,
4185 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
4186 host->name, host->address, msg);
4190 /* Either RSET was not needed, or it succeeded */
4197 int socket_fd = sx.cctx.sock;
4200 if (sx.first_addr != NULL) /* More addresses still to be sent */
4201 { /* in this run of the transport */
4202 continue_sequence++; /* Causes * in logging */
4206 /* Unless caller said it already has more messages listed for this host,
4207 pass the connection on to a new Exim process (below, the call to
4208 transport_pass_socket). If the caller has more ready, just return with
4209 the connection still open. */
4212 if (tls_out.active.sock >= 0)
4213 if ( f.continue_more
4214 || verify_check_given_host(CUSS &ob->hosts_noproxy_tls, host) == OK)
4216 /* Before passing the socket on, or returning to caller with it still
4217 open, we must shut down TLS. Not all MTAs allow for the continuation
4218 of the SMTP session when TLS is shut down. We test for this by sending
4219 a new EHLO. If we don't get a good response, we don't attempt to pass
4222 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4223 sx.cctx.tls_ctx = NULL;
4224 smtp_peer_options = smtp_peer_options_wrap;
4226 && smtp_write_command(&sx, SCMD_FLUSH, "EHLO %s\r\n", sx.helo_data)
4228 && smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4229 '2', ob->command_timeout);
4231 if (sx.ok && f.continue_more)
4232 return yield; /* More addresses for another run */
4236 /* Set up a pipe for proxying TLS for the new transport process */
4238 smtp_peer_options |= OPTION_TLS;
4239 if (sx.ok = (socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
4242 set_errno(sx.first_addr, errno, US"internal allocation problem",
4244 # ifdef EXPERIMENTAL_DSN_INFO
4245 , sx.smtp_greeting, sx.helo_response
4251 if (f.continue_more)
4252 return yield; /* More addresses for another run */
4254 /* If the socket is successfully passed, we mustn't send QUIT (or
4255 indeed anything!) from here. */
4257 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4258 propagate it from the initial
4260 if (sx.ok && transport_pass_socket(tblock->name, host->name,
4261 host->address, new_message_id, socket_fd))
4263 sx.send_quit = FALSE;
4265 /* We have passed the client socket to a fresh transport process.
4266 If TLS is still active, we need to proxy it for the transport we
4267 just passed the baton to. Fork a child to to do it, and return to
4268 get logging done asap. Which way to place the work makes assumptions
4269 about post-fork prioritisation which may not hold on all platforms. */
4271 if (tls_out.active.sock >= 0)
4274 if (pid == 0) /* child; fork again to disconnect totally */
4276 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
4277 /* does not return */
4278 smtp_proxy_tls(sx.cctx.tls_ctx, sx.buffer, sizeof(sx.buffer), pfd,
4279 ob->command_timeout);
4282 if (pid > 0) /* parent */
4284 DEBUG(D_transport) debug_printf("proxy-proc inter-pid %d\n", pid);
4286 /* tidy the inter-proc to disconn the proxy proc */
4287 waitpid(pid, NULL, 0);
4288 tls_close(sx.cctx.tls_ctx, TLS_NO_SHUTDOWN);
4289 sx.cctx.tls_ctx = NULL;
4290 (void)close(sx.cctx.sock);
4292 continue_transport = NULL;
4293 continue_hostname = NULL;
4296 log_write(0, LOG_PANIC_DIE, "fork failed");
4302 /* If RSET failed and there are addresses left, they get deferred. */
4304 set_errno(sx.first_addr, errno, msg, DEFER, FALSE, host
4305 #ifdef EXPERIMENTAL_DSN_INFO
4306 , sx.smtp_greeting, sx.helo_response
4312 /* End off tidily with QUIT unless the connection has died or the socket has
4313 been passed to another process. There has been discussion on the net about what
4314 to do after sending QUIT. The wording of the RFC suggests that it is necessary
4315 to wait for a response, but on the other hand, there isn't anything one can do
4316 with an error response, other than log it. Exim used to do that. However,
4317 further discussion suggested that it is positively advantageous not to wait for
4318 the response, but to close the session immediately. This is supposed to move
4319 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
4320 load from the server. (Hosts that are both servers and clients may not see much
4321 difference, of course.) Further discussion indicated that this was safe to do
4322 on Unix systems which have decent implementations of TCP/IP that leave the
4323 connection around for a while (TIME_WAIT) after the application has gone away.
4324 This enables the response sent by the server to be properly ACKed rather than
4325 timed out, as can happen on broken TCP/IP implementations on other OS.
4327 This change is being made on 31-Jul-98. After over a year of trouble-free
4328 operation, the old commented-out code was removed on 17-Sep-99. */
4332 (void) setsockopt(sx.cctx.sock, IPPROTO_TCP, TCP_CORK, US &on, sizeof(on));
4334 if (sx.send_quit) (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4339 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4340 sx.cctx.tls_ctx = NULL;
4343 /* Close the socket, and return the appropriate value, first setting
4344 works because the NULL setting is passed back to the calling process, and
4345 remote_max_parallel is forced to 1 when delivering over an existing connection,
4347 If all went well and continue_more is set, we shouldn't actually get here if
4348 there are further addresses, as the return above will be taken. However,
4349 writing RSET might have failed, or there may be other addresses whose hosts are
4350 specified in the transports, and therefore not visible at top level, in which
4351 case continue_more won't get set. */
4353 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
4356 shutdown(sx.cctx.sock, SHUT_WR);
4357 millisleep(f.running_in_test_harness ? 200 : 20);
4358 if (fcntl(sx.cctx.sock, F_SETFL, O_NONBLOCK) == 0)
4359 for (int i = 16; read(sx.cctx.sock, sx.inbuffer, sizeof(sx.inbuffer)) > 0 && i > 0;)
4360 i--; /* drain socket */
4362 (void)close(sx.cctx.sock);
4364 #ifndef DISABLE_EVENT
4365 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
4368 continue_transport = NULL;
4369 continue_hostname = NULL;
4376 /*************************************************
4377 * Closedown entry point *
4378 *************************************************/
4380 /* This function is called when exim is passed an open smtp channel
4381 from another incarnation, but the message which it has been asked
4382 to deliver no longer exists. The channel is on stdin.
4384 We might do fancy things like looking for another message to send down
4385 the channel, but if the one we sought has gone, it has probably been
4386 delivered by some other process that itself will seek further messages,
4387 so just close down our connection.
4389 Argument: pointer to the transport instance block
4394 smtp_transport_closedown(transport_instance *tblock)
4396 smtp_transport_options_block * ob = SOB tblock->options_block;
4397 client_conn_ctx cctx;
4400 uschar inbuffer[4096];
4401 uschar outbuffer[16];
4403 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4404 cctx.sock = fileno(stdin);
4405 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
4407 sx.inblock.cctx = &cctx;
4408 sx.inblock.buffer = inbuffer;
4409 sx.inblock.buffersize = sizeof(inbuffer);
4410 sx.inblock.ptr = inbuffer;
4411 sx.inblock.ptrend = inbuffer;
4413 sx.outblock.cctx = &cctx;
4414 sx.outblock.buffersize = sizeof(outbuffer);
4415 sx.outblock.buffer = outbuffer;
4416 sx.outblock.ptr = outbuffer;
4417 sx.outblock.cmd_count = 0;
4418 sx.outblock.authenticating = FALSE;
4420 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4421 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
4422 (void)close(cctx.sock);
4427 /*************************************************
4428 * Prepare addresses for delivery *
4429 *************************************************/
4431 /* This function is called to flush out error settings from previous delivery
4432 attempts to other hosts. It also records whether we got here via an MX record
4433 or not in the more_errno field of the address. We are interested only in
4434 addresses that are still marked DEFER - others may have got delivered to a
4435 previously considered IP address. Set their status to PENDING_DEFER to indicate
4436 which ones are relevant this time.
4439 addrlist the list of addresses
4440 host the host we are delivering to
4442 Returns: the first address for this delivery
4445 static address_item *
4446 prepare_addresses(address_item *addrlist, host_item *host)
4448 address_item *first_addr = NULL;
4449 for (address_item * addr = addrlist; addr; addr = addr->next)
4450 if (addr->transport_return == DEFER)
4452 if (!first_addr) first_addr = addr;
4453 addr->transport_return = PENDING_DEFER;
4454 addr->basic_errno = 0;
4455 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
4456 addr->message = NULL;
4458 addr->cipher = NULL;
4459 addr->ourcert = NULL;
4460 addr->peercert = NULL;
4461 addr->peerdn = NULL;
4462 addr->ocsp = OCSP_NOT_REQ;
4464 #ifdef EXPERIMENTAL_DSN_INFO
4465 addr->smtp_greeting = NULL;
4466 addr->helo_response = NULL;
4474 /*************************************************
4475 * Main entry point *
4476 *************************************************/
4478 /* See local README for interface details. As this is a remote transport, it is
4479 given a chain of addresses to be delivered in one connection, if possible. It
4480 always returns TRUE, indicating that each address has its own independent
4481 status set, except if there is a setting up problem, in which case it returns
4485 smtp_transport_entry(
4486 transport_instance *tblock, /* data for this instantiation */
4487 address_item *addrlist) /* addresses we are working on */
4490 int hosts_defer = 0;
4492 int hosts_looked_up = 0;
4493 int hosts_retry = 0;
4494 int hosts_serial = 0;
4495 int hosts_total = 0;
4496 int total_hosts_tried = 0;
4497 BOOL expired = TRUE;
4498 uschar *expanded_hosts = NULL;
4500 uschar *tid = string_sprintf("%s transport", tblock->name);
4501 smtp_transport_options_block *ob = SOB tblock->options_block;
4502 host_item *hostlist = addrlist->host_list;
4503 host_item *host = NULL;
4507 debug_printf("%s transport entered\n", tblock->name);
4508 for (address_item * addr = addrlist; addr; addr = addr->next)
4509 debug_printf(" %s\n", addr->address);
4512 debug_printf("hostlist:\n");
4513 for (host_item * host = hostlist; host; host = host->next)
4514 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
4516 if (continue_hostname)
4517 debug_printf("already connected to %s [%s] (on fd %d)\n",
4518 continue_hostname, continue_host_address,
4519 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
4522 /* Set the flag requesting that these hosts be added to the waiting
4523 database if the delivery fails temporarily or if we are running with
4524 queue_smtp or a 2-stage queue run. This gets unset for certain
4525 kinds of error, typically those that are specific to the message. */
4527 update_waiting = TRUE;
4529 /* If a host list is not defined for the addresses - they must all have the
4530 same one in order to be passed to a single transport - or if the transport has
4531 a host list with hosts_override set, use the host list supplied with the
4532 transport. It is an error for this not to exist. */
4534 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
4535 if (tls_requiretls & REQUIRETLS_MSG)
4536 ob->tls_tempfail_tryclear = FALSE; /*XXX surely we should have a local for this
4537 rather than modifying the transport? */
4540 if (!hostlist || (ob->hosts_override && ob->hosts))
4544 addrlist->message = string_sprintf("%s transport called with no hosts set",
4546 addrlist->transport_return = PANIC;
4547 return FALSE; /* Only top address has status */
4550 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4553 /* If the transport's host list contains no '$' characters, and we are not
4554 randomizing, it is fixed and therefore a chain of hosts can be built once
4555 and for all, and remembered for subsequent use by other calls to this
4556 transport. If, on the other hand, the host list does contain '$', or we are
4557 randomizing its order, we have to rebuild it each time. In the fixed case,
4558 as the hosts string will never be used again, it doesn't matter that we
4559 replace all the : characters with zeros. */
4563 uschar *s = ob->hosts;
4565 if (Ustrchr(s, '$') != NULL)
4567 if (!(expanded_hosts = expand_string(s)))
4569 addrlist->message = string_sprintf("failed to expand list of hosts "
4570 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4571 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4572 return FALSE; /* Only top address has status */
4574 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4575 "\"%s\"\n", s, expanded_hosts);
4579 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4581 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4583 /* Check that the expansion yielded something useful. */
4587 string_sprintf("%s transport has empty hosts setting", tblock->name);
4588 addrlist->transport_return = PANIC;
4589 return FALSE; /* Only top address has status */
4592 /* If there was no expansion of hosts, save the host list for
4595 if (!expanded_hosts) ob->hostlist = hostlist;
4598 /* This is not the first time this transport has been run in this delivery;
4599 the host list was built previously. */
4602 hostlist = ob->hostlist;
4605 /* The host list was supplied with the address. If hosts_randomize is set, we
4606 must sort it into a random order if it did not come from MX records and has not
4607 already been randomized (but don't bother if continuing down an existing
4610 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4612 host_item *newlist = NULL;
4615 host_item *h = hostlist;
4616 hostlist = hostlist->next;
4618 h->sort_key = random_number(100);
4625 else if (h->sort_key < newlist->sort_key)
4632 host_item *hh = newlist;
4635 if (h->sort_key < hh->next->sort_key) break;
4643 hostlist = addrlist->host_list = newlist;
4646 /* Sort out the default port. */
4648 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4650 /* For each host-plus-IP-address on the list:
4652 . If this is a continued delivery and the host isn't the one with the
4653 current connection, skip.
4655 . If the status is unusable (i.e. previously failed or retry checked), skip.
4657 . If no IP address set, get the address, either by turning the name into
4658 an address, calling gethostbyname if gethostbyname is on, or by calling
4659 the DNS. The DNS may yield multiple addresses, in which case insert the
4660 extra ones into the list.
4662 . Get the retry data if not previously obtained for this address and set the
4663 field which remembers the state of this address. Skip if the retry time is
4664 not reached. If not, remember whether retry data was found. The retry string
4665 contains both the name and the IP address.
4667 . Scan the list of addresses and mark those whose status is DEFER as
4668 PENDING_DEFER. These are the only ones that will be processed in this cycle
4671 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4672 Some addresses may be successfully delivered, others may fail, and yet
4673 others may get temporary errors and so get marked DEFER.
4675 . The return from the delivery attempt is OK if a connection was made and a
4676 valid SMTP dialogue was completed. Otherwise it is DEFER.
4678 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4680 . If fail to connect, or other defer state, add a retry item.
4682 . If there are any addresses whose status is still DEFER, carry on to the
4683 next host/IPaddress, unless we have tried the number of hosts given
4684 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4685 there is some fancy logic for hosts_max_try that means its limit can be
4686 overstepped in some circumstances.
4688 If we get to the end of the list, all hosts have deferred at least one address,
4689 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4690 delivery attempt to those hosts whose last try was before the arrival time of
4691 the current message. To cope with this, we have to go round the loop a second
4692 time. After that, set the status and error data for any addresses that haven't
4693 had it set already. */
4695 for (int cutoff_retry = 0;
4696 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4699 host_item *nexthost = NULL;
4700 int unexpired_hosts_tried = 0;
4701 BOOL continue_host_tried = FALSE;
4703 retry_non_continued:
4704 for (host = hostlist;
4706 && unexpired_hosts_tried < ob->hosts_max_try
4707 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4712 BOOL host_is_expired = FALSE;
4713 BOOL message_defer = FALSE;
4714 BOOL some_deferred = FALSE;
4715 address_item *first_addr = NULL;
4716 uschar *interface = NULL;
4717 uschar *retry_host_key = NULL;
4718 uschar *retry_message_key = NULL;
4719 uschar *serialize_key = NULL;
4721 /* Default next host is next host. :-) But this can vary if the
4722 hosts_max_try limit is hit (see below). It may also be reset if a host
4723 address is looked up here (in case the host was multihomed). */
4725 nexthost = host->next;
4727 /* If the address hasn't yet been obtained from the host name, look it up
4728 now, unless the host is already marked as unusable. If it is marked as
4729 unusable, it means that the router was unable to find its IP address (in
4730 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4731 the lookup failed last time. We don't get this far if *all* MX records
4732 point to non-existent hosts; that is treated as a hard error.
4734 We can just skip this host entirely. When the hosts came from the router,
4735 the address will timeout based on the other host(s); when the address is
4736 looked up below, there is an explicit retry record added.
4738 Note that we mustn't skip unusable hosts if the address is not unset; they
4739 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4743 int new_port, flags;
4745 if (host->status >= hstatus_unusable)
4747 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4752 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4754 /* The host name is permitted to have an attached port. Find it, and
4755 strip it from the name. Just remember it for now. */
4757 new_port = host_item_get_port(host);
4759 /* Count hosts looked up */
4763 /* Find by name if so configured, or if it's an IP address. We don't
4764 just copy the IP address, because we need the test-for-local to happen. */
4766 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4767 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4768 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4770 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4771 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4773 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4774 &ob->dnssec, /* domains for request/require */
4777 /* Update the host (and any additional blocks, resulting from
4778 multihoming) with a host-specific port, if any. */
4780 for (host_item * hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4782 /* Failure to find the host at this time (usually DNS temporary failure)
4783 is really a kind of routing failure rather than a transport failure.
4784 Therefore we add a retry item of the routing kind, not to stop us trying
4785 to look this name up here again, but to ensure the address gets timed
4786 out if the failures go on long enough. A complete failure at this point
4787 commonly points to a configuration error, but the best action is still
4788 to carry on for the next host. */
4790 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4792 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4794 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4795 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4796 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4797 host->status = hstatus_unusable;
4799 for (address_item * addr = addrlist; addr; addr = addr->next)
4801 if (addr->transport_return != DEFER) continue;
4802 addr->basic_errno = ERRNO_UNKNOWNHOST;
4803 addr->message = string_sprintf(
4804 rc == HOST_FIND_SECURITY
4805 ? "lookup of IP address for %s was insecure"
4806 : "failed to lookup IP address for %s",
4812 /* If the host is actually the local host, we may have a problem, or
4813 there may be some cunning configuration going on. In the problem case,
4814 log things and give up. The default transport status is already DEFER. */
4816 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4818 for (address_item * addr = addrlist; addr; addr = addr->next)
4820 addr->basic_errno = 0;
4821 addr->message = string_sprintf("%s transport found host %s to be "
4822 "local", tblock->name, host->name);
4826 } /* End of block for IP address lookup */
4828 /* If this is a continued delivery, we are interested only in the host
4829 which matches the name of the existing open channel. The check is put
4830 here after the local host lookup, in case the name gets expanded as a
4831 result of the lookup. Set expired FALSE, to save the outer loop executing
4834 if (continue_hostname)
4835 if ( Ustrcmp(continue_hostname, host->name) != 0
4836 || Ustrcmp(continue_host_address, host->address) != 0
4840 continue; /* With next host */
4843 continue_host_tried = TRUE;
4845 /* Reset the default next host in case a multihomed host whose addresses
4846 are not looked up till just above added to the host list. */
4848 nexthost = host->next;
4850 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4851 domain is in queue_smtp_domains, we don't actually want to attempt any
4852 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4853 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4854 were not in it. We don't want to hold up all SMTP deliveries! Except when
4855 doing a two-stage queue run, don't do this if forcing. */
4857 if ((!f.deliver_force || f.queue_2stage) && (f.queue_smtp ||
4858 match_isinlist(addrlist->domain,
4859 (const uschar **)&queue_smtp_domains, 0,
4860 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
4863 for (address_item * addr = addrlist; addr; addr = addr->next)
4864 if (addr->transport_return == DEFER)
4865 addr->message = US"domain matches queue_smtp_domains, or -odqs set";
4866 continue; /* With next host */
4869 /* Count hosts being considered - purely for an intelligent comment
4870 if none are usable. */
4874 /* Set $host and $host address now in case they are needed for the
4875 interface expansion or the serialize_hosts check; they remain set if an
4876 actual delivery happens. */
4878 deliver_host = host->name;
4879 deliver_host_address = host->address;
4880 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
4881 : host->dnssec == DS_NO ? US"no"
4884 /* Set up a string for adding to the retry key if the port number is not
4885 the standard SMTP port. A host may have its own port setting that overrides
4888 pistring = string_sprintf(":%d", host->port == PORT_NONE
4889 ? defport : host->port);
4890 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
4892 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4893 string is set, even if constant (as different transports can have different
4894 constant settings), we must add it to the key that is used for retries,
4895 because connections to the same host from a different interface should be
4896 treated separately. */
4898 host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
4900 uschar * s = ob->interface;
4903 if (!smtp_get_interface(s, host_af, addrlist, &interface, tid))
4905 pistring = string_sprintf("%s/%s", pistring, interface);
4909 /* The first time round the outer loop, check the status of the host by
4910 inspecting the retry data. The second time round, we are interested only
4911 in expired hosts that haven't been tried since this message arrived. */
4913 if (cutoff_retry == 0)
4916 /* Ensure the status of the address is set by checking retry data if
4917 necessary. There may be host-specific retry data (applicable to all
4918 messages) and also data for retries of a specific message at this host.
4919 If either of these retry records are actually read, the keys used are
4920 returned to save recomputing them later. */
4922 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4923 US"retry_include_ip_address", ob->retry_include_ip_address,
4924 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4925 continue; /* with next host */
4927 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
4928 incl_ip, &retry_host_key, &retry_message_key);
4930 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
4931 host->address ? host->address : US"", pistring,
4932 host->status == hstatus_usable ? "usable"
4933 : host->status == hstatus_unusable ? "unusable"
4934 : host->status == hstatus_unusable_expired ? "unusable (expired)" : "?");
4936 /* Skip this address if not usable at this time, noting if it wasn't
4937 actually expired, both locally and in the address. */
4939 switch (host->status)
4941 case hstatus_unusable:
4943 setflag(addrlist, af_retry_skipped);
4946 case hstatus_unusable_expired:
4949 case hwhy_retry: hosts_retry++; break;
4950 case hwhy_failed: hosts_fail++; break;
4952 case hwhy_deferred: hosts_defer++; break;
4955 /* If there was a retry message key, implying that previously there
4956 was a message-specific defer, we don't want to update the list of
4957 messages waiting for these hosts. */
4959 if (retry_message_key) update_waiting = FALSE;
4960 continue; /* With the next host or IP address */
4964 /* Second time round the loop: if the address is set but expired, and
4965 the message is newer than the last try, let it through. */
4970 || host->status != hstatus_unusable_expired
4971 || host->last_try > received_time.tv_sec)
4973 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
4974 host->name, host->address, pistring);
4975 host_is_expired = TRUE;
4978 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
4979 it remains TRUE only if all hosts are expired and none are actually tried.
4984 /* If this host is listed as one to which access must be serialized,
4985 see if another Exim process has a connection to it, and if so, skip
4986 this host. If not, update the database to record our connection to it
4987 and remember this for later deletion. Do not do any of this if we are
4988 sending the message down a pre-existing connection. */
4990 if ( !continue_hostname
4991 && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
4993 serialize_key = string_sprintf("host-serialize-%s", host->name);
4994 if (!enq_start(serialize_key, 1))
4997 debug_printf("skipping host %s because another Exim process "
4998 "is connected to it\n", host->name);
5004 /* OK, we have an IP address that is not waiting for its retry time to
5005 arrive (it might be expired) OR (second time round the loop) we have an
5006 expired host that hasn't been tried since the message arrived. Have a go
5007 at delivering the message to it. First prepare the addresses by flushing
5008 out the result of previous attempts, and finding the first address that
5009 is still to be delivered. */
5011 first_addr = prepare_addresses(addrlist, host);
5013 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5014 message_id, host->name, host->address, addrlist->address,
5015 addrlist->next ? ", ..." : "");
5017 set_process_info("delivering %s to %s [%s]%s (%s%s)",
5018 message_id, host->name, host->address, pistring, addrlist->address,
5019 addrlist->next ? ", ..." : "");
5021 /* This is not for real; don't do the delivery. If there are
5022 any remaining hosts, list them. */
5026 set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
5027 for (address_item * addr = addrlist; addr; addr = addr->next)
5029 addr->host_used = host;
5030 addr->special_action = '*';
5031 addr->message = US"delivery bypassed by -N option";
5035 debug_printf("*** delivery by %s transport bypassed by -N option\n"
5036 "*** host and remaining hosts:\n", tblock->name);
5037 for (host_item * host2 = host; host2; host2 = host2->next)
5038 debug_printf(" %s [%s]\n", host2->name,
5039 host2->address ? host2->address : US"unset");
5044 /* This is for real. If the host is expired, we don't count it for
5045 hosts_max_retry. This ensures that all hosts must expire before an address
5046 is timed out, unless hosts_max_try_hardlimit (which protects against
5047 lunatic DNS configurations) is reached.
5049 If the host is not expired and we are about to hit the hosts_max_retry
5050 limit, check to see if there is a subsequent hosts with a different MX
5051 value. If so, make that the next host, and don't count this one. This is a
5052 heuristic to make sure that different MXs do get tried. With a normal kind
5053 of retry rule, they would get tried anyway when the earlier hosts were
5054 delayed, but if the domain has a "retry every time" type of rule - as is
5055 often used for the the very large ISPs, that won't happen. */
5060 /* Make a copy of the host if it is local to this invocation
5061 of the transport. */
5065 thost = store_get(sizeof(host_item));
5067 thost->name = string_copy(host->name);
5068 thost->address = string_copy(host->address);
5073 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
5076 debug_printf("hosts_max_try limit reached with this host\n");
5077 for (host_item * h = host; h; h = h->next) if (h->mx != host->mx)
5080 unexpired_hosts_tried--;
5081 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
5082 "and will be tried\n");
5087 /* Attempt the delivery. */
5089 total_hosts_tried++;
5090 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5091 &message_defer, FALSE);
5094 OK => connection made, each address contains its result;
5095 message_defer is set for message-specific defers (when all
5096 recipients are marked defer)
5097 DEFER => there was a non-message-specific delivery problem;
5098 ERROR => there was a problem setting up the arguments for a filter,
5099 or there was a problem with expanding added headers
5102 /* If the result is not OK, there was a non-message-specific problem.
5103 If the result is DEFER, we need to write to the logs saying what happened
5104 for this particular host, except in the case of authentication and TLS
5105 failures, where the log has already been written. If all hosts defer a
5106 general message is written at the end. */
5108 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
5109 && first_addr->basic_errno != ERRNO_TLSFAILURE)
5110 write_logs(host, first_addr->message, first_addr->basic_errno);
5112 #ifndef DISABLE_EVENT
5114 deferred_event_raise(first_addr, host);
5117 /* If STARTTLS was accepted, but there was a failure in setting up the
5118 TLS session (usually a certificate screwup), and the host is not in
5119 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5120 TLS forcibly turned off. We have to start from scratch with a new SMTP
5121 connection. That's why the retry is done from here, not from within
5122 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5123 session, so the in-clear transmission after those errors, if permitted,
5124 happens inside smtp_deliver().] */
5128 && first_addr->basic_errno == ERRNO_TLSFAILURE
5129 && ob->tls_tempfail_tryclear
5130 && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
5133 log_write(0, LOG_MAIN,
5134 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5135 first_addr->message, host->name, host->address);
5136 first_addr = prepare_addresses(addrlist, host);
5137 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5138 &message_defer, TRUE);
5139 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
5140 write_logs(host, first_addr->message, first_addr->basic_errno);
5141 # ifndef DISABLE_EVENT
5143 deferred_event_raise(first_addr, host);
5146 #endif /*SUPPORT_TLS*/
5149 /* Delivery attempt finished */
5151 set_process_info("delivering %s: just tried %s [%s]%s for %s%s: result %s",
5152 message_id, host->name, host->address, pistring, addrlist->address,
5153 addrlist->next ? " (& others)" : "", rc_to_string(rc));
5155 /* Release serialization if set up */
5157 if (serialize_key) enq_end(serialize_key);
5159 /* If the result is DEFER, or if a host retry record is known to exist, we
5160 need to add an item to the retry chain for updating the retry database
5161 at the end of delivery. We only need to add the item to the top address,
5162 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5163 for any other delivery attempts using the same address. (It is copied into
5164 the unusable tree at the outer level, so even if different address blocks
5165 contain the same address, it still won't get tried again.) */
5167 if (rc == DEFER || retry_host_key)
5169 int delete_flag = rc != DEFER ? rf_delete : 0;
5170 if (!retry_host_key)
5173 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5174 US"retry_include_ip_address", ob->retry_include_ip_address,
5175 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5176 incl_ip = TRUE; /* error; use most-specific retry record */
5178 retry_host_key = incl_ip
5179 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
5180 : string_sprintf("T:%S%s", host->name, pistring);
5183 /* If a delivery of another message over an existing SMTP connection
5184 yields DEFER, we do NOT set up retry data for the host. This covers the
5185 case when there are delays in routing the addresses in the second message
5186 that are so long that the server times out. This is alleviated by not
5187 routing addresses that previously had routing defers when handling an
5188 existing connection, but even so, this case may occur (e.g. if a
5189 previously happily routed address starts giving routing defers). If the
5190 host is genuinely down, another non-continued message delivery will
5191 notice it soon enough. */
5193 if (delete_flag != 0 || !continue_hostname)
5194 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
5196 /* We may have tried an expired host, if its retry time has come; ensure
5197 the status reflects the expiry for the benefit of any other addresses. */
5201 host->status = host_is_expired
5202 ? hstatus_unusable_expired : hstatus_unusable;
5203 host->why = hwhy_deferred;
5207 /* If message_defer is set (host was OK, but every recipient got deferred
5208 because of some message-specific problem), or if that had happened
5209 previously so that a message retry key exists, add an appropriate item
5210 to the retry chain. Note that if there was a message defer but now there is
5211 a host defer, the message defer record gets deleted. That seems perfectly
5212 reasonable. Also, stop the message from being remembered as waiting
5213 for specific hosts. */
5215 if (message_defer || retry_message_key)
5217 int delete_flag = message_defer ? 0 : rf_delete;
5218 if (!retry_message_key)
5221 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5222 US"retry_include_ip_address", ob->retry_include_ip_address,
5223 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5224 incl_ip = TRUE; /* error; use most-specific retry record */
5226 retry_message_key = incl_ip
5227 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
5229 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
5231 retry_add_item(addrlist, retry_message_key,
5232 rf_message | rf_host | delete_flag);
5233 update_waiting = FALSE;
5236 /* Any return other than DEFER (that is, OK or ERROR) means that the
5237 addresses have got their final statuses filled in for this host. In the OK
5238 case, see if any of them are deferred. */
5241 for (address_item * addr = addrlist; addr; addr = addr->next)
5242 if (addr->transport_return == DEFER)
5244 some_deferred = TRUE;
5248 /* If no addresses deferred or the result was ERROR, return. We do this for
5249 ERROR because a failing filter set-up or add_headers expansion is likely to
5250 fail for any host we try. */
5252 if (rc == ERROR || (rc == OK && !some_deferred))
5254 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5255 return TRUE; /* Each address has its status */
5258 /* If the result was DEFER or some individual addresses deferred, let
5259 the loop run to try other hosts with the deferred addresses, except for the
5260 case when we were trying to deliver down an existing channel and failed.
5261 Don't try any other hosts in this case. */
5263 if (continue_hostname) break;
5265 /* If the whole delivery, or some individual addresses, were deferred and
5266 there are more hosts that could be tried, do not count this host towards
5267 the hosts_max_try limit if the age of the message is greater than the
5268 maximum retry time for this host. This means we may try try all hosts,
5269 ignoring the limit, when messages have been around for some time. This is
5270 important because if we don't try all hosts, the address will never time
5271 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5273 if ((rc == DEFER || some_deferred) && nexthost)
5276 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
5278 if (retry && retry->rules)
5280 retry_rule *last_rule;
5281 for (last_rule = retry->rules;
5283 last_rule = last_rule->next);
5284 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
5286 else timedout = TRUE; /* No rule => timed out */
5290 unexpired_hosts_tried--;
5291 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
5292 "hosts_max_try (message older than host's retry time)\n");
5298 if (unexpired_hosts_tried >= ob->hosts_max_try)
5299 debug_printf("reached transport hosts_max_try limit %d\n",
5301 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5302 debug_printf("reached transport hosts_max_try_hardlimit limit %d\n",
5303 ob->hosts_max_try_hardlimit);
5306 if (f.running_in_test_harness) millisleep(500); /* let server debug out */
5307 } /* End of loop for trying multiple hosts. */
5309 /* If we failed to find a matching host in the list, for an already-open
5310 connection, just close it and start over with the list. This can happen
5311 for routing that changes from run to run, or big multi-IP sites with
5314 if (continue_hostname && !continue_host_tried)
5316 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
5318 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
5320 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5322 /*XXX doublecheck that! */
5324 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
5326 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
5327 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
5328 cutthrough.cctx.tls_ctx = NULL;
5329 cutthrough.is_tls = FALSE;
5333 (void) write(fd, US"QUIT\r\n", 6);
5336 cutthrough.cctx.sock = -1;
5337 continue_hostname = NULL;
5338 goto retry_non_continued;
5341 /* This is the end of the loop that repeats iff expired is TRUE and
5342 ob->delay_after_cutoff is FALSE. The second time round we will
5343 try those hosts that haven't been tried since the message arrived. */
5347 debug_printf("all IP addresses skipped or deferred at least one address\n");
5348 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
5349 debug_printf("retrying IP addresses not tried since message arrived\n");
5354 /* Get here if all IP addresses are skipped or defer at least one address. In
5355 MUA wrapper mode, this will happen only for connection or other non-message-
5356 specific failures. Force the delivery status for all addresses to FAIL. */
5360 for (address_item * addr = addrlist; addr; addr = addr->next)
5361 addr->transport_return = FAIL;
5365 /* In the normal, non-wrapper case, add a standard message to each deferred
5366 address if there hasn't been an error, that is, if it hasn't actually been
5367 tried this time. The variable "expired" will be FALSE if any deliveries were
5368 actually tried, or if there was at least one host that was not expired. That
5369 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5370 a delivery has been tried, an error code will be set, and the failing of the
5371 message is handled by the retry code later.
5373 If queue_smtp is set, or this transport was called to send a subsequent message
5374 down an existing TCP/IP connection, and something caused the host not to be
5375 found, we end up here, but can detect these cases and handle them specially. */
5377 for (address_item * addr = addrlist; addr; addr = addr->next)
5379 /* If host is not NULL, it means that we stopped processing the host list
5380 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5381 means we need to behave as if some hosts were skipped because their retry
5382 time had not come. Specifically, this prevents the address from timing out.
5383 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5384 hosts were tried. */
5387 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5390 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5391 "hosts were tried\n");
5396 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5397 setflag(addr, af_retry_skipped);
5400 if (f.queue_smtp) /* no deliveries attempted */
5402 addr->transport_return = DEFER;
5403 addr->basic_errno = 0;
5404 addr->message = US"SMTP delivery explicitly queued";
5407 else if ( addr->transport_return == DEFER
5408 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
5412 addr->basic_errno = ERRNO_HRETRY;
5413 if (continue_hostname)
5414 addr->message = US"no host found for existing SMTP connection";
5417 setflag(addr, af_pass_message); /* This is not a security risk */
5418 addr->message = string_sprintf(
5419 "all hosts%s have been failing for a long time %s",
5420 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
5421 ob->delay_after_cutoff
5422 ? US"(and retry time not reached)"
5423 : US"and were last tried after this message arrived");
5425 /* If we are already using fallback hosts, or there are no fallback hosts
5426 defined, convert the result to FAIL to cause a bounce. */
5428 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
5429 addr->transport_return = FAIL;
5434 if (hosts_retry == hosts_total)
5435 s = "retry time not reached for any host%s";
5436 else if (hosts_fail == hosts_total)
5437 s = "all host address lookups%s failed permanently";
5438 else if (hosts_defer == hosts_total)
5439 s = "all host address lookups%s failed temporarily";
5440 else if (hosts_serial == hosts_total)
5441 s = "connection limit reached for all hosts%s";
5442 else if (hosts_fail+hosts_defer == hosts_total)
5443 s = "all host address lookups%s failed";
5445 s = "some host address lookups failed and retry time "
5446 "not reached for other hosts or connection limit reached%s";
5448 addr->message = string_sprintf(s,
5449 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
5454 /* Update the database which keeps information about which messages are waiting
5455 for which hosts to become available. For some message-specific errors, the
5456 update_waiting flag is turned off because we don't want follow-on deliveries in
5457 those cases. If this transport instance is explicitly limited to one message
5458 per connection then follow-on deliveries are not possible and there's no need
5459 to create/update the per-transport wait-<transport_name> database. */
5461 if (update_waiting && tblock->connection_max_messages != 1)
5462 transport_update_waiting(hostlist, tblock->name);
5466 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5468 return TRUE; /* Each address has its status */
5471 #endif /*!MACRO_PREDEF*/
5474 /* End of transport/smtp.c */