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