tidying: coverity fixes

[exim.git] / src / src / verify.c

diff --git a/src/src/verify.c b/src/src/verify.c
index ea733b60596dae968d61efdd382853cff059ad10..6a50af5069abbf6cbc584189904f685577a7b81f 100644 (file)
--- a/src/src/verify.c
+++ b/src/src/verify.c
@@ -2,7 +2,7 @@
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 

-/* Copyright (c) University of Cambridge 1995 - 2014 */
+/* Copyright (c) University of Cambridge 1995 - 2017 */

 /* See the file NOTICE for conditions of use and distribution. */
 
 /* Functions concerned with verifying things. The original code for callout
 /* See the file NOTICE for conditions of use and distribution. */
 
 /* Functions concerned with verifying things. The original code for callout


@@ -14,7 +14,6 @@ caching was contributed by Kevin Fleming (but I hacked it around a bit). */
 
 #define CUTTHROUGH_CMD_TIMEOUT  30     /* timeout for cutthrough-routing calls */
 #define CUTTHROUGH_DATA_TIMEOUT 60     /* timeout for cutthrough-routing calls */
 
 #define CUTTHROUGH_CMD_TIMEOUT  30     /* timeout for cutthrough-routing calls */
 #define CUTTHROUGH_DATA_TIMEOUT 60     /* timeout for cutthrough-routing calls */

-address_item cutthrough_addr;

 static smtp_outblock ctblock;
 uschar ctbuffer[8192];
 
 static smtp_outblock ctblock;
 uschar ctbuffer[8192];
 


@@ -22,6 +21,7 @@ uschar ctbuffer[8192];
 /* Structure for caching DNSBL lookups */
 
 typedef struct dnsbl_cache_block {
 /* Structure for caching DNSBL lookups */
 
 typedef struct dnsbl_cache_block {

+  time_t expiry;

   dns_address *rhs;
   uschar *text;
   int rc;
   dns_address *rhs;
   uschar *text;
   int rc;


@@ -39,6 +39,8 @@ static tree_node *dnsbl_cache = NULL;
 #define MT_NOT 1
 #define MT_ALL 2
 
 #define MT_NOT 1
 #define MT_ALL 2
 

+static uschar cutthrough_response(int, char, uschar **, int);
+

 
 
 /*************************************************
 
 
 /*************************************************


@@ -58,7 +60,7 @@ Returns:            the cache record if a non-expired one exists, else NULL
 */
 
 static dbdata_callout_cache *
 */
 
 static dbdata_callout_cache *

-get_callout_cache_record(open_db *dbm_file, uschar *key, uschar *type,
+get_callout_cache_record(open_db *dbm_file, const uschar *key, uschar *type,

   int positive_expire, int negative_expire)
 {
 BOOL negative;
   int positive_expire, int negative_expire)
 {
 BOOL negative;


@@ -70,7 +72,7 @@ cache_record = dbfn_read_with_length(dbm_file, key, &length);
 
 if (cache_record == NULL)
   {
 
 if (cache_record == NULL)
   {

-  HDEBUG(D_verify) debug_printf("callout cache: no %s record found\n", type);
+  HDEBUG(D_verify) debug_printf("callout cache: no %s record found for %s\n", type, key);

   return NULL;
   }
 
   return NULL;
   }
 


@@ -84,7 +86,7 @@ now = time(NULL);
 
 if (now - cache_record->time_stamp > expire)
   {
 
 if (now - cache_record->time_stamp > expire)
   {

-  HDEBUG(D_verify) debug_printf("callout cache: %s record expired\n", type);
+  HDEBUG(D_verify) debug_printf("callout cache: %s record expired for %s\n", type, key);

   return NULL;
   }
 
   return NULL;
   }
 


@@ -111,134 +113,53 @@ if (type[0] == 'd' && cache_record->result != ccache_reject)
     cache_record->random_result = ccache_unknown;
   }
 
     cache_record->random_result = ccache_unknown;
   }
 

-HDEBUG(D_verify) debug_printf("callout cache: found %s record\n", type);
+HDEBUG(D_verify) debug_printf("callout cache: found %s record for %s\n", type, key);

 return cache_record;
 }
 
 
 
 return cache_record;
 }
 
 
 

-/*************************************************
-*      Do callout verification for an address    *
-*************************************************/
+/* Check the callout cache.
+Options * pm_mailfrom may be modified by cache partial results.

 
 

-/* This function is called from verify_address() when the address has routed to
-a host list, and a callout has been requested. Callouts are expensive; that is
-why a cache is used to improve the efficiency.
-
-Arguments:
-  addr              the address that's been routed
-  host_list         the list of hosts to try
-  tf                the transport feedback block
-
-  ifstring          "interface" option from transport, or NULL
-  portstring        "port" option from transport, or NULL
-  protocolstring    "protocol" option from transport, or NULL
-  callout           the per-command callout timeout
-  callout_overall   the overall callout timeout (if < 0 use 4*callout)
-  callout_connect   the callout connection timeout (if < 0 use callout)
-  options           the verification options - these bits are used:
-                      vopt_is_recipient => this is a recipient address
-                      vopt_callout_no_cache => don't use callout cache
-                      vopt_callout_fullpm => if postmaster check, do full one
-                      vopt_callout_random => do the "random" thing
-                      vopt_callout_recipsender => use real sender for recipient
-                      vopt_callout_recippmaster => use postmaster for recipient
-  se_mailfrom         MAIL FROM address for sender verify; NULL => ""
-  pm_mailfrom         if non-NULL, do the postmaster check with this sender
-
-Returns:            OK/FAIL/DEFER
+Return: TRUE if result found

 */
 
 */
 

-static int
-do_callout(address_item *addr, host_item *host_list, transport_feedback *tf,
-  int callout, int callout_overall, int callout_connect, int options,
-  uschar *se_mailfrom, uschar *pm_mailfrom)
+static BOOL
+cached_callout_lookup(address_item * addr, uschar * address_key,
+  uschar * from_address, int * opt_ptr, uschar ** pm_ptr,
+  int * yield, uschar ** failure_ptr,
+  dbdata_callout_cache * new_domain_record, int * old_domain_res)

 {
 {

-BOOL is_recipient = (options & vopt_is_recipient) != 0;
-BOOL callout_no_cache = (options & vopt_callout_no_cache) != 0;
-BOOL callout_random = (options & vopt_callout_random) != 0;
-
-int yield = OK;
-int old_domain_cache_result = ccache_accept;
-BOOL done = FALSE;
-uschar *address_key;
-uschar *from_address;
-uschar *random_local_part = NULL;
-uschar *save_deliver_domain = deliver_domain;
-uschar **failure_ptr = is_recipient?
-  &recipient_verify_failure : &sender_verify_failure;
+int options = *opt_ptr;

 open_db dbblock;
 open_db *dbm_file = NULL;
 open_db dbblock;
 open_db *dbm_file = NULL;

-dbdata_callout_cache new_domain_record;
-dbdata_callout_cache_address new_address_record;
-host_item *host;
-time_t callout_start_time;
-
-new_domain_record.result = ccache_unknown;
-new_domain_record.postmaster_result = ccache_unknown;
-new_domain_record.random_result = ccache_unknown;
-
-memset(&new_address_record, 0, sizeof(new_address_record));
-
-/* For a recipient callout, the key used for the address cache record must
-include the sender address if we are using the real sender in the callout,
-because that may influence the result of the callout. */
-
-address_key = addr->address;
-from_address = US"";
-
-if (is_recipient)
-  {
-  if ((options & vopt_callout_recipsender) != 0)
-    {
-    address_key = string_sprintf("%s/<%s>", addr->address, sender_address);
-    from_address = sender_address;
-    }
-  else if ((options & vopt_callout_recippmaster) != 0)
-    {
-    address_key = string_sprintf("%s/<postmaster@%s>", addr->address,
-      qualify_domain_sender);
-    from_address = string_sprintf("postmaster@%s", qualify_domain_sender);
-    }
-  }
-
-/* For a sender callout, we must adjust the key if the mailfrom address is not
-empty. */
-
-else
-  {
-  from_address = (se_mailfrom == NULL)? US"" : se_mailfrom;
-  if (from_address[0] != 0)
-    address_key = string_sprintf("%s/<%s>", addr->address, from_address);
-  }

 
 /* Open the callout cache database, it it exists, for reading only at this
 stage, unless caching has been disabled. */
 
 
 /* Open the callout cache database, it it exists, for reading only at this
 stage, unless caching has been disabled. */
 

-if (callout_no_cache)
+if (options & vopt_callout_no_cache)

   {
   HDEBUG(D_verify) debug_printf("callout cache: disabled by no_cache\n");
   }
   {
   HDEBUG(D_verify) debug_printf("callout cache: disabled by no_cache\n");
   }

-else if ((dbm_file = dbfn_open(US"callout", O_RDWR, &dbblock, FALSE)) == NULL)
+else if (!(dbm_file = dbfn_open(US"callout", O_RDWR, &dbblock, FALSE)))

   {
   HDEBUG(D_verify) debug_printf("callout cache: not available\n");
   }
   {
   HDEBUG(D_verify) debug_printf("callout cache: not available\n");
   }

-
-/* If a cache database is available see if we can avoid the need to do an
-actual callout by making use of previously-obtained data. */
-
-if (dbm_file != NULL)
+else

   {
   {

-  dbdata_callout_cache_address *cache_address_record;
-  dbdata_callout_cache *cache_record = get_callout_cache_record(dbm_file,
-    addr->domain, US"domain",
-    callout_cache_domain_positive_expire,
-    callout_cache_domain_negative_expire);
+  /* If a cache database is available see if we can avoid the need to do an
+  actual callout by making use of previously-obtained data. */
+
+  dbdata_callout_cache_address * cache_address_record;
+  dbdata_callout_cache * cache_record = get_callout_cache_record(dbm_file,
+      addr->domain, US"domain",
+      callout_cache_domain_positive_expire, callout_cache_domain_negative_expire);

 
   /* If an unexpired cache record was found for this domain, see if the callout
   process can be short-circuited. */
 
 
   /* If an unexpired cache record was found for this domain, see if the callout
   process can be short-circuited. */
 

-  if (cache_record != NULL)
+  if (cache_record)

     {
     /* In most cases, if an early command (up to and including MAIL FROM:<>)
     was rejected, there is no point carrying on. The callout fails. However, if
     {
     /* In most cases, if an early command (up to and including MAIL FROM:<>)
     was rejected, there is no point carrying on. The callout fails. However, if


@@ -248,20 +169,21 @@ if (dbm_file != NULL)
     not to disturb the cached domain value if this whole verification succeeds
     (we don't want it turning into "accept"). */
 
     not to disturb the cached domain value if this whole verification succeeds
     (we don't want it turning into "accept"). */
 

-    old_domain_cache_result = cache_record->result;
+    *old_domain_res = cache_record->result;

 
 

-    if (cache_record->result == ccache_reject ||
-         (*from_address == 0 && cache_record->result == ccache_reject_mfnull))
+    if (  cache_record->result == ccache_reject
+       || *from_address == 0 && cache_record->result == ccache_reject_mfnull)

       {
       setflag(addr, af_verify_nsfail);
       HDEBUG(D_verify)
       {
       setflag(addr, af_verify_nsfail);
       HDEBUG(D_verify)

-        debug_printf("callout cache: domain gave initial rejection, or "
-          "does not accept HELO or MAIL FROM:<>\n");
+       debug_printf("callout cache: domain gave initial rejection, or "
+         "does not accept HELO or MAIL FROM:<>\n");

       setflag(addr, af_verify_nsfail);
       addr->user_message = US"(result of an earlier callout reused).";
       setflag(addr, af_verify_nsfail);
       addr->user_message = US"(result of an earlier callout reused).";

-      yield = FAIL;
+      *yield = FAIL;

       *failure_ptr = US"mail";
       *failure_ptr = US"mail";

-      goto END_CALLOUT;
+      dbfn_close(dbm_file);
+      return TRUE;

       }
 
     /* If a previous check on a "random" local part was accepted, we assume
       }
 
     /* If a previous check on a "random" local part was accepted, we assume


@@ -271,26 +193,28 @@ if (dbm_file != NULL)
     the data in the new record. If a random check is required but hasn't been
     done, skip the remaining cache processing. */
 
     the data in the new record. If a random check is required but hasn't been
     done, skip the remaining cache processing. */
 

-    if (callout_random) switch(cache_record->random_result)
+    if (options & vopt_callout_random) switch(cache_record->random_result)

       {
       case ccache_accept:
       {
       case ccache_accept:

-      HDEBUG(D_verify)
-        debug_printf("callout cache: domain accepts random addresses\n");
-      goto END_CALLOUT;     /* Default yield is OK */
+       HDEBUG(D_verify)
+         debug_printf("callout cache: domain accepts random addresses\n");
+       dbfn_close(dbm_file);
+       return TRUE;     /* Default yield is OK */

 
       case ccache_reject:
 
       case ccache_reject:

-      HDEBUG(D_verify)
-        debug_printf("callout cache: domain rejects random addresses\n");
-      callout_random = FALSE;
-      new_domain_record.random_result = ccache_reject;
-      new_domain_record.random_stamp = cache_record->random_stamp;
-      break;
+       HDEBUG(D_verify)
+         debug_printf("callout cache: domain rejects random addresses\n");
+       *opt_ptr = options & ~vopt_callout_random;
+       new_domain_record->random_result = ccache_reject;
+       new_domain_record->random_stamp = cache_record->random_stamp;
+       break;

 
       default:
 
       default:

-      HDEBUG(D_verify)
-        debug_printf("callout cache: need to check random address handling "
-          "(not cached or cache expired)\n");
-      goto END_CACHE;
+       HDEBUG(D_verify)
+         debug_printf("callout cache: need to check random address handling "
+           "(not cached or cache expired)\n");
+       dbfn_close(dbm_file);
+       return FALSE;

       }
 
     /* If a postmaster check is requested, but there was a previous failure,
       }
 
     /* If a postmaster check is requested, but there was a previous failure,


@@ -298,27 +222,29 @@ if (dbm_file != NULL)
     but has not been done before, we are going to have to do a callout, so skip
     remaining cache processing. */
 
     but has not been done before, we are going to have to do a callout, so skip
     remaining cache processing. */
 

-    if (pm_mailfrom != NULL)
+    if (*pm_ptr)

       {
       if (cache_record->postmaster_result == ccache_reject)
       {
       if (cache_record->postmaster_result == ccache_reject)

-        {
-        setflag(addr, af_verify_pmfail);
-        HDEBUG(D_verify)
-          debug_printf("callout cache: domain does not accept "
-            "RCPT TO:<postmaster@domain>\n");
-        yield = FAIL;
-        *failure_ptr = US"postmaster";
-        setflag(addr, af_verify_pmfail);
-        addr->user_message = US"(result of earlier verification reused).";
-        goto END_CALLOUT;
-        }
+       {
+       setflag(addr, af_verify_pmfail);
+       HDEBUG(D_verify)
+         debug_printf("callout cache: domain does not accept "
+           "RCPT TO:<postmaster@domain>\n");
+       *yield = FAIL;
+       *failure_ptr = US"postmaster";
+       setflag(addr, af_verify_pmfail);
+       addr->user_message = US"(result of earlier verification reused).";
+       dbfn_close(dbm_file);
+       return TRUE;
+       }

       if (cache_record->postmaster_result == ccache_unknown)
       if (cache_record->postmaster_result == ccache_unknown)

-        {
-        HDEBUG(D_verify)
-          debug_printf("callout cache: need to check RCPT "
-            "TO:<postmaster@domain> (not cached or cache expired)\n");
-        goto END_CACHE;
-        }
+       {
+       HDEBUG(D_verify)
+         debug_printf("callout cache: need to check RCPT "
+           "TO:<postmaster@domain> (not cached or cache expired)\n");
+       dbfn_close(dbm_file);
+       return FALSE;
+       }

 
       /* If cache says OK, set pm_mailfrom NULL to prevent a redundant
       postmaster check if the address itself has to be checked. Also ensure
 
       /* If cache says OK, set pm_mailfrom NULL to prevent a redundant
       postmaster check if the address itself has to be checked. Also ensure


@@ -326,10 +252,10 @@ if (dbm_file != NULL)
       */
 
       HDEBUG(D_verify) debug_printf("callout cache: domain accepts RCPT "
       */
 
       HDEBUG(D_verify) debug_printf("callout cache: domain accepts RCPT "

-        "TO:<postmaster@domain>\n");
-      pm_mailfrom = NULL;
-      new_domain_record.postmaster_result = ccache_accept;
-      new_domain_record.postmaster_stamp = cache_record->postmaster_stamp;
+       "TO:<postmaster@domain>\n");
+      *pm_ptr = NULL;
+      new_domain_record->postmaster_result = ccache_accept;
+      new_domain_record->postmaster_stamp = cache_record->postmaster_stamp;

       }
     }
 
       }
     }
 


@@ -338,585 +264,684 @@ if (dbm_file != NULL)
   sender address if we are doing a recipient callout with a non-empty sender).
   */
 
   sender address if we are doing a recipient callout with a non-empty sender).
   */
 

-  cache_address_record = (dbdata_callout_cache_address *)
-    get_callout_cache_record(dbm_file,
-      address_key, US"address",
-      callout_cache_positive_expire,
-      callout_cache_negative_expire);
+  if (!(cache_address_record = (dbdata_callout_cache_address *)
+    get_callout_cache_record(dbm_file, address_key, US"address",
+      callout_cache_positive_expire, callout_cache_negative_expire)))
+    {
+    dbfn_close(dbm_file);
+    return FALSE;
+    }

 
 

-  if (cache_address_record != NULL)
+  if (cache_address_record->result == ccache_accept)

     {
     {

-    if (cache_address_record->result == ccache_accept)
-      {
-      HDEBUG(D_verify)
-        debug_printf("callout cache: address record is positive\n");
-      }
-    else
-      {
-      HDEBUG(D_verify)
-        debug_printf("callout cache: address record is negative\n");
-      addr->user_message = US"Previous (cached) callout verification failure";
-      *failure_ptr = US"recipient";
-      yield = FAIL;
-      }
-    goto END_CALLOUT;
+    HDEBUG(D_verify)
+      debug_printf("callout cache: address record is positive\n");
+    }
+  else
+    {
+    HDEBUG(D_verify)
+      debug_printf("callout cache: address record is negative\n");
+    addr->user_message = US"Previous (cached) callout verification failure";
+    *failure_ptr = US"recipient";
+    *yield = FAIL;

     }
 
   /* Close the cache database while we actually do the callout for real. */
 
     }
 
   /* Close the cache database while we actually do the callout for real. */
 

-  END_CACHE:

   dbfn_close(dbm_file);
   dbfn_close(dbm_file);

-  dbm_file = NULL;
+  return TRUE;

   }
   }

+return FALSE;
+}

 
 

-if (!addr->transport)
-  {
-  HDEBUG(D_verify) debug_printf("cannot callout via null transport\n");
-  }
-else if (Ustrcmp(addr->transport->driver_name, "smtp") != 0)
-  log_write(0, LOG_MAIN|LOG_PANIC|LOG_CONFIG_FOR, "callout transport '%s': %s is non-smtp",
-    addr->transport->name, addr->transport->driver_name);
-else
-  {
-  smtp_transport_options_block *ob =
-    (smtp_transport_options_block *)addr->transport->options_block;

 
 

-  /* The information wasn't available in the cache, so we have to do a real
-  callout and save the result in the cache for next time, unless no_cache is set,
-  or unless we have a previously cached negative random result. If we are to test
-  with a random local part, ensure that such a local part is available. If not,
-  log the fact, but carry on without randomming. */
+/* Write results to callout cache
+*/
+static void
+cache_callout_write(dbdata_callout_cache * dom_rec, const uschar * domain,
+  int done, dbdata_callout_cache_address * addr_rec, uschar * address_key)
+{
+open_db dbblock;
+open_db *dbm_file = NULL;
+
+/* If we get here with done == TRUE, a successful callout happened, and yield
+will be set OK or FAIL according to the response to the RCPT command.
+Otherwise, we looped through the hosts but couldn't complete the business.
+However, there may be domain-specific information to cache in both cases.

 
 

-  if (callout_random && callout_random_local_part != NULL)
+The value of the result field in the new_domain record is ccache_unknown if
+there was an error before or with MAIL FROM:, and errno was not zero,
+implying some kind of I/O error. We don't want to write the cache in that case.
+Otherwise the value is ccache_accept, ccache_reject, or ccache_reject_mfnull. */
+
+if (dom_rec->result != ccache_unknown)
+  if (!(dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE)))

     {
     {

-    random_local_part = expand_string(callout_random_local_part);
-    if (random_local_part == NULL)
-      log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
-        "callout_random_local_part: %s", expand_string_message);
+    HDEBUG(D_verify) debug_printf("callout cache: not available\n");
+    }
+  else
+    {
+    (void)dbfn_write(dbm_file, domain, dom_rec,
+      (int)sizeof(dbdata_callout_cache));
+    HDEBUG(D_verify) debug_printf("wrote callout cache domain record for %s:\n"
+      "  result=%d postmaster=%d random=%d\n",
+      domain,
+      dom_rec->result,
+      dom_rec->postmaster_result,
+      dom_rec->random_result);

     }
 
     }
 

-  /* Default the connect and overall callout timeouts if not set, and record the
-  time we are starting so that we can enforce it. */
-
-  if (callout_overall < 0) callout_overall = 4 * callout;
-  if (callout_connect < 0) callout_connect = callout;
-  callout_start_time = time(NULL);
+/* If a definite result was obtained for the callout, cache it unless caching
+is disabled. */

 
 

-  /* Before doing a real callout, if this is an SMTP connection, flush the SMTP
-  output because a callout might take some time. When PIPELINING is active and
-  there are many recipients, the total time for doing lots of callouts can add up
-  and cause the client to time out. So in this case we forgo the PIPELINING
-  optimization. */
+if (done  &&  addr_rec->result != ccache_unknown)
+  {
+  if (!dbm_file)
+    dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE);
+  if (!dbm_file)
+    {
+    HDEBUG(D_verify) debug_printf("no callout cache available\n");
+    }
+  else
+    {
+    (void)dbfn_write(dbm_file, address_key, addr_rec,
+      (int)sizeof(dbdata_callout_cache_address));
+    HDEBUG(D_verify) debug_printf("wrote %s callout cache address record for %s\n",
+      addr_rec->result == ccache_accept ? "positive" : "negative",
+      address_key);
+    }
+  }

 
 

