src/src/transports/smtp.c

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