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