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