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