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

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#if (OPENSSL_VERSION_NUMBER < 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER)		CRYPTO_cleanup_all_ex_data();		ERR_free_strings();		EVP_cleanup();#endif#ifdef WINPR_OPENSSL_LOCKING_REQUIRED		flags |= WINPR_SSL_CLEANUP_THREAD;#endif	}#ifdef WINPR_OPENSSL_LOCKING_REQUIRED	if (flags & WINPR_SSL_CLEANUP_THREAD)	{#if (OPENSSL_VERSION_NUMBER < 0x10000000L) || defined(LIBRESSL_VERSION_NUMBER)		ERR_remove_state(0);#else		ERR_remove_thread_state(NULL);#endif	}#endif	return TRUE;}

void OpenSSL::ClassDestroy() {	MS_TRACE();	MS_DEBUG("unloading openssl");	// FAQ: https://www.openssl.org/support/faq.html#PROG13	// Thread-local cleanup functions.	ERR_remove_thread_state(nullptr);	// Application-global cleanup functions that are aware of usage (and	// therefore thread-safe).	ENGINE_cleanup();	// "Brutal" (thread-unsafe) Application-global cleanup functions.	ERR_free_strings();	EVP_cleanup();  // Removes all ciphers and digests.	CRYPTO_cleanup_all_ex_data();	// https://bugs.launchpad.net/percona-server/+bug/1341067.	sk_SSL_COMP_free(SSL_COMP_get_compression_methods());	// Free mutexes.	for (int i=0; i<OpenSSL::numMutexes; i++) {		int err = pthread_mutex_destroy(&OpenSSL::mutexes[i]);		if (err)			MS_ERROR("pthread_mutex_destroy() failed with return code %d/n", err);	}	if (OpenSSL::mutexes)		delete[] OpenSSL::mutexes;	// Reset callbacks.	CRYPTO_THREADID_set_callback(nullptr);	CRYPTO_set_locking_callback(nullptr);	CRYPTO_set_dynlock_create_callback(nullptr);	CRYPTO_set_dynlock_lock_callback(nullptr);	CRYPTO_set_dynlock_destroy_callback(nullptr);}

void OpenSSLSession::Stop(){	if(!m_bStarted)	{		return;	}	if(m_ConnectionCtx)	{		SSL_CTX_free(m_ConnectionCtx);		m_ConnectionCtx = 0;	}	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();	m_bStarted = false;}

/** * Stop SSL support library * @return TRUE, or FALSE if an error has occured. */int stop_ssl() {#ifdef HAVE_OPENSSL    if ( ssl_initilized ) {        ssl_initilized=FALSE;        ERR_free_strings();        return (ssl_thread_stop() && ssl_entropy_stop());    } else {        return TRUE;    }#else    return FALSE;#endif}

voidtls_deinit(void){	if (tls_initialised) {		tls_compat_cleanup();		tls_config_free(tls_config_default);		tls_config_default = NULL;#ifdef USE_LIBSSL_INTERNALS		EVP_cleanup();		CRYPTO_cleanup_all_ex_data();		BIO_sock_cleanup();		ERR_clear_error();		ERR_remove_thread_state(NULL);		ERR_free_strings();#else		OPENSSL_cleanup();#endif		tls_initialised = 0;	}}

UtlBoolean OsEncryption::openSslError(void){#if defined(OSENCRYPTION)    unsigned long err = ERR_get_error();    if (err != 0)    {        ERR_load_crypto_strings();        ERR_load_ERR_strings();        char errbuff[256];        errbuff[0] = 0;        ERR_error_string_n(err, errbuff, sizeof(errbuff));        osPrintf("OpenSLL ERROR:/n/tlib:%s/n/tfunction:%s/n/treason:%s/n",            ERR_lib_error_string(err),            ERR_func_error_string(err),            ERR_reason_error_string(err));        ERR_free_strings();        return TRUE;    }#endif    return FALSE;}

/** * @brief Deinitialize the signing subsystem * * @param none * * @returns Nothing */void sign_deinit(void) {    if (rsa) {        RSA_free(rsa);        rsa = NULL;    }    if (crypto_initialized) {        /* (From: https://wiki.openssl.org/index.php/Libcrypto_API) */        /* Removes all digests and ciphers */         EVP_cleanup();         /**          * if you omit the next, a small leak may be left when you make use          * of the BIO (low level API) for e.g. base64 transformations          */         CRYPTO_cleanup_all_ex_data();         /* Remove error strings */         ERR_free_strings();        crypto_initialized = false;    }}

/* 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    init_ssl=0; /* not inited any more */  }#else  /* SSL disabled, do nothing */#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 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 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;}

bool_t CC_CALL _cckit_destroy_http_request(cckit_http_t **h){	if (h == NULL || *h == NULL) {		return FALSE;	}#ifdef CC_OPENSSL_HTTPS    if ((*h)->address->scheme == CC_SCHEME_HTTPS) {        if ((*h)->ssl) {            SSL_shutdown((*h)->ssl);            SSL_free((*h)->ssl);            SSL_CTX_free((*h)->ssl_ctx);        }        /*SSL*/        if(cc_atomic_dec_ref(_SSL_init_refcount)) {            ERR_free_strings();        }    }#endif    if ((*h)->response) {        _cckit_destroy_http_response(&(*h)->response);    }	if ((*h)->address) {		cc_destroy_url(&(*h)->address);	}	if ((*h)->sock_event) {		cckit_data_buffer_pop((cckit_data_buffer_t**)&(*h)->sock_event->args[2]);		cckit_tcp_close((*h)->sock_event);		(*h)->sock_event = NULL;	}	cc_free((*h));	*h = NULL;	return TRUE;}

/*   Release SSL and free resources   Will be automatically executed by    mysql_server_end() function   SYNOPSIS     my_ssl_end()       void   RETURN VALUES     void*/void ma_tls_end(){  if (ma_tls_initialized)  {    int i;    pthread_mutex_lock(&LOCK_openssl_config);    CRYPTO_set_locking_callback(NULL);    CRYPTO_set_id_callback(NULL);    for (i=0; i < CRYPTO_num_locks(); i++)      pthread_mutex_destroy(&LOCK_crypto[i]);    ma_free((gptr)LOCK_crypto);    LOCK_crypto= NULL;    if (SSL_context)    {      SSL_CTX_free(SSL_context);      SSL_context= NULL;    }    if (mariadb_deinitialize_ssl)    {      ERR_remove_state(0);      EVP_cleanup();      CRYPTO_cleanup_all_ex_data();      ERR_free_strings();      CONF_modules_free();      CONF_modules_unload(1);      sk_SSL_COMP_free(SSL_COMP_get_compression_methods());    }    ma_tls_initialized= FALSE;    pthread_mutex_unlock(&LOCK_openssl_config);    pthread_mutex_destroy(&LOCK_openssl_config);  }  return;}

static ret_t_free (cherokee_cryptor_libssl_t *cryp){	/* DH Parameters	 */	if (dh_param_512  != NULL) {		DH_free (dh_param_512);		dh_param_512 = NULL;	}	if (dh_param_1024 != NULL) {		DH_free (dh_param_1024);		dh_param_1024 = NULL;	}	if (dh_param_2048 != NULL) {		DH_free (dh_param_2048);		dh_param_2048 = NULL;	}	if (dh_param_4096 != NULL) {		DH_free (dh_param_4096);		dh_param_4096 = NULL;	}	/* Free loaded error strings	 */	ERR_free_strings();	/* Free all ciphers and digests	 */	EVP_cleanup();	cherokee_cryptor_free_base (CRYPTOR(cryp));	return ret_ok;}

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 < 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}

bool __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, void* lpvReserved){    switch (fdwReason)    {        case DLL_PROCESS_ATTACH:            module = hinstDLL;            DisableThreadLibraryCalls(hinstDLL);            #ifndef USE_CURL            SSL_library_init();            SSL_load_error_strings();            OpenSSL_add_all_algorithms();            #else            curl_global_init(CURL_GLOBAL_ALL);            #endif            break;        case DLL_PROCESS_DETACH:            #ifndef USE_CURL            ERR_free_strings();            EVP_cleanup();            CRYPTO_cleanup_all_ex_data();            #else            curl_global_cleanup();            #endif            break;        case DLL_THREAD_ATTACH:            break;        case DLL_THREAD_DETACH:            break;    }    return true;}

voidlws_ssl_context_destroy(struct lws_context *context){#if defined(LWS_USE_POLARSSL)#else#if defined(LWS_USE_MBEDTLS)#else#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}

voidtor_cleanup (void){	if (!initialized) {		return;	}	EVP_cleanup();	ERR_remove_state(0);	ERR_free_strings();	ENGINE_cleanup();	CONF_modules_unload(1);	CRYPTO_cleanup_all_ex_data();	// cleanup multithreading	for (size_t i = 0; i < locks.length; i++) {		uv_mutex_destroy(&locks.item[i]);	}	free(locks.item);	locks.length = 0;}

//.........这里部分代码省略.........  tvhftrace("main", service_done);  tvhftrace("main", channel_done);  tvhftrace("main", bouquet_done);  tvhftrace("main", dvr_done);  tvhftrace("main", subscription_done);  tvhftrace("main", access_done);  tvhftrace("main", epg_done);  tvhftrace("main", avahi_done);  tvhftrace("main", bonjour_done);  tvhftrace("main", imagecache_done);  tvhftrace("main", lang_code_done);  tvhftrace("main", api_done);  tvhtrace("main", "tasklet enter");  pthread_cond_signal(&tasklet_cond);  pthread_join(tasklet_tid, NULL);  tvhtrace("main", "tasklet thread end");  tasklet_flush();  tvhtrace("main", "tasklet leave");  tvhftrace("main", hts_settings_done);  tvhftrace("main", dvb_done);  tvhftrace("main", lang_str_done);  tvhftrace("main", esfilter_done);  tvhftrace("main", profile_done);  tvhftrace("main", intlconv_done);  tvhftrace("main", urlparse_done);  tvhftrace("main", idnode_done);  tvhftrace("main", notify_done);  tvhftrace("main", spawn_done);  tvhlog(LOG_NOTICE, "STOP", "Exiting HTS Tvheadend");  tvhlog_end();  tvhftrace("main", config_done);  if(opt_fork)    unlink(opt_pidpath);    #if ENABLE_TSFILE  free(opt_tsfile.str);#endif  free(opt_satip_xml.str);  /* OpenSSL - welcome to the "cleanup" hell */  ENGINE_cleanup();  RAND_cleanup();  CRYPTO_cleanup_all_ex_data();  EVP_cleanup();  CONF_modules_free();#ifndef OPENSSL_NO_COMP  COMP_zlib_cleanup();#endif  ERR_remove_state(0);  ERR_free_strings();#ifndef OPENSSL_NO_COMP  sk_SSL_COMP_free(SSL_COMP_get_compression_methods());#endif  /* end of OpenSSL cleanup code */#if ENABLE_DBUS_1  extern void dbus_shutdown(void);  if (opt_dbus) dbus_shutdown();#endif  return 0;}/** * */voidtvh_str_set(char **strp, const char *src){  free(*strp);  *strp = src ? strdup(src) : NULL;}/** * */inttvh_str_update(char **strp, const char *src){  if(src == NULL)    return 0;  free(*strp);  *strp = strdup(src);  return 1;}/** * */voidscopedunlock(pthread_mutex_t **mtxp){  pthread_mutex_unlock(*mtxp);}

//.........这里部分代码省略......... * */voidInit_openssl(){    /*     * Init timezone info     */#if 0    tzset();#endif    /*     * Init all digests, ciphers     */    /* CRYPTO_malloc_init(); */    /* ENGINE_load_builtin_engines(); */    OpenSSL_add_ssl_algorithms();    OpenSSL_add_all_algorithms();    ERR_load_crypto_strings();    SSL_load_error_strings();    /*     * FIXME:     * On unload do:     */#if 0    CONF_modules_unload(1);    destroy_ui_method();    EVP_cleanup();    ENGINE_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_state(0);    ERR_free_strings();#endif    /*     * Init main module     */    mOSSL = rb_define_module("OpenSSL");    rb_global_variable(&mOSSL);    /*     * OpenSSL ruby extension version     */    rb_define_const(mOSSL, "VERSION", rb_str_new2(OSSL_VERSION));    /*     * Version of OpenSSL the ruby OpenSSL extension was built with     */    rb_define_const(mOSSL, "OPENSSL_VERSION", rb_str_new2(OPENSSL_VERSION_TEXT));    /*     * Version number of OpenSSL the ruby OpenSSL extension was built with     * (base 16)     */    rb_define_const(mOSSL, "OPENSSL_VERSION_NUMBER", INT2NUM(OPENSSL_VERSION_NUMBER));    /*     * Boolean indicating whether OpenSSL is FIPS-enabled or not     */#ifdef HAVE_OPENSSL_FIPS    rb_define_const(mOSSL, "OPENSSL_FIPS", Qtrue);#else    rb_define_const(mOSSL, "OPENSSL_FIPS", Qfalse);#endif

//.........这里部分代码省略.........        /* Should still be off even after ALL Protocols on */        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off after config #1 FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "SSLv2") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");            goto end;        }        /* Should still be off even if explicitly asked for */        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off after config #2 FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "-SSLv2") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");;            goto end;        }        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off after config #3 FAIL/n");            goto end;        }        if (currtest == TEST_SSL_CTX)            SSL_CTX_clear_options(ctx, SSL_OP_NO_SSLv2);        else            SSL_clear_options(ssl, SSL_OP_NO_SSLv2);        if (!checksslv2(currtest, SSLV2ON)) {            BIO_printf(err, "SSLv2 CONF Test: On after clear FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "ALL") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");            goto end;        }        /* Option has been cleared and config says have SSLv2 so should be on */        if (!checksslv2(currtest, SSLV2ON)) {            BIO_printf(err, "SSLv2 CONF Test: On after config #1 FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "SSLv2") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");            goto end;        }        /* Option has been cleared and config says have SSLv2 so should be on */        if (!checksslv2(currtest, SSLV2ON)) {            BIO_printf(err, "SSLv2 CONF Test: On after config #2 FAIL/n");            goto end;        }        if (SSL_CONF_cmd(confctx, "Protocol", "-SSLv2") != 2                || !SSL_CONF_CTX_finish(confctx)) {            BIO_printf(err, "SSLv2 CONF Test: SSL_CONF command FAIL/n");            goto end;        }        /* Option has been cleared but config says no SSLv2 so should be off */        if (!checksslv2(currtest, SSLV2OFF)) {            BIO_printf(err, "SSLv2 CONF Test: Off after config #4 FAIL/n");            goto end;        }    }    testresult = 1; end:    SSL_free(ssl);    SSL_CTX_free(ctx);    SSL_CONF_CTX_free(confctx);    if (!testresult) {        printf("SSLv2 CONF test: FAILED (Test %d)/n", currtest);        ERR_print_errors(err);    } else {        printf("SSLv2 CONF test: PASSED/n");    }    ERR_free_strings();    ERR_remove_thread_state(NULL);    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    CRYPTO_mem_leaks(err);    BIO_free(err);    return testresult ? EXIT_SUCCESS : EXIT_FAILURE;}

//.........这里部分代码省略.........    /* Load up the software EVP_CIPHER and EVP_MD definitions */    OpenSSL_add_all_ciphers();    OpenSSL_add_all_digests();#ifndef OPENSSL_NO_ENGINE    /* Load all compiled-in ENGINEs */    ENGINE_load_builtin_engines();#endif#if 0    OPENSSL_config();#endif#ifndef OPENSSL_NO_ENGINE    /* Register all available ENGINE implementations of ciphers and digests.     * This could perhaps be changed to "ENGINE_register_all_complete()"? */    ENGINE_register_all_ciphers();    ENGINE_register_all_digests();    /* If we add command-line options, this statement should be switchable.     * It'll prevent ENGINEs being ENGINE_init()ialised for cipher/digest use if     * they weren't already initialised. */    /* ENGINE_set_cipher_flags(ENGINE_CIPHER_FLAG_NOINIT); */#endif    for( ; ; )	{	char line[4096];	char *p;	char *cipher;	unsigned char *iv,*key,*plaintext,*ciphertext;	int encdec;	int kn,in,pn,cn;	if(!fgets((char *)line,sizeof line,f))	    break;	if(line[0] == '#' || line[0] == '/n')	    continue;	p=line;	cipher=sstrsep(&p,":");		key=ustrsep(&p,":");	iv=ustrsep(&p,":");	plaintext=ustrsep(&p,":");	ciphertext=ustrsep(&p,":");	if (p[-1] == '/n') {	    p[-1] = '/0';	    encdec = -1;	} else {	    encdec = atoi(sstrsep(&p,"/n"));	}	      	kn=convert(key);	in=convert(iv);	pn=convert(plaintext);	cn=convert(ciphertext);	if(!test_cipher(cipher,key,kn,iv,in,plaintext,pn,ciphertext,cn,encdec)	   && !test_digest(cipher,plaintext,pn,ciphertext,cn))	    {#ifdef OPENSSL_NO_AES	    if (strstr(cipher, "AES") == cipher)		{		fprintf(stdout, "Cipher disabled, skipping %s/n", cipher); 		continue;		}#endif#ifdef OPENSSL_NO_DES	    if (strstr(cipher, "DES") == cipher)		{		fprintf(stdout, "Cipher disabled, skipping %s/n", cipher); 		continue;		}#endif#ifdef OPENSSL_NO_RC4	    if (strstr(cipher, "RC4") == cipher)		{		fprintf(stdout, "Cipher disabled, skipping %s/n", cipher); 		continue;		}#endif#ifdef OPENSSL_NO_CAMELLIA	    if (strstr(cipher, "CAMELLIA") == cipher)		{		fprintf(stdout, "Cipher disabled, skipping %s/n", cipher); 		continue;		}#endif	    fprintf(stderr,"Can't find %s/n",cipher);	    EXIT(3);	    }	}#ifndef OPENSSL_NO_ENGINE    ENGINE_cleanup();#endif    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_state(0);    ERR_free_strings();    CRYPTO_mem_leaks_fp(stderr);    return 0;    }

 ~openssl_scope() {    EVP_cleanup();    ERR_free_strings(); }

int ssl_test_dsa(int argc, char **argv)	{	BN_GENCB cb;	DSA *dsa=NULL;	int counter,ret=0,i,j;	unsigned char buf[256];	unsigned long h;	unsigned char sig[256];	unsigned int siglen;#ifndef OPENSSL_SYS_WINDOWS		bio_err = BIO_new(BIO_s_mem());		if (bio_err == NULL) return(1);	#else		if (bio_err == NULL)			bio_err=BIO_new_fp(OPENSSL_TYPE__FILE_STDERR,BIO_NOCLOSE);#endif	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	ERR_load_crypto_strings();	RAND_seed(rnd_seed, sizeof rnd_seed);	TINYCLR_SSL_PRINTF("test generation of DSA parameters/n");	BN_GENCB_set(&cb, dsa_cb, bio_err);	if(((dsa = DSA_new()) == NULL) || !DSA_generate_parameters_ex(dsa, 512,				seed, 20, &counter, &h, &cb))		goto end;	TINYCLR_SSL_PRINTF("seed/n");	for (i=0; i<20; i+=4)		{		TINYCLR_SSL_PRINTF("%02X%02X%02X%02X ",			seed[i],seed[i+1],seed[i+2],seed[i+3]);		}	TINYCLR_SSL_PRINTF("/ncounter=%d h=%ld/n",counter,h);			DSA_print(bio_err,dsa,0);	if (counter != 105) 		{		TINYCLR_SSL_PRINTF("counter should be 105/n");		goto end;		}	if (h != 2)		{		TINYCLR_SSL_PRINTF("h should be 2/n");		goto end;		}	i=BN_bn2bin(dsa->q,buf);	j=sizeof(out_q);	if ((i != j) || (TINYCLR_SSL_MEMCMP(buf,out_q,i) != 0))		{		TINYCLR_SSL_PRINTF("q value is wrong/n");		goto end;		}	i=BN_bn2bin(dsa->p,buf);	j=sizeof(out_p);	if ((i != j) || (TINYCLR_SSL_MEMCMP(buf,out_p,i) != 0))		{		TINYCLR_SSL_PRINTF("p value is wrong/n");		goto end;		}	i=BN_bn2bin(dsa->g,buf);	j=sizeof(out_g);	if ((i != j) || (TINYCLR_SSL_MEMCMP(buf,out_g,i) != 0))		{		TINYCLR_SSL_PRINTF("g value is wrong/n");		goto end;		}	dsa->flags |= DSA_FLAG_NO_EXP_CONSTTIME;	DSA_generate_key(dsa);	DSA_sign(0, str1, 20, sig, &siglen, dsa);	if (DSA_verify(0, str1, 20, sig, siglen, dsa) == 1)		ret=1;	dsa->flags &= ~DSA_FLAG_NO_EXP_CONSTTIME;	DSA_generate_key(dsa);	DSA_sign(0, str1, 20, sig, &siglen, dsa);	if (DSA_verify(0, str1, 20, sig, siglen, dsa) == 1)		ret=1;end:	if (!ret)		ERR_print_errors(bio_err);	if (dsa != NULL) DSA_free(dsa);	CRYPTO_cleanup_all_ex_data();	ERR_remove_thread_state(NULL);	ERR_free_strings();	CRYPTO_mem_leaks(bio_err);	if (bio_err != NULL)		{		BIO_free(bio_err);//.........这里部分代码省略.........

voidcrypto_finish(void){    ERR_free_strings();}

int main(int argc, char **argv) {  int c = 0;  char *ptr, *progname = *argv;  const char *cmdopts = "hqv", *secret = NULL;  ptr = strrchr(progname, '/');  if (ptr != NULL) {    progname = ptr+1;  }  opterr = 0;  while ((c =#ifdef HAVE_GETOPT_LONG	 getopt_long(argc, argv, cmdopts, opts, NULL)#else /* HAVE_GETOPT_LONG */	 getopt(argc, argv, cmdopts)#endif /* HAVE_GETOPT_LONG */	 ) != -1) {    switch (c) {      case 'h':        show_usage(progname, 0);        break;      case 'q':        verbose = FALSE;        quiet = TRUE;        break;      case 'v':        quiet = FALSE;        verbose = TRUE;        break;      case '?':        fprintf(stderr, "unknown option: %c/n", (char) optopt);        show_usage(progname, 1);        break;    }  }  auth_otp_pool = make_sub_pool(NULL);#if OPENSSL_VERSION_NUMBER < 0x10100000L  OPENSSL_config(NULL);#endif /* prior to OpenSSL-1.1.x */  ERR_load_crypto_strings();  OpenSSL_add_all_algorithms();  secret = generate_secret(auth_otp_pool);    if (secret == NULL) {    return 1;  }  if (quiet) {    fprintf(stdout, "%s/n", secret);  } else {    int code;    code = generate_code(auth_otp_pool, secret, strlen(secret));    if (code < 0) {      fprintf(stderr, "%s: error generating verification code: %s/n", progname,        strerror(errno));      destroy_pool(auth_otp_pool);      return 1;    }    fprintf(stdout, "-------------------------------------------------/n");    fprintf(stdout, "Your new secret key is: %s/n/n", secret);    fprintf(stdout, "To add this key to your SQL table, you might use:/n/n");    fprintf(stdout, "  INSERT INTO auth_otp (secret, counter) VALUES ('%s', 0);/n/n",      secret);    fprintf(stdout, "Your verification code is: %06d/n", code);    fprintf(stdout, "-------------------------------------------------/n");  }  ERR_free_strings();  EVP_cleanup();  RAND_cleanup();  destroy_pool(auth_otp_pool);  return 0;}

int main2(int argc, char **argv) {	InitializeCriticalSection(&mutex);	EnterCriticalSection(&mutex);#endif	if(!detach())		return 1;#ifdef HAVE_MLOCKALL	/* Lock all pages into memory if requested.	 * This has to be done after daemon()/fork() so it works for child.	 * No need to do that in parent as it's very short-lived. */	if(do_mlock && mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {		logger(LOG_ERR, "System call `%s' failed: %s", "mlockall",		   strerror(errno));		return 1;	}#endif	/* Setup sockets and open device. */	if(!setup_network())		goto end;	/* Initiate all outgoing connections. */	try_outgoing_connections();	/* Change process priority */        char *priority = 0;        if(get_config_string(lookup_config(config_tree, "ProcessPriority"), &priority)) {                if(!strcasecmp(priority, "Normal")) {                        if (setpriority(NORMAL_PRIORITY_CLASS) != 0) {                                logger(LOG_ERR, "System call `%s' failed: %s",                                       "setpriority", strerror(errno));                                goto end;                        }                } else if(!strcasecmp(priority, "Low")) {                        if (setpriority(BELOW_NORMAL_PRIORITY_CLASS) != 0) {                                       logger(LOG_ERR, "System call `%s' failed: %s",                                       "setpriority", strerror(errno));                                goto end;                        }                } else if(!strcasecmp(priority, "High")) {                        if (setpriority(HIGH_PRIORITY_CLASS) != 0) {                                logger(LOG_ERR, "System call `%s' failed: %s",                                       "setpriority", strerror(errno));                                goto end;                        }                } else {                        logger(LOG_ERR, "Invalid priority `%s`!", priority);                        goto end;                }        }	/* drop privileges */	if (!drop_privs())		goto end;	/* Start main loop. It only exits when tinc is killed. */	status = main_loop();	/* Shutdown properly. */	ifdebug(CONNECTIONS)		dump_device_stats();	close_network_connections();end:	logger(LOG_NOTICE, "Terminating");#ifndef HAVE_MINGW	remove_pid(pidfilename);#endif	EVP_cleanup();	ENGINE_cleanup();	CRYPTO_cleanup_all_ex_data();	ERR_remove_state(0);	ERR_free_strings();	exit_configuration(&config_tree);	free_names();	return status;}

void crypto_deinit(){    EVP_cleanup();    ERR_free_strings();}

void free_openssl(){    RAND_cleanup();    ERR_free_strings();}

jint Java_org_keysupport_provider_ECDSASignature_jniVerifyFinal(JNIEnv *env,		jobject obj, jbyteArray jmsg, jint jmdid, jbyteArray jsig) {//	LOGD("entering ECDSASignature_jniVerifyFinal");	EC_Ctx *ec;	EVP_MD_CTX *ctx = 0;	const EVP_MD *md;	jsize msgLen = 0;	jsize sigLen = 0;	const unsigned char *sig_ptr = NULL;	if (!(ec = get_ptr(env, obj))) {		LOGE("Failed to obtain key pointer");		return 0;	}	if (!(ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX)))) {		throw_exception(env, "java/lang/RuntimeException",				"allocating EVP_MD_CTX");		destroy_ec_ctx(ec);		FIPS_md_ctx_destroy(ctx);		return 0;	}	md = FIPS_get_digestbynid(jmdid);	ctx = EVP_MD_CTX_create();	msgLen = (*env)->GetArrayLength(env, jmsg);	sigLen = (*env)->GetArrayLength(env, jsig);	jbyte msg[msgLen];	jbyte sig[sigLen];	(*env)->GetByteArrayRegion(env, jmsg, 0, msgLen, msg);	(*env)->GetByteArrayRegion(env, jsig, 0, sigLen, sig);	sig_ptr = sig;	ECDSA_SIG *esig = d2i_ECDSA_SIG(NULL, &sig_ptr, sigLen);	FIPS_digestinit(ctx, md);	int ok = FIPS_ecdsa_verify(ec->ec, msg, msgLen, md, esig);	/*	 * This is handled a bit differently than the way OpenSSL	 * handles RSA Signatures, so our error handling below is a bit different.	 *	 *  returns	 *      1: correct signature	 *      0: incorrect signature	 *     -1: error	 *///	LOGD("FIPS_ecdsa_verify Returned: %d/n", ok);	FIPS_md_ctx_destroy(ctx);	FIPS_ecdsa_sig_free(esig);	if (ok == 0) {		throw_exception(env, "java/security/SignatureException",				"Bad Signature");		return 0;	} else if (ok == -1) {		/*		 * TODO:  Print any pending errors		 * ERR_print_errors_fp(ANDROID_LOG_ERROR);		 */		ERR_load_crypto_strings();		LOGE("%s", ERR_error_string(ERR_peek_error(), NULL));		throw_exception(env, "java/security/SignatureException",				"jniVerifyFinal fail");		ERR_free_strings();		return 0;	}//	LOGD("leaving ECDSASignature_jniVerifyFinal");	return ok;}

int main(int argc, char **argv){	int ret;	struct server_settings settings;	// load arguments	ret = parse_server_settings(argc, (char **) argv, &settings);	if (is_failure(ret))	{		print_usage;		return ret;	}	int sock;	SSL_CTX *ssl_ctx;	SSL *ssl;	pthread_t thread_id;	struct client client = {&settings, NULL};	// init ssl	if (is_failure(init_ssl(&ssl_ctx, NULL, settings.cert_path, settings.key_path)))		goto GENERAL_CLEAN_UP;	sock = create_server_socket(settings.port);	printf("Listening on port %d/n", settings.port);	register_signal_handler();	while (server_running)	{		struct sockaddr_in addr;		uint len = sizeof addr;		int client_sock = accept(sock, (struct sockaddr *) &addr, &len);		if (client_sock < 0)		{			// not clean			if (server_running)			{				error_print("Failed to accept client connection/n");				ret = ERROR_SOCKET;			}			break;		}		puts("Client connected");		if (is_failure(accept_ssl(ssl_ctx, &ssl, client_sock)))			continue;		// spawn thread		client.ssl = ssl;		if (pthread_create(&thread_id, NULL, client_handler, (void *) &client) < 0)			error_print("Failed to spawn client thread/n");	}GENERAL_CLEAN_UP:	puts("/nCleaning up");	if (ssl_ctx != NULL)		SSL_CTX_free(ssl_ctx);	ERR_free_strings();	EVP_cleanup();	return ret;}

//.........这里部分代码省略.........	if (bev == NULL) {		fprintf(stderr, "bufferevent_openssl_socket_new() failed/n");		goto error;	}	bufferevent_openssl_set_allow_dirty_shutdown(bev, 1);	// For simplicity, we let DNS resolution block. Everything else should be	// asynchronous though.	evcon = evhttp_connection_base_bufferevent_new(base, NULL, bev,		host, port);	if (evcon == NULL) {		fprintf(stderr, "evhttp_connection_base_bufferevent_new() failed/n");		goto error;	}	if (retries > 0) {		evhttp_connection_set_retries(evcon, retries);	}	if (timeout >= 0) {		evhttp_connection_set_timeout(evcon, timeout);	}	// Fire off the request	req = evhttp_request_new(http_request_done, bev);	if (req == NULL) {		fprintf(stderr, "evhttp_request_new() failed/n");		goto error;	}	output_headers = evhttp_request_get_output_headers(req);	evhttp_add_header(output_headers, "Host", host);	evhttp_add_header(output_headers, "Connection", "close");	if (data_file) {		/* NOTE: In production code, you'd probably want to use		 * evbuffer_add_file() or evbuffer_add_file_segment(), to		 * avoid needless copying. */		FILE * f = fopen(data_file, "rb");		char buf[1024];		size_t s;		size_t bytes = 0;		if (!f) {			syntax();			goto error;		}		output_buffer = evhttp_request_get_output_buffer(req);		while ((s = fread(buf, 1, sizeof(buf), f)) > 0) {			evbuffer_add(output_buffer, buf, s);			bytes += s;		}		evutil_snprintf(buf, sizeof(buf)-1, "%lu", (unsigned long)bytes);		evhttp_add_header(output_headers, "Content-Length", buf);		fclose(f);	}	r = evhttp_make_request(evcon, req, data_file ? EVHTTP_REQ_POST : EVHTTP_REQ_GET, uri);	if (r != 0) {		fprintf(stderr, "evhttp_make_request() failed/n");		goto error;	}	event_base_dispatch(base);	goto cleanup;error:	ret = 1;cleanup:	if (evcon)		evhttp_connection_free(evcon);	if (http_uri)		evhttp_uri_free(http_uri);	event_base_free(base);	if (ssl_ctx)		SSL_CTX_free(ssl_ctx);	if (type == HTTP && ssl)		SSL_free(ssl);#if OPENSSL_VERSION_NUMBER < 0x10100000L	EVP_cleanup();	ERR_free_strings();#ifdef EVENT__HAVE_ERR_REMOVE_THREAD_STATE	ERR_remove_thread_state(NULL);#else	ERR_remove_state(0);#endif	CRYPTO_cleanup_all_ex_data();	sk_SSL_COMP_free(SSL_COMP_get_compression_methods());#endif /*OPENSSL_VERSION_NUMBER < 0x10100000L */#ifdef _WIN32	WSACleanup();#endif	return ret;}