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 /* P2. We want encoder_store to be cleaned up before the provider store */
269 if (ctx->encoder_store != NULL) {
270 ossl_method_store_free(ctx->encoder_store);
271 ctx->encoder_store = NULL;
272 }
273
274 /* P2. We want loader_store to be cleaned up before the provider store */
275 if (ctx->store_loader_store != NULL) {
276 ossl_method_store_free(ctx->store_loader_store);
277 ctx->store_loader_store = NULL;
278 }
279 #endif
280
281 /* P1. Needs to be freed before the child provider data is freed */
282 if (ctx->provider_store != NULL) {
283 ossl_provider_store_free(ctx->provider_store);
284 ctx->provider_store = NULL;
285 }
286
287 /* Default priority. */
288 if (ctx->property_string_data != NULL) {
289 ossl_property_string_data_free(ctx->property_string_data);
290 ctx->property_string_data = NULL;
291 }
292
293 if (ctx->namemap != NULL) {
294 ossl_stored_namemap_free(ctx->namemap);
295 ctx->namemap = NULL;
296 }
297
298 if (ctx->property_defns != NULL) {
299 ossl_property_defns_free(ctx->property_defns);
300 ctx->property_defns = NULL;
301 }
302
303 if (ctx->global_properties != NULL) {
304 ossl_ctx_global_properties_free(ctx->global_properties);
305 ctx->global_properties = NULL;
306 }
307
308 #ifndef FIPS_MODULE
309 if (ctx->bio_core != NULL) {
310 ossl_bio_core_globals_free(ctx->bio_core);
311 ctx->bio_core = NULL;
312 }
313 #endif
314
315 if (ctx->drbg_nonce != NULL) {
316 ossl_prov_drbg_nonce_ctx_free(ctx->drbg_nonce);
317 ctx->drbg_nonce = NULL;
318 }
319
320 #ifndef FIPS_MODULE
321 if (ctx->indicator_cb != NULL) {
322 ossl_indicator_set_callback_free(ctx->indicator_cb);
323 ctx->indicator_cb = NULL;
324 }
325
326 if (ctx->self_test_cb != NULL) {
327 ossl_self_test_set_callback_free(ctx->self_test_cb);
328 ctx->self_test_cb = NULL;
329 }
330 #endif
331
332 #ifdef FIPS_MODULE
333 if (ctx->thread_event_handler != NULL) {
334 ossl_thread_event_ctx_free(ctx->thread_event_handler);
335 ctx->thread_event_handler = NULL;
336 }
337
338 if (ctx->fips_prov != NULL) {
339 ossl_fips_prov_ossl_ctx_free(ctx->fips_prov);
340 ctx->fips_prov = NULL;
341 }
342 #endif
343
344 #ifndef OPENSSL_NO_THREAD_POOL
345 if (ctx->threads != NULL) {
346 ossl_threads_ctx_free(ctx->threads);
347 ctx->threads = NULL;
348 }
349 #endif
350
351 /* Low priority. */
352 #ifndef FIPS_MODULE
353 if (ctx->child_provider != NULL) {
354 ossl_child_prov_ctx_free(ctx->child_provider);
355 ctx->child_provider = NULL;
356 }
357 #endif
358
359 #ifndef FIPS_MODULE
360 if (ctx->comp_methods != NULL) {
361 ossl_free_compression_methods_int(ctx->comp_methods);
362 ctx->comp_methods = NULL;
363 }
364 #endif
365 }
366
context_deinit(OSSL_LIB_CTX * ctx)367 static int context_deinit(OSSL_LIB_CTX *ctx)
368 {
369 if (ctx == NULL)
370 return 1;
371
372 ossl_ctx_thread_stop(ctx);
373
374 context_deinit_objs(ctx);
375
376 ossl_crypto_cleanup_all_ex_data_int(ctx);
377
378 CRYPTO_THREAD_lock_free(ctx->lock);
379 ctx->lock = NULL;
380 CRYPTO_THREAD_cleanup_local(&ctx->rcu_local_key);
381 return 1;
382 }
383
384 #ifndef FIPS_MODULE
385 /* The default default context */
386 static OSSL_LIB_CTX default_context_int;
387
388 static CRYPTO_ONCE default_context_init = CRYPTO_ONCE_STATIC_INIT;
389 static CRYPTO_THREAD_LOCAL default_context_thread_local;
390 static int default_context_inited = 0;
391
DEFINE_RUN_ONCE_STATIC(default_context_do_init)392 DEFINE_RUN_ONCE_STATIC(default_context_do_init)
393 {
394 if (!CRYPTO_THREAD_init_local(&default_context_thread_local, NULL))
395 goto err;
396
397 if (!context_init(&default_context_int))
398 goto deinit_thread;
399
400 default_context_inited = 1;
401 return 1;
402
403 deinit_thread:
404 CRYPTO_THREAD_cleanup_local(&default_context_thread_local);
405 err:
406 return 0;
407 }
408
ossl_lib_ctx_default_deinit(void)409 void ossl_lib_ctx_default_deinit(void)
410 {
411 if (!default_context_inited)
412 return;
413 context_deinit(&default_context_int);
414 CRYPTO_THREAD_cleanup_local(&default_context_thread_local);
415 default_context_inited = 0;
416 }
417
get_thread_default_context(void)418 static OSSL_LIB_CTX *get_thread_default_context(void)
419 {
420 if (!RUN_ONCE(&default_context_init, default_context_do_init))
421 return NULL;
422
423 return CRYPTO_THREAD_get_local(&default_context_thread_local);
424 }
425
get_default_context(void)426 static OSSL_LIB_CTX *get_default_context(void)
427 {
428 OSSL_LIB_CTX *current_defctx = get_thread_default_context();
429
430 if (current_defctx == NULL && default_context_inited)
431 current_defctx = &default_context_int;
432 return current_defctx;
433 }
434
set_default_context(OSSL_LIB_CTX * defctx)435 static int set_default_context(OSSL_LIB_CTX *defctx)
436 {
437 if (defctx == &default_context_int)
438 defctx = NULL;
439
440 return CRYPTO_THREAD_set_local(&default_context_thread_local, defctx);
441 }
442 #endif
443
OSSL_LIB_CTX_new(void)444 OSSL_LIB_CTX *OSSL_LIB_CTX_new(void)
445 {
446 OSSL_LIB_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
447
448 if (ctx != NULL && !context_init(ctx)) {
449 OPENSSL_free(ctx);
450 ctx = NULL;
451 }
452 return ctx;
453 }
454
455 #ifndef FIPS_MODULE
OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in)456 OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE *handle,
457 const OSSL_DISPATCH *in)
458 {
459 OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new();
460
461 if (ctx == NULL)
462 return NULL;
463
464 if (!ossl_bio_init_core(ctx, in)) {
465 OSSL_LIB_CTX_free(ctx);
466 return NULL;
467 }
468
469 return ctx;
470 }
471
OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in)472 OSSL_LIB_CTX *OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE *handle,
473 const OSSL_DISPATCH *in)
474 {
475 OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new_from_dispatch(handle, in);
476
477 if (ctx == NULL)
478 return NULL;
479
480 if (!ossl_provider_init_as_child(ctx, handle, in)) {
481 OSSL_LIB_CTX_free(ctx);
482 return NULL;
483 }
484 ctx->ischild = 1;
485
486 return ctx;
487 }
488
OSSL_LIB_CTX_load_config(OSSL_LIB_CTX * ctx,const char * config_file)489 int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file)
490 {
491 return CONF_modules_load_file_ex(ctx, config_file, NULL, 0) > 0;
492 }
493 #endif
494
OSSL_LIB_CTX_free(OSSL_LIB_CTX * ctx)495 void OSSL_LIB_CTX_free(OSSL_LIB_CTX *ctx)
496 {
497 if (ctx == NULL || ossl_lib_ctx_is_default(ctx))
498 return;
499
500 #ifndef FIPS_MODULE
501 if (ctx->ischild)
502 ossl_provider_deinit_child(ctx);
503 #endif
504 context_deinit(ctx);
505 OPENSSL_free(ctx);
506 }
507
508 #ifndef FIPS_MODULE
OSSL_LIB_CTX_get0_global_default(void)509 OSSL_LIB_CTX *OSSL_LIB_CTX_get0_global_default(void)
510 {
511 if (!RUN_ONCE(&default_context_init, default_context_do_init))
512 return NULL;
513
514 return &default_context_int;
515 }
516
OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX * libctx)517 OSSL_LIB_CTX *OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX *libctx)
518 {
519 OSSL_LIB_CTX *current_defctx;
520
521 if ((current_defctx = get_default_context()) != NULL) {
522 if (libctx != NULL)
523 set_default_context(libctx);
524 return current_defctx;
525 }
526
527 return NULL;
528 }
529
ossl_release_default_drbg_ctx(void)530 void ossl_release_default_drbg_ctx(void)
531 {
532 /* early release of the DRBG in global default libctx */
533 if (default_context_int.drbg != NULL) {
534 ossl_rand_ctx_free(default_context_int.drbg);
535 default_context_int.drbg = NULL;
536 }
537 }
538 #endif
539
ossl_lib_ctx_get_concrete(OSSL_LIB_CTX * ctx)540 OSSL_LIB_CTX *ossl_lib_ctx_get_concrete(OSSL_LIB_CTX *ctx)
541 {
542 #ifndef FIPS_MODULE
543 if (ctx == NULL)
544 return get_default_context();
545 #endif
546 return ctx;
547 }
548
ossl_lib_ctx_is_default(OSSL_LIB_CTX * ctx)549 int ossl_lib_ctx_is_default(OSSL_LIB_CTX *ctx)
550 {
551 #ifndef FIPS_MODULE
552 if (ctx == NULL || ctx == get_default_context())
553 return 1;
554 #endif
555 return 0;
556 }
557
ossl_lib_ctx_is_global_default(OSSL_LIB_CTX * ctx)558 int ossl_lib_ctx_is_global_default(OSSL_LIB_CTX *ctx)
559 {
560 #ifndef FIPS_MODULE
561 if (ossl_lib_ctx_get_concrete(ctx) == &default_context_int)
562 return 1;
563 #endif
564 return 0;
565 }
566
ossl_lib_ctx_get_data(OSSL_LIB_CTX * ctx,int index)567 void *ossl_lib_ctx_get_data(OSSL_LIB_CTX *ctx, int index)
568 {
569 ctx = ossl_lib_ctx_get_concrete(ctx);
570 if (ctx == NULL)
571 return NULL;
572
573 switch (index) {
574 case OSSL_LIB_CTX_PROPERTY_STRING_INDEX:
575 return ctx->property_string_data;
576 case OSSL_LIB_CTX_EVP_METHOD_STORE_INDEX:
577 return ctx->evp_method_store;
578 case OSSL_LIB_CTX_PROVIDER_STORE_INDEX:
579 return ctx->provider_store;
580 case OSSL_LIB_CTX_NAMEMAP_INDEX:
581 return ctx->namemap;
582 case OSSL_LIB_CTX_PROPERTY_DEFN_INDEX:
583 return ctx->property_defns;
584 case OSSL_LIB_CTX_GLOBAL_PROPERTIES:
585 return ctx->global_properties;
586 case OSSL_LIB_CTX_DRBG_INDEX:
587 return ctx->drbg;
588 case OSSL_LIB_CTX_DRBG_NONCE_INDEX:
589 return ctx->drbg_nonce;
590 #ifndef FIPS_MODULE
591 case OSSL_LIB_CTX_PROVIDER_CONF_INDEX:
592 return ctx->provider_conf;
593 case OSSL_LIB_CTX_BIO_CORE_INDEX:
594 return ctx->bio_core;
595 case OSSL_LIB_CTX_CHILD_PROVIDER_INDEX:
596 return ctx->child_provider;
597 case OSSL_LIB_CTX_DECODER_STORE_INDEX:
598 return ctx->decoder_store;
599 case OSSL_LIB_CTX_DECODER_CACHE_INDEX:
600 return ctx->decoder_cache;
601 case OSSL_LIB_CTX_ENCODER_STORE_INDEX:
602 return ctx->encoder_store;
603 case OSSL_LIB_CTX_STORE_LOADER_STORE_INDEX:
604 return ctx->store_loader_store;
605 case OSSL_LIB_CTX_SELF_TEST_CB_INDEX:
606 return ctx->self_test_cb;
607 case OSSL_LIB_CTX_INDICATOR_CB_INDEX:
608 return ctx->indicator_cb;
609 #endif
610 #ifndef OPENSSL_NO_THREAD_POOL
611 case OSSL_LIB_CTX_THREAD_INDEX:
612 return ctx->threads;
613 #endif
614
615 #ifdef FIPS_MODULE
616 case OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX:
617 return ctx->thread_event_handler;
618
619 case OSSL_LIB_CTX_FIPS_PROV_INDEX:
620 return ctx->fips_prov;
621 #endif
622
623 case OSSL_LIB_CTX_COMP_METHODS:
624 return (void *)&ctx->comp_methods;
625
626 default:
627 return NULL;
628 }
629 }
630
OSSL_LIB_CTX_get_data(OSSL_LIB_CTX * ctx,int index)631 void *OSSL_LIB_CTX_get_data(OSSL_LIB_CTX *ctx, int index)
632 {
633 return ossl_lib_ctx_get_data(ctx, index);
634 }
635
ossl_lib_ctx_get_ex_data_global(OSSL_LIB_CTX * ctx)636 OSSL_EX_DATA_GLOBAL *ossl_lib_ctx_get_ex_data_global(OSSL_LIB_CTX *ctx)
637 {
638 ctx = ossl_lib_ctx_get_concrete(ctx);
639 if (ctx == NULL)
640 return NULL;
641 return &ctx->global;
642 }
643
ossl_lib_ctx_get_descriptor(OSSL_LIB_CTX * libctx)644 const char *ossl_lib_ctx_get_descriptor(OSSL_LIB_CTX *libctx)
645 {
646 #ifdef FIPS_MODULE
647 return "FIPS internal library context";
648 #else
649 if (ossl_lib_ctx_is_global_default(libctx))
650 return "Global default library context";
651 if (ossl_lib_ctx_is_default(libctx))
652 return "Thread-local default library context";
653 return "Non-default library context";
654 #endif
655 }
656
ossl_lib_ctx_get_rcukey(OSSL_LIB_CTX * libctx)657 CRYPTO_THREAD_LOCAL *ossl_lib_ctx_get_rcukey(OSSL_LIB_CTX *libctx)
658 {
659 libctx = ossl_lib_ctx_get_concrete(libctx);
660 if (libctx == NULL)
661 return NULL;
662 return &libctx->rcu_local_key;
663 }
664
OSSL_LIB_CTX_get_conf_diagnostics(OSSL_LIB_CTX * libctx)665 int OSSL_LIB_CTX_get_conf_diagnostics(OSSL_LIB_CTX *libctx)
666 {
667 libctx = ossl_lib_ctx_get_concrete(libctx);
668 if (libctx == NULL)
669 return 0;
670 return libctx->conf_diagnostics;
671 }
672
OSSL_LIB_CTX_set_conf_diagnostics(OSSL_LIB_CTX * libctx,int value)673 void OSSL_LIB_CTX_set_conf_diagnostics(OSSL_LIB_CTX *libctx, int value)
674 {
675 libctx = ossl_lib_ctx_get_concrete(libctx);
676 if (libctx == NULL)
677 return;
678 libctx->conf_diagnostics = value;
679 }
680