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