1 /* crypto/bio/bio_lib.c */ 2 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com) 3 * All rights reserved. 4 * 5 * This package is an SSL implementation written 6 * by Eric Young (eay (at) 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 (at) 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 (at) 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 (at) 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 BIO *BIO_new(BIO_METHOD *method) 67 { 68 BIO *ret=NULL; 69 70 ret=(BIO *)OPENSSL_malloc(sizeof(BIO)); 71 if (ret == NULL) 72 { 73 BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE); 74 return(NULL); 75 } 76 if (!BIO_set(ret,method)) 77 { 78 OPENSSL_free(ret); 79 ret=NULL; 80 } 81 return(ret); 82 } 83 84 int BIO_set(BIO *bio, BIO_METHOD *method) 85 { 86 bio->method=method; 87 bio->callback=NULL; 88 bio->cb_arg=NULL; 89 bio->init=0; 90 bio->shutdown=1; 91 bio->flags=0; 92 bio->retry_reason=0; 93 bio->num=0; 94 bio->ptr=NULL; 95 bio->prev_bio=NULL; 96 bio->next_bio=NULL; 97 bio->references=1; 98 bio->num_read=0L; 99 bio->num_write=0L; 100 CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data); 101 if (method->create != NULL) 102 if (!method->create(bio)) 103 { 104 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, 105 &bio->ex_data); 106 return(0); 107 } 108 return(1); 109 } 110 111 int BIO_free(BIO *a) 112 { 113 int i; 114 115 if (a == NULL) return(0); 116 117 i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_BIO); 118 #ifdef REF_PRINT 119 REF_PRINT("BIO",a); 120 #endif 121 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 if ((a->callback != NULL) && 130 ((i=(int)a->callback(a,BIO_CB_FREE,NULL,0,0L,1L)) <= 0)) 131 return(i); 132 133 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data); 134 135 if ((a->method == NULL) || (a->method->destroy == NULL)) return(1); 136 a->method->destroy(a); 137 OPENSSL_free(a); 138 return(1); 139 } 140 141 void BIO_vfree(BIO *a) 142 { BIO_free(a); } 143 144 void BIO_clear_flags(BIO *b, int flags) 145 { 146 b->flags &= ~flags; 147 } 148 149 int BIO_test_flags(const BIO *b, int flags) 150 { 151 return (b->flags & flags); 152 } 153 154 void BIO_set_flags(BIO *b, int flags) 155 { 156 b->flags |= flags; 157 } 158 159 long (*BIO_get_callback(const BIO *b))(struct bio_st *,int,const char *,int, long,long) 160 { 161 return b->callback; 162 } 163 164 void BIO_set_callback(BIO *b, long (*cb)(struct bio_st *,int,const char *,int, long,long)) 165 { 166 b->callback = cb; 167 } 168 169 void BIO_set_callback_arg(BIO *b, char *arg) 170 { 171 b->cb_arg = arg; 172 } 173 174 char * BIO_get_callback_arg(const BIO *b) 175 { 176 return b->cb_arg; 177 } 178 179 const char * BIO_method_name(const BIO *b) 180 { 181 return b->method->name; 182 } 183 184 int BIO_method_type(const BIO *b) 185 { 186 return b->method->type; 187 } 188 189 190 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 if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) 196 { 197 BIOerr(BIO_F_BIO_READ,BIO_R_UNSUPPORTED_METHOD); 198 return(-2); 199 } 200 201 cb=b->callback; 202 if ((cb != NULL) && 203 ((i=(int)cb(b,BIO_CB_READ,out,outl,0L,1L)) <= 0)) 204 return(i); 205 206 if (!b->init) 207 { 208 BIOerr(BIO_F_BIO_READ,BIO_R_UNINITIALIZED); 209 return(-2); 210 } 211 212 i=b->method->bread(b,out,outl); 213 214 if (i > 0) b->num_read+=(unsigned long)i; 215 216 if (cb != NULL) 217 i=(int)cb(b,BIO_CB_READ|BIO_CB_RETURN,out,outl, 218 0L,(long)i); 219 return(i); 220 } 221 222 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 if (b == NULL) 228 return(0); 229 230 cb=b->callback; 231 if ((b->method == NULL) || (b->method->bwrite == NULL)) 232 { 233 BIOerr(BIO_F_BIO_WRITE,BIO_R_UNSUPPORTED_METHOD); 234 return(-2); 235 } 236 237 if ((cb != NULL) && 238 ((i=(int)cb(b,BIO_CB_WRITE,in,inl,0L,1L)) <= 0)) 239 return(i); 240 241 if (!b->init) 242 { 243 BIOerr(BIO_F_BIO_WRITE,BIO_R_UNINITIALIZED); 244 return(-2); 245 } 246 247 i=b->method->bwrite(b,in,inl); 248 249 if (i > 0) b->num_write+=(unsigned long)i; 250 251 if (cb != NULL) 252 i=(int)cb(b,BIO_CB_WRITE|BIO_CB_RETURN,in,inl, 253 0L,(long)i); 254 return(i); 255 } 256 257 int BIO_puts(BIO *b, const char *in) 258 { 259 int i; 260 long (*cb)(BIO *,int,const char *,int,long,long); 261 262 if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) 263 { 264 BIOerr(BIO_F_BIO_PUTS,BIO_R_UNSUPPORTED_METHOD); 265 return(-2); 266 } 267 268 cb=b->callback; 269 270 if ((cb != NULL) && 271 ((i=(int)cb(b,BIO_CB_PUTS,in,0,0L,1L)) <= 0)) 272 return(i); 273 274 if (!b->init) 275 { 276 BIOerr(BIO_F_BIO_PUTS,BIO_R_UNINITIALIZED); 277 return(-2); 278 } 279 280 i=b->method->bputs(b,in); 281 282 if (i > 0) b->num_write+=(unsigned long)i; 283 284 if (cb != NULL) 285 i=(int)cb(b,BIO_CB_PUTS|BIO_CB_RETURN,in,0, 286 0L,(long)i); 287 return(i); 288 } 289 290 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 if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) 296 { 297 BIOerr(BIO_F_BIO_GETS,BIO_R_UNSUPPORTED_METHOD); 298 return(-2); 299 } 300 301 cb=b->callback; 302 303 if ((cb != NULL) && 304 ((i=(int)cb(b,BIO_CB_GETS,in,inl,0L,1L)) <= 0)) 305 return(i); 306 307 if (!b->init) 308 { 309 BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITIALIZED); 310 return(-2); 311 } 312 313 i=b->method->bgets(b,in,inl); 314 315 if (cb != NULL) 316 i=(int)cb(b,BIO_CB_GETS|BIO_CB_RETURN,in,inl, 317 0L,(long)i); 318 return(i); 319 } 320 321 int BIO_indent(BIO *b,int indent,int max) 322 { 323 if(indent < 0) 324 indent=0; 325 if(indent > max) 326 indent=max; 327 while(indent--) 328 if(BIO_puts(b," ") != 1) 329 return 0; 330 return 1; 331 } 332 333 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) 334 { 335 int i; 336 337 i=iarg; 338 return(BIO_ctrl(b,cmd,larg,(char *)&i)); 339 } 340 341 char *BIO_ptr_ctrl(BIO *b, int cmd, long larg) 342 { 343 char *p=NULL; 344 345 if (BIO_ctrl(b,cmd,larg,(char *)&p) <= 0) 346 return(NULL); 347 else 348 return(p); 349 } 350 351 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 if (b == NULL) return(0); 357 358 if ((b->method == NULL) || (b->method->ctrl == NULL)) 359 { 360 BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD); 361 return(-2); 362 } 363 364 cb=b->callback; 365 366 if ((cb != NULL) && 367 ((ret=cb(b,BIO_CB_CTRL,parg,cmd,larg,1L)) <= 0)) 368 return(ret); 369 370 ret=b->method->ctrl(b,cmd,larg,parg); 371 372 if (cb != NULL) 373 ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,parg,cmd, 374 larg,ret); 375 return(ret); 376 } 377 378 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 if (b == NULL) return(0); 384 385 if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) 386 { 387 BIOerr(BIO_F_BIO_CALLBACK_CTRL,BIO_R_UNSUPPORTED_METHOD); 388 return(-2); 389 } 390 391 cb=b->callback; 392 393 if ((cb != NULL) && 394 ((ret=cb(b,BIO_CB_CTRL,(void *)&fp,cmd,0,1L)) <= 0)) 395 return(ret); 396 397 ret=b->method->callback_ctrl(b,cmd,fp); 398 399 if (cb != NULL) 400 ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp,cmd, 401 0,ret); 402 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 size_t BIO_ctrl_pending(BIO *bio) 409 { 410 return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL); 411 } 412 413 size_t BIO_ctrl_wpending(BIO *bio) 414 { 415 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 BIO *BIO_push(BIO *b, BIO *bio) 421 { 422 BIO *lb; 423 424 if (b == NULL) return(bio); 425 lb=b; 426 while (lb->next_bio != NULL) 427 lb=lb->next_bio; 428 lb->next_bio=bio; 429 if (bio != NULL) 430 bio->prev_bio=lb; 431 /* called to do internal processing */ 432 BIO_ctrl(b,BIO_CTRL_PUSH,0,lb); 433 return(b); 434 } 435 436 /* Remove the first and return the rest */ 437 BIO *BIO_pop(BIO *b) 438 { 439 BIO *ret; 440 441 if (b == NULL) return(NULL); 442 ret=b->next_bio; 443 444 BIO_ctrl(b,BIO_CTRL_POP,0,b); 445 446 if (b->prev_bio != NULL) 447 b->prev_bio->next_bio=b->next_bio; 448 if (b->next_bio != NULL) 449 b->next_bio->prev_bio=b->prev_bio; 450 451 b->next_bio=NULL; 452 b->prev_bio=NULL; 453 return(ret); 454 } 455 456 BIO *BIO_get_retry_BIO(BIO *bio, int *reason) 457 { 458 BIO *b,*last; 459 460 b=last=bio; 461 for (;;) 462 { 463 if (!BIO_should_retry(b)) break; 464 last=b; 465 b=b->next_bio; 466 if (b == NULL) break; 467 } 468 if (reason != NULL) *reason=last->retry_reason; 469 return(last); 470 } 471 472 int BIO_get_retry_reason(BIO *bio) 473 { 474 return(bio->retry_reason); 475 } 476 477 BIO *BIO_find_type(BIO *bio, int type) 478 { 479 int mt,mask; 480 481 if(!bio) return NULL; 482 mask=type&0xff; 483 do { 484 if (bio->method != NULL) 485 { 486 mt=bio->method->type; 487 488 if (!mask) 489 { 490 if (mt & type) return(bio); 491 } 492 else if (mt == type) 493 return(bio); 494 } 495 bio=bio->next_bio; 496 } while (bio != NULL); 497 return(NULL); 498 } 499 500 BIO *BIO_next(BIO *b) 501 { 502 if(!b) return NULL; 503 return b->next_bio; 504 } 505 506 void BIO_free_all(BIO *bio) 507 { 508 BIO *b; 509 int ref; 510 511 while (bio != NULL) 512 { 513 b=bio; 514 ref=b->references; 515 bio=bio->next_bio; 516 BIO_free(b); 517 /* Since ref count > 1, don't free anyone else. */ 518 if (ref > 1) break; 519 } 520 } 521 522 BIO *BIO_dup_chain(BIO *in) 523 { 524 BIO *ret=NULL,*eoc=NULL,*bio,*new; 525 526 for (bio=in; bio != NULL; bio=bio->next_bio) 527 { 528 if ((new=BIO_new(bio->method)) == NULL) goto err; 529 new->callback=bio->callback; 530 new->cb_arg=bio->cb_arg; 531 new->init=bio->init; 532 new->shutdown=bio->shutdown; 533 new->flags=bio->flags; 534 535 /* This will let SSL_s_sock() work with stdin/stdout */ 536 new->num=bio->num; 537 538 if (!BIO_dup_state(bio,(char *)new)) 539 { 540 BIO_free(new); 541 goto err; 542 } 543 544 /* copy app data */ 545 if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new->ex_data, 546 &bio->ex_data)) 547 goto err; 548 549 if (ret == NULL) 550 { 551 eoc=new; 552 ret=eoc; 553 } 554 else 555 { 556 BIO_push(eoc,new); 557 eoc=new; 558 } 559 } 560 return(ret); 561 err: 562 if (ret != NULL) 563 BIO_free(ret); 564 return(NULL); 565 } 566 567 void BIO_copy_next_retry(BIO *b) 568 { 569 BIO_set_flags(b,BIO_get_retry_flags(b->next_bio)); 570 b->retry_reason=b->next_bio->retry_reason; 571 } 572 573 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 return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp, 577 new_func, dup_func, free_func); 578 } 579 580 int BIO_set_ex_data(BIO *bio, int idx, void *data) 581 { 582 return(CRYPTO_set_ex_data(&(bio->ex_data),idx,data)); 583 } 584 585 void *BIO_get_ex_data(BIO *bio, int idx) 586 { 587 return(CRYPTO_get_ex_data(&(bio->ex_data),idx)); 588 } 589 590 unsigned long BIO_number_read(BIO *bio) 591 { 592 if(bio) return bio->num_read; 593 return 0; 594 } 595 596 unsigned long BIO_number_written(BIO *bio) 597 { 598 if(bio) return bio->num_write; 599 return 0; 600 } 601 602 IMPLEMENT_STACK_OF(BIO) 603