-  if (smtp_out != NULL && !disable_callout_flush) mac_smtp_fflush();
+if (dbm_file) dbfn_close(dbm_file);
+}

 
 

-  /* Now make connections to the hosts and do real callouts. The list of hosts
-  is passed in as an argument. */

 
 

-  for (host = host_list; host != NULL && !done; host = host->next)
-    {
-    smtp_inblock inblock;
-    smtp_outblock outblock;
-    int host_af;
-    int port = 25;
-    BOOL send_quit = TRUE;
-    uschar *active_hostname = smtp_active_hostname;
-    BOOL lmtp;
-    BOOL smtps;
-    BOOL esmtp;
-    BOOL suppress_tls = FALSE;
-    uschar *interface = NULL;  /* Outgoing interface to use; NULL => any */
-    uschar inbuffer[4096];
-    uschar outbuffer[1024];
-    uschar responsebuffer[4096];
+/* Cutthrough-multi.  If the existing cached cutthrough connection matches
+the one we would make for a subsequent recipient, use it.  Send the RCPT TO
+and check the result, nonpipelined as it may be wanted immediately for
+recipient-verification.

 
 

-    clearflag(addr, af_verify_pmfail);  /* postmaster callout flag */
-    clearflag(addr, af_verify_nsfail);  /* null sender callout flag */
+It seems simpler to deal with this case separately from the main callout loop.
+We will need to remember it has sent, or not, so that rcpt-acl tail code
+can do it there for the non-rcpt-verify case.  For this we keep an addresscount.

 
 

-    /* Skip this host if we don't have an IP address for it. */
+Return: TRUE for a definitive result for the recipient
+*/
+static int
+cutthrough_multi(address_item * addr, host_item * host_list,
+  transport_feedback * tf, int * yield)
+{
+BOOL done = FALSE;
+host_item * host;

 
 

-    if (host->address == NULL)
+if (addr->transport == cutthrough.addr.transport)
+  for (host = host_list; host; host = host->next)
+    if (Ustrcmp(host->address, cutthrough.host.address) == 0)

       {
       {

-      DEBUG(D_verify) debug_printf("no IP address for host name %s: skipping\n",
-        host->name);
-      continue;
-      }
-
-    /* Check the overall callout timeout */
+      int host_af;
+      uschar *interface = NULL;  /* Outgoing interface to use; NULL => any */
+      int port = 25;
+
+      deliver_host = host->name;
+      deliver_host_address = host->address;
+      deliver_host_port = host->port;
+      deliver_domain = addr->domain;
+      transport_name = addr->transport->name;
+
+      host_af = Ustrchr(host->address, ':') ? AF_INET6 : AF_INET;
+
+      if (!smtp_get_interface(tf->interface, host_af, addr, &interface,
+             US"callout") ||
+         !smtp_get_port(tf->port, addr, &port, US"callout"))
+       log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
+         addr->message);
+
+      if (  (  interface == cutthrough.interface
+           || (  interface
+              && cutthrough.interface
+              && Ustrcmp(interface, cutthrough.interface) == 0
+           )  )
+        && port == cutthrough.host.port
+        )
+       {
+       uschar * resp = NULL;
+
+       /* Match!  Send the RCPT TO, set done from the response */
+       done =
+         smtp_write_command(&ctblock, SCMD_FLUSH, "RCPT TO:<%.1000s>\r\n",
+           transport_rcpt_address(addr,
+              addr->transport->rcpt_include_affixes)) >= 0 &&
+         cutthrough_response(cutthrough.fd, '2', &resp, CUTTHROUGH_DATA_TIMEOUT) == '2';
+
+       /* This would go horribly wrong if a callout fail was ignored by ACL.
+       We punt by abandoning cutthrough on a reject, like the
+       first-rcpt does. */
+
+       if (done)
+         {
+         address_item * na = store_get(sizeof(address_item));
+         *na = cutthrough.addr;
+         cutthrough.addr = *addr;
+         cutthrough.addr.host_used = &cutthrough.host;
+         cutthrough.addr.next = na;

 
 

-    if (time(NULL) - callout_start_time >= callout_overall)
-      {
-      HDEBUG(D_verify) debug_printf("overall timeout for callout exceeded\n");
-      break;
+         cutthrough.nrcpt++;
+         }
+       else
+         {
+         cancel_cutthrough_connection(TRUE, US"recipient rejected");
+         if (!resp || errno == ETIMEDOUT)
+           {
+           HDEBUG(D_verify) debug_printf("SMTP timeout\n");
+           }
+         else if (errno == 0)
+           {
+           if (*resp == 0)
+             Ustrcpy(resp, US"connection dropped");
+
+           addr->message =
+             string_sprintf("response to \"%s\" was: %s",
+               big_buffer, string_printing(resp));
+
+           addr->user_message =
+             string_sprintf("Callout verification failed:\n%s", resp);
+
+           /* Hard rejection ends the process */
+
+           if (resp[0] == '5')   /* Address rejected */
+             {
+             *yield = FAIL;
+             done = TRUE;
+             }
+           }
+         }
+       }
+      break;   /* host_list */

       }
       }

+if (!done)
+  cancel_cutthrough_connection(TRUE, US"incompatible connection");
+return done;
+}

 
 

-    /* Set IPv4 or IPv6 */
-
-    host_af = (Ustrchr(host->address, ':') == NULL)? AF_INET:AF_INET6;
-
-    /* Expand and interpret the interface and port strings. The latter will not
-    be used if there is a host-specific port (e.g. from a manualroute router).
-    This has to be delayed till now, because they may expand differently for
-    different hosts. If there's a failure, log it, but carry on with the
-    defaults. */
-
-    deliver_host = host->name;
-    deliver_host_address = host->address;
-    deliver_domain = addr->domain;
-
-    if (!smtp_get_interface(tf->interface, host_af, addr, NULL, &interface,
-            US"callout") ||
-        !smtp_get_port(tf->port, addr, &port, US"callout"))
-      log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
-        addr->message);
-
-    /* Set HELO string according to the protocol */
-    lmtp= Ustrcmp(tf->protocol, "lmtp") == 0;
-    smtps= Ustrcmp(tf->protocol, "smtps") == 0;
-
-
-    HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", interface, port);
-
-    /* Set up the buffer for reading SMTP response packets. */
-
-    inblock.buffer = inbuffer;
-    inblock.buffersize = sizeof(inbuffer);
-    inblock.ptr = inbuffer;
-    inblock.ptrend = inbuffer;
-
-    /* Set up the buffer for holding SMTP commands while pipelining */
-
-    outblock.buffer = outbuffer;
-    outblock.buffersize = sizeof(outbuffer);
-    outblock.ptr = outbuffer;
-    outblock.cmd_count = 0;
-    outblock.authenticating = FALSE;
-
-    /* Reset the parameters of a TLS session */
-    tls_out.cipher = tls_out.peerdn = NULL;

 
 

-    /* Connect to the host; on failure, just loop for the next one, but we
-    set the error for the last one. Use the callout_connect timeout. */
+/*************************************************
+*      Do callout verification for an address    *
+*************************************************/

 
 

-    tls_retry_connection:
+/* This function is called from verify_address() when the address has routed to
+a host list, and a callout has been requested. Callouts are expensive; that is
+why a cache is used to improve the efficiency.

 
 

-    inblock.sock = outblock.sock =
-      smtp_connect(host, host_af, port, interface, callout_connect, TRUE, NULL);
-    /* reconsider DSCP here */
-    if (inblock.sock < 0)
-      {
-      addr->message = string_sprintf("could not connect to %s [%s]: %s",
-          host->name, host->address, strerror(errno));
-      deliver_host = deliver_host_address = NULL;
-      deliver_domain = save_deliver_domain;
-      continue;
-      }
+Arguments:
+  addr              the address that's been routed
+  host_list         the list of hosts to try
+  tf                the transport feedback block

 
 

-    /* Expand the helo_data string to find the host name to use. */
+  ifstring          "interface" option from transport, or NULL
+  portstring        "port" option from transport, or NULL
+  protocolstring    "protocol" option from transport, or NULL
+  callout           the per-command callout timeout
+  callout_overall   the overall callout timeout (if < 0 use 4*callout)
+  callout_connect   the callout connection timeout (if < 0 use callout)
+  options           the verification options - these bits are used:
+                      vopt_is_recipient => this is a recipient address
+                      vopt_callout_no_cache => don't use callout cache
+                      vopt_callout_fullpm => if postmaster check, do full one
+                      vopt_callout_random => do the "random" thing
+                      vopt_callout_recipsender => use real sender for recipient
+                      vopt_callout_recippmaster => use postmaster for recipient
+                     vopt_callout_hold         => lazy close connection
+  se_mailfrom         MAIL FROM address for sender verify; NULL => ""
+  pm_mailfrom         if non-NULL, do the postmaster check with this sender

 
 

-    if (tf->helo_data != NULL)
-      {
-      uschar *s = expand_string(tf->helo_data);
-      if (s == NULL)
-        log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: failed to expand transport's "
-          "helo_data value for callout: %s", addr->address,
-          expand_string_message);
-      else active_hostname = s;
-      }
+Returns:            OK/FAIL/DEFER
+*/

 
 

-    deliver_host = deliver_host_address = NULL;
-    deliver_domain = save_deliver_domain;
+static int
+do_callout(address_item *addr, host_item *host_list, transport_feedback *tf,
+  int callout, int callout_overall, int callout_connect, int options,
+  uschar *se_mailfrom, uschar *pm_mailfrom)
+{
+int yield = OK;
+int old_domain_cache_result = ccache_accept;
+BOOL done = FALSE;
+uschar *address_key;
+uschar *from_address;
+uschar *random_local_part = NULL;
+const uschar *save_deliver_domain = deliver_domain;
+uschar **failure_ptr = options & vopt_is_recipient
+  ? &recipient_verify_failure : &sender_verify_failure;
+dbdata_callout_cache new_domain_record;
+dbdata_callout_cache_address new_address_record;
+time_t callout_start_time;

 
 

-    /* Wait for initial response, and send HELO. The smtp_write_command()
-    function leaves its command in big_buffer. This is used in error responses.
-    Initialize it in case the connection is rejected. */
+new_domain_record.result = ccache_unknown;
+new_domain_record.postmaster_result = ccache_unknown;
+new_domain_record.random_result = ccache_unknown;

 
 

-    Ustrcpy(big_buffer, "initial connection");
+memset(&new_address_record, 0, sizeof(new_address_record));

 
 

-    /* Unless ssl-on-connect, wait for the initial greeting */
-    smtps_redo_greeting:
+/* For a recipient callout, the key used for the address cache record must
+include the sender address if we are using the real sender in the callout,
+because that may influence the result of the callout. */

 
 

-    #ifdef SUPPORT_TLS
-    if (!smtps || (smtps && tls_out.active >= 0))
-    #endif
-      if (!(done= smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), '2', callout)))
-        goto RESPONSE_FAILED;
+if (options & vopt_is_recipient)
+  if (options & vopt_callout_recipsender)
+    {
+    from_address = sender_address;
+    address_key = string_sprintf("%s/<%s>", addr->address, sender_address);
+    if (cutthrough.delivery) options |= vopt_callout_no_cache;
+    }
+  else if (options & vopt_callout_recippmaster)
+    {
+    from_address = string_sprintf("postmaster@%s", qualify_domain_sender);
+    address_key = string_sprintf("%s/<postmaster@%s>", addr->address,
+      qualify_domain_sender);
+    }
+  else
+    {
+    from_address = US"";
+    address_key = addr->address;
+    }

 
 

