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