2 * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
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
10 #define OSSL_FORCE_ERR_STATE
15 #include "crypto/cryptlib.h"
16 #include "internal/err.h"
17 #include "crypto/err.h"
18 #include <openssl/err.h>
19 #include <openssl/crypto.h>
20 #include <openssl/buffer.h>
21 #include <openssl/bio.h>
22 #include <openssl/opensslconf.h>
23 #include "internal/thread_once.h"
24 #include "crypto/ctype.h"
25 #include "internal/constant_time.h"
26 #include "internal/e_os.h"
27 #include "err_local.h"
29 /* Forward declaration in case it's not published because of configuration */
30 ERR_STATE
*ERR_get_state(void);
32 #ifndef OPENSSL_NO_ERR
33 static int err_load_strings(const ERR_STRING_DATA
*str
);
36 #ifndef OPENSSL_NO_ERR
37 static ERR_STRING_DATA ERR_str_libraries
[] = {
38 {ERR_PACK(ERR_LIB_NONE
, 0, 0), "unknown library"},
39 {ERR_PACK(ERR_LIB_SYS
, 0, 0), "system library"},
40 {ERR_PACK(ERR_LIB_BN
, 0, 0), "bignum routines"},
41 {ERR_PACK(ERR_LIB_RSA
, 0, 0), "rsa routines"},
42 {ERR_PACK(ERR_LIB_DH
, 0, 0), "Diffie-Hellman routines"},
43 {ERR_PACK(ERR_LIB_EVP
, 0, 0), "digital envelope routines"},
44 {ERR_PACK(ERR_LIB_BUF
, 0, 0), "memory buffer routines"},
45 {ERR_PACK(ERR_LIB_OBJ
, 0, 0), "object identifier routines"},
46 {ERR_PACK(ERR_LIB_PEM
, 0, 0), "PEM routines"},
47 {ERR_PACK(ERR_LIB_DSA
, 0, 0), "dsa routines"},
48 {ERR_PACK(ERR_LIB_X509
, 0, 0), "x509 certificate routines"},
49 {ERR_PACK(ERR_LIB_ASN1
, 0, 0), "asn1 encoding routines"},
50 {ERR_PACK(ERR_LIB_CONF
, 0, 0), "configuration file routines"},
51 {ERR_PACK(ERR_LIB_CRYPTO
, 0, 0), "common libcrypto routines"},
52 {ERR_PACK(ERR_LIB_EC
, 0, 0), "elliptic curve routines"},
53 {ERR_PACK(ERR_LIB_ECDSA
, 0, 0), "ECDSA routines"},
54 {ERR_PACK(ERR_LIB_ECDH
, 0, 0), "ECDH routines"},
55 {ERR_PACK(ERR_LIB_SSL
, 0, 0), "SSL routines"},
56 {ERR_PACK(ERR_LIB_BIO
, 0, 0), "BIO routines"},
57 {ERR_PACK(ERR_LIB_PKCS7
, 0, 0), "PKCS7 routines"},
58 {ERR_PACK(ERR_LIB_X509V3
, 0, 0), "X509 V3 routines"},
59 {ERR_PACK(ERR_LIB_PKCS12
, 0, 0), "PKCS12 routines"},
60 {ERR_PACK(ERR_LIB_RAND
, 0, 0), "random number generator"},
61 {ERR_PACK(ERR_LIB_DSO
, 0, 0), "DSO support routines"},
62 {ERR_PACK(ERR_LIB_TS
, 0, 0), "time stamp routines"},
63 {ERR_PACK(ERR_LIB_ENGINE
, 0, 0), "engine routines"},
64 {ERR_PACK(ERR_LIB_OCSP
, 0, 0), "OCSP routines"},
65 {ERR_PACK(ERR_LIB_UI
, 0, 0), "UI routines"},
66 {ERR_PACK(ERR_LIB_FIPS
, 0, 0), "FIPS routines"},
67 {ERR_PACK(ERR_LIB_CMS
, 0, 0), "CMS routines"},
68 {ERR_PACK(ERR_LIB_CRMF
, 0, 0), "CRMF routines"},
69 {ERR_PACK(ERR_LIB_CMP
, 0, 0), "CMP routines"},
70 {ERR_PACK(ERR_LIB_HMAC
, 0, 0), "HMAC routines"},
71 {ERR_PACK(ERR_LIB_CT
, 0, 0), "CT routines"},
72 {ERR_PACK(ERR_LIB_ASYNC
, 0, 0), "ASYNC routines"},
73 {ERR_PACK(ERR_LIB_KDF
, 0, 0), "KDF routines"},
74 {ERR_PACK(ERR_LIB_OSSL_STORE
, 0, 0), "STORE routines"},
75 {ERR_PACK(ERR_LIB_SM2
, 0, 0), "SM2 routines"},
76 {ERR_PACK(ERR_LIB_ESS
, 0, 0), "ESS routines"},
77 {ERR_PACK(ERR_LIB_PROV
, 0, 0), "Provider routines"},
78 {ERR_PACK(ERR_LIB_OSSL_ENCODER
, 0, 0), "ENCODER routines"},
79 {ERR_PACK(ERR_LIB_OSSL_DECODER
, 0, 0), "DECODER routines"},
80 {ERR_PACK(ERR_LIB_HTTP
, 0, 0), "HTTP routines"},
85 * Should make sure that all ERR_R_ reasons defined in include/openssl/err.h.in
86 * are listed. For maintainability, please keep all reasons in the same order.
88 static ERR_STRING_DATA ERR_str_reasons
[] = {
89 {ERR_R_SYS_LIB
, "system lib"},
90 {ERR_R_BN_LIB
, "BN lib"},
91 {ERR_R_RSA_LIB
, "RSA lib"},
92 {ERR_R_DH_LIB
, "DH lib"},
93 {ERR_R_EVP_LIB
, "EVP lib"},
94 {ERR_R_BUF_LIB
, "BUF lib"},
95 {ERR_R_OBJ_LIB
, "OBJ lib"},
96 {ERR_R_PEM_LIB
, "PEM lib"},
97 {ERR_R_DSA_LIB
, "DSA lib"},
98 {ERR_R_X509_LIB
, "X509 lib"},
99 {ERR_R_ASN1_LIB
, "ASN1 lib"},
100 {ERR_R_CRYPTO_LIB
, "CRYPTO lib"},
101 {ERR_R_EC_LIB
, "EC lib"},
102 {ERR_R_BIO_LIB
, "BIO lib"},
103 {ERR_R_PKCS7_LIB
, "PKCS7 lib"},
104 {ERR_R_X509V3_LIB
, "X509V3 lib"},
105 {ERR_R_ENGINE_LIB
, "ENGINE lib"},
106 {ERR_R_UI_LIB
, "UI lib"},
107 {ERR_R_ECDSA_LIB
, "ECDSA lib"},
108 {ERR_R_OSSL_STORE_LIB
, "OSSL_STORE lib"},
109 {ERR_R_OSSL_DECODER_LIB
, "OSSL_DECODER lib"},
111 {ERR_R_FATAL
, "fatal"},
112 {ERR_R_MALLOC_FAILURE
, "malloc failure"},
113 {ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED
,
114 "called a function you should not call"},
115 {ERR_R_PASSED_NULL_PARAMETER
, "passed a null parameter"},
116 {ERR_R_INTERNAL_ERROR
, "internal error"},
117 {ERR_R_DISABLED
, "called a function that was disabled at compile-time"},
118 {ERR_R_INIT_FAIL
, "init fail"},
119 {ERR_R_PASSED_INVALID_ARGUMENT
, "passed invalid argument"},
120 {ERR_R_OPERATION_FAIL
, "operation fail"},
121 {ERR_R_INVALID_PROVIDER_FUNCTIONS
, "invalid provider functions"},
122 {ERR_R_INTERRUPTED_OR_CANCELLED
, "interrupted or cancelled"},
123 {ERR_R_NESTED_ASN1_ERROR
, "nested asn1 error"},
124 {ERR_R_MISSING_ASN1_EOS
, "missing asn1 eos"},
126 * Something is unsupported, exactly what is expressed with additional data
128 {ERR_R_UNSUPPORTED
, "unsupported"},
130 * A fetch failed for other reasons than the name to be fetched being
133 {ERR_R_FETCH_FAILED
, "fetch failed"},
134 {ERR_R_INVALID_PROPERTY_DEFINITION
, "invalid property definition"},
135 {ERR_R_UNABLE_TO_GET_READ_LOCK
, "unable to get read lock"},
136 {ERR_R_UNABLE_TO_GET_WRITE_LOCK
, "unable to get write lock"},
141 static CRYPTO_ONCE err_init
= CRYPTO_ONCE_STATIC_INIT
;
142 static int set_err_thread_local
;
143 static CRYPTO_THREAD_LOCAL err_thread_local
;
145 static CRYPTO_ONCE err_string_init
= CRYPTO_ONCE_STATIC_INIT
;
146 static CRYPTO_RWLOCK
*err_string_lock
= NULL
;
148 #ifndef OPENSSL_NO_ERR
149 static ERR_STRING_DATA
*int_err_get_item(const ERR_STRING_DATA
*);
156 #ifndef OPENSSL_NO_ERR
157 static LHASH_OF(ERR_STRING_DATA
) *int_error_hash
= NULL
;
159 static int int_err_library_number
= ERR_LIB_USER
;
161 typedef enum ERR_GET_ACTION_e
{
162 EV_POP
, EV_PEEK
, EV_PEEK_LAST
165 static unsigned long get_error_values(ERR_GET_ACTION g
,
166 const char **file
, int *line
,
167 const char **func
, const char **data
,
170 #ifndef OPENSSL_NO_ERR
171 static unsigned long err_string_data_hash(const ERR_STRING_DATA
*a
)
173 unsigned long ret
, l
;
176 ret
= l
^ ERR_GET_LIB(l
);
177 return (ret
^ ret
% 19 * 13);
180 static int err_string_data_cmp(const ERR_STRING_DATA
*a
,
181 const ERR_STRING_DATA
*b
)
183 if (a
->error
== b
->error
)
185 return a
->error
> b
->error
? 1 : -1;
188 static ERR_STRING_DATA
*int_err_get_item(const ERR_STRING_DATA
*d
)
190 ERR_STRING_DATA
*p
= NULL
;
192 if (!CRYPTO_THREAD_read_lock(err_string_lock
))
194 p
= lh_ERR_STRING_DATA_retrieve(int_error_hash
, d
);
195 CRYPTO_THREAD_unlock(err_string_lock
);
201 void OSSL_ERR_STATE_free(ERR_STATE
*state
)
207 for (i
= 0; i
< ERR_NUM_ERRORS
; i
++) {
208 err_clear(state
, i
, 1);
210 CRYPTO_free(state
, OPENSSL_FILE
, OPENSSL_LINE
);
213 DEFINE_RUN_ONCE_STATIC(do_err_strings_init
)
215 if (!OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY
, NULL
))
217 err_string_lock
= CRYPTO_THREAD_lock_new();
218 if (err_string_lock
== NULL
)
220 #ifndef OPENSSL_NO_ERR
221 int_error_hash
= lh_ERR_STRING_DATA_new(err_string_data_hash
,
222 err_string_data_cmp
);
223 if (int_error_hash
== NULL
) {
224 CRYPTO_THREAD_lock_free(err_string_lock
);
225 err_string_lock
= NULL
;
232 void err_cleanup(void)
234 if (set_err_thread_local
!= 0)
235 CRYPTO_THREAD_cleanup_local(&err_thread_local
);
236 CRYPTO_THREAD_lock_free(err_string_lock
);
237 err_string_lock
= NULL
;
238 #ifndef OPENSSL_NO_ERR
239 lh_ERR_STRING_DATA_free(int_error_hash
);
240 int_error_hash
= NULL
;
244 #ifndef OPENSSL_NO_ERR
246 * Legacy; pack in the library.
248 static void err_patch(int lib
, ERR_STRING_DATA
*str
)
250 unsigned long plib
= ERR_PACK(lib
, 0, 0);
252 for (; str
->error
!= 0; str
++)
257 * Hash in |str| error strings. Assumes the RUN_ONCE was done.
259 static int err_load_strings(const ERR_STRING_DATA
*str
)
261 if (!CRYPTO_THREAD_write_lock(err_string_lock
))
263 for (; str
->error
; str
++)
264 (void)lh_ERR_STRING_DATA_insert(int_error_hash
,
265 (ERR_STRING_DATA
*)str
);
266 CRYPTO_THREAD_unlock(err_string_lock
);
271 int ossl_err_load_ERR_strings(void)
273 #ifndef OPENSSL_NO_ERR
274 if (!RUN_ONCE(&err_string_init
, do_err_strings_init
))
277 err_load_strings(ERR_str_libraries
);
278 err_load_strings(ERR_str_reasons
);
283 int ERR_load_strings(int lib
, ERR_STRING_DATA
*str
)
285 #ifndef OPENSSL_NO_ERR
286 if (ossl_err_load_ERR_strings() == 0)
290 err_load_strings(str
);
296 int ERR_load_strings_const(const ERR_STRING_DATA
*str
)
298 #ifndef OPENSSL_NO_ERR
299 if (ossl_err_load_ERR_strings() == 0)
301 err_load_strings(str
);
307 int ERR_unload_strings(int lib
, ERR_STRING_DATA
*str
)
309 #ifndef OPENSSL_NO_ERR
310 if (!RUN_ONCE(&err_string_init
, do_err_strings_init
))
313 if (!CRYPTO_THREAD_write_lock(err_string_lock
))
316 * We don't need to ERR_PACK the lib, since that was done (to
317 * the table) when it was loaded.
319 for (; str
->error
; str
++)
320 (void)lh_ERR_STRING_DATA_delete(int_error_hash
, str
);
321 CRYPTO_THREAD_unlock(err_string_lock
);
327 void err_free_strings_int(void)
332 /********************************************************/
334 void ERR_clear_error(void)
339 es
= ossl_err_get_state_int();
343 for (i
= 0; i
< ERR_NUM_ERRORS
; i
++) {
346 es
->top
= es
->bottom
= 0;
349 unsigned long ERR_get_error(void)
351 return get_error_values(EV_POP
, NULL
, NULL
, NULL
, NULL
, NULL
);
354 unsigned long ERR_get_error_all(const char **file
, int *line
,
356 const char **data
, int *flags
)
358 return get_error_values(EV_POP
, file
, line
, func
, data
, flags
);
361 #ifndef OPENSSL_NO_DEPRECATED_3_0
362 unsigned long ERR_get_error_line(const char **file
, int *line
)
364 return get_error_values(EV_POP
, file
, line
, NULL
, NULL
, NULL
);
367 unsigned long ERR_get_error_line_data(const char **file
, int *line
,
368 const char **data
, int *flags
)
370 return get_error_values(EV_POP
, file
, line
, NULL
, data
, flags
);
374 unsigned long ERR_peek_error(void)
376 return get_error_values(EV_PEEK
, NULL
, NULL
, NULL
, NULL
, NULL
);
379 unsigned long ERR_peek_error_line(const char **file
, int *line
)
381 return get_error_values(EV_PEEK
, file
, line
, NULL
, NULL
, NULL
);
384 unsigned long ERR_peek_error_func(const char **func
)
386 return get_error_values(EV_PEEK
, NULL
, NULL
, func
, NULL
, NULL
);
389 unsigned long ERR_peek_error_data(const char **data
, int *flags
)
391 return get_error_values(EV_PEEK
, NULL
, NULL
, NULL
, data
, flags
);
394 unsigned long ERR_peek_error_all(const char **file
, int *line
,
396 const char **data
, int *flags
)
398 return get_error_values(EV_PEEK
, file
, line
, func
, data
, flags
);
401 #ifndef OPENSSL_NO_DEPRECATED_3_0
402 unsigned long ERR_peek_error_line_data(const char **file
, int *line
,
403 const char **data
, int *flags
)
405 return get_error_values(EV_PEEK
, file
, line
, NULL
, data
, flags
);
409 unsigned long ERR_peek_last_error(void)
411 return get_error_values(EV_PEEK_LAST
, NULL
, NULL
, NULL
, NULL
, NULL
);
414 unsigned long ERR_peek_last_error_line(const char **file
, int *line
)
416 return get_error_values(EV_PEEK_LAST
, file
, line
, NULL
, NULL
, NULL
);
419 unsigned long ERR_peek_last_error_func(const char **func
)
421 return get_error_values(EV_PEEK_LAST
, NULL
, NULL
, func
, NULL
, NULL
);
424 unsigned long ERR_peek_last_error_data(const char **data
, int *flags
)
426 return get_error_values(EV_PEEK_LAST
, NULL
, NULL
, NULL
, data
, flags
);
429 unsigned long ERR_peek_last_error_all(const char **file
, int *line
,
431 const char **data
, int *flags
)
433 return get_error_values(EV_PEEK_LAST
, file
, line
, func
, data
, flags
);
436 #ifndef OPENSSL_NO_DEPRECATED_3_0
437 unsigned long ERR_peek_last_error_line_data(const char **file
, int *line
,
438 const char **data
, int *flags
)
440 return get_error_values(EV_PEEK_LAST
, file
, line
, NULL
, data
, flags
);
444 static unsigned long get_error_values(ERR_GET_ACTION g
,
445 const char **file
, int *line
,
447 const char **data
, int *flags
)
453 es
= ossl_err_get_state_int();
458 * Clear anything that should have been cleared earlier. We do this
459 * here because this doesn't have constant-time issues.
461 while (es
->bottom
!= es
->top
) {
462 if (es
->err_flags
[es
->top
] & ERR_FLAG_CLEAR
) {
463 err_clear(es
, es
->top
, 0);
464 es
->top
= es
->top
> 0 ? es
->top
- 1 : ERR_NUM_ERRORS
- 1;
467 i
= (es
->bottom
+ 1) % ERR_NUM_ERRORS
;
468 if (es
->err_flags
[i
] & ERR_FLAG_CLEAR
) {
470 err_clear(es
, es
->bottom
, 0);
476 /* If everything has been cleared, the stack is empty. */
477 if (es
->bottom
== es
->top
)
480 /* Which error, the top of stack (latest one) or the first one? */
481 if (g
== EV_PEEK_LAST
)
484 i
= (es
->bottom
+ 1) % ERR_NUM_ERRORS
;
486 ret
= es
->err_buffer
[i
];
489 es
->err_buffer
[i
] = 0;
493 *file
= es
->err_file
[i
];
498 *line
= es
->err_line
[i
];
500 *func
= es
->err_func
[i
];
505 *flags
= es
->err_data_flags
[i
];
508 err_clear_data(es
, i
, 0);
511 *data
= es
->err_data
[i
];
521 void ossl_err_string_int(unsigned long e
, const char *func
,
522 char *buf
, size_t len
)
524 char lsbuf
[64], rsbuf
[256];
525 const char *ls
, *rs
= NULL
;
532 ls
= ERR_lib_error_string(e
);
534 BIO_snprintf(lsbuf
, sizeof(lsbuf
), "lib(%lu)", l
);
539 * ERR_reason_error_string() can't safely return system error strings,
540 * since it would call openssl_strerror_r(), which needs a buffer for
541 * thread safety. So for system errors, we call openssl_strerror_r()
544 r
= ERR_GET_REASON(e
);
545 #ifndef OPENSSL_NO_ERR
546 if (ERR_SYSTEM_ERROR(e
)) {
547 if (openssl_strerror_r(r
, rsbuf
, sizeof(rsbuf
)))
550 rs
= ERR_reason_error_string(e
);
554 BIO_snprintf(rsbuf
, sizeof(rsbuf
), "reason(%lu)",
555 r
& ~(ERR_RFLAGS_MASK
<< ERR_RFLAGS_OFFSET
));
559 BIO_snprintf(buf
, len
, "error:%08lX:%s:%s:%s", e
, ls
, func
, rs
);
560 if (strlen(buf
) == len
- 1) {
561 /* Didn't fit; use a minimal format. */
562 BIO_snprintf(buf
, len
, "err:%lx:%lx:%lx:%lx", e
, l
, 0L, r
);
567 void ERR_error_string_n(unsigned long e
, char *buf
, size_t len
)
569 ossl_err_string_int(e
, "", buf
, len
);
573 * ERR_error_string_n should be used instead for ret != NULL as
574 * ERR_error_string cannot know how large the buffer is
576 char *ERR_error_string(unsigned long e
, char *ret
)
578 static char buf
[256];
582 ERR_error_string_n(e
, ret
, (int)sizeof(buf
));
586 const char *ERR_lib_error_string(unsigned long e
)
588 #ifndef OPENSSL_NO_ERR
589 ERR_STRING_DATA d
, *p
;
592 if (!RUN_ONCE(&err_string_init
, do_err_strings_init
)) {
597 d
.error
= ERR_PACK(l
, 0, 0);
598 p
= int_err_get_item(&d
);
599 return ((p
== NULL
) ? NULL
: p
->string
);
605 #ifndef OPENSSL_NO_DEPRECATED_3_0
606 const char *ERR_func_error_string(unsigned long e
)
612 const char *ERR_reason_error_string(unsigned long e
)
614 #ifndef OPENSSL_NO_ERR
615 ERR_STRING_DATA d
, *p
= NULL
;
618 if (!RUN_ONCE(&err_string_init
, do_err_strings_init
)) {
623 * ERR_reason_error_string() can't safely return system error strings,
624 * since openssl_strerror_r() needs a buffer for thread safety, and we
625 * haven't got one that would serve any sensible purpose.
627 if (ERR_SYSTEM_ERROR(e
))
631 r
= ERR_GET_REASON(e
);
632 d
.error
= ERR_PACK(l
, 0, r
);
633 p
= int_err_get_item(&d
);
635 d
.error
= ERR_PACK(0, 0, r
);
636 p
= int_err_get_item(&d
);
638 return ((p
== NULL
) ? NULL
: p
->string
);
644 static void err_delete_thread_state(void *unused
)
646 ERR_STATE
*state
= CRYPTO_THREAD_get_local(&err_thread_local
);
650 CRYPTO_THREAD_set_local(&err_thread_local
, NULL
);
651 OSSL_ERR_STATE_free(state
);
654 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
655 void ERR_remove_thread_state(void *dummy
)
660 #ifndef OPENSSL_NO_DEPRECATED_1_0_0
661 void ERR_remove_state(unsigned long pid
)
666 DEFINE_RUN_ONCE_STATIC(err_do_init
)
668 set_err_thread_local
= 1;
669 return CRYPTO_THREAD_init_local(&err_thread_local
, NULL
);
672 ERR_STATE
*ossl_err_get_state_int(void)
675 int saveerrno
= get_last_sys_error();
677 if (!OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY
, NULL
))
680 if (!RUN_ONCE(&err_init
, err_do_init
))
683 state
= CRYPTO_THREAD_get_local(&err_thread_local
);
684 if (state
== (ERR_STATE
*)-1)
688 if (!CRYPTO_THREAD_set_local(&err_thread_local
, (ERR_STATE
*)-1))
691 state
= OSSL_ERR_STATE_new();
693 CRYPTO_THREAD_set_local(&err_thread_local
, NULL
);
697 if (!ossl_init_thread_start(NULL
, NULL
, err_delete_thread_state
)
698 || !CRYPTO_THREAD_set_local(&err_thread_local
, state
)) {
699 OSSL_ERR_STATE_free(state
);
700 CRYPTO_THREAD_set_local(&err_thread_local
, NULL
);
704 /* Ignore failures from these */
705 OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS
, NULL
);
708 set_sys_error(saveerrno
);
712 #ifndef OPENSSL_NO_DEPRECATED_3_0
713 ERR_STATE
*ERR_get_state(void)
715 return ossl_err_get_state_int();
721 * err_shelve_state returns the current thread local error state
722 * and freezes the error module until err_unshelve_state is called.
724 int err_shelve_state(void **state
)
726 int saveerrno
= get_last_sys_error();
729 * Note, at present our only caller is OPENSSL_init_crypto(), indirectly
730 * via ossl_init_load_crypto_nodelete(), by which point the requested
731 * "base" initialization has already been performed, so the below call is a
732 * NOOP, that re-enters OPENSSL_init_crypto() only to quickly return.
734 * If are no other valid callers of this function, the call below can be
735 * removed, avoiding the re-entry into OPENSSL_init_crypto(). If there are
736 * potential uses that are not from inside OPENSSL_init_crypto(), then this
737 * call is needed, but some care is required to make sure that the re-entry
740 if (!OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY
, NULL
))
743 if (!RUN_ONCE(&err_init
, err_do_init
))
746 *state
= CRYPTO_THREAD_get_local(&err_thread_local
);
747 if (!CRYPTO_THREAD_set_local(&err_thread_local
, (ERR_STATE
*)-1))
750 set_sys_error(saveerrno
);
755 * err_unshelve_state restores the error state that was returned
756 * by err_shelve_state previously.
758 void err_unshelve_state(void* state
)
760 if (state
!= (void*)-1)
761 CRYPTO_THREAD_set_local(&err_thread_local
, (ERR_STATE
*)state
);
764 int ERR_get_next_error_library(void)
768 if (!RUN_ONCE(&err_string_init
, do_err_strings_init
))
771 if (!CRYPTO_THREAD_write_lock(err_string_lock
))
773 ret
= int_err_library_number
++;
774 CRYPTO_THREAD_unlock(err_string_lock
);
778 static int err_set_error_data_int(char *data
, size_t size
, int flags
,
783 es
= ossl_err_get_state_int();
787 err_clear_data(es
, es
->top
, deallocate
);
788 err_set_data(es
, es
->top
, data
, size
, flags
);
793 void ERR_set_error_data(char *data
, int flags
)
796 * This function is void so we cannot propagate the error return. Since it
797 * is also in the public API we can't change the return type.
799 * We estimate the size of the data. If it's not flagged as allocated,
800 * then this is safe, and if it is flagged as allocated, then our size
801 * may be smaller than the actual allocation, but that doesn't matter
802 * too much, the buffer will remain untouched or will eventually be
803 * reallocated to a new size.
805 * callers should be advised that this function takes over ownership of
806 * the allocated memory, i.e. they can't count on the pointer to remain
809 err_set_error_data_int(data
, strlen(data
) + 1, flags
, 1);
812 void ERR_add_error_data(int num
, ...)
816 ERR_add_error_vdata(num
, args
);
820 void ERR_add_error_vdata(int num
, va_list args
)
823 int flags
= ERR_TXT_MALLOCED
| ERR_TXT_STRING
;
827 /* Get the current error data; if an allocated string get it. */
828 es
= ossl_err_get_state_int();
834 * If err_data is allocated already, reuse the space.
835 * Otherwise, allocate a small new buffer.
837 if ((es
->err_data_flags
[i
] & flags
) == flags
838 && ossl_assert(es
->err_data
[i
] != NULL
)) {
839 str
= es
->err_data
[i
];
840 size
= es
->err_data_size
[i
];
843 * To protect the string we just grabbed from tampering by other
844 * functions we may call, or to protect them from freeing a pointer
845 * that may no longer be valid at that point, we clear away the
846 * data pointer and the flags. We will set them again at the end
849 es
->err_data
[i
] = NULL
;
850 es
->err_data_flags
[i
] = 0;
851 } else if ((str
= OPENSSL_malloc(size
= 81)) == NULL
) {
859 arg
= va_arg(args
, char *);
867 p
= OPENSSL_realloc(str
, size
);
874 OPENSSL_strlcat(str
, arg
, (size_t)size
);
876 if (!err_set_error_data_int(str
, size
, flags
, 0))
880 void err_clear_last_constant_time(int clear
)
885 es
= ossl_err_get_state_int();
892 * Flag error as cleared but remove it elsewhere to avoid two errors
893 * accessing the same error stack location, revealing timing information.
895 clear
= constant_time_select_int(constant_time_eq_int(clear
, 0),
897 es
->err_flags
[top
] |= clear
;