crypto/bio/b_sock.c

   1 /* crypto/bio/b_sock.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <errno.h>
  62 #define USE_SOCKETS
  63 #include "cryptlib.h"
  64 #include <openssl/bio.h>
  65 #if defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_BSDSOCK)
  66 # include <netdb.h>
  67 # if defined(NETWARE_CLIB)
  68 #  include <sys/ioctl.h>
  69 NETDB_DEFINE_CONTEXT
  70 # endif
  71 #endif
  72 #ifndef OPENSSL_NO_SOCK
  73 # include <openssl/dso.h>
  74 # define SOCKET_PROTOCOL IPPROTO_TCP
  75 # ifdef SO_MAXCONN
  76 #  define MAX_LISTEN  SO_MAXCONN
  77 # elif defined(SOMAXCONN)
  78 #  define MAX_LISTEN  SOMAXCONN
  79 # else
  80 #  define MAX_LISTEN  32
  81 # endif
  82 # if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
  83 static int wsa_init_done = 0;
  84 # endif
  85
  86 /*
  87  * WSAAPI specifier is required to make indirect calls to run-time
  88  * linked WinSock 2 functions used in this module, to be specific
  89  * [get|free]addrinfo and getnameinfo. This is because WinSock uses
  90  * uses non-C calling convention, __stdcall vs. __cdecl, on x86
  91  * Windows. On non-WinSock platforms WSAAPI needs to be void.
  92  */
  93 # ifndef WSAAPI
  94 #  define WSAAPI
  95 # endif
  96
  97 # if 0
  98 static unsigned long BIO_ghbn_hits = 0L;
  99 static unsigned long BIO_ghbn_miss = 0L;
 100
 101 #  define GHBN_NUM        4
 102 static struct ghbn_cache_st {
 103     char name[129];
 104     struct hostent *ent;
 105     unsigned long order;
 106 } ghbn_cache[GHBN_NUM];
 107 # endif
 108
 109 static int get_ip(const char *str, unsigned char *ip);
 110 # if 0
 111 static void ghbn_free(struct hostent *a);
 112 static struct hostent *ghbn_dup(struct hostent *a);
 113 # endif
 114 int BIO_get_host_ip(const char *str, unsigned char *ip)
 115 {
 116     int i;
 117     int err = 1;
 118     int locked = 0;
 119     struct hostent *he;
 120
 121     i = get_ip(str, ip);
 122     if (i < 0) {
 123         BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_INVALID_IP_ADDRESS);
 124         goto err;
 125     }
 126
 127     /*
 128      * At this point, we have something that is most probably correct in some
 129      * way, so let's init the socket.
 130      */
 131     if (BIO_sock_init() != 1)
 132         return 0;               /* don't generate another error code here */
 133
 134     /*
 135      * If the string actually contained an IP address, we need not do
 136      * anything more
 137      */
 138     if (i > 0)
 139         return (1);
 140
 141     /* do a gethostbyname */
 142     CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
 143     locked = 1;
 144     he = BIO_gethostbyname(str);
 145     if (he == NULL) {
 146         BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_BAD_HOSTNAME_LOOKUP);
 147         goto err;
 148     }
 149
 150     if (he->h_addrtype != AF_INET) {
 151         BIOerr(BIO_F_BIO_GET_HOST_IP,
 152                BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
 153         goto err;
 154     }
 155     for (i = 0; i < 4; i++)
 156         ip[i] = he->h_addr_list[0][i];
 157     err = 0;
 158
 159  err:
 160     if (locked)
 161         CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
 162     if (err) {
 163         ERR_add_error_data(2, "host=", str);
 164         return 0;
 165     } else
 166         return 1;
 167 }
 168
 169 int BIO_get_port(const char *str, unsigned short *port_ptr)
 170 {
 171     int i;
 172     struct servent *s;
 173
 174     if (str == NULL) {
 175         BIOerr(BIO_F_BIO_GET_PORT, BIO_R_NO_PORT_DEFINED);
 176         return (0);
 177     }
 178     i = atoi(str);
 179     if (i != 0)
 180         *port_ptr = (unsigned short)i;
 181     else {
 182         CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
 183         /*
 184          * Note: under VMS with SOCKETSHR, it seems like the first parameter
 185          * is 'char *', instead of 'const char *'
 186          */
 187 # ifndef CONST_STRICT
 188         s = getservbyname((char *)str, "tcp");
 189 # else
 190         s = getservbyname(str, "tcp");
 191 # endif
 192         if (s != NULL)
 193             *port_ptr = ntohs((unsigned short)s->s_port);
 194         CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
 195         if (s == NULL) {
 196             if (strcmp(str, "http") == 0)
 197                 *port_ptr = 80;
 198             else if (strcmp(str, "telnet") == 0)
 199                 *port_ptr = 23;
 200             else if (strcmp(str, "socks") == 0)
 201                 *port_ptr = 1080;
 202             else if (strcmp(str, "https") == 0)
 203                 *port_ptr = 443;
 204             else if (strcmp(str, "ssl") == 0)
 205                 *port_ptr = 443;
 206             else if (strcmp(str, "ftp") == 0)
 207                 *port_ptr = 21;
 208             else if (strcmp(str, "gopher") == 0)
 209                 *port_ptr = 70;
 210 # if 0
 211             else if (strcmp(str, "wais") == 0)
 212                 *port_ptr = 21;
 213 # endif
 214             else {
 215                 SYSerr(SYS_F_GETSERVBYNAME, get_last_socket_error());
 216                 ERR_add_error_data(3, "service='", str, "'");
 217                 return (0);
 218             }
 219         }
 220     }
 221     return (1);
 222 }
 223
 224 int BIO_sock_error(int sock)
 225 {
 226     int j, i;
 227     union {
 228         size_t s;
 229         int i;
 230     } size;
 231
 232     /* heuristic way to adapt for platforms that expect 64-bit optlen */
 233     size.s = 0, size.i = sizeof(j);
 234     /*
 235      * Note: under Windows the third parameter is of type (char *) whereas
 236      * under other systems it is (void *) if you don't have a cast it will
 237      * choke the compiler: if you do have a cast then you can either go for
 238      * (char *) or (void *).
 239      */
 240     i = getsockopt(sock, SOL_SOCKET, SO_ERROR, (void *)&j, (void *)&size);
 241     if (i < 0)
 242         return (1);
 243     else
 244         return (j);
 245 }
 246
 247 # if 0
 248 long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
 249 {
 250     int i;
 251     char **p;
 252
 253     switch (cmd) {
 254     case BIO_GHBN_CTRL_HITS:
 255         return (BIO_ghbn_hits);
 256         /* break; */
 257     case BIO_GHBN_CTRL_MISSES:
 258         return (BIO_ghbn_miss);
 259         /* break; */
 260     case BIO_GHBN_CTRL_CACHE_SIZE:
 261         return (GHBN_NUM);
 262         /* break; */
 263     case BIO_GHBN_CTRL_GET_ENTRY:
 264         if ((iarg >= 0) && (iarg < GHBN_NUM) && (ghbn_cache[iarg].order > 0)) {
 265             p = (char **)parg;
 266             if (p == NULL)
 267                 return (0);
 268             *p = ghbn_cache[iarg].name;
 269             ghbn_cache[iarg].name[128] = '\0';
 270             return (1);
 271         }
 272         return (0);
 273         /* break; */
 274     case BIO_GHBN_CTRL_FLUSH:
 275         for (i = 0; i < GHBN_NUM; i++)
 276             ghbn_cache[i].order = 0;
 277         break;
 278     default:
 279         return (0);
 280     }
 281     return (1);
 282 }
 283 # endif
 284
 285 # if 0
 286 static struct hostent *ghbn_dup(struct hostent *a)
 287 {
 288     struct hostent *ret;
 289     int i, j;
 290
 291     MemCheck_off();
 292     ret = (struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
 293     if (ret == NULL)
 294         return (NULL);
 295     memset(ret, 0, sizeof(struct hostent));
 296
 297     for (i = 0; a->h_aliases[i] != NULL; i++) ;
 298     i++;
 299     ret->h_aliases = (char **)OPENSSL_malloc(i * sizeof(char *));
 300     if (ret->h_aliases == NULL)
 301         goto err;
 302     memset(ret->h_aliases, 0, i * sizeof(char *));
 303
 304     for (i = 0; a->h_addr_list[i] != NULL; i++) ;
 305     i++;
 306     ret->h_addr_list = (char **)OPENSSL_malloc(i * sizeof(char *));
 307     if (ret->h_addr_list == NULL)
 308         goto err;
 309     memset(ret->h_addr_list, 0, i * sizeof(char *));
 310
 311     j = strlen(a->h_name) + 1;
 312     if ((ret->h_name = OPENSSL_malloc(j)) == NULL)
 313         goto err;
 314     memcpy((char *)ret->h_name, a->h_name, j);
 315     for (i = 0; a->h_aliases[i] != NULL; i++) {
 316         j = strlen(a->h_aliases[i]) + 1;
 317         if ((ret->h_aliases[i] = OPENSSL_malloc(j)) == NULL)
 318             goto err;
 319         memcpy(ret->h_aliases[i], a->h_aliases[i], j);
 320     }
 321     ret->h_length = a->h_length;
 322     ret->h_addrtype = a->h_addrtype;
 323     for (i = 0; a->h_addr_list[i] != NULL; i++) {
 324         if ((ret->h_addr_list[i] = OPENSSL_malloc(a->h_length)) == NULL)
 325             goto err;
 326         memcpy(ret->h_addr_list[i], a->h_addr_list[i], a->h_length);
 327     }
 328     if (0) {
 329  err:
 330         if (ret != NULL)
 331             ghbn_free(ret);
 332         ret = NULL;
 333     }
 334     MemCheck_on();
 335     return (ret);
 336 }
 337
 338 static void ghbn_free(struct hostent *a)
 339 {
 340     int i;
 341
 342     if (a == NULL)
 343         return;
 344
 345     if (a->h_aliases != NULL) {
 346         for (i = 0; a->h_aliases[i] != NULL; i++)
 347             OPENSSL_free(a->h_aliases[i]);
 348         OPENSSL_free(a->h_aliases);
 349     }
 350     if (a->h_addr_list != NULL) {
 351         for (i = 0; a->h_addr_list[i] != NULL; i++)
 352             OPENSSL_free(a->h_addr_list[i]);
 353         OPENSSL_free(a->h_addr_list);
 354     }
 355     if (a->h_name != NULL)
 356         OPENSSL_free(a->h_name);
 357     OPENSSL_free(a);
 358 }
 359
 360 # endif
 361
 362 struct hostent *BIO_gethostbyname(const char *name)
 363 {
 364 # if 1
 365     /*
 366      * Caching gethostbyname() results forever is wrong, so we have to let
 367      * the true gethostbyname() worry about this
 368      */
 369 #  if (defined(NETWARE_BSDSOCK) && !defined(__NOVELL_LIBC__))
 370     return gethostbyname((char *)name);
 371 #  else
 372     return gethostbyname(name);
 373 #  endif
 374 # else
 375     struct hostent *ret;
 376     int i, lowi = 0, j;
 377     unsigned long low = (unsigned long)-1;
 378
 379 #  if 0
 380     /*
 381      * It doesn't make sense to use locking here: The function interface is
 382      * not thread-safe, because threads can never be sure when some other
 383      * thread destroys the data they were given a pointer to.
 384      */
 385     CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
 386 #  endif
 387     j = strlen(name);
 388     if (j < 128) {
 389         for (i = 0; i < GHBN_NUM; i++) {
 390             if (low > ghbn_cache[i].order) {
 391                 low = ghbn_cache[i].order;
 392                 lowi = i;
 393             }
 394             if (ghbn_cache[i].order > 0) {
 395                 if (strncmp(name, ghbn_cache[i].name, 128) == 0)
 396                     break;
 397             }
 398         }
 399     } else
 400         i = GHBN_NUM;
 401
 402     if (i == GHBN_NUM) {        /* no hit */
 403         BIO_ghbn_miss++;
 404         /*
 405          * Note: under VMS with SOCKETSHR, it seems like the first parameter
 406          * is 'char *', instead of 'const char *'
 407          */
 408 #  ifndef CONST_STRICT
 409         ret = gethostbyname((char *)name);
 410 #  else
 411         ret = gethostbyname(name);
 412 #  endif
 413
 414         if (ret == NULL)
 415             goto end;
 416         if (j > 128) {          /* too big to cache */
 417 #  if 0
 418             /*
 419              * If we were trying to make this function thread-safe (which is
 420              * bound to fail), we'd have to give up in this case (or allocate
 421              * more memory).
 422              */
 423             ret = NULL;
 424 #  endif
 425             goto end;
 426         }
 427
 428         /* else add to cache */
 429         if (ghbn_cache[lowi].ent != NULL)
 430             ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
 431         ghbn_cache[lowi].name[0] = '\0';
 432
 433         if ((ret = ghbn_cache[lowi].ent = ghbn_dup(ret)) == NULL) {
 434             BIOerr(BIO_F_BIO_GETHOSTBYNAME, ERR_R_MALLOC_FAILURE);
 435             goto end;
 436         }
 437         strncpy(ghbn_cache[lowi].name, name, 128);
 438         ghbn_cache[lowi].order = BIO_ghbn_miss + BIO_ghbn_hits;
 439     } else {
 440         BIO_ghbn_hits++;
 441         ret = ghbn_cache[i].ent;
 442         ghbn_cache[i].order = BIO_ghbn_miss + BIO_ghbn_hits;
 443     }
 444  end:
 445 #  if 0
 446     CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
 447 #  endif
 448     return (ret);
 449 # endif
 450 }
 451
 452 int BIO_sock_init(void)
 453 {
 454 # ifdef OPENSSL_SYS_WINDOWS
 455     static struct WSAData wsa_state;
 456
 457     if (!wsa_init_done) {
 458         int err;
 459
 460         wsa_init_done = 1;
 461         memset(&wsa_state, 0, sizeof(wsa_state));
 462         /*
 463          * Not making wsa_state available to the rest of the code is formally
 464          * wrong. But the structures we use are [beleived to be] invariable
 465          * among Winsock DLLs, while API availability is [expected to be]
 466          * probed at run-time with DSO_global_lookup.
 467          */
 468         if (WSAStartup(0x0202, &wsa_state) != 0) {
 469             err = WSAGetLastError();
 470             SYSerr(SYS_F_WSASTARTUP, err);
 471             BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
 472             return (-1);
 473         }
 474     }
 475 # endif                         /* OPENSSL_SYS_WINDOWS */
 476 # ifdef WATT32
 477     extern int _watt_do_exit;
 478     _watt_do_exit = 0;          /* don't make sock_init() call exit() */
 479     if (sock_init())
 480         return (-1);
 481 # endif
 482
 483 # if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
 484     WORD wVerReq;
 485     WSADATA wsaData;
 486     int err;
 487
 488     if (!wsa_init_done) {
 489         wsa_init_done = 1;
 490         wVerReq = MAKEWORD(2, 0);
 491         err = WSAStartup(wVerReq, &wsaData);
 492         if (err != 0) {
 493             SYSerr(SYS_F_WSASTARTUP, err);
 494             BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
 495             return (-1);
 496         }
 497     }
 498 # endif
 499
 500     return (1);
 501 }
 502
 503 void BIO_sock_cleanup(void)
 504 {
 505 # ifdef OPENSSL_SYS_WINDOWS
 506     if (wsa_init_done) {
 507         wsa_init_done = 0;
 508 #  if 0                         /* this call is claimed to be non-present in
 509                                  * Winsock2 */
 510         WSACancelBlockingCall();
 511 #  endif
 512         WSACleanup();
 513     }
 514 # elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
 515     if (wsa_init_done) {
 516         wsa_init_done = 0;
 517         WSACleanup();
 518     }
 519 # endif
 520 }
 521
 522 # if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000
 523
 524 int BIO_socket_ioctl(int fd, long type, void *arg)
 525 {
 526     int i;
 527
 528 #  ifdef __DJGPP__
 529     i = ioctlsocket(fd, type, (char *)arg);
 530 #  else
 531 #   if defined(OPENSSL_SYS_VMS)
 532         /*-
 533          * 2011-02-18 SMS.
 534          * VMS ioctl() can't tolerate a 64-bit "void *arg", but we
 535          * observe that all the consumers pass in an "unsigned long *",
 536          * so we arrange a local copy with a short pointer, and use
 537          * that, instead.
 538          */
 539 #    if __INITIAL_POINTER_SIZE == 64
 540 #     define ARG arg_32p
 541 #     pragma pointer_size save
 542 #     pragma pointer_size 32
 543     unsigned long arg_32;
 544     unsigned long *arg_32p;
 545 #     pragma pointer_size restore
 546     arg_32p = &arg_32;
 547     arg_32 = *((unsigned long *)arg);
 548 #    else                       /* __INITIAL_POINTER_SIZE == 64 */
 549 #     define ARG arg
 550 #    endif                      /* __INITIAL_POINTER_SIZE == 64 [else] */
 551 #   else                        /* defined(OPENSSL_SYS_VMS) */
 552 #    define ARG arg
 553 #   endif                       /* defined(OPENSSL_SYS_VMS) [else] */
 554
 555     i = ioctlsocket(fd, type, ARG);
 556 #  endif                        /* __DJGPP__ */
 557     if (i < 0)
 558         SYSerr(SYS_F_IOCTLSOCKET, get_last_socket_error());
 559     return (i);
 560 }
 561 # endif                         /* __VMS_VER */
 562
 563 /*
 564  * The reason I have implemented this instead of using sscanf is because
 565  * Visual C 1.52c gives an unresolved external when linking a DLL :-(
 566  */
 567 static int get_ip(const char *str, unsigned char ip[4])
 568 {
 569     unsigned int tmp[4];
 570     int num = 0, c, ok = 0;
 571
 572     tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
 573
 574     for (;;) {
 575         c = *(str++);
 576         if ((c >= '0') && (c <= '9')) {
 577             ok = 1;
 578             tmp[num] = tmp[num] * 10 + c - '0';
 579             if (tmp[num] > 255)
 580                 return (0);
 581         } else if (c == '.') {
 582             if (!ok)
 583                 return (-1);
 584             if (num == 3)
 585                 return (0);
 586             num++;
 587             ok = 0;
 588         } else if (c == '\0' && (num == 3) && ok)
 589             break;
 590         else
 591             return (0);
 592     }
 593     ip[0] = tmp[0];
 594     ip[1] = tmp[1];
 595     ip[2] = tmp[2];
 596     ip[3] = tmp[3];
 597     return (1);
 598 }
 599
 600 int BIO_get_accept_socket(char *host, int bind_mode)
 601 {
 602     int ret = 0;
 603     union {
 604         struct sockaddr sa;
 605         struct sockaddr_in sa_in;
 606 # if OPENSSL_USE_IPV6
 607         struct sockaddr_in6 sa_in6;
 608 # endif
 609     } server, client;
 610     int s = INVALID_SOCKET, cs, addrlen;
 611     unsigned char ip[4];
 612     unsigned short port;
 613     char *str = NULL, *e;
 614     char *h, *p;
 615     unsigned long l;
 616     int err_num;
 617
 618     if (BIO_sock_init() != 1)
 619         return (INVALID_SOCKET);
 620
 621     if ((str = BUF_strdup(host)) == NULL)
 622         return (INVALID_SOCKET);
 623
 624     h = p = NULL;
 625     h = str;
 626     for (e = str; *e; e++) {
 627         if (*e == ':') {
 628             p = e;
 629         } else if (*e == '/') {
 630             *e = '\0';
 631             break;
 632         }
 633     }
 634     if (p)
 635         *p++ = '\0';            /* points at last ':', '::port' is special
 636                                  * [see below] */
 637     else
 638         p = h, h = NULL;
 639
 640 # ifdef EAI_FAMILY
 641     do {
 642         static union {
 643             void *p;
 644             int (WSAAPI *f) (const char *, const char *,
 645                              const struct addrinfo *, struct addrinfo **);
 646         } p_getaddrinfo = {
 647             NULL
 648         };
 649         static union {
 650             void *p;
 651             void (WSAAPI *f) (struct addrinfo *);
 652         } p_freeaddrinfo = {
 653             NULL
 654         };
 655         struct addrinfo *res, hint;
 656
 657         if (p_getaddrinfo.p == NULL) {
 658             if ((p_getaddrinfo.p = DSO_global_lookup("getaddrinfo")) == NULL
 659                 || (p_freeaddrinfo.p =
 660                     DSO_global_lookup("freeaddrinfo")) == NULL)
 661                 p_getaddrinfo.p = (void *)-1;
 662         }
 663         if (p_getaddrinfo.p == (void *)-1)
 664             break;
 665
 666         /*
 667          * '::port' enforces IPv6 wildcard listener. Some OSes, e.g. Solaris,
 668          * default to IPv6 without any hint. Also note that commonly IPv6
 669          * wildchard socket can service IPv4 connections just as well...
 670          */
 671         memset(&hint, 0, sizeof(hint));
 672         hint.ai_flags = AI_PASSIVE;
 673         if (h) {
 674             if (strchr(h, ':')) {
 675                 if (h[1] == '\0')
 676                     h = NULL;
 677 #  if OPENSSL_USE_IPV6
 678                 hint.ai_family = AF_INET6;
 679 #  else
 680                 h = NULL;
 681 #  endif
 682             } else if (h[0] == '*' && h[1] == '\0') {
 683                 hint.ai_family = AF_INET;
 684                 h = NULL;
 685             }
 686         }
 687
 688         if ((*p_getaddrinfo.f) (h, p, &hint, &res))
 689             break;
 690
 691         addrlen = res->ai_addrlen <= sizeof(server) ?
 692             res->ai_addrlen : sizeof(server);
 693         memcpy(&server, res->ai_addr, addrlen);
 694
 695         (*p_freeaddrinfo.f) (res);
 696         goto again;
 697     } while (0);
 698 # endif
 699
 700     if (!BIO_get_port(p, &port))
 701         goto err;
 702
 703     memset((char *)&server, 0, sizeof(server));
 704     server.sa_in.sin_family = AF_INET;
 705     server.sa_in.sin_port = htons(port);
 706     addrlen = sizeof(server.sa_in);
 707
 708     if (h == NULL || strcmp(h, "*") == 0)
 709         server.sa_in.sin_addr.s_addr = INADDR_ANY;
 710     else {
 711         if (!BIO_get_host_ip(h, &(ip[0])))
 712             goto err;
 713         l = (unsigned long)
 714             ((unsigned long)ip[0] << 24L) |
 715             ((unsigned long)ip[1] << 16L) |
 716             ((unsigned long)ip[2] << 8L) | ((unsigned long)ip[3]);
 717         server.sa_in.sin_addr.s_addr = htonl(l);
 718     }
 719
 720  again:
 721     s = socket(server.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
 722     if (s == INVALID_SOCKET) {
 723         SYSerr(SYS_F_SOCKET, get_last_socket_error());
 724         ERR_add_error_data(3, "port='", host, "'");
 725         BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET);
 726         goto err;
 727     }
 728 # ifdef SO_REUSEADDR
 729     if (bind_mode == BIO_BIND_REUSEADDR) {
 730         int i = 1;
 731
 732         ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&i, sizeof(i));
 733         bind_mode = BIO_BIND_NORMAL;
 734     }
 735 # endif
 736     if (bind(s, &server.sa, addrlen) == -1) {
 737 # ifdef SO_REUSEADDR
 738         err_num = get_last_socket_error();
 739         if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
 740 #  ifdef OPENSSL_SYS_WINDOWS
 741             /*
 742              * Some versions of Windows define EADDRINUSE to a dummy value.
 743              */
 744             (err_num == WSAEADDRINUSE))
 745 #  else
 746             (err_num == EADDRINUSE))
 747 #  endif
 748         {
 749             client = server;
 750             if (h == NULL || strcmp(h, "*") == 0) {
 751 #  if OPENSSL_USE_IPV6
 752                 if (client.sa.sa_family == AF_INET6) {
 753                     memset(&client.sa_in6.sin6_addr, 0,
 754                            sizeof(client.sa_in6.sin6_addr));
 755                     client.sa_in6.sin6_addr.s6_addr[15] = 1;
 756                 } else
 757 #  endif
 758                 if (client.sa.sa_family == AF_INET) {
 759                     client.sa_in.sin_addr.s_addr = htonl(0x7F000001);
 760                 } else
 761                     goto err;
 762             }
 763             cs = socket(client.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
 764             if (cs != INVALID_SOCKET) {
 765                 int ii;
 766                 ii = connect(cs, &client.sa, addrlen);
 767                 closesocket(cs);
 768                 if (ii == INVALID_SOCKET) {
 769                     bind_mode = BIO_BIND_REUSEADDR;
 770                     closesocket(s);
 771                     goto again;
 772                 }
 773                 /* else error */
 774             }
 775             /* else error */
 776         }
 777 # endif
 778         SYSerr(SYS_F_BIND, err_num);
 779         ERR_add_error_data(3, "port='", host, "'");
 780         BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_BIND_SOCKET);
 781         goto err;
 782     }
 783     if (listen(s, MAX_LISTEN) == -1) {
 784         SYSerr(SYS_F_BIND, get_last_socket_error());
 785         ERR_add_error_data(3, "port='", host, "'");
 786         BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_LISTEN_SOCKET);
 787         goto err;
 788     }
 789     ret = 1;
 790  err:
 791     if (str != NULL)
 792         OPENSSL_free(str);
 793     if ((ret == 0) && (s != INVALID_SOCKET)) {
 794         closesocket(s);
 795         s = INVALID_SOCKET;
 796     }
 797     return (s);
 798 }
 799
 800 int BIO_accept(int sock, char **addr)
 801 {
 802     int ret = INVALID_SOCKET;
 803     unsigned long l;
 804     unsigned short port;
 805     char *p;
 806
 807     struct {
 808         /*
 809          * As for following union. Trouble is that there are platforms
 810          * that have socklen_t and there are platforms that don't, on
 811          * some platforms socklen_t is int and on some size_t. So what
 812          * one can do? One can cook #ifdef spaghetti, which is nothing
 813          * but masochistic. Or one can do union between int and size_t.
 814          * One naturally does it primarily for 64-bit platforms where
 815          * sizeof(int) != sizeof(size_t). But would it work? Note that
 816          * if size_t member is initialized to 0, then later int member
 817          * assignment naturally does the job on little-endian platforms
 818          * regardless accept's expectations! What about big-endians?
 819          * If accept expects int*, then it works, and if size_t*, then
 820          * length value would appear as unreasonably large. But this
 821          * won't prevent it from filling in the address structure. The
 822          * trouble of course would be if accept returns more data than
 823          * actual buffer can accomodate and overwrite stack... That's
 824          * where early OPENSSL_assert comes into picture. Besides, the
 825          * only 64-bit big-endian platform found so far that expects
 826          * size_t* is HP-UX, where stack grows towards higher address.
 827          * <appro>
 828          */
 829         union {
 830             size_t s;
 831             int i;
 832         } len;
 833         union {
 834             struct sockaddr sa;
 835             struct sockaddr_in sa_in;
 836 # if OPENSSL_USE_IPV6
 837             struct sockaddr_in6 sa_in6;
 838 # endif
 839         } from;
 840     } sa;
 841
 842     sa.len.s = 0;
 843     sa.len.i = sizeof(sa.from);
 844     memset(&sa.from, 0, sizeof(sa.from));
 845     ret = accept(sock, &sa.from.sa, (void *)&sa.len);
 846     if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) {
 847         OPENSSL_assert(sa.len.s <= sizeof(sa.from));
 848         sa.len.i = (int)sa.len.s;
 849         /* use sa.len.i from this point */
 850     }
 851     if (ret == INVALID_SOCKET) {
 852         if (BIO_sock_should_retry(ret))
 853             return -2;
 854         SYSerr(SYS_F_ACCEPT, get_last_socket_error());
 855         BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR);
 856         goto end;
 857     }
 858
 859     if (addr == NULL)
 860         goto end;
 861
 862 # ifdef EAI_FAMILY
 863     do {
 864         char h[NI_MAXHOST], s[NI_MAXSERV];
 865         size_t nl;
 866         static union {
 867             void *p;
 868             int (WSAAPI *f) (const struct sockaddr *, size_t /* socklen_t */ ,
 869                              char *, size_t, char *, size_t, int);
 870         } p_getnameinfo = {
 871             NULL
 872         };
 873         /*
 874          * 2nd argument to getnameinfo is specified to be socklen_t.
 875          * Unfortunately there is a number of environments where socklen_t is
 876          * not defined. As it's passed by value, it's safe to pass it as
 877          * size_t... <appro>
 878          */
 879
 880         if (p_getnameinfo.p == NULL) {
 881             if ((p_getnameinfo.p = DSO_global_lookup("getnameinfo")) == NULL)
 882                 p_getnameinfo.p = (void *)-1;
 883         }
 884         if (p_getnameinfo.p == (void *)-1)
 885             break;
 886
 887         if ((*p_getnameinfo.f) (&sa.from.sa, sa.len.i, h, sizeof(h), s,
 888                                 sizeof(s), NI_NUMERICHOST | NI_NUMERICSERV))
 889             break;
 890         nl = strlen(h) + strlen(s) + 2;
 891         p = *addr;
 892         if (p) {
 893             *p = '\0';
 894             p = OPENSSL_realloc(p, nl);
 895         } else {
 896             p = OPENSSL_malloc(nl);
 897         }
 898         if (p == NULL) {
 899             BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
 900             goto end;
 901         }
 902         *addr = p;
 903         BIO_snprintf(*addr, nl, "%s:%s", h, s);
 904         goto end;
 905     } while (0);
 906 # endif
 907     if (sa.from.sa.sa_family != AF_INET)
 908         goto end;
 909     l = ntohl(sa.from.sa_in.sin_addr.s_addr);
 910     port = ntohs(sa.from.sa_in.sin_port);
 911     if (*addr == NULL) {
 912         if ((p = OPENSSL_malloc(24)) == NULL) {
 913             BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
 914             goto end;
 915         }
 916         *addr = p;
 917     }
 918     BIO_snprintf(*addr, 24, "%d.%d.%d.%d:%d",
 919                  (unsigned char)(l >> 24L) & 0xff,
 920                  (unsigned char)(l >> 16L) & 0xff,
 921                  (unsigned char)(l >> 8L) & 0xff,
 922                  (unsigned char)(l) & 0xff, port);
 923  end:
 924     return (ret);
 925 }
 926
 927 int BIO_set_tcp_ndelay(int s, int on)
 928 {
 929     int ret = 0;
 930 # if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
 931     int opt;
 932
 933 #  ifdef SOL_TCP
 934     opt = SOL_TCP;
 935 #  else
 936 #   ifdef IPPROTO_TCP
 937     opt = IPPROTO_TCP;
 938 #   endif
 939 #  endif
 940
 941     ret = setsockopt(s, opt, TCP_NODELAY, (char *)&on, sizeof(on));
 942 # endif
 943     return (ret == 0);
 944 }
 945
 946 int BIO_socket_nbio(int s, int mode)
 947 {
 948     int ret = -1;
 949     int l;
 950
 951     l = mode;
 952 # ifdef FIONBIO
 953     ret = BIO_socket_ioctl(s, FIONBIO, &l);
 954 # endif
 955     return (ret == 0);
 956 }
 957 #endif