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