Debug: fix coding in dnssec reporting. Bug 2205
[exim.git] / src / src / host.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
9242a7e8 5/* Copyright (c) University of Cambridge 1995 - 2017 */
059ec3d9
PH
6/* See the file NOTICE for conditions of use and distribution. */
7
8/* Functions for finding hosts, either by gethostbyname(), gethostbyaddr(), or
9directly via the DNS. When IPv6 is supported, getipnodebyname() and
10getipnodebyaddr() may be used instead of gethostbyname() and gethostbyaddr(),
11if the newer functions are available. This module also contains various other
12functions concerned with hosts and addresses, and a random number function,
13used for randomizing hosts with equal MXs but available for use in other parts
14of Exim. */
15
16
17#include "exim.h"
18
19
20/* Static variable for preserving the list of interface addresses in case it is
21used more than once. */
22
23static ip_address_item *local_interface_data = NULL;
24
25
26#ifdef USE_INET_NTOA_FIX
27/*************************************************
28* Replacement for broken inet_ntoa() *
29*************************************************/
30
31/* On IRIX systems, gcc uses a different structure passing convention to the
32native libraries. This causes inet_ntoa() to always yield 0.0.0.0 or
33255.255.255.255. To get round this, we provide a private version of the
34function here. It is used only if USE_INET_NTOA_FIX is set, which should happen
35only when gcc is in use on an IRIX system. Code send to me by J.T. Breitner,
36with these comments:
37
38 code by Stuart Levy
39 as seen in comp.sys.sgi.admin
40
2548ba04
PH
41August 2005: Apparently this is also needed for AIX systems; USE_INET_NTOA_FIX
42should now be set for them as well.
43
059ec3d9
PH
44Arguments: sa an in_addr structure
45Returns: pointer to static text string
46*/
47
48char *
49inet_ntoa(struct in_addr sa)
50{
51static uschar addr[20];
52sprintf(addr, "%d.%d.%d.%d",
53 (US &sa.s_addr)[0],
54 (US &sa.s_addr)[1],
55 (US &sa.s_addr)[2],
56 (US &sa.s_addr)[3]);
57 return addr;
58}
59#endif
60
61
62
63/*************************************************
64* Random number generator *
65*************************************************/
66
67/* This is a simple pseudo-random number generator. It does not have to be
68very good for the uses to which it is put. When running the regression tests,
69start with a fixed seed.
70
17c76198 71If you need better, see vaguely_random_number() which is potentially stronger,
9e3331ea
TK
72if a crypto library is available, but might end up just calling this instead.
73
059ec3d9
PH
74Arguments:
75 limit: one more than the largest number required
76
77Returns: a pseudo-random number in the range 0 to limit-1
78*/
79
80int
81random_number(int limit)
82{
9e3331ea
TK
83if (limit < 1)
84 return 0;
059ec3d9
PH
85if (random_seed == 0)
86 {
87 if (running_in_test_harness) random_seed = 42; else
88 {
89 int p = (int)getpid();
90 random_seed = (int)time(NULL) ^ ((p << 16) | p);
91 }
92 }
93random_seed = 1103515245 * random_seed + 12345;
94return (unsigned int)(random_seed >> 16) % limit;
95}
96
846430d9
JH
97/*************************************************
98* Wrappers for logging lookup times *
99*************************************************/
100
101/* When the 'slow_lookup_log' variable is enabled, these wrappers will
102write to the log file all (potential) dns lookups that take more than
103slow_lookup_log milliseconds
104*/
105
106static void
107log_long_lookup(const uschar * type, const uschar * data, unsigned long msec)
108{
109log_write(0, LOG_MAIN, "Long %s lookup for '%s': %lu msec",
110 type, data, msec);
111}
112
113
114/* returns the current system epoch time in milliseconds. */
115static unsigned long
116get_time_in_ms()
117{
118struct timeval tmp_time;
119unsigned long seconds, microseconds;
120
121gettimeofday(&tmp_time, NULL);
122seconds = (unsigned long) tmp_time.tv_sec;
123microseconds = (unsigned long) tmp_time.tv_usec;
124return seconds*1000 + microseconds/1000;
125}
126
127
128static int
129dns_lookup_timerwrap(dns_answer *dnsa, const uschar *name, int type,
130 const uschar **fully_qualified_name)
131{
132int retval;
133unsigned long time_msec;
134
135if (!slow_lookup_log)
136 return dns_lookup(dnsa, name, type, fully_qualified_name);
137
138time_msec = get_time_in_ms();
139retval = dns_lookup(dnsa, name, type, fully_qualified_name);
140if ((time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
141 log_long_lookup(US"name", name, time_msec);
142return retval;
143}
059ec3d9
PH
144
145
146/*************************************************
e7726cbf
PH
147* Replace gethostbyname() when testing *
148*************************************************/
149
150/* This function is called instead of gethostbyname(), gethostbyname2(), or
1fb7660f 151getipnodebyname() when running in the test harness. . It also
7a546ad5
PH
152recognizes an unqualified "localhost" and forces it to the appropriate loopback
153address. IP addresses are treated as literals. For other names, it uses the DNS
75e0e026
PH
154to find the host name. In the test harness, this means it will access only the
155fake DNS resolver.
e7726cbf
PH
156
157Arguments:
158 name the host name or a textual IP address
159 af AF_INET or AF_INET6
160 error_num where to put an error code:
161 HOST_NOT_FOUND/TRY_AGAIN/NO_RECOVERY/NO_DATA
162
163Returns: a hostent structure or NULL for an error
164*/
165
166static struct hostent *
55414b25 167host_fake_gethostbyname(const uschar *name, int af, int *error_num)
e7726cbf 168{
70d67ad3 169#if HAVE_IPV6
e7726cbf 170int alen = (af == AF_INET)? sizeof(struct in_addr):sizeof(struct in6_addr);
70d67ad3
PH
171#else
172int alen = sizeof(struct in_addr);
173#endif
174
175int ipa;
55414b25 176const uschar *lname = name;
e7726cbf
PH
177uschar *adds;
178uschar **alist;
179struct hostent *yield;
180dns_answer dnsa;
181dns_scan dnss;
182dns_record *rr;
183
184DEBUG(D_host_lookup)
185 debug_printf("using host_fake_gethostbyname for %s (%s)\n", name,
186 (af == AF_INET)? "IPv4" : "IPv6");
187
7a546ad5
PH
188/* Handle unqualified "localhost" */
189
e7726cbf
PH
190if (Ustrcmp(name, "localhost") == 0)
191 lname = (af == AF_INET)? US"127.0.0.1" : US"::1";
192
193/* Handle a literal IP address */
194
195ipa = string_is_ip_address(lname, NULL);
196if (ipa != 0)
197 {
198 if ((ipa == 4 && af == AF_INET) ||
199 (ipa == 6 && af == AF_INET6))
200 {
201 int i, n;
202 int x[4];
203 yield = store_get(sizeof(struct hostent));
204 alist = store_get(2 * sizeof(char *));
205 adds = store_get(alen);
206 yield->h_name = CS name;
207 yield->h_aliases = NULL;
208 yield->h_addrtype = af;
209 yield->h_length = alen;
210 yield->h_addr_list = CSS alist;
211 *alist++ = adds;
212 n = host_aton(lname, x);
213 for (i = 0; i < n; i++)
214 {
215 int y = x[i];
216 *adds++ = (y >> 24) & 255;
217 *adds++ = (y >> 16) & 255;
218 *adds++ = (y >> 8) & 255;
219 *adds++ = y & 255;
220 }
221 *alist = NULL;
222 }
223
224 /* Wrong kind of literal address */
225
226 else
227 {
228 *error_num = HOST_NOT_FOUND;
229 return NULL;
230 }
231 }
232
233/* Handle a host name */
234
235else
236 {
237 int type = (af == AF_INET)? T_A:T_AAAA;
846430d9 238 int rc = dns_lookup_timerwrap(&dnsa, lname, type, NULL);
e7726cbf
PH
239 int count = 0;
240
4e0983dc
JH
241 lookup_dnssec_authenticated = NULL;
242
e7726cbf
PH
243 switch(rc)
244 {
245 case DNS_SUCCEED: break;
246 case DNS_NOMATCH: *error_num = HOST_NOT_FOUND; return NULL;
247 case DNS_NODATA: *error_num = NO_DATA; return NULL;
248 case DNS_AGAIN: *error_num = TRY_AGAIN; return NULL;
249 default:
250 case DNS_FAIL: *error_num = NO_RECOVERY; return NULL;
251 }
252
253 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
e1a3f32f 254 rr;
e7726cbf 255 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
e1a3f32f
JH
256 if (rr->type == type)
257 count++;
e7726cbf
PH
258
259 yield = store_get(sizeof(struct hostent));
96f5fe4c 260 alist = store_get((count + 1) * sizeof(char *));
e7726cbf
PH
261 adds = store_get(count *alen);
262
263 yield->h_name = CS name;
264 yield->h_aliases = NULL;
265 yield->h_addrtype = af;
266 yield->h_length = alen;
267 yield->h_addr_list = CSS alist;
268
269 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
e1a3f32f 270 rr;
e7726cbf
PH
271 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
272 {
273 int i, n;
274 int x[4];
275 dns_address *da;
276 if (rr->type != type) continue;
e1a3f32f 277 if (!(da = dns_address_from_rr(&dnsa, rr))) break;
e7726cbf
PH
278 *alist++ = adds;
279 n = host_aton(da->address, x);
280 for (i = 0; i < n; i++)
281 {
282 int y = x[i];
283 *adds++ = (y >> 24) & 255;
284 *adds++ = (y >> 16) & 255;
285 *adds++ = (y >> 8) & 255;
286 *adds++ = y & 255;
287 }
288 }
289 *alist = NULL;
290 }
291
292return yield;
293}
294
295
296
297/*************************************************
059ec3d9
PH
298* Build chain of host items from list *
299*************************************************/
300
301/* This function builds a chain of host items from a textual list of host
302names. It does not do any lookups. If randomize is true, the chain is build in
303a randomized order. There may be multiple groups of independently randomized
304hosts; they are delimited by a host name consisting of just "+".
305
306Arguments:
307 anchor anchor for the chain
308 list text list
309 randomize TRUE for randomizing
310
311Returns: nothing
312*/
313
314void
55414b25 315host_build_hostlist(host_item **anchor, const uschar *list, BOOL randomize)
059ec3d9
PH
316{
317int sep = 0;
318int fake_mx = MX_NONE; /* This value is actually -1 */
319uschar *name;
059ec3d9
PH
320
321if (list == NULL) return;
322if (randomize) fake_mx--; /* Start at -2 for randomizing */
323
324*anchor = NULL;
325
55414b25 326while ((name = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
059ec3d9
PH
327 {
328 host_item *h;
329
330 if (name[0] == '+' && name[1] == 0) /* "+" delimits a randomized group */
331 { /* ignore if not randomizing */
332 if (randomize) fake_mx--;
333 continue;
334 }
335
336 h = store_get(sizeof(host_item));
55414b25 337 h->name = name;
059ec3d9
PH
338 h->address = NULL;
339 h->port = PORT_NONE;
340 h->mx = fake_mx;
341 h->sort_key = randomize? (-fake_mx)*1000 + random_number(1000) : 0;
342 h->status = hstatus_unknown;
343 h->why = hwhy_unknown;
344 h->last_try = 0;
345
346 if (*anchor == NULL)
347 {
348 h->next = NULL;
349 *anchor = h;
350 }
351 else
352 {
353 host_item *hh = *anchor;
354 if (h->sort_key < hh->sort_key)
355 {
356 h->next = hh;
357 *anchor = h;
358 }
359 else
360 {
361 while (hh->next != NULL && h->sort_key >= (hh->next)->sort_key)
362 hh = hh->next;
363 h->next = hh->next;
364 hh->next = h;
365 }
366 }
367 }
368}
369
370
371
372
373
374/*************************************************
375* Extract port from address string *
376*************************************************/
377
378/* In the spool file, and in the -oMa and -oMi options, a host plus port is
379given as an IP address followed by a dot and a port number. This function
380decodes this.
381
382An alternative format for the -oMa and -oMi options is [ip address]:port which
383is what Exim 4 uses for output, because it seems to becoming commonly used,
384whereas the dot form confuses some programs/people. So we recognize that form
385too.
386
387Argument:
388 address points to the string; if there is a port, the '.' in the string
389 is overwritten with zero to terminate the address; if the string
390 is in the [xxx]:ppp format, the address is shifted left and the
391 brackets are removed
392
393Returns: 0 if there is no port, else the port number. If there's a syntax
394 error, leave the incoming address alone, and return 0.
395*/
396
397int
7cd1141b 398host_address_extract_port(uschar *address)
059ec3d9
PH
399{
400int port = 0;
401uschar *endptr;
402
403/* Handle the "bracketed with colon on the end" format */
404
405if (*address == '[')
406 {
407 uschar *rb = address + 1;
408 while (*rb != 0 && *rb != ']') rb++;
409 if (*rb++ == 0) return 0; /* Missing ]; leave invalid address */
410 if (*rb == ':')
411 {
412 port = Ustrtol(rb + 1, &endptr, 10);
413 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
414 }
415 else if (*rb != 0) return 0; /* Bad syntax; leave invalid address */
416 memmove(address, address + 1, rb - address - 2);
417 rb[-2] = 0;
418 }
419
420/* Handle the "dot on the end" format */
421
422else
423 {
424 int skip = -3; /* Skip 3 dots in IPv4 addresses */
425 address--;
426 while (*(++address) != 0)
427 {
428 int ch = *address;
429 if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */
430 else if (ch == '.' && skip++ >= 0) break;
431 }
432 if (*address == 0) return 0;
433 port = Ustrtol(address + 1, &endptr, 10);
434 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
435 *address = 0;
436 }
437
438return port;
439}
440
441
7cd1141b
PH
442/*************************************************
443* Get port from a host item's name *
444*************************************************/
445
446/* This function is called when finding the IP address for a host that is in a
447list of hosts explicitly configured, such as in the manualroute router, or in a
448fallback hosts list. We see if there is a port specification at the end of the
449host name, and if so, remove it. A minimum length of 3 is required for the
450original name; nothing shorter is recognized as having a port.
451
452We test for a name ending with a sequence of digits; if preceded by colon we
453have a port if the character before the colon is ] and the name starts with [
454or if there are no other colons in the name (i.e. it's not an IPv6 address).
455
456Arguments: pointer to the host item
457Returns: a port number or PORT_NONE
458*/
459
460int
461host_item_get_port(host_item *h)
462{
55414b25 463const uschar *p;
7cd1141b
PH
464int port, x;
465int len = Ustrlen(h->name);
466
467if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
468
469/* Extract potential port number */
470
471port = *p-- - '0';
472x = 10;
473
474while (p > h->name + 1 && isdigit(*p))
475 {
476 port += (*p-- - '0') * x;
477 x *= 10;
478 }
479
480/* The smallest value of p at this point is h->name + 1. */
481
482if (*p != ':') return PORT_NONE;
483
484if (p[-1] == ']' && h->name[0] == '[')
485 h->name = string_copyn(h->name + 1, p - h->name - 2);
486else if (Ustrchr(h->name, ':') == p)
487 h->name = string_copyn(h->name, p - h->name);
488else return PORT_NONE;
489
490DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
491return port;
492}
493
494
059ec3d9
PH
495
496#ifndef STAND_ALONE /* Omit when standalone testing */
497
498/*************************************************
499* Build sender_fullhost and sender_rcvhost *
500*************************************************/
501
502/* This function is called when sender_host_name and/or sender_helo_name
503have been set. Or might have been set - for a local message read off the spool
504they won't be. In that case, do nothing. Otherwise, set up the fullhost string
505as follows:
506
507(a) No sender_host_name or sender_helo_name: "[ip address]"
508(b) Just sender_host_name: "host_name [ip address]"
82c19f95
PH
509(c) Just sender_helo_name: "(helo_name) [ip address]" unless helo is IP
510 in which case: "[ip address}"
511(d) The two are identical: "host_name [ip address]" includes helo = IP
059ec3d9
PH
512(e) The two are different: "host_name (helo_name) [ip address]"
513
514If log_incoming_port is set, the sending host's port number is added to the IP
515address.
516
517This function also builds sender_rcvhost for use in Received: lines, whose
518syntax is a bit different. This value also includes the RFC 1413 identity.
519There wouldn't be two different variables if I had got all this right in the
520first place.
521
522Because this data may survive over more than one incoming SMTP message, it has
523to be in permanent store.
524
525Arguments: none
526Returns: nothing
527*/
528
529void
530host_build_sender_fullhost(void)
531{
82c19f95 532BOOL show_helo = TRUE;
059ec3d9 533uschar *address;
82c19f95 534int len;
059ec3d9
PH
535int old_pool = store_pool;
536
537if (sender_host_address == NULL) return;
538
539store_pool = POOL_PERM;
540
541/* Set up address, with or without the port. After discussion, it seems that
542the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
543use this directly as the first item for Received: because it ain't an RFC 2822
544domain. Sigh. */
545
546address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
6c6d6e48 547if (!LOGGING(incoming_port) || sender_host_port <= 0)
059ec3d9
PH
548 *(Ustrrchr(address, ':')) = 0;
549
82c19f95
PH
550/* If there's no EHLO/HELO data, we can't show it. */
551
552if (sender_helo_name == NULL) show_helo = FALSE;
553
554/* If HELO/EHLO was followed by an IP literal, it's messy because of two
555features of IPv6. Firstly, there's the "IPv6:" prefix (Exim is liberal and
556doesn't require this, for historical reasons). Secondly, IPv6 addresses may not
4c04137d 557be given in canonical form, so we have to canonicalize them before comparing. As
82c19f95
PH
558it happens, the code works for both IPv4 and IPv6. */
559
560else if (sender_helo_name[0] == '[' &&
561 sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']')
562 {
563 int offset = 1;
564 uschar *helo_ip;
565
566 if (strncmpic(sender_helo_name + 1, US"IPv6:", 5) == 0) offset += 5;
567 if (strncmpic(sender_helo_name + 1, US"IPv4:", 5) == 0) offset += 5;
568
569 helo_ip = string_copyn(sender_helo_name + offset, len - offset - 1);
570
571 if (string_is_ip_address(helo_ip, NULL) != 0)
572 {
573 int x[4], y[4];
574 int sizex, sizey;
575 uschar ipx[48], ipy[48]; /* large enough for full IPv6 */
576
577 sizex = host_aton(helo_ip, x);
578 sizey = host_aton(sender_host_address, y);
579
580 (void)host_nmtoa(sizex, x, -1, ipx, ':');
581 (void)host_nmtoa(sizey, y, -1, ipy, ':');
582
583 if (strcmpic(ipx, ipy) == 0) show_helo = FALSE;
584 }
585 }
586
059ec3d9
PH
587/* Host name is not verified */
588
acec9514 589if (!sender_host_name)
059ec3d9
PH
590 {
591 uschar *portptr = Ustrstr(address, "]:");
acec9514 592 gstring * g;
059ec3d9
PH
593 int adlen; /* Sun compiler doesn't like ++ in initializers */
594
acec9514
JH
595 adlen = portptr ? (++portptr - address) : Ustrlen(address);
596 sender_fullhost = sender_helo_name
597 ? string_sprintf("(%s) %s", sender_helo_name, address)
598 : address;
059ec3d9 599
acec9514 600 g = string_catn(NULL, address, adlen);
059ec3d9 601
82c19f95 602 if (sender_ident != NULL || show_helo || portptr != NULL)
059ec3d9
PH
603 {
604 int firstptr;
acec9514
JH
605 g = string_catn(g, US" (", 2);
606 firstptr = g->ptr;
059ec3d9 607
acec9514
JH
608 if (portptr)
609 g = string_append(g, 2, US"port=", portptr + 1);
059ec3d9 610
82c19f95 611 if (show_helo)
acec9514
JH
612 g = string_append(g, 2,
613 firstptr == g->ptr ? US"helo=" : US" helo=", sender_helo_name);
059ec3d9 614
acec9514
JH
615 if (sender_ident)
616 g = string_append(g, 2,
617 firstptr == g->ptr ? US"ident=" : US" ident=", sender_ident);
059ec3d9 618
acec9514 619 g = string_catn(g, US")", 1);
059ec3d9
PH
620 }
621
acec9514 622 sender_rcvhost = string_from_gstring(g);
059ec3d9
PH
623
624 /* Release store, because string_cat allocated a minimum of 100 bytes that
625 are rarely completely used. */
626
acec9514 627 store_reset(sender_rcvhost + g->ptr + 1);
059ec3d9
PH
628 }
629
82c19f95
PH
630/* Host name is known and verified. Unless we've already found that the HELO
631data matches the IP address, compare it with the name. */
059ec3d9
PH
632
633else
634 {
82c19f95
PH
635 if (show_helo && strcmpic(sender_host_name, sender_helo_name) == 0)
636 show_helo = FALSE;
5dd9625b 637
82c19f95 638 if (show_helo)
059ec3d9
PH
639 {
640 sender_fullhost = string_sprintf("%s (%s) %s", sender_host_name,
641 sender_helo_name, address);
642 sender_rcvhost = (sender_ident == NULL)?
643 string_sprintf("%s (%s helo=%s)", sender_host_name,
644 address, sender_helo_name) :
645 string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
646 address, sender_helo_name, sender_ident);
647 }
82c19f95
PH
648 else
649 {
650 sender_fullhost = string_sprintf("%s %s", sender_host_name, address);
651 sender_rcvhost = (sender_ident == NULL)?
652 string_sprintf("%s (%s)", sender_host_name, address) :
653 string_sprintf("%s (%s ident=%s)", sender_host_name, address,
654 sender_ident);
655 }
059ec3d9
PH
656 }
657
658store_pool = old_pool;
659
660DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
661DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
662}
663
664
665
666/*************************************************
667* Build host+ident message *
668*************************************************/
669
670/* Used when logging rejections and various ACL and SMTP incidents. The text
671return depends on whether sender_fullhost and sender_ident are set or not:
672
673 no ident, no host => U=unknown
674 no ident, host set => H=sender_fullhost
675 ident set, no host => U=ident
676 ident set, host set => H=sender_fullhost U=ident
677
678Arguments:
679 useflag TRUE if first item to be flagged (H= or U=); if there are two
680 items, the second is always flagged
681
682Returns: pointer to a string in big_buffer
683*/
684
685uschar *
686host_and_ident(BOOL useflag)
687{
688if (sender_fullhost == NULL)
689 {
690 (void)string_format(big_buffer, big_buffer_size, "%s%s", useflag? "U=" : "",
691 (sender_ident == NULL)? US"unknown" : sender_ident);
692 }
693else
694 {
695 uschar *flag = useflag? US"H=" : US"";
696 uschar *iface = US"";
6c6d6e48 697 if (LOGGING(incoming_interface) && interface_address != NULL)
059ec3d9
PH
698 iface = string_sprintf(" I=[%s]:%d", interface_address, interface_port);
699 if (sender_ident == NULL)
700 (void)string_format(big_buffer, big_buffer_size, "%s%s%s",
701 flag, sender_fullhost, iface);
702 else
703 (void)string_format(big_buffer, big_buffer_size, "%s%s%s U=%s",
704 flag, sender_fullhost, iface, sender_ident);
705 }
706return big_buffer;
707}
708
709#endif /* STAND_ALONE */
710
711
712
713
714/*************************************************
715* Build list of local interfaces *
716*************************************************/
717
718/* This function interprets the contents of the local_interfaces or
719extra_local_interfaces options, and creates an ip_address_item block for each
720item on the list. There is no special interpretation of any IP addresses; in
721particular, 0.0.0.0 and ::0 are returned without modification. If any address
722includes a port, it is set in the block. Otherwise the port value is set to
723zero.
724
725Arguments:
726 list the list
727 name the name of the option being expanded
728
729Returns: a chain of ip_address_items, each containing to a textual
730 version of an IP address, and a port number (host order) or
731 zero if no port was given with the address
732*/
733
734ip_address_item *
55414b25 735host_build_ifacelist(const uschar *list, uschar *name)
059ec3d9
PH
736{
737int sep = 0;
738uschar *s;
b891534f 739ip_address_item * yield = NULL, * last = NULL, * next;
059ec3d9 740
b891534f 741while ((s = string_nextinlist(&list, &sep, NULL, 0)))
059ec3d9 742 {
7e66e54d 743 int ipv;
7cd1141b 744 int port = host_address_extract_port(s); /* Leaves just the IP address */
b891534f
JH
745
746 if (!(ipv = string_is_ip_address(s, NULL)))
059ec3d9
PH
747 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
748 s, name);
749
7e66e54d
PH
750 /* Skip IPv6 addresses if IPv6 is disabled. */
751
752 if (disable_ipv6 && ipv == 6) continue;
753
059ec3d9
PH
754 /* This use of strcpy() is OK because we have checked that s is a valid IP
755 address above. The field in the ip_address_item is large enough to hold an
756 IPv6 address. */
757
758 next = store_get(sizeof(ip_address_item));
759 next->next = NULL;
760 Ustrcpy(next->address, s);
761 next->port = port;
762 next->v6_include_v4 = FALSE;
763
b891534f
JH
764 if (!yield)
765 yield = last = next;
766 else
059ec3d9
PH
767 {
768 last->next = next;
769 last = next;
770 }
771 }
772
773return yield;
774}
775
776
777
778
779
780/*************************************************
781* Find addresses on local interfaces *
782*************************************************/
783
784/* This function finds the addresses of local IP interfaces. These are used
785when testing for routing to the local host. As the function may be called more
786than once, the list is preserved in permanent store, pointed to by a static
787variable, to save doing the work more than once per process.
788
789The generic list of interfaces is obtained by calling host_build_ifacelist()
790for local_interfaces and extra_local_interfaces. This list scanned to remove
791duplicates (which may exist with different ports - not relevant here). If
792either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
793replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
794obtained from os_find_running_interfaces().
795
796Arguments: none
797Returns: a chain of ip_address_items, each containing to a textual
798 version of an IP address; the port numbers are not relevant
799*/
800
801
802/* First, a local subfunction to add an interface to a list in permanent store,
803but only if there isn't a previous copy of that address on the list. */
804
805static ip_address_item *
806add_unique_interface(ip_address_item *list, ip_address_item *ipa)
807{
808ip_address_item *ipa2;
809for (ipa2 = list; ipa2 != NULL; ipa2 = ipa2->next)
810 if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
811ipa2 = store_get_perm(sizeof(ip_address_item));
812*ipa2 = *ipa;
813ipa2->next = list;
814return ipa2;
815}
816
817
818/* This is the globally visible function */
819
820ip_address_item *
821host_find_interfaces(void)
822{
823ip_address_item *running_interfaces = NULL;
824
825if (local_interface_data == NULL)
826 {
827 void *reset_item = store_get(0);
55414b25 828 ip_address_item *dlist = host_build_ifacelist(CUS local_interfaces,
059ec3d9 829 US"local_interfaces");
55414b25 830 ip_address_item *xlist = host_build_ifacelist(CUS extra_local_interfaces,
059ec3d9
PH
831 US"extra_local_interfaces");
832 ip_address_item *ipa;
833
834 if (dlist == NULL) dlist = xlist; else
835 {
836 for (ipa = dlist; ipa->next != NULL; ipa = ipa->next);
837 ipa->next = xlist;
838 }
839
840 for (ipa = dlist; ipa != NULL; ipa = ipa->next)
841 {
842 if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
843 Ustrcmp(ipa->address, "::0") == 0)
844 {
845 ip_address_item *ipa2;
846 BOOL ipv6 = ipa->address[0] == ':';
847 if (running_interfaces == NULL)
848 running_interfaces = os_find_running_interfaces();
849 for (ipa2 = running_interfaces; ipa2 != NULL; ipa2 = ipa2->next)
850 {
851 if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
852 local_interface_data = add_unique_interface(local_interface_data,
853 ipa2);
854 }
855 }
856 else
857 {
858 local_interface_data = add_unique_interface(local_interface_data, ipa);
859 DEBUG(D_interface)
860 {
861 debug_printf("Configured local interface: address=%s", ipa->address);
862 if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
863 debug_printf("\n");
864 }
865 }
866 }
867 store_reset(reset_item);
868 }
869
870return local_interface_data;
871}
872
873
874
875
876
877/*************************************************
878* Convert network IP address to text *
879*************************************************/
880
881/* Given an IPv4 or IPv6 address in binary, convert it to a text
882string and return the result in a piece of new store. The address can
883either be given directly, or passed over in a sockaddr structure. Note
884that this isn't the converse of host_aton() because of byte ordering
885differences. See host_nmtoa() below.
886
887Arguments:
888 type if < 0 then arg points to a sockaddr, else
889 either AF_INET or AF_INET6
890 arg points to a sockaddr if type is < 0, or
891 points to an IPv4 address (32 bits), or
892 points to an IPv6 address (128 bits),
893 in both cases, in network byte order
894 buffer if NULL, the result is returned in gotten store;
895 else points to a buffer to hold the answer
896 portptr points to where to put the port number, if non NULL; only
897 used when type < 0
898
899Returns: pointer to character string
900*/
901
902uschar *
903host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
904{
905uschar *yield;
906
907/* The new world. It is annoying that we have to fish out the address from
908different places in the block, depending on what kind of address it is. It
909is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
910function inet_ntoa() returns just uschar *, and some picky compilers insist
911on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
912
913#if HAVE_IPV6
914uschar addr_buffer[46];
915if (type < 0)
916 {
917 int family = ((struct sockaddr *)arg)->sa_family;
918 if (family == AF_INET6)
919 {
920 struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
5903c6ff 921 yield = US inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
059ec3d9
PH
922 sizeof(addr_buffer));
923 if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
924 }
925 else
926 {
927 struct sockaddr_in *sk = (struct sockaddr_in *)arg;
5903c6ff 928 yield = US inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
059ec3d9
PH
929 sizeof(addr_buffer));
930 if (portptr != NULL) *portptr = ntohs(sk->sin_port);
931 }
932 }
933else
934 {
5903c6ff 935 yield = US inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
059ec3d9
PH
936 }
937
938/* If the result is a mapped IPv4 address, show it in V4 format. */
939
940if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
941
942#else /* HAVE_IPV6 */
943
944/* The old world */
945
946if (type < 0)
947 {
948 yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
949 if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
950 }
951else
952 yield = US inet_ntoa(*((struct in_addr *)arg));
953#endif
954
955/* If there is no buffer, put the string into some new store. */
956
957if (buffer == NULL) return string_copy(yield);
958
959/* Callers of this function with a non-NULL buffer must ensure that it is
960large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
961makes this use of strcpy() OK. */
962
963Ustrcpy(buffer, yield);
964return buffer;
965}
966
967
968
969
970/*************************************************
971* Convert address text to binary *
972*************************************************/
973
974/* Given the textual form of an IP address, convert it to binary in an
975array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
976The result has the first byte in the most significant byte of the first int. In
977other words, the result is not in network byte order, but in host byte order.
978As a result, this is not the converse of host_ntoa(), which expects network
979byte order. See host_nmtoa() below.
980
981Arguments:
982 address points to the textual address, checked for syntax
983 bin points to an array of 4 ints
984
985Returns: the number of ints used
986*/
987
988int
55414b25 989host_aton(const uschar *address, int *bin)
059ec3d9
PH
990{
991int x[4];
992int v4offset = 0;
993
8e669ac1 994/* Handle IPv6 address, which may end with an IPv4 address. It may also end
7e634d24
PH
995with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
996HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
997supported. */
059ec3d9
PH
998
999if (Ustrchr(address, ':') != NULL)
1000 {
55414b25
JH
1001 const uschar *p = address;
1002 const uschar *component[8];
059ec3d9
PH
1003 BOOL ipv4_ends = FALSE;
1004 int ci = 0;
1005 int nulloffset = 0;
1006 int v6count = 8;
1007 int i;
1008
1009 /* If the address starts with a colon, it will start with two colons.
1010 Just lose the first one, which will leave a null first component. */
8e669ac1 1011
059ec3d9
PH
1012 if (*p == ':') p++;
1013
8e669ac1
PH
1014 /* Split the address into components separated by colons. The input address
1015 is supposed to be checked for syntax. There was a case where this was
1016 overlooked; to guard against that happening again, check here and crash if
7e634d24 1017 there are too many components. */
059ec3d9 1018
7e634d24 1019 while (*p != 0 && *p != '%')
059ec3d9 1020 {
7e634d24 1021 int len = Ustrcspn(p, ":%");
059ec3d9 1022 if (len == 0) nulloffset = ci;
8e669ac1 1023 if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
b975ba52 1024 "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
8e669ac1 1025 address);
059ec3d9
PH
1026 component[ci++] = p;
1027 p += len;
1028 if (*p == ':') p++;
1029 }
1030
1031 /* If the final component contains a dot, it is a trailing v4 address.
1032 As the syntax is known to be checked, just set up for a trailing
1033 v4 address and restrict the v6 part to 6 components. */
1034
1035 if (Ustrchr(component[ci-1], '.') != NULL)
1036 {
1037 address = component[--ci];
1038 ipv4_ends = TRUE;
1039 v4offset = 3;
1040 v6count = 6;
1041 }
1042
1043 /* If there are fewer than 6 or 8 components, we have to insert some
1044 more empty ones in the middle. */
1045
1046 if (ci < v6count)
1047 {
1048 int insert_count = v6count - ci;
1049 for (i = v6count-1; i > nulloffset + insert_count; i--)
1050 component[i] = component[i - insert_count];
1051 while (i > nulloffset) component[i--] = US"";
1052 }
1053
1054 /* Now turn the components into binary in pairs and bung them
1055 into the vector of ints. */
1056
1057 for (i = 0; i < v6count; i += 2)
1058 bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
1059 Ustrtol(component[i+1], NULL, 16);
1060
1061 /* If there was no terminating v4 component, we are done. */
1062
1063 if (!ipv4_ends) return 4;
1064 }
1065
1066/* Handle IPv4 address */
1067
ff790e47 1068(void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
13559da6 1069bin[v4offset] = ((uint)x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
059ec3d9
PH
1070return v4offset+1;
1071}
1072
1073
1074/*************************************************
1075* Apply mask to an IP address *
1076*************************************************/
1077
1078/* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
1079first int, etc.
1080
1081Arguments:
1082 count the number of ints
1083 binary points to the ints to be masked
1084 mask the count of ms bits to leave, or -1 if no masking
1085
1086Returns: nothing
1087*/
1088
1089void
1090host_mask(int count, int *binary, int mask)
1091{
1092int i;
1093if (mask < 0) mask = 99999;
1094for (i = 0; i < count; i++)
1095 {
1096 int wordmask;
1097 if (mask == 0) wordmask = 0;
1098 else if (mask < 32)
1099 {
13559da6 1100 wordmask = (uint)(-1) << (32 - mask);
059ec3d9
PH
1101 mask = 0;
1102 }
1103 else
1104 {
1105 wordmask = -1;
1106 mask -= 32;
1107 }
1108 binary[i] &= wordmask;
1109 }
1110}
1111
1112
1113
1114
1115/*************************************************
1116* Convert masked IP address in ints to text *
1117*************************************************/
1118
1119/* We can't use host_ntoa() because it assumes the binary values are in network
1120byte order, and these are the result of host_aton(), which puts them in ints in
1121host byte order. Also, we really want IPv6 addresses to be in a canonical
6f0c9a4f
PH
1122format, so we output them with no abbreviation. In a number of cases we can't
1123use the normal colon separator in them because it terminates keys in lsearch
8e669ac1 1124files, so we want to use dot instead. There's an argument that specifies what
6f0c9a4f 1125to use for IPv6 addresses.
059ec3d9
PH
1126
1127Arguments:
1128 count 1 or 4 (number of ints)
1129 binary points to the ints
1130 mask mask value; if < 0 don't add to result
1131 buffer big enough to hold the result
8e669ac1 1132 sep component separator character for IPv6 addresses
059ec3d9
PH
1133
1134Returns: the number of characters placed in buffer, not counting
1135 the final nul.
1136*/
1137
1138int
6f0c9a4f 1139host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
059ec3d9
PH
1140{
1141int i, j;
1142uschar *tt = buffer;
1143
1144if (count == 1)
1145 {
1146 j = binary[0];
1147 for (i = 24; i >= 0; i -= 8)
fc4a7f70 1148 tt += sprintf(CS tt, "%d.", (j >> i) & 255);
059ec3d9
PH
1149 }
1150else
059ec3d9
PH
1151 for (i = 0; i < 4; i++)
1152 {
1153 j = binary[i];
fc4a7f70 1154 tt += sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
059ec3d9 1155 }
059ec3d9 1156
6f0c9a4f 1157tt--; /* lose final separator */
059ec3d9
PH
1158
1159if (mask < 0)
1160 *tt = 0;
1161else
5976eb99 1162 tt += sprintf(CS tt, "/%d", mask);
059ec3d9
PH
1163
1164return tt - buffer;
1165}
1166
1167
fc4a7f70
JH
1168/* Like host_nmtoa() but: ipv6-only, canonical output, no mask
1169
1170Arguments:
1171 binary points to the ints
1172 buffer big enough to hold the result
1173
1174Returns: the number of characters placed in buffer, not counting
1175 the final nul.
1176*/
1177
1178int
1179ipv6_nmtoa(int * binary, uschar * buffer)
1180{
1181int i, j, k;
1182uschar * c = buffer;
39755c16 1183uschar * d = NULL; /* shut insufficiently "clever" compiler up */
fc4a7f70
JH
1184
1185for (i = 0; i < 4; i++)
1186 { /* expand to text */
1187 j = binary[i];
1188 c += sprintf(CS c, "%x:%x:", (j >> 16) & 0xffff, j & 0xffff);
1189 }
1190
1191for (c = buffer, k = -1, i = 0; i < 8; i++)
1192 { /* find longest 0-group sequence */
1193 if (*c == '0') /* must be "0:" */
1194 {
1195 uschar * s = c;
1196 j = i;
1197 while (c[2] == '0') i++, c += 2;
1198 if (i-j > k)
1199 {
1200 k = i-j; /* length of sequence */
1201 d = s; /* start of sequence */
1202 }
1203 }
1204 while (*++c != ':') ;
1205 c++;
1206 }
1207
1208c[-1] = '\0'; /* drop trailing colon */
1209
1210/* debug_printf("%s: D k %d <%s> <%s>\n", __FUNCTION__, k, d, d + 2*(k+1)); */
1211if (k >= 0)
1212 { /* collapse */
1213 c = d + 2*(k+1);
1214 if (d == buffer) c--; /* need extra colon */
1215 *d++ = ':'; /* 1st 0 */
39755c16 1216 while ((*d++ = *c++)) ;
fc4a7f70
JH
1217 }
1218else
1219 d = c;
1220
1221return d - buffer;
1222}
1223
1224
059ec3d9
PH
1225
1226/*************************************************
1227* Check port for tls_on_connect *
1228*************************************************/
1229
1230/* This function checks whether a given incoming port is configured for tls-
1231on-connect. It is called from the daemon and from inetd handling. If the global
1232option tls_on_connect is already set, all ports operate this way. Otherwise, we
1233check the tls_on_connect_ports option for a list of ports.
1234
1235Argument: a port number
1236Returns: TRUE or FALSE
1237*/
1238
1239BOOL
1240host_is_tls_on_connect_port(int port)
1241{
1242int sep = 0;
1243uschar buffer[32];
55414b25 1244const uschar *list = tls_in.on_connect_ports;
059ec3d9 1245uschar *s;
071c51f7 1246uschar *end;
059ec3d9 1247
817d9f57 1248if (tls_in.on_connect) return TRUE;
059ec3d9 1249
071c51f7
JH
1250while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
1251 if (Ustrtol(s, &end, 10) == port)
1252 return TRUE;
059ec3d9
PH
1253
1254return FALSE;
1255}
1256
1257
1258
1259/*************************************************
1260* Check whether host is in a network *
1261*************************************************/
1262
1263/* This function checks whether a given IP address matches a pattern that
1264represents either a single host, or a network (using CIDR notation). The caller
1265of this function must check the syntax of the arguments before calling it.
1266
1267Arguments:
1268 host string representation of the ip-address to check
1269 net string representation of the network, with optional CIDR mask
1270 maskoffset offset to the / that introduces the mask in the key
1271 zero if there is no mask
1272
1273Returns:
1274 TRUE the host is inside the network
1275 FALSE the host is NOT inside the network
1276*/
1277
1278BOOL
55414b25 1279host_is_in_net(const uschar *host, const uschar *net, int maskoffset)
059ec3d9
PH
1280{
1281int i;
1282int address[4];
1283int incoming[4];
1284int mlen;
1285int size = host_aton(net, address);
1286int insize;
1287
1288/* No mask => all bits to be checked */
1289
1290if (maskoffset == 0) mlen = 99999; /* Big number */
1291 else mlen = Uatoi(net + maskoffset + 1);
1292
1293/* Convert the incoming address to binary. */
1294
1295insize = host_aton(host, incoming);
1296
1297/* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1298 connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1299 ::ffff:<v4address>, to IPv4 format. */
1300
1301if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1302 incoming[2] == 0xffff)
1303 {
1304 insize = 1;
1305 incoming[0] = incoming[3];
1306 }
1307
1308/* No match if the sizes don't agree. */
1309
1310if (insize != size) return FALSE;
1311
1312/* Else do the masked comparison. */
1313
1314for (i = 0; i < size; i++)
1315 {
1316 int mask;
1317 if (mlen == 0) mask = 0;
1318 else if (mlen < 32)
1319 {
13559da6 1320 mask = (uint)(-1) << (32 - mlen);
059ec3d9
PH
1321 mlen = 0;
1322 }
1323 else
1324 {
1325 mask = -1;
1326 mlen -= 32;
1327 }
1328 if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1329 }
1330
1331return TRUE;
1332}
1333
1334
1335
1336/*************************************************
1337* Scan host list for local hosts *
1338*************************************************/
1339
1340/* Scan through a chain of addresses and check whether any of them is the
1341address of an interface on the local machine. If so, remove that address and
1342any previous ones with the same MX value, and all subsequent ones (which will
1343have greater or equal MX values) from the chain. Note: marking them as unusable
1344is NOT the right thing to do because it causes the hosts not to be used for
1345other domains, for which they may well be correct.
1346
1347The hosts may be part of a longer chain; we only process those between the
1348initial pointer and the "last" pointer.
1349
1350There is also a list of "pseudo-local" host names which are checked against the
1351host names. Any match causes that host item to be treated the same as one which
1352matches a local IP address.
1353
1354If the very first host is a local host, then all MX records had a precedence
1355greater than or equal to that of the local host. Either there's a problem in
1356the DNS, or an apparently remote name turned out to be an abbreviation for the
1357local host. Give a specific return code, and let the caller decide what to do.
1358Otherwise, give a success code if at least one host address has been found.
1359
1360Arguments:
1361 host pointer to the first host in the chain
1362 lastptr pointer to pointer to the last host in the chain (may be updated)
1363 removed if not NULL, set TRUE if some local addresses were removed
1364 from the list
1365
1366Returns:
1367 HOST_FOUND if there is at least one host with an IP address on the chain
1368 and an MX value less than any MX value associated with the
1369 local host
1370 HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1371 the host addresses were obtained from A records or
1372 gethostbyname(), the MX values are set to -1.
1373 HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1374*/
1375
1376int
1377host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1378{
1379int yield = HOST_FIND_FAILED;
1380host_item *last = *lastptr;
1381host_item *prev = NULL;
1382host_item *h;
1383
1384if (removed != NULL) *removed = FALSE;
1385
1386if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1387
1388for (h = host; h != last->next; h = h->next)
1389 {
1390 #ifndef STAND_ALONE
1391 if (hosts_treat_as_local != NULL)
1392 {
1393 int rc;
55414b25 1394 const uschar *save = deliver_domain;
059ec3d9 1395 deliver_domain = h->name; /* set $domain */
55414b25 1396 rc = match_isinlist(string_copylc(h->name), CUSS &hosts_treat_as_local, 0,
059ec3d9
PH
1397 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1398 deliver_domain = save;
1399 if (rc == OK) goto FOUND_LOCAL;
1400 }
1401 #endif
1402
1403 /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1404 for 127.0.0.1 and refers to the local host. We therefore force it always to
1405 be treated as local. */
1406
1407 if (h->address != NULL)
1408 {
1409 ip_address_item *ip;
1410 if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1411 for (ip = local_interface_data; ip != NULL; ip = ip->next)
1412 if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1413 yield = HOST_FOUND; /* At least one remote address has been found */
1414 }
1415
1416 /* Update prev to point to the last host item before any that have
1417 the same MX value as the one we have just considered. */
1418
1419 if (h->next == NULL || h->next->mx != h->mx) prev = h;
1420 }
1421
1422return yield; /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1423
1424/* A host whose IP address matches a local IP address, or whose name matches
1425something in hosts_treat_as_local has been found. */
1426
1427FOUND_LOCAL:
1428
1429if (prev == NULL)
1430 {
1431 HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1432 "local host has lowest MX\n" :
1433 "local host found for non-MX address\n");
1434 return HOST_FOUND_LOCAL;
1435 }
1436
1437HDEBUG(D_host_lookup)
1438 {
1439 debug_printf("local host in host list - removed hosts:\n");
1440 for (h = prev->next; h != last->next; h = h->next)
1441 debug_printf(" %s %s %d\n", h->name, h->address, h->mx);
1442 }
1443
1444if (removed != NULL) *removed = TRUE;
1445prev->next = last->next;
1446*lastptr = prev;
1447return yield;
1448}
1449
1450
1451
1452
1453/*************************************************
1454* Remove duplicate IPs in host list *
1455*************************************************/
1456
1457/* You would think that administrators could set up their DNS records so that
1458one ended up with a list of unique IP addresses after looking up A or MX
1459records, but apparently duplication is common. So we scan such lists and
1460remove the later duplicates. Note that we may get lists in which some host
1461addresses are not set.
1462
1463Arguments:
1464 host pointer to the first host in the chain
1465 lastptr pointer to pointer to the last host in the chain (may be updated)
1466
1467Returns: nothing
1468*/
1469
1470static void
1471host_remove_duplicates(host_item *host, host_item **lastptr)
1472{
1473while (host != *lastptr)
1474 {
1475 if (host->address != NULL)
1476 {
1477 host_item *h = host;
1478 while (h != *lastptr)
1479 {
1480 if (h->next->address != NULL &&
1481 Ustrcmp(h->next->address, host->address) == 0)
1482 {
1483 DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1484 "removed\n", host->address, h->next->mx);
1485 if (h->next == *lastptr) *lastptr = h;
1486 h->next = h->next->next;
1487 }
1488 else h = h->next;
1489 }
1490 }
1491 /* If the last item was removed, host may have become == *lastptr */
1492 if (host != *lastptr) host = host->next;
1493 }
1494}
1495
1496
1497
1498
1499/*************************************************
1500* Find sender host name by gethostbyaddr() *
1501*************************************************/
1502
1503/* This used to be the only way it was done, but it turns out that not all
1504systems give aliases for calls to gethostbyaddr() - or one of the modern
1505equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1506but they can still exist. This function is now used only when a DNS lookup of
1507the IP address fails, in order to give access to /etc/hosts.
1508
1509Arguments: none
1510Returns: OK, DEFER, FAIL
1511*/
1512
1513static int
1514host_name_lookup_byaddr(void)
1515{
1516int len;
1517uschar *s, *t;
1518struct hostent *hosts;
1519struct in_addr addr;
f2cb6292 1520unsigned long time_msec = 0; /* init to quieten dumb static analysis */
846430d9
JH
1521
1522if (slow_lookup_log) time_msec = get_time_in_ms();
059ec3d9
PH
1523
1524/* Lookup on IPv6 system */
1525
1526#if HAVE_IPV6
1527if (Ustrchr(sender_host_address, ':') != NULL)
1528 {
1529 struct in6_addr addr6;
1530 if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1531 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1532 "IPv6 address", sender_host_address);
1533 #if HAVE_GETIPNODEBYADDR
1534 hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1535 #else
1536 hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1537 #endif
1538 }
1539else
1540 {
1541 if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1542 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1543 "IPv4 address", sender_host_address);
1544 #if HAVE_GETIPNODEBYADDR
1545 hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1546 #else
1547 hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1548 #endif
1549 }
1550
1551/* Do lookup on IPv4 system */
1552
1553#else
1554addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1555hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1556#endif
1557
846430d9
JH
1558if ( slow_lookup_log
1559 && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log
1560 )
1561 log_long_lookup(US"name", sender_host_address, time_msec);
1562
059ec3d9
PH
1563/* Failed to look up the host. */
1564
1565if (hosts == NULL)
1566 {
1567 HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1568 h_errno);
1569 return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1570 }
1571
1572/* It seems there are some records in the DNS that yield an empty name. We
1573treat this as non-existent. In some operating systems, this is returned as an
1574empty string; in others as a single dot. */
1575
8ad076b2 1576if (hosts->h_name == NULL || hosts->h_name[0] == 0 || hosts->h_name[0] == '.')
059ec3d9
PH
1577 {
1578 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1579 "treated as non-existent host name\n");
1580 return FAIL;
1581 }
1582
1583/* Copy and lowercase the name, which is in static storage in many systems.
1584Put it in permanent memory. */
1585
5903c6ff 1586s = US hosts->h_name;
059ec3d9
PH
1587len = Ustrlen(s) + 1;
1588t = sender_host_name = store_get_perm(len);
1589while (*s != 0) *t++ = tolower(*s++);
1590*t = 0;
1591
1592/* If the host has aliases, build a copy of the alias list */
1593
1594if (hosts->h_aliases != NULL)
1595 {
1596 int count = 1;
1597 uschar **aliases, **ptr;
1598 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++) count++;
1599 ptr = sender_host_aliases = store_get_perm(count * sizeof(uschar *));
1600 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++)
1601 {
1602 uschar *s = *aliases;
1603 int len = Ustrlen(s) + 1;
1604 uschar *t = *ptr++ = store_get_perm(len);
1605 while (*s != 0) *t++ = tolower(*s++);
1606 *t = 0;
1607 }
1608 *ptr = NULL;
1609 }
1610
1611return OK;
1612}
1613
1614
1615
1616/*************************************************
1617* Find host name for incoming call *
1618*************************************************/
1619
1620/* Put the name in permanent store, pointed to by sender_host_name. We also set
1621up a list of alias names, pointed to by sender_host_alias. The list is
1622NULL-terminated. The incoming address is in sender_host_address, either in
1623dotted-quad form for IPv4 or in colon-separated form for IPv6.
1624
1625This function does a thorough check that the names it finds point back to the
1626incoming IP address. Any that do not are discarded. Note that this is relied on
1627by the ACL reverse_host_lookup check.
1628
1629On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1630this it not universally true. Also, for release 4.30, this function was changed
1631to do a direct DNS lookup first, by default[1], because it turns out that that
1632is the only guaranteed way to find all the aliases on some systems. My
1633experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1634Linux does not.
1635
1636[1] The actual order is controlled by the host_lookup_order option.
1637
1638Arguments: none
1639Returns: OK on success, the answer being placed in the global variable
1640 sender_host_name, with any aliases in a list hung off
1641 sender_host_aliases
1642 FAIL if no host name can be found
1643 DEFER if a temporary error was encountered
1644
4c04137d 1645The variable host_lookup_msg is set to an empty string on success, or to a
059ec3d9 1646reason for the failure otherwise, in a form suitable for tagging onto an error
8e669ac1 1647message, and also host_lookup_failed is set TRUE if the lookup failed. If there
b08b24c8
PH
1648was a defer, host_lookup_deferred is set TRUE.
1649
1650Any dynamically constructed string for host_lookup_msg must be in permanent
1651store, because it might be used for several incoming messages on the same SMTP
059ec3d9
PH
1652connection. */
1653
1654int
1655host_name_lookup(void)
1656{
1657int old_pool, rc;
1658int sep = 0;
1659uschar *hname, *save_hostname;
1660uschar **aliases;
1661uschar buffer[256];
1662uschar *ordername;
55414b25 1663const uschar *list = host_lookup_order;
059ec3d9
PH
1664dns_record *rr;
1665dns_answer dnsa;
1666dns_scan dnss;
1667
1f4a55da 1668sender_host_dnssec = host_lookup_deferred = host_lookup_failed = FALSE;
b08b24c8 1669
059ec3d9
PH
1670HDEBUG(D_host_lookup)
1671 debug_printf("looking up host name for %s\n", sender_host_address);
1672
1673/* For testing the case when a lookup does not complete, we have a special
1674reserved IP address. */
1675
1676if (running_in_test_harness &&
1677 Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1678 {
1679 HDEBUG(D_host_lookup)
1680 debug_printf("Test harness: host name lookup returns DEFER\n");
8e669ac1 1681 host_lookup_deferred = TRUE;
059ec3d9
PH
1682 return DEFER;
1683 }
1684
1685/* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1686the order specified by the host_lookup_order option. */
1687
1f155f8e 1688while ((ordername = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
059ec3d9
PH
1689 {
1690 if (strcmpic(ordername, US"bydns") == 0)
1691 {
9d9c3746 1692 dns_init(FALSE, FALSE, FALSE); /* dnssec ctrl by dns_dnssec_ok glbl */
059ec3d9 1693 dns_build_reverse(sender_host_address, buffer);
846430d9 1694 rc = dns_lookup_timerwrap(&dnsa, buffer, T_PTR, NULL);
059ec3d9
PH
1695
1696 /* The first record we come across is used for the name; others are
1697 considered to be aliases. We have to scan twice, in order to find out the
1698 number of aliases. However, if all the names are empty, we will behave as
1699 if failure. (PTR records that yield empty names have been encountered in
1700 the DNS.) */
1701
1702 if (rc == DNS_SUCCEED)
1703 {
1704 uschar **aptr = NULL;
1705 int ssize = 264;
1706 int count = 0;
1707 int old_pool = store_pool;
1708
1f4a55da
PP
1709 sender_host_dnssec = dns_is_secure(&dnsa);
1710 DEBUG(D_dns)
1711 debug_printf("Reverse DNS security status: %s\n",
1712 sender_host_dnssec ? "DNSSEC verified (AD)" : "unverified");
1713
059ec3d9
PH
1714 store_pool = POOL_PERM; /* Save names in permanent storage */
1715
1716 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1705dd20 1717 rr;
059ec3d9 1718 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1705dd20
JH
1719 if (rr->type == T_PTR)
1720 count++;
059ec3d9
PH
1721
1722 /* Get store for the list of aliases. For compatibility with
1723 gethostbyaddr, we make an empty list if there are none. */
1724
1725 aptr = sender_host_aliases = store_get(count * sizeof(uschar *));
1726
1727 /* Re-scan and extract the names */
1728
1729 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1705dd20 1730 rr;
059ec3d9
PH
1731 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1732 {
1733 uschar *s = NULL;
1734 if (rr->type != T_PTR) continue;
1735 s = store_get(ssize);
1736
1737 /* If an overlong response was received, the data will have been
1738 truncated and dn_expand may fail. */
1739
1740 if (dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen,
5903c6ff 1741 US (rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
059ec3d9
PH
1742 {
1743 log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1744 sender_host_address);
1745 break;
1746 }
1747
1748 store_reset(s + Ustrlen(s) + 1);
1749 if (s[0] == 0)
1750 {
1751 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1752 "empty name: treated as non-existent host name\n");
1753 continue;
1754 }
1f155f8e
JH
1755 if (!sender_host_name) sender_host_name = s;
1756 else *aptr++ = s;
059ec3d9
PH
1757 while (*s != 0) { *s = tolower(*s); s++; }
1758 }
1759
1760 *aptr = NULL; /* End of alias list */
1761 store_pool = old_pool; /* Reset store pool */
1762
1763 /* If we've found a names, break out of the "order" loop */
1764
1765 if (sender_host_name != NULL) break;
1766 }
1767
1768 /* If the DNS lookup deferred, we must also defer. */
1769
1770 if (rc == DNS_AGAIN)
1771 {
1772 HDEBUG(D_host_lookup)
1773 debug_printf("IP address PTR lookup gave temporary error\n");
8e669ac1 1774 host_lookup_deferred = TRUE;
059ec3d9
PH
1775 return DEFER;
1776 }
1777 }
1778
1779 /* Do a lookup using gethostbyaddr() - or equivalent */
1780
1781 else if (strcmpic(ordername, US"byaddr") == 0)
1782 {
1783 HDEBUG(D_host_lookup)
1784 debug_printf("IP address lookup using gethostbyaddr()\n");
059ec3d9 1785 rc = host_name_lookup_byaddr();
8e669ac1 1786 if (rc == DEFER)
b08b24c8 1787 {
8e669ac1 1788 host_lookup_deferred = TRUE;
b08b24c8 1789 return rc; /* Can't carry on */
8e669ac1 1790 }
059ec3d9
PH
1791 if (rc == OK) break; /* Found a name */
1792 }
1793 } /* Loop for bydns/byaddr scanning */
1794
1795/* If we have failed to find a name, return FAIL and log when required.
1796NB host_lookup_msg must be in permanent store. */
1797
1798if (sender_host_name == NULL)
1799 {
1800 if (host_checking || !log_testing_mode)
1801 log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1802 "address %s", sender_host_address);
1803 host_lookup_msg = US" (failed to find host name from IP address)";
b08b24c8 1804 host_lookup_failed = TRUE;
059ec3d9
PH
1805 return FAIL;
1806 }
1807
059ec3d9
PH
1808HDEBUG(D_host_lookup)
1809 {
1810 uschar **aliases = sender_host_aliases;
de11307f
JH
1811 debug_printf("IP address lookup yielded \"%s\"\n", sender_host_name);
1812 while (*aliases != NULL) debug_printf(" alias \"%s\"\n", *aliases++);
059ec3d9
PH
1813 }
1814
1815/* We need to verify that a forward lookup on the name we found does indeed
1816correspond to the address. This is for security: in principle a malefactor who
1817happened to own a reverse zone could set it to point to any names at all.
1818
1819This code was present in versions of Exim before 3.20. At that point I took it
1820out because I thought that gethostbyaddr() did the check anyway. It turns out
1821that this isn't always the case, so it's coming back in at 4.01. This version
1822is actually better, because it also checks aliases.
1823
1824The code was made more robust at release 4.21. Prior to that, it accepted all
1825the names if any of them had the correct IP address. Now the code checks all
1826the names, and accepts only those that have the correct IP address. */
1827
1828save_hostname = sender_host_name; /* Save for error messages */
1829aliases = sender_host_aliases;
2546388c 1830for (hname = sender_host_name; hname; hname = *aliases++)
059ec3d9
PH
1831 {
1832 int rc;
1833 BOOL ok = FALSE;
1834 host_item h;
1f155f8e
JH
1835 dnssec_domains d;
1836
059ec3d9
PH
1837 h.next = NULL;
1838 h.name = hname;
1839 h.mx = MX_NONE;
1840 h.address = NULL;
1f155f8e
JH
1841 d.request = sender_host_dnssec ? US"*" : NULL;;
1842 d.require = NULL;
059ec3d9 1843
1f155f8e
JH
1844 if ( (rc = host_find_bydns(&h, NULL, HOST_FIND_BY_A,
1845 NULL, NULL, NULL, &d, NULL, NULL)) == HOST_FOUND
1846 || rc == HOST_FOUND_LOCAL
1847 )
059ec3d9
PH
1848 {
1849 host_item *hh;
059ec3d9 1850 HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1f155f8e
JH
1851
1852 /* If the forward lookup was not secure we cancel the is-secure variable */
1853
1854 DEBUG(D_dns) debug_printf("Forward DNS security status: %s\n",
1855 h.dnssec == DS_YES ? "DNSSEC verified (AD)" : "unverified");
1856 if (h.dnssec != DS_YES) sender_host_dnssec = FALSE;
1857
2546388c 1858 for (hh = &h; hh; hh = hh->next)
d27f1df3 1859 if (host_is_in_net(hh->address, sender_host_address, 0))
059ec3d9
PH
1860 {
1861 HDEBUG(D_host_lookup) debug_printf(" %s OK\n", hh->address);
1862 ok = TRUE;
1863 break;
1864 }
1865 else
059ec3d9 1866 HDEBUG(D_host_lookup) debug_printf(" %s\n", hh->address);
1f155f8e 1867
059ec3d9
PH
1868 if (!ok) HDEBUG(D_host_lookup)
1869 debug_printf("no IP address for %s matched %s\n", hname,
1870 sender_host_address);
1871 }
1872 else if (rc == HOST_FIND_AGAIN)
1873 {
1874 HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
8e669ac1 1875 host_lookup_deferred = TRUE;
55728a4f 1876 sender_host_name = NULL;
059ec3d9
PH
1877 return DEFER;
1878 }
1879 else
059ec3d9 1880 HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
059ec3d9
PH
1881
1882 /* If this name is no good, and it's the sender name, set it null pro tem;
1883 if it's an alias, just remove it from the list. */
1884
1885 if (!ok)
1886 {
1887 if (hname == sender_host_name) sender_host_name = NULL; else
1888 {
1889 uschar **a; /* Don't amalgamate - some */
1890 a = --aliases; /* compilers grumble */
1891 while (*a != NULL) { *a = a[1]; a++; }
1892 }
1893 }
1894 }
1895
1896/* If sender_host_name == NULL, it means we didn't like the name. Replace
1897it with the first alias, if there is one. */
1898
1899if (sender_host_name == NULL && *sender_host_aliases != NULL)
1900 sender_host_name = *sender_host_aliases++;
1901
1902/* If we now have a main name, all is well. */
1903
1904if (sender_host_name != NULL) return OK;
1905
1906/* We have failed to find an address that matches. */
1907
1908HDEBUG(D_host_lookup)
1909 debug_printf("%s does not match any IP address for %s\n",
1910 sender_host_address, save_hostname);
1911
1912/* This message must be in permanent store */
1913
1914old_pool = store_pool;
1915store_pool = POOL_PERM;
1916host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1917 sender_host_address, save_hostname);
1918store_pool = old_pool;
059ec3d9
PH
1919host_lookup_failed = TRUE;
1920return FAIL;
1921}
1922
1923
1924
1925
1926/*************************************************
1927* Find IP address(es) for host by name *
1928*************************************************/
1929
1930/* The input is a host_item structure with the name filled in and the address
322050c2
PH
1931field set to NULL. We use gethostbyname() or getipnodebyname() or
1932gethostbyname2(), as appropriate. Of course, these functions may use the DNS,
1933but they do not do MX processing. It appears, however, that in some systems the
1934current setting of resolver options is used when one of these functions calls
1935the resolver. For this reason, we call dns_init() at the start, with arguments
1936influenced by bits in "flags", just as we do for host_find_bydns().
059ec3d9
PH
1937
1938The second argument provides a host list (usually an IP list) of hosts to
1939ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1940addresses in unreasonable places.
1941
1942The lookup may result in a change of name. For compatibility with the dns
1943lookup, return this via fully_qualified_name as well as updating the host item.
1944The lookup may also yield more than one IP address, in which case chain on
1945subsequent host_item structures.
1946
1947Arguments:
1948 host a host item with the name and MX filled in;
1949 the address is to be filled in;
1950 multiple IP addresses cause other host items to be
1951 chained on.
1952 ignore_target_hosts a list of hosts to ignore
322050c2
PH
1953 flags HOST_FIND_QUALIFY_SINGLE ) passed to
1954 HOST_FIND_SEARCH_PARENTS ) dns_init()
059ec3d9
PH
1955 fully_qualified_name if not NULL, set to point to host name for
1956 compatibility with host_find_bydns
1957 local_host_check TRUE if a check for the local host is wanted
1958
1959Returns: HOST_FIND_FAILED Failed to find the host or domain
1960 HOST_FIND_AGAIN Try again later
1961 HOST_FOUND Host found - data filled in
1962 HOST_FOUND_LOCAL Host found and is the local host
1963*/
1964
1965int
55414b25
JH
1966host_find_byname(host_item *host, const uschar *ignore_target_hosts, int flags,
1967 const uschar **fully_qualified_name, BOOL local_host_check)
059ec3d9
PH
1968{
1969int i, yield, times;
1970uschar **addrlist;
1971host_item *last = NULL;
1972BOOL temp_error = FALSE;
b08b24c8
PH
1973#if HAVE_IPV6
1974int af;
1975#endif
1976
322050c2
PH
1977/* Make sure DNS options are set as required. This appears to be necessary in
1978some circumstances when the get..byname() function actually calls the DNS. */
1979
1980dns_init((flags & HOST_FIND_QUALIFY_SINGLE) != 0,
8c51eead 1981 (flags & HOST_FIND_SEARCH_PARENTS) != 0,
7cd171b7 1982 FALSE); /* Cannot retrieve dnssec status so do not request */
322050c2 1983
7e66e54d
PH
1984/* In an IPv6 world, unless IPv6 has been disabled, we need to scan for both
1985kinds of address, so go round the loop twice. Note that we have ensured that
1986AF_INET6 is defined even in an IPv4 world, which makes for slightly tidier
1987code. However, if dns_ipv4_lookup matches the domain, we also just do IPv4
1988lookups here (except when testing standalone). */
059ec3d9
PH
1989
1990#if HAVE_IPV6
322050c2
PH
1991 #ifdef STAND_ALONE
1992 if (disable_ipv6)
1993 #else
1994 if (disable_ipv6 ||
1995 (dns_ipv4_lookup != NULL &&
55414b25
JH
1996 match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
1997 MCL_DOMAIN, TRUE, NULL) == OK))
322050c2
PH
1998 #endif
1999
059ec3d9
PH
2000 { af = AF_INET; times = 1; }
2001 else
059ec3d9
PH
2002 { af = AF_INET6; times = 2; }
2003
2004/* No IPv6 support */
2005
2006#else /* HAVE_IPV6 */
2007 times = 1;
2008#endif /* HAVE_IPV6 */
2009
2010/* Initialize the flag that gets set for DNS syntax check errors, so that the
2011interface to this function can be similar to host_find_bydns. */
2012
2013host_find_failed_syntax = FALSE;
2014
2015/* Loop to look up both kinds of address in an IPv6 world */
2016
2017for (i = 1; i <= times;
2018 #if HAVE_IPV6
2019 af = AF_INET, /* If 2 passes, IPv4 on the second */
2020 #endif
2021 i++)
2022 {
2023 BOOL ipv4_addr;
91ecef39 2024 int error_num = 0;
059ec3d9 2025 struct hostent *hostdata;
0539a19d 2026 unsigned long time_msec = 0; /* compiler quietening */
059ec3d9 2027
322050c2
PH
2028 #ifdef STAND_ALONE
2029 printf("Looking up: %s\n", host->name);
2030 #endif
2031
846430d9
JH
2032 if (slow_lookup_log) time_msec = get_time_in_ms();
2033
059ec3d9 2034 #if HAVE_IPV6
e7726cbf
PH
2035 if (running_in_test_harness)
2036 hostdata = host_fake_gethostbyname(host->name, af, &error_num);
2037 else
2038 {
059ec3d9
PH
2039 #if HAVE_GETIPNODEBYNAME
2040 hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
2041 #else
2042 hostdata = gethostbyname2(CS host->name, af);
2043 error_num = h_errno;
2044 #endif
e7726cbf
PH
2045 }
2046
2047 #else /* not HAVE_IPV6 */
2048 if (running_in_test_harness)
2049 hostdata = host_fake_gethostbyname(host->name, AF_INET, &error_num);
2050 else
2051 {
2052 hostdata = gethostbyname(CS host->name);
2053 error_num = h_errno;
2054 }
2055 #endif /* HAVE_IPV6 */
059ec3d9 2056
0539a19d 2057 if ( slow_lookup_log
abe1353e
HSHR
2058 && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
2059 log_long_lookup(US"name", host->name, time_msec);
846430d9 2060
059ec3d9
PH
2061 if (hostdata == NULL)
2062 {
2063 uschar *error;
2064 switch (error_num)
2065 {
2066 case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
4a452c43
JH
2067 case TRY_AGAIN: error = US"TRY_AGAIN"; break;
2068 case NO_RECOVERY: error = US"NO_RECOVERY"; break;
2069 case NO_DATA: error = US"NO_DATA"; break;
059ec3d9 2070 #if NO_DATA != NO_ADDRESS
4a452c43 2071 case NO_ADDRESS: error = US"NO_ADDRESS"; break;
059ec3d9
PH
2072 #endif
2073 default: error = US"?"; break;
2074 }
2075
2076 DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
2077 #if HAVE_IPV6
2078 #if HAVE_GETIPNODEBYNAME
2079 (af == AF_INET6)? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
2080 #else
2081 (af == AF_INET6)? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
2082 #endif
2083 #else
2084 "gethostbyname",
2085 #endif
2086 error_num, error);
2087
2088 if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
2089 continue;
2090 }
2091 if ((hostdata->h_addr_list)[0] == NULL) continue;
2092
2093 /* Replace the name with the fully qualified one if necessary, and fill in
2094 the fully_qualified_name pointer. */
2095
2096 if (hostdata->h_name[0] != 0 &&
2097 Ustrcmp(host->name, hostdata->h_name) != 0)
5903c6ff 2098 host->name = string_copy_dnsdomain(US hostdata->h_name);
059ec3d9
PH
2099 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2100
2101 /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
2102 by their different lengths. Scan the list, ignoring any that are to be
2103 ignored, and build a chain from the rest. */
2104
2105 ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
2106
2107 for (addrlist = USS hostdata->h_addr_list; *addrlist != NULL; addrlist++)
2108 {
2109 uschar *text_address =
2110 host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
2111
2112 #ifndef STAND_ALONE
2113 if (ignore_target_hosts != NULL &&
2114 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2115 text_address, NULL) == OK)
2116 {
2117 DEBUG(D_host_lookup)
2118 debug_printf("ignored host %s [%s]\n", host->name, text_address);
2119 continue;
2120 }
2121 #endif
2122
2123 /* If this is the first address, last == NULL and we put the data in the
2124 original block. */
2125
2126 if (last == NULL)
2127 {
2128 host->address = text_address;
2129 host->port = PORT_NONE;
2130 host->status = hstatus_unknown;
2131 host->why = hwhy_unknown;
783b385f 2132 host->dnssec = DS_UNK;
059ec3d9
PH
2133 last = host;
2134 }
2135
2136 /* Else add further host item blocks for any other addresses, keeping
2137 the order. */
2138
2139 else
2140 {
2141 host_item *next = store_get(sizeof(host_item));
2142 next->name = host->name;
2143 next->mx = host->mx;
2144 next->address = text_address;
2145 next->port = PORT_NONE;
2146 next->status = hstatus_unknown;
2147 next->why = hwhy_unknown;
783b385f 2148 next->dnssec = DS_UNK;
059ec3d9
PH
2149 next->last_try = 0;
2150 next->next = last->next;
2151 last->next = next;
2152 last = next;
2153 }
2154 }
2155 }
2156
2157/* If no hosts were found, the address field in the original host block will be
2158NULL. If temp_error is set, at least one of the lookups gave a temporary error,
2159so we pass that back. */
2160
2161if (host->address == NULL)
2162 {
2163 uschar *msg =
2164 #ifndef STAND_ALONE
2165 (message_id[0] == 0 && smtp_in != NULL)?
2166 string_sprintf("no IP address found for host %s (during %s)", host->name,
2167 smtp_get_connection_info()) :
2168 #endif
2169 string_sprintf("no IP address found for host %s", host->name);
2170
2171 HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
9b8fadde 2172 if (temp_error) goto RETURN_AGAIN;
059ec3d9
PH
2173 if (host_checking || !log_testing_mode)
2174 log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
2175 return HOST_FIND_FAILED;
2176 }
2177
2178/* Remove any duplicate IP addresses, then check to see if this is the local
2179host if required. */
2180
2181host_remove_duplicates(host, &last);
2182yield = local_host_check?
2183 host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
2184
059ec3d9
PH
2185HDEBUG(D_host_lookup)
2186 {
55414b25 2187 const host_item *h;
059ec3d9
PH
2188 if (fully_qualified_name != NULL)
2189 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2190 debug_printf("%s looked up these IP addresses:\n",
2191 #if HAVE_IPV6
2192 #if HAVE_GETIPNODEBYNAME
2193 "getipnodebyname"
2194 #else
2195 "gethostbyname2"
2196 #endif
2197 #else
2198 "gethostbyname"
2199 #endif
2200 );
2201 for (h = host; h != last->next; h = h->next)
2202 debug_printf(" name=%s address=%s\n", h->name,
2203 (h->address == NULL)? US"<null>" : h->address);
2204 }
2205
2206/* Return the found status. */
2207
2208return yield;
9b8fadde
PH
2209
2210/* Handle the case when there is a temporary error. If the name matches
2211dns_again_means_nonexist, return permanent rather than temporary failure. */
2212
2213RETURN_AGAIN:
2214 {
2215 #ifndef STAND_ALONE
2216 int rc;
55414b25 2217 const uschar *save = deliver_domain;
9b8fadde 2218 deliver_domain = host->name; /* set $domain */
55414b25 2219 rc = match_isinlist(host->name, CUSS &dns_again_means_nonexist, 0, NULL, NULL,
9b8fadde
PH
2220 MCL_DOMAIN, TRUE, NULL);
2221 deliver_domain = save;
2222 if (rc == OK)
2223 {
2224 DEBUG(D_host_lookup) debug_printf("%s is in dns_again_means_nonexist: "
2225 "returning HOST_FIND_FAILED\n", host->name);
2226 return HOST_FIND_FAILED;
2227 }
2228 #endif
2229 return HOST_FIND_AGAIN;
2230 }
059ec3d9
PH
2231}
2232
2233
2234
2235/*************************************************
2236* Fill in a host address from the DNS *
2237*************************************************/
2238
1349e1e5
PH
2239/* Given a host item, with its name, port and mx fields set, and its address
2240field set to NULL, fill in its IP address from the DNS. If it is multi-homed,
2241create additional host items for the additional addresses, copying all the
2242other fields, and randomizing the order.
059ec3d9
PH
2243
2244On IPv6 systems, A6 records are sought first (but only if support for A6 is
2245configured - they may never become mainstream), then AAAA records are sought,
2246and finally A records are sought as well.
2247
2248The host name may be changed if the DNS returns a different name - e.g. fully
2249qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
2250ensures that it points to the fully qualified name. However, this is the fully
2251qualified version of the original name; if a CNAME is involved, the actual
2252canonical host name may be different again, and so we get it directly from the
2253relevant RR. Note that we do NOT change the mx field of the host item in this
2254function as it may be called to set the addresses of hosts taken from MX
2255records.
2256
2257Arguments:
2258 host points to the host item we're filling in
2259 lastptr points to pointer to last host item in a chain of
2260 host items (may be updated if host is last and gets
2261 extended because multihomed)
2262 ignore_target_hosts list of hosts to ignore
2263 allow_ip if TRUE, recognize an IP address and return it
2264 fully_qualified_name if not NULL, return fully qualified name here if
2265 the contents are different (i.e. it must be preset
2266 to something)
221dff13
HSHR
2267 dnssec_request if TRUE request the AD bit
2268 dnssec_require if TRUE require the AD bit
059ec3d9
PH
2269
2270Returns: HOST_FIND_FAILED couldn't find A record
2271 HOST_FIND_AGAIN try again later
2546388c 2272 HOST_FIND_SECURITY dnssec required but not acheived
059ec3d9
PH
2273 HOST_FOUND found AAAA and/or A record(s)
2274 HOST_IGNORED found, but all IPs ignored
2275*/
2276
2277static int
2278set_address_from_dns(host_item *host, host_item **lastptr,
55414b25
JH
2279 const uschar *ignore_target_hosts, BOOL allow_ip,
2280 const uschar **fully_qualified_name,
cf2b569e 2281 BOOL dnssec_request, BOOL dnssec_require)
059ec3d9
PH
2282{
2283dns_record *rr;
2284host_item *thishostlast = NULL; /* Indicates not yet filled in anything */
2285BOOL v6_find_again = FALSE;
2546388c 2286BOOL dnssec_fail = FALSE;
059ec3d9
PH
2287int i;
2288
2289/* If allow_ip is set, a name which is an IP address returns that value
2290as its address. This is used for MX records when allow_mx_to_ip is set, for
2291those sites that feel they have to flaunt the RFC rules. */
2292
2293if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2294 {
2295 #ifndef STAND_ALONE
2296 if (ignore_target_hosts != NULL &&
2297 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2298 host->name, NULL) == OK)
2299 return HOST_IGNORED;
2300 #endif
2301
2302 host->address = host->name;
059ec3d9
PH
2303 return HOST_FOUND;
2304 }
2305
0539a19d
JH
2306/* On an IPv6 system, unless IPv6 is disabled, go round the loop up to twice,
2307looking for AAAA records the first time. However, unless
7e66e54d 2308doing standalone testing, we force an IPv4 lookup if the domain matches
0539a19d 2309dns_ipv4_lookup is set. On an IPv4 system, go round the
7e66e54d 2310loop once only, looking only for A records. */
059ec3d9
PH
2311
2312#if HAVE_IPV6
059ec3d9 2313 #ifndef STAND_ALONE
7e66e54d 2314 if (disable_ipv6 || (dns_ipv4_lookup != NULL &&
55414b25
JH
2315 match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
2316 MCL_DOMAIN, TRUE, NULL) == OK))
059ec3d9
PH
2317 i = 0; /* look up A records only */
2318 else
2319 #endif /* STAND_ALONE */
2320
059ec3d9 2321 i = 1; /* look up AAAA and A records */
059ec3d9
PH
2322
2323/* The IPv4 world */
2324
2325#else /* HAVE_IPV6 */
2326 i = 0; /* look up A records only */
2327#endif /* HAVE_IPV6 */
2328
2329for (; i >= 0; i--)
2330 {
0539a19d 2331 static int types[] = { T_A, T_AAAA };
059ec3d9
PH
2332 int type = types[i];
2333 int randoffset = (i == 0)? 500 : 0; /* Ensures v6 sorts before v4 */
2334 dns_answer dnsa;
2335 dns_scan dnss;
2336
846430d9 2337 int rc = dns_lookup_timerwrap(&dnsa, host->name, type, fully_qualified_name);
cf2b569e 2338 lookup_dnssec_authenticated = !dnssec_request ? NULL
4e0983dc 2339 : dns_is_secure(&dnsa) ? US"yes" : US"no";
059ec3d9 2340
221dff13 2341 DEBUG(D_dns)
0539a19d
JH
2342 if ( (dnssec_request || dnssec_require)
2343 && !dns_is_secure(&dnsa)
2344 && dns_is_aa(&dnsa)
2345 )
2346 debug_printf("DNS lookup of %.256s (A/AAAA) requested AD, but got AA\n", host->name);
221dff13 2347
0539a19d 2348 /* We want to return HOST_FIND_AGAIN if one of the A or AAAA lookups
059ec3d9
PH
2349 fails or times out, but not if another one succeeds. (In the early
2350 IPv6 days there are name servers that always fail on AAAA, but are happy
2351 to give out an A record. We want to proceed with that A record.) */
8e669ac1 2352
059ec3d9
PH
2353 if (rc != DNS_SUCCEED)
2354 {
2355 if (i == 0) /* Just tried for an A record, i.e. end of loop */
2356 {
0539a19d 2357 if (host->address != NULL) return HOST_FOUND; /* AAAA was found */
059ec3d9
PH
2358 if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2359 return HOST_FIND_AGAIN;
2360 return HOST_FIND_FAILED; /* DNS_NOMATCH or DNS_NODATA */
2361 }
2362
0539a19d 2363 /* Tried for an AAAA record: remember if this was a temporary
059ec3d9
PH
2364 error, and look for the next record type. */
2365
2366 if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2367 continue;
2368 }
cf2b569e
JH
2369
2370 if (dnssec_request)
8c51eead 2371 {
cf2b569e
JH
2372 if (dns_is_secure(&dnsa))
2373 {
2374 DEBUG(D_host_lookup) debug_printf("%s A DNSSEC\n", host->name);
2375 if (host->dnssec == DS_UNK) /* set in host_find_bydns() */
2376 host->dnssec = DS_YES;
2377 }
2378 else
2379 {
2380 if (dnssec_require)
2381 {
2546388c
JH
2382 dnssec_fail = TRUE;
2383 DEBUG(D_host_lookup) debug_printf("dnssec fail on %s for %.256s",
0539a19d 2384 i>0 ? "AAAA" : "A", host->name);
cf2b569e
JH
2385 continue;
2386 }
2387 if (host->dnssec == DS_YES) /* set in host_find_bydns() */
2388 {
2389 DEBUG(D_host_lookup) debug_printf("%s A cancel DNSSEC\n", host->name);
2390 host->dnssec = DS_NO;
2391 lookup_dnssec_authenticated = US"no";
2392 }
2393 }
8c51eead 2394 }
059ec3d9
PH
2395
2396 /* Lookup succeeded: fill in the given host item with the first non-ignored
2397 address found; create additional items for any others. A single A6 record
8241d8dd
JH
2398 may generate more than one address. The lookup had a chance to update the
2399 fqdn; we do not want any later times round the loop to do so. */
2400
2401 fully_qualified_name = NULL;
059ec3d9
PH
2402
2403 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
e1a3f32f 2404 rr;
059ec3d9
PH
2405 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2406 {
2407 if (rr->type == type)
2408 {
d57d474f 2409 dns_address *da = dns_address_from_rr(&dnsa, rr);
059ec3d9
PH
2410
2411 DEBUG(D_host_lookup)
e1a3f32f 2412 if (!da) debug_printf("no addresses extracted from A6 RR for %s\n",
059ec3d9 2413 host->name);
059ec3d9
PH
2414
2415 /* This loop runs only once for A and AAAA records, but may run
2416 several times for an A6 record that generated multiple addresses. */
2417
e1a3f32f 2418 for (; da; da = da->next)
059ec3d9
PH
2419 {
2420 #ifndef STAND_ALONE
2421 if (ignore_target_hosts != NULL &&
2422 verify_check_this_host(&ignore_target_hosts, NULL,
2423 host->name, da->address, NULL) == OK)
2424 {
2425 DEBUG(D_host_lookup)
2426 debug_printf("ignored host %s [%s]\n", host->name, da->address);
2427 continue;
2428 }
2429 #endif
2430
2431 /* If this is the first address, stick it in the given host block,
2432 and change the name if the returned RR has a different name. */
2433
2434 if (thishostlast == NULL)
2435 {
2436 if (strcmpic(host->name, rr->name) != 0)
2437 host->name = string_copy_dnsdomain(rr->name);
2438 host->address = da->address;
059ec3d9
PH
2439 host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2440 host->status = hstatus_unknown;
2441 host->why = hwhy_unknown;
2442 thishostlast = host;
2443 }
2444
2445 /* Not the first address. Check for, and ignore, duplicates. Then
2446 insert in the chain at a random point. */
2447
2448 else
2449 {
2450 int new_sort_key;
2451 host_item *next;
2452
2453 /* End of our local chain is specified by "thishostlast". */
2454
2455 for (next = host;; next = next->next)
2456 {
2457 if (Ustrcmp(CS da->address, next->address) == 0) break;
2458 if (next == thishostlast) { next = NULL; break; }
2459 }
2460 if (next != NULL) continue; /* With loop for next address */
2461
2462 /* Not a duplicate */
2463
2464 new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2465 next = store_get(sizeof(host_item));
2466
2467 /* New address goes first: insert the new block after the first one
2468 (so as not to disturb the original pointer) but put the new address
2469 in the original block. */
2470
2471 if (new_sort_key < host->sort_key)
2472 {
1349e1e5 2473 *next = *host; /* Copies port */
059ec3d9
PH
2474 host->next = next;
2475 host->address = da->address;
059ec3d9
PH
2476 host->sort_key = new_sort_key;
2477 if (thishostlast == host) thishostlast = next; /* Local last */
2478 if (*lastptr == host) *lastptr = next; /* Global last */
2479 }
2480
2481 /* Otherwise scan down the addresses for this host to find the
2482 one to insert after. */
2483
2484 else
2485 {
2486 host_item *h = host;
2487 while (h != thishostlast)
2488 {
2489 if (new_sort_key < h->next->sort_key) break;
2490 h = h->next;
2491 }
1349e1e5 2492 *next = *h; /* Copies port */
059ec3d9
PH
2493 h->next = next;
2494 next->address = da->address;
059ec3d9
PH
2495 next->sort_key = new_sort_key;
2496 if (h == thishostlast) thishostlast = next; /* Local last */
2497 if (h == *lastptr) *lastptr = next; /* Global last */
2498 }
2499 }
2500 }
2501 }
2502 }
2503 }
2504
2546388c 2505/* Control gets here only if the second lookup (the A record) succeeded.
059ec3d9
PH
2506However, the address may not be filled in if it was ignored. */
2507
2546388c
JH
2508return host->address
2509 ? HOST_FOUND
2510 : dnssec_fail
2511 ? HOST_FIND_SECURITY
2512 : HOST_IGNORED;
059ec3d9
PH
2513}
2514
2515
2516
2517
2518/*************************************************
1349e1e5 2519* Find IP addresses and host names via DNS *
059ec3d9
PH
2520*************************************************/
2521
1349e1e5
PH
2522/* The input is a host_item structure with the name field filled in and the
2523address field set to NULL. This may be in a chain of other host items. The
2524lookup may result in more than one IP address, in which case we must created
2525new host blocks for the additional addresses, and insert them into the chain.
2526The original name may not be fully qualified. Use the fully_qualified_name
2527argument to return the official name, as returned by the resolver.
059ec3d9
PH
2528
2529Arguments:
2530 host point to initial host item
2531 ignore_target_hosts a list of hosts to ignore
2532 whichrrs flags indicating which RRs to look for:
2533 HOST_FIND_BY_SRV => look for SRV
2534 HOST_FIND_BY_MX => look for MX
2535 HOST_FIND_BY_A => look for A or AAAA
2536 also flags indicating how the lookup is done
2537 HOST_FIND_QUALIFY_SINGLE ) passed to the
2538 HOST_FIND_SEARCH_PARENTS ) resolver
2539 srv_service when SRV used, the service name
2540 srv_fail_domains DNS errors for these domains => assume nonexist
2541 mx_fail_domains DNS errors for these domains => assume nonexist
7cd171b7
JH
2542 dnssec_d.request => make dnssec request: domainlist
2543 dnssec_d.require => ditto and nonexist failures
059ec3d9
PH
2544 fully_qualified_name if not NULL, return fully-qualified name
2545 removed set TRUE if local host was removed from the list
2546
2547Returns: HOST_FIND_FAILED Failed to find the host or domain;
2548 if there was a syntax error,
2549 host_find_failed_syntax is set.
2550 HOST_FIND_AGAIN Could not resolve at this time
2546388c 2551 HOST_FIND_SECURITY dnsssec required but not acheived
059ec3d9
PH
2552 HOST_FOUND Host found
2553 HOST_FOUND_LOCAL The lowest MX record points to this
2554 machine, if MX records were found, or
2555 an A record that was found contains
2556 an address of the local host
2557*/
2558
2559int
55414b25 2560host_find_bydns(host_item *host, const uschar *ignore_target_hosts, int whichrrs,
059ec3d9 2561 uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
7cd171b7 2562 const dnssec_domains *dnssec_d,
55414b25 2563 const uschar **fully_qualified_name, BOOL *removed)
059ec3d9
PH
2564{
2565host_item *h, *last;
2566dns_record *rr;
2567int rc = DNS_FAIL;
2568int ind_type = 0;
2569int yield;
2570dns_answer dnsa;
2571dns_scan dnss;
7cd171b7
JH
2572BOOL dnssec_require = dnssec_d
2573 && match_isinlist(host->name, CUSS &dnssec_d->require,
8c51eead 2574 0, NULL, NULL, MCL_DOMAIN, TRUE, NULL) == OK;
783b385f 2575BOOL dnssec_request = dnssec_require
7cd171b7
JH
2576 || ( dnssec_d
2577 && match_isinlist(host->name, CUSS &dnssec_d->request,
2578 0, NULL, NULL, MCL_DOMAIN, TRUE, NULL) == OK);
783b385f 2579dnssec_status_t dnssec;
059ec3d9
PH
2580
2581/* Set the default fully qualified name to the incoming name, initialize the
2582resolver if necessary, set up the relevant options, and initialize the flag
2583that gets set for DNS syntax check errors. */
2584
2585if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2586dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
8c51eead 2587 (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0,
1f155f8e 2588 dnssec_request);
059ec3d9
PH
2589host_find_failed_syntax = FALSE;
2590
2591/* First, if requested, look for SRV records. The service name is given; we
221dff13 2592assume TCP protocol. DNS domain names are constrained to a maximum of 256
059ec3d9
PH
2593characters, so the code below should be safe. */
2594
2595if ((whichrrs & HOST_FIND_BY_SRV) != 0)
2596 {
2597 uschar buffer[300];
2598 uschar *temp_fully_qualified_name = buffer;
2599 int prefix_length;
2600
2601 (void)sprintf(CS buffer, "_%s._tcp.%n%.256s", srv_service, &prefix_length,
2602 host->name);
2603 ind_type = T_SRV;
2604
2605 /* Search for SRV records. If the fully qualified name is different to
2606 the input name, pass back the new original domain, without the prepended
2607 magic. */
2608
783b385f
JH
2609 dnssec = DS_UNK;
2610 lookup_dnssec_authenticated = NULL;
846430d9 2611 rc = dns_lookup_timerwrap(&dnsa, buffer, ind_type, CUSS &temp_fully_qualified_name);
783b385f 2612
221dff13
HSHR
2613 DEBUG(D_dns)
2614 if ((dnssec_request || dnssec_require)
8f07c250
JH
2615 && !dns_is_secure(&dnsa)
2616 && dns_is_aa(&dnsa))
221dff13
HSHR
2617 debug_printf("DNS lookup of %.256s (SRV) requested AD, but got AA\n", host->name);
2618
783b385f
JH
2619 if (dnssec_request)
2620 {
2621 if (dns_is_secure(&dnsa))
2622 { dnssec = DS_YES; lookup_dnssec_authenticated = US"yes"; }
2623 else
2624 { dnssec = DS_NO; lookup_dnssec_authenticated = US"no"; }
2625 }
4e0983dc 2626
059ec3d9
PH
2627 if (temp_fully_qualified_name != buffer && fully_qualified_name != NULL)
2628 *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2629
2630 /* On DNS failures, we give the "try again" error unless the domain is
2631 listed as one for which we continue. */
2632
8c51eead
JH
2633 if (rc == DNS_SUCCEED && dnssec_require && !dns_is_secure(&dnsa))
2634 {
2635 log_write(L_host_lookup_failed, LOG_MAIN,
2636 "dnssec fail on SRV for %.256s", host->name);
2637 rc = DNS_FAIL;
2638 }
059ec3d9
PH
2639 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2640 {
e7726cbf 2641 #ifndef STAND_ALONE
55414b25
JH
2642 if (match_isinlist(host->name, CUSS &srv_fail_domains, 0, NULL, NULL,
2643 MCL_DOMAIN, TRUE, NULL) != OK)
e7726cbf 2644 #endif
8c51eead 2645 { yield = HOST_FIND_AGAIN; goto out; }
059ec3d9
PH
2646 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2647 "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2648 }
2649 }
2650
2651/* If we did not find any SRV records, search the DNS for MX records, if
2652requested to do so. If the result is DNS_NOMATCH, it means there is no such
2653domain, and there's no point in going on to look for address records with the
2654same domain. The result will be DNS_NODATA if the domain exists but has no MX
2655records. On DNS failures, we give the "try again" error unless the domain is
2656listed as one for which we continue. */
2657
2546388c 2658if (rc != DNS_SUCCEED && whichrrs & HOST_FIND_BY_MX)
059ec3d9
PH
2659 {
2660 ind_type = T_MX;
783b385f
JH
2661 dnssec = DS_UNK;
2662 lookup_dnssec_authenticated = NULL;
846430d9 2663 rc = dns_lookup_timerwrap(&dnsa, host->name, ind_type, fully_qualified_name);
783b385f 2664
221dff13 2665 DEBUG(D_dns)
2546388c
JH
2666 if ( (dnssec_request || dnssec_require)
2667 && !dns_is_secure(&dnsa)
2668 && dns_is_aa(&dnsa))
cf3d165f 2669 debug_printf("DNS lookup of %.256s (MX) requested AD, but got AA\n", host->name);
221dff13 2670
783b385f 2671 if (dnssec_request)
783b385f 2672 if (dns_is_secure(&dnsa))
94431adb 2673 {
cf2b569e
JH
2674 DEBUG(D_host_lookup) debug_printf("%s MX DNSSEC\n", host->name);
2675 dnssec = DS_YES; lookup_dnssec_authenticated = US"yes";
2676 }
783b385f 2677 else
cf2b569e
JH
2678 {
2679 dnssec = DS_NO; lookup_dnssec_authenticated = US"no";
2680 }
4e0983dc 2681
8c51eead
JH
2682 switch (rc)
2683 {
2684 case DNS_NOMATCH:
2685 yield = HOST_FIND_FAILED; goto out;
2686
2687 case DNS_SUCCEED:
2688 if (!dnssec_require || dns_is_secure(&dnsa))
2689 break;
2546388c
JH
2690 DEBUG(D_host_lookup)
2691 debug_printf("dnssec fail on MX for %.256s", host->name);
2692#ifndef STAND_ALONE
2693 if (match_isinlist(host->name, CUSS &mx_fail_domains, 0, NULL, NULL,
2694 MCL_DOMAIN, TRUE, NULL) != OK)
2695 { yield = HOST_FIND_SECURITY; goto out; }
2696#endif
8c51eead 2697 rc = DNS_FAIL;
cf2b569e 2698 /*FALLTHROUGH*/
8c51eead
JH
2699
2700 case DNS_FAIL:
2701 case DNS_AGAIN:
2546388c 2702#ifndef STAND_ALONE
55414b25
JH
2703 if (match_isinlist(host->name, CUSS &mx_fail_domains, 0, NULL, NULL,
2704 MCL_DOMAIN, TRUE, NULL) != OK)
2546388c 2705#endif
8c51eead
JH
2706 { yield = HOST_FIND_AGAIN; goto out; }
2707 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2708 "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2709 break;
059ec3d9
PH
2710 }
2711 }
2712
2713/* If we haven't found anything yet, and we are requested to do so, try for an
2714A or AAAA record. If we find it (or them) check to see that it isn't the local
2715host. */
2716
2717if (rc != DNS_SUCCEED)
2718 {
2719 if ((whichrrs & HOST_FIND_BY_A) == 0)
2720 {
2721 DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
8c51eead
JH
2722 yield = HOST_FIND_FAILED;
2723 goto out;
059ec3d9
PH
2724 }
2725
2726 last = host; /* End of local chainlet */
2727 host->mx = MX_NONE;
2728 host->port = PORT_NONE;
cf2b569e 2729 host->dnssec = DS_UNK;
783b385f 2730 lookup_dnssec_authenticated = NULL;
059ec3d9 2731 rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
4e0983dc 2732 fully_qualified_name, dnssec_request, dnssec_require);
059ec3d9
PH
2733
2734 /* If one or more address records have been found, check that none of them
2735 are local. Since we know the host items all have their IP addresses
2736 inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2737 HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2738 because set_address_from_dns() removes them. */
2739
2740 if (rc == HOST_FOUND)
2741 rc = host_scan_for_local_hosts(host, &last, removed);
2742 else
2743 if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED; /* No special action */
2744
2745 DEBUG(D_host_lookup)
2746 {
2747 host_item *h;
2748 if (host->address != NULL)
2749 {
2750 if (fully_qualified_name != NULL)
2751 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2752 for (h = host; h != last->next; h = h->next)
2753 debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2754 (h->address == NULL)? US"<null>" : h->address, h->mx, h->sort_key,
2755 (h->status >= hstatus_unusable)? US"*" : US"");
2756 }
2757 }
2758
8c51eead
JH
2759 yield = rc;
2760 goto out;
059ec3d9
PH
2761 }
2762
2763/* We have found one or more MX or SRV records. Sort them according to
2764precedence. Put the data for the first one into the existing host block, and
2765insert new host_item blocks into the chain for the remainder. For equal
2766precedences one is supposed to randomize the order. To make this happen, the
2767sorting is actually done on the MX value * 1000 + a random number. This is put
2768into a host field called sort_key.
2769
2770In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2771IPv6 address in preference. At this stage, we don't know what kind of address
2772the host has. We choose a random number < 500; if later we find an A record
2773first, we add 500 to the random number. Then for any other address records, we
2774use random numbers in the range 0-499 for AAAA records and 500-999 for A
2775records.
2776
2777At this point we remove any duplicates that point to the same host, retaining
2778only the one with the lowest precedence. We cannot yet check for precedence
2779greater than that of the local host, because that test cannot be properly done
2780until the addresses have been found - an MX record may point to a name for this
2781host which is not the primary hostname. */
2782
2783last = NULL; /* Indicates that not even the first item is filled yet */
2784
2785for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
dd708fd7
JH
2786 rr;
2787 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT)) if (rr->type == ind_type)
059ec3d9
PH
2788 {
2789 int precedence;
2790 int weight = 0; /* For SRV records */
1349e1e5 2791 int port = PORT_NONE;
dd708fd7 2792 const uschar * s = rr->data; /* MUST be unsigned for GETSHORT */
059ec3d9
PH
2793 uschar data[256];
2794
059ec3d9
PH
2795 GETSHORT(precedence, s); /* Pointer s is advanced */
2796
2797 /* For MX records, we use a random "weight" which causes multiple records of
2798 the same precedence to sort randomly. */
2799
2800 if (ind_type == T_MX)
059ec3d9 2801 weight = random_number(500);
059ec3d9
PH
2802
2803 /* SRV records are specified with a port and a weight. The weight is used
2804 in a special algorithm. However, to start with, we just use it to order the
2805 records of equal priority (precedence). */
2806
2807 else
2808 {
2809 GETSHORT(weight, s);
2810 GETSHORT(port, s);
2811 }
2812
2813 /* Get the name of the host pointed to. */
2814
2815 (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, s,
2816 (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2817
2818 /* Check that we haven't already got this host on the chain; if we have,
2819 keep only the lower precedence. This situation shouldn't occur, but you
2820 never know what junk might get into the DNS (and this case has been seen on
2821 more than one occasion). */
2822
2823 if (last != NULL) /* This is not the first record */
2824 {
2825 host_item *prev = NULL;
2826
2827 for (h = host; h != last->next; prev = h, h = h->next)
2828 {
2829 if (strcmpic(h->name, data) == 0)
2830 {
2831 DEBUG(D_host_lookup)
2832 debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2833 (precedence > h->mx)? precedence : h->mx);
2834 if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2835 if (h == host) /* Override first item */
2836 {
2837 h->mx = precedence;
2838 host->sort_key = precedence * 1000 + weight;
2839 goto NEXT_MX_RR;
2840 }
2841
2842 /* Unwanted host item is not the first in the chain, so we can get
2843 get rid of it by cutting it out. */
2844
2845 prev->next = h->next;
2846 if (h == last) last = prev;
2847 break;
2848 }
2849 }
2850 }
2851
2852 /* If this is the first MX or SRV record, put the data into the existing host
2853 block. Otherwise, add a new block in the correct place; if it has to be
2854 before the first block, copy the first block's data to a new second block. */
2855
2856 if (last == NULL)
2857 {
2858 host->name = string_copy_dnsdomain(data);
2859 host->address = NULL;
2860 host->port = port;
2861 host->mx = precedence;
2862 host->sort_key = precedence * 1000 + weight;
2863 host->status = hstatus_unknown;
2864 host->why = hwhy_unknown;
783b385f 2865 host->dnssec = dnssec;
059ec3d9
PH
2866 last = host;
2867 }
2868
2869 /* Make a new host item and seek the correct insertion place */
2870
2871 else
2872 {
2873 int sort_key = precedence * 1000 + weight;
2874 host_item *next = store_get(sizeof(host_item));
2875 next->name = string_copy_dnsdomain(data);
2876 next->address = NULL;
2877 next->port = port;
2878 next->mx = precedence;
2879 next->sort_key = sort_key;
2880 next->status = hstatus_unknown;
2881 next->why = hwhy_unknown;
783b385f 2882 next->dnssec = dnssec;
059ec3d9
PH
2883 next->last_try = 0;
2884
2885 /* Handle the case when we have to insert before the first item. */
2886
2887 if (sort_key < host->sort_key)
2888 {
2889 host_item htemp;
2890 htemp = *host;
2891 *host = *next;
2892 *next = htemp;
2893 host->next = next;
2894 if (last == host) last = next;
2895 }
2896
2897 /* Else scan down the items we have inserted as part of this exercise;
2898 don't go further. */
2899
2900 else
2901 {
2902 for (h = host; h != last; h = h->next)
2903 {
2904 if (sort_key < h->next->sort_key)
2905 {
2906 next->next = h->next;
2907 h->next = next;
2908 break;
2909 }
2910 }
2911
2912 /* Join on after the last host item that's part of this
2913 processing if we haven't stopped sooner. */
2914
2915 if (h == last)
2916 {
2917 next->next = last->next;
2918 last->next = next;
2919 last = next;
2920 }
2921 }
2922 }
2923
2924 NEXT_MX_RR: continue;
2925 }
2926
dc8091e7
JH
2927if (!last) /* No rr of correct type; give up */
2928 {
2929 yield = HOST_FIND_FAILED;
2930 goto out;
2931 }
2932
059ec3d9
PH
2933/* If the list of hosts was obtained from SRV records, there are two things to
2934do. First, if there is only one host, and it's name is ".", it means there is
2935no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2936priority according to their weights, using an algorithm that is defined in RFC
29372782. The hosts are currently sorted by priority and weight. For each priority
2938group we have to pick off one host and put it first, and then repeat for any
2939remaining in the same priority group. */
2940
2941if (ind_type == T_SRV)
2942 {
2943 host_item **pptr;
2944
2945 if (host == last && host->name[0] == 0)
2946 {
2947 DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
8c51eead
JH
2948 yield = HOST_FIND_FAILED;
2949 goto out;
059ec3d9
PH
2950 }
2951
2952 DEBUG(D_host_lookup)
2953 {
2954 debug_printf("original ordering of hosts from SRV records:\n");
2955 for (h = host; h != last->next; h = h->next)
2956 debug_printf(" %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2957 }
2958
dc8091e7 2959 for (pptr = &host, h = host; h != last; pptr = &h->next, h = h->next)
059ec3d9
PH
2960 {
2961 int sum = 0;
2962 host_item *hh;
2963
2964 /* Find the last following host that has the same precedence. At the same
2965 time, compute the sum of the weights and the running totals. These can be
2966 stored in the sort_key field. */
2967
2968 for (hh = h; hh != last; hh = hh->next)
2969 {
2970 int weight = hh->sort_key % 1000; /* was precedence * 1000 + weight */
2971 sum += weight;
2972 hh->sort_key = sum;
2973 if (hh->mx != hh->next->mx) break;
2974 }
2975
2976 /* If there's more than one host at this precedence (priority), we need to
2977 pick one to go first. */
2978
2979 if (hh != h)
2980 {
2981 host_item *hhh;
2982 host_item **ppptr;
2983 int randomizer = random_number(sum + 1);
2984
2985 for (ppptr = pptr, hhh = h;
2986 hhh != hh;
2987 ppptr = &(hhh->next), hhh = hhh->next)
2988 {
2989 if (hhh->sort_key >= randomizer) break;
2990 }
2991
2992 /* hhh now points to the host that should go first; ppptr points to the
2993 place that points to it. Unfortunately, if the start of the minilist is
2994 the start of the entire list, we can't just swap the items over, because
2995 we must not change the value of host, since it is passed in from outside.
2996 One day, this could perhaps be changed.
2997
2998 The special case is fudged by putting the new item *second* in the chain,
2999 and then transferring the data between the first and second items. We
3000 can't just swap the first and the chosen item, because that would mean
3001 that an item with zero weight might no longer be first. */
3002
3003 if (hhh != h)
3004 {
3005 *ppptr = hhh->next; /* Cuts it out of the chain */
3006
3007 if (h == host)
3008 {
3009 host_item temp = *h;
3010 *h = *hhh;
3011 *hhh = temp;
3012 hhh->next = temp.next;
3013 h->next = hhh;
3014 }
3015
3016 else
3017 {
3018 hhh->next = h; /* The rest of the chain follows it */
3019 *pptr = hhh; /* It takes the place of h */
3020 h = hhh; /* It's now the start of this minilist */
3021 }
3022 }
3023 }
3024
3025 /* A host has been chosen to be first at this priority and h now points
3026 to this host. There may be others at the same priority, or others at a
3027 different priority. Before we leave this host, we need to put back a sort
3028 key of the traditional MX kind, in case this host is multihomed, because
3029 the sort key is used for ordering the multiple IP addresses. We do not need
3030 to ensure that these new sort keys actually reflect the order of the hosts,
3031 however. */
3032
3033 h->sort_key = h->mx * 1000 + random_number(500);
3034 } /* Move on to the next host */
3035 }
3036
1349e1e5
PH
3037/* Now we have to find IP addresses for all the hosts. We have ensured above
3038that the names in all the host items are unique. Before release 4.61 we used to
3039process records from the additional section in the DNS packet that returned the
3040MX or SRV records. However, a DNS name server is free to drop any resource
3041records from the additional section. In theory, this has always been a
3042potential problem, but it is exacerbated by the advent of IPv6. If a host had
3043several IPv4 addresses and some were not in the additional section, at least
3044Exim would try the others. However, if a host had both IPv4 and IPv6 addresses
3045and all the IPv4 (say) addresses were absent, Exim would try only for a IPv6
3046connection, and never try an IPv4 address. When there was only IPv4
3047connectivity, this was a disaster that did in practice occur.
3048
3049So, from release 4.61 onwards, we always search for A and AAAA records
3050explicitly. The names shouldn't point to CNAMES, but we use the general lookup
3051function that handles them, just in case. If any lookup gives a soft error,
3052change the default yield.
059ec3d9
PH
3053
3054For these DNS lookups, we must disable qualify_single and search_parents;
3055otherwise invalid host names obtained from MX or SRV records can cause trouble
3056if they happen to match something local. */
3057
1349e1e5 3058yield = HOST_FIND_FAILED; /* Default yield */
8c51eead
JH
3059dns_init(FALSE, FALSE, /* Disable qualify_single and search_parents */
3060 dnssec_request || dnssec_require);
059ec3d9
PH
3061
3062for (h = host; h != last->next; h = h->next)
3063 {
dc8091e7
JH
3064 if (h->address) continue; /* Inserted by a multihomed host */
3065
8c51eead 3066 rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip,
4e0983dc 3067 NULL, dnssec_request, dnssec_require);
059ec3d9
PH
3068 if (rc != HOST_FOUND)
3069 {
3070 h->status = hstatus_unusable;
2546388c 3071 switch (rc)
059ec3d9 3072 {
2546388c
JH
3073 case HOST_FIND_AGAIN:
3074 yield = rc; h->why = hwhy_deferred; break;
3075 case HOST_FIND_SECURITY:
3076 yield = rc; h->why = hwhy_insecure; break;
3077 case HOST_IGNORED:
3078 h->why = hwhy_ignored; break;
3079 default:
3080 h->why = hwhy_failed; break;
059ec3d9 3081 }
059ec3d9
PH
3082 }
3083 }
3084
3085/* Scan the list for any hosts that are marked unusable because they have
3086been explicitly ignored, and remove them from the list, as if they did not
3087exist. If we end up with just a single, ignored host, flatten its fields as if
3088nothing was found. */
3089
2546388c 3090if (ignore_target_hosts)
059ec3d9
PH
3091 {
3092 host_item *prev = NULL;
3093 for (h = host; h != last->next; h = h->next)
3094 {
3095 REDO:
3096 if (h->why != hwhy_ignored) /* Non ignored host, just continue */
3097 prev = h;
3098 else if (prev == NULL) /* First host is ignored */
3099 {
3100 if (h != last) /* First is not last */
3101 {
3102 if (h->next == last) last = h; /* Overwrite it with next */
3103 *h = *(h->next); /* and reprocess it. */
3104 goto REDO; /* C should have redo, like Perl */
3105 }
3106 }
3107 else /* Ignored host is not first - */
3108 { /* cut it out */
3109 prev->next = h->next;
3110 if (h == last) last = prev;
3111 }
3112 }
3113
3114 if (host->why == hwhy_ignored) host->address = NULL;
3115 }
3116
3117/* There is still one complication in the case of IPv6. Although the code above
3118arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
3119hosts, it doesn't do this for addresses that apply to different hosts with the
3120same MX precedence, because the sorting on MX precedence happens first. So we
3121have to make another pass to check for this case. We ensure that, within a
3122single MX preference value, IPv6 addresses come first. This can separate the
3123addresses of a multihomed host, but that should not matter. */
3124
3125#if HAVE_IPV6
2546388c 3126if (h != last && !disable_ipv6) for (h = host; h != last; h = h->next)
059ec3d9 3127 {
2546388c
JH
3128 host_item temp;
3129 host_item *next = h->next;
3130
3131 if (h->mx != next->mx || /* If next is different MX */
3132 h->address == NULL || /* OR this one is unset */
3133 Ustrchr(h->address, ':') != NULL || /* OR this one is IPv6 */
3134 (next->address != NULL &&
3135 Ustrchr(next->address, ':') == NULL)) /* OR next is IPv4 */
3136 continue; /* move on to next */
3137 temp = *h; /* otherwise, swap */
3138 temp.next = next->next;
3139 *h = *next;
3140 h->next = next;
3141 *next = temp;
059ec3d9
PH
3142 }
3143#endif
3144
059ec3d9
PH
3145/* Remove any duplicate IP addresses and then scan the list of hosts for any
3146whose IP addresses are on the local host. If any are found, all hosts with the
3147same or higher MX values are removed. However, if the local host has the lowest
3148numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
3149with an IP address is on the list, HOST_FOUND is returned. Otherwise,
3150HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
3151might have been set to HOST_FIND_AGAIN just above here. If not, it will already
3152be HOST_FIND_FAILED. */
3153
3154host_remove_duplicates(host, &last);
3155rc = host_scan_for_local_hosts(host, &last, removed);
3156if (rc != HOST_FIND_FAILED) yield = rc;
3157
3158DEBUG(D_host_lookup)
3159 {
3160 if (fully_qualified_name != NULL)
3161 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
3162 debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
3163 (yield == HOST_FOUND)? "HOST_FOUND" :
3164 (yield == HOST_FOUND_LOCAL)? "HOST_FOUND_LOCAL" :
2546388c 3165 (yield == HOST_FIND_SECURITY)? "HOST_FIND_SECURITY" :
059ec3d9
PH
3166 (yield == HOST_FIND_AGAIN)? "HOST_FIND_AGAIN" :
3167 (yield == HOST_FIND_FAILED)? "HOST_FIND_FAILED" : "?",
3168 yield);
3169 for (h = host; h != last->next; h = h->next)
3170 {
805c9d53
JH
3171 debug_printf(" %s %s MX=%d %s", h->name,
3172 !h->address ? US"<null>" : h->address, h->mx,
3173 h->dnssec == DS_YES ? US"DNSSEC " : US"");
059ec3d9
PH
3174 if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
3175 if (h->status >= hstatus_unusable) debug_printf("*");
3176 debug_printf("\n");
3177 }
3178 }
3179
8c51eead
JH
3180out:
3181
3182dns_init(FALSE, FALSE, FALSE); /* clear the dnssec bit for getaddrbyname */
059ec3d9
PH
3183return yield;
3184}
3185
059ec3d9
PH
3186/*************************************************
3187**************************************************
3188* Stand-alone test program *
3189**************************************************
3190*************************************************/
3191
3192#ifdef STAND_ALONE
3193
059ec3d9
PH
3194int main(int argc, char **cargv)
3195{
3196host_item h;
3197int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A;
3198BOOL byname = FALSE;
3199BOOL qualify_single = TRUE;
3200BOOL search_parents = FALSE;
8c51eead
JH
3201BOOL request_dnssec = FALSE;
3202BOOL require_dnssec = FALSE;
059ec3d9
PH
3203uschar **argv = USS cargv;
3204uschar buffer[256];
3205
322050c2 3206disable_ipv6 = FALSE;
059ec3d9
PH
3207primary_hostname = US"";
3208store_pool = POOL_MAIN;
3209debug_selector = D_host_lookup|D_interface;
3210debug_file = stdout;
3211debug_fd = fileno(debug_file);
3212
3213printf("Exim stand-alone host functions test\n");
3214
3215host_find_interfaces();
3216debug_selector = D_host_lookup | D_dns;
3217
3218if (argc > 1) primary_hostname = argv[1];
3219
3220/* So that debug level changes can be done first */
3221
8c51eead 3222dns_init(qualify_single, search_parents, FALSE);
059ec3d9
PH
3223
3224printf("Testing host lookup\n");
3225printf("> ");
3226while (Ufgets(buffer, 256, stdin) != NULL)
3227 {
3228 int rc;
3229 int len = Ustrlen(buffer);
3230 uschar *fully_qualified_name;
3231
3232 while (len > 0 && isspace(buffer[len-1])) len--;
3233 buffer[len] = 0;
3234
3235 if (Ustrcmp(buffer, "q") == 0) break;
3236
3237 if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3238 else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3239 else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A;
3240 else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3241 else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3242 else if (Ustrcmp(buffer, "srv+a") == 0)
3243 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A;
3244 else if (Ustrcmp(buffer, "srv+mx") == 0)
3245 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3246 else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3247 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A;
8c51eead 3248 else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
059ec3d9 3249 else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
8c51eead 3250 else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
059ec3d9 3251 else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
8c51eead
JH
3252 else if (Ustrcmp(buffer, "request_dnssec") == 0) request_dnssec = TRUE;
3253 else if (Ustrcmp(buffer, "no_request_dnssec") == 0) request_dnssec = FALSE;
3254 else if (Ustrcmp(buffer, "require_dnssec") == 0) require_dnssec = TRUE;
f988ce57 3255 else if (Ustrcmp(buffer, "no_require_dnssec") == 0) require_dnssec = FALSE;
e7726cbf
PH
3256 else if (Ustrcmp(buffer, "test_harness") == 0)
3257 running_in_test_harness = !running_in_test_harness;
322050c2 3258 else if (Ustrcmp(buffer, "ipv6") == 0) disable_ipv6 = !disable_ipv6;
e7726cbf
PH
3259 else if (Ustrcmp(buffer, "res_debug") == 0)
3260 {
3261 _res.options ^= RES_DEBUG;
3262 }
059ec3d9
PH
3263 else if (Ustrncmp(buffer, "retrans", 7) == 0)
3264 {
ff790e47 3265 (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
059ec3d9
PH
3266 _res.retrans = dns_retrans;
3267 }
3268 else if (Ustrncmp(buffer, "retry", 5) == 0)
3269 {
ff790e47 3270 (void)sscanf(CS(buffer+6), "%d", &dns_retry);
059ec3d9
PH
3271 _res.retry = dns_retry;
3272 }
059ec3d9
PH
3273 else
3274 {
3275 int flags = whichrrs;
505d976a 3276 dnssec_domains d;
059ec3d9
PH
3277
3278 h.name = buffer;
3279 h.next = NULL;
3280 h.mx = MX_NONE;
3281 h.port = PORT_NONE;
3282 h.status = hstatus_unknown;
3283 h.why = hwhy_unknown;
3284 h.address = NULL;
3285
3286 if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3287 if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3288
7cd171b7
JH
3289 d.request = request_dnssec ? &h.name : NULL;
3290 d.require = require_dnssec ? &h.name : NULL;
3291
8c51eead
JH
3292 rc = byname
3293 ? host_find_byname(&h, NULL, flags, &fully_qualified_name, TRUE)
3294 : host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
7cd171b7 3295 &d, &fully_qualified_name, NULL);
059ec3d9 3296
2546388c
JH
3297 switch (rc)
3298 {
3299 case HOST_FIND_FAILED: printf("Failed\n"); break;
3300 case HOST_FIND_AGAIN: printf("Again\n"); break;
3301 case HOST_FIND_SECURITY: printf("Security\n"); break;
3302 case HOST_FOUND_LOCAL: printf("Local\n"); break;
3303 }
059ec3d9
PH
3304 }
3305
3306 printf("\n> ");
3307 }
3308
3309printf("Testing host_aton\n");
3310printf("> ");
3311while (Ufgets(buffer, 256, stdin) != NULL)
3312 {
3313 int i;
3314 int x[4];
3315 int len = Ustrlen(buffer);
3316
3317 while (len > 0 && isspace(buffer[len-1])) len--;
3318 buffer[len] = 0;
3319
3320 if (Ustrcmp(buffer, "q") == 0) break;
3321
3322 len = host_aton(buffer, x);
3323 printf("length = %d ", len);
3324 for (i = 0; i < len; i++)
3325 {
3326 printf("%04x ", (x[i] >> 16) & 0xffff);
3327 printf("%04x ", x[i] & 0xffff);
3328 }
3329 printf("\n> ");
3330 }
3331
3332printf("\n");
3333
3334printf("Testing host_name_lookup\n");
3335printf("> ");
3336while (Ufgets(buffer, 256, stdin) != NULL)
3337 {
3338 int len = Ustrlen(buffer);
3339 while (len > 0 && isspace(buffer[len-1])) len--;
3340 buffer[len] = 0;
3341 if (Ustrcmp(buffer, "q") == 0) break;
3342 sender_host_address = buffer;
3343 sender_host_name = NULL;
3344 sender_host_aliases = NULL;
3345 host_lookup_msg = US"";
3346 host_lookup_failed = FALSE;
3347 if (host_name_lookup() == FAIL) /* Debug causes printing */
3348 printf("Lookup failed:%s\n", host_lookup_msg);
3349 printf("\n> ");
3350 }
3351
3352printf("\n");
3353
3354return 0;
3355}
3356#endif /* STAND_ALONE */
3357
8c51eead
JH
3358/* vi: aw ai sw=2
3359*/
059ec3d9 3360/* End of host.c */