自学教程：C++ CRYPTO_THREAD_lock_free函数代码示例

EC_KEY *EC_KEY_new_method(ENGINE *engine){    EC_KEY *ret = OPENSSL_zalloc(sizeof(*ret));    if (ret == NULL) {        ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_MALLOC_FAILURE);        return NULL;    }    if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data)) {        OPENSSL_free(ret);        return NULL;    }    ret->lock = CRYPTO_THREAD_lock_new();    if (ret->lock == NULL) {        ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_MALLOC_FAILURE);        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data);        OPENSSL_free(ret);        return NULL;    }    ret->meth = EC_KEY_get_default_method();#ifndef OPENSSL_NO_ENGINE    if (engine != NULL) {        if (!ENGINE_init(engine)) {            ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_ENGINE_LIB);            CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data);            CRYPTO_THREAD_lock_free(ret->lock);            OPENSSL_free(ret);            return NULL;        }        ret->engine = engine;    } else        ret->engine = ENGINE_get_default_EC();    if (ret->engine != NULL) {        ret->meth = ENGINE_get_EC(ret->engine);        if (ret->meth == NULL) {            ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_ENGINE_LIB);            ENGINE_finish(ret->engine);            CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data);            CRYPTO_THREAD_lock_free(ret->lock);            OPENSSL_free(ret);            return NULL;        }    }#endif    ret->version = 1;    ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;    ret->references = 1;    if (ret->meth->init != NULL && ret->meth->init(ret) == 0) {        EC_KEY_free(ret);        return NULL;    }    return ret;}

void bio_cleanup(void){#ifndef OPENSSL_NO_SOCK    bio_sock_cleanup_int();    CRYPTO_THREAD_lock_free(bio_lookup_lock);    bio_lookup_lock = NULL;#endif    CRYPTO_THREAD_lock_free(bio_type_lock);    bio_type_lock = NULL;}

void rand_cleanup_int(void){    const RAND_METHOD *meth = default_RAND_meth;    if (meth && meth->cleanup)        meth->cleanup();    RAND_set_rand_method(NULL);    CRYPTO_THREAD_lock_free(rand_meth_lock);#ifndef OPENSSL_NO_ENGINE    CRYPTO_THREAD_lock_free(rand_engine_lock);#endif}

static void rand_cleanup(void){    OPENSSL_cleanse(state, sizeof(state));    state_num = 0;    state_index = 0;    OPENSSL_cleanse(md, MD_DIGEST_LENGTH);    md_count[0] = 0;    md_count[1] = 0;    entropy = 0;    initialized = 0;    CRYPTO_THREAD_lock_free(rand_lock);    CRYPTO_THREAD_lock_free(rand_tmp_lock);}

void err_cleanup(void){    if (set_err_thread_local != 0)        CRYPTO_THREAD_cleanup_local(&err_thread_local);    CRYPTO_THREAD_lock_free(err_string_lock);    err_string_lock = NULL;}

int BIO_set(BIO *bio, const BIO_METHOD *method){    bio->method = method;    bio->callback = NULL;    bio->cb_arg = NULL;    bio->init = 0;    bio->shutdown = 1;    bio->flags = 0;    bio->retry_reason = 0;    bio->num = 0;    bio->ptr = NULL;    bio->prev_bio = NULL;    bio->next_bio = NULL;    bio->references = 1;    bio->num_read = 0L;    bio->num_write = 0L;    CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);    bio->lock = CRYPTO_THREAD_lock_new();    if (bio->lock == NULL) {        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);        return 0;    }    if (method->create != NULL) {        if (!method->create(bio)) {            CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);            CRYPTO_THREAD_lock_free(bio->lock);            return 0;        }    }    return 1;}

/* Destructor (complements the "ENGINE_chil()" constructor) */static int hwcrhk_destroy(ENGINE *e){    free_HWCRHK_LIBNAME();    ERR_unload_HWCRHK_strings();    CRYPTO_THREAD_lock_free(chil_lock);    return 1;}

