crypto/bio/bio_lib.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <errno.h>
  12 #include <openssl/crypto.h>
  13 #include "bio_lcl.h"
  14 #include "internal/cryptlib.h"
  15
  16 BIO *BIO_new(const BIO_METHOD *method)
  17 {
  18     BIO *bio = OPENSSL_zalloc(sizeof(*bio));
  19
  20     if (bio == NULL) {
  21         BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
  22         return (NULL);
  23     }
  24
  25     bio->method = method;
  26     bio->shutdown = 1;
  27     bio->references = 1;
  28
  29     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data))
  30         goto err;
  31
  32     bio->lock = CRYPTO_THREAD_lock_new();
  33     if (bio->lock == NULL) {
  34         BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
  35         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
  36         goto err;
  37     }
  38
  39     if (method->create != NULL && !method->create(bio)) {
  40         BIOerr(BIO_F_BIO_NEW, ERR_R_INIT_FAIL);
  41         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
  42         CRYPTO_THREAD_lock_free(bio->lock);
  43         goto err;
  44     }
  45
  46     return bio;
  47
  48 err:
  49     OPENSSL_free(bio);
  50     return NULL;
  51 }
  52
  53 int BIO_free(BIO *a)
  54 {
  55     int i;
  56
  57     if (a == NULL)
  58         return 0;
  59
  60     if (CRYPTO_atomic_add(&a->references, -1, &i, a->lock) <= 0)
  61         return 0;
  62
  63     REF_PRINT_COUNT("BIO", a);
  64     if (i > 0)
  65         return 1;
  66     REF_ASSERT_ISNT(i < 0);
  67     if ((a->callback != NULL) &&
  68         ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
  69         return i;
  70
  71     if ((a->method != NULL) && (a->method->destroy != NULL))
  72         a->method->destroy(a);
  73
  74     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
  75
  76     CRYPTO_THREAD_lock_free(a->lock);
  77
  78     OPENSSL_free(a);
  79
  80     return 1;
  81 }
  82
  83 void BIO_set_data(BIO *a, void *ptr)
  84 {
  85     a->ptr = ptr;
  86 }
  87
  88 void *BIO_get_data(BIO *a)
  89 {
  90     return a->ptr;
  91 }
  92
  93 void BIO_set_init(BIO *a, int init)
  94 {
  95     a->init = init;
  96 }
  97
  98 int BIO_get_init(BIO *a)
  99 {
 100     return a->init;
 101 }
 102
 103 void BIO_set_shutdown(BIO *a, int shut)
 104 {
 105     a->shutdown = shut;
 106 }
 107
 108 int BIO_get_shutdown(BIO *a)
 109 {
 110     return a->shutdown;
 111 }
 112
 113 void BIO_vfree(BIO *a)
 114 {
 115     BIO_free(a);
 116 }
 117
 118 int BIO_up_ref(BIO *a)
 119 {
 120     int i;
 121
 122     if (CRYPTO_atomic_add(&a->references, 1, &i, a->lock) <= 0)
 123         return 0;
 124
 125     REF_PRINT_COUNT("BIO", a);
 126     REF_ASSERT_ISNT(i < 2);
 127     return ((i > 1) ? 1 : 0);
 128 }
 129
 130 void BIO_clear_flags(BIO *b, int flags)
 131 {
 132     b->flags &= ~flags;
 133 }
 134
 135 int BIO_test_flags(const BIO *b, int flags)
 136 {
 137     return (b->flags & flags);
 138 }
 139
 140 void BIO_set_flags(BIO *b, int flags)
 141 {
 142     b->flags |= flags;
 143 }
 144
 145 BIO_callback_fn BIO_get_callback(const BIO *b)
 146 {
 147     return b->callback;
 148 }
 149
 150 void BIO_set_callback(BIO *b, BIO_callback_fn cb)
 151 {
 152     b->callback = cb;
 153 }
 154
 155 BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b)
 156 {
 157     return b->callback_ex;
 158 }
 159
 160 void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex cb)
 161 {
 162     b->callback_ex = cb;
 163 }
 164
 165 void BIO_set_callback_arg(BIO *b, char *arg)
 166 {
 167     b->cb_arg = arg;
 168 }
 169
 170 char *BIO_get_callback_arg(const BIO *b)
 171 {
 172     return b->cb_arg;
 173 }
 174
 175 const char *BIO_method_name(const BIO *b)
 176 {
 177     return b->method->name;
 178 }
 179
 180 int BIO_method_type(const BIO *b)
 181 {
 182     return b->method->type;
 183 }
 184
 185 static int bio_call_callback(BIO *b, int oper, const char *argp, size_t len,
 186                              int argi, long argl, int inret, size_t *processed,
 187                              long *lret)
 188 {
 189     long ret;
 190     int bareoper;
 191
 192     if (b->callback_ex != NULL) {
 193         return b->callback_ex(b, oper, argp, len, argi, argl, inret, processed,
 194                               lret);
 195     }
 196
 197     /* Strip off the BIO_CB_RETURN flag */
 198     bareoper = oper & ~BIO_CB_RETURN;
 199     /*
 200      * We have an old style callback, so we will have to do nasty casts and
 201      * check for overflows.
 202      */
 203     if (bareoper == BIO_CB_READ || bareoper == BIO_CB_WRITE
 204             || bareoper == BIO_CB_GETS) {
 205         /* In this case |len| is set, and should be used instead of |argi| */
 206         if (len > INT_MAX)
 207             return 0;
 208
 209         argi = (int)len;
 210
 211         if (inret && (oper & BIO_CB_RETURN)) {
 212             if (*processed > INT_MAX)
 213                 return 0;
 214             inret = *processed;
 215         }
 216     }
 217
 218     ret = b->callback(b, oper, argp, argi, argl, inret);
 219     if (bareoper == BIO_CB_CTRL)
 220         return 1;
 221
 222     if (ret > INT_MAX || ret < INT_MIN)
 223         return 0;
 224
 225     if (lret != NULL)
 226         *lret = ret;
 227
 228     if (ret >= 0) {
 229         *processed = (size_t)ret;
 230         ret = 1;
 231     }
 232
 233     return (int)ret;
 234 }
 235
 236 int BIO_read(BIO *b, void *out, int outl)
 237 {
 238     size_t read;
 239     int ret;
 240
 241     if (outl < 0)
 242         return 0;
 243
 244     ret = BIO_read_ex(b, out, (size_t)outl, &read);
 245
 246     if (ret > 0) {
 247         /* *read should always be <= outl */
 248         ret = (int)read;
 249     }
 250
 251     return ret;
 252 }
 253
 254 int BIO_read_ex(BIO *b, void *out, size_t outl, size_t *read)
 255 {
 256     int ret;
 257
 258     if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
 259         BIOerr(BIO_F_BIO_READ_EX, BIO_R_UNSUPPORTED_METHOD);
 260         return (-2);
 261     }
 262
 263     if ((b->callback != NULL || b->callback_ex != NULL) &&
 264         ((ret = bio_call_callback(b, BIO_CB_READ, out, outl, 0, 0L, 1L, read,
 265                                   NULL)) <= 0))
 266         return ret;
 267
 268     if (!b->init) {
 269         BIOerr(BIO_F_BIO_READ_EX, BIO_R_UNINITIALIZED);
 270         return -2;
 271     }
 272
 273     ret = b->method->bread(b, out, outl, read);
 274
 275     if (ret > 0)
 276         b->num_read += (uint64_t)*read;
 277
 278     if (b->callback != NULL || b->callback_ex != NULL)
 279         ret = bio_call_callback(b, BIO_CB_READ | BIO_CB_RETURN, out, outl, 0,
 280                                 0L, ret, read, NULL);
 281
 282     return ret;
 283 }
 284
 285 int BIO_write(BIO *b, const void *in, int inl)
 286 {
 287     size_t written;
 288     int ret;
 289
 290     if (inl < 0)
 291         return 0;
 292
 293     ret = BIO_write_ex(b, in, (size_t)inl, &written);
 294
 295     if (ret > 0) {
 296         /* *written should always be <= inl */
 297         ret = (int)written;
 298     }
 299
 300     return ret;
 301 }
 302
 303 int BIO_write_ex(BIO *b, const void *in, size_t inl, size_t *written)
 304 {
 305     int ret;
 306
 307     if (b == NULL)
 308         return (0);
 309
 310     if ((b->method == NULL) || (b->method->bwrite == NULL)) {
 311         BIOerr(BIO_F_BIO_WRITE_EX, BIO_R_UNSUPPORTED_METHOD);
 312         return (-2);
 313     }
 314
 315     if ((b->callback != NULL || b->callback_ex != NULL) &&
 316         ((ret = bio_call_callback(b, BIO_CB_WRITE, in, inl, 0, 0L, 1L, written,
 317                                   NULL)) <= 0))
 318         return ret;
 319
 320     if (!b->init) {
 321         BIOerr(BIO_F_BIO_WRITE_EX, BIO_R_UNINITIALIZED);
 322         return -2;
 323     }
 324
 325     ret = b->method->bwrite(b, in, inl, written);
 326
 327     if (ret > 0)
 328         b->num_write += (uint64_t)*written;
 329
 330     if (b->callback != NULL || b->callback_ex != NULL)
 331         ret = bio_call_callback(b, BIO_CB_WRITE | BIO_CB_RETURN, in, inl, 0,
 332                                 0L, ret, written, NULL);
 333
 334     return ret;
 335 }
 336
 337 int BIO_puts(BIO *b, const char *in)
 338 {
 339     int i;
 340     long (*cb) (BIO *, int, const char *, int, long, long);
 341
 342     if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) {
 343         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNSUPPORTED_METHOD);
 344         return (-2);
 345     }
 346
 347     cb = b->callback;
 348
 349     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_PUTS, in, 0, 0L, 1L)) <= 0))
 350         return (i);
 351
 352     if (!b->init) {
 353         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNINITIALIZED);
 354         return (-2);
 355     }
 356
 357     i = b->method->bputs(b, in);
 358
 359     if (i > 0)
 360         b->num_write += (uint64_t)i;
 361
 362     if (cb != NULL)
 363         i = (int)cb(b, BIO_CB_PUTS | BIO_CB_RETURN, in, 0, 0L, (long)i);
 364     return (i);
 365 }
 366
 367 int BIO_gets(BIO *b, char *in, int inl)
 368 {
 369     int i;
 370     long (*cb) (BIO *, int, const char *, int, long, long);
 371
 372     if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) {
 373         BIOerr(BIO_F_BIO_GETS, BIO_R_UNSUPPORTED_METHOD);
 374         return (-2);
 375     }
 376
 377     cb = b->callback;
 378
 379     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_GETS, in, inl, 0L, 1L)) <= 0))
 380         return (i);
 381
 382     if (!b->init) {
 383         BIOerr(BIO_F_BIO_GETS, BIO_R_UNINITIALIZED);
 384         return (-2);
 385     }
 386
 387     i = b->method->bgets(b, in, inl);
 388
 389     if (cb != NULL)
 390         i = (int)cb(b, BIO_CB_GETS | BIO_CB_RETURN, in, inl, 0L, (long)i);
 391     return (i);
 392 }
 393
 394 int BIO_indent(BIO *b, int indent, int max)
 395 {
 396     if (indent < 0)
 397         indent = 0;
 398     if (indent > max)
 399         indent = max;
 400     while (indent--)
 401         if (BIO_puts(b, " ") != 1)
 402             return 0;
 403     return 1;
 404 }
 405
 406 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
 407 {
 408     int i;
 409
 410     i = iarg;
 411     return (BIO_ctrl(b, cmd, larg, (char *)&i));
 412 }
 413
 414 void *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
 415 {
 416     void *p = NULL;
 417
 418     if (BIO_ctrl(b, cmd, larg, (char *)&p) <= 0)
 419         return (NULL);
 420     else
 421         return (p);
 422 }
 423
 424 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
 425 {
 426     long ret;
 427     long (*cb) (BIO *, int, const char *, int, long, long);
 428
 429     if (b == NULL)
 430         return (0);
 431
 432     if ((b->method == NULL) || (b->method->ctrl == NULL)) {
 433         BIOerr(BIO_F_BIO_CTRL, BIO_R_UNSUPPORTED_METHOD);
 434         return (-2);
 435     }
 436
 437     cb = b->callback;
 438
 439     if ((cb != NULL) &&
 440         ((ret = cb(b, BIO_CB_CTRL, parg, cmd, larg, 1L)) <= 0))
 441         return (ret);
 442
 443     ret = b->method->ctrl(b, cmd, larg, parg);
 444
 445     if (cb != NULL)
 446         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, parg, cmd, larg, ret);
 447     return (ret);
 448 }
 449
 450 long BIO_callback_ctrl(BIO *b, int cmd,
 451                        void (*fp) (struct bio_st *, int, const char *, int,
 452                                    long, long))
 453 {
 454     long ret;
 455     long (*cb) (BIO *, int, const char *, int, long, long);
 456
 457     if (b == NULL)
 458         return (0);
 459
 460     if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) {
 461         BIOerr(BIO_F_BIO_CALLBACK_CTRL, BIO_R_UNSUPPORTED_METHOD);
 462         return (-2);
 463     }
 464
 465     cb = b->callback;
 466
 467     if ((cb != NULL) &&
 468         ((ret = cb(b, BIO_CB_CTRL, (void *)&fp, cmd, 0, 1L)) <= 0))
 469         return (ret);
 470
 471     ret = b->method->callback_ctrl(b, cmd, fp);
 472
 473     if (cb != NULL)
 474         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, cmd, 0, ret);
 475     return (ret);
 476 }
 477
 478 /*
 479  * It is unfortunate to duplicate in functions what the BIO_(w)pending macros
 480  * do; but those macros have inappropriate return type, and for interfacing
 481  * from other programming languages, C macros aren't much of a help anyway.
 482  */
 483 size_t BIO_ctrl_pending(BIO *bio)
 484 {
 485     return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
 486 }
 487
 488 size_t BIO_ctrl_wpending(BIO *bio)
 489 {
 490     return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
 491 }
 492
 493 /* put the 'bio' on the end of b's list of operators */
 494 BIO *BIO_push(BIO *b, BIO *bio)
 495 {
 496     BIO *lb;
 497
 498     if (b == NULL)
 499         return (bio);
 500     lb = b;
 501     while (lb->next_bio != NULL)
 502         lb = lb->next_bio;
 503     lb->next_bio = bio;
 504     if (bio != NULL)
 505         bio->prev_bio = lb;
 506     /* called to do internal processing */
 507     BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
 508     return (b);
 509 }
 510
 511 /* Remove the first and return the rest */
 512 BIO *BIO_pop(BIO *b)
 513 {
 514     BIO *ret;
 515
 516     if (b == NULL)
 517         return (NULL);
 518     ret = b->next_bio;
 519
 520     BIO_ctrl(b, BIO_CTRL_POP, 0, b);
 521
 522     if (b->prev_bio != NULL)
 523         b->prev_bio->next_bio = b->next_bio;
 524     if (b->next_bio != NULL)
 525         b->next_bio->prev_bio = b->prev_bio;
 526
 527     b->next_bio = NULL;
 528     b->prev_bio = NULL;
 529     return (ret);
 530 }
 531
 532 BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
 533 {
 534     BIO *b, *last;
 535
 536     b = last = bio;
 537     for (;;) {
 538         if (!BIO_should_retry(b))
 539             break;
 540         last = b;
 541         b = b->next_bio;
 542         if (b == NULL)
 543             break;
 544     }
 545     if (reason != NULL)
 546         *reason = last->retry_reason;
 547     return (last);
 548 }
 549
 550 int BIO_get_retry_reason(BIO *bio)
 551 {
 552     return (bio->retry_reason);
 553 }
 554
 555 void BIO_set_retry_reason(BIO *bio, int reason)
 556 {
 557     bio->retry_reason = reason;
 558 }
 559
 560 BIO *BIO_find_type(BIO *bio, int type)
 561 {
 562     int mt, mask;
 563
 564     if (bio == NULL)
 565         return NULL;
 566     mask = type & 0xff;
 567     do {
 568         if (bio->method != NULL) {
 569             mt = bio->method->type;
 570
 571             if (!mask) {
 572                 if (mt & type)
 573                     return (bio);
 574             } else if (mt == type)
 575                 return (bio);
 576         }
 577         bio = bio->next_bio;
 578     } while (bio != NULL);
 579     return (NULL);
 580 }
 581
 582 BIO *BIO_next(BIO *b)
 583 {
 584     if (b == NULL)
 585         return NULL;
 586     return b->next_bio;
 587 }
 588
 589 void BIO_set_next(BIO *b, BIO *next)
 590 {
 591     b->next_bio = next;
 592 }
 593
 594 void BIO_free_all(BIO *bio)
 595 {
 596     BIO *b;
 597     int ref;
 598
 599     while (bio != NULL) {
 600         b = bio;
 601         ref = b->references;
 602         bio = bio->next_bio;
 603         BIO_free(b);
 604         /* Since ref count > 1, don't free anyone else. */
 605         if (ref > 1)
 606             break;
 607     }
 608 }
 609
 610 BIO *BIO_dup_chain(BIO *in)
 611 {
 612     BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
 613
 614     for (bio = in; bio != NULL; bio = bio->next_bio) {
 615         if ((new_bio = BIO_new(bio->method)) == NULL)
 616             goto err;
 617         new_bio->callback = bio->callback;
 618         new_bio->cb_arg = bio->cb_arg;
 619         new_bio->init = bio->init;
 620         new_bio->shutdown = bio->shutdown;
 621         new_bio->flags = bio->flags;
 622
 623         /* This will let SSL_s_sock() work with stdin/stdout */
 624         new_bio->num = bio->num;
 625
 626         if (!BIO_dup_state(bio, (char *)new_bio)) {
 627             BIO_free(new_bio);
 628             goto err;
 629         }
 630
 631         /* copy app data */
 632         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
 633                                 &bio->ex_data)) {
 634             BIO_free(new_bio);
 635             goto err;
 636         }
 637
 638         if (ret == NULL) {
 639             eoc = new_bio;
 640             ret = eoc;
 641         } else {
 642             BIO_push(eoc, new_bio);
 643             eoc = new_bio;
 644         }
 645     }
 646     return (ret);
 647  err:
 648     BIO_free_all(ret);
 649
 650     return (NULL);
 651 }
 652
 653 void BIO_copy_next_retry(BIO *b)
 654 {
 655     BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
 656     b->retry_reason = b->next_bio->retry_reason;
 657 }
 658
 659 int BIO_set_ex_data(BIO *bio, int idx, void *data)
 660 {
 661     return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data));
 662 }
 663
 664 void *BIO_get_ex_data(BIO *bio, int idx)
 665 {
 666     return (CRYPTO_get_ex_data(&(bio->ex_data), idx));
 667 }
 668
 669 uint64_t BIO_number_read(BIO *bio)
 670 {
 671     if (bio)
 672         return bio->num_read;
 673     return 0;
 674 }
 675
 676 uint64_t BIO_number_written(BIO *bio)
 677 {
 678     if (bio)
 679         return bio->num_write;
 680     return 0;
 681 }
 682
 683 void bio_free_ex_data(BIO *bio)
 684 {
 685     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 686 }
 687
 688 void bio_cleanup(void)
 689 {
 690 #ifndef OPENSSL_NO_SOCK
 691     bio_sock_cleanup_int();
 692     CRYPTO_THREAD_lock_free(bio_lookup_lock);
 693     bio_lookup_lock = NULL;
 694 #endif
 695     CRYPTO_THREAD_lock_free(bio_type_lock);
 696     bio_type_lock = NULL;
 697 }