自学教程：C++ ENGINE_set_cmd_defns函数代码示例

static int bind_helper(ENGINE * e) {    if (!ENGINE_set_id(e, TEST_ENGINE_ID)        || !ENGINE_set_name(e, TEST_ENGINE_NAME)        || !ENGINE_set_ctrl_function(e, test_engine_ctrl)        || !ENGINE_set_cmd_defns(e, te_cmd_defns)        || !ENGINE_set_digests(e, te_digests)        || !ENGINE_set_pkey_meths(e, te_pkey_meths)        || !ENGINE_set_pkey_asn1_meths(e, te_pkey_asn1_meths) ) {        printf("Engine init failed/n");        return 0;    }    if (!register_ameth_gost(NID_hmac_sha1, &ameth_HMAC_SHA1, "hmac-sha1", "HMAC-SHA1 MAC")        || !register_pmeth_gost(NID_hmac_sha1, &pmeth_HMAC_SHA1, 0)) {        printf("Internal init failed/n");        return 0;    }    if(!ENGINE_register_digests(e)        || !ENGINE_register_pkey_meths(e)        || !ENGINE_register_pkey_asn1_meths(e)        || !EVP_add_digest(&digest_hmac_sha1)) {        printf("Digest registration failed/n");        return 0;    }    return 1;}

