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