engine.h 39 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833
  1. /* openssl/engine.h */
  2. /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
  3. * project 2000.
  4. */
  5. /* ====================================================================
  6. * Copyright (c) 1999-2004 The OpenSSL Project. All rights reserved.
  7. *
  8. * Redistribution and use in source and binary forms, with or without
  9. * modification, are permitted provided that the following conditions
  10. * are met:
  11. *
  12. * 1. Redistributions of source code must retain the above copyright
  13. * notice, this list of conditions and the following disclaimer.
  14. *
  15. * 2. Redistributions in binary form must reproduce the above copyright
  16. * notice, this list of conditions and the following disclaimer in
  17. * the documentation and/or other materials provided with the
  18. * distribution.
  19. *
  20. * 3. All advertising materials mentioning features or use of this
  21. * software must display the following acknowledgment:
  22. * "This product includes software developed by the OpenSSL Project
  23. * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24. *
  25. * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26. * endorse or promote products derived from this software without
  27. * prior written permission. For written permission, please contact
  28. * licensing@OpenSSL.org.
  29. *
  30. * 5. Products derived from this software may not be called "OpenSSL"
  31. * nor may "OpenSSL" appear in their names without prior written
  32. * permission of the OpenSSL Project.
  33. *
  34. * 6. Redistributions of any form whatsoever must retain the following
  35. * acknowledgment:
  36. * "This product includes software developed by the OpenSSL Project
  37. * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38. *
  39. * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40. * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42. * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43. * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45. * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50. * OF THE POSSIBILITY OF SUCH DAMAGE.
  51. * ====================================================================
  52. *
  53. * This product includes cryptographic software written by Eric Young
  54. * (eay@cryptsoft.com). This product includes software written by Tim
  55. * Hudson (tjh@cryptsoft.com).
  56. *
  57. */
  58. /* ====================================================================
  59. * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  60. * ECDH support in OpenSSL originally developed by
  61. * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  62. */
  63. #ifndef HEADER_ENGINE_H
  64. #define HEADER_ENGINE_H
  65. #include <openssl/opensslconf.h>
  66. #ifdef OPENSSL_NO_ENGINE
  67. #error ENGINE is disabled.
  68. #endif
  69. #ifndef OPENSSL_NO_DEPRECATED
  70. #include <openssl/bn.h>
  71. #ifndef OPENSSL_NO_RSA
  72. #include <openssl/rsa.h>
  73. #endif
  74. #ifndef OPENSSL_NO_DSA
  75. #include <openssl/dsa.h>
  76. #endif
  77. #ifndef OPENSSL_NO_DH
  78. #include <openssl/dh.h>
  79. #endif
  80. #ifndef OPENSSL_NO_ECDH
  81. #include <openssl/ecdh.h>
  82. #endif
  83. #ifndef OPENSSL_NO_ECDSA
  84. #include <openssl/ecdsa.h>
  85. #endif
  86. #include <openssl/rand.h>
  87. #include <openssl/ui.h>
  88. #include <openssl/err.h>
  89. #endif
  90. #include <openssl/ossl_typ.h>
  91. #include <openssl/symhacks.h>
  92. #include <openssl/x509.h>
  93. #ifdef __cplusplus
  94. extern "C" {
  95. #endif
  96. /* These flags are used to control combinations of algorithm (methods)
  97. * by bitwise "OR"ing. */
  98. #define ENGINE_METHOD_RSA (unsigned int)0x0001
  99. #define ENGINE_METHOD_DSA (unsigned int)0x0002
  100. #define ENGINE_METHOD_DH (unsigned int)0x0004
  101. #define ENGINE_METHOD_RAND (unsigned int)0x0008
  102. #define ENGINE_METHOD_ECDH (unsigned int)0x0010
  103. #define ENGINE_METHOD_ECDSA (unsigned int)0x0020
  104. #define ENGINE_METHOD_CIPHERS (unsigned int)0x0040
  105. #define ENGINE_METHOD_DIGESTS (unsigned int)0x0080
  106. #define ENGINE_METHOD_STORE (unsigned int)0x0100
  107. #define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200
  108. #define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400
  109. /* Obvious all-or-nothing cases. */
  110. #define ENGINE_METHOD_ALL (unsigned int)0xFFFF
  111. #define ENGINE_METHOD_NONE (unsigned int)0x0000
  112. /* This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used
  113. * internally to control registration of ENGINE implementations, and can be set
  114. * by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to
  115. * initialise registered ENGINEs if they are not already initialised. */
  116. #define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001
  117. /* ENGINE flags that can be set by ENGINE_set_flags(). */
  118. /* #define ENGINE_FLAGS_MALLOCED 0x0001 */ /* Not used */
  119. /* This flag is for ENGINEs that wish to handle the various 'CMD'-related
  120. * control commands on their own. Without this flag, ENGINE_ctrl() handles these
  121. * control commands on behalf of the ENGINE using their "cmd_defns" data. */
  122. #define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002
  123. /* This flag is for ENGINEs who return new duplicate structures when found via
  124. * "ENGINE_by_id()". When an ENGINE must store state (eg. if ENGINE_ctrl()
  125. * commands are called in sequence as part of some stateful process like
  126. * key-generation setup and execution), it can set this flag - then each attempt
  127. * to obtain the ENGINE will result in it being copied into a new structure.
  128. * Normally, ENGINEs don't declare this flag so ENGINE_by_id() just increments
  129. * the existing ENGINE's structural reference count. */
  130. #define ENGINE_FLAGS_BY_ID_COPY (int)0x0004
  131. /* ENGINEs can support their own command types, and these flags are used in
  132. * ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input each
  133. * command expects. Currently only numeric and string input is supported. If a
  134. * control command supports none of the _NUMERIC, _STRING, or _NO_INPUT options,
  135. * then it is regarded as an "internal" control command - and not for use in
  136. * config setting situations. As such, they're not available to the
  137. * ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl() access. Changes to
  138. * this list of 'command types' should be reflected carefully in
  139. * ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string(). */
  140. /* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */
  141. #define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001
  142. /* accepts string input (cast from 'void*' to 'const char *', 4th parameter to
  143. * ENGINE_ctrl) */
  144. #define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002
  145. /* Indicates that the control command takes *no* input. Ie. the control command
  146. * is unparameterised. */
  147. #define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004
  148. /* Indicates that the control command is internal. This control command won't
  149. * be shown in any output, and is only usable through the ENGINE_ctrl_cmd()
  150. * function. */
  151. #define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008
  152. /* NB: These 3 control commands are deprecated and should not be used. ENGINEs
  153. * relying on these commands should compile conditional support for
  154. * compatibility (eg. if these symbols are defined) but should also migrate the
  155. * same functionality to their own ENGINE-specific control functions that can be
  156. * "discovered" by calling applications. The fact these control commands
  157. * wouldn't be "executable" (ie. usable by text-based config) doesn't change the
  158. * fact that application code can find and use them without requiring per-ENGINE
  159. * hacking. */
  160. /* These flags are used to tell the ctrl function what should be done.
  161. * All command numbers are shared between all engines, even if some don't
  162. * make sense to some engines. In such a case, they do nothing but return
  163. * the error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED. */
  164. #define ENGINE_CTRL_SET_LOGSTREAM 1
  165. #define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2
  166. #define ENGINE_CTRL_HUP 3 /* Close and reinitialise any
  167. handles/connections etc. */
  168. #define ENGINE_CTRL_SET_USER_INTERFACE 4 /* Alternative to callback */
  169. #define ENGINE_CTRL_SET_CALLBACK_DATA 5 /* User-specific data, used
  170. when calling the password
  171. callback and the user
  172. interface */
  173. #define ENGINE_CTRL_LOAD_CONFIGURATION 6 /* Load a configuration, given
  174. a string that represents a
  175. file name or so */
  176. #define ENGINE_CTRL_LOAD_SECTION 7 /* Load data from a given
  177. section in the already loaded
  178. configuration */
  179. /* These control commands allow an application to deal with an arbitrary engine
  180. * in a dynamic way. Warn: Negative return values indicate errors FOR THESE
  181. * COMMANDS because zero is used to indicate 'end-of-list'. Other commands,
  182. * including ENGINE-specific command types, return zero for an error.
  183. *
  184. * An ENGINE can choose to implement these ctrl functions, and can internally
  185. * manage things however it chooses - it does so by setting the
  186. * ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise the
  187. * ENGINE_ctrl() code handles this on the ENGINE's behalf using the cmd_defns
  188. * data (set using ENGINE_set_cmd_defns()). This means an ENGINE's ctrl()
  189. * handler need only implement its own commands - the above "meta" commands will
  190. * be taken care of. */
  191. /* Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not", then
  192. * all the remaining control commands will return failure, so it is worth
  193. * checking this first if the caller is trying to "discover" the engine's
  194. * capabilities and doesn't want errors generated unnecessarily. */
  195. #define ENGINE_CTRL_HAS_CTRL_FUNCTION 10
  196. /* Returns a positive command number for the first command supported by the
  197. * engine. Returns zero if no ctrl commands are supported. */
  198. #define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11
  199. /* The 'long' argument specifies a command implemented by the engine, and the
  200. * return value is the next command supported, or zero if there are no more. */
  201. #define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12
  202. /* The 'void*' argument is a command name (cast from 'const char *'), and the
  203. * return value is the command that corresponds to it. */
  204. #define ENGINE_CTRL_GET_CMD_FROM_NAME 13
  205. /* The next two allow a command to be converted into its corresponding string
  206. * form. In each case, the 'long' argument supplies the command. In the NAME_LEN
  207. * case, the return value is the length of the command name (not counting a
  208. * trailing EOL). In the NAME case, the 'void*' argument must be a string buffer
  209. * large enough, and it will be populated with the name of the command (WITH a
  210. * trailing EOL). */
  211. #define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14
  212. #define ENGINE_CTRL_GET_NAME_FROM_CMD 15
  213. /* The next two are similar but give a "short description" of a command. */
  214. #define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16
  215. #define ENGINE_CTRL_GET_DESC_FROM_CMD 17
  216. /* With this command, the return value is the OR'd combination of
  217. * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given
  218. * engine-specific ctrl command expects. */
  219. #define ENGINE_CTRL_GET_CMD_FLAGS 18
  220. /* ENGINE implementations should start the numbering of their own control
  221. * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc). */
  222. #define ENGINE_CMD_BASE 200
  223. /* NB: These 2 nCipher "chil" control commands are deprecated, and their
  224. * functionality is now available through ENGINE-specific control commands
  225. * (exposed through the above-mentioned 'CMD'-handling). Code using these 2
  226. * commands should be migrated to the more general command handling before these
  227. * are removed. */
  228. /* Flags specific to the nCipher "chil" engine */
  229. #define ENGINE_CTRL_CHIL_SET_FORKCHECK 100
  230. /* Depending on the value of the (long)i argument, this sets or
  231. * unsets the SimpleForkCheck flag in the CHIL API to enable or
  232. * disable checking and workarounds for applications that fork().
  233. */
  234. #define ENGINE_CTRL_CHIL_NO_LOCKING 101
  235. /* This prevents the initialisation function from providing mutex
  236. * callbacks to the nCipher library. */
  237. /* If an ENGINE supports its own specific control commands and wishes the
  238. * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on its
  239. * behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN entries
  240. * to ENGINE_set_cmd_defns(). It should also implement a ctrl() handler that
  241. * supports the stated commands (ie. the "cmd_num" entries as described by the
  242. * array). NB: The array must be ordered in increasing order of cmd_num.
  243. * "null-terminated" means that the last ENGINE_CMD_DEFN element has cmd_num set
  244. * to zero and/or cmd_name set to NULL. */
  245. typedef struct ENGINE_CMD_DEFN_st
  246. {
  247. unsigned int cmd_num; /* The command number */
  248. const char *cmd_name; /* The command name itself */
  249. const char *cmd_desc; /* A short description of the command */
  250. unsigned int cmd_flags; /* The input the command expects */
  251. } ENGINE_CMD_DEFN;
  252. /* Generic function pointer */
  253. typedef int (*ENGINE_GEN_FUNC_PTR)(void);
  254. /* Generic function pointer taking no arguments */
  255. typedef int (*ENGINE_GEN_INT_FUNC_PTR)(ENGINE *);
  256. /* Specific control function pointer */
  257. typedef int (*ENGINE_CTRL_FUNC_PTR)(ENGINE *, int, long, void *, void (*f)(void));
  258. /* Generic load_key function pointer */
  259. typedef EVP_PKEY * (*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *,
  260. UI_METHOD *ui_method, void *callback_data);
  261. typedef int (*ENGINE_SSL_CLIENT_CERT_PTR)(ENGINE *, SSL *ssl,
  262. STACK_OF(X509_NAME) *ca_dn, X509 **pcert, EVP_PKEY **pkey,
  263. STACK_OF(X509) **pother, UI_METHOD *ui_method, void *callback_data);
  264. /* These callback types are for an ENGINE's handler for cipher and digest logic.
  265. * These handlers have these prototypes;
  266. * int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
  267. * int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid);
  268. * Looking at how to implement these handlers in the case of cipher support, if
  269. * the framework wants the EVP_CIPHER for 'nid', it will call;
  270. * foo(e, &p_evp_cipher, NULL, nid); (return zero for failure)
  271. * If the framework wants a list of supported 'nid's, it will call;
  272. * foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error)
  273. */
  274. /* Returns to a pointer to the array of supported cipher 'nid's. If the second
  275. * parameter is non-NULL it is set to the size of the returned array. */
  276. typedef int (*ENGINE_CIPHERS_PTR)(ENGINE *, const EVP_CIPHER **, const int **, int);
  277. typedef int (*ENGINE_DIGESTS_PTR)(ENGINE *, const EVP_MD **, const int **, int);
  278. typedef int (*ENGINE_PKEY_METHS_PTR)(ENGINE *, EVP_PKEY_METHOD **, const int **, int);
  279. typedef int (*ENGINE_PKEY_ASN1_METHS_PTR)(ENGINE *, EVP_PKEY_ASN1_METHOD **, const int **, int);
  280. /* STRUCTURE functions ... all of these functions deal with pointers to ENGINE
  281. * structures where the pointers have a "structural reference". This means that
  282. * their reference is to allowed access to the structure but it does not imply
  283. * that the structure is functional. To simply increment or decrement the
  284. * structural reference count, use ENGINE_by_id and ENGINE_free. NB: This is not
  285. * required when iterating using ENGINE_get_next as it will automatically
  286. * decrement the structural reference count of the "current" ENGINE and
  287. * increment the structural reference count of the ENGINE it returns (unless it
  288. * is NULL). */
  289. /* Get the first/last "ENGINE" type available. */
  290. ENGINE *ENGINE_get_first(void);
  291. ENGINE *ENGINE_get_last(void);
  292. /* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
  293. ENGINE *ENGINE_get_next(ENGINE *e);
  294. ENGINE *ENGINE_get_prev(ENGINE *e);
  295. /* Add another "ENGINE" type into the array. */
  296. int ENGINE_add(ENGINE *e);
  297. /* Remove an existing "ENGINE" type from the array. */
  298. int ENGINE_remove(ENGINE *e);
  299. /* Retrieve an engine from the list by its unique "id" value. */
  300. ENGINE *ENGINE_by_id(const char *id);
  301. /* Add all the built-in engines. */
  302. void ENGINE_load_openssl(void);
  303. void ENGINE_load_dynamic(void);
  304. #ifndef OPENSSL_NO_STATIC_ENGINE
  305. void ENGINE_load_4758cca(void);
  306. void ENGINE_load_aep(void);
  307. void ENGINE_load_atalla(void);
  308. void ENGINE_load_chil(void);
  309. void ENGINE_load_cswift(void);
  310. void ENGINE_load_nuron(void);
  311. void ENGINE_load_sureware(void);
  312. void ENGINE_load_ubsec(void);
  313. void ENGINE_load_padlock(void);
  314. #ifdef OPENSSL_SYS_WIN32
  315. #ifndef OPENSSL_NO_CAPIENG
  316. void ENGINE_load_capi(void);
  317. #endif
  318. #endif
  319. #ifndef OPENSSL_NO_GMP
  320. void ENGINE_load_gmp(void);
  321. #endif
  322. #ifndef OPENSSL_NO_GOST
  323. void ENGINE_load_gost(void);
  324. #endif
  325. #endif
  326. void ENGINE_load_cryptodev(void);
  327. void ENGINE_load_builtin_engines(void);
  328. /* Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation
  329. * "registry" handling. */
  330. unsigned int ENGINE_get_table_flags(void);
  331. void ENGINE_set_table_flags(unsigned int flags);
  332. /* Manage registration of ENGINEs per "table". For each type, there are 3
  333. * functions;
  334. * ENGINE_register_***(e) - registers the implementation from 'e' (if it has one)
  335. * ENGINE_unregister_***(e) - unregister the implementation from 'e'
  336. * ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list
  337. * Cleanup is automatically registered from each table when required, so
  338. * ENGINE_cleanup() will reverse any "register" operations. */
  339. int ENGINE_register_RSA(ENGINE *e);
  340. void ENGINE_unregister_RSA(ENGINE *e);
  341. void ENGINE_register_all_RSA(void);
  342. int ENGINE_register_DSA(ENGINE *e);
  343. void ENGINE_unregister_DSA(ENGINE *e);
  344. void ENGINE_register_all_DSA(void);
  345. int ENGINE_register_ECDH(ENGINE *e);
  346. void ENGINE_unregister_ECDH(ENGINE *e);
  347. void ENGINE_register_all_ECDH(void);
  348. int ENGINE_register_ECDSA(ENGINE *e);
  349. void ENGINE_unregister_ECDSA(ENGINE *e);
  350. void ENGINE_register_all_ECDSA(void);
  351. int ENGINE_register_DH(ENGINE *e);
  352. void ENGINE_unregister_DH(ENGINE *e);
  353. void ENGINE_register_all_DH(void);
  354. int ENGINE_register_RAND(ENGINE *e);
  355. void ENGINE_unregister_RAND(ENGINE *e);
  356. void ENGINE_register_all_RAND(void);
  357. int ENGINE_register_STORE(ENGINE *e);
  358. void ENGINE_unregister_STORE(ENGINE *e);
  359. void ENGINE_register_all_STORE(void);
  360. int ENGINE_register_ciphers(ENGINE *e);
  361. void ENGINE_unregister_ciphers(ENGINE *e);
  362. void ENGINE_register_all_ciphers(void);
  363. int ENGINE_register_digests(ENGINE *e);
  364. void ENGINE_unregister_digests(ENGINE *e);
  365. void ENGINE_register_all_digests(void);
  366. int ENGINE_register_pkey_meths(ENGINE *e);
  367. void ENGINE_unregister_pkey_meths(ENGINE *e);
  368. void ENGINE_register_all_pkey_meths(void);
  369. int ENGINE_register_pkey_asn1_meths(ENGINE *e);
  370. void ENGINE_unregister_pkey_asn1_meths(ENGINE *e);
  371. void ENGINE_register_all_pkey_asn1_meths(void);
  372. /* These functions register all support from the above categories. Note, use of
  373. * these functions can result in static linkage of code your application may not
  374. * need. If you only need a subset of functionality, consider using more
  375. * selective initialisation. */
  376. int ENGINE_register_complete(ENGINE *e);
  377. int ENGINE_register_all_complete(void);
  378. /* Send parametrised control commands to the engine. The possibilities to send
  379. * down an integer, a pointer to data or a function pointer are provided. Any of
  380. * the parameters may or may not be NULL, depending on the command number. In
  381. * actuality, this function only requires a structural (rather than functional)
  382. * reference to an engine, but many control commands may require the engine be
  383. * functional. The caller should be aware of trying commands that require an
  384. * operational ENGINE, and only use functional references in such situations. */
  385. int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void));
  386. /* This function tests if an ENGINE-specific command is usable as a "setting".
  387. * Eg. in an application's config file that gets processed through
  388. * ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to
  389. * ENGINE_ctrl_cmd_string(), only ENGINE_ctrl(). */
  390. int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
  391. /* This function works like ENGINE_ctrl() with the exception of taking a
  392. * command name instead of a command number, and can handle optional commands.
  393. * See the comment on ENGINE_ctrl_cmd_string() for an explanation on how to
  394. * use the cmd_name and cmd_optional. */
  395. int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
  396. long i, void *p, void (*f)(void), int cmd_optional);
  397. /* This function passes a command-name and argument to an ENGINE. The cmd_name
  398. * is converted to a command number and the control command is called using
  399. * 'arg' as an argument (unless the ENGINE doesn't support such a command, in
  400. * which case no control command is called). The command is checked for input
  401. * flags, and if necessary the argument will be converted to a numeric value. If
  402. * cmd_optional is non-zero, then if the ENGINE doesn't support the given
  403. * cmd_name the return value will be success anyway. This function is intended
  404. * for applications to use so that users (or config files) can supply
  405. * engine-specific config data to the ENGINE at run-time to control behaviour of
  406. * specific engines. As such, it shouldn't be used for calling ENGINE_ctrl()
  407. * functions that return data, deal with binary data, or that are otherwise
  408. * supposed to be used directly through ENGINE_ctrl() in application code. Any
  409. * "return" data from an ENGINE_ctrl() operation in this function will be lost -
  410. * the return value is interpreted as failure if the return value is zero,
  411. * success otherwise, and this function returns a boolean value as a result. In
  412. * other words, vendors of 'ENGINE'-enabled devices should write ENGINE
  413. * implementations with parameterisations that work in this scheme, so that
  414. * compliant ENGINE-based applications can work consistently with the same
  415. * configuration for the same ENGINE-enabled devices, across applications. */
  416. int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
  417. int cmd_optional);
  418. /* These functions are useful for manufacturing new ENGINE structures. They
  419. * don't address reference counting at all - one uses them to populate an ENGINE
  420. * structure with personalised implementations of things prior to using it
  421. * directly or adding it to the builtin ENGINE list in OpenSSL. These are also
  422. * here so that the ENGINE structure doesn't have to be exposed and break binary
  423. * compatibility! */
  424. ENGINE *ENGINE_new(void);
  425. int ENGINE_free(ENGINE *e);
  426. int ENGINE_up_ref(ENGINE *e);
  427. int ENGINE_set_id(ENGINE *e, const char *id);
  428. int ENGINE_set_name(ENGINE *e, const char *name);
  429. int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
  430. int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
  431. int ENGINE_set_ECDH(ENGINE *e, const ECDH_METHOD *ecdh_meth);
  432. int ENGINE_set_ECDSA(ENGINE *e, const ECDSA_METHOD *ecdsa_meth);
  433. int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
  434. int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
  435. int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *store_meth);
  436. int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
  437. int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
  438. int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
  439. int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
  440. int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f);
  441. int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
  442. int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
  443. ENGINE_SSL_CLIENT_CERT_PTR loadssl_f);
  444. int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
  445. int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
  446. int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
  447. int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f);
  448. int ENGINE_set_flags(ENGINE *e, int flags);
  449. int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns);
  450. /* These functions allow control over any per-structure ENGINE data. */
  451. int ENGINE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
  452. CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
  453. int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
  454. void *ENGINE_get_ex_data(const ENGINE *e, int idx);
  455. /* This function cleans up anything that needs it. Eg. the ENGINE_add() function
  456. * automatically ensures the list cleanup function is registered to be called
  457. * from ENGINE_cleanup(). Similarly, all ENGINE_register_*** functions ensure
  458. * ENGINE_cleanup() will clean up after them. */
  459. void ENGINE_cleanup(void);
  460. /* These return values from within the ENGINE structure. These can be useful
  461. * with functional references as well as structural references - it depends
  462. * which you obtained. Using the result for functional purposes if you only
  463. * obtained a structural reference may be problematic! */
  464. const char *ENGINE_get_id(const ENGINE *e);
  465. const char *ENGINE_get_name(const ENGINE *e);
  466. const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
  467. const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
  468. const ECDH_METHOD *ENGINE_get_ECDH(const ENGINE *e);
  469. const ECDSA_METHOD *ENGINE_get_ECDSA(const ENGINE *e);
  470. const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
  471. const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
  472. const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e);
  473. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
  474. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
  475. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
  476. ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
  477. ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
  478. ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
  479. ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e);
  480. ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
  481. ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
  482. ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e);
  483. ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e);
  484. const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
  485. const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
  486. const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid);
  487. const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid);
  488. const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e,
  489. const char *str, int len);
  490. const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
  491. const char *str, int len);
  492. const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
  493. int ENGINE_get_flags(const ENGINE *e);
  494. /* FUNCTIONAL functions. These functions deal with ENGINE structures
  495. * that have (or will) be initialised for use. Broadly speaking, the
  496. * structural functions are useful for iterating the list of available
  497. * engine types, creating new engine types, and other "list" operations.
  498. * These functions actually deal with ENGINEs that are to be used. As
  499. * such these functions can fail (if applicable) when particular
  500. * engines are unavailable - eg. if a hardware accelerator is not
  501. * attached or not functioning correctly. Each ENGINE has 2 reference
  502. * counts; structural and functional. Every time a functional reference
  503. * is obtained or released, a corresponding structural reference is
  504. * automatically obtained or released too. */
  505. /* Initialise a engine type for use (or up its reference count if it's
  506. * already in use). This will fail if the engine is not currently
  507. * operational and cannot initialise. */
  508. int ENGINE_init(ENGINE *e);
  509. /* Free a functional reference to a engine type. This does not require
  510. * a corresponding call to ENGINE_free as it also releases a structural
  511. * reference. */
  512. int ENGINE_finish(ENGINE *e);
  513. /* The following functions handle keys that are stored in some secondary
  514. * location, handled by the engine. The storage may be on a card or
  515. * whatever. */
  516. EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
  517. UI_METHOD *ui_method, void *callback_data);
  518. EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
  519. UI_METHOD *ui_method, void *callback_data);
  520. int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s,
  521. STACK_OF(X509_NAME) *ca_dn, X509 **pcert, EVP_PKEY **ppkey,
  522. STACK_OF(X509) **pother,
  523. UI_METHOD *ui_method, void *callback_data);
  524. /* This returns a pointer for the current ENGINE structure that
  525. * is (by default) performing any RSA operations. The value returned
  526. * is an incremented reference, so it should be free'd (ENGINE_finish)
  527. * before it is discarded. */
  528. ENGINE *ENGINE_get_default_RSA(void);
  529. /* Same for the other "methods" */
  530. ENGINE *ENGINE_get_default_DSA(void);
  531. ENGINE *ENGINE_get_default_ECDH(void);
  532. ENGINE *ENGINE_get_default_ECDSA(void);
  533. ENGINE *ENGINE_get_default_DH(void);
  534. ENGINE *ENGINE_get_default_RAND(void);
  535. /* These functions can be used to get a functional reference to perform
  536. * ciphering or digesting corresponding to "nid". */
  537. ENGINE *ENGINE_get_cipher_engine(int nid);
  538. ENGINE *ENGINE_get_digest_engine(int nid);
  539. ENGINE *ENGINE_get_pkey_meth_engine(int nid);
  540. ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid);
  541. /* This sets a new default ENGINE structure for performing RSA
  542. * operations. If the result is non-zero (success) then the ENGINE
  543. * structure will have had its reference count up'd so the caller
  544. * should still free their own reference 'e'. */
  545. int ENGINE_set_default_RSA(ENGINE *e);
  546. int ENGINE_set_default_string(ENGINE *e, const char *def_list);
  547. /* Same for the other "methods" */
  548. int ENGINE_set_default_DSA(ENGINE *e);
  549. int ENGINE_set_default_ECDH(ENGINE *e);
  550. int ENGINE_set_default_ECDSA(ENGINE *e);
  551. int ENGINE_set_default_DH(ENGINE *e);
  552. int ENGINE_set_default_RAND(ENGINE *e);
  553. int ENGINE_set_default_ciphers(ENGINE *e);
  554. int ENGINE_set_default_digests(ENGINE *e);
  555. int ENGINE_set_default_pkey_meths(ENGINE *e);
  556. int ENGINE_set_default_pkey_asn1_meths(ENGINE *e);
  557. /* The combination "set" - the flags are bitwise "OR"d from the
  558. * ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()"
  559. * function, this function can result in unnecessary static linkage. If your
  560. * application requires only specific functionality, consider using more
  561. * selective functions. */
  562. int ENGINE_set_default(ENGINE *e, unsigned int flags);
  563. void ENGINE_add_conf_module(void);
  564. /* Deprecated functions ... */
  565. /* int ENGINE_clear_defaults(void); */
  566. /**************************/
  567. /* DYNAMIC ENGINE SUPPORT */
  568. /**************************/
  569. /* Binary/behaviour compatibility levels */
  570. #define OSSL_DYNAMIC_VERSION (unsigned long)0x00020000
  571. /* Binary versions older than this are too old for us (whether we're a loader or
  572. * a loadee) */
  573. #define OSSL_DYNAMIC_OLDEST (unsigned long)0x00020000
  574. /* When compiling an ENGINE entirely as an external shared library, loadable by
  575. * the "dynamic" ENGINE, these types are needed. The 'dynamic_fns' structure
  576. * type provides the calling application's (or library's) error functionality
  577. * and memory management function pointers to the loaded library. These should
  578. * be used/set in the loaded library code so that the loading application's
  579. * 'state' will be used/changed in all operations. The 'static_state' pointer
  580. * allows the loaded library to know if it shares the same static data as the
  581. * calling application (or library), and thus whether these callbacks need to be
  582. * set or not. */
  583. typedef void *(*dyn_MEM_malloc_cb)(size_t);
  584. typedef void *(*dyn_MEM_realloc_cb)(void *, size_t);
  585. typedef void (*dyn_MEM_free_cb)(void *);
  586. typedef struct st_dynamic_MEM_fns {
  587. dyn_MEM_malloc_cb malloc_cb;
  588. dyn_MEM_realloc_cb realloc_cb;
  589. dyn_MEM_free_cb free_cb;
  590. } dynamic_MEM_fns;
  591. /* FIXME: Perhaps the memory and locking code (crypto.h) should declare and use
  592. * these types so we (and any other dependant code) can simplify a bit?? */
  593. typedef void (*dyn_lock_locking_cb)(int,int,const char *,int);
  594. typedef int (*dyn_lock_add_lock_cb)(int*,int,int,const char *,int);
  595. typedef struct CRYPTO_dynlock_value *(*dyn_dynlock_create_cb)(
  596. const char *,int);
  597. typedef void (*dyn_dynlock_lock_cb)(int,struct CRYPTO_dynlock_value *,
  598. const char *,int);
  599. typedef void (*dyn_dynlock_destroy_cb)(struct CRYPTO_dynlock_value *,
  600. const char *,int);
  601. typedef struct st_dynamic_LOCK_fns {
  602. dyn_lock_locking_cb lock_locking_cb;
  603. dyn_lock_add_lock_cb lock_add_lock_cb;
  604. dyn_dynlock_create_cb dynlock_create_cb;
  605. dyn_dynlock_lock_cb dynlock_lock_cb;
  606. dyn_dynlock_destroy_cb dynlock_destroy_cb;
  607. } dynamic_LOCK_fns;
  608. /* The top-level structure */
  609. typedef struct st_dynamic_fns {
  610. void *static_state;
  611. const ERR_FNS *err_fns;
  612. const CRYPTO_EX_DATA_IMPL *ex_data_fns;
  613. dynamic_MEM_fns mem_fns;
  614. dynamic_LOCK_fns lock_fns;
  615. } dynamic_fns;
  616. /* The version checking function should be of this prototype. NB: The
  617. * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading code.
  618. * If this function returns zero, it indicates a (potential) version
  619. * incompatibility and the loaded library doesn't believe it can proceed.
  620. * Otherwise, the returned value is the (latest) version supported by the
  621. * loading library. The loader may still decide that the loaded code's version
  622. * is unsatisfactory and could veto the load. The function is expected to
  623. * be implemented with the symbol name "v_check", and a default implementation
  624. * can be fully instantiated with IMPLEMENT_DYNAMIC_CHECK_FN(). */
  625. typedef unsigned long (*dynamic_v_check_fn)(unsigned long ossl_version);
  626. #define IMPLEMENT_DYNAMIC_CHECK_FN() \
  627. OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \
  628. if(v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \
  629. return 0; }
  630. /* This function is passed the ENGINE structure to initialise with its own
  631. * function and command settings. It should not adjust the structural or
  632. * functional reference counts. If this function returns zero, (a) the load will
  633. * be aborted, (b) the previous ENGINE state will be memcpy'd back onto the
  634. * structure, and (c) the shared library will be unloaded. So implementations
  635. * should do their own internal cleanup in failure circumstances otherwise they
  636. * could leak. The 'id' parameter, if non-NULL, represents the ENGINE id that
  637. * the loader is looking for. If this is NULL, the shared library can choose to
  638. * return failure or to initialise a 'default' ENGINE. If non-NULL, the shared
  639. * library must initialise only an ENGINE matching the passed 'id'. The function
  640. * is expected to be implemented with the symbol name "bind_engine". A standard
  641. * implementation can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where
  642. * the parameter 'fn' is a callback function that populates the ENGINE structure
  643. * and returns an int value (zero for failure). 'fn' should have prototype;
  644. * [static] int fn(ENGINE *e, const char *id); */
  645. typedef int (*dynamic_bind_engine)(ENGINE *e, const char *id,
  646. const dynamic_fns *fns);
  647. #define IMPLEMENT_DYNAMIC_BIND_FN(fn) \
  648. OPENSSL_EXPORT \
  649. int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \
  650. if(ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \
  651. if(!CRYPTO_set_mem_functions(fns->mem_fns.malloc_cb, \
  652. fns->mem_fns.realloc_cb, fns->mem_fns.free_cb)) \
  653. return 0; \
  654. CRYPTO_set_locking_callback(fns->lock_fns.lock_locking_cb); \
  655. CRYPTO_set_add_lock_callback(fns->lock_fns.lock_add_lock_cb); \
  656. CRYPTO_set_dynlock_create_callback(fns->lock_fns.dynlock_create_cb); \
  657. CRYPTO_set_dynlock_lock_callback(fns->lock_fns.dynlock_lock_cb); \
  658. CRYPTO_set_dynlock_destroy_callback(fns->lock_fns.dynlock_destroy_cb); \
  659. if(!CRYPTO_set_ex_data_implementation(fns->ex_data_fns)) \
  660. return 0; \
  661. if(!ERR_set_implementation(fns->err_fns)) return 0; \
  662. skip_cbs: \
  663. if(!fn(e,id)) return 0; \
  664. return 1; }
  665. /* If the loading application (or library) and the loaded ENGINE library share
  666. * the same static data (eg. they're both dynamically linked to the same
  667. * libcrypto.so) we need a way to avoid trying to set system callbacks - this
  668. * would fail, and for the same reason that it's unnecessary to try. If the
  669. * loaded ENGINE has (or gets from through the loader) its own copy of the
  670. * libcrypto static data, we will need to set the callbacks. The easiest way to
  671. * detect this is to have a function that returns a pointer to some static data
  672. * and let the loading application and loaded ENGINE compare their respective
  673. * values. */
  674. void *ENGINE_get_static_state(void);
  675. #if defined(__OpenBSD__) || defined(__FreeBSD__)
  676. void ENGINE_setup_bsd_cryptodev(void);
  677. #endif
  678. /* BEGIN ERROR CODES */
  679. /* The following lines are auto generated by the script mkerr.pl. Any changes
  680. * made after this point may be overwritten when the script is next run.
  681. */
  682. void ERR_load_ENGINE_strings(void);
  683. /* Error codes for the ENGINE functions. */
  684. /* Function codes. */
  685. #define ENGINE_F_DYNAMIC_CTRL 180
  686. #define ENGINE_F_DYNAMIC_GET_DATA_CTX 181
  687. #define ENGINE_F_DYNAMIC_LOAD 182
  688. #define ENGINE_F_DYNAMIC_SET_DATA_CTX 183
  689. #define ENGINE_F_ENGINE_ADD 105
  690. #define ENGINE_F_ENGINE_BY_ID 106
  691. #define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE 170
  692. #define ENGINE_F_ENGINE_CTRL 142
  693. #define ENGINE_F_ENGINE_CTRL_CMD 178
  694. #define ENGINE_F_ENGINE_CTRL_CMD_STRING 171
  695. #define ENGINE_F_ENGINE_FINISH 107
  696. #define ENGINE_F_ENGINE_FREE_UTIL 108
  697. #define ENGINE_F_ENGINE_GET_CIPHER 185
  698. #define ENGINE_F_ENGINE_GET_DEFAULT_TYPE 177
  699. #define ENGINE_F_ENGINE_GET_DIGEST 186
  700. #define ENGINE_F_ENGINE_GET_NEXT 115
  701. #define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH 193
  702. #define ENGINE_F_ENGINE_GET_PKEY_METH 192
  703. #define ENGINE_F_ENGINE_GET_PREV 116
  704. #define ENGINE_F_ENGINE_INIT 119
  705. #define ENGINE_F_ENGINE_LIST_ADD 120
  706. #define ENGINE_F_ENGINE_LIST_REMOVE 121
  707. #define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY 150
  708. #define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY 151
  709. #define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT 194
  710. #define ENGINE_F_ENGINE_NEW 122
  711. #define ENGINE_F_ENGINE_REMOVE 123
  712. #define ENGINE_F_ENGINE_SET_DEFAULT_STRING 189
  713. #define ENGINE_F_ENGINE_SET_DEFAULT_TYPE 126
  714. #define ENGINE_F_ENGINE_SET_ID 129
  715. #define ENGINE_F_ENGINE_SET_NAME 130
  716. #define ENGINE_F_ENGINE_TABLE_REGISTER 184
  717. #define ENGINE_F_ENGINE_UNLOAD_KEY 152
  718. #define ENGINE_F_ENGINE_UNLOCKED_FINISH 191
  719. #define ENGINE_F_ENGINE_UP_REF 190
  720. #define ENGINE_F_INT_CTRL_HELPER 172
  721. #define ENGINE_F_INT_ENGINE_CONFIGURE 188
  722. #define ENGINE_F_INT_ENGINE_MODULE_INIT 187
  723. #define ENGINE_F_LOG_MESSAGE 141
  724. /* Reason codes. */
  725. #define ENGINE_R_ALREADY_LOADED 100
  726. #define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER 133
  727. #define ENGINE_R_CMD_NOT_EXECUTABLE 134
  728. #define ENGINE_R_COMMAND_TAKES_INPUT 135
  729. #define ENGINE_R_COMMAND_TAKES_NO_INPUT 136
  730. #define ENGINE_R_CONFLICTING_ENGINE_ID 103
  731. #define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED 119
  732. #define ENGINE_R_DH_NOT_IMPLEMENTED 139
  733. #define ENGINE_R_DSA_NOT_IMPLEMENTED 140
  734. #define ENGINE_R_DSO_FAILURE 104
  735. #define ENGINE_R_DSO_NOT_FOUND 132
  736. #define ENGINE_R_ENGINES_SECTION_ERROR 148
  737. #define ENGINE_R_ENGINE_IS_NOT_IN_LIST 105
  738. #define ENGINE_R_ENGINE_SECTION_ERROR 149
  739. #define ENGINE_R_FAILED_LOADING_PRIVATE_KEY 128
  740. #define ENGINE_R_FAILED_LOADING_PUBLIC_KEY 129
  741. #define ENGINE_R_FINISH_FAILED 106
  742. #define ENGINE_R_GET_HANDLE_FAILED 107
  743. #define ENGINE_R_ID_OR_NAME_MISSING 108
  744. #define ENGINE_R_INIT_FAILED 109
  745. #define ENGINE_R_INTERNAL_LIST_ERROR 110
  746. #define ENGINE_R_INVALID_ARGUMENT 143
  747. #define ENGINE_R_INVALID_CMD_NAME 137
  748. #define ENGINE_R_INVALID_CMD_NUMBER 138
  749. #define ENGINE_R_INVALID_INIT_VALUE 151
  750. #define ENGINE_R_INVALID_STRING 150
  751. #define ENGINE_R_NOT_INITIALISED 117
  752. #define ENGINE_R_NOT_LOADED 112
  753. #define ENGINE_R_NO_CONTROL_FUNCTION 120
  754. #define ENGINE_R_NO_INDEX 144
  755. #define ENGINE_R_NO_LOAD_FUNCTION 125
  756. #define ENGINE_R_NO_REFERENCE 130
  757. #define ENGINE_R_NO_SUCH_ENGINE 116
  758. #define ENGINE_R_NO_UNLOAD_FUNCTION 126
  759. #define ENGINE_R_PROVIDE_PARAMETERS 113
  760. #define ENGINE_R_RSA_NOT_IMPLEMENTED 141
  761. #define ENGINE_R_UNIMPLEMENTED_CIPHER 146
  762. #define ENGINE_R_UNIMPLEMENTED_DIGEST 147
  763. #define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD 101
  764. #define ENGINE_R_VERSION_INCOMPATIBILITY 145
  765. #ifdef __cplusplus
  766. }
  767. #endif
  768. #endif