crypto/bio/bss_bio.c

   1 /* crypto/bio/bss_bio.c  -*- Mode: C; c-file-style: "eay" -*- */
   2
   3 /* Special method for a BIO where the other endpoint is also a BIO
   4  * of this kind, handled by the same thread (i.e. the "peer" is actually
   5  * ourselves, wearing a different hat).
   6  * Such "BIO pairs" are mainly for using the SSL library with I/O interfaces
   7  * for which no specific BIO method is available.
   8  * See ssl/ssltest.c for some hints on how this can be used. */
   9
  10 /* BIO_DEBUG implies BIO_PAIR_DEBUG */
  11 #ifdef BIO_DEBUG
  12 # ifndef BIO_PAIR_DEBUG
  13 #  define BIO_PAIR_DEBUG
  14 # endif
  15 #endif
  16
  17 /* disable assert() unless BIO_PAIR_DEBUG has been defined */
  18 #ifndef BIO_PAIR_DEBUG
  19 # ifndef NDEBUG
  20 #  define NDEBUG
  21 # endif
  22 #endif
  23
  24 #include <assert.h>
  25 #include <limits.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <openssl/bio.h>
  30 #include <openssl/err.h>
  31 #include <openssl/err.h>
  32 #include <openssl/crypto.h>
  33
  34 #include "e_os.h"
  35
  36 /* VxWorks defines SSIZE_MAX with an empty value causing compile errors */
  37 #if defined(OPENSSL_SYS_VSWORKS)
  38 # undef SSIZE_MAX
  39 #endif
  40 #ifndef SSIZE_MAX
  41 # define SSIZE_MAX INT_MAX
  42 #endif
  43
  44 static int bio_new(BIO *bio);
  45 static int bio_free(BIO *bio);
  46 static int bio_read(BIO *bio, char *buf, int size);
  47 static int bio_write(BIO *bio, const char *buf, int num);
  48 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr);
  49 static int bio_puts(BIO *bio, const char *str);
  50
  51 static int bio_make_pair(BIO *bio1, BIO *bio2);
  52 static void bio_destroy_pair(BIO *bio);
  53
  54 static BIO_METHOD methods_biop =
  55 {
  56         BIO_TYPE_BIO,
  57         "BIO pair",
  58         bio_write,
  59         bio_read,
  60         bio_puts,
  61         NULL /* no bio_gets */,
  62         bio_ctrl,
  63         bio_new,
  64         bio_free,
  65         NULL /* no bio_callback_ctrl */
  66 };
  67
  68 BIO_METHOD *BIO_s_bio(void)
  69         {
  70         return &methods_biop;
  71         }
  72
  73 struct bio_bio_st
  74 {
  75         BIO *peer;     /* NULL if buf == NULL.
  76                         * If peer != NULL, then peer->ptr is also a bio_bio_st,
  77                         * and its "peer" member points back to us.
  78                         * peer != NULL iff init != 0 in the BIO. */
  79
  80         /* This is for what we write (i.e. reading uses peer's struct): */
  81         int closed;     /* valid iff peer != NULL */
  82         size_t len;     /* valid iff buf != NULL; 0 if peer == NULL */
  83         size_t offset;  /* valid iff buf != NULL; 0 if len == 0 */
  84         size_t size;
  85         char *buf;      /* "size" elements (if != NULL) */
  86
  87         size_t request; /* valid iff peer != NULL; 0 if len != 0,
  88                          * otherwise set by peer to number of bytes
  89                          * it (unsuccessfully) tried to read,
  90                          * never more than buffer space (size-len) warrants. */
  91 };
  92
  93 static int bio_new(BIO *bio)
  94         {
  95         struct bio_bio_st *b;
  96
  97         b = OPENSSL_malloc(sizeof *b);
  98         if (b == NULL)
  99                 return 0;
 100
 101         b->peer = NULL;
 102         b->size = 17*1024; /* enough for one TLS record (just a default) */
 103         b->buf = NULL;
 104
 105         bio->ptr = b;
 106         return 1;
 107         }
 108
 109
 110 static int bio_free(BIO *bio)
 111         {
 112         struct bio_bio_st *b;
 113
 114         if (bio == NULL)
 115                 return 0;
 116         b = bio->ptr;
 117
 118         assert(b != NULL);
 119
 120         if (b->peer)
 121                 bio_destroy_pair(bio);
 122
 123         if (b->buf != NULL)
 124                 {
 125                 OPENSSL_free(b->buf);
 126                 }
 127
 128         OPENSSL_free(b);
 129
 130         return 1;
 131         }
 132
 133
 134
 135 static int bio_read(BIO *bio, char *buf, int size_)
 136         {
 137         size_t size = size_;
 138         size_t rest;
 139         struct bio_bio_st *b, *peer_b;
 140
 141         BIO_clear_retry_flags(bio);
 142
 143         if (!bio->init)
 144                 return 0;
 145
 146         b = bio->ptr;
 147         assert(b != NULL);
 148         assert(b->peer != NULL);
 149         peer_b = b->peer->ptr;
 150         assert(peer_b != NULL);
 151         assert(peer_b->buf != NULL);
 152
 153         peer_b->request = 0; /* will be set in "retry_read" situation */
 154
 155         if (buf == NULL || size == 0)
 156                 return 0;
 157
 158         if (peer_b->len == 0)
 159                 {
 160                 if (peer_b->closed)
 161                         return 0; /* writer has closed, and no data is left */
 162                 else
 163                         {
 164                         BIO_set_retry_read(bio); /* buffer is empty */
 165                         if (size <= peer_b->size)
 166                                 peer_b->request = size;
 167                         else
 168                                 /* don't ask for more than the peer can
 169                                  * deliver in one write */
 170                                 peer_b->request = peer_b->size;
 171                         return -1;
 172                         }
 173                 }
 174
 175         /* we can read */
 176         if (peer_b->len < size)
 177                 size = peer_b->len;
 178
 179         /* now read "size" bytes */
 180
 181         rest = size;
 182
 183         assert(rest > 0);
 184         do /* one or two iterations */
 185                 {
 186                 size_t chunk;
 187
 188                 assert(rest <= peer_b->len);
 189                 if (peer_b->offset + rest <= peer_b->size)
 190                         chunk = rest;
 191                 else
 192                         /* wrap around ring buffer */
 193                         chunk = peer_b->size - peer_b->offset;
 194                 assert(peer_b->offset + chunk <= peer_b->size);
 195
 196                 memcpy(buf, peer_b->buf + peer_b->offset, chunk);
 197
 198                 peer_b->len -= chunk;
 199                 if (peer_b->len)
 200                         {
 201                         peer_b->offset += chunk;
 202                         assert(peer_b->offset <= peer_b->size);
 203                         if (peer_b->offset == peer_b->size)
 204                                 peer_b->offset = 0;
 205                         buf += chunk;
 206                         }
 207                 else
 208                         {
 209                         /* buffer now empty, no need to advance "buf" */
 210                         assert(chunk == rest);
 211                         peer_b->offset = 0;
 212                         }
 213                 rest -= chunk;
 214                 }
 215         while (rest);
 216
 217         return size;
 218         }
 219
 220 /* non-copying interface: provide pointer to available data in buffer
 221  *    bio_nread0:  return number of available bytes
 222  *    bio_nread:   also advance index
 223  * (example usage:  bio_nread0(), read from buffer, bio_nread()
 224  *  or just         bio_nread(), read from buffer)
 225  */
 226 /* WARNING: The non-copying interface is largely untested as of yet
 227  * and may contain bugs. */
 228 static ssize_t bio_nread0(BIO *bio, char **buf)
 229         {
 230         struct bio_bio_st *b, *peer_b;
 231         ssize_t num;
 232
 233         BIO_clear_retry_flags(bio);
 234
 235         if (!bio->init)
 236                 return 0;
 237
 238         b = bio->ptr;
 239         assert(b != NULL);
 240         assert(b->peer != NULL);
 241         peer_b = b->peer->ptr;
 242         assert(peer_b != NULL);
 243         assert(peer_b->buf != NULL);
 244
 245         peer_b->request = 0;
 246
 247         if (peer_b->len == 0)
 248                 {
 249                 char dummy;
 250
 251                 /* avoid code duplication -- nothing available for reading */
 252                 return bio_read(bio, &dummy, 1); /* returns 0 or -1 */
 253                 }
 254
 255         num = peer_b->len;
 256         if (peer_b->size < peer_b->offset + num)
 257                 /* no ring buffer wrap-around for non-copying interface */
 258                 num = peer_b->size - peer_b->offset;
 259         assert(num > 0);
 260
 261         if (buf != NULL)
 262                 *buf = peer_b->buf + peer_b->offset;
 263         return num;
 264         }
 265
 266 static ssize_t bio_nread(BIO *bio, char **buf, size_t num_)
 267         {
 268         struct bio_bio_st *b, *peer_b;
 269         ssize_t num, available;
 270
 271         if (num_ > SSIZE_MAX)
 272                 num = SSIZE_MAX;
 273         else
 274                 num = (ssize_t)num_;
 275
 276         available = bio_nread0(bio, buf);
 277         if (num > available)
 278                 num = available;
 279         if (num <= 0)
 280                 return num;
 281
 282         b = bio->ptr;
 283         peer_b = b->peer->ptr;
 284
 285         peer_b->len -= num;
 286         if (peer_b->len)
 287                 {
 288                 peer_b->offset += num;
 289                 assert(peer_b->offset <= peer_b->size);
 290                 if (peer_b->offset == peer_b->size)
 291                         peer_b->offset = 0;
 292                 }
 293         else
 294                 peer_b->offset = 0;
 295
 296         return num;
 297         }
 298
 299
 300 static int bio_write(BIO *bio, const char *buf, int num_)
 301         {
 302         size_t num = num_;
 303         size_t rest;
 304         struct bio_bio_st *b;
 305
 306         BIO_clear_retry_flags(bio);
 307
 308         if (!bio->init || buf == NULL || num == 0)
 309                 return 0;
 310
 311         b = bio->ptr;
 312         assert(b != NULL);
 313         assert(b->peer != NULL);
 314         assert(b->buf != NULL);
 315
 316         b->request = 0;
 317         if (b->closed)
 318                 {
 319                 /* we already closed */
 320                 BIOerr(BIO_F_BIO_WRITE, BIO_R_BROKEN_PIPE);
 321                 return -1;
 322                 }
 323
 324         assert(b->len <= b->size);
 325
 326         if (b->len == b->size)
 327                 {
 328                 BIO_set_retry_write(bio); /* buffer is full */
 329                 return -1;
 330                 }
 331
 332         /* we can write */
 333         if (num > b->size - b->len)
 334                 num = b->size - b->len;
 335
 336         /* now write "num" bytes */
 337
 338         rest = num;
 339
 340         assert(rest > 0);
 341         do /* one or two iterations */
 342                 {
 343                 size_t write_offset;
 344                 size_t chunk;
 345
 346                 assert(b->len + rest <= b->size);
 347
 348                 write_offset = b->offset + b->len;
 349                 if (write_offset >= b->size)
 350                         write_offset -= b->size;
 351                 /* b->buf[write_offset] is the first byte we can write to. */
 352
 353                 if (write_offset + rest <= b->size)
 354                         chunk = rest;
 355                 else
 356                         /* wrap around ring buffer */
 357                         chunk = b->size - write_offset;
 358
 359                 memcpy(b->buf + write_offset, buf, chunk);
 360
 361                 b->len += chunk;
 362
 363                 assert(b->len <= b->size);
 364
 365                 rest -= chunk;
 366                 buf += chunk;
 367                 }
 368         while (rest);
 369
 370         return num;
 371         }
 372
 373 /* non-copying interface: provide pointer to region to write to
 374  *   bio_nwrite0:  check how much space is available
 375  *   bio_nwrite:   also increase length
 376  * (example usage:  bio_nwrite0(), write to buffer, bio_nwrite()
 377  *  or just         bio_nwrite(), write to buffer)
 378  */
 379 static ssize_t bio_nwrite0(BIO *bio, char **buf)
 380         {
 381         struct bio_bio_st *b;
 382         size_t num;
 383         size_t write_offset;
 384
 385         BIO_clear_retry_flags(bio);
 386
 387         if (!bio->init)
 388                 return 0;
 389
 390         b = bio->ptr;
 391         assert(b != NULL);
 392         assert(b->peer != NULL);
 393         assert(b->buf != NULL);
 394
 395         b->request = 0;
 396         if (b->closed)
 397                 {
 398                 BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE);
 399                 return -1;
 400                 }
 401
 402         assert(b->len <= b->size);
 403
 404         if (b->len == b->size)
 405                 {
 406                 BIO_set_retry_write(bio);
 407                 return -1;
 408                 }
 409
 410         num = b->size - b->len;
 411         write_offset = b->offset + b->len;
 412         if (write_offset >= b->size)
 413                 write_offset -= b->size;
 414         if (write_offset + num > b->size)
 415                 /* no ring buffer wrap-around for non-copying interface
 416                  * (to fulfil the promise by BIO_ctrl_get_write_guarantee,
 417                  * BIO_nwrite may have to be called twice) */
 418                 num = b->size - write_offset;
 419
 420         if (buf != NULL)
 421                 *buf = b->buf + write_offset;
 422         assert(write_offset + num <= b->size);
 423
 424         return num;
 425         }
 426
 427 static ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_)
 428         {
 429         struct bio_bio_st *b;
 430         ssize_t num, space;
 431
 432         if (num_ > SSIZE_MAX)
 433                 num = SSIZE_MAX;
 434         else
 435                 num = (ssize_t)num_;
 436
 437         space = bio_nwrite0(bio, buf);
 438         if (num > space)
 439                 num = space;
 440         if (num <= 0)
 441                 return num;
 442         b = bio->ptr;
 443         assert(b != NULL);
 444         b->len += num;
 445         assert(b->len <= b->size);
 446
 447         return num;
 448         }
 449
 450
 451 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
 452         {
 453         long ret;
 454         struct bio_bio_st *b = bio->ptr;
 455
 456         assert(b != NULL);
 457
 458         switch (cmd)
 459                 {
 460         /* specific CTRL codes */
 461
 462         case BIO_C_SET_WRITE_BUF_SIZE:
 463                 if (b->peer)
 464                         {
 465                         BIOerr(BIO_F_BIO_CTRL, BIO_R_IN_USE);
 466                         ret = 0;
 467                         }
 468                 else if (num == 0)
 469                         {
 470                         BIOerr(BIO_F_BIO_CTRL, BIO_R_INVALID_ARGUMENT);
 471                         ret = 0;
 472                         }
 473                 else
 474                         {
 475                         size_t new_size = num;
 476
 477                         if (b->size != new_size)
 478                                 {
 479                                 if (b->buf)
 480                                         {
 481                                         OPENSSL_free(b->buf);
 482                                         b->buf = NULL;
 483                                         }
 484                                 b->size = new_size;
 485                                 }
 486                         ret = 1;
 487                         }
 488                 break;
 489
 490         case BIO_C_GET_WRITE_BUF_SIZE:
 491                 ret = (long) b->size;
 492                 break;
 493
 494         case BIO_C_MAKE_BIO_PAIR:
 495                 {
 496                 BIO *other_bio = ptr;
 497
 498                 if (bio_make_pair(bio, other_bio))
 499                         ret = 1;
 500                 else
 501                         ret = 0;
 502                 }
 503                 break;
 504
 505         case BIO_C_DESTROY_BIO_PAIR:
 506                 /* Effects both BIOs in the pair -- call just once!
 507                  * Or let BIO_free(bio1); BIO_free(bio2); do the job. */
 508                 bio_destroy_pair(bio);
 509                 ret = 1;
 510                 break;
 511
 512         case BIO_C_GET_WRITE_GUARANTEE:
 513                 /* How many bytes can the caller feed to the next write
 514                  * without having to keep any? */
 515                 if (b->peer == NULL || b->closed)
 516                         ret = 0;
 517                 else
 518                         ret = (long) b->size - b->len;
 519                 break;
 520
 521         case BIO_C_GET_READ_REQUEST:
 522                 /* If the peer unsuccessfully tried to read, how many bytes
 523                  * were requested?  (As with BIO_CTRL_PENDING, that number
 524                  * can usually be treated as boolean.) */
 525                 ret = (long) b->request;
 526                 break;
 527
 528         case BIO_C_RESET_READ_REQUEST:
 529                 /* Reset request.  (Can be useful after read attempts
 530                  * at the other side that are meant to be non-blocking,
 531                  * e.g. when probing SSL_read to see if any data is
 532                  * available.) */
 533                 b->request = 0;
 534                 ret = 1;
 535                 break;
 536
 537         case BIO_C_SHUTDOWN_WR:
 538                 /* similar to shutdown(..., SHUT_WR) */
 539                 b->closed = 1;
 540                 ret = 1;
 541                 break;
 542
 543         case BIO_C_NREAD0:
 544                 /* prepare for non-copying read */
 545                 ret = (long) bio_nread0(bio, ptr);
 546                 break;
 547
 548         case BIO_C_NREAD:
 549                 /* non-copying read */
 550                 ret = (long) bio_nread(bio, ptr, (size_t) num);
 551                 break;
 552
 553         case BIO_C_NWRITE0:
 554                 /* prepare for non-copying write */
 555                 ret = (long) bio_nwrite0(bio, ptr);
 556                 break;
 557
 558         case BIO_C_NWRITE:
 559                 /* non-copying write */
 560                 ret = (long) bio_nwrite(bio, ptr, (size_t) num);
 561                 break;
 562
 563
 564         /* standard CTRL codes follow */
 565
 566         case BIO_CTRL_RESET:
 567                 if (b->buf != NULL)
 568                         {
 569                         b->len = 0;
 570                         b->offset = 0;
 571                         }
 572                 ret = 0;
 573                 break;
 574
 575         case BIO_CTRL_GET_CLOSE:
 576                 ret = bio->shutdown;
 577                 break;
 578
 579         case BIO_CTRL_SET_CLOSE:
 580                 bio->shutdown = (int) num;
 581                 ret = 1;
 582                 break;
 583
 584         case BIO_CTRL_PENDING:
 585                 if (b->peer != NULL)
 586                         {
 587                         struct bio_bio_st *peer_b = b->peer->ptr;
 588
 589                         ret = (long) peer_b->len;
 590                         }
 591                 else
 592                         ret = 0;
 593                 break;
 594
 595         case BIO_CTRL_WPENDING:
 596                 if (b->buf != NULL)
 597                         ret = (long) b->len;
 598                 else
 599                         ret = 0;
 600                 break;
 601
 602         case BIO_CTRL_DUP:
 603                 /* See BIO_dup_chain for circumstances we have to expect. */
 604                 {
 605                 BIO *other_bio = ptr;
 606                 struct bio_bio_st *other_b;
 607
 608                 assert(other_bio != NULL);
 609                 other_b = other_bio->ptr;
 610                 assert(other_b != NULL);
 611
 612                 assert(other_b->buf == NULL); /* other_bio is always fresh */
 613
 614                 other_b->size = b->size;
 615                 }
 616
 617                 ret = 1;
 618                 break;
 619
 620         case BIO_CTRL_FLUSH:
 621                 ret = 1;
 622                 break;
 623
 624         case BIO_CTRL_EOF:
 625                 {
 626                 BIO *other_bio = ptr;
 627
 628                 if (other_bio)
 629                         {
 630                         struct bio_bio_st *other_b = other_bio->ptr;
 631
 632                         assert(other_b != NULL);
 633                         ret = other_b->len == 0 && other_b->closed;
 634                         }
 635                 else
 636                         ret = 1;
 637                 }
 638                 break;
 639
 640         default:
 641                 ret = 0;
 642                 }
 643         return ret;
 644         }
 645
 646 static int bio_puts(BIO *bio, const char *str)
 647         {
 648         return bio_write(bio, str, strlen(str));
 649         }
 650
 651
 652 static int bio_make_pair(BIO *bio1, BIO *bio2)
 653         {
 654         struct bio_bio_st *b1, *b2;
 655
 656         assert(bio1 != NULL);
 657         assert(bio2 != NULL);
 658
 659         b1 = bio1->ptr;
 660         b2 = bio2->ptr;
 661
 662         if (b1->peer != NULL || b2->peer != NULL)
 663                 {
 664                 BIOerr(BIO_F_BIO_MAKE_PAIR, BIO_R_IN_USE);
 665                 return 0;
 666                 }
 667
 668         if (b1->buf == NULL)
 669                 {
 670                 b1->buf = OPENSSL_malloc(b1->size);
 671                 if (b1->buf == NULL)
 672                         {
 673                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
 674                         return 0;
 675                         }
 676                 b1->len = 0;
 677                 b1->offset = 0;
 678                 }
 679
 680         if (b2->buf == NULL)
 681                 {
 682                 b2->buf = OPENSSL_malloc(b2->size);
 683                 if (b2->buf == NULL)
 684                         {
 685                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
 686                         return 0;
 687                         }
 688                 b2->len = 0;
 689                 b2->offset = 0;
 690                 }
 691
 692         b1->peer = bio2;
 693         b1->closed = 0;
 694         b1->request = 0;
 695         b2->peer = bio1;
 696         b2->closed = 0;
 697         b2->request = 0;
 698
 699         bio1->init = 1;
 700         bio2->init = 1;
 701
 702         return 1;
 703         }
 704
 705 static void bio_destroy_pair(BIO *bio)
 706         {
 707         struct bio_bio_st *b = bio->ptr;
 708
 709         if (b != NULL)
 710                 {
 711                 BIO *peer_bio = b->peer;
 712
 713                 if (peer_bio != NULL)
 714                         {
 715                         struct bio_bio_st *peer_b = peer_bio->ptr;
 716
 717                         assert(peer_b != NULL);
 718                         assert(peer_b->peer == bio);
 719
 720                         peer_b->peer = NULL;
 721                         peer_bio->init = 0;
 722                         assert(peer_b->buf != NULL);
 723                         peer_b->len = 0;
 724                         peer_b->offset = 0;
 725
 726                         b->peer = NULL;
 727                         bio->init = 0;
 728                         assert(b->buf != NULL);
 729                         b->len = 0;
 730                         b->offset = 0;
 731                         }
 732                 }
 733         }
 734
 735
 736 /* Exported convenience functions */
 737 int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1,
 738         BIO **bio2_p, size_t writebuf2)
 739          {
 740          BIO *bio1 = NULL, *bio2 = NULL;
 741          long r;
 742          int ret = 0;
 743
 744          bio1 = BIO_new(BIO_s_bio());
 745          if (bio1 == NULL)
 746                  goto err;
 747          bio2 = BIO_new(BIO_s_bio());
 748          if (bio2 == NULL)
 749                  goto err;
 750
 751          if (writebuf1)
 752                  {
 753                  r = BIO_set_write_buf_size(bio1, writebuf1);
 754                  if (!r)
 755                          goto err;
 756                  }
 757          if (writebuf2)
 758                  {
 759                  r = BIO_set_write_buf_size(bio2, writebuf2);
 760                  if (!r)
 761                          goto err;
 762                  }
 763
 764          r = BIO_make_bio_pair(bio1, bio2);
 765          if (!r)
 766                  goto err;
 767          ret = 1;
 768
 769  err:
 770          if (ret == 0)
 771                  {
 772                  if (bio1)
 773                          {
 774                          BIO_free(bio1);
 775                          bio1 = NULL;
 776                          }
 777                  if (bio2)
 778                          {
 779                          BIO_free(bio2);
 780                          bio2 = NULL;
 781                          }
 782                  }
 783
 784          *bio1_p = bio1;
 785          *bio2_p = bio2;
 786          return ret;
 787          }
 788
 789 size_t BIO_ctrl_get_write_guarantee(BIO *bio)
 790         {
 791         return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL);
 792         }
 793
 794 size_t BIO_ctrl_get_read_request(BIO *bio)
 795         {
 796         return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);
 797         }
 798
 799 int BIO_ctrl_reset_read_request(BIO *bio)
 800         {
 801         return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0);
 802         }
 803
 804
 805 /* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now
 806  * (conceivably some other BIOs could allow non-copying reads and writes too.)
 807  */
 808 int BIO_nread0(BIO *bio, char **buf)
 809         {
 810         long ret;
 811
 812         if (!bio->init)
 813                 {
 814                 BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED);
 815                 return -2;
 816                 }
 817
 818         ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf);
 819         if (ret > INT_MAX)
 820                 return INT_MAX;
 821         else
 822                 return (int) ret;
 823         }
 824
 825 int BIO_nread(BIO *bio, char **buf, int num)
 826         {
 827         int ret;
 828
 829         if (!bio->init)
 830                 {
 831                 BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED);
 832                 return -2;
 833                 }
 834
 835         ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf);
 836         if (ret > 0)
 837                 bio->num_read += ret;
 838         return ret;
 839         }
 840
 841 int BIO_nwrite0(BIO *bio, char **buf)
 842         {
 843         long ret;
 844
 845         if (!bio->init)
 846                 {
 847                 BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED);
 848                 return -2;
 849                 }
 850
 851         ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf);
 852         if (ret > INT_MAX)
 853                 return INT_MAX;
 854         else
 855                 return (int) ret;
 856         }
 857
 858 int BIO_nwrite(BIO *bio, char **buf, int num)
 859         {
 860         int ret;
 861
 862         if (!bio->init)
 863                 {
 864                 BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED);
 865                 return -2;
 866                 }
 867
 868         ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf);
 869         if (ret > 0)
 870                 bio->num_read += ret;
 871         return ret;
 872         }