b_addr.c 25.6 KB
Newer Older
R
Rich Salz 已提交
1
/*
M
Matt Caswell 已提交
2
 * Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved.
3
 *
R
Rich Salz 已提交
4 5 6 7
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
8 9
 */

10
#include <assert.h>
11 12 13
#include <string.h>

#include "bio_lcl.h"
14
#include <openssl/crypto.h>
15

R
Rich Salz 已提交
16
#ifndef OPENSSL_NO_SOCK
17 18
#include <openssl/err.h>
#include <openssl/buffer.h>
R
Rich Salz 已提交
19
#include "internal/thread_once.h"
20

21
CRYPTO_RWLOCK *bio_lookup_lock;
22 23
static CRYPTO_ONCE bio_lookup_init = CRYPTO_ONCE_STATIC_INIT;

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
/*
 * Throughout this file and bio_lcl.h, the existence of the macro
 * AI_PASSIVE is used to detect the availability of struct addrinfo,
 * getnameinfo() and getaddrinfo().  If that macro doesn't exist,
 * we use our own implementation instead, using gethostbyname,
 * getservbyname and a few other.
 */

/**********************************************************************
 *
 * Address structure
 *
 */

BIO_ADDR *BIO_ADDR_new(void)
{
R
Rich Salz 已提交
40 41
    BIO_ADDR *ret = OPENSSL_zalloc(sizeof(*ret));

42 43
    if (ret == NULL) {
        BIOerr(BIO_F_BIO_ADDR_NEW, ERR_R_MALLOC_FAILURE);
44
        return NULL;
45
    }
46

M
Matt Caswell 已提交
47
    ret->sa.sa_family = AF_UNSPEC;
48 49 50 51 52 53 54 55
    return ret;
}

void BIO_ADDR_free(BIO_ADDR *ap)
{
    OPENSSL_free(ap);
}

M
Matt Caswell 已提交
56 57 58 59 60 61
void BIO_ADDR_clear(BIO_ADDR *ap)
{
    memset(ap, 0, sizeof(*ap));
    ap->sa.sa_family = AF_UNSPEC;
}

62 63 64 65 66 67 68
/*
 * BIO_ADDR_make - non-public routine to fill a BIO_ADDR with the contents
 * of a struct sockaddr.
 */
int BIO_ADDR_make(BIO_ADDR *ap, const struct sockaddr *sa)
{
    if (sa->sa_family == AF_INET) {
69
        memcpy(&(ap->s_in), sa, sizeof(struct sockaddr_in));
70 71 72 73
        return 1;
    }
#ifdef AF_INET6
    if (sa->sa_family == AF_INET6) {
74
        memcpy(&(ap->s_in6), sa, sizeof(struct sockaddr_in6));
75 76 77 78
        return 1;
    }
#endif
#ifdef AF_UNIX
79
    if (sa->sa_family == AF_UNIX) {
80
        memcpy(&(ap->s_un), sa, sizeof(struct sockaddr_un));
81 82 83 84 85 86 87 88 89 90 91 92 93
        return 1;
    }
#endif

    return 0;
}

int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
                     const void *where, size_t wherelen,
                     unsigned short port)
{
#ifdef AF_UNIX
    if (family == AF_UNIX) {
94
        if (wherelen + 1 > sizeof(ap->s_un.sun_path))
95
            return 0;
96 97 98
        memset(&ap->s_un, 0, sizeof(ap->s_un));
        ap->s_un.sun_family = family;
        strncpy(ap->s_un.sun_path, where, sizeof(ap->s_un.sun_path) - 1);
99 100 101 102 103 104
        return 1;
    }
#endif
    if (family == AF_INET) {
        if (wherelen != sizeof(struct in_addr))
            return 0;
105 106 107 108
        memset(&ap->s_in, 0, sizeof(ap->s_in));
        ap->s_in.sin_family = family;
        ap->s_in.sin_port = port;
        ap->s_in.sin_addr = *(struct in_addr *)where;
109 110 111 112 113 114
        return 1;
    }
#ifdef AF_INET6
    if (family == AF_INET6) {
        if (wherelen != sizeof(struct in6_addr))
            return 0;
115 116 117 118
        memset(&ap->s_in6, 0, sizeof(ap->s_in6));
        ap->s_in6.sin6_family = family;
        ap->s_in6.sin6_port = port;
        ap->s_in6.sin6_addr = *(struct in6_addr *)where;
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
        return 1;
    }
#endif

    return 0;
}

