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