err.c revision 312826
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 * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. 60 * 61 * Redistribution and use in source and binary forms, with or without 62 * modification, are permitted provided that the following conditions 63 * are met: 64 * 65 * 1. Redistributions of source code must retain the above copyright 66 * notice, this list of conditions and the following disclaimer. 67 * 68 * 2. Redistributions in binary form must reproduce the above copyright 69 * notice, this list of conditions and the following disclaimer in 70 * the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3. All advertising materials mentioning features or use of this 74 * software must display the following acknowledgment: 75 * "This product includes software developed by the OpenSSL Project 76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" 77 * 78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 79 * endorse or promote products derived from this software without 80 * prior written permission. For written permission, please contact 81 * openssl-core@openssl.org. 82 * 83 * 5. Products derived from this software may not be called "OpenSSL" 84 * nor may "OpenSSL" appear in their names without prior written 85 * permission of the OpenSSL Project. 86 * 87 * 6. Redistributions of any form whatsoever must retain the following 88 * acknowledgment: 89 * "This product includes software developed by the OpenSSL Project 90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" 91 * 92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 103 * OF THE POSSIBILITY OF SUCH DAMAGE. 104 * ==================================================================== 105 * 106 * This product includes cryptographic software written by Eric Young 107 * (eay@cryptsoft.com). This product includes software written by Tim 108 * Hudson (tjh@cryptsoft.com). 109 * 110 */ 111 112#include <stdio.h> 113#include <stdarg.h> 114#include <string.h> 115#include "cryptlib.h" 116#include <openssl/lhash.h> 117#include <openssl/crypto.h> 118#include <openssl/buffer.h> 119#include <openssl/bio.h> 120#include <openssl/err.h> 121 122DECLARE_LHASH_OF(ERR_STRING_DATA); 123DECLARE_LHASH_OF(ERR_STATE); 124 125static void err_load_strings(int lib, ERR_STRING_DATA *str); 126 127static void ERR_STATE_free(ERR_STATE *s); 128#ifndef OPENSSL_NO_ERR 129static ERR_STRING_DATA ERR_str_libraries[] = { 130 {ERR_PACK(ERR_LIB_NONE, 0, 0), "unknown library"}, 131 {ERR_PACK(ERR_LIB_SYS, 0, 0), "system library"}, 132 {ERR_PACK(ERR_LIB_BN, 0, 0), "bignum routines"}, 133 {ERR_PACK(ERR_LIB_RSA, 0, 0), "rsa routines"}, 134 {ERR_PACK(ERR_LIB_DH, 0, 0), "Diffie-Hellman routines"}, 135 {ERR_PACK(ERR_LIB_EVP, 0, 0), "digital envelope routines"}, 136 {ERR_PACK(ERR_LIB_BUF, 0, 0), "memory buffer routines"}, 137 {ERR_PACK(ERR_LIB_OBJ, 0, 0), "object identifier routines"}, 138 {ERR_PACK(ERR_LIB_PEM, 0, 0), "PEM routines"}, 139 {ERR_PACK(ERR_LIB_DSA, 0, 0), "dsa routines"}, 140 {ERR_PACK(ERR_LIB_X509, 0, 0), "x509 certificate routines"}, 141 {ERR_PACK(ERR_LIB_ASN1, 0, 0), "asn1 encoding routines"}, 142 {ERR_PACK(ERR_LIB_CONF, 0, 0), "configuration file routines"}, 143 {ERR_PACK(ERR_LIB_CRYPTO, 0, 0), "common libcrypto routines"}, 144 {ERR_PACK(ERR_LIB_EC, 0, 0), "elliptic curve routines"}, 145 {ERR_PACK(ERR_LIB_SSL, 0, 0), "SSL routines"}, 146 {ERR_PACK(ERR_LIB_BIO, 0, 0), "BIO routines"}, 147 {ERR_PACK(ERR_LIB_PKCS7, 0, 0), "PKCS7 routines"}, 148 {ERR_PACK(ERR_LIB_X509V3, 0, 0), "X509 V3 routines"}, 149 {ERR_PACK(ERR_LIB_PKCS12, 0, 0), "PKCS12 routines"}, 150 {ERR_PACK(ERR_LIB_RAND, 0, 0), "random number generator"}, 151 {ERR_PACK(ERR_LIB_DSO, 0, 0), "DSO support routines"}, 152 {ERR_PACK(ERR_LIB_TS, 0, 0), "time stamp routines"}, 153 {ERR_PACK(ERR_LIB_ENGINE, 0, 0), "engine routines"}, 154 {ERR_PACK(ERR_LIB_OCSP, 0, 0), "OCSP routines"}, 155 {ERR_PACK(ERR_LIB_FIPS, 0, 0), "FIPS routines"}, 156 {ERR_PACK(ERR_LIB_CMS, 0, 0), "CMS routines"}, 157 {ERR_PACK(ERR_LIB_HMAC, 0, 0), "HMAC routines"}, 158 {0, NULL}, 159}; 160 161static ERR_STRING_DATA ERR_str_functs[] = { 162 {ERR_PACK(0, SYS_F_FOPEN, 0), "fopen"}, 163 {ERR_PACK(0, SYS_F_CONNECT, 0), "connect"}, 164 {ERR_PACK(0, SYS_F_GETSERVBYNAME, 0), "getservbyname"}, 165 {ERR_PACK(0, SYS_F_SOCKET, 0), "socket"}, 166 {ERR_PACK(0, SYS_F_IOCTLSOCKET, 0), "ioctlsocket"}, 167 {ERR_PACK(0, SYS_F_BIND, 0), "bind"}, 168 {ERR_PACK(0, SYS_F_LISTEN, 0), "listen"}, 169 {ERR_PACK(0, SYS_F_ACCEPT, 0), "accept"}, 170# ifdef OPENSSL_SYS_WINDOWS 171 {ERR_PACK(0, SYS_F_WSASTARTUP, 0), "WSAstartup"}, 172# endif 173 {ERR_PACK(0, SYS_F_OPENDIR, 0), "opendir"}, 174 {ERR_PACK(0, SYS_F_FREAD, 0), "fread"}, 175 {0, NULL}, 176}; 177 178static ERR_STRING_DATA ERR_str_reasons[] = { 179 {ERR_R_SYS_LIB, "system lib"}, 180 {ERR_R_BN_LIB, "BN lib"}, 181 {ERR_R_RSA_LIB, "RSA lib"}, 182 {ERR_R_DH_LIB, "DH lib"}, 183 {ERR_R_EVP_LIB, "EVP lib"}, 184 {ERR_R_BUF_LIB, "BUF lib"}, 185 {ERR_R_OBJ_LIB, "OBJ lib"}, 186 {ERR_R_PEM_LIB, "PEM lib"}, 187 {ERR_R_DSA_LIB, "DSA lib"}, 188 {ERR_R_X509_LIB, "X509 lib"}, 189 {ERR_R_ASN1_LIB, "ASN1 lib"}, 190 {ERR_R_CONF_LIB, "CONF lib"}, 191 {ERR_R_CRYPTO_LIB, "CRYPTO lib"}, 192 {ERR_R_EC_LIB, "EC lib"}, 193 {ERR_R_SSL_LIB, "SSL lib"}, 194 {ERR_R_BIO_LIB, "BIO lib"}, 195 {ERR_R_PKCS7_LIB, "PKCS7 lib"}, 196 {ERR_R_X509V3_LIB, "X509V3 lib"}, 197 {ERR_R_PKCS12_LIB, "PKCS12 lib"}, 198 {ERR_R_RAND_LIB, "RAND lib"}, 199 {ERR_R_DSO_LIB, "DSO lib"}, 200 {ERR_R_ENGINE_LIB, "ENGINE lib"}, 201 {ERR_R_OCSP_LIB, "OCSP lib"}, 202 {ERR_R_TS_LIB, "TS lib"}, 203 204 {ERR_R_NESTED_ASN1_ERROR, "nested asn1 error"}, 205 {ERR_R_BAD_ASN1_OBJECT_HEADER, "bad asn1 object header"}, 206 {ERR_R_BAD_GET_ASN1_OBJECT_CALL, "bad get asn1 object call"}, 207 {ERR_R_EXPECTING_AN_ASN1_SEQUENCE, "expecting an asn1 sequence"}, 208 {ERR_R_ASN1_LENGTH_MISMATCH, "asn1 length mismatch"}, 209 {ERR_R_MISSING_ASN1_EOS, "missing asn1 eos"}, 210 211 {ERR_R_FATAL, "fatal"}, 212 {ERR_R_MALLOC_FAILURE, "malloc failure"}, 213 {ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED, 214 "called a function you should not call"}, 215 {ERR_R_PASSED_NULL_PARAMETER, "passed a null parameter"}, 216 {ERR_R_INTERNAL_ERROR, "internal error"}, 217 {ERR_R_DISABLED, "called a function that was disabled at compile-time"}, 218 219 {0, NULL}, 220}; 221#endif 222 223/* Define the predeclared (but externally opaque) "ERR_FNS" type */ 224struct st_ERR_FNS { 225 /* Works on the "error_hash" string table */ 226 LHASH_OF(ERR_STRING_DATA) *(*cb_err_get) (int create); 227 void (*cb_err_del) (void); 228 ERR_STRING_DATA *(*cb_err_get_item) (const ERR_STRING_DATA *); 229 ERR_STRING_DATA *(*cb_err_set_item) (ERR_STRING_DATA *); 230 ERR_STRING_DATA *(*cb_err_del_item) (ERR_STRING_DATA *); 231 /* Works on the "thread_hash" error-state table */ 232 LHASH_OF(ERR_STATE) *(*cb_thread_get) (int create); 233 void (*cb_thread_release) (LHASH_OF(ERR_STATE) **hash); 234 ERR_STATE *(*cb_thread_get_item) (const ERR_STATE *); 235 ERR_STATE *(*cb_thread_set_item) (ERR_STATE *); 236 void (*cb_thread_del_item) (const ERR_STATE *); 237 /* Returns the next available error "library" numbers */ 238 int (*cb_get_next_lib) (void); 239}; 240 241/* Predeclarations of the "err_defaults" functions */ 242static LHASH_OF(ERR_STRING_DATA) *int_err_get(int create); 243static void int_err_del(void); 244static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *); 245static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *); 246static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *); 247static LHASH_OF(ERR_STATE) *int_thread_get(int create); 248static void int_thread_release(LHASH_OF(ERR_STATE) **hash); 249static ERR_STATE *int_thread_get_item(const ERR_STATE *); 250static ERR_STATE *int_thread_set_item(ERR_STATE *); 251static void int_thread_del_item(const ERR_STATE *); 252static int int_err_get_next_lib(void); 253/* The static ERR_FNS table using these defaults functions */ 254static const ERR_FNS err_defaults = { 255 int_err_get, 256 int_err_del, 257 int_err_get_item, 258 int_err_set_item, 259 int_err_del_item, 260 int_thread_get, 261 int_thread_release, 262 int_thread_get_item, 263 int_thread_set_item, 264 int_thread_del_item, 265 int_err_get_next_lib 266}; 267 268/* The replacable table of ERR_FNS functions we use at run-time */ 269static const ERR_FNS *err_fns = NULL; 270 271/* Eg. rather than using "err_get()", use "ERRFN(err_get)()". */ 272#define ERRFN(a) err_fns->cb_##a 273 274/* 275 * The internal state used by "err_defaults" - as such, the setting, reading, 276 * creating, and deleting of this data should only be permitted via the 277 * "err_defaults" functions. This way, a linked module can completely defer 278 * all ERR state operation (together with requisite locking) to the 279 * implementations and state in the loading application. 280 */ 281static LHASH_OF(ERR_STRING_DATA) *int_error_hash = NULL; 282static LHASH_OF(ERR_STATE) *int_thread_hash = NULL; 283static int int_thread_hash_references = 0; 284static int int_err_library_number = ERR_LIB_USER; 285 286/* 287 * Internal function that checks whether "err_fns" is set and if not, sets it 288 * to the defaults. 289 */ 290static void err_fns_check(void) 291{ 292 if (err_fns) 293 return; 294 295 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 296 if (!err_fns) 297 err_fns = &err_defaults; 298 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 299} 300 301/* API functions to get or set the underlying ERR functions. */ 302 303const ERR_FNS *ERR_get_implementation(void) 304{ 305 err_fns_check(); 306 return err_fns; 307} 308 309int ERR_set_implementation(const ERR_FNS *fns) 310{ 311 int ret = 0; 312 313 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 314 /* 315 * It's too late if 'err_fns' is non-NULL. BTW: not much point setting an 316 * error is there?! 317 */ 318 if (!err_fns) { 319 err_fns = fns; 320 ret = 1; 321 } 322 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 323 return ret; 324} 325 326/* 327 * These are the callbacks provided to "lh_new()" when creating the LHASH 328 * tables internal to the "err_defaults" implementation. 329 */ 330 331static unsigned long get_error_values(int inc, int top, const char **file, 332 int *line, const char **data, 333 int *flags); 334 335/* The internal functions used in the "err_defaults" implementation */ 336 337static unsigned long err_string_data_hash(const ERR_STRING_DATA *a) 338{ 339 unsigned long ret, l; 340 341 l = a->error; 342 ret = l ^ ERR_GET_LIB(l) ^ ERR_GET_FUNC(l); 343 return (ret ^ ret % 19 * 13); 344} 345 346static IMPLEMENT_LHASH_HASH_FN(err_string_data, ERR_STRING_DATA) 347 348static int err_string_data_cmp(const ERR_STRING_DATA *a, 349 const ERR_STRING_DATA *b) 350{ 351 return (int)(a->error - b->error); 352} 353 354static IMPLEMENT_LHASH_COMP_FN(err_string_data, ERR_STRING_DATA) 355 356static LHASH_OF(ERR_STRING_DATA) *int_err_get(int create) 357{ 358 LHASH_OF(ERR_STRING_DATA) *ret = NULL; 359 360 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 361 if (!int_error_hash && create) { 362 CRYPTO_push_info("int_err_get (err.c)"); 363 int_error_hash = lh_ERR_STRING_DATA_new(); 364 CRYPTO_pop_info(); 365 } 366 if (int_error_hash) 367 ret = int_error_hash; 368 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 369 370 return ret; 371} 372 373static void int_err_del(void) 374{ 375 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 376 if (int_error_hash) { 377 lh_ERR_STRING_DATA_free(int_error_hash); 378 int_error_hash = NULL; 379 } 380 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 381} 382 383static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d) 384{ 385 ERR_STRING_DATA *p; 386 LHASH_OF(ERR_STRING_DATA) *hash; 387 388 err_fns_check(); 389 hash = ERRFN(err_get) (0); 390 if (!hash) 391 return NULL; 392 393 CRYPTO_r_lock(CRYPTO_LOCK_ERR); 394 p = lh_ERR_STRING_DATA_retrieve(hash, d); 395 CRYPTO_r_unlock(CRYPTO_LOCK_ERR); 396 397 return p; 398} 399 400static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d) 401{ 402 ERR_STRING_DATA *p; 403 LHASH_OF(ERR_STRING_DATA) *hash; 404 405 err_fns_check(); 406 hash = ERRFN(err_get) (1); 407 if (!hash) 408 return NULL; 409 410 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 411 p = lh_ERR_STRING_DATA_insert(hash, d); 412 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 413 414 return p; 415} 416 417static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *d) 418{ 419 ERR_STRING_DATA *p; 420 LHASH_OF(ERR_STRING_DATA) *hash; 421 422 err_fns_check(); 423 hash = ERRFN(err_get) (0); 424 if (!hash) 425 return NULL; 426 427 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 428 p = lh_ERR_STRING_DATA_delete(hash, d); 429 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 430 431 return p; 432} 433 434static unsigned long err_state_hash(const ERR_STATE *a) 435{ 436 return CRYPTO_THREADID_hash(&a->tid) * 13; 437} 438 439static IMPLEMENT_LHASH_HASH_FN(err_state, ERR_STATE) 440 441static int err_state_cmp(const ERR_STATE *a, const ERR_STATE *b) 442{ 443 return CRYPTO_THREADID_cmp(&a->tid, &b->tid); 444} 445 446static IMPLEMENT_LHASH_COMP_FN(err_state, ERR_STATE) 447 448static LHASH_OF(ERR_STATE) *int_thread_get(int create) 449{ 450 LHASH_OF(ERR_STATE) *ret = NULL; 451 452 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 453 if (!int_thread_hash && create) { 454 CRYPTO_push_info("int_thread_get (err.c)"); 455 int_thread_hash = lh_ERR_STATE_new(); 456 CRYPTO_pop_info(); 457 } 458 if (int_thread_hash) { 459 int_thread_hash_references++; 460 ret = int_thread_hash; 461 } 462 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 463 return ret; 464} 465 466static void int_thread_release(LHASH_OF(ERR_STATE) **hash) 467{ 468 int i; 469 470 if (hash == NULL || *hash == NULL) 471 return; 472 473 i = CRYPTO_add(&int_thread_hash_references, -1, CRYPTO_LOCK_ERR); 474 475#ifdef REF_PRINT 476 fprintf(stderr, "%4d:%s\n", int_thread_hash_references, "ERR"); 477#endif 478 if (i > 0) 479 return; 480#ifdef REF_CHECK 481 if (i < 0) { 482 fprintf(stderr, "int_thread_release, bad reference count\n"); 483 abort(); /* ok */ 484 } 485#endif 486 *hash = NULL; 487} 488 489static ERR_STATE *int_thread_get_item(const ERR_STATE *d) 490{ 491 ERR_STATE *p; 492 LHASH_OF(ERR_STATE) *hash; 493 494 err_fns_check(); 495 hash = ERRFN(thread_get) (0); 496 if (!hash) 497 return NULL; 498 499 CRYPTO_r_lock(CRYPTO_LOCK_ERR); 500 p = lh_ERR_STATE_retrieve(hash, d); 501 CRYPTO_r_unlock(CRYPTO_LOCK_ERR); 502 503 ERRFN(thread_release) (&hash); 504 return p; 505} 506 507static ERR_STATE *int_thread_set_item(ERR_STATE *d) 508{ 509 ERR_STATE *p; 510 LHASH_OF(ERR_STATE) *hash; 511 512 err_fns_check(); 513 hash = ERRFN(thread_get) (1); 514 if (!hash) 515 return NULL; 516 517 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 518 p = lh_ERR_STATE_insert(hash, d); 519 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 520 521 ERRFN(thread_release) (&hash); 522 return p; 523} 524 525static void int_thread_del_item(const ERR_STATE *d) 526{ 527 ERR_STATE *p; 528 LHASH_OF(ERR_STATE) *hash; 529 530 err_fns_check(); 531 hash = ERRFN(thread_get) (0); 532 if (!hash) 533 return; 534 535 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 536 p = lh_ERR_STATE_delete(hash, d); 537 /* make sure we don't leak memory */ 538 if (int_thread_hash_references == 1 539 && int_thread_hash && lh_ERR_STATE_num_items(int_thread_hash) == 0) { 540 lh_ERR_STATE_free(int_thread_hash); 541 int_thread_hash = NULL; 542 } 543 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 544 545 ERRFN(thread_release) (&hash); 546 if (p) 547 ERR_STATE_free(p); 548} 549 550static int int_err_get_next_lib(void) 551{ 552 int ret; 553 554 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 555 ret = int_err_library_number++; 556 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 557 558 return ret; 559} 560 561#ifndef OPENSSL_NO_ERR 562# define NUM_SYS_STR_REASONS 127 563# define LEN_SYS_STR_REASON 32 564 565static ERR_STRING_DATA SYS_str_reasons[NUM_SYS_STR_REASONS + 1]; 566/* 567 * SYS_str_reasons is filled with copies of strerror() results at 568 * initialization. 'errno' values up to 127 should cover all usual errors, 569 * others will be displayed numerically by ERR_error_string. It is crucial 570 * that we have something for each reason code that occurs in 571 * ERR_str_reasons, or bogus reason strings will be returned for SYSerr(), 572 * which always gets an errno value and never one of those 'standard' reason 573 * codes. 574 */ 575 576static void build_SYS_str_reasons(void) 577{ 578 /* OPENSSL_malloc cannot be used here, use static storage instead */ 579 static char strerror_tab[NUM_SYS_STR_REASONS][LEN_SYS_STR_REASON]; 580 int i; 581 static int init = 1; 582 583 CRYPTO_r_lock(CRYPTO_LOCK_ERR); 584 if (!init) { 585 CRYPTO_r_unlock(CRYPTO_LOCK_ERR); 586 return; 587 } 588 589 CRYPTO_r_unlock(CRYPTO_LOCK_ERR); 590 CRYPTO_w_lock(CRYPTO_LOCK_ERR); 591 if (!init) { 592 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 593 return; 594 } 595 596 for (i = 1; i <= NUM_SYS_STR_REASONS; i++) { 597 ERR_STRING_DATA *str = &SYS_str_reasons[i - 1]; 598 599 str->error = (unsigned long)i; 600 if (str->string == NULL) { 601 char (*dest)[LEN_SYS_STR_REASON] = &(strerror_tab[i - 1]); 602 char *src = strerror(i); 603 if (src != NULL) { 604 strncpy(*dest, src, sizeof *dest); 605 (*dest)[sizeof *dest - 1] = '\0'; 606 str->string = *dest; 607 } 608 } 609 if (str->string == NULL) 610 str->string = "unknown"; 611 } 612 613 /* 614 * Now we still have SYS_str_reasons[NUM_SYS_STR_REASONS] = {0, NULL}, as 615 * required by ERR_load_strings. 616 */ 617 618 init = 0; 619 620 CRYPTO_w_unlock(CRYPTO_LOCK_ERR); 621} 622#endif 623 624#define err_clear_data(p,i) \ 625 do { \ 626 if (((p)->err_data[i] != NULL) && \ 627 (p)->err_data_flags[i] & ERR_TXT_MALLOCED) \ 628 { \ 629 OPENSSL_free((p)->err_data[i]); \ 630 (p)->err_data[i]=NULL; \ 631 } \ 632 (p)->err_data_flags[i]=0; \ 633 } while(0) 634 635#define err_clear(p,i) \ 636 do { \ 637 (p)->err_flags[i]=0; \ 638 (p)->err_buffer[i]=0; \ 639 err_clear_data(p,i); \ 640 (p)->err_file[i]=NULL; \ 641 (p)->err_line[i]= -1; \ 642 } while(0) 643 644static void ERR_STATE_free(ERR_STATE *s) 645{ 646 int i; 647 648 if (s == NULL) 649 return; 650 651 for (i = 0; i < ERR_NUM_ERRORS; i++) { 652 err_clear_data(s, i); 653 } 654 OPENSSL_free(s); 655} 656 657void ERR_load_ERR_strings(void) 658{ 659 err_fns_check(); 660#ifndef OPENSSL_NO_ERR 661 err_load_strings(0, ERR_str_libraries); 662 err_load_strings(0, ERR_str_reasons); 663 err_load_strings(ERR_LIB_SYS, ERR_str_functs); 664 build_SYS_str_reasons(); 665 err_load_strings(ERR_LIB_SYS, SYS_str_reasons); 666#endif 667} 668 669static void err_load_strings(int lib, ERR_STRING_DATA *str) 670{ 671 while (str->error) { 672 if (lib) 673 str->error |= ERR_PACK(lib, 0, 0); 674 ERRFN(err_set_item) (str); 675 str++; 676 } 677} 678 679void ERR_load_strings(int lib, ERR_STRING_DATA *str) 680{ 681 ERR_load_ERR_strings(); 682 err_load_strings(lib, str); 683} 684 685void ERR_unload_strings(int lib, ERR_STRING_DATA *str) 686{ 687 while (str->error) { 688 if (lib) 689 str->error |= ERR_PACK(lib, 0, 0); 690 ERRFN(err_del_item) (str); 691 str++; 692 } 693} 694 695void ERR_free_strings(void) 696{ 697 err_fns_check(); 698 ERRFN(err_del) (); 699} 700 701/********************************************************/ 702 703void ERR_put_error(int lib, int func, int reason, const char *file, int line) 704{ 705 ERR_STATE *es; 706 707#ifdef _OSD_POSIX 708 /* 709 * In the BS2000-OSD POSIX subsystem, the compiler generates path names 710 * in the form "*POSIX(/etc/passwd)". This dirty hack strips them to 711 * something sensible. @@@ We shouldn't modify a const string, though. 712 */ 713 if (strncmp(file, "*POSIX(", sizeof("*POSIX(") - 1) == 0) { 714 char *end; 715 716 /* Skip the "*POSIX(" prefix */ 717 file += sizeof("*POSIX(") - 1; 718 end = &file[strlen(file) - 1]; 719 if (*end == ')') 720 *end = '\0'; 721 /* Optional: use the basename of the path only. */ 722 if ((end = strrchr(file, '/')) != NULL) 723 file = &end[1]; 724 } 725#endif 726 es = ERR_get_state(); 727 728 es->top = (es->top + 1) % ERR_NUM_ERRORS; 729 if (es->top == es->bottom) 730 es->bottom = (es->bottom + 1) % ERR_NUM_ERRORS; 731 es->err_flags[es->top] = 0; 732 es->err_buffer[es->top] = ERR_PACK(lib, func, reason); 733 es->err_file[es->top] = file; 734 es->err_line[es->top] = line; 735 err_clear_data(es, es->top); 736} 737 738void ERR_clear_error(void) 739{ 740 int i; 741 ERR_STATE *es; 742 743 es = ERR_get_state(); 744 745 for (i = 0; i < ERR_NUM_ERRORS; i++) { 746 err_clear(es, i); 747 } 748 es->top = es->bottom = 0; 749} 750 751unsigned long ERR_get_error(void) 752{ 753 return (get_error_values(1, 0, NULL, NULL, NULL, NULL)); 754} 755 756unsigned long ERR_get_error_line(const char **file, int *line) 757{ 758 return (get_error_values(1, 0, file, line, NULL, NULL)); 759} 760 761unsigned long ERR_get_error_line_data(const char **file, int *line, 762 const char **data, int *flags) 763{ 764 return (get_error_values(1, 0, file, line, data, flags)); 765} 766 767unsigned long ERR_peek_error(void) 768{ 769 return (get_error_values(0, 0, NULL, NULL, NULL, NULL)); 770} 771 772unsigned long ERR_peek_error_line(const char **file, int *line) 773{ 774 return (get_error_values(0, 0, file, line, NULL, NULL)); 775} 776 777unsigned long ERR_peek_error_line_data(const char **file, int *line, 778 const char **data, int *flags) 779{ 780 return (get_error_values(0, 0, file, line, data, flags)); 781} 782 783unsigned long ERR_peek_last_error(void) 784{ 785 return (get_error_values(0, 1, NULL, NULL, NULL, NULL)); 786} 787 788unsigned long ERR_peek_last_error_line(const char **file, int *line) 789{ 790 return (get_error_values(0, 1, file, line, NULL, NULL)); 791} 792 793unsigned long ERR_peek_last_error_line_data(const char **file, int *line, 794 const char **data, int *flags) 795{ 796 return (get_error_values(0, 1, file, line, data, flags)); 797} 798 799static unsigned long get_error_values(int inc, int top, const char **file, 800 int *line, const char **data, 801 int *flags) 802{ 803 int i = 0; 804 ERR_STATE *es; 805 unsigned long ret; 806 807 es = ERR_get_state(); 808 809 if (inc && top) { 810 if (file) 811 *file = ""; 812 if (line) 813 *line = 0; 814 if (data) 815 *data = ""; 816 if (flags) 817 *flags = 0; 818 819 return ERR_R_INTERNAL_ERROR; 820 } 821 822 if (es->bottom == es->top) 823 return 0; 824 if (top) 825 i = es->top; /* last error */ 826 else 827 i = (es->bottom + 1) % ERR_NUM_ERRORS; /* first error */ 828 829 ret = es->err_buffer[i]; 830 if (inc) { 831 es->bottom = i; 832 es->err_buffer[i] = 0; 833 } 834 835 if ((file != NULL) && (line != NULL)) { 836 if (es->err_file[i] == NULL) { 837 *file = "NA"; 838 if (line != NULL) 839 *line = 0; 840 } else { 841 *file = es->err_file[i]; 842 if (line != NULL) 843 *line = es->err_line[i]; 844 } 845 } 846 847 if (data == NULL) { 848 if (inc) { 849 err_clear_data(es, i); 850 } 851 } else { 852 if (es->err_data[i] == NULL) { 853 *data = ""; 854 if (flags != NULL) 855 *flags = 0; 856 } else { 857 *data = es->err_data[i]; 858 if (flags != NULL) 859 *flags = es->err_data_flags[i]; 860 } 861 } 862 return ret; 863} 864 865void ERR_error_string_n(unsigned long e, char *buf, size_t len) 866{ 867 char lsbuf[64], fsbuf[64], rsbuf[64]; 868 const char *ls, *fs, *rs; 869 unsigned long l, f, r; 870 871 if (len == 0) 872 return; 873 874 l = ERR_GET_LIB(e); 875 f = ERR_GET_FUNC(e); 876 r = ERR_GET_REASON(e); 877 878 ls = ERR_lib_error_string(e); 879 fs = ERR_func_error_string(e); 880 rs = ERR_reason_error_string(e); 881 882 if (ls == NULL) 883 BIO_snprintf(lsbuf, sizeof(lsbuf), "lib(%lu)", l); 884 if (fs == NULL) 885 BIO_snprintf(fsbuf, sizeof(fsbuf), "func(%lu)", f); 886 if (rs == NULL) 887 BIO_snprintf(rsbuf, sizeof(rsbuf), "reason(%lu)", r); 888 889 BIO_snprintf(buf, len, "error:%08lX:%s:%s:%s", e, ls ? ls : lsbuf, 890 fs ? fs : fsbuf, rs ? rs : rsbuf); 891 if (strlen(buf) == len - 1) { 892 /* 893 * output may be truncated; make sure we always have 5 894 * colon-separated fields, i.e. 4 colons ... 895 */ 896#define NUM_COLONS 4 897 if (len > NUM_COLONS) { /* ... if possible */ 898 int i; 899 char *s = buf; 900 901 for (i = 0; i < NUM_COLONS; i++) { 902 char *colon = strchr(s, ':'); 903 if (colon == NULL || colon > &buf[len - 1] - NUM_COLONS + i) { 904 /* 905 * set colon no. i at last possible position (buf[len-1] 906 * is the terminating 0) 907 */ 908 colon = &buf[len - 1] - NUM_COLONS + i; 909 *colon = ':'; 910 } 911 s = colon + 1; 912 } 913 } 914 } 915} 916 917/* BAD for multi-threading: uses a local buffer if ret == NULL */ 918/* 919 * ERR_error_string_n should be used instead for ret != NULL as 920 * ERR_error_string cannot know how large the buffer is 921 */ 922char *ERR_error_string(unsigned long e, char *ret) 923{ 924 static char buf[256]; 925 926 if (ret == NULL) 927 ret = buf; 928 ERR_error_string_n(e, ret, 256); 929 930 return ret; 931} 932 933LHASH_OF(ERR_STRING_DATA) *ERR_get_string_table(void) 934{ 935 err_fns_check(); 936 return ERRFN(err_get) (0); 937} 938 939LHASH_OF(ERR_STATE) *ERR_get_err_state_table(void) 940{ 941 err_fns_check(); 942 return ERRFN(thread_get) (0); 943} 944 945void ERR_release_err_state_table(LHASH_OF(ERR_STATE) **hash) 946{ 947 err_fns_check(); 948 ERRFN(thread_release) (hash); 949} 950 951const char *ERR_lib_error_string(unsigned long e) 952{ 953 ERR_STRING_DATA d, *p; 954 unsigned long l; 955 956 err_fns_check(); 957 l = ERR_GET_LIB(e); 958 d.error = ERR_PACK(l, 0, 0); 959 p = ERRFN(err_get_item) (&d); 960 return ((p == NULL) ? NULL : p->string); 961} 962 963const char *ERR_func_error_string(unsigned long e) 964{ 965 ERR_STRING_DATA d, *p; 966 unsigned long l, f; 967 968 err_fns_check(); 969 l = ERR_GET_LIB(e); 970 f = ERR_GET_FUNC(e); 971 d.error = ERR_PACK(l, f, 0); 972 p = ERRFN(err_get_item) (&d); 973 return ((p == NULL) ? NULL : p->string); 974} 975 976const char *ERR_reason_error_string(unsigned long e) 977{ 978 ERR_STRING_DATA d, *p = NULL; 979 unsigned long l, r; 980 981 err_fns_check(); 982 l = ERR_GET_LIB(e); 983 r = ERR_GET_REASON(e); 984 d.error = ERR_PACK(l, 0, r); 985 p = ERRFN(err_get_item) (&d); 986 if (!p) { 987 d.error = ERR_PACK(0, 0, r); 988 p = ERRFN(err_get_item) (&d); 989 } 990 return ((p == NULL) ? NULL : p->string); 991} 992 993void ERR_remove_thread_state(const CRYPTO_THREADID *id) 994{ 995 ERR_STATE tmp; 996 997 if (id) 998 CRYPTO_THREADID_cpy(&tmp.tid, id); 999 else 1000 CRYPTO_THREADID_current(&tmp.tid); 1001 err_fns_check(); 1002 /* 1003 * thread_del_item automatically destroys the LHASH if the number of 1004 * items reaches zero. 1005 */ 1006 ERRFN(thread_del_item) (&tmp); 1007} 1008 1009#ifndef OPENSSL_NO_DEPRECATED 1010void ERR_remove_state(unsigned long pid) 1011{ 1012 ERR_remove_thread_state(NULL); 1013} 1014#endif 1015 1016ERR_STATE *ERR_get_state(void) 1017{ 1018 static ERR_STATE fallback; 1019 ERR_STATE *ret, tmp, *tmpp = NULL; 1020 int i; 1021 CRYPTO_THREADID tid; 1022 1023 err_fns_check(); 1024 CRYPTO_THREADID_current(&tid); 1025 CRYPTO_THREADID_cpy(&tmp.tid, &tid); 1026 ret = ERRFN(thread_get_item) (&tmp); 1027 1028 /* ret == the error state, if NULL, make a new one */ 1029 if (ret == NULL) { 1030 ret = (ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE)); 1031 if (ret == NULL) 1032 return (&fallback); 1033 CRYPTO_THREADID_cpy(&ret->tid, &tid); 1034 ret->top = 0; 1035 ret->bottom = 0; 1036 for (i = 0; i < ERR_NUM_ERRORS; i++) { 1037 ret->err_data[i] = NULL; 1038 ret->err_data_flags[i] = 0; 1039 } 1040 tmpp = ERRFN(thread_set_item) (ret); 1041 /* To check if insertion failed, do a get. */ 1042 if (ERRFN(thread_get_item) (ret) != ret) { 1043 ERR_STATE_free(ret); /* could not insert it */ 1044 return (&fallback); 1045 } 1046 /* 1047 * If a race occured in this function and we came second, tmpp is the 1048 * first one that we just replaced. 1049 */ 1050 if (tmpp) 1051 ERR_STATE_free(tmpp); 1052 } 1053 return ret; 1054} 1055 1056int ERR_get_next_error_library(void) 1057{ 1058 err_fns_check(); 1059 return ERRFN(get_next_lib) (); 1060} 1061 1062void ERR_set_error_data(char *data, int flags) 1063{ 1064 ERR_STATE *es; 1065 int i; 1066 1067 es = ERR_get_state(); 1068 1069 i = es->top; 1070 if (i == 0) 1071 i = ERR_NUM_ERRORS - 1; 1072 1073 err_clear_data(es, i); 1074 es->err_data[i] = data; 1075 es->err_data_flags[i] = flags; 1076} 1077 1078void ERR_add_error_data(int num, ...) 1079{ 1080 va_list args; 1081 va_start(args, num); 1082 ERR_add_error_vdata(num, args); 1083 va_end(args); 1084} 1085 1086void ERR_add_error_vdata(int num, va_list args) 1087{ 1088 int i, n, s; 1089 char *str, *p, *a; 1090 1091 s = 80; 1092 str = OPENSSL_malloc(s + 1); 1093 if (str == NULL) 1094 return; 1095 str[0] = '\0'; 1096 1097 n = 0; 1098 for (i = 0; i < num; i++) { 1099 a = va_arg(args, char *); 1100 /* ignore NULLs, thanks to Bob Beck <beck@obtuse.com> */ 1101 if (a != NULL) { 1102 n += strlen(a); 1103 if (n > s) { 1104 s = n + 20; 1105 p = OPENSSL_realloc(str, s + 1); 1106 if (p == NULL) { 1107 OPENSSL_free(str); 1108 return; 1109 } else 1110 str = p; 1111 } 1112 BUF_strlcat(str, a, (size_t)s + 1); 1113 } 1114 } 1115 ERR_set_error_data(str, ERR_TXT_MALLOCED | ERR_TXT_STRING); 1116} 1117 1118int ERR_set_mark(void) 1119{ 1120 ERR_STATE *es; 1121 1122 es = ERR_get_state(); 1123 1124 if (es->bottom == es->top) 1125 return 0; 1126 es->err_flags[es->top] |= ERR_FLAG_MARK; 1127 return 1; 1128} 1129 1130int ERR_pop_to_mark(void) 1131{ 1132 ERR_STATE *es; 1133 1134 es = ERR_get_state(); 1135 1136 while (es->bottom != es->top 1137 && (es->err_flags[es->top] & ERR_FLAG_MARK) == 0) { 1138 err_clear(es, es->top); 1139 es->top -= 1; 1140 if (es->top == -1) 1141 es->top = ERR_NUM_ERRORS - 1; 1142 } 1143 1144 if (es->bottom == es->top) 1145 return 0; 1146 es->err_flags[es->top] &= ~ERR_FLAG_MARK; 1147 return 1; 1148} 1149