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