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
 472     if (!smtp_get_interface(tf->interface, host_af, addr, NULL, &interface,
 473             US"callout") ||
 474         !smtp_get_port(tf->port, addr, &port, US"callout"))
 475       log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
 476         addr->message);
 477
 478     /* Set HELO string according to the protocol */
 479     lmtp= Ustrcmp(tf->protocol, "lmtp") == 0;
 480     smtps= Ustrcmp(tf->protocol, "smtps") == 0;
 481
 482
 483     HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", interface, port);
 484
 485 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
 486       {
 487       BOOL dane_required;
 488       int rc;
 489
 490       tls_out.dane_verified = FALSE;
 491       tls_out.tlsa_usage = 0;
 492
 493       dane_required = verify_check_this_host(&ob->hosts_require_dane, NULL,
 494                                 host->name, host->address, NULL) == OK;
 495
 496       if (host->dnssec == DS_YES)
 497         {
 498         if(  dane_required
 499           || verify_check_this_host(&ob->hosts_try_dane, NULL,
 500                                 host->name, host->address, NULL) == 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_TPDA
 542     /*XXX tpda 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       deliver_host = deliver_host_address = NULL;
 552       deliver_domain = save_deliver_domain;
 553       continue;
 554       }
 555
 556     /* Expand the helo_data string to find the host name to use. */
 557
 558     if (tf->helo_data != NULL)
 559       {
 560       uschar *s = expand_string(tf->helo_data);
 561       if (s == NULL)
 562         log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: failed to expand transport's "
 563           "helo_data value for callout: %s", addr->address,
 564           expand_string_message);
 565       else active_hostname = s;
 566       }
 567
 568     /* Wait for initial response, and send HELO. The smtp_write_command()
 569     function leaves its command in big_buffer. This is used in error responses.
 570     Initialize it in case the connection is rejected. */
 571
 572     Ustrcpy(big_buffer, "initial connection");
 573
 574     /* Unless ssl-on-connect, wait for the initial greeting */
 575     smtps_redo_greeting:
 576
 577 #ifdef SUPPORT_TLS
 578     if (!smtps || (smtps && tls_out.active >= 0))
 579 #endif
 580       {
 581       if (!(done= smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), '2', callout)))
 582         goto RESPONSE_FAILED;
 583
 584 #ifdef EXPERIMENTAL_TPDA
 585       if (tpda_raise_event(addr->transport->tpda_event_action,
 586                             US"smtp:connect", responsebuffer) == DEFER)
 587         {
 588         /* Logging?  Debug? */
 589         goto RESPONSE_FAILED;
 590         }
 591 #endif
 592       }
 593
 594     /* Not worth checking greeting line for ESMTP support */
 595     if (!(esmtp = verify_check_this_host(&(ob->hosts_avoid_esmtp), NULL,
 596       host->name, host->address, NULL) != OK))
 597       DEBUG(D_transport)
 598         debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
 599
 600     tls_redo_helo:
 601
 602 #ifdef SUPPORT_TLS
 603     if (smtps  &&  tls_out.active < 0)  /* ssl-on-connect, first pass */
 604       {
 605       tls_offered = TRUE;
 606       ob->tls_tempfail_tryclear = FALSE;
 607       }
 608     else                                /* all other cases */
 609 #endif
 610
 611       { esmtp_retry:
 612
 613       if (!(done= smtp_write_command(&outblock, FALSE, "%s %s\r\n",
 614         !esmtp? "HELO" : lmtp? "LHLO" : "EHLO", active_hostname) >= 0))
 615         goto SEND_FAILED;
 616       if (!smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer), '2', callout))
 617         {
 618         if (errno != 0 || responsebuffer[0] == 0 || lmtp || !esmtp || tls_out.active >= 0)
 619           {
 620           done= FALSE;
 621           goto RESPONSE_FAILED;
 622           }
 623 #ifdef SUPPORT_TLS
 624         tls_offered = FALSE;
 625 #endif
 626         esmtp = FALSE;
 627         goto esmtp_retry;                       /* fallback to HELO */
 628         }
 629
 630       /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
 631 #ifdef SUPPORT_TLS
 632       if (esmtp && !suppress_tls &&  tls_out.active < 0)
 633         {
 634         if (regex_STARTTLS == NULL) regex_STARTTLS =
 635           regex_must_compile(US"\\n250[\\s\\-]STARTTLS(\\s|\\n|$)", FALSE, TRUE);
 636
 637         tls_offered = pcre_exec(regex_STARTTLS, NULL, CS responsebuffer,
 638                       Ustrlen(responsebuffer), 0, PCRE_EOPT, NULL, 0) >= 0;
 639         }
 640       else
 641         tls_offered = FALSE;
 642 #endif
 643       }
 644
 645     /* If TLS is available on this connection attempt to
 646     start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
 647     send another EHLO - the server may give a different answer in secure mode. We
 648     use a separate buffer for reading the response to STARTTLS so that if it is
 649     negative, the original EHLO data is available for subsequent analysis, should
 650     the client not be required to use TLS. If the response is bad, copy the buffer
 651     for error analysis. */
 652
 653 #ifdef SUPPORT_TLS
 654     if (tls_offered &&
 655         verify_check_this_host(&(ob->hosts_avoid_tls), NULL, host->name,
 656           host->address, NULL) != OK &&
 657         verify_check_this_host(&(ob->hosts_verify_avoid_tls), NULL, host->name,
 658           host->address, NULL) != OK
 659        )
 660       {
 661       uschar buffer2[4096];
 662       if (  !smtps
 663          && !(done= smtp_write_command(&outblock, FALSE, "STARTTLS\r\n") >= 0))
 664         goto SEND_FAILED;
 665
 666       /* If there is an I/O error, transmission of this message is deferred. If
 667       there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
 668       false, we also defer. However, if there is a temporary rejection of STARTTLS
 669       and tls_tempfail_tryclear is true, or if there is an outright rejection of
 670       STARTTLS, we carry on. This means we will try to send the message in clear,
 671       unless the host is in hosts_require_tls (tested below). */
 672
 673       if (!smtps && !smtp_read_response(&inblock, buffer2, sizeof(buffer2), '2',
 674                         ob->command_timeout))
 675         {
 676         if (errno != 0 || buffer2[0] == 0 ||
 677                 (buffer2[0] == '4' && !ob->tls_tempfail_tryclear))
 678           {
 679           Ustrncpy(responsebuffer, buffer2, sizeof(responsebuffer));
 680           done= FALSE;
 681           goto RESPONSE_FAILED;
 682           }
 683         }
 684
 685        /* STARTTLS accepted or ssl-on-connect: try to negotiate a TLS session. */
 686       else
 687         {
 688         int oldtimeout = ob->command_timeout;
 689         int rc;
 690
 691         ob->command_timeout = callout;
 692         rc = tls_client_start(inblock.sock, host, addr, addr->transport
 693 #ifdef EXPERIMENTAL_DANE
 694                             , dane ? &tlsa_dnsa : NULL
 695 #endif
 696                             );
 697         ob->command_timeout = oldtimeout;
 698
 699         /* TLS negotiation failed; give an error.  Try in clear on a new connection,
 700            if the options permit it for this host. */
 701         if (rc != OK)
 702           {
 703           if (  rc == DEFER
 704              && ob->tls_tempfail_tryclear
 705              && !smtps
 706              && verify_check_this_host(&(ob->hosts_require_tls), NULL,
 707                host->name, host->address, NULL) != OK
 708              )
 709             {
 710             (void)close(inblock.sock);
 711 #ifdef EXPERIMENTAL_TPDA
 712             (void) tpda_raise_event(addr->transport->tpda_event_action,
 713                                     US"tcp:close", NULL);
 714 #endif
 715             log_write(0, LOG_MAIN, "TLS session failure: delivering unencrypted "
 716               "to %s [%s] (not in hosts_require_tls)", host->name, host->address);
 717             suppress_tls = TRUE;
 718             goto tls_retry_connection;
 719             }
 720           /*save_errno = ERRNO_TLSFAILURE;*/
 721           /*message = US"failure while setting up TLS session";*/
 722           send_quit = FALSE;
 723           done= FALSE;
 724           goto TLS_FAILED;
 725           }
 726
 727         /* TLS session is set up.  Copy info for logging. */
 728         addr->cipher = tls_out.cipher;
 729         addr->peerdn = tls_out.peerdn;
 730
 731         /* For SMTPS we need to wait for the initial OK response, then do HELO. */
 732         if (smtps)
 733           goto smtps_redo_greeting;
 734
 735         /* For STARTTLS we need to redo EHLO */
 736         goto tls_redo_helo;
 737         }
 738       }
 739
 740     /* If the host is required to use a secure channel, ensure that we have one. */
 741     if (tls_out.active < 0)
 742       if (
 743 #ifdef EXPERIMENTAL_DANE
 744          dane ||
 745 #endif
 746          verify_check_this_host(&(ob->hosts_require_tls), NULL, host->name,
 747               host->address, NULL) == OK
 748          )
 749         {
 750         /*save_errno = ERRNO_TLSREQUIRED;*/
 751         log_write(0, LOG_MAIN, "a TLS session is required for %s [%s], but %s",
 752           host->name, host->address,
 753         tls_offered? "an attempt to start TLS failed" : "the server did not offer TLS support");
 754         done= FALSE;
 755         goto TLS_FAILED;
 756         }
 757
 758     #endif /*SUPPORT_TLS*/
 759
 760     done = TRUE; /* so far so good; have response to HELO */
 761
 762     /*XXX the EHLO response would be analyzed here for IGNOREQUOTA, SIZE, PIPELINING */
 763
 764     /* For now, transport_filter by cutthrough-delivery is not supported */
 765     /* Need proper integration with the proper transport mechanism. */
 766     if (cutthrough_delivery)
 767       {
 768       if (addr->transport->filter_command)
 769         {
 770         cutthrough_delivery= FALSE;
 771         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of transport filter\n");
 772         }
 773 #ifndef DISABLE_DKIM
 774       if (ob->dkim_domain)
 775         {
 776         cutthrough_delivery= FALSE;
 777         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of DKIM signing\n");
 778         }
 779 #endif
 780       }
 781
 782     SEND_FAILED:
 783     RESPONSE_FAILED:
 784     TLS_FAILED:
 785     ;
 786     /* Clear down of the TLS, SMTP and TCP layers on error is handled below.  */
 787
 788     /* Failure to accept HELO is cached; this blocks the whole domain for all
 789     senders. I/O errors and defer responses are not cached. */
 790
 791     if (!done)
 792       {
 793       *failure_ptr = US"mail";     /* At or before MAIL */
 794       if (errno == 0 && responsebuffer[0] == '5')
 795         {
 796         setflag(addr, af_verify_nsfail);
 797         new_domain_record.result = ccache_reject;
 798         }
 799       }
 800
 801     /* If we haven't authenticated, but are required to, give up. */
 802     /* Try to AUTH */
 803
 804     else done = smtp_auth(responsebuffer, sizeof(responsebuffer),
 805         addr, host, ob, esmtp, &inblock, &outblock) == OK  &&
 806
 807                 /* Copy AUTH info for logging */
 808       ( (addr->authenticator = client_authenticator),
 809         (addr->auth_id = client_authenticated_id),
 810
 811     /* Build a mail-AUTH string (re-using responsebuffer for convenience */
 812         !smtp_mail_auth_str(responsebuffer, sizeof(responsebuffer), addr, ob)
 813       )  &&
 814
 815       ( (addr->auth_sndr = client_authenticated_sender),
 816
 817     /* Send the MAIL command */
 818         (smtp_write_command(&outblock, FALSE, "MAIL FROM:<%s>%s\r\n",
 819           from_address, responsebuffer) >= 0)
 820       )  &&
 821
 822       smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
 823         '2', callout);
 824
 825     deliver_host = deliver_host_address = NULL;
 826     deliver_domain = save_deliver_domain;
 827
 828     /* If the host does not accept MAIL FROM:<>, arrange to cache this
 829     information, but again, don't record anything for an I/O error or a defer. Do
 830     not cache rejections of MAIL when a non-empty sender has been used, because
 831     that blocks the whole domain for all senders. */
 832
 833     if (!done)
 834       {
 835       *failure_ptr = US"mail";     /* At or before MAIL */
 836       if (errno == 0 && responsebuffer[0] == '5')
 837         {
 838         setflag(addr, af_verify_nsfail);
 839         if (from_address[0] == 0)
 840           new_domain_record.result = ccache_reject_mfnull;
 841         }
 842       }
 843
 844     /* Otherwise, proceed to check a "random" address (if required), then the
 845     given address, and the postmaster address (if required). Between each check,
 846     issue RSET, because some servers accept only one recipient after MAIL
 847     FROM:<>.
 848
 849     Before doing this, set the result in the domain cache record to "accept",
 850     unless its previous value was ccache_reject_mfnull. In that case, the domain
 851     rejects MAIL FROM:<> and we want to continue to remember that. When that is
 852     the case, we have got here only in the case of a recipient verification with
 853     a non-null sender. */
 854
 855     else
 856       {
 857       new_domain_record.result =
 858         (old_domain_cache_result == ccache_reject_mfnull)?
 859           ccache_reject_mfnull: ccache_accept;
 860
 861       /* Do the random local part check first */
 862
 863       if (random_local_part != NULL)
 864         {
 865         uschar randombuffer[1024];
 866         BOOL random_ok =
 867           smtp_write_command(&outblock, FALSE,
 868             "RCPT TO:<%.1000s@%.1000s>\r\n", random_local_part,
 869             addr->domain) >= 0 &&
 870           smtp_read_response(&inblock, randombuffer,
 871             sizeof(randombuffer), '2', callout);
 872
 873         /* Remember when we last did a random test */
 874
 875         new_domain_record.random_stamp = time(NULL);
 876
 877         /* If accepted, we aren't going to do any further tests below. */
 878
 879         if (random_ok)
 880           {
 881           new_domain_record.random_result = ccache_accept;
 882           }
 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_TPDA
1068       (void) tpda_raise_event(addr->transport->tpda_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           rc = do_callout(addr, host_list, &tf, callout, callout_overall,
1854             callout_connect, options, se_mailfrom, pm_mailfrom);
1855           }
1856         }
1857       else
1858         {
1859         HDEBUG(D_verify) debug_printf("Cannot do callout: neither router nor "
1860           "transport provided a host list\n");
1861         }
1862       }
1863     }
1864
1865   /* Otherwise, any failure is a routing failure */
1866
1867   else *failure_ptr = US"route";
1868
1869   /* A router may return REROUTED if it has set up a child address as a result
1870   of a change of domain name (typically from widening). In this case we always
1871   want to continue to verify the new child. */
1872
1873   if (rc == REROUTED) continue;
1874
1875   /* Handle hard failures */
1876
1877   if (rc == FAIL)
1878     {
1879     allok = FALSE;
1880     if (f != NULL)
1881       {
1882       address_item *p = addr->parent;
1883
1884       respond_printf(f, "%s%s %s", ko_prefix,
1885         full_info? addr->address : address,
1886         address_test_mode? "is undeliverable" : "failed to verify");
1887       if (!expn && admin_user)
1888         {
1889         if (addr->basic_errno > 0)
1890           respond_printf(f, ": %s", strerror(addr->basic_errno));
1891         if (addr->message != NULL)
1892           respond_printf(f, ": %s", addr->message);
1893         }
1894
1895       /* Show parents iff doing full info */
1896
1897       if (full_info) while (p != NULL)
1898         {
1899         respond_printf(f, "%s\n    <-- %s", cr, p->address);
1900         p = p->parent;
1901         }
1902       respond_printf(f, "%s\n", cr);
1903       }
1904     cancel_cutthrough_connection("routing hard fail");
1905
1906     if (!full_info)
1907     {
1908       yield = copy_error(vaddr, addr, FAIL);
1909       goto out;
1910     }
1911     else yield = FAIL;
1912     }
1913
1914   /* Soft failure */
1915
1916   else if (rc == DEFER)
1917     {
1918     allok = FALSE;
1919     if (f != NULL)
1920       {
1921       address_item *p = addr->parent;
1922       respond_printf(f, "%s%s cannot be resolved at this time", ko_prefix,
1923         full_info? addr->address : address);
1924       if (!expn && admin_user)
1925         {
1926         if (addr->basic_errno > 0)
1927           respond_printf(f, ": %s", strerror(addr->basic_errno));
1928         if (addr->message != NULL)
1929           respond_printf(f, ": %s", addr->message);
1930         else if (addr->basic_errno <= 0)
1931           respond_printf(f, ": unknown error");
1932         }
1933
1934       /* Show parents iff doing full info */
1935
1936       if (full_info) while (p != NULL)
1937         {
1938         respond_printf(f, "%s\n    <-- %s", cr, p->address);
1939         p = p->parent;
1940         }
1941       respond_printf(f, "%s\n", cr);
1942       }
1943     cancel_cutthrough_connection("routing soft fail");
1944
1945     if (!full_info)
1946       {
1947       yield = copy_error(vaddr, addr, DEFER);
1948       goto out;
1949       }
1950     else if (yield == OK) yield = DEFER;
1951     }
1952
1953   /* If we are handling EXPN, we do not want to continue to route beyond
1954   the top level (whose address is in "address"). */
1955
1956   else if (expn)
1957     {
1958     uschar *ok_prefix = US"250-";
1959     if (addr_new == NULL)
1960       {
1961       if (addr_local == NULL && addr_remote == NULL)
1962         respond_printf(f, "250 mail to <%s> is discarded\r\n", address);
1963       else
1964         respond_printf(f, "250 <%s>\r\n", address);
1965       }
1966     else while (addr_new != NULL)
1967       {
1968       address_item *addr2 = addr_new;
1969       addr_new = addr2->next;
1970       if (addr_new == NULL) ok_prefix = US"250 ";
1971       respond_printf(f, "%s<%s>\r\n", ok_prefix, addr2->address);
1972       }
1973     yield = OK;
1974     goto out;
1975     }
1976
1977   /* Successful routing other than EXPN. */
1978
1979   else
1980     {
1981     /* Handle successful routing when short info wanted. Otherwise continue for
1982     other (generated) addresses. Short info is the operational case. Full info
1983     can be requested only when debug_selector != 0 and a file is supplied.
1984
1985     There is a conflict between the use of aliasing as an alternate email
1986     address, and as a sort of mailing list. If an alias turns the incoming
1987     address into just one address (e.g. J.Caesar->jc44) you may well want to
1988     carry on verifying the generated address to ensure it is valid when
1989     checking incoming mail. If aliasing generates multiple addresses, you
1990     probably don't want to do this. Exim therefore treats the generation of
1991     just a single new address as a special case, and continues on to verify the
1992     generated address. */
1993
1994     if (!full_info &&                    /* Stop if short info wanted AND */
1995          (((addr_new == NULL ||          /* No new address OR */
1996            addr_new->next != NULL ||     /* More than one new address OR */
1997            testflag(addr_new, af_pfr)))  /* New address is pfr */
1998          ||                              /* OR */
1999          (addr_new != NULL &&            /* At least one new address AND */
2000           success_on_redirect)))         /* success_on_redirect is set */
2001       {
2002       if (f != NULL) fprintf(f, "%s %s\n", address,
2003         address_test_mode? "is deliverable" : "verified");
2004
2005       /* If we have carried on to verify a child address, we want the value
2006       of $address_data to be that of the child */
2007
2008       vaddr->p.address_data = addr->p.address_data;
2009       yield = OK;
2010       goto out;
2011       }
2012     }
2013   }     /* Loop for generated addresses */
2014
2015 /* Display the full results of the successful routing, including any generated
2016 addresses. Control gets here only when full_info is set, which requires f not
2017 to be NULL, and this occurs only when a top-level verify is called with the
2018 debugging switch on.
2019
2020 If there are no local and no remote addresses, and there were no pipes, files,
2021 or autoreplies, and there were no errors or deferments, the message is to be
2022 discarded, usually because of the use of :blackhole: in an alias file. */
2023
2024 if (allok && addr_local == NULL && addr_remote == NULL)
2025   {
2026   fprintf(f, "mail to %s is discarded\n", address);
2027   goto out;
2028   }
2029
2030 for (addr_list = addr_local, i = 0; i < 2; addr_list = addr_remote, i++)
2031   {
2032   while (addr_list != NULL)
2033     {
2034     address_item *addr = addr_list;
2035     address_item *p = addr->parent;
2036     addr_list = addr->next;
2037
2038     fprintf(f, "%s", CS addr->address);
2039 #ifdef EXPERIMENTAL_SRS
2040     if(addr->p.srs_sender)
2041       fprintf(f, "    [srs = %s]", addr->p.srs_sender);
2042 #endif
2043
2044     /* If the address is a duplicate, show something about it. */
2045
2046     if (!testflag(addr, af_pfr))
2047       {
2048       tree_node *tnode;
2049       if ((tnode = tree_search(tree_duplicates, addr->unique)) != NULL)
2050         fprintf(f, "   [duplicate, would not be delivered]");
2051       else tree_add_duplicate(addr->unique, addr);
2052       }
2053
2054     /* Now show its parents */
2055
2056     while (p != NULL)
2057       {
2058       fprintf(f, "\n    <-- %s", p->address);
2059       p = p->parent;
2060       }
2061     fprintf(f, "\n  ");
2062
2063     /* Show router, and transport */
2064
2065     fprintf(f, "router = %s, ", addr->router->name);
2066     fprintf(f, "transport = %s\n", (addr->transport == NULL)? US"unset" :
2067       addr->transport->name);
2068
2069     /* Show any hosts that are set up by a router unless the transport
2070     is going to override them; fiddle a bit to get a nice format. */
2071
2072     if (addr->host_list != NULL && addr->transport != NULL &&
2073         !addr->transport->overrides_hosts)
2074       {
2075       host_item *h;
2076       int maxlen = 0;
2077       int maxaddlen = 0;
2078       for (h = addr->host_list; h != NULL; h = h->next)
2079         {
2080         int len = Ustrlen(h->name);
2081         if (len > maxlen) maxlen = len;
2082         len = (h->address != NULL)? Ustrlen(h->address) : 7;
2083         if (len > maxaddlen) maxaddlen = len;
2084         }
2085       for (h = addr->host_list; h != NULL; h = h->next)
2086         {
2087         int len = Ustrlen(h->name);
2088         fprintf(f, "  host %s ", h->name);
2089         while (len++ < maxlen) fprintf(f, " ");
2090         if (h->address != NULL)
2091           {
2092           fprintf(f, "[%s] ", h->address);
2093           len = Ustrlen(h->address);
2094           }
2095         else if (!addr->transport->info->local)  /* Omit [unknown] for local */
2096           {
2097           fprintf(f, "[unknown] ");
2098           len = 7;
2099           }
2100         else len = -3;
2101         while (len++ < maxaddlen) fprintf(f," ");
2102         if (h->mx >= 0) fprintf(f, "MX=%d", h->mx);
2103         if (h->port != PORT_NONE) fprintf(f, " port=%d", h->port);
2104         if (h->status == hstatus_unusable) fprintf(f, " ** unusable **");
2105         fprintf(f, "\n");
2106         }
2107       }
2108     }
2109   }
2110
2111 /* Yield will be DEFER or FAIL if any one address has, only for full_info (which is
2112 the -bv or -bt case). */
2113
2114 out:
2115 tls_modify_variables(&tls_in);
2116
2117 return yield;
2118 }
2119
2120
2121
2122
2123 /*************************************************
2124 *      Check headers for syntax errors           *
2125 *************************************************/
2126
2127 /* This function checks those header lines that contain addresses, and verifies
2128 that all the addresses therein are syntactially correct.
2129
2130 Arguments:
2131   msgptr     where to put an error message
2132
2133 Returns:     OK
2134              FAIL
2135 */
2136
2137 int
2138 verify_check_headers(uschar **msgptr)
2139 {
2140 header_line *h;
2141 uschar *colon, *s;
2142 int yield = OK;
2143
2144 for (h = header_list; h != NULL && yield == OK; h = h->next)
2145   {
2146   if (h->type != htype_from &&
2147       h->type != htype_reply_to &&
2148       h->type != htype_sender &&
2149       h->type != htype_to &&
2150       h->type != htype_cc &&
2151       h->type != htype_bcc)
2152     continue;
2153
2154   colon = Ustrchr(h->text, ':');
2155   s = colon + 1;
2156   while (isspace(*s)) s++;
2157
2158   /* Loop for multiple addresses in the header, enabling group syntax. Note
2159   that we have to reset this after the header has been scanned. */
2160
2161   parse_allow_group = TRUE;
2162
2163   while (*s != 0)
2164     {
2165     uschar *ss = parse_find_address_end(s, FALSE);
2166     uschar *recipient, *errmess;
2167     int terminator = *ss;
2168     int start, end, domain;
2169
2170     /* Temporarily terminate the string at this point, and extract the
2171     operative address within, allowing group syntax. */
2172
2173     *ss = 0;
2174     recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
2175     *ss = terminator;
2176
2177     /* Permit an unqualified address only if the message is local, or if the
2178     sending host is configured to be permitted to send them. */
2179
2180     if (recipient != NULL && domain == 0)
2181       {
2182       if (h->type == htype_from || h->type == htype_sender)
2183         {
2184         if (!allow_unqualified_sender) recipient = NULL;
2185         }
2186       else
2187         {
2188         if (!allow_unqualified_recipient) recipient = NULL;
2189         }
2190       if (recipient == NULL) errmess = US"unqualified address not permitted";
2191       }
2192
2193     /* It's an error if no address could be extracted, except for the special
2194     case of an empty address. */
2195
2196     if (recipient == NULL && Ustrcmp(errmess, "empty address") != 0)
2197       {
2198       uschar *verb = US"is";
2199       uschar *t = ss;
2200       uschar *tt = colon;
2201       int len;
2202
2203       /* Arrange not to include any white space at the end in the
2204       error message or the header name. */
2205
2206       while (t > s && isspace(t[-1])) t--;
2207       while (tt > h->text && isspace(tt[-1])) tt--;
2208
2209       /* Add the address that failed to the error message, since in a
2210       header with very many addresses it is sometimes hard to spot
2211       which one is at fault. However, limit the amount of address to
2212       quote - cases have been seen where, for example, a missing double
2213       quote in a humungous To: header creates an "address" that is longer
2214       than string_sprintf can handle. */
2215
2216       len = t - s;
2217       if (len > 1024)
2218         {
2219         len = 1024;
2220         verb = US"begins";
2221         }
2222
2223       *msgptr = string_printing(
2224         string_sprintf("%s: failing address in \"%.*s:\" header %s: %.*s",
2225           errmess, tt - h->text, h->text, verb, len, s));
2226
2227       yield = FAIL;
2228       break;          /* Out of address loop */
2229       }
2230
2231     /* Advance to the next address */
2232
2233     s = ss + (terminator? 1:0);
2234     while (isspace(*s)) s++;
2235     }   /* Next address */
2236
2237   parse_allow_group = FALSE;
2238   parse_found_group = FALSE;
2239   }     /* Next header unless yield has been set FALSE */
2240
2241 return yield;
2242 }
2243
2244
2245 /*************************************************
2246 *      Check header names for 8-bit characters   *
2247 *************************************************/
2248
2249 /* This function checks for invalid charcters in header names. See
2250 RFC 5322, 2.2. and RFC 6532, 3.
2251
2252 Arguments:
2253   msgptr     where to put an error message
2254
2255 Returns:     OK
2256              FAIL
2257 */
2258
2259 int
2260 verify_check_header_names_ascii(uschar **msgptr)
2261 {
2262 header_line *h;
2263 uschar *colon, *s;
2264
2265 for (h = header_list; h != NULL; h = h->next)
2266   {
2267    colon = Ustrchr(h->text, ':');
2268    for(s = h->text; s < colon; s++)
2269      {
2270         if ((*s < 33) || (*s > 126))
2271         {
2272                 *msgptr = string_sprintf("Invalid character in header \"%.*s\" found",
2273                                          colon - h->text, h->text);
2274                 return FAIL;
2275         }
2276      }
2277   }
2278 return OK;
2279 }
2280
2281 /*************************************************
2282 *          Check for blind recipients            *
2283 *************************************************/
2284
2285 /* This function checks that every (envelope) recipient is mentioned in either
2286 the To: or Cc: header lines, thus detecting blind carbon copies.
2287
2288 There are two ways of scanning that could be used: either scan the header lines
2289 and tick off the recipients, or scan the recipients and check the header lines.
2290 The original proposed patch did the former, but I have chosen to do the latter,
2291 because (a) it requires no memory and (b) will use fewer resources when there
2292 are many addresses in To: and/or Cc: and only one or two envelope recipients.
2293
2294 Arguments:   none
2295 Returns:     OK    if there are no blind recipients
2296              FAIL  if there is at least one blind recipient
2297 */
2298
2299 int
2300 verify_check_notblind(void)
2301 {
2302 int i;
2303 for (i = 0; i < recipients_count; i++)
2304   {
2305   header_line *h;
2306   BOOL found = FALSE;
2307   uschar *address = recipients_list[i].address;
2308
2309   for (h = header_list; !found && h != NULL; h = h->next)
2310     {
2311     uschar *colon, *s;
2312
2313     if (h->type != htype_to && h->type != htype_cc) continue;
2314
2315     colon = Ustrchr(h->text, ':');
2316     s = colon + 1;
2317     while (isspace(*s)) s++;
2318
2319     /* Loop for multiple addresses in the header, enabling group syntax. Note
2320     that we have to reset this after the header has been scanned. */
2321
2322     parse_allow_group = TRUE;
2323
2324     while (*s != 0)
2325       {
2326       uschar *ss = parse_find_address_end(s, FALSE);
2327       uschar *recipient,*errmess;
2328       int terminator = *ss;
2329       int start, end, domain;
2330
2331       /* Temporarily terminate the string at this point, and extract the
2332       operative address within, allowing group syntax. */
2333
2334       *ss = 0;
2335       recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
2336       *ss = terminator;
2337
2338       /* If we found a valid recipient that has a domain, compare it with the
2339       envelope recipient. Local parts are compared case-sensitively, domains
2340       case-insensitively. By comparing from the start with length "domain", we
2341       include the "@" at the end, which ensures that we are comparing the whole
2342       local part of each address. */
2343
2344       if (recipient != NULL && domain != 0)
2345         {
2346         found = Ustrncmp(recipient, address, domain) == 0 &&
2347                 strcmpic(recipient + domain, address + domain) == 0;
2348         if (found) break;
2349         }
2350
2351       /* Advance to the next address */
2352
2353       s = ss + (terminator? 1:0);
2354       while (isspace(*s)) s++;
2355       }   /* Next address */
2356
2357     parse_allow_group = FALSE;
2358     parse_found_group = FALSE;
2359     }     /* Next header (if found is false) */
2360
2361   if (!found) return FAIL;
2362   }       /* Next recipient */
2363
2364 return OK;
2365 }
2366
2367
2368
2369 /*************************************************
2370 *          Find if verified sender               *
2371 *************************************************/
2372
2373 /* Usually, just a single address is verified as the sender of the message.
2374 However, Exim can be made to verify other addresses as well (often related in
2375 some way), and this is useful in some environments. There may therefore be a
2376 chain of such addresses that have previously been tested. This function finds
2377 whether a given address is on the chain.
2378
2379 Arguments:   the address to be verified
2380 Returns:     pointer to an address item, or NULL
2381 */
2382
2383 address_item *
2384 verify_checked_sender(uschar *sender)
2385 {
2386 address_item *addr;
2387 for (addr = sender_verified_list; addr != NULL; addr = addr->next)
2388   if (Ustrcmp(sender, addr->address) == 0) break;
2389 return addr;
2390 }
2391
2392
2393
2394
2395
2396 /*************************************************
2397 *             Get valid header address           *
2398 *************************************************/
2399
2400 /* Scan the originator headers of the message, looking for an address that
2401 verifies successfully. RFC 822 says:
2402
2403     o   The "Sender" field mailbox should be sent  notices  of
2404         any  problems in transport or delivery of the original
2405         messages.  If there is no  "Sender"  field,  then  the
2406         "From" field mailbox should be used.
2407
2408     o   If the "Reply-To" field exists, then the reply  should
2409         go to the addresses indicated in that field and not to
2410         the address(es) indicated in the "From" field.
2411
2412 So we check a Sender field if there is one, else a Reply_to field, else a From
2413 field. As some strange messages may have more than one of these fields,
2414 especially if they are resent- fields, check all of them if there is more than
2415 one.
2416
2417 Arguments:
2418   user_msgptr      points to where to put a user error message
2419   log_msgptr       points to where to put a log error message
2420   callout          timeout for callout check (passed to verify_address())
2421   callout_overall  overall callout timeout (ditto)
2422   callout_connect  connect callout timeout (ditto)
2423   se_mailfrom      mailfrom for verify; NULL => ""
2424   pm_mailfrom      sender for pm callout check (passed to verify_address())
2425   options          callout options (passed to verify_address())
2426   verrno           where to put the address basic_errno
2427
2428 If log_msgptr is set to something without setting user_msgptr, the caller
2429 normally uses log_msgptr for both things.
2430
2431 Returns:           result of the verification attempt: OK, FAIL, or DEFER;
2432                    FAIL is given if no appropriate headers are found
2433 */
2434
2435 int
2436 verify_check_header_address(uschar **user_msgptr, uschar **log_msgptr,
2437   int callout, int callout_overall, int callout_connect, uschar *se_mailfrom,
2438   uschar *pm_mailfrom, int options, int *verrno)
2439 {
2440 static int header_types[] = { htype_sender, htype_reply_to, htype_from };
2441 BOOL done = FALSE;
2442 int yield = FAIL;
2443 int i;
2444
2445 for (i = 0; i < 3 && !done; i++)
2446   {
2447   header_line *h;
2448   for (h = header_list; h != NULL && !done; h = h->next)
2449     {
2450     int terminator, new_ok;
2451     uschar *s, *ss, *endname;
2452
2453     if (h->type != header_types[i]) continue;
2454     s = endname = Ustrchr(h->text, ':') + 1;
2455
2456     /* Scan the addresses in the header, enabling group syntax. Note that we
2457     have to reset this after the header has been scanned. */
2458
2459     parse_allow_group = TRUE;
2460
2461     while (*s != 0)
2462       {
2463       address_item *vaddr;
2464
2465       while (isspace(*s) || *s == ',') s++;
2466       if (*s == 0) break;        /* End of header */
2467
2468       ss = parse_find_address_end(s, FALSE);
2469
2470       /* The terminator is a comma or end of header, but there may be white
2471       space preceding it (including newline for the last address). Move back
2472       past any white space so we can check against any cached envelope sender
2473       address verifications. */
2474
2475       while (isspace(ss[-1])) ss--;
2476       terminator = *ss;
2477       *ss = 0;
2478
2479       HDEBUG(D_verify) debug_printf("verifying %.*s header address %s\n",
2480         (int)(endname - h->text), h->text, s);
2481
2482       /* See if we have already verified this address as an envelope sender,
2483       and if so, use the previous answer. */
2484
2485       vaddr = verify_checked_sender(s);
2486
2487       if (vaddr != NULL &&                   /* Previously checked */
2488            (callout <= 0 ||                  /* No callout needed; OR */
2489             vaddr->special_action > 256))    /* Callout was done */
2490         {
2491         new_ok = vaddr->special_action & 255;
2492         HDEBUG(D_verify) debug_printf("previously checked as envelope sender\n");
2493         *ss = terminator;  /* Restore shortened string */
2494         }
2495
2496       /* Otherwise we run the verification now. We must restore the shortened
2497       string before running the verification, so the headers are correct, in
2498       case there is any rewriting. */
2499
2500       else
2501         {
2502         int start, end, domain;
2503         uschar *address = parse_extract_address(s, log_msgptr, &start, &end,
2504           &domain, FALSE);
2505
2506         *ss = terminator;
2507
2508         /* If we found an empty address, just carry on with the next one, but
2509         kill the message. */
2510
2511         if (address == NULL && Ustrcmp(*log_msgptr, "empty address") == 0)
2512           {
2513           *log_msgptr = NULL;
2514           s = ss;
2515           continue;
2516           }
2517
2518         /* If verification failed because of a syntax error, fail this
2519         function, and ensure that the failing address gets added to the error
2520         message. */
2521
2522         if (address == NULL)
2523           {
2524           new_ok = FAIL;
2525           while (ss > s && isspace(ss[-1])) ss--;
2526           *log_msgptr = string_sprintf("syntax error in '%.*s' header when "
2527             "scanning for sender: %s in \"%.*s\"",
2528             endname - h->text, h->text, *log_msgptr, ss - s, s);
2529           yield = FAIL;
2530           done = TRUE;
2531           break;
2532           }
2533
2534         /* Else go ahead with the sender verification. But it isn't *the*
2535         sender of the message, so set vopt_fake_sender to stop sender_address
2536         being replaced after rewriting or qualification. */
2537
2538         else
2539           {
2540           vaddr = deliver_make_addr(address, FALSE);
2541           new_ok = verify_address(vaddr, NULL, options | vopt_fake_sender,
2542             callout, callout_overall, callout_connect, se_mailfrom,
2543             pm_mailfrom, NULL);
2544           }
2545         }
2546
2547       /* We now have the result, either newly found, or cached. If we are
2548       giving out error details, set a specific user error. This means that the
2549       last of these will be returned to the user if all three fail. We do not
2550       set a log message - the generic one below will be used. */
2551
2552       if (new_ok != OK)
2553         {
2554         *verrno = vaddr->basic_errno;
2555         if (smtp_return_error_details)
2556           {
2557           *user_msgptr = string_sprintf("Rejected after DATA: "
2558             "could not verify \"%.*s\" header address\n%s: %s",
2559             endname - h->text, h->text, vaddr->address, vaddr->message);
2560           }
2561         }
2562
2563       /* Success or defer */
2564
2565       if (new_ok == OK)
2566         {
2567         yield = OK;
2568         done = TRUE;
2569         break;
2570         }
2571
2572       if (new_ok == DEFER) yield = DEFER;
2573
2574       /* Move on to any more addresses in the header */
2575
2576       s = ss;
2577       }     /* Next address */
2578
2579     parse_allow_group = FALSE;
2580     parse_found_group = FALSE;
2581     }       /* Next header, unless done */
2582   }         /* Next header type unless done */
2583
2584 if (yield == FAIL && *log_msgptr == NULL)
2585   *log_msgptr = US"there is no valid sender in any header line";
2586
2587 if (yield == DEFER && *log_msgptr == NULL)
2588   *log_msgptr = US"all attempts to verify a sender in a header line deferred";
2589
2590 return yield;
2591 }
2592
2593
2594
2595
2596 /*************************************************
2597 *            Get RFC 1413 identification         *
2598 *************************************************/
2599
2600 /* Attempt to get an id from the sending machine via the RFC 1413 protocol. If
2601 the timeout is set to zero, then the query is not done. There may also be lists
2602 of hosts and nets which are exempt. To guard against malefactors sending
2603 non-printing characters which could, for example, disrupt a message's headers,
2604 make sure the string consists of printing characters only.
2605
2606 Argument:
2607   port    the port to connect to; usually this is IDENT_PORT (113), but when
2608           running in the test harness with -bh a different value is used.
2609
2610 Returns:  nothing
2611
2612 Side effect: any received ident value is put in sender_ident (NULL otherwise)
2613 */
2614
2615 void
2616 verify_get_ident(int port)
2617 {
2618 int sock, host_af, qlen;
2619 int received_sender_port, received_interface_port, n;
2620 uschar *p;
2621 uschar buffer[2048];
2622
2623 /* Default is no ident. Check whether we want to do an ident check for this
2624 host. */
2625
2626 sender_ident = NULL;
2627 if (rfc1413_query_timeout <= 0 || verify_check_host(&rfc1413_hosts) != OK)
2628   return;
2629
2630 DEBUG(D_ident) debug_printf("doing ident callback\n");
2631
2632 /* Set up a connection to the ident port of the remote host. Bind the local end
2633 to the incoming interface address. If the sender host address is an IPv6
2634 address, the incoming interface address will also be IPv6. */
2635
2636 host_af = (Ustrchr(sender_host_address, ':') == NULL)? AF_INET : AF_INET6;
2637 sock = ip_socket(SOCK_STREAM, host_af);
2638 if (sock < 0) return;
2639
2640 if (ip_bind(sock, host_af, interface_address, 0) < 0)
2641   {
2642   DEBUG(D_ident) debug_printf("bind socket for ident failed: %s\n",
2643     strerror(errno));
2644   goto END_OFF;
2645   }
2646
2647 if (ip_connect(sock, host_af, sender_host_address, port, rfc1413_query_timeout)
2648      < 0)
2649   {
2650   if (errno == ETIMEDOUT && (log_extra_selector & LX_ident_timeout) != 0)
2651     {
2652     log_write(0, LOG_MAIN, "ident connection to %s timed out",
2653       sender_host_address);
2654     }
2655   else
2656     {
2657     DEBUG(D_ident) debug_printf("ident connection to %s failed: %s\n",
2658       sender_host_address, strerror(errno));
2659     }
2660   goto END_OFF;
2661   }
2662
2663 /* Construct and send the query. */
2664
2665 sprintf(CS buffer, "%d , %d\r\n", sender_host_port, interface_port);
2666 qlen = Ustrlen(buffer);
2667 if (send(sock, buffer, qlen, 0) < 0)
2668   {
2669   DEBUG(D_ident) debug_printf("ident send failed: %s\n", strerror(errno));
2670   goto END_OFF;
2671   }
2672
2673 /* Read a response line. We put it into the rest of the buffer, using several
2674 recv() calls if necessary. */
2675
2676 p = buffer + qlen;
2677
2678 for (;;)
2679   {
2680   uschar *pp;
2681   int count;
2682   int size = sizeof(buffer) - (p - buffer);
2683
2684   if (size <= 0) goto END_OFF;   /* Buffer filled without seeing \n. */
2685   count = ip_recv(sock, p, size, rfc1413_query_timeout);
2686   if (count <= 0) goto END_OFF;  /* Read error or EOF */
2687
2688   /* Scan what we just read, to see if we have reached the terminating \r\n. Be
2689   generous, and accept a plain \n terminator as well. The only illegal
2690   character is 0. */
2691
2692   for (pp = p; pp < p + count; pp++)
2693     {
2694     if (*pp == 0) goto END_OFF;   /* Zero octet not allowed */
2695     if (*pp == '\n')
2696       {
2697       if (pp[-1] == '\r') pp--;
2698       *pp = 0;
2699       goto GOT_DATA;             /* Break out of both loops */
2700       }
2701     }
2702
2703   /* Reached the end of the data without finding \n. Let the loop continue to
2704   read some more, if there is room. */
2705
2706   p = pp;
2707   }
2708
2709 GOT_DATA:
2710
2711 /* We have received a line of data. Check it carefully. It must start with the
2712 same two port numbers that we sent, followed by data as defined by the RFC. For
2713 example,
2714
2715   12345 , 25 : USERID : UNIX :root
2716
2717 However, the amount of white space may be different to what we sent. In the
2718 "osname" field there may be several sub-fields, comma separated. The data we
2719 actually want to save follows the third colon. Some systems put leading spaces
2720 in it - we discard those. */
2721
2722 if (sscanf(CS buffer + qlen, "%d , %d%n", &received_sender_port,
2723       &received_interface_port, &n) != 2 ||
2724     received_sender_port != sender_host_port ||
2725     received_interface_port != interface_port)
2726   goto END_OFF;
2727
2728 p = buffer + qlen + n;
2729 while(isspace(*p)) p++;
2730 if (*p++ != ':') goto END_OFF;
2731 while(isspace(*p)) p++;
2732 if (Ustrncmp(p, "USERID", 6) != 0) goto END_OFF;
2733 p += 6;
2734 while(isspace(*p)) p++;
2735 if (*p++ != ':') goto END_OFF;
2736 while (*p != 0 && *p != ':') p++;
2737 if (*p++ == 0) goto END_OFF;
2738 while(isspace(*p)) p++;
2739 if (*p == 0) goto END_OFF;
2740
2741 /* The rest of the line is the data we want. We turn it into printing
2742 characters when we save it, so that it cannot mess up the format of any logging
2743 or Received: lines into which it gets inserted. We keep a maximum of 127
2744 characters. */
2745
2746 sender_ident = string_printing(string_copyn(p, 127));
2747 DEBUG(D_ident) debug_printf("sender_ident = %s\n", sender_ident);
2748
2749 END_OFF:
2750 (void)close(sock);
2751 return;
2752 }
2753
2754
2755
2756
2757 /*************************************************
2758 *      Match host to a single host-list item     *
2759 *************************************************/
2760
2761 /* This function compares a host (name or address) against a single item
2762 from a host list. The host name gets looked up if it is needed and is not
2763 already known. The function is called from verify_check_this_host() via
2764 match_check_list(), which is why most of its arguments are in a single block.
2765
2766 Arguments:
2767   arg            the argument block (see below)
2768   ss             the host-list item
2769   valueptr       where to pass back looked up data, or NULL
2770   error          for error message when returning ERROR
2771
2772 The block contains:
2773   host_name      (a) the host name, or
2774                  (b) NULL, implying use sender_host_name and
2775                        sender_host_aliases, looking them up if required, or
2776                  (c) the empty string, meaning that only IP address matches
2777                        are permitted
2778   host_address   the host address
2779   host_ipv4      the IPv4 address taken from an IPv6 one
2780
2781 Returns:         OK      matched
2782                  FAIL    did not match
2783                  DEFER   lookup deferred
2784                  ERROR   (a) failed to find the host name or IP address, or
2785                          (b) unknown lookup type specified, or
2786                          (c) host name encountered when only IP addresses are
2787                                being matched
2788 */
2789
2790 int
2791 check_host(void *arg, uschar *ss, uschar **valueptr, uschar **error)
2792 {
2793 check_host_block *cb = (check_host_block *)arg;
2794 int mlen = -1;
2795 int maskoffset;
2796 BOOL iplookup = FALSE;
2797 BOOL isquery = FALSE;
2798 BOOL isiponly = cb->host_name != NULL && cb->host_name[0] == 0;
2799 uschar *t;
2800 uschar *semicolon;
2801 uschar **aliases;
2802
2803 /* Optimize for the special case when the pattern is "*". */
2804
2805 if (*ss == '*' && ss[1] == 0) return OK;
2806
2807 /* If the pattern is empty, it matches only in the case when there is no host -
2808 this can occur in ACL checking for SMTP input using the -bs option. In this
2809 situation, the host address is the empty string. */
2810
2811 if (cb->host_address[0] == 0) return (*ss == 0)? OK : FAIL;
2812 if (*ss == 0) return FAIL;
2813
2814 /* If the pattern is precisely "@" then match against the primary host name,
2815 provided that host name matching is permitted; if it's "@[]" match against the
2816 local host's IP addresses. */
2817
2818 if (*ss == '@')
2819   {
2820   if (ss[1] == 0)
2821     {
2822     if (isiponly) return ERROR;
2823     ss = primary_hostname;
2824     }
2825   else if (Ustrcmp(ss, "@[]") == 0)
2826     {
2827     ip_address_item *ip;
2828     for (ip = host_find_interfaces(); ip != NULL; ip = ip->next)
2829       if (Ustrcmp(ip->address, cb->host_address) == 0) return OK;
2830     return FAIL;
2831     }
2832   }
2833
2834 /* If the pattern is an IP address, optionally followed by a bitmask count, do
2835 a (possibly masked) comparision with the current IP address. */
2836
2837 if (string_is_ip_address(ss, &maskoffset) != 0)
2838   return (host_is_in_net(cb->host_address, ss, maskoffset)? OK : FAIL);
2839
2840 /* The pattern is not an IP address. A common error that people make is to omit
2841 one component of an IPv4 address, either by accident, or believing that, for
2842 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,
2843 which it isn't. (Those applications that do accept 1.2.3 as an IP address
2844 interpret it as 1.2.0.3 because the final component becomes 16-bit - this is an
2845 ancient specification.) To aid in debugging these cases, we give a specific
2846 error if the pattern contains only digits and dots or contains a slash preceded
2847 only by digits and dots (a slash at the start indicates a file name and of
2848 course slashes may be present in lookups, but not preceded only by digits and
2849 dots). */
2850
2851 for (t = ss; isdigit(*t) || *t == '.'; t++);
2852 if (*t == 0 || (*t == '/' && t != ss))
2853   {
2854   *error = US"malformed IPv4 address or address mask";
2855   return ERROR;
2856   }
2857
2858 /* See if there is a semicolon in the pattern */
2859
2860 semicolon = Ustrchr(ss, ';');
2861
2862 /* If we are doing an IP address only match, then all lookups must be IP
2863 address lookups, even if there is no "net-". */
2864
2865 if (isiponly)
2866   {
2867   iplookup = semicolon != NULL;
2868   }
2869
2870 /* Otherwise, if the item is of the form net[n]-lookup;<file|query> then it is
2871 a lookup on a masked IP network, in textual form. We obey this code even if we
2872 have already set iplookup, so as to skip over the "net-" prefix and to set the
2873 mask length. The net- stuff really only applies to single-key lookups where the
2874 key is implicit. For query-style lookups the key is specified in the query.
2875 From release 4.30, the use of net- for query style is no longer needed, but we
2876 retain it for backward compatibility. */
2877
2878 if (Ustrncmp(ss, "net", 3) == 0 && semicolon != NULL)
2879   {
2880   mlen = 0;
2881   for (t = ss + 3; isdigit(*t); t++) mlen = mlen * 10 + *t - '0';
2882   if (mlen == 0 && t == ss+3) mlen = -1;  /* No mask supplied */
2883   iplookup = (*t++ == '-');
2884   }
2885 else t = ss;
2886
2887 /* Do the IP address lookup if that is indeed what we have */
2888
2889 if (iplookup)
2890   {
2891   int insize;
2892   int search_type;
2893   int incoming[4];
2894   void *handle;
2895   uschar *filename, *key, *result;
2896   uschar buffer[64];
2897
2898   /* Find the search type */
2899
2900   search_type = search_findtype(t, semicolon - t);
2901
2902   if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
2903     search_error_message);
2904
2905   /* Adjust parameters for the type of lookup. For a query-style lookup, there
2906   is no file name, and the "key" is just the query. For query-style with a file
2907   name, we have to fish the file off the start of the query. For a single-key
2908   lookup, the key is the current IP address, masked appropriately, and
2909   reconverted to text form, with the mask appended. For IPv6 addresses, specify
2910   dot separators instead of colons, except when the lookup type is "iplsearch".
2911   */
2912
2913   if (mac_islookup(search_type, lookup_absfilequery))
2914     {
2915     filename = semicolon + 1;
2916     key = filename;
2917     while (*key != 0 && !isspace(*key)) key++;
2918     filename = string_copyn(filename, key - filename);
2919     while (isspace(*key)) key++;
2920     }
2921   else if (mac_islookup(search_type, lookup_querystyle))
2922     {
2923     filename = NULL;
2924     key = semicolon + 1;
2925     }
2926   else   /* Single-key style */
2927     {
2928     int sep = (Ustrcmp(lookup_list[search_type]->name, "iplsearch") == 0)?
2929       ':' : '.';
2930     insize = host_aton(cb->host_address, incoming);
2931     host_mask(insize, incoming, mlen);
2932     (void)host_nmtoa(insize, incoming, mlen, buffer, sep);
2933     key = buffer;
2934     filename = semicolon + 1;
2935     }
2936
2937   /* Now do the actual lookup; note that there is no search_close() because
2938   of the caching arrangements. */
2939
2940   handle = search_open(filename, search_type, 0, NULL, NULL);
2941   if (handle == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
2942     search_error_message);
2943   result = search_find(handle, filename, key, -1, NULL, 0, 0, NULL);
2944   if (valueptr != NULL) *valueptr = result;
2945   return (result != NULL)? OK : search_find_defer? DEFER: FAIL;
2946   }
2947
2948 /* The pattern is not an IP address or network reference of any kind. That is,
2949 it is a host name pattern. If this is an IP only match, there's an error in the
2950 host list. */
2951
2952 if (isiponly)
2953   {
2954   *error = US"cannot match host name in match_ip list";
2955   return ERROR;
2956   }
2957
2958 /* Check the characters of the pattern to see if they comprise only letters,
2959 digits, full stops, and hyphens (the constituents of domain names). Allow
2960 underscores, as they are all too commonly found. Sigh. Also, if
2961 allow_utf8_domains is set, allow top-bit characters. */
2962
2963 for (t = ss; *t != 0; t++)
2964   if (!isalnum(*t) && *t != '.' && *t != '-' && *t != '_' &&
2965       (!allow_utf8_domains || *t < 128)) break;
2966
2967 /* If the pattern is a complete domain name, with no fancy characters, look up
2968 its IP address and match against that. Note that a multi-homed host will add
2969 items to the chain. */
2970
2971 if (*t == 0)
2972   {
2973   int rc;
2974   host_item h;
2975   h.next = NULL;
2976   h.name = ss;
2977   h.address = NULL;
2978   h.mx = MX_NONE;
2979
2980   rc = host_find_byname(&h, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, FALSE);
2981   if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
2982     {
2983     host_item *hh;
2984     for (hh = &h; hh != NULL; hh = hh->next)
2985       {
2986       if (host_is_in_net(hh->address, cb->host_address, 0)) return OK;
2987       }
2988     return FAIL;
2989     }
2990   if (rc == HOST_FIND_AGAIN) return DEFER;
2991   *error = string_sprintf("failed to find IP address for %s", ss);
2992   return ERROR;
2993   }
2994
2995 /* Almost all subsequent comparisons require the host name, and can be done
2996 using the general string matching function. When this function is called for
2997 outgoing hosts, the name is always given explicitly. If it is NULL, it means we
2998 must use sender_host_name and its aliases, looking them up if necessary. */
2999
3000 if (cb->host_name != NULL)   /* Explicit host name given */
3001   return match_check_string(cb->host_name, ss, -1, TRUE, TRUE, TRUE,
3002     valueptr);
3003
3004 /* Host name not given; in principle we need the sender host name and its
3005 aliases. However, for query-style lookups, we do not need the name if the
3006 query does not contain $sender_host_name. From release 4.23, a reference to
3007 $sender_host_name causes it to be looked up, so we don't need to do the lookup
3008 on spec. */
3009
3010 if ((semicolon = Ustrchr(ss, ';')) != NULL)
3011   {
3012   uschar *affix;
3013   int partial, affixlen, starflags, id;
3014
3015   *semicolon = 0;
3016   id = search_findtype_partial(ss, &partial, &affix, &affixlen, &starflags);
3017   *semicolon=';';
3018
3019   if (id < 0)                           /* Unknown lookup type */
3020     {
3021     log_write(0, LOG_MAIN|LOG_PANIC, "%s in host list item \"%s\"",
3022       search_error_message, ss);
3023     return DEFER;
3024     }
3025   isquery = mac_islookup(id, lookup_querystyle|lookup_absfilequery);
3026   }
3027
3028 if (isquery)
3029   {
3030   switch(match_check_string(US"", ss, -1, TRUE, TRUE, TRUE, valueptr))
3031     {
3032     case OK:    return OK;
3033     case DEFER: return DEFER;
3034     default:    return FAIL;
3035     }
3036   }
3037
3038 /* Not a query-style lookup; must ensure the host name is present, and then we
3039 do a check on the name and all its aliases. */
3040
3041 if (sender_host_name == NULL)
3042   {
3043   HDEBUG(D_host_lookup)
3044     debug_printf("sender host name required, to match against %s\n", ss);
3045   if (host_lookup_failed || host_name_lookup() != OK)
3046     {
3047     *error = string_sprintf("failed to find host name for %s",
3048       sender_host_address);;
3049     return ERROR;
3050     }
3051   host_build_sender_fullhost();
3052   }
3053
3054 /* Match on the sender host name, using the general matching function */
3055
3056 switch(match_check_string(sender_host_name, ss, -1, TRUE, TRUE, TRUE,
3057        valueptr))
3058   {
3059   case OK:    return OK;
3060   case DEFER: return DEFER;
3061   }
3062
3063 /* If there are aliases, try matching on them. */
3064
3065 aliases = sender_host_aliases;
3066 while (*aliases != NULL)
3067   {
3068   switch(match_check_string(*aliases++, ss, -1, TRUE, TRUE, TRUE, valueptr))
3069     {
3070     case OK:    return OK;
3071     case DEFER: return DEFER;
3072     }
3073   }
3074 return FAIL;
3075 }
3076
3077
3078
3079
3080 /*************************************************
3081 *    Check a specific host matches a host list   *
3082 *************************************************/
3083
3084 /* This function is passed a host list containing items in a number of
3085 different formats and the identity of a host. Its job is to determine whether
3086 the given host is in the set of hosts defined by the list. The host name is
3087 passed as a pointer so that it can be looked up if needed and not already
3088 known. This is commonly the case when called from verify_check_host() to check
3089 an incoming connection. When called from elsewhere the host name should usually
3090 be set.
3091
3092 This function is now just a front end to match_check_list(), which runs common
3093 code for scanning a list. We pass it the check_host() function to perform a
3094 single test.
3095
3096 Arguments:
3097   listptr              pointer to the host list
3098   cache_bits           pointer to cache for named lists, or NULL
3099   host_name            the host name or NULL, implying use sender_host_name and
3100                          sender_host_aliases, looking them up if required
3101   host_address         the IP address
3102   valueptr             if not NULL, data from a lookup is passed back here
3103
3104 Returns:    OK    if the host is in the defined set
3105             FAIL  if the host is not in the defined set,
3106             DEFER if a data lookup deferred (not a host lookup)
3107
3108 If the host name was needed in order to make a comparison, and could not be
3109 determined from the IP address, the result is FAIL unless the item
3110 "+allow_unknown" was met earlier in the list, in which case OK is returned. */
3111
3112 int
3113 verify_check_this_host(uschar **listptr, unsigned int *cache_bits,
3114   uschar *host_name, uschar *host_address, uschar **valueptr)
3115 {
3116 int rc;
3117 unsigned int *local_cache_bits = cache_bits;
3118 uschar *save_host_address = deliver_host_address;
3119 check_host_block cb;
3120 cb.host_name = host_name;
3121 cb.host_address = host_address;
3122
3123 if (valueptr != NULL) *valueptr = NULL;
3124
3125 /* If the host address starts off ::ffff: it is an IPv6 address in
3126 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
3127 addresses. */
3128
3129 cb.host_ipv4 = (Ustrncmp(host_address, "::ffff:", 7) == 0)?
3130   host_address + 7 : host_address;
3131
3132 /* During the running of the check, put the IP address into $host_address. In
3133 the case of calls from the smtp transport, it will already be there. However,
3134 in other calls (e.g. when testing ignore_target_hosts), it won't. Just to be on
3135 the safe side, any existing setting is preserved, though as I write this
3136 (November 2004) I can't see any cases where it is actually needed. */
3137
3138 deliver_host_address = host_address;
3139 rc = match_check_list(
3140        listptr,                                /* the list */
3141        0,                                      /* separator character */
3142        &hostlist_anchor,                       /* anchor pointer */
3143        &local_cache_bits,                      /* cache pointer */
3144        check_host,                             /* function for testing */
3145        &cb,                                    /* argument for function */
3146        MCL_HOST,                               /* type of check */
3147        (host_address == sender_host_address)?
3148          US"host" : host_address,              /* text for debugging */
3149        valueptr);                              /* where to pass back data */
3150 deliver_host_address = save_host_address;
3151 return rc;
3152 }
3153
3154
3155
3156
3157 /*************************************************
3158 *      Check the remote host matches a list      *
3159 *************************************************/
3160
3161 /* This is a front end to verify_check_this_host(), created because checking
3162 the remote host is a common occurrence. With luck, a good compiler will spot
3163 the tail recursion and optimize it. If there's no host address, this is
3164 command-line SMTP input - check against an empty string for the address.
3165
3166 Arguments:
3167   listptr              pointer to the host list
3168
3169 Returns:               the yield of verify_check_this_host(),
3170                        i.e. OK, FAIL, or DEFER
3171 */
3172
3173 int
3174 verify_check_host(uschar **listptr)
3175 {
3176 return verify_check_this_host(listptr, sender_host_cache, NULL,
3177   (sender_host_address == NULL)? US"" : sender_host_address, NULL);
3178 }
3179
3180
3181
3182
3183
3184 /*************************************************
3185 *              Invert an IP address              *
3186 *************************************************/
3187
3188 /* Originally just used for DNS xBL lists, now also used for the
3189 reverse_ip expansion operator.
3190
3191 Arguments:
3192   buffer         where to put the answer
3193   address        the address to invert
3194 */
3195
3196 void
3197 invert_address(uschar *buffer, uschar *address)
3198 {
3199 int bin[4];
3200 uschar *bptr = buffer;
3201
3202 /* If this is an IPv4 address mapped into IPv6 format, adjust the pointer
3203 to the IPv4 part only. */
3204
3205 if (Ustrncmp(address, "::ffff:", 7) == 0) address += 7;
3206
3207 /* Handle IPv4 address: when HAVE_IPV6 is false, the result of host_aton() is
3208 always 1. */
3209
3210 if (host_aton(address, bin) == 1)
3211   {
3212   int i;
3213   int x = bin[0];
3214   for (i = 0; i < 4; i++)
3215     {
3216     sprintf(CS bptr, "%d.", x & 255);
3217     while (*bptr) bptr++;
3218     x >>= 8;
3219     }
3220   }
3221
3222 /* Handle IPv6 address. Actually, as far as I know, there are no IPv6 addresses
3223 in any DNS black lists, and the format in which they will be looked up is
3224 unknown. This is just a guess. */
3225
3226 #if HAVE_IPV6
3227 else
3228   {
3229   int i, j;
3230   for (j = 3; j >= 0; j--)
3231     {
3232     int x = bin[j];
3233     for (i = 0; i < 8; i++)
3234       {
3235       sprintf(CS bptr, "%x.", x & 15);
3236       while (*bptr) bptr++;
3237       x >>= 4;
3238       }
3239     }
3240   }
3241 #endif
3242
3243 /* Remove trailing period -- this is needed so that both arbitrary
3244 dnsbl keydomains and inverted addresses may be combined with the
3245 same format string, "%s.%s" */
3246
3247 *(--bptr) = 0;
3248 }
3249
3250
3251
3252 /*************************************************
3253 *          Perform a single dnsbl lookup         *
3254 *************************************************/
3255
3256 /* This function is called from verify_check_dnsbl() below. It is also called
3257 recursively from within itself when domain and domain_txt are different
3258 pointers, in order to get the TXT record from the alternate domain.
3259
3260 Arguments:
3261   domain         the outer dnsbl domain
3262   domain_txt     alternate domain to lookup TXT record on success; when the
3263                    same domain is to be used, domain_txt == domain (that is,
3264                    the pointers must be identical, not just the text)
3265   keydomain      the current keydomain (for debug message)
3266   prepend        subdomain to lookup (like keydomain, but
3267                    reversed if IP address)
3268   iplist         the list of matching IP addresses, or NULL for "any"
3269   bitmask        true if bitmask matching is wanted
3270   match_type     condition for 'succeed' result
3271                    0 => Any RR in iplist     (=)
3272                    1 => No RR in iplist      (!=)
3273                    2 => All RRs in iplist    (==)
3274                    3 => Some RRs not in iplist (!==)
3275                    the two bits are defined as MT_NOT and MT_ALL
3276   defer_return   what to return for a defer
3277
3278 Returns:         OK if lookup succeeded
3279                  FAIL if not
3280 */
3281
3282 static int
3283 one_check_dnsbl(uschar *domain, uschar *domain_txt, uschar *keydomain,
3284   uschar *prepend, uschar *iplist, BOOL bitmask, int match_type,
3285   int defer_return)
3286 {
3287 dns_answer dnsa;
3288 dns_scan dnss;
3289 tree_node *t;
3290 dnsbl_cache_block *cb;
3291 int old_pool = store_pool;
3292 uschar query[256];         /* DNS domain max length */
3293
3294 /* Construct the specific query domainname */
3295
3296 if (!string_format(query, sizeof(query), "%s.%s", prepend, domain))
3297   {
3298   log_write(0, LOG_MAIN|LOG_PANIC, "dnslist query is too long "
3299     "(ignored): %s...", query);
3300   return FAIL;
3301   }
3302
3303 /* Look for this query in the cache. */
3304
3305 t = tree_search(dnsbl_cache, query);
3306
3307 /* If not cached from a previous lookup, we must do a DNS lookup, and
3308 cache the result in permanent memory. */
3309
3310 if (t == NULL)
3311   {
3312   store_pool = POOL_PERM;
3313
3314   /* Set up a tree entry to cache the lookup */
3315
3316   t = store_get(sizeof(tree_node) + Ustrlen(query));
3317   Ustrcpy(t->name, query);
3318   t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block));
3319   (void)tree_insertnode(&dnsbl_cache, t);
3320
3321   /* Do the DNS loopup . */
3322
3323   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
3324   cb->rc = dns_basic_lookup(&dnsa, query, T_A);
3325   cb->text_set = FALSE;
3326   cb->text = NULL;
3327   cb->rhs = NULL;
3328
3329   /* If the lookup succeeded, cache the RHS address. The code allows for
3330   more than one address - this was for complete generality and the possible
3331   use of A6 records. However, A6 records have been reduced to experimental
3332   status (August 2001) and may die out. So they may never get used at all,
3333   let alone in dnsbl records. However, leave the code here, just in case.
3334
3335   Quite apart from one A6 RR generating multiple addresses, there are DNS
3336   lists that return more than one A record, so we must handle multiple
3337   addresses generated in that way as well. */
3338
3339   if (cb->rc == DNS_SUCCEED)
3340     {
3341     dns_record *rr;
3342     dns_address **addrp = &(cb->rhs);
3343     for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
3344          rr != NULL;
3345          rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
3346       {
3347       if (rr->type == T_A)
3348         {
3349         dns_address *da = dns_address_from_rr(&dnsa, rr);
3350         if (da != NULL)
3351           {
3352           *addrp = da;
3353           while (da->next != NULL) da = da->next;
3354           addrp = &(da->next);
3355           }
3356         }
3357       }
3358
3359     /* If we didn't find any A records, change the return code. This can
3360     happen when there is a CNAME record but there are no A records for what
3361     it points to. */
3362
3363     if (cb->rhs == NULL) cb->rc = DNS_NODATA;
3364     }
3365
3366   store_pool = old_pool;
3367   }
3368
3369 /* Previous lookup was cached */
3370
3371 else
3372   {
3373   HDEBUG(D_dnsbl) debug_printf("using result of previous DNS lookup\n");
3374   cb = t->data.ptr;
3375   }
3376
3377 /* We now have the result of the DNS lookup, either newly done, or cached
3378 from a previous call. If the lookup succeeded, check against the address
3379 list if there is one. This may be a positive equality list (introduced by
3380 "="), a negative equality list (introduced by "!="), a positive bitmask
3381 list (introduced by "&"), or a negative bitmask list (introduced by "!&").*/
3382
3383 if (cb->rc == DNS_SUCCEED)
3384   {
3385   dns_address *da = NULL;
3386   uschar *addlist = cb->rhs->address;
3387
3388   /* For A and AAAA records, there may be multiple addresses from multiple
3389   records. For A6 records (currently not expected to be used) there may be
3390   multiple addresses from a single record. */
3391
3392   for (da = cb->rhs->next; da != NULL; da = da->next)
3393     addlist = string_sprintf("%s, %s", addlist, da->address);
3394
3395   HDEBUG(D_dnsbl) debug_printf("DNS lookup for %s succeeded (yielding %s)\n",
3396     query, addlist);
3397
3398   /* Address list check; this can be either for equality, or via a bitmask.
3399   In the latter case, all the bits must match. */
3400
3401   if (iplist != NULL)
3402     {
3403     for (da = cb->rhs; da != NULL; da = da->next)
3404       {
3405       int ipsep = ',';
3406       uschar ip[46];
3407       uschar *ptr = iplist;
3408       uschar *res;
3409
3410       /* Handle exact matching */
3411
3412       if (!bitmask)
3413         {
3414         while ((res = string_nextinlist(&ptr, &ipsep, ip, sizeof(ip))) != NULL)
3415           {
3416           if (Ustrcmp(CS da->address, ip) == 0) break;
3417           }
3418         }
3419
3420       /* Handle bitmask matching */
3421
3422       else
3423         {
3424         int address[4];
3425         int mask = 0;
3426
3427         /* At present, all known DNS blocking lists use A records, with
3428         IPv4 addresses on the RHS encoding the information they return. I
3429         wonder if this will linger on as the last vestige of IPv4 when IPv6
3430         is ubiquitous? Anyway, for now we use paranoia code to completely
3431         ignore IPv6 addresses. The default mask is 0, which always matches.
3432         We change this only for IPv4 addresses in the list. */
3433
3434         if (host_aton(da->address, address) == 1) mask = address[0];
3435
3436         /* Scan the returned addresses, skipping any that are IPv6 */
3437
3438         while ((res = string_nextinlist(&ptr, &ipsep, ip, sizeof(ip))) != NULL)
3439           {
3440           if (host_aton(ip, address) != 1) continue;
3441           if ((address[0] & mask) == address[0]) break;
3442           }
3443         }
3444
3445       /* If either
3446
3447          (a) An IP address in an any ('=') list matched, or
3448          (b) No IP address in an all ('==') list matched
3449
3450       then we're done searching. */
3451
3452       if (((match_type & MT_ALL) != 0) == (res == NULL)) break;
3453       }
3454
3455     /* If da == NULL, either
3456
3457        (a) No IP address in an any ('=') list matched, or
3458        (b) An IP address in an all ('==') list didn't match
3459
3460     so behave as if the DNSBL lookup had not succeeded, i.e. the host is not on
3461     the list. */
3462
3463     if ((match_type == MT_NOT || match_type == MT_ALL) != (da == NULL))
3464       {
3465       HDEBUG(D_dnsbl)
3466         {
3467         uschar *res = NULL;
3468         switch(match_type)
3469           {
3470           case 0:
3471           res = US"was no match";
3472           break;
3473           case MT_NOT:
3474           res = US"was an exclude match";
3475           break;
3476           case MT_ALL:
3477           res = US"was an IP address that did not match";
3478           break;
3479           case MT_NOT|MT_ALL:
3480           res = US"were no IP addresses that did not match";
3481           break;
3482           }
3483         debug_printf("=> but we are not accepting this block class because\n");
3484         debug_printf("=> there %s for %s%c%s\n",
3485           res,
3486           ((match_type & MT_ALL) == 0)? "" : "=",
3487           bitmask? '&' : '=', iplist);
3488         }
3489       return FAIL;
3490       }
3491     }
3492
3493   /* Either there was no IP list, or the record matched, implying that the
3494   domain is on the list. We now want to find a corresponding TXT record. If an
3495   alternate domain is specified for the TXT record, call this function
3496   recursively to look that up; this has the side effect of re-checking that
3497   there is indeed an A record at the alternate domain. */
3498
3499   if (domain_txt != domain)
3500     return one_check_dnsbl(domain_txt, domain_txt, keydomain, prepend, NULL,
3501       FALSE, match_type, defer_return);
3502
3503   /* If there is no alternate domain, look up a TXT record in the main domain
3504   if it has not previously been cached. */
3505
3506   if (!cb->text_set)
3507     {
3508     cb->text_set = TRUE;
3509     if (dns_basic_lookup(&dnsa, query, T_TXT) == DNS_SUCCEED)
3510       {
3511       dns_record *rr;
3512       for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
3513            rr != NULL;
3514            rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
3515         if (rr->type == T_TXT) break;
3516       if (rr != NULL)
3517         {
3518         int len = (rr->data)[0];
3519         if (len > 511) len = 127;
3520         store_pool = POOL_PERM;
3521         cb->text = string_sprintf("%.*s", len, (const uschar *)(rr->data+1));
3522         store_pool = old_pool;
3523         }
3524       }
3525     }
3526
3527   dnslist_value = addlist;
3528   dnslist_text = cb->text;
3529   return OK;
3530   }
3531
3532 /* There was a problem with the DNS lookup */
3533
3534 if (cb->rc != DNS_NOMATCH && cb->rc != DNS_NODATA)
3535   {
3536   log_write(L_dnslist_defer, LOG_MAIN,
3537     "DNS list lookup defer (probably timeout) for %s: %s", query,
3538     (defer_return == OK)?   US"assumed in list" :
3539     (defer_return == FAIL)? US"assumed not in list" :
3540                             US"returned DEFER");
3541   return defer_return;
3542   }
3543
3544 /* No entry was found in the DNS; continue for next domain */
3545
3546 HDEBUG(D_dnsbl)
3547   {
3548   debug_printf("DNS lookup for %s failed\n", query);
3549   debug_printf("=> that means %s is not listed at %s\n",
3550      keydomain, domain);
3551   }
3552
3553 return FAIL;
3554 }
3555
3556
3557
3558
3559 /*************************************************
3560 *        Check host against DNS black lists      *
3561 *************************************************/
3562
3563 /* This function runs checks against a list of DNS black lists, until one
3564 matches. Each item on the list can be of the form
3565
3566   domain=ip-address/key
3567
3568 The domain is the right-most domain that is used for the query, for example,
3569 blackholes.mail-abuse.org. If the IP address is present, there is a match only
3570 if the DNS lookup returns a matching IP address. Several addresses may be
3571 given, comma-separated, for example: x.y.z=127.0.0.1,127.0.0.2.
3572
3573 If no key is given, what is looked up in the domain is the inverted IP address
3574 of the current client host. If a key is given, it is used to construct the
3575 domain for the lookup. For example:
3576
3577   dsn.rfc-ignorant.org/$sender_address_domain
3578
3579 After finding a match in the DNS, the domain is placed in $dnslist_domain, and
3580 then we check for a TXT record for an error message, and if found, save its
3581 value in $dnslist_text. We also cache everything in a tree, to optimize
3582 multiple lookups.
3583
3584 The TXT record is normally looked up in the same domain as the A record, but
3585 when many lists are combined in a single DNS domain, this will not be a very
3586 specific message. It is possible to specify a different domain for looking up
3587 TXT records; this is given before the main domain, comma-separated. For
3588 example:
3589
3590   dnslists = http.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.2 : \
3591              socks.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.3
3592
3593 The caching ensures that only one lookup in dnsbl.sorbs.net is done.
3594
3595 Note: an address for testing RBL is 192.203.178.39
3596 Note: an address for testing DUL is 192.203.178.4
3597 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
3598
3599 Arguments:
3600   listptr      the domain/address/data list
3601
3602 Returns:    OK      successful lookup (i.e. the address is on the list), or
3603                       lookup deferred after +include_unknown
3604             FAIL    name not found, or no data found for the given type, or
3605                       lookup deferred after +exclude_unknown (default)
3606             DEFER   lookup failure, if +defer_unknown was set
3607 */
3608
3609 int
3610 verify_check_dnsbl(uschar **listptr)
3611 {
3612 int sep = 0;
3613 int defer_return = FAIL;
3614 uschar *list = *listptr;
3615 uschar *domain;
3616 uschar *s;
3617 uschar buffer[1024];
3618 uschar revadd[128];        /* Long enough for IPv6 address */
3619
3620 /* Indicate that the inverted IP address is not yet set up */
3621
3622 revadd[0] = 0;
3623
3624 /* In case this is the first time the DNS resolver is being used. */
3625
3626 dns_init(FALSE, FALSE, FALSE);  /*XXX dnssec? */
3627
3628 /* Loop through all the domains supplied, until something matches */
3629
3630 while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
3631   {
3632   int rc;
3633   BOOL bitmask = FALSE;
3634   int match_type = 0;
3635   uschar *domain_txt;
3636   uschar *comma;
3637   uschar *iplist;
3638   uschar *key;
3639
3640   HDEBUG(D_dnsbl) debug_printf("DNS list check: %s\n", domain);
3641
3642   /* Deal with special values that change the behaviour on defer */
3643
3644   if (domain[0] == '+')
3645     {
3646     if      (strcmpic(domain, US"+include_unknown") == 0) defer_return = OK;
3647     else if (strcmpic(domain, US"+exclude_unknown") == 0) defer_return = FAIL;
3648     else if (strcmpic(domain, US"+defer_unknown") == 0)   defer_return = DEFER;
3649     else
3650       log_write(0, LOG_MAIN|LOG_PANIC, "unknown item in dnslist (ignored): %s",
3651         domain);
3652     continue;
3653     }
3654
3655   /* See if there's explicit data to be looked up */
3656
3657   key = Ustrchr(domain, '/');
3658   if (key != NULL) *key++ = 0;
3659
3660   /* See if there's a list of addresses supplied after the domain name. This is
3661   introduced by an = or a & character; if preceded by = we require all matches
3662   and if preceded by ! we invert the result. */
3663
3664   iplist = Ustrchr(domain, '=');
3665   if (iplist == NULL)
3666     {
3667     bitmask = TRUE;
3668     iplist = Ustrchr(domain, '&');
3669     }
3670
3671   if (iplist != NULL)                          /* Found either = or & */
3672     {
3673     if (iplist > domain && iplist[-1] == '!')  /* Handle preceding ! */
3674       {
3675       match_type |= MT_NOT;
3676       iplist[-1] = 0;
3677       }
3678
3679     *iplist++ = 0;                             /* Terminate domain, move on */
3680
3681     /* If we found = (bitmask == FALSE), check for == or =& */
3682
3683     if (!bitmask && (*iplist == '=' || *iplist == '&'))
3684       {
3685       bitmask = *iplist++ == '&';
3686       match_type |= MT_ALL;
3687       }
3688     }
3689
3690   /* If there is a comma in the domain, it indicates that a second domain for
3691   looking up TXT records is provided, before the main domain. Otherwise we must
3692   set domain_txt == domain. */
3693
3694   domain_txt = domain;
3695   comma = Ustrchr(domain, ',');
3696   if (comma != NULL)
3697     {
3698     *comma++ = 0;
3699     domain = comma;
3700     }
3701
3702   /* Check that what we have left is a sensible domain name. There is no reason
3703   why these domains should in fact use the same syntax as hosts and email
3704   domains, but in practice they seem to. However, there is little point in
3705   actually causing an error here, because that would no doubt hold up incoming
3706   mail. Instead, I'll just log it. */
3707
3708   for (s = domain; *s != 0; s++)
3709     {
3710     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3711       {
3712       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3713         "strange characters - is this right?", domain);
3714       break;
3715       }
3716     }
3717
3718   /* Check the alternate domain if present */
3719
3720   if (domain_txt != domain) for (s = domain_txt; *s != 0; s++)
3721     {
3722     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3723       {
3724       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3725         "strange characters - is this right?", domain_txt);
3726       break;
3727       }
3728     }
3729
3730   /* If there is no key string, construct the query by adding the domain name
3731   onto the inverted host address, and perform a single DNS lookup. */
3732
3733   if (key == NULL)
3734     {
3735     if (sender_host_address == NULL) return FAIL;    /* can never match */
3736     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
3737     rc = one_check_dnsbl(domain, domain_txt, sender_host_address, revadd,
3738       iplist, bitmask, match_type, defer_return);
3739     if (rc == OK)
3740       {
3741       dnslist_domain = string_copy(domain_txt);
3742       dnslist_matched = string_copy(sender_host_address);
3743       HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3744         sender_host_address, dnslist_domain);
3745       }
3746     if (rc != FAIL) return rc;     /* OK or DEFER */
3747     }
3748
3749   /* If there is a key string, it can be a list of domains or IP addresses to
3750   be concatenated with the main domain. */
3751
3752   else
3753     {
3754     int keysep = 0;
3755     BOOL defer = FALSE;
3756     uschar *keydomain;
3757     uschar keybuffer[256];
3758     uschar keyrevadd[128];
3759
3760     while ((keydomain = string_nextinlist(&key, &keysep, keybuffer,
3761             sizeof(keybuffer))) != NULL)
3762       {
3763       uschar *prepend = keydomain;
3764
3765       if (string_is_ip_address(keydomain, NULL) != 0)
3766         {
3767         invert_address(keyrevadd, keydomain);
3768         prepend = keyrevadd;
3769         }
3770
3771       rc = one_check_dnsbl(domain, domain_txt, keydomain, prepend, iplist,
3772         bitmask, match_type, defer_return);
3773
3774       if (rc == OK)
3775         {
3776         dnslist_domain = string_copy(domain_txt);
3777         dnslist_matched = string_copy(keydomain);
3778         HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3779           keydomain, dnslist_domain);
3780         return OK;
3781         }
3782
3783       /* If the lookup deferred, remember this fact. We keep trying the rest
3784       of the list to see if we get a useful result, and if we don't, we return
3785       DEFER at the end. */
3786
3787       if (rc == DEFER) defer = TRUE;
3788       }    /* continue with next keystring domain/address */
3789
3790     if (defer) return DEFER;
3791     }
3792   }        /* continue with next dnsdb outer domain */
3793
3794 return FAIL;
3795 }
3796
3797 /* vi: aw ai sw=2
3798 */
3799 /* End of verify.c */