1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
12 /* Options specific to the smtp transport. This transport also supports LMTP
13 over TCP/IP. The options must be in alphabetic order (note that "_" comes
14 before the lower case letters). Some live in the transport_instance block so as
15 to be publicly visible; these are flagged with opt_public. */
17 optionlist smtp_transport_options[] = {
18 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
19 (void *)offsetof(transport_instance, expand_multi_domain) },
20 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
21 (void *)(offsetof(smtp_transport_options_block, expand_retry_include_ip_address)) },
23 { "address_retry_include_sender", opt_bool,
24 (void *)offsetof(smtp_transport_options_block, address_retry_include_sender) },
25 { "allow_localhost", opt_bool,
26 (void *)offsetof(smtp_transport_options_block, allow_localhost) },
27 #ifdef EXPERIMENTAL_ARC
28 { "arc_sign", opt_stringptr,
29 (void *)offsetof(smtp_transport_options_block, arc_sign) },
31 { "authenticated_sender", opt_stringptr,
32 (void *)offsetof(smtp_transport_options_block, authenticated_sender) },
33 { "authenticated_sender_force", opt_bool,
34 (void *)offsetof(smtp_transport_options_block, authenticated_sender_force) },
35 { "command_timeout", opt_time,
36 (void *)offsetof(smtp_transport_options_block, command_timeout) },
37 { "connect_timeout", opt_time,
38 (void *)offsetof(smtp_transport_options_block, connect_timeout) },
39 { "connection_max_messages", opt_int | opt_public,
40 (void *)offsetof(transport_instance, connection_max_messages) },
42 { "dane_require_tls_ciphers", opt_stringptr,
43 (void *)offsetof(smtp_transport_options_block, dane_require_tls_ciphers) },
45 { "data_timeout", opt_time,
46 (void *)offsetof(smtp_transport_options_block, data_timeout) },
47 { "delay_after_cutoff", opt_bool,
48 (void *)offsetof(smtp_transport_options_block, delay_after_cutoff) },
50 { "dkim_canon", opt_stringptr,
51 (void *)offsetof(smtp_transport_options_block, dkim.dkim_canon) },
52 { "dkim_domain", opt_stringptr,
53 (void *)offsetof(smtp_transport_options_block, dkim.dkim_domain) },
54 { "dkim_hash", opt_stringptr,
55 (void *)offsetof(smtp_transport_options_block, dkim.dkim_hash) },
56 { "dkim_identity", opt_stringptr,
57 (void *)offsetof(smtp_transport_options_block, dkim.dkim_identity) },
58 { "dkim_private_key", opt_stringptr,
59 (void *)offsetof(smtp_transport_options_block, dkim.dkim_private_key) },
60 { "dkim_selector", opt_stringptr,
61 (void *)offsetof(smtp_transport_options_block, dkim.dkim_selector) },
62 { "dkim_sign_headers", opt_stringptr,
63 (void *)offsetof(smtp_transport_options_block, dkim.dkim_sign_headers) },
64 { "dkim_strict", opt_stringptr,
65 (void *)offsetof(smtp_transport_options_block, dkim.dkim_strict) },
66 { "dkim_timestamps", opt_stringptr,
67 (void *)offsetof(smtp_transport_options_block, dkim.dkim_timestamps) },
69 { "dns_qualify_single", opt_bool,
70 (void *)offsetof(smtp_transport_options_block, dns_qualify_single) },
71 { "dns_search_parents", opt_bool,
72 (void *)offsetof(smtp_transport_options_block, dns_search_parents) },
73 { "dnssec_request_domains", opt_stringptr,
74 (void *)offsetof(smtp_transport_options_block, dnssec.request) },
75 { "dnssec_require_domains", opt_stringptr,
76 (void *)offsetof(smtp_transport_options_block, dnssec.require) },
77 { "dscp", opt_stringptr,
78 (void *)offsetof(smtp_transport_options_block, dscp) },
79 { "fallback_hosts", opt_stringptr,
80 (void *)offsetof(smtp_transport_options_block, fallback_hosts) },
81 { "final_timeout", opt_time,
82 (void *)offsetof(smtp_transport_options_block, final_timeout) },
83 { "gethostbyname", opt_bool,
84 (void *)offsetof(smtp_transport_options_block, gethostbyname) },
85 { "helo_data", opt_stringptr,
86 (void *)offsetof(smtp_transport_options_block, helo_data) },
87 { "hosts", opt_stringptr,
88 (void *)offsetof(smtp_transport_options_block, hosts) },
89 { "hosts_avoid_esmtp", opt_stringptr,
90 (void *)offsetof(smtp_transport_options_block, hosts_avoid_esmtp) },
91 { "hosts_avoid_pipelining", opt_stringptr,
92 (void *)offsetof(smtp_transport_options_block, hosts_avoid_pipelining) },
94 { "hosts_avoid_tls", opt_stringptr,
95 (void *)offsetof(smtp_transport_options_block, hosts_avoid_tls) },
97 { "hosts_max_try", opt_int,
98 (void *)offsetof(smtp_transport_options_block, hosts_max_try) },
99 { "hosts_max_try_hardlimit", opt_int,
100 (void *)offsetof(smtp_transport_options_block, hosts_max_try_hardlimit) },
102 { "hosts_nopass_tls", opt_stringptr,
103 (void *)offsetof(smtp_transport_options_block, hosts_nopass_tls) },
104 { "hosts_noproxy_tls", opt_stringptr,
105 (void *)offsetof(smtp_transport_options_block, hosts_noproxy_tls) },
107 { "hosts_override", opt_bool,
108 (void *)offsetof(smtp_transport_options_block, hosts_override) },
109 #ifdef EXPERIMENTAL_PIPE_CONNECT
110 { "hosts_pipe_connect", opt_stringptr,
111 (void *)offsetof(smtp_transport_options_block, hosts_pipe_connect) },
113 { "hosts_randomize", opt_bool,
114 (void *)offsetof(smtp_transport_options_block, hosts_randomize) },
115 #if defined(SUPPORT_TLS) && !defined(DISABLE_OCSP)
116 { "hosts_request_ocsp", opt_stringptr,
117 (void *)offsetof(smtp_transport_options_block, hosts_request_ocsp) },
119 { "hosts_require_auth", opt_stringptr,
120 (void *)offsetof(smtp_transport_options_block, hosts_require_auth) },
123 { "hosts_require_dane", opt_stringptr,
124 (void *)offsetof(smtp_transport_options_block, hosts_require_dane) },
126 # ifndef DISABLE_OCSP
127 { "hosts_require_ocsp", opt_stringptr,
128 (void *)offsetof(smtp_transport_options_block, hosts_require_ocsp) },
130 { "hosts_require_tls", opt_stringptr,
131 (void *)offsetof(smtp_transport_options_block, hosts_require_tls) },
133 { "hosts_try_auth", opt_stringptr,
134 (void *)offsetof(smtp_transport_options_block, hosts_try_auth) },
135 { "hosts_try_chunking", opt_stringptr,
136 (void *)offsetof(smtp_transport_options_block, hosts_try_chunking) },
137 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
138 { "hosts_try_dane", opt_stringptr,
139 (void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
141 { "hosts_try_fastopen", opt_stringptr,
142 (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
144 { "hosts_try_prdr", opt_stringptr,
145 (void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
148 { "hosts_verify_avoid_tls", opt_stringptr,
149 (void *)offsetof(smtp_transport_options_block, hosts_verify_avoid_tls) },
151 { "interface", opt_stringptr,
152 (void *)offsetof(smtp_transport_options_block, interface) },
153 { "keepalive", opt_bool,
154 (void *)offsetof(smtp_transport_options_block, keepalive) },
155 { "lmtp_ignore_quota", opt_bool,
156 (void *)offsetof(smtp_transport_options_block, lmtp_ignore_quota) },
157 { "max_rcpt", opt_int | opt_public,
158 (void *)offsetof(transport_instance, max_addresses) },
159 { "multi_domain", opt_expand_bool | opt_public,
160 (void *)offsetof(transport_instance, multi_domain) },
161 { "port", opt_stringptr,
162 (void *)offsetof(smtp_transport_options_block, port) },
163 { "protocol", opt_stringptr,
164 (void *)offsetof(smtp_transport_options_block, protocol) },
165 { "retry_include_ip_address", opt_expand_bool,
166 (void *)offsetof(smtp_transport_options_block, retry_include_ip_address) },
167 { "serialize_hosts", opt_stringptr,
168 (void *)offsetof(smtp_transport_options_block, serialize_hosts) },
169 { "size_addition", opt_int,
170 (void *)offsetof(smtp_transport_options_block, size_addition) },
172 { "socks_proxy", opt_stringptr,
173 (void *)offsetof(smtp_transport_options_block, socks_proxy) },
176 { "tls_certificate", opt_stringptr,
177 (void *)offsetof(smtp_transport_options_block, tls_certificate) },
178 { "tls_crl", opt_stringptr,
179 (void *)offsetof(smtp_transport_options_block, tls_crl) },
180 { "tls_dh_min_bits", opt_int,
181 (void *)offsetof(smtp_transport_options_block, tls_dh_min_bits) },
182 { "tls_privatekey", opt_stringptr,
183 (void *)offsetof(smtp_transport_options_block, tls_privatekey) },
184 { "tls_require_ciphers", opt_stringptr,
185 (void *)offsetof(smtp_transport_options_block, tls_require_ciphers) },
186 { "tls_sni", opt_stringptr,
187 (void *)offsetof(smtp_transport_options_block, tls_sni) },
188 { "tls_tempfail_tryclear", opt_bool,
189 (void *)offsetof(smtp_transport_options_block, tls_tempfail_tryclear) },
190 { "tls_try_verify_hosts", opt_stringptr,
191 (void *)offsetof(smtp_transport_options_block, tls_try_verify_hosts) },
192 { "tls_verify_cert_hostnames", opt_stringptr,
193 (void *)offsetof(smtp_transport_options_block,tls_verify_cert_hostnames)},
194 { "tls_verify_certificates", opt_stringptr,
195 (void *)offsetof(smtp_transport_options_block, tls_verify_certificates) },
196 { "tls_verify_hosts", opt_stringptr,
197 (void *)offsetof(smtp_transport_options_block, tls_verify_hosts) },
200 { "utf8_downconvert", opt_stringptr,
201 (void *)offsetof(smtp_transport_options_block, utf8_downconvert) },
205 /* Size of the options list. An extern variable has to be used so that its
206 address can appear in the tables drtables.c. */
208 int smtp_transport_options_count = nelem(smtp_transport_options);
214 smtp_transport_options_block smtp_transport_option_defaults = {0};
215 void smtp_transport_init(transport_instance *tblock) {}
216 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
217 void smtp_transport_closedown(transport_instance *tblock) {}
219 #else /*!MACRO_PREDEF*/
222 /* Default private options block for the smtp transport. */
224 smtp_transport_options_block smtp_transport_option_defaults = {
226 .fallback_hosts = NULL,
228 .fallback_hostlist = NULL,
229 .helo_data = US"$primary_hostname",
232 .protocol = US"smtp",
234 .serialize_hosts = NULL,
235 .hosts_try_auth = NULL,
236 .hosts_require_auth = NULL,
237 .hosts_try_chunking = US"*",
239 .hosts_try_dane = NULL,
240 .hosts_require_dane = NULL,
241 .dane_require_tls_ciphers = NULL,
243 .hosts_try_fastopen = NULL,
245 .hosts_try_prdr = US"*",
248 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
249 .hosts_require_ocsp = NULL,
251 .hosts_require_tls = NULL,
252 .hosts_avoid_tls = NULL,
253 .hosts_verify_avoid_tls = NULL,
254 .hosts_avoid_pipelining = NULL,
255 #ifdef EXPERIMENTAL_PIPE_CONNECT
256 .hosts_pipe_connect = NULL,
258 .hosts_avoid_esmtp = NULL,
260 .hosts_nopass_tls = NULL,
261 .hosts_noproxy_tls = US"*",
263 .command_timeout = 5*60,
264 .connect_timeout = 5*60,
265 .data_timeout = 5*60,
266 .final_timeout = 10*60,
267 .size_addition = 1024,
269 .hosts_max_try_hardlimit = 50,
270 .address_retry_include_sender = TRUE,
271 .allow_localhost = FALSE,
272 .authenticated_sender_force = FALSE,
273 .gethostbyname = FALSE,
274 .dns_qualify_single = TRUE,
275 .dns_search_parents = FALSE,
276 .dnssec = { .request=NULL, .require=NULL },
277 .delay_after_cutoff = TRUE,
278 .hosts_override = FALSE,
279 .hosts_randomize = FALSE,
281 .lmtp_ignore_quota = FALSE,
282 .expand_retry_include_ip_address = NULL,
283 .retry_include_ip_address = TRUE,
288 .tls_certificate = NULL,
290 .tls_privatekey = NULL,
291 .tls_require_ciphers = NULL,
293 .tls_verify_certificates = US"system",
294 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
295 .tls_tempfail_tryclear = TRUE,
296 .tls_verify_hosts = NULL,
297 .tls_try_verify_hosts = US"*",
298 .tls_verify_cert_hostnames = US"*",
301 .utf8_downconvert = NULL,
305 {.dkim_domain = NULL,
306 .dkim_identity = NULL,
307 .dkim_private_key = NULL,
308 .dkim_selector = NULL,
310 .dkim_sign_headers = NULL,
312 .dkim_hash = US"sha256",
313 .dkim_timestamps = NULL,
314 .dot_stuffed = FALSE,
315 .force_bodyhash = FALSE,
316 # ifdef EXPERIMENTAL_ARC
317 .arc_signspec = NULL,
320 # ifdef EXPERIMENTAL_ARC
326 /* some DSN flags for use later */
328 static int rf_list[] = {rf_notify_never, rf_notify_success,
329 rf_notify_failure, rf_notify_delay };
331 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
337 static uschar *smtp_command; /* Points to last cmd for error messages */
338 static uschar *mail_command; /* Points to MAIL cmd for error messages */
339 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
340 static BOOL update_waiting; /* TRUE to update the "wait" database */
342 /*XXX move to smtp_context */
343 static BOOL pipelining_active; /* current transaction is in pipe mode */
346 static unsigned ehlo_response(uschar * buf, unsigned checks);
349 /*************************************************
350 * Setup entry point *
351 *************************************************/
353 /* This function is called when the transport is about to be used,
354 but before running it in a sub-process. It is used for two things:
356 (1) To set the fallback host list in addresses, when delivering.
357 (2) To pass back the interface, port, protocol, and other options, for use
358 during callout verification.
361 tblock pointer to the transport instance block
362 addrlist list of addresses about to be transported
363 tf if not NULL, pointer to block in which to return options
364 uid the uid that will be set (not used)
365 gid the gid that will be set (not used)
366 errmsg place for error message (not used)
368 Returns: OK always (FAIL, DEFER not used)
372 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
373 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
375 smtp_transport_options_block *ob = SOB tblock->options_block;
377 errmsg = errmsg; /* Keep picky compilers happy */
381 /* Pass back options if required. This interface is getting very messy. */
385 tf->interface = ob->interface;
387 tf->protocol = ob->protocol;
388 tf->hosts = ob->hosts;
389 tf->hosts_override = ob->hosts_override;
390 tf->hosts_randomize = ob->hosts_randomize;
391 tf->gethostbyname = ob->gethostbyname;
392 tf->qualify_single = ob->dns_qualify_single;
393 tf->search_parents = ob->dns_search_parents;
394 tf->helo_data = ob->helo_data;
397 /* Set the fallback host list for all the addresses that don't have fallback
398 host lists, provided that the local host wasn't present in the original host
401 if (!testflag(addrlist, af_local_host_removed))
402 for (; addrlist; addrlist = addrlist->next)
403 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
410 /*************************************************
411 * Initialization entry point *
412 *************************************************/
414 /* Called for each instance, after its options have been read, to
415 enable consistency checks to be done, or anything else that needs
418 Argument: pointer to the transport instance block
423 smtp_transport_init(transport_instance *tblock)
425 smtp_transport_options_block *ob = SOB tblock->options_block;
427 /* Retry_use_local_part defaults FALSE if unset */
429 if (tblock->retry_use_local_part == TRUE_UNSET)
430 tblock->retry_use_local_part = FALSE;
432 /* Set the default port according to the protocol */
435 ob->port = strcmpic(ob->protocol, US"lmtp") == 0
437 : strcmpic(ob->protocol, US"smtps") == 0
438 ? US"smtps" : US"smtp";
440 /* Set up the setup entry point, to be called before subprocesses for this
443 tblock->setup = smtp_transport_setup;
445 /* Complain if any of the timeouts are zero. */
447 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
448 ob->final_timeout <= 0)
449 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
450 "command, data, or final timeout value is zero for %s transport",
453 /* If hosts_override is set and there are local hosts, set the global
454 flag that stops verify from showing router hosts. */
456 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
458 /* If there are any fallback hosts listed, build a chain of host items
459 for them, but do not do any lookups at this time. */
461 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
468 /*************************************************
469 * Set delivery info into all active addresses *
470 *************************************************/
472 /* Only addresses whose status is >= PENDING are relevant. A lesser
473 status means that an address is not currently being processed.
476 addrlist points to a chain of addresses
477 errno_value to put in each address's errno field
478 msg to put in each address's message field
479 rc to put in each address's transport_return field
480 pass_message if TRUE, set the "pass message" flag in the address
481 host if set, mark addrs as having used this host
482 smtp_greeting from peer
483 helo_response from peer
485 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
486 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
487 this particular type of timeout.
493 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
494 BOOL pass_message, host_item * host
495 #ifdef EXPERIMENTAL_DSN_INFO
496 , const uschar * smtp_greeting, const uschar * helo_response
502 if (errno_value == ERRNO_CONNECTTIMEOUT)
504 errno_value = ETIMEDOUT;
505 orvalue = RTEF_CTOUT;
507 for (addr = addrlist; addr; addr = addr->next)
508 if (addr->transport_return >= PENDING)
510 addr->basic_errno = errno_value;
511 addr->more_errno |= orvalue;
515 if (pass_message) setflag(addr, af_pass_message);
517 addr->transport_return = rc;
520 addr->host_used = host;
521 #ifdef EXPERIMENTAL_DSN_INFO
523 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
524 addr->smtp_greeting = smtp_greeting;
527 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
528 addr->helo_response = helo_response;
535 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
538 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
539 #ifdef EXPERIMENTAL_DSN_INFO
546 /*************************************************
547 * Check an SMTP response *
548 *************************************************/
550 /* This function is given an errno code and the SMTP response buffer
551 to analyse, together with the host identification for generating messages. It
552 sets an appropriate message and puts the first digit of the response code into
553 the yield variable. If no response was actually read, a suitable digit is
557 host the current host, to get its name for messages
558 errno_value pointer to the errno value
559 more_errno from the top address for use with ERRNO_FILTER_FAIL
560 buffer the SMTP response buffer
561 yield where to put a one-digit SMTP response code
562 message where to put an error message
563 pass_message set TRUE if message is an SMTP response
565 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
569 check_response(host_item *host, int *errno_value, int more_errno,
570 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
572 uschar * pl = pipelining_active ? US"pipelined " : US"";
575 *yield = '4'; /* Default setting is to give a temporary error */
579 case ETIMEDOUT: /* Handle response timeout */
580 *message = US string_sprintf("SMTP timeout after %s%s",
582 if (transport_count > 0)
583 *message = US string_sprintf("%s (%d bytes written)", *message,
587 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
588 s = string_printing(buffer);
589 while (isspace(*s)) s++;
591 ? string_sprintf("Malformed SMTP reply (an empty line) "
592 "in response to %s%s", pl, smtp_command)
593 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
594 pl, smtp_command, s);
597 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
598 can't send QUIT as we mustn't end the DATA. */
599 *message = string_sprintf("transport filter process failed (%d)%s",
601 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
604 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
605 can't send QUIT as we mustn't end the DATA. */
607 string_sprintf("failed to expand headers_add or headers_remove: %s",
608 expand_string_message);
611 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
612 *message = string_sprintf("failed to write a data block");
616 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
617 *message = US"utf8 support required but not offered for forwarding";
618 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
623 /* Handle error responses from the remote mailer. */
627 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
628 "%s", pl, smtp_command, s = string_printing(buffer));
629 *pass_message = TRUE;
634 /* No data was read. If there is no errno, this must be the EOF (i.e.
635 connection closed) case, which causes deferral. An explicit connection reset
636 error has the same effect. Otherwise, put the host's identity in the message,
637 leaving the errno value to be interpreted as well. In all cases, we have to
638 assume the connection is now dead. */
640 if (*errno_value == 0 || *errno_value == ECONNRESET)
642 *errno_value = ERRNO_SMTPCLOSED;
643 *message = US string_sprintf("Remote host closed connection "
644 "in response to %s%s", pl, smtp_command);
647 *message = US string_sprintf("%s [%s]", host->name, host->address);
654 /*************************************************
655 * Write error message to logs *
656 *************************************************/
658 /* This writes to the main log and to the message log.
661 host the current host
662 detail the current message (addr_item->message)
663 basic_errno the errno (addr_item->basic_errno)
669 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
671 uschar *message = LOGGING(outgoing_port)
672 ? string_sprintf("H=%s [%s]:%d", host->name, host->address,
673 host->port == PORT_NONE ? 25 : host->port)
674 : string_sprintf("H=%s [%s]", host->name, host->address);
678 message = string_sprintf("%s: %s", message, suffix);
680 message = string_sprintf("%s: %s", message, strerror(basic_errno));
683 message = string_sprintf("%s %s", message, exim_errstr(basic_errno));
685 log_write(0, LOG_MAIN, "%s", message);
686 deliver_msglog("%s %s\n", tod_stamp(tod_log), message);
690 msglog_line(host_item * host, uschar * message)
692 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
693 host->name, host->address, message);
698 #ifndef DISABLE_EVENT
699 /*************************************************
700 * Post-defer action *
701 *************************************************/
703 /* This expands an arbitrary per-transport string.
704 It might, for example, be used to write to the database log.
707 addr the address item containing error information
708 host the current host
714 deferred_event_raise(address_item *addr, host_item *host)
716 uschar * action = addr->transport->event_action;
717 const uschar * save_domain;
723 save_domain = deliver_domain;
724 save_local = deliver_localpart;
726 /*XXX would ip & port already be set up? */
727 deliver_host_address = string_copy(host->address);
728 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
729 event_defer_errno = addr->basic_errno;
731 router_name = addr->router->name;
732 transport_name = addr->transport->name;
733 deliver_domain = addr->domain;
734 deliver_localpart = addr->local_part;
736 (void) event_raise(action, US"msg:host:defer",
738 ? addr->basic_errno > 0
739 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
740 : string_copy(addr->message)
741 : addr->basic_errno > 0
742 ? string_copy(US strerror(addr->basic_errno))
745 deliver_localpart = save_local;
746 deliver_domain = save_domain;
747 router_name = transport_name = NULL;
751 /*************************************************
752 * Reap SMTP specific responses *
753 *************************************************/
755 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
758 uschar flushbuffer[4096];
762 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
763 '2', ob->command_timeout)
764 && (errno != 0 || flushbuffer[0] == 0))
771 /* Return boolean success */
774 smtp_reap_banner(smtp_context * sx)
776 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
777 '2', (SOB sx->conn_args.ob)->command_timeout);
778 #ifdef EXPERIMENTAL_DSN_INFO
779 sx->smtp_greeting = string_copy(sx->buffer);
781 return good_response;
785 smtp_reap_ehlo(smtp_context * sx)
787 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
788 (SOB sx->conn_args.ob)->command_timeout))
790 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
792 #ifdef EXPERIMENTAL_DSN_INFO
793 sx->helo_response = string_copy(sx->buffer);
799 #ifdef EXPERIMENTAL_DSN_INFO
800 sx->helo_response = string_copy(sx->buffer);
807 #ifdef EXPERIMENTAL_PIPE_CONNECT
809 ehlo_cache_key(const smtp_context * sx)
811 host_item * host = sx->conn_args.host;
812 return Ustrchr(host->address, ':')
813 ? string_sprintf("[%s]:%d.EHLO", host->address,
814 host->port == PORT_NONE ? sx->port : host->port)
815 : string_sprintf("%s:%d.EHLO", host->address,
816 host->port == PORT_NONE ? sx->port : host->port);
820 write_ehlo_cache_entry(const smtp_context * sx)
822 open_db dbblock, * dbm_file;
824 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
826 uschar * ehlo_resp_key = ehlo_cache_key(sx);
827 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
829 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
830 dbfn_close(dbm_file);
835 invalidate_ehlo_cache_entry(smtp_context * sx)
837 open_db dbblock, * dbm_file;
839 if ( sx->early_pipe_active
840 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
842 uschar * ehlo_resp_key = ehlo_cache_key(sx);
843 dbfn_delete(dbm_file, ehlo_resp_key);
844 dbfn_close(dbm_file);
849 read_ehlo_cache_entry(smtp_context * sx)
854 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE)))
855 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
858 uschar * ehlo_resp_key = ehlo_cache_key(sx);
859 dbdata_ehlo_resp * er;
861 if (!(er = dbfn_read(dbm_file, ehlo_resp_key)))
862 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
863 else if (time(NULL) - er->time_stamp > retry_data_expire)
865 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
866 dbfn_close(dbm_file);
867 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
868 dbfn_delete(dbm_file, ehlo_resp_key);
872 sx->ehlo_resp = er->data;
873 dbfn_close(dbm_file);
874 DEBUG(D_transport) debug_printf(
875 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
876 er->data.cleartext_features, er->data.crypted_features);
879 dbfn_close(dbm_file);
886 /* Return an auths bitmap for the set of AUTH methods offered by the server
887 which match our authenticators. */
889 static unsigned short
890 study_ehlo_auths(smtp_context * sx)
895 unsigned short authbits = 0;
897 if (!sx->esmtp) return 0;
898 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
899 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
900 expand_nmax = -1; /* reset */
901 names = string_copyn(expand_nstring[1], expand_nlength[1]);
903 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
905 const uschar * list = names;
909 while (string_nextinlist(&list, &sep, name, sizeof(name)))
910 if (strcmpic(au->public_name, name) == 0)
911 { authbits |= BIT(authnum); break; }
915 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
916 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
918 if (tls_out.active.sock >= 0)
919 sx->ehlo_resp.crypted_auths = authbits;
921 sx->ehlo_resp.cleartext_auths = authbits;
928 /* Wait for and check responses for early-pipelining.
930 Called from the lower-level smtp_read_response() function
931 used for general code that assume synchronisation, if context
932 flags indicate outstanding early-pipelining commands. Also
933 called fom sync_responses() which handles pipelined commands.
936 sx smtp connection context
937 countp number of outstanding responses, adjusted on return
941 FAIL SMTP error in response
944 smtp_reap_early_pipe(smtp_context * sx, int * countp)
946 BOOL pending_BANNER = sx->pending_BANNER;
947 BOOL pending_EHLO = sx->pending_EHLO;
949 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
950 sx->pending_EHLO = FALSE;
954 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
956 if (!smtp_reap_banner(sx))
958 DEBUG(D_transport) debug_printf("bad banner\n");
965 unsigned peer_offered;
966 unsigned short authbits = 0, * ap;
968 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
970 if (!smtp_reap_ehlo(sx))
972 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
976 /* Compare the actual EHLO response to the cached value we assumed;
977 on difference, dump or rewrite the cache and arrange for a retry. */
979 ap = tls_out.active.sock < 0
980 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
982 peer_offered = ehlo_response(sx->buffer,
983 (tls_out.active.sock < 0 ? OPTION_TLS : OPTION_REQUIRETLS)
984 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
985 | OPTION_UTF8 | OPTION_EARLY_PIPE
987 if ( peer_offered != sx->peer_offered
988 || (authbits = study_ehlo_auths(sx)) != *ap)
991 debug_printf("EHLO extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
992 sx->peer_offered, *ap, peer_offered, authbits);
994 if (peer_offered & OPTION_EARLY_PIPE)
995 write_ehlo_cache_entry(sx);
997 invalidate_ehlo_cache_entry(sx);
999 return OK; /* just carry on */
1005 invalidate_ehlo_cache_entry(sx);
1006 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
1012 /*************************************************
1013 * Synchronize SMTP responses *
1014 *************************************************/
1016 /* This function is called from smtp_deliver() to receive SMTP responses from
1017 the server, and match them up with the commands to which they relate. When
1018 PIPELINING is not in use, this function is called after every command, and is
1019 therefore somewhat over-engineered, but it is simpler to use a single scheme
1020 that works both with and without PIPELINING instead of having two separate sets
1023 The set of commands that are buffered up with pipelining may start with MAIL
1024 and may end with DATA; in between are RCPT commands that correspond to the
1025 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1026 etc.) are never buffered.
1028 Errors after MAIL or DATA abort the whole process leaving the response in the
1029 buffer. After MAIL, pending responses are flushed, and the original command is
1030 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1031 permitted to reject some recipient addresses while accepting others. However
1032 certain errors clearly abort the whole process. Set the value in
1033 transport_return to PENDING_OK if the address is accepted. If there is a
1034 subsequent general error, it will get reset accordingly. If not, it will get
1035 converted to OK at the end.
1038 sx smtp connection context
1039 count the number of responses to read
1040 pending_DATA 0 if last command sent was not DATA
1041 +1 if previously had a good recipient
1042 -1 if not previously had a good recipient
1044 Returns: 3 if at least one address had 2xx and one had 5xx
1045 2 if at least one address had 5xx but none had 2xx
1046 1 if at least one host had a 2xx response, but none had 5xx
1047 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1048 -1 timeout while reading RCPT response
1049 -2 I/O or other non-response error for RCPT
1050 -3 DATA or MAIL failed - errno and buffer set
1051 -4 banner or EHLO failed (early-pipelining)
1055 sync_responses(smtp_context * sx, int count, int pending_DATA)
1057 address_item * addr = sx->sync_addr;
1058 smtp_transport_options_block * ob = sx->conn_args.ob;
1061 #ifdef EXPERIMENTAL_PIPE_CONNECT
1062 if (smtp_reap_early_pipe(sx, &count) != OK)
1066 /* Handle the response for a MAIL command. On error, reinstate the original
1067 command in big_buffer for error message use, and flush any further pending
1068 responses before returning, except after I/O errors and timeouts. */
1070 if (sx->pending_MAIL)
1072 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1074 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1075 '2', ob->command_timeout))
1077 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1078 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1079 if (errno == 0 && sx->buffer[0] != 0)
1082 if (sx->buffer[0] == '4')
1084 save_errno = ERRNO_MAIL4XX;
1085 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1087 count = smtp_discard_responses(sx, ob, count);
1091 if (pending_DATA) count--; /* Number of RCPT responses to come */
1092 while (count-- > 0) /* Mark any pending addrs with the host used */
1094 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1095 addr->host_used = sx->conn_args.host;
1102 if (pending_DATA) count--; /* Number of RCPT responses to come */
1104 /* Read and handle the required number of RCPT responses, matching each one up
1105 with an address by scanning for the next address whose status is PENDING_DEFER.
1110 while (addr->transport_return != PENDING_DEFER)
1111 if (!(addr = addr->next))
1114 /* The address was accepted */
1115 addr->host_used = sx->conn_args.host;
1117 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1118 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1119 '2', ob->command_timeout))
1122 addr->transport_return = PENDING_OK;
1124 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1125 ensure that any address-specific retry record is expunged. We do this both
1126 for the basic key and for the version that also includes the sender. */
1128 if (testflag(addr, af_dr_retry_exists))
1130 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1132 retry_add_item(addr, altkey, rf_delete);
1133 retry_add_item(addr, addr->address_retry_key, rf_delete);
1137 /* Timeout while reading the response */
1139 else if (errno == ETIMEDOUT)
1141 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1142 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1143 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
1144 retry_add_item(addr, addr->address_retry_key, 0);
1145 update_waiting = FALSE;
1149 /* Handle other errors in obtaining an SMTP response by returning -1. This
1150 will cause all the addresses to be deferred. Restore the SMTP command in
1151 big_buffer for which we are checking the response, so the error message
1154 else if (errno != 0 || sx->buffer[0] == 0)
1156 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
1157 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1161 /* Handle SMTP permanent and temporary response codes. */
1166 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1167 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1168 string_printing(sx->buffer));
1169 setflag(addr, af_pass_message);
1171 msglog_line(sx->conn_args.host, addr->message);
1173 /* The response was 5xx */
1175 if (sx->buffer[0] == '5')
1177 addr->transport_return = FAIL;
1181 /* The response was 4xx */
1185 addr->transport_return = DEFER;
1186 addr->basic_errno = ERRNO_RCPT4XX;
1187 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1191 #ifndef DISABLE_EVENT
1192 event_defer_errno = addr->more_errno;
1193 msg_event_raise(US"msg:rcpt:host:defer", addr);
1196 /* Log temporary errors if there are more hosts to be tried.
1197 If not, log this last one in the == line. */
1199 if (sx->conn_args.host->next)
1200 log_write(0, LOG_MAIN, "H=%s [%s]: %s",
1201 sx->conn_args.host->name, sx->conn_args.host->address, addr->message);
1203 #ifndef DISABLE_EVENT
1205 msg_event_raise(US"msg:rcpt:defer", addr);
1208 /* Do not put this message on the list of those waiting for specific
1209 hosts, as otherwise it is likely to be tried too often. */
1211 update_waiting = FALSE;
1213 /* Add a retry item for the address so that it doesn't get tried again
1214 too soon. If address_retry_include_sender is true, add the sender address
1215 to the retry key. */
1217 retry_add_item(addr,
1218 ob->address_retry_include_sender
1219 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1220 : addr->address_retry_key,
1225 } /* Loop for next RCPT response */
1227 /* Update where to start at for the next block of responses, unless we
1228 have already handled all the addresses. */
1230 if (addr) sx->sync_addr = addr->next;
1232 /* Handle a response to DATA. If we have not had any good recipients, either
1233 previously or in this block, the response is ignored. */
1235 if (pending_DATA != 0)
1237 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1238 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1239 '3', ob->command_timeout))
1244 if (pending_DATA > 0 || (yield & 1) != 0)
1246 if (errno == 0 && sx->buffer[0] == '4')
1248 errno = ERRNO_DATA4XX;
1249 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1253 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1254 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1255 "is in use and there were no good recipients\n", msg);
1259 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1260 present) received 3xx. If any RCPTs were handled and yielded anything other
1261 than 4xx, yield will be set non-zero. */
1270 /* Try an authenticator's client entry */
1273 try_authenticator(smtp_context * sx, auth_instance * au)
1275 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1276 host_item * host = sx->conn_args.host; /* host to deliver to */
1279 sx->outblock.authenticating = TRUE;
1280 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1281 sx->buffer, sizeof(sx->buffer));
1282 sx->outblock.authenticating = FALSE;
1283 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1285 /* A temporary authentication failure must hold up delivery to
1286 this host. After a permanent authentication failure, we carry on
1287 to try other authentication methods. If all fail hard, try to
1288 deliver the message unauthenticated unless require_auth was set. */
1293 f.smtp_authenticated = TRUE; /* stops the outer loop */
1294 client_authenticator = au->name;
1295 if (au->set_client_id)
1296 client_authenticated_id = expand_string(au->set_client_id);
1299 /* Failure after writing a command */
1304 /* Failure after reading a response */
1307 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1308 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1309 au->name, host->name, host->address, sx->buffer);
1312 /* Failure by some other means. In effect, the authenticator
1313 decided it wasn't prepared to handle this case. Typically this
1314 is the result of "fail" in an expansion string. Do we need to
1315 log anything here? Feb 2006: a message is now put in the buffer
1316 if logging is required. */
1319 if (*sx->buffer != 0)
1320 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1321 "authentication H=%s [%s] %s", au->name, host->name,
1322 host->address, sx->buffer);
1325 /* Internal problem, message in buffer. */
1328 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1338 /* Do the client side of smtp-level authentication.
1341 sx smtp connection context
1343 sx->buffer should have the EHLO response from server (gets overwritten)
1346 OK Success, or failed (but not required): global "smtp_authenticated" set
1347 DEFER Failed authentication (and was required)
1348 ERROR Internal problem
1350 FAIL_SEND Failed communications - transmit
1355 smtp_auth(smtp_context * sx)
1357 host_item * host = sx->conn_args.host; /* host to deliver to */
1358 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1359 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1360 #ifdef EXPERIMENTAL_PIPE_CONNECT
1361 unsigned short authbits = tls_out.active.sock >= 0
1362 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1364 uschar * fail_reason = US"server did not advertise AUTH support";
1366 f.smtp_authenticated = FALSE;
1367 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1370 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1372 /* Is the server offering AUTH? */
1376 #ifdef EXPERIMENTAL_PIPE_CONNECT
1377 sx->early_pipe_active ? authbits
1380 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1383 uschar * names = NULL;
1384 expand_nmax = -1; /* reset */
1386 #ifdef EXPERIMENTAL_PIPE_CONNECT
1387 if (!sx->early_pipe_active)
1389 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1391 /* Must not do this check until after we have saved the result of the
1392 regex match above as the check could be another RE. */
1394 if ( require_auth == OK
1395 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1399 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1400 fail_reason = US"no common mechanisms were found";
1402 #ifdef EXPERIMENTAL_PIPE_CONNECT
1403 if (sx->early_pipe_active)
1405 /* Scan our authenticators (which support use by a client and were offered
1406 by the server (checked at cache-write time)), not suppressed by
1407 client_condition. If one is found, attempt to authenticate by calling its
1408 client function. We are limited to supporting up to 16 authenticator
1409 public-names by the number of bits in a short. */
1414 for (bitnum = 0, au = auths;
1415 !f.smtp_authenticated && au && bitnum < 16;
1416 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1418 if ( au->client_condition
1419 && !expand_check_condition(au->client_condition, au->name,
1420 US"client authenticator"))
1422 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1423 au->name, "client_condition is false");
1427 /* Found data for a listed mechanism. Call its client entry. Set
1428 a flag in the outblock so that data is overwritten after sending so
1429 that reflections don't show it. */
1431 fail_reason = US"authentication attempt(s) failed";
1433 if ((rc = try_authenticator(sx, au)) != OK)
1440 /* Scan the configured authenticators looking for one which is configured
1441 for use as a client, which is not suppressed by client_condition, and
1442 whose name matches an authentication mechanism supported by the server.
1443 If one is found, attempt to authenticate by calling its client function.
1446 for (au = auths; !f.smtp_authenticated && au; au = au->next)
1451 || ( au->client_condition
1452 && !expand_check_condition(au->client_condition, au->name,
1453 US"client authenticator")))
1455 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1457 (au->client)? "client_condition is false" :
1458 "not configured as a client");
1462 /* Loop to scan supported server mechanisms */
1466 int len = Ustrlen(au->public_name);
1469 while (isspace(*p)) p++;
1471 if (strncmpic(au->public_name, p, len) != 0 ||
1472 (p[len] != 0 && !isspace(p[len])))
1474 while (*p != 0 && !isspace(*p)) p++;
1478 /* Found data for a listed mechanism. Call its client entry. Set
1479 a flag in the outblock so that data is overwritten after sending so
1480 that reflections don't show it. */
1482 fail_reason = US"authentication attempt(s) failed";
1484 if ((rc = try_authenticator(sx, au)) != OK)
1487 break; /* If not authenticated, try next authenticator */
1488 } /* Loop for scanning supported server mechanisms */
1489 } /* Loop for further authenticators */
1493 /* If we haven't authenticated, but are required to, give up. */
1495 if (require_auth == OK && !f.smtp_authenticated)
1497 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1498 string_sprintf("authentication required but %s", fail_reason), DEFER,
1507 /* Construct AUTH appendix string for MAIL TO */
1510 buffer to build string
1511 addrlist chain of potential addresses to deliver
1512 ob transport options
1514 Globals f.smtp_authenticated
1515 client_authenticated_sender
1516 Return True on error, otherwise buffer has (possibly empty) terminated string
1520 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1521 smtp_transport_options_block *ob)
1523 uschar *local_authenticated_sender = authenticated_sender;
1526 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1529 if (ob->authenticated_sender != NULL)
1531 uschar *new = expand_string(ob->authenticated_sender);
1534 if (!f.expand_string_forcedfail)
1536 uschar *message = string_sprintf("failed to expand "
1537 "authenticated_sender: %s", expand_string_message);
1538 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1542 else if (new[0] != 0) local_authenticated_sender = new;
1545 /* Add the authenticated sender address if present */
1547 if ((f.smtp_authenticated || ob->authenticated_sender_force) &&
1548 local_authenticated_sender != NULL)
1550 string_format(buffer, bufsize, " AUTH=%s",
1551 auth_xtextencode(local_authenticated_sender,
1552 Ustrlen(local_authenticated_sender)));
1553 client_authenticated_sender = string_copy(local_authenticated_sender);
1564 /* Lookup TLSA record for host/port.
1565 Return: OK success with dnssec; DANE mode
1566 DEFER Do not use this host now, may retry later
1567 FAIL_FORCED No TLSA record; DANE not usable
1568 FAIL Do not use this connection
1572 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1574 /* move this out to host.c given the similarity to dns_lookup() ? */
1576 const uschar * fullname = buffer;
1580 /* TLSA lookup string */
1581 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1583 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1584 sec = dns_is_secure(dnsa);
1586 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1591 return DEFER; /* just defer this TLS'd conn */
1600 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1601 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1602 if (rr->type == T_TLSA && rr->size > 3)
1604 uint16_t payload_length = rr->size - 3;
1605 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1607 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1608 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1609 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1610 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1611 sp += sprintf(CS sp, "%02x", *p++);
1613 debug_printf(" %s\n", s);
1618 log_write(0, LOG_MAIN,
1619 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1622 case DNS_NODATA: /* no TLSA RR for this lookup */
1623 case DNS_NOMATCH: /* no records at all for this lookup */
1624 return dane_required ? FAIL : FAIL_FORCED;
1628 return dane_required ? FAIL : DEFER;
1635 typedef struct smtp_compare_s
1637 uschar *current_sender_address;
1638 struct transport_instance *tblock;
1642 /* Create a unique string that identifies this message, it is based on
1643 sender_address, helo_data and tls_certificate if enabled.
1647 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1649 address_item * addr1;
1650 uschar * if1 = US"";
1651 uschar * helo1 = US"";
1653 uschar * tlsc1 = US"";
1655 uschar * save_sender_address = sender_address;
1656 uschar * local_identity = NULL;
1657 smtp_transport_options_block * ob = SOB tblock->options_block;
1659 sender_address = sender;
1661 addr1 = deliver_make_addr (sender, TRUE);
1662 deliver_set_expansions(addr1);
1665 if1 = expand_string(ob->interface);
1668 helo1 = expand_string(ob->helo_data);
1671 if (ob->tls_certificate)
1672 tlsc1 = expand_string(ob->tls_certificate);
1673 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1675 local_identity = string_sprintf ("%s^%s", if1, helo1);
1678 deliver_set_expansions(NULL);
1679 sender_address = save_sender_address;
1681 return local_identity;
1686 /* This routine is a callback that is called from transport_check_waiting.
1687 This function will evaluate the incoming message versus the previous
1688 message. If the incoming message is using a different local identity then
1689 we will veto this new message. */
1692 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1694 uschar * message_local_identity,
1695 * current_local_identity,
1696 * new_sender_address;
1698 current_local_identity =
1699 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1701 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1704 message_local_identity =
1705 smtp_local_identity(new_sender_address, s_compare->tblock);
1707 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1713 ehlo_response(uschar * buf, unsigned checks)
1715 size_t bsize = Ustrlen(buf);
1717 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1720 # ifdef EXPERIMENTAL_REQUIRETLS
1721 if ( checks & OPTION_REQUIRETLS
1722 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1724 checks &= ~OPTION_REQUIRETLS;
1726 if ( checks & OPTION_TLS
1727 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1729 checks &= ~OPTION_TLS;
1731 if ( checks & OPTION_IGNQ
1732 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1733 PCRE_EOPT, NULL, 0) < 0)
1734 checks &= ~OPTION_IGNQ;
1736 if ( checks & OPTION_CHUNKING
1737 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1738 checks &= ~OPTION_CHUNKING;
1740 #ifndef DISABLE_PRDR
1741 if ( checks & OPTION_PRDR
1742 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1744 checks &= ~OPTION_PRDR;
1747 if ( checks & OPTION_UTF8
1748 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1750 checks &= ~OPTION_UTF8;
1752 if ( checks & OPTION_DSN
1753 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1754 checks &= ~OPTION_DSN;
1756 if ( checks & OPTION_PIPE
1757 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1758 PCRE_EOPT, NULL, 0) < 0)
1759 checks &= ~OPTION_PIPE;
1761 if ( checks & OPTION_SIZE
1762 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1763 checks &= ~OPTION_SIZE;
1765 #ifdef EXPERIMENTAL_PIPE_CONNECT
1766 if ( checks & OPTION_EARLY_PIPE
1767 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1768 PCRE_EOPT, NULL, 0) < 0)
1770 checks &= ~OPTION_EARLY_PIPE;
1772 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1778 /* Callback for emitting a BDAT data chunk header.
1780 If given a nonzero size, first flush any buffered SMTP commands
1781 then emit the command.
1783 Reap previous SMTP command responses if requested, and always reap
1784 the response from a previous BDAT command.
1787 tctx transport context
1788 chunk_size value for SMTP BDAT command
1790 tc_chunk_last add LAST option to SMTP BDAT command
1791 tc_reap_prev reap response to previous SMTP commands
1793 Returns: OK or ERROR
1797 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1800 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1801 smtp_context * sx = tctx->smtp_context;
1805 /* Write SMTP chunk header command. If not reaping responses, note that
1806 there may be more writes (like, the chunk data) done soon. */
1810 #ifdef EXPERIMENTAL_PIPE_CONNECT
1811 BOOL new_conn = !!(sx->outblock.conn_args);
1813 if((cmd_count = smtp_write_command(sx,
1814 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1815 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1816 ) < 0) return ERROR;
1817 if (flags & tc_chunk_last)
1818 data_command = string_copy(big_buffer); /* Save for later error message */
1819 #ifdef EXPERIMENTAL_PIPE_CONNECT
1820 /* That command write could have been the one that made the connection.
1821 Copy the fd from the client conn ctx (smtp transport specific) to the
1822 generic transport ctx. */
1825 tctx->u.fd = sx->outblock.cctx->sock;
1829 prev_cmd_count = cmd_count += sx->cmd_count;
1831 /* Reap responses for any previous, but not one we just emitted */
1835 if (sx->pending_BDAT)
1838 if (flags & tc_reap_prev && prev_cmd_count > 0)
1840 DEBUG(D_transport) debug_printf("look for %d responses"
1841 " for previous pipelined cmds\n", prev_cmd_count);
1843 switch(sync_responses(sx, prev_cmd_count, 0))
1845 case 1: /* 2xx (only) => OK */
1846 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1847 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1848 case 0: break; /* No 2xx or 5xx, but no probs */
1850 case -1: /* Timeout on RCPT */
1851 #ifdef EXPERIMENTAL_PIPE_CONNECT
1852 case -4: /* non-2xx for pipelined banner or EHLO */
1854 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1857 if (!sx->pending_BDAT)
1858 pipelining_active = FALSE;
1861 /* Reap response for an outstanding BDAT */
1863 if (sx->pending_BDAT)
1865 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1867 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1868 ob->command_timeout))
1870 if (errno == 0 && sx->buffer[0] == '4')
1872 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1873 sx->addrlist->more_errno |=
1874 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1879 sx->pending_BDAT = FALSE;
1880 pipelining_active = FALSE;
1882 else if (chunk_size > 0)
1883 sx->pending_BDAT = TRUE;
1886 sx->cmd_count = cmd_count;
1894 /*************************************************
1895 * Make connection for given message *
1896 *************************************************/
1900 ctx connection context
1901 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1902 a second attempt after TLS initialization fails
1904 Returns: OK - the connection was made and the delivery attempted;
1905 fd is set in the conn context, tls_out set up.
1906 DEFER - the connection could not be made, or something failed
1907 while setting up the SMTP session, or there was a
1908 non-message-specific error, such as a timeout.
1909 ERROR - helo_data or add_headers or authenticated_sender is
1910 specified for this transport, and the string failed
1914 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1916 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1917 dns_answer tlsa_dnsa;
1919 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1920 BOOL pass_message = FALSE;
1921 uschar * message = NULL;
1925 sx->conn_args.ob = ob;
1927 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1928 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1930 sx->send_rset = TRUE;
1931 sx->send_quit = TRUE;
1932 sx->setting_up = TRUE;
1934 sx->esmtp_sent = FALSE;
1936 sx->utf8_needed = FALSE;
1938 sx->dsn_all_lasthop = TRUE;
1939 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1942 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1944 #ifdef EXPERIMENTAL_PIPE_CONNECT
1945 sx->early_pipe_active = sx->early_pipe_ok = FALSE;
1946 sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0;
1947 sx->pending_BANNER = sx->pending_EHLO = FALSE;
1950 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1951 sx->peer_offered = 0;
1952 sx->avoid_option = 0;
1953 sx->igquotstr = US"";
1954 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1955 #ifdef EXPERIMENTAL_DSN_INFO
1956 sx->smtp_greeting = NULL;
1957 sx->helo_response = NULL;
1960 smtp_command = US"initial connection";
1961 sx->buffer[0] = '\0';
1963 /* Set up the buffer for reading SMTP response packets. */
1965 sx->inblock.buffer = sx->inbuffer;
1966 sx->inblock.buffersize = sizeof(sx->inbuffer);
1967 sx->inblock.ptr = sx->inbuffer;
1968 sx->inblock.ptrend = sx->inbuffer;
1970 /* Set up the buffer for holding SMTP commands while pipelining */
1972 sx->outblock.buffer = sx->outbuffer;
1973 sx->outblock.buffersize = sizeof(sx->outbuffer);
1974 sx->outblock.ptr = sx->outbuffer;
1975 sx->outblock.cmd_count = 0;
1976 sx->outblock.authenticating = FALSE;
1977 sx->outblock.conn_args = NULL;
1979 /* Reset the parameters of a TLS session. */
1982 tls_out.cipher = NULL; /* the one we may use for this transport */
1983 tls_out.ourcert = NULL;
1984 tls_out.peercert = NULL;
1985 tls_out.peerdn = NULL;
1986 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1989 tls_out.ocsp = OCSP_NOT_REQ;
1991 /* Flip the legacy TLS-related variables over to the outbound set in case
1992 they're used in the context of the transport. Don't bother resetting
1993 afterward (when being used by a transport) as we're in a subprocess.
1994 For verify, unflipped once the callout is dealt with */
1996 tls_modify_variables(&tls_out);
2001 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
2007 /* Make a connection to the host if this isn't a continued delivery, and handle
2008 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2009 specially so they can be identified for retries. */
2011 if (!continue_hostname)
2014 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2016 /* Get the actual port the connection will use, into sx->conn_args.host */
2018 smtp_port_for_connect(sx->conn_args.host, sx->port);
2020 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
2021 /* Do TLSA lookup for DANE */
2023 tls_out.dane_verified = FALSE;
2024 tls_out.tlsa_usage = 0;
2026 if (sx->conn_args.host->dnssec == DS_YES)
2028 if( sx->dane_required
2029 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2031 switch (rc = tlsa_lookup(sx->conn_args.host, &tlsa_dnsa, sx->dane_required))
2033 case OK: sx->dane = TRUE;
2034 ob->tls_tempfail_tryclear = FALSE;
2036 case FAIL_FORCED: break;
2037 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2038 string_sprintf("DANE error: tlsa lookup %s",
2039 rc == DEFER ? "DEFER" : "FAIL"),
2041 # ifndef DISABLE_EVENT
2042 (void) event_raise(sx->conn_args.tblock->event_action,
2043 US"dane:fail", sx->dane_required
2044 ? US"dane-required" : US"dnssec-invalid");
2049 else if (sx->dane_required)
2051 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2052 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2054 # ifndef DISABLE_EVENT
2055 (void) event_raise(sx->conn_args.tblock->event_action,
2056 US"dane:fail", US"dane-required");
2063 /* Make the TCP connection */
2065 sx->cctx.tls_ctx = NULL;
2066 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2067 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2069 #ifdef EXPERIMENTAL_PIPE_CONNECT
2070 if (verify_check_given_host(CUSS &ob->hosts_pipe_connect, sx->conn_args.host) == OK)
2072 sx->early_pipe_ok = TRUE;
2073 if ( read_ehlo_cache_entry(sx)
2074 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2076 DEBUG(D_transport) debug_printf("Using cached cleartext PIPE_CONNECT\n");
2077 sx->early_pipe_active = TRUE;
2078 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2082 if (sx->early_pipe_active)
2083 sx->outblock.conn_args = &sx->conn_args;
2087 if ((sx->cctx.sock = smtp_connect(&sx->conn_args, NULL)) < 0)
2089 uschar * msg = NULL;
2092 msg = US strerror(errno);
2093 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
2095 set_errno_nohost(sx->addrlist,
2096 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2097 sx->verify ? string_sprintf("could not connect: %s", msg)
2100 sx->send_quit = FALSE;
2104 /* Expand the greeting message while waiting for the initial response. (Makes
2105 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2106 delayed till here so that $sending_interface and $sending_port are set. */
2107 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2108 will be? Somehow I doubt it. */
2111 if (!(sx->helo_data = expand_string(sx->helo_data)))
2113 log_write(0, LOG_MAIN|LOG_PANIC,
2114 "<%s>: failed to expand transport's helo_data value for callout: %s",
2115 sx->addrlist->address, expand_string_message);
2120 expand_string_message = NULL;
2121 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2122 &expand_string_message)),
2123 expand_string_message)
2125 log_write(0, LOG_MAIN|LOG_PANIC,
2126 "<%s>: failed to expand transport's helo_data value for callout: %s",
2127 sx->addrlist->address, expand_string_message);
2129 sx->helo_data = NULL;
2133 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2134 is nevertheless a reasonably clean way of programming this kind of logic,
2135 where you want to escape on any error. */
2139 #ifdef EXPERIMENTAL_PIPE_CONNECT
2140 if (sx->early_pipe_active)
2142 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2143 sx->outblock.cmd_count = 1;
2149 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2152 if (!smtp_reap_banner(sx))
2153 goto RESPONSE_FAILED;
2156 #ifndef DISABLE_EVENT
2159 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2160 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2161 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2164 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2165 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2173 /* Now check if the helo_data expansion went well, and sign off cleanly if
2178 message = string_sprintf("failed to expand helo_data: %s",
2179 expand_string_message);
2180 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2186 /** Debugging without sending a message
2187 sx->addrlist->transport_return = DEFER;
2191 /* Errors that occur after this point follow an SMTP command, which is
2192 left in big_buffer by smtp_write_command() for use in error messages. */
2194 smtp_command = big_buffer;
2196 /* Tell the remote who we are...
2198 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2199 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2200 greeting is of this form. The assumption was that the far end supports it
2201 properly... but experience shows that there are some that give 5xx responses,
2202 even though the banner includes "ESMTP" (there's a bloody-minded one that
2203 says "ESMTP not spoken here"). Cope with that case.
2205 September 2000: Time has passed, and it seems reasonable now to always send
2206 EHLO at the start. It is also convenient to make the change while installing
2209 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2210 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2211 would be no way to send out the mails, so there is now a host list
2212 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2213 PIPELINING problem as well. Maybe it can also be useful to cure other
2214 problems with broken servers.
2216 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2217 Then somebody tried it with a Microsoft mailer... It seems that all other
2218 mailers use upper case for some reason (the RFC is quite clear about case
2219 independence) so, for peace of mind, I gave in. */
2221 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2223 /* Alas; be careful, since this goto is not an error-out, so conceivably
2224 we might set data between here and the target which we assume to exist
2225 and be usable. I can see this coming back to bite us. */
2229 smtp_peer_options |= OPTION_TLS;
2230 suppress_tls = FALSE;
2231 ob->tls_tempfail_tryclear = FALSE;
2232 smtp_command = US"SSL-on-connect";
2239 if (smtp_write_command(sx,
2240 #ifdef EXPERIMENTAL_PIPE_CONNECT
2241 sx->early_pipe_active ? SCMD_BUFFER :
2244 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2246 sx->esmtp_sent = TRUE;
2248 #ifdef EXPERIMENTAL_PIPE_CONNECT
2249 if (sx->early_pipe_active)
2251 sx->pending_EHLO = TRUE;
2253 /* If we have too many authenticators to handle and might need to AUTH
2254 for this transport, pipeline no further as we will need the
2255 list of auth methods offered. Reap the banner and EHLO. */
2257 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2258 && f.smtp_in_early_pipe_no_auth)
2260 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2261 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2263 if (sync_responses(sx, 2, 0) != 0)
2266 debug_printf("failed reaping pipelined cmd responses\n");
2267 goto RESPONSE_FAILED;
2269 sx->early_pipe_active = FALSE;
2274 if (!smtp_reap_ehlo(sx))
2275 goto RESPONSE_FAILED;
2279 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2281 #ifdef EXPERIMENTAL_PIPE_CONNECT
2282 if (!sx->early_pipe_active)
2287 int n = sizeof(sx->buffer);
2288 uschar * rsp = sx->buffer;
2290 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2291 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2293 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2295 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2296 #ifdef EXPERIMENTAL_DSN_INFO
2297 sx->helo_response = string_copy(rsp);
2301 /* Handle special logging for a closed connection after HELO
2302 when had previously sent EHLO */
2304 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2306 errno = ERRNO_SMTPCLOSED;
2307 goto EHLOHELO_FAILED;
2309 memmove(sx->buffer, rsp, Ustrlen(rsp));
2310 goto RESPONSE_FAILED;
2314 if (sx->esmtp || sx->lmtp)
2316 #ifdef EXPERIMENTAL_PIPE_CONNECT
2317 if (!sx->early_pipe_active)
2320 sx->peer_offered = ehlo_response(sx->buffer,
2321 OPTION_TLS /* others checked later */
2322 #ifdef EXPERIMENTAL_PIPE_CONNECT
2323 | (sx->early_pipe_ok
2325 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2334 #ifdef EXPERIMENTAL_PIPE_CONNECT
2335 if (sx->early_pipe_ok)
2337 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2339 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2340 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2342 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2343 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2344 write_ehlo_cache_entry(sx);
2350 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2353 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2358 /* For continuing deliveries down the same channel, having re-exec'd the socket
2359 is the standard input; for a socket held open from verify it is recorded
2360 in the cutthrough context block. Either way we don't need to redo EHLO here
2361 (but may need to do so for TLS - see below).
2362 Set up the pointer to where subsequent commands will be left, for
2363 error messages. Note that smtp_peer_options will have been
2364 set from the command line if they were set in the process that passed the
2367 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2368 as the continue goes via transport_pass_socket() and doublefork and exec.
2369 It does not wait. Unclear how we keep separate host's responses
2370 separate - we could match up by host ip+port as a bodge. */
2374 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2376 sx->cctx = cutthrough.cctx;
2377 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2381 sx->cctx.sock = 0; /* stdin */
2382 sx->cctx.tls_ctx = NULL;
2383 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2385 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2386 smtp_command = big_buffer;
2387 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2389 /* For a continued connection with TLS being proxied for us, or a
2390 held-open verify connection with TLS, nothing more to do. */
2392 if ( continue_proxy_cipher
2393 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2394 && cutthrough.is_tls)
2397 sx->peer_offered = smtp_peer_options;
2398 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2399 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2400 continue_proxy_cipher ? "proxied" : "verify conn with");
2403 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2406 /* If TLS is available on this connection, whether continued or not, attempt to
2407 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2408 send another EHLO - the server may give a different answer in secure mode. We
2409 use a separate buffer for reading the response to STARTTLS so that if it is
2410 negative, the original EHLO data is available for subsequent analysis, should
2411 the client not be required to use TLS. If the response is bad, copy the buffer
2412 for error analysis. */
2415 if ( smtp_peer_options & OPTION_TLS
2417 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2419 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2422 uschar buffer2[4096];
2424 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2427 #ifdef EXPERIMENTAL_PIPE_CONNECT
2428 /* If doing early-pipelining reap the banner and EHLO-response but leave
2429 the response for the STARTTLS we just sent alone. */
2431 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2434 debug_printf("failed reaping pipelined cmd responses\n");
2435 goto RESPONSE_FAILED;
2439 /* If there is an I/O error, transmission of this message is deferred. If
2440 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2441 false, we also defer. However, if there is a temporary rejection of STARTTLS
2442 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2443 STARTTLS, we carry on. This means we will try to send the message in clear,
2444 unless the host is in hosts_require_tls (tested below). */
2446 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2450 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2453 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2454 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2455 goto RESPONSE_FAILED;
2459 /* STARTTLS accepted: try to negotiate a TLS session. */
2464 address_item * addr;
2466 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->conn_args.host,
2467 sx->addrlist, sx->conn_args.tblock,
2468 # ifdef SUPPORT_DANE
2469 sx->dane ? &tlsa_dnsa : NULL,
2473 if (!sx->cctx.tls_ctx)
2475 /* TLS negotiation failed; give an error. From outside, this function may
2476 be called again to try in clear on a new connection, if the options permit
2477 it for this host. */
2478 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", errstr);
2480 # ifdef SUPPORT_DANE
2483 log_write(0, LOG_MAIN,
2484 "DANE attempt failed; TLS connection to %s [%s]: %s",
2485 sx->conn_args.host->name, sx->conn_args.host->address, errstr);
2486 # ifndef DISABLE_EVENT
2487 (void) event_raise(sx->conn_args.tblock->event_action,
2488 US"dane:fail", US"validation-failure"); /* could do with better detail */
2493 errno = ERRNO_TLSFAILURE;
2494 message = string_sprintf("TLS session: %s", errstr);
2495 sx->send_quit = FALSE;
2499 /* TLS session is set up */
2501 smtp_peer_options_wrap = smtp_peer_options;
2502 for (addr = sx->addrlist; addr; addr = addr->next)
2503 if (addr->transport_return == PENDING_DEFER)
2505 addr->cipher = tls_out.cipher;
2506 addr->ourcert = tls_out.ourcert;
2507 addr->peercert = tls_out.peercert;
2508 addr->peerdn = tls_out.peerdn;
2509 addr->ocsp = tls_out.ocsp;
2514 /* if smtps, we'll have smtp_command set to something else; always safe to
2516 smtp_command = big_buffer;
2518 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2519 helo_data is null, we are dealing with a connection that was passed from
2520 another process, and so we won't have expanded helo_data above. We have to
2521 expand it here. $sending_ip_address and $sending_port are set up right at the
2522 start of the Exim process (in exim.c). */
2524 if (tls_out.active.sock >= 0)
2526 uschar * greeting_cmd;
2528 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2530 uschar *message = string_sprintf("failed to expand helo_data: %s",
2531 expand_string_message);
2532 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2537 #ifdef EXPERIMENTAL_PIPE_CONNECT
2538 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2539 We're unlikely to get the group sent and delivered before the server sends its
2540 banner, but it's still worth sending as a group.
2541 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2544 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2546 sx->peer_offered = sx->ehlo_resp.crypted_features;
2547 if ((sx->early_pipe_active =
2548 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2549 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2553 /* For SMTPS we need to wait for the initial OK response. */
2555 #ifdef EXPERIMENTAL_PIPE_CONNECT
2556 if (sx->early_pipe_active)
2558 sx->pending_BANNER = TRUE;
2559 sx->outblock.cmd_count = 1;
2563 if (!smtp_reap_banner(sx))
2564 goto RESPONSE_FAILED;
2567 greeting_cmd = US"LHLO";
2569 greeting_cmd = US"EHLO";
2572 greeting_cmd = US"HELO";
2574 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2577 if (smtp_write_command(sx,
2578 #ifdef EXPERIMENTAL_PIPE_CONNECT
2579 sx->early_pipe_active ? SCMD_BUFFER :
2582 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2585 #ifdef EXPERIMENTAL_PIPE_CONNECT
2586 if (sx->early_pipe_active)
2587 sx->pending_EHLO = TRUE;
2591 if (!smtp_reap_ehlo(sx))
2592 goto RESPONSE_FAILED;
2593 smtp_peer_options = 0;
2597 /* If the host is required to use a secure channel, ensure that we
2601 # ifdef SUPPORT_DANE
2604 # ifdef EXPERIMENTAL_REQUIRETLS
2605 || tls_requiretls & REQUIRETLS_MSG
2607 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2611 # ifdef EXPERIMENTAL_REQUIRETLS
2612 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2615 message = string_sprintf("a TLS session is required, but %s",
2616 smtp_peer_options & OPTION_TLS
2617 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2618 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2620 (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2621 smtp_peer_options & OPTION_TLS
2622 ? US"validation-failure" /* could do with better detail */
2623 : US"starttls-not-supported");
2627 #endif /*SUPPORT_TLS*/
2629 /* If TLS is active, we have just started it up and re-done the EHLO command,
2630 so its response needs to be analyzed. If TLS is not active and this is a
2631 continued session down a previously-used socket, we haven't just done EHLO, so
2634 if (continue_hostname == NULL
2636 || tls_out.active.sock >= 0
2640 if (sx->esmtp || sx->lmtp)
2642 #ifdef EXPERIMENTAL_PIPE_CONNECT
2643 if (!sx->early_pipe_active)
2646 sx->peer_offered = ehlo_response(sx->buffer,
2648 #ifdef EXPERIMENTAL_PIPE_CONNECT
2649 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2650 | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2651 | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8 | OPTION_REQUIRETLS
2652 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2656 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2659 # ifdef SUPPORT_I18N
2660 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2661 /*XXX if we hand peercaps on to continued-conn processes,
2662 must not depend on this addr */
2666 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2667 # if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2668 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2672 #ifdef EXPERIMENTAL_PIPE_CONNECT
2673 if (tls_out.active.sock >= 0)
2674 sx->ehlo_resp.crypted_features = sx->peer_offered;
2678 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2679 lmtp_ignore_quota option was set. */
2681 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2683 /* If the response to EHLO specified support for the SIZE parameter, note
2684 this, provided size_addition is non-negative. */
2686 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2688 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2689 the current host, esmtp will be false, so PIPELINING can never be used. If
2690 the current host matches hosts_avoid_pipelining, don't do it. */
2692 if ( sx->peer_offered & OPTION_PIPE
2693 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2694 smtp_peer_options |= OPTION_PIPE;
2696 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2697 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2699 if ( sx->peer_offered & OPTION_CHUNKING
2700 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2701 sx->peer_offered &= ~OPTION_CHUNKING;
2703 if (sx->peer_offered & OPTION_CHUNKING)
2704 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2706 #ifndef DISABLE_PRDR
2707 if ( sx->peer_offered & OPTION_PRDR
2708 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2709 sx->peer_offered &= ~OPTION_PRDR;
2711 if (sx->peer_offered & OPTION_PRDR)
2712 DEBUG(D_transport) debug_printf("PRDR usable\n");
2715 /* Note if the server supports DSN */
2716 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2717 DEBUG(D_transport) debug_printf("%susing DSN\n",
2718 sx->peer_offered & OPTION_DSN ? "" : "not ");
2720 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2721 if (sx->peer_offered & OPTION_REQUIRETLS)
2723 smtp_peer_options |= OPTION_REQUIRETLS;
2724 DEBUG(D_transport) debug_printf(
2725 tls_requiretls & REQUIRETLS_MSG
2726 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2730 #ifdef EXPERIMENTAL_PIPE_CONNECT
2731 if ( sx->early_pipe_ok
2732 && !sx->early_pipe_active
2733 && tls_out.active.sock >= 0
2734 && smtp_peer_options & OPTION_PIPE
2735 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2736 & OPTION_EARLY_PIPE)
2738 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2739 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2740 write_ehlo_cache_entry(sx);
2744 /* Note if the response to EHLO specifies support for the AUTH extension.
2745 If it has, check that this host is one we want to authenticate to, and do
2746 the business. The host name and address must be available when the
2747 authenticator's client driver is running. */
2749 switch (yield = smtp_auth(sx))
2751 default: goto SEND_QUIT;
2753 case FAIL_SEND: goto SEND_FAILED;
2754 case FAIL: goto RESPONSE_FAILED;
2758 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2760 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2761 message-specific. */
2763 sx->setting_up = FALSE;
2766 if (sx->addrlist->prop.utf8_msg)
2770 /* If the transport sets a downconversion mode it overrides any set by ACL
2773 if ((s = ob->utf8_downconvert))
2775 if (!(s = expand_string(s)))
2777 message = string_sprintf("failed to expand utf8_downconvert: %s",
2778 expand_string_message);
2779 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2785 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2786 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2788 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2789 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2791 case '-': if (s[1] == '1')
2793 sx->addrlist->prop.utf8_downcvt = FALSE;
2794 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2800 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2801 && !sx->addrlist->prop.utf8_downcvt_maybe;
2802 DEBUG(D_transport) if (!sx->utf8_needed)
2803 debug_printf("utf8: %s downconvert\n",
2804 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2807 /* If this is an international message we need the host to speak SMTPUTF8 */
2808 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2810 errno = ERRNO_UTF8_FWD;
2811 goto RESPONSE_FAILED;
2813 #endif /*SUPPORT_I18N*/
2815 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2816 /*XXX should tls_requiretls actually be per-addr? */
2818 if ( tls_requiretls & REQUIRETLS_MSG
2819 && !(sx->peer_offered & OPTION_REQUIRETLS)
2822 sx->setting_up = TRUE;
2823 errno = ERRNO_REQUIRETLS;
2824 message = US"REQUIRETLS support is required from the server"
2825 " but it was not offered";
2826 DEBUG(D_transport) debug_printf("%s\n", message);
2839 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2840 sx->buffer, &code, &message, &pass_message);
2846 message = US string_sprintf("send() to %s [%s] failed: %s",
2847 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2848 sx->send_quit = FALSE;
2854 message = string_sprintf("Remote host closed connection in response to %s"
2855 " (EHLO response was: %s)", smtp_command, sx->buffer);
2856 sx->send_quit = FALSE;
2860 /* This label is jumped to directly when a TLS negotiation has failed,
2861 or was not done for a host for which it is required. Values will be set
2862 in message and errno, and setting_up will always be true. Treat as
2863 a temporary error. */
2867 # ifdef EXPERIMENTAL_REQUIRETLS
2868 if (errno == ERRNO_REQUIRETLS)
2869 code = '5', yield = FAIL;
2870 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2873 code = '4', yield = DEFER;
2877 /* The failure happened while setting up the call; see if the failure was
2878 a 5xx response (this will either be on connection, or following HELO - a 5xx
2879 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2880 fail all addresses, as this host is never going to accept them. For other
2881 errors during setting up (timeouts or whatever), defer all addresses, and
2882 yield DEFER, so that the host is not tried again for a while.
2884 XXX This peeking for another host feels like a layering violation. We want
2885 to note the host as unusable, but down here we shouldn't know if this was
2886 the last host to try for the addr(list). Perhaps the upper layer should be
2887 the one to do set_errno() ? The problem is that currently the addr is where
2888 errno etc. are stashed, but until we run out of hosts to try the errors are
2889 host-specific. Maybe we should enhance the host_item definition? */
2892 sx->ok = FALSE; /* For when reached by GOTO */
2893 set_errno(sx->addrlist, errno, message,
2894 sx->conn_args.host->next
2898 || errno == ERRNO_UTF8_FWD
2901 pass_message, sx->conn_args.host
2902 #ifdef EXPERIMENTAL_DSN_INFO
2903 , sx->smtp_greeting, sx->helo_response
2912 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2915 if (sx->cctx.tls_ctx)
2917 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2918 sx->cctx.tls_ctx = NULL;
2922 /* Close the socket, and return the appropriate value, first setting
2923 works because the NULL setting is passed back to the calling process, and
2924 remote_max_parallel is forced to 1 when delivering over an existing connection,
2927 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2930 shutdown(sx->cctx.sock, SHUT_WR);
2931 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2932 for (rc = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && rc > 0;)
2933 rc--; /* drain socket */
2934 sx->send_quit = FALSE;
2936 (void)close(sx->cctx.sock);
2939 #ifndef DISABLE_EVENT
2940 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2943 continue_transport = NULL;
2944 continue_hostname = NULL;
2951 /* Create the string of options that will be appended to the MAIL FROM:
2952 in the connection context buffer */
2955 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2957 uschar * p = sx->buffer;
2958 address_item * addr;
2963 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2964 send it, adding something to the message size to allow for imprecision
2965 and things that get added en route. Exim keeps the number of lines
2966 in a message, so we can give an accurate value for the original message, but we
2967 need some additional to handle added headers. (Double "." characters don't get
2968 included in the count.) */
2970 if ( message_size > 0
2971 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2973 /*XXX problem here under spool_files_wireformat?
2974 Or just forget about lines? Or inflate by a fixed proportion? */
2976 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
2980 #ifndef DISABLE_PRDR
2981 /* If it supports Per-Recipient Data Reponses, and we have omre than one recipient,
2984 sx->prdr_active = FALSE;
2985 if (sx->peer_offered & OPTION_PRDR)
2986 for (addr = addrlist; addr; addr = addr->next)
2987 if (addr->transport_return == PENDING_DEFER)
2989 for (addr = addr->next; addr; addr = addr->next)
2990 if (addr->transport_return == PENDING_DEFER)
2991 { /* at least two recipients to send */
2992 sx->prdr_active = TRUE;
2993 sprintf(CS p, " PRDR"); p += 5;
3001 /* If it supports internationalised messages, and this meesage need that,
3004 if ( sx->peer_offered & OPTION_UTF8
3005 && addrlist->prop.utf8_msg
3006 && !addrlist->prop.utf8_downcvt
3008 Ustrcpy(p, " SMTPUTF8"), p += 9;
3011 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3012 if (tls_requiretls & REQUIRETLS_MSG)
3013 Ustrcpy(p, " REQUIRETLS") , p += 11;
3016 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3017 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3018 addr && address_count < sx->max_rcpt;
3019 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3022 if (!(addr->dsn_flags & rf_dsnlasthop))
3024 sx->dsn_all_lasthop = FALSE;
3029 /* Add any DSN flags to the mail command */
3031 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3033 if (dsn_ret == dsn_ret_hdrs)
3034 { Ustrcpy(p, " RET=HDRS"); p += 9; }
3035 else if (dsn_ret == dsn_ret_full)
3036 { Ustrcpy(p, " RET=FULL"); p += 9; }
3040 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3045 /* If an authenticated_sender override has been specified for this transport
3046 instance, expand it. If the expansion is forced to fail, and there was already
3047 an authenticated_sender for this message, the original value will be used.
3048 Other expansion failures are serious. An empty result is ignored, but there is
3049 otherwise no check - this feature is expected to be used with LMTP and other
3050 cases where non-standard addresses (e.g. without domains) might be required. */
3052 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->conn_args.ob))
3060 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3062 uschar * p = sx->buffer;
3065 /* Add any DSN flags to the rcpt command */
3067 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3069 if (addr->dsn_flags & rf_dsnflags)
3074 Ustrcpy(p, " NOTIFY=");
3076 for (i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3078 if (!first) *p++ = ',';
3080 Ustrcpy(p, rf_names[i]);
3085 if (addr->dsn_orcpt)
3087 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3098 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3099 -1 MAIL response error
3100 -2 any non-MAIL read i/o error
3101 -3 non-MAIL response timeout
3102 -4 internal error; channel still usable
3107 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3109 address_item * addr;
3113 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3119 /* From here until we send the DATA command, we can make use of PIPELINING
3120 if the server host supports it. The code has to be able to check the responses
3121 at any point, for when the buffer fills up, so we write it totally generally.
3122 When PIPELINING is off, each command written reports that it has flushed the
3125 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3128 uschar * s = sx->from_addr;
3130 uschar * errstr = NULL;
3132 /* If we must downconvert, do the from-address here. Remember we had to
3133 for the to-addresses (done below), and also (ugly) for re-doing when building
3134 the delivery log line. */
3136 if ( sx->addrlist->prop.utf8_msg
3137 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3140 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3142 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3146 setflag(sx->addrlist, af_utf8_downcvt);
3150 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3151 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3154 mail_command = string_copy(big_buffer); /* Save for later error message */
3158 case -1: /* Transmission error */
3161 case +1: /* Cmd was sent */
3162 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3163 (SOB sx->conn_args.ob)->command_timeout))
3165 if (errno == 0 && sx->buffer[0] == '4')
3167 errno = ERRNO_MAIL4XX;
3168 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3172 sx->pending_MAIL = FALSE;
3175 /* otherwise zero: command queued for pipeline */
3178 /* Pass over all the relevant recipient addresses for this host, which are the
3179 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3180 several before we have to read the responses for those seen so far. This
3181 checking is done by a subroutine because it also needs to be done at the end.
3182 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3183 the next one if not all are sent.
3185 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3186 last address because we want to abort if any recipients have any kind of
3187 problem, temporary or permanent. We know that all recipient addresses will have
3188 the PENDING_DEFER status, because only one attempt is ever made, and we know
3189 that max_rcpt will be large, so all addresses will be done at once.
3191 For verify we flush the pipeline after any (the only) rcpt address. */
3193 for (addr = sx->first_addr, address_count = 0;
3194 addr && address_count < sx->max_rcpt;
3195 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3201 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3202 ? dsn_support_yes : dsn_support_no;
3205 no_flush = pipelining_active && !sx->verify
3206 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3208 build_rcptcmd_options(sx, addr);
3210 /* Now send the RCPT command, and process outstanding responses when
3211 necessary. After a timeout on RCPT, we just end the function, leaving the
3212 yield as OK, because this error can often mean that there is a problem with
3213 just one address, so we don't want to delay the host. */
3215 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3218 if ( testflag(sx->addrlist, af_utf8_downcvt)
3219 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3222 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3223 errno = ERRNO_EXPANDFAIL;
3224 return -5; /*XXX too harsh? */
3228 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3229 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3231 if (count < 0) return -5;
3234 switch(sync_responses(sx, count, 0))
3236 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3237 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3240 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3241 if (!sx->lmtp) /* can't tell about progress yet */
3242 sx->completed_addr = TRUE;
3243 case 0: /* No 2xx or 5xx, but no probs */
3246 case -1: return -3; /* Timeout on RCPT */
3247 case -2: return -2; /* non-MAIL read i/o error */
3248 default: return -1; /* any MAIL error */
3250 #ifdef EXPERIMENTAL_PIPE_CONNECT
3251 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3254 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
3256 } /* Loop for next address */
3258 sx->next_addr = addr;
3264 /*****************************************************
3265 * Proxy TLS connection for another transport process *
3266 ******************************************************/
3268 Close the unused end of the pipe, fork once more, then use the given buffer
3269 as a staging area, and select on both the given fd and the TLS'd client-fd for
3270 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3271 Do blocking full-size writes, and reads under a timeout. Once both input
3272 channels are closed, exit the process.
3276 buf space to use for buffering
3277 bufsiz size of buffer
3278 pfd pipe filedescriptor array; [0] is comms to proxied process
3279 timeout per-read timeout, seconds
3283 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3287 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3288 int rc, i, fd_bits, nbytes;
3293 DEBUG(D_transport) debug_printf("proxy-proc final-pid %d\n", rc);
3294 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3297 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
3298 set_process_info("proxying TLS connection for continued transport");
3300 FD_SET(tls_out.active.sock, &rfds);
3301 FD_SET(pfd[0], &rfds);
3303 for (fd_bits = 3; fd_bits; )
3305 time_t time_left = timeout;
3306 time_t time_start = time(NULL);
3312 struct timeval tv = { time_left, 0 };
3315 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
3317 if (rc < 0 && errno == EINTR)
3318 if ((time_left -= time(NULL) - time_start) > 0) continue;
3322 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
3326 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
3328 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
3329 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
3333 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
3335 /* handle inbound data */
3336 if (FD_ISSET(tls_out.active.sock, &rfds))
3337 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
3340 FD_CLR(tls_out.active.sock, &rfds);
3341 shutdown(pfd[0], SHUT_WR);
3346 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3347 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
3349 else if (fd_bits & 1)
3350 FD_SET(tls_out.active.sock, &rfds);
3352 /* handle outbound data */
3353 if (FD_ISSET(pfd[0], &rfds))
3354 if ((rc = read(pfd[0], buf, bsize)) <= 0)
3357 tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
3362 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3363 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
3366 else if (fd_bits & 2)
3367 FD_SET(pfd[0], &rfds);
3371 if (f.running_in_test_harness) millisleep(100); /* let logging complete */
3372 exim_exit(0, US"TLS proxy");
3377 /*************************************************
3378 * Deliver address list to given host *
3379 *************************************************/
3381 /* If continue_hostname is not null, we get here only when continuing to
3382 deliver down an existing channel. The channel was passed as the standard
3383 input. TLS is never active on a passed channel; the previous process always
3384 closes it down before passing the connection on.
3386 Otherwise, we have to make a connection to the remote host, and do the
3387 initial protocol exchange.
3389 When running as an MUA wrapper, if the sender or any recipient is rejected,
3390 temporarily or permanently, we force failure for all recipients.
3393 addrlist chain of potential addresses to deliver; only those whose
3394 transport_return field is set to PENDING_DEFER are currently
3395 being processed; others should be skipped - they have either
3396 been delivered to an earlier host or IP address, or been
3397 failed by one of them.
3398 host host to deliver to
3399 host_af AF_INET or AF_INET6
3400 defport default TCP/IP port to use if host does not specify, in host
3402 interface interface to bind to, or NULL
3403 tblock transport instance block
3404 message_defer set TRUE if yield is OK, but all addresses were deferred
3405 because of a non-recipient, non-host failure, that is, a
3406 4xx response to MAIL FROM, DATA, or ".". This is a defer
3407 that is specific to the message.
3408 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
3409 a second attempt after TLS initialization fails
3411 Returns: OK - the connection was made and the delivery attempted;
3412 the result for each address is in its data block.
3413 DEFER - the connection could not be made, or something failed
3414 while setting up the SMTP session, or there was a
3415 non-message-specific error, such as a timeout.
3416 ERROR - a filter command is specified for this transport,
3417 and there was a problem setting it up; OR helo_data
3418 or add_headers or authenticated_sender is specified
3419 for this transport, and the string failed to expand
3423 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
3424 uschar *interface, transport_instance *tblock,
3425 BOOL *message_defer, BOOL suppress_tls)
3428 smtp_transport_options_block * ob = SOB tblock->options_block;
3432 struct timeval start_delivery_time;
3434 BOOL pass_message = FALSE;
3435 uschar *message = NULL;
3436 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
3440 gettimeofday(&start_delivery_time, NULL);
3441 suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
3442 *message_defer = FALSE;
3444 sx.addrlist = addrlist;
3445 sx.conn_args.host = host;
3446 sx.conn_args.host_af = host_af,
3448 sx.conn_args.interface = interface;
3449 sx.helo_data = NULL;
3450 sx.conn_args.tblock = tblock;
3452 #ifdef EXPERIMENTAL_PIPE_CONNECT
3453 sx.sync_addr = sx.first_addr = addrlist;
3456 /* Get the channel set up ready for a message (MAIL FROM being the next
3457 SMTP command to send */
3459 if ((rc = smtp_setup_conn(&sx, suppress_tls)) != OK)
3462 /* If there is a filter command specified for this transport, we can now
3463 set it up. This cannot be done until the identify of the host is known. */
3465 if (tblock->filter_command)
3467 transport_filter_timeout = tblock->filter_timeout;
3469 /* On failure, copy the error to all addresses, abandon the SMTP call, and
3472 if (!transport_set_up_command(&transport_filter_argv,
3473 tblock->filter_command, TRUE, DEFER, addrlist,
3474 string_sprintf("%.50s transport", tblock->name), NULL))
3476 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
3482 if ( transport_filter_argv
3483 && *transport_filter_argv
3484 && **transport_filter_argv
3485 && sx.peer_offered & OPTION_CHUNKING
3488 sx.peer_offered &= ~OPTION_CHUNKING;
3489 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
3493 /* For messages that have more than the maximum number of envelope recipients,
3494 we want to send several transactions down the same SMTP connection. (See
3495 comments in deliver.c as to how this reconciles, heuristically, with
3496 remote_max_parallel.) This optimization was added to Exim after the following
3497 code was already working. The simplest way to put it in without disturbing the
3498 code was to use a goto to jump back to this point when there is another
3499 transaction to handle. */
3502 sx.from_addr = return_path;
3503 sx.sync_addr = sx.first_addr;
3505 sx.send_rset = TRUE;
3506 sx.completed_addr = FALSE;
3509 /* If we are a continued-connection-after-verify the MAIL and RCPT
3510 commands were already sent; do not re-send but do mark the addrs as
3511 having been accepted up to RCPT stage. A traditional cont-conn
3512 always has a sequence number greater than one. */
3514 if (continue_hostname && continue_sequence == 1)
3516 address_item * addr;
3518 sx.peer_offered = smtp_peer_options;
3519 sx.pending_MAIL = FALSE;
3521 sx.next_addr = NULL;
3523 for (addr = addrlist; addr; addr = addr->next)
3524 addr->transport_return = PENDING_OK;
3528 /* Initiate a message transfer. */
3530 switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
3533 case -1: case -2: goto RESPONSE_FAILED;
3534 case -3: goto END_OFF;
3535 case -4: goto SEND_QUIT;
3536 default: goto SEND_FAILED;
3539 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3540 permanently or temporarily. We should have flushed and synced after the last
3548 for (a = sx.first_addr, cnt = 0; a && cnt < sx.max_rcpt; a = a->next, cnt++)
3549 if (a->transport_return != PENDING_OK)
3551 /*XXX could we find a better errno than 0 here? */
3552 set_errno_nohost(addrlist, 0, a->message, FAIL,
3553 testflag(a, af_pass_message));
3560 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3561 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3562 have a good recipient buffered up if we are pipelining. We don't want to waste
3563 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3564 are pipelining. The responses are all handled by sync_responses().
3565 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3568 if ( !(sx.peer_offered & OPTION_CHUNKING)
3569 && (sx.ok || (pipelining_active && !mua_wrapper)))
3571 int count = smtp_write_command(&sx, SCMD_FLUSH, "DATA\r\n");
3573 if (count < 0) goto SEND_FAILED;
3574 switch(sync_responses(&sx, count, sx.ok ? +1 : -1))
3576 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3577 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3580 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3581 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3582 case 0: break; /* No 2xx or 5xx, but no probs */
3584 case -1: goto END_OFF; /* Timeout on RCPT */
3586 #ifdef EXPERIMENTAL_PIPE_CONNECT
3587 case -4: HDEBUG(D_transport)
3588 debug_printf("failed reaping pipelined cmd responses\n");
3590 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3592 pipelining_active = FALSE;
3593 data_command = string_copy(big_buffer); /* Save for later error message */
3596 /* If there were no good recipients (but otherwise there have been no
3597 problems), just set ok TRUE, since we have handled address-specific errors
3598 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3599 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3600 well as body. Set the appropriate timeout value to be used for each chunk.
3601 (Haven't been able to make it work using select() for writing yet.) */
3603 if (!(sx.peer_offered & OPTION_CHUNKING) && !sx.ok)
3605 /* Save the first address of the next batch. */
3606 sx.first_addr = sx.next_addr;
3612 transport_ctx tctx = {
3613 .u = {.fd = sx.cctx.sock}, /*XXX will this need TLS info? */
3616 .check_string = US".",
3617 .escape_string = US"..", /* Escaping strings */
3619 topt_use_crlf | topt_escape_headers
3620 | (tblock->body_only ? topt_no_headers : 0)
3621 | (tblock->headers_only ? topt_no_body : 0)
3622 | (tblock->return_path_add ? topt_add_return_path : 0)
3623 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3624 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3627 /* If using CHUNKING we need a callback from the generic transport
3628 support to us, for the sending of BDAT smtp commands and the reaping
3629 of responses. The callback needs a whole bunch of state so set up
3630 a transport-context structure to be passed around. */
3632 if (sx.peer_offered & OPTION_CHUNKING)
3634 tctx.check_string = tctx.escape_string = NULL;
3635 tctx.options |= topt_use_bdat;
3636 tctx.chunk_cb = smtp_chunk_cmd_callback;
3637 sx.pending_BDAT = FALSE;
3638 sx.good_RCPT = sx.ok;
3640 tctx.smtp_context = &sx;
3643 tctx.options |= topt_end_dot;
3645 /* Save the first address of the next batch. */
3646 sx.first_addr = sx.next_addr;
3648 /* Responses from CHUNKING commands go in buffer. Otherwise,
3649 there has not been a response. */
3653 sigalrm_seen = FALSE;
3654 transport_write_timeout = ob->data_timeout;
3655 smtp_command = US"sending data block"; /* For error messages */
3656 DEBUG(D_transport|D_v)
3657 if (sx.peer_offered & OPTION_CHUNKING)
3658 debug_printf(" will write message using CHUNKING\n");
3660 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3661 transport_count = 0;
3663 #ifndef DISABLE_DKIM
3664 dkim_exim_sign_init();
3665 # ifdef EXPERIMENTAL_ARC
3667 uschar * s = ob->arc_sign;
3670 if (!(ob->dkim.arc_signspec = s = expand_string(s)))
3672 if (!f.expand_string_forcedfail)
3674 message = US"failed to expand arc_sign";
3681 /* Ask dkim code to hash the body for ARC */
3682 (void) arc_ams_setup_sign_bodyhash();
3683 ob->dkim.force_bodyhash = TRUE;
3688 sx.ok = dkim_transport_write_message(&tctx, &ob->dkim, CUSS &message);
3690 sx.ok = transport_write_message(&tctx, 0);
3693 /* transport_write_message() uses write() because it is called from other
3694 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3695 it can exit with "Broken pipe" as its error. This really means that the
3696 socket got closed at the far end. */
3698 transport_write_timeout = 0; /* for subsequent transports */
3700 /* Failure can either be some kind of I/O disaster (including timeout),
3701 or the failure of a transport filter or the expansion of added headers.
3702 Or, when CHUNKING, it can be a protocol-detected failure. */
3705 if (message) goto SEND_FAILED;
3706 else goto RESPONSE_FAILED;
3708 /* We used to send the terminating "." explicitly here, but because of
3709 buffering effects at both ends of TCP/IP connections, you don't gain
3710 anything by keeping it separate, so it might as well go in the final
3711 data buffer for efficiency. This is now done by setting the topt_end_dot
3714 smtp_command = US"end of data";
3716 if (sx.peer_offered & OPTION_CHUNKING && sx.cmd_count > 1)
3718 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3719 switch(sync_responses(&sx, sx.cmd_count-1, 0))
3721 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3722 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3725 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3726 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3727 case 0: break; /* No 2xx or 5xx, but no probs */
3729 case -1: goto END_OFF; /* Timeout on RCPT */
3731 #ifdef EXPERIMENTAL_PIPE_CONNECT
3732 case -4: HDEBUG(D_transport)
3733 debug_printf("failed reaping pipelined cmd responses\n");
3735 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3739 #ifndef DISABLE_PRDR
3740 /* For PRDR we optionally get a partial-responses warning followed by the
3741 individual responses, before going on with the overall response. If we don't
3742 get the warning then deal with per non-PRDR. */
3746 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '3', ob->final_timeout);
3747 if (!sx.ok && errno == 0) switch(sx.buffer[0])
3749 case '2': sx.prdr_active = FALSE;
3752 case '4': errno = ERRNO_DATA4XX;
3753 addrlist->more_errno |=
3754 ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3761 /* For non-PRDR SMTP, we now read a single response that applies to the
3762 whole message. If it is OK, then all the addresses have been delivered. */
3766 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3768 if (!sx.ok && errno == 0 && sx.buffer[0] == '4')
3770 errno = ERRNO_DATA4XX;
3771 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3775 /* For LMTP, we get back a response for every RCPT command that we sent;
3776 some may be accepted and some rejected. For those that get a response, their
3777 status is fixed; any that are accepted have been handed over, even if later
3778 responses crash - at least, that's how I read RFC 2033.
3780 If all went well, mark the recipient addresses as completed, record which
3781 host/IPaddress they were delivered to, and cut out RSET when sending another
3782 message down the same channel. Write the completed addresses to the journal
3783 now so that they are recorded in case there is a crash of hardware or
3784 software before the spool gets updated. Also record the final SMTP
3785 confirmation if needed (for SMTP only). */
3790 struct timeval delivery_time;
3792 uschar * conf = NULL;
3794 timesince(&delivery_time, &start_delivery_time);
3795 sx.send_rset = FALSE;
3796 pipelining_active = FALSE;
3798 /* Set up confirmation if needed - applies only to SMTP */
3801 #ifdef DISABLE_EVENT
3802 LOGGING(smtp_confirmation) &&
3807 const uschar *s = string_printing(sx.buffer);
3808 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3809 conf = (s == sx.buffer)? US string_copy(s) : US s;
3812 /* Process all transported addresses - for LMTP or PRDR, read a status for
3815 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3817 if (addr->transport_return != PENDING_OK) continue;
3819 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3820 remaining addresses. Otherwise, it's a return code for just the one
3821 address. For temporary errors, add a retry item for the address so that
3822 it doesn't get tried again too soon. */
3824 #ifndef DISABLE_PRDR
3825 if (sx.lmtp || sx.prdr_active)
3830 if (!smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3833 if (errno != 0 || sx.buffer[0] == 0) goto RESPONSE_FAILED;
3834 addr->message = string_sprintf(
3835 #ifndef DISABLE_PRDR
3836 "%s error after %s: %s", sx.prdr_active ? "PRDR":"LMTP",
3838 "LMTP error after %s: %s",
3840 data_command, string_printing(sx.buffer));
3841 setflag(addr, af_pass_message); /* Allow message to go to user */
3842 if (sx.buffer[0] == '5')
3843 addr->transport_return = FAIL;
3846 errno = ERRNO_DATA4XX;
3847 addr->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3848 addr->transport_return = DEFER;
3849 #ifndef DISABLE_PRDR
3850 if (!sx.prdr_active)
3852 retry_add_item(addr, addr->address_retry_key, 0);
3856 sx.completed_addr = TRUE; /* NOW we can set this flag */
3857 if (LOGGING(smtp_confirmation))
3859 const uschar *s = string_printing(sx.buffer);
3860 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3861 conf = (s == sx.buffer) ? US string_copy(s) : US s;
3865 /* SMTP, or success return from LMTP for this address. Pass back the
3866 actual host that was used. */
3868 addr->transport_return = OK;
3869 addr->more_errno = delivery_time.tv_sec;
3870 addr->delivery_usec = delivery_time.tv_usec;
3871 addr->host_used = host;
3872 addr->special_action = flag;
3873 addr->message = conf;
3875 if (tcp_out_fastopen)
3877 setflag(addr, af_tcp_fastopen_conn);
3878 if (tcp_out_fastopen >= TFO_USED_NODATA) setflag(addr, af_tcp_fastopen);
3879 if (tcp_out_fastopen >= TFO_USED_DATA) setflag(addr, af_tcp_fastopen_data);
3881 if (sx.pipelining_used) setflag(addr, af_pipelining);
3882 #ifdef EXPERIMENTAL_PIPE_CONNECT
3883 if (sx.early_pipe_active) setflag(addr, af_early_pipe);
3885 #ifndef DISABLE_PRDR
3886 if (sx.prdr_active) setflag(addr, af_prdr_used);
3888 if (sx.peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3891 #ifndef DISABLE_PRDR
3892 if (!sx.prdr_active)
3895 /* Update the journal. For homonymic addresses, use the base address plus
3896 the transport name. See lots of comments in deliver.c about the reasons
3897 for the complications when homonyms are involved. Just carry on after
3898 write error, as it may prove possible to update the spool file later. */
3900 if (testflag(addr, af_homonym))
3901 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3903 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3905 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx.buffer);
3906 len = Ustrlen(CS sx.buffer);
3907 if (write(journal_fd, sx.buffer, len) != len)
3908 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3909 "%s: %s", sx.buffer, strerror(errno));
3913 #ifndef DISABLE_PRDR
3916 const uschar * overall_message;
3918 /* PRDR - get the final, overall response. For any non-success
3919 upgrade all the address statuses. */
3921 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3925 if(errno == 0 && sx.buffer[0] == '4')
3927 errno = ERRNO_DATA4XX;
3928 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3930 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3931 if (sx.buffer[0] == '5' || addr->transport_return == OK)
3932 addr->transport_return = PENDING_OK; /* allow set_errno action */
3933 goto RESPONSE_FAILED;
3936 /* Append the overall response to the individual PRDR response for logging
3937 and update the journal, or setup retry. */
3939 overall_message = string_printing(sx.buffer);
3940 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3941 if (addr->transport_return == OK)
3942 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
3944 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3945 if (addr->transport_return == OK)
3947 if (testflag(addr, af_homonym))
3948 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3950 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3952 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx.buffer);
3953 len = Ustrlen(CS sx.buffer);
3954 if (write(journal_fd, sx.buffer, len) != len)
3955 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3956 "%s: %s", sx.buffer, strerror(errno));
3958 else if (addr->transport_return == DEFER)
3959 retry_add_item(addr, addr->address_retry_key, -2);
3963 /* Ensure the journal file is pushed out to disk. */
3965 if (EXIMfsync(journal_fd) < 0)
3966 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
3972 /* Handle general (not specific to one address) failures here. The value of ok
3973 is used to skip over this code on the falling through case. A timeout causes a
3974 deferral. Other errors may defer or fail according to the response code, and
3975 may set up a special errno value, e.g. after connection chopped, which is
3976 assumed if errno == 0 and there is no text in the buffer. If control reaches
3977 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
3978 the problem is not related to this specific message. */
3983 uschar * set_message;
3989 sx.send_quit = check_response(host, &save_errno, addrlist->more_errno,
3990 sx.buffer, &code, &message, &pass_message);
3998 message = string_sprintf("send() to %s [%s] failed: %s",
3999 host->name, host->address, message ? message : US strerror(save_errno));
4000 sx.send_quit = FALSE;
4008 sx.ok = FALSE; /* For when reached by GOTO */
4009 set_message = message;
4011 /* We want to handle timeouts after MAIL or "." and loss of connection after
4012 "." specially. They can indicate a problem with the sender address or with
4013 the contents of the message rather than a real error on the connection. These
4014 cases are treated in the same way as a 4xx response. This next bit of code
4015 does the classification. */
4022 message_error = TRUE;
4026 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
4027 Ustrncmp(smtp_command,"end ",4) == 0;
4030 case ERRNO_SMTPCLOSED:
4031 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
4035 message_error = FALSE;
4039 /* Handle the cases that are treated as message errors. These are:
4041 (a) negative response or timeout after MAIL
4042 (b) negative response after DATA
4043 (c) negative response or timeout or dropped connection after "."
4044 (d) utf8 support required and not offered
4046 It won't be a negative response or timeout after RCPT, as that is dealt
4047 with separately above. The action in all cases is to set an appropriate
4048 error code for all the addresses, but to leave yield set to OK because the
4049 host itself has not failed. Of course, it might in practice have failed
4050 when we've had a timeout, but if so, we'll discover that at the next
4051 delivery attempt. For a temporary error, set the message_defer flag, and
4052 write to the logs for information if this is not the last host. The error
4053 for the last host will be logged as part of the address's log line. */
4057 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
4059 /* If there's an errno, the message contains just the identity of
4064 else /* Anything other than 5 is treated as temporary */
4068 message = US string_sprintf("%s: %s", message, strerror(save_errno));
4070 write_logs(host, message, sx.first_addr ? sx.first_addr->basic_errno : 0);
4072 *message_defer = TRUE;
4076 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4077 ".", or some other transportation error. We defer all addresses and yield
4078 DEFER, except for the case of failed add_headers expansion, or a transport
4079 filter failure, when the yield should be ERROR, to stop it trying other
4084 #ifdef EXPERIMENTAL_PIPE_CONNECT
4085 /* If we were early-pipelinng and the actual EHLO response did not match
4086 the cached value we assumed, we could have detected it and passed a
4087 custom errno through to here. It would be nice to RSET and retry right
4088 away, but to reliably do that we eould need an extra synch point before
4089 we committed to data and that would discard half the gained roundrips.
4090 Or we could summarily drop the TCP connection. but that is also ugly.
4091 Instead, we ignore the possibility (having freshened the cache) and rely
4092 on the server telling us with a nonmessage error if we have tried to
4093 do something it no longer supports. */
4096 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
4097 save_errno == ERRNO_FILTER_FAIL) ? ERROR : DEFER;
4101 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
4102 #ifdef EXPERIMENTAL_DSN_INFO
4103 , sx.smtp_greeting, sx.helo_response
4109 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4110 SMTP session tidily. However, if there were too many addresses to send in one
4111 message (indicated by first_addr being non-NULL) we want to carry on with the
4112 rest of them. Also, it is desirable to send more than one message down the SMTP
4113 connection if there are several waiting, provided we haven't already sent so
4114 many as to hit the configured limit. The function transport_check_waiting looks
4115 for a waiting message and returns its id. Then transport_pass_socket tries to
4116 set up a continued delivery by passing the socket on to another process. The
4117 variable send_rset is FALSE if a message has just been successfully transfered.
4119 If we are already sending down a continued channel, there may be further
4120 addresses not yet delivered that are aimed at the same host, but which have not
4121 been passed in this run of the transport. In this case, continue_more will be
4122 true, and all we should do is send RSET if necessary, and return, leaving the
4125 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4126 do not want to continue with other messages down the same channel, because that
4127 can lead to looping between two or more messages, all with the same,
4128 temporarily failing address(es). [The retry information isn't updated yet, so
4129 new processes keep on trying.] We probably also don't want to try more of this
4130 message's addresses either.
4132 If we have started a TLS session, we have to end it before passing the
4133 connection to a new process. However, not all servers can handle this (Exim
4134 can), so we do not pass such a connection on if the host matches
4135 hosts_nopass_tls. */
4138 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4139 "yield=%d first_address is %sNULL\n", sx.ok, sx.send_quit,
4140 sx.send_rset, f.continue_more, yield, sx.first_addr ? "not " : "");
4142 if (sx.completed_addr && sx.ok && sx.send_quit)
4145 smtp_compare_t t_compare;
4147 t_compare.tblock = tblock;
4148 t_compare.current_sender_address = sender_address;
4150 if ( sx.first_addr != NULL
4154 ( tls_out.active.sock < 0 && !continue_proxy_cipher
4155 || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
4159 transport_check_waiting(tblock->name, host->name,
4160 tblock->connection_max_messages, new_message_id, &more,
4161 (oicf)smtp_are_same_identities, (void*)&t_compare)
4168 if (! (sx.ok = smtp_write_command(&sx, SCMD_FLUSH, "RSET\r\n") >= 0))
4170 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
4171 host->address, strerror(errno));
4172 sx.send_quit = FALSE;
4174 else if (! (sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4175 '2', ob->command_timeout)))
4178 sx.send_quit = check_response(host, &errno, 0, sx.buffer, &code, &msg,
4182 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
4183 host->name, host->address, msg);
4187 /* Either RSET was not needed, or it succeeded */
4194 int socket_fd = sx.cctx.sock;
4197 if (sx.first_addr != NULL) /* More addresses still to be sent */
4198 { /* in this run of the transport */
4199 continue_sequence++; /* Causes * in logging */
4203 /* Unless caller said it already has more messages listed for this host,
4204 pass the connection on to a new Exim process (below, the call to
4205 transport_pass_socket). If the caller has more ready, just return with
4206 the connection still open. */
4209 if (tls_out.active.sock >= 0)
4210 if ( f.continue_more
4211 || verify_check_given_host(CUSS &ob->hosts_noproxy_tls, host) == OK)
4213 /* Before passing the socket on, or returning to caller with it still
4214 open, we must shut down TLS. Not all MTAs allow for the continuation
4215 of the SMTP session when TLS is shut down. We test for this by sending
4216 a new EHLO. If we don't get a good response, we don't attempt to pass
4219 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4220 sx.cctx.tls_ctx = NULL;
4221 smtp_peer_options = smtp_peer_options_wrap;
4223 && smtp_write_command(&sx, SCMD_FLUSH, "EHLO %s\r\n", sx.helo_data)
4225 && smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4226 '2', ob->command_timeout);
4228 if (sx.ok && f.continue_more)
4229 return yield; /* More addresses for another run */
4233 /* Set up a pipe for proxying TLS for the new transport process */
4235 smtp_peer_options |= OPTION_TLS;
4236 if (sx.ok = (socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
4239 set_errno(sx.first_addr, errno, US"internal allocation problem",
4241 # ifdef EXPERIMENTAL_DSN_INFO
4242 , sx.smtp_greeting, sx.helo_response
4248 if (f.continue_more)
4249 return yield; /* More addresses for another run */
4251 /* If the socket is successfully passed, we mustn't send QUIT (or
4252 indeed anything!) from here. */
4254 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4255 propagate it from the initial
4257 if (sx.ok && transport_pass_socket(tblock->name, host->name,
4258 host->address, new_message_id, socket_fd))
4260 sx.send_quit = FALSE;
4262 /* We have passed the client socket to a fresh transport process.
4263 If TLS is still active, we need to proxy it for the transport we
4264 just passed the baton to. Fork a child to to do it, and return to
4265 get logging done asap. Which way to place the work makes assumptions
4266 about post-fork prioritisation which may not hold on all platforms. */
4268 if (tls_out.active.sock >= 0)
4271 if (pid == 0) /* child; fork again to disconnect totally */
4273 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
4274 /* does not return */
4275 smtp_proxy_tls(sx.cctx.tls_ctx, sx.buffer, sizeof(sx.buffer), pfd,
4276 ob->command_timeout);
4279 if (pid > 0) /* parent */
4281 DEBUG(D_transport) debug_printf("proxy-proc inter-pid %d\n", pid);
4283 /* tidy the inter-proc to disconn the proxy proc */
4284 waitpid(pid, NULL, 0);
4285 tls_close(sx.cctx.tls_ctx, TLS_NO_SHUTDOWN);
4286 sx.cctx.tls_ctx = NULL;
4287 (void)close(sx.cctx.sock);
4289 continue_transport = NULL;
4290 continue_hostname = NULL;
4293 log_write(0, LOG_PANIC_DIE, "fork failed");
4299 /* If RSET failed and there are addresses left, they get deferred. */
4301 set_errno(sx.first_addr, errno, msg, DEFER, FALSE, host
4302 #ifdef EXPERIMENTAL_DSN_INFO
4303 , sx.smtp_greeting, sx.helo_response
4309 /* End off tidily with QUIT unless the connection has died or the socket has
4310 been passed to another process. There has been discussion on the net about what
4311 to do after sending QUIT. The wording of the RFC suggests that it is necessary
4312 to wait for a response, but on the other hand, there isn't anything one can do
4313 with an error response, other than log it. Exim used to do that. However,
4314 further discussion suggested that it is positively advantageous not to wait for
4315 the response, but to close the session immediately. This is supposed to move
4316 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
4317 load from the server. (Hosts that are both servers and clients may not see much
4318 difference, of course.) Further discussion indicated that this was safe to do
4319 on Unix systems which have decent implementations of TCP/IP that leave the
4320 connection around for a while (TIME_WAIT) after the application has gone away.
4321 This enables the response sent by the server to be properly ACKed rather than
4322 timed out, as can happen on broken TCP/IP implementations on other OS.
4324 This change is being made on 31-Jul-98. After over a year of trouble-free
4325 operation, the old commented-out code was removed on 17-Sep-99. */
4328 if (sx.send_quit) (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4333 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4334 sx.cctx.tls_ctx = NULL;
4337 /* Close the socket, and return the appropriate value, first setting
4338 works because the NULL setting is passed back to the calling process, and
4339 remote_max_parallel is forced to 1 when delivering over an existing connection,
4341 If all went well and continue_more is set, we shouldn't actually get here if
4342 there are further addresses, as the return above will be taken. However,
4343 writing RSET might have failed, or there may be other addresses whose hosts are
4344 specified in the transports, and therefore not visible at top level, in which
4345 case continue_more won't get set. */
4347 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
4350 shutdown(sx.cctx.sock, SHUT_WR);
4351 millisleep(f.running_in_test_harness ? 200 : 20);
4352 if (fcntl(sx.cctx.sock, F_SETFL, O_NONBLOCK) == 0)
4353 for (rc = 16; read(sx.cctx.sock, sx.inbuffer, sizeof(sx.inbuffer)) > 0 && rc > 0;)
4354 rc--; /* drain socket */
4356 (void)close(sx.cctx.sock);
4358 #ifndef DISABLE_EVENT
4359 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
4362 continue_transport = NULL;
4363 continue_hostname = NULL;
4370 /*************************************************
4371 * Closedown entry point *
4372 *************************************************/
4374 /* This function is called when exim is passed an open smtp channel
4375 from another incarnation, but the message which it has been asked
4376 to deliver no longer exists. The channel is on stdin.
4378 We might do fancy things like looking for another message to send down
4379 the channel, but if the one we sought has gone, it has probably been
4380 delivered by some other process that itself will seek further messages,
4381 so just close down our connection.
4383 Argument: pointer to the transport instance block
4388 smtp_transport_closedown(transport_instance *tblock)
4390 smtp_transport_options_block * ob = SOB tblock->options_block;
4391 client_conn_ctx cctx;
4394 uschar inbuffer[4096];
4395 uschar outbuffer[16];
4397 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4398 cctx.sock = fileno(stdin);
4399 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
4401 sx.inblock.cctx = &cctx;
4402 sx.inblock.buffer = inbuffer;
4403 sx.inblock.buffersize = sizeof(inbuffer);
4404 sx.inblock.ptr = inbuffer;
4405 sx.inblock.ptrend = inbuffer;
4407 sx.outblock.cctx = &cctx;
4408 sx.outblock.buffersize = sizeof(outbuffer);
4409 sx.outblock.buffer = outbuffer;
4410 sx.outblock.ptr = outbuffer;
4411 sx.outblock.cmd_count = 0;
4412 sx.outblock.authenticating = FALSE;
4414 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4415 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
4416 (void)close(cctx.sock);
4421 /*************************************************
4422 * Prepare addresses for delivery *
4423 *************************************************/
4425 /* This function is called to flush out error settings from previous delivery
4426 attempts to other hosts. It also records whether we got here via an MX record
4427 or not in the more_errno field of the address. We are interested only in
4428 addresses that are still marked DEFER - others may have got delivered to a
4429 previously considered IP address. Set their status to PENDING_DEFER to indicate
4430 which ones are relevant this time.
4433 addrlist the list of addresses
4434 host the host we are delivering to
4436 Returns: the first address for this delivery
4439 static address_item *
4440 prepare_addresses(address_item *addrlist, host_item *host)
4442 address_item *first_addr = NULL;
4444 for (addr = addrlist; addr; addr = addr->next)
4445 if (addr->transport_return == DEFER)
4447 if (!first_addr) first_addr = addr;
4448 addr->transport_return = PENDING_DEFER;
4449 addr->basic_errno = 0;
4450 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
4451 addr->message = NULL;
4453 addr->cipher = NULL;
4454 addr->ourcert = NULL;
4455 addr->peercert = NULL;
4456 addr->peerdn = NULL;
4457 addr->ocsp = OCSP_NOT_REQ;
4459 #ifdef EXPERIMENTAL_DSN_INFO
4460 addr->smtp_greeting = NULL;
4461 addr->helo_response = NULL;
4469 /*************************************************
4470 * Main entry point *
4471 *************************************************/
4473 /* See local README for interface details. As this is a remote transport, it is
4474 given a chain of addresses to be delivered in one connection, if possible. It
4475 always returns TRUE, indicating that each address has its own independent
4476 status set, except if there is a setting up problem, in which case it returns
4480 smtp_transport_entry(
4481 transport_instance *tblock, /* data for this instantiation */
4482 address_item *addrlist) /* addresses we are working on */
4486 int hosts_defer = 0;
4488 int hosts_looked_up = 0;
4489 int hosts_retry = 0;
4490 int hosts_serial = 0;
4491 int hosts_total = 0;
4492 int total_hosts_tried = 0;
4494 BOOL expired = TRUE;
4495 uschar *expanded_hosts = NULL;
4497 uschar *tid = string_sprintf("%s transport", tblock->name);
4498 smtp_transport_options_block *ob = SOB tblock->options_block;
4499 host_item *hostlist = addrlist->host_list;
4504 debug_printf("%s transport entered\n", tblock->name);
4505 for (addr = addrlist; addr; addr = addr->next)
4506 debug_printf(" %s\n", addr->address);
4509 debug_printf("hostlist:\n");
4510 for (host = hostlist; host; host = host->next)
4511 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
4513 if (continue_hostname)
4514 debug_printf("already connected to %s [%s] (on fd %d)\n",
4515 continue_hostname, continue_host_address,
4516 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
4519 /* Set the flag requesting that these hosts be added to the waiting
4520 database if the delivery fails temporarily or if we are running with
4521 queue_smtp or a 2-stage queue run. This gets unset for certain
4522 kinds of error, typically those that are specific to the message. */
4524 update_waiting = TRUE;
4526 /* If a host list is not defined for the addresses - they must all have the
4527 same one in order to be passed to a single transport - or if the transport has
4528 a host list with hosts_override set, use the host list supplied with the
4529 transport. It is an error for this not to exist. */
4531 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
4532 if (tls_requiretls & REQUIRETLS_MSG)
4533 ob->tls_tempfail_tryclear = FALSE; /*XXX surely we should have a local for this
4534 rather than modifying the transport? */
4537 if (!hostlist || (ob->hosts_override && ob->hosts))
4541 addrlist->message = string_sprintf("%s transport called with no hosts set",
4543 addrlist->transport_return = PANIC;
4544 return FALSE; /* Only top address has status */
4547 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4550 /* If the transport's host list contains no '$' characters, and we are not
4551 randomizing, it is fixed and therefore a chain of hosts can be built once
4552 and for all, and remembered for subsequent use by other calls to this
4553 transport. If, on the other hand, the host list does contain '$', or we are
4554 randomizing its order, we have to rebuild it each time. In the fixed case,
4555 as the hosts string will never be used again, it doesn't matter that we
4556 replace all the : characters with zeros. */
4560 uschar *s = ob->hosts;
4562 if (Ustrchr(s, '$') != NULL)
4564 if (!(expanded_hosts = expand_string(s)))
4566 addrlist->message = string_sprintf("failed to expand list of hosts "
4567 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4568 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4569 return FALSE; /* Only top address has status */
4571 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4572 "\"%s\"\n", s, expanded_hosts);
4576 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4578 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4580 /* Check that the expansion yielded something useful. */
4584 string_sprintf("%s transport has empty hosts setting", tblock->name);
4585 addrlist->transport_return = PANIC;
4586 return FALSE; /* Only top address has status */
4589 /* If there was no expansion of hosts, save the host list for
4592 if (!expanded_hosts) ob->hostlist = hostlist;
4595 /* This is not the first time this transport has been run in this delivery;
4596 the host list was built previously. */
4599 hostlist = ob->hostlist;
4602 /* The host list was supplied with the address. If hosts_randomize is set, we
4603 must sort it into a random order if it did not come from MX records and has not
4604 already been randomized (but don't bother if continuing down an existing
4607 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4609 host_item *newlist = NULL;
4612 host_item *h = hostlist;
4613 hostlist = hostlist->next;
4615 h->sort_key = random_number(100);
4622 else if (h->sort_key < newlist->sort_key)
4629 host_item *hh = newlist;
4632 if (h->sort_key < hh->next->sort_key) break;
4640 hostlist = addrlist->host_list = newlist;
4643 /* Sort out the default port. */
4645 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4647 /* For each host-plus-IP-address on the list:
4649 . If this is a continued delivery and the host isn't the one with the
4650 current connection, skip.
4652 . If the status is unusable (i.e. previously failed or retry checked), skip.
4654 . If no IP address set, get the address, either by turning the name into
4655 an address, calling gethostbyname if gethostbyname is on, or by calling
4656 the DNS. The DNS may yield multiple addresses, in which case insert the
4657 extra ones into the list.
4659 . Get the retry data if not previously obtained for this address and set the
4660 field which remembers the state of this address. Skip if the retry time is
4661 not reached. If not, remember whether retry data was found. The retry string
4662 contains both the name and the IP address.
4664 . Scan the list of addresses and mark those whose status is DEFER as
4665 PENDING_DEFER. These are the only ones that will be processed in this cycle
4668 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4669 Some addresses may be successfully delivered, others may fail, and yet
4670 others may get temporary errors and so get marked DEFER.
4672 . The return from the delivery attempt is OK if a connection was made and a
4673 valid SMTP dialogue was completed. Otherwise it is DEFER.
4675 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4677 . If fail to connect, or other defer state, add a retry item.
4679 . If there are any addresses whose status is still DEFER, carry on to the
4680 next host/IPaddress, unless we have tried the number of hosts given
4681 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4682 there is some fancy logic for hosts_max_try that means its limit can be
4683 overstepped in some circumstances.
4685 If we get to the end of the list, all hosts have deferred at least one address,
4686 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4687 delivery attempt to those hosts whose last try was before the arrival time of
4688 the current message. To cope with this, we have to go round the loop a second
4689 time. After that, set the status and error data for any addresses that haven't
4690 had it set already. */
4692 for (cutoff_retry = 0;
4693 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4696 host_item *nexthost = NULL;
4697 int unexpired_hosts_tried = 0;
4698 BOOL continue_host_tried = FALSE;
4700 retry_non_continued:
4701 for (host = hostlist;
4703 && unexpired_hosts_tried < ob->hosts_max_try
4704 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4710 BOOL host_is_expired = FALSE;
4711 BOOL message_defer = FALSE;
4712 BOOL some_deferred = FALSE;
4713 address_item *first_addr = NULL;
4714 uschar *interface = NULL;
4715 uschar *retry_host_key = NULL;
4716 uschar *retry_message_key = NULL;
4717 uschar *serialize_key = NULL;
4719 /* Default next host is next host. :-) But this can vary if the
4720 hosts_max_try limit is hit (see below). It may also be reset if a host
4721 address is looked up here (in case the host was multihomed). */
4723 nexthost = host->next;
4725 /* If the address hasn't yet been obtained from the host name, look it up
4726 now, unless the host is already marked as unusable. If it is marked as
4727 unusable, it means that the router was unable to find its IP address (in
4728 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4729 the lookup failed last time. We don't get this far if *all* MX records
4730 point to non-existent hosts; that is treated as a hard error.
4732 We can just skip this host entirely. When the hosts came from the router,
4733 the address will timeout based on the other host(s); when the address is
4734 looked up below, there is an explicit retry record added.
4736 Note that we mustn't skip unusable hosts if the address is not unset; they
4737 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4741 int new_port, flags;
4744 if (host->status >= hstatus_unusable)
4746 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4751 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4753 /* The host name is permitted to have an attached port. Find it, and
4754 strip it from the name. Just remember it for now. */
4756 new_port = host_item_get_port(host);
4758 /* Count hosts looked up */
4762 /* Find by name if so configured, or if it's an IP address. We don't
4763 just copy the IP address, because we need the test-for-local to happen. */
4765 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4766 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4767 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4769 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4770 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4772 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4773 &ob->dnssec, /* domains for request/require */
4776 /* Update the host (and any additional blocks, resulting from
4777 multihoming) with a host-specific port, if any. */
4779 for (hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4781 /* Failure to find the host at this time (usually DNS temporary failure)
4782 is really a kind of routing failure rather than a transport failure.
4783 Therefore we add a retry item of the routing kind, not to stop us trying
4784 to look this name up here again, but to ensure the address gets timed
4785 out if the failures go on long enough. A complete failure at this point
4786 commonly points to a configuration error, but the best action is still
4787 to carry on for the next host. */
4789 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4791 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4793 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4794 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4795 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4796 host->status = hstatus_unusable;
4798 for (addr = addrlist; addr; addr = addr->next)
4800 if (addr->transport_return != DEFER) continue;
4801 addr->basic_errno = ERRNO_UNKNOWNHOST;
4802 addr->message = string_sprintf(
4803 rc == HOST_FIND_SECURITY
4804 ? "lookup of IP address for %s was insecure"
4805 : "failed to lookup IP address for %s",
4811 /* If the host is actually the local host, we may have a problem, or
4812 there may be some cunning configuration going on. In the problem case,
4813 log things and give up. The default transport status is already DEFER. */
4815 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4817 for (addr = addrlist; addr; addr = addr->next)
4819 addr->basic_errno = 0;
4820 addr->message = string_sprintf("%s transport found host %s to be "
4821 "local", tblock->name, host->name);
4825 } /* End of block for IP address lookup */
4827 /* If this is a continued delivery, we are interested only in the host
4828 which matches the name of the existing open channel. The check is put
4829 here after the local host lookup, in case the name gets expanded as a
4830 result of the lookup. Set expired FALSE, to save the outer loop executing
4833 if (continue_hostname)
4834 if ( Ustrcmp(continue_hostname, host->name) != 0
4835 || Ustrcmp(continue_host_address, host->address) != 0
4839 continue; /* With next host */
4842 continue_host_tried = TRUE;
4844 /* Reset the default next host in case a multihomed host whose addresses
4845 are not looked up till just above added to the host list. */
4847 nexthost = host->next;
4849 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4850 domain is in queue_smtp_domains, we don't actually want to attempt any
4851 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4852 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4853 were not in it. We don't want to hold up all SMTP deliveries! Except when
4854 doing a two-stage queue run, don't do this if forcing. */
4856 if ((!f.deliver_force || f.queue_2stage) && (f.queue_smtp ||
4857 match_isinlist(addrlist->domain,
4858 (const uschar **)&queue_smtp_domains, 0,
4859 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
4862 for (addr = addrlist; addr; addr = addr->next)
4863 if (addr->transport_return == DEFER)
4864 addr->message = US"domain matches queue_smtp_domains, or -odqs set";
4865 continue; /* With next host */
4868 /* Count hosts being considered - purely for an intelligent comment
4869 if none are usable. */
4873 /* Set $host and $host address now in case they are needed for the
4874 interface expansion or the serialize_hosts check; they remain set if an
4875 actual delivery happens. */
4877 deliver_host = host->name;
4878 deliver_host_address = host->address;
4879 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
4880 : host->dnssec == DS_NO ? US"no"
4883 /* Set up a string for adding to the retry key if the port number is not
4884 the standard SMTP port. A host may have its own port setting that overrides
4887 pistring = string_sprintf(":%d", host->port == PORT_NONE
4888 ? defport : host->port);
4889 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
4891 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4892 string is set, even if constant (as different transports can have different
4893 constant settings), we must add it to the key that is used for retries,
4894 because connections to the same host from a different interface should be
4895 treated separately. */
4897 host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
4898 if ((rs = ob->interface) && *rs)
4900 if (!smtp_get_interface(rs, host_af, addrlist, &interface, tid))
4902 pistring = string_sprintf("%s/%s", pistring, interface);
4905 /* The first time round the outer loop, check the status of the host by
4906 inspecting the retry data. The second time round, we are interested only
4907 in expired hosts that haven't been tried since this message arrived. */
4909 if (cutoff_retry == 0)
4912 /* Ensure the status of the address is set by checking retry data if
4913 necessary. There may be host-specific retry data (applicable to all
4914 messages) and also data for retries of a specific message at this host.
4915 If either of these retry records are actually read, the keys used are
4916 returned to save recomputing them later. */
4918 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4919 US"retry_include_ip_address", ob->retry_include_ip_address,
4920 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4921 continue; /* with next host */
4923 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
4924 incl_ip, &retry_host_key, &retry_message_key);
4926 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
4927 (host->address == NULL)? US"" : host->address, pistring,
4928 (host->status == hstatus_usable)? "usable" :
4929 (host->status == hstatus_unusable)? "unusable" :
4930 (host->status == hstatus_unusable_expired)? "unusable (expired)" : "?");
4932 /* Skip this address if not usable at this time, noting if it wasn't
4933 actually expired, both locally and in the address. */
4935 switch (host->status)
4937 case hstatus_unusable:
4939 setflag(addrlist, af_retry_skipped);
4942 case hstatus_unusable_expired:
4945 case hwhy_retry: hosts_retry++; break;
4946 case hwhy_failed: hosts_fail++; break;
4948 case hwhy_deferred: hosts_defer++; break;
4951 /* If there was a retry message key, implying that previously there
4952 was a message-specific defer, we don't want to update the list of
4953 messages waiting for these hosts. */
4955 if (retry_message_key) update_waiting = FALSE;
4956 continue; /* With the next host or IP address */
4960 /* Second time round the loop: if the address is set but expired, and
4961 the message is newer than the last try, let it through. */
4966 || host->status != hstatus_unusable_expired
4967 || host->last_try > received_time.tv_sec)
4969 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
4970 host->name, host->address, pistring);
4971 host_is_expired = TRUE;
4974 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
4975 it remains TRUE only if all hosts are expired and none are actually tried.
4980 /* If this host is listed as one to which access must be serialized,
4981 see if another Exim process has a connection to it, and if so, skip
4982 this host. If not, update the database to record our connection to it
4983 and remember this for later deletion. Do not do any of this if we are
4984 sending the message down a pre-existing connection. */
4986 if ( !continue_hostname
4987 && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
4989 serialize_key = string_sprintf("host-serialize-%s", host->name);
4990 if (!enq_start(serialize_key, 1))
4993 debug_printf("skipping host %s because another Exim process "
4994 "is connected to it\n", host->name);
5000 /* OK, we have an IP address that is not waiting for its retry time to
5001 arrive (it might be expired) OR (second time round the loop) we have an
5002 expired host that hasn't been tried since the message arrived. Have a go
5003 at delivering the message to it. First prepare the addresses by flushing
5004 out the result of previous attempts, and finding the first address that
5005 is still to be delivered. */
5007 first_addr = prepare_addresses(addrlist, host);
5009 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5010 message_id, host->name, host->address, addrlist->address,
5011 addrlist->next ? ", ..." : "");
5013 set_process_info("delivering %s to %s [%s] (%s%s)",
5014 message_id, host->name, host->address, addrlist->address,
5015 addrlist->next ? ", ..." : "");
5017 /* This is not for real; don't do the delivery. If there are
5018 any remaining hosts, list them. */
5023 set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
5024 for (addr = addrlist; addr; addr = addr->next)
5026 addr->host_used = host;
5027 addr->special_action = '*';
5028 addr->message = US"delivery bypassed by -N option";
5032 debug_printf("*** delivery by %s transport bypassed by -N option\n"
5033 "*** host and remaining hosts:\n", tblock->name);
5034 for (host2 = host; host2; host2 = host2->next)
5035 debug_printf(" %s [%s]\n", host2->name,
5036 host2->address ? host2->address : US"unset");
5041 /* This is for real. If the host is expired, we don't count it for
5042 hosts_max_retry. This ensures that all hosts must expire before an address
5043 is timed out, unless hosts_max_try_hardlimit (which protects against
5044 lunatic DNS configurations) is reached.
5046 If the host is not expired and we are about to hit the hosts_max_retry
5047 limit, check to see if there is a subsequent hosts with a different MX
5048 value. If so, make that the next host, and don't count this one. This is a
5049 heuristic to make sure that different MXs do get tried. With a normal kind
5050 of retry rule, they would get tried anyway when the earlier hosts were
5051 delayed, but if the domain has a "retry every time" type of rule - as is
5052 often used for the the very large ISPs, that won't happen. */
5057 /* Make a copy of the host if it is local to this invocation
5058 of the transport. */
5062 thost = store_get(sizeof(host_item));
5064 thost->name = string_copy(host->name);
5065 thost->address = string_copy(host->address);
5070 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
5074 debug_printf("hosts_max_try limit reached with this host\n");
5075 for (h = host; h; h = h->next) if (h->mx != host->mx)
5078 unexpired_hosts_tried--;
5079 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
5080 "and will be tried\n");
5085 /* Attempt the delivery. */
5087 total_hosts_tried++;
5088 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5089 &message_defer, FALSE);
5092 OK => connection made, each address contains its result;
5093 message_defer is set for message-specific defers (when all
5094 recipients are marked defer)
5095 DEFER => there was a non-message-specific delivery problem;
5096 ERROR => there was a problem setting up the arguments for a filter,
5097 or there was a problem with expanding added headers
5100 /* If the result is not OK, there was a non-message-specific problem.
5101 If the result is DEFER, we need to write to the logs saying what happened
5102 for this particular host, except in the case of authentication and TLS
5103 failures, where the log has already been written. If all hosts defer a
5104 general message is written at the end. */
5106 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
5107 && first_addr->basic_errno != ERRNO_TLSFAILURE)
5108 write_logs(host, first_addr->message, first_addr->basic_errno);
5110 #ifndef DISABLE_EVENT
5112 deferred_event_raise(first_addr, host);
5115 /* If STARTTLS was accepted, but there was a failure in setting up the
5116 TLS session (usually a certificate screwup), and the host is not in
5117 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5118 TLS forcibly turned off. We have to start from scratch with a new SMTP
5119 connection. That's why the retry is done from here, not from within
5120 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5121 session, so the in-clear transmission after those errors, if permitted,
5122 happens inside smtp_deliver().] */
5126 && first_addr->basic_errno == ERRNO_TLSFAILURE
5127 && ob->tls_tempfail_tryclear
5128 && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
5131 log_write(0, LOG_MAIN,
5132 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5133 first_addr->message, host->name, host->address);
5134 first_addr = prepare_addresses(addrlist, host);
5135 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5136 &message_defer, TRUE);
5137 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
5138 write_logs(host, first_addr->message, first_addr->basic_errno);
5139 # ifndef DISABLE_EVENT
5141 deferred_event_raise(first_addr, host);
5144 #endif /*SUPPORT_TLS*/
5147 /* Delivery attempt finished */
5149 rs = rc == OK ? US"OK"
5150 : rc == DEFER ? US"DEFER"
5151 : rc == ERROR ? US"ERROR"
5154 set_process_info("delivering %s: just tried %s [%s] for %s%s: result %s",
5155 message_id, host->name, host->address, addrlist->address,
5156 addrlist->next ? " (& others)" : "", rs);
5158 /* Release serialization if set up */
5160 if (serialize_key) enq_end(serialize_key);
5162 /* If the result is DEFER, or if a host retry record is known to exist, we
5163 need to add an item to the retry chain for updating the retry database
5164 at the end of delivery. We only need to add the item to the top address,
5165 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5166 for any other delivery attempts using the same address. (It is copied into
5167 the unusable tree at the outer level, so even if different address blocks
5168 contain the same address, it still won't get tried again.) */
5170 if (rc == DEFER || retry_host_key)
5172 int delete_flag = rc != DEFER ? rf_delete : 0;
5173 if (!retry_host_key)
5176 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5177 US"retry_include_ip_address", ob->retry_include_ip_address,
5178 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5179 incl_ip = TRUE; /* error; use most-specific retry record */
5181 retry_host_key = incl_ip
5182 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
5183 : string_sprintf("T:%S%s", host->name, pistring);
5186 /* If a delivery of another message over an existing SMTP connection
5187 yields DEFER, we do NOT set up retry data for the host. This covers the
5188 case when there are delays in routing the addresses in the second message
5189 that are so long that the server times out. This is alleviated by not
5190 routing addresses that previously had routing defers when handling an
5191 existing connection, but even so, this case may occur (e.g. if a
5192 previously happily routed address starts giving routing defers). If the
5193 host is genuinely down, another non-continued message delivery will
5194 notice it soon enough. */
5196 if (delete_flag != 0 || !continue_hostname)
5197 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
5199 /* We may have tried an expired host, if its retry time has come; ensure
5200 the status reflects the expiry for the benefit of any other addresses. */
5204 host->status = host_is_expired
5205 ? hstatus_unusable_expired : hstatus_unusable;
5206 host->why = hwhy_deferred;
5210 /* If message_defer is set (host was OK, but every recipient got deferred
5211 because of some message-specific problem), or if that had happened
5212 previously so that a message retry key exists, add an appropriate item
5213 to the retry chain. Note that if there was a message defer but now there is
5214 a host defer, the message defer record gets deleted. That seems perfectly
5215 reasonable. Also, stop the message from being remembered as waiting
5216 for specific hosts. */
5218 if (message_defer || retry_message_key)
5220 int delete_flag = message_defer ? 0 : rf_delete;
5221 if (!retry_message_key)
5224 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5225 US"retry_include_ip_address", ob->retry_include_ip_address,
5226 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5227 incl_ip = TRUE; /* error; use most-specific retry record */
5229 retry_message_key = incl_ip
5230 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
5232 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
5234 retry_add_item(addrlist, retry_message_key,
5235 rf_message | rf_host | delete_flag);
5236 update_waiting = FALSE;
5239 /* Any return other than DEFER (that is, OK or ERROR) means that the
5240 addresses have got their final statuses filled in for this host. In the OK
5241 case, see if any of them are deferred. */
5244 for (addr = addrlist; addr; addr = addr->next)
5245 if (addr->transport_return == DEFER)
5247 some_deferred = TRUE;
5251 /* If no addresses deferred or the result was ERROR, return. We do this for
5252 ERROR because a failing filter set-up or add_headers expansion is likely to
5253 fail for any host we try. */
5255 if (rc == ERROR || (rc == OK && !some_deferred))
5257 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5258 return TRUE; /* Each address has its status */
5261 /* If the result was DEFER or some individual addresses deferred, let
5262 the loop run to try other hosts with the deferred addresses, except for the
5263 case when we were trying to deliver down an existing channel and failed.
5264 Don't try any other hosts in this case. */
5266 if (continue_hostname) break;
5268 /* If the whole delivery, or some individual addresses, were deferred and
5269 there are more hosts that could be tried, do not count this host towards
5270 the hosts_max_try limit if the age of the message is greater than the
5271 maximum retry time for this host. This means we may try try all hosts,
5272 ignoring the limit, when messages have been around for some time. This is
5273 important because if we don't try all hosts, the address will never time
5274 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5276 if ((rc == DEFER || some_deferred) && nexthost)
5279 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
5281 if (retry && retry->rules)
5283 retry_rule *last_rule;
5284 for (last_rule = retry->rules;
5286 last_rule = last_rule->next);
5287 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
5289 else timedout = TRUE; /* No rule => timed out */
5293 unexpired_hosts_tried--;
5294 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
5295 "hosts_max_try (message older than host's retry time)\n");
5298 if (f.running_in_test_harness) millisleep(500); /* let server debug out */
5299 } /* End of loop for trying multiple hosts. */
5301 /* If we failed to find a matching host in the list, for an already-open
5302 connection, just close it and start over with the list. This can happen
5303 for routing that changes from run to run, or big multi-IP sites with
5306 if (continue_hostname && !continue_host_tried)
5308 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
5310 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
5312 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5314 /*XXX doublecheck that! */
5316 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
5318 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
5319 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
5320 cutthrough.cctx.tls_ctx = NULL;
5321 cutthrough.is_tls = FALSE;
5325 (void) write(fd, US"QUIT\r\n", 6);
5328 cutthrough.cctx.sock = -1;
5329 continue_hostname = NULL;
5330 goto retry_non_continued;
5333 /* This is the end of the loop that repeats iff expired is TRUE and
5334 ob->delay_after_cutoff is FALSE. The second time round we will
5335 try those hosts that haven't been tried since the message arrived. */
5339 debug_printf("all IP addresses skipped or deferred at least one address\n");
5340 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
5341 debug_printf("retrying IP addresses not tried since message arrived\n");
5346 /* Get here if all IP addresses are skipped or defer at least one address. In
5347 MUA wrapper mode, this will happen only for connection or other non-message-
5348 specific failures. Force the delivery status for all addresses to FAIL. */
5352 for (addr = addrlist; addr; addr = addr->next)
5353 addr->transport_return = FAIL;
5357 /* In the normal, non-wrapper case, add a standard message to each deferred
5358 address if there hasn't been an error, that is, if it hasn't actually been
5359 tried this time. The variable "expired" will be FALSE if any deliveries were
5360 actually tried, or if there was at least one host that was not expired. That
5361 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5362 a delivery has been tried, an error code will be set, and the failing of the
5363 message is handled by the retry code later.
5365 If queue_smtp is set, or this transport was called to send a subsequent message
5366 down an existing TCP/IP connection, and something caused the host not to be
5367 found, we end up here, but can detect these cases and handle them specially. */
5369 for (addr = addrlist; addr; addr = addr->next)
5371 /* If host is not NULL, it means that we stopped processing the host list
5372 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5373 means we need to behave as if some hosts were skipped because their retry
5374 time had not come. Specifically, this prevents the address from timing out.
5375 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5376 hosts were tried. */
5379 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5382 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5383 "hosts were tried\n");
5388 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5389 setflag(addr, af_retry_skipped);
5392 if (f.queue_smtp) /* no deliveries attempted */
5394 addr->transport_return = DEFER;
5395 addr->basic_errno = 0;
5396 addr->message = US"SMTP delivery explicitly queued";
5399 else if ( addr->transport_return == DEFER
5400 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
5404 addr->basic_errno = ERRNO_HRETRY;
5405 if (continue_hostname)
5406 addr->message = US"no host found for existing SMTP connection";
5409 setflag(addr, af_pass_message); /* This is not a security risk */
5410 addr->message = string_sprintf(
5411 "all hosts%s have been failing for a long time %s",
5412 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
5413 ob->delay_after_cutoff
5414 ? US"(and retry time not reached)"
5415 : US"and were last tried after this message arrived");
5417 /* If we are already using fallback hosts, or there are no fallback hosts
5418 defined, convert the result to FAIL to cause a bounce. */
5420 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
5421 addr->transport_return = FAIL;
5426 if (hosts_retry == hosts_total)
5427 s = "retry time not reached for any host%s";
5428 else if (hosts_fail == hosts_total)
5429 s = "all host address lookups%s failed permanently";
5430 else if (hosts_defer == hosts_total)
5431 s = "all host address lookups%s failed temporarily";
5432 else if (hosts_serial == hosts_total)
5433 s = "connection limit reached for all hosts%s";
5434 else if (hosts_fail+hosts_defer == hosts_total)
5435 s = "all host address lookups%s failed";
5437 s = "some host address lookups failed and retry time "
5438 "not reached for other hosts or connection limit reached%s";
5440 addr->message = string_sprintf(s,
5441 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
5446 /* Update the database which keeps information about which messages are waiting
5447 for which hosts to become available. For some message-specific errors, the
5448 update_waiting flag is turned off because we don't want follow-on deliveries in
5449 those cases. If this transport instance is explicitly limited to one message
5450 per connection then follow-on deliveries are not possible and there's no need
5451 to create/update the per-transport wait-<transport_name> database. */
5453 if (update_waiting && tblock->connection_max_messages != 1)
5454 transport_update_waiting(hostlist, tblock->name);
5458 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5460 return TRUE; /* Each address has its status */
5463 #endif /*!MACRO_PREDEF*/
5466 /* End of transport/smtp.c */