crypto/bio/bio_lib.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.]
  56  */
  57
  58 #include <stdio.h>
  59 #include <errno.h>
  60 #include <openssl/crypto.h>
  61 #include "bio_lcl.h"
  62 #include "internal/cryptlib.h"
  63 #include <openssl/stack.h>
  64
  65 BIO *BIO_new(const BIO_METHOD *method)
  66 {
  67     BIO *ret = OPENSSL_malloc(sizeof(*ret));
  68
  69     if (ret == NULL) {
  70         BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
  71         return (NULL);
  72     }
  73     if (!BIO_set(ret, method)) {
  74         OPENSSL_free(ret);
  75         ret = NULL;
  76     }
  77     return (ret);
  78 }
  79
  80 int BIO_set(BIO *bio, const BIO_METHOD *method)
  81 {
  82     bio->method = method;
  83     bio->callback = NULL;
  84     bio->cb_arg = NULL;
  85     bio->init = 0;
  86     bio->shutdown = 1;
  87     bio->flags = 0;
  88     bio->retry_reason = 0;
  89     bio->num = 0;
  90     bio->ptr = NULL;
  91     bio->prev_bio = NULL;
  92     bio->next_bio = NULL;
  93     bio->references = 1;
  94     bio->num_read = 0L;
  95     bio->num_write = 0L;
  96     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data))
  97         return 0;
  98
  99     bio->lock = CRYPTO_THREAD_lock_new();
 100     if (bio->lock == NULL) {
 101         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 102         return 0;
 103     }
 104
 105     if (method->create != NULL) {
 106         if (!method->create(bio)) {
 107             CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 108             CRYPTO_THREAD_lock_free(bio->lock);
 109             return 0;
 110         }
 111     }
 112
 113     return 1;
 114 }
 115
 116 int BIO_free(BIO *a)
 117 {
 118     int i;
 119
 120     if (a == NULL)
 121         return 0;
 122
 123     if (CRYPTO_atomic_add(&a->references, -1, &i, a->lock) <= 0)
 124         return 0;
 125
 126     REF_PRINT_COUNT("BIO", a);
 127     if (i > 0)
 128         return 1;
 129     REF_ASSERT_ISNT(i < 0);
 130     if ((a->callback != NULL) &&
 131         ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
 132         return i;
 133
 134     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
 135
 136     CRYPTO_THREAD_lock_free(a->lock);
 137
 138     if ((a->method != NULL) && (a->method->destroy != NULL))
 139         a->method->destroy(a);
 140
 141     OPENSSL_free(a);
 142
 143     return 1;
 144 }
 145
 146 void BIO_set_data(BIO *a, void *ptr)
 147 {
 148     a->ptr = ptr;
 149 }
 150
 151 void *BIO_get_data(BIO *a)
 152 {
 153     return a->ptr;
 154 }
 155
 156 void BIO_set_init(BIO *a, int init)
 157 {
 158     a->init = init;
 159 }
 160
 161 int BIO_get_init(BIO *a)
 162 {
 163     return a->init;
 164 }
 165
 166 void BIO_set_shutdown(BIO *a, int shut)
 167 {
 168     a->shutdown = shut;
 169 }
 170
 171 int BIO_get_shutdown(BIO *a)
 172 {
 173     return a->shutdown;
 174 }
 175
 176 void BIO_vfree(BIO *a)
 177 {
 178     BIO_free(a);
 179 }
 180
 181 int BIO_up_ref(BIO *a)
 182 {
 183     int i;
 184
 185     if (CRYPTO_atomic_add(&a->references, 1, &i, a->lock) <= 0)
 186         return 0;
 187
 188     REF_PRINT_COUNT("BIO", a);
 189     REF_ASSERT_ISNT(i < 2);
 190     return ((i > 1) ? 1 : 0);
 191 }
 192
 193 void BIO_clear_flags(BIO *b, int flags)
 194 {
 195     b->flags &= ~flags;
 196 }
 197
 198 int BIO_test_flags(const BIO *b, int flags)
 199 {
 200     return (b->flags & flags);
 201 }
 202
 203 void BIO_set_flags(BIO *b, int flags)
 204 {
 205     b->flags |= flags;
 206 }
 207
 208 long (*BIO_get_callback(const BIO *b)) (struct bio_st *, int, const char *,
 209                                         int, long, long) {
 210     return b->callback;
 211 }
 212
 213 void BIO_set_callback(BIO *b,
 214                       long (*cb) (struct bio_st *, int, const char *, int,
 215                                   long, long))
 216 {
 217     b->callback = cb;
 218 }
 219
 220 void BIO_set_callback_arg(BIO *b, char *arg)
 221 {
 222     b->cb_arg = arg;
 223 }
 224
 225 char *BIO_get_callback_arg(const BIO *b)
 226 {
 227     return b->cb_arg;
 228 }
 229
 230 const char *BIO_method_name(const BIO *b)
 231 {
 232     return b->method->name;
 233 }
 234
 235 int BIO_method_type(const BIO *b)
 236 {
 237     return b->method->type;
 238 }
 239
 240 int BIO_read(BIO *b, void *out, int outl)
 241 {
 242     int i;
 243     long (*cb) (BIO *, int, const char *, int, long, long);
 244
 245     if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
 246         BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD);
 247         return (-2);
 248     }
 249
 250     cb = b->callback;
 251     if ((cb != NULL) &&
 252         ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0))
 253         return (i);
 254
 255     if (!b->init) {
 256         BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED);
 257         return (-2);
 258     }
 259
 260     i = b->method->bread(b, out, outl);
 261
 262     if (i > 0)
 263         b->num_read += (uint64_t)i;
 264
 265     if (cb != NULL)
 266         i = (int)cb(b, BIO_CB_READ | BIO_CB_RETURN, out, outl, 0L, (long)i);
 267     return (i);
 268 }
 269
 270 int BIO_write(BIO *b, const void *in, int inl)
 271 {
 272     int i;
 273     long (*cb) (BIO *, int, const char *, int, long, long);
 274
 275     if (b == NULL)
 276         return (0);
 277
 278     cb = b->callback;
 279     if ((b->method == NULL) || (b->method->bwrite == NULL)) {
 280         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNSUPPORTED_METHOD);
 281         return (-2);
 282     }
 283
 284     if ((cb != NULL) &&
 285         ((i = (int)cb(b, BIO_CB_WRITE, in, inl, 0L, 1L)) <= 0))
 286         return (i);
 287
 288     if (!b->init) {
 289         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNINITIALIZED);
 290         return (-2);
 291     }
 292
 293     i = b->method->bwrite(b, in, inl);
 294
 295     if (i > 0)
 296         b->num_write += (uint64_t)i;
 297
 298     if (cb != NULL)
 299         i = (int)cb(b, BIO_CB_WRITE | BIO_CB_RETURN, in, inl, 0L, (long)i);
 300     return (i);
 301 }
 302
 303 int BIO_puts(BIO *b, const char *in)
 304 {
 305     int i;
 306     long (*cb) (BIO *, int, const char *, int, long, long);
 307
 308     if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) {
 309         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNSUPPORTED_METHOD);
 310         return (-2);
 311     }
 312
 313     cb = b->callback;
 314
 315     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_PUTS, in, 0, 0L, 1L)) <= 0))
 316         return (i);
 317
 318     if (!b->init) {
 319         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNINITIALIZED);
 320         return (-2);
 321     }
 322
 323     i = b->method->bputs(b, in);
 324
 325     if (i > 0)
 326         b->num_write += (uint64_t)i;
 327
 328     if (cb != NULL)
 329         i = (int)cb(b, BIO_CB_PUTS | BIO_CB_RETURN, in, 0, 0L, (long)i);
 330     return (i);
 331 }
 332
 333 int BIO_gets(BIO *b, char *in, int inl)
 334 {
 335     int i;
 336     long (*cb) (BIO *, int, const char *, int, long, long);
 337
 338     if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) {
 339         BIOerr(BIO_F_BIO_GETS, BIO_R_UNSUPPORTED_METHOD);
 340         return (-2);
 341     }
 342
 343     cb = b->callback;
 344
 345     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_GETS, in, inl, 0L, 1L)) <= 0))
 346         return (i);
 347
 348     if (!b->init) {
 349         BIOerr(BIO_F_BIO_GETS, BIO_R_UNINITIALIZED);
 350         return (-2);
 351     }
 352
 353     i = b->method->bgets(b, in, inl);
 354
 355     if (cb != NULL)
 356         i = (int)cb(b, BIO_CB_GETS | BIO_CB_RETURN, in, inl, 0L, (long)i);
 357     return (i);
 358 }
 359
 360 int BIO_indent(BIO *b, int indent, int max)
 361 {
 362     if (indent < 0)
 363         indent = 0;
 364     if (indent > max)
 365         indent = max;
 366     while (indent--)
 367         if (BIO_puts(b, " ") != 1)
 368             return 0;
 369     return 1;
 370 }
 371
 372 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
 373 {
 374     int i;
 375
 376     i = iarg;
 377     return (BIO_ctrl(b, cmd, larg, (char *)&i));
 378 }
 379
 380 void *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
 381 {
 382     void *p = NULL;
 383
 384     if (BIO_ctrl(b, cmd, larg, (char *)&p) <= 0)
 385         return (NULL);
 386     else
 387         return (p);
 388 }
 389
 390 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
 391 {
 392     long ret;
 393     long (*cb) (BIO *, int, const char *, int, long, long);
 394
 395     if (b == NULL)
 396         return (0);
 397
 398     if ((b->method == NULL) || (b->method->ctrl == NULL)) {
 399         BIOerr(BIO_F_BIO_CTRL, BIO_R_UNSUPPORTED_METHOD);
 400         return (-2);
 401     }
 402
 403     cb = b->callback;
 404
 405     if ((cb != NULL) &&
 406         ((ret = cb(b, BIO_CB_CTRL, parg, cmd, larg, 1L)) <= 0))
 407         return (ret);
 408
 409     ret = b->method->ctrl(b, cmd, larg, parg);
 410
 411     if (cb != NULL)
 412         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, parg, cmd, larg, ret);
 413     return (ret);
 414 }
 415
 416 long BIO_callback_ctrl(BIO *b, int cmd,
 417                        void (*fp) (struct bio_st *, int, const char *, int,
 418                                    long, long))
 419 {
 420     long ret;
 421     long (*cb) (BIO *, int, const char *, int, long, long);
 422
 423     if (b == NULL)
 424         return (0);
 425
 426     if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) {
 427         BIOerr(BIO_F_BIO_CALLBACK_CTRL, BIO_R_UNSUPPORTED_METHOD);
 428         return (-2);
 429     }
 430
 431     cb = b->callback;
 432
 433     if ((cb != NULL) &&
 434         ((ret = cb(b, BIO_CB_CTRL, (void *)&fp, cmd, 0, 1L)) <= 0))
 435         return (ret);
 436
 437     ret = b->method->callback_ctrl(b, cmd, fp);
 438
 439     if (cb != NULL)
 440         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, cmd, 0, ret);
 441     return (ret);
 442 }
 443
 444 /*
 445  * It is unfortunate to duplicate in functions what the BIO_(w)pending macros
 446  * do; but those macros have inappropriate return type, and for interfacing
 447  * from other programming languages, C macros aren't much of a help anyway.
 448  */
 449 size_t BIO_ctrl_pending(BIO *bio)
 450 {
 451     return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
 452 }
 453
 454 size_t BIO_ctrl_wpending(BIO *bio)
 455 {
 456     return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
 457 }
 458
 459 /* put the 'bio' on the end of b's list of operators */
 460 BIO *BIO_push(BIO *b, BIO *bio)
 461 {
 462     BIO *lb;
 463
 464     if (b == NULL)
 465         return (bio);
 466     lb = b;
 467     while (lb->next_bio != NULL)
 468         lb = lb->next_bio;
 469     lb->next_bio = bio;
 470     if (bio != NULL)
 471         bio->prev_bio = lb;
 472     /* called to do internal processing */
 473     BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
 474     return (b);
 475 }
 476
 477 /* Remove the first and return the rest */
 478 BIO *BIO_pop(BIO *b)
 479 {
 480     BIO *ret;
 481
 482     if (b == NULL)
 483         return (NULL);
 484     ret = b->next_bio;
 485
 486     BIO_ctrl(b, BIO_CTRL_POP, 0, b);
 487
 488     if (b->prev_bio != NULL)
 489         b->prev_bio->next_bio = b->next_bio;
 490     if (b->next_bio != NULL)
 491         b->next_bio->prev_bio = b->prev_bio;
 492
 493     b->next_bio = NULL;
 494     b->prev_bio = NULL;
 495     return (ret);
 496 }
 497
 498 BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
 499 {
 500     BIO *b, *last;
 501
 502     b = last = bio;
 503     for (;;) {
 504         if (!BIO_should_retry(b))
 505             break;
 506         last = b;
 507         b = b->next_bio;
 508         if (b == NULL)
 509             break;
 510     }
 511     if (reason != NULL)
 512         *reason = last->retry_reason;
 513     return (last);
 514 }
 515
 516 int BIO_get_retry_reason(BIO *bio)
 517 {
 518     return (bio->retry_reason);
 519 }
 520
 521 void BIO_set_retry_reason(BIO *bio, int reason)
 522 {
 523     bio->retry_reason = reason;
 524 }
 525
 526 BIO *BIO_find_type(BIO *bio, int type)
 527 {
 528     int mt, mask;
 529
 530     if (bio == NULL)
 531         return NULL;
 532     mask = type & 0xff;
 533     do {
 534         if (bio->method != NULL) {
 535             mt = bio->method->type;
 536
 537             if (!mask) {
 538                 if (mt & type)
 539                     return (bio);
 540             } else if (mt == type)
 541                 return (bio);
 542         }
 543         bio = bio->next_bio;
 544     } while (bio != NULL);
 545     return (NULL);
 546 }
 547
 548 BIO *BIO_next(BIO *b)
 549 {
 550     if (b == NULL)
 551         return NULL;
 552     return b->next_bio;
 553 }
 554
 555 void BIO_set_next(BIO *b, BIO *next)
 556 {
 557     b->next_bio = next;
 558 }
 559
 560 void BIO_free_all(BIO *bio)
 561 {
 562     BIO *b;
 563     int ref;
 564
 565     while (bio != NULL) {
 566         b = bio;
 567         ref = b->references;
 568         bio = bio->next_bio;
 569         BIO_free(b);
 570         /* Since ref count > 1, don't free anyone else. */
 571         if (ref > 1)
 572             break;
 573     }
 574 }
 575
 576 BIO *BIO_dup_chain(BIO *in)
 577 {
 578     BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
 579
 580     for (bio = in; bio != NULL; bio = bio->next_bio) {
 581         if ((new_bio = BIO_new(bio->method)) == NULL)
 582             goto err;
 583         new_bio->callback = bio->callback;
 584         new_bio->cb_arg = bio->cb_arg;
 585         new_bio->init = bio->init;
 586         new_bio->shutdown = bio->shutdown;
 587         new_bio->flags = bio->flags;
 588
 589         /* This will let SSL_s_sock() work with stdin/stdout */
 590         new_bio->num = bio->num;
 591
 592         if (!BIO_dup_state(bio, (char *)new_bio)) {
 593             BIO_free(new_bio);
 594             goto err;
 595         }
 596
 597         /* copy app data */
 598         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
 599                                 &bio->ex_data)) {
 600             BIO_free(new_bio);
 601             goto err;
 602         }
 603
 604         if (ret == NULL) {
 605             eoc = new_bio;
 606             ret = eoc;
 607         } else {
 608             BIO_push(eoc, new_bio);
 609             eoc = new_bio;
 610         }
 611     }
 612     return (ret);
 613  err:
 614     BIO_free_all(ret);
 615
 616     return (NULL);
 617 }
 618
 619 void BIO_copy_next_retry(BIO *b)
 620 {
 621     BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
 622     b->retry_reason = b->next_bio->retry_reason;
 623 }
 624
 625 int BIO_set_ex_data(BIO *bio, int idx, void *data)
 626 {
 627     return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data));
 628 }
 629
 630 void *BIO_get_ex_data(BIO *bio, int idx)
 631 {
 632     return (CRYPTO_get_ex_data(&(bio->ex_data), idx));
 633 }
 634
 635 uint64_t BIO_number_read(BIO *bio)
 636 {
 637     if (bio)
 638         return bio->num_read;
 639     return 0;
 640 }
 641
 642 uint64_t BIO_number_written(BIO *bio)
 643 {
 644     if (bio)
 645         return bio->num_write;
 646     return 0;
 647 }
 648
 649 void bio_free_ex_data(BIO *bio)
 650 {
 651     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 652 }
 653
 654 void bio_cleanup(void)
 655 {
 656 #ifndef OPENSSL_NO_SOCK
 657     bio_sock_cleanup_int();
 658     CRYPTO_THREAD_lock_free(bio_lookup_lock);
 659     bio_lookup_lock = NULL;
 660 #endif
 661 }