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