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