1 /* $KAME: name6.c,v 1.25 2000/06/26 16:44:40 itojun Exp $ */ 2 3 /* 4 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the project nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 /* 32 * ++Copyright++ 1985, 1988, 1993 33 * - 34 * Copyright (c) 1985, 1988, 1993 35 * The Regents of the University of California. All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 3. All advertising materials mentioning features or use of this software 46 * must display the following acknowledgement: 47 * This product includes software developed by the University of 48 * California, Berkeley and its contributors. 49 * 4. Neither the name of the University nor the names of its contributors 50 * may be used to endorse or promote products derived from this software 51 * without specific prior written permission. 52 * 53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 63 * SUCH DAMAGE. 64 * - 65 * Portions Copyright (c) 1993 by Digital Equipment Corporation. 66 * 67 * Permission to use, copy, modify, and distribute this software for any 68 * purpose with or without fee is hereby granted, provided that the above 69 * copyright notice and this permission notice appear in all copies, and that 70 * the name of Digital Equipment Corporation not be used in advertising or 71 * publicity pertaining to distribution of the document or software without 72 * specific, written prior permission. 73 * 74 * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL 75 * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES 76 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT 77 * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 78 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 79 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 80 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 81 * SOFTWARE. 82 * - 83 * --Copyright-- 84 */ 85 86 /* 87 * Atsushi Onoe <onoe@sm.sony.co.jp> 88 */ 89 90 #include <sys/cdefs.h> 91 __FBSDID("$FreeBSD$"); 92 93 #include "namespace.h" 94 #ifdef ICMPNL 95 #include "reentrant.h" 96 #endif 97 #include <sys/param.h> 98 #include <sys/socket.h> 99 #include <sys/time.h> 100 #include <sys/queue.h> 101 #include <netinet/in.h> 102 #ifdef INET6 103 #include <net/if.h> 104 #include <net/if_var.h> 105 #include <sys/sysctl.h> 106 #include <sys/ioctl.h> 107 #include <netinet6/in6_var.h> /* XXX */ 108 #endif 109 110 #include <arpa/inet.h> 111 #include <arpa/nameser.h> 112 113 #include <errno.h> 114 #include <netdb.h> 115 #include <resolv.h> 116 #include <stdio.h> 117 #include <stdlib.h> 118 #include <string.h> 119 #include <stdarg.h> 120 #include <nsswitch.h> 121 #include <unistd.h> 122 #include "un-namespace.h" 123 #include "netdb_private.h" 124 #include "res_config.h" 125 #include "res_private.h" 126 #ifdef NS_CACHING 127 #include "nscache.h" 128 #endif 129 130 #ifndef _PATH_HOSTS 131 #define _PATH_HOSTS "/etc/hosts" 132 #endif 133 134 #ifndef MAXALIASES 135 #define MAXALIASES 10 136 #endif 137 #ifndef MAXADDRS 138 #define MAXADDRS 20 139 #endif 140 #ifndef MAXDNAME 141 #define MAXDNAME 1025 142 #endif 143 144 #ifdef INET6 145 #define ADDRLEN(af) ((af) == AF_INET6 ? sizeof(struct in6_addr) : \ 146 sizeof(struct in_addr)) 147 #else 148 #define ADDRLEN(af) sizeof(struct in_addr) 149 #endif 150 151 #define MAPADDR(ab, ina) \ 152 do { \ 153 memcpy(&(ab)->map_inaddr, ina, sizeof(struct in_addr)); \ 154 memset((ab)->map_zero, 0, sizeof((ab)->map_zero)); \ 155 memset((ab)->map_one, 0xff, sizeof((ab)->map_one)); \ 156 } while (0) 157 #define MAPADDRENABLED(flags) \ 158 (((flags) & AI_V4MAPPED) || \ 159 (((flags) & AI_V4MAPPED_CFG) && _mapped_addr_enabled())) 160 161 union inx_addr { 162 struct in_addr in_addr; 163 #ifdef INET6 164 struct in6_addr in6_addr; 165 #endif 166 struct { 167 u_char mau_zero[10]; 168 u_char mau_one[2]; 169 struct in_addr mau_inaddr; 170 } map_addr_un; 171 #define map_zero map_addr_un.mau_zero 172 #define map_one map_addr_un.mau_one 173 #define map_inaddr map_addr_un.mau_inaddr 174 }; 175 176 struct policyqueue { 177 TAILQ_ENTRY(policyqueue) pc_entry; 178 #ifdef INET6 179 struct in6_addrpolicy pc_policy; 180 #endif 181 }; 182 TAILQ_HEAD(policyhead, policyqueue); 183 184 #define AIO_SRCFLAG_DEPRECATED 0x1 185 186 struct hp_order { 187 union { 188 struct sockaddr_storage aiou_ss; 189 struct sockaddr aiou_sa; 190 } aio_src_un; 191 #define aio_srcsa aio_src_un.aiou_sa 192 u_int32_t aio_srcflag; 193 int aio_srcscope; 194 int aio_dstscope; 195 struct policyqueue *aio_srcpolicy; 196 struct policyqueue *aio_dstpolicy; 197 union { 198 struct sockaddr_storage aiou_ss; 199 struct sockaddr aiou_sa; 200 } aio_un; 201 #define aio_sa aio_un.aiou_sa 202 int aio_matchlen; 203 char *aio_h_addr; 204 }; 205 206 static struct hostent *_hpcopy(struct hostent *, int *); 207 static struct hostent *_hpaddr(int, const char *, void *, int *); 208 static struct hostent *_hpmerge(struct hostent *, struct hostent *, int *); 209 #ifdef INET6 210 static struct hostent *_hpmapv6(struct hostent *, int *); 211 #endif 212 static struct hostent *_hpsort(struct hostent *, res_state); 213 static struct hostent *_ghbyname(const char *, int, int, int *); 214 static char *_hgetword(char **); 215 static int _mapped_addr_enabled(void); 216 217 static struct hostent *_hpreorder(struct hostent *); 218 static int get_addrselectpolicy(struct policyhead *); 219 static void free_addrselectpolicy(struct policyhead *); 220 static struct policyqueue *match_addrselectpolicy(struct sockaddr *, 221 struct policyhead *); 222 static void set_source(struct hp_order *, struct policyhead *); 223 static int matchlen(struct sockaddr *, struct sockaddr *); 224 static int comp_dst(const void *, const void *); 225 static int gai_addr2scopetype(struct sockaddr *); 226 227 static FILE *_files_open(int *); 228 static int _files_ghbyname(void *, void *, va_list); 229 static int _files_ghbyaddr(void *, void *, va_list); 230 #ifdef YP 231 static int _nis_ghbyname(void *, void *, va_list); 232 static int _nis_ghbyaddr(void *, void *, va_list); 233 #endif 234 static int _dns_ghbyname(void *, void *, va_list); 235 static int _dns_ghbyaddr(void *, void *, va_list); 236 static void _dns_shent(int) __unused; 237 static void _dns_ehent(void) __unused; 238 #ifdef ICMPNL 239 static int _icmp_ghbyaddr(void *, void *, va_list); 240 #endif /* ICMPNL */ 241 #ifdef NS_CACHING 242 static int ipnode_id_func(char *, size_t *, va_list, void *); 243 static int ipnode_marshal_func(char *, size_t *, void *, va_list, void *); 244 static int ipnode_unmarshal_func(char *, size_t, void *, va_list, void *); 245 #endif 246 247 #ifdef ICMPNL 248 static mutex_t _getipnodeby_thread_lock = MUTEX_INITIALIZER; 249 #define THREAD_LOCK() mutex_lock(&_getipnodeby_thread_lock); 250 #define THREAD_UNLOCK() mutex_unlock(&_getipnodeby_thread_lock); 251 #endif 252 253 /* Host lookup order if nsswitch.conf is broken or nonexistant */ 254 static const ns_src default_src[] = { 255 { NSSRC_FILES, NS_SUCCESS }, 256 { NSSRC_DNS, NS_SUCCESS }, 257 #ifdef ICMPNL 258 #define NSSRC_ICMP "icmp" 259 { NSSRC_ICMP, NS_SUCCESS }, 260 #endif 261 { 0 } 262 }; 263 264 /* 265 * Check if kernel supports mapped address. 266 * implementation dependent 267 */ 268 #ifdef __KAME__ 269 #include <sys/sysctl.h> 270 #endif /* __KAME__ */ 271 272 static int 273 _mapped_addr_enabled(void) 274 { 275 /* implementation dependent check */ 276 #if defined(__KAME__) && defined(IPV6CTL_MAPPED_ADDR) 277 int mib[4]; 278 size_t len; 279 int val; 280 281 mib[0] = CTL_NET; 282 mib[1] = PF_INET6; 283 mib[2] = IPPROTO_IPV6; 284 mib[3] = IPV6CTL_MAPPED_ADDR; 285 len = sizeof(val); 286 if (sysctl(mib, 4, &val, &len, 0, 0) == 0 && val != 0) 287 return 1; 288 #endif /* __KAME__ && IPV6CTL_MAPPED_ADDR */ 289 return 0; 290 } 291 292 #ifdef NS_CACHING 293 static int 294 ipnode_id_func(char *buffer, size_t *buffer_size, va_list ap, 295 void *cache_mdata) 296 { 297 res_state statp; 298 u_long res_options; 299 300 const int op_id = 2; 301 char *name; 302 int af; 303 size_t len; 304 void *src; 305 306 char *p; 307 size_t desired_size, size; 308 enum nss_lookup_type lookup_type; 309 int res = NS_UNAVAIL; 310 311 statp = __res_state(); 312 res_options = statp->options & (RES_RECURSE | RES_DEFNAMES | 313 RES_DNSRCH | RES_NOALIASES | RES_USE_INET6); 314 315 lookup_type = (enum nss_lookup_type)cache_mdata; 316 switch (lookup_type) { 317 case nss_lt_name: 318 name = va_arg(ap, char *); 319 af = va_arg(ap, int); 320 321 size = strlen(name); 322 desired_size = sizeof(res_options) + sizeof(int) + 323 sizeof(enum nss_lookup_type) + sizeof(int) + size + 1; 324 325 if (desired_size > *buffer_size) { 326 res = NS_RETURN; 327 goto fin; 328 } 329 330 p = buffer; 331 memcpy(p, &res_options, sizeof(res_options)); 332 p += sizeof(res_options); 333 334 memcpy(p, &op_id, sizeof(int)); 335 p += sizeof(int); 336 337 memcpy(p, &lookup_type, sizeof(enum nss_lookup_type)); 338 p += sizeof(enum nss_lookup_type); 339 340 memcpy(p, &af, sizeof(int)); 341 p += sizeof(int); 342 343 memcpy(p, name, size + 1); 344 345 res = NS_SUCCESS; 346 break; 347 case nss_lt_id: 348 src = va_arg(ap, void *); 349 len = va_arg(ap, size_t); 350 af = va_arg(ap, int); 351 352 desired_size = sizeof(res_options) + sizeof(int) + 353 sizeof(enum nss_lookup_type) + sizeof(int) + 354 sizeof(size_t) + len; 355 356 if (desired_size > *buffer_size) { 357 res = NS_RETURN; 358 goto fin; 359 } 360 361 p = buffer; 362 memcpy(p, &res_options, sizeof(res_options)); 363 p += sizeof(res_options); 364 365 memcpy(p, &op_id, sizeof(int)); 366 p += sizeof(int); 367 368 memcpy(p, &lookup_type, sizeof(enum nss_lookup_type)); 369 p += sizeof(enum nss_lookup_type); 370 371 memcpy(p, &af, sizeof(int)); 372 p += sizeof(int); 373 374 memcpy(p, &len, sizeof(size_t)); 375 p += sizeof(size_t); 376 377 memcpy(p, src, len); 378 379 res = NS_SUCCESS; 380 break; 381 default: 382 /* should be unreachable */ 383 return (NS_UNAVAIL); 384 } 385 386 fin: 387 *buffer_size = desired_size; 388 return (res); 389 } 390 391 static int 392 ipnode_marshal_func(char *buffer, size_t *buffer_size, void *retval, 393 va_list ap, void *cache_mdata) 394 { 395 struct hostent *ht; 396 397 struct hostent new_ht; 398 size_t desired_size, aliases_size, addr_size, size; 399 char *p, **iter; 400 401 ht = *((struct hostent **)retval); 402 403 desired_size = _ALIGNBYTES + sizeof(struct hostent) + sizeof(char *); 404 if (ht->h_name != NULL) 405 desired_size += strlen(ht->h_name) + 1; 406 407 if (ht->h_aliases != NULL) { 408 aliases_size = 0; 409 for (iter = ht->h_aliases; *iter; ++iter) { 410 desired_size += strlen(*iter) + 1; 411 ++aliases_size; 412 } 413 414 desired_size += _ALIGNBYTES + 415 (aliases_size + 1) * sizeof(char *); 416 } 417 418 if (ht->h_addr_list != NULL) { 419 addr_size = 0; 420 for (iter = ht->h_addr_list; *iter; ++iter) 421 ++addr_size; 422 423 desired_size += addr_size * _ALIGN(ht->h_length); 424 desired_size += _ALIGNBYTES + (addr_size + 1) * sizeof(char *); 425 } 426 427 if (desired_size > *buffer_size) { 428 /* this assignment is here for future use */ 429 *buffer_size = desired_size; 430 return (NS_RETURN); 431 } 432 433 memcpy(&new_ht, ht, sizeof(struct hostent)); 434 memset(buffer, 0, desired_size); 435 436 *buffer_size = desired_size; 437 p = buffer + sizeof(struct hostent) + sizeof(char *); 438 memcpy(buffer + sizeof(struct hostent), &p, sizeof(char *)); 439 p = (char *)_ALIGN(p); 440 441 if (new_ht.h_name != NULL) { 442 size = strlen(new_ht.h_name); 443 memcpy(p, new_ht.h_name, size); 444 new_ht.h_name = p; 445 p += size + 1; 446 } 447 448 if (new_ht.h_aliases != NULL) { 449 p = (char *)_ALIGN(p); 450 memcpy(p, new_ht.h_aliases, sizeof(char *) * aliases_size); 451 new_ht.h_aliases = (char **)p; 452 p += sizeof(char *) * (aliases_size + 1); 453 454 for (iter = new_ht.h_aliases; *iter; ++iter) { 455 size = strlen(*iter); 456 memcpy(p, *iter, size); 457 *iter = p; 458 p += size + 1; 459 } 460 } 461 462 if (new_ht.h_addr_list != NULL) { 463 p = (char *)_ALIGN(p); 464 memcpy(p, new_ht.h_addr_list, sizeof(char *) * addr_size); 465 new_ht.h_addr_list = (char **)p; 466 p += sizeof(char *) * (addr_size + 1); 467 468 size = _ALIGN(new_ht.h_length); 469 for (iter = new_ht.h_addr_list; *iter; ++iter) { 470 memcpy(p, *iter, size); 471 *iter = p; 472 p += size + 1; 473 } 474 } 475 memcpy(buffer, &new_ht, sizeof(struct hostent)); 476 return (NS_SUCCESS); 477 } 478 479 static int 480 ipnode_unmarshal_func(char *buffer, size_t buffer_size, void *retval, 481 va_list ap, void *cache_mdata) 482 { 483 struct hostent new_ht; 484 struct hostent *ht; 485 486 char *p; 487 char **iter; 488 char *orig_buf; 489 int err; 490 491 ht = &new_ht; 492 493 memcpy(ht, buffer, sizeof(struct hostent)); 494 memcpy(&p, buffer + sizeof(struct hostent), sizeof(char *)); 495 496 orig_buf = buffer + sizeof(struct hostent) + sizeof(char *) + 497 _ALIGN(p) - (size_t)p; 498 p = (char *)_ALIGN(p); 499 500 501 NS_APPLY_OFFSET(ht->h_name, orig_buf, p, char *); 502 if (ht->h_aliases != NULL) { 503 NS_APPLY_OFFSET(ht->h_aliases, orig_buf, p, char **); 504 505 for (iter = ht->h_aliases; *iter; ++iter) 506 NS_APPLY_OFFSET(*iter, orig_buf, p, char *); 507 } 508 509 if (ht->h_addr_list != NULL) { 510 NS_APPLY_OFFSET(ht->h_addr_list, orig_buf, p, char **); 511 512 for (iter = ht->h_addr_list; *iter; ++iter) 513 NS_APPLY_OFFSET(*iter, orig_buf, p, char *); 514 } 515 516 ht = _hpcopy(ht, &err); 517 if (ht == NULL) 518 return (NS_UNAVAIL); 519 520 *((struct hostent **)retval) = ht; 521 return (NS_SUCCESS); 522 } 523 #endif 524 525 /* 526 * Functions defined in RFC2553 527 * getipnodebyname, getipnodebyaddr, freehostent 528 */ 529 530 static struct hostent * 531 _ghbyname(const char *name, int af, int flags, int *errp) 532 { 533 struct hostent *hp; 534 int rval; 535 536 #ifdef NS_CACHING 537 static const nss_cache_info cache_info = 538 NS_COMMON_CACHE_INFO_INITIALIZER( 539 hosts, (void *)nss_lt_name, 540 ipnode_id_func, ipnode_marshal_func, ipnode_unmarshal_func); 541 #endif 542 static const ns_dtab dtab[] = { 543 NS_FILES_CB(_files_ghbyname, NULL) 544 { NSSRC_DNS, _dns_ghbyname, NULL }, 545 NS_NIS_CB(_nis_ghbyname, NULL) 546 #ifdef NS_CACHING 547 NS_CACHE_CB(&cache_info) 548 #endif 549 { 0 } 550 }; 551 552 if (flags & AI_ADDRCONFIG) { 553 int s; 554 555 if ((s = _socket(af, SOCK_DGRAM, 0)) < 0) 556 return NULL; 557 /* 558 * TODO: 559 * Note that implementation dependent test for address 560 * configuration should be done everytime called 561 * (or apropriate interval), 562 * because addresses will be dynamically assigned or deleted. 563 */ 564 _close(s); 565 } 566 567 rval = _nsdispatch(&hp, dtab, NSDB_HOSTS, "ghbyname", default_src, 568 name, af, errp); 569 return (rval == NS_SUCCESS) ? hp : NULL; 570 } 571 572 struct hostent * 573 getipnodebyname(const char *name, int af, int flags, int *errp) 574 { 575 struct hostent *hp; 576 union inx_addr addrbuf; 577 res_state statp; 578 579 switch (af) { 580 case AF_INET: 581 #ifdef INET6 582 case AF_INET6: 583 #endif 584 break; 585 default: 586 *errp = NO_RECOVERY; 587 return NULL; 588 } 589 590 #ifdef INET6 591 /* special case for literal address */ 592 if (inet_pton(AF_INET6, name, &addrbuf) == 1) { 593 if (af != AF_INET6) { 594 *errp = HOST_NOT_FOUND; 595 return NULL; 596 } 597 return _hpaddr(af, name, &addrbuf, errp); 598 } 599 #endif 600 if (inet_aton(name, (struct in_addr *)&addrbuf) == 1) { 601 if (af != AF_INET) { 602 if (MAPADDRENABLED(flags)) { 603 MAPADDR(&addrbuf, &addrbuf.in_addr); 604 } else { 605 *errp = HOST_NOT_FOUND; 606 return NULL; 607 } 608 } 609 return _hpaddr(af, name, &addrbuf, errp); 610 } 611 612 statp = __res_state(); 613 if ((statp->options & RES_INIT) == 0) { 614 if (res_ninit(statp) < 0) { 615 *errp = NETDB_INTERNAL; 616 return NULL; 617 } 618 } 619 620 *errp = HOST_NOT_FOUND; 621 hp = _ghbyname(name, af, flags, errp); 622 623 #ifdef INET6 624 if (af == AF_INET6 && ((flags & AI_ALL) || hp == NULL) && 625 MAPADDRENABLED(flags)) { 626 struct hostent *hp2 = _ghbyname(name, AF_INET, flags, errp); 627 if (hp == NULL) 628 hp = _hpmapv6(hp2, errp); 629 else { 630 if (hp2 && strcmp(hp->h_name, hp2->h_name) != 0) { 631 freehostent(hp2); 632 hp2 = NULL; 633 } 634 hp = _hpmerge(hp, hp2, errp); 635 } 636 } 637 #endif 638 return _hpreorder(_hpsort(hp, statp)); 639 } 640 641 struct hostent * 642 getipnodebyaddr(const void *src, size_t len, int af, int *errp) 643 { 644 struct hostent *hp; 645 int rval; 646 #ifdef INET6 647 struct in6_addr addrbuf; 648 #else 649 struct in_addr addrbuf; 650 #endif 651 652 #ifdef NS_CACHING 653 static const nss_cache_info cache_info = 654 NS_COMMON_CACHE_INFO_INITIALIZER( 655 hosts, (void *)nss_lt_id, 656 ipnode_id_func, ipnode_marshal_func, ipnode_unmarshal_func); 657 #endif 658 static const ns_dtab dtab[] = { 659 NS_FILES_CB(_files_ghbyaddr, NULL) 660 { NSSRC_DNS, _dns_ghbyaddr, NULL }, 661 NS_NIS_CB(_nis_ghbyaddr, NULL) 662 #ifdef ICMPNL 663 { NSSRC_ICMP, _icmp_ghbyaddr, NULL }, 664 #endif 665 #ifdef NS_CACHING 666 NS_CACHE_CB(&cache_info) 667 #endif 668 { 0 } 669 }; 670 671 *errp = HOST_NOT_FOUND; 672 673 switch (af) { 674 case AF_INET: 675 if (len != sizeof(struct in_addr)) { 676 *errp = NO_RECOVERY; 677 return NULL; 678 } 679 if ((long)src & ~(sizeof(struct in_addr) - 1)) { 680 memcpy(&addrbuf, src, len); 681 src = &addrbuf; 682 } 683 if (((struct in_addr *)src)->s_addr == 0) 684 return NULL; 685 break; 686 #ifdef INET6 687 case AF_INET6: 688 if (len != sizeof(struct in6_addr)) { 689 *errp = NO_RECOVERY; 690 return NULL; 691 } 692 if ((long)src & ~(sizeof(struct in6_addr) / 2 - 1)) { /*XXX*/ 693 memcpy(&addrbuf, src, len); 694 src = &addrbuf; 695 } 696 if (IN6_IS_ADDR_UNSPECIFIED((struct in6_addr *)src)) 697 return NULL; 698 if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)src) 699 || IN6_IS_ADDR_V4COMPAT((struct in6_addr *)src)) { 700 src = (char *)src + 701 (sizeof(struct in6_addr) - sizeof(struct in_addr)); 702 af = AF_INET; 703 len = sizeof(struct in_addr); 704 } 705 break; 706 #endif 707 default: 708 *errp = NO_RECOVERY; 709 return NULL; 710 } 711 712 rval = _nsdispatch(&hp, dtab, NSDB_HOSTS, "ghbyaddr", default_src, 713 src, len, af, errp); 714 return (rval == NS_SUCCESS) ? hp : NULL; 715 } 716 717 void 718 freehostent(struct hostent *ptr) 719 { 720 free(ptr); 721 } 722 723 /* 724 * Private utility functions 725 */ 726 727 /* 728 * _hpcopy: allocate and copy hostent structure 729 */ 730 static struct hostent * 731 _hpcopy(struct hostent *hp, int *errp) 732 { 733 struct hostent *nhp; 734 char *cp, **pp; 735 int size, addrsize; 736 int nalias = 0, naddr = 0; 737 int al_off; 738 int i; 739 740 if (hp == NULL) 741 return hp; 742 743 /* count size to be allocated */ 744 size = sizeof(struct hostent); 745 if (hp->h_name != NULL) 746 size += strlen(hp->h_name) + 1; 747 if ((pp = hp->h_aliases) != NULL) { 748 for (i = 0; *pp != NULL; i++, pp++) { 749 if (**pp != '\0') { 750 size += strlen(*pp) + 1; 751 nalias++; 752 } 753 } 754 } 755 /* adjust alignment */ 756 size = ALIGN(size); 757 al_off = size; 758 size += sizeof(char *) * (nalias + 1); 759 addrsize = ALIGN(hp->h_length); 760 if ((pp = hp->h_addr_list) != NULL) { 761 while (*pp++ != NULL) 762 naddr++; 763 } 764 size += addrsize * naddr; 765 size += sizeof(char *) * (naddr + 1); 766 767 /* copy */ 768 if ((nhp = (struct hostent *)malloc(size)) == NULL) { 769 *errp = TRY_AGAIN; 770 return NULL; 771 } 772 cp = (char *)&nhp[1]; 773 if (hp->h_name != NULL) { 774 nhp->h_name = cp; 775 strcpy(cp, hp->h_name); 776 cp += strlen(cp) + 1; 777 } else 778 nhp->h_name = NULL; 779 nhp->h_aliases = (char **)((char *)nhp + al_off); 780 if ((pp = hp->h_aliases) != NULL) { 781 for (i = 0; *pp != NULL; pp++) { 782 if (**pp != '\0') { 783 nhp->h_aliases[i++] = cp; 784 strcpy(cp, *pp); 785 cp += strlen(cp) + 1; 786 } 787 } 788 } 789 nhp->h_aliases[nalias] = NULL; 790 cp = (char *)&nhp->h_aliases[nalias + 1]; 791 nhp->h_addrtype = hp->h_addrtype; 792 nhp->h_length = hp->h_length; 793 nhp->h_addr_list = (char **)cp; 794 if ((pp = hp->h_addr_list) != NULL) { 795 cp = (char *)&nhp->h_addr_list[naddr + 1]; 796 for (i = 0; *pp != NULL; pp++) { 797 nhp->h_addr_list[i++] = cp; 798 memcpy(cp, *pp, hp->h_length); 799 cp += addrsize; 800 } 801 } 802 nhp->h_addr_list[naddr] = NULL; 803 return nhp; 804 } 805 806 /* 807 * _hpaddr: construct hostent structure with one address 808 */ 809 static struct hostent * 810 _hpaddr(int af, const char *name, void *addr, int *errp) 811 { 812 struct hostent *hp, hpbuf; 813 char *addrs[2]; 814 815 hp = &hpbuf; 816 hp->h_name = (char *)name; 817 hp->h_aliases = NULL; 818 hp->h_addrtype = af; 819 hp->h_length = ADDRLEN(af); 820 hp->h_addr_list = addrs; 821 addrs[0] = (char *)addr; 822 addrs[1] = NULL; 823 return _hpcopy(hp, errp); 824 } 825 826 /* 827 * _hpmerge: merge 2 hostent structure, arguments will be freed 828 */ 829 static struct hostent * 830 _hpmerge(struct hostent *hp1, struct hostent *hp2, int *errp) 831 { 832 int i, j; 833 int naddr, nalias; 834 char **pp; 835 struct hostent *hp, hpbuf; 836 char *aliases[MAXALIASES + 1], *addrs[MAXADDRS + 1]; 837 union inx_addr addrbuf[MAXADDRS]; 838 839 if (hp1 == NULL) 840 return hp2; 841 if (hp2 == NULL) 842 return hp1; 843 844 #define HP(i) (i == 1 ? hp1 : hp2) 845 hp = &hpbuf; 846 hp->h_name = (hp1->h_name != NULL ? hp1->h_name : hp2->h_name); 847 hp->h_aliases = aliases; 848 nalias = 0; 849 for (i = 1; i <= 2; i++) { 850 if ((pp = HP(i)->h_aliases) == NULL) 851 continue; 852 for (; nalias < MAXALIASES && *pp != NULL; pp++) { 853 /* check duplicates */ 854 for (j = 0; j < nalias; j++) 855 if (strcasecmp(*pp, aliases[j]) == 0) 856 break; 857 if (j == nalias) 858 aliases[nalias++] = *pp; 859 } 860 } 861 aliases[nalias] = NULL; 862 #ifdef INET6 863 if (hp1->h_length != hp2->h_length) { 864 hp->h_addrtype = AF_INET6; 865 hp->h_length = sizeof(struct in6_addr); 866 } else { 867 #endif 868 hp->h_addrtype = hp1->h_addrtype; 869 hp->h_length = hp1->h_length; 870 #ifdef INET6 871 } 872 #endif 873 hp->h_addr_list = addrs; 874 naddr = 0; 875 for (i = 1; i <= 2; i++) { 876 if ((pp = HP(i)->h_addr_list) == NULL) 877 continue; 878 if (HP(i)->h_length == hp->h_length) { 879 while (naddr < MAXADDRS && *pp != NULL) 880 addrs[naddr++] = *pp++; 881 } else { 882 /* copy IPv4 addr as mapped IPv6 addr */ 883 while (naddr < MAXADDRS && *pp != NULL) { 884 MAPADDR(&addrbuf[naddr], *pp++); 885 addrs[naddr] = (char *)&addrbuf[naddr]; 886 naddr++; 887 } 888 } 889 } 890 addrs[naddr] = NULL; 891 hp = _hpcopy(hp, errp); 892 freehostent(hp1); 893 freehostent(hp2); 894 return hp; 895 } 896 897 /* 898 * _hpmapv6: convert IPv4 hostent into IPv4-mapped IPv6 addresses 899 */ 900 #ifdef INET6 901 static struct hostent * 902 _hpmapv6(struct hostent *hp, int *errp) 903 { 904 struct hostent *hp6; 905 906 if (hp == NULL) 907 return NULL; 908 if (hp->h_addrtype == AF_INET6) 909 return hp; 910 911 /* make dummy hostent to convert IPv6 address */ 912 if ((hp6 = (struct hostent *)malloc(sizeof(struct hostent))) == NULL) { 913 *errp = TRY_AGAIN; 914 return NULL; 915 } 916 hp6->h_name = NULL; 917 hp6->h_aliases = NULL; 918 hp6->h_addrtype = AF_INET6; 919 hp6->h_length = sizeof(struct in6_addr); 920 hp6->h_addr_list = NULL; 921 return _hpmerge(hp6, hp, errp); 922 } 923 #endif 924 925 /* 926 * _hpsort: sort address by sortlist 927 */ 928 static struct hostent * 929 _hpsort(struct hostent *hp, res_state statp) 930 { 931 int i, j, n; 932 u_char *ap, *sp, *mp, **pp; 933 char t; 934 char order[MAXADDRS]; 935 int nsort = statp->nsort; 936 937 if (hp == NULL || hp->h_addr_list[1] == NULL || nsort == 0) 938 return hp; 939 for (i = 0; (ap = (u_char *)hp->h_addr_list[i]); i++) { 940 for (j = 0; j < nsort; j++) { 941 #ifdef INET6 942 if (statp->_u._ext.ext->sort_list[j].af != 943 hp->h_addrtype) 944 continue; 945 sp = (u_char *)&statp->_u._ext.ext->sort_list[j].addr; 946 mp = (u_char *)&statp->_u._ext.ext->sort_list[j].mask; 947 #else 948 sp = (u_char *)&statp->sort_list[j].addr; 949 mp = (u_char *)&statp->sort_list[j].mask; 950 #endif 951 for (n = 0; n < hp->h_length; n++) { 952 if ((ap[n] & mp[n]) != sp[n]) 953 break; 954 } 955 if (n == hp->h_length) 956 break; 957 } 958 order[i] = j; 959 } 960 n = i; 961 pp = (u_char **)hp->h_addr_list; 962 for (i = 0; i < n - 1; i++) { 963 for (j = i + 1; j < n; j++) { 964 if (order[i] > order[j]) { 965 ap = pp[i]; 966 pp[i] = pp[j]; 967 pp[j] = ap; 968 t = order[i]; 969 order[i] = order[j]; 970 order[j] = t; 971 } 972 } 973 } 974 return hp; 975 } 976 977 static char * 978 _hgetword(char **pp) 979 { 980 char c, *p, *ret; 981 const char *sp; 982 static const char sep[] = "# \t\n"; 983 984 ret = NULL; 985 for (p = *pp; (c = *p) != '\0'; p++) { 986 for (sp = sep; *sp != '\0'; sp++) { 987 if (c == *sp) 988 break; 989 } 990 if (c == '#') 991 p[1] = '\0'; /* ignore rest of line */ 992 if (ret == NULL) { 993 if (*sp == '\0') 994 ret = p; 995 } else { 996 if (*sp != '\0') { 997 *p++ = '\0'; 998 break; 999 } 1000 } 1001 } 1002 *pp = p; 1003 if (ret == NULL || *ret == '\0') 1004 return NULL; 1005 return ret; 1006 } 1007 1008 /* 1009 * _hpreorder: sort address by default address selection 1010 */ 1011 static struct hostent * 1012 _hpreorder(struct hostent *hp) 1013 { 1014 struct hp_order *aio; 1015 int i, n; 1016 char *ap; 1017 struct sockaddr *sa; 1018 struct policyhead policyhead; 1019 1020 if (hp == NULL) 1021 return hp; 1022 1023 switch (hp->h_addrtype) { 1024 case AF_INET: 1025 #ifdef INET6 1026 case AF_INET6: 1027 #endif 1028 break; 1029 default: 1030 free_addrselectpolicy(&policyhead); 1031 return hp; 1032 } 1033 1034 /* count the number of addrinfo elements for sorting. */ 1035 for (n = 0; hp->h_addr_list[n] != NULL; n++) 1036 ; 1037 1038 /* 1039 * If the number is small enough, we can skip the reordering process. 1040 */ 1041 if (n <= 1) 1042 return hp; 1043 1044 /* allocate a temporary array for sort and initialization of it. */ 1045 if ((aio = malloc(sizeof(*aio) * n)) == NULL) 1046 return hp; /* give up reordering */ 1047 memset(aio, 0, sizeof(*aio) * n); 1048 1049 /* retrieve address selection policy from the kernel */ 1050 TAILQ_INIT(&policyhead); 1051 if (!get_addrselectpolicy(&policyhead)) { 1052 /* no policy is installed into kernel, we don't sort. */ 1053 free(aio); 1054 return hp; 1055 } 1056 1057 for (i = 0; i < n; i++) { 1058 ap = hp->h_addr_list[i]; 1059 aio[i].aio_h_addr = ap; 1060 sa = &aio[i].aio_sa; 1061 switch (hp->h_addrtype) { 1062 case AF_INET: 1063 sa->sa_family = AF_INET; 1064 sa->sa_len = sizeof(struct sockaddr_in); 1065 memcpy(&((struct sockaddr_in *)sa)->sin_addr, ap, 1066 sizeof(struct in_addr)); 1067 break; 1068 #ifdef INET6 1069 case AF_INET6: 1070 if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) { 1071 sa->sa_family = AF_INET; 1072 sa->sa_len = sizeof(struct sockaddr_in); 1073 memcpy(&((struct sockaddr_in *)sa)->sin_addr, 1074 &ap[12], sizeof(struct in_addr)); 1075 } else { 1076 sa->sa_family = AF_INET6; 1077 sa->sa_len = sizeof(struct sockaddr_in6); 1078 memcpy(&((struct sockaddr_in6 *)sa)->sin6_addr, 1079 ap, sizeof(struct in6_addr)); 1080 } 1081 break; 1082 #endif 1083 } 1084 aio[i].aio_dstscope = gai_addr2scopetype(sa); 1085 aio[i].aio_dstpolicy = match_addrselectpolicy(sa, &policyhead); 1086 set_source(&aio[i], &policyhead); 1087 } 1088 1089 /* perform sorting. */ 1090 qsort(aio, n, sizeof(*aio), comp_dst); 1091 1092 /* reorder the h_addr_list. */ 1093 for (i = 0; i < n; i++) 1094 hp->h_addr_list[i] = aio[i].aio_h_addr; 1095 1096 /* cleanup and return */ 1097 free(aio); 1098 free_addrselectpolicy(&policyhead); 1099 return hp; 1100 } 1101 1102 static int 1103 get_addrselectpolicy(struct policyhead *head) 1104 { 1105 #ifdef INET6 1106 int mib[] = { CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_ADDRCTLPOLICY }; 1107 size_t l; 1108 char *buf; 1109 struct in6_addrpolicy *pol, *ep; 1110 1111 if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &l, NULL, 0) < 0) 1112 return (0); 1113 if ((buf = malloc(l)) == NULL) 1114 return (0); 1115 if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), buf, &l, NULL, 0) < 0) { 1116 free(buf); 1117 return (0); 1118 } 1119 1120 ep = (struct in6_addrpolicy *)(buf + l); 1121 for (pol = (struct in6_addrpolicy *)buf; pol + 1 <= ep; pol++) { 1122 struct policyqueue *new; 1123 1124 if ((new = malloc(sizeof(*new))) == NULL) { 1125 free_addrselectpolicy(head); /* make the list empty */ 1126 break; 1127 } 1128 new->pc_policy = *pol; 1129 TAILQ_INSERT_TAIL(head, new, pc_entry); 1130 } 1131 1132 free(buf); 1133 return (1); 1134 #else 1135 return (0); 1136 #endif 1137 } 1138 1139 static void 1140 free_addrselectpolicy(struct policyhead *head) 1141 { 1142 struct policyqueue *ent, *nent; 1143 1144 for (ent = TAILQ_FIRST(head); ent; ent = nent) { 1145 nent = TAILQ_NEXT(ent, pc_entry); 1146 TAILQ_REMOVE(head, ent, pc_entry); 1147 free(ent); 1148 } 1149 } 1150 1151 static struct policyqueue * 1152 match_addrselectpolicy(struct sockaddr *addr, struct policyhead *head) 1153 { 1154 #ifdef INET6 1155 struct policyqueue *ent, *bestent = NULL; 1156 struct in6_addrpolicy *pol; 1157 int matchlen, bestmatchlen = -1; 1158 u_char *mp, *ep, *k, *p, m; 1159 struct sockaddr_in6 key; 1160 1161 switch(addr->sa_family) { 1162 case AF_INET6: 1163 key = *(struct sockaddr_in6 *)addr; 1164 break; 1165 case AF_INET: 1166 /* convert the address into IPv4-mapped IPv6 address. */ 1167 memset(&key, 0, sizeof(key)); 1168 key.sin6_family = AF_INET6; 1169 key.sin6_len = sizeof(key); 1170 key.sin6_addr.s6_addr[10] = 0xff; 1171 key.sin6_addr.s6_addr[11] = 0xff; 1172 memcpy(&key.sin6_addr.s6_addr[12], 1173 &((struct sockaddr_in *)addr)->sin_addr, 4); 1174 break; 1175 default: 1176 return(NULL); 1177 } 1178 1179 for (ent = TAILQ_FIRST(head); ent; ent = TAILQ_NEXT(ent, pc_entry)) { 1180 pol = &ent->pc_policy; 1181 matchlen = 0; 1182 1183 mp = (u_char *)&pol->addrmask.sin6_addr; 1184 ep = mp + 16; /* XXX: scope field? */ 1185 k = (u_char *)&key.sin6_addr; 1186 p = (u_char *)&pol->addr.sin6_addr; 1187 for (; mp < ep && *mp; mp++, k++, p++) { 1188 m = *mp; 1189 if ((*k & m) != *p) 1190 goto next; /* not match */ 1191 if (m == 0xff) /* short cut for a typical case */ 1192 matchlen += 8; 1193 else { 1194 while (m >= 0x80) { 1195 matchlen++; 1196 m <<= 1; 1197 } 1198 } 1199 } 1200 1201 /* matched. check if this is better than the current best. */ 1202 if (matchlen > bestmatchlen) { 1203 bestent = ent; 1204 bestmatchlen = matchlen; 1205 } 1206 1207 next: 1208 continue; 1209 } 1210 1211 return(bestent); 1212 #else 1213 return(NULL); 1214 #endif 1215 1216 } 1217 1218 static void 1219 set_source(struct hp_order *aio, struct policyhead *ph) 1220 { 1221 struct sockaddr_storage ss = aio->aio_un.aiou_ss; 1222 socklen_t srclen; 1223 int s; 1224 1225 /* set unspec ("no source is available"), just in case */ 1226 aio->aio_srcsa.sa_family = AF_UNSPEC; 1227 aio->aio_srcscope = -1; 1228 1229 switch(ss.ss_family) { 1230 case AF_INET: 1231 ((struct sockaddr_in *)&ss)->sin_port = htons(1); 1232 break; 1233 #ifdef INET6 1234 case AF_INET6: 1235 ((struct sockaddr_in6 *)&ss)->sin6_port = htons(1); 1236 break; 1237 #endif 1238 default: /* ignore unsupported AFs explicitly */ 1239 return; 1240 } 1241 1242 /* open a socket to get the source address for the given dst */ 1243 if ((s = _socket(ss.ss_family, SOCK_DGRAM, IPPROTO_UDP)) < 0) 1244 return; /* give up */ 1245 if (_connect(s, (struct sockaddr *)&ss, ss.ss_len) < 0) 1246 goto cleanup; 1247 srclen = ss.ss_len; 1248 if (_getsockname(s, &aio->aio_srcsa, &srclen) < 0) { 1249 aio->aio_srcsa.sa_family = AF_UNSPEC; 1250 goto cleanup; 1251 } 1252 aio->aio_srcscope = gai_addr2scopetype(&aio->aio_srcsa); 1253 aio->aio_srcpolicy = match_addrselectpolicy(&aio->aio_srcsa, ph); 1254 aio->aio_matchlen = matchlen(&aio->aio_srcsa, (struct sockaddr *)&ss); 1255 #ifdef INET6 1256 if (ss.ss_family == AF_INET6) { 1257 struct in6_ifreq ifr6; 1258 u_int32_t flags6; 1259 1260 /* XXX: interface name should not be hardcoded */ 1261 strncpy(ifr6.ifr_name, "lo0", sizeof(ifr6.ifr_name)); 1262 memset(&ifr6, 0, sizeof(ifr6)); 1263 memcpy(&ifr6.ifr_addr, &ss, ss.ss_len); 1264 if (_ioctl(s, SIOCGIFAFLAG_IN6, &ifr6) == 0) { 1265 flags6 = ifr6.ifr_ifru.ifru_flags6; 1266 if ((flags6 & IN6_IFF_DEPRECATED)) 1267 aio->aio_srcflag |= AIO_SRCFLAG_DEPRECATED; 1268 } 1269 } 1270 #endif 1271 1272 cleanup: 1273 _close(s); 1274 return; 1275 } 1276 1277 static int 1278 matchlen(struct sockaddr *src, struct sockaddr *dst) 1279 { 1280 int match = 0; 1281 u_char *s, *d; 1282 u_char *lim, r; 1283 int addrlen; 1284 1285 switch (src->sa_family) { 1286 #ifdef INET6 1287 case AF_INET6: 1288 s = (u_char *)&((struct sockaddr_in6 *)src)->sin6_addr; 1289 d = (u_char *)&((struct sockaddr_in6 *)dst)->sin6_addr; 1290 addrlen = sizeof(struct in6_addr); 1291 lim = s + addrlen; 1292 break; 1293 #endif 1294 case AF_INET: 1295 s = (u_char *)&((struct sockaddr_in *)src)->sin_addr; 1296 d = (u_char *)&((struct sockaddr_in *)dst)->sin_addr; 1297 addrlen = sizeof(struct in_addr); 1298 lim = s + addrlen; 1299 break; 1300 default: 1301 return(0); 1302 } 1303 1304 while (s < lim) 1305 if ((r = (*d++ ^ *s++)) != 0) { 1306 while (r < addrlen * 8) { 1307 match++; 1308 r <<= 1; 1309 } 1310 break; 1311 } else 1312 match += 8; 1313 return(match); 1314 } 1315 1316 static int 1317 comp_dst(const void *arg1, const void *arg2) 1318 { 1319 const struct hp_order *dst1 = arg1, *dst2 = arg2; 1320 1321 /* 1322 * Rule 1: Avoid unusable destinations. 1323 * XXX: we currently do not consider if an appropriate route exists. 1324 */ 1325 if (dst1->aio_srcsa.sa_family != AF_UNSPEC && 1326 dst2->aio_srcsa.sa_family == AF_UNSPEC) { 1327 return(-1); 1328 } 1329 if (dst1->aio_srcsa.sa_family == AF_UNSPEC && 1330 dst2->aio_srcsa.sa_family != AF_UNSPEC) { 1331 return(1); 1332 } 1333 1334 /* Rule 2: Prefer matching scope. */ 1335 if (dst1->aio_dstscope == dst1->aio_srcscope && 1336 dst2->aio_dstscope != dst2->aio_srcscope) { 1337 return(-1); 1338 } 1339 if (dst1->aio_dstscope != dst1->aio_srcscope && 1340 dst2->aio_dstscope == dst2->aio_srcscope) { 1341 return(1); 1342 } 1343 1344 /* Rule 3: Avoid deprecated addresses. */ 1345 if (dst1->aio_srcsa.sa_family != AF_UNSPEC && 1346 dst2->aio_srcsa.sa_family != AF_UNSPEC) { 1347 if (!(dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) && 1348 (dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) { 1349 return(-1); 1350 } 1351 if ((dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) && 1352 !(dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) { 1353 return(1); 1354 } 1355 } 1356 1357 /* Rule 4: Prefer home addresses. */ 1358 /* XXX: not implemented yet */ 1359 1360 /* Rule 5: Prefer matching label. */ 1361 #ifdef INET6 1362 if (dst1->aio_srcpolicy && dst1->aio_dstpolicy && 1363 dst1->aio_srcpolicy->pc_policy.label == 1364 dst1->aio_dstpolicy->pc_policy.label && 1365 (dst2->aio_srcpolicy == NULL || dst2->aio_dstpolicy == NULL || 1366 dst2->aio_srcpolicy->pc_policy.label != 1367 dst2->aio_dstpolicy->pc_policy.label)) { 1368 return(-1); 1369 } 1370 if (dst2->aio_srcpolicy && dst2->aio_dstpolicy && 1371 dst2->aio_srcpolicy->pc_policy.label == 1372 dst2->aio_dstpolicy->pc_policy.label && 1373 (dst1->aio_srcpolicy == NULL || dst1->aio_dstpolicy == NULL || 1374 dst1->aio_srcpolicy->pc_policy.label != 1375 dst1->aio_dstpolicy->pc_policy.label)) { 1376 return(1); 1377 } 1378 #endif 1379 1380 /* Rule 6: Prefer higher precedence. */ 1381 #ifdef INET6 1382 if (dst1->aio_dstpolicy && 1383 (dst2->aio_dstpolicy == NULL || 1384 dst1->aio_dstpolicy->pc_policy.preced > 1385 dst2->aio_dstpolicy->pc_policy.preced)) { 1386 return(-1); 1387 } 1388 if (dst2->aio_dstpolicy && 1389 (dst1->aio_dstpolicy == NULL || 1390 dst2->aio_dstpolicy->pc_policy.preced > 1391 dst1->aio_dstpolicy->pc_policy.preced)) { 1392 return(1); 1393 } 1394 #endif 1395 1396 /* Rule 7: Prefer native transport. */ 1397 /* XXX: not implemented yet */ 1398 1399 /* Rule 8: Prefer smaller scope. */ 1400 if (dst1->aio_dstscope >= 0 && 1401 dst1->aio_dstscope < dst2->aio_dstscope) { 1402 return(-1); 1403 } 1404 if (dst2->aio_dstscope >= 0 && 1405 dst2->aio_dstscope < dst1->aio_dstscope) { 1406 return(1); 1407 } 1408 1409 /* 1410 * Rule 9: Use longest matching prefix. 1411 * We compare the match length in a same AF only. 1412 */ 1413 if (dst1->aio_sa.sa_family == dst2->aio_sa.sa_family) { 1414 if (dst1->aio_matchlen > dst2->aio_matchlen) { 1415 return(-1); 1416 } 1417 if (dst1->aio_matchlen < dst2->aio_matchlen) { 1418 return(1); 1419 } 1420 } 1421 1422 /* Rule 10: Otherwise, leave the order unchanged. */ 1423 return(-1); 1424 } 1425 1426 /* 1427 * Copy from scope.c. 1428 * XXX: we should standardize the functions and link them as standard 1429 * library. 1430 */ 1431 static int 1432 gai_addr2scopetype(struct sockaddr *sa) 1433 { 1434 #ifdef INET6 1435 struct sockaddr_in6 *sa6; 1436 #endif 1437 struct sockaddr_in *sa4; 1438 1439 switch(sa->sa_family) { 1440 #ifdef INET6 1441 case AF_INET6: 1442 sa6 = (struct sockaddr_in6 *)sa; 1443 if (IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) { 1444 /* just use the scope field of the multicast address */ 1445 return(sa6->sin6_addr.s6_addr[2] & 0x0f); 1446 } 1447 /* 1448 * Unicast addresses: map scope type to corresponding scope 1449 * value defined for multcast addresses. 1450 * XXX: hardcoded scope type values are bad... 1451 */ 1452 if (IN6_IS_ADDR_LOOPBACK(&sa6->sin6_addr)) 1453 return(1); /* node local scope */ 1454 if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr)) 1455 return(2); /* link-local scope */ 1456 if (IN6_IS_ADDR_SITELOCAL(&sa6->sin6_addr)) 1457 return(5); /* site-local scope */ 1458 return(14); /* global scope */ 1459 break; 1460 #endif 1461 case AF_INET: 1462 /* 1463 * IPv4 pseudo scoping according to RFC 3484. 1464 */ 1465 sa4 = (struct sockaddr_in *)sa; 1466 /* IPv4 autoconfiguration addresses have link-local scope. */ 1467 if (((u_char *)&sa4->sin_addr)[0] == 169 && 1468 ((u_char *)&sa4->sin_addr)[1] == 254) 1469 return(2); 1470 /* Private addresses have site-local scope. */ 1471 if (((u_char *)&sa4->sin_addr)[0] == 10 || 1472 (((u_char *)&sa4->sin_addr)[0] == 172 && 1473 (((u_char *)&sa4->sin_addr)[1] & 0xf0) == 16) || 1474 (((u_char *)&sa4->sin_addr)[0] == 192 && 1475 ((u_char *)&sa4->sin_addr)[1] == 168)) 1476 return(14); /* XXX: It should be 5 unless NAT */ 1477 /* Loopback addresses have link-local scope. */ 1478 if (((u_char *)&sa4->sin_addr)[0] == 127) 1479 return(2); 1480 return(14); 1481 break; 1482 default: 1483 errno = EAFNOSUPPORT; /* is this a good error? */ 1484 return(-1); 1485 } 1486 } 1487 1488 /* 1489 * FILES (/etc/hosts) 1490 */ 1491 1492 static FILE * 1493 _files_open(int *errp) 1494 { 1495 FILE *fp; 1496 fp = fopen(_PATH_HOSTS, "r"); 1497 if (fp == NULL) 1498 *errp = NO_RECOVERY; 1499 return fp; 1500 } 1501 1502 static int 1503 _files_ghbyname(void *rval, void *cb_data, va_list ap) 1504 { 1505 const char *name; 1506 int af; 1507 int *errp; 1508 int match, nalias; 1509 char *p, *line, *addrstr, *cname; 1510 FILE *fp; 1511 struct hostent *rethp, *hp, hpbuf; 1512 char *aliases[MAXALIASES + 1], *addrs[2]; 1513 union inx_addr addrbuf; 1514 char buf[BUFSIZ]; 1515 1516 name = va_arg(ap, const char *); 1517 af = va_arg(ap, int); 1518 errp = va_arg(ap, int *); 1519 1520 *(struct hostent **)rval = NULL; 1521 1522 if ((fp = _files_open(errp)) == NULL) 1523 return NS_UNAVAIL; 1524 rethp = hp = NULL; 1525 1526 while (fgets(buf, sizeof(buf), fp)) { 1527 line = buf; 1528 if ((addrstr = _hgetword(&line)) == NULL 1529 || (cname = _hgetword(&line)) == NULL) 1530 continue; 1531 match = (strcasecmp(cname, name) == 0); 1532 nalias = 0; 1533 while ((p = _hgetword(&line)) != NULL) { 1534 if (!match) 1535 match = (strcasecmp(p, name) == 0); 1536 if (nalias < MAXALIASES) 1537 aliases[nalias++] = p; 1538 } 1539 if (!match) 1540 continue; 1541 switch (af) { 1542 case AF_INET: 1543 if (inet_aton(addrstr, (struct in_addr *)&addrbuf) 1544 != 1) { 1545 *errp = NO_DATA; /* name found */ 1546 continue; 1547 } 1548 break; 1549 #ifdef INET6 1550 case AF_INET6: 1551 if (inet_pton(af, addrstr, &addrbuf) != 1) { 1552 *errp = NO_DATA; /* name found */ 1553 continue; 1554 } 1555 break; 1556 #endif 1557 } 1558 hp = &hpbuf; 1559 hp->h_name = cname; 1560 hp->h_aliases = aliases; 1561 aliases[nalias] = NULL; 1562 hp->h_addrtype = af; 1563 hp->h_length = ADDRLEN(af); 1564 hp->h_addr_list = addrs; 1565 addrs[0] = (char *)&addrbuf; 1566 addrs[1] = NULL; 1567 hp = _hpcopy(hp, errp); 1568 rethp = _hpmerge(rethp, hp, errp); 1569 } 1570 fclose(fp); 1571 *(struct hostent **)rval = rethp; 1572 return (rethp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 1573 } 1574 1575 static int 1576 _files_ghbyaddr(void *rval, void *cb_data, va_list ap) 1577 { 1578 const void *addr; 1579 int addrlen; 1580 int af; 1581 int *errp; 1582 int nalias; 1583 char *p, *line; 1584 FILE *fp; 1585 struct hostent *hp, hpbuf; 1586 char *aliases[MAXALIASES + 1], *addrs[2]; 1587 union inx_addr addrbuf; 1588 char buf[BUFSIZ]; 1589 1590 addr = va_arg(ap, const void *); 1591 addrlen = va_arg(ap, int); 1592 af = va_arg(ap, int); 1593 errp = va_arg(ap, int *); 1594 1595 *(struct hostent**)rval = NULL; 1596 1597 if ((fp = _files_open(errp)) == NULL) 1598 return NS_UNAVAIL; 1599 hp = NULL; 1600 while (fgets(buf, sizeof(buf), fp)) { 1601 line = buf; 1602 if ((p = _hgetword(&line)) == NULL 1603 || (af == AF_INET 1604 ? inet_aton(p, (struct in_addr *)&addrbuf) 1605 : inet_pton(af, p, &addrbuf)) != 1 1606 || memcmp(addr, &addrbuf, addrlen) != 0 1607 || (p = _hgetword(&line)) == NULL) 1608 continue; 1609 hp = &hpbuf; 1610 hp->h_name = p; 1611 hp->h_aliases = aliases; 1612 nalias = 0; 1613 while ((p = _hgetword(&line)) != NULL) { 1614 if (nalias < MAXALIASES) 1615 aliases[nalias++] = p; 1616 } 1617 aliases[nalias] = NULL; 1618 hp->h_addrtype = af; 1619 hp->h_length = addrlen; 1620 hp->h_addr_list = addrs; 1621 addrs[0] = (char *)&addrbuf; 1622 addrs[1] = NULL; 1623 hp = _hpcopy(hp, errp); 1624 break; 1625 } 1626 fclose(fp); 1627 *(struct hostent **)rval = hp; 1628 return (hp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 1629 } 1630 1631 #ifdef YP 1632 /* 1633 * NIS 1634 * 1635 * XXX actually a hack. 1636 */ 1637 static int 1638 _nis_ghbyname(void *rval, void *cb_data, va_list ap) 1639 { 1640 const char *name; 1641 int af; 1642 int *errp; 1643 struct hostent *hp = NULL; 1644 1645 name = va_arg(ap, const char *); 1646 af = va_arg(ap, int); 1647 errp = va_arg(ap, int *); 1648 1649 hp = _gethostbynisname(name, af); 1650 if (hp != NULL) 1651 hp = _hpcopy(hp, errp); 1652 1653 *(struct hostent **)rval = hp; 1654 return (hp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 1655 } 1656 1657 static int 1658 _nis_ghbyaddr(void *rval, void *cb_data, va_list ap) 1659 { 1660 const void *addr; 1661 int addrlen; 1662 int af; 1663 int *errp; 1664 struct hostent *hp = NULL; 1665 1666 addr = va_arg(ap, const void *); 1667 addrlen = va_arg(ap, int); 1668 af = va_arg(ap, int); 1669 1670 hp = _gethostbynisaddr(addr, addrlen, af); 1671 if (hp != NULL) 1672 hp = _hpcopy(hp, errp); 1673 *(struct hostent **)rval = hp; 1674 return (hp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 1675 } 1676 #endif 1677 1678 #define MAXPACKET (64*1024) 1679 1680 typedef union { 1681 HEADER hdr; 1682 u_char buf[MAXPACKET]; 1683 } querybuf; 1684 1685 static struct hostent *getanswer(const querybuf *, int, const char *, int, 1686 struct hostent *, int *); 1687 1688 /* 1689 * we don't need to take care about sorting, nor IPv4 mapped address here. 1690 */ 1691 static struct hostent * 1692 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype, 1693 struct hostent *template, int *errp) 1694 { 1695 const HEADER *hp; 1696 const u_char *cp; 1697 int n; 1698 const u_char *eom, *erdata; 1699 char *bp, *ep, **ap, **hap; 1700 int type, class, ancount, qdcount; 1701 int haveanswer, had_error; 1702 char tbuf[MAXDNAME]; 1703 const char *tname; 1704 int (*name_ok)(const char *); 1705 static char *h_addr_ptrs[MAXADDRS + 1]; 1706 static char *host_aliases[MAXALIASES]; 1707 static char hostbuf[8*1024]; 1708 1709 #define BOUNDED_INCR(x) \ 1710 do { \ 1711 cp += x; \ 1712 if (cp > eom) { \ 1713 *errp = NO_RECOVERY; \ 1714 return (NULL); \ 1715 } \ 1716 } while (0) 1717 1718 #define BOUNDS_CHECK(ptr, count) \ 1719 do { \ 1720 if ((ptr) + (count) > eom) { \ 1721 *errp = NO_RECOVERY; \ 1722 return (NULL); \ 1723 } \ 1724 } while (0) 1725 1726 /* XXX do {} while (0) cannot be put here */ 1727 #define DNS_ASSERT(x) \ 1728 { \ 1729 if (!(x)) { \ 1730 cp += n; \ 1731 continue; \ 1732 } \ 1733 } 1734 1735 /* XXX do {} while (0) cannot be put here */ 1736 #define DNS_FATAL(x) \ 1737 { \ 1738 if (!(x)) { \ 1739 had_error++; \ 1740 continue; \ 1741 } \ 1742 } 1743 1744 tname = qname; 1745 template->h_name = NULL; 1746 eom = answer->buf + anslen; 1747 switch (qtype) { 1748 case T_A: 1749 case T_AAAA: 1750 name_ok = res_hnok; 1751 break; 1752 case T_PTR: 1753 name_ok = res_dnok; 1754 break; 1755 default: 1756 return (NULL); /* XXX should be abort(); */ 1757 } 1758 /* 1759 * find first satisfactory answer 1760 */ 1761 hp = &answer->hdr; 1762 ancount = ntohs(hp->ancount); 1763 qdcount = ntohs(hp->qdcount); 1764 bp = hostbuf; 1765 ep = hostbuf + sizeof hostbuf; 1766 cp = answer->buf; 1767 BOUNDED_INCR(HFIXEDSZ); 1768 if (qdcount != 1) { 1769 *errp = NO_RECOVERY; 1770 return (NULL); 1771 } 1772 n = dn_expand(answer->buf, eom, cp, bp, ep - bp); 1773 if ((n < 0) || !(*name_ok)(bp)) { 1774 *errp = NO_RECOVERY; 1775 return (NULL); 1776 } 1777 BOUNDED_INCR(n + QFIXEDSZ); 1778 if (qtype == T_A || qtype == T_AAAA) { 1779 /* res_send() has already verified that the query name is the 1780 * same as the one we sent; this just gets the expanded name 1781 * (i.e., with the succeeding search-domain tacked on). 1782 */ 1783 n = strlen(bp) + 1; /* for the \0 */ 1784 if (n >= MAXHOSTNAMELEN) { 1785 *errp = NO_RECOVERY; 1786 return (NULL); 1787 } 1788 template->h_name = bp; 1789 bp += n; 1790 /* The qname can be abbreviated, but h_name is now absolute. */ 1791 qname = template->h_name; 1792 } 1793 ap = host_aliases; 1794 *ap = NULL; 1795 template->h_aliases = host_aliases; 1796 hap = h_addr_ptrs; 1797 *hap = NULL; 1798 template->h_addr_list = h_addr_ptrs; 1799 haveanswer = 0; 1800 had_error = 0; 1801 while (ancount-- > 0 && cp < eom && !had_error) { 1802 n = dn_expand(answer->buf, eom, cp, bp, ep - bp); 1803 DNS_FATAL(n >= 0); 1804 DNS_FATAL((*name_ok)(bp)); 1805 cp += n; /* name */ 1806 BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ); 1807 type = _getshort(cp); 1808 cp += INT16SZ; /* type */ 1809 class = _getshort(cp); 1810 cp += INT16SZ + INT32SZ; /* class, TTL */ 1811 n = _getshort(cp); 1812 cp += INT16SZ; /* len */ 1813 BOUNDS_CHECK(cp, n); 1814 erdata = cp + n; 1815 DNS_ASSERT(class == C_IN); 1816 if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) { 1817 if (ap >= &host_aliases[MAXALIASES-1]) 1818 continue; 1819 n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf); 1820 DNS_FATAL(n >= 0); 1821 DNS_FATAL((*name_ok)(tbuf)); 1822 cp += n; 1823 if (cp != erdata) { 1824 *errp = NO_RECOVERY; 1825 return (NULL); 1826 } 1827 /* Store alias. */ 1828 *ap++ = bp; 1829 n = strlen(bp) + 1; /* for the \0 */ 1830 DNS_FATAL(n < MAXHOSTNAMELEN); 1831 bp += n; 1832 /* Get canonical name. */ 1833 n = strlen(tbuf) + 1; /* for the \0 */ 1834 DNS_FATAL(n <= ep - bp); 1835 DNS_FATAL(n < MAXHOSTNAMELEN); 1836 strcpy(bp, tbuf); 1837 template->h_name = bp; 1838 bp += n; 1839 continue; 1840 } 1841 if (qtype == T_PTR && type == T_CNAME) { 1842 n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf); 1843 if (n < 0 || !res_dnok(tbuf)) { 1844 had_error++; 1845 continue; 1846 } 1847 cp += n; 1848 if (cp != erdata) { 1849 *errp = NO_RECOVERY; 1850 return (NULL); 1851 } 1852 /* Get canonical name. */ 1853 n = strlen(tbuf) + 1; /* for the \0 */ 1854 if (n > ep - bp || n >= MAXHOSTNAMELEN) { 1855 had_error++; 1856 continue; 1857 } 1858 strcpy(bp, tbuf); 1859 tname = bp; 1860 bp += n; 1861 continue; 1862 } 1863 DNS_ASSERT(type == qtype); 1864 switch (type) { 1865 case T_PTR: 1866 DNS_ASSERT(strcasecmp(tname, bp) == 0); 1867 n = dn_expand(answer->buf, eom, cp, bp, ep - bp); 1868 DNS_FATAL(n >= 0); 1869 DNS_FATAL(res_hnok(bp)); 1870 #if MULTI_PTRS_ARE_ALIASES 1871 cp += n; 1872 if (cp != erdata) { 1873 *errp = NO_RECOVERY; 1874 return (NULL); 1875 } 1876 if (!haveanswer) 1877 template->h_name = bp; 1878 else if (ap < &host_aliases[MAXALIASES-1]) 1879 *ap++ = bp; 1880 else 1881 n = -1; 1882 if (n != -1) { 1883 n = strlen(bp) + 1; /* for the \0 */ 1884 if (n >= MAXHOSTNAMELEN) { 1885 had_error++; 1886 break; 1887 } 1888 bp += n; 1889 } 1890 break; 1891 #else 1892 template->h_name = bp; 1893 *errp = NETDB_SUCCESS; 1894 return (template); 1895 #endif 1896 case T_A: 1897 case T_AAAA: 1898 DNS_ASSERT(strcasecmp(template->h_name, bp) == 0); 1899 DNS_ASSERT(n == template->h_length); 1900 if (!haveanswer) { 1901 int nn; 1902 1903 template->h_name = bp; 1904 nn = strlen(bp) + 1; /* for the \0 */ 1905 bp += nn; 1906 } 1907 bp = (char *)ALIGN(bp); 1908 1909 DNS_FATAL(bp + n < ep); 1910 DNS_ASSERT(hap < &h_addr_ptrs[MAXADDRS-1]); 1911 #ifdef FILTER_V4MAPPED 1912 if (type == T_AAAA) { 1913 struct in6_addr in6; 1914 memcpy(&in6, cp, sizeof(in6)); 1915 DNS_ASSERT(IN6_IS_ADDR_V4MAPPED(&in6) == 0); 1916 } 1917 #endif 1918 bcopy(cp, *hap++ = bp, n); 1919 bp += n; 1920 cp += n; 1921 if (cp != erdata) { 1922 *errp = NO_RECOVERY; 1923 return (NULL); 1924 } 1925 break; 1926 default: 1927 abort(); 1928 } 1929 if (!had_error) 1930 haveanswer++; 1931 } 1932 if (haveanswer) { 1933 *ap = NULL; 1934 *hap = NULL; 1935 if (!template->h_name) { 1936 n = strlen(qname) + 1; /* for the \0 */ 1937 if (n > ep - bp || n >= MAXHOSTNAMELEN) 1938 goto no_recovery; 1939 strcpy(bp, qname); 1940 template->h_name = bp; 1941 bp += n; 1942 } 1943 *errp = NETDB_SUCCESS; 1944 return (template); 1945 } 1946 no_recovery: 1947 *errp = NO_RECOVERY; 1948 return (NULL); 1949 1950 #undef BOUNDED_INCR 1951 #undef BOUNDS_CHECK 1952 #undef DNS_ASSERT 1953 #undef DNS_FATAL 1954 } 1955 1956 static int 1957 _dns_ghbyname(void *rval, void *cb_data, va_list ap) 1958 { 1959 const char *name; 1960 int af; 1961 int *errp; 1962 int n; 1963 struct hostent *hp; 1964 int qtype; 1965 struct hostent hbuf; 1966 querybuf *buf; 1967 res_state statp; 1968 1969 name = va_arg(ap, const char *); 1970 af = va_arg(ap, int); 1971 errp = va_arg(ap, int *); 1972 1973 statp = __res_state(); 1974 1975 memset(&hbuf, 0, sizeof(hbuf)); 1976 hbuf.h_addrtype = af; 1977 hbuf.h_length = ADDRLEN(af); 1978 1979 switch (af) { 1980 #ifdef INET6 1981 case AF_INET6: 1982 qtype = T_AAAA; 1983 break; 1984 #endif 1985 case AF_INET: 1986 qtype = T_A; 1987 break; 1988 default: 1989 *errp = NO_RECOVERY; 1990 return NS_NOTFOUND; 1991 } 1992 buf = malloc(sizeof(*buf)); 1993 if (buf == NULL) { 1994 *errp = NETDB_INTERNAL; 1995 return NS_UNAVAIL; 1996 } 1997 n = res_nsearch(statp, name, C_IN, qtype, buf->buf, sizeof(buf->buf)); 1998 if (n < 0) { 1999 free(buf); 2000 *errp = statp->res_h_errno; 2001 return NS_UNAVAIL; 2002 } 2003 hp = getanswer(buf, n, name, qtype, &hbuf, errp); 2004 free(buf); 2005 if (!hp) { 2006 *errp = NO_RECOVERY; 2007 return NS_NOTFOUND; 2008 } 2009 *(struct hostent **)rval = _hpcopy(&hbuf, errp); 2010 if (*(struct hostent **)rval != NULL) 2011 return NS_SUCCESS; 2012 else if (*errp == TRY_AGAIN) 2013 return NS_TRYAGAIN; 2014 else 2015 return NS_NOTFOUND; 2016 } 2017 2018 static int 2019 _dns_ghbyaddr(void *rval, void *cb_data, va_list ap) 2020 { 2021 const void *addr; 2022 int addrlen; 2023 int af; 2024 int *errp; 2025 int n; 2026 int err; 2027 struct hostent *hp; 2028 u_char c, *cp; 2029 char *bp; 2030 struct hostent hbuf; 2031 #ifdef INET6 2032 static const char hex[] = "0123456789abcdef"; 2033 #endif 2034 querybuf *buf; 2035 char qbuf[MAXDNAME+1]; 2036 char *hlist[2]; 2037 char *tld6[] = { "ip6.arpa", NULL }; 2038 char *tld4[] = { "in-addr.arpa", NULL }; 2039 char **tld; 2040 res_state statp; 2041 2042 addr = va_arg(ap, const void *); 2043 addrlen = va_arg(ap, int); 2044 af = va_arg(ap, int); 2045 errp = va_arg(ap, int *); 2046 2047 *(struct hostent **)rval = NULL; 2048 2049 #ifdef INET6 2050 /* XXX */ 2051 if (af == AF_INET6 && IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)addr)) 2052 return NS_NOTFOUND; 2053 #endif 2054 2055 switch (af) { 2056 #ifdef INET6 2057 case AF_INET6: 2058 tld = tld6; 2059 break; 2060 #endif 2061 case AF_INET: 2062 tld = tld4; 2063 break; 2064 default: 2065 return NS_NOTFOUND; 2066 } 2067 2068 statp = __res_state(); 2069 if ((statp->options & RES_INIT) == 0) { 2070 if (res_ninit(statp) < 0) { 2071 *errp = NETDB_INTERNAL; 2072 return NS_UNAVAIL; 2073 } 2074 } 2075 memset(&hbuf, 0, sizeof(hbuf)); 2076 hbuf.h_name = NULL; 2077 hbuf.h_addrtype = af; 2078 hbuf.h_length = addrlen; 2079 2080 buf = malloc(sizeof(*buf)); 2081 if (buf == NULL) { 2082 *errp = NETDB_INTERNAL; 2083 return NS_UNAVAIL; 2084 } 2085 err = NS_SUCCESS; 2086 for (/* nothing */; *tld; tld++) { 2087 /* 2088 * XXX assumes that MAXDNAME is big enough - error checks 2089 * has been made by callers 2090 */ 2091 n = 0; 2092 bp = qbuf; 2093 cp = (u_char *)addr+addrlen-1; 2094 switch (af) { 2095 #ifdef INET6 2096 case AF_INET6: 2097 for (; n < addrlen; n++, cp--) { 2098 c = *cp; 2099 *bp++ = hex[c & 0xf]; 2100 *bp++ = '.'; 2101 *bp++ = hex[c >> 4]; 2102 *bp++ = '.'; 2103 } 2104 strcpy(bp, *tld); 2105 break; 2106 #endif 2107 case AF_INET: 2108 for (; n < addrlen; n++, cp--) { 2109 c = *cp; 2110 if (c >= 100) 2111 *bp++ = '0' + c / 100; 2112 if (c >= 10) 2113 *bp++ = '0' + (c % 100) / 10; 2114 *bp++ = '0' + c % 10; 2115 *bp++ = '.'; 2116 } 2117 strcpy(bp, *tld); 2118 break; 2119 } 2120 2121 n = res_nquery(statp, qbuf, C_IN, T_PTR, buf->buf, 2122 sizeof buf->buf); 2123 if (n < 0) { 2124 *errp = statp->res_h_errno; 2125 err = NS_UNAVAIL; 2126 continue; 2127 } else if (n > sizeof(buf->buf)) { 2128 #if 0 2129 errno = ERANGE; /* XXX is it OK to set errno here? */ 2130 #endif 2131 *errp = NETDB_INTERNAL; 2132 err = NS_UNAVAIL; 2133 continue; 2134 } 2135 hp = getanswer(buf, n, qbuf, T_PTR, &hbuf, errp); 2136 if (!hp) { 2137 err = NS_NOTFOUND; 2138 continue; 2139 } 2140 free(buf); 2141 hbuf.h_addrtype = af; 2142 hbuf.h_length = addrlen; 2143 hbuf.h_addr_list = hlist; 2144 hlist[0] = (char *)addr; 2145 hlist[1] = NULL; 2146 *(struct hostent **)rval = _hpcopy(&hbuf, errp); 2147 return NS_SUCCESS; 2148 } 2149 free(buf); 2150 return err; 2151 } 2152 2153 static void 2154 _dns_shent(int stayopen) 2155 { 2156 res_state statp; 2157 2158 statp = __res_state(); 2159 if ((statp->options & RES_INIT) == 0) { 2160 if (res_ninit(statp) < 0) 2161 return; 2162 } 2163 if (stayopen) 2164 statp->options |= RES_STAYOPEN | RES_USEVC; 2165 } 2166 2167 static void 2168 _dns_ehent(void) 2169 { 2170 res_state statp; 2171 2172 statp = __res_state(); 2173 statp->options &= ~(RES_STAYOPEN | RES_USEVC); 2174 res_nclose(statp); 2175 } 2176 2177 #ifdef ICMPNL 2178 2179 /* 2180 * experimental: 2181 * draft-ietf-ipngwg-icmp-namelookups-02.txt 2182 * ifindex is assumed to be encoded in addr. 2183 */ 2184 #include <sys/uio.h> 2185 #include <netinet/ip6.h> 2186 #include <netinet/icmp6.h> 2187 2188 struct _icmp_host_cache { 2189 struct _icmp_host_cache *hc_next; 2190 int hc_ifindex; 2191 struct in6_addr hc_addr; 2192 char *hc_name; 2193 }; 2194 2195 static char * 2196 _icmp_fqdn_query(const struct in6_addr *addr, int ifindex) 2197 { 2198 int s; 2199 struct icmp6_filter filter; 2200 struct msghdr msg; 2201 struct cmsghdr *cmsg; 2202 struct in6_pktinfo *pkt; 2203 char cbuf[256]; 2204 char buf[1024]; 2205 int cc; 2206 struct icmp6_fqdn_query *fq; 2207 struct icmp6_fqdn_reply *fr; 2208 struct _icmp_host_cache *hc; 2209 struct sockaddr_in6 sin6; 2210 struct iovec iov; 2211 fd_set s_fds, fds; 2212 struct timeval tout; 2213 int len; 2214 char *name; 2215 static struct _icmp_host_cache *hc_head; 2216 2217 THREAD_LOCK(); 2218 for (hc = hc_head; hc; hc = hc->hc_next) { 2219 if (hc->hc_ifindex == ifindex 2220 && IN6_ARE_ADDR_EQUAL(&hc->hc_addr, addr)) { 2221 THREAD_UNLOCK(); 2222 return hc->hc_name; /* XXX: never freed */ 2223 } 2224 } 2225 THREAD_UNLOCK(); 2226 2227 ICMP6_FILTER_SETBLOCKALL(&filter); 2228 ICMP6_FILTER_SETPASS(ICMP6_FQDN_REPLY, &filter); 2229 2230 FD_ZERO(&s_fds); 2231 tout.tv_sec = 0; 2232 tout.tv_usec = 200000; /*XXX: 200ms*/ 2233 2234 fq = (struct icmp6_fqdn_query *)buf; 2235 fq->icmp6_fqdn_type = ICMP6_FQDN_QUERY; 2236 fq->icmp6_fqdn_code = 0; 2237 fq->icmp6_fqdn_cksum = 0; 2238 fq->icmp6_fqdn_id = (u_short)getpid(); 2239 fq->icmp6_fqdn_unused = 0; 2240 fq->icmp6_fqdn_cookie[0] = 0; 2241 fq->icmp6_fqdn_cookie[1] = 0; 2242 2243 memset(&sin6, 0, sizeof(sin6)); 2244 sin6.sin6_family = AF_INET6; 2245 sin6.sin6_addr = *addr; 2246 2247 memset(&msg, 0, sizeof(msg)); 2248 msg.msg_name = (caddr_t)&sin6; 2249 msg.msg_namelen = sizeof(sin6); 2250 msg.msg_iov = &iov; 2251 msg.msg_iovlen = 1; 2252 msg.msg_control = NULL; 2253 msg.msg_controllen = 0; 2254 iov.iov_base = (caddr_t)buf; 2255 iov.iov_len = sizeof(struct icmp6_fqdn_query); 2256 2257 if (ifindex) { 2258 msg.msg_control = cbuf; 2259 msg.msg_controllen = sizeof(cbuf); 2260 cmsg = CMSG_FIRSTHDR(&msg); 2261 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo)); 2262 cmsg->cmsg_level = IPPROTO_IPV6; 2263 cmsg->cmsg_type = IPV6_PKTINFO; 2264 pkt = (struct in6_pktinfo *)&cmsg[1]; 2265 memset(&pkt->ipi6_addr, 0, sizeof(struct in6_addr)); 2266 pkt->ipi6_ifindex = ifindex; 2267 cmsg = CMSG_NXTHDR(&msg, cmsg); 2268 msg.msg_controllen = (char *)cmsg - cbuf; 2269 } 2270 2271 if ((s = _socket(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0) 2272 return NULL; 2273 (void)_setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER, 2274 (char *)&filter, sizeof(filter)); 2275 cc = _sendmsg(s, &msg, 0); 2276 if (cc < 0) { 2277 _close(s); 2278 return NULL; 2279 } 2280 FD_SET(s, &s_fds); 2281 for (;;) { 2282 fds = s_fds; 2283 if (_select(s + 1, &fds, NULL, NULL, &tout) <= 0) { 2284 _close(s); 2285 return NULL; 2286 } 2287 len = sizeof(sin6); 2288 cc = _recvfrom(s, buf, sizeof(buf), 0, 2289 (struct sockaddr *)&sin6, &len); 2290 if (cc <= 0) { 2291 _close(s); 2292 return NULL; 2293 } 2294 if (cc < sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr)) 2295 continue; 2296 if (!IN6_ARE_ADDR_EQUAL(addr, &sin6.sin6_addr)) 2297 continue; 2298 fr = (struct icmp6_fqdn_reply *)(buf + sizeof(struct ip6_hdr)); 2299 if (fr->icmp6_fqdn_type == ICMP6_FQDN_REPLY) 2300 break; 2301 } 2302 _close(s); 2303 if (fr->icmp6_fqdn_cookie[1] != 0) { 2304 /* rfc1788 type */ 2305 name = buf + sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr) + 4; 2306 len = (buf + cc) - name; 2307 } else { 2308 len = fr->icmp6_fqdn_namelen; 2309 name = fr->icmp6_fqdn_name; 2310 } 2311 if (len <= 0) 2312 return NULL; 2313 name[len] = 0; 2314 2315 if ((hc = (struct _icmp_host_cache *)malloc(sizeof(*hc))) == NULL) 2316 return NULL; 2317 /* XXX: limit number of cached entries */ 2318 hc->hc_ifindex = ifindex; 2319 hc->hc_addr = *addr; 2320 hc->hc_name = strdup(name); 2321 THREAD_LOCK(); 2322 hc->hc_next = hc_head; 2323 hc_head = hc; 2324 THREAD_UNLOCK(); 2325 return hc->hc_name; 2326 } 2327 2328 static struct hostent * 2329 _icmp_ghbyaddr(const void *addr, int addrlen, int af, int *errp) 2330 { 2331 char *hname; 2332 int ifindex; 2333 struct in6_addr addr6; 2334 2335 if (af != AF_INET6) { 2336 /* 2337 * Note: rfc1788 defines Who Are You for IPv4, 2338 * but no one implements it. 2339 */ 2340 return NULL; 2341 } 2342 2343 memcpy(&addr6, addr, addrlen); 2344 ifindex = (addr6.s6_addr[2] << 8) | addr6.s6_addr[3]; 2345 addr6.s6_addr[2] = addr6.s6_addr[3] = 0; 2346 2347 if (!IN6_IS_ADDR_LINKLOCAL(&addr6)) 2348 return NULL; /*XXX*/ 2349 2350 if ((hname = _icmp_fqdn_query(&addr6, ifindex)) == NULL) 2351 return NULL; 2352 return _hpaddr(af, hname, &addr6, errp); 2353 } 2354 #endif /* ICMPNL */ 2355