int BIO_ADDR_family(const BIO_ADDR *ap)
{
    return ap->sa.sa_family;
}

int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l)
{
    size_t len = 0;
    const void *addrptr = NULL;

    if (ap->sa.sa_family == AF_INET) {
137 138
        len = sizeof(ap->s_in.sin_addr);
        addrptr = &ap->s_in.sin_addr;
139 140 141
    }
#ifdef AF_INET6
    else if (ap->sa.sa_family == AF_INET6) {
142 143
        len = sizeof(ap->s_in6.sin6_addr);
        addrptr = &ap->s_in6.sin6_addr;
144 145 146 147
    }
#endif
#ifdef AF_UNIX
    else if (ap->sa.sa_family == AF_UNIX) {
148 149
        len = strlen(ap->s_un.sun_path);
        addrptr = &ap->s_un.sun_path;
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
    }
#endif

    if (addrptr == NULL)
        return 0;

    if (p != NULL) {
        memcpy(p, addrptr, len);
    }
    if (l != NULL)
        *l = len;

    return 1;
}

unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap)
{
    if (ap->sa.sa_family == AF_INET)
168
        return ap->s_in.sin_port;
169 170
#ifdef AF_INET6
    if (ap->sa.sa_family == AF_INET6)
171
        return ap->s_in6.sin6_port;
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
#endif
    return 0;
}

/*-
 * addr_strings - helper function to get host and service names
 * @ap: the BIO_ADDR that has the input info
 * @numeric: 0 if actual names should be returned, 1 if the numeric
 * representation should be returned.
 * @hostname: a pointer to a pointer to a memory area to store the
 * host name or numeric representation.  Unused if NULL.
 * @service: a pointer to a pointer to a memory area to store the
 * service name or numeric representation.  Unused if NULL.
 *
 * The return value is 0 on failure, with the error code in the error
 * stack, and 1 on success.
 */
static int addr_strings(const BIO_ADDR *ap, int numeric,
                        char **hostname, char **service)
{
192 193 194
    if (BIO_sock_init() != 1)
        return 0;

195 196 197
    if (1) {
#ifdef AI_PASSIVE
        int ret = 0;
198
        char host[NI_MAXHOST] = "", serv[NI_MAXSERV] = "";
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
        int flags = 0;

        if (numeric)
            flags |= NI_NUMERICHOST | NI_NUMERICSERV;

        if ((ret = getnameinfo(BIO_ADDR_sockaddr(ap),
                               BIO_ADDR_sockaddr_size(ap),
                               host, sizeof(host), serv, sizeof(serv),
                               flags)) != 0) {
# ifdef EAI_SYSTEM
            if (ret == EAI_SYSTEM) {
                SYSerr(SYS_F_GETNAMEINFO, get_last_socket_error());
                BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);
            } else
# endif
            {
                BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);
                ERR_add_error_data(1, gai_strerror(ret));
            }
            return 0;
        }
220

221 222 223 224 225
        /* VMS getnameinfo() has a bug, it doesn't fill in serv, which
         * leaves it with whatever garbage that happens to be there.
         * However, we initialise serv with the empty string (serv[0]
         * is therefore NUL), so it gets real easy to detect when things
         * didn't go the way one might expect.
226
         */
227
        if (serv[0] == '\0') {
228 229 230 231
            BIO_snprintf(serv, sizeof(serv), "%d",
                         ntohs(BIO_ADDR_rawport(ap)));
        }

232
        if (hostname != NULL)
233
            *hostname = OPENSSL_strdup(host);
