Branch data Line data Source code
1 : : /* crypto/bio/bio_lib.c */
2 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 : : * All rights reserved.
4 : : *
5 : : * This package is an SSL implementation written
6 : : * by Eric Young (eay@cryptsoft.com).
7 : : * The implementation was written so as to conform with Netscapes SSL.
8 : : *
9 : : * This library is free for commercial and non-commercial use as long as
10 : : * the following conditions are aheared to. The following conditions
11 : : * apply to all code found in this distribution, be it the RC4, RSA,
12 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 : : * included with this distribution is covered by the same copyright terms
14 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 : : *
16 : : * Copyright remains Eric Young's, and as such any Copyright notices in
17 : : * the code are not to be removed.
18 : : * If this package is used in a product, Eric Young should be given attribution
19 : : * as the author of the parts of the library used.
20 : : * This can be in the form of a textual message at program startup or
21 : : * in documentation (online or textual) provided with the package.
22 : : *
23 : : * Redistribution and use in source and binary forms, with or without
24 : : * modification, are permitted provided that the following conditions
25 : : * are met:
26 : : * 1. Redistributions of source code must retain the copyright
27 : : * notice, this list of conditions and the following disclaimer.
28 : : * 2. Redistributions in binary form must reproduce the above copyright
29 : : * notice, this list of conditions and the following disclaimer in the
30 : : * documentation and/or other materials provided with the distribution.
31 : : * 3. All advertising materials mentioning features or use of this software
32 : : * must display the following acknowledgement:
33 : : * "This product includes cryptographic software written by
34 : : * Eric Young (eay@cryptsoft.com)"
35 : : * The word 'cryptographic' can be left out if the rouines from the library
36 : : * being used are not cryptographic related :-).
37 : : * 4. If you include any Windows specific code (or a derivative thereof) from
38 : : * the apps directory (application code) you must include an acknowledgement:
39 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 : : *
41 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 : : * SUCH DAMAGE.
52 : : *
53 : : * The licence and distribution terms for any publically available version or
54 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
55 : : * copied and put under another distribution licence
56 : : * [including the GNU Public Licence.]
57 : : */
58 : :
59 : : #include <stdio.h>
60 : : #include <errno.h>
61 : : #include <openssl/crypto.h>
62 : : #include "cryptlib.h"
63 : : #include <openssl/bio.h>
64 : : #include <openssl/stack.h>
65 : :
66 : 19413 : BIO *BIO_new(BIO_METHOD *method)
67 : : {
68 : 19413 : BIO *ret=NULL;
69 : :
70 : 19413 : ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
71 [ - + ]: 19413 : if (ret == NULL)
72 : : {
73 : 0 : BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
74 : 0 : return(NULL);
75 : : }
76 [ - + ]: 19413 : if (!BIO_set(ret,method))
77 : : {
78 : 0 : OPENSSL_free(ret);
79 : 0 : ret=NULL;
80 : : }
81 : 19413 : return(ret);
82 : : }
83 : :
84 : 19413 : int BIO_set(BIO *bio, BIO_METHOD *method)
85 : : {
86 : 19413 : bio->method=method;
87 : 19413 : bio->callback=NULL;
88 : 19413 : bio->cb_arg=NULL;
89 : 19413 : bio->init=0;
90 : 19413 : bio->shutdown=1;
91 : 19413 : bio->flags=0;
92 : 19413 : bio->retry_reason=0;
93 : 19413 : bio->num=0;
94 : 19413 : bio->ptr=NULL;
95 : 19413 : bio->prev_bio=NULL;
96 : 19413 : bio->next_bio=NULL;
97 : 19413 : bio->references=1;
98 : 19413 : bio->num_read=0L;
99 : 19413 : bio->num_write=0L;
100 : 19413 : CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
101 [ + - ]: 19413 : if (method->create != NULL)
102 [ - + ]: 19413 : if (!method->create(bio))
103 : : {
104 : 0 : CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio,
105 : : &bio->ex_data);
106 : 0 : return(0);
107 : : }
108 : : return(1);
109 : : }
110 : :
111 : 22066 : int BIO_free(BIO *a)
112 : : {
113 : : int i;
114 : :
115 [ + + ]: 22066 : if (a == NULL) return(0);
116 : :
117 : 21836 : i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_BIO);
118 : : #ifdef REF_PRINT
119 : : REF_PRINT("BIO",a);
120 : : #endif
121 [ + + ]: 21836 : if (i > 0) return(1);
122 : : #ifdef REF_CHECK
123 : : if (i < 0)
124 : : {
125 : : fprintf(stderr,"BIO_free, bad reference count\n");
126 : : abort();
127 : : }
128 : : #endif
129 [ - + # # ]: 19412 : if ((a->callback != NULL) &&
130 : 0 : ((i=(int)a->callback(a,BIO_CB_FREE,NULL,0,0L,1L)) <= 0))
131 : : return(i);
132 : :
133 : 19412 : CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
134 : :
135 [ + - ][ + - ]: 19412 : if ((a->method != NULL) && (a->method->destroy != NULL))
136 : 19412 : a->method->destroy(a);
137 : 19412 : OPENSSL_free(a);
138 : 19412 : return(1);
139 : : }
140 : :
141 : 0 : void BIO_vfree(BIO *a)
142 : 0 : { BIO_free(a); }
143 : :
144 : 396505 : void BIO_clear_flags(BIO *b, int flags)
145 : : {
146 : 396505 : b->flags &= ~flags;
147 : 396505 : }
148 : :
149 : 198463 : int BIO_test_flags(const BIO *b, int flags)
150 : : {
151 : 198463 : return (b->flags & flags);
152 : : }
153 : :
154 : 195058 : void BIO_set_flags(BIO *b, int flags)
155 : : {
156 : 195058 : b->flags |= flags;
157 : 195058 : }
158 : :
159 : 0 : long (*BIO_get_callback(const BIO *b))(struct bio_st *,int,const char *,int, long,long)
160 : : {
161 : 0 : return b->callback;
162 : : }
163 : :
164 : 0 : void BIO_set_callback(BIO *b, long (*cb)(struct bio_st *,int,const char *,int, long,long))
165 : : {
166 : 0 : b->callback = cb;
167 : 0 : }
168 : :
169 : 0 : void BIO_set_callback_arg(BIO *b, char *arg)
170 : : {
171 : 0 : b->cb_arg = arg;
172 : 0 : }
173 : :
174 : 0 : char * BIO_get_callback_arg(const BIO *b)
175 : : {
176 : 0 : return b->cb_arg;
177 : : }
178 : :
179 : 0 : const char * BIO_method_name(const BIO *b)
180 : : {
181 : 0 : return b->method->name;
182 : : }
183 : :
184 : 59 : int BIO_method_type(const BIO *b)
185 : : {
186 : 59 : return b->method->type;
187 : : }
188 : :
189 : :
190 : 212914 : int BIO_read(BIO *b, void *out, int outl)
191 : : {
192 : : int i;
193 : : long (*cb)(BIO *,int,const char *,int,long,long);
194 : :
195 [ + - ][ + - ]: 212914 : if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL))
[ - + ]
196 : : {
197 : 0 : BIOerr(BIO_F_BIO_READ,BIO_R_UNSUPPORTED_METHOD);
198 : 0 : return(-2);
199 : : }
200 : :
201 : 212914 : cb=b->callback;
202 [ - + # # ]: 212914 : if ((cb != NULL) &&
203 : 0 : ((i=(int)cb(b,BIO_CB_READ,out,outl,0L,1L)) <= 0))
204 : : return(i);
205 : :
206 [ - + ]: 212914 : if (!b->init)
207 : : {
208 : 0 : BIOerr(BIO_F_BIO_READ,BIO_R_UNINITIALIZED);
209 : 0 : return(-2);
210 : : }
211 : :
212 : 212914 : i=b->method->bread(b,out,outl);
213 : :
214 [ + + ]: 212914 : if (i > 0) b->num_read+=(unsigned long)i;
215 : :
216 [ - + ]: 212914 : if (cb != NULL)
217 : 0 : i=(int)cb(b,BIO_CB_READ|BIO_CB_RETURN,out,outl,
218 : : 0L,(long)i);
219 : 212914 : return(i);
220 : : }
221 : :
222 : 938527 : int BIO_write(BIO *b, const void *in, int inl)
223 : : {
224 : : int i;
225 : : long (*cb)(BIO *,int,const char *,int,long,long);
226 : :
227 [ + - ]: 938527 : if (b == NULL)
228 : : return(0);
229 : :
230 : 938527 : cb=b->callback;
231 [ + - ][ - + ]: 938527 : if ((b->method == NULL) || (b->method->bwrite == NULL))
232 : : {
233 : 0 : BIOerr(BIO_F_BIO_WRITE,BIO_R_UNSUPPORTED_METHOD);
234 : 0 : return(-2);
235 : : }
236 : :
237 [ - + # # ]: 938527 : if ((cb != NULL) &&
238 : 0 : ((i=(int)cb(b,BIO_CB_WRITE,in,inl,0L,1L)) <= 0))
239 : : return(i);
240 : :
241 [ + + ]: 938527 : if (!b->init)
242 : : {
243 : 1430 : BIOerr(BIO_F_BIO_WRITE,BIO_R_UNINITIALIZED);
244 : 1430 : return(-2);
245 : : }
246 : :
247 : 937097 : i=b->method->bwrite(b,in,inl);
248 : :
249 [ + + ]: 937097 : if (i > 0) b->num_write+=(unsigned long)i;
250 : :
251 [ - + ]: 937097 : if (cb != NULL)
252 : 0 : i=(int)cb(b,BIO_CB_WRITE|BIO_CB_RETURN,in,inl,
253 : : 0L,(long)i);
254 : 937097 : return(i);
255 : : }
256 : :
257 : 20053 : int BIO_puts(BIO *b, const char *in)
258 : : {
259 : : int i;
260 : : long (*cb)(BIO *,int,const char *,int,long,long);
261 : :
262 [ + - ][ + - ]: 20053 : if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL))
[ - + ]
263 : : {
264 : 0 : BIOerr(BIO_F_BIO_PUTS,BIO_R_UNSUPPORTED_METHOD);
265 : 0 : return(-2);
266 : : }
267 : :
268 : 20053 : cb=b->callback;
269 : :
270 [ - + # # ]: 20053 : if ((cb != NULL) &&
271 : 0 : ((i=(int)cb(b,BIO_CB_PUTS,in,0,0L,1L)) <= 0))
272 : : return(i);
273 : :
274 [ - + ]: 20053 : if (!b->init)
275 : : {
276 : 0 : BIOerr(BIO_F_BIO_PUTS,BIO_R_UNINITIALIZED);
277 : 0 : return(-2);
278 : : }
279 : :
280 : 20053 : i=b->method->bputs(b,in);
281 : :
282 [ + - ]: 20053 : if (i > 0) b->num_write+=(unsigned long)i;
283 : :
284 [ - + ]: 20053 : if (cb != NULL)
285 : 0 : i=(int)cb(b,BIO_CB_PUTS|BIO_CB_RETURN,in,0,
286 : : 0L,(long)i);
287 : 20053 : return(i);
288 : : }
289 : :
290 : 332173 : int BIO_gets(BIO *b, char *in, int inl)
291 : : {
292 : : int i;
293 : : long (*cb)(BIO *,int,const char *,int,long,long);
294 : :
295 [ + - ][ + - ]: 332173 : if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL))
[ - + ]
296 : : {
297 : 0 : BIOerr(BIO_F_BIO_GETS,BIO_R_UNSUPPORTED_METHOD);
298 : 0 : return(-2);
299 : : }
300 : :
301 : 332173 : cb=b->callback;
302 : :
303 [ - + # # ]: 332173 : if ((cb != NULL) &&
304 : 0 : ((i=(int)cb(b,BIO_CB_GETS,in,inl,0L,1L)) <= 0))
305 : : return(i);
306 : :
307 [ - + ]: 332173 : if (!b->init)
308 : : {
309 : 0 : BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITIALIZED);
310 : 0 : return(-2);
311 : : }
312 : :
313 : 332173 : i=b->method->bgets(b,in,inl);
314 : :
315 [ - + ]: 332173 : if (cb != NULL)
316 : 0 : i=(int)cb(b,BIO_CB_GETS|BIO_CB_RETURN,in,inl,
317 : : 0L,(long)i);
318 : 332173 : return(i);
319 : : }
320 : :
321 : 822 : int BIO_indent(BIO *b,int indent,int max)
322 : : {
323 [ - + ]: 822 : if(indent < 0)
324 : 0 : indent=0;
325 [ - + ]: 822 : if(indent > max)
326 : 0 : indent=max;
327 [ + + ]: 12802 : while(indent--)
328 [ + - ]: 12802 : if(BIO_puts(b," ") != 1)
329 : : return 0;
330 : : return 1;
331 : : }
332 : :
333 : 2160 : long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
334 : : {
335 : : int i;
336 : :
337 : 2160 : i=iarg;
338 : 2160 : return(BIO_ctrl(b,cmd,larg,(char *)&i));
339 : : }
340 : :
341 : 0 : char *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
342 : : {
343 : 0 : char *p=NULL;
344 : :
345 [ # # ]: 0 : if (BIO_ctrl(b,cmd,larg,(char *)&p) <= 0)
346 : : return(NULL);
347 : : else
348 : 0 : return(p);
349 : : }
350 : :
351 : 260902 : long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
352 : : {
353 : : long ret;
354 : : long (*cb)(BIO *,int,const char *,int,long,long);
355 : :
356 [ + - ]: 260902 : if (b == NULL) return(0);
357 : :
358 [ + - ][ - + ]: 260902 : if ((b->method == NULL) || (b->method->ctrl == NULL))
359 : : {
360 : 0 : BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD);
361 : 0 : return(-2);
362 : : }
363 : :
364 : 260902 : cb=b->callback;
365 : :
366 [ - + ][ # # ]: 260902 : if ((cb != NULL) &&
367 : : ((ret=cb(b,BIO_CB_CTRL,parg,cmd,larg,1L)) <= 0))
368 : : return(ret);
369 : :
370 : 260902 : ret=b->method->ctrl(b,cmd,larg,parg);
371 : :
372 [ - + ]: 260902 : if (cb != NULL)
373 : 0 : ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,parg,cmd,
374 : : larg,ret);
375 : 260902 : return(ret);
376 : : }
377 : :
378 : 0 : long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long))
379 : : {
380 : : long ret;
381 : : long (*cb)(BIO *,int,const char *,int,long,long);
382 : :
383 [ # # ]: 0 : if (b == NULL) return(0);
384 : :
385 [ # # ][ # # ]: 0 : if ((b->method == NULL) || (b->method->callback_ctrl == NULL))
386 : : {
387 : 0 : BIOerr(BIO_F_BIO_CALLBACK_CTRL,BIO_R_UNSUPPORTED_METHOD);
388 : 0 : return(-2);
389 : : }
390 : :
391 : 0 : cb=b->callback;
392 : :
393 [ # # ][ # # ]: 0 : if ((cb != NULL) &&
394 : : ((ret=cb(b,BIO_CB_CTRL,(void *)&fp,cmd,0,1L)) <= 0))
395 : : return(ret);
396 : :
397 : 0 : ret=b->method->callback_ctrl(b,cmd,fp);
398 : :
399 [ # # ]: 0 : if (cb != NULL)
400 : 0 : ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp,cmd,
401 : : 0,ret);
402 : 0 : return(ret);
403 : : }
404 : :
405 : : /* It is unfortunate to duplicate in functions what the BIO_(w)pending macros
406 : : * do; but those macros have inappropriate return type, and for interfacing
407 : : * from other programming languages, C macros aren't much of a help anyway. */
408 : 56417 : size_t BIO_ctrl_pending(BIO *bio)
409 : : {
410 : 56417 : return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
411 : : }
412 : :
413 : 0 : size_t BIO_ctrl_wpending(BIO *bio)
414 : : {
415 : 0 : return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
416 : : }
417 : :
418 : :
419 : : /* put the 'bio' on the end of b's list of operators */
420 : 2882 : BIO *BIO_push(BIO *b, BIO *bio)
421 : : {
422 : : BIO *lb;
423 : :
424 [ + - ]: 2882 : if (b == NULL) return(bio);
425 : : lb=b;
426 [ - + ]: 2882 : while (lb->next_bio != NULL)
427 : : lb=lb->next_bio;
428 : 2882 : lb->next_bio=bio;
429 [ + - ]: 2882 : if (bio != NULL)
430 : 2882 : bio->prev_bio=lb;
431 : : /* called to do internal processing */
432 : 2882 : BIO_ctrl(b,BIO_CTRL_PUSH,0,lb);
433 : 2882 : return(b);
434 : : }
435 : :
436 : : /* Remove the first and return the rest */
437 : 2397 : BIO *BIO_pop(BIO *b)
438 : : {
439 : : BIO *ret;
440 : :
441 [ + - ]: 2397 : if (b == NULL) return(NULL);
442 : 2397 : ret=b->next_bio;
443 : :
444 : 2397 : BIO_ctrl(b,BIO_CTRL_POP,0,b);
445 : :
446 [ - + ]: 2397 : if (b->prev_bio != NULL)
447 : 0 : b->prev_bio->next_bio=b->next_bio;
448 [ + - ]: 2397 : if (b->next_bio != NULL)
449 : 2397 : b->next_bio->prev_bio=b->prev_bio;
450 : :
451 : 2397 : b->next_bio=NULL;
452 : 2397 : b->prev_bio=NULL;
453 : 2397 : return(ret);
454 : : }
455 : :
456 : 0 : BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
457 : : {
458 : : BIO *b,*last;
459 : :
460 : 0 : b=last=bio;
461 : : for (;;)
462 : : {
463 [ # # ]: 0 : if (!BIO_should_retry(b)) break;
464 : 0 : last=b;
465 : 0 : b=b->next_bio;
466 [ # # ]: 0 : if (b == NULL) break;
467 : : }
468 [ # # ]: 0 : if (reason != NULL) *reason=last->retry_reason;
469 : 0 : return(last);
470 : : }
471 : :
472 : 0 : int BIO_get_retry_reason(BIO *bio)
473 : : {
474 : 0 : return(bio->retry_reason);
475 : : }
476 : :
477 : 189 : BIO *BIO_find_type(BIO *bio, int type)
478 : : {
479 : : int mt,mask;
480 : :
481 [ + - ]: 189 : if(!bio) return NULL;
482 : 189 : mask=type&0xff;
483 : : do {
484 [ + - ]: 202 : if (bio->method != NULL)
485 : : {
486 : 202 : mt=bio->method->type;
487 : :
488 [ - + ]: 202 : if (!mask)
489 : : {
490 [ # # ]: 0 : if (mt & type) return(bio);
491 : : }
492 [ + + ]: 202 : else if (mt == type)
493 : : return(bio);
494 : : }
495 : 13 : bio=bio->next_bio;
496 [ + - ]: 13 : } while (bio != NULL);
497 : : return(NULL);
498 : : }
499 : :
500 : 0 : BIO *BIO_next(BIO *b)
501 : : {
502 [ # # ]: 0 : if(!b) return NULL;
503 : 0 : return b->next_bio;
504 : : }
505 : :
506 : 3464 : void BIO_free_all(BIO *bio)
507 : : {
508 : : BIO *b;
509 : : int ref;
510 : :
511 [ + + ]: 7753 : while (bio != NULL)
512 : : {
513 : 4289 : b=bio;
514 : 4289 : ref=b->references;
515 : 4289 : bio=bio->next_bio;
516 : 4289 : BIO_free(b);
517 : : /* Since ref count > 1, don't free anyone else. */
518 [ + - ]: 4289 : if (ref > 1) break;
519 : : }
520 : 3464 : }
521 : :
522 : 0 : BIO *BIO_dup_chain(BIO *in)
523 : : {
524 : 0 : BIO *ret=NULL,*eoc=NULL,*bio,*new_bio;
525 : :
526 [ # # ]: 0 : for (bio=in; bio != NULL; bio=bio->next_bio)
527 : : {
528 [ # # ]: 0 : if ((new_bio=BIO_new(bio->method)) == NULL) goto err;
529 : 0 : new_bio->callback=bio->callback;
530 : 0 : new_bio->cb_arg=bio->cb_arg;
531 : 0 : new_bio->init=bio->init;
532 : 0 : new_bio->shutdown=bio->shutdown;
533 : 0 : new_bio->flags=bio->flags;
534 : :
535 : : /* This will let SSL_s_sock() work with stdin/stdout */
536 : 0 : new_bio->num=bio->num;
537 : :
538 [ # # ]: 0 : if (!BIO_dup_state(bio,(char *)new_bio))
539 : : {
540 : 0 : BIO_free(new_bio);
541 : 0 : goto err;
542 : : }
543 : :
544 : : /* copy app data */
545 [ # # ]: 0 : if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
546 : : &bio->ex_data))
547 : : goto err;
548 : :
549 [ # # ]: 0 : if (ret == NULL)
550 : : {
551 : : eoc=new_bio;
552 : : ret=eoc;
553 : : }
554 : : else
555 : : {
556 : 0 : BIO_push(eoc,new_bio);
557 : 0 : eoc=new_bio;
558 : : }
559 : : }
560 : : return(ret);
561 : : err:
562 [ # # ]: 0 : if (ret != NULL)
563 : 0 : BIO_free(ret);
564 : : return(NULL);
565 : : }
566 : :
567 : 19258 : void BIO_copy_next_retry(BIO *b)
568 : : {
569 : 19258 : BIO_set_flags(b,BIO_get_retry_flags(b->next_bio));
570 : 19258 : b->retry_reason=b->next_bio->retry_reason;
571 : 19258 : }
572 : :
573 : 0 : int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
574 : : CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
575 : : {
576 : 0 : return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp,
577 : : new_func, dup_func, free_func);
578 : : }
579 : :
580 : 0 : int BIO_set_ex_data(BIO *bio, int idx, void *data)
581 : : {
582 : 0 : return(CRYPTO_set_ex_data(&(bio->ex_data),idx,data));
583 : : }
584 : :
585 : 0 : void *BIO_get_ex_data(BIO *bio, int idx)
586 : : {
587 : 0 : return(CRYPTO_get_ex_data(&(bio->ex_data),idx));
588 : : }
589 : :
590 : 0 : unsigned long BIO_number_read(BIO *bio)
591 : : {
592 [ # # ]: 0 : if(bio) return bio->num_read;
593 : : return 0;
594 : : }
595 : :
596 : 0 : unsigned long BIO_number_written(BIO *bio)
597 : : {
598 [ # # ]: 0 : if(bio) return bio->num_write;
599 : : return 0;
600 : : }
601 : :
602 : : IMPLEMENT_STACK_OF(BIO)
|