/* ---------------------*/static int bind_helper(ENGINE *e){    if (!ENGINE_set_id(e, engine_cluster_labs_id) ||        !ENGINE_set_name(e, engine_cluster_labs_name) ||#  ifndef OPENSSL_NO_RSA        !ENGINE_set_RSA(e, &cluster_labs_rsa) ||#  endif#  ifndef OPENSSL_NO_DSA        !ENGINE_set_DSA(e, &cluster_labs_dsa) ||#  endif#  ifndef OPENSSL_NO_DH        !ENGINE_set_DH(e, &cluster_labs_dh) ||#  endif        !ENGINE_set_RAND(e, &cluster_labs_rand) ||        !ENGINE_set_destroy_function(e, cluster_labs_destroy) ||        !ENGINE_set_init_function(e, cluster_labs_init) ||        !ENGINE_set_finish_function(e, cluster_labs_finish) ||        !ENGINE_set_ctrl_function(e, cluster_labs_ctrl) ||        !ENGINE_set_cmd_defns(e, cluster_labs_cmd_defns))        return 0;    /* Ensure the error handling is set up */    ERR_load_CL_strings();    return 1;}

static int keystore_engine_setup(ENGINE* e) {    ALOGV("keystore_engine_setup");    if (!ENGINE_set_id(e, KEYSTORE_ENGINE_ID)            || !ENGINE_set_name(e, KEYSTORE_ENGINE_NAME)            || !ENGINE_set_load_privkey_function(e, keystore_loadkey)            || !ENGINE_set_load_pubkey_function(e, keystore_loadkey)            || !ENGINE_set_cmd_defns(e, keystore_cmd_defns)) {        ALOGE("Could not set up keystore engine");        return 0;    }    if (!ENGINE_set_RSA(e, &keystore_rsa_meth)            || !register_rsa_methods()) {        ALOGE("Could not set up keystore RSA methods");        return 0;    }    /* We need a handle in the RSA keys as well for keygen if it's not already initialized. */    pthread_once(&rsa_key_handle_control, init_rsa_key_handle);    if (rsa_key_handle < 0) {        ALOGE("Could not set up RSA ex_data index");        return 0;    }    return 1;}

/* This internal function is used by ENGINE_gmp() and possibly by the * "dynamic" ENGINE support too */static int bind_helper(ENGINE *e)	{#ifndef OPENSSL_NO_RSA	const RSA_METHOD *meth1;#endif	if(!ENGINE_set_id(e, engine_e_gmp_id) ||			!ENGINE_set_name(e, engine_e_gmp_name) ||#ifndef OPENSSL_NO_RSA			!ENGINE_set_RSA(e, &e_gmp_rsa) ||#endif			!ENGINE_set_destroy_function(e, e_gmp_destroy) ||			!ENGINE_set_init_function(e, e_gmp_init) ||			!ENGINE_set_finish_function(e, e_gmp_finish) ||			!ENGINE_set_ctrl_function(e, e_gmp_ctrl) ||			!ENGINE_set_cmd_defns(e, e_gmp_cmd_defns))		return 0;#ifndef OPENSSL_NO_RSA	meth1 = RSA_PKCS1_SSLeay();	e_gmp_rsa.rsa_pub_enc = meth1->rsa_pub_enc;	e_gmp_rsa.rsa_pub_dec = meth1->rsa_pub_dec;	e_gmp_rsa.rsa_priv_enc = meth1->rsa_priv_enc;	e_gmp_rsa.rsa_priv_dec = meth1->rsa_priv_dec;	e_gmp_rsa.bn_mod_exp = meth1->bn_mod_exp;#endif	/* Ensure the e_gmp error handling is set up */	ERR_load_GMP_strings();	return 1;	}

    static ENGINE* LoadEngine()    {      // This function creates an engine for PKCS#11 and inspired by      // the "ENGINE_load_dynamic" function from OpenSSL, in file      // "crypto/engine/eng_dyn.c"      ENGINE* engine = ENGINE_new();      if (!engine)      {        LOG(ERROR) << "Cannot create an OpenSSL engine for PKCS#11";        throw OrthancException(ErrorCode_InternalError);      }      // Create a PKCS#11 context using libp11      context_ = pkcs11_new();      if (!context_)      {        LOG(ERROR) << "Cannot create a libp11 context for PKCS#11";        ENGINE_free(engine);        throw OrthancException(ErrorCode_InternalError);      }      if (!ENGINE_set_id(engine, PKCS11_ENGINE_ID) ||          !ENGINE_set_name(engine, PKCS11_ENGINE_NAME) ||          !ENGINE_set_cmd_defns(engine, PKCS11_ENGINE_COMMANDS) ||          // Register the callback functions          !ENGINE_set_init_function(engine, EngineInitialize) ||          !ENGINE_set_finish_function(engine, EngineFinalize) ||          !ENGINE_set_destroy_function(engine, EngineDestroy) ||          !ENGINE_set_ctrl_function(engine, EngineControl) ||          !ENGINE_set_load_pubkey_function(engine, EngineLoadPublicKey) ||          !ENGINE_set_load_privkey_function(engine, EngineLoadPrivateKey) ||          !ENGINE_set_RSA(engine, PKCS11_get_rsa_method()) ||          !ENGINE_set_ECDSA(engine, PKCS11_get_ecdsa_method()) ||          !ENGINE_set_ECDH(engine, PKCS11_get_ecdh_method()) ||#if OPENSSL_VERSION_NUMBER  >= 0x10100002L          !ENGINE_set_EC(engine, PKCS11_get_ec_key_method()) ||#endif          // Make OpenSSL know about our PKCS#11 engine          !ENGINE_add(engine))      {        LOG(ERROR) << "Cannot initialize the OpenSSL engine for PKCS#11";        pkcs11_finish(context_);        ENGINE_free(engine);        throw OrthancException(ErrorCode_InternalError);      }      // If the "ENGINE_add" worked, it gets a structural      // reference. We release our just-created reference.      ENGINE_free(engine);      return ENGINE_by_id(PKCS11_ENGINE_ID);    }

/* * This internal function is used by ENGINE_ubsec() and possibly by the * "dynamic" ENGINE support too */static int bind_helper(ENGINE *e){#  ifndef OPENSSL_NO_RSA    const RSA_METHOD *meth1;#  endif#  ifndef OPENSSL_NO_DH#   ifndef HAVE_UBSEC_DH    const DH_METHOD *meth3;#   endif                       /* HAVE_UBSEC_DH */#  endif    if (!ENGINE_set_id(e, engine_ubsec_id) ||        !ENGINE_set_name(e, engine_ubsec_name) ||#  ifndef OPENSSL_NO_RSA        !ENGINE_set_RSA(e, &ubsec_rsa) ||#  endif#  ifndef OPENSSL_NO_DSA        !ENGINE_set_DSA(e, &ubsec_dsa) ||#  endif#  ifndef OPENSSL_NO_DH        !ENGINE_set_DH(e, &ubsec_dh) ||#  endif        !ENGINE_set_destroy_function(e, ubsec_destroy) ||        !ENGINE_set_init_function(e, ubsec_init) ||        !ENGINE_set_finish_function(e, ubsec_finish) ||        !ENGINE_set_ctrl_function(e, ubsec_ctrl) ||        !ENGINE_set_cmd_defns(e, ubsec_cmd_defns))        return 0;#  ifndef OPENSSL_NO_RSA    /*     * We know that the "PKCS1_OpenSSL()" functions hook properly to the     * Broadcom-specific mod_exp and mod_exp_crt so we use those functions.     * NB: We don't use ENGINE_openssl() or anything "more generic" because     * something like the RSAref code may not hook properly, and if you own     * one of these cards then you have the right to do RSA operations on it     * anyway!     */    meth1 = RSA_PKCS1_OpenSSL();    ubsec_rsa.rsa_pub_enc = meth1->rsa_pub_enc;    ubsec_rsa.rsa_pub_dec = meth1->rsa_pub_dec;    ubsec_rsa.rsa_priv_enc = meth1->rsa_priv_enc;    ubsec_rsa.rsa_priv_dec = meth1->rsa_priv_dec;#  endif#  ifndef OPENSSL_NO_DH#   ifndef HAVE_UBSEC_DH    /* Much the same for Diffie-Hellman */    meth3 = DH_OpenSSL();    ubsec_dh.generate_key = meth3->generate_key;    ubsec_dh.compute_key = meth3->compute_key;#   endif                       /* HAVE_UBSEC_DH */#  endif    /* Ensure the ubsec error handling is set up */    ERR_load_UBSEC_strings();    return 1;}

static int bind_devcrypto(ENGINE *e) {    if (!ENGINE_set_id(e, engine_devcrypto_id)        || !ENGINE_set_name(e, "/dev/crypto engine")        || !ENGINE_set_destroy_function(e, devcrypto_unload)        || !ENGINE_set_cmd_defns(e, devcrypto_cmds)        || !ENGINE_set_ctrl_function(e, devcrypto_ctrl))        return 0;    prepare_cipher_methods();#ifdef IMPLEMENT_DIGEST    prepare_digest_methods();#endif    return (ENGINE_set_ciphers(e, devcrypto_ciphers)#ifdef IMPLEMENT_DIGEST        && ENGINE_set_digests(e, devcrypto_digests)#endif/* * Asymmetric ciphers aren't well supported with /dev/crypto.  Among the BSD * implementations, it seems to only exist in FreeBSD, and regarding the * parameters in its crypt_kop, the manual crypto(4) has this to say: * *    The semantics of these arguments are currently undocumented. * * Reading through the FreeBSD source code doesn't give much more than * their CRK_MOD_EXP implementation for ubsec. * * It doesn't look much better with cryptodev-linux.  They have the crypt_kop * structure as well as the command (CRK_*) in cryptodev.h, but no support * seems to be implemented at all for the moment. * * At the time of writing, it seems impossible to write proper support for * FreeBSD's asym features without some very deep knowledge and access to * specific kernel modules. * * /Richard Levitte, 2017-05-11 */#if 0# ifndef OPENSSL_NO_RSA        && ENGINE_set_RSA(e, devcrypto_rsa)# endif# ifndef OPENSSL_NO_DSA        && ENGINE_set_DSA(e, devcrypto_dsa)# endif# ifndef OPENSSL_NO_DH        && ENGINE_set_DH(e, devcrypto_dh)# endif# ifndef OPENSSL_NO_EC        && ENGINE_set_EC(e, devcrypto_ec)# endif#endif        );}

/* * This internal function is used by ENGINE_chil() and possibly by the * "dynamic" ENGINE support too */static int bind_helper(ENGINE *e){#  ifndef OPENSSL_NO_RSA    const RSA_METHOD *meth1;#  endif#  ifndef OPENSSL_NO_DH    const DH_METHOD *meth2;#  endif    if (!ENGINE_set_id(e, engine_hwcrhk_id) ||        !ENGINE_set_name(e, engine_hwcrhk_name) ||#  ifndef OPENSSL_NO_RSA        !ENGINE_set_RSA(e, &hwcrhk_rsa) ||#  endif#  ifndef OPENSSL_NO_DH        !ENGINE_set_DH(e, &hwcrhk_dh) ||#  endif        !ENGINE_set_RAND(e, &hwcrhk_rand) ||        !ENGINE_set_destroy_function(e, hwcrhk_destroy) ||        !ENGINE_set_init_function(e, hwcrhk_init) ||        !ENGINE_set_finish_function(e, hwcrhk_finish) ||        !ENGINE_set_ctrl_function(e, hwcrhk_ctrl) ||        !ENGINE_set_load_privkey_function(e, hwcrhk_load_privkey) ||        !ENGINE_set_load_pubkey_function(e, hwcrhk_load_pubkey) ||        !ENGINE_set_cmd_defns(e, hwcrhk_cmd_defns))        return 0;#  ifndef OPENSSL_NO_RSA    /*     * We know that the "PKCS1_SSLeay()" functions hook properly to the     * cswift-specific mod_exp and mod_exp_crt so we use those functions. NB:     * We don't use ENGINE_openssl() or anything "more generic" because     * something like the RSAref code may not hook properly, and if you own     * one of these cards then you have the right to do RSA operations on it     * anyway!     */    meth1 = RSA_PKCS1_SSLeay();    hwcrhk_rsa.rsa_pub_enc = meth1->rsa_pub_enc;    hwcrhk_rsa.rsa_pub_dec = meth1->rsa_pub_dec;    hwcrhk_rsa.rsa_priv_enc = meth1->rsa_priv_enc;    hwcrhk_rsa.rsa_priv_dec = meth1->rsa_priv_dec;#  endif#  ifndef OPENSSL_NO_DH    /* Much the same for Diffie-Hellman */    meth2 = DH_OpenSSL();    hwcrhk_dh.generate_key = meth2->generate_key;    hwcrhk_dh.compute_key = meth2->compute_key;#  endif    /* Ensure the hwcrhk error handling is set up */    ERR_load_HWCRHK_strings();    return 1;}

static int cuda_bind_helper(ENGINE * e) {	if (!ENGINE_set_id(e, CUDA_ENGINE_ID) ||	    !ENGINE_set_init_function(e, cuda_init) ||	    !ENGINE_set_finish_function(e, cuda_finish) ||	    !ENGINE_set_ctrl_function(e, cuda_engine_ctrl) ||	    !ENGINE_set_cmd_defns(e, cuda_cmd_defns) ||	    !ENGINE_set_name(e, CUDA_ENGINE_NAME) ||	    !ENGINE_set_ciphers (e, cuda_ciphers)) {		return 0;	} else {		return 1;	}}

static ENGINE *engine_dynamic(void){    ENGINE *ret = ENGINE_new();    if (ret == NULL)        return NULL;    if (!ENGINE_set_id(ret, engine_dynamic_id) ||        !ENGINE_set_name(ret, engine_dynamic_name) ||        !ENGINE_set_init_function(ret, dynamic_init) ||        !ENGINE_set_finish_function(ret, dynamic_finish) ||        !ENGINE_set_ctrl_function(ret, dynamic_ctrl) ||        !ENGINE_set_flags(ret, ENGINE_FLAGS_BY_ID_COPY) ||        !ENGINE_set_cmd_defns(ret, dynamic_cmd_defns)) {        ENGINE_free(ret);        return NULL;    }    return ret;}

static int bind_helper(ENGINE *e){    fprintf(stderr, "arrive at bind_helper/n");	if(!ENGINE_set_id(e, engine_hwdev_id) ||	   !ENGINE_set_name(e, engine_hwdev_name) ||	   !ENGINE_set_ECDH(e, &ecdh_meth) ||	   !ENGINE_set_destroy_function(e, hwdev_destroy) ||	   !ENGINE_set_init_function(e, hwdev_init) ||	   !ENGINE_set_finish_function(e, hwdev_finish) ||	   !ENGINE_set_ctrl_function(e, hwdev_ctrl) ||	   !ENGINE_set_load_privkey_function(e, hwdev_load_privkey) ||	   !ENGINE_set_load_pubkey_function(e, hwdev_load_pubkey) ||	   !ENGINE_set_cmd_defns(e, hwdev_cmd_defns))		return 0;	return 1;}

static int bind_capi(ENGINE *e)	{	if (!ENGINE_set_id(e, engine_capi_id)		|| !ENGINE_set_name(e, engine_capi_name)		|| !ENGINE_set_init_function(e, capi_init)		|| !ENGINE_set_finish_function(e, capi_finish)		|| !ENGINE_set_destroy_function(e, capi_destroy)		|| !ENGINE_set_RSA(e, &capi_rsa_method)		|| !ENGINE_set_DSA(e, &capi_dsa_method)		|| !ENGINE_set_load_privkey_function(e, capi_load_privkey)		|| !ENGINE_set_load_ssl_client_cert_function(e,						capi_load_ssl_client_cert)		|| !ENGINE_set_cmd_defns(e, capi_cmd_defns)		|| !ENGINE_set_ctrl_function(e, capi_ctrl))			return 0;	ERR_load_CAPI_strings();	return 1;	}

/* This internal function is used by ENGINE_tpm() and possibly by the * "dynamic" ENGINE support too */static int bind_helper(ENGINE * e){	if (!ENGINE_set_id(e, engine_tpm_id) ||	    !ENGINE_set_name(e, engine_tpm_name) ||#ifndef OPENSSL_NO_RSA	    !ENGINE_set_RSA(e, &tpm_rsa) ||#endif	    !ENGINE_set_RAND(e, &tpm_rand) ||	    !ENGINE_set_destroy_function(e, tpm_engine_destroy) ||	    !ENGINE_set_init_function(e, tpm_engine_init) ||	    !ENGINE_set_finish_function(e, tpm_engine_finish) ||	    !ENGINE_set_ctrl_function(e, tpm_engine_ctrl) ||	    !ENGINE_set_load_pubkey_function(e, tpm_engine_load_key) ||	    !ENGINE_set_load_privkey_function(e, tpm_engine_load_key) ||	    !ENGINE_set_cmd_defns(e, tpm_cmd_defns))		return 0;	/* Ensure the tpm error handling is set up */	ERR_load_TPM_strings();	return 1;}

/* ---------------------*/static int bind_helper(ENGINE *e){    if (!ENGINE_set_id(e, engine_4758_cca_id) ||        !ENGINE_set_name(e, engine_4758_cca_name) ||#  ifndef OPENSSL_NO_RSA        !ENGINE_set_RSA(e, &ibm_4758_cca_rsa) ||#  endif        !ENGINE_set_RAND(e, &ibm_4758_cca_rand) ||        !ENGINE_set_destroy_function(e, ibm_4758_cca_destroy) ||        !ENGINE_set_init_function(e, ibm_4758_cca_init) ||        !ENGINE_set_finish_function(e, ibm_4758_cca_finish) ||        !ENGINE_set_ctrl_function(e, ibm_4758_cca_ctrl) ||#  ifndef OPENSSL_NO_RSA        !ENGINE_set_load_privkey_function(e, ibm_4758_load_privkey) ||        !ENGINE_set_load_pubkey_function(e, ibm_4758_load_pubkey) ||#  endif        !ENGINE_set_cmd_defns(e, cca4758_cmd_defns))        return 0;    /* Ensure the error handling is set up */    ERR_load_CCA4758_strings();    return 1;}

/* * This internal function is used by ENGINE_skf() and possibly by the * "dynamic" ENGINE support too */static int bind_helper(ENGINE *e){#  ifndef OPENSSL_NO_RSA    const RSA_METHOD *meth1;#  endif    if (!ENGINE_set_id(e, engine_hwskf_id) ||        !ENGINE_set_name(e, engine_hwskf_name) ||                !ENGINE_set_destroy_function(e, hwskf_destroy) ||        !ENGINE_set_init_function(e, hwskf_init) ||        !ENGINE_set_finish_function(e, hwskf_finish) ||        !ENGINE_set_ctrl_function(e, hwskf_ctrl) ||        !ENGINE_set_load_privkey_function(e, hwskf_load_privkey) ||        !ENGINE_set_load_pubkey_function(e, hwskf_load_pubkey) ||        !ENGINE_set_cmd_defns(e, hwskf_cmd_defns))        return 0;#  ifndef OPENSSL_NO_RSA    /*     * We know that the "PKCS1_SSLeay()" functions hook properly to the     * cswift-specific mod_exp and mod_exp_crt so we use those functions. NB:     * We don't use ENGINE_openssl() or anything "more generic" because     * something like the RSAref code may not hook properly, and if you own     * one of these cards then you have the right to do RSA operations on it     * anyway!     */     /*    meth1 = RSA_PKCS1_SSLeay();    hwskf_rsa.rsa_pub_enc = meth1->rsa_pub_enc;    hwskf_rsa.rsa_pub_dec = meth1->rsa_pub_dec;    hwskf_rsa.rsa_priv_enc = meth1->rsa_priv_enc;    hwskf_rsa.rsa_priv_dec = meth1->rsa_priv_dec;    */#  endif    /* Ensure the hwcrhk error handling is set up */    //ERR_load_HWSKF_strings();    return 1;}

/* Returns 1 if successfully added, 2 if engine has previously been added,   and 0 for error. */int Cryptography_add_osrandom_engine(void) {    ENGINE *e;    ERR_load_Cryptography_OSRandom_strings();    e = ENGINE_by_id(Cryptography_osrandom_engine_id);    if (e != NULL) {        ENGINE_free(e);        return 2;    } else {        ERR_clear_error();    }    e = ENGINE_new();    if (e == NULL) {        return 0;    }    if (!ENGINE_set_id(e, Cryptography_osrandom_engine_id) ||            !ENGINE_set_name(e, Cryptography_osrandom_engine_name) ||            !ENGINE_set_RAND(e, &osrandom_rand) ||            !ENGINE_set_init_function(e, osrandom_init) ||            !ENGINE_set_finish_function(e, osrandom_finish) ||            !ENGINE_set_cmd_defns(e, osrandom_cmd_defns) ||            !ENGINE_set_ctrl_function(e, osrandom_ctrl)) {        ENGINE_free(e);        return 0;    }    if (!ENGINE_add(e)) {        ENGINE_free(e);        return 0;    }    if (!ENGINE_free(e)) {        return 0;    }    return 1;}

static int bind_HCSP(ENGINE* e){   if (!ENGINE_set_id(e, engine_HCSP_id)    || !ENGINE_set_name(e, engine_HCSP_name)    || !ENGINE_set_RSA(e, &HCSP_rsa)    || !ENGINE_set_destroy_function(e, HCSP_destroy)    || !ENGINE_set_init_function(e, HCSP_init)    || !ENGINE_set_finish_function(e, HCSP_finish)    || !ENGINE_set_load_pubkey_function(e, HCSP_load_key)    || !ENGINE_set_load_privkey_function(e, HCSP_load_key)#ifdef FILE_CONFIG    || !ENGINE_set_ctrl_function(e, HCSP_ctrl)    || !ENGINE_set_cmd_defns(e, HCSP_cmd_defns)#endif   ) return 0;   /* Ensure the rsaref error handling is set up */#ifndef OPENSSL_NO_ERR   ERR_load_HCSP_strings();#endif   return 1;}

//.........这里部分代码省略.........    WARN("QAT Warnings enabled./n");    DEBUG("QAT Debug enabled./n");    DEBUG("id=%s/n", id);    if (access(QAT_DEV, F_OK) != 0) {        WARN("Qat memory driver not present/n");        QATerr(QAT_F_BIND_QAT, QAT_R_MEM_DRV_NOT_PRESENT);        goto end;    }#ifndef OPENSSL_ENABLE_QAT_UPSTREAM_DRIVER    if (!getDevices(devmasks, &upstream_flags)) {        WARN("Qat device not present/n");        QATerr(QAT_F_BIND_QAT, QAT_R_QAT_DEV_NOT_PRESENT);        goto end;    }#endif    if (id && (strcmp(id, engine_qat_id) != 0)) {        WARN("ENGINE_id defined already!/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_ID_ALREADY_DEFINED);        goto end;    }    if (!ENGINE_set_id(e, engine_qat_id)) {        WARN("ENGINE_set_id failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_ID_FAILURE);        goto end;    }    if (!ENGINE_set_name(e, engine_qat_name)) {        WARN("ENGINE_set_name failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_NAME_FAILURE);        goto end;    }    /* Ensure the QAT error handling is set up */    ERR_load_QAT_strings();    /*     * Create static structures for ciphers now     * as this function will be called by a single thread.     */    qat_create_ciphers();    if (!ENGINE_set_RSA(e, qat_get_RSA_methods())) {        WARN("ENGINE_set_RSA failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_RSA_FAILURE);        goto end;    }    if (!ENGINE_set_DSA(e, qat_get_DSA_methods())) {        WARN("ENGINE_set_DSA failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_DSA_FAILURE);        goto end;    }    if (!ENGINE_set_DH(e, qat_get_DH_methods())) {        WARN("ENGINE_set_DH failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_DH_FAILURE);        goto end;    }    if (!ENGINE_set_EC(e, qat_get_EC_methods())) {        WARN("ENGINE_set_EC failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_EC_FAILURE);        goto end;    }    if (!ENGINE_set_ciphers(e, qat_ciphers)) {        WARN("ENGINE_set_ciphers failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_CIPHER_FAILURE);        goto end;    }    if (!ENGINE_set_pkey_meths(e, qat_PRF_pkey_methods)) {        WARN("ENGINE_set_pkey_meths failed/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_SET_PKEY_FAILURE);        goto end;    }    pthread_atfork(engine_finish_before_fork_handler, NULL,                   engine_init_child_at_fork_handler);    ret = 1;    ret &= ENGINE_set_destroy_function(e, qat_engine_destroy);    ret &= ENGINE_set_init_function(e, qat_engine_init);    ret &= ENGINE_set_finish_function(e, qat_engine_finish);    ret &= ENGINE_set_ctrl_function(e, qat_engine_ctrl);    ret &= ENGINE_set_cmd_defns(e, qat_cmd_defns);    if (ret == 0) {        WARN("Engine failed to register init, finish or destroy functions/n");        QATerr(QAT_F_BIND_QAT, QAT_R_ENGINE_REGISTER_FUNC_FAILURE);    } end:    return ret;}

/* * This internal function is used by ENGINE_nuron() and possibly by the * "dynamic" ENGINE support too */static int bind_helper(ENGINE *e){#  ifndef OPENSSL_NO_RSA    const RSA_METHOD *meth1;#  endif#  ifndef OPENSSL_NO_DSA    const DSA_METHOD *meth2;#  endif#  ifndef OPENSSL_NO_DH    const DH_METHOD *meth3;#  endif    if (!ENGINE_set_id(e, engine_nuron_id) ||        !ENGINE_set_name(e, engine_nuron_name) ||#  ifndef OPENSSL_NO_RSA        !ENGINE_set_RSA(e, &nuron_rsa) ||#  endif#  ifndef OPENSSL_NO_DSA        !ENGINE_set_DSA(e, &nuron_dsa) ||#  endif#  ifndef OPENSSL_NO_DH        !ENGINE_set_DH(e, &nuron_dh) ||#  endif        !ENGINE_set_destroy_function(e, nuron_destroy) ||        !ENGINE_set_init_function(e, nuron_init) ||        !ENGINE_set_finish_function(e, nuron_finish) ||        !ENGINE_set_ctrl_function(e, nuron_ctrl) ||        !ENGINE_set_cmd_defns(e, nuron_cmd_defns))        return 0;#  ifndef OPENSSL_NO_RSA    /*     * We know that the "PKCS1_SSLeay()" functions hook properly to the     * nuron-specific mod_exp and mod_exp_crt so we use those functions. NB:     * We don't use ENGINE_openssl() or anything "more generic" because     * something like the RSAref code may not hook properly, and if you own     * one of these cards then you have the right to do RSA operations on it     * anyway!     */    meth1 = RSA_PKCS1_SSLeay();    nuron_rsa.rsa_pub_enc = meth1->rsa_pub_enc;    nuron_rsa.rsa_pub_dec = meth1->rsa_pub_dec;    nuron_rsa.rsa_priv_enc = meth1->rsa_priv_enc;    nuron_rsa.rsa_priv_dec = meth1->rsa_priv_dec;#  endif#  ifndef OPENSSL_NO_DSA    /*     * Use the DSA_OpenSSL() method and just hook the mod_exp-ish bits.     */    meth2 = DSA_OpenSSL();    nuron_dsa.dsa_do_sign = meth2->dsa_do_sign;    nuron_dsa.dsa_sign_setup = meth2->dsa_sign_setup;    nuron_dsa.dsa_do_verify = meth2->dsa_do_verify;#  endif#  ifndef OPENSSL_NO_DH    /* Much the same for Diffie-Hellman */    meth3 = DH_OpenSSL();    nuron_dh.generate_key = meth3->generate_key;    nuron_dh.compute_key = meth3->compute_key;#  endif    /* Ensure the nuron error handling is set up */    ERR_load_NURON_strings();    return 1;}

/* This internal function is used by ENGINE_aep() and possibly by the * "dynamic" ENGINE support too */static int bind_aep(ENGINE *e)	{#ifndef OPENSSL_NO_RSA	const RSA_METHOD  *meth1;#endif#ifndef OPENSSL_NO_DSA	const DSA_METHOD  *meth2;#endif#ifndef OPENSSL_NO_DH	const DH_METHOD	  *meth3;#endif	if(!ENGINE_set_id(e, engine_aep_id) ||		!ENGINE_set_name(e, engine_aep_name) ||#ifndef OPENSSL_NO_RSA		!ENGINE_set_RSA(e, &aep_rsa) ||#endif#ifndef OPENSSL_NO_DSA		!ENGINE_set_DSA(e, &aep_dsa) ||#endif#ifndef OPENSSL_NO_DH		!ENGINE_set_DH(e, &aep_dh) ||#endif#ifdef AEPRAND		!ENGINE_set_RAND(e, &aep_random) ||#endif		!ENGINE_set_init_function(e, aep_init) ||		!ENGINE_set_destroy_function(e, aep_destroy) ||		!ENGINE_set_finish_function(e, aep_finish) ||		!ENGINE_set_ctrl_function(e, aep_ctrl) ||		!ENGINE_set_cmd_defns(e, aep_cmd_defns))		return 0;#ifndef OPENSSL_NO_RSA	/* We know that the "PKCS1_SSLeay()" functions hook properly	 * to the aep-specific mod_exp and mod_exp_crt so we use	 * those functions. NB: We don't use ENGINE_openssl() or	 * anything "more generic" because something like the RSAref	 * code may not hook properly, and if you own one of these	 * cards then you have the right to do RSA operations on it	 * anyway! */	meth1 = RSA_PKCS1_SSLeay();	aep_rsa.rsa_pub_enc = meth1->rsa_pub_enc;	aep_rsa.rsa_pub_dec = meth1->rsa_pub_dec;	aep_rsa.rsa_priv_enc = meth1->rsa_priv_enc;	aep_rsa.rsa_priv_dec = meth1->rsa_priv_dec;#endif#ifndef OPENSSL_NO_DSA	/* Use the DSA_OpenSSL() method and just hook the mod_exp-ish	 * bits. */	meth2 = DSA_OpenSSL();	aep_dsa.dsa_do_sign    = meth2->dsa_do_sign;	aep_dsa.dsa_sign_setup = meth2->dsa_sign_setup;	aep_dsa.dsa_do_verify  = meth2->dsa_do_verify;	aep_dsa = *DSA_get_default_method(); 	aep_dsa.dsa_mod_exp = aep_dsa_mod_exp; 	aep_dsa.bn_mod_exp = aep_mod_exp_dsa;#endif#ifndef OPENSSL_NO_DH	/* Much the same for Diffie-Hellman */	meth3 = DH_OpenSSL();	aep_dh.generate_key = meth3->generate_key;	aep_dh.compute_key  = meth3->compute_key;	aep_dh.bn_mod_exp   = meth3->bn_mod_exp;#endif	/* Ensure the aep error handling is set up */	ERR_load_AEPHK_strings();	return 1;}

voidENGINE_load_cryptodev(void){	ENGINE *engine = ENGINE_new();	int fd;	if (engine == NULL)		return;	if ((fd = get_dev_crypto()) < 0) {		ENGINE_free(engine);		return;	}	/*	 * find out what asymmetric crypto algorithms we support	 */	if (ioctl(fd, CIOCASYMFEAT, &cryptodev_asymfeat) == -1) {		close(fd);		ENGINE_free(engine);		return;	}	close(fd);	if (!ENGINE_set_id(engine, "cryptodev") ||	    !ENGINE_set_name(engine, "BSD cryptodev engine") ||	    !ENGINE_set_ciphers(engine, cryptodev_engine_ciphers) ||	    !ENGINE_set_digests(engine, cryptodev_engine_digests) ||	    !ENGINE_set_ctrl_function(engine, cryptodev_ctrl) ||	    !ENGINE_set_cmd_defns(engine, cryptodev_defns)) {		ENGINE_free(engine);		return;	}	if (ENGINE_set_RSA(engine, &cryptodev_rsa)) {		const RSA_METHOD *rsa_meth = RSA_PKCS1_SSLeay();		cryptodev_rsa.bn_mod_exp = rsa_meth->bn_mod_exp;		cryptodev_rsa.rsa_mod_exp = rsa_meth->rsa_mod_exp;		cryptodev_rsa.rsa_pub_enc = rsa_meth->rsa_pub_enc;		cryptodev_rsa.rsa_pub_dec = rsa_meth->rsa_pub_dec;		cryptodev_rsa.rsa_priv_enc = rsa_meth->rsa_priv_enc;		cryptodev_rsa.rsa_priv_dec = rsa_meth->rsa_priv_dec;		if (cryptodev_asymfeat & CRF_MOD_EXP) {			cryptodev_rsa.bn_mod_exp = cryptodev_bn_mod_exp;			if (cryptodev_asymfeat & CRF_MOD_EXP_CRT)				cryptodev_rsa.rsa_mod_exp =				    cryptodev_rsa_mod_exp;			else				cryptodev_rsa.rsa_mod_exp =				    cryptodev_rsa_nocrt_mod_exp;		}	}	if (ENGINE_set_DSA(engine, &cryptodev_dsa)) {		const DSA_METHOD *meth = DSA_OpenSSL();		memcpy(&cryptodev_dsa, meth, sizeof(DSA_METHOD));		if (cryptodev_asymfeat & CRF_DSA_SIGN)			cryptodev_dsa.dsa_do_sign = cryptodev_dsa_do_sign;		if (cryptodev_asymfeat & CRF_MOD_EXP) {			cryptodev_dsa.bn_mod_exp = cryptodev_dsa_bn_mod_exp;			cryptodev_dsa.dsa_mod_exp = cryptodev_dsa_dsa_mod_exp;		}		if (cryptodev_asymfeat & CRF_DSA_VERIFY)			cryptodev_dsa.dsa_do_verify = cryptodev_dsa_verify;	}	if (ENGINE_set_DH(engine, &cryptodev_dh)){		const DH_METHOD *dh_meth = DH_OpenSSL();		cryptodev_dh.generate_key = dh_meth->generate_key;		cryptodev_dh.compute_key = dh_meth->compute_key;		cryptodev_dh.bn_mod_exp = dh_meth->bn_mod_exp;		if (cryptodev_asymfeat & CRF_MOD_EXP) {			cryptodev_dh.bn_mod_exp = cryptodev_mod_exp_dh;			if (cryptodev_asymfeat & CRF_DH_COMPUTE_KEY)				cryptodev_dh.compute_key =				    cryptodev_dh_compute_key;		}	}	ENGINE_add(engine);	ENGINE_free(engine);	ERR_clear_error();}

/******************************************************************************* function:*         bind_qat(ENGINE *e,*                  const char *id)** @param e  [IN] - OpenSSL engine pointer* @param id [IN] - engine id** description:*    Connect Qat engine to OpenSSL engine library******************************************************************************/static int bind_qat(ENGINE *e, const char *id){    int ret = 0;    WARN("QAT Warnings enabled./n");    DEBUG("QAT Debug enabled./n");    DEBUG("[%s] id=%s/n", __func__, id);    if (id && (strcmp(id, engine_qat_id) != 0)) {        WARN("ENGINE_id defined already!/n");        goto end;    }    if (!ENGINE_set_id(e, engine_qat_id)) {        WARN("ENGINE_set_id failed/n");        goto end;    }    if (!ENGINE_set_name(e, engine_qat_name)) {        WARN("ENGINE_set_name failed/n");        goto end;    }    /* Ensure the QAT error handling is set up */    ERR_load_QAT_strings();    /*     * Create static structures for ciphers now     * as this function will be called by a single thread.     */    qat_create_ciphers();#ifndef OPENSSL_ENABLE_QAT_SMALL_PACKET_CIPHER_OFFLOADS    CRYPTO_THREAD_run_once(&qat_pkt_threshold_table_once,qat_pkt_threshold_table_make_key);#endif    DEBUG("%s: About to set mem functions/n", __func__);    if (!ENGINE_set_RSA(e, qat_get_RSA_methods())) {        WARN("ENGINE_set_RSA failed/n");        goto end;    }    if (!ENGINE_set_DSA(e, qat_get_DSA_methods())) {        WARN("ENGINE_set_DSA failed/n");        goto end;    }    if (!ENGINE_set_DH(e, qat_get_DH_methods())) {        WARN("ENGINE_set_DH failed/n");        goto end;    }    if (!ENGINE_set_EC(e, qat_get_EC_methods())) {        WARN("ENGINE_set_EC failed/n");        goto end;    }    if (!ENGINE_set_ciphers(e, qat_ciphers)) {        WARN("ENGINE_set_ciphers failed/n");        goto end;    }    if (!ENGINE_set_pkey_meths(e, qat_PRF_pkey_methods)) {        WARN("ENGINE_set_pkey_meths failed/n");        goto end;    }    pthread_atfork(engine_fork_handler, NULL, NULL);    if (!ENGINE_set_destroy_function(e, qat_engine_destroy)        || !ENGINE_set_init_function(e, qat_engine_init)        || !ENGINE_set_finish_function(e, qat_engine_finish)        || !ENGINE_set_ctrl_function(e, qat_engine_ctrl)        || !ENGINE_set_cmd_defns(e, qat_cmd_defns)) {        WARN("[%s] failed reg destroy, init or finish/n", __func__);        goto end;    }    ret = 1; end:    return ret;}

/* This internal function is used by ENGINE_zencod () and possibly by the * "dynamic" ENGINE support too   ;-) */static int bind_helper ( ENGINE *e ){#ifndef OPENSSL_NO_RSA	const RSA_METHOD *meth_rsa ;#endif#ifndef OPENSSL_NO_DSA	const DSA_METHOD *meth_dsa ;#endif#ifndef OPENSSL_NO_DH	const DH_METHOD *meth_dh ;#endif	const RAND_METHOD *meth_rand ;	if ( !ENGINE_set_id ( e, engine_zencod_id ) ||			!ENGINE_set_name ( e, engine_zencod_name ) ||#ifndef OPENSSL_NO_RSA			!ENGINE_set_RSA ( e, &zencod_rsa ) ||#endif#ifndef OPENSSL_NO_DSA			!ENGINE_set_DSA ( e, &zencod_dsa ) ||#endif#ifndef OPENSSL_NO_DH			!ENGINE_set_DH ( e, &zencod_dh ) ||#endif			!ENGINE_set_RAND ( e, &zencod_rand ) ||			!ENGINE_set_destroy_function ( e, zencod_destroy ) ||			!ENGINE_set_init_function ( e, zencod_init ) ||			!ENGINE_set_finish_function ( e, zencod_finish ) ||			!ENGINE_set_ctrl_function ( e, zencod_ctrl ) ||			!ENGINE_set_cmd_defns ( e, zencod_cmd_defns ) ||			!ENGINE_set_digests ( e, engine_digests ) ||			!ENGINE_set_ciphers ( e, engine_ciphers ) ) {		return 0 ;	}#ifndef OPENSSL_NO_RSA	/* We know that the "PKCS1_SSLeay()" functions hook properly	 * to the Zencod-specific mod_exp and mod_exp_crt so we use	 * those functions. NB: We don't use ENGINE_openssl() or	 * anything "more generic" because something like the RSAref	 * code may not hook properly, and if you own one of these	 * cards then you have the right to do RSA operations on it	 * anyway!	 */	meth_rsa = RSA_PKCS1_SSLeay () ;	zencod_rsa.rsa_pub_enc = meth_rsa->rsa_pub_enc ;	zencod_rsa.rsa_pub_dec = meth_rsa->rsa_pub_dec ;	zencod_rsa.rsa_priv_enc = meth_rsa->rsa_priv_enc ;	zencod_rsa.rsa_priv_dec = meth_rsa->rsa_priv_dec ;	/* meth_rsa->rsa_mod_exp */	/* meth_rsa->bn_mod_exp */	zencod_rsa.init = meth_rsa->init ;	zencod_rsa.finish = meth_rsa->finish ;#endif#ifndef OPENSSL_NO_DSA	/* We use OpenSSL meth to supply what we don't provide ;-*)	 */	meth_dsa = DSA_OpenSSL () ;	/* meth_dsa->dsa_do_sign */	zencod_dsa.dsa_sign_setup = meth_dsa->dsa_sign_setup ;	/* meth_dsa->dsa_do_verify */	zencod_dsa.dsa_mod_exp = meth_dsa->dsa_mod_exp ;	/* zencod_dsa.bn_mod_exp = meth_dsa->bn_mod_exp ; */	zencod_dsa.init = meth_dsa->init ;	zencod_dsa.finish = meth_dsa->finish ;#endif#ifndef OPENSSL_NO_DH	/* We use OpenSSL meth to supply what we don't provide ;-*)	 */	meth_dh = DH_OpenSSL () ;	/* zencod_dh.generate_key = meth_dh->generate_key ; */	/* zencod_dh.compute_key = meth_dh->compute_key ; */	/* zencod_dh.bn_mod_exp = meth_dh->bn_mod_exp ; */	zencod_dh.init = meth_dh->init ;	zencod_dh.finish = meth_dh->finish ;#endif	/* We use OpenSSL (SSLeay) meth to supply what we don't provide ;-*)	 */	meth_rand = RAND_SSLeay () ;	/* meth_rand->seed ; */	/* zencod_rand.seed = meth_rand->seed ; */	/* meth_rand->bytes ; */	/* zencod_rand.bytes = meth_rand->bytes ; */	zencod_rand.cleanup = meth_rand->cleanup ;	zencod_rand.add = meth_rand->add ;//.........这里部分代码省略.........

static int bind_gost (ENGINE * e, const char *id){    int ret = 0;    if (id && strcmp (id, engine_gost_id))        return 0;    if (ameth_GostR3410_94)    {        printf ("GOST engine already loaded/n");        goto end;    }    if (!ENGINE_set_id (e, engine_gost_id))    {        printf ("ENGINE_set_id failed/n");        goto end;    }    if (!ENGINE_set_name (e, engine_gost_name))    {        printf ("ENGINE_set_name failed/n");        goto end;    }    if (!ENGINE_set_digests (e, gost_digests))    {        printf ("ENGINE_set_digests failed/n");        goto end;    }    if (!ENGINE_set_ciphers (e, gost_ciphers))    {        printf ("ENGINE_set_ciphers failed/n");        goto end;    }    if (!ENGINE_set_pkey_meths (e, gost_pkey_meths))    {        printf ("ENGINE_set_pkey_meths failed/n");        goto end;    }    if (!ENGINE_set_pkey_asn1_meths (e, gost_pkey_asn1_meths))    {        printf ("ENGINE_set_pkey_asn1_meths failed/n");        goto end;    }    /* Control function and commands */    if (!ENGINE_set_cmd_defns (e, gost_cmds))    {        fprintf (stderr, "ENGINE_set_cmd_defns failed/n");        goto end;    }    if (!ENGINE_set_ctrl_function (e, gost_control_func))    {        fprintf (stderr, "ENGINE_set_ctrl_func failed/n");        goto end;    }    if (!ENGINE_set_destroy_function (e, gost_engine_destroy)            || !ENGINE_set_init_function (e, gost_engine_init) || !ENGINE_set_finish_function (e, gost_engine_finish))    {        goto end;    }    if (!register_ameth_gost (NID_id_GostR3410_94, &ameth_GostR3410_94, "GOST94", "GOST R 34.10-94"))        goto end;    if (!register_ameth_gost (NID_id_GostR3410_2001, &ameth_GostR3410_2001, "GOST2001", "GOST R 34.10-2001"))        goto end;    if (!register_ameth_gost (NID_id_Gost28147_89_MAC, &ameth_Gost28147_MAC, "GOST-MAC", "GOST 28147-89 MAC"))        goto end;    if (!register_pmeth_gost (NID_id_GostR3410_94, &pmeth_GostR3410_94, 0))        goto end;    if (!register_pmeth_gost (NID_id_GostR3410_2001, &pmeth_GostR3410_2001, 0))        goto end;    if (!register_pmeth_gost (NID_id_Gost28147_89_MAC, &pmeth_Gost28147_MAC, 0))        goto end;    if (!ENGINE_register_ciphers (e) || !ENGINE_register_digests (e) || !ENGINE_register_pkey_meths (e)            /* These two actually should go in LIST_ADD command */            || !EVP_add_cipher (&cipher_gost)            || !EVP_add_cipher (&cipher_gost_cpacnt) || !EVP_add_digest (&digest_gost) || !EVP_add_digest (&imit_gost_cpa))    {        goto end;    }    ERR_load_GOST_strings ();    ret = 1;end:    return ret;}