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

void thread_cleanup (){#ifndef HAVE_CLIENT  if (!mutex_buf) return;  CRYPTO_set_id_callback (NULL);  CRYPTO_set_locking_callback (NULL);  int i;  for (i = 0;  i < CRYPTO_num_locks ();  i++)    MUTEX_CLEANUP (mutex_buf[i]);  free (mutex_buf);  mutex_buf = NULL;#endif}

static voidinit_openssl(void){    int i;    openssl_mutex_array = g_new0(GMutex *, CRYPTO_num_locks());    for (i=0; i<CRYPTO_num_locks(); i++) {	openssl_mutex_array[i] = g_mutex_new();    }    CRYPTO_set_locking_callback(openssl_lock_callback);}

static void init_openssl_locking(){  gint i;  // initialize OpenSSL locking for multi-threaded operation  openssl_mutexes = g_new(GMutex*, CRYPTO_num_locks());  for (i = 0; i < CRYPTO_num_locks(); i++)    openssl_mutexes[i] = g_mutex_new();  SSL_library_init();  CRYPTO_set_id_callback(openssl_thread_id_callback);  CRYPTO_set_locking_callback(openssl_locking_callback);}

CWBool CWSecurityInitLib() {	int i;	SSL_load_error_strings();	SSL_library_init();	/* setup mutexes for openssl internal locking */	CW_CREATE_ARRAY_ERR(mutexOpensslBuf,			    CRYPTO_num_locks() * sizeof(CWThreadMutex),			    CWThreadMutex,			    return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, 				    		"Cannot create openssl mutexes");)

/** * Creates the given number of mutexes, such that OpenSSL will have at least * this number of mutexes at its disposal. * * @param count *     The number of mutexes (locks) to create. */static void guac_common_ssh_openssl_init_locks(int count) {    int i;    /* Allocate required number of locks */    guac_common_ssh_openssl_locks =        malloc(sizeof(pthread_mutex_t) * CRYPTO_num_locks());    /* Initialize each lock */    for (i=0; i < count; i++)        pthread_mutex_init(&(guac_common_ssh_openssl_locks[i]), NULL);}

void utils::initialize_ssl_implementation(void) {#if HAVE_OPENSSL	openssl_mutexes_size = CRYPTO_num_locks();	openssl_mutexes = new mutex[openssl_mutexes_size];	CRYPTO_set_id_callback(openssl_mth_id_function);	CRYPTO_set_locking_callback(openssl_mth_locking_function);#endif#if HAVE_GCRYPT	gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);	gnutls_global_init();#endif}

void ff_openssl_init(void){    avpriv_lock_avformat();    if (!openssl_init) {        SSL_library_init();        SSL_load_error_strings();#if HAVE_THREADS        if (!CRYPTO_get_locking_callback()) {            int i;            openssl_mutexes = av_malloc(sizeof(pthread_mutex_t) * CRYPTO_num_locks());            for (i = 0; i < CRYPTO_num_locks(); i++)                pthread_mutex_init(&openssl_mutexes[i], NULL);            CRYPTO_set_locking_callback(openssl_lock);#if !defined(WIN32) && OPENSSL_VERSION_NUMBER < 0x10000000            CRYPTO_set_id_callback(openssl_thread_id);#endif        }#endif    }    openssl_init++;    avpriv_unlock_avformat();}

void CRYPTO_thread_setup(void){    int i;    lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));    lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));    if (!lock_cs || !lock_count) {        /* Nothing we can do about this...void function! */        if (lock_cs)            OPENSSL_free(lock_cs);        if (lock_count)            OPENSSL_free(lock_count);        return;    }    for (i = 0; i < CRYPTO_num_locks(); i++) {        lock_count[i] = 0;        pthread_mutex_init(&(lock_cs[i]), NULL);    }    CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);    CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);}

