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