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

int main(int argc, char *argv[])	{			/* enable memory leak checking unless explicitly disabled */	if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))		{		CRYPTO_malloc_debug_init();		CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);		}	else		{		/* OPENSSL_DEBUG_MEMORY=off */		CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);		}	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	ERR_load_crypto_strings();	RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_generate_prime may fail */	prime_field_tests();	puts("");	char2_field_tests();	/* test the internal curves */	internal_curve_test();#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CRYPTO_cleanup_all_ex_data();	ERR_free_strings();	ERR_remove_state(0);	CRYPTO_mem_leaks_fp(stderr);		return 0;	}

int main(int argc, char *argv[]) {    int err;    struct shouter app;    libre_init();    err = tcsound_alloc(&app.sound, asend, &app);    if(err != 0)        goto fail;    err = rtp_io_alloc(&app.rtp, FMT_SPEEX);    if(err != 0)        goto close_sound;    tcsound_start(app.sound);    re_main(signal_handler);close_sound:    mem_deref(app.sound);fail:    tmr_debug();    mem_debug();    ENGINE_cleanup();fail_sound:    libre_close();}

void cleanup(struct soap* soap) {  /* release our connection and context */  xmpp_conn_release(conn);  xmpp_ctx_free(ctx);    /* final shutdown of the library */  xmpp_shutdown();  if (rsa_private_key) {    EVP_PKEY_free(rsa_private_key);  }  if (cert) {    X509_free(cert);  }  if (soap) {    soap_end(soap);    soap_done(soap);    soap_free(soap);  }    ERR_remove_state(0);  ENGINE_cleanup();  CONF_modules_unload(1);  ERR_free_strings();  EVP_cleanup();  CRYPTO_cleanup_all_ex_data();}

int main(int argc, char **argv)	{	BIO *bio_err;	X509_REQ *req=NULL;	EVP_PKEY *pkey=NULL;	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);	mkreq(&req,&pkey,512,0,365);	RSA_print_fp(stdout,pkey->pkey.rsa,0);	X509_REQ_print_fp(stdout,req);	PEM_write_X509_REQ(stdout,req);	X509_REQ_free(req);	EVP_PKEY_free(pkey);#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CRYPTO_cleanup_all_ex_data();	CRYPTO_mem_leaks(bio_err);	BIO_free(bio_err);	return(0);	}