-    /* Not worth checking greeting line for ESMTP support */
-    if (!(esmtp = verify_check_this_host(&(ob->hosts_avoid_esmtp), NULL,
-      host->name, host->address, NULL) != OK))
-      DEBUG(D_transport)
-        debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
+/* For a sender callout, we must adjust the key if the mailfrom address is not
+empty. */

 
 

-    tls_redo_helo:
+else
+  {
+  from_address = se_mailfrom ? se_mailfrom : US"";
+  address_key = *from_address
+    ? string_sprintf("%s/<%s>", addr->address, from_address) : addr->address;
+  }

 
 

-    #ifdef SUPPORT_TLS
-    if (smtps  &&  tls_out.active < 0) /* ssl-on-connect, first pass */
-      {
-      tls_offered = TRUE;
-      ob->tls_tempfail_tryclear = FALSE;
-      }
-      else                             /* all other cases */
-    #endif
+if (cached_callout_lookup(addr, address_key, from_address,
+      &options, &pm_mailfrom, &yield, failure_ptr,
+      &new_domain_record, &old_domain_cache_result))
+  {
+  cancel_cutthrough_connection(TRUE, US"cache-hit");
+  goto END_CALLOUT;
+  }

 
 

-      { esmtp_retry:
+if (!addr->transport)
+  {
+  HDEBUG(D_verify) debug_printf("cannot callout via null transport\n");
+  }
+else if (Ustrcmp(addr->transport->driver_name, "smtp") != 0)
+  log_write(0, LOG_MAIN|LOG_PANIC|LOG_CONFIG_FOR, "callout transport '%s': %s is non-smtp",
+    addr->transport->name, addr->transport->driver_name);
+else
+  {
+  smtp_transport_options_block *ob =
+    (smtp_transport_options_block *)addr->transport->options_block;
+  host_item * host;

 
 

-      if (!(done= smtp_write_command(&outblock, FALSE, "%s %s\r\n",
-        !esmtp? "HELO" : lmtp? "LHLO" : "EHLO", active_hostname) >= 0))
-        goto SEND_FAILED;
-      if (!smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), '2', callout))
-        {
-       if (errno != 0 || responsebuffer[0] == 0 || lmtp || !esmtp || tls_out.active >= 0)
-         {
-         done= FALSE;
-         goto RESPONSE_FAILED;
-         }
-        #ifdef SUPPORT_TLS
-        tls_offered = FALSE;
-        #endif
-        esmtp = FALSE;
-        goto esmtp_retry;                      /* fallback to HELO */
-        }
+  /* The information wasn't available in the cache, so we have to do a real
+  callout and save the result in the cache for next time, unless no_cache is set,
+  or unless we have a previously cached negative random result. If we are to test
+  with a random local part, ensure that such a local part is available. If not,
+  log the fact, but carry on without randomising. */

 
 

-      /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
-      #ifdef SUPPORT_TLS
-      if (esmtp && !suppress_tls &&  tls_out.active < 0)
-        {
-          if (regex_STARTTLS == NULL) regex_STARTTLS =
-           regex_must_compile(US"\\n250[\\s\\-]STARTTLS(\\s|\\n|$)", FALSE, TRUE);
+  if (options & vopt_callout_random  &&  callout_random_local_part)
+    if (!(random_local_part = expand_string(callout_random_local_part)))
+      log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
+        "callout_random_local_part: %s", expand_string_message);

 
 

-          tls_offered = pcre_exec(regex_STARTTLS, NULL, CS responsebuffer,
-                       Ustrlen(responsebuffer), 0, PCRE_EOPT, NULL, 0) >= 0;
-       }
-      else
-        tls_offered = FALSE;
-      #endif
-      }
+  /* Default the connect and overall callout timeouts if not set, and record the
+  time we are starting so that we can enforce it. */

 
 

-    /* If TLS is available on this connection attempt to
-    start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
-    send another EHLO - the server may give a different answer in secure mode. We
-    use a separate buffer for reading the response to STARTTLS so that if it is
-    negative, the original EHLO data is available for subsequent analysis, should
-    the client not be required to use TLS. If the response is bad, copy the buffer
-    for error analysis. */
-
-    #ifdef SUPPORT_TLS
-    if (tls_offered &&
-       verify_check_this_host(&(ob->hosts_avoid_tls), NULL, host->name,
-         host->address, NULL) != OK &&
-       verify_check_this_host(&(ob->hosts_verify_avoid_tls), NULL, host->name,
-         host->address, NULL) != OK
-       )
-      {
-      uschar buffer2[4096];
-      if (  !smtps
-         && !(done= smtp_write_command(&outblock, FALSE, "STARTTLS\r\n") >= 0))
-        goto SEND_FAILED;
-
-      /* If there is an I/O error, transmission of this message is deferred. If
-      there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
-      false, we also defer. However, if there is a temporary rejection of STARTTLS
-      and tls_tempfail_tryclear is true, or if there is an outright rejection of
-      STARTTLS, we carry on. This means we will try to send the message in clear,
-      unless the host is in hosts_require_tls (tested below). */
-
-      if (!smtps && !smtp_read_response(&inblock, buffer2, sizeof(buffer2), '2',
-                       ob->command_timeout))
-        {
-        if (errno != 0 || buffer2[0] == 0 ||
-               (buffer2[0] == '4' && !ob->tls_tempfail_tryclear))
-       {
-       Ustrncpy(responsebuffer, buffer2, sizeof(responsebuffer));
-       done= FALSE;
-       goto RESPONSE_FAILED;
-       }
-        }
+  if (callout_overall < 0) callout_overall = 4 * callout;
+  if (callout_connect < 0) callout_connect = callout;
+  callout_start_time = time(NULL);

 
 

-       /* STARTTLS accepted or ssl-on-connect: try to negotiate a TLS session. */
-      else
-        {
-       int oldtimeout = ob->command_timeout;
-       int rc;
+  /* Before doing a real callout, if this is an SMTP connection, flush the SMTP
+  output because a callout might take some time. When PIPELINING is active and
+  there are many recipients, the total time for doing lots of callouts can add up
+  and cause the client to time out. So in this case we forgo the PIPELINING
+  optimization. */

 
 

-       ob->command_timeout = callout;
-        rc = tls_client_start(inblock.sock, host, addr, ob);
-       ob->command_timeout = oldtimeout;
+  if (smtp_out && !disable_callout_flush) mac_smtp_fflush();

 
 

-        /* TLS negotiation failed; give an error.  Try in clear on a new connection,
-           if the options permit it for this host. */
-        if (rc != OK)
-          {
-       if (rc == DEFER && ob->tls_tempfail_tryclear && !smtps &&
-          verify_check_this_host(&(ob->hosts_require_tls), NULL, host->name,
-            host->address, NULL) != OK)
-         {
-            (void)close(inblock.sock);
-         log_write(0, LOG_MAIN, "TLS session failure: delivering unencrypted "
-           "to %s [%s] (not in hosts_require_tls)", host->name, host->address);
-         suppress_tls = TRUE;
-         goto tls_retry_connection;
-         }
-       /*save_errno = ERRNO_TLSFAILURE;*/
-       /*message = US"failure while setting up TLS session";*/
-       send_quit = FALSE;
-       done= FALSE;
-       goto TLS_FAILED;
-       }
-
-        /* TLS session is set up.  Copy info for logging. */
-        addr->cipher = tls_out.cipher;
-        addr->peerdn = tls_out.peerdn;
-
-        /* For SMTPS we need to wait for the initial OK response, then do HELO. */
-        if (smtps)
-        goto smtps_redo_greeting;
-
-        /* For STARTTLS we need to redo EHLO */
-        goto tls_redo_helo;
-        }
-      }
+  clearflag(addr, af_verify_pmfail);  /* postmaster callout flag */
+  clearflag(addr, af_verify_nsfail);  /* null sender callout flag */

 
 

-    /* If the host is required to use a secure channel, ensure that we have one. */
-    if (tls_out.active < 0)
-      if (verify_check_this_host(&(ob->hosts_require_tls), NULL, host->name,
-       host->address, NULL) == OK)
-        {
-        /*save_errno = ERRNO_TLSREQUIRED;*/
-        log_write(0, LOG_MAIN, "a TLS session is required for %s [%s], but %s",
-          host->name, host->address,
-       tls_offered? "an attempt to start TLS failed" : "the server did not offer TLS support");
-        done= FALSE;
-        goto TLS_FAILED;
-        }
+/* cutthrough-multi: if a nonfirst rcpt has the same routing as the first,
+and we are holding a cutthrough conn open, we can just append the rcpt to
+that conn for verification purposes (and later delivery also).  Simplest
+coding means skipping this whole loop and doing the append separately.  */

 
 

-    #endif /*SUPPORT_TLS*/
+  /* Can we re-use an open cutthrough connection? */
+  if (  cutthrough.fd >= 0
+     && (options & (vopt_callout_recipsender | vopt_callout_recippmaster))
+       == vopt_callout_recipsender
+     && !random_local_part
+     && !pm_mailfrom
+     )
+    done = cutthrough_multi(addr, host_list, tf, &yield);

 
 

-    done = TRUE; /* so far so good; have response to HELO */
+  /* If we did not use a cached connection, make connections to the hosts
+  and do real callouts. The list of hosts is passed in as an argument. */

 
 

-    /*XXX the EHLO response would be analyzed here for IGNOREQUOTA, SIZE, PIPELINING */
+  for (host = host_list; host && !done; host = host->next)
+    {
+    int host_af;
+    int port = 25;
+    uschar *interface = NULL;  /* Outgoing interface to use; NULL => any */
+    smtp_context sx;

 
 

-    /* For now, transport_filter by cutthrough-delivery is not supported */
-    /* Need proper integration with the proper transport mechanism. */
-    if (cutthrough_delivery)
+    if (!host->address)

       {
       {

-      if (addr->transport->filter_command)
-        {
-        cutthrough_delivery= FALSE;
-        HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of transport filter\n");
-        }
-      #ifndef DISABLE_DKIM
-      if (ob->dkim_domain)
-        {
-        cutthrough_delivery= FALSE;
-        HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of DKIM signing\n");
-        }
-      #endif
+      DEBUG(D_verify) debug_printf("no IP address for host name %s: skipping\n",
+        host->name);
+      continue;

       }
 
       }
 

-    SEND_FAILED:
-    RESPONSE_FAILED:
-    TLS_FAILED:
-    ;
-    /* Clear down of the TLS, SMTP and TCP layers on error is handled below.  */
-
-
-    /* Failure to accept HELO is cached; this blocks the whole domain for all
-    senders. I/O errors and defer responses are not cached. */
+    /* Check the overall callout timeout */

 
 

-    if (!done)
+    if (time(NULL) - callout_start_time >= callout_overall)

       {
       {

-      *failure_ptr = US"mail";     /* At or before MAIL */
-      if (errno == 0 && responsebuffer[0] == '5')
-        {
-        setflag(addr, af_verify_nsfail);
-        new_domain_record.result = ccache_reject;
-        }
+      HDEBUG(D_verify) debug_printf("overall timeout for callout exceeded\n");
+      break;

       }
 
       }
 

-    /* If we haven't authenticated, but are required to, give up. */
-    /* Try to AUTH */
+    /* Set IPv4 or IPv6 */
+
+    host_af = Ustrchr(host->address, ':') ? AF_INET6 : AF_INET;

 
 

-    else done = smtp_auth(responsebuffer, sizeof(responsebuffer),
-       addr, host, ob, esmtp, &inblock, &outblock) == OK  &&
+    /* Expand and interpret the interface and port strings. The latter will not
+    be used if there is a host-specific port (e.g. from a manualroute router).
+    This has to be delayed till now, because they may expand differently for
+    different hosts. If there's a failure, log it, but carry on with the
+    defaults. */

 
 

-               /* Copy AUTH info for logging */
-      ( (addr->authenticator = client_authenticator),
-        (addr->auth_id = client_authenticated_id),
+    deliver_host = host->name;
+    deliver_host_address = host->address;
+    deliver_host_port = host->port;
+    deliver_domain = addr->domain;
+    transport_name = addr->transport->name;

 
 

-    /* Build a mail-AUTH string (re-using responsebuffer for convenience */
-        !smtp_mail_auth_str(responsebuffer, sizeof(responsebuffer), addr, ob)
-      )  &&
+    if (  !smtp_get_interface(tf->interface, host_af, addr, &interface,
+            US"callout")
+       || !smtp_get_port(tf->port, addr, &port, US"callout")
+       )
+      log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
+        addr->message);

 
 

-      ( (addr->auth_sndr = client_authenticated_sender),
+    sx.addrlist = addr;
+    sx.host = host;
+    sx.host_af = host_af,
+    sx.port = port;
+    sx.interface = interface;
+    sx.helo_data = tf->helo_data;
+    sx.tblock = addr->transport;
+    sx.verify = TRUE;

 
 

-    /* Send the MAIL command */
-        (smtp_write_command(&outblock, FALSE, "MAIL FROM:<%s>%s\r\n",
-          from_address, responsebuffer) >= 0)
-      )  &&
+tls_retry_connection:
+    /* Set the address state so that errors are recorded in it */

 
 

-      smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
-        '2', callout);
+    addr->transport_return = PENDING_DEFER;
+    ob->connect_timeout = callout_connect;
+    ob->command_timeout = callout;

 
 

-    /* If the host does not accept MAIL FROM:<>, arrange to cache this
-    information, but again, don't record anything for an I/O error or a defer. Do
-    not cache rejections of MAIL when a non-empty sender has been used, because
-    that blocks the whole domain for all senders. */
+    /* Get the channel set up ready for a message (MAIL FROM being the next
+    SMTP command to send.  If we tried TLS but it failed, try again without
+    if permitted */

 
 

-    if (!done)
+    yield = smtp_setup_conn(&sx, FALSE);
+#ifdef SUPPORT_TLS
+    if (  yield == DEFER
+       && addr->basic_errno == ERRNO_TLSFAILURE
+       && ob->tls_tempfail_tryclear
+       && verify_check_given_host(&ob->hosts_require_tls, host) != OK
+       )

       {
       {

-      *failure_ptr = US"mail";     /* At or before MAIL */
-      if (errno == 0 && responsebuffer[0] == '5')
-        {
-        setflag(addr, af_verify_nsfail);
-        if (from_address[0] == 0)
-          new_domain_record.result = ccache_reject_mfnull;
-        }
+      log_write(0, LOG_MAIN,
+       "%s: callout unencrypted to %s [%s] (not in hosts_require_tls)",
+       addr->message, host->name, host->address);
+      addr->transport_return = PENDING_DEFER;
+      yield = smtp_setup_conn(&sx, TRUE);

       }
       }

-
-    /* Otherwise, proceed to check a "random" address (if required), then the
-    given address, and the postmaster address (if required). Between each check,
-    issue RSET, because some servers accept only one recipient after MAIL
-    FROM:<>.
-
-    Before doing this, set the result in the domain cache record to "accept",
-    unless its previous value was ccache_reject_mfnull. In that case, the domain
-    rejects MAIL FROM:<> and we want to continue to remember that. When that is
-    the case, we have got here only in the case of a recipient verification with
-    a non-null sender. */
-
-    else
+#endif
+    if (yield != OK)

       {
       {

-      new_domain_record.result =
-        (old_domain_cache_result == ccache_reject_mfnull)?
-          ccache_reject_mfnull: ccache_accept;
-
-      /* Do the random local part check first */
-
-      if (random_local_part != NULL)
-        {
-        uschar randombuffer[1024];
-        BOOL random_ok =
-          smtp_write_command(&outblock, FALSE,
-            "RCPT TO:<%.1000s@%.1000s>\r\n", random_local_part,
-            addr->domain) >= 0 &&
-          smtp_read_response(&inblock, randombuffer,
-            sizeof(randombuffer), '2', callout);
-
-        /* Remember when we last did a random test */
-
-        new_domain_record.random_stamp = time(NULL);
+      errno = addr->basic_errno;
+      transport_name = NULL;
+      deliver_host = deliver_host_address = NULL;
+      deliver_domain = save_deliver_domain;

 
 

-        /* If accepted, we aren't going to do any further tests below. */
+      /* Failure to accept HELO is cached; this blocks the whole domain for all
+      senders. I/O errors and defer responses are not cached. */

 
 

-        if (random_ok)
-          {
-          new_domain_record.random_result = ccache_accept;
-          }
+      if (yield == FAIL && (errno == 0 || errno == ERRNO_SMTPCLOSED))
+       {
+       setflag(addr, af_verify_nsfail);
+       new_domain_record.result = ccache_reject;
+       done = TRUE;
+       }
+      else
+       done = FALSE;
+      goto no_conn;
+      }

 
 

-        /* Otherwise, cache a real negative response, and get back to the right
-        state to send RCPT. Unless there's some problem such as a dropped
-        connection, we expect to succeed, because the commands succeeded above. */
+    /* If we needed to authenticate, smtp_setup_conn() did that.  Copy
+    the AUTH info for logging */

 
 

-        else if (errno == 0)
-          {
-          if (randombuffer[0] == '5')
-            new_domain_record.random_result = ccache_reject;
-
-          done =
-            smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0 &&
-            smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
-              '2', callout) &&
-
-            smtp_write_command(&outblock, FALSE, "MAIL FROM:<%s>\r\n",
-              from_address) >= 0 &&
-            smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
-              '2', callout);
-          }
-        else done = FALSE;    /* Some timeout/connection problem */
-        }                     /* Random check */
+    addr->authenticator = client_authenticator;
+    addr->auth_id = client_authenticated_id;

 
 

