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