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