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