1 /*
2 * Copyright 2019-2025 The OpenSSL Project Authors. All Rights Reserved.
3 *
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
8 */
9
10 #include "crypto/cryptlib.h"
11 #include <openssl/conf.h>
12 #include <openssl/trace.h>
13 #include "internal/thread_once.h"
14 #include "internal/property.h"
15 #include "internal/cryptlib.h"
16 #include "internal/core.h"
17 #include "internal/bio.h"
18 #include "internal/provider.h"
19 #include "crypto/decoder.h"
20 #include "crypto/context.h"
21
22 struct ossl_lib_ctx_st {
23 CRYPTO_RWLOCK *lock;
24 OSSL_EX_DATA_GLOBAL global;
25
26 void *property_string_data;
27 void *evp_method_store;
28 void *provider_store;
29 void *namemap;
30 void *property_defns;
31 void *global_properties;
32 void *drbg;
33 void *drbg_nonce;
34 CRYPTO_THREAD_LOCAL rcu_local_key;
35 #ifndef FIPS_MODULE
36 void *provider_conf;
37 void *bio_core;
38 void *child_provider;
39 OSSL_METHOD_STORE *decoder_store;
40 void *decoder_cache;
41 OSSL_METHOD_STORE *encoder_store;
42 OSSL_METHOD_STORE *store_loader_store;
43 void *self_test_cb;
44 void *indicator_cb;
45 #endif
46 #if defined(OPENSSL_THREADS)
47 void *threads;
48 #endif
49 #ifdef FIPS_MODULE
50 void *thread_event_handler;
51 void *fips_prov;
52 #endif
53 STACK_OF(SSL_COMP) *comp_methods;
54
55 int ischild;
56 int conf_diagnostics;
57 };
58
ossl_lib_ctx_write_lock(OSSL_LIB_CTX * ctx)59 int ossl_lib_ctx_write_lock(OSSL_LIB_CTX *ctx)
60 {
61 if ((ctx = ossl_lib_ctx_get_concrete(ctx)) == NULL)
62 return 0;
63 return CRYPTO_THREAD_write_lock(ctx->lock);
64 }
65
ossl_lib_ctx_read_lock(OSSL_LIB_CTX * ctx)66 int ossl_lib_ctx_read_lock(OSSL_LIB_CTX *ctx)
67 {
68 if ((ctx = ossl_lib_ctx_get_concrete(ctx)) == NULL)
69 return 0;
70 return CRYPTO_THREAD_read_lock(ctx->lock);
71 }
72
ossl_lib_ctx_unlock(OSSL_LIB_CTX * ctx)73 int ossl_lib_ctx_unlock(OSSL_LIB_CTX *ctx)
74 {
75 if ((ctx = ossl_lib_ctx_get_concrete(ctx)) == NULL)
76 return 0;
77 return CRYPTO_THREAD_unlock(ctx->lock);
78 }
79
ossl_lib_ctx_is_child(OSSL_LIB_CTX * ctx)80 int ossl_lib_ctx_is_child(OSSL_LIB_CTX *ctx)
81 {
82 ctx = ossl_lib_ctx_get_concrete(ctx);
83
84 if (ctx == NULL)
85 return 0;
86 return ctx->ischild;
87 }
88
89 static void context_deinit_objs(OSSL_LIB_CTX *ctx);
90
context_init(OSSL_LIB_CTX * ctx)91 static int context_init(OSSL_LIB_CTX *ctx)
92 {
93 int exdata_done = 0;
94
95 if (!CRYPTO_THREAD_init_local(&ctx->rcu_local_key, NULL))
96 return 0;
97
98 ctx->lock = CRYPTO_THREAD_lock_new();
99 if (ctx->lock == NULL)
100 goto err;
101
102 /* Initialize ex_data. */
103 if (!ossl_do_ex_data_init(ctx))
104 goto err;
105 exdata_done = 1;
106
107 /* P2. We want evp_method_store to be cleaned up before the provider store */
108 ctx->evp_method_store = ossl_method_store_new(ctx);
109 if (ctx->evp_method_store == NULL)
110 goto err;
111 OSSL_TRACE1(QUERY, "context_init: allocating store %p\n", ctx->evp_method_store);
112
113 #ifndef FIPS_MODULE
114 /* P2. Must be freed before the provider store is freed */
115 ctx->provider_conf = ossl_prov_conf_ctx_new(ctx);
116 if (ctx->provider_conf == NULL)
117 goto err;
118 #endif
119
120 /* P2. */
121 ctx->drbg = ossl_rand_ctx_new(ctx);
122 if (ctx->drbg == NULL)
123 goto err;
124
125 #ifndef FIPS_MODULE
126 /*
127 * P2. We want decoder_store/decoder_cache to be cleaned up before the
128 * provider store
129 */
130 ctx->decoder_store = ossl_method_store_new(ctx);
131 if (ctx->decoder_store == NULL)
132 goto err;
133 ctx->decoder_cache = ossl_decoder_cache_new(ctx);
134 if (ctx->decoder_cache == NULL)
135 goto err;
136
137 /* P2. We want encoder_store to be cleaned up before the provider store */
138 ctx->encoder_store = ossl_method_store_new(ctx);
139 if (ctx->encoder_store == NULL)
140 goto err;
141
142 /* P2. We want loader_store to be cleaned up before the provider store */
143 ctx->store_loader_store = ossl_method_store_new(ctx);
144 if (ctx->store_loader_store == NULL)
145 goto err;
146 #endif
147
148 /* P1. Needs to be freed before the child provider data is freed */
149 ctx->provider_store = ossl_provider_store_new(ctx);
150 if (ctx->provider_store == NULL)
151 goto err;
152
153 /* Default priority. */
154 ctx->property_string_data = ossl_property_string_data_new(ctx);
155 if (ctx->property_string_data == NULL)
156 goto err;
157
158 ctx->namemap = ossl_stored_namemap_new(ctx);
159 if (ctx->namemap == NULL)
160 goto err;
161
162 ctx->property_defns = ossl_property_defns_new(ctx);
163 if (ctx->property_defns == NULL)
164 goto err;
165
166 ctx->global_properties = ossl_ctx_global_properties_new(ctx);
167 if (ctx->global_properties == NULL)
168 goto err;
169
170 #ifndef FIPS_MODULE
171 ctx->bio_core = ossl_bio_core_globals_new(ctx);
172 if (ctx->bio_core == NULL)
173 goto err;
174 #endif
175
176 ctx->drbg_nonce = ossl_prov_drbg_nonce_ctx_new(ctx);
177 if (ctx->drbg_nonce == NULL)
178 goto err;
179
180 #ifndef FIPS_MODULE
181 ctx->self_test_cb = ossl_self_test_set_callback_new(ctx);
182 if (ctx->self_test_cb == NULL)
183 goto err;
184 ctx->indicator_cb = ossl_indicator_set_callback_new(ctx);
185 if (ctx->indicator_cb == NULL)
186 goto err;
187 #endif
188
189 #ifdef FIPS_MODULE
190 ctx->thread_event_handler = ossl_thread_event_ctx_new(ctx);
191 if (ctx->thread_event_handler == NULL)
192 goto err;
193
194 ctx->fips_prov = ossl_fips_prov_ossl_ctx_new(ctx);
195 if (ctx->fips_prov == NULL)
196 goto err;
197 #endif
198
199 #ifndef OPENSSL_NO_THREAD_POOL
200 ctx->threads = ossl_threads_ctx_new(ctx);
201 if (ctx->threads == NULL)
202 goto err;
203 #endif
204
205 /* Low priority. */
206 #ifndef FIPS_MODULE
207 ctx->child_provider = ossl_child_prov_ctx_new(ctx);
208 if (ctx->child_provider == NULL)
209 goto err;
210 #endif
211
212 /* Everything depends on properties, so we also pre-initialise that */
213 if (!ossl_property_parse_init(ctx))
214 goto err;
215
216 #ifndef FIPS_MODULE
217 ctx->comp_methods = ossl_load_builtin_compressions();
218 #endif
219
220 return 1;
221
222 err:
223 context_deinit_objs(ctx);
224
225 if (exdata_done)
226 ossl_crypto_cleanup_all_ex_data_int(ctx);
227
228 CRYPTO_THREAD_lock_free(ctx->lock);
229 CRYPTO_THREAD_cleanup_local(&ctx->rcu_local_key);
230 memset(ctx, '\0', sizeof(*ctx));
231 return 0;
232 }
233
context_deinit_objs(OSSL_LIB_CTX * ctx)234 static void context_deinit_objs(OSSL_LIB_CTX *ctx)
235 {
236 /* P2. We want evp_method_store to be cleaned up before the provider store */
237 if (ctx->evp_method_store != NULL) {
238 ossl_method_store_free(ctx->evp_method_store);
239 ctx->evp_method_store = NULL;
240 }
241
242 /* P2. */
243 if (ctx->drbg != NULL) {
244 ossl_rand_ctx_free(ctx->drbg);
245 ctx->drbg = NULL;
246 }
247
248 #ifndef FIPS_MODULE
249 /* P2. */
250 if (ctx->provider_conf != NULL) {
251 ossl_prov_conf_ctx_free(ctx->provider_conf);
252 ctx->provider_conf = NULL;
253 }
254
255 /*
256 * P2. We want decoder_store/decoder_cache to be cleaned up before the
257 * provider store
258 */
259 if (ctx->decoder_store != NULL) {
260 ossl_method_store_free(ctx->decoder_store);
261 ctx->decoder_store = NULL;
262 }
263 if (ctx->decoder_cache != NULL) {
264 ossl_decoder_cache_free(ctx->decoder_cache);
265 ctx->decoder_cache = NULL;
266 }
267
268
269 /* P2. We want encoder_store to be cleaned up before the provider store */
270 if (ctx->encoder_store != NULL) {
271 ossl_method_store_free(ctx->encoder_store);
272 ctx->encoder_store = NULL;
273 }
274
275 /* P2. We want loader_store to be cleaned up before the provider store */
276 if (ctx->store_loader_store != NULL) {
277 ossl_method_store_free(ctx->store_loader_store);
278 ctx->store_loader_store = NULL;
279 }
280 #endif
281
282 /* P1. Needs to be freed before the child provider data is freed */
283 if (ctx->provider_store != NULL) {
284 ossl_provider_store_free(ctx->provider_store);
285 ctx->provider_store = NULL;
286 }
287
288 /* Default priority. */
289 if (ctx->property_string_data != NULL) {
290 ossl_property_string_data_free(ctx->property_string_data);
291 ctx->property_string_data = NULL;
292 }
293
294 if (ctx->namemap != NULL) {
295 ossl_stored_namemap_free(ctx->namemap);
296 ctx->namemap = NULL;
297 }
298
299 if (ctx->property_defns != NULL) {
300 ossl_property_defns_free(ctx->property_defns);
301 ctx->property_defns = NULL;
302 }
303
304 if (ctx->global_properties != NULL) {
305 ossl_ctx_global_properties_free(ctx->global_properties);
306 ctx->global_properties = NULL;
307 }
308
309 #ifndef FIPS_MODULE
310 if (ctx->bio_core != NULL) {
311 ossl_bio_core_globals_free(ctx->bio_core);
312 ctx->bio_core = NULL;
313 }
314 #endif
315
316 if (ctx->drbg_nonce != NULL) {
317 ossl_prov_drbg_nonce_ctx_free(ctx->drbg_nonce);
318 ctx->drbg_nonce = NULL;
319 }
320
321 #ifndef FIPS_MODULE
322 if (ctx->indicator_cb != NULL) {
323 ossl_indicator_set_callback_free(ctx->indicator_cb);
324 ctx->indicator_cb = NULL;
325 }
326
327 if (ctx->self_test_cb != NULL) {
328 ossl_self_test_set_callback_free(ctx->self_test_cb);
329 ctx->self_test_cb = NULL;
330 }
331 #endif
332
333 #ifdef FIPS_MODULE
334 if (ctx->thread_event_handler != NULL) {
335 ossl_thread_event_ctx_free(ctx->thread_event_handler);
336 ctx->thread_event_handler = NULL;
337 }
338
339 if (ctx->fips_prov != NULL) {
340 ossl_fips_prov_ossl_ctx_free(ctx->fips_prov);
341 ctx->fips_prov = NULL;
342 }
343 #endif
344
345 #ifndef OPENSSL_NO_THREAD_POOL
346 if (ctx->threads != NULL) {
347 ossl_threads_ctx_free(ctx->threads);
348 ctx->threads = NULL;
349 }
350 #endif
351
352 /* Low priority. */
353 #ifndef FIPS_MODULE
354 if (ctx->child_provider != NULL) {
355 ossl_child_prov_ctx_free(ctx->child_provider);
356 ctx->child_provider = NULL;
357 }
358 #endif
359
360 #ifndef FIPS_MODULE
361 if (ctx->comp_methods != NULL) {
362 ossl_free_compression_methods_int(ctx->comp_methods);
363 ctx->comp_methods = NULL;
364 }
365 #endif
366
367 }
368
context_deinit(OSSL_LIB_CTX * ctx)369 static int context_deinit(OSSL_LIB_CTX *ctx)
370 {
371 if (ctx == NULL)
372 return 1;
373
374 ossl_ctx_thread_stop(ctx);
375
376 context_deinit_objs(ctx);
377
378 ossl_crypto_cleanup_all_ex_data_int(ctx);
379
380 CRYPTO_THREAD_lock_free(ctx->lock);
381 ctx->lock = NULL;
382 CRYPTO_THREAD_cleanup_local(&ctx->rcu_local_key);
383 return 1;
384 }
385
386 #ifndef FIPS_MODULE
387 /* The default default context */
388 static OSSL_LIB_CTX default_context_int;
389
390 static CRYPTO_ONCE default_context_init = CRYPTO_ONCE_STATIC_INIT;
391 static CRYPTO_THREAD_LOCAL default_context_thread_local;
392 static int default_context_inited = 0;
393
DEFINE_RUN_ONCE_STATIC(default_context_do_init)394 DEFINE_RUN_ONCE_STATIC(default_context_do_init)
395 {
396 if (!CRYPTO_THREAD_init_local(&default_context_thread_local, NULL))
397 goto err;
398
399 if (!context_init(&default_context_int))
400 goto deinit_thread;
401
402 default_context_inited = 1;
403 return 1;
404
405 deinit_thread:
406 CRYPTO_THREAD_cleanup_local(&default_context_thread_local);
407 err:
408 return 0;
409 }
410
ossl_lib_ctx_default_deinit(void)411 void ossl_lib_ctx_default_deinit(void)
412 {
413 if (!default_context_inited)
414 return;
415 context_deinit(&default_context_int);
416 CRYPTO_THREAD_cleanup_local(&default_context_thread_local);
417 default_context_inited = 0;
418 }
419
get_thread_default_context(void)420 static OSSL_LIB_CTX *get_thread_default_context(void)
421 {
422 if (!RUN_ONCE(&default_context_init, default_context_do_init))
423 return NULL;
424
425 return CRYPTO_THREAD_get_local(&default_context_thread_local);
426 }
427
get_default_context(void)428 static OSSL_LIB_CTX *get_default_context(void)
429 {
430 OSSL_LIB_CTX *current_defctx = get_thread_default_context();
431
432 if (current_defctx == NULL && default_context_inited)
433 current_defctx = &default_context_int;
434 return current_defctx;
435 }
436
set_default_context(OSSL_LIB_CTX * defctx)437 static int set_default_context(OSSL_LIB_CTX *defctx)
438 {
439 if (defctx == &default_context_int)
440 defctx = NULL;
441
442 return CRYPTO_THREAD_set_local(&default_context_thread_local, defctx);
443 }
444 #endif
445
OSSL_LIB_CTX_new(void)446 OSSL_LIB_CTX *OSSL_LIB_CTX_new(void)
447 {
448 OSSL_LIB_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
449
450 if (ctx != NULL && !context_init(ctx)) {
451 OPENSSL_free(ctx);
452 ctx = NULL;
453 }
454 return ctx;
455 }
456
457 #ifndef FIPS_MODULE
OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in)458 OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE *handle,
459 const OSSL_DISPATCH *in)
460 {
461 OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new();
462
463 if (ctx == NULL)
464 return NULL;
465
466 if (!ossl_bio_init_core(ctx, in)) {
467 OSSL_LIB_CTX_free(ctx);
468 return NULL;
469 }
470
471 return ctx;
472 }
473
OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in)474 OSSL_LIB_CTX *OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE *handle,
475 const OSSL_DISPATCH *in)
476 {
477 OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new_from_dispatch(handle, in);
478
479 if (ctx == NULL)
480 return NULL;
481
482 if (!ossl_provider_init_as_child(ctx, handle, in)) {
483 OSSL_LIB_CTX_free(ctx);
484 return NULL;
485 }
486 ctx->ischild = 1;
487
488 return ctx;
489 }
490
OSSL_LIB_CTX_load_config(OSSL_LIB_CTX * ctx,const char * config_file)491 int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file)
492 {
493 return CONF_modules_load_file_ex(ctx, config_file, NULL, 0) > 0;
494 }
495 #endif
496
OSSL_LIB_CTX_free(OSSL_LIB_CTX * ctx)497 void OSSL_LIB_CTX_free(OSSL_LIB_CTX *ctx)
498 {
499 if (ctx == NULL || ossl_lib_ctx_is_default(ctx))
500 return;
501
502 #ifndef FIPS_MODULE
503 if (ctx->ischild)
504 ossl_provider_deinit_child(ctx);
505 #endif
506 context_deinit(ctx);
507 OPENSSL_free(ctx);
508 }
509
510 #ifndef FIPS_MODULE
OSSL_LIB_CTX_get0_global_default(void)511 OSSL_LIB_CTX *OSSL_LIB_CTX_get0_global_default(void)
512 {
513 if (!RUN_ONCE(&default_context_init, default_context_do_init))
514 return NULL;
515
516 return &default_context_int;
517 }
518
OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX * libctx)519 OSSL_LIB_CTX *OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX *libctx)
520 {
521 OSSL_LIB_CTX *current_defctx;
522
523 if ((current_defctx = get_default_context()) != NULL) {
524 if (libctx != NULL)
525 set_default_context(libctx);
526 return current_defctx;
527 }
528
529 return NULL;
530 }
531
ossl_release_default_drbg_ctx(void)532 void ossl_release_default_drbg_ctx(void)
533 {
534 /* early release of the DRBG in global default libctx */
535 if (default_context_int.drbg != NULL) {
536 ossl_rand_ctx_free(default_context_int.drbg);
537 default_context_int.drbg = NULL;
538 }
539 }
540 #endif
541
ossl_lib_ctx_get_concrete(OSSL_LIB_CTX * ctx)542 OSSL_LIB_CTX *ossl_lib_ctx_get_concrete(OSSL_LIB_CTX *ctx)
543 {
544 #ifndef FIPS_MODULE
545 if (ctx == NULL)
546 return get_default_context();
547 #endif
548 return ctx;
549 }
550
ossl_lib_ctx_is_default(OSSL_LIB_CTX * ctx)551 int ossl_lib_ctx_is_default(OSSL_LIB_CTX *ctx)
552 {
553 #ifndef FIPS_MODULE
554 if (ctx == NULL || ctx == get_default_context())
555 return 1;
556 #endif
557 return 0;
558 }
559
ossl_lib_ctx_is_global_default(OSSL_LIB_CTX * ctx)560 int ossl_lib_ctx_is_global_default(OSSL_LIB_CTX *ctx)
561 {
562 #ifndef FIPS_MODULE
563 if (ossl_lib_ctx_get_concrete(ctx) == &default_context_int)
564 return 1;
565 #endif
566 return 0;
567 }
568
ossl_lib_ctx_get_data(OSSL_LIB_CTX * ctx,int index)569 void *ossl_lib_ctx_get_data(OSSL_LIB_CTX *ctx, int index)
570 {
571 ctx = ossl_lib_ctx_get_concrete(ctx);
572 if (ctx == NULL)
573 return NULL;
574
575 switch (index) {
576 case OSSL_LIB_CTX_PROPERTY_STRING_INDEX:
577 return ctx->property_string_data;
578 case OSSL_LIB_CTX_EVP_METHOD_STORE_INDEX:
579 return ctx->evp_method_store;
580 case OSSL_LIB_CTX_PROVIDER_STORE_INDEX:
581 return ctx->provider_store;
582 case OSSL_LIB_CTX_NAMEMAP_INDEX:
583 return ctx->namemap;
584 case OSSL_LIB_CTX_PROPERTY_DEFN_INDEX:
585 return ctx->property_defns;
586 case OSSL_LIB_CTX_GLOBAL_PROPERTIES:
587 return ctx->global_properties;
588 case OSSL_LIB_CTX_DRBG_INDEX:
589 return ctx->drbg;
590 case OSSL_LIB_CTX_DRBG_NONCE_INDEX:
591 return ctx->drbg_nonce;
592 #ifndef FIPS_MODULE
593 case OSSL_LIB_CTX_PROVIDER_CONF_INDEX:
594 return ctx->provider_conf;
595 case OSSL_LIB_CTX_BIO_CORE_INDEX:
596 return ctx->bio_core;
597 case OSSL_LIB_CTX_CHILD_PROVIDER_INDEX:
598 return ctx->child_provider;
599 case OSSL_LIB_CTX_DECODER_STORE_INDEX:
600 return ctx->decoder_store;
601 case OSSL_LIB_CTX_DECODER_CACHE_INDEX:
602 return ctx->decoder_cache;
603 case OSSL_LIB_CTX_ENCODER_STORE_INDEX:
604 return ctx->encoder_store;
605 case OSSL_LIB_CTX_STORE_LOADER_STORE_INDEX:
606 return ctx->store_loader_store;
607 case OSSL_LIB_CTX_SELF_TEST_CB_INDEX:
608 return ctx->self_test_cb;
609 case OSSL_LIB_CTX_INDICATOR_CB_INDEX:
610 return ctx->indicator_cb;
611 #endif
612 #ifndef OPENSSL_NO_THREAD_POOL
613 case OSSL_LIB_CTX_THREAD_INDEX:
614 return ctx->threads;
615 #endif
616
617 #ifdef FIPS_MODULE
618 case OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX:
619 return ctx->thread_event_handler;
620
621 case OSSL_LIB_CTX_FIPS_PROV_INDEX:
622 return ctx->fips_prov;
623 #endif
624
625 case OSSL_LIB_CTX_COMP_METHODS:
626 return (void *)&ctx->comp_methods;
627
628 default:
629 return NULL;
630 }
631 }
632
OSSL_LIB_CTX_get_data(OSSL_LIB_CTX * ctx,int index)633 void *OSSL_LIB_CTX_get_data(OSSL_LIB_CTX *ctx, int index)
634 {
635 return ossl_lib_ctx_get_data(ctx, index);
636 }
637
ossl_lib_ctx_get_ex_data_global(OSSL_LIB_CTX * ctx)638 OSSL_EX_DATA_GLOBAL *ossl_lib_ctx_get_ex_data_global(OSSL_LIB_CTX *ctx)
639 {
640 ctx = ossl_lib_ctx_get_concrete(ctx);
641 if (ctx == NULL)
642 return NULL;
643 return &ctx->global;
644 }
645
ossl_lib_ctx_get_descriptor(OSSL_LIB_CTX * libctx)646 const char *ossl_lib_ctx_get_descriptor(OSSL_LIB_CTX *libctx)
647 {
648 #ifdef FIPS_MODULE
649 return "FIPS internal library context";
650 #else
651 if (ossl_lib_ctx_is_global_default(libctx))
652 return "Global default library context";
653 if (ossl_lib_ctx_is_default(libctx))
654 return "Thread-local default library context";
655 return "Non-default library context";
656 #endif
657 }
658
ossl_lib_ctx_get_rcukey(OSSL_LIB_CTX * libctx)659 CRYPTO_THREAD_LOCAL *ossl_lib_ctx_get_rcukey(OSSL_LIB_CTX *libctx)
660 {
661 libctx = ossl_lib_ctx_get_concrete(libctx);
662 if (libctx == NULL)
663 return NULL;
664 return &libctx->rcu_local_key;
665 }
666
OSSL_LIB_CTX_get_conf_diagnostics(OSSL_LIB_CTX * libctx)667 int OSSL_LIB_CTX_get_conf_diagnostics(OSSL_LIB_CTX *libctx)
668 {
669 libctx = ossl_lib_ctx_get_concrete(libctx);
670 if (libctx == NULL)
671 return 0;
672 return libctx->conf_diagnostics;
673 }
674
OSSL_LIB_CTX_set_conf_diagnostics(OSSL_LIB_CTX * libctx,int value)675 void OSSL_LIB_CTX_set_conf_diagnostics(OSSL_LIB_CTX *libctx, int value)
676 {
677 libctx = ossl_lib_ctx_get_concrete(libctx);
678 if (libctx == NULL)
679 return;
680 libctx->conf_diagnostics = value;
681 }
682