crypto/bio/bio_lib.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 #define OPENSSL_SUPPRESS_DEPRECATED
  11
  12 #include <stdio.h>
  13 #include <errno.h>
  14 #include <openssl/crypto.h>
  15 #include "internal/numbers.h"
  16 #include "bio_local.h"
  17
  18 /*
  19  * Helper macro for the callback to determine whether an operator expects a
  20  * len parameter or not
  21  */
  22 #define HAS_LEN_OPER(o) ((o) == BIO_CB_READ || (o) == BIO_CB_WRITE \
  23                          || (o) == BIO_CB_GETS)
  24
  25 #ifndef OPENSSL_NO_DEPRECATED_3_0
  26 # define HAS_CALLBACK(b) ((b)->callback != NULL || (b)->callback_ex != NULL)
  27 #else
  28 # define HAS_CALLBACK(b) ((b)->callback_ex != NULL)
  29 #endif
  30 /*
  31  * Helper function to work out whether to call the new style callback or the old
  32  * one, and translate between the two.
  33  *
  34  * This has a long return type for consistency with the old callback. Similarly
  35  * for the "long" used for "inret"
  36  */
  37 static long bio_call_callback(BIO *b, int oper, const char *argp, size_t len,
  38                               int argi, long argl, long inret,
  39                               size_t *processed)
  40 {
  41     long ret = inret;
  42 #ifndef OPENSSL_NO_DEPRECATED_3_0
  43     int bareoper;
  44
  45     if (b->callback_ex != NULL)
  46 #endif
  47         return b->callback_ex(b, oper, argp, len, argi, argl, inret, processed);
  48
  49 #ifndef OPENSSL_NO_DEPRECATED_3_0
  50     /* Strip off any BIO_CB_RETURN flag */
  51     bareoper = oper & ~BIO_CB_RETURN;
  52
  53     /*
  54      * We have an old style callback, so we will have to do nasty casts and
  55      * check for overflows.
  56      */
  57     if (HAS_LEN_OPER(bareoper)) {
  58         /* In this case |len| is set, and should be used instead of |argi| */
  59         if (len > INT_MAX)
  60             return -1;
  61
  62         argi = (int)len;
  63     }
  64
  65     if (inret > 0 && (oper & BIO_CB_RETURN) && bareoper != BIO_CB_CTRL) {
  66         if (*processed > INT_MAX)
  67             return -1;
  68         inret = *processed;
  69     }
  70
  71     ret = b->callback(b, oper, argp, argi, argl, inret);
  72
  73     if (ret > 0 && (oper & BIO_CB_RETURN) && bareoper != BIO_CB_CTRL) {
  74         *processed = (size_t)ret;
  75         ret = 1;
  76     }
  77 #endif
  78     return ret;
  79 }
  80
  81 BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method)
  82 {
  83     BIO *bio = OPENSSL_zalloc(sizeof(*bio));
  84
  85     if (bio == NULL)
  86         return NULL;
  87
  88     bio->libctx = libctx;
  89     bio->method = method;
  90     bio->shutdown = 1;
  91
  92     if (!CRYPTO_NEW_REF(&bio->references, 1))
  93         goto err;
  94
  95     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data))
  96         goto err;
  97
  98     if (method->create != NULL && !method->create(bio)) {
  99         ERR_raise(ERR_LIB_BIO, ERR_R_INIT_FAIL);
 100         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 101         goto err;
 102     }
 103     if (method->create == NULL)
 104         bio->init = 1;
 105
 106     return bio;
 107
 108 err:
 109     CRYPTO_FREE_REF(&bio->references);
 110     OPENSSL_free(bio);
 111     return NULL;
 112 }
 113
 114 BIO *BIO_new(const BIO_METHOD *method)
 115 {
 116     return BIO_new_ex(NULL, method);
 117 }
 118
 119 int BIO_free(BIO *a)
 120 {
 121     int ret;
 122
 123     if (a == NULL)
 124         return 0;
 125
 126     if (CRYPTO_DOWN_REF(&a->references, &ret) <= 0)
 127         return 0;
 128
 129     REF_PRINT_COUNT("BIO", a);
 130     if (ret > 0)
 131         return 1;
 132     REF_ASSERT_ISNT(ret < 0);
 133
 134     if (HAS_CALLBACK(a)) {
 135         ret = (int)bio_call_callback(a, BIO_CB_FREE, NULL, 0, 0, 0L, 1L, NULL);
 136         if (ret <= 0)
 137             return 0;
 138     }
 139
 140     if ((a->method != NULL) && (a->method->destroy != NULL))
 141         a->method->destroy(a);
 142
 143     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
 144
 145     CRYPTO_FREE_REF(&a->references);
 146
 147     OPENSSL_free(a);
 148
 149     return 1;
 150 }
 151
 152 void BIO_set_data(BIO *a, void *ptr)
 153 {
 154     a->ptr = ptr;
 155 }
 156
 157 void *BIO_get_data(BIO *a)
 158 {
 159     return a->ptr;
 160 }
 161
 162 void BIO_set_init(BIO *a, int init)
 163 {
 164     a->init = init;
 165 }
 166
 167 int BIO_get_init(BIO *a)
 168 {
 169     return a->init;
 170 }
 171
 172 void BIO_set_shutdown(BIO *a, int shut)
 173 {
 174     a->shutdown = shut;
 175 }
 176
 177 int BIO_get_shutdown(BIO *a)
 178 {
 179     return a->shutdown;
 180 }
 181
 182 void BIO_vfree(BIO *a)
 183 {
 184     BIO_free(a);
 185 }
 186
 187 int BIO_up_ref(BIO *a)
 188 {
 189     int i;
 190
 191     if (CRYPTO_UP_REF(&a->references, &i) <= 0)
 192         return 0;
 193
 194     REF_PRINT_COUNT("BIO", a);
 195     REF_ASSERT_ISNT(i < 2);
 196     return i > 1;
 197 }
 198
 199 void BIO_clear_flags(BIO *b, int flags)
 200 {
 201     b->flags &= ~flags;
 202 }
 203
 204 int BIO_test_flags(const BIO *b, int flags)
 205 {
 206     return (b->flags & flags);
 207 }
 208
 209 void BIO_set_flags(BIO *b, int flags)
 210 {
 211     b->flags |= flags;
 212 }
 213
 214 #ifndef OPENSSL_NO_DEPRECATED_3_0
 215 BIO_callback_fn BIO_get_callback(const BIO *b)
 216 {
 217     return b->callback;
 218 }
 219
 220 void BIO_set_callback(BIO *b, BIO_callback_fn cb)
 221 {
 222     b->callback = cb;
 223 }
 224 #endif
 225
 226 BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b)
 227 {
 228     return b->callback_ex;
 229 }
 230
 231 void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex cb)
 232 {
 233     b->callback_ex = cb;
 234 }
 235
 236 void BIO_set_callback_arg(BIO *b, char *arg)
 237 {
 238     b->cb_arg = arg;
 239 }
 240
 241 char *BIO_get_callback_arg(const BIO *b)
 242 {
 243     return b->cb_arg;
 244 }
 245
 246 const char *BIO_method_name(const BIO *b)
 247 {
 248     return b->method->name;
 249 }
 250
 251 int BIO_method_type(const BIO *b)
 252 {
 253     return b->method->type;
 254 }
 255
 256 /*
 257  * This is essentially the same as BIO_read_ex() except that it allows
 258  * 0 or a negative value to indicate failure (retryable or not) in the return.
 259  * This is for compatibility with the old style BIO_read(), where existing code
 260  * may make assumptions about the return value that it might get.
 261  */
 262 static int bio_read_intern(BIO *b, void *data, size_t dlen, size_t *readbytes)
 263 {
 264     int ret;
 265
 266     if (b == NULL) {
 267         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 268         return -1;
 269     }
 270     if (b->method == NULL || b->method->bread == NULL) {
 271         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 272         return -2;
 273     }
 274
 275     if (HAS_CALLBACK(b) &&
 276         ((ret = (int)bio_call_callback(b, BIO_CB_READ, data, dlen, 0, 0L, 1L,
 277                                        NULL)) <= 0))
 278         return ret;
 279
 280     if (!b->init) {
 281         ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
 282         return -1;
 283     }
 284
 285     ret = b->method->bread(b, data, dlen, readbytes);
 286
 287     if (ret > 0)
 288         b->num_read += (uint64_t)*readbytes;
 289
 290     if (HAS_CALLBACK(b))
 291         ret = (int)bio_call_callback(b, BIO_CB_READ | BIO_CB_RETURN, data,
 292                                      dlen, 0, 0L, ret, readbytes);
 293
 294     /* Shouldn't happen */
 295     if (ret > 0 && *readbytes > dlen) {
 296         ERR_raise(ERR_LIB_BIO, ERR_R_INTERNAL_ERROR);
 297         return -1;
 298     }
 299
 300     return ret;
 301 }
 302
 303 int BIO_read(BIO *b, void *data, int dlen)
 304 {
 305     size_t readbytes;
 306     int ret;
 307
 308     if (dlen < 0)
 309         return 0;
 310
 311     ret = bio_read_intern(b, data, (size_t)dlen, &readbytes);
 312
 313     if (ret > 0) {
 314         /* *readbytes should always be <= dlen */
 315         ret = (int)readbytes;
 316     }
 317
 318     return ret;
 319 }
 320
 321 int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes)
 322 {
 323     return bio_read_intern(b, data, dlen, readbytes) > 0;
 324 }
 325
 326 static int bio_write_intern(BIO *b, const void *data, size_t dlen,
 327                             size_t *written)
 328 {
 329     size_t local_written;
 330     int ret;
 331
 332     if (written != NULL)
 333         *written = 0;
 334     /*
 335      * b == NULL is not an error but just means that zero bytes are written.
 336      * Do not raise an error here.
 337      */
 338     if (b == NULL)
 339         return 0;
 340
 341     if (b->method == NULL || b->method->bwrite == NULL) {
 342         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 343         return -2;
 344     }
 345
 346     if (HAS_CALLBACK(b) &&
 347         ((ret = (int)bio_call_callback(b, BIO_CB_WRITE, data, dlen, 0, 0L, 1L,
 348                                        NULL)) <= 0))
 349         return ret;
 350
 351     if (!b->init) {
 352         ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
 353         return -1;
 354     }
 355
 356     ret = b->method->bwrite(b, data, dlen, &local_written);
 357
 358     if (ret > 0)
 359         b->num_write += (uint64_t)local_written;
 360
 361     if (HAS_CALLBACK(b))
 362         ret = (int)bio_call_callback(b, BIO_CB_WRITE | BIO_CB_RETURN, data,
 363                                      dlen, 0, 0L, ret, &local_written);
 364
 365     if (written != NULL)
 366         *written = local_written;
 367     return ret;
 368 }
 369
 370 int BIO_write(BIO *b, const void *data, int dlen)
 371 {
 372     size_t written;
 373     int ret;
 374
 375     if (dlen <= 0)
 376         return 0;
 377
 378     ret = bio_write_intern(b, data, (size_t)dlen, &written);
 379
 380     if (ret > 0) {
 381         /* written should always be <= dlen */
 382         ret = (int)written;
 383     }
 384
 385     return ret;
 386 }
 387
 388 int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written)
 389 {
 390     return bio_write_intern(b, data, dlen, written) > 0
 391         || (b != NULL && dlen == 0); /* order is important for *written */
 392 }
 393
 394 int BIO_sendmmsg(BIO *b, BIO_MSG *msg,
 395                  size_t stride, size_t num_msg, uint64_t flags,
 396                  size_t *msgs_processed)
 397 {
 398     size_t ret;
 399     BIO_MMSG_CB_ARGS args;
 400
 401     if (b == NULL) {
 402         *msgs_processed = 0;
 403         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 404         return 0;
 405     }
 406
 407     if (b->method == NULL || b->method->bsendmmsg == NULL) {
 408         *msgs_processed = 0;
 409         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 410         return 0;
 411     }
 412
 413     if (HAS_CALLBACK(b)) {
 414         args.msg            = msg;
 415         args.stride         = stride;
 416         args.num_msg        = num_msg;
 417         args.flags          = flags;
 418         args.msgs_processed = msgs_processed;
 419
 420         ret = (size_t)bio_call_callback(b, BIO_CB_SENDMMSG, (void *)&args,
 421                                         0, 0, 0, 1, NULL);
 422         if (ret <= 0)
 423             return 0;
 424     }
 425
 426     if (!b->init) {
 427         *msgs_processed = 0;
 428         ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
 429         return 0;
 430     }
 431
 432     ret = b->method->bsendmmsg(b, msg, stride, num_msg, flags, msgs_processed);
 433
 434     if (HAS_CALLBACK(b))
 435         ret = (size_t)bio_call_callback(b, BIO_CB_SENDMMSG | BIO_CB_RETURN,
 436                                         (void *)&args, ret, 0, 0, ret, NULL);
 437
 438     return ret;
 439 }
 440
 441 int BIO_recvmmsg(BIO *b, BIO_MSG *msg,
 442                  size_t stride, size_t num_msg, uint64_t flags,
 443                  size_t *msgs_processed)
 444 {
 445     size_t ret;
 446     BIO_MMSG_CB_ARGS args;
 447
 448     if (b == NULL) {
 449         *msgs_processed = 0;
 450         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 451         return 0;
 452     }
 453
 454     if (b->method == NULL || b->method->brecvmmsg == NULL) {
 455         *msgs_processed = 0;
 456         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 457         return 0;
 458     }
 459
 460     if (HAS_CALLBACK(b)) {
 461         args.msg            = msg;
 462         args.stride         = stride;
 463         args.num_msg        = num_msg;
 464         args.flags          = flags;
 465         args.msgs_processed = msgs_processed;
 466
 467         ret = bio_call_callback(b, BIO_CB_RECVMMSG, (void *)&args,
 468                                 0, 0, 0, 1, NULL);
 469         if (ret <= 0)
 470             return 0;
 471     }
 472
 473     if (!b->init) {
 474         *msgs_processed = 0;
 475         ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
 476         return 0;
 477     }
 478
 479     ret = b->method->brecvmmsg(b, msg, stride, num_msg, flags, msgs_processed);
 480
 481     if (HAS_CALLBACK(b))
 482         ret = (size_t)bio_call_callback(b, BIO_CB_RECVMMSG | BIO_CB_RETURN,
 483                                         (void *)&args, ret, 0, 0, ret, NULL);
 484
 485     return ret;
 486 }
 487
 488 int BIO_get_rpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc)
 489 {
 490     return BIO_ctrl(b, BIO_CTRL_GET_RPOLL_DESCRIPTOR, 0, desc);
 491 }
 492
 493 int BIO_get_wpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc)
 494 {
 495     return BIO_ctrl(b, BIO_CTRL_GET_WPOLL_DESCRIPTOR, 0, desc);
 496 }
 497
 498 int BIO_puts(BIO *b, const char *buf)
 499 {
 500     int ret;
 501     size_t written = 0;
 502
 503     if (b == NULL) {
 504         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 505         return -1;
 506     }
 507     if (b->method == NULL || b->method->bputs == NULL) {
 508         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 509         return -2;
 510     }
 511
 512     if (HAS_CALLBACK(b)) {
 513         ret = (int)bio_call_callback(b, BIO_CB_PUTS, buf, 0, 0, 0L, 1L, NULL);
 514         if (ret <= 0)
 515             return ret;
 516     }
 517
 518     if (!b->init) {
 519         ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
 520         return -1;
 521     }
 522
 523     ret = b->method->bputs(b, buf);
 524
 525     if (ret > 0) {
 526         b->num_write += (uint64_t)ret;
 527         written = ret;
 528         ret = 1;
 529     }
 530
 531     if (HAS_CALLBACK(b))
 532         ret = (int)bio_call_callback(b, BIO_CB_PUTS | BIO_CB_RETURN, buf, 0, 0,
 533                                      0L, ret, &written);
 534
 535     if (ret > 0) {
 536         if (written > INT_MAX) {
 537             ERR_raise(ERR_LIB_BIO, BIO_R_LENGTH_TOO_LONG);
 538             ret = -1;
 539         } else {
 540             ret = (int)written;
 541         }
 542     }
 543
 544     return ret;
 545 }
 546
 547 int BIO_gets(BIO *b, char *buf, int size)
 548 {
 549     int ret;
 550     size_t readbytes = 0;
 551
 552     if (b == NULL) {
 553         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 554         return -1;
 555     }
 556     if (b->method == NULL || b->method->bgets == NULL) {
 557         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 558         return -2;
 559     }
 560
 561     if (size < 0) {
 562         ERR_raise(ERR_LIB_BIO, BIO_R_INVALID_ARGUMENT);
 563         return -1;
 564     }
 565
 566     if (HAS_CALLBACK(b)) {
 567         ret = (int)bio_call_callback(b, BIO_CB_GETS, buf, size, 0, 0L, 1, NULL);
 568         if (ret <= 0)
 569             return ret;
 570     }
 571
 572     if (!b->init) {
 573         ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
 574         return -1;
 575     }
 576
 577     ret = b->method->bgets(b, buf, size);
 578
 579     if (ret > 0) {
 580         readbytes = ret;
 581         ret = 1;
 582     }
 583
 584     if (HAS_CALLBACK(b))
 585         ret = (int)bio_call_callback(b, BIO_CB_GETS | BIO_CB_RETURN, buf, size,
 586                                      0, 0L, ret, &readbytes);
 587
 588     if (ret > 0) {
 589         /* Shouldn't happen */
 590         if (readbytes > (size_t)size)
 591             ret = -1;
 592         else
 593             ret = (int)readbytes;
 594     }
 595
 596     return ret;
 597 }
 598
 599 int BIO_get_line(BIO *bio, char *buf, int size)
 600 {
 601     int ret = 0;
 602     char *ptr = buf;
 603
 604     if (buf == NULL) {
 605         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 606         return -1;
 607     }
 608     if (size <= 0) {
 609         ERR_raise(ERR_LIB_BIO, BIO_R_INVALID_ARGUMENT);
 610         return -1;
 611     }
 612     *buf = '\0';
 613
 614     if (bio == NULL) {
 615         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 616         return -1;
 617     }
 618     if (!bio->init) {
 619         ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
 620         return -1;
 621     }
 622
 623     while (size-- > 1 && (ret = BIO_read(bio, ptr, 1)) > 0)
 624         if (*ptr++ == '\n')
 625             break;
 626     *ptr = '\0';
 627     return ret > 0 || BIO_eof(bio) ? ptr - buf : ret;
 628 }
 629
 630 int BIO_indent(BIO *b, int indent, int max)
 631 {
 632     if (indent < 0)
 633         indent = 0;
 634     if (indent > max)
 635         indent = max;
 636     while (indent--)
 637         if (BIO_puts(b, " ") != 1)
 638             return 0;
 639     return 1;
 640 }
 641
 642 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
 643 {
 644     int i;
 645
 646     i = iarg;
 647     return BIO_ctrl(b, cmd, larg, (char *)&i);
 648 }
 649
 650 void *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
 651 {
 652     void *p = NULL;
 653
 654     if (BIO_ctrl(b, cmd, larg, (char *)&p) <= 0)
 655         return NULL;
 656     else
 657         return p;
 658 }
 659
 660 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
 661 {
 662     long ret;
 663
 664     if (b == NULL)
 665         return -1;
 666     if (b->method == NULL || b->method->ctrl == NULL) {
 667         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 668         return -2;
 669     }
 670
 671     if (HAS_CALLBACK(b)) {
 672         ret = bio_call_callback(b, BIO_CB_CTRL, parg, 0, cmd, larg, 1L, NULL);
 673         if (ret <= 0)
 674             return ret;
 675     }
 676
 677     ret = b->method->ctrl(b, cmd, larg, parg);
 678
 679     if (HAS_CALLBACK(b))
 680         ret = bio_call_callback(b, BIO_CB_CTRL | BIO_CB_RETURN, parg, 0, cmd,
 681                                 larg, ret, NULL);
 682
 683     return ret;
 684 }
 685
 686 long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
 687 {
 688     long ret;
 689
 690     if (b == NULL)
 691         return -2;
 692     if (b->method == NULL || b->method->callback_ctrl == NULL
 693             || cmd != BIO_CTRL_SET_CALLBACK) {
 694         ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
 695         return -2;
 696     }
 697
 698     if (HAS_CALLBACK(b)) {
 699         ret = bio_call_callback(b, BIO_CB_CTRL, (void *)&fp, 0, cmd, 0, 1L,
 700                                 NULL);
 701         if (ret <= 0)
 702             return ret;
 703     }
 704
 705     ret = b->method->callback_ctrl(b, cmd, fp);
 706
 707     if (HAS_CALLBACK(b))
 708         ret = bio_call_callback(b, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, 0,
 709                                 cmd, 0, ret, NULL);
 710
 711     return ret;
 712 }
 713
 714 /*
 715  * It is unfortunate to duplicate in functions what the BIO_(w)pending macros
 716  * do; but those macros have inappropriate return type, and for interfacing
 717  * from other programming languages, C macros aren't much of a help anyway.
 718  */
 719 size_t BIO_ctrl_pending(BIO *bio)
 720 {
 721     long ret = BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
 722
 723     if (ret < 0)
 724         ret = 0;
 725 #if LONG_MAX > SIZE_MAX
 726     if (ret > SIZE_MAX)
 727         ret = SIZE_MAX;
 728 #endif
 729     return (size_t)ret;
 730 }
 731
 732 size_t BIO_ctrl_wpending(BIO *bio)
 733 {
 734     long ret = BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
 735
 736     if (ret < 0)
 737         ret = 0;
 738 #if LONG_MAX > SIZE_MAX
 739     if (ret > SIZE_MAX)
 740         ret = SIZE_MAX;
 741 #endif
 742     return (size_t)ret;
 743 }
 744
 745 /* put the 'bio' on the end of b's list of operators */
 746 BIO *BIO_push(BIO *b, BIO *bio)
 747 {
 748     BIO *lb;
 749
 750     if (b == NULL)
 751         return bio;
 752     lb = b;
 753     while (lb->next_bio != NULL)
 754         lb = lb->next_bio;
 755     lb->next_bio = bio;
 756     if (bio != NULL)
 757         bio->prev_bio = lb;
 758     /* called to do internal processing */
 759     BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
 760     return b;
 761 }
 762
 763 /* Remove the first and return the rest */
 764 BIO *BIO_pop(BIO *b)
 765 {
 766     BIO *ret;
 767
 768     if (b == NULL)
 769         return NULL;
 770     ret = b->next_bio;
 771
 772     BIO_ctrl(b, BIO_CTRL_POP, 0, b);
 773
 774     if (b->prev_bio != NULL)
 775         b->prev_bio->next_bio = b->next_bio;
 776     if (b->next_bio != NULL)
 777         b->next_bio->prev_bio = b->prev_bio;
 778
 779     b->next_bio = NULL;
 780     b->prev_bio = NULL;
 781     return ret;
 782 }
 783
 784 BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
 785 {
 786     BIO *b, *last;
 787
 788     b = last = bio;
 789     for (;;) {
 790         if (!BIO_should_retry(b))
 791             break;
 792         last = b;
 793         b = b->next_bio;
 794         if (b == NULL)
 795             break;
 796     }
 797     if (reason != NULL)
 798         *reason = last->retry_reason;
 799     return last;
 800 }
 801
 802 int BIO_get_retry_reason(BIO *bio)
 803 {
 804     return bio->retry_reason;
 805 }
 806
 807 void BIO_set_retry_reason(BIO *bio, int reason)
 808 {
 809     bio->retry_reason = reason;
 810 }
 811
 812 BIO *BIO_find_type(BIO *bio, int type)
 813 {
 814     int mt, mask;
 815
 816     if (bio == NULL) {
 817         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
 818         return NULL;
 819     }
 820     mask = type & BIO_TYPE_MASK;
 821     do {
 822         if (bio->method != NULL) {
 823             mt = bio->method->type;
 824
 825             if (!mask) {
 826                 if (mt & type)
 827                     return bio;
 828             } else if (mt == type) {
 829                 return bio;
 830             }
 831         }
 832         bio = bio->next_bio;
 833     } while (bio != NULL);
 834     return NULL;
 835 }
 836
 837 BIO *BIO_next(BIO *b)
 838 {
 839     if (b == NULL)
 840         return NULL;
 841     return b->next_bio;
 842 }
 843
 844 void BIO_set_next(BIO *b, BIO *next)
 845 {
 846     b->next_bio = next;
 847 }
 848
 849 void BIO_free_all(BIO *bio)
 850 {
 851     BIO *b;
 852     int ref;
 853
 854     while (bio != NULL) {
 855         b = bio;
 856         CRYPTO_GET_REF(&b->references, &ref);
 857         bio = bio->next_bio;
 858         BIO_free(b);
 859         /* Since ref count > 1, don't free anyone else. */
 860         if (ref > 1)
 861             break;
 862     }
 863 }
 864
 865 BIO *BIO_dup_chain(BIO *in)
 866 {
 867     BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
 868
 869     for (bio = in; bio != NULL; bio = bio->next_bio) {
 870         if ((new_bio = BIO_new(bio->method)) == NULL)
 871             goto err;
 872 #ifndef OPENSSL_NO_DEPRECATED_3_0
 873         new_bio->callback = bio->callback;
 874 #endif
 875         new_bio->callback_ex = bio->callback_ex;
 876         new_bio->cb_arg = bio->cb_arg;
 877         new_bio->init = bio->init;
 878         new_bio->shutdown = bio->shutdown;
 879         new_bio->flags = bio->flags;
 880
 881         /* This will let SSL_s_sock() work with stdin/stdout */
 882         new_bio->num = bio->num;
 883
 884         if (BIO_dup_state(bio, (char *)new_bio) <= 0) {
 885             BIO_free(new_bio);
 886             goto err;
 887         }
 888
 889         /* copy app data */
 890         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
 891                                 &bio->ex_data)) {
 892             BIO_free(new_bio);
 893             goto err;
 894         }
 895
 896         if (ret == NULL) {
 897             eoc = new_bio;
 898             ret = eoc;
 899         } else {
 900             BIO_push(eoc, new_bio);
 901             eoc = new_bio;
 902         }
 903     }
 904     return ret;
 905  err:
 906     BIO_free_all(ret);
 907
 908     return NULL;
 909 }
 910
 911 void BIO_copy_next_retry(BIO *b)
 912 {
 913     BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
 914     b->retry_reason = b->next_bio->retry_reason;
 915 }
 916
 917 int BIO_set_ex_data(BIO *bio, int idx, void *data)
 918 {
 919     return CRYPTO_set_ex_data(&(bio->ex_data), idx, data);
 920 }
 921
 922 void *BIO_get_ex_data(const BIO *bio, int idx)
 923 {
 924     return CRYPTO_get_ex_data(&(bio->ex_data), idx);
 925 }
 926
 927 uint64_t BIO_number_read(BIO *bio)
 928 {
 929     if (bio)
 930         return bio->num_read;
 931     return 0;
 932 }
 933
 934 uint64_t BIO_number_written(BIO *bio)
 935 {
 936     if (bio)
 937         return bio->num_write;
 938     return 0;
 939 }
 940
 941 void bio_free_ex_data(BIO *bio)
 942 {
 943     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 944 }
 945
 946 void bio_cleanup(void)
 947 {
 948 #ifndef OPENSSL_NO_SOCK
 949     bio_sock_cleanup_int();
 950     CRYPTO_THREAD_lock_free(bio_lookup_lock);
 951     bio_lookup_lock = NULL;
 952 #endif
 953     CRYPTO_FREE_REF(&bio_type_count);
 954 }
 955
 956 /* Internal variant of the below BIO_wait() not calling ERR_raise(...) */
 957 static int bio_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds)
 958 {
 959 #ifndef OPENSSL_NO_SOCK
 960     int fd;
 961 #endif
 962     long sec_diff;
 963
 964     if (max_time == 0) /* no timeout */
 965         return 1;
 966
 967 #ifndef OPENSSL_NO_SOCK
 968     if (BIO_get_fd(bio, &fd) > 0 && fd < FD_SETSIZE)
 969         return BIO_socket_wait(fd, BIO_should_read(bio), max_time);
 970 #endif
 971     /* fall back to polling since no sockets are available */
 972
 973     sec_diff = (long)(max_time - time(NULL)); /* might overflow */
 974     if (sec_diff < 0)
 975         return 0; /* clearly timeout */
 976
 977     /* now take a nap at most the given number of milliseconds */
 978     if (sec_diff == 0) { /* we are below the 1 seconds resolution of max_time */
 979         if (nap_milliseconds > 1000)
 980             nap_milliseconds = 1000;
 981     } else { /* for sec_diff > 0, take min(sec_diff * 1000, nap_milliseconds) */
 982         if ((unsigned long)sec_diff * 1000 < nap_milliseconds)
 983             nap_milliseconds = (unsigned int)sec_diff * 1000;
 984     }
 985     OSSL_sleep(nap_milliseconds);
 986     return 1;
 987 }
 988
 989 /*-
 990  * Wait on (typically socket-based) BIO at most until max_time.
 991  * Succeed immediately if max_time == 0.
 992  * If sockets are not available support polling: succeed after waiting at most
 993  * the number of nap_milliseconds in order to avoid a tight busy loop.
 994  * Call ERR_raise(ERR_LIB_BIO, ...) on timeout or error.
 995  * Returns -1 on error, 0 on timeout, and 1 on success.
 996  */
 997 int BIO_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds)
 998 {
 999     int rv = bio_wait(bio, max_time, nap_milliseconds);
1000
1001     if (rv <= 0)
1002         ERR_raise(ERR_LIB_BIO,
1003                   rv == 0 ? BIO_R_TRANSFER_TIMEOUT : BIO_R_TRANSFER_ERROR);
1004     return rv;
1005 }
1006
1007 /*
1008  * Connect via given BIO using BIO_do_connect() until success/timeout/error.
1009  * Parameter timeout == 0 means no timeout, < 0 means exactly one try.
1010  * For non-blocking and potentially even non-socket BIOs perform polling with
1011  * the given density: between polls sleep nap_milliseconds using BIO_wait()
1012  * in order to avoid a tight busy loop.
1013  * Returns -1 on error, 0 on timeout, and 1 on success.
1014  */
1015 int BIO_do_connect_retry(BIO *bio, int timeout, int nap_milliseconds)
1016 {
1017     int blocking = timeout <= 0;
1018     time_t max_time = timeout > 0 ? time(NULL) + timeout : 0;
1019     int rv;
1020
1021     if (bio == NULL) {
1022         ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
1023         return -1;
1024     }
1025
1026     if (nap_milliseconds < 0)
1027         nap_milliseconds = 100;
1028     BIO_set_nbio(bio, !blocking);
1029
1030  retry:
1031     ERR_set_mark();
1032     rv = BIO_do_connect(bio);
1033
1034     if (rv <= 0) { /* could be timeout or retryable error or fatal error */
1035         int err = ERR_peek_last_error();
1036         int reason = ERR_GET_REASON(err);
1037         int do_retry = BIO_should_retry(bio); /* may be 1 only if !blocking */
1038
1039         if (ERR_GET_LIB(err) == ERR_LIB_BIO) {
1040             switch (reason) {
1041             case ERR_R_SYS_LIB:
1042                 /*
1043                  * likely retryable system error occurred, which may be
1044                  * EAGAIN (resource temporarily unavailable) some 40 secs after
1045                  * calling getaddrinfo(): Temporary failure in name resolution
1046                  * or a premature ETIMEDOUT, some 30 seconds after connect()
1047                  */
1048             case BIO_R_CONNECT_ERROR:
1049             case BIO_R_NBIO_CONNECT_ERROR:
1050                 /* some likely retryable connection error occurred */
1051                 (void)BIO_reset(bio); /* often needed to avoid retry failure */
1052                 do_retry = 1;
1053                 break;
1054             default:
1055                 break;
1056             }
1057         }
1058         if (timeout >= 0 && do_retry) {
1059             ERR_pop_to_mark();
1060             /* will not actually wait if timeout == 0 (i.e., blocking BIO): */
1061             rv = bio_wait(bio, max_time, nap_milliseconds);
1062             if (rv > 0)
1063                 goto retry;
1064             ERR_raise(ERR_LIB_BIO,
1065                       rv == 0 ? BIO_R_CONNECT_TIMEOUT : BIO_R_CONNECT_ERROR);
1066         } else {
1067             ERR_clear_last_mark();
1068             rv = -1;
1069             if (err == 0) /* missing error queue entry */
1070                 /* workaround: general error */
1071                 ERR_raise(ERR_LIB_BIO, BIO_R_CONNECT_ERROR);
1072         }
1073     } else {
1074         ERR_clear_last_mark();
1075     }
1076
1077     return rv;
1078 }