int BIO_free(BIO *a){    int ret;    if (a == NULL)        return 0;    if (CRYPTO_DOWN_REF(&a->references, &ret, a->lock) <= 0)        return 0;    REF_PRINT_COUNT("BIO", a);    if (ret > 0)        return 1;    REF_ASSERT_ISNT(ret < 0);    if (a->callback != NULL || a->callback_ex != NULL) {        ret = (int)bio_call_callback(a, BIO_CB_FREE, NULL, 0, 0, 0L, 1L, NULL);        if (ret <= 0)            return ret;    }    if ((a->method != NULL) && (a->method->destroy != NULL))        a->method->destroy(a);    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);    CRYPTO_THREAD_lock_free(a->lock);    OPENSSL_free(a);    return 1;}

void X509_STORE_free(X509_STORE *vfy){    int i;    STACK_OF(X509_LOOKUP) *sk;    X509_LOOKUP *lu;    if (vfy == NULL)        return;    CRYPTO_atomic_add(&vfy->references, -1, &i, vfy->lock);    REF_PRINT_COUNT("X509_STORE", vfy);    if (i > 0)        return;    REF_ASSERT_ISNT(i < 0);    sk = vfy->get_cert_methods;    for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) {        lu = sk_X509_LOOKUP_value(sk, i);        X509_LOOKUP_shutdown(lu);        X509_LOOKUP_free(lu);    }    sk_X509_LOOKUP_free(sk);    sk_X509_OBJECT_pop_free(vfy->objs, cleanup);    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE, vfy, &vfy->ex_data);    X509_VERIFY_PARAM_free(vfy->param);    CRYPTO_THREAD_lock_free(vfy->lock);    OPENSSL_free(vfy);}

void DSA_free(DSA *r){    int i;    if (r == NULL)        return;    CRYPTO_DOWN_REF(&r->references, &i, r->lock);    REF_PRINT_COUNT("DSA", r);    if (i > 0)        return;    REF_ASSERT_ISNT(i < 0);    if (r->meth->finish)        r->meth->finish(r);#ifndef OPENSSL_NO_ENGINE    ENGINE_finish(r->engine);#endif    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_DSA, r, &r->ex_data);    CRYPTO_THREAD_lock_free(r->lock);    BN_clear_free(r->p);    BN_clear_free(r->q);    BN_clear_free(r->g);    BN_clear_free(r->pub_key);    BN_clear_free(r->priv_key);    OPENSSL_free(r);}

int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it){    const ASN1_AUX *aux;    int *lck, ret;    CRYPTO_RWLOCK **lock;    if ((it->itype != ASN1_ITYPE_SEQUENCE)        && (it->itype != ASN1_ITYPE_NDEF_SEQUENCE))        return 0;    aux = it->funcs;    if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT))        return 0;    lck = offset2ptr(*pval, aux->ref_offset);    lock = offset2ptr(*pval, aux->ref_lock);    if (op == 0) {        *lck = 1;        *lock = CRYPTO_THREAD_lock_new();        if (*lock == NULL)            return 0;        return 1;    }    CRYPTO_atomic_add(lck, op, &ret, *lock);#ifdef REF_PRINT    fprintf(stderr, "%p:%4d:%s/n", it, *lck, it->sname);#endif    REF_ASSERT_ISNT(ret < 0);    if (ret == 0)        CRYPTO_THREAD_lock_free(*lock);    return ret;}

SSL_SESSION *SSL_SESSION_new(void){    SSL_SESSION *ss;    if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))        return NULL;    ss = OPENSSL_zalloc(sizeof(*ss));    if (ss == NULL) {        SSLerr(SSL_F_SSL_SESSION_NEW, ERR_R_MALLOC_FAILURE);        return NULL;    }    ss->verify_result = 1;      /* avoid 0 (= X509_V_OK) just in case */    ss->references = 1;    ss->timeout = 60 * 5 + 4;   /* 5 minute timeout by default */    ss->time = (unsigned long)time(NULL);    ss->lock = CRYPTO_THREAD_lock_new();    if (ss->lock == NULL) {        SSLerr(SSL_F_SSL_SESSION_NEW, ERR_R_MALLOC_FAILURE);        OPENSSL_free(ss);        return NULL;    }    if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data)) {        CRYPTO_THREAD_lock_free(ss->lock);        OPENSSL_free(ss);        return NULL;    }    return ss;}

