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 void init_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); }
static void l_init(void) { int i, n_locks; n_locks = CRYPTO_num_locks(); if((l_array = (pthread_mutex_t *)calloc(n_locks, sizeof(pthread_mutex_t))) == NULL) { logmsg(LOG_ERR, "lock init: out of memory - aborted..."); exit(1); } for(i = 0; i < n_locks; i++) pthread_mutex_init(&l_array[i], NULL); return; }
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 void crypto_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); }
void svCrypto::Uninitialize(void) { if (!mutex_crypto) return; int num_locks = CRYPTO_num_locks(); if (num_locks <= 0) return; for (int i = 0; i < num_locks; i++) { pthread_mutex_destroy(mutex_crypto[i]); delete mutex_crypto[i]; } delete mutex_crypto; mutex_crypto = NULL; }
//////////////////////////////////////////////////////////////////////////////// // // 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); }
void thread_cleanup(void) { int i; CRYPTO_set_locking_callback(NULL); fprintf(stderr, "cleanup\n"); for (i = 0; i < CRYPTO_num_locks(); i++) { delete lock_cs[i]; fprintf(stderr, "%8ld:%s\n", lock_count[i], CRYPTO_get_lock_name(i)); } OPENSSL_free(lock_cs); OPENSSL_free(lock_count); fprintf(stderr, "done cleanup\n"); }
static void ossl_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); }