bss_bio.c revision 120632
1193323Sed/* crypto/bio/bss_bio.c -*- Mode: C; c-file-style: "eay" -*- */ 2193323Sed/* ==================================================================== 3193323Sed * Copyright (c) 1998-2003 The OpenSSL Project. All rights reserved. 4193323Sed * 5193323Sed * Redistribution and use in source and binary forms, with or without 6193323Sed * modification, are permitted provided that the following conditions 7193323Sed * are met: 8193323Sed * 9193323Sed * 1. Redistributions of source code must retain the above copyright 10193323Sed * notice, this list of conditions and the following disclaimer. 11193323Sed * 12193323Sed * 2. Redistributions in binary form must reproduce the above copyright 13193323Sed * notice, this list of conditions and the following disclaimer in 14193323Sed * the documentation and/or other materials provided with the 15252723Sdim * distribution. 16218893Sdim * 17252723Sdim * 3. All advertising materials mentioning features or use of this 18193323Sed * software must display the following acknowledgment: 19198090Srdivacky * "This product includes software developed by the OpenSSL Project 20198090Srdivacky * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" 21193323Sed * 22198090Srdivacky * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 23193323Sed * endorse or promote products derived from this software without 24198090Srdivacky * prior written permission. For written permission, please contact 25198090Srdivacky * openssl-core@openssl.org. 26235633Sdim * 27235633Sdim * 5. Products derived from this software may not be called "OpenSSL" 28193323Sed * nor may "OpenSSL" appear in their names without prior written 29263509Sdim * permission of the OpenSSL Project. 30263509Sdim * 31263509Sdim * 6. Redistributions of any form whatsoever must retain the following 32263509Sdim * acknowledgment: 33198090Srdivacky * "This product includes software developed by the OpenSSL Project 34198090Srdivacky * for use in the OpenSSL Toolkit (http://www.openssl.org/)" 35198090Srdivacky * 36193323Sed * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 37198090Srdivacky * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 38198090Srdivacky * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 39198090Srdivacky * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 40198090Srdivacky * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 41198090Srdivacky * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 42198090Srdivacky * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 43193323Sed * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 44198090Srdivacky * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 45198090Srdivacky * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 46198090Srdivacky * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 47193323Sed * OF THE POSSIBILITY OF SUCH DAMAGE. 48193323Sed * ==================================================================== 49198090Srdivacky * 50198090Srdivacky * This product includes cryptographic software written by Eric Young 51198090Srdivacky * (eay@cryptsoft.com). This product includes software written by Tim 52218893Sdim * Hudson (tjh@cryptsoft.com). 53218893Sdim * 54218893Sdim */ 55218893Sdim 56218893Sdim/* Special method for a BIO where the other endpoint is also a BIO 57218893Sdim * of this kind, handled by the same thread (i.e. the "peer" is actually 58198090Srdivacky * ourselves, wearing a different hat). 59198090Srdivacky * Such "BIO pairs" are mainly for using the SSL library with I/O interfaces 60198090Srdivacky * for which no specific BIO method is available. 61198090Srdivacky * See ssl/ssltest.c for some hints on how this can be used. */ 62198090Srdivacky 63193323Sed/* BIO_DEBUG implies BIO_PAIR_DEBUG */ 64193323Sed#ifdef BIO_DEBUG 65198090Srdivacky# ifndef BIO_PAIR_DEBUG 66198090Srdivacky# define BIO_PAIR_DEBUG 67198090Srdivacky# endif 68198090Srdivacky#endif 69198090Srdivacky 70198090Srdivacky/* disable assert() unless BIO_PAIR_DEBUG has been defined */ 71198090Srdivacky#ifndef BIO_PAIR_DEBUG 72198090Srdivacky# ifndef NDEBUG 73198090Srdivacky# define NDEBUG 74198090Srdivacky# endif 75198090Srdivacky#endif 76198090Srdivacky 77198090Srdivacky#include <assert.h> 78198090Srdivacky#include <limits.h> 79193323Sed#include <stdlib.h> 80193323Sed#include <string.h> 81198090Srdivacky 82198090Srdivacky#include <openssl/bio.h> 83193323Sed#include <openssl/err.h> 84207618Srdivacky#include <openssl/crypto.h> 85207618Srdivacky 86198090Srdivacky#include "e_os.h" 87198090Srdivacky 88198090Srdivacky/* VxWorks defines SSIZE_MAX with an empty value causing compile errors */ 89198090Srdivacky#if defined(OPENSSL_SYS_VXWORKS) 90252723Sdim# undef SSIZE_MAX 91193323Sed#endif 92193323Sed#ifndef SSIZE_MAX 93198090Srdivacky# define SSIZE_MAX INT_MAX 94198090Srdivacky#endif 95198090Srdivacky 96207618Srdivackystatic int bio_new(BIO *bio); 97207618Srdivackystatic int bio_free(BIO *bio); 98207618Srdivackystatic int bio_read(BIO *bio, char *buf, int size); 99198090Srdivackystatic int bio_write(BIO *bio, const char *buf, int num); 100198090Srdivackystatic long bio_ctrl(BIO *bio, int cmd, long num, void *ptr); 101198090Srdivackystatic int bio_puts(BIO *bio, const char *str); 102198090Srdivacky 103198090Srdivackystatic int bio_make_pair(BIO *bio1, BIO *bio2); 104198090Srdivackystatic void bio_destroy_pair(BIO *bio); 105198090Srdivacky 106198090Srdivackystatic BIO_METHOD methods_biop = 107198090Srdivacky{ 108198090Srdivacky BIO_TYPE_BIO, 109198090Srdivacky "BIO pair", 110198090Srdivacky bio_write, 111252723Sdim bio_read, 112252723Sdim bio_puts, 113252723Sdim NULL /* no bio_gets */, 114252723Sdim bio_ctrl, 115198090Srdivacky bio_new, 116198090Srdivacky bio_free, 117198090Srdivacky NULL /* no bio_callback_ctrl */ 118198090Srdivacky}; 119198090Srdivacky 120198090SrdivackyBIO_METHOD *BIO_s_bio(void) 121198090Srdivacky { 122198090Srdivacky return &methods_biop; 123198090Srdivacky } 124198090Srdivacky 125198090Srdivackystruct bio_bio_st 126198090Srdivacky{ 127198090Srdivacky BIO *peer; /* NULL if buf == NULL. 128198090Srdivacky * If peer != NULL, then peer->ptr is also a bio_bio_st, 129198090Srdivacky * and its "peer" member points back to us. 130252723Sdim * peer != NULL iff init != 0 in the BIO. */ 131198090Srdivacky 132198090Srdivacky /* This is for what we write (i.e. reading uses peer's struct): */ 133198090Srdivacky int closed; /* valid iff peer != NULL */ 134198090Srdivacky size_t len; /* valid iff buf != NULL; 0 if peer == NULL */ 135198090Srdivacky size_t offset; /* valid iff buf != NULL; 0 if len == 0 */ 136198090Srdivacky size_t size; 137198090Srdivacky char *buf; /* "size" elements (if != NULL) */ 138198090Srdivacky 139252723Sdim size_t request; /* valid iff peer != NULL; 0 if len != 0, 140193323Sed * otherwise set by peer to number of bytes 141193323Sed * it (unsuccessfully) tried to read, 142193323Sed * never more than buffer space (size-len) warrants. */ 143198090Srdivacky}; 144198090Srdivacky 145198090Srdivackystatic int bio_new(BIO *bio) 146198090Srdivacky { 147198090Srdivacky struct bio_bio_st *b; 148198090Srdivacky 149198090Srdivacky b = OPENSSL_malloc(sizeof *b); 150198090Srdivacky if (b == NULL) 151221345Sdim return 0; 152221345Sdim 153221345Sdim b->peer = NULL; 154221345Sdim b->size = 17*1024; /* enough for one TLS record (just a default) */ 155221345Sdim b->buf = NULL; 156221345Sdim 157221345Sdim bio->ptr = b; 158221345Sdim return 1; 159193323Sed } 160198090Srdivacky 161198090Srdivacky 162198090Srdivackystatic int bio_free(BIO *bio) 163198090Srdivacky { 164198090Srdivacky struct bio_bio_st *b; 165198090Srdivacky 166193323Sed if (bio == NULL) 167198090Srdivacky return 0; 168198090Srdivacky b = bio->ptr; 169198090Srdivacky 170198090Srdivacky assert(b != NULL); 171198090Srdivacky 172193323Sed if (b->peer) 173193323Sed bio_destroy_pair(bio); 174198090Srdivacky 175198090Srdivacky if (b->buf != NULL) 176198090Srdivacky { 177198090Srdivacky OPENSSL_free(b->buf); 178198090Srdivacky } 179198090Srdivacky 180198090Srdivacky OPENSSL_free(b); 181198090Srdivacky 182198090Srdivacky return 1; 183193323Sed } 184198090Srdivacky 185198090Srdivacky 186198090Srdivacky 187198090Srdivackystatic int bio_read(BIO *bio, char *buf, int size_) 188198090Srdivacky { 189198090Srdivacky size_t size = size_; 190198090Srdivacky size_t rest; 191198090Srdivacky struct bio_bio_st *b, *peer_b; 192198090Srdivacky 193198090Srdivacky BIO_clear_retry_flags(bio); 194198090Srdivacky 195198090Srdivacky if (!bio->init) 196198090Srdivacky return 0; 197198090Srdivacky 198 b = bio->ptr; 199 assert(b != NULL); 200 assert(b->peer != NULL); 201 peer_b = b->peer->ptr; 202 assert(peer_b != NULL); 203 assert(peer_b->buf != NULL); 204 205 peer_b->request = 0; /* will be set in "retry_read" situation */ 206 207 if (buf == NULL || size == 0) 208 return 0; 209 210 if (peer_b->len == 0) 211 { 212 if (peer_b->closed) 213 return 0; /* writer has closed, and no data is left */ 214 else 215 { 216 BIO_set_retry_read(bio); /* buffer is empty */ 217 if (size <= peer_b->size) 218 peer_b->request = size; 219 else 220 /* don't ask for more than the peer can 221 * deliver in one write */ 222 peer_b->request = peer_b->size; 223 return -1; 224 } 225 } 226 227 /* we can read */ 228 if (peer_b->len < size) 229 size = peer_b->len; 230 231 /* now read "size" bytes */ 232 233 rest = size; 234 235 assert(rest > 0); 236 do /* one or two iterations */ 237 { 238 size_t chunk; 239 240 assert(rest <= peer_b->len); 241 if (peer_b->offset + rest <= peer_b->size) 242 chunk = rest; 243 else 244 /* wrap around ring buffer */ 245 chunk = peer_b->size - peer_b->offset; 246 assert(peer_b->offset + chunk <= peer_b->size); 247 248 memcpy(buf, peer_b->buf + peer_b->offset, chunk); 249 250 peer_b->len -= chunk; 251 if (peer_b->len) 252 { 253 peer_b->offset += chunk; 254 assert(peer_b->offset <= peer_b->size); 255 if (peer_b->offset == peer_b->size) 256 peer_b->offset = 0; 257 buf += chunk; 258 } 259 else 260 { 261 /* buffer now empty, no need to advance "buf" */ 262 assert(chunk == rest); 263 peer_b->offset = 0; 264 } 265 rest -= chunk; 266 } 267 while (rest); 268 269 return size; 270 } 271 272/* non-copying interface: provide pointer to available data in buffer 273 * bio_nread0: return number of available bytes 274 * bio_nread: also advance index 275 * (example usage: bio_nread0(), read from buffer, bio_nread() 276 * or just bio_nread(), read from buffer) 277 */ 278/* WARNING: The non-copying interface is largely untested as of yet 279 * and may contain bugs. */ 280static ssize_t bio_nread0(BIO *bio, char **buf) 281 { 282 struct bio_bio_st *b, *peer_b; 283 ssize_t num; 284 285 BIO_clear_retry_flags(bio); 286 287 if (!bio->init) 288 return 0; 289 290 b = bio->ptr; 291 assert(b != NULL); 292 assert(b->peer != NULL); 293 peer_b = b->peer->ptr; 294 assert(peer_b != NULL); 295 assert(peer_b->buf != NULL); 296 297 peer_b->request = 0; 298 299 if (peer_b->len == 0) 300 { 301 char dummy; 302 303 /* avoid code duplication -- nothing available for reading */ 304 return bio_read(bio, &dummy, 1); /* returns 0 or -1 */ 305 } 306 307 num = peer_b->len; 308 if (peer_b->size < peer_b->offset + num) 309 /* no ring buffer wrap-around for non-copying interface */ 310 num = peer_b->size - peer_b->offset; 311 assert(num > 0); 312 313 if (buf != NULL) 314 *buf = peer_b->buf + peer_b->offset; 315 return num; 316 } 317 318static ssize_t bio_nread(BIO *bio, char **buf, size_t num_) 319 { 320 struct bio_bio_st *b, *peer_b; 321 ssize_t num, available; 322 323 if (num_ > SSIZE_MAX) 324 num = SSIZE_MAX; 325 else 326 num = (ssize_t)num_; 327 328 available = bio_nread0(bio, buf); 329 if (num > available) 330 num = available; 331 if (num <= 0) 332 return num; 333 334 b = bio->ptr; 335 peer_b = b->peer->ptr; 336 337 peer_b->len -= num; 338 if (peer_b->len) 339 { 340 peer_b->offset += num; 341 assert(peer_b->offset <= peer_b->size); 342 if (peer_b->offset == peer_b->size) 343 peer_b->offset = 0; 344 } 345 else 346 peer_b->offset = 0; 347 348 return num; 349 } 350 351 352static int bio_write(BIO *bio, const char *buf, int num_) 353 { 354 size_t num = num_; 355 size_t rest; 356 struct bio_bio_st *b; 357 358 BIO_clear_retry_flags(bio); 359 360 if (!bio->init || buf == NULL || num == 0) 361 return 0; 362 363 b = bio->ptr; 364 assert(b != NULL); 365 assert(b->peer != NULL); 366 assert(b->buf != NULL); 367 368 b->request = 0; 369 if (b->closed) 370 { 371 /* we already closed */ 372 BIOerr(BIO_F_BIO_WRITE, BIO_R_BROKEN_PIPE); 373 return -1; 374 } 375 376 assert(b->len <= b->size); 377 378 if (b->len == b->size) 379 { 380 BIO_set_retry_write(bio); /* buffer is full */ 381 return -1; 382 } 383 384 /* we can write */ 385 if (num > b->size - b->len) 386 num = b->size - b->len; 387 388 /* now write "num" bytes */ 389 390 rest = num; 391 392 assert(rest > 0); 393 do /* one or two iterations */ 394 { 395 size_t write_offset; 396 size_t chunk; 397 398 assert(b->len + rest <= b->size); 399 400 write_offset = b->offset + b->len; 401 if (write_offset >= b->size) 402 write_offset -= b->size; 403 /* b->buf[write_offset] is the first byte we can write to. */ 404 405 if (write_offset + rest <= b->size) 406 chunk = rest; 407 else 408 /* wrap around ring buffer */ 409 chunk = b->size - write_offset; 410 411 memcpy(b->buf + write_offset, buf, chunk); 412 413 b->len += chunk; 414 415 assert(b->len <= b->size); 416 417 rest -= chunk; 418 buf += chunk; 419 } 420 while (rest); 421 422 return num; 423 } 424 425/* non-copying interface: provide pointer to region to write to 426 * bio_nwrite0: check how much space is available 427 * bio_nwrite: also increase length 428 * (example usage: bio_nwrite0(), write to buffer, bio_nwrite() 429 * or just bio_nwrite(), write to buffer) 430 */ 431static ssize_t bio_nwrite0(BIO *bio, char **buf) 432 { 433 struct bio_bio_st *b; 434 size_t num; 435 size_t write_offset; 436 437 BIO_clear_retry_flags(bio); 438 439 if (!bio->init) 440 return 0; 441 442 b = bio->ptr; 443 assert(b != NULL); 444 assert(b->peer != NULL); 445 assert(b->buf != NULL); 446 447 b->request = 0; 448 if (b->closed) 449 { 450 BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE); 451 return -1; 452 } 453 454 assert(b->len <= b->size); 455 456 if (b->len == b->size) 457 { 458 BIO_set_retry_write(bio); 459 return -1; 460 } 461 462 num = b->size - b->len; 463 write_offset = b->offset + b->len; 464 if (write_offset >= b->size) 465 write_offset -= b->size; 466 if (write_offset + num > b->size) 467 /* no ring buffer wrap-around for non-copying interface 468 * (to fulfil the promise by BIO_ctrl_get_write_guarantee, 469 * BIO_nwrite may have to be called twice) */ 470 num = b->size - write_offset; 471 472 if (buf != NULL) 473 *buf = b->buf + write_offset; 474 assert(write_offset + num <= b->size); 475 476 return num; 477 } 478 479static ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_) 480 { 481 struct bio_bio_st *b; 482 ssize_t num, space; 483 484 if (num_ > SSIZE_MAX) 485 num = SSIZE_MAX; 486 else 487 num = (ssize_t)num_; 488 489 space = bio_nwrite0(bio, buf); 490 if (num > space) 491 num = space; 492 if (num <= 0) 493 return num; 494 b = bio->ptr; 495 assert(b != NULL); 496 b->len += num; 497 assert(b->len <= b->size); 498 499 return num; 500 } 501 502 503static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) 504 { 505 long ret; 506 struct bio_bio_st *b = bio->ptr; 507 508 assert(b != NULL); 509 510 switch (cmd) 511 { 512 /* specific CTRL codes */ 513 514 case BIO_C_SET_WRITE_BUF_SIZE: 515 if (b->peer) 516 { 517 BIOerr(BIO_F_BIO_CTRL, BIO_R_IN_USE); 518 ret = 0; 519 } 520 else if (num == 0) 521 { 522 BIOerr(BIO_F_BIO_CTRL, BIO_R_INVALID_ARGUMENT); 523 ret = 0; 524 } 525 else 526 { 527 size_t new_size = num; 528 529 if (b->size != new_size) 530 { 531 if (b->buf) 532 { 533 OPENSSL_free(b->buf); 534 b->buf = NULL; 535 } 536 b->size = new_size; 537 } 538 ret = 1; 539 } 540 break; 541 542 case BIO_C_GET_WRITE_BUF_SIZE: 543 ret = (long) b->size; 544 break; 545 546 case BIO_C_MAKE_BIO_PAIR: 547 { 548 BIO *other_bio = ptr; 549 550 if (bio_make_pair(bio, other_bio)) 551 ret = 1; 552 else 553 ret = 0; 554 } 555 break; 556 557 case BIO_C_DESTROY_BIO_PAIR: 558 /* Affects both BIOs in the pair -- call just once! 559 * Or let BIO_free(bio1); BIO_free(bio2); do the job. */ 560 bio_destroy_pair(bio); 561 ret = 1; 562 break; 563 564 case BIO_C_GET_WRITE_GUARANTEE: 565 /* How many bytes can the caller feed to the next write 566 * without having to keep any? */ 567 if (b->peer == NULL || b->closed) 568 ret = 0; 569 else 570 ret = (long) b->size - b->len; 571 break; 572 573 case BIO_C_GET_READ_REQUEST: 574 /* If the peer unsuccessfully tried to read, how many bytes 575 * were requested? (As with BIO_CTRL_PENDING, that number 576 * can usually be treated as boolean.) */ 577 ret = (long) b->request; 578 break; 579 580 case BIO_C_RESET_READ_REQUEST: 581 /* Reset request. (Can be useful after read attempts 582 * at the other side that are meant to be non-blocking, 583 * e.g. when probing SSL_read to see if any data is 584 * available.) */ 585 b->request = 0; 586 ret = 1; 587 break; 588 589 case BIO_C_SHUTDOWN_WR: 590 /* similar to shutdown(..., SHUT_WR) */ 591 b->closed = 1; 592 ret = 1; 593 break; 594 595 case BIO_C_NREAD0: 596 /* prepare for non-copying read */ 597 ret = (long) bio_nread0(bio, ptr); 598 break; 599 600 case BIO_C_NREAD: 601 /* non-copying read */ 602 ret = (long) bio_nread(bio, ptr, (size_t) num); 603 break; 604 605 case BIO_C_NWRITE0: 606 /* prepare for non-copying write */ 607 ret = (long) bio_nwrite0(bio, ptr); 608 break; 609 610 case BIO_C_NWRITE: 611 /* non-copying write */ 612 ret = (long) bio_nwrite(bio, ptr, (size_t) num); 613 break; 614 615 616 /* standard CTRL codes follow */ 617 618 case BIO_CTRL_RESET: 619 if (b->buf != NULL) 620 { 621 b->len = 0; 622 b->offset = 0; 623 } 624 ret = 0; 625 break; 626 627 case BIO_CTRL_GET_CLOSE: 628 ret = bio->shutdown; 629 break; 630 631 case BIO_CTRL_SET_CLOSE: 632 bio->shutdown = (int) num; 633 ret = 1; 634 break; 635 636 case BIO_CTRL_PENDING: 637 if (b->peer != NULL) 638 { 639 struct bio_bio_st *peer_b = b->peer->ptr; 640 641 ret = (long) peer_b->len; 642 } 643 else 644 ret = 0; 645 break; 646 647 case BIO_CTRL_WPENDING: 648 if (b->buf != NULL) 649 ret = (long) b->len; 650 else 651 ret = 0; 652 break; 653 654 case BIO_CTRL_DUP: 655 /* See BIO_dup_chain for circumstances we have to expect. */ 656 { 657 BIO *other_bio = ptr; 658 struct bio_bio_st *other_b; 659 660 assert(other_bio != NULL); 661 other_b = other_bio->ptr; 662 assert(other_b != NULL); 663 664 assert(other_b->buf == NULL); /* other_bio is always fresh */ 665 666 other_b->size = b->size; 667 } 668 669 ret = 1; 670 break; 671 672 case BIO_CTRL_FLUSH: 673 ret = 1; 674 break; 675 676 case BIO_CTRL_EOF: 677 { 678 BIO *other_bio = ptr; 679 680 if (other_bio) 681 { 682 struct bio_bio_st *other_b = other_bio->ptr; 683 684 assert(other_b != NULL); 685 ret = other_b->len == 0 && other_b->closed; 686 } 687 else 688 ret = 1; 689 } 690 break; 691 692 default: 693 ret = 0; 694 } 695 return ret; 696 } 697 698static int bio_puts(BIO *bio, const char *str) 699 { 700 return bio_write(bio, str, strlen(str)); 701 } 702 703 704static int bio_make_pair(BIO *bio1, BIO *bio2) 705 { 706 struct bio_bio_st *b1, *b2; 707 708 assert(bio1 != NULL); 709 assert(bio2 != NULL); 710 711 b1 = bio1->ptr; 712 b2 = bio2->ptr; 713 714 if (b1->peer != NULL || b2->peer != NULL) 715 { 716 BIOerr(BIO_F_BIO_MAKE_PAIR, BIO_R_IN_USE); 717 return 0; 718 } 719 720 if (b1->buf == NULL) 721 { 722 b1->buf = OPENSSL_malloc(b1->size); 723 if (b1->buf == NULL) 724 { 725 BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE); 726 return 0; 727 } 728 b1->len = 0; 729 b1->offset = 0; 730 } 731 732 if (b2->buf == NULL) 733 { 734 b2->buf = OPENSSL_malloc(b2->size); 735 if (b2->buf == NULL) 736 { 737 BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE); 738 return 0; 739 } 740 b2->len = 0; 741 b2->offset = 0; 742 } 743 744 b1->peer = bio2; 745 b1->closed = 0; 746 b1->request = 0; 747 b2->peer = bio1; 748 b2->closed = 0; 749 b2->request = 0; 750 751 bio1->init = 1; 752 bio2->init = 1; 753 754 return 1; 755 } 756 757static void bio_destroy_pair(BIO *bio) 758 { 759 struct bio_bio_st *b = bio->ptr; 760 761 if (b != NULL) 762 { 763 BIO *peer_bio = b->peer; 764 765 if (peer_bio != NULL) 766 { 767 struct bio_bio_st *peer_b = peer_bio->ptr; 768 769 assert(peer_b != NULL); 770 assert(peer_b->peer == bio); 771 772 peer_b->peer = NULL; 773 peer_bio->init = 0; 774 assert(peer_b->buf != NULL); 775 peer_b->len = 0; 776 peer_b->offset = 0; 777 778 b->peer = NULL; 779 bio->init = 0; 780 assert(b->buf != NULL); 781 b->len = 0; 782 b->offset = 0; 783 } 784 } 785 } 786 787 788/* Exported convenience functions */ 789int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1, 790 BIO **bio2_p, size_t writebuf2) 791 { 792 BIO *bio1 = NULL, *bio2 = NULL; 793 long r; 794 int ret = 0; 795 796 bio1 = BIO_new(BIO_s_bio()); 797 if (bio1 == NULL) 798 goto err; 799 bio2 = BIO_new(BIO_s_bio()); 800 if (bio2 == NULL) 801 goto err; 802 803 if (writebuf1) 804 { 805 r = BIO_set_write_buf_size(bio1, writebuf1); 806 if (!r) 807 goto err; 808 } 809 if (writebuf2) 810 { 811 r = BIO_set_write_buf_size(bio2, writebuf2); 812 if (!r) 813 goto err; 814 } 815 816 r = BIO_make_bio_pair(bio1, bio2); 817 if (!r) 818 goto err; 819 ret = 1; 820 821 err: 822 if (ret == 0) 823 { 824 if (bio1) 825 { 826 BIO_free(bio1); 827 bio1 = NULL; 828 } 829 if (bio2) 830 { 831 BIO_free(bio2); 832 bio2 = NULL; 833 } 834 } 835 836 *bio1_p = bio1; 837 *bio2_p = bio2; 838 return ret; 839 } 840 841size_t BIO_ctrl_get_write_guarantee(BIO *bio) 842 { 843 return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL); 844 } 845 846size_t BIO_ctrl_get_read_request(BIO *bio) 847 { 848 return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL); 849 } 850 851int BIO_ctrl_reset_read_request(BIO *bio) 852 { 853 return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0); 854 } 855 856 857/* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now 858 * (conceivably some other BIOs could allow non-copying reads and writes too.) 859 */ 860int BIO_nread0(BIO *bio, char **buf) 861 { 862 long ret; 863 864 if (!bio->init) 865 { 866 BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED); 867 return -2; 868 } 869 870 ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf); 871 if (ret > INT_MAX) 872 return INT_MAX; 873 else 874 return (int) ret; 875 } 876 877int BIO_nread(BIO *bio, char **buf, int num) 878 { 879 int ret; 880 881 if (!bio->init) 882 { 883 BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED); 884 return -2; 885 } 886 887 ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf); 888 if (ret > 0) 889 bio->num_read += ret; 890 return ret; 891 } 892 893int BIO_nwrite0(BIO *bio, char **buf) 894 { 895 long ret; 896 897 if (!bio->init) 898 { 899 BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED); 900 return -2; 901 } 902 903 ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf); 904 if (ret > INT_MAX) 905 return INT_MAX; 906 else 907 return (int) ret; 908 } 909 910int BIO_nwrite(BIO *bio, char **buf, int num) 911 { 912 int ret; 913 914 if (!bio->init) 915 { 916 BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED); 917 return -2; 918 } 919 920 ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf); 921 if (ret > 0) 922 bio->num_read += ret; 923 return ret; 924 } 925