591c6c03df74e1011dcae89d980886ea7aa2b3ac
[exim.git] / src / src / verify.c
1 /* $Cambridge: exim/src/src/verify.c,v 1.10 2005/01/11 15:51:02 ph10 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10 /* Functions concerned with verifying things. The original code for callout
11 caching was contributed by Kevin Fleming (but I hacked it around a bit). */
12
13
14 #include "exim.h"
15
16
17 /* Structure for caching DNSBL lookups */
18
19 typedef struct dnsbl_cache_block {
20   dns_address *rhs;
21   uschar *text;
22   int rc;
23   BOOL text_set;
24 } dnsbl_cache_block;
25
26
27 /* Anchor for DNSBL cache */
28
29 static tree_node *dnsbl_cache = NULL;
30
31
32
33 /*************************************************
34 *          Retrieve a callout cache record       *
35 *************************************************/
36
37 /* If a record exists, check whether it has expired.
38
39 Arguments:
40   dbm_file          an open hints file
41   key               the record key
42   type              "address" or "domain"
43   positive_expire   expire time for positive records
44   negative_expire   expire time for negative records
45
46 Returns:            the cache record if a non-expired one exists, else NULL
47 */
48
49 static dbdata_callout_cache *
50 get_callout_cache_record(open_db *dbm_file, uschar *key, uschar *type,
51   int positive_expire, int negative_expire)
52 {
53 BOOL negative;
54 int length, expire;
55 time_t now;
56 dbdata_callout_cache *cache_record;
57
58 cache_record = dbfn_read_with_length(dbm_file, key, &length);
59
60 if (cache_record == NULL)
61   {
62   HDEBUG(D_verify) debug_printf("callout cache: no %s record found\n", type);
63   return NULL;
64   }
65
66 /* We treat a record as "negative" if its result field is not positive, or if
67 it is a domain record and the postmaster field is negative. */
68
69 negative = cache_record->result != ccache_accept ||
70   (type[0] == 'd' && cache_record->postmaster_result == ccache_reject);
71 expire = negative? negative_expire : positive_expire;
72 now = time(NULL);
73
74 if (now - cache_record->time_stamp > expire)
75   {
76   HDEBUG(D_verify) debug_printf("callout cache: %s record expired\n", type);
77   return NULL;
78   }
79
80 /* If this is a non-reject domain record, check for the obsolete format version
81 that doesn't have the postmaster and random timestamps, by looking at the
82 length. If so, copy it to a new-style block, replicating the record's
83 timestamp. Then check the additional timestamps. (There's no point wasting
84 effort if connections are rejected.) */
85
86 if (type[0] == 'd' && cache_record->result != ccache_reject)
87   {
88   if (length == sizeof(dbdata_callout_cache_obs))
89     {
90     dbdata_callout_cache *new = store_get(sizeof(dbdata_callout_cache));
91     memcpy(new, cache_record, length);
92     new->postmaster_stamp = new->random_stamp = new->time_stamp;
93     cache_record = new;
94     }
95
96   if (now - cache_record->postmaster_stamp > expire)
97     cache_record->postmaster_result = ccache_unknown;
98
99   if (now - cache_record->random_stamp > expire)
100     cache_record->random_result = ccache_unknown;
101   }
102
103 HDEBUG(D_verify) debug_printf("callout cache: found %s record\n", type);
104 return cache_record;
105 }
106
107
108
109 /*************************************************
110 *      Do callout verification for an address    *
111 *************************************************/
112
113 /* This function is called from verify_address() when the address has routed to
114 a host list, and a callout has been requested. Callouts are expensive; that is
115 why a cache is used to improve the efficiency.
116
117 Arguments:
118   addr              the address that's been routed
119   host_list         the list of hosts to try
120   tf                the transport feedback block
121
122   ifstring          "interface" option from transport, or NULL
123   portstring        "port" option from transport, or NULL
124   protocolstring    "protocol" option from transport, or NULL
125   callout           the per-command callout timeout
126   callout_overall   the overall callout timeout (if < 0 use 4*callout)
127   callout_connect   the callout connection timeout (if < 0 use callout)
128   options           the verification options - these bits are used:
129                       vopt_is_recipient => this is a recipient address
130                       vopt_callout_no_cache => don't use callout cache
131                       vopt_callout_random => do the "random" thing
132                       vopt_callout_recipsender => use real sender for recipient
133                       vopt_callout_recippmaster => use postmaster for recipient
134   se_mailfrom         MAIL FROM address for sender verify; NULL => ""
135   pm_mailfrom         if non-NULL, do the postmaster check with this sender
136
137 Returns:            OK/FAIL/DEFER
138 */
139
140 static int
141 do_callout(address_item *addr, host_item *host_list, transport_feedback *tf,
142   int callout, int callout_overall, int callout_connect, int options, 
143   uschar *se_mailfrom, uschar *pm_mailfrom)
144 {
145 BOOL is_recipient = (options & vopt_is_recipient) != 0;
146 BOOL callout_no_cache = (options & vopt_callout_no_cache) != 0;
147 BOOL callout_random = (options & vopt_callout_random) != 0;
148
149 int yield = OK;
150 BOOL done = FALSE;
151 uschar *address_key;
152 uschar *from_address;
153 uschar *random_local_part = NULL;
154 uschar **failure_ptr = is_recipient? 
155   &recipient_verify_failure : &sender_verify_failure;
156 open_db dbblock;
157 open_db *dbm_file = NULL;
158 dbdata_callout_cache new_domain_record;
159 dbdata_callout_cache_address new_address_record;
160 host_item *host;
161 time_t callout_start_time;
162
163 new_domain_record.result = ccache_unknown;
164 new_domain_record.postmaster_result = ccache_unknown;
165 new_domain_record.random_result = ccache_unknown;
166
167 memset(&new_address_record, 0, sizeof(new_address_record));
168
169 /* For a recipient callout, the key used for the address cache record must
170 include the sender address if we are using the real sender in the callout,
171 because that may influence the result of the callout. */
172
173 address_key = addr->address;
174 from_address = US"";
175
176 if (is_recipient)
177   {
178   if ((options & vopt_callout_recipsender) != 0)
179     {
180     address_key = string_sprintf("%s/<%s>", addr->address, sender_address);
181     from_address = sender_address;
182     }
183   else if ((options & vopt_callout_recippmaster) != 0)
184     {
185     address_key = string_sprintf("%s/<postmaster@%s>", addr->address,
186       qualify_domain_sender);
187     from_address = string_sprintf("postmaster@%s", qualify_domain_sender);
188     }
189   }
190
191 /* For a sender callout, we must adjust the key if the mailfrom address is not
192 empty. */
193
194 else
195   {
196   from_address = (se_mailfrom == NULL)? US"" : se_mailfrom;
197   if (from_address[0] != 0)
198     address_key = string_sprintf("%s/<%s>", addr->address, from_address);
199   }
200
201 /* Open the callout cache database, it it exists, for reading only at this
202 stage, unless caching has been disabled. */
203
204 if (callout_no_cache)
205   {
206   HDEBUG(D_verify) debug_printf("callout cache: disabled by no_cache\n");
207   }
208 else if ((dbm_file = dbfn_open(US"callout", O_RDWR, &dbblock, FALSE)) == NULL)
209   {
210   HDEBUG(D_verify) debug_printf("callout cache: not available\n");
211   }
212
213 /* If a cache database is available see if we can avoid the need to do an
214 actual callout by making use of previously-obtained data. */
215
216 if (dbm_file != NULL)
217   {
218   dbdata_callout_cache_address *cache_address_record;
219   dbdata_callout_cache *cache_record = get_callout_cache_record(dbm_file,
220     addr->domain, US"domain",
221     callout_cache_domain_positive_expire,
222     callout_cache_domain_negative_expire);
223
224   /* If an unexpired cache record was found for this domain, see if the callout
225   process can be short-circuited. */
226
227   if (cache_record != NULL)
228     {
229     /* If an early command (up to and including MAIL FROM:<>) was rejected,
230     there is no point carrying on. The callout fails. */
231
232     if (cache_record->result == ccache_reject)
233       {
234       setflag(addr, af_verify_nsfail);
235       HDEBUG(D_verify)
236         debug_printf("callout cache: domain gave initial rejection, or "
237           "does not accept HELO or MAIL FROM:<>\n");
238       setflag(addr, af_verify_nsfail);
239       addr->user_message = US"(result of an earlier callout reused).";
240       yield = FAIL;
241       *failure_ptr = US"mail"; 
242       goto END_CALLOUT;
243       }
244
245     /* If a previous check on a "random" local part was accepted, we assume
246     that the server does not do any checking on local parts. There is therefore
247     no point in doing the callout, because it will always be successful. If a
248     random check previously failed, arrange not to do it again, but preserve
249     the data in the new record. If a random check is required but hasn't been
250     done, skip the remaining cache processing. */
251
252     if (callout_random) switch(cache_record->random_result)
253       {
254       case ccache_accept:
255       HDEBUG(D_verify)
256         debug_printf("callout cache: domain accepts random addresses\n");
257       goto END_CALLOUT;     /* Default yield is OK */
258
259       case ccache_reject:
260       HDEBUG(D_verify)
261         debug_printf("callout cache: domain rejects random addresses\n");
262       callout_random = FALSE;
263       new_domain_record.random_result = ccache_reject;
264       new_domain_record.random_stamp = cache_record->random_stamp;
265       break;
266
267       default:
268       HDEBUG(D_verify)
269         debug_printf("callout cache: need to check random address handling "
270           "(not cached or cache expired)\n");
271       goto END_CACHE;
272       }
273
274     /* If a postmaster check is requested, but there was a previous failure,
275     there is again no point in carrying on. If a postmaster check is required,
276     but has not been done before, we are going to have to do a callout, so skip
277     remaining cache processing. */
278
279     if (pm_mailfrom != NULL)
280       {
281       if (cache_record->postmaster_result == ccache_reject)
282         {
283         setflag(addr, af_verify_pmfail);
284         HDEBUG(D_verify)
285           debug_printf("callout cache: domain does not accept "
286             "RCPT TO:<postmaster@domain>\n");
287         yield = FAIL;
288         *failure_ptr = US"postmaster"; 
289         setflag(addr, af_verify_pmfail);
290         addr->user_message = US"(result of earlier verification reused).";
291         goto END_CALLOUT;
292         }
293       if (cache_record->postmaster_result == ccache_unknown)
294         {
295         HDEBUG(D_verify)
296           debug_printf("callout cache: need to check RCPT "
297             "TO:<postmaster@domain> (not cached or cache expired)\n");
298         goto END_CACHE;
299         }
300
301       /* If cache says OK, set pm_mailfrom NULL to prevent a redundant
302       postmaster check if the address itself has to be checked. Also ensure
303       that the value in the cache record is preserved (with its old timestamp).
304       */
305
306       HDEBUG(D_verify) debug_printf("callout cache: domain accepts RCPT "
307         "TO:<postmaster@domain>\n");
308       pm_mailfrom = NULL;
309       new_domain_record.postmaster_result = ccache_accept;
310       new_domain_record.postmaster_stamp = cache_record->postmaster_stamp;
311       }
312     }
313
314   /* We can't give a result based on information about the domain. See if there
315   is an unexpired cache record for this specific address (combined with the
316   sender address if we are doing a recipient callout with a non-empty sender).
317   */
318
319   cache_address_record = (dbdata_callout_cache_address *)
320     get_callout_cache_record(dbm_file,
321       address_key, US"address",
322       callout_cache_positive_expire,
323       callout_cache_negative_expire);
324
325   if (cache_address_record != NULL)
326     {
327     if (cache_address_record->result == ccache_accept)
328       {
329       HDEBUG(D_verify)
330         debug_printf("callout cache: address record is positive\n");
331       }
332     else
333       {
334       HDEBUG(D_verify)
335         debug_printf("callout cache: address record is negative\n");
336       addr->user_message = US"Previous (cached) callout verification failure";
337       *failure_ptr = US"recipient"; 
338       yield = FAIL;
339       }
340     goto END_CALLOUT;
341     }
342
343   /* Close the cache database while we actually do the callout for real. */
344
345   END_CACHE:
346   dbfn_close(dbm_file);
347   dbm_file = NULL;
348   }
349
350 /* The information wasn't available in the cache, so we have to do a real
351 callout and save the result in the cache for next time, unless no_cache is set,
352 or unless we have a previously cached negative random result. If we are to test
353 with a random local part, ensure that such a local part is available. If not,
354 log the fact, but carry on without randomming. */
355
356 if (callout_random && callout_random_local_part != NULL)
357   {
358   random_local_part = expand_string(callout_random_local_part);
359   if (random_local_part == NULL)
360     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
361       "callout_random_local_part: %s", expand_string_message);
362   }
363
364 /* Default the connect and overall callout timeouts if not set, and record the
365 time we are starting so that we can enforce it. */
366
367 if (callout_overall < 0) callout_overall = 4 * callout;
368 if (callout_connect < 0) callout_connect = callout;
369 callout_start_time = time(NULL);
370
371 /* Now make connections to the hosts and do real callouts. The list of hosts
372 is passed in as an argument. */
373
374 for (host = host_list; host != NULL && !done; host = host->next)
375   {
376   smtp_inblock inblock;
377   smtp_outblock outblock;
378   int host_af;
379   int port = 25;
380   uschar *helo = US"HELO";
381   uschar *interface = NULL;  /* Outgoing interface to use; NULL => any */
382   uschar inbuffer[4096];
383   uschar outbuffer[1024];
384   uschar responsebuffer[4096];
385
386   clearflag(addr, af_verify_pmfail);  /* postmaster callout flag */
387   clearflag(addr, af_verify_nsfail);  /* null sender callout flag */
388
389   /* Skip this host if we don't have an IP address for it. */
390
391   if (host->address == NULL)
392     {
393     DEBUG(D_verify) debug_printf("no IP address for host name %s: skipping\n",
394       host->name);
395     continue;
396     }
397
398   /* Check the overall callout timeout */
399
400   if (time(NULL) - callout_start_time >= callout_overall)
401     {
402     HDEBUG(D_verify) debug_printf("overall timeout for callout exceeded\n");
403     break;
404     }
405
406   /* Set IPv4 or IPv6 */
407
408   host_af = (Ustrchr(host->address, ':') == NULL)? AF_INET:AF_INET6;
409
410   /* Expand and interpret the interface and port strings. This has to
411   be delayed till now, because they may expand differently for different
412   hosts. If there's a failure, log it, but carry on with the defaults. */
413
414   deliver_host = host->name;
415   deliver_host_address = host->address;
416   if (!smtp_get_interface(tf->interface, host_af, addr, NULL, &interface,
417           US"callout") ||
418       !smtp_get_port(tf->port, addr, &port, US"callout"))
419     log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
420       addr->message);
421   deliver_host = deliver_host_address = NULL;
422
423   /* Set HELO string according to the protocol */
424
425   if (Ustrcmp(tf->protocol, "lmtp") == 0) helo = US"LHLO";
426
427   HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", interface, port);
428
429   /* Set up the buffer for reading SMTP response packets. */
430
431   inblock.buffer = inbuffer;
432   inblock.buffersize = sizeof(inbuffer);
433   inblock.ptr = inbuffer;
434   inblock.ptrend = inbuffer;
435
436   /* Set up the buffer for holding SMTP commands while pipelining */
437
438   outblock.buffer = outbuffer;
439   outblock.buffersize = sizeof(outbuffer);
440   outblock.ptr = outbuffer;
441   outblock.cmd_count = 0;
442   outblock.authenticating = FALSE;
443
444   /* Connect to the host; on failure, just loop for the next one, but we
445   set the error for the last one. Use the callout_connect timeout. */
446
447   inblock.sock = outblock.sock =
448     smtp_connect(host, host_af, port, interface, callout_connect, TRUE);
449   if (inblock.sock < 0)
450     {
451     addr->message = string_sprintf("could not connect to %s [%s]: %s",
452         host->name, host->address, strerror(errno));
453     continue;
454     }
455
456   /* Wait for initial response, and then run the initial SMTP commands. The
457   smtp_write_command() function leaves its command in big_buffer. This is
458   used in error responses. Initialize it in case the connection is
459   rejected. */
460
461   Ustrcpy(big_buffer, "initial connection");
462
463   done =
464     smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
465       '2', callout) &&
466
467     smtp_write_command(&outblock, FALSE, "%s %s\r\n", helo,
468       smtp_active_hostname) >= 0 &&
469     smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
470       '2', callout) &&
471
472     smtp_write_command(&outblock, FALSE, "MAIL FROM:<%s>\r\n",
473       from_address) >= 0 &&
474     smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
475       '2', callout);
476
477   /* If the host gave an initial error, or does not accept HELO or MAIL
478   FROM:<>, arrange to cache this information, but don't record anything for an
479   I/O error or a defer. Do not cache rejections when a non-empty sender has
480   been used, because that blocks the whole domain for all senders. */
481
482   if (!done)
483     {
484     *failure_ptr = US"mail"; 
485     if (errno == 0 && responsebuffer[0] == '5')
486       {
487       setflag(addr, af_verify_nsfail);
488       if (from_address[0] == 0) new_domain_record.result = ccache_reject;
489       }
490     }
491
492   /* Otherwise, proceed to check a "random" address (if required), then the
493   given address, and the postmaster address (if required). Between each check,
494   issue RSET, because some servers accept only one recipient after MAIL
495   FROM:<>. */
496
497   else
498     {
499     new_domain_record.result = ccache_accept;
500
501     /* Do the random local part check first */
502
503     if (random_local_part != NULL)
504       {
505       uschar randombuffer[1024];
506       BOOL random_ok =
507         smtp_write_command(&outblock, FALSE,
508           "RCPT TO:<%.1000s@%.1000s>\r\n", random_local_part,
509           addr->domain) >= 0 &&
510         smtp_read_response(&inblock, randombuffer,
511           sizeof(randombuffer), '2', callout);
512
513       /* Remember when we last did a random test */
514
515       new_domain_record.random_stamp = time(NULL);
516
517       /* If accepted, we aren't going to do any further tests below. */
518
519       if (random_ok)
520         {
521         new_domain_record.random_result = ccache_accept;
522         }
523
524       /* Otherwise, cache a real negative response, and get back to the right
525       state to send RCPT. Unless there's some problem such as a dropped
526       connection, we expect to succeed, because the commands succeeded above. */
527
528       else if (errno == 0)
529         {
530         if (randombuffer[0] == '5')
531           new_domain_record.random_result = ccache_reject;
532
533         done =
534           smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0 &&
535           smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
536             '2', callout) &&
537
538           smtp_write_command(&outblock, FALSE, "MAIL FROM:<>\r\n") >= 0 &&
539           smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
540             '2', callout);
541         }
542       else done = FALSE;    /* Some timeout/connection problem */
543       }                     /* Random check */
544
545     /* If the host is accepting all local parts, as determined by the "random"
546     check, we don't need to waste time doing any further checking. */
547
548     if (new_domain_record.random_result != ccache_accept && done)
549       {
550       done =
551         smtp_write_command(&outblock, FALSE, "RCPT TO:<%.1000s>\r\n",
552           addr->address) >= 0 &&
553         smtp_read_response(&inblock, responsebuffer, sizeof(responsebuffer),
554           '2', callout);
555
556       if (done)
557         new_address_record.result = ccache_accept;
558       else if (errno == 0 && responsebuffer[0] == '5')
559         {
560         *failure_ptr = US"recipient";  
561         new_address_record.result = ccache_reject;
562         } 
563
564       /* Do postmaster check if requested */
565
566       if (done && pm_mailfrom != NULL)
567         {
568         done =
569           smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0 &&
570           smtp_read_response(&inblock, responsebuffer,
571             sizeof(responsebuffer), '2', callout) &&
572
573           smtp_write_command(&outblock, FALSE,
574             "MAIL FROM:<%s>\r\n", pm_mailfrom) >= 0 &&
575           smtp_read_response(&inblock, responsebuffer,
576             sizeof(responsebuffer), '2', callout) &&
577
578           smtp_write_command(&outblock, FALSE,
579             "RCPT TO:<postmaster@%.1000s>\r\n", addr->domain) >= 0 &&
580           smtp_read_response(&inblock, responsebuffer,
581             sizeof(responsebuffer), '2', callout);
582
583         new_domain_record.postmaster_stamp = time(NULL);
584
585         if (done)
586           new_domain_record.postmaster_result = ccache_accept;
587         else if (errno == 0 && responsebuffer[0] == '5')
588           {
589           *failure_ptr = US"postmaster"; 
590           setflag(addr, af_verify_pmfail);
591           new_domain_record.postmaster_result = ccache_reject;
592           }
593         }
594       }           /* Random not accepted */
595     }             /* MAIL FROM:<> accepted */
596
597   /* For any failure of the main check, other than a negative response, we just
598   close the connection and carry on. We can identify a negative response by the
599   fact that errno is zero. For I/O errors it will be non-zero
600
601   Set up different error texts for logging and for sending back to the caller
602   as an SMTP response. Log in all cases, using a one-line format. For sender
603   callouts, give a full response to the caller, but for recipient callouts,
604   don't give the IP address because this may be an internal host whose identity
605   is not to be widely broadcast. */
606
607   if (!done)
608     {
609     if (errno == ETIMEDOUT)
610       {
611       HDEBUG(D_verify) debug_printf("SMTP timeout\n");
612       }
613     else if (errno == 0)
614       {
615       if (*responsebuffer == 0) Ustrcpy(responsebuffer, US"connection dropped");
616
617       addr->message =
618         string_sprintf("response to \"%s\" from %s [%s] was: %s",
619           big_buffer, host->name, host->address,
620           string_printing(responsebuffer));
621
622       addr->user_message = is_recipient?
623         string_sprintf("Callout verification failed:\n%s", responsebuffer)
624         :
625         string_sprintf("Called:   %s\nSent:     %s\nResponse: %s",
626           host->address, big_buffer, responsebuffer);
627
628       /* Hard rejection ends the process */
629
630       if (responsebuffer[0] == '5')   /* Address rejected */
631         {
632         yield = FAIL;
633         done = TRUE;
634         }
635       }
636     }
637
638   /* End the SMTP conversation and close the connection. */
639
640   (void)smtp_write_command(&outblock, FALSE, "QUIT\r\n");
641   close(inblock.sock);
642   }    /* Loop through all hosts, while !done */
643
644 /* If we get here with done == TRUE, a successful callout happened, and yield
645 will be set OK or FAIL according to the response to the RCPT command.
646 Otherwise, we looped through the hosts but couldn't complete the business.
647 However, there may be domain-specific information to cache in both cases.
648
649 The value of the result field in the new_domain record is ccache_unknown if
650 there was an error before or with MAIL FROM:<>, and errno was not zero,
651 implying some kind of I/O error. We don't want to write the cache in that case.
652 Otherwise the value is ccache_accept or ccache_reject. */
653
654 if (!callout_no_cache && new_domain_record.result != ccache_unknown)
655   {
656   if ((dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE))
657        == NULL)
658     {
659     HDEBUG(D_verify) debug_printf("callout cache: not available\n");
660     }
661   else
662     {
663     (void)dbfn_write(dbm_file, addr->domain, &new_domain_record,
664       (int)sizeof(dbdata_callout_cache));
665     HDEBUG(D_verify) debug_printf("wrote callout cache domain record:\n"
666       "  result=%d postmaster=%d random=%d\n",
667       new_domain_record.result,
668       new_domain_record.postmaster_result,
669       new_domain_record.random_result);
670     }
671   }
672
673 /* If a definite result was obtained for the callout, cache it unless caching
674 is disabled. */
675
676 if (done)
677   {
678   if (!callout_no_cache && new_address_record.result != ccache_unknown)
679     {
680     if (dbm_file == NULL)
681       dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE);
682     if (dbm_file == NULL)
683       {
684       HDEBUG(D_verify) debug_printf("no callout cache available\n");
685       }
686     else
687       {
688       (void)dbfn_write(dbm_file, address_key, &new_address_record,
689         (int)sizeof(dbdata_callout_cache_address));
690       HDEBUG(D_verify) debug_printf("wrote %s callout cache address record\n",
691         (new_address_record.result == ccache_accept)? "positive" : "negative");
692       }
693     }
694   }    /* done */
695
696 /* Failure to connect to any host, or any response other than 2xx or 5xx is a
697 temporary error. If there was only one host, and a response was received, leave
698 it alone if supplying details. Otherwise, give a generic response. */
699
700 else   /* !done */
701   {
702   uschar *dullmsg = string_sprintf("Could not complete %s verify callout",
703     is_recipient? "recipient" : "sender");
704   yield = DEFER;
705
706   if (host_list->next != NULL || addr->message == NULL) addr->message = dullmsg;
707
708   addr->user_message = (!smtp_return_error_details)? dullmsg :
709     string_sprintf("%s for <%s>.\n"
710       "The mail server(s) for the domain may be temporarily unreachable, or\n"
711       "they may be permanently unreachable from this server. In the latter case,\n%s",
712       dullmsg, addr->address,
713       is_recipient?
714         "the address will never be accepted."
715         :
716         "you need to change the address or create an MX record for its domain\n"
717         "if it is supposed to be generally accessible from the Internet.\n"
718         "Talk to your mail administrator for details.");
719
720   /* Force a specific error code */
721
722   addr->basic_errno = ERRNO_CALLOUTDEFER;
723   }
724
725 /* Come here from within the cache-reading code on fast-track exit. */
726
727 END_CALLOUT:
728 if (dbm_file != NULL) dbfn_close(dbm_file);
729 return yield;
730 }
731
732
733
734 /*************************************************
735 *           Copy error to toplevel address       *
736 *************************************************/
737
738 /* This function is used when a verify fails or defers, to ensure that the
739 failure or defer information is in the original toplevel address. This applies
740 when an address is redirected to a single new address, and the failure or
741 deferral happens to the child address.
742
743 Arguments:
744   vaddr       the verify address item
745   addr        the final address item
746   yield       FAIL or DEFER
747
748 Returns:      the value of YIELD
749 */
750
751 static int
752 copy_error(address_item *vaddr, address_item *addr, int yield)
753 {
754 if (addr != vaddr)
755   {
756   vaddr->message = addr->message;
757   vaddr->user_message = addr->user_message;
758   vaddr->basic_errno = addr->basic_errno;
759   vaddr->more_errno = addr->more_errno;
760   }
761 return yield;
762 }
763
764
765
766
767 /*************************************************
768 *            Verify an email address             *
769 *************************************************/
770
771 /* This function is used both for verification (-bv and at other times) and
772 address testing (-bt), which is indicated by address_test_mode being set.
773
774 Arguments:
775   vaddr            contains the address to verify; the next field in this block
776                      must be NULL
777   f                if not NULL, write the result to this file
778   options          various option bits:
779                      vopt_fake_sender => this sender verify is not for the real
780                        sender (it was verify=sender=xxxx or an address from a
781                        header line) - rewriting must not change sender_address
782                      vopt_is_recipient => this is a recipient address, otherwise
783                        it's a sender address - this affects qualification and
784                        rewriting and messages from callouts
785                      vopt_qualify => qualify an unqualified address; else error
786                      vopt_expn => called from SMTP EXPN command
787
788                      These ones are used by do_callout() -- the options variable
789                        is passed to it.
790
791                      vopt_callout_no_cache => don't use callout cache
792                      vopt_callout_random => do the "random" thing
793                      vopt_callout_recipsender => use real sender for recipient
794                      vopt_callout_recippmaster => use postmaster for recipient
795
796   callout          if > 0, specifies that callout is required, and gives timeout
797                      for individual commands
798   callout_overall  if > 0, gives overall timeout for the callout function;
799                    if < 0, a default is used (see do_callout())
800   callout_connect  the connection timeout for callouts                  
801   se_mailfrom      when callout is requested to verify a sender, use this
802                      in MAIL FROM; NULL => ""
803   pm_mailfrom      when callout is requested, if non-NULL, do the postmaster
804                      thing and use this as the sender address (may be "")
805
806   routed           if not NULL, set TRUE if routing succeeded, so we can
807                      distinguish between routing failed and callout failed
808
809 Returns:           OK      address verified
810                    FAIL    address failed to verify
811                    DEFER   can't tell at present
812 */
813
814 int
815 verify_address(address_item *vaddr, FILE *f, int options, int callout,
816   int callout_overall, int callout_connect, uschar *se_mailfrom, 
817   uschar *pm_mailfrom, BOOL *routed)
818 {
819 BOOL allok = TRUE;
820 BOOL full_info = (f == NULL)? FALSE : (debug_selector != 0);
821 BOOL is_recipient = (options & vopt_is_recipient) != 0;
822 BOOL expn         = (options & vopt_expn) != 0;
823 int i;
824 int yield = OK;
825 int verify_type = expn? v_expn :
826      address_test_mode? v_none :
827           is_recipient? v_recipient : v_sender;
828 address_item *addr_list;
829 address_item *addr_new = NULL;
830 address_item *addr_remote = NULL;
831 address_item *addr_local = NULL;
832 address_item *addr_succeed = NULL;
833 uschar **failure_ptr = is_recipient? 
834   &recipient_verify_failure : &sender_verify_failure;
835 uschar *ko_prefix, *cr;
836 uschar *address = vaddr->address;
837 uschar *save_sender;
838 uschar null_sender[] = { 0 };             /* Ensure writeable memory */
839
840 /* Clear, just in case */
841
842 *failure_ptr = NULL;
843
844 /* Set up a prefix and suffix for error message which allow us to use the same
845 output statements both in EXPN mode (where an SMTP response is needed) and when
846 debugging with an output file. */
847
848 if (expn)
849   {
850   ko_prefix = US"553 ";
851   cr = US"\r";
852   }
853 else ko_prefix = cr = US"";
854
855 /* Add qualify domain if permitted; otherwise an unqualified address fails. */
856
857 if (parse_find_at(address) == NULL)
858   {
859   if ((options & vopt_qualify) == 0)
860     {
861     if (f != NULL)
862       fprintf(f, "%sA domain is required for \"%s\"%s\n", ko_prefix, address,
863         cr);
864     *failure_ptr = US"qualify";     
865     return FAIL;
866     }
867   address = rewrite_address_qualify(address, is_recipient);
868   }
869
870 DEBUG(D_verify)
871   {
872   debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
873   debug_printf("%s %s\n", address_test_mode? "Testing" : "Verifying", address);
874   }
875
876 /* Rewrite and report on it. Clear the domain and local part caches - these
877 may have been set by domains and local part tests during an ACL. */
878
879 if (global_rewrite_rules != NULL)
880   {
881   uschar *old = address;
882   address = rewrite_address(address, is_recipient, FALSE,
883     global_rewrite_rules, rewrite_existflags);
884   if (address != old)
885     {
886     for (i = 0; i < (MAX_NAMED_LIST * 2)/32; i++) vaddr->localpart_cache[i] = 0;
887     for (i = 0; i < (MAX_NAMED_LIST * 2)/32; i++) vaddr->domain_cache[i] = 0;
888     if (f != NULL && !expn) fprintf(f, "Address rewritten as: %s\n", address);
889     }
890   }
891
892 /* If this is the real sender address, we must update sender_address at
893 this point, because it may be referred to in the routers. */
894
895 if ((options & (vopt_fake_sender|vopt_is_recipient)) == 0)
896   sender_address = address;
897
898 /* If the address was rewritten to <> no verification can be done, and we have
899 to return OK. This rewriting is permitted only for sender addresses; for other
900 addresses, such rewriting fails. */
901
902 if (address[0] == 0) return OK;
903
904 /* Save a copy of the sender address for re-instating if we change it to <>
905 while verifying a sender address (a nice bit of self-reference there). */
906
907 save_sender = sender_address;
908
909 /* Update the address structure with the possibly qualified and rewritten
910 address. Set it up as the starting address on the chain of new addresses. */
911
912 vaddr->address = address;
913 addr_new = vaddr;
914
915 /* We need a loop, because an address can generate new addresses. We must also
916 cope with generated pipes and files at the top level. (See also the code and
917 comment in deliver.c.) However, it is usually the case that the router for
918 user's .forward files has its verify flag turned off.
919
920 If an address generates more than one child, the loop is used only when
921 full_info is set, and this can only be set locally. Remote enquiries just get
922 information about the top level address, not anything that it generated. */
923
924 while (addr_new != NULL)
925   {
926   int rc;
927   address_item *addr = addr_new;
928
929   addr_new = addr->next;
930   addr->next = NULL;
931
932   DEBUG(D_verify)
933     {
934     debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
935     debug_printf("Considering %s\n", addr->address);
936     }
937
938   /* Handle generated pipe, file or reply addresses. We don't get these
939   when handling EXPN, as it does only one level of expansion. */
940
941   if (testflag(addr, af_pfr))
942     {
943     allok = FALSE;
944     if (f != NULL)
945       {
946       BOOL allow;
947
948       if (addr->address[0] == '>')
949         {
950         allow = testflag(addr, af_allow_reply);
951         fprintf(f, "%s -> mail %s", addr->parent->address, addr->address + 1);
952         }
953       else
954         {
955         allow = (addr->address[0] == '|')?
956           testflag(addr, af_allow_pipe) : testflag(addr, af_allow_file);
957         fprintf(f, "%s -> %s", addr->parent->address, addr->address);
958         }
959
960       if (addr->basic_errno == ERRNO_BADTRANSPORT)
961         fprintf(f, "\n*** Error in setting up pipe, file, or autoreply:\n"
962           "%s\n", addr->message);
963       else if (allow)
964         fprintf(f, "\n  transport = %s\n", addr->transport->name);
965       else
966         fprintf(f, " *** forbidden ***\n");
967       }
968     continue;
969     }
970
971   /* Just in case some router parameter refers to it. */
972
973   return_path = (addr->p.errors_address != NULL)?
974     addr->p.errors_address : sender_address;
975
976   /* Split the address into domain and local part, handling the %-hack if
977   necessary, and then route it. While routing a sender address, set
978   $sender_address to <> because that is what it will be if we were trying to
979   send a bounce to the sender. */
980
981   if (routed != NULL) *routed = FALSE;
982   if ((rc = deliver_split_address(addr)) == OK)
983     {
984     if (!is_recipient) sender_address = null_sender;
985     rc = route_address(addr, &addr_local, &addr_remote, &addr_new,
986       &addr_succeed, verify_type);
987     sender_address = save_sender;     /* Put back the real sender */
988     }
989
990   /* If routing an address succeeded, set the flag that remembers, for use when
991   an ACL cached a sender verify (in case a callout fails). Then if routing set
992   up a list of hosts or the transport has a host list, and the callout option
993   is set, and we aren't in a host checking run, do the callout verification,
994   and set another flag that notes that a callout happened. */
995
996   if (rc == OK)
997     {
998     if (routed != NULL) *routed = TRUE;
999     if (callout > 0)
1000       {
1001       host_item *host_list = addr->host_list;
1002
1003       /* Default, if no remote transport, to NULL for the interface (=> any),
1004       "smtp" for the port, and "smtp" for the protocol. */
1005
1006       transport_feedback tf = { NULL, US"smtp", US"smtp", NULL, FALSE, FALSE };
1007
1008       /* If verification yielded a remote transport, we want to use that
1009       transport's options, so as to mimic what would happen if we were really
1010       sending a message to this address. */
1011
1012       if (addr->transport != NULL && !addr->transport->info->local)
1013         {
1014         (void)(addr->transport->setup)(addr->transport, addr, &tf, NULL);
1015
1016         /* If the transport has hosts and the router does not, or if the
1017         transport is configured to override the router's hosts, we must build a
1018         host list of the transport's hosts, and find the IP addresses */
1019
1020         if (tf.hosts != NULL && (host_list == NULL || tf.hosts_override))
1021           {
1022           uschar *s;
1023
1024           host_list = NULL;    /* Ignore the router's hosts */
1025
1026           deliver_domain = addr->domain;
1027           deliver_localpart = addr->local_part;
1028           s = expand_string(tf.hosts);
1029           deliver_domain = deliver_localpart = NULL;
1030
1031           if (s == NULL)
1032             {
1033             log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand list of hosts "
1034               "\"%s\" in %s transport for callout: %s", tf.hosts,
1035               addr->transport->name, expand_string_message);
1036             }
1037           else
1038             {
1039             uschar *canonical_name;
1040             host_item *host, *nexthost;
1041             host_build_hostlist(&host_list, s, tf.hosts_randomize);
1042
1043             /* Just ignore failures to find a host address. If we don't manage
1044             to find any addresses, the callout will defer. Note that more than 
1045             one address may be found for a single host, which will result in 
1046             additional host items being inserted into the chain. Hence we must 
1047             save the next host first. */
1048
1049             for (host = host_list; host != NULL; host = nexthost)
1050               {
1051               nexthost = host->next;
1052               if (tf.gethostbyname || 
1053                   string_is_ip_address(host->name, NULL) > 0)
1054                 (void)host_find_byname(host, NULL, &canonical_name, TRUE);
1055               else
1056                 {
1057                 int flags = HOST_FIND_BY_A;
1058                 if (tf.qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
1059                 if (tf.search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
1060                 (void)host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
1061                   &canonical_name, NULL);
1062                 }
1063               }
1064             }
1065           }
1066         }
1067
1068       /* Can only do a callout if we have at least one host! If the callout 
1069       fails, it will have set ${sender,recipient}_verify_failure. */
1070
1071       if (host_list != NULL)
1072         {
1073         HDEBUG(D_verify) debug_printf("Attempting full verification using callout\n");
1074         if (host_checking && !host_checking_callout)
1075           {
1076           HDEBUG(D_verify)
1077             debug_printf("... callout omitted by default when host testing\n"
1078               "(Use -bhc if you want the callouts to happen.)\n");
1079           }
1080         else
1081           {
1082           rc = do_callout(addr, host_list, &tf, callout, callout_overall,
1083             callout_connect, options, se_mailfrom, pm_mailfrom);
1084           }
1085         }
1086       else
1087         {
1088         HDEBUG(D_verify) debug_printf("Cannot do callout: neither router nor "
1089           "transport provided a host list\n");
1090         }
1091       }
1092     }
1093     
1094   /* Otherwise, any failure is a routing failure */
1095   
1096   else *failure_ptr = US"route"; 
1097
1098   /* A router may return REROUTED if it has set up a child address as a result
1099   of a change of domain name (typically from widening). In this case we always
1100   want to continue to verify the new child. */
1101
1102   if (rc == REROUTED) continue;
1103
1104   /* Handle hard failures */
1105
1106   if (rc == FAIL)
1107     {
1108     allok = FALSE;
1109     if (f != NULL)
1110       {
1111       fprintf(f, "%s%s %s", ko_prefix, address,
1112         address_test_mode? "is undeliverable" : "failed to verify");
1113       if (!expn && admin_user)
1114         {
1115         if (addr->basic_errno > 0)
1116           fprintf(f, ": %s", strerror(addr->basic_errno));
1117         if (addr->message != NULL)
1118           fprintf(f, ":\n  %s", addr->message);
1119         }
1120       fprintf(f, "%s\n", cr);
1121       }
1122
1123     if (!full_info) return copy_error(vaddr, addr, FAIL);
1124       else yield = FAIL;
1125     }
1126
1127   /* Soft failure */
1128
1129   else if (rc == DEFER)
1130     {
1131     allok = FALSE;
1132     if (f != NULL)
1133       {
1134       fprintf(f, "%s%s cannot be resolved at this time", ko_prefix, address);
1135       if (!expn && admin_user)
1136         {
1137         if (addr->basic_errno > 0)
1138           fprintf(f, ":\n  %s", strerror(addr->basic_errno));
1139         if (addr->message != NULL)
1140           fprintf(f, ":\n  %s", addr->message);
1141         else if (addr->basic_errno <= 0)
1142           fprintf(f, ":\n  unknown error");
1143         }
1144
1145       fprintf(f, "%s\n", cr);
1146       }
1147     if (!full_info) return copy_error(vaddr, addr, DEFER);
1148       else if (yield == OK) yield = DEFER;
1149     }
1150
1151   /* If we are handling EXPN, we do not want to continue to route beyond
1152   the top level. */
1153
1154   else if (expn)
1155     {
1156     uschar *ok_prefix = US"250-";
1157     if (addr_new == NULL)
1158       {
1159       if (addr_local == NULL && addr_remote == NULL)
1160         fprintf(f, "250 mail to <%s> is discarded\r\n", address);
1161       else
1162         fprintf(f, "250 <%s>\r\n", address);
1163       }
1164     else while (addr_new != NULL)
1165       {
1166       address_item *addr2 = addr_new;
1167       addr_new = addr2->next;
1168       if (addr_new == NULL) ok_prefix = US"250 ";
1169       fprintf(f, "%s<%s>\r\n", ok_prefix, addr2->address);
1170       }
1171     return OK;
1172     }
1173
1174   /* Successful routing other than EXPN. */
1175
1176   else
1177     {
1178     /* Handle successful routing when short info wanted. Otherwise continue for
1179     other (generated) addresses. Short info is the operational case. Full info
1180     can be requested only when debug_selector != 0 and a file is supplied.
1181
1182     There is a conflict between the use of aliasing as an alternate email
1183     address, and as a sort of mailing list. If an alias turns the incoming
1184     address into just one address (e.g. J.Caesar->jc44) you may well want to
1185     carry on verifying the generated address to ensure it is valid when
1186     checking incoming mail. If aliasing generates multiple addresses, you
1187     probably don't want to do this. Exim therefore treats the generation of
1188     just a single new address as a special case, and continues on to verify the
1189     generated address. */
1190
1191     if (!full_info &&                    /* Stop if short info wanted AND */
1192          (addr_new == NULL ||            /* No new address OR */
1193           addr_new->next != NULL ||      /* More than one new address OR */
1194           testflag(addr_new, af_pfr)))   /* New address is pfr */
1195       {
1196       if (f != NULL) fprintf(f, "%s %s\n", address,
1197         address_test_mode? "is deliverable" : "verified");
1198
1199       /* If we have carried on to verify a child address, we want the value
1200       of $address_data to be that of the child */
1201
1202       vaddr->p.address_data = addr->p.address_data;
1203       return OK;
1204       }
1205     }
1206   }     /* Loop for generated addresses */
1207
1208 /* Display the full results of the successful routing, including any generated
1209 addresses. Control gets here only when full_info is set, which requires f not
1210 to be NULL, and this occurs only when a top-level verify is called with the
1211 debugging switch on.
1212
1213 If there are no local and no remote addresses, and there were no pipes, files,
1214 or autoreplies, and there were no errors or deferments, the message is to be
1215 discarded, usually because of the use of :blackhole: in an alias file. */
1216
1217 if (allok && addr_local == NULL && addr_remote == NULL)
1218   fprintf(f, "mail to %s is discarded\n", address);
1219
1220 else for (addr_list = addr_local, i = 0; i < 2; addr_list = addr_remote, i++)
1221   {
1222   while (addr_list != NULL)
1223     {
1224     address_item *addr = addr_list;
1225     address_item *p = addr->parent;
1226     addr_list = addr->next;
1227
1228     fprintf(f, "%s", CS addr->address);
1229     while (p != NULL)
1230       {
1231       fprintf(f, "\n    <-- %s", p->address);
1232       p = p->parent;
1233       }
1234     fprintf(f, "\n  ");
1235
1236     /* Show router, and transport */
1237
1238     fprintf(f, "router = %s, ", addr->router->name);
1239     fprintf(f, "transport = %s\n", (addr->transport == NULL)? US"unset" :
1240       addr->transport->name);
1241
1242     /* Show any hosts that are set up by a router unless the transport
1243     is going to override them; fiddle a bit to get a nice format. */
1244
1245     if (addr->host_list != NULL && addr->transport != NULL &&
1246         !addr->transport->overrides_hosts)
1247       {
1248       host_item *h;
1249       int maxlen = 0;
1250       int maxaddlen = 0;
1251       for (h = addr->host_list; h != NULL; h = h->next)
1252         {
1253         int len = Ustrlen(h->name);
1254         if (len > maxlen) maxlen = len;
1255         len = (h->address != NULL)? Ustrlen(h->address) : 7;
1256         if (len > maxaddlen) maxaddlen = len;
1257         }
1258       for (h = addr->host_list; h != NULL; h = h->next)
1259         {
1260         int len = Ustrlen(h->name);
1261         fprintf(f, "  host %s ", h->name);
1262         while (len++ < maxlen) fprintf(f, " ");
1263         if (h->address != NULL)
1264           {
1265           fprintf(f, "[%s] ", h->address);
1266           len = Ustrlen(h->address);
1267           }
1268         else if (!addr->transport->info->local)  /* Omit [unknown] for local */
1269           {
1270           fprintf(f, "[unknown] ");
1271           len = 7;
1272           }
1273         else len = -3;
1274         while (len++ < maxaddlen) fprintf(f," ");
1275         if (h->mx >= 0) fprintf(f, "MX=%d", h->mx);
1276         if (h->port != PORT_NONE) fprintf(f, " port=%d", h->port);
1277         if (h->status == hstatus_unusable) fprintf(f, " ** unusable **");
1278         fprintf(f, "\n");
1279         }
1280       }
1281     }
1282   }
1283
1284 /* Will be DEFER or FAIL if any one address has, only for full_info (which is 
1285 the -bv or -bt case). */
1286
1287 return yield;  
1288 }
1289
1290
1291
1292
1293 /*************************************************
1294 *      Check headers for syntax errors           *
1295 *************************************************/
1296
1297 /* This function checks those header lines that contain addresses, and verifies
1298 that all the addresses therein are syntactially correct.
1299
1300 Arguments:
1301   msgptr     where to put an error message
1302
1303 Returns:     OK
1304              FAIL
1305 */
1306
1307 int
1308 verify_check_headers(uschar **msgptr)
1309 {
1310 header_line *h;
1311 uschar *colon, *s;
1312
1313 for (h = header_list; h != NULL; h = h->next)
1314   {
1315   if (h->type != htype_from &&
1316       h->type != htype_reply_to &&
1317       h->type != htype_sender &&
1318       h->type != htype_to &&
1319       h->type != htype_cc &&
1320       h->type != htype_bcc)
1321     continue;
1322
1323   colon = Ustrchr(h->text, ':');
1324   s = colon + 1;
1325   while (isspace(*s)) s++;
1326
1327   parse_allow_group = TRUE;     /* Allow group syntax */
1328
1329   /* Loop for multiple addresses in the header */
1330
1331   while (*s != 0)
1332     {
1333     uschar *ss = parse_find_address_end(s, FALSE);
1334     uschar *recipient, *errmess;
1335     int terminator = *ss;
1336     int start, end, domain;
1337
1338     /* Temporarily terminate the string at this point, and extract the
1339     operative address within. */
1340
1341     *ss = 0;
1342     recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
1343     *ss = terminator;
1344
1345     /* Permit an unqualified address only if the message is local, or if the
1346     sending host is configured to be permitted to send them. */
1347
1348     if (recipient != NULL && domain == 0)
1349       {
1350       if (h->type == htype_from || h->type == htype_sender)
1351         {
1352         if (!allow_unqualified_sender) recipient = NULL;
1353         }
1354       else
1355         {
1356         if (!allow_unqualified_recipient) recipient = NULL;
1357         }
1358       if (recipient == NULL) errmess = US"unqualified address not permitted";
1359       }
1360
1361     /* It's an error if no address could be extracted, except for the special
1362     case of an empty address. */
1363
1364     if (recipient == NULL && Ustrcmp(errmess, "empty address") != 0)
1365       {
1366       uschar *verb = US"is";
1367       uschar *t = ss;
1368       int len;
1369
1370       /* Arrange not to include any white space at the end in the
1371       error message. */
1372
1373       while (t > s && isspace(t[-1])) t--;
1374
1375       /* Add the address which failed to the error message, since in a
1376       header with very many addresses it is sometimes hard to spot
1377       which one is at fault. However, limit the amount of address to
1378       quote - cases have been seen where, for example, a missing double
1379       quote in a humungous To: header creates an "address" that is longer
1380       than string_sprintf can handle. */
1381
1382       len = t - s;
1383       if (len > 1024)
1384         {
1385         len = 1024;
1386         verb = US"begins";
1387         }
1388
1389       *msgptr = string_printing(
1390         string_sprintf("%s: failing address in \"%.*s\" header %s: %.*s",
1391           errmess, colon - h->text, h->text, verb, len, s));
1392
1393       return FAIL;
1394       }
1395
1396     /* Advance to the next address */
1397
1398     s = ss + (terminator? 1:0);
1399     while (isspace(*s)) s++;
1400     }   /* Next address */
1401   }     /* Next header */
1402
1403 return OK;
1404 }
1405
1406
1407
1408
1409 /*************************************************
1410 *          Find if verified sender               *
1411 *************************************************/
1412
1413 /* Usually, just a single address is verified as the sender of the message.
1414 However, Exim can be made to verify other addresses as well (often related in
1415 some way), and this is useful in some environments. There may therefore be a
1416 chain of such addresses that have previously been tested. This function finds
1417 whether a given address is on the chain.
1418
1419 Arguments:   the address to be verified
1420 Returns:     pointer to an address item, or NULL
1421 */
1422
1423 address_item *
1424 verify_checked_sender(uschar *sender)
1425 {
1426 address_item *addr;
1427 for (addr = sender_verified_list; addr != NULL; addr = addr->next)
1428   if (Ustrcmp(sender, addr->address) == 0) break;
1429 return addr;
1430 }
1431
1432
1433
1434
1435
1436 /*************************************************
1437 *             Get valid header address           *
1438 *************************************************/
1439
1440 /* Scan the originator headers of the message, looking for an address that
1441 verifies successfully. RFC 822 says:
1442
1443     o   The "Sender" field mailbox should be sent  notices  of
1444         any  problems in transport or delivery of the original
1445         messages.  If there is no  "Sender"  field,  then  the
1446         "From" field mailbox should be used.
1447
1448     o   If the "Reply-To" field exists, then the reply  should
1449         go to the addresses indicated in that field and not to
1450         the address(es) indicated in the "From" field.
1451
1452 So we check a Sender field if there is one, else a Reply_to field, else a From
1453 field. As some strange messages may have more than one of these fields,
1454 especially if they are resent- fields, check all of them if there is more than
1455 one.
1456
1457 Arguments:
1458   user_msgptr      points to where to put a user error message
1459   log_msgptr       points to where to put a log error message
1460   callout          timeout for callout check (passed to verify_address())
1461   callout_overall  overall callout timeout (ditto)
1462   callout_connect  connect callout timeout (ditto) 
1463   se_mailfrom      mailfrom for verify; NULL => ""
1464   pm_mailfrom      sender for pm callout check (passed to verify_address())
1465   options          callout options (passed to verify_address())
1466
1467 If log_msgptr is set to something without setting user_msgptr, the caller
1468 normally uses log_msgptr for both things.
1469
1470 Returns:           result of the verification attempt: OK, FAIL, or DEFER;
1471                    FAIL is given if no appropriate headers are found
1472 */
1473
1474 int
1475 verify_check_header_address(uschar **user_msgptr, uschar **log_msgptr,
1476   int callout, int callout_overall, int callout_connect, uschar *se_mailfrom, 
1477   uschar *pm_mailfrom, int options)
1478 {
1479 static int header_types[] = { htype_sender, htype_reply_to, htype_from };
1480 int yield = FAIL;
1481 int i;
1482
1483 for (i = 0; i < 3; i++)
1484   {
1485   header_line *h;
1486   for (h = header_list; h != NULL; h = h->next)
1487     {
1488     int terminator, new_ok;
1489     uschar *s, *ss, *endname;
1490
1491     if (h->type != header_types[i]) continue;
1492     s = endname = Ustrchr(h->text, ':') + 1;
1493
1494     while (*s != 0)
1495       {
1496       address_item *vaddr;
1497
1498       while (isspace(*s) || *s == ',') s++;
1499       if (*s == 0) break;        /* End of header */
1500
1501       ss = parse_find_address_end(s, FALSE);
1502
1503       /* The terminator is a comma or end of header, but there may be white
1504       space preceding it (including newline for the last address). Move back
1505       past any white space so we can check against any cached envelope sender
1506       address verifications. */
1507
1508       while (isspace(ss[-1])) ss--;
1509       terminator = *ss;
1510       *ss = 0;
1511
1512       HDEBUG(D_verify) debug_printf("verifying %.*s header address %s\n",
1513         (int)(endname - h->text), h->text, s);
1514
1515       /* See if we have already verified this address as an envelope sender,
1516       and if so, use the previous answer. */
1517
1518       vaddr = verify_checked_sender(s);
1519
1520       if (vaddr != NULL &&                   /* Previously checked */
1521            (callout <= 0 ||                  /* No callout needed; OR */
1522             vaddr->special_action > 256))    /* Callout was done */
1523         {
1524         new_ok = vaddr->special_action & 255;
1525         HDEBUG(D_verify) debug_printf("previously checked as envelope sender\n");
1526         *ss = terminator;  /* Restore shortened string */
1527         }
1528
1529       /* Otherwise we run the verification now. We must restore the shortened
1530       string before running the verification, so the headers are correct, in
1531       case there is any rewriting. */
1532
1533       else
1534         {
1535         int start, end, domain;
1536         uschar *address = parse_extract_address(s, log_msgptr, &start,
1537           &end, &domain, FALSE);
1538
1539         *ss = terminator;
1540
1541         /* If verification failed because of a syntax error, fail this
1542         function, and ensure that the failing address gets added to the error
1543         message. */
1544
1545         if (address == NULL)
1546           {
1547           new_ok = FAIL;
1548           if (*log_msgptr != NULL)
1549             {
1550             while (ss > s && isspace(ss[-1])) ss--;
1551             *log_msgptr = string_sprintf("syntax error in '%.*s' header when "
1552               "scanning for sender: %s in \"%.*s\"",
1553               endname - h->text, h->text, *log_msgptr, ss - s, s);
1554             return FAIL;
1555             }
1556           }
1557
1558         /* Else go ahead with the sender verification. But is isn't *the*
1559         sender of the message, so set vopt_fake_sender to stop sender_address
1560         being replaced after rewriting or qualification. */
1561
1562         else
1563           {
1564           vaddr = deliver_make_addr(address, FALSE);
1565           new_ok = verify_address(vaddr, NULL, options | vopt_fake_sender,
1566             callout, callout_overall, callout_connect, se_mailfrom, 
1567             pm_mailfrom, NULL);
1568           }
1569         }
1570
1571       /* We now have the result, either newly found, or cached. If we are
1572       giving out error details, set a specific user error. This means that the
1573       last of these will be returned to the user if all three fail. We do not
1574       set a log message - the generic one below will be used. */
1575
1576       if (new_ok != OK && smtp_return_error_details)
1577         {
1578         *user_msgptr = string_sprintf("Rejected after DATA: "
1579           "could not verify \"%.*s\" header address\n%s: %s",
1580           endname - h->text, h->text, vaddr->address, vaddr->message);
1581         }
1582
1583       /* Success or defer */
1584
1585       if (new_ok == OK) return OK;
1586       if (new_ok == DEFER) yield = DEFER;
1587
1588       /* Move on to any more addresses in the header */
1589
1590       s = ss;
1591       }
1592     }
1593   }
1594
1595 if (yield == FAIL && *log_msgptr == NULL)
1596   *log_msgptr = US"there is no valid sender in any header line";
1597
1598 if (yield == DEFER && *log_msgptr == NULL)
1599   *log_msgptr = US"all attempts to verify a sender in a header line deferred";
1600
1601 return yield;
1602 }
1603
1604
1605
1606
1607 /*************************************************
1608 *            Get RFC 1413 identification         *
1609 *************************************************/
1610
1611 /* Attempt to get an id from the sending machine via the RFC 1413 protocol. If
1612 the timeout is set to zero, then the query is not done. There may also be lists
1613 of hosts and nets which are exempt. To guard against malefactors sending
1614 non-printing characters which could, for example, disrupt a message's headers,
1615 make sure the string consists of printing characters only.
1616
1617 Argument:
1618   port    the port to connect to; usually this is IDENT_PORT (113), but when
1619           running in the test harness with -bh a different value is used.
1620
1621 Returns:  nothing
1622
1623 Side effect: any received ident value is put in sender_ident (NULL otherwise)
1624 */
1625
1626 void
1627 verify_get_ident(int port)
1628 {
1629 int sock, host_af, qlen;
1630 int received_sender_port, received_interface_port, n;
1631 uschar *p;
1632 uschar buffer[2048];
1633
1634 /* Default is no ident. Check whether we want to do an ident check for this
1635 host. */
1636
1637 sender_ident = NULL;
1638 if (rfc1413_query_timeout <= 0 || verify_check_host(&rfc1413_hosts) != OK)
1639   return;
1640
1641 DEBUG(D_ident) debug_printf("doing ident callback\n");
1642
1643 /* Set up a connection to the ident port of the remote host. Bind the local end
1644 to the incoming interface address. If the sender host address is an IPv6
1645 address, the incoming interface address will also be IPv6. */
1646
1647 host_af = (Ustrchr(sender_host_address, ':') == NULL)? AF_INET : AF_INET6;
1648 sock = ip_socket(SOCK_STREAM, host_af);
1649 if (sock < 0) return;
1650
1651 if (ip_bind(sock, host_af, interface_address, 0) < 0)
1652   {
1653   DEBUG(D_ident) debug_printf("bind socket for ident failed: %s\n",
1654     strerror(errno));
1655   goto END_OFF;
1656   }
1657
1658 if (ip_connect(sock, host_af, sender_host_address, port, rfc1413_query_timeout)
1659      < 0)
1660   {
1661   if (errno == ETIMEDOUT && (log_extra_selector & LX_ident_timeout) != 0)
1662     {
1663     log_write(0, LOG_MAIN, "ident connection to %s timed out",
1664       sender_host_address);
1665     }
1666   else
1667     {
1668     DEBUG(D_ident) debug_printf("ident connection to %s failed: %s\n",
1669       sender_host_address, strerror(errno));
1670     }
1671   goto END_OFF;
1672   }
1673
1674 /* Construct and send the query. */
1675
1676 sprintf(CS buffer, "%d , %d\r\n", sender_host_port, interface_port);
1677 qlen = Ustrlen(buffer);
1678 if (send(sock, buffer, qlen, 0) < 0)
1679   {
1680   DEBUG(D_ident) debug_printf("ident send failed: %s\n", strerror(errno));
1681   goto END_OFF;
1682   }
1683
1684 /* Read a response line. We put it into the rest of the buffer, using several
1685 recv() calls if necessary. */
1686
1687 p = buffer + qlen;
1688
1689 for (;;)
1690   {
1691   uschar *pp;
1692   int count;
1693   int size = sizeof(buffer) - (p - buffer);
1694
1695   if (size <= 0) goto END_OFF;   /* Buffer filled without seeing \n. */
1696   count = ip_recv(sock, p, size, rfc1413_query_timeout);
1697   if (count <= 0) goto END_OFF;  /* Read error or EOF */
1698
1699   /* Scan what we just read, to see if we have reached the terminating \r\n. Be
1700   generous, and accept a plain \n terminator as well. The only illegal
1701   character is 0. */
1702
1703   for (pp = p; pp < p + count; pp++)
1704     {
1705     if (*pp == 0) goto END_OFF;   /* Zero octet not allowed */
1706     if (*pp == '\n')
1707       {
1708       if (pp[-1] == '\r') pp--;
1709       *pp = 0;
1710       goto GOT_DATA;             /* Break out of both loops */
1711       }
1712     }
1713
1714   /* Reached the end of the data without finding \n. Let the loop continue to
1715   read some more, if there is room. */
1716
1717   p = pp;
1718   }
1719
1720 GOT_DATA:
1721
1722 /* We have received a line of data. Check it carefully. It must start with the
1723 same two port numbers that we sent, followed by data as defined by the RFC. For
1724 example,
1725
1726   12345 , 25 : USERID : UNIX :root
1727
1728 However, the amount of white space may be different to what we sent. In the
1729 "osname" field there may be several sub-fields, comma separated. The data we
1730 actually want to save follows the third colon. Some systems put leading spaces
1731 in it - we discard those. */
1732
1733 if (sscanf(CS buffer + qlen, "%d , %d%n", &received_sender_port,
1734       &received_interface_port, &n) != 2 ||
1735     received_sender_port != sender_host_port ||
1736     received_interface_port != interface_port)
1737   goto END_OFF;
1738
1739 p = buffer + qlen + n;
1740 while(isspace(*p)) p++;
1741 if (*p++ != ':') goto END_OFF;
1742 while(isspace(*p)) p++;
1743 if (Ustrncmp(p, "USERID", 6) != 0) goto END_OFF;
1744 p += 6;
1745 while(isspace(*p)) p++;
1746 if (*p++ != ':') goto END_OFF;
1747 while (*p != 0 && *p != ':') p++;
1748 if (*p++ == 0) goto END_OFF;
1749 while(isspace(*p)) p++;
1750 if (*p == 0) goto END_OFF;
1751
1752 /* The rest of the line is the data we want. We turn it into printing
1753 characters when we save it, so that it cannot mess up the format of any logging
1754 or Received: lines into which it gets inserted. We keep a maximum of 127
1755 characters. */
1756
1757 sender_ident = string_printing(string_copyn(p, 127));
1758 DEBUG(D_ident) debug_printf("sender_ident = %s\n", sender_ident);
1759
1760 END_OFF:
1761 close(sock);
1762 return;
1763 }
1764
1765
1766
1767
1768 /*************************************************
1769 *      Match host to a single host-list item     *
1770 *************************************************/
1771
1772 /* This function compares a host (name or address) against a single item
1773 from a host list. The host name gets looked up if it is needed and is not
1774 already known. The function is called from verify_check_this_host() via
1775 match_check_list(), which is why most of its arguments are in a single block.
1776
1777 Arguments:
1778   arg            the argument block (see below)
1779   ss             the host-list item
1780   valueptr       where to pass back looked up data, or NULL
1781   error          for error message when returning ERROR
1782
1783 The block contains:
1784   host_name      the host name or NULL, implying use sender_host_name and
1785                    sender_host_aliases, looking them up if required
1786   host_address   the host address
1787   host_ipv4      the IPv4 address taken from an IPv6 one
1788
1789 Returns:         OK      matched
1790                  FAIL    did not match
1791                  DEFER   lookup deferred
1792                  ERROR   failed to find the host name or IP address
1793                          unknown lookup type specified
1794 */
1795
1796 static int
1797 check_host(void *arg, uschar *ss, uschar **valueptr, uschar **error)
1798 {
1799 check_host_block *cb = (check_host_block *)arg;
1800 int maskoffset;
1801 BOOL isquery = FALSE;
1802 uschar *semicolon, *t;
1803 uschar **aliases;
1804
1805 /* Optimize for the special case when the pattern is "*". */
1806
1807 if (*ss == '*' && ss[1] == 0) return OK;
1808
1809 /* If the pattern is empty, it matches only in the case when there is no host -
1810 this can occur in ACL checking for SMTP input using the -bs option. In this
1811 situation, the host address is the empty string. */
1812
1813 if (cb->host_address[0] == 0) return (*ss == 0)? OK : FAIL;
1814 if (*ss == 0) return FAIL;
1815
1816 /* If the pattern is precisely "@" then match against the primary host name;
1817 if it's "@[]" match against the local host's IP addresses. */
1818
1819 if (*ss == '@')
1820   {
1821   if (ss[1] == 0) ss = primary_hostname;
1822   else if (Ustrcmp(ss, "@[]") == 0)
1823     {
1824     ip_address_item *ip;
1825     for (ip = host_find_interfaces(); ip != NULL; ip = ip->next)
1826       if (Ustrcmp(ip->address, cb->host_address) == 0) return OK;
1827     return FAIL;
1828     }
1829   }
1830
1831 /* If the pattern is an IP address, optionally followed by a bitmask count, do
1832 a (possibly masked) comparision with the current IP address. */
1833
1834 if (string_is_ip_address(ss, &maskoffset) > 0)
1835   return (host_is_in_net(cb->host_address, ss, maskoffset)? OK : FAIL);
1836
1837 /* If the item is of the form net[n]-lookup;<file|query> then it is a lookup on
1838 a masked IP network, in textual form. The net- stuff really only applies to
1839 single-key lookups where the key is implicit. For query-style lookups the key
1840 is specified in the query. From release 4.30, the use of net- for query style
1841 is no longer needed, but we retain it for backward compatibility. */
1842
1843 if (Ustrncmp(ss, "net", 3) == 0 && (semicolon = Ustrchr(ss, ';')) != NULL)
1844   {
1845   int mlen = 0;
1846   for (t = ss + 3; isdigit(*t); t++) mlen = mlen * 10 + *t - '0';
1847   if (*t++ == '-')
1848     {
1849     int insize;
1850     int search_type;
1851     int incoming[4];
1852     void *handle;
1853     uschar *filename, *key, *result;
1854     uschar buffer[64];
1855
1856     /* If no mask was supplied, set a negative value */
1857
1858     if (mlen == 0 && t == ss+4) mlen = -1;
1859
1860     /* Find the search type */
1861
1862     search_type = search_findtype(t, semicolon - t);
1863
1864     if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
1865       search_error_message);
1866
1867     /* Adjust parameters for the type of lookup. For a query-style
1868     lookup, there is no file name, and the "key" is just the query. For
1869     a single-key lookup, the key is the current IP address, masked
1870     appropriately, and reconverted to text form, with the mask appended. 
1871     For IPv6 addresses, specify dot separators instead of colons. */
1872
1873     if (mac_islookup(search_type, lookup_querystyle))
1874       {
1875       filename = NULL;
1876       key = semicolon + 1;
1877       }
1878     else
1879       {
1880       insize = host_aton(cb->host_address, incoming);
1881       host_mask(insize, incoming, mlen);
1882       (void)host_nmtoa(insize, incoming, mlen, buffer, '.');
1883       key = buffer;
1884       filename = semicolon + 1;
1885       }
1886
1887     /* Now do the actual lookup; note that there is no search_close() because
1888     of the caching arrangements. */
1889
1890     handle = search_open(filename, search_type, 0, NULL, NULL);
1891     if (handle == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
1892       search_error_message);
1893     result = search_find(handle, filename, key, -1, NULL, 0, 0, NULL);
1894     if (valueptr != NULL) *valueptr = result;
1895     return (result != NULL)? OK : search_find_defer? DEFER: FAIL;
1896     }
1897   }
1898
1899 /* The pattern is not an IP address or network reference of any kind. That is,
1900 it is a host name pattern. Check the characters of the pattern to see if they
1901 comprise only letters, digits, full stops, and hyphens (the constituents of
1902 domain names). Allow underscores, as they are all too commonly found. Sigh.
1903 Also, if allow_utf8_domains is set, allow top-bit characters. */
1904
1905 for (t = ss; *t != 0; t++)
1906   if (!isalnum(*t) && *t != '.' && *t != '-' && *t != '_' &&
1907       (!allow_utf8_domains || *t < 128)) break;
1908
1909 /* If the pattern is a complete domain name, with no fancy characters, look up
1910 its IP address and match against that. Note that a multi-homed host will add
1911 items to the chain. */
1912
1913 if (*t == 0)
1914   {
1915   int rc;
1916   host_item h;
1917   h.next = NULL;
1918   h.name = ss;
1919   h.address = NULL;
1920   h.mx = MX_NONE;
1921   rc = host_find_byname(&h, NULL, NULL, FALSE);
1922   if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
1923     {
1924     host_item *hh;
1925     for (hh = &h; hh != NULL; hh = hh->next)
1926       {
1927       if (Ustrcmp(hh->address, (Ustrchr(hh->address, ':') == NULL)?
1928         cb->host_ipv4 : cb->host_address) == 0)
1929           return OK;
1930       }
1931     return FAIL;
1932     }
1933   if (rc == HOST_FIND_AGAIN) return DEFER;
1934   *error = string_sprintf("failed to find IP address for %s", ss);
1935   return ERROR;
1936   }
1937
1938 /* Almost all subsequent comparisons require the host name, and can be done
1939 using the general string matching function. When this function is called for
1940 outgoing hosts, the name is always given explicitly. If it is NULL, it means we
1941 must use sender_host_name and its aliases, looking them up if necessary. */
1942
1943 if (cb->host_name != NULL)   /* Explicit host name given */
1944   return match_check_string(cb->host_name, ss, -1, TRUE, TRUE, TRUE,
1945     valueptr);
1946
1947 /* Host name not given; in principle we need the sender host name and its
1948 aliases. However, for query-style lookups, we do not need the name if the
1949 query does not contain $sender_host_name. From release 4.23, a reference to
1950 $sender_host_name causes it to be looked up, so we don't need to do the lookup
1951 on spec. */
1952
1953 if ((semicolon = Ustrchr(ss, ';')) != NULL)
1954   {
1955   uschar *affix;
1956   int partial, affixlen, starflags, id;
1957
1958   *semicolon = 0;
1959   id = search_findtype_partial(ss, &partial, &affix, &affixlen, &starflags);
1960   *semicolon=';';
1961
1962   if (id < 0)                           /* Unknown lookup type */
1963     {
1964     log_write(0, LOG_MAIN|LOG_PANIC, "%s in host list item \"%s\"",
1965       search_error_message, ss);
1966     return DEFER;
1967     }
1968   isquery = mac_islookup(id, lookup_querystyle);
1969   }
1970
1971 if (isquery)
1972   {
1973   switch(match_check_string(US"", ss, -1, TRUE, TRUE, TRUE, valueptr))
1974     {
1975     case OK:    return OK;
1976     case DEFER: return DEFER;
1977     default:    return FAIL;
1978     }
1979   }
1980
1981 /* Not a query-style lookup; must ensure the host name is present, and then we
1982 do a check on the name and all its aliases. */
1983
1984 if (sender_host_name == NULL)
1985   {
1986   HDEBUG(D_host_lookup)
1987     debug_printf("sender host name required, to match against %s\n", ss);
1988   if (host_lookup_failed || host_name_lookup() != OK)
1989     {
1990     *error = string_sprintf("failed to find host name for %s",
1991       sender_host_address);;
1992     return ERROR;
1993     }
1994   host_build_sender_fullhost();
1995   }
1996
1997 /* Match on the sender host name, using the general matching function */
1998
1999 switch(match_check_string(sender_host_name, ss, -1, TRUE, TRUE, TRUE,
2000        valueptr))
2001   {
2002   case OK:    return OK;
2003   case DEFER: return DEFER;
2004   }
2005
2006 /* If there are aliases, try matching on them. */
2007
2008 aliases = sender_host_aliases;
2009 while (*aliases != NULL)
2010   {
2011   switch(match_check_string(*aliases++, ss, -1, TRUE, TRUE, TRUE, valueptr))
2012     {
2013     case OK:    return OK;
2014     case DEFER: return DEFER;
2015     }
2016   }
2017 return FAIL;
2018 }
2019
2020
2021
2022
2023 /*************************************************
2024 *    Check a specific host matches a host list   *
2025 *************************************************/
2026
2027 /* This function is passed a host list containing items in a number of
2028 different formats and the identity of a host. Its job is to determine whether
2029 the given host is in the set of hosts defined by the list. The host name is
2030 passed as a pointer so that it can be looked up if needed and not already
2031 known. This is commonly the case when called from verify_check_host() to check
2032 an incoming connection. When called from elsewhere the host name should usually
2033 be set.
2034
2035 This function is now just a front end to match_check_list(), which runs common
2036 code for scanning a list. We pass it the check_host() function to perform a
2037 single test.
2038
2039 Arguments:
2040   listptr              pointer to the host list
2041   cache_bits           pointer to cache for named lists, or NULL
2042   host_name            the host name or NULL, implying use sender_host_name and
2043                          sender_host_aliases, looking them up if required
2044   host_address         the IP address
2045   valueptr             if not NULL, data from a lookup is passed back here
2046
2047 Returns:    OK    if the host is in the defined set
2048             FAIL  if the host is not in the defined set,
2049             DEFER if a data lookup deferred (not a host lookup)
2050
2051 If the host name was needed in order to make a comparison, and could not be
2052 determined from the IP address, the result is FAIL unless the item
2053 "+allow_unknown" was met earlier in the list, in which case OK is returned. */
2054
2055 int
2056 verify_check_this_host(uschar **listptr, unsigned int *cache_bits,
2057   uschar *host_name, uschar *host_address, uschar **valueptr)
2058 {
2059 int rc;
2060 unsigned int *local_cache_bits = cache_bits;
2061 uschar *save_host_address = deliver_host_address;
2062 check_host_block cb;
2063 cb.host_name = host_name;
2064 cb.host_address = host_address;
2065
2066 if (valueptr != NULL) *valueptr = NULL;
2067
2068 /* If the host address starts off ::ffff: it is an IPv6 address in
2069 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
2070 addresses. */
2071
2072 cb.host_ipv4 = (Ustrncmp(host_address, "::ffff:", 7) == 0)?
2073   host_address + 7 : host_address;
2074
2075 /* During the running of the check, put the IP address into $host_address. In 
2076 the case of calls from the smtp transport, it will already be there. However, 
2077 in other calls (e.g. when testing ignore_target_hosts), it won't. Just to be on 
2078 the safe side, any existing setting is preserved, though as I write this
2079 (November 2004) I can't see any cases where it is actually needed. */
2080
2081 deliver_host_address = host_address;
2082 rc = match_check_list(
2083        listptr,                                /* the list */
2084        0,                                      /* separator character */
2085        &hostlist_anchor,                       /* anchor pointer */
2086        &local_cache_bits,                      /* cache pointer */
2087        check_host,                             /* function for testing */
2088        &cb,                                    /* argument for function */
2089        MCL_HOST,                               /* type of check */
2090        (host_address == sender_host_address)? 
2091          US"host" : host_address,              /* text for debugging */
2092        valueptr);                              /* where to pass back data */
2093 deliver_host_address = save_host_address;
2094 return rc; 
2095 }
2096
2097
2098
2099
2100 /*************************************************
2101 *      Check the remote host matches a list      *
2102 *************************************************/
2103
2104 /* This is a front end to verify_check_this_host(), created because checking
2105 the remote host is a common occurrence. With luck, a good compiler will spot
2106 the tail recursion and optimize it. If there's no host address, this is
2107 command-line SMTP input - check against an empty string for the address.
2108
2109 Arguments:
2110   listptr              pointer to the host list
2111
2112 Returns:               the yield of verify_check_this_host(),
2113                        i.e. OK, FAIL, or DEFER
2114 */
2115
2116 int
2117 verify_check_host(uschar **listptr)
2118 {
2119 return verify_check_this_host(listptr, sender_host_cache, NULL,
2120   (sender_host_address == NULL)? US"" : sender_host_address, NULL);
2121 }
2122
2123
2124
2125
2126
2127 /*************************************************
2128 *    Invert an IP address for a DNS black list   *
2129 *************************************************/
2130
2131 /*
2132 Arguments:
2133   buffer         where to put the answer
2134   address        the address to invert
2135 */
2136
2137 static void
2138 invert_address(uschar *buffer, uschar *address)
2139 {
2140 int bin[4];
2141 uschar *bptr = buffer;
2142
2143 /* If this is an IPv4 address mapped into IPv6 format, adjust the pointer
2144 to the IPv4 part only. */
2145
2146 if (Ustrncmp(address, "::ffff:", 7) == 0) address += 7;
2147
2148 /* Handle IPv4 address: when HAVE_IPV6 is false, the result of host_aton() is
2149 always 1. */
2150
2151 if (host_aton(address, bin) == 1)
2152   {
2153   int i;
2154   int x = bin[0];
2155   for (i = 0; i < 4; i++)
2156     {
2157     sprintf(CS bptr, "%d.", x & 255);
2158     while (*bptr) bptr++;
2159     x >>= 8;
2160     }
2161   }
2162
2163 /* Handle IPv6 address. Actually, as far as I know, there are no IPv6 addresses
2164 in any DNS black lists, and the format in which they will be looked up is
2165 unknown. This is just a guess. */
2166
2167 #if HAVE_IPV6
2168 else
2169   {
2170   int i, j;
2171   for (j = 3; j >= 0; j--)
2172     {
2173     int x = bin[j];
2174     for (i = 0; i < 8; i++)
2175       {
2176       sprintf(CS bptr, "%x.", x & 15);
2177       while (*bptr) bptr++;
2178       x >>= 4;
2179       }
2180     }
2181   }
2182 #endif
2183 }
2184
2185
2186
2187 /*************************************************
2188 *          Perform a single dnsbl lookup         *
2189 *************************************************/
2190
2191 /* This function is called from verify_check_dnsbl() below.
2192
2193 Arguments:
2194   domain         the outer dnsbl domain (for debug message)
2195   keydomain      the current keydomain (for debug message) 
2196   query          the domain to be looked up
2197   iplist         the list of matching IP addresses 
2198   bitmask        true if bitmask matching is wanted 
2199   invert_result  true if result to be inverted 
2200   defer_return   what to return for a defer 
2201
2202 Returns:         OK if lookup succeeded
2203                  FAIL if not
2204 */
2205
2206 static int
2207 one_check_dnsbl(uschar *domain, uschar *keydomain, uschar *query, 
2208   uschar *iplist, BOOL bitmask, BOOL invert_result, int defer_return)
2209 {                
2210 dns_answer dnsa;
2211 dns_scan dnss;
2212 tree_node *t;
2213 dnsbl_cache_block *cb;
2214 int old_pool = store_pool;
2215
2216 /* Look for this query in the cache. */
2217
2218 t = tree_search(dnsbl_cache, query);
2219
2220 /* If not cached from a previous lookup, we must do a DNS lookup, and
2221 cache the result in permanent memory. */
2222
2223 if (t == NULL)
2224   {
2225   store_pool = POOL_PERM;
2226
2227   /* Set up a tree entry to cache the lookup */
2228
2229   t = store_get(sizeof(tree_node) + Ustrlen(query));
2230   Ustrcpy(t->name, query);
2231   t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block));
2232   (void)tree_insertnode(&dnsbl_cache, t);
2233
2234   /* Do the DNS loopup . */
2235
2236   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
2237   cb->rc = dns_basic_lookup(&dnsa, query, T_A);
2238   cb->text_set = FALSE;
2239   cb->text = NULL;
2240   cb->rhs = NULL;
2241
2242   /* If the lookup succeeded, cache the RHS address. The code allows for
2243   more than one address - this was for complete generality and the possible
2244   use of A6 records. However, A6 records have been reduced to experimental
2245   status (August 2001) and may die out. So they may never get used at all,
2246   let alone in dnsbl records. However, leave the code here, just in case.
2247
2248   Quite apart from one A6 RR generating multiple addresses, there are DNS
2249   lists that return more than one A record, so we must handle multiple
2250   addresses generated in that way as well. */
2251
2252   if (cb->rc == DNS_SUCCEED)
2253     {
2254     dns_record *rr;
2255     dns_address **addrp = &(cb->rhs);
2256     for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2257          rr != NULL;
2258          rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2259       {
2260       if (rr->type == T_A)
2261         {
2262         dns_address *da = dns_address_from_rr(&dnsa, rr);
2263         if (da != NULL)
2264           {
2265           *addrp = da;
2266           while (da->next != NULL) da = da->next;
2267           addrp = &(da->next);
2268           }
2269         }
2270       }
2271
2272     /* If we didn't find any A records, change the return code. This can
2273     happen when there is a CNAME record but there are no A records for what
2274     it points to. */
2275
2276     if (cb->rhs == NULL) cb->rc = DNS_NODATA;
2277     }
2278
2279   store_pool = old_pool;
2280   }
2281
2282 /* Previous lookup was cached */
2283
2284 else
2285   {
2286   HDEBUG(D_dnsbl) debug_printf("using result of previous DNS lookup\n");
2287   cb = t->data.ptr;
2288   }
2289
2290 /* We now have the result of the DNS lookup, either newly done, or cached
2291 from a previous call. If the lookup succeeded, check against the address
2292 list if there is one. This may be a positive equality list (introduced by
2293 "="), a negative equality list (introduced by "!="), a positive bitmask
2294 list (introduced by "&"), or a negative bitmask list (introduced by "!&").*/
2295
2296 if (cb->rc == DNS_SUCCEED)
2297   {
2298   dns_address *da = NULL;
2299   uschar *addlist = cb->rhs->address;
2300
2301   /* For A and AAAA records, there may be multiple addresses from multiple
2302   records. For A6 records (currently not expected to be used) there may be
2303   multiple addresses from a single record. */
2304
2305   for (da = cb->rhs->next; da != NULL; da = da->next)
2306     addlist = string_sprintf("%s, %s", addlist, da->address);
2307
2308   HDEBUG(D_dnsbl) debug_printf("DNS lookup for %s succeeded (yielding %s)\n",
2309     query, addlist);
2310
2311   /* Address list check; this can be either for equality, or via a bitmask.
2312   In the latter case, all the bits must match. */
2313
2314   if (iplist != NULL)
2315     {
2316     int ipsep = ',';
2317     uschar ip[46];
2318     uschar *ptr = iplist;
2319
2320     while (string_nextinlist(&ptr, &ipsep, ip, sizeof(ip)) != NULL)
2321       {
2322       /* Handle exact matching */
2323       if (!bitmask)
2324         {
2325         for (da = cb->rhs; da != NULL; da = da->next)
2326           {
2327           if (Ustrcmp(CS da->address, ip) == 0) break;
2328           }
2329         }
2330       /* Handle bitmask matching */
2331       else
2332         {
2333         int address[4];
2334         int mask = 0;
2335
2336         /* At present, all known DNS blocking lists use A records, with
2337         IPv4 addresses on the RHS encoding the information they return. I
2338         wonder if this will linger on as the last vestige of IPv4 when IPv6
2339         is ubiquitous? Anyway, for now we use paranoia code to completely
2340         ignore IPv6 addresses. The default mask is 0, which always matches.
2341         We change this only for IPv4 addresses in the list. */
2342
2343         if (host_aton(ip, address) == 1) mask = address[0];
2344
2345         /* Scan the returned addresses, skipping any that are IPv6 */
2346
2347         for (da = cb->rhs; da != NULL; da = da->next)
2348           {
2349           if (host_aton(da->address, address) != 1) continue;
2350           if ((address[0] & mask) == mask) break;
2351           }
2352         }
2353
2354       /* Break out if a match has been found */
2355
2356       if (da != NULL) break;
2357       }
2358
2359     /* If either
2360
2361        (a) No IP address in a positive list matched, or
2362        (b) An IP address in a negative list did match
2363
2364     then behave as if the DNSBL lookup had not succeeded, i.e. the host is
2365     not on the list. */
2366
2367     if (invert_result != (da == NULL))
2368       {
2369       HDEBUG(D_dnsbl)
2370         {
2371         debug_printf("=> but we are not accepting this block class because\n");
2372         debug_printf("=> there was %s match for %c%s\n",
2373           invert_result? "an exclude":"no", bitmask? '&' : '=', iplist);
2374         }
2375       return FAIL; 
2376       }
2377     }
2378
2379   /* Either there was no IP list, or the record matched. Look up a TXT record
2380   if it hasn't previously been done. */
2381
2382   if (!cb->text_set)
2383     {
2384     cb->text_set = TRUE;
2385     if (dns_basic_lookup(&dnsa, query, T_TXT) == DNS_SUCCEED)
2386       {
2387       dns_record *rr;
2388       for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2389            rr != NULL;
2390            rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2391         if (rr->type == T_TXT) break;
2392       if (rr != NULL)
2393         {
2394         int len = (rr->data)[0];
2395         if (len > 511) len = 127;
2396         store_pool = POOL_PERM;
2397         cb->text = string_sprintf("%.*s", len, (const uschar *)(rr->data+1));
2398         store_pool = old_pool;
2399         }
2400       }
2401     }
2402
2403   dnslist_value = addlist;
2404   dnslist_text = cb->text;
2405   return OK;
2406   }
2407
2408 /* There was a problem with the DNS lookup */
2409
2410 if (cb->rc != DNS_NOMATCH && cb->rc != DNS_NODATA)
2411   {
2412   log_write(L_dnslist_defer, LOG_MAIN,
2413     "DNS list lookup defer (probably timeout) for %s: %s", query,
2414     (defer_return == OK)?   US"assumed in list" :
2415     (defer_return == FAIL)? US"assumed not in list" :
2416                             US"returned DEFER");
2417   return defer_return;
2418   }
2419
2420 /* No entry was found in the DNS; continue for next domain */
2421
2422 HDEBUG(D_dnsbl)
2423   {
2424   debug_printf("DNS lookup for %s failed\n", query);
2425   debug_printf("=> that means %s is not listed at %s\n",
2426      keydomain, domain);
2427   }
2428
2429 return FAIL;
2430 }
2431
2432
2433
2434
2435 /*************************************************
2436 *        Check host against DNS black lists      *
2437 *************************************************/
2438
2439 /* This function runs checks against a list of DNS black lists, until one
2440 matches. Each item on the list can be of the form
2441
2442   domain=ip-address/key
2443
2444 The domain is the right-most domain that is used for the query, for example,
2445 blackholes.mail-abuse.org. If the IP address is present, there is a match only
2446 if the DNS lookup returns a matching IP address. Several addresses may be
2447 given, comma-separated, for example: x.y.z=127.0.0.1,127.0.0.2.
2448
2449 If no key is given, what is looked up in the domain is the inverted IP address
2450 of the current client host. If a key is given, it is used to construct the
2451 domain for the lookup. For example,
2452
2453   dsn.rfc-ignorant.org/$sender_address_domain
2454
2455 After finding a match in the DNS, the domain is placed in $dnslist_domain, and
2456 then we check for a TXT record for an error message, and if found, save its
2457 value in $dnslist_text. We also cache everything in a tree, to optimize
2458 multiple lookups.
2459
2460 Note: an address for testing RBL is 192.203.178.39
2461 Note: an address for testing DUL is 192.203.178.4
2462 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
2463
2464 Arguments:
2465   listptr      the domain/address/data list
2466
2467 Returns:    OK      successful lookup (i.e. the address is on the list), or
2468                       lookup deferred after +include_unknown
2469             FAIL    name not found, or no data found for the given type, or
2470                       lookup deferred after +exclude_unknown (default)
2471             DEFER   lookup failure, if +defer_unknown was set
2472 */
2473
2474 int
2475 verify_check_dnsbl(uschar **listptr)
2476 {
2477 int sep = 0;
2478 int defer_return = FAIL;
2479 BOOL invert_result = FALSE;
2480 uschar *list = *listptr;
2481 uschar *domain;
2482 uschar *s;
2483 uschar buffer[1024];
2484 uschar query[256];         /* DNS domain max length */
2485 uschar revadd[128];        /* Long enough for IPv6 address */
2486
2487 /* Indicate that the inverted IP address is not yet set up */
2488
2489 revadd[0] = 0;
2490
2491 /* In case this is the first time the DNS resolver is being used. */
2492
2493 dns_init(FALSE, FALSE);
2494
2495 /* Loop through all the domains supplied, until something matches */
2496
2497 while ((domain = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
2498   {
2499   int rc;
2500   BOOL frc;
2501   BOOL bitmask = FALSE;
2502   uschar *iplist;
2503   uschar *key;
2504
2505   HDEBUG(D_dnsbl) debug_printf("DNS list check: %s\n", domain);
2506
2507   /* Deal with special values that change the behaviour on defer */
2508
2509   if (domain[0] == '+')
2510     {
2511     if      (strcmpic(domain, US"+include_unknown") == 0) defer_return = OK;
2512     else if (strcmpic(domain, US"+exclude_unknown") == 0) defer_return = FAIL;
2513     else if (strcmpic(domain, US"+defer_unknown") == 0)   defer_return = DEFER;
2514     else
2515       log_write(0, LOG_MAIN|LOG_PANIC, "unknown item in dnslist (ignored): %s",
2516         domain);
2517     continue;
2518     }
2519
2520   /* See if there's explicit data to be looked up */
2521
2522   key = Ustrchr(domain, '/');
2523   if (key != NULL) *key++ = 0;
2524
2525   /* See if there's a list of addresses supplied after the domain name. This is
2526   introduced by an = or a & character; if preceded by ! we invert the result.
2527   */
2528
2529   iplist = Ustrchr(domain, '=');
2530   if (iplist == NULL)
2531     {
2532     bitmask = TRUE;
2533     iplist = Ustrchr(domain, '&');
2534     }
2535
2536   if (iplist != NULL)
2537     {
2538     if (iplist > domain && iplist[-1] == '!')
2539       {
2540       invert_result = TRUE;
2541       iplist[-1] = 0;
2542       }
2543     *iplist++ = 0;
2544     }
2545
2546   /* Check that what we have left is a sensible domain name. There is no reason
2547   why these domains should in fact use the same syntax as hosts and email
2548   domains, but in practice they seem to. However, there is little point in
2549   actually causing an error here, because that would no doubt hold up incoming
2550   mail. Instead, I'll just log it. */
2551
2552   for (s = domain; *s != 0; s++)
2553     {
2554     if (!isalnum(*s) && *s != '-' && *s != '.')
2555       {
2556       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
2557         "strange characters - is this right?", domain);
2558       break;
2559       }
2560     }
2561
2562   /* If there is no key string, construct the query by adding the domain name 
2563   onto the inverted host address, and perform a single DNS lookup. */
2564   
2565   if (key == NULL)
2566     {
2567     if (sender_host_address == NULL) return FAIL;    /* can never match */
2568     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
2569     frc = string_format(query, sizeof(query), "%s%s", revadd, domain);
2570     
2571     if (!frc)
2572       {
2573       log_write(0, LOG_MAIN|LOG_PANIC, "dnslist query is too long "
2574         "(ignored): %s...", query);
2575       continue;
2576       }
2577       
2578     rc = one_check_dnsbl(domain, sender_host_address, query, iplist, bitmask, 
2579       invert_result, defer_return);
2580        
2581     if (rc == OK)
2582       {
2583       dnslist_domain = string_copy(domain);
2584       HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n", 
2585         sender_host_address, domain);
2586       }
2587        
2588     if (rc != FAIL) return rc;     /* OK or DEFER */
2589     }
2590     
2591   /* If there is a key string, it can be a list of domains or IP addresses to 
2592   be concatenated with the main domain. */
2593  
2594   else
2595     {
2596     int keysep = 0;
2597     BOOL defer = FALSE; 
2598     uschar *keydomain; 
2599     uschar keybuffer[256];
2600   
2601     while ((keydomain = string_nextinlist(&key, &keysep, keybuffer, 
2602             sizeof(keybuffer))) != NULL)
2603       {       
2604       if (string_is_ip_address(keydomain, NULL) > 0)
2605         {
2606         uschar keyrevadd[128];
2607         invert_address(keyrevadd, keydomain);
2608         frc = string_format(query, sizeof(query), "%s%s", keyrevadd, domain); 
2609         }
2610       else
2611         { 
2612         frc = string_format(query, sizeof(query), "%s.%s", keydomain, domain);
2613         }
2614
2615       if (!frc)
2616         {
2617         log_write(0, LOG_MAIN|LOG_PANIC, "dnslist query is too long "
2618           "(ignored): %s...", query);
2619         continue;
2620         }
2621         
2622       rc = one_check_dnsbl(domain, keydomain, query, iplist, bitmask, 
2623         invert_result, defer_return);
2624          
2625       if (rc == OK)
2626         {
2627         dnslist_domain = string_copy(domain);
2628         HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n", 
2629           keydomain, domain);
2630         return OK;   
2631         }
2632          
2633       /* If the lookup deferred, remember this fact. We keep trying the rest
2634       of the list to see if we get a useful result, and if we don't, we return
2635       DEFER at the end. */
2636
2637       if (rc == DEFER) defer = TRUE;
2638       }    /* continue with next keystring domain/address */
2639
2640     if (defer) return DEFER;
2641     }  
2642   }        /* continue with next dnsdb outer domain */
2643
2644 return FAIL;
2645 }
2646
2647 /* End of verify.c */