234
        if (service != NULL)
235 236 237
            *service = OPENSSL_strdup(serv);
    } else {
#endif
238
        if (hostname != NULL)
239
            *hostname = OPENSSL_strdup(inet_ntoa(ap->s_in.sin_addr));
240
        if (service != NULL) {
241
            char serv[6];        /* port is 16 bits => max 5 decimal digits */
242
            BIO_snprintf(serv, sizeof(serv), "%d", ntohs(ap->s_in.sin_port));
243 244 245 246
            *service = OPENSSL_strdup(serv);
        }
    }

247 248 249 250 251 252 253 254 255 256 257 258 259 260
    if ((hostname != NULL && *hostname == NULL)
            || (service != NULL && *service == NULL)) {
        if (hostname != NULL) {
            OPENSSL_free(*hostname);
            *hostname = NULL;
        }
        if (service != NULL) {
            OPENSSL_free(*service);
            *service = NULL;
        }
        BIOerr(BIO_F_ADDR_STRINGS, ERR_R_MALLOC_FAILURE);
        return 0;
    }

261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
    return 1;
}

char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric)
{
    char *hostname = NULL;

    if (addr_strings(ap, numeric, &hostname, NULL))
        return hostname;

    return NULL;
}

char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric)
{
    char *service = NULL;

    if (addr_strings(ap, numeric, NULL, &service))
        return service;

    return NULL;
}

char *BIO_ADDR_path_string(const BIO_ADDR *ap)
{
#ifdef AF_UNIX
    if (ap->sa.sa_family == AF_UNIX)
288
        return OPENSSL_strdup(ap->s_un.sun_path);
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
#endif
    return NULL;
}

/*
 * BIO_ADDR_sockaddr - non-public routine to return the struct sockaddr
 * for a given BIO_ADDR.  In reality, this is simply a type safe cast.
 * The returned struct sockaddr is const, so it can't be tampered with.
 */
const struct sockaddr *BIO_ADDR_sockaddr(const BIO_ADDR *ap)
{
    return &(ap->sa);
}

/*
 * BIO_ADDR_sockaddr_noconst - non-public function that does the same
 * as BIO_ADDR_sockaddr, but returns a non-const.  USE WITH CARE, as
 * it allows you to tamper with the data (and thereby the contents
 * of the input BIO_ADDR).
 */
struct sockaddr *BIO_ADDR_sockaddr_noconst(BIO_ADDR *ap)
{
    return &(ap->sa);
}

/*
 * BIO_ADDR_sockaddr_size - non-public function that returns the size
 * of the struct sockaddr the BIO_ADDR is using.  If the protocol family
 * isn't set or is something other than AF_INET, AF_INET6 or AF_UNIX,
 * the size of the BIO_ADDR type is returned.
 */
socklen_t BIO_ADDR_sockaddr_size(const BIO_ADDR *ap)
{
    if (ap->sa.sa_family == AF_INET)
323
        return sizeof(ap->s_in);
324 325
#ifdef AF_INET6
    if (ap->sa.sa_family == AF_INET6)
326
        return sizeof(ap->s_in6);
327 328 329
#endif
#ifdef AF_UNIX
    if (ap->sa.sa_family == AF_UNIX)
330
        return sizeof(ap->s_un);
331 332 333 334 335 336
#endif
    return sizeof(*ap);
}

/**********************************************************************
 *
R
Richard Levitte 已提交
337
 * Address info database
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
 *
 */

const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai)
{
    if (bai != NULL)
        return bai->bai_next;
    return NULL;
}

int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai)
{
    if (bai != NULL)
        return bai->bai_family;
    return 0;
}

int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai)
{
    if (bai != NULL)
        return bai->bai_socktype;
    return 0;
}

int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai)
{
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
    if (bai != NULL) {
        if (bai->bai_protocol != 0)
            return bai->bai_protocol;

#ifdef AF_UNIX
        if (bai->bai_family == AF_UNIX)
            return 0;
#endif

        switch (bai->bai_socktype) {
        case SOCK_STREAM:
            return IPPROTO_TCP;
        case SOCK_DGRAM:
            return IPPROTO_UDP;
        default:
            break;
        }
    }
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
    return 0;
}

