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