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