1/* 2 * Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10#ifndef _GNU_SOURCE 11# define _GNU_SOURCE 12#endif 13 14/* 15 * VC configurations may define UNICODE, to indicate to the C RTL that 16 * WCHAR functions are preferred. 17 * This affects functions like gai_strerror(), which is implemented as 18 * an alias macro for gai_strerrorA() (which returns a const char *) or 19 * gai_strerrorW() (which returns a const WCHAR *). This source file 20 * assumes POSIX declarations, so prefer the non-UNICODE definitions. 21 */ 22#undef UNICODE 23 24#include <assert.h> 25#include <string.h> 26 27#include "bio_local.h" 28#include <openssl/crypto.h> 29 30#ifndef OPENSSL_NO_SOCK 31#include <openssl/err.h> 32#include <openssl/buffer.h> 33#include "internal/thread_once.h" 34 35CRYPTO_RWLOCK *bio_lookup_lock; 36static CRYPTO_ONCE bio_lookup_init = CRYPTO_ONCE_STATIC_INIT; 37 38/* 39 * Throughout this file and bio_local.h, the existence of the macro 40 * AI_PASSIVE is used to detect the availability of struct addrinfo, 41 * getnameinfo() and getaddrinfo(). If that macro doesn't exist, 42 * we use our own implementation instead, using gethostbyname, 43 * getservbyname and a few other. 44 */ 45 46/********************************************************************** 47 * 48 * Address structure 49 * 50 */ 51 52BIO_ADDR *BIO_ADDR_new(void) 53{ 54 BIO_ADDR *ret = OPENSSL_zalloc(sizeof(*ret)); 55 56 if (ret == NULL) { 57 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 58 return NULL; 59 } 60 61 ret->sa.sa_family = AF_UNSPEC; 62 return ret; 63} 64 65void BIO_ADDR_free(BIO_ADDR *ap) 66{ 67 OPENSSL_free(ap); 68} 69 70void BIO_ADDR_clear(BIO_ADDR *ap) 71{ 72 memset(ap, 0, sizeof(*ap)); 73 ap->sa.sa_family = AF_UNSPEC; 74} 75 76/* 77 * BIO_ADDR_make - non-public routine to fill a BIO_ADDR with the contents 78 * of a struct sockaddr. 79 */ 80int BIO_ADDR_make(BIO_ADDR *ap, const struct sockaddr *sa) 81{ 82 if (sa->sa_family == AF_INET) { 83 memcpy(&(ap->s_in), sa, sizeof(struct sockaddr_in)); 84 return 1; 85 } 86#ifdef AF_INET6 87 if (sa->sa_family == AF_INET6) { 88 memcpy(&(ap->s_in6), sa, sizeof(struct sockaddr_in6)); 89 return 1; 90 } 91#endif 92#ifdef AF_UNIX 93 if (sa->sa_family == AF_UNIX) { 94 memcpy(&(ap->s_un), sa, sizeof(struct sockaddr_un)); 95 return 1; 96 } 97#endif 98 99 return 0; 100} 101 102int BIO_ADDR_rawmake(BIO_ADDR *ap, int family, 103 const void *where, size_t wherelen, 104 unsigned short port) 105{ 106#ifdef AF_UNIX 107 if (family == AF_UNIX) { 108 if (wherelen + 1 > sizeof(ap->s_un.sun_path)) 109 return 0; 110 memset(&ap->s_un, 0, sizeof(ap->s_un)); 111 ap->s_un.sun_family = family; 112 strncpy(ap->s_un.sun_path, where, sizeof(ap->s_un.sun_path) - 1); 113 return 1; 114 } 115#endif 116 if (family == AF_INET) { 117 if (wherelen != sizeof(struct in_addr)) 118 return 0; 119 memset(&ap->s_in, 0, sizeof(ap->s_in)); 120 ap->s_in.sin_family = family; 121 ap->s_in.sin_port = port; 122 ap->s_in.sin_addr = *(struct in_addr *)where; 123 return 1; 124 } 125#ifdef AF_INET6 126 if (family == AF_INET6) { 127 if (wherelen != sizeof(struct in6_addr)) 128 return 0; 129 memset(&ap->s_in6, 0, sizeof(ap->s_in6)); 130 ap->s_in6.sin6_family = family; 131 ap->s_in6.sin6_port = port; 132 ap->s_in6.sin6_addr = *(struct in6_addr *)where; 133 return 1; 134 } 135#endif 136 137 return 0; 138} 139 140int BIO_ADDR_family(const BIO_ADDR *ap) 141{ 142 return ap->sa.sa_family; 143} 144 145int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l) 146{ 147 size_t len = 0; 148 const void *addrptr = NULL; 149 150 if (ap->sa.sa_family == AF_INET) { 151 len = sizeof(ap->s_in.sin_addr); 152 addrptr = &ap->s_in.sin_addr; 153 } 154#ifdef AF_INET6 155 else if (ap->sa.sa_family == AF_INET6) { 156 len = sizeof(ap->s_in6.sin6_addr); 157 addrptr = &ap->s_in6.sin6_addr; 158 } 159#endif 160#ifdef AF_UNIX 161 else if (ap->sa.sa_family == AF_UNIX) { 162 len = strlen(ap->s_un.sun_path); 163 addrptr = &ap->s_un.sun_path; 164 } 165#endif 166 167 if (addrptr == NULL) 168 return 0; 169 170 if (p != NULL) { 171 memcpy(p, addrptr, len); 172 } 173 if (l != NULL) 174 *l = len; 175 176 return 1; 177} 178 179unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap) 180{ 181 if (ap->sa.sa_family == AF_INET) 182 return ap->s_in.sin_port; 183#ifdef AF_INET6 184 if (ap->sa.sa_family == AF_INET6) 185 return ap->s_in6.sin6_port; 186#endif 187 return 0; 188} 189 190/*- 191 * addr_strings - helper function to get host and service names 192 * @ap: the BIO_ADDR that has the input info 193 * @numeric: 0 if actual names should be returned, 1 if the numeric 194 * representation should be returned. 195 * @hostname: a pointer to a pointer to a memory area to store the 196 * host name or numeric representation. Unused if NULL. 197 * @service: a pointer to a pointer to a memory area to store the 198 * service name or numeric representation. Unused if NULL. 199 * 200 * The return value is 0 on failure, with the error code in the error 201 * stack, and 1 on success. 202 */ 203static int addr_strings(const BIO_ADDR *ap, int numeric, 204 char **hostname, char **service) 205{ 206 if (BIO_sock_init() != 1) 207 return 0; 208 209 if (1) { 210#ifdef AI_PASSIVE 211 int ret = 0; 212 char host[NI_MAXHOST] = "", serv[NI_MAXSERV] = ""; 213 int flags = 0; 214 215 if (numeric) 216 flags |= NI_NUMERICHOST | NI_NUMERICSERV; 217 218 if ((ret = getnameinfo(BIO_ADDR_sockaddr(ap), 219 BIO_ADDR_sockaddr_size(ap), 220 host, sizeof(host), serv, sizeof(serv), 221 flags)) != 0) { 222# ifdef EAI_SYSTEM 223 if (ret == EAI_SYSTEM) { 224 ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(), 225 "calling getnameinfo()"); 226 } else 227# endif 228 { 229 ERR_raise_data(ERR_LIB_BIO, ERR_R_SYS_LIB, gai_strerror(ret)); 230 } 231 return 0; 232 } 233 234 /* VMS getnameinfo() has a bug, it doesn't fill in serv, which 235 * leaves it with whatever garbage that happens to be there. 236 * However, we initialise serv with the empty string (serv[0] 237 * is therefore NUL), so it gets real easy to detect when things 238 * didn't go the way one might expect. 239 */ 240 if (serv[0] == '\0') { 241 BIO_snprintf(serv, sizeof(serv), "%d", 242 ntohs(BIO_ADDR_rawport(ap))); 243 } 244 245 if (hostname != NULL) 246 *hostname = OPENSSL_strdup(host); 247 if (service != NULL) 248 *service = OPENSSL_strdup(serv); 249 } else { 250#endif 251 if (hostname != NULL) 252 *hostname = OPENSSL_strdup(inet_ntoa(ap->s_in.sin_addr)); 253 if (service != NULL) { 254 char serv[6]; /* port is 16 bits => max 5 decimal digits */ 255 BIO_snprintf(serv, sizeof(serv), "%d", ntohs(ap->s_in.sin_port)); 256 *service = OPENSSL_strdup(serv); 257 } 258 } 259 260 if ((hostname != NULL && *hostname == NULL) 261 || (service != NULL && *service == NULL)) { 262 if (hostname != NULL) { 263 OPENSSL_free(*hostname); 264 *hostname = NULL; 265 } 266 if (service != NULL) { 267 OPENSSL_free(*service); 268 *service = NULL; 269 } 270 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 271 return 0; 272 } 273 274 return 1; 275} 276 277char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric) 278{ 279 char *hostname = NULL; 280 281 if (addr_strings(ap, numeric, &hostname, NULL)) 282 return hostname; 283 284 return NULL; 285} 286 287char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric) 288{ 289 char *service = NULL; 290 291 if (addr_strings(ap, numeric, NULL, &service)) 292 return service; 293 294 return NULL; 295} 296 297char *BIO_ADDR_path_string(const BIO_ADDR *ap) 298{ 299#ifdef AF_UNIX 300 if (ap->sa.sa_family == AF_UNIX) 301 return OPENSSL_strdup(ap->s_un.sun_path); 302#endif 303 return NULL; 304} 305 306/* 307 * BIO_ADDR_sockaddr - non-public routine to return the struct sockaddr 308 * for a given BIO_ADDR. In reality, this is simply a type safe cast. 309 * The returned struct sockaddr is const, so it can't be tampered with. 310 */ 311const struct sockaddr *BIO_ADDR_sockaddr(const BIO_ADDR *ap) 312{ 313 return &(ap->sa); 314} 315 316/* 317 * BIO_ADDR_sockaddr_noconst - non-public function that does the same 318 * as BIO_ADDR_sockaddr, but returns a non-const. USE WITH CARE, as 319 * it allows you to tamper with the data (and thereby the contents 320 * of the input BIO_ADDR). 321 */ 322struct sockaddr *BIO_ADDR_sockaddr_noconst(BIO_ADDR *ap) 323{ 324 return &(ap->sa); 325} 326 327/* 328 * BIO_ADDR_sockaddr_size - non-public function that returns the size 329 * of the struct sockaddr the BIO_ADDR is using. If the protocol family 330 * isn't set or is something other than AF_INET, AF_INET6 or AF_UNIX, 331 * the size of the BIO_ADDR type is returned. 332 */ 333socklen_t BIO_ADDR_sockaddr_size(const BIO_ADDR *ap) 334{ 335 if (ap->sa.sa_family == AF_INET) 336 return sizeof(ap->s_in); 337#ifdef AF_INET6 338 if (ap->sa.sa_family == AF_INET6) 339 return sizeof(ap->s_in6); 340#endif 341#ifdef AF_UNIX 342 if (ap->sa.sa_family == AF_UNIX) 343 return sizeof(ap->s_un); 344#endif 345 return sizeof(*ap); 346} 347 348/********************************************************************** 349 * 350 * Address info database 351 * 352 */ 353 354const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai) 355{ 356 if (bai != NULL) 357 return bai->bai_next; 358 return NULL; 359} 360 361int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai) 362{ 363 if (bai != NULL) 364 return bai->bai_family; 365 return 0; 366} 367 368int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai) 369{ 370 if (bai != NULL) 371 return bai->bai_socktype; 372 return 0; 373} 374 375int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai) 376{ 377 if (bai != NULL) { 378 if (bai->bai_protocol != 0) 379 return bai->bai_protocol; 380 381#ifdef AF_UNIX 382 if (bai->bai_family == AF_UNIX) 383 return 0; 384#endif 385 386 switch (bai->bai_socktype) { 387 case SOCK_STREAM: 388 return IPPROTO_TCP; 389 case SOCK_DGRAM: 390 return IPPROTO_UDP; 391 default: 392 break; 393 } 394 } 395 return 0; 396} 397 398/* 399 * BIO_ADDRINFO_sockaddr_size - non-public function that returns the size 400 * of the struct sockaddr inside the BIO_ADDRINFO. 401 */ 402socklen_t BIO_ADDRINFO_sockaddr_size(const BIO_ADDRINFO *bai) 403{ 404 if (bai != NULL) 405 return bai->bai_addrlen; 406 return 0; 407} 408 409/* 410 * BIO_ADDRINFO_sockaddr - non-public function that returns bai_addr 411 * as the struct sockaddr it is. 412 */ 413const struct sockaddr *BIO_ADDRINFO_sockaddr(const BIO_ADDRINFO *bai) 414{ 415 if (bai != NULL) 416 return bai->bai_addr; 417 return NULL; 418} 419 420const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai) 421{ 422 if (bai != NULL) 423 return (BIO_ADDR *)bai->bai_addr; 424 return NULL; 425} 426 427void BIO_ADDRINFO_free(BIO_ADDRINFO *bai) 428{ 429 if (bai == NULL) 430 return; 431 432#ifdef AI_PASSIVE 433# ifdef AF_UNIX 434# define _cond bai->bai_family != AF_UNIX 435# else 436# define _cond 1 437# endif 438 if (_cond) { 439 freeaddrinfo(bai); 440 return; 441 } 442#endif 443 444 /* Free manually when we know that addrinfo_wrap() was used. 445 * See further comment above addrinfo_wrap() 446 */ 447 while (bai != NULL) { 448 BIO_ADDRINFO *next = bai->bai_next; 449 OPENSSL_free(bai->bai_addr); 450 OPENSSL_free(bai); 451 bai = next; 452 } 453} 454 455/********************************************************************** 456 * 457 * Service functions 458 * 459 */ 460 461/*- 462 * The specs in hostserv can take these forms: 463 * 464 * host:service => *host = "host", *service = "service" 465 * host:* => *host = "host", *service = NULL 466 * host: => *host = "host", *service = NULL 467 * :service => *host = NULL, *service = "service" 468 * *:service => *host = NULL, *service = "service" 469 * 470 * in case no : is present in the string, the result depends on 471 * hostserv_prio, as follows: 472 * 473 * when hostserv_prio == BIO_PARSE_PRIO_HOST 474 * host => *host = "host", *service untouched 475 * 476 * when hostserv_prio == BIO_PARSE_PRIO_SERV 477 * service => *host untouched, *service = "service" 478 * 479 */ 480int BIO_parse_hostserv(const char *hostserv, char **host, char **service, 481 enum BIO_hostserv_priorities hostserv_prio) 482{ 483 const char *h = NULL; size_t hl = 0; 484 const char *p = NULL; size_t pl = 0; 485 486 if (*hostserv == '[') { 487 if ((p = strchr(hostserv, ']')) == NULL) 488 goto spec_err; 489 h = hostserv + 1; 490 hl = p - h; 491 p++; 492 if (*p == '\0') 493 p = NULL; 494 else if (*p != ':') 495 goto spec_err; 496 else { 497 p++; 498 pl = strlen(p); 499 } 500 } else { 501 const char *p2 = strrchr(hostserv, ':'); 502 p = strchr(hostserv, ':'); 503 504 /*- 505 * Check for more than one colon. There are three possible 506 * interpretations: 507 * 1. IPv6 address with port number, last colon being separator. 508 * 2. IPv6 address only. 509 * 3. IPv6 address only if hostserv_prio == BIO_PARSE_PRIO_HOST, 510 * IPv6 address and port number if hostserv_prio == BIO_PARSE_PRIO_SERV 511 * Because of this ambiguity, we currently choose to make it an 512 * error. 513 */ 514 if (p != p2) 515 goto amb_err; 516 517 if (p != NULL) { 518 h = hostserv; 519 hl = p - h; 520 p++; 521 pl = strlen(p); 522 } else if (hostserv_prio == BIO_PARSE_PRIO_HOST) { 523 h = hostserv; 524 hl = strlen(h); 525 } else { 526 p = hostserv; 527 pl = strlen(p); 528 } 529 } 530 531 if (p != NULL && strchr(p, ':')) 532 goto spec_err; 533 534 if (h != NULL && host != NULL) { 535 if (hl == 0 536 || (hl == 1 && h[0] == '*')) { 537 *host = NULL; 538 } else { 539 *host = OPENSSL_strndup(h, hl); 540 if (*host == NULL) 541 goto memerr; 542 } 543 } 544 if (p != NULL && service != NULL) { 545 if (pl == 0 546 || (pl == 1 && p[0] == '*')) { 547 *service = NULL; 548 } else { 549 *service = OPENSSL_strndup(p, pl); 550 if (*service == NULL) 551 goto memerr; 552 } 553 } 554 555 return 1; 556 amb_err: 557 ERR_raise(ERR_LIB_BIO, BIO_R_AMBIGUOUS_HOST_OR_SERVICE); 558 return 0; 559 spec_err: 560 ERR_raise(ERR_LIB_BIO, BIO_R_MALFORMED_HOST_OR_SERVICE); 561 return 0; 562 memerr: 563 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 564 return 0; 565} 566 567/* addrinfo_wrap is used to build our own addrinfo "chain". 568 * (it has only one entry, so calling it a chain may be a stretch) 569 * It should ONLY be called when getaddrinfo() and friends 570 * aren't available, OR when dealing with a non IP protocol 571 * family, such as AF_UNIX 572 * 573 * the return value is 1 on success, or 0 on failure, which 574 * only happens if a memory allocation error occurred. 575 */ 576static int addrinfo_wrap(int family, int socktype, 577 const void *where, size_t wherelen, 578 unsigned short port, 579 BIO_ADDRINFO **bai) 580{ 581 if ((*bai = OPENSSL_zalloc(sizeof(**bai))) == NULL) { 582 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 583 return 0; 584 } 585 586 (*bai)->bai_family = family; 587 (*bai)->bai_socktype = socktype; 588 if (socktype == SOCK_STREAM) 589 (*bai)->bai_protocol = IPPROTO_TCP; 590 if (socktype == SOCK_DGRAM) 591 (*bai)->bai_protocol = IPPROTO_UDP; 592#ifdef AF_UNIX 593 if (family == AF_UNIX) 594 (*bai)->bai_protocol = 0; 595#endif 596 { 597 /* Magic: We know that BIO_ADDR_sockaddr_noconst is really 598 just an advanced cast of BIO_ADDR* to struct sockaddr * 599 by the power of union, so while it may seem that we're 600 creating a memory leak here, we are not. It will be 601 all right. */ 602 BIO_ADDR *addr = BIO_ADDR_new(); 603 if (addr != NULL) { 604 BIO_ADDR_rawmake(addr, family, where, wherelen, port); 605 (*bai)->bai_addr = BIO_ADDR_sockaddr_noconst(addr); 606 } 607 } 608 (*bai)->bai_next = NULL; 609 if ((*bai)->bai_addr == NULL) { 610 BIO_ADDRINFO_free(*bai); 611 *bai = NULL; 612 return 0; 613 } 614 return 1; 615} 616 617DEFINE_RUN_ONCE_STATIC(do_bio_lookup_init) 618{ 619 bio_lookup_lock = CRYPTO_THREAD_lock_new(); 620 return bio_lookup_lock != NULL; 621} 622 623int BIO_lookup(const char *host, const char *service, 624 enum BIO_lookup_type lookup_type, 625 int family, int socktype, BIO_ADDRINFO **res) 626{ 627 return BIO_lookup_ex(host, service, lookup_type, family, socktype, 0, res); 628} 629 630/*- 631 * BIO_lookup_ex - look up the host and service you want to connect to. 632 * @host: the host (or node, in case family == AF_UNIX) you want to connect to. 633 * @service: the service you want to connect to. 634 * @lookup_type: declare intent with the result, client or server. 635 * @family: the address family you want to use. Use AF_UNSPEC for any, or 636 * AF_INET, AF_INET6 or AF_UNIX. 637 * @socktype: The socket type you want to use. Can be SOCK_STREAM, SOCK_DGRAM 638 * or 0 for all. 639 * @protocol: The protocol to use, e.g. IPPROTO_TCP or IPPROTO_UDP or 0 for all. 640 * Note that some platforms may not return IPPROTO_SCTP without 641 * explicitly requesting it (i.e. IPPROTO_SCTP may not be returned 642 * with 0 for the protocol) 643 * @res: Storage place for the resulting list of returned addresses 644 * 645 * This will do a lookup of the host and service that you want to connect to. 646 * It returns a linked list of different addresses you can try to connect to. 647 * 648 * When no longer needed you should call BIO_ADDRINFO_free() to free the result. 649 * 650 * The return value is 1 on success or 0 in case of error. 651 */ 652int BIO_lookup_ex(const char *host, const char *service, int lookup_type, 653 int family, int socktype, int protocol, BIO_ADDRINFO **res) 654{ 655 int ret = 0; /* Assume failure */ 656 657 switch(family) { 658 case AF_INET: 659#ifdef AF_INET6 660 case AF_INET6: 661#endif 662#ifdef AF_UNIX 663 case AF_UNIX: 664#endif 665#ifdef AF_UNSPEC 666 case AF_UNSPEC: 667#endif 668 break; 669 default: 670 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_PROTOCOL_FAMILY); 671 return 0; 672 } 673 674#ifdef AF_UNIX 675 if (family == AF_UNIX) { 676 if (addrinfo_wrap(family, socktype, host, strlen(host), 0, res)) 677 return 1; 678 else 679 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 680 return 0; 681 } 682#endif 683 684 if (BIO_sock_init() != 1) 685 return 0; 686 687 if (1) { 688#ifdef AI_PASSIVE 689 int gai_ret = 0, old_ret = 0; 690 struct addrinfo hints; 691 692 memset(&hints, 0, sizeof(hints)); 693 694 hints.ai_family = family; 695 hints.ai_socktype = socktype; 696 hints.ai_protocol = protocol; 697# ifdef AI_ADDRCONFIG 698# ifdef AF_UNSPEC 699 if (host != NULL && family == AF_UNSPEC) 700# endif 701 hints.ai_flags |= AI_ADDRCONFIG; 702# endif 703 704 if (lookup_type == BIO_LOOKUP_SERVER) 705 hints.ai_flags |= AI_PASSIVE; 706 707 /* Note that |res| SHOULD be a 'struct addrinfo **' thanks to 708 * macro magic in bio_local.h 709 */ 710# if defined(AI_ADDRCONFIG) && defined(AI_NUMERICHOST) 711 retry: 712# endif 713 switch ((gai_ret = getaddrinfo(host, service, &hints, res))) { 714# ifdef EAI_SYSTEM 715 case EAI_SYSTEM: 716 ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(), 717 "calling getaddrinfo()"); 718 ERR_raise(ERR_LIB_BIO, ERR_R_SYS_LIB); 719 break; 720# endif 721# ifdef EAI_MEMORY 722 case EAI_MEMORY: 723 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 724 break; 725# endif 726 case 0: 727 ret = 1; /* Success */ 728 break; 729 default: 730# if defined(AI_ADDRCONFIG) && defined(AI_NUMERICHOST) 731 if (hints.ai_flags & AI_ADDRCONFIG) { 732 hints.ai_flags &= ~AI_ADDRCONFIG; 733 hints.ai_flags |= AI_NUMERICHOST; 734 old_ret = gai_ret; 735 goto retry; 736 } 737# endif 738 ERR_raise_data(ERR_LIB_BIO, ERR_R_SYS_LIB, 739 gai_strerror(old_ret ? old_ret : gai_ret)); 740 break; 741 } 742 } else { 743#endif 744 const struct hostent *he; 745/* 746 * Because struct hostent is defined for 32-bit pointers only with 747 * VMS C, we need to make sure that '&he_fallback_address' and 748 * '&he_fallback_addresses' are 32-bit pointers 749 */ 750#if defined(OPENSSL_SYS_VMS) && defined(__DECC) 751# pragma pointer_size save 752# pragma pointer_size 32 753#endif 754 /* Windows doesn't seem to have in_addr_t */ 755#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) 756 static uint32_t he_fallback_address; 757 static const char *he_fallback_addresses[] = 758 { (char *)&he_fallback_address, NULL }; 759#else 760 static in_addr_t he_fallback_address; 761 static const char *he_fallback_addresses[] = 762 { (char *)&he_fallback_address, NULL }; 763#endif 764 static const struct hostent he_fallback = 765 { NULL, NULL, AF_INET, sizeof(he_fallback_address), 766 (char **)&he_fallback_addresses }; 767#if defined(OPENSSL_SYS_VMS) && defined(__DECC) 768# pragma pointer_size restore 769#endif 770 771 struct servent *se; 772 /* Apparently, on WIN64, s_proto and s_port have traded places... */ 773#ifdef _WIN64 774 struct servent se_fallback = { NULL, NULL, NULL, 0 }; 775#else 776 struct servent se_fallback = { NULL, NULL, 0, NULL }; 777#endif 778 779 if (!RUN_ONCE(&bio_lookup_init, do_bio_lookup_init)) { 780 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 781 ret = 0; 782 goto err; 783 } 784 785 if (!CRYPTO_THREAD_write_lock(bio_lookup_lock)) { 786 ret = 0; 787 goto err; 788 } 789 he_fallback_address = INADDR_ANY; 790 if (host == NULL) { 791 he = &he_fallback; 792 switch(lookup_type) { 793 case BIO_LOOKUP_CLIENT: 794 he_fallback_address = INADDR_LOOPBACK; 795 break; 796 case BIO_LOOKUP_SERVER: 797 he_fallback_address = INADDR_ANY; 798 break; 799 default: 800 /* We forgot to handle a lookup type! */ 801 assert("We forgot to handle a lookup type!" == NULL); 802 ERR_raise(ERR_LIB_BIO, ERR_R_INTERNAL_ERROR); 803 ret = 0; 804 goto err; 805 } 806 } else { 807 he = gethostbyname(host); 808 809 if (he == NULL) { 810#ifndef OPENSSL_SYS_WINDOWS 811 /* 812 * This might be misleading, because h_errno is used as if 813 * it was errno. To minimize mixup add 1000. Underlying 814 * reason for this is that hstrerror is declared obsolete, 815 * not to mention that a) h_errno is not always guaranteed 816 * to be meaningless; b) hstrerror can reside in yet another 817 * library, linking for sake of hstrerror is an overkill; 818 * c) this path is not executed on contemporary systems 819 * anyway [above getaddrinfo/gai_strerror is]. We just let 820 * system administrator figure this out... 821 */ 822# if defined(OPENSSL_SYS_VXWORKS) 823 /* h_errno doesn't exist on VxWorks */ 824 ERR_raise_data(ERR_LIB_SYS, 1000, 825 "calling gethostbyname()"); 826# else 827 ERR_raise_data(ERR_LIB_SYS, 1000 + h_errno, 828 "calling gethostbyname()"); 829# endif 830#else 831 ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(), 832 "calling gethostbyname()"); 833#endif 834 ret = 0; 835 goto err; 836 } 837 } 838 839 if (service == NULL) { 840 se_fallback.s_port = 0; 841 se_fallback.s_proto = NULL; 842 se = &se_fallback; 843 } else { 844 char *endp = NULL; 845 long portnum = strtol(service, &endp, 10); 846 847/* 848 * Because struct servent is defined for 32-bit pointers only with 849 * VMS C, we need to make sure that 'proto' is a 32-bit pointer. 850 */ 851#if defined(OPENSSL_SYS_VMS) && defined(__DECC) 852# pragma pointer_size save 853# pragma pointer_size 32 854#endif 855 char *proto = NULL; 856#if defined(OPENSSL_SYS_VMS) && defined(__DECC) 857# pragma pointer_size restore 858#endif 859 860 switch (socktype) { 861 case SOCK_STREAM: 862 proto = "tcp"; 863 break; 864 case SOCK_DGRAM: 865 proto = "udp"; 866 break; 867 } 868 869 if (endp != service && *endp == '\0' 870 && portnum > 0 && portnum < 65536) { 871 se_fallback.s_port = htons((unsigned short)portnum); 872 se_fallback.s_proto = proto; 873 se = &se_fallback; 874 } else if (endp == service) { 875 se = getservbyname(service, proto); 876 877 if (se == NULL) { 878 ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(), 879 "calling getservbyname()"); 880 goto err; 881 } 882 } else { 883 ERR_raise(ERR_LIB_BIO, BIO_R_MALFORMED_HOST_OR_SERVICE); 884 goto err; 885 } 886 } 887 888 *res = NULL; 889 890 { 891/* 892 * Because hostent::h_addr_list is an array of 32-bit pointers with VMS C, 893 * we must make sure our iterator designates the same element type, hence 894 * the pointer size dance. 895 */ 896#if defined(OPENSSL_SYS_VMS) && defined(__DECC) 897# pragma pointer_size save 898# pragma pointer_size 32 899#endif 900 char **addrlistp; 901#if defined(OPENSSL_SYS_VMS) && defined(__DECC) 902# pragma pointer_size restore 903#endif 904 size_t addresses; 905 BIO_ADDRINFO *tmp_bai = NULL; 906 907 /* The easiest way to create a linked list from an 908 array is to start from the back */ 909 for(addrlistp = he->h_addr_list; *addrlistp != NULL; 910 addrlistp++) 911 ; 912 913 for(addresses = addrlistp - he->h_addr_list; 914 addrlistp--, addresses-- > 0; ) { 915 if (!addrinfo_wrap(he->h_addrtype, socktype, 916 *addrlistp, he->h_length, 917 se->s_port, &tmp_bai)) 918 goto addrinfo_malloc_err; 919 tmp_bai->bai_next = *res; 920 *res = tmp_bai; 921 continue; 922 addrinfo_malloc_err: 923 BIO_ADDRINFO_free(*res); 924 *res = NULL; 925 ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE); 926 ret = 0; 927 goto err; 928 } 929 930 ret = 1; 931 } 932 err: 933 CRYPTO_THREAD_unlock(bio_lookup_lock); 934 } 935 936 return ret; 937} 938 939#endif /* OPENSSL_NO_SOCK */ 940