src/src/transports/smtp.c

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