crypto/bio/bss_conn.c

   1 /*
   2  * Copyright 1995-2022 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     char *param_hostname;
  23     char *param_service;
  24     int connect_mode;
  25 # ifndef OPENSSL_NO_KTLS
  26     unsigned char record_type;
  27 # endif
  28     int tfo_first;
  29
  30     BIO_ADDRINFO *addr_first;
  31     const BIO_ADDRINFO *addr_iter;
  32     /*
  33      * int socket; this will be kept in bio->num so that it is compatible
  34      * with the bss_sock bio
  35      */
  36     /*
  37      * called when the connection is initially made callback(BIO,state,ret);
  38      * The callback should return 'ret'.  state is for compatibility with the
  39      * ssl info_callback
  40      */
  41     BIO_info_cb *info_callback;
  42 } BIO_CONNECT;
  43
  44 static int conn_write(BIO *h, const char *buf, int num);
  45 static int conn_read(BIO *h, char *buf, int size);
  46 static int conn_puts(BIO *h, const char *str);
  47 static int conn_gets(BIO *h, char *buf, int size);
  48 static long conn_ctrl(BIO *h, int cmd, long arg1, void *arg2);
  49 static int conn_new(BIO *h);
  50 static int conn_free(BIO *data);
  51 static long conn_callback_ctrl(BIO *h, int cmd, BIO_info_cb *);
  52
  53 static int conn_state(BIO *b, BIO_CONNECT *c);
  54 static void conn_close_socket(BIO *data);
  55 static BIO_CONNECT *BIO_CONNECT_new(void);
  56 static void BIO_CONNECT_free(BIO_CONNECT *a);
  57
  58 #define BIO_CONN_S_BEFORE                1
  59 #define BIO_CONN_S_GET_ADDR              2
  60 #define BIO_CONN_S_CREATE_SOCKET         3
  61 #define BIO_CONN_S_CONNECT               4
  62 #define BIO_CONN_S_OK                    5
  63 #define BIO_CONN_S_BLOCKED_CONNECT       6
  64 #define BIO_CONN_S_CONNECT_ERROR         7
  65
  66 static const BIO_METHOD methods_connectp = {
  67     BIO_TYPE_CONNECT,
  68     "socket connect",
  69     bwrite_conv,
  70     conn_write,
  71     bread_conv,
  72     conn_read,
  73     conn_puts,
  74     conn_gets,
  75     conn_ctrl,
  76     conn_new,
  77     conn_free,
  78     conn_callback_ctrl,
  79 };
  80
  81 static int conn_state(BIO *b, BIO_CONNECT *c)
  82 {
  83     int ret = -1, i;
  84     BIO_info_cb *cb = NULL;
  85
  86     if (c->info_callback != NULL)
  87         cb = c->info_callback;
  88
  89     for (;;) {
  90         switch (c->state) {
  91         case BIO_CONN_S_BEFORE:
  92             if (c->param_hostname == NULL && c->param_service == NULL) {
  93                 ERR_raise_data(ERR_LIB_BIO,
  94                                BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED,
  95                                "hostname=%s service=%s",
  96                                c->param_hostname, c->param_service);
  97                 goto exit_loop;
  98             }
  99             c->state = BIO_CONN_S_GET_ADDR;
 100             break;
 101
 102         case BIO_CONN_S_GET_ADDR:
 103             {
 104                 int family = AF_UNSPEC;
 105                 switch (c->connect_family) {
 106                 case BIO_FAMILY_IPV6:
 107                     if (1) { /* This is a trick we use to avoid bit rot.
 108                               * at least the "else" part will always be
 109                               * compiled.
 110                               */
 111 #if OPENSSL_USE_IPV6
 112                         family = AF_INET6;
 113                     } else {
 114 #endif
 115                         ERR_raise(ERR_LIB_BIO, BIO_R_UNAVAILABLE_IP_FAMILY);
 116                         goto exit_loop;
 117                     }
 118                     break;
 119                 case BIO_FAMILY_IPV4:
 120                     family = AF_INET;
 121                     break;
 122                 case BIO_FAMILY_IPANY:
 123                     family = AF_UNSPEC;
 124                     break;
 125                 default:
 126                     ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_IP_FAMILY);
 127                     goto exit_loop;
 128                 }
 129                 if (BIO_lookup(c->param_hostname, c->param_service,
 130                                BIO_LOOKUP_CLIENT,
 131                                family, SOCK_STREAM, &c->addr_first) == 0)
 132                     goto exit_loop;
 133             }
 134             if (c->addr_first == NULL) {
 135                 ERR_raise(ERR_LIB_BIO, BIO_R_LOOKUP_RETURNED_NOTHING);
 136                 goto exit_loop;
 137             }
 138             c->addr_iter = c->addr_first;
 139             c->state = BIO_CONN_S_CREATE_SOCKET;
 140             break;
 141
 142         case BIO_CONN_S_CREATE_SOCKET:
 143             ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
 144                              BIO_ADDRINFO_socktype(c->addr_iter),
 145                              BIO_ADDRINFO_protocol(c->addr_iter), 0);
 146             if (ret == (int)INVALID_SOCKET) {
 147                 ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
 148                                "calling socket(%s, %s)",
 149                                c->param_hostname, c->param_service);
 150                 ERR_raise(ERR_LIB_BIO, BIO_R_UNABLE_TO_CREATE_SOCKET);
 151                 goto exit_loop;
 152             }
 153             b->num = ret;
 154             c->state = BIO_CONN_S_CONNECT;
 155             break;
 156
 157         case BIO_CONN_S_CONNECT:
 158             BIO_clear_retry_flags(b);
 159             ERR_set_mark();
 160             ret = BIO_connect(b->num, BIO_ADDRINFO_address(c->addr_iter),
 161                               BIO_SOCK_KEEPALIVE | c->connect_mode);
 162             b->retry_reason = 0;
 163             if (ret == 0) {
 164                 if (BIO_sock_should_retry(ret)) {
 165                     BIO_set_retry_special(b);
 166                     c->state = BIO_CONN_S_BLOCKED_CONNECT;
 167                     b->retry_reason = BIO_RR_CONNECT;
 168                     ERR_pop_to_mark();
 169                 } else if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter))
 170                            != NULL) {
 171                     /*
 172                      * if there are more addresses to try, do that first
 173                      */
 174                     BIO_closesocket(b->num);
 175                     c->state = BIO_CONN_S_CREATE_SOCKET;
 176                     ERR_pop_to_mark();
 177                     break;
 178                 } else {
 179                     ERR_clear_last_mark();
 180                     ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
 181                                    "calling connect(%s, %s)",
 182                                     c->param_hostname, c->param_service);
 183                     c->state = BIO_CONN_S_CONNECT_ERROR;
 184                     break;
 185                 }
 186                 goto exit_loop;
 187             } else {
 188                 ERR_clear_last_mark();
 189                 c->state = BIO_CONN_S_OK;
 190             }
 191             break;
 192
 193         case BIO_CONN_S_BLOCKED_CONNECT:
 194             /* wait for socket being writable, before querying BIO_sock_error */
 195             if (BIO_socket_wait(b->num, 0, time(NULL)) == 0)
 196                 break;
 197             i = BIO_sock_error(b->num);
 198             if (i != 0) {
 199                 BIO_clear_retry_flags(b);
 200                 if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter)) != NULL) {
 201                     /*
 202                      * if there are more addresses to try, do that first
 203                      */
 204                     BIO_closesocket(b->num);
 205                     c->state = BIO_CONN_S_CREATE_SOCKET;
 206                     break;
 207                 }
 208                 ERR_raise_data(ERR_LIB_SYS, i,
 209                                "calling connect(%s, %s)",
 210                                 c->param_hostname, c->param_service);
 211                 ERR_raise(ERR_LIB_BIO, BIO_R_NBIO_CONNECT_ERROR);
 212                 ret = 0;
 213                 goto exit_loop;
 214             } else {
 215                 c->state = BIO_CONN_S_OK;
 216 # ifndef OPENSSL_NO_KTLS
 217                 /*
 218                  * The new socket is created successfully regardless of ktls_enable.
 219                  * ktls_enable doesn't change any functionality of the socket, except
 220                  * changing the setsockopt to enable the processing of ktls_start.
 221                  * Thus, it is not a problem to call it for non-TLS sockets.
 222                  */
 223                 ktls_enable(b->num);
 224 # endif
 225             }
 226             break;
 227
 228         case BIO_CONN_S_CONNECT_ERROR:
 229             ERR_raise(ERR_LIB_BIO, BIO_R_CONNECT_ERROR);
 230             ret = 0;
 231             goto exit_loop;
 232
 233         case BIO_CONN_S_OK:
 234             ret = 1;
 235             goto exit_loop;
 236         default:
 237             /* abort(); */
 238             goto exit_loop;
 239         }
 240
 241         if (cb != NULL) {
 242             if ((ret = cb((BIO *)b, c->state, ret)) == 0)
 243                 goto end;
 244         }
 245     }
 246
 247     /* Loop does not exit */
 248  exit_loop:
 249     if (cb != NULL)
 250         ret = cb((BIO *)b, c->state, ret);
 251  end:
 252     return ret;
 253 }
 254
 255 static BIO_CONNECT *BIO_CONNECT_new(void)
 256 {
 257     BIO_CONNECT *ret;
 258
 259     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
 260         return NULL;
 261     ret->state = BIO_CONN_S_BEFORE;
 262     ret->connect_family = BIO_FAMILY_IPANY;
 263     return ret;
 264 }
 265
 266 static void BIO_CONNECT_free(BIO_CONNECT *a)
 267 {
 268     if (a == NULL)
 269         return;
 270     OPENSSL_free(a->param_hostname);
 271     OPENSSL_free(a->param_service);
 272     BIO_ADDRINFO_free(a->addr_first);
 273     OPENSSL_free(a);
 274 }
 275
 276 const BIO_METHOD *BIO_s_connect(void)
 277 {
 278     return &methods_connectp;
 279 }
 280
 281 static int conn_new(BIO *bi)
 282 {
 283     bi->init = 0;
 284     bi->num = (int)INVALID_SOCKET;
 285     bi->flags = 0;
 286     if ((bi->ptr = (char *)BIO_CONNECT_new()) == NULL)
 287         return 0;
 288     else
 289         return 1;
 290 }
 291
 292 static void conn_close_socket(BIO *bio)
 293 {
 294     BIO_CONNECT *c;
 295
 296     c = (BIO_CONNECT *)bio->ptr;
 297     if (bio->num != (int)INVALID_SOCKET) {
 298         /* Only do a shutdown if things were established */
 299         if (c->state == BIO_CONN_S_OK)
 300             shutdown(bio->num, 2);
 301         BIO_closesocket(bio->num);
 302         bio->num = (int)INVALID_SOCKET;
 303     }
 304 }
 305
 306 static int conn_free(BIO *a)
 307 {
 308     BIO_CONNECT *data;
 309
 310     if (a == NULL)
 311         return 0;
 312     data = (BIO_CONNECT *)a->ptr;
 313
 314     if (a->shutdown) {
 315         conn_close_socket(a);
 316         BIO_CONNECT_free(data);
 317         a->ptr = NULL;
 318         a->flags = 0;
 319         a->init = 0;
 320     }
 321     return 1;
 322 }
 323
 324 static int conn_read(BIO *b, char *out, int outl)
 325 {
 326     int ret = 0;
 327     BIO_CONNECT *data;
 328
 329     data = (BIO_CONNECT *)b->ptr;
 330     if (data->state != BIO_CONN_S_OK) {
 331         ret = conn_state(b, data);
 332         if (ret <= 0)
 333             return ret;
 334     }
 335
 336     if (out != NULL) {
 337         clear_socket_error();
 338 # ifndef OPENSSL_NO_KTLS
 339         if (BIO_get_ktls_recv(b))
 340             ret = ktls_read_record(b->num, out, outl);
 341         else
 342 # endif
 343             ret = readsocket(b->num, out, outl);
 344         BIO_clear_retry_flags(b);
 345         if (ret <= 0) {
 346             if (BIO_sock_should_retry(ret))
 347                 BIO_set_retry_read(b);
 348             else if (ret == 0)
 349                 b->flags |= BIO_FLAGS_IN_EOF;
 350         }
 351     }
 352     return ret;
 353 }
 354
 355 static int conn_write(BIO *b, const char *in, int inl)
 356 {
 357     int ret;
 358     BIO_CONNECT *data;
 359
 360     data = (BIO_CONNECT *)b->ptr;
 361     if (data->state != BIO_CONN_S_OK) {
 362         ret = conn_state(b, data);
 363         if (ret <= 0)
 364             return ret;
 365     }
 366
 367     clear_socket_error();
 368 # ifndef OPENSSL_NO_KTLS
 369     if (BIO_should_ktls_ctrl_msg_flag(b)) {
 370         ret = ktls_send_ctrl_message(b->num, data->record_type, in, inl);
 371         if (ret >= 0) {
 372             ret = inl;
 373             BIO_clear_ktls_ctrl_msg_flag(b);
 374         }
 375     } else
 376 # endif
 377 # if defined(OSSL_TFO_SENDTO)
 378     if (data->tfo_first) {
 379         int peerlen = BIO_ADDRINFO_sockaddr_size(data->addr_iter);
 380
 381         ret = sendto(b->num, in, inl, OSSL_TFO_SENDTO,
 382                      BIO_ADDRINFO_sockaddr(data->addr_iter), peerlen);
 383         data->tfo_first = 0;
 384     } else
 385 # endif
 386         ret = writesocket(b->num, in, inl);
 387     BIO_clear_retry_flags(b);
 388     if (ret <= 0) {
 389         if (BIO_sock_should_retry(ret))
 390             BIO_set_retry_write(b);
 391     }
 392     return ret;
 393 }
 394
 395 static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
 396 {
 397     BIO *dbio;
 398     int *ip;
 399     const char **pptr = NULL;
 400     long ret = 1;
 401     BIO_CONNECT *data;
 402 # ifndef OPENSSL_NO_KTLS
 403     ktls_crypto_info_t *crypto_info;
 404 # endif
 405
 406     data = (BIO_CONNECT *)b->ptr;
 407
 408     switch (cmd) {
 409     case BIO_CTRL_RESET:
 410         ret = 0;
 411         data->state = BIO_CONN_S_BEFORE;
 412         conn_close_socket(b);
 413         BIO_ADDRINFO_free(data->addr_first);
 414         data->addr_first = NULL;
 415         b->flags = 0;
 416         break;
 417     case BIO_C_DO_STATE_MACHINE:
 418         /* use this one to start the connection */
 419         if (data->state != BIO_CONN_S_OK)
 420             ret = (long)conn_state(b, data);
 421         else
 422             ret = 1;
 423         break;
 424     case BIO_C_GET_CONNECT:
 425         if (ptr != NULL) {
 426             pptr = (const char **)ptr;
 427             if (num == 0) {
 428                 *pptr = data->param_hostname;
 429             } else if (num == 1) {
 430                 *pptr = data->param_service;
 431             } else if (num == 2) {
 432                 *pptr = (const char *)BIO_ADDRINFO_address(data->addr_iter);
 433             } else if (num == 3) {
 434                 switch (BIO_ADDRINFO_family(data->addr_iter)) {
 435 # if OPENSSL_USE_IPV6
 436                 case AF_INET6:
 437                     ret = BIO_FAMILY_IPV6;
 438                     break;
 439 # endif
 440                 case AF_INET:
 441                     ret = BIO_FAMILY_IPV4;
 442                     break;
 443                 case 0:
 444                     ret = data->connect_family;
 445                     break;
 446                 default:
 447                     ret = -1;
 448                     break;
 449                 }
 450             } else if (num == 4) {
 451                 ret = data->connect_mode;
 452             } else {
 453                 ret = 0;
 454             }
 455         } else {
 456             ret = 0;
 457         }
 458         break;
 459     case BIO_C_SET_CONNECT:
 460         if (ptr != NULL) {
 461             b->init = 1;
 462             if (num == 0) { /* BIO_set_conn_hostname */
 463                 char *hold_service = data->param_service;
 464                 /* We affect the hostname regardless.  However, the input
 465                  * string might contain a host:service spec, so we must
 466                  * parse it, which might or might not affect the service
 467                  */
 468
 469                 OPENSSL_free(data->param_hostname);
 470                 data->param_hostname = NULL;
 471                 ret = BIO_parse_hostserv(ptr,
 472                                          &data->param_hostname,
 473                                          &data->param_service,
 474                                          BIO_PARSE_PRIO_HOST);
 475                 if (hold_service != data->param_service)
 476                     OPENSSL_free(hold_service);
 477             } else if (num == 1) { /* BIO_set_conn_port */
 478                 OPENSSL_free(data->param_service);
 479                 if ((data->param_service = OPENSSL_strdup(ptr)) == NULL)
 480                     ret = 0;
 481             } else if (num == 2) { /* BIO_set_conn_address */
 482                 const BIO_ADDR *addr = (const BIO_ADDR *)ptr;
 483                 char *host = BIO_ADDR_hostname_string(addr, 1);
 484                 char *service = BIO_ADDR_service_string(addr, 1);
 485
 486                 ret = host != NULL && service != NULL;
 487                 if (ret) {
 488                     OPENSSL_free(data->param_hostname);
 489                     data->param_hostname = host;
 490                     OPENSSL_free(data->param_service);
 491                     data->param_service = service;
 492                     BIO_ADDRINFO_free(data->addr_first);
 493                     data->addr_first = NULL;
 494                     data->addr_iter = NULL;
 495                 } else {
 496                     OPENSSL_free(host);
 497                     OPENSSL_free(service);
 498                 }
 499             } else if (num == 3) { /* BIO_set_conn_ip_family */
 500                 data->connect_family = *(int *)ptr;
 501             } else {
 502                 ret = 0;
 503             }
 504         }
 505         break;
 506     case BIO_C_SET_NBIO:
 507         if (num != 0)
 508             data->connect_mode |= BIO_SOCK_NONBLOCK;
 509         else
 510             data->connect_mode &= ~BIO_SOCK_NONBLOCK;
 511         break;
 512 #if defined(TCP_FASTOPEN) && !defined(OPENSSL_NO_TFO)
 513     case BIO_C_SET_TFO:
 514         if (num != 0) {
 515             data->connect_mode |= BIO_SOCK_TFO;
 516             data->tfo_first = 1;
 517         } else {
 518             data->connect_mode &= ~BIO_SOCK_TFO;
 519             data->tfo_first = 0;
 520         }
 521         break;
 522 #endif
 523     case BIO_C_SET_CONNECT_MODE:
 524         data->connect_mode = (int)num;
 525         if (num & BIO_SOCK_TFO)
 526             data->tfo_first = 1;
 527         else
 528             data->tfo_first = 0;
 529         break;
 530     case BIO_C_GET_FD:
 531         if (b->init) {
 532             ip = (int *)ptr;
 533             if (ip != NULL)
 534                 *ip = b->num;
 535             ret = b->num;
 536         } else
 537             ret = -1;
 538         break;
 539     case BIO_CTRL_GET_CLOSE:
 540         ret = b->shutdown;
 541         break;
 542     case BIO_CTRL_SET_CLOSE:
 543         b->shutdown = (int)num;
 544         break;
 545     case BIO_CTRL_PENDING:
 546     case BIO_CTRL_WPENDING:
 547         ret = 0;
 548         break;
 549     case BIO_CTRL_FLUSH:
 550         break;
 551     case BIO_CTRL_DUP:
 552         {
 553             dbio = (BIO *)ptr;
 554             if (data->param_hostname)
 555                 BIO_set_conn_hostname(dbio, data->param_hostname);
 556             if (data->param_service)
 557                 BIO_set_conn_port(dbio, data->param_service);
 558             BIO_set_conn_ip_family(dbio, data->connect_family);
 559             BIO_set_conn_mode(dbio, data->connect_mode);
 560             /*
 561              * FIXME: the cast of the function seems unlikely to be a good
 562              * idea
 563              */
 564             (void)BIO_set_info_callback(dbio, data->info_callback);
 565         }
 566         break;
 567     case BIO_CTRL_SET_CALLBACK:
 568         ret = 0; /* use callback ctrl */
 569         break;
 570     case BIO_CTRL_GET_CALLBACK:
 571         {
 572             BIO_info_cb **fptr;
 573
 574             fptr = (BIO_info_cb **)ptr;
 575             *fptr = data->info_callback;
 576         }
 577         break;
 578     case BIO_CTRL_EOF:
 579         ret = (b->flags & BIO_FLAGS_IN_EOF) != 0;
 580         break;
 581 # ifndef OPENSSL_NO_KTLS
 582     case BIO_CTRL_SET_KTLS:
 583         crypto_info = (ktls_crypto_info_t *)ptr;
 584         ret = ktls_start(b->num, crypto_info, num);
 585         if (ret)
 586             BIO_set_ktls_flag(b, num);
 587         break;
 588     case BIO_CTRL_GET_KTLS_SEND:
 589         return BIO_should_ktls_flag(b, 1) != 0;
 590     case BIO_CTRL_GET_KTLS_RECV:
 591         return BIO_should_ktls_flag(b, 0) != 0;
 592     case BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG:
 593         BIO_set_ktls_ctrl_msg_flag(b);
 594         data->record_type = num;
 595         ret = 0;
 596         break;
 597     case BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG:
 598         BIO_clear_ktls_ctrl_msg_flag(b);
 599         ret = 0;
 600         break;
 601     case BIO_CTRL_SET_KTLS_TX_ZEROCOPY_SENDFILE:
 602         ret = ktls_enable_tx_zerocopy_sendfile(b->num);
 603         if (ret)
 604             BIO_set_ktls_zerocopy_sendfile_flag(b);
 605         break;
 606 # endif
 607     default:
 608         ret = 0;
 609         break;
 610     }
 611     return ret;
 612 }
 613
 614 static long conn_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
 615 {
 616     long ret = 1;
 617     BIO_CONNECT *data;
 618
 619     data = (BIO_CONNECT *)b->ptr;
 620
 621     switch (cmd) {
 622     case BIO_CTRL_SET_CALLBACK:
 623         {
 624             data->info_callback = fp;
 625         }
 626         break;
 627     default:
 628         ret = 0;
 629         break;
 630     }
 631     return ret;
 632 }
 633
 634 static int conn_puts(BIO *bp, const char *str)
 635 {
 636     int n, ret;
 637
 638     n = strlen(str);
 639     ret = conn_write(bp, str, n);
 640     return ret;
 641 }
 642
 643 int conn_gets(BIO *bio, char *buf, int size)
 644 {
 645     BIO_CONNECT *data;
 646     char *ptr = buf;
 647     int ret = 0;
 648
 649     if (buf == NULL) {
 650         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 651         return -1;
 652     }
 653     if (size <= 0) {
 654         ERR_raise(ERR_LIB_BIO, BIO_R_INVALID_ARGUMENT);
 655         return -1;
 656     }
 657     *buf = '\0';
 658
 659     if (bio == NULL || bio->ptr == NULL) {
 660         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 661         return -1;
 662     }
 663     data = (BIO_CONNECT *)bio->ptr;
 664     if (data->state != BIO_CONN_S_OK) {
 665         ret = conn_state(bio, data);
 666         if (ret <= 0)
 667             return ret;
 668     }
 669
 670     clear_socket_error();
 671     while (size-- > 1) {
 672 # ifndef OPENSSL_NO_KTLS
 673         if (BIO_get_ktls_recv(bio))
 674             ret = ktls_read_record(bio->num, ptr, 1);
 675         else
 676 # endif
 677             ret = readsocket(bio->num, ptr, 1);
 678         BIO_clear_retry_flags(bio);
 679         if (ret <= 0) {
 680             if (BIO_sock_should_retry(ret))
 681                 BIO_set_retry_read(bio);
 682             else if (ret == 0)
 683                 bio->flags |= BIO_FLAGS_IN_EOF;
 684             break;
 685         }
 686         if (*ptr++ == '\n')
 687             break;
 688     }
 689     *ptr = '\0';
 690     return ret > 0 || (bio->flags & BIO_FLAGS_IN_EOF) != 0 ? ptr - buf : ret;
 691 }
 692
 693 BIO *BIO_new_connect(const char *str)
 694 {
 695     BIO *ret;
 696
 697     ret = BIO_new(BIO_s_connect());
 698     if (ret == NULL)
 699         return NULL;
 700     if (BIO_set_conn_hostname(ret, str))
 701         return ret;
 702     BIO_free(ret);
 703     return NULL;
 704 }
 705
 706 #endif