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