1CRYPTO_GET_EX_NEW_INDEX(3)          OpenSSL         CRYPTO_GET_EX_NEW_INDEX(3)
2
3
4

NAME

6       CRYPTO_EX_new, CRYPTO_EX_free, CRYPTO_EX_dup, CRYPTO_free_ex_index,
7       CRYPTO_get_ex_new_index, CRYPTO_set_ex_data, CRYPTO_get_ex_data,
8       CRYPTO_free_ex_data, CRYPTO_new_ex_data - functions supporting
9       application-specific data
10

SYNOPSIS

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

DESCRIPTION

38       Several OpenSSL structures can have application-specific data attached
39       to them, known as "exdata."  The specific structures are:
40
41           APP
42           BIO
43           DH
44           DRBG
45           DSA
46           EC_KEY
47           ENGINE
48           RSA
49           SSL
50           SSL_CTX
51           SSL_SESSION
52           UI
53           UI_METHOD
54           X509
55           X509_STORE
56           X509_STORE_CTX
57
58       Each is identified by an CRYPTO_EX_INDEX_xxx define in the crypto.h
59       header file.  In addition, 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
63       specific structures.  Since the application data can be anything at all
64       it is passed and retrieved as a void * type.
65
66       The CRYPTO_EX_DATA type is opaque.  To initialize the exdata part of a
67       structure, call CRYPTO_new_ex_data(). This is only necessary for
68       CRYPTO_EX_INDEX_APP objects.
69
70       Exdata types are identified by an index, an integer guaranteed to be
71       unique within structures for the lifetime of the program.  Applications
72       using exdata typically call 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 class_index should be one of the
75       CRYPTO_EX_INDEX_xxx values. The argl and argp parameters are saved to
76       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 index value.
82
83       If a dynamic library can be unloaded, it should call
84       CRYPTO_free_ex_index() when this is done.  This will replace the
85       callbacks with no-ops so that applications don't crash.  Any existing
86       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
90       opaque and the CRYPTO_EX_DATA field is not accessible.  In both API's,
91       the idx parameter should be an already-created index value.
92
93       When setting exdata, the pointer specified with a particular index is
94       saved, and returned on a subsequent "get" call.  If the application is
95       going to release the data, it must make sure to set a NULL value at the
96       index, to avoid likely double-free crashes.
97
98       The function CRYPTO_free_ex_data is used to free all exdata attached to
99       a structure. The appropriate type-specific routine must be used.  The
100       class_index identifies the structure type, the obj is be the pointer to
101       the actual structure, and r is a pointer to the structure's exdata
102       field.
103
104   Callback Functions
105       This section describes how the callback functions are used.
106       Applications that are defining their own exdata using
107       CYPRTO_EX_INDEX_APP must 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.  The
112       new_func() is typically used only to allocate memory to store the
113       exdata, and perhaps an "initialized" flag within that memory.  The
114       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
119       a NULL pointer.
120
121       Both new_func() and free_func() take the same parameters.  The parent
122       is the pointer to the structure that contains the exdata.  The ptr is
123       the current exdata item; for new_func() this will typically be NULL.
124       The r parameter is a pointer to the exdata field of the object.  The
125       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
130       done for SSL, SSL_SESSION, EC_KEY objects and BIO chains via
131       BIO_dup_chain().  The to and from parameters are pointers to the
132       destination and source CRYPTO_EX_DATA structures, respectively.  The
133       from_d parameter needs to be cast to a void **pptr as the API has
134       currently the wrong signature; that will be changed in a future
135       version.  The *pptr is a pointer to the source exdata.  When the
136       dup_func() returns, the value in *pptr is copied to the destination
137       ex_data.  If the pointer contained in *pptr is not modified by the
138       dup_func(), then both to and from will point to the same data.  The
139       idx, argl and argp parameters are as described for the other two
140       callbacks.  If the dup_func() returns 0 the whole CRYPTO_dup_ex_data()
141       will fail.
142

RETURN VALUES

144       CRYPTO_get_ex_new_index() returns a new index or -1 on failure.
145
146       CRYPTO_free_ex_index() and CRYPTO_set_ex_data() return 1 on success or
147       0 on failure.
148
149       CRYPTO_get_ex_data() returns the application data or NULL on failure;
150       note that NULL may be a valid value.
151
152       dup_func() should return 0 for failure and 1 for success.
153
155       Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
156
157       Licensed under the OpenSSL license (the "License").  You may not use
158       this file except in compliance with the License.  You can obtain a copy
159       in the file LICENSE in the source distribution or at
160       <https://www.openssl.org/source/license.html>.
161
162
163
1641.1.1                             2018-09-11        CRYPTO_GET_EX_NEW_INDEX(3)
Impressum