crypto/bio/bio_lib.c

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