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