int BIO_free(BIO *a){    int i;    if (a == NULL)        return 0;    if (CRYPTO_atomic_add(&a->references, -1, &i, a->lock) <= 0)        return 0;    REF_PRINT_COUNT("BIO", a);    if (i > 0)        return 1;    REF_ASSERT_ISNT(i < 0);    if ((a->callback != NULL) &&        ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))        return i;    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);    CRYPTO_THREAD_lock_free(a->lock);    if ((a->method != NULL) && (a->method->destroy != NULL))        a->method->destroy(a);    OPENSSL_free(a);    return 1;}

void EC_KEY_free(EC_KEY *r){    int i;    if (r == NULL)        return;    CRYPTO_DOWN_REF(&r->references, &i, r->lock);    REF_PRINT_COUNT("EC_KEY", r);    if (i > 0)        return;    REF_ASSERT_ISNT(i < 0);    if (r->meth->finish != NULL)        r->meth->finish(r);#ifndef OPENSSL_NO_ENGINE    ENGINE_finish(r->engine);#endif    if (r->group && r->group->meth->keyfinish)        r->group->meth->keyfinish(r);    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, r, &r->ex_data);    CRYPTO_THREAD_lock_free(r->lock);    EC_GROUP_free(r->group);    EC_POINT_free(r->pub_key);    BN_clear_free(r->priv_key);    OPENSSL_clear_free((void *)r, sizeof(EC_KEY));}

void ssl_cert_free(CERT *c){    int i;    if (c == NULL)        return;    CRYPTO_DOWN_REF(&c->references, &i, c->lock);    REF_PRINT_COUNT("CERT", c);    if (i > 0)        return;    REF_ASSERT_ISNT(i < 0);#ifndef OPENSSL_NO_DH    EVP_PKEY_free(c->dh_tmp);#endif    ssl_cert_clear_certs(c);    OPENSSL_free(c->conf_sigalgs);    OPENSSL_free(c->client_sigalgs);    OPENSSL_free(c->shared_sigalgs);    OPENSSL_free(c->ctype);    X509_STORE_free(c->verify_store);    X509_STORE_free(c->chain_store);    custom_exts_free(&c->custext);#ifndef OPENSSL_NO_PSK    OPENSSL_free(c->psk_identity_hint);#endif    CRYPTO_THREAD_lock_free(c->lock);    OPENSSL_free(c);}

int DSO_free(DSO *dso){    int i;    if (dso == NULL)        return (1);    if (CRYPTO_DOWN_REF(&dso->references, &i, dso->lock) <= 0)        return 0;    REF_PRINT_COUNT("DSO", dso);    if (i > 0)        return 1;    REF_ASSERT_ISNT(i < 0);    if ((dso->flags & DSO_FLAG_NO_UNLOAD_ON_FREE) == 0) {        if ((dso->meth->dso_unload != NULL) && !dso->meth->dso_unload(dso)) {            DSOerr(DSO_F_DSO_FREE, DSO_R_UNLOAD_FAILED);            return 0;        }    }    if ((dso->meth->finish != NULL) && !dso->meth->finish(dso)) {        DSOerr(DSO_F_DSO_FREE, DSO_R_FINISH_FAILED);        return 0;    }    sk_void_free(dso->meth_data);    OPENSSL_free(dso->filename);    OPENSSL_free(dso->loaded_filename);    CRYPTO_THREAD_lock_free(dso->lock);    OPENSSL_free(dso);    return 1;}

/* Cleans up the given global DRBG  */static void drbg_cleanup(RAND_DRBG *drbg){    if (drbg != NULL) {        RAND_DRBG_uninstantiate(drbg);        CRYPTO_THREAD_lock_free(drbg->lock);        OPENSSL_secure_clear_free(drbg, sizeof(RAND_DRBG));    }}

void rand_cleanup_int(void){    const RAND_METHOD *meth = default_RAND_meth;    if (meth != NULL && meth->cleanup != NULL)        meth->cleanup();    RAND_set_rand_method(NULL);#ifndef OPENSSL_NO_ENGINE    CRYPTO_THREAD_lock_free(rand_engine_lock);#endif    CRYPTO_THREAD_lock_free(rand_meth_lock);    CRYPTO_THREAD_lock_free(rand_bytes.lock);    if (rand_bytes.secure)        OPENSSL_secure_clear_free(rand_bytes.buff, rand_bytes.size);    else        OPENSSL_clear_free(rand_bytes.buff, rand_bytes.size);}

void engine_cleanup_int(void){    if (int_cleanup_check(0)) {        sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack,                                        engine_cleanup_cb_free);        cleanup_stack = NULL;    }    CRYPTO_THREAD_lock_free(global_engine_lock);}

static void free_drbg(RAND_DRBG *drbg){    CRYPTO_THREAD_lock_free(drbg->lock);    if (drbg->secure)        OPENSSL_secure_clear_free(drbg->randomness, drbg->size);    else        OPENSSL_clear_free(drbg->randomness, drbg->size);    RAND_DRBG_uninstantiate(drbg);}

void err_cleanup(void){    if (set_err_thread_local != 0)        CRYPTO_THREAD_cleanup_local(&err_thread_local);    CRYPTO_THREAD_lock_free(err_string_lock);    err_string_lock = NULL;    lh_ERR_STRING_DATA_free(int_error_hash);    int_error_hash = NULL;}

void UI_free(UI *ui){    if (ui == NULL)        return;    sk_UI_STRING_pop_free(ui->strings, free_string);    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data);    CRYPTO_THREAD_lock_free(ui->lock);    OPENSSL_free(ui);}

static void provider_store_free(void *vstore){    struct provider_store_st *store = vstore;    if (store == NULL)        return;    sk_OSSL_PROVIDER_pop_free(store->providers, ossl_provider_free);    CRYPTO_THREAD_lock_free(store->lock);    OPENSSL_free(store);}

int CRYPTO_secure_malloc_done(){#ifdef IMPLEMENTED    if (secure_mem_used == 0) {        sh_done();        secure_mem_initialized = 0;        CRYPTO_THREAD_lock_free(sec_malloc_lock);        return 1;    }#endif /* IMPLEMENTED */    return 0;}

void UI_free(UI *ui){    if (ui == NULL)        return;    if ((ui->flags & UI_FLAG_DUPL_DATA) != 0) {        ui->meth->ui_destroy_data(ui, ui->user_data);    }    sk_UI_STRING_pop_free(ui->strings, free_string);    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data);    CRYPTO_THREAD_lock_free(ui->lock);    OPENSSL_free(ui);}

void BN_BLINDING_free(BN_BLINDING *r){    if (r == NULL)        return;    BN_free(r->A);    BN_free(r->Ai);    BN_free(r->e);    BN_free(r->mod);    CRYPTO_THREAD_lock_free(r->lock);    OPENSSL_free(r);}

static void EVP_PKEY_free_it(EVP_PKEY *x){    /* internal function; x is never NULL */    if (x->ameth && x->ameth->pkey_free) {        x->ameth->pkey_free(x);        x->pkey.ptr = NULL;    }#ifndef OPENSSL_NO_ENGINE    ENGINE_finish(x->engine);    x->engine = NULL;#endif    CRYPTO_THREAD_lock_free(x->lock);}

int CRYPTO_secure_malloc_done(void){#ifdef OPENSSL_SECURE_MEMORY    if (secure_mem_used == 0) {        sh_done();        secure_mem_initialized = 0;        CRYPTO_THREAD_lock_free(sec_malloc_lock);        sec_malloc_lock = NULL;        return 1;    }#endif /* OPENSSL_SECURE_MEMORY */    return 0;}

void engine_cleanup_int(void){    if (int_cleanup_check(0)) {        sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack,                                        engine_cleanup_cb_free);        cleanup_stack = NULL;    }    /*     * FIXME: This should be handled (somehow) through RAND, eg. by it     * registering a cleanup callback.     */    RAND_set_rand_method(NULL);    CRYPTO_THREAD_lock_free(global_engine_lock);}

/* * Uninstantiate |drbg| and free all memory. */void RAND_DRBG_free(RAND_DRBG *drbg){    if (drbg == NULL)        return;    if (drbg->meth != NULL)        drbg->meth->uninstantiate(drbg);    CRYPTO_THREAD_lock_free(drbg->lock);    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_DRBG, drbg, &drbg->ex_data);    if (drbg->secure)        OPENSSL_secure_clear_free(drbg, sizeof(*drbg));    else        OPENSSL_clear_free(drbg, sizeof(*drbg));}