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