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