/*
 * BIO_ADDRINFO_sockaddr_size - non-public function that returns the size
 * of the struct sockaddr inside the BIO_ADDRINFO.
 */
socklen_t BIO_ADDRINFO_sockaddr_size(const BIO_ADDRINFO *bai)
{
    if (bai != NULL)
        return bai->bai_addrlen;
    return 0;
}

/*
 * BIO_ADDRINFO_sockaddr - non-public function that returns bai_addr
 * as the struct sockaddr it is.
 */
const struct sockaddr *BIO_ADDRINFO_sockaddr(const BIO_ADDRINFO *bai)
{
    if (bai != NULL)
        return bai->bai_addr;
    return NULL;
}

const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai)
{
    if (bai != NULL)
        return (BIO_ADDR *)bai->bai_addr;
    return NULL;
}

void BIO_ADDRINFO_free(BIO_ADDRINFO *bai)
{
    if (bai == NULL)
        return;

#ifdef AI_PASSIVE
# ifdef AF_UNIX
#  define _cond bai->bai_family != AF_UNIX
# else
#  define _cond 1
# endif
    if (_cond) {
        freeaddrinfo(bai);
        return;
    }
#endif

    /* Free manually when we know that addrinfo_wrap() was used.
     * See further comment above addrinfo_wrap()
     */
    while (bai != NULL) {
        BIO_ADDRINFO *next = bai->bai_next;
        OPENSSL_free(bai->bai_addr);
        OPENSSL_free(bai);
        bai = next;
    }
}

/**********************************************************************
 *
 * Service functions
 *
 */

/*-
 * The specs in hostserv can take these forms:
 *
 * host:service         => *host = "host", *service = "service"
 * host:*               => *host = "host", *service = NULL
 * host:                => *host = "host", *service = NULL
 * :service             => *host = NULL, *service = "service"
 * *:service            => *host = NULL, *service = "service"
 *
 * in case no : is present in the string, the result depends on
 * hostserv_prio, as follows:
 *
 * when hostserv_prio == BIO_PARSE_PRIO_HOST
 * host                 => *host = "host", *service untouched
 *
 * when hostserv_prio == BIO_PARSE_PRIO_SERV
 * service              => *host untouched, *service = "service"
 *
 */
int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
                       enum BIO_hostserv_priorities hostserv_prio)
{
    const char *h = NULL; size_t hl = 0;
    const char *p = NULL; size_t pl = 0;

    if (*hostserv == '[') {
        if ((p = strchr(hostserv, ']')) == NULL)
            goto spec_err;
        h = hostserv + 1;
        hl = p - h;
        p++;
        if (*p == '\0')
            p = NULL;
        else if (*p != ':')
            goto spec_err;
        else {
            p++;
            pl = strlen(p);
        }
    } else {
        const char *p2 = strrchr(hostserv, ':');
        p = strchr(hostserv, ':');

        /*-
         * Check for more than one colon.  There are three possible
         * interpretations:
         * 1. IPv6 address with port number, last colon being separator.
         * 2. IPv6 address only.
         * 3. IPv6 address only if hostserv_prio == BIO_PARSE_PRIO_HOST,
         *    IPv6 address and port number if hostserv_prio == BIO_PARSE_PRIO_SERV
         * Because of this ambiguity, we currently choose to make it an
         * error.
         */
        if (p != p2)
            goto amb_err;

        if (p != NULL) {
            h = hostserv;
            hl = p - h;
            p++;
            pl = strlen(p);
        } else if (hostserv_prio == BIO_PARSE_PRIO_HOST) {
            h = hostserv;
            hl = strlen(h);
        } else {
            p = hostserv;
            pl = strlen(p);
        }
    }

518
    if (p != NULL && strchr(p, ':'))
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
        goto spec_err;

