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