1 /* 2 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the project nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* 31 * "#ifdef FAITH" part is local hack for supporting IPv4-v6 translator. 32 * 33 * Issues to be discussed: 34 * - Thread safe-ness must be checked. 35 * - Return values. There are nonstandard return values defined and used 36 * in the source code. This is because RFC2553 is silent about which error 37 * code must be returned for which situation. 38 * Note: 39 * - We use getipnodebyname() just for thread-safeness. There's no intent 40 * to let it do PF_UNSPEC (actually we never pass PF_UNSPEC to 41 * getipnodebyname(). 42 * - The code filters out AFs that are not supported by the kernel, 43 * when globbing NULL hostname (to loopback, or wildcard). Is it the right 44 * thing to do? What is the relationship with post-RFC2553 AI_ADDRCONFIG 45 * in ai_flags? 46 */ 47 48 #ifdef HAVE_CONFIG_H 49 #include <config.h> 50 #endif 51 52 #ifndef lint 53 static const char rcsid[] _U_ = 54 "@(#) $Header: /tcpdump/master/tcpdump/missing/getaddrinfo.c,v 1.13 2003/11/16 09:36:48 guy Exp $"; 55 #endif 56 57 #include <sys/types.h> 58 #include <sys/param.h> 59 #if 0 60 #include <sys/sysctl.h> 61 #endif 62 #include <sys/socket.h> 63 #include <net/if.h> 64 #include <netinet/in.h> 65 #include <arpa/inet.h> 66 #include <arpa/nameser.h> 67 #include <netdb.h> 68 #include <resolv.h> 69 #include <string.h> 70 #include <stdlib.h> 71 #include <stddef.h> 72 #include <ctype.h> 73 #include <unistd.h> 74 #include <stdio.h> 75 #include <errno.h> 76 77 #ifndef HAVE_U_INT32_T 78 #include "bittypes.h" 79 #endif 80 81 #ifndef HAVE_SOCKADDR_STORAGE 82 #include "sockstorage.h" 83 #endif 84 85 #ifdef NEED_ADDRINFO_H 86 #include "addrinfo.h" 87 #endif 88 89 #if defined(__KAME__) && defined(INET6) 90 # define FAITH 91 #endif 92 93 #define SUCCESS 0 94 #define ANY 0 95 #define YES 1 96 #define NO 0 97 98 #ifdef FAITH 99 static int translate = NO; 100 static struct in6_addr faith_prefix = IN6ADDR_ANY_INIT; 101 #endif 102 103 static const char in_addrany[] = { 0, 0, 0, 0 }; 104 static const char in6_addrany[] = { 105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 106 }; 107 static const char in_loopback[] = { 127, 0, 0, 1 }; 108 static const char in6_loopback[] = { 109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 110 }; 111 112 struct sockinet { 113 u_char si_len; 114 u_char si_family; 115 u_short si_port; 116 u_int32_t si_scope_id; 117 }; 118 119 static const struct afd { 120 int a_af; 121 int a_addrlen; 122 int a_socklen; 123 int a_off; 124 const char *a_addrany; 125 const char *a_loopback; 126 int a_scoped; 127 } afdl [] = { 128 #ifdef INET6 129 {PF_INET6, sizeof(struct in6_addr), 130 sizeof(struct sockaddr_in6), 131 offsetof(struct sockaddr_in6, sin6_addr), 132 in6_addrany, in6_loopback, 1}, 133 #endif 134 {PF_INET, sizeof(struct in_addr), 135 sizeof(struct sockaddr_in), 136 offsetof(struct sockaddr_in, sin_addr), 137 in_addrany, in_loopback, 0}, 138 {0, 0, 0, 0, NULL, NULL, 0}, 139 }; 140 141 struct explore { 142 int e_af; 143 int e_socktype; 144 int e_protocol; 145 const char *e_protostr; 146 int e_wild; 147 #define WILD_AF(ex) ((ex)->e_wild & 0x01) 148 #define WILD_SOCKTYPE(ex) ((ex)->e_wild & 0x02) 149 #define WILD_PROTOCOL(ex) ((ex)->e_wild & 0x04) 150 }; 151 152 static const struct explore explore[] = { 153 #if 0 154 { PF_LOCAL, 0, ANY, ANY, NULL, 0x01 }, 155 #endif 156 #ifdef INET6 157 { PF_INET6, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 }, 158 { PF_INET6, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 }, 159 { PF_INET6, SOCK_RAW, ANY, NULL, 0x05 }, 160 #endif 161 { PF_INET, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 }, 162 { PF_INET, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 }, 163 { PF_INET, SOCK_RAW, ANY, NULL, 0x05 }, 164 { -1, 0, 0, NULL, 0 }, 165 }; 166 167 #ifdef INET6 168 #define PTON_MAX 16 169 #else 170 #define PTON_MAX 4 171 #endif 172 173 174 static int str_isnumber (const char *); 175 static int explore_fqdn (const struct addrinfo *, const char *, 176 const char *, struct addrinfo **); 177 static int explore_null (const struct addrinfo *, const char *, 178 const char *, struct addrinfo **); 179 static int explore_numeric (const struct addrinfo *, const char *, 180 const char *, struct addrinfo **); 181 static int explore_numeric_scope (const struct addrinfo *, const char *, 182 const char *, struct addrinfo **); 183 static int get_name (const char *, const struct afd *, struct addrinfo **, 184 char *, const struct addrinfo *, const char *); 185 static int get_canonname (const struct addrinfo *, 186 struct addrinfo *, const char *); 187 static struct addrinfo *get_ai (const struct addrinfo *, 188 const struct afd *, const char *); 189 static int get_portmatch (const struct addrinfo *, const char *); 190 static int get_port (struct addrinfo *, const char *, int); 191 static const struct afd *find_afd (int); 192 193 static char *ai_errlist[] = { 194 "Success", 195 "Address family for hostname not supported", /* EAI_ADDRFAMILY */ 196 "Temporary failure in name resolution", /* EAI_AGAIN */ 197 "Invalid value for ai_flags", /* EAI_BADFLAGS */ 198 "Non-recoverable failure in name resolution", /* EAI_FAIL */ 199 "ai_family not supported", /* EAI_FAMILY */ 200 "Memory allocation failure", /* EAI_MEMORY */ 201 "No address associated with hostname", /* EAI_NODATA */ 202 "hostname nor servname provided, or not known", /* EAI_NONAME */ 203 "servname not supported for ai_socktype", /* EAI_SERVICE */ 204 "ai_socktype not supported", /* EAI_SOCKTYPE */ 205 "System error returned in errno", /* EAI_SYSTEM */ 206 "Invalid value for hints", /* EAI_BADHINTS */ 207 "Resolved protocol is unknown", /* EAI_PROTOCOL */ 208 "Unknown error", /* EAI_MAX */ 209 }; 210 211 /* XXX macros that make external reference is BAD. */ 212 213 #define GET_AI(ai, afd, addr) \ 214 do { \ 215 /* external reference: pai, error, and label free */ \ 216 (ai) = get_ai(pai, (afd), (addr)); \ 217 if ((ai) == NULL) { \ 218 error = EAI_MEMORY; \ 219 goto free; \ 220 } \ 221 } while (0) 222 223 #define GET_PORT(ai, serv) \ 224 do { \ 225 /* external reference: error and label free */ \ 226 error = get_port((ai), (serv), 0); \ 227 if (error != 0) \ 228 goto free; \ 229 } while (0) 230 231 #define GET_CANONNAME(ai, str) \ 232 do { \ 233 /* external reference: pai, error and label free */ \ 234 error = get_canonname(pai, (ai), (str)); \ 235 if (error != 0) \ 236 goto free; \ 237 } while (0) 238 239 #define ERR(err) \ 240 do { \ 241 /* external reference: error, and label bad */ \ 242 error = (err); \ 243 goto bad; \ 244 } while (0) 245 246 #define MATCH_FAMILY(x, y, w) \ 247 ((x) == (y) || ((w) && ((x) == PF_UNSPEC || (y) == PF_UNSPEC))) 248 #define MATCH(x, y, w) \ 249 ((x) == (y) || ((w) && ((x) == ANY || (y) == ANY))) 250 251 char * 252 gai_strerror(ecode) 253 int ecode; 254 { 255 if (ecode < 0 || ecode > EAI_MAX) 256 ecode = EAI_MAX; 257 return ai_errlist[ecode]; 258 } 259 260 void 261 freeaddrinfo(ai) 262 struct addrinfo *ai; 263 { 264 struct addrinfo *next; 265 266 do { 267 next = ai->ai_next; 268 if (ai->ai_canonname) 269 free(ai->ai_canonname); 270 /* no need to free(ai->ai_addr) */ 271 free(ai); 272 } while ((ai = next) != NULL); 273 } 274 275 static int 276 str_isnumber(p) 277 const char *p; 278 { 279 char *q = (char *)p; 280 while (*q) { 281 if (! isdigit(*q)) 282 return NO; 283 q++; 284 } 285 return YES; 286 } 287 288 int 289 getaddrinfo(hostname, servname, hints, res) 290 const char *hostname, *servname; 291 const struct addrinfo *hints; 292 struct addrinfo **res; 293 { 294 struct addrinfo sentinel; 295 struct addrinfo *cur; 296 int error = 0; 297 struct addrinfo ai; 298 struct addrinfo ai0; 299 struct addrinfo *pai; 300 const struct afd *afd; 301 const struct explore *ex; 302 303 #ifdef FAITH 304 static int firsttime = 1; 305 306 if (firsttime) { 307 /* translator hack */ 308 char *q = getenv("GAI"); 309 if (q && inet_pton(AF_INET6, q, &faith_prefix) == 1) 310 translate = YES; 311 firsttime = 0; 312 } 313 #endif 314 315 sentinel.ai_next = NULL; 316 cur = &sentinel; 317 pai = &ai; 318 pai->ai_flags = 0; 319 pai->ai_family = PF_UNSPEC; 320 pai->ai_socktype = ANY; 321 pai->ai_protocol = ANY; 322 pai->ai_addrlen = 0; 323 pai->ai_canonname = NULL; 324 pai->ai_addr = NULL; 325 pai->ai_next = NULL; 326 327 if (hostname == NULL && servname == NULL) 328 return EAI_NONAME; 329 if (hints) { 330 /* error check for hints */ 331 if (hints->ai_addrlen || hints->ai_canonname || 332 hints->ai_addr || hints->ai_next) 333 ERR(EAI_BADHINTS); /* xxx */ 334 if (hints->ai_flags & ~AI_MASK) 335 ERR(EAI_BADFLAGS); 336 switch (hints->ai_family) { 337 case PF_UNSPEC: 338 case PF_INET: 339 #ifdef INET6 340 case PF_INET6: 341 #endif 342 break; 343 default: 344 ERR(EAI_FAMILY); 345 } 346 memcpy(pai, hints, sizeof(*pai)); 347 348 /* 349 * if both socktype/protocol are specified, check if they 350 * are meaningful combination. 351 */ 352 if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) { 353 for (ex = explore; ex->e_af >= 0; ex++) { 354 if (pai->ai_family != ex->e_af) 355 continue; 356 if (ex->e_socktype == ANY) 357 continue; 358 if (ex->e_protocol == ANY) 359 continue; 360 if (pai->ai_socktype == ex->e_socktype 361 && pai->ai_protocol != ex->e_protocol) { 362 ERR(EAI_BADHINTS); 363 } 364 } 365 } 366 } 367 368 /* 369 * check for special cases. (1) numeric servname is disallowed if 370 * socktype/protocol are left unspecified. (2) servname is disallowed 371 * for raw and other inet{,6} sockets. 372 */ 373 if (MATCH_FAMILY(pai->ai_family, PF_INET, 1) 374 #ifdef PF_INET6 375 || MATCH_FAMILY(pai->ai_family, PF_INET6, 1) 376 #endif 377 ) { 378 ai0 = *pai; 379 380 if (pai->ai_family == PF_UNSPEC) { 381 #ifdef PF_INET6 382 pai->ai_family = PF_INET6; 383 #else 384 pai->ai_family = PF_INET; 385 #endif 386 } 387 error = get_portmatch(pai, servname); 388 if (error) 389 ERR(error); 390 391 *pai = ai0; 392 } 393 394 ai0 = *pai; 395 396 /* NULL hostname, or numeric hostname */ 397 for (ex = explore; ex->e_af >= 0; ex++) { 398 *pai = ai0; 399 400 if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex))) 401 continue; 402 if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex))) 403 continue; 404 if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex))) 405 continue; 406 407 if (pai->ai_family == PF_UNSPEC) 408 pai->ai_family = ex->e_af; 409 if (pai->ai_socktype == ANY && ex->e_socktype != ANY) 410 pai->ai_socktype = ex->e_socktype; 411 if (pai->ai_protocol == ANY && ex->e_protocol != ANY) 412 pai->ai_protocol = ex->e_protocol; 413 414 if (hostname == NULL) 415 error = explore_null(pai, hostname, servname, &cur->ai_next); 416 else 417 error = explore_numeric_scope(pai, hostname, servname, &cur->ai_next); 418 419 if (error) 420 goto free; 421 422 while (cur && cur->ai_next) 423 cur = cur->ai_next; 424 } 425 426 /* 427 * XXX 428 * If numreic representation of AF1 can be interpreted as FQDN 429 * representation of AF2, we need to think again about the code below. 430 */ 431 if (sentinel.ai_next) 432 goto good; 433 434 if (pai->ai_flags & AI_NUMERICHOST) 435 ERR(EAI_NONAME); 436 if (hostname == NULL) 437 ERR(EAI_NONAME); 438 439 /* 440 * hostname as alphabetical name. 441 * we would like to prefer AF_INET6 than AF_INET, so we'll make a 442 * outer loop by AFs. 443 */ 444 for (afd = afdl; afd->a_af; afd++) { 445 *pai = ai0; 446 447 if (!MATCH_FAMILY(pai->ai_family, afd->a_af, 1)) 448 continue; 449 450 for (ex = explore; ex->e_af >= 0; ex++) { 451 *pai = ai0; 452 453 if (pai->ai_family == PF_UNSPEC) 454 pai->ai_family = afd->a_af; 455 456 if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex))) 457 continue; 458 if (!MATCH(pai->ai_socktype, ex->e_socktype, 459 WILD_SOCKTYPE(ex))) { 460 continue; 461 } 462 if (!MATCH(pai->ai_protocol, ex->e_protocol, 463 WILD_PROTOCOL(ex))) { 464 continue; 465 } 466 467 if (pai->ai_family == PF_UNSPEC) 468 pai->ai_family = ex->e_af; 469 if (pai->ai_socktype == ANY && ex->e_socktype != ANY) 470 pai->ai_socktype = ex->e_socktype; 471 if (pai->ai_protocol == ANY && ex->e_protocol != ANY) 472 pai->ai_protocol = ex->e_protocol; 473 474 error = explore_fqdn(pai, hostname, servname, 475 &cur->ai_next); 476 477 while (cur && cur->ai_next) 478 cur = cur->ai_next; 479 } 480 } 481 482 /* XXX */ 483 if (sentinel.ai_next) 484 error = 0; 485 486 if (error) 487 goto free; 488 if (error == 0) { 489 if (sentinel.ai_next) { 490 good: 491 *res = sentinel.ai_next; 492 return SUCCESS; 493 } else 494 error = EAI_FAIL; 495 } 496 free: 497 bad: 498 if (sentinel.ai_next) 499 freeaddrinfo(sentinel.ai_next); 500 *res = NULL; 501 return error; 502 } 503 504 /* 505 * FQDN hostname, DNS lookup 506 */ 507 static int 508 explore_fqdn(pai, hostname, servname, res) 509 const struct addrinfo *pai; 510 const char *hostname; 511 const char *servname; 512 struct addrinfo **res; 513 { 514 struct hostent *hp; 515 int h_error; 516 int af; 517 char **aplist = NULL, *apbuf = NULL; 518 char *ap; 519 struct addrinfo sentinel, *cur; 520 int i; 521 #ifndef USE_GETIPNODEBY 522 int naddrs; 523 #endif 524 const struct afd *afd; 525 int error; 526 527 *res = NULL; 528 sentinel.ai_next = NULL; 529 cur = &sentinel; 530 531 /* 532 * Do not filter unsupported AFs here. We need to honor content of 533 * databases (/etc/hosts, DNS and others). Otherwise we cannot 534 * replace gethostbyname() by getaddrinfo(). 535 */ 536 537 /* 538 * if the servname does not match socktype/protocol, ignore it. 539 */ 540 if (get_portmatch(pai, servname) != 0) 541 return 0; 542 543 afd = find_afd(pai->ai_family); 544 545 /* 546 * post-RFC2553: should look at (pai->ai_flags & AI_ADDRCONFIG) 547 * rather than hardcoding it. we may need to add AI_ADDRCONFIG 548 * handling code by ourselves in case we don't have getipnodebyname(). 549 */ 550 #ifdef USE_GETIPNODEBY 551 hp = getipnodebyname(hostname, pai->ai_family, AI_ADDRCONFIG, &h_error); 552 #else 553 #ifdef HAVE_GETHOSTBYNAME2 554 hp = gethostbyname2(hostname, pai->ai_family); 555 #else 556 if (pai->ai_family != AF_INET) 557 return 0; 558 hp = gethostbyname(hostname); 559 #ifdef HAVE_H_ERRNO 560 h_error = h_errno; 561 #else 562 h_error = EINVAL; 563 #endif 564 #endif /*HAVE_GETHOSTBYNAME2*/ 565 #endif /*USE_GETIPNODEBY*/ 566 567 if (hp == NULL) { 568 switch (h_error) { 569 case HOST_NOT_FOUND: 570 case NO_DATA: 571 error = EAI_NODATA; 572 break; 573 case TRY_AGAIN: 574 error = EAI_AGAIN; 575 break; 576 case NO_RECOVERY: 577 case NETDB_INTERNAL: 578 default: 579 error = EAI_FAIL; 580 break; 581 } 582 } else if ((hp->h_name == NULL) || (hp->h_name[0] == 0) 583 || (hp->h_addr_list[0] == NULL)) { 584 #ifdef USE_GETIPNODEBY 585 freehostent(hp); 586 #endif 587 hp = NULL; 588 error = EAI_FAIL; 589 } 590 591 if (hp == NULL) 592 goto free; 593 594 #ifdef USE_GETIPNODEBY 595 aplist = hp->h_addr_list; 596 #else 597 /* 598 * hp will be overwritten if we use gethostbyname2(). 599 * always deep copy for simplification. 600 */ 601 for (naddrs = 0; hp->h_addr_list[naddrs] != NULL; naddrs++) 602 ; 603 naddrs++; 604 aplist = (char **)malloc(sizeof(aplist[0]) * naddrs); 605 apbuf = (char *)malloc(hp->h_length * naddrs); 606 if (aplist == NULL || apbuf == NULL) { 607 error = EAI_MEMORY; 608 goto free; 609 } 610 memset(aplist, 0, sizeof(aplist[0]) * naddrs); 611 for (i = 0; i < naddrs; i++) { 612 if (hp->h_addr_list[i] == NULL) { 613 aplist[i] = NULL; 614 continue; 615 } 616 memcpy(&apbuf[i * hp->h_length], hp->h_addr_list[i], 617 hp->h_length); 618 aplist[i] = &apbuf[i * hp->h_length]; 619 } 620 #endif 621 622 for (i = 0; aplist[i] != NULL; i++) { 623 af = hp->h_addrtype; 624 ap = aplist[i]; 625 #ifdef AF_INET6 626 if (af == AF_INET6 627 && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) { 628 af = AF_INET; 629 ap = ap + sizeof(struct in6_addr) 630 - sizeof(struct in_addr); 631 } 632 #endif 633 634 if (af != pai->ai_family) 635 continue; 636 637 if ((pai->ai_flags & AI_CANONNAME) == 0) { 638 GET_AI(cur->ai_next, afd, ap); 639 GET_PORT(cur->ai_next, servname); 640 } else { 641 /* 642 * if AI_CANONNAME and if reverse lookup 643 * fail, return ai anyway to pacify 644 * calling application. 645 * 646 * XXX getaddrinfo() is a name->address 647 * translation function, and it looks 648 * strange that we do addr->name 649 * translation here. 650 */ 651 get_name(ap, afd, &cur->ai_next, 652 ap, pai, servname); 653 } 654 655 while (cur && cur->ai_next) 656 cur = cur->ai_next; 657 } 658 659 *res = sentinel.ai_next; 660 return 0; 661 662 free: 663 #ifdef USE_GETIPNODEBY 664 if (hp) 665 freehostent(hp); 666 #endif 667 if (aplist) 668 free(aplist); 669 if (apbuf) 670 free(apbuf); 671 if (sentinel.ai_next) 672 freeaddrinfo(sentinel.ai_next); 673 return error; 674 } 675 676 /* 677 * hostname == NULL. 678 * passive socket -> anyaddr (0.0.0.0 or ::) 679 * non-passive socket -> localhost (127.0.0.1 or ::1) 680 */ 681 static int 682 explore_null(pai, hostname, servname, res) 683 const struct addrinfo *pai; 684 const char *hostname; 685 const char *servname; 686 struct addrinfo **res; 687 { 688 int s; 689 const struct afd *afd; 690 struct addrinfo *cur; 691 struct addrinfo sentinel; 692 int error; 693 694 *res = NULL; 695 sentinel.ai_next = NULL; 696 cur = &sentinel; 697 698 /* 699 * filter out AFs that are not supported by the kernel 700 * XXX errno? 701 */ 702 s = socket(pai->ai_family, SOCK_DGRAM, 0); 703 if (s < 0) { 704 if (errno != EMFILE) 705 return 0; 706 } else 707 close(s); 708 709 /* 710 * if the servname does not match socktype/protocol, ignore it. 711 */ 712 if (get_portmatch(pai, servname) != 0) 713 return 0; 714 715 afd = find_afd(pai->ai_family); 716 717 if (pai->ai_flags & AI_PASSIVE) { 718 GET_AI(cur->ai_next, afd, afd->a_addrany); 719 /* xxx meaningless? 720 * GET_CANONNAME(cur->ai_next, "anyaddr"); 721 */ 722 GET_PORT(cur->ai_next, servname); 723 } else { 724 GET_AI(cur->ai_next, afd, afd->a_loopback); 725 /* xxx meaningless? 726 * GET_CANONNAME(cur->ai_next, "localhost"); 727 */ 728 GET_PORT(cur->ai_next, servname); 729 } 730 cur = cur->ai_next; 731 732 *res = sentinel.ai_next; 733 return 0; 734 735 free: 736 if (sentinel.ai_next) 737 freeaddrinfo(sentinel.ai_next); 738 return error; 739 } 740 741 /* 742 * numeric hostname 743 */ 744 static int 745 explore_numeric(pai, hostname, servname, res) 746 const struct addrinfo *pai; 747 const char *hostname; 748 const char *servname; 749 struct addrinfo **res; 750 { 751 const struct afd *afd; 752 struct addrinfo *cur; 753 struct addrinfo sentinel; 754 int error; 755 char pton[PTON_MAX]; 756 int flags; 757 758 *res = NULL; 759 sentinel.ai_next = NULL; 760 cur = &sentinel; 761 762 /* 763 * if the servname does not match socktype/protocol, ignore it. 764 */ 765 if (get_portmatch(pai, servname) != 0) 766 return 0; 767 768 afd = find_afd(pai->ai_family); 769 flags = pai->ai_flags; 770 771 if (inet_pton(afd->a_af, hostname, pton) == 1) { 772 u_int32_t v4a; 773 #ifdef INET6 774 u_char pfx; 775 #endif 776 777 switch (afd->a_af) { 778 case AF_INET: 779 v4a = (u_int32_t)ntohl(((struct in_addr *)pton)->s_addr); 780 if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a)) 781 flags &= ~AI_CANONNAME; 782 v4a >>= IN_CLASSA_NSHIFT; 783 if (v4a == 0 || v4a == IN_LOOPBACKNET) 784 flags &= ~AI_CANONNAME; 785 break; 786 #ifdef INET6 787 case AF_INET6: 788 pfx = ((struct in6_addr *)pton)->s6_addr[0]; 789 if (pfx == 0 || pfx == 0xfe || pfx == 0xff) 790 flags &= ~AI_CANONNAME; 791 break; 792 #endif 793 } 794 795 if (pai->ai_family == afd->a_af || 796 pai->ai_family == PF_UNSPEC /*?*/) { 797 if ((flags & AI_CANONNAME) == 0) { 798 GET_AI(cur->ai_next, afd, pton); 799 GET_PORT(cur->ai_next, servname); 800 } else { 801 /* 802 * if AI_CANONNAME and if reverse lookup 803 * fail, return ai anyway to pacify 804 * calling application. 805 * 806 * XXX getaddrinfo() is a name->address 807 * translation function, and it looks 808 * strange that we do addr->name 809 * translation here. 810 */ 811 get_name(pton, afd, &cur->ai_next, 812 pton, pai, servname); 813 } 814 while (cur && cur->ai_next) 815 cur = cur->ai_next; 816 } else 817 ERR(EAI_FAMILY); /*xxx*/ 818 } 819 820 *res = sentinel.ai_next; 821 return 0; 822 823 free: 824 bad: 825 if (sentinel.ai_next) 826 freeaddrinfo(sentinel.ai_next); 827 return error; 828 } 829 830 /* 831 * numeric hostname with scope 832 */ 833 static int 834 explore_numeric_scope(pai, hostname, servname, res) 835 const struct addrinfo *pai; 836 const char *hostname; 837 const char *servname; 838 struct addrinfo **res; 839 { 840 #ifndef SCOPE_DELIMITER 841 return explore_numeric(pai, hostname, servname, res); 842 #else 843 const struct afd *afd; 844 struct addrinfo *cur; 845 int error; 846 char *cp, *hostname2 = NULL; 847 int scope; 848 struct sockaddr_in6 *sin6; 849 850 /* 851 * if the servname does not match socktype/protocol, ignore it. 852 */ 853 if (get_portmatch(pai, servname) != 0) 854 return 0; 855 856 afd = find_afd(pai->ai_family); 857 if (!afd->a_scoped) 858 return explore_numeric(pai, hostname, servname, res); 859 860 cp = strchr(hostname, SCOPE_DELIMITER); 861 if (cp == NULL) 862 return explore_numeric(pai, hostname, servname, res); 863 864 /* 865 * Handle special case of <scoped_address><delimiter><scope id> 866 */ 867 hostname2 = strdup(hostname); 868 if (hostname2 == NULL) 869 return EAI_MEMORY; 870 /* terminate at the delimiter */ 871 hostname2[cp - hostname] = '\0'; 872 873 cp++; 874 switch (pai->ai_family) { 875 #ifdef INET6 876 case AF_INET6: 877 scope = if_nametoindex(cp); 878 if (scope == 0) { 879 free(hostname2); 880 return (EAI_NONAME); 881 } 882 break; 883 #endif 884 } 885 886 error = explore_numeric(pai, hostname2, servname, res); 887 if (error == 0) { 888 for (cur = *res; cur; cur = cur->ai_next) { 889 if (cur->ai_family != AF_INET6) 890 continue; 891 sin6 = (struct sockaddr_in6 *)cur->ai_addr; 892 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) || 893 IN6_IS_ADDR_MC_LINKLOCAL(&sin6->sin6_addr)) 894 sin6->sin6_scope_id = scope; 895 } 896 } 897 898 free(hostname2); 899 900 return error; 901 #endif 902 } 903 904 static int 905 get_name(addr, afd, res, numaddr, pai, servname) 906 const char *addr; 907 const struct afd *afd; 908 struct addrinfo **res; 909 char *numaddr; 910 const struct addrinfo *pai; 911 const char *servname; 912 { 913 struct hostent *hp = NULL; 914 struct addrinfo *cur = NULL; 915 int error = 0; 916 char *ap = NULL, *cn = NULL; 917 #ifdef USE_GETIPNODEBY 918 int h_error; 919 920 hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error); 921 #else 922 hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af); 923 #endif 924 if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) { 925 #ifdef USE_GETIPNODEBY 926 GET_AI(cur, afd, hp->h_addr_list[0]); 927 GET_PORT(cur, servname); 928 GET_CANONNAME(cur, hp->h_name); 929 #else 930 /* hp will be damaged if we use gethostbyaddr() */ 931 if ((ap = (char *)malloc(hp->h_length)) == NULL) { 932 error = EAI_MEMORY; 933 goto free; 934 } 935 memcpy(ap, hp->h_addr_list[0], hp->h_length); 936 if ((cn = strdup(hp->h_name)) == NULL) { 937 error = EAI_MEMORY; 938 goto free; 939 } 940 941 GET_AI(cur, afd, ap); 942 GET_PORT(cur, servname); 943 GET_CANONNAME(cur, cn); 944 free(ap); ap = NULL; 945 free(cn); cn = NULL; 946 #endif 947 } else { 948 GET_AI(cur, afd, numaddr); 949 GET_PORT(cur, servname); 950 } 951 952 #ifdef USE_GETIPNODEBY 953 if (hp) 954 freehostent(hp); 955 #endif 956 *res = cur; 957 return SUCCESS; 958 free: 959 if (cur) 960 freeaddrinfo(cur); 961 if (ap) 962 free(ap); 963 if (cn) 964 free(cn); 965 #ifdef USE_GETIPNODEBY 966 if (hp) 967 freehostent(hp); 968 #endif 969 *res = NULL; 970 return error; 971 } 972 973 static int 974 get_canonname(pai, ai, str) 975 const struct addrinfo *pai; 976 struct addrinfo *ai; 977 const char *str; 978 { 979 if ((pai->ai_flags & AI_CANONNAME) != 0) { 980 ai->ai_canonname = (char *)malloc(strlen(str) + 1); 981 if (ai->ai_canonname == NULL) 982 return EAI_MEMORY; 983 strcpy(ai->ai_canonname, str); 984 } 985 return 0; 986 } 987 988 static struct addrinfo * 989 get_ai(pai, afd, addr) 990 const struct addrinfo *pai; 991 const struct afd *afd; 992 const char *addr; 993 { 994 char *p; 995 struct addrinfo *ai; 996 997 ai = (struct addrinfo *)malloc(sizeof(struct addrinfo) 998 + (afd->a_socklen)); 999 if (ai == NULL) 1000 return NULL; 1001 1002 memcpy(ai, pai, sizeof(struct addrinfo)); 1003 ai->ai_addr = (struct sockaddr *)(ai + 1); 1004 memset(ai->ai_addr, 0, afd->a_socklen); 1005 #ifdef HAVE_SOCKADDR_SA_LEN 1006 ai->ai_addr->sa_len = afd->a_socklen; 1007 #endif 1008 ai->ai_addrlen = afd->a_socklen; 1009 ai->ai_addr->sa_family = ai->ai_family = afd->a_af; 1010 p = (char *)(ai->ai_addr); 1011 memcpy(p + afd->a_off, addr, afd->a_addrlen); 1012 return ai; 1013 } 1014 1015 static int 1016 get_portmatch(ai, servname) 1017 const struct addrinfo *ai; 1018 const char *servname; 1019 { 1020 1021 /* get_port does not touch first argument. when matchonly == 1. */ 1022 return get_port((struct addrinfo *)ai, servname, 1); 1023 } 1024 1025 static int 1026 get_port(ai, servname, matchonly) 1027 struct addrinfo *ai; 1028 const char *servname; 1029 int matchonly; 1030 { 1031 const char *proto; 1032 struct servent *sp; 1033 int port; 1034 int allownumeric; 1035 1036 if (servname == NULL) 1037 return 0; 1038 switch (ai->ai_family) { 1039 case AF_INET: 1040 #ifdef AF_INET6 1041 case AF_INET6: 1042 #endif 1043 break; 1044 default: 1045 return 0; 1046 } 1047 1048 switch (ai->ai_socktype) { 1049 case SOCK_RAW: 1050 return EAI_SERVICE; 1051 case SOCK_DGRAM: 1052 case SOCK_STREAM: 1053 allownumeric = 1; 1054 break; 1055 case ANY: 1056 allownumeric = 0; 1057 break; 1058 default: 1059 return EAI_SOCKTYPE; 1060 } 1061 1062 if (str_isnumber(servname)) { 1063 if (!allownumeric) 1064 return EAI_SERVICE; 1065 port = htons(atoi(servname)); 1066 if (port < 0 || port > 65535) 1067 return EAI_SERVICE; 1068 } else { 1069 switch (ai->ai_socktype) { 1070 case SOCK_DGRAM: 1071 proto = "udp"; 1072 break; 1073 case SOCK_STREAM: 1074 proto = "tcp"; 1075 break; 1076 default: 1077 proto = NULL; 1078 break; 1079 } 1080 1081 if ((sp = getservbyname(servname, proto)) == NULL) 1082 return EAI_SERVICE; 1083 port = sp->s_port; 1084 } 1085 1086 if (!matchonly) { 1087 switch (ai->ai_family) { 1088 case AF_INET: 1089 ((struct sockaddr_in *)ai->ai_addr)->sin_port = port; 1090 break; 1091 #ifdef INET6 1092 case AF_INET6: 1093 ((struct sockaddr_in6 *)ai->ai_addr)->sin6_port = port; 1094 break; 1095 #endif 1096 } 1097 } 1098 1099 return 0; 1100 } 1101 1102 static const struct afd * 1103 find_afd(af) 1104 int af; 1105 { 1106 const struct afd *afd; 1107 1108 if (af == PF_UNSPEC) 1109 return NULL; 1110 for (afd = afdl; afd->a_af; afd++) { 1111 if (afd->a_af == af) 1112 return afd; 1113 } 1114 return NULL; 1115 } 1116
