?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Some cleanups. Add branch prediction.
[glibc/history.git] / sysdeps / posix / getaddrinfo.c
blobfc0928676d89c8e96f4543741b62b7c8a6f18100
1 /* The Inner Net License, Version 2.00
2
3 The author(s) grant permission for redistribution and use in source and
4 binary forms, with or without modification, of the software and documentation
5 provided that the following conditions are met:
6
7 0. If you receive a version of the software that is specifically labelled
8 as not being for redistribution (check the version message and/or README),
9 you are not permitted to redistribute that version of the software in any
10 way or form.
11 1. All terms of the all other applicable copyrights and licenses must be
12 followed.
13 2. Redistributions of source code must retain the authors' copyright
14 notice(s), this list of conditions, and the following disclaimer.
15 3. Redistributions in binary form must reproduce the authors' copyright
16 notice(s), this list of conditions, and the following disclaimer in the
17 documentation and/or other materials provided with the distribution.
18 4. [The copyright holder has authorized the removal of this clause.]
19 5. Neither the name(s) of the author(s) nor the names of its contributors
20 may be used to endorse or promote products derived from this software
21 without specific prior written permission.
22
23 THIS SOFTWARE IS PROVIDED BY ITS AUTHORS AND CONTRIBUTORS ``AS IS'' AND ANY
24 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY
27 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
30 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
34 If these license terms cause you a real problem, contact the author. */
35
36 /* This software is Copyright 1996 by Craig Metz, All Rights Reserved. */
37
38 #include <assert.h>
39 #include <ctype.h>
40 #include <errno.h>
41 #include <ifaddrs.h>
42 #include <netdb.h>
43 #include <resolv.h>
44 #include <stdbool.h>
45 #include <stdio.h>
46 #include <stdio_ext.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <arpa/inet.h>
50 #include <net/if.h>
51 #include <netinet/in.h>
52 #include <sys/socket.h>
53 #include <sys/stat.h>
54 #include <sys/types.h>
55 #include <sys/un.h>
56 #include <sys/utsname.h>
57 #include <unistd.h>
58 #include <nsswitch.h>
59 #include <bits/libc-lock.h>
60 #include <not-cancel.h>
61 #include <nscd/nscd-client.h>
62 #include <nscd/nscd_proto.h>
63
64 #ifdef HAVE_LIBIDN
65 extern int __idna_to_ascii_lz (const char *input, char **output, int flags);
66 extern int __idna_to_unicode_lzlz (const char *input, char **output,
67 int flags);
68 # include <libidn/idna.h>
69 #endif
70
71 #define GAIH_OKIFUNSPEC 0x0100
72 #define GAIH_EAI ~(GAIH_OKIFUNSPEC)
73
74 #ifndef UNIX_PATH_MAX
75 # define UNIX_PATH_MAX 108
76 #endif
77
78 struct gaih_service
79 {
80 const char *name;
81 int num;
82 };
83
84 struct gaih_servtuple
85 {
86 struct gaih_servtuple *next;
87 int socktype;
88 int protocol;
89 int port;
90 };
91
92 static const struct gaih_servtuple nullserv;
93
94 struct gaih_addrtuple
95 {
96 struct gaih_addrtuple *next;
97 char *name;
98 int family;
99 uint32_t addr[4];
100 uint32_t scopeid;
101 };
102
103 struct gaih_typeproto
104 {
105 int socktype;
106 int protocol;
107 char name[4];
108 int protoflag;
109 };
110
111 /* Values for `protoflag'. */
112 #define GAI_PROTO_NOSERVICE 1
113 #define GAI_PROTO_PROTOANY 2
114
115 static const struct gaih_typeproto gaih_inet_typeproto[] =
116 {
117 { 0, 0, "", 0 },
118 { SOCK_STREAM, IPPROTO_TCP, "tcp", 0 },
119 { SOCK_DGRAM, IPPROTO_UDP, "udp", 0 },
120 { SOCK_RAW, 0, "raw", GAI_PROTO_PROTOANY|GAI_PROTO_NOSERVICE },
121 { 0, 0, "", 0 }
122 };
123
124 struct gaih
125 {
126 int family;
127 int (*gaih)(const char *name, const struct gaih_service *service,
128 const struct addrinfo *req, struct addrinfo **pai,
129 unsigned int *naddrs);
130 };
131
132 static const struct addrinfo default_hints =
133 {
134 .ai_flags = AI_DEFAULT,
135 .ai_family = PF_UNSPEC,
136 .ai_socktype = 0,
137 .ai_protocol = 0,
138 .ai_addrlen = 0,
139 .ai_addr = NULL,
140 .ai_canonname = NULL,
141 .ai_next = NULL
142 };
143
144
145 #if 0
146 /* Using Unix sockets this way is a security risk. */
147 static int
148 gaih_local (const char *name, const struct gaih_service *service,
149 const struct addrinfo *req, struct addrinfo **pai)
150 {
151 struct utsname utsname;
152
153 if ((name != NULL) && (req->ai_flags & AI_NUMERICHOST))
154 return GAIH_OKIFUNSPEC | -EAI_NONAME;
155
156 if ((name != NULL) || (req->ai_flags & AI_CANONNAME))
157 if (uname (&utsname) < 0)
158 return -EAI_SYSTEM;
159
160 if (name != NULL)
161 {
162 if (strcmp(name, "localhost") &&
163 strcmp(name, "local") &&
164 strcmp(name, "unix") &&
165 strcmp(name, utsname.nodename))
166 return GAIH_OKIFUNSPEC | -EAI_NONAME;
167 }
168
169 if (req->ai_protocol || req->ai_socktype)
170 {
171 const struct gaih_typeproto *tp = gaih_inet_typeproto + 1;
172
173 while (tp->name[0]
174 && ((tp->protoflag & GAI_PROTO_NOSERVICE) != 0
175 || (req->ai_socktype != 0 && req->ai_socktype != tp->socktype)
176 || (req->ai_protocol != 0
177 && !(tp->protoflag & GAI_PROTO_PROTOANY)
178 && req->ai_protocol != tp->protocol)))
179 ++tp;
180
181 if (! tp->name[0])
182 {
183 if (req->ai_socktype)
184 return GAIH_OKIFUNSPEC | -EAI_SOCKTYPE;
185 else
186 return GAIH_OKIFUNSPEC | -EAI_SERVICE;
187 }
188 }
189
190 *pai = malloc (sizeof (struct addrinfo) + sizeof (struct sockaddr_un)
191 + ((req->ai_flags & AI_CANONNAME)
192 ? (strlen(utsname.nodename) + 1): 0));
193 if (*pai == NULL)
194 return -EAI_MEMORY;
195
196 (*pai)->ai_next = NULL;
197 (*pai)->ai_flags = req->ai_flags;
198 (*pai)->ai_family = AF_LOCAL;
199 (*pai)->ai_socktype = req->ai_socktype ? req->ai_socktype : SOCK_STREAM;
200 (*pai)->ai_protocol = req->ai_protocol;
201 (*pai)->ai_addrlen = sizeof (struct sockaddr_un);
202 (*pai)->ai_addr = (void *) (*pai) + sizeof (struct addrinfo);
203
204 #ifdef _HAVE_SA_LEN
205 ((struct sockaddr_un *) (*pai)->ai_addr)->sun_len =
206 sizeof (struct sockaddr_un);
207 #endif /* _HAVE_SA_LEN */
208
209 ((struct sockaddr_un *)(*pai)->ai_addr)->sun_family = AF_LOCAL;
210 memset(((struct sockaddr_un *)(*pai)->ai_addr)->sun_path, 0, UNIX_PATH_MAX);
211
212 if (service)
213 {
214 struct sockaddr_un *sunp = (struct sockaddr_un *) (*pai)->ai_addr;
215
216 if (strchr (service->name, '/') != NULL)
217 {
218 if (strlen (service->name) >= sizeof (sunp->sun_path))
219 return GAIH_OKIFUNSPEC | -EAI_SERVICE;
220
221 strcpy (sunp->sun_path, service->name);
222 }
223 else
224 {
225 if (strlen (P_tmpdir "/") + 1 + strlen (service->name) >=
226 sizeof (sunp->sun_path))
227 return GAIH_OKIFUNSPEC | -EAI_SERVICE;
228
229 __stpcpy (__stpcpy (sunp->sun_path, P_tmpdir "/"), service->name);
230 }
231 }
232 else
233 {
234 /* This is a dangerous use of the interface since there is a time
235 window between the test for the file and the actual creation
236 (done by the caller) in which a file with the same name could
237 be created. */
238 char *buf = ((struct sockaddr_un *) (*pai)->ai_addr)->sun_path;
239
240 if (__builtin_expect (__path_search (buf, L_tmpnam, NULL, NULL, 0),
241 0) != 0
242 || __builtin_expect (__gen_tempname (buf, __GT_NOCREATE), 0) != 0)
243 return -EAI_SYSTEM;
244 }
245
246 if (req->ai_flags & AI_CANONNAME)
247 (*pai)->ai_canonname = strcpy ((char *) *pai + sizeof (struct addrinfo)
248 + sizeof (struct sockaddr_un),
249 utsname.nodename);
250 else
251 (*pai)->ai_canonname = NULL;
252 return 0;
253 }
254 #endif /* 0 */
255
256
257 static int
258 gaih_inet_serv (const char *servicename, const struct gaih_typeproto *tp,
259 const struct addrinfo *req, struct gaih_servtuple *st)
260 {
261 struct servent *s;
262 size_t tmpbuflen = 1024;
263 struct servent ts;
264 char *tmpbuf;
265 int r;
266
267 do
268 {
269 tmpbuf = __alloca (tmpbuflen);
270
271 r = __getservbyname_r (servicename, tp->name, &ts, tmpbuf, tmpbuflen,
272 &s);
273 if (r != 0 || s == NULL)
274 {
275 if (r == ERANGE)
276 tmpbuflen *= 2;
277 else
278 return GAIH_OKIFUNSPEC | -EAI_SERVICE;
279 }
280 }
281 while (r);
282
283 st->next = NULL;
284 st->socktype = tp->socktype;
285 st->protocol = ((tp->protoflag & GAI_PROTO_PROTOANY)
286 ? req->ai_protocol : tp->protocol);
287 st->port = s->s_port;
288
289 return 0;
290 }
291
292 #define gethosts(_family, _type) \
293 { \
294 int i; \
295 int herrno; \
296 struct hostent th; \
297 struct hostent *h; \
298 char *localcanon = NULL; \
299 no_data = 0; \
300 while (1) { \
301 rc = 0; \
302 status = DL_CALL_FCT (fct, (name, _family, &th, tmpbuf, tmpbuflen, \
303 &rc, &herrno, NULL, &localcanon)); \
304 if (rc != ERANGE || herrno != NETDB_INTERNAL) \
305 break; \
306 tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen); \
307 } \
308 if (status == NSS_STATUS_SUCCESS && rc == 0) \
309 h = &th; \
310 else \
311 h = NULL; \
312 if (rc != 0) \
313 { \
314 if (herrno == NETDB_INTERNAL) \
315 { \
316 __set_h_errno (herrno); \
317 return -EAI_SYSTEM; \
318 } \
319 if (herrno == TRY_AGAIN) \
320 no_data = EAI_AGAIN; \
321 else \
322 no_data = herrno == NO_DATA; \
323 } \
324 else if (h != NULL) \
325 { \
326 for (i = 0; h->h_addr_list[i]; i++) \
327 { \
328 if (*pat == NULL) \
329 { \
330 *pat = __alloca (sizeof (struct gaih_addrtuple)); \
331 (*pat)->scopeid = 0; \
332 } \
333 uint32_t *addr = (*pat)->addr; \
334 (*pat)->next = NULL; \
335 (*pat)->name = i == 0 ? strdupa (h->h_name) : NULL; \
336 if (_family == AF_INET && req->ai_family == AF_INET6) \
337 { \
338 (*pat)->family = AF_INET6; \
339 addr[3] = *(uint32_t *) h->h_addr_list[i]; \
340 addr[2] = htonl (0xffff); \
341 addr[1] = 0; \
342 addr[0] = 0; \
343 } \
344 else \
345 { \
346 (*pat)->family = _family; \
347 memcpy (addr, h->h_addr_list[i], sizeof(_type)); \
348 } \
349 pat = &((*pat)->next); \
350 } \
351 \
352 if (localcanon != NULL && canon == NULL) \
353 canon = strdupa (localcanon); \
354 \
355 if (_family == AF_INET6 && i > 0) \
356 got_ipv6 = true; \
357 } \
358 }
359
360
361 typedef enum nss_status (*nss_gethostbyname3_r)
362 (const char *name, int af, struct hostent *host,
363 char *buffer, size_t buflen, int *errnop,
364 int *h_errnop, int32_t *ttlp, char **canonp);
365 typedef enum nss_status (*nss_getcanonname_r)
366 (const char *name, char *buffer, size_t buflen, char **result,
367 int *errnop, int *h_errnop);
368 extern service_user *__nss_hosts_database attribute_hidden;
369
370
371 static int
372 gaih_inet (const char *name, const struct gaih_service *service,
373 const struct addrinfo *req, struct addrinfo **pai,
374 unsigned int *naddrs)
375 {
376 const struct gaih_typeproto *tp = gaih_inet_typeproto;
377 struct gaih_servtuple *st = (struct gaih_servtuple *) &nullserv;
378 struct gaih_addrtuple *at = NULL;
379 int rc;
380 bool got_ipv6 = false;
381 const char *canon = NULL;
382 const char *orig_name = name;
383
384 if (req->ai_protocol || req->ai_socktype)
385 {
386 ++tp;
387
388 while (tp->name[0]
389 && ((req->ai_socktype != 0 && req->ai_socktype != tp->socktype)
390 || (req->ai_protocol != 0
391 && !(tp->protoflag & GAI_PROTO_PROTOANY)
392 && req->ai_protocol != tp->protocol)))
393 ++tp;
394
395 if (! tp->name[0])
396 {
397 if (req->ai_socktype)
398 return GAIH_OKIFUNSPEC | -EAI_SOCKTYPE;
399 else
400 return GAIH_OKIFUNSPEC | -EAI_SERVICE;
401 }
402 }
403
404 int port = 0;
405 if (service != NULL)
406 {
407 if ((tp->protoflag & GAI_PROTO_NOSERVICE) != 0)
408 return GAIH_OKIFUNSPEC | -EAI_SERVICE;
409
410 if (service->num < 0)
411 {
412 if (tp->name[0])
413 {
414 st = (struct gaih_servtuple *)
415 __alloca (sizeof (struct gaih_servtuple));
416
417 if ((rc = gaih_inet_serv (service->name, tp, req, st)))
418 return rc;
419 }
420 else
421 {
422 struct gaih_servtuple **pst = &st;
423 for (tp++; tp->name[0]; tp++)
424 {
425 struct gaih_servtuple *newp;
426
427 if ((tp->protoflag & GAI_PROTO_NOSERVICE) != 0)
428 continue;
429
430 if (req->ai_socktype != 0
431 && req->ai_socktype != tp->socktype)
432 continue;
433 if (req->ai_protocol != 0
434 && !(tp->protoflag & GAI_PROTO_PROTOANY)
435 && req->ai_protocol != tp->protocol)
436 continue;
437
438 newp = (struct gaih_servtuple *)
439 __alloca (sizeof (struct gaih_servtuple));
440
441 if ((rc = gaih_inet_serv (service->name, tp, req, newp)))
442 {
443 if (rc & GAIH_OKIFUNSPEC)
444 continue;
445 return rc;
446 }
447
448 *pst = newp;
449 pst = &(newp->next);
450 }
451 if (st == (struct gaih_servtuple *) &nullserv)
452 return GAIH_OKIFUNSPEC | -EAI_SERVICE;
453 }
454 }
455 else
456 {
457 port = htons (service->num);
458 goto got_port;
459 }
460 }
461 else
462 {
463 got_port:
464
465 if (req->ai_socktype || req->ai_protocol)
466 {
467 st = __alloca (sizeof (struct gaih_servtuple));
468 st->next = NULL;
469 st->socktype = tp->socktype;
470 st->protocol = ((tp->protoflag & GAI_PROTO_PROTOANY)
471 ? req->ai_protocol : tp->protocol);
472 st->port = port;
473 }
474 else
475 {
476 /* Neither socket type nor protocol is set. Return all socket types
477 we know about. */
478 struct gaih_servtuple **lastp = &st;
479 for (++tp; tp->name[0]; ++tp)
480 {
481 struct gaih_servtuple *newp;
482
483 newp = __alloca (sizeof (struct gaih_servtuple));
484 newp->next = NULL;
485 newp->socktype = tp->socktype;
486 newp->protocol = tp->protocol;
487 newp->port = port;
488
489 *lastp = newp;
490 lastp = &newp->next;
491 }
492 }
493 }
494
495 if (name != NULL)
496 {
497 at = __alloca (sizeof (struct gaih_addrtuple));
498
499 at->family = AF_UNSPEC;
500 at->scopeid = 0;
501 at->next = NULL;
502
503 #ifdef HAVE_LIBIDN
504 if (req->ai_flags & AI_IDN)
505 {
506 int idn_flags = 0;
507 if (req->ai_flags & AI_IDN_ALLOW_UNASSIGNED)
508 idn_flags |= IDNA_ALLOW_UNASSIGNED;
509 if (req->ai_flags & AI_IDN_USE_STD3_ASCII_RULES)
510 idn_flags |= IDNA_USE_STD3_ASCII_RULES;
511
512 char *p = NULL;
513 rc = __idna_to_ascii_lz (name, &p, idn_flags);
514 if (rc != IDNA_SUCCESS)
515 {
516 if (rc == IDNA_MALLOC_ERROR)
517 return -EAI_MEMORY;
518 if (rc == IDNA_DLOPEN_ERROR)
519 return -EAI_SYSTEM;
520 return -EAI_IDN_ENCODE;
521 }
522 /* In case the output string is the same as the input string
523 no new string has been allocated. */
524 if (p != name)
525 {
526 name = strdupa (p);
527 free (p);
528 }
529 }
530 #endif
531
532 if (__inet_aton (name, (struct in_addr *) at->addr) != 0)
533 {
534 if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET)
535 at->family = AF_INET;
536 else if (req->ai_family == AF_INET6 && (req->ai_flags & AI_V4MAPPED))
537 {
538 at->addr[3] = at->addr[0];
539 at->addr[2] = htonl (0xffff);
540 at->addr[1] = 0;
541 at->addr[0] = 0;
542 at->family = AF_INET6;
543 }
544 else
545 return -EAI_ADDRFAMILY;
546
547 if (req->ai_flags & AI_CANONNAME)
548 canon = name;
549 }
550 else if (at->family == AF_UNSPEC)
551 {
552 char *namebuf = (char *) name;
553 char *scope_delim = strchr (name, SCOPE_DELIMITER);
554
555 if (__builtin_expect (scope_delim != NULL, 0))
556 {
557 namebuf = alloca (scope_delim - name + 1);
558 *((char *) __mempcpy (namebuf, name, scope_delim - name)) = '\0';
559 }
560
561 if (inet_pton (AF_INET6, namebuf, at->addr) > 0)
562 {
563 if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET6)
564 at->family = AF_INET6;
565 else if (req->ai_family == AF_INET
566 && IN6_IS_ADDR_V4MAPPED (at->addr))
567 {
568 at->addr[0] = at->addr[3];
569 at->family = AF_INET;
570 }
571 else
572 return -EAI_ADDRFAMILY;
573
574 if (scope_delim != NULL)
575 {
576 int try_numericscope = 0;
577 if (IN6_IS_ADDR_LINKLOCAL (at->addr)
578 || IN6_IS_ADDR_MC_LINKLOCAL (at->addr))
579 {
580 at->scopeid = if_nametoindex (scope_delim + 1);
581 if (at->scopeid == 0)
582 try_numericscope = 1;
583 }
584 else
585 try_numericscope = 1;
586
587 if (try_numericscope != 0)
588 {
589 char *end;
590 assert (sizeof (uint32_t) <= sizeof (unsigned long));
591 at->scopeid = (uint32_t) strtoul (scope_delim + 1, &end,
592 10);
593 if (*end != '\0')
594 return GAIH_OKIFUNSPEC | -EAI_NONAME;
595 }
596 }
597
598 if (req->ai_flags & AI_CANONNAME)
599 canon = name;
600 }
601 }
602
603 if (at->family == AF_UNSPEC && (req->ai_flags & AI_NUMERICHOST) == 0)
604 {
605 struct gaih_addrtuple **pat = &at;
606 int no_data = 0;
607 int no_inet6_data = 0;
608 service_user *nip = NULL;
609 enum nss_status inet6_status = NSS_STATUS_UNAVAIL;
610 enum nss_status status = NSS_STATUS_UNAVAIL;
611 int no_more;
612 int old_res_options;
613
614 /* If we do not have to look for IPv4 and IPv6 together, use
615 the simple, old functions. */
616 if (req->ai_family == AF_INET
617 || (req->ai_family == AF_INET6
618 && ((req->ai_flags & AI_V4MAPPED) == 0
619 || (req->ai_flags & AI_ALL) == 0)))
620 {
621 int family = req->ai_family;
622 size_t tmpbuflen = 512;
623 char *tmpbuf = alloca (tmpbuflen);
624 int rc;
625 struct hostent th;
626 struct hostent *h;
627 int herrno;
628
629 simple_again:
630 while (1)
631 {
632 rc = __gethostbyname2_r (name, family, &th, tmpbuf,
633 tmpbuflen, &h, &herrno);
634 if (rc != ERANGE || herrno != NETDB_INTERNAL)
635 break;
636 tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
637 }
638
639 if (rc == 0)
640 {
641 if (h == NULL)
642 {
643 if (req->ai_family == AF_INET6
644 && (req->ai_flags & AI_V4MAPPED)
645 && family == AF_INET6)
646 {
647 /* Try again, this time looking for IPv4
648 addresses. */
649 family = AF_INET;
650 goto simple_again;
651 }
652 }
653 else
654 {
655 /* We found data, now convert it into the list. */
656 for (int i = 0; h->h_addr_list[i]; ++i)
657 {
658 if (*pat == NULL)
659 {
660 *pat = __alloca (sizeof (struct gaih_addrtuple));
661 (*pat)->scopeid = 0;
662 }
663 (*pat)->next = NULL;
664 (*pat)->family = req->ai_family;
665 if (family == req->ai_family)
666 memcpy ((*pat)->addr, h->h_addr_list[i],
667 h->h_length);
668 else
669 {
670 uint32_t *addr = (uint32_t *) (*pat)->addr;
671 addr[3] = *(uint32_t *) h->h_addr_list[i];
672 addr[2] = htonl (0xffff);
673 addr[1] = 0;
674 addr[0] = 0;
675 }
676 pat = &((*pat)->next);
677 }
678 }
679 }
680 else
681 {
682 if (herrno == NETDB_INTERNAL)
683 {
684 __set_h_errno (herrno);
685 return -EAI_SYSTEM;
686 }
687 if (herrno == TRY_AGAIN)
688 {
689 return -EAI_AGAIN;
690 }
691 /* We made requests but they turned out no data.
692 The name is known, though. */
693 return GAIH_OKIFUNSPEC | -EAI_NODATA;
694 }
695
696 goto process_list;
697 }
698
699 #ifdef USE_NSCD
700 if (__nss_not_use_nscd_hosts > 0
701 && ++__nss_not_use_nscd_hosts > NSS_NSCD_RETRY)
702 __nss_not_use_nscd_hosts = 0;
703
704 if (!__nss_not_use_nscd_hosts)
705 {
706 /* Try to use nscd. */
707 struct nscd_ai_result *air = NULL;
708 int herrno;
709 int err = __nscd_getai (name, &air, &herrno);
710 if (air != NULL)
711 {
712 /* Transform into gaih_addrtuple list. */
713 bool added_canon = (req->ai_flags & AI_CANONNAME) == 0;
714 char *addrs = air->addrs;
715
716 for (int i = 0; i < air->naddrs; ++i)
717 {
718 socklen_t size = (air->family[i] == AF_INET
719 ? INADDRSZ : IN6ADDRSZ);
720 if (*pat == NULL)
721 {
722 *pat = __alloca (sizeof (struct gaih_addrtuple));
723 (*pat)->scopeid = 0;
724 }
725 uint32_t *pataddr = (*pat)->addr;
726 (*pat)->next = NULL;
727 if (added_canon || air->canon == NULL)
728 (*pat)->name = NULL;
729 else
730 canon = (*pat)->name = strdupa (air->canon);
731
732 if (air->family[i] == AF_INET
733 && req->ai_family == AF_INET6
734 && (req->ai_flags & AI_V4MAPPED))
735 {
736 (*pat)->family = AF_INET6;
737 pataddr[3] = *(uint32_t *) addrs;
738 pataddr[2] = htonl (0xffff);
739 pataddr[1] = 0;
740 pataddr[0] = 0;
741 pat = &((*pat)->next);
742 added_canon = true;
743 }
744 else if (req->ai_family == AF_UNSPEC
745 || air->family[i] == req->ai_family)
746 {
747 (*pat)->family = air->family[i];
748 memcpy (pataddr, addrs, size);
749 pat = &((*pat)->next);
750 added_canon = true;
751 if (air->family[i] == AF_INET6)
752 got_ipv6 = true;
753 }
754 addrs += size;
755 }
756
757 free (air);
758
759 if (at->family == AF_UNSPEC)
760 return GAIH_OKIFUNSPEC | -EAI_NONAME;
761
762 goto process_list;
763 }
764 else if (err != 0 && __nss_not_use_nscd_hosts == 0)
765 {
766 if (herrno == NETDB_INTERNAL && errno == ENOMEM)
767 return -EAI_MEMORY;
768 if (herrno == TRY_AGAIN)
769 return -EAI_AGAIN;
770 return -EAI_SYSTEM;
771 }
772 }
773 #endif
774
775 if (__nss_hosts_database != NULL)
776 {
777 no_more = 0;
778 nip = __nss_hosts_database;
779 }
780 else
781 no_more = __nss_database_lookup ("hosts", NULL,
782 "dns [!UNAVAIL=return] files",
783 &nip);
784
785 if (__res_maybe_init (&_res, 0) == -1)
786 no_more = 1;
787
788 /* If we are looking for both IPv4 and IPv6 address we don't
789 want the lookup functions to automatically promote IPv4
790 addresses to IPv6 addresses. Currently this is decided
791 by setting the RES_USE_INET6 bit in _res.options. */
792 old_res_options = _res.options;
793 _res.options &= ~RES_USE_INET6;
794
795 size_t tmpbuflen = 512;
796 char *tmpbuf = alloca (tmpbuflen);
797
798 while (!no_more)
799 {
800 nss_gethostbyname3_r fct = NULL;
801 if (req->ai_flags & AI_CANONNAME)
802 /* No need to use this function if we do not look for
803 the canonical name. The function does not exist in
804 all NSS modules and therefore the lookup would
805 often fail. */
806 fct = __nss_lookup_function (nip, "gethostbyname3_r");
807 if (fct == NULL)
808 /* We are cheating here. The gethostbyname2_r function does
809 not have the same interface as gethostbyname3_r but the
810 extra arguments the latter takes are added at the end.
811 So the gethostbyname2_r code will just ignore them. */
812 fct = __nss_lookup_function (nip, "gethostbyname2_r");
813
814 if (fct != NULL)
815 {
816 if (req->ai_family == AF_INET6
817 || req->ai_family == AF_UNSPEC)
818 {
819 gethosts (AF_INET6, struct in6_addr);
820 no_inet6_data = no_data;
821 inet6_status = status;
822 }
823 if (req->ai_family == AF_INET
824 || req->ai_family == AF_UNSPEC
825 || (req->ai_family == AF_INET6
826 && (req->ai_flags & AI_V4MAPPED)
827 /* Avoid generating the mapped addresses if we
828 know we are not going to need them. */
829 && ((req->ai_flags & AI_ALL) || !got_ipv6)))
830 {
831 gethosts (AF_INET, struct in_addr);
832
833 if (req->ai_family == AF_INET)
834 {
835 no_inet6_data = no_data;
836 inet6_status = status;
837 }
838 }
839
840 /* If we found one address for AF_INET or AF_INET6,
841 don't continue the search. */
842 if (inet6_status == NSS_STATUS_SUCCESS
843 || status == NSS_STATUS_SUCCESS)
844 {
845 if ((req->ai_flags & AI_CANONNAME) != 0 && canon == NULL)
846 {
847 /* If we need the canonical name, get it
848 from the same service as the result. */
849 nss_getcanonname_r cfct;
850 int herrno;
851
852 cfct = __nss_lookup_function (nip, "getcanonname_r");
853 if (cfct != NULL)
854 {
855 const size_t max_fqdn_len = 256;
856 char *buf = alloca (max_fqdn_len);
857 char *s;
858
859 if (DL_CALL_FCT (cfct, (at->name ?: name, buf,
860 max_fqdn_len, &s, &rc,
861 &herrno))
862 == NSS_STATUS_SUCCESS)
863 canon = s;
864 else
865 /* Set to name now to avoid using
866 gethostbyaddr. */
867 canon = name;
868 }
869 }
870
871 break;
872 }
873
874 /* We can have different states for AF_INET and
875 AF_INET6. Try to find a useful one for both. */
876 if (inet6_status == NSS_STATUS_TRYAGAIN)
877 status = NSS_STATUS_TRYAGAIN;
878 else if (status == NSS_STATUS_UNAVAIL
879 && inet6_status != NSS_STATUS_UNAVAIL)
880 status = inet6_status;
881 }
882
883 if (nss_next_action (nip, status) == NSS_ACTION_RETURN)
884 break;
885
886 if (nip->next == NULL)
887 no_more = -1;
888 else
889 nip = nip->next;
890 }
891
892 _res.options = old_res_options;
893
894 if (no_data != 0 && no_inet6_data != 0)
895 {
896 /* If both requests timed out report this. */
897 if (no_data == EAI_AGAIN && no_inet6_data == EAI_AGAIN)
898 return -EAI_AGAIN;
899
900 /* We made requests but they turned out no data. The name
901 is known, though. */
902 return GAIH_OKIFUNSPEC | -EAI_NODATA;
903 }
904 }
905
906 process_list:
907 if (at->family == AF_UNSPEC)
908 return GAIH_OKIFUNSPEC | -EAI_NONAME;
909 }
910 else
911 {
912 struct gaih_addrtuple *atr;
913 atr = at = __alloca (sizeof (struct gaih_addrtuple));
914 memset (at, '\0', sizeof (struct gaih_addrtuple));
915
916 if (req->ai_family == AF_UNSPEC)
917 {
918 at->next = __alloca (sizeof (struct gaih_addrtuple));
919 memset (at->next, '\0', sizeof (struct gaih_addrtuple));
920 }
921
922 if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET6)
923 {
924 at->family = AF_INET6;
925 if ((req->ai_flags & AI_PASSIVE) == 0)
926 memcpy (at->addr, &in6addr_loopback, sizeof (struct in6_addr));
927 atr = at->next;
928 }
929
930 if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET)
931 {
932 atr->family = AF_INET;
933 if ((req->ai_flags & AI_PASSIVE) == 0)
934 atr->addr[0] = htonl (INADDR_LOOPBACK);
935 }
936 }
937
938 if (pai == NULL)
939 return 0;
940
941 {
942 struct gaih_servtuple *st2;
943 struct gaih_addrtuple *at2 = at;
944 size_t socklen;
945 sa_family_t family;
946
947 /*
948 buffer is the size of an unformatted IPv6 address in printable format.
949 */
950 while (at2 != NULL)
951 {
952 /* Only the first entry gets the canonical name. */
953 if (at2 == at && (req->ai_flags & AI_CANONNAME) != 0)
954 {
955 if (canon == NULL)
956 {
957 struct hostent *h = NULL;
958 int herrno;
959 struct hostent th;
960 size_t tmpbuflen = 512;
961 char *tmpbuf = NULL;
962
963 do
964 {
965 tmpbuf = extend_alloca (tmpbuf, tmpbuflen, tmpbuflen * 2);
966 rc = __gethostbyaddr_r (at2->addr,
967 ((at2->family == AF_INET6)
968 ? sizeof (struct in6_addr)
969 : sizeof (struct in_addr)),
970 at2->family, &th, tmpbuf,
971 tmpbuflen, &h, &herrno);
972 }
973 while (rc == ERANGE && herrno == NETDB_INTERNAL);
974
975 if (rc != 0 && herrno == NETDB_INTERNAL)
976 {
977 __set_h_errno (herrno);
978 return -EAI_SYSTEM;
979 }
980
981 if (h != NULL)
982 canon = h->h_name;
983 else
984 {
985 assert (orig_name != NULL);
986 /* If the canonical name cannot be determined, use
987 the passed in string. */
988 canon = orig_name;
989 }
990 }
991
992 #ifdef HAVE_LIBIDN
993 if (req->ai_flags & AI_CANONIDN)
994 {
995 int idn_flags = 0;
996 if (req->ai_flags & AI_IDN_ALLOW_UNASSIGNED)
997 idn_flags |= IDNA_ALLOW_UNASSIGNED;
998 if (req->ai_flags & AI_IDN_USE_STD3_ASCII_RULES)
999 idn_flags |= IDNA_USE_STD3_ASCII_RULES;
1000
1001 char *out;
1002 int rc = __idna_to_unicode_lzlz (canon, &out, idn_flags);
1003 if (rc != IDNA_SUCCESS)
1004 {
1005 if (rc == IDNA_MALLOC_ERROR)
1006 return -EAI_MEMORY;
1007 if (rc == IDNA_DLOPEN_ERROR)
1008 return -EAI_SYSTEM;
1009 return -EAI_IDN_ENCODE;
1010 }
1011 /* In case the output string is the same as the input
1012 string no new string has been allocated. Otherwise
1013 make a copy. */
1014 if (out == canon)
1015 goto make_copy;
1016 }
1017 else
1018 #endif
1019 {
1020 #ifdef HAVE_LIBIDN
1021 make_copy:
1022 #endif
1023 canon = strdup (canon);
1024 if (canon == NULL)
1025 return -EAI_MEMORY;
1026 }
1027 }
1028
1029 family = at2->family;
1030 if (family == AF_INET6)
1031 {
1032 socklen = sizeof (struct sockaddr_in6);
1033
1034 /* If we looked up IPv4 mapped address discard them here if
1035 the caller isn't interested in all address and we have
1036 found at least one IPv6 address. */
1037 if (got_ipv6
1038 && (req->ai_flags & (AI_V4MAPPED|AI_ALL)) == AI_V4MAPPED
1039 && IN6_IS_ADDR_V4MAPPED (at2->addr))
1040 goto ignore;
1041 }
1042 else
1043 socklen = sizeof (struct sockaddr_in);
1044
1045 for (st2 = st; st2 != NULL; st2 = st2->next)
1046 {
1047 struct addrinfo *ai;
1048 ai = *pai = malloc (sizeof (struct addrinfo) + socklen);
1049 if (ai == NULL)
1050 return -EAI_MEMORY;
1051
1052 ai->ai_flags = req->ai_flags;
1053 ai->ai_family = family;
1054 ai->ai_socktype = st2->socktype;
1055 ai->ai_protocol = st2->protocol;
1056 ai->ai_addrlen = socklen;
1057 ai->ai_addr = (void *) (ai + 1);
1058
1059 /* We only add the canonical name once. */
1060 ai->ai_canonname = (char *) canon;
1061 canon = NULL;
1062
1063 #ifdef _HAVE_SA_LEN
1064 ai->ai_addr->sa_len = socklen;
1065 #endif /* _HAVE_SA_LEN */
1066 ai->ai_addr->sa_family = family;
1067
1068 if (family == AF_INET6)
1069 {
1070 struct sockaddr_in6 *sin6p =
1071 (struct sockaddr_in6 *) ai->ai_addr;
1072
1073 sin6p->sin6_port = st2->port;
1074 sin6p->sin6_flowinfo = 0;
1075 memcpy (&sin6p->sin6_addr,
1076 at2->addr, sizeof (struct in6_addr));
1077 sin6p->sin6_scope_id = at2->scopeid;
1078 }
1079 else
1080 {
1081 struct sockaddr_in *sinp =
1082 (struct sockaddr_in *) ai->ai_addr;
1083 sinp->sin_port = st2->port;
1084 memcpy (&sinp->sin_addr,
1085 at2->addr, sizeof (struct in_addr));
1086 memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
1087 }
1088
1089 pai = &(ai->ai_next);
1090 }
1091 *pai = NULL;
1092
1093 ++*naddrs;
1094
1095 ignore:
1096 at2 = at2->next;
1097 }
1098 }
1099 return 0;
1100 }
1101
1102 #if 0
1103 static const struct gaih gaih[] =
1104 {
1105 { PF_INET6, gaih_inet },
1106 { PF_INET, gaih_inet },
1107 #if 0
1108 { PF_LOCAL, gaih_local },
1109 #endif
1110 { PF_UNSPEC, NULL }
1111 };
1112 #endif
1113
1114 struct sort_result
1115 {
1116 struct addrinfo *dest_addr;
1117 struct sockaddr_storage source_addr;
1118 uint8_t source_addr_len;
1119 bool got_source_addr;
1120 uint8_t source_addr_flags;
1121 };
1122
1123
1124 static int
1125 get_scope (const struct sockaddr_storage *ss)
1126 {
1127 int scope;
1128 if (ss->ss_family == PF_INET6)
1129 {
1130 const struct sockaddr_in6 *in6 = (const struct sockaddr_in6 *) ss;
1131
1132 if (! IN6_IS_ADDR_MULTICAST (&in6->sin6_addr))
1133 {
1134 if (IN6_IS_ADDR_LINKLOCAL (&in6->sin6_addr))
1135 scope = 2;
1136 else if (IN6_IS_ADDR_SITELOCAL (&in6->sin6_addr))
1137 scope = 5;
1138 else
1139 /* XXX Is this the correct default behavior? */
1140 scope = 14;
1141 }
1142 else
1143 scope = in6->sin6_addr.s6_addr[1] & 0xf;
1144 }
1145 else if (ss->ss_family == PF_INET)
1146 {
1147 const struct sockaddr_in *in = (const struct sockaddr_in *) ss;
1148 const uint8_t *addr = (const uint8_t *) &in->sin_addr;
1149
1150 /* RFC 3484 specifies how to map IPv6 addresses to scopes.
1151 169.254/16 and 127/8 are link-local. */
1152 if ((addr[0] == 169 && addr[1] == 254) || addr[0] == 127)
1153 scope = 2;
1154 else if (addr[0] == 10 || (addr[0] == 172 && addr[1] == 16)
1155 || (addr[0] == 192 && addr[1] == 168))
1156 scope = 5;
1157 else
1158 scope = 14;
1159 }
1160 else
1161 /* XXX What is a good default? */
1162 scope = 15;
1163
1164 return scope;
1165 }
1166
1167
1168 struct prefixentry
1169 {
1170 struct in6_addr prefix;
1171 unsigned int bits;
1172 int val;
1173 };
1174
1175
1176 /* The label table. */
1177 static const struct prefixentry *labels;
1178
1179 /* Default labels. */
1180 static const struct prefixentry default_labels[] =
1181 {
1182 /* See RFC 3484 for the details. */
1183 { { .in6_u
1184 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1185 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } } },
1186 128, 0 },
1187 { { .in6_u
1188 = { .u6_addr8 = { 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1189 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
1190 16, 2 },
1191 { { .in6_u
1192 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1193 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
1194 96, 3 },
1195 { { .in6_u
1196 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1197 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
1198 96, 4 },
1199 { { .in6_u
1200 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1201 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
1202 0, 1 }
1203 };
1204
1205
1206 /* The precedence table. */
1207 static const struct prefixentry *precedence;
1208
1209 /* The default precedences. */
1210 static const struct prefixentry default_precedence[] =
1211 {
1212 /* See RFC 3484 for the details. */
1213 { { .in6_u
1214 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1215 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } } },
1216 128, 50 },
1217 { { .in6_u
1218 = { .u6_addr8 = { 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1219 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
1220 16, 30 },
1221 { { .in6_u
1222 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1223 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
1224 96, 20 },
1225 { { .in6_u
1226 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1227 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
1228 96, 100 },
1229 { { .in6_u
1230 = { .u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1231 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
1232 0, 40 }
1233 };
1234
1235
1236 static int
1237 match_prefix (const struct sockaddr_storage *ss,
1238 const struct prefixentry *list, int default_val)
1239 {
1240 int idx;
1241 struct sockaddr_in6 in6_mem;
1242 const struct sockaddr_in6 *in6;
1243
1244 if (ss->ss_family == PF_INET6)
1245 in6 = (const struct sockaddr_in6 *) ss;
1246 else if (ss->ss_family == PF_INET)
1247 {
1248 const struct sockaddr_in *in = (const struct sockaddr_in *) ss;
1249
1250 /* Convert to IPv6 address. */
1251 in6_mem.sin6_family = PF_INET6;
1252 in6_mem.sin6_port = in->sin_port;
1253 in6_mem.sin6_flowinfo = 0;
1254 if (in->sin_addr.s_addr == htonl (0x7f000001))
1255 in6_mem.sin6_addr = (struct in6_addr) IN6ADDR_LOOPBACK_INIT;
1256 else
1257 {
1258 /* Construct a V4-to-6 mapped address. */
1259 memset (&in6_mem.sin6_addr, '\0', sizeof (in6_mem.sin6_addr));
1260 in6_mem.sin6_addr.s6_addr16[5] = 0xffff;
1261 in6_mem.sin6_addr.s6_addr32[3] = in->sin_addr.s_addr;
1262 in6_mem.sin6_scope_id = 0;
1263 }
1264
1265 in6 = &in6_mem;
1266 }
1267 else
1268 return default_val;
1269
1270 for (idx = 0; ; ++idx)
1271 {
1272 unsigned int bits = list[idx].bits;
1273 uint8_t *mask = list[idx].prefix.s6_addr;
1274 uint8_t *val = in6->sin6_addr.s6_addr;
1275
1276 while (bits >= 8)
1277 {
1278 if (*mask != *val)
1279 break;
1280
1281 ++mask;
1282 ++val;
1283 bits -= 8;
1284 }
1285
1286 if (bits < 8)
1287 {
1288 if ((*mask & (0xff00 >> bits)) == (*val & (0xff00 >> bits)))
1289 /* Match! */
1290 break;
1291 }
1292 }
1293
1294 return list[idx].val;
1295 }
1296
1297
1298 static int
1299 get_label (const struct sockaddr_storage *ss)
1300 {
1301 /* XXX What is a good default value? */
1302 return match_prefix (ss, labels, INT_MAX);
1303 }
1304
1305
1306 static int
1307 get_precedence (const struct sockaddr_storage *ss)
1308 {
1309 /* XXX What is a good default value? */
1310 return match_prefix (ss, precedence, 0);
1311 }
1312
1313
1314 /* Find last bit set in a word. */
1315 static int
1316 fls (uint32_t a)
1317 {
1318 uint32_t mask;
1319 int n = 0;
1320 for (n = 0, mask = 1 << 31; n < 32; mask >>= 1, ++n)
1321 if ((a & mask) != 0)
1322 break;
1323 return n;
1324 }
1325
1326
1327 static int
1328 rfc3484_sort (const void *p1, const void *p2)
1329 {
1330 const struct sort_result *a1 = (const struct sort_result *) p1;
1331 const struct sort_result *a2 = (const struct sort_result *) p2;
1332
1333 /* Rule 1: Avoid unusable destinations.
1334 We have the got_source_addr flag set if the destination is reachable. */
1335 if (a1->got_source_addr && ! a2->got_source_addr)
1336 return -1;
1337 if (! a1->got_source_addr && a2->got_source_addr)
1338 return 1;
1339
1340
1341 /* Rule 2: Prefer matching scope. Only interesting if both
1342 destination addresses are IPv6. */
1343 int a1_dst_scope
1344 = get_scope ((struct sockaddr_storage *) a1->dest_addr->ai_addr);
1345
1346 int a2_dst_scope
1347 = get_scope ((struct sockaddr_storage *) a2->dest_addr->ai_addr);
1348
1349 if (a1->got_source_addr)
1350 {
1351 int a1_src_scope = get_scope (&a1->source_addr);
1352 int a2_src_scope = get_scope (&a2->source_addr);
1353
1354 if (a1_dst_scope == a1_src_scope && a2_dst_scope != a2_src_scope)
1355 return -1;
1356 if (a1_dst_scope != a1_src_scope && a2_dst_scope == a2_src_scope)
1357 return 1;
1358 }
1359
1360
1361 /* Rule 3: Avoid deprecated addresses. */
1362 if (a1->got_source_addr)
1363 {
1364 if (!(a1->source_addr_flags & in6ai_deprecated)
1365 && (a2->source_addr_flags & in6ai_deprecated))
1366 return -1;
1367 if ((a1->source_addr_flags & in6ai_deprecated)
1368 && !(a2->source_addr_flags & in6ai_deprecated))
1369 return 1;
1370 }
1371
1372 /* Rule 4: Prefer home addresses.
1373 Another thing only the kernel can decide. */
1374
1375 /* Rule 5: Prefer matching label. */
1376 if (a1->got_source_addr)
1377 {
1378 int a1_dst_label
1379 = get_label ((struct sockaddr_storage *) a1->dest_addr->ai_addr);
1380 int a1_src_label = get_label (&a1->source_addr);
1381
1382 int a2_dst_label
1383 = get_label ((struct sockaddr_storage *) a2->dest_addr->ai_addr);
1384 int a2_src_label = get_label (&a2->source_addr);
1385
1386 if (a1_dst_label == a1_src_label && a2_dst_label != a2_src_label)
1387 return -1;
1388 if (a1_dst_label != a1_src_label && a2_dst_label == a2_src_label)
1389 return 1;
1390 }
1391
1392
1393 /* Rule 6: Prefer higher precedence. */
1394 int a1_prec
1395 = get_precedence ((struct sockaddr_storage *) a1->dest_addr->ai_addr);
1396 int a2_prec
1397 = get_precedence ((struct sockaddr_storage *) a2->dest_addr->ai_addr);
1398
1399 if (a1_prec > a2_prec)
1400 return -1;
1401 if (a1_prec < a2_prec)
1402 return 1;
1403
1404
1405 /* Rule 7: Prefer native transport. */
1406 if (a1->got_source_addr)
1407 {
1408 if (!(a1->source_addr_flags & in6ai_temporary)
1409 && (a1->source_addr_flags & in6ai_temporary))
1410 return -1;
1411 if ((a1->source_addr_flags & in6ai_temporary)
1412 && !(a1->source_addr_flags & in6ai_temporary))
1413 return -1;
1414
1415 /* XXX Do we need to check anything beside temporary addresses? */
1416 }
1417
1418
1419 /* Rule 8: Prefer smaller scope. */
1420 if (a1_dst_scope < a2_dst_scope)
1421 return -1;
1422 if (a1_dst_scope > a2_dst_scope)
1423 return 1;
1424
1425
1426 /* Rule 9: Use longest matching prefix. */
1427 if (a1->got_source_addr
1428 && a1->dest_addr->ai_family == a2->dest_addr->ai_family)
1429 {
1430 int bit1 = 0;
1431 int bit2 = 0;
1432
1433 if (a1->dest_addr->ai_family == PF_INET)
1434 {
1435 assert (a1->source_addr.ss_family == PF_INET);
1436 assert (a2->source_addr.ss_family == PF_INET);
1437
1438 struct sockaddr_in *in1_dst;
1439 struct sockaddr_in *in1_src;
1440 struct sockaddr_in *in2_dst;
1441 struct sockaddr_in *in2_src;
1442
1443 in1_dst = (struct sockaddr_in *) a1->dest_addr->ai_addr;
1444 in1_src = (struct sockaddr_in *) &a1->source_addr;
1445 in2_dst = (struct sockaddr_in *) a2->dest_addr->ai_addr;
1446 in2_src = (struct sockaddr_in *) &a2->source_addr;
1447
1448 bit1 = fls (ntohl (in1_dst->sin_addr.s_addr
1449 ^ in1_src->sin_addr.s_addr));
1450 bit2 = fls (ntohl (in2_dst->sin_addr.s_addr
1451 ^ in2_src->sin_addr.s_addr));
1452 }
1453 else if (a1->dest_addr->ai_family == PF_INET6)
1454 {
1455 assert (a1->source_addr.ss_family == PF_INET6);
1456 assert (a2->source_addr.ss_family == PF_INET6);
1457
1458 struct sockaddr_in6 *in1_dst;
1459 struct sockaddr_in6 *in1_src;
1460 struct sockaddr_in6 *in2_dst;
1461 struct sockaddr_in6 *in2_src;
1462
1463 in1_dst = (struct sockaddr_in6 *) a1->dest_addr->ai_addr;
1464 in1_src = (struct sockaddr_in6 *) &a1->source_addr;
1465 in2_dst = (struct sockaddr_in6 *) a2->dest_addr->ai_addr;
1466 in2_src = (struct sockaddr_in6 *) &a2->source_addr;
1467
1468 int i;
1469 for (i = 0; i < 4; ++i)
1470 if (in1_dst->sin6_addr.s6_addr32[i]
1471 != in1_src->sin6_addr.s6_addr32[i]
1472 || (in2_dst->sin6_addr.s6_addr32[i]
1473 != in2_src->sin6_addr.s6_addr32[i]))
1474 break;
1475
1476 if (i < 4)
1477 {
1478 bit1 = fls (ntohl (in1_dst->sin6_addr.s6_addr32[i]
1479 ^ in1_src->sin6_addr.s6_addr32[i]));
1480 bit2 = fls (ntohl (in2_dst->sin6_addr.s6_addr32[i]
1481 ^ in2_src->sin6_addr.s6_addr32[i]));
1482 }
1483 }
1484
1485 if (bit1 > bit2)
1486 return -1;
1487 if (bit1 < bit2)
1488 return 1;
1489 }
1490
1491
1492 /* Rule 10: Otherwise, leave the order unchanged. */
1493 return 0;
1494 }
1495
1496
1497 static int
1498 in6aicmp (const void *p1, const void *p2)
1499 {
1500 struct in6addrinfo *a1 = (struct in6addrinfo *) p1;
1501 struct in6addrinfo *a2 = (struct in6addrinfo *) p2;
1502
1503 return memcmp (a1->addr, a2->addr, sizeof (a1->addr));
1504 }
1505
1506
1507 /* Name of the config file for RFC 3484 sorting (for now). */
1508 #define GAICONF_FNAME "/etc/gai.conf"
1509
1510
1511 /* Nozero if we are supposed to reload the config file automatically
1512 whenever it changed. */
1513 static int gaiconf_reload_flag;
1514
1515 /* Last modification time. */
1516 static struct timespec gaiconf_mtime;
1517
1518
1519 libc_freeres_fn(fini)
1520 {
1521 if (labels != default_labels)
1522 {
1523 const struct prefixentry *old = labels;
1524 labels = default_labels;
1525 free ((void *) old);
1526 }
1527
1528 if (precedence != default_precedence)
1529 {
1530 const struct prefixentry *old = precedence;
1531 precedence = default_precedence;
1532 free ((void *) old);
1533 }
1534 }
1535
1536
1537 struct prefixlist
1538 {
1539 struct prefixentry entry;
1540 struct prefixlist *next;
1541 };
1542
1543
1544 static void
1545 free_prefixlist (struct prefixlist *list)
1546 {
1547 while (list != NULL)
1548 {
1549 struct prefixlist *oldp = list;
1550 list = list->next;
1551 free (oldp);
1552 }
1553 }
1554
1555
1556 static int
1557 prefixcmp (const void *p1, const void *p2)
1558 {
1559 const struct prefixentry *e1 = (const struct prefixentry *) p1;
1560 const struct prefixentry *e2 = (const struct prefixentry *) p2;
1561
1562 if (e1->bits < e2->bits)
1563 return 1;
1564 if (e1->bits == e2->bits)
1565 return 0;
1566 return -1;
1567 }
1568
1569
1570 static void
1571 gaiconf_init (void)
1572 {
1573 struct prefixlist *labellist = NULL;
1574 size_t nlabellist = 0;
1575 bool labellist_nullbits = false;
1576 struct prefixlist *precedencelist = NULL;
1577 size_t nprecedencelist = 0;
1578 bool precedencelist_nullbits = false;
1579
1580 FILE *fp = fopen (GAICONF_FNAME, "rc");
1581 if (fp != NULL)
1582 {
1583 struct stat64 st;
1584 if (__fxstat64 (_STAT_VER, fileno (fp), &st) != 0)
1585 {
1586 fclose (fp);
1587 goto no_file;
1588 }
1589
1590 char *line = NULL;
1591 size_t linelen = 0;
1592
1593 __fsetlocking (fp, FSETLOCKING_BYCALLER);
1594
1595 while (!feof_unlocked (fp))
1596 {
1597 ssize_t n = __getline (&line, &linelen, fp);
1598 if (n <= 0)
1599 break;
1600
1601 /* Handle comments. No escaping possible so this is easy. */
1602 char *cp = strchr (line, '#');
1603 if (cp != NULL)
1604 *cp = '\0';
1605
1606 cp = line;
1607 while (isspace (*cp))
1608 ++cp;
1609
1610 char *cmd = cp;
1611 while (*cp != '\0' && !isspace (*cp))
1612 ++cp;
1613 size_t cmdlen = cp - cmd;
1614
1615 if (*cp != '\0')
1616 *cp++ = '\0';
1617 while (isspace (*cp))
1618 ++cp;
1619
1620 char *val1 = cp;
1621 while (*cp != '\0' && !isspace (*cp))
1622 ++cp;
1623 size_t val1len = cp - cmd;
1624
1625 /* We always need at least two values. */
1626 if (val1len == 0)
1627 continue;
1628
1629 if (*cp != '\0')
1630 *cp++ = '\0';
1631 while (isspace (*cp))
1632 ++cp;
1633
1634 char *val2 = cp;
1635 while (*cp != '\0' && !isspace (*cp))
1636 ++cp;
1637
1638 /* Ignore the rest of the line. */
1639 *cp = '\0';
1640
1641 struct prefixlist **listp;
1642 size_t *lenp;
1643 bool *nullbitsp;
1644 switch (cmdlen)
1645 {
1646 case 5:
1647 if (strcmp (cmd, "label") == 0)
1648 {
1649 struct in6_addr prefix;
1650 unsigned long int bits = 128;
1651 unsigned long int val;
1652 char *endp;
1653
1654 listp = &labellist;
1655 lenp = &nlabellist;
1656 nullbitsp = &labellist_nullbits;
1657
1658 new_elem:
1659 __set_errno (0);
1660 cp = strchr (val1, '/');
1661 if (cp != NULL)
1662 *cp++ = '\0';
1663 if (inet_pton (AF_INET6, val1, &prefix)
1664 && (cp == NULL
1665 || (bits = strtoul (cp, &endp, 10)) != ULONG_MAX
1666 || errno != ERANGE)
1667 && *endp == '\0'
1668 && bits <= INT_MAX
1669 && ((val = strtoul (val2, &endp, 10)) != ULONG_MAX
1670 || errno != ERANGE)
1671 && *endp == '\0'
1672 && val <= INT_MAX)
1673 {
1674 struct prefixlist *newp = malloc (sizeof (*newp));
1675 if (newp == NULL)
1676 {
1677 free (line);
1678 fclose (fp);
1679 goto no_file;
1680 }
1681
1682 memcpy (&newp->entry.prefix, &prefix, sizeof (prefix));
1683 newp->entry.bits = bits;
1684 newp->entry.val = val;
1685 newp->next = *listp;
1686 *listp = newp;
1687 ++*lenp;
1688 *nullbitsp |= bits == 0;
1689 }
1690 }
1691 break;
1692
1693 case 6:
1694 if (strcmp (cmd, "reload") == 0)
1695 gaiconf_reload_flag = strcmp (val1, "yes") == 0;
1696 break;
1697
1698 case 10:
1699 if (strcmp (cmd, "precedence") == 0)
1700 {
1701 listp = &precedencelist;
1702 lenp = &nprecedencelist;
1703 nullbitsp = &precedencelist_nullbits;
1704 goto new_elem;
1705 }
1706 break;
1707 }
1708 }
1709
1710 free (line);
1711
1712 fclose (fp);
1713
1714 /* Create the array for the labels. */
1715 struct prefixentry *new_labels;
1716 if (nlabellist > 0)
1717 {
1718 if (!labellist_nullbits)
1719 ++nlabellist;
1720 new_labels = malloc (nlabellist * sizeof (*new_labels));
1721 if (new_labels == NULL)
1722 goto no_file;
1723
1724 int i = nlabellist;
1725 if (!labellist_nullbits)
1726 {
1727 --i;
1728 memset (&new_labels[i].prefix, '\0', sizeof (struct in6_addr));
1729 new_labels[i].bits = 0;
1730 new_labels[i].val = 1;
1731 }
1732
1733 struct prefixlist *l = labellist;
1734 while (i-- > 0)
1735 {
1736 new_labels[i] = l->entry;
1737 l = l->next;
1738 }
1739 free_prefixlist (labellist);
1740
1741 /* Sort the entries so that the most specific ones are at
1742 the beginning. */
1743 qsort (new_labels, nlabellist, sizeof (*new_labels), prefixcmp);
1744 }
1745 else
1746 new_labels = (struct prefixentry *) default_labels;
1747
1748 struct prefixentry *new_precedence;
1749 if (nprecedencelist > 0)
1750 {
1751 if (!precedencelist_nullbits)
1752 ++nprecedencelist;
1753 new_precedence = malloc (nprecedencelist * sizeof (*new_precedence));
1754 if (new_precedence == NULL)
1755 {
1756 if (new_labels != default_labels)
1757 free (new_labels);
1758 goto no_file;
1759 }
1760
1761 int i = nprecedencelist;
1762 if (!precedencelist_nullbits)
1763 {
1764 --i;
1765 memset (&new_precedence[i].prefix, '\0',
1766 sizeof (struct in6_addr));
1767 new_precedence[i].bits = 0;
1768 new_precedence[i].val = 40;
1769 }
1770
1771 struct prefixlist *l = precedencelist;
1772 while (i-- > 0)
1773 {
1774 new_precedence[i] = l->entry;
1775 l = l->next;
1776 }
1777 free_prefixlist (precedencelist);
1778
1779 /* Sort the entries so that the most specific ones are at
1780 the beginning. */
1781 qsort (new_precedence, nprecedencelist, sizeof (*new_labels),
1782 prefixcmp);
1783 }
1784 else
1785 new_precedence = (struct prefixentry *) default_precedence;
1786
1787 /* Now we are ready to replace the values. */
1788 const struct prefixentry *old = labels;
1789 labels = new_labels;
1790 if (old != default_labels)
1791 free ((void *) old);
1792
1793 old = precedence;
1794 precedence = new_precedence;
1795 if (old != default_precedence)
1796 free ((void *) old);
1797
1798 gaiconf_mtime = st.st_mtim;
1799 }
1800 else
1801 {
1802 no_file:
1803 free_prefixlist (labellist);
1804 free_prefixlist (precedencelist);
1805
1806 /* If we previously read the file but it is gone now, free the
1807 old data and use the builtin one. Leave the reload flag
1808 alone. */
1809 fini ();
1810 }
1811 }
1812
1813
1814 static void
1815 gaiconf_reload (void)
1816 {
1817 struct stat64 st;
1818 if (__xstat64 (_STAT_VER, GAICONF_FNAME, &st) != 0
1819 || memcmp (&st.st_mtim, &gaiconf_mtime, sizeof (gaiconf_mtime)) != 0)
1820 gaiconf_init ();
1821 }
1822
1823
1824 int
1825 getaddrinfo (const char *name, const char *service,
1826 const struct addrinfo *hints, struct addrinfo **pai)
1827 {
1828 int i = 0, last_i = 0;
1829 int nresults = 0;
1830 struct addrinfo *p = NULL;
1831 struct gaih_service gaih_service, *pservice;
1832 struct addrinfo local_hints;
1833
1834 if (name != NULL && name[0] == '*' && name[1] == 0)
1835 name = NULL;
1836
1837 if (service != NULL && service[0] == '*' && service[1] == 0)
1838 service = NULL;
1839
1840 if (name == NULL && service == NULL)
1841 return EAI_NONAME;
1842
1843 if (hints == NULL)
1844 hints = &default_hints;
1845
1846 if (hints->ai_flags
1847 & ~(AI_PASSIVE|AI_CANONNAME|AI_NUMERICHOST|AI_ADDRCONFIG|AI_V4MAPPED
1848 #ifdef HAVE_LIBIDN
1849 |AI_IDN|AI_CANONIDN|AI_IDN_ALLOW_UNASSIGNED
1850 |AI_IDN_USE_STD3_ASCII_RULES
1851 #endif
1852 |AI_NUMERICSERV|AI_ALL))
1853 return EAI_BADFLAGS;
1854
1855 if ((hints->ai_flags & AI_CANONNAME) && name == NULL)
1856 return EAI_BADFLAGS;
1857
1858 struct in6addrinfo *in6ai = NULL;
1859 size_t in6ailen;
1860 bool seen_ipv4 = false;
1861 bool seen_ipv6 = false;
1862 /* We might need information about what kind of interfaces are available.
1863 But even if AI_ADDRCONFIG is not used, if the user requested IPv6
1864 addresses we have to know whether an address is deprecated or
1865 temporary. */
1866 if ((hints->ai_flags & AI_ADDRCONFIG) || hints->ai_family == PF_UNSPEC
1867 || hints->ai_family == PF_INET6)
1868 /* Determine whether we have IPv4 or IPv6 interfaces or both. We
1869 cannot cache the results since new interfaces could be added at
1870 any time. */
1871 __check_pf (&seen_ipv4, &seen_ipv6, &in6ai, &in6ailen);
1872
1873 if (hints->ai_flags & AI_ADDRCONFIG)
1874 {
1875 /* Now make a decision on what we return, if anything. */
1876 if (hints->ai_family == PF_UNSPEC && (seen_ipv4 || seen_ipv6))
1877 {
1878 /* If we haven't seen both IPv4 and IPv6 interfaces we can
1879 narrow down the search. */
1880 if (! seen_ipv4 || ! seen_ipv6)
1881 {
1882 local_hints = *hints;
1883 local_hints.ai_family = seen_ipv4 ? PF_INET : PF_INET6;
1884 hints = &local_hints;
1885 }
1886 }
1887 else if ((hints->ai_family == PF_INET && ! seen_ipv4)
1888 || (hints->ai_family == PF_INET6 && ! seen_ipv6))
1889 {
1890 /* We cannot possibly return a valid answer. */
1891 free (in6ai);
1892 return EAI_NONAME;
1893 }
1894 }
1895
1896 if (service && service[0])
1897 {
1898 char *c;
1899 gaih_service.name = service;
1900 gaih_service.num = strtoul (gaih_service.name, &c, 10);
1901 if (*c != '\0')
1902 {
1903 if (hints->ai_flags & AI_NUMERICSERV)
1904 {
1905 free (in6ai);
1906 return EAI_NONAME;
1907 }
1908
1909 gaih_service.num = -1;
1910 }
1911
1912 pservice = &gaih_service;
1913 }
1914 else
1915 pservice = NULL;
1916
1917 struct addrinfo **end;
1918 if (pai)
1919 end = &p;
1920 else
1921 end = NULL;
1922
1923 unsigned int naddrs = 0;
1924 #if 0
1925 /* If we would support more protocols than just IPv4 and IPv6 we
1926 would iterate over a table with appropriate callback functions.
1927 Since we currently only handle IPv4 and IPv6 this is not
1928 necessary. */
1929 const struct gaih *g = gaih;
1930 const struct gaih *pg = NULL;
1931 int j = 0;
1932 while (g->gaih)
1933 {
1934 if (hints->ai_family == g->family || hints->ai_family == AF_UNSPEC)
1935 {
1936 j++;
1937 if (pg == NULL || pg->gaih != g->gaih)
1938 {
1939 pg = g;
1940 i = g->gaih (name, pservice, hints, end, &naddrs);
1941 if (i != 0)
1942 {
1943 /* EAI_NODATA is a more specific result as it says that
1944 we found a result but it is not usable. */
1945 if (last_i != (GAIH_OKIFUNSPEC | -EAI_NODATA))
1946 last_i = i;
1947
1948 if (hints->ai_family == AF_UNSPEC && (i & GAIH_OKIFUNSPEC))
1949 {
1950 ++g;
1951 continue;
1952 }
1953
1954 freeaddrinfo (p);
1955 free (in6ai);
1956
1957 return -(i & GAIH_EAI);
1958 }
1959 if (end)
1960 while (*end)
1961 {
1962 end = &((*end)->ai_next);
1963 ++nresults;
1964 }
1965 }
1966 }
1967 ++g;
1968 }
1969
1970 if (j == 0)
1971 {
1972 free (in6ai);
1973 return EAI_FAMILY;
1974 }
1975 #else
1976 if (hints->ai_family == AF_UNSPEC || hints->ai_family == AF_INET
1977 || hints->ai_family == AF_INET6)
1978 {
1979 last_i = gaih_inet (name, pservice, hints, end, &naddrs);
1980 if (last_i != 0)
1981 {
1982 freeaddrinfo (p);
1983 free (in6ai);
1984
1985 return -(last_i & GAIH_EAI);
1986 }
1987 if (end)
1988 while (*end)
1989 {
1990 end = &((*end)->ai_next);
1991 ++nresults;
1992 }
1993 }
1994 else
1995 {
1996 free (in6ai);
1997 return EAI_FAMILY;
1998 }
1999 #endif
2000
2001 if (naddrs > 1)
2002 {
2003 /* Read the config file. */
2004 __libc_once_define (static, once);
2005 __typeof (once) old_once = once;
2006 __libc_once (once, gaiconf_init);
2007 if (old_once && gaiconf_reload_flag)
2008 gaiconf_reload ();
2009
2010 /* Sort results according to RFC 3484. */
2011 struct sort_result results[nresults];
2012 struct addrinfo *q;
2013 struct addrinfo *last = NULL;
2014 char *canonname = NULL;
2015
2016 /* If we have information about deprecated and temporary address
2017 sort the array now. */
2018 if (in6ai != NULL)
2019 qsort (in6ai, in6ailen, sizeof (*in6ai), in6aicmp);
2020
2021 for (i = 0, q = p; q != NULL; ++i, last = q, q = q->ai_next)
2022 {
2023 results[i].dest_addr = q;
2024 results[i].got_source_addr = false;
2025
2026 /* If we just looked up the address for a different
2027 protocol, reuse the result. */
2028 if (last != NULL && last->ai_addrlen == q->ai_addrlen
2029 && memcmp (last->ai_addr, q->ai_addr, q->ai_addrlen) == 0)
2030 {
2031 memcpy (&results[i].source_addr, &results[i - 1].source_addr,
2032 results[i - 1].source_addr_len);
2033 results[i].source_addr_len = results[i - 1].source_addr_len;
2034 results[i].got_source_addr = results[i - 1].got_source_addr;
2035 results[i].source_addr_flags = results[i - 1].source_addr_flags;
2036 }
2037 else
2038 {
2039 results[i].source_addr_flags = 0;
2040
2041 /* We overwrite the type with SOCK_DGRAM since we do not
2042 want connect() to connect to the other side. If we
2043 cannot determine the source address remember this
2044 fact. */
2045 int fd = __socket (q->ai_family, SOCK_DGRAM, IPPROTO_IP);
2046 socklen_t sl = sizeof (results[i].source_addr);
2047 if (fd != -1
2048 && __connect (fd, q->ai_addr, q->ai_addrlen) == 0
2049 && __getsockname (fd,
2050 (struct sockaddr *) &results[i].source_addr,
2051 &sl) == 0)
2052 {
2053 results[i].source_addr_len = sl;
2054 results[i].got_source_addr = true;
2055
2056 if (q->ai_family == PF_INET6 && in6ai != NULL)
2057 {
2058 /* See whether the address is the list of deprecated
2059 or temporary addresses. */
2060 struct in6addrinfo tmp;
2061 memcpy (tmp.addr, q->ai_addr, IN6ADDRSZ);
2062
2063 struct in6addrinfo *found
2064 = bsearch (&tmp, in6ai, in6ailen, sizeof (*in6ai),
2065 in6aicmp);
2066 if (found != NULL)
2067 results[i].source_addr_flags = found->flags;
2068 }
2069 }
2070 else
2071 /* Just make sure that if we have to process the same
2072 address again we do not copy any memory. */
2073 results[i].source_addr_len = 0;
2074
2075 if (fd != -1)
2076 close_not_cancel_no_status (fd);
2077 }
2078
2079 /* Remember the canonical name. */
2080 if (q->ai_canonname != NULL)
2081 {
2082 assert (canonname == NULL);
2083 canonname = q->ai_canonname;
2084 q->ai_canonname = NULL;
2085 }
2086 }
2087
2088 /* We got all the source addresses we can get, now sort using
2089 the information. */
2090 qsort (results, nresults, sizeof (results[0]), rfc3484_sort);
2091
2092 /* Queue the results up as they come out of sorting. */
2093 q = p = results[0].dest_addr;
2094 for (i = 1; i < nresults; ++i)
2095 q = q->ai_next = results[i].dest_addr;
2096 q->ai_next = NULL;
2097
2098 /* Fill in the canonical name into the new first entry. */
2099 p->ai_canonname = canonname;
2100 }
2101
2102 free (in6ai);
2103
2104 if (p)
2105 {
2106 *pai = p;
2107 return 0;
2108 }
2109
2110 if (pai == NULL && last_i == 0)
2111 return 0;
2112
2113 return last_i ? -(last_i & GAIH_EAI) : EAI_NONAME;
2114 }
2115 libc_hidden_def (getaddrinfo)
2116
2117 static_link_warning (getaddrinfo)
2118
2119 void
2120 freeaddrinfo (struct addrinfo *ai)
2121 {
2122 struct addrinfo *p;
2123
2124 while (ai != NULL)
2125 {
2126 p = ai;
2127 ai = ai->ai_next;
2128 free (p->ai_canonname);
2129 free (p);
2130 }
2131 }
2132 libc_hidden_def (freeaddrinfo)
Unaltered CVS history