    if (h != NULL && host != NULL) {
        if (hl == 0
            || (hl == 1 && h[0] == '*')) {
            *host = NULL;
        } else {
            *host = OPENSSL_strndup(h, hl);
            if (*host == NULL)
                goto memerr;
        }
    }
    if (p != NULL && service != NULL) {
        if (pl == 0
            || (pl == 1 && p[0] == '*')) {
            *service = NULL;
        } else {
            *service = OPENSSL_strndup(p, pl);
            if (*service == NULL)
                goto memerr;
        }
    }

    return 1;
 amb_err:
    BIOerr(BIO_F_BIO_PARSE_HOSTSERV, BIO_R_AMBIGUOUS_HOST_OR_SERVICE);
    return 0;
 spec_err:
    BIOerr(BIO_F_BIO_PARSE_HOSTSERV, BIO_R_MALFORMED_HOST_OR_SERVICE);
    return 0;
 memerr:
    BIOerr(BIO_F_BIO_PARSE_HOSTSERV, ERR_R_MALLOC_FAILURE);
    return 0;
}

/* addrinfo_wrap is used to build our own addrinfo "chain".
 * (it has only one entry, so calling it a chain may be a stretch)
 * It should ONLY be called when getaddrinfo() and friends
 * aren't available, OR when dealing with a non IP protocol
 * family, such as AF_UNIX
 *
 * the return value is 1 on success, or 0 on failure, which
F
FdaSilvaYY 已提交
561
 * only happens if a memory allocation error occurred.
562 563 564 565 566 567
 */
static int addrinfo_wrap(int family, int socktype,
                         const void *where, size_t wherelen,
                         unsigned short port,
                         BIO_ADDRINFO **bai)
{
R
Rich Salz 已提交
568 569
    if ((*bai = OPENSSL_zalloc(sizeof(**bai))) == NULL) {
        BIOerr(BIO_F_ADDRINFO_WRAP, ERR_R_MALLOC_FAILURE);
570
        return 0;
R
Rich Salz 已提交
571
    }
R
Rich Salz 已提交
572

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
    (*bai)->bai_family = family;
    (*bai)->bai_socktype = socktype;
    if (socktype == SOCK_STREAM)
        (*bai)->bai_protocol = IPPROTO_TCP;
    if (socktype == SOCK_DGRAM)
        (*bai)->bai_protocol = IPPROTO_UDP;
#ifdef AF_UNIX
    if (family == AF_UNIX)
        (*bai)->bai_protocol = 0;
#endif
    {
        /* Magic: We know that BIO_ADDR_sockaddr_noconst is really
           just an advanced cast of BIO_ADDR* to struct sockaddr *
           by the power of union, so while it may seem that we're
           creating a memory leak here, we are not.  It will be
           all right. */
        BIO_ADDR *addr = BIO_ADDR_new();
        if (addr != NULL) {
            BIO_ADDR_rawmake(addr, family, where, wherelen, port);
            (*bai)->bai_addr = BIO_ADDR_sockaddr_noconst(addr);
        }
    }
    (*bai)->bai_next = NULL;
    if ((*bai)->bai_addr == NULL) {
        BIO_ADDRINFO_free(*bai);
        *bai = NULL;
        return 0;
    }
    return 1;
}

604
DEFINE_RUN_ONCE_STATIC(do_bio_lookup_init)
605
{
606 607
    if (!OPENSSL_init_crypto(0, NULL))
        return 0;
608
    bio_lookup_lock = CRYPTO_THREAD_lock_new();
R
Rich Salz 已提交
609
    return bio_lookup_lock != NULL;
610 611
}

M
Matt Caswell 已提交
612 613 614 615 616 617 618
int BIO_lookup(const char *host, const char *service,
               enum BIO_lookup_type lookup_type,
               int family, int socktype, BIO_ADDRINFO **res)
{
    return BIO_lookup_ex(host, service, lookup_type, family, socktype, 0, res);
}

