src/src/transports/smtp.c

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