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