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