X509_STORE *X509_STORE_new(void) { X509_STORE *ret; if ((ret = (X509_STORE *)OPENSSL_malloc(sizeof(X509_STORE))) == NULL) return NULL; OPENSSL_memset(ret, 0, sizeof(*ret)); CRYPTO_MUTEX_init(&ret->objs_lock); ret->objs = sk_X509_OBJECT_new(x509_object_cmp); if (ret->objs == NULL) goto err; ret->cache = 1; ret->get_cert_methods = sk_X509_LOOKUP_new_null(); if (ret->get_cert_methods == NULL) goto err; ret->param = X509_VERIFY_PARAM_new(); if (ret->param == NULL) goto err; ret->references = 1; return ret; err: if (ret) { CRYPTO_MUTEX_cleanup(&ret->objs_lock); if (ret->param) X509_VERIFY_PARAM_free(ret->param); if (ret->get_cert_methods) sk_X509_LOOKUP_free(ret->get_cert_methods); if (ret->objs) sk_X509_OBJECT_free(ret->objs); OPENSSL_free(ret); } return NULL; }
RSA *RSA_new_method(const ENGINE *engine) { RSA *rsa = OPENSSL_malloc(sizeof(RSA)); if (rsa == NULL) { OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE); return NULL; } OPENSSL_memset(rsa, 0, sizeof(RSA)); if (engine) { rsa->meth = ENGINE_get_RSA_method(engine); } if (rsa->meth == NULL) { rsa->meth = (RSA_METHOD *) RSA_default_method(); } METHOD_ref(rsa->meth); rsa->references = 1; rsa->flags = rsa->meth->flags; CRYPTO_MUTEX_init(&rsa->lock); CRYPTO_new_ex_data(&rsa->ex_data); if (rsa->meth->init && !rsa->meth->init(rsa)) { CRYPTO_free_ex_data(g_rsa_ex_data_class_bss_get(), rsa, &rsa->ex_data); CRYPTO_MUTEX_cleanup(&rsa->lock); METHOD_unref(rsa->meth); OPENSSL_free(rsa); return NULL; } return rsa; }
DH *DH_new_method(const ENGINE *engine) { DH *dh = (DH *)OPENSSL_malloc(sizeof(DH)); if (dh == NULL) { OPENSSL_PUT_ERROR(DH, DH_new_method, ERR_R_MALLOC_FAILURE); return NULL; } memset(dh, 0, sizeof(DH)); if (engine) { dh->meth = ENGINE_get_DH_method(engine); } if (dh->meth == NULL) { dh->meth = (DH_METHOD*) &DH_default_method; } METHOD_ref(dh->meth); CRYPTO_MUTEX_init(&dh->method_mont_p_lock); dh->references = 1; if (!CRYPTO_new_ex_data(&g_ex_data_class, dh, &dh->ex_data)) { OPENSSL_free(dh); return NULL; } if (dh->meth->init && !dh->meth->init(dh)) { CRYPTO_free_ex_data(&g_ex_data_class, dh, &dh->ex_data); METHOD_unref(dh->meth); OPENSSL_free(dh); return NULL; } return dh; }
static int x509_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) { X509 *ret = (X509 *)*pval; switch (operation) { case ASN1_OP_NEW_POST: ret->name = NULL; ret->ex_flags = 0; ret->ex_pathlen = -1; ret->skid = NULL; ret->akid = NULL; ret->aux = NULL; ret->crldp = NULL; ret->buf = NULL; CRYPTO_new_ex_data(&ret->ex_data); CRYPTO_MUTEX_init(&ret->lock); break; case ASN1_OP_D2I_PRE: CRYPTO_BUFFER_free(ret->buf); ret->buf = NULL; break; case ASN1_OP_D2I_POST: if (ret->name != NULL) OPENSSL_free(ret->name); ret->name = X509_NAME_oneline(ret->cert_info->subject, NULL, 0); break; case ASN1_OP_FREE_POST: CRYPTO_MUTEX_cleanup(&ret->lock); CRYPTO_free_ex_data(&g_ex_data_class, ret, &ret->ex_data); X509_CERT_AUX_free(ret->aux); ASN1_OCTET_STRING_free(ret->skid); AUTHORITY_KEYID_free(ret->akid); CRL_DIST_POINTS_free(ret->crldp); policy_cache_free(ret->policy_cache); GENERAL_NAMES_free(ret->altname); NAME_CONSTRAINTS_free(ret->nc); CRYPTO_BUFFER_free(ret->buf); OPENSSL_free(ret->name); break; } return 1; }
DH *DH_new(void) { DH *dh = OPENSSL_malloc(sizeof(DH)); if (dh == NULL) { OPENSSL_PUT_ERROR(DH, ERR_R_MALLOC_FAILURE); return NULL; } OPENSSL_memset(dh, 0, sizeof(DH)); CRYPTO_MUTEX_init(&dh->method_mont_p_lock); dh->references = 1; CRYPTO_new_ex_data(&dh->ex_data); return dh; }
CRYPTO_BUFFER_POOL* CRYPTO_BUFFER_POOL_new(void) { CRYPTO_BUFFER_POOL *pool = OPENSSL_malloc(sizeof(CRYPTO_BUFFER_POOL)); if (pool == NULL) { return NULL; } OPENSSL_memset(pool, 0, sizeof(CRYPTO_BUFFER_POOL)); pool->bufs = lh_CRYPTO_BUFFER_new(CRYPTO_BUFFER_hash, CRYPTO_BUFFER_cmp); if (pool->bufs == NULL) { OPENSSL_free(pool); return NULL; } CRYPTO_MUTEX_init(&pool->lock); return pool; }
DSA *DSA_new_method(const ENGINE *engine) { DSA *dsa = (DSA *)OPENSSL_malloc(sizeof(DSA)); if (dsa == NULL) { OPENSSL_PUT_ERROR(DSA, DSA_new_method, ERR_R_MALLOC_FAILURE); return NULL; } memset(dsa, 0, sizeof(DSA)); if (engine) { dsa->meth = ENGINE_get_DSA_method(engine); } if (dsa->meth == NULL) { dsa->meth = (DSA_METHOD*) &DSA_default_method; } METHOD_ref(dsa->meth); dsa->write_params = 1; dsa->references = 1; CRYPTO_MUTEX_init(&dsa->method_mont_p_lock); if (!CRYPTO_new_ex_data(&g_ex_data_class, dsa, &dsa->ex_data)) { METHOD_unref(dsa->meth); OPENSSL_free(dsa); return NULL; } if (dsa->meth->init && !dsa->meth->init(dsa)) { CRYPTO_free_ex_data(&g_ex_data_class, dsa, &dsa->ex_data); METHOD_unref(dsa->meth); OPENSSL_free(dsa); return NULL; } return dsa; }