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