-      /* If the host is accepting all local parts, as determined by the "random"
-      check, we don't need to waste time doing any further checking. */
+    sx.from_addr = from_address;
+    sx.first_addr = sx.sync_addr = addr;
+    sx.ok = FALSE;                     /*XXX these 3 last might not be needed for verify? */
+    sx.send_rset = TRUE;
+    sx.completed_addr = FALSE;

 
 

-      if (new_domain_record.random_result != ccache_accept && done)
-        {
-        /* Get the rcpt_include_affixes flag from the transport if there is one,
-        but assume FALSE if there is not. */
-
-        done =
-          smtp_write_command(&outblock, FALSE, "RCPT TO:<%.1000s>\r\n",
-            transport_rcpt_address(addr,
-              (addr->transport == NULL)? FALSE :
-               addr->transport->rcpt_include_affixes)) >= 0 &&
-          smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
-            '2', callout);
-
-        if (done)
-          new_address_record.result = ccache_accept;
-        else if (errno == 0 && responsebuffer[0] == '5')
-          {
-          *failure_ptr = US"recipient";
-          new_address_record.result = ccache_reject;
-          }
+    new_domain_record.result = old_domain_cache_result == ccache_reject_mfnull
+      ? ccache_reject_mfnull : ccache_accept;

 
 

-        /* Do postmaster check if requested; if a full check is required, we
-        check for RCPT TO:<postmaster> (no domain) in accordance with RFC 821. */
+    /* Do the random local part check first. Temporarily replace the recipient
+    with the "random" value */

 
 

-        if (done && pm_mailfrom != NULL)
-          {
-          /*XXX not suitable for cutthrough - sequencing problems */
-       cutthrough_delivery= FALSE;
-       HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of postmaster verify\n");
+    if (random_local_part)
+      {
+      uschar * main_address = addr->address;
+      const uschar * rcpt_domain = addr->domain;
+
+#ifdef SUPPORT_I18N
+      uschar * errstr = NULL;
+      if (  testflag(addr, af_utf8_downcvt)
+        && (rcpt_domain = string_domain_utf8_to_alabel(rcpt_domain,
+                                   &errstr), errstr)
+        )
+       {
+       addr->message = errstr;
+       errno = ERRNO_EXPANDFAIL;
+       setflag(addr, af_verify_nsfail);
+       done = FALSE;
+       rcpt_domain = US"";  /*XXX errorhandling! */
+       }
+#endif

 
 

-          done =
-            smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0 &&
-            smtp_read_response(&inblock, responsebuffer,
-              sizeof(responsebuffer), '2', callout) &&
+      /* This would be ok for 1st rcpt of a cutthrough (the case handled here;
+      subsequents are done in cutthrough_multi()), but no way to
+      handle a subsequent because of the RSET vaporising the MAIL FROM.
+      So refuse to support any.  Most cutthrough use will not involve
+      random_local_part, so no loss. */
+      cancel_cutthrough_connection(TRUE, US"random-recipient");
+
+      addr->address = string_sprintf("%s@%.1000s",
+                                   random_local_part, rcpt_domain);
+      done = FALSE;
+
+      /* If accepted, we aren't going to do any further tests below.
+      Otherwise, cache a real negative response, and get back to the right
+      state to send RCPT. Unless there's some problem such as a dropped
+      connection, we expect to succeed, because the commands succeeded above.
+      However, some servers drop the connection after responding to an
+      invalid recipient, so on (any) error we drop and remake the connection.
+      XXX We don't care about that for postmaster_full.  Should we?
+
+      XXX could we add another flag to the context, and have the common
+      code emit the RSET too?  Even pipelined after the RCPT...
+      Then the main-verify call could use it if there's to be a subsequent
+      postmaster-verify.
+      The sync_responses() would need to be taught about it and we'd
+      need another return code filtering out to here.
+      */

 
 

-            smtp_write_command(&outblock, FALSE,
-              "MAIL FROM:<%s>\r\n", pm_mailfrom) >= 0 &&
-            smtp_read_response(&inblock, responsebuffer,
-              sizeof(responsebuffer), '2', callout) &&
+      /* Remember when we last did a random test */
+      new_domain_record.random_stamp = time(NULL);

 
 

-            /* First try using the current domain */
+      if (smtp_write_mail_and_rcpt_cmds(&sx, &yield) == 0)
+       switch(addr->transport_return)
+         {
+         case PENDING_OK:
+           new_domain_record.random_result = ccache_accept;
+           break;
+         case FAIL:
+           new_domain_record.random_result = ccache_reject;
+
+           /* Between each check, issue RSET, because some servers accept only
+           one recipient after MAIL FROM:<>.
+           XXX We don't care about that for postmaster_full.  Should we? */
+
+           if ((done =
+             smtp_write_command(&sx.outblock, SCMD_FLUSH, "RSET\r\n") >= 0 &&
+             smtp_read_response(&sx.inblock, sx.buffer, sizeof(sx.buffer),
+               '2', callout)))
+             break;
+
+           HDEBUG(D_acl|D_v)
+             debug_printf_indent("problem after random/rset/mfrom; reopen conn\n");
+           random_local_part = NULL;
+#ifdef SUPPORT_TLS
+           tls_close(FALSE, TRUE);
+#endif
+           HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
+           (void)close(sx.inblock.sock);
+           sx.inblock.sock = sx.outblock.sock = -1;
+#ifndef DISABLE_EVENT
+           (void) event_raise(addr->transport->event_action,
+                             US"tcp:close", NULL);
+#endif
+           addr->address = main_address;
+           addr->transport_return = PENDING_DEFER;
+           sx.first_addr = sx.sync_addr = addr;
+           sx.ok = FALSE;
+           sx.send_rset = TRUE;
+           sx.completed_addr = FALSE;
+           goto tls_retry_connection;
+         }

 
 

-            ((
-            smtp_write_command(&outblock, FALSE,
-              "RCPT TO:<postmaster@%.1000s>\r\n", addr->domain) >= 0 &&
-            smtp_read_response(&inblock, responsebuffer,
-              sizeof(responsebuffer), '2', callout)
-            )
+      /* Re-setup for main verify, or for the error message when failing */
+      addr->address = main_address;
+      addr->transport_return = PENDING_DEFER;
+      sx.first_addr = sx.sync_addr = addr;
+      sx.ok = FALSE;
+      sx.send_rset = TRUE;
+      sx.completed_addr = FALSE;
+      }
+    else
+      done = TRUE;

 
 

-            ||
+    /* Main verify. If the host is accepting all local parts, as determined
+    by the "random" check, we don't need to waste time doing any further
+    checking. */

 
 

-            /* If that doesn't work, and a full check is requested,
-            try without the domain. */
+    if (done)
+      {
+      done = FALSE;
+      switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
+       {
+       case 0:  switch(addr->transport_return) /* ok so far */
+                   {
+                   case PENDING_OK:  done = TRUE;
+                                     new_address_record.result = ccache_accept;
+                                     break;
+                   case FAIL:        done = TRUE;
+                                     yield = FAIL;
+                                     *failure_ptr = US"recipient";
+                                     new_address_record.result = ccache_reject;
+                                     break;
+                   default:          break;
+                   }
+                 break;
+
+       case -1:                                /* MAIL response error */
+                 *failure_ptr = US"mail";
+                 if (errno == 0 && sx.buffer[0] == '5')
+                   {
+                   setflag(addr, af_verify_nsfail);
+                   if (from_address[0] == 0)
+                     new_domain_record.result = ccache_reject_mfnull;
+                   }
+                 break;
+                                               /* non-MAIL read i/o error */
+                                               /* non-MAIL response timeout */
+                                               /* internal error; channel still usable */
+       default:  break;                        /* transmit failed */
+       }
+      }

 
 

-            (
-            (options & vopt_callout_fullpm) != 0 &&
-            smtp_write_command(&outblock, FALSE,
-              "RCPT TO:<postmaster>\r\n") >= 0 &&
-            smtp_read_response(&inblock, responsebuffer,
-              sizeof(responsebuffer), '2', callout)
-            ));
+    addr->auth_sndr = client_authenticated_sender;

 
 

-          /* Sort out the cache record */
+    deliver_host = deliver_host_address = NULL;
+    deliver_domain = save_deliver_domain;

 
 

-          new_domain_record.postmaster_stamp = time(NULL);
+    /* Do postmaster check if requested; if a full check is required, we
+    check for RCPT TO:<postmaster> (no domain) in accordance with RFC 821. */

 
 

-          if (done)
-            new_domain_record.postmaster_result = ccache_accept;
-          else if (errno == 0 && responsebuffer[0] == '5')
-            {
-            *failure_ptr = US"postmaster";
-            setflag(addr, af_verify_pmfail);
-            new_domain_record.postmaster_result = ccache_reject;
-            }
-          }
-        }           /* Random not accepted */
-      }             /* MAIL FROM: accepted */
+    if (done && pm_mailfrom)
+      {
+      /* Could possibly shift before main verify, just above, and be ok
+      for cutthrough.  But no way to handle a subsequent rcpt, so just
+      refuse any */
+      cancel_cutthrough_connection(TRUE, US"postmaster verify");
+      HDEBUG(D_acl|D_v) debug_printf_indent("Cutthrough cancelled by presence of postmaster verify\n");
+
+      done = smtp_write_command(&sx.outblock, SCMD_FLUSH, "RSET\r\n") >= 0
+          && smtp_read_response(&sx.inblock, sx.buffer,
+                               sizeof(sx.buffer), '2', callout);
+
+      if (done)
+       {
+       uschar * main_address = addr->address;
+
+       /*XXX oops, affixes */
+       addr->address = string_sprintf("postmaster@%.1000s", addr->domain);
+       addr->transport_return = PENDING_DEFER;
+
+       sx.from_addr = pm_mailfrom;
+       sx.first_addr = sx.sync_addr = addr;
+       sx.ok = FALSE;
+       sx.send_rset = TRUE;
+       sx.completed_addr = FALSE;
+
+       if(  smtp_write_mail_and_rcpt_cmds(&sx, &yield) == 0
+         && addr->transport_return == PENDING_OK
+         )
+         done = TRUE;
+       else
+         done = (options & vopt_callout_fullpm) != 0
+             && smtp_write_command(&sx.outblock, SCMD_FLUSH,
+                           "RCPT TO:<postmaster>\r\n") >= 0
+             && smtp_read_response(&sx.inblock, sx.buffer,
+                           sizeof(sx.buffer), '2', callout);
+
+       /* Sort out the cache record */
+
+       new_domain_record.postmaster_stamp = time(NULL);
+
+       if (done)
+         new_domain_record.postmaster_result = ccache_accept;
+       else if (errno == 0 && sx.buffer[0] == '5')
+         {
+         *failure_ptr = US"postmaster";
+         setflag(addr, af_verify_pmfail);
+         new_domain_record.postmaster_result = ccache_reject;
+         }

 
 

+       addr->address = main_address;
+       }
+      }

     /* For any failure of the main check, other than a negative response, we just
     close the connection and carry on. We can identify a negative response by the
     fact that errno is zero. For I/O errors it will be non-zero
     /* For any failure of the main check, other than a negative response, we just
     close the connection and carry on. We can identify a negative response by the
     fact that errno is zero. For I/O errors it will be non-zero


@@ -927,158 +952,179 @@ else
     don't give the IP address because this may be an internal host whose identity
     is not to be widely broadcast. */
 
     don't give the IP address because this may be an internal host whose identity
     is not to be widely broadcast. */
 

-    if (!done)
+no_conn:
+    switch(errno)

       {
       {

-      if (errno == ETIMEDOUT)
-        {
-        HDEBUG(D_verify) debug_printf("SMTP timeout\n");
-        send_quit = FALSE;
-        }
-      else if (errno == 0)
-        {
-        if (*responsebuffer == 0) Ustrcpy(responsebuffer, US"connection dropped");
-
-        addr->message =
-          string_sprintf("response to \"%s\" from %s [%s] was: %s",
-            big_buffer, host->name, host->address,
-            string_printing(responsebuffer));
-
-        addr->user_message = is_recipient?
-          string_sprintf("Callout verification failed:\n%s", responsebuffer)
-          :
-          string_sprintf("Called:   %s\nSent:     %s\nResponse: %s",
-            host->address, big_buffer, responsebuffer);
-
-        /* Hard rejection ends the process */
-
-        if (responsebuffer[0] == '5')   /* Address rejected */
-          {
-          yield = FAIL;
-          done = TRUE;
-          }
-        }
+      case ETIMEDOUT:
+       HDEBUG(D_verify) debug_printf("SMTP timeout\n");
+       sx.send_quit = FALSE;
+       break;
+
+#ifdef SUPPORT_I18N
+      case ERRNO_UTF8_FWD:
+       {
+       extern int acl_where;   /* src/acl.c */
+       errno = 0;
+       addr->message = string_sprintf(
+           "response to \"EHLO\" did not include SMTPUTF8");
+       addr->user_message = acl_where == ACL_WHERE_RCPT
+         ? US"533 no support for internationalised mailbox name"
+         : US"550 mailbox unavailable";
+       yield = FAIL;
+       done = TRUE;
+       }
+       break;
+#endif
+      case ECONNREFUSED:
+       sx.send_quit = FALSE;
+       break;
+
+      case 0:
+       if (*sx.buffer == 0) Ustrcpy(sx.buffer, US"connection dropped");
+
+       /*XXX test here is ugly; seem to have a split of responsibility for
+       building this message.  Need to reationalise.  Where is it done
+       before here, and when not?
+       Not == 5xx resp to MAIL on main-verify
+       */
+       if (!addr->message) addr->message =
+         string_sprintf("response to \"%s\" was: %s",
+                         big_buffer, string_printing(sx.buffer));
+
+       addr->user_message = options & vopt_is_recipient
+         ? string_sprintf("Callout verification failed:\n%s", sx.buffer)
+         : string_sprintf("Called:   %s\nSent:     %s\nResponse: %s",
+           host->address, big_buffer, sx.buffer);
+
+       /* Hard rejection ends the process */
+
+       if (sx.buffer[0] == '5')   /* Address rejected */
+         {
+         yield = FAIL;
+         done = TRUE;
+         }
+       break;

       }
 
     /* End the SMTP conversation and close the connection. */
 
       }
 
     /* End the SMTP conversation and close the connection. */
 