int _tmain(int argc, _TCHAR* argv[]){	WSADATA wsaData = {0};	WSAStartup(MAKEWORD(2, 2), &wsaData);	SSLeay_add_all_algorithms();	pthread_t pid;		ERR_load_BIO_strings();	SSL_library_init(); 	SSL_load_error_strings();	SSL *ssl = NULL;	SSL_CTX *ctx = NULL;	//这里要注意是client	ctx = SSL_CTX_new(TLSv1_client_method());	if (ctx == NULL)	{		printf("ssl ctx new eer/n");		exit(-1);	}	transf_lock_cs = (pthread_mutex_t *)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));	transf_lock_count = (long *)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));	for (int i = 0; i < CRYPTO_num_locks(); i++)	{		transf_lock_count[i] = 0;		pthread_mutex_init(&(transf_lock_cs[i]), NULL);	}	CRYPTO_set_id_callback((unsigned long(*)())transf_pthreads_thread_id);	CRYPTO_set_locking_callback(transf_client_locking_callback);	pthread_create(&pid, NULL, tcp_forwardlistenthread, ctx);	pthread_join(pid, NULL);	system("pause");	getchar();	SSL_CTX_free(ctx);	WSACleanup();	return 0;}

void pthreads_locking_callback( int mode, int n,    const char *caller_file, int caller_line ){  (void)caller_file;  (void)caller_line;  if(!crypto_locks)  {    VLOG(1) << "Allocating " << CRYPTO_num_locks() << " locks for OpenSSL";    crypto_locks = new pthread_mutex_t[ CRYPTO_num_locks() ];    for(int i=0; i<CRYPTO_num_locks(); ++i)      pthread_mutex_init( crypto_locks+i, 0 );  }  if(mode & CRYPTO_LOCK)  {    pthread_mutex_lock( crypto_locks + n );  } else  {    pthread_mutex_unlock( crypto_locks + n );  }}

/** * Stop SSL support library * @return TRUE, or FALSE if an error has occured. */void stop_ssl() {        if (ssl_initialized) {                int i;                ssl_initialized = FALSE;                ERR_free_strings();                CRYPTO_set_id_callback(NULL);                CRYPTO_set_locking_callback(NULL);                for (i = 0; i < CRYPTO_num_locks(); i++)                        assert(pthread_mutex_destroy(&ssl_mutex_table[i]) == 0);                FREE(ssl_mutex_table);                RAND_cleanup();        }}

static void thread_cleanup(void){	int i;	CRYPTO_set_locking_callback(NULL);	for (i=0; i<CRYPTO_num_locks(); i++) {		pthread_mutex_destroy(&(lock_cs[i]));	}	OPENSSL_free(lock_cs);	OPENSSL_free(lock_count);}

int thread_cleanup(void){  int i;  if (!mutex_buf)    return 0;  CRYPTO_set_id_callback(NULL);  CRYPTO_set_locking_callback(NULL);  for (i = 0; i < CRYPTO_num_locks();  i++)    MUTEX_CLEANUP(mutex_buf[i]);  free(mutex_buf);  mutex_buf = NULL;  return 1;}

static void init_ssl(void){#ifdef GIT_SSL	SSL_load_error_strings();	OpenSSL_add_ssl_algorithms();	/*	 * Load SSLv{2,3} and TLSv1 so that we can talk with servers	 * which use the SSL hellos, which are often used for	 * compatibility. We then disable SSL so we only allow OpenSSL	 * to speak TLSv1 to perform the encryption itself.	 */	git__ssl_ctx = SSL_CTX_new(SSLv23_method());	SSL_CTX_set_options(git__ssl_ctx,			    SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3	/* Older OpenSSL and MacOS OpenSSL doesn't have this */# ifdef SSL_OP_NO_COMPRESSION			    | SSL_OP_NO_COMPRESSION# endif		);	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {		SSL_CTX_free(git__ssl_ctx);		git__ssl_ctx = NULL;	}# ifdef GIT_THREADS	{		int num_locks, i;		num_locks = CRYPTO_num_locks();		openssl_locks = git__calloc(num_locks, sizeof(git_mutex));		if (openssl_locks == NULL) {			SSL_CTX_free(git__ssl_ctx);			git__ssl_ctx = NULL;		}		for (i = 0; i < num_locks; i++) {			if (git_mutex_init(&openssl_locks[i]) != 0) {				SSL_CTX_free(git__ssl_ctx);				git__ssl_ctx = NULL;			}		}		CRYPTO_set_locking_callback(openssl_locking_function);	}	git__on_shutdown(shutdown_ssl);# endif#endif}

void CRYPTO_thread_cleanup(){ int i;  if (!mutex_buf)    return;  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);  for (i = 0; i < CRYPTO_num_locks(); i++)    MUTEX_CLEANUP(mutex_buf[i]);  free(mutex_buf);  mutex_buf = NULL;}

void thread_cleanup(void){    int i;    CRYPTO_set_locking_callback(NULL);    for (i = 0; i < CRYPTO_num_locks(); i++) {        char buf[10];        sprintf(buf, "%2d:", i);        usdumpsema(lock_cs[i], stdout, buf);        usfreesema(lock_cs[i], arena);    }    OPENSSL_free(lock_cs);}

void CRYPTO_thread_setup(void)	{	int i;#ifdef USE_MUTEX	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));#else	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(rwlock_t));#endif	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));	for (i=0; i<CRYPTO_num_locks(); i++)		{		lock_count[i]=0;#ifdef USE_MUTEX		mutex_init(&(lock_cs[i]),USYNC_THREAD,NULL);#else		rwlock_init(&(lock_cs[i]),USYNC_THREAD,NULL);#endif		}	CRYPTO_set_id_callback((unsigned long (*)())solaris_thread_id);	CRYPTO_set_locking_callback((void (*)())solaris_locking_callback);	}

void thread_setup(void){    int i;    char filename[20];    sgx_strcpy(filename, "/tmp/mttest.XXXXXX");    mktemp(filename);    usconfig(CONF_STHREADIOOFF);    usconfig(CONF_STHREADMALLOCOFF);    usconfig(CONF_INITUSERS, 100);    usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);    arena = usinit(filename);    unlink(filename);    lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));    for (i = 0; i < CRYPTO_num_locks(); i++) {        lock_cs[i] = usnewsema(arena, 1);    }    CRYPTO_set_id_callback((unsigned long (*)())irix_thread_id);    CRYPTO_set_locking_callback((void (*)())irix_locking_callback);}

