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_FILTER_FAIL: /* Handle a failed filter process error;
598 can't send QUIT as we mustn't end the DATA. */
599 *message = string_sprintf("transport filter process failed (%d)%s",
601 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
604 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
605 can't send QUIT as we mustn't end the DATA. */
607 string_sprintf("failed to expand headers_add or headers_remove: %s",
608 expand_string_message);
611 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
612 *message = string_sprintf("failed to write a data block");
616 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
617 *message = US"utf8 support required but not offered for forwarding";
618 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
623 /* Handle error responses from the remote mailer. */
627 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
628 "%s", pl, smtp_command, s = string_printing(buffer));
629 *pass_message = TRUE;
634 /* No data was read. If there is no errno, this must be the EOF (i.e.
635 connection closed) case, which causes deferral. An explicit connection reset
636 error has the same effect. Otherwise, put the host's identity in the message,
637 leaving the errno value to be interpreted as well. In all cases, we have to
638 assume the connection is now dead. */
640 if (*errno_value == 0 || *errno_value == ECONNRESET)
642 *errno_value = ERRNO_SMTPCLOSED;
643 *message = US string_sprintf("Remote host closed connection "
644 "in response to %s%s", pl, smtp_command);
647 *message = US string_sprintf("%s [%s]", host->name, host->address);
654 /*************************************************
655 * Write error message to logs *
656 *************************************************/
658 /* This writes to the main log and to the message log.
661 host the current host
662 detail the current message (addr_item->message)
663 basic_errno the errno (addr_item->basic_errno)
669 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
671 uschar *message = LOGGING(outgoing_port)
672 ? string_sprintf("H=%s [%s]:%d", host->name, host->address,
673 host->port == PORT_NONE ? 25 : host->port)
674 : string_sprintf("H=%s [%s]", host->name, host->address);
678 message = string_sprintf("%s: %s", message, suffix);
680 message = string_sprintf("%s: %s", message, strerror(basic_errno));
683 message = string_sprintf("%s %s", message, exim_errstr(basic_errno));
685 log_write(0, LOG_MAIN, "%s", message);
686 deliver_msglog("%s %s\n", tod_stamp(tod_log), message);
690 msglog_line(host_item * host, uschar * message)
692 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
693 host->name, host->address, message);
698 #ifndef DISABLE_EVENT
699 /*************************************************
700 * Post-defer action *
701 *************************************************/
703 /* This expands an arbitrary per-transport string.
704 It might, for example, be used to write to the database log.
707 addr the address item containing error information
708 host the current host
714 deferred_event_raise(address_item *addr, host_item *host)
716 uschar * action = addr->transport->event_action;
717 const uschar * save_domain;
723 save_domain = deliver_domain;
724 save_local = deliver_localpart;
726 /*XXX would ip & port already be set up? */
727 deliver_host_address = string_copy(host->address);
728 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
729 event_defer_errno = addr->basic_errno;
731 router_name = addr->router->name;
732 transport_name = addr->transport->name;
733 deliver_domain = addr->domain;
734 deliver_localpart = addr->local_part;
736 (void) event_raise(action, US"msg:host:defer",
738 ? addr->basic_errno > 0
739 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
740 : string_copy(addr->message)
741 : addr->basic_errno > 0
742 ? string_copy(US strerror(addr->basic_errno))
745 deliver_localpart = save_local;
746 deliver_domain = save_domain;
747 router_name = transport_name = NULL;
751 /*************************************************
752 * Reap SMTP specific responses *
753 *************************************************/
755 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
758 uschar flushbuffer[4096];
762 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
763 '2', ob->command_timeout)
764 && (errno != 0 || flushbuffer[0] == 0))
771 /* Return boolean success */
774 smtp_reap_banner(smtp_context * sx)
776 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
777 '2', (SOB sx->conn_args.ob)->command_timeout);
778 #ifdef EXPERIMENTAL_DSN_INFO
779 sx->smtp_greeting = string_copy(sx->buffer);
781 return good_response;
785 smtp_reap_ehlo(smtp_context * sx)
787 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
788 (SOB sx->conn_args.ob)->command_timeout))
790 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
792 #ifdef EXPERIMENTAL_DSN_INFO
793 sx->helo_response = string_copy(sx->buffer);
799 #ifdef EXPERIMENTAL_DSN_INFO
800 sx->helo_response = string_copy(sx->buffer);
807 #ifdef EXPERIMENTAL_PIPE_CONNECT
809 ehlo_cache_key(const smtp_context * sx)
811 host_item * host = sx->conn_args.host;
812 return Ustrchr(host->address, ':')
813 ? string_sprintf("[%s]:%d.EHLO", host->address,
814 host->port == PORT_NONE ? sx->port : host->port)
815 : string_sprintf("%s:%d.EHLO", host->address,
816 host->port == PORT_NONE ? sx->port : host->port);
820 write_ehlo_cache_entry(const smtp_context * sx)
822 open_db dbblock, * dbm_file;
824 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
826 uschar * ehlo_resp_key = ehlo_cache_key(sx);
827 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
829 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
830 dbfn_close(dbm_file);
835 invalidate_ehlo_cache_entry(smtp_context * sx)
837 open_db dbblock, * dbm_file;
839 if ( sx->early_pipe_active
840 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
842 uschar * ehlo_resp_key = ehlo_cache_key(sx);
843 dbfn_delete(dbm_file, ehlo_resp_key);
844 dbfn_close(dbm_file);
849 read_ehlo_cache_entry(smtp_context * sx)
854 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE)))
855 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
858 uschar * ehlo_resp_key = ehlo_cache_key(sx);
859 dbdata_ehlo_resp * er;
861 if (!(er = dbfn_read(dbm_file, ehlo_resp_key)))
862 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
863 else if (time(NULL) - er->time_stamp > retry_data_expire)
865 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
866 dbfn_close(dbm_file);
867 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
868 dbfn_delete(dbm_file, ehlo_resp_key);
872 sx->ehlo_resp = er->data;
873 dbfn_close(dbm_file);
874 DEBUG(D_transport) debug_printf(
875 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
876 er->data.cleartext_features, er->data.crypted_features);
879 dbfn_close(dbm_file);
886 /* Return an auths bitmap for the set of AUTH methods offered by the server
887 which match our authenticators. */
889 static unsigned short
890 study_ehlo_auths(smtp_context * sx)
895 unsigned short authbits = 0;
897 if (!sx->esmtp) return 0;
898 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
899 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
900 expand_nmax = -1; /* reset */
901 names = string_copyn(expand_nstring[1], expand_nlength[1]);
903 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
905 const uschar * list = names;
909 while (string_nextinlist(&list, &sep, name, sizeof(name)))
910 if (strcmpic(au->public_name, name) == 0)
911 { authbits |= BIT(authnum); break; }
915 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
916 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
918 if (tls_out.active.sock >= 0)
919 sx->ehlo_resp.crypted_auths = authbits;
921 sx->ehlo_resp.cleartext_auths = authbits;
928 /* Wait for and check responses for early-pipelining.
930 Called from the lower-level smtp_read_response() function
931 used for general code that assume synchronisation, if context
932 flags indicate outstanding early-pipelining commands. Also
933 called fom sync_responses() which handles pipelined commands.
936 sx smtp connection context
937 countp number of outstanding responses, adjusted on return
941 FAIL SMTP error in response
944 smtp_reap_early_pipe(smtp_context * sx, int * countp)
946 BOOL pending_BANNER = sx->pending_BANNER;
947 BOOL pending_EHLO = sx->pending_EHLO;
949 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
950 sx->pending_EHLO = FALSE;
954 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
956 if (!smtp_reap_banner(sx))
958 DEBUG(D_transport) debug_printf("bad banner\n");
965 unsigned peer_offered;
966 unsigned short authbits = 0, * ap;
968 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
970 if (!smtp_reap_ehlo(sx))
972 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
976 /* Compare the actual EHLO response to the cached value we assumed;
977 on difference, dump or rewrite the cache and arrange for a retry. */
979 ap = tls_out.active.sock < 0
980 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
982 peer_offered = ehlo_response(sx->buffer,
983 (tls_out.active.sock < 0 ? OPTION_TLS : OPTION_REQUIRETLS)
984 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
985 | OPTION_UTF8 | OPTION_EARLY_PIPE
987 if ( peer_offered != sx->peer_offered
988 || (authbits = study_ehlo_auths(sx)) != *ap)
991 debug_printf("EHLO extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
992 sx->peer_offered, *ap, peer_offered, authbits);
994 if (peer_offered & OPTION_EARLY_PIPE)
995 write_ehlo_cache_entry(sx);
997 invalidate_ehlo_cache_entry(sx);
999 return OK; /* just carry on */
1005 invalidate_ehlo_cache_entry(sx);
1006 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
1012 /*************************************************
1013 * Synchronize SMTP responses *
1014 *************************************************/
1016 /* This function is called from smtp_deliver() to receive SMTP responses from
1017 the server, and match them up with the commands to which they relate. When
1018 PIPELINING is not in use, this function is called after every command, and is
1019 therefore somewhat over-engineered, but it is simpler to use a single scheme
1020 that works both with and without PIPELINING instead of having two separate sets
1023 The set of commands that are buffered up with pipelining may start with MAIL
1024 and may end with DATA; in between are RCPT commands that correspond to the
1025 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1026 etc.) are never buffered.
1028 Errors after MAIL or DATA abort the whole process leaving the response in the
1029 buffer. After MAIL, pending responses are flushed, and the original command is
1030 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1031 permitted to reject some recipient addresses while accepting others. However
1032 certain errors clearly abort the whole process. Set the value in
1033 transport_return to PENDING_OK if the address is accepted. If there is a
1034 subsequent general error, it will get reset accordingly. If not, it will get
1035 converted to OK at the end.
1038 sx smtp connection context
1039 count the number of responses to read
1040 pending_DATA 0 if last command sent was not DATA
1041 +1 if previously had a good recipient
1042 -1 if not previously had a good recipient
1044 Returns: 3 if at least one address had 2xx and one had 5xx
1045 2 if at least one address had 5xx but none had 2xx
1046 1 if at least one host had a 2xx response, but none had 5xx
1047 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1048 -1 timeout while reading RCPT response
1049 -2 I/O or other non-response error for RCPT
1050 -3 DATA or MAIL failed - errno and buffer set
1051 -4 banner or EHLO failed (early-pipelining)
1055 sync_responses(smtp_context * sx, int count, int pending_DATA)
1057 address_item * addr = sx->sync_addr;
1058 smtp_transport_options_block * ob = sx->conn_args.ob;
1061 #ifdef EXPERIMENTAL_PIPE_CONNECT
1062 if (smtp_reap_early_pipe(sx, &count) != OK)
1066 /* Handle the response for a MAIL command. On error, reinstate the original
1067 command in big_buffer for error message use, and flush any further pending
1068 responses before returning, except after I/O errors and timeouts. */
1070 if (sx->pending_MAIL)
1072 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1074 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1075 '2', ob->command_timeout))
1077 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1078 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1079 if (errno == 0 && sx->buffer[0] != 0)
1082 if (sx->buffer[0] == '4')
1084 save_errno = ERRNO_MAIL4XX;
1085 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1087 count = smtp_discard_responses(sx, ob, count);
1091 if (pending_DATA) count--; /* Number of RCPT responses to come */
1092 while (count-- > 0) /* Mark any pending addrs with the host used */
1094 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1095 addr->host_used = sx->conn_args.host;
1102 if (pending_DATA) count--; /* Number of RCPT responses to come */
1104 /* Read and handle the required number of RCPT responses, matching each one up
1105 with an address by scanning for the next address whose status is PENDING_DEFER.
1110 while (addr->transport_return != PENDING_DEFER)
1111 if (!(addr = addr->next))
1114 /* The address was accepted */
1115 addr->host_used = sx->conn_args.host;
1117 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1118 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1119 '2', ob->command_timeout))
1122 addr->transport_return = PENDING_OK;
1124 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1125 ensure that any address-specific retry record is expunged. We do this both
1126 for the basic key and for the version that also includes the sender. */
1128 if (testflag(addr, af_dr_retry_exists))
1130 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1132 retry_add_item(addr, altkey, rf_delete);
1133 retry_add_item(addr, addr->address_retry_key, rf_delete);
1137 /* Timeout while reading the response */
1139 else if (errno == ETIMEDOUT)
1141 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1142 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1143 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
1144 retry_add_item(addr, addr->address_retry_key, 0);
1145 update_waiting = FALSE;
1149 /* Handle other errors in obtaining an SMTP response by returning -1. This
1150 will cause all the addresses to be deferred. Restore the SMTP command in
1151 big_buffer for which we are checking the response, so the error message
1154 else if (errno != 0 || sx->buffer[0] == 0)
1156 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
1157 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1161 /* Handle SMTP permanent and temporary response codes. */
1166 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1167 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1168 string_printing(sx->buffer));
1169 setflag(addr, af_pass_message);
1171 msglog_line(sx->conn_args.host, addr->message);
1173 /* The response was 5xx */
1175 if (sx->buffer[0] == '5')
1177 addr->transport_return = FAIL;
1181 /* The response was 4xx */
1185 addr->transport_return = DEFER;
1186 addr->basic_errno = ERRNO_RCPT4XX;
1187 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1191 #ifndef DISABLE_EVENT
1192 event_defer_errno = addr->more_errno;
1193 msg_event_raise(US"msg:rcpt:host:defer", addr);
1196 /* Log temporary errors if there are more hosts to be tried.
1197 If not, log this last one in the == line. */
1199 if (sx->conn_args.host->next)
1200 log_write(0, LOG_MAIN, "H=%s [%s]: %s",
1201 sx->conn_args.host->name, sx->conn_args.host->address, addr->message);
1203 #ifndef DISABLE_EVENT
1205 msg_event_raise(US"msg:rcpt:defer", addr);
1208 /* Do not put this message on the list of those waiting for specific
1209 hosts, as otherwise it is likely to be tried too often. */
1211 update_waiting = FALSE;
1213 /* Add a retry item for the address so that it doesn't get tried again
1214 too soon. If address_retry_include_sender is true, add the sender address
1215 to the retry key. */
1217 retry_add_item(addr,
1218 ob->address_retry_include_sender
1219 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1220 : addr->address_retry_key,
1225 } /* Loop for next RCPT response */
1227 /* Update where to start at for the next block of responses, unless we
1228 have already handled all the addresses. */
1230 if (addr) sx->sync_addr = addr->next;
1232 /* Handle a response to DATA. If we have not had any good recipients, either
1233 previously or in this block, the response is ignored. */
1235 if (pending_DATA != 0)
1237 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1238 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1239 '3', ob->command_timeout))
1244 if (pending_DATA > 0 || (yield & 1) != 0)
1246 if (errno == 0 && sx->buffer[0] == '4')
1248 errno = ERRNO_DATA4XX;
1249 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1253 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1254 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1255 "is in use and there were no good recipients\n", msg);
1259 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1260 present) received 3xx. If any RCPTs were handled and yielded anything other
1261 than 4xx, yield will be set non-zero. */
1270 /* Try an authenticator's client entry */
1273 try_authenticator(smtp_context * sx, auth_instance * au)
1275 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1276 host_item * host = sx->conn_args.host; /* host to deliver to */
1279 sx->outblock.authenticating = TRUE;
1280 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1281 sx->buffer, sizeof(sx->buffer));
1282 sx->outblock.authenticating = FALSE;
1283 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1285 /* A temporary authentication failure must hold up delivery to
1286 this host. After a permanent authentication failure, we carry on
1287 to try other authentication methods. If all fail hard, try to
1288 deliver the message unauthenticated unless require_auth was set. */
1293 f.smtp_authenticated = TRUE; /* stops the outer loop */
1294 client_authenticator = au->name;
1295 if (au->set_client_id)
1296 client_authenticated_id = expand_string(au->set_client_id);
1299 /* Failure after writing a command */
1304 /* Failure after reading a response */
1307 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1308 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1309 au->name, host->name, host->address, sx->buffer);
1312 /* Failure by some other means. In effect, the authenticator
1313 decided it wasn't prepared to handle this case. Typically this
1314 is the result of "fail" in an expansion string. Do we need to
1315 log anything here? Feb 2006: a message is now put in the buffer
1316 if logging is required. */
1319 if (*sx->buffer != 0)
1320 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1321 "authentication H=%s [%s] %s", au->name, host->name,
1322 host->address, sx->buffer);
1325 /* Internal problem, message in buffer. */
1328 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1338 /* Do the client side of smtp-level authentication.
1341 sx smtp connection context
1343 sx->buffer should have the EHLO response from server (gets overwritten)
1346 OK Success, or failed (but not required): global "smtp_authenticated" set
1347 DEFER Failed authentication (and was required)
1348 ERROR Internal problem
1350 FAIL_SEND Failed communications - transmit
1355 smtp_auth(smtp_context * sx)
1357 host_item * host = sx->conn_args.host; /* host to deliver to */
1358 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1359 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1360 #ifdef EXPERIMENTAL_PIPE_CONNECT
1361 unsigned short authbits = tls_out.active.sock >= 0
1362 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1364 uschar * fail_reason = US"server did not advertise AUTH support";
1366 f.smtp_authenticated = FALSE;
1367 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1370 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1372 /* Is the server offering AUTH? */
1376 #ifdef EXPERIMENTAL_PIPE_CONNECT
1377 sx->early_pipe_active ? authbits
1380 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1383 uschar * names = NULL;
1384 expand_nmax = -1; /* reset */
1386 #ifdef EXPERIMENTAL_PIPE_CONNECT
1387 if (!sx->early_pipe_active)
1389 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1391 /* Must not do this check until after we have saved the result of the
1392 regex match above as the check could be another RE. */
1394 if ( require_auth == OK
1395 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1399 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1400 fail_reason = US"no common mechanisms were found";
1402 #ifdef EXPERIMENTAL_PIPE_CONNECT
1403 if (sx->early_pipe_active)
1405 /* Scan our authenticators (which support use by a client and were offered
1406 by the server (checked at cache-write time)), not suppressed by
1407 client_condition. If one is found, attempt to authenticate by calling its
1408 client function. We are limited to supporting up to 16 authenticator
1409 public-names by the number of bits in a short. */
1414 for (bitnum = 0, au = auths;
1415 !f.smtp_authenticated && au && bitnum < 16;
1416 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1418 if ( au->client_condition
1419 && !expand_check_condition(au->client_condition, au->name,
1420 US"client authenticator"))
1422 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1423 au->name, "client_condition is false");
1427 /* Found data for a listed mechanism. Call its client entry. Set
1428 a flag in the outblock so that data is overwritten after sending so
1429 that reflections don't show it. */
1431 fail_reason = US"authentication attempt(s) failed";
1433 if ((rc = try_authenticator(sx, au)) != OK)
1440 /* Scan the configured authenticators looking for one which is configured
1441 for use as a client, which is not suppressed by client_condition, and
1442 whose name matches an authentication mechanism supported by the server.
1443 If one is found, attempt to authenticate by calling its client function.
1446 for (au = auths; !f.smtp_authenticated && au; au = au->next)
1451 || ( au->client_condition
1452 && !expand_check_condition(au->client_condition, au->name,
1453 US"client authenticator")))
1455 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1457 (au->client)? "client_condition is false" :
1458 "not configured as a client");
1462 /* Loop to scan supported server mechanisms */
1466 int len = Ustrlen(au->public_name);
1469 while (isspace(*p)) p++;
1471 if (strncmpic(au->public_name, p, len) != 0 ||
1472 (p[len] != 0 && !isspace(p[len])))
1474 while (*p != 0 && !isspace(*p)) p++;
1478 /* Found data for a listed mechanism. Call its client entry. Set
1479 a flag in the outblock so that data is overwritten after sending so
1480 that reflections don't show it. */
1482 fail_reason = US"authentication attempt(s) failed";
1484 if ((rc = try_authenticator(sx, au)) != OK)
1487 break; /* If not authenticated, try next authenticator */
1488 } /* Loop for scanning supported server mechanisms */
1489 } /* Loop for further authenticators */
1493 /* If we haven't authenticated, but are required to, give up. */
1495 if (require_auth == OK && !f.smtp_authenticated)
1497 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1498 string_sprintf("authentication required but %s", fail_reason), DEFER,
1507 /* Construct AUTH appendix string for MAIL TO */
1510 buffer to build string
1511 addrlist chain of potential addresses to deliver
1512 ob transport options
1514 Globals f.smtp_authenticated
1515 client_authenticated_sender
1516 Return True on error, otherwise buffer has (possibly empty) terminated string
1520 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1521 smtp_transport_options_block *ob)
1523 uschar *local_authenticated_sender = authenticated_sender;
1526 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1529 if (ob->authenticated_sender != NULL)
1531 uschar *new = expand_string(ob->authenticated_sender);
1534 if (!f.expand_string_forcedfail)
1536 uschar *message = string_sprintf("failed to expand "
1537 "authenticated_sender: %s", expand_string_message);
1538 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1542 else if (new[0] != 0) local_authenticated_sender = new;
1545 /* Add the authenticated sender address if present */
1547 if ((f.smtp_authenticated || ob->authenticated_sender_force) &&
1548 local_authenticated_sender != NULL)
1550 string_format(buffer, bufsize, " AUTH=%s",
1551 auth_xtextencode(local_authenticated_sender,
1552 Ustrlen(local_authenticated_sender)));
1553 client_authenticated_sender = string_copy(local_authenticated_sender);
1564 /* Lookup TLSA record for host/port.
1565 Return: OK success with dnssec; DANE mode
1566 DEFER Do not use this host now, may retry later
1567 FAIL_FORCED No TLSA record; DANE not usable
1568 FAIL Do not use this connection
1572 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1574 /* move this out to host.c given the similarity to dns_lookup() ? */
1576 const uschar * fullname = buffer;
1580 /* TLSA lookup string */
1581 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1583 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1584 sec = dns_is_secure(dnsa);
1586 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1591 return DEFER; /* just defer this TLS'd conn */
1600 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1601 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1602 if (rr->type == T_TLSA && rr->size > 3)
1604 uint16_t payload_length = rr->size - 3;
1605 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1607 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1608 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1609 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1610 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1611 sp += sprintf(CS sp, "%02x", *p++);
1613 debug_printf(" %s\n", s);
1618 log_write(0, LOG_MAIN,
1619 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1622 case DNS_NODATA: /* no TLSA RR for this lookup */
1623 case DNS_NOMATCH: /* no records at all for this lookup */
1624 return dane_required ? FAIL : FAIL_FORCED;
1628 return dane_required ? FAIL : DEFER;
1635 typedef struct smtp_compare_s
1637 uschar *current_sender_address;
1638 struct transport_instance *tblock;
1642 /* Create a unique string that identifies this message, it is based on
1643 sender_address, helo_data and tls_certificate if enabled.
1647 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1649 address_item * addr1;
1650 uschar * if1 = US"";
1651 uschar * helo1 = US"";
1653 uschar * tlsc1 = US"";
1655 uschar * save_sender_address = sender_address;
1656 uschar * local_identity = NULL;
1657 smtp_transport_options_block * ob = SOB tblock->options_block;
1659 sender_address = sender;
1661 addr1 = deliver_make_addr (sender, TRUE);
1662 deliver_set_expansions(addr1);
1665 if1 = expand_string(ob->interface);
1668 helo1 = expand_string(ob->helo_data);
1671 if (ob->tls_certificate)
1672 tlsc1 = expand_string(ob->tls_certificate);
1673 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1675 local_identity = string_sprintf ("%s^%s", if1, helo1);
1678 deliver_set_expansions(NULL);
1679 sender_address = save_sender_address;
1681 return local_identity;
1686 /* This routine is a callback that is called from transport_check_waiting.
1687 This function will evaluate the incoming message versus the previous
1688 message. If the incoming message is using a different local identity then
1689 we will veto this new message. */
1692 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1694 uschar * message_local_identity,
1695 * current_local_identity,
1696 * new_sender_address;
1698 current_local_identity =
1699 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1701 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1704 message_local_identity =
1705 smtp_local_identity(new_sender_address, s_compare->tblock);
1707 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1713 ehlo_response(uschar * buf, unsigned checks)
1715 size_t bsize = Ustrlen(buf);
1717 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1720 # ifdef EXPERIMENTAL_REQUIRETLS
1721 if ( checks & OPTION_REQUIRETLS
1722 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1724 checks &= ~OPTION_REQUIRETLS;
1726 if ( checks & OPTION_TLS
1727 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1729 checks &= ~OPTION_TLS;
1731 if ( checks & OPTION_IGNQ
1732 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1733 PCRE_EOPT, NULL, 0) < 0)
1734 checks &= ~OPTION_IGNQ;
1736 if ( checks & OPTION_CHUNKING
1737 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1738 checks &= ~OPTION_CHUNKING;
1740 #ifndef DISABLE_PRDR
1741 if ( checks & OPTION_PRDR
1742 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1744 checks &= ~OPTION_PRDR;
1747 if ( checks & OPTION_UTF8
1748 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1750 checks &= ~OPTION_UTF8;
1752 if ( checks & OPTION_DSN
1753 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1754 checks &= ~OPTION_DSN;
1756 if ( checks & OPTION_PIPE
1757 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1758 PCRE_EOPT, NULL, 0) < 0)
1759 checks &= ~OPTION_PIPE;
1761 if ( checks & OPTION_SIZE
1762 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1763 checks &= ~OPTION_SIZE;
1765 #ifdef EXPERIMENTAL_PIPE_CONNECT
1766 if ( checks & OPTION_EARLY_PIPE
1767 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1768 PCRE_EOPT, NULL, 0) < 0)
1770 checks &= ~OPTION_EARLY_PIPE;
1772 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1778 /* Callback for emitting a BDAT data chunk header.
1780 If given a nonzero size, first flush any buffered SMTP commands
1781 then emit the command.
1783 Reap previous SMTP command responses if requested, and always reap
1784 the response from a previous BDAT command.
1787 tctx transport context
1788 chunk_size value for SMTP BDAT command
1790 tc_chunk_last add LAST option to SMTP BDAT command
1791 tc_reap_prev reap response to previous SMTP commands
1793 Returns: OK or ERROR
1797 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1800 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1801 smtp_context * sx = tctx->smtp_context;
1805 /* Write SMTP chunk header command. If not reaping responses, note that
1806 there may be more writes (like, the chunk data) done soon. */
1810 #ifdef EXPERIMENTAL_PIPE_CONNECT
1811 BOOL new_conn = !!(sx->outblock.conn_args);
1813 if((cmd_count = smtp_write_command(sx,
1814 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1815 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1816 ) < 0) return ERROR;
1817 if (flags & tc_chunk_last)
1818 data_command = string_copy(big_buffer); /* Save for later error message */
1819 #ifdef EXPERIMENTAL_PIPE_CONNECT
1820 /* That command write could have been the one that made the connection.
1821 Copy the fd from the client conn ctx (smtp transport specific) to the
1822 generic transport ctx. */
1825 tctx->u.fd = sx->outblock.cctx->sock;
1829 prev_cmd_count = cmd_count += sx->cmd_count;
1831 /* Reap responses for any previous, but not one we just emitted */
1835 if (sx->pending_BDAT)
1838 if (flags & tc_reap_prev && prev_cmd_count > 0)
1840 DEBUG(D_transport) debug_printf("look for %d responses"
1841 " for previous pipelined cmds\n", prev_cmd_count);
1843 switch(sync_responses(sx, prev_cmd_count, 0))
1845 case 1: /* 2xx (only) => OK */
1846 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1847 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1848 case 0: break; /* No 2xx or 5xx, but no probs */
1850 case -1: /* Timeout on RCPT */
1851 #ifdef EXPERIMENTAL_PIPE_CONNECT
1852 case -4: /* non-2xx for pipelined banner or EHLO */
1854 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1857 if (!sx->pending_BDAT)
1858 pipelining_active = FALSE;
1861 /* Reap response for an outstanding BDAT */
1863 if (sx->pending_BDAT)
1865 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1867 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1868 ob->command_timeout))
1870 if (errno == 0 && sx->buffer[0] == '4')
1872 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1873 sx->addrlist->more_errno |=
1874 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1879 sx->pending_BDAT = FALSE;
1880 pipelining_active = FALSE;
1882 else if (chunk_size > 0)
1883 sx->pending_BDAT = TRUE;
1886 sx->cmd_count = cmd_count;
1894 /*************************************************
1895 * Make connection for given message *
1896 *************************************************/
1900 ctx connection context
1901 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1902 a second attempt after TLS initialization fails
1904 Returns: OK - the connection was made and the delivery attempted;
1905 fd is set in the conn context, tls_out set up.
1906 DEFER - the connection could not be made, or something failed
1907 while setting up the SMTP session, or there was a
1908 non-message-specific error, such as a timeout.
1909 ERROR - helo_data or add_headers or authenticated_sender is
1910 specified for this transport, and the string failed
1914 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1916 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1917 dns_answer tlsa_dnsa;
1919 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1920 BOOL pass_message = FALSE;
1921 uschar * message = NULL;
1925 sx->conn_args.ob = ob;
1927 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1928 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1930 sx->send_rset = TRUE;
1931 sx->send_quit = TRUE;
1932 sx->setting_up = TRUE;
1934 sx->esmtp_sent = FALSE;
1936 sx->utf8_needed = FALSE;
1938 sx->dsn_all_lasthop = TRUE;
1939 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1942 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1944 #ifdef EXPERIMENTAL_PIPE_CONNECT
1945 sx->early_pipe_active = sx->early_pipe_ok = FALSE;
1946 sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0;
1947 sx->pending_BANNER = sx->pending_EHLO = FALSE;
1950 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1951 sx->peer_offered = 0;
1952 sx->avoid_option = 0;
1953 sx->igquotstr = US"";
1954 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1955 #ifdef EXPERIMENTAL_DSN_INFO
1956 sx->smtp_greeting = NULL;
1957 sx->helo_response = NULL;
1960 smtp_command = US"initial connection";
1961 sx->buffer[0] = '\0';
1963 /* Set up the buffer for reading SMTP response packets. */
1965 sx->inblock.buffer = sx->inbuffer;
1966 sx->inblock.buffersize = sizeof(sx->inbuffer);
1967 sx->inblock.ptr = sx->inbuffer;
1968 sx->inblock.ptrend = sx->inbuffer;
1970 /* Set up the buffer for holding SMTP commands while pipelining */
1972 sx->outblock.buffer = sx->outbuffer;
1973 sx->outblock.buffersize = sizeof(sx->outbuffer);
1974 sx->outblock.ptr = sx->outbuffer;
1975 sx->outblock.cmd_count = 0;
1976 sx->outblock.authenticating = FALSE;
1977 sx->outblock.conn_args = NULL;
1979 /* Reset the parameters of a TLS session. */
1982 tls_out.cipher = NULL; /* the one we may use for this transport */
1983 tls_out.ourcert = NULL;
1984 tls_out.peercert = NULL;
1985 tls_out.peerdn = NULL;
1986 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1989 tls_out.ocsp = OCSP_NOT_REQ;
1991 /* Flip the legacy TLS-related variables over to the outbound set in case
1992 they're used in the context of the transport. Don't bother resetting
1993 afterward (when being used by a transport) as we're in a subprocess.
1994 For verify, unflipped once the callout is dealt with */
1996 tls_modify_variables(&tls_out);
2001 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
2007 /* Make a connection to the host if this isn't a continued delivery, and handle
2008 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2009 specially so they can be identified for retries. */
2011 if (!continue_hostname)
2014 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2016 /* Get the actual port the connection will use, into sx->conn_args.host */
2018 smtp_port_for_connect(sx->conn_args.host, sx->port);
2020 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
2021 /* Do TLSA lookup for DANE */
2023 tls_out.dane_verified = FALSE;
2024 tls_out.tlsa_usage = 0;
2026 if (sx->conn_args.host->dnssec == DS_YES)
2028 if( sx->dane_required
2029 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2031 switch (rc = tlsa_lookup(sx->conn_args.host, &tlsa_dnsa, sx->dane_required))
2033 case OK: sx->dane = TRUE;
2034 ob->tls_tempfail_tryclear = FALSE;
2036 case FAIL_FORCED: break;
2037 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2038 string_sprintf("DANE error: tlsa lookup %s",
2039 rc == DEFER ? "DEFER" : "FAIL"),
2041 # ifndef DISABLE_EVENT
2042 (void) event_raise(sx->conn_args.tblock->event_action,
2043 US"dane:fail", sx->dane_required
2044 ? US"dane-required" : US"dnssec-invalid");
2049 else if (sx->dane_required)
2051 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2052 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2054 # ifndef DISABLE_EVENT
2055 (void) event_raise(sx->conn_args.tblock->event_action,
2056 US"dane:fail", US"dane-required");
2063 /* Make the TCP connection */
2065 sx->cctx.tls_ctx = NULL;
2066 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2067 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2069 #ifdef EXPERIMENTAL_PIPE_CONNECT
2070 if (verify_check_given_host(CUSS &ob->hosts_pipe_connect, sx->conn_args.host) == OK)
2072 sx->early_pipe_ok = TRUE;
2073 if ( read_ehlo_cache_entry(sx)
2074 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2076 DEBUG(D_transport) debug_printf("Using cached cleartext PIPE_CONNECT\n");
2077 sx->early_pipe_active = TRUE;
2078 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2082 if (sx->early_pipe_active)
2083 sx->outblock.conn_args = &sx->conn_args;
2087 if ((sx->cctx.sock = smtp_connect(&sx->conn_args, NULL)) < 0)
2089 uschar * msg = NULL;
2092 msg = US strerror(errno);
2093 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
2095 set_errno_nohost(sx->addrlist,
2096 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2097 sx->verify ? string_sprintf("could not connect: %s", msg)
2100 sx->send_quit = FALSE;
2104 /* Expand the greeting message while waiting for the initial response. (Makes
2105 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2106 delayed till here so that $sending_interface and $sending_port are set. */
2107 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2108 will be? Somehow I doubt it. */
2111 if (!(sx->helo_data = expand_string(sx->helo_data)))
2113 log_write(0, LOG_MAIN|LOG_PANIC,
2114 "<%s>: failed to expand transport's helo_data value for callout: %s",
2115 sx->addrlist->address, expand_string_message);
2120 expand_string_message = NULL;
2121 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2122 &expand_string_message)),
2123 expand_string_message)
2125 log_write(0, LOG_MAIN|LOG_PANIC,
2126 "<%s>: failed to expand transport's helo_data value for callout: %s",
2127 sx->addrlist->address, expand_string_message);
2129 sx->helo_data = NULL;
2133 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2134 is nevertheless a reasonably clean way of programming this kind of logic,
2135 where you want to escape on any error. */
2139 #ifdef EXPERIMENTAL_PIPE_CONNECT
2140 if (sx->early_pipe_active)
2142 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2143 sx->outblock.cmd_count = 1;
2149 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2152 if (!smtp_reap_banner(sx))
2153 goto RESPONSE_FAILED;
2156 #ifndef DISABLE_EVENT
2159 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2160 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2161 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2164 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2165 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2173 /* Now check if the helo_data expansion went well, and sign off cleanly if
2178 message = string_sprintf("failed to expand helo_data: %s",
2179 expand_string_message);
2180 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2186 /** Debugging without sending a message
2187 sx->addrlist->transport_return = DEFER;
2191 /* Errors that occur after this point follow an SMTP command, which is
2192 left in big_buffer by smtp_write_command() for use in error messages. */
2194 smtp_command = big_buffer;
2196 /* Tell the remote who we are...
2198 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2199 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2200 greeting is of this form. The assumption was that the far end supports it
2201 properly... but experience shows that there are some that give 5xx responses,
2202 even though the banner includes "ESMTP" (there's a bloody-minded one that
2203 says "ESMTP not spoken here"). Cope with that case.
2205 September 2000: Time has passed, and it seems reasonable now to always send
2206 EHLO at the start. It is also convenient to make the change while installing
2209 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2210 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2211 would be no way to send out the mails, so there is now a host list
2212 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2213 PIPELINING problem as well. Maybe it can also be useful to cure other
2214 problems with broken servers.
2216 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2217 Then somebody tried it with a Microsoft mailer... It seems that all other
2218 mailers use upper case for some reason (the RFC is quite clear about case
2219 independence) so, for peace of mind, I gave in. */
2221 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2223 /* Alas; be careful, since this goto is not an error-out, so conceivably
2224 we might set data between here and the target which we assume to exist
2225 and be usable. I can see this coming back to bite us. */
2229 smtp_peer_options |= OPTION_TLS;
2230 suppress_tls = FALSE;
2231 ob->tls_tempfail_tryclear = FALSE;
2232 smtp_command = US"SSL-on-connect";
2239 if (smtp_write_command(sx,
2240 #ifdef EXPERIMENTAL_PIPE_CONNECT
2241 sx->early_pipe_active ? SCMD_BUFFER :
2244 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2246 sx->esmtp_sent = TRUE;
2248 #ifdef EXPERIMENTAL_PIPE_CONNECT
2249 if (sx->early_pipe_active)
2251 sx->pending_EHLO = TRUE;
2253 /* If we have too many authenticators to handle and might need to AUTH
2254 for this transport, pipeline no further as we will need the
2255 list of auth methods offered. Reap the banner and EHLO. */
2257 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2258 && f.smtp_in_early_pipe_no_auth)
2260 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2261 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2263 if (sync_responses(sx, 2, 0) != 0)
2266 debug_printf("failed reaping pipelined cmd responses\n");
2267 goto RESPONSE_FAILED;
2269 sx->early_pipe_active = FALSE;
2274 if (!smtp_reap_ehlo(sx))
2275 goto RESPONSE_FAILED;
2279 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2281 #ifdef EXPERIMENTAL_PIPE_CONNECT
2282 if (!sx->early_pipe_active)
2287 int n = sizeof(sx->buffer);
2288 uschar * rsp = sx->buffer;
2290 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2291 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2293 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2295 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2296 #ifdef EXPERIMENTAL_DSN_INFO
2297 sx->helo_response = string_copy(rsp);
2301 /* Handle special logging for a closed connection after HELO
2302 when had previously sent EHLO */
2304 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2306 errno = ERRNO_SMTPCLOSED;
2307 goto EHLOHELO_FAILED;
2309 memmove(sx->buffer, rsp, Ustrlen(rsp));
2310 goto RESPONSE_FAILED;
2314 if (sx->esmtp || sx->lmtp)
2316 #ifdef EXPERIMENTAL_PIPE_CONNECT
2317 if (!sx->early_pipe_active)
2320 sx->peer_offered = ehlo_response(sx->buffer,
2321 OPTION_TLS /* others checked later */
2322 #ifdef EXPERIMENTAL_PIPE_CONNECT
2323 | (sx->early_pipe_ok
2325 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2334 #ifdef EXPERIMENTAL_PIPE_CONNECT
2335 if (sx->early_pipe_ok)
2337 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2339 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2340 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2342 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2343 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2344 write_ehlo_cache_entry(sx);
2350 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2353 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2358 /* For continuing deliveries down the same channel, having re-exec'd the socket
2359 is the standard input; for a socket held open from verify it is recorded
2360 in the cutthrough context block. Either way we don't need to redo EHLO here
2361 (but may need to do so for TLS - see below).
2362 Set up the pointer to where subsequent commands will be left, for
2363 error messages. Note that smtp_peer_options will have been
2364 set from the command line if they were set in the process that passed the
2367 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2368 as the continue goes via transport_pass_socket() and doublefork and exec.
2369 It does not wait. Unclear how we keep separate host's responses
2370 separate - we could match up by host ip+port as a bodge. */
2374 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2376 sx->cctx = cutthrough.cctx;
2377 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2381 sx->cctx.sock = 0; /* stdin */
2382 sx->cctx.tls_ctx = NULL;
2383 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2385 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2386 smtp_command = big_buffer;
2387 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2389 /* For a continued connection with TLS being proxied for us, or a
2390 held-open verify connection with TLS, nothing more to do. */
2392 if ( continue_proxy_cipher
2393 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2394 && cutthrough.is_tls)
2397 sx->peer_offered = smtp_peer_options;
2398 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2399 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2400 continue_proxy_cipher ? "proxied" : "verify conn with");
2403 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2406 /* If TLS is available on this connection, whether continued or not, attempt to
2407 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2408 send another EHLO - the server may give a different answer in secure mode. We
2409 use a separate buffer for reading the response to STARTTLS so that if it is
2410 negative, the original EHLO data is available for subsequent analysis, should
2411 the client not be required to use TLS. If the response is bad, copy the buffer
2412 for error analysis. */
2415 if ( smtp_peer_options & OPTION_TLS
2417 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2419 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2422 uschar buffer2[4096];
2424 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2427 #ifdef EXPERIMENTAL_PIPE_CONNECT
2428 /* If doing early-pipelining reap the banner and EHLO-response but leave
2429 the response for the STARTTLS we just sent alone. */
2431 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2434 debug_printf("failed reaping pipelined cmd responses\n");
2435 goto RESPONSE_FAILED;
2439 /* If there is an I/O error, transmission of this message is deferred. If
2440 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2441 false, we also defer. However, if there is a temporary rejection of STARTTLS
2442 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2443 STARTTLS, we carry on. This means we will try to send the message in clear,
2444 unless the host is in hosts_require_tls (tested below). */
2446 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2450 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2453 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2454 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2455 goto RESPONSE_FAILED;
2459 /* STARTTLS accepted: try to negotiate a TLS session. */
2464 address_item * addr;
2466 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->conn_args.host,
2467 sx->addrlist, sx->conn_args.tblock,
2468 # ifdef SUPPORT_DANE
2469 sx->dane ? &tlsa_dnsa : NULL,
2473 if (!sx->cctx.tls_ctx)
2475 /* TLS negotiation failed; give an error. From outside, this function may
2476 be called again to try in clear on a new connection, if the options permit
2477 it for this host. */
2478 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", errstr);
2480 # ifdef SUPPORT_DANE
2483 log_write(0, LOG_MAIN,
2484 "DANE attempt failed; TLS connection to %s [%s]: %s",
2485 sx->conn_args.host->name, sx->conn_args.host->address, errstr);
2486 # ifndef DISABLE_EVENT
2487 (void) event_raise(sx->conn_args.tblock->event_action,
2488 US"dane:fail", US"validation-failure"); /* could do with better detail */
2493 errno = ERRNO_TLSFAILURE;
2494 message = string_sprintf("TLS session: %s", errstr);
2495 sx->send_quit = FALSE;
2499 /* TLS session is set up */
2501 smtp_peer_options_wrap = smtp_peer_options;
2502 for (addr = sx->addrlist; addr; addr = addr->next)
2503 if (addr->transport_return == PENDING_DEFER)
2505 addr->cipher = tls_out.cipher;
2506 addr->ourcert = tls_out.ourcert;
2507 addr->peercert = tls_out.peercert;
2508 addr->peerdn = tls_out.peerdn;
2509 addr->ocsp = tls_out.ocsp;
2514 /* if smtps, we'll have smtp_command set to something else; always safe to
2516 smtp_command = big_buffer;
2518 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2519 helo_data is null, we are dealing with a connection that was passed from
2520 another process, and so we won't have expanded helo_data above. We have to
2521 expand it here. $sending_ip_address and $sending_port are set up right at the
2522 start of the Exim process (in exim.c). */
2524 if (tls_out.active.sock >= 0)
2526 uschar * greeting_cmd;
2528 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2530 uschar *message = string_sprintf("failed to expand helo_data: %s",
2531 expand_string_message);
2532 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2537 #ifdef EXPERIMENTAL_PIPE_CONNECT
2538 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2539 We're unlikely to get the group sent and delivered before the server sends its
2540 banner, but it's still worth sending as a group.
2541 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2544 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2546 sx->peer_offered = sx->ehlo_resp.crypted_features;
2547 if ((sx->early_pipe_active =
2548 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2549 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2553 /* For SMTPS we need to wait for the initial OK response. */
2555 #ifdef EXPERIMENTAL_PIPE_CONNECT
2556 if (sx->early_pipe_active)
2558 sx->pending_BANNER = TRUE;
2559 sx->outblock.cmd_count = 1;
2563 if (!smtp_reap_banner(sx))
2564 goto RESPONSE_FAILED;
2567 greeting_cmd = US"LHLO";
2569 greeting_cmd = US"EHLO";
2572 greeting_cmd = US"HELO";
2574 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2577 if (smtp_write_command(sx,
2578 #ifdef EXPERIMENTAL_PIPE_CONNECT
2579 sx->early_pipe_active ? SCMD_BUFFER :
2582 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2585 #ifdef EXPERIMENTAL_PIPE_CONNECT
2586 if (sx->early_pipe_active)
2587 sx->pending_EHLO = TRUE;
2591 if (!smtp_reap_ehlo(sx))
2592 goto RESPONSE_FAILED;
2593 smtp_peer_options = 0;
2597 /* If the host is required to use a secure channel, ensure that we
2601 # ifdef SUPPORT_DANE
2604 # ifdef EXPERIMENTAL_REQUIRETLS
2605 || tls_requiretls & REQUIRETLS_MSG
2607 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2611 # ifdef EXPERIMENTAL_REQUIRETLS
2612 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2615 message = string_sprintf("a TLS session is required, but %s",
2616 smtp_peer_options & OPTION_TLS
2617 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2618 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2620 (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2621 smtp_peer_options & OPTION_TLS
2622 ? US"validation-failure" /* could do with better detail */
2623 : US"starttls-not-supported");
2627 #endif /*SUPPORT_TLS*/
2629 /* If TLS is active, we have just started it up and re-done the EHLO command,
2630 so its response needs to be analyzed. If TLS is not active and this is a
2631 continued session down a previously-used socket, we haven't just done EHLO, so
2634 if (continue_hostname == NULL
2636 || tls_out.active.sock >= 0
2640 if (sx->esmtp || sx->lmtp)
2642 #ifdef EXPERIMENTAL_PIPE_CONNECT
2643 if (!sx->early_pipe_active)
2646 sx->peer_offered = ehlo_response(sx->buffer,
2648 #ifdef EXPERIMENTAL_PIPE_CONNECT
2649 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2650 | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2651 | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8 | OPTION_REQUIRETLS
2652 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2656 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2659 # ifdef SUPPORT_I18N
2660 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2661 /*XXX if we hand peercaps on to continued-conn processes,
2662 must not depend on this addr */
2666 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2667 # if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2668 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2672 #ifdef EXPERIMENTAL_PIPE_CONNECT
2673 if (tls_out.active.sock >= 0)
2674 sx->ehlo_resp.crypted_features = sx->peer_offered;
2678 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2679 lmtp_ignore_quota option was set. */
2681 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2683 /* If the response to EHLO specified support for the SIZE parameter, note
2684 this, provided size_addition is non-negative. */
2686 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2688 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2689 the current host, esmtp will be false, so PIPELINING can never be used. If
2690 the current host matches hosts_avoid_pipelining, don't do it. */
2692 if ( sx->peer_offered & OPTION_PIPE
2693 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2694 smtp_peer_options |= OPTION_PIPE;
2696 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2697 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2699 if ( sx->peer_offered & OPTION_CHUNKING
2700 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2701 sx->peer_offered &= ~OPTION_CHUNKING;
2703 if (sx->peer_offered & OPTION_CHUNKING)
2704 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2706 #ifndef DISABLE_PRDR
2707 if ( sx->peer_offered & OPTION_PRDR
2708 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2709 sx->peer_offered &= ~OPTION_PRDR;
2711 if (sx->peer_offered & OPTION_PRDR)
2712 DEBUG(D_transport) debug_printf("PRDR usable\n");
2715 /* Note if the server supports DSN */
2716 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2717 DEBUG(D_transport) debug_printf("%susing DSN\n",
2718 sx->peer_offered & OPTION_DSN ? "" : "not ");
2720 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2721 if (sx->peer_offered & OPTION_REQUIRETLS)
2723 smtp_peer_options |= OPTION_REQUIRETLS;
2724 DEBUG(D_transport) debug_printf(
2725 tls_requiretls & REQUIRETLS_MSG
2726 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2730 #ifdef EXPERIMENTAL_PIPE_CONNECT
2731 if ( sx->early_pipe_ok
2732 && !sx->early_pipe_active
2733 && tls_out.active.sock >= 0
2734 && smtp_peer_options & OPTION_PIPE
2735 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2736 & OPTION_EARLY_PIPE)
2738 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2739 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2740 write_ehlo_cache_entry(sx);
2744 /* Note if the response to EHLO specifies support for the AUTH extension.
2745 If it has, check that this host is one we want to authenticate to, and do
2746 the business. The host name and address must be available when the
2747 authenticator's client driver is running. */
2749 switch (yield = smtp_auth(sx))
2751 default: goto SEND_QUIT;
2753 case FAIL_SEND: goto SEND_FAILED;
2754 case FAIL: goto RESPONSE_FAILED;
2758 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2760 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2761 message-specific. */
2763 sx->setting_up = FALSE;
2766 if (sx->addrlist->prop.utf8_msg)
2770 /* If the transport sets a downconversion mode it overrides any set by ACL
2773 if ((s = ob->utf8_downconvert))
2775 if (!(s = expand_string(s)))
2777 message = string_sprintf("failed to expand utf8_downconvert: %s",
2778 expand_string_message);
2779 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2785 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2786 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2788 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2789 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2791 case '-': if (s[1] == '1')
2793 sx->addrlist->prop.utf8_downcvt = FALSE;
2794 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2800 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2801 && !sx->addrlist->prop.utf8_downcvt_maybe;
2802 DEBUG(D_transport) if (!sx->utf8_needed)
2803 debug_printf("utf8: %s downconvert\n",
2804 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2807 /* If this is an international message we need the host to speak SMTPUTF8 */
2808 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2810 errno = ERRNO_UTF8_FWD;
2811 goto RESPONSE_FAILED;
2813 #endif /*SUPPORT_I18N*/
2815 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2816 /*XXX should tls_requiretls actually be per-addr? */
2818 if ( tls_requiretls & REQUIRETLS_MSG
2819 && !(sx->peer_offered & OPTION_REQUIRETLS)
2822 sx->setting_up = TRUE;
2823 errno = ERRNO_REQUIRETLS;
2824 message = US"REQUIRETLS support is required from the server"
2825 " but it was not offered";
2826 DEBUG(D_transport) debug_printf("%s\n", message);
2839 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2840 sx->buffer, &code, &message, &pass_message);
2846 message = US string_sprintf("send() to %s [%s] failed: %s",
2847 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2848 sx->send_quit = FALSE;
2854 message = string_sprintf("Remote host closed connection in response to %s"
2855 " (EHLO response was: %s)", smtp_command, sx->buffer);
2856 sx->send_quit = FALSE;
2860 /* This label is jumped to directly when a TLS negotiation has failed,
2861 or was not done for a host for which it is required. Values will be set
2862 in message and errno, and setting_up will always be true. Treat as
2863 a temporary error. */
2867 # ifdef EXPERIMENTAL_REQUIRETLS
2868 if (errno == ERRNO_REQUIRETLS)
2869 code = '5', yield = FAIL;
2870 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2873 code = '4', yield = DEFER;
2877 /* The failure happened while setting up the call; see if the failure was
2878 a 5xx response (this will either be on connection, or following HELO - a 5xx
2879 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2880 fail all addresses, as this host is never going to accept them. For other
2881 errors during setting up (timeouts or whatever), defer all addresses, and
2882 yield DEFER, so that the host is not tried again for a while.
2884 XXX This peeking for another host feels like a layering violation. We want
2885 to note the host as unusable, but down here we shouldn't know if this was
2886 the last host to try for the addr(list). Perhaps the upper layer should be
2887 the one to do set_errno() ? The problem is that currently the addr is where
2888 errno etc. are stashed, but until we run out of hosts to try the errors are
2889 host-specific. Maybe we should enhance the host_item definition? */
2892 sx->ok = FALSE; /* For when reached by GOTO */
2893 set_errno(sx->addrlist, errno, message,
2894 sx->conn_args.host->next
2898 || errno == ERRNO_UTF8_FWD
2901 pass_message, sx->conn_args.host
2902 #ifdef EXPERIMENTAL_DSN_INFO
2903 , sx->smtp_greeting, sx->helo_response
2912 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2915 if (sx->cctx.tls_ctx)
2917 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2918 sx->cctx.tls_ctx = NULL;
2922 /* Close the socket, and return the appropriate value, first setting
2923 works because the NULL setting is passed back to the calling process, and
2924 remote_max_parallel is forced to 1 when delivering over an existing connection,
2927 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2930 shutdown(sx->cctx.sock, SHUT_WR);
2931 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2932 for (rc = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && rc > 0;)
2933 rc--; /* drain socket */
2934 sx->send_quit = FALSE;
2936 (void)close(sx->cctx.sock);
2939 #ifndef DISABLE_EVENT
2940 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2943 continue_transport = NULL;
2944 continue_hostname = NULL;
2951 /* Create the string of options that will be appended to the MAIL FROM:
2952 in the connection context buffer */
2955 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2957 uschar * p = sx->buffer;
2958 address_item * addr;
2963 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2964 send it, adding something to the message size to allow for imprecision
2965 and things that get added en route. Exim keeps the number of lines
2966 in a message, so we can give an accurate value for the original message, but we
2967 need some additional to handle added headers. (Double "." characters don't get
2968 included in the count.) */
2970 if ( message_size > 0
2971 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2973 /*XXX problem here under spool_files_wireformat?
2974 Or just forget about lines? Or inflate by a fixed proportion? */
2976 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
2980 #ifndef DISABLE_PRDR
2981 /* If it supports Per-Recipient Data Reponses, and we have omre than one recipient,
2984 sx->prdr_active = FALSE;
2985 if (sx->peer_offered & OPTION_PRDR)
2986 for (addr = addrlist; addr; addr = addr->next)
2987 if (addr->transport_return == PENDING_DEFER)
2989 for (addr = addr->next; addr; addr = addr->next)
2990 if (addr->transport_return == PENDING_DEFER)
2991 { /* at least two recipients to send */
2992 sx->prdr_active = TRUE;
2993 sprintf(CS p, " PRDR"); p += 5;
3001 /* If it supports internationalised messages, and this meesage need that,
3004 if ( sx->peer_offered & OPTION_UTF8
3005 && addrlist->prop.utf8_msg
3006 && !addrlist->prop.utf8_downcvt
3008 Ustrcpy(p, " SMTPUTF8"), p += 9;
3011 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3012 if (tls_requiretls & REQUIRETLS_MSG)
3013 Ustrcpy(p, " REQUIRETLS") , p += 11;
3016 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3017 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3018 addr && address_count < sx->max_rcpt;
3019 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3022 if (!(addr->dsn_flags & rf_dsnlasthop))
3024 sx->dsn_all_lasthop = FALSE;
3029 /* Add any DSN flags to the mail command */
3031 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3033 if (dsn_ret == dsn_ret_hdrs)
3034 { Ustrcpy(p, " RET=HDRS"); p += 9; }
3035 else if (dsn_ret == dsn_ret_full)
3036 { Ustrcpy(p, " RET=FULL"); p += 9; }
3040 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3045 /* If an authenticated_sender override has been specified for this transport
3046 instance, expand it. If the expansion is forced to fail, and there was already
3047 an authenticated_sender for this message, the original value will be used.
3048 Other expansion failures are serious. An empty result is ignored, but there is
3049 otherwise no check - this feature is expected to be used with LMTP and other
3050 cases where non-standard addresses (e.g. without domains) might be required. */
3052 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->conn_args.ob))
3060 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3062 uschar * p = sx->buffer;
3065 /* Add any DSN flags to the rcpt command */
3067 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3069 if (addr->dsn_flags & rf_dsnflags)
3074 Ustrcpy(p, " NOTIFY=");
3076 for (i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3078 if (!first) *p++ = ',';
3080 Ustrcpy(p, rf_names[i]);
3085 if (addr->dsn_orcpt)
3087 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3098 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3099 -1 MAIL response error
3100 -2 any non-MAIL read i/o error
3101 -3 non-MAIL response timeout
3102 -4 internal error; channel still usable
3107 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3109 address_item * addr;
3113 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3119 /* From here until we send the DATA command, we can make use of PIPELINING
3120 if the server host supports it. The code has to be able to check the responses
3121 at any point, for when the buffer fills up, so we write it totally generally.
3122 When PIPELINING is off, each command written reports that it has flushed the
3125 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3128 uschar * s = sx->from_addr;
3130 uschar * errstr = NULL;
3132 /* If we must downconvert, do the from-address here. Remember we had to
3133 for the to-addresses (done below), and also (ugly) for re-doing when building
3134 the delivery log line. */
3136 if ( sx->addrlist->prop.utf8_msg
3137 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3140 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3142 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3146 setflag(sx->addrlist, af_utf8_downcvt);
3150 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3151 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3154 mail_command = string_copy(big_buffer); /* Save for later error message */
3158 case -1: /* Transmission error */
3161 case +1: /* Cmd was sent */
3162 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3163 (SOB sx->conn_args.ob)->command_timeout))
3165 if (errno == 0 && sx->buffer[0] == '4')
3167 errno = ERRNO_MAIL4XX;
3168 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3172 sx->pending_MAIL = FALSE;
3175 /* otherwise zero: command queued for pipeline */
3178 /* Pass over all the relevant recipient addresses for this host, which are the
3179 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3180 several before we have to read the responses for those seen so far. This
3181 checking is done by a subroutine because it also needs to be done at the end.
3182 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3183 the next one if not all are sent.
3185 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3186 last address because we want to abort if any recipients have any kind of
3187 problem, temporary or permanent. We know that all recipient addresses will have
3188 the PENDING_DEFER status, because only one attempt is ever made, and we know
3189 that max_rcpt will be large, so all addresses will be done at once.
3191 For verify we flush the pipeline after any (the only) rcpt address. */
3193 for (addr = sx->first_addr, address_count = 0;
3194 addr && address_count < sx->max_rcpt;
3195 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3201 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3202 ? dsn_support_yes : dsn_support_no;
3205 no_flush = pipelining_active && !sx->verify
3206 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3208 build_rcptcmd_options(sx, addr);
3210 /* Now send the RCPT command, and process outstanding responses when
3211 necessary. After a timeout on RCPT, we just end the function, leaving the
3212 yield as OK, because this error can often mean that there is a problem with
3213 just one address, so we don't want to delay the host. */
3215 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3218 if ( testflag(sx->addrlist, af_utf8_downcvt)
3219 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3222 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3223 errno = ERRNO_EXPANDFAIL;
3224 return -5; /*XXX too harsh? */
3228 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3229 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3231 if (count < 0) return -5;
3234 switch(sync_responses(sx, count, 0))
3236 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3237 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3240 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3241 if (!sx->lmtp) /* can't tell about progress yet */
3242 sx->completed_addr = TRUE;
3243 case 0: /* No 2xx or 5xx, but no probs */
3246 case -1: return -3; /* Timeout on RCPT */
3247 case -2: return -2; /* non-MAIL read i/o error */
3248 default: return -1; /* any MAIL error */
3250 #ifdef EXPERIMENTAL_PIPE_CONNECT
3251 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3254 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
3256 } /* Loop for next address */
3258 sx->next_addr = addr;
3264 /*****************************************************
3265 * Proxy TLS connection for another transport process *
3266 ******************************************************/
3268 Close the unused end of the pipe, fork once more, then use the given buffer
3269 as a staging area, and select on both the given fd and the TLS'd client-fd for
3270 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3271 Do blocking full-size writes, and reads under a timeout. Once both input
3272 channels are closed, exit the process.
3276 buf space to use for buffering
3277 bufsiz size of buffer
3278 pfd pipe filedescriptor array; [0] is comms to proxied process
3279 timeout per-read timeout, seconds
3283 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3287 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3288 int rc, i, fd_bits, nbytes;
3293 DEBUG(D_transport) debug_printf("proxy-proc final-pid %d\n", rc);
3294 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3297 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
3298 set_process_info("proxying TLS connection for continued transport");
3300 FD_SET(tls_out.active.sock, &rfds);
3301 FD_SET(pfd[0], &rfds);
3303 for (fd_bits = 3; fd_bits; )
3305 time_t time_left = timeout;
3306 time_t time_start = time(NULL);
3312 struct timeval tv = { time_left, 0 };
3315 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
3317 if (rc < 0 && errno == EINTR)
3318 if ((time_left -= time(NULL) - time_start) > 0) continue;
3322 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
3326 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
3328 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
3329 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
3333 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
3335 /* handle inbound data */
3336 if (FD_ISSET(tls_out.active.sock, &rfds))
3337 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
3340 FD_CLR(tls_out.active.sock, &rfds);
3341 shutdown(pfd[0], SHUT_WR);
3346 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3347 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
3349 else if (fd_bits & 1)
3350 FD_SET(tls_out.active.sock, &rfds);
3352 /* handle outbound data */
3353 if (FD_ISSET(pfd[0], &rfds))
3354 if ((rc = read(pfd[0], buf, bsize)) <= 0)
3357 tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
3362 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3363 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
3366 else if (fd_bits & 2)
3367 FD_SET(pfd[0], &rfds);
3371 if (f.running_in_test_harness) millisleep(100); /* let logging complete */
3372 exim_exit(0, US"TLS proxy");
3377 /*************************************************
3378 * Deliver address list to given host *
3379 *************************************************/
3381 /* If continue_hostname is not null, we get here only when continuing to
3382 deliver down an existing channel. The channel was passed as the standard
3383 input. TLS is never active on a passed channel; the previous process always
3384 closes it down before passing the connection on.
3386 Otherwise, we have to make a connection to the remote host, and do the
3387 initial protocol exchange.
3389 When running as an MUA wrapper, if the sender or any recipient is rejected,
3390 temporarily or permanently, we force failure for all recipients.
3393 addrlist chain of potential addresses to deliver; only those whose
3394 transport_return field is set to PENDING_DEFER are currently
3395 being processed; others should be skipped - they have either
3396 been delivered to an earlier host or IP address, or been
3397 failed by one of them.
3398 host host to deliver to
3399 host_af AF_INET or AF_INET6
3400 defport default TCP/IP port to use if host does not specify, in host
3402 interface interface to bind to, or NULL
3403 tblock transport instance block
3404 message_defer set TRUE if yield is OK, but all addresses were deferred
3405 because of a non-recipient, non-host failure, that is, a
3406 4xx response to MAIL FROM, DATA, or ".". This is a defer
3407 that is specific to the message.
3408 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
3409 a second attempt after TLS initialization fails
3411 Returns: OK - the connection was made and the delivery attempted;
3412 the result for each address is in its data block.
3413 DEFER - the connection could not be made, or something failed
3414 while setting up the SMTP session, or there was a
3415 non-message-specific error, such as a timeout.
3416 ERROR - a filter command is specified for this transport,
3417 and there was a problem setting it up; OR helo_data
3418 or add_headers or authenticated_sender is specified
3419 for this transport, and the string failed to expand
3423 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
3424 uschar *interface, transport_instance *tblock,
3425 BOOL *message_defer, BOOL suppress_tls)
3428 smtp_transport_options_block * ob = SOB tblock->options_block;
3432 struct timeval start_delivery_time;
3434 BOOL pass_message = FALSE;
3435 uschar *message = NULL;
3436 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
3440 gettimeofday(&start_delivery_time, NULL);
3441 suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
3442 *message_defer = FALSE;
3444 sx.addrlist = addrlist;
3445 sx.conn_args.host = host;
3446 sx.conn_args.host_af = host_af,
3448 sx.conn_args.interface = interface;
3449 sx.helo_data = NULL;
3450 sx.conn_args.tblock = tblock;
3452 sx.sync_addr = sx.first_addr = addrlist;
3454 /* Get the channel set up ready for a message (MAIL FROM being the next
3455 SMTP command to send */
3457 if ((rc = smtp_setup_conn(&sx, suppress_tls)) != OK)
3460 /* If there is a filter command specified for this transport, we can now
3461 set it up. This cannot be done until the identify of the host is known. */
3463 if (tblock->filter_command)
3465 transport_filter_timeout = tblock->filter_timeout;
3467 /* On failure, copy the error to all addresses, abandon the SMTP call, and
3470 if (!transport_set_up_command(&transport_filter_argv,
3471 tblock->filter_command, TRUE, DEFER, addrlist,
3472 string_sprintf("%.50s transport", tblock->name), NULL))
3474 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
3480 if ( transport_filter_argv
3481 && *transport_filter_argv
3482 && **transport_filter_argv
3483 && sx.peer_offered & OPTION_CHUNKING
3486 sx.peer_offered &= ~OPTION_CHUNKING;
3487 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
3491 /* For messages that have more than the maximum number of envelope recipients,
3492 we want to send several transactions down the same SMTP connection. (See
3493 comments in deliver.c as to how this reconciles, heuristically, with
3494 remote_max_parallel.) This optimization was added to Exim after the following
3495 code was already working. The simplest way to put it in without disturbing the
3496 code was to use a goto to jump back to this point when there is another
3497 transaction to handle. */
3500 sx.from_addr = return_path;
3501 sx.sync_addr = sx.first_addr;
3503 sx.send_rset = TRUE;
3504 sx.completed_addr = FALSE;
3507 /* If we are a continued-connection-after-verify the MAIL and RCPT
3508 commands were already sent; do not re-send but do mark the addrs as
3509 having been accepted up to RCPT stage. A traditional cont-conn
3510 always has a sequence number greater than one. */
3512 if (continue_hostname && continue_sequence == 1)
3514 address_item * addr;
3516 sx.peer_offered = smtp_peer_options;
3517 sx.pending_MAIL = FALSE;
3519 sx.next_addr = NULL;
3521 for (addr = addrlist; addr; addr = addr->next)
3522 addr->transport_return = PENDING_OK;
3526 /* Initiate a message transfer. */
3528 switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
3531 case -1: case -2: goto RESPONSE_FAILED;
3532 case -3: goto END_OFF;
3533 case -4: goto SEND_QUIT;
3534 default: goto SEND_FAILED;
3537 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3538 permanently or temporarily. We should have flushed and synced after the last
3546 for (a = sx.first_addr, cnt = 0; a && cnt < sx.max_rcpt; a = a->next, cnt++)
3547 if (a->transport_return != PENDING_OK)
3549 /*XXX could we find a better errno than 0 here? */
3550 set_errno_nohost(addrlist, 0, a->message, FAIL,
3551 testflag(a, af_pass_message));
3558 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3559 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3560 have a good recipient buffered up if we are pipelining. We don't want to waste
3561 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3562 are pipelining. The responses are all handled by sync_responses().
3563 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3566 if ( !(sx.peer_offered & OPTION_CHUNKING)
3567 && (sx.ok || (pipelining_active && !mua_wrapper)))
3569 int count = smtp_write_command(&sx, SCMD_FLUSH, "DATA\r\n");
3571 if (count < 0) goto SEND_FAILED;
3572 switch(sync_responses(&sx, count, sx.ok ? +1 : -1))
3574 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3575 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3578 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3579 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3580 case 0: break; /* No 2xx or 5xx, but no probs */
3582 case -1: goto END_OFF; /* Timeout on RCPT */
3584 #ifdef EXPERIMENTAL_PIPE_CONNECT
3585 case -4: HDEBUG(D_transport)
3586 debug_printf("failed reaping pipelined cmd responses\n");
3588 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3590 pipelining_active = FALSE;
3591 data_command = string_copy(big_buffer); /* Save for later error message */
3594 /* If there were no good recipients (but otherwise there have been no
3595 problems), just set ok TRUE, since we have handled address-specific errors
3596 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3597 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3598 well as body. Set the appropriate timeout value to be used for each chunk.
3599 (Haven't been able to make it work using select() for writing yet.) */
3601 if (!(sx.peer_offered & OPTION_CHUNKING) && !sx.ok)
3603 /* Save the first address of the next batch. */
3604 sx.first_addr = sx.next_addr;
3610 transport_ctx tctx = {
3611 .u = {.fd = sx.cctx.sock}, /*XXX will this need TLS info? */
3614 .check_string = US".",
3615 .escape_string = US"..", /* Escaping strings */
3617 topt_use_crlf | topt_escape_headers
3618 | (tblock->body_only ? topt_no_headers : 0)
3619 | (tblock->headers_only ? topt_no_body : 0)
3620 | (tblock->return_path_add ? topt_add_return_path : 0)
3621 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3622 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3625 /* If using CHUNKING we need a callback from the generic transport
3626 support to us, for the sending of BDAT smtp commands and the reaping
3627 of responses. The callback needs a whole bunch of state so set up
3628 a transport-context structure to be passed around. */
3630 if (sx.peer_offered & OPTION_CHUNKING)
3632 tctx.check_string = tctx.escape_string = NULL;
3633 tctx.options |= topt_use_bdat;
3634 tctx.chunk_cb = smtp_chunk_cmd_callback;
3635 sx.pending_BDAT = FALSE;
3636 sx.good_RCPT = sx.ok;
3638 tctx.smtp_context = &sx;
3641 tctx.options |= topt_end_dot;
3643 /* Save the first address of the next batch. */
3644 sx.first_addr = sx.next_addr;
3646 /* Responses from CHUNKING commands go in buffer. Otherwise,
3647 there has not been a response. */
3651 sigalrm_seen = FALSE;
3652 transport_write_timeout = ob->data_timeout;
3653 smtp_command = US"sending data block"; /* For error messages */
3654 DEBUG(D_transport|D_v)
3655 if (sx.peer_offered & OPTION_CHUNKING)
3656 debug_printf(" will write message using CHUNKING\n");
3658 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3659 transport_count = 0;
3661 #ifndef DISABLE_DKIM
3662 dkim_exim_sign_init();
3663 # ifdef EXPERIMENTAL_ARC
3665 uschar * s = ob->arc_sign;
3668 if (!(ob->dkim.arc_signspec = s = expand_string(s)))
3670 if (!f.expand_string_forcedfail)
3672 message = US"failed to expand arc_sign";
3679 /* Ask dkim code to hash the body for ARC */
3680 (void) arc_ams_setup_sign_bodyhash();
3681 ob->dkim.force_bodyhash = TRUE;
3686 sx.ok = dkim_transport_write_message(&tctx, &ob->dkim, CUSS &message);
3688 sx.ok = transport_write_message(&tctx, 0);
3691 /* transport_write_message() uses write() because it is called from other
3692 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3693 it can exit with "Broken pipe" as its error. This really means that the
3694 socket got closed at the far end. */
3696 transport_write_timeout = 0; /* for subsequent transports */
3698 /* Failure can either be some kind of I/O disaster (including timeout),
3699 or the failure of a transport filter or the expansion of added headers.
3700 Or, when CHUNKING, it can be a protocol-detected failure. */
3703 if (message) goto SEND_FAILED;
3704 else goto RESPONSE_FAILED;
3706 /* We used to send the terminating "." explicitly here, but because of
3707 buffering effects at both ends of TCP/IP connections, you don't gain
3708 anything by keeping it separate, so it might as well go in the final
3709 data buffer for efficiency. This is now done by setting the topt_end_dot
3712 smtp_command = US"end of data";
3714 if (sx.peer_offered & OPTION_CHUNKING && sx.cmd_count > 1)
3716 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3717 switch(sync_responses(&sx, sx.cmd_count-1, 0))
3719 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3720 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3723 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3724 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3725 case 0: break; /* No 2xx or 5xx, but no probs */
3727 case -1: goto END_OFF; /* Timeout on RCPT */
3729 #ifdef EXPERIMENTAL_PIPE_CONNECT
3730 case -4: HDEBUG(D_transport)
3731 debug_printf("failed reaping pipelined cmd responses\n");
3733 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3737 #ifndef DISABLE_PRDR
3738 /* For PRDR we optionally get a partial-responses warning followed by the
3739 individual responses, before going on with the overall response. If we don't
3740 get the warning then deal with per non-PRDR. */
3744 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '3', ob->final_timeout);
3745 if (!sx.ok && errno == 0) switch(sx.buffer[0])
3747 case '2': sx.prdr_active = FALSE;
3750 case '4': errno = ERRNO_DATA4XX;
3751 addrlist->more_errno |=
3752 ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3759 /* For non-PRDR SMTP, we now read a single response that applies to the
3760 whole message. If it is OK, then all the addresses have been delivered. */
3764 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3766 if (!sx.ok && errno == 0 && sx.buffer[0] == '4')
3768 errno = ERRNO_DATA4XX;
3769 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3773 /* For LMTP, we get back a response for every RCPT command that we sent;
3774 some may be accepted and some rejected. For those that get a response, their
3775 status is fixed; any that are accepted have been handed over, even if later
3776 responses crash - at least, that's how I read RFC 2033.
3778 If all went well, mark the recipient addresses as completed, record which
3779 host/IPaddress they were delivered to, and cut out RSET when sending another
3780 message down the same channel. Write the completed addresses to the journal
3781 now so that they are recorded in case there is a crash of hardware or
3782 software before the spool gets updated. Also record the final SMTP
3783 confirmation if needed (for SMTP only). */
3788 struct timeval delivery_time;
3790 uschar * conf = NULL;
3792 timesince(&delivery_time, &start_delivery_time);
3793 sx.send_rset = FALSE;
3794 pipelining_active = FALSE;
3796 /* Set up confirmation if needed - applies only to SMTP */
3799 #ifdef DISABLE_EVENT
3800 LOGGING(smtp_confirmation) &&
3805 const uschar *s = string_printing(sx.buffer);
3806 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3807 conf = (s == sx.buffer)? US string_copy(s) : US s;
3810 /* Process all transported addresses - for LMTP or PRDR, read a status for
3813 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3815 if (addr->transport_return != PENDING_OK) continue;
3817 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3818 remaining addresses. Otherwise, it's a return code for just the one
3819 address. For temporary errors, add a retry item for the address so that
3820 it doesn't get tried again too soon. */
3822 #ifndef DISABLE_PRDR
3823 if (sx.lmtp || sx.prdr_active)
3828 if (!smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3831 if (errno != 0 || sx.buffer[0] == 0) goto RESPONSE_FAILED;
3832 addr->message = string_sprintf(
3833 #ifndef DISABLE_PRDR
3834 "%s error after %s: %s", sx.prdr_active ? "PRDR":"LMTP",
3836 "LMTP error after %s: %s",
3838 data_command, string_printing(sx.buffer));
3839 setflag(addr, af_pass_message); /* Allow message to go to user */
3840 if (sx.buffer[0] == '5')
3841 addr->transport_return = FAIL;
3844 errno = ERRNO_DATA4XX;
3845 addr->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3846 addr->transport_return = DEFER;
3847 #ifndef DISABLE_PRDR
3848 if (!sx.prdr_active)
3850 retry_add_item(addr, addr->address_retry_key, 0);
3854 sx.completed_addr = TRUE; /* NOW we can set this flag */
3855 if (LOGGING(smtp_confirmation))
3857 const uschar *s = string_printing(sx.buffer);
3858 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3859 conf = (s == sx.buffer) ? US string_copy(s) : US s;
3863 /* SMTP, or success return from LMTP for this address. Pass back the
3864 actual host that was used. */
3866 addr->transport_return = OK;
3867 addr->more_errno = delivery_time.tv_sec;
3868 addr->delivery_usec = delivery_time.tv_usec;
3869 addr->host_used = host;
3870 addr->special_action = flag;
3871 addr->message = conf;
3873 if (tcp_out_fastopen)
3875 setflag(addr, af_tcp_fastopen_conn);
3876 if (tcp_out_fastopen >= TFO_USED_NODATA) setflag(addr, af_tcp_fastopen);
3877 if (tcp_out_fastopen >= TFO_USED_DATA) setflag(addr, af_tcp_fastopen_data);
3879 if (sx.pipelining_used) setflag(addr, af_pipelining);
3880 #ifdef EXPERIMENTAL_PIPE_CONNECT
3881 if (sx.early_pipe_active) setflag(addr, af_early_pipe);
3883 #ifndef DISABLE_PRDR
3884 if (sx.prdr_active) setflag(addr, af_prdr_used);
3886 if (sx.peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3889 #ifndef DISABLE_PRDR
3890 if (!sx.prdr_active)
3893 /* Update the journal. For homonymic addresses, use the base address plus
3894 the transport name. See lots of comments in deliver.c about the reasons
3895 for the complications when homonyms are involved. Just carry on after
3896 write error, as it may prove possible to update the spool file later. */
3898 if (testflag(addr, af_homonym))
3899 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3901 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3903 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx.buffer);
3904 len = Ustrlen(CS sx.buffer);
3905 if (write(journal_fd, sx.buffer, len) != len)
3906 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3907 "%s: %s", sx.buffer, strerror(errno));
3911 #ifndef DISABLE_PRDR
3914 const uschar * overall_message;
3916 /* PRDR - get the final, overall response. For any non-success
3917 upgrade all the address statuses. */
3919 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3923 if(errno == 0 && sx.buffer[0] == '4')
3925 errno = ERRNO_DATA4XX;
3926 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3928 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3929 if (sx.buffer[0] == '5' || addr->transport_return == OK)
3930 addr->transport_return = PENDING_OK; /* allow set_errno action */
3931 goto RESPONSE_FAILED;
3934 /* Append the overall response to the individual PRDR response for logging
3935 and update the journal, or setup retry. */
3937 overall_message = string_printing(sx.buffer);
3938 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3939 if (addr->transport_return == OK)
3940 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
3942 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3943 if (addr->transport_return == OK)
3945 if (testflag(addr, af_homonym))
3946 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3948 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3950 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx.buffer);
3951 len = Ustrlen(CS sx.buffer);
3952 if (write(journal_fd, sx.buffer, len) != len)
3953 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3954 "%s: %s", sx.buffer, strerror(errno));
3956 else if (addr->transport_return == DEFER)
3957 retry_add_item(addr, addr->address_retry_key, -2);
3961 /* Ensure the journal file is pushed out to disk. */
3963 if (EXIMfsync(journal_fd) < 0)
3964 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
3970 /* Handle general (not specific to one address) failures here. The value of ok
3971 is used to skip over this code on the falling through case. A timeout causes a
3972 deferral. Other errors may defer or fail according to the response code, and
3973 may set up a special errno value, e.g. after connection chopped, which is
3974 assumed if errno == 0 and there is no text in the buffer. If control reaches
3975 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
3976 the problem is not related to this specific message. */
3981 uschar * set_message;
3987 sx.send_quit = check_response(host, &save_errno, addrlist->more_errno,
3988 sx.buffer, &code, &message, &pass_message);
3996 message = string_sprintf("send() to %s [%s] failed: %s",
3997 host->name, host->address, message ? message : US strerror(save_errno));
3998 sx.send_quit = FALSE;
4006 sx.ok = FALSE; /* For when reached by GOTO */
4007 set_message = message;
4009 /* We want to handle timeouts after MAIL or "." and loss of connection after
4010 "." specially. They can indicate a problem with the sender address or with
4011 the contents of the message rather than a real error on the connection. These
4012 cases are treated in the same way as a 4xx response. This next bit of code
4013 does the classification. */
4020 message_error = TRUE;
4024 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
4025 Ustrncmp(smtp_command,"end ",4) == 0;
4028 case ERRNO_SMTPCLOSED:
4029 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
4033 message_error = FALSE;
4037 /* Handle the cases that are treated as message errors. These are:
4039 (a) negative response or timeout after MAIL
4040 (b) negative response after DATA
4041 (c) negative response or timeout or dropped connection after "."
4042 (d) utf8 support required and not offered
4044 It won't be a negative response or timeout after RCPT, as that is dealt
4045 with separately above. The action in all cases is to set an appropriate
4046 error code for all the addresses, but to leave yield set to OK because the
4047 host itself has not failed. Of course, it might in practice have failed
4048 when we've had a timeout, but if so, we'll discover that at the next
4049 delivery attempt. For a temporary error, set the message_defer flag, and
4050 write to the logs for information if this is not the last host. The error
4051 for the last host will be logged as part of the address's log line. */
4055 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
4057 /* If there's an errno, the message contains just the identity of
4062 else /* Anything other than 5 is treated as temporary */
4066 message = US string_sprintf("%s: %s", message, strerror(save_errno));
4068 write_logs(host, message, sx.first_addr ? sx.first_addr->basic_errno : 0);
4070 *message_defer = TRUE;
4074 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4075 ".", or some other transportation error. We defer all addresses and yield
4076 DEFER, except for the case of failed add_headers expansion, or a transport
4077 filter failure, when the yield should be ERROR, to stop it trying other
4082 #ifdef EXPERIMENTAL_PIPE_CONNECT
4083 /* If we were early-pipelinng and the actual EHLO response did not match
4084 the cached value we assumed, we could have detected it and passed a
4085 custom errno through to here. It would be nice to RSET and retry right
4086 away, but to reliably do that we eould need an extra synch point before
4087 we committed to data and that would discard half the gained roundrips.
4088 Or we could summarily drop the TCP connection. but that is also ugly.
4089 Instead, we ignore the possibility (having freshened the cache) and rely
4090 on the server telling us with a nonmessage error if we have tried to
4091 do something it no longer supports. */
4094 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
4095 save_errno == ERRNO_FILTER_FAIL) ? ERROR : DEFER;
4099 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
4100 #ifdef EXPERIMENTAL_DSN_INFO
4101 , sx.smtp_greeting, sx.helo_response
4107 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4108 SMTP session tidily. However, if there were too many addresses to send in one
4109 message (indicated by first_addr being non-NULL) we want to carry on with the
4110 rest of them. Also, it is desirable to send more than one message down the SMTP
4111 connection if there are several waiting, provided we haven't already sent so
4112 many as to hit the configured limit. The function transport_check_waiting looks
4113 for a waiting message and returns its id. Then transport_pass_socket tries to
4114 set up a continued delivery by passing the socket on to another process. The
4115 variable send_rset is FALSE if a message has just been successfully transfered.
4117 If we are already sending down a continued channel, there may be further
4118 addresses not yet delivered that are aimed at the same host, but which have not
4119 been passed in this run of the transport. In this case, continue_more will be
4120 true, and all we should do is send RSET if necessary, and return, leaving the
4123 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4124 do not want to continue with other messages down the same channel, because that
4125 can lead to looping between two or more messages, all with the same,
4126 temporarily failing address(es). [The retry information isn't updated yet, so
4127 new processes keep on trying.] We probably also don't want to try more of this
4128 message's addresses either.
4130 If we have started a TLS session, we have to end it before passing the
4131 connection to a new process. However, not all servers can handle this (Exim
4132 can), so we do not pass such a connection on if the host matches
4133 hosts_nopass_tls. */
4136 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4137 "yield=%d first_address is %sNULL\n", sx.ok, sx.send_quit,
4138 sx.send_rset, f.continue_more, yield, sx.first_addr ? "not " : "");
4140 if (sx.completed_addr && sx.ok && sx.send_quit)
4143 smtp_compare_t t_compare;
4145 t_compare.tblock = tblock;
4146 t_compare.current_sender_address = sender_address;
4148 if ( sx.first_addr != NULL
4152 ( tls_out.active.sock < 0 && !continue_proxy_cipher
4153 || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
4157 transport_check_waiting(tblock->name, host->name,
4158 tblock->connection_max_messages, new_message_id, &more,
4159 (oicf)smtp_are_same_identities, (void*)&t_compare)
4166 if (! (sx.ok = smtp_write_command(&sx, SCMD_FLUSH, "RSET\r\n") >= 0))
4168 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
4169 host->address, strerror(errno));
4170 sx.send_quit = FALSE;
4172 else if (! (sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4173 '2', ob->command_timeout)))
4176 sx.send_quit = check_response(host, &errno, 0, sx.buffer, &code, &msg,
4180 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
4181 host->name, host->address, msg);
4185 /* Either RSET was not needed, or it succeeded */
4192 int socket_fd = sx.cctx.sock;
4195 if (sx.first_addr != NULL) /* More addresses still to be sent */
4196 { /* in this run of the transport */
4197 continue_sequence++; /* Causes * in logging */
4201 /* Unless caller said it already has more messages listed for this host,
4202 pass the connection on to a new Exim process (below, the call to
4203 transport_pass_socket). If the caller has more ready, just return with
4204 the connection still open. */
4207 if (tls_out.active.sock >= 0)
4208 if ( f.continue_more
4209 || verify_check_given_host(CUSS &ob->hosts_noproxy_tls, host) == OK)
4211 /* Before passing the socket on, or returning to caller with it still
4212 open, we must shut down TLS. Not all MTAs allow for the continuation
4213 of the SMTP session when TLS is shut down. We test for this by sending
4214 a new EHLO. If we don't get a good response, we don't attempt to pass
4217 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4218 sx.cctx.tls_ctx = NULL;
4219 smtp_peer_options = smtp_peer_options_wrap;
4221 && smtp_write_command(&sx, SCMD_FLUSH, "EHLO %s\r\n", sx.helo_data)
4223 && smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4224 '2', ob->command_timeout);
4226 if (sx.ok && f.continue_more)
4227 return yield; /* More addresses for another run */
4231 /* Set up a pipe for proxying TLS for the new transport process */
4233 smtp_peer_options |= OPTION_TLS;
4234 if (sx.ok = (socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
4237 set_errno(sx.first_addr, errno, US"internal allocation problem",
4239 # ifdef EXPERIMENTAL_DSN_INFO
4240 , sx.smtp_greeting, sx.helo_response
4246 if (f.continue_more)
4247 return yield; /* More addresses for another run */
4249 /* If the socket is successfully passed, we mustn't send QUIT (or
4250 indeed anything!) from here. */
4252 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4253 propagate it from the initial
4255 if (sx.ok && transport_pass_socket(tblock->name, host->name,
4256 host->address, new_message_id, socket_fd))
4258 sx.send_quit = FALSE;
4260 /* We have passed the client socket to a fresh transport process.
4261 If TLS is still active, we need to proxy it for the transport we
4262 just passed the baton to. Fork a child to to do it, and return to
4263 get logging done asap. Which way to place the work makes assumptions
4264 about post-fork prioritisation which may not hold on all platforms. */
4266 if (tls_out.active.sock >= 0)
4269 if (pid == 0) /* child; fork again to disconnect totally */
4271 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
4272 /* does not return */
4273 smtp_proxy_tls(sx.cctx.tls_ctx, sx.buffer, sizeof(sx.buffer), pfd,
4274 ob->command_timeout);
4277 if (pid > 0) /* parent */
4279 DEBUG(D_transport) debug_printf("proxy-proc inter-pid %d\n", pid);
4281 /* tidy the inter-proc to disconn the proxy proc */
4282 waitpid(pid, NULL, 0);
4283 tls_close(sx.cctx.tls_ctx, TLS_NO_SHUTDOWN);
4284 sx.cctx.tls_ctx = NULL;
4285 (void)close(sx.cctx.sock);
4287 continue_transport = NULL;
4288 continue_hostname = NULL;
4291 log_write(0, LOG_PANIC_DIE, "fork failed");
4297 /* If RSET failed and there are addresses left, they get deferred. */
4299 set_errno(sx.first_addr, errno, msg, DEFER, FALSE, host
4300 #ifdef EXPERIMENTAL_DSN_INFO
4301 , sx.smtp_greeting, sx.helo_response
4307 /* End off tidily with QUIT unless the connection has died or the socket has
4308 been passed to another process. There has been discussion on the net about what
4309 to do after sending QUIT. The wording of the RFC suggests that it is necessary
4310 to wait for a response, but on the other hand, there isn't anything one can do
4311 with an error response, other than log it. Exim used to do that. However,
4312 further discussion suggested that it is positively advantageous not to wait for
4313 the response, but to close the session immediately. This is supposed to move
4314 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
4315 load from the server. (Hosts that are both servers and clients may not see much
4316 difference, of course.) Further discussion indicated that this was safe to do
4317 on Unix systems which have decent implementations of TCP/IP that leave the
4318 connection around for a while (TIME_WAIT) after the application has gone away.
4319 This enables the response sent by the server to be properly ACKed rather than
4320 timed out, as can happen on broken TCP/IP implementations on other OS.
4322 This change is being made on 31-Jul-98. After over a year of trouble-free
4323 operation, the old commented-out code was removed on 17-Sep-99. */
4326 if (sx.send_quit) (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4331 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4332 sx.cctx.tls_ctx = NULL;
4335 /* Close the socket, and return the appropriate value, first setting
4336 works because the NULL setting is passed back to the calling process, and
4337 remote_max_parallel is forced to 1 when delivering over an existing connection,
4339 If all went well and continue_more is set, we shouldn't actually get here if
4340 there are further addresses, as the return above will be taken. However,
4341 writing RSET might have failed, or there may be other addresses whose hosts are
4342 specified in the transports, and therefore not visible at top level, in which
4343 case continue_more won't get set. */
4345 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
4348 shutdown(sx.cctx.sock, SHUT_WR);
4349 millisleep(f.running_in_test_harness ? 200 : 20);
4350 if (fcntl(sx.cctx.sock, F_SETFL, O_NONBLOCK) == 0)
4351 for (rc = 16; read(sx.cctx.sock, sx.inbuffer, sizeof(sx.inbuffer)) > 0 && rc > 0;)
4352 rc--; /* drain socket */
4354 (void)close(sx.cctx.sock);
4356 #ifndef DISABLE_EVENT
4357 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
4360 continue_transport = NULL;
4361 continue_hostname = NULL;
4368 /*************************************************
4369 * Closedown entry point *
4370 *************************************************/
4372 /* This function is called when exim is passed an open smtp channel
4373 from another incarnation, but the message which it has been asked
4374 to deliver no longer exists. The channel is on stdin.
4376 We might do fancy things like looking for another message to send down
4377 the channel, but if the one we sought has gone, it has probably been
4378 delivered by some other process that itself will seek further messages,
4379 so just close down our connection.
4381 Argument: pointer to the transport instance block
4386 smtp_transport_closedown(transport_instance *tblock)
4388 smtp_transport_options_block * ob = SOB tblock->options_block;
4389 client_conn_ctx cctx;
4392 uschar inbuffer[4096];
4393 uschar outbuffer[16];
4395 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4396 cctx.sock = fileno(stdin);
4397 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
4399 sx.inblock.cctx = &cctx;
4400 sx.inblock.buffer = inbuffer;
4401 sx.inblock.buffersize = sizeof(inbuffer);
4402 sx.inblock.ptr = inbuffer;
4403 sx.inblock.ptrend = inbuffer;
4405 sx.outblock.cctx = &cctx;
4406 sx.outblock.buffersize = sizeof(outbuffer);
4407 sx.outblock.buffer = outbuffer;
4408 sx.outblock.ptr = outbuffer;
4409 sx.outblock.cmd_count = 0;
4410 sx.outblock.authenticating = FALSE;
4412 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4413 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
4414 (void)close(cctx.sock);
4419 /*************************************************
4420 * Prepare addresses for delivery *
4421 *************************************************/
4423 /* This function is called to flush out error settings from previous delivery
4424 attempts to other hosts. It also records whether we got here via an MX record
4425 or not in the more_errno field of the address. We are interested only in
4426 addresses that are still marked DEFER - others may have got delivered to a
4427 previously considered IP address. Set their status to PENDING_DEFER to indicate
4428 which ones are relevant this time.
4431 addrlist the list of addresses
4432 host the host we are delivering to
4434 Returns: the first address for this delivery
4437 static address_item *
4438 prepare_addresses(address_item *addrlist, host_item *host)
4440 address_item *first_addr = NULL;
4442 for (addr = addrlist; addr; addr = addr->next)
4443 if (addr->transport_return == DEFER)
4445 if (!first_addr) first_addr = addr;
4446 addr->transport_return = PENDING_DEFER;
4447 addr->basic_errno = 0;
4448 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
4449 addr->message = NULL;
4451 addr->cipher = NULL;
4452 addr->ourcert = NULL;
4453 addr->peercert = NULL;
4454 addr->peerdn = NULL;
4455 addr->ocsp = OCSP_NOT_REQ;
4457 #ifdef EXPERIMENTAL_DSN_INFO
4458 addr->smtp_greeting = NULL;
4459 addr->helo_response = NULL;
4467 /*************************************************
4468 * Main entry point *
4469 *************************************************/
4471 /* See local README for interface details. As this is a remote transport, it is
4472 given a chain of addresses to be delivered in one connection, if possible. It
4473 always returns TRUE, indicating that each address has its own independent
4474 status set, except if there is a setting up problem, in which case it returns
4478 smtp_transport_entry(
4479 transport_instance *tblock, /* data for this instantiation */
4480 address_item *addrlist) /* addresses we are working on */
4484 int hosts_defer = 0;
4486 int hosts_looked_up = 0;
4487 int hosts_retry = 0;
4488 int hosts_serial = 0;
4489 int hosts_total = 0;
4490 int total_hosts_tried = 0;
4492 BOOL expired = TRUE;
4493 uschar *expanded_hosts = NULL;
4495 uschar *tid = string_sprintf("%s transport", tblock->name);
4496 smtp_transport_options_block *ob = SOB tblock->options_block;
4497 host_item *hostlist = addrlist->host_list;
4502 debug_printf("%s transport entered\n", tblock->name);
4503 for (addr = addrlist; addr; addr = addr->next)
4504 debug_printf(" %s\n", addr->address);
4507 debug_printf("hostlist:\n");
4508 for (host = hostlist; host; host = host->next)
4509 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
4511 if (continue_hostname)
4512 debug_printf("already connected to %s [%s] (on fd %d)\n",
4513 continue_hostname, continue_host_address,
4514 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
4517 /* Set the flag requesting that these hosts be added to the waiting
4518 database if the delivery fails temporarily or if we are running with
4519 queue_smtp or a 2-stage queue run. This gets unset for certain
4520 kinds of error, typically those that are specific to the message. */
4522 update_waiting = TRUE;
4524 /* If a host list is not defined for the addresses - they must all have the
4525 same one in order to be passed to a single transport - or if the transport has
4526 a host list with hosts_override set, use the host list supplied with the
4527 transport. It is an error for this not to exist. */
4529 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
4530 if (tls_requiretls & REQUIRETLS_MSG)
4531 ob->tls_tempfail_tryclear = FALSE; /*XXX surely we should have a local for this
4532 rather than modifying the transport? */
4535 if (!hostlist || (ob->hosts_override && ob->hosts))
4539 addrlist->message = string_sprintf("%s transport called with no hosts set",
4541 addrlist->transport_return = PANIC;
4542 return FALSE; /* Only top address has status */
4545 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4548 /* If the transport's host list contains no '$' characters, and we are not
4549 randomizing, it is fixed and therefore a chain of hosts can be built once
4550 and for all, and remembered for subsequent use by other calls to this
4551 transport. If, on the other hand, the host list does contain '$', or we are
4552 randomizing its order, we have to rebuild it each time. In the fixed case,
4553 as the hosts string will never be used again, it doesn't matter that we
4554 replace all the : characters with zeros. */
4558 uschar *s = ob->hosts;
4560 if (Ustrchr(s, '$') != NULL)
4562 if (!(expanded_hosts = expand_string(s)))
4564 addrlist->message = string_sprintf("failed to expand list of hosts "
4565 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4566 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4567 return FALSE; /* Only top address has status */
4569 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4570 "\"%s\"\n", s, expanded_hosts);
4574 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4576 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4578 /* Check that the expansion yielded something useful. */
4582 string_sprintf("%s transport has empty hosts setting", tblock->name);
4583 addrlist->transport_return = PANIC;
4584 return FALSE; /* Only top address has status */
4587 /* If there was no expansion of hosts, save the host list for
4590 if (!expanded_hosts) ob->hostlist = hostlist;
4593 /* This is not the first time this transport has been run in this delivery;
4594 the host list was built previously. */
4597 hostlist = ob->hostlist;
4600 /* The host list was supplied with the address. If hosts_randomize is set, we
4601 must sort it into a random order if it did not come from MX records and has not
4602 already been randomized (but don't bother if continuing down an existing
4605 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4607 host_item *newlist = NULL;
4610 host_item *h = hostlist;
4611 hostlist = hostlist->next;
4613 h->sort_key = random_number(100);
4620 else if (h->sort_key < newlist->sort_key)
4627 host_item *hh = newlist;
4630 if (h->sort_key < hh->next->sort_key) break;
4638 hostlist = addrlist->host_list = newlist;
4641 /* Sort out the default port. */
4643 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4645 /* For each host-plus-IP-address on the list:
4647 . If this is a continued delivery and the host isn't the one with the
4648 current connection, skip.
4650 . If the status is unusable (i.e. previously failed or retry checked), skip.
4652 . If no IP address set, get the address, either by turning the name into
4653 an address, calling gethostbyname if gethostbyname is on, or by calling
4654 the DNS. The DNS may yield multiple addresses, in which case insert the
4655 extra ones into the list.
4657 . Get the retry data if not previously obtained for this address and set the
4658 field which remembers the state of this address. Skip if the retry time is
4659 not reached. If not, remember whether retry data was found. The retry string
4660 contains both the name and the IP address.
4662 . Scan the list of addresses and mark those whose status is DEFER as
4663 PENDING_DEFER. These are the only ones that will be processed in this cycle
4666 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4667 Some addresses may be successfully delivered, others may fail, and yet
4668 others may get temporary errors and so get marked DEFER.
4670 . The return from the delivery attempt is OK if a connection was made and a
4671 valid SMTP dialogue was completed. Otherwise it is DEFER.
4673 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4675 . If fail to connect, or other defer state, add a retry item.
4677 . If there are any addresses whose status is still DEFER, carry on to the
4678 next host/IPaddress, unless we have tried the number of hosts given
4679 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4680 there is some fancy logic for hosts_max_try that means its limit can be
4681 overstepped in some circumstances.
4683 If we get to the end of the list, all hosts have deferred at least one address,
4684 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4685 delivery attempt to those hosts whose last try was before the arrival time of
4686 the current message. To cope with this, we have to go round the loop a second
4687 time. After that, set the status and error data for any addresses that haven't
4688 had it set already. */
4690 for (cutoff_retry = 0;
4691 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4694 host_item *nexthost = NULL;
4695 int unexpired_hosts_tried = 0;
4696 BOOL continue_host_tried = FALSE;
4698 retry_non_continued:
4699 for (host = hostlist;
4701 && unexpired_hosts_tried < ob->hosts_max_try
4702 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4708 BOOL host_is_expired = FALSE;
4709 BOOL message_defer = FALSE;
4710 BOOL some_deferred = FALSE;
4711 address_item *first_addr = NULL;
4712 uschar *interface = NULL;
4713 uschar *retry_host_key = NULL;
4714 uschar *retry_message_key = NULL;
4715 uschar *serialize_key = NULL;
4717 /* Default next host is next host. :-) But this can vary if the
4718 hosts_max_try limit is hit (see below). It may also be reset if a host
4719 address is looked up here (in case the host was multihomed). */
4721 nexthost = host->next;
4723 /* If the address hasn't yet been obtained from the host name, look it up
4724 now, unless the host is already marked as unusable. If it is marked as
4725 unusable, it means that the router was unable to find its IP address (in
4726 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4727 the lookup failed last time. We don't get this far if *all* MX records
4728 point to non-existent hosts; that is treated as a hard error.
4730 We can just skip this host entirely. When the hosts came from the router,
4731 the address will timeout based on the other host(s); when the address is
4732 looked up below, there is an explicit retry record added.
4734 Note that we mustn't skip unusable hosts if the address is not unset; they
4735 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4739 int new_port, flags;
4742 if (host->status >= hstatus_unusable)
4744 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4749 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4751 /* The host name is permitted to have an attached port. Find it, and
4752 strip it from the name. Just remember it for now. */
4754 new_port = host_item_get_port(host);
4756 /* Count hosts looked up */
4760 /* Find by name if so configured, or if it's an IP address. We don't
4761 just copy the IP address, because we need the test-for-local to happen. */
4763 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4764 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4765 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4767 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4768 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4770 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4771 &ob->dnssec, /* domains for request/require */
4774 /* Update the host (and any additional blocks, resulting from
4775 multihoming) with a host-specific port, if any. */
4777 for (hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4779 /* Failure to find the host at this time (usually DNS temporary failure)
4780 is really a kind of routing failure rather than a transport failure.
4781 Therefore we add a retry item of the routing kind, not to stop us trying
4782 to look this name up here again, but to ensure the address gets timed
4783 out if the failures go on long enough. A complete failure at this point
4784 commonly points to a configuration error, but the best action is still
4785 to carry on for the next host. */
4787 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4789 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4791 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4792 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4793 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4794 host->status = hstatus_unusable;
4796 for (addr = addrlist; addr; addr = addr->next)
4798 if (addr->transport_return != DEFER) continue;
4799 addr->basic_errno = ERRNO_UNKNOWNHOST;
4800 addr->message = string_sprintf(
4801 rc == HOST_FIND_SECURITY
4802 ? "lookup of IP address for %s was insecure"
4803 : "failed to lookup IP address for %s",
4809 /* If the host is actually the local host, we may have a problem, or
4810 there may be some cunning configuration going on. In the problem case,
4811 log things and give up. The default transport status is already DEFER. */
4813 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4815 for (addr = addrlist; addr; addr = addr->next)
4817 addr->basic_errno = 0;
4818 addr->message = string_sprintf("%s transport found host %s to be "
4819 "local", tblock->name, host->name);
4823 } /* End of block for IP address lookup */
4825 /* If this is a continued delivery, we are interested only in the host
4826 which matches the name of the existing open channel. The check is put
4827 here after the local host lookup, in case the name gets expanded as a
4828 result of the lookup. Set expired FALSE, to save the outer loop executing
4831 if (continue_hostname)
4832 if ( Ustrcmp(continue_hostname, host->name) != 0
4833 || Ustrcmp(continue_host_address, host->address) != 0
4837 continue; /* With next host */
4840 continue_host_tried = TRUE;
4842 /* Reset the default next host in case a multihomed host whose addresses
4843 are not looked up till just above added to the host list. */
4845 nexthost = host->next;
4847 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4848 domain is in queue_smtp_domains, we don't actually want to attempt any
4849 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4850 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4851 were not in it. We don't want to hold up all SMTP deliveries! Except when
4852 doing a two-stage queue run, don't do this if forcing. */
4854 if ((!f.deliver_force || f.queue_2stage) && (f.queue_smtp ||
4855 match_isinlist(addrlist->domain,
4856 (const uschar **)&queue_smtp_domains, 0,
4857 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
4860 for (addr = addrlist; addr; addr = addr->next)
4861 if (addr->transport_return == DEFER)
4862 addr->message = US"domain matches queue_smtp_domains, or -odqs set";
4863 continue; /* With next host */
4866 /* Count hosts being considered - purely for an intelligent comment
4867 if none are usable. */
4871 /* Set $host and $host address now in case they are needed for the
4872 interface expansion or the serialize_hosts check; they remain set if an
4873 actual delivery happens. */
4875 deliver_host = host->name;
4876 deliver_host_address = host->address;
4877 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
4878 : host->dnssec == DS_NO ? US"no"
4881 /* Set up a string for adding to the retry key if the port number is not
4882 the standard SMTP port. A host may have its own port setting that overrides
4885 pistring = string_sprintf(":%d", host->port == PORT_NONE
4886 ? defport : host->port);
4887 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
4889 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4890 string is set, even if constant (as different transports can have different
4891 constant settings), we must add it to the key that is used for retries,
4892 because connections to the same host from a different interface should be
4893 treated separately. */
4895 host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
4896 if ((rs = ob->interface) && *rs)
4898 if (!smtp_get_interface(rs, host_af, addrlist, &interface, tid))
4900 pistring = string_sprintf("%s/%s", pistring, interface);
4903 /* The first time round the outer loop, check the status of the host by
4904 inspecting the retry data. The second time round, we are interested only
4905 in expired hosts that haven't been tried since this message arrived. */
4907 if (cutoff_retry == 0)
4910 /* Ensure the status of the address is set by checking retry data if
4911 necessary. There may be host-specific retry data (applicable to all
4912 messages) and also data for retries of a specific message at this host.
4913 If either of these retry records are actually read, the keys used are
4914 returned to save recomputing them later. */
4916 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4917 US"retry_include_ip_address", ob->retry_include_ip_address,
4918 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4919 continue; /* with next host */
4921 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
4922 incl_ip, &retry_host_key, &retry_message_key);
4924 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
4925 (host->address == NULL)? US"" : host->address, pistring,
4926 (host->status == hstatus_usable)? "usable" :
4927 (host->status == hstatus_unusable)? "unusable" :
4928 (host->status == hstatus_unusable_expired)? "unusable (expired)" : "?");
4930 /* Skip this address if not usable at this time, noting if it wasn't
4931 actually expired, both locally and in the address. */
4933 switch (host->status)
4935 case hstatus_unusable:
4937 setflag(addrlist, af_retry_skipped);
4940 case hstatus_unusable_expired:
4943 case hwhy_retry: hosts_retry++; break;
4944 case hwhy_failed: hosts_fail++; break;
4946 case hwhy_deferred: hosts_defer++; break;
4949 /* If there was a retry message key, implying that previously there
4950 was a message-specific defer, we don't want to update the list of
4951 messages waiting for these hosts. */
4953 if (retry_message_key) update_waiting = FALSE;
4954 continue; /* With the next host or IP address */
4958 /* Second time round the loop: if the address is set but expired, and
4959 the message is newer than the last try, let it through. */
4964 || host->status != hstatus_unusable_expired
4965 || host->last_try > received_time.tv_sec)
4967 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
4968 host->name, host->address, pistring);
4969 host_is_expired = TRUE;
4972 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
4973 it remains TRUE only if all hosts are expired and none are actually tried.
4978 /* If this host is listed as one to which access must be serialized,
4979 see if another Exim process has a connection to it, and if so, skip
4980 this host. If not, update the database to record our connection to it
4981 and remember this for later deletion. Do not do any of this if we are
4982 sending the message down a pre-existing connection. */
4984 if ( !continue_hostname
4985 && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
4987 serialize_key = string_sprintf("host-serialize-%s", host->name);
4988 if (!enq_start(serialize_key, 1))
4991 debug_printf("skipping host %s because another Exim process "
4992 "is connected to it\n", host->name);
4998 /* OK, we have an IP address that is not waiting for its retry time to
4999 arrive (it might be expired) OR (second time round the loop) we have an
5000 expired host that hasn't been tried since the message arrived. Have a go
5001 at delivering the message to it. First prepare the addresses by flushing
5002 out the result of previous attempts, and finding the first address that
5003 is still to be delivered. */
5005 first_addr = prepare_addresses(addrlist, host);
5007 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5008 message_id, host->name, host->address, addrlist->address,
5009 addrlist->next ? ", ..." : "");
5011 set_process_info("delivering %s to %s [%s] (%s%s)",
5012 message_id, host->name, host->address, addrlist->address,
5013 addrlist->next ? ", ..." : "");
5015 /* This is not for real; don't do the delivery. If there are
5016 any remaining hosts, list them. */
5021 set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
5022 for (addr = addrlist; addr; addr = addr->next)
5024 addr->host_used = host;
5025 addr->special_action = '*';
5026 addr->message = US"delivery bypassed by -N option";
5030 debug_printf("*** delivery by %s transport bypassed by -N option\n"
5031 "*** host and remaining hosts:\n", tblock->name);
5032 for (host2 = host; host2; host2 = host2->next)
5033 debug_printf(" %s [%s]\n", host2->name,
5034 host2->address ? host2->address : US"unset");
5039 /* This is for real. If the host is expired, we don't count it for
5040 hosts_max_retry. This ensures that all hosts must expire before an address
5041 is timed out, unless hosts_max_try_hardlimit (which protects against
5042 lunatic DNS configurations) is reached.
5044 If the host is not expired and we are about to hit the hosts_max_retry
5045 limit, check to see if there is a subsequent hosts with a different MX
5046 value. If so, make that the next host, and don't count this one. This is a
5047 heuristic to make sure that different MXs do get tried. With a normal kind
5048 of retry rule, they would get tried anyway when the earlier hosts were
5049 delayed, but if the domain has a "retry every time" type of rule - as is
5050 often used for the the very large ISPs, that won't happen. */
5055 /* Make a copy of the host if it is local to this invocation
5056 of the transport. */
5060 thost = store_get(sizeof(host_item));
5062 thost->name = string_copy(host->name);
5063 thost->address = string_copy(host->address);
5068 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
5072 debug_printf("hosts_max_try limit reached with this host\n");
5073 for (h = host; h; h = h->next) if (h->mx != host->mx)
5076 unexpired_hosts_tried--;
5077 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
5078 "and will be tried\n");
5083 /* Attempt the delivery. */
5085 total_hosts_tried++;
5086 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5087 &message_defer, FALSE);
5090 OK => connection made, each address contains its result;
5091 message_defer is set for message-specific defers (when all
5092 recipients are marked defer)
5093 DEFER => there was a non-message-specific delivery problem;
5094 ERROR => there was a problem setting up the arguments for a filter,
5095 or there was a problem with expanding added headers
5098 /* If the result is not OK, there was a non-message-specific problem.
5099 If the result is DEFER, we need to write to the logs saying what happened
5100 for this particular host, except in the case of authentication and TLS
5101 failures, where the log has already been written. If all hosts defer a
5102 general message is written at the end. */
5104 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
5105 && first_addr->basic_errno != ERRNO_TLSFAILURE)
5106 write_logs(host, first_addr->message, first_addr->basic_errno);
5108 #ifndef DISABLE_EVENT
5110 deferred_event_raise(first_addr, host);
5113 /* If STARTTLS was accepted, but there was a failure in setting up the
5114 TLS session (usually a certificate screwup), and the host is not in
5115 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5116 TLS forcibly turned off. We have to start from scratch with a new SMTP
5117 connection. That's why the retry is done from here, not from within
5118 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5119 session, so the in-clear transmission after those errors, if permitted,
5120 happens inside smtp_deliver().] */
5124 && first_addr->basic_errno == ERRNO_TLSFAILURE
5125 && ob->tls_tempfail_tryclear
5126 && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
5129 log_write(0, LOG_MAIN,
5130 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5131 first_addr->message, host->name, host->address);
5132 first_addr = prepare_addresses(addrlist, host);
5133 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5134 &message_defer, TRUE);
5135 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
5136 write_logs(host, first_addr->message, first_addr->basic_errno);
5137 # ifndef DISABLE_EVENT
5139 deferred_event_raise(first_addr, host);
5142 #endif /*SUPPORT_TLS*/
5145 /* Delivery attempt finished */
5147 rs = rc == OK ? US"OK"
5148 : rc == DEFER ? US"DEFER"
5149 : rc == ERROR ? US"ERROR"
5152 set_process_info("delivering %s: just tried %s [%s] for %s%s: result %s",
5153 message_id, host->name, host->address, addrlist->address,
5154 addrlist->next ? " (& others)" : "", rs);
5156 /* Release serialization if set up */
5158 if (serialize_key) enq_end(serialize_key);
5160 /* If the result is DEFER, or if a host retry record is known to exist, we
5161 need to add an item to the retry chain for updating the retry database
5162 at the end of delivery. We only need to add the item to the top address,
5163 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5164 for any other delivery attempts using the same address. (It is copied into
5165 the unusable tree at the outer level, so even if different address blocks
5166 contain the same address, it still won't get tried again.) */
5168 if (rc == DEFER || retry_host_key)
5170 int delete_flag = rc != DEFER ? rf_delete : 0;
5171 if (!retry_host_key)
5174 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5175 US"retry_include_ip_address", ob->retry_include_ip_address,
5176 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5177 incl_ip = TRUE; /* error; use most-specific retry record */
5179 retry_host_key = incl_ip
5180 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
5181 : string_sprintf("T:%S%s", host->name, pistring);
5184 /* If a delivery of another message over an existing SMTP connection
5185 yields DEFER, we do NOT set up retry data for the host. This covers the
5186 case when there are delays in routing the addresses in the second message
5187 that are so long that the server times out. This is alleviated by not
5188 routing addresses that previously had routing defers when handling an
5189 existing connection, but even so, this case may occur (e.g. if a
5190 previously happily routed address starts giving routing defers). If the
5191 host is genuinely down, another non-continued message delivery will
5192 notice it soon enough. */
5194 if (delete_flag != 0 || !continue_hostname)
5195 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
5197 /* We may have tried an expired host, if its retry time has come; ensure
5198 the status reflects the expiry for the benefit of any other addresses. */
5202 host->status = host_is_expired
5203 ? hstatus_unusable_expired : hstatus_unusable;
5204 host->why = hwhy_deferred;
5208 /* If message_defer is set (host was OK, but every recipient got deferred
5209 because of some message-specific problem), or if that had happened
5210 previously so that a message retry key exists, add an appropriate item
5211 to the retry chain. Note that if there was a message defer but now there is
5212 a host defer, the message defer record gets deleted. That seems perfectly
5213 reasonable. Also, stop the message from being remembered as waiting
5214 for specific hosts. */
5216 if (message_defer || retry_message_key)
5218 int delete_flag = message_defer ? 0 : rf_delete;
5219 if (!retry_message_key)
5222 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5223 US"retry_include_ip_address", ob->retry_include_ip_address,
5224 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5225 incl_ip = TRUE; /* error; use most-specific retry record */
5227 retry_message_key = incl_ip
5228 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
5230 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
5232 retry_add_item(addrlist, retry_message_key,
5233 rf_message | rf_host | delete_flag);
5234 update_waiting = FALSE;
5237 /* Any return other than DEFER (that is, OK or ERROR) means that the
5238 addresses have got their final statuses filled in for this host. In the OK
5239 case, see if any of them are deferred. */
5242 for (addr = addrlist; addr; addr = addr->next)
5243 if (addr->transport_return == DEFER)
5245 some_deferred = TRUE;
5249 /* If no addresses deferred or the result was ERROR, return. We do this for
5250 ERROR because a failing filter set-up or add_headers expansion is likely to
5251 fail for any host we try. */
5253 if (rc == ERROR || (rc == OK && !some_deferred))
5255 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5256 return TRUE; /* Each address has its status */
5259 /* If the result was DEFER or some individual addresses deferred, let
5260 the loop run to try other hosts with the deferred addresses, except for the
5261 case when we were trying to deliver down an existing channel and failed.
5262 Don't try any other hosts in this case. */
5264 if (continue_hostname) break;
5266 /* If the whole delivery, or some individual addresses, were deferred and
5267 there are more hosts that could be tried, do not count this host towards
5268 the hosts_max_try limit if the age of the message is greater than the
5269 maximum retry time for this host. This means we may try try all hosts,
5270 ignoring the limit, when messages have been around for some time. This is
5271 important because if we don't try all hosts, the address will never time
5272 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5274 if ((rc == DEFER || some_deferred) && nexthost)
5277 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
5279 if (retry && retry->rules)
5281 retry_rule *last_rule;
5282 for (last_rule = retry->rules;
5284 last_rule = last_rule->next);
5285 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
5287 else timedout = TRUE; /* No rule => timed out */
5291 unexpired_hosts_tried--;
5292 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
5293 "hosts_max_try (message older than host's retry time)\n");
5296 if (f.running_in_test_harness) millisleep(500); /* let server debug out */
5297 } /* End of loop for trying multiple hosts. */
5299 /* If we failed to find a matching host in the list, for an already-open
5300 connection, just close it and start over with the list. This can happen
5301 for routing that changes from run to run, or big multi-IP sites with
5304 if (continue_hostname && !continue_host_tried)
5306 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
5308 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
5310 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5312 /*XXX doublecheck that! */
5314 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
5316 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
5317 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
5318 cutthrough.cctx.tls_ctx = NULL;
5319 cutthrough.is_tls = FALSE;
5323 (void) write(fd, US"QUIT\r\n", 6);
5326 cutthrough.cctx.sock = -1;
5327 continue_hostname = NULL;
5328 goto retry_non_continued;
5331 /* This is the end of the loop that repeats iff expired is TRUE and
5332 ob->delay_after_cutoff is FALSE. The second time round we will
5333 try those hosts that haven't been tried since the message arrived. */
5337 debug_printf("all IP addresses skipped or deferred at least one address\n");
5338 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
5339 debug_printf("retrying IP addresses not tried since message arrived\n");
5344 /* Get here if all IP addresses are skipped or defer at least one address. In
5345 MUA wrapper mode, this will happen only for connection or other non-message-
5346 specific failures. Force the delivery status for all addresses to FAIL. */
5350 for (addr = addrlist; addr; addr = addr->next)
5351 addr->transport_return = FAIL;
5355 /* In the normal, non-wrapper case, add a standard message to each deferred
5356 address if there hasn't been an error, that is, if it hasn't actually been
5357 tried this time. The variable "expired" will be FALSE if any deliveries were
5358 actually tried, or if there was at least one host that was not expired. That
5359 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5360 a delivery has been tried, an error code will be set, and the failing of the
5361 message is handled by the retry code later.
5363 If queue_smtp is set, or this transport was called to send a subsequent message
5364 down an existing TCP/IP connection, and something caused the host not to be
5365 found, we end up here, but can detect these cases and handle them specially. */
5367 for (addr = addrlist; addr; addr = addr->next)
5369 /* If host is not NULL, it means that we stopped processing the host list
5370 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5371 means we need to behave as if some hosts were skipped because their retry
5372 time had not come. Specifically, this prevents the address from timing out.
5373 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5374 hosts were tried. */
5377 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5380 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5381 "hosts were tried\n");
5386 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5387 setflag(addr, af_retry_skipped);
5390 if (f.queue_smtp) /* no deliveries attempted */
5392 addr->transport_return = DEFER;
5393 addr->basic_errno = 0;
5394 addr->message = US"SMTP delivery explicitly queued";
5397 else if ( addr->transport_return == DEFER
5398 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
5402 addr->basic_errno = ERRNO_HRETRY;
5403 if (continue_hostname)
5404 addr->message = US"no host found for existing SMTP connection";
5407 setflag(addr, af_pass_message); /* This is not a security risk */
5408 addr->message = string_sprintf(
5409 "all hosts%s have been failing for a long time %s",
5410 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
5411 ob->delay_after_cutoff
5412 ? US"(and retry time not reached)"
5413 : US"and were last tried after this message arrived");
5415 /* If we are already using fallback hosts, or there are no fallback hosts
5416 defined, convert the result to FAIL to cause a bounce. */
5418 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
5419 addr->transport_return = FAIL;
5424 if (hosts_retry == hosts_total)
5425 s = "retry time not reached for any host%s";
5426 else if (hosts_fail == hosts_total)
5427 s = "all host address lookups%s failed permanently";
5428 else if (hosts_defer == hosts_total)
5429 s = "all host address lookups%s failed temporarily";
5430 else if (hosts_serial == hosts_total)
5431 s = "connection limit reached for all hosts%s";
5432 else if (hosts_fail+hosts_defer == hosts_total)
5433 s = "all host address lookups%s failed";
5435 s = "some host address lookups failed and retry time "
5436 "not reached for other hosts or connection limit reached%s";
5438 addr->message = string_sprintf(s,
5439 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
5444 /* Update the database which keeps information about which messages are waiting
5445 for which hosts to become available. For some message-specific errors, the
5446 update_waiting flag is turned off because we don't want follow-on deliveries in
5447 those cases. If this transport instance is explicitly limited to one message
5448 per connection then follow-on deliveries are not possible and there's no need
5449 to create/update the per-transport wait-<transport_name> database. */
5451 if (update_waiting && tblock->connection_max_messages != 1)
5452 transport_update_waiting(hostlist, tblock->name);
5456 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5458 return TRUE; /* Each address has its status */
5461 #endif /*!MACRO_PREDEF*/
5464 /* End of transport/smtp.c */