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

static int ibmca_finish(ENGINE *e)        {        if(ibmca_dso == NULL)                {                IBMCAerr(IBMCA_F_IBMCA_FINISH,IBMCA_R_NOT_LOADED);                return 0;                }        release_context(handle);        if(!DSO_free(ibmca_dso))                {                IBMCAerr(IBMCA_F_IBMCA_FINISH,IBMCA_R_DSO_FAILURE);                return 0;                }        ibmca_dso = NULL;        return 1;        }

static int ubsec_finish(ENGINE *e)	{	free_UBSEC_LIBNAME();	if(ubsec_dso == NULL)		{		UBSECerr(UBSEC_F_UBSEC_FINISH, UBSEC_R_NOT_LOADED);		return 0;		}	if(!DSO_free(ubsec_dso))		{		UBSECerr(UBSEC_F_UBSEC_FINISH, UBSEC_R_DSO_FAILURE);		return 0;		}	ubsec_dso = NULL;	p_UBSEC_ubsec_bytes_to_bits = NULL;	p_UBSEC_ubsec_bits_to_bytes = NULL;	p_UBSEC_ubsec_open = NULL;	p_UBSEC_ubsec_close = NULL;#ifndef OPENSSL_NO_DH	p_UBSEC_diffie_hellman_generate_ioctl = NULL;	p_UBSEC_diffie_hellman_agree_ioctl = NULL;#endif#ifndef OPENSSL_NO_RSA	p_UBSEC_rsa_mod_exp_ioctl = NULL;	p_UBSEC_rsa_mod_exp_crt_ioctl = NULL;#endif#ifndef OPENSSL_NO_DSA	p_UBSEC_dsa_sign_ioctl = NULL;	p_UBSEC_dsa_verify_ioctl = NULL;#endif	p_UBSEC_math_accelerate_ioctl = NULL;	p_UBSEC_rng_ioctl = NULL;        p_UBSEC_max_key_len_ioctl = NULL;	return 1;	}

static int surewarehk_finish(ENGINE *e){    int to_return = 1;    if(surewarehk_dso == NULL)    {        SUREWAREerr(SUREWARE_F_SUREWAREHK_FINISH,ENGINE_R_NOT_LOADED);        to_return = 0;        goto err;    }    p_surewarehk_Finish();    if(!DSO_free(surewarehk_dso))    {        SUREWAREerr(SUREWARE_F_SUREWAREHK_FINISH,ENGINE_R_DSO_FAILURE);        to_return = 0;        goto err;    }err:    if (logstream)        BIO_free(logstream);    surewarehk_dso = NULL;    p_surewarehk_Init = NULL;    p_surewarehk_Finish = NULL;    p_surewarehk_Rand_Bytes = NULL;    p_surewarehk_Rand_Seed = NULL;    p_surewarehk_Load_Privkey = NULL;    p_surewarehk_Load_Rsa_Pubkey = NULL;    p_surewarehk_Free = NULL;    p_surewarehk_Rsa_Priv_Dec = NULL;    p_surewarehk_Rsa_Sign = NULL;    p_surewarehk_Dsa_Sign = NULL;    p_surewarehk_Info_Pubkey = NULL;    p_surewarehk_Load_Dsa_Pubkey = NULL;    p_surewarehk_Mod_Exp = NULL;    return to_return;}

DSO *DSO_load(DSO *dso, const char *filename, DSO_METHOD *meth, int flags)	{	DSO *ret;	int allocated = 0;	if(dso == NULL)		{		ret = DSO_new_method(meth);		if(ret == NULL)			{			DSOerr(DSO_F_DSO_LOAD,ERR_R_MALLOC_FAILURE);			goto err;			}		allocated = 1;		/* Pass the provided flags to the new DSO object */		if(DSO_ctrl(ret, DSO_CTRL_SET_FLAGS, flags, NULL) < 0)			{			DSOerr(DSO_F_DSO_LOAD,DSO_R_CTRL_FAILED);			goto err;			}		}	else		ret = dso;	/* Don't load if we're currently already loaded */	if(ret->filename != NULL)		{		DSOerr(DSO_F_DSO_LOAD,DSO_R_DSO_ALREADY_LOADED);		goto err;		}	/* filename can only be NULL if we were passed a dso that already has	 * one set. */	if(filename != NULL)		if(!DSO_set_filename(ret, filename))			{			DSOerr(DSO_F_DSO_LOAD,DSO_R_SET_FILENAME_FAILED);			goto err;			}	filename = ret->filename;	if(filename == NULL)		{		DSOerr(DSO_F_DSO_LOAD,DSO_R_NO_FILENAME);		goto err;		}	if(ret->meth->dso_load == NULL)		{		DSOerr(DSO_F_DSO_LOAD,DSO_R_UNSUPPORTED);		goto err;		}	if(!ret->meth->dso_load(ret))		{		DSOerr(DSO_F_DSO_LOAD,DSO_R_LOAD_FAILED);		goto err;		}	/* Load succeeded */	return(ret);err:	if(allocated)		DSO_free(ret);	return(NULL);	}

void COMP_zlib_cleanup (void){#ifdef ZLIB_SHARED    if (zlib_dso)        DSO_free (zlib_dso);#endif}

static int ibm_4758_cca_finish(ENGINE *e)	{	free_CCA4758_LIB_NAME();	if(!dso)		{		CCA4758err(CCA4758_F_IBM_4758_CCA_FINISH,				CCA4758_R_NOT_LOADED);		return 0;		}	if(!DSO_free(dso))		{		CCA4758err(CCA4758_F_IBM_4758_CCA_FINISH,				CCA4758_R_UNIT_FAILURE);		return 0;		}	dso = NULL;#ifndef OPENSSL_NO_RSA	keyRecordRead = (F_KEYRECORDREAD)0;	randomNumberGenerate = (F_RANDOMNUMBERGENERATE)0;	digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)0;	digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)0;	publicKeyExtract = (F_PUBLICKEYEXTRACT)0;	pkaEncrypt = (F_PKAENCRYPT)0;	pkaDecrypt = (F_PKADECRYPT)0;#endif	randomNumberGenerate = (F_RANDOMNUMBERGENERATE)0;	return 1;	}

static int cluster_labs_finish(ENGINE *e){    if (cluster_labs_dso == NULL) {        CLerr(CL_F_CLUSTER_LABS_FINISH, CL_R_NOT_LOADED);        return 0;    }    if (!DSO_free(cluster_labs_dso)) {        CLerr(CL_F_CLUSTER_LABS_FINISH, CL_R_DSO_FAILURE);        return 0;    }    cluster_labs_dso = NULL;    p_cl_engine_init = NULL;    p_cl_mod_exp = NULL;    p_cl_rsa_mod_exp = NULL;    p_cl_mod_exp_crt = NULL;    p_cl_rsa_priv_enc = NULL;    p_cl_rsa_priv_dec = NULL;    p_cl_rsa_pub_enc = NULL;    p_cl_rsa_pub_dec = NULL;    p_cl_rand_bytes = NULL;    p_cl_dsa_sign = NULL;    p_cl_dsa_verify = NULL;    return (1);}

static int hwcrhk_finish(ENGINE *e)	{	int to_return = 1;	free_HWCRHK_LIBNAME();	if(hwcrhk_dso == NULL)		{		HWCRHKerr(HWCRHK_F_HWCRHK_FINISH,HWCRHK_R_NOT_LOADED);		to_return = 0;		goto err;		}	release_context(hwcrhk_context);	if(!DSO_free(hwcrhk_dso))		{		HWCRHKerr(HWCRHK_F_HWCRHK_FINISH,HWCRHK_R_DSO_FAILURE);		to_return = 0;		goto err;		} err:	if (logstream)		BIO_free(logstream);	hwcrhk_dso = NULL;	p_hwcrhk_Init = NULL;	p_hwcrhk_Finish = NULL;	p_hwcrhk_ModExp = NULL;#ifndef OPENSSL_NO_RSA	p_hwcrhk_RSA = NULL;	p_hwcrhk_RSALoadKey = NULL;	p_hwcrhk_RSAGetPublicKey = NULL;	p_hwcrhk_RSAUnloadKey = NULL;#endif	p_hwcrhk_ModExpCRT = NULL;	p_hwcrhk_RandomBytes = NULL;	return to_return;	}

/* (de)initialisation functions. */static int cswift_init(ENGINE *e)	{        SW_CONTEXT_HANDLE hac;        t_swAcquireAccContext *p1;        t_swAttachKeyParam *p2;        t_swSimpleRequest *p3;        t_swReleaseAccContext *p4;	if(cswift_dso != NULL)		{		CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_ALREADY_LOADED);		goto err;		}	/* Attempt to load libswift.so/swift.dll/whatever. */	cswift_dso = DSO_load(NULL, get_CSWIFT_LIBNAME(), NULL, 0);	if(cswift_dso == NULL)		{		CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_NOT_LOADED);		goto err;		}	if(!(p1 = (t_swAcquireAccContext *)				DSO_bind_func(cswift_dso, CSWIFT_F1)) ||			!(p2 = (t_swAttachKeyParam *)				DSO_bind_func(cswift_dso, CSWIFT_F2)) ||			!(p3 = (t_swSimpleRequest *)				DSO_bind_func(cswift_dso, CSWIFT_F3)) ||			!(p4 = (t_swReleaseAccContext *)				DSO_bind_func(cswift_dso, CSWIFT_F4)))		{		CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_NOT_LOADED);		goto err;		}	/* Copy the pointers */	p_CSwift_AcquireAccContext = p1;	p_CSwift_AttachKeyParam = p2;	p_CSwift_SimpleRequest = p3;	p_CSwift_ReleaseAccContext = p4;	/* Try and get a context - if not, we may have a DSO but no	 * accelerator! */	if(!get_context(&hac))		{		CSWIFTerr(CSWIFT_F_CSWIFT_INIT,CSWIFT_R_UNIT_FAILURE);		goto err;		}	release_context(hac);	/* Everything's fine. */	return 1;err:	if(cswift_dso)	{		DSO_free(cswift_dso);		cswift_dso = NULL;	}	p_CSwift_AcquireAccContext = NULL;	p_CSwift_AttachKeyParam = NULL;	p_CSwift_SimpleRequest = NULL;	p_CSwift_ReleaseAccContext = NULL;	return 0;	}

/* (de)initialisation functions. */static int atalla_init(ENGINE *e)	{	tfnASI_GetHardwareConfig *p1;	tfnASI_RSAPrivateKeyOpFn *p2;	tfnASI_GetPerformanceStatistics *p3;	/* Not sure of the origin of this magic value, but Ben's code had it	 * and it seemed to have been working for a few people. :-) */	unsigned int config_buf[1024];	if(atalla_dso != NULL)		{		ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_ALREADY_LOADED);		goto err;		}	/* Attempt to load libatasi.so/atasi.dll/whatever. Needs to be	 * changed unfortunately because the Atalla drivers don't have	 * standard library names that can be platform-translated well. */	/* TODO: Work out how to actually map to the names the Atalla	 * drivers really use - for now a symbollic link needs to be	 * created on the host system from libatasi.so to atasi.so on	 * unix variants. */	atalla_dso = DSO_load(NULL, get_ATALLA_LIBNAME(), NULL, 0);	if(atalla_dso == NULL)		{		ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_NOT_LOADED);		goto err;		}	if(!(p1 = (tfnASI_GetHardwareConfig *)DSO_bind_func(				atalla_dso, ATALLA_F1)) ||			!(p2 = (tfnASI_RSAPrivateKeyOpFn *)DSO_bind_func(				atalla_dso, ATALLA_F2)) ||			!(p3 = (tfnASI_GetPerformanceStatistics *)DSO_bind_func(				atalla_dso, ATALLA_F3)))		{		ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_NOT_LOADED);		goto err;		}	/* Copy the pointers */	p_Atalla_GetHardwareConfig = p1;	p_Atalla_RSAPrivateKeyOpFn = p2;	p_Atalla_GetPerformanceStatistics = p3;	/* Perform a basic test to see if there's actually any unit	 * running. */	if(p1(0L, config_buf) != 0)		{		ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_UNIT_FAILURE);		goto err;		}	/* Everything's fine. */	return 1;err:	if(atalla_dso)		DSO_free(atalla_dso);	atalla_dso = NULL;	p_Atalla_GetHardwareConfig = NULL;	p_Atalla_RSAPrivateKeyOpFn = NULL;	p_Atalla_GetPerformanceStatistics = NULL;	return 0;	}

