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         BIOerr(BIO_F_BIO_SET, ERR_R_MALLOC_FAILURE);
 102         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 103         return 0;
 104     }
 105
 106     if (method->create != NULL) {
 107         if (!method->create(bio)) {
 108             CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 109             CRYPTO_THREAD_lock_free(bio->lock);
 110             return 0;
 111         }
 112     }
 113
 114     return 1;
 115 }
 116
 117 int BIO_free(BIO *a)
 118 {
 119     int i;
 120
 121     if (a == NULL)
 122         return 0;
 123
 124     if (CRYPTO_atomic_add(&a->references, -1, &i, a->lock) <= 0)
 125         return 0;
 126
 127     REF_PRINT_COUNT("BIO", a);
 128     if (i > 0)
 129         return 1;
 130     REF_ASSERT_ISNT(i < 0);
 131     if ((a->callback != NULL) &&
 132         ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
 133         return i;
 134
 135     if ((a->method != NULL) && (a->method->destroy != NULL))
 136         a->method->destroy(a);
 137
 138     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
 139
 140     CRYPTO_THREAD_lock_free(a->lock);
 141
 142     OPENSSL_free(a);
 143
 144     return 1;
 145 }
 146
 147 void BIO_set_data(BIO *a, void *ptr)
 148 {
 149     a->ptr = ptr;
 150 }
 151
 152 void *BIO_get_data(BIO *a)
 153 {
 154     return a->ptr;
 155 }
 156
 157 void BIO_set_init(BIO *a, int init)
 158 {
 159     a->init = init;
 160 }
 161
 162 int BIO_get_init(BIO *a)
 163 {
 164     return a->init;
 165 }
 166
 167 void BIO_set_shutdown(BIO *a, int shut)
 168 {
 169     a->shutdown = shut;
 170 }
 171
 172 int BIO_get_shutdown(BIO *a)
 173 {
 174     return a->shutdown;
 175 }
 176
 177 void BIO_vfree(BIO *a)
 178 {
 179     BIO_free(a);
 180 }
 181
 182 int BIO_up_ref(BIO *a)
 183 {
 184     int i;
 185
 186     if (CRYPTO_atomic_add(&a->references, 1, &i, a->lock) <= 0)
 187         return 0;
 188
 189     REF_PRINT_COUNT("BIO", a);
 190     REF_ASSERT_ISNT(i < 2);
 191     return ((i > 1) ? 1 : 0);
 192 }
 193
 194 void BIO_clear_flags(BIO *b, int flags)
 195 {
 196     b->flags &= ~flags;
 197 }
 198
 199 int BIO_test_flags(const BIO *b, int flags)
 200 {
 201     return (b->flags & flags);
 202 }
 203
 204 void BIO_set_flags(BIO *b, int flags)
 205 {
 206     b->flags |= flags;
 207 }
 208
 209 long (*BIO_get_callback(const BIO *b)) (struct bio_st *, int, const char *,
 210                                         int, long, long) {
 211     return b->callback;
 212 }
 213
 214 void BIO_set_callback(BIO *b,
 215                       long (*cb) (struct bio_st *, int, const char *, int,
 216                                   long, long))
 217 {
 218     b->callback = cb;
 219 }
 220
 221 void BIO_set_callback_arg(BIO *b, char *arg)
 222 {
 223     b->cb_arg = arg;
 224 }
 225
 226 char *BIO_get_callback_arg(const BIO *b)
 227 {
 228     return b->cb_arg;
 229 }
 230
 231 const char *BIO_method_name(const BIO *b)
 232 {
 233     return b->method->name;
 234 }
 235
 236 int BIO_method_type(const BIO *b)
 237 {
 238     return b->method->type;
 239 }
 240
 241 int BIO_read(BIO *b, void *out, int outl)
 242 {
 243     int i;
 244     long (*cb) (BIO *, int, const char *, int, long, long);
 245
 246     if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
 247         BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD);
 248         return (-2);
 249     }
 250
 251     cb = b->callback;
 252     if ((cb != NULL) &&
 253         ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0))
 254         return (i);
 255
 256     if (!b->init) {
 257         BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED);
 258         return (-2);
 259     }
 260
 261     i = b->method->bread(b, out, outl);
 262
 263     if (i > 0)
 264         b->num_read += (uint64_t)i;
 265
 266     if (cb != NULL)
 267         i = (int)cb(b, BIO_CB_READ | BIO_CB_RETURN, out, outl, 0L, (long)i);
 268     return (i);
 269 }
 270
 271 int BIO_write(BIO *b, const void *in, int inl)
 272 {
 273     int i;
 274     long (*cb) (BIO *, int, const char *, int, long, long);
 275
 276     if (b == NULL)
 277         return (0);
 278
 279     cb = b->callback;
 280     if ((b->method == NULL) || (b->method->bwrite == NULL)) {
 281         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNSUPPORTED_METHOD);
 282         return (-2);
 283     }
 284
 285     if ((cb != NULL) &&
 286         ((i = (int)cb(b, BIO_CB_WRITE, in, inl, 0L, 1L)) <= 0))
 287         return (i);
 288
 289     if (!b->init) {
 290         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNINITIALIZED);
 291         return (-2);
 292     }
 293
 294     i = b->method->bwrite(b, in, inl);
 295
 296     if (i > 0)
 297         b->num_write += (uint64_t)i;
 298
 299     if (cb != NULL)
 300         i = (int)cb(b, BIO_CB_WRITE | BIO_CB_RETURN, in, inl, 0L, (long)i);
 301     return (i);
 302 }
 303
 304 int BIO_puts(BIO *b, const char *in)
 305 {
 306     int i;
 307     long (*cb) (BIO *, int, const char *, int, long, long);
 308
 309     if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) {
 310         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNSUPPORTED_METHOD);
 311         return (-2);
 312     }
 313
 314     cb = b->callback;
 315
 316     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_PUTS, in, 0, 0L, 1L)) <= 0))
 317         return (i);
 318
 319     if (!b->init) {
 320         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNINITIALIZED);
 321         return (-2);
 322     }
 323
 324     i = b->method->bputs(b, in);
 325
 326     if (i > 0)
 327         b->num_write += (uint64_t)i;
 328
 329     if (cb != NULL)
 330         i = (int)cb(b, BIO_CB_PUTS | BIO_CB_RETURN, in, 0, 0L, (long)i);
 331     return (i);
 332 }
 333
 334 int BIO_gets(BIO *b, char *in, int inl)
 335 {
 336     int i;
 337     long (*cb) (BIO *, int, const char *, int, long, long);
 338
 339     if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) {
 340         BIOerr(BIO_F_BIO_GETS, BIO_R_UNSUPPORTED_METHOD);
 341         return (-2);
 342     }
 343
 344     cb = b->callback;
 345
 346     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_GETS, in, inl, 0L, 1L)) <= 0))
 347         return (i);
 348
 349     if (!b->init) {
 350         BIOerr(BIO_F_BIO_GETS, BIO_R_UNINITIALIZED);
 351         return (-2);
 352     }
 353
 354     i = b->method->bgets(b, in, inl);
 355
 356     if (cb != NULL)
 357         i = (int)cb(b, BIO_CB_GETS | BIO_CB_RETURN, in, inl, 0L, (long)i);
 358     return (i);
 359 }
 360
 361 int BIO_indent(BIO *b, int indent, int max)
 362 {
 363     if (indent < 0)
 364         indent = 0;
 365     if (indent > max)
 366         indent = max;
 367     while (indent--)
 368         if (BIO_puts(b, " ") != 1)
 369             return 0;
 370     return 1;
 371 }
 372
 373 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
 374 {
 375     int i;
 376
 377     i = iarg;
 378     return (BIO_ctrl(b, cmd, larg, (char *)&i));
 379 }
 380
 381 void *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
 382 {
 383     void *p = NULL;
 384
 385     if (BIO_ctrl(b, cmd, larg, (char *)&p) <= 0)
 386         return (NULL);
 387     else
 388         return (p);
 389 }
 390
 391 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
 392 {
 393     long ret;
 394     long (*cb) (BIO *, int, const char *, int, long, long);
 395
 396     if (b == NULL)
 397         return (0);
 398
 399     if ((b->method == NULL) || (b->method->ctrl == NULL)) {
 400         BIOerr(BIO_F_BIO_CTRL, BIO_R_UNSUPPORTED_METHOD);
 401         return (-2);
 402     }
 403
 404     cb = b->callback;
 405
 406     if ((cb != NULL) &&
 407         ((ret = cb(b, BIO_CB_CTRL, parg, cmd, larg, 1L)) <= 0))
 408         return (ret);
 409
 410     ret = b->method->ctrl(b, cmd, larg, parg);
 411
 412     if (cb != NULL)
 413         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, parg, cmd, larg, ret);
 414     return (ret);
 415 }
 416
 417 long BIO_callback_ctrl(BIO *b, int cmd,
 418                        void (*fp) (struct bio_st *, int, const char *, int,
 419                                    long, long))
 420 {
 421     long ret;
 422     long (*cb) (BIO *, int, const char *, int, long, long);
 423
 424     if (b == NULL)
 425         return (0);
 426
 427     if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) {
 428         BIOerr(BIO_F_BIO_CALLBACK_CTRL, BIO_R_UNSUPPORTED_METHOD);
 429         return (-2);
 430     }
 431
 432     cb = b->callback;
 433
 434     if ((cb != NULL) &&
 435         ((ret = cb(b, BIO_CB_CTRL, (void *)&fp, cmd, 0, 1L)) <= 0))
 436         return (ret);
 437
 438     ret = b->method->callback_ctrl(b, cmd, fp);
 439
 440     if (cb != NULL)
 441         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, cmd, 0, ret);
 442     return (ret);
 443 }
 444
 445 /*
 446  * It is unfortunate to duplicate in functions what the BIO_(w)pending macros
 447  * do; but those macros have inappropriate return type, and for interfacing
 448  * from other programming languages, C macros aren't much of a help anyway.
 449  */
 450 size_t BIO_ctrl_pending(BIO *bio)
 451 {
 452     return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
 453 }
 454
 455 size_t BIO_ctrl_wpending(BIO *bio)
 456 {
 457     return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
 458 }
 459
 460 /* put the 'bio' on the end of b's list of operators */
 461 BIO *BIO_push(BIO *b, BIO *bio)
 462 {
 463     BIO *lb;
 464
 465     if (b == NULL)
 466         return (bio);
 467     lb = b;
 468     while (lb->next_bio != NULL)
 469         lb = lb->next_bio;
 470     lb->next_bio = bio;
 471     if (bio != NULL)
 472         bio->prev_bio = lb;
 473     /* called to do internal processing */
 474     BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
 475     return (b);
 476 }
 477
 478 /* Remove the first and return the rest */
 479 BIO *BIO_pop(BIO *b)
 480 {
 481     BIO *ret;
 482
 483     if (b == NULL)
 484         return (NULL);
 485     ret = b->next_bio;
 486
 487     BIO_ctrl(b, BIO_CTRL_POP, 0, b);
 488
 489     if (b->prev_bio != NULL)
 490         b->prev_bio->next_bio = b->next_bio;
 491     if (b->next_bio != NULL)
 492         b->next_bio->prev_bio = b->prev_bio;
 493
 494     b->next_bio = NULL;
 495     b->prev_bio = NULL;
 496     return (ret);
 497 }
 498
 499 BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
 500 {
 501     BIO *b, *last;
 502
 503     b = last = bio;
 504     for (;;) {
 505         if (!BIO_should_retry(b))
 506             break;
 507         last = b;
 508         b = b->next_bio;
 509         if (b == NULL)
 510             break;
 511     }
 512     if (reason != NULL)
 513         *reason = last->retry_reason;
 514     return (last);
 515 }
 516
 517 int BIO_get_retry_reason(BIO *bio)
 518 {
 519     return (bio->retry_reason);
 520 }
 521
 522 void BIO_set_retry_reason(BIO *bio, int reason)
 523 {
 524     bio->retry_reason = reason;
 525 }
 526
 527 BIO *BIO_find_type(BIO *bio, int type)
 528 {
 529     int mt, mask;
 530
 531     if (bio == NULL)
 532         return NULL;
 533     mask = type & 0xff;
 534     do {
 535         if (bio->method != NULL) {
 536             mt = bio->method->type;
 537
 538             if (!mask) {
 539                 if (mt & type)
 540                     return (bio);
 541             } else if (mt == type)
 542                 return (bio);
 543         }
 544         bio = bio->next_bio;
 545     } while (bio != NULL);
 546     return (NULL);
 547 }
 548
 549 BIO *BIO_next(BIO *b)
 550 {
 551     if (b == NULL)
 552         return NULL;
 553     return b->next_bio;
 554 }
 555
 556 void BIO_set_next(BIO *b, BIO *next)
 557 {
 558     b->next_bio = next;
 559 }
 560
 561 void BIO_free_all(BIO *bio)
 562 {
 563     BIO *b;
 564     int ref;
 565
 566     while (bio != NULL) {
 567         b = bio;
 568         ref = b->references;
 569         bio = bio->next_bio;
 570         BIO_free(b);
 571         /* Since ref count > 1, don't free anyone else. */
 572         if (ref > 1)
 573             break;
 574     }
 575 }
 576
 577 BIO *BIO_dup_chain(BIO *in)
 578 {
 579     BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
 580
 581     for (bio = in; bio != NULL; bio = bio->next_bio) {
 582         if ((new_bio = BIO_new(bio->method)) == NULL)
 583             goto err;
 584         new_bio->callback = bio->callback;
 585         new_bio->cb_arg = bio->cb_arg;
 586         new_bio->init = bio->init;
 587         new_bio->shutdown = bio->shutdown;
 588         new_bio->flags = bio->flags;
 589
 590         /* This will let SSL_s_sock() work with stdin/stdout */
 591         new_bio->num = bio->num;
 592
 593         if (!BIO_dup_state(bio, (char *)new_bio)) {
 594             BIO_free(new_bio);
 595             goto err;
 596         }
 597
 598         /* copy app data */
 599         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
 600                                 &bio->ex_data)) {
 601             BIO_free(new_bio);
 602             goto err;
 603         }
 604
 605         if (ret == NULL) {
 606             eoc = new_bio;
 607             ret = eoc;
 608         } else {
 609             BIO_push(eoc, new_bio);
 610             eoc = new_bio;
 611         }
 612     }
 613     return (ret);
 614  err:
 615     BIO_free_all(ret);
 616
 617     return (NULL);
 618 }
 619
 620 void BIO_copy_next_retry(BIO *b)
 621 {
 622     BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
 623     b->retry_reason = b->next_bio->retry_reason;
 624 }
 625
 626 int BIO_set_ex_data(BIO *bio, int idx, void *data)
 627 {
 628     return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data));
 629 }
 630
 631 void *BIO_get_ex_data(BIO *bio, int idx)
 632 {
 633     return (CRYPTO_get_ex_data(&(bio->ex_data), idx));
 634 }
 635
 636 uint64_t BIO_number_read(BIO *bio)
 637 {
 638     if (bio)
 639         return bio->num_read;
 640     return 0;
 641 }
 642
 643 uint64_t BIO_number_written(BIO *bio)
 644 {
 645     if (bio)
 646         return bio->num_write;
 647     return 0;
 648 }
 649
 650 void bio_free_ex_data(BIO *bio)
 651 {
 652     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
 653 }
 654
 655 void bio_cleanup(void)
 656 {
 657 #ifndef OPENSSL_NO_SOCK
 658     bio_sock_cleanup_int();
 659     CRYPTO_THREAD_lock_free(bio_lookup_lock);
 660     bio_lookup_lock = NULL;
 661 #endif
 662 }