1 /* crypto/bio/bss_bio.c -*- Mode: C; c-file-style: "eay" -*- */ 2 /* ==================================================================== 3 * Copyright (c) 1998-2003 The OpenSSL Project. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the 15 * distribution. 16 * 17 * 3. All advertising materials mentioning features or use of this 18 * software must display the following acknowledgment: 19 * "This product includes software developed by the OpenSSL Project 20 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" 21 * 22 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 23 * endorse or promote products derived from this software without 24 * prior written permission. For written permission, please contact 25 * openssl-core (at) openssl.org. 26 * 27 * 5. Products derived from this software may not be called "OpenSSL" 28 * nor may "OpenSSL" appear in their names without prior written 29 * permission of the OpenSSL Project. 30 * 31 * 6. Redistributions of any form whatsoever must retain the following 32 * acknowledgment: 33 * "This product includes software developed by the OpenSSL Project 34 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" 35 * 36 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 37 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 38 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 39 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 40 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 41 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 42 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 43 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 44 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 45 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 46 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 47 * OF THE POSSIBILITY OF SUCH DAMAGE. 48 * ==================================================================== 49 * 50 * This product includes cryptographic software written by Eric Young 51 * (eay (at) cryptsoft.com). This product includes software written by Tim 52 * Hudson (tjh (at) cryptsoft.com). 53 * 54 */ 55 56 /* Special method for a BIO where the other endpoint is also a BIO 57 * of this kind, handled by the same thread (i.e. the "peer" is actually 58 * ourselves, wearing a different hat). 59 * Such "BIO pairs" are mainly for using the SSL library with I/O interfaces 60 * for which no specific BIO method is available. 61 * See ssl/ssltest.c for some hints on how this can be used. */ 62 63 /* BIO_DEBUG implies BIO_PAIR_DEBUG */ 64 #ifdef BIO_DEBUG 65 # ifndef BIO_PAIR_DEBUG 66 # define BIO_PAIR_DEBUG 67 # endif 68 #endif 69 70 /* disable assert() unless BIO_PAIR_DEBUG has been defined */ 71 #ifndef BIO_PAIR_DEBUG 72 # ifndef NDEBUG 73 # define NDEBUG 74 # endif 75 #endif 76 77 #include <assert.h> 78 #include <limits.h> 79 #include <stdlib.h> 80 #include <string.h> 81 82 #include <openssl/bio.h> 83 #include <openssl/err.h> 84 #include <openssl/crypto.h> 85 86 #include "e_os.h" 87 88 /* VxWorks defines SSIZE_MAX with an empty value causing compile errors */ 89 #if defined(OPENSSL_SYS_VXWORKS) 90 # undef SSIZE_MAX 91 #endif 92 #ifndef SSIZE_MAX 93 # define SSIZE_MAX INT_MAX 94 #endif 95 96 static int bio_new(BIO *bio); 97 static int bio_free(BIO *bio); 98 static int bio_read(BIO *bio, char *buf, int size); 99 static int bio_write(BIO *bio, const char *buf, int num); 100 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr); 101 static int bio_puts(BIO *bio, const char *str); 102 103 static int bio_make_pair(BIO *bio1, BIO *bio2); 104 static void bio_destroy_pair(BIO *bio); 105 106 static BIO_METHOD methods_biop = 107 { 108 BIO_TYPE_BIO, 109 "BIO pair", 110 bio_write, 111 bio_read, 112 bio_puts, 113 NULL /* no bio_gets */, 114 bio_ctrl, 115 bio_new, 116 bio_free, 117 NULL /* no bio_callback_ctrl */ 118 }; 119 120 BIO_METHOD *BIO_s_bio(void) 121 { 122 return &methods_biop; 123 } 124 125 struct bio_bio_st 126 { 127 BIO *peer; /* NULL if buf == NULL. 128 * If peer != NULL, then peer->ptr is also a bio_bio_st, 129 * and its "peer" member points back to us. 130 * peer != NULL iff init != 0 in the BIO. */ 131 132 /* This is for what we write (i.e. reading uses peer's struct): */ 133 int closed; /* valid iff peer != NULL */ 134 size_t len; /* valid iff buf != NULL; 0 if peer == NULL */ 135 size_t offset; /* valid iff buf != NULL; 0 if len == 0 */ 136 size_t size; 137 char *buf; /* "size" elements (if != NULL) */ 138 139 size_t request; /* valid iff peer != NULL; 0 if len != 0, 140 * otherwise set by peer to number of bytes 141 * it (unsuccessfully) tried to read, 142 * never more than buffer space (size-len) warrants. */ 143 }; 144 145 static int bio_new(BIO *bio) 146 { 147 struct bio_bio_st *b; 148 149 b = OPENSSL_malloc(sizeof *b); 150 if (b == NULL) 151 return 0; 152 153 b->peer = NULL; 154 b->size = 17*1024; /* enough for one TLS record (just a default) */ 155 b->buf = NULL; 156 157 bio->ptr = b; 158 return 1; 159 } 160 161 162 static int bio_free(BIO *bio) 163 { 164 struct bio_bio_st *b; 165 166 if (bio == NULL) 167 return 0; 168 b = bio->ptr; 169 170 assert(b != NULL); 171 172 if (b->peer) 173 bio_destroy_pair(bio); 174 175 if (b->buf != NULL) 176 { 177 OPENSSL_free(b->buf); 178 } 179 180 OPENSSL_free(b); 181 182 return 1; 183 } 184 185 186 187 static int bio_read(BIO *bio, char *buf, int size_) 188 { 189 size_t size = size_; 190 size_t rest; 191 struct bio_bio_st *b, *peer_b; 192 193 BIO_clear_retry_flags(bio); 194 195 if (!bio->init) 196 return 0; 197 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. */ 280 static ossl_ssize_t bio_nread0(BIO *bio, char **buf) 281 { 282 struct bio_bio_st *b, *peer_b; 283 ossl_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 318 static ossl_ssize_t bio_nread(BIO *bio, char **buf, size_t num_) 319 { 320 struct bio_bio_st *b, *peer_b; 321 ossl_ssize_t num, available; 322 323 if (num_ > SSIZE_MAX) 324 num = SSIZE_MAX; 325 else 326 num = (ossl_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 352 static 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 */ 431 static ossl_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 479 static ossl_ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_) 480 { 481 struct bio_bio_st *b; 482 ossl_ssize_t num, space; 483 484 if (num_ > SSIZE_MAX) 485 num = SSIZE_MAX; 486 else 487 num = (ossl_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 503 static 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 698 static int bio_puts(BIO *bio, const char *str) 699 { 700 return bio_write(bio, str, strlen(str)); 701 } 702 703 704 static 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 757 static 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 */ 789 int 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 841 size_t BIO_ctrl_get_write_guarantee(BIO *bio) 842 { 843 return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL); 844 } 845 846 size_t BIO_ctrl_get_read_request(BIO *bio) 847 { 848 return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL); 849 } 850 851 int 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 */ 860 int 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 877 int 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 893 int 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 910 int 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_write += ret; 923 return ret; 924 } 925
