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