Lines Matching full: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);
588 * then be added to the provider store.
594 /* Assumes that the store lock is held */
599 struct provider_store_st *store = prov->store;
603 max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
609 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
620 struct provider_store_st *store;
628 if ((store = get_provider_store(prov->libctx)) == NULL)
631 if (!CRYPTO_THREAD_write_lock(store->lock))
635 idx = sk_OSSL_PROVIDER_find(store->providers, &tmpl);
639 actualtmp = sk_OSSL_PROVIDER_value(store->providers, idx);
642 if (sk_OSSL_PROVIDER_push(store->providers, prov) == 0)
644 prov->store = store;
646 sk_OSSL_PROVIDER_delete_ptr(store->providers, prov);
650 store->use_fallbacks = 0;
653 CRYPTO_THREAD_unlock(store->lock);
666 * The provider is already in the store. Probably two threads
668 * name and raced to put them in the store. This thread lost. We
682 CRYPTO_THREAD_unlock(store->lock);
811 struct provider_store_st *store;
821 if ((store = get_provider_store(libctx)) != NULL
822 && CRYPTO_THREAD_write_lock(store->default_path_lock)) {
823 OPENSSL_free(store->default_path);
824 store->default_path = p;
825 CRYPTO_THREAD_unlock(store->default_path_lock);
833 * Internal version that doesn't affect the store flags, and thereby avoid
834 * locking. Direct callers must remember to set the store flags when
867 struct provider_store_st *store;
874 if ((store = get_provider_store(prov->libctx)) == NULL
875 || !CRYPTO_THREAD_read_lock(store->default_path_lock))
878 if (store->default_path != NULL) {
879 allocated_load_dir = OPENSSL_strdup(store->default_path);
880 CRYPTO_THREAD_unlock(store->default_path_lock);
887 CRYPTO_THREAD_unlock(store->default_path_lock);
1053 struct provider_store_st *store;
1063 * No need to lock if we've got no store because we've not been shared with
1066 store = get_provider_store(prov->libctx);
1067 if (store == NULL)
1070 if (lock && !CRYPTO_THREAD_read_lock(store->lock))
1073 CRYPTO_THREAD_unlock(store->lock);
1097 if (removechildren && store != NULL) {
1098 int i, max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
1102 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
1109 CRYPTO_THREAD_unlock(store->lock);
1127 struct provider_store_st *store;
1130 store = prov->store;
1132 * If the provider hasn't been added to the store, then we don't need
1135 if (store == NULL) {
1146 if (lock && !CRYPTO_THREAD_read_lock(store->lock)) {
1155 CRYPTO_THREAD_unlock(store->lock);
1166 if (prov->activatecnt == 1 && store != NULL) {
1171 CRYPTO_THREAD_unlock(store->lock);
1182 struct provider_store_st *store;
1185 if ((store = get_provider_store(prov->libctx)) == NULL)
1188 if (!CRYPTO_THREAD_read_lock(store->lock))
1190 freeing = store->freeing;
1191 CRYPTO_THREAD_unlock(store->lock);
1214 struct provider_store_st *store;
1217 if ((store = get_provider_store(prov->libctx)) == NULL)
1220 if (!CRYPTO_THREAD_read_lock(store->lock))
1222 freeing = store->freeing;
1223 CRYPTO_THREAD_unlock(store->lock);
1288 * This function only does something once when store->use_fallbacks == 1,
1289 * and then sets store->use_fallbacks = 0, so the second call and so on is
1292 static int provider_activate_fallbacks(struct provider_store_st *store)
1299 if (!CRYPTO_THREAD_read_lock(store->lock))
1301 use_fallbacks = store->use_fallbacks;
1302 CRYPTO_THREAD_unlock(store->lock);
1306 if (!CRYPTO_THREAD_write_lock(store->lock))
1309 use_fallbacks = store->use_fallbacks;
1311 CRYPTO_THREAD_unlock(store->lock);
1327 prov->libctx = store->libctx;
1333 * We are calling provider_activate while holding the store lock. This
1342 prov->store = store;
1343 if (sk_OSSL_PROVIDER_push(store->providers, prov) == 0) {
1351 store->use_fallbacks = 0;
1355 CRYPTO_THREAD_unlock(store->lock);
1365 struct provider_store_st *store = get_provider_store(ctx);
1377 if (store == NULL)
1379 if (!provider_activate_fallbacks(store))
1386 if (!CRYPTO_THREAD_read_lock(store->lock))
1388 provs = sk_OSSL_PROVIDER_dup(store->providers);
1390 CRYPTO_THREAD_unlock(store->lock);
1432 CRYPTO_THREAD_unlock(store->lock);
1451 CRYPTO_THREAD_unlock(store->lock);
1465 * to the provider in the store, so this should never drop to 0.
1482 struct provider_store_st *store = get_provider_store(libctx);
1484 if (store == NULL || !provider_activate_fallbacks(store))
1696 struct provider_store_st *store = NULL;
1700 if ((store = get_provider_store(libctx)) == NULL)
1703 if (!CRYPTO_THREAD_read_lock(store->lock))
1706 max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
1708 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
1712 CRYPTO_THREAD_unlock(store->lock);
1736 struct provider_store_st *store = NULL;
1741 if ((store = get_provider_store(libctx)) == NULL)
1753 if (!CRYPTO_THREAD_write_lock(store->lock)) {
1763 max = sk_OSSL_PROVIDER_num(store->providers);
1767 prov = sk_OSSL_PROVIDER_value(store->providers, i);
1774 * We hold the store lock while calling the user callback. This means
1780 * the store lock.
1787 ret = sk_OSSL_PROVIDER_CHILD_CB_push(store->child_cbs, child_cb);
1792 prov = sk_OSSL_PROVIDER_value(store->providers, i);
1798 CRYPTO_THREAD_unlock(store->lock);
1811 struct provider_store_st *store = NULL;
1815 if ((store = get_provider_store(libctx)) == NULL)
1818 if (!CRYPTO_THREAD_write_lock(store->lock))
1820 max = sk_OSSL_PROVIDER_CHILD_CB_num(store->child_cbs);
1822 child_cb = sk_OSSL_PROVIDER_CHILD_CB_value(store->child_cbs, i);
1825 sk_OSSL_PROVIDER_CHILD_CB_delete(store->child_cbs, i);
1830 CRYPTO_THREAD_unlock(store->lock);