Refactor authenticators API to take an (opaque) smtp connection context
[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(&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 if (ip_connect(ident_conn_ctx.sock, host_af, sender_host_address, port,
2749                 rfc1413_query_timeout, &early_data) < 0)
2750   {
2751   if (errno == ETIMEDOUT && LOGGING(ident_timeout))
2752     log_write(0, LOG_MAIN, "ident connection to %s timed out",
2753       sender_host_address);
2754   else
2755     DEBUG(D_ident) debug_printf("ident connection to %s failed: %s\n",
2756       sender_host_address, strerror(errno));
2757   goto END_OFF;
2758   }
2759
2760 /* Read a response line. We put it into the rest of the buffer, using several
2761 recv() calls if necessary. */
2762
2763 p = buffer + qlen;
2764
2765 for (;;)
2766   {
2767   uschar *pp;
2768   int count;
2769   int size = sizeof(buffer) - (p - buffer);
2770
2771   if (size <= 0) goto END_OFF;   /* Buffer filled without seeing \n. */
2772   count = ip_recv(&ident_conn_ctx, p, size, rfc1413_query_timeout);
2773   if (count <= 0) goto END_OFF;  /* Read error or EOF */
2774
2775   /* Scan what we just read, to see if we have reached the terminating \r\n. Be
2776   generous, and accept a plain \n terminator as well. The only illegal
2777   character is 0. */
2778
2779   for (pp = p; pp < p + count; pp++)
2780     {
2781     if (*pp == 0) goto END_OFF;   /* Zero octet not allowed */
2782     if (*pp == '\n')
2783       {
2784       if (pp[-1] == '\r') pp--;
2785       *pp = 0;
2786       goto GOT_DATA;             /* Break out of both loops */
2787       }
2788     }
2789
2790   /* Reached the end of the data without finding \n. Let the loop continue to
2791   read some more, if there is room. */
2792
2793   p = pp;
2794   }
2795
2796 GOT_DATA:
2797
2798 /* We have received a line of data. Check it carefully. It must start with the
2799 same two port numbers that we sent, followed by data as defined by the RFC. For
2800 example,
2801
2802   12345 , 25 : USERID : UNIX :root
2803
2804 However, the amount of white space may be different to what we sent. In the
2805 "osname" field there may be several sub-fields, comma separated. The data we
2806 actually want to save follows the third colon. Some systems put leading spaces
2807 in it - we discard those. */
2808
2809 if (sscanf(CS buffer + qlen, "%d , %d%n", &received_sender_port,
2810       &received_interface_port, &n) != 2 ||
2811     received_sender_port != sender_host_port ||
2812     received_interface_port != interface_port)
2813   goto END_OFF;
2814
2815 p = buffer + qlen + n;
2816 while(isspace(*p)) p++;
2817 if (*p++ != ':') goto END_OFF;
2818 while(isspace(*p)) p++;
2819 if (Ustrncmp(p, "USERID", 6) != 0) goto END_OFF;
2820 p += 6;
2821 while(isspace(*p)) p++;
2822 if (*p++ != ':') goto END_OFF;
2823 while (*p != 0 && *p != ':') p++;
2824 if (*p++ == 0) goto END_OFF;
2825 while(isspace(*p)) p++;
2826 if (*p == 0) goto END_OFF;
2827
2828 /* The rest of the line is the data we want. We turn it into printing
2829 characters when we save it, so that it cannot mess up the format of any logging
2830 or Received: lines into which it gets inserted. We keep a maximum of 127
2831 characters. The deconst cast is ok as we fed a nonconst to string_printing() */
2832
2833 sender_ident = US string_printing(string_copyn(p, 127));
2834 DEBUG(D_ident) debug_printf("sender_ident = %s\n", sender_ident);
2835
2836 END_OFF:
2837 (void)close(ident_conn_ctx.sock);
2838 return;
2839 }
2840
2841
2842
2843
2844 /*************************************************
2845 *      Match host to a single host-list item     *
2846 *************************************************/
2847
2848 /* This function compares a host (name or address) against a single item
2849 from a host list. The host name gets looked up if it is needed and is not
2850 already known. The function is called from verify_check_this_host() via
2851 match_check_list(), which is why most of its arguments are in a single block.
2852
2853 Arguments:
2854   arg            the argument block (see below)
2855   ss             the host-list item
2856   valueptr       where to pass back looked up data, or NULL
2857   error          for error message when returning ERROR
2858
2859 The block contains:
2860   host_name      (a) the host name, or
2861                  (b) NULL, implying use sender_host_name and
2862                        sender_host_aliases, looking them up if required, or
2863                  (c) the empty string, meaning that only IP address matches
2864                        are permitted
2865   host_address   the host address
2866   host_ipv4      the IPv4 address taken from an IPv6 one
2867
2868 Returns:         OK      matched
2869                  FAIL    did not match
2870                  DEFER   lookup deferred
2871                  ERROR   (a) failed to find the host name or IP address, or
2872                          (b) unknown lookup type specified, or
2873                          (c) host name encountered when only IP addresses are
2874                                being matched
2875 */
2876
2877 int
2878 check_host(void *arg, const uschar *ss, const uschar **valueptr, uschar **error)
2879 {
2880 check_host_block *cb = (check_host_block *)arg;
2881 int mlen = -1;
2882 int maskoffset;
2883 BOOL iplookup = FALSE;
2884 BOOL isquery = FALSE;
2885 BOOL isiponly = cb->host_name != NULL && cb->host_name[0] == 0;
2886 const uschar *t;
2887 uschar *semicolon;
2888 uschar **aliases;
2889
2890 /* Optimize for the special case when the pattern is "*". */
2891
2892 if (*ss == '*' && ss[1] == 0) return OK;
2893
2894 /* If the pattern is empty, it matches only in the case when there is no host -
2895 this can occur in ACL checking for SMTP input using the -bs option. In this
2896 situation, the host address is the empty string. */
2897
2898 if (cb->host_address[0] == 0) return (*ss == 0)? OK : FAIL;
2899 if (*ss == 0) return FAIL;
2900
2901 /* If the pattern is precisely "@" then match against the primary host name,
2902 provided that host name matching is permitted; if it's "@[]" match against the
2903 local host's IP addresses. */
2904
2905 if (*ss == '@')
2906   {
2907   if (ss[1] == 0)
2908     {
2909     if (isiponly) return ERROR;
2910     ss = primary_hostname;
2911     }
2912   else if (Ustrcmp(ss, "@[]") == 0)
2913     {
2914     ip_address_item *ip;
2915     for (ip = host_find_interfaces(); ip != NULL; ip = ip->next)
2916       if (Ustrcmp(ip->address, cb->host_address) == 0) return OK;
2917     return FAIL;
2918     }
2919   }
2920
2921 /* If the pattern is an IP address, optionally followed by a bitmask count, do
2922 a (possibly masked) comparison with the current IP address. */
2923
2924 if (string_is_ip_address(ss, &maskoffset) != 0)
2925   return (host_is_in_net(cb->host_address, ss, maskoffset)? OK : FAIL);
2926
2927 /* The pattern is not an IP address. A common error that people make is to omit
2928 one component of an IPv4 address, either by accident, or believing that, for
2929 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,
2930 which it isn't. (Those applications that do accept 1.2.3 as an IP address
2931 interpret it as 1.2.0.3 because the final component becomes 16-bit - this is an
2932 ancient specification.) To aid in debugging these cases, we give a specific
2933 error if the pattern contains only digits and dots or contains a slash preceded
2934 only by digits and dots (a slash at the start indicates a file name and of
2935 course slashes may be present in lookups, but not preceded only by digits and
2936 dots). */
2937
2938 for (t = ss; isdigit(*t) || *t == '.'; t++);
2939 if (*t == 0 || (*t == '/' && t != ss))
2940   {
2941   *error = US"malformed IPv4 address or address mask";
2942   return ERROR;
2943   }
2944
2945 /* See if there is a semicolon in the pattern */
2946
2947 semicolon = Ustrchr(ss, ';');
2948
2949 /* If we are doing an IP address only match, then all lookups must be IP
2950 address lookups, even if there is no "net-". */
2951
2952 if (isiponly)
2953   {
2954   iplookup = semicolon != NULL;
2955   }
2956
2957 /* Otherwise, if the item is of the form net[n]-lookup;<file|query> then it is
2958 a lookup on a masked IP network, in textual form. We obey this code even if we
2959 have already set iplookup, so as to skip over the "net-" prefix and to set the
2960 mask length. The net- stuff really only applies to single-key lookups where the
2961 key is implicit. For query-style lookups the key is specified in the query.
2962 From release 4.30, the use of net- for query style is no longer needed, but we
2963 retain it for backward compatibility. */
2964
2965 if (Ustrncmp(ss, "net", 3) == 0 && semicolon != NULL)
2966   {
2967   mlen = 0;
2968   for (t = ss + 3; isdigit(*t); t++) mlen = mlen * 10 + *t - '0';
2969   if (mlen == 0 && t == ss+3) mlen = -1;  /* No mask supplied */
2970   iplookup = (*t++ == '-');
2971   }
2972 else t = ss;
2973
2974 /* Do the IP address lookup if that is indeed what we have */
2975
2976 if (iplookup)
2977   {
2978   int insize;
2979   int search_type;
2980   int incoming[4];
2981   void *handle;
2982   uschar *filename, *key, *result;
2983   uschar buffer[64];
2984
2985   /* Find the search type */
2986
2987   search_type = search_findtype(t, semicolon - t);
2988
2989   if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
2990     search_error_message);
2991
2992   /* Adjust parameters for the type of lookup. For a query-style lookup, there
2993   is no file name, and the "key" is just the query. For query-style with a file
2994   name, we have to fish the file off the start of the query. For a single-key
2995   lookup, the key is the current IP address, masked appropriately, and
2996   reconverted to text form, with the mask appended. For IPv6 addresses, specify
2997   dot separators instead of colons, except when the lookup type is "iplsearch".
2998   */
2999
3000   if (mac_islookup(search_type, lookup_absfilequery))
3001     {
3002     filename = semicolon + 1;
3003     key = filename;
3004     while (*key != 0 && !isspace(*key)) key++;
3005     filename = string_copyn(filename, key - filename);
3006     while (isspace(*key)) key++;
3007     }
3008   else if (mac_islookup(search_type, lookup_querystyle))
3009     {
3010     filename = NULL;
3011     key = semicolon + 1;
3012     }
3013   else   /* Single-key style */
3014     {
3015     int sep = (Ustrcmp(lookup_list[search_type]->name, "iplsearch") == 0)?
3016       ':' : '.';
3017     insize = host_aton(cb->host_address, incoming);
3018     host_mask(insize, incoming, mlen);
3019     (void)host_nmtoa(insize, incoming, mlen, buffer, sep);
3020     key = buffer;
3021     filename = semicolon + 1;
3022     }
3023
3024   /* Now do the actual lookup; note that there is no search_close() because
3025   of the caching arrangements. */
3026
3027   if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
3028     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
3029
3030   result = search_find(handle, filename, key, -1, NULL, 0, 0, NULL);
3031   if (valueptr) *valueptr = result;
3032   return result ? OK : f.search_find_defer ? DEFER: FAIL;
3033   }
3034
3035 /* The pattern is not an IP address or network reference of any kind. That is,
3036 it is a host name pattern. If this is an IP only match, there's an error in the
3037 host list. */
3038
3039 if (isiponly)
3040   {
3041   *error = US"cannot match host name in match_ip list";
3042   return ERROR;
3043   }
3044
3045 /* Check the characters of the pattern to see if they comprise only letters,
3046 digits, full stops, and hyphens (the constituents of domain names). Allow
3047 underscores, as they are all too commonly found. Sigh. Also, if
3048 allow_utf8_domains is set, allow top-bit characters. */
3049
3050 for (t = ss; *t != 0; t++)
3051   if (!isalnum(*t) && *t != '.' && *t != '-' && *t != '_' &&
3052       (!allow_utf8_domains || *t < 128)) break;
3053
3054 /* If the pattern is a complete domain name, with no fancy characters, look up
3055 its IP address and match against that. Note that a multi-homed host will add
3056 items to the chain. */
3057
3058 if (*t == 0)
3059   {
3060   int rc;
3061   host_item h;
3062   h.next = NULL;
3063   h.name = ss;
3064   h.address = NULL;
3065   h.mx = MX_NONE;
3066
3067   /* Using byname rather than bydns here means we cannot determine dnssec
3068   status.  On the other hand it is unclear how that could be either
3069   propagated up or enforced. */
3070
3071   rc = host_find_byname(&h, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, FALSE);
3072   if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
3073     {
3074     host_item *hh;
3075     for (hh = &h; hh != NULL; hh = hh->next)
3076       {
3077       if (host_is_in_net(hh->address, cb->host_address, 0)) return OK;
3078       }
3079     return FAIL;
3080     }
3081   if (rc == HOST_FIND_AGAIN) return DEFER;
3082   *error = string_sprintf("failed to find IP address for %s", ss);
3083   return ERROR;
3084   }
3085
3086 /* Almost all subsequent comparisons require the host name, and can be done
3087 using the general string matching function. When this function is called for
3088 outgoing hosts, the name is always given explicitly. If it is NULL, it means we
3089 must use sender_host_name and its aliases, looking them up if necessary. */
3090
3091 if (cb->host_name != NULL)   /* Explicit host name given */
3092   return match_check_string(cb->host_name, ss, -1, TRUE, TRUE, TRUE,
3093     valueptr);
3094
3095 /* Host name not given; in principle we need the sender host name and its
3096 aliases. However, for query-style lookups, we do not need the name if the
3097 query does not contain $sender_host_name. From release 4.23, a reference to
3098 $sender_host_name causes it to be looked up, so we don't need to do the lookup
3099 on spec. */
3100
3101 if ((semicolon = Ustrchr(ss, ';')) != NULL)
3102   {
3103   const uschar *affix;
3104   int partial, affixlen, starflags, id;
3105
3106   *semicolon = 0;
3107   id = search_findtype_partial(ss, &partial, &affix, &affixlen, &starflags);
3108   *semicolon=';';
3109
3110   if (id < 0)                           /* Unknown lookup type */
3111     {
3112     log_write(0, LOG_MAIN|LOG_PANIC, "%s in host list item \"%s\"",
3113       search_error_message, ss);
3114     return DEFER;
3115     }
3116   isquery = mac_islookup(id, lookup_querystyle|lookup_absfilequery);
3117   }
3118
3119 if (isquery)
3120   {
3121   switch(match_check_string(US"", ss, -1, TRUE, TRUE, TRUE, valueptr))
3122     {
3123     case OK:    return OK;
3124     case DEFER: return DEFER;
3125     default:    return FAIL;
3126     }
3127   }
3128
3129 /* Not a query-style lookup; must ensure the host name is present, and then we
3130 do a check on the name and all its aliases. */
3131
3132 if (!sender_host_name)
3133   {
3134   HDEBUG(D_host_lookup)
3135     debug_printf("sender host name required, to match against %s\n", ss);
3136   if (host_lookup_failed || host_name_lookup() != OK)
3137     {
3138     *error = string_sprintf("failed to find host name for %s",
3139       sender_host_address);;
3140     return ERROR;
3141     }
3142   host_build_sender_fullhost();
3143   }
3144
3145 /* Match on the sender host name, using the general matching function */
3146
3147 switch(match_check_string(sender_host_name, ss, -1, TRUE, TRUE, TRUE, valueptr))
3148   {
3149   case OK:    return OK;
3150   case DEFER: return DEFER;
3151   }
3152
3153 /* If there are aliases, try matching on them. */
3154
3155 aliases = sender_host_aliases;
3156 while (*aliases)
3157   switch(match_check_string(*aliases++, ss, -1, TRUE, TRUE, TRUE, valueptr))
3158     {
3159     case OK:    return OK;
3160     case DEFER: return DEFER;
3161     }
3162 return FAIL;
3163 }
3164
3165
3166
3167
3168 /*************************************************
3169 *    Check a specific host matches a host list   *
3170 *************************************************/
3171
3172 /* This function is passed a host list containing items in a number of
3173 different formats and the identity of a host. Its job is to determine whether
3174 the given host is in the set of hosts defined by the list. The host name is
3175 passed as a pointer so that it can be looked up if needed and not already
3176 known. This is commonly the case when called from verify_check_host() to check
3177 an incoming connection. When called from elsewhere the host name should usually
3178 be set.
3179
3180 This function is now just a front end to match_check_list(), which runs common
3181 code for scanning a list. We pass it the check_host() function to perform a
3182 single test.
3183
3184 Arguments:
3185   listptr              pointer to the host list
3186   cache_bits           pointer to cache for named lists, or NULL
3187   host_name            the host name or NULL, implying use sender_host_name and
3188                          sender_host_aliases, looking them up if required
3189   host_address         the IP address
3190   valueptr             if not NULL, data from a lookup is passed back here
3191
3192 Returns:    OK    if the host is in the defined set
3193             FAIL  if the host is not in the defined set,
3194             DEFER if a data lookup deferred (not a host lookup)
3195
3196 If the host name was needed in order to make a comparison, and could not be
3197 determined from the IP address, the result is FAIL unless the item
3198 "+allow_unknown" was met earlier in the list, in which case OK is returned. */
3199
3200 int
3201 verify_check_this_host(const uschar **listptr, unsigned int *cache_bits,
3202   const uschar *host_name, const uschar *host_address, const uschar **valueptr)
3203 {
3204 int rc;
3205 unsigned int *local_cache_bits = cache_bits;
3206 const uschar *save_host_address = deliver_host_address;
3207 check_host_block cb = { .host_name = host_name, .host_address = host_address };
3208
3209 if (valueptr) *valueptr = NULL;
3210
3211 /* If the host address starts off ::ffff: it is an IPv6 address in
3212 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
3213 addresses. */
3214
3215 cb.host_ipv4 = Ustrncmp(host_address, "::ffff:", 7) == 0
3216   ? host_address + 7 : host_address;
3217
3218 /* During the running of the check, put the IP address into $host_address. In
3219 the case of calls from the smtp transport, it will already be there. However,
3220 in other calls (e.g. when testing ignore_target_hosts), it won't. Just to be on
3221 the safe side, any existing setting is preserved, though as I write this
3222 (November 2004) I can't see any cases where it is actually needed. */
3223
3224 deliver_host_address = host_address;
3225 rc = match_check_list(
3226        listptr,                                /* the list */
3227        0,                                      /* separator character */
3228        &hostlist_anchor,                       /* anchor pointer */
3229        &local_cache_bits,                      /* cache pointer */
3230        check_host,                             /* function for testing */
3231        &cb,                                    /* argument for function */
3232        MCL_HOST,                               /* type of check */
3233        (host_address == sender_host_address)?
3234          US"host" : host_address,              /* text for debugging */
3235        valueptr);                              /* where to pass back data */
3236 deliver_host_address = save_host_address;
3237 return rc;
3238 }
3239
3240
3241
3242
3243 /*************************************************
3244 *      Check the given host item matches a list  *
3245 *************************************************/
3246 int
3247 verify_check_given_host(uschar **listptr, host_item *host)
3248 {
3249 return verify_check_this_host(CUSS listptr, NULL, host->name, host->address, NULL);
3250 }
3251
3252 /*************************************************
3253 *      Check the remote host matches a list      *
3254 *************************************************/
3255
3256 /* This is a front end to verify_check_this_host(), created because checking
3257 the remote host is a common occurrence. With luck, a good compiler will spot
3258 the tail recursion and optimize it. If there's no host address, this is
3259 command-line SMTP input - check against an empty string for the address.
3260
3261 Arguments:
3262   listptr              pointer to the host list
3263
3264 Returns:               the yield of verify_check_this_host(),
3265                        i.e. OK, FAIL, or DEFER
3266 */
3267
3268 int
3269 verify_check_host(uschar **listptr)
3270 {
3271 return verify_check_this_host(CUSS listptr, sender_host_cache, NULL,
3272   (sender_host_address == NULL)? US"" : sender_host_address, NULL);
3273 }
3274
3275
3276
3277
3278
3279 /*************************************************
3280 *              Invert an IP address              *
3281 *************************************************/
3282
3283 /* Originally just used for DNS xBL lists, now also used for the
3284 reverse_ip expansion operator.
3285
3286 Arguments:
3287   buffer         where to put the answer
3288   address        the address to invert
3289 */
3290
3291 void
3292 invert_address(uschar *buffer, uschar *address)
3293 {
3294 int bin[4];
3295 uschar *bptr = buffer;
3296
3297 /* If this is an IPv4 address mapped into IPv6 format, adjust the pointer
3298 to the IPv4 part only. */
3299
3300 if (Ustrncmp(address, "::ffff:", 7) == 0) address += 7;
3301
3302 /* Handle IPv4 address: when HAVE_IPV6 is false, the result of host_aton() is
3303 always 1. */
3304
3305 if (host_aton(address, bin) == 1)
3306   {
3307   int i;
3308   int x = bin[0];
3309   for (i = 0; i < 4; i++)
3310     {
3311     sprintf(CS bptr, "%d.", x & 255);
3312     while (*bptr) bptr++;
3313     x >>= 8;
3314     }
3315   }
3316
3317 /* Handle IPv6 address. Actually, as far as I know, there are no IPv6 addresses
3318 in any DNS black lists, and the format in which they will be looked up is
3319 unknown. This is just a guess. */
3320
3321 #if HAVE_IPV6
3322 else
3323   {
3324   int i, j;
3325   for (j = 3; j >= 0; j--)
3326     {
3327     int x = bin[j];
3328     for (i = 0; i < 8; i++)
3329       {
3330       sprintf(CS bptr, "%x.", x & 15);
3331       while (*bptr) bptr++;
3332       x >>= 4;
3333       }
3334     }
3335   }
3336 #endif
3337
3338 /* Remove trailing period -- this is needed so that both arbitrary
3339 dnsbl keydomains and inverted addresses may be combined with the
3340 same format string, "%s.%s" */
3341
3342 *(--bptr) = 0;
3343 }
3344
3345
3346
3347 /*************************************************
3348 *          Perform a single dnsbl lookup         *
3349 *************************************************/
3350
3351 /* This function is called from verify_check_dnsbl() below. It is also called
3352 recursively from within itself when domain and domain_txt are different
3353 pointers, in order to get the TXT record from the alternate domain.
3354
3355 Arguments:
3356   domain         the outer dnsbl domain
3357   domain_txt     alternate domain to lookup TXT record on success; when the
3358                    same domain is to be used, domain_txt == domain (that is,
3359                    the pointers must be identical, not just the text)
3360   keydomain      the current keydomain (for debug message)
3361   prepend        subdomain to lookup (like keydomain, but
3362                    reversed if IP address)
3363   iplist         the list of matching IP addresses, or NULL for "any"
3364   bitmask        true if bitmask matching is wanted
3365   match_type     condition for 'succeed' result
3366                    0 => Any RR in iplist     (=)
3367                    1 => No RR in iplist      (!=)
3368                    2 => All RRs in iplist    (==)
3369                    3 => Some RRs not in iplist (!==)
3370                    the two bits are defined as MT_NOT and MT_ALL
3371   defer_return   what to return for a defer
3372
3373 Returns:         OK if lookup succeeded
3374                  FAIL if not
3375 */
3376
3377 static int
3378 one_check_dnsbl(uschar *domain, uschar *domain_txt, uschar *keydomain,
3379   uschar *prepend, uschar *iplist, BOOL bitmask, int match_type,
3380   int defer_return)
3381 {
3382 dns_answer dnsa;
3383 dns_scan dnss;
3384 tree_node *t;
3385 dnsbl_cache_block *cb;
3386 int old_pool = store_pool;
3387 uschar query[256];         /* DNS domain max length */
3388
3389 /* Construct the specific query domainname */
3390
3391 if (!string_format(query, sizeof(query), "%s.%s", prepend, domain))
3392   {
3393   log_write(0, LOG_MAIN|LOG_PANIC, "dnslist query is too long "
3394     "(ignored): %s...", query);
3395   return FAIL;
3396   }
3397
3398 /* Look for this query in the cache. */
3399
3400 if (  (t = tree_search(dnsbl_cache, query))
3401    && (cb = t->data.ptr)->expiry > time(NULL)
3402    )
3403
3404 /* Previous lookup was cached */
3405
3406   {
3407   HDEBUG(D_dnsbl) debug_printf("using result of previous DNS lookup\n");
3408   }
3409
3410 /* If not cached from a previous lookup, we must do a DNS lookup, and
3411 cache the result in permanent memory. */
3412
3413 else
3414   {
3415   uint ttl = 3600;
3416
3417   store_pool = POOL_PERM;
3418
3419   if (t)
3420     {
3421     HDEBUG(D_dnsbl) debug_printf("cached data found but past valid time; ");
3422     }
3423
3424   else
3425     {   /* Set up a tree entry to cache the lookup */
3426     t = store_get(sizeof(tree_node) + Ustrlen(query));
3427     Ustrcpy(t->name, query);
3428     t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block));
3429     (void)tree_insertnode(&dnsbl_cache, t);
3430     }
3431
3432   /* Do the DNS lookup . */
3433
3434   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
3435   cb->rc = dns_basic_lookup(&dnsa, query, T_A);
3436   cb->text_set = FALSE;
3437   cb->text = NULL;
3438   cb->rhs = NULL;
3439
3440   /* If the lookup succeeded, cache the RHS address. The code allows for
3441   more than one address - this was for complete generality and the possible
3442   use of A6 records. However, A6 records are no longer supported. Leave the code
3443   here, just in case.
3444
3445   Quite apart from one A6 RR generating multiple addresses, there are DNS
3446   lists that return more than one A record, so we must handle multiple
3447   addresses generated in that way as well.
3448
3449   Mark the cache entry with the "now" plus the minimum of the address TTLs,
3450   or some suitably far-future time if none were found. */
3451
3452   if (cb->rc == DNS_SUCCEED)
3453     {
3454     dns_record *rr;
3455     dns_address **addrp = &(cb->rhs);
3456     for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
3457          rr;
3458          rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
3459       if (rr->type == T_A)
3460         {
3461         dns_address *da = dns_address_from_rr(&dnsa, rr);
3462         if (da)
3463           {
3464           *addrp = da;
3465           while (da->next) da = da->next;
3466           addrp = &da->next;
3467           if (ttl > rr->ttl) ttl = rr->ttl;
3468           }
3469         }
3470
3471     /* If we didn't find any A records, change the return code. This can
3472     happen when there is a CNAME record but there are no A records for what
3473     it points to. */
3474
3475     if (!cb->rhs) cb->rc = DNS_NODATA;
3476     }
3477
3478   cb->expiry = time(NULL)+ttl;
3479   store_pool = old_pool;
3480   }
3481
3482 /* We now have the result of the DNS lookup, either newly done, or cached
3483 from a previous call. If the lookup succeeded, check against the address
3484 list if there is one. This may be a positive equality list (introduced by
3485 "="), a negative equality list (introduced by "!="), a positive bitmask
3486 list (introduced by "&"), or a negative bitmask list (introduced by "!&").*/
3487
3488 if (cb->rc == DNS_SUCCEED)
3489   {
3490   dns_address *da = NULL;
3491   uschar *addlist = cb->rhs->address;
3492
3493   /* For A and AAAA records, there may be multiple addresses from multiple
3494   records. For A6 records (currently not expected to be used) there may be
3495   multiple addresses from a single record. */
3496
3497   for (da = cb->rhs->next; da; da = da->next)
3498     addlist = string_sprintf("%s, %s", addlist, da->address);
3499
3500   HDEBUG(D_dnsbl) debug_printf("DNS lookup for %s succeeded (yielding %s)\n",
3501     query, addlist);
3502
3503   /* Address list check; this can be either for equality, or via a bitmask.
3504   In the latter case, all the bits must match. */
3505
3506   if (iplist)
3507     {
3508     for (da = cb->rhs; da; da = da->next)
3509       {
3510       int ipsep = ',';
3511       uschar ip[46];
3512       const uschar *ptr = iplist;
3513       uschar *res;
3514
3515       /* Handle exact matching */
3516
3517       if (!bitmask)
3518         {
3519         while ((res = string_nextinlist(&ptr, &ipsep, ip, sizeof(ip))))
3520           if (Ustrcmp(CS da->address, ip) == 0)
3521             break;
3522         }
3523
3524       /* Handle bitmask matching */
3525
3526       else
3527         {
3528         int address[4];
3529         int mask = 0;
3530
3531         /* At present, all known DNS blocking lists use A records, with
3532         IPv4 addresses on the RHS encoding the information they return. I
3533         wonder if this will linger on as the last vestige of IPv4 when IPv6
3534         is ubiquitous? Anyway, for now we use paranoia code to completely
3535         ignore IPv6 addresses. The default mask is 0, which always matches.
3536         We change this only for IPv4 addresses in the list. */
3537
3538         if (host_aton(da->address, address) == 1) mask = address[0];
3539
3540         /* Scan the returned addresses, skipping any that are IPv6 */
3541
3542         while ((res = string_nextinlist(&ptr, &ipsep, ip, sizeof(ip))))
3543           {
3544           if (host_aton(ip, address) != 1) continue;
3545           if ((address[0] & mask) == address[0]) break;
3546           }
3547         }
3548
3549       /* If either
3550
3551          (a) An IP address in an any ('=') list matched, or
3552          (b) No IP address in an all ('==') list matched
3553
3554       then we're done searching. */
3555
3556       if (((match_type & MT_ALL) != 0) == (res == NULL)) break;
3557       }
3558
3559     /* If da == NULL, either
3560
3561        (a) No IP address in an any ('=') list matched, or
3562        (b) An IP address in an all ('==') list didn't match
3563
3564     so behave as if the DNSBL lookup had not succeeded, i.e. the host is not on
3565     the list. */
3566
3567     if ((match_type == MT_NOT || match_type == MT_ALL) != (da == NULL))
3568       {
3569       HDEBUG(D_dnsbl)
3570         {
3571         uschar *res = NULL;
3572         switch(match_type)
3573           {
3574           case 0:
3575             res = US"was no match"; break;
3576           case MT_NOT:
3577             res = US"was an exclude match"; break;
3578           case MT_ALL:
3579             res = US"was an IP address that did not match"; break;
3580           case MT_NOT|MT_ALL:
3581             res = US"were no IP addresses that did not match"; break;
3582           }
3583         debug_printf("=> but we are not accepting this block class because\n");
3584         debug_printf("=> there %s for %s%c%s\n",
3585           res,
3586           ((match_type & MT_ALL) == 0)? "" : "=",
3587           bitmask? '&' : '=', iplist);
3588         }
3589       return FAIL;
3590       }
3591     }
3592
3593   /* Either there was no IP list, or the record matched, implying that the
3594   domain is on the list. We now want to find a corresponding TXT record. If an
3595   alternate domain is specified for the TXT record, call this function
3596   recursively to look that up; this has the side effect of re-checking that
3597   there is indeed an A record at the alternate domain. */
3598
3599   if (domain_txt != domain)
3600     return one_check_dnsbl(domain_txt, domain_txt, keydomain, prepend, NULL,
3601       FALSE, match_type, defer_return);
3602
3603   /* If there is no alternate domain, look up a TXT record in the main domain
3604   if it has not previously been cached. */
3605
3606   if (!cb->text_set)
3607     {
3608     cb->text_set = TRUE;
3609     if (dns_basic_lookup(&dnsa, query, T_TXT) == DNS_SUCCEED)
3610       {
3611       dns_record *rr;
3612       for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
3613            rr;
3614            rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
3615         if (rr->type == T_TXT) break;
3616       if (rr)
3617         {
3618         int len = (rr->data)[0];
3619         if (len > 511) len = 127;
3620         store_pool = POOL_PERM;
3621         cb->text = string_sprintf("%.*s", len, CUS (rr->data+1));
3622         store_pool = old_pool;
3623         }
3624       }
3625     }
3626
3627   dnslist_value = addlist;
3628   dnslist_text = cb->text;
3629   return OK;
3630   }
3631
3632 /* There was a problem with the DNS lookup */
3633
3634 if (cb->rc != DNS_NOMATCH && cb->rc != DNS_NODATA)
3635   {
3636   log_write(L_dnslist_defer, LOG_MAIN,
3637     "DNS list lookup defer (probably timeout) for %s: %s", query,
3638     (defer_return == OK)?   US"assumed in list" :
3639     (defer_return == FAIL)? US"assumed not in list" :
3640                             US"returned DEFER");
3641   return defer_return;
3642   }
3643
3644 /* No entry was found in the DNS; continue for next domain */
3645
3646 HDEBUG(D_dnsbl)
3647   {
3648   debug_printf("DNS lookup for %s failed\n", query);
3649   debug_printf("=> that means %s is not listed at %s\n",
3650      keydomain, domain);
3651   }
3652
3653 return FAIL;
3654 }
3655
3656
3657
3658
3659 /*************************************************
3660 *        Check host against DNS black lists      *
3661 *************************************************/
3662
3663 /* This function runs checks against a list of DNS black lists, until one
3664 matches. Each item on the list can be of the form
3665
3666   domain=ip-address/key
3667
3668 The domain is the right-most domain that is used for the query, for example,
3669 blackholes.mail-abuse.org. If the IP address is present, there is a match only
3670 if the DNS lookup returns a matching IP address. Several addresses may be
3671 given, comma-separated, for example: x.y.z=127.0.0.1,127.0.0.2.
3672
3673 If no key is given, what is looked up in the domain is the inverted IP address
3674 of the current client host. If a key is given, it is used to construct the
3675 domain for the lookup. For example:
3676
3677   dsn.rfc-ignorant.org/$sender_address_domain
3678
3679 After finding a match in the DNS, the domain is placed in $dnslist_domain, and
3680 then we check for a TXT record for an error message, and if found, save its
3681 value in $dnslist_text. We also cache everything in a tree, to optimize
3682 multiple lookups.
3683
3684 The TXT record is normally looked up in the same domain as the A record, but
3685 when many lists are combined in a single DNS domain, this will not be a very
3686 specific message. It is possible to specify a different domain for looking up
3687 TXT records; this is given before the main domain, comma-separated. For
3688 example:
3689
3690   dnslists = http.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.2 : \
3691              socks.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.3
3692
3693 The caching ensures that only one lookup in dnsbl.sorbs.net is done.
3694
3695 Note: an address for testing RBL is 192.203.178.39
3696 Note: an address for testing DUL is 192.203.178.4
3697 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
3698
3699 Arguments:
3700   where        the acl type
3701   listptr      the domain/address/data list
3702   log_msgptr   log message on error
3703
3704 Returns:    OK      successful lookup (i.e. the address is on the list), or
3705                       lookup deferred after +include_unknown
3706             FAIL    name not found, or no data found for the given type, or
3707                       lookup deferred after +exclude_unknown (default)
3708             DEFER   lookup failure, if +defer_unknown was set
3709 */
3710
3711 int
3712 verify_check_dnsbl(int where, const uschar ** listptr, uschar ** log_msgptr)
3713 {
3714 int sep = 0;
3715 int defer_return = FAIL;
3716 const uschar *list = *listptr;
3717 uschar *domain;
3718 uschar *s;
3719 uschar buffer[1024];
3720 uschar revadd[128];        /* Long enough for IPv6 address */
3721
3722 /* Indicate that the inverted IP address is not yet set up */
3723
3724 revadd[0] = 0;
3725
3726 /* In case this is the first time the DNS resolver is being used. */
3727
3728 dns_init(FALSE, FALSE, FALSE);  /*XXX dnssec? */
3729
3730 /* Loop through all the domains supplied, until something matches */
3731
3732 while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
3733   {
3734   int rc;
3735   BOOL bitmask = FALSE;
3736   int match_type = 0;
3737   uschar *domain_txt;
3738   uschar *comma;
3739   uschar *iplist;
3740   uschar *key;
3741
3742   HDEBUG(D_dnsbl) debug_printf("DNS list check: %s\n", domain);
3743
3744   /* Deal with special values that change the behaviour on defer */
3745
3746   if (domain[0] == '+')
3747     {
3748     if      (strcmpic(domain, US"+include_unknown") == 0) defer_return = OK;
3749     else if (strcmpic(domain, US"+exclude_unknown") == 0) defer_return = FAIL;
3750     else if (strcmpic(domain, US"+defer_unknown") == 0)   defer_return = DEFER;
3751     else
3752       log_write(0, LOG_MAIN|LOG_PANIC, "unknown item in dnslist (ignored): %s",
3753         domain);
3754     continue;
3755     }
3756
3757   /* See if there's explicit data to be looked up */
3758
3759   if ((key = Ustrchr(domain, '/'))) *key++ = 0;
3760
3761   /* See if there's a list of addresses supplied after the domain name. This is
3762   introduced by an = or a & character; if preceded by = we require all matches
3763   and if preceded by ! we invert the result. */
3764
3765   if (!(iplist = Ustrchr(domain, '=')))
3766     {
3767     bitmask = TRUE;
3768     iplist = Ustrchr(domain, '&');
3769     }
3770
3771   if (iplist)                                  /* Found either = or & */
3772     {
3773     if (iplist > domain && iplist[-1] == '!')  /* Handle preceding ! */
3774       {
3775       match_type |= MT_NOT;
3776       iplist[-1] = 0;
3777       }
3778
3779     *iplist++ = 0;                             /* Terminate domain, move on */
3780
3781     /* If we found = (bitmask == FALSE), check for == or =& */
3782
3783     if (!bitmask && (*iplist == '=' || *iplist == '&'))
3784       {
3785       bitmask = *iplist++ == '&';
3786       match_type |= MT_ALL;
3787       }
3788     }
3789
3790
3791   /* If there is a comma in the domain, it indicates that a second domain for
3792   looking up TXT records is provided, before the main domain. Otherwise we must
3793   set domain_txt == domain. */
3794
3795   domain_txt = domain;
3796   comma = Ustrchr(domain, ',');
3797   if (comma != NULL)
3798     {
3799     *comma++ = 0;
3800     domain = comma;
3801     }
3802
3803   /* Check that what we have left is a sensible domain name. There is no reason
3804   why these domains should in fact use the same syntax as hosts and email
3805   domains, but in practice they seem to. However, there is little point in
3806   actually causing an error here, because that would no doubt hold up incoming
3807   mail. Instead, I'll just log it. */
3808
3809   for (s = domain; *s != 0; s++)
3810     {
3811     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3812       {
3813       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3814         "strange characters - is this right?", domain);
3815       break;
3816       }
3817     }
3818
3819   /* Check the alternate domain if present */
3820
3821   if (domain_txt != domain) for (s = domain_txt; *s != 0; s++)
3822     {
3823     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3824       {
3825       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3826         "strange characters - is this right?", domain_txt);
3827       break;
3828       }
3829     }
3830
3831   /* If there is no key string, construct the query by adding the domain name
3832   onto the inverted host address, and perform a single DNS lookup. */
3833
3834   if (key == NULL)
3835     {
3836     if (where == ACL_WHERE_NOTSMTP_START || where == ACL_WHERE_NOTSMTP)
3837       {
3838       *log_msgptr = string_sprintf
3839         ("cannot test auto-keyed dnslists condition in %s ACL",
3840           acl_wherenames[where]);
3841       return ERROR;
3842       }
3843     if (sender_host_address == NULL) return FAIL;    /* can never match */
3844     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
3845     rc = one_check_dnsbl(domain, domain_txt, sender_host_address, revadd,
3846       iplist, bitmask, match_type, defer_return);
3847     if (rc == OK)
3848       {
3849       dnslist_domain = string_copy(domain_txt);
3850       dnslist_matched = string_copy(sender_host_address);
3851       HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3852         sender_host_address, dnslist_domain);
3853       }
3854     if (rc != FAIL) return rc;     /* OK or DEFER */
3855     }
3856
3857   /* If there is a key string, it can be a list of domains or IP addresses to
3858   be concatenated with the main domain. */
3859
3860   else
3861     {
3862     int keysep = 0;
3863     BOOL defer = FALSE;
3864     uschar *keydomain;
3865     uschar keybuffer[256];
3866     uschar keyrevadd[128];
3867
3868     while ((keydomain = string_nextinlist(CUSS &key, &keysep, keybuffer,
3869             sizeof(keybuffer))) != NULL)
3870       {
3871       uschar *prepend = keydomain;
3872
3873       if (string_is_ip_address(keydomain, NULL) != 0)
3874         {
3875         invert_address(keyrevadd, keydomain);
3876         prepend = keyrevadd;
3877         }
3878
3879       rc = one_check_dnsbl(domain, domain_txt, keydomain, prepend, iplist,
3880         bitmask, match_type, defer_return);
3881
3882       if (rc == OK)
3883         {
3884         dnslist_domain = string_copy(domain_txt);
3885         dnslist_matched = string_copy(keydomain);
3886         HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3887           keydomain, dnslist_domain);
3888         return OK;
3889         }
3890
3891       /* If the lookup deferred, remember this fact. We keep trying the rest
3892       of the list to see if we get a useful result, and if we don't, we return
3893       DEFER at the end. */
3894
3895       if (rc == DEFER) defer = TRUE;
3896       }    /* continue with next keystring domain/address */
3897
3898     if (defer) return DEFER;
3899     }
3900   }        /* continue with next dnsdb outer domain */
3901
3902 return FAIL;
3903 }
3904
3905 /* vi: aw ai sw=2
3906 */
3907 /* End of verify.c */