src/src/verify.c

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