crypto/bio/bio_lib.c

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