Lines Matching refs:ENGINE
71 # error ENGINE is disabled.
126 * internally to control registration of ENGINE implementations, and can be
132 /* ENGINE flags that can be set by ENGINE_set_flags(). */
139 * these control commands on behalf of the ENGINE using their "cmd_defns"
146 * via "ENGINE_by_id()". When an ENGINE must store state (eg. if
149 * then each attempt to obtain the ENGINE will result in it being copied into
151 * ENGINE_by_id() just increments the existing ENGINE's structural reference
157 * This flag if for an ENGINE that does not want its methods registered as
199 * the same functionality to their own ENGINE-specific control functions that
203 * without requiring per-ENGINE hacking.
234 * commands, including ENGINE-specific command types, return zero for an
235 * error. An ENGINE can choose to implement these ctrl functions, and can
238 * the ENGINE_ctrl() code handles this on the ENGINE's behalf using the
239 * cmd_defns data (set using ENGINE_set_cmd_defns()). This means an ENGINE's
245 * Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not",
287 * ENGINE implementations should start the numbering of their own control
294 * functionality is now available through ENGINE-specific control commands
314 * If an ENGINE supports its own specific control commands and wishes the
333 typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *);
335 typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *,
338 typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *,
341 typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl,
348 * These callback types are for an ENGINE's handler for cipher and digest logic.
350 * int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
351 * int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid);
362 typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **,
364 typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **,
366 typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **,
368 typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **,
372 * ENGINE structures where the pointers have a "structural reference". This
378 * "current" ENGINE and increment the structural reference count of the
379 * ENGINE it returns (unless it is NULL).
382 /* Get the first/last "ENGINE" type available. */
383 ENGINE *ENGINE_get_first(void);
384 ENGINE *ENGINE_get_last(void);
385 /* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
386 ENGINE *ENGINE_get_next(ENGINE *e);
387 ENGINE *ENGINE_get_prev(ENGINE *e);
388 /* Add another "ENGINE" type into the array. */
389 int ENGINE_add(ENGINE *e);
390 /* Remove an existing "ENGINE" type from the array. */
391 int ENGINE_remove(ENGINE *e);
393 ENGINE *ENGINE_by_id(const char *id);
435 int ENGINE_register_RSA(ENGINE *e);
436 void ENGINE_unregister_RSA(ENGINE *e);
439 int ENGINE_register_DSA(ENGINE *e);
440 void ENGINE_unregister_DSA(ENGINE *e);
443 int ENGINE_register_ECDH(ENGINE *e);
444 void ENGINE_unregister_ECDH(ENGINE *e);
447 int ENGINE_register_ECDSA(ENGINE *e);
448 void ENGINE_unregister_ECDSA(ENGINE *e);
451 int ENGINE_register_DH(ENGINE *e);
452 void ENGINE_unregister_DH(ENGINE *e);
455 int ENGINE_register_RAND(ENGINE *e);
456 void ENGINE_unregister_RAND(ENGINE *e);
459 int ENGINE_register_STORE(ENGINE *e);
460 void ENGINE_unregister_STORE(ENGINE *e);
463 int ENGINE_register_ciphers(ENGINE *e);
464 void ENGINE_unregister_ciphers(ENGINE *e);
467 int ENGINE_register_digests(ENGINE *e);
468 void ENGINE_unregister_digests(ENGINE *e);
471 int ENGINE_register_pkey_meths(ENGINE *e);
472 void ENGINE_unregister_pkey_meths(ENGINE *e);
475 int ENGINE_register_pkey_asn1_meths(ENGINE *e);
476 void ENGINE_unregister_pkey_asn1_meths(ENGINE *e);
485 int ENGINE_register_complete(ENGINE *e);
495 * commands that require an operational ENGINE, and only use functional
498 int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void));
501 * This function tests if an ENGINE-specific command is usable as a
506 int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
514 int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
518 * This function passes a command-name and argument to an ENGINE. The
520 * called using 'arg' as an argument (unless the ENGINE doesn't support such
523 * to a numeric value. If cmd_optional is non-zero, then if the ENGINE
526 * (or config files) can supply engine-specific config data to the ENGINE at
534 * 'ENGINE'-enabled devices should write ENGINE implementations with
535 * parameterisations that work in this scheme, so that compliant ENGINE-based
537 * same ENGINE-enabled devices, across applications.
539 int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
543 * These functions are useful for manufacturing new ENGINE structures. They
545 * ENGINE structure with personalised implementations of things prior to
546 * using it directly or adding it to the builtin ENGINE list in OpenSSL.
547 * These are also here so that the ENGINE structure doesn't have to be
550 ENGINE *ENGINE_new(void);
551 int ENGINE_free(ENGINE *e);
552 int ENGINE_up_ref(ENGINE *e);
553 int ENGINE_set_id(ENGINE *e, const char *id);
554 int ENGINE_set_name(ENGINE *e, const char *name);
555 int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
556 int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
557 int ENGINE_set_ECDH(ENGINE *e, const ECDH_METHOD *ecdh_meth);
558 int ENGINE_set_ECDSA(ENGINE *e, const ECDSA_METHOD *ecdsa_meth);
559 int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
560 int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
561 int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *store_meth);
562 int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
563 int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
564 int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
565 int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
566 int ENGINE_set_load_privkey_function(ENGINE *e,
568 int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
569 int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
572 int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
573 int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
574 int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
575 int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f);
576 int ENGINE_set_flags(ENGINE *e, int flags);
577 int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns);
578 /* These functions allow control over any per-structure ENGINE data. */
582 int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
583 void *ENGINE_get_ex_data(const ENGINE *e, int idx);
594 * These return values from within the ENGINE structure. These can be useful
599 const char *ENGINE_get_id(const ENGINE *e);
600 const char *ENGINE_get_name(const ENGINE *e);
601 const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
602 const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
603 const ECDH_METHOD *ENGINE_get_ECDH(const ENGINE *e);
604 const ECDSA_METHOD *ENGINE_get_ECDSA(const ENGINE *e);
605 const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
606 const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
607 const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e);
608 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
609 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
610 ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
611 ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
612 ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
613 ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
614 ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE
616 ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
617 ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
618 ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e);
619 ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e);
620 const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
621 const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
622 const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid);
623 const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid);
624 const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e,
627 const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
630 const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
631 int ENGINE_get_flags(const ENGINE *e);
634 * FUNCTIONAL functions. These functions deal with ENGINE structures that
641 * ENGINE has 2 reference counts; structural and functional. Every time a
651 int ENGINE_init(ENGINE *e);
657 int ENGINE_finish(ENGINE *e);
664 EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
666 EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
668 int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s,
674 * This returns a pointer for the current ENGINE structure that is (by
679 ENGINE *ENGINE_get_default_RSA(void);
681 ENGINE *ENGINE_get_default_DSA(void);
682 ENGINE *ENGINE_get_default_ECDH(void);
683 ENGINE *ENGINE_get_default_ECDSA(void);
684 ENGINE *ENGINE_get_default_DH(void);
685 ENGINE *ENGINE_get_default_RAND(void);
690 ENGINE *ENGINE_get_cipher_engine(int nid);
691 ENGINE *ENGINE_get_digest_engine(int nid);
692 ENGINE *ENGINE_get_pkey_meth_engine(int nid);
693 ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid);
696 * This sets a new default ENGINE structure for performing RSA operations. If
697 * the result is non-zero (success) then the ENGINE structure will have had
701 int ENGINE_set_default_RSA(ENGINE *e);
702 int ENGINE_set_default_string(ENGINE *e, const char *def_list);
704 int ENGINE_set_default_DSA(ENGINE *e);
705 int ENGINE_set_default_ECDH(ENGINE *e);
706 int ENGINE_set_default_ECDSA(ENGINE *e);
707 int ENGINE_set_default_DH(ENGINE *e);
708 int ENGINE_set_default_RAND(ENGINE *e);
709 int ENGINE_set_default_ciphers(ENGINE *e);
710 int ENGINE_set_default_digests(ENGINE *e);
711 int ENGINE_set_default_pkey_meths(ENGINE *e);
712 int ENGINE_set_default_pkey_asn1_meths(ENGINE *e);
721 int ENGINE_set_default(ENGINE *e, unsigned int flags);
729 /* DYNAMIC ENGINE SUPPORT */
741 * When compiling an ENGINE entirely as an external shared library, loadable
742 * by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns'
807 * This function is passed the ENGINE structure to initialise with its own
810 * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto
814 * represents the ENGINE id that the loader is looking for. If this is NULL,
816 * 'default' ENGINE. If non-NULL, the shared library must initialise only an
817 * ENGINE matching the passed 'id'. The function is expected to be
820 * 'fn' is a callback function that populates the ENGINE structure and
822 * [static] int fn(ENGINE *e, const char *id);
824 typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id,
828 int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \
830 int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \
848 * If the loading application (or library) and the loaded ENGINE library
852 * the loaded ENGINE has (or gets from through the loader) its own copy of
855 * static data and let the loading application and loaded ENGINE compare
871 /* Error codes for the ENGINE functions. */