619
/*-
620
 * BIO_lookup_ex - look up the node and service you want to connect to.
621 622 623 624 625 626 627
 * @node: the node you want to connect to.
 * @service: the service you want to connect to.
 * @lookup_type: declare intent with the result, client or server.
 * @family: the address family you want to use.  Use AF_UNSPEC for any, or
 *  AF_INET, AF_INET6 or AF_UNIX.
 * @socktype: The socket type you want to use.  Can be SOCK_STREAM, SOCK_DGRAM
 *  or 0 for all.
M
Matt Caswell 已提交
628 629 630 631
 * @protocol: The protocol to use, e.g. IPPROTO_TCP or IPPROTO_UDP or 0 for all.
 *            Note that some platforms may not return IPPROTO_SCTP without
 *            explicitly requesting it (i.e. IPPROTO_SCTP may not be returned
 *            with 0 for the protocol)
632 633 634 635 636 637 638 639 640
 * @res: Storage place for the resulting list of returned addresses
 *
 * This will do a lookup of the node and service that you want to connect to.
 * It returns a linked list of different addresses you can try to connect to.
 *
 * When no longer needed you should call BIO_ADDRINFO_free() to free the result.
 *
 * The return value is 1 on success or 0 in case of error.
 */
M
Matt Caswell 已提交
641
int BIO_lookup_ex(const char *host, const char *service, int lookup_type,
M
Matt Caswell 已提交
642
                  int family, int socktype, int protocol, BIO_ADDRINFO **res)
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
{
    int ret = 0;                 /* Assume failure */

    switch(family) {
    case AF_INET:
#ifdef AF_INET6
    case AF_INET6:
#endif
#ifdef AF_UNIX
    case AF_UNIX:
#endif
#ifdef AF_UNSPEC
    case AF_UNSPEC:
#endif
        break;
    default:
M
Matt Caswell 已提交
659
        BIOerr(BIO_F_BIO_LOOKUP_EX, BIO_R_UNSUPPORTED_PROTOCOL_FAMILY);
660 661 662 663 664 665 666 667
        return 0;
    }

#ifdef AF_UNIX
    if (family == AF_UNIX) {
        if (addrinfo_wrap(family, socktype, host, strlen(host), 0, res))
            return 1;
        else
M
Matt Caswell 已提交
668
            BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_MALLOC_FAILURE);
669 670 671 672
        return 0;
    }
#endif

673 674 675
    if (BIO_sock_init() != 1)
        return 0;

676 677
    if (1) {
#ifdef AI_PASSIVE
678
        int gai_ret = 0;
679
        struct addrinfo hints;
680

R
Rich Salz 已提交
681
        memset(&hints, 0, sizeof(hints));
682 683 684

        hints.ai_family = family;
        hints.ai_socktype = socktype;
M
Matt Caswell 已提交
685
        hints.ai_protocol = protocol;
686 687 688 689 690 691
#ifdef AI_ADDRCONFIG
#ifdef AF_UNSPEC
        if (family == AF_UNSPEC)
#endif
            hints.ai_flags |= AI_ADDRCONFIG;
#endif
692 693 694 695 696 697 698

        if (lookup_type == BIO_LOOKUP_SERVER)
            hints.ai_flags |= AI_PASSIVE;

        /* Note that |res| SHOULD be a 'struct addrinfo **' thanks to
         * macro magic in bio_lcl.h
         */
699
      retry:
700
        switch ((gai_ret = getaddrinfo(host, service, &hints, res))) {
701 702 703
# ifdef EAI_SYSTEM
        case EAI_SYSTEM:
            SYSerr(SYS_F_GETADDRINFO, get_last_socket_error());
M
Matt Caswell 已提交
704
            BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_SYS_LIB);
705 706 707 708 709
            break;
# endif
        case 0:
            ret = 1;             /* Success */
            break;
710 711 712 713 714 715 716 717 718 719 720 721
# if (defined(EAI_FAMILY) || defined(EAI_ADDRFAMILY)) && defined(AI_ADDRCONFIG)
#  ifdef EAI_FAMILY
        case EAI_FAMILY:
#  endif
#  ifdef EAI_ADDRFAMILY
        case EAI_ADDRFAMILY:
#  endif
            if (hints.ai_flags & AI_ADDRCONFIG) {
                hints.ai_flags &= ~AI_ADDRCONFIG;
                goto retry;
            }
# endif
M
Matt Caswell 已提交
722
            /* fall through */
723
        default:
M
Matt Caswell 已提交
724
            BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_SYS_LIB);
