Remove unnecessary trailing whitespace
[openssl.git] / crypto / engine / eng_lib.c
1 /*
2  * Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include "e_os.h"
11 #include "eng_int.h"
12 #include <openssl/rand.h>
13 #include "internal/refcount.h"
14
15 CRYPTO_RWLOCK *global_engine_lock;
16
17 CRYPTO_ONCE engine_lock_init = CRYPTO_ONCE_STATIC_INIT;
18
19 /* The "new"/"free" stuff first */
20
21 DEFINE_RUN_ONCE(do_engine_lock_init)
22 {
23     if (!OPENSSL_init_crypto(0, NULL))
24         return 0;
25     global_engine_lock = CRYPTO_THREAD_lock_new();
26     return global_engine_lock != NULL;
27 }
28
29 ENGINE *ENGINE_new(void)
30 {
31     ENGINE *ret;
32
33     if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)
34         || (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
35         ENGINEerr(ENGINE_F_ENGINE_NEW, ERR_R_MALLOC_FAILURE);
36         return NULL;
37     }
38     ret->struct_ref = 1;
39     engine_ref_debug(ret, 0, 1);
40     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_ENGINE, ret, &ret->ex_data)) {
41         OPENSSL_free(ret);
42         return NULL;
43     }
44     return ret;
45 }
46
47 /*
48  * Placed here (close proximity to ENGINE_new) so that modifications to the
49  * elements of the ENGINE structure are more likely to be caught and changed
50  * here.
51  */
52 void engine_set_all_null(ENGINE *e)
53 {
54     e->id = NULL;
55     e->name = NULL;
56     e->rsa_meth = NULL;
57     e->dsa_meth = NULL;
58     e->dh_meth = NULL;
59     e->rand_meth = NULL;
60     e->ciphers = NULL;
61     e->digests = NULL;
62     e->destroy = NULL;
63     e->init = NULL;
64     e->finish = NULL;
65     e->ctrl = NULL;
66     e->load_privkey = NULL;
67     e->load_pubkey = NULL;
68     e->cmd_defns = NULL;
69     e->flags = 0;
70 }
71
72 int engine_free_util(ENGINE *e, int not_locked)
73 {
74     int i;
75
76     if (e == NULL)
77         return 1;
78     if (not_locked)
79         CRYPTO_DOWN_REF(&e->struct_ref, &i, global_engine_lock);
80     else
81         i = --e->struct_ref;
82     engine_ref_debug(e, 0, -1);
83     if (i > 0)
84         return 1;
85     REF_ASSERT_ISNT(i < 0);
86     /* Free up any dynamically allocated public key methods */
87     engine_pkey_meths_free(e);
88     engine_pkey_asn1_meths_free(e);
89     /*
90      * Give the ENGINE a chance to do any structural cleanup corresponding to
91      * allocation it did in its constructor (eg. unload error strings)
92      */
93     if (e->destroy)
94         e->destroy(e);
95     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_ENGINE, e, &e->ex_data);
96     OPENSSL_free(e);
97     return 1;
98 }
99
100 int ENGINE_free(ENGINE *e)
101 {
102     return engine_free_util(e, 1);
103 }
104
105 /* Cleanup stuff */
106
107 /*
108  * engine_cleanup_int() is coded such that anything that does work that will
109  * need cleanup can register a "cleanup" callback here. That way we don't get
110  * linker bloat by referring to all *possible* cleanups, but any linker bloat
111  * into code "X" will cause X's cleanup function to end up here.
112  */
113 static STACK_OF(ENGINE_CLEANUP_ITEM) *cleanup_stack = NULL;
114 static int int_cleanup_check(int create)
115 {
116     if (cleanup_stack)
117         return 1;
118     if (!create)
119         return 0;
120     cleanup_stack = sk_ENGINE_CLEANUP_ITEM_new_null();
121     return (cleanup_stack ? 1 : 0);
122 }
123
124 static ENGINE_CLEANUP_ITEM *int_cleanup_item(ENGINE_CLEANUP_CB *cb)
125 {
126     ENGINE_CLEANUP_ITEM *item;
127
128     if ((item = OPENSSL_malloc(sizeof(*item))) == NULL) {
129         ENGINEerr(ENGINE_F_INT_CLEANUP_ITEM, ERR_R_MALLOC_FAILURE);
130         return NULL;
131     }
132     item->cb = cb;
133     return item;
134 }
135
136 void engine_cleanup_add_first(ENGINE_CLEANUP_CB *cb)
137 {
138     ENGINE_CLEANUP_ITEM *item;
139
140     if (!int_cleanup_check(1))
141         return;
142     item = int_cleanup_item(cb);
143     if (item)
144         sk_ENGINE_CLEANUP_ITEM_insert(cleanup_stack, item, 0);
145 }
146
147 void engine_cleanup_add_last(ENGINE_CLEANUP_CB *cb)
148 {
149     ENGINE_CLEANUP_ITEM *item;
150     if (!int_cleanup_check(1))
151         return;
152     item = int_cleanup_item(cb);
153     if (item != NULL) {
154         if (sk_ENGINE_CLEANUP_ITEM_push(cleanup_stack, item) <= 0)
155             OPENSSL_free(item);
156     }
157 }
158
159 /* The API function that performs all cleanup */
160 static void engine_cleanup_cb_free(ENGINE_CLEANUP_ITEM *item)
161 {
162     (*(item->cb)) ();
163     OPENSSL_free(item);
164 }
165
166 void engine_cleanup_int(void)
167 {
168     if (int_cleanup_check(0)) {
169         sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack,
170                                         engine_cleanup_cb_free);
171         cleanup_stack = NULL;
172     }
173     CRYPTO_THREAD_lock_free(global_engine_lock);
174 }
175
176 /* Now the "ex_data" support */
177
178 int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg)
179 {
180     return CRYPTO_set_ex_data(&e->ex_data, idx, arg);
181 }
182
183 void *ENGINE_get_ex_data(const ENGINE *e, int idx)
184 {
185     return CRYPTO_get_ex_data(&e->ex_data, idx);
186 }
187
188 /*
189  * Functions to get/set an ENGINE's elements - mainly to avoid exposing the
190  * ENGINE structure itself.
191  */
192
193 int ENGINE_set_id(ENGINE *e, const char *id)
194 {
195     if (id == NULL) {
196         ENGINEerr(ENGINE_F_ENGINE_SET_ID, ERR_R_PASSED_NULL_PARAMETER);
197         return 0;
198     }
199     e->id = id;
200     return 1;
201 }
202
203 int ENGINE_set_name(ENGINE *e, const char *name)
204 {
205     if (name == NULL) {
206         ENGINEerr(ENGINE_F_ENGINE_SET_NAME, ERR_R_PASSED_NULL_PARAMETER);
207         return 0;
208     }
209     e->name = name;
210     return 1;
211 }
212
213 int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f)
214 {
215     e->destroy = destroy_f;
216     return 1;
217 }
218
219 int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f)
220 {
221     e->init = init_f;
222     return 1;
223 }
224
225 int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f)
226 {
227     e->finish = finish_f;
228     return 1;
229 }
230
231 int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f)
232 {
233     e->ctrl = ctrl_f;
234     return 1;
235 }
236
237 int ENGINE_set_flags(ENGINE *e, int flags)
238 {
239     e->flags = flags;
240     return 1;
241 }
242
243 int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns)
244 {
245     e->cmd_defns = defns;
246     return 1;
247 }
248
249 const char *ENGINE_get_id(const ENGINE *e)
250 {
251     return e->id;
252 }
253
254 const char *ENGINE_get_name(const ENGINE *e)
255 {
256     return e->name;
257 }
258
259 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e)
260 {
261     return e->destroy;
262 }
263
264 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e)
265 {
266     return e->init;
267 }
268
269 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e)
270 {
271     return e->finish;
272 }
273
274 ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e)
275 {
276     return e->ctrl;
277 }
278
279 int ENGINE_get_flags(const ENGINE *e)
280 {
281     return e->flags;
282 }
283
284 const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e)
285 {
286     return e->cmd_defns;
287 }
288
289 /*
290  * eng_lib.o is pretty much linked into anything that touches ENGINE already,
291  * so put the "static_state" hack here.
292  */
293
294 static int internal_static_hack = 0;
295
296 void *ENGINE_get_static_state(void)
297 {
298     return &internal_static_hack;
299 }