From fd38fecc1a79b9365a6ecbc2a908f2eb9751db6f Mon Sep 17 00:00:00 2001 From: "Dr. Stephen Henson" Date: Mon, 24 Jan 2000 01:50:17 +0000 Subject: [PATCH] Document how CRYPTO_EX_DATA stuff works for RSA structures. Other structures behave in a similar way. --- doc/crypto/RSA_get_ex_new_index.pod | 102 ++++++++++++++++++++++++++-- 1 file changed, 95 insertions(+), 7 deletions(-) diff --git a/doc/crypto/RSA_get_ex_new_index.pod b/doc/crypto/RSA_get_ex_new_index.pod index 2afcc20401..c56adb8b7f 100644 --- a/doc/crypto/RSA_get_ex_new_index.pod +++ b/doc/crypto/RSA_get_ex_new_index.pod @@ -2,26 +2,114 @@ =head1 NAME -RSA_get_ex_new_index, RSA_set_ex_data, RSA_get_ex_data - ... +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, char *argp, int (*new_func)(), - int (*dup_func)(), void (*free_func)()); + 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); + + int new_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, + int idx, long argl, void *argp); + + void free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, + int idx, long argl, void *argp); + int dup_func(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d, + int idx, long argl, void *argp); - int RSA_set_ex_data(RSA *r,int idx,char *arg); - char *RSA_get_ex_data(RSA *r, int idx); =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 pointer 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 B. + +=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 -- 2.25.1