eb6b77416a7bbcd5019e946a052688f133fee420
[users/heiko/exim.git] / src / src / transports / smtp.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 #include "../exim.h"
10 #include "smtp.h"
11
12 #if defined(SUPPORT_DANE) && defined(DISABLE_TLS)
13 # error TLS is required for DANE
14 #endif
15
16
17 /* Options specific to the smtp transport. This transport also supports LMTP
18 over TCP/IP. The options must be in alphabetic order (note that "_" comes
19 before the lower case letters). Some live in the transport_instance block so as
20 to be publicly visible; these are flagged with opt_public. */
21
22 #define LOFF(field) OPT_OFF(smtp_transport_options_block, field)
23
24 optionlist smtp_transport_options[] = {
25   { "*expand_multi_domain",             opt_stringptr | opt_hidden | opt_public,
26       OPT_OFF(transport_instance, expand_multi_domain) },
27   { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
28       LOFF(expand_retry_include_ip_address) },
29
30   { "address_retry_include_sender", opt_bool,
31       LOFF(address_retry_include_sender) },
32   { "allow_localhost",      opt_bool,      LOFF(allow_localhost) },
33 #ifdef EXPERIMENTAL_ARC
34   { "arc_sign", opt_stringptr,             LOFF(arc_sign) },
35 #endif
36   { "authenticated_sender", opt_stringptr, LOFF(authenticated_sender) },
37   { "authenticated_sender_force", opt_bool, LOFF(authenticated_sender_force) },
38   { "command_timeout",      opt_time,      LOFF(command_timeout) },
39   { "connect_timeout",      opt_time,      LOFF(connect_timeout) },
40   { "connection_max_messages", opt_int | opt_public,
41       OPT_OFF(transport_instance, connection_max_messages) },
42 # ifdef SUPPORT_DANE
43   { "dane_require_tls_ciphers", opt_stringptr, LOFF(dane_require_tls_ciphers) },
44 # endif
45   { "data_timeout",         opt_time,      LOFF(data_timeout) },
46   { "delay_after_cutoff",   opt_bool,      LOFF(delay_after_cutoff) },
47 #ifndef DISABLE_DKIM
48   { "dkim_canon", opt_stringptr,           LOFF(dkim.dkim_canon) },
49   { "dkim_domain", opt_stringptr,          LOFF(dkim.dkim_domain) },
50   { "dkim_hash", opt_stringptr,            LOFF(dkim.dkim_hash) },
51   { "dkim_identity", opt_stringptr,        LOFF(dkim.dkim_identity) },
52   { "dkim_private_key", opt_stringptr,     LOFF(dkim.dkim_private_key) },
53   { "dkim_selector", opt_stringptr,        LOFF(dkim.dkim_selector) },
54   { "dkim_sign_headers", opt_stringptr,    LOFF(dkim.dkim_sign_headers) },
55   { "dkim_strict", opt_stringptr,          LOFF(dkim.dkim_strict) },
56   { "dkim_timestamps", opt_stringptr,      LOFF(dkim.dkim_timestamps) },
57 #endif
58   { "dns_qualify_single",   opt_bool,      LOFF(dns_qualify_single) },
59   { "dns_search_parents",   opt_bool,      LOFF(dns_search_parents) },
60   { "dnssec_request_domains", opt_stringptr, LOFF(dnssec.request) },
61   { "dnssec_require_domains", opt_stringptr, LOFF(dnssec.require) },
62   { "dscp",                 opt_stringptr, LOFF(dscp) },
63   { "fallback_hosts",       opt_stringptr, LOFF(fallback_hosts) },
64   { "final_timeout",        opt_time,      LOFF(final_timeout) },
65   { "gethostbyname",        opt_bool,      LOFF(gethostbyname) },
66   { "helo_data",            opt_stringptr, LOFF(helo_data) },
67   { "hosts",                opt_stringptr, LOFF(hosts) },
68   { "hosts_avoid_esmtp",    opt_stringptr, LOFF(hosts_avoid_esmtp) },
69   { "hosts_avoid_pipelining", opt_stringptr, LOFF(hosts_avoid_pipelining) },
70 #ifndef DISABLE_TLS
71   { "hosts_avoid_tls",      opt_stringptr, LOFF(hosts_avoid_tls) },
72 #endif
73   { "hosts_max_try",        opt_int,       LOFF(hosts_max_try) },
74   { "hosts_max_try_hardlimit", opt_int,    LOFF(hosts_max_try_hardlimit) },
75 #ifndef DISABLE_TLS
76   { "hosts_nopass_tls",     opt_stringptr, LOFF(hosts_nopass_tls) },
77   { "hosts_noproxy_tls",    opt_stringptr, LOFF(hosts_noproxy_tls) },
78 #endif
79   { "hosts_override",       opt_bool,      LOFF(hosts_override) },
80 #ifndef DISABLE_PIPE_CONNECT
81   { "hosts_pipe_connect",   opt_stringptr, LOFF(hosts_pipe_connect) },
82 #endif
83   { "hosts_randomize",      opt_bool,      LOFF(hosts_randomize) },
84 #if !defined(DISABLE_TLS) && !defined(DISABLE_OCSP)
85   { "hosts_request_ocsp",   opt_stringptr, LOFF(hosts_request_ocsp) },
86 #endif
87   { "hosts_require_auth",   opt_stringptr, LOFF(hosts_require_auth) },
88 #ifndef DISABLE_TLS
89 # ifdef SUPPORT_DANE
90   { "hosts_require_dane",   opt_stringptr, LOFF(hosts_require_dane) },
91 # endif
92 # ifndef DISABLE_OCSP
93   { "hosts_require_ocsp",   opt_stringptr, LOFF(hosts_require_ocsp) },
94 # endif
95   { "hosts_require_tls",    opt_stringptr, LOFF(hosts_require_tls) },
96 #endif
97   { "hosts_try_auth",       opt_stringptr, LOFF(hosts_try_auth) },
98   { "hosts_try_chunking",   opt_stringptr, LOFF(hosts_try_chunking) },
99 #ifdef SUPPORT_DANE
100   { "hosts_try_dane",       opt_stringptr, LOFF(hosts_try_dane) },
101 #endif
102   { "hosts_try_fastopen",   opt_stringptr, LOFF(hosts_try_fastopen) },
103 #ifndef DISABLE_PRDR
104   { "hosts_try_prdr",       opt_stringptr, LOFF(hosts_try_prdr) },
105 #endif
106 #ifndef DISABLE_TLS
107   { "hosts_verify_avoid_tls", opt_stringptr, LOFF(hosts_verify_avoid_tls) },
108 #endif
109   { "interface",            opt_stringptr, LOFF(interface) },
110   { "keepalive",            opt_bool,      LOFF(keepalive) },
111   { "lmtp_ignore_quota",    opt_bool,      LOFF(lmtp_ignore_quota) },
112   { "max_rcpt",             opt_int | opt_public,
113       OPT_OFF(transport_instance, max_addresses) },
114   { "message_linelength_limit", opt_int,   LOFF(message_linelength_limit) },
115   { "multi_domain",         opt_expand_bool | opt_public,
116       OPT_OFF(transport_instance, multi_domain) },
117   { "port",                 opt_stringptr, LOFF(port) },
118   { "protocol",             opt_stringptr, LOFF(protocol) },
119   { "retry_include_ip_address", opt_expand_bool, LOFF(retry_include_ip_address) },
120   { "serialize_hosts",      opt_stringptr, LOFF(serialize_hosts) },
121   { "size_addition",        opt_int,       LOFF(size_addition) },
122 #ifdef SUPPORT_SOCKS
123   { "socks_proxy",          opt_stringptr, LOFF(socks_proxy) },
124 #endif
125 #ifndef DISABLE_TLS
126   { "tls_certificate",      opt_stringptr, LOFF(tls_certificate) },
127   { "tls_crl",              opt_stringptr, LOFF(tls_crl) },
128   { "tls_dh_min_bits",      opt_int,       LOFF(tls_dh_min_bits) },
129   { "tls_privatekey",       opt_stringptr, LOFF(tls_privatekey) },
130   { "tls_require_ciphers",  opt_stringptr, LOFF(tls_require_ciphers) },
131 # ifndef DISABLE_TLS_RESUME
132   { "tls_resumption_hosts", opt_stringptr, LOFF(tls_resumption_hosts) },
133 # endif
134   { "tls_sni",              opt_stringptr, LOFF(tls_sni) },
135   { "tls_tempfail_tryclear", opt_bool, LOFF(tls_tempfail_tryclear) },
136   { "tls_try_verify_hosts", opt_stringptr, LOFF(tls_try_verify_hosts) },
137   { "tls_verify_cert_hostnames", opt_stringptr, LOFF(tls_verify_cert_hostnames)},
138   { "tls_verify_certificates", opt_stringptr, LOFF(tls_verify_certificates) },
139   { "tls_verify_hosts",     opt_stringptr, LOFF(tls_verify_hosts) },
140 #endif
141 #ifdef SUPPORT_I18N
142   { "utf8_downconvert",     opt_stringptr, LOFF(utf8_downconvert) },
143 #endif
144 };
145
146 /* Size of the options list. An extern variable has to be used so that its
147 address can appear in the tables drtables.c. */
148
149 int smtp_transport_options_count = nelem(smtp_transport_options);
150
151
152 #ifdef MACRO_PREDEF
153
154 /* Dummy values */
155 smtp_transport_options_block smtp_transport_option_defaults = {0};
156 void smtp_transport_init(transport_instance *tblock) {}
157 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
158 void smtp_transport_closedown(transport_instance *tblock) {}
159
160 #else   /*!MACRO_PREDEF*/
161
162
163 /* Default private options block for the smtp transport. */
164
165 smtp_transport_options_block smtp_transport_option_defaults = {
166   /* All non-mentioned elements 0/NULL/FALSE */
167   .helo_data =                  US"$primary_hostname",
168   .protocol =                   US"smtp",
169   .hosts_try_chunking =         US"*",
170 #ifdef SUPPORT_DANE
171   .hosts_try_dane =             US"*",
172 #endif
173   .hosts_try_fastopen =         US"*",
174 #ifndef DISABLE_PRDR
175   .hosts_try_prdr =             US"*",
176 #endif
177 #ifndef DISABLE_OCSP
178   .hosts_request_ocsp =         US"*",               /* hosts_request_ocsp (except under DANE; tls_client_start()) */
179 #endif
180   .command_timeout =            5*60,
181   .connect_timeout =            5*60,
182   .data_timeout =               5*60,
183   .final_timeout =              10*60,
184   .size_addition =              1024,
185   .hosts_max_try =              5,
186   .hosts_max_try_hardlimit =    50,
187   .message_linelength_limit =   998,
188   .address_retry_include_sender = TRUE,
189   .dns_qualify_single =         TRUE,
190   .dnssec = { .request= US"*", .require=NULL },
191   .delay_after_cutoff =         TRUE,
192   .keepalive =                  TRUE,
193   .retry_include_ip_address =   TRUE,
194 #ifndef DISABLE_TLS
195 # if defined(SUPPORT_SYSDEFAULT_CABUNDLE) || !defined(USE_GNUTLS)
196   .tls_verify_certificates =    US"system",
197 # endif
198   .tls_dh_min_bits =            EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
199   .tls_tempfail_tryclear =      TRUE,
200   .tls_try_verify_hosts =       US"*",
201   .tls_verify_cert_hostnames =  US"*",
202 #endif
203 #ifdef SUPPORT_I18N
204   .utf8_downconvert =           US"-1",
205 #endif
206 #ifndef DISABLE_DKIM
207  .dkim =
208    { .dkim_hash =               US"sha256", },
209 #endif
210 };
211
212 /* some DSN flags for use later */
213
214 static int     rf_list[] = {rf_notify_never, rf_notify_success,
215                             rf_notify_failure, rf_notify_delay };
216
217 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
218
219
220
221 /* Local statics */
222
223 static uschar *smtp_command;            /* Points to last cmd for error messages */
224 static uschar *mail_command;            /* Points to MAIL cmd for error messages */
225 static uschar *data_command = US"";     /* Points to DATA cmd for error messages */
226 static BOOL    update_waiting;          /* TRUE to update the "wait" database */
227
228 /*XXX move to smtp_context */
229 static BOOL    pipelining_active;       /* current transaction is in pipe mode */
230
231
232 static unsigned ehlo_response(uschar * buf, unsigned checks);
233
234
235 /******************************************************************************/
236
237 void
238 smtp_deliver_init(void)
239 {
240 if (!regex_PIPELINING) regex_PIPELINING =
241   regex_must_compile(US"\\n250[\\s\\-]PIPELINING(\\s|\\n|$)", FALSE, TRUE);
242
243 if (!regex_SIZE) regex_SIZE =
244   regex_must_compile(US"\\n250[\\s\\-]SIZE(\\s|\\n|$)", FALSE, TRUE);
245
246 if (!regex_AUTH) regex_AUTH =
247   regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
248
249 #ifndef DISABLE_TLS
250 if (!regex_STARTTLS) regex_STARTTLS =
251   regex_must_compile(US"\\n250[\\s\\-]STARTTLS(\\s|\\n|$)", FALSE, TRUE);
252 #endif
253
254 if (!regex_CHUNKING) regex_CHUNKING =
255   regex_must_compile(US"\\n250[\\s\\-]CHUNKING(\\s|\\n|$)", FALSE, TRUE);
256
257 #ifndef DISABLE_PRDR
258 if (!regex_PRDR) regex_PRDR =
259   regex_must_compile(US"\\n250[\\s\\-]PRDR(\\s|\\n|$)", FALSE, TRUE);
260 #endif
261
262 #ifdef SUPPORT_I18N
263 if (!regex_UTF8) regex_UTF8 =
264   regex_must_compile(US"\\n250[\\s\\-]SMTPUTF8(\\s|\\n|$)", FALSE, TRUE);
265 #endif
266
267 if (!regex_DSN) regex_DSN  =
268   regex_must_compile(US"\\n250[\\s\\-]DSN(\\s|\\n|$)", FALSE, TRUE);
269
270 if (!regex_IGNOREQUOTA) regex_IGNOREQUOTA =
271   regex_must_compile(US"\\n250[\\s\\-]IGNOREQUOTA(\\s|\\n|$)", FALSE, TRUE);
272
273 #ifndef DISABLE_PIPE_CONNECT
274 if (!regex_EARLY_PIPE) regex_EARLY_PIPE =
275   regex_must_compile(US"\\n250[\\s\\-]" EARLY_PIPE_FEATURE_NAME "(\\s|\\n|$)", FALSE, TRUE);
276 #endif
277 }
278
279
280 /*************************************************
281 *             Setup entry point                  *
282 *************************************************/
283
284 /* This function is called when the transport is about to be used,
285 but before running it in a sub-process. It is used for two things:
286
287   (1) To set the fallback host list in addresses, when delivering.
288   (2) To pass back the interface, port, protocol, and other options, for use
289       during callout verification.
290
291 Arguments:
292   tblock    pointer to the transport instance block
293   addrlist  list of addresses about to be transported
294   tf        if not NULL, pointer to block in which to return options
295   uid       the uid that will be set (not used)
296   gid       the gid that will be set (not used)
297   errmsg    place for error message (not used)
298
299 Returns:  OK always (FAIL, DEFER not used)
300 */
301
302 static int
303 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
304   transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
305 {
306 smtp_transport_options_block *ob = SOB tblock->options_block;
307
308 /* Pass back options if required. This interface is getting very messy. */
309
310 if (tf)
311   {
312   tf->interface = ob->interface;
313   tf->port = ob->port;
314   tf->protocol = ob->protocol;
315   tf->hosts = ob->hosts;
316   tf->hosts_override = ob->hosts_override;
317   tf->hosts_randomize = ob->hosts_randomize;
318   tf->gethostbyname = ob->gethostbyname;
319   tf->qualify_single = ob->dns_qualify_single;
320   tf->search_parents = ob->dns_search_parents;
321   tf->helo_data = ob->helo_data;
322   }
323
324 /* Set the fallback host list for all the addresses that don't have fallback
325 host lists, provided that the local host wasn't present in the original host
326 list. */
327
328 if (!testflag(addrlist, af_local_host_removed))
329   for (; addrlist; addrlist = addrlist->next)
330     if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
331
332 return OK;
333 }
334
335
336
337 /*************************************************
338 *          Initialization entry point            *
339 *************************************************/
340
341 /* Called for each instance, after its options have been read, to
342 enable consistency checks to be done, or anything else that needs
343 to be set up.
344
345 Argument:   pointer to the transport instance block
346 Returns:    nothing
347 */
348
349 void
350 smtp_transport_init(transport_instance *tblock)
351 {
352 smtp_transport_options_block *ob = SOB tblock->options_block;
353
354 /* Retry_use_local_part defaults FALSE if unset */
355
356 if (tblock->retry_use_local_part == TRUE_UNSET)
357   tblock->retry_use_local_part = FALSE;
358
359 /* Set the default port according to the protocol */
360
361 if (!ob->port)
362   ob->port = strcmpic(ob->protocol, US"lmtp") == 0
363   ? US"lmtp"
364   : strcmpic(ob->protocol, US"smtps") == 0
365   ? US"smtps" : US"smtp";
366
367 /* Set up the setup entry point, to be called before subprocesses for this
368 transport. */
369
370 tblock->setup = smtp_transport_setup;
371
372 /* Complain if any of the timeouts are zero. */
373
374 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
375     ob->final_timeout <= 0)
376   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
377     "command, data, or final timeout value is zero for %s transport",
378       tblock->name);
379
380 /* If hosts_override is set and there are local hosts, set the global
381 flag that stops verify from showing router hosts. */
382
383 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
384
385 /* If there are any fallback hosts listed, build a chain of host items
386 for them, but do not do any lookups at this time. */
387
388 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
389 }
390
391
392
393
394
395 /*************************************************
396 *   Set delivery info into all active addresses  *
397 *************************************************/
398
399 /* Only addresses whose status is >= PENDING are relevant. A lesser
400 status means that an address is not currently being processed.
401
402 Arguments:
403   addrlist       points to a chain of addresses
404   errno_value    to put in each address's errno field
405   msg            to put in each address's message field
406   rc             to put in each address's transport_return field
407   pass_message   if TRUE, set the "pass message" flag in the address
408   host           if set, mark addrs as having used this host
409   smtp_greeting  from peer
410   helo_response  from peer
411   start          points to timestamp of delivery start
412
413 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
414 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
415 this particular type of timeout.
416
417 Returns:       nothing
418 */
419
420 static void
421 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
422   BOOL pass_message, host_item * host,
423 #ifdef EXPERIMENTAL_DSN_INFO
424   const uschar * smtp_greeting, const uschar * helo_response,
425 #endif
426   struct timeval * start
427   )
428 {
429 int orvalue = 0;
430 struct timeval deliver_time;
431
432 if (errno_value == ERRNO_CONNECTTIMEOUT)
433   {
434   errno_value = ETIMEDOUT;
435   orvalue = RTEF_CTOUT;
436   }
437 timesince(&deliver_time, start);
438
439 for (address_item * addr = addrlist; addr; addr = addr->next)
440   if (addr->transport_return >= PENDING)
441     {
442     addr->basic_errno = errno_value;
443     addr->more_errno |= orvalue;
444     addr->delivery_time = deliver_time;
445     if (msg)
446       {
447       addr->message = msg;
448       if (pass_message) setflag(addr, af_pass_message);
449       }
450     addr->transport_return = rc;
451     if (host)
452       {
453       addr->host_used = host;
454 #ifdef EXPERIMENTAL_DSN_INFO
455       if (smtp_greeting)
456         {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
457       addr->smtp_greeting = smtp_greeting;
458
459       if (helo_response)
460         {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
461       addr->helo_response = helo_response;
462 #endif
463       }
464     }
465 }
466
467 static void
468 set_errno_nohost(address_item * addrlist, int errno_value, uschar * msg, int rc,
469   BOOL pass_message, struct timeval * start)
470 {
471 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL,
472 #ifdef EXPERIMENTAL_DSN_INFO
473           NULL, NULL,
474 #endif
475           start);
476 }
477
478
479 /*************************************************
480 *          Check an SMTP response                *
481 *************************************************/
482
483 /* This function is given an errno code and the SMTP response buffer
484 to analyse, together with the host identification for generating messages. It
485 sets an appropriate message and puts the first digit of the response code into
486 the yield variable. If no response was actually read, a suitable digit is
487 chosen.
488
489 Arguments:
490   host           the current host, to get its name for messages
491   errno_value    pointer to the errno value
492   more_errno     from the top address for use with ERRNO_FILTER_FAIL
493   buffer         the SMTP response buffer
494   yield          where to put a one-digit SMTP response code
495   message        where to put an error message
496   pass_message   set TRUE if message is an SMTP response
497
498 Returns:         TRUE if an SMTP "QUIT" command should be sent, else FALSE
499 */
500
501 static BOOL
502 check_response(host_item *host, int *errno_value, int more_errno,
503   uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
504 {
505 uschar * pl = pipelining_active ? US"pipelined " : US"";
506 const uschar * s;
507
508 *yield = '4';    /* Default setting is to give a temporary error */
509
510 switch(*errno_value)
511   {
512   case ETIMEDOUT:               /* Handle response timeout */
513     *message = US string_sprintf("SMTP timeout after %s%s",
514         pl, smtp_command);
515     if (transport_count > 0)
516       *message = US string_sprintf("%s (%d bytes written)", *message,
517         transport_count);
518     return FALSE;
519
520   case ERRNO_SMTPFORMAT:        /* Handle malformed SMTP response */
521     s = string_printing(buffer);
522     while (isspace(*s)) s++;
523     *message = *s == 0
524       ? string_sprintf("Malformed SMTP reply (an empty line) "
525           "in response to %s%s", pl, smtp_command)
526       : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
527           pl, smtp_command, s);
528     return FALSE;
529
530   case ERRNO_TLSFAILURE:        /* Handle bad first read; can happen with
531                                 GnuTLS and TLS1.3 */
532     *message = US"bad first read from TLS conn";
533     return TRUE;
534
535   case ERRNO_FILTER_FAIL:       /* Handle a failed filter process error;
536                           can't send QUIT as we mustn't end the DATA. */
537     *message = string_sprintf("transport filter process failed (%d)%s",
538       more_errno,
539       more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
540     return FALSE;
541
542   case ERRNO_CHHEADER_FAIL:     /* Handle a failed add_headers expansion;
543                             can't send QUIT as we mustn't end the DATA. */
544     *message =
545       string_sprintf("failed to expand headers_add or headers_remove: %s",
546         expand_string_message);
547     return FALSE;
548
549   case ERRNO_WRITEINCOMPLETE:   /* failure to write a complete data block */
550     *message = US"failed to write a data block";
551     return FALSE;
552
553 #ifdef SUPPORT_I18N
554   case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
555     *message = US"utf8 support required but not offered for forwarding";
556     DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
557     return TRUE;
558 #endif
559   }
560
561 /* Handle error responses from the remote mailer. */
562
563 if (buffer[0] != 0)
564   {
565   *message = string_sprintf("SMTP error from remote mail server after %s%s: "
566     "%s", pl, smtp_command, s = string_printing(buffer));
567   *pass_message = TRUE;
568   *yield = buffer[0];
569   return TRUE;
570   }
571
572 /* No data was read. If there is no errno, this must be the EOF (i.e.
573 connection closed) case, which causes deferral. An explicit connection reset
574 error has the same effect. Otherwise, put the host's identity in the message,
575 leaving the errno value to be interpreted as well. In all cases, we have to
576 assume the connection is now dead. */
577
578 if (*errno_value == 0 || *errno_value == ECONNRESET)
579   {
580   *errno_value = ERRNO_SMTPCLOSED;
581   *message = US string_sprintf("Remote host closed connection "
582     "in response to %s%s", pl, smtp_command);
583   }
584 else
585   *message = US string_sprintf("%s [%s]", host->name, host->address);
586
587 return FALSE;
588 }
589
590
591
592 /*************************************************
593 *          Write error message to logs           *
594 *************************************************/
595
596 /* This writes to the main log and to the message log.
597
598 Arguments:
599   host     the current host
600   detail  the current message (addr_item->message)
601   basic_errno the errno (addr_item->basic_errno)
602
603 Returns:   nothing
604 */
605
606 static void
607 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
608 {
609 gstring * message = LOGGING(outgoing_port)
610   ? string_fmt_append(NULL, "H=%s [%s]:%d", host->name, host->address,
611                     host->port == PORT_NONE ? 25 : host->port)
612   : string_fmt_append(NULL, "H=%s [%s]", host->name, host->address);
613
614 if (suffix)
615   {
616   message = string_fmt_append(message, ": %s", suffix);
617   if (basic_errno > 0)
618     message = string_fmt_append(message, ": %s", strerror(basic_errno));
619   }
620 else
621   message = string_fmt_append(message, " %s", exim_errstr(basic_errno));
622
623 log_write(0, LOG_MAIN, "%s", string_from_gstring(message));
624 deliver_msglog("%s %s\n", tod_stamp(tod_log), message->s);
625 }
626
627 static void
628 msglog_line(host_item * host, uschar * message)
629 {
630 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
631   host->name, host->address, message);
632 }
633
634
635
636 #ifndef DISABLE_EVENT
637 /*************************************************
638 *   Post-defer action                            *
639 *************************************************/
640
641 /* This expands an arbitrary per-transport string.
642    It might, for example, be used to write to the database log.
643
644 Arguments:
645   addr                  the address item containing error information
646   host                  the current host
647   evstr                 the event
648
649 Returns:   nothing
650 */
651
652 static void
653 deferred_event_raise(address_item * addr, host_item * host, uschar * evstr)
654 {
655 uschar * action = addr->transport->event_action;
656 const uschar * save_domain;
657 uschar * save_local;
658
659 if (!action)
660   return;
661
662 save_domain = deliver_domain;
663 save_local = deliver_localpart;
664
665 /*XXX would ip & port already be set up? */
666 deliver_host_address = string_copy(host->address);
667 deliver_host_port =    host->port == PORT_NONE ? 25 : host->port;
668 event_defer_errno =    addr->basic_errno;
669
670 router_name =    addr->router->name;
671 transport_name = addr->transport->name;
672 deliver_domain = addr->domain;
673 deliver_localpart = addr->local_part;
674
675 (void) event_raise(action, evstr,
676     addr->message
677       ? addr->basic_errno > 0
678         ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
679         : string_copy(addr->message)
680       : addr->basic_errno > 0
681         ? string_copy(US strerror(addr->basic_errno))
682         : NULL);
683
684 deliver_localpart = save_local;
685 deliver_domain =    save_domain;
686 router_name = transport_name = NULL;
687 }
688 #endif
689
690 /*************************************************
691 *           Reap SMTP specific responses         *
692 *************************************************/
693 static int
694 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
695   int count)
696 {
697 uschar flushbuffer[4096];
698
699 while (count-- > 0)
700   {
701   if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
702              '2', ob->command_timeout)
703       && (errno != 0 || flushbuffer[0] == 0))
704     break;
705   }
706 return count;
707 }
708
709
710 /* Return boolean success */
711
712 static BOOL
713 smtp_reap_banner(smtp_context * sx)
714 {
715 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
716   '2', (SOB sx->conn_args.ob)->command_timeout);
717 #ifdef EXPERIMENTAL_DSN_INFO
718 sx->smtp_greeting = string_copy(sx->buffer);
719 #endif
720 return good_response;
721 }
722
723 static BOOL
724 smtp_reap_ehlo(smtp_context * sx)
725 {
726 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
727        (SOB sx->conn_args.ob)->command_timeout))
728   {
729   if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
730     {
731 #ifdef EXPERIMENTAL_DSN_INFO
732     sx->helo_response = string_copy(sx->buffer);
733 #endif
734     return FALSE;
735     }
736   sx->esmtp = FALSE;
737   }
738 #ifdef EXPERIMENTAL_DSN_INFO
739 sx->helo_response = string_copy(sx->buffer);
740 #endif
741 #ifndef DISABLE_EVENT
742 (void) event_raise(sx->conn_args.tblock->event_action,
743   US"smtp:ehlo", sx->buffer);
744 #endif
745 return TRUE;
746 }
747
748
749
750 #ifndef DISABLE_PIPE_CONNECT
751 static uschar *
752 ehlo_cache_key(const smtp_context * sx)
753 {
754 host_item * host = sx->conn_args.host;
755 return Ustrchr(host->address, ':')
756   ? string_sprintf("[%s]:%d.EHLO", host->address,
757     host->port == PORT_NONE ? sx->port : host->port)
758   : string_sprintf("%s:%d.EHLO", host->address,
759     host->port == PORT_NONE ? sx->port : host->port);
760 }
761
762 static void
763 write_ehlo_cache_entry(const smtp_context * sx)
764 {
765 open_db dbblock, * dbm_file;
766
767 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
768   {
769   uschar * ehlo_resp_key = ehlo_cache_key(sx);
770   dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
771
772   HDEBUG(D_transport) debug_printf("writing clr %04x/%04x cry %04x/%04x\n",
773     sx->ehlo_resp.cleartext_features, sx->ehlo_resp.cleartext_auths,
774     sx->ehlo_resp.crypted_features, sx->ehlo_resp.crypted_auths);
775
776   dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
777   dbfn_close(dbm_file);
778   }
779 }
780
781 static void
782 invalidate_ehlo_cache_entry(smtp_context * sx)
783 {
784 open_db dbblock, * dbm_file;
785
786 if (  sx->early_pipe_active
787    && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
788   {
789   uschar * ehlo_resp_key = ehlo_cache_key(sx);
790   dbfn_delete(dbm_file, ehlo_resp_key);
791   dbfn_close(dbm_file);
792   }
793 }
794
795 static BOOL
796 read_ehlo_cache_entry(smtp_context * sx)
797 {
798 open_db dbblock;
799 open_db * dbm_file;
800
801 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE, TRUE)))
802   { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
803 else
804   {
805   uschar * ehlo_resp_key = ehlo_cache_key(sx);
806   dbdata_ehlo_resp * er;
807
808   if (!(er = dbfn_read_enforce_length(dbm_file, ehlo_resp_key, sizeof(dbdata_ehlo_resp))))
809     { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
810   else if (time(NULL) - er->time_stamp > retry_data_expire)
811     {
812     DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
813     dbfn_close(dbm_file);
814     if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
815       dbfn_delete(dbm_file, ehlo_resp_key);
816     }
817   else
818     {
819     sx->ehlo_resp = er->data;
820     dbfn_close(dbm_file);
821     DEBUG(D_transport) debug_printf(
822         "EHLO response bits from cache: cleartext 0x%04x/0x%04x crypted 0x%04x/0x%04x\n",
823         er->data.cleartext_features, er->data.cleartext_auths,
824         er->data.crypted_features, er->data.crypted_auths);
825     return TRUE;
826     }
827   dbfn_close(dbm_file);
828   }
829 return FALSE;
830 }
831
832
833
834 /* Return an auths bitmap for the set of AUTH methods offered by the server
835 which match our authenticators. */
836
837 static unsigned short
838 study_ehlo_auths(smtp_context * sx)
839 {
840 uschar * names;
841 auth_instance * au;
842 uschar authnum;
843 unsigned short authbits = 0;
844
845 if (!sx->esmtp) return 0;
846 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
847 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
848 expand_nmax = -1;                                               /* reset */
849 names = string_copyn(expand_nstring[1], expand_nlength[1]);
850
851 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
852   {
853   const uschar * list = names;
854   uschar * s;
855   for (int sep = ' '; s = string_nextinlist(&list, &sep, NULL, 0); )
856     if (strcmpic(au->public_name, s) == 0)
857       { authbits |= BIT(authnum); break; }
858   }
859
860 DEBUG(D_transport)
861   debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
862     tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
863
864 if (tls_out.active.sock >= 0)
865   sx->ehlo_resp.crypted_auths = authbits;
866 else
867   sx->ehlo_resp.cleartext_auths = authbits;
868 return authbits;
869 }
870
871
872
873
874 /* Wait for and check responses for early-pipelining.
875
876 Called from the lower-level smtp_read_response() function
877 used for general code that assume synchronisation, if context
878 flags indicate outstanding early-pipelining commands.  Also
879 called fom sync_responses() which handles pipelined commands.
880
881 Arguments:
882  sx     smtp connection context
883  countp number of outstanding responses, adjusted on return
884
885 Return:
886  OK     all well
887  DEFER  error on first read of TLS'd conn
888  FAIL   SMTP error in response
889 */
890 int
891 smtp_reap_early_pipe(smtp_context * sx, int * countp)
892 {
893 BOOL pending_BANNER = sx->pending_BANNER;
894 BOOL pending_EHLO = sx->pending_EHLO;
895 int rc = FAIL;
896
897 sx->pending_BANNER = FALSE;     /* clear early to avoid recursion */
898 sx->pending_EHLO = FALSE;
899
900 if (pending_BANNER)
901   {
902   DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
903   (*countp)--;
904   if (!smtp_reap_banner(sx))
905     {
906     DEBUG(D_transport) debug_printf("bad banner\n");
907     if (tls_out.active.sock >= 0) rc = DEFER;
908     goto fail;
909     }
910   }
911
912 if (pending_EHLO)
913   {
914   unsigned peer_offered;
915   unsigned short authbits = 0, * ap;
916
917   DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
918   (*countp)--;
919   if (!smtp_reap_ehlo(sx))
920     {
921     DEBUG(D_transport) debug_printf("bad response for EHLO\n");
922     if (tls_out.active.sock >= 0) rc = DEFER;
923     goto fail;
924     }
925
926   /* Compare the actual EHLO response to the cached value we assumed;
927   on difference, dump or rewrite the cache and arrange for a retry. */
928
929   ap = tls_out.active.sock < 0
930       ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
931
932   peer_offered = ehlo_response(sx->buffer,
933           (tls_out.active.sock < 0 ?  OPTION_TLS : 0)
934         | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
935         | OPTION_UTF8 | OPTION_EARLY_PIPE
936         );
937   if (  peer_offered != sx->peer_offered
938      || (authbits = study_ehlo_auths(sx)) != *ap)
939     {
940     HDEBUG(D_transport)
941       debug_printf("EHLO %s extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
942                     tls_out.active.sock < 0 ? "cleartext" : "crypted",
943                     sx->peer_offered, *ap, peer_offered, authbits);
944     *(tls_out.active.sock < 0
945       ? &sx->ehlo_resp.cleartext_features : &sx->ehlo_resp.crypted_features) = peer_offered;
946     *ap = authbits;
947     if (peer_offered & OPTION_EARLY_PIPE)
948       write_ehlo_cache_entry(sx);
949     else
950       invalidate_ehlo_cache_entry(sx);
951
952     return OK;          /* just carry on */
953     }
954   }
955 return OK;
956
957 fail:
958   invalidate_ehlo_cache_entry(sx);
959   (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
960   return rc;
961 }
962 #endif
963
964
965 /*************************************************
966 *           Synchronize SMTP responses           *
967 *************************************************/
968
969 /* This function is called from smtp_deliver() to receive SMTP responses from
970 the server, and match them up with the commands to which they relate. When
971 PIPELINING is not in use, this function is called after every command, and is
972 therefore somewhat over-engineered, but it is simpler to use a single scheme
973 that works both with and without PIPELINING instead of having two separate sets
974 of code.
975
976 The set of commands that are buffered up with pipelining may start with MAIL
977 and may end with DATA; in between are RCPT commands that correspond to the
978 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
979 etc.) are never buffered.
980
981 Errors after MAIL or DATA abort the whole process leaving the response in the
982 buffer. After MAIL, pending responses are flushed, and the original command is
983 re-instated in big_buffer for error messages. For RCPT commands, the remote is
984 permitted to reject some recipient addresses while accepting others. However
985 certain errors clearly abort the whole process. Set the value in
986 transport_return to PENDING_OK if the address is accepted. If there is a
987 subsequent general error, it will get reset accordingly. If not, it will get
988 converted to OK at the end.
989
990 Arguments:
991   sx                smtp connection context
992   count             the number of responses to read
993   pending_DATA      0 if last command sent was not DATA
994                    +1 if previously had a good recipient
995                    -1 if not previously had a good recipient
996
997 Returns:      3 if at least one address had 2xx and one had 5xx
998               2 if at least one address had 5xx but none had 2xx
999               1 if at least one host had a 2xx response, but none had 5xx
1000               0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1001              -1 timeout while reading RCPT response
1002              -2 I/O or other non-response error for RCPT
1003              -3 DATA or MAIL failed - errno and buffer set
1004              -4 banner or EHLO failed (early-pipelining)
1005              -5 banner or EHLO failed (early-pipelining, TLS)
1006 */
1007
1008 static int
1009 sync_responses(smtp_context * sx, int count, int pending_DATA)
1010 {
1011 address_item * addr = sx->sync_addr;
1012 smtp_transport_options_block * ob = sx->conn_args.ob;
1013 int yield = 0;
1014
1015 #ifndef DISABLE_PIPE_CONNECT
1016 int rc;
1017 if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
1018   return rc == FAIL ? -4 : -5;
1019 #endif
1020
1021 /* Handle the response for a MAIL command. On error, reinstate the original
1022 command in big_buffer for error message use, and flush any further pending
1023 responses before returning, except after I/O errors and timeouts. */
1024
1025 if (sx->pending_MAIL)
1026   {
1027   DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1028   count--;
1029   sx->pending_MAIL = FALSE;
1030   if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1031                           '2', ob->command_timeout))
1032     {
1033     DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1034     Ustrcpy(big_buffer, mail_command);  /* Fits, because it came from there! */
1035     if (errno == ERRNO_TLSFAILURE)
1036       return -5;
1037     if (errno == 0 && sx->buffer[0] != 0)
1038       {
1039       int save_errno = 0;
1040       if (sx->buffer[0] == '4')
1041         {
1042         save_errno = ERRNO_MAIL4XX;
1043         addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1044         }
1045       count = smtp_discard_responses(sx, ob, count);
1046       errno = save_errno;
1047       }
1048
1049     if (pending_DATA) count--;  /* Number of RCPT responses to come */
1050     while (count-- > 0)         /* Mark any pending addrs with the host used */
1051       {
1052       while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1053       addr->host_used = sx->conn_args.host;
1054       addr = addr->next;
1055       }
1056     return -3;
1057     }
1058   }
1059
1060 if (pending_DATA) count--;  /* Number of RCPT responses to come */
1061
1062 /* Read and handle the required number of RCPT responses, matching each one up
1063 with an address by scanning for the next address whose status is PENDING_DEFER.
1064 */
1065
1066 while (count-- > 0)
1067   {
1068   while (addr->transport_return != PENDING_DEFER)
1069     if (!(addr = addr->next))
1070       return -2;
1071
1072   /* The address was accepted */
1073   addr->host_used = sx->conn_args.host;
1074
1075   DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1076   if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1077                           '2', ob->command_timeout))
1078     {
1079     yield |= 1;
1080     addr->transport_return = PENDING_OK;
1081
1082     /* If af_dr_retry_exists is set, there was a routing delay on this address;
1083     ensure that any address-specific retry record is expunged. We do this both
1084     for the basic key and for the version that also includes the sender. */
1085
1086     if (testflag(addr, af_dr_retry_exists))
1087       {
1088       uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1089         sender_address);
1090       retry_add_item(addr, altkey, rf_delete);
1091       retry_add_item(addr, addr->address_retry_key, rf_delete);
1092       }
1093     }
1094
1095   /* Error on first TLS read */
1096
1097   else if (errno == ERRNO_TLSFAILURE)
1098     return -5;
1099
1100   /* Timeout while reading the response */
1101
1102   else if (errno == ETIMEDOUT)
1103     {
1104     uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1105                 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1106     set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE, &sx->delivery_start);
1107     retry_add_item(addr, addr->address_retry_key, 0);
1108     update_waiting = FALSE;
1109     return -1;
1110     }
1111
1112   /* Handle other errors in obtaining an SMTP response by returning -1. This
1113   will cause all the addresses to be deferred. Restore the SMTP command in
1114   big_buffer for which we are checking the response, so the error message
1115   makes sense. */
1116
1117   else if (errno != 0 || sx->buffer[0] == 0)
1118     {
1119     gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer }, * g = &gs;
1120
1121     /* Use taint-unchecked routines for writing into big_buffer, trusting
1122     that we'll never expand it. */
1123
1124     g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "RCPT TO:<%s>",
1125       transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1126     string_from_gstring(g);
1127     return -2;
1128     }
1129
1130   /* Handle SMTP permanent and temporary response codes. */
1131
1132   else
1133     {
1134     addr->message =
1135       string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1136         "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1137         string_printing(sx->buffer));
1138     setflag(addr, af_pass_message);
1139     if (!sx->verify)
1140       msglog_line(sx->conn_args.host, addr->message);
1141
1142     /* The response was 5xx */
1143
1144     if (sx->buffer[0] == '5')
1145       {
1146       addr->transport_return = FAIL;
1147       yield |= 2;
1148       }
1149
1150     /* The response was 4xx */
1151
1152     else
1153       {
1154       addr->transport_return = DEFER;
1155       addr->basic_errno = ERRNO_RCPT4XX;
1156       addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1157
1158       if (!sx->verify)
1159         {
1160 #ifndef DISABLE_EVENT
1161         event_defer_errno = addr->more_errno;
1162         msg_event_raise(US"msg:rcpt:host:defer", addr);
1163 #endif
1164         /* If a 452 and we've had at least one 2xx or 5xx, set next_addr to the
1165         start point for another MAIL command. */
1166
1167         if (addr->more_errno >> 8 == 52  &&  yield & 3)
1168           {
1169           if (!sx->RCPT_452)
1170             {
1171             DEBUG(D_transport)
1172               debug_printf("%s: seen first 452 too-many-rcpts\n", __FUNCTION__);
1173             sx->RCPT_452 = TRUE;
1174             sx->next_addr = addr;
1175             }
1176           addr->transport_return = PENDING_DEFER;
1177           addr->basic_errno = 0;
1178           }
1179         else
1180           {
1181           /* Log temporary errors if there are more hosts to be tried.
1182           If not, log this last one in the == line. */
1183
1184           if (sx->conn_args.host->next)
1185             if (LOGGING(outgoing_port))
1186               log_write(0, LOG_MAIN, "H=%s [%s]:%d %s", sx->conn_args.host->name,
1187                 sx->conn_args.host->address,
1188                 sx->port == PORT_NONE ? 25 : sx->port, addr->message);
1189             else
1190               log_write(0, LOG_MAIN, "H=%s [%s]: %s", sx->conn_args.host->name,
1191                 sx->conn_args.host->address, addr->message);
1192
1193 #ifndef DISABLE_EVENT
1194           else
1195             msg_event_raise(US"msg:rcpt:defer", addr);
1196 #endif
1197
1198           /* Do not put this message on the list of those waiting for specific
1199           hosts, as otherwise it is likely to be tried too often. */
1200
1201           update_waiting = FALSE;
1202
1203           /* Add a retry item for the address so that it doesn't get tried again
1204           too soon. If address_retry_include_sender is true, add the sender address
1205           to the retry key. */
1206
1207           retry_add_item(addr,
1208             ob->address_retry_include_sender
1209               ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1210               : addr->address_retry_key,
1211             0);
1212           }
1213         }
1214       }
1215     }
1216   }       /* Loop for next RCPT response */
1217
1218 /* Update where to start at for the next block of responses, unless we
1219 have already handled all the addresses. */
1220
1221 if (addr) sx->sync_addr = addr->next;
1222
1223 /* Handle a response to DATA. If we have not had any good recipients, either
1224 previously or in this block, the response is ignored. */
1225
1226 if (pending_DATA != 0)
1227   {
1228   DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1229   if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1230                         '3', ob->command_timeout))
1231     {
1232     int code;
1233     uschar *msg;
1234     BOOL pass_message;
1235
1236     if (errno == ERRNO_TLSFAILURE)      /* Error on first TLS read */
1237       return -5;
1238
1239     if (pending_DATA > 0 || (yield & 1) != 0)
1240       {
1241       if (errno == 0 && sx->buffer[0] == '4')
1242         {
1243         errno = ERRNO_DATA4XX;
1244         sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1245         }
1246       return -3;
1247       }
1248     (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1249     DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1250       "is in use and there were no good recipients\n", msg);
1251     }
1252   }
1253
1254 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1255 present) received 3xx. If any RCPTs were handled and yielded anything other
1256 than 4xx, yield will be set non-zero. */
1257
1258 return yield;
1259 }
1260
1261
1262
1263
1264
1265 /* Try an authenticator's client entry */
1266
1267 static int
1268 try_authenticator(smtp_context * sx, auth_instance * au)
1269 {
1270 smtp_transport_options_block * ob = sx->conn_args.ob;   /* transport options */
1271 host_item * host = sx->conn_args.host;                  /* host to deliver to */
1272 int rc;
1273
1274 sx->outblock.authenticating = TRUE;
1275 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1276                             sx->buffer, sizeof(sx->buffer));
1277 sx->outblock.authenticating = FALSE;
1278 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1279
1280 /* A temporary authentication failure must hold up delivery to
1281 this host. After a permanent authentication failure, we carry on
1282 to try other authentication methods. If all fail hard, try to
1283 deliver the message unauthenticated unless require_auth was set. */
1284
1285 switch(rc)
1286   {
1287   case OK:
1288     f.smtp_authenticated = TRUE;   /* stops the outer loop */
1289     client_authenticator = au->name;
1290     if (au->set_client_id)
1291       client_authenticated_id = expand_string(au->set_client_id);
1292     break;
1293
1294   /* Failure after writing a command */
1295
1296   case FAIL_SEND:
1297     return FAIL_SEND;
1298
1299   /* Failure after reading a response */
1300
1301   case FAIL:
1302     if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1303     log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1304       au->name, host->name, host->address, sx->buffer);
1305     break;
1306
1307   /* Failure by some other means. In effect, the authenticator
1308   decided it wasn't prepared to handle this case. Typically this
1309   is the result of "fail" in an expansion string. Do we need to
1310   log anything here? Feb 2006: a message is now put in the buffer
1311   if logging is required. */
1312
1313   case CANCELLED:
1314     if (*sx->buffer != 0)
1315       log_write(0, LOG_MAIN, "%s authenticator cancelled "
1316         "authentication H=%s [%s] %s", au->name, host->name,
1317         host->address, sx->buffer);
1318     break;
1319
1320   /* Internal problem, message in buffer. */
1321
1322   case ERROR:
1323     set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1324               DEFER, FALSE, &sx->delivery_start);
1325     return ERROR;
1326   }
1327 return OK;
1328 }
1329
1330
1331
1332
1333 /* Do the client side of smtp-level authentication.
1334
1335 Arguments:
1336   sx            smtp connection context
1337
1338 sx->buffer should have the EHLO response from server (gets overwritten)
1339
1340 Returns:
1341   OK                    Success, or failed (but not required): global "smtp_authenticated" set
1342   DEFER                 Failed authentication (and was required)
1343   ERROR                 Internal problem
1344
1345   FAIL_SEND             Failed communications - transmit
1346   FAIL                  - response
1347 */
1348
1349 static int
1350 smtp_auth(smtp_context * sx)
1351 {
1352 host_item * host = sx->conn_args.host;                  /* host to deliver to */
1353 smtp_transport_options_block * ob = sx->conn_args.ob;   /* transport options */
1354 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1355 #ifndef DISABLE_PIPE_CONNECT
1356 unsigned short authbits = tls_out.active.sock >= 0
1357       ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1358 #endif
1359 uschar * fail_reason = US"server did not advertise AUTH support";
1360
1361 f.smtp_authenticated = FALSE;
1362 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1363
1364 if (!regex_AUTH)
1365   regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1366
1367 /* Is the server offering AUTH? */
1368
1369 if (  sx->esmtp
1370    &&
1371 #ifndef DISABLE_PIPE_CONNECT
1372       sx->early_pipe_active ? authbits
1373       :
1374 #endif
1375         regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1376    )
1377   {
1378   uschar * names = NULL;
1379   expand_nmax = -1;                          /* reset */
1380
1381 #ifndef DISABLE_PIPE_CONNECT
1382   if (!sx->early_pipe_active)
1383 #endif
1384     names = string_copyn(expand_nstring[1], expand_nlength[1]);
1385
1386   /* Must not do this check until after we have saved the result of the
1387   regex match above as the check could be another RE. */
1388
1389   if (  require_auth == OK
1390      || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1391     {
1392     DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1393     fail_reason = US"no common mechanisms were found";
1394
1395 #ifndef DISABLE_PIPE_CONNECT
1396     if (sx->early_pipe_active)
1397       {
1398       /* Scan our authenticators (which support use by a client and were offered
1399       by the server (checked at cache-write time)), not suppressed by
1400       client_condition.  If one is found, attempt to authenticate by calling its
1401       client function.  We are limited to supporting up to 16 authenticator
1402       public-names by the number of bits in a short. */
1403
1404       auth_instance * au;
1405       uschar bitnum;
1406       int rc;
1407
1408       for (bitnum = 0, au = auths;
1409            !f.smtp_authenticated && au && bitnum < 16;
1410            bitnum++, au = au->next) if (authbits & BIT(bitnum))
1411         {
1412         if (  au->client_condition
1413            && !expand_check_condition(au->client_condition, au->name,
1414                    US"client authenticator"))
1415           {
1416           DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1417             au->name, "client_condition is false");
1418           continue;
1419           }
1420
1421         /* Found data for a listed mechanism. Call its client entry. Set
1422         a flag in the outblock so that data is overwritten after sending so
1423         that reflections don't show it. */
1424
1425         fail_reason = US"authentication attempt(s) failed";
1426
1427         if ((rc = try_authenticator(sx, au)) != OK)
1428           return rc;
1429         }
1430       }
1431     else
1432 #endif
1433
1434     /* Scan the configured authenticators looking for one which is configured
1435     for use as a client, which is not suppressed by client_condition, and
1436     whose name matches an authentication mechanism supported by the server.
1437     If one is found, attempt to authenticate by calling its client function.
1438     */
1439
1440     for (auth_instance * au = auths; !f.smtp_authenticated && au; au = au->next)
1441       {
1442       uschar *p = names;
1443
1444       if (  !au->client
1445          || (   au->client_condition
1446             &&  !expand_check_condition(au->client_condition, au->name,
1447                    US"client authenticator")))
1448         {
1449         DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1450           au->name,
1451           (au->client)? "client_condition is false" :
1452                         "not configured as a client");
1453         continue;
1454         }
1455
1456       /* Loop to scan supported server mechanisms */
1457
1458       while (*p)
1459         {
1460         int len = Ustrlen(au->public_name);
1461         int rc;
1462
1463         while (isspace(*p)) p++;
1464
1465         if (strncmpic(au->public_name, p, len) != 0 ||
1466             (p[len] != 0 && !isspace(p[len])))
1467           {
1468           while (*p != 0 && !isspace(*p)) p++;
1469           continue;
1470           }
1471
1472         /* Found data for a listed mechanism. Call its client entry. Set
1473         a flag in the outblock so that data is overwritten after sending so
1474         that reflections don't show it. */
1475
1476         fail_reason = US"authentication attempt(s) failed";
1477
1478         if ((rc = try_authenticator(sx, au)) != OK)
1479           return rc;
1480
1481         break;  /* If not authenticated, try next authenticator */
1482         }       /* Loop for scanning supported server mechanisms */
1483       }         /* Loop for further authenticators */
1484     }
1485   }
1486
1487 /* If we haven't authenticated, but are required to, give up. */
1488
1489 if (require_auth == OK && !f.smtp_authenticated)
1490   {
1491   invalidate_ehlo_cache_entry(sx);
1492   set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1493     string_sprintf("authentication required but %s", fail_reason), DEFER,
1494     FALSE, &sx->delivery_start);
1495   return DEFER;
1496   }
1497
1498 return OK;
1499 }
1500
1501
1502 /* Construct AUTH appendix string for MAIL TO */
1503 /*
1504 Arguments
1505   sx            context for smtp connection
1506   p             point in sx->buffer to build string
1507   addrlist      chain of potential addresses to deliver
1508
1509 Globals         f.smtp_authenticated
1510                 client_authenticated_sender
1511 Return  True on error, otherwise buffer has (possibly empty) terminated string
1512 */
1513
1514 static BOOL
1515 smtp_mail_auth_str(smtp_context * sx, uschar * p, address_item * addrlist)
1516 {
1517 smtp_transport_options_block * ob = sx->conn_args.ob;
1518 uschar * local_authenticated_sender = authenticated_sender;
1519
1520 #ifdef notdef
1521   debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n",
1522     authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1523 #endif
1524
1525 if (ob->authenticated_sender)
1526   {
1527   uschar * new = expand_string(ob->authenticated_sender);
1528   if (!new)
1529     {
1530     if (!f.expand_string_forcedfail)
1531       {
1532       uschar *message = string_sprintf("failed to expand "
1533         "authenticated_sender: %s", expand_string_message);
1534       set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
1535       return TRUE;
1536       }
1537     }
1538   else if (*new)
1539     local_authenticated_sender = new;
1540   }
1541
1542 /* Add the authenticated sender address if present */
1543
1544 if (  (f.smtp_authenticated || ob->authenticated_sender_force)
1545    && local_authenticated_sender)
1546   {
1547   string_format_nt(p, sizeof(sx->buffer) - (p-sx->buffer), " AUTH=%s",
1548     auth_xtextencode(local_authenticated_sender,
1549       Ustrlen(local_authenticated_sender)));
1550   client_authenticated_sender = string_copy(local_authenticated_sender);
1551   }
1552 else
1553   *p = 0;
1554
1555 return FALSE;
1556 }
1557
1558
1559
1560 typedef struct smtp_compare_s
1561 {
1562     uschar *                    current_sender_address;
1563     struct transport_instance * tblock;
1564 } smtp_compare_t;
1565
1566
1567 /* Create a unique string that identifies this message, it is based on
1568 sender_address, helo_data and tls_certificate if enabled.
1569 */
1570
1571 static uschar *
1572 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1573 {
1574 address_item * addr1;
1575 uschar * if1 = US"";
1576 uschar * helo1 = US"";
1577 #ifndef DISABLE_TLS
1578 uschar * tlsc1 = US"";
1579 #endif
1580 uschar * save_sender_address = sender_address;
1581 uschar * local_identity = NULL;
1582 smtp_transport_options_block * ob = SOB tblock->options_block;
1583
1584 sender_address = sender;
1585
1586 addr1 = deliver_make_addr (sender, TRUE);
1587 deliver_set_expansions(addr1);
1588
1589 if (ob->interface)
1590   if1 = expand_string(ob->interface);
1591
1592 if (ob->helo_data)
1593   helo1 = expand_string(ob->helo_data);
1594
1595 #ifndef DISABLE_TLS
1596 if (ob->tls_certificate)
1597   tlsc1 = expand_string(ob->tls_certificate);
1598 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1599 #else
1600 local_identity = string_sprintf ("%s^%s", if1, helo1);
1601 #endif
1602
1603 deliver_set_expansions(NULL);
1604 sender_address = save_sender_address;
1605
1606 return local_identity;
1607 }
1608
1609
1610
1611 /* This routine is a callback that is called from transport_check_waiting.
1612 This function will evaluate the incoming message versus the previous
1613 message.  If the incoming message is using a different local identity then
1614 we will veto this new message.  */
1615
1616 static BOOL
1617 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1618 {
1619 uschar * message_local_identity,
1620        * current_local_identity,
1621        * new_sender_address;
1622
1623 current_local_identity =
1624   smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1625
1626 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1627     return FALSE;
1628
1629 message_local_identity =
1630   smtp_local_identity(new_sender_address, s_compare->tblock);
1631
1632 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1633 }
1634
1635
1636
1637 static unsigned
1638 ehlo_response(uschar * buf, unsigned checks)
1639 {
1640 size_t bsize = Ustrlen(buf);
1641
1642 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1643
1644 #ifndef DISABLE_TLS
1645 if (  checks & OPTION_TLS
1646    && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1647 #endif
1648   checks &= ~OPTION_TLS;
1649
1650 if (  checks & OPTION_IGNQ
1651    && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1652                 PCRE_EOPT, NULL, 0) < 0)
1653   checks &= ~OPTION_IGNQ;
1654
1655 if (  checks & OPTION_CHUNKING
1656    && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1657   checks &= ~OPTION_CHUNKING;
1658
1659 #ifndef DISABLE_PRDR
1660 if (  checks & OPTION_PRDR
1661    && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1662 #endif
1663   checks &= ~OPTION_PRDR;
1664
1665 #ifdef SUPPORT_I18N
1666 if (  checks & OPTION_UTF8
1667    && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1668 #endif
1669   checks &= ~OPTION_UTF8;
1670
1671 if (  checks & OPTION_DSN
1672    && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1673   checks &= ~OPTION_DSN;
1674
1675 if (  checks & OPTION_PIPE
1676    && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1677                 PCRE_EOPT, NULL, 0) < 0)
1678   checks &= ~OPTION_PIPE;
1679
1680 if (  checks & OPTION_SIZE
1681    && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1682   checks &= ~OPTION_SIZE;
1683
1684 #ifndef DISABLE_PIPE_CONNECT
1685 if (  checks & OPTION_EARLY_PIPE
1686    && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1687                 PCRE_EOPT, NULL, 0) < 0)
1688 #endif
1689   checks &= ~OPTION_EARLY_PIPE;
1690
1691 /* debug_printf("%s: found     0x%04x\n", __FUNCTION__, checks); */
1692 return checks;
1693 }
1694
1695
1696
1697 /* Callback for emitting a BDAT data chunk header.
1698
1699 If given a nonzero size, first flush any buffered SMTP commands
1700 then emit the command.
1701
1702 Reap previous SMTP command responses if requested, and always reap
1703 the response from a previous BDAT command.
1704
1705 Args:
1706  tctx           transport context
1707  chunk_size     value for SMTP BDAT command
1708  flags
1709    tc_chunk_last        add LAST option to SMTP BDAT command
1710    tc_reap_prev         reap response to previous SMTP commands
1711
1712 Returns:
1713   OK or ERROR
1714   DEFER                 TLS error on first read (EHLO-resp); errno set
1715 */
1716
1717 static int
1718 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1719   unsigned flags)
1720 {
1721 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1722 smtp_context * sx = tctx->smtp_context;
1723 int cmd_count = 0;
1724 int prev_cmd_count;
1725
1726 /* Write SMTP chunk header command.  If not reaping responses, note that
1727 there may be more writes (like, the chunk data) done soon. */
1728
1729 if (chunk_size > 0)
1730   {
1731 #ifndef DISABLE_PIPE_CONNECT
1732   BOOL new_conn = !!(sx->outblock.conn_args);
1733 #endif
1734   if((cmd_count = smtp_write_command(sx,
1735               flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1736               "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1737      ) < 0) return ERROR;
1738   if (flags & tc_chunk_last)
1739     data_command = string_copy(big_buffer);  /* Save for later error message */
1740 #ifndef DISABLE_PIPE_CONNECT
1741   /* That command write could have been the one that made the connection.
1742   Copy the fd from the client conn ctx (smtp transport specific) to the
1743   generic transport ctx. */
1744
1745   if (new_conn)
1746     tctx->u.fd = sx->outblock.cctx->sock;
1747 #endif
1748   }
1749
1750 prev_cmd_count = cmd_count += sx->cmd_count;
1751
1752 /* Reap responses for any previous, but not one we just emitted */
1753
1754 if (chunk_size > 0)
1755   prev_cmd_count--;
1756 if (sx->pending_BDAT)
1757   prev_cmd_count--;
1758
1759 if (flags & tc_reap_prev  &&  prev_cmd_count > 0)
1760   {
1761   DEBUG(D_transport) debug_printf("look for %d responses"
1762     " for previous pipelined cmds\n", prev_cmd_count);
1763
1764   switch(sync_responses(sx, prev_cmd_count, 0))
1765     {
1766     case 1:                             /* 2xx (only) => OK */
1767     case 3: sx->good_RCPT = TRUE;       /* 2xx & 5xx => OK & progress made */
1768     case 2: sx->completed_addr = TRUE;  /* 5xx (only) => progress made */
1769     case 0: break;                      /* No 2xx or 5xx, but no probs */
1770
1771     case -5: errno = ERRNO_TLSFAILURE;
1772              return DEFER;
1773 #ifndef DISABLE_PIPE_CONNECT
1774     case -4:                            /* non-2xx for pipelined banner or EHLO */
1775 #endif
1776     case -1:                            /* Timeout on RCPT */
1777     default: return ERROR;              /* I/O error, or any MAIL/DATA error */
1778     }
1779   cmd_count = 1;
1780   if (!sx->pending_BDAT)
1781     pipelining_active = FALSE;
1782   }
1783
1784 /* Reap response for an outstanding BDAT */
1785
1786 if (sx->pending_BDAT)
1787   {
1788   DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1789
1790   if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1791        ob->command_timeout))
1792     {
1793     if (errno == 0 && sx->buffer[0] == '4')
1794       {
1795       errno = ERRNO_DATA4XX;    /*XXX does this actually get used? */
1796       sx->addrlist->more_errno |=
1797         ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1798       }
1799     return ERROR;
1800     }
1801   cmd_count--;
1802   sx->pending_BDAT = FALSE;
1803   pipelining_active = FALSE;
1804   }
1805 else if (chunk_size > 0)
1806   sx->pending_BDAT = TRUE;
1807
1808
1809 sx->cmd_count = cmd_count;
1810 return OK;
1811 }
1812
1813
1814
1815
1816
1817 /*************************************************
1818 *       Make connection for given message        *
1819 *************************************************/
1820
1821 /*
1822 Arguments:
1823   ctx             connection context
1824   suppress_tls    if TRUE, don't attempt a TLS connection - this is set for
1825                     a second attempt after TLS initialization fails
1826
1827 Returns:          OK    - the connection was made and the delivery attempted;
1828                           fd is set in the conn context, tls_out set up.
1829                   DEFER - the connection could not be made, or something failed
1830                           while setting up the SMTP session, or there was a
1831                           non-message-specific error, such as a timeout.
1832                   ERROR - helo_data or add_headers or authenticated_sender is
1833                           specified for this transport, and the string failed
1834                           to expand
1835 */
1836 int
1837 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1838 {
1839 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1840 BOOL pass_message = FALSE;
1841 uschar * message = NULL;
1842 int yield = OK;
1843 #ifndef DISABLE_TLS
1844 uschar * tls_errstr;
1845 #endif
1846
1847 sx->conn_args.ob = ob;
1848
1849 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1850 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1851 /* sx->ok = FALSE; */
1852 sx->send_rset = TRUE;
1853 sx->send_quit = TRUE;
1854 sx->setting_up = TRUE;
1855 sx->esmtp = TRUE;
1856 /* sx->esmtp_sent = FALSE; */
1857 #ifdef SUPPORT_I18N
1858 /* sx->utf8_needed = FALSE; */
1859 #endif
1860 sx->dsn_all_lasthop = TRUE;
1861 #ifdef SUPPORT_DANE
1862 /* sx->conn_args.dane = FALSE; */
1863 sx->dane_required =
1864   verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1865 #endif
1866 #ifndef DISABLE_PIPE_CONNECT
1867 /* sx->early_pipe_active = sx->early_pipe_ok = FALSE; */
1868 /* sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0; */
1869 /* sx->pending_BANNER = sx->pending_EHLO = sx->pending_MAIL = FALSE; */
1870 #endif
1871
1872 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1873 /* sx->peer_offered = 0; */
1874 /* sx->avoid_option = 0; */
1875 sx->igquotstr = US"";
1876 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1877 #ifdef EXPERIMENTAL_DSN_INFO
1878 /* sx->smtp_greeting = NULL; */
1879 /* sx->helo_response = NULL; */
1880 #endif
1881
1882 smtp_command = US"initial connection";
1883 /* sx->buffer[0] = '\0'; */
1884
1885 /* Set up the buffer for reading SMTP response packets. */
1886
1887 sx->inblock.buffer = sx->inbuffer;
1888 sx->inblock.buffersize = sizeof(sx->inbuffer);
1889 sx->inblock.ptr = sx->inbuffer;
1890 sx->inblock.ptrend = sx->inbuffer;
1891
1892 /* Set up the buffer for holding SMTP commands while pipelining */
1893
1894 sx->outblock.buffer = sx->outbuffer;
1895 sx->outblock.buffersize = sizeof(sx->outbuffer);
1896 sx->outblock.ptr = sx->outbuffer;
1897 /* sx->outblock.cmd_count = 0; */
1898 /* sx->outblock.authenticating = FALSE; */
1899 /* sx->outblock.conn_args = NULL; */
1900
1901 /* Reset the parameters of a TLS session. */
1902
1903 tls_out.bits = 0;
1904 tls_out.cipher = NULL;  /* the one we may use for this transport */
1905 tls_out.ourcert = NULL;
1906 tls_out.peercert = NULL;
1907 tls_out.peerdn = NULL;
1908 #ifdef USE_OPENSSL
1909 tls_out.sni = NULL;
1910 #endif
1911 tls_out.ocsp = OCSP_NOT_REQ;
1912 #ifndef DISABLE_TLS_RESUME
1913 tls_out.resumption = 0;
1914 #endif
1915 tls_out.ver = NULL;
1916
1917 /* Flip the legacy TLS-related variables over to the outbound set in case
1918 they're used in the context of the transport.  Don't bother resetting
1919 afterward (when being used by a transport) as we're in a subprocess.
1920 For verify, unflipped once the callout is dealt with */
1921
1922 tls_modify_variables(&tls_out);
1923
1924 #ifdef DISABLE_TLS
1925 if (sx->smtps)
1926   {
1927   set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
1928             DEFER, FALSE, &sx->delivery_start);
1929   return ERROR;
1930   }
1931 #else
1932
1933 /* If we have a proxied TLS connection, check usability for this message */
1934
1935 if (continue_hostname && continue_proxy_cipher)
1936   {
1937   int rc;
1938   const uschar * sni = US"";
1939
1940 # ifdef SUPPORT_DANE
1941   /* Check if the message will be DANE-verified; if so force its SNI */
1942
1943   tls_out.dane_verified = FALSE;
1944   smtp_port_for_connect(sx->conn_args.host, sx->port);
1945   if (  sx->conn_args.host->dnssec == DS_YES
1946      && (  sx->dane_required
1947         || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
1948      )  )
1949     switch (rc = tlsa_lookup(sx->conn_args.host, &sx->conn_args.tlsa_dnsa, sx->dane_required))
1950       {
1951       case OK:          sx->conn_args.dane = TRUE;
1952                         ob->tls_tempfail_tryclear = FALSE;      /* force TLS */
1953                         ob->tls_sni = sx->first_addr->domain;   /* force SNI */
1954                         break;
1955       case FAIL_FORCED: break;
1956       default:          set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
1957                               string_sprintf("DANE error: tlsa lookup %s",
1958                                 rc_to_string(rc)),
1959                               rc, FALSE, &sx->delivery_start);
1960 #  ifndef DISABLE_EVENT
1961                             (void) event_raise(sx->conn_args.tblock->event_action,
1962                               US"dane:fail", sx->dane_required
1963                                 ?  US"dane-required" : US"dnssec-invalid");
1964 #  endif
1965                             return rc;
1966       }
1967 # endif
1968
1969   /* If the SNI or the DANE status required for the new message differs from the
1970   existing conn drop the connection to force a new one. */
1971
1972   if (ob->tls_sni && !(sni = expand_cstring(ob->tls_sni)))
1973     log_write(0, LOG_MAIN|LOG_PANIC,
1974       "<%s>: failed to expand transport's tls_sni value: %s",
1975       sx->addrlist->address, expand_string_message);
1976
1977 # ifdef SUPPORT_DANE
1978   if (  (continue_proxy_sni ? (Ustrcmp(continue_proxy_sni, sni) == 0) : !*sni)
1979      && continue_proxy_dane == sx->conn_args.dane)
1980     {
1981     tls_out.sni = US sni;
1982     if ((tls_out.dane_verified = continue_proxy_dane))
1983       sx->conn_args.host->dnssec = DS_YES;
1984     }
1985 # else
1986   if ((continue_proxy_sni ? (Ustrcmp(continue_proxy_sni, sni) == 0) : !*sni))
1987     tls_out.sni = US sni;
1988 # endif
1989   else
1990     {
1991     DEBUG(D_transport)
1992       debug_printf("Closing proxied-TLS connection due to SNI mismatch\n");
1993
1994     HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> QUIT\n");
1995     write(0, "QUIT\r\n", 6);
1996     close(0);
1997     continue_hostname = continue_proxy_cipher = NULL;
1998     f.continue_more = FALSE;
1999     continue_sequence = 1;      /* Unfortunately, this process cannot affect success log
2000                                 which is done by delivery proc.  Would have to pass this
2001                                 back through reporting pipe. */
2002     }
2003   }
2004 #endif  /*!DISABLE_TLS*/
2005
2006 /* Make a connection to the host if this isn't a continued delivery, and handle
2007 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2008 specially so they can be identified for retries. */
2009
2010 if (!continue_hostname)
2011   {
2012   if (sx->verify)
2013     HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2014
2015   /* Get the actual port the connection will use, into sx->conn_args.host */
2016
2017   smtp_port_for_connect(sx->conn_args.host, sx->port);
2018
2019 #ifdef SUPPORT_DANE
2020     /* Do TLSA lookup for DANE */
2021     {
2022     tls_out.dane_verified = FALSE;
2023     tls_out.tlsa_usage = 0;
2024
2025     if (sx->conn_args.host->dnssec == DS_YES)
2026       {
2027       int rc;
2028       if(  sx->dane_required
2029         || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2030         )
2031         switch (rc = tlsa_lookup(sx->conn_args.host, &sx->conn_args.tlsa_dnsa, sx->dane_required))
2032           {
2033           case OK:              sx->conn_args.dane = TRUE;
2034                                 ob->tls_tempfail_tryclear = FALSE;      /* force TLS */
2035                                 ob->tls_sni = sx->first_addr->domain;   /* force SNI */
2036                                 break;
2037           case FAIL_FORCED:     break;
2038           default:              set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2039                                   string_sprintf("DANE error: tlsa lookup %s",
2040                                     rc_to_string(rc)),
2041                                   rc, FALSE, &sx->delivery_start);
2042 # ifndef DISABLE_EVENT
2043                                 (void) event_raise(sx->conn_args.tblock->event_action,
2044                                   US"dane:fail", sx->dane_required
2045                                     ?  US"dane-required" : US"dnssec-invalid");
2046 # endif
2047                                 return rc;
2048           }
2049       }
2050     else if (sx->dane_required)
2051       {
2052       set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2053         string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2054         FAIL, FALSE, &sx->delivery_start);
2055 # ifndef DISABLE_EVENT
2056       (void) event_raise(sx->conn_args.tblock->event_action,
2057         US"dane:fail", US"dane-required");
2058 # endif
2059       return FAIL;
2060       }
2061     }
2062 #endif  /*DANE*/
2063
2064   /* Make the TCP connection */
2065
2066   sx->cctx.tls_ctx = NULL;
2067   sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2068   sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2069
2070 #ifndef DISABLE_PIPE_CONNECT
2071   if (  verify_check_given_host(CUSS &ob->hosts_pipe_connect,
2072                                             sx->conn_args.host) == OK)
2073
2074     /* We don't find out the local ip address until the connect, so if
2075     the helo string might use it avoid doing early-pipelining. */
2076
2077     if (  !sx->helo_data
2078        || !Ustrstr(sx->helo_data, "$sending_ip_address")
2079        || Ustrstr(sx->helo_data, "def:sending_ip_address")
2080        )
2081       {
2082       sx->early_pipe_ok = TRUE;
2083       if (  read_ehlo_cache_entry(sx)
2084          && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2085         {
2086         DEBUG(D_transport)
2087           debug_printf("Using cached cleartext PIPE_CONNECT\n");
2088         sx->early_pipe_active = TRUE;
2089         sx->peer_offered = sx->ehlo_resp.cleartext_features;
2090         }
2091       }
2092     else DEBUG(D_transport)
2093       debug_printf("helo needs $sending_ip_address\n");
2094
2095 PIPE_CONNECT_RETRY:
2096   if (sx->early_pipe_active)
2097     sx->outblock.conn_args = &sx->conn_args;
2098   else
2099 #endif
2100     {
2101     blob lazy_conn = {.data = NULL};
2102     /* For TLS-connect, a TFO lazy-connect is useful since the Client Hello
2103     can go on the TCP SYN. */
2104
2105     if ((sx->cctx.sock = smtp_connect(&sx->conn_args,
2106                             sx->smtps ? &lazy_conn : NULL)) < 0)
2107       {
2108       set_errno_nohost(sx->addrlist,
2109         errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2110         sx->verify ? US strerror(errno) : NULL,
2111         DEFER, FALSE, &sx->delivery_start);
2112       sx->send_quit = FALSE;
2113       return DEFER;
2114       }
2115 #ifdef TCP_QUICKACK
2116     (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2117                         sizeof(off));
2118 #endif
2119     }
2120   /* Expand the greeting message while waiting for the initial response. (Makes
2121   sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2122   delayed till here so that $sending_interface and $sending_port are set. */
2123 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2124 will be?  Somehow I doubt it. */
2125
2126   if (sx->helo_data)
2127     if (!(sx->helo_data = expand_string(sx->helo_data)))
2128       if (sx->verify)
2129         log_write(0, LOG_MAIN|LOG_PANIC,
2130           "<%s>: failed to expand transport's helo_data value for callout: %s",
2131           sx->addrlist->address, expand_string_message);
2132
2133 #ifdef SUPPORT_I18N
2134   if (sx->helo_data)
2135     {
2136     expand_string_message = NULL;
2137     if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2138                                               &expand_string_message)),
2139         expand_string_message)
2140       if (sx->verify)
2141         log_write(0, LOG_MAIN|LOG_PANIC,
2142           "<%s>: failed to expand transport's helo_data value for callout: %s",
2143           sx->addrlist->address, expand_string_message);
2144       else
2145         sx->helo_data = NULL;
2146     }
2147 #endif
2148
2149   /* The first thing is to wait for an initial OK response. The dreaded "goto"
2150   is nevertheless a reasonably clean way of programming this kind of logic,
2151   where you want to escape on any error. */
2152
2153   if (!sx->smtps)
2154     {
2155 #ifndef DISABLE_PIPE_CONNECT
2156     if (sx->early_pipe_active)
2157       {
2158       sx->pending_BANNER = TRUE;        /* sync_responses() must eventually handle */
2159       sx->outblock.cmd_count = 1;
2160       }
2161     else
2162 #endif
2163       {
2164       if (!smtp_reap_banner(sx))
2165         goto RESPONSE_FAILED;
2166       }
2167
2168 #ifndef DISABLE_EVENT
2169       {
2170       uschar * s;
2171       lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2172         : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2173       s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2174       if (s)
2175         {
2176         set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2177           string_sprintf("deferred by smtp:connect event expansion: %s", s),
2178           DEFER, FALSE, &sx->delivery_start);
2179         yield = DEFER;
2180         goto SEND_QUIT;
2181         }
2182       }
2183 #endif
2184
2185     /* Now check if the helo_data expansion went well, and sign off cleanly if
2186     it didn't. */
2187
2188     if (!sx->helo_data)
2189       {
2190       message = string_sprintf("failed to expand helo_data: %s",
2191         expand_string_message);
2192       set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
2193       yield = DEFER;
2194       goto SEND_QUIT;
2195       }
2196     }
2197
2198 /** Debugging without sending a message
2199 sx->addrlist->transport_return = DEFER;
2200 goto SEND_QUIT;
2201 **/
2202
2203   /* Errors that occur after this point follow an SMTP command, which is
2204   left in big_buffer by smtp_write_command() for use in error messages. */
2205
2206   smtp_command = big_buffer;
2207
2208   /* Tell the remote who we are...
2209
2210   February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2211   string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2212   greeting is of this form. The assumption was that the far end supports it
2213   properly... but experience shows that there are some that give 5xx responses,
2214   even though the banner includes "ESMTP" (there's a bloody-minded one that
2215   says "ESMTP not spoken here"). Cope with that case.
2216
2217   September 2000: Time has passed, and it seems reasonable now to always send
2218   EHLO at the start. It is also convenient to make the change while installing
2219   the TLS stuff.
2220
2221   July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2222   but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2223   would be no way to send out the mails, so there is now a host list
2224   "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2225   PIPELINING problem as well. Maybe it can also be useful to cure other
2226   problems with broken servers.
2227
2228   Exim originally sent "Helo" at this point and ran for nearly a year that way.
2229   Then somebody tried it with a Microsoft mailer... It seems that all other
2230   mailers use upper case for some reason (the RFC is quite clear about case
2231   independence) so, for peace of mind, I gave in. */
2232
2233   sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2234
2235   /* Alas; be careful, since this goto is not an error-out, so conceivably
2236   we might set data between here and the target which we assume to exist
2237   and be usable.  I can see this coming back to bite us. */
2238 #ifndef DISABLE_TLS
2239   if (sx->smtps)
2240     {
2241     smtp_peer_options |= OPTION_TLS;
2242     suppress_tls = FALSE;
2243     ob->tls_tempfail_tryclear = FALSE;
2244     smtp_command = US"SSL-on-connect";
2245     goto TLS_NEGOTIATE;
2246     }
2247 #endif
2248
2249   if (sx->esmtp)
2250     {
2251     if (smtp_write_command(sx,
2252 #ifndef DISABLE_PIPE_CONNECT
2253           sx->early_pipe_active ? SCMD_BUFFER :
2254 #endif
2255             SCMD_FLUSH,
2256           "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2257       goto SEND_FAILED;
2258     sx->esmtp_sent = TRUE;
2259
2260 #ifndef DISABLE_PIPE_CONNECT
2261     if (sx->early_pipe_active)
2262       {
2263       sx->pending_EHLO = TRUE;
2264
2265       /* If we have too many authenticators to handle and might need to AUTH
2266       for this transport, pipeline no further as we will need the
2267       list of auth methods offered.  Reap the banner and EHLO. */
2268
2269       if (  (ob->hosts_require_auth || ob->hosts_try_auth)
2270          && f.smtp_in_early_pipe_no_auth)
2271         {
2272         DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2273         if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2274           goto SEND_FAILED;
2275         if (sync_responses(sx, 2, 0) != 0)
2276           {
2277           HDEBUG(D_transport)
2278             debug_printf("failed reaping pipelined cmd responses\n");
2279           goto RESPONSE_FAILED;
2280           }
2281         sx->early_pipe_active = FALSE;
2282         }
2283       }
2284     else
2285 #endif
2286       if (!smtp_reap_ehlo(sx))
2287         goto RESPONSE_FAILED;
2288     }
2289   else
2290     DEBUG(D_transport)
2291       debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2292
2293 #ifndef DISABLE_PIPE_CONNECT
2294   if (!sx->early_pipe_active)
2295 #endif
2296     if (!sx->esmtp)
2297       {
2298       BOOL good_response;
2299       int n = sizeof(sx->buffer);
2300       uschar * rsp = sx->buffer;
2301
2302       if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2303         { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2304
2305       if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2306         goto SEND_FAILED;
2307       good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2308 #ifdef EXPERIMENTAL_DSN_INFO
2309       sx->helo_response = string_copy(rsp);
2310 #endif
2311       if (!good_response)
2312         {
2313         /* Handle special logging for a closed connection after HELO
2314         when had previously sent EHLO */
2315
2316         if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2317           {
2318           errno = ERRNO_SMTPCLOSED;
2319           goto EHLOHELO_FAILED;
2320           }
2321         memmove(sx->buffer, rsp, Ustrlen(rsp));
2322         goto RESPONSE_FAILED;
2323         }
2324       }
2325
2326   if (sx->esmtp || sx->lmtp)
2327     {
2328 #ifndef DISABLE_PIPE_CONNECT
2329     if (!sx->early_pipe_active)
2330 #endif
2331       {
2332       sx->peer_offered = ehlo_response(sx->buffer,
2333         OPTION_TLS      /* others checked later */
2334 #ifndef DISABLE_PIPE_CONNECT
2335         | (sx->early_pipe_ok
2336           ?   OPTION_IGNQ
2337             | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2338 #ifdef SUPPORT_I18N
2339             | OPTION_UTF8
2340 #endif
2341             | OPTION_EARLY_PIPE
2342           : 0
2343           )
2344 #endif
2345         );
2346 #ifndef DISABLE_PIPE_CONNECT
2347       if (sx->early_pipe_ok)
2348         {
2349         sx->ehlo_resp.cleartext_features = sx->peer_offered;
2350
2351         if (  (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2352            == (OPTION_PIPE | OPTION_EARLY_PIPE))
2353           {
2354           DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2355           sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2356           write_ehlo_cache_entry(sx);
2357           }
2358         }
2359 #endif
2360       }
2361
2362   /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2363
2364 #ifndef DISABLE_TLS
2365     smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2366 #endif
2367     }
2368   }
2369
2370 /* For continuing deliveries down the same channel, having re-exec'd  the socket
2371 is the standard input; for a socket held open from verify it is recorded
2372 in the cutthrough context block.  Either way we don't need to redo EHLO here
2373 (but may need to do so for TLS - see below).
2374 Set up the pointer to where subsequent commands will be left, for
2375 error messages. Note that smtp_peer_options will have been
2376 set from the command line if they were set in the process that passed the
2377 connection on. */
2378
2379 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2380 as the continue goes via transport_pass_socket() and doublefork and exec.
2381 It does not wait.  Unclear how we keep separate host's responses
2382 separate - we could match up by host ip+port as a bodge. */
2383
2384 else
2385   {
2386   if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2387     {
2388     sx->cctx = cutthrough.cctx;
2389     sx->conn_args.host->port = sx->port = cutthrough.host.port;
2390     }
2391   else
2392     {
2393     sx->cctx.sock = 0;                          /* stdin */
2394     sx->cctx.tls_ctx = NULL;
2395     smtp_port_for_connect(sx->conn_args.host, sx->port);        /* Record the port that was used */
2396     }
2397   sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2398   smtp_command = big_buffer;
2399   sx->peer_offered = smtp_peer_options;
2400   sx->helo_data = NULL;         /* ensure we re-expand ob->helo_data */
2401
2402   /* For a continued connection with TLS being proxied for us, or a
2403   held-open verify connection with TLS, nothing more to do. */
2404
2405   if (  continue_proxy_cipher
2406      || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2407          && cutthrough.is_tls)
2408      )
2409     {
2410     sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2411     HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2412       continue_proxy_cipher ? "proxied" : "verify conn with");
2413     return OK;
2414     }
2415   HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2416   }
2417
2418 /* If TLS is available on this connection, whether continued or not, attempt to
2419 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2420 send another EHLO - the server may give a different answer in secure mode. We
2421 use a separate buffer for reading the response to STARTTLS so that if it is
2422 negative, the original EHLO data is available for subsequent analysis, should
2423 the client not be required to use TLS. If the response is bad, copy the buffer
2424 for error analysis. */
2425
2426 #ifndef DISABLE_TLS
2427 if (  smtp_peer_options & OPTION_TLS
2428    && !suppress_tls
2429    && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2430    && (  !sx->verify
2431       || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2432    )  )
2433   {
2434   uschar buffer2[4096];
2435
2436   if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2437     goto SEND_FAILED;
2438
2439 #ifndef DISABLE_PIPE_CONNECT
2440   /* If doing early-pipelining reap the banner and EHLO-response but leave
2441   the response for the STARTTLS we just sent alone. */
2442
2443   if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2444     {
2445     HDEBUG(D_transport)
2446       debug_printf("failed reaping pipelined cmd responses\n");
2447     close(sx->cctx.sock);
2448     sx->cctx.sock = -1;
2449     sx->early_pipe_active = FALSE;
2450     goto PIPE_CONNECT_RETRY;
2451     }
2452 #endif
2453
2454   /* If there is an I/O error, transmission of this message is deferred. If
2455   there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2456   false, we also defer. However, if there is a temporary rejection of STARTTLS
2457   and tls_tempfail_tryclear is true, or if there is an outright rejection of
2458   STARTTLS, we carry on. This means we will try to send the message in clear,
2459   unless the host is in hosts_require_tls (tested below). */
2460
2461   if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2462     {
2463     if (  errno != 0
2464        || buffer2[0] == 0
2465        || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2466        )
2467       {
2468       Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2469       sx->buffer[sizeof(sx->buffer)-1] = '\0';
2470       goto RESPONSE_FAILED;
2471       }
2472     }
2473
2474   /* STARTTLS accepted: try to negotiate a TLS session. */
2475
2476   else
2477   TLS_NEGOTIATE:
2478     {
2479     if (!tls_client_start(&sx->cctx, &sx->conn_args, sx->addrlist, &tls_out, &tls_errstr))
2480       {
2481       /* TLS negotiation failed; give an error. From outside, this function may
2482       be called again to try in clear on a new connection, if the options permit
2483       it for this host. */
2484   TLS_CONN_FAILED:
2485       DEBUG(D_tls) debug_printf("TLS session fail: %s\n", tls_errstr);
2486
2487 # ifdef SUPPORT_DANE
2488       if (sx->conn_args.dane)
2489         {
2490         log_write(0, LOG_MAIN,
2491           "DANE attempt failed; TLS connection to %s [%s]: %s",
2492           sx->conn_args.host->name, sx->conn_args.host->address, tls_errstr);
2493 #  ifndef DISABLE_EVENT
2494         (void) event_raise(sx->conn_args.tblock->event_action,
2495           US"dane:fail", US"validation-failure");       /* could do with better detail */
2496 #  endif
2497         }
2498 # endif
2499
2500       errno = ERRNO_TLSFAILURE;
2501       message = string_sprintf("TLS session: %s", tls_errstr);
2502       sx->send_quit = FALSE;
2503       goto TLS_FAILED;
2504       }
2505
2506     /* TLS session is set up.  Check the inblock fill level.  If there is
2507     content then as we have not yet done a tls read it must have arrived before
2508     the TLS handshake, in-clear.  That violates the sync requirement of the
2509     STARTTLS RFC, so fail. */
2510
2511     if (sx->inblock.ptr != sx->inblock.ptrend)
2512       {
2513       DEBUG(D_tls)
2514         {
2515         int i = sx->inblock.ptrend - sx->inblock.ptr;
2516         debug_printf("unused data in input buffer after ack for STARTTLS:\n"
2517           "'%.*s'%s\n",
2518           i > 100 ? 100 : i, sx->inblock.ptr, i > 100 ? "..." : "");
2519         }
2520       tls_errstr = US"synch error before connect";
2521       goto TLS_CONN_FAILED;
2522       }
2523
2524     smtp_peer_options_wrap = smtp_peer_options;
2525     for (address_item * addr = sx->addrlist; addr; addr = addr->next)
2526       if (addr->transport_return == PENDING_DEFER)
2527         {
2528         addr->cipher = tls_out.cipher;
2529         addr->ourcert = tls_out.ourcert;
2530         addr->peercert = tls_out.peercert;
2531         addr->peerdn = tls_out.peerdn;
2532         addr->ocsp = tls_out.ocsp;
2533         addr->tlsver = tls_out.ver;
2534         }
2535     }
2536   }
2537
2538 /* if smtps, we'll have smtp_command set to something else; always safe to
2539 reset it here. */
2540 smtp_command = big_buffer;
2541
2542 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2543 helo_data is null, we are dealing with a connection that was passed from
2544 another process, and so we won't have expanded helo_data above. We have to
2545 expand it here. $sending_ip_address and $sending_port are set up right at the
2546 start of the Exim process (in exim.c). */
2547
2548 if (tls_out.active.sock >= 0)
2549   {
2550   uschar * greeting_cmd;
2551
2552   if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2553     {
2554     uschar *message = string_sprintf("failed to expand helo_data: %s",
2555       expand_string_message);
2556     set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
2557     yield = DEFER;
2558     goto SEND_QUIT;
2559     }
2560
2561 #ifndef DISABLE_PIPE_CONNECT
2562   /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2563   We're unlikely to get the group sent and delivered before the server sends its
2564   banner, but it's still worth sending as a group.
2565   For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2566   the reverse.  */
2567
2568   if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2569     {
2570     sx->peer_offered = sx->ehlo_resp.crypted_features;
2571     if ((sx->early_pipe_active =
2572          !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2573       DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2574     }
2575 #endif
2576
2577   /* For SMTPS we need to wait for the initial OK response. */
2578   if (sx->smtps)
2579 #ifndef DISABLE_PIPE_CONNECT
2580     if (sx->early_pipe_active)
2581       {
2582       sx->pending_BANNER = TRUE;
2583       sx->outblock.cmd_count = 1;
2584       }
2585     else
2586 #endif
2587       if (!smtp_reap_banner(sx))
2588         goto RESPONSE_FAILED;
2589
2590   if (sx->lmtp)
2591     greeting_cmd = US"LHLO";
2592   else if (sx->esmtp)
2593     greeting_cmd = US"EHLO";
2594   else
2595     {
2596     greeting_cmd = US"HELO";
2597     DEBUG(D_transport)
2598       debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2599     }
2600
2601   if (smtp_write_command(sx,
2602 #ifndef DISABLE_PIPE_CONNECT
2603         sx->early_pipe_active ? SCMD_BUFFER :
2604 #endif
2605           SCMD_FLUSH,
2606         "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2607     goto SEND_FAILED;
2608
2609 #ifndef DISABLE_PIPE_CONNECT
2610   if (sx->early_pipe_active)
2611     sx->pending_EHLO = TRUE;
2612   else
2613 #endif
2614     {
2615     if (!smtp_reap_ehlo(sx))
2616 #ifdef USE_GNUTLS
2617       {
2618       /* The GnuTLS layer in Exim only spots a server-rejection of a client
2619       cert late, under TLS1.3 - which means here; the first time we try to
2620       receive crypted data.  Treat it as if it was a connect-time failure.
2621       See also the early-pipe equivalent... which will be hard; every call
2622       to sync_responses will need to check the result.
2623       It would be nicer to have GnuTLS check the cert during the handshake.
2624       Can it do that, with all the flexibility we need? */
2625
2626       tls_errstr = US"error on first read";
2627       goto TLS_CONN_FAILED;
2628       }
2629 #else
2630       goto RESPONSE_FAILED;
2631 #endif
2632     smtp_peer_options = 0;
2633     }
2634   }
2635
2636 /* If the host is required to use a secure channel, ensure that we
2637 have one. */
2638
2639 else if (  sx->smtps
2640 # ifdef SUPPORT_DANE
2641         || sx->conn_args.dane
2642 # endif
2643         || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2644         )
2645   {
2646   errno = ERRNO_TLSREQUIRED;
2647   message = string_sprintf("a TLS session is required, but %s",
2648     smtp_peer_options & OPTION_TLS
2649     ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2650 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2651   if (sx->conn_args.dane)
2652     (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2653       smtp_peer_options & OPTION_TLS
2654       ? US"validation-failure"          /* could do with better detail */
2655       : US"starttls-not-supported");
2656 # endif
2657   goto TLS_FAILED;
2658   }
2659 #endif  /*DISABLE_TLS*/
2660
2661 /* If TLS is active, we have just started it up and re-done the EHLO command,
2662 so its response needs to be analyzed. If TLS is not active and this is a
2663 continued session down a previously-used socket, we haven't just done EHLO, so
2664 we skip this. */
2665
2666 if (continue_hostname == NULL
2667 #ifndef DISABLE_TLS
2668     || tls_out.active.sock >= 0
2669 #endif
2670     )
2671   {
2672   if (sx->esmtp || sx->lmtp)
2673     {
2674 #ifndef DISABLE_PIPE_CONNECT
2675   if (!sx->early_pipe_active)
2676 #endif
2677     {
2678     sx->peer_offered = ehlo_response(sx->buffer,
2679         0 /* no TLS */
2680 #ifndef DISABLE_PIPE_CONNECT
2681         | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2682         | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2683         | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8
2684         | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2685
2686 #else
2687
2688         | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2689         | OPTION_CHUNKING
2690         | OPTION_PRDR
2691 # ifdef SUPPORT_I18N
2692         | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2693           /*XXX if we hand peercaps on to continued-conn processes,
2694                 must not depend on this addr */
2695 # endif
2696         | OPTION_DSN
2697         | OPTION_PIPE
2698         | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2699 #endif
2700       );
2701 #ifndef DISABLE_PIPE_CONNECT
2702     if (tls_out.active.sock >= 0)
2703       sx->ehlo_resp.crypted_features = sx->peer_offered;
2704 #endif
2705     }
2706
2707     /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2708     lmtp_ignore_quota option was set. */
2709
2710     sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2711
2712     /* If the response to EHLO specified support for the SIZE parameter, note
2713     this, provided size_addition is non-negative. */
2714
2715     smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2716
2717     /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2718     the current host, esmtp will be false, so PIPELINING can never be used. If
2719     the current host matches hosts_avoid_pipelining, don't do it. */
2720
2721     if (  sx->peer_offered & OPTION_PIPE
2722        && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2723       smtp_peer_options |= OPTION_PIPE;
2724
2725     DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2726       smtp_peer_options & OPTION_PIPE ? "" : "not ");
2727
2728     if (  sx->peer_offered & OPTION_CHUNKING
2729        && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2730       sx->peer_offered &= ~OPTION_CHUNKING;
2731
2732     if (sx->peer_offered & OPTION_CHUNKING)
2733       DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2734
2735 #ifndef DISABLE_PRDR
2736     if (  sx->peer_offered & OPTION_PRDR
2737        && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2738       sx->peer_offered &= ~OPTION_PRDR;
2739
2740     if (sx->peer_offered & OPTION_PRDR)
2741       DEBUG(D_transport) debug_printf("PRDR usable\n");
2742 #endif
2743
2744     /* Note if the server supports DSN */
2745     smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2746     DEBUG(D_transport) debug_printf("%susing DSN\n",
2747                         sx->peer_offered & OPTION_DSN ? "" : "not ");
2748
2749 #ifndef DISABLE_PIPE_CONNECT
2750     if (  sx->early_pipe_ok
2751        && !sx->early_pipe_active
2752        && tls_out.active.sock >= 0
2753        && smtp_peer_options & OPTION_PIPE
2754        && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2755           & OPTION_EARLY_PIPE)
2756       {
2757       DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2758       sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2759       write_ehlo_cache_entry(sx);
2760       }
2761 #endif
2762
2763     /* Note if the response to EHLO specifies support for the AUTH extension.
2764     If it has, check that this host is one we want to authenticate to, and do
2765     the business. The host name and address must be available when the
2766     authenticator's client driver is running. */
2767
2768     switch (yield = smtp_auth(sx))
2769       {
2770       default:          goto SEND_QUIT;
2771       case OK:          break;
2772       case FAIL_SEND:   goto SEND_FAILED;
2773       case FAIL:        goto RESPONSE_FAILED;
2774       }
2775     }
2776   }
2777 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2778
2779 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2780 message-specific. */
2781
2782 sx->setting_up = FALSE;
2783
2784 #ifdef SUPPORT_I18N
2785 if (sx->addrlist->prop.utf8_msg)
2786   {
2787   uschar * s;
2788
2789   /* If the transport sets a downconversion mode it overrides any set by ACL
2790   for the message. */
2791
2792   if ((s = ob->utf8_downconvert))
2793     {
2794     if (!(s = expand_string(s)))
2795       {
2796       message = string_sprintf("failed to expand utf8_downconvert: %s",
2797         expand_string_message);
2798       set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE, &sx->delivery_start);
2799       yield = DEFER;
2800       goto SEND_QUIT;
2801       }
2802     switch (*s)
2803       {
2804       case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2805                 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2806                 break;
2807       case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2808                 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2809                 break;
2810       case '-': if (s[1] == '1')
2811                   {
2812                   sx->addrlist->prop.utf8_downcvt = FALSE;
2813                   sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2814                   }
2815                 break;
2816       }
2817     }
2818
2819   sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2820                     && !sx->addrlist->prop.utf8_downcvt_maybe;
2821   DEBUG(D_transport) if (!sx->utf8_needed)
2822     debug_printf("utf8: %s downconvert\n",
2823       sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2824   }
2825
2826 /* If this is an international message we need the host to speak SMTPUTF8 */
2827 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2828   {
2829   errno = ERRNO_UTF8_FWD;
2830   goto RESPONSE_FAILED;
2831   }
2832 #endif  /*SUPPORT_I18N*/
2833
2834 return OK;
2835
2836
2837   {
2838   int code;
2839
2840   RESPONSE_FAILED:
2841     if (errno == ECONNREFUSED)  /* first-read error on a TFO conn */
2842       {
2843       /* There is a testing facility for simulating a connection timeout, as I
2844       can't think of any other way of doing this. It converts a connection
2845       refused into a timeout if the timeout is set to 999999.  This is done for
2846       a 3whs connection in ip_connect(), but a TFO connection does not error
2847       there - instead it gets ECONNREFUSED on the first data read.  Tracking
2848       that a TFO really was done is too hard, or we would set a
2849       sx->pending_conn_done bit and test that in smtp_reap_banner() and
2850       smtp_reap_ehlo().  That would let us also add the conn-timeout to the
2851       cmd-timeout. */
2852
2853       if (f.running_in_test_harness && ob->connect_timeout == 999999)
2854         errno = ETIMEDOUT;
2855       set_errno_nohost(sx->addrlist,
2856         errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2857         sx->verify ? US strerror(errno) : NULL,
2858         DEFER, FALSE, &sx->delivery_start);
2859       sx->send_quit = FALSE;
2860       return DEFER;
2861       }
2862
2863     /* really an error on an SMTP read */
2864     message = NULL;
2865     sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2866       sx->buffer, &code, &message, &pass_message);
2867     yield = DEFER;
2868     goto FAILED;
2869
2870   SEND_FAILED:
2871     code = '4';
2872     message = US string_sprintf("send() to %s [%s] failed: %s",
2873       sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2874     sx->send_quit = FALSE;
2875     yield = DEFER;
2876     goto FAILED;
2877
2878   EHLOHELO_FAILED:
2879     code = '4';
2880     message = string_sprintf("Remote host closed connection in response to %s"
2881       " (EHLO response was: %s)", smtp_command, sx->buffer);
2882     sx->send_quit = FALSE;
2883     yield = DEFER;
2884     goto FAILED;
2885
2886   /* This label is jumped to directly when a TLS negotiation has failed,
2887   or was not done for a host for which it is required. Values will be set
2888   in message and errno, and setting_up will always be true. Treat as
2889   a temporary error. */
2890
2891 #ifndef DISABLE_TLS
2892   TLS_FAILED:
2893     code = '4', yield = DEFER;
2894     goto FAILED;
2895 #endif
2896
2897   /* The failure happened while setting up the call; see if the failure was
2898   a 5xx response (this will either be on connection, or following HELO - a 5xx
2899   after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2900   fail all addresses, as this host is never going to accept them. For other
2901   errors during setting up (timeouts or whatever), defer all addresses, and
2902   yield DEFER, so that the host is not tried again for a while.
2903
2904   XXX This peeking for another host feels like a layering violation. We want
2905   to note the host as unusable, but down here we shouldn't know if this was
2906   the last host to try for the addr(list).  Perhaps the upper layer should be
2907   the one to do set_errno() ?  The problem is that currently the addr is where
2908   errno etc. are stashed, but until we run out of hosts to try the errors are
2909   host-specific.  Maybe we should enhance the host_item definition? */
2910
2911 FAILED:
2912   sx->ok = FALSE;                /* For when reached by GOTO */
2913   set_errno(sx->addrlist, errno, message,
2914             sx->conn_args.host->next
2915             ? DEFER
2916             : code == '5'
2917 #ifdef SUPPORT_I18N
2918                         || errno == ERRNO_UTF8_FWD
2919 #endif
2920             ? FAIL : DEFER,
2921             pass_message,
2922             errno == ECONNREFUSED ? NULL : sx->conn_args.host,
2923 #ifdef EXPERIMENTAL_DSN_INFO
2924             sx->smtp_greeting, sx->helo_response,
2925 #endif
2926             &sx->delivery_start);
2927   }
2928
2929
2930 SEND_QUIT:
2931
2932 if (sx->send_quit)
2933   (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2934
2935 #ifndef DISABLE_TLS
2936 if (sx->cctx.tls_ctx)
2937   {
2938   tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2939   sx->cctx.tls_ctx = NULL;
2940   }
2941 #endif
2942
2943 /* Close the socket, and return the appropriate value, first setting
2944 works because the NULL setting is passed back to the calling process, and
2945 remote_max_parallel is forced to 1 when delivering over an existing connection,
2946 */
2947
2948 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
2949 if (sx->send_quit)
2950   {
2951   shutdown(sx->cctx.sock, SHUT_WR);
2952   if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2953     for (int i = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && i > 0;)
2954       i--;                              /* drain socket */
2955   sx->send_quit = FALSE;
2956   }
2957 (void)close(sx->cctx.sock);
2958 sx->cctx.sock = -1;
2959
2960 #ifndef DISABLE_EVENT
2961 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2962 #endif
2963
2964 continue_transport = NULL;
2965 continue_hostname = NULL;
2966 return yield;
2967 }
2968
2969
2970
2971
2972 /* Create the string of options that will be appended to the MAIL FROM:
2973 in the connection context buffer */
2974
2975 static int
2976 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2977 {
2978 uschar * p = sx->buffer;
2979 address_item * addr;
2980 int address_count;
2981
2982 *p = 0;
2983
2984 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2985 send it, adding something to the message size to allow for imprecision
2986 and things that get added en route. Exim keeps the number of lines
2987 in a message, so we can give an accurate value for the original message, but we
2988 need some additional to handle added headers. (Double "." characters don't get
2989 included in the count.) */
2990
2991 if (  message_size > 0
2992    && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2993   {
2994 /*XXX problem here under spool_files_wireformat?
2995 Or just forget about lines?  Or inflate by a fixed proportion? */
2996
2997   sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
2998   while (*p) p++;
2999   }
3000
3001 #ifndef DISABLE_PRDR
3002 /* If it supports Per-Recipient Data Responses, and we have more than one recipient,
3003 request that */
3004
3005 sx->prdr_active = FALSE;
3006 if (sx->peer_offered & OPTION_PRDR)
3007   for (address_item * addr = addrlist; addr; addr = addr->next)
3008     if (addr->transport_return == PENDING_DEFER)
3009       {
3010       for (addr = addr->next; addr; addr = addr->next)
3011         if (addr->transport_return == PENDING_DEFER)
3012           {                     /* at least two recipients to send */
3013           sx->prdr_active = TRUE;
3014           sprintf(CS p, " PRDR"); p += 5;
3015           break;
3016           }
3017       break;
3018       }
3019 #endif
3020
3021 #ifdef SUPPORT_I18N
3022 /* If it supports internationalised messages, and this meesage need that,
3023 request it */
3024
3025 if (  sx->peer_offered & OPTION_UTF8
3026    && addrlist->prop.utf8_msg
3027    && !addrlist->prop.utf8_downcvt
3028    )
3029   Ustrcpy(p, US" SMTPUTF8"), p += 9;
3030 #endif
3031
3032 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3033 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3034      addr && address_count < sx->max_rcpt;
3035      addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3036   {
3037   address_count++;
3038   if (!(addr->dsn_flags & rf_dsnlasthop))
3039     {
3040     sx->dsn_all_lasthop = FALSE;
3041     break;
3042     }
3043   }
3044
3045 /* Add any DSN flags to the mail command */
3046
3047 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3048   {
3049   if (dsn_ret == dsn_ret_hdrs)
3050     { Ustrcpy(p, US" RET=HDRS"); p += 9; }
3051   else if (dsn_ret == dsn_ret_full)
3052     { Ustrcpy(p, US" RET=FULL"); p += 9; }
3053
3054   if (dsn_envid)
3055     {
3056     string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3057     while (*p) p++;
3058     }
3059   }
3060
3061 /* If an authenticated_sender override has been specified for this transport
3062 instance, expand it. If the expansion is forced to fail, and there was already
3063 an authenticated_sender for this message, the original value will be used.
3064 Other expansion failures are serious. An empty result is ignored, but there is
3065 otherwise no check - this feature is expected to be used with LMTP and other
3066 cases where non-standard addresses (e.g. without domains) might be required. */
3067
3068 return smtp_mail_auth_str(sx, p, addrlist) ? ERROR : OK;
3069 }
3070
3071
3072 static void
3073 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3074 {
3075 uschar * p = sx->buffer;
3076 *p = 0;
3077
3078 /* Add any DSN flags to the rcpt command */
3079
3080 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3081   {
3082   if (addr->dsn_flags & rf_dsnflags)
3083     {
3084     BOOL first = TRUE;
3085
3086     Ustrcpy(p, US" NOTIFY=");
3087     while (*p) p++;
3088     for (int i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3089       {
3090       if (!first) *p++ = ',';
3091       first = FALSE;
3092       Ustrcpy(p, rf_names[i]);
3093       while (*p) p++;
3094       }
3095     }
3096
3097   if (addr->dsn_orcpt)
3098     {
3099     string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3100       addr->dsn_orcpt);
3101     while (*p) p++;
3102     }
3103   }
3104 }
3105
3106
3107
3108 /*
3109 Return:
3110  0      good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3111  -1     MAIL response error
3112  -2     any non-MAIL read i/o error
3113  -3     non-MAIL response timeout
3114  -4     internal error; channel still usable
3115  -5     transmit failed
3116  */
3117
3118 int
3119 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3120 {
3121 address_item * addr;
3122 int address_count, pipe_limit;
3123 int rc;
3124
3125 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3126   {
3127   *yield = ERROR;
3128   return -4;
3129   }
3130
3131 /* From here until we send the DATA command, we can make use of PIPELINING
3132 if the server host supports it. The code has to be able to check the responses
3133 at any point, for when the buffer fills up, so we write it totally generally.
3134 When PIPELINING is off, each command written reports that it has flushed the
3135 buffer. */
3136
3137 sx->pending_MAIL = TRUE;     /* The block starts with MAIL */
3138
3139   {
3140   uschar * s = sx->from_addr;
3141 #ifdef SUPPORT_I18N
3142   uschar * errstr = NULL;
3143
3144   /* If we must downconvert, do the from-address here.  Remember we had to
3145   for the to-addresses (done below), and also (ugly) for re-doing when building
3146   the delivery log line. */
3147
3148   if (  sx->addrlist->prop.utf8_msg
3149      && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3150      )
3151     {
3152     if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3153       {
3154       set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE, &sx->delivery_start);
3155       *yield = ERROR;
3156       return -4;
3157       }
3158     setflag(sx->addrlist, af_utf8_downcvt);
3159     }
3160 #endif
3161
3162   rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3163           "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3164   }
3165
3166 mail_command = string_copy(big_buffer);  /* Save for later error message */
3167
3168 switch(rc)
3169   {
3170   case -1:                /* Transmission error */
3171     return -5;
3172
3173   case +1:                /* Cmd was sent */
3174     if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3175        (SOB sx->conn_args.ob)->command_timeout))
3176       {
3177       if (errno == 0 && sx->buffer[0] == '4')
3178         {
3179         errno = ERRNO_MAIL4XX;
3180         sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3181         }
3182       return -1;
3183       }
3184     sx->pending_MAIL = FALSE;
3185     break;
3186
3187   /* otherwise zero: command queued for pipeline */
3188   }
3189
3190 /* Pass over all the relevant recipient addresses for this host, which are the
3191 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3192 several before we have to read the responses for those seen so far. This
3193 checking is done by a subroutine because it also needs to be done at the end.
3194 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3195 the next one if not all are sent.
3196
3197 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3198 last address because we want to abort if any recipients have any kind of
3199 problem, temporary or permanent. We know that all recipient addresses will have
3200 the PENDING_DEFER status, because only one attempt is ever made, and we know
3201 that max_rcpt will be large, so all addresses will be done at once.
3202
3203 For verify we flush the pipeline after any (the only) rcpt address. */
3204
3205 for (addr = sx->first_addr, address_count = 0, pipe_limit = 100;
3206      addr  &&  address_count < sx->max_rcpt;
3207      addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3208   {
3209   int cmds_sent;
3210   BOOL no_flush;
3211   uschar * rcpt_addr;
3212
3213   addr->dsn_aware = sx->peer_offered & OPTION_DSN
3214     ? dsn_support_yes : dsn_support_no;
3215
3216   address_count++;
3217   if (pipe_limit-- <= 0)
3218     { no_flush = FALSE; pipe_limit = 100; }
3219   else
3220     no_flush = pipelining_active && !sx->verify
3221           && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3222
3223   build_rcptcmd_options(sx, addr);
3224
3225   /* Now send the RCPT command, and process outstanding responses when
3226   necessary. After a timeout on RCPT, we just end the function, leaving the
3227   yield as OK, because this error can often mean that there is a problem with
3228   just one address, so we don't want to delay the host. */
3229
3230   rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3231
3232 #ifdef SUPPORT_I18N
3233   if (  testflag(sx->addrlist, af_utf8_downcvt)
3234      && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3235      )
3236     {
3237     /*XXX could we use a per-address errstr here? Not fail the whole send? */
3238     errno = ERRNO_EXPANDFAIL;
3239     return -5;          /*XXX too harsh? */
3240     }
3241 #endif
3242
3243   cmds_sent = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3244     "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3245
3246   if (cmds_sent < 0) return -5;
3247   if (cmds_sent > 0)
3248     {
3249     switch(sync_responses(sx, cmds_sent, 0))
3250       {
3251       case 3: sx->ok = TRUE;                    /* 2xx & 5xx => OK & progress made */
3252       case 2: sx->completed_addr = TRUE;        /* 5xx (only) => progress made */
3253               break;
3254
3255       case 1: sx->ok = TRUE;                    /* 2xx (only) => OK, but if LMTP, */
3256               if (!sx->lmtp)                    /*  can't tell about progress yet */
3257                 sx->completed_addr = TRUE;
3258       case 0:                                   /* No 2xx or 5xx, but no probs */
3259               /* If any RCPT got a 452 response then next_addr has been updated
3260               for restarting with a new MAIL on the same connection.  Send no more
3261               RCPTs for this MAIL. */
3262
3263               if (sx->RCPT_452)
3264                 {
3265                 DEBUG(D_transport) debug_printf("seen 452 too-many-rcpts\n");
3266                 sx->RCPT_452 = FALSE;
3267                 /* sx->next_addr has been reset for fast_retry */
3268                 return 0;
3269                 }
3270               break;
3271
3272       case -1: return -3;                       /* Timeout on RCPT */
3273       case -2: return -2;                       /* non-MAIL read i/o error */
3274       default: return -1;                       /* any MAIL error */
3275
3276 #ifndef DISABLE_PIPE_CONNECT
3277       case -4: return -1;                       /* non-2xx for pipelined banner or EHLO */
3278       case -5: return -1;                       /* TLS first-read error */
3279 #endif
3280       }
3281     }
3282   }      /* Loop for next address */
3283
3284 sx->next_addr = addr;
3285 return 0;
3286 }
3287
3288
3289 #ifndef DISABLE_TLS
3290 /*****************************************************
3291 * Proxy TLS connection for another transport process *
3292 ******************************************************/
3293 /*
3294 Close the unused end of the pipe, fork once more, then use the given buffer
3295 as a staging area, and select on both the given fd and the TLS'd client-fd for
3296 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3297 Do blocking full-size writes, and reads under a timeout.  Once both input
3298 channels are closed, exit the process.
3299
3300 Arguments:
3301   ct_ctx        tls context
3302   buf           space to use for buffering
3303   bufsiz        size of buffer
3304   pfd           pipe filedescriptor array; [0] is comms to proxied process
3305   timeout       per-read timeout, seconds
3306
3307 Does not return.
3308 */
3309
3310 void
3311 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3312   int timeout)
3313 {
3314 fd_set rfds, efds;
3315 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3316 int rc, i;
3317
3318 close(pfd[1]);
3319 if ((rc = exim_fork(US"tls-proxy")))
3320   _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3321
3322 set_process_info("proxying TLS connection for continued transport");
3323 FD_ZERO(&rfds);
3324 FD_SET(tls_out.active.sock, &rfds);
3325 FD_SET(pfd[0], &rfds);
3326
3327 for (int fd_bits = 3; fd_bits; )
3328   {
3329   time_t time_left = timeout;
3330   time_t time_start = time(NULL);
3331
3332   /* wait for data */
3333   efds = rfds;
3334   do
3335     {
3336     struct timeval tv = { time_left, 0 };
3337
3338     rc = select(max_fd,
3339       (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
3340
3341     if (rc < 0 && errno == EINTR)
3342       if ((time_left -= time(NULL) - time_start) > 0) continue;
3343
3344     if (rc <= 0)
3345       {
3346       DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
3347       goto done;
3348       }
3349
3350     if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
3351       {
3352       DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
3353         FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
3354       goto done;
3355       }
3356     }
3357   while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
3358
3359   /* handle inbound data */
3360   if (FD_ISSET(tls_out.active.sock, &rfds))
3361     if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
3362       {
3363       fd_bits &= ~1;
3364       FD_CLR(tls_out.active.sock, &rfds);
3365       shutdown(pfd[0], SHUT_WR);
3366       timeout = 5;
3367       }
3368     else
3369       {
3370       for (int nbytes = 0; rc - nbytes > 0; nbytes += i)
3371         if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
3372       }
3373   else if (fd_bits & 1)
3374     FD_SET(tls_out.active.sock, &rfds);
3375
3376   /* handle outbound data */
3377   if (FD_ISSET(pfd[0], &rfds))
3378     if ((rc = read(pfd[0], buf, bsize)) <= 0)
3379       {
3380       fd_bits = 0;
3381       tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
3382       ct_ctx = NULL;
3383       }
3384     else
3385       {
3386       for (int nbytes = 0; rc - nbytes > 0; nbytes += i)
3387         if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
3388           goto done;
3389       }
3390   else if (fd_bits & 2)
3391     FD_SET(pfd[0], &rfds);
3392   }
3393
3394 done:
3395   testharness_pause_ms(100);    /* let logging complete */
3396   exim_exit(EXIT_SUCCESS);
3397 }
3398 #endif
3399
3400
3401 /*************************************************
3402 *       Deliver address list to given host       *
3403 *************************************************/
3404
3405 /* If continue_hostname is not null, we get here only when continuing to
3406 deliver down an existing channel. The channel was passed as the standard
3407 input. TLS is never active on a passed channel; the previous process either
3408 closes it down before passing the connection on, or inserts a TLS-proxy
3409 process and passes on a cleartext conection.
3410
3411 Otherwise, we have to make a connection to the remote host, and do the
3412 initial protocol exchange.
3413
3414 When running as an MUA wrapper, if the sender or any recipient is rejected,
3415 temporarily or permanently, we force failure for all recipients.
3416
3417 Arguments:
3418   addrlist        chain of potential addresses to deliver; only those whose
3419                   transport_return field is set to PENDING_DEFER are currently
3420                   being processed; others should be skipped - they have either
3421                   been delivered to an earlier host or IP address, or been
3422                   failed by one of them.
3423   host            host to deliver to
3424   host_af         AF_INET or AF_INET6
3425   defport         default TCP/IP port to use if host does not specify, in host
3426                   byte order
3427   interface       interface to bind to, or NULL
3428   tblock          transport instance block
3429   message_defer   set TRUE if yield is OK, but all addresses were deferred
3430                     because of a non-recipient, non-host failure, that is, a
3431                     4xx response to MAIL FROM, DATA, or ".". This is a defer
3432                     that is specific to the message.
3433   suppress_tls    if TRUE, don't attempt a TLS connection - this is set for
3434                     a second attempt after TLS initialization fails
3435
3436 Returns:          OK    - the connection was made and the delivery attempted;
3437                           the result for each address is in its data block.
3438                   DEFER - the connection could not be made, or something failed
3439                           while setting up the SMTP session, or there was a
3440                           non-message-specific error, such as a timeout.
3441                   ERROR - a filter command is specified for this transport,
3442                           and there was a problem setting it up; OR helo_data
3443                           or add_headers or authenticated_sender is specified
3444                           for this transport, and the string failed to expand
3445
3446                 For all non-OK returns the first addr of the list carries the
3447                 time taken for the attempt.
3448 */
3449
3450 static int
3451 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
3452   uschar *interface, transport_instance *tblock,
3453   BOOL *message_defer, BOOL suppress_tls)
3454 {
3455 smtp_transport_options_block * ob = SOB tblock->options_block;
3456 int yield = OK;
3457 int save_errno;
3458 int rc;
3459
3460 BOOL pass_message = FALSE;
3461 uschar *message = NULL;
3462 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
3463 smtp_context * sx = store_get(sizeof(*sx), TRUE);       /* tainted, for the data buffers */
3464 #ifdef SUPPORT_DANE
3465 BOOL dane_held;
3466 #endif
3467
3468 *message_defer = FALSE;
3469
3470 memset(sx, 0, sizeof(*sx));
3471 sx->addrlist = addrlist;
3472 sx->conn_args.host = host;
3473 sx->conn_args.host_af = host_af,
3474 sx->port = defport;
3475 sx->conn_args.interface = interface;
3476 sx->helo_data = NULL;
3477 sx->conn_args.tblock = tblock;
3478 /* sx->verify = FALSE; */
3479 gettimeofday(&sx->delivery_start, NULL);
3480 sx->sync_addr = sx->first_addr = addrlist;
3481
3482 #ifdef SUPPORT_DANE
3483 DANE_DOMAINS:
3484 dane_held = FALSE;
3485 #endif
3486
3487 /* Get the channel set up ready for a message, MAIL FROM being the next
3488 SMTP command to send. */
3489
3490 if ((rc = smtp_setup_conn(sx, suppress_tls)) != OK)
3491   {
3492   timesince(&addrlist->delivery_time, &sx->delivery_start);
3493   yield = rc;
3494   goto TIDYUP;
3495   }
3496
3497 #ifdef SUPPORT_DANE
3498 /* If the connection used DANE, ignore for now any addresses with incompatible
3499 domains.  The SNI has to be the domain.  Arrange a whole new TCP conn later,
3500 just in case only TLS isn't enough. */
3501
3502 if (sx->conn_args.dane)
3503   {
3504   const uschar * dane_domain = sx->first_addr->domain;
3505
3506   for (address_item * a = sx->first_addr->next; a; a = a->next)
3507     if (  a->transport_return == PENDING_DEFER
3508        && Ustrcmp(dane_domain, a->domain) != 0)
3509       {
3510       DEBUG(D_transport) debug_printf("DANE: holding %s for later\n", a->domain);
3511       dane_held = TRUE;
3512       a->transport_return = DANE;
3513       }
3514   }
3515 #endif
3516
3517 /* If there is a filter command specified for this transport, we can now
3518 set it up. This cannot be done until the identity of the host is known. */
3519
3520 if (tblock->filter_command)
3521   {
3522   transport_filter_timeout = tblock->filter_timeout;
3523
3524   /* On failure, copy the error to all addresses, abandon the SMTP call, and
3525   yield ERROR. */
3526
3527   if (!transport_set_up_command(&transport_filter_argv,
3528         tblock->filter_command, TRUE, DEFER, addrlist,
3529         string_sprintf("%.50s transport", tblock->name), NULL))
3530     {
3531     set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
3532       FALSE, &sx->delivery_start);
3533     yield = ERROR;
3534     goto SEND_QUIT;
3535     }
3536
3537   if (  transport_filter_argv
3538      && *transport_filter_argv
3539      && **transport_filter_argv
3540      && sx->peer_offered & OPTION_CHUNKING
3541 #ifndef DISABLE_DKIM
3542     /* When dkim signing, chunking is handled even with a transport-filter */
3543      && !(ob->dkim.dkim_private_key && ob->dkim.dkim_domain && ob->dkim.dkim_selector)
3544      && !ob->dkim.force_bodyhash
3545 #endif
3546      )
3547     {
3548     sx->peer_offered &= ~OPTION_CHUNKING;
3549     DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
3550     }
3551   }
3552
3553 /* For messages that have more than the maximum number of envelope recipients,
3554 we want to send several transactions down the same SMTP connection. (See
3555 comments in deliver.c as to how this reconciles, heuristically, with
3556 remote_max_parallel.) This optimization was added to Exim after the following
3557 code was already working. The simplest way to put it in without disturbing the
3558 code was to use a goto to jump back to this point when there is another
3559 transaction to handle. */
3560
3561 SEND_MESSAGE:
3562 sx->from_addr = return_path;
3563 sx->sync_addr = sx->first_addr;
3564 sx->ok = FALSE;
3565 sx->send_rset = TRUE;
3566 sx->completed_addr = FALSE;
3567
3568
3569 /* If we are a continued-connection-after-verify the MAIL and RCPT
3570 commands were already sent; do not re-send but do mark the addrs as
3571 having been accepted up to RCPT stage.  A traditional cont-conn
3572 always has a sequence number greater than one. */
3573
3574 if (continue_hostname && continue_sequence == 1)
3575   {
3576   /* sx->pending_MAIL = FALSE; */
3577   sx->ok = TRUE;
3578   /* sx->next_addr = NULL; */
3579
3580   for (address_item * addr = addrlist; addr; addr = addr->next)
3581     addr->transport_return = PENDING_OK;
3582   }
3583 else
3584   {
3585   /* Initiate a message transfer. */
3586
3587   switch(smtp_write_mail_and_rcpt_cmds(sx, &yield))
3588     {
3589     case 0:             break;
3590     case -1: case -2:   goto RESPONSE_FAILED;
3591     case -3:            goto END_OFF;
3592     case -4:            goto SEND_QUIT;
3593     default:            goto SEND_FAILED;
3594     }
3595
3596   /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3597   permanently or temporarily. We should have flushed and synced after the last
3598   RCPT. */
3599
3600   if (mua_wrapper)
3601     {
3602     address_item * a;
3603     unsigned cnt;
3604
3605     for (a = sx->first_addr, cnt = 0; a && cnt < sx->max_rcpt; a = a->next, cnt++)
3606       if (a->transport_return != PENDING_OK)
3607         {
3608         /*XXX could we find a better errno than 0 here? */
3609         set_errno_nohost(addrlist, 0, a->message, FAIL,
3610           testflag(a, af_pass_message), &sx->delivery_start);
3611         sx->ok = FALSE;
3612         break;
3613         }
3614     }
3615   }
3616
3617 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3618 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3619 have a good recipient buffered up if we are pipelining. We don't want to waste
3620 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3621 are pipelining. The responses are all handled by sync_responses().
3622 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3623 to send is. */
3624
3625 if (  !(sx->peer_offered & OPTION_CHUNKING)
3626    && (sx->ok || (pipelining_active && !mua_wrapper)))
3627   {
3628   int count = smtp_write_command(sx, SCMD_FLUSH, "DATA\r\n");
3629
3630   if (count < 0) goto SEND_FAILED;
3631   switch(sync_responses(sx, count, sx->ok ? +1 : -1))
3632     {
3633     case 3: sx->ok = TRUE;            /* 2xx & 5xx => OK & progress made */
3634     case 2: sx->completed_addr = TRUE;    /* 5xx (only) => progress made */
3635     break;
3636
3637     case 1: sx->ok = TRUE;            /* 2xx (only) => OK, but if LMTP, */
3638     if (!sx->lmtp) sx->completed_addr = TRUE; /* can't tell about progress yet */
3639     case 0: break;                      /* No 2xx or 5xx, but no probs */
3640
3641     case -1: goto END_OFF;              /* Timeout on RCPT */
3642
3643 #ifndef DISABLE_PIPE_CONNECT
3644     case -5:                            /* TLS first-read error */
3645     case -4:  HDEBUG(D_transport)
3646                 debug_printf("failed reaping pipelined cmd responses\n");
3647 #endif
3648     default: goto RESPONSE_FAILED;       /* I/O error, or any MAIL/DATA error */
3649     }
3650   pipelining_active = FALSE;
3651   data_command = string_copy(big_buffer);  /* Save for later error message */
3652   }
3653
3654 /* If there were no good recipients (but otherwise there have been no
3655 problems), just set ok TRUE, since we have handled address-specific errors
3656 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3657 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3658 well as body. Set the appropriate timeout value to be used for each chunk.
3659 (Haven't been able to make it work using select() for writing yet.) */
3660
3661 if (  !sx->ok
3662    && (!(sx->peer_offered & OPTION_CHUNKING) || !pipelining_active))
3663   {
3664   /* Save the first address of the next batch. */
3665   sx->first_addr = sx->next_addr;
3666
3667   sx->ok = TRUE;
3668   }
3669 else
3670   {
3671   transport_ctx tctx = {
3672     .u = {.fd = sx->cctx.sock}, /*XXX will this need TLS info? */
3673     .tblock =   tblock,
3674     .addr =     addrlist,
3675     .check_string = US".",
3676     .escape_string = US"..",    /* Escaping strings */
3677     .options =
3678       topt_use_crlf | topt_escape_headers
3679     | (tblock->body_only        ? topt_no_headers : 0)
3680     | (tblock->headers_only     ? topt_no_body : 0)
3681     | (tblock->return_path_add  ? topt_add_return_path : 0)
3682     | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3683     | (tblock->envelope_to_add  ? topt_add_envelope_to : 0)
3684   };
3685
3686   /* If using CHUNKING we need a callback from the generic transport
3687   support to us, for the sending of BDAT smtp commands and the reaping
3688   of responses.  The callback needs a whole bunch of state so set up
3689   a transport-context structure to be passed around. */
3690
3691   if (sx->peer_offered & OPTION_CHUNKING)
3692     {
3693     tctx.check_string = tctx.escape_string = NULL;
3694     tctx.options |= topt_use_bdat;
3695     tctx.chunk_cb = smtp_chunk_cmd_callback;
3696     sx->pending_BDAT = FALSE;
3697     sx->good_RCPT = sx->ok;
3698     sx->cmd_count = 0;
3699     tctx.smtp_context = sx;
3700     }
3701   else
3702     tctx.options |= topt_end_dot;
3703
3704   /* Save the first address of the next batch. */
3705   sx->first_addr = sx->next_addr;
3706
3707   /* Responses from CHUNKING commands go in buffer.  Otherwise,
3708   there has not been a response. */
3709
3710   sx->buffer[0] = 0;
3711
3712   sigalrm_seen = FALSE;
3713   transport_write_timeout = ob->data_timeout;
3714   smtp_command = US"sending data block";   /* For error messages */
3715   DEBUG(D_transport|D_v)
3716     if (sx->peer_offered & OPTION_CHUNKING)
3717       debug_printf("         will write message using CHUNKING\n");
3718     else
3719       debug_printf("  SMTP>> writing message and terminating \".\"\n");
3720   transport_count = 0;
3721
3722 #ifndef DISABLE_DKIM
3723   {
3724 # ifdef MEASURE_TIMING
3725   struct timeval t0;
3726   gettimeofday(&t0, NULL);
3727 # endif
3728   dkim_exim_sign_init();
3729 # ifdef EXPERIMENTAL_ARC
3730     {
3731     uschar * s = ob->arc_sign;
3732     if (s)
3733       {
3734       if (!(ob->dkim.arc_signspec = s = expand_string(s)))
3735         {
3736         if (!f.expand_string_forcedfail)
3737           {
3738           message = US"failed to expand arc_sign";
3739           sx->ok = FALSE;
3740           goto SEND_FAILED;
3741           }
3742         }
3743       else if (*s)
3744         {
3745         /* Ask dkim code to hash the body for ARC */
3746         (void) arc_ams_setup_sign_bodyhash();
3747         ob->dkim.force_bodyhash = TRUE;
3748         }
3749       }
3750     }
3751 # endif
3752 # ifdef MEASURE_TIMING
3753   report_time_since(&t0, US"dkim_exim_sign_init (delta)");
3754 # endif
3755   }
3756   sx->ok = dkim_transport_write_message(&tctx, &ob->dkim, CUSS &message);
3757 #else
3758   sx->ok = transport_write_message(&tctx, 0);
3759 #endif
3760
3761   /* transport_write_message() uses write() because it is called from other
3762   places to write to non-sockets. This means that under some OS (e.g. Solaris)
3763   it can exit with "Broken pipe" as its error. This really means that the
3764   socket got closed at the far end. */
3765
3766   transport_write_timeout = 0;   /* for subsequent transports */
3767
3768   /* Failure can either be some kind of I/O disaster (including timeout),
3769   or the failure of a transport filter or the expansion of added headers.
3770   Or, when CHUNKING, it can be a protocol-detected failure. */
3771
3772   if (!sx->ok)
3773     if (message) goto SEND_FAILED;
3774     else         goto RESPONSE_FAILED;
3775
3776   /* We used to send the terminating "." explicitly here, but because of
3777   buffering effects at both ends of TCP/IP connections, you don't gain
3778   anything by keeping it separate, so it might as well go in the final
3779   data buffer for efficiency. This is now done by setting the topt_end_dot
3780   flag above. */
3781
3782   smtp_command = US"end of data";
3783
3784   if (sx->peer_offered & OPTION_CHUNKING && sx->cmd_count > 1)
3785     {
3786     /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3787     switch(sync_responses(sx, sx->cmd_count-1, 0))
3788       {
3789       case 3: sx->ok = TRUE;            /* 2xx & 5xx => OK & progress made */
3790       case 2: sx->completed_addr = TRUE;    /* 5xx (only) => progress made */
3791               break;
3792
3793       case 1: sx->ok = TRUE;            /* 2xx (only) => OK, but if LMTP, */
3794       if (!sx->lmtp) sx->completed_addr = TRUE; /* can't tell about progress yet */
3795       case 0: break;                    /* No 2xx or 5xx, but no probs */
3796
3797       case -1: goto END_OFF;            /* Timeout on RCPT */
3798
3799 #ifndef DISABLE_PIPE_CONNECT
3800       case -5:                          /* TLS first-read error */
3801       case -4:  HDEBUG(D_transport)
3802                   debug_printf("failed reaping pipelined cmd responses\n");
3803 #endif
3804       default: goto RESPONSE_FAILED;    /* I/O error, or any MAIL/DATA error */
3805       }
3806     }
3807
3808 #ifndef DISABLE_PRDR
3809   /* For PRDR we optionally get a partial-responses warning followed by the
3810   individual responses, before going on with the overall response.  If we don't
3811   get the warning then deal with per non-PRDR. */
3812
3813   if(sx->prdr_active)
3814     {
3815     sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '3', ob->final_timeout);
3816     if (!sx->ok && errno == 0) switch(sx->buffer[0])
3817       {
3818       case '2': sx->prdr_active = FALSE;
3819                 sx->ok = TRUE;
3820                 break;
3821       case '4': errno = ERRNO_DATA4XX;
3822                 addrlist->more_errno |=
3823                   ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3824                 break;
3825       }
3826     }
3827   else
3828 #endif
3829
3830   /* For non-PRDR SMTP, we now read a single response that applies to the
3831   whole message.  If it is OK, then all the addresses have been delivered. */
3832
3833   if (!sx->lmtp)
3834     {
3835     sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3836       ob->final_timeout);
3837     if (!sx->ok && errno == 0 && sx->buffer[0] == '4')
3838       {
3839       errno = ERRNO_DATA4XX;
3840       addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3841       }
3842     }
3843
3844   /* For LMTP, we get back a response for every RCPT command that we sent;
3845   some may be accepted and some rejected. For those that get a response, their
3846   status is fixed; any that are accepted have been handed over, even if later
3847   responses crash - at least, that's how I read RFC 2033.
3848
3849   If all went well, mark the recipient addresses as completed, record which
3850   host/IPaddress they were delivered to, and cut out RSET when sending another
3851   message down the same channel. Write the completed addresses to the journal
3852   now so that they are recorded in case there is a crash of hardware or
3853   software before the spool gets updated. Also record the final SMTP
3854   confirmation if needed (for SMTP only). */
3855
3856   if (sx->ok)
3857     {
3858     int flag = '=';
3859     struct timeval delivery_time;
3860     int len;
3861     uschar * conf = NULL;
3862
3863     timesince(&delivery_time, &sx->delivery_start);
3864     sx->send_rset = FALSE;
3865     pipelining_active = FALSE;
3866
3867     /* Set up confirmation if needed - applies only to SMTP */
3868
3869     if (
3870 #ifdef DISABLE_EVENT
3871           LOGGING(smtp_confirmation) &&
3872 #endif
3873           !sx->lmtp
3874        )
3875       {
3876       const uschar *s = string_printing(sx->buffer);
3877       /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3878       conf = (s == sx->buffer)? US string_copy(s) : US s;
3879       }
3880
3881     /* Process all transported addresses - for LMTP or PRDR, read a status for
3882     each one. */
3883
3884     for (address_item * addr = addrlist; addr != sx->first_addr; addr = addr->next)
3885       {
3886       if (addr->transport_return != PENDING_OK) continue;
3887
3888       /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3889       remaining addresses. Otherwise, it's a return code for just the one
3890       address. For temporary errors, add a retry item for the address so that
3891       it doesn't get tried again too soon. */
3892
3893 #ifndef DISABLE_PRDR
3894       if (sx->lmtp || sx->prdr_active)
3895 #else
3896       if (sx->lmtp)
3897 #endif
3898         {
3899         if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3900             ob->final_timeout))
3901           {
3902           if (errno != 0 || sx->buffer[0] == 0) goto RESPONSE_FAILED;
3903           addr->message = string_sprintf(
3904 #ifndef DISABLE_PRDR
3905             "%s error after %s: %s", sx->prdr_active ? "PRDR":"LMTP",
3906 #else
3907             "LMTP error after %s: %s",
3908 #endif
3909             data_command, string_printing(sx->buffer));
3910           setflag(addr, af_pass_message);   /* Allow message to go to user */
3911           if (sx->buffer[0] == '5')
3912             addr->transport_return = FAIL;
3913           else
3914             {
3915             errno = ERRNO_DATA4XX;
3916             addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3917             addr->transport_return = DEFER;
3918 #ifndef DISABLE_PRDR
3919             if (!sx->prdr_active)
3920 #endif
3921               retry_add_item(addr, addr->address_retry_key, 0);
3922             }
3923           continue;
3924           }
3925         sx->completed_addr = TRUE;   /* NOW we can set this flag */
3926         if (LOGGING(smtp_confirmation))
3927           {
3928           const uschar *s = string_printing(sx->buffer);
3929           /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3930           conf = (s == sx->buffer) ? US string_copy(s) : US s;
3931           }
3932         }
3933
3934       /* SMTP, or success return from LMTP for this address. Pass back the
3935       actual host that was used. */
3936
3937       addr->transport_return = OK;
3938       addr->host_used = host;
3939       addr->delivery_time = delivery_time;
3940       addr->special_action = flag;
3941       addr->message = conf;
3942
3943       if (tcp_out_fastopen)
3944         {
3945         setflag(addr, af_tcp_fastopen_conn);
3946         if (tcp_out_fastopen >= TFO_USED_NODATA) setflag(addr, af_tcp_fastopen);
3947         if (tcp_out_fastopen >= TFO_USED_DATA) setflag(addr, af_tcp_fastopen_data);
3948         }
3949       if (sx->pipelining_used) setflag(addr, af_pipelining);
3950 #ifndef DISABLE_PIPE_CONNECT
3951       if (sx->early_pipe_active) setflag(addr, af_early_pipe);
3952 #endif
3953 #ifndef DISABLE_PRDR
3954       if (sx->prdr_active) setflag(addr, af_prdr_used);
3955 #endif
3956       if (sx->peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3957       flag = '-';
3958
3959 #ifndef DISABLE_PRDR
3960       if (!sx->prdr_active)
3961 #endif
3962         {
3963         /* Update the journal. For homonymic addresses, use the base address plus
3964         the transport name. See lots of comments in deliver.c about the reasons
3965         for the complications when homonyms are involved. Just carry on after
3966         write error, as it may prove possible to update the spool file later. */
3967
3968         if (testflag(addr, af_homonym))
3969           sprintf(CS sx->buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3970         else
3971           sprintf(CS sx->buffer, "%.500s\n", addr->unique);
3972
3973         DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx->buffer);
3974         len = Ustrlen(CS sx->buffer);
3975         if (write(journal_fd, sx->buffer, len) != len)
3976           log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3977             "%s: %s", sx->buffer, strerror(errno));
3978         }
3979       }
3980
3981 #ifndef DISABLE_PRDR
3982     if (sx->prdr_active)
3983       {
3984       const uschar * overall_message;
3985
3986       /* PRDR - get the final, overall response.  For any non-success
3987       upgrade all the address statuses. */
3988
3989       sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3990         ob->final_timeout);
3991       if (!sx->ok)
3992         {
3993         if(errno == 0 && sx->buffer[0] == '4')
3994           {
3995           errno = ERRNO_DATA4XX;
3996           addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3997           }
3998         for (address_item * addr = addrlist; addr != sx->first_addr; addr = addr->next)
3999           if (sx->buffer[0] == '5' || addr->transport_return == OK)
4000             addr->transport_return = PENDING_OK; /* allow set_errno action */
4001         goto RESPONSE_FAILED;
4002         }
4003
4004       /* Append the overall response to the individual PRDR response for logging
4005       and update the journal, or setup retry. */
4006
4007       overall_message = string_printing(sx->buffer);
4008       for (address_item * addr = addrlist; addr != sx->first_addr; addr = addr->next)
4009         if (addr->transport_return == OK)
4010           addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
4011
4012       for (address_item * addr = addrlist; addr != sx->first_addr; addr = addr->next)
4013         if (addr->transport_return == OK)
4014           {
4015           if (testflag(addr, af_homonym))
4016             sprintf(CS sx->buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
4017           else
4018             sprintf(CS sx->buffer, "%.500s\n", addr->unique);
4019
4020           DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx->buffer);
4021           len = Ustrlen(CS sx->buffer);
4022           if (write(journal_fd, sx->buffer, len) != len)
4023             log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
4024               "%s: %s", sx->buffer, strerror(errno));
4025           }
4026         else if (addr->transport_return == DEFER)
4027           retry_add_item(addr, addr->address_retry_key, -2);
4028       }
4029 #endif
4030
4031     /* Ensure the journal file is pushed out to disk. */
4032
4033     if (EXIMfsync(journal_fd) < 0)
4034       log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
4035         strerror(errno));
4036     }
4037   }
4038
4039
4040 /* Handle general (not specific to one address) failures here. The value of ok
4041 is used to skip over this code on the falling through case. A timeout causes a
4042 deferral. Other errors may defer or fail according to the response code, and
4043 may set up a special errno value, e.g. after connection chopped, which is
4044 assumed if errno == 0 and there is no text in the buffer. If control reaches
4045 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
4046 the problem is not related to this specific message. */
4047
4048 if (!sx->ok)
4049   {
4050   int code, set_rc;
4051   uschar * set_message;
4052
4053   RESPONSE_FAILED:
4054     {
4055     save_errno = errno;
4056     message = NULL;
4057     sx->send_quit = check_response(host, &save_errno, addrlist->more_errno,
4058       sx->buffer, &code, &message, &pass_message);
4059     goto FAILED;
4060     }
4061
4062   SEND_FAILED:
4063     {
4064     save_errno = errno;
4065     code = '4';
4066     message = string_sprintf("send() to %s [%s] failed: %s",
4067       host->name, host->address, message ? message : US strerror(save_errno));
4068     sx->send_quit = FALSE;
4069     goto FAILED;
4070     }
4071
4072   FAILED:
4073     {
4074     BOOL message_error;
4075
4076     sx->ok = FALSE;                /* For when reached by GOTO */
4077     set_message = message;
4078
4079   /* We want to handle timeouts after MAIL or "." and loss of connection after
4080   "." specially. They can indicate a problem with the sender address or with
4081   the contents of the message rather than a real error on the connection. These
4082   cases are treated in the same way as a 4xx response. This next bit of code
4083   does the classification. */
4084
4085     switch(save_errno)
4086       {
4087       case 0:
4088       case ERRNO_MAIL4XX:
4089       case ERRNO_DATA4XX:
4090         message_error = TRUE;
4091         break;
4092
4093       case ETIMEDOUT:
4094         message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
4095                         Ustrncmp(smtp_command,"end ",4) == 0;
4096         break;
4097
4098       case ERRNO_SMTPCLOSED:
4099         message_error = Ustrncmp(smtp_command,"end ",4) == 0;
4100         break;
4101
4102       default:
4103         message_error = FALSE;
4104         break;
4105       }
4106
4107     /* Handle the cases that are treated as message errors. These are:
4108
4109       (a) negative response or timeout after MAIL
4110       (b) negative response after DATA
4111       (c) negative response or timeout or dropped connection after "."
4112       (d) utf8 support required and not offered
4113
4114     It won't be a negative response or timeout after RCPT, as that is dealt
4115     with separately above. The action in all cases is to set an appropriate
4116     error code for all the addresses, but to leave yield set to OK because the
4117     host itself has not failed. Of course, it might in practice have failed
4118     when we've had a timeout, but if so, we'll discover that at the next
4119     delivery attempt. For a temporary error, set the message_defer flag, and
4120     write to the logs for information if this is not the last host. The error
4121     for the last host will be logged as part of the address's log line. */
4122
4123     if (message_error)
4124       {
4125       if (mua_wrapper) code = '5';  /* Force hard failure in wrapper mode */
4126
4127       /* If there's an errno, the message contains just the identity of
4128       the host. */
4129
4130       if (code == '5')
4131         set_rc = FAIL;
4132       else              /* Anything other than 5 is treated as temporary */
4133         {
4134         set_rc = DEFER;
4135         if (save_errno > 0)
4136           message = US string_sprintf("%s: %s", message, strerror(save_errno));
4137
4138         write_logs(host, message, sx->first_addr ? sx->first_addr->basic_errno : 0);
4139
4140         *message_defer = TRUE;
4141         }
4142 #ifdef TIOCOUTQ
4143       DEBUG(D_transport) if (sx->cctx.sock >= 0)
4144         {
4145         int n;
4146         if (ioctl(sx->cctx.sock, TIOCOUTQ, &n) == 0)
4147           debug_printf("%d bytes remain in socket output buffer\n", n);
4148         }
4149 #endif
4150       }
4151     /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4152     ".", or some other transportation error. We defer all addresses and yield
4153     DEFER, except for the case of failed add_headers expansion, or a transport
4154     filter failure, when the yield should be ERROR, to stop it trying other
4155     hosts. */
4156
4157     else
4158       {
4159 #ifndef DISABLE_PIPE_CONNECT
4160       /* If we were early-pipelinng and the actual EHLO response did not match
4161       the cached value we assumed, we could have detected it and passed a
4162       custom errno through to here.  It would be nice to RSET and retry right
4163       away, but to reliably do that we eould need an extra synch point before
4164       we committed to data and that would discard half the gained roundrips.
4165       Or we could summarily drop the TCP connection. but that is also ugly.
4166       Instead, we ignore the possibility (having freshened the cache) and rely
4167       on the server telling us with a nonmessage error if we have tried to
4168       do something it no longer supports. */
4169 #endif
4170       set_rc = DEFER;
4171       yield = (save_errno == ERRNO_CHHEADER_FAIL ||
4172                save_errno == ERRNO_FILTER_FAIL) ? ERROR : DEFER;
4173       }
4174     }
4175
4176   set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host,
4177 #ifdef EXPERIMENTAL_DSN_INFO
4178             sx->smtp_greeting, sx->helo_response,
4179 #endif
4180             &sx->delivery_start);
4181   }
4182
4183 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4184 SMTP session tidily. However, if there were too many addresses to send in one
4185 message (indicated by first_addr being non-NULL) we want to carry on with the
4186 rest of them. Also, it is desirable to send more than one message down the SMTP
4187 connection if there are several waiting, provided we haven't already sent so
4188 many as to hit the configured limit. The function transport_check_waiting looks
4189 for a waiting message and returns its id. Then transport_pass_socket tries to
4190 set up a continued delivery by passing the socket on to another process. The
4191 variable send_rset is FALSE if a message has just been successfully transferred.
4192
4193 If we are already sending down a continued channel, there may be further
4194 addresses not yet delivered that are aimed at the same host, but which have not
4195 been passed in this run of the transport. In this case, continue_more will be
4196 true, and all we should do is send RSET if necessary, and return, leaving the
4197 channel open.
4198
4199 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4200 do not want to continue with other messages down the same channel, because that
4201 can lead to looping between two or more messages, all with the same,
4202 temporarily failing address(es). [The retry information isn't updated yet, so
4203 new processes keep on trying.] We probably also don't want to try more of this
4204 message's addresses either.
4205
4206 If we have started a TLS session, we have to end it before passing the
4207 connection to a new process. However, not all servers can handle this (Exim
4208 can), so we do not pass such a connection on if the host matches
4209 hosts_nopass_tls. */
4210
4211 DEBUG(D_transport)
4212   debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4213     "yield=%d first_address is %sNULL\n", sx->ok, sx->send_quit,
4214     sx->send_rset, f.continue_more, yield, sx->first_addr ? "not " : "");
4215
4216 if (sx->completed_addr && sx->ok && sx->send_quit)
4217   {
4218   smtp_compare_t t_compare;
4219
4220   t_compare.tblock = tblock;
4221   t_compare.current_sender_address = sender_address;
4222
4223   if (  sx->first_addr != NULL          /* more addrs for this message */
4224      || f.continue_more                 /* more addrs for coninued-host */
4225      || (
4226 #ifndef DISABLE_TLS
4227            (  tls_out.active.sock < 0  &&  !continue_proxy_cipher
4228            || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
4229            )
4230         &&
4231 #endif
4232            transport_check_waiting(tblock->name, host->name,
4233              tblock->connection_max_messages, new_message_id,
4234              (oicf)smtp_are_same_identities, (void*)&t_compare)
4235      )  )
4236     {
4237     uschar *msg;
4238     BOOL pass_message;
4239
4240     if (sx->send_rset)
4241       if (! (sx->ok = smtp_write_command(sx, SCMD_FLUSH, "RSET\r\n") >= 0))
4242         {
4243         msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
4244           host->address, strerror(errno));
4245         sx->send_quit = FALSE;
4246         }
4247       else if (! (sx->ok = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
4248                   '2', ob->command_timeout)))
4249         {
4250         int code;
4251         sx->send_quit = check_response(host, &errno, 0, sx->buffer, &code, &msg,
4252           &pass_message);
4253         if (!sx->send_quit)
4254           {
4255           DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
4256             host->name, host->address, msg);
4257           }
4258         }
4259
4260     /* Either RSET was not needed, or it succeeded */
4261
4262     if (sx->ok)
4263       {
4264 #ifndef DISABLE_TLS
4265       int pfd[2];
4266 #endif
4267       int socket_fd = sx->cctx.sock;
4268
4269
4270       if (sx->first_addr != NULL)       /* More addresses still to be sent */
4271         {                               /*   for this message              */
4272         continue_sequence++;            /* Causes * in logging */
4273         pipelining_active = sx->pipelining_used;    /* was cleared at DATA */
4274         goto SEND_MESSAGE;
4275         }
4276
4277       /* Unless caller said it already has more messages listed for this host,
4278       pass the connection on to a new Exim process (below, the call to
4279       transport_pass_socket).  If the caller has more ready, just return with
4280       the connection still open. */
4281
4282 #ifndef DISABLE_TLS
4283       if (tls_out.active.sock >= 0)
4284         if (  f.continue_more
4285            || verify_check_given_host(CUSS &ob->hosts_noproxy_tls, host) == OK)
4286           {
4287           /* Before passing the socket on, or returning to caller with it still
4288           open, we must shut down TLS.  Not all MTAs allow for the continuation
4289           of the SMTP session when TLS is shut down. We test for this by sending
4290           a new EHLO. If we don't get a good response, we don't attempt to pass
4291           the socket on. */
4292
4293           tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4294           sx->cctx.tls_ctx = NULL;
4295           tls_out.active.sock = -1;
4296           smtp_peer_options = smtp_peer_options_wrap;
4297           sx->ok = !sx->smtps
4298             && smtp_write_command(sx, SCMD_FLUSH, "EHLO %s\r\n", sx->helo_data)
4299                 >= 0
4300             && smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
4301                                       '2', ob->command_timeout);
4302
4303           if (sx->ok && f.continue_more)
4304             goto TIDYUP;                /* More addresses for another run */
4305           }
4306         else
4307           {
4308           /* Set up a pipe for proxying TLS for the new transport process */
4309
4310           smtp_peer_options |= OPTION_TLS;
4311           if ((sx->ok = socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
4312             socket_fd = pfd[1];
4313           else
4314             set_errno(sx->first_addr, errno, US"internal allocation problem",
4315                     DEFER, FALSE, host,
4316 # ifdef EXPERIMENTAL_DSN_INFO
4317                     sx->smtp_greeting, sx->helo_response,
4318 # endif
4319                     &sx->delivery_start);
4320           }
4321       else
4322 #endif
4323         if (f.continue_more)
4324           goto TIDYUP;                  /* More addresses for another run */
4325
4326       /* If the socket is successfully passed, we mustn't send QUIT (or
4327       indeed anything!) from here. */
4328
4329 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4330 propagate it from the initial
4331 */
4332       if (sx->ok && transport_pass_socket(tblock->name, host->name,
4333             host->address, new_message_id, socket_fd))
4334         {
4335         sx->send_quit = FALSE;
4336
4337         /* We have passed the client socket to a fresh transport process.
4338         If TLS is still active, we need to proxy it for the transport we
4339         just passed the baton to.  Fork a child to to do it, and return to
4340         get logging done asap.  Which way to place the work makes assumptions
4341         about post-fork prioritisation which may not hold on all platforms. */
4342 #ifndef DISABLE_TLS
4343         if (tls_out.active.sock >= 0)
4344           {
4345           int pid = exim_fork(US"tls-proxy-interproc");
4346           if (pid == 0)         /* child; fork again to disconnect totally */
4347             {
4348             /* does not return */
4349             smtp_proxy_tls(sx->cctx.tls_ctx, sx->buffer, sizeof(sx->buffer), pfd,
4350                             ob->command_timeout);
4351             }
4352
4353           if (pid > 0)          /* parent */
4354             {
4355             close(pfd[0]);
4356             /* tidy the inter-proc to disconn the proxy proc */
4357             waitpid(pid, NULL, 0);
4358             tls_close(sx->cctx.tls_ctx, TLS_NO_SHUTDOWN);
4359             sx->cctx.tls_ctx = NULL;
4360             (void)close(sx->cctx.sock);
4361             sx->cctx.sock = -1;
4362             continue_transport = NULL;
4363             continue_hostname = NULL;
4364             goto TIDYUP;
4365             }
4366           log_write(0, LOG_PANIC_DIE, "fork failed");
4367           }
4368 #endif
4369         }
4370       }
4371
4372     /* If RSET failed and there are addresses left, they get deferred. */
4373     else
4374       set_errno(sx->first_addr, errno, msg, DEFER, FALSE, host,
4375 #ifdef EXPERIMENTAL_DSN_INFO
4376                   sx->smtp_greeting, sx->helo_response,
4377 #endif
4378                   &sx->delivery_start);
4379     }
4380   }
4381
4382 /* End off tidily with QUIT unless the connection has died or the socket has
4383 been passed to another process. There has been discussion on the net about what
4384 to do after sending QUIT. The wording of the RFC suggests that it is necessary
4385 to wait for a response, but on the other hand, there isn't anything one can do
4386 with an error response, other than log it. Exim used to do that. However,
4387 further discussion suggested that it is positively advantageous not to wait for
4388 the response, but to close the session immediately. This is supposed to move
4389 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
4390 load from the server. (Hosts that are both servers and clients may not see much
4391 difference, of course.) Further discussion indicated that this was safe to do
4392 on Unix systems which have decent implementations of TCP/IP that leave the
4393 connection around for a while (TIME_WAIT) after the application has gone away.
4394 This enables the response sent by the server to be properly ACKed rather than
4395 timed out, as can happen on broken TCP/IP implementations on other OS.
4396
4397 This change is being made on 31-Jul-98. After over a year of trouble-free
4398 operation, the old commented-out code was removed on 17-Sep-99. */
4399
4400 SEND_QUIT:
4401 if (sx->send_quit)
4402   {
4403 #ifdef EXIM_TCP_CORK
4404   (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, EXIM_TCP_CORK, US &on, sizeof(on));
4405 #endif
4406   (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
4407   }
4408
4409 END_OFF:
4410
4411 #ifndef DISABLE_TLS
4412 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4413 sx->cctx.tls_ctx = NULL;
4414 #endif
4415
4416 /* Close the socket, and return the appropriate value, first setting
4417 works because the NULL setting is passed back to the calling process, and
4418 remote_max_parallel is forced to 1 when delivering over an existing connection,
4419
4420 If all went well and continue_more is set, we shouldn't actually get here if
4421 there are further addresses, as the return above will be taken. However,
4422 writing RSET might have failed, or there may be other addresses whose hosts are
4423 specified in the transports, and therefore not visible at top level, in which
4424 case continue_more won't get set. */
4425
4426 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
4427 if (sx->send_quit)
4428   {
4429   shutdown(sx->cctx.sock, SHUT_WR);
4430   millisleep(20);
4431   testharness_pause_ms(200);
4432   if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
4433     for (int i = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && i > 0;)
4434       i--;                              /* drain socket */
4435   }
4436 (void)close(sx->cctx.sock);
4437
4438 #ifndef DISABLE_EVENT
4439 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
4440 #endif
4441
4442 #ifdef SUPPORT_DANE
4443 if (dane_held)
4444   {
4445   sx->first_addr = NULL;
4446   for (address_item * a = sx->addrlist->next; a; a = a->next)
4447     if (a->transport_return == DANE)
4448       {
4449       a->transport_return = PENDING_DEFER;
4450       if (!sx->first_addr)
4451         {
4452         /* Remember the new start-point in the addrlist, for smtp_setup_conn()
4453         to get the domain string for SNI */
4454
4455         sx->first_addr = a;
4456         DEBUG(D_transport) debug_printf("DANE: go-around for %s\n", a->domain);
4457         }
4458       }
4459   goto DANE_DOMAINS;
4460   }
4461 #endif
4462
4463 continue_transport = NULL;
4464 continue_hostname = NULL;
4465 return yield;
4466
4467 TIDYUP:
4468 #ifdef SUPPORT_DANE
4469 if (dane_held) for (address_item * a = sx->addrlist->next; a; a = a->next)
4470   if (a->transport_return == DANE)
4471     a->transport_return = PENDING_DEFER;
4472 #endif
4473 return yield;
4474 }
4475
4476
4477
4478
4479 /*************************************************
4480 *              Closedown entry point             *
4481 *************************************************/
4482
4483 /* This function is called when exim is passed an open smtp channel
4484 from another incarnation, but the message which it has been asked
4485 to deliver no longer exists. The channel is on stdin.
4486
4487 We might do fancy things like looking for another message to send down
4488 the channel, but if the one we sought has gone, it has probably been
4489 delivered by some other process that itself will seek further messages,
4490 so just close down our connection.
4491
4492 Argument:   pointer to the transport instance block
4493 Returns:    nothing
4494 */
4495
4496 void
4497 smtp_transport_closedown(transport_instance *tblock)
4498 {
4499 smtp_transport_options_block * ob = SOB tblock->options_block;
4500 client_conn_ctx cctx;
4501 smtp_context sx;
4502 uschar buffer[256];
4503 uschar inbuffer[4096];
4504 uschar outbuffer[16];
4505
4506 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4507 cctx.sock = fileno(stdin);
4508 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
4509
4510 sx.inblock.cctx = &cctx;
4511 sx.inblock.buffer = inbuffer;
4512 sx.inblock.buffersize = sizeof(inbuffer);
4513 sx.inblock.ptr = inbuffer;
4514 sx.inblock.ptrend = inbuffer;
4515
4516 sx.outblock.cctx = &cctx;
4517 sx.outblock.buffersize = sizeof(outbuffer);
4518 sx.outblock.buffer = outbuffer;
4519 sx.outblock.ptr = outbuffer;
4520 sx.outblock.cmd_count = 0;
4521 sx.outblock.authenticating = FALSE;
4522
4523 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4524 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
4525 (void)close(cctx.sock);
4526 }
4527
4528
4529
4530 /*************************************************
4531 *            Prepare addresses for delivery      *
4532 *************************************************/
4533
4534 /* This function is called to flush out error settings from previous delivery
4535 attempts to other hosts. It also records whether we got here via an MX record
4536 or not in the more_errno field of the address. We are interested only in
4537 addresses that are still marked DEFER - others may have got delivered to a
4538 previously considered IP address. Set their status to PENDING_DEFER to indicate
4539 which ones are relevant this time.
4540
4541 Arguments:
4542   addrlist     the list of addresses
4543   host         the host we are delivering to
4544
4545 Returns:       the first address for this delivery
4546 */
4547
4548 static address_item *
4549 prepare_addresses(address_item *addrlist, host_item *host)
4550 {
4551 address_item *first_addr = NULL;
4552 for (address_item * addr = addrlist; addr; addr = addr->next)
4553   if (addr->transport_return == DEFER)
4554     {
4555     if (!first_addr) first_addr = addr;
4556     addr->transport_return = PENDING_DEFER;
4557     addr->basic_errno = 0;
4558     addr->more_errno = (host->mx >= 0)? 'M' : 'A';
4559     addr->message = NULL;
4560 #ifndef DISABLE_TLS
4561     addr->cipher = NULL;
4562     addr->ourcert = NULL;
4563     addr->peercert = NULL;
4564     addr->peerdn = NULL;
4565     addr->ocsp = OCSP_NOT_REQ;
4566     addr->tlsver = NULL;
4567 #endif
4568 #ifdef EXPERIMENTAL_DSN_INFO
4569     addr->smtp_greeting = NULL;
4570     addr->helo_response = NULL;
4571 #endif
4572     }
4573 return first_addr;
4574 }
4575
4576
4577
4578 /*************************************************
4579 *              Main entry point                  *
4580 *************************************************/
4581
4582 /* See local README for interface details. As this is a remote transport, it is
4583 given a chain of addresses to be delivered in one connection, if possible. It
4584 always returns TRUE, indicating that each address has its own independent
4585 status set, except if there is a setting up problem, in which case it returns
4586 FALSE. */
4587
4588 BOOL
4589 smtp_transport_entry(
4590   transport_instance *tblock,      /* data for this instantiation */
4591   address_item *addrlist)          /* addresses we are working on */
4592 {
4593 int defport;
4594 int hosts_defer = 0;
4595 int hosts_fail  = 0;
4596 int hosts_looked_up = 0;
4597 int hosts_retry = 0;
4598 int hosts_serial = 0;
4599 int hosts_total = 0;
4600 int total_hosts_tried = 0;
4601 BOOL expired = TRUE;
4602 uschar *expanded_hosts = NULL;
4603 uschar *pistring;
4604 uschar *tid = string_sprintf("%s transport", tblock->name);
4605 smtp_transport_options_block *ob = SOB tblock->options_block;
4606 host_item *hostlist = addrlist->host_list;
4607 host_item *host = NULL;
4608
4609 DEBUG(D_transport)
4610   {
4611   debug_printf("%s transport entered\n", tblock->name);
4612   for (address_item * addr = addrlist; addr; addr = addr->next)
4613     debug_printf("  %s\n", addr->address);
4614   if (hostlist)
4615     {
4616     debug_printf("hostlist:\n");
4617     for (host_item * host = hostlist; host; host = host->next)
4618       debug_printf("  '%s' IP %s port %d\n", host->name, host->address, host->port);
4619     }
4620   if (continue_hostname)
4621     debug_printf("already connected to %s [%s] (on fd %d)\n",
4622       continue_hostname, continue_host_address,
4623       cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
4624   }
4625
4626 /* Check the restrictions on line length */
4627
4628 if (max_received_linelength > ob->message_linelength_limit)
4629   {
4630   struct timeval now;
4631   gettimeofday(&now, NULL);
4632
4633   for (address_item * addr = addrlist; addr; addr = addr->next)
4634     if (addr->transport_return == DEFER)
4635       addr->transport_return = PENDING_DEFER;
4636
4637   set_errno_nohost(addrlist, ERRNO_SMTPFORMAT,
4638     US"message has lines too long for transport", FAIL, TRUE, &now);
4639   goto END_TRANSPORT;
4640   }
4641
4642 /* Set the flag requesting that these hosts be added to the waiting
4643 database if the delivery fails temporarily or if we are running with
4644 queue_smtp or a 2-stage queue run. This gets unset for certain
4645 kinds of error, typically those that are specific to the message. */
4646
4647 update_waiting =  TRUE;
4648
4649 /* If a host list is not defined for the addresses - they must all have the
4650 same one in order to be passed to a single transport - or if the transport has
4651 a host list with hosts_override set, use the host list supplied with the
4652 transport. It is an error for this not to exist. */
4653
4654 if (!hostlist || (ob->hosts_override && ob->hosts))
4655   {
4656   if (!ob->hosts)
4657     {
4658     addrlist->message = string_sprintf("%s transport called with no hosts set",
4659       tblock->name);
4660     addrlist->transport_return = PANIC;
4661     return FALSE;   /* Only top address has status */
4662     }
4663
4664   DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4665     ob->hosts);
4666
4667   /* If the transport's host list contains no '$' characters, and we are not
4668   randomizing, it is fixed and therefore a chain of hosts can be built once
4669   and for all, and remembered for subsequent use by other calls to this
4670   transport. If, on the other hand, the host list does contain '$', or we are
4671   randomizing its order, we have to rebuild it each time. In the fixed case,
4672   as the hosts string will never be used again, it doesn't matter that we
4673   replace all the : characters with zeros. */
4674
4675   if (!ob->hostlist)
4676     {
4677     uschar *s = ob->hosts;
4678
4679     if (Ustrchr(s, '$') != NULL)
4680       {
4681       if (!(expanded_hosts = expand_string(s)))
4682         {
4683         addrlist->message = string_sprintf("failed to expand list of hosts "
4684           "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4685         addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4686         return FALSE;     /* Only top address has status */
4687         }
4688       DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4689         "\"%s\"\n", s, expanded_hosts);
4690       s = expanded_hosts;
4691       }
4692     else
4693       if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4694
4695     if (is_tainted(s))
4696       {
4697       log_write(0, LOG_MAIN|LOG_PANIC,
4698         "attempt to use tainted host list '%s' from '%s' in transport %s",
4699         s, ob->hosts, tblock->name);
4700       /* Avoid leaking info to an attacker */
4701       addrlist->message = US"internal configuration error";
4702       addrlist->transport_return = PANIC;
4703       return FALSE;
4704       }
4705
4706     host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4707
4708     /* Check that the expansion yielded something useful. */
4709     if (!hostlist)
4710       {
4711       addrlist->message =
4712         string_sprintf("%s transport has empty hosts setting", tblock->name);
4713       addrlist->transport_return = PANIC;
4714       return FALSE;   /* Only top address has status */
4715       }
4716
4717     /* If there was no expansion of hosts, save the host list for
4718     next time. */
4719
4720     if (!expanded_hosts) ob->hostlist = hostlist;
4721     }
4722
4723   /* This is not the first time this transport has been run in this delivery;
4724   the host list was built previously. */
4725
4726   else
4727     hostlist = ob->hostlist;
4728   }
4729
4730 /* The host list was supplied with the address. If hosts_randomize is set, we
4731 must sort it into a random order if it did not come from MX records and has not
4732 already been randomized (but don't bother if continuing down an existing
4733 connection). */
4734
4735 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4736   {
4737   host_item *newlist = NULL;
4738   while (hostlist)
4739     {
4740     host_item *h = hostlist;
4741     hostlist = hostlist->next;
4742
4743     h->sort_key = random_number(100);
4744
4745     if (!newlist)
4746       {
4747       h->next = NULL;
4748       newlist = h;
4749       }
4750     else if (h->sort_key < newlist->sort_key)
4751       {
4752       h->next = newlist;
4753       newlist = h;
4754       }
4755     else
4756       {
4757       host_item *hh = newlist;
4758       while (hh->next)
4759         {
4760         if (h->sort_key < hh->next->sort_key) break;
4761         hh = hh->next;
4762         }
4763       h->next = hh->next;
4764       hh->next = h;
4765       }
4766     }
4767
4768   hostlist = addrlist->host_list = newlist;
4769   }
4770
4771 /* Sort out the default port.  */
4772
4773 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4774
4775 /* For each host-plus-IP-address on the list:
4776
4777 .  If this is a continued delivery and the host isn't the one with the
4778    current connection, skip.
4779
4780 .  If the status is unusable (i.e. previously failed or retry checked), skip.
4781
4782 .  If no IP address set, get the address, either by turning the name into
4783    an address, calling gethostbyname if gethostbyname is on, or by calling
4784    the DNS. The DNS may yield multiple addresses, in which case insert the
4785    extra ones into the list.
4786
4787 .  Get the retry data if not previously obtained for this address and set the
4788    field which remembers the state of this address. Skip if the retry time is
4789    not reached. If not, remember whether retry data was found. The retry string
4790    contains both the name and the IP address.
4791
4792 .  Scan the list of addresses and mark those whose status is DEFER as
4793    PENDING_DEFER. These are the only ones that will be processed in this cycle
4794    of the hosts loop.
4795
4796 .  Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4797    Some addresses may be successfully delivered, others may fail, and yet
4798    others may get temporary errors and so get marked DEFER.
4799
4800 .  The return from the delivery attempt is OK if a connection was made and a
4801    valid SMTP dialogue was completed. Otherwise it is DEFER.
4802
4803 .  If OK, add a "remove" retry item for this host/IPaddress, if any.
4804
4805 .  If fail to connect, or other defer state, add a retry item.
4806
4807 .  If there are any addresses whose status is still DEFER, carry on to the
4808    next host/IPaddress, unless we have tried the number of hosts given
4809    by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4810    there is some fancy logic for hosts_max_try that means its limit can be
4811    overstepped in some circumstances.
4812
4813 If we get to the end of the list, all hosts have deferred at least one address,
4814 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4815 delivery attempt to those hosts whose last try was before the arrival time of
4816 the current message. To cope with this, we have to go round the loop a second
4817 time. After that, set the status and error data for any addresses that haven't
4818 had it set already. */
4819
4820 for (int cutoff_retry = 0;
4821      expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4822      cutoff_retry++)
4823   {
4824   host_item *nexthost = NULL;
4825   int unexpired_hosts_tried = 0;
4826   BOOL continue_host_tried = FALSE;
4827
4828 retry_non_continued:
4829   for (host = hostlist;
4830           host
4831        && unexpired_hosts_tried < ob->hosts_max_try
4832        && total_hosts_tried < ob->hosts_max_try_hardlimit;
4833        host = nexthost)
4834     {
4835     int rc;
4836     int host_af;
4837     BOOL host_is_expired = FALSE;
4838     BOOL message_defer = FALSE;
4839     BOOL some_deferred = FALSE;
4840     address_item *first_addr = NULL;
4841     uschar *interface = NULL;
4842     uschar *retry_host_key = NULL;
4843     uschar *retry_message_key = NULL;
4844     uschar *serialize_key = NULL;
4845
4846     /* Default next host is next host. :-) But this can vary if the
4847     hosts_max_try limit is hit (see below). It may also be reset if a host
4848     address is looked up here (in case the host was multihomed). */
4849
4850     nexthost = host->next;
4851
4852     /* If the address hasn't yet been obtained from the host name, look it up
4853     now, unless the host is already marked as unusable. If it is marked as
4854     unusable, it means that the router was unable to find its IP address (in
4855     the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4856     the lookup failed last time. We don't get this far if *all* MX records
4857     point to non-existent hosts; that is treated as a hard error.
4858
4859     We can just skip this host entirely. When the hosts came from the router,
4860     the address will timeout based on the other host(s); when the address is
4861     looked up below, there is an explicit retry record added.
4862
4863     Note that we mustn't skip unusable hosts if the address is not unset; they
4864     may be needed as expired hosts on the 2nd time round the cutoff loop. */
4865
4866     if (!host->address)
4867       {
4868       int new_port, flags;
4869
4870       if (host->status >= hstatus_unusable)
4871         {
4872         DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4873           host->name);
4874         continue;
4875         }
4876
4877       DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4878
4879       /* The host name is permitted to have an attached port. Find it, and
4880       strip it from the name. Just remember it for now. */
4881
4882       new_port = host_item_get_port(host);
4883
4884       /* Count hosts looked up */
4885
4886       hosts_looked_up++;
4887
4888       /* Find by name if so configured, or if it's an IP address. We don't
4889       just copy the IP address, because we need the test-for-local to happen. */
4890
4891       flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4892       if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4893       if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4894
4895       if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4896         rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4897       else
4898         rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4899           &ob->dnssec,          /* domains for request/require */
4900           NULL, NULL);
4901
4902       /* Update the host (and any additional blocks, resulting from
4903       multihoming) with a host-specific port, if any. */
4904
4905       for (host_item * hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4906
4907       /* Failure to find the host at this time (usually DNS temporary failure)
4908       is really a kind of routing failure rather than a transport failure.
4909       Therefore we add a retry item of the routing kind, not to stop us trying
4910       to look this name up here again, but to ensure the address gets timed
4911       out if the failures go on long enough. A complete failure at this point
4912       commonly points to a configuration error, but the best action is still
4913       to carry on for the next host. */
4914
4915       if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4916         {
4917         retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4918         expired = FALSE;
4919         if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4920         DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4921           "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4922         host->status = hstatus_unusable;
4923
4924         for (address_item * addr = addrlist; addr; addr = addr->next)
4925           {
4926           if (addr->transport_return != DEFER) continue;
4927           addr->basic_errno = ERRNO_UNKNOWNHOST;
4928           addr->message = string_sprintf(
4929             rc == HOST_FIND_SECURITY
4930               ? "lookup of IP address for %s was insecure"
4931               : "failed to lookup IP address for %s",
4932             host->name);
4933           }
4934         continue;
4935         }
4936
4937       /* If the host is actually the local host, we may have a problem, or
4938       there may be some cunning configuration going on. In the problem case,
4939       log things and give up. The default transport status is already DEFER. */
4940
4941       if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4942         {
4943         for (address_item * addr = addrlist; addr; addr = addr->next)
4944           {
4945           addr->basic_errno = ERRNO_HOST_IS_LOCAL;
4946           addr->message = string_sprintf("%s transport found host %s to be "
4947             "local", tblock->name, host->name);
4948           }
4949         goto END_TRANSPORT;
4950         }
4951       }   /* End of block for IP address lookup */
4952
4953     /* If this is a continued delivery, we are interested only in the host
4954     which matches the name of the existing open channel. The check is put
4955     here after the local host lookup, in case the name gets expanded as a
4956     result of the lookup. Set expired FALSE, to save the outer loop executing
4957     twice. */
4958
4959     if (continue_hostname)
4960       if (  Ustrcmp(continue_hostname, host->name) != 0
4961          || Ustrcmp(continue_host_address, host->address) != 0
4962          )
4963         {
4964         expired = FALSE;
4965         continue;      /* With next host */
4966         }
4967       else
4968         continue_host_tried = TRUE;
4969
4970     /* Reset the default next host in case a multihomed host whose addresses
4971     are not looked up till just above added to the host list. */
4972
4973     nexthost = host->next;
4974
4975     /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4976     domain is in queue_smtp_domains, we don't actually want to attempt any
4977     deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4978     there is a lookup defer in queue_smtp_domains, proceed as if the domain
4979     were not in it. We don't want to hold up all SMTP deliveries! Except when
4980     doing a two-stage queue run, don't do this if forcing. */
4981
4982     if (  (!f.deliver_force || f.queue_2stage)
4983        && (  f.queue_smtp
4984           || match_isinlist(addrlist->domain,
4985               CUSS &queue_smtp_domains, 0,
4986               &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK)
4987        )
4988       {
4989       DEBUG(D_transport) debug_printf("first-pass routing only\n");
4990       expired = FALSE;
4991       for (address_item * addr = addrlist; addr; addr = addr->next)
4992         if (addr->transport_return == DEFER)
4993           addr->message = US"first-pass only routing due to -odqs, "
4994                             "queue_smtp_domains or control=queue";
4995       continue;      /* With next host */
4996       }
4997
4998     /* Count hosts being considered - purely for an intelligent comment
4999     if none are usable. */
5000
5001     hosts_total++;
5002
5003     /* Set $host and $host address now in case they are needed for the
5004     interface expansion or the serialize_hosts check; they remain set if an
5005     actual delivery happens. */
5006
5007     deliver_host = host->name;
5008     deliver_host_address = host->address;
5009     lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
5010                                 : host->dnssec == DS_NO ? US"no"
5011                                 : US"";
5012
5013     /* Set up a string for adding to the retry key if the port number is not
5014     the standard SMTP port. A host may have its own port setting that overrides
5015     the default. */
5016
5017     pistring = string_sprintf(":%d", host->port == PORT_NONE
5018       ? defport : host->port);
5019     if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
5020
5021     /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
5022     string is set, even if constant (as different transports can have different
5023     constant settings), we must add it to the key that is used for retries,
5024     because connections to the same host from a different interface should be
5025     treated separately. */
5026
5027     host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
5028       {
5029       uschar * s = ob->interface;
5030       if (s && *s)
5031         {
5032         if (!smtp_get_interface(s, host_af, addrlist, &interface, tid))
5033           return FALSE;
5034         pistring = string_sprintf("%s/%s", pistring, interface);
5035         }
5036       }
5037
5038     /* The first time round the outer loop, check the status of the host by
5039     inspecting the retry data. The second time round, we are interested only
5040     in expired hosts that haven't been tried since this message arrived. */
5041
5042     if (cutoff_retry == 0)
5043       {
5044       BOOL incl_ip;
5045       /* Ensure the status of the address is set by checking retry data if
5046       necessary. There may be host-specific retry data (applicable to all
5047       messages) and also data for retries of a specific message at this host.
5048       If either of these retry records are actually read, the keys used are
5049       returned to save recomputing them later. */
5050
5051       if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5052                 US"retry_include_ip_address", ob->retry_include_ip_address,
5053                 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5054         continue;       /* with next host */
5055
5056       host_is_expired = retry_check_address(addrlist->domain, host, pistring,
5057         incl_ip, &retry_host_key, &retry_message_key);
5058
5059       DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
5060         host->address ? host->address : US"", pistring,
5061         host->status == hstatus_usable ? "usable"
5062         : host->status == hstatus_unusable ? "unusable"
5063         : host->status == hstatus_unusable_expired ? "unusable (expired)" : "?");
5064
5065       /* Skip this address if not usable at this time, noting if it wasn't
5066       actually expired, both locally and in the address. */
5067
5068       switch (host->status)
5069         {
5070         case hstatus_unusable:
5071           expired = FALSE;
5072           setflag(addrlist, af_retry_skipped);
5073           /* Fall through */
5074
5075         case hstatus_unusable_expired:
5076           switch (host->why)
5077             {
5078             case hwhy_retry: hosts_retry++; break;
5079             case hwhy_failed:  hosts_fail++; break;
5080             case hwhy_insecure:
5081             case hwhy_deferred: hosts_defer++; break;
5082             }
5083
5084           /* If there was a retry message key, implying that previously there
5085           was a message-specific defer, we don't want to update the list of
5086           messages waiting for these hosts. */
5087
5088           if (retry_message_key) update_waiting = FALSE;
5089           continue;   /* With the next host or IP address */
5090         }
5091       }
5092
5093     /* Second time round the loop: if the address is set but expired, and
5094     the message is newer than the last try, let it through. */
5095
5096     else
5097       {
5098       if (  !host->address
5099          || host->status != hstatus_unusable_expired
5100          || host->last_try > received_time.tv_sec)
5101         continue;
5102       DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
5103           host->name, host->address, pistring);
5104       host_is_expired = TRUE;
5105       }
5106
5107     /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
5108     it remains TRUE only if all hosts are expired and none are actually tried.
5109     */
5110
5111     expired = FALSE;
5112
5113     /* If this host is listed as one to which access must be serialized,
5114     see if another Exim process has a connection to it, and if so, skip
5115     this host. If not, update the database to record our connection to it
5116     and remember this for later deletion. Do not do any of this if we are
5117     sending the message down a pre-existing connection. */
5118
5119     if (  !continue_hostname
5120        && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
5121       {
5122       serialize_key = string_sprintf("host-serialize-%s", host->name);
5123       if (!enq_start(serialize_key, 1))
5124         {
5125         DEBUG(D_transport)
5126           debug_printf("skipping host %s because another Exim process "
5127             "is connected to it\n", host->name);
5128         hosts_serial++;
5129         continue;
5130         }
5131       }
5132
5133     /* OK, we have an IP address that is not waiting for its retry time to
5134     arrive (it might be expired) OR (second time round the loop) we have an
5135     expired host that hasn't been tried since the message arrived. Have a go
5136     at delivering the message to it. First prepare the addresses by flushing
5137     out the result of previous attempts, and finding the first address that
5138     is still to be delivered. */
5139
5140     first_addr = prepare_addresses(addrlist, host);
5141
5142     DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5143       message_id, host->name, host->address, addrlist->address,
5144       addrlist->next ? ", ..." : "");
5145
5146     set_process_info("delivering %s to %s [%s]%s (%s%s)",
5147       message_id, host->name, host->address, pistring, addrlist->address,
5148       addrlist->next ? ", ..." : "");
5149
5150     /* This is not for real; don't do the delivery. If there are
5151     any remaining hosts, list them. */
5152
5153     if (f.dont_deliver)
5154       {
5155       struct timeval now;
5156       gettimeofday(&now, NULL);
5157       set_errno_nohost(addrlist, 0, NULL, OK, FALSE, &now);
5158       for (address_item * addr = addrlist; addr; addr = addr->next)
5159         {
5160         addr->host_used = host;
5161         addr->special_action = '*';
5162         addr->message = US"delivery bypassed by -N option";
5163         }
5164       DEBUG(D_transport)
5165         {
5166         debug_printf("*** delivery by %s transport bypassed by -N option\n"
5167                      "*** host and remaining hosts:\n", tblock->name);
5168         for (host_item * host2 = host; host2; host2 = host2->next)
5169           debug_printf("    %s [%s]\n", host2->name,
5170             host2->address ? host2->address : US"unset");
5171         }
5172       rc = OK;
5173       }
5174
5175     /* This is for real. If the host is expired, we don't count it for
5176     hosts_max_retry. This ensures that all hosts must expire before an address
5177     is timed out, unless hosts_max_try_hardlimit (which protects against
5178     lunatic DNS configurations) is reached.
5179
5180     If the host is not expired and we are about to hit the hosts_max_retry
5181     limit, check to see if there is a subsequent hosts with a different MX
5182     value. If so, make that the next host, and don't count this one. This is a
5183     heuristic to make sure that different MXs do get tried. With a normal kind
5184     of retry rule, they would get tried anyway when the earlier hosts were
5185     delayed, but if the domain has a "retry every time" type of rule - as is
5186     often used for the the very large ISPs, that won't happen. */
5187
5188     else
5189       {
5190       host_item * thost;
5191       /* Make a copy of the host if it is local to this invocation
5192        of the transport. */
5193
5194       if (expanded_hosts)
5195         {
5196         thost = store_get(sizeof(host_item), FALSE);
5197         *thost = *host;
5198         thost->name = string_copy(host->name);
5199         thost->address = string_copy(host->address);
5200         }
5201       else
5202         thost = host;
5203
5204       if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
5205         {
5206         DEBUG(D_transport)
5207           debug_printf("hosts_max_try limit reached with this host\n");
5208         for (host_item * h = host; h; h = h->next) if (h->mx != host->mx)
5209           {
5210           nexthost = h;
5211           unexpired_hosts_tried--;
5212           DEBUG(D_transport) debug_printf("however, a higher MX host exists "
5213             "and will be tried\n");
5214           break;
5215           }
5216         }
5217
5218       /* Attempt the delivery. */
5219
5220       total_hosts_tried++;
5221       rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5222         &message_defer, FALSE);
5223
5224       /* Yield is one of:
5225          OK     => connection made, each address contains its result;
5226                      message_defer is set for message-specific defers (when all
5227                      recipients are marked defer)
5228          DEFER  => there was a non-message-specific delivery problem;
5229          ERROR  => there was a problem setting up the arguments for a filter,
5230                    or there was a problem with expanding added headers
5231       */
5232
5233       /* If the result is not OK, there was a non-message-specific problem.
5234       If the result is DEFER, we need to write to the logs saying what happened
5235       for this particular host, except in the case of authentication and TLS
5236       failures, where the log has already been written. If all hosts defer a
5237       general message is written at the end. */
5238
5239       if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
5240                       && first_addr->basic_errno != ERRNO_TLSFAILURE)
5241         write_logs(host, first_addr->message, first_addr->basic_errno);
5242
5243 #ifndef DISABLE_EVENT
5244       if (rc == DEFER)
5245         deferred_event_raise(first_addr, host, US"msg:host:defer");
5246 #endif
5247
5248       /* If STARTTLS was accepted, but there was a failure in setting up the
5249       TLS session (usually a certificate screwup), and the host is not in
5250       hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5251       TLS forcibly turned off. We have to start from scratch with a new SMTP
5252       connection. That's why the retry is done from here, not from within
5253       smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5254       session, so the in-clear transmission after those errors, if permitted,
5255       happens inside smtp_deliver().] */
5256
5257 #ifndef DISABLE_TLS
5258       if (  rc == DEFER
5259          && first_addr->basic_errno == ERRNO_TLSFAILURE
5260          && ob->tls_tempfail_tryclear
5261          && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
5262          )
5263         {
5264         log_write(0, LOG_MAIN,
5265           "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5266           first_addr->message, host->name, host->address);
5267         first_addr = prepare_addresses(addrlist, host);
5268         rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5269           &message_defer, TRUE);
5270         if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
5271           write_logs(host, first_addr->message, first_addr->basic_errno);
5272 # ifndef DISABLE_EVENT
5273         if (rc == DEFER)
5274           deferred_event_raise(first_addr, host, US"msg:host:defer");
5275 # endif
5276         }
5277 #endif  /*DISABLE_TLS*/
5278
5279 #ifndef DISABLE_EVENT
5280       /* If the last host gave a defer raise a per-message event */
5281
5282       if (  !(  nexthost
5283              && unexpired_hosts_tried < ob->hosts_max_try
5284              && total_hosts_tried < ob->hosts_max_try_hardlimit
5285              )
5286          && (message_defer || rc == DEFER)
5287          )
5288         deferred_event_raise(first_addr, host, US"msg:defer");
5289 #endif
5290       }
5291
5292     /* Delivery attempt finished */
5293
5294     set_process_info("delivering %s: just tried %s [%s]%s for %s%s: result %s",
5295       message_id, host->name, host->address, pistring, addrlist->address,
5296       addrlist->next ? " (& others)" : "", rc_to_string(rc));
5297
5298     /* Release serialization if set up */
5299
5300     if (serialize_key) enq_end(serialize_key);
5301
5302     /* If the result is DEFER, or if a host retry record is known to exist, we
5303     need to add an item to the retry chain for updating the retry database
5304     at the end of delivery. We only need to add the item to the top address,
5305     of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5306     for any other delivery attempts using the same address. (It is copied into
5307     the unusable tree at the outer level, so even if different address blocks
5308     contain the same address, it still won't get tried again.) */
5309
5310     if (rc == DEFER || retry_host_key)
5311       {
5312       int delete_flag = rc != DEFER ? rf_delete : 0;
5313       if (!retry_host_key)
5314         {
5315         BOOL incl_ip;
5316         if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5317                   US"retry_include_ip_address", ob->retry_include_ip_address,
5318                   ob->expand_retry_include_ip_address, &incl_ip) != OK)
5319           incl_ip = TRUE;       /* error; use most-specific retry record */
5320
5321         retry_host_key = incl_ip
5322           ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
5323           : string_sprintf("T:%S%s", host->name, pistring);
5324         }
5325
5326       /* If a delivery of another message over an existing SMTP connection
5327       yields DEFER, we do NOT set up retry data for the host. This covers the
5328       case when there are delays in routing the addresses in the second message
5329       that are so long that the server times out. This is alleviated by not
5330       routing addresses that previously had routing defers when handling an
5331       existing connection, but even so, this case may occur (e.g. if a
5332       previously happily routed address starts giving routing defers). If the
5333       host is genuinely down, another non-continued message delivery will
5334       notice it soon enough. */
5335
5336       if (delete_flag != 0 || !continue_hostname)
5337         retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
5338
5339       /* We may have tried an expired host, if its retry time has come; ensure
5340       the status reflects the expiry for the benefit of any other addresses. */
5341
5342       if (rc == DEFER)
5343         {
5344         host->status = host_is_expired
5345           ? hstatus_unusable_expired : hstatus_unusable;
5346         host->why = hwhy_deferred;
5347         }
5348       }
5349
5350     /* If message_defer is set (host was OK, but every recipient got deferred
5351     because of some message-specific problem), or if that had happened
5352     previously so that a message retry key exists, add an appropriate item
5353     to the retry chain. Note that if there was a message defer but now there is
5354     a host defer, the message defer record gets deleted. That seems perfectly
5355     reasonable. Also, stop the message from being remembered as waiting
5356     for specific hosts. */
5357
5358     if (message_defer || retry_message_key)
5359       {
5360       int delete_flag = message_defer ? 0 : rf_delete;
5361       if (!retry_message_key)
5362         {
5363         BOOL incl_ip;
5364         if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5365                   US"retry_include_ip_address", ob->retry_include_ip_address,
5366                   ob->expand_retry_include_ip_address, &incl_ip) != OK)
5367           incl_ip = TRUE;       /* error; use most-specific retry record */
5368
5369         retry_message_key = incl_ip
5370           ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
5371               message_id)
5372           : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
5373         }
5374       retry_add_item(addrlist, retry_message_key,
5375         rf_message | rf_host | delete_flag);
5376       update_waiting = FALSE;
5377       }
5378
5379     /* Any return other than DEFER (that is, OK or ERROR) means that the
5380     addresses have got their final statuses filled in for this host. In the OK
5381     case, see if any of them are deferred. */
5382
5383     if (rc == OK)
5384       for (address_item * addr = addrlist; addr; addr = addr->next)
5385         if (addr->transport_return == DEFER)
5386           {
5387           some_deferred = TRUE;
5388           break;
5389           }
5390
5391     /* If no addresses deferred or the result was ERROR, return. We do this for
5392     ERROR because a failing filter set-up or add_headers expansion is likely to
5393     fail for any host we try. */
5394
5395     if (rc == ERROR || (rc == OK && !some_deferred))
5396       {
5397       DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5398       return TRUE;    /* Each address has its status */
5399       }
5400
5401     /* If the result was DEFER or some individual addresses deferred, let
5402     the loop run to try other hosts with the deferred addresses, except for the
5403     case when we were trying to deliver down an existing channel and failed.
5404     Don't try any other hosts in this case. */
5405
5406     if (continue_hostname) break;
5407
5408     /* If the whole delivery, or some individual addresses, were deferred and
5409     there are more hosts that could be tried, do not count this host towards
5410     the hosts_max_try limit if the age of the message is greater than the
5411     maximum retry time for this host. This means we may try try all hosts,
5412     ignoring the limit, when messages have been around for some time. This is
5413     important because if we don't try all hosts, the address will never time
5414     out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5415
5416     if ((rc == DEFER || some_deferred) && nexthost)
5417       {
5418       BOOL timedout;
5419       retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
5420
5421       if (retry && retry->rules)
5422         {
5423         retry_rule *last_rule;
5424         for (last_rule = retry->rules;
5425              last_rule->next;
5426              last_rule = last_rule->next);
5427         timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
5428         }
5429       else timedout = TRUE;    /* No rule => timed out */
5430
5431       if (timedout)
5432         {
5433         unexpired_hosts_tried--;
5434         DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
5435           "hosts_max_try (message older than host's retry time)\n");
5436         }
5437       }
5438
5439     DEBUG(D_transport)
5440       {
5441       if (unexpired_hosts_tried >= ob->hosts_max_try)
5442         debug_printf("reached transport hosts_max_try limit %d\n",
5443           ob->hosts_max_try);
5444       if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5445         debug_printf("reached transport hosts_max_try_hardlimit limit %d\n",
5446           ob->hosts_max_try_hardlimit);
5447       }
5448
5449     testharness_pause_ms(500); /* let server debug out */
5450     }   /* End of loop for trying multiple hosts. */
5451
5452   /* If we failed to find a matching host in the list, for an already-open
5453   connection, just close it and start over with the list.  This can happen
5454   for routing that changes from run to run, or big multi-IP sites with
5455   round-robin DNS. */
5456
5457   if (continue_hostname && !continue_host_tried)
5458     {
5459     int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
5460
5461     DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
5462 #ifndef DISABLE_TLS
5463     /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5464     transport */
5465 /*XXX doublecheck that! */
5466
5467     if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
5468       {
5469       (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
5470       tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
5471       cutthrough.cctx.tls_ctx = NULL;
5472       cutthrough.is_tls = FALSE;
5473       }
5474     else
5475 #else
5476       (void) write(fd, US"QUIT\r\n", 6);
5477 #endif
5478     (void) close(fd);
5479     cutthrough.cctx.sock = -1;
5480     continue_hostname = NULL;
5481     goto retry_non_continued;
5482     }
5483
5484   /* This is the end of the loop that repeats iff expired is TRUE and
5485   ob->delay_after_cutoff is FALSE. The second time round we will
5486   try those hosts that haven't been tried since the message arrived. */
5487
5488   DEBUG(D_transport)
5489     {
5490     debug_printf("all IP addresses skipped or deferred at least one address\n");
5491     if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
5492       debug_printf("retrying IP addresses not tried since message arrived\n");
5493     }
5494   }
5495
5496
5497 /* Get here if all IP addresses are skipped or defer at least one address. In
5498 MUA wrapper mode, this will happen only for connection or other non-message-
5499 specific failures. Force the delivery status for all addresses to FAIL. */
5500
5501 if (mua_wrapper)
5502   {
5503   for (address_item * addr = addrlist; addr; addr = addr->next)
5504     addr->transport_return = FAIL;
5505   goto END_TRANSPORT;
5506   }
5507
5508 /* In the normal, non-wrapper case, add a standard message to each deferred
5509 address if there hasn't been an error, that is, if it hasn't actually been
5510 tried this time. The variable "expired" will be FALSE if any deliveries were
5511 actually tried, or if there was at least one host that was not expired. That
5512 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5513 a delivery has been tried, an error code will be set, and the failing of the
5514 message is handled by the retry code later.
5515
5516 If queue_smtp is set, or this transport was called to send a subsequent message
5517 down an existing TCP/IP connection, and something caused the host not to be
5518 found, we end up here, but can detect these cases and handle them specially. */
5519
5520 for (address_item * addr = addrlist; addr; addr = addr->next)
5521   {
5522   /* If host is not NULL, it means that we stopped processing the host list
5523   because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5524   means we need to behave as if some hosts were skipped because their retry
5525   time had not come. Specifically, this prevents the address from timing out.
5526   However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5527   hosts were tried. */
5528
5529   if (host)
5530     if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5531       {
5532       DEBUG(D_transport)
5533         debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5534           "hosts were tried\n");
5535       }
5536     else
5537       {
5538       DEBUG(D_transport)
5539         debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5540       setflag(addr, af_retry_skipped);
5541       }
5542
5543   if (f.queue_smtp)    /* no deliveries attempted */
5544     {
5545     addr->transport_return = DEFER;
5546     addr->basic_errno = 0;
5547     addr->message = US"SMTP delivery explicitly queued";
5548     }
5549
5550   else if (  addr->transport_return == DEFER
5551           && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
5552           && !addr->message
5553           )
5554     {
5555     addr->basic_errno = ERRNO_HRETRY;
5556     if (continue_hostname)
5557       addr->message = US"no host found for existing SMTP connection";
5558     else if (expired)
5559       {
5560       setflag(addr, af_pass_message);   /* This is not a security risk */
5561       addr->message = string_sprintf(
5562         "all hosts%s have been failing for a long time %s",
5563         addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
5564         ob->delay_after_cutoff
5565         ? US"(and retry time not reached)"
5566         : US"and were last tried after this message arrived");
5567
5568       /* If we are already using fallback hosts, or there are no fallback hosts
5569       defined, convert the result to FAIL to cause a bounce. */
5570
5571       if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
5572         addr->transport_return = FAIL;
5573       }
5574     else
5575       {
5576       const char * s;
5577       if (hosts_retry == hosts_total)
5578         s = "retry time not reached for any host%s";
5579       else if (hosts_fail == hosts_total)
5580         s = "all host address lookups%s failed permanently";
5581       else if (hosts_defer == hosts_total)
5582         s = "all host address lookups%s failed temporarily";
5583       else if (hosts_serial == hosts_total)
5584         s = "connection limit reached for all hosts%s";
5585       else if (hosts_fail+hosts_defer == hosts_total)
5586         s = "all host address lookups%s failed";
5587       else
5588         s = "some host address lookups failed and retry time "
5589         "not reached for other hosts or connection limit reached%s";
5590
5591       addr->message = string_sprintf(s,
5592         addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
5593       }
5594     }
5595   }
5596
5597 /* Update the database which keeps information about which messages are waiting
5598 for which hosts to become available. For some message-specific errors, the
5599 update_waiting flag is turned off because we don't want follow-on deliveries in
5600 those cases.  If this transport instance is explicitly limited to one message
5601 per connection then follow-on deliveries are not possible and there's no need
5602 to create/update the per-transport wait-<transport_name> database. */
5603
5604 if (update_waiting && tblock->connection_max_messages != 1)
5605   transport_update_waiting(hostlist, tblock->name);
5606
5607 END_TRANSPORT:
5608
5609 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5610
5611 return TRUE;   /* Each address has its status */
5612 }
5613
5614 #endif  /*!MACRO_PREDEF*/
5615 /* vi: aw ai sw=2
5616 */
5617 /* End of transport/smtp.c */