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