Lines Matching refs:store
21 #include "crypto/store.h" /* ossl_store_loader_store_cache_flush */
52 * provider store. Each provider that exists in the parent provider store, has
53 * an associated child provider in the child library context's provider store.
84 * The store default_path_lock: Used to control access to the provider store's
87 * The store lock: Used to control the stack of provider's held within the
88 * provider store, as well as the stack of registered child provider callbacks.
102 * provider store lock, the provider flag_lock and the provider refcnt_lock.
105 * 1) provider store lock
115 * - It is permissible to hold the store and flag locks when calling child
160 struct provider_store_st *store; /* The store this instance belongs to */
208 * Provider Object store
211 * The Provider Object store is a library context object, and therefore needs
232 * Since this is only called when the provider store is being emptied, we
288 struct provider_store_st *store = vstore;
291 if (store == NULL)
293 store->freeing = 1;
294 OPENSSL_free(store->default_path);
295 sk_OSSL_PROVIDER_pop_free(store->providers, provider_deactivate_free);
297 sk_OSSL_PROVIDER_CHILD_CB_pop_free(store->child_cbs,
300 CRYPTO_THREAD_lock_free(store->default_path_lock);
301 CRYPTO_THREAD_lock_free(store->lock);
302 for (i = 0; i < store->numprovinfo; i++)
303 ossl_provider_info_clear(&store->provinfo[i]);
304 OPENSSL_free(store->provinfo);
305 OPENSSL_free(store);
310 struct provider_store_st *store = OPENSSL_zalloc(sizeof(*store));
312 if (store == NULL
313 || (store->providers = sk_OSSL_PROVIDER_new(ossl_provider_cmp)) == NULL
314 || (store->default_path_lock = CRYPTO_THREAD_lock_new()) == NULL
316 || (store->child_cbs = sk_OSSL_PROVIDER_CHILD_CB_new_null()) == NULL
318 || (store->lock = CRYPTO_THREAD_lock_new()) == NULL) {
319 provider_store_free(store);
322 store->libctx = ctx;
323 store->use_fallbacks = 1;
325 return store;
337 struct provider_store_st *store = NULL;
339 store = ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_PROVIDER_STORE_INDEX,
341 if (store == NULL)
343 return store;
348 struct provider_store_st *store;
350 if ((store = get_provider_store(libctx)) != NULL) {
351 if (!CRYPTO_THREAD_write_lock(store->lock))
353 store->use_fallbacks = 0;
354 CRYPTO_THREAD_unlock(store->lock);
365 struct provider_store_st *store = get_provider_store(libctx);
373 if (store == NULL) {
378 if (!CRYPTO_THREAD_write_lock(store->lock))
380 if (store->provinfosz == 0) {
381 store->provinfo = OPENSSL_zalloc(sizeof(*store->provinfo)
383 if (store->provinfo == NULL) {
387 store->provinfosz = BUILTINS_BLOCK_SIZE;
388 } else if (store->numprovinfo == store->provinfosz) {
390 size_t newsz = store->provinfosz + BUILTINS_BLOCK_SIZE;
392 tmpbuiltins = OPENSSL_realloc(store->provinfo,
393 sizeof(*store->provinfo) * newsz);
398 store->provinfo = tmpbuiltins;
399 store->provinfosz = newsz;
401 store->provinfo[store->numprovinfo] = *entry;
402 store->numprovinfo++;
406 CRYPTO_THREAD_unlock(store->lock);
413 struct provider_store_st *store = NULL;
416 if ((store = get_provider_store(libctx)) != NULL) {
436 if (!CRYPTO_THREAD_write_lock(store->lock))
438 if ((i = sk_OSSL_PROVIDER_find(store->providers, &tmpl)) != -1)
439 prov = sk_OSSL_PROVIDER_value(store->providers, i);
440 CRYPTO_THREAD_unlock(store->lock);
526 * We assume that the requested provider does not already exist in the store.
527 * The caller should check. If it does exist then adding it to the store later
534 struct provider_store_st *store = NULL;
538 if ((store = get_provider_store(libctx)) == NULL)
555 if (!CRYPTO_THREAD_read_lock(store->lock))
557 for (i = 0, p = store->provinfo; i < store->numprovinfo; p++, i++) {
563 CRYPTO_THREAD_unlock(store->lock);
581 * then be added to the provider store.
587 /* Assumes that the store lock is held */
592 struct provider_store_st *store = prov->store;
596 max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
602 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
613 struct provider_store_st *store;
621 if ((store = get_provider_store(prov->libctx)) == NULL)
624 if (!CRYPTO_THREAD_write_lock(store->lock))
628 idx = sk_OSSL_PROVIDER_find(store->providers, &tmpl);
632 actualtmp = sk_OSSL_PROVIDER_value(store->providers, idx);
635 if (sk_OSSL_PROVIDER_push(store->providers, prov) == 0)
637 prov->store = store;
639 sk_OSSL_PROVIDER_delete_ptr(store->providers, prov);
643 store->use_fallbacks = 0;
646 CRYPTO_THREAD_unlock(store->lock);
659 * The provider is already in the store. Probably two threads
661 * name and raced to put them in the store. This thread lost. We
675 CRYPTO_THREAD_unlock(store->lock);
804 struct provider_store_st *store;
814 if ((store = get_provider_store(libctx)) != NULL
815 && CRYPTO_THREAD_write_lock(store->default_path_lock)) {
816 OPENSSL_free(store->default_path);
817 store->default_path = p;
818 CRYPTO_THREAD_unlock(store->default_path_lock);
826 * Internal version that doesn't affect the store flags, and thereby avoid
827 * locking. Direct callers must remember to set the store flags when
860 struct provider_store_st *store;
867 if ((store = get_provider_store(prov->libctx)) == NULL
868 || !CRYPTO_THREAD_read_lock(store->default_path_lock))
871 if (store->default_path != NULL) {
872 allocated_load_dir = OPENSSL_strdup(store->default_path);
873 CRYPTO_THREAD_unlock(store->default_path_lock);
880 CRYPTO_THREAD_unlock(store->default_path_lock);
1044 struct provider_store_st *store;
1054 * No need to lock if we've got no store because we've not been shared with
1057 store = get_provider_store(prov->libctx);
1058 if (store == NULL)
1061 if (lock && !CRYPTO_THREAD_read_lock(store->lock))
1064 CRYPTO_THREAD_unlock(store->lock);
1088 if (removechildren && store != NULL) {
1089 int i, max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
1093 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
1100 CRYPTO_THREAD_unlock(store->lock);
1118 struct provider_store_st *store;
1121 store = prov->store;
1123 * If the provider hasn't been added to the store, then we don't need
1126 if (store == NULL) {
1137 if (lock && !CRYPTO_THREAD_read_lock(store->lock)) {
1146 CRYPTO_THREAD_unlock(store->lock);
1157 if (prov->activatecnt == 1 && store != NULL) {
1162 CRYPTO_THREAD_unlock(store->lock);
1173 struct provider_store_st *store;
1176 if ((store = get_provider_store(prov->libctx)) == NULL)
1179 if (!CRYPTO_THREAD_read_lock(store->lock))
1181 freeing = store->freeing;
1182 CRYPTO_THREAD_unlock(store->lock);
1205 struct provider_store_st *store;
1208 if ((store = get_provider_store(prov->libctx)) == NULL)
1211 if (!CRYPTO_THREAD_read_lock(store->lock))
1213 freeing = store->freeing;
1214 CRYPTO_THREAD_unlock(store->lock);
1279 * This function only does something once when store->use_fallbacks == 1,
1280 * and then sets store->use_fallbacks = 0, so the second call and so on is
1283 static int provider_activate_fallbacks(struct provider_store_st *store)
1290 if (!CRYPTO_THREAD_read_lock(store->lock))
1292 use_fallbacks = store->use_fallbacks;
1293 CRYPTO_THREAD_unlock(store->lock);
1297 if (!CRYPTO_THREAD_write_lock(store->lock))
1300 use_fallbacks = store->use_fallbacks;
1302 CRYPTO_THREAD_unlock(store->lock);
1318 prov->libctx = store->libctx;
1324 * We are calling provider_activate while holding the store lock. This
1333 prov->store = store;
1334 if (sk_OSSL_PROVIDER_push(store->providers, prov) == 0) {
1342 store->use_fallbacks = 0;
1346 CRYPTO_THREAD_unlock(store->lock);
1356 struct provider_store_st *store = get_provider_store(ctx);
1368 if (store == NULL)
1370 if (!provider_activate_fallbacks(store))
1377 if (!CRYPTO_THREAD_read_lock(store->lock))
1379 provs = sk_OSSL_PROVIDER_dup(store->providers);
1381 CRYPTO_THREAD_unlock(store->lock);
1423 CRYPTO_THREAD_unlock(store->lock);
1442 CRYPTO_THREAD_unlock(store->lock);
1456 * to the provider in the store, so this should never drop to 0.
1473 struct provider_store_st *store = get_provider_store(libctx);
1475 if (store == NULL || !provider_activate_fallbacks(store))
1687 struct provider_store_st *store = NULL;
1691 if ((store = get_provider_store(libctx)) == NULL)
1694 if (!CRYPTO_THREAD_read_lock(store->lock))
1697 max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
1699 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
1703 CRYPTO_THREAD_unlock(store->lock);
1727 struct provider_store_st *store = NULL;
1732 if ((store = get_provider_store(libctx)) == NULL)
1744 if (!CRYPTO_THREAD_write_lock(store->lock)) {
1754 max = sk_OSSL_PROVIDER_num(store->providers);
1758 prov = sk_OSSL_PROVIDER_value(store->providers, i);
1765 * We hold the store lock while calling the user callback. This means
1771 * the store lock.
1778 ret = sk_OSSL_PROVIDER_CHILD_CB_push(store->child_cbs, child_cb);
1783 prov = sk_OSSL_PROVIDER_value(store->providers, i);
1789 CRYPTO_THREAD_unlock(store->lock);
1802 struct provider_store_st *store = NULL;
1806 if ((store = get_provider_store(libctx)) == NULL)
1809 if (!CRYPTO_THREAD_write_lock(store->lock))
1811 max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
1813 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
1816 sk_OSSL_PROVIDER_CHILD_CB_delete(store->child_cbs, i);
1821 CRYPTO_THREAD_unlock(store->lock);