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