crypto/bio/bss_acpt.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <errno.h>
  12 #include "bio_lcl.h"
  13
  14 #ifndef OPENSSL_NO_SOCK
  15
  16 typedef struct bio_accept_st {
  17     int state;
  18     int accept_family;
  19     int bind_mode;     /* Socket mode for BIO_listen */
  20     int accepted_mode; /* Socket mode for BIO_accept (set on accepted sock) */
  21     char *param_addr;
  22     char *param_serv;
  23
  24     int accept_sock;
  25
  26     BIO_ADDRINFO *addr_first;
  27     const BIO_ADDRINFO *addr_iter;
  28     BIO_ADDR cache_accepting_addr;   /* Useful if we asked for port 0 */
  29     char *cache_accepting_name, *cache_accepting_serv;
  30     BIO_ADDR cache_peer_addr;
  31     char *cache_peer_name, *cache_peer_serv;
  32
  33     BIO *bio_chain;
  34 } BIO_ACCEPT;
  35
  36 static int acpt_write(BIO *h, const char *buf, int num);
  37 static int acpt_read(BIO *h, char *buf, int size);
  38 static int acpt_puts(BIO *h, const char *str);
  39 static long acpt_ctrl(BIO *h, int cmd, long arg1, void *arg2);
  40 static int acpt_new(BIO *h);
  41 static int acpt_free(BIO *data);
  42 static int acpt_state(BIO *b, BIO_ACCEPT *c);
  43 static void acpt_close_socket(BIO *data);
  44 static BIO_ACCEPT *BIO_ACCEPT_new(void);
  45 static void BIO_ACCEPT_free(BIO_ACCEPT *a);
  46
  47 # define ACPT_S_BEFORE                   1
  48 # define ACPT_S_GET_ADDR                 2
  49 # define ACPT_S_CREATE_SOCKET            3
  50 # define ACPT_S_LISTEN                   4
  51 # define ACPT_S_ACCEPT                   5
  52 # define ACPT_S_OK                       6
  53
  54 static const BIO_METHOD methods_acceptp = {
  55     BIO_TYPE_ACCEPT,
  56     "socket accept",
  57     acpt_write,
  58     acpt_read,
  59     acpt_puts,
  60     NULL,                       /* connect_gets, */
  61     acpt_ctrl,
  62     acpt_new,
  63     acpt_free,
  64     NULL,
  65 };
  66
  67 const BIO_METHOD *BIO_s_accept(void)
  68 {
  69     return (&methods_acceptp);
  70 }
  71
  72 static int acpt_new(BIO *bi)
  73 {
  74     BIO_ACCEPT *ba;
  75
  76     bi->init = 0;
  77     bi->num = (int)INVALID_SOCKET;
  78     bi->flags = 0;
  79     if ((ba = BIO_ACCEPT_new()) == NULL)
  80         return (0);
  81     bi->ptr = (char *)ba;
  82     ba->state = ACPT_S_BEFORE;
  83     bi->shutdown = 1;
  84     return (1);
  85 }
  86
  87 static BIO_ACCEPT *BIO_ACCEPT_new(void)
  88 {
  89     BIO_ACCEPT *ret;
  90
  91     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
  92         return (NULL);
  93     ret->accept_family = BIO_FAMILY_IPANY;
  94     ret->accept_sock = (int)INVALID_SOCKET;
  95     return (ret);
  96 }
  97
  98 static void BIO_ACCEPT_free(BIO_ACCEPT *a)
  99 {
 100     if (a == NULL)
 101         return;
 102
 103     OPENSSL_free(a->param_addr);
 104     OPENSSL_free(a->param_serv);
 105     BIO_ADDRINFO_free(a->addr_first);
 106     OPENSSL_free(a->cache_accepting_name);
 107     OPENSSL_free(a->cache_accepting_serv);
 108     OPENSSL_free(a->cache_peer_name);
 109     OPENSSL_free(a->cache_peer_serv);
 110     BIO_free(a->bio_chain);
 111     OPENSSL_free(a);
 112 }
 113
 114 static void acpt_close_socket(BIO *bio)
 115 {
 116     BIO_ACCEPT *c;
 117
 118     c = (BIO_ACCEPT *)bio->ptr;
 119     if (c->accept_sock != (int)INVALID_SOCKET) {
 120         shutdown(c->accept_sock, 2);
 121         closesocket(c->accept_sock);
 122         c->accept_sock = (int)INVALID_SOCKET;
 123         bio->num = (int)INVALID_SOCKET;
 124     }
 125 }
 126
 127 static int acpt_free(BIO *a)
 128 {
 129     BIO_ACCEPT *data;
 130
 131     if (a == NULL)
 132         return (0);
 133     data = (BIO_ACCEPT *)a->ptr;
 134
 135     if (a->shutdown) {
 136         acpt_close_socket(a);
 137         BIO_ACCEPT_free(data);
 138         a->ptr = NULL;
 139         a->flags = 0;
 140         a->init = 0;
 141     }
 142     return (1);
 143 }
 144
 145 static int acpt_state(BIO *b, BIO_ACCEPT *c)
 146 {
 147     BIO *bio = NULL, *dbio;
 148     int s = -1, ret = -1;
 149
 150     for (;;) {
 151         switch (c->state) {
 152         case ACPT_S_BEFORE:
 153             if (c->param_addr == NULL && c->param_serv == NULL) {
 154                 BIOerr(BIO_F_ACPT_STATE, BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED);
 155                 ERR_add_error_data(4,
 156                                    "hostname=", c->param_addr,
 157                                    " service=", c->param_serv);
 158                 goto exit_loop;
 159             }
 160
 161             /* Because we're starting a new bind, any cached name and serv
 162              * are now obsolete and need to be cleaned out.
 163              * QUESTION: should this be done in acpt_close_socket() instead?
 164              */
 165             OPENSSL_free(c->cache_accepting_name);
 166             c->cache_accepting_name = NULL;
 167             OPENSSL_free(c->cache_accepting_serv);
 168             c->cache_accepting_serv = NULL;
 169             OPENSSL_free(c->cache_peer_name);
 170             c->cache_peer_name = NULL;
 171             OPENSSL_free(c->cache_peer_serv);
 172             c->cache_peer_serv = NULL;
 173
 174             c->state = ACPT_S_GET_ADDR;
 175             break;
 176
 177         case ACPT_S_GET_ADDR:
 178             {
 179                 int family = AF_UNSPEC;
 180                 switch (c->accept_family) {
 181                 case BIO_FAMILY_IPV6:
 182                     if (1) { /* This is a trick we use to avoid bit rot.
 183                               * at least the "else" part will always be
 184                               * compiled.
 185                               */
 186 #ifdef AF_INET6
 187                         family = AF_INET6;
 188                     } else {
 189 #endif
 190                         BIOerr(BIO_F_ACPT_STATE, BIO_R_UNAVAILABLE_IP_FAMILY);
 191                         goto exit_loop;
 192                     }
 193                     break;
 194                 case BIO_FAMILY_IPV4:
 195                     family = AF_INET;
 196                     break;
 197                 case BIO_FAMILY_IPANY:
 198                     family = AF_UNSPEC;
 199                     break;
 200                 default:
 201                     BIOerr(BIO_F_ACPT_STATE, BIO_R_UNSUPPORTED_IP_FAMILY);
 202                     goto exit_loop;
 203                 }
 204                 if (BIO_lookup(c->param_addr, c->param_serv, BIO_LOOKUP_SERVER,
 205                                family, SOCK_STREAM, &c->addr_first) == 0)
 206                     goto exit_loop;
 207             }
 208             if (c->addr_first == NULL) {
 209                 BIOerr(BIO_F_ACPT_STATE, BIO_R_LOOKUP_RETURNED_NOTHING);
 210                 goto exit_loop;
 211             }
 212             /* We're currently not iterating, but set this as preparation
 213              * for possible future development in that regard
 214              */
 215             c->addr_iter = c->addr_first;
 216             c->state = ACPT_S_CREATE_SOCKET;
 217             break;
 218
 219         case ACPT_S_CREATE_SOCKET:
 220             ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
 221                              BIO_ADDRINFO_socktype(c->addr_iter),
 222                              BIO_ADDRINFO_protocol(c->addr_iter), 0);
 223             if (ret == (int)INVALID_SOCKET) {
 224                 SYSerr(SYS_F_SOCKET, get_last_socket_error());
 225                 ERR_add_error_data(4,
 226                                    "hostname=", c->param_addr,
 227                                    " service=", c->param_serv);
 228                 BIOerr(BIO_F_ACPT_STATE, BIO_R_UNABLE_TO_CREATE_SOCKET);
 229                 goto exit_loop;
 230             }
 231             c->accept_sock = ret;
 232             b->num = ret;
 233             c->state = ACPT_S_LISTEN;
 234             break;
 235
 236         case ACPT_S_LISTEN:
 237             {
 238                 if (!BIO_listen(c->accept_sock,
 239                                 BIO_ADDRINFO_address(c->addr_iter),
 240                                 c->bind_mode)) {
 241                     BIO_closesocket(c->accept_sock);
 242                     goto exit_loop;
 243                 }
 244             }
 245
 246             {
 247                 union BIO_sock_info_u info;
 248
 249                 info.addr = &c->cache_accepting_addr;
 250                 if (!BIO_sock_info(c->accept_sock, BIO_SOCK_INFO_ADDRESS,
 251                                    &info)) {
 252                     BIO_closesocket(c->accept_sock);
 253                     goto exit_loop;
 254                 }
 255             }
 256
 257             c->cache_accepting_name =
 258                 BIO_ADDR_hostname_string(&c->cache_accepting_addr, 1);
 259             c->cache_accepting_serv =
 260                 BIO_ADDR_service_string(&c->cache_accepting_addr, 1);
 261             c->state = ACPT_S_ACCEPT;
 262             s = -1;
 263             ret = 1;
 264             goto end;
 265
 266         case ACPT_S_ACCEPT:
 267             if (b->next_bio != NULL) {
 268                 c->state = ACPT_S_OK;
 269                 break;
 270             }
 271             BIO_clear_retry_flags(b);
 272             b->retry_reason = 0;
 273
 274             s = BIO_accept_ex(c->accept_sock, &c->cache_peer_addr,
 275                               c->accepted_mode);
 276
 277             /* If the returned socket is invalid, this might still be
 278              * retryable
 279              */
 280             if (s < 0) {
 281                 if (BIO_sock_should_retry(s)) {
 282                     BIO_set_retry_special(b);
 283                     b->retry_reason = BIO_RR_ACCEPT;
 284                     goto end;
 285                 }
 286             }
 287
 288             /* If it wasn't retryable, we fail */
 289             if (s < 0) {
 290                 ret = s;
 291                 goto exit_loop;
 292             }
 293
 294             bio = BIO_new_socket(s, BIO_CLOSE);
 295             if (bio == NULL)
 296                 goto exit_loop;
 297
 298             BIO_set_callback(bio, BIO_get_callback(b));
 299             BIO_set_callback_arg(bio, BIO_get_callback_arg(b));
 300
 301             /*
 302              * If the accept BIO has an bio_chain, we dup it and put the new
 303              * socket at the end.
 304              */
 305             if (c->bio_chain != NULL) {
 306                 if ((dbio = BIO_dup_chain(c->bio_chain)) == NULL)
 307                     goto exit_loop;
 308                 if (!BIO_push(dbio, bio))
 309                     goto exit_loop;
 310                 bio = dbio;
 311             }
 312             if (BIO_push(b, bio) == NULL)
 313                 goto exit_loop;
 314
 315             c->cache_peer_name =
 316                 BIO_ADDR_hostname_string(&c->cache_peer_addr, 1);
 317             c->cache_peer_serv =
 318                 BIO_ADDR_service_string(&c->cache_peer_addr, 1);
 319             c->state = ACPT_S_OK;
 320             bio = NULL;
 321             ret = 1;
 322             goto end;
 323
 324         case ACPT_S_OK:
 325             if (b->next_bio == NULL) {
 326                 c->state = ACPT_S_ACCEPT;
 327                 break;
 328             }
 329             ret = 1;
 330             goto end;
 331
 332         default:
 333             ret = 0;
 334             goto end;
 335         }
 336     }
 337
 338   exit_loop:
 339     if (bio != NULL)
 340         BIO_free(bio);
 341     else if (s >= 0)
 342         BIO_closesocket(s);
 343   end:
 344     return ret;
 345 }
 346
 347 static int acpt_read(BIO *b, char *out, int outl)
 348 {
 349     int ret = 0;
 350     BIO_ACCEPT *data;
 351
 352     BIO_clear_retry_flags(b);
 353     data = (BIO_ACCEPT *)b->ptr;
 354
 355     while (b->next_bio == NULL) {
 356         ret = acpt_state(b, data);
 357         if (ret <= 0)
 358             return (ret);
 359     }
 360
 361     ret = BIO_read(b->next_bio, out, outl);
 362     BIO_copy_next_retry(b);
 363     return (ret);
 364 }
 365
 366 static int acpt_write(BIO *b, const char *in, int inl)
 367 {
 368     int ret;
 369     BIO_ACCEPT *data;
 370
 371     BIO_clear_retry_flags(b);
 372     data = (BIO_ACCEPT *)b->ptr;
 373
 374     while (b->next_bio == NULL) {
 375         ret = acpt_state(b, data);
 376         if (ret <= 0)
 377             return (ret);
 378     }
 379
 380     ret = BIO_write(b->next_bio, in, inl);
 381     BIO_copy_next_retry(b);
 382     return (ret);
 383 }
 384
 385 static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
 386 {
 387     int *ip;
 388     long ret = 1;
 389     BIO_ACCEPT *data;
 390     char **pp;
 391
 392     data = (BIO_ACCEPT *)b->ptr;
 393
 394     switch (cmd) {
 395     case BIO_CTRL_RESET:
 396         ret = 0;
 397         data->state = ACPT_S_BEFORE;
 398         acpt_close_socket(b);
 399         BIO_ADDRINFO_free(data->addr_first);
 400         data->addr_first = NULL;
 401         b->flags = 0;
 402         break;
 403     case BIO_C_DO_STATE_MACHINE:
 404         /* use this one to start the connection */
 405         ret = (long)acpt_state(b, data);
 406         break;
 407     case BIO_C_SET_ACCEPT:
 408         if (ptr != NULL) {
 409             if (num == 0) {
 410                 char *hold_serv = data->param_serv;
 411                 /* We affect the hostname regardless.  However, the input
 412                  * string might contain a host:service spec, so we must
 413                  * parse it, which might or might not affect the service
 414                  */
 415                 OPENSSL_free(data->param_addr);
 416                 data->param_addr = NULL;
 417                 ret = BIO_parse_hostserv(ptr,
 418                                          &data->param_addr,
 419                                          &data->param_serv,
 420                                          BIO_PARSE_PRIO_SERV);
 421                 if (hold_serv != data->param_serv)
 422                     OPENSSL_free(hold_serv);
 423                 b->init = 1;
 424             } else if (num == 1) {
 425                 OPENSSL_free(data->param_serv);
 426                 data->param_serv = BUF_strdup(ptr);
 427                 b->init = 1;
 428             } else if (num == 2) {
 429                 data->bind_mode |= BIO_SOCK_NONBLOCK;
 430             } else if (num == 3) {
 431                 BIO_free(data->bio_chain);
 432                 data->bio_chain = (BIO *)ptr;
 433             } else if (num == 4) {
 434                 data->accept_family = *(int *)ptr;
 435             }
 436         } else {
 437             if (num == 2) {
 438                 data->bind_mode &= ~BIO_SOCK_NONBLOCK;
 439             }
 440         }
 441         break;
 442     case BIO_C_SET_NBIO:
 443         if (num != 0)
 444             data->accepted_mode |= BIO_SOCK_NONBLOCK;
 445         else
 446             data->accepted_mode &= ~BIO_SOCK_NONBLOCK;
 447         break;
 448     case BIO_C_SET_FD:
 449         b->init = 1;
 450         b->num = *((int *)ptr);
 451         data->accept_sock = b->num;
 452         data->state = ACPT_S_ACCEPT;
 453         b->shutdown = (int)num;
 454         b->init = 1;
 455         break;
 456     case BIO_C_GET_FD:
 457         if (b->init) {
 458             ip = (int *)ptr;
 459             if (ip != NULL)
 460                 *ip = data->accept_sock;
 461             ret = data->accept_sock;
 462         } else
 463             ret = -1;
 464         break;
 465     case BIO_C_GET_ACCEPT:
 466         if (b->init) {
 467             if (num == 0 && ptr != NULL) {
 468                 pp = (char **)ptr;
 469                 *pp = data->cache_accepting_name;
 470             } else if (num == 1 && ptr != NULL) {
 471                 pp = (char **)ptr;
 472                 *pp = data->cache_accepting_serv;
 473             } else if (num == 2 && ptr != NULL) {
 474                 pp = (char **)ptr;
 475                 *pp = data->cache_peer_name;
 476             } else if (num == 3 && ptr != NULL) {
 477                 pp = (char **)ptr;
 478                 *pp = data->cache_peer_serv;
 479             } else if (num == 4) {
 480                 switch (BIO_ADDRINFO_family(data->addr_iter)) {
 481 #ifdef AF_INET6
 482                 case AF_INET6:
 483                     ret = BIO_FAMILY_IPV6;
 484                     break;
 485 #endif
 486                 case AF_INET:
 487                     ret = BIO_FAMILY_IPV4;
 488                     break;
 489                 case 0:
 490                     ret = data->accept_family;
 491                     break;
 492                 default:
 493                     ret = -1;
 494                     break;
 495                 }
 496             } else
 497                 ret = -1;
 498         } else
 499             ret = -1;
 500         break;
 501     case BIO_CTRL_GET_CLOSE:
 502         ret = b->shutdown;
 503         break;
 504     case BIO_CTRL_SET_CLOSE:
 505         b->shutdown = (int)num;
 506         break;
 507     case BIO_CTRL_PENDING:
 508     case BIO_CTRL_WPENDING:
 509         ret = 0;
 510         break;
 511     case BIO_CTRL_FLUSH:
 512         break;
 513     case BIO_C_SET_BIND_MODE:
 514         data->bind_mode = (int)num;
 515         break;
 516     case BIO_C_GET_BIND_MODE:
 517         ret = (long)data->bind_mode;
 518         break;
 519     case BIO_CTRL_DUP:
 520 /*-     dbio=(BIO *)ptr;
 521         if (data->param_port) EAY EAY
 522                 BIO_set_port(dbio,data->param_port);
 523         if (data->param_hostname)
 524                 BIO_set_hostname(dbio,data->param_hostname);
 525         BIO_set_nbio(dbio,data->nbio); */
 526         break;
 527
 528     default:
 529         ret = 0;
 530         break;
 531     }
 532     return (ret);
 533 }
 534
 535 static int acpt_puts(BIO *bp, const char *str)
 536 {
 537     int n, ret;
 538
 539     n = strlen(str);
 540     ret = acpt_write(bp, str, n);
 541     return (ret);
 542 }
 543
 544 BIO *BIO_new_accept(const char *str)
 545 {
 546     BIO *ret;
 547
 548     ret = BIO_new(BIO_s_accept());
 549     if (ret == NULL)
 550         return (NULL);
 551     if (BIO_set_accept_port(ret, str))
 552         return (ret);
 553     BIO_free(ret);
 554     return (NULL);
 555 }
 556
 557 #endif