=pod

=head1 NAME

EVP_PKEY_new, EVP_PKEY_up_ref, EVP_PKEY_free - private key allocation functions.

=head1 SYNOPSIS

 #include <openssl/evp.h>

 EVP_PKEY *EVP_PKEY_new(void);
 void EVP_PKEY_up_ref(EVP_PKEY *key);
 void EVP_PKEY_free(EVP_PKEY *key);


=head1 DESCRIPTION

The EVP_PKEY_new() function allocates an empty B<EVP_PKEY> structure which is
used by OpenSSL to store private keys. The reference count is set to B<1>.

EVP_PKEY_up_ref() increments the reference count of B<key>.

EVP_PKEY_free() decrements the reference count of B<key> and, if the reference
count is zero, frees it up. If B<key> is NULL, nothing is done.

=head1 NOTES

The B<EVP_PKEY> structure is used by various OpenSSL functions which require a
general private key without reference to any particular algorithm.

The structure returned by EVP_PKEY_new() is empty. To add a private key to this
empty structure the functions described in L<EVP_PKEY_set1_RSA(3)> should be
used.

=head1 RETURN VALUES

EVP_PKEY_new() returns either the newly allocated B<EVP_PKEY> structure or
B<NULL> if an error occurred.

EVP_PKEY_up_ref() and EVP_PKEY_free() do not return a value.

=head1 SEE ALSO

L<EVP_PKEY_set1_RSA(3)>

=head1 HISTORY

EVP_PKEY_new() and EVP_PKEY_free() exist in all versions of OpenSSL.

EVP_PKEY_up_ref() was first added to OpenSSL 1.1.0.

=cut