725
            ERR_add_error_data(1, gai_strerror(gai_ret));
726 727 728 729
            break;
        }
    } else {
#endif
730
        const struct hostent *he;
R
Richard Levitte 已提交
731 732 733 734 735 736 737 738 739
/*
 * Because struct hostent is defined for 32-bit pointers only with
 * VMS C, we need to make sure that '&he_fallback_address' and
 * '&he_fallback_addresses' are 32-bit pointers
 */
#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
# pragma pointer_size save
# pragma pointer_size 32
#endif
740 741
        /* Windows doesn't seem to have in_addr_t */
#ifdef OPENSSL_SYS_WINDOWS
742
        static uint32_t he_fallback_address;
743 744
        static const char *he_fallback_addresses[] =
            { (char *)&he_fallback_address, NULL };
745
#else
746
        static in_addr_t he_fallback_address;
747 748
        static const char *he_fallback_addresses[] =
            { (char *)&he_fallback_address, NULL };
749
#endif
750 751 752
        static const struct hostent he_fallback =
            { NULL, NULL, AF_INET, sizeof(he_fallback_address),
              (char **)&he_fallback_addresses };
R
Richard Levitte 已提交
753 754 755 756
#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
# pragma pointer_size restore
#endif

757
        struct servent *se;
F
FdaSilvaYY 已提交
758
        /* Apparently, on WIN64, s_proto and s_port have traded places... */
759 760 761 762 763 764
#ifdef _WIN64
        struct servent se_fallback = { NULL, NULL, NULL, 0 };
#else
        struct servent se_fallback = { NULL, NULL, 0, NULL };
#endif

765
        if (!RUN_ONCE(&bio_lookup_init, do_bio_lookup_init)) {
M
Matt Caswell 已提交
766
            BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_MALLOC_FAILURE);
767 768 769
            ret = 0;
            goto err;
        }
770 771

        CRYPTO_THREAD_write_lock(bio_lookup_lock);
772
        he_fallback_address = INADDR_ANY;
