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