/* The following functions handle keys that are stored in some secondary * location, handled by the engine.  The storage may be on a card or * whatever. */EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,	UI_METHOD *ui_method, void *callback_data);EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,	UI_METHOD *ui_method, void *callback_data);/* This returns a pointer for the current ENGINE structure that * is (by default) performing any RSA operations. The value returned * is an incremented reference, so it should be free'd (ENGINE_finish) * before it is discarded. */ENGINE *ENGINE_get_default_RSA(void);/* Same for the other "methods" */ENGINE *ENGINE_get_default_DSA(void);ENGINE *ENGINE_get_default_ECDH(void);ENGINE *ENGINE_get_default_ECDSA(void);ENGINE *ENGINE_get_default_DH(void);ENGINE *ENGINE_get_default_RAND(void);/* These functions can be used to get a functional reference to perform * ciphering or digesting corresponding to "nid". */ENGINE *ENGINE_get_cipher_engine(int nid);ENGINE *ENGINE_get_digest_engine(int nid);/* This sets a new default ENGINE structure for performing RSA * operations. If the result is non-zero (success) then the ENGINE * structure will have had its reference count up'd so the caller * should still free their own reference 'e'. */int ENGINE_set_default_RSA(ENGINE *e);int ENGINE_set_default_string(ENGINE *e, const char *def_list);/* Same for the other "methods" */int ENGINE_set_default_DSA(ENGINE *e);int ENGINE_set_default_ECDH(ENGINE *e);int ENGINE_set_default_ECDSA(ENGINE *e);int ENGINE_set_default_DH(ENGINE *e);int ENGINE_set_default_RAND(ENGINE *e);int ENGINE_set_default_ciphers(ENGINE *e);int ENGINE_set_default_digests(ENGINE *e);/* The combination "set" - the flags are bitwise "OR"d from the * ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()" * function, this function can result in unnecessary static linkage. If your * application requires only specific functionality, consider using more * selective functions. */int ENGINE_set_default(ENGINE *e, unsigned int flags);void ENGINE_add_conf_module(void);/* Deprecated functions ... *//* int ENGINE_clear_defaults(void); *//**************************//* DYNAMIC ENGINE SUPPORT *//**************************//* Binary/behaviour compatibility levels */#define OSSL_DYNAMIC_VERSION		(unsigned long)0x00020000/* Binary versions older than this are too old for us (whether we're a loader or * a loadee) */#define OSSL_DYNAMIC_OLDEST		(unsigned long)0x00020000/* When compiling an ENGINE entirely as an external shared library, loadable by * the "dynamic" ENGINE, these types are needed. The 'dynamic_fns' structure * type provides the calling application's (or library's) error functionality * and memory management function pointers to the loaded library. These should * be used/set in the loaded library code so that the loading application's * 'state' will be used/changed in all operations. The 'static_state' pointer * allows the loaded library to know if it shares the same static data as the * calling application (or library), and thus whether these callbacks need to be * set or not. */typedef void *(*dyn_MEM_malloc_cb)(size_t);typedef void *(*dyn_MEM_realloc_cb)(void *, size_t);typedef void (*dyn_MEM_free_cb)(void *);typedef struct st_dynamic_MEM_fns {	dyn_MEM_malloc_cb			malloc_cb;	dyn_MEM_realloc_cb			realloc_cb;	dyn_MEM_free_cb				free_cb;	} dynamic_MEM_fns;/* FIXME: Perhaps the memory and locking code (crypto.h) should declare and use * these types so we (and any other dependant code) can simplify a bit?? */typedef void (*dyn_lock_locking_cb)(int,int,const char *,int);typedef int (*dyn_lock_add_lock_cb)(int*,int,int,const char *,int);typedef struct CRYPTO_dynlock_value *(*dyn_dynlock_create_cb)(						const char *,int);typedef void (*dyn_dynlock_lock_cb)(int,struct CRYPTO_dynlock_value *,						const char *,int);typedef void (*dyn_dynlock_destroy_cb)(struct CRYPTO_dynlock_value *,						const char *,int);typedef struct st_dynamic_LOCK_fns {	dyn_lock_locking_cb			lock_locking_cb;	dyn_lock_add_lock_cb			lock_add_lock_cb;	dyn_dynlock_create_cb			dynlock_create_cb;	dyn_dynlock_lock_cb			dynlock_lock_cb;	dyn_dynlock_destroy_cb			dynlock_destroy_cb;	} dynamic_LOCK_fns;/* The top-level structure */typedef struct st_dynamic_fns {	void 					*static_state;	const ERR_FNS				*err_fns;	const CRYPTO_EX_DATA_IMPL		*ex_data_fns;	dynamic_MEM_fns				mem_fns;	dynamic_LOCK_fns			lock_fns;	} dynamic_fns;/* The version checking function should be of this prototype. NB: The * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading code. * If this function returns zero, it indicates a (potential) version * incompatibility and the loaded library doesn't believe it can proceed. * Otherwise, the returned value is the (latest) version supported by the * loading library. The loader may still decide that the loaded code's version * is unsatisfactory and could veto the load. The function is expected to * be implemented with the symbol name "v_check", and a default implementation * can be fully instantiated with IMPLEMENT_DYNAMIC_CHECK_FN(). */typedef unsigned long (*dynamic_v_check_fn)(unsigned long ossl_version);#define IMPLEMENT_DYNAMIC_CHECK_FN() \	unsigned long v_check(unsigned long v) { \		if(v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \		return 0; }/* This function is passed the ENGINE structure to initialise with its own * function and command settings. It should not adjust the structural or * functional reference counts. If this function returns zero, (a) the load will * be aborted, (b) the previous ENGINE state will be memcpy'd back onto the * structure, and (c) the shared library will be unloaded. So implementations * should do their own internal cleanup in failure circumstances otherwise they * could leak. The 'id' parameter, if non-NULL, represents the ENGINE id that * the loader is looking for. If this is NULL, the shared library can choose to * return failure or to initialise a 'default' ENGINE. If non-NULL, the shared * library must initialise only an ENGINE matching the passed 'id'. The function * is expected to be implemented with the symbol name "bind_engine". A standard * implementation can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where * the parameter 'fn' is a callback function that populates the ENGINE structure * and returns an int value (zero for failure). 'fn' should have prototype; *    [static] int fn(ENGINE *e, const char *id); */typedef int (*dynamic_bind_engine)(ENGINE *e, const char *id,				const dynamic_fns *fns);#define IMPLEMENT_DYNAMIC_BIND_FN(fn) \	int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \		if(ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \		if(!CRYPTO_set_mem_functions(fns->mem_fns.malloc_cb, \			fns->mem_fns.realloc_cb, fns->mem_fns.free_cb)) \			return 0; \		CRYPTO_set_locking_callback(fns->lock_fns.lock_locking_cb); \		CRYPTO_set_add_lock_callback(fns->lock_fns.lock_add_lock_cb); \		CRYPTO_set_dynlock_create_callback(fns->lock_fns.dynlock_create_cb); \		CRYPTO_set_dynlock_lock_callback(fns->lock_fns.dynlock_lock_cb); \		CRYPTO_set_dynlock_destroy_callback(fns->lock_fns.dynlock_destroy_cb); \		if(!CRYPTO_set_ex_data_implementation(fns->ex_data_fns)) \			return 0; \		if(!ERR_set_implementation(fns->err_fns)) return 0; \	skip_cbs: \		if(!fn(e,id)) return 0; \		return 1; }/* If the loading application (or library) and the loaded ENGINE library share * the same static data (eg. they're both dynamically linked to the same * libcrypto.so) we need a way to avoid trying to set system callbacks - this * would fail, and for the same reason that it's unnecessary to try. If the * loaded ENGINE has (or gets from through the loader) its own copy of the * libcrypto static data, we will need to set the callbacks. The easiest way to * detect this is to have a function that returns a pointer to some static data * and let the loading application and loaded ENGINE compare their respective * values. */void *ENGINE_get_static_state(void);#if defined(__OpenBSD__) || defined(__FreeBSD__)void ENGINE_setup_bsd_cryptodev(void);#endif/* BEGIN ERROR CODES *//* The following lines are auto generated by the script mkerr.pl. Any changes * made after this point may be overwritten when the script is next run. */void ERR_load_ENGINE_strings(void);/* Error codes for the ENGINE functions. *//* Function codes. */#define ENGINE_F_DYNAMIC_CTRL				 180#define ENGINE_F_DYNAMIC_GET_DATA_CTX			 181#define ENGINE_F_DYNAMIC_LOAD				 182#define ENGINE_F_DYNAMIC_SET_DATA_CTX			 183#define ENGINE_F_ENGINE_ADD				 105#define ENGINE_F_ENGINE_BY_ID				 106#define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE		 170#define ENGINE_F_ENGINE_CTRL				 142#define ENGINE_F_ENGINE_CTRL_CMD			 178#define ENGINE_F_ENGINE_CTRL_CMD_STRING			 171#define ENGINE_F_ENGINE_FINISH				 107#define ENGINE_F_ENGINE_FREE_UTIL			 108#define ENGINE_F_ENGINE_GET_CIPHER			 185#define ENGINE_F_ENGINE_GET_DEFAULT_TYPE		 177#define ENGINE_F_ENGINE_GET_DIGEST			 186#define ENGINE_F_ENGINE_GET_NEXT			 115#define ENGINE_F_ENGINE_GET_PREV			 116#define ENGINE_F_ENGINE_INIT				 119#define ENGINE_F_ENGINE_LIST_ADD			 120#define ENGINE_F_ENGINE_LIST_REMOVE			 121#define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY		 150#define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY			 151#define ENGINE_F_ENGINE_NEW				 122#define ENGINE_F_ENGINE_REMOVE				 123#define ENGINE_F_ENGINE_SET_DEFAULT_STRING		 189#define ENGINE_F_ENGINE_SET_DEFAULT_TYPE		 126#define ENGINE_F_ENGINE_SET_ID				 129#define ENGINE_F_ENGINE_SET_NAME			 130#define ENGINE_F_ENGINE_TABLE_REGISTER			 184#define ENGINE_F_ENGINE_UNLOAD_KEY			 152#define ENGINE_F_ENGINE_UNLOCKED_FINISH			 191#define ENGINE_F_ENGINE_UP_REF				 190#define ENGINE_F_INT_CTRL_HELPER			 172#define ENGINE_F_INT_ENGINE_CONFIGURE			 188#define ENGINE_F_INT_ENGINE_MODULE_INIT			 187#define ENGINE_F_LOG_MESSAGE				 141/* Reason codes. */#define ENGINE_R_ALREADY_LOADED				 100#define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER		 133#define ENGINE_R_CMD_NOT_EXECUTABLE			 134#define ENGINE_R_COMMAND_TAKES_INPUT			 135#define ENGINE_R_COMMAND_TAKES_NO_INPUT			 136#define ENGINE_R_CONFLICTING_ENGINE_ID			 103#define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED		 119#define ENGINE_R_DH_NOT_IMPLEMENTED			 139#define ENGINE_R_DSA_NOT_IMPLEMENTED			 140#define ENGINE_R_DSO_FAILURE				 104#define ENGINE_R_DSO_NOT_FOUND				 132#define ENGINE_R_ENGINES_SECTION_ERROR			 148#define ENGINE_R_ENGINE_IS_NOT_IN_LIST			 105#define ENGINE_R_ENGINE_SECTION_ERROR			 149#define ENGINE_R_FAILED_LOADING_PRIVATE_KEY		 128#define ENGINE_R_FAILED_LOADING_PUBLIC_KEY		 129#define ENGINE_R_FINISH_FAILED				 106#define ENGINE_R_GET_HANDLE_FAILED			 107#define ENGINE_R_ID_OR_NAME_MISSING			 108#define ENGINE_R_INIT_FAILED				 109#define ENGINE_R_INTERNAL_LIST_ERROR			 110#define ENGINE_R_INVALID_ARGUMENT			 143#define ENGINE_R_INVALID_CMD_NAME			 137#define ENGINE_R_INVALID_CMD_NUMBER			 138#define ENGINE_R_INVALID_INIT_VALUE			 151#define ENGINE_R_INVALID_STRING				 150#define ENGINE_R_NOT_INITIALISED			 117#define ENGINE_R_NOT_LOADED				 112#define ENGINE_R_NO_CONTROL_FUNCTION			 120#define ENGINE_R_NO_INDEX				 144#define ENGINE_R_NO_LOAD_FUNCTION			 125#define ENGINE_R_NO_REFERENCE				 130#define ENGINE_R_NO_SUCH_ENGINE				 116#define ENGINE_R_NO_UNLOAD_FUNCTION			 126#define ENGINE_R_PROVIDE_PARAMETERS			 113#define ENGINE_R_RSA_NOT_IMPLEMENTED			 141#define ENGINE_R_UNIMPLEMENTED_CIPHER			 146#define ENGINE_R_UNIMPLEMENTED_DIGEST			 147#define ENGINE_R_VERSION_INCOMPATIBILITY		 145#ifdef  __cplusplus}#endif#endif