From 52261db09ef9dbf5abc95baed22722c5c332f9f7 Mon Sep 17 00:00:00 2001 From: Rob Austein Date: Tue, 20 Jun 2006 17:33:26 +0000 Subject: Pulling OpenSSL 0.9.8b into trunk svn path=/openssl/trunk; revision=3 --- openssl/trunk/doc/crypto/RSA_get_ex_new_index.pod | 120 ++++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 openssl/trunk/doc/crypto/RSA_get_ex_new_index.pod (limited to 'openssl/trunk/doc/crypto/RSA_get_ex_new_index.pod') diff --git a/openssl/trunk/doc/crypto/RSA_get_ex_new_index.pod b/openssl/trunk/doc/crypto/RSA_get_ex_new_index.pod new file mode 100644 index 00000000..46cc8f53 --- /dev/null +++ b/openssl/trunk/doc/crypto/RSA_get_ex_new_index.pod @@ -0,0 +1,120 @@ +=pod + +=head1 NAME + +RSA_get_ex_new_index, RSA_set_ex_data, RSA_get_ex_data - add application specific data to RSA structures + +=head1 SYNOPSIS + + #include + + int RSA_get_ex_new_index(long argl, void *argp, + CRYPTO_EX_new *new_func, + CRYPTO_EX_dup *dup_func, + CRYPTO_EX_free *free_func); + + int RSA_set_ex_data(RSA *r, int idx, void *arg); + + void *RSA_get_ex_data(RSA *r, int idx); + + typedef int new_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, + int idx, long argl, void *argp); + typedef void free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, + int idx, long argl, void *argp); + typedef int dup_func(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d, + int idx, long argl, void *argp); + +=head1 DESCRIPTION + +Several OpenSSL structures can have application specific data attached to them. +This has several potential uses, it can be used to cache data associated with +a structure (for example the hash of some part of the structure) or some +additional data (for example a handle to the data in an external library). + +Since the application data can be anything at all it is passed and retrieved +as a B type. + +The B function is initially called to "register" some +new application specific data. It takes three optional function pointers which +are called when the parent structure (in this case an RSA structure) is +initially created, when it is copied and when it is freed up. If any or all of +these function pointer arguments are not used they should be set to NULL. The +precise manner in which these function pointers are called is described in more +detail below. B also takes additional long and pointer +parameters which will be passed to the supplied functions but which otherwise +have no special meaning. It returns an B which should be stored +(typically in a static variable) and passed used in the B parameter in +the remaining functions. Each successful call to B +will return an index greater than any previously returned, this is important +because the optional functions are called in order of increasing index value. + +B is used to set application specific data, the data is +supplied in the B parameter and its precise meaning is up to the +application. + +B is used to retrieve application specific data. The data +is returned to the application, this will be the same value as supplied to +a previous B call. + +B is called when a structure is initially allocated (for example +with B. The parent structure members will not have any meaningful +values at this point. This function will typically be used to allocate any +application specific structure. + +B is called when a structure is being freed up. The dynamic parent +structure members should not be accessed because they will be freed up when +this function is called. + +B and B take the same parameters. B is a +pointer to the parent RSA structure. B is a the application specific data +(this wont be of much use in B. B is a pointer to the +B structure from the parent RSA structure: the functions +B and B can be called to manipulate +it. The B parameter is the index: this will be the same value returned by +B when the functions were initially registered. Finally +the B and B parameters are the values originally passed to the same +corresponding parameters when B was called. + +B is called when a structure is being copied. Pointers to the +destination and source B structures are passed in the B and +B parameters respectively. The B parameter is passed a pointer to +the source application data when the function is called, when the function returns +the value is copied to the destination: the application can thus modify the data +pointed to by B and have different values in the source and destination. +The B, B and B parameters are the same as those in B +and B. + +=head1 RETURN VALUES + +B returns a new index or -1 on failure (note 0 is a valid +index value). + +B returns 1 on success or 0 on failure. + +B returns the application data or 0 on failure. 0 may also +be valid application data but currently it can only fail if given an invalid B +parameter. + +B and B should return 0 for failure and 1 for success. + +On failure an error code can be obtained from L. + +=head1 BUGS + +B is currently never called. + +The return value of B is ignored. + +The B function isn't very useful because no meaningful values are +present in the parent RSA structure when it is called. + +=head1 SEE ALSO + +L, L + +=head1 HISTORY + +RSA_get_ex_new_index(), RSA_set_ex_data() and RSA_get_ex_data() are +available since SSLeay 0.9.0. + +=cut -- cgit v1.2.3