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

int sthreads_init(void) {    int i;    /* initialize stunnel critical sections */    for(i=0; i<CRIT_SECTIONS; i++)        pthread_mutex_init(stunnel_cs+i, NULL);    /* initialize OpenSSL locking callback */    lock_cs=str_alloc_detached(                (size_t)CRYPTO_num_locks()*sizeof(pthread_mutex_t));    for(i=0; i<CRYPTO_num_locks(); i++)        pthread_mutex_init(lock_cs+i, NULL);#if OPENSSL_VERSION_NUMBER>=0x10000000L    CRYPTO_THREADID_set_callback(threadid_func);#else    CRYPTO_set_id_callback(stunnel_thread_id);#endif    CRYPTO_set_locking_callback(locking_callback);    /* initialize OpenSSL dynamic locks callbacks */    CRYPTO_set_dynlock_create_callback(dyn_create_function);    CRYPTO_set_dynlock_lock_callback(dyn_lock_function);    CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);    return 0;}

voidtor_init (void){	if (initialized) {		return;	}	ERR_load_crypto_strings();	OpenSSL_add_all_algorithms();	// enable proper threading	locks.length = CRYPTO_num_locks();	locks.item   = malloc(locks.length * sizeof(uv_mutex_t));	for (size_t i = 0; i < locks.length; i++) {		uv_mutex_init(&locks.item[i]);	}	CRYPTO_set_locking_callback(_locking_callback);	CRYPTO_set_id_callback(uv_thread_self);	CRYPTO_set_dynlock_create_callback(_dynlock_create_callback);	CRYPTO_set_dynlock_lock_callback(_dynlock_lock_callback);	CRYPTO_set_dynlock_destroy_callback(_dynlock_destroy_callback);	ENGINE_load_builtin_engines();	ENGINE_register_all_complete();	initialized = true;}

/* * Bring down the OpenSSL subsystem */static BOOL server_destroy_ssl( Remote * remote ){	int i = 0;	if( remote == NULL )		return FALSE;	dprintf("[SERVER] Destroying SSL");	lock_acquire( remote->lock );	SSL_free( remote->ssl );		SSL_CTX_free( remote->ctx );	CRYPTO_set_locking_callback( NULL );	CRYPTO_set_id_callback( NULL );	CRYPTO_set_dynlock_create_callback( NULL );	CRYPTO_set_dynlock_lock_callback( NULL );	CRYPTO_set_dynlock_destroy_callback( NULL );	for( i=0 ; i<CRYPTO_num_locks() ; i++ )		lock_destroy( ssl_locks[i] );			free( ssl_locks );	lock_release( remote->lock );	return TRUE;}

void SSLContext::initializeOpenSSLLocked() {  if (initialized_) {    return;  }  SSL_library_init();  SSL_load_error_strings();  ERR_load_crypto_strings();  // static locking  locks.reset(new SSLLock[::CRYPTO_num_locks()]);  for (auto it: lockTypes) {    locks[it.first].lockType = it.second;  }  CRYPTO_set_id_callback(callbackThreadID);  CRYPTO_set_locking_callback(callbackLocking);  // dynamic locking  CRYPTO_set_dynlock_create_callback(dyn_create);  CRYPTO_set_dynlock_lock_callback(dyn_lock);  CRYPTO_set_dynlock_destroy_callback(dyn_destroy);  randomize();#ifdef OPENSSL_NPN_NEGOTIATED  sNextProtocolsExDataIndex_ = SSL_get_ex_new_index(0,      (void*)"Advertised next protocol index", nullptr, nullptr, nullptr);#endif  initialized_ = true;}

intThread_cleanup(void){#ifdef _USE_OPENSSL  int i;  if (!mutex_buf)    return 0;  CRYPTO_set_id_callback(NULL);  CRYPTO_set_locking_callback(NULL);#ifdef _DYNAMIC_LOCKING_MECHANISM_  CRYPTO_set_dynlock_create_callback(NULL);  CRYPTO_set_dynlock_lock_callback(NULL);  CRYPTO_set_dynlock_destroy_callback(NULL);#endif  for (i=0 ; i < CRYPTO_num_locks(); i++)    MUTEX_CLEANUP(mutex_buf[i]);  mutex_buf = NULL ;  return 1;#else  return -1;#endif}

void OpenSSLInitializer::initialize(){	Poco::FastMutex::ScopedLock lock(_mutex);		if (++_rc == 1)	{#if OPENSSL_VERSION_NUMBER >= 0x0907000L		OPENSSL_config(NULL);#endif		SSL_library_init();		SSL_load_error_strings();		OpenSSL_add_all_algorithms();				char seed[SEEDSIZE];		RandomInputStream rnd;		rnd.read(seed, sizeof(seed));		RAND_seed(seed, SEEDSIZE);				int nMutexes = CRYPTO_num_locks();		_mutexes = new Poco::FastMutex[nMutexes];		CRYPTO_set_locking_callback(&OpenSSLInitializer::lock);#ifndef POCO_OS_FAMILY_WINDOWS // SF# 1828231: random unhandled exceptions when linking with ssl		CRYPTO_set_id_callback(&OpenSSLInitializer::id);#endif		CRYPTO_set_dynlock_create_callback(&OpenSSLInitializer::dynlockCreate);		CRYPTO_set_dynlock_lock_callback(&OpenSSLInitializer::dynlock);		CRYPTO_set_dynlock_destroy_callback(&OpenSSLInitializer::dynlockDestroy);	}}

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}

int sthreads_init(void) {    int i;    /* initialize OpenSSL dynamic locks callbacks */    CRYPTO_set_dynlock_create_callback(dyn_create_function);    CRYPTO_set_dynlock_lock_callback(dyn_lock_function);    CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);    /* initialize stunnel critical sections */    for(i=0; i<STUNNEL_LOCKS; i++)        stunnel_locks[i]=CRYPTO_get_new_dynlockid();    /* initialize OpenSSL locking callback */    lock_cs=str_alloc_detached(        (size_t)CRYPTO_num_locks()*sizeof(struct CRYPTO_dynlock_value));    for(i=0; i<CRYPTO_num_locks(); i++)        pthread_rwlock_init(&lock_cs[i].rwlock, NULL);#if OPENSSL_VERSION_NUMBER>=0x10000000L    CRYPTO_THREADID_set_callback(threadid_func);#else    CRYPTO_set_id_callback(stunnel_thread_id);#endif    CRYPTO_set_locking_callback(locking_callback);    return 0;}

/*! * @brief Initialize the OpenSSL subsystem for use in a multi threaded enviroment. * @param transport Pointer to the transport instance. * @return Indication of success or failure. */static BOOL server_initialize_ssl(Transport* transport) {	int i;	lock_acquire(transport->lock);	// Begin to bring up the OpenSSL subsystem...	CRYPTO_malloc_init();	SSL_load_error_strings();	SSL_library_init();	// Setup the required OpenSSL multi-threaded enviroment...	ssl_locks = malloc(CRYPTO_num_locks() * sizeof(LOCK *));	if (ssl_locks == NULL) {			dprintf("[SSL INIT] failed to allocate locks (%d locks)", CRYPTO_num_locks());		lock_release(transport->lock);		return FALSE;	}	for (i = 0; i < CRYPTO_num_locks(); i++) {		ssl_locks[i] = lock_create();	}	CRYPTO_set_id_callback(server_threadid_callback);	CRYPTO_set_locking_callback(server_locking_callback);	CRYPTO_set_dynlock_create_callback(server_dynamiclock_create);	CRYPTO_set_dynlock_lock_callback(server_dynamiclock_lock);	CRYPTO_set_dynlock_destroy_callback(server_dynamiclock_destroy);	lock_release(transport->lock);	return TRUE;}

static rfbBoolInitializeTLS(void){  int i;  if (rfbTLSInitialized) return TRUE;  mutex_buf = malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));  if (mutex_buf == NULL) {    rfbClientLog("Failed to initialized OpenSSL: memory./n");    return (-1);  }  for (i = 0; i < CRYPTO_num_locks(); i++)    pthread_mutex_init(&mutex_buf[i], NULL);  CRYPTO_set_locking_callback(locking_function);  CRYPTO_set_id_callback(id_function);  CRYPTO_set_dynlock_create_callback(dyn_create_function);  CRYPTO_set_dynlock_lock_callback(dyn_lock_function);  CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);  SSL_load_error_strings();  SSLeay_add_ssl_algorithms();  RAND_load_file("/dev/urandom", 1024);  rfbClientLog("OpenSSL initialized./n");  rfbTLSInitialized = TRUE;  return TRUE;}

/* * Initialize OpenSSL thread support *  Returns: 0 on success *           errno on failure */int openssl_init_threads (void){   int i, numlocks;   int status;   /* Set thread ID callback */   CRYPTO_set_id_callback(get_openssl_thread_id);   /* Initialize static locking */   numlocks = CRYPTO_num_locks();   mutexes = (pthread_mutex_t *) malloc(numlocks * sizeof(pthread_mutex_t));   for (i = 0; i < numlocks; i++) {      if ((status = pthread_mutex_init(&mutexes[i], NULL)) != 0) {         berrno be;         Jmsg1(NULL, M_FATAL, 0, _("Unable to init mutex: ERR=%s/n"), be.bstrerror(status));         return status;      }   }   /* Set static locking callback */   CRYPTO_set_locking_callback(openssl_update_static_mutex);   /* Initialize dyanmic locking */   CRYPTO_set_dynlock_create_callback(openssl_create_dynamic_mutex);   CRYPTO_set_dynlock_lock_callback(openssl_update_dynamic_mutex);   CRYPTO_set_dynlock_destroy_callback(openssl_destroy_dynamic_mutex);   return 0;}

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

void ssl_util_thread_setup(apr_pool_t *p){    int i;    lock_num_locks = CRYPTO_num_locks();    lock_cs = apr_palloc(p, lock_num_locks * sizeof(*lock_cs));    for (i = 0; i < lock_num_locks; i++) {        apr_thread_mutex_create(&(lock_cs[i]), APR_THREAD_MUTEX_DEFAULT, p);    }    CRYPTO_set_id_callback(ssl_util_thr_id);    CRYPTO_set_locking_callback(ssl_util_thr_lock);    /* Set up dynamic locking scaffolding for OpenSSL to use at its     * convenience.     */    dynlockpool = p;    CRYPTO_set_dynlock_create_callback(ssl_dyn_create_function);    CRYPTO_set_dynlock_lock_callback(ssl_dyn_lock_function);    CRYPTO_set_dynlock_destroy_callback(ssl_dyn_destroy_function);    apr_pool_cleanup_register(p, NULL, ssl_util_thread_cleanup,                                       apr_pool_cleanup_null);}

CAMLprim value ocaml_ssl_init(value use_threads){  int i;  SSL_library_init();  SSL_load_error_strings();  if(Int_val(use_threads))  {#ifdef WIN32    mutex_buf = malloc(CRYPTO_num_locks() * sizeof(HANDLE));#else    mutex_buf = malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));#endif    assert(mutex_buf);    for (i = 0; i < CRYPTO_num_locks(); i++)#ifdef WIN32      mutex_buf[i] = CreateMutex(NULL, FALSE, NULL);#else      pthread_mutex_init(&mutex_buf[i], NULL);#endif    CRYPTO_set_locking_callback(locking_function);#ifndef WIN32    /* Windows does not require id_function, see threads(3) */    CRYPTO_set_id_callback(id_function);#endif    CRYPTO_set_dynlock_create_callback(dyn_create_function);    CRYPTO_set_dynlock_lock_callback(dyn_lock_function);    CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);  }  return Val_unit;}

	void start() {		PlatformSpecific::ThirdParty::start();		if (!RAND_status()) { // should be always inited in all modern OS			char buf[16];			memcpy(buf, &_msStart, 8);			memcpy(buf + 8, &_msFreq, 8);			uchar sha256Buffer[32];			RAND_seed(hashSha256(buf, 16, sha256Buffer), 32);			if (!RAND_status()) {				LOG(("MTP Error: Could not init OpenSSL rand, RAND_status() is 0.."));			}		}		int32 numLocks = CRYPTO_num_locks();		if (numLocks) {			_sslLocks = new QMutex[numLocks];			CRYPTO_set_locking_callback(_sslLockingCallback);		} else {			LOG(("MTP Error: Could not init OpenSSL threads, CRYPTO_num_locks() returned zero!"));		}		CRYPTO_THREADID_set_callback(_sslThreadId);		CRYPTO_set_dynlock_create_callback(_sslCreateFunction);		CRYPTO_set_dynlock_lock_callback(_sslLockFunction);		CRYPTO_set_dynlock_destroy_callback(_sslDestroyFunction);		av_register_all();		avcodec_register_all();		av_lockmgr_register(_ffmpegLockManager);		_sslInited = true;	}

/*! * @brief Bring down the OpenSSL subsystem * @param transport Pointer to the transport instance. * @return Indication of success or failure. */static BOOL server_destroy_ssl(Transport* transport) {	TcpTransportContext* ctx = NULL;	int i;	if (transport) {		dprintf("[SERVER] Destroying SSL");		lock_acquire(transport->lock);		if (transport && transport->ctx) {			ctx = (TcpTransportContext*)transport->ctx;			SSL_free(ctx->ssl);			SSL_CTX_free(ctx->ctx);		}		CRYPTO_set_locking_callback(NULL);		CRYPTO_set_id_callback(NULL);		CRYPTO_set_dynlock_create_callback(NULL);		CRYPTO_set_dynlock_lock_callback(NULL);		CRYPTO_set_dynlock_destroy_callback(NULL);		for (i = 0; i < CRYPTO_num_locks(); i++) {			lock_destroy(ssl_locks[i]);		}		free(ssl_locks);		lock_release(transport->lock);	}	return TRUE;}

boolSSLSocketServer::SSL_Init(){	int nLockCt = CRYPTO_num_locks();	InitializeCryptoLocks(nLockCt);#ifdef _DEBUG    CRYPTO_malloc_debug_init();    CRYPTO_dbg_set_options	(V_CRYPTO_MDEBUG_ALL);    CRYPTO_mem_ctrl			(CRYPTO_MEM_CHECK_ON);#endif		CRYPTO_set_locking_callback			(&ssl_lock_callback);    CRYPTO_set_dynlock_create_callback	(&ssl_lock_dyn_create_callback);	CRYPTO_set_dynlock_lock_callback	(&ssl_lock_dyn_callback);    CRYPTO_set_dynlock_destroy_callback	(&ssl_lock_dyn_destroy_callback);    SSL_load_error_strings	();    SSL_library_init		();	// Initialize and verify SSL context. {{	const SSL_METHOD* meth = SSLv23_method();	m_pssl_ctx = SSL_CTX_new(meth);	SSL_CTX_set_verify(m_pssl_ctx, SSL_VERIFY_NONE, nullptr);	// }}	::InitializeCriticalSection(&m_lock_connect_ex);	return true;	}

void OpenSSLInitializer::uninitialize(){	if (--_rc == 0)	{        if(_mutexes != NULL) {		    CRYPTO_set_dynlock_create_callback(0);		    CRYPTO_set_dynlock_lock_callback(0);		    CRYPTO_set_dynlock_destroy_callback(0);		    CRYPTO_set_locking_callback(0);#ifndef POCO_OS_FAMILY_WINDOWS#ifndef OPENSSL_NO_DEPRECATED		    CRYPTO_set_id_callback(0);#else		    CRYPTO_THREADID tid;		    CRYPTO_THREADID_set_numeric(&tid, 0);#endif /* OPENSSL_NO_DEPRECATED */#endif		    delete [] _mutexes;		}        if(! _disableSSLInitialization) {    		EVP_cleanup();	    	ERR_free_strings();    		CONF_modules_free();        }	}}

CSSLInitializer::CSSLInitializer(){#if OPENSSL_VERSION_NUMBER < OPENSSL_VERSION_1_1_0	sm_iLockNum = CRYPTO_num_locks();	if(sm_iLockNum > 0)		sm_pcsLocks = new CSimpleRWLock[sm_iLockNum];/*#ifdef _DEBUG	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);#endif*/	CRYPTO_set_locking_callback			(&ssl_lock_callback);	CRYPTO_set_dynlock_create_callback	(&ssl_lock_dyn_create_callback);	CRYPTO_set_dynlock_destroy_callback	(&ssl_lock_dyn_destroy_callback);	CRYPTO_set_dynlock_lock_callback	(&ssl_lock_dyn_callback);	SSL_library_init();	SSL_load_error_strings();	OpenSSL_add_all_algorithms();#else	OPENSSL_init_ssl(OPENSSL_INIT_SSL_DEFAULT, nullptr);#endif}

void OpenSSL::ClassInit() {	MS_TRACE();	MS_DEBUG("loaded openssl version: %s", SSLeay_version(SSLEAY_VERSION));	// First initialize OpenSSL stuff.	SSL_load_error_strings();	SSL_library_init();	RAND_poll();	// Make OpenSSL thread-safe.	OpenSSL::mutexes = new pthread_mutex_t[CRYPTO_num_locks()];	if (! OpenSSL::mutexes)		MS_THROW_ERROR("allocation of mutexes failed");	OpenSSL::numMutexes = CRYPTO_num_locks();	for (int i=0; i<OpenSSL::numMutexes; i++) {		int err = pthread_mutex_init(&OpenSSL::mutexes[i], nullptr);		if (err)			MS_THROW_ERROR("pthread_mutex_init() failed with return code %d/n", err);	}	CRYPTO_THREADID_set_callback(OpenSSL::SetThreadId);	CRYPTO_set_locking_callback(OpenSSL::LockingFunction);	CRYPTO_set_dynlock_create_callback(OpenSSL::DynCreateFunction);	CRYPTO_set_dynlock_lock_callback(OpenSSL::DynLockFunction);	CRYPTO_set_dynlock_destroy_callback(OpenSSL::DynDestroyFunction);}

void manager::init(actor_system_config&) {  CAF_LOG_TRACE("");  ERR_load_crypto_strings();  OPENSSL_add_all_algorithms_conf();  SSL_library_init();  SSL_load_error_strings();  if (authentication_enabled()) {    if (system().config().openssl_certificate.size() == 0)      CAF_RAISE_ERROR("No certificate configured for SSL endpoint");    if (system().config().openssl_key.size() == 0)      CAF_RAISE_ERROR("No private key configured for SSL endpoint");  }#if OPENSSL_VERSION_NUMBER < 0x10100000L  std::lock_guard<std::mutex> lock{init_mutex};  ++init_count;  if (init_count == 1) {    mutexes = std::vector<std::mutex>(CRYPTO_num_locks());    CRYPTO_set_locking_callback(locking_function);    CRYPTO_set_dynlock_create_callback(dynlock_create);    CRYPTO_set_dynlock_lock_callback(dynlock_lock);    CRYPTO_set_dynlock_destroy_callback(dynlock_destroy);    // OpenSSL's default thread ID callback should work, so don't set our own.  }#endif}

void _ssl_init() {	// check if ssl already initialized	int num_locks;	int i;	if (g_ssl_locks != NULL) {		return;	}	num_locks = CRYPTO_num_locks();	g_ssl_locks = _memory_malloc(sizeof(int *)*num_locks);	if (g_ssl_locks == NULL) {		return;	}	for (i = 0; i < num_locks; ++i) {		_tr50_mutex_create(&(g_ssl_locks[i]));	}	CRYPTO_set_id_callback(_id_function);	CRYPTO_set_locking_callback(_locking_function);	CRYPTO_set_dynlock_create_callback(_dyn_create_function);	CRYPTO_set_dynlock_lock_callback(_dyn_lock_function);	CRYPTO_set_dynlock_destroy_callback(_dyn_destroy_function);	SSL_library_init();	SSL_load_error_strings();	//random_init();	return;}

intThread_setup(void){#ifdef _USE_OPENSSL  int i;  mutex_buf = (MUTEX_TYPE *)malloc(sizeof(MUTEX_TYPE) * CRYPTO_num_locks());  if(!mutex_buf)    return 0;  for ( i = 0 ; i < CRYPTO_num_locks() ; i++)    MUTEX_SETUP(mutex_buf[i]);  CRYPTO_set_id_callback(id_function);  CRYPTO_set_locking_callback(locking_function);  /*  **  Dynamic locking routine registration  **/#ifdef _DYNAMIC_LOCKING_MECHANISM_  CRYPTO_set_dynlock_create_callback(dyn_create_function);  CRYPTO_set_dynlock_lock_callback(dyn_lock_function);  CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);#endif  return 1;#else  return -1;#endif}

/** * thread_cleanup * * Clean up multi-thread protection used by the SSL library. * * Note that this function is not currently used because there is no shutdown * code for plugins.  It is left here in case that happens in the future. * * Return value: 0 for success, -1 for failure (though it currently can't fail) **/static int	thread_cleanup(void){	int		i;	/* Nullify the locking functions we registered with the SSL library */	CRYPTO_set_id_callback(NULL);	CRYPTO_set_locking_callback(NULL);	CRYPTO_set_dynlock_create_callback(NULL);	CRYPTO_set_dynlock_lock_callback(NULL);	CRYPTO_set_dynlock_destroy_callback(NULL);	/* Clean up and destroy mutexes, if we have any */	g_static_mutex_lock(&ssl_mutexes);	if (mutexes) {		for (i = 0; i < CRYPTO_num_locks(); i++) {			if (mutexes[i]) {				g_mutex_free(mutexes[i]);			}		}		g_free(mutexes);		mutexes = NULL;	}	g_static_mutex_free(&ssl_mutexes);	return(0);			/* No errors */}

int tls_init_multithread(void){	/* init static locks support */	tls_static_locks_no = CRYPTO_num_locks();	if (tls_static_locks_no>0) {		/* init a lock set & pass locking function to SSL */		tls_static_locks = lock_set_alloc(tls_static_locks_no);		if (tls_static_locks == NULL) {			LM_ERR("Failed to alloc static locks/n");			return -1;		}		if (lock_set_init(tls_static_locks)==0) {				LM_ERR("Failed to init static locks/n");				lock_set_dealloc(tls_static_locks);				return -1;		}		CRYPTO_set_locking_callback(tls_static_locks_ops);	}	CRYPTO_set_id_callback(tls_get_id);	/* dynamic locks support*/	CRYPTO_set_dynlock_create_callback(tls_dyn_lock_create);	CRYPTO_set_dynlock_lock_callback(tls_dyn_lock_ops);	CRYPTO_set_dynlock_destroy_callback(tls_dyn_lock_destroy);	return 0;}

void initialize(){    Mutex::ScopedLock lock(_mutex);        if (++_refCount == 1)    {#if OPENSSL_VERSION_NUMBER >= 0x0907000L        OPENSSL_config(NULL);#endif        SSL_library_init();        SSL_load_error_strings();        OpenSSL_add_all_algorithms();                char seed[SEEDSIZE];        Random::getSeed(seed, sizeof(seed));        RAND_seed(seed, SEEDSIZE);                int nMutexes = CRYPTO_num_locks();        _mutexes = new Mutex[nMutexes];        CRYPTO_set_locking_callback(&internal::lock);// #ifndef WIN32 // SF# 1828231: random unhandled exceptions when linking with ssl//         CRYPTO_set_id_callback(&internal::id);// #endif        CRYPTO_set_dynlock_create_callback(&internal::dynlockCreate);        CRYPTO_set_dynlock_lock_callback(&internal::dynlock);        CRYPTO_set_dynlock_destroy_callback(&internal::dynlockDestroy);    }}

/* * Initialize the OpenSSL subsystem for use in a multi threaded enviroment. */static BOOL server_initialize_ssl( Remote * remote ){	int i = 0;	lock_acquire( remote->lock );	// Begin to bring up the OpenSSL subsystem...	CRYPTO_malloc_init();	SSL_load_error_strings();	SSL_library_init();	// Setup the required OpenSSL multi-threaded enviroment...	ssl_locks = (LOCK**)malloc( CRYPTO_num_locks() * sizeof(LOCK *) );	if( ssl_locks == NULL )	{		lock_release( remote->lock );		return FALSE;	}	for( i=0 ; i<CRYPTO_num_locks() ; i++ )		ssl_locks[i] = lock_create();	CRYPTO_set_id_callback( server_threadid_callback );	CRYPTO_set_locking_callback( server_locking_callback );	CRYPTO_set_dynlock_create_callback( server_dynamiclock_create );	CRYPTO_set_dynlock_lock_callback( server_dynamiclock_lock );	CRYPTO_set_dynlock_destroy_callback( server_dynamiclock_destroy  ); 	lock_release( remote->lock );	return TRUE;}

/*================================================================================	Function	:initSSLThreadMutex	Input		:void	Output		:void	Return		:int				 < status >	Description	:initialize mutexes for ssl thread safe================================================================================*/static int initSSLThreadMutex( void ){	int		i;	int		result;	mutex_locks = ( pthread_mutex_t* )malloc( CRYPTO_num_locks( ) *											   sizeof( pthread_mutex_t ) );		if( !mutex_locks )	{		return( -1 );	}		for( i = 0 ; i < CRYPTO_num_locks( ) ; i++ )	{		if( ( result = pthread_mutex_init( &( mutex_locks[ i ] ), NULL ) ) < 0 )		{			return( result );		}	}	if( ( result = CRYPTO_THREADID_set_callback( getThreadId ) ) < 0 )	{		return( result );	}	CRYPTO_set_locking_callback( lockSSLThreadMutex );	CRYPTO_set_dynlock_create_callback( createSSLDynamicThreadMutex );	CRYPTO_set_dynlock_lock_callback( lockSSLDynamicThreadMutex );	CRYPTO_set_dynlock_destroy_callback( destroySSLDynamicThreadMutex );	return( 0 );}

static void Init_ossl_locks(void){    int i;    int num_locks = CRYPTO_num_locks();    if ((unsigned)num_locks >= INT_MAX / (int)sizeof(VALUE)) {	rb_raise(rb_eRuntimeError, "CRYPTO_num_locks() is too big: %d", num_locks);    }    ossl_locks = (rb_nativethread_lock_t *) OPENSSL_malloc(num_locks * (int)sizeof(rb_nativethread_lock_t));    if (!ossl_locks) {	rb_raise(rb_eNoMemError, "CRYPTO_num_locks() is too big: %d", num_locks);    }    for (i = 0; i < num_locks; i++) {	rb_nativethread_lock_initialize(&ossl_locks[i]);    }#ifdef HAVE_CRYPTO_THREADID_PTR    CRYPTO_THREADID_set_callback(ossl_threadid_func);#else    CRYPTO_set_id_callback(ossl_thread_id);#endif    CRYPTO_set_locking_callback(ossl_lock_callback);    CRYPTO_set_dynlock_create_callback(ossl_dyn_create_callback);    CRYPTO_set_dynlock_lock_callback(ossl_dyn_lock_callback);    CRYPTO_set_dynlock_destroy_callback(ossl_dyn_destroy_callback);}

void BaseSSLConfig::uninit_ssl() {    CRYPTO_set_locking_callback(NULL);    CRYPTO_set_dynlock_create_callback(NULL);    CRYPTO_set_dynlock_lock_callback(NULL);    CRYPTO_set_dynlock_destroy_callback(NULL);    EVP_cleanup();    CRYPTO_cleanup_all_ex_data();    ERR_remove_state(0);    ERR_free_strings();    if (NULL != ssl_locks) {        for (int n = 0; n < number_of_locks; ++n)            DeleteCriticalSection(&ssl_locks[n]);        free(ssl_locks);        ssl_locks = NULL;        number_of_locks = 0;    }    if(m_rootcert != NULL) {        X509_free(m_rootcert);        m_rootcert=NULL;    }    if(m_rootkeypair != NULL) {        EVP_PKEY_free(m_rootkeypair);        m_rootkeypair=NULL;    }    m_status = STATUS_UNINIT;}