if (cipher == NULL)
return NULL;
- cipher->lock = CRYPTO_THREAD_lock_new();
- if (cipher->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
+ if (!CRYPTO_NEW_REF(&cipher->refcnt, 1)) {
OPENSSL_free(cipher);
return NULL;
}
cipher->prov = prov;
ossl_provider_up_ref(prov);
- cipher->refcnt = 1;
return cipher;
}
if (cipher == NULL)
return;
- CRYPTO_DOWN_REF(&cipher->refcnt, &i, cipher->lock);
+ CRYPTO_DOWN_REF(&cipher->refcnt, &i);
if (i > 0)
return;
OPENSSL_free(cipher->type_name);
ossl_provider_free(cipher->prov);
- CRYPTO_THREAD_lock_free(cipher->lock);
+ CRYPTO_FREE_REF(&cipher->refcnt);
OPENSSL_free(cipher);
}
{
int ref = 0;
- CRYPTO_UP_REF(&cipher->refcnt, &ref, cipher->lock);
+ CRYPTO_UP_REF(&cipher->refcnt, &ref);
return 1;
}
if ((to = EVP_CIPHER_meth_new(cipher->nid, cipher->block_size,
cipher->key_len)) != NULL) {
- CRYPTO_RWLOCK *lock = to->lock;
+ CRYPTO_REF_COUNT refcnt = to->refcnt;
memcpy(to, cipher, sizeof(*to));
- to->lock = lock;
+ to->refcnt = refcnt;
to->origin = EVP_ORIG_METH;
}
return to;
{
EVP_MD *md = OPENSSL_zalloc(sizeof(*md));
- if (md != NULL) {
- md->lock = CRYPTO_THREAD_lock_new();
- if (md->lock == NULL) {
- OPENSSL_free(md);
- return NULL;
- }
- md->refcnt = 1;
+ if (md != NULL && !CRYPTO_NEW_REF(&md->refcnt, 1)) {
+ OPENSSL_free(md);
+ return NULL;
}
return md;
}
int ref = 0;
if (md->origin == EVP_ORIG_DYNAMIC)
- CRYPTO_UP_REF(&md->refcnt, &ref, md->lock);
+ CRYPTO_UP_REF(&md->refcnt, &ref);
return 1;
}
if (md == NULL || md->origin != EVP_ORIG_DYNAMIC)
return;
- CRYPTO_DOWN_REF(&md->refcnt, &i, md->lock);
+ CRYPTO_DOWN_REF(&md->refcnt, &i);
if (i > 0)
return;
evp_md_free_int(md);
{
EVP_CIPHER *cipher = OPENSSL_zalloc(sizeof(EVP_CIPHER));
- if (cipher != NULL) {
- cipher->lock = CRYPTO_THREAD_lock_new();
- if (cipher->lock == NULL) {
- OPENSSL_free(cipher);
- return NULL;
- }
- cipher->refcnt = 1;
+ if (cipher != NULL && !CRYPTO_NEW_REF(&cipher->refcnt, 1)) {
+ OPENSSL_free(cipher);
+ return NULL;
}
return cipher;
}
int ref = 0;
if (cipher->origin == EVP_ORIG_DYNAMIC)
- CRYPTO_UP_REF(&cipher->refcnt, &ref, cipher->lock);
+ CRYPTO_UP_REF(&cipher->refcnt, &ref);
return 1;
}
{
OPENSSL_free(cipher->type_name);
ossl_provider_free(cipher->prov);
- CRYPTO_THREAD_lock_free(cipher->lock);
+ CRYPTO_FREE_REF(&cipher->refcnt);
OPENSSL_free(cipher);
}
if (cipher == NULL || cipher->origin != EVP_ORIG_DYNAMIC)
return;
- CRYPTO_DOWN_REF(&cipher->refcnt, &i, cipher->lock);
+ CRYPTO_DOWN_REF(&cipher->refcnt, &i);
if (i > 0)
return;
evp_cipher_free_int(cipher);
return NULL;
if ((to = EVP_MD_meth_new(md->type, md->pkey_type)) != NULL) {
- CRYPTO_RWLOCK *lock = to->lock;
+ CRYPTO_REF_COUNT refcnt = to->refcnt;
memcpy(to, md, sizeof(*to));
- to->lock = lock;
+ to->refcnt = refcnt;
to->origin = EVP_ORIG_METH;
}
return to;
{
OPENSSL_free(md->type_name);
ossl_provider_free(md->prov);
- CRYPTO_THREAD_lock_free(md->lock);
+ CRYPTO_FREE_REF(&md->refcnt);
OPENSSL_free(md);
}
const char *description;
OSSL_PROVIDER *prov;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
/* Constructor(s), destructor, information */
OSSL_FUNC_keymgmt_new_fn *new;
const char *description;
OSSL_PROVIDER *prov;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_keyexch_newctx_fn *newctx;
OSSL_FUNC_keyexch_init_fn *init;
const char *description;
OSSL_PROVIDER *prov;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_signature_newctx_fn *newctx;
OSSL_FUNC_signature_sign_init_fn *sign_init;
const char *description;
OSSL_PROVIDER *prov;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_asym_cipher_newctx_fn *newctx;
OSSL_FUNC_asym_cipher_encrypt_init_fn *encrypt_init;
const char *description;
OSSL_PROVIDER *prov;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_kem_newctx_fn *newctx;
OSSL_FUNC_kem_encapsulate_init_fn *encapsulate_init;
char *type_name;
const char *description;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *refcnt_lock;
const OSSL_DISPATCH *dispatch;
OSSL_FUNC_rand_newctx_fn *newctx;
int ref = 0;
if (rand != NULL)
- return CRYPTO_UP_REF(&rand->refcnt, &ref, rand->refcnt_lock);
+ return CRYPTO_UP_REF(&rand->refcnt, &ref);
return 1;
}
if (rand == NULL)
return;
- CRYPTO_DOWN_REF(&rand->refcnt, &ref, rand->refcnt_lock);
+ CRYPTO_DOWN_REF(&rand->refcnt, &ref);
if (ref > 0)
return;
OPENSSL_free(rand->type_name);
ossl_provider_free(rand->prov);
- CRYPTO_THREAD_lock_free(rand->refcnt_lock);
+ CRYPTO_FREE_REF(&rand->refcnt);
OPENSSL_free(rand);
}
{
EVP_RAND *rand = OPENSSL_zalloc(sizeof(*rand));
- if (rand == NULL
- || (rand->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ if (rand == NULL || !CRYPTO_NEW_REF(&rand->refcnt, 1)) {
OPENSSL_free(rand);
return NULL;
}
- rand->refcnt = 1;
return rand;
}
{
int ref = 0;
- return CRYPTO_UP_REF(&ctx->refcnt, &ref, ctx->refcnt_lock);
+ return CRYPTO_UP_REF(&ctx->refcnt, &ref);
}
EVP_RAND_CTX *EVP_RAND_CTX_new(EVP_RAND *rand, EVP_RAND_CTX *parent)
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx == NULL)
return NULL;
- if ((ctx->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ if (!CRYPTO_NEW_REF(&ctx->refcnt, 1)) {
OPENSSL_free(ctx);
- ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
return NULL;
}
if (parent != NULL) {
if (!EVP_RAND_CTX_up_ref(parent)) {
ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
- CRYPTO_THREAD_lock_free(ctx->refcnt_lock);
+ CRYPTO_FREE_REF(&ctx->refcnt);
OPENSSL_free(ctx);
return NULL;
}
|| !EVP_RAND_up_ref(rand)) {
ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
rand->freectx(ctx->algctx);
- CRYPTO_THREAD_lock_free(ctx->refcnt_lock);
+ CRYPTO_FREE_REF(&ctx->refcnt);
OPENSSL_free(ctx);
EVP_RAND_CTX_free(parent);
return NULL;
}
ctx->meth = rand;
ctx->parent = parent;
- ctx->refcnt = 1;
return ctx;
}
if (ctx == NULL)
return;
- CRYPTO_DOWN_REF(&ctx->refcnt, &ref, ctx->refcnt_lock);
+ CRYPTO_DOWN_REF(&ctx->refcnt, &ref);
if (ref > 0)
return;
parent = ctx->parent;
ctx->meth->freectx(ctx->algctx);
ctx->algctx = NULL;
EVP_RAND_free(ctx->meth);
- CRYPTO_THREAD_lock_free(ctx->refcnt_lock);
+ CRYPTO_FREE_REF(&ctx->refcnt);
OPENSSL_free(ctx);
EVP_RAND_CTX_free(parent);
}
if (exchange == NULL)
return NULL;
- exchange->lock = CRYPTO_THREAD_lock_new();
- if (exchange->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
+ if (!CRYPTO_NEW_REF(&exchange->refcnt, 1)) {
OPENSSL_free(exchange);
return NULL;
}
exchange->prov = prov;
ossl_provider_up_ref(prov);
- exchange->refcnt = 1;
return exchange;
}
if (exchange == NULL)
return;
- CRYPTO_DOWN_REF(&exchange->refcnt, &i, exchange->lock);
+ CRYPTO_DOWN_REF(&exchange->refcnt, &i);
if (i > 0)
return;
OPENSSL_free(exchange->type_name);
ossl_provider_free(exchange->prov);
- CRYPTO_THREAD_lock_free(exchange->lock);
+ CRYPTO_FREE_REF(&exchange->refcnt);
OPENSSL_free(exchange);
}
{
int ref = 0;
- CRYPTO_UP_REF(&exchange->refcnt, &ref, exchange->lock);
+ CRYPTO_UP_REF(&exchange->refcnt, &ref);
return 1;
}
EVP_KDF *kdf = (EVP_KDF *)vkdf;
int ref = 0;
- CRYPTO_UP_REF(&kdf->refcnt, &ref, kdf->lock);
+ CRYPTO_UP_REF(&kdf->refcnt, &ref);
return 1;
}
if (kdf == NULL)
return;
- CRYPTO_DOWN_REF(&kdf->refcnt, &ref, kdf->lock);
+ CRYPTO_DOWN_REF(&kdf->refcnt, &ref);
if (ref > 0)
return;
OPENSSL_free(kdf->type_name);
ossl_provider_free(kdf->prov);
- CRYPTO_THREAD_lock_free(kdf->lock);
+ CRYPTO_FREE_REF(&kdf->refcnt);
OPENSSL_free(kdf);
}
EVP_KDF *kdf = NULL;
if ((kdf = OPENSSL_zalloc(sizeof(*kdf))) == NULL
- || (kdf->lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ || !CRYPTO_NEW_REF(&kdf->refcnt, 1)) {
OPENSSL_free(kdf);
return NULL;
}
- kdf->refcnt = 1;
return kdf;
}
if (kem == NULL)
return NULL;
- kem->lock = CRYPTO_THREAD_lock_new();
- if (kem->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
+ if (!CRYPTO_NEW_REF(&kem->refcnt, 1)) {
OPENSSL_free(kem);
return NULL;
}
kem->prov = prov;
ossl_provider_up_ref(prov);
- kem->refcnt = 1;
return kem;
}
if (kem == NULL)
return;
- CRYPTO_DOWN_REF(&kem->refcnt, &i, kem->lock);
+ CRYPTO_DOWN_REF(&kem->refcnt, &i);
if (i > 0)
return;
OPENSSL_free(kem->type_name);
ossl_provider_free(kem->prov);
- CRYPTO_THREAD_lock_free(kem->lock);
+ CRYPTO_FREE_REF(&kem->refcnt);
OPENSSL_free(kem);
}
{
int ref = 0;
- CRYPTO_UP_REF(&kem->refcnt, &ref, kem->lock);
+ CRYPTO_UP_REF(&kem->refcnt, &ref);
return 1;
}
if ((keymgmt = OPENSSL_zalloc(sizeof(*keymgmt))) == NULL)
return NULL;
- if ((keymgmt->lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ if (!CRYPTO_NEW_REF(&keymgmt->refcnt, 1)) {
EVP_KEYMGMT_free(keymgmt);
- ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
return NULL;
}
-
- keymgmt->refcnt = 1;
-
return keymgmt;
}
{
int ref = 0;
- CRYPTO_UP_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
+ CRYPTO_UP_REF(&keymgmt->refcnt, &ref);
return 1;
}
if (keymgmt == NULL)
return;
- CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
+ CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref);
if (ref > 0)
return;
OPENSSL_free(keymgmt->type_name);
ossl_provider_free(keymgmt->prov);
- CRYPTO_THREAD_lock_free(keymgmt->lock);
+ CRYPTO_FREE_REF(&keymgmt->refcnt);
OPENSSL_free(keymgmt);
}
EVP_MAC *mac = vmac;
int ref = 0;
- CRYPTO_UP_REF(&mac->refcnt, &ref, mac->lock);
+ CRYPTO_UP_REF(&mac->refcnt, &ref);
return 1;
}
if (mac == NULL)
return;
- CRYPTO_DOWN_REF(&mac->refcnt, &ref, mac->lock);
+ CRYPTO_DOWN_REF(&mac->refcnt, &ref);
if (ref > 0)
return;
OPENSSL_free(mac->type_name);
ossl_provider_free(mac->prov);
- CRYPTO_THREAD_lock_free(mac->lock);
+ CRYPTO_FREE_REF(&mac->refcnt);
OPENSSL_free(mac);
}
EVP_MAC *mac = NULL;
if ((mac = OPENSSL_zalloc(sizeof(*mac))) == NULL
- || (mac->lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ || !CRYPTO_NEW_REF(&mac->refcnt, 1)) {
evp_mac_free(mac);
return NULL;
}
-
- mac->refcnt = 1;
-
return mac;
}
ret->type = EVP_PKEY_NONE;
ret->save_type = EVP_PKEY_NONE;
- ret->references = 1;
+
+ if (!CRYPTO_NEW_REF(&ret->references, 1))
+ goto err;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
return ret;
err:
+ CRYPTO_FREE_REF(&ret->references);
CRYPTO_THREAD_lock_free(ret->lock);
OPENSSL_free(ret);
return NULL;
{
int i;
- if (CRYPTO_UP_REF(&pkey->references, &i, pkey->lock) <= 0)
+ if (CRYPTO_UP_REF(&pkey->references, &i) <= 0)
return 0;
REF_PRINT_COUNT("EVP_PKEY", pkey);
if (x == NULL)
return;
- CRYPTO_DOWN_REF(&x->references, &i, x->lock);
+ CRYPTO_DOWN_REF(&x->references, &i);
REF_PRINT_COUNT("EVP_PKEY", x);
if (i > 0)
return;
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EVP_PKEY, x, &x->ex_data);
#endif
CRYPTO_THREAD_lock_free(x->lock);
+ CRYPTO_FREE_REF(&x->references);
#ifndef FIPS_MODULE
sk_X509_ATTRIBUTE_pop_free(x->attributes, X509_ATTRIBUTE_free);
#endif
if (signature == NULL)
return NULL;
- signature->lock = CRYPTO_THREAD_lock_new();
- if (signature->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
+ if (!CRYPTO_NEW_REF(&signature->refcnt, 1)) {
OPENSSL_free(signature);
return NULL;
}
+
signature->prov = prov;
ossl_provider_up_ref(prov);
- signature->refcnt = 1;
return signature;
}
if (signature == NULL)
return;
- CRYPTO_DOWN_REF(&signature->refcnt, &i, signature->lock);
+ CRYPTO_DOWN_REF(&signature->refcnt, &i);
if (i > 0)
return;
OPENSSL_free(signature->type_name);
ossl_provider_free(signature->prov);
- CRYPTO_THREAD_lock_free(signature->lock);
+ CRYPTO_FREE_REF(&signature->refcnt);
OPENSSL_free(signature);
}
{
int ref = 0;
- CRYPTO_UP_REF(&signature->refcnt, &ref, signature->lock);
+ CRYPTO_UP_REF(&signature->refcnt, &ref);
return 1;
}
const char *description;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_mac_newctx_fn *newctx;
OSSL_FUNC_mac_dupctx_fn *dupctx;
char *type_name;
const char *description;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_kdf_newctx_fn *newctx;
OSSL_FUNC_kdf_dupctx_fn *dupctx;
const char *description;
OSSL_PROVIDER *prov;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_digest_newctx_fn *newctx;
OSSL_FUNC_digest_init_fn *dinit;
OSSL_FUNC_digest_update_fn *dupdate;
const char *description;
OSSL_PROVIDER *prov;
CRYPTO_REF_COUNT refcnt;
- CRYPTO_RWLOCK *lock;
OSSL_FUNC_cipher_newctx_fn *newctx;
OSSL_FUNC_cipher_encrypt_init_fn *einit;
OSSL_FUNC_cipher_decrypt_init_fn *dinit;