1 /*
2 * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 #define OPENSSL_SUPPRESS_DEPRECATED
11
12 #include <stdio.h>
13 #include <errno.h>
14 #include <openssl/crypto.h>
15 #include "internal/numbers.h"
16 #include "bio_local.h"
17
18 /*
19 * Helper macro for the callback to determine whether an operator expects a
20 * len parameter or not
21 */
22 #define HAS_LEN_OPER(o) ((o) == BIO_CB_READ || (o) == BIO_CB_WRITE \
23 || (o) == BIO_CB_GETS)
24
25 #ifndef OPENSSL_NO_DEPRECATED_3_0
26 # define HAS_CALLBACK(b) ((b)->callback != NULL || (b)->callback_ex != NULL)
27 #else
28 # define HAS_CALLBACK(b) ((b)->callback_ex != NULL)
29 #endif
30 /*
31 * Helper function to work out whether to call the new style callback or the old
32 * one, and translate between the two.
33 *
34 * This has a long return type for consistency with the old callback. Similarly
35 * for the "long" used for "inret"
36 */
bio_call_callback(BIO * b,int oper,const char * argp,size_t len,int argi,long argl,long inret,size_t * processed)37 static long bio_call_callback(BIO *b, int oper, const char *argp, size_t len,
38 int argi, long argl, long inret,
39 size_t *processed)
40 {
41 long ret = inret;
42 #ifndef OPENSSL_NO_DEPRECATED_3_0
43 int bareoper;
44
45 if (b->callback_ex != NULL)
46 #endif
47 return b->callback_ex(b, oper, argp, len, argi, argl, inret, processed);
48
49 #ifndef OPENSSL_NO_DEPRECATED_3_0
50 /* Strip off any BIO_CB_RETURN flag */
51 bareoper = oper & ~BIO_CB_RETURN;
52
53 /*
54 * We have an old style callback, so we will have to do nasty casts and
55 * check for overflows.
56 */
57 if (HAS_LEN_OPER(bareoper)) {
58 /* In this case |len| is set, and should be used instead of |argi| */
59 if (len > INT_MAX)
60 return -1;
61
62 argi = (int)len;
63 }
64
65 if (inret > 0 && (oper & BIO_CB_RETURN) && bareoper != BIO_CB_CTRL) {
66 if (*processed > INT_MAX)
67 return -1;
68 inret = *processed;
69 }
70
71 ret = b->callback(b, oper, argp, argi, argl, inret);
72
73 if (ret > 0 && (oper & BIO_CB_RETURN) && bareoper != BIO_CB_CTRL) {
74 *processed = (size_t)ret;
75 ret = 1;
76 }
77 #endif
78 return ret;
79 }
80
BIO_new_ex(OSSL_LIB_CTX * libctx,const BIO_METHOD * method)81 BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method)
82 {
83 BIO *bio = OPENSSL_zalloc(sizeof(*bio));
84
85 if (bio == NULL)
86 return NULL;
87
88 bio->libctx = libctx;
89 bio->method = method;
90 bio->shutdown = 1;
91
92 if (!CRYPTO_NEW_REF(&bio->references, 1))
93 goto err;
94
95 if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data))
96 goto err;
97
98 if (method->create != NULL && !method->create(bio)) {
99 ERR_raise(ERR_LIB_BIO, ERR_R_INIT_FAIL);
100 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
101 goto err;
102 }
103 if (method->create == NULL)
104 bio->init = 1;
105
106 return bio;
107
108 err:
109 CRYPTO_FREE_REF(&bio->references);
110 OPENSSL_free(bio);
111 return NULL;
112 }
113
BIO_new(const BIO_METHOD * method)114 BIO *BIO_new(const BIO_METHOD *method)
115 {
116 return BIO_new_ex(NULL, method);
117 }
118
BIO_free(BIO * a)119 int BIO_free(BIO *a)
120 {
121 int ret;
122
123 if (a == NULL)
124 return 0;
125
126 if (CRYPTO_DOWN_REF(&a->references, &ret) <= 0)
127 return 0;
128
129 REF_PRINT_COUNT("BIO", a);
130 if (ret > 0)
131 return 1;
132 REF_ASSERT_ISNT(ret < 0);
133
134 if (HAS_CALLBACK(a)) {
135 ret = (int)bio_call_callback(a, BIO_CB_FREE, NULL, 0, 0, 0L, 1L, NULL);
136 if (ret <= 0)
137 return 0;
138 }
139
140 if ((a->method != NULL) && (a->method->destroy != NULL))
141 a->method->destroy(a);
142
143 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
144
145 CRYPTO_FREE_REF(&a->references);
146
147 OPENSSL_free(a);
148
149 return 1;
150 }
151
BIO_set_data(BIO * a,void * ptr)152 void BIO_set_data(BIO *a, void *ptr)
153 {
154 a->ptr = ptr;
155 }
156
BIO_get_data(BIO * a)157 void *BIO_get_data(BIO *a)
158 {
159 return a->ptr;
160 }
161
BIO_set_init(BIO * a,int init)162 void BIO_set_init(BIO *a, int init)
163 {
164 a->init = init;
165 }
166
BIO_get_init(BIO * a)167 int BIO_get_init(BIO *a)
168 {
169 return a->init;
170 }
171
BIO_set_shutdown(BIO * a,int shut)172 void BIO_set_shutdown(BIO *a, int shut)
173 {
174 a->shutdown = shut;
175 }
176
BIO_get_shutdown(BIO * a)177 int BIO_get_shutdown(BIO *a)
178 {
179 return a->shutdown;
180 }
181
BIO_vfree(BIO * a)182 void BIO_vfree(BIO *a)
183 {
184 BIO_free(a);
185 }
186
BIO_up_ref(BIO * a)187 int BIO_up_ref(BIO *a)
188 {
189 int i;
190
191 if (CRYPTO_UP_REF(&a->references, &i) <= 0)
192 return 0;
193
194 REF_PRINT_COUNT("BIO", a);
195 REF_ASSERT_ISNT(i < 2);
196 return i > 1;
197 }
198
BIO_clear_flags(BIO * b,int flags)199 void BIO_clear_flags(BIO *b, int flags)
200 {
201 b->flags &= ~flags;
202 }
203
BIO_test_flags(const BIO * b,int flags)204 int BIO_test_flags(const BIO *b, int flags)
205 {
206 return (b->flags & flags);
207 }
208
BIO_set_flags(BIO * b,int flags)209 void BIO_set_flags(BIO *b, int flags)
210 {
211 b->flags |= flags;
212 }
213
214 #ifndef OPENSSL_NO_DEPRECATED_3_0
BIO_get_callback(const BIO * b)215 BIO_callback_fn BIO_get_callback(const BIO *b)
216 {
217 return b->callback;
218 }
219
BIO_set_callback(BIO * b,BIO_callback_fn cb)220 void BIO_set_callback(BIO *b, BIO_callback_fn cb)
221 {
222 b->callback = cb;
223 }
224 #endif
225
BIO_get_callback_ex(const BIO * b)226 BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b)
227 {
228 return b->callback_ex;
229 }
230
BIO_set_callback_ex(BIO * b,BIO_callback_fn_ex cb)231 void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex cb)
232 {
233 b->callback_ex = cb;
234 }
235
BIO_set_callback_arg(BIO * b,char * arg)236 void BIO_set_callback_arg(BIO *b, char *arg)
237 {
238 b->cb_arg = arg;
239 }
240
BIO_get_callback_arg(const BIO * b)241 char *BIO_get_callback_arg(const BIO *b)
242 {
243 return b->cb_arg;
244 }
245
BIO_method_name(const BIO * b)246 const char *BIO_method_name(const BIO *b)
247 {
248 return b->method->name;
249 }
250
BIO_method_type(const BIO * b)251 int BIO_method_type(const BIO *b)
252 {
253 return b->method->type;
254 }
255
256 /*
257 * This is essentially the same as BIO_read_ex() except that it allows
258 * 0 or a negative value to indicate failure (retryable or not) in the return.
259 * This is for compatibility with the old style BIO_read(), where existing code
260 * may make assumptions about the return value that it might get.
261 */
bio_read_intern(BIO * b,void * data,size_t dlen,size_t * readbytes)262 static int bio_read_intern(BIO *b, void *data, size_t dlen, size_t *readbytes)
263 {
264 int ret;
265
266 if (b == NULL) {
267 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
268 return -1;
269 }
270 if (b->method == NULL || b->method->bread == NULL) {
271 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
272 return -2;
273 }
274
275 if (HAS_CALLBACK(b) &&
276 ((ret = (int)bio_call_callback(b, BIO_CB_READ, data, dlen, 0, 0L, 1L,
277 NULL)) <= 0))
278 return ret;
279
280 if (!b->init) {
281 ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
282 return -1;
283 }
284
285 ret = b->method->bread(b, data, dlen, readbytes);
286
287 if (ret > 0)
288 b->num_read += (uint64_t)*readbytes;
289
290 if (HAS_CALLBACK(b))
291 ret = (int)bio_call_callback(b, BIO_CB_READ | BIO_CB_RETURN, data,
292 dlen, 0, 0L, ret, readbytes);
293
294 /* Shouldn't happen */
295 if (ret > 0 && *readbytes > dlen) {
296 ERR_raise(ERR_LIB_BIO, ERR_R_INTERNAL_ERROR);
297 return -1;
298 }
299
300 return ret;
301 }
302
BIO_read(BIO * b,void * data,int dlen)303 int BIO_read(BIO *b, void *data, int dlen)
304 {
305 size_t readbytes;
306 int ret;
307
308 if (dlen < 0)
309 return 0;
310
311 ret = bio_read_intern(b, data, (size_t)dlen, &readbytes);
312
313 if (ret > 0) {
314 /* *readbytes should always be <= dlen */
315 ret = (int)readbytes;
316 }
317
318 return ret;
319 }
320
BIO_read_ex(BIO * b,void * data,size_t dlen,size_t * readbytes)321 int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes)
322 {
323 return bio_read_intern(b, data, dlen, readbytes) > 0;
324 }
325
bio_write_intern(BIO * b,const void * data,size_t dlen,size_t * written)326 static int bio_write_intern(BIO *b, const void *data, size_t dlen,
327 size_t *written)
328 {
329 size_t local_written;
330 int ret;
331
332 if (written != NULL)
333 *written = 0;
334 /*
335 * b == NULL is not an error but just means that zero bytes are written.
336 * Do not raise an error here.
337 */
338 if (b == NULL)
339 return 0;
340
341 if (b->method == NULL || b->method->bwrite == NULL) {
342 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
343 return -2;
344 }
345
346 if (HAS_CALLBACK(b) &&
347 ((ret = (int)bio_call_callback(b, BIO_CB_WRITE, data, dlen, 0, 0L, 1L,
348 NULL)) <= 0))
349 return ret;
350
351 if (!b->init) {
352 ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
353 return -1;
354 }
355
356 ret = b->method->bwrite(b, data, dlen, &local_written);
357
358 if (ret > 0)
359 b->num_write += (uint64_t)local_written;
360
361 if (HAS_CALLBACK(b))
362 ret = (int)bio_call_callback(b, BIO_CB_WRITE | BIO_CB_RETURN, data,
363 dlen, 0, 0L, ret, &local_written);
364
365 if (written != NULL)
366 *written = local_written;
367 return ret;
368 }
369
BIO_write(BIO * b,const void * data,int dlen)370 int BIO_write(BIO *b, const void *data, int dlen)
371 {
372 size_t written;
373 int ret;
374
375 if (dlen <= 0)
376 return 0;
377
378 ret = bio_write_intern(b, data, (size_t)dlen, &written);
379
380 if (ret > 0) {
381 /* written should always be <= dlen */
382 ret = (int)written;
383 }
384
385 return ret;
386 }
387
BIO_write_ex(BIO * b,const void * data,size_t dlen,size_t * written)388 int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written)
389 {
390 return bio_write_intern(b, data, dlen, written) > 0
391 || (b != NULL && dlen == 0); /* order is important for *written */
392 }
393
BIO_sendmmsg(BIO * b,BIO_MSG * msg,size_t stride,size_t num_msg,uint64_t flags,size_t * msgs_processed)394 int BIO_sendmmsg(BIO *b, BIO_MSG *msg,
395 size_t stride, size_t num_msg, uint64_t flags,
396 size_t *msgs_processed)
397 {
398 size_t ret;
399 BIO_MMSG_CB_ARGS args;
400
401 if (b == NULL) {
402 *msgs_processed = 0;
403 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
404 return 0;
405 }
406
407 if (b->method == NULL || b->method->bsendmmsg == NULL) {
408 *msgs_processed = 0;
409 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
410 return 0;
411 }
412
413 if (HAS_CALLBACK(b)) {
414 args.msg = msg;
415 args.stride = stride;
416 args.num_msg = num_msg;
417 args.flags = flags;
418 args.msgs_processed = msgs_processed;
419
420 ret = (size_t)bio_call_callback(b, BIO_CB_SENDMMSG, (void *)&args,
421 0, 0, 0, 1, NULL);
422 if (ret <= 0)
423 return 0;
424 }
425
426 if (!b->init) {
427 *msgs_processed = 0;
428 ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
429 return 0;
430 }
431
432 ret = b->method->bsendmmsg(b, msg, stride, num_msg, flags, msgs_processed);
433
434 if (HAS_CALLBACK(b))
435 ret = (size_t)bio_call_callback(b, BIO_CB_SENDMMSG | BIO_CB_RETURN,
436 (void *)&args, ret, 0, 0, ret, NULL);
437
438 return ret;
439 }
440
BIO_recvmmsg(BIO * b,BIO_MSG * msg,size_t stride,size_t num_msg,uint64_t flags,size_t * msgs_processed)441 int BIO_recvmmsg(BIO *b, BIO_MSG *msg,
442 size_t stride, size_t num_msg, uint64_t flags,
443 size_t *msgs_processed)
444 {
445 size_t ret;
446 BIO_MMSG_CB_ARGS args;
447
448 if (b == NULL) {
449 *msgs_processed = 0;
450 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
451 return 0;
452 }
453
454 if (b->method == NULL || b->method->brecvmmsg == NULL) {
455 *msgs_processed = 0;
456 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
457 return 0;
458 }
459
460 if (HAS_CALLBACK(b)) {
461 args.msg = msg;
462 args.stride = stride;
463 args.num_msg = num_msg;
464 args.flags = flags;
465 args.msgs_processed = msgs_processed;
466
467 ret = bio_call_callback(b, BIO_CB_RECVMMSG, (void *)&args,
468 0, 0, 0, 1, NULL);
469 if (ret <= 0)
470 return 0;
471 }
472
473 if (!b->init) {
474 *msgs_processed = 0;
475 ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
476 return 0;
477 }
478
479 ret = b->method->brecvmmsg(b, msg, stride, num_msg, flags, msgs_processed);
480
481 if (HAS_CALLBACK(b))
482 ret = (size_t)bio_call_callback(b, BIO_CB_RECVMMSG | BIO_CB_RETURN,
483 (void *)&args, ret, 0, 0, ret, NULL);
484
485 return ret;
486 }
487
BIO_get_rpoll_descriptor(BIO * b,BIO_POLL_DESCRIPTOR * desc)488 int BIO_get_rpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc)
489 {
490 return BIO_ctrl(b, BIO_CTRL_GET_RPOLL_DESCRIPTOR, 0, desc);
491 }
492
BIO_get_wpoll_descriptor(BIO * b,BIO_POLL_DESCRIPTOR * desc)493 int BIO_get_wpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc)
494 {
495 return BIO_ctrl(b, BIO_CTRL_GET_WPOLL_DESCRIPTOR, 0, desc);
496 }
497
BIO_puts(BIO * b,const char * buf)498 int BIO_puts(BIO *b, const char *buf)
499 {
500 int ret;
501 size_t written = 0;
502
503 if (b == NULL) {
504 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
505 return -1;
506 }
507 if (b->method == NULL || b->method->bputs == NULL) {
508 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
509 return -2;
510 }
511
512 if (HAS_CALLBACK(b)) {
513 ret = (int)bio_call_callback(b, BIO_CB_PUTS, buf, 0, 0, 0L, 1L, NULL);
514 if (ret <= 0)
515 return ret;
516 }
517
518 if (!b->init) {
519 ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
520 return -1;
521 }
522
523 ret = b->method->bputs(b, buf);
524
525 if (ret > 0) {
526 b->num_write += (uint64_t)ret;
527 written = ret;
528 ret = 1;
529 }
530
531 if (HAS_CALLBACK(b))
532 ret = (int)bio_call_callback(b, BIO_CB_PUTS | BIO_CB_RETURN, buf, 0, 0,
533 0L, ret, &written);
534
535 if (ret > 0) {
536 if (written > INT_MAX) {
537 ERR_raise(ERR_LIB_BIO, BIO_R_LENGTH_TOO_LONG);
538 ret = -1;
539 } else {
540 ret = (int)written;
541 }
542 }
543
544 return ret;
545 }
546
BIO_gets(BIO * b,char * buf,int size)547 int BIO_gets(BIO *b, char *buf, int size)
548 {
549 int ret;
550 size_t readbytes = 0;
551
552 if (b == NULL) {
553 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
554 return -1;
555 }
556 if (b->method == NULL || b->method->bgets == NULL) {
557 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
558 return -2;
559 }
560
561 if (size < 0) {
562 ERR_raise(ERR_LIB_BIO, BIO_R_INVALID_ARGUMENT);
563 return -1;
564 }
565
566 if (HAS_CALLBACK(b)) {
567 ret = (int)bio_call_callback(b, BIO_CB_GETS, buf, size, 0, 0L, 1, NULL);
568 if (ret <= 0)
569 return ret;
570 }
571
572 if (!b->init) {
573 ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
574 return -1;
575 }
576
577 ret = b->method->bgets(b, buf, size);
578
579 if (ret > 0) {
580 readbytes = ret;
581 ret = 1;
582 }
583
584 if (HAS_CALLBACK(b))
585 ret = (int)bio_call_callback(b, BIO_CB_GETS | BIO_CB_RETURN, buf, size,
586 0, 0L, ret, &readbytes);
587
588 if (ret > 0) {
589 /* Shouldn't happen */
590 if (readbytes > (size_t)size)
591 ret = -1;
592 else
593 ret = (int)readbytes;
594 }
595
596 return ret;
597 }
598
BIO_get_line(BIO * bio,char * buf,int size)599 int BIO_get_line(BIO *bio, char *buf, int size)
600 {
601 int ret = 0;
602 char *ptr = buf;
603
604 if (buf == NULL) {
605 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
606 return -1;
607 }
608 if (size <= 0) {
609 ERR_raise(ERR_LIB_BIO, BIO_R_INVALID_ARGUMENT);
610 return -1;
611 }
612 *buf = '\0';
613
614 if (bio == NULL) {
615 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
616 return -1;
617 }
618 if (!bio->init) {
619 ERR_raise(ERR_LIB_BIO, BIO_R_UNINITIALIZED);
620 return -1;
621 }
622
623 while (size-- > 1 && (ret = BIO_read(bio, ptr, 1)) > 0)
624 if (*ptr++ == '\n')
625 break;
626 *ptr = '\0';
627 return ret > 0 || BIO_eof(bio) ? ptr - buf : ret;
628 }
629
BIO_indent(BIO * b,int indent,int max)630 int BIO_indent(BIO *b, int indent, int max)
631 {
632 if (indent < 0)
633 indent = 0;
634 if (indent > max)
635 indent = max;
636 while (indent--)
637 if (BIO_puts(b, " ") != 1)
638 return 0;
639 return 1;
640 }
641
BIO_int_ctrl(BIO * b,int cmd,long larg,int iarg)642 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
643 {
644 int i;
645
646 i = iarg;
647 return BIO_ctrl(b, cmd, larg, (char *)&i);
648 }
649
BIO_ptr_ctrl(BIO * b,int cmd,long larg)650 void *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
651 {
652 void *p = NULL;
653
654 if (BIO_ctrl(b, cmd, larg, (char *)&p) <= 0)
655 return NULL;
656 else
657 return p;
658 }
659
BIO_ctrl(BIO * b,int cmd,long larg,void * parg)660 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
661 {
662 long ret;
663
664 if (b == NULL)
665 return -1;
666 if (b->method == NULL || b->method->ctrl == NULL) {
667 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
668 return -2;
669 }
670
671 if (HAS_CALLBACK(b)) {
672 ret = bio_call_callback(b, BIO_CB_CTRL, parg, 0, cmd, larg, 1L, NULL);
673 if (ret <= 0)
674 return ret;
675 }
676
677 ret = b->method->ctrl(b, cmd, larg, parg);
678
679 if (HAS_CALLBACK(b))
680 ret = bio_call_callback(b, BIO_CB_CTRL | BIO_CB_RETURN, parg, 0, cmd,
681 larg, ret, NULL);
682
683 return ret;
684 }
685
BIO_callback_ctrl(BIO * b,int cmd,BIO_info_cb * fp)686 long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
687 {
688 long ret;
689
690 if (b == NULL)
691 return -2;
692 if (b->method == NULL || b->method->callback_ctrl == NULL
693 || cmd != BIO_CTRL_SET_CALLBACK) {
694 ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
695 return -2;
696 }
697
698 if (HAS_CALLBACK(b)) {
699 ret = bio_call_callback(b, BIO_CB_CTRL, (void *)&fp, 0, cmd, 0, 1L,
700 NULL);
701 if (ret <= 0)
702 return ret;
703 }
704
705 ret = b->method->callback_ctrl(b, cmd, fp);
706
707 if (HAS_CALLBACK(b))
708 ret = bio_call_callback(b, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, 0,
709 cmd, 0, ret, NULL);
710
711 return ret;
712 }
713
714 /*
715 * It is unfortunate to duplicate in functions what the BIO_(w)pending macros
716 * do; but those macros have inappropriate return type, and for interfacing
717 * from other programming languages, C macros aren't much of a help anyway.
718 */
BIO_ctrl_pending(BIO * bio)719 size_t BIO_ctrl_pending(BIO *bio)
720 {
721 long ret = BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
722
723 if (ret < 0)
724 ret = 0;
725 #if LONG_MAX > SIZE_MAX
726 if (ret > SIZE_MAX)
727 ret = SIZE_MAX;
728 #endif
729 return (size_t)ret;
730 }
731
BIO_ctrl_wpending(BIO * bio)732 size_t BIO_ctrl_wpending(BIO *bio)
733 {
734 long ret = BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
735
736 if (ret < 0)
737 ret = 0;
738 #if LONG_MAX > SIZE_MAX
739 if (ret > SIZE_MAX)
740 ret = SIZE_MAX;
741 #endif
742 return (size_t)ret;
743 }
744
745 /* put the 'bio' on the end of b's list of operators */
BIO_push(BIO * b,BIO * bio)746 BIO *BIO_push(BIO *b, BIO *bio)
747 {
748 BIO *lb;
749
750 if (b == NULL)
751 return bio;
752 lb = b;
753 while (lb->next_bio != NULL)
754 lb = lb->next_bio;
755 lb->next_bio = bio;
756 if (bio != NULL)
757 bio->prev_bio = lb;
758 /* called to do internal processing */
759 BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
760 return b;
761 }
762
763 /* Remove the first and return the rest */
BIO_pop(BIO * b)764 BIO *BIO_pop(BIO *b)
765 {
766 BIO *ret;
767
768 if (b == NULL)
769 return NULL;
770 ret = b->next_bio;
771
772 BIO_ctrl(b, BIO_CTRL_POP, 0, b);
773
774 if (b->prev_bio != NULL)
775 b->prev_bio->next_bio = b->next_bio;
776 if (b->next_bio != NULL)
777 b->next_bio->prev_bio = b->prev_bio;
778
779 b->next_bio = NULL;
780 b->prev_bio = NULL;
781 return ret;
782 }
783
BIO_get_retry_BIO(BIO * bio,int * reason)784 BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
785 {
786 BIO *b, *last;
787
788 b = last = bio;
789 for (;;) {
790 if (!BIO_should_retry(b))
791 break;
792 last = b;
793 b = b->next_bio;
794 if (b == NULL)
795 break;
796 }
797 if (reason != NULL)
798 *reason = last->retry_reason;
799 return last;
800 }
801
BIO_get_retry_reason(BIO * bio)802 int BIO_get_retry_reason(BIO *bio)
803 {
804 return bio->retry_reason;
805 }
806
BIO_set_retry_reason(BIO * bio,int reason)807 void BIO_set_retry_reason(BIO *bio, int reason)
808 {
809 bio->retry_reason = reason;
810 }
811
BIO_find_type(BIO * bio,int type)812 BIO *BIO_find_type(BIO *bio, int type)
813 {
814 int mt, mask;
815
816 if (bio == NULL) {
817 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
818 return NULL;
819 }
820 mask = type & BIO_TYPE_MASK;
821 do {
822 if (bio->method != NULL) {
823 mt = bio->method->type;
824
825 if (!mask) {
826 if (mt & type)
827 return bio;
828 } else if (mt == type) {
829 return bio;
830 }
831 }
832 bio = bio->next_bio;
833 } while (bio != NULL);
834 return NULL;
835 }
836
BIO_next(BIO * b)837 BIO *BIO_next(BIO *b)
838 {
839 if (b == NULL)
840 return NULL;
841 return b->next_bio;
842 }
843
BIO_set_next(BIO * b,BIO * next)844 void BIO_set_next(BIO *b, BIO *next)
845 {
846 b->next_bio = next;
847 }
848
BIO_free_all(BIO * bio)849 void BIO_free_all(BIO *bio)
850 {
851 BIO *b;
852 int ref;
853
854 while (bio != NULL) {
855 b = bio;
856 CRYPTO_GET_REF(&b->references, &ref);
857 bio = bio->next_bio;
858 BIO_free(b);
859 /* Since ref count > 1, don't free anyone else. */
860 if (ref > 1)
861 break;
862 }
863 }
864
BIO_dup_chain(BIO * in)865 BIO *BIO_dup_chain(BIO *in)
866 {
867 BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
868
869 for (bio = in; bio != NULL; bio = bio->next_bio) {
870 if ((new_bio = BIO_new(bio->method)) == NULL)
871 goto err;
872 #ifndef OPENSSL_NO_DEPRECATED_3_0
873 new_bio->callback = bio->callback;
874 #endif
875 new_bio->callback_ex = bio->callback_ex;
876 new_bio->cb_arg = bio->cb_arg;
877 new_bio->init = bio->init;
878 new_bio->shutdown = bio->shutdown;
879 new_bio->flags = bio->flags;
880
881 /* This will let SSL_s_sock() work with stdin/stdout */
882 new_bio->num = bio->num;
883
884 if (BIO_dup_state(bio, (char *)new_bio) <= 0) {
885 BIO_free(new_bio);
886 goto err;
887 }
888
889 /* copy app data */
890 if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
891 &bio->ex_data)) {
892 BIO_free(new_bio);
893 goto err;
894 }
895
896 if (ret == NULL) {
897 eoc = new_bio;
898 ret = eoc;
899 } else {
900 BIO_push(eoc, new_bio);
901 eoc = new_bio;
902 }
903 }
904 return ret;
905 err:
906 BIO_free_all(ret);
907
908 return NULL;
909 }
910
BIO_copy_next_retry(BIO * b)911 void BIO_copy_next_retry(BIO *b)
912 {
913 BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
914 b->retry_reason = b->next_bio->retry_reason;
915 }
916
BIO_set_ex_data(BIO * bio,int idx,void * data)917 int BIO_set_ex_data(BIO *bio, int idx, void *data)
918 {
919 return CRYPTO_set_ex_data(&(bio->ex_data), idx, data);
920 }
921
BIO_get_ex_data(const BIO * bio,int idx)922 void *BIO_get_ex_data(const BIO *bio, int idx)
923 {
924 return CRYPTO_get_ex_data(&(bio->ex_data), idx);
925 }
926
BIO_number_read(BIO * bio)927 uint64_t BIO_number_read(BIO *bio)
928 {
929 if (bio)
930 return bio->num_read;
931 return 0;
932 }
933
BIO_number_written(BIO * bio)934 uint64_t BIO_number_written(BIO *bio)
935 {
936 if (bio)
937 return bio->num_write;
938 return 0;
939 }
940
bio_free_ex_data(BIO * bio)941 void bio_free_ex_data(BIO *bio)
942 {
943 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
944 }
945
bio_cleanup(void)946 void bio_cleanup(void)
947 {
948 #ifndef OPENSSL_NO_SOCK
949 bio_sock_cleanup_int();
950 CRYPTO_THREAD_lock_free(bio_lookup_lock);
951 bio_lookup_lock = NULL;
952 #endif
953 CRYPTO_FREE_REF(&bio_type_count);
954 }
955
956 /* Internal variant of the below BIO_wait() not calling ERR_raise(...) */
bio_wait(BIO * bio,time_t max_time,unsigned int nap_milliseconds)957 static int bio_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds)
958 {
959 #ifndef OPENSSL_NO_SOCK
960 int fd;
961 #endif
962 long sec_diff;
963
964 if (max_time == 0) /* no timeout */
965 return 1;
966
967 #ifndef OPENSSL_NO_SOCK
968 if (BIO_get_fd(bio, &fd) > 0) {
969 int ret = BIO_socket_wait(fd, BIO_should_read(bio), max_time);
970
971 if (ret != -1)
972 return ret;
973 }
974 #endif
975 /* fall back to polling since no sockets are available */
976
977 sec_diff = (long)(max_time - time(NULL)); /* might overflow */
978 if (sec_diff < 0)
979 return 0; /* clearly timeout */
980
981 /* now take a nap at most the given number of milliseconds */
982 if (sec_diff == 0) { /* we are below the 1 seconds resolution of max_time */
983 if (nap_milliseconds > 1000)
984 nap_milliseconds = 1000;
985 } else { /* for sec_diff > 0, take min(sec_diff * 1000, nap_milliseconds) */
986 if ((unsigned long)sec_diff * 1000 < nap_milliseconds)
987 nap_milliseconds = (unsigned int)sec_diff * 1000;
988 }
989 OSSL_sleep(nap_milliseconds);
990 return 1;
991 }
992
993 /*-
994 * Wait on (typically socket-based) BIO at most until max_time.
995 * Succeed immediately if max_time == 0.
996 * If sockets are not available support polling: succeed after waiting at most
997 * the number of nap_milliseconds in order to avoid a tight busy loop.
998 * Call ERR_raise(ERR_LIB_BIO, ...) on timeout or error.
999 * Returns -1 on error, 0 on timeout, and 1 on success.
1000 */
BIO_wait(BIO * bio,time_t max_time,unsigned int nap_milliseconds)1001 int BIO_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds)
1002 {
1003 int rv = bio_wait(bio, max_time, nap_milliseconds);
1004
1005 if (rv <= 0)
1006 ERR_raise(ERR_LIB_BIO,
1007 rv == 0 ? BIO_R_TRANSFER_TIMEOUT : BIO_R_TRANSFER_ERROR);
1008 return rv;
1009 }
1010
1011 /*
1012 * Connect via given BIO using BIO_do_connect() until success/timeout/error.
1013 * Parameter timeout == 0 means no timeout, < 0 means exactly one try.
1014 * For non-blocking and potentially even non-socket BIOs perform polling with
1015 * the given density: between polls sleep nap_milliseconds using BIO_wait()
1016 * in order to avoid a tight busy loop.
1017 * Returns -1 on error, 0 on timeout, and 1 on success.
1018 */
BIO_do_connect_retry(BIO * bio,int timeout,int nap_milliseconds)1019 int BIO_do_connect_retry(BIO *bio, int timeout, int nap_milliseconds)
1020 {
1021 int blocking = timeout <= 0;
1022 time_t max_time = timeout > 0 ? time(NULL) + timeout : 0;
1023 int rv;
1024
1025 if (bio == NULL) {
1026 ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
1027 return -1;
1028 }
1029
1030 if (nap_milliseconds < 0)
1031 nap_milliseconds = 100;
1032 BIO_set_nbio(bio, !blocking);
1033
1034 retry:
1035 ERR_set_mark();
1036 rv = BIO_do_connect(bio);
1037
1038 if (rv <= 0) { /* could be timeout or retryable error or fatal error */
1039 int err = ERR_peek_last_error();
1040 int reason = ERR_GET_REASON(err);
1041 int do_retry = BIO_should_retry(bio); /* may be 1 only if !blocking */
1042
1043 if (ERR_GET_LIB(err) == ERR_LIB_BIO) {
1044 switch (reason) {
1045 case ERR_R_SYS_LIB:
1046 /*
1047 * likely retryable system error occurred, which may be
1048 * EAGAIN (resource temporarily unavailable) some 40 secs after
1049 * calling getaddrinfo(): Temporary failure in name resolution
1050 * or a premature ETIMEDOUT, some 30 seconds after connect()
1051 */
1052 case BIO_R_CONNECT_ERROR:
1053 case BIO_R_NBIO_CONNECT_ERROR:
1054 /* some likely retryable connection error occurred */
1055 (void)BIO_reset(bio); /* often needed to avoid retry failure */
1056 do_retry = 1;
1057 break;
1058 default:
1059 break;
1060 }
1061 }
1062 if (timeout >= 0 && do_retry) {
1063 ERR_pop_to_mark();
1064 /* will not actually wait if timeout == 0 (i.e., blocking BIO): */
1065 rv = bio_wait(bio, max_time, nap_milliseconds);
1066 if (rv > 0)
1067 goto retry;
1068 ERR_raise(ERR_LIB_BIO,
1069 rv == 0 ? BIO_R_CONNECT_TIMEOUT : BIO_R_CONNECT_ERROR);
1070 } else {
1071 ERR_clear_last_mark();
1072 rv = -1;
1073 if (err == 0) /* missing error queue entry */
1074 /* workaround: general error */
1075 ERR_raise(ERR_LIB_BIO, BIO_R_CONNECT_ERROR);
1076 }
1077 } else {
1078 ERR_clear_last_mark();
1079 }
1080
1081 return rv;
1082 }
1083