crypto/bio/b_addr.c

   1 /* ====================================================================
   2  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in
  13  *    the documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  * 3. All advertising materials mentioning features or use of this
  17  *    software must display the following acknowledgment:
  18  *    "This product includes software developed by the OpenSSL Project
  19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  20  *
  21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  22  *    endorse or promote products derived from this software without
  23  *    prior written permission. For written permission, please contact
  24  *    openssl-core@openssl.org.
  25  *
  26  * 5. Products derived from this software may not be called "OpenSSL"
  27  *    nor may "OpenSSL" appear in their names without prior written
  28  *    permission of the OpenSSL Project.
  29  *
  30  * 6. Redistributions of any form whatsoever must retain the following
  31  *    acknowledgment:
  32  *    "This product includes software developed by the OpenSSL Project
  33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  46  * OF THE POSSIBILITY OF SUCH DAMAGE.
  47  * ====================================================================
  48  *
  49  * This product includes cryptographic software written by Eric Young
  50  * (eay@cryptsoft.com).  This product includes software written by Tim
  51  * Hudson (tjh@cryptsoft.com).
  52  *
  53  */
  54
  55 #include <string.h>
  56
  57 #include "bio_lcl.h"
  58
  59 #include <openssl/err.h>
  60 #include <openssl/buffer.h>
  61
  62 /*
  63  * Throughout this file and bio_lcl.h, the existence of the macro
  64  * AI_PASSIVE is used to detect the availability of struct addrinfo,
  65  * getnameinfo() and getaddrinfo().  If that macro doesn't exist,
  66  * we use our own implementation instead, using gethostbyname,
  67  * getservbyname and a few other.
  68  */
  69
  70 /**********************************************************************
  71  *
  72  * Address structure
  73  *
  74  */
  75
  76 BIO_ADDR *BIO_ADDR_new(void)
  77 {
  78     BIO_ADDR *ret = (BIO_ADDR *)OPENSSL_zalloc(sizeof(BIO_ADDR));
  79     return ret;
  80 }
  81
  82 void BIO_ADDR_free(BIO_ADDR *ap)
  83 {
  84     OPENSSL_free(ap);
  85 }
  86
  87 /*
  88  * BIO_ADDR_make - non-public routine to fill a BIO_ADDR with the contents
  89  * of a struct sockaddr.
  90  */
  91 int BIO_ADDR_make(BIO_ADDR *ap, const struct sockaddr *sa)
  92 {
  93     if (sa->sa_family == AF_INET) {
  94         ap->sin = *(const struct sockaddr_in *)sa;
  95         return 1;
  96     }
  97 #ifdef AF_INET6
  98     if (sa->sa_family == AF_INET6) {
  99         ap->sin6 = *(const struct sockaddr_in6 *)sa;
 100         return 1;
 101     }
 102 #endif
 103 #ifdef AF_UNIX
 104     if (ap->sa.sa_family == AF_UNIX) {
 105         ap->sun = *(const struct sockaddr_un *)sa;
 106         return 1;
 107     }
 108 #endif
 109
 110     return 0;
 111 }
 112
 113 int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
 114                      const void *where, size_t wherelen,
 115                      unsigned short port)
 116 {
 117 #ifdef AF_UNIX
 118     if (family == AF_UNIX) {
 119         if (wherelen + 1 > sizeof(ap->sun.sun_path))
 120             return 0;
 121         memset(&ap->sun, 0, sizeof(ap->sun));
 122         ap->sun.sun_family = family;
 123         strncpy(ap->sun.sun_path, where, sizeof(ap->sun.sun_path) - 1);
 124         return 1;
 125     }
 126 #endif
 127     if (family == AF_INET) {
 128         if (wherelen != sizeof(struct in_addr))
 129             return 0;
 130         memset(&ap->sin, 0, sizeof(ap->sin));
 131         ap->sin.sin_family = family;
 132         ap->sin.sin_port = port;
 133         ap->sin.sin_addr = *(struct in_addr *)where;
 134         return 1;
 135     }
 136 #ifdef AF_INET6
 137     if (family == AF_INET6) {
 138         if (wherelen != sizeof(struct in6_addr))
 139             return 0;
 140         memset(&ap->sin6, 0, sizeof(ap->sin6));
 141         ap->sin6.sin6_family = family;
 142         ap->sin6.sin6_port = port;
 143         ap->sin6.sin6_addr = *(struct in6_addr *)where;
 144         return 1;
 145     }
 146 #endif
 147
 148     return 0;
 149 }
 150
 151 int BIO_ADDR_family(const BIO_ADDR *ap)
 152 {
 153     return ap->sa.sa_family;
 154 }
 155
 156 int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l)
 157 {
 158     size_t len = 0;
 159     const void *addrptr = NULL;
 160
 161     if (ap->sa.sa_family == AF_INET) {
 162         len = sizeof(ap->sin.sin_addr);
 163         addrptr = &ap->sin.sin_addr;
 164     }
 165 #ifdef AF_INET6
 166     else if (ap->sa.sa_family == AF_INET6) {
 167         len = sizeof(ap->sin6.sin6_addr);
 168         addrptr = &ap->sin6.sin6_addr;
 169     }
 170 #endif
 171 #ifdef AF_UNIX
 172     else if (ap->sa.sa_family == AF_UNIX) {
 173         len = strlen(ap->sun.sun_path);
 174         addrptr = &ap->sun.sun_path;
 175     }
 176 #endif
 177
 178     if (addrptr == NULL)
 179         return 0;
 180
 181     if (p != NULL) {
 182         memcpy(p, addrptr, len);
 183     }
 184     if (l != NULL)
 185         *l = len;
 186
 187     return 1;
 188 }
 189
 190 unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap)
 191 {
 192     if (ap->sa.sa_family == AF_INET)
 193         return ap->sin.sin_port;
 194 #ifdef AF_INET6
 195     if (ap->sa.sa_family == AF_INET6)
 196         return ap->sin6.sin6_port;
 197 #endif
 198     return 0;
 199 }
 200
 201 /*-
 202  * addr_strings - helper function to get host and service names
 203  * @ap: the BIO_ADDR that has the input info
 204  * @numeric: 0 if actual names should be returned, 1 if the numeric
 205  * representation should be returned.
 206  * @hostname: a pointer to a pointer to a memory area to store the
 207  * host name or numeric representation.  Unused if NULL.
 208  * @service: a pointer to a pointer to a memory area to store the
 209  * service name or numeric representation.  Unused if NULL.
 210  *
 211  * The return value is 0 on failure, with the error code in the error
 212  * stack, and 1 on success.
 213  */
 214 static int addr_strings(const BIO_ADDR *ap, int numeric,
 215                         char **hostname, char **service)
 216 {
 217     if (1) {
 218 #ifdef AI_PASSIVE
 219         int ret = 0;
 220         char host[NI_MAXHOST], serv[NI_MAXSERV];
 221         int flags = 0;
 222
 223         if (numeric)
 224             flags |= NI_NUMERICHOST | NI_NUMERICSERV;
 225
 226         if ((ret = getnameinfo(BIO_ADDR_sockaddr(ap),
 227                                BIO_ADDR_sockaddr_size(ap),
 228                                host, sizeof(host), serv, sizeof(serv),
 229                                flags)) != 0) {
 230 # ifdef EAI_SYSTEM
 231             if (ret == EAI_SYSTEM) {
 232                 SYSerr(SYS_F_GETNAMEINFO, get_last_socket_error());
 233                 BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);
 234             } else
 235 # endif
 236             {
 237                 BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);
 238                 ERR_add_error_data(1, gai_strerror(ret));
 239             }
 240             return 0;
 241         }
 242         if (hostname)
 243             *hostname = OPENSSL_strdup(host);
 244         if (service)
 245             *service = OPENSSL_strdup(serv);
 246     } else {
 247 #endif
 248         if (hostname)
 249             *hostname = OPENSSL_strdup(inet_ntoa(ap->sin.sin_addr));
 250         if (service) {
 251             char serv[6];        /* port is 16 bits => max 5 decimal digits */
 252             BIO_snprintf(serv, sizeof(serv), "%d", ntohs(ap->sin.sin_port));
 253             *service = OPENSSL_strdup(serv);
 254         }
 255     }
 256
 257     return 1;
 258 }
 259
 260 char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric)
 261 {
 262     char *hostname = NULL;
 263
 264     if (addr_strings(ap, numeric, &hostname, NULL))
 265         return hostname;
 266
 267     return NULL;
 268 }
 269
 270 char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric)
 271 {
 272     char *service = NULL;
 273
 274     if (addr_strings(ap, numeric, NULL, &service))
 275         return service;
 276
 277     return NULL;
 278 }
 279
 280 char *BIO_ADDR_path_string(const BIO_ADDR *ap)
 281 {
 282 #ifdef AF_UNIX
 283     if (ap->sa.sa_family == AF_UNIX)
 284         return OPENSSL_strdup(ap->sun.sun_path);
 285 #endif
 286     return NULL;
 287 }
 288
 289 /*
 290  * BIO_ADDR_sockaddr - non-public routine to return the struct sockaddr
 291  * for a given BIO_ADDR.  In reality, this is simply a type safe cast.
 292  * The returned struct sockaddr is const, so it can't be tampered with.
 293  */
 294 const struct sockaddr *BIO_ADDR_sockaddr(const BIO_ADDR *ap)
 295 {
 296     return &(ap->sa);
 297 }
 298
 299 /*
 300  * BIO_ADDR_sockaddr_noconst - non-public function that does the same
 301  * as BIO_ADDR_sockaddr, but returns a non-const.  USE WITH CARE, as
 302  * it allows you to tamper with the data (and thereby the contents
 303  * of the input BIO_ADDR).
 304  */
 305 struct sockaddr *BIO_ADDR_sockaddr_noconst(BIO_ADDR *ap)
 306 {
 307     return &(ap->sa);
 308 }
 309
 310 /*
 311  * BIO_ADDR_sockaddr_size - non-public function that returns the size
 312  * of the struct sockaddr the BIO_ADDR is using.  If the protocol family
 313  * isn't set or is something other than AF_INET, AF_INET6 or AF_UNIX,
 314  * the size of the BIO_ADDR type is returned.
 315  */
 316 socklen_t BIO_ADDR_sockaddr_size(const BIO_ADDR *ap)
 317 {
 318     if (ap->sa.sa_family == AF_INET)
 319         return sizeof(ap->sin);
 320 #ifdef AF_INET6
 321     if (ap->sa.sa_family == AF_INET6)
 322         return sizeof(ap->sin6);
 323 #endif
 324 #ifdef AF_UNIX
 325     if (ap->sa.sa_family == AF_UNIX)
 326         return sizeof(ap->sun);
 327 #endif
 328     return sizeof(*ap);
 329 }
 330
 331 /**********************************************************************
 332  *
 333  * Address into database
 334  *
 335  */
 336
 337 const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai)
 338 {
 339     if (bai != NULL)
 340         return bai->bai_next;
 341     return NULL;
 342 }
 343
 344 int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai)
 345 {
 346     if (bai != NULL)
 347         return bai->bai_family;
 348     return 0;
 349 }
 350
 351 int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai)
 352 {
 353     if (bai != NULL)
 354         return bai->bai_socktype;
 355     return 0;
 356 }
 357
 358 int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai)
 359 {
 360     if (bai != NULL)
 361         return bai->bai_protocol;
 362     return 0;
 363 }
 364
 365 /*
 366  * BIO_ADDRINFO_sockaddr_size - non-public function that returns the size
 367  * of the struct sockaddr inside the BIO_ADDRINFO.
 368  */
 369 socklen_t BIO_ADDRINFO_sockaddr_size(const BIO_ADDRINFO *bai)
 370 {
 371     if (bai != NULL)
 372         return bai->bai_addrlen;
 373     return 0;
 374 }
 375
 376 /*
 377  * BIO_ADDRINFO_sockaddr - non-public function that returns bai_addr
 378  * as the struct sockaddr it is.
 379  */
 380 const struct sockaddr *BIO_ADDRINFO_sockaddr(const BIO_ADDRINFO *bai)
 381 {
 382     if (bai != NULL)
 383         return bai->bai_addr;
 384     return NULL;
 385 }
 386
 387 const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai)
 388 {
 389     if (bai != NULL)
 390         return (BIO_ADDR *)bai->bai_addr;
 391     return NULL;
 392 }
 393
 394 void BIO_ADDRINFO_free(BIO_ADDRINFO *bai)
 395 {
 396     if (bai == NULL)
 397         return;
 398
 399 #ifdef AI_PASSIVE
 400 # ifdef AF_UNIX
 401 #  define _cond bai->bai_family != AF_UNIX
 402 # else
 403 #  define _cond 1
 404 # endif
 405     if (_cond) {
 406         freeaddrinfo(bai);
 407         return;
 408     }
 409 #endif
 410
 411     /* Free manually when we know that addrinfo_wrap() was used.
 412      * See further comment above addrinfo_wrap()
 413      */
 414     while (bai != NULL) {
 415         BIO_ADDRINFO *next = bai->bai_next;
 416         OPENSSL_free(bai->bai_addr);
 417         OPENSSL_free(bai);
 418         bai = next;
 419     }
 420 }
 421
 422 /**********************************************************************
 423  *
 424  * Service functions
 425  *
 426  */
 427
 428 /*-
 429  * The specs in hostserv can take these forms:
 430  *
 431  * host:service         => *host = "host", *service = "service"
 432  * host:*               => *host = "host", *service = NULL
 433  * host:                => *host = "host", *service = NULL
 434  * :service             => *host = NULL, *service = "service"
 435  * *:service            => *host = NULL, *service = "service"
 436  *
 437  * in case no : is present in the string, the result depends on
 438  * hostserv_prio, as follows:
 439  *
 440  * when hostserv_prio == BIO_PARSE_PRIO_HOST
 441  * host                 => *host = "host", *service untouched
 442  *
 443  * when hostserv_prio == BIO_PARSE_PRIO_SERV
 444  * service              => *host untouched, *service = "service"
 445  *
 446  */
 447 int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
 448                        enum BIO_hostserv_priorities hostserv_prio)
 449 {
 450     const char *h = NULL; size_t hl = 0;
 451     const char *p = NULL; size_t pl = 0;
 452
 453     if (*hostserv == '[') {
 454         if ((p = strchr(hostserv, ']')) == NULL)
 455             goto spec_err;
 456         h = hostserv + 1;
 457         hl = p - h;
 458         p++;
 459         if (*p == '\0')
 460             p = NULL;
 461         else if (*p != ':')
 462             goto spec_err;
 463         else {
 464             p++;
 465             pl = strlen(p);
 466         }
 467     } else {
 468         const char *p2 = strrchr(hostserv, ':');
 469         p = strchr(hostserv, ':');
 470
 471         /*-
 472          * Check for more than one colon.  There are three possible
 473          * interpretations:
 474          * 1. IPv6 address with port number, last colon being separator.
 475          * 2. IPv6 address only.
 476          * 3. IPv6 address only if hostserv_prio == BIO_PARSE_PRIO_HOST,
 477          *    IPv6 address and port number if hostserv_prio == BIO_PARSE_PRIO_SERV
 478          * Because of this ambiguity, we currently choose to make it an
 479          * error.
 480          */
 481         if (p != p2)
 482             goto amb_err;
 483
 484         if (p != NULL) {
 485             h = hostserv;
 486             hl = p - h;
 487             p++;
 488             pl = strlen(p);
 489         } else if (hostserv_prio == BIO_PARSE_PRIO_HOST) {
 490             h = hostserv;
 491             hl = strlen(h);
 492         } else {
 493             p = hostserv;
 494             pl = strlen(p);
 495         }
 496     }
 497
 498     if (strchr(p, ':'))
 499         goto spec_err;
 500
 501     if (h != NULL && host != NULL) {
 502         if (hl == 0
 503             || (hl == 1 && h[0] == '*')) {
 504             *host = NULL;
 505         } else {
 506             *host = OPENSSL_strndup(h, hl);
 507             if (*host == NULL)
 508                 goto memerr;
 509         }
 510     }
 511     if (p != NULL && service != NULL) {
 512         if (pl == 0
 513             || (pl == 1 && p[0] == '*')) {
 514             *service = NULL;
 515         } else {
 516             *service = OPENSSL_strndup(p, pl);
 517             if (*service == NULL)
 518                 goto memerr;
 519         }
 520     }
 521
 522     return 1;
 523  amb_err:
 524     BIOerr(BIO_F_BIO_PARSE_HOSTSERV, BIO_R_AMBIGUOUS_HOST_OR_SERVICE);
 525     return 0;
 526  spec_err:
 527     BIOerr(BIO_F_BIO_PARSE_HOSTSERV, BIO_R_MALFORMED_HOST_OR_SERVICE);
 528     return 0;
 529  memerr:
 530     BIOerr(BIO_F_BIO_PARSE_HOSTSERV, ERR_R_MALLOC_FAILURE);
 531     return 0;
 532 }
 533
 534 /* addrinfo_wrap is used to build our own addrinfo "chain".
 535  * (it has only one entry, so calling it a chain may be a stretch)
 536  * It should ONLY be called when getaddrinfo() and friends
 537  * aren't available, OR when dealing with a non IP protocol
 538  * family, such as AF_UNIX
 539  *
 540  * the return value is 1 on success, or 0 on failure, which
 541  * only happens if a memory allocation error occured.
 542  */
 543 static int addrinfo_wrap(int family, int socktype,
 544                          const void *where, size_t wherelen,
 545                          unsigned short port,
 546                          BIO_ADDRINFO **bai)
 547 {
 548     OPENSSL_assert(bai != NULL);
 549
 550     *bai = (BIO_ADDRINFO *)OPENSSL_zalloc(sizeof(**bai));
 551
 552     if (*bai == NULL)
 553         return 0;
 554     (*bai)->bai_family = family;
 555     (*bai)->bai_socktype = socktype;
 556     if (socktype == SOCK_STREAM)
 557         (*bai)->bai_protocol = IPPROTO_TCP;
 558     if (socktype == SOCK_DGRAM)
 559         (*bai)->bai_protocol = IPPROTO_UDP;
 560 #ifdef AF_UNIX
 561     if (family == AF_UNIX)
 562         (*bai)->bai_protocol = 0;
 563 #endif
 564     {
 565         /* Magic: We know that BIO_ADDR_sockaddr_noconst is really
 566            just an advanced cast of BIO_ADDR* to struct sockaddr *
 567            by the power of union, so while it may seem that we're
 568            creating a memory leak here, we are not.  It will be
 569            all right. */
 570         BIO_ADDR *addr = BIO_ADDR_new();
 571         if (addr != NULL) {
 572             BIO_ADDR_rawmake(addr, family, where, wherelen, port);
 573             (*bai)->bai_addr = BIO_ADDR_sockaddr_noconst(addr);
 574         }
 575     }
 576     (*bai)->bai_next = NULL;
 577     if ((*bai)->bai_addr == NULL) {
 578         BIO_ADDRINFO_free(*bai);
 579         *bai = NULL;
 580         return 0;
 581     }
 582     return 1;
 583 }
 584
 585 /*-
 586  * BIO_lookup - look up the node and service you want to connect to.
 587  * @node: the node you want to connect to.
 588  * @service: the service you want to connect to.
 589  * @lookup_type: declare intent with the result, client or server.
 590  * @family: the address family you want to use.  Use AF_UNSPEC for any, or
 591  *  AF_INET, AF_INET6 or AF_UNIX.
 592  * @socktype: The socket type you want to use.  Can be SOCK_STREAM, SOCK_DGRAM
 593  *  or 0 for all.
 594  * @res: Storage place for the resulting list of returned addresses
 595  *
 596  * This will do a lookup of the node and service that you want to connect to.
 597  * It returns a linked list of different addresses you can try to connect to.
 598  *
 599  * When no longer needed you should call BIO_ADDRINFO_free() to free the result.
 600  *
 601  * The return value is 1 on success or 0 in case of error.
 602  */
 603 int BIO_lookup(const char *host, const char *service,
 604                enum BIO_lookup_type lookup_type,
 605                int family, int socktype, BIO_ADDRINFO **res)
 606 {
 607     int ret = 0;                 /* Assume failure */
 608
 609     switch(family) {
 610     case AF_INET:
 611 #ifdef AF_INET6
 612     case AF_INET6:
 613 #endif
 614 #ifdef AF_UNIX
 615     case AF_UNIX:
 616 #endif
 617 #ifdef AF_UNSPEC
 618     case AF_UNSPEC:
 619 #endif
 620         break;
 621     default:
 622         BIOerr(BIO_F_BIO_LOOKUP, BIO_R_UNSUPPORTED_PROTOCOL_FAMILY);
 623         return 0;
 624     }
 625
 626 #ifdef AF_UNIX
 627     if (family == AF_UNIX) {
 628         if (addrinfo_wrap(family, socktype, host, strlen(host), 0, res))
 629             return 1;
 630         else
 631             BIOerr(BIO_F_BIO_LOOKUP, ERR_R_MALLOC_FAILURE);
 632         return 0;
 633     }
 634 #endif
 635
 636     if (1) {
 637 #ifdef AI_PASSIVE
 638         struct addrinfo hints;
 639
 640         hints.ai_flags = 0;
 641 # ifdef AI_ADDRCONFIG
 642         hints.ai_flags = AI_ADDRCONFIG;
 643 # endif
 644         hints.ai_family = family;
 645         hints.ai_socktype = socktype;
 646         hints.ai_protocol = 0;
 647         hints.ai_addrlen = 0;
 648         hints.ai_addr = NULL;
 649         hints.ai_canonname = NULL;
 650         hints.ai_next = NULL;
 651
 652         if (lookup_type == BIO_LOOKUP_SERVER)
 653             hints.ai_flags |= AI_PASSIVE;
 654
 655         /* Note that |res| SHOULD be a 'struct addrinfo **' thanks to
 656          * macro magic in bio_lcl.h
 657          */
 658         switch (getaddrinfo(host, service, &hints, res)) {
 659 # ifdef EAI_SYSTEM
 660         case EAI_SYSTEM:
 661             SYSerr(SYS_F_GETADDRINFO, get_last_socket_error());
 662             BIOerr(BIO_F_BIO_LOOKUP, ERR_R_SYS_LIB);
 663             break;
 664 # endif
 665         case 0:
 666             ret = 1;             /* Success */
 667             break;
 668         default:
 669             BIOerr(BIO_F_BIO_LOOKUP, ERR_R_SYS_LIB);
 670             ERR_add_error_data(1, gai_strerror(ret));
 671             break;
 672         }
 673     } else {
 674 #endif
 675         const struct hostent *he;
 676         /* Windows doesn't seem to have in_addr_t */
 677 #ifdef OPENSSL_SYS_WINDOWS
 678         static uint32_t he_fallback_address;
 679         static const uint32_t *he_fallback_addresses[] =
 680             { &he_fallback_address, NULL };
 681 #else
 682         static in_addr_t he_fallback_address;
 683         static const in_addr_t *he_fallback_addresses[] =
 684             { &he_fallback_address, NULL };
 685 #endif
 686         static const struct hostent he_fallback =
 687             { NULL, NULL, AF_INET, sizeof(he_fallback_address),
 688               (char **)&he_fallback_addresses };
 689         struct servent *se;
 690         /* Apprently, on WIN64, s_proto and s_port have traded places... */
 691 #ifdef _WIN64
 692         struct servent se_fallback = { NULL, NULL, NULL, 0 };
 693 #else
 694         struct servent se_fallback = { NULL, NULL, 0, NULL };
 695 #endif
 696         char *proto = NULL;
 697
 698         CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
 699         CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
 700         he_fallback_address = INADDR_ANY;
 701         if (host == NULL) {
 702             he = &he_fallback;
 703             switch(lookup_type) {
 704             case BIO_LOOKUP_CLIENT:
 705                 he_fallback_address = INADDR_LOOPBACK;
 706                 break;
 707             case BIO_LOOKUP_SERVER:
 708                 he_fallback_address = INADDR_ANY;
 709                 break;
 710             default:
 711                 OPENSSL_assert(("We forgot to handle a lookup type!" == 0));
 712                 break;
 713             }
 714         } else {
 715             he = gethostbyname(host);
 716
 717             if (he == NULL) {
 718                 BIOerr(BIO_F_BIO_LOOKUP, ERR_R_SYS_LIB);
 719                 ERR_add_error_data(1, hstrerror(h_errno));
 720                 ret = 0;
 721                 goto err;
 722             }
 723         }
 724
 725         if (service == NULL) {
 726             se_fallback.s_port = 0;
 727             se_fallback.s_proto = proto;
 728             se = &se_fallback;
 729         } else {
 730             char *endp = NULL;
 731             long portnum = strtol(service, &endp, 10);
 732
 733             if (endp != service && *endp == '\0'
 734                     && portnum > 0 && portnum < 65536) {
 735                 se_fallback.s_port = htons(portnum);
 736                 se_fallback.s_proto = proto;
 737                 se = &se_fallback;
 738             } else if (endp == service) {
 739                 switch (socktype) {
 740                 case SOCK_STREAM:
 741                     proto = "tcp";
 742                     break;
 743                 case SOCK_DGRAM:
 744                     proto = "udp";
 745                     break;
 746                 }
 747                 se = getservbyname(service, proto);
 748
 749                 if (se == NULL) {
 750                     BIOerr(BIO_F_BIO_LOOKUP, ERR_R_SYS_LIB);
 751                     ERR_add_error_data(1, hstrerror(h_errno));
 752                     goto err;
 753                 }
 754             } else {
 755                 BIOerr(BIO_F_BIO_LOOKUP, BIO_R_MALFORMED_HOST_OR_SERVICE);
 756                 goto err;
 757             }
 758         }
 759
 760         *res = NULL;
 761
 762         {
 763             char **addrlistp;
 764             size_t addresses;
 765             BIO_ADDRINFO *tmp_bai = NULL;
 766
 767             /* The easiest way to create a linked list from an
 768                array is to start from the back */
 769             for(addrlistp = he->h_addr_list; *addrlistp != NULL;
 770                 addrlistp++)
 771                 ;
 772
 773             for(addresses = addrlistp - he->h_addr_list;
 774                 addrlistp--, addresses-- > 0; ) {
 775                 if (!addrinfo_wrap(he->h_addrtype, socktype,
 776                                    *addrlistp, he->h_length,
 777                                    se->s_port, &tmp_bai))
 778                     goto addrinfo_malloc_err;
 779                 tmp_bai->bai_next = *res;
 780                 *res = tmp_bai;
 781                 continue;
 782              addrinfo_malloc_err:
 783                 BIO_ADDRINFO_free(*res);
 784                 *res = NULL;
 785                 BIOerr(BIO_F_BIO_LOOKUP, ERR_R_MALLOC_FAILURE);
 786                 ret = 0;
 787                 goto err;
 788             }
 789
 790             ret = 1;
 791         }
 792      err:
 793         CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
 794         CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
 795     }
 796
 797     return ret;
 798 }