int CRYPTO_BUFFER_up_ref(CRYPTO_BUFFER *buf) { // This is safe in the case that |buf->pool| is NULL because it's just // standard reference counting in that case. // // This is also safe if |buf->pool| is non-NULL because, if it were racing // with |CRYPTO_BUFFER_free| then the two callers must have independent // references already and so the reference count will never hit zero. CRYPTO_refcount_inc(&buf->references); return 1; }
SSL_SESSION *SSL_SESSION_up_ref(SSL_SESSION *session) { if (session != NULL) { CRYPTO_refcount_inc(&session->references); } return session; }
int RSA_up_ref(RSA *rsa) { CRYPTO_refcount_inc(&rsa->references); return 1; }
int DSA_up_ref(DSA *dsa) { CRYPTO_refcount_inc(&dsa->references); return 1; }
int X509_up_ref(X509 *x) { CRYPTO_refcount_inc(&x->references); return 1; }
int DH_up_ref(DH *dh) { CRYPTO_refcount_inc(&dh->references); return 1; }
CRYPTO_BUFFER *CRYPTO_BUFFER_new(const uint8_t *data, size_t len, CRYPTO_BUFFER_POOL *pool) { if (pool != NULL) { CRYPTO_BUFFER tmp; tmp.data = (uint8_t *) data; tmp.len = len; CRYPTO_MUTEX_lock_read(&pool->lock); CRYPTO_BUFFER *const duplicate = lh_CRYPTO_BUFFER_retrieve(pool->bufs, &tmp); if (duplicate != NULL) { CRYPTO_refcount_inc(&duplicate->references); } CRYPTO_MUTEX_unlock_read(&pool->lock); if (duplicate != NULL) { return duplicate; } } CRYPTO_BUFFER *const buf = OPENSSL_malloc(sizeof(CRYPTO_BUFFER)); if (buf == NULL) { return NULL; } OPENSSL_memset(buf, 0, sizeof(CRYPTO_BUFFER)); buf->data = BUF_memdup(data, len); if (len != 0 && buf->data == NULL) { OPENSSL_free(buf); return NULL; } buf->len = len; buf->references = 1; if (pool == NULL) { return buf; } buf->pool = pool; CRYPTO_MUTEX_lock_write(&pool->lock); CRYPTO_BUFFER *duplicate = lh_CRYPTO_BUFFER_retrieve(pool->bufs, buf); int inserted = 0; if (duplicate == NULL) { CRYPTO_BUFFER *old = NULL; inserted = lh_CRYPTO_BUFFER_insert(pool->bufs, &old, buf); assert(old == NULL); } else { CRYPTO_refcount_inc(&duplicate->references); } CRYPTO_MUTEX_unlock_write(&pool->lock); if (!inserted) { // We raced to insert |buf| into the pool and lost, or else there was an // error inserting. OPENSSL_free(buf->data); OPENSSL_free(buf); return duplicate; } return buf; }
int X509_STORE_up_ref(X509_STORE *store) { CRYPTO_refcount_inc(&store->references); return 1; }
EVP_PKEY *EVP_PKEY_up_ref(EVP_PKEY *pkey) { CRYPTO_refcount_inc(&pkey->references); return pkey; }
int SSL_SESSION_up_ref(SSL_SESSION *session) { CRYPTO_refcount_inc(&session->references); return 1; }
CERT *ssl_cert_dup(CERT *cert) { CERT *ret = (CERT *)OPENSSL_malloc(sizeof(CERT)); if (ret == NULL) { OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); return NULL; } memset(ret, 0, sizeof(CERT)); ret->mask_k = cert->mask_k; ret->mask_a = cert->mask_a; if (cert->dh_tmp != NULL) { ret->dh_tmp = DHparams_dup(cert->dh_tmp); if (ret->dh_tmp == NULL) { OPENSSL_PUT_ERROR(SSL, ERR_R_DH_LIB); goto err; } if (cert->dh_tmp->priv_key) { BIGNUM *b = BN_dup(cert->dh_tmp->priv_key); if (!b) { OPENSSL_PUT_ERROR(SSL, ERR_R_BN_LIB); goto err; } ret->dh_tmp->priv_key = b; } if (cert->dh_tmp->pub_key) { BIGNUM *b = BN_dup(cert->dh_tmp->pub_key); if (!b) { OPENSSL_PUT_ERROR(SSL, ERR_R_BN_LIB); goto err; } ret->dh_tmp->pub_key = b; } } ret->dh_tmp_cb = cert->dh_tmp_cb; ret->ecdh_nid = cert->ecdh_nid; ret->ecdh_tmp_cb = cert->ecdh_tmp_cb; if (cert->x509 != NULL) { ret->x509 = X509_up_ref(cert->x509); } if (cert->privatekey != NULL) { ret->privatekey = EVP_PKEY_up_ref(cert->privatekey); } if (cert->chain) { ret->chain = X509_chain_up_ref(cert->chain); if (!ret->chain) { OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE); goto err; } } /* Copy over signature algorithm configuration. */ if (cert->conf_sigalgs) { ret->conf_sigalgs = BUF_memdup(cert->conf_sigalgs, cert->conf_sigalgslen); if (!ret->conf_sigalgs) { goto err; } ret->conf_sigalgslen = cert->conf_sigalgslen; } if (cert->client_sigalgs) { ret->client_sigalgs = BUF_memdup(cert->client_sigalgs, cert->client_sigalgslen); if (!ret->client_sigalgs) { goto err; } ret->client_sigalgslen = cert->client_sigalgslen; } /* Copy any custom client certificate types */ if (cert->client_certificate_types) { ret->client_certificate_types = BUF_memdup( cert->client_certificate_types, cert->num_client_certificate_types); if (!ret->client_certificate_types) { goto err; } ret->num_client_certificate_types = cert->num_client_certificate_types; } ret->cert_cb = cert->cert_cb; ret->cert_cb_arg = cert->cert_cb_arg; if (cert->verify_store) { CRYPTO_refcount_inc(&cert->verify_store->references); ret->verify_store = cert->verify_store; } if (cert->chain_store) { CRYPTO_refcount_inc(&cert->chain_store->references); ret->chain_store = cert->chain_store; } return ret; err: ssl_cert_free(ret); return NULL; }
MONO_API MonoBtlsSslCtx * mono_btls_ssl_ctx_up_ref (MonoBtlsSslCtx *ctx) { CRYPTO_refcount_inc (&ctx->references); return ctx; }
MONO_API MonoBtlsX509Lookup * mono_btls_x509_lookup_up_ref (MonoBtlsX509Lookup *lookup) { CRYPTO_refcount_inc (&lookup->references); return lookup; }