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