src/src/transports/smtp.c

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