773 774 775 776 777 778 779 780 781 782
        if (host == NULL) {
            he = &he_fallback;
            switch(lookup_type) {
            case BIO_LOOKUP_CLIENT:
                he_fallback_address = INADDR_LOOPBACK;
                break;
            case BIO_LOOKUP_SERVER:
                he_fallback_address = INADDR_ANY;
                break;
            default:
783 784 785 786 787
                /* We forgot to handle a lookup type! */
                assert("We forgot to handle a lookup type!" == NULL);
                BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_INTERNAL_ERROR);
                ret = 0;
                goto err;
788 789 790 791 792
            }
        } else {
            he = gethostbyname(host);

            if (he == NULL) {
K
Kurt Roeckx 已提交
793
#ifndef OPENSSL_SYS_WINDOWS
794 795 796 797 798
                /*
                 * This might be misleading, because h_errno is used as if
                 * it was errno. To minimize mixup add 1000. Underlying
                 * reason for this is that hstrerror is declared obsolete,
                 * not to mention that a) h_errno is not always guaranteed
F
FdaSilvaYY 已提交
799
                 * to be meaningless; b) hstrerror can reside in yet another
800 801 802 803 804
                 * library, linking for sake of hstrerror is an overkill;
                 * c) this path is not executed on contemporary systems
                 * anyway [above getaddrinfo/gai_strerror is]. We just let
                 * system administrator figure this out...
                 */
805 806 807 808
# if defined(OPENSSL_SYS_VXWORKS)
                /* h_errno doesn't exist on VxWorks */
                SYSerr(SYS_F_GETHOSTBYNAME, 1000 );
# else
809
                SYSerr(SYS_F_GETHOSTBYNAME, 1000 + h_errno);
810
# endif
K
Kurt Roeckx 已提交
811 812 813
#else
                SYSerr(SYS_F_GETHOSTBYNAME, WSAGetLastError());
#endif
814 815 816 817 818 819 820
                ret = 0;
                goto err;
            }
        }

        if (service == NULL) {
            se_fallback.s_port = 0;
821
            se_fallback.s_proto = NULL;
822 823 824 825
            se = &se_fallback;
        } else {
            char *endp = NULL;
            long portnum = strtol(service, &endp, 10);
R
Richard Levitte 已提交
826 827 828 829 830 831 832 833 834

/*
 * Because struct servent is defined for 32-bit pointers only with
 * VMS C, we need to make sure that 'proto' is a 32-bit pointer.
 */
#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
# pragma pointer_size save
# pragma pointer_size 32
#endif
835
            char *proto = NULL;
R
Richard Levitte 已提交
836 837 838
#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
# pragma pointer_size restore
#endif
839 840 841 842 843 844 845 846 847

            switch (socktype) {
            case SOCK_STREAM:
                proto = "tcp";
                break;
            case SOCK_DGRAM:
                proto = "udp";
                break;
            }
848 849 850

            if (endp != service && *endp == '\0'
                    && portnum > 0 && portnum < 65536) {
851
                se_fallback.s_port = htons((unsigned short)portnum);
852 853 854 855 856 857
                se_fallback.s_proto = proto;
                se = &se_fallback;
            } else if (endp == service) {
                se = getservbyname(service, proto);

                if (se == NULL) {
K
Kurt Roeckx 已提交
858
#ifndef OPENSSL_SYS_WINDOWS
859
                    SYSerr(SYS_F_GETSERVBYNAME, errno);
K
Kurt Roeckx 已提交
860 861 862
#else
                    SYSerr(SYS_F_GETSERVBYNAME, WSAGetLastError());
#endif
863 864 865
                    goto err;
                }
            } else {
M
Matt Caswell 已提交
866
                BIOerr(BIO_F_BIO_LOOKUP_EX, BIO_R_MALFORMED_HOST_OR_SERVICE);
867 868 869 870 871 872 873
                goto err;
            }
        }

        *res = NULL;

        {
R
Richard Levitte 已提交
874 875 876 877 878 879 880 881 882
/*
 * Because hostent::h_addr_list is an array of 32-bit pointers with VMS C,
 * we must make sure our iterator designates the same element type, hence
 * the pointer size dance.
 */
#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
# pragma pointer_size save
# pragma pointer_size 32
#endif
883
            char **addrlistp;
R
Richard Levitte 已提交
884 885 886
#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
# pragma pointer_size restore
#endif
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
            size_t addresses;
            BIO_ADDRINFO *tmp_bai = NULL;

            /* The easiest way to create a linked list from an
               array is to start from the back */
            for(addrlistp = he->h_addr_list; *addrlistp != NULL;
                addrlistp++)
                ;

            for(addresses = addrlistp - he->h_addr_list;
                addrlistp--, addresses-- > 0; ) {
                if (!addrinfo_wrap(he->h_addrtype, socktype,
                                   *addrlistp, he->h_length,
                                   se->s_port, &tmp_bai))
                    goto addrinfo_malloc_err;
                tmp_bai->bai_next = *res;
                *res = tmp_bai;
                continue;
             addrinfo_malloc_err:
                BIO_ADDRINFO_free(*res);
                *res = NULL;
M
Matt Caswell 已提交
908
                BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_MALLOC_FAILURE);
909 910 911 912 913 914 915
                ret = 0;
                goto err;
            }

            ret = 1;
        }
     err:
916
        CRYPTO_THREAD_unlock(bio_lookup_lock);
917 918 919 920
    }

    return ret;
}
921

R
Rich Salz 已提交
922
#endif /* OPENSSL_NO_SOCK */