void ub_openssl_lock_delete(void){#if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L	int i;	if(!ub_openssl_locks)		return;	CRYPTO_set_id_callback(NULL);	CRYPTO_set_locking_callback(NULL);	for(i=0; i<CRYPTO_num_locks(); i++) {		lock_basic_destroy(&ub_openssl_locks[i]);	}	free(ub_openssl_locks);#endif /* OPENSSL_THREADS */}

/** * thread_setup * * Set up multi-thread protection used by the SSL library * * Return value: 0 for success, -1 for failure **/static int      thread_setup(void){        int             i;        /* First, create and initialize the necessary mutexes */        if (! (mutexes = (pthread_mutex_t *)g_malloc(CRYPTO_num_locks() *                                            sizeof(pthread_mutex_t)))) {                err("out of memory");                return(-1);        }        for (i = 0; i < CRYPTO_num_locks(); i++) {                pthread_mutex_init(& (mutexes[i]), NULL);        }        /* Register our locking functions with the SSL library */        CRYPTO_set_id_callback(id_function);        CRYPTO_set_locking_callback(lock_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);        return(0);                      /* No errors */}

static void threadLockCleanup(void){    int i;    CRYPTO_set_locking_callback(NULL);    fprintf(stderr,"cleanup/n");    for (i = 0; i < CRYPTO_num_locks(); i++) {    pthread_mutex_destroy(&(lock_cs[i]));    fprintf(stderr,"%8ld:%s/n",lock_count[i],        CRYPTO_get_lock_name(i));    }    OPENSSL_free(lock_cs);    OPENSSL_free(lock_count);}

static voidcrypto_init_threading(void){    gint i;    ssl_lock_count = CRYPTO_num_locks();    ssl_locks = g_new(GStaticMutex, ssl_lock_count);    for (i = 0; i < ssl_lock_count; i++)    {        g_static_mutex_init(&ssl_locks[i]);    }    CRYPTO_set_id_callback(ssl_thread_id);    CRYPTO_set_locking_callback(ssl_locking_callback);}

/* returns -1 on error, 0 on success */int tls_init_locks(){	/* init "static" tls locks */	n_static_locks=CRYPTO_num_locks();	if (n_static_locks<0){		LM_CRIT("bad CRYPTO_num_locks %d/n", n_static_locks);		n_static_locks=0;	}	if (n_static_locks){		if (CRYPTO_get_locking_callback()!=NULL) {			LM_CRIT("ssl locking callback already set/n");			return -1;		}		static_locks=lock_set_alloc(n_static_locks);		if (static_locks==0){			LM_CRIT("could not allocate lockset with %d locks/n",					n_static_locks);			goto error;		}		if (lock_set_init(static_locks)==0){			LM_CRIT("lock set init failed (%d locks)/n", n_static_locks);			lock_set_dealloc(static_locks);			static_locks=0;			n_static_locks=0;			goto error;		}		CRYPTO_set_locking_callback(locking_f);	}	/* set "dynamic" locks callbacks */	CRYPTO_set_dynlock_create_callback(dyn_create_f);	CRYPTO_set_dynlock_lock_callback(dyn_lock_f);	CRYPTO_set_dynlock_destroy_callback(dyn_destroy_f);	/* starting with v1.0.0 openssl does not use anymore getpid(), but address	 * of errno which can point to same virtual address in a multi-process	 * application	 * - for refrence http://www.openssl.org/docs/crypto/threads.html	 */	CRYPTO_set_id_callback(sr_ssl_id_f);	/* atomic add -- since for now we don't have atomic_add	 *  (only atomic_inc), fallback to the default use-locks mode	 * CRYPTO_set_add_lock_callback(atomic_add_f);	 */	return 0;error:	tls_destroy_locks();	return -1;}

void svCrypto::Initialize(void){	if (mutex_crypto) return;	int num_locks = CRYPTO_num_locks();	if (num_locks <= 0) return;	mutex_crypto = new pthread_mutex_t *[num_locks];	for (int i = 0; i < num_locks; i++) {		mutex_crypto[i] = new pthread_mutex_t;		pthread_mutex_init(mutex_crypto[i], NULL);	}	CRYPTO_set_locking_callback(sv_crypto_lock);	svDebug("svCrypto: Initialized %d lock(s)/n", num_locks);}

////////////////////////////////////////////////////////////////////////////////////	This is called from Http::start after all the modules are loaded.//	The code here is global for this handler and is not required per handler//	instance.//int MaOpenSslModule::start(){	RandBuf		randBuf;	static int	once = 0;	//	//	Depending on the order in the configuration file, we will get called 	//	by the module mechanism and by OpenSslConfig::start(). But we only 	//	want to run once.	//	if (once++ > 0) {		return 0;	}	randBuf.pid = getpid();	randBuf.time = (int) time(0);	randBuf.msec = (int) mprGetTime(0);	RAND_seed((void*) &randBuf, sizeof(randBuf));#if SOLARIS || LINUX || MACOSX || FREEBSD	mprLog(6, "OpenSsl: Before calling RAND_load_file/n");	RAND_load_file("/dev/urandom", 256);	mprLog(6, "OpenSsl: After calling RAND_load_file/n");#endif#if BLD_FEATURE_MULTITHREAD	numLocks = CRYPTO_num_locks();	locks = (MprMutex**) mprMalloc(numLocks * sizeof(MprMutex*));	for (int i = 0; i < numLocks; i++) {		locks[i] = new MprMutex();	}	CRYPTO_set_id_callback(sslThreadId);	CRYPTO_set_locking_callback(sslStaticLock);	CRYPTO_set_dynlock_create_callback(sslCreateDynLock);	CRYPTO_set_dynlock_destroy_callback(sslDestroyDynLock);	CRYPTO_set_dynlock_lock_callback(sslDynLock);#endif#if WIN	// _fmode=_O_BINARY;	//	CRYPTO_malloc_init();	//	SSLC_add_all_algorithms();#else	OpenSSL_add_all_algorithms();#endif	SSL_library_init();	return 0;}

static void Init_ossl_locks(void){    int i;    int num_locks = CRYPTO_num_locks();    ossl_locks = ALLOC_N(struct CRYPTO_dynlock_value, num_locks);    for (i = 0; i < num_locks; i++)	ossl_lock_init(&ossl_locks[i]);    CRYPTO_THREADID_set_callback(ossl_threadid_func);    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);}

static voidossl_init_locks(void){    unsigned ii, nlocks;    if (CRYPTO_get_locking_callback() != NULL) {        /* Someone already set the callback before us. Don't destroy it! */        return;    }    nlocks = CRYPTO_num_locks();    ossl_locks = malloc(sizeof(*ossl_locks) * nlocks);    for (ii = 0; ii < nlocks; ii++) {        ossl_lock_init(ossl_locks + ii);    }    CRYPTO_set_locking_callback(ossl_lockfn);}