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