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