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