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