]>
Commit | Line | Data |
---|---|---|
a5db6fa5 | 1 | /* crypto/store/store.h -*- mode:C; c-file-style: "eay" -*- */ |
0f113f3e MC |
2 | /* |
3 | * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project | |
4 | * 2003. | |
a5db6fa5 RL |
5 | */ |
6 | /* ==================================================================== | |
7 | * Copyright (c) 2003 The OpenSSL Project. All rights reserved. | |
8 | * | |
9 | * Redistribution and use in source and binary forms, with or without | |
10 | * modification, are permitted provided that the following conditions | |
11 | * are met: | |
12 | * | |
13 | * 1. Redistributions of source code must retain the above copyright | |
0f113f3e | 14 | * notice, this list of conditions and the following disclaimer. |
a5db6fa5 RL |
15 | * |
16 | * 2. Redistributions in binary form must reproduce the above copyright | |
17 | * notice, this list of conditions and the following disclaimer in | |
18 | * the documentation and/or other materials provided with the | |
19 | * distribution. | |
20 | * | |
21 | * 3. All advertising materials mentioning features or use of this | |
22 | * software must display the following acknowledgment: | |
23 | * "This product includes software developed by the OpenSSL Project | |
24 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | |
25 | * | |
26 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
27 | * endorse or promote products derived from this software without | |
28 | * prior written permission. For written permission, please contact | |
29 | * openssl-core@openssl.org. | |
30 | * | |
31 | * 5. Products derived from this software may not be called "OpenSSL" | |
32 | * nor may "OpenSSL" appear in their names without prior written | |
33 | * permission of the OpenSSL Project. | |
34 | * | |
35 | * 6. Redistributions of any form whatsoever must retain the following | |
36 | * acknowledgment: | |
37 | * "This product includes software developed by the OpenSSL Project | |
38 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | |
39 | * | |
40 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
41 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
42 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
43 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
44 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
45 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
46 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
47 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
49 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
50 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
51 | * OF THE POSSIBILITY OF SUCH DAMAGE. | |
52 | * ==================================================================== | |
53 | * | |
54 | * This product includes cryptographic software written by Eric Young | |
55 | * (eay@cryptsoft.com). This product includes software written by Tim | |
56 | * Hudson (tjh@cryptsoft.com). | |
57 | * | |
58 | */ | |
59 | ||
60 | #ifndef HEADER_STORE_H | |
0f113f3e | 61 | # define HEADER_STORE_H |
a5db6fa5 | 62 | |
0f113f3e | 63 | # include <openssl/opensslconf.h> |
605b04f6 | 64 | |
0f113f3e MC |
65 | # ifdef OPENSSL_NO_STORE |
66 | # error STORE is disabled. | |
67 | # endif | |
605b04f6 | 68 | |
0f113f3e MC |
69 | # include <openssl/ossl_typ.h> |
70 | # ifdef OPENSSL_USE_DEPRECATED | |
71 | # include <openssl/evp.h> | |
72 | # include <openssl/bn.h> | |
73 | # include <openssl/x509.h> | |
74 | # endif | |
a5db6fa5 RL |
75 | |
76 | #ifdef __cplusplus | |
77 | extern "C" { | |
78 | #endif | |
79 | ||
3a87a9b9 GT |
80 | /* Already defined in ossl_typ.h */ |
81 | /* typedef struct store_st STORE; */ | |
82 | /* typedef struct store_method_st STORE_METHOD; */ | |
a5db6fa5 | 83 | |
0f113f3e MC |
84 | /* |
85 | * All the following functions return 0, a negative number or NULL on error. | |
86 | * When everything is fine, they return a positive value or a non-NULL | |
87 | * pointer, all depending on their purpose. | |
88 | */ | |
a5db6fa5 RL |
89 | |
90 | /* Creators and destructor. */ | |
91 | STORE *STORE_new_method(const STORE_METHOD *method); | |
f59c9419 | 92 | STORE *STORE_new_engine(ENGINE *engine); |
a5db6fa5 RL |
93 | void STORE_free(STORE *ui); |
94 | ||
0f113f3e MC |
95 | /* |
96 | * Give a user interface parametrised control commands. This can be used to | |
97 | * send down an integer, a data pointer or a function pointer, as well as be | |
98 | * used to get information from a STORE. | |
99 | */ | |
100 | int STORE_ctrl(STORE *store, int cmd, long i, void *p, void (*f) (void)); | |
a5db6fa5 | 101 | |
0f113f3e MC |
102 | /* |
103 | * A control to set the directory with keys and certificates. Used by the | |
104 | * built-in directory level method. | |
105 | */ | |
106 | # define STORE_CTRL_SET_DIRECTORY 0x0001 | |
107 | /* | |
108 | * A control to set a file to load. Used by the built-in file level method. | |
109 | */ | |
110 | # define STORE_CTRL_SET_FILE 0x0002 | |
111 | /* | |
112 | * A control to set a configuration file to load. Can be used by any method | |
113 | * that wishes to load a configuration file. | |
114 | */ | |
115 | # define STORE_CTRL_SET_CONF_FILE 0x0003 | |
116 | /* | |
117 | * A control to set a the section of the loaded configuration file. Can be | |
118 | * used by any method that wishes to load a configuration file. | |
119 | */ | |
120 | # define STORE_CTRL_SET_CONF_SECTION 0x0004 | |
a5db6fa5 RL |
121 | |
122 | /* Some methods may use extra data */ | |
0f113f3e MC |
123 | # define STORE_set_app_data(s,arg) STORE_set_ex_data(s,0,arg) |
124 | # define STORE_get_app_data(s) STORE_get_ex_data(s,0) | |
e6390aca RS |
125 | |
126 | #define STORE_get_ex_new_index(l, p, newf, dupf, freef) \ | |
127 | CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_STORE, l, p, newf, dupf, freef) | |
0f113f3e | 128 | int STORE_set_ex_data(STORE *r, int idx, void *arg); |
a5db6fa5 RL |
129 | void *STORE_get_ex_data(STORE *r, int idx); |
130 | ||
131 | /* Use specific methods instead of the built-in one */ | |
132 | const STORE_METHOD *STORE_get_method(STORE *store); | |
133 | const STORE_METHOD *STORE_set_method(STORE *store, const STORE_METHOD *meth); | |
134 | ||
135 | /* The standard OpenSSL methods. */ | |
0f113f3e MC |
136 | /* |
137 | * This is the in-memory method. It does everything except revoking and | |
138 | * updating, and is of course volatile. It's used by other methods that have | |
139 | * an in-memory cache. | |
140 | */ | |
a5db6fa5 | 141 | const STORE_METHOD *STORE_Memory(void); |
0f113f3e MC |
142 | # if 0 /* Not yet implemented */ |
143 | /* | |
144 | * This is the directory store. It does everything except revoking and | |
145 | * updating, and uses STORE_Memory() to cache things in memory. | |
146 | */ | |
a5db6fa5 | 147 | const STORE_METHOD *STORE_Directory(void); |
0f113f3e MC |
148 | /* |
149 | * This is the file store. It does everything except revoking and updating, | |
150 | * and uses STORE_Memory() to cache things in memory. Certificates are added | |
151 | * to it with the store operation, and it will only get cached certificates. | |
152 | */ | |
a5db6fa5 | 153 | const STORE_METHOD *STORE_File(void); |
0f113f3e | 154 | # endif |
a5db6fa5 | 155 | |
0f113f3e MC |
156 | /* |
157 | * Store functions take a type code for the type of data they should store or | |
158 | * fetch | |
159 | */ | |
160 | typedef enum STORE_object_types { | |
161 | STORE_OBJECT_TYPE_X509_CERTIFICATE = 0x01, /* X509 * */ | |
162 | STORE_OBJECT_TYPE_X509_CRL = 0x02, /* X509_CRL * */ | |
163 | STORE_OBJECT_TYPE_PRIVATE_KEY = 0x03, /* EVP_PKEY * */ | |
164 | STORE_OBJECT_TYPE_PUBLIC_KEY = 0x04, /* EVP_PKEY * */ | |
165 | STORE_OBJECT_TYPE_NUMBER = 0x05, /* BIGNUM * */ | |
166 | STORE_OBJECT_TYPE_ARBITRARY = 0x06, /* BUF_MEM * */ | |
167 | STORE_OBJECT_TYPE_NUM = 0x06 /* The amount of known object types */ | |
168 | } STORE_OBJECT_TYPES; | |
a5db6fa5 | 169 | /* List of text strings corresponding to the object types. */ |
0f113f3e MC |
170 | extern const char *const STORE_object_type_string[STORE_OBJECT_TYPE_NUM + 1]; |
171 | ||
172 | /* | |
173 | * Some store functions take a parameter list. Those parameters come with | |
174 | * one of the following codes. The comments following the codes below | |
175 | * indicate what type the value should be a pointer to. | |
176 | */ | |
177 | typedef enum STORE_params { | |
178 | STORE_PARAM_EVP_TYPE = 0x01, /* int */ | |
179 | STORE_PARAM_BITS = 0x02, /* size_t */ | |
180 | STORE_PARAM_KEY_PARAMETERS = 0x03, /* ??? */ | |
181 | STORE_PARAM_KEY_NO_PARAMETERS = 0x04, /* N/A */ | |
182 | STORE_PARAM_AUTH_PASSPHRASE = 0x05, /* char * */ | |
e36827f6 | 183 | STORE_PARAM_TYPE_NUM = 0x05 /* The amount of known parameter types */ |
0f113f3e MC |
184 | } STORE_PARAM_TYPES; |
185 | /* | |
186 | * Parameter value sizes. -1 means unknown, anything else is the required | |
187 | * size. | |
188 | */ | |
189 | extern const int STORE_param_sizes[STORE_PARAM_TYPE_NUM + 1]; | |
190 | ||
191 | /* | |
192 | * Store functions take attribute lists. Those attributes come with codes. | |
193 | * The comments following the codes below indicate what type the value should | |
194 | * be a pointer to. | |
195 | */ | |
196 | typedef enum STORE_attribs { | |
197 | STORE_ATTR_END = 0x00, | |
198 | STORE_ATTR_FRIENDLYNAME = 0x01, /* C string */ | |
199 | STORE_ATTR_KEYID = 0x02, /* 160 bit string (SHA1) */ | |
200 | STORE_ATTR_ISSUERKEYID = 0x03, /* 160 bit string (SHA1) */ | |
201 | STORE_ATTR_SUBJECTKEYID = 0x04, /* 160 bit string (SHA1) */ | |
202 | STORE_ATTR_ISSUERSERIALHASH = 0x05, /* 160 bit string (SHA1) */ | |
203 | STORE_ATTR_ISSUER = 0x06, /* X509_NAME * */ | |
204 | STORE_ATTR_SERIAL = 0x07, /* BIGNUM * */ | |
205 | STORE_ATTR_SUBJECT = 0x08, /* X509_NAME * */ | |
206 | STORE_ATTR_CERTHASH = 0x09, /* 160 bit string (SHA1) */ | |
207 | STORE_ATTR_EMAIL = 0x0a, /* C string */ | |
208 | STORE_ATTR_FILENAME = 0x0b, /* C string */ | |
209 | STORE_ATTR_TYPE_NUM = 0x0b, /* The amount of known attribute types */ | |
210 | STORE_ATTR_OR = 0xff /* This is a special separator, which | |
211 | * expresses the OR operation. */ | |
212 | } STORE_ATTR_TYPES; | |
213 | /* | |
214 | * Attribute value sizes. -1 means unknown, anything else is the required | |
215 | * size. | |
216 | */ | |
217 | extern const int STORE_attr_sizes[STORE_ATTR_TYPE_NUM + 1]; | |
218 | ||
219 | typedef enum STORE_certificate_status { | |
220 | STORE_X509_VALID = 0x00, | |
221 | STORE_X509_EXPIRED = 0x01, | |
222 | STORE_X509_SUSPENDED = 0x02, | |
223 | STORE_X509_REVOKED = 0x03 | |
224 | } STORE_CERTIFICATE_STATUS; | |
225 | ||
226 | /* | |
227 | * Engine store functions will return a structure that contains all the | |
228 | * necessary information, including revokation status for certificates. This | |
229 | * is really not needed for application authors, as the ENGINE framework | |
230 | * functions will extract the OpenSSL-specific information when at all | |
231 | * possible. However, for engine authors, it's crucial to know this | |
232 | * structure. | |
233 | */ | |
234 | typedef struct STORE_OBJECT_st { | |
235 | STORE_OBJECT_TYPES type; | |
236 | union { | |
237 | struct { | |
238 | STORE_CERTIFICATE_STATUS status; | |
239 | X509 *certificate; | |
240 | } x509; | |
241 | X509_CRL *crl; | |
242 | EVP_PKEY *key; | |
243 | BIGNUM *number; | |
244 | BUF_MEM *arbitrary; | |
245 | } data; | |
246 | } STORE_OBJECT; | |
4af31846 | 247 | DECLARE_STACK_OF(STORE_OBJECT) |
a5db6fa5 RL |
248 | STORE_OBJECT *STORE_OBJECT_new(void); |
249 | void STORE_OBJECT_free(STORE_OBJECT *data); | |
250 | ||
8d1d0f4d RS |
251 | /* A generic structure to pass assorted data in a expandable way */ |
252 | typedef struct openssl_item_st { | |
253 | int code; | |
254 | void *value; /* Not used for flag attributes */ | |
255 | size_t value_size; /* Max size of value for output, length for | |
256 | * input */ | |
257 | size_t *value_length; /* Returned length of value for output */ | |
258 | } OPENSSL_ITEM; | |
259 | ||
0f113f3e MC |
260 | /* |
261 | * The following functions handle the storage. They return 0, a negative | |
262 | * number or NULL on error, anything else on success. | |
263 | */ | |
48c36fdb | 264 | X509 *STORE_get_certificate(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 265 | OPENSSL_ITEM parameters[]); |
48c36fdb | 266 | int STORE_store_certificate(STORE *e, X509 *data, OPENSSL_ITEM attributes[], |
0f113f3e | 267 | OPENSSL_ITEM parameters[]); |
a5db6fa5 | 268 | int STORE_modify_certificate(STORE *e, OPENSSL_ITEM search_attributes[], |
0f113f3e MC |
269 | OPENSSL_ITEM add_attributes[], |
270 | OPENSSL_ITEM modify_attributes[], | |
271 | OPENSSL_ITEM delete_attributes[], | |
272 | OPENSSL_ITEM parameters[]); | |
48c36fdb | 273 | int STORE_revoke_certificate(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 274 | OPENSSL_ITEM parameters[]); |
48c36fdb | 275 | int STORE_delete_certificate(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 276 | OPENSSL_ITEM parameters[]); |
48c36fdb | 277 | void *STORE_list_certificate_start(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 278 | OPENSSL_ITEM parameters[]); |
a5db6fa5 RL |
279 | X509 *STORE_list_certificate_next(STORE *e, void *handle); |
280 | int STORE_list_certificate_end(STORE *e, void *handle); | |
281 | int STORE_list_certificate_endp(STORE *e, void *handle); | |
48c36fdb | 282 | EVP_PKEY *STORE_generate_key(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 283 | OPENSSL_ITEM parameters[]); |
48c36fdb | 284 | EVP_PKEY *STORE_get_private_key(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 285 | OPENSSL_ITEM parameters[]); |
48c36fdb | 286 | int STORE_store_private_key(STORE *e, EVP_PKEY *data, |
0f113f3e MC |
287 | OPENSSL_ITEM attributes[], |
288 | OPENSSL_ITEM parameters[]); | |
a5db6fa5 | 289 | int STORE_modify_private_key(STORE *e, OPENSSL_ITEM search_attributes[], |
0f113f3e MC |
290 | OPENSSL_ITEM add_sttributes[], |
291 | OPENSSL_ITEM modify_attributes[], | |
292 | OPENSSL_ITEM delete_attributes[], | |
293 | OPENSSL_ITEM parameters[]); | |
48c36fdb | 294 | int STORE_revoke_private_key(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 295 | OPENSSL_ITEM parameters[]); |
48c36fdb | 296 | int STORE_delete_private_key(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 297 | OPENSSL_ITEM parameters[]); |
48c36fdb | 298 | void *STORE_list_private_key_start(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 299 | OPENSSL_ITEM parameters[]); |
a5db6fa5 RL |
300 | EVP_PKEY *STORE_list_private_key_next(STORE *e, void *handle); |
301 | int STORE_list_private_key_end(STORE *e, void *handle); | |
302 | int STORE_list_private_key_endp(STORE *e, void *handle); | |
48c36fdb | 303 | EVP_PKEY *STORE_get_public_key(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e MC |
304 | OPENSSL_ITEM parameters[]); |
305 | int STORE_store_public_key(STORE *e, EVP_PKEY *data, | |
306 | OPENSSL_ITEM attributes[], | |
307 | OPENSSL_ITEM parameters[]); | |
a5db6fa5 | 308 | int STORE_modify_public_key(STORE *e, OPENSSL_ITEM search_attributes[], |
0f113f3e MC |
309 | OPENSSL_ITEM add_sttributes[], |
310 | OPENSSL_ITEM modify_attributes[], | |
311 | OPENSSL_ITEM delete_attributes[], | |
312 | OPENSSL_ITEM parameters[]); | |
48c36fdb | 313 | int STORE_revoke_public_key(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 314 | OPENSSL_ITEM parameters[]); |
48c36fdb | 315 | int STORE_delete_public_key(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 316 | OPENSSL_ITEM parameters[]); |
48c36fdb | 317 | void *STORE_list_public_key_start(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 318 | OPENSSL_ITEM parameters[]); |
a5db6fa5 RL |
319 | EVP_PKEY *STORE_list_public_key_next(STORE *e, void *handle); |
320 | int STORE_list_public_key_end(STORE *e, void *handle); | |
321 | int STORE_list_public_key_endp(STORE *e, void *handle); | |
48c36fdb | 322 | X509_CRL *STORE_generate_crl(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 323 | OPENSSL_ITEM parameters[]); |
48c36fdb | 324 | X509_CRL *STORE_get_crl(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 325 | OPENSSL_ITEM parameters[]); |
48c36fdb | 326 | int STORE_store_crl(STORE *e, X509_CRL *data, OPENSSL_ITEM attributes[], |
0f113f3e | 327 | OPENSSL_ITEM parameters[]); |
a5db6fa5 | 328 | int STORE_modify_crl(STORE *e, OPENSSL_ITEM search_attributes[], |
0f113f3e MC |
329 | OPENSSL_ITEM add_sttributes[], |
330 | OPENSSL_ITEM modify_attributes[], | |
331 | OPENSSL_ITEM delete_attributes[], | |
332 | OPENSSL_ITEM parameters[]); | |
48c36fdb | 333 | int STORE_delete_crl(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 334 | OPENSSL_ITEM parameters[]); |
48c36fdb | 335 | void *STORE_list_crl_start(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 336 | OPENSSL_ITEM parameters[]); |
a5db6fa5 RL |
337 | X509_CRL *STORE_list_crl_next(STORE *e, void *handle); |
338 | int STORE_list_crl_end(STORE *e, void *handle); | |
339 | int STORE_list_crl_endp(STORE *e, void *handle); | |
48c36fdb | 340 | int STORE_store_number(STORE *e, BIGNUM *data, OPENSSL_ITEM attributes[], |
0f113f3e | 341 | OPENSSL_ITEM parameters[]); |
a5db6fa5 | 342 | int STORE_modify_number(STORE *e, OPENSSL_ITEM search_attributes[], |
0f113f3e MC |
343 | OPENSSL_ITEM add_sttributes[], |
344 | OPENSSL_ITEM modify_attributes[], | |
345 | OPENSSL_ITEM delete_attributes[], | |
346 | OPENSSL_ITEM parameters[]); | |
48c36fdb | 347 | BIGNUM *STORE_get_number(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 348 | OPENSSL_ITEM parameters[]); |
48c36fdb | 349 | int STORE_delete_number(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 350 | OPENSSL_ITEM parameters[]); |
48c36fdb | 351 | int STORE_store_arbitrary(STORE *e, BUF_MEM *data, OPENSSL_ITEM attributes[], |
0f113f3e | 352 | OPENSSL_ITEM parameters[]); |
742b139f | 353 | int STORE_modify_arbitrary(STORE *e, OPENSSL_ITEM search_attributes[], |
0f113f3e MC |
354 | OPENSSL_ITEM add_sttributes[], |
355 | OPENSSL_ITEM modify_attributes[], | |
356 | OPENSSL_ITEM delete_attributes[], | |
357 | OPENSSL_ITEM parameters[]); | |
48c36fdb | 358 | BUF_MEM *STORE_get_arbitrary(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 359 | OPENSSL_ITEM parameters[]); |
48c36fdb | 360 | int STORE_delete_arbitrary(STORE *e, OPENSSL_ITEM attributes[], |
0f113f3e | 361 | OPENSSL_ITEM parameters[]); |
a5db6fa5 RL |
362 | |
363 | /* Create and manipulate methods */ | |
364 | STORE_METHOD *STORE_create_method(char *name); | |
365 | void STORE_destroy_method(STORE_METHOD *store_method); | |
366 | ||
367 | /* These callback types are use for store handlers */ | |
0f113f3e MC |
368 | typedef int (*STORE_INITIALISE_FUNC_PTR) (STORE *); |
369 | typedef void (*STORE_CLEANUP_FUNC_PTR) (STORE *); | |
370 | typedef STORE_OBJECT *(*STORE_GENERATE_OBJECT_FUNC_PTR)(STORE *, | |
371 | STORE_OBJECT_TYPES | |
372 | type, | |
373 | OPENSSL_ITEM | |
374 | attributes[], | |
375 | OPENSSL_ITEM | |
376 | parameters[]); | |
377 | typedef STORE_OBJECT *(*STORE_GET_OBJECT_FUNC_PTR)(STORE *, | |
378 | STORE_OBJECT_TYPES type, | |
379 | OPENSSL_ITEM attributes[], | |
380 | OPENSSL_ITEM parameters[]); | |
381 | typedef void *(*STORE_START_OBJECT_FUNC_PTR)(STORE *, STORE_OBJECT_TYPES type, | |
382 | OPENSSL_ITEM attributes[], | |
383 | OPENSSL_ITEM parameters[]); | |
a5db6fa5 | 384 | typedef STORE_OBJECT *(*STORE_NEXT_OBJECT_FUNC_PTR)(STORE *, void *handle); |
0f113f3e MC |
385 | typedef int (*STORE_END_OBJECT_FUNC_PTR) (STORE *, void *handle); |
386 | typedef int (*STORE_HANDLE_OBJECT_FUNC_PTR) (STORE *, STORE_OBJECT_TYPES type, | |
387 | OPENSSL_ITEM attributes[], | |
388 | OPENSSL_ITEM parameters[]); | |
389 | typedef int (*STORE_STORE_OBJECT_FUNC_PTR) (STORE *, STORE_OBJECT_TYPES type, | |
390 | STORE_OBJECT *data, | |
391 | OPENSSL_ITEM attributes[], | |
392 | OPENSSL_ITEM parameters[]); | |
393 | typedef int (*STORE_MODIFY_OBJECT_FUNC_PTR) (STORE *, STORE_OBJECT_TYPES type, | |
394 | OPENSSL_ITEM search_attributes[], | |
395 | OPENSSL_ITEM add_attributes[], | |
396 | OPENSSL_ITEM modify_attributes[], | |
397 | OPENSSL_ITEM delete_attributes[], | |
398 | OPENSSL_ITEM parameters[]); | |
399 | typedef int (*STORE_GENERIC_FUNC_PTR) (STORE *, OPENSSL_ITEM attributes[], | |
400 | OPENSSL_ITEM parameters[]); | |
401 | typedef int (*STORE_CTRL_FUNC_PTR) (STORE *, int cmd, long l, void *p, | |
402 | void (*f) (void)); | |
403 | ||
404 | int STORE_method_set_initialise_function(STORE_METHOD *sm, | |
405 | STORE_INITIALISE_FUNC_PTR init_f); | |
406 | int STORE_method_set_cleanup_function(STORE_METHOD *sm, | |
407 | STORE_CLEANUP_FUNC_PTR clean_f); | |
408 | int STORE_method_set_generate_function(STORE_METHOD *sm, | |
409 | STORE_GENERATE_OBJECT_FUNC_PTR | |
410 | generate_f); | |
411 | int STORE_method_set_get_function(STORE_METHOD *sm, | |
412 | STORE_GET_OBJECT_FUNC_PTR get_f); | |
413 | int STORE_method_set_store_function(STORE_METHOD *sm, | |
414 | STORE_STORE_OBJECT_FUNC_PTR store_f); | |
415 | int STORE_method_set_modify_function(STORE_METHOD *sm, | |
416 | STORE_MODIFY_OBJECT_FUNC_PTR store_f); | |
417 | int STORE_method_set_revoke_function(STORE_METHOD *sm, | |
418 | STORE_HANDLE_OBJECT_FUNC_PTR revoke_f); | |
419 | int STORE_method_set_delete_function(STORE_METHOD *sm, | |
420 | STORE_HANDLE_OBJECT_FUNC_PTR delete_f); | |
421 | int STORE_method_set_list_start_function(STORE_METHOD *sm, | |
422 | STORE_START_OBJECT_FUNC_PTR | |
423 | list_start_f); | |
424 | int STORE_method_set_list_next_function(STORE_METHOD *sm, | |
425 | STORE_NEXT_OBJECT_FUNC_PTR | |
426 | list_next_f); | |
427 | int STORE_method_set_list_end_function(STORE_METHOD *sm, | |
428 | STORE_END_OBJECT_FUNC_PTR list_end_f); | |
429 | int STORE_method_set_update_store_function(STORE_METHOD *sm, | |
430 | STORE_GENERIC_FUNC_PTR); | |
431 | int STORE_method_set_lock_store_function(STORE_METHOD *sm, | |
432 | STORE_GENERIC_FUNC_PTR); | |
433 | int STORE_method_set_unlock_store_function(STORE_METHOD *sm, | |
434 | STORE_GENERIC_FUNC_PTR); | |
435 | int STORE_method_set_ctrl_function(STORE_METHOD *sm, | |
436 | STORE_CTRL_FUNC_PTR ctrl_f); | |
437 | ||
438 | STORE_INITIALISE_FUNC_PTR STORE_method_get_initialise_function(STORE_METHOD | |
439 | *sm); | |
a5db6fa5 | 440 | STORE_CLEANUP_FUNC_PTR STORE_method_get_cleanup_function(STORE_METHOD *sm); |
0f113f3e MC |
441 | STORE_GENERATE_OBJECT_FUNC_PTR STORE_method_get_generate_function(STORE_METHOD |
442 | *sm); | |
a5db6fa5 RL |
443 | STORE_GET_OBJECT_FUNC_PTR STORE_method_get_get_function(STORE_METHOD *sm); |
444 | STORE_STORE_OBJECT_FUNC_PTR STORE_method_get_store_function(STORE_METHOD *sm); | |
0f113f3e MC |
445 | STORE_MODIFY_OBJECT_FUNC_PTR STORE_method_get_modify_function(STORE_METHOD |
446 | *sm); | |
447 | STORE_HANDLE_OBJECT_FUNC_PTR STORE_method_get_revoke_function(STORE_METHOD | |
448 | *sm); | |
449 | STORE_HANDLE_OBJECT_FUNC_PTR STORE_method_get_delete_function(STORE_METHOD | |
450 | *sm); | |
451 | STORE_START_OBJECT_FUNC_PTR STORE_method_get_list_start_function(STORE_METHOD | |
452 | *sm); | |
453 | STORE_NEXT_OBJECT_FUNC_PTR STORE_method_get_list_next_function(STORE_METHOD | |
454 | *sm); | |
455 | STORE_END_OBJECT_FUNC_PTR STORE_method_get_list_end_function(STORE_METHOD | |
456 | *sm); | |
457 | STORE_GENERIC_FUNC_PTR STORE_method_get_update_store_function(STORE_METHOD | |
458 | *sm); | |
a5db6fa5 | 459 | STORE_GENERIC_FUNC_PTR STORE_method_get_lock_store_function(STORE_METHOD *sm); |
0f113f3e MC |
460 | STORE_GENERIC_FUNC_PTR STORE_method_get_unlock_store_function(STORE_METHOD |
461 | *sm); | |
a5db6fa5 RL |
462 | STORE_CTRL_FUNC_PTR STORE_method_get_ctrl_function(STORE_METHOD *sm); |
463 | ||
464 | /* Method helper structures and functions. */ | |
465 | ||
0f113f3e MC |
466 | /* |
467 | * This structure is the result of parsing through the information in a list | |
468 | * of OPENSSL_ITEMs. It stores all the necessary information in a structured | |
469 | * way. | |
470 | */ | |
a5db6fa5 RL |
471 | typedef struct STORE_attr_info_st STORE_ATTR_INFO; |
472 | ||
0f113f3e MC |
473 | /* |
474 | * Parse a list of OPENSSL_ITEMs and return a pointer to a STORE_ATTR_INFO. | |
475 | * Note that we do this in the list form, since the list of OPENSSL_ITEMs can | |
476 | * come in blocks separated with STORE_ATTR_OR. Note that the value returned | |
477 | * by STORE_parse_attrs_next() must be freed with STORE_ATTR_INFO_free(). | |
478 | */ | |
a5db6fa5 RL |
479 | void *STORE_parse_attrs_start(OPENSSL_ITEM *attributes); |
480 | STORE_ATTR_INFO *STORE_parse_attrs_next(void *handle); | |
481 | int STORE_parse_attrs_end(void *handle); | |
482 | int STORE_parse_attrs_endp(void *handle); | |
483 | ||
484 | /* Creator and destructor */ | |
485 | STORE_ATTR_INFO *STORE_ATTR_INFO_new(void); | |
486 | int STORE_ATTR_INFO_free(STORE_ATTR_INFO *attrs); | |
487 | ||
488 | /* Manipulators */ | |
0f113f3e MC |
489 | char *STORE_ATTR_INFO_get0_cstr(STORE_ATTR_INFO *attrs, |
490 | STORE_ATTR_TYPES code); | |
a5db6fa5 | 491 | unsigned char *STORE_ATTR_INFO_get0_sha1str(STORE_ATTR_INFO *attrs, |
0f113f3e MC |
492 | STORE_ATTR_TYPES code); |
493 | X509_NAME *STORE_ATTR_INFO_get0_dn(STORE_ATTR_INFO *attrs, | |
494 | STORE_ATTR_TYPES code); | |
495 | BIGNUM *STORE_ATTR_INFO_get0_number(STORE_ATTR_INFO *attrs, | |
496 | STORE_ATTR_TYPES code); | |
a5db6fa5 | 497 | int STORE_ATTR_INFO_set_cstr(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code, |
0f113f3e | 498 | char *cstr, size_t cstr_size); |
a5db6fa5 | 499 | int STORE_ATTR_INFO_set_sha1str(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code, |
0f113f3e | 500 | unsigned char *sha1str, size_t sha1str_size); |
a5db6fa5 | 501 | int STORE_ATTR_INFO_set_dn(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code, |
0f113f3e | 502 | X509_NAME *dn); |
a5db6fa5 | 503 | int STORE_ATTR_INFO_set_number(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code, |
0f113f3e | 504 | BIGNUM *number); |
a5db6fa5 | 505 | int STORE_ATTR_INFO_modify_cstr(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code, |
0f113f3e MC |
506 | char *cstr, size_t cstr_size); |
507 | int STORE_ATTR_INFO_modify_sha1str(STORE_ATTR_INFO *attrs, | |
508 | STORE_ATTR_TYPES code, | |
509 | unsigned char *sha1str, | |
510 | size_t sha1str_size); | |
a5db6fa5 | 511 | int STORE_ATTR_INFO_modify_dn(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code, |
0f113f3e MC |
512 | X509_NAME *dn); |
513 | int STORE_ATTR_INFO_modify_number(STORE_ATTR_INFO *attrs, | |
514 | STORE_ATTR_TYPES code, BIGNUM *number); | |
515 | ||
516 | /* | |
517 | * Compare on basis of a bit pattern formed by the STORE_ATTR_TYPES values in | |
518 | * each contained attribute. | |
519 | */ | |
520 | int STORE_ATTR_INFO_compare(const STORE_ATTR_INFO *const *a, | |
521 | const STORE_ATTR_INFO *const *b); | |
522 | /* | |
523 | * Check if the set of attributes in a is within the range of attributes set | |
524 | * in b. | |
525 | */ | |
b52d512d | 526 | int STORE_ATTR_INFO_in_range(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b); |
a5db6fa5 RL |
527 | /* Check if the set of attributes in a are also set in b. */ |
528 | int STORE_ATTR_INFO_in(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b); | |
529 | /* Same as STORE_ATTR_INFO_in(), but also checks the attribute values. */ | |
530 | int STORE_ATTR_INFO_in_ex(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b); | |
531 | ||
a5db6fa5 | 532 | /* BEGIN ERROR CODES */ |
0f113f3e MC |
533 | /* |
534 | * The following lines are auto generated by the script mkerr.pl. Any changes | |
a5db6fa5 RL |
535 | * made after this point may be overwritten when the script is next run. |
536 | */ | |
537 | void ERR_load_STORE_strings(void); | |
538 | ||
539 | /* Error codes for the STORE functions. */ | |
540 | ||
541 | /* Function codes. */ | |
0f113f3e MC |
542 | # define STORE_F_MEM_DELETE 134 |
543 | # define STORE_F_MEM_GENERATE 135 | |
544 | # define STORE_F_MEM_LIST_END 168 | |
545 | # define STORE_F_MEM_LIST_NEXT 136 | |
546 | # define STORE_F_MEM_LIST_START 137 | |
547 | # define STORE_F_MEM_MODIFY 169 | |
548 | # define STORE_F_MEM_STORE 138 | |
549 | # define STORE_F_STORE_ATTR_INFO_GET0_CSTR 139 | |
550 | # define STORE_F_STORE_ATTR_INFO_GET0_DN 140 | |
551 | # define STORE_F_STORE_ATTR_INFO_GET0_NUMBER 141 | |
552 | # define STORE_F_STORE_ATTR_INFO_GET0_SHA1STR 142 | |
553 | # define STORE_F_STORE_ATTR_INFO_MODIFY_CSTR 143 | |
554 | # define STORE_F_STORE_ATTR_INFO_MODIFY_DN 144 | |
555 | # define STORE_F_STORE_ATTR_INFO_MODIFY_NUMBER 145 | |
556 | # define STORE_F_STORE_ATTR_INFO_MODIFY_SHA1STR 146 | |
557 | # define STORE_F_STORE_ATTR_INFO_SET_CSTR 147 | |
558 | # define STORE_F_STORE_ATTR_INFO_SET_DN 148 | |
559 | # define STORE_F_STORE_ATTR_INFO_SET_NUMBER 149 | |
560 | # define STORE_F_STORE_ATTR_INFO_SET_SHA1STR 150 | |
561 | # define STORE_F_STORE_CERTIFICATE 170 | |
562 | # define STORE_F_STORE_CTRL 161 | |
563 | # define STORE_F_STORE_DELETE_ARBITRARY 158 | |
564 | # define STORE_F_STORE_DELETE_CERTIFICATE 102 | |
565 | # define STORE_F_STORE_DELETE_CRL 103 | |
566 | # define STORE_F_STORE_DELETE_NUMBER 104 | |
567 | # define STORE_F_STORE_DELETE_PRIVATE_KEY 105 | |
568 | # define STORE_F_STORE_DELETE_PUBLIC_KEY 106 | |
569 | # define STORE_F_STORE_GENERATE_CRL 107 | |
570 | # define STORE_F_STORE_GENERATE_KEY 108 | |
571 | # define STORE_F_STORE_GET_ARBITRARY 159 | |
572 | # define STORE_F_STORE_GET_CERTIFICATE 109 | |
573 | # define STORE_F_STORE_GET_CRL 110 | |
574 | # define STORE_F_STORE_GET_NUMBER 111 | |
575 | # define STORE_F_STORE_GET_PRIVATE_KEY 112 | |
576 | # define STORE_F_STORE_GET_PUBLIC_KEY 113 | |
577 | # define STORE_F_STORE_LIST_CERTIFICATE_END 114 | |
578 | # define STORE_F_STORE_LIST_CERTIFICATE_ENDP 153 | |
579 | # define STORE_F_STORE_LIST_CERTIFICATE_NEXT 115 | |
580 | # define STORE_F_STORE_LIST_CERTIFICATE_START 116 | |
581 | # define STORE_F_STORE_LIST_CRL_END 117 | |
582 | # define STORE_F_STORE_LIST_CRL_ENDP 154 | |
583 | # define STORE_F_STORE_LIST_CRL_NEXT 118 | |
584 | # define STORE_F_STORE_LIST_CRL_START 119 | |
585 | # define STORE_F_STORE_LIST_PRIVATE_KEY_END 120 | |
586 | # define STORE_F_STORE_LIST_PRIVATE_KEY_ENDP 155 | |
587 | # define STORE_F_STORE_LIST_PRIVATE_KEY_NEXT 121 | |
588 | # define STORE_F_STORE_LIST_PRIVATE_KEY_START 122 | |
589 | # define STORE_F_STORE_LIST_PUBLIC_KEY_END 123 | |
590 | # define STORE_F_STORE_LIST_PUBLIC_KEY_ENDP 156 | |
591 | # define STORE_F_STORE_LIST_PUBLIC_KEY_NEXT 124 | |
592 | # define STORE_F_STORE_LIST_PUBLIC_KEY_START 125 | |
593 | # define STORE_F_STORE_MODIFY_ARBITRARY 162 | |
594 | # define STORE_F_STORE_MODIFY_CERTIFICATE 163 | |
595 | # define STORE_F_STORE_MODIFY_CRL 164 | |
596 | # define STORE_F_STORE_MODIFY_NUMBER 165 | |
597 | # define STORE_F_STORE_MODIFY_PRIVATE_KEY 166 | |
598 | # define STORE_F_STORE_MODIFY_PUBLIC_KEY 167 | |
599 | # define STORE_F_STORE_NEW_ENGINE 133 | |
600 | # define STORE_F_STORE_NEW_METHOD 132 | |
601 | # define STORE_F_STORE_PARSE_ATTRS_END 151 | |
602 | # define STORE_F_STORE_PARSE_ATTRS_ENDP 172 | |
603 | # define STORE_F_STORE_PARSE_ATTRS_NEXT 152 | |
604 | # define STORE_F_STORE_PARSE_ATTRS_START 171 | |
605 | # define STORE_F_STORE_REVOKE_CERTIFICATE 129 | |
606 | # define STORE_F_STORE_REVOKE_PRIVATE_KEY 130 | |
607 | # define STORE_F_STORE_REVOKE_PUBLIC_KEY 131 | |
608 | # define STORE_F_STORE_STORE_ARBITRARY 157 | |
609 | # define STORE_F_STORE_STORE_CERTIFICATE 100 | |
610 | # define STORE_F_STORE_STORE_CRL 101 | |
611 | # define STORE_F_STORE_STORE_NUMBER 126 | |
612 | # define STORE_F_STORE_STORE_PRIVATE_KEY 127 | |
613 | # define STORE_F_STORE_STORE_PUBLIC_KEY 128 | |
a5db6fa5 RL |
614 | |
615 | /* Reason codes. */ | |
0f113f3e MC |
616 | # define STORE_R_ALREADY_HAS_A_VALUE 127 |
617 | # define STORE_R_FAILED_DELETING_ARBITRARY 132 | |
618 | # define STORE_R_FAILED_DELETING_CERTIFICATE 100 | |
619 | # define STORE_R_FAILED_DELETING_KEY 101 | |
620 | # define STORE_R_FAILED_DELETING_NUMBER 102 | |
621 | # define STORE_R_FAILED_GENERATING_CRL 103 | |
622 | # define STORE_R_FAILED_GENERATING_KEY 104 | |
623 | # define STORE_R_FAILED_GETTING_ARBITRARY 133 | |
624 | # define STORE_R_FAILED_GETTING_CERTIFICATE 105 | |
625 | # define STORE_R_FAILED_GETTING_KEY 106 | |
626 | # define STORE_R_FAILED_GETTING_NUMBER 107 | |
627 | # define STORE_R_FAILED_LISTING_CERTIFICATES 108 | |
628 | # define STORE_R_FAILED_LISTING_KEYS 109 | |
629 | # define STORE_R_FAILED_MODIFYING_ARBITRARY 138 | |
630 | # define STORE_R_FAILED_MODIFYING_CERTIFICATE 139 | |
631 | # define STORE_R_FAILED_MODIFYING_CRL 140 | |
632 | # define STORE_R_FAILED_MODIFYING_NUMBER 141 | |
633 | # define STORE_R_FAILED_MODIFYING_PRIVATE_KEY 142 | |
634 | # define STORE_R_FAILED_MODIFYING_PUBLIC_KEY 143 | |
635 | # define STORE_R_FAILED_REVOKING_CERTIFICATE 110 | |
636 | # define STORE_R_FAILED_REVOKING_KEY 111 | |
637 | # define STORE_R_FAILED_STORING_ARBITRARY 134 | |
638 | # define STORE_R_FAILED_STORING_CERTIFICATE 112 | |
639 | # define STORE_R_FAILED_STORING_KEY 113 | |
640 | # define STORE_R_FAILED_STORING_NUMBER 114 | |
641 | # define STORE_R_NOT_IMPLEMENTED 128 | |
642 | # define STORE_R_NO_CONTROL_FUNCTION 144 | |
643 | # define STORE_R_NO_DELETE_ARBITRARY_FUNCTION 135 | |
644 | # define STORE_R_NO_DELETE_NUMBER_FUNCTION 115 | |
645 | # define STORE_R_NO_DELETE_OBJECT_FUNCTION 116 | |
646 | # define STORE_R_NO_GENERATE_CRL_FUNCTION 117 | |
647 | # define STORE_R_NO_GENERATE_OBJECT_FUNCTION 118 | |
648 | # define STORE_R_NO_GET_OBJECT_ARBITRARY_FUNCTION 136 | |
649 | # define STORE_R_NO_GET_OBJECT_FUNCTION 119 | |
650 | # define STORE_R_NO_GET_OBJECT_NUMBER_FUNCTION 120 | |
651 | # define STORE_R_NO_LIST_OBJECT_ENDP_FUNCTION 131 | |
652 | # define STORE_R_NO_LIST_OBJECT_END_FUNCTION 121 | |
653 | # define STORE_R_NO_LIST_OBJECT_NEXT_FUNCTION 122 | |
654 | # define STORE_R_NO_LIST_OBJECT_START_FUNCTION 123 | |
655 | # define STORE_R_NO_MODIFY_OBJECT_FUNCTION 145 | |
656 | # define STORE_R_NO_REVOKE_OBJECT_FUNCTION 124 | |
657 | # define STORE_R_NO_STORE 129 | |
658 | # define STORE_R_NO_STORE_OBJECT_ARBITRARY_FUNCTION 137 | |
659 | # define STORE_R_NO_STORE_OBJECT_FUNCTION 125 | |
660 | # define STORE_R_NO_STORE_OBJECT_NUMBER_FUNCTION 126 | |
661 | # define STORE_R_NO_VALUE 130 | |
a5db6fa5 RL |
662 | |
663 | #ifdef __cplusplus | |
664 | } | |
665 | #endif | |
666 | #endif |