]> git.saurik.com Git - apple/libinfo.git/blob - lookup.subproj/si_getaddrinfo.c
projects / apple / libinfo.git / blob
? search:


9bd03f4e5df1b723c664157108d7dfda4be352a7
[apple/libinfo.git] / lookup.subproj / si_getaddrinfo.c
1 /*
2 * Copyright (c) 2008-2009 Apple Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24 #include <netdb.h>
25 #include <sys/types.h>
26 #include <ctype.h>
27 #include <stdio.h>
28 #include <stdint.h>
29 #include <sys/socket.h>
30 #include <net/if.h>
31 #include <netinet/in.h>
32 #include <arpa/inet.h>
33 #include <ifaddrs.h>
34 #include <net/if.h>
35 #include <string.h>
36 #include <sys/param.h>
37 #include <TargetConditionals.h>
38 #include "netdb_async.h"
39 #include "si_module.h"
40
41 #define SOCK_UNSPEC 0
42 #define IPPROTO_UNSPEC 0
43
44 #define IPV6_ADDR_LEN 16
45 #define IPV4_ADDR_LEN 4
46
47 #define WANT_NOTHING 0
48 #define WANT_A4_ONLY 1
49 #define WANT_A6_ONLY 2
50 #define WANT_A6_PLUS_MAPPED_A4 3
51 #define WANT_A6_OR_MAPPED_A4_IF_NO_A6 4
52
53 typedef struct {
54 struct hostent host;
55 int alias_count;
56 int addr_count;
57 uint64_t ttl;
58 } build_hostent_t;
59
60 void
61 freeaddrinfo(struct addrinfo *a)
62 {
63 struct addrinfo *next;
64
65 while (a != NULL)
66 {
67 next = a->ai_next;
68 if (a->ai_addr != NULL) free(a->ai_addr);
69 if (a->ai_canonname != NULL) free(a->ai_canonname);
70 free(a);
71 a = next;
72 }
73 }
74
75 const char *
76 gai_strerror(int32_t err)
77 {
78 switch (err)
79 {
80 case EAI_ADDRFAMILY: return "Address family for nodename not supported";
81 case EAI_AGAIN: return "Temporary failure in name resolution";
82 case EAI_BADFLAGS: return "Invalid value for ai_flags";
83 case EAI_FAIL: return "Non-recoverable failure in name resolution";
84 case EAI_FAMILY: return "ai_family not supported";
85 case EAI_MEMORY: return "Memory allocation failure";
86 case EAI_NODATA: return "No address associated with nodename";
87 case EAI_NONAME: return "nodename nor servname provided, or not known";
88 case EAI_SERVICE: return "servname not supported for ai_socktype";
89 case EAI_SOCKTYPE: return "ai_socktype not supported";
90 case EAI_SYSTEM: return "System error";
91 case EAI_BADHINTS: return "Bad hints";
92 case EAI_PROTOCOL: return "ai_protocol not supported";
93 case EAI_OVERFLOW: return "argument buffer overflow";
94 }
95
96 return "Unknown error";
97 }
98
99 /*
100 * getnameinfo
101 *
102 * We handle some "trival" cases locally. If the caller passes
103 * NI_NUMERICHOST (only), then this call turns into a getservbyport
104 * to get the service name + inet_pton() to create a host string.
105 * If the caller passes NI_NUMERICSERV (only), then we zero out the port
106 * number, complete the getnameinfo, and use printf() to create a service
107 * string. If the caller specifies both NI_NUMERICHOST and NI_NUMERICSERV,
108 * we inet_ntop() and printf() and return the results.
109 */
110 __private_extern__ si_item_t *
111 si_nameinfo(si_mod_t *si, const struct sockaddr *sa, int flags, const char *interface, uint32_t *err)
112 {
113 si_item_t *out = NULL;
114 const struct sockaddr *lookup_sa;
115 struct sockaddr_in s4;
116 struct in_addr a4;
117 struct in6_addr a6;
118 const uint64_t unused = 0;
119 void *addr = NULL;
120 char *host = NULL;
121 char *serv = NULL;
122 uint32_t ifnum = 0;
123 uint16_t port = 0;
124
125 int do_host_lookup = ((flags & NI_NUMERICHOST) == 0);
126 int do_serv_lookup = ((flags & NI_NUMERICSERV) == 0);
127
128 /* check input */
129 if ((si == NULL) || (sa == NULL))
130 {
131 if (err != NULL) *err = SI_STATUS_EAI_FAIL;
132 return NULL;
133 }
134
135 if (err != NULL) *err = SI_STATUS_NO_ERROR;
136
137 lookup_sa = sa;
138
139 if (sa->sa_family == AF_INET)
140 {
141 struct sockaddr_in *s4 = (struct sockaddr_in *)sa;
142 memcpy(&a4, &s4->sin_addr, sizeof(a4));
143 port = s4->sin_port;
144 addr = &a4;
145 }
146 else if (sa->sa_family == AF_INET6)
147 {
148 struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)sa;
149 memcpy(&a6, &s6->sin6_addr, sizeof(a6));
150 port = s6->sin6_port;
151
152 /* Look for link-local IPv6 scope id */
153 if (IN6_IS_ADDR_LINKLOCAL(&s6->sin6_addr))
154 {
155 ifnum = ntohs(a6.__u6_addr.__u6_addr16[1]);
156 if (ifnum == 0)
157 {
158 ifnum = s6->sin6_scope_id;
159 a6.__u6_addr.__u6_addr16[1] = htons(ifnum);
160 }
161
162 if (ifnum != s6->sin6_scope_id &&
163 s6->sin6_scope_id != 0)
164 {
165 if (err != NULL) *err = SI_STATUS_EAI_FAIL;
166 return NULL;
167 }
168 }
169
170 /* v4 mapped and compat addresses are converted to plain v4 */
171 if (IN6_IS_ADDR_V4MAPPED(&s6->sin6_addr) || IN6_IS_ADDR_V4COMPAT(&s6->sin6_addr))
172 {
173 memcpy(&a4, &s6->sin6_addr.s6_addr[12], sizeof(a4));
174 addr = &a4;
175 memset(&s4, 0, sizeof(s4));
176 s4.sin_len = sizeof(s4);
177 s4.sin_family = AF_INET;
178 s4.sin_port = port;
179 memcpy(&s4.sin_addr, &a4, sizeof(s4.sin_addr));
180 lookup_sa = (const struct sockaddr *)&s4;
181 }
182 else
183 {
184 addr = &a6;
185 }
186 }
187 else
188 {
189 if (err != NULL) *err = SI_STATUS_EAI_FAMILY;
190 return NULL;
191 }
192
193 if (do_host_lookup == 1)
194 {
195 #if 0
196 if ((do_serv_lookup == 1) && (si->sim_nameinfo != NULL))
197 {
198 return si->sim_nameinfo(si, lookup_sa, flags, interface, err);
199 }
200 #endif
201 si_item_t *item = si_host_byaddr(si, addr, lookup_sa->sa_family, interface, NULL);
202 if (item != NULL)
203 {
204 struct hostent *h;
205 h = (struct hostent *)((uintptr_t)item + sizeof(si_item_t));
206 host = strdup(h->h_name);
207 si_item_release(item);
208 if (host == NULL)
209 {
210 if (err != NULL) *err = SI_STATUS_EAI_MEMORY;
211 return NULL;
212 }
213 }
214 }
215
216 if ((do_serv_lookup == 1) && (port != 0))
217 {
218 si_item_t *item = si_service_byport(si, port, NULL);
219 if (item != NULL)
220 {
221 struct servent *s;
222 s = (struct servent *)((uintptr_t)item + sizeof(si_item_t));
223 serv = strdup(s->s_name);
224 si_item_release(item);
225 if (serv == NULL)
226 {
227 free(host);
228 if (err != NULL) *err = SI_STATUS_EAI_MEMORY;
229 return NULL;
230 }
231 }
232 }
233
234 /*
235 * Return numeric host name for NI_NUMERICHOST or if lookup failed, but not
236 * if NI_NAMEREQD is specified (so that we later fail with EAI_NONAME).
237 */
238 if (host == NULL && (flags & NI_NAMEREQD) == 0)
239 {
240 char tmp[INET6_ADDRSTRLEN + 1 + IF_NAMESIZE + 1];
241 tmp[0] = '\0';
242 if (sa->sa_family == AF_INET)
243 {
244 char buf[INET_ADDRSTRLEN];
245 if (inet_ntop(AF_INET, &a4, buf, sizeof(buf)) != 0)
246 {
247 host = strdup(buf);
248 }
249 }
250 else if (sa->sa_family == AF_INET6)
251 {
252 char buf[INET6_ADDRSTRLEN];
253
254 /* zero the embedded scope ID */
255 if (ifnum != 0)
256 {
257 a6.__u6_addr.__u6_addr16[1] = 0;
258 }
259
260 if (inet_ntop(AF_INET6, &a6, buf, sizeof(buf)) != 0)
261 {
262 if (ifnum != 0)
263 {
264 char ifname[IF_NAMESIZE];
265 if (if_indextoname(ifnum, ifname) != NULL)
266 {
267 asprintf(&host, "%s%%%s", buf, ifname);
268 }
269 else
270 {
271 /* ENXIO */
272 if (err != NULL) *err = SI_STATUS_EAI_FAIL;
273 return NULL;
274 }
275 }
276 else
277 {
278 host = strdup(buf);
279 }
280 }
281 }
282 }
283
284 /* Return numeric service name for NI_NUMERICSERV or if lookup failed. */
285 if (serv == NULL)
286 {
287 asprintf(&serv, "%hu", ntohs(port));
288 }
289
290 if ((host == NULL) || (serv == NULL))
291 {
292 if (err != NULL)
293 {
294 if ((flags & NI_NAMEREQD) != 0)
295 {
296 *err = SI_STATUS_EAI_NONAME;
297 }
298 else
299 {
300 *err = SI_STATUS_EAI_MEMORY;
301 }
302 }
303 }
304 else
305 {
306 out = (si_item_t *)LI_ils_create("L4488ss", (unsigned long)si, CATEGORY_NAMEINFO, 1, unused, unused, host, serv);
307 }
308
309 free(host);
310 free(serv);
311 return out;
312 }
313
314 static int
315 _gai_numericserv(const char *serv, uint16_t *port)
316 {
317 int numeric;
318 char *endptr;
319 long num;
320
321 numeric = 0;
322
323 if (serv == NULL)
324 {
325 if (port) *port = 0;
326 numeric = 1;
327 }
328 else
329 {
330 num = strtol(serv, &endptr, 10);
331 if ((serv[0] != '\0') && (*endptr == '\0') && (num >= 0) && (num <= UINT16_MAX))
332 {
333 numeric = 1;
334 if (port != NULL) *port = (uint16_t)num;
335 }
336 }
337
338 return numeric;
339 }
340
341 __private_extern__ int
342 _gai_serv_to_port(const char *serv, uint32_t proto, uint16_t *port)
343 {
344 si_item_t *item;
345 struct servent *s;
346 const char *protoname = NULL;
347
348 if (_gai_numericserv(serv, port)) return 0;
349
350 if (proto == IPPROTO_UDP) protoname = "udp";
351 if (proto == IPPROTO_TCP) protoname = "tcp";
352
353 item = si_service_byname(si_search(), serv, protoname);
354 if (item == NULL) return -1;
355
356 s = (struct servent *)((uintptr_t)item + sizeof(si_item_t));
357 if (port) *port = ntohs(s->s_port);
358 si_item_release(item);
359
360 return 0;
361 }
362
363 __private_extern__ si_item_t *
364 si_addrinfo_v4(si_mod_t *si, int32_t flags, int32_t sock, int32_t proto, uint16_t port, struct in_addr *addr, uint16_t iface, const char *cname)
365 {
366 socket_data_t sockdata;
367 struct sockaddr_in *sa;
368 int32_t len, v32;
369 uint64_t unused;
370
371 unused = 0;
372 len = sizeof(struct sockaddr_in);
373 memset(&sockdata, 0, sizeof(socket_data_t));
374 sa = (struct sockaddr_in *)&sockdata;
375
376 sa->sin_len = len;
377 sa->sin_family = AF_INET;
378 sa->sin_port = htons(port);
379 memcpy(&sa->sin_addr, addr, sizeof(sa->sin_addr));
380
381 /* Kludge: Jam the interface number into sin_zero (4 bytes). */
382 v32 = iface;
383 memmove(sa->sin_zero, &v32, sizeof(uint32_t));
384
385 return (si_item_t *)LI_ils_create("L448844444Ss", (unsigned long)si, CATEGORY_ADDRINFO, 1, unused, unused, flags, AF_INET, sock, proto, len, sockdata, cname);
386 }
387
388 __private_extern__ si_item_t *
389 si_addrinfo_v6(si_mod_t *si, int32_t flags, int32_t sock, int32_t proto, uint16_t port, struct in6_addr *addr, uint16_t iface, const char *cname)
390 {
391 socket_data_t sockdata;
392 struct sockaddr_in6 *sa;
393 int32_t len;
394 uint64_t unused;
395
396 unused = 0;
397 len = sizeof(struct sockaddr_in6);
398 memset(&sockdata, 0, sizeof(socket_data_t));
399 sa = (struct sockaddr_in6 *)&sockdata;
400
401 sa->sin6_len = len;
402 sa->sin6_family = AF_INET6;
403 sa->sin6_port = htons(port);
404 memcpy(&sa->sin6_addr, addr, sizeof(sa->sin6_addr));
405
406 /* sin6_scope_id is in host byte order */
407 sa->sin6_scope_id = iface;
408
409 if (IN6_IS_ADDR_LINKLOCAL(&sa->sin6_addr))
410 {
411 /* check for embedded scopeid */
412 uint16_t esid = ntohs(sa->sin6_addr.__u6_addr.__u6_addr16[1]);
413 if (esid != 0)
414 {
415 sa->sin6_addr.__u6_addr.__u6_addr16[1] = 0;
416 if (iface == 0) sa->sin6_scope_id = esid;
417 }
418 }
419
420 return (si_item_t *)LI_ils_create("L448844444Ss", (unsigned long)si, CATEGORY_ADDRINFO, 1, unused, unused, flags, AF_INET6, sock, proto, len, sockdata, cname);
421 }
422
423 __private_extern__ si_list_t *
424 si_addrinfo_list(si_mod_t *si, int socktype, int proto, struct in_addr *a4, struct in6_addr *a6, int port, int scopeid, const char *cname4, const char *cname6)
425 {
426 si_item_t *item = NULL;
427 si_list_t *out4 = NULL, *out6 = NULL;
428 if (a4 != NULL)
429 {
430 if ((proto == IPPROTO_UNSPEC) || (proto == IPPROTO_UDP))
431 {
432 item = si_addrinfo_v4(si, 0, SOCK_DGRAM, IPPROTO_UDP, port, a4, 0, cname4);
433 out4 = si_list_add(out4, item);
434 si_item_release(item);
435 }
436
437 if ((proto == IPPROTO_UNSPEC) || (proto == IPPROTO_TCP))
438 {
439 item = si_addrinfo_v4(si, 0, SOCK_STREAM, IPPROTO_TCP, port, a4, 0, cname4);
440 out4 = si_list_add(out4, item);
441 si_item_release(item);
442 }
443
444 if (proto == IPPROTO_ICMP)
445 {
446 item = si_addrinfo_v4(si, 0, SOCK_RAW, IPPROTO_ICMP, port, a4, 0, cname4);
447 out4 = si_list_add(out4, item);
448 si_item_release(item);
449 }
450 }
451
452 if (a6 != NULL)
453 {
454 if ((proto == IPPROTO_UNSPEC) || (proto == IPPROTO_UDP))
455 {
456 item = si_addrinfo_v6(si, 0, SOCK_DGRAM, IPPROTO_UDP, port, a6, scopeid, cname6);
457 out6 = si_list_add(out6, item);
458 si_item_release(item);
459 }
460
461 if ((proto == IPPROTO_UNSPEC) || (proto == IPPROTO_TCP))
462 {
463 item = si_addrinfo_v6(si, 0, SOCK_STREAM, IPPROTO_TCP, port, a6, scopeid, cname6);
464 out6 = si_list_add(out6, item);
465 si_item_release(item);
466 }
467
468 if (proto == IPPROTO_ICMPV6)
469 {
470 item = si_addrinfo_v6(si, 0, SOCK_RAW, IPPROTO_ICMPV6, port, a6, scopeid, cname6);
471 out6 = si_list_add(out6, item);
472 si_item_release(item);
473 }
474 }
475
476 out6 = si_list_concat(out6, out4);
477 si_list_release(out4);
478
479 return out6;
480 }
481
482 /*
483 * _gai_numerichost
484 * Determines whether the given host name is a numeric IPv4 or IPv6 address,
485 * based on the address family input value. If the input addres family is
486 * unspecified, a more specific value will be provided on output if possible.
487 * Returns 1 if host name is numeric or 0 if not, or -1 on error.
488 */
489 static int
490 _gai_numerichost(const char* nodename, uint32_t *family, int flags, struct in_addr *a4, struct in6_addr *a6)
491 {
492 int numerichost, passive;
493
494 numerichost = 0;
495
496 if (nodename == NULL)
497 {
498 /* return loopback or passive addresses */
499 passive = (flags & AI_PASSIVE);
500
501 if ((*family == AF_UNSPEC) || (*family == AF_INET))
502 {
503 if (passive) a4->s_addr = 0;
504 else a4->s_addr = htonl(INADDR_LOOPBACK);
505 }
506
507 if ((*family == AF_UNSPEC) || (*family == AF_INET6))
508 {
509 memset(a6, 0, sizeof(*a6));
510 if (!passive) a6->__u6_addr.__u6_addr32[3] = htonl(1);
511 }
512
513 numerichost = 1;
514 }
515 else
516 {
517 /* numeric IPv4 host valid for AF_UNSPEC and AF_INET */
518 numerichost = inet_pton(AF_INET, nodename, a4);
519 if (numerichost == 1)
520 {
521 if (*family == AF_UNSPEC) *family = AF_INET;
522 else if (*family == AF_INET6) numerichost = -1;
523 return numerichost;
524 }
525
526 /* numeric IPv6 host valid for AF_UNSPEC and AF_INET6 */
527 numerichost = inet_pton(AF_INET6, nodename, a6);
528 if (numerichost == 1)
529 {
530 if (*family == AF_UNSPEC) *family = AF_INET6;
531 else if (*family == AF_INET) numerichost = -1;
532 return numerichost;
533 }
534 }
535
536 return numerichost;
537 }
538
539 /* si_addrinfo_list_from_hostent
540 * Returns an addrinfo list from IPv4 and IPv6 hostent entries
541 */
542 __private_extern__ si_list_t *
543 si_addrinfo_list_from_hostent(si_mod_t *si, uint32_t socktype, uint32_t proto, uint16_t port, uint16_t scope, const struct hostent *h4, const struct hostent *h6)
544 {
545 int i;
546 si_list_t *out = NULL;
547 si_list_t *list;
548
549 if ((h6 != NULL) && (h6->h_addr_list != NULL))
550 {
551 for (i = 0; h6->h_addr_list[i] != NULL; i++)
552 {
553 struct in6_addr a6;
554 memcpy(&a6, h6->h_addr_list[i], h6->h_length);
555 list = si_addrinfo_list(si, socktype, proto, NULL, &a6, port, scope, NULL, h6->h_name);
556 out = si_list_concat(out, list);
557 si_list_release(list);
558 }
559 }
560
561 if ((h4 != NULL) && (h4->h_addr_list != NULL))
562 {
563 for (i = 0; h4->h_addr_list[i] != NULL; i++)
564 {
565 struct in_addr a4;
566 memcpy(&a4, h4->h_addr_list[i], h4->h_length);
567 list = si_addrinfo_list(si, socktype, proto, &a4, NULL, port, 0, h4->h_name, NULL);
568 out = si_list_concat(out, list);
569 si_list_release(list);
570 }
571 }
572
573 return out;
574 }
575
576 /* _gai_simple
577 * Simple lookup via gethostbyname2(3) mechanism.
578 */
579 static si_list_t *
580 _gai_simple(si_mod_t *si, const void *nodeptr, const void *servptr, uint32_t family, uint32_t socktype, uint32_t proto, uint32_t flags, const char *interface, uint32_t *err)
581 {
582 si_item_t *h4_item = NULL, *h6_item = NULL;
583 struct hostent *h4 = NULL, *h6 = NULL;
584 si_list_t *out = NULL;
585 uint16_t port;
586
587 if ((flags & AI_NUMERICSERV) != 0)
588 {
589 port = *(uint16_t*)servptr;
590 }
591 else
592 {
593 if (_gai_serv_to_port(servptr, proto, &port) != 0)
594 {
595 if (err) *err = SI_STATUS_EAI_NONAME;
596 return NULL;
597 }
598 }
599
600 if ((flags & AI_NUMERICHOST) != 0)
601 {
602 if (family == AF_INET)
603 {
604 h4_item = si_host_byaddr(si, nodeptr, AF_INET, interface, NULL);
605 }
606 else if (family == AF_INET6)
607 {
608 h6_item = si_host_byaddr(si, nodeptr, AF_INET6, interface, NULL);
609 }
610 }
611 else
612 {
613 if ((family == AF_INET) || (family == AF_UNSPEC))
614 {
615 h4_item = si_host_byname(si, nodeptr, AF_INET, interface, NULL);
616 }
617
618 if ((family == AF_INET6) || (family == AF_UNSPEC))
619 {
620 h6_item = si_host_byname(si, nodeptr, AF_INET6, interface, NULL);
621 }
622 }
623
624 if (h4_item != NULL)
625 {
626 h4 = (struct hostent *)((uintptr_t)h4_item + sizeof(si_item_t));
627 }
628
629 if (h6_item != NULL)
630 {
631 h6 = (struct hostent *)((uintptr_t)h6_item + sizeof(si_item_t));
632 }
633
634 out = si_addrinfo_list_from_hostent(si, socktype, proto, port, 0, h4, h6);
635 si_item_release(h4_item);
636 si_item_release(h6_item);
637
638 return out;
639 }
640
641 __private_extern__ si_list_t *
642 si_srv_byname(si_mod_t *si, const char *qname, const char *interface, uint32_t *err)
643 {
644 if (si == NULL) return 0;
645 if (si->sim_srv_byname == NULL) return 0;
646
647 return si->sim_srv_byname(si, qname, interface, err);
648 }
649
650 __private_extern__ int
651 si_wants_addrinfo(si_mod_t *si)
652 {
653 if (si == NULL) return 0;
654 if (si->sim_addrinfo == NULL) return 0;
655 if (si->sim_wants_addrinfo == NULL) return 0;
656
657 return si->sim_wants_addrinfo(si);
658 }
659
660 static si_list_t *
661 _gai_srv(si_mod_t *si, const char *node, const char *serv, uint32_t family, uint32_t socktype, uint32_t proto, uint32_t flags, const char *interface, uint32_t *err)
662 {
663 int i;
664 char *qname;
665 si_srv_t *srv;
666 si_item_t *item;
667
668 si_list_t *list = NULL;
669 si_list_t *result = NULL;
670
671 /* Minimum SRV priority is zero. Start below that. */
672 int lastprio = -1;
673 int currprio;
674
675 if (node == NULL || serv == NULL) return NULL;
676
677 asprintf(&qname, "%s.%s", serv, node);
678 list = si_srv_byname(si, qname, interface, err);
679 free(qname);
680
681 /* Iterate the SRV records starting at lowest priority and attempt to
682 * lookup the target host name. Returns the first successful lookup.
683 * It's an O(n^2) algorithm but data sets are small (less than 100) and
684 * sorting overhead is dwarfed by network I/O for each element.
685 */
686 while (list != NULL && result == NULL)
687 {
688 /* Find the next lowest priority level. */
689 /* Maximum SRV priority is UINT16_MAX. Start above that. */
690 currprio = INT_MAX;
691
692 for (i = 0; i < list->count; ++i)
693 {
694 item = list->entry[i];
695 srv = (si_srv_t *)((uintptr_t)item + sizeof(si_item_t));
696
697 if (srv->priority > lastprio && srv->priority < currprio)
698 {
699 currprio = srv->priority;
700 }
701 }
702
703 if (currprio == INT_MAX)
704 {
705 /* All priorities have been evaluated. Done. */
706 break;
707 }
708 else
709 {
710 lastprio = currprio;
711 }
712
713 /* Lookup hosts at the current priority level. Return first match. */
714 for (i = 0; i < list->count; ++i)
715 {
716 item = list->entry[i];
717 srv = (si_srv_t *)((uintptr_t)item + sizeof(si_item_t));
718
719 if (srv->priority == currprio)
720 {
721 /* So that _gai_simple expects an integer service. */
722 flags |= AI_NUMERICSERV;
723
724 result = _gai_simple(si, srv->target, &srv->port, family, socktype, proto, flags, interface, err);
725 if (result)
726 {
727 break;
728 }
729 }
730 }
731 }
732
733 if (list != NULL)
734 {
735 si_list_release(list);
736 }
737
738 return result;
739 }
740
741 __private_extern__ si_list_t *
742 si_addrinfo(si_mod_t *si, const char *node, const char *serv, uint32_t family, uint32_t socktype, uint32_t proto, uint32_t flags, const char *interface, uint32_t *err)
743 {
744 int numerichost, numericserv = 0;
745 const void *nodeptr = NULL, *servptr = NULL;
746 uint16_t port;
747 struct in_addr a4, *p4;
748 struct in6_addr a6, *p6;
749 const char *cname;
750
751 if (err != NULL) *err = SI_STATUS_NO_ERROR;
752
753 if (si == NULL)
754 {
755 if (err != NULL) *err = SI_STATUS_EAI_FAIL;
756 return NULL;
757 }
758
759 /* treat empty strings as NULL */
760 if ((node != NULL) && (node[0] == '\0')) node = NULL;
761 if ((serv != NULL) && (serv[0] == '\0')) serv = NULL;
762
763 /* make sure we have a query */
764 if ((node == NULL) && (serv == NULL))
765 {
766 if (err != NULL) *err = SI_STATUS_EAI_NONAME;
767 return NULL;
768 }
769
770 /* verify family is supported */
771 switch (family)
772 {
773 case AF_UNSPEC:
774 case AF_INET:
775 case AF_INET6:
776 break;
777 default:
778 if (err != NULL) *err = SI_STATUS_EAI_FAMILY;
779 return NULL;
780 }
781
782 /* verify socket type is supported */
783 switch (socktype)
784 {
785 case SOCK_UNSPEC:
786 case SOCK_RAW:
787 case SOCK_DGRAM:
788 case SOCK_STREAM:
789 break;
790 default:
791 if (err != NULL) *err = SI_STATUS_EAI_BADHINTS;
792 return NULL;
793 }
794
795 /* verify protocol is supported */
796 switch (proto)
797 {
798 case IPPROTO_UNSPEC:
799 case IPPROTO_UDP:
800 case IPPROTO_TCP:
801 case IPPROTO_ICMP:
802 case IPPROTO_ICMPV6:
803 break;
804 default:
805 if (err != NULL) *err = SI_STATUS_EAI_BADHINTS;
806 return NULL;
807 }
808
809 /* verify socket type compatible with protocol */
810 if (((socktype == SOCK_DGRAM) && (proto != IPPROTO_UNSPEC) && (proto != IPPROTO_UDP)) || ((socktype == SOCK_STREAM) && (proto != IPPROTO_UNSPEC) && (proto != IPPROTO_TCP)))
811 {
812 if (err != NULL) *err = SI_STATUS_EAI_BADHINTS;
813 return NULL;
814 }
815
816 memset(&a4, 0, sizeof(struct in_addr));
817 memset(&a6, 0, sizeof(struct in6_addr));
818
819 /* determine the protocol if possible */
820 if ((proto == IPPROTO_UNSPEC) && (socktype == SOCK_DGRAM)) proto = IPPROTO_UDP;
821 if ((proto == IPPROTO_UNSPEC) && (socktype == SOCK_STREAM)) proto = IPPROTO_TCP;
822
823 port = 0;
824
825 if ((flags & AI_SRV) != 0)
826 {
827 /* AI_SRV SPI */
828 return _gai_srv(si, node, serv, family, socktype, proto, flags, interface, err);
829 }
830 else
831 {
832 /* Usual service lookup */
833 numericserv = _gai_numericserv(serv, &port);
834 }
835
836 if ((flags & AI_NUMERICSERV) && (numericserv == 0))
837 {
838 /* FreeBSD returns SI_STATUS_EAI_SERVICE */
839 if (err != NULL) *err = SI_STATUS_EAI_NONAME;
840 return NULL;
841 }
842
843 if (serv != NULL)
844 {
845 if (numericserv == 1)
846 {
847 flags |= AI_NUMERICSERV;
848 servptr = &port;
849 }
850 else
851 {
852 servptr = serv;
853 }
854 }
855
856 numerichost = _gai_numerichost(node, &family, flags, &a4, &a6);
857 if ((numerichost == -1) || ((flags & AI_NUMERICHOST) && (numerichost == 0)))
858 {
859 if (err != NULL) *err = SI_STATUS_EAI_NONAME;
860 return NULL;
861 }
862
863 if (numerichost == 1)
864 {
865 flags |= AI_NUMERICHOST;
866 if (family == AF_INET)
867 {
868 nodeptr = &a4;
869 }
870 else if (family == AF_INET6)
871 {
872 nodeptr = &a6;
873 }
874 }
875 else
876 {
877 nodeptr = node;
878 }
879
880 if ((numerichost == 1) && (numericserv == 0))
881 {
882 /* only service lookup needed. convert to port and perform a trivial getaddrinfo */
883 if (_gai_serv_to_port(serv, proto, &port) != 0)
884 {
885 if (err != NULL) *err = SI_STATUS_EAI_NONAME;
886 return NULL;
887 }
888 else
889 {
890 flags |= AI_NUMERICSERV;
891 servptr = &port;
892 numericserv = 1;
893 }
894 }
895
896 if ((numerichost == 1) && (numericserv == 1))
897 {
898 p4 = &a4;
899 p6 = &a6;
900 cname = NULL;
901
902 if (family == AF_INET) p6 = NULL;
903 if (family == AF_INET6) p4 = NULL;
904 if (node == NULL) cname = "localhost";
905
906 /* handle trivial questions */
907 return si_addrinfo_list(si, socktype, proto, p4, p6, port, 0, cname, cname);
908 }
909 else if ((si->sim_wants_addrinfo != NULL) && si->sim_wants_addrinfo(si))
910 {
911 /* or let the current module handle the host lookups intelligently */
912 return si->sim_addrinfo(si, nodeptr, servptr, family, socktype, proto, flags, interface, err);
913 }
914
915 /* fall back to a default path */
916 return _gai_simple(si, nodeptr, servptr, family, socktype, proto, flags, interface, err);
917 }
918
919 static struct addrinfo *
920 si_item_to_addrinfo(si_item_t *item)
921 {
922 si_addrinfo_t *a;
923 struct addrinfo *out;
924
925 if (item == NULL) return NULL;
926
927 a = (si_addrinfo_t *)((uintptr_t)item + sizeof(si_item_t));
928
929 out = (struct addrinfo *)calloc(1, sizeof(struct addrinfo));
930 if (out == NULL) return NULL;
931
932 out->ai_flags = a->ai_flags;
933 out->ai_family = a->ai_family;
934 out->ai_socktype = a->ai_socktype;
935 out->ai_protocol = a->ai_protocol;
936 out->ai_addrlen = a->ai_addrlen;
937
938 out->ai_addr = (struct sockaddr *)calloc(1, out->ai_addrlen);
939 if (out->ai_addr == NULL)
940 {
941 free(out);
942 return NULL;
943 }
944
945 memcpy(out->ai_addr, a->ai_addr.x, out->ai_addrlen);
946
947 if (a->ai_canonname != NULL)
948 {
949 out->ai_canonname = strdup(a->ai_canonname);
950 if (out->ai_canonname == NULL)
951 {
952 free(out);
953 return NULL;
954 }
955 }
956
957 return out;
958 }
959
960 __private_extern__ struct addrinfo *
961 si_list_to_addrinfo(si_list_t *list)
962 {
963 struct addrinfo *tail, *out;
964 int i;
965
966 if (list == NULL) return NULL;
967 if (list->count == 0) return NULL;
968
969 i = list->count - 1;
970
971 out = si_item_to_addrinfo(list->entry[i]);
972 tail = out;
973
974 for (i--; i >= 0; i--)
975 {
976 out = si_item_to_addrinfo(list->entry[i]);
977 if (out == NULL)
978 {
979 freeaddrinfo(tail);
980 return NULL;
981 }
982
983 out->ai_next = tail;
984 tail = out;
985 }
986
987 return out;
988 }
989
990 /* getipnodebyname */
991
992 static si_item_t *
993 make_hostent(si_mod_t *si, const char *name, struct in_addr addr)
994 {
995 char *addrs[2];
996 char *aliases[1];
997 uint64_t unused;
998
999 if (name == NULL) return NULL;
1000
1001 unused = 0;
1002
1003 addrs[0] = (char *)&(addr.s_addr);
1004 addrs[1] = NULL;
1005 aliases[0] = NULL;
1006
1007 return (si_item_t *)LI_ils_create("L4488s*44a", (unsigned long)si, CATEGORY_HOST_IPV4, 1, unused, unused, name, aliases, AF_INET, IPV4_ADDR_LEN, addrs);
1008 }
1009
1010 static si_item_t *
1011 make_hostent6(si_mod_t *si, const char *name, struct in6_addr addr)
1012 {
1013 char *addrs[2];
1014 char *aliases[1];
1015 uint64_t unused;
1016
1017 if (name == NULL) return NULL;
1018
1019 unused = 0;
1020
1021 addrs[0] = (char *)&(addr.__u6_addr.__u6_addr32[0]);
1022 addrs[1] = NULL;
1023 aliases[0] = NULL;
1024
1025 return (si_item_t *)LI_ils_create("L4488s*44c", (unsigned long)si, CATEGORY_HOST_IPV6, 1, unused, unused, name, aliases, AF_INET6, IPV6_ADDR_LEN, addrs);
1026 }
1027
1028 static char *
1029 lower_case(const char *s)
1030 {
1031 int i;
1032 char *t;
1033
1034 if (s == NULL) return NULL;
1035
1036 t = malloc(strlen(s) + 1);
1037
1038 for (i = 0; s[i] != '\0'; i++)
1039 {
1040 if ((s[i] >= 'A') && (s[i] <= 'Z')) t[i] = s[i] + 32;
1041 else t[i] = s[i];
1042 }
1043
1044 t[i] = '\0';
1045
1046 return t;
1047 }
1048
1049 static int
1050 merge_alias(const char *name, build_hostent_t *h)
1051 {
1052 int i;
1053
1054 if (name == NULL) return 0;
1055 if (h == NULL) return 0;
1056
1057 if ((h->host.h_name != NULL) && (string_equal(name, h->host.h_name))) return 0;
1058
1059 for (i = 0; i < h->alias_count; i++)
1060 {
1061 if (string_equal(name, h->host.h_aliases[i])) return 0;
1062 }
1063
1064 if (h->alias_count == 0) h->host.h_aliases = (char **)calloc(2, sizeof(char *));
1065 else h->host.h_aliases = (char **)reallocf(h->host.h_aliases, (h->alias_count + 2) * sizeof(char *));
1066
1067 if (h->host.h_aliases == NULL)
1068 {
1069 h->alias_count = 0;
1070 return -1;
1071 }
1072
1073 h->host.h_aliases[h->alias_count] = lower_case(name);
1074 h->alias_count++;
1075 h->host.h_aliases[h->alias_count] = NULL;
1076
1077 return 0;
1078 }
1079
1080 static int
1081 append_addr(const char *addr, uint32_t len, build_hostent_t *h)
1082 {
1083 if (addr == NULL) return 0;
1084 if (h == NULL) return 0;
1085
1086 if (h->addr_count == 0) h->host.h_addr_list = (char **)calloc(2, sizeof(char *));
1087 else h->host.h_addr_list = (char **)reallocf(h->host.h_addr_list, (h->addr_count + 2) * sizeof(char *));
1088
1089 if (h->host.h_addr_list == NULL)
1090 {
1091 h->addr_count = 0;
1092 return -1;
1093 }
1094
1095 h->host.h_addr_list[h->addr_count] = malloc(len);
1096 if (h->host.h_addr_list[h->addr_count] == NULL) return -1;
1097
1098 memcpy(h->host.h_addr_list[h->addr_count], addr, len);
1099 h->addr_count++;
1100 h->host.h_addr_list[h->addr_count] = NULL;
1101
1102 return 0;
1103 }
1104
1105 static void
1106 free_build_hostent(build_hostent_t *h)
1107 {
1108 uint32_t i;
1109 char **aliases;
1110
1111 if (h == NULL) return;
1112
1113 if (h->host.h_name != NULL) free(h->host.h_name);
1114 h->host.h_name = NULL;
1115
1116 aliases = h->host.h_aliases;
1117 if (aliases != NULL)
1118 {
1119 while (*aliases != NULL) free(*aliases++);
1120 free(h->host.h_aliases);
1121 }
1122
1123 h->host.h_aliases = NULL;
1124
1125 if (h->host.h_addr_list != NULL)
1126 {
1127 for (i = 0; h->host.h_addr_list[i] != NULL; i++) free(h->host.h_addr_list[i]);
1128 free(h->host.h_addr_list);
1129 }
1130
1131 h->host.h_addr_list = NULL;
1132 free(h);
1133 }
1134
1135 __private_extern__ si_item_t *
1136 si_ipnode_byname(si_mod_t *si, const char *name, int family, int flags, const char *interface, uint32_t *err)
1137 {
1138 int i, status, want, if4, if6;
1139 struct ifaddrs *ifa, *ifap;
1140 struct in_addr addr4;
1141 struct in6_addr addr6;
1142 si_item_t *item4, *item6;
1143 build_hostent_t *out;
1144 struct hostent *h;
1145 uint64_t unused;
1146
1147 memset(&addr4, 0, sizeof(struct in_addr));
1148 memset(&addr6, 0, sizeof(struct in6_addr));
1149
1150 if (err != NULL) *err = 0;
1151
1152 if (family == AF_INET)
1153 {
1154 status = inet_aton(name, &addr4);
1155 if (status == 1)
1156 {
1157 /* create a host entry */
1158 item4 = make_hostent(si, name, addr4);
1159 if (item4 == NULL)
1160 {
1161 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1162 return NULL;
1163 }
1164
1165 return item4;
1166 }
1167 }
1168 else if (family == AF_INET6)
1169 {
1170 status = inet_pton(family, name, &addr6);
1171 if (status == 1)
1172 {
1173 /* create a host entry */
1174 item6 = make_hostent6(si, name, addr6);
1175 if (item6 == NULL)
1176 {
1177 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1178 return NULL;
1179 }
1180
1181 return item6;
1182 }
1183
1184 status = inet_aton(name, &addr4);
1185 if (status == 1)
1186 {
1187 if (!(flags & (AI_V4MAPPED | AI_V4MAPPED_CFG)))
1188 {
1189 if (err != NULL) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
1190 return NULL;
1191 }
1192
1193 addr6.__u6_addr.__u6_addr32[0] = 0x00000000;
1194 addr6.__u6_addr.__u6_addr32[1] = 0x00000000;
1195 addr6.__u6_addr.__u6_addr32[2] = htonl(0x0000ffff);
1196 memmove(&(addr6.__u6_addr.__u6_addr32[3]), &(addr4.s_addr), IPV4_ADDR_LEN);
1197
1198 /* create a host entry */
1199 item6 = make_hostent6(si, name, addr6);
1200 if (item6 == NULL)
1201 {
1202 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1203 return NULL;
1204 }
1205
1206 return item6;
1207 }
1208 }
1209 else
1210 {
1211 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1212 return NULL;
1213 }
1214
1215 /*
1216 * IF AI_ADDRCONFIG is set, we need to know what interface flavors we really have.
1217 */
1218
1219 if4 = 0;
1220 if6 = 0;
1221
1222 if (flags & AI_ADDRCONFIG)
1223 {
1224 if (getifaddrs(&ifa) < 0)
1225 {
1226 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1227 return NULL;
1228 }
1229
1230 for (ifap = ifa; ifap != NULL; ifap = ifap->ifa_next)
1231 {
1232 if (ifap->ifa_addr == NULL) continue;
1233 if ((ifap->ifa_flags & IFF_UP) == 0) continue;
1234 if (ifap->ifa_addr->sa_family == AF_INET) if4++;
1235 else if (ifap->ifa_addr->sa_family == AF_INET6) if6++;
1236 }
1237
1238 freeifaddrs(ifa);
1239
1240 /* Bail out if there are no interfaces */
1241 if ((if4 == 0) && (if6 == 0))
1242 {
1243 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1244 return NULL;
1245 }
1246 }
1247
1248 /*
1249 * Figure out what we want.
1250 * If user asked for AF_INET, we only want V4 addresses.
1251 */
1252 want = WANT_A4_ONLY;
1253
1254 if (family == AF_INET)
1255 {
1256 if ((flags & AI_ADDRCONFIG) && (if4 == 0))
1257 {
1258 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1259 return NULL;
1260 }
1261 }
1262 else if (family == AF_INET6)
1263 {
1264 /* family == AF_INET6 */
1265 want = WANT_A6_ONLY;
1266
1267 if (flags & (AI_V4MAPPED | AI_V4MAPPED_CFG))
1268 {
1269 if (flags & AI_ALL)
1270 {
1271 want = WANT_A6_PLUS_MAPPED_A4;
1272 }
1273 else
1274 {
1275 want = WANT_A6_OR_MAPPED_A4_IF_NO_A6;
1276 }
1277 }
1278 else
1279 {
1280 if ((flags & AI_ADDRCONFIG) && (if6 == 0))
1281 {
1282 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1283 return NULL;
1284 }
1285 }
1286 }
1287 else
1288 {
1289 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1290 return NULL;
1291 }
1292
1293 item6 = NULL;
1294 item4 = NULL;
1295
1296 /* fetch IPv6 data if required */
1297 if ((want == WANT_A6_ONLY) || (want == WANT_A6_OR_MAPPED_A4_IF_NO_A6) || (want == WANT_A6_PLUS_MAPPED_A4))
1298 {
1299 item6 = si_host_byname(si, name, AF_INET6, interface, (uint32_t *)err);
1300 }
1301
1302 /* fetch IPv4 data if required */
1303 if ((want == WANT_A4_ONLY) || (want == WANT_A6_PLUS_MAPPED_A4) || ((want == WANT_A6_OR_MAPPED_A4_IF_NO_A6) && (item6 == NULL)))
1304 {
1305 item4 = si_host_byname(si, name, AF_INET, interface, (uint32_t *)err);
1306 }
1307
1308 if (want == WANT_A4_ONLY)
1309 {
1310 si_item_release(item6);
1311 if ((item4 == NULL) && (err != NULL)) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
1312 return item4;
1313 }
1314
1315 if (want == WANT_A6_ONLY)
1316 {
1317 si_item_release(item4);
1318 if ((item6 == NULL) && (err != NULL)) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
1319 return item6;
1320 }
1321
1322 if ((item6 == NULL) && (item4 == NULL))
1323 {
1324 if (err != NULL) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
1325 return NULL;
1326 }
1327
1328 /* output item will have IPv6 + mapped IPv4 addresses */
1329
1330 out = (build_hostent_t *)calloc(1, sizeof(build_hostent_t));
1331 if (out == NULL)
1332 {
1333 si_item_release(item4);
1334 si_item_release(item6);
1335 if (err != NULL) *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1336 return NULL;
1337 }
1338
1339 if (item4 != NULL)
1340 {
1341 h = (struct hostent *)((uintptr_t)item4 + sizeof(si_item_t));
1342
1343 out->host.h_name = lower_case(h->h_name);
1344
1345 if (h->h_aliases != NULL)
1346 {
1347 for (i = 0; h->h_aliases[i] != NULL; i++) merge_alias(h->h_aliases[i], out);
1348 }
1349
1350 for (i = 0; h->h_addr_list[i] != 0; i++)
1351 {
1352 addr6.__u6_addr.__u6_addr32[0] = 0x00000000;
1353 addr6.__u6_addr.__u6_addr32[1] = 0x00000000;
1354 addr6.__u6_addr.__u6_addr32[2] = htonl(0x0000ffff);
1355 memmove(&(addr6.__u6_addr.__u6_addr32[3]), h->h_addr_list[i], IPV4_ADDR_LEN);
1356 append_addr((const char *)&addr6, IPV6_ADDR_LEN, out);
1357 }
1358 }
1359
1360 if (item6 != NULL)
1361 {
1362 h = (struct hostent *)((uintptr_t)item6 + sizeof(si_item_t));
1363
1364 if (out->host.h_name == NULL) out->host.h_name = lower_case(h->h_name);
1365
1366 if (h->h_aliases != NULL)
1367 {
1368 for (i = 0; h->h_aliases[i] != NULL; i++) merge_alias(h->h_aliases[i], out);
1369 }
1370
1371 for (i = 0; h->h_addr_list[i] != 0; i++) append_addr(h->h_addr_list[i], IPV6_ADDR_LEN, out);
1372 }
1373
1374 si_item_release(item4);
1375 si_item_release(item6);
1376
1377 unused = 0;
1378
1379 item6 = (si_item_t *)LI_ils_create("L4488s*44c", (unsigned long)si, CATEGORY_HOST_IPV6, 1, unused, unused, out->host.h_name, out->host.h_aliases, AF_INET6, IPV6_ADDR_LEN, out->host.h_addr_list);
1380
1381 free_build_hostent(out);
1382
1383 return item6;
1384 }
mirror of libinfo