src/src/verify.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2014 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Functions concerned with verifying things. The original code for callout
   9 caching was contributed by Kevin Fleming (but I hacked it around a bit). */
  10
  11
  12 #include "exim.h"
  13 #include "transports/smtp.h"
  14
  15 #define CUTTHROUGH_CMD_TIMEOUT  30      /* timeout for cutthrough-routing calls */
  16 #define CUTTHROUGH_DATA_TIMEOUT 60      /* timeout for cutthrough-routing calls */
  17 address_item cutthrough_addr;
  18 static smtp_outblock ctblock;
  19 uschar ctbuffer[8192];
  20
  21
  22 /* Structure for caching DNSBL lookups */
  23
  24 typedef struct dnsbl_cache_block {
  25   dns_address *rhs;
  26   uschar *text;
  27   int rc;
  28   BOOL text_set;
  29 } dnsbl_cache_block;
  30
  31
  32 /* Anchor for DNSBL cache */
  33
  34 static tree_node *dnsbl_cache = NULL;
  35
  36
  37 /* Bits for match_type in one_check_dnsbl() */
  38
  39 #define MT_NOT 1
  40 #define MT_ALL 2
  41
  42
  43
  44 /*************************************************
  45 *          Retrieve a callout cache record       *
  46 *************************************************/
  47
  48 /* If a record exists, check whether it has expired.
  49
  50 Arguments:
  51   dbm_file          an open hints file
  52   key               the record key
  53   type              "address" or "domain"
  54   positive_expire   expire time for positive records
  55   negative_expire   expire time for negative records
  56
  57 Returns:            the cache record if a non-expired one exists, else NULL
  58 */
  59
  60 static dbdata_callout_cache *
  61 get_callout_cache_record(open_db *dbm_file, uschar *key, uschar *type,
  62   int positive_expire, int negative_expire)
  63 {
  64 BOOL negative;
  65 int length, expire;
  66 time_t now;
  67 dbdata_callout_cache *cache_record;
  68
  69 cache_record = dbfn_read_with_length(dbm_file, key, &length);
  70
  71 if (cache_record == NULL)
  72   {
  73   HDEBUG(D_verify) debug_printf("callout cache: no %s record found\n", type);
  74   return NULL;
  75   }
  76
  77 /* We treat a record as "negative" if its result field is not positive, or if
  78 it is a domain record and the postmaster field is negative. */
  79
  80 negative = cache_record->result != ccache_accept ||
  81   (type[0] == 'd' && cache_record->postmaster_result == ccache_reject);
  82 expire = negative? negative_expire : positive_expire;
  83 now = time(NULL);
  84
  85 if (now - cache_record->time_stamp > expire)
  86   {
  87   HDEBUG(D_verify) debug_printf("callout cache: %s record expired\n", type);
  88   return NULL;
  89   }
  90
  91 /* If this is a non-reject domain record, check for the obsolete format version
  92 that doesn't have the postmaster and random timestamps, by looking at the
  93 length. If so, copy it to a new-style block, replicating the record's
  94 timestamp. Then check the additional timestamps. (There's no point wasting
  95 effort if connections are rejected.) */
  96
  97 if (type[0] == 'd' && cache_record->result != ccache_reject)
  98   {
  99   if (length == sizeof(dbdata_callout_cache_obs))
 100     {
 101     dbdata_callout_cache *new = store_get(sizeof(dbdata_callout_cache));
 102     memcpy(new, cache_record, length);
 103     new->postmaster_stamp = new->random_stamp = new->time_stamp;
 104     cache_record = new;
 105     }
 106
 107   if (now - cache_record->postmaster_stamp > expire)
 108     cache_record->postmaster_result = ccache_unknown;
 109
 110   if (now - cache_record->random_stamp > expire)
 111     cache_record->random_result = ccache_unknown;
 112   }
 113
 114 HDEBUG(D_verify) debug_printf("callout cache: found %s record\n", type);
 115 return cache_record;
 116 }
 117
 118
 119
 120 /*************************************************
 121 *      Do callout verification for an address    *
 122 *************************************************/
 123
 124 /* This function is called from verify_address() when the address has routed to
 125 a host list, and a callout has been requested. Callouts are expensive; that is
 126 why a cache is used to improve the efficiency.
 127
 128 Arguments:
 129   addr              the address that's been routed
 130   host_list         the list of hosts to try
 131   tf                the transport feedback block
 132
 133   ifstring          "interface" option from transport, or NULL
 134   portstring        "port" option from transport, or NULL
 135   protocolstring    "protocol" option from transport, or NULL
 136   callout           the per-command callout timeout
 137   callout_overall   the overall callout timeout (if < 0 use 4*callout)
 138   callout_connect   the callout connection timeout (if < 0 use callout)
 139   options           the verification options - these bits are used:
 140                       vopt_is_recipient => this is a recipient address
 141                       vopt_callout_no_cache => don't use callout cache
 142                       vopt_callout_fullpm => if postmaster check, do full one
 143                       vopt_callout_random => do the "random" thing
 144                       vopt_callout_recipsender => use real sender for recipient
 145                       vopt_callout_recippmaster => use postmaster for recipient
 146   se_mailfrom         MAIL FROM address for sender verify; NULL => ""
 147   pm_mailfrom         if non-NULL, do the postmaster check with this sender
 148
 149 Returns:            OK/FAIL/DEFER
 150 */
 151
 152 static int
 153 do_callout(address_item *addr, host_item *host_list, transport_feedback *tf,
 154   int callout, int callout_overall, int callout_connect, int options,
 155   uschar *se_mailfrom, uschar *pm_mailfrom)
 156 {
 157 BOOL is_recipient = (options & vopt_is_recipient) != 0;
 158 BOOL callout_no_cache = (options & vopt_callout_no_cache) != 0;
 159 BOOL callout_random = (options & vopt_callout_random) != 0;
 160
 161 int yield = OK;
 162 int old_domain_cache_result = ccache_accept;
 163 BOOL done = FALSE;
 164 uschar *address_key;
 165 uschar *from_address;
 166 uschar *random_local_part = NULL;
 167 uschar *save_deliver_domain = deliver_domain;
 168 uschar **failure_ptr = is_recipient?
 169   &recipient_verify_failure : &sender_verify_failure;
 170 open_db dbblock;
 171 open_db *dbm_file = NULL;
 172 dbdata_callout_cache new_domain_record;
 173 dbdata_callout_cache_address new_address_record;
 174 host_item *host;
 175 time_t callout_start_time;
 176
 177 new_domain_record.result = ccache_unknown;
 178 new_domain_record.postmaster_result = ccache_unknown;
 179 new_domain_record.random_result = ccache_unknown;
 180
 181 memset(&new_address_record, 0, sizeof(new_address_record));
 182
 183 /* For a recipient callout, the key used for the address cache record must
 184 include the sender address if we are using the real sender in the callout,
 185 because that may influence the result of the callout. */
 186
 187 address_key = addr->address;
 188 from_address = US"";
 189
 190 if (is_recipient)
 191   {
 192   if ((options & vopt_callout_recipsender) != 0)
 193     {
 194     address_key = string_sprintf("%s/<%s>", addr->address, sender_address);
 195     from_address = sender_address;
 196     }
 197   else if ((options & vopt_callout_recippmaster) != 0)
 198     {
 199     address_key = string_sprintf("%s/<postmaster@%s>", addr->address,
 200       qualify_domain_sender);
 201     from_address = string_sprintf("postmaster@%s", qualify_domain_sender);
 202     }
 203   }
 204
 205 /* For a sender callout, we must adjust the key if the mailfrom address is not
 206 empty. */
 207
 208 else
 209   {
 210   from_address = (se_mailfrom == NULL)? US"" : se_mailfrom;
 211   if (from_address[0] != 0)
 212     address_key = string_sprintf("%s/<%s>", addr->address, from_address);
 213   }
 214
 215 /* Open the callout cache database, it it exists, for reading only at this
 216 stage, unless caching has been disabled. */
 217
 218 if (callout_no_cache)
 219   {
 220   HDEBUG(D_verify) debug_printf("callout cache: disabled by no_cache\n");
 221   }
 222 else if ((dbm_file = dbfn_open(US"callout", O_RDWR, &dbblock, FALSE)) == NULL)
 223   {
 224   HDEBUG(D_verify) debug_printf("callout cache: not available\n");
 225   }
 226
 227 /* If a cache database is available see if we can avoid the need to do an
 228 actual callout by making use of previously-obtained data. */
 229
 230 if (dbm_file != NULL)
 231   {
 232   dbdata_callout_cache_address *cache_address_record;
 233   dbdata_callout_cache *cache_record = get_callout_cache_record(dbm_file,
 234     addr->domain, US"domain",
 235     callout_cache_domain_positive_expire,
 236     callout_cache_domain_negative_expire);
 237
 238   /* If an unexpired cache record was found for this domain, see if the callout
 239   process can be short-circuited. */
 240
 241   if (cache_record != NULL)
 242     {
 243     /* In most cases, if an early command (up to and including MAIL FROM:<>)
 244     was rejected, there is no point carrying on. The callout fails. However, if
 245     we are doing a recipient verification with use_sender or use_postmaster
 246     set, a previous failure of MAIL FROM:<> doesn't count, because this time we
 247     will be using a non-empty sender. We have to remember this situation so as
 248     not to disturb the cached domain value if this whole verification succeeds
 249     (we don't want it turning into "accept"). */
 250
 251     old_domain_cache_result = cache_record->result;
 252
 253     if (cache_record->result == ccache_reject ||
 254          (*from_address == 0 && cache_record->result == ccache_reject_mfnull))
 255       {
 256       setflag(addr, af_verify_nsfail);
 257       HDEBUG(D_verify)
 258         debug_printf("callout cache: domain gave initial rejection, or "
 259           "does not accept HELO or MAIL FROM:<>\n");
 260       setflag(addr, af_verify_nsfail);
 261       addr->user_message = US"(result of an earlier callout reused).";
 262       yield = FAIL;
 263       *failure_ptr = US"mail";
 264       goto END_CALLOUT;
 265       }
 266
 267     /* If a previous check on a "random" local part was accepted, we assume
 268     that the server does not do any checking on local parts. There is therefore
 269     no point in doing the callout, because it will always be successful. If a
 270     random check previously failed, arrange not to do it again, but preserve
 271     the data in the new record. If a random check is required but hasn't been
 272     done, skip the remaining cache processing. */
 273
 274     if (callout_random) switch(cache_record->random_result)
 275       {
 276       case ccache_accept:
 277       HDEBUG(D_verify)
 278         debug_printf("callout cache: domain accepts random addresses\n");
 279       goto END_CALLOUT;     /* Default yield is OK */
 280
 281       case ccache_reject:
 282       HDEBUG(D_verify)
 283         debug_printf("callout cache: domain rejects random addresses\n");
 284       callout_random = FALSE;
 285       new_domain_record.random_result = ccache_reject;
 286       new_domain_record.random_stamp = cache_record->random_stamp;
 287       break;
 288
 289       default:
 290       HDEBUG(D_verify)
 291         debug_printf("callout cache: need to check random address handling "
 292           "(not cached or cache expired)\n");
 293       goto END_CACHE;
 294       }
 295
 296     /* If a postmaster check is requested, but there was a previous failure,
 297     there is again no point in carrying on. If a postmaster check is required,
 298     but has not been done before, we are going to have to do a callout, so skip
 299     remaining cache processing. */
 300
 301     if (pm_mailfrom != NULL)
 302       {
 303       if (cache_record->postmaster_result == ccache_reject)
 304         {
 305         setflag(addr, af_verify_pmfail);
 306         HDEBUG(D_verify)
 307           debug_printf("callout cache: domain does not accept "
 308             "RCPT TO:<postmaster@domain>\n");
 309         yield = FAIL;
 310         *failure_ptr = US"postmaster";
 311         setflag(addr, af_verify_pmfail);
 312         addr->user_message = US"(result of earlier verification reused).";
 313         goto END_CALLOUT;
 314         }
 315       if (cache_record->postmaster_result == ccache_unknown)
 316         {
 317         HDEBUG(D_verify)
 318           debug_printf("callout cache: need to check RCPT "
 319             "TO:<postmaster@domain> (not cached or cache expired)\n");
 320         goto END_CACHE;
 321         }
 322
 323       /* If cache says OK, set pm_mailfrom NULL to prevent a redundant
 324       postmaster check if the address itself has to be checked. Also ensure
 325       that the value in the cache record is preserved (with its old timestamp).
 326       */
 327
 328       HDEBUG(D_verify) debug_printf("callout cache: domain accepts RCPT "
 329         "TO:<postmaster@domain>\n");
 330       pm_mailfrom = NULL;
 331       new_domain_record.postmaster_result = ccache_accept;
 332       new_domain_record.postmaster_stamp = cache_record->postmaster_stamp;
 333       }
 334     }
 335
 336   /* We can't give a result based on information about the domain. See if there
 337   is an unexpired cache record for this specific address (combined with the
 338   sender address if we are doing a recipient callout with a non-empty sender).
 339   */
 340
 341   cache_address_record = (dbdata_callout_cache_address *)
 342     get_callout_cache_record(dbm_file,
 343       address_key, US"address",
 344       callout_cache_positive_expire,
 345       callout_cache_negative_expire);
 346
 347   if (cache_address_record != NULL)
 348     {
 349     if (cache_address_record->result == ccache_accept)
 350       {
 351       HDEBUG(D_verify)
 352         debug_printf("callout cache: address record is positive\n");
 353       }
 354     else
 355       {
 356       HDEBUG(D_verify)
 357         debug_printf("callout cache: address record is negative\n");
 358       addr->user_message = US"Previous (cached) callout verification failure";
 359       *failure_ptr = US"recipient";
 360       yield = FAIL;
 361       }
 362     goto END_CALLOUT;
 363     }
 364
 365   /* Close the cache database while we actually do the callout for real. */
 366
 367   END_CACHE:
 368   dbfn_close(dbm_file);
 369   dbm_file = NULL;
 370   }
 371
 372 if (!addr->transport)
 373   {
 374   HDEBUG(D_verify) debug_printf("cannot callout via null transport\n");
 375   }
 376 else if (Ustrcmp(addr->transport->driver_name, "smtp") != 0)
 377   log_write(0, LOG_MAIN|LOG_PANIC|LOG_CONFIG_FOR, "callout transport '%s': %s is non-smtp",
 378     addr->transport->name, addr->transport->driver_name);
 379 else
 380   {
 381   smtp_transport_options_block *ob =
 382     (smtp_transport_options_block *)addr->transport->options_block;
 383
 384   /* The information wasn't available in the cache, so we have to do a real
 385   callout and save the result in the cache for next time, unless no_cache is set,
 386   or unless we have a previously cached negative random result. If we are to test
 387   with a random local part, ensure that such a local part is available. If not,
 388   log the fact, but carry on without randomming. */
 389
 390   if (callout_random && callout_random_local_part != NULL)
 391     {
 392     random_local_part = expand_string(callout_random_local_part);
 393     if (random_local_part == NULL)
 394       log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
 395         "callout_random_local_part: %s", expand_string_message);
 396     }
 397
 398   /* Default the connect and overall callout timeouts if not set, and record the
 399   time we are starting so that we can enforce it. */
 400
 401   if (callout_overall < 0) callout_overall = 4 * callout;
 402   if (callout_connect < 0) callout_connect = callout;
 403   callout_start_time = time(NULL);
 404
 405   /* Before doing a real callout, if this is an SMTP connection, flush the SMTP
 406   output because a callout might take some time. When PIPELINING is active and
 407   there are many recipients, the total time for doing lots of callouts can add up
 408   and cause the client to time out. So in this case we forgo the PIPELINING
 409   optimization. */
 410
 411   if (smtp_out != NULL && !disable_callout_flush) mac_smtp_fflush();
 412
 413   /* Now make connections to the hosts and do real callouts. The list of hosts
 414   is passed in as an argument. */
 415
 416   for (host = host_list; host != NULL && !done; host = host->next)
 417     {
 418     smtp_inblock inblock;
 419     smtp_outblock outblock;
 420     int host_af;
 421     int port = 25;
 422     BOOL send_quit = TRUE;
 423     uschar *active_hostname = smtp_active_hostname;
 424     BOOL lmtp;
 425     BOOL smtps;
 426     BOOL esmtp;
 427     BOOL suppress_tls = FALSE;
 428     uschar *interface = NULL;  /* Outgoing interface to use; NULL => any */
 429 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
 430     BOOL dane = FALSE;
 431     dns_answer tlsa_dnsa;
 432 #endif
 433     uschar inbuffer[4096];
 434     uschar outbuffer[1024];
 435     uschar responsebuffer[4096];
 436
 437     clearflag(addr, af_verify_pmfail);  /* postmaster callout flag */
 438     clearflag(addr, af_verify_nsfail);  /* null sender callout flag */
 439
 440     /* Skip this host if we don't have an IP address for it. */
 441
 442     if (host->address == NULL)
 443       {
 444       DEBUG(D_verify) debug_printf("no IP address for host name %s: skipping\n",
 445         host->name);
 446       continue;
 447       }
 448
 449     /* Check the overall callout timeout */
 450
 451     if (time(NULL) - callout_start_time >= callout_overall)
 452       {
 453       HDEBUG(D_verify) debug_printf("overall timeout for callout exceeded\n");
 454       break;
 455       }
 456
 457     /* Set IPv4 or IPv6 */
 458
 459     host_af = (Ustrchr(host->address, ':') == NULL)? AF_INET:AF_INET6;
 460
 461     /* Expand and interpret the interface and port strings. The latter will not
 462     be used if there is a host-specific port (e.g. from a manualroute router).
 463     This has to be delayed till now, because they may expand differently for
 464     different hosts. If there's a failure, log it, but carry on with the
 465     defaults. */
 466
 467     deliver_host = host->name;
 468     deliver_host_address = host->address;
 469     deliver_host_port = host->port;
 470     deliver_domain = addr->domain;
 471     transport_name = addr->transport->name;
 472
 473     if (!smtp_get_interface(tf->interface, host_af, addr, NULL, &interface,
 474             US"callout") ||
 475         !smtp_get_port(tf->port, addr, &port, US"callout"))
 476       log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
 477         addr->message);
 478
 479     /* Set HELO string according to the protocol */
 480     lmtp= Ustrcmp(tf->protocol, "lmtp") == 0;
 481     smtps= Ustrcmp(tf->protocol, "smtps") == 0;
 482
 483
 484     HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", interface, port);
 485
 486 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
 487       {
 488       BOOL dane_required;
 489       int rc;
 490
 491       tls_out.dane_verified = FALSE;
 492       tls_out.tlsa_usage = 0;
 493
 494       dane_required =
 495         verify_check_given_host(&ob->hosts_require_dane, host) == OK;
 496
 497       if (host->dnssec == DS_YES)
 498         {
 499         if(  dane_required
 500           || verify_check_given_host(&ob->hosts_try_dane, host) == OK
 501           )
 502           if ((rc = tlsa_lookup(host, &tlsa_dnsa, dane_required, &dane)) != OK)
 503             return rc;
 504         }
 505       else if (dane_required)
 506         {
 507         log_write(0, LOG_MAIN, "DANE error: %s lookup not DNSSEC", host->name);
 508         return FAIL;
 509         }
 510
 511       if (dane)
 512         ob->tls_tempfail_tryclear = FALSE;
 513       }
 514 #endif  /*DANE*/
 515
 516     /* Set up the buffer for reading SMTP response packets. */
 517
 518     inblock.buffer = inbuffer;
 519     inblock.buffersize = sizeof(inbuffer);
 520     inblock.ptr = inbuffer;
 521     inblock.ptrend = inbuffer;
 522
 523     /* Set up the buffer for holding SMTP commands while pipelining */
 524
 525     outblock.buffer = outbuffer;
 526     outblock.buffersize = sizeof(outbuffer);
 527     outblock.ptr = outbuffer;
 528     outblock.cmd_count = 0;
 529     outblock.authenticating = FALSE;
 530
 531     /* Reset the parameters of a TLS session */
 532     tls_out.cipher = tls_out.peerdn = NULL;
 533
 534     /* Connect to the host; on failure, just loop for the next one, but we
 535     set the error for the last one. Use the callout_connect timeout. */
 536
 537     tls_retry_connection:
 538
 539     inblock.sock = outblock.sock =
 540       smtp_connect(host, host_af, port, interface, callout_connect, TRUE, NULL
 541 #ifdef EXPERIMENTAL_EVENT
 542     /*XXX event action? NULL for now. */
 543                   , NULL
 544 #endif
 545                   );
 546     /* reconsider DSCP here */
 547     if (inblock.sock < 0)
 548       {
 549       addr->message = string_sprintf("could not connect to %s [%s]: %s",
 550           host->name, host->address, strerror(errno));
 551       transport_name = NULL;
 552       deliver_host = deliver_host_address = NULL;
 553       deliver_domain = save_deliver_domain;
 554       continue;
 555       }
 556
 557     /* Expand the helo_data string to find the host name to use. */
 558
 559     if (tf->helo_data != NULL)
 560       {
 561       uschar *s = expand_string(tf->helo_data);
 562       if (s == NULL)
 563         log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: failed to expand transport's "
 564           "helo_data value for callout: %s", addr->address,
 565           expand_string_message);
 566       else active_hostname = s;
 567       }
 568
 569     /* Wait for initial response, and send HELO. The smtp_write_command()
 570     function leaves its command in big_buffer. This is used in error responses.
 571     Initialize it in case the connection is rejected. */
 572
 573     Ustrcpy(big_buffer, "initial connection");
 574
 575     /* Unless ssl-on-connect, wait for the initial greeting */
 576     smtps_redo_greeting:
 577
 578 #ifdef SUPPORT_TLS
 579     if (!smtps || (smtps && tls_out.active >= 0))
 580 #endif
 581       {
 582       if (!(done= smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), '2', callout)))
 583         goto RESPONSE_FAILED;
 584
 585 #ifdef EXPERIMENTAL_EVENT
 586       lookup_dnssec_authenticated = host->dnssec==DS_YES ? US"yes"
 587         : host->dnssec==DS_NO ? US"no" : NULL;
 588       if (event_raise(addr->transport->event_action,
 589                             US"smtp:connect", responsebuffer))
 590         {
 591         lookup_dnssec_authenticated = NULL;
 592         /* Logging?  Debug? */
 593         goto RESPONSE_FAILED;
 594         }
 595       lookup_dnssec_authenticated = NULL;
 596 #endif
 597       }
 598
 599     /* Not worth checking greeting line for ESMTP support */
 600     if (!(esmtp = verify_check_given_host(&(ob->hosts_avoid_esmtp), host) != OK))
 601       DEBUG(D_transport)
 602         debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
 603
 604     tls_redo_helo:
 605
 606 #ifdef SUPPORT_TLS
 607     if (smtps  &&  tls_out.active < 0)  /* ssl-on-connect, first pass */
 608       {
 609       tls_offered = TRUE;
 610       ob->tls_tempfail_tryclear = FALSE;
 611       }
 612     else                                /* all other cases */
 613 #endif
 614
 615       { esmtp_retry:
 616
 617       if (!(done= smtp_write_command(&outblock, FALSE, "%s %s\r\n",
 618         !esmtp? "HELO" : lmtp? "LHLO" : "EHLO", active_hostname) >= 0))
 619         goto SEND_FAILED;
 620       if (!smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), '2', callout))
 621         {
 622         if (errno != 0 || responsebuffer[0] == 0 || lmtp || !esmtp || tls_out.active >= 0)
 623           {
 624           done= FALSE;
 625           goto RESPONSE_FAILED;
 626           }
 627 #ifdef SUPPORT_TLS
 628         tls_offered = FALSE;
 629 #endif
 630         esmtp = FALSE;
 631         goto esmtp_retry;                       /* fallback to HELO */
 632         }
 633
 634       /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
 635 #ifdef SUPPORT_TLS
 636       if (esmtp && !suppress_tls &&  tls_out.active < 0)
 637         {
 638         if (regex_STARTTLS == NULL) regex_STARTTLS =
 639           regex_must_compile(US"\\n250[\\s\\-]STARTTLS(\\s|\\n|$)", FALSE, TRUE);
 640
 641         tls_offered = pcre_exec(regex_STARTTLS, NULL, CS responsebuffer,
 642                       Ustrlen(responsebuffer), 0, PCRE_EOPT, NULL, 0) >= 0;
 643         }
 644       else
 645         tls_offered = FALSE;
 646 #endif
 647       }
 648
 649     /* If TLS is available on this connection attempt to
 650     start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
 651     send another EHLO - the server may give a different answer in secure mode. We
 652     use a separate buffer for reading the response to STARTTLS so that if it is
 653     negative, the original EHLO data is available for subsequent analysis, should
 654     the client not be required to use TLS. If the response is bad, copy the buffer
 655     for error analysis. */
 656
 657 #ifdef SUPPORT_TLS
 658     if (  tls_offered
 659        && verify_check_given_host(&ob->hosts_avoid_tls, host) != OK
 660        && verify_check_given_host(&ob->hosts_verify_avoid_tls, host) != OK
 661        )
 662       {
 663       uschar buffer2[4096];
 664       if (  !smtps
 665          && !(done= smtp_write_command(&outblock, FALSE, "STARTTLS\r\n") >= 0))
 666         goto SEND_FAILED;
 667
 668       /* If there is an I/O error, transmission of this message is deferred. If
 669       there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
 670       false, we also defer. However, if there is a temporary rejection of STARTTLS
 671       and tls_tempfail_tryclear is true, or if there is an outright rejection of
 672       STARTTLS, we carry on. This means we will try to send the message in clear,
 673       unless the host is in hosts_require_tls (tested below). */
 674
 675       if (!smtps && !smtp_read_response(&inblock, buffer2, sizeof(buffer2), '2',
 676                         ob->command_timeout))
 677         {
 678         if (errno != 0 || buffer2[0] == 0 ||
 679                 (buffer2[0] == '4' && !ob->tls_tempfail_tryclear))
 680           {
 681           Ustrncpy(responsebuffer, buffer2, sizeof(responsebuffer));
 682           done= FALSE;
 683           goto RESPONSE_FAILED;
 684           }
 685         }
 686
 687        /* STARTTLS accepted or ssl-on-connect: try to negotiate a TLS session. */
 688       else
 689         {
 690         int oldtimeout = ob->command_timeout;
 691         int rc;
 692
 693         ob->command_timeout = callout;
 694         rc = tls_client_start(inblock.sock, host, addr, addr->transport
 695 #ifdef EXPERIMENTAL_DANE
 696                             , dane ? &tlsa_dnsa : NULL
 697 #endif
 698                             );
 699         ob->command_timeout = oldtimeout;
 700
 701         /* TLS negotiation failed; give an error.  Try in clear on a new connection,
 702            if the options permit it for this host. */
 703         if (rc != OK)
 704           {
 705           if (  rc == DEFER
 706              && ob->tls_tempfail_tryclear
 707              && !smtps
 708              && verify_check_given_host(&ob->hosts_require_tls, host) != OK
 709              )
 710             {
 711             (void)close(inblock.sock);
 712 #ifdef EXPERIMENTAL_EVENT
 713             (void) event_raise(addr->transport->event_action,
 714                                     US"tcp:close", NULL);
 715 #endif
 716             log_write(0, LOG_MAIN, "TLS session failure: delivering unencrypted "
 717               "to %s [%s] (not in hosts_require_tls)", host->name, host->address);
 718             suppress_tls = TRUE;
 719             goto tls_retry_connection;
 720             }
 721           /*save_errno = ERRNO_TLSFAILURE;*/
 722           /*message = US"failure while setting up TLS session";*/
 723           send_quit = FALSE;
 724           done= FALSE;
 725           goto TLS_FAILED;
 726           }
 727
 728         /* TLS session is set up.  Copy info for logging. */
 729         addr->cipher = tls_out.cipher;
 730         addr->peerdn = tls_out.peerdn;
 731
 732         /* For SMTPS we need to wait for the initial OK response, then do HELO. */
 733         if (smtps)
 734           goto smtps_redo_greeting;
 735
 736         /* For STARTTLS we need to redo EHLO */
 737         goto tls_redo_helo;
 738         }
 739       }
 740
 741     /* If the host is required to use a secure channel, ensure that we have one. */
 742     if (tls_out.active < 0)
 743       if (
 744 #ifdef EXPERIMENTAL_DANE
 745          dane ||
 746 #endif
 747          verify_check_given_host(&ob->hosts_require_tls, host) == OK
 748          )
 749         {
 750         /*save_errno = ERRNO_TLSREQUIRED;*/
 751         log_write(0, LOG_MAIN,
 752           "H=%s [%s]: a TLS session is required for this host, but %s",
 753           host->name, host->address,
 754           tls_offered ? "an attempt to start TLS failed"
 755                       : "the server did not offer TLS support");
 756         done= FALSE;
 757         goto TLS_FAILED;
 758         }
 759
 760     #endif /*SUPPORT_TLS*/
 761
 762     done = TRUE; /* so far so good; have response to HELO */
 763
 764     /*XXX the EHLO response would be analyzed here for IGNOREQUOTA, SIZE, PIPELINING */
 765
 766     /* For now, transport_filter by cutthrough-delivery is not supported */
 767     /* Need proper integration with the proper transport mechanism. */
 768     if (cutthrough_delivery)
 769       {
 770       if (addr->transport->filter_command)
 771         {
 772         cutthrough_delivery= FALSE;
 773         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of transport filter\n");
 774         }
 775 #ifndef DISABLE_DKIM
 776       if (ob->dkim_domain)
 777         {
 778         cutthrough_delivery= FALSE;
 779         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of DKIM signing\n");
 780         }
 781 #endif
 782       }
 783
 784     SEND_FAILED:
 785     RESPONSE_FAILED:
 786     TLS_FAILED:
 787     ;
 788     /* Clear down of the TLS, SMTP and TCP layers on error is handled below.  */
 789
 790     /* Failure to accept HELO is cached; this blocks the whole domain for all
 791     senders. I/O errors and defer responses are not cached. */
 792
 793     if (!done)
 794       {
 795       *failure_ptr = US"mail";     /* At or before MAIL */
 796       if (errno == 0 && responsebuffer[0] == '5')
 797         {
 798         setflag(addr, af_verify_nsfail);
 799         new_domain_record.result = ccache_reject;
 800         }
 801       }
 802
 803     /* If we haven't authenticated, but are required to, give up. */
 804     /* Try to AUTH */
 805
 806     else done = smtp_auth(responsebuffer, sizeof(responsebuffer),
 807         addr, host, ob, esmtp, &inblock, &outblock) == OK  &&
 808
 809                 /* Copy AUTH info for logging */
 810       ( (addr->authenticator = client_authenticator),
 811         (addr->auth_id = client_authenticated_id),
 812
 813     /* Build a mail-AUTH string (re-using responsebuffer for convenience */
 814         !smtp_mail_auth_str(responsebuffer, sizeof(responsebuffer), addr, ob)
 815       )  &&
 816
 817       ( (addr->auth_sndr = client_authenticated_sender),
 818
 819     /* Send the MAIL command */
 820         (smtp_write_command(&outblock, FALSE, "MAIL FROM:<%s>%s\r\n",
 821           from_address, responsebuffer) >= 0)
 822       )  &&
 823
 824       smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
 825         '2', callout);
 826
 827     deliver_host = deliver_host_address = NULL;
 828     deliver_domain = save_deliver_domain;
 829
 830     /* If the host does not accept MAIL FROM:<>, arrange to cache this
 831     information, but again, don't record anything for an I/O error or a defer. Do
 832     not cache rejections of MAIL when a non-empty sender has been used, because
 833     that blocks the whole domain for all senders. */
 834
 835     if (!done)
 836       {
 837       *failure_ptr = US"mail";     /* At or before MAIL */
 838       if (errno == 0 && responsebuffer[0] == '5')
 839         {
 840         setflag(addr, af_verify_nsfail);
 841         if (from_address[0] == 0)
 842           new_domain_record.result = ccache_reject_mfnull;
 843         }
 844       }
 845
 846     /* Otherwise, proceed to check a "random" address (if required), then the
 847     given address, and the postmaster address (if required). Between each check,
 848     issue RSET, because some servers accept only one recipient after MAIL
 849     FROM:<>.
 850
 851     Before doing this, set the result in the domain cache record to "accept",
 852     unless its previous value was ccache_reject_mfnull. In that case, the domain
 853     rejects MAIL FROM:<> and we want to continue to remember that. When that is
 854     the case, we have got here only in the case of a recipient verification with
 855     a non-null sender. */
 856
 857     else
 858       {
 859       new_domain_record.result =
 860         (old_domain_cache_result == ccache_reject_mfnull)?
 861           ccache_reject_mfnull: ccache_accept;
 862
 863       /* Do the random local part check first */
 864
 865       if (random_local_part != NULL)
 866         {
 867         uschar randombuffer[1024];
 868         BOOL random_ok =
 869           smtp_write_command(&outblock, FALSE,
 870             "RCPT TO:<%.1000s@%.1000s>\r\n", random_local_part,
 871             addr->domain) >= 0 &&
 872           smtp_read_response(&inblock, randombuffer,
 873             sizeof(randombuffer), '2', callout);
 874
 875         /* Remember when we last did a random test */
 876
 877         new_domain_record.random_stamp = time(NULL);
 878
 879         /* If accepted, we aren't going to do any further tests below. */
 880
 881         if (random_ok)
 882           new_domain_record.random_result = ccache_accept;
 883
 884         /* Otherwise, cache a real negative response, and get back to the right
 885         state to send RCPT. Unless there's some problem such as a dropped
 886         connection, we expect to succeed, because the commands succeeded above. */
 887
 888         else if (errno == 0)
 889           {
 890           if (randombuffer[0] == '5')
 891             new_domain_record.random_result = ccache_reject;
 892
 893           done =
 894             smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0 &&
 895             smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
 896               '2', callout) &&
 897
 898             smtp_write_command(&outblock, FALSE, "MAIL FROM:<%s>\r\n",
 899               from_address) >= 0 &&
 900             smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
 901               '2', callout);
 902           }
 903         else done = FALSE;    /* Some timeout/connection problem */
 904         }                     /* Random check */
 905
 906       /* If the host is accepting all local parts, as determined by the "random"
 907       check, we don't need to waste time doing any further checking. */
 908
 909       if (new_domain_record.random_result != ccache_accept && done)
 910         {
 911         /* Get the rcpt_include_affixes flag from the transport if there is one,
 912         but assume FALSE if there is not. */
 913
 914         done =
 915           smtp_write_command(&outblock, FALSE, "RCPT TO:<%.1000s>\r\n",
 916             transport_rcpt_address(addr,
 917               (addr->transport == NULL)? FALSE :
 918                addr->transport->rcpt_include_affixes)) >= 0 &&
 919           smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
 920             '2', callout);
 921
 922         if (done)
 923           new_address_record.result = ccache_accept;
 924         else if (errno == 0 && responsebuffer[0] == '5')
 925           {
 926           *failure_ptr = US"recipient";
 927           new_address_record.result = ccache_reject;
 928           }
 929
 930         /* Do postmaster check if requested; if a full check is required, we
 931         check for RCPT TO:<postmaster> (no domain) in accordance with RFC 821. */
 932
 933         if (done && pm_mailfrom != NULL)
 934           {
 935           /*XXX not suitable for cutthrough - sequencing problems */
 936         cutthrough_delivery= FALSE;
 937         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of postmaster verify\n");
 938
 939           done =
 940             smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0 &&
 941             smtp_read_response(&inblock, responsebuffer,
 942               sizeof(responsebuffer), '2', callout) &&
 943
 944             smtp_write_command(&outblock, FALSE,
 945               "MAIL FROM:<%s>\r\n", pm_mailfrom) >= 0 &&
 946             smtp_read_response(&inblock, responsebuffer,
 947               sizeof(responsebuffer), '2', callout) &&
 948
 949             /* First try using the current domain */
 950
 951             ((
 952             smtp_write_command(&outblock, FALSE,
 953               "RCPT TO:<postmaster@%.1000s>\r\n", addr->domain) >= 0 &&
 954             smtp_read_response(&inblock, responsebuffer,
 955               sizeof(responsebuffer), '2', callout)
 956             )
 957
 958             ||
 959
 960             /* If that doesn't work, and a full check is requested,
 961             try without the domain. */
 962
 963             (
 964             (options & vopt_callout_fullpm) != 0 &&
 965             smtp_write_command(&outblock, FALSE,
 966               "RCPT TO:<postmaster>\r\n") >= 0 &&
 967             smtp_read_response(&inblock, responsebuffer,
 968               sizeof(responsebuffer), '2', callout)
 969             ));
 970
 971           /* Sort out the cache record */
 972
 973           new_domain_record.postmaster_stamp = time(NULL);
 974
 975           if (done)
 976             new_domain_record.postmaster_result = ccache_accept;
 977           else if (errno == 0 && responsebuffer[0] == '5')
 978             {
 979             *failure_ptr = US"postmaster";
 980             setflag(addr, af_verify_pmfail);
 981             new_domain_record.postmaster_result = ccache_reject;
 982             }
 983           }
 984         }           /* Random not accepted */
 985       }             /* MAIL FROM: accepted */
 986
 987     /* For any failure of the main check, other than a negative response, we just
 988     close the connection and carry on. We can identify a negative response by the
 989     fact that errno is zero. For I/O errors it will be non-zero
 990
 991     Set up different error texts for logging and for sending back to the caller
 992     as an SMTP response. Log in all cases, using a one-line format. For sender
 993     callouts, give a full response to the caller, but for recipient callouts,
 994     don't give the IP address because this may be an internal host whose identity
 995     is not to be widely broadcast. */
 996
 997     if (!done)
 998       {
 999       if (errno == ETIMEDOUT)
1000         {
1001         HDEBUG(D_verify) debug_printf("SMTP timeout\n");
1002         send_quit = FALSE;
1003         }
1004       else if (errno == 0)
1005         {
1006         if (*responsebuffer == 0) Ustrcpy(responsebuffer, US"connection dropped");
1007
1008         addr->message =
1009           string_sprintf("response to \"%s\" from %s [%s] was: %s",
1010             big_buffer, host->name, host->address,
1011             string_printing(responsebuffer));
1012
1013         addr->user_message = is_recipient?
1014           string_sprintf("Callout verification failed:\n%s", responsebuffer)
1015           :
1016           string_sprintf("Called:   %s\nSent:     %s\nResponse: %s",
1017             host->address, big_buffer, responsebuffer);
1018
1019         /* Hard rejection ends the process */
1020
1021         if (responsebuffer[0] == '5')   /* Address rejected */
1022           {
1023           yield = FAIL;
1024           done = TRUE;
1025           }
1026         }
1027       }
1028
1029     /* End the SMTP conversation and close the connection. */
1030
1031     /* Cutthrough - on a successfull connect and recipient-verify with use-sender
1032     and we have no cutthrough conn so far
1033     here is where we want to leave the conn open */
1034     if (  cutthrough_delivery
1035        && done
1036        && yield == OK
1037        && (options & (vopt_callout_recipsender|vopt_callout_recippmaster)) == vopt_callout_recipsender
1038        && !random_local_part
1039        && !pm_mailfrom
1040        && cutthrough_fd < 0
1041        )
1042       {
1043       cutthrough_fd= outblock.sock;     /* We assume no buffer in use in the outblock */
1044       cutthrough_addr = *addr;          /* Save the address_item for later logging */
1045       cutthrough_addr.next =      NULL;
1046       cutthrough_addr.host_used = store_get(sizeof(host_item));
1047       *(cutthrough_addr.host_used) = *host;
1048       if (addr->parent)
1049         *(cutthrough_addr.parent = store_get(sizeof(address_item)))= *addr->parent;
1050       ctblock.buffer = ctbuffer;
1051       ctblock.buffersize = sizeof(ctbuffer);
1052       ctblock.ptr = ctbuffer;
1053       /* ctblock.cmd_count = 0; ctblock.authenticating = FALSE; */
1054       ctblock.sock = cutthrough_fd;
1055       }
1056     else
1057       {
1058       /* Ensure no cutthrough on multiple address verifies */
1059       if (options & vopt_callout_recipsender)
1060         cancel_cutthrough_connection("multiple verify calls");
1061       if (send_quit) (void)smtp_write_command(&outblock, FALSE, "QUIT\r\n");
1062
1063 #ifdef SUPPORT_TLS
1064       tls_close(FALSE, TRUE);
1065 #endif
1066       (void)close(inblock.sock);
1067 #ifdef EXPERIMENTAL_EVENT
1068       (void) event_raise(addr->transport->event_action,
1069                               US"tcp:close", NULL);
1070 #endif
1071       }
1072
1073     }    /* Loop through all hosts, while !done */
1074   }
1075
1076 /* If we get here with done == TRUE, a successful callout happened, and yield
1077 will be set OK or FAIL according to the response to the RCPT command.
1078 Otherwise, we looped through the hosts but couldn't complete the business.
1079 However, there may be domain-specific information to cache in both cases.
1080
1081 The value of the result field in the new_domain record is ccache_unknown if
1082 there was an error before or with MAIL FROM:, and errno was not zero,
1083 implying some kind of I/O error. We don't want to write the cache in that case.
1084 Otherwise the value is ccache_accept, ccache_reject, or ccache_reject_mfnull. */
1085
1086 if (!callout_no_cache && new_domain_record.result != ccache_unknown)
1087   {
1088   if ((dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE))
1089        == NULL)
1090     {
1091     HDEBUG(D_verify) debug_printf("callout cache: not available\n");
1092     }
1093   else
1094     {
1095     (void)dbfn_write(dbm_file, addr->domain, &new_domain_record,
1096       (int)sizeof(dbdata_callout_cache));
1097     HDEBUG(D_verify) debug_printf("wrote callout cache domain record:\n"
1098       "  result=%d postmaster=%d random=%d\n",
1099       new_domain_record.result,
1100       new_domain_record.postmaster_result,
1101       new_domain_record.random_result);
1102     }
1103   }
1104
1105 /* If a definite result was obtained for the callout, cache it unless caching
1106 is disabled. */
1107
1108 if (done)
1109   {
1110   if (!callout_no_cache && new_address_record.result != ccache_unknown)
1111     {
1112     if (dbm_file == NULL)
1113       dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE);
1114     if (dbm_file == NULL)
1115       {
1116       HDEBUG(D_verify) debug_printf("no callout cache available\n");
1117       }
1118     else
1119       {
1120       (void)dbfn_write(dbm_file, address_key, &new_address_record,
1121         (int)sizeof(dbdata_callout_cache_address));
1122       HDEBUG(D_verify) debug_printf("wrote %s callout cache address record\n",
1123         (new_address_record.result == ccache_accept)? "positive" : "negative");
1124       }
1125     }
1126   }    /* done */
1127
1128 /* Failure to connect to any host, or any response other than 2xx or 5xx is a
1129 temporary error. If there was only one host, and a response was received, leave
1130 it alone if supplying details. Otherwise, give a generic response. */
1131
1132 else   /* !done */
1133   {
1134   uschar *dullmsg = string_sprintf("Could not complete %s verify callout",
1135     is_recipient? "recipient" : "sender");
1136   yield = DEFER;
1137
1138   if (host_list->next != NULL || addr->message == NULL) addr->message = dullmsg;
1139
1140   addr->user_message = (!smtp_return_error_details)? dullmsg :
1141     string_sprintf("%s for <%s>.\n"
1142       "The mail server(s) for the domain may be temporarily unreachable, or\n"
1143       "they may be permanently unreachable from this server. In the latter case,\n%s",
1144       dullmsg, addr->address,
1145       is_recipient?
1146         "the address will never be accepted."
1147         :
1148         "you need to change the address or create an MX record for its domain\n"
1149         "if it is supposed to be generally accessible from the Internet.\n"
1150         "Talk to your mail administrator for details.");
1151
1152   /* Force a specific error code */
1153
1154   addr->basic_errno = ERRNO_CALLOUTDEFER;
1155   }
1156
1157 /* Come here from within the cache-reading code on fast-track exit. */
1158
1159 END_CALLOUT:
1160 if (dbm_file != NULL) dbfn_close(dbm_file);
1161 return yield;
1162 }
1163
1164
1165
1166 /* Called after recipient-acl to get a cutthrough connection open when
1167    one was requested and a recipient-verify wasn't subsequently done.
1168 */
1169 void
1170 open_cutthrough_connection( address_item * addr )
1171 {
1172 address_item addr2;
1173
1174 /* Use a recipient-verify-callout to set up the cutthrough connection. */
1175 /* We must use a copy of the address for verification, because it might
1176 get rewritten. */
1177
1178 addr2 = *addr;
1179 HDEBUG(D_acl) debug_printf("----------- start cutthrough setup ------------\n");
1180 (void) verify_address(&addr2, NULL,
1181         vopt_is_recipient | vopt_callout_recipsender | vopt_callout_no_cache,
1182         CUTTHROUGH_CMD_TIMEOUT, -1, -1,
1183         NULL, NULL, NULL);
1184 HDEBUG(D_acl) debug_printf("----------- end cutthrough setup ------------\n");
1185 return;
1186 }
1187
1188
1189
1190 /* Send given number of bytes from the buffer */
1191 static BOOL
1192 cutthrough_send(int n)
1193 {
1194 if(cutthrough_fd < 0)
1195   return TRUE;
1196
1197 if(
1198 #ifdef SUPPORT_TLS
1199    (tls_out.active == cutthrough_fd) ? tls_write(FALSE, ctblock.buffer, n) :
1200 #endif
1201    send(cutthrough_fd, ctblock.buffer, n, 0) > 0
1202   )
1203 {
1204   transport_count += n;
1205   ctblock.ptr= ctblock.buffer;
1206   return TRUE;
1207 }
1208
1209 HDEBUG(D_transport|D_acl) debug_printf("cutthrough_send failed: %s\n", strerror(errno));
1210 return FALSE;
1211 }
1212
1213
1214
1215 static BOOL
1216 _cutthrough_puts(uschar * cp, int n)
1217 {
1218 while(n--)
1219  {
1220  if(ctblock.ptr >= ctblock.buffer+ctblock.buffersize)
1221    if(!cutthrough_send(ctblock.buffersize))
1222      return FALSE;
1223
1224  *ctblock.ptr++ = *cp++;
1225  }
1226 return TRUE;
1227 }
1228
1229 /* Buffered output of counted data block.   Return boolean success */
1230 BOOL
1231 cutthrough_puts(uschar * cp, int n)
1232 {
1233 if (cutthrough_fd < 0)       return TRUE;
1234 if (_cutthrough_puts(cp, n)) return TRUE;
1235 cancel_cutthrough_connection("transmit failed");
1236 return FALSE;
1237 }
1238
1239
1240 static BOOL
1241 _cutthrough_flush_send( void )
1242 {
1243 int n= ctblock.ptr-ctblock.buffer;
1244
1245 if(n>0)
1246   if(!cutthrough_send(n))
1247     return FALSE;
1248 return TRUE;
1249 }
1250
1251
1252 /* Send out any bufferred output.  Return boolean success. */
1253 BOOL
1254 cutthrough_flush_send( void )
1255 {
1256 if (_cutthrough_flush_send()) return TRUE;
1257 cancel_cutthrough_connection("transmit failed");
1258 return FALSE;
1259 }
1260
1261
1262 BOOL
1263 cutthrough_put_nl( void )
1264 {
1265 return cutthrough_puts(US"\r\n", 2);
1266 }
1267
1268
1269 /* Get and check response from cutthrough target */
1270 static uschar
1271 cutthrough_response(char expect, uschar ** copy)
1272 {
1273 smtp_inblock inblock;
1274 uschar inbuffer[4096];
1275 uschar responsebuffer[4096];
1276
1277 inblock.buffer = inbuffer;
1278 inblock.buffersize = sizeof(inbuffer);
1279 inblock.ptr = inbuffer;
1280 inblock.ptrend = inbuffer;
1281 inblock.sock = cutthrough_fd;
1282 /* this relies on (inblock.sock == tls_out.active) */
1283 if(!smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), expect, CUTTHROUGH_DATA_TIMEOUT))
1284   cancel_cutthrough_connection("target timeout on read");
1285
1286 if(copy != NULL)
1287   {
1288   uschar * cp;
1289   *copy= cp= string_copy(responsebuffer);
1290   /* Trim the trailing end of line */
1291   cp += Ustrlen(responsebuffer);
1292   if(cp > *copy  &&  cp[-1] == '\n') *--cp = '\0';
1293   if(cp > *copy  &&  cp[-1] == '\r') *--cp = '\0';
1294   }
1295
1296 return responsebuffer[0];
1297 }
1298
1299
1300 /* Negotiate dataphase with the cutthrough target, returning success boolean */
1301 BOOL
1302 cutthrough_predata( void )
1303 {
1304 if(cutthrough_fd < 0)
1305   return FALSE;
1306
1307 HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> DATA\n");
1308 cutthrough_puts(US"DATA\r\n", 6);
1309 cutthrough_flush_send();
1310
1311 /* Assume nothing buffered.  If it was it gets ignored. */
1312 return cutthrough_response('3', NULL) == '3';
1313 }
1314
1315
1316 /* fd and use_crlf args only to match write_chunk() */
1317 static BOOL
1318 cutthrough_write_chunk(int fd, uschar * s, int len, BOOL use_crlf)
1319 {
1320 uschar * s2;
1321 while(s && (s2 = Ustrchr(s, '\n')))
1322  {
1323  if(!cutthrough_puts(s, s2-s) || !cutthrough_put_nl())
1324   return FALSE;
1325  s = s2+1;
1326  }
1327 return TRUE;
1328 }
1329
1330
1331 /* Buffered send of headers.  Return success boolean. */
1332 /* Expands newlines to wire format (CR,NL).           */
1333 /* Also sends header-terminating blank line.          */
1334 BOOL
1335 cutthrough_headers_send( void )
1336 {
1337 if(cutthrough_fd < 0)
1338   return FALSE;
1339
1340 /* We share a routine with the mainline transport to handle header add/remove/rewrites,
1341    but having a separate buffered-output function (for now)
1342 */
1343 HDEBUG(D_acl) debug_printf("----------- start cutthrough headers send -----------\n");
1344
1345 if (!transport_headers_send(&cutthrough_addr, cutthrough_fd,
1346         cutthrough_addr.transport->add_headers, cutthrough_addr.transport->remove_headers,
1347         &cutthrough_write_chunk, TRUE,
1348         cutthrough_addr.transport->rewrite_rules, cutthrough_addr.transport->rewrite_existflags))
1349   return FALSE;
1350
1351 HDEBUG(D_acl) debug_printf("----------- done cutthrough headers send ------------\n");
1352 return TRUE;
1353 }
1354
1355
1356 static void
1357 close_cutthrough_connection( const char * why )
1358 {
1359 if(cutthrough_fd >= 0)
1360   {
1361   /* We could be sending this after a bunch of data, but that is ok as
1362      the only way to cancel the transfer in dataphase is to drop the tcp
1363      conn before the final dot.
1364   */
1365   ctblock.ptr = ctbuffer;
1366   HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> QUIT\n");
1367   _cutthrough_puts(US"QUIT\r\n", 6);    /* avoid recursion */
1368   _cutthrough_flush_send();
1369   /* No wait for response */
1370
1371   #ifdef SUPPORT_TLS
1372   tls_close(FALSE, TRUE);
1373   #endif
1374   (void)close(cutthrough_fd);
1375   cutthrough_fd= -1;
1376   HDEBUG(D_acl) debug_printf("----------- cutthrough shutdown (%s) ------------\n", why);
1377   }
1378 ctblock.ptr = ctbuffer;
1379 }
1380
1381 void
1382 cancel_cutthrough_connection( const char * why )
1383 {
1384 close_cutthrough_connection(why);
1385 cutthrough_delivery= FALSE;
1386 }
1387
1388
1389
1390
1391 /* Have senders final-dot.  Send one to cutthrough target, and grab the response.
1392    Log an OK response as a transmission.
1393    Close the connection.
1394    Return smtp response-class digit.
1395 */
1396 uschar *
1397 cutthrough_finaldot( void )
1398 {
1399 HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> .\n");
1400
1401 /* Assume data finshed with new-line */
1402 if(!cutthrough_puts(US".", 1) || !cutthrough_put_nl() || !cutthrough_flush_send())
1403   return cutthrough_addr.message;
1404
1405 switch(cutthrough_response('2', &cutthrough_addr.message))
1406   {
1407   case '2':
1408     delivery_log(LOG_MAIN, &cutthrough_addr, (int)'>', NULL);
1409     close_cutthrough_connection("delivered");
1410     break;
1411
1412   case '4':
1413     delivery_log(LOG_MAIN, &cutthrough_addr, 0, US"tmp-reject from cutthrough after DATA:");
1414     break;
1415
1416   case '5':
1417     delivery_log(LOG_MAIN|LOG_REJECT, &cutthrough_addr, 0, US"rejected after DATA:");
1418     break;
1419
1420   default:
1421     break;
1422   }
1423   return cutthrough_addr.message;
1424 }
1425
1426
1427
1428 /*************************************************
1429 *           Copy error to toplevel address       *
1430 *************************************************/
1431
1432 /* This function is used when a verify fails or defers, to ensure that the
1433 failure or defer information is in the original toplevel address. This applies
1434 when an address is redirected to a single new address, and the failure or
1435 deferral happens to the child address.
1436
1437 Arguments:
1438   vaddr       the verify address item
1439   addr        the final address item
1440   yield       FAIL or DEFER
1441
1442 Returns:      the value of YIELD
1443 */
1444
1445 static int
1446 copy_error(address_item *vaddr, address_item *addr, int yield)
1447 {
1448 if (addr != vaddr)
1449   {
1450   vaddr->message = addr->message;
1451   vaddr->user_message = addr->user_message;
1452   vaddr->basic_errno = addr->basic_errno;
1453   vaddr->more_errno = addr->more_errno;
1454   vaddr->p.address_data = addr->p.address_data;
1455   copyflag(vaddr, addr, af_pass_message);
1456   }
1457 return yield;
1458 }
1459
1460
1461
1462
1463 /**************************************************
1464 * printf that automatically handles TLS if needed *
1465 ***************************************************/
1466
1467 /* This function is used by verify_address() as a substitute for all fprintf()
1468 calls; a direct fprintf() will not produce output in a TLS SMTP session, such
1469 as a response to an EXPN command.  smtp_in.c makes smtp_printf available but
1470 that assumes that we always use the smtp_out FILE* when not using TLS or the
1471 ssl buffer when we are.  Instead we take a FILE* parameter and check to see if
1472 that is smtp_out; if so, smtp_printf() with TLS support, otherwise regular
1473 fprintf().
1474
1475 Arguments:
1476   f           the candidate FILE* to write to
1477   format      format string
1478   ...         optional arguments
1479
1480 Returns:
1481               nothing
1482 */
1483
1484 static void PRINTF_FUNCTION(2,3)
1485 respond_printf(FILE *f, const char *format, ...)
1486 {
1487 va_list ap;
1488
1489 va_start(ap, format);
1490 if (smtp_out && (f == smtp_out))
1491   smtp_vprintf(format, ap);
1492 else
1493   vfprintf(f, format, ap);
1494 va_end(ap);
1495 }
1496
1497
1498
1499 /*************************************************
1500 *            Verify an email address             *
1501 *************************************************/
1502
1503 /* This function is used both for verification (-bv and at other times) and
1504 address testing (-bt), which is indicated by address_test_mode being set.
1505
1506 Arguments:
1507   vaddr            contains the address to verify; the next field in this block
1508                      must be NULL
1509   f                if not NULL, write the result to this file
1510   options          various option bits:
1511                      vopt_fake_sender => this sender verify is not for the real
1512                        sender (it was verify=sender=xxxx or an address from a
1513                        header line) - rewriting must not change sender_address
1514                      vopt_is_recipient => this is a recipient address, otherwise
1515                        it's a sender address - this affects qualification and
1516                        rewriting and messages from callouts
1517                      vopt_qualify => qualify an unqualified address; else error
1518                      vopt_expn => called from SMTP EXPN command
1519                      vopt_success_on_redirect => when a new address is generated
1520                        the verification instantly succeeds
1521
1522                      These ones are used by do_callout() -- the options variable
1523                        is passed to it.
1524
1525                      vopt_callout_fullpm => if postmaster check, do full one
1526                      vopt_callout_no_cache => don't use callout cache
1527                      vopt_callout_random => do the "random" thing
1528                      vopt_callout_recipsender => use real sender for recipient
1529                      vopt_callout_recippmaster => use postmaster for recipient
1530
1531   callout          if > 0, specifies that callout is required, and gives timeout
1532                      for individual commands
1533   callout_overall  if > 0, gives overall timeout for the callout function;
1534                    if < 0, a default is used (see do_callout())
1535   callout_connect  the connection timeout for callouts
1536   se_mailfrom      when callout is requested to verify a sender, use this
1537                      in MAIL FROM; NULL => ""
1538   pm_mailfrom      when callout is requested, if non-NULL, do the postmaster
1539                      thing and use this as the sender address (may be "")
1540
1541   routed           if not NULL, set TRUE if routing succeeded, so we can
1542                      distinguish between routing failed and callout failed
1543
1544 Returns:           OK      address verified
1545                    FAIL    address failed to verify
1546                    DEFER   can't tell at present
1547 */
1548
1549 int
1550 verify_address(address_item *vaddr, FILE *f, int options, int callout,
1551   int callout_overall, int callout_connect, uschar *se_mailfrom,
1552   uschar *pm_mailfrom, BOOL *routed)
1553 {
1554 BOOL allok = TRUE;
1555 BOOL full_info = (f == NULL)? FALSE : (debug_selector != 0);
1556 BOOL is_recipient = (options & vopt_is_recipient) != 0;
1557 BOOL expn         = (options & vopt_expn) != 0;
1558 BOOL success_on_redirect = (options & vopt_success_on_redirect) != 0;
1559 int i;
1560 int yield = OK;
1561 int verify_type = expn? v_expn :
1562      address_test_mode? v_none :
1563           is_recipient? v_recipient : v_sender;
1564 address_item *addr_list;
1565 address_item *addr_new = NULL;
1566 address_item *addr_remote = NULL;
1567 address_item *addr_local = NULL;
1568 address_item *addr_succeed = NULL;
1569 uschar **failure_ptr = is_recipient?
1570   &recipient_verify_failure : &sender_verify_failure;
1571 uschar *ko_prefix, *cr;
1572 uschar *address = vaddr->address;
1573 uschar *save_sender;
1574 uschar null_sender[] = { 0 };             /* Ensure writeable memory */
1575
1576 /* Clear, just in case */
1577
1578 *failure_ptr = NULL;
1579
1580 /* Set up a prefix and suffix for error message which allow us to use the same
1581 output statements both in EXPN mode (where an SMTP response is needed) and when
1582 debugging with an output file. */
1583
1584 if (expn)
1585   {
1586   ko_prefix = US"553 ";
1587   cr = US"\r";
1588   }
1589 else ko_prefix = cr = US"";
1590
1591 /* Add qualify domain if permitted; otherwise an unqualified address fails. */
1592
1593 if (parse_find_at(address) == NULL)
1594   {
1595   if ((options & vopt_qualify) == 0)
1596     {
1597     if (f != NULL)
1598       respond_printf(f, "%sA domain is required for \"%s\"%s\n",
1599         ko_prefix, address, cr);
1600     *failure_ptr = US"qualify";
1601     return FAIL;
1602     }
1603   address = rewrite_address_qualify(address, is_recipient);
1604   }
1605
1606 DEBUG(D_verify)
1607   {
1608   debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1609   debug_printf("%s %s\n", address_test_mode? "Testing" : "Verifying", address);
1610   }
1611
1612 /* Rewrite and report on it. Clear the domain and local part caches - these
1613 may have been set by domains and local part tests during an ACL. */
1614
1615 if (global_rewrite_rules != NULL)
1616   {
1617   uschar *old = address;
1618   address = rewrite_address(address, is_recipient, FALSE,
1619     global_rewrite_rules, rewrite_existflags);
1620   if (address != old)
1621     {
1622     for (i = 0; i < (MAX_NAMED_LIST * 2)/32; i++) vaddr->localpart_cache[i] = 0;
1623     for (i = 0; i < (MAX_NAMED_LIST * 2)/32; i++) vaddr->domain_cache[i] = 0;
1624     if (f != NULL && !expn) fprintf(f, "Address rewritten as: %s\n", address);
1625     }
1626   }
1627
1628 /* If this is the real sender address, we must update sender_address at
1629 this point, because it may be referred to in the routers. */
1630
1631 if ((options & (vopt_fake_sender|vopt_is_recipient)) == 0)
1632   sender_address = address;
1633
1634 /* If the address was rewritten to <> no verification can be done, and we have
1635 to return OK. This rewriting is permitted only for sender addresses; for other
1636 addresses, such rewriting fails. */
1637
1638 if (address[0] == 0) return OK;
1639
1640 /* Flip the legacy TLS-related variables over to the outbound set in case
1641 they're used in the context of a transport used by verification. Reset them
1642 at exit from this routine. */
1643
1644 tls_modify_variables(&tls_out);
1645
1646 /* Save a copy of the sender address for re-instating if we change it to <>
1647 while verifying a sender address (a nice bit of self-reference there). */
1648
1649 save_sender = sender_address;
1650
1651 /* Update the address structure with the possibly qualified and rewritten
1652 address. Set it up as the starting address on the chain of new addresses. */
1653
1654 vaddr->address = address;
1655 addr_new = vaddr;
1656
1657 /* We need a loop, because an address can generate new addresses. We must also
1658 cope with generated pipes and files at the top level. (See also the code and
1659 comment in deliver.c.) However, it is usually the case that the router for
1660 user's .forward files has its verify flag turned off.
1661
1662 If an address generates more than one child, the loop is used only when
1663 full_info is set, and this can only be set locally. Remote enquiries just get
1664 information about the top level address, not anything that it generated. */
1665
1666 while (addr_new != NULL)
1667   {
1668   int rc;
1669   address_item *addr = addr_new;
1670
1671   addr_new = addr->next;
1672   addr->next = NULL;
1673
1674   DEBUG(D_verify)
1675     {
1676     debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1677     debug_printf("Considering %s\n", addr->address);
1678     }
1679
1680   /* Handle generated pipe, file or reply addresses. We don't get these
1681   when handling EXPN, as it does only one level of expansion. */
1682
1683   if (testflag(addr, af_pfr))
1684     {
1685     allok = FALSE;
1686     if (f != NULL)
1687       {
1688       BOOL allow;
1689
1690       if (addr->address[0] == '>')
1691         {
1692         allow = testflag(addr, af_allow_reply);
1693         fprintf(f, "%s -> mail %s", addr->parent->address, addr->address + 1);
1694         }
1695       else
1696         {
1697         allow = (addr->address[0] == '|')?
1698           testflag(addr, af_allow_pipe) : testflag(addr, af_allow_file);
1699         fprintf(f, "%s -> %s", addr->parent->address, addr->address);
1700         }
1701
1702       if (addr->basic_errno == ERRNO_BADTRANSPORT)
1703         fprintf(f, "\n*** Error in setting up pipe, file, or autoreply:\n"
1704           "%s\n", addr->message);
1705       else if (allow)
1706         fprintf(f, "\n  transport = %s\n", addr->transport->name);
1707       else
1708         fprintf(f, " *** forbidden ***\n");
1709       }
1710     continue;
1711     }
1712
1713   /* Just in case some router parameter refers to it. */
1714
1715   return_path = (addr->p.errors_address != NULL)?
1716     addr->p.errors_address : sender_address;
1717
1718   /* Split the address into domain and local part, handling the %-hack if
1719   necessary, and then route it. While routing a sender address, set
1720   $sender_address to <> because that is what it will be if we were trying to
1721   send a bounce to the sender. */
1722
1723   if (routed != NULL) *routed = FALSE;
1724   if ((rc = deliver_split_address(addr)) == OK)
1725     {
1726     if (!is_recipient) sender_address = null_sender;
1727     rc = route_address(addr, &addr_local, &addr_remote, &addr_new,
1728       &addr_succeed, verify_type);
1729     sender_address = save_sender;     /* Put back the real sender */
1730     }
1731
1732   /* If routing an address succeeded, set the flag that remembers, for use when
1733   an ACL cached a sender verify (in case a callout fails). Then if routing set
1734   up a list of hosts or the transport has a host list, and the callout option
1735   is set, and we aren't in a host checking run, do the callout verification,
1736   and set another flag that notes that a callout happened. */
1737
1738   if (rc == OK)
1739     {
1740     if (routed != NULL) *routed = TRUE;
1741     if (callout > 0)
1742       {
1743       host_item *host_list = addr->host_list;
1744
1745       /* Make up some data for use in the case where there is no remote
1746       transport. */
1747
1748       transport_feedback tf = {
1749         NULL,                       /* interface (=> any) */
1750         US"smtp",                   /* port */
1751         US"smtp",                   /* protocol */
1752         NULL,                       /* hosts */
1753         US"$smtp_active_hostname",  /* helo_data */
1754         FALSE,                      /* hosts_override */
1755         FALSE,                      /* hosts_randomize */
1756         FALSE,                      /* gethostbyname */
1757         TRUE,                       /* qualify_single */
1758         FALSE                       /* search_parents */
1759         };
1760
1761       /* If verification yielded a remote transport, we want to use that
1762       transport's options, so as to mimic what would happen if we were really
1763       sending a message to this address. */
1764
1765       if (addr->transport != NULL && !addr->transport->info->local)
1766         {
1767         (void)(addr->transport->setup)(addr->transport, addr, &tf, 0, 0, NULL);
1768
1769         /* If the transport has hosts and the router does not, or if the
1770         transport is configured to override the router's hosts, we must build a
1771         host list of the transport's hosts, and find the IP addresses */
1772
1773         if (tf.hosts != NULL && (host_list == NULL || tf.hosts_override))
1774           {
1775           uschar *s;
1776           uschar *save_deliver_domain = deliver_domain;
1777           uschar *save_deliver_localpart = deliver_localpart;
1778
1779           host_list = NULL;    /* Ignore the router's hosts */
1780
1781           deliver_domain = addr->domain;
1782           deliver_localpart = addr->local_part;
1783           s = expand_string(tf.hosts);
1784           deliver_domain = save_deliver_domain;
1785           deliver_localpart = save_deliver_localpart;
1786
1787           if (s == NULL)
1788             {
1789             log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand list of hosts "
1790               "\"%s\" in %s transport for callout: %s", tf.hosts,
1791               addr->transport->name, expand_string_message);
1792             }
1793           else
1794             {
1795             int flags;
1796             uschar *canonical_name;
1797             host_item *host, *nexthost;
1798             host_build_hostlist(&host_list, s, tf.hosts_randomize);
1799
1800             /* Just ignore failures to find a host address. If we don't manage
1801             to find any addresses, the callout will defer. Note that more than
1802             one address may be found for a single host, which will result in
1803             additional host items being inserted into the chain. Hence we must
1804             save the next host first. */
1805
1806             flags = HOST_FIND_BY_A;
1807             if (tf.qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
1808             if (tf.search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
1809
1810             for (host = host_list; host != NULL; host = nexthost)
1811               {
1812               nexthost = host->next;
1813               if (tf.gethostbyname ||
1814                   string_is_ip_address(host->name, NULL) != 0)
1815                 (void)host_find_byname(host, NULL, flags, &canonical_name, TRUE);
1816               else
1817                 {
1818                 uschar * d_request = NULL, * d_require = NULL;
1819                 if (Ustrcmp(addr->transport->driver_name, "smtp") == 0)
1820                   {
1821                   smtp_transport_options_block * ob =
1822                       (smtp_transport_options_block *)
1823                         addr->transport->options_block;
1824                   d_request = ob->dnssec_request_domains;
1825                   d_require = ob->dnssec_require_domains;
1826                   }
1827
1828                 (void)host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
1829                   d_request, d_require, &canonical_name, NULL);
1830                 }
1831               }
1832             }
1833           }
1834         }
1835
1836       /* Can only do a callout if we have at least one host! If the callout
1837       fails, it will have set ${sender,recipient}_verify_failure. */
1838
1839       if (host_list != NULL)
1840         {
1841         HDEBUG(D_verify) debug_printf("Attempting full verification using callout\n");
1842         if (host_checking && !host_checking_callout)
1843           {
1844           HDEBUG(D_verify)
1845             debug_printf("... callout omitted by default when host testing\n"
1846               "(Use -bhc if you want the callouts to happen.)\n");
1847           }
1848         else
1849           {
1850 #ifdef SUPPORT_TLS
1851           deliver_set_expansions(addr);
1852 #endif
1853           verify_mode = is_recipient ? US"R" : US"S";
1854           rc = do_callout(addr, host_list, &tf, callout, callout_overall,
1855             callout_connect, options, se_mailfrom, pm_mailfrom);
1856           verify_mode = NULL;
1857           }
1858         }
1859       else
1860         {
1861         HDEBUG(D_verify) debug_printf("Cannot do callout: neither router nor "
1862           "transport provided a host list\n");
1863         }
1864       }
1865     }
1866
1867   /* Otherwise, any failure is a routing failure */
1868
1869   else *failure_ptr = US"route";
1870
1871   /* A router may return REROUTED if it has set up a child address as a result
1872   of a change of domain name (typically from widening). In this case we always
1873   want to continue to verify the new child. */
1874
1875   if (rc == REROUTED) continue;
1876
1877   /* Handle hard failures */
1878
1879   if (rc == FAIL)
1880     {
1881     allok = FALSE;
1882     if (f != NULL)
1883       {
1884       address_item *p = addr->parent;
1885
1886       respond_printf(f, "%s%s %s", ko_prefix,
1887         full_info? addr->address : address,
1888         address_test_mode? "is undeliverable" : "failed to verify");
1889       if (!expn && admin_user)
1890         {
1891         if (addr->basic_errno > 0)
1892           respond_printf(f, ": %s", strerror(addr->basic_errno));
1893         if (addr->message != NULL)
1894           respond_printf(f, ": %s", addr->message);
1895         }
1896
1897       /* Show parents iff doing full info */
1898
1899       if (full_info) while (p != NULL)
1900         {
1901         respond_printf(f, "%s\n    <-- %s", cr, p->address);
1902         p = p->parent;
1903         }
1904       respond_printf(f, "%s\n", cr);
1905       }
1906     cancel_cutthrough_connection("routing hard fail");
1907
1908     if (!full_info)
1909     {
1910       yield = copy_error(vaddr, addr, FAIL);
1911       goto out;
1912     }
1913     else yield = FAIL;
1914     }
1915
1916   /* Soft failure */
1917
1918   else if (rc == DEFER)
1919     {
1920     allok = FALSE;
1921     if (f != NULL)
1922       {
1923       address_item *p = addr->parent;
1924       respond_printf(f, "%s%s cannot be resolved at this time", ko_prefix,
1925         full_info? addr->address : address);
1926       if (!expn && admin_user)
1927         {
1928         if (addr->basic_errno > 0)
1929           respond_printf(f, ": %s", strerror(addr->basic_errno));
1930         if (addr->message != NULL)
1931           respond_printf(f, ": %s", addr->message);
1932         else if (addr->basic_errno <= 0)
1933           respond_printf(f, ": unknown error");
1934         }
1935
1936       /* Show parents iff doing full info */
1937
1938       if (full_info) while (p != NULL)
1939         {
1940         respond_printf(f, "%s\n    <-- %s", cr, p->address);
1941         p = p->parent;
1942         }
1943       respond_printf(f, "%s\n", cr);
1944       }
1945     cancel_cutthrough_connection("routing soft fail");
1946
1947     if (!full_info)
1948       {
1949       yield = copy_error(vaddr, addr, DEFER);
1950       goto out;
1951       }
1952     else if (yield == OK) yield = DEFER;
1953     }
1954
1955   /* If we are handling EXPN, we do not want to continue to route beyond
1956   the top level (whose address is in "address"). */
1957
1958   else if (expn)
1959     {
1960     uschar *ok_prefix = US"250-";
1961     if (addr_new == NULL)
1962       {
1963       if (addr_local == NULL && addr_remote == NULL)
1964         respond_printf(f, "250 mail to <%s> is discarded\r\n", address);
1965       else
1966         respond_printf(f, "250 <%s>\r\n", address);
1967       }
1968     else while (addr_new != NULL)
1969       {
1970       address_item *addr2 = addr_new;
1971       addr_new = addr2->next;
1972       if (addr_new == NULL) ok_prefix = US"250 ";
1973       respond_printf(f, "%s<%s>\r\n", ok_prefix, addr2->address);
1974       }
1975     yield = OK;
1976     goto out;
1977     }
1978
1979   /* Successful routing other than EXPN. */
1980
1981   else
1982     {
1983     /* Handle successful routing when short info wanted. Otherwise continue for
1984     other (generated) addresses. Short info is the operational case. Full info
1985     can be requested only when debug_selector != 0 and a file is supplied.
1986
1987     There is a conflict between the use of aliasing as an alternate email
1988     address, and as a sort of mailing list. If an alias turns the incoming
1989     address into just one address (e.g. J.Caesar->jc44) you may well want to
1990     carry on verifying the generated address to ensure it is valid when
1991     checking incoming mail. If aliasing generates multiple addresses, you
1992     probably don't want to do this. Exim therefore treats the generation of
1993     just a single new address as a special case, and continues on to verify the
1994     generated address. */
1995
1996     if (!full_info &&                    /* Stop if short info wanted AND */
1997          (((addr_new == NULL ||          /* No new address OR */
1998            addr_new->next != NULL ||     /* More than one new address OR */
1999            testflag(addr_new, af_pfr)))  /* New address is pfr */
2000          ||                              /* OR */
2001          (addr_new != NULL &&            /* At least one new address AND */
2002           success_on_redirect)))         /* success_on_redirect is set */
2003       {
2004       if (f != NULL) fprintf(f, "%s %s\n", address,
2005         address_test_mode? "is deliverable" : "verified");
2006
2007       /* If we have carried on to verify a child address, we want the value
2008       of $address_data to be that of the child */
2009
2010       vaddr->p.address_data = addr->p.address_data;
2011       yield = OK;
2012       goto out;
2013       }
2014     }
2015   }     /* Loop for generated addresses */
2016
2017 /* Display the full results of the successful routing, including any generated
2018 addresses. Control gets here only when full_info is set, which requires f not
2019 to be NULL, and this occurs only when a top-level verify is called with the
2020 debugging switch on.
2021
2022 If there are no local and no remote addresses, and there were no pipes, files,
2023 or autoreplies, and there were no errors or deferments, the message is to be
2024 discarded, usually because of the use of :blackhole: in an alias file. */
2025
2026 if (allok && addr_local == NULL && addr_remote == NULL)
2027   {
2028   fprintf(f, "mail to %s is discarded\n", address);
2029   goto out;
2030   }
2031
2032 for (addr_list = addr_local, i = 0; i < 2; addr_list = addr_remote, i++)
2033   {
2034   while (addr_list != NULL)
2035     {
2036     address_item *addr = addr_list;
2037     address_item *p = addr->parent;
2038     addr_list = addr->next;
2039
2040     fprintf(f, "%s", CS addr->address);
2041 #ifdef EXPERIMENTAL_SRS
2042     if(addr->p.srs_sender)
2043       fprintf(f, "    [srs = %s]", addr->p.srs_sender);
2044 #endif
2045
2046     /* If the address is a duplicate, show something about it. */
2047
2048     if (!testflag(addr, af_pfr))
2049       {
2050       tree_node *tnode;
2051       if ((tnode = tree_search(tree_duplicates, addr->unique)) != NULL)
2052         fprintf(f, "   [duplicate, would not be delivered]");
2053       else tree_add_duplicate(addr->unique, addr);
2054       }
2055
2056     /* Now show its parents */
2057
2058     while (p != NULL)
2059       {
2060       fprintf(f, "\n    <-- %s", p->address);
2061       p = p->parent;
2062       }
2063     fprintf(f, "\n  ");
2064
2065     /* Show router, and transport */
2066
2067     fprintf(f, "router = %s, ", addr->router->name);
2068     fprintf(f, "transport = %s\n", (addr->transport == NULL)? US"unset" :
2069       addr->transport->name);
2070
2071     /* Show any hosts that are set up by a router unless the transport
2072     is going to override them; fiddle a bit to get a nice format. */
2073
2074     if (addr->host_list != NULL && addr->transport != NULL &&
2075         !addr->transport->overrides_hosts)
2076       {
2077       host_item *h;
2078       int maxlen = 0;
2079       int maxaddlen = 0;
2080       for (h = addr->host_list; h != NULL; h = h->next)
2081         {
2082         int len = Ustrlen(h->name);
2083         if (len > maxlen) maxlen = len;
2084         len = (h->address != NULL)? Ustrlen(h->address) : 7;
2085         if (len > maxaddlen) maxaddlen = len;
2086         }
2087       for (h = addr->host_list; h != NULL; h = h->next)
2088         {
2089         int len = Ustrlen(h->name);
2090         fprintf(f, "  host %s ", h->name);
2091         while (len++ < maxlen) fprintf(f, " ");
2092         if (h->address != NULL)
2093           {
2094           fprintf(f, "[%s] ", h->address);
2095           len = Ustrlen(h->address);
2096           }
2097         else if (!addr->transport->info->local)  /* Omit [unknown] for local */
2098           {
2099           fprintf(f, "[unknown] ");
2100           len = 7;
2101           }
2102         else len = -3;
2103         while (len++ < maxaddlen) fprintf(f," ");
2104         if (h->mx >= 0) fprintf(f, "MX=%d", h->mx);
2105         if (h->port != PORT_NONE) fprintf(f, " port=%d", h->port);
2106         if (h->status == hstatus_unusable) fprintf(f, " ** unusable **");
2107         fprintf(f, "\n");
2108         }
2109       }
2110     }
2111   }
2112
2113 /* Yield will be DEFER or FAIL if any one address has, only for full_info (which is
2114 the -bv or -bt case). */
2115
2116 out:
2117 tls_modify_variables(&tls_in);
2118
2119 return yield;
2120 }
2121
2122
2123
2124
2125 /*************************************************
2126 *      Check headers for syntax errors           *
2127 *************************************************/
2128
2129 /* This function checks those header lines that contain addresses, and verifies
2130 that all the addresses therein are syntactially correct.
2131
2132 Arguments:
2133   msgptr     where to put an error message
2134
2135 Returns:     OK
2136              FAIL
2137 */
2138
2139 int
2140 verify_check_headers(uschar **msgptr)
2141 {
2142 header_line *h;
2143 uschar *colon, *s;
2144 int yield = OK;
2145
2146 for (h = header_list; h != NULL && yield == OK; h = h->next)
2147   {
2148   if (h->type != htype_from &&
2149       h->type != htype_reply_to &&
2150       h->type != htype_sender &&
2151       h->type != htype_to &&
2152       h->type != htype_cc &&
2153       h->type != htype_bcc)
2154     continue;
2155
2156   colon = Ustrchr(h->text, ':');
2157   s = colon + 1;
2158   while (isspace(*s)) s++;
2159
2160   /* Loop for multiple addresses in the header, enabling group syntax. Note
2161   that we have to reset this after the header has been scanned. */
2162
2163   parse_allow_group = TRUE;
2164
2165   while (*s != 0)
2166     {
2167     uschar *ss = parse_find_address_end(s, FALSE);
2168     uschar *recipient, *errmess;
2169     int terminator = *ss;
2170     int start, end, domain;
2171
2172     /* Temporarily terminate the string at this point, and extract the
2173     operative address within, allowing group syntax. */
2174
2175     *ss = 0;
2176     recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
2177     *ss = terminator;
2178
2179     /* Permit an unqualified address only if the message is local, or if the
2180     sending host is configured to be permitted to send them. */
2181
2182     if (recipient != NULL && domain == 0)
2183       {
2184       if (h->type == htype_from || h->type == htype_sender)
2185         {
2186         if (!allow_unqualified_sender) recipient = NULL;
2187         }
2188       else
2189         {
2190         if (!allow_unqualified_recipient) recipient = NULL;
2191         }
2192       if (recipient == NULL) errmess = US"unqualified address not permitted";
2193       }
2194
2195     /* It's an error if no address could be extracted, except for the special
2196     case of an empty address. */
2197
2198     if (recipient == NULL && Ustrcmp(errmess, "empty address") != 0)
2199       {
2200       uschar *verb = US"is";
2201       uschar *t = ss;
2202       uschar *tt = colon;
2203       int len;
2204
2205       /* Arrange not to include any white space at the end in the
2206       error message or the header name. */
2207
2208       while (t > s && isspace(t[-1])) t--;
2209       while (tt > h->text && isspace(tt[-1])) tt--;
2210
2211       /* Add the address that failed to the error message, since in a
2212       header with very many addresses it is sometimes hard to spot
2213       which one is at fault. However, limit the amount of address to
2214       quote - cases have been seen where, for example, a missing double
2215       quote in a humungous To: header creates an "address" that is longer
2216       than string_sprintf can handle. */
2217
2218       len = t - s;
2219       if (len > 1024)
2220         {
2221         len = 1024;
2222         verb = US"begins";
2223         }
2224
2225       *msgptr = string_printing(
2226         string_sprintf("%s: failing address in \"%.*s:\" header %s: %.*s",
2227           errmess, tt - h->text, h->text, verb, len, s));
2228
2229       yield = FAIL;
2230       break;          /* Out of address loop */
2231       }
2232
2233     /* Advance to the next address */
2234
2235     s = ss + (terminator? 1:0);
2236     while (isspace(*s)) s++;
2237     }   /* Next address */
2238
2239   parse_allow_group = FALSE;
2240   parse_found_group = FALSE;
2241   }     /* Next header unless yield has been set FALSE */
2242
2243 return yield;
2244 }
2245
2246
2247 /*************************************************
2248 *      Check header names for 8-bit characters   *
2249 *************************************************/
2250
2251 /* This function checks for invalid charcters in header names. See
2252 RFC 5322, 2.2. and RFC 6532, 3.
2253
2254 Arguments:
2255   msgptr     where to put an error message
2256
2257 Returns:     OK
2258              FAIL
2259 */
2260
2261 int
2262 verify_check_header_names_ascii(uschar **msgptr)
2263 {
2264 header_line *h;
2265 uschar *colon, *s;
2266
2267 for (h = header_list; h != NULL; h = h->next)
2268   {
2269    colon = Ustrchr(h->text, ':');
2270    for(s = h->text; s < colon; s++)
2271      {
2272         if ((*s < 33) || (*s > 126))
2273         {
2274                 *msgptr = string_sprintf("Invalid character in header \"%.*s\" found",
2275                                          colon - h->text, h->text);
2276                 return FAIL;
2277         }
2278      }
2279   }
2280 return OK;
2281 }
2282
2283 /*************************************************
2284 *          Check for blind recipients            *
2285 *************************************************/
2286
2287 /* This function checks that every (envelope) recipient is mentioned in either
2288 the To: or Cc: header lines, thus detecting blind carbon copies.
2289
2290 There are two ways of scanning that could be used: either scan the header lines
2291 and tick off the recipients, or scan the recipients and check the header lines.
2292 The original proposed patch did the former, but I have chosen to do the latter,
2293 because (a) it requires no memory and (b) will use fewer resources when there
2294 are many addresses in To: and/or Cc: and only one or two envelope recipients.
2295
2296 Arguments:   none
2297 Returns:     OK    if there are no blind recipients
2298              FAIL  if there is at least one blind recipient
2299 */
2300
2301 int
2302 verify_check_notblind(void)
2303 {
2304 int i;
2305 for (i = 0; i < recipients_count; i++)
2306   {
2307   header_line *h;
2308   BOOL found = FALSE;
2309   uschar *address = recipients_list[i].address;
2310
2311   for (h = header_list; !found && h != NULL; h = h->next)
2312     {
2313     uschar *colon, *s;
2314
2315     if (h->type != htype_to && h->type != htype_cc) continue;
2316
2317     colon = Ustrchr(h->text, ':');
2318     s = colon + 1;
2319     while (isspace(*s)) s++;
2320
2321     /* Loop for multiple addresses in the header, enabling group syntax. Note
2322     that we have to reset this after the header has been scanned. */
2323
2324     parse_allow_group = TRUE;
2325
2326     while (*s != 0)
2327       {
2328       uschar *ss = parse_find_address_end(s, FALSE);
2329       uschar *recipient,*errmess;
2330       int terminator = *ss;
2331       int start, end, domain;
2332
2333       /* Temporarily terminate the string at this point, and extract the
2334       operative address within, allowing group syntax. */
2335
2336       *ss = 0;
2337       recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
2338       *ss = terminator;
2339
2340       /* If we found a valid recipient that has a domain, compare it with the
2341       envelope recipient. Local parts are compared case-sensitively, domains
2342       case-insensitively. By comparing from the start with length "domain", we
2343       include the "@" at the end, which ensures that we are comparing the whole
2344       local part of each address. */
2345
2346       if (recipient != NULL && domain != 0)
2347         {
2348         found = Ustrncmp(recipient, address, domain) == 0 &&
2349                 strcmpic(recipient + domain, address + domain) == 0;
2350         if (found) break;
2351         }
2352
2353       /* Advance to the next address */
2354
2355       s = ss + (terminator? 1:0);
2356       while (isspace(*s)) s++;
2357       }   /* Next address */
2358
2359     parse_allow_group = FALSE;
2360     parse_found_group = FALSE;
2361     }     /* Next header (if found is false) */
2362
2363   if (!found) return FAIL;
2364   }       /* Next recipient */
2365
2366 return OK;
2367 }
2368
2369
2370
2371 /*************************************************
2372 *          Find if verified sender               *
2373 *************************************************/
2374
2375 /* Usually, just a single address is verified as the sender of the message.
2376 However, Exim can be made to verify other addresses as well (often related in
2377 some way), and this is useful in some environments. There may therefore be a
2378 chain of such addresses that have previously been tested. This function finds
2379 whether a given address is on the chain.
2380
2381 Arguments:   the address to be verified
2382 Returns:     pointer to an address item, or NULL
2383 */
2384
2385 address_item *
2386 verify_checked_sender(uschar *sender)
2387 {
2388 address_item *addr;
2389 for (addr = sender_verified_list; addr != NULL; addr = addr->next)
2390   if (Ustrcmp(sender, addr->address) == 0) break;
2391 return addr;
2392 }
2393
2394
2395
2396
2397
2398 /*************************************************
2399 *             Get valid header address           *
2400 *************************************************/
2401
2402 /* Scan the originator headers of the message, looking for an address that
2403 verifies successfully. RFC 822 says:
2404
2405     o   The "Sender" field mailbox should be sent  notices  of
2406         any  problems in transport or delivery of the original
2407         messages.  If there is no  "Sender"  field,  then  the
2408         "From" field mailbox should be used.
2409
2410     o   If the "Reply-To" field exists, then the reply  should
2411         go to the addresses indicated in that field and not to
2412         the address(es) indicated in the "From" field.
2413
2414 So we check a Sender field if there is one, else a Reply_to field, else a From
2415 field. As some strange messages may have more than one of these fields,
2416 especially if they are resent- fields, check all of them if there is more than
2417 one.
2418
2419 Arguments:
2420   user_msgptr      points to where to put a user error message
2421   log_msgptr       points to where to put a log error message
2422   callout          timeout for callout check (passed to verify_address())
2423   callout_overall  overall callout timeout (ditto)
2424   callout_connect  connect callout timeout (ditto)
2425   se_mailfrom      mailfrom for verify; NULL => ""
2426   pm_mailfrom      sender for pm callout check (passed to verify_address())
2427   options          callout options (passed to verify_address())
2428   verrno           where to put the address basic_errno
2429
2430 If log_msgptr is set to something without setting user_msgptr, the caller
2431 normally uses log_msgptr for both things.
2432
2433 Returns:           result of the verification attempt: OK, FAIL, or DEFER;
2434                    FAIL is given if no appropriate headers are found
2435 */
2436
2437 int
2438 verify_check_header_address(uschar **user_msgptr, uschar **log_msgptr,
2439   int callout, int callout_overall, int callout_connect, uschar *se_mailfrom,
2440   uschar *pm_mailfrom, int options, int *verrno)
2441 {
2442 static int header_types[] = { htype_sender, htype_reply_to, htype_from };
2443 BOOL done = FALSE;
2444 int yield = FAIL;
2445 int i;
2446
2447 for (i = 0; i < 3 && !done; i++)
2448   {
2449   header_line *h;
2450   for (h = header_list; h != NULL && !done; h = h->next)
2451     {
2452     int terminator, new_ok;
2453     uschar *s, *ss, *endname;
2454
2455     if (h->type != header_types[i]) continue;
2456     s = endname = Ustrchr(h->text, ':') + 1;
2457
2458     /* Scan the addresses in the header, enabling group syntax. Note that we
2459     have to reset this after the header has been scanned. */
2460
2461     parse_allow_group = TRUE;
2462
2463     while (*s != 0)
2464       {
2465       address_item *vaddr;
2466
2467       while (isspace(*s) || *s == ',') s++;
2468       if (*s == 0) break;        /* End of header */
2469
2470       ss = parse_find_address_end(s, FALSE);
2471
2472       /* The terminator is a comma or end of header, but there may be white
2473       space preceding it (including newline for the last address). Move back
2474       past any white space so we can check against any cached envelope sender
2475       address verifications. */
2476
2477       while (isspace(ss[-1])) ss--;
2478       terminator = *ss;
2479       *ss = 0;
2480
2481       HDEBUG(D_verify) debug_printf("verifying %.*s header address %s\n",
2482         (int)(endname - h->text), h->text, s);
2483
2484       /* See if we have already verified this address as an envelope sender,
2485       and if so, use the previous answer. */
2486
2487       vaddr = verify_checked_sender(s);
2488
2489       if (vaddr != NULL &&                   /* Previously checked */
2490            (callout <= 0 ||                  /* No callout needed; OR */
2491             vaddr->special_action > 256))    /* Callout was done */
2492         {
2493         new_ok = vaddr->special_action & 255;
2494         HDEBUG(D_verify) debug_printf("previously checked as envelope sender\n");
2495         *ss = terminator;  /* Restore shortened string */
2496         }
2497
2498       /* Otherwise we run the verification now. We must restore the shortened
2499       string before running the verification, so the headers are correct, in
2500       case there is any rewriting. */
2501
2502       else
2503         {
2504         int start, end, domain;
2505         uschar *address = parse_extract_address(s, log_msgptr, &start, &end,
2506           &domain, FALSE);
2507
2508         *ss = terminator;
2509
2510         /* If we found an empty address, just carry on with the next one, but
2511         kill the message. */
2512
2513         if (address == NULL && Ustrcmp(*log_msgptr, "empty address") == 0)
2514           {
2515           *log_msgptr = NULL;
2516           s = ss;
2517           continue;
2518           }
2519
2520         /* If verification failed because of a syntax error, fail this
2521         function, and ensure that the failing address gets added to the error
2522         message. */
2523
2524         if (address == NULL)
2525           {
2526           new_ok = FAIL;
2527           while (ss > s && isspace(ss[-1])) ss--;
2528           *log_msgptr = string_sprintf("syntax error in '%.*s' header when "
2529             "scanning for sender: %s in \"%.*s\"",
2530             endname - h->text, h->text, *log_msgptr, ss - s, s);
2531           yield = FAIL;
2532           done = TRUE;
2533           break;
2534           }
2535
2536         /* Else go ahead with the sender verification. But it isn't *the*
2537         sender of the message, so set vopt_fake_sender to stop sender_address
2538         being replaced after rewriting or qualification. */
2539
2540         else
2541           {
2542           vaddr = deliver_make_addr(address, FALSE);
2543           new_ok = verify_address(vaddr, NULL, options | vopt_fake_sender,
2544             callout, callout_overall, callout_connect, se_mailfrom,
2545             pm_mailfrom, NULL);
2546           }
2547         }
2548
2549       /* We now have the result, either newly found, or cached. If we are
2550       giving out error details, set a specific user error. This means that the
2551       last of these will be returned to the user if all three fail. We do not
2552       set a log message - the generic one below will be used. */
2553
2554       if (new_ok != OK)
2555         {
2556         *verrno = vaddr->basic_errno;
2557         if (smtp_return_error_details)
2558           {
2559           *user_msgptr = string_sprintf("Rejected after DATA: "
2560             "could not verify \"%.*s\" header address\n%s: %s",
2561             endname - h->text, h->text, vaddr->address, vaddr->message);
2562           }
2563         }
2564
2565       /* Success or defer */
2566
2567       if (new_ok == OK)
2568         {
2569         yield = OK;
2570         done = TRUE;
2571         break;
2572         }
2573
2574       if (new_ok == DEFER) yield = DEFER;
2575
2576       /* Move on to any more addresses in the header */
2577
2578       s = ss;
2579       }     /* Next address */
2580
2581     parse_allow_group = FALSE;
2582     parse_found_group = FALSE;
2583     }       /* Next header, unless done */
2584   }         /* Next header type unless done */
2585
2586 if (yield == FAIL && *log_msgptr == NULL)
2587   *log_msgptr = US"there is no valid sender in any header line";
2588
2589 if (yield == DEFER && *log_msgptr == NULL)
2590   *log_msgptr = US"all attempts to verify a sender in a header line deferred";
2591
2592 return yield;
2593 }
2594
2595
2596
2597
2598 /*************************************************
2599 *            Get RFC 1413 identification         *
2600 *************************************************/
2601
2602 /* Attempt to get an id from the sending machine via the RFC 1413 protocol. If
2603 the timeout is set to zero, then the query is not done. There may also be lists
2604 of hosts and nets which are exempt. To guard against malefactors sending
2605 non-printing characters which could, for example, disrupt a message's headers,
2606 make sure the string consists of printing characters only.
2607
2608 Argument:
2609   port    the port to connect to; usually this is IDENT_PORT (113), but when
2610           running in the test harness with -bh a different value is used.
2611
2612 Returns:  nothing
2613
2614 Side effect: any received ident value is put in sender_ident (NULL otherwise)
2615 */
2616
2617 void
2618 verify_get_ident(int port)
2619 {
2620 int sock, host_af, qlen;
2621 int received_sender_port, received_interface_port, n;
2622 uschar *p;
2623 uschar buffer[2048];
2624
2625 /* Default is no ident. Check whether we want to do an ident check for this
2626 host. */
2627
2628 sender_ident = NULL;
2629 if (rfc1413_query_timeout <= 0 || verify_check_host(&rfc1413_hosts) != OK)
2630   return;
2631
2632 DEBUG(D_ident) debug_printf("doing ident callback\n");
2633
2634 /* Set up a connection to the ident port of the remote host. Bind the local end
2635 to the incoming interface address. If the sender host address is an IPv6
2636 address, the incoming interface address will also be IPv6. */
2637
2638 host_af = (Ustrchr(sender_host_address, ':') == NULL)? AF_INET : AF_INET6;
2639 sock = ip_socket(SOCK_STREAM, host_af);
2640 if (sock < 0) return;
2641
2642 if (ip_bind(sock, host_af, interface_address, 0) < 0)
2643   {
2644   DEBUG(D_ident) debug_printf("bind socket for ident failed: %s\n",
2645     strerror(errno));
2646   goto END_OFF;
2647   }
2648
2649 if (ip_connect(sock, host_af, sender_host_address, port, rfc1413_query_timeout)
2650      < 0)
2651   {
2652   if (errno == ETIMEDOUT && (log_extra_selector & LX_ident_timeout) != 0)
2653     {
2654     log_write(0, LOG_MAIN, "ident connection to %s timed out",
2655       sender_host_address);
2656     }
2657   else
2658     {
2659     DEBUG(D_ident) debug_printf("ident connection to %s failed: %s\n",
2660       sender_host_address, strerror(errno));
2661     }
2662   goto END_OFF;
2663   }
2664
2665 /* Construct and send the query. */
2666
2667 sprintf(CS buffer, "%d , %d\r\n", sender_host_port, interface_port);
2668 qlen = Ustrlen(buffer);
2669 if (send(sock, buffer, qlen, 0) < 0)
2670   {
2671   DEBUG(D_ident) debug_printf("ident send failed: %s\n", strerror(errno));
2672   goto END_OFF;
2673   }
2674
2675 /* Read a response line. We put it into the rest of the buffer, using several
2676 recv() calls if necessary. */
2677
2678 p = buffer + qlen;
2679
2680 for (;;)
2681   {
2682   uschar *pp;
2683   int count;
2684   int size = sizeof(buffer) - (p - buffer);
2685
2686   if (size <= 0) goto END_OFF;   /* Buffer filled without seeing \n. */
2687   count = ip_recv(sock, p, size, rfc1413_query_timeout);
2688   if (count <= 0) goto END_OFF;  /* Read error or EOF */
2689
2690   /* Scan what we just read, to see if we have reached the terminating \r\n. Be
2691   generous, and accept a plain \n terminator as well. The only illegal
2692   character is 0. */
2693
2694   for (pp = p; pp < p + count; pp++)
2695     {
2696     if (*pp == 0) goto END_OFF;   /* Zero octet not allowed */
2697     if (*pp == '\n')
2698       {
2699       if (pp[-1] == '\r') pp--;
2700       *pp = 0;
2701       goto GOT_DATA;             /* Break out of both loops */
2702       }
2703     }
2704
2705   /* Reached the end of the data without finding \n. Let the loop continue to
2706   read some more, if there is room. */
2707
2708   p = pp;
2709   }
2710
2711 GOT_DATA:
2712
2713 /* We have received a line of data. Check it carefully. It must start with the
2714 same two port numbers that we sent, followed by data as defined by the RFC. For
2715 example,
2716
2717   12345 , 25 : USERID : UNIX :root
2718
2719 However, the amount of white space may be different to what we sent. In the
2720 "osname" field there may be several sub-fields, comma separated. The data we
2721 actually want to save follows the third colon. Some systems put leading spaces
2722 in it - we discard those. */
2723
2724 if (sscanf(CS buffer + qlen, "%d , %d%n", &received_sender_port,
2725       &received_interface_port, &n) != 2 ||
2726     received_sender_port != sender_host_port ||
2727     received_interface_port != interface_port)
2728   goto END_OFF;
2729
2730 p = buffer + qlen + n;
2731 while(isspace(*p)) p++;
2732 if (*p++ != ':') goto END_OFF;
2733 while(isspace(*p)) p++;
2734 if (Ustrncmp(p, "USERID", 6) != 0) goto END_OFF;
2735 p += 6;
2736 while(isspace(*p)) p++;
2737 if (*p++ != ':') goto END_OFF;
2738 while (*p != 0 && *p != ':') p++;
2739 if (*p++ == 0) goto END_OFF;
2740 while(isspace(*p)) p++;
2741 if (*p == 0) goto END_OFF;
2742
2743 /* The rest of the line is the data we want. We turn it into printing
2744 characters when we save it, so that it cannot mess up the format of any logging
2745 or Received: lines into which it gets inserted. We keep a maximum of 127
2746 characters. */
2747
2748 sender_ident = string_printing(string_copyn(p, 127));
2749 DEBUG(D_ident) debug_printf("sender_ident = %s\n", sender_ident);
2750
2751 END_OFF:
2752 (void)close(sock);
2753 return;
2754 }
2755
2756
2757
2758
2759 /*************************************************
2760 *      Match host to a single host-list item     *
2761 *************************************************/
2762
2763 /* This function compares a host (name or address) against a single item
2764 from a host list. The host name gets looked up if it is needed and is not
2765 already known. The function is called from verify_check_this_host() via
2766 match_check_list(), which is why most of its arguments are in a single block.
2767
2768 Arguments:
2769   arg            the argument block (see below)
2770   ss             the host-list item
2771   valueptr       where to pass back looked up data, or NULL
2772   error          for error message when returning ERROR
2773
2774 The block contains:
2775   host_name      (a) the host name, or
2776                  (b) NULL, implying use sender_host_name and
2777                        sender_host_aliases, looking them up if required, or
2778                  (c) the empty string, meaning that only IP address matches
2779                        are permitted
2780   host_address   the host address
2781   host_ipv4      the IPv4 address taken from an IPv6 one
2782
2783 Returns:         OK      matched
2784                  FAIL    did not match
2785                  DEFER   lookup deferred
2786                  ERROR   (a) failed to find the host name or IP address, or
2787                          (b) unknown lookup type specified, or
2788                          (c) host name encountered when only IP addresses are
2789                                being matched
2790 */
2791
2792 int
2793 check_host(void *arg, uschar *ss, uschar **valueptr, uschar **error)
2794 {
2795 check_host_block *cb = (check_host_block *)arg;
2796 int mlen = -1;
2797 int maskoffset;
2798 BOOL iplookup = FALSE;
2799 BOOL isquery = FALSE;
2800 BOOL isiponly = cb->host_name != NULL && cb->host_name[0] == 0;
2801 uschar *t;
2802 uschar *semicolon;
2803 uschar **aliases;
2804
2805 /* Optimize for the special case when the pattern is "*". */
2806
2807 if (*ss == '*' && ss[1] == 0) return OK;
2808
2809 /* If the pattern is empty, it matches only in the case when there is no host -
2810 this can occur in ACL checking for SMTP input using the -bs option. In this
2811 situation, the host address is the empty string. */
2812
2813 if (cb->host_address[0] == 0) return (*ss == 0)? OK : FAIL;
2814 if (*ss == 0) return FAIL;
2815
2816 /* If the pattern is precisely "@" then match against the primary host name,
2817 provided that host name matching is permitted; if it's "@[]" match against the
2818 local host's IP addresses. */
2819
2820 if (*ss == '@')
2821   {
2822   if (ss[1] == 0)
2823     {
2824     if (isiponly) return ERROR;
2825     ss = primary_hostname;
2826     }
2827   else if (Ustrcmp(ss, "@[]") == 0)
2828     {
2829     ip_address_item *ip;
2830     for (ip = host_find_interfaces(); ip != NULL; ip = ip->next)
2831       if (Ustrcmp(ip->address, cb->host_address) == 0) return OK;
2832     return FAIL;
2833     }
2834   }
2835
2836 /* If the pattern is an IP address, optionally followed by a bitmask count, do
2837 a (possibly masked) comparision with the current IP address. */
2838
2839 if (string_is_ip_address(ss, &maskoffset) != 0)
2840   return (host_is_in_net(cb->host_address, ss, maskoffset)? OK : FAIL);
2841
2842 /* The pattern is not an IP address. A common error that people make is to omit
2843 one component of an IPv4 address, either by accident, or believing that, for
2844 example, 1.2.3/24 is the same as 1.2.3.0/24, or 1.2.3 is the same as 1.2.3.0,
2845 which it isn't. (Those applications that do accept 1.2.3 as an IP address
2846 interpret it as 1.2.0.3 because the final component becomes 16-bit - this is an
2847 ancient specification.) To aid in debugging these cases, we give a specific
2848 error if the pattern contains only digits and dots or contains a slash preceded
2849 only by digits and dots (a slash at the start indicates a file name and of
2850 course slashes may be present in lookups, but not preceded only by digits and
2851 dots). */
2852
2853 for (t = ss; isdigit(*t) || *t == '.'; t++);
2854 if (*t == 0 || (*t == '/' && t != ss))
2855   {
2856   *error = US"malformed IPv4 address or address mask";
2857   return ERROR;
2858   }
2859
2860 /* See if there is a semicolon in the pattern */
2861
2862 semicolon = Ustrchr(ss, ';');
2863
2864 /* If we are doing an IP address only match, then all lookups must be IP
2865 address lookups, even if there is no "net-". */
2866
2867 if (isiponly)
2868   {
2869   iplookup = semicolon != NULL;
2870   }
2871
2872 /* Otherwise, if the item is of the form net[n]-lookup;<file|query> then it is
2873 a lookup on a masked IP network, in textual form. We obey this code even if we
2874 have already set iplookup, so as to skip over the "net-" prefix and to set the
2875 mask length. The net- stuff really only applies to single-key lookups where the
2876 key is implicit. For query-style lookups the key is specified in the query.
2877 From release 4.30, the use of net- for query style is no longer needed, but we
2878 retain it for backward compatibility. */
2879
2880 if (Ustrncmp(ss, "net", 3) == 0 && semicolon != NULL)
2881   {
2882   mlen = 0;
2883   for (t = ss + 3; isdigit(*t); t++) mlen = mlen * 10 + *t - '0';
2884   if (mlen == 0 && t == ss+3) mlen = -1;  /* No mask supplied */
2885   iplookup = (*t++ == '-');
2886   }
2887 else t = ss;
2888
2889 /* Do the IP address lookup if that is indeed what we have */
2890
2891 if (iplookup)
2892   {
2893   int insize;
2894   int search_type;
2895   int incoming[4];
2896   void *handle;
2897   uschar *filename, *key, *result;
2898   uschar buffer[64];
2899
2900   /* Find the search type */
2901
2902   search_type = search_findtype(t, semicolon - t);
2903
2904   if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
2905     search_error_message);
2906
2907   /* Adjust parameters for the type of lookup. For a query-style lookup, there
2908   is no file name, and the "key" is just the query. For query-style with a file
2909   name, we have to fish the file off the start of the query. For a single-key
2910   lookup, the key is the current IP address, masked appropriately, and
2911   reconverted to text form, with the mask appended. For IPv6 addresses, specify
2912   dot separators instead of colons, except when the lookup type is "iplsearch".
2913   */
2914
2915   if (mac_islookup(search_type, lookup_absfilequery))
2916     {
2917     filename = semicolon + 1;
2918     key = filename;
2919     while (*key != 0 && !isspace(*key)) key++;
2920     filename = string_copyn(filename, key - filename);
2921     while (isspace(*key)) key++;
2922     }
2923   else if (mac_islookup(search_type, lookup_querystyle))
2924     {
2925     filename = NULL;
2926     key = semicolon + 1;
2927     }
2928   else   /* Single-key style */
2929     {
2930     int sep = (Ustrcmp(lookup_list[search_type]->name, "iplsearch") == 0)?
2931       ':' : '.';
2932     insize = host_aton(cb->host_address, incoming);
2933     host_mask(insize, incoming, mlen);
2934     (void)host_nmtoa(insize, incoming, mlen, buffer, sep);
2935     key = buffer;
2936     filename = semicolon + 1;
2937     }
2938
2939   /* Now do the actual lookup; note that there is no search_close() because
2940   of the caching arrangements. */
2941
2942   handle = search_open(filename, search_type, 0, NULL, NULL);
2943   if (handle == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
2944     search_error_message);
2945   result = search_find(handle, filename, key, -1, NULL, 0, 0, NULL);
2946   if (valueptr != NULL) *valueptr = result;
2947   return (result != NULL)? OK : search_find_defer? DEFER: FAIL;
2948   }
2949
2950 /* The pattern is not an IP address or network reference of any kind. That is,
2951 it is a host name pattern. If this is an IP only match, there's an error in the
2952 host list. */
2953
2954 if (isiponly)
2955   {
2956   *error = US"cannot match host name in match_ip list";
2957   return ERROR;
2958   }
2959
2960 /* Check the characters of the pattern to see if they comprise only letters,
2961 digits, full stops, and hyphens (the constituents of domain names). Allow
2962 underscores, as they are all too commonly found. Sigh. Also, if
2963 allow_utf8_domains is set, allow top-bit characters. */
2964
2965 for (t = ss; *t != 0; t++)
2966   if (!isalnum(*t) && *t != '.' && *t != '-' && *t != '_' &&
2967       (!allow_utf8_domains || *t < 128)) break;
2968
2969 /* If the pattern is a complete domain name, with no fancy characters, look up
2970 its IP address and match against that. Note that a multi-homed host will add
2971 items to the chain. */
2972
2973 if (*t == 0)
2974   {
2975   int rc;
2976   host_item h;
2977   h.next = NULL;
2978   h.name = ss;
2979   h.address = NULL;
2980   h.mx = MX_NONE;
2981
2982   rc = host_find_byname(&h, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, FALSE);
2983   if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
2984     {
2985     host_item *hh;
2986     for (hh = &h; hh != NULL; hh = hh->next)
2987       {
2988       if (host_is_in_net(hh->address, cb->host_address, 0)) return OK;
2989       }
2990     return FAIL;
2991     }
2992   if (rc == HOST_FIND_AGAIN) return DEFER;
2993   *error = string_sprintf("failed to find IP address for %s", ss);
2994   return ERROR;
2995   }
2996
2997 /* Almost all subsequent comparisons require the host name, and can be done
2998 using the general string matching function. When this function is called for
2999 outgoing hosts, the name is always given explicitly. If it is NULL, it means we
3000 must use sender_host_name and its aliases, looking them up if necessary. */
3001
3002 if (cb->host_name != NULL)   /* Explicit host name given */
3003   return match_check_string(cb->host_name, ss, -1, TRUE, TRUE, TRUE,
3004     valueptr);
3005
3006 /* Host name not given; in principle we need the sender host name and its
3007 aliases. However, for query-style lookups, we do not need the name if the
3008 query does not contain $sender_host_name. From release 4.23, a reference to
3009 $sender_host_name causes it to be looked up, so we don't need to do the lookup
3010 on spec. */
3011
3012 if ((semicolon = Ustrchr(ss, ';')) != NULL)
3013   {
3014   uschar *affix;
3015   int partial, affixlen, starflags, id;
3016
3017   *semicolon = 0;
3018   id = search_findtype_partial(ss, &partial, &affix, &affixlen, &starflags);
3019   *semicolon=';';
3020
3021   if (id < 0)                           /* Unknown lookup type */
3022     {
3023     log_write(0, LOG_MAIN|LOG_PANIC, "%s in host list item \"%s\"",
3024       search_error_message, ss);
3025     return DEFER;
3026     }
3027   isquery = mac_islookup(id, lookup_querystyle|lookup_absfilequery);
3028   }
3029
3030 if (isquery)
3031   {
3032   switch(match_check_string(US"", ss, -1, TRUE, TRUE, TRUE, valueptr))
3033     {
3034     case OK:    return OK;
3035     case DEFER: return DEFER;
3036     default:    return FAIL;
3037     }
3038   }
3039
3040 /* Not a query-style lookup; must ensure the host name is present, and then we
3041 do a check on the name and all its aliases. */
3042
3043 if (sender_host_name == NULL)
3044   {
3045   HDEBUG(D_host_lookup)
3046     debug_printf("sender host name required, to match against %s\n", ss);
3047   if (host_lookup_failed || host_name_lookup() != OK)
3048     {
3049     *error = string_sprintf("failed to find host name for %s",
3050       sender_host_address);;
3051     return ERROR;
3052     }
3053   host_build_sender_fullhost();
3054   }
3055
3056 /* Match on the sender host name, using the general matching function */
3057
3058 switch(match_check_string(sender_host_name, ss, -1, TRUE, TRUE, TRUE,
3059        valueptr))
3060   {
3061   case OK:    return OK;
3062   case DEFER: return DEFER;
3063   }
3064
3065 /* If there are aliases, try matching on them. */
3066
3067 aliases = sender_host_aliases;
3068 while (*aliases != NULL)
3069   {
3070   switch(match_check_string(*aliases++, ss, -1, TRUE, TRUE, TRUE, valueptr))
3071     {
3072     case OK:    return OK;
3073     case DEFER: return DEFER;
3074     }
3075   }
3076 return FAIL;
3077 }
3078
3079
3080
3081
3082 /*************************************************
3083 *    Check a specific host matches a host list   *
3084 *************************************************/
3085
3086 /* This function is passed a host list containing items in a number of
3087 different formats and the identity of a host. Its job is to determine whether
3088 the given host is in the set of hosts defined by the list. The host name is
3089 passed as a pointer so that it can be looked up if needed and not already
3090 known. This is commonly the case when called from verify_check_host() to check
3091 an incoming connection. When called from elsewhere the host name should usually
3092 be set.
3093
3094 This function is now just a front end to match_check_list(), which runs common
3095 code for scanning a list. We pass it the check_host() function to perform a
3096 single test.
3097
3098 Arguments:
3099   listptr              pointer to the host list
3100   cache_bits           pointer to cache for named lists, or NULL
3101   host_name            the host name or NULL, implying use sender_host_name and
3102                          sender_host_aliases, looking them up if required
3103   host_address         the IP address
3104   valueptr             if not NULL, data from a lookup is passed back here
3105
3106 Returns:    OK    if the host is in the defined set
3107             FAIL  if the host is not in the defined set,
3108             DEFER if a data lookup deferred (not a host lookup)
3109
3110 If the host name was needed in order to make a comparison, and could not be
3111 determined from the IP address, the result is FAIL unless the item
3112 "+allow_unknown" was met earlier in the list, in which case OK is returned. */
3113
3114 int
3115 verify_check_this_host(uschar **listptr, unsigned int *cache_bits,
3116   uschar *host_name, uschar *host_address, uschar **valueptr)
3117 {
3118 int rc;
3119 unsigned int *local_cache_bits = cache_bits;
3120 uschar *save_host_address = deliver_host_address;
3121 check_host_block cb;
3122 cb.host_name = host_name;
3123 cb.host_address = host_address;
3124
3125 if (valueptr != NULL) *valueptr = NULL;
3126
3127 /* If the host address starts off ::ffff: it is an IPv6 address in
3128 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
3129 addresses. */
3130
3131 cb.host_ipv4 = (Ustrncmp(host_address, "::ffff:", 7) == 0)?
3132   host_address + 7 : host_address;
3133
3134 /* During the running of the check, put the IP address into $host_address. In
3135 the case of calls from the smtp transport, it will already be there. However,
3136 in other calls (e.g. when testing ignore_target_hosts), it won't. Just to be on
3137 the safe side, any existing setting is preserved, though as I write this
3138 (November 2004) I can't see any cases where it is actually needed. */
3139
3140 deliver_host_address = host_address;
3141 rc = match_check_list(
3142        listptr,                                /* the list */
3143        0,                                      /* separator character */
3144        &hostlist_anchor,                       /* anchor pointer */
3145        &local_cache_bits,                      /* cache pointer */
3146        check_host,                             /* function for testing */
3147        &cb,                                    /* argument for function */
3148        MCL_HOST,                               /* type of check */
3149        (host_address == sender_host_address)?
3150          US"host" : host_address,              /* text for debugging */
3151        valueptr);                              /* where to pass back data */
3152 deliver_host_address = save_host_address;
3153 return rc;
3154 }
3155
3156
3157
3158
3159 /*************************************************
3160 *      Check the given host item matches a list  *
3161 *************************************************/
3162 int
3163 verify_check_given_host(uschar **listptr, host_item *host)
3164 {
3165 return verify_check_this_host(listptr, NULL, host->name, host->address, NULL);
3166 }
3167
3168 /*************************************************
3169 *      Check the remote host matches a list      *
3170 *************************************************/
3171
3172 /* This is a front end to verify_check_this_host(), created because checking
3173 the remote host is a common occurrence. With luck, a good compiler will spot
3174 the tail recursion and optimize it. If there's no host address, this is
3175 command-line SMTP input - check against an empty string for the address.
3176
3177 Arguments:
3178   listptr              pointer to the host list
3179
3180 Returns:               the yield of verify_check_this_host(),
3181                        i.e. OK, FAIL, or DEFER
3182 */
3183
3184 int
3185 verify_check_host(uschar **listptr)
3186 {
3187 return verify_check_this_host(listptr, sender_host_cache, NULL,
3188   (sender_host_address == NULL)? US"" : sender_host_address, NULL);
3189 }
3190
3191
3192
3193
3194
3195 /*************************************************
3196 *              Invert an IP address              *
3197 *************************************************/
3198
3199 /* Originally just used for DNS xBL lists, now also used for the
3200 reverse_ip expansion operator.
3201
3202 Arguments:
3203   buffer         where to put the answer
3204   address        the address to invert
3205 */
3206
3207 void
3208 invert_address(uschar *buffer, uschar *address)
3209 {
3210 int bin[4];
3211 uschar *bptr = buffer;
3212
3213 /* If this is an IPv4 address mapped into IPv6 format, adjust the pointer
3214 to the IPv4 part only. */
3215
3216 if (Ustrncmp(address, "::ffff:", 7) == 0) address += 7;
3217
3218 /* Handle IPv4 address: when HAVE_IPV6 is false, the result of host_aton() is
3219 always 1. */
3220
3221 if (host_aton(address, bin) == 1)
3222   {
3223   int i;
3224   int x = bin[0];
3225   for (i = 0; i < 4; i++)
3226     {
3227     sprintf(CS bptr, "%d.", x & 255);
3228     while (*bptr) bptr++;
3229     x >>= 8;
3230     }
3231   }
3232
3233 /* Handle IPv6 address. Actually, as far as I know, there are no IPv6 addresses
3234 in any DNS black lists, and the format in which they will be looked up is
3235 unknown. This is just a guess. */
3236
3237 #if HAVE_IPV6
3238 else
3239   {
3240   int i, j;
3241   for (j = 3; j >= 0; j--)
3242     {
3243     int x = bin[j];
3244     for (i = 0; i < 8; i++)
3245       {
3246       sprintf(CS bptr, "%x.", x & 15);
3247       while (*bptr) bptr++;
3248       x >>= 4;
3249       }
3250     }
3251   }
3252 #endif
3253
3254 /* Remove trailing period -- this is needed so that both arbitrary
3255 dnsbl keydomains and inverted addresses may be combined with the
3256 same format string, "%s.%s" */
3257
3258 *(--bptr) = 0;
3259 }
3260
3261
3262
3263 /*************************************************
3264 *          Perform a single dnsbl lookup         *
3265 *************************************************/
3266
3267 /* This function is called from verify_check_dnsbl() below. It is also called
3268 recursively from within itself when domain and domain_txt are different
3269 pointers, in order to get the TXT record from the alternate domain.
3270
3271 Arguments:
3272   domain         the outer dnsbl domain
3273   domain_txt     alternate domain to lookup TXT record on success; when the
3274                    same domain is to be used, domain_txt == domain (that is,
3275                    the pointers must be identical, not just the text)
3276   keydomain      the current keydomain (for debug message)
3277   prepend        subdomain to lookup (like keydomain, but
3278                    reversed if IP address)
3279   iplist         the list of matching IP addresses, or NULL for "any"
3280   bitmask        true if bitmask matching is wanted
3281   match_type     condition for 'succeed' result
3282                    0 => Any RR in iplist     (=)
3283                    1 => No RR in iplist      (!=)
3284                    2 => All RRs in iplist    (==)
3285                    3 => Some RRs not in iplist (!==)
3286                    the two bits are defined as MT_NOT and MT_ALL
3287   defer_return   what to return for a defer
3288
3289 Returns:         OK if lookup succeeded
3290                  FAIL if not
3291 */
3292
3293 static int
3294 one_check_dnsbl(uschar *domain, uschar *domain_txt, uschar *keydomain,
3295   uschar *prepend, uschar *iplist, BOOL bitmask, int match_type,
3296   int defer_return)
3297 {
3298 dns_answer dnsa;
3299 dns_scan dnss;
3300 tree_node *t;
3301 dnsbl_cache_block *cb;
3302 int old_pool = store_pool;
3303 uschar query[256];         /* DNS domain max length */
3304
3305 /* Construct the specific query domainname */
3306
3307 if (!string_format(query, sizeof(query), "%s.%s", prepend, domain))
3308   {
3309   log_write(0, LOG_MAIN|LOG_PANIC, "dnslist query is too long "
3310     "(ignored): %s...", query);
3311   return FAIL;
3312   }
3313
3314 /* Look for this query in the cache. */
3315
3316 t = tree_search(dnsbl_cache, query);
3317
3318 /* If not cached from a previous lookup, we must do a DNS lookup, and
3319 cache the result in permanent memory. */
3320
3321 if (t == NULL)
3322   {
3323   store_pool = POOL_PERM;
3324
3325   /* Set up a tree entry to cache the lookup */
3326
3327   t = store_get(sizeof(tree_node) + Ustrlen(query));
3328   Ustrcpy(t->name, query);
3329   t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block));
3330   (void)tree_insertnode(&dnsbl_cache, t);
3331
3332   /* Do the DNS loopup . */
3333
3334   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
3335   cb->rc = dns_basic_lookup(&dnsa, query, T_A);
3336   cb->text_set = FALSE;
3337   cb->text = NULL;
3338   cb->rhs = NULL;
3339
3340   /* If the lookup succeeded, cache the RHS address. The code allows for
3341   more than one address - this was for complete generality and the possible
3342   use of A6 records. However, A6 records have been reduced to experimental
3343   status (August 2001) and may die out. So they may never get used at all,
3344   let alone in dnsbl records. However, leave the code here, just in case.
3345
3346   Quite apart from one A6 RR generating multiple addresses, there are DNS
3347   lists that return more than one A record, so we must handle multiple
3348   addresses generated in that way as well. */
3349
3350   if (cb->rc == DNS_SUCCEED)
3351     {
3352     dns_record *rr;
3353     dns_address **addrp = &(cb->rhs);
3354     for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
3355          rr != NULL;
3356          rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
3357       {
3358       if (rr->type == T_A)
3359         {
3360         dns_address *da = dns_address_from_rr(&dnsa, rr);
3361         if (da != NULL)
3362           {
3363           *addrp = da;
3364           while (da->next != NULL) da = da->next;
3365           addrp = &(da->next);
3366           }
3367         }
3368       }
3369
3370     /* If we didn't find any A records, change the return code. This can
3371     happen when there is a CNAME record but there are no A records for what
3372     it points to. */
3373
3374     if (cb->rhs == NULL) cb->rc = DNS_NODATA;
3375     }
3376
3377   store_pool = old_pool;
3378   }
3379
3380 /* Previous lookup was cached */
3381
3382 else
3383   {
3384   HDEBUG(D_dnsbl) debug_printf("using result of previous DNS lookup\n");
3385   cb = t->data.ptr;
3386   }
3387
3388 /* We now have the result of the DNS lookup, either newly done, or cached
3389 from a previous call. If the lookup succeeded, check against the address
3390 list if there is one. This may be a positive equality list (introduced by
3391 "="), a negative equality list (introduced by "!="), a positive bitmask
3392 list (introduced by "&"), or a negative bitmask list (introduced by "!&").*/
3393
3394 if (cb->rc == DNS_SUCCEED)
3395   {
3396   dns_address *da = NULL;
3397   uschar *addlist = cb->rhs->address;
3398
3399   /* For A and AAAA records, there may be multiple addresses from multiple
3400   records. For A6 records (currently not expected to be used) there may be
3401   multiple addresses from a single record. */
3402
3403   for (da = cb->rhs->next; da != NULL; da = da->next)
3404     addlist = string_sprintf("%s, %s", addlist, da->address);
3405
3406   HDEBUG(D_dnsbl) debug_printf("DNS lookup for %s succeeded (yielding %s)\n",
3407     query, addlist);
3408
3409   /* Address list check; this can be either for equality, or via a bitmask.
3410   In the latter case, all the bits must match. */
3411
3412   if (iplist != NULL)
3413     {
3414     for (da = cb->rhs; da != NULL; da = da->next)
3415       {
3416       int ipsep = ',';
3417       uschar ip[46];
3418       uschar *ptr = iplist;
3419       uschar *res;
3420
3421       /* Handle exact matching */
3422
3423       if (!bitmask)
3424         {
3425         while ((res = string_nextinlist(&ptr, &ipsep, ip, sizeof(ip))) != NULL)
3426           {
3427           if (Ustrcmp(CS da->address, ip) == 0) break;
3428           }
3429         }
3430
3431       /* Handle bitmask matching */
3432
3433       else
3434         {
3435         int address[4];
3436         int mask = 0;
3437
3438         /* At present, all known DNS blocking lists use A records, with
3439         IPv4 addresses on the RHS encoding the information they return. I
3440         wonder if this will linger on as the last vestige of IPv4 when IPv6
3441         is ubiquitous? Anyway, for now we use paranoia code to completely
3442         ignore IPv6 addresses. The default mask is 0, which always matches.
3443         We change this only for IPv4 addresses in the list. */
3444
3445         if (host_aton(da->address, address) == 1) mask = address[0];
3446
3447         /* Scan the returned addresses, skipping any that are IPv6 */
3448
3449         while ((res = string_nextinlist(&ptr, &ipsep, ip, sizeof(ip))) != NULL)
3450           {
3451           if (host_aton(ip, address) != 1) continue;
3452           if ((address[0] & mask) == address[0]) break;
3453           }
3454         }
3455
3456       /* If either
3457
3458          (a) An IP address in an any ('=') list matched, or
3459          (b) No IP address in an all ('==') list matched
3460
3461       then we're done searching. */
3462
3463       if (((match_type & MT_ALL) != 0) == (res == NULL)) break;
3464       }
3465
3466     /* If da == NULL, either
3467
3468        (a) No IP address in an any ('=') list matched, or
3469        (b) An IP address in an all ('==') list didn't match
3470
3471     so behave as if the DNSBL lookup had not succeeded, i.e. the host is not on
3472     the list. */
3473
3474     if ((match_type == MT_NOT || match_type == MT_ALL) != (da == NULL))
3475       {
3476       HDEBUG(D_dnsbl)
3477         {
3478         uschar *res = NULL;
3479         switch(match_type)
3480           {
3481           case 0:
3482           res = US"was no match";
3483           break;
3484           case MT_NOT:
3485           res = US"was an exclude match";
3486           break;
3487           case MT_ALL:
3488           res = US"was an IP address that did not match";
3489           break;
3490           case MT_NOT|MT_ALL:
3491           res = US"were no IP addresses that did not match";
3492           break;
3493           }
3494         debug_printf("=> but we are not accepting this block class because\n");
3495         debug_printf("=> there %s for %s%c%s\n",
3496           res,
3497           ((match_type & MT_ALL) == 0)? "" : "=",
3498           bitmask? '&' : '=', iplist);
3499         }
3500       return FAIL;
3501       }
3502     }
3503
3504   /* Either there was no IP list, or the record matched, implying that the
3505   domain is on the list. We now want to find a corresponding TXT record. If an
3506   alternate domain is specified for the TXT record, call this function
3507   recursively to look that up; this has the side effect of re-checking that
3508   there is indeed an A record at the alternate domain. */
3509
3510   if (domain_txt != domain)
3511     return one_check_dnsbl(domain_txt, domain_txt, keydomain, prepend, NULL,
3512       FALSE, match_type, defer_return);
3513
3514   /* If there is no alternate domain, look up a TXT record in the main domain
3515   if it has not previously been cached. */
3516
3517   if (!cb->text_set)
3518     {
3519     cb->text_set = TRUE;
3520     if (dns_basic_lookup(&dnsa, query, T_TXT) == DNS_SUCCEED)
3521       {
3522       dns_record *rr;
3523       for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
3524            rr != NULL;
3525            rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
3526         if (rr->type == T_TXT) break;
3527       if (rr != NULL)
3528         {
3529         int len = (rr->data)[0];
3530         if (len > 511) len = 127;
3531         store_pool = POOL_PERM;
3532         cb->text = string_sprintf("%.*s", len, (const uschar *)(rr->data+1));
3533         store_pool = old_pool;
3534         }
3535       }
3536     }
3537
3538   dnslist_value = addlist;
3539   dnslist_text = cb->text;
3540   return OK;
3541   }
3542
3543 /* There was a problem with the DNS lookup */
3544
3545 if (cb->rc != DNS_NOMATCH && cb->rc != DNS_NODATA)
3546   {
3547   log_write(L_dnslist_defer, LOG_MAIN,
3548     "DNS list lookup defer (probably timeout) for %s: %s", query,
3549     (defer_return == OK)?   US"assumed in list" :
3550     (defer_return == FAIL)? US"assumed not in list" :
3551                             US"returned DEFER");
3552   return defer_return;
3553   }
3554
3555 /* No entry was found in the DNS; continue for next domain */
3556
3557 HDEBUG(D_dnsbl)
3558   {
3559   debug_printf("DNS lookup for %s failed\n", query);
3560   debug_printf("=> that means %s is not listed at %s\n",
3561      keydomain, domain);
3562   }
3563
3564 return FAIL;
3565 }
3566
3567
3568
3569
3570 /*************************************************
3571 *        Check host against DNS black lists      *
3572 *************************************************/
3573
3574 /* This function runs checks against a list of DNS black lists, until one
3575 matches. Each item on the list can be of the form
3576
3577   domain=ip-address/key
3578
3579 The domain is the right-most domain that is used for the query, for example,
3580 blackholes.mail-abuse.org. If the IP address is present, there is a match only
3581 if the DNS lookup returns a matching IP address. Several addresses may be
3582 given, comma-separated, for example: x.y.z=127.0.0.1,127.0.0.2.
3583
3584 If no key is given, what is looked up in the domain is the inverted IP address
3585 of the current client host. If a key is given, it is used to construct the
3586 domain for the lookup. For example:
3587
3588   dsn.rfc-ignorant.org/$sender_address_domain
3589
3590 After finding a match in the DNS, the domain is placed in $dnslist_domain, and
3591 then we check for a TXT record for an error message, and if found, save its
3592 value in $dnslist_text. We also cache everything in a tree, to optimize
3593 multiple lookups.
3594
3595 The TXT record is normally looked up in the same domain as the A record, but
3596 when many lists are combined in a single DNS domain, this will not be a very
3597 specific message. It is possible to specify a different domain for looking up
3598 TXT records; this is given before the main domain, comma-separated. For
3599 example:
3600
3601   dnslists = http.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.2 : \
3602              socks.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.3
3603
3604 The caching ensures that only one lookup in dnsbl.sorbs.net is done.
3605
3606 Note: an address for testing RBL is 192.203.178.39
3607 Note: an address for testing DUL is 192.203.178.4
3608 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
3609
3610 Arguments:
3611   listptr      the domain/address/data list
3612
3613 Returns:    OK      successful lookup (i.e. the address is on the list), or
3614                       lookup deferred after +include_unknown
3615             FAIL    name not found, or no data found for the given type, or
3616                       lookup deferred after +exclude_unknown (default)
3617             DEFER   lookup failure, if +defer_unknown was set
3618 */
3619
3620 int
3621 verify_check_dnsbl(uschar **listptr)
3622 {
3623 int sep = 0;
3624 int defer_return = FAIL;
3625 uschar *list = *listptr;
3626 uschar *domain;
3627 uschar *s;
3628 uschar buffer[1024];
3629 uschar revadd[128];        /* Long enough for IPv6 address */
3630
3631 /* Indicate that the inverted IP address is not yet set up */
3632
3633 revadd[0] = 0;
3634
3635 /* In case this is the first time the DNS resolver is being used. */
3636
3637 dns_init(FALSE, FALSE, FALSE);  /*XXX dnssec? */
3638
3639 /* Loop through all the domains supplied, until something matches */
3640
3641 while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
3642   {
3643   int rc;
3644   BOOL bitmask = FALSE;
3645   int match_type = 0;
3646   uschar *domain_txt;
3647   uschar *comma;
3648   uschar *iplist;
3649   uschar *key;
3650
3651   HDEBUG(D_dnsbl) debug_printf("DNS list check: %s\n", domain);
3652
3653   /* Deal with special values that change the behaviour on defer */
3654
3655   if (domain[0] == '+')
3656     {
3657     if      (strcmpic(domain, US"+include_unknown") == 0) defer_return = OK;
3658     else if (strcmpic(domain, US"+exclude_unknown") == 0) defer_return = FAIL;
3659     else if (strcmpic(domain, US"+defer_unknown") == 0)   defer_return = DEFER;
3660     else
3661       log_write(0, LOG_MAIN|LOG_PANIC, "unknown item in dnslist (ignored): %s",
3662         domain);
3663     continue;
3664     }
3665
3666   /* See if there's explicit data to be looked up */
3667
3668   key = Ustrchr(domain, '/');
3669   if (key != NULL) *key++ = 0;
3670
3671   /* See if there's a list of addresses supplied after the domain name. This is
3672   introduced by an = or a & character; if preceded by = we require all matches
3673   and if preceded by ! we invert the result. */
3674
3675   iplist = Ustrchr(domain, '=');
3676   if (iplist == NULL)
3677     {
3678     bitmask = TRUE;
3679     iplist = Ustrchr(domain, '&');
3680     }
3681
3682   if (iplist != NULL)                          /* Found either = or & */
3683     {
3684     if (iplist > domain && iplist[-1] == '!')  /* Handle preceding ! */
3685       {
3686       match_type |= MT_NOT;
3687       iplist[-1] = 0;
3688       }
3689
3690     *iplist++ = 0;                             /* Terminate domain, move on */
3691
3692     /* If we found = (bitmask == FALSE), check for == or =& */
3693
3694     if (!bitmask && (*iplist == '=' || *iplist == '&'))
3695       {
3696       bitmask = *iplist++ == '&';
3697       match_type |= MT_ALL;
3698       }
3699     }
3700
3701   /* If there is a comma in the domain, it indicates that a second domain for
3702   looking up TXT records is provided, before the main domain. Otherwise we must
3703   set domain_txt == domain. */
3704
3705   domain_txt = domain;
3706   comma = Ustrchr(domain, ',');
3707   if (comma != NULL)
3708     {
3709     *comma++ = 0;
3710     domain = comma;
3711     }
3712
3713   /* Check that what we have left is a sensible domain name. There is no reason
3714   why these domains should in fact use the same syntax as hosts and email
3715   domains, but in practice they seem to. However, there is little point in
3716   actually causing an error here, because that would no doubt hold up incoming
3717   mail. Instead, I'll just log it. */
3718
3719   for (s = domain; *s != 0; s++)
3720     {
3721     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3722       {
3723       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3724         "strange characters - is this right?", domain);
3725       break;
3726       }
3727     }
3728
3729   /* Check the alternate domain if present */
3730
3731   if (domain_txt != domain) for (s = domain_txt; *s != 0; s++)
3732     {
3733     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3734       {
3735       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3736         "strange characters - is this right?", domain_txt);
3737       break;
3738       }
3739     }
3740
3741   /* If there is no key string, construct the query by adding the domain name
3742   onto the inverted host address, and perform a single DNS lookup. */
3743
3744   if (key == NULL)
3745     {
3746     if (sender_host_address == NULL) return FAIL;    /* can never match */
3747     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
3748     rc = one_check_dnsbl(domain, domain_txt, sender_host_address, revadd,
3749       iplist, bitmask, match_type, defer_return);
3750     if (rc == OK)
3751       {
3752       dnslist_domain = string_copy(domain_txt);
3753       dnslist_matched = string_copy(sender_host_address);
3754       HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3755         sender_host_address, dnslist_domain);
3756       }
3757     if (rc != FAIL) return rc;     /* OK or DEFER */
3758     }
3759
3760   /* If there is a key string, it can be a list of domains or IP addresses to
3761   be concatenated with the main domain. */
3762
3763   else
3764     {
3765     int keysep = 0;
3766     BOOL defer = FALSE;
3767     uschar *keydomain;
3768     uschar keybuffer[256];
3769     uschar keyrevadd[128];
3770
3771     while ((keydomain = string_nextinlist(&key, &keysep, keybuffer,
3772             sizeof(keybuffer))) != NULL)
3773       {
3774       uschar *prepend = keydomain;
3775
3776       if (string_is_ip_address(keydomain, NULL) != 0)
3777         {
3778         invert_address(keyrevadd, keydomain);
3779         prepend = keyrevadd;
3780         }
3781
3782       rc = one_check_dnsbl(domain, domain_txt, keydomain, prepend, iplist,
3783         bitmask, match_type, defer_return);
3784
3785       if (rc == OK)
3786         {
3787         dnslist_domain = string_copy(domain_txt);
3788         dnslist_matched = string_copy(keydomain);
3789         HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3790           keydomain, dnslist_domain);
3791         return OK;
3792         }
3793
3794       /* If the lookup deferred, remember this fact. We keep trying the rest
3795       of the list to see if we get a useful result, and if we don't, we return
3796       DEFER at the end. */
3797
3798       if (rc == DEFER) defer = TRUE;
3799       }    /* continue with next keystring domain/address */
3800
3801     if (defer) return DEFER;
3802     }
3803   }        /* continue with next dnsdb outer domain */
3804
3805 return FAIL;
3806 }
3807
3808 /* vi: aw ai sw=2
3809 */
3810 /* End of verify.c */