1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
12 /* Options specific to the smtp transport. This transport also supports LMTP
13 over TCP/IP. The options must be in alphabetic order (note that "_" comes
14 before the lower case letters). Some live in the transport_instance block so as
15 to be publicly visible; these are flagged with opt_public. */
17 optionlist smtp_transport_options[] = {
18 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
19 (void *)offsetof(transport_instance, expand_multi_domain) },
20 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
21 (void *)(offsetof(smtp_transport_options_block, expand_retry_include_ip_address)) },
23 { "address_retry_include_sender", opt_bool,
24 (void *)offsetof(smtp_transport_options_block, address_retry_include_sender) },
25 { "allow_localhost", opt_bool,
26 (void *)offsetof(smtp_transport_options_block, allow_localhost) },
27 #ifdef EXPERIMENTAL_ARC
28 { "arc_sign", opt_stringptr,
29 (void *)offsetof(smtp_transport_options_block, arc_sign) },
31 { "authenticated_sender", opt_stringptr,
32 (void *)offsetof(smtp_transport_options_block, authenticated_sender) },
33 { "authenticated_sender_force", opt_bool,
34 (void *)offsetof(smtp_transport_options_block, authenticated_sender_force) },
35 { "command_timeout", opt_time,
36 (void *)offsetof(smtp_transport_options_block, command_timeout) },
37 { "connect_timeout", opt_time,
38 (void *)offsetof(smtp_transport_options_block, connect_timeout) },
39 { "connection_max_messages", opt_int | opt_public,
40 (void *)offsetof(transport_instance, connection_max_messages) },
42 { "dane_require_tls_ciphers", opt_stringptr,
43 (void *)offsetof(smtp_transport_options_block, dane_require_tls_ciphers) },
45 { "data_timeout", opt_time,
46 (void *)offsetof(smtp_transport_options_block, data_timeout) },
47 { "delay_after_cutoff", opt_bool,
48 (void *)offsetof(smtp_transport_options_block, delay_after_cutoff) },
50 { "dkim_canon", opt_stringptr,
51 (void *)offsetof(smtp_transport_options_block, dkim.dkim_canon) },
52 { "dkim_domain", opt_stringptr,
53 (void *)offsetof(smtp_transport_options_block, dkim.dkim_domain) },
54 { "dkim_hash", opt_stringptr,
55 (void *)offsetof(smtp_transport_options_block, dkim.dkim_hash) },
56 { "dkim_identity", opt_stringptr,
57 (void *)offsetof(smtp_transport_options_block, dkim.dkim_identity) },
58 { "dkim_private_key", opt_stringptr,
59 (void *)offsetof(smtp_transport_options_block, dkim.dkim_private_key) },
60 { "dkim_selector", opt_stringptr,
61 (void *)offsetof(smtp_transport_options_block, dkim.dkim_selector) },
62 { "dkim_sign_headers", opt_stringptr,
63 (void *)offsetof(smtp_transport_options_block, dkim.dkim_sign_headers) },
64 { "dkim_strict", opt_stringptr,
65 (void *)offsetof(smtp_transport_options_block, dkim.dkim_strict) },
66 { "dkim_timestamps", opt_stringptr,
67 (void *)offsetof(smtp_transport_options_block, dkim.dkim_timestamps) },
69 { "dns_qualify_single", opt_bool,
70 (void *)offsetof(smtp_transport_options_block, dns_qualify_single) },
71 { "dns_search_parents", opt_bool,
72 (void *)offsetof(smtp_transport_options_block, dns_search_parents) },
73 { "dnssec_request_domains", opt_stringptr,
74 (void *)offsetof(smtp_transport_options_block, dnssec.request) },
75 { "dnssec_require_domains", opt_stringptr,
76 (void *)offsetof(smtp_transport_options_block, dnssec.require) },
77 { "dscp", opt_stringptr,
78 (void *)offsetof(smtp_transport_options_block, dscp) },
79 { "fallback_hosts", opt_stringptr,
80 (void *)offsetof(smtp_transport_options_block, fallback_hosts) },
81 { "final_timeout", opt_time,
82 (void *)offsetof(smtp_transport_options_block, final_timeout) },
83 { "gethostbyname", opt_bool,
84 (void *)offsetof(smtp_transport_options_block, gethostbyname) },
85 { "helo_data", opt_stringptr,
86 (void *)offsetof(smtp_transport_options_block, helo_data) },
87 { "hosts", opt_stringptr,
88 (void *)offsetof(smtp_transport_options_block, hosts) },
89 { "hosts_avoid_esmtp", opt_stringptr,
90 (void *)offsetof(smtp_transport_options_block, hosts_avoid_esmtp) },
91 { "hosts_avoid_pipelining", opt_stringptr,
92 (void *)offsetof(smtp_transport_options_block, hosts_avoid_pipelining) },
94 { "hosts_avoid_tls", opt_stringptr,
95 (void *)offsetof(smtp_transport_options_block, hosts_avoid_tls) },
97 { "hosts_max_try", opt_int,
98 (void *)offsetof(smtp_transport_options_block, hosts_max_try) },
99 { "hosts_max_try_hardlimit", opt_int,
100 (void *)offsetof(smtp_transport_options_block, hosts_max_try_hardlimit) },
102 { "hosts_nopass_tls", opt_stringptr,
103 (void *)offsetof(smtp_transport_options_block, hosts_nopass_tls) },
104 { "hosts_noproxy_tls", opt_stringptr,
105 (void *)offsetof(smtp_transport_options_block, hosts_noproxy_tls) },
107 { "hosts_override", opt_bool,
108 (void *)offsetof(smtp_transport_options_block, hosts_override) },
109 { "hosts_randomize", opt_bool,
110 (void *)offsetof(smtp_transport_options_block, hosts_randomize) },
111 #if defined(SUPPORT_TLS) && !defined(DISABLE_OCSP)
112 { "hosts_request_ocsp", opt_stringptr,
113 (void *)offsetof(smtp_transport_options_block, hosts_request_ocsp) },
115 { "hosts_require_auth", opt_stringptr,
116 (void *)offsetof(smtp_transport_options_block, hosts_require_auth) },
119 { "hosts_require_dane", opt_stringptr,
120 (void *)offsetof(smtp_transport_options_block, hosts_require_dane) },
122 # ifndef DISABLE_OCSP
123 { "hosts_require_ocsp", opt_stringptr,
124 (void *)offsetof(smtp_transport_options_block, hosts_require_ocsp) },
126 { "hosts_require_tls", opt_stringptr,
127 (void *)offsetof(smtp_transport_options_block, hosts_require_tls) },
129 { "hosts_try_auth", opt_stringptr,
130 (void *)offsetof(smtp_transport_options_block, hosts_try_auth) },
131 { "hosts_try_chunking", opt_stringptr,
132 (void *)offsetof(smtp_transport_options_block, hosts_try_chunking) },
133 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
134 { "hosts_try_dane", opt_stringptr,
135 (void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
137 { "hosts_try_fastopen", opt_stringptr,
138 (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
140 { "hosts_try_prdr", opt_stringptr,
141 (void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
144 { "hosts_verify_avoid_tls", opt_stringptr,
145 (void *)offsetof(smtp_transport_options_block, hosts_verify_avoid_tls) },
147 { "interface", opt_stringptr,
148 (void *)offsetof(smtp_transport_options_block, interface) },
149 { "keepalive", opt_bool,
150 (void *)offsetof(smtp_transport_options_block, keepalive) },
151 { "lmtp_ignore_quota", opt_bool,
152 (void *)offsetof(smtp_transport_options_block, lmtp_ignore_quota) },
153 { "max_rcpt", opt_int | opt_public,
154 (void *)offsetof(transport_instance, max_addresses) },
155 { "multi_domain", opt_expand_bool | opt_public,
156 (void *)offsetof(transport_instance, multi_domain) },
157 { "port", opt_stringptr,
158 (void *)offsetof(smtp_transport_options_block, port) },
159 { "protocol", opt_stringptr,
160 (void *)offsetof(smtp_transport_options_block, protocol) },
161 { "retry_include_ip_address", opt_expand_bool,
162 (void *)offsetof(smtp_transport_options_block, retry_include_ip_address) },
163 { "serialize_hosts", opt_stringptr,
164 (void *)offsetof(smtp_transport_options_block, serialize_hosts) },
165 { "size_addition", opt_int,
166 (void *)offsetof(smtp_transport_options_block, size_addition) },
168 { "socks_proxy", opt_stringptr,
169 (void *)offsetof(smtp_transport_options_block, socks_proxy) },
172 { "tls_certificate", opt_stringptr,
173 (void *)offsetof(smtp_transport_options_block, tls_certificate) },
174 { "tls_crl", opt_stringptr,
175 (void *)offsetof(smtp_transport_options_block, tls_crl) },
176 { "tls_dh_min_bits", opt_int,
177 (void *)offsetof(smtp_transport_options_block, tls_dh_min_bits) },
178 { "tls_privatekey", opt_stringptr,
179 (void *)offsetof(smtp_transport_options_block, tls_privatekey) },
180 { "tls_require_ciphers", opt_stringptr,
181 (void *)offsetof(smtp_transport_options_block, tls_require_ciphers) },
182 { "tls_sni", opt_stringptr,
183 (void *)offsetof(smtp_transport_options_block, tls_sni) },
184 { "tls_tempfail_tryclear", opt_bool,
185 (void *)offsetof(smtp_transport_options_block, tls_tempfail_tryclear) },
186 { "tls_try_verify_hosts", opt_stringptr,
187 (void *)offsetof(smtp_transport_options_block, tls_try_verify_hosts) },
188 { "tls_verify_cert_hostnames", opt_stringptr,
189 (void *)offsetof(smtp_transport_options_block,tls_verify_cert_hostnames)},
190 { "tls_verify_certificates", opt_stringptr,
191 (void *)offsetof(smtp_transport_options_block, tls_verify_certificates) },
192 { "tls_verify_hosts", opt_stringptr,
193 (void *)offsetof(smtp_transport_options_block, tls_verify_hosts) },
196 { "utf8_downconvert", opt_stringptr,
197 (void *)offsetof(smtp_transport_options_block, utf8_downconvert) },
201 /* Size of the options list. An extern variable has to be used so that its
202 address can appear in the tables drtables.c. */
204 int smtp_transport_options_count = nelem(smtp_transport_options);
210 smtp_transport_options_block smtp_transport_option_defaults = {0};
211 void smtp_transport_init(transport_instance *tblock) {}
212 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
213 void smtp_transport_closedown(transport_instance *tblock) {}
215 #else /*!MACRO_PREDEF*/
218 /* Default private options block for the smtp transport. */
220 smtp_transport_options_block smtp_transport_option_defaults = {
222 .fallback_hosts = NULL,
224 .fallback_hostlist = NULL,
225 .helo_data = US"$primary_hostname",
228 .protocol = US"smtp",
230 .serialize_hosts = NULL,
231 .hosts_try_auth = NULL,
232 .hosts_require_auth = NULL,
233 .hosts_try_chunking = US"*",
235 .hosts_try_dane = NULL,
236 .hosts_require_dane = NULL,
237 .dane_require_tls_ciphers = NULL,
239 .hosts_try_fastopen = NULL,
241 .hosts_try_prdr = US"*",
244 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
245 .hosts_require_ocsp = NULL,
247 .hosts_require_tls = NULL,
248 .hosts_avoid_tls = NULL,
249 .hosts_verify_avoid_tls = NULL,
250 .hosts_avoid_pipelining = NULL,
251 .hosts_avoid_esmtp = NULL,
253 .hosts_nopass_tls = NULL,
254 .hosts_noproxy_tls = US"*",
256 .command_timeout = 5*60,
257 .connect_timeout = 5*60,
258 .data_timeout = 5*60,
259 .final_timeout = 10*60,
260 .size_addition = 1024,
262 .hosts_max_try_hardlimit = 50,
263 .address_retry_include_sender = TRUE,
264 .allow_localhost = FALSE,
265 .authenticated_sender_force = FALSE,
266 .gethostbyname = FALSE,
267 .dns_qualify_single = TRUE,
268 .dns_search_parents = FALSE,
269 .dnssec = { .request=NULL, .require=NULL },
270 .delay_after_cutoff = TRUE,
271 .hosts_override = FALSE,
272 .hosts_randomize = FALSE,
274 .lmtp_ignore_quota = FALSE,
275 .expand_retry_include_ip_address = NULL,
276 .retry_include_ip_address = TRUE,
281 .tls_certificate = NULL,
283 .tls_privatekey = NULL,
284 .tls_require_ciphers = NULL,
286 .tls_verify_certificates = US"system",
287 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
288 .tls_tempfail_tryclear = TRUE,
289 .tls_verify_hosts = NULL,
290 .tls_try_verify_hosts = US"*",
291 .tls_verify_cert_hostnames = US"*",
294 .utf8_downconvert = NULL,
298 {.dkim_domain = NULL,
299 .dkim_identity = NULL,
300 .dkim_private_key = NULL,
301 .dkim_selector = NULL,
303 .dkim_sign_headers = NULL,
305 .dkim_hash = US"sha256",
306 .dkim_timestamps = NULL,
307 .dot_stuffed = FALSE,
308 .force_bodyhash = FALSE,
309 # ifdef EXPERIMENTAL_ARC
310 .arc_signspec = NULL,
313 # ifdef EXPERIMENTAL_ARC
319 /* some DSN flags for use later */
321 static int rf_list[] = {rf_notify_never, rf_notify_success,
322 rf_notify_failure, rf_notify_delay };
324 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
330 static uschar *smtp_command; /* Points to last cmd for error messages */
331 static uschar *mail_command; /* Points to MAIL cmd for error messages */
332 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
333 static BOOL update_waiting; /* TRUE to update the "wait" database */
335 /*XXX move to smtp_context */
336 static BOOL pipelining_active; /* current transaction is in pipe mode */
339 /*************************************************
340 * Setup entry point *
341 *************************************************/
343 /* This function is called when the transport is about to be used,
344 but before running it in a sub-process. It is used for two things:
346 (1) To set the fallback host list in addresses, when delivering.
347 (2) To pass back the interface, port, protocol, and other options, for use
348 during callout verification.
351 tblock pointer to the transport instance block
352 addrlist list of addresses about to be transported
353 tf if not NULL, pointer to block in which to return options
354 uid the uid that will be set (not used)
355 gid the gid that will be set (not used)
356 errmsg place for error message (not used)
358 Returns: OK always (FAIL, DEFER not used)
362 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
363 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
365 smtp_transport_options_block *ob =
366 (smtp_transport_options_block *)(tblock->options_block);
368 errmsg = errmsg; /* Keep picky compilers happy */
372 /* Pass back options if required. This interface is getting very messy. */
376 tf->interface = ob->interface;
378 tf->protocol = ob->protocol;
379 tf->hosts = ob->hosts;
380 tf->hosts_override = ob->hosts_override;
381 tf->hosts_randomize = ob->hosts_randomize;
382 tf->gethostbyname = ob->gethostbyname;
383 tf->qualify_single = ob->dns_qualify_single;
384 tf->search_parents = ob->dns_search_parents;
385 tf->helo_data = ob->helo_data;
388 /* Set the fallback host list for all the addresses that don't have fallback
389 host lists, provided that the local host wasn't present in the original host
392 if (!testflag(addrlist, af_local_host_removed))
393 for (; addrlist; addrlist = addrlist->next)
394 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
401 /*************************************************
402 * Initialization entry point *
403 *************************************************/
405 /* Called for each instance, after its options have been read, to
406 enable consistency checks to be done, or anything else that needs
409 Argument: pointer to the transport instance block
414 smtp_transport_init(transport_instance *tblock)
416 smtp_transport_options_block *ob =
417 (smtp_transport_options_block *)(tblock->options_block);
419 /* Retry_use_local_part defaults FALSE if unset */
421 if (tblock->retry_use_local_part == TRUE_UNSET)
422 tblock->retry_use_local_part = FALSE;
424 /* Set the default port according to the protocol */
426 if (ob->port == NULL)
427 ob->port = (strcmpic(ob->protocol, US"lmtp") == 0)? US"lmtp" :
428 (strcmpic(ob->protocol, US"smtps") == 0)? US"smtps" : US"smtp";
430 /* Set up the setup entry point, to be called before subprocesses for this
433 tblock->setup = smtp_transport_setup;
435 /* Complain if any of the timeouts are zero. */
437 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
438 ob->final_timeout <= 0)
439 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
440 "command, data, or final timeout value is zero for %s transport",
443 /* If hosts_override is set and there are local hosts, set the global
444 flag that stops verify from showing router hosts. */
446 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
448 /* If there are any fallback hosts listed, build a chain of host items
449 for them, but do not do any lookups at this time. */
451 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
458 /*************************************************
459 * Set delivery info into all active addresses *
460 *************************************************/
462 /* Only addresses whose status is >= PENDING are relevant. A lesser
463 status means that an address is not currently being processed.
466 addrlist points to a chain of addresses
467 errno_value to put in each address's errno field
468 msg to put in each address's message field
469 rc to put in each address's transport_return field
470 pass_message if TRUE, set the "pass message" flag in the address
471 host if set, mark addrs as having used this host
472 smtp_greeting from peer
473 helo_response from peer
475 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
476 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
477 this particular type of timeout.
483 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
484 BOOL pass_message, host_item * host
485 #ifdef EXPERIMENTAL_DSN_INFO
486 , const uschar * smtp_greeting, const uschar * helo_response
492 if (errno_value == ERRNO_CONNECTTIMEOUT)
494 errno_value = ETIMEDOUT;
495 orvalue = RTEF_CTOUT;
497 for (addr = addrlist; addr; addr = addr->next)
498 if (addr->transport_return >= PENDING)
500 addr->basic_errno = errno_value;
501 addr->more_errno |= orvalue;
505 if (pass_message) setflag(addr, af_pass_message);
507 addr->transport_return = rc;
510 addr->host_used = host;
511 #ifdef EXPERIMENTAL_DSN_INFO
513 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
514 addr->smtp_greeting = smtp_greeting;
517 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
518 addr->helo_response = helo_response;
525 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
528 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
529 #ifdef EXPERIMENTAL_DSN_INFO
536 /*************************************************
537 * Check an SMTP response *
538 *************************************************/
540 /* This function is given an errno code and the SMTP response buffer
541 to analyse, together with the host identification for generating messages. It
542 sets an appropriate message and puts the first digit of the response code into
543 the yield variable. If no response was actually read, a suitable digit is
547 host the current host, to get its name for messages
548 errno_value pointer to the errno value
549 more_errno from the top address for use with ERRNO_FILTER_FAIL
550 buffer the SMTP response buffer
551 yield where to put a one-digit SMTP response code
552 message where to put an error message
553 pass_message set TRUE if message is an SMTP response
555 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
559 check_response(host_item *host, int *errno_value, int more_errno,
560 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
562 uschar * pl = pipelining_active ? US"pipelined " : US"";
565 *yield = '4'; /* Default setting is to give a temporary error */
569 case ETIMEDOUT: /* Handle response timeout */
570 *message = US string_sprintf("SMTP timeout after %s%s",
572 if (transport_count > 0)
573 *message = US string_sprintf("%s (%d bytes written)", *message,
577 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
578 s = string_printing(buffer);
579 while (isspace(*s)) s++;
581 ? string_sprintf("Malformed SMTP reply (an empty line) "
582 "in response to %s%s", pl, smtp_command)
583 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
584 pl, smtp_command, s);
587 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
588 can't send QUIT as we mustn't end the DATA. */
589 *message = string_sprintf("transport filter process failed (%d)%s",
591 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
594 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
595 can't send QUIT as we mustn't end the DATA. */
597 string_sprintf("failed to expand headers_add or headers_remove: %s",
598 expand_string_message);
601 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
602 *message = string_sprintf("failed to write a data block");
606 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
607 *message = US"utf8 support required but not offered for forwarding";
608 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
613 /* Handle error responses from the remote mailer. */
617 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
618 "%s", pl, smtp_command, s = string_printing(buffer));
619 *pass_message = TRUE;
624 /* No data was read. If there is no errno, this must be the EOF (i.e.
625 connection closed) case, which causes deferral. An explicit connection reset
626 error has the same effect. Otherwise, put the host's identity in the message,
627 leaving the errno value to be interpreted as well. In all cases, we have to
628 assume the connection is now dead. */
630 if (*errno_value == 0 || *errno_value == ECONNRESET)
632 *errno_value = ERRNO_SMTPCLOSED;
633 *message = US string_sprintf("Remote host closed connection "
634 "in response to %s%s", pl, smtp_command);
637 *message = US string_sprintf("%s [%s]", host->name, host->address);
644 /*************************************************
645 * Write error message to logs *
646 *************************************************/
648 /* This writes to the main log and to the message log.
651 host the current host
652 detail the current message (addr_item->message)
653 basic_errno the errno (addr_item->basic_errno)
659 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
663 uschar *message = LOGGING(outgoing_port)
664 ? string_sprintf("H=%s [%s]:%d", host->name, host->address,
665 host->port == PORT_NONE ? 25 : host->port)
666 : string_sprintf("H=%s [%s]", host->name, host->address);
670 message = string_sprintf("%s: %s", message, suffix);
672 message = string_sprintf("%s: %s", message, strerror(basic_errno));
675 message = string_sprintf("%s %s", message, exim_errstr(basic_errno));
677 log_write(0, LOG_MAIN, "%s", message);
678 deliver_msglog("%s %s\n", tod_stamp(tod_log), message);
682 msglog_line(host_item * host, uschar * message)
684 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
685 host->name, host->address, message);
690 #ifndef DISABLE_EVENT
691 /*************************************************
692 * Post-defer action *
693 *************************************************/
695 /* This expands an arbitrary per-transport string.
696 It might, for example, be used to write to the database log.
699 addr the address item containing error information
700 host the current host
706 deferred_event_raise(address_item *addr, host_item *host)
708 uschar * action = addr->transport->event_action;
709 const uschar * save_domain;
715 save_domain = deliver_domain;
716 save_local = deliver_localpart;
718 /*XXX would ip & port already be set up? */
719 deliver_host_address = string_copy(host->address);
720 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
721 event_defer_errno = addr->basic_errno;
723 router_name = addr->router->name;
724 transport_name = addr->transport->name;
725 deliver_domain = addr->domain;
726 deliver_localpart = addr->local_part;
728 (void) event_raise(action, US"msg:host:defer",
730 ? addr->basic_errno > 0
731 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
732 : string_copy(addr->message)
733 : addr->basic_errno > 0
734 ? string_copy(US strerror(addr->basic_errno))
737 deliver_localpart = save_local;
738 deliver_domain = save_domain;
739 router_name = transport_name = NULL;
743 /*************************************************
744 * Synchronize SMTP responses *
745 *************************************************/
747 /* This function is called from smtp_deliver() to receive SMTP responses from
748 the server, and match them up with the commands to which they relate. When
749 PIPELINING is not in use, this function is called after every command, and is
750 therefore somewhat over-engineered, but it is simpler to use a single scheme
751 that works both with and without PIPELINING instead of having two separate sets
754 The set of commands that are buffered up with pipelining may start with MAIL
755 and may end with DATA; in between are RCPT commands that correspond to the
756 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
757 etc.) are never buffered.
759 Errors after MAIL or DATA abort the whole process leaving the response in the
760 buffer. After MAIL, pending responses are flushed, and the original command is
761 re-instated in big_buffer for error messages. For RCPT commands, the remote is
762 permitted to reject some recipient addresses while accepting others. However
763 certain errors clearly abort the whole process. Set the value in
764 transport_return to PENDING_OK if the address is accepted. If there is a
765 subsequent general error, it will get reset accordingly. If not, it will get
766 converted to OK at the end.
769 sx smtp connection context
770 count the number of responses to read
771 pending_DATA 0 if last command sent was not DATA
772 +1 if previously had a good recipient
773 -1 if not previously had a good recipient
775 Returns: 3 if at least one address had 2xx and one had 5xx
776 2 if at least one address had 5xx but none had 2xx
777 1 if at least one host had a 2xx response, but none had 5xx
778 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
779 -1 timeout while reading RCPT response
780 -2 I/O or other non-response error for RCPT
781 -3 DATA or MAIL failed - errno and buffer set
785 sync_responses(smtp_context * sx, int count, int pending_DATA)
787 address_item *addr = sx->sync_addr;
788 smtp_transport_options_block *ob =
789 (smtp_transport_options_block *)sx->tblock->options_block;
792 /* Handle the response for a MAIL command. On error, reinstate the original
793 command in big_buffer for error message use, and flush any further pending
794 responses before returning, except after I/O errors and timeouts. */
796 if (sx->pending_MAIL)
798 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
800 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
801 '2', ob->command_timeout))
803 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
804 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
805 if (errno == 0 && sx->buffer[0] != 0)
807 uschar flushbuffer[4096];
809 if (sx->buffer[0] == '4')
811 save_errno = ERRNO_MAIL4XX;
812 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
816 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
817 '2', ob->command_timeout)
818 && (errno != 0 || flushbuffer[0] == 0))
824 if (pending_DATA) count--; /* Number of RCPT responses to come */
825 while (count-- > 0) /* Mark any pending addrs with the host used */
827 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
828 addr->host_used = sx->host;
835 if (pending_DATA) count--; /* Number of RCPT responses to come */
837 /* Read and handle the required number of RCPT responses, matching each one up
838 with an address by scanning for the next address whose status is PENDING_DEFER.
843 while (addr->transport_return != PENDING_DEFER)
844 if (!(addr = addr->next))
847 /* The address was accepted */
848 addr->host_used = sx->host;
850 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
851 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
852 '2', ob->command_timeout))
855 addr->transport_return = PENDING_OK;
857 /* If af_dr_retry_exists is set, there was a routing delay on this address;
858 ensure that any address-specific retry record is expunged. We do this both
859 for the basic key and for the version that also includes the sender. */
861 if (testflag(addr, af_dr_retry_exists))
863 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
865 retry_add_item(addr, altkey, rf_delete);
866 retry_add_item(addr, addr->address_retry_key, rf_delete);
870 /* Timeout while reading the response */
872 else if (errno == ETIMEDOUT)
874 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
875 transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes));
876 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
877 retry_add_item(addr, addr->address_retry_key, 0);
878 update_waiting = FALSE;
882 /* Handle other errors in obtaining an SMTP response by returning -1. This
883 will cause all the addresses to be deferred. Restore the SMTP command in
884 big_buffer for which we are checking the response, so the error message
887 else if (errno != 0 || sx->buffer[0] == 0)
889 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
890 transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes));
894 /* Handle SMTP permanent and temporary response codes. */
899 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
900 "%s", transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes),
901 string_printing(sx->buffer));
902 setflag(addr, af_pass_message);
904 msglog_line(sx->host, addr->message);
906 /* The response was 5xx */
908 if (sx->buffer[0] == '5')
910 addr->transport_return = FAIL;
914 /* The response was 4xx */
918 addr->transport_return = DEFER;
919 addr->basic_errno = ERRNO_RCPT4XX;
920 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
924 #ifndef DISABLE_EVENT
925 event_defer_errno = addr->more_errno;
926 msg_event_raise(US"msg:rcpt:host:defer", addr);
929 /* Log temporary errors if there are more hosts to be tried.
930 If not, log this last one in the == line. */
933 log_write(0, LOG_MAIN, "H=%s [%s]: %s",
934 sx->host->name, sx->host->address, addr->message);
936 #ifndef DISABLE_EVENT
938 msg_event_raise(US"msg:rcpt:defer", addr);
941 /* Do not put this message on the list of those waiting for specific
942 hosts, as otherwise it is likely to be tried too often. */
944 update_waiting = FALSE;
946 /* Add a retry item for the address so that it doesn't get tried again
947 too soon. If address_retry_include_sender is true, add the sender address
951 ob->address_retry_include_sender
952 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
953 : addr->address_retry_key,
958 } /* Loop for next RCPT response */
960 /* Update where to start at for the next block of responses, unless we
961 have already handled all the addresses. */
963 if (addr) sx->sync_addr = addr->next;
965 /* Handle a response to DATA. If we have not had any good recipients, either
966 previously or in this block, the response is ignored. */
968 if (pending_DATA != 0)
970 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
971 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
972 '3', ob->command_timeout))
977 if (pending_DATA > 0 || (yield & 1) != 0)
979 if (errno == 0 && sx->buffer[0] == '4')
981 errno = ERRNO_DATA4XX;
982 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
986 (void)check_response(sx->host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
987 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
988 "is in use and there were no good recipients\n", msg);
992 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
993 present) received 3xx. If any RCPTs were handled and yielded anything other
994 than 4xx, yield will be set non-zero. */
1001 /* Do the client side of smtp-level authentication */
1005 buffer EHLO response from server (gets overwritten)
1008 OK Success, or failed (but not required): global "smtp_authenticated" set
1009 DEFER Failed authentication (and was required)
1010 ERROR Internal problem
1012 FAIL_SEND Failed communications - transmit
1017 smtp_auth(smtp_context * sx, uschar * buffer, unsigned bufsize)
1019 smtp_transport_options_block * ob = sx->ob;
1021 uschar *fail_reason = US"server did not advertise AUTH support";
1023 f.smtp_authenticated = FALSE;
1024 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1025 require_auth = verify_check_given_host(&ob->hosts_require_auth, sx->host);
1027 if (sx->esmtp && !regex_AUTH) regex_AUTH =
1028 regex_must_compile(US"\\n250[\\s\\-]AUTH\\s+([\\-\\w\\s]+)(?:\\n|$)",
1031 if (sx->esmtp && regex_match_and_setup(regex_AUTH, buffer, 0, -1))
1033 uschar *names = string_copyn(expand_nstring[1], expand_nlength[1]);
1034 expand_nmax = -1; /* reset */
1036 /* Must not do this check until after we have saved the result of the
1037 regex match above. */
1039 if (require_auth == OK ||
1040 verify_check_given_host(&ob->hosts_try_auth, sx->host) == OK)
1043 fail_reason = US"no common mechanisms were found";
1045 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1047 /* Scan the configured authenticators looking for one which is configured
1048 for use as a client, which is not suppressed by client_condition, and
1049 whose name matches an authentication mechanism supported by the server.
1050 If one is found, attempt to authenticate by calling its client function.
1053 for (au = auths; !f.smtp_authenticated && au; au = au->next)
1057 (au->client_condition != NULL &&
1058 !expand_check_condition(au->client_condition, au->name,
1059 US"client authenticator")))
1061 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1063 (au->client)? "client_condition is false" :
1064 "not configured as a client");
1068 /* Loop to scan supported server mechanisms */
1073 int len = Ustrlen(au->public_name);
1074 while (isspace(*p)) p++;
1076 if (strncmpic(au->public_name, p, len) != 0 ||
1077 (p[len] != 0 && !isspace(p[len])))
1079 while (*p != 0 && !isspace(*p)) p++;
1083 /* Found data for a listed mechanism. Call its client entry. Set
1084 a flag in the outblock so that data is overwritten after sending so
1085 that reflections don't show it. */
1087 fail_reason = US"authentication attempt(s) failed";
1088 sx->outblock.authenticating = TRUE;
1089 rc = (au->info->clientcode)(au, sx,
1090 ob->command_timeout, buffer, bufsize);
1091 sx->outblock.authenticating = FALSE;
1092 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n",
1095 /* A temporary authentication failure must hold up delivery to
1096 this host. After a permanent authentication failure, we carry on
1097 to try other authentication methods. If all fail hard, try to
1098 deliver the message unauthenticated unless require_auth was set. */
1103 f.smtp_authenticated = TRUE; /* stops the outer loop */
1104 client_authenticator = au->name;
1105 if (au->set_client_id != NULL)
1106 client_authenticated_id = expand_string(au->set_client_id);
1109 /* Failure after writing a command */
1114 /* Failure after reading a response */
1117 if (errno != 0 || buffer[0] != '5') return FAIL;
1118 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1119 au->name, sx->host->name, sx->host->address, buffer);
1122 /* Failure by some other means. In effect, the authenticator
1123 decided it wasn't prepared to handle this case. Typically this
1124 is the result of "fail" in an expansion string. Do we need to
1125 log anything here? Feb 2006: a message is now put in the buffer
1126 if logging is required. */
1130 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1131 "authentication H=%s [%s] %s", au->name, sx->host->name,
1132 sx->host->address, buffer);
1135 /* Internal problem, message in buffer. */
1138 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(buffer),
1143 break; /* If not authenticated, try next authenticator */
1144 } /* Loop for scanning supported server mechanisms */
1145 } /* Loop for further authenticators */
1149 /* If we haven't authenticated, but are required to, give up. */
1151 if (require_auth == OK && !f.smtp_authenticated)
1153 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1154 string_sprintf("authentication required but %s", fail_reason), DEFER,
1163 /* Construct AUTH appendix string for MAIL TO */
1166 buffer to build string
1167 addrlist chain of potential addresses to deliver
1168 ob transport options
1170 Globals f.smtp_authenticated
1171 client_authenticated_sender
1172 Return True on error, otherwise buffer has (possibly empty) terminated string
1176 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1177 smtp_transport_options_block *ob)
1179 uschar *local_authenticated_sender = authenticated_sender;
1182 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1185 if (ob->authenticated_sender != NULL)
1187 uschar *new = expand_string(ob->authenticated_sender);
1190 if (!f.expand_string_forcedfail)
1192 uschar *message = string_sprintf("failed to expand "
1193 "authenticated_sender: %s", expand_string_message);
1194 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1198 else if (new[0] != 0) local_authenticated_sender = new;
1201 /* Add the authenticated sender address if present */
1203 if ((f.smtp_authenticated || ob->authenticated_sender_force) &&
1204 local_authenticated_sender != NULL)
1206 string_format(buffer, bufsize, " AUTH=%s",
1207 auth_xtextencode(local_authenticated_sender,
1208 Ustrlen(local_authenticated_sender)));
1209 client_authenticated_sender = string_copy(local_authenticated_sender);
1220 /* Lookup TLSA record for host/port.
1221 Return: OK success with dnssec; DANE mode
1222 DEFER Do not use this host now, may retry later
1223 FAIL_FORCED No TLSA record; DANE not usable
1224 FAIL Do not use this connection
1228 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1230 /* move this out to host.c given the similarity to dns_lookup() ? */
1232 const uschar * fullname = buffer;
1236 /* TLSA lookup string */
1237 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1239 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1240 sec = dns_is_secure(dnsa);
1242 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1247 return DEFER; /* just defer this TLS'd conn */
1256 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1257 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_TLSA)
1259 uint16_t payload_length = rr->size - 3;
1260 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1262 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1263 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1264 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1265 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1266 sp += sprintf(CS sp, "%02x", *p++);
1268 debug_printf(" %s\n", s);
1273 log_write(0, LOG_MAIN,
1274 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1277 case DNS_NODATA: /* no TLSA RR for this lookup */
1278 case DNS_NOMATCH: /* no records at all for this lookup */
1279 return dane_required ? FAIL : FAIL_FORCED;
1283 return dane_required ? FAIL : DEFER;
1290 typedef struct smtp_compare_s
1292 uschar *current_sender_address;
1293 struct transport_instance *tblock;
1297 /* Create a unique string that identifies this message, it is based on
1298 sender_address, helo_data and tls_certificate if enabled.
1302 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1304 address_item * addr1;
1305 uschar * if1 = US"";
1306 uschar * helo1 = US"";
1308 uschar * tlsc1 = US"";
1310 uschar * save_sender_address = sender_address;
1311 uschar * local_identity = NULL;
1312 smtp_transport_options_block * ob =
1313 (smtp_transport_options_block *)tblock->options_block;
1315 sender_address = sender;
1317 addr1 = deliver_make_addr (sender, TRUE);
1318 deliver_set_expansions(addr1);
1321 if1 = expand_string(ob->interface);
1324 helo1 = expand_string(ob->helo_data);
1327 if (ob->tls_certificate)
1328 tlsc1 = expand_string(ob->tls_certificate);
1329 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1331 local_identity = string_sprintf ("%s^%s", if1, helo1);
1334 deliver_set_expansions(NULL);
1335 sender_address = save_sender_address;
1337 return local_identity;
1342 /* This routine is a callback that is called from transport_check_waiting.
1343 This function will evaluate the incoming message versus the previous
1344 message. If the incoming message is using a different local identity then
1345 we will veto this new message. */
1348 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1350 uschar * message_local_identity,
1351 * current_local_identity,
1352 * new_sender_address;
1354 current_local_identity =
1355 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1357 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1360 message_local_identity =
1361 smtp_local_identity(new_sender_address, s_compare->tblock);
1363 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1369 ehlo_response(uschar * buf, unsigned checks)
1371 size_t bsize = Ustrlen(buf);
1374 if ( checks & OPTION_TLS
1375 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1376 checks &= ~OPTION_TLS;
1378 # ifdef EXPERIMENTAL_REQUIRETLS
1379 if ( checks & OPTION_REQUIRETLS
1380 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1381 checks &= ~OPTION_REQUIRETLS;
1385 if ( checks & OPTION_IGNQ
1386 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1387 PCRE_EOPT, NULL, 0) < 0)
1388 checks &= ~OPTION_IGNQ;
1390 if ( checks & OPTION_CHUNKING
1391 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1392 checks &= ~OPTION_CHUNKING;
1394 #ifndef DISABLE_PRDR
1395 if ( checks & OPTION_PRDR
1396 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1397 checks &= ~OPTION_PRDR;
1401 if ( checks & OPTION_UTF8
1402 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1403 checks &= ~OPTION_UTF8;
1406 if ( checks & OPTION_DSN
1407 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1408 checks &= ~OPTION_DSN;
1410 if ( checks & OPTION_PIPE
1411 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1412 PCRE_EOPT, NULL, 0) < 0)
1413 checks &= ~OPTION_PIPE;
1415 if ( checks & OPTION_SIZE
1416 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1417 checks &= ~OPTION_SIZE;
1424 /* Callback for emitting a BDAT data chunk header.
1426 If given a nonzero size, first flush any buffered SMTP commands
1427 then emit the command.
1429 Reap previous SMTP command responses if requested, and always reap
1430 the response from a previous BDAT command.
1433 tctx transport context
1434 chunk_size value for SMTP BDAT command
1436 tc_chunk_last add LAST option to SMTP BDAT command
1437 tc_reap_prev reap response to previous SMTP commands
1439 Returns: OK or ERROR
1443 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1446 smtp_transport_options_block * ob =
1447 (smtp_transport_options_block *)(tctx->tblock->options_block);
1448 smtp_context * sx = tctx->smtp_context;
1452 /* Write SMTP chunk header command. If not reaping responses, note that
1453 there may be more writes (like, the chunk data) done soon. */
1457 if((cmd_count = smtp_write_command(sx,
1458 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1459 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1460 ) < 0) return ERROR;
1461 if (flags & tc_chunk_last)
1462 data_command = string_copy(big_buffer); /* Save for later error message */
1465 prev_cmd_count = cmd_count += sx->cmd_count;
1467 /* Reap responses for any previous, but not one we just emitted */
1471 if (sx->pending_BDAT)
1474 if (flags & tc_reap_prev && prev_cmd_count > 0)
1476 DEBUG(D_transport) debug_printf("look for %d responses"
1477 " for previous pipelined cmds\n", prev_cmd_count);
1479 switch(sync_responses(sx, prev_cmd_count, 0))
1481 case 1: /* 2xx (only) => OK */
1482 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1483 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1484 case 0: break; /* No 2xx or 5xx, but no probs */
1486 case -1: /* Timeout on RCPT */
1487 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1490 if (!sx->pending_BDAT)
1491 pipelining_active = FALSE;
1494 /* Reap response for an outstanding BDAT */
1496 if (sx->pending_BDAT)
1498 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1500 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1501 ob->command_timeout))
1503 if (errno == 0 && sx->buffer[0] == '4')
1505 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1506 sx->addrlist->more_errno |=
1507 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1512 sx->pending_BDAT = FALSE;
1513 pipelining_active = FALSE;
1515 else if (chunk_size > 0)
1516 sx->pending_BDAT = TRUE;
1519 sx->cmd_count = cmd_count;
1525 /*************************************************
1526 * Make connection for given message *
1527 *************************************************/
1531 ctx connection context
1532 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1533 a second attempt after TLS initialization fails
1535 Returns: OK - the connection was made and the delivery attempted;
1536 fd is set in the conn context, tls_out set up.
1537 DEFER - the connection could not be made, or something failed
1538 while setting up the SMTP session, or there was a
1539 non-message-specific error, such as a timeout.
1540 ERROR - helo_data or add_headers or authenticated_sender is
1541 specified for this transport, and the string failed
1545 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1547 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1548 dns_answer tlsa_dnsa;
1550 BOOL pass_message = FALSE;
1551 uschar * message = NULL;
1555 sx->ob = (smtp_transport_options_block *) sx->tblock->options_block;
1557 sx->lmtp = strcmpic(sx->ob->protocol, US"lmtp") == 0;
1558 sx->smtps = strcmpic(sx->ob->protocol, US"smtps") == 0;
1560 sx->send_rset = TRUE;
1561 sx->send_quit = TRUE;
1562 sx->setting_up = TRUE;
1564 sx->esmtp_sent = FALSE;
1566 sx->utf8_needed = FALSE;
1568 sx->dsn_all_lasthop = TRUE;
1569 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1572 verify_check_given_host(&sx->ob->hosts_require_dane, sx->host) == OK;
1575 if ((sx->max_rcpt = sx->tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1576 sx->peer_offered = 0;
1577 sx->avoid_option = 0;
1578 sx->igquotstr = US"";
1579 if (!sx->helo_data) sx->helo_data = sx->ob->helo_data;
1580 #ifdef EXPERIMENTAL_DSN_INFO
1581 sx->smtp_greeting = NULL;
1582 sx->helo_response = NULL;
1585 smtp_command = US"initial connection";
1586 sx->buffer[0] = '\0';
1588 /* Set up the buffer for reading SMTP response packets. */
1590 sx->inblock.buffer = sx->inbuffer;
1591 sx->inblock.buffersize = sizeof(sx->inbuffer);
1592 sx->inblock.ptr = sx->inbuffer;
1593 sx->inblock.ptrend = sx->inbuffer;
1595 /* Set up the buffer for holding SMTP commands while pipelining */
1597 sx->outblock.buffer = sx->outbuffer;
1598 sx->outblock.buffersize = sizeof(sx->outbuffer);
1599 sx->outblock.ptr = sx->outbuffer;
1600 sx->outblock.cmd_count = 0;
1601 sx->outblock.authenticating = FALSE;
1603 /* Reset the parameters of a TLS session. */
1606 tls_out.cipher = NULL; /* the one we may use for this transport */
1607 tls_out.ourcert = NULL;
1608 tls_out.peercert = NULL;
1609 tls_out.peerdn = NULL;
1610 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1613 tls_out.ocsp = OCSP_NOT_REQ;
1615 /* Flip the legacy TLS-related variables over to the outbound set in case
1616 they're used in the context of the transport. Don't bother resetting
1617 afterward (when being used by a transport) as we're in a subprocess.
1618 For verify, unflipped once the callout is dealt with */
1620 tls_modify_variables(&tls_out);
1625 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
1631 /* Make a connection to the host if this isn't a continued delivery, and handle
1632 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
1633 specially so they can be identified for retries. */
1635 if (!continue_hostname)
1638 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->interface, sx->port);
1640 /* Get the actual port the connection will use, into sx->host */
1642 smtp_port_for_connect(sx->host, sx->port);
1644 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1645 /* Do TLSA lookup for DANE */
1647 tls_out.dane_verified = FALSE;
1648 tls_out.tlsa_usage = 0;
1650 if (sx->host->dnssec == DS_YES)
1652 if( sx->dane_required
1653 || verify_check_given_host(&sx->ob->hosts_try_dane, sx->host) == OK
1655 switch (rc = tlsa_lookup(sx->host, &tlsa_dnsa, sx->dane_required))
1657 case OK: sx->dane = TRUE;
1658 sx->ob->tls_tempfail_tryclear = FALSE;
1660 case FAIL_FORCED: break;
1661 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
1662 string_sprintf("DANE error: tlsa lookup %s",
1663 rc == DEFER ? "DEFER" : "FAIL"),
1665 # ifndef DISABLE_EVENT
1666 (void) event_raise(sx->tblock->event_action,
1667 US"dane:fail", sx->dane_required
1668 ? US"dane-required" : US"dnssec-invalid");
1673 else if (sx->dane_required)
1675 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
1676 string_sprintf("DANE error: %s lookup not DNSSEC", sx->host->name),
1678 # ifndef DISABLE_EVENT
1679 (void) event_raise(sx->tblock->event_action,
1680 US"dane:fail", US"dane-required");
1687 /* Make the TCP connection */
1690 smtp_connect(sx->host, sx->host_af, sx->interface,
1691 sx->ob->connect_timeout, sx->tblock);
1692 sx->cctx.tls_ctx = NULL;
1693 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
1695 if (sx->cctx.sock < 0)
1697 uschar * msg = NULL;
1700 msg = US strerror(errno);
1701 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
1703 set_errno_nohost(sx->addrlist,
1704 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
1705 sx->verify ? string_sprintf("could not connect: %s", msg)
1708 sx->send_quit = FALSE;
1712 /* Expand the greeting message while waiting for the initial response. (Makes
1713 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
1714 delayed till here so that $sending_interface and $sending_port are set. */
1717 if (!(sx->helo_data = expand_string(sx->helo_data)))
1719 log_write(0, LOG_MAIN|LOG_PANIC,
1720 "<%s>: failed to expand transport's helo_data value for callout: %s",
1721 sx->addrlist->address, expand_string_message);
1726 expand_string_message = NULL;
1727 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
1728 &expand_string_message)),
1729 expand_string_message)
1731 log_write(0, LOG_MAIN|LOG_PANIC,
1732 "<%s>: failed to expand transport's helo_data value for callout: %s",
1733 sx->addrlist->address, expand_string_message);
1735 sx->helo_data = NULL;
1739 /* The first thing is to wait for an initial OK response. The dreaded "goto"
1740 is nevertheless a reasonably clean way of programming this kind of logic,
1741 where you want to escape on any error. */
1748 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
1750 good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1751 '2', sx->ob->command_timeout);
1752 #ifdef EXPERIMENTAL_DSN_INFO
1753 sx->smtp_greeting = string_copy(sx->buffer);
1755 if (!good_response) goto RESPONSE_FAILED;
1757 #ifndef DISABLE_EVENT
1760 lookup_dnssec_authenticated = sx->host->dnssec==DS_YES ? US"yes"
1761 : sx->host->dnssec==DS_NO ? US"no" : NULL;
1762 s = event_raise(sx->tblock->event_action, US"smtp:connect", sx->buffer);
1765 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
1766 string_sprintf("deferred by smtp:connect event expansion: %s", s),
1774 /* Now check if the helo_data expansion went well, and sign off cleanly if
1779 message = string_sprintf("failed to expand helo_data: %s",
1780 expand_string_message);
1781 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1787 /** Debugging without sending a message
1788 sx->addrlist->transport_return = DEFER;
1792 /* Errors that occur after this point follow an SMTP command, which is
1793 left in big_buffer by smtp_write_command() for use in error messages. */
1795 smtp_command = big_buffer;
1797 /* Tell the remote who we are...
1799 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
1800 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
1801 greeting is of this form. The assumption was that the far end supports it
1802 properly... but experience shows that there are some that give 5xx responses,
1803 even though the banner includes "ESMTP" (there's a bloody-minded one that
1804 says "ESMTP not spoken here"). Cope with that case.
1806 September 2000: Time has passed, and it seems reasonable now to always send
1807 EHLO at the start. It is also convenient to make the change while installing
1810 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
1811 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
1812 would be no way to send out the mails, so there is now a host list
1813 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
1814 PIPELINING problem as well. Maybe it can also be useful to cure other
1815 problems with broken servers.
1817 Exim originally sent "Helo" at this point and ran for nearly a year that way.
1818 Then somebody tried it with a Microsoft mailer... It seems that all other
1819 mailers use upper case for some reason (the RFC is quite clear about case
1820 independence) so, for peace of mind, I gave in. */
1822 sx->esmtp = verify_check_given_host(&sx->ob->hosts_avoid_esmtp, sx->host) != OK;
1824 /* Alas; be careful, since this goto is not an error-out, so conceivably
1825 we might set data between here and the target which we assume to exist
1826 and be usable. I can see this coming back to bite us. */
1830 smtp_peer_options |= OPTION_TLS;
1831 suppress_tls = FALSE;
1832 sx->ob->tls_tempfail_tryclear = FALSE;
1833 smtp_command = US"SSL-on-connect";
1840 if (smtp_write_command(sx, SCMD_FLUSH, "%s %s\r\n",
1841 sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
1843 sx->esmtp_sent = TRUE;
1844 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1845 sx->ob->command_timeout))
1847 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
1849 #ifdef EXPERIMENTAL_DSN_INFO
1850 sx->helo_response = string_copy(sx->buffer);
1852 goto RESPONSE_FAILED;
1856 #ifdef EXPERIMENTAL_DSN_INFO
1857 sx->helo_response = string_copy(sx->buffer);
1862 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
1867 int n = sizeof(sx->buffer);
1868 uschar * rsp = sx->buffer;
1870 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
1871 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
1873 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
1875 good_response = smtp_read_response(sx, rsp, n, '2', sx->ob->command_timeout);
1876 #ifdef EXPERIMENTAL_DSN_INFO
1877 sx->helo_response = string_copy(rsp);
1881 /* Handle special logging for a closed connection after HELO
1882 when had previously sent EHLO */
1884 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
1886 errno = ERRNO_SMTPCLOSED;
1887 goto EHLOHELO_FAILED;
1889 memmove(sx->buffer, rsp, Ustrlen(rsp));
1890 goto RESPONSE_FAILED;
1894 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
1896 if (sx->esmtp || sx->lmtp)
1898 sx->peer_offered = ehlo_response(sx->buffer,
1899 OPTION_TLS /* others checked later */
1902 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
1905 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
1910 /* For continuing deliveries down the same channel, having re-exec'd the socket
1911 is the standard input; for a socket held open from verify it is recorded
1912 in the cutthrough context block. Either way we don't need to redo EHLO here
1913 (but may need to do so for TLS - see below).
1914 Set up the pointer to where subsequent commands will be left, for
1915 error messages. Note that smtp_peer_options will have been
1916 set from the command line if they were set in the process that passed the
1919 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
1920 as the continue goes via transport_pass_socket() and doublefork and exec.
1921 It does not wait. Unclear how we keep separate host's responses
1922 separate - we could match up by host ip+port as a bodge. */
1926 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
1928 sx->cctx = cutthrough.cctx;
1929 sx->host->port = sx->port = cutthrough.host.port;
1933 sx->cctx.sock = 0; /* stdin */
1934 sx->cctx.tls_ctx = NULL;
1935 smtp_port_for_connect(sx->host, sx->port); /* Record the port that was used */
1937 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
1938 smtp_command = big_buffer;
1939 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
1941 /* For a continued connection with TLS being proxied for us, or a
1942 held-open verify connection with TLS, nothing more to do. */
1944 if ( continue_proxy_cipher
1945 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
1946 && cutthrough.is_tls)
1949 sx->peer_offered = smtp_peer_options;
1950 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
1951 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
1952 continue_proxy_cipher ? "proxied" : "verify conn with");
1955 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
1958 /* If TLS is available on this connection, whether continued or not, attempt to
1959 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
1960 send another EHLO - the server may give a different answer in secure mode. We
1961 use a separate buffer for reading the response to STARTTLS so that if it is
1962 negative, the original EHLO data is available for subsequent analysis, should
1963 the client not be required to use TLS. If the response is bad, copy the buffer
1964 for error analysis. */
1967 if ( smtp_peer_options & OPTION_TLS
1969 && verify_check_given_host(&sx->ob->hosts_avoid_tls, sx->host) != OK
1971 || verify_check_given_host(&sx->ob->hosts_verify_avoid_tls, sx->host) != OK
1974 uschar buffer2[4096];
1975 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
1978 /* If there is an I/O error, transmission of this message is deferred. If
1979 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
1980 false, we also defer. However, if there is a temporary rejection of STARTTLS
1981 and tls_tempfail_tryclear is true, or if there is an outright rejection of
1982 STARTTLS, we carry on. This means we will try to send the message in clear,
1983 unless the host is in hosts_require_tls (tested below). */
1985 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2',
1986 sx->ob->command_timeout))
1990 || (buffer2[0] == '4' && !sx->ob->tls_tempfail_tryclear)
1993 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
1994 sx->buffer[sizeof(sx->buffer)-1] = '\0';
1995 goto RESPONSE_FAILED;
1999 /* STARTTLS accepted: try to negotiate a TLS session. */
2004 address_item * addr;
2006 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->host,
2007 sx->addrlist, sx->tblock,
2008 # ifdef SUPPORT_DANE
2009 sx->dane ? &tlsa_dnsa : NULL,
2013 if (!sx->cctx.tls_ctx)
2015 /* TLS negotiation failed; give an error. From outside, this function may
2016 be called again to try in clear on a new connection, if the options permit
2017 it for this host. */
2019 # ifdef SUPPORT_DANE
2022 log_write(0, LOG_MAIN,
2023 "DANE attempt failed; TLS connection to %s [%s]: %s",
2024 sx->host->name, sx->host->address, errstr);
2025 # ifndef DISABLE_EVENT
2026 (void) event_raise(sx->tblock->event_action,
2027 US"dane:fail", US"validation-failure"); /* could do with better detail */
2032 errno = ERRNO_TLSFAILURE;
2033 message = string_sprintf("TLS session: %s", errstr);
2034 sx->send_quit = FALSE;
2038 /* TLS session is set up */
2040 smtp_peer_options_wrap = smtp_peer_options;
2041 for (addr = sx->addrlist; addr; addr = addr->next)
2042 if (addr->transport_return == PENDING_DEFER)
2044 addr->cipher = tls_out.cipher;
2045 addr->ourcert = tls_out.ourcert;
2046 addr->peercert = tls_out.peercert;
2047 addr->peerdn = tls_out.peerdn;
2048 addr->ocsp = tls_out.ocsp;
2053 /* if smtps, we'll have smtp_command set to something else; always safe to
2055 smtp_command = big_buffer;
2057 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2058 helo_data is null, we are dealing with a connection that was passed from
2059 another process, and so we won't have expanded helo_data above. We have to
2060 expand it here. $sending_ip_address and $sending_port are set up right at the
2061 start of the Exim process (in exim.c). */
2063 if (tls_out.active.sock >= 0)
2068 if (!sx->helo_data && !(sx->helo_data = expand_string(sx->ob->helo_data)))
2070 uschar *message = string_sprintf("failed to expand helo_data: %s",
2071 expand_string_message);
2072 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2077 /* For SMTPS we need to wait for the initial OK response. */
2080 good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
2081 '2', sx->ob->command_timeout);
2082 #ifdef EXPERIMENTAL_DSN_INFO
2083 sx->smtp_greeting = string_copy(sx->buffer);
2085 if (!good_response) goto RESPONSE_FAILED;
2089 greeting_cmd = "EHLO";
2092 greeting_cmd = "HELO";
2094 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2097 if (smtp_write_command(sx, SCMD_FLUSH, "%s %s\r\n",
2098 sx->lmtp ? "LHLO" : greeting_cmd, sx->helo_data) < 0)
2100 good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
2101 '2', sx->ob->command_timeout);
2102 #ifdef EXPERIMENTAL_DSN_INFO
2103 sx->helo_response = string_copy(sx->buffer);
2105 if (!good_response) goto RESPONSE_FAILED;
2106 smtp_peer_options = 0;
2109 /* If the host is required to use a secure channel, ensure that we
2113 # ifdef SUPPORT_DANE
2116 # ifdef EXPERIMENTAL_REQUIRETLS
2117 || tls_requiretls & REQUIRETLS_MSG
2119 || verify_check_given_host(&sx->ob->hosts_require_tls, sx->host) == OK
2123 # ifdef EXPERIMENTAL_REQUIRETLS
2124 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2127 message = string_sprintf("a TLS session is required, but %s",
2128 smtp_peer_options & OPTION_TLS
2129 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2130 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2132 (void) event_raise(sx->tblock->event_action, US"dane:fail",
2133 smtp_peer_options & OPTION_TLS
2134 ? US"validation-failure" /* could do with better detail */
2135 : US"starttls-not-supported");
2139 #endif /*SUPPORT_TLS*/
2141 /* If TLS is active, we have just started it up and re-done the EHLO command,
2142 so its response needs to be analyzed. If TLS is not active and this is a
2143 continued session down a previously-used socket, we haven't just done EHLO, so
2146 if (continue_hostname == NULL
2148 || tls_out.active.sock >= 0
2152 if (sx->esmtp || sx->lmtp)
2154 sx->peer_offered = ehlo_response(sx->buffer,
2156 | (sx->lmtp && sx->ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2160 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2161 /*XXX if we hand peercaps on to continued-conn processes,
2162 must not depend on this addr */
2166 | (sx->ob->size_addition >= 0 ? OPTION_SIZE : 0)
2167 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2168 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2172 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2173 lmtp_ignore_quota option was set. */
2175 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2177 /* If the response to EHLO specified support for the SIZE parameter, note
2178 this, provided size_addition is non-negative. */
2180 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2182 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2183 the current host, esmtp will be false, so PIPELINING can never be used. If
2184 the current host matches hosts_avoid_pipelining, don't do it. */
2186 if ( sx->peer_offered & OPTION_PIPE
2187 && verify_check_given_host(&sx->ob->hosts_avoid_pipelining, sx->host) != OK)
2188 smtp_peer_options |= OPTION_PIPE;
2190 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2191 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2193 if ( sx->peer_offered & OPTION_CHUNKING
2194 && verify_check_given_host(&sx->ob->hosts_try_chunking, sx->host) != OK)
2195 sx->peer_offered &= ~OPTION_CHUNKING;
2197 if (sx->peer_offered & OPTION_CHUNKING)
2198 {DEBUG(D_transport) debug_printf("CHUNKING usable\n");}
2200 #ifndef DISABLE_PRDR
2201 if ( sx->peer_offered & OPTION_PRDR
2202 && verify_check_given_host(&sx->ob->hosts_try_prdr, sx->host) != OK)
2203 sx->peer_offered &= ~OPTION_PRDR;
2205 if (sx->peer_offered & OPTION_PRDR)
2206 {DEBUG(D_transport) debug_printf("PRDR usable\n");}
2209 /* Note if the server supports DSN */
2210 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2211 DEBUG(D_transport) debug_printf("%susing DSN\n",
2212 sx->peer_offered & OPTION_DSN ? "" : "not ");
2214 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2215 if (sx->peer_offered & OPTION_REQUIRETLS)
2217 smtp_peer_options |= OPTION_REQUIRETLS;
2218 DEBUG(D_transport) debug_printf(
2219 tls_requiretls & REQUIRETLS_MSG
2220 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2224 /* Note if the response to EHLO specifies support for the AUTH extension.
2225 If it has, check that this host is one we want to authenticate to, and do
2226 the business. The host name and address must be available when the
2227 authenticator's client driver is running. */
2229 switch (yield = smtp_auth(sx, sx->buffer, sizeof(sx->buffer)))
2231 default: goto SEND_QUIT;
2233 case FAIL_SEND: goto SEND_FAILED;
2234 case FAIL: goto RESPONSE_FAILED;
2238 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2240 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2241 message-specific. */
2243 sx->setting_up = FALSE;
2246 if (sx->addrlist->prop.utf8_msg)
2250 /* If the transport sets a downconversion mode it overrides any set by ACL
2253 if ((s = sx->ob->utf8_downconvert))
2255 if (!(s = expand_string(s)))
2257 message = string_sprintf("failed to expand utf8_downconvert: %s",
2258 expand_string_message);
2259 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2265 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2266 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2268 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2269 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2271 case '-': if (s[1] == '1')
2273 sx->addrlist->prop.utf8_downcvt = FALSE;
2274 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2280 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2281 && !sx->addrlist->prop.utf8_downcvt_maybe;
2282 DEBUG(D_transport) if (!sx->utf8_needed)
2283 debug_printf("utf8: %s downconvert\n",
2284 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2287 /* If this is an international message we need the host to speak SMTPUTF8 */
2288 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2290 errno = ERRNO_UTF8_FWD;
2291 goto RESPONSE_FAILED;
2293 #endif /*SUPPORT_I18N*/
2295 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2296 /*XXX should tls_requiretls actually be per-addr? */
2298 if ( tls_requiretls & REQUIRETLS_MSG
2299 && !(sx->peer_offered & OPTION_REQUIRETLS)
2302 sx->setting_up = TRUE;
2303 errno = ERRNO_REQUIRETLS;
2304 message = US"REQUIRETLS support is required from the server"
2305 " but it was not offered";
2306 DEBUG(D_transport) debug_printf("%s\n", message);
2319 sx->send_quit = check_response(sx->host, &errno, sx->addrlist->more_errno,
2320 sx->buffer, &code, &message, &pass_message);
2326 message = US string_sprintf("send() to %s [%s] failed: %s",
2327 sx->host->name, sx->host->address, strerror(errno));
2328 sx->send_quit = FALSE;
2334 message = string_sprintf("Remote host closed connection in response to %s"
2335 " (EHLO response was: %s)", smtp_command, sx->buffer);
2336 sx->send_quit = FALSE;
2340 /* This label is jumped to directly when a TLS negotiation has failed,
2341 or was not done for a host for which it is required. Values will be set
2342 in message and errno, and setting_up will always be true. Treat as
2343 a temporary error. */
2347 # ifdef EXPERIMENTAL_REQUIRETLS
2348 if (errno == ERRNO_REQUIRETLS)
2349 code = '5', yield = FAIL;
2350 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2353 code = '4', yield = DEFER;
2357 /* The failure happened while setting up the call; see if the failure was
2358 a 5xx response (this will either be on connection, or following HELO - a 5xx
2359 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2360 fail all addresses, as this host is never going to accept them. For other
2361 errors during setting up (timeouts or whatever), defer all addresses, and
2362 yield DEFER, so that the host is not tried again for a while.
2364 XXX This peeking for another host feels like a layering violation. We want
2365 to note the host as unusable, but down here we shouldn't know if this was
2366 the last host to try for the addr(list). Perhaps the upper layer should be
2367 the one to do set_errno() ? The problem is that currently the addr is where
2368 errno etc. are stashed, but until we run out of hosts to try the errors are
2369 host-specific. Maybe we should enhance the host_item definition? */
2372 sx->ok = FALSE; /* For when reached by GOTO */
2373 set_errno(sx->addrlist, errno, message,
2378 || errno == ERRNO_UTF8_FWD
2381 pass_message, sx->host
2382 #ifdef EXPERIMENTAL_DSN_INFO
2383 , sx->smtp_greeting, sx->helo_response
2392 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2395 if (sx->cctx.tls_ctx)
2397 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2398 sx->cctx.tls_ctx = NULL;
2402 /* Close the socket, and return the appropriate value, first setting
2403 works because the NULL setting is passed back to the calling process, and
2404 remote_max_parallel is forced to 1 when delivering over an existing connection,
2407 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2410 shutdown(sx->cctx.sock, SHUT_WR);
2411 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2412 for (rc = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && rc > 0;)
2413 rc--; /* drain socket */
2414 sx->send_quit = FALSE;
2416 (void)close(sx->cctx.sock);
2419 #ifndef DISABLE_EVENT
2420 (void) event_raise(sx->tblock->event_action, US"tcp:close", NULL);
2423 continue_transport = NULL;
2424 continue_hostname = NULL;
2431 /* Create the string of options that will be appended to the MAIL FROM:
2432 in the connection context buffer */
2435 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2437 uschar * p = sx->buffer;
2438 address_item * addr;
2443 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2444 send it, adding something to the message size to allow for imprecision
2445 and things that get added en route. Exim keeps the number of lines
2446 in a message, so we can give an accurate value for the original message, but we
2447 need some additional to handle added headers. (Double "." characters don't get
2448 included in the count.) */
2450 if ( message_size > 0
2451 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2453 /*XXX problem here under spool_files_wireformat?
2454 Or just forget about lines? Or inflate by a fixed proportion? */
2456 sprintf(CS p, " SIZE=%d", message_size+message_linecount+sx->ob->size_addition);
2460 #ifndef DISABLE_PRDR
2461 /* If it supports Per-Recipient Data Reponses, and we have omre than one recipient,
2464 sx->prdr_active = FALSE;
2465 if (sx->peer_offered & OPTION_PRDR)
2466 for (addr = addrlist; addr; addr = addr->next)
2467 if (addr->transport_return == PENDING_DEFER)
2469 for (addr = addr->next; addr; addr = addr->next)
2470 if (addr->transport_return == PENDING_DEFER)
2471 { /* at least two recipients to send */
2472 sx->prdr_active = TRUE;
2473 sprintf(CS p, " PRDR"); p += 5;
2481 /* If it supports internationalised messages, and this meesage need that,
2484 if ( sx->peer_offered & OPTION_UTF8
2485 && addrlist->prop.utf8_msg
2486 && !addrlist->prop.utf8_downcvt
2488 Ustrcpy(p, " SMTPUTF8"), p += 9;
2491 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2492 if (tls_requiretls & REQUIRETLS_MSG)
2493 Ustrcpy(p, " REQUIRETLS") , p += 11;
2496 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
2497 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
2498 addr && address_count < sx->max_rcpt;
2499 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
2502 if (!(addr->dsn_flags & rf_dsnlasthop))
2504 sx->dsn_all_lasthop = FALSE;
2509 /* Add any DSN flags to the mail command */
2511 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
2513 if (dsn_ret == dsn_ret_hdrs)
2514 { Ustrcpy(p, " RET=HDRS"); p += 9; }
2515 else if (dsn_ret == dsn_ret_full)
2516 { Ustrcpy(p, " RET=FULL"); p += 9; }
2520 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
2525 /* If an authenticated_sender override has been specified for this transport
2526 instance, expand it. If the expansion is forced to fail, and there was already
2527 an authenticated_sender for this message, the original value will be used.
2528 Other expansion failures are serious. An empty result is ignored, but there is
2529 otherwise no check - this feature is expected to be used with LMTP and other
2530 cases where non-standard addresses (e.g. without domains) might be required. */
2532 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->ob))
2540 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
2542 uschar * p = sx->buffer;
2545 /* Add any DSN flags to the rcpt command */
2547 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
2549 if (addr->dsn_flags & rf_dsnflags)
2554 Ustrcpy(p, " NOTIFY=");
2556 for (i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
2558 if (!first) *p++ = ',';
2560 Ustrcpy(p, rf_names[i]);
2565 if (addr->dsn_orcpt)
2567 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
2578 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
2579 -1 MAIL response error
2580 -2 any non-MAIL read i/o error
2581 -3 non-MAIL response timeout
2582 -4 internal error; channel still usable
2587 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
2589 address_item * addr;
2593 if (build_mailcmd_options(sx, sx->first_addr) != OK)
2599 /* From here until we send the DATA command, we can make use of PIPELINING
2600 if the server host supports it. The code has to be able to check the responses
2601 at any point, for when the buffer fills up, so we write it totally generally.
2602 When PIPELINING is off, each command written reports that it has flushed the
2605 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
2608 uschar * s = sx->from_addr;
2610 uschar * errstr = NULL;
2612 /* If we must downconvert, do the from-address here. Remember we had to
2613 for the to-addresses (done below), and also (ugly) for re-doing when building
2614 the delivery log line. */
2616 if ( sx->addrlist->prop.utf8_msg
2617 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
2620 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
2622 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
2626 setflag(sx->addrlist, af_utf8_downcvt);
2630 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
2631 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
2634 mail_command = string_copy(big_buffer); /* Save for later error message */
2638 case -1: /* Transmission error */
2641 case +1: /* Cmd was sent */
2642 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
2643 sx->ob->command_timeout))
2645 if (errno == 0 && sx->buffer[0] == '4')
2647 errno = ERRNO_MAIL4XX;
2648 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
2652 sx->pending_MAIL = FALSE;
2655 /* otherwise zero: command queued for pipeline */
2658 /* Pass over all the relevant recipient addresses for this host, which are the
2659 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
2660 several before we have to read the responses for those seen so far. This
2661 checking is done by a subroutine because it also needs to be done at the end.
2662 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
2663 the next one if not all are sent.
2665 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
2666 last address because we want to abort if any recipients have any kind of
2667 problem, temporary or permanent. We know that all recipient addresses will have
2668 the PENDING_DEFER status, because only one attempt is ever made, and we know
2669 that max_rcpt will be large, so all addresses will be done at once.
2671 For verify we flush the pipeline after any (the only) rcpt address. */
2673 for (addr = sx->first_addr, address_count = 0;
2674 addr && address_count < sx->max_rcpt;
2675 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
2681 if (tcp_out_fastopen && !f.tcp_out_fastopen_logged)
2683 setflag(addr, af_tcp_fastopen_conn);
2684 if (tcp_out_fastopen > 1) setflag(addr, af_tcp_fastopen);
2687 addr->dsn_aware = sx->peer_offered & OPTION_DSN
2688 ? dsn_support_yes : dsn_support_no;
2691 no_flush = pipelining_active && !sx->verify
2692 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
2694 build_rcptcmd_options(sx, addr);
2696 /* Now send the RCPT command, and process outstanding responses when
2697 necessary. After a timeout on RCPT, we just end the function, leaving the
2698 yield as OK, because this error can often mean that there is a problem with
2699 just one address, so we don't want to delay the host. */
2701 rcpt_addr = transport_rcpt_address(addr, sx->tblock->rcpt_include_affixes);
2704 if ( testflag(sx->addrlist, af_utf8_downcvt)
2705 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
2708 /*XXX could we use a per-address errstr here? Not fail the whole send? */
2709 errno = ERRNO_EXPANDFAIL;
2710 return -5; /*XXX too harsh? */
2714 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
2715 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
2717 if (count < 0) return -5;
2720 switch(sync_responses(sx, count, 0))
2722 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
2723 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
2726 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
2727 if (!sx->lmtp) /* can't tell about progress yet */
2728 sx->completed_addr = TRUE;
2729 case 0: /* No 2xx or 5xx, but no probs */
2732 case -1: return -3; /* Timeout on RCPT */
2733 case -2: return -2; /* non-MAIL read i/o error */
2734 default: return -1; /* any MAIL error */
2736 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
2738 } /* Loop for next address */
2740 f.tcp_out_fastopen_logged = TRUE;
2741 sx->next_addr = addr;
2747 /*****************************************************
2748 * Proxy TLS connection for another transport process *
2749 ******************************************************/
2751 Close the unused end of the pipe, fork once more, then use the given buffer
2752 as a staging area, and select on both the given fd and the TLS'd client-fd for
2753 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
2754 Do blocking full-size writes, and reads under a timeout. Once both input
2755 channels are closed, exit the process.
2759 buf space to use for buffering
2760 bufsiz size of buffer
2761 pfd pipe filedescriptor array; [0] is comms to proxied process
2762 timeout per-read timeout, seconds
2766 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
2770 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
2771 int rc, i, fd_bits, nbytes;
2776 DEBUG(D_transport) debug_printf("proxy-proc final-pid %d\n", rc);
2777 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
2780 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
2781 set_process_info("proxying TLS connection for continued transport");
2783 FD_SET(tls_out.active.sock, &rfds);
2784 FD_SET(pfd[0], &rfds);
2786 for (fd_bits = 3; fd_bits; )
2788 time_t time_left = timeout;
2789 time_t time_start = time(NULL);
2795 struct timeval tv = { time_left, 0 };
2798 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
2800 if (rc < 0 && errno == EINTR)
2801 if ((time_left -= time(NULL) - time_start) > 0) continue;
2805 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
2809 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
2811 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
2812 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
2816 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
2818 /* handle inbound data */
2819 if (FD_ISSET(tls_out.active.sock, &rfds))
2820 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
2823 FD_CLR(tls_out.active.sock, &rfds);
2824 shutdown(pfd[0], SHUT_WR);
2829 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
2830 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
2832 else if (fd_bits & 1)
2833 FD_SET(tls_out.active.sock, &rfds);
2835 /* handle outbound data */
2836 if (FD_ISSET(pfd[0], &rfds))
2837 if ((rc = read(pfd[0], buf, bsize)) <= 0)
2840 tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
2845 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
2846 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
2849 else if (fd_bits & 2)
2850 FD_SET(pfd[0], &rfds);
2854 if (f.running_in_test_harness) millisleep(100); /* let logging complete */
2855 exim_exit(0, US"TLS proxy");
2860 /*************************************************
2861 * Deliver address list to given host *
2862 *************************************************/
2864 /* If continue_hostname is not null, we get here only when continuing to
2865 deliver down an existing channel. The channel was passed as the standard
2866 input. TLS is never active on a passed channel; the previous process always
2867 closes it down before passing the connection on.
2869 Otherwise, we have to make a connection to the remote host, and do the
2870 initial protocol exchange.
2872 When running as an MUA wrapper, if the sender or any recipient is rejected,
2873 temporarily or permanently, we force failure for all recipients.
2876 addrlist chain of potential addresses to deliver; only those whose
2877 transport_return field is set to PENDING_DEFER are currently
2878 being processed; others should be skipped - they have either
2879 been delivered to an earlier host or IP address, or been
2880 failed by one of them.
2881 host host to deliver to
2882 host_af AF_INET or AF_INET6
2883 defport default TCP/IP port to use if host does not specify, in host
2885 interface interface to bind to, or NULL
2886 tblock transport instance block
2887 message_defer set TRUE if yield is OK, but all addresses were deferred
2888 because of a non-recipient, non-host failure, that is, a
2889 4xx response to MAIL FROM, DATA, or ".". This is a defer
2890 that is specific to the message.
2891 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
2892 a second attempt after TLS initialization fails
2894 Returns: OK - the connection was made and the delivery attempted;
2895 the result for each address is in its data block.
2896 DEFER - the connection could not be made, or something failed
2897 while setting up the SMTP session, or there was a
2898 non-message-specific error, such as a timeout.
2899 ERROR - a filter command is specified for this transport,
2900 and there was a problem setting it up; OR helo_data
2901 or add_headers or authenticated_sender is specified
2902 for this transport, and the string failed to expand
2906 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
2907 uschar *interface, transport_instance *tblock,
2908 BOOL *message_defer, BOOL suppress_tls)
2914 struct timeval start_delivery_time;
2916 BOOL pass_message = FALSE;
2917 uschar *message = NULL;
2918 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
2922 gettimeofday(&start_delivery_time, NULL);
2923 suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
2924 *message_defer = FALSE;
2926 sx.addrlist = addrlist;
2928 sx.host_af = host_af,
2930 sx.interface = interface;
2931 sx.helo_data = NULL;
2935 /* Get the channel set up ready for a message (MAIL FROM being the next
2936 SMTP command to send */
2938 if ((rc = smtp_setup_conn(&sx, suppress_tls)) != OK)
2941 /* If there is a filter command specified for this transport, we can now
2942 set it up. This cannot be done until the identify of the host is known. */
2944 if (tblock->filter_command)
2946 transport_filter_timeout = tblock->filter_timeout;
2948 /* On failure, copy the error to all addresses, abandon the SMTP call, and
2951 if (!transport_set_up_command(&transport_filter_argv,
2952 tblock->filter_command, TRUE, DEFER, addrlist,
2953 string_sprintf("%.50s transport", tblock->name), NULL))
2955 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
2961 if ( transport_filter_argv
2962 && *transport_filter_argv
2963 && **transport_filter_argv
2964 && sx.peer_offered & OPTION_CHUNKING
2967 sx.peer_offered &= ~OPTION_CHUNKING;
2968 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
2972 sx.first_addr = addrlist;
2974 /* For messages that have more than the maximum number of envelope recipients,
2975 we want to send several transactions down the same SMTP connection. (See
2976 comments in deliver.c as to how this reconciles, heuristically, with
2977 remote_max_parallel.) This optimization was added to Exim after the following
2978 code was already working. The simplest way to put it in without disturbing the
2979 code was to use a goto to jump back to this point when there is another
2980 transaction to handle. */
2983 sx.from_addr = return_path;
2984 sx.sync_addr = sx.first_addr;
2986 sx.send_rset = TRUE;
2987 sx.completed_addr = FALSE;
2990 /* If we are a continued-connection-after-verify the MAIL and RCPT
2991 commands were already sent; do not re-send but do mark the addrs as
2992 having been accepted up to RCPT stage. A traditional cont-conn
2993 always has a sequence number greater than one. */
2995 if (continue_hostname && continue_sequence == 1)
2997 address_item * addr;
2999 sx.peer_offered = smtp_peer_options;
3000 sx.pending_MAIL = FALSE;
3002 sx.next_addr = NULL;
3004 for (addr = addrlist; addr; addr = addr->next)
3005 addr->transport_return = PENDING_OK;
3009 /* Initiate a message transfer. */
3011 switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
3014 case -1: case -2: goto RESPONSE_FAILED;
3015 case -3: goto END_OFF;
3016 case -4: goto SEND_QUIT;
3017 default: goto SEND_FAILED;
3020 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3021 permanently or temporarily. We should have flushed and synced after the last
3029 for (a = sx.first_addr, cnt = 0; a && cnt < sx.max_rcpt; a = a->next, cnt++)
3030 if (a->transport_return != PENDING_OK)
3032 /*XXX could we find a better errno than 0 here? */
3033 set_errno_nohost(addrlist, 0, a->message, FAIL,
3034 testflag(a, af_pass_message));
3041 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3042 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3043 have a good recipient buffered up if we are pipelining. We don't want to waste
3044 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3045 are pipelining. The responses are all handled by sync_responses().
3046 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3049 if ( !(sx.peer_offered & OPTION_CHUNKING)
3050 && (sx.ok || (pipelining_active && !mua_wrapper)))
3052 int count = smtp_write_command(&sx, SCMD_FLUSH, "DATA\r\n");
3054 if (count < 0) goto SEND_FAILED;
3055 switch(sync_responses(&sx, count, sx.ok ? +1 : -1))
3057 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3058 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3061 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3062 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3063 case 0: break; /* No 2xx or 5xx, but no probs */
3065 case -1: goto END_OFF; /* Timeout on RCPT */
3066 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3068 pipelining_active = FALSE;
3069 data_command = string_copy(big_buffer); /* Save for later error message */
3072 /* If there were no good recipients (but otherwise there have been no
3073 problems), just set ok TRUE, since we have handled address-specific errors
3074 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3075 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3076 well as body. Set the appropriate timeout value to be used for each chunk.
3077 (Haven't been able to make it work using select() for writing yet.) */
3079 if (!(sx.peer_offered & OPTION_CHUNKING) && !sx.ok)
3081 /* Save the first address of the next batch. */
3082 sx.first_addr = sx.next_addr;
3088 transport_ctx tctx = {
3089 {sx.cctx.sock}, /*XXX will this need TLS info? */
3092 US".", US"..", /* Escaping strings */
3093 topt_use_crlf | topt_escape_headers
3094 | (tblock->body_only ? topt_no_headers : 0)
3095 | (tblock->headers_only ? topt_no_body : 0)
3096 | (tblock->return_path_add ? topt_add_return_path : 0)
3097 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3098 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3101 /* If using CHUNKING we need a callback from the generic transport
3102 support to us, for the sending of BDAT smtp commands and the reaping
3103 of responses. The callback needs a whole bunch of state so set up
3104 a transport-context structure to be passed around. */
3106 if (sx.peer_offered & OPTION_CHUNKING)
3108 tctx.check_string = tctx.escape_string = NULL;
3109 tctx.options |= topt_use_bdat;
3110 tctx.chunk_cb = smtp_chunk_cmd_callback;
3111 sx.pending_BDAT = FALSE;
3112 sx.good_RCPT = sx.ok;
3114 tctx.smtp_context = &sx;
3117 tctx.options |= topt_end_dot;
3119 /* Save the first address of the next batch. */
3120 sx.first_addr = sx.next_addr;
3122 /* Responses from CHUNKING commands go in buffer. Otherwise,
3123 there has not been a response. */
3127 sigalrm_seen = FALSE;
3128 transport_write_timeout = sx.ob->data_timeout;
3129 smtp_command = US"sending data block"; /* For error messages */
3130 DEBUG(D_transport|D_v)
3131 if (sx.peer_offered & OPTION_CHUNKING)
3132 debug_printf(" will write message using CHUNKING\n");
3134 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3135 transport_count = 0;
3137 #ifndef DISABLE_DKIM
3138 dkim_exim_sign_init();
3139 # ifdef EXPERIMENTAL_ARC
3141 uschar * s = sx.ob->arc_sign;
3144 if (!(sx.ob->dkim.arc_signspec = s = expand_string(s)))
3146 if (!f.expand_string_forcedfail)
3148 message = US"failed to expand arc_sign";
3155 /* Ask dkim code to hash the body for ARC */
3156 (void) arc_ams_setup_sign_bodyhash();
3157 sx.ob->dkim.force_bodyhash = TRUE;
3162 sx.ok = dkim_transport_write_message(&tctx, &sx.ob->dkim, CUSS &message);
3164 sx.ok = transport_write_message(&tctx, 0);
3167 /* transport_write_message() uses write() because it is called from other
3168 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3169 it can exit with "Broken pipe" as its error. This really means that the
3170 socket got closed at the far end. */
3172 transport_write_timeout = 0; /* for subsequent transports */
3174 /* Failure can either be some kind of I/O disaster (including timeout),
3175 or the failure of a transport filter or the expansion of added headers.
3176 Or, when CHUNKING, it can be a protocol-detected failure. */
3179 if (message) goto SEND_FAILED;
3180 else goto RESPONSE_FAILED;
3182 /* We used to send the terminating "." explicitly here, but because of
3183 buffering effects at both ends of TCP/IP connections, you don't gain
3184 anything by keeping it separate, so it might as well go in the final
3185 data buffer for efficiency. This is now done by setting the topt_end_dot
3188 smtp_command = US"end of data";
3190 if (sx.peer_offered & OPTION_CHUNKING && sx.cmd_count > 1)
3192 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3193 switch(sync_responses(&sx, sx.cmd_count-1, 0))
3195 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3196 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3199 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3200 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3201 case 0: break; /* No 2xx or 5xx, but no probs */
3203 case -1: goto END_OFF; /* Timeout on RCPT */
3204 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3208 #ifndef DISABLE_PRDR
3209 /* For PRDR we optionally get a partial-responses warning
3210 * followed by the individual responses, before going on with
3211 * the overall response. If we don't get the warning then deal
3212 * with per non-PRDR. */
3215 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '3',
3216 sx.ob->final_timeout);
3217 if (!sx.ok && errno == 0) switch(sx.buffer[0])
3219 case '2': sx.prdr_active = FALSE;
3222 case '4': errno = ERRNO_DATA4XX;
3223 addrlist->more_errno |=
3224 ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3231 /* For non-PRDR SMTP, we now read a single response that applies to the
3232 whole message. If it is OK, then all the addresses have been delivered. */
3236 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3237 sx.ob->final_timeout);
3238 if (!sx.ok && errno == 0 && sx.buffer[0] == '4')
3240 errno = ERRNO_DATA4XX;
3241 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3245 /* For LMTP, we get back a response for every RCPT command that we sent;
3246 some may be accepted and some rejected. For those that get a response, their
3247 status is fixed; any that are accepted have been handed over, even if later
3248 responses crash - at least, that's how I read RFC 2033.
3250 If all went well, mark the recipient addresses as completed, record which
3251 host/IPaddress they were delivered to, and cut out RSET when sending another
3252 message down the same channel. Write the completed addresses to the journal
3253 now so that they are recorded in case there is a crash of hardware or
3254 software before the spool gets updated. Also record the final SMTP
3255 confirmation if needed (for SMTP only). */
3260 struct timeval delivery_time;
3262 uschar * conf = NULL;
3264 timesince(&delivery_time, &start_delivery_time);
3265 sx.send_rset = FALSE;
3266 pipelining_active = FALSE;
3268 /* Set up confirmation if needed - applies only to SMTP */
3271 #ifdef DISABLE_EVENT
3272 LOGGING(smtp_confirmation) &&
3277 const uschar *s = string_printing(sx.buffer);
3278 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3279 conf = (s == sx.buffer)? US string_copy(s) : US s;
3282 /* Process all transported addresses - for LMTP or PRDR, read a status for
3285 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3287 if (addr->transport_return != PENDING_OK) continue;
3289 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3290 remaining addresses. Otherwise, it's a return code for just the one
3291 address. For temporary errors, add a retry item for the address so that
3292 it doesn't get tried again too soon. */
3294 #ifndef DISABLE_PRDR
3295 if (sx.lmtp || sx.prdr_active)
3300 if (!smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3301 sx.ob->final_timeout))
3303 if (errno != 0 || sx.buffer[0] == 0) goto RESPONSE_FAILED;
3304 addr->message = string_sprintf(
3305 #ifndef DISABLE_PRDR
3306 "%s error after %s: %s", sx.prdr_active ? "PRDR":"LMTP",
3308 "LMTP error after %s: %s",
3310 data_command, string_printing(sx.buffer));
3311 setflag(addr, af_pass_message); /* Allow message to go to user */
3312 if (sx.buffer[0] == '5')
3313 addr->transport_return = FAIL;
3316 errno = ERRNO_DATA4XX;
3317 addr->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3318 addr->transport_return = DEFER;
3319 #ifndef DISABLE_PRDR
3320 if (!sx.prdr_active)
3322 retry_add_item(addr, addr->address_retry_key, 0);
3326 sx.completed_addr = TRUE; /* NOW we can set this flag */
3327 if (LOGGING(smtp_confirmation))
3329 const uschar *s = string_printing(sx.buffer);
3330 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3331 conf = (s == sx.buffer) ? US string_copy(s) : US s;
3335 /* SMTP, or success return from LMTP for this address. Pass back the
3336 actual host that was used. */
3338 addr->transport_return = OK;
3339 addr->more_errno = delivery_time.tv_sec;
3340 addr->delivery_usec = delivery_time.tv_usec;
3341 addr->host_used = host;
3342 addr->special_action = flag;
3343 addr->message = conf;
3345 if (sx.pipelining_used) setflag(addr, af_pipelining);
3346 #ifndef DISABLE_PRDR
3347 if (sx.prdr_active) setflag(addr, af_prdr_used);
3349 if (sx.peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3352 #ifndef DISABLE_PRDR
3353 if (!sx.prdr_active)
3356 /* Update the journal. For homonymic addresses, use the base address plus
3357 the transport name. See lots of comments in deliver.c about the reasons
3358 for the complications when homonyms are involved. Just carry on after
3359 write error, as it may prove possible to update the spool file later. */
3361 if (testflag(addr, af_homonym))
3362 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3364 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3366 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx.buffer);
3367 len = Ustrlen(CS sx.buffer);
3368 if (write(journal_fd, sx.buffer, len) != len)
3369 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3370 "%s: %s", sx.buffer, strerror(errno));
3374 #ifndef DISABLE_PRDR
3377 const uschar * overall_message;
3379 /* PRDR - get the final, overall response. For any non-success
3380 upgrade all the address statuses. */
3382 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3383 sx.ob->final_timeout);
3386 if(errno == 0 && sx.buffer[0] == '4')
3388 errno = ERRNO_DATA4XX;
3389 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3391 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3392 if (sx.buffer[0] == '5' || addr->transport_return == OK)
3393 addr->transport_return = PENDING_OK; /* allow set_errno action */
3394 goto RESPONSE_FAILED;
3397 /* Append the overall response to the individual PRDR response for logging
3398 and update the journal, or setup retry. */
3400 overall_message = string_printing(sx.buffer);
3401 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3402 if (addr->transport_return == OK)
3403 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
3405 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3406 if (addr->transport_return == OK)
3408 if (testflag(addr, af_homonym))
3409 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3411 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3413 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx.buffer);
3414 len = Ustrlen(CS sx.buffer);
3415 if (write(journal_fd, sx.buffer, len) != len)
3416 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3417 "%s: %s", sx.buffer, strerror(errno));
3419 else if (addr->transport_return == DEFER)
3420 retry_add_item(addr, addr->address_retry_key, -2);
3424 /* Ensure the journal file is pushed out to disk. */
3426 if (EXIMfsync(journal_fd) < 0)
3427 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
3433 /* Handle general (not specific to one address) failures here. The value of ok
3434 is used to skip over this code on the falling through case. A timeout causes a
3435 deferral. Other errors may defer or fail according to the response code, and
3436 may set up a special errno value, e.g. after connection chopped, which is
3437 assumed if errno == 0 and there is no text in the buffer. If control reaches
3438 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
3439 the problem is not related to this specific message. */
3444 uschar * set_message;
3450 sx.send_quit = check_response(host, &save_errno, addrlist->more_errno,
3451 sx.buffer, &code, &message, &pass_message);
3459 message = string_sprintf("send() to %s [%s] failed: %s",
3460 host->name, host->address, message ? message : US strerror(save_errno));
3461 sx.send_quit = FALSE;
3469 sx.ok = FALSE; /* For when reached by GOTO */
3470 set_message = message;
3472 /* We want to handle timeouts after MAIL or "." and loss of connection after
3473 "." specially. They can indicate a problem with the sender address or with
3474 the contents of the message rather than a real error on the connection. These
3475 cases are treated in the same way as a 4xx response. This next bit of code
3476 does the classification. */
3483 message_error = TRUE;
3487 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
3488 Ustrncmp(smtp_command,"end ",4) == 0;
3491 case ERRNO_SMTPCLOSED:
3492 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
3496 message_error = FALSE;
3500 /* Handle the cases that are treated as message errors. These are:
3502 (a) negative response or timeout after MAIL
3503 (b) negative response after DATA
3504 (c) negative response or timeout or dropped connection after "."
3505 (d) utf8 support required and not offered
3507 It won't be a negative response or timeout after RCPT, as that is dealt
3508 with separately above. The action in all cases is to set an appropriate
3509 error code for all the addresses, but to leave yield set to OK because the
3510 host itself has not failed. Of course, it might in practice have failed
3511 when we've had a timeout, but if so, we'll discover that at the next
3512 delivery attempt. For a temporary error, set the message_defer flag, and
3513 write to the logs for information if this is not the last host. The error
3514 for the last host will be logged as part of the address's log line. */
3518 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
3520 /* If there's an errno, the message contains just the identity of
3525 else /* Anything other than 5 is treated as temporary */
3529 message = US string_sprintf("%s: %s", message, strerror(save_errno));
3531 write_logs(host, message, sx.first_addr ? sx.first_addr->basic_errno : 0);
3533 *message_defer = TRUE;
3537 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
3538 ".", or some other transportation error. We defer all addresses and yield
3539 DEFER, except for the case of failed add_headers expansion, or a transport
3540 filter failure, when the yield should be ERROR, to stop it trying other
3546 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
3547 save_errno == ERRNO_FILTER_FAIL)? ERROR : DEFER;
3551 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
3552 #ifdef EXPERIMENTAL_DSN_INFO
3553 , sx.smtp_greeting, sx.helo_response
3559 /* If all has gone well, send_quit will be set TRUE, implying we can end the
3560 SMTP session tidily. However, if there were too many addresses to send in one
3561 message (indicated by first_addr being non-NULL) we want to carry on with the
3562 rest of them. Also, it is desirable to send more than one message down the SMTP
3563 connection if there are several waiting, provided we haven't already sent so
3564 many as to hit the configured limit. The function transport_check_waiting looks
3565 for a waiting message and returns its id. Then transport_pass_socket tries to
3566 set up a continued delivery by passing the socket on to another process. The
3567 variable send_rset is FALSE if a message has just been successfully transfered.
3569 If we are already sending down a continued channel, there may be further
3570 addresses not yet delivered that are aimed at the same host, but which have not
3571 been passed in this run of the transport. In this case, continue_more will be
3572 true, and all we should do is send RSET if necessary, and return, leaving the
3575 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
3576 do not want to continue with other messages down the same channel, because that
3577 can lead to looping between two or more messages, all with the same,
3578 temporarily failing address(es). [The retry information isn't updated yet, so
3579 new processes keep on trying.] We probably also don't want to try more of this
3580 message's addresses either.
3582 If we have started a TLS session, we have to end it before passing the
3583 connection to a new process. However, not all servers can handle this (Exim
3584 can), so we do not pass such a connection on if the host matches
3585 hosts_nopass_tls. */
3588 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
3589 "yield=%d first_address is %sNULL\n", sx.ok, sx.send_quit,
3590 sx.send_rset, f.continue_more, yield, sx.first_addr ? "not " : "");
3592 if (sx.completed_addr && sx.ok && sx.send_quit)
3595 smtp_compare_t t_compare;
3597 t_compare.tblock = tblock;
3598 t_compare.current_sender_address = sender_address;
3600 if ( sx.first_addr != NULL
3604 ( tls_out.active.sock < 0 && !continue_proxy_cipher
3605 || verify_check_given_host(&sx.ob->hosts_nopass_tls, host) != OK
3609 transport_check_waiting(tblock->name, host->name,
3610 tblock->connection_max_messages, new_message_id, &more,
3611 (oicf)smtp_are_same_identities, (void*)&t_compare)
3618 if (! (sx.ok = smtp_write_command(&sx, SCMD_FLUSH, "RSET\r\n") >= 0))
3620 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
3621 host->address, strerror(errno));
3622 sx.send_quit = FALSE;
3624 else if (! (sx.ok = smtp_read_response(&sx, sx.buffer,
3625 sizeof(sx.buffer), '2', sx.ob->command_timeout)))
3628 sx.send_quit = check_response(host, &errno, 0, sx.buffer, &code, &msg,
3632 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
3633 host->name, host->address, msg);
3637 /* Either RSET was not needed, or it succeeded */
3642 int socket_fd = sx.cctx.sock;
3645 if (sx.first_addr != NULL) /* More addresses still to be sent */
3646 { /* in this run of the transport */
3647 continue_sequence++; /* Causes * in logging */
3651 /* Unless caller said it already has more messages listed for this host,
3652 pass the connection on to a new Exim process (below, the call to
3653 transport_pass_socket). If the caller has more ready, just return with
3654 the connection still open. */
3657 if (tls_out.active.sock >= 0)
3658 if ( f.continue_more
3659 || verify_check_given_host(&sx.ob->hosts_noproxy_tls, host) == OK)
3661 /* Before passing the socket on, or returning to caller with it still
3662 open, we must shut down TLS. Not all MTAs allow for the continuation
3663 of the SMTP session when TLS is shut down. We test for this by sending
3664 a new EHLO. If we don't get a good response, we don't attempt to pass
3667 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
3668 sx.cctx.tls_ctx = NULL;
3669 smtp_peer_options = smtp_peer_options_wrap;
3671 && smtp_write_command(&sx, SCMD_FLUSH, "EHLO %s\r\n", sx.helo_data)
3673 && smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
3674 '2', sx.ob->command_timeout);
3676 if (sx.ok && f.continue_more)
3677 return yield; /* More addresses for another run */
3681 /* Set up a pipe for proxying TLS for the new transport process */
3683 smtp_peer_options |= OPTION_TLS;
3684 if (sx.ok = (socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
3687 set_errno(sx.first_addr, errno, US"internal allocation problem",
3689 # ifdef EXPERIMENTAL_DSN_INFO
3690 , sx.smtp_greeting, sx.helo_response
3696 if (f.continue_more)
3697 return yield; /* More addresses for another run */
3699 /* If the socket is successfully passed, we mustn't send QUIT (or
3700 indeed anything!) from here. */
3702 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
3703 propagate it from the initial
3705 if (sx.ok && transport_pass_socket(tblock->name, host->name,
3706 host->address, new_message_id, socket_fd))
3708 sx.send_quit = FALSE;
3710 /* We have passed the client socket to a fresh transport process.
3711 If TLS is still active, we need to proxy it for the transport we
3712 just passed the baton to. Fork a child to to do it, and return to
3713 get logging done asap. Which way to place the work makes assumptions
3714 about post-fork prioritisation which may not hold on all platforms. */
3716 if (tls_out.active.sock >= 0)
3719 if (pid == 0) /* child; fork again to disconnect totally */
3721 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
3722 /* does not return */
3723 smtp_proxy_tls(sx.cctx.tls_ctx, sx.buffer, sizeof(sx.buffer), pfd,
3724 sx.ob->command_timeout);
3727 if (pid > 0) /* parent */
3729 DEBUG(D_transport) debug_printf("proxy-proc inter-pid %d\n", pid);
3731 /* tidy the inter-proc to disconn the proxy proc */
3732 waitpid(pid, NULL, 0);
3733 tls_close(sx.cctx.tls_ctx, TLS_NO_SHUTDOWN);
3734 sx.cctx.tls_ctx = NULL;
3735 (void)close(sx.cctx.sock);
3737 continue_transport = NULL;
3738 continue_hostname = NULL;
3741 log_write(0, LOG_PANIC_DIE, "fork failed");
3747 /* If RSET failed and there are addresses left, they get deferred. */
3749 set_errno(sx.first_addr, errno, msg, DEFER, FALSE, host
3750 #ifdef EXPERIMENTAL_DSN_INFO
3751 , sx.smtp_greeting, sx.helo_response
3757 /* End off tidily with QUIT unless the connection has died or the socket has
3758 been passed to another process. There has been discussion on the net about what
3759 to do after sending QUIT. The wording of the RFC suggests that it is necessary
3760 to wait for a response, but on the other hand, there isn't anything one can do
3761 with an error response, other than log it. Exim used to do that. However,
3762 further discussion suggested that it is positively advantageous not to wait for
3763 the response, but to close the session immediately. This is supposed to move
3764 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
3765 load from the server. (Hosts that are both servers and clients may not see much
3766 difference, of course.) Further discussion indicated that this was safe to do
3767 on Unix systems which have decent implementations of TCP/IP that leave the
3768 connection around for a while (TIME_WAIT) after the application has gone away.
3769 This enables the response sent by the server to be properly ACKed rather than
3770 timed out, as can happen on broken TCP/IP implementations on other OS.
3772 This change is being made on 31-Jul-98. After over a year of trouble-free
3773 operation, the old commented-out code was removed on 17-Sep-99. */
3776 if (sx.send_quit) (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
3781 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
3782 sx.cctx.tls_ctx = NULL;
3785 /* Close the socket, and return the appropriate value, first setting
3786 works because the NULL setting is passed back to the calling process, and
3787 remote_max_parallel is forced to 1 when delivering over an existing connection,
3789 If all went well and continue_more is set, we shouldn't actually get here if
3790 there are further addresses, as the return above will be taken. However,
3791 writing RSET might have failed, or there may be other addresses whose hosts are
3792 specified in the transports, and therefore not visible at top level, in which
3793 case continue_more won't get set. */
3795 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
3798 shutdown(sx.cctx.sock, SHUT_WR);
3799 if (fcntl(sx.cctx.sock, F_SETFL, O_NONBLOCK) == 0)
3800 for (rc = 16; read(sx.cctx.sock, sx.inbuffer, sizeof(sx.inbuffer)) > 0 && rc > 0;)
3801 rc--; /* drain socket */
3803 (void)close(sx.cctx.sock);
3805 #ifndef DISABLE_EVENT
3806 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
3809 continue_transport = NULL;
3810 continue_hostname = NULL;
3817 /*************************************************
3818 * Closedown entry point *
3819 *************************************************/
3821 /* This function is called when exim is passed an open smtp channel
3822 from another incarnation, but the message which it has been asked
3823 to deliver no longer exists. The channel is on stdin.
3825 We might do fancy things like looking for another message to send down
3826 the channel, but if the one we sought has gone, it has probably been
3827 delivered by some other process that itself will seek further messages,
3828 so just close down our connection.
3830 Argument: pointer to the transport instance block
3835 smtp_transport_closedown(transport_instance *tblock)
3837 smtp_transport_options_block *ob =
3838 (smtp_transport_options_block *)tblock->options_block;
3839 client_conn_ctx cctx;
3842 uschar inbuffer[4096];
3843 uschar outbuffer[16];
3845 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
3846 cctx.sock = fileno(stdin);
3847 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
3849 sx.inblock.cctx = &cctx;
3850 sx.inblock.buffer = inbuffer;
3851 sx.inblock.buffersize = sizeof(inbuffer);
3852 sx.inblock.ptr = inbuffer;
3853 sx.inblock.ptrend = inbuffer;
3855 sx.outblock.cctx = &cctx;
3856 sx.outblock.buffersize = sizeof(outbuffer);
3857 sx.outblock.buffer = outbuffer;
3858 sx.outblock.ptr = outbuffer;
3859 sx.outblock.cmd_count = 0;
3860 sx.outblock.authenticating = FALSE;
3862 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
3863 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
3864 (void)close(cctx.sock);
3869 /*************************************************
3870 * Prepare addresses for delivery *
3871 *************************************************/
3873 /* This function is called to flush out error settings from previous delivery
3874 attempts to other hosts. It also records whether we got here via an MX record
3875 or not in the more_errno field of the address. We are interested only in
3876 addresses that are still marked DEFER - others may have got delivered to a
3877 previously considered IP address. Set their status to PENDING_DEFER to indicate
3878 which ones are relevant this time.
3881 addrlist the list of addresses
3882 host the host we are delivering to
3884 Returns: the first address for this delivery
3887 static address_item *
3888 prepare_addresses(address_item *addrlist, host_item *host)
3890 address_item *first_addr = NULL;
3892 for (addr = addrlist; addr; addr = addr->next)
3893 if (addr->transport_return == DEFER)
3895 if (!first_addr) first_addr = addr;
3896 addr->transport_return = PENDING_DEFER;
3897 addr->basic_errno = 0;
3898 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
3899 addr->message = NULL;
3901 addr->cipher = NULL;
3902 addr->ourcert = NULL;
3903 addr->peercert = NULL;
3904 addr->peerdn = NULL;
3905 addr->ocsp = OCSP_NOT_REQ;
3907 #ifdef EXPERIMENTAL_DSN_INFO
3908 addr->smtp_greeting = NULL;
3909 addr->helo_response = NULL;
3917 /*************************************************
3918 * Main entry point *
3919 *************************************************/
3921 /* See local README for interface details. As this is a remote transport, it is
3922 given a chain of addresses to be delivered in one connection, if possible. It
3923 always returns TRUE, indicating that each address has its own independent
3924 status set, except if there is a setting up problem, in which case it returns
3928 smtp_transport_entry(
3929 transport_instance *tblock, /* data for this instantiation */
3930 address_item *addrlist) /* addresses we are working on */
3934 int hosts_defer = 0;
3936 int hosts_looked_up = 0;
3937 int hosts_retry = 0;
3938 int hosts_serial = 0;
3939 int hosts_total = 0;
3940 int total_hosts_tried = 0;
3942 BOOL expired = TRUE;
3943 uschar *expanded_hosts = NULL;
3945 uschar *tid = string_sprintf("%s transport", tblock->name);
3946 smtp_transport_options_block *ob =
3947 (smtp_transport_options_block *)(tblock->options_block);
3948 host_item *hostlist = addrlist->host_list;
3953 debug_printf("%s transport entered\n", tblock->name);
3954 for (addr = addrlist; addr; addr = addr->next)
3955 debug_printf(" %s\n", addr->address);
3958 debug_printf("hostlist:\n");
3959 for (host = hostlist; host; host = host->next)
3960 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
3962 if (continue_hostname)
3963 debug_printf("already connected to %s [%s] (on fd %d)\n",
3964 continue_hostname, continue_host_address,
3965 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
3968 /* Set the flag requesting that these hosts be added to the waiting
3969 database if the delivery fails temporarily or if we are running with
3970 queue_smtp or a 2-stage queue run. This gets unset for certain
3971 kinds of error, typically those that are specific to the message. */
3973 update_waiting = TRUE;
3975 /* If a host list is not defined for the addresses - they must all have the
3976 same one in order to be passed to a single transport - or if the transport has
3977 a host list with hosts_override set, use the host list supplied with the
3978 transport. It is an error for this not to exist. */
3980 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3981 if (tls_requiretls & REQUIRETLS_MSG)
3982 ob->tls_tempfail_tryclear = FALSE; /*XXX surely we should have a local for this
3983 rather than modifying the transport? */
3986 if (!hostlist || (ob->hosts_override && ob->hosts))
3990 addrlist->message = string_sprintf("%s transport called with no hosts set",
3992 addrlist->transport_return = PANIC;
3993 return FALSE; /* Only top address has status */
3996 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
3999 /* If the transport's host list contains no '$' characters, and we are not
4000 randomizing, it is fixed and therefore a chain of hosts can be built once
4001 and for all, and remembered for subsequent use by other calls to this
4002 transport. If, on the other hand, the host list does contain '$', or we are
4003 randomizing its order, we have to rebuild it each time. In the fixed case,
4004 as the hosts string will never be used again, it doesn't matter that we
4005 replace all the : characters with zeros. */
4009 uschar *s = ob->hosts;
4011 if (Ustrchr(s, '$') != NULL)
4013 if (!(expanded_hosts = expand_string(s)))
4015 addrlist->message = string_sprintf("failed to expand list of hosts "
4016 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4017 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4018 return FALSE; /* Only top address has status */
4020 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4021 "\"%s\"\n", s, expanded_hosts);
4025 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4027 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4029 /* Check that the expansion yielded something useful. */
4033 string_sprintf("%s transport has empty hosts setting", tblock->name);
4034 addrlist->transport_return = PANIC;
4035 return FALSE; /* Only top address has status */
4038 /* If there was no expansion of hosts, save the host list for
4041 if (!expanded_hosts) ob->hostlist = hostlist;
4044 /* This is not the first time this transport has been run in this delivery;
4045 the host list was built previously. */
4048 hostlist = ob->hostlist;
4051 /* The host list was supplied with the address. If hosts_randomize is set, we
4052 must sort it into a random order if it did not come from MX records and has not
4053 already been randomized (but don't bother if continuing down an existing
4056 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4058 host_item *newlist = NULL;
4061 host_item *h = hostlist;
4062 hostlist = hostlist->next;
4064 h->sort_key = random_number(100);
4071 else if (h->sort_key < newlist->sort_key)
4078 host_item *hh = newlist;
4081 if (h->sort_key < hh->next->sort_key) break;
4089 hostlist = addrlist->host_list = newlist;
4092 /* Sort out the default port. */
4094 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4096 /* For each host-plus-IP-address on the list:
4098 . If this is a continued delivery and the host isn't the one with the
4099 current connection, skip.
4101 . If the status is unusable (i.e. previously failed or retry checked), skip.
4103 . If no IP address set, get the address, either by turning the name into
4104 an address, calling gethostbyname if gethostbyname is on, or by calling
4105 the DNS. The DNS may yield multiple addresses, in which case insert the
4106 extra ones into the list.
4108 . Get the retry data if not previously obtained for this address and set the
4109 field which remembers the state of this address. Skip if the retry time is
4110 not reached. If not, remember whether retry data was found. The retry string
4111 contains both the name and the IP address.
4113 . Scan the list of addresses and mark those whose status is DEFER as
4114 PENDING_DEFER. These are the only ones that will be processed in this cycle
4117 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4118 Some addresses may be successfully delivered, others may fail, and yet
4119 others may get temporary errors and so get marked DEFER.
4121 . The return from the delivery attempt is OK if a connection was made and a
4122 valid SMTP dialogue was completed. Otherwise it is DEFER.
4124 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4126 . If fail to connect, or other defer state, add a retry item.
4128 . If there are any addresses whose status is still DEFER, carry on to the
4129 next host/IPaddress, unless we have tried the number of hosts given
4130 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4131 there is some fancy logic for hosts_max_try that means its limit can be
4132 overstepped in some circumstances.
4134 If we get to the end of the list, all hosts have deferred at least one address,
4135 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4136 delivery attempt to those hosts whose last try was before the arrival time of
4137 the current message. To cope with this, we have to go round the loop a second
4138 time. After that, set the status and error data for any addresses that haven't
4139 had it set already. */
4141 for (cutoff_retry = 0;
4142 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4145 host_item *nexthost = NULL;
4146 int unexpired_hosts_tried = 0;
4147 BOOL continue_host_tried = FALSE;
4149 retry_non_continued:
4150 for (host = hostlist;
4152 && unexpired_hosts_tried < ob->hosts_max_try
4153 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4159 BOOL host_is_expired = FALSE;
4160 BOOL message_defer = FALSE;
4161 BOOL some_deferred = FALSE;
4162 address_item *first_addr = NULL;
4163 uschar *interface = NULL;
4164 uschar *retry_host_key = NULL;
4165 uschar *retry_message_key = NULL;
4166 uschar *serialize_key = NULL;
4168 /* Default next host is next host. :-) But this can vary if the
4169 hosts_max_try limit is hit (see below). It may also be reset if a host
4170 address is looked up here (in case the host was multihomed). */
4172 nexthost = host->next;
4174 /* If the address hasn't yet been obtained from the host name, look it up
4175 now, unless the host is already marked as unusable. If it is marked as
4176 unusable, it means that the router was unable to find its IP address (in
4177 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4178 the lookup failed last time. We don't get this far if *all* MX records
4179 point to non-existent hosts; that is treated as a hard error.
4181 We can just skip this host entirely. When the hosts came from the router,
4182 the address will timeout based on the other host(s); when the address is
4183 looked up below, there is an explicit retry record added.
4185 Note that we mustn't skip unusable hosts if the address is not unset; they
4186 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4190 int new_port, flags;
4193 if (host->status >= hstatus_unusable)
4195 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4200 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4202 /* The host name is permitted to have an attached port. Find it, and
4203 strip it from the name. Just remember it for now. */
4205 new_port = host_item_get_port(host);
4207 /* Count hosts looked up */
4211 /* Find by name if so configured, or if it's an IP address. We don't
4212 just copy the IP address, because we need the test-for-local to happen. */
4214 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4215 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4216 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4218 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4219 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4221 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4222 &ob->dnssec, /* domains for request/require */
4225 /* Update the host (and any additional blocks, resulting from
4226 multihoming) with a host-specific port, if any. */
4228 for (hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4230 /* Failure to find the host at this time (usually DNS temporary failure)
4231 is really a kind of routing failure rather than a transport failure.
4232 Therefore we add a retry item of the routing kind, not to stop us trying
4233 to look this name up here again, but to ensure the address gets timed
4234 out if the failures go on long enough. A complete failure at this point
4235 commonly points to a configuration error, but the best action is still
4236 to carry on for the next host. */
4238 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4240 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4242 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4243 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4244 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4245 host->status = hstatus_unusable;
4247 for (addr = addrlist; addr; addr = addr->next)
4249 if (addr->transport_return != DEFER) continue;
4250 addr->basic_errno = ERRNO_UNKNOWNHOST;
4251 addr->message = string_sprintf(
4252 rc == HOST_FIND_SECURITY
4253 ? "lookup of IP address for %s was insecure"
4254 : "failed to lookup IP address for %s",
4260 /* If the host is actually the local host, we may have a problem, or
4261 there may be some cunning configuration going on. In the problem case,
4262 log things and give up. The default transport status is already DEFER. */
4264 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4266 for (addr = addrlist; addr; addr = addr->next)
4268 addr->basic_errno = 0;
4269 addr->message = string_sprintf("%s transport found host %s to be "
4270 "local", tblock->name, host->name);
4274 } /* End of block for IP address lookup */
4276 /* If this is a continued delivery, we are interested only in the host
4277 which matches the name of the existing open channel. The check is put
4278 here after the local host lookup, in case the name gets expanded as a
4279 result of the lookup. Set expired FALSE, to save the outer loop executing
4282 if (continue_hostname)
4283 if ( Ustrcmp(continue_hostname, host->name) != 0
4284 || Ustrcmp(continue_host_address, host->address) != 0
4288 continue; /* With next host */
4291 continue_host_tried = TRUE;
4293 /* Reset the default next host in case a multihomed host whose addresses
4294 are not looked up till just above added to the host list. */
4296 nexthost = host->next;
4298 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4299 domain is in queue_smtp_domains, we don't actually want to attempt any
4300 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4301 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4302 were not in it. We don't want to hold up all SMTP deliveries! Except when
4303 doing a two-stage queue run, don't do this if forcing. */
4305 if ((!f.deliver_force || f.queue_2stage) && (f.queue_smtp ||
4306 match_isinlist(addrlist->domain,
4307 (const uschar **)&queue_smtp_domains, 0,
4308 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
4311 for (addr = addrlist; addr; addr = addr->next)
4312 if (addr->transport_return == DEFER)
4313 addr->message = US"domain matches queue_smtp_domains, or -odqs set";
4314 continue; /* With next host */
4317 /* Count hosts being considered - purely for an intelligent comment
4318 if none are usable. */
4322 /* Set $host and $host address now in case they are needed for the
4323 interface expansion or the serialize_hosts check; they remain set if an
4324 actual delivery happens. */
4326 deliver_host = host->name;
4327 deliver_host_address = host->address;
4328 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
4329 : host->dnssec == DS_NO ? US"no"
4332 /* Set up a string for adding to the retry key if the port number is not
4333 the standard SMTP port. A host may have its own port setting that overrides
4336 pistring = string_sprintf(":%d", host->port == PORT_NONE
4337 ? defport : host->port);
4338 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
4340 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4341 string is set, even if constant (as different transports can have different
4342 constant settings), we must add it to the key that is used for retries,
4343 because connections to the same host from a different interface should be
4344 treated separately. */
4346 host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
4347 if ((rs = ob->interface) && *rs)
4349 if (!smtp_get_interface(rs, host_af, addrlist, &interface, tid))
4351 pistring = string_sprintf("%s/%s", pistring, interface);
4354 /* The first time round the outer loop, check the status of the host by
4355 inspecting the retry data. The second time round, we are interested only
4356 in expired hosts that haven't been tried since this message arrived. */
4358 if (cutoff_retry == 0)
4361 /* Ensure the status of the address is set by checking retry data if
4362 necessary. There may be host-specific retry data (applicable to all
4363 messages) and also data for retries of a specific message at this host.
4364 If either of these retry records are actually read, the keys used are
4365 returned to save recomputing them later. */
4367 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4368 US"retry_include_ip_address", ob->retry_include_ip_address,
4369 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4370 continue; /* with next host */
4372 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
4373 incl_ip, &retry_host_key, &retry_message_key);
4375 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
4376 (host->address == NULL)? US"" : host->address, pistring,
4377 (host->status == hstatus_usable)? "usable" :
4378 (host->status == hstatus_unusable)? "unusable" :
4379 (host->status == hstatus_unusable_expired)? "unusable (expired)" : "?");
4381 /* Skip this address if not usable at this time, noting if it wasn't
4382 actually expired, both locally and in the address. */
4384 switch (host->status)
4386 case hstatus_unusable:
4388 setflag(addrlist, af_retry_skipped);
4391 case hstatus_unusable_expired:
4394 case hwhy_retry: hosts_retry++; break;
4395 case hwhy_failed: hosts_fail++; break;
4397 case hwhy_deferred: hosts_defer++; break;
4400 /* If there was a retry message key, implying that previously there
4401 was a message-specific defer, we don't want to update the list of
4402 messages waiting for these hosts. */
4404 if (retry_message_key) update_waiting = FALSE;
4405 continue; /* With the next host or IP address */
4409 /* Second time round the loop: if the address is set but expired, and
4410 the message is newer than the last try, let it through. */
4415 || host->status != hstatus_unusable_expired
4416 || host->last_try > received_time.tv_sec)
4418 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
4419 host->name, host->address, pistring);
4420 host_is_expired = TRUE;
4423 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
4424 it remains TRUE only if all hosts are expired and none are actually tried.
4429 /* If this host is listed as one to which access must be serialized,
4430 see if another Exim process has a connection to it, and if so, skip
4431 this host. If not, update the database to record our connection to it
4432 and remember this for later deletion. Do not do any of this if we are
4433 sending the message down a pre-existing connection. */
4435 if ( !continue_hostname
4436 && verify_check_given_host(&ob->serialize_hosts, host) == OK)
4438 serialize_key = string_sprintf("host-serialize-%s", host->name);
4439 if (!enq_start(serialize_key, 1))
4442 debug_printf("skipping host %s because another Exim process "
4443 "is connected to it\n", host->name);
4449 /* OK, we have an IP address that is not waiting for its retry time to
4450 arrive (it might be expired) OR (second time round the loop) we have an
4451 expired host that hasn't been tried since the message arrived. Have a go
4452 at delivering the message to it. First prepare the addresses by flushing
4453 out the result of previous attempts, and finding the first address that
4454 is still to be delivered. */
4456 first_addr = prepare_addresses(addrlist, host);
4458 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
4459 message_id, host->name, host->address, addrlist->address,
4460 addrlist->next ? ", ..." : "");
4462 set_process_info("delivering %s to %s [%s] (%s%s)",
4463 message_id, host->name, host->address, addrlist->address,
4464 addrlist->next ? ", ..." : "");
4466 /* This is not for real; don't do the delivery. If there are
4467 any remaining hosts, list them. */
4472 set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
4473 for (addr = addrlist; addr; addr = addr->next)
4475 addr->host_used = host;
4476 addr->special_action = '*';
4477 addr->message = US"delivery bypassed by -N option";
4481 debug_printf("*** delivery by %s transport bypassed by -N option\n"
4482 "*** host and remaining hosts:\n", tblock->name);
4483 for (host2 = host; host2; host2 = host2->next)
4484 debug_printf(" %s [%s]\n", host2->name,
4485 host2->address ? host2->address : US"unset");
4490 /* This is for real. If the host is expired, we don't count it for
4491 hosts_max_retry. This ensures that all hosts must expire before an address
4492 is timed out, unless hosts_max_try_hardlimit (which protects against
4493 lunatic DNS configurations) is reached.
4495 If the host is not expired and we are about to hit the hosts_max_retry
4496 limit, check to see if there is a subsequent hosts with a different MX
4497 value. If so, make that the next host, and don't count this one. This is a
4498 heuristic to make sure that different MXs do get tried. With a normal kind
4499 of retry rule, they would get tried anyway when the earlier hosts were
4500 delayed, but if the domain has a "retry every time" type of rule - as is
4501 often used for the the very large ISPs, that won't happen. */
4506 /* Make a copy of the host if it is local to this invocation
4507 of the transport. */
4511 thost = store_get(sizeof(host_item));
4513 thost->name = string_copy(host->name);
4514 thost->address = string_copy(host->address);
4519 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
4523 debug_printf("hosts_max_try limit reached with this host\n");
4524 for (h = host; h; h = h->next) if (h->mx != host->mx)
4527 unexpired_hosts_tried--;
4528 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
4529 "and will be tried\n");
4534 /* Attempt the delivery. */
4536 total_hosts_tried++;
4537 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
4538 &message_defer, FALSE);
4541 OK => connection made, each address contains its result;
4542 message_defer is set for message-specific defers (when all
4543 recipients are marked defer)
4544 DEFER => there was a non-message-specific delivery problem;
4545 ERROR => there was a problem setting up the arguments for a filter,
4546 or there was a problem with expanding added headers
4549 /* If the result is not OK, there was a non-message-specific problem.
4550 If the result is DEFER, we need to write to the logs saying what happened
4551 for this particular host, except in the case of authentication and TLS
4552 failures, where the log has already been written. If all hosts defer a
4553 general message is written at the end. */
4555 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
4556 && first_addr->basic_errno != ERRNO_TLSFAILURE)
4557 write_logs(host, first_addr->message, first_addr->basic_errno);
4559 #ifndef DISABLE_EVENT
4561 deferred_event_raise(first_addr, host);
4564 /* If STARTTLS was accepted, but there was a failure in setting up the
4565 TLS session (usually a certificate screwup), and the host is not in
4566 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
4567 TLS forcibly turned off. We have to start from scratch with a new SMTP
4568 connection. That's why the retry is done from here, not from within
4569 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
4570 session, so the in-clear transmission after those errors, if permitted,
4571 happens inside smtp_deliver().] */
4575 && first_addr->basic_errno == ERRNO_TLSFAILURE
4576 && ob->tls_tempfail_tryclear
4577 && verify_check_given_host(&ob->hosts_require_tls, host) != OK
4580 log_write(0, LOG_MAIN,
4581 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
4582 first_addr->message, host->name, host->address);
4583 first_addr = prepare_addresses(addrlist, host);
4584 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
4585 &message_defer, TRUE);
4586 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
4587 write_logs(host, first_addr->message, first_addr->basic_errno);
4588 # ifndef DISABLE_EVENT
4590 deferred_event_raise(first_addr, host);
4593 #endif /*SUPPORT_TLS*/
4596 /* Delivery attempt finished */
4598 rs = rc == OK ? US"OK"
4599 : rc == DEFER ? US"DEFER"
4600 : rc == ERROR ? US"ERROR"
4603 set_process_info("delivering %s: just tried %s [%s] for %s%s: result %s",
4604 message_id, host->name, host->address, addrlist->address,
4605 addrlist->next ? " (& others)" : "", rs);
4607 /* Release serialization if set up */
4609 if (serialize_key) enq_end(serialize_key);
4611 /* If the result is DEFER, or if a host retry record is known to exist, we
4612 need to add an item to the retry chain for updating the retry database
4613 at the end of delivery. We only need to add the item to the top address,
4614 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
4615 for any other delivery attempts using the same address. (It is copied into
4616 the unusable tree at the outer level, so even if different address blocks
4617 contain the same address, it still won't get tried again.) */
4619 if (rc == DEFER || retry_host_key)
4621 int delete_flag = rc != DEFER ? rf_delete : 0;
4622 if (!retry_host_key)
4625 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4626 US"retry_include_ip_address", ob->retry_include_ip_address,
4627 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4628 incl_ip = TRUE; /* error; use most-specific retry record */
4630 retry_host_key = incl_ip
4631 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
4632 : string_sprintf("T:%S%s", host->name, pistring);
4635 /* If a delivery of another message over an existing SMTP connection
4636 yields DEFER, we do NOT set up retry data for the host. This covers the
4637 case when there are delays in routing the addresses in the second message
4638 that are so long that the server times out. This is alleviated by not
4639 routing addresses that previously had routing defers when handling an
4640 existing connection, but even so, this case may occur (e.g. if a
4641 previously happily routed address starts giving routing defers). If the
4642 host is genuinely down, another non-continued message delivery will
4643 notice it soon enough. */
4645 if (delete_flag != 0 || !continue_hostname)
4646 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
4648 /* We may have tried an expired host, if its retry time has come; ensure
4649 the status reflects the expiry for the benefit of any other addresses. */
4653 host->status = host_is_expired
4654 ? hstatus_unusable_expired : hstatus_unusable;
4655 host->why = hwhy_deferred;
4659 /* If message_defer is set (host was OK, but every recipient got deferred
4660 because of some message-specific problem), or if that had happened
4661 previously so that a message retry key exists, add an appropriate item
4662 to the retry chain. Note that if there was a message defer but now there is
4663 a host defer, the message defer record gets deleted. That seems perfectly
4664 reasonable. Also, stop the message from being remembered as waiting
4665 for specific hosts. */
4667 if (message_defer || retry_message_key)
4669 int delete_flag = message_defer ? 0 : rf_delete;
4670 if (!retry_message_key)
4673 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4674 US"retry_include_ip_address", ob->retry_include_ip_address,
4675 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4676 incl_ip = TRUE; /* error; use most-specific retry record */
4678 retry_message_key = incl_ip
4679 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
4681 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
4683 retry_add_item(addrlist, retry_message_key,
4684 rf_message | rf_host | delete_flag);
4685 update_waiting = FALSE;
4688 /* Any return other than DEFER (that is, OK or ERROR) means that the
4689 addresses have got their final statuses filled in for this host. In the OK
4690 case, see if any of them are deferred. */
4693 for (addr = addrlist; addr; addr = addr->next)
4694 if (addr->transport_return == DEFER)
4696 some_deferred = TRUE;
4700 /* If no addresses deferred or the result was ERROR, return. We do this for
4701 ERROR because a failing filter set-up or add_headers expansion is likely to
4702 fail for any host we try. */
4704 if (rc == ERROR || (rc == OK && !some_deferred))
4706 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
4707 return TRUE; /* Each address has its status */
4710 /* If the result was DEFER or some individual addresses deferred, let
4711 the loop run to try other hosts with the deferred addresses, except for the
4712 case when we were trying to deliver down an existing channel and failed.
4713 Don't try any other hosts in this case. */
4715 if (continue_hostname) break;
4717 /* If the whole delivery, or some individual addresses, were deferred and
4718 there are more hosts that could be tried, do not count this host towards
4719 the hosts_max_try limit if the age of the message is greater than the
4720 maximum retry time for this host. This means we may try try all hosts,
4721 ignoring the limit, when messages have been around for some time. This is
4722 important because if we don't try all hosts, the address will never time
4723 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
4725 if ((rc == DEFER || some_deferred) && nexthost)
4728 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
4730 if (retry && retry->rules)
4732 retry_rule *last_rule;
4733 for (last_rule = retry->rules;
4735 last_rule = last_rule->next);
4736 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
4738 else timedout = TRUE; /* No rule => timed out */
4742 unexpired_hosts_tried--;
4743 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
4744 "hosts_max_try (message older than host's retry time)\n");
4747 } /* End of loop for trying multiple hosts. */
4749 /* If we failed to find a matching host in the list, for an already-open
4750 connection, just close it and start over with the list. This can happen
4751 for routing that changes from run to run, or big multi-IP sites with
4754 if (continue_hostname && !continue_host_tried)
4756 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
4758 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
4760 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
4762 /*XXX doublecheck that! */
4764 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
4766 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
4767 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4768 cutthrough.cctx.tls_ctx = NULL;
4769 cutthrough.is_tls = FALSE;
4773 (void) write(fd, US"QUIT\r\n", 6);
4776 cutthrough.cctx.sock = -1;
4777 continue_hostname = NULL;
4778 goto retry_non_continued;
4781 /* This is the end of the loop that repeats iff expired is TRUE and
4782 ob->delay_after_cutoff is FALSE. The second time round we will
4783 try those hosts that haven't been tried since the message arrived. */
4787 debug_printf("all IP addresses skipped or deferred at least one address\n");
4788 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
4789 debug_printf("retrying IP addresses not tried since message arrived\n");
4794 /* Get here if all IP addresses are skipped or defer at least one address. In
4795 MUA wrapper mode, this will happen only for connection or other non-message-
4796 specific failures. Force the delivery status for all addresses to FAIL. */
4800 for (addr = addrlist; addr; addr = addr->next)
4801 addr->transport_return = FAIL;
4805 /* In the normal, non-wrapper case, add a standard message to each deferred
4806 address if there hasn't been an error, that is, if it hasn't actually been
4807 tried this time. The variable "expired" will be FALSE if any deliveries were
4808 actually tried, or if there was at least one host that was not expired. That
4809 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
4810 a delivery has been tried, an error code will be set, and the failing of the
4811 message is handled by the retry code later.
4813 If queue_smtp is set, or this transport was called to send a subsequent message
4814 down an existing TCP/IP connection, and something caused the host not to be
4815 found, we end up here, but can detect these cases and handle them specially. */
4817 for (addr = addrlist; addr; addr = addr->next)
4819 /* If host is not NULL, it means that we stopped processing the host list
4820 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
4821 means we need to behave as if some hosts were skipped because their retry
4822 time had not come. Specifically, this prevents the address from timing out.
4823 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
4824 hosts were tried. */
4827 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
4830 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
4831 "hosts were tried\n");
4836 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
4837 setflag(addr, af_retry_skipped);
4840 if (f.queue_smtp) /* no deliveries attempted */
4842 addr->transport_return = DEFER;
4843 addr->basic_errno = 0;
4844 addr->message = US"SMTP delivery explicitly queued";
4847 else if ( addr->transport_return == DEFER
4848 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
4852 addr->basic_errno = ERRNO_HRETRY;
4853 if (continue_hostname)
4854 addr->message = US"no host found for existing SMTP connection";
4857 setflag(addr, af_pass_message); /* This is not a security risk */
4858 addr->message = string_sprintf(
4859 "all hosts%s have been failing for a long time %s",
4860 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
4861 ob->delay_after_cutoff
4862 ? US"(and retry time not reached)"
4863 : US"and were last tried after this message arrived");
4865 /* If we are already using fallback hosts, or there are no fallback hosts
4866 defined, convert the result to FAIL to cause a bounce. */
4868 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
4869 addr->transport_return = FAIL;
4874 if (hosts_retry == hosts_total)
4875 s = "retry time not reached for any host%s";
4876 else if (hosts_fail == hosts_total)
4877 s = "all host address lookups%s failed permanently";
4878 else if (hosts_defer == hosts_total)
4879 s = "all host address lookups%s failed temporarily";
4880 else if (hosts_serial == hosts_total)
4881 s = "connection limit reached for all hosts%s";
4882 else if (hosts_fail+hosts_defer == hosts_total)
4883 s = "all host address lookups%s failed";
4885 s = "some host address lookups failed and retry time "
4886 "not reached for other hosts or connection limit reached%s";
4888 addr->message = string_sprintf(s,
4889 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
4894 /* Update the database which keeps information about which messages are waiting
4895 for which hosts to become available. For some message-specific errors, the
4896 update_waiting flag is turned off because we don't want follow-on deliveries in
4897 those cases. If this transport instance is explicitly limited to one message
4898 per connection then follow-on deliveries are not possible and there's no need
4899 to create/update the per-transport wait-<transport_name> database. */
4901 if (update_waiting && tblock->connection_max_messages != 1)
4902 transport_update_waiting(hostlist, tblock->name);
4906 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
4908 return TRUE; /* Each address has its status */
4911 #endif /*!MACRO_PREDEF*/
4914 /* End of transport/smtp.c */