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