voidcrypto_uninit_lib (void){#ifndef ENABLE_SSL  /* If SSL is enabled cleanup is taken care of in ssl_openssl.c */  EVP_cleanup ();#ifndef ENABLE_SMALL  ERR_free_strings ();#endif#endif#ifdef CRYPTO_MDEBUG  FILE* fp = fopen ("sdlog", "w");  ASSERT (fp);  CRYPTO_mem_leaks_fp (fp);  fclose (fp);#endif#if HAVE_OPENSSL_ENGINE  if (engine_initialized)    {      ENGINE_cleanup ();      engine_persist = NULL;      engine_initialized = false;    }#endif}

//----------------------------------------------------------------//void moaicore::SystemFinalize () {	MOAIGlobalsMgr::Finalize ();		#if USE_CURL		curl_global_cleanup ();	#endif		#if USE_OPENSSL		#ifndef OPENSSL_NO_ENGINE			ENGINE_cleanup ();		#endif				CONF_modules_unload ( 1 );				#ifndef OPENSSL_NO_ERR			ERR_free_strings ();		#endif				EVP_cleanup ();		CRYPTO_cleanup_all_ex_data ();	#endif		zl_cleanup ();}

/** * xmlSecOpenSSLAppShutdown: * * General crypto engine shutdown. This function is used * by XMLSec command line utility and called after * @xmlSecShutdown function. * * Returns: 0 on success or a negative value otherwise. */intxmlSecOpenSSLAppShutdown(void) {    xmlSecOpenSSLAppSaveRANDFile(NULL);    RAND_cleanup();    EVP_cleanup();#ifndef XMLSEC_NO_X509    X509_TRUST_cleanup();#endif /* XMLSEC_NO_X509 */    ENGINE_cleanup();    CONF_modules_unload(1);    CRYPTO_cleanup_all_ex_data();    /* finally cleanup errors */#if defined(XMLSEC_OPENSSL_110)    ERR_remove_thread_state();#elif defined(XMLSEC_OPENSSL_100)    ERR_remove_thread_state(NULL);#else    ERR_remove_state(0);#endif /* defined(XMLSEC_OPENSSL_100) || defined(XMLSEC_OPENSSL_110) */    ERR_free_strings();    /* done */    return(0);}

voidas_tls_cleanup(void){	// Skip if we were never initialized.	if (! s_tls_inited) {		return;	}#if !defined USE_XDR	// Cleanup global OpenSSL state, must be after all other OpenSSL	// API calls, of course ...#if OPENSSL_VERSION_NUMBER < 0x10100000L	threading_cleanup();#endif	// https://wiki.openssl.org/index.php/Library_Initialization#Cleanup	//	FIPS_mode_set(0);	ENGINE_cleanup();	CONF_modules_unload(1);	EVP_cleanup();	as_tls_thread_cleanup();	CRYPTO_cleanup_all_ex_data();	ERR_free_strings();	// http://stackoverflow.com/questions/29845527/how-to-properly-uninitialize-openssl	STACK_OF(SSL_COMP) *ssl_comp_methods = SSL_COMP_get_compression_methods();	if (ssl_comp_methods != NULL) {        sk_SSL_COMP_free(ssl_comp_methods);	}#endif}

/* *  the various processing hooks */static apr_status_t ssl_cleanup_pre_config(void *data){    /*     * Try to kill the internals of the SSL library.     */    /* Corresponds to OPENSSL_load_builtin_modules():     * XXX: borrowed from apps.h, but why not CONF_modules_free()     * which also invokes CONF_modules_finish()?     */    CONF_modules_unload(1);    /* Corresponds to SSL_library_init: */    EVP_cleanup();#if HAVE_ENGINE_LOAD_BUILTIN_ENGINES    ENGINE_cleanup();#endif    ERR_remove_state(0);    /* Don't call ERR_free_strings here; ERR_load_*_strings only     * actually load the error strings once per process due to static     * variable abuse in OpenSSL. */    /* Also don't call CRYPTO_cleanup_all_ex_data here; any registered     * ex_data indices may have been cached in static variables in     * OpenSSL; removing them may cause havoc.  Notably, with OpenSSL     * versions >= 0.9.8f, COMP_CTX cleanups would not be run, which     * could result in a per-connection memory leak (!). */    /*     * TODO: determine somewhere we can safely shove out diagnostics     *       (when enabled) at this late stage in the game:     * CRYPTO_mem_leaks_fp(stderr);     */    return APR_SUCCESS;}

/* Global cleanup */void Curl_SSL_cleanup(void){#ifdef USE_SSLEAY  if(init_ssl) {    /* only cleanup if we did a previous init */    /* Free the SSL error strings */    ERR_free_strings();    /* EVP_cleanup() removes all ciphers and digests from the       table. */    EVP_cleanup();#ifdef HAVE_ENGINE_cleanup    ENGINE_cleanup();#endif#ifdef HAVE_CRYPTO_CLEANUP_ALL_EX_DATA    /* this function was not present in 0.9.6b, but was added sometimes       later */    CRYPTO_cleanup_all_ex_data();#endif    init_ssl=0; /* not inited any more */  }#else  /* SSL disabled, do nothing */#endif}

int main(int argc, char **argv){    int i;    testdata *test = test_cases;    CRYPTO_malloc_debug_init();    CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    OpenSSL_add_all_digests();# ifndef OPENSSL_NO_ENGINE    ENGINE_load_builtin_engines();    ENGINE_register_all_digests();# endif    printf("PKCS5_PBKDF2_HMAC() tests ");    for (i = 0; test->pass != NULL; i++, test++) {        test_p5_pbkdf2(i, "sha1", test, sha1_results[i]);        test_p5_pbkdf2(i, "sha256", test, sha256_results[i]);        test_p5_pbkdf2(i, "sha512", test, sha512_results[i]);        printf(".");    }    printf(" done/n");# ifndef OPENSSL_NO_ENGINE    ENGINE_cleanup();# endif    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    ERR_free_strings();    CRYPTO_mem_leaks_fp(stderr);    return 0;}

static void openssl_cleanup(void){	ENGINE_cleanup();	ERR_free_strings();	CRYPTO_cleanup_all_ex_data();	EVP_cleanup();}

static int load_engine(void **ctx,MESSAGE *msg){	int i;	ENGINE **e=(ENGINE **)ctx;	ENGINE_load_dynamic();	if(!(*e=ENGINE_by_id("dynamic")))goto err1;	if(!ENGINE_ctrl_cmd_string(*e,"SO_PATH",msg->engine,0))goto err2;	for(i=0;pkcs11[i].name;i++)		if(!ENGINE_ctrl_cmd_string(*e,pkcs11[i].name,pkcs11[i].value,0))			goto err2;	if(!ENGINE_ctrl_cmd_string(*e,"MODULE_PATH",msg->pkcs11,0))goto err2;	if(msg->nopin)if(!ENGINE_ctrl_cmd_string(*e,"NOLOGIN","1",0))goto err2;	if(!ENGINE_ctrl_cmd_string(*e,"PIN",msg->nopin?"":msg->pin,0))goto err2;	if(!ENGINE_init(*e))	{err2:		ENGINE_free(*e);err1:		ENGINE_cleanup();		return ENGFAIL;	}	ENGINE_free(*e);	ENGINE_set_default(*e,ENGINE_METHOD_ALL&~ENGINE_METHOD_RAND);	return OK;}

int main(int argc, char *argv[]){	BIO *bio_err = NULL;	SSL_library_init();	SSL_load_error_strings();	ERR_load_crypto_strings();	/* error write context */	bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);	const SSL_METHOD *meth = SSLv23_method();	SSL_CTX *ctx = SSL_CTX_new(meth);	/***/	BIO_free(bio_err);	ERR_free_strings();	ERR_remove_state(0);	ENGINE_cleanup();	CONF_modules_free();	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();	return 0;}

int main(int argc, char **argv)	{	BIO *bio_err;	X509 *x509=NULL;	EVP_PKEY *pkey=NULL;	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);	mkcert(&x509,&pkey,512,0,365);	RSA_print_fp(stdout,pkey->pkey.rsa,0);	X509_print_fp(stdout,x509);	PEM_write_PrivateKey(stdout,pkey,NULL,NULL,0,NULL, NULL);	PEM_write_X509(stdout,x509);	X509_free(x509);	EVP_PKEY_free(pkey);#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CRYPTO_cleanup_all_ex_data();	CRYPTO_mem_leaks(bio_err);	BIO_free(bio_err);	return(0);	}

static void unload_engine(void *ctx){	ENGINE *e=(ENGINE *)ctx;	ENGINE_finish(e);	ENGINE_cleanup();}

/** * Shutdown the crypto library and release resources. */static apr_status_t crypto_shutdown(void){    ERR_free_strings();    EVP_cleanup();    ENGINE_cleanup();    return APR_SUCCESS;}

/* * Deinitialize OpenSSL and free as much memory as possible. * Some 10k-100k will still remain resident no matter what. */voidssl_fini(void){	if (!ssl_initialized)		return;	ERR_remove_state(0); /* current thread */#ifdef OPENSSL_THREADS	CRYPTO_set_locking_callback(NULL);	CRYPTO_set_dynlock_create_callback(NULL);	CRYPTO_set_dynlock_lock_callback(NULL);	CRYPTO_set_dynlock_destroy_callback(NULL);#ifdef OPENSSL_NO_THREADID	CRYPTO_set_id_callback(NULL);#else /* !OPENSSL_NO_THREADID */	CRYPTO_THREADID_set_callback(NULL);#endif /* !OPENSSL_NO_THREADID */	int i;	for (i = 0; i < ssl_mutex_num; i++) {		pthread_mutex_destroy(&ssl_mutex[i]);	}	free(ssl_mutex);#endif	ENGINE_cleanup();	CONF_modules_finish();	CONF_modules_unload(1);	CONF_modules_free();	EVP_cleanup();	ERR_free_strings();	CRYPTO_cleanup_all_ex_data();}

/*   Release SSL and free resources   Will be automatically executed by    mysql_server_end() function   SYNOPSIS     my_ssl_end()       void   RETURN VALUES     void*/void my_ssl_end(){  DBUG_ENTER("my_ssl_end");  pthread_mutex_lock(&LOCK_ssl_config);  if (my_ssl_initialized)  {    int i;    CRYPTO_set_locking_callback(NULL);		CRYPTO_set_id_callback(NULL);    for (i=0; i < CRYPTO_num_locks(); i++)      pthread_mutex_destroy(&LOCK_crypto[i]);    my_free((gptr)LOCK_crypto, MYF(0));    if (SSL_context)    {      SSL_CTX_free(SSL_context);      SSL_context= FALSE;    }    ERR_remove_state(0);    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_free_strings();    ENGINE_cleanup();    CONF_modules_free();    CONF_modules_unload(1);    sk_SSL_COMP_free(SSL_COMP_get_compression_methods());    my_ssl_initialized= FALSE;  }  pthread_mutex_unlock(&LOCK_ssl_config);  pthread_mutex_destroy(&LOCK_ssl_config);  DBUG_VOID_RETURN;}

CSSLInitializer::~CSSLInitializer(){	CleanupThreadState();#if OPENSSL_VERSION_NUMBER < OPENSSL_VERSION_1_1_0	CONF_modules_free();	ENGINE_cleanup();	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();	ERR_free_strings();	SSL_COMP_free_compression_methods();	CRYPTO_set_locking_callback			(nullptr);	CRYPTO_set_dynlock_create_callback	(nullptr);	CRYPTO_set_dynlock_destroy_callback	(nullptr);	CRYPTO_set_dynlock_lock_callback	(nullptr);	if(sm_iLockNum > 0)	{		delete[] sm_pcsLocks;		sm_pcsLocks = nullptr;		sm_iLockNum = 0;	}#endif}

Environment::~Environment(){    DEBUG( "env: dtor: shutting down OpenSSL" );    EVP_cleanup();    ENGINE_cleanup();    DEBUG( "env: dtor: done" );}

static VALUEossl_engine_s_cleanup(VALUE self){#if defined(HAVE_ENGINE_CLEANUP)    ENGINE_cleanup();#endif    return Qnil;}

void krx_end() {  ERR_remove_state(0);  ENGINE_cleanup();  CONF_modules_unload(1);  ERR_free_strings();  EVP_cleanup();  sk_SSL_COMP_free(SSL_COMP_get_compression_methods());  CRYPTO_cleanup_all_ex_data();}

void openssl_shutdown(bool threaded) {#ifndef OPENSSL_NO_ENGINE  ENGINE_cleanup();#endif  if (threaded) {    pthreads_locking_cleanup();  }}

static void BSslFreeOSSL(void){	ERR_remove_state(0);#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CRYPTO_cleanup_all_ex_data();	ERR_free_strings();	EVP_cleanup();}

void openssl_cleanup(){    CONF_modules_unload(1);    OBJ_cleanup();    EVP_cleanup();    ENGINE_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_state(0);    ERR_free_strings();}

/* Free memory for the hardware engine */static void unload_hardware_engine () {  if (!reng)    return;  ENGINE_finish (reng);  ENGINE_free (reng);  ENGINE_cleanup ();  reng = NULL;  rand_loaded = 0;}

voidzdb_finalize(){    if(!zdb_init_done)    {        return;    }    zdb_init_done = FALSE;#if ZDB_DNSSEC_SUPPORT != 0    dnssec_keystore_destroy();    dnssec_keystore_resetpath();#endif#if ZDB_OPENSSL_SUPPORT!=0    ERR_remove_state(0);    /* Init openssl */    CRYPTO_set_locking_callback(NULL);    CRYPTO_set_id_callback(NULL);    int i;    for(i = 0; i < ssl_mutex_count; i++)    {        pthread_mutex_destroy(&ssl_mutex[i]);    }    free(ssl_mutex);    ENGINE_cleanup();#endif    logger_stop();#if ZDB_USE_THREADPOOL != 0    /*     *  The default value for the database.     *  This initialization will do nothing if it has already been done.     *     *  The server will have to do it before calling zdb_init();     *     */    if(thread_pool_initialized_by_zdb)    {        thread_pool_destroy();    }#endif}