doc/man3/CRYPTO_get_ex_new_index.pod

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