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