-    /* Cutthrough - on a successfull connect and recipient-verify with use-sender
-    and we have no cutthrough conn so far
-    here is where we want to leave the conn open */
-    if (  cutthrough_delivery
+    /* Cutthrough - on a successful connect and recipient-verify with
+    use-sender and we are 1st rcpt and have no cutthrough conn so far
+    here is where we want to leave the conn open.  Ditto for a lazy-close
+    verify. */
+
+    if (  (cutthrough.delivery || options & vopt_callout_hold)
+       && rcpt_count == 1

        && done
        && yield == OK
        && done
        && yield == OK

-       && (options & (vopt_callout_recipsender|vopt_callout_recippmaster)) == vopt_callout_recipsender
+       &&    (options & (vopt_callout_recipsender|vopt_callout_recippmaster|vopt_success_on_redirect))
+          == vopt_callout_recipsender

        && !random_local_part
        && !pm_mailfrom
        && !random_local_part
        && !pm_mailfrom

-       && cutthrough_fd < 0
+       && cutthrough.fd < 0
+       && !sx.lmtp

        )
       {
        )
       {

-      cutthrough_fd= outblock.sock;    /* We assume no buffer in use in the outblock */
-      cutthrough_addr = *addr;         /* Save the address_item for later logging */
-      cutthrough_addr.next =     NULL;
-      cutthrough_addr.host_used = store_get(sizeof(host_item));
-      cutthrough_addr.host_used->name =    host->name;
-      cutthrough_addr.host_used->address = host->address;
-      cutthrough_addr.host_used->port =    port;
+      HDEBUG(D_acl|D_v) debug_printf_indent("holding verify callout open for %s\n",
+       cutthrough.delivery
+       ? "cutthrough delivery" : "potential further verifies and delivery");
+
+      cutthrough.callout_hold_only = !cutthrough.delivery;
+      cutthrough.is_tls =      tls_out.active >= 0;
+      cutthrough.fd =  sx.outblock.sock;       /* We assume no buffer in use in the outblock */
+      cutthrough.nrcpt =       1;
+      cutthrough.transport =   addr->transport->name;
+      cutthrough.interface =   interface;
+      cutthrough.snd_port =    sending_port;
+      cutthrough.peer_options =        smtp_peer_options;
+      cutthrough.host =                *host;
+       {
+       int oldpool = store_pool;
+       store_pool = POOL_PERM;
+       cutthrough.snd_ip = string_copy(sending_ip_address);
+       cutthrough.host.name = string_copy(host->name);
+       cutthrough.host.address = string_copy(host->address);
+       store_pool = oldpool;
+       }
+      cutthrough.addr =                *addr;          /* Save the address_item for later logging */
+      cutthrough.addr.next =   NULL;
+      cutthrough.addr.host_used = &cutthrough.host;

       if (addr->parent)
       if (addr->parent)

-        *(cutthrough_addr.parent = store_get(sizeof(address_item)))= *addr->parent;
+        *(cutthrough.addr.parent = store_get(sizeof(address_item))) =
+         *addr->parent;

       ctblock.buffer = ctbuffer;
       ctblock.buffersize = sizeof(ctbuffer);
       ctblock.ptr = ctbuffer;
       /* ctblock.cmd_count = 0; ctblock.authenticating = FALSE; */
       ctblock.buffer = ctbuffer;
       ctblock.buffersize = sizeof(ctbuffer);
       ctblock.ptr = ctbuffer;
       /* ctblock.cmd_count = 0; ctblock.authenticating = FALSE; */

-      ctblock.sock = cutthrough_fd;
+      ctblock.sock = cutthrough.fd;

       }
     else
       {
       }
     else
       {

-      /* Ensure no cutthrough on multiple address verifies */
+      /* Ensure no cutthrough on multiple verifies that were incompatible */

       if (options & vopt_callout_recipsender)
       if (options & vopt_callout_recipsender)

-        cancel_cutthrough_connection("multiple verify calls");
-      if (send_quit) (void)smtp_write_command(&outblock, FALSE, "QUIT\r\n");
+        cancel_cutthrough_connection(TRUE, US"not usable for cutthrough");
+      if (sx.send_quit)
+       {
+       (void) smtp_write_command(&sx.outblock, SCMD_FLUSH, "QUIT\r\n");
+
+       /* Wait a short time for response, and discard it */
+       smtp_read_response(&sx.inblock, sx.buffer, sizeof(sx.buffer),
+         '2', 1);
+       }

 
 

-      #ifdef SUPPORT_TLS
-      tls_close(FALSE, TRUE);
-      #endif
-      (void)close(inblock.sock);
+      if (sx.inblock.sock >= 0)
+       {
+#ifdef SUPPORT_TLS
+       tls_close(FALSE, TRUE);
+#endif
+       HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
+       (void)close(sx.inblock.sock);
+       sx.inblock.sock = sx.outblock.sock = -1;
+#ifndef DISABLE_EVENT
+       (void) event_raise(addr->transport->event_action, US"tcp:close", NULL);
+#endif
+       }

       }
 
       }
 

+    if (!done || yield != OK)
+      addr->message = string_sprintf("%s [%s] : %s", host->name, host->address,
+                                   addr->message);

     }    /* Loop through all hosts, while !done */
   }
 
 /* If we get here with done == TRUE, a successful callout happened, and yield
 will be set OK or FAIL according to the response to the RCPT command.
 Otherwise, we looped through the hosts but couldn't complete the business.
     }    /* Loop through all hosts, while !done */
   }
 
 /* If we get here with done == TRUE, a successful callout happened, and yield
 will be set OK or FAIL according to the response to the RCPT command.
 Otherwise, we looped through the hosts but couldn't complete the business.

-However, there may be domain-specific information to cache in both cases.
-
-The value of the result field in the new_domain record is ccache_unknown if
-there was an error before or with MAIL FROM:, and errno was not zero,
-implying some kind of I/O error. We don't want to write the cache in that case.
-Otherwise the value is ccache_accept, ccache_reject, or ccache_reject_mfnull. */
-
-if (!callout_no_cache && new_domain_record.result != ccache_unknown)
-  {
-  if ((dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE))
-       == NULL)
-    {
-    HDEBUG(D_verify) debug_printf("callout cache: not available\n");
-    }
-  else
-    {
-    (void)dbfn_write(dbm_file, addr->domain, &new_domain_record,
-      (int)sizeof(dbdata_callout_cache));
-    HDEBUG(D_verify) debug_printf("wrote callout cache domain record:\n"
-      "  result=%d postmaster=%d random=%d\n",
-      new_domain_record.result,
-      new_domain_record.postmaster_result,
-      new_domain_record.random_result);
-    }
-  }
-
-/* If a definite result was obtained for the callout, cache it unless caching
-is disabled. */
+However, there may be domain-specific information to cache in both cases. */

 
 

-if (done)
-  {
-  if (!callout_no_cache && new_address_record.result != ccache_unknown)
-    {
-    if (dbm_file == NULL)
-      dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE);
-    if (dbm_file == NULL)
-      {
-      HDEBUG(D_verify) debug_printf("no callout cache available\n");
-      }
-    else
-      {
-      (void)dbfn_write(dbm_file, address_key, &new_address_record,
-        (int)sizeof(dbdata_callout_cache_address));
-      HDEBUG(D_verify) debug_printf("wrote %s callout cache address record\n",
-        (new_address_record.result == ccache_accept)? "positive" : "negative");
-      }
-    }
-  }    /* done */
+if (!(options & vopt_callout_no_cache))
+  cache_callout_write(&new_domain_record, addr->domain,
+    done, &new_address_record, address_key);

 
 /* Failure to connect to any host, or any response other than 2xx or 5xx is a
 temporary error. If there was only one host, and a response was received, leave
 it alone if supplying details. Otherwise, give a generic response. */
 
 
 /* Failure to connect to any host, or any response other than 2xx or 5xx is a
 temporary error. If there was only one host, and a response was received, leave
 it alone if supplying details. Otherwise, give a generic response. */
 

-else   /* !done */
+if (!done)

   {
   {

-  uschar *dullmsg = string_sprintf("Could not complete %s verify callout",
-    is_recipient? "recipient" : "sender");
+  uschar * dullmsg = string_sprintf("Could not complete %s verify callout",
+    options & vopt_is_recipient ? "recipient" : "sender");

   yield = DEFER;
 
   yield = DEFER;
 

-  if (host_list->next != NULL || addr->message == NULL) addr->message = dullmsg;
+  addr->message = host_list->next || !addr->message
+    ? dullmsg : string_sprintf("%s: %s", dullmsg, addr->message);

 
 

-  addr->user_message = (!smtp_return_error_details)? dullmsg :
-    string_sprintf("%s for <%s>.\n"
+  addr->user_message = smtp_return_error_details
+    ? string_sprintf("%s for <%s>.\n"

       "The mail server(s) for the domain may be temporarily unreachable, or\n"
       "they may be permanently unreachable from this server. In the latter case,\n%s",
       dullmsg, addr->address,
       "The mail server(s) for the domain may be temporarily unreachable, or\n"
       "they may be permanently unreachable from this server. In the latter case,\n%s",
       dullmsg, addr->address,

-      is_recipient?
-        "the address will never be accepted."
-        :
-        "you need to change the address or create an MX record for its domain\n"
-        "if it is supposed to be generally accessible from the Internet.\n"
-        "Talk to your mail administrator for details.");
+      options & vopt_is_recipient
+       ? "the address will never be accepted."
+        : "you need to change the address or create an MX record for its domain\n"
+         "if it is supposed to be generally accessible from the Internet.\n"
+         "Talk to your mail administrator for details.")
+    : dullmsg;

 
   /* Force a specific error code */
 
 
   /* Force a specific error code */
 


@@ -1088,7 +1134,7 @@ else   /* !done */
 /* Come here from within the cache-reading code on fast-track exit. */
 
 END_CALLOUT:
 /* Come here from within the cache-reading code on fast-track exit. */
 
 END_CALLOUT:

-if (dbm_file != NULL) dbfn_close(dbm_file);
+tls_modify_variables(&tls_in);

 return yield;
 }
 
 return yield;
 }
 


@@ -1097,23 +1143,27 @@ return yield;
 /* Called after recipient-acl to get a cutthrough connection open when
    one was requested and a recipient-verify wasn't subsequently done.
 */
 /* Called after recipient-acl to get a cutthrough connection open when
    one was requested and a recipient-verify wasn't subsequently done.
 */

-void
+int

 open_cutthrough_connection( address_item * addr )
 {
 address_item addr2;
 open_cutthrough_connection( address_item * addr )
 {
 address_item addr2;

+int rc;

 
 /* Use a recipient-verify-callout to set up the cutthrough connection. */
 /* We must use a copy of the address for verification, because it might
 get rewritten. */
 
 addr2 = *addr;
 
 /* Use a recipient-verify-callout to set up the cutthrough connection. */
 /* We must use a copy of the address for verification, because it might
 get rewritten. */
 
 addr2 = *addr;

-HDEBUG(D_acl) debug_printf("----------- start cutthrough setup ------------\n");
-(void) verify_address(&addr2, NULL,
+HDEBUG(D_acl) debug_printf_indent("----------- %s cutthrough setup ------------\n",
+  rcpt_count > 1 ? "more" : "start");
+rc = verify_address(&addr2, NULL,

        vopt_is_recipient | vopt_callout_recipsender | vopt_callout_no_cache,
        CUTTHROUGH_CMD_TIMEOUT, -1, -1,
        NULL, NULL, NULL);
        vopt_is_recipient | vopt_callout_recipsender | vopt_callout_no_cache,
        CUTTHROUGH_CMD_TIMEOUT, -1, -1,
        NULL, NULL, NULL);

-HDEBUG(D_acl) debug_printf("----------- end cutthrough setup ------------\n");
-return;
+addr->message = addr2.message;
+addr->user_message = addr2.user_message;
+HDEBUG(D_acl) debug_printf_indent("----------- end cutthrough setup ------------\n");
+return rc;

 }
 
 
 }
 
 


@@ -1122,14 +1172,14 @@ return;
 static BOOL
 cutthrough_send(int n)
 {
 static BOOL
 cutthrough_send(int n)
 {

-if(cutthrough_fd < 0)
+if(cutthrough.fd < 0)

   return TRUE;
 
 if(
 #ifdef SUPPORT_TLS
   return TRUE;
 
 if(
 #ifdef SUPPORT_TLS

-   (tls_out.active == cutthrough_fd) ? tls_write(FALSE, ctblock.buffer, n) :
+   (tls_out.active == cutthrough.fd) ? tls_write(FALSE, ctblock.buffer, n) :

 #endif
 #endif

-   send(cutthrough_fd, ctblock.buffer, n, 0) > 0
+   send(cutthrough.fd, ctblock.buffer, n, 0) > 0

   )
 {
   transport_count += n;
   )
 {
   transport_count += n;


@@ -1137,7 +1187,7 @@ if(
   return TRUE;
 }
 
   return TRUE;
 }
 

-HDEBUG(D_transport|D_acl) debug_printf("cutthrough_send failed: %s\n", strerror(errno));
+HDEBUG(D_transport|D_acl) debug_printf_indent("cutthrough_send failed: %s\n", strerror(errno));

 return FALSE;
 }
 
 return FALSE;
 }
 


@@ -1158,20 +1208,27 @@ return TRUE;
 }
 
 /* Buffered output of counted data block.   Return boolean success */
 }
 
 /* Buffered output of counted data block.   Return boolean success */

-BOOL
+static BOOL

 cutthrough_puts(uschar * cp, int n)
 {
 cutthrough_puts(uschar * cp, int n)
 {

-if (cutthrough_fd < 0)       return TRUE;
+if (cutthrough.fd < 0)       return TRUE;

 if (_cutthrough_puts(cp, n)) return TRUE;
 if (_cutthrough_puts(cp, n)) return TRUE;

-cancel_cutthrough_connection("transmit failed");
+cancel_cutthrough_connection(TRUE, US"transmit failed");

 return FALSE;
 }
 
 return FALSE;
 }
 

+void
+cutthrough_data_puts(uschar * cp, int n)
+{
+if (cutthrough.delivery) (void) cutthrough_puts(cp, n);
+return;
+}
+

 
 static BOOL
 
 static BOOL

-_cutthrough_flush_send( void )
+_cutthrough_flush_send(void)

 {
 {

-int n= ctblock.ptr-ctblock.buffer;
+int n = ctblock.ptr - ctblock.buffer;

 
 if(n>0)
   if(!cutthrough_send(n))
 
 if(n>0)
   if(!cutthrough_send(n))


@@ -1182,24 +1239,31 @@ return TRUE;
 
 /* Send out any bufferred output.  Return boolean success. */
 BOOL
 
 /* Send out any bufferred output.  Return boolean success. */
 BOOL

-cutthrough_flush_send( void )
+cutthrough_flush_send(void)

 {
 if (_cutthrough_flush_send()) return TRUE;
 {
 if (_cutthrough_flush_send()) return TRUE;

-cancel_cutthrough_connection("transmit failed");
+cancel_cutthrough_connection(TRUE, US"transmit failed");

 return FALSE;
 }
 
 
 return FALSE;
 }
 
 

-BOOL
-cutthrough_put_nl( void )
+static BOOL
+cutthrough_put_nl(void)

 {
 return cutthrough_puts(US"\r\n", 2);
 }
 
 
 {
 return cutthrough_puts(US"\r\n", 2);
 }
 
 

+void
+cutthrough_data_put_nl(void)
+{
+cutthrough_data_puts(US"\r\n", 2);
+}
+
+

 /* Get and check response from cutthrough target */
 static uschar
 /* Get and check response from cutthrough target */
 static uschar

-cutthrough_response(char expect, uschar ** copy)
+cutthrough_response(int fd, char expect, uschar ** copy, int timeout)

 {
 smtp_inblock inblock;
 uschar inbuffer[4096];
 {
 smtp_inblock inblock;
 uschar inbuffer[4096];


@@ -1209,15 +1273,15 @@ inblock.buffer = inbuffer;
 inblock.buffersize = sizeof(inbuffer);
 inblock.ptr = inbuffer;
 inblock.ptrend = inbuffer;
 inblock.buffersize = sizeof(inbuffer);
 inblock.ptr = inbuffer;
 inblock.ptrend = inbuffer;

-inblock.sock = cutthrough_fd;
+inblock.sock = fd;

 /* this relies on (inblock.sock == tls_out.active) */
 /* this relies on (inblock.sock == tls_out.active) */

-if(!smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), expect, CUTTHROUGH_DATA_TIMEOUT))
-  cancel_cutthrough_connection("target timeout on read");
+if(!smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), expect, timeout))
+  cancel_cutthrough_connection(TRUE, US"target timeout on read");

 
 

-if(copy != NULL)
+if(copy)

   {
   uschar * cp;
   {
   uschar * cp;

-  *copy= cp= string_copy(responsebuffer);
+  *copy = cp = string_copy(responsebuffer);

   /* Trim the trailing end of line */
   cp += Ustrlen(responsebuffer);
   if(cp > *copy  &&  cp[-1] == '\n') *--cp = '\0';
   /* Trim the trailing end of line */
   cp += Ustrlen(responsebuffer);
   if(cp > *copy  &&  cp[-1] == '\n') *--cp = '\0';


@@ -1230,23 +1294,23 @@ return responsebuffer[0];
 
 /* Negotiate dataphase with the cutthrough target, returning success boolean */
 BOOL
 
 /* Negotiate dataphase with the cutthrough target, returning success boolean */
 BOOL

-cutthrough_predata( void )
+cutthrough_predata(void)

 {
 {

-if(cutthrough_fd < 0)
+if(cutthrough.fd < 0 || cutthrough.callout_hold_only)

   return FALSE;
 
   return FALSE;
 

-HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> DATA\n");
+HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> DATA\n");

 cutthrough_puts(US"DATA\r\n", 6);
 cutthrough_flush_send();
 
 /* Assume nothing buffered.  If it was it gets ignored. */
 cutthrough_puts(US"DATA\r\n", 6);
 cutthrough_flush_send();
 
 /* Assume nothing buffered.  If it was it gets ignored. */

-return cutthrough_response('3', NULL) == '3';
+return cutthrough_response(cutthrough.fd, '3', NULL, CUTTHROUGH_DATA_TIMEOUT) == '3';

 }
 
 
 }
 
 

-/* fd and use_crlf args only to match write_chunk() */
+/* tctx arg only to match write_chunk() */

 static BOOL
 static BOOL

-cutthrough_write_chunk(int fd, uschar * s, int len, BOOL use_crlf)
+cutthrough_write_chunk(transport_ctx * tctx, uschar * s, int len)

 {
 uschar * s2;
 while(s && (s2 = Ustrchr(s, '\n')))
 {
 uschar * s2;
 while(s && (s2 = Ustrchr(s, '\n')))


@@ -1263,57 +1327,79 @@ return TRUE;
 /* Expands newlines to wire format (CR,NL).           */
 /* Also sends header-terminating blank line.          */
 BOOL
 /* Expands newlines to wire format (CR,NL).           */
 /* Also sends header-terminating blank line.          */
 BOOL

-cutthrough_headers_send( void )
+cutthrough_headers_send(void)

 {
 {

-if(cutthrough_fd < 0)
+transport_ctx tctx;
+
+if(cutthrough.fd < 0 || cutthrough.callout_hold_only)

   return FALSE;
 
 /* We share a routine with the mainline transport to handle header add/remove/rewrites,
    but having a separate buffered-output function (for now)
 */
   return FALSE;
 
 /* We share a routine with the mainline transport to handle header add/remove/rewrites,
    but having a separate buffered-output function (for now)
 */

-HDEBUG(D_acl) debug_printf("----------- start cutthrough headers send -----------\n");
+HDEBUG(D_acl) debug_printf_indent("----------- start cutthrough headers send -----------\n");
+
+tctx.u.fd = cutthrough.fd;
+tctx.tblock = cutthrough.addr.transport;
+tctx.addr = &cutthrough.addr;
+tctx.check_string = US".";
+tctx.escape_string = US"..";
+/*XXX check under spool_files_wireformat.  Might be irrelevant */
+tctx.options = topt_use_crlf;

 
 

-if (!transport_headers_send(&cutthrough_addr, cutthrough_fd,
-       cutthrough_addr.transport->add_headers, cutthrough_addr.transport->remove_headers,
-       &cutthrough_write_chunk, TRUE,
-       cutthrough_addr.transport->rewrite_rules, cutthrough_addr.transport->rewrite_existflags))
+if (!transport_headers_send(&tctx, &cutthrough_write_chunk))

   return FALSE;
 
   return FALSE;
 

-HDEBUG(D_acl) debug_printf("----------- done cutthrough headers send ------------\n");
+HDEBUG(D_acl) debug_printf_indent("----------- done cutthrough headers send ------------\n");

 return TRUE;
 }
 
 
 static void
 return TRUE;
 }
 
 
 static void

-close_cutthrough_connection( const char * why )
+close_cutthrough_connection(const uschar * why)

 {
 {

-if(cutthrough_fd >= 0)
+int fd = cutthrough.fd;
+if(fd >= 0)

   {
   /* We could be sending this after a bunch of data, but that is ok as
      the only way to cancel the transfer in dataphase is to drop the tcp
      conn before the final dot.
   */
   ctblock.ptr = ctbuffer;
   {
   /* We could be sending this after a bunch of data, but that is ok as
      the only way to cancel the transfer in dataphase is to drop the tcp
      conn before the final dot.
   */
   ctblock.ptr = ctbuffer;

-  HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> QUIT\n");
+  HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> QUIT\n");

   _cutthrough_puts(US"QUIT\r\n", 6);   /* avoid recursion */
   _cutthrough_flush_send();
   _cutthrough_puts(US"QUIT\r\n", 6);   /* avoid recursion */
   _cutthrough_flush_send();

-  /* No wait for response */
+  cutthrough.fd = -1;                  /* avoid recursion via read timeout */

 
 

-  #ifdef SUPPORT_TLS
+  /* Wait a short time for response, and discard it */
+  cutthrough_response(fd, '2', NULL, 1);
+
+#ifdef SUPPORT_TLS

   tls_close(FALSE, TRUE);
   tls_close(FALSE, TRUE);

-  #endif
-  (void)close(cutthrough_fd);
-  cutthrough_fd= -1;
-  HDEBUG(D_acl) debug_printf("----------- cutthrough shutdown (%s) ------------\n", why);
+#endif
+  HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
+  (void)close(fd);
+  HDEBUG(D_acl) debug_printf_indent("----------- cutthrough shutdown (%s) ------------\n", why);

   }
 ctblock.ptr = ctbuffer;
 }
 
 void
   }
 ctblock.ptr = ctbuffer;
 }
 
 void

-cancel_cutthrough_connection( const char * why )
+cancel_cutthrough_connection(BOOL close_noncutthrough_verifies, const uschar * why)
+{
+if (cutthrough.delivery || close_noncutthrough_verifies)
+  close_cutthrough_connection(why);
+cutthrough.delivery = cutthrough.callout_hold_only = FALSE;
+}
+
+
+void
+release_cutthrough_connection(const uschar * why)

 {
 {

-close_cutthrough_connection(why);
-cutthrough_delivery= FALSE;
+if (cutthrough.fd < 0) return;
+HDEBUG(D_acl) debug_printf_indent("release cutthrough conn: %s\n", why);
+cutthrough.fd = -1;
+cutthrough.delivery = cutthrough.callout_hold_only = FALSE;

 }
 
 
 }
 
 


@@ -1325,33 +1411,45 @@ cutthrough_delivery= FALSE;
    Return smtp response-class digit.
 */
 uschar *
    Return smtp response-class digit.
 */
 uschar *

-cutthrough_finaldot( void )
+cutthrough_finaldot(void)

 {
 {

-HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> .\n");
+uschar res;
+address_item * addr;
+HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> .\n");

 
 /* Assume data finshed with new-line */
 
 /* Assume data finshed with new-line */

-if(!cutthrough_puts(US".", 1) || !cutthrough_put_nl() || !cutthrough_flush_send())
-  return cutthrough_addr.message;
+if(  !cutthrough_puts(US".", 1)
+  || !cutthrough_put_nl()
+  || !cutthrough_flush_send()
+  )
+  return cutthrough.addr.message;

 
 

-switch(cutthrough_response('2', &cutthrough_addr.message))
+res = cutthrough_response(cutthrough.fd, '2', &cutthrough.addr.message, CUTTHROUGH_DATA_TIMEOUT);
+for (addr = &cutthrough.addr; addr; addr = addr->next)

   {
   {

-  case '2':
-    delivery_log(LOG_MAIN, &cutthrough_addr, (int)'>', NULL);
-    close_cutthrough_connection("delivered");
-    break;
+  addr->message = cutthrough.addr.message;
+  switch(res)
+    {
+    case '2':
+      delivery_log(LOG_MAIN, addr, (int)'>', NULL);
+      close_cutthrough_connection(US"delivered");
+      break;

 
 

-  case '4':
-    delivery_log(LOG_MAIN, &cutthrough_addr, 0, US"tmp-reject from cutthrough after DATA:");
-    break;
+    case '4':
+      delivery_log(LOG_MAIN, addr, 0,
+       US"tmp-reject from cutthrough after DATA:");
+      break;

 
 

-  case '5':
-    delivery_log(LOG_MAIN|LOG_REJECT, &cutthrough_addr, 0, US"rejected after DATA:");
-    break;
+    case '5':
+      delivery_log(LOG_MAIN|LOG_REJECT, addr, 0,
+       US"rejected after DATA:");
+      break;

 
 

-  default:
-    break;
+    default:
+      break;
+    }

   }
   }

-  return cutthrough_addr.message;
+return cutthrough.addr.message;

 }
 
 
 }
 
 


@@ -1382,7 +1480,7 @@ if (addr != vaddr)
   vaddr->user_message = addr->user_message;
   vaddr->basic_errno = addr->basic_errno;
   vaddr->more_errno = addr->more_errno;
   vaddr->user_message = addr->user_message;
   vaddr->basic_errno = addr->basic_errno;
   vaddr->more_errno = addr->more_errno;

-  vaddr->p.address_data = addr->p.address_data;
+  vaddr->prop.address_data = addr->prop.address_data;

   copyflag(vaddr, addr, af_pass_message);
   }
 return yield;
   copyflag(vaddr, addr, af_pass_message);
   }
 return yield;


@@ -1484,21 +1582,20 @@ verify_address(address_item *vaddr, FILE *f, int options, int callout,
 {
 BOOL allok = TRUE;
 BOOL full_info = (f == NULL)? FALSE : (debug_selector != 0);
 {
 BOOL allok = TRUE;
 BOOL full_info = (f == NULL)? FALSE : (debug_selector != 0);

-BOOL is_recipient = (options & vopt_is_recipient) != 0;

 BOOL expn         = (options & vopt_expn) != 0;
 BOOL success_on_redirect = (options & vopt_success_on_redirect) != 0;
 int i;
 int yield = OK;
 int verify_type = expn? v_expn :
      address_test_mode? v_none :
 BOOL expn         = (options & vopt_expn) != 0;
 BOOL success_on_redirect = (options & vopt_success_on_redirect) != 0;
 int i;
 int yield = OK;
 int verify_type = expn? v_expn :
      address_test_mode? v_none :

-          is_recipient? v_recipient : v_sender;
+          options & vopt_is_recipient? v_recipient : v_sender;

 address_item *addr_list;
 address_item *addr_new = NULL;
 address_item *addr_remote = NULL;
 address_item *addr_local = NULL;
 address_item *addr_succeed = NULL;
 address_item *addr_list;
 address_item *addr_new = NULL;
 address_item *addr_remote = NULL;
 address_item *addr_local = NULL;
 address_item *addr_succeed = NULL;

-uschar **failure_ptr = is_recipient?
-  &recipient_verify_failure : &sender_verify_failure;
+uschar **failure_ptr = options & vopt_is_recipient
+  ? &recipient_verify_failure : &sender_verify_failure;

 uschar *ko_prefix, *cr;
 uschar *address = vaddr->address;
 uschar *save_sender;
 uschar *ko_prefix, *cr;
 uschar *address = vaddr->address;
 uschar *save_sender;


@@ -1531,7 +1628,7 @@ if (parse_find_at(address) == NULL)
     *failure_ptr = US"qualify";
     return FAIL;
     }
     *failure_ptr = US"qualify";
     return FAIL;
     }

-  address = rewrite_address_qualify(address, is_recipient);
+  address = rewrite_address_qualify(address, options & vopt_is_recipient);

   }
 
 DEBUG(D_verify)
   }
 
 DEBUG(D_verify)


@@ -1546,7 +1643,7 @@ may have been set by domains and local part tests during an ACL. */
 if (global_rewrite_rules != NULL)
   {
   uschar *old = address;
 if (global_rewrite_rules != NULL)
   {
   uschar *old = address;

-  address = rewrite_address(address, is_recipient, FALSE,
+  address = rewrite_address(address, options & vopt_is_recipient, FALSE,

     global_rewrite_rules, rewrite_existflags);
   if (address != old)
     {
     global_rewrite_rules, rewrite_existflags);
   if (address != old)
     {


@@ -1570,7 +1667,7 @@ if (address[0] == 0) return OK;
 
 /* Flip the legacy TLS-related variables over to the outbound set in case
 they're used in the context of a transport used by verification. Reset them
 
 /* Flip the legacy TLS-related variables over to the outbound set in case
 they're used in the context of a transport used by verification. Reset them

-at exit from this routine. */
+at exit from this routine (so no returns allowed from here on). */

 
 tls_modify_variables(&tls_out);
 
 
 tls_modify_variables(&tls_out);
 


@@ -1579,6 +1676,10 @@ while verifying a sender address (a nice bit of self-reference there). */
 
 save_sender = sender_address;
 
 
 save_sender = sender_address;
 

+/* Observability variable for router/transport use */
+
+verify_mode = options & vopt_is_recipient ? US"R" : US"S";
+

 /* Update the address structure with the possibly qualified and rewritten
 address. Set it up as the starting address on the chain of new addresses. */
 
 /* Update the address structure with the possibly qualified and rewritten
 address. Set it up as the starting address on the chain of new addresses. */
 


@@ -1594,7 +1695,7 @@ If an address generates more than one child, the loop is used only when
 full_info is set, and this can only be set locally. Remote enquiries just get
 information about the top level address, not anything that it generated. */
 
 full_info is set, and this can only be set locally. Remote enquiries just get
 information about the top level address, not anything that it generated. */
 

-while (addr_new != NULL)
+while (addr_new)

   {
   int rc;
   address_item *addr = addr_new;
   {
   int rc;
   address_item *addr = addr_new;


@@ -1643,18 +1744,18 @@ while (addr_new != NULL)
 
   /* Just in case some router parameter refers to it. */
 
 
   /* Just in case some router parameter refers to it. */
 

-  return_path = (addr->p.errors_address != NULL)?
-    addr->p.errors_address : sender_address;
+  return_path = addr->prop.errors_address
+    ? addr->prop.errors_address : sender_address;

 
   /* Split the address into domain and local part, handling the %-hack if
   necessary, and then route it. While routing a sender address, set
   $sender_address to <> because that is what it will be if we were trying to
   send a bounce to the sender. */
 
 
   /* Split the address into domain and local part, handling the %-hack if
   necessary, and then route it. While routing a sender address, set
   $sender_address to <> because that is what it will be if we were trying to
   send a bounce to the sender. */
 

-  if (routed != NULL) *routed = FALSE;
+  if (routed) *routed = FALSE;

   if ((rc = deliver_split_address(addr)) == OK)
     {
   if ((rc = deliver_split_address(addr)) == OK)
     {

-    if (!is_recipient) sender_address = null_sender;
+    if (!(options & vopt_is_recipient)) sender_address = null_sender;

     rc = route_address(addr, &addr_local, &addr_remote, &addr_new,
       &addr_succeed, verify_type);
     sender_address = save_sender;     /* Put back the real sender */
     rc = route_address(addr, &addr_local, &addr_remote, &addr_new,
       &addr_succeed, verify_type);
     sender_address = save_sender;     /* Put back the real sender */


@@ -1668,10 +1769,11 @@ while (addr_new != NULL)
 
   if (rc == OK)
     {
 
   if (rc == OK)
     {

-    if (routed != NULL) *routed = TRUE;
+    if (routed) *routed = TRUE;

     if (callout > 0)
       {
     if (callout > 0)
       {

-      host_item *host_list = addr->host_list;
+      transport_instance * tp;
+      host_item * host_list = addr->host_list;

 
       /* Make up some data for use in the case where there is no remote
       transport. */
 
       /* Make up some data for use in the case where there is no remote
       transport. */


@@ -1693,18 +1795,18 @@ while (addr_new != NULL)
       transport's options, so as to mimic what would happen if we were really
       sending a message to this address. */
 
       transport's options, so as to mimic what would happen if we were really
       sending a message to this address. */
 

-      if (addr->transport != NULL && !addr->transport->info->local)
+      if ((tp = addr->transport) && !tp->info->local)

         {
         {

-        (void)(addr->transport->setup)(addr->transport, addr, &tf, 0, 0, NULL);
+        (void)(tp->setup)(tp, addr, &tf, 0, 0, NULL);

 
         /* If the transport has hosts and the router does not, or if the
         transport is configured to override the router's hosts, we must build a
         host list of the transport's hosts, and find the IP addresses */
 
 
         /* If the transport has hosts and the router does not, or if the
         transport is configured to override the router's hosts, we must build a
         host list of the transport's hosts, and find the IP addresses */
 

-        if (tf.hosts != NULL && (host_list == NULL || tf.hosts_override))
+        if (tf.hosts && (!host_list || tf.hosts_override))

           {
           uschar *s;
           {
           uschar *s;

-          uschar *save_deliver_domain = deliver_domain;
+          const uschar *save_deliver_domain = deliver_domain;

           uschar *save_deliver_localpart = deliver_localpart;
 
           host_list = NULL;    /* Ignore the router's hosts */
           uschar *save_deliver_localpart = deliver_localpart;
 
           host_list = NULL;    /* Ignore the router's hosts */


@@ -1715,16 +1817,15 @@ while (addr_new != NULL)
           deliver_domain = save_deliver_domain;
           deliver_localpart = save_deliver_localpart;
 
           deliver_domain = save_deliver_domain;
           deliver_localpart = save_deliver_localpart;
 

-          if (s == NULL)
+          if (!s)

             {
             log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand list of hosts "
               "\"%s\" in %s transport for callout: %s", tf.hosts,
             {
             log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand list of hosts "
               "\"%s\" in %s transport for callout: %s", tf.hosts,

-              addr->transport->name, expand_string_message);
+              tp->name, expand_string_message);

             }
           else
             {
             int flags;
             }
           else
             {
             int flags;

-            uschar *canonical_name;

             host_item *host, *nexthost;
             host_build_hostlist(&host_list, s, tf.hosts_randomize);
 
             host_item *host, *nexthost;
             host_build_hostlist(&host_list, s, tf.hosts_randomize);
 


@@ -1738,26 +1839,24 @@ while (addr_new != NULL)
             if (tf.qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
             if (tf.search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
 
             if (tf.qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
             if (tf.search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
 

-            for (host = host_list; host != NULL; host = nexthost)
+            for (host = host_list; host; host = nexthost)

               {
               nexthost = host->next;
               if (tf.gethostbyname ||
                   string_is_ip_address(host->name, NULL) != 0)
               {
               nexthost = host->next;
               if (tf.gethostbyname ||
                   string_is_ip_address(host->name, NULL) != 0)

-                (void)host_find_byname(host, NULL, flags, &canonical_name, TRUE);
+                (void)host_find_byname(host, NULL, flags, NULL, TRUE);

               else
                {
               else
                {

-               uschar * d_request = NULL, * d_require = NULL;
-               if (Ustrcmp(addr->transport->driver_name, "smtp") == 0)
+               dnssec_domains * dnssec_domains = NULL;
+               if (Ustrcmp(tp->driver_name, "smtp") == 0)

                  {
                  smtp_transport_options_block * ob =
                  {
                  smtp_transport_options_block * ob =

-                     (smtp_transport_options_block *)
-                       addr->transport->options_block;
-                 d_request = ob->dnssec_request_domains;
-                 d_require = ob->dnssec_require_domains;
+                     (smtp_transport_options_block *) tp->options_block;
+                 dnssec_domains = &ob->dnssec;

                  }
 
                  }
 

-                (void)host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
-                 d_request, d_require, &canonical_name, NULL);
+                (void) host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
+                 dnssec_domains, NULL, NULL);

                }
               }
             }
                }
               }
             }


@@ -1767,7 +1866,7 @@ while (addr_new != NULL)
       /* Can only do a callout if we have at least one host! If the callout
       fails, it will have set ${sender,recipient}_verify_failure. */
 
       /* Can only do a callout if we have at least one host! If the callout
       fails, it will have set ${sender,recipient}_verify_failure. */
 

-      if (host_list != NULL)
+      if (host_list)

         {
         HDEBUG(D_verify) debug_printf("Attempting full verification using callout\n");
         if (host_checking && !host_checking_callout)
         {
         HDEBUG(D_verify) debug_printf("Attempting full verification using callout\n");
         if (host_checking && !host_checking_callout)


@@ -1808,38 +1907,38 @@ while (addr_new != NULL)
   if (rc == FAIL)
     {
     allok = FALSE;
   if (rc == FAIL)
     {
     allok = FALSE;

-    if (f != NULL)
+    if (f)

       {
       address_item *p = addr->parent;
 
       respond_printf(f, "%s%s %s", ko_prefix,
       {
       address_item *p = addr->parent;
 
       respond_printf(f, "%s%s %s", ko_prefix,

-        full_info? addr->address : address,
-        address_test_mode? "is undeliverable" : "failed to verify");
+        full_info ? addr->address : address,
+        address_test_mode ? "is undeliverable" : "failed to verify");

       if (!expn && admin_user)
         {
         if (addr->basic_errno > 0)
           respond_printf(f, ": %s", strerror(addr->basic_errno));
       if (!expn && admin_user)
         {
         if (addr->basic_errno > 0)
           respond_printf(f, ": %s", strerror(addr->basic_errno));

-        if (addr->message != NULL)
+        if (addr->message)

           respond_printf(f, ": %s", addr->message);
         }
 
       /* Show parents iff doing full info */
 
           respond_printf(f, ": %s", addr->message);
         }
 
       /* Show parents iff doing full info */
 

-      if (full_info) while (p != NULL)
+      if (full_info) while (p)

         {
         respond_printf(f, "%s\n    <-- %s", cr, p->address);
         p = p->parent;
         }
       respond_printf(f, "%s\n", cr);
       }
         {
         respond_printf(f, "%s\n    <-- %s", cr, p->address);
         p = p->parent;
         }
       respond_printf(f, "%s\n", cr);
       }

-    cancel_cutthrough_connection("routing hard fail");
+    cancel_cutthrough_connection(TRUE, US"routing hard fail");

 
     if (!full_info)
 
     if (!full_info)

-    {
+      {

       yield = copy_error(vaddr, addr, FAIL);
       goto out;
       yield = copy_error(vaddr, addr, FAIL);
       goto out;

-    }
-    else yield = FAIL;
+      }
+    yield = FAIL;

     }
 
   /* Soft failure */
     }
 
   /* Soft failure */


@@ -1847,7 +1946,7 @@ while (addr_new != NULL)
   else if (rc == DEFER)
     {
     allok = FALSE;
   else if (rc == DEFER)
     {
     allok = FALSE;

-    if (f != NULL)
+    if (f)

       {
       address_item *p = addr->parent;
       respond_printf(f, "%s%s cannot be resolved at this time", ko_prefix,
       {
       address_item *p = addr->parent;
       respond_printf(f, "%s%s cannot be resolved at this time", ko_prefix,


@@ -1856,7 +1955,7 @@ while (addr_new != NULL)
         {
         if (addr->basic_errno > 0)
           respond_printf(f, ": %s", strerror(addr->basic_errno));
         {
         if (addr->basic_errno > 0)
           respond_printf(f, ": %s", strerror(addr->basic_errno));

-        if (addr->message != NULL)
+        if (addr->message)

           respond_printf(f, ": %s", addr->message);
         else if (addr->basic_errno <= 0)
           respond_printf(f, ": unknown error");
           respond_printf(f, ": %s", addr->message);
         else if (addr->basic_errno <= 0)
           respond_printf(f, ": unknown error");


@@ -1864,21 +1963,21 @@ while (addr_new != NULL)
 
       /* Show parents iff doing full info */
 
 
       /* Show parents iff doing full info */
 

-      if (full_info) while (p != NULL)
+      if (full_info) while (p)

         {
         respond_printf(f, "%s\n    <-- %s", cr, p->address);
         p = p->parent;
         }
       respond_printf(f, "%s\n", cr);
       }
         {
         respond_printf(f, "%s\n    <-- %s", cr, p->address);
         p = p->parent;
         }
       respond_printf(f, "%s\n", cr);
       }

-    cancel_cutthrough_connection("routing soft fail");
+    cancel_cutthrough_connection(TRUE, US"routing soft fail");

 
     if (!full_info)
       {
       yield = copy_error(vaddr, addr, DEFER);
       goto out;
       }
 
     if (!full_info)
       {
       yield = copy_error(vaddr, addr, DEFER);
       goto out;
       }

-    else if (yield == OK) yield = DEFER;
+    if (yield == OK) yield = DEFER;

     }
 
   /* If we are handling EXPN, we do not want to continue to route beyond
     }
 
   /* If we are handling EXPN, we do not want to continue to route beyond


@@ -1887,20 +1986,20 @@ while (addr_new != NULL)
   else if (expn)
     {
     uschar *ok_prefix = US"250-";
   else if (expn)
     {
     uschar *ok_prefix = US"250-";

-    if (addr_new == NULL)
-      {
-      if (addr_local == NULL && addr_remote == NULL)
+
+    if (!addr_new)
+      if (!addr_local && !addr_remote)

         respond_printf(f, "250 mail to <%s> is discarded\r\n", address);
       else
         respond_printf(f, "250 <%s>\r\n", address);
         respond_printf(f, "250 mail to <%s> is discarded\r\n", address);
       else
         respond_printf(f, "250 <%s>\r\n", address);

-      }
-    else while (addr_new != NULL)
+
+    else do

       {
       address_item *addr2 = addr_new;
       addr_new = addr2->next;
       {
       address_item *addr2 = addr_new;
       addr_new = addr2->next;

-      if (addr_new == NULL) ok_prefix = US"250 ";
+      if (!addr_new) ok_prefix = US"250 ";

       respond_printf(f, "%s<%s>\r\n", ok_prefix, addr2->address);
       respond_printf(f, "%s<%s>\r\n", ok_prefix, addr2->address);

-      }
+      } while (addr_new);

     yield = OK;
     goto out;
     }
     yield = OK;
     goto out;
     }


@@ -1922,21 +2021,30 @@ while (addr_new != NULL)
     just a single new address as a special case, and continues on to verify the
     generated address. */
 
     just a single new address as a special case, and continues on to verify the
     generated address. */
 

-    if (!full_info &&                    /* Stop if short info wanted AND */
-         (((addr_new == NULL ||          /* No new address OR */
-           addr_new->next != NULL ||     /* More than one new address OR */
-           testflag(addr_new, af_pfr)))  /* New address is pfr */
-         ||                              /* OR */
-         (addr_new != NULL &&            /* At least one new address AND */
-          success_on_redirect)))         /* success_on_redirect is set */
+    if (  !full_info                   /* Stop if short info wanted AND */
+       && (  (  !addr_new              /* No new address OR */
+             || addr_new->next         /* More than one new address OR */
+            || testflag(addr_new, af_pfr)      /* New address is pfr */
+            )
+          ||                           /* OR */
+             (  addr_new               /* At least one new address AND */
+             && success_on_redirect    /* success_on_redirect is set */
+         )  )
+       )

       {
       {

-      if (f != NULL) fprintf(f, "%s %s\n", address,
-        address_test_mode? "is deliverable" : "verified");
+      if (f) fprintf(f, "%s %s\n",
+        address, address_test_mode ? "is deliverable" : "verified");

 
       /* If we have carried on to verify a child address, we want the value
       of $address_data to be that of the child */
 
 
       /* If we have carried on to verify a child address, we want the value
       of $address_data to be that of the child */
 

-      vaddr->p.address_data = addr->p.address_data;
+      vaddr->prop.address_data = addr->prop.address_data;
+
+      /* If stopped because more than one new address, cannot cutthrough */
+
+      if (addr_new && addr_new->next)
+       cancel_cutthrough_connection(TRUE, US"multiple addresses from routing");
+

       yield = OK;
       goto out;
       }
       yield = OK;
       goto out;
       }


@@ -1952,24 +2060,25 @@ If there are no local and no remote addresses, and there were no pipes, files,
 or autoreplies, and there were no errors or deferments, the message is to be
 discarded, usually because of the use of :blackhole: in an alias file. */
 
 or autoreplies, and there were no errors or deferments, the message is to be
 discarded, usually because of the use of :blackhole: in an alias file. */
 

-if (allok && addr_local == NULL && addr_remote == NULL)
+if (allok && !addr_local && !addr_remote)

   {
   fprintf(f, "mail to %s is discarded\n", address);
   goto out;
   }
 
 for (addr_list = addr_local, i = 0; i < 2; addr_list = addr_remote, i++)
   {
   fprintf(f, "mail to %s is discarded\n", address);
   goto out;
   }
 
 for (addr_list = addr_local, i = 0; i < 2; addr_list = addr_remote, i++)

-  {
-  while (addr_list != NULL)
+  while (addr_list)

     {
     address_item *addr = addr_list;
     address_item *p = addr->parent;
     {
     address_item *addr = addr_list;
     address_item *p = addr->parent;

+    transport_instance * tp = addr->transport;
+

     addr_list = addr->next;
 
     fprintf(f, "%s", CS addr->address);
 #ifdef EXPERIMENTAL_SRS
     addr_list = addr->next;
 
     fprintf(f, "%s", CS addr->address);
 #ifdef EXPERIMENTAL_SRS

-    if(addr->p.srs_sender)
-      fprintf(f, "    [srs = %s]", addr->p.srs_sender);
+    if(addr->prop.srs_sender)
+      fprintf(f, "    [srs = %s]", addr->prop.srs_sender);

 #endif
 
     /* If the address is a duplicate, show something about it. */
 #endif
 
     /* If the address is a duplicate, show something about it. */


@@ -1977,72 +2086,62 @@ for (addr_list = addr_local, i = 0; i < 2; addr_list = addr_remote, i++)
     if (!testflag(addr, af_pfr))
       {
       tree_node *tnode;
     if (!testflag(addr, af_pfr))
       {
       tree_node *tnode;

-      if ((tnode = tree_search(tree_duplicates, addr->unique)) != NULL)
+      if ((tnode = tree_search(tree_duplicates, addr->unique)))

         fprintf(f, "   [duplicate, would not be delivered]");
       else tree_add_duplicate(addr->unique, addr);
       }
 
     /* Now show its parents */
 
         fprintf(f, "   [duplicate, would not be delivered]");
       else tree_add_duplicate(addr->unique, addr);
       }
 
     /* Now show its parents */
 

-    while (p != NULL)
-      {
+    for (p = addr->parent; p; p = p->parent)

       fprintf(f, "\n    <-- %s", p->address);
       fprintf(f, "\n    <-- %s", p->address);

-      p = p->parent;
-      }

     fprintf(f, "\n  ");
 
     /* Show router, and transport */
 
     fprintf(f, "\n  ");
 
     /* Show router, and transport */
 

-    fprintf(f, "router = %s, ", addr->router->name);
-    fprintf(f, "transport = %s\n", (addr->transport == NULL)? US"unset" :
-      addr->transport->name);
+    fprintf(f, "router = %s, transport = %s\n",
+      addr->router->name, tp ? tp->name : US"unset");

 
     /* Show any hosts that are set up by a router unless the transport
     is going to override them; fiddle a bit to get a nice format. */
 
 
     /* Show any hosts that are set up by a router unless the transport
     is going to override them; fiddle a bit to get a nice format. */
 

-    if (addr->host_list != NULL && addr->transport != NULL &&
-        !addr->transport->overrides_hosts)
+    if (addr->host_list && tp && !tp->overrides_hosts)

       {
       host_item *h;
       int maxlen = 0;
       int maxaddlen = 0;
       {
       host_item *h;
       int maxlen = 0;
       int maxaddlen = 0;

-      for (h = addr->host_list; h != NULL; h = h->next)
-        {
+      for (h = addr->host_list; h; h = h->next)
+        {                              /* get max lengths of host names, addrs */

         int len = Ustrlen(h->name);
         if (len > maxlen) maxlen = len;
         int len = Ustrlen(h->name);
         if (len > maxlen) maxlen = len;

-        len = (h->address != NULL)? Ustrlen(h->address) : 7;
+        len = h->address ? Ustrlen(h->address) : 7;

         if (len > maxaddlen) maxaddlen = len;
         }
         if (len > maxaddlen) maxaddlen = len;
         }

-      for (h = addr->host_list; h != NULL; h = h->next)
-        {
-        int len = Ustrlen(h->name);
-        fprintf(f, "  host %s ", h->name);
-        while (len++ < maxlen) fprintf(f, " ");
-        if (h->address != NULL)
-          {
-          fprintf(f, "[%s] ", h->address);
-          len = Ustrlen(h->address);
-          }
-        else if (!addr->transport->info->local)  /* Omit [unknown] for local */
-          {
-          fprintf(f, "[unknown] ");
-          len = 7;
-          }
-        else len = -3;
-        while (len++ < maxaddlen) fprintf(f," ");
-        if (h->mx >= 0) fprintf(f, "MX=%d", h->mx);
+      for (h = addr->host_list; h; h = h->next)
+       {
+       fprintf(f, "  host %-*s ", maxlen, h->name);
+
+       if (h->address)
+         fprintf(f, "[%s%-*c", h->address, maxaddlen+1 - Ustrlen(h->address), ']');
+       else if (tp->info->local)
+         fprintf(f, " %-*s ", maxaddlen, "");  /* Omit [unknown] for local */
+       else
+         fprintf(f, "[%s%-*c", "unknown", maxaddlen+1 - 7, ']');
+
+        if (h->mx >= 0) fprintf(f, " MX=%d", h->mx);

         if (h->port != PORT_NONE) fprintf(f, " port=%d", h->port);
         if (h->port != PORT_NONE) fprintf(f, " port=%d", h->port);

-        if (h->status == hstatus_unusable) fprintf(f, " ** unusable **");
-        fprintf(f, "\n");
+        if (running_in_test_harness  &&  h->dnssec == DS_YES) fputs(" AD", f);
+        if (h->status == hstatus_unusable) fputs(" ** unusable **", f);
+       fputc('\n', f);

         }
       }
     }
         }
       }
     }

-  }

 
 /* Yield will be DEFER or FAIL if any one address has, only for full_info (which is
 the -bv or -bt case). */
 
 out:
 
 /* Yield will be DEFER or FAIL if any one address has, only for full_info (which is
 the -bv or -bt case). */
 
 out:

+verify_mode = NULL;

 tls_modify_variables(&tls_in);
 
 return yield;
 tls_modify_variables(&tls_in);
 
 return yield;


@@ -2151,7 +2250,8 @@ for (h = header_list; h != NULL && yield == OK; h = h->next)
         verb = US"begins";
         }
 
         verb = US"begins";
         }
 

-      *msgptr = string_printing(
+      /* deconst cast ok as we're passing a non-const to string_printing() */
+      *msgptr = US string_printing(

         string_sprintf("%s: failing address in \"%.*s:\" header %s: %.*s",
           errmess, tt - h->text, h->text, verb, len, s));
 
         string_sprintf("%s: failing address in \"%.*s:\" header %s: %.*s",
           errmess, tt - h->text, h->text, verb, len, s));
 


@@ -2177,7 +2277,7 @@ return yield;
 *      Check header names for 8-bit characters   *
 *************************************************/
 
 *      Check header names for 8-bit characters   *
 *************************************************/
 

-/* This function checks for invalid charcters in header names. See
+/* This function checks for invalid characters in header names. See

 RFC 5322, 2.2. and RFC 6532, 3.
 
 Arguments:
 RFC 5322, 2.2. and RFC 6532, 3.
 
 Arguments:


@@ -2193,18 +2293,16 @@ verify_check_header_names_ascii(uschar **msgptr)
 header_line *h;
 uschar *colon, *s;
 
 header_line *h;
 uschar *colon, *s;
 

-for (h = header_list; h != NULL; h = h->next)
+for (h = header_list; h; h = h->next)

   {
   {

-   colon = Ustrchr(h->text, ':');
-   for(s = h->text; s < colon; s++)
-     {
-        if ((*s < 33) || (*s > 126))
-        {
-                *msgptr = string_sprintf("Invalid character in header \"%.*s\" found",
-                                         colon - h->text, h->text);
-                return FAIL;
-        }
-     }
+  colon = Ustrchr(h->text, ':');
+  for(s = h->text; s < colon; s++)
+    if ((*s < 33) || (*s > 126))
+      {
+      *msgptr = string_sprintf("Invalid character in header \"%.*s\" found",
+                            colon - h->text, h->text);
+      return FAIL;
+      }

   }
 return OK;
 }
   }
 return OK;
 }


@@ -2564,9 +2662,8 @@ DEBUG(D_ident) debug_printf("doing ident callback\n");
 to the incoming interface address. If the sender host address is an IPv6
 address, the incoming interface address will also be IPv6. */
 
 to the incoming interface address. If the sender host address is an IPv6
 address, the incoming interface address will also be IPv6. */
 

-host_af = (Ustrchr(sender_host_address, ':') == NULL)? AF_INET : AF_INET6;
-sock = ip_socket(SOCK_STREAM, host_af);
-if (sock < 0) return;
+host_af = Ustrchr(sender_host_address, ':') == NULL ? AF_INET : AF_INET6;
+if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return;

 
 if (ip_bind(sock, host_af, interface_address, 0) < 0)
   {
 
 if (ip_bind(sock, host_af, interface_address, 0) < 0)
   {


@@ -2575,19 +2672,15 @@ if (ip_bind(sock, host_af, interface_address, 0) < 0)
   goto END_OFF;
   }
 
   goto END_OFF;
   }
 

-if (ip_connect(sock, host_af, sender_host_address, port, rfc1413_query_timeout)
-     < 0)
+if (ip_connect(sock, host_af, sender_host_address, port,
+               rfc1413_query_timeout, TRUE) < 0)

   {
   {

-  if (errno == ETIMEDOUT && (log_extra_selector & LX_ident_timeout) != 0)
-    {
+  if (errno == ETIMEDOUT && LOGGING(ident_timeout))

     log_write(0, LOG_MAIN, "ident connection to %s timed out",
       sender_host_address);
     log_write(0, LOG_MAIN, "ident connection to %s timed out",
       sender_host_address);

-    }

   else
   else

-    {

     DEBUG(D_ident) debug_printf("ident connection to %s failed: %s\n",
       sender_host_address, strerror(errno));
     DEBUG(D_ident) debug_printf("ident connection to %s failed: %s\n",
       sender_host_address, strerror(errno));

-    }

   goto END_OFF;
   }
 
   goto END_OFF;
   }
 


@@ -2672,9 +2765,9 @@ if (*p == 0) goto END_OFF;
 /* The rest of the line is the data we want. We turn it into printing
 characters when we save it, so that it cannot mess up the format of any logging
 or Received: lines into which it gets inserted. We keep a maximum of 127
 /* The rest of the line is the data we want. We turn it into printing
 characters when we save it, so that it cannot mess up the format of any logging
 or Received: lines into which it gets inserted. We keep a maximum of 127

-characters. */
+characters. The deconst cast is ok as we fed a nonconst to string_printing() */

 
 

-sender_ident = string_printing(string_copyn(p, 127));
+sender_ident = US string_printing(string_copyn(p, 127));

 DEBUG(D_ident) debug_printf("sender_ident = %s\n", sender_ident);
 
 END_OFF:
 DEBUG(D_ident) debug_printf("sender_ident = %s\n", sender_ident);
 
 END_OFF:


@@ -2719,7 +2812,7 @@ Returns:         OK      matched
 */
 
 int
 */
 
 int

-check_host(void *arg, uschar *ss, uschar **valueptr, uschar **error)
+check_host(void *arg, const uschar *ss, const uschar **valueptr, uschar **error)

 {
 check_host_block *cb = (check_host_block *)arg;
 int mlen = -1;
 {
 check_host_block *cb = (check_host_block *)arg;
 int mlen = -1;


@@ -2727,7 +2820,7 @@ int maskoffset;
 BOOL iplookup = FALSE;
 BOOL isquery = FALSE;
 BOOL isiponly = cb->host_name != NULL && cb->host_name[0] == 0;
 BOOL iplookup = FALSE;
 BOOL isquery = FALSE;
 BOOL isiponly = cb->host_name != NULL && cb->host_name[0] == 0;

-uschar *t;
+const uschar *t;

 uschar *semicolon;
 uschar **aliases;
 
 uschar *semicolon;
 uschar **aliases;
 


@@ -2763,7 +2856,7 @@ if (*ss == '@')
   }
 
 /* If the pattern is an IP address, optionally followed by a bitmask count, do
   }
 
 /* If the pattern is an IP address, optionally followed by a bitmask count, do

-a (possibly masked) comparision with the current IP address. */
+a (possibly masked) comparison with the current IP address. */

 
 if (string_is_ip_address(ss, &maskoffset) != 0)
   return (host_is_in_net(cb->host_address, ss, maskoffset)? OK : FAIL);
 
 if (string_is_ip_address(ss, &maskoffset) != 0)
   return (host_is_in_net(cb->host_address, ss, maskoffset)? OK : FAIL);


@@ -2868,9 +2961,9 @@ if (iplookup)
   /* Now do the actual lookup; note that there is no search_close() because
   of the caching arrangements. */
 
   /* Now do the actual lookup; note that there is no search_close() because
   of the caching arrangements. */
 

-  handle = search_open(filename, search_type, 0, NULL, NULL);
-  if (handle == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
-    search_error_message);
+  if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
+    log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
+

   result = search_find(handle, filename, key, -1, NULL, 0, 0, NULL);
   if (valueptr != NULL) *valueptr = result;
   return (result != NULL)? OK : search_find_defer? DEFER: FAIL;
   result = search_find(handle, filename, key, -1, NULL, 0, 0, NULL);
   if (valueptr != NULL) *valueptr = result;
   return (result != NULL)? OK : search_find_defer? DEFER: FAIL;


@@ -2908,6 +3001,10 @@ if (*t == 0)
   h.address = NULL;
   h.mx = MX_NONE;
 
   h.address = NULL;
   h.mx = MX_NONE;
 

+  /* Using byname rather than bydns here means we cannot determine dnssec
+  status.  On the other hand it is unclear how that could be either
+  propagated up or enforced. */
+

   rc = host_find_byname(&h, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, FALSE);
   if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
     {
   rc = host_find_byname(&h, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, FALSE);
   if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
     {


@@ -2940,7 +3037,7 @@ on spec. */
 
 if ((semicolon = Ustrchr(ss, ';')) != NULL)
   {
 
 if ((semicolon = Ustrchr(ss, ';')) != NULL)
   {

-  uschar *affix;
+  const uschar *affix;

   int partial, affixlen, starflags, id;
 
   *semicolon = 0;
   int partial, affixlen, starflags, id;
 
   *semicolon = 0;


@@ -3041,12 +3138,12 @@ determined from the IP address, the result is FAIL unless the item
 "+allow_unknown" was met earlier in the list, in which case OK is returned. */
 
 int
 "+allow_unknown" was met earlier in the list, in which case OK is returned. */
 
 int

-verify_check_this_host(uschar **listptr, unsigned int *cache_bits,
-  uschar *host_name, uschar *host_address, uschar **valueptr)
+verify_check_this_host(const uschar **listptr, unsigned int *cache_bits,
+  const uschar *host_name, const uschar *host_address, const uschar **valueptr)

 {
 int rc;
 unsigned int *local_cache_bits = cache_bits;
 {
 int rc;
 unsigned int *local_cache_bits = cache_bits;

-uschar *save_host_address = deliver_host_address;
+const uschar *save_host_address = deliver_host_address;

 check_host_block cb;
 cb.host_name = host_name;
 cb.host_address = host_address;
 check_host_block cb;
 cb.host_name = host_name;
 cb.host_address = host_address;


@@ -3085,6 +3182,15 @@ return rc;
 
 
 
 
 
 

+/*************************************************
+*      Check the given host item matches a list  *
+*************************************************/
+int
+verify_check_given_host(uschar **listptr, host_item *host)
+{
+return verify_check_this_host(CUSS listptr, NULL, host->name, host->address, NULL);
+}
+

 /*************************************************
 *      Check the remote host matches a list      *
 *************************************************/
 /*************************************************
 *      Check the remote host matches a list      *
 *************************************************/


@@ -3104,7 +3210,7 @@ Returns:               the yield of verify_check_this_host(),
 int
 verify_check_host(uschar **listptr)
 {
 int
 verify_check_host(uschar **listptr)
 {

-return verify_check_this_host(listptr, sender_host_cache, NULL,
+return verify_check_this_host(CUSS listptr, sender_host_cache, NULL,

   (sender_host_address == NULL)? US"" : sender_host_address, NULL);
 }
 
   (sender_host_address == NULL)? US"" : sender_host_address, NULL);
 }
 


@@ -3233,23 +3339,39 @@ if (!string_format(query, sizeof(query), "%s.%s", prepend, domain))
 
 /* Look for this query in the cache. */
 
 
 /* Look for this query in the cache. */
 

-t = tree_search(dnsbl_cache, query);
+if (  (t = tree_search(dnsbl_cache, query))
+   && (cb = t->data.ptr)->expiry > time(NULL)
+   )
+
+/* Previous lookup was cached */
+
+  {
+  HDEBUG(D_dnsbl) debug_printf("using result of previous DNS lookup\n");
+  }

 
 /* If not cached from a previous lookup, we must do a DNS lookup, and
 cache the result in permanent memory. */
 
 
 /* If not cached from a previous lookup, we must do a DNS lookup, and
 cache the result in permanent memory. */
 

-if (t == NULL)
+else

   {
   {

+  uint ttl = 3600;
+

   store_pool = POOL_PERM;
 
   store_pool = POOL_PERM;
 

-  /* Set up a tree entry to cache the lookup */
+  if (t)
+    {
+    HDEBUG(D_dnsbl) debug_printf("cached data found but past valid time; ");
+    }

 
 

-  t = store_get(sizeof(tree_node) + Ustrlen(query));
-  Ustrcpy(t->name, query);
-  t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block));
-  (void)tree_insertnode(&dnsbl_cache, t);
+  else
+    {  /* Set up a tree entry to cache the lookup */
+    t = store_get(sizeof(tree_node) + Ustrlen(query));
+    Ustrcpy(t->name, query);
+    t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block));
+    (void)tree_insertnode(&dnsbl_cache, t);
+    }

 
 

-  /* Do the DNS loopup . */
+  /* Do the DNS lookup . */

 
   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
   cb->rc = dns_basic_lookup(&dnsa, query, T_A);
 
   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
   cb->rc = dns_basic_lookup(&dnsa, query, T_A);


@@ -3265,24 +3387,28 @@ if (t == NULL)
 
   Quite apart from one A6 RR generating multiple addresses, there are DNS
   lists that return more than one A record, so we must handle multiple
 
   Quite apart from one A6 RR generating multiple addresses, there are DNS
   lists that return more than one A record, so we must handle multiple

-  addresses generated in that way as well. */
+  addresses generated in that way as well.
+
+  Mark the cache entry with the "now" plus the minimum of the address TTLs,
+  or some suitably far-future time if none were found. */

 
   if (cb->rc == DNS_SUCCEED)
     {
     dns_record *rr;
     dns_address **addrp = &(cb->rhs);
     for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
 
   if (cb->rc == DNS_SUCCEED)
     {
     dns_record *rr;
     dns_address **addrp = &(cb->rhs);
     for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);

-         rr != NULL;
+         rr;

          rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
       {
       if (rr->type == T_A)
         {
         dns_address *da = dns_address_from_rr(&dnsa, rr);
          rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
       {
       if (rr->type == T_A)
         {
         dns_address *da = dns_address_from_rr(&dnsa, rr);

-        if (da != NULL)
+        if (da)

           {
           *addrp = da;
           while (da->next != NULL) da = da->next;
           addrp = &(da->next);
           {
           *addrp = da;
           while (da->next != NULL) da = da->next;
           addrp = &(da->next);

+         if (ttl > rr->ttl) ttl = rr->ttl;

           }
         }
       }
           }
         }
       }


@@ -3294,17 +3420,10 @@ if (t == NULL)
     if (cb->rhs == NULL) cb->rc = DNS_NODATA;
     }
 
     if (cb->rhs == NULL) cb->rc = DNS_NODATA;
     }
 

+  cb->expiry = time(NULL)+ttl;

   store_pool = old_pool;
   }
 
   store_pool = old_pool;
   }
 

-/* Previous lookup was cached */
-
-else
-  {
-  HDEBUG(D_dnsbl) debug_printf("using result of previous DNS lookup\n");
-  cb = t->data.ptr;
-  }
-

 /* We now have the result of the DNS lookup, either newly done, or cached
 from a previous call. If the lookup succeeded, check against the address
 list if there is one. This may be a positive equality list (introduced by
 /* We now have the result of the DNS lookup, either newly done, or cached
 from a previous call. If the lookup succeeded, check against the address
 list if there is one. This may be a positive equality list (introduced by


@@ -3335,7 +3454,7 @@ if (cb->rc == DNS_SUCCEED)
       {
       int ipsep = ',';
       uschar ip[46];
       {
       int ipsep = ',';
       uschar ip[46];

-      uschar *ptr = iplist;
+      const uschar *ptr = iplist;

       uschar *res;
 
       /* Handle exact matching */
       uschar *res;
 
       /* Handle exact matching */


@@ -3528,7 +3647,9 @@ Note: an address for testing DUL is 192.203.178.4
 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
 
 Arguments:
 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
 
 Arguments:

+  where        the acl type

   listptr      the domain/address/data list
   listptr      the domain/address/data list

+  log_msgptr   log message on error

 
 Returns:    OK      successful lookup (i.e. the address is on the list), or
                       lookup deferred after +include_unknown
 
 Returns:    OK      successful lookup (i.e. the address is on the list), or
                       lookup deferred after +include_unknown


@@ -3538,11 +3659,11 @@ Returns:    OK      successful lookup (i.e. the address is on the list), or
 */
 
 int
 */
 
 int

-verify_check_dnsbl(uschar **listptr)
+verify_check_dnsbl(int where, const uschar ** listptr, uschar ** log_msgptr)

 {
 int sep = 0;
 int defer_return = FAIL;
 {
 int sep = 0;
 int defer_return = FAIL;

-uschar *list = *listptr;
+const uschar *list = *listptr;

 uschar *domain;
 uschar *s;
 uschar buffer[1024];
 uschar *domain;
 uschar *s;
 uschar buffer[1024];


@@ -3585,21 +3706,19 @@ while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL
 
   /* See if there's explicit data to be looked up */
 
 
   /* See if there's explicit data to be looked up */
 

-  key = Ustrchr(domain, '/');
-  if (key != NULL) *key++ = 0;
+  if ((key = Ustrchr(domain, '/'))) *key++ = 0;

 
   /* See if there's a list of addresses supplied after the domain name. This is
   introduced by an = or a & character; if preceded by = we require all matches
   and if preceded by ! we invert the result. */
 
 
   /* See if there's a list of addresses supplied after the domain name. This is
   introduced by an = or a & character; if preceded by = we require all matches
   and if preceded by ! we invert the result. */
 

-  iplist = Ustrchr(domain, '=');
-  if (iplist == NULL)
+  if (!(iplist = Ustrchr(domain, '=')))

     {
     bitmask = TRUE;
     iplist = Ustrchr(domain, '&');
     }
 
     {
     bitmask = TRUE;
     iplist = Ustrchr(domain, '&');
     }
 

-  if (iplist != NULL)                          /* Found either = or & */
+  if (iplist)                                 /* Found either = or & */

     {
     if (iplist > domain && iplist[-1] == '!')  /* Handle preceding ! */
       {
     {
     if (iplist > domain && iplist[-1] == '!')  /* Handle preceding ! */
       {


@@ -3618,6 +3737,7 @@ while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL
       }
     }
 
       }
     }
 

+

   /* If there is a comma in the domain, it indicates that a second domain for
   looking up TXT records is provided, before the main domain. Otherwise we must
   set domain_txt == domain. */
   /* If there is a comma in the domain, it indicates that a second domain for
   looking up TXT records is provided, before the main domain. Otherwise we must
   set domain_txt == domain. */


@@ -3663,6 +3783,13 @@ while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL
 
   if (key == NULL)
     {
 
   if (key == NULL)
     {

+    if (where == ACL_WHERE_NOTSMTP_START || where == ACL_WHERE_NOTSMTP)
+      {
+      *log_msgptr = string_sprintf
+       ("cannot test auto-keyed dnslists condition in %s ACL",
+         acl_wherenames[where]);
+      return ERROR;
+      }

     if (sender_host_address == NULL) return FAIL;    /* can never match */
     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
     rc = one_check_dnsbl(domain, domain_txt, sender_host_address, revadd,
     if (sender_host_address == NULL) return FAIL;    /* can never match */
     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
     rc = one_check_dnsbl(domain, domain_txt, sender_host_address, revadd,


@@ -3688,7 +3815,7 @@ while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL
     uschar keybuffer[256];
     uschar keyrevadd[128];
 
     uschar keybuffer[256];
     uschar keyrevadd[128];
 

-    while ((keydomain = string_nextinlist(&key, &keysep, keybuffer,
+    while ((keydomain = string_nextinlist(CUSS &key, &keysep, keybuffer,

             sizeof(keybuffer))) != NULL)
       {
       uschar *prepend = keydomain;
             sizeof(keybuffer))) != NULL)
       {
       uschar *prepend = keydomain;