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

LWS_VISIBLE voidlws_ssl_destroy(struct lws_vhost *vhost){	if (!lws_check_opt(vhost->context->options,			   LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT))		return;#if defined(LWS_USE_POLARSSL)#else#if defined(LWS_USE_MBEDTLS)#else	if (vhost->ssl_ctx)		SSL_CTX_free(vhost->ssl_ctx);	if (!vhost->user_supplied_ssl_ctx && vhost->ssl_client_ctx)		SSL_CTX_free(vhost->ssl_client_ctx);#if (OPENSSL_VERSION_NUMBER < 0x01000000) || defined(USE_WOLFSSL)	ERR_remove_state(0);#else#if (OPENSSL_VERSION_NUMBER >= 0x10100005L) && /	!defined(LIBRESSL_VERSION_NUMBER) && /	!defined(OPENSSL_IS_BORINGSSL)	ERR_remove_thread_state();#else	ERR_remove_thread_state(NULL);#endif#endif	ERR_free_strings();	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();#endif#endif}

voidlws_ssl_context_destroy(struct lws_context *context){#if defined(LWS_USE_POLARSSL)#else#if defined(LWS_USE_MBEDTLS)#else#if (OPENSSL_VERSION_NUMBER < 0x10100006L)#if (OPENSSL_VERSION_NUMBER < 0x01000000) || defined(USE_WOLFSSL)	ERR_remove_state(0);#else#if (OPENSSL_VERSION_NUMBER >= 0x10100005L) && /	!defined(LIBRESSL_VERSION_NUMBER) && /	!defined(OPENSSL_IS_BORINGSSL)	ERR_remove_thread_state();#else	ERR_remove_thread_state(NULL);#endif#endif	ERR_free_strings();	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();#endif#endif#endif}

voidlws_ssl_context_destroy(struct lws_context *context){#if !defined(LWS_WITH_MBEDTLS)// after 1.1.0 no need#if (OPENSSL_VERSION_NUMBER <  0x10100000)// <= 1.0.1f = old api, 1.0.1g+ = new api#if (OPENSSL_VERSION_NUMBER <= 0x1000106f) || defined(USE_WOLFSSL)	ERR_remove_state(0);#else#if OPENSSL_VERSION_NUMBER >= 0x1010005f && /    !defined(LIBRESSL_VERSION_NUMBER) && /    !defined(OPENSSL_IS_BORINGSSL)	ERR_remove_thread_state();#else	ERR_remove_thread_state(NULL);#endif#endif	// after 1.1.0 no need#if  (OPENSSL_VERSION_NUMBER >= 0x10002000) && (OPENSSL_VERSION_NUMBER <= 0x10100000)	SSL_COMP_free_compression_methods();#endif	ERR_free_strings();	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();#endif#endif}

LWS_VISIBLE voidlws_ssl_destroy(struct lws_vhost *vhost){	if (!lws_check_opt(vhost->context->options,			   LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT))		return;	if (vhost->tls.ssl_ctx)		SSL_CTX_free(vhost->tls.ssl_ctx);	if (!vhost->tls.user_supplied_ssl_ctx && vhost->tls.ssl_client_ctx)		SSL_CTX_free(vhost->tls.ssl_client_ctx);// after 1.1.0 no need#if (OPENSSL_VERSION_NUMBER <  0x10100000)// <= 1.0.1f = old api, 1.0.1g+ = new api#if (OPENSSL_VERSION_NUMBER <= 0x1000106f) || defined(USE_WOLFSSL)	ERR_remove_state(0);#else#if OPENSSL_VERSION_NUMBER >= 0x1010005f && /    !defined(LIBRESSL_VERSION_NUMBER) && /    !defined(OPENSSL_IS_BORINGSSL)	ERR_remove_thread_state();#else	ERR_remove_thread_state(NULL);#endif#endif	// after 1.1.0 no need#if  (OPENSSL_VERSION_NUMBER >= 0x10002000) && (OPENSSL_VERSION_NUMBER <= 0x10100000)	SSL_COMP_free_compression_methods();#endif	ERR_free_strings();	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();#endif}

/** * 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);}

void sslCleanup(){  // Various cleanup functions  // Maddeningly, 64 bytes still remains (see https://bugs.launchpad.net/percona-server/+bug/1205196)  //ENGINE_cleanup();  CRYPTO_cleanup_all_ex_data();  ERR_free_strings();#if OPENSSL_VERSION_NUMBER < 0x10100000L  ERR_remove_thread_state(NULL);#else  ERR_remove_thread_state();#endif  EVP_cleanup();}

static void ossl_init_thread_stop(struct thread_local_inits_st *locals){    /* Can't do much about this */    if (locals == NULL)        return;    if (locals->async) {#ifdef OPENSSL_INIT_DEBUG        fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "                        "ASYNC_cleanup_thread()/n");#endif        ASYNC_cleanup_thread();    }    if (locals->err_state) {#ifdef OPENSSL_INIT_DEBUG        fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "                        "ERR_remove_thread_state(NULL)/n");#endif        ERR_remove_thread_state(NULL);    }    OPENSSL_free(locals);    ossl_init_thread_stop_cleanup();}

BOOL winpr_CleanupSSL(DWORD flags){	if (flags & WINPR_SSL_CLEANUP_GLOBAL)	{		if (!g_winpr_openssl_initialized_by_winpr)		{			WLog_WARN(TAG, "ssl was not initialized by winpr");			return FALSE;		}		g_winpr_openssl_initialized_by_winpr = FALSE;#ifdef WINPR_OPENSSL_LOCKING_REQUIRED		_winpr_openssl_cleanup_locking();#endif		CRYPTO_cleanup_all_ex_data();		ERR_free_strings();		EVP_cleanup();		flags |= WINPR_SSL_CLEANUP_THREAD;	}#ifdef WINPR_OPENSSL_LOCKING_REQUIRED	if (flags & WINPR_SSL_CLEANUP_THREAD)	{#if (OPENSSL_VERSION_NUMBER < 0x10000000L)		ERR_remove_state(0);#else		ERR_remove_thread_state(NULL);#endif	}#endif	return TRUE;}

int main(int argc, char **argv){    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    ERR_load_crypto_strings();    OpenSSL_add_all_digests();    if (argc != 4) {        fprintf(stderr, "usage: verify_extra_test roots.pem untrusted.pem bad.pem/n");        return 1;    }    if (!test_alt_chains_cert_forgery(argv[1], argv[2], argv[3])) {        fprintf(stderr, "Test alt chains cert forgery failed/n");        return 1;    }    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    ERR_free_strings();#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks_fp(stderr) <= 0)        return 1;#endif    printf("PASS/n");    return 0;}

int main(int argc, char **argv)	{	BIO *bio_err;	bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	ERR_load_crypto_strings();	/* "Negative" test, expect a mismatch */	if(run_srp("alice", "password1", "password2") == 0)		{		fprintf(stderr, "Mismatched SRP run failed/n");		return 1;		}	/* "Positive" test, should pass */	if(run_srp("alice", "password", "password") != 0)		{		fprintf(stderr, "Plain SRP run failed/n");		return 1;		}	CRYPTO_cleanup_all_ex_data();	ERR_remove_thread_state(NULL);	ERR_free_strings();	CRYPTO_mem_leaks(bio_err);	return 0;	}

/* Delete the memory used for string errors as well as memory allocated for * certificates and private keys. */void terminate_signature(void){	//TODO: once implemented, must free chain	//TODO: once implemented, must free crl	if (store) {		X509_STORE_free(store);		store = NULL;	}	if (x509_stack) {		sk_X509_pop_free(x509_stack, X509_free);		x509_stack = NULL;	}	ERR_free_strings();	if (pkey) {		EVP_PKEY_free(pkey);		pkey = NULL;	}	EVP_cleanup();	if (fp_pubkey) {		fclose(fp_pubkey);	}	if (cert) {		cert = NULL;	}	ERR_remove_thread_state(NULL);	CRYPTO_cleanup_all_ex_data();}

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 internal_idevice_deinit(void){#ifdef HAVE_OPENSSL	int i;	if (mutex_buf) {		CRYPTO_set_id_callback(NULL);		CRYPTO_set_locking_callback(NULL);		for (i = 0; i < CRYPTO_num_locks(); i++)			mutex_destroy(&mutex_buf[i]);		free(mutex_buf);		mutex_buf = NULL;	}	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();	sk_SSL_COMP_free(SSL_COMP_get_compression_methods());#ifdef HAVE_ERR_REMOVE_THREAD_STATE	ERR_remove_thread_state(NULL);#else	ERR_remove_state(0);#endif#else	gnutls_global_deinit();#endif}

/*! * /internal * /brief fopencookie()/funopen() stream close function. * * /param cookie Stream control data. * * /retval 0 on success. * /retval -1 on error. */static int tcptls_stream_close(void *cookie){	struct ast_tcptls_stream *stream = cookie;	if (!stream) {		errno = EBADF;		return -1;	}	if (stream->fd != -1) {#if defined(DO_SSL)		if (stream->ssl) {			int res;			/*			 * According to the TLS standard, it is acceptable for an			 * application to only send its shutdown alert and then			 * close the underlying connection without waiting for			 * the peer's response (this way resources can be saved,			 * as the process can already terminate or serve another			 * connection).			 */			res = SSL_shutdown(stream->ssl);			if (res < 0) {				ast_log(LOG_ERROR, "SSL_shutdown() failed: %d/n",					SSL_get_error(stream->ssl, res));			}			if (!stream->ssl->server) {				/* For client threads, ensure that the error stack is cleared */#if OPENSSL_VERSION_NUMBER >= 0x10000000L				ERR_remove_thread_state(NULL);#else				ERR_remove_state(0);#endif	/* OPENSSL_VERSION_NUMBER >= 0x10000000L */			}			SSL_free(stream->ssl);			stream->ssl = NULL;		}#endif	/* defined(DO_SSL) */		/*		 * Issuing shutdown() is necessary here to avoid a race		 * condition where the last data written may not appear		 * in the TCP stream.  See ASTERISK-23548		 */		shutdown(stream->fd, SHUT_RDWR);		if (close(stream->fd)) {			ast_log(LOG_ERROR, "close() failed: %s/n", strerror(errno));		}		stream->fd = -1;	}	ao2_t_ref(stream, -1, "Closed tcptls stream cookie");	return 0;}

static void aes_cleanup(EVP_CIPHER_CTX* ctx){	EVP_CIPHER_CTX_free(ctx);	#if(OPENSSL_VERSION_NUMBER<0x10000000L)		ERR_remove_state(0);	#elif(OPENSSL_VERSION_NUMBER<0x10100000L)		ERR_remove_thread_state(NULL);	#endif}

int ssl_test_ecdh(int argc, char *argv[])	{	BN_CTX *ctx=NULL;	int ret=1;	BIO *out;	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#ifdef OPENSSL_SYS_WIN32	CRYPTO_malloc_init();#endif	RAND_seed(rnd_seed, sizeof rnd_seed);#ifndef OPENSSL_SYS_WINDOWS	out = BIO_new(BIO_s_mem());	if (out == NULL) return(1);#else	out=BIO_new(BIO_s_file());	if (out == NULL) return(1);	BIO_set_fp(out,OPENSSL_TYPE__FILE_STDOUT,BIO_NOCLOSE);#endif		if ((ctx=BN_CTX_new()) == NULL) goto err;	/* NIST PRIME CURVES TESTS */	if (!test_ecdh_curve(NID_X9_62_prime192v1, "NIST Prime-Curve P-192", ctx, out)) goto err;	if (!test_ecdh_curve(NID_secp224r1, "NIST Prime-Curve P-224", ctx, out)) goto err;	if (!test_ecdh_curve(NID_X9_62_prime256v1, "NIST Prime-Curve P-256", ctx, out)) goto err;	if (!test_ecdh_curve(NID_secp384r1, "NIST Prime-Curve P-384", ctx, out)) goto err;	if (!test_ecdh_curve(NID_secp521r1, "NIST Prime-Curve P-521", ctx, out)) goto err;	/* NIST BINARY CURVES TESTS */	if (!test_ecdh_curve(NID_sect163k1, "NIST Binary-Curve K-163", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect163r2, "NIST Binary-Curve B-163", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect233k1, "NIST Binary-Curve K-233", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect233r1, "NIST Binary-Curve B-233", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect283k1, "NIST Binary-Curve K-283", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect283r1, "NIST Binary-Curve B-283", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect409k1, "NIST Binary-Curve K-409", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect409r1, "NIST Binary-Curve B-409", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect571k1, "NIST Binary-Curve K-571", ctx, out)) goto err;	if (!test_ecdh_curve(NID_sect571r1, "NIST Binary-Curve B-571", ctx, out)) goto err;	ret = 0;err:	ERR_print_errors_fp(OPENSSL_TYPE__FILE_STDERR);	if (ctx) BN_CTX_free(ctx);	BIO_free(out);	CRYPTO_cleanup_all_ex_data();	ERR_remove_thread_state(NULL);	CRYPTO_mem_leaks_fp(OPENSSL_TYPE__FILE_STDERR);	return(ret);	}

int main(void){    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    ERR_load_crypto_strings();    /* Load up the software EVP_CIPHER and EVP_MD definitions */    OpenSSL_add_all_ciphers();    OpenSSL_add_all_digests();    if (!test_EVP_DigestSignInit()) {        fprintf(stderr, "EVP_DigestSignInit failed/n");        return 1;    }    if (!test_EVP_DigestVerifyInit()) {        fprintf(stderr, "EVP_DigestVerifyInit failed/n");        return 1;    }    if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),                                 EVP_PKEY_RSA)) {        fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed/n");        return 1;    }    if (!test_d2i_AutoPrivateKey        (kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA)) {        fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed/n");        return 1;    }#ifndef OPENSSL_NO_EC    if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),                                 EVP_PKEY_EC)) {        fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed/n");        return 1;    }    if (!test_EVP_PKCS82PKEY()) {        fprintf(stderr, "test_EVP_PKCS82PKEY failed/n");        return 1;    }#endif    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    ERR_free_strings();#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks_fp(stderr) <= 0)        return 1;#endif    printf("PASS/n");    return 0;}

EXPORT void STDCALL TaggantFinalizeLibrary(void){    lib_initialized = 0;    OBJ_cleanup();    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);    ERR_free_strings();}

int main(int argc, char *argv[]){    BN_CTX *ctx = NULL;    int nid, ret = 1;    EC_builtin_curve *curves = NULL;    size_t crv_len = 0, n = 0;    BIO *out;    CRYPTO_set_mem_debug(1);    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);    RAND_seed(rnd_seed, sizeof rnd_seed);    out = BIO_new(BIO_s_file());    if (out == NULL)        EXIT(1);    BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT);    if ((ctx = BN_CTX_new()) == NULL)        goto err;    /* get a list of all internal curves */    crv_len = EC_get_builtin_curves(NULL, 0);    curves = OPENSSL_malloc(sizeof(*curves) * crv_len);    if (curves == NULL) goto err;    if (!EC_get_builtin_curves(curves, crv_len)) goto err;    /* NAMED CURVES TESTS */    for (n = 0; n < crv_len; n++) {        nid = curves[n].nid;        if (!test_ecdh_curve(nid, ctx, out)) goto err;    }    /* KATs */    for (n = 0; n < (sizeof(ecdh_kats)/sizeof(ecdh_kat_t)); n++) {        if (!ecdh_kat(out, &ecdh_kats[n]))            goto err;    }    ret = 0; err:    ERR_print_errors_fp(stderr);    OPENSSL_free(curves);    BN_CTX_free(ctx);    BIO_free(out);    CRYPTO_cleanup_all_ex_data();    ERR_remove_thread_state(NULL);#ifndef OPENSSL_NO_CRYPTO_MDEBUG    if (CRYPTO_mem_leaks_fp(stderr) <= 0)        ret = 1;#endif    EXIT(ret);}

static void rsa_remove(void){	CRYPTO_cleanup_all_ex_data();	ERR_free_strings();#ifdef HAVE_ERR_REMOVE_THREAD_STATE	ERR_remove_thread_state(NULL);#else	ERR_remove_state(0);#endif	EVP_cleanup();}

int main(int argc, char *argv[]) {  int ret = 1;  BIO *out;  CRYPTO_malloc_debug_init();  CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);  CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#ifdef OPENSSL_SYS_WIN32  CRYPTO_malloc_init();#endif  RAND_seed(rnd_seed, sizeof rnd_seed);  out = BIO_new(BIO_s_file());  if (out == NULL) EXIT(1);  BIO_set_fp(out, stdout, BIO_NOCLOSE);  if (argc == 1) {    if (!test_lwekex(out, 1)) goto err;  } else if (argc == 2 && !strcmp((const char *)argv[1], "cont")) {    BIO_printf(out, "Running continuous test. ^C to quit./n/n");    int iterations = 0;    int failures = 0;    time_t starttime = time(NULL);    while (1) {      iterations++;      if (test_lwekex(out, 0) == 1) {      } else {        failures++;      }      if ((iterations % 100) == 0) {        BIO_printf(out, "Iterations: %d, failures: %d, elapsed time: %ld/n",                   iterations, failures, time(NULL) - starttime);        if (iterations > (1 << 20)) break;      }    }  } else {    BIO_printf(out,               "Error: argument must be /"cont/" for invoking /continuously run test./n");  }  ret = 0;err:  ERR_print_errors_fp(stderr);  BIO_free(out);  CRYPTO_cleanup_all_ex_data();  ERR_remove_thread_state(NULL);  CRYPTO_mem_leaks_fp(stderr);  EXIT(ret);  return (ret);}

/* * Make sure openssl does not introduce memory leaks for valgrind */__attribute__((destructor)) void cleanup_openssl (void){    //http://www.openssl.org/support/faq.html#PROG13    ERR_remove_thread_state(NULL);    ENGINE_cleanup();    CONF_modules_unload(1);    ERR_free_strings();    OBJ_cleanup();    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();}

void CSSLInitializer::CleanupThreadState(DWORD dwThreadID){#if OPENSSL_VERSION_NUMBER < OPENSSL_VERSION_1_1_0	CRYPTO_THREADID tid = {nullptr, dwThreadID};		CRYPTO_THREADID_current(&tid);	ERR_remove_thread_state(&tid);#else	OPENSSL_thread_stop();#endif}

static voidopenssl_shutdown(void){	CONF_modules_unload(1);	destroy_ui();	OBJ_cleanup();	EVP_cleanup();	CRYPTO_cleanup_all_ex_data();	ERR_remove_thread_state(NULL);	ERR_free_strings();}

static void openssl_remove_thread_state(void){/*  ERR_remove_thread_state() is available since OpenSSL 1.0.0-beta1, but *  deprecated in OpenSSL 1.1.0 */#if OPENSSL_VERSION_NUMBER < 0x10100000L#if OPENSSL_VERSION_NUMBER >= 0x10000001L	ERR_remove_thread_state(NULL);#else	ERR_remove_state(0);#endif#endif}

static int luaclose_openssl(lua_State *L){  if(atomic_fetch_sub(&init, 1) > 1)    return 0;#if !defined(LIBRESSL_VERSION_NUMBER)  FIPS_mode_set(0);#endif  OBJ_cleanup();  EVP_cleanup();  ENGINE_cleanup();  RAND_cleanup();#if OPENSSL_VERSION_NUMBER >= 0x10002000L && !defined(LIBRESSL_VERSION_NUMBER)  SSL_COMP_free_compression_methods();#endif  COMP_zlib_cleanup();#if OPENSSL_VERSION_NUMBER < 0x10000000L  ERR_remove_state(0);#elif OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)  ERR_remove_thread_state(NULL);#endif#if defined(OPENSSL_THREADS)  CRYPTO_thread_cleanup();#endif  CRYPTO_set_locking_callback(NULL);  CRYPTO_set_id_callback(NULL);  CRYPTO_cleanup_all_ex_data();  ERR_free_strings();  CONF_modules_free();  CONF_modules_unload(1);#ifndef OPENSSL_NO_CRYPTO_MDEBUG#if !(defined(OPENSSL_NO_STDIO) || defined(OPENSSL_NO_FP_API))#if defined(LIBRESSL_VERSION_NUMBER) || OPENSSL_VERSION_NUMBER < 0x10101000L  CRYPTO_mem_leaks_fp(stderr);#else  if(CRYPTO_mem_leaks_fp(stderr)!=1)  {    fprintf(stderr,            "Please report a bug on https://github.com/zhaozg/lua-openssl."            "And if can, please provide a reproduce method and minimal code./n"            "/n/tThank You.");  }#endif#endif /* OPENSSL_NO_STDIO or OPENSSL_NO_FP_API */#endif /* OPENSSL_NO_CRYPTO_MDEBUG */  return 0;}

static apr_status_t ssl_cleanup_pre_config(void *data){    /*     * Try to kill the internals of the SSL library.     */#ifdef HAVE_FIPS    FIPS_mode_set(0);#endif    /* Corresponds to OBJ_create()s */    OBJ_cleanup();    /* Corresponds to OPENSSL_load_builtin_modules() */    CONF_modules_free();    /* Corresponds to SSL_library_init: */    EVP_cleanup();#if HAVE_ENGINE_LOAD_BUILTIN_ENGINES    ENGINE_cleanup();#endif#if OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined(OPENSSL_NO_COMP)    SSL_COMP_free_compression_methods();#endif    /* Usually needed per thread, but this parent process is single-threaded */#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)#if OPENSSL_VERSION_NUMBER >= 0x1000000fL    ERR_remove_thread_state(NULL);#else    ERR_remove_state(0);#endif#endif    /* Don't call ERR_free_strings in earlier versions, ERR_load_*_strings only     * actually loaded the error strings once per process due to static     * variable abuse in OpenSSL. */#if (OPENSSL_VERSION_NUMBER >= 0x00090805f)    ERR_free_strings();#endif    /* Also don't call CRYPTO_cleanup_all_ex_data when linked statically 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 (!). */    if (!modssl_running_statically) {        CRYPTO_cleanup_all_ex_data();    }    /*     * 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;}

/* * Checks this thread's OpenSSL error queue and logs if * necessary. */static void logOpenSSLError(const char* location) {    int error = ERR_get_error();    if (error != 0) {        char message[256];        ERR_error_string_n(error, message, sizeof(message));        ALOGE("OpenSSL error in %s %d: %s", location, error, message);    }    ERR_clear_error();    ERR_remove_thread_state(NULL);}

static void SQBIND_ffmpeg_cleanup(){	// SSL cleanup sequence	ERR_remove_state( 0 );#ifndef OPENSSL_NO_ENGINE	ENGINE_cleanup();#endif	CONF_modules_unload( 1 );		CRYPTO_cleanup_all_ex_data();	ERR_free_strings();	ERR_remove_thread_state(NULL);	EVP_cleanup();}

void main_cleanup(void) {        ecies_group_free();        // As a child I was taught that your done eating until your plate is completely clean.        // The following should release _all_ of the memory allocated by the OpenSSL functions used.        EVP_cleanup();        CRYPTO_cleanup_all_ex_data();        ERR_free_strings();        ERR_remove_thread_state(NULL);        sk_pop_free((_STACK *)SSL_COMP_get_compression_methods(), CRYPTO_free);        return;}