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
502 if (errno_value == ERRNO_CONNECTTIMEOUT)
504 errno_value = ETIMEDOUT;
505 orvalue = RTEF_CTOUT;
507 for (addr = addrlist; addr; addr = addr->next)
508 if (addr->transport_return >= PENDING)
510 addr->basic_errno = errno_value;
511 addr->more_errno |= orvalue;
515 if (pass_message) setflag(addr, af_pass_message);
517 addr->transport_return = rc;
520 addr->host_used = host;
521 #ifdef EXPERIMENTAL_DSN_INFO
523 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
524 addr->smtp_greeting = smtp_greeting;
527 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
528 addr->helo_response = helo_response;
535 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
538 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
539 #ifdef EXPERIMENTAL_DSN_INFO
546 /*************************************************
547 * Check an SMTP response *
548 *************************************************/
550 /* This function is given an errno code and the SMTP response buffer
551 to analyse, together with the host identification for generating messages. It
552 sets an appropriate message and puts the first digit of the response code into
553 the yield variable. If no response was actually read, a suitable digit is
557 host the current host, to get its name for messages
558 errno_value pointer to the errno value
559 more_errno from the top address for use with ERRNO_FILTER_FAIL
560 buffer the SMTP response buffer
561 yield where to put a one-digit SMTP response code
562 message where to put an error message
563 pass_message set TRUE if message is an SMTP response
565 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
569 check_response(host_item *host, int *errno_value, int more_errno,
570 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
572 uschar * pl = pipelining_active ? US"pipelined " : US"";
575 *yield = '4'; /* Default setting is to give a temporary error */
579 case ETIMEDOUT: /* Handle response timeout */
580 *message = US string_sprintf("SMTP timeout after %s%s",
582 if (transport_count > 0)
583 *message = US string_sprintf("%s (%d bytes written)", *message,
587 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
588 s = string_printing(buffer);
589 while (isspace(*s)) s++;
591 ? string_sprintf("Malformed SMTP reply (an empty line) "
592 "in response to %s%s", pl, smtp_command)
593 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
594 pl, smtp_command, s);
597 case ERRNO_TLSFAILURE: /* Handle bad first read; can happen with
599 *message = US"bad first read from TLS conn";
602 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
603 can't send QUIT as we mustn't end the DATA. */
604 *message = string_sprintf("transport filter process failed (%d)%s",
606 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
609 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
610 can't send QUIT as we mustn't end the DATA. */
612 string_sprintf("failed to expand headers_add or headers_remove: %s",
613 expand_string_message);
616 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
617 *message = string_sprintf("failed to write a data block");
621 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
622 *message = US"utf8 support required but not offered for forwarding";
623 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
628 /* Handle error responses from the remote mailer. */
632 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
633 "%s", pl, smtp_command, s = string_printing(buffer));
634 *pass_message = TRUE;
639 /* No data was read. If there is no errno, this must be the EOF (i.e.
640 connection closed) case, which causes deferral. An explicit connection reset
641 error has the same effect. Otherwise, put the host's identity in the message,
642 leaving the errno value to be interpreted as well. In all cases, we have to
643 assume the connection is now dead. */
645 if (*errno_value == 0 || *errno_value == ECONNRESET)
647 *errno_value = ERRNO_SMTPCLOSED;
648 *message = US string_sprintf("Remote host closed connection "
649 "in response to %s%s", pl, smtp_command);
652 *message = US string_sprintf("%s [%s]", host->name, host->address);
659 /*************************************************
660 * Write error message to logs *
661 *************************************************/
663 /* This writes to the main log and to the message log.
666 host the current host
667 detail the current message (addr_item->message)
668 basic_errno the errno (addr_item->basic_errno)
674 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
676 gstring * message = LOGGING(outgoing_port)
677 ? string_fmt_append(NULL, "H=%s [%s]:%d", host->name, host->address,
678 host->port == PORT_NONE ? 25 : host->port)
679 : string_fmt_append(NULL, "H=%s [%s]", host->name, host->address);
683 message = string_fmt_append(message, ": %s", suffix);
685 message = string_fmt_append(message, ": %s", strerror(basic_errno));
688 message = string_fmt_append(message, " %s", exim_errstr(basic_errno));
690 log_write(0, LOG_MAIN, "%s", string_from_gstring(message));
691 deliver_msglog("%s %s\n", tod_stamp(tod_log), message->s);
695 msglog_line(host_item * host, uschar * message)
697 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
698 host->name, host->address, message);
703 #ifndef DISABLE_EVENT
704 /*************************************************
705 * Post-defer action *
706 *************************************************/
708 /* This expands an arbitrary per-transport string.
709 It might, for example, be used to write to the database log.
712 addr the address item containing error information
713 host the current host
719 deferred_event_raise(address_item *addr, host_item *host)
721 uschar * action = addr->transport->event_action;
722 const uschar * save_domain;
728 save_domain = deliver_domain;
729 save_local = deliver_localpart;
731 /*XXX would ip & port already be set up? */
732 deliver_host_address = string_copy(host->address);
733 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
734 event_defer_errno = addr->basic_errno;
736 router_name = addr->router->name;
737 transport_name = addr->transport->name;
738 deliver_domain = addr->domain;
739 deliver_localpart = addr->local_part;
741 (void) event_raise(action, US"msg:host:defer",
743 ? addr->basic_errno > 0
744 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
745 : string_copy(addr->message)
746 : addr->basic_errno > 0
747 ? string_copy(US strerror(addr->basic_errno))
750 deliver_localpart = save_local;
751 deliver_domain = save_domain;
752 router_name = transport_name = NULL;
756 /*************************************************
757 * Reap SMTP specific responses *
758 *************************************************/
760 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
763 uschar flushbuffer[4096];
767 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
768 '2', ob->command_timeout)
769 && (errno != 0 || flushbuffer[0] == 0))
776 /* Return boolean success */
779 smtp_reap_banner(smtp_context * sx)
781 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
782 '2', (SOB sx->conn_args.ob)->command_timeout);
783 #ifdef EXPERIMENTAL_DSN_INFO
784 sx->smtp_greeting = string_copy(sx->buffer);
786 return good_response;
790 smtp_reap_ehlo(smtp_context * sx)
792 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
793 (SOB sx->conn_args.ob)->command_timeout))
795 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
797 #ifdef EXPERIMENTAL_DSN_INFO
798 sx->helo_response = string_copy(sx->buffer);
804 #ifdef EXPERIMENTAL_DSN_INFO
805 sx->helo_response = string_copy(sx->buffer);
812 #ifdef EXPERIMENTAL_PIPE_CONNECT
814 ehlo_cache_key(const smtp_context * sx)
816 host_item * host = sx->conn_args.host;
817 return Ustrchr(host->address, ':')
818 ? string_sprintf("[%s]:%d.EHLO", host->address,
819 host->port == PORT_NONE ? sx->port : host->port)
820 : string_sprintf("%s:%d.EHLO", host->address,
821 host->port == PORT_NONE ? sx->port : host->port);
825 write_ehlo_cache_entry(const smtp_context * sx)
827 open_db dbblock, * dbm_file;
829 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
831 uschar * ehlo_resp_key = ehlo_cache_key(sx);
832 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
834 HDEBUG(D_transport) debug_printf("writing clr %04x/%04x cry %04x/%04x\n",
835 sx->ehlo_resp.cleartext_features, sx->ehlo_resp.cleartext_auths,
836 sx->ehlo_resp.crypted_features, sx->ehlo_resp.crypted_auths);
838 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
839 dbfn_close(dbm_file);
844 invalidate_ehlo_cache_entry(smtp_context * sx)
846 open_db dbblock, * dbm_file;
848 if ( sx->early_pipe_active
849 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
851 uschar * ehlo_resp_key = ehlo_cache_key(sx);
852 dbfn_delete(dbm_file, ehlo_resp_key);
853 dbfn_close(dbm_file);
858 read_ehlo_cache_entry(smtp_context * sx)
863 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE)))
864 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
867 uschar * ehlo_resp_key = ehlo_cache_key(sx);
868 dbdata_ehlo_resp * er;
870 if (!(er = dbfn_read(dbm_file, ehlo_resp_key)))
871 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
872 else if (time(NULL) - er->time_stamp > retry_data_expire)
874 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
875 dbfn_close(dbm_file);
876 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
877 dbfn_delete(dbm_file, ehlo_resp_key);
881 sx->ehlo_resp = er->data;
882 dbfn_close(dbm_file);
883 DEBUG(D_transport) debug_printf(
884 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
885 er->data.cleartext_features, er->data.crypted_features);
888 dbfn_close(dbm_file);
895 /* Return an auths bitmap for the set of AUTH methods offered by the server
896 which match our authenticators. */
898 static unsigned short
899 study_ehlo_auths(smtp_context * sx)
904 unsigned short authbits = 0;
906 if (!sx->esmtp) return 0;
907 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
908 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
909 expand_nmax = -1; /* reset */
910 names = string_copyn(expand_nstring[1], expand_nlength[1]);
912 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
914 const uschar * list = names;
918 while (string_nextinlist(&list, &sep, name, sizeof(name)))
919 if (strcmpic(au->public_name, name) == 0)
920 { authbits |= BIT(authnum); break; }
924 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
925 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
927 if (tls_out.active.sock >= 0)
928 sx->ehlo_resp.crypted_auths = authbits;
930 sx->ehlo_resp.cleartext_auths = authbits;
937 /* Wait for and check responses for early-pipelining.
939 Called from the lower-level smtp_read_response() function
940 used for general code that assume synchronisation, if context
941 flags indicate outstanding early-pipelining commands. Also
942 called fom sync_responses() which handles pipelined commands.
945 sx smtp connection context
946 countp number of outstanding responses, adjusted on return
950 DEFER error on first read of TLS'd conn
951 FAIL SMTP error in response
954 smtp_reap_early_pipe(smtp_context * sx, int * countp)
956 BOOL pending_BANNER = sx->pending_BANNER;
957 BOOL pending_EHLO = sx->pending_EHLO;
960 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
961 sx->pending_EHLO = FALSE;
965 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
967 if (!smtp_reap_banner(sx))
969 DEBUG(D_transport) debug_printf("bad banner\n");
970 if (tls_out.active.sock >= 0) rc = DEFER;
977 unsigned peer_offered;
978 unsigned short authbits = 0, * ap;
980 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
982 if (!smtp_reap_ehlo(sx))
984 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
985 if (tls_out.active.sock >= 0) rc = DEFER;
989 /* Compare the actual EHLO response to the cached value we assumed;
990 on difference, dump or rewrite the cache and arrange for a retry. */
992 ap = tls_out.active.sock < 0
993 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
995 peer_offered = ehlo_response(sx->buffer,
996 (tls_out.active.sock < 0 ? OPTION_TLS : OPTION_REQUIRETLS)
997 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
998 | OPTION_UTF8 | OPTION_EARLY_PIPE
1000 if ( peer_offered != sx->peer_offered
1001 || (authbits = study_ehlo_auths(sx)) != *ap)
1004 debug_printf("EHLO %s extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
1005 tls_out.active.sock < 0 ? "cleartext" : "crypted",
1006 sx->peer_offered, *ap, peer_offered, authbits);
1007 *(tls_out.active.sock < 0
1008 ? &sx->ehlo_resp.cleartext_features : &sx->ehlo_resp.crypted_features) = peer_offered;
1010 if (peer_offered & OPTION_EARLY_PIPE)
1011 write_ehlo_cache_entry(sx);
1013 invalidate_ehlo_cache_entry(sx);
1015 return OK; /* just carry on */
1021 invalidate_ehlo_cache_entry(sx);
1022 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
1028 /*************************************************
1029 * Synchronize SMTP responses *
1030 *************************************************/
1032 /* This function is called from smtp_deliver() to receive SMTP responses from
1033 the server, and match them up with the commands to which they relate. When
1034 PIPELINING is not in use, this function is called after every command, and is
1035 therefore somewhat over-engineered, but it is simpler to use a single scheme
1036 that works both with and without PIPELINING instead of having two separate sets
1039 The set of commands that are buffered up with pipelining may start with MAIL
1040 and may end with DATA; in between are RCPT commands that correspond to the
1041 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1042 etc.) are never buffered.
1044 Errors after MAIL or DATA abort the whole process leaving the response in the
1045 buffer. After MAIL, pending responses are flushed, and the original command is
1046 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1047 permitted to reject some recipient addresses while accepting others. However
1048 certain errors clearly abort the whole process. Set the value in
1049 transport_return to PENDING_OK if the address is accepted. If there is a
1050 subsequent general error, it will get reset accordingly. If not, it will get
1051 converted to OK at the end.
1054 sx smtp connection context
1055 count the number of responses to read
1056 pending_DATA 0 if last command sent was not DATA
1057 +1 if previously had a good recipient
1058 -1 if not previously had a good recipient
1060 Returns: 3 if at least one address had 2xx and one had 5xx
1061 2 if at least one address had 5xx but none had 2xx
1062 1 if at least one host had a 2xx response, but none had 5xx
1063 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1064 -1 timeout while reading RCPT response
1065 -2 I/O or other non-response error for RCPT
1066 -3 DATA or MAIL failed - errno and buffer set
1067 -4 banner or EHLO failed (early-pipelining)
1068 -5 banner or EHLO failed (early-pipelining, TLS)
1072 sync_responses(smtp_context * sx, int count, int pending_DATA)
1074 address_item * addr = sx->sync_addr;
1075 smtp_transport_options_block * ob = sx->conn_args.ob;
1079 #ifdef EXPERIMENTAL_PIPE_CONNECT
1080 if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
1081 return rc == FAIL ? -4 : -5;
1084 /* Handle the response for a MAIL command. On error, reinstate the original
1085 command in big_buffer for error message use, and flush any further pending
1086 responses before returning, except after I/O errors and timeouts. */
1088 if (sx->pending_MAIL)
1090 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1092 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1093 '2', ob->command_timeout))
1095 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1096 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1097 if (errno == ERRNO_TLSFAILURE)
1099 if (errno == 0 && sx->buffer[0] != 0)
1102 if (sx->buffer[0] == '4')
1104 save_errno = ERRNO_MAIL4XX;
1105 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1107 count = smtp_discard_responses(sx, ob, count);
1111 if (pending_DATA) count--; /* Number of RCPT responses to come */
1112 while (count-- > 0) /* Mark any pending addrs with the host used */
1114 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1115 addr->host_used = sx->conn_args.host;
1122 if (pending_DATA) count--; /* Number of RCPT responses to come */
1124 /* Read and handle the required number of RCPT responses, matching each one up
1125 with an address by scanning for the next address whose status is PENDING_DEFER.
1130 while (addr->transport_return != PENDING_DEFER)
1131 if (!(addr = addr->next))
1134 /* The address was accepted */
1135 addr->host_used = sx->conn_args.host;
1137 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1138 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1139 '2', ob->command_timeout))
1142 addr->transport_return = PENDING_OK;
1144 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1145 ensure that any address-specific retry record is expunged. We do this both
1146 for the basic key and for the version that also includes the sender. */
1148 if (testflag(addr, af_dr_retry_exists))
1150 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1152 retry_add_item(addr, altkey, rf_delete);
1153 retry_add_item(addr, addr->address_retry_key, rf_delete);
1157 /* Error on first TLS read */
1159 else if (errno == ERRNO_TLSFAILURE)
1162 /* Timeout while reading the response */
1164 else if (errno == ETIMEDOUT)
1166 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1167 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1168 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
1169 retry_add_item(addr, addr->address_retry_key, 0);
1170 update_waiting = FALSE;
1174 /* Handle other errors in obtaining an SMTP response by returning -1. This
1175 will cause all the addresses to be deferred. Restore the SMTP command in
1176 big_buffer for which we are checking the response, so the error message
1179 else if (errno != 0 || sx->buffer[0] == 0)
1181 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
1182 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1186 /* Handle SMTP permanent and temporary response codes. */
1191 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1192 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1193 string_printing(sx->buffer));
1194 setflag(addr, af_pass_message);
1196 msglog_line(sx->conn_args.host, addr->message);
1198 /* The response was 5xx */
1200 if (sx->buffer[0] == '5')
1202 addr->transport_return = FAIL;
1206 /* The response was 4xx */
1210 addr->transport_return = DEFER;
1211 addr->basic_errno = ERRNO_RCPT4XX;
1212 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1216 #ifndef DISABLE_EVENT
1217 event_defer_errno = addr->more_errno;
1218 msg_event_raise(US"msg:rcpt:host:defer", addr);
1221 /* Log temporary errors if there are more hosts to be tried.
1222 If not, log this last one in the == line. */
1224 if (sx->conn_args.host->next)
1225 if (LOGGING(outgoing_port))
1226 log_write(0, LOG_MAIN, "H=%s [%s]:%d %s", sx->conn_args.host->name,
1227 sx->conn_args.host->address,
1228 sx->port == PORT_NONE ? 25 : sx->port, addr->message);
1230 log_write(0, LOG_MAIN, "H=%s [%s]: %s", sx->conn_args.host->name,
1231 sx->conn_args.host->address, addr->message);
1233 #ifndef DISABLE_EVENT
1235 msg_event_raise(US"msg:rcpt:defer", addr);
1238 /* Do not put this message on the list of those waiting for specific
1239 hosts, as otherwise it is likely to be tried too often. */
1241 update_waiting = FALSE;
1243 /* Add a retry item for the address so that it doesn't get tried again
1244 too soon. If address_retry_include_sender is true, add the sender address
1245 to the retry key. */
1247 retry_add_item(addr,
1248 ob->address_retry_include_sender
1249 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1250 : addr->address_retry_key,
1255 } /* Loop for next RCPT response */
1257 /* Update where to start at for the next block of responses, unless we
1258 have already handled all the addresses. */
1260 if (addr) sx->sync_addr = addr->next;
1262 /* Handle a response to DATA. If we have not had any good recipients, either
1263 previously or in this block, the response is ignored. */
1265 if (pending_DATA != 0)
1267 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1268 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1269 '3', ob->command_timeout))
1275 if (errno == ERRNO_TLSFAILURE) /* Error on first TLS read */
1278 if (pending_DATA > 0 || (yield & 1) != 0)
1280 if (errno == 0 && sx->buffer[0] == '4')
1282 errno = ERRNO_DATA4XX;
1283 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1287 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1288 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1289 "is in use and there were no good recipients\n", msg);
1293 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1294 present) received 3xx. If any RCPTs were handled and yielded anything other
1295 than 4xx, yield will be set non-zero. */
1304 /* Try an authenticator's client entry */
1307 try_authenticator(smtp_context * sx, auth_instance * au)
1309 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1310 host_item * host = sx->conn_args.host; /* host to deliver to */
1313 sx->outblock.authenticating = TRUE;
1314 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1315 sx->buffer, sizeof(sx->buffer));
1316 sx->outblock.authenticating = FALSE;
1317 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1319 /* A temporary authentication failure must hold up delivery to
1320 this host. After a permanent authentication failure, we carry on
1321 to try other authentication methods. If all fail hard, try to
1322 deliver the message unauthenticated unless require_auth was set. */
1327 f.smtp_authenticated = TRUE; /* stops the outer loop */
1328 client_authenticator = au->name;
1329 if (au->set_client_id)
1330 client_authenticated_id = expand_string(au->set_client_id);
1333 /* Failure after writing a command */
1338 /* Failure after reading a response */
1341 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1342 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1343 au->name, host->name, host->address, sx->buffer);
1346 /* Failure by some other means. In effect, the authenticator
1347 decided it wasn't prepared to handle this case. Typically this
1348 is the result of "fail" in an expansion string. Do we need to
1349 log anything here? Feb 2006: a message is now put in the buffer
1350 if logging is required. */
1353 if (*sx->buffer != 0)
1354 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1355 "authentication H=%s [%s] %s", au->name, host->name,
1356 host->address, sx->buffer);
1359 /* Internal problem, message in buffer. */
1362 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1372 /* Do the client side of smtp-level authentication.
1375 sx smtp connection context
1377 sx->buffer should have the EHLO response from server (gets overwritten)
1380 OK Success, or failed (but not required): global "smtp_authenticated" set
1381 DEFER Failed authentication (and was required)
1382 ERROR Internal problem
1384 FAIL_SEND Failed communications - transmit
1389 smtp_auth(smtp_context * sx)
1391 host_item * host = sx->conn_args.host; /* host to deliver to */
1392 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1393 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1394 #ifdef EXPERIMENTAL_PIPE_CONNECT
1395 unsigned short authbits = tls_out.active.sock >= 0
1396 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1398 uschar * fail_reason = US"server did not advertise AUTH support";
1400 f.smtp_authenticated = FALSE;
1401 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1404 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1406 /* Is the server offering AUTH? */
1410 #ifdef EXPERIMENTAL_PIPE_CONNECT
1411 sx->early_pipe_active ? authbits
1414 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1417 uschar * names = NULL;
1418 expand_nmax = -1; /* reset */
1420 #ifdef EXPERIMENTAL_PIPE_CONNECT
1421 if (!sx->early_pipe_active)
1423 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1425 /* Must not do this check until after we have saved the result of the
1426 regex match above as the check could be another RE. */
1428 if ( require_auth == OK
1429 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1433 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1434 fail_reason = US"no common mechanisms were found";
1436 #ifdef EXPERIMENTAL_PIPE_CONNECT
1437 if (sx->early_pipe_active)
1439 /* Scan our authenticators (which support use by a client and were offered
1440 by the server (checked at cache-write time)), not suppressed by
1441 client_condition. If one is found, attempt to authenticate by calling its
1442 client function. We are limited to supporting up to 16 authenticator
1443 public-names by the number of bits in a short. */
1448 for (bitnum = 0, au = auths;
1449 !f.smtp_authenticated && au && bitnum < 16;
1450 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1452 if ( au->client_condition
1453 && !expand_check_condition(au->client_condition, au->name,
1454 US"client authenticator"))
1456 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1457 au->name, "client_condition is false");
1461 /* Found data for a listed mechanism. Call its client entry. Set
1462 a flag in the outblock so that data is overwritten after sending so
1463 that reflections don't show it. */
1465 fail_reason = US"authentication attempt(s) failed";
1467 if ((rc = try_authenticator(sx, au)) != OK)
1474 /* Scan the configured authenticators looking for one which is configured
1475 for use as a client, which is not suppressed by client_condition, and
1476 whose name matches an authentication mechanism supported by the server.
1477 If one is found, attempt to authenticate by calling its client function.
1480 for (au = auths; !f.smtp_authenticated && au; au = au->next)
1485 || ( au->client_condition
1486 && !expand_check_condition(au->client_condition, au->name,
1487 US"client authenticator")))
1489 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1491 (au->client)? "client_condition is false" :
1492 "not configured as a client");
1496 /* Loop to scan supported server mechanisms */
1500 int len = Ustrlen(au->public_name);
1503 while (isspace(*p)) p++;
1505 if (strncmpic(au->public_name, p, len) != 0 ||
1506 (p[len] != 0 && !isspace(p[len])))
1508 while (*p != 0 && !isspace(*p)) p++;
1512 /* Found data for a listed mechanism. Call its client entry. Set
1513 a flag in the outblock so that data is overwritten after sending so
1514 that reflections don't show it. */
1516 fail_reason = US"authentication attempt(s) failed";
1518 if ((rc = try_authenticator(sx, au)) != OK)
1521 break; /* If not authenticated, try next authenticator */
1522 } /* Loop for scanning supported server mechanisms */
1523 } /* Loop for further authenticators */
1527 /* If we haven't authenticated, but are required to, give up. */
1529 if (require_auth == OK && !f.smtp_authenticated)
1531 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1532 string_sprintf("authentication required but %s", fail_reason), DEFER,
1541 /* Construct AUTH appendix string for MAIL TO */
1544 buffer to build string
1545 addrlist chain of potential addresses to deliver
1546 ob transport options
1548 Globals f.smtp_authenticated
1549 client_authenticated_sender
1550 Return True on error, otherwise buffer has (possibly empty) terminated string
1554 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1555 smtp_transport_options_block *ob)
1557 uschar *local_authenticated_sender = authenticated_sender;
1560 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1563 if (ob->authenticated_sender != NULL)
1565 uschar *new = expand_string(ob->authenticated_sender);
1568 if (!f.expand_string_forcedfail)
1570 uschar *message = string_sprintf("failed to expand "
1571 "authenticated_sender: %s", expand_string_message);
1572 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1576 else if (new[0] != 0) local_authenticated_sender = new;
1579 /* Add the authenticated sender address if present */
1581 if ((f.smtp_authenticated || ob->authenticated_sender_force) &&
1582 local_authenticated_sender != NULL)
1584 string_format(buffer, bufsize, " AUTH=%s",
1585 auth_xtextencode(local_authenticated_sender,
1586 Ustrlen(local_authenticated_sender)));
1587 client_authenticated_sender = string_copy(local_authenticated_sender);
1598 /* Lookup TLSA record for host/port.
1599 Return: OK success with dnssec; DANE mode
1600 DEFER Do not use this host now, may retry later
1601 FAIL_FORCED No TLSA record; DANE not usable
1602 FAIL Do not use this connection
1606 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1608 /* move this out to host.c given the similarity to dns_lookup() ? */
1610 const uschar * fullname = buffer;
1614 /* TLSA lookup string */
1615 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1617 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1618 sec = dns_is_secure(dnsa);
1620 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1625 return DEFER; /* just defer this TLS'd conn */
1634 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1635 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1636 if (rr->type == T_TLSA && rr->size > 3)
1638 uint16_t payload_length = rr->size - 3;
1639 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1641 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1642 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1643 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1644 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1645 sp += sprintf(CS sp, "%02x", *p++);
1647 debug_printf(" %s\n", s);
1652 log_write(0, LOG_MAIN,
1653 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1656 case DNS_NODATA: /* no TLSA RR for this lookup */
1657 case DNS_NOMATCH: /* no records at all for this lookup */
1658 return dane_required ? FAIL : FAIL_FORCED;
1662 return dane_required ? FAIL : DEFER;
1669 typedef struct smtp_compare_s
1671 uschar *current_sender_address;
1672 struct transport_instance *tblock;
1676 /* Create a unique string that identifies this message, it is based on
1677 sender_address, helo_data and tls_certificate if enabled.
1681 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1683 address_item * addr1;
1684 uschar * if1 = US"";
1685 uschar * helo1 = US"";
1687 uschar * tlsc1 = US"";
1689 uschar * save_sender_address = sender_address;
1690 uschar * local_identity = NULL;
1691 smtp_transport_options_block * ob = SOB tblock->options_block;
1693 sender_address = sender;
1695 addr1 = deliver_make_addr (sender, TRUE);
1696 deliver_set_expansions(addr1);
1699 if1 = expand_string(ob->interface);
1702 helo1 = expand_string(ob->helo_data);
1705 if (ob->tls_certificate)
1706 tlsc1 = expand_string(ob->tls_certificate);
1707 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1709 local_identity = string_sprintf ("%s^%s", if1, helo1);
1712 deliver_set_expansions(NULL);
1713 sender_address = save_sender_address;
1715 return local_identity;
1720 /* This routine is a callback that is called from transport_check_waiting.
1721 This function will evaluate the incoming message versus the previous
1722 message. If the incoming message is using a different local identity then
1723 we will veto this new message. */
1726 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1728 uschar * message_local_identity,
1729 * current_local_identity,
1730 * new_sender_address;
1732 current_local_identity =
1733 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1735 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1738 message_local_identity =
1739 smtp_local_identity(new_sender_address, s_compare->tblock);
1741 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1747 ehlo_response(uschar * buf, unsigned checks)
1749 size_t bsize = Ustrlen(buf);
1751 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1754 # ifdef EXPERIMENTAL_REQUIRETLS
1755 if ( checks & OPTION_REQUIRETLS
1756 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1758 checks &= ~OPTION_REQUIRETLS;
1760 if ( checks & OPTION_TLS
1761 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1763 checks &= ~OPTION_TLS;
1765 if ( checks & OPTION_IGNQ
1766 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1767 PCRE_EOPT, NULL, 0) < 0)
1768 checks &= ~OPTION_IGNQ;
1770 if ( checks & OPTION_CHUNKING
1771 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1772 checks &= ~OPTION_CHUNKING;
1774 #ifndef DISABLE_PRDR
1775 if ( checks & OPTION_PRDR
1776 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1778 checks &= ~OPTION_PRDR;
1781 if ( checks & OPTION_UTF8
1782 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1784 checks &= ~OPTION_UTF8;
1786 if ( checks & OPTION_DSN
1787 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1788 checks &= ~OPTION_DSN;
1790 if ( checks & OPTION_PIPE
1791 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1792 PCRE_EOPT, NULL, 0) < 0)
1793 checks &= ~OPTION_PIPE;
1795 if ( checks & OPTION_SIZE
1796 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1797 checks &= ~OPTION_SIZE;
1799 #ifdef EXPERIMENTAL_PIPE_CONNECT
1800 if ( checks & OPTION_EARLY_PIPE
1801 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1802 PCRE_EOPT, NULL, 0) < 0)
1804 checks &= ~OPTION_EARLY_PIPE;
1806 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1812 /* Callback for emitting a BDAT data chunk header.
1814 If given a nonzero size, first flush any buffered SMTP commands
1815 then emit the command.
1817 Reap previous SMTP command responses if requested, and always reap
1818 the response from a previous BDAT command.
1821 tctx transport context
1822 chunk_size value for SMTP BDAT command
1824 tc_chunk_last add LAST option to SMTP BDAT command
1825 tc_reap_prev reap response to previous SMTP commands
1829 DEFER TLS error on first read (EHLO-resp); errno set
1833 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1836 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1837 smtp_context * sx = tctx->smtp_context;
1841 /* Write SMTP chunk header command. If not reaping responses, note that
1842 there may be more writes (like, the chunk data) done soon. */
1846 #ifdef EXPERIMENTAL_PIPE_CONNECT
1847 BOOL new_conn = !!(sx->outblock.conn_args);
1849 if((cmd_count = smtp_write_command(sx,
1850 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1851 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1852 ) < 0) return ERROR;
1853 if (flags & tc_chunk_last)
1854 data_command = string_copy(big_buffer); /* Save for later error message */
1855 #ifdef EXPERIMENTAL_PIPE_CONNECT
1856 /* That command write could have been the one that made the connection.
1857 Copy the fd from the client conn ctx (smtp transport specific) to the
1858 generic transport ctx. */
1861 tctx->u.fd = sx->outblock.cctx->sock;
1865 prev_cmd_count = cmd_count += sx->cmd_count;
1867 /* Reap responses for any previous, but not one we just emitted */
1871 if (sx->pending_BDAT)
1874 if (flags & tc_reap_prev && prev_cmd_count > 0)
1876 DEBUG(D_transport) debug_printf("look for %d responses"
1877 " for previous pipelined cmds\n", prev_cmd_count);
1879 switch(sync_responses(sx, prev_cmd_count, 0))
1881 case 1: /* 2xx (only) => OK */
1882 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1883 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1884 case 0: break; /* No 2xx or 5xx, but no probs */
1886 case -5: errno = ERRNO_TLSFAILURE;
1888 #ifdef EXPERIMENTAL_PIPE_CONNECT
1889 case -4: /* non-2xx for pipelined banner or EHLO */
1891 case -1: /* Timeout on RCPT */
1892 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1895 if (!sx->pending_BDAT)
1896 pipelining_active = FALSE;
1899 /* Reap response for an outstanding BDAT */
1901 if (sx->pending_BDAT)
1903 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1905 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1906 ob->command_timeout))
1908 if (errno == 0 && sx->buffer[0] == '4')
1910 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1911 sx->addrlist->more_errno |=
1912 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1917 sx->pending_BDAT = FALSE;
1918 pipelining_active = FALSE;
1920 else if (chunk_size > 0)
1921 sx->pending_BDAT = TRUE;
1924 sx->cmd_count = cmd_count;
1932 /*************************************************
1933 * Make connection for given message *
1934 *************************************************/
1938 ctx connection context
1939 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1940 a second attempt after TLS initialization fails
1942 Returns: OK - the connection was made and the delivery attempted;
1943 fd is set in the conn context, tls_out set up.
1944 DEFER - the connection could not be made, or something failed
1945 while setting up the SMTP session, or there was a
1946 non-message-specific error, such as a timeout.
1947 ERROR - helo_data or add_headers or authenticated_sender is
1948 specified for this transport, and the string failed
1952 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1954 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1955 dns_answer tlsa_dnsa;
1957 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1958 BOOL pass_message = FALSE;
1959 uschar * message = NULL;
1963 uschar * tls_errstr;
1966 sx->conn_args.ob = ob;
1968 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1969 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1971 sx->send_rset = TRUE;
1972 sx->send_quit = TRUE;
1973 sx->setting_up = TRUE;
1975 sx->esmtp_sent = FALSE;
1977 sx->utf8_needed = FALSE;
1979 sx->dsn_all_lasthop = TRUE;
1980 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1983 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1985 #ifdef EXPERIMENTAL_PIPE_CONNECT
1986 sx->early_pipe_active = sx->early_pipe_ok = FALSE;
1987 sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0;
1988 sx->pending_BANNER = sx->pending_EHLO = FALSE;
1991 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1992 sx->peer_offered = 0;
1993 sx->avoid_option = 0;
1994 sx->igquotstr = US"";
1995 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1996 #ifdef EXPERIMENTAL_DSN_INFO
1997 sx->smtp_greeting = NULL;
1998 sx->helo_response = NULL;
2001 smtp_command = US"initial connection";
2002 sx->buffer[0] = '\0';
2004 /* Set up the buffer for reading SMTP response packets. */
2006 sx->inblock.buffer = sx->inbuffer;
2007 sx->inblock.buffersize = sizeof(sx->inbuffer);
2008 sx->inblock.ptr = sx->inbuffer;
2009 sx->inblock.ptrend = sx->inbuffer;
2011 /* Set up the buffer for holding SMTP commands while pipelining */
2013 sx->outblock.buffer = sx->outbuffer;
2014 sx->outblock.buffersize = sizeof(sx->outbuffer);
2015 sx->outblock.ptr = sx->outbuffer;
2016 sx->outblock.cmd_count = 0;
2017 sx->outblock.authenticating = FALSE;
2018 sx->outblock.conn_args = NULL;
2020 /* Reset the parameters of a TLS session. */
2023 tls_out.cipher = NULL; /* the one we may use for this transport */
2024 tls_out.ourcert = NULL;
2025 tls_out.peercert = NULL;
2026 tls_out.peerdn = NULL;
2027 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
2030 tls_out.ocsp = OCSP_NOT_REQ;
2032 /* Flip the legacy TLS-related variables over to the outbound set in case
2033 they're used in the context of the transport. Don't bother resetting
2034 afterward (when being used by a transport) as we're in a subprocess.
2035 For verify, unflipped once the callout is dealt with */
2037 tls_modify_variables(&tls_out);
2042 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
2048 /* Make a connection to the host if this isn't a continued delivery, and handle
2049 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2050 specially so they can be identified for retries. */
2052 if (!continue_hostname)
2055 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2057 /* Get the actual port the connection will use, into sx->conn_args.host */
2059 smtp_port_for_connect(sx->conn_args.host, sx->port);
2061 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
2062 /* Do TLSA lookup for DANE */
2064 tls_out.dane_verified = FALSE;
2065 tls_out.tlsa_usage = 0;
2067 if (sx->conn_args.host->dnssec == DS_YES)
2069 if( sx->dane_required
2070 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2072 switch (rc = tlsa_lookup(sx->conn_args.host, &tlsa_dnsa, sx->dane_required))
2074 case OK: sx->dane = TRUE;
2075 ob->tls_tempfail_tryclear = FALSE;
2077 case FAIL_FORCED: break;
2078 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2079 string_sprintf("DANE error: tlsa lookup %s",
2080 rc == DEFER ? "DEFER" : "FAIL"),
2082 # ifndef DISABLE_EVENT
2083 (void) event_raise(sx->conn_args.tblock->event_action,
2084 US"dane:fail", sx->dane_required
2085 ? US"dane-required" : US"dnssec-invalid");
2090 else if (sx->dane_required)
2092 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2093 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2095 # ifndef DISABLE_EVENT
2096 (void) event_raise(sx->conn_args.tblock->event_action,
2097 US"dane:fail", US"dane-required");
2104 /* Make the TCP connection */
2106 sx->cctx.tls_ctx = NULL;
2107 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2108 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2110 #ifdef EXPERIMENTAL_PIPE_CONNECT
2111 if (verify_check_given_host(CUSS &ob->hosts_pipe_connect, sx->conn_args.host) == OK)
2113 sx->early_pipe_ok = TRUE;
2114 if ( read_ehlo_cache_entry(sx)
2115 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2117 DEBUG(D_transport) debug_printf("Using cached cleartext PIPE_CONNECT\n");
2118 sx->early_pipe_active = TRUE;
2119 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2123 if (sx->early_pipe_active)
2124 sx->outblock.conn_args = &sx->conn_args;
2128 if ((sx->cctx.sock = smtp_connect(&sx->conn_args, NULL)) < 0)
2130 uschar * msg = NULL;
2133 msg = US strerror(errno);
2134 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
2136 set_errno_nohost(sx->addrlist,
2137 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2138 sx->verify ? string_sprintf("could not connect: %s", msg)
2141 sx->send_quit = FALSE;
2145 /* Expand the greeting message while waiting for the initial response. (Makes
2146 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2147 delayed till here so that $sending_interface and $sending_port are set. */
2148 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2149 will be? Somehow I doubt it. */
2152 if (!(sx->helo_data = expand_string(sx->helo_data)))
2154 log_write(0, LOG_MAIN|LOG_PANIC,
2155 "<%s>: failed to expand transport's helo_data value for callout: %s",
2156 sx->addrlist->address, expand_string_message);
2161 expand_string_message = NULL;
2162 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2163 &expand_string_message)),
2164 expand_string_message)
2166 log_write(0, LOG_MAIN|LOG_PANIC,
2167 "<%s>: failed to expand transport's helo_data value for callout: %s",
2168 sx->addrlist->address, expand_string_message);
2170 sx->helo_data = NULL;
2174 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2175 is nevertheless a reasonably clean way of programming this kind of logic,
2176 where you want to escape on any error. */
2180 #ifdef EXPERIMENTAL_PIPE_CONNECT
2181 if (sx->early_pipe_active)
2183 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2184 sx->outblock.cmd_count = 1;
2190 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2193 if (!smtp_reap_banner(sx))
2194 goto RESPONSE_FAILED;
2197 #ifndef DISABLE_EVENT
2200 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2201 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2202 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2205 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2206 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2214 /* Now check if the helo_data expansion went well, and sign off cleanly if
2219 message = string_sprintf("failed to expand helo_data: %s",
2220 expand_string_message);
2221 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2227 /** Debugging without sending a message
2228 sx->addrlist->transport_return = DEFER;
2232 /* Errors that occur after this point follow an SMTP command, which is
2233 left in big_buffer by smtp_write_command() for use in error messages. */
2235 smtp_command = big_buffer;
2237 /* Tell the remote who we are...
2239 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2240 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2241 greeting is of this form. The assumption was that the far end supports it
2242 properly... but experience shows that there are some that give 5xx responses,
2243 even though the banner includes "ESMTP" (there's a bloody-minded one that
2244 says "ESMTP not spoken here"). Cope with that case.
2246 September 2000: Time has passed, and it seems reasonable now to always send
2247 EHLO at the start. It is also convenient to make the change while installing
2250 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2251 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2252 would be no way to send out the mails, so there is now a host list
2253 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2254 PIPELINING problem as well. Maybe it can also be useful to cure other
2255 problems with broken servers.
2257 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2258 Then somebody tried it with a Microsoft mailer... It seems that all other
2259 mailers use upper case for some reason (the RFC is quite clear about case
2260 independence) so, for peace of mind, I gave in. */
2262 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2264 /* Alas; be careful, since this goto is not an error-out, so conceivably
2265 we might set data between here and the target which we assume to exist
2266 and be usable. I can see this coming back to bite us. */
2270 smtp_peer_options |= OPTION_TLS;
2271 suppress_tls = FALSE;
2272 ob->tls_tempfail_tryclear = FALSE;
2273 smtp_command = US"SSL-on-connect";
2280 if (smtp_write_command(sx,
2281 #ifdef EXPERIMENTAL_PIPE_CONNECT
2282 sx->early_pipe_active ? SCMD_BUFFER :
2285 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2287 sx->esmtp_sent = TRUE;
2289 #ifdef EXPERIMENTAL_PIPE_CONNECT
2290 if (sx->early_pipe_active)
2292 sx->pending_EHLO = TRUE;
2294 /* If we have too many authenticators to handle and might need to AUTH
2295 for this transport, pipeline no further as we will need the
2296 list of auth methods offered. Reap the banner and EHLO. */
2298 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2299 && f.smtp_in_early_pipe_no_auth)
2301 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2302 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2304 if (sync_responses(sx, 2, 0) != 0)
2307 debug_printf("failed reaping pipelined cmd responses\n");
2308 goto RESPONSE_FAILED;
2310 sx->early_pipe_active = FALSE;
2315 if (!smtp_reap_ehlo(sx))
2316 goto RESPONSE_FAILED;
2320 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2322 #ifdef EXPERIMENTAL_PIPE_CONNECT
2323 if (!sx->early_pipe_active)
2328 int n = sizeof(sx->buffer);
2329 uschar * rsp = sx->buffer;
2331 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2332 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2334 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2336 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2337 #ifdef EXPERIMENTAL_DSN_INFO
2338 sx->helo_response = string_copy(rsp);
2342 /* Handle special logging for a closed connection after HELO
2343 when had previously sent EHLO */
2345 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2347 errno = ERRNO_SMTPCLOSED;
2348 goto EHLOHELO_FAILED;
2350 memmove(sx->buffer, rsp, Ustrlen(rsp));
2351 goto RESPONSE_FAILED;
2355 if (sx->esmtp || sx->lmtp)
2357 #ifdef EXPERIMENTAL_PIPE_CONNECT
2358 if (!sx->early_pipe_active)
2361 sx->peer_offered = ehlo_response(sx->buffer,
2362 OPTION_TLS /* others checked later */
2363 #ifdef EXPERIMENTAL_PIPE_CONNECT
2364 | (sx->early_pipe_ok
2366 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2375 #ifdef EXPERIMENTAL_PIPE_CONNECT
2376 if (sx->early_pipe_ok)
2378 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2380 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2381 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2383 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2384 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2385 write_ehlo_cache_entry(sx);
2391 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2394 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2399 /* For continuing deliveries down the same channel, having re-exec'd the socket
2400 is the standard input; for a socket held open from verify it is recorded
2401 in the cutthrough context block. Either way we don't need to redo EHLO here
2402 (but may need to do so for TLS - see below).
2403 Set up the pointer to where subsequent commands will be left, for
2404 error messages. Note that smtp_peer_options will have been
2405 set from the command line if they were set in the process that passed the
2408 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2409 as the continue goes via transport_pass_socket() and doublefork and exec.
2410 It does not wait. Unclear how we keep separate host's responses
2411 separate - we could match up by host ip+port as a bodge. */
2415 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2417 sx->cctx = cutthrough.cctx;
2418 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2422 sx->cctx.sock = 0; /* stdin */
2423 sx->cctx.tls_ctx = NULL;
2424 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2426 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2427 smtp_command = big_buffer;
2428 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2430 /* For a continued connection with TLS being proxied for us, or a
2431 held-open verify connection with TLS, nothing more to do. */
2433 if ( continue_proxy_cipher
2434 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2435 && cutthrough.is_tls)
2438 sx->peer_offered = smtp_peer_options;
2439 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2440 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2441 continue_proxy_cipher ? "proxied" : "verify conn with");
2444 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2447 /* If TLS is available on this connection, whether continued or not, attempt to
2448 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2449 send another EHLO - the server may give a different answer in secure mode. We
2450 use a separate buffer for reading the response to STARTTLS so that if it is
2451 negative, the original EHLO data is available for subsequent analysis, should
2452 the client not be required to use TLS. If the response is bad, copy the buffer
2453 for error analysis. */
2456 if ( smtp_peer_options & OPTION_TLS
2458 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2460 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2463 uschar buffer2[4096];
2465 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2468 #ifdef EXPERIMENTAL_PIPE_CONNECT
2469 /* If doing early-pipelining reap the banner and EHLO-response but leave
2470 the response for the STARTTLS we just sent alone. */
2472 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2475 debug_printf("failed reaping pipelined cmd responses\n");
2476 goto RESPONSE_FAILED;
2480 /* If there is an I/O error, transmission of this message is deferred. If
2481 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2482 false, we also defer. However, if there is a temporary rejection of STARTTLS
2483 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2484 STARTTLS, we carry on. This means we will try to send the message in clear,
2485 unless the host is in hosts_require_tls (tested below). */
2487 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2491 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2494 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2495 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2496 goto RESPONSE_FAILED;
2500 /* STARTTLS accepted: try to negotiate a TLS session. */
2505 address_item * addr;
2506 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->conn_args.host,
2507 sx->addrlist, sx->conn_args.tblock,
2508 # ifdef SUPPORT_DANE
2509 sx->dane ? &tlsa_dnsa : NULL,
2511 &tls_out, &tls_errstr);
2513 if (!sx->cctx.tls_ctx)
2515 /* TLS negotiation failed; give an error. From outside, this function may
2516 be called again to try in clear on a new connection, if the options permit
2517 it for this host. */
2519 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", tls_errstr);
2521 # ifdef SUPPORT_DANE
2524 log_write(0, LOG_MAIN,
2525 "DANE attempt failed; TLS connection to %s [%s]: %s",
2526 sx->conn_args.host->name, sx->conn_args.host->address, tls_errstr);
2527 # ifndef DISABLE_EVENT
2528 (void) event_raise(sx->conn_args.tblock->event_action,
2529 US"dane:fail", US"validation-failure"); /* could do with better detail */
2534 errno = ERRNO_TLSFAILURE;
2535 message = string_sprintf("TLS session: %s", tls_errstr);
2536 sx->send_quit = FALSE;
2540 /* TLS session is set up */
2542 smtp_peer_options_wrap = smtp_peer_options;
2543 for (addr = sx->addrlist; addr; addr = addr->next)
2544 if (addr->transport_return == PENDING_DEFER)
2546 addr->cipher = tls_out.cipher;
2547 addr->ourcert = tls_out.ourcert;
2548 addr->peercert = tls_out.peercert;
2549 addr->peerdn = tls_out.peerdn;
2550 addr->ocsp = tls_out.ocsp;
2555 /* if smtps, we'll have smtp_command set to something else; always safe to
2557 smtp_command = big_buffer;
2559 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2560 helo_data is null, we are dealing with a connection that was passed from
2561 another process, and so we won't have expanded helo_data above. We have to
2562 expand it here. $sending_ip_address and $sending_port are set up right at the
2563 start of the Exim process (in exim.c). */
2565 if (tls_out.active.sock >= 0)
2567 uschar * greeting_cmd;
2569 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2571 uschar *message = string_sprintf("failed to expand helo_data: %s",
2572 expand_string_message);
2573 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2578 #ifdef EXPERIMENTAL_PIPE_CONNECT
2579 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2580 We're unlikely to get the group sent and delivered before the server sends its
2581 banner, but it's still worth sending as a group.
2582 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2585 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2587 sx->peer_offered = sx->ehlo_resp.crypted_features;
2588 if ((sx->early_pipe_active =
2589 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2590 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2594 /* For SMTPS we need to wait for the initial OK response. */
2596 #ifdef EXPERIMENTAL_PIPE_CONNECT
2597 if (sx->early_pipe_active)
2599 sx->pending_BANNER = TRUE;
2600 sx->outblock.cmd_count = 1;
2604 if (!smtp_reap_banner(sx))
2605 goto RESPONSE_FAILED;
2608 greeting_cmd = US"LHLO";
2610 greeting_cmd = US"EHLO";
2613 greeting_cmd = US"HELO";
2615 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2618 if (smtp_write_command(sx,
2619 #ifdef EXPERIMENTAL_PIPE_CONNECT
2620 sx->early_pipe_active ? SCMD_BUFFER :
2623 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2626 #ifdef EXPERIMENTAL_PIPE_CONNECT
2627 if (sx->early_pipe_active)
2628 sx->pending_EHLO = TRUE;
2632 if (!smtp_reap_ehlo(sx))
2635 /* The GnuTLS layer in Exim only spots a server-rejection of a client
2636 cert late, under TLS1.3 - which means here; the first time we try to
2637 receive crypted data. Treat it as if it was a connect-time failure.
2638 See also the early-pipe equivalent... which will be hard; every call
2639 to sync_responses will need to check the result.
2640 It would be nicer to have GnuTLS check the cert during the handshake.
2641 Can it do that, with all the flexibility we need? */
2643 tls_errstr = US"error on first read";
2644 goto GNUTLS_CONN_FAILED;
2647 goto RESPONSE_FAILED;
2649 smtp_peer_options = 0;
2653 /* If the host is required to use a secure channel, ensure that we
2657 # ifdef SUPPORT_DANE
2660 # ifdef EXPERIMENTAL_REQUIRETLS
2661 || tls_requiretls & REQUIRETLS_MSG
2663 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2667 # ifdef EXPERIMENTAL_REQUIRETLS
2668 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2671 message = string_sprintf("a TLS session is required, but %s",
2672 smtp_peer_options & OPTION_TLS
2673 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2674 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2676 (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2677 smtp_peer_options & OPTION_TLS
2678 ? US"validation-failure" /* could do with better detail */
2679 : US"starttls-not-supported");
2683 #endif /*SUPPORT_TLS*/
2685 /* If TLS is active, we have just started it up and re-done the EHLO command,
2686 so its response needs to be analyzed. If TLS is not active and this is a
2687 continued session down a previously-used socket, we haven't just done EHLO, so
2690 if (continue_hostname == NULL
2692 || tls_out.active.sock >= 0
2696 if (sx->esmtp || sx->lmtp)
2698 #ifdef EXPERIMENTAL_PIPE_CONNECT
2699 if (!sx->early_pipe_active)
2702 sx->peer_offered = ehlo_response(sx->buffer,
2704 #ifdef EXPERIMENTAL_PIPE_CONNECT
2705 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2706 | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2707 | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8 | OPTION_REQUIRETLS
2708 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2712 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2715 # ifdef SUPPORT_I18N
2716 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2717 /*XXX if we hand peercaps on to continued-conn processes,
2718 must not depend on this addr */
2722 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2723 # if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2724 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2728 #ifdef EXPERIMENTAL_PIPE_CONNECT
2729 if (tls_out.active.sock >= 0)
2730 sx->ehlo_resp.crypted_features = sx->peer_offered;
2734 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2735 lmtp_ignore_quota option was set. */
2737 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2739 /* If the response to EHLO specified support for the SIZE parameter, note
2740 this, provided size_addition is non-negative. */
2742 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2744 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2745 the current host, esmtp will be false, so PIPELINING can never be used. If
2746 the current host matches hosts_avoid_pipelining, don't do it. */
2748 if ( sx->peer_offered & OPTION_PIPE
2749 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2750 smtp_peer_options |= OPTION_PIPE;
2752 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2753 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2755 if ( sx->peer_offered & OPTION_CHUNKING
2756 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2757 sx->peer_offered &= ~OPTION_CHUNKING;
2759 if (sx->peer_offered & OPTION_CHUNKING)
2760 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2762 #ifndef DISABLE_PRDR
2763 if ( sx->peer_offered & OPTION_PRDR
2764 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2765 sx->peer_offered &= ~OPTION_PRDR;
2767 if (sx->peer_offered & OPTION_PRDR)
2768 DEBUG(D_transport) debug_printf("PRDR usable\n");
2771 /* Note if the server supports DSN */
2772 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2773 DEBUG(D_transport) debug_printf("%susing DSN\n",
2774 sx->peer_offered & OPTION_DSN ? "" : "not ");
2776 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2777 if (sx->peer_offered & OPTION_REQUIRETLS)
2779 smtp_peer_options |= OPTION_REQUIRETLS;
2780 DEBUG(D_transport) debug_printf(
2781 tls_requiretls & REQUIRETLS_MSG
2782 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2786 #ifdef EXPERIMENTAL_PIPE_CONNECT
2787 if ( sx->early_pipe_ok
2788 && !sx->early_pipe_active
2789 && tls_out.active.sock >= 0
2790 && smtp_peer_options & OPTION_PIPE
2791 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2792 & OPTION_EARLY_PIPE)
2794 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2795 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2796 write_ehlo_cache_entry(sx);
2800 /* Note if the response to EHLO specifies support for the AUTH extension.
2801 If it has, check that this host is one we want to authenticate to, and do
2802 the business. The host name and address must be available when the
2803 authenticator's client driver is running. */
2805 switch (yield = smtp_auth(sx))
2807 default: goto SEND_QUIT;
2809 case FAIL_SEND: goto SEND_FAILED;
2810 case FAIL: goto RESPONSE_FAILED;
2814 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2816 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2817 message-specific. */
2819 sx->setting_up = FALSE;
2822 if (sx->addrlist->prop.utf8_msg)
2826 /* If the transport sets a downconversion mode it overrides any set by ACL
2829 if ((s = ob->utf8_downconvert))
2831 if (!(s = expand_string(s)))
2833 message = string_sprintf("failed to expand utf8_downconvert: %s",
2834 expand_string_message);
2835 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2841 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2842 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2844 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2845 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2847 case '-': if (s[1] == '1')
2849 sx->addrlist->prop.utf8_downcvt = FALSE;
2850 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2856 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2857 && !sx->addrlist->prop.utf8_downcvt_maybe;
2858 DEBUG(D_transport) if (!sx->utf8_needed)
2859 debug_printf("utf8: %s downconvert\n",
2860 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2863 /* If this is an international message we need the host to speak SMTPUTF8 */
2864 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2866 errno = ERRNO_UTF8_FWD;
2867 goto RESPONSE_FAILED;
2869 #endif /*SUPPORT_I18N*/
2871 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2872 /*XXX should tls_requiretls actually be per-addr? */
2874 if ( tls_requiretls & REQUIRETLS_MSG
2875 && !(sx->peer_offered & OPTION_REQUIRETLS)
2878 sx->setting_up = TRUE;
2879 errno = ERRNO_REQUIRETLS;
2880 message = US"REQUIRETLS support is required from the server"
2881 " but it was not offered";
2882 DEBUG(D_transport) debug_printf("%s\n", message);
2895 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2896 sx->buffer, &code, &message, &pass_message);
2902 message = US string_sprintf("send() to %s [%s] failed: %s",
2903 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2904 sx->send_quit = FALSE;
2910 message = string_sprintf("Remote host closed connection in response to %s"
2911 " (EHLO response was: %s)", smtp_command, sx->buffer);
2912 sx->send_quit = FALSE;
2916 /* This label is jumped to directly when a TLS negotiation has failed,
2917 or was not done for a host for which it is required. Values will be set
2918 in message and errno, and setting_up will always be true. Treat as
2919 a temporary error. */
2923 # ifdef EXPERIMENTAL_REQUIRETLS
2924 if (errno == ERRNO_REQUIRETLS)
2925 code = '5', yield = FAIL;
2926 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2929 code = '4', yield = DEFER;
2933 /* The failure happened while setting up the call; see if the failure was
2934 a 5xx response (this will either be on connection, or following HELO - a 5xx
2935 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2936 fail all addresses, as this host is never going to accept them. For other
2937 errors during setting up (timeouts or whatever), defer all addresses, and
2938 yield DEFER, so that the host is not tried again for a while.
2940 XXX This peeking for another host feels like a layering violation. We want
2941 to note the host as unusable, but down here we shouldn't know if this was
2942 the last host to try for the addr(list). Perhaps the upper layer should be
2943 the one to do set_errno() ? The problem is that currently the addr is where
2944 errno etc. are stashed, but until we run out of hosts to try the errors are
2945 host-specific. Maybe we should enhance the host_item definition? */
2948 sx->ok = FALSE; /* For when reached by GOTO */
2949 set_errno(sx->addrlist, errno, message,
2950 sx->conn_args.host->next
2954 || errno == ERRNO_UTF8_FWD
2957 pass_message, sx->conn_args.host
2958 #ifdef EXPERIMENTAL_DSN_INFO
2959 , sx->smtp_greeting, sx->helo_response
2968 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2971 if (sx->cctx.tls_ctx)
2973 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2974 sx->cctx.tls_ctx = NULL;
2978 /* Close the socket, and return the appropriate value, first setting
2979 works because the NULL setting is passed back to the calling process, and
2980 remote_max_parallel is forced to 1 when delivering over an existing connection,
2983 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2986 shutdown(sx->cctx.sock, SHUT_WR);
2987 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2988 for (rc = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && rc > 0;)
2989 rc--; /* drain socket */
2990 sx->send_quit = FALSE;
2992 (void)close(sx->cctx.sock);
2995 #ifndef DISABLE_EVENT
2996 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2999 continue_transport = NULL;
3000 continue_hostname = NULL;
3007 /* Create the string of options that will be appended to the MAIL FROM:
3008 in the connection context buffer */
3011 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
3013 uschar * p = sx->buffer;
3014 address_item * addr;
3019 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
3020 send it, adding something to the message size to allow for imprecision
3021 and things that get added en route. Exim keeps the number of lines
3022 in a message, so we can give an accurate value for the original message, but we
3023 need some additional to handle added headers. (Double "." characters don't get
3024 included in the count.) */
3026 if ( message_size > 0
3027 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
3029 /*XXX problem here under spool_files_wireformat?
3030 Or just forget about lines? Or inflate by a fixed proportion? */
3032 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
3036 #ifndef DISABLE_PRDR
3037 /* If it supports Per-Recipient Data Responses, and we have more than one recipient,
3040 sx->prdr_active = FALSE;
3041 if (sx->peer_offered & OPTION_PRDR)
3042 for (addr = addrlist; addr; addr = addr->next)
3043 if (addr->transport_return == PENDING_DEFER)
3045 for (addr = addr->next; addr; addr = addr->next)
3046 if (addr->transport_return == PENDING_DEFER)
3047 { /* at least two recipients to send */
3048 sx->prdr_active = TRUE;
3049 sprintf(CS p, " PRDR"); p += 5;
3057 /* If it supports internationalised messages, and this meesage need that,
3060 if ( sx->peer_offered & OPTION_UTF8
3061 && addrlist->prop.utf8_msg
3062 && !addrlist->prop.utf8_downcvt
3064 Ustrcpy(p, " SMTPUTF8"), p += 9;
3067 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3068 if (tls_requiretls & REQUIRETLS_MSG)
3069 Ustrcpy(p, " REQUIRETLS") , p += 11;
3072 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3073 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3074 addr && address_count < sx->max_rcpt;
3075 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3078 if (!(addr->dsn_flags & rf_dsnlasthop))
3080 sx->dsn_all_lasthop = FALSE;
3085 /* Add any DSN flags to the mail command */
3087 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3089 if (dsn_ret == dsn_ret_hdrs)
3090 { Ustrcpy(p, " RET=HDRS"); p += 9; }
3091 else if (dsn_ret == dsn_ret_full)
3092 { Ustrcpy(p, " RET=FULL"); p += 9; }
3096 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3101 /* If an authenticated_sender override has been specified for this transport
3102 instance, expand it. If the expansion is forced to fail, and there was already
3103 an authenticated_sender for this message, the original value will be used.
3104 Other expansion failures are serious. An empty result is ignored, but there is
3105 otherwise no check - this feature is expected to be used with LMTP and other
3106 cases where non-standard addresses (e.g. without domains) might be required. */
3108 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->conn_args.ob))
3116 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3118 uschar * p = sx->buffer;
3121 /* Add any DSN flags to the rcpt command */
3123 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3125 if (addr->dsn_flags & rf_dsnflags)
3130 Ustrcpy(p, " NOTIFY=");
3132 for (i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3134 if (!first) *p++ = ',';
3136 Ustrcpy(p, rf_names[i]);
3141 if (addr->dsn_orcpt)
3143 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3154 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3155 -1 MAIL response error
3156 -2 any non-MAIL read i/o error
3157 -3 non-MAIL response timeout
3158 -4 internal error; channel still usable
3163 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3165 address_item * addr;
3169 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3175 /* From here until we send the DATA command, we can make use of PIPELINING
3176 if the server host supports it. The code has to be able to check the responses
3177 at any point, for when the buffer fills up, so we write it totally generally.
3178 When PIPELINING is off, each command written reports that it has flushed the
3181 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3184 uschar * s = sx->from_addr;
3186 uschar * errstr = NULL;
3188 /* If we must downconvert, do the from-address here. Remember we had to
3189 for the to-addresses (done below), and also (ugly) for re-doing when building
3190 the delivery log line. */
3192 if ( sx->addrlist->prop.utf8_msg
3193 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3196 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3198 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3202 setflag(sx->addrlist, af_utf8_downcvt);
3206 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3207 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3210 mail_command = string_copy(big_buffer); /* Save for later error message */
3214 case -1: /* Transmission error */
3217 case +1: /* Cmd was sent */
3218 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3219 (SOB sx->conn_args.ob)->command_timeout))
3221 if (errno == 0 && sx->buffer[0] == '4')
3223 errno = ERRNO_MAIL4XX;
3224 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3228 sx->pending_MAIL = FALSE;
3231 /* otherwise zero: command queued for pipeline */
3234 /* Pass over all the relevant recipient addresses for this host, which are the
3235 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3236 several before we have to read the responses for those seen so far. This
3237 checking is done by a subroutine because it also needs to be done at the end.
3238 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3239 the next one if not all are sent.
3241 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3242 last address because we want to abort if any recipients have any kind of
3243 problem, temporary or permanent. We know that all recipient addresses will have
3244 the PENDING_DEFER status, because only one attempt is ever made, and we know
3245 that max_rcpt will be large, so all addresses will be done at once.
3247 For verify we flush the pipeline after any (the only) rcpt address. */
3249 for (addr = sx->first_addr, address_count = 0;
3250 addr && address_count < sx->max_rcpt;
3251 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3257 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3258 ? dsn_support_yes : dsn_support_no;
3261 no_flush = pipelining_active && !sx->verify
3262 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3264 build_rcptcmd_options(sx, addr);
3266 /* Now send the RCPT command, and process outstanding responses when
3267 necessary. After a timeout on RCPT, we just end the function, leaving the
3268 yield as OK, because this error can often mean that there is a problem with
3269 just one address, so we don't want to delay the host. */
3271 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3274 if ( testflag(sx->addrlist, af_utf8_downcvt)
3275 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3278 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3279 errno = ERRNO_EXPANDFAIL;
3280 return -5; /*XXX too harsh? */
3284 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3285 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3287 if (count < 0) return -5;
3290 switch(sync_responses(sx, count, 0))
3292 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3293 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3296 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3297 if (!sx->lmtp) /* can't tell about progress yet */
3298 sx->completed_addr = TRUE;
3299 case 0: /* No 2xx or 5xx, but no probs */
3302 case -1: return -3; /* Timeout on RCPT */
3303 case -2: return -2; /* non-MAIL read i/o error */
3304 default: return -1; /* any MAIL error */
3306 #ifdef EXPERIMENTAL_PIPE_CONNECT
3307 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3308 case -5: return -1; /* TLS first-read error */
3311 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
3313 } /* Loop for next address */
3315 sx->next_addr = addr;
3321 /*****************************************************
3322 * Proxy TLS connection for another transport process *
3323 ******************************************************/
3325 Close the unused end of the pipe, fork once more, then use the given buffer
3326 as a staging area, and select on both the given fd and the TLS'd client-fd for
3327 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3328 Do blocking full-size writes, and reads under a timeout. Once both input
3329 channels are closed, exit the process.
3333 buf space to use for buffering
3334 bufsiz size of buffer
3335 pfd pipe filedescriptor array; [0] is comms to proxied process
3336 timeout per-read timeout, seconds
3340 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3344 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3345 int rc, i, fd_bits, nbytes;
3350 DEBUG(D_transport) debug_printf("proxy-proc final-pid %d\n", rc);
3351 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3354 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
3355 set_process_info("proxying TLS connection for continued transport");
3357 FD_SET(tls_out.active.sock, &rfds);
3358 FD_SET(pfd[0], &rfds);
3360 for (fd_bits = 3; fd_bits; )
3362 time_t time_left = timeout;
3363 time_t time_start = time(NULL);
3369 struct timeval tv = { time_left, 0 };
3372 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
3374 if (rc < 0 && errno == EINTR)
3375 if ((time_left -= time(NULL) - time_start) > 0) continue;
3379 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
3383 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
3385 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
3386 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
3390 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
3392 /* handle inbound data */
3393 if (FD_ISSET(tls_out.active.sock, &rfds))
3394 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
3397 FD_CLR(tls_out.active.sock, &rfds);
3398 shutdown(pfd[0], SHUT_WR);
3403 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3404 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
3406 else if (fd_bits & 1)
3407 FD_SET(tls_out.active.sock, &rfds);
3409 /* handle outbound data */
3410 if (FD_ISSET(pfd[0], &rfds))
3411 if ((rc = read(pfd[0], buf, bsize)) <= 0)
3414 tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
3419 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3420 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
3423 else if (fd_bits & 2)
3424 FD_SET(pfd[0], &rfds);
3428 if (f.running_in_test_harness) millisleep(100); /* let logging complete */
3429 exim_exit(0, US"TLS proxy");
3434 /*************************************************
3435 * Deliver address list to given host *
3436 *************************************************/
3438 /* If continue_hostname is not null, we get here only when continuing to
3439 deliver down an existing channel. The channel was passed as the standard
3440 input. TLS is never active on a passed channel; the previous process always
3441 closes it down before passing the connection on.
3443 Otherwise, we have to make a connection to the remote host, and do the
3444 initial protocol exchange.
3446 When running as an MUA wrapper, if the sender or any recipient is rejected,
3447 temporarily or permanently, we force failure for all recipients.
3450 addrlist chain of potential addresses to deliver; only those whose
3451 transport_return field is set to PENDING_DEFER are currently
3452 being processed; others should be skipped - they have either
3453 been delivered to an earlier host or IP address, or been
3454 failed by one of them.
3455 host host to deliver to
3456 host_af AF_INET or AF_INET6
3457 defport default TCP/IP port to use if host does not specify, in host
3459 interface interface to bind to, or NULL
3460 tblock transport instance block
3461 message_defer set TRUE if yield is OK, but all addresses were deferred
3462 because of a non-recipient, non-host failure, that is, a
3463 4xx response to MAIL FROM, DATA, or ".". This is a defer
3464 that is specific to the message.
3465 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
3466 a second attempt after TLS initialization fails
3468 Returns: OK - the connection was made and the delivery attempted;
3469 the result for each address is in its data block.
3470 DEFER - the connection could not be made, or something failed
3471 while setting up the SMTP session, or there was a
3472 non-message-specific error, such as a timeout.
3473 ERROR - a filter command is specified for this transport,
3474 and there was a problem setting it up; OR helo_data
3475 or add_headers or authenticated_sender is specified
3476 for this transport, and the string failed to expand
3480 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
3481 uschar *interface, transport_instance *tblock,
3482 BOOL *message_defer, BOOL suppress_tls)
3485 smtp_transport_options_block * ob = SOB tblock->options_block;
3489 struct timeval start_delivery_time;
3491 BOOL pass_message = FALSE;
3492 uschar *message = NULL;
3493 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
3497 gettimeofday(&start_delivery_time, NULL);
3498 suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
3499 *message_defer = FALSE;
3501 sx.addrlist = addrlist;
3502 sx.conn_args.host = host;
3503 sx.conn_args.host_af = host_af,
3505 sx.conn_args.interface = interface;
3506 sx.helo_data = NULL;
3507 sx.conn_args.tblock = tblock;
3509 sx.sync_addr = sx.first_addr = addrlist;
3511 /* Get the channel set up ready for a message (MAIL FROM being the next
3512 SMTP command to send */
3514 if ((rc = smtp_setup_conn(&sx, suppress_tls)) != OK)
3517 /* If there is a filter command specified for this transport, we can now
3518 set it up. This cannot be done until the identify of the host is known. */
3520 if (tblock->filter_command)
3522 transport_filter_timeout = tblock->filter_timeout;
3524 /* On failure, copy the error to all addresses, abandon the SMTP call, and
3527 if (!transport_set_up_command(&transport_filter_argv,
3528 tblock->filter_command, TRUE, DEFER, addrlist,
3529 string_sprintf("%.50s transport", tblock->name), NULL))
3531 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
3537 if ( transport_filter_argv
3538 && *transport_filter_argv
3539 && **transport_filter_argv
3540 && sx.peer_offered & OPTION_CHUNKING
3543 sx.peer_offered &= ~OPTION_CHUNKING;
3544 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
3548 /* For messages that have more than the maximum number of envelope recipients,
3549 we want to send several transactions down the same SMTP connection. (See
3550 comments in deliver.c as to how this reconciles, heuristically, with
3551 remote_max_parallel.) This optimization was added to Exim after the following
3552 code was already working. The simplest way to put it in without disturbing the
3553 code was to use a goto to jump back to this point when there is another
3554 transaction to handle. */
3557 sx.from_addr = return_path;
3558 sx.sync_addr = sx.first_addr;
3560 sx.send_rset = TRUE;
3561 sx.completed_addr = FALSE;
3564 /* If we are a continued-connection-after-verify the MAIL and RCPT
3565 commands were already sent; do not re-send but do mark the addrs as
3566 having been accepted up to RCPT stage. A traditional cont-conn
3567 always has a sequence number greater than one. */
3569 if (continue_hostname && continue_sequence == 1)
3571 address_item * addr;
3573 sx.peer_offered = smtp_peer_options;
3574 sx.pending_MAIL = FALSE;
3576 sx.next_addr = NULL;
3578 for (addr = addrlist; addr; addr = addr->next)
3579 addr->transport_return = PENDING_OK;
3583 /* Initiate a message transfer. */
3585 switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
3588 case -1: case -2: goto RESPONSE_FAILED;
3589 case -3: goto END_OFF;
3590 case -4: goto SEND_QUIT;
3591 default: goto SEND_FAILED;
3594 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3595 permanently or temporarily. We should have flushed and synced after the last
3603 for (a = sx.first_addr, cnt = 0; a && cnt < sx.max_rcpt; a = a->next, cnt++)
3604 if (a->transport_return != PENDING_OK)
3606 /*XXX could we find a better errno than 0 here? */
3607 set_errno_nohost(addrlist, 0, a->message, FAIL,
3608 testflag(a, af_pass_message));
3615 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3616 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3617 have a good recipient buffered up if we are pipelining. We don't want to waste
3618 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3619 are pipelining. The responses are all handled by sync_responses().
3620 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3623 if ( !(sx.peer_offered & OPTION_CHUNKING)
3624 && (sx.ok || (pipelining_active && !mua_wrapper)))
3626 int count = smtp_write_command(&sx, SCMD_FLUSH, "DATA\r\n");
3628 if (count < 0) goto SEND_FAILED;
3629 switch(sync_responses(&sx, count, sx.ok ? +1 : -1))
3631 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3632 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3635 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3636 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3637 case 0: break; /* No 2xx or 5xx, but no probs */
3639 case -1: goto END_OFF; /* Timeout on RCPT */
3641 #ifdef EXPERIMENTAL_PIPE_CONNECT
3642 case -5: /* TLS first-read error */
3643 case -4: HDEBUG(D_transport)
3644 debug_printf("failed reaping pipelined cmd responses\n");
3646 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3648 pipelining_active = FALSE;
3649 data_command = string_copy(big_buffer); /* Save for later error message */
3652 /* If there were no good recipients (but otherwise there have been no
3653 problems), just set ok TRUE, since we have handled address-specific errors
3654 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3655 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3656 well as body. Set the appropriate timeout value to be used for each chunk.
3657 (Haven't been able to make it work using select() for writing yet.) */
3659 if (!(sx.peer_offered & OPTION_CHUNKING) && !sx.ok)
3661 /* Save the first address of the next batch. */
3662 sx.first_addr = sx.next_addr;
3668 transport_ctx tctx = {
3669 .u = {.fd = sx.cctx.sock}, /*XXX will this need TLS info? */
3672 .check_string = US".",
3673 .escape_string = US"..", /* Escaping strings */
3675 topt_use_crlf | topt_escape_headers
3676 | (tblock->body_only ? topt_no_headers : 0)
3677 | (tblock->headers_only ? topt_no_body : 0)
3678 | (tblock->return_path_add ? topt_add_return_path : 0)
3679 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3680 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3683 /* If using CHUNKING we need a callback from the generic transport
3684 support to us, for the sending of BDAT smtp commands and the reaping
3685 of responses. The callback needs a whole bunch of state so set up
3686 a transport-context structure to be passed around. */
3688 if (sx.peer_offered & OPTION_CHUNKING)
3690 tctx.check_string = tctx.escape_string = NULL;
3691 tctx.options |= topt_use_bdat;
3692 tctx.chunk_cb = smtp_chunk_cmd_callback;
3693 sx.pending_BDAT = FALSE;
3694 sx.good_RCPT = sx.ok;
3696 tctx.smtp_context = &sx;
3699 tctx.options |= topt_end_dot;
3701 /* Save the first address of the next batch. */
3702 sx.first_addr = sx.next_addr;
3704 /* Responses from CHUNKING commands go in buffer. Otherwise,
3705 there has not been a response. */
3709 sigalrm_seen = FALSE;
3710 transport_write_timeout = ob->data_timeout;
3711 smtp_command = US"sending data block"; /* For error messages */
3712 DEBUG(D_transport|D_v)
3713 if (sx.peer_offered & OPTION_CHUNKING)
3714 debug_printf(" will write message using CHUNKING\n");
3716 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3717 transport_count = 0;
3719 #ifndef DISABLE_DKIM
3720 dkim_exim_sign_init();
3721 # ifdef EXPERIMENTAL_ARC
3723 uschar * s = ob->arc_sign;
3726 if (!(ob->dkim.arc_signspec = s = expand_string(s)))
3728 if (!f.expand_string_forcedfail)
3730 message = US"failed to expand arc_sign";
3737 /* Ask dkim code to hash the body for ARC */
3738 (void) arc_ams_setup_sign_bodyhash();
3739 ob->dkim.force_bodyhash = TRUE;
3744 sx.ok = dkim_transport_write_message(&tctx, &ob->dkim, CUSS &message);
3746 sx.ok = transport_write_message(&tctx, 0);
3749 /* transport_write_message() uses write() because it is called from other
3750 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3751 it can exit with "Broken pipe" as its error. This really means that the
3752 socket got closed at the far end. */
3754 transport_write_timeout = 0; /* for subsequent transports */
3756 /* Failure can either be some kind of I/O disaster (including timeout),
3757 or the failure of a transport filter or the expansion of added headers.
3758 Or, when CHUNKING, it can be a protocol-detected failure. */
3761 if (message) goto SEND_FAILED;
3762 else goto RESPONSE_FAILED;
3764 /* We used to send the terminating "." explicitly here, but because of
3765 buffering effects at both ends of TCP/IP connections, you don't gain
3766 anything by keeping it separate, so it might as well go in the final
3767 data buffer for efficiency. This is now done by setting the topt_end_dot
3770 smtp_command = US"end of data";
3772 if (sx.peer_offered & OPTION_CHUNKING && sx.cmd_count > 1)
3774 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3775 switch(sync_responses(&sx, sx.cmd_count-1, 0))
3777 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3778 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3781 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3782 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3783 case 0: break; /* No 2xx or 5xx, but no probs */
3785 case -1: goto END_OFF; /* Timeout on RCPT */
3787 #ifdef EXPERIMENTAL_PIPE_CONNECT
3788 case -5: /* TLS first-read error */
3789 case -4: HDEBUG(D_transport)
3790 debug_printf("failed reaping pipelined cmd responses\n");
3792 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3796 #ifndef DISABLE_PRDR
3797 /* For PRDR we optionally get a partial-responses warning followed by the
3798 individual responses, before going on with the overall response. If we don't
3799 get the warning then deal with per non-PRDR. */
3803 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '3', ob->final_timeout);
3804 if (!sx.ok && errno == 0) switch(sx.buffer[0])
3806 case '2': sx.prdr_active = FALSE;
3809 case '4': errno = ERRNO_DATA4XX;
3810 addrlist->more_errno |=
3811 ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3818 /* For non-PRDR SMTP, we now read a single response that applies to the
3819 whole message. If it is OK, then all the addresses have been delivered. */
3823 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3825 if (!sx.ok && errno == 0 && sx.buffer[0] == '4')
3827 errno = ERRNO_DATA4XX;
3828 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3832 /* For LMTP, we get back a response for every RCPT command that we sent;
3833 some may be accepted and some rejected. For those that get a response, their
3834 status is fixed; any that are accepted have been handed over, even if later
3835 responses crash - at least, that's how I read RFC 2033.
3837 If all went well, mark the recipient addresses as completed, record which
3838 host/IPaddress they were delivered to, and cut out RSET when sending another
3839 message down the same channel. Write the completed addresses to the journal
3840 now so that they are recorded in case there is a crash of hardware or
3841 software before the spool gets updated. Also record the final SMTP
3842 confirmation if needed (for SMTP only). */
3847 struct timeval delivery_time;
3849 uschar * conf = NULL;
3851 timesince(&delivery_time, &start_delivery_time);
3852 sx.send_rset = FALSE;
3853 pipelining_active = FALSE;
3855 /* Set up confirmation if needed - applies only to SMTP */
3858 #ifdef DISABLE_EVENT
3859 LOGGING(smtp_confirmation) &&
3864 const uschar *s = string_printing(sx.buffer);
3865 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3866 conf = (s == sx.buffer)? US string_copy(s) : US s;
3869 /* Process all transported addresses - for LMTP or PRDR, read a status for
3872 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3874 if (addr->transport_return != PENDING_OK) continue;
3876 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3877 remaining addresses. Otherwise, it's a return code for just the one
3878 address. For temporary errors, add a retry item for the address so that
3879 it doesn't get tried again too soon. */
3881 #ifndef DISABLE_PRDR
3882 if (sx.lmtp || sx.prdr_active)
3887 if (!smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3890 if (errno != 0 || sx.buffer[0] == 0) goto RESPONSE_FAILED;
3891 addr->message = string_sprintf(
3892 #ifndef DISABLE_PRDR
3893 "%s error after %s: %s", sx.prdr_active ? "PRDR":"LMTP",
3895 "LMTP error after %s: %s",
3897 data_command, string_printing(sx.buffer));
3898 setflag(addr, af_pass_message); /* Allow message to go to user */
3899 if (sx.buffer[0] == '5')
3900 addr->transport_return = FAIL;
3903 errno = ERRNO_DATA4XX;
3904 addr->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3905 addr->transport_return = DEFER;
3906 #ifndef DISABLE_PRDR
3907 if (!sx.prdr_active)
3909 retry_add_item(addr, addr->address_retry_key, 0);
3913 sx.completed_addr = TRUE; /* NOW we can set this flag */
3914 if (LOGGING(smtp_confirmation))
3916 const uschar *s = string_printing(sx.buffer);
3917 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3918 conf = (s == sx.buffer) ? US string_copy(s) : US s;
3922 /* SMTP, or success return from LMTP for this address. Pass back the
3923 actual host that was used. */
3925 addr->transport_return = OK;
3926 addr->more_errno = delivery_time.tv_sec;
3927 addr->delivery_usec = delivery_time.tv_usec;
3928 addr->host_used = host;
3929 addr->special_action = flag;
3930 addr->message = conf;
3932 if (tcp_out_fastopen)
3934 setflag(addr, af_tcp_fastopen_conn);
3935 if (tcp_out_fastopen >= TFO_USED_NODATA) setflag(addr, af_tcp_fastopen);
3936 if (tcp_out_fastopen >= TFO_USED_DATA) setflag(addr, af_tcp_fastopen_data);
3938 if (sx.pipelining_used) setflag(addr, af_pipelining);
3939 #ifdef EXPERIMENTAL_PIPE_CONNECT
3940 if (sx.early_pipe_active) setflag(addr, af_early_pipe);
3942 #ifndef DISABLE_PRDR
3943 if (sx.prdr_active) setflag(addr, af_prdr_used);
3945 if (sx.peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3948 #ifndef DISABLE_PRDR
3949 if (!sx.prdr_active)
3952 /* Update the journal. For homonymic addresses, use the base address plus
3953 the transport name. See lots of comments in deliver.c about the reasons
3954 for the complications when homonyms are involved. Just carry on after
3955 write error, as it may prove possible to update the spool file later. */
3957 if (testflag(addr, af_homonym))
3958 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3960 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3962 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx.buffer);
3963 len = Ustrlen(CS sx.buffer);
3964 if (write(journal_fd, sx.buffer, len) != len)
3965 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3966 "%s: %s", sx.buffer, strerror(errno));
3970 #ifndef DISABLE_PRDR
3973 const uschar * overall_message;
3975 /* PRDR - get the final, overall response. For any non-success
3976 upgrade all the address statuses. */
3978 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3982 if(errno == 0 && sx.buffer[0] == '4')
3984 errno = ERRNO_DATA4XX;
3985 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3987 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3988 if (sx.buffer[0] == '5' || addr->transport_return == OK)
3989 addr->transport_return = PENDING_OK; /* allow set_errno action */
3990 goto RESPONSE_FAILED;
3993 /* Append the overall response to the individual PRDR response for logging
3994 and update the journal, or setup retry. */
3996 overall_message = string_printing(sx.buffer);
3997 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3998 if (addr->transport_return == OK)
3999 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
4001 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
4002 if (addr->transport_return == OK)
4004 if (testflag(addr, af_homonym))
4005 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
4007 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
4009 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx.buffer);
4010 len = Ustrlen(CS sx.buffer);
4011 if (write(journal_fd, sx.buffer, len) != len)
4012 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
4013 "%s: %s", sx.buffer, strerror(errno));
4015 else if (addr->transport_return == DEFER)
4016 retry_add_item(addr, addr->address_retry_key, -2);
4020 /* Ensure the journal file is pushed out to disk. */
4022 if (EXIMfsync(journal_fd) < 0)
4023 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
4029 /* Handle general (not specific to one address) failures here. The value of ok
4030 is used to skip over this code on the falling through case. A timeout causes a
4031 deferral. Other errors may defer or fail according to the response code, and
4032 may set up a special errno value, e.g. after connection chopped, which is
4033 assumed if errno == 0 and there is no text in the buffer. If control reaches
4034 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
4035 the problem is not related to this specific message. */
4040 uschar * set_message;
4046 sx.send_quit = check_response(host, &save_errno, addrlist->more_errno,
4047 sx.buffer, &code, &message, &pass_message);
4055 message = string_sprintf("send() to %s [%s] failed: %s",
4056 host->name, host->address, message ? message : US strerror(save_errno));
4057 sx.send_quit = FALSE;
4065 sx.ok = FALSE; /* For when reached by GOTO */
4066 set_message = message;
4068 /* We want to handle timeouts after MAIL or "." and loss of connection after
4069 "." specially. They can indicate a problem with the sender address or with
4070 the contents of the message rather than a real error on the connection. These
4071 cases are treated in the same way as a 4xx response. This next bit of code
4072 does the classification. */
4079 message_error = TRUE;
4083 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
4084 Ustrncmp(smtp_command,"end ",4) == 0;
4087 case ERRNO_SMTPCLOSED:
4088 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
4092 message_error = FALSE;
4096 /* Handle the cases that are treated as message errors. These are:
4098 (a) negative response or timeout after MAIL
4099 (b) negative response after DATA
4100 (c) negative response or timeout or dropped connection after "."
4101 (d) utf8 support required and not offered
4103 It won't be a negative response or timeout after RCPT, as that is dealt
4104 with separately above. The action in all cases is to set an appropriate
4105 error code for all the addresses, but to leave yield set to OK because the
4106 host itself has not failed. Of course, it might in practice have failed
4107 when we've had a timeout, but if so, we'll discover that at the next
4108 delivery attempt. For a temporary error, set the message_defer flag, and
4109 write to the logs for information if this is not the last host. The error
4110 for the last host will be logged as part of the address's log line. */
4114 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
4116 /* If there's an errno, the message contains just the identity of
4121 else /* Anything other than 5 is treated as temporary */
4125 message = US string_sprintf("%s: %s", message, strerror(save_errno));
4127 write_logs(host, message, sx.first_addr ? sx.first_addr->basic_errno : 0);
4129 *message_defer = TRUE;
4133 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4134 ".", or some other transportation error. We defer all addresses and yield
4135 DEFER, except for the case of failed add_headers expansion, or a transport
4136 filter failure, when the yield should be ERROR, to stop it trying other
4141 #ifdef EXPERIMENTAL_PIPE_CONNECT
4142 /* If we were early-pipelinng and the actual EHLO response did not match
4143 the cached value we assumed, we could have detected it and passed a
4144 custom errno through to here. It would be nice to RSET and retry right
4145 away, but to reliably do that we eould need an extra synch point before
4146 we committed to data and that would discard half the gained roundrips.
4147 Or we could summarily drop the TCP connection. but that is also ugly.
4148 Instead, we ignore the possibility (having freshened the cache) and rely
4149 on the server telling us with a nonmessage error if we have tried to
4150 do something it no longer supports. */
4153 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
4154 save_errno == ERRNO_FILTER_FAIL) ? ERROR : DEFER;
4158 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
4159 #ifdef EXPERIMENTAL_DSN_INFO
4160 , sx.smtp_greeting, sx.helo_response
4166 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4167 SMTP session tidily. However, if there were too many addresses to send in one
4168 message (indicated by first_addr being non-NULL) we want to carry on with the
4169 rest of them. Also, it is desirable to send more than one message down the SMTP
4170 connection if there are several waiting, provided we haven't already sent so
4171 many as to hit the configured limit. The function transport_check_waiting looks
4172 for a waiting message and returns its id. Then transport_pass_socket tries to
4173 set up a continued delivery by passing the socket on to another process. The
4174 variable send_rset is FALSE if a message has just been successfully transferred.
4176 If we are already sending down a continued channel, there may be further
4177 addresses not yet delivered that are aimed at the same host, but which have not
4178 been passed in this run of the transport. In this case, continue_more will be
4179 true, and all we should do is send RSET if necessary, and return, leaving the
4182 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4183 do not want to continue with other messages down the same channel, because that
4184 can lead to looping between two or more messages, all with the same,
4185 temporarily failing address(es). [The retry information isn't updated yet, so
4186 new processes keep on trying.] We probably also don't want to try more of this
4187 message's addresses either.
4189 If we have started a TLS session, we have to end it before passing the
4190 connection to a new process. However, not all servers can handle this (Exim
4191 can), so we do not pass such a connection on if the host matches
4192 hosts_nopass_tls. */
4195 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4196 "yield=%d first_address is %sNULL\n", sx.ok, sx.send_quit,
4197 sx.send_rset, f.continue_more, yield, sx.first_addr ? "not " : "");
4199 if (sx.completed_addr && sx.ok && sx.send_quit)
4202 smtp_compare_t t_compare;
4204 t_compare.tblock = tblock;
4205 t_compare.current_sender_address = sender_address;
4207 if ( sx.first_addr != NULL
4211 ( tls_out.active.sock < 0 && !continue_proxy_cipher
4212 || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
4216 transport_check_waiting(tblock->name, host->name,
4217 tblock->connection_max_messages, new_message_id, &more,
4218 (oicf)smtp_are_same_identities, (void*)&t_compare)
4225 if (! (sx.ok = smtp_write_command(&sx, SCMD_FLUSH, "RSET\r\n") >= 0))
4227 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
4228 host->address, strerror(errno));
4229 sx.send_quit = FALSE;
4231 else if (! (sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4232 '2', ob->command_timeout)))
4235 sx.send_quit = check_response(host, &errno, 0, sx.buffer, &code, &msg,
4239 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
4240 host->name, host->address, msg);
4244 /* Either RSET was not needed, or it succeeded */
4251 int socket_fd = sx.cctx.sock;
4254 if (sx.first_addr != NULL) /* More addresses still to be sent */
4255 { /* in this run of the transport */
4256 continue_sequence++; /* Causes * in logging */
4260 /* Unless caller said it already has more messages listed for this host,
4261 pass the connection on to a new Exim process (below, the call to
4262 transport_pass_socket). If the caller has more ready, just return with
4263 the connection still open. */
4266 if (tls_out.active.sock >= 0)
4267 if ( f.continue_more
4268 || verify_check_given_host(CUSS &ob->hosts_noproxy_tls, host) == OK)
4270 /* Before passing the socket on, or returning to caller with it still
4271 open, we must shut down TLS. Not all MTAs allow for the continuation
4272 of the SMTP session when TLS is shut down. We test for this by sending
4273 a new EHLO. If we don't get a good response, we don't attempt to pass
4276 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4277 sx.cctx.tls_ctx = NULL;
4278 smtp_peer_options = smtp_peer_options_wrap;
4280 && smtp_write_command(&sx, SCMD_FLUSH, "EHLO %s\r\n", sx.helo_data)
4282 && smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4283 '2', ob->command_timeout);
4285 if (sx.ok && f.continue_more)
4286 return yield; /* More addresses for another run */
4290 /* Set up a pipe for proxying TLS for the new transport process */
4292 smtp_peer_options |= OPTION_TLS;
4293 if (sx.ok = (socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
4296 set_errno(sx.first_addr, errno, US"internal allocation problem",
4298 # ifdef EXPERIMENTAL_DSN_INFO
4299 , sx.smtp_greeting, sx.helo_response
4305 if (f.continue_more)
4306 return yield; /* More addresses for another run */
4308 /* If the socket is successfully passed, we mustn't send QUIT (or
4309 indeed anything!) from here. */
4311 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4312 propagate it from the initial
4314 if (sx.ok && transport_pass_socket(tblock->name, host->name,
4315 host->address, new_message_id, socket_fd))
4317 sx.send_quit = FALSE;
4319 /* We have passed the client socket to a fresh transport process.
4320 If TLS is still active, we need to proxy it for the transport we
4321 just passed the baton to. Fork a child to to do it, and return to
4322 get logging done asap. Which way to place the work makes assumptions
4323 about post-fork prioritisation which may not hold on all platforms. */
4325 if (tls_out.active.sock >= 0)
4328 if (pid == 0) /* child; fork again to disconnect totally */
4330 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
4331 /* does not return */
4332 smtp_proxy_tls(sx.cctx.tls_ctx, sx.buffer, sizeof(sx.buffer), pfd,
4333 ob->command_timeout);
4336 if (pid > 0) /* parent */
4338 DEBUG(D_transport) debug_printf("proxy-proc inter-pid %d\n", pid);
4340 /* tidy the inter-proc to disconn the proxy proc */
4341 waitpid(pid, NULL, 0);
4342 tls_close(sx.cctx.tls_ctx, TLS_NO_SHUTDOWN);
4343 sx.cctx.tls_ctx = NULL;
4344 (void)close(sx.cctx.sock);
4346 continue_transport = NULL;
4347 continue_hostname = NULL;
4350 log_write(0, LOG_PANIC_DIE, "fork failed");
4356 /* If RSET failed and there are addresses left, they get deferred. */
4358 set_errno(sx.first_addr, errno, msg, DEFER, FALSE, host
4359 #ifdef EXPERIMENTAL_DSN_INFO
4360 , sx.smtp_greeting, sx.helo_response
4366 /* End off tidily with QUIT unless the connection has died or the socket has
4367 been passed to another process. There has been discussion on the net about what
4368 to do after sending QUIT. The wording of the RFC suggests that it is necessary
4369 to wait for a response, but on the other hand, there isn't anything one can do
4370 with an error response, other than log it. Exim used to do that. However,
4371 further discussion suggested that it is positively advantageous not to wait for
4372 the response, but to close the session immediately. This is supposed to move
4373 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
4374 load from the server. (Hosts that are both servers and clients may not see much
4375 difference, of course.) Further discussion indicated that this was safe to do
4376 on Unix systems which have decent implementations of TCP/IP that leave the
4377 connection around for a while (TIME_WAIT) after the application has gone away.
4378 This enables the response sent by the server to be properly ACKed rather than
4379 timed out, as can happen on broken TCP/IP implementations on other OS.
4381 This change is being made on 31-Jul-98. After over a year of trouble-free
4382 operation, the old commented-out code was removed on 17-Sep-99. */
4385 if (sx.send_quit) (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4390 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4391 sx.cctx.tls_ctx = NULL;
4394 /* Close the socket, and return the appropriate value, first setting
4395 works because the NULL setting is passed back to the calling process, and
4396 remote_max_parallel is forced to 1 when delivering over an existing connection,
4398 If all went well and continue_more is set, we shouldn't actually get here if
4399 there are further addresses, as the return above will be taken. However,
4400 writing RSET might have failed, or there may be other addresses whose hosts are
4401 specified in the transports, and therefore not visible at top level, in which
4402 case continue_more won't get set. */
4404 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
4407 shutdown(sx.cctx.sock, SHUT_WR);
4408 millisleep(f.running_in_test_harness ? 200 : 20);
4409 if (fcntl(sx.cctx.sock, F_SETFL, O_NONBLOCK) == 0)
4410 for (rc = 16; read(sx.cctx.sock, sx.inbuffer, sizeof(sx.inbuffer)) > 0 && rc > 0;)
4411 rc--; /* drain socket */
4413 (void)close(sx.cctx.sock);
4415 #ifndef DISABLE_EVENT
4416 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
4419 continue_transport = NULL;
4420 continue_hostname = NULL;
4427 /*************************************************
4428 * Closedown entry point *
4429 *************************************************/
4431 /* This function is called when exim is passed an open smtp channel
4432 from another incarnation, but the message which it has been asked
4433 to deliver no longer exists. The channel is on stdin.
4435 We might do fancy things like looking for another message to send down
4436 the channel, but if the one we sought has gone, it has probably been
4437 delivered by some other process that itself will seek further messages,
4438 so just close down our connection.
4440 Argument: pointer to the transport instance block
4445 smtp_transport_closedown(transport_instance *tblock)
4447 smtp_transport_options_block * ob = SOB tblock->options_block;
4448 client_conn_ctx cctx;
4451 uschar inbuffer[4096];
4452 uschar outbuffer[16];
4454 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4455 cctx.sock = fileno(stdin);
4456 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
4458 sx.inblock.cctx = &cctx;
4459 sx.inblock.buffer = inbuffer;
4460 sx.inblock.buffersize = sizeof(inbuffer);
4461 sx.inblock.ptr = inbuffer;
4462 sx.inblock.ptrend = inbuffer;
4464 sx.outblock.cctx = &cctx;
4465 sx.outblock.buffersize = sizeof(outbuffer);
4466 sx.outblock.buffer = outbuffer;
4467 sx.outblock.ptr = outbuffer;
4468 sx.outblock.cmd_count = 0;
4469 sx.outblock.authenticating = FALSE;
4471 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4472 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
4473 (void)close(cctx.sock);
4478 /*************************************************
4479 * Prepare addresses for delivery *
4480 *************************************************/
4482 /* This function is called to flush out error settings from previous delivery
4483 attempts to other hosts. It also records whether we got here via an MX record
4484 or not in the more_errno field of the address. We are interested only in
4485 addresses that are still marked DEFER - others may have got delivered to a
4486 previously considered IP address. Set their status to PENDING_DEFER to indicate
4487 which ones are relevant this time.
4490 addrlist the list of addresses
4491 host the host we are delivering to
4493 Returns: the first address for this delivery
4496 static address_item *
4497 prepare_addresses(address_item *addrlist, host_item *host)
4499 address_item *first_addr = NULL;
4501 for (addr = addrlist; addr; addr = addr->next)
4502 if (addr->transport_return == DEFER)
4504 if (!first_addr) first_addr = addr;
4505 addr->transport_return = PENDING_DEFER;
4506 addr->basic_errno = 0;
4507 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
4508 addr->message = NULL;
4510 addr->cipher = NULL;
4511 addr->ourcert = NULL;
4512 addr->peercert = NULL;
4513 addr->peerdn = NULL;
4514 addr->ocsp = OCSP_NOT_REQ;
4516 #ifdef EXPERIMENTAL_DSN_INFO
4517 addr->smtp_greeting = NULL;
4518 addr->helo_response = NULL;
4526 /*************************************************
4527 * Main entry point *
4528 *************************************************/
4530 /* See local README for interface details. As this is a remote transport, it is
4531 given a chain of addresses to be delivered in one connection, if possible. It
4532 always returns TRUE, indicating that each address has its own independent
4533 status set, except if there is a setting up problem, in which case it returns
4537 smtp_transport_entry(
4538 transport_instance *tblock, /* data for this instantiation */
4539 address_item *addrlist) /* addresses we are working on */
4543 int hosts_defer = 0;
4545 int hosts_looked_up = 0;
4546 int hosts_retry = 0;
4547 int hosts_serial = 0;
4548 int hosts_total = 0;
4549 int total_hosts_tried = 0;
4551 BOOL expired = TRUE;
4552 uschar *expanded_hosts = NULL;
4554 uschar *tid = string_sprintf("%s transport", tblock->name);
4555 smtp_transport_options_block *ob = SOB tblock->options_block;
4556 host_item *hostlist = addrlist->host_list;
4561 debug_printf("%s transport entered\n", tblock->name);
4562 for (addr = addrlist; addr; addr = addr->next)
4563 debug_printf(" %s\n", addr->address);
4566 debug_printf("hostlist:\n");
4567 for (host = hostlist; host; host = host->next)
4568 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
4570 if (continue_hostname)
4571 debug_printf("already connected to %s [%s] (on fd %d)\n",
4572 continue_hostname, continue_host_address,
4573 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
4576 /* Set the flag requesting that these hosts be added to the waiting
4577 database if the delivery fails temporarily or if we are running with
4578 queue_smtp or a 2-stage queue run. This gets unset for certain
4579 kinds of error, typically those that are specific to the message. */
4581 update_waiting = TRUE;
4583 /* If a host list is not defined for the addresses - they must all have the
4584 same one in order to be passed to a single transport - or if the transport has
4585 a host list with hosts_override set, use the host list supplied with the
4586 transport. It is an error for this not to exist. */
4588 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
4589 if (tls_requiretls & REQUIRETLS_MSG)
4590 ob->tls_tempfail_tryclear = FALSE; /*XXX surely we should have a local for this
4591 rather than modifying the transport? */
4594 if (!hostlist || (ob->hosts_override && ob->hosts))
4598 addrlist->message = string_sprintf("%s transport called with no hosts set",
4600 addrlist->transport_return = PANIC;
4601 return FALSE; /* Only top address has status */
4604 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4607 /* If the transport's host list contains no '$' characters, and we are not
4608 randomizing, it is fixed and therefore a chain of hosts can be built once
4609 and for all, and remembered for subsequent use by other calls to this
4610 transport. If, on the other hand, the host list does contain '$', or we are
4611 randomizing its order, we have to rebuild it each time. In the fixed case,
4612 as the hosts string will never be used again, it doesn't matter that we
4613 replace all the : characters with zeros. */
4617 uschar *s = ob->hosts;
4619 if (Ustrchr(s, '$') != NULL)
4621 if (!(expanded_hosts = expand_string(s)))
4623 addrlist->message = string_sprintf("failed to expand list of hosts "
4624 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4625 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4626 return FALSE; /* Only top address has status */
4628 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4629 "\"%s\"\n", s, expanded_hosts);
4633 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4635 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4637 /* Check that the expansion yielded something useful. */
4641 string_sprintf("%s transport has empty hosts setting", tblock->name);
4642 addrlist->transport_return = PANIC;
4643 return FALSE; /* Only top address has status */
4646 /* If there was no expansion of hosts, save the host list for
4649 if (!expanded_hosts) ob->hostlist = hostlist;
4652 /* This is not the first time this transport has been run in this delivery;
4653 the host list was built previously. */
4656 hostlist = ob->hostlist;
4659 /* The host list was supplied with the address. If hosts_randomize is set, we
4660 must sort it into a random order if it did not come from MX records and has not
4661 already been randomized (but don't bother if continuing down an existing
4664 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4666 host_item *newlist = NULL;
4669 host_item *h = hostlist;
4670 hostlist = hostlist->next;
4672 h->sort_key = random_number(100);
4679 else if (h->sort_key < newlist->sort_key)
4686 host_item *hh = newlist;
4689 if (h->sort_key < hh->next->sort_key) break;
4697 hostlist = addrlist->host_list = newlist;
4700 /* Sort out the default port. */
4702 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4704 /* For each host-plus-IP-address on the list:
4706 . If this is a continued delivery and the host isn't the one with the
4707 current connection, skip.
4709 . If the status is unusable (i.e. previously failed or retry checked), skip.
4711 . If no IP address set, get the address, either by turning the name into
4712 an address, calling gethostbyname if gethostbyname is on, or by calling
4713 the DNS. The DNS may yield multiple addresses, in which case insert the
4714 extra ones into the list.
4716 . Get the retry data if not previously obtained for this address and set the
4717 field which remembers the state of this address. Skip if the retry time is
4718 not reached. If not, remember whether retry data was found. The retry string
4719 contains both the name and the IP address.
4721 . Scan the list of addresses and mark those whose status is DEFER as
4722 PENDING_DEFER. These are the only ones that will be processed in this cycle
4725 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4726 Some addresses may be successfully delivered, others may fail, and yet
4727 others may get temporary errors and so get marked DEFER.
4729 . The return from the delivery attempt is OK if a connection was made and a
4730 valid SMTP dialogue was completed. Otherwise it is DEFER.
4732 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4734 . If fail to connect, or other defer state, add a retry item.
4736 . If there are any addresses whose status is still DEFER, carry on to the
4737 next host/IPaddress, unless we have tried the number of hosts given
4738 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4739 there is some fancy logic for hosts_max_try that means its limit can be
4740 overstepped in some circumstances.
4742 If we get to the end of the list, all hosts have deferred at least one address,
4743 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4744 delivery attempt to those hosts whose last try was before the arrival time of
4745 the current message. To cope with this, we have to go round the loop a second
4746 time. After that, set the status and error data for any addresses that haven't
4747 had it set already. */
4749 for (cutoff_retry = 0;
4750 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4753 host_item *nexthost = NULL;
4754 int unexpired_hosts_tried = 0;
4755 BOOL continue_host_tried = FALSE;
4757 retry_non_continued:
4758 for (host = hostlist;
4760 && unexpired_hosts_tried < ob->hosts_max_try
4761 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4767 BOOL host_is_expired = FALSE;
4768 BOOL message_defer = FALSE;
4769 BOOL some_deferred = FALSE;
4770 address_item *first_addr = NULL;
4771 uschar *interface = NULL;
4772 uschar *retry_host_key = NULL;
4773 uschar *retry_message_key = NULL;
4774 uschar *serialize_key = NULL;
4776 /* Default next host is next host. :-) But this can vary if the
4777 hosts_max_try limit is hit (see below). It may also be reset if a host
4778 address is looked up here (in case the host was multihomed). */
4780 nexthost = host->next;
4782 /* If the address hasn't yet been obtained from the host name, look it up
4783 now, unless the host is already marked as unusable. If it is marked as
4784 unusable, it means that the router was unable to find its IP address (in
4785 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4786 the lookup failed last time. We don't get this far if *all* MX records
4787 point to non-existent hosts; that is treated as a hard error.
4789 We can just skip this host entirely. When the hosts came from the router,
4790 the address will timeout based on the other host(s); when the address is
4791 looked up below, there is an explicit retry record added.
4793 Note that we mustn't skip unusable hosts if the address is not unset; they
4794 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4798 int new_port, flags;
4801 if (host->status >= hstatus_unusable)
4803 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4808 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4810 /* The host name is permitted to have an attached port. Find it, and
4811 strip it from the name. Just remember it for now. */
4813 new_port = host_item_get_port(host);
4815 /* Count hosts looked up */
4819 /* Find by name if so configured, or if it's an IP address. We don't
4820 just copy the IP address, because we need the test-for-local to happen. */
4822 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4823 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4824 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4826 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4827 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4829 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4830 &ob->dnssec, /* domains for request/require */
4833 /* Update the host (and any additional blocks, resulting from
4834 multihoming) with a host-specific port, if any. */
4836 for (hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4838 /* Failure to find the host at this time (usually DNS temporary failure)
4839 is really a kind of routing failure rather than a transport failure.
4840 Therefore we add a retry item of the routing kind, not to stop us trying
4841 to look this name up here again, but to ensure the address gets timed
4842 out if the failures go on long enough. A complete failure at this point
4843 commonly points to a configuration error, but the best action is still
4844 to carry on for the next host. */
4846 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4848 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4850 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4851 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4852 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4853 host->status = hstatus_unusable;
4855 for (addr = addrlist; addr; addr = addr->next)
4857 if (addr->transport_return != DEFER) continue;
4858 addr->basic_errno = ERRNO_UNKNOWNHOST;
4859 addr->message = string_sprintf(
4860 rc == HOST_FIND_SECURITY
4861 ? "lookup of IP address for %s was insecure"
4862 : "failed to lookup IP address for %s",
4868 /* If the host is actually the local host, we may have a problem, or
4869 there may be some cunning configuration going on. In the problem case,
4870 log things and give up. The default transport status is already DEFER. */
4872 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4874 for (addr = addrlist; addr; addr = addr->next)
4876 addr->basic_errno = 0;
4877 addr->message = string_sprintf("%s transport found host %s to be "
4878 "local", tblock->name, host->name);
4882 } /* End of block for IP address lookup */
4884 /* If this is a continued delivery, we are interested only in the host
4885 which matches the name of the existing open channel. The check is put
4886 here after the local host lookup, in case the name gets expanded as a
4887 result of the lookup. Set expired FALSE, to save the outer loop executing
4890 if (continue_hostname)
4891 if ( Ustrcmp(continue_hostname, host->name) != 0
4892 || Ustrcmp(continue_host_address, host->address) != 0
4896 continue; /* With next host */
4899 continue_host_tried = TRUE;
4901 /* Reset the default next host in case a multihomed host whose addresses
4902 are not looked up till just above added to the host list. */
4904 nexthost = host->next;
4906 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4907 domain is in queue_smtp_domains, we don't actually want to attempt any
4908 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4909 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4910 were not in it. We don't want to hold up all SMTP deliveries! Except when
4911 doing a two-stage queue run, don't do this if forcing. */
4913 if ((!f.deliver_force || f.queue_2stage) && (f.queue_smtp ||
4914 match_isinlist(addrlist->domain,
4915 (const uschar **)&queue_smtp_domains, 0,
4916 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
4919 for (addr = addrlist; addr; addr = addr->next)
4920 if (addr->transport_return == DEFER)
4921 addr->message = US"domain matches queue_smtp_domains, or -odqs set";
4922 continue; /* With next host */
4925 /* Count hosts being considered - purely for an intelligent comment
4926 if none are usable. */
4930 /* Set $host and $host address now in case they are needed for the
4931 interface expansion or the serialize_hosts check; they remain set if an
4932 actual delivery happens. */
4934 deliver_host = host->name;
4935 deliver_host_address = host->address;
4936 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
4937 : host->dnssec == DS_NO ? US"no"
4940 /* Set up a string for adding to the retry key if the port number is not
4941 the standard SMTP port. A host may have its own port setting that overrides
4944 pistring = string_sprintf(":%d", host->port == PORT_NONE
4945 ? defport : host->port);
4946 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
4948 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4949 string is set, even if constant (as different transports can have different
4950 constant settings), we must add it to the key that is used for retries,
4951 because connections to the same host from a different interface should be
4952 treated separately. */
4954 host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
4955 if ((rs = ob->interface) && *rs)
4957 if (!smtp_get_interface(rs, host_af, addrlist, &interface, tid))
4959 pistring = string_sprintf("%s/%s", pistring, interface);
4962 /* The first time round the outer loop, check the status of the host by
4963 inspecting the retry data. The second time round, we are interested only
4964 in expired hosts that haven't been tried since this message arrived. */
4966 if (cutoff_retry == 0)
4969 /* Ensure the status of the address is set by checking retry data if
4970 necessary. There may be host-specific retry data (applicable to all
4971 messages) and also data for retries of a specific message at this host.
4972 If either of these retry records are actually read, the keys used are
4973 returned to save recomputing them later. */
4975 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4976 US"retry_include_ip_address", ob->retry_include_ip_address,
4977 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4978 continue; /* with next host */
4980 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
4981 incl_ip, &retry_host_key, &retry_message_key);
4983 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
4984 host->address ? host->address : US"", pistring,
4985 host->status == hstatus_usable ? "usable"
4986 : host->status == hstatus_unusable ? "unusable"
4987 : host->status == hstatus_unusable_expired ? "unusable (expired)" : "?");
4989 /* Skip this address if not usable at this time, noting if it wasn't
4990 actually expired, both locally and in the address. */
4992 switch (host->status)
4994 case hstatus_unusable:
4996 setflag(addrlist, af_retry_skipped);
4999 case hstatus_unusable_expired:
5002 case hwhy_retry: hosts_retry++; break;
5003 case hwhy_failed: hosts_fail++; break;
5005 case hwhy_deferred: hosts_defer++; break;
5008 /* If there was a retry message key, implying that previously there
5009 was a message-specific defer, we don't want to update the list of
5010 messages waiting for these hosts. */
5012 if (retry_message_key) update_waiting = FALSE;
5013 continue; /* With the next host or IP address */
5017 /* Second time round the loop: if the address is set but expired, and
5018 the message is newer than the last try, let it through. */
5023 || host->status != hstatus_unusable_expired
5024 || host->last_try > received_time.tv_sec)
5026 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
5027 host->name, host->address, pistring);
5028 host_is_expired = TRUE;
5031 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
5032 it remains TRUE only if all hosts are expired and none are actually tried.
5037 /* If this host is listed as one to which access must be serialized,
5038 see if another Exim process has a connection to it, and if so, skip
5039 this host. If not, update the database to record our connection to it
5040 and remember this for later deletion. Do not do any of this if we are
5041 sending the message down a pre-existing connection. */
5043 if ( !continue_hostname
5044 && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
5046 serialize_key = string_sprintf("host-serialize-%s", host->name);
5047 if (!enq_start(serialize_key, 1))
5050 debug_printf("skipping host %s because another Exim process "
5051 "is connected to it\n", host->name);
5057 /* OK, we have an IP address that is not waiting for its retry time to
5058 arrive (it might be expired) OR (second time round the loop) we have an
5059 expired host that hasn't been tried since the message arrived. Have a go
5060 at delivering the message to it. First prepare the addresses by flushing
5061 out the result of previous attempts, and finding the first address that
5062 is still to be delivered. */
5064 first_addr = prepare_addresses(addrlist, host);
5066 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5067 message_id, host->name, host->address, addrlist->address,
5068 addrlist->next ? ", ..." : "");
5070 set_process_info("delivering %s to %s [%s]%s (%s%s)",
5071 message_id, host->name, host->address, pistring, addrlist->address,
5072 addrlist->next ? ", ..." : "");
5074 /* This is not for real; don't do the delivery. If there are
5075 any remaining hosts, list them. */
5080 set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
5081 for (addr = addrlist; addr; addr = addr->next)
5083 addr->host_used = host;
5084 addr->special_action = '*';
5085 addr->message = US"delivery bypassed by -N option";
5089 debug_printf("*** delivery by %s transport bypassed by -N option\n"
5090 "*** host and remaining hosts:\n", tblock->name);
5091 for (host2 = host; host2; host2 = host2->next)
5092 debug_printf(" %s [%s]\n", host2->name,
5093 host2->address ? host2->address : US"unset");
5098 /* This is for real. If the host is expired, we don't count it for
5099 hosts_max_retry. This ensures that all hosts must expire before an address
5100 is timed out, unless hosts_max_try_hardlimit (which protects against
5101 lunatic DNS configurations) is reached.
5103 If the host is not expired and we are about to hit the hosts_max_retry
5104 limit, check to see if there is a subsequent hosts with a different MX
5105 value. If so, make that the next host, and don't count this one. This is a
5106 heuristic to make sure that different MXs do get tried. With a normal kind
5107 of retry rule, they would get tried anyway when the earlier hosts were
5108 delayed, but if the domain has a "retry every time" type of rule - as is
5109 often used for the the very large ISPs, that won't happen. */
5114 /* Make a copy of the host if it is local to this invocation
5115 of the transport. */
5119 thost = store_get(sizeof(host_item));
5121 thost->name = string_copy(host->name);
5122 thost->address = string_copy(host->address);
5127 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
5131 debug_printf("hosts_max_try limit reached with this host\n");
5132 for (h = host; h; h = h->next) if (h->mx != host->mx)
5135 unexpired_hosts_tried--;
5136 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
5137 "and will be tried\n");
5142 /* Attempt the delivery. */
5144 total_hosts_tried++;
5145 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5146 &message_defer, FALSE);
5149 OK => connection made, each address contains its result;
5150 message_defer is set for message-specific defers (when all
5151 recipients are marked defer)
5152 DEFER => there was a non-message-specific delivery problem;
5153 ERROR => there was a problem setting up the arguments for a filter,
5154 or there was a problem with expanding added headers
5157 /* If the result is not OK, there was a non-message-specific problem.
5158 If the result is DEFER, we need to write to the logs saying what happened
5159 for this particular host, except in the case of authentication and TLS
5160 failures, where the log has already been written. If all hosts defer a
5161 general message is written at the end. */
5163 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
5164 && first_addr->basic_errno != ERRNO_TLSFAILURE)
5165 write_logs(host, first_addr->message, first_addr->basic_errno);
5167 #ifndef DISABLE_EVENT
5169 deferred_event_raise(first_addr, host);
5172 /* If STARTTLS was accepted, but there was a failure in setting up the
5173 TLS session (usually a certificate screwup), and the host is not in
5174 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5175 TLS forcibly turned off. We have to start from scratch with a new SMTP
5176 connection. That's why the retry is done from here, not from within
5177 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5178 session, so the in-clear transmission after those errors, if permitted,
5179 happens inside smtp_deliver().] */
5183 && first_addr->basic_errno == ERRNO_TLSFAILURE
5184 && ob->tls_tempfail_tryclear
5185 && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
5188 log_write(0, LOG_MAIN,
5189 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5190 first_addr->message, host->name, host->address);
5191 first_addr = prepare_addresses(addrlist, host);
5192 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5193 &message_defer, TRUE);
5194 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
5195 write_logs(host, first_addr->message, first_addr->basic_errno);
5196 # ifndef DISABLE_EVENT
5198 deferred_event_raise(first_addr, host);
5201 #endif /*SUPPORT_TLS*/
5204 /* Delivery attempt finished */
5206 rs = rc == OK ? US"OK"
5207 : rc == DEFER ? US"DEFER"
5208 : rc == ERROR ? US"ERROR"
5211 set_process_info("delivering %s: just tried %s [%s]%s for %s%s: result %s",
5212 message_id, host->name, host->address, pistring, addrlist->address,
5213 addrlist->next ? " (& others)" : "", rs);
5215 /* Release serialization if set up */
5217 if (serialize_key) enq_end(serialize_key);
5219 /* If the result is DEFER, or if a host retry record is known to exist, we
5220 need to add an item to the retry chain for updating the retry database
5221 at the end of delivery. We only need to add the item to the top address,
5222 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5223 for any other delivery attempts using the same address. (It is copied into
5224 the unusable tree at the outer level, so even if different address blocks
5225 contain the same address, it still won't get tried again.) */
5227 if (rc == DEFER || retry_host_key)
5229 int delete_flag = rc != DEFER ? rf_delete : 0;
5230 if (!retry_host_key)
5233 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5234 US"retry_include_ip_address", ob->retry_include_ip_address,
5235 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5236 incl_ip = TRUE; /* error; use most-specific retry record */
5238 retry_host_key = incl_ip
5239 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
5240 : string_sprintf("T:%S%s", host->name, pistring);
5243 /* If a delivery of another message over an existing SMTP connection
5244 yields DEFER, we do NOT set up retry data for the host. This covers the
5245 case when there are delays in routing the addresses in the second message
5246 that are so long that the server times out. This is alleviated by not
5247 routing addresses that previously had routing defers when handling an
5248 existing connection, but even so, this case may occur (e.g. if a
5249 previously happily routed address starts giving routing defers). If the
5250 host is genuinely down, another non-continued message delivery will
5251 notice it soon enough. */
5253 if (delete_flag != 0 || !continue_hostname)
5254 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
5256 /* We may have tried an expired host, if its retry time has come; ensure
5257 the status reflects the expiry for the benefit of any other addresses. */
5261 host->status = host_is_expired
5262 ? hstatus_unusable_expired : hstatus_unusable;
5263 host->why = hwhy_deferred;
5267 /* If message_defer is set (host was OK, but every recipient got deferred
5268 because of some message-specific problem), or if that had happened
5269 previously so that a message retry key exists, add an appropriate item
5270 to the retry chain. Note that if there was a message defer but now there is
5271 a host defer, the message defer record gets deleted. That seems perfectly
5272 reasonable. Also, stop the message from being remembered as waiting
5273 for specific hosts. */
5275 if (message_defer || retry_message_key)
5277 int delete_flag = message_defer ? 0 : rf_delete;
5278 if (!retry_message_key)
5281 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5282 US"retry_include_ip_address", ob->retry_include_ip_address,
5283 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5284 incl_ip = TRUE; /* error; use most-specific retry record */
5286 retry_message_key = incl_ip
5287 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
5289 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
5291 retry_add_item(addrlist, retry_message_key,
5292 rf_message | rf_host | delete_flag);
5293 update_waiting = FALSE;
5296 /* Any return other than DEFER (that is, OK or ERROR) means that the
5297 addresses have got their final statuses filled in for this host. In the OK
5298 case, see if any of them are deferred. */
5301 for (addr = addrlist; addr; addr = addr->next)
5302 if (addr->transport_return == DEFER)
5304 some_deferred = TRUE;
5308 /* If no addresses deferred or the result was ERROR, return. We do this for
5309 ERROR because a failing filter set-up or add_headers expansion is likely to
5310 fail for any host we try. */
5312 if (rc == ERROR || (rc == OK && !some_deferred))
5314 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5315 return TRUE; /* Each address has its status */
5318 /* If the result was DEFER or some individual addresses deferred, let
5319 the loop run to try other hosts with the deferred addresses, except for the
5320 case when we were trying to deliver down an existing channel and failed.
5321 Don't try any other hosts in this case. */
5323 if (continue_hostname) break;
5325 /* If the whole delivery, or some individual addresses, were deferred and
5326 there are more hosts that could be tried, do not count this host towards
5327 the hosts_max_try limit if the age of the message is greater than the
5328 maximum retry time for this host. This means we may try try all hosts,
5329 ignoring the limit, when messages have been around for some time. This is
5330 important because if we don't try all hosts, the address will never time
5331 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5333 if ((rc == DEFER || some_deferred) && nexthost)
5336 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
5338 if (retry && retry->rules)
5340 retry_rule *last_rule;
5341 for (last_rule = retry->rules;
5343 last_rule = last_rule->next);
5344 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
5346 else timedout = TRUE; /* No rule => timed out */
5350 unexpired_hosts_tried--;
5351 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
5352 "hosts_max_try (message older than host's retry time)\n");
5358 if (unexpired_hosts_tried >= ob->hosts_max_try)
5359 debug_printf("reached transport hosts_max_try limit %d\n",
5361 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5362 debug_printf("reached transport hosts_max_try_hardlimit limit %d\n",
5363 ob->hosts_max_try_hardlimit);
5366 if (f.running_in_test_harness) millisleep(500); /* let server debug out */
5367 } /* End of loop for trying multiple hosts. */
5369 /* If we failed to find a matching host in the list, for an already-open
5370 connection, just close it and start over with the list. This can happen
5371 for routing that changes from run to run, or big multi-IP sites with
5374 if (continue_hostname && !continue_host_tried)
5376 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
5378 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
5380 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5382 /*XXX doublecheck that! */
5384 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
5386 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
5387 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
5388 cutthrough.cctx.tls_ctx = NULL;
5389 cutthrough.is_tls = FALSE;
5393 (void) write(fd, US"QUIT\r\n", 6);
5396 cutthrough.cctx.sock = -1;
5397 continue_hostname = NULL;
5398 goto retry_non_continued;
5401 /* This is the end of the loop that repeats iff expired is TRUE and
5402 ob->delay_after_cutoff is FALSE. The second time round we will
5403 try those hosts that haven't been tried since the message arrived. */
5407 debug_printf("all IP addresses skipped or deferred at least one address\n");
5408 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
5409 debug_printf("retrying IP addresses not tried since message arrived\n");
5414 /* Get here if all IP addresses are skipped or defer at least one address. In
5415 MUA wrapper mode, this will happen only for connection or other non-message-
5416 specific failures. Force the delivery status for all addresses to FAIL. */
5420 for (addr = addrlist; addr; addr = addr->next)
5421 addr->transport_return = FAIL;
5425 /* In the normal, non-wrapper case, add a standard message to each deferred
5426 address if there hasn't been an error, that is, if it hasn't actually been
5427 tried this time. The variable "expired" will be FALSE if any deliveries were
5428 actually tried, or if there was at least one host that was not expired. That
5429 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5430 a delivery has been tried, an error code will be set, and the failing of the
5431 message is handled by the retry code later.
5433 If queue_smtp is set, or this transport was called to send a subsequent message
5434 down an existing TCP/IP connection, and something caused the host not to be
5435 found, we end up here, but can detect these cases and handle them specially. */
5437 for (addr = addrlist; addr; addr = addr->next)
5439 /* If host is not NULL, it means that we stopped processing the host list
5440 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5441 means we need to behave as if some hosts were skipped because their retry
5442 time had not come. Specifically, this prevents the address from timing out.
5443 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5444 hosts were tried. */
5447 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5450 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5451 "hosts were tried\n");
5456 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5457 setflag(addr, af_retry_skipped);
5460 if (f.queue_smtp) /* no deliveries attempted */
5462 addr->transport_return = DEFER;
5463 addr->basic_errno = 0;
5464 addr->message = US"SMTP delivery explicitly queued";
5467 else if ( addr->transport_return == DEFER
5468 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
5472 addr->basic_errno = ERRNO_HRETRY;
5473 if (continue_hostname)
5474 addr->message = US"no host found for existing SMTP connection";
5477 setflag(addr, af_pass_message); /* This is not a security risk */
5478 addr->message = string_sprintf(
5479 "all hosts%s have been failing for a long time %s",
5480 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
5481 ob->delay_after_cutoff
5482 ? US"(and retry time not reached)"
5483 : US"and were last tried after this message arrived");
5485 /* If we are already using fallback hosts, or there are no fallback hosts
5486 defined, convert the result to FAIL to cause a bounce. */
5488 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
5489 addr->transport_return = FAIL;
5494 if (hosts_retry == hosts_total)
5495 s = "retry time not reached for any host%s";
5496 else if (hosts_fail == hosts_total)
5497 s = "all host address lookups%s failed permanently";
5498 else if (hosts_defer == hosts_total)
5499 s = "all host address lookups%s failed temporarily";
5500 else if (hosts_serial == hosts_total)
5501 s = "connection limit reached for all hosts%s";
5502 else if (hosts_fail+hosts_defer == hosts_total)
5503 s = "all host address lookups%s failed";
5505 s = "some host address lookups failed and retry time "
5506 "not reached for other hosts or connection limit reached%s";
5508 addr->message = string_sprintf(s,
5509 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
5514 /* Update the database which keeps information about which messages are waiting
5515 for which hosts to become available. For some message-specific errors, the
5516 update_waiting flag is turned off because we don't want follow-on deliveries in
5517 those cases. If this transport instance is explicitly limited to one message
5518 per connection then follow-on deliveries are not possible and there's no need
5519 to create/update the per-transport wait-<transport_name> database. */
5521 if (update_waiting && tblock->connection_max_messages != 1)
5522 transport_update_waiting(hostlist, tblock->name);
5526 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5528 return TRUE; /* Each address has its status */
5531 #endif /*!MACRO_PREDEF*/
5534 /* End of transport/smtp.c */