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