1 /* crypto/err/err.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 "lhash.h" 61 #include "crypto.h" 62 #include "cryptlib.h" 63 #include "buffer.h" 64 #include "err.h" 65 #include "crypto.h" 66 67 68 static LHASH *error_hash=NULL; 69 static LHASH *thread_hash=NULL; 70 71 #ifndef NOPROTO 72 static unsigned long err_hash(ERR_STRING_DATA *a); 73 static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b); 74 static unsigned long pid_hash(ERR_STATE *pid); 75 static int pid_cmp(ERR_STATE *a,ERR_STATE *pid); 76 static unsigned long get_error_values(int inc,char **file,int *line, 77 char **data,int *flags); 78 static void ERR_STATE_free(ERR_STATE *s); 79 #else 80 static unsigned long err_hash(); 81 static int err_cmp(); 82 static unsigned long pid_hash(); 83 static int pid_cmp(); 84 static void ERR_STATE_free(); 85 ERR_STATE *s; 86 #endif 87 88 #ifndef NO_ERR 89 static ERR_STRING_DATA ERR_str_libraries[]= 90 { 91 {ERR_PACK(ERR_LIB_NONE,0,0) ,"unknown library"}, 92 {ERR_PACK(ERR_LIB_SYS,0,0) ,"system library"}, 93 {ERR_PACK(ERR_LIB_BN,0,0) ,"bignum routines"}, 94 {ERR_PACK(ERR_LIB_RSA,0,0) ,"rsa routines"}, 95 {ERR_PACK(ERR_LIB_DH,0,0) ,"Diffie-Hellman routines"}, 96 {ERR_PACK(ERR_LIB_EVP,0,0) ,"digital envelope routines"}, 97 {ERR_PACK(ERR_LIB_BUF,0,0) ,"memory buffer routines"}, 98 {ERR_PACK(ERR_LIB_BIO,0,0) ,"BIO routines"}, 99 {ERR_PACK(ERR_LIB_OBJ,0,0) ,"object identifier routines"}, 100 {ERR_PACK(ERR_LIB_PEM,0,0) ,"PEM routines"}, 101 {ERR_PACK(ERR_LIB_ASN1,0,0) ,"asn1 encoding routines"}, 102 {ERR_PACK(ERR_LIB_X509,0,0) ,"x509 certificate routines"}, 103 {ERR_PACK(ERR_LIB_CONF,0,0) ,"configuation file routines"}, 104 {ERR_PACK(ERR_LIB_METH,0,0) ,"X509 lookup 'method' routines"}, 105 {ERR_PACK(ERR_LIB_SSL,0,0) ,"SSL routines"}, 106 {ERR_PACK(ERR_LIB_RSAREF,0,0) ,"RSAref routines"}, 107 {ERR_PACK(ERR_LIB_PROXY,0,0) ,"Proxy routines"}, 108 {ERR_PACK(ERR_LIB_BIO,0,0) ,"BIO routines"}, 109 {ERR_PACK(ERR_LIB_PKCS7,0,0) ,"PKCS7 routines"}, 110 {0,NULL}, 111 }; 112 113 static ERR_STRING_DATA ERR_str_functs[]= 114 { 115 {ERR_PACK(0,SYS_F_FOPEN,0), "fopen"}, 116 {ERR_PACK(0,SYS_F_CONNECT,0), "connect"}, 117 {ERR_PACK(0,SYS_F_GETSERVBYNAME,0), "getservbyname"}, 118 {ERR_PACK(0,SYS_F_SOCKET,0), "socket"}, 119 {ERR_PACK(0,SYS_F_IOCTLSOCKET,0), "ioctlsocket"}, 120 {ERR_PACK(0,SYS_F_BIND,0), "bind"}, 121 {ERR_PACK(0,SYS_F_LISTEN,0), "listen"}, 122 {ERR_PACK(0,SYS_F_ACCEPT,0), "accept"}, 123 #ifdef WINDOWS 124 {ERR_PACK(0,SYS_F_WSASTARTUP,0), "WSAstartup"}, 125 #endif 126 {0,NULL}, 127 }; 128 129 static ERR_STRING_DATA ERR_str_reasons[]= 130 { 131 {ERR_R_FATAL ,"fatal"}, 132 {ERR_R_SYS_LIB ,"system lib"}, 133 {ERR_R_BN_LIB ,"BN lib"}, 134 {ERR_R_RSA_LIB ,"RSA lib"}, 135 {ERR_R_DH_LIB ,"DH lib"}, 136 {ERR_R_EVP_LIB ,"EVP lib"}, 137 {ERR_R_BUF_LIB ,"BUF lib"}, 138 {ERR_R_BIO_LIB ,"BIO lib"}, 139 {ERR_R_OBJ_LIB ,"OBJ lib"}, 140 {ERR_R_PEM_LIB ,"PEM lib"}, 141 {ERR_R_X509_LIB ,"X509 lib"}, 142 {ERR_R_METH_LIB ,"METH lib"}, 143 {ERR_R_ASN1_LIB ,"ASN1 lib"}, 144 {ERR_R_CONF_LIB ,"CONF lib"}, 145 {ERR_R_SSL_LIB ,"SSL lib"}, 146 {ERR_R_PROXY_LIB ,"PROXY lib"}, 147 {ERR_R_BIO_LIB ,"BIO lib"}, 148 {ERR_R_PKCS7_LIB ,"PKCS7 lib"}, 149 {ERR_R_MALLOC_FAILURE ,"Malloc failure"}, 150 {ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED ,"called a fuction you should not call"}, 151 {0,NULL}, 152 }; 153 #endif 154 155 #define err_clear_data(p,i) \ 156 if (((p)->err_data[i] != NULL) && \ 157 (p)->err_data_flags[i] & ERR_TXT_MALLOCED) \ 158 { \ 159 Free((p)->err_data[i]); \ 160 (p)->err_data[i]=NULL; \ 161 } \ 162 (p)->err_data_flags[i]=0; 163 164 static void ERR_STATE_free(s) 165 ERR_STATE *s; 166 { 167 int i; 168 169 for (i=0; i<ERR_NUM_ERRORS; i++) 170 { 171 err_clear_data(s,i); 172 } 173 Free(s); 174 } 175 176 void ERR_load_ERR_strings() 177 { 178 static int init=1; 179 180 if (init) 181 { 182 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 183 if (init == 0) 184 { 185 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 186 return; 187 } 188 init=0; 189 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 190 191 #ifndef NO_ERR 192 ERR_load_strings(0,ERR_str_libraries); 193 ERR_load_strings(0,ERR_str_reasons); 194 ERR_load_strings(ERR_LIB_SYS,ERR_str_functs); 195 #endif 196 } 197 } 198 199 void ERR_load_strings(lib,str) 200 int lib; 201 ERR_STRING_DATA *str; 202 { 203 if (error_hash == NULL) 204 { 205 CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH); 206 error_hash=lh_new(err_hash,err_cmp); 207 if (error_hash == NULL) 208 { 209 CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH); 210 return; 211 } 212 CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH); 213 214 ERR_load_ERR_strings(); 215 } 216 217 CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH); 218 while (str->error) 219 { 220 str->error|=ERR_PACK(lib,0,0); 221 lh_insert(error_hash,(char *)str); 222 str++; 223 } 224 CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH); 225 } 226 227 void ERR_free_strings() 228 { 229 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 230 231 if (error_hash != NULL) 232 { 233 lh_free(error_hash); 234 error_hash=NULL; 235 } 236 237 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 238 } 239 240 /********************************************************/ 241 242 void ERR_put_error(lib,func,reason,file,line) 243 int lib,func,reason; 244 char *file; 245 int line; 246 { 247 ERR_STATE *es; 248 249 es=ERR_get_state(); 250 251 es->top=(es->top+1)%ERR_NUM_ERRORS; 252 if (es->top == es->bottom) 253 es->bottom=(es->bottom+1)%ERR_NUM_ERRORS; 254 es->err_buffer[es->top]=ERR_PACK(lib,func,reason); 255 es->err_file[es->top]=file; 256 es->err_line[es->top]=line; 257 err_clear_data(es,es->top); 258 } 259 260 void ERR_clear_error() 261 { 262 ERR_STATE *es; 263 264 es=ERR_get_state(); 265 266 #if 0 267 /* hmm... is this needed */ 268 for (i=0; i<ERR_NUM_ERRORS; i++) 269 { 270 es->err_buffer[i]=0; 271 es->err_file[i]=NULL; 272 es->err_line[i]= -1; 273 err_clear_data(es,i); 274 } 275 #endif 276 es->top=es->bottom=0; 277 } 278 279 280 unsigned long ERR_get_error() 281 { return(get_error_values(1,NULL,NULL,NULL,NULL)); } 282 283 unsigned long ERR_get_error_line(file,line) 284 char **file; 285 int *line; 286 { return(get_error_values(1,file,line,NULL,NULL)); } 287 288 unsigned long ERR_get_error_line_data(file,line,data,flags) 289 char **file; 290 int *line; 291 char **data; 292 int *flags; 293 { return(get_error_values(1,file,line,data,flags)); } 294 295 unsigned long ERR_peek_error() 296 { return(get_error_values(0,NULL,NULL,NULL,NULL)); } 297 298 unsigned long ERR_peek_error_line(file,line) 299 char **file; 300 int *line; 301 { return(get_error_values(0,file,line,NULL,NULL)); } 302 303 unsigned long ERR_peek_error_line_data(file,line,data,flags) 304 char **file; 305 int *line; 306 char **data; 307 int *flags; 308 { return(get_error_values(0,file,line,data,flags)); } 309 310 static unsigned long get_error_values(inc,file,line,data,flags) 311 int inc; 312 char **file; 313 int *line; 314 char **data; 315 int *flags; 316 { 317 int i=0; 318 ERR_STATE *es; 319 unsigned long ret; 320 321 es=ERR_get_state(); 322 323 if (es->bottom == es->top) return(0); 324 i=(es->bottom+1)%ERR_NUM_ERRORS; 325 326 ret=es->err_buffer[i]; 327 if (inc) 328 { 329 es->bottom=i; 330 es->err_buffer[i]=0; 331 } 332 333 if ((file != NULL) && (line != NULL)) 334 { 335 if (es->err_file[i] == NULL) 336 { 337 *file="NA"; 338 if (line != NULL) *line=0; 339 } 340 else 341 { 342 *file=es->err_file[i]; 343 if (line != NULL) *line=es->err_line[i]; 344 } 345 } 346 347 if (data != NULL) 348 { 349 if (es->err_data[i] == NULL) 350 { 351 *data=""; 352 if (flags != NULL) *flags=0; 353 } 354 else 355 { 356 *data=es->err_data[i]; 357 if (flags != NULL) *flags=es->err_data_flags[i]; 358 } 359 } 360 return(ret); 361 } 362 363 /* BAD for multi-threaded, uses a local buffer if ret == NULL */ 364 char *ERR_error_string(e,ret) 365 unsigned long e; 366 char *ret; 367 { 368 static char buf[256]; 369 char *ls,*fs,*rs; 370 unsigned long l,f,r; 371 int i; 372 373 l=ERR_GET_LIB(e); 374 f=ERR_GET_FUNC(e); 375 r=ERR_GET_REASON(e); 376 377 ls=ERR_lib_error_string(e); 378 fs=ERR_func_error_string(e); 379 rs=ERR_reason_error_string(e); 380 381 if (ret == NULL) ret=buf; 382 383 sprintf(&(ret[0]),"error:%08lX:",e); 384 i=strlen(ret); 385 if (ls == NULL) 386 sprintf(&(ret[i]),":lib(%lu) ",l); 387 else sprintf(&(ret[i]),"%s",ls); 388 i=strlen(ret); 389 if (fs == NULL) 390 sprintf(&(ret[i]),":func(%lu) ",f); 391 else sprintf(&(ret[i]),":%s",fs); 392 i=strlen(ret); 393 if (rs == NULL) 394 sprintf(&(ret[i]),":reason(%lu)",r); 395 else sprintf(&(ret[i]),":%s",rs); 396 397 return(ret); 398 } 399 400 LHASH *ERR_get_string_table() 401 { 402 return(error_hash); 403 } 404 405 LHASH *ERR_get_err_state_table() 406 { 407 return(thread_hash); 408 } 409 410 char *ERR_lib_error_string(e) 411 unsigned long e; 412 { 413 ERR_STRING_DATA d,*p=NULL; 414 unsigned long l; 415 416 l=ERR_GET_LIB(e); 417 418 CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH); 419 420 if (error_hash != NULL) 421 { 422 d.error=ERR_PACK(l,0,0); 423 p=(ERR_STRING_DATA *)lh_retrieve(error_hash,(char *)&d); 424 } 425 426 CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH); 427 428 return((p == NULL)?NULL:p->string); 429 } 430 431 char *ERR_func_error_string(e) 432 unsigned long e; 433 { 434 ERR_STRING_DATA d,*p=NULL; 435 unsigned long l,f; 436 437 l=ERR_GET_LIB(e); 438 f=ERR_GET_FUNC(e); 439 440 CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH); 441 442 if (error_hash != NULL) 443 { 444 d.error=ERR_PACK(l,f,0); 445 p=(ERR_STRING_DATA *)lh_retrieve(error_hash,(char *)&d); 446 } 447 448 CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH); 449 450 return((p == NULL)?NULL:p->string); 451 } 452 453 char *ERR_reason_error_string(e) 454 unsigned long e; 455 { 456 ERR_STRING_DATA d,*p=NULL; 457 unsigned long l,r; 458 459 l=ERR_GET_LIB(e); 460 r=ERR_GET_REASON(e); 461 462 CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH); 463 464 if (error_hash != NULL) 465 { 466 d.error=ERR_PACK(l,0,r); 467 p=(ERR_STRING_DATA *)lh_retrieve(error_hash,(char *)&d); 468 if (p == NULL) 469 { 470 d.error=ERR_PACK(0,0,r); 471 p=(ERR_STRING_DATA *)lh_retrieve(error_hash, 472 (char *)&d); 473 } 474 } 475 476 CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH); 477 478 return((p == NULL)?NULL:p->string); 479 } 480 481 static unsigned long err_hash(a) 482 ERR_STRING_DATA *a; 483 { 484 unsigned long ret,l; 485 486 l=a->error; 487 ret=l^ERR_GET_LIB(l)^ERR_GET_FUNC(l); 488 return(ret^ret%19*13); 489 } 490 491 static int err_cmp(a,b) 492 ERR_STRING_DATA *a,*b; 493 { 494 return((int)(a->error-b->error)); 495 } 496 497 static unsigned long pid_hash(a) 498 ERR_STATE *a; 499 { 500 return(a->pid*13); 501 } 502 503 static int pid_cmp(a,b) 504 ERR_STATE *a,*b; 505 { 506 return((int)((long)a->pid - (long)b->pid)); 507 } 508 509 void ERR_remove_state(pid) 510 unsigned long pid; 511 { 512 ERR_STATE *p,tmp; 513 514 if (thread_hash == NULL) 515 return; 516 if (pid == 0) 517 pid=(unsigned long)CRYPTO_thread_id(); 518 tmp.pid=pid; 519 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 520 p=(ERR_STATE *)lh_delete(thread_hash,(char *)&tmp); 521 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 522 523 if (p != NULL) ERR_STATE_free(p); 524 } 525 526 ERR_STATE *ERR_get_state() 527 { 528 static ERR_STATE fallback; 529 ERR_STATE *ret=NULL,tmp,*tmpp; 530 int i; 531 unsigned long pid; 532 533 pid=(unsigned long)CRYPTO_thread_id(); 534 535 CRYPTO_r_lock(CRYPTO_LOCK_ERR); 536 if (thread_hash == NULL) 537 { 538 CRYPTO_r_unlock(CRYPTO_LOCK_ERR); 539 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 540 if (thread_hash == NULL) 541 { 542 thread_hash=lh_new(pid_hash,pid_cmp); 543 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 544 if (thread_hash == NULL) return(&fallback); 545 } 546 else 547 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 548 } 549 else 550 { 551 tmp.pid=pid; 552 ret=(ERR_STATE *)lh_retrieve(thread_hash,(char *)&tmp); 553 CRYPTO_r_unlock(CRYPTO_LOCK_ERR); 554 } 555 556 /* ret == the error state, if NULL, make a new one */ 557 if (ret == NULL) 558 { 559 ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE)); 560 if (ret == NULL) return(&fallback); 561 ret->pid=pid; 562 ret->top=0; 563 ret->bottom=0; 564 for (i=0; i<ERR_NUM_ERRORS; i++) 565 { 566 ret->err_data[i]=NULL; 567 ret->err_data_flags[i]=0; 568 } 569 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 570 tmpp=(ERR_STATE *)lh_insert(thread_hash,(char *)ret); 571 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 572 if (tmpp != NULL) /* old entry - should not happen */ 573 { 574 ERR_STATE_free(tmpp); 575 } 576 } 577 return(ret); 578 } 579 580 int ERR_get_next_error_library() 581 { 582 static int value=ERR_LIB_USER; 583 584 return(value++); 585 } 586 587 void ERR_set_error_data(data,flags) 588 char *data; 589 int flags; 590 { 591 ERR_STATE *es; 592 int i; 593 594 es=ERR_get_state(); 595 596 i=es->top; 597 if (i == 0) 598 i=ERR_NUM_ERRORS-1; 599 600 es->err_data[i]=data; 601 es->err_data_flags[es->top]=flags; 602 } 603 604 void ERR_add_error_data( VAR_PLIST(int , num)) 605 VAR_ALIST 606 { 607 VAR_BDEFN(args, int, num); 608 int i,n,s; 609 char *str,*p,*a; 610 611 s=64; 612 str=Malloc(s+1); 613 if (str == NULL) return; 614 str[0]='\0'; 615 616 VAR_INIT(args,int,num); 617 n=0; 618 for (i=0; i<num; i++) 619 { 620 VAR_ARG(args,char *,a); 621 if (a != NULL) { 622 n+=strlen(a); 623 if (n > s) 624 { 625 s=n+20; 626 p=Realloc(str,s+1); 627 if (p == NULL) 628 { 629 Free(str); 630 return; 631 } 632 else 633 str=p; 634 } 635 strcat(str,a); 636 } 637 } 638 ERR_set_error_data(str,ERR_TXT_MALLOCED|ERR_TXT_STRING); 639 640 VAR_END( args ); 641 } 642 643