doc/crypto/CRYPTO_get_ex_new_index.pod

   1 =pod
   2
   3 =head1 NAME
   4
   5 CRYPTO_free_ex_index, CRYPTO_get_ex_new_index, CRYPTO_set_ex_data,
   6 CRYPTO_get_ex_data, CRYPTO_free_ex_data
   7 - functions supporting application-specific data
   8
   9 =head1 SYNOPSIS
  10
  11  #include <openssl/crypto.h>
  12
  13  int CRYPTO_get_ex_new_index(int class_index,
  14                 long argl, void *argp,
  15                 CRYPTO_EX_new *new_func,
  16                 CRYPTO_EX_dup *dup_func,
  17                 CRYPTO_EX_free *free_func);
  18
  19  typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  20                            int idx, long argl, void *argp);
  21  typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  22                              int idx, long argl, void *argp);
  23  typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from,
  24                            void *from_d, int idx, long argl, void *argp);
  25
  26  int CRYPTO_set_ex_data(CRYPTO_EX_DATA *r, int idx, void *arg);
  27
  28  void *CRYPTO_get_ex_data(CRYPTO_EX_DATA *r, int idx);
  29
  30  void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *r);
  31
  32  int CRYPTO_free_ex_index(int class_index, int idx);
  33
  34 =head1 DESCRIPTION
  35
  36 Several OpenSSL structures can have application-specific data attached to them,
  37 known as "exdata."
  38 The specific structures are:
  39
  40     SSL
  41     SSL_CTX
  42     SSL_SESSION
  43     X509
  44     X509_STORE
  45     X509_STORE_CTX
  46     DH
  47     DSA
  48     ECDH
  49     ECDSA
  50     RSA
  51     ENGINE
  52     UI
  53     BIO
  54
  55 Each is identified by an B<CRYPTO_EX_INDEX_xxx> define in the B<crypto.h>
  56 header file.  In addition, B<CRYPTO_EX_INDEX_APP> is reserved for
  57 applications to use this facility for their own structures.
  58
  59 The API described here is used by OpenSSL to manipulate exdata for specific
  60 structures.  Since the application data can be anything at all it is passed
  61 and retrieved as a B<void *> type.
  62
  63 Exdata types are identified by an B<index>, an integer guaranteed to be
  64 unique within structures for the lifetime of the program.  Applications
  65 using exdata typically call B<CRYPTO_get_ex_new_index> at startup, and
  66 store the result in a global variable, or write a wrapper function to
  67 provide lazy evaluation.  The B<class_index> should be one of the
  68 B<CRYPTO_EX_INDEX_xxx> values. The B<argl> and B<argp> parameters are saved
  69 to be passed to the callbacks but are otherwise not used.  In order to
  70 transparently manipulate exdata, three callbacks must be provided. The
  71 semantics of those callbacks are described below.
  72
  73 When copying or releasing objects with exdata, the callback functions
  74 are called in increasing order of their B<index> value.
  75
  76 If a dynamic library can be unloaded, it should call CRYPTO_free_ex_index()
  77 when this is done.
  78 This will replace the callbacks with no-ops
  79 so that applications don't crash.  Any existing exdata will be leaked.
  80
  81 To set or get the exdata on an object, the appropriate type-specific
  82 routine must be used.  This is because the containing structure is opaque
  83 and the B<CRYPTO_EX_DATA> field is not accessible.  In both API's, the
  84 B<idx> parameter should be an already-created index value.
  85
  86 When setting exdata, the pointer specified with a particular index is saved,
  87 and returned on a subsequent "get" call.  If the application is going to
  88 release the data, it must make sure to set a B<NULL> value at the index,
  89 to avoid likely double-free crash.
  90
  91 The function B<CRYPTO_free_ex_data> is used to free all exdata attached
  92 to a structure. The appropriate type-specific routine must be used.
  93 The B<class_index> identifies the structure type, the B<obj> is
  94 be the pointer to the actual structure, and B<r> is a pointer to the
  95 structure's exdata field.
  96
  97 =head2 Callback Functions
  98
  99 This section describes how the callback functions are used. Applications
 100 that are defining their own exdata using B<CYPRTO_EX_INDEX_APP> must
 101 call them as described here.
 102
 103 When a structure is initially allocated (such as RSA_new()) then the
 104 new_func() is called for every defined index. There is no requirement
 105 that the entire parent, or containing, structure has been set up.
 106 The new_func() is typically used only to allocate memory to store the
 107 exdata, and perhaps an "initialized" flag within that memory.
 108 The exdata value should be set by calling CRYPTO_set_ex_data().
 109
 110 When a structure is free'd (such as SSL_CTX_free()) then the
 111 free_func() is called for every defined index.  Again, the state of the
 112 parent structure is not guaranteed.  The free_func() may be called with a
 113 NULL pointer.
 114
 115 Both new_func() and free_func() take the same parameters.
 116 The B<parent> is the pointer to the structure that contains the exdata.
 117 The B<ptr> is the current exdata item; for new_func() this will typically
 118 be NULL.  The B<r> parameter is a pointer to the exdata field of the object.
 119 The B<idx> is the index and is the value returned when the callbacks were
 120 initially registered via CRYPTO_get_ex_new_index() and can be used if
 121 the same callback handles different types of exdata.
 122
 123 dup_func() is called when a structure is being copied.  This is only done
 124 for B<SSL> and B<SSL_SESSION> objects.  The B<to> and B<from> parameters
 125 are pointers to the destination and source B<CRYPTO_EX_DATA> structures,
 126 respectively.  The B<srcp> parameter is a pointer to the source exdata.
 127 When the dup_func() returns, the value in B<srcp> is copied to the
 128 destination ex_data.  If the pointer contained in B<srcp> is not modified,
 129 then both B<to> and B<from> will point to the same data.  The B<idx>,
 130 B<argl> and B<argp> parameters are as described for the other two callbacks.
 131
 132 =head1 RETURN VALUES
 133
 134 CRYPTO_get_ex_new_index() returns a new index or -1 on failure; the
 135 value B<0> is reserved for the legacy "app_data" API's.
 136
 137 CRYPTO_free_ex_index() and
 138 CRYPTO_set_ex_data() return 1 on success or 0 on failure.
 139
 140 CRYPTO_get_ex_data() returns the application data or NULL on failure;
 141 note that NULL may be a valid value.
 142
 143 dup_func() should return 0 for failure and 1 for success.
 144
 145 =cut