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