src/src/transports/smtp.c

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