crypto/bio/bss_conn.c

   1 /*
   2  * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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
  13 #include "bio_local.h"
  14 #include "internal/bio_tfo.h"
  15 #include "internal/ktls.h"
  16
  17 #ifndef OPENSSL_NO_SOCK
  18
  19 typedef struct bio_connect_st {
  20     int state;
  21     int connect_family;
  22     int connect_sock_type;
  23     char *param_hostname;
  24     char *param_service;
  25     int connect_mode;
  26 # ifndef OPENSSL_NO_KTLS
  27     unsigned char record_type;
  28 # endif
  29     int tfo_first;
  30
  31     BIO_ADDRINFO *addr_first;
  32     const BIO_ADDRINFO *addr_iter;
  33     /*
  34      * int socket; this will be kept in bio->num so that it is compatible
  35      * with the bss_sock bio
  36      */
  37     /*
  38      * called when the connection is initially made callback(BIO,state,ret);
  39      * The callback should return 'ret'.  state is for compatibility with the
  40      * ssl info_callback
  41      */
  42     BIO_info_cb *info_callback;
  43     /*
  44      * Used when connect_sock_type is SOCK_DGRAM. Owned by us; we forward
  45      * read/write(mmsg) calls to this if present.
  46      */
  47     BIO *dgram_bio;
  48 } BIO_CONNECT;
  49
  50 static int conn_write(BIO *h, const char *buf, int num);
  51 static int conn_read(BIO *h, char *buf, int size);
  52 static int conn_puts(BIO *h, const char *str);
  53 static int conn_gets(BIO *h, char *buf, int size);
  54 static long conn_ctrl(BIO *h, int cmd, long arg1, void *arg2);
  55 static int conn_new(BIO *h);
  56 static int conn_free(BIO *data);
  57 static long conn_callback_ctrl(BIO *h, int cmd, BIO_info_cb *);
  58 static int conn_sendmmsg(BIO *h, BIO_MSG *m, size_t s, size_t n,
  59                          uint64_t f, size_t *mp);
  60 static int conn_recvmmsg(BIO *h, BIO_MSG *m, size_t s, size_t n,
  61                          uint64_t f, size_t *mp);
  62
  63 static int conn_state(BIO *b, BIO_CONNECT *c);
  64 static void conn_close_socket(BIO *data);
  65 static BIO_CONNECT *BIO_CONNECT_new(void);
  66 static void BIO_CONNECT_free(BIO_CONNECT *a);
  67
  68 #define BIO_CONN_S_BEFORE                1
  69 #define BIO_CONN_S_GET_ADDR              2
  70 #define BIO_CONN_S_CREATE_SOCKET         3
  71 #define BIO_CONN_S_CONNECT               4
  72 #define BIO_CONN_S_OK                    5
  73 #define BIO_CONN_S_BLOCKED_CONNECT       6
  74 #define BIO_CONN_S_CONNECT_ERROR         7
  75
  76 static const BIO_METHOD methods_connectp = {
  77     BIO_TYPE_CONNECT,
  78     "socket connect",
  79     bwrite_conv,
  80     conn_write,
  81     bread_conv,
  82     conn_read,
  83     conn_puts,
  84     conn_gets,
  85     conn_ctrl,
  86     conn_new,
  87     conn_free,
  88     conn_callback_ctrl,
  89     conn_sendmmsg,
  90     conn_recvmmsg,
  91 };
  92
  93 static int conn_create_dgram_bio(BIO *b, BIO_CONNECT *c)
  94 {
  95     if (c->connect_sock_type != SOCK_DGRAM)
  96         return 1;
  97
  98 #ifndef OPENSSL_NO_DGRAM
  99     c->dgram_bio = BIO_new_dgram(b->num, 0);
 100     if (c->dgram_bio == NULL)
 101         goto err;
 102
 103     return 1;
 104
 105 err:
 106 #endif
 107     c->state = BIO_CONN_S_CONNECT_ERROR;
 108     return 0;
 109 }
 110
 111 static int conn_state(BIO *b, BIO_CONNECT *c)
 112 {
 113     int ret = -1, i;
 114     BIO_info_cb *cb = NULL;
 115
 116     if (c->info_callback != NULL)
 117         cb = c->info_callback;
 118
 119     for (;;) {
 120         switch (c->state) {
 121         case BIO_CONN_S_BEFORE:
 122             if (c->param_hostname == NULL && c->param_service == NULL) {
 123                 ERR_raise_data(ERR_LIB_BIO,
 124                                BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED,
 125                                "hostname=%s service=%s",
 126                                c->param_hostname, c->param_service);
 127                 goto exit_loop;
 128             }
 129             c->state = BIO_CONN_S_GET_ADDR;
 130             break;
 131
 132         case BIO_CONN_S_GET_ADDR:
 133             {
 134                 int family = AF_UNSPEC;
 135                 switch (c->connect_family) {
 136                 case BIO_FAMILY_IPV6:
 137                     if (1) { /* This is a trick we use to avoid bit rot.
 138                               * at least the "else" part will always be
 139                               * compiled.
 140                               */
 141 #if OPENSSL_USE_IPV6
 142                         family = AF_INET6;
 143                     } else {
 144 #endif
 145                         ERR_raise(ERR_LIB_BIO, BIO_R_UNAVAILABLE_IP_FAMILY);
 146                         goto exit_loop;
 147                     }
 148                     break;
 149                 case BIO_FAMILY_IPV4:
 150                     family = AF_INET;
 151                     break;
 152                 case BIO_FAMILY_IPANY:
 153                     family = AF_UNSPEC;
 154                     break;
 155                 default:
 156                     ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_IP_FAMILY);
 157                     goto exit_loop;
 158                 }
 159                 if (BIO_lookup(c->param_hostname, c->param_service,
 160                                BIO_LOOKUP_CLIENT,
 161                                family, c->connect_sock_type,
 162                                &c->addr_first) == 0)
 163                     goto exit_loop;
 164             }
 165             if (c->addr_first == NULL) {
 166                 ERR_raise(ERR_LIB_BIO, BIO_R_LOOKUP_RETURNED_NOTHING);
 167                 goto exit_loop;
 168             }
 169             c->addr_iter = c->addr_first;
 170             c->state = BIO_CONN_S_CREATE_SOCKET;
 171             break;
 172
 173         case BIO_CONN_S_CREATE_SOCKET:
 174             ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
 175                              BIO_ADDRINFO_socktype(c->addr_iter),
 176                              BIO_ADDRINFO_protocol(c->addr_iter), 0);
 177             if (ret == (int)INVALID_SOCKET) {
 178                 ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
 179                                "calling socket(%s, %s)",
 180                                c->param_hostname, c->param_service);
 181                 ERR_raise(ERR_LIB_BIO, BIO_R_UNABLE_TO_CREATE_SOCKET);
 182                 goto exit_loop;
 183             }
 184             b->num = ret;
 185             c->state = BIO_CONN_S_CONNECT;
 186             break;
 187
 188         case BIO_CONN_S_CONNECT:
 189             BIO_clear_retry_flags(b);
 190             ERR_set_mark();
 191             ret = BIO_connect(b->num, BIO_ADDRINFO_address(c->addr_iter),
 192                               BIO_SOCK_KEEPALIVE | c->connect_mode);
 193             b->retry_reason = 0;
 194             if (ret == 0) {
 195                 if (BIO_sock_should_retry(ret)) {
 196                     BIO_set_retry_special(b);
 197                     c->state = BIO_CONN_S_BLOCKED_CONNECT;
 198                     b->retry_reason = BIO_RR_CONNECT;
 199                     ERR_pop_to_mark();
 200                 } else if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter))
 201                            != NULL) {
 202                     /*
 203                      * if there are more addresses to try, do that first
 204                      */
 205                     BIO_closesocket(b->num);
 206                     c->state = BIO_CONN_S_CREATE_SOCKET;
 207                     ERR_pop_to_mark();
 208                     break;
 209                 } else {
 210                     ERR_clear_last_mark();
 211                     ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
 212                                    "calling connect(%s, %s)",
 213                                     c->param_hostname, c->param_service);
 214                     c->state = BIO_CONN_S_CONNECT_ERROR;
 215                     break;
 216                 }
 217                 goto exit_loop;
 218             } else {
 219                 ERR_clear_last_mark();
 220                 if (!conn_create_dgram_bio(b, c))
 221                     break;
 222                 c->state = BIO_CONN_S_OK;
 223             }
 224             break;
 225
 226         case BIO_CONN_S_BLOCKED_CONNECT:
 227             /* wait for socket being writable, before querying BIO_sock_error */
 228             if (BIO_socket_wait(b->num, 0, time(NULL)) == 0)
 229                 break;
 230             i = BIO_sock_error(b->num);
 231             if (i != 0) {
 232                 BIO_clear_retry_flags(b);
 233                 if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter)) != NULL) {
 234                     /*
 235                      * if there are more addresses to try, do that first
 236                      */
 237                     BIO_closesocket(b->num);
 238                     c->state = BIO_CONN_S_CREATE_SOCKET;
 239                     break;
 240                 }
 241                 ERR_raise_data(ERR_LIB_SYS, i,
 242                                "calling connect(%s, %s)",
 243                                 c->param_hostname, c->param_service);
 244                 ERR_raise(ERR_LIB_BIO, BIO_R_NBIO_CONNECT_ERROR);
 245                 ret = 0;
 246                 goto exit_loop;
 247             } else {
 248                 if (!conn_create_dgram_bio(b, c))
 249                     break;
 250                 c->state = BIO_CONN_S_OK;
 251 # ifndef OPENSSL_NO_KTLS
 252                 /*
 253                  * The new socket is created successfully regardless of ktls_enable.
 254                  * ktls_enable doesn't change any functionality of the socket, except
 255                  * changing the setsockopt to enable the processing of ktls_start.
 256                  * Thus, it is not a problem to call it for non-TLS sockets.
 257                  */
 258                 ktls_enable(b->num);
 259 # endif
 260             }
 261             break;
 262
 263         case BIO_CONN_S_CONNECT_ERROR:
 264             ERR_raise(ERR_LIB_BIO, BIO_R_CONNECT_ERROR);
 265             ret = 0;
 266             goto exit_loop;
 267
 268         case BIO_CONN_S_OK:
 269             ret = 1;
 270             goto exit_loop;
 271         default:
 272             /* abort(); */
 273             goto exit_loop;
 274         }
 275
 276         if (cb != NULL) {
 277             if ((ret = cb((BIO *)b, c->state, ret)) == 0)
 278                 goto end;
 279         }
 280     }
 281
 282     /* Loop does not exit */
 283  exit_loop:
 284     if (cb != NULL)
 285         ret = cb((BIO *)b, c->state, ret);
 286  end:
 287     return ret;
 288 }
 289
 290 static BIO_CONNECT *BIO_CONNECT_new(void)
 291 {
 292     BIO_CONNECT *ret;
 293
 294     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
 295         return NULL;
 296     ret->state = BIO_CONN_S_BEFORE;
 297     ret->connect_family = BIO_FAMILY_IPANY;
 298     ret->connect_sock_type = SOCK_STREAM;
 299     return ret;
 300 }
 301
 302 static void BIO_CONNECT_free(BIO_CONNECT *a)
 303 {
 304     if (a == NULL)
 305         return;
 306     OPENSSL_free(a->param_hostname);
 307     OPENSSL_free(a->param_service);
 308     BIO_ADDRINFO_free(a->addr_first);
 309     OPENSSL_free(a);
 310 }
 311
 312 const BIO_METHOD *BIO_s_connect(void)
 313 {
 314     return &methods_connectp;
 315 }
 316
 317 static int conn_new(BIO *bi)
 318 {
 319     bi->init = 0;
 320     bi->num = (int)INVALID_SOCKET;
 321     bi->flags = 0;
 322     if ((bi->ptr = (char *)BIO_CONNECT_new()) == NULL)
 323         return 0;
 324     else
 325         return 1;
 326 }
 327
 328 static void conn_close_socket(BIO *bio)
 329 {
 330     BIO_CONNECT *c;
 331
 332     c = (BIO_CONNECT *)bio->ptr;
 333     if (bio->num != (int)INVALID_SOCKET) {
 334         /* Only do a shutdown if things were established */
 335         if (c->state == BIO_CONN_S_OK)
 336             shutdown(bio->num, 2);
 337         BIO_closesocket(bio->num);
 338         bio->num = (int)INVALID_SOCKET;
 339     }
 340 }
 341
 342 static int conn_free(BIO *a)
 343 {
 344     BIO_CONNECT *data;
 345
 346     if (a == NULL)
 347         return 0;
 348     data = (BIO_CONNECT *)a->ptr;
 349
 350     BIO_free(data->dgram_bio);
 351
 352     if (a->shutdown) {
 353         conn_close_socket(a);
 354         BIO_CONNECT_free(data);
 355         a->ptr = NULL;
 356         a->flags = 0;
 357         a->init = 0;
 358     }
 359     return 1;
 360 }
 361
 362 static int conn_read(BIO *b, char *out, int outl)
 363 {
 364     int ret = 0;
 365     BIO_CONNECT *data;
 366
 367     data = (BIO_CONNECT *)b->ptr;
 368     if (data->state != BIO_CONN_S_OK) {
 369         ret = conn_state(b, data);
 370         if (ret <= 0)
 371             return ret;
 372     }
 373
 374     if (data->dgram_bio != NULL) {
 375         BIO_clear_retry_flags(b);
 376         ret = BIO_read(data->dgram_bio, out, outl);
 377         BIO_set_flags(b, BIO_get_retry_flags(data->dgram_bio));
 378         return ret;
 379     }
 380
 381     if (out != NULL) {
 382         clear_socket_error();
 383 # ifndef OPENSSL_NO_KTLS
 384         if (BIO_get_ktls_recv(b))
 385             ret = ktls_read_record(b->num, out, outl);
 386         else
 387 # endif
 388             ret = readsocket(b->num, out, outl);
 389         BIO_clear_retry_flags(b);
 390         if (ret <= 0) {
 391             if (BIO_sock_should_retry(ret))
 392                 BIO_set_retry_read(b);
 393             else if (ret == 0)
 394                 b->flags |= BIO_FLAGS_IN_EOF;
 395         }
 396     }
 397     return ret;
 398 }
 399
 400 static int conn_write(BIO *b, const char *in, int inl)
 401 {
 402     int ret;
 403     BIO_CONNECT *data;
 404
 405     data = (BIO_CONNECT *)b->ptr;
 406     if (data->state != BIO_CONN_S_OK) {
 407         ret = conn_state(b, data);
 408         if (ret <= 0)
 409             return ret;
 410     }
 411
 412     if (data->dgram_bio != NULL) {
 413         BIO_clear_retry_flags(b);
 414         ret = BIO_write(data->dgram_bio, in, inl);
 415         BIO_set_flags(b, BIO_get_retry_flags(data->dgram_bio));
 416         return ret;
 417     }
 418
 419     clear_socket_error();
 420 # ifndef OPENSSL_NO_KTLS
 421     if (BIO_should_ktls_ctrl_msg_flag(b)) {
 422         ret = ktls_send_ctrl_message(b->num, data->record_type, in, inl);
 423         if (ret >= 0) {
 424             ret = inl;
 425             BIO_clear_ktls_ctrl_msg_flag(b);
 426         }
 427     } else
 428 # endif
 429 # if defined(OSSL_TFO_SENDTO)
 430     if (data->tfo_first) {
 431         int peerlen = BIO_ADDRINFO_sockaddr_size(data->addr_iter);
 432
 433         ret = sendto(b->num, in, inl, OSSL_TFO_SENDTO,
 434                      BIO_ADDRINFO_sockaddr(data->addr_iter), peerlen);
 435         data->tfo_first = 0;
 436     } else
 437 # endif
 438         ret = writesocket(b->num, in, inl);
 439     BIO_clear_retry_flags(b);
 440     if (ret <= 0) {
 441         if (BIO_sock_should_retry(ret))
 442             BIO_set_retry_write(b);
 443     }
 444     return ret;
 445 }
 446
 447 static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
 448 {
 449     BIO *dbio;
 450     int *ip;
 451     const char **pptr = NULL;
 452     long ret = 1;
 453     BIO_CONNECT *data;
 454     const BIO_ADDR *dg_addr;
 455 # ifndef OPENSSL_NO_KTLS
 456     ktls_crypto_info_t *crypto_info;
 457 # endif
 458
 459     data = (BIO_CONNECT *)b->ptr;
 460
 461     switch (cmd) {
 462     case BIO_CTRL_RESET:
 463         ret = 0;
 464         data->state = BIO_CONN_S_BEFORE;
 465         conn_close_socket(b);
 466         BIO_ADDRINFO_free(data->addr_first);
 467         data->addr_first = NULL;
 468         b->flags = 0;
 469         break;
 470     case BIO_C_DO_STATE_MACHINE:
 471         /* use this one to start the connection */
 472         if (data->state != BIO_CONN_S_OK)
 473             ret = (long)conn_state(b, data);
 474         else
 475             ret = 1;
 476         break;
 477     case BIO_C_GET_CONNECT:
 478         if (ptr != NULL) {
 479             pptr = (const char **)ptr;
 480             if (num == 0) {
 481                 *pptr = data->param_hostname;
 482             } else if (num == 1) {
 483                 *pptr = data->param_service;
 484             } else if (num == 2) {
 485                 *pptr = (const char *)BIO_ADDRINFO_address(data->addr_iter);
 486             } else if (num == 3) {
 487                 switch (BIO_ADDRINFO_family(data->addr_iter)) {
 488 # if OPENSSL_USE_IPV6
 489                 case AF_INET6:
 490                     ret = BIO_FAMILY_IPV6;
 491                     break;
 492 # endif
 493                 case AF_INET:
 494                     ret = BIO_FAMILY_IPV4;
 495                     break;
 496                 case 0:
 497                     ret = data->connect_family;
 498                     break;
 499                 default:
 500                     ret = -1;
 501                     break;
 502                 }
 503             } else if (num == 4) {
 504                 ret = data->connect_mode;
 505             } else {
 506                 ret = 0;
 507             }
 508         } else {
 509             ret = 0;
 510         }
 511         break;
 512     case BIO_C_SET_CONNECT:
 513         if (ptr != NULL) {
 514             b->init = 1;
 515             if (num == 0) { /* BIO_set_conn_hostname */
 516                 char *hold_service = data->param_service;
 517                 /* We affect the hostname regardless.  However, the input
 518                  * string might contain a host:service spec, so we must
 519                  * parse it, which might or might not affect the service
 520                  */
 521
 522                 OPENSSL_free(data->param_hostname);
 523                 data->param_hostname = NULL;
 524                 ret = BIO_parse_hostserv(ptr,
 525                                          &data->param_hostname,
 526                                          &data->param_service,
 527                                          BIO_PARSE_PRIO_HOST);
 528                 if (hold_service != data->param_service)
 529                     OPENSSL_free(hold_service);
 530             } else if (num == 1) { /* BIO_set_conn_port */
 531                 OPENSSL_free(data->param_service);
 532                 if ((data->param_service = OPENSSL_strdup(ptr)) == NULL)
 533                     ret = 0;
 534             } else if (num == 2) { /* BIO_set_conn_address */
 535                 const BIO_ADDR *addr = (const BIO_ADDR *)ptr;
 536                 char *host = BIO_ADDR_hostname_string(addr, 1);
 537                 char *service = BIO_ADDR_service_string(addr, 1);
 538
 539                 ret = host != NULL && service != NULL;
 540                 if (ret) {
 541                     OPENSSL_free(data->param_hostname);
 542                     data->param_hostname = host;
 543                     OPENSSL_free(data->param_service);
 544                     data->param_service = service;
 545                     BIO_ADDRINFO_free(data->addr_first);
 546                     data->addr_first = NULL;
 547                     data->addr_iter = NULL;
 548                 } else {
 549                     OPENSSL_free(host);
 550                     OPENSSL_free(service);
 551                 }
 552             } else if (num == 3) { /* BIO_set_conn_ip_family */
 553                 data->connect_family = *(int *)ptr;
 554             } else {
 555                 ret = 0;
 556             }
 557         }
 558         break;
 559     case BIO_C_SET_SOCK_TYPE:
 560         if ((num != SOCK_STREAM && num != SOCK_DGRAM)
 561             || data->state >= BIO_CONN_S_GET_ADDR) {
 562             ret = 0;
 563             break;
 564         }
 565
 566         data->connect_sock_type = (int)num;
 567         ret = 1;
 568         break;
 569     case BIO_C_GET_SOCK_TYPE:
 570         ret = data->connect_sock_type;
 571         break;
 572     case BIO_C_GET_DGRAM_BIO:
 573         if (data->dgram_bio != NULL) {
 574             *(BIO **)ptr = data->dgram_bio;
 575             ret = 1;
 576         } else {
 577             ret = 0;
 578         }
 579         break;
 580     case BIO_CTRL_DGRAM_GET_PEER:
 581     case BIO_CTRL_DGRAM_DETECT_PEER_ADDR:
 582         if (data->state != BIO_CONN_S_OK)
 583             conn_state(b, data); /* best effort */
 584
 585         if (data->state >= BIO_CONN_S_CREATE_SOCKET
 586             && data->addr_iter != NULL
 587             && (dg_addr = BIO_ADDRINFO_address(data->addr_iter)) != NULL) {
 588
 589             ret = BIO_ADDR_sockaddr_size(dg_addr);
 590             if (num == 0 || num > ret)
 591                 num = ret;
 592
 593             memcpy(ptr, dg_addr, num);
 594             ret = num;
 595         } else {
 596             ret = 0;
 597         }
 598
 599         break;
 600     case BIO_CTRL_GET_RPOLL_DESCRIPTOR:
 601     case BIO_CTRL_GET_WPOLL_DESCRIPTOR:
 602         {
 603             BIO_POLL_DESCRIPTOR *pd = ptr;
 604
 605             if (data->state != BIO_CONN_S_OK)
 606                 conn_state(b, data); /* best effort */
 607
 608             if (data->state >= BIO_CONN_S_CREATE_SOCKET) {
 609                 pd->type        = BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD;
 610                 pd->value.fd    = b->num;
 611             } else {
 612                 ret = 0;
 613             }
 614         }
 615         break;
 616     case BIO_C_SET_NBIO:
 617         if (num != 0)
 618             data->connect_mode |= BIO_SOCK_NONBLOCK;
 619         else
 620             data->connect_mode &= ~BIO_SOCK_NONBLOCK;
 621
 622         if (data->dgram_bio != NULL)
 623             ret = BIO_set_nbio(data->dgram_bio, num);
 624
 625         break;
 626 #if defined(TCP_FASTOPEN) && !defined(OPENSSL_NO_TFO)
 627     case BIO_C_SET_TFO:
 628         if (num != 0) {
 629             data->connect_mode |= BIO_SOCK_TFO;
 630             data->tfo_first = 1;
 631         } else {
 632             data->connect_mode &= ~BIO_SOCK_TFO;
 633             data->tfo_first = 0;
 634         }
 635         break;
 636 #endif
 637     case BIO_C_SET_CONNECT_MODE:
 638         data->connect_mode = (int)num;
 639         if (num & BIO_SOCK_TFO)
 640             data->tfo_first = 1;
 641         else
 642             data->tfo_first = 0;
 643         break;
 644     case BIO_C_GET_FD:
 645         if (b->init) {
 646             ip = (int *)ptr;
 647             if (ip != NULL)
 648                 *ip = b->num;
 649             ret = b->num;
 650         } else
 651             ret = -1;
 652         break;
 653     case BIO_CTRL_GET_CLOSE:
 654         ret = b->shutdown;
 655         break;
 656     case BIO_CTRL_SET_CLOSE:
 657         b->shutdown = (int)num;
 658         break;
 659     case BIO_CTRL_PENDING:
 660     case BIO_CTRL_WPENDING:
 661         ret = 0;
 662         break;
 663     case BIO_CTRL_FLUSH:
 664         break;
 665     case BIO_CTRL_DUP:
 666         {
 667             dbio = (BIO *)ptr;
 668             if (data->param_hostname)
 669                 BIO_set_conn_hostname(dbio, data->param_hostname);
 670             if (data->param_service)
 671                 BIO_set_conn_port(dbio, data->param_service);
 672             BIO_set_conn_ip_family(dbio, data->connect_family);
 673             BIO_set_conn_mode(dbio, data->connect_mode);
 674             /*
 675              * FIXME: the cast of the function seems unlikely to be a good
 676              * idea
 677              */
 678             (void)BIO_set_info_callback(dbio, data->info_callback);
 679         }
 680         break;
 681     case BIO_CTRL_SET_CALLBACK:
 682         ret = 0; /* use callback ctrl */
 683         break;
 684     case BIO_CTRL_GET_CALLBACK:
 685         {
 686             BIO_info_cb **fptr;
 687
 688             fptr = (BIO_info_cb **)ptr;
 689             *fptr = data->info_callback;
 690         }
 691         break;
 692     case BIO_CTRL_EOF:
 693         ret = (b->flags & BIO_FLAGS_IN_EOF) != 0;
 694         break;
 695 # ifndef OPENSSL_NO_KTLS
 696     case BIO_CTRL_SET_KTLS:
 697         crypto_info = (ktls_crypto_info_t *)ptr;
 698         ret = ktls_start(b->num, crypto_info, num);
 699         if (ret)
 700             BIO_set_ktls_flag(b, num);
 701         break;
 702     case BIO_CTRL_GET_KTLS_SEND:
 703         return BIO_should_ktls_flag(b, 1) != 0;
 704     case BIO_CTRL_GET_KTLS_RECV:
 705         return BIO_should_ktls_flag(b, 0) != 0;
 706     case BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG:
 707         BIO_set_ktls_ctrl_msg_flag(b);
 708         data->record_type = num;
 709         ret = 0;
 710         break;
 711     case BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG:
 712         BIO_clear_ktls_ctrl_msg_flag(b);
 713         ret = 0;
 714         break;
 715     case BIO_CTRL_SET_KTLS_TX_ZEROCOPY_SENDFILE:
 716         ret = ktls_enable_tx_zerocopy_sendfile(b->num);
 717         if (ret)
 718             BIO_set_ktls_zerocopy_sendfile_flag(b);
 719         break;
 720 # endif
 721     default:
 722         ret = 0;
 723         break;
 724     }
 725     return ret;
 726 }
 727
 728 static long conn_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
 729 {
 730     long ret = 1;
 731     BIO_CONNECT *data;
 732
 733     data = (BIO_CONNECT *)b->ptr;
 734
 735     switch (cmd) {
 736     case BIO_CTRL_SET_CALLBACK:
 737         {
 738             data->info_callback = fp;
 739         }
 740         break;
 741     default:
 742         ret = 0;
 743         break;
 744     }
 745     return ret;
 746 }
 747
 748 static int conn_puts(BIO *bp, const char *str)
 749 {
 750     int n, ret;
 751
 752     n = strlen(str);
 753     ret = conn_write(bp, str, n);
 754     return ret;
 755 }
 756
 757 int conn_gets(BIO *bio, char *buf, int size)
 758 {
 759     BIO_CONNECT *data;
 760     char *ptr = buf;
 761     int ret = 0;
 762
 763     if (buf == NULL) {
 764         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 765         return -1;
 766     }
 767     if (size <= 0) {
 768         ERR_raise(ERR_LIB_BIO, BIO_R_INVALID_ARGUMENT);
 769         return -1;
 770     }
 771     *buf = '\0';
 772
 773     if (bio == NULL || bio->ptr == NULL) {
 774         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 775         return -1;
 776     }
 777     data = (BIO_CONNECT *)bio->ptr;
 778     if (data->state != BIO_CONN_S_OK) {
 779         ret = conn_state(bio, data);
 780         if (ret <= 0)
 781             return ret;
 782     }
 783
 784     if (data->dgram_bio != NULL) {
 785         ERR_raise(ERR_LIB_BIO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 786         return -1;
 787     }
 788
 789     clear_socket_error();
 790     while (size-- > 1) {
 791 # ifndef OPENSSL_NO_KTLS
 792         if (BIO_get_ktls_recv(bio))
 793             ret = ktls_read_record(bio->num, ptr, 1);
 794         else
 795 # endif
 796             ret = readsocket(bio->num, ptr, 1);
 797         BIO_clear_retry_flags(bio);
 798         if (ret <= 0) {
 799             if (BIO_sock_should_retry(ret))
 800                 BIO_set_retry_read(bio);
 801             else if (ret == 0)
 802                 bio->flags |= BIO_FLAGS_IN_EOF;
 803             break;
 804         }
 805         if (*ptr++ == '\n')
 806             break;
 807     }
 808     *ptr = '\0';
 809     return ret > 0 || (bio->flags & BIO_FLAGS_IN_EOF) != 0 ? ptr - buf : ret;
 810 }
 811
 812 static int conn_sendmmsg(BIO *bio, BIO_MSG *msg, size_t stride, size_t num_msgs,
 813                          uint64_t flags, size_t *msgs_processed)
 814 {
 815     int ret;
 816     BIO_CONNECT *data;
 817
 818     if (bio == NULL) {
 819         *msgs_processed = 0;
 820         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 821         return 0;
 822     }
 823
 824     data = (BIO_CONNECT *)bio->ptr;
 825     if (data->state != BIO_CONN_S_OK) {
 826         ret = conn_state(bio, data);
 827         if (ret <= 0) {
 828             *msgs_processed = 0;
 829             return 0;
 830         }
 831     }
 832
 833     if (data->dgram_bio == NULL) {
 834         *msgs_processed = 0;
 835         ERR_raise(ERR_LIB_BIO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 836         return 0;
 837     }
 838
 839     return BIO_sendmmsg(data->dgram_bio, msg, stride, num_msgs,
 840                         flags, msgs_processed);
 841 }
 842
 843 static int conn_recvmmsg(BIO *bio, BIO_MSG *msg, size_t stride, size_t num_msgs,
 844                          uint64_t flags, size_t *msgs_processed)
 845 {
 846     int ret;
 847     BIO_CONNECT *data;
 848
 849     if (bio == NULL) {
 850         *msgs_processed = 0;
 851         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 852         return 0;
 853     }
 854
 855     data = (BIO_CONNECT *)bio->ptr;
 856     if (data->state != BIO_CONN_S_OK) {
 857         ret = conn_state(bio, data);
 858         if (ret <= 0) {
 859             *msgs_processed = 0;
 860             return 0;
 861         }
 862     }
 863
 864     if (data->dgram_bio == NULL) {
 865         *msgs_processed = 0;
 866         ERR_raise(ERR_LIB_BIO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 867         return 0;
 868     }
 869
 870     return BIO_recvmmsg(data->dgram_bio, msg, stride, num_msgs,
 871                         flags, msgs_processed);
 872 }
 873
 874 BIO *BIO_new_connect(const char *str)
 875 {
 876     BIO *ret;
 877
 878     ret = BIO_new(BIO_s_connect());
 879     if (ret == NULL)
 880         return NULL;
 881     if (BIO_set_conn_hostname(ret, str))
 882         return ret;
 883     BIO_free(ret);
 884     return NULL;
 885 }
 886
 887 #endif