void comp_zlib_cleanup_int(void){#ifdef ZLIB_SHARED    if (zlib_dso != NULL)        DSO_free(zlib_dso);    zlib_dso = NULL;#endif}

int OPENSSL_atexit(void (*handler)(void)){    OPENSSL_INIT_STOP *newhand;#if !defined(OPENSSL_NO_DSO) && !defined(OPENSSL_USE_NODELETE)    {        union {            void *sym;            void (*func)(void);        } handlersym;        handlersym.func = handler;# ifdef DSO_WIN32        {            HMODULE handle = NULL;            BOOL ret;            /*             * We don't use the DSO route for WIN32 because there is a better             * way             */            ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS                                    | GET_MODULE_HANDLE_EX_FLAG_PIN,                                    handlersym.sym, &handle);            if (!ret)                return 0;        }# else        /*         * Deliberately leak a reference to the handler. This will force the         * library/code containing the handler to remain loaded until we run the         * atexit handler. If -znodelete has been used then this is         * unnecessary.         */        {            DSO *dso = NULL;            ERR_set_mark();            dso = DSO_dsobyaddr(handlersym.sym, DSO_FLAG_NO_UNLOAD_ON_FREE);            DSO_free(dso);            ERR_pop_to_mark();        }# endif    }#endif    newhand = OPENSSL_malloc(sizeof(*newhand));    if (newhand == NULL)        return 0;    newhand->handler = handler;    newhand->next = stop_handlers;    stop_handlers = newhand;    return 1;}

static int aep_finish(ENGINE *e)	{	int to_return = 0, in_use;	AEP_RV rv;	if(aep_dso == NULL)		{		AEPHKerr(AEPHK_F_AEP_FINISH,AEPHK_R_NOT_LOADED);		goto err;		}	rv = aep_close_all_connections(0, &in_use);	if (rv != AEP_R_OK)		{		AEPHKerr(AEPHK_F_AEP_FINISH,AEPHK_R_CLOSE_HANDLES_FAILED);		goto err;		}	if (in_use)		{		AEPHKerr(AEPHK_F_AEP_FINISH,AEPHK_R_CONNECTIONS_IN_USE);		goto err;		}	rv = p_AEP_Finalize();	if (rv != AEP_R_OK)		{		AEPHKerr(AEPHK_F_AEP_FINISH,AEPHK_R_FINALIZE_FAILED);		goto err;		}	if(!DSO_free(aep_dso))		{		AEPHKerr(AEPHK_F_AEP_FINISH,AEPHK_R_UNIT_FAILURE);		goto err;		}	aep_dso = NULL;	p_AEP_CloseConnection   = NULL;	p_AEP_OpenConnection    = NULL;	p_AEP_ModExp            = NULL;	p_AEP_ModExpCrt         = NULL;#ifdef AEPRAND	p_AEP_GenRandom         = NULL;#endif	p_AEP_Initialize        = NULL;	p_AEP_Finalize          = NULL;	p_AEP_SetBNCallBacks    = NULL;	to_return = 1; err:	return to_return;	}

/* * Because our ex_data element may or may not get allocated depending on * whether a "first-use" occurs before the ENGINE is freed, we have a memory * leak problem to solve. We can't declare a "new" handler for the ex_data as * we don't want a dynamic_data_ctx in *all* ENGINE structures of all types * (this is a bug in the design of CRYPTO_EX_DATA). As such, we just declare * a "free" handler and that will get called if an ENGINE is being destroyed * and there was an ex_data element corresponding to our context type. */static void dynamic_data_ctx_free_func(void *parent, void *ptr,                                       CRYPTO_EX_DATA *ad, int idx, long argl,                                       void *argp){    if (ptr) {        dynamic_data_ctx *ctx = (dynamic_data_ctx *)ptr;        DSO_free(ctx->dynamic_dso);        OPENSSL_free(ctx->DYNAMIC_LIBNAME);        OPENSSL_free(ctx->engine_id);        sk_OPENSSL_STRING_pop_free(ctx->dirs, int_free_str);        OPENSSL_free(ctx);    }}

static int nuron_finish(ENGINE *e){    free_NURON_LIBNAME();    if (pvDSOHandle == NULL) {        NURONerr(NURON_F_NURON_FINISH, NURON_R_NOT_LOADED);        return 0;    }    if (!DSO_free(pvDSOHandle)) {        NURONerr(NURON_F_NURON_FINISH, NURON_R_DSO_FAILURE);        return 0;    }    pvDSOHandle = NULL;    pfnModExp = NULL;    return 1;}

static int atalla_finish(ENGINE *e){    free_ATALLA_LIBNAME();    if (atalla_dso == NULL) {        ATALLAerr(ATALLA_F_ATALLA_FINISH, ATALLA_R_NOT_LOADED);        return 0;    }    if (!DSO_free(atalla_dso)) {        ATALLAerr(ATALLA_F_ATALLA_FINISH, ATALLA_R_UNIT_FAILURE);        return 0;    }    atalla_dso = NULL;    p_Atalla_GetHardwareConfig = NULL;    p_Atalla_RSAPrivateKeyOpFn = NULL;    p_Atalla_GetPerformanceStatistics = NULL;    return 1;}

static int cswift_finish(ENGINE *e){    free_CSWIFT_LIBNAME();    if (cswift_dso == NULL) {        CSWIFTerr(CSWIFT_F_CSWIFT_FINISH, CSWIFT_R_NOT_LOADED);        return 0;    }    if (!DSO_free(cswift_dso)) {        CSWIFTerr(CSWIFT_F_CSWIFT_FINISH, CSWIFT_R_UNIT_FAILURE);        return 0;    }    cswift_dso = NULL;    p_CSwift_AcquireAccContext = NULL;    p_CSwift_AttachKeyParam = NULL;    p_CSwift_SimpleRequest = NULL;    p_CSwift_ReleaseAccContext = NULL;    return 1;}

static int hwskf_init(ENGINE *e){    if (hwskf_dso != NULL) {        //HWCRHKerr(HWCRHK_F_HWCRHK_INIT, HWCRHK_R_ALREADY_LOADED);        goto err;    }    /* Attempt to load ShuttleCsp11_3000GM.dll/whatever. */    hwskf_dso = DSO_load(NULL, get_HWSKF_LIBNAME(), NULL, 0);    if (hwskf_dso == NULL) {        //HWCRHKerr(HWCRHK_F_HWCRHK_INIT, HWCRHK_R_DSO_FAILURE);        goto err;    } err:    if (hwskf_dso)        DSO_free(hwskf_dso);    hwskf_dso = NULL;    return 0;}

static int zencod_finish ( ENGINE *e ){	CHEESE () ;	/*	 * We Should add some tests for non NULL parameters or bad value !!	 * Stuff to be done ...	 */	if ( zencod_dso == NULL ) {		ZENCODerr ( ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_NOT_LOADED ) ;		return 0 ;	}	if ( !DSO_free ( zencod_dso ) ) {		ZENCODerr ( ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_DSO_FAILURE ) ;		return 0 ;	}	zencod_dso = NULL ;	ptr_zencod_bytes2bits = NULL ;	ptr_zencod_bits2bytes = NULL ;	ptr_zencod_new_number = NULL ;	ptr_zencod_init_number = NULL ;	ptr_zencod_rsa_mod_exp = NULL ;	ptr_zencod_rsa_mod_exp_crt = NULL ;	ptr_zencod_dsa_do_sign = NULL ;	ptr_zencod_dsa_do_verify = NULL ;	ptr_zencod_dh_generate_key = NULL ;	ptr_zencod_dh_compute_key = NULL ;	ptr_zencod_rand_bytes = NULL ;	ptr_zencod_math_mod_exp = NULL ;	ptr_zencod_test = NULL ;	ptr_zencod_md5_init = NULL ;	ptr_zencod_md5_update = NULL ;	ptr_zencod_md5_do_final = NULL ;	ptr_zencod_sha1_init = NULL ;	ptr_zencod_sha1_update = NULL ;	ptr_zencod_sha1_do_final = NULL ;	ptr_zencod_xdes_cipher = NULL ;	ptr_zencod_rc4_cipher = NULL ;	return 1 ;}

static DSO *DSO_new_method(DSO_METHOD *meth){    DSO *ret;    if (default_DSO_meth == NULL) {        /*         * We default to DSO_METH_openssl() which in turn defaults to         * stealing the "best available" method. Will fallback to         * DSO_METH_null() in the worst case.         */        default_DSO_meth = DSO_METHOD_openssl();    }    ret = OPENSSL_zalloc(sizeof(*ret));    if (ret == NULL) {        DSOerr(DSO_F_DSO_NEW_METHOD, ERR_R_MALLOC_FAILURE);        return (NULL);    }    ret->meth_data = sk_void_new_null();    if (ret->meth_data == NULL) {        /* sk_new doesn't generate any errors so we do */        DSOerr(DSO_F_DSO_NEW_METHOD, ERR_R_MALLOC_FAILURE);        OPENSSL_free(ret);        return (NULL);    }    ret->meth = default_DSO_meth;    ret->references = 1;    ret->lock = CRYPTO_THREAD_lock_new();    if (ret->lock == NULL) {        DSOerr(DSO_F_DSO_NEW_METHOD, ERR_R_MALLOC_FAILURE);        sk_void_free(ret->meth_data);        OPENSSL_free(ret);        return NULL;    }    if ((ret->meth->init != NULL) && !ret->meth->init(ret)) {        DSO_free(ret);        ret = NULL;    }    return ret;}

DSO *DSO_new_method(DSO_METHOD *meth){    DSO *ret;    if (default_DSO_meth == NULL)        /* We default to DSO_METH_openssl() which in turn defaults         * to stealing the "best available" method. Will fallback         * to DSO_METH_null() in the worst case. */        default_DSO_meth = DSO_METHOD_openssl();    ret = calloc(1, sizeof(DSO));    if (ret == NULL) {        DSOerr(DSO_F_DSO_NEW_METHOD, ERR_R_MALLOC_FAILURE);        return NULL;    }    ret->meth_data = sk_void_new_null();    if (ret->meth_data == NULL) {        /* sk_new doesn't generate any errors so we do */        DSOerr(DSO_F_DSO_NEW_METHOD, ERR_R_MALLOC_FAILURE);        free(ret);        return NULL;    }    if (meth == NULL)        ret->meth = default_DSO_meth;    else        ret->meth = meth;    ret->references = 1;    ret->lock = CRYPTO_thread_new();    if (ret->lock == NULL) {        sk_void_free(ret->meth_data);        free(ret);        return NULL;    }    if ((ret->meth->init != NULL) && !ret->meth->init(ret)) {        DSO_free(ret);        ret = NULL;    }    return ret;}

static int hwskf_finish(ENGINE *e){    int to_return = 1;    free_HWSKF_LIBNAME();    if (hwskf_dso == NULL) {        //HWCRHKerr(HWCRHK_F_HWCRHK_FINISH, HWCRHK_R_NOT_LOADED);        to_return = 0;        goto err;    }    if (!DSO_free(hwskf_dso)) {        //HWCRHKerr(HWCRHK_F_HWCRHK_FINISH, HWCRHK_R_DSO_FAILURE);        to_return = 0;        goto err;    } err:    if (logstream)        BIO_free(logstream);    hwskf_dso = NULL;        return to_return;}

static int tpm_engine_finish(ENGINE * e){	DBG("%s", __FUNCTION__);#ifdef DLOPEN_TSPI	if (tpm_dso == NULL) {		TSSerr(TPM_F_TPM_ENGINE_FINISH, TPM_R_NOT_LOADED);		return 0;	}#endif	if (hContext != NULL_HCONTEXT) {		Tspi_Context_Close(hContext);		hContext = NULL_HCONTEXT;	}#ifdef DLOPEN_TSPI	if (!DSO_free(tpm_dso)) {		TSSerr(TPM_F_TPM_ENGINE_FINISH, TPM_R_DSO_FAILURE);		return 0;	}	tpm_dso = NULL;#endif	return 1;}

void ossl_provider_free(OSSL_PROVIDER *prov){    if (prov != NULL) {        int ref = 0;        CRYPTO_DOWN_REF(&prov->refcnt, &ref, prov->refcnt_lock);        /*         * When the refcount drops below two, the store is the only         * possible reference, or it has already been taken away from         * the store (this may happen if a provider was activated         * because it's a fallback, but isn't currently used)         * When that happens, the provider is inactivated.         */        if (ref < 2 && prov->flag_initialized) {            if (prov->teardown != NULL)                prov->teardown();            prov->flag_initialized = 0;        }        /*         * When the refcount drops to zero, it has been taken out of         * the store.  All we have to do here is clean it out.         */        if (ref == 0) {            DSO_free(prov->module);            OPENSSL_free(prov->name);            OPENSSL_free(prov->path);            sk_INFOPAIR_pop_free(prov->parameters, free_infopair);#ifndef HAVE_ATOMICS            CRYPTO_THREAD_lock_free(prov->refcnt_lock);#endif            OPENSSL_free(prov);        }    }}

//.........这里部分代码省略.........		{		UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_ALREADY_LOADED);		goto err;		}	/* 	 * Attempt to load libubsec.so/ubsec.dll/whatever. 	 */	ubsec_dso = DSO_load(NULL, get_UBSEC_LIBNAME(), NULL, 0);	if(ubsec_dso == NULL)		{		UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE);		goto err;		}	if (	!(p1 = (t_UBSEC_ubsec_bytes_to_bits *) DSO_bind_func(ubsec_dso, UBSEC_F1)) ||	!(p2 = (t_UBSEC_ubsec_bits_to_bytes *) DSO_bind_func(ubsec_dso, UBSEC_F2)) ||	!(p3 = (t_UBSEC_ubsec_open *) DSO_bind_func(ubsec_dso, UBSEC_F3)) ||	!(p4 = (t_UBSEC_ubsec_close *) DSO_bind_func(ubsec_dso, UBSEC_F4)) ||#ifndef OPENSSL_NO_DH	!(p5 = (t_UBSEC_diffie_hellman_generate_ioctl *) 				DSO_bind_func(ubsec_dso, UBSEC_F5)) ||	!(p6 = (t_UBSEC_diffie_hellman_agree_ioctl *) 				DSO_bind_func(ubsec_dso, UBSEC_F6)) ||#endif/* #ifndef OPENSSL_NO_RSA */	!(p7 = (t_UBSEC_rsa_mod_exp_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F7)) ||	!(p8 = (t_UBSEC_rsa_mod_exp_crt_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F8)) ||/* #endif */#ifndef OPENSSL_NO_DSA	!(p9 = (t_UBSEC_dsa_sign_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F9)) ||	!(p10 = (t_UBSEC_dsa_verify_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F10)) ||#endif	!(p11 = (t_UBSEC_math_accelerate_ioctl *) 				DSO_bind_func(ubsec_dso, UBSEC_F11)) ||	!(p12 = (t_UBSEC_rng_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F12)) ||        !(p13 = (t_UBSEC_max_key_len_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F13)))		{		UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE);		goto err;		}	/* Copy the pointers */	p_UBSEC_ubsec_bytes_to_bits = p1;	p_UBSEC_ubsec_bits_to_bytes = p2;	p_UBSEC_ubsec_open = p3;	p_UBSEC_ubsec_close = p4;#ifndef OPENSSL_NO_DH	p_UBSEC_diffie_hellman_generate_ioctl = p5;	p_UBSEC_diffie_hellman_agree_ioctl = p6;#endif#ifndef OPENSSL_NO_RSA	p_UBSEC_rsa_mod_exp_ioctl = p7;	p_UBSEC_rsa_mod_exp_crt_ioctl = p8;#endif#ifndef OPENSSL_NO_DSA	p_UBSEC_dsa_sign_ioctl = p9;	p_UBSEC_dsa_verify_ioctl = p10;#endif	p_UBSEC_math_accelerate_ioctl = p11;	p_UBSEC_rng_ioctl = p12;        p_UBSEC_max_key_len_ioctl = p13;	/* Perform an open to see if there's actually any unit running. */	if (((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) > 0) && (p_UBSEC_max_key_len_ioctl(fd, &max_key_len) == 0))	{	   p_UBSEC_ubsec_close(fd);	   return 1;	}	else	{	  UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_UNIT_FAILURE);	}err:	if(ubsec_dso)		DSO_free(ubsec_dso);	ubsec_dso = NULL;	p_UBSEC_ubsec_bytes_to_bits = NULL;	p_UBSEC_ubsec_bits_to_bytes = NULL;	p_UBSEC_ubsec_open = NULL;	p_UBSEC_ubsec_close = NULL;#ifndef OPENSSL_NO_DH	p_UBSEC_diffie_hellman_generate_ioctl = NULL;	p_UBSEC_diffie_hellman_agree_ioctl = NULL;#endif#ifndef OPENSSL_NO_RSA	p_UBSEC_rsa_mod_exp_ioctl = NULL;	p_UBSEC_rsa_mod_exp_crt_ioctl = NULL;#endif#ifndef OPENSSL_NO_DSA	p_UBSEC_dsa_sign_ioctl = NULL;	p_UBSEC_dsa_verify_ioctl = NULL;#endif	p_UBSEC_math_accelerate_ioctl = NULL;	p_UBSEC_rng_ioctl = NULL;        p_UBSEC_max_key_len_ioctl = NULL;	return 0;	}

int cluster_labs_init(ENGINE *e){    cl_engine_init *p1;    cl_mod_exp *p2;    cl_mod_exp_crt *p3;    cl_rsa_mod_exp *p4;    cl_rsa_priv_enc *p5;    cl_rsa_priv_dec *p6;    cl_rsa_pub_enc *p7;    cl_rsa_pub_dec *p8;    cl_rand_bytes *p20;    cl_dsa_sign *p30;    cl_dsa_verify *p31;    /* engine already loaded */    if (cluster_labs_dso != NULL) {        CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_ALREADY_LOADED);        goto err;    }    /* try to load engine    */    cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL, 0);    if (cluster_labs_dso == NULL) {        CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_DSO_FAILURE);        goto err;    }    /* bind functions */#define BINDIT(t, name) (t *)DSO_bind_func(cluster_labs_dso, name)    if ((p1 = (cl_engine_init, CLUSTER_LABS_F1)) == NULL        || (p2 = BINDIT(cl_mod_exp, CLUSTER_LABS_F2)) == NULL        || (p3 = BINDIT(cl_mod_exp_crt, CLUSTER_LABS_F3)) == NULL        || (p4 = BINDIT(cl_rsa_mod_exp, CLUSTER_LABS_F4)) == NULL        || (p5 = BINDIT(cl_rsa_priv_enc, CLUSTER_LABS_F5)) == NULL        || (p6 = BINDIT(cl_rsa_priv_dec, CLUSTER_LABS_F6)) == NULL        || (p7 = BINDIT(cl_rsa_pub_enc, CLUSTER_LABS_F7)) == NULL        || (p8 = BINDIT(cl_rsa_pub_dec, CLUSTER_LABS_F8)) == NULL        || (p20 = BINDIT(cl_rand_bytes, CLUSTER_LABS_F20)) == NULL        || (p30 = BINDIT(cl_dsa_sign, CLUSTER_LABS_F30)) == NULL        || (p31 = BINDIT(cl_dsa_verify, CLUSTER_LABS_F31)) == NULL) {        CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_DSO_FAILURE);        goto err;    }    /* copy function pointers */    p_cl_engine_init = p1;    p_cl_mod_exp = p2;    p_cl_mod_exp_crt = p3;    p_cl_rsa_mod_exp = p4;    p_cl_rsa_priv_enc = p5;    p_cl_rsa_priv_dec = p6;    p_cl_rsa_pub_enc = p7;    p_cl_rsa_pub_dec = p8;    p_cl_rand_bytes = p20;    p_cl_dsa_sign = p30;    p_cl_dsa_verify = p31;    /* cluster labs engine init */    if (p_cl_engine_init() == 0) {        CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_INIT_FAILED);        goto err;    }    return (1); err:    /* reset all pointers */    DSO_free(cluster_labs_dso);    cluster_labs_dso = NULL;    p_cl_engine_init = NULL;    p_cl_mod_exp = NULL;    p_cl_mod_exp_crt = NULL;    p_cl_rsa_mod_exp = NULL;    p_cl_rsa_priv_enc = NULL;    p_cl_rsa_priv_dec = NULL;    p_cl_rsa_pub_enc = NULL;    p_cl_rsa_pub_dec = NULL;    p_cl_rand_bytes = NULL;    p_cl_dsa_sign = NULL;    p_cl_dsa_verify = NULL;    return (0);}

static int dynamic_load(ENGINE *e, dynamic_data_ctx *ctx){    ENGINE cpy;    dynamic_fns fns;    if (ctx->dynamic_dso == NULL)        ctx->dynamic_dso = DSO_new();    if (ctx->dynamic_dso == NULL)        return 0;    if (!ctx->DYNAMIC_LIBNAME) {        if (!ctx->engine_id)            return 0;        ctx->DYNAMIC_LIBNAME =            DSO_convert_filename(ctx->dynamic_dso, ctx->engine_id);    }    if (!int_load(ctx)) {        ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_DSO_NOT_FOUND);        DSO_free(ctx->dynamic_dso);        ctx->dynamic_dso = NULL;        return 0;    }    /* We have to find a bind function otherwise it'll always end badly */    if (!        (ctx->bind_engine =         (dynamic_bind_engine) DSO_bind_func(ctx->dynamic_dso,                                             ctx->DYNAMIC_F2))) {        ctx->bind_engine = NULL;        DSO_free(ctx->dynamic_dso);        ctx->dynamic_dso = NULL;        ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_DSO_FAILURE);        return 0;    }    /* Do we perform version checking? */    if (!ctx->no_vcheck) {        unsigned long vcheck_res = 0;        /*         * Now we try to find a version checking function and decide how to         * cope with failure if/when it fails.         */        ctx->v_check =            (dynamic_v_check_fn) DSO_bind_func(ctx->dynamic_dso,                                               ctx->DYNAMIC_F1);        if (ctx->v_check)            vcheck_res = ctx->v_check(OSSL_DYNAMIC_VERSION);        /*         * We fail if the version checker veto'd the load *or* if it is         * deferring to us (by returning its version) and we think it is too         * old.         */        if (vcheck_res < OSSL_DYNAMIC_OLDEST) {            /* Fail */            ctx->bind_engine = NULL;            ctx->v_check = NULL;            DSO_free(ctx->dynamic_dso);            ctx->dynamic_dso = NULL;            ENGINEerr(ENGINE_F_DYNAMIC_LOAD,                      ENGINE_R_VERSION_INCOMPATIBILITY);            return 0;        }    }    /*     * First binary copy the ENGINE structure so that we can roll back if the     * hand-over fails     */    memcpy(&cpy, e, sizeof(ENGINE));    /*     * Provide the ERR, "ex_data", memory, and locking callbacks so the     * loaded library uses our state rather than its own. FIXME: As noted in     * engine.h, much of this would be simplified if each area of code     * provided its own "summary" structure of all related callbacks. It     * would also increase opaqueness.     */    fns.static_state = ENGINE_get_static_state();    fns.lock_fns.lock_locking_cb = CRYPTO_get_locking_callback();    fns.lock_fns.lock_add_lock_cb = CRYPTO_get_add_lock_callback();    fns.lock_fns.dynlock_create_cb = CRYPTO_get_dynlock_create_callback();    fns.lock_fns.dynlock_lock_cb = CRYPTO_get_dynlock_lock_callback();    fns.lock_fns.dynlock_destroy_cb = CRYPTO_get_dynlock_destroy_callback();    /*     * Now that we've loaded the dynamic engine, make sure no "dynamic"     * ENGINE elements will show through.     */    engine_set_all_null(e);    /* Try to bind the ENGINE onto our own ENGINE structure */    if (!ctx->bind_engine(e, ctx->engine_id, &fns)) {        ctx->bind_engine = NULL;        ctx->v_check = NULL;        DSO_free(ctx->dynamic_dso);        ctx->dynamic_dso = NULL;        ENGINEerr(ENGINE_F_DYNAMIC_LOAD, ENGINE_R_INIT_FAILED);        /* Copy the original ENGINE structure back */        memcpy(e, &cpy, sizeof(ENGINE));        return 0;    }    /* Do we try to add this ENGINE to the internal list too? */    if (ctx->list_add_value > 0) {        if (!ENGINE_add(e)) {            /* Do we tolerate this or fail? */            if (ctx->list_add_value > 1) {//.........这里部分代码省略.........

/* (de)initialisation functions. */static int hwcrhk_init(ENGINE *e)	{	HWCryptoHook_Init_t *p1;	HWCryptoHook_Finish_t *p2;	HWCryptoHook_ModExp_t *p3;#ifndef OPENSSL_NO_RSA	HWCryptoHook_RSA_t *p4;	HWCryptoHook_RSALoadKey_t *p5;	HWCryptoHook_RSAGetPublicKey_t *p6;	HWCryptoHook_RSAUnloadKey_t *p7;#endif	HWCryptoHook_RandomBytes_t *p8;	HWCryptoHook_ModExpCRT_t *p9;	if(hwcrhk_dso != NULL)		{		HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_ALREADY_LOADED);		goto err;		}	/* Attempt to load libnfhwcrhk.so/nfhwcrhk.dll/whatever. */	hwcrhk_dso = DSO_load(NULL, get_HWCRHK_LIBNAME(), NULL, 0);	if(hwcrhk_dso == NULL)		{		HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_DSO_FAILURE);		goto err;		}	if(!(p1 = (HWCryptoHook_Init_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_Init)) ||		!(p2 = (HWCryptoHook_Finish_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_Finish)) ||		!(p3 = (HWCryptoHook_ModExp_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_ModExp)) ||#ifndef OPENSSL_NO_RSA		!(p4 = (HWCryptoHook_RSA_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSA)) ||		!(p5 = (HWCryptoHook_RSALoadKey_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSALoadKey)) ||		!(p6 = (HWCryptoHook_RSAGetPublicKey_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSAGetPublicKey)) ||		!(p7 = (HWCryptoHook_RSAUnloadKey_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSAUnloadKey)) ||#endif		!(p8 = (HWCryptoHook_RandomBytes_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_RandomBytes)) ||		!(p9 = (HWCryptoHook_ModExpCRT_t *)			DSO_bind_func(hwcrhk_dso, n_hwcrhk_ModExpCRT)))		{		HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_DSO_FAILURE);		goto err;		}	/* Copy the pointers */	p_hwcrhk_Init = p1;	p_hwcrhk_Finish = p2;	p_hwcrhk_ModExp = p3;#ifndef OPENSSL_NO_RSA	p_hwcrhk_RSA = p4;	p_hwcrhk_RSALoadKey = p5;	p_hwcrhk_RSAGetPublicKey = p6;	p_hwcrhk_RSAUnloadKey = p7;#endif	p_hwcrhk_RandomBytes = p8;	p_hwcrhk_ModExpCRT = p9;	/* Check if the application decided to support dynamic locks,	   and if it does, use them. */	if (disable_mutex_callbacks == 0)		{		if (CRYPTO_get_dynlock_create_callback() != NULL &&			CRYPTO_get_dynlock_lock_callback() != NULL &&			CRYPTO_get_dynlock_destroy_callback() != NULL)			{			hwcrhk_globals.mutex_init = hwcrhk_mutex_init;			hwcrhk_globals.mutex_acquire = hwcrhk_mutex_lock;			hwcrhk_globals.mutex_release = hwcrhk_mutex_unlock;			hwcrhk_globals.mutex_destroy = hwcrhk_mutex_destroy;			}		}	/* Try and get a context - if not, we may have a DSO but no	 * accelerator! */	if(!get_context(&hwcrhk_context, &password_context))		{		HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_UNIT_FAILURE);		goto err;		}	/* Everything's fine. */#ifndef OPENSSL_NO_RSA	if (hndidx_rsa == -1)		hndidx_rsa = RSA_get_ex_new_index(0,			"nFast HWCryptoHook RSA key handle",			NULL, NULL, NULL);#endif	return 1;err:	if(hwcrhk_dso)		DSO_free(hwcrhk_dso);	hwcrhk_dso = NULL;	p_hwcrhk_Init = NULL;	p_hwcrhk_Finish = NULL;//.........这里部分代码省略.........

/* (de)initialisation functions. */static int surewarehk_init(ENGINE *e){    char msg[64]="ENGINE_init";    SureWareHook_Init_t *p1=NULL;    SureWareHook_Finish_t *p2=NULL;    SureWareHook_Rand_Bytes_t *p3=NULL;    SureWareHook_Rand_Seed_t *p4=NULL;    SureWareHook_Load_Privkey_t *p5=NULL;    SureWareHook_Load_Rsa_Pubkey_t *p6=NULL;    SureWareHook_Free_t *p7=NULL;    SureWareHook_Rsa_Priv_Dec_t *p8=NULL;    SureWareHook_Rsa_Sign_t *p9=NULL;    SureWareHook_Dsa_Sign_t *p12=NULL;    SureWareHook_Info_Pubkey_t *p13=NULL;    SureWareHook_Load_Dsa_Pubkey_t *p14=NULL;    SureWareHook_Mod_Exp_t *p15=NULL;    if(surewarehk_dso != NULL)    {        SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,ENGINE_R_ALREADY_LOADED);        goto err;    }    /* Attempt to load libsurewarehk.so/surewarehk.dll/whatever. */    surewarehk_dso = DSO_load(NULL, surewarehk_LIBNAME, NULL, 0);    if(surewarehk_dso == NULL)    {        SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,ENGINE_R_DSO_FAILURE);        goto err;    }    if(!(p1=(SureWareHook_Init_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Init)) ||            !(p2=(SureWareHook_Finish_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Finish)) ||            !(p3=(SureWareHook_Rand_Bytes_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rand_Bytes)) ||            !(p4=(SureWareHook_Rand_Seed_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rand_Seed)) ||            !(p5=(SureWareHook_Load_Privkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Load_Privkey)) ||            !(p6=(SureWareHook_Load_Rsa_Pubkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Load_Rsa_Pubkey)) ||            !(p7=(SureWareHook_Free_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Free)) ||            !(p8=(SureWareHook_Rsa_Priv_Dec_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rsa_Priv_Dec)) ||            !(p9=(SureWareHook_Rsa_Sign_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Rsa_Sign)) ||            !(p12=(SureWareHook_Dsa_Sign_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Dsa_Sign)) ||            !(p13=(SureWareHook_Info_Pubkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Info_Pubkey)) ||            !(p14=(SureWareHook_Load_Dsa_Pubkey_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Load_Dsa_Pubkey)) ||            !(p15=(SureWareHook_Mod_Exp_t*)DSO_bind_func(surewarehk_dso, n_surewarehk_Mod_Exp)))    {        SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,ENGINE_R_DSO_FAILURE);        goto err;    }    /* Copy the pointers */    p_surewarehk_Init = p1;    p_surewarehk_Finish = p2;    p_surewarehk_Rand_Bytes = p3;    p_surewarehk_Rand_Seed = p4;    p_surewarehk_Load_Privkey = p5;    p_surewarehk_Load_Rsa_Pubkey = p6;    p_surewarehk_Free = p7;    p_surewarehk_Rsa_Priv_Dec = p8;    p_surewarehk_Rsa_Sign = p9;    p_surewarehk_Dsa_Sign = p12;    p_surewarehk_Info_Pubkey = p13;    p_surewarehk_Load_Dsa_Pubkey = p14;    p_surewarehk_Mod_Exp = p15;    /* Contact the hardware and initialises it. */    if(p_surewarehk_Init(msg,threadsafe)==SUREWAREHOOK_ERROR_UNIT_FAILURE)    {        SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,SUREWARE_R_UNIT_FAILURE);        goto err;    }    if(p_surewarehk_Init(msg,threadsafe)==SUREWAREHOOK_ERROR_UNIT_FAILURE)    {        SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT,SUREWARE_R_UNIT_FAILURE);        goto err;    }    /* try to load the default private key, if failed does not return a failure but           wait for an explicit ENGINE_load_privakey */    surewarehk_load_privkey(e,NULL,NULL,NULL);    /* Everything's fine. */#ifndef OPENSSL_NO_RSA    if (rsaHndidx == -1)        rsaHndidx = RSA_get_ex_new_index(0,                                         (void*)"SureWareHook RSA key handle",                                         NULL, NULL, surewarehk_ex_free);#endif#ifndef OPENSSL_NO_DSA    if (dsaHndidx == -1)        dsaHndidx = DSA_get_ex_new_index(0,                                         (void*)"SureWareHook DSA key handle",                                         NULL, NULL, surewarehk_ex_free);#endif    return 1;err:    if(surewarehk_dso)        DSO_free(surewarehk_dso);    surewarehk_dso = NULL;    p_surewarehk_Init = NULL;    p_surewarehk_Finish = NULL;    p_surewarehk_Rand_Bytes = NULL;    p_surewarehk_Rand_Seed = NULL;    p_surewarehk_Load_Privkey = NULL;//.........这里部分代码省略.........

static int ibm_4758_cca_init(ENGINE *e){    if (dso) {        CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_ALREADY_LOADED);        goto err;    }    dso = DSO_load(NULL, get_CCA4758_LIB_NAME(), NULL, 0);    if (!dso) {        CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_DSO_FAILURE);        goto err;    }#  ifndef OPENSSL_NO_RSA    if (!(keyRecordRead = (F_KEYRECORDREAD)          DSO_bind_func(dso, n_keyRecordRead)) ||        !(randomNumberGenerate = (F_RANDOMNUMBERGENERATE)          DSO_bind_func(dso, n_randomNumberGenerate)) ||        !(digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)          DSO_bind_func(dso, n_digitalSignatureGenerate)) ||        !(digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)          DSO_bind_func(dso, n_digitalSignatureVerify)) ||        !(publicKeyExtract = (F_PUBLICKEYEXTRACT)          DSO_bind_func(dso, n_publicKeyExtract)) ||        !(pkaEncrypt = (F_PKAENCRYPT)          DSO_bind_func(dso, n_pkaEncrypt)) || !(pkaDecrypt = (F_PKADECRYPT)                                                 DSO_bind_func(dso,                                                               n_pkaDecrypt)))    {        CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_DSO_FAILURE);        goto err;    }#  else    if (!(randomNumberGenerate = (F_RANDOMNUMBERGENERATE)          DSO_bind_func(dso, n_randomNumberGenerate))) {        CCA4758err(CCA4758_F_IBM_4758_CCA_INIT, CCA4758_R_DSO_FAILURE);        goto err;    }#  endif#  ifndef OPENSSL_NO_RSA    hndidx = RSA_get_ex_new_index(0, "IBM 4758 CCA RSA key handle",                                  NULL, NULL, cca_ex_free);#  endif    return 1; err:    if (dso)        DSO_free(dso);    dso = NULL;#  ifndef OPENSSL_NO_RSA    keyRecordRead = (F_KEYRECORDREAD) 0;    digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE) 0;    digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)0;    publicKeyExtract = (F_PUBLICKEYEXTRACT)0;    pkaEncrypt = (F_PKAENCRYPT) 0;    pkaDecrypt = (F_PKADECRYPT) 0;#  endif    randomNumberGenerate = (F_RANDOMNUMBERGENERATE) 0;    return 0;}