crypto/openssl/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     /* cast to short because of win16 winsock definition */
 151     if ((short)he->h_addrtype != AF_INET) {
 152         BIOerr(BIO_F_BIO_GET_HOST_IP,
 153                BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
 154         goto err;
 155     }
 156     for (i = 0; i < 4; i++)
 157         ip[i] = he->h_addr_list[0][i];
 158     err = 0;
 159
 160  err:
 161     if (locked)
 162         CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
 163     if (err) {
 164         ERR_add_error_data(2, "host=", str);
 165         return 0;
 166     } else
 167         return 1;
 168 }
 169
 170 int BIO_get_port(const char *str, unsigned short *port_ptr)
 171 {
 172     int i;
 173     struct servent *s;
 174
 175     if (str == NULL) {
 176         BIOerr(BIO_F_BIO_GET_PORT, BIO_R_NO_PORT_DEFINED);
 177         return (0);
 178     }
 179     i = atoi(str);
 180     if (i != 0)
 181         *port_ptr = (unsigned short)i;
 182     else {
 183         CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
 184         /*
 185          * Note: under VMS with SOCKETSHR, it seems like the first parameter
 186          * is 'char *', instead of 'const char *'
 187          */
 188 # ifndef CONST_STRICT
 189         s = getservbyname((char *)str, "tcp");
 190 # else
 191         s = getservbyname(str, "tcp");
 192 # endif
 193         if (s != NULL)
 194             *port_ptr = ntohs((unsigned short)s->s_port);
 195         CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
 196         if (s == NULL) {
 197             if (strcmp(str, "http") == 0)
 198                 *port_ptr = 80;
 199             else if (strcmp(str, "telnet") == 0)
 200                 *port_ptr = 23;
 201             else if (strcmp(str, "socks") == 0)
 202                 *port_ptr = 1080;
 203             else if (strcmp(str, "https") == 0)
 204                 *port_ptr = 443;
 205             else if (strcmp(str, "ssl") == 0)
 206                 *port_ptr = 443;
 207             else if (strcmp(str, "ftp") == 0)
 208                 *port_ptr = 21;
 209             else if (strcmp(str, "gopher") == 0)
 210                 *port_ptr = 70;
 211 # if 0
 212             else if (strcmp(str, "wais") == 0)
 213                 *port_ptr = 21;
 214 # endif
 215             else {
 216                 SYSerr(SYS_F_GETSERVBYNAME, get_last_socket_error());
 217                 ERR_add_error_data(3, "service='", str, "'");
 218                 return (0);
 219             }
 220         }
 221     }
 222     return (1);
 223 }
 224
 225 int BIO_sock_error(int sock)
 226 {
 227     int j, i;
 228     int size;
 229
 230 # if defined(OPENSSL_SYS_BEOS_R5)
 231     return 0;
 232 # endif
 233
 234     size = sizeof(int);
 235     /*
 236      * Note: under Windows the third parameter is of type (char *) whereas
 237      * under other systems it is (void *) if you don't have a cast it will
 238      * choke the compiler: if you do have a cast then you can either go for
 239      * (char *) or (void *).
 240      */
 241     i = getsockopt(sock, SOL_SOCKET, SO_ERROR, (void *)&j, (void *)&size);
 242     if (i < 0)
 243         return (1);
 244     else
 245         return (j);
 246 }
 247
 248 # if 0
 249 long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
 250 {
 251     int i;
 252     char **p;
 253
 254     switch (cmd) {
 255     case BIO_GHBN_CTRL_HITS:
 256         return (BIO_ghbn_hits);
 257         /* break; */
 258     case BIO_GHBN_CTRL_MISSES:
 259         return (BIO_ghbn_miss);
 260         /* break; */
 261     case BIO_GHBN_CTRL_CACHE_SIZE:
 262         return (GHBN_NUM);
 263         /* break; */
 264     case BIO_GHBN_CTRL_GET_ENTRY:
 265         if ((iarg >= 0) && (iarg < GHBN_NUM) && (ghbn_cache[iarg].order > 0)) {
 266             p = (char **)parg;
 267             if (p == NULL)
 268                 return (0);
 269             *p = ghbn_cache[iarg].name;
 270             ghbn_cache[iarg].name[128] = '\0';
 271             return (1);
 272         }
 273         return (0);
 274         /* break; */
 275     case BIO_GHBN_CTRL_FLUSH:
 276         for (i = 0; i < GHBN_NUM; i++)
 277             ghbn_cache[i].order = 0;
 278         break;
 279     default:
 280         return (0);
 281     }
 282     return (1);
 283 }
 284 # endif
 285
 286 # if 0
 287 static struct hostent *ghbn_dup(struct hostent *a)
 288 {
 289     struct hostent *ret;
 290     int i, j;
 291
 292     MemCheck_off();
 293     ret = (struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
 294     if (ret == NULL)
 295         return (NULL);
 296     memset(ret, 0, sizeof(struct hostent));
 297
 298     for (i = 0; a->h_aliases[i] != NULL; i++) ;
 299     i++;
 300     ret->h_aliases = (char **)OPENSSL_malloc(i * sizeof(char *));
 301     if (ret->h_aliases == NULL)
 302         goto err;
 303     memset(ret->h_aliases, 0, i * sizeof(char *));
 304
 305     for (i = 0; a->h_addr_list[i] != NULL; i++) ;
 306     i++;
 307     ret->h_addr_list = (char **)OPENSSL_malloc(i * sizeof(char *));
 308     if (ret->h_addr_list == NULL)
 309         goto err;
 310     memset(ret->h_addr_list, 0, i * sizeof(char *));
 311
 312     j = strlen(a->h_name) + 1;
 313     if ((ret->h_name = OPENSSL_malloc(j)) == NULL)
 314         goto err;
 315     memcpy((char *)ret->h_name, a->h_name, j);
 316     for (i = 0; a->h_aliases[i] != NULL; i++) {
 317         j = strlen(a->h_aliases[i]) + 1;
 318         if ((ret->h_aliases[i] = OPENSSL_malloc(j)) == NULL)
 319             goto err;
 320         memcpy(ret->h_aliases[i], a->h_aliases[i], j);
 321     }
 322     ret->h_length = a->h_length;
 323     ret->h_addrtype = a->h_addrtype;
 324     for (i = 0; a->h_addr_list[i] != NULL; i++) {
 325         if ((ret->h_addr_list[i] = OPENSSL_malloc(a->h_length)) == NULL)
 326             goto err;
 327         memcpy(ret->h_addr_list[i], a->h_addr_list[i], a->h_length);
 328     }
 329     if (0) {
 330  err:
 331         if (ret != NULL)
 332             ghbn_free(ret);
 333         ret = NULL;
 334     }
 335     MemCheck_on();
 336     return (ret);
 337 }
 338
 339 static void ghbn_free(struct hostent *a)
 340 {
 341     int i;
 342
 343     if (a == NULL)
 344         return;
 345
 346     if (a->h_aliases != NULL) {
 347         for (i = 0; a->h_aliases[i] != NULL; i++)
 348             OPENSSL_free(a->h_aliases[i]);
 349         OPENSSL_free(a->h_aliases);
 350     }
 351     if (a->h_addr_list != NULL) {
 352         for (i = 0; a->h_addr_list[i] != NULL; i++)
 353             OPENSSL_free(a->h_addr_list[i]);
 354         OPENSSL_free(a->h_addr_list);
 355     }
 356     if (a->h_name != NULL)
 357         OPENSSL_free(a->h_name);
 358     OPENSSL_free(a);
 359 }
 360
 361 # endif
 362
 363 struct hostent *BIO_gethostbyname(const char *name)
 364 {
 365 # if 1
 366     /*
 367      * Caching gethostbyname() results forever is wrong, so we have to let
 368      * the true gethostbyname() worry about this
 369      */
 370 #  if (defined(NETWARE_BSDSOCK) && !defined(__NOVELL_LIBC__))
 371     return gethostbyname((char *)name);
 372 #  else
 373     return gethostbyname(name);
 374 #  endif
 375 # else
 376     struct hostent *ret;
 377     int i, lowi = 0, j;
 378     unsigned long low = (unsigned long)-1;
 379
 380 #  if 0
 381     /*
 382      * It doesn't make sense to use locking here: The function interface is
 383      * not thread-safe, because threads can never be sure when some other
 384      * thread destroys the data they were given a pointer to.
 385      */
 386     CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
 387 #  endif
 388     j = strlen(name);
 389     if (j < 128) {
 390         for (i = 0; i < GHBN_NUM; i++) {
 391             if (low > ghbn_cache[i].order) {
 392                 low = ghbn_cache[i].order;
 393                 lowi = i;
 394             }
 395             if (ghbn_cache[i].order > 0) {
 396                 if (strncmp(name, ghbn_cache[i].name, 128) == 0)
 397                     break;
 398             }
 399         }
 400     } else
 401         i = GHBN_NUM;
 402
 403     if (i == GHBN_NUM) {        /* no hit */
 404         BIO_ghbn_miss++;
 405         /*
 406          * Note: under VMS with SOCKETSHR, it seems like the first parameter
 407          * is 'char *', instead of 'const char *'
 408          */
 409 #  ifndef CONST_STRICT
 410         ret = gethostbyname((char *)name);
 411 #  else
 412         ret = gethostbyname(name);
 413 #  endif
 414
 415         if (ret == NULL)
 416             goto end;
 417         if (j > 128) {          /* too big to cache */
 418 #  if 0
 419             /*
 420              * If we were trying to make this function thread-safe (which is
 421              * bound to fail), we'd have to give up in this case (or allocate
 422              * more memory).
 423              */
 424             ret = NULL;
 425 #  endif
 426             goto end;
 427         }
 428
 429         /* else add to cache */
 430         if (ghbn_cache[lowi].ent != NULL)
 431             ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
 432         ghbn_cache[lowi].name[0] = '\0';
 433
 434         if ((ret = ghbn_cache[lowi].ent = ghbn_dup(ret)) == NULL) {
 435             BIOerr(BIO_F_BIO_GETHOSTBYNAME, ERR_R_MALLOC_FAILURE);
 436             goto end;
 437         }
 438         strncpy(ghbn_cache[lowi].name, name, 128);
 439         ghbn_cache[lowi].order = BIO_ghbn_miss + BIO_ghbn_hits;
 440     } else {
 441         BIO_ghbn_hits++;
 442         ret = ghbn_cache[i].ent;
 443         ghbn_cache[i].order = BIO_ghbn_miss + BIO_ghbn_hits;
 444     }
 445  end:
 446 #  if 0
 447     CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
 448 #  endif
 449     return (ret);
 450 # endif
 451 }
 452
 453 int BIO_sock_init(void)
 454 {
 455 # ifdef OPENSSL_SYS_WINDOWS
 456     static struct WSAData wsa_state;
 457
 458     if (!wsa_init_done) {
 459         int err;
 460
 461         wsa_init_done = 1;
 462         memset(&wsa_state, 0, sizeof(wsa_state));
 463         /*
 464          * Not making wsa_state available to the rest of the code is formally
 465          * wrong. But the structures we use are [beleived to be] invariable
 466          * among Winsock DLLs, while API availability is [expected to be]
 467          * probed at run-time with DSO_global_lookup.
 468          */
 469         if (WSAStartup(0x0202, &wsa_state) != 0) {
 470             err = WSAGetLastError();
 471             SYSerr(SYS_F_WSASTARTUP, err);
 472             BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
 473             return (-1);
 474         }
 475     }
 476 # endif                         /* OPENSSL_SYS_WINDOWS */
 477 # ifdef WATT32
 478     extern int _watt_do_exit;
 479     _watt_do_exit = 0;          /* don't make sock_init() call exit() */
 480     if (sock_init())
 481         return (-1);
 482 # endif
 483
 484 # if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
 485     WORD wVerReq;
 486     WSADATA wsaData;
 487     int err;
 488
 489     if (!wsa_init_done) {
 490         wsa_init_done = 1;
 491         wVerReq = MAKEWORD(2, 0);
 492         err = WSAStartup(wVerReq, &wsaData);
 493         if (err != 0) {
 494             SYSerr(SYS_F_WSASTARTUP, err);
 495             BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
 496             return (-1);
 497         }
 498     }
 499 # endif
 500
 501     return (1);
 502 }
 503
 504 void BIO_sock_cleanup(void)
 505 {
 506 # ifdef OPENSSL_SYS_WINDOWS
 507     if (wsa_init_done) {
 508         wsa_init_done = 0;
 509 #  if 0                         /* this call is claimed to be non-present in
 510                                  * Winsock2 */
 511         WSACancelBlockingCall();
 512 #  endif
 513         WSACleanup();
 514     }
 515 # elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
 516     if (wsa_init_done) {
 517         wsa_init_done = 0;
 518         WSACleanup();
 519     }
 520 # endif
 521 }
 522
 523 # if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000
 524
 525 int BIO_socket_ioctl(int fd, long type, void *arg)
 526 {
 527     int i;
 528
 529 #  ifdef __DJGPP__
 530     i = ioctlsocket(fd, type, (char *)arg);
 531 #  else
 532 #   if defined(OPENSSL_SYS_VMS)
 533     /*-
 534      * 2011-02-18 SMS.
 535      * VMS ioctl() can't tolerate a 64-bit "void *arg", but we
 536      * observe that all the consumers pass in an "unsigned long *",
 537      * so we arrange a local copy with a short pointer, and use
 538      * that, instead.
 539      */
 540 #    if __INITIAL_POINTER_SIZE == 64
 541 #     define ARG arg_32p
 542 #     pragma pointer_size save
 543 #     pragma pointer_size 32
 544     unsigned long arg_32;
 545     unsigned long *arg_32p;
 546 #     pragma pointer_size restore
 547     arg_32p = &arg_32;
 548     arg_32 = *((unsigned long *)arg);
 549 #    else                       /* __INITIAL_POINTER_SIZE == 64 */
 550 #     define ARG arg
 551 #    endif                      /* __INITIAL_POINTER_SIZE == 64 [else] */
 552 #   else                        /* defined(OPENSSL_SYS_VMS) */
 553 #    define ARG arg
 554 #   endif                       /* defined(OPENSSL_SYS_VMS) [else] */
 555
 556     i = ioctlsocket(fd, type, ARG);
 557 #  endif                        /* __DJGPP__ */
 558     if (i < 0)
 559         SYSerr(SYS_F_IOCTLSOCKET, get_last_socket_error());
 560     return (i);
 561 }
 562 # endif                         /* __VMS_VER */
 563
 564 /*
 565  * The reason I have implemented this instead of using sscanf is because
 566  * Visual C 1.52c gives an unresolved external when linking a DLL :-(
 567  */
 568 static int get_ip(const char *str, unsigned char ip[4])
 569 {
 570     unsigned int tmp[4];
 571     int num = 0, c, ok = 0;
 572
 573     tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
 574
 575     for (;;) {
 576         c = *(str++);
 577         if ((c >= '0') && (c <= '9')) {
 578             ok = 1;
 579             tmp[num] = tmp[num] * 10 + c - '0';
 580             if (tmp[num] > 255)
 581                 return (0);
 582         } else if (c == '.') {
 583             if (!ok)
 584                 return (-1);
 585             if (num == 3)
 586                 return (0);
 587             num++;
 588             ok = 0;
 589         } else if (c == '\0' && (num == 3) && ok)
 590             break;
 591         else
 592             return (0);
 593     }
 594     ip[0] = tmp[0];
 595     ip[1] = tmp[1];
 596     ip[2] = tmp[2];
 597     ip[3] = tmp[3];
 598     return (1);
 599 }
 600
 601 int BIO_get_accept_socket(char *host, int bind_mode)
 602 {
 603     int ret = 0;
 604     union {
 605         struct sockaddr sa;
 606         struct sockaddr_in sa_in;
 607 # if OPENSSL_USE_IPV6
 608         struct sockaddr_in6 sa_in6;
 609 # endif
 610     } server, client;
 611     int s = INVALID_SOCKET, cs, addrlen;
 612     unsigned char ip[4];
 613     unsigned short port;
 614     char *str = NULL, *e;
 615     char *h, *p;
 616     unsigned long l;
 617     int err_num;
 618
 619     if (BIO_sock_init() != 1)
 620         return (INVALID_SOCKET);
 621
 622     if ((str = BUF_strdup(host)) == NULL)
 623         return (INVALID_SOCKET);
 624
 625     h = p = NULL;
 626     h = str;
 627     for (e = str; *e; e++) {
 628         if (*e == ':') {
 629             p = e;
 630         } else if (*e == '/') {
 631             *e = '\0';
 632             break;
 633         }
 634     }
 635     if (p)
 636         *p++ = '\0';            /* points at last ':', '::port' is special
 637                                  * [see below] */
 638     else
 639         p = h, h = NULL;
 640
 641 # ifdef EAI_FAMILY
 642     do {
 643         static union {
 644             void *p;
 645             int (WSAAPI *f) (const char *, const char *,
 646                              const struct addrinfo *, struct addrinfo **);
 647         } p_getaddrinfo = {
 648             NULL
 649         };
 650         static union {
 651             void *p;
 652             void (WSAAPI *f) (struct addrinfo *);
 653         } p_freeaddrinfo = {
 654             NULL
 655         };
 656         struct addrinfo *res, hint;
 657
 658         if (p_getaddrinfo.p == NULL) {
 659             if ((p_getaddrinfo.p = DSO_global_lookup("getaddrinfo")) == NULL
 660                 || (p_freeaddrinfo.p =
 661                     DSO_global_lookup("freeaddrinfo")) == NULL)
 662                 p_getaddrinfo.p = (void *)-1;
 663         }
 664         if (p_getaddrinfo.p == (void *)-1)
 665             break;
 666
 667         /*
 668          * '::port' enforces IPv6 wildcard listener. Some OSes, e.g. Solaris,
 669          * default to IPv6 without any hint. Also note that commonly IPv6
 670          * wildchard socket can service IPv4 connections just as well...
 671          */
 672         memset(&hint, 0, sizeof(hint));
 673         hint.ai_flags = AI_PASSIVE;
 674         if (h) {
 675             if (strchr(h, ':')) {
 676                 if (h[1] == '\0')
 677                     h = NULL;
 678 #  if OPENSSL_USE_IPV6
 679                 hint.ai_family = AF_INET6;
 680 #  else
 681                 h = NULL;
 682 #  endif
 683             } else if (h[0] == '*' && h[1] == '\0') {
 684                 hint.ai_family = AF_INET;
 685                 h = NULL;
 686             }
 687         }
 688
 689         if ((*p_getaddrinfo.f) (h, p, &hint, &res))
 690             break;
 691
 692         addrlen = res->ai_addrlen <= sizeof(server) ?
 693             res->ai_addrlen : sizeof(server);
 694         memcpy(&server, res->ai_addr, addrlen);
 695
 696         (*p_freeaddrinfo.f) (res);
 697         goto again;
 698     } while (0);
 699 # endif
 700
 701     if (!BIO_get_port(p, &port))
 702         goto err;
 703
 704     memset((char *)&server, 0, sizeof(server));
 705     server.sa_in.sin_family = AF_INET;
 706     server.sa_in.sin_port = htons(port);
 707     addrlen = sizeof(server.sa_in);
 708
 709     if (h == NULL || strcmp(h, "*") == 0)
 710         server.sa_in.sin_addr.s_addr = INADDR_ANY;
 711     else {
 712         if (!BIO_get_host_ip(h, &(ip[0])))
 713             goto err;
 714         l = (unsigned long)
 715             ((unsigned long)ip[0] << 24L) |
 716             ((unsigned long)ip[1] << 16L) |
 717             ((unsigned long)ip[2] << 8L) | ((unsigned long)ip[3]);
 718         server.sa_in.sin_addr.s_addr = htonl(l);
 719     }
 720
 721  again:
 722     s = socket(server.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
 723     if (s == INVALID_SOCKET) {
 724         SYSerr(SYS_F_SOCKET, get_last_socket_error());
 725         ERR_add_error_data(3, "port='", host, "'");
 726         BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET);
 727         goto err;
 728     }
 729 # ifdef SO_REUSEADDR
 730     if (bind_mode == BIO_BIND_REUSEADDR) {
 731         int i = 1;
 732
 733         ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&i, sizeof(i));
 734         bind_mode = BIO_BIND_NORMAL;
 735     }
 736 # endif
 737     if (bind(s, &server.sa, addrlen) == -1) {
 738 # ifdef SO_REUSEADDR
 739         err_num = get_last_socket_error();
 740         if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
 741 #  ifdef OPENSSL_SYS_WINDOWS
 742             /*
 743              * Some versions of Windows define EADDRINUSE to a dummy value.
 744              */
 745             (err_num == WSAEADDRINUSE))
 746 #  else
 747             (err_num == EADDRINUSE))
 748 #  endif
 749         {
 750             client = server;
 751             if (h == NULL || strcmp(h, "*") == 0) {
 752 #  if OPENSSL_USE_IPV6
 753                 if (client.sa.sa_family == AF_INET6) {
 754                     memset(&client.sa_in6.sin6_addr, 0,
 755                            sizeof(client.sa_in6.sin6_addr));
 756                     client.sa_in6.sin6_addr.s6_addr[15] = 1;
 757                 } else
 758 #  endif
 759                 if (client.sa.sa_family == AF_INET) {
 760                     client.sa_in.sin_addr.s_addr = htonl(0x7F000001);
 761                 } else
 762                     goto err;
 763             }
 764             cs = socket(client.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
 765             if (cs != INVALID_SOCKET) {
 766                 int ii;
 767                 ii = connect(cs, &client.sa, addrlen);
 768                 closesocket(cs);
 769                 if (ii == INVALID_SOCKET) {
 770                     bind_mode = BIO_BIND_REUSEADDR;
 771                     closesocket(s);
 772                     goto again;
 773                 }
 774                 /* else error */
 775             }
 776             /* else error */
 777         }
 778 # endif
 779         SYSerr(SYS_F_BIND, err_num);
 780         ERR_add_error_data(3, "port='", host, "'");
 781         BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_BIND_SOCKET);
 782         goto err;
 783     }
 784     if (listen(s, MAX_LISTEN) == -1) {
 785         SYSerr(SYS_F_BIND, get_last_socket_error());
 786         ERR_add_error_data(3, "port='", host, "'");
 787         BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_LISTEN_SOCKET);
 788         goto err;
 789     }
 790     ret = 1;
 791  err:
 792     if (str != NULL)
 793         OPENSSL_free(str);
 794     if ((ret == 0) && (s != INVALID_SOCKET)) {
 795         closesocket(s);
 796         s = INVALID_SOCKET;
 797     }
 798     return (s);
 799 }
 800
 801 int BIO_accept(int sock, char **addr)
 802 {
 803     int ret = INVALID_SOCKET;
 804     unsigned long l;
 805     unsigned short port;
 806     char *p;
 807
 808     struct {
 809         /*
 810          * As for following union. Trouble is that there are platforms
 811          * that have socklen_t and there are platforms that don't, on
 812          * some platforms socklen_t is int and on some size_t. So what
 813          * one can do? One can cook #ifdef spaghetti, which is nothing
 814          * but masochistic. Or one can do union between int and size_t.
 815          * One naturally does it primarily for 64-bit platforms where
 816          * sizeof(int) != sizeof(size_t). But would it work? Note that
 817          * if size_t member is initialized to 0, then later int member
 818          * assignment naturally does the job on little-endian platforms
 819          * regardless accept's expectations! What about big-endians?
 820          * If accept expects int*, then it works, and if size_t*, then
 821          * length value would appear as unreasonably large. But this
 822          * won't prevent it from filling in the address structure. The
 823          * trouble of course would be if accept returns more data than
 824          * actual buffer can accomodate and overwrite stack... That's
 825          * where early OPENSSL_assert comes into picture. Besides, the
 826          * only 64-bit big-endian platform found so far that expects
 827          * size_t* is HP-UX, where stack grows towards higher address.
 828          * <appro>
 829          */
 830         union {
 831             size_t s;
 832             int i;
 833         } len;
 834         union {
 835             struct sockaddr sa;
 836             struct sockaddr_in sa_in;
 837 # if OPENSSL_USE_IPV6
 838             struct sockaddr_in6 sa_in6;
 839 # endif
 840         } from;
 841     } sa;
 842
 843     sa.len.s = 0;
 844     sa.len.i = sizeof(sa.from);
 845     memset(&sa.from, 0, sizeof(sa.from));
 846     ret = accept(sock, &sa.from.sa, (void *)&sa.len);
 847     if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) {
 848         OPENSSL_assert(sa.len.s <= sizeof(sa.from));
 849         sa.len.i = (int)sa.len.s;
 850         /* use sa.len.i from this point */
 851     }
 852     if (ret == INVALID_SOCKET) {
 853         if (BIO_sock_should_retry(ret))
 854             return -2;
 855         SYSerr(SYS_F_ACCEPT, get_last_socket_error());
 856         BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR);
 857         goto end;
 858     }
 859
 860     if (addr == NULL)
 861         goto end;
 862
 863 # ifdef EAI_FAMILY
 864     do {
 865         char h[NI_MAXHOST], s[NI_MAXSERV];
 866         size_t nl;
 867         static union {
 868             void *p;
 869             int (WSAAPI *f) (const struct sockaddr *, size_t /* socklen_t */ ,
 870                              char *, size_t, char *, size_t, int);
 871         } p_getnameinfo = {
 872             NULL
 873         };
 874         /*
 875          * 2nd argument to getnameinfo is specified to be socklen_t.
 876          * Unfortunately there is a number of environments where socklen_t is
 877          * not defined. As it's passed by value, it's safe to pass it as
 878          * size_t... <appro>
 879          */
 880
 881         if (p_getnameinfo.p == NULL) {
 882             if ((p_getnameinfo.p = DSO_global_lookup("getnameinfo")) == NULL)
 883                 p_getnameinfo.p = (void *)-1;
 884         }
 885         if (p_getnameinfo.p == (void *)-1)
 886             break;
 887
 888         if ((*p_getnameinfo.f) (&sa.from.sa, sa.len.i, h, sizeof(h), s,
 889                                 sizeof(s), NI_NUMERICHOST | NI_NUMERICSERV))
 890             break;
 891         nl = strlen(h) + strlen(s) + 2;
 892         p = *addr;
 893         if (p) {
 894             *p = '\0';
 895             p = OPENSSL_realloc(p, nl);
 896         } else {
 897             p = OPENSSL_malloc(nl);
 898         }
 899         if (p == NULL) {
 900             BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
 901             goto end;
 902         }
 903         *addr = p;
 904         BIO_snprintf(*addr, nl, "%s:%s", h, s);
 905         goto end;
 906     } while (0);
 907 # endif
 908     if (sa.from.sa.sa_family != AF_INET)
 909         goto end;
 910     l = ntohl(sa.from.sa_in.sin_addr.s_addr);
 911     port = ntohs(sa.from.sa_in.sin_port);
 912     if (*addr == NULL) {
 913         if ((p = OPENSSL_malloc(24)) == NULL) {
 914             BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
 915             goto end;
 916         }
 917         *addr = p;
 918     }
 919     BIO_snprintf(*addr, 24, "%d.%d.%d.%d:%d",
 920                  (unsigned char)(l >> 24L) & 0xff,
 921                  (unsigned char)(l >> 16L) & 0xff,
 922                  (unsigned char)(l >> 8L) & 0xff,
 923                  (unsigned char)(l) & 0xff, port);
 924  end:
 925     return (ret);
 926 }
 927
 928 int BIO_set_tcp_ndelay(int s, int on)
 929 {
 930     int ret = 0;
 931 # if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
 932     int opt;
 933
 934 #  ifdef SOL_TCP
 935     opt = SOL_TCP;
 936 #  else
 937 #   ifdef IPPROTO_TCP
 938     opt = IPPROTO_TCP;
 939 #   endif
 940 #  endif
 941
 942     ret = setsockopt(s, opt, TCP_NODELAY, (char *)&on, sizeof(on));
 943 # endif
 944     return (ret == 0);
 945 }
 946
 947 int BIO_socket_nbio(int s, int mode)
 948 {
 949     int ret = -1;
 950     int l;
 951
 952     l = mode;
 953 # ifdef FIONBIO
 954     ret = BIO_socket_ioctl(s, FIONBIO, &l);
 955 # endif
 956     return (ret == 0);
 957 }
 958 #endif