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; }
void LLCurl::initClass() { // Do not change this "unless you are familiar with and mean to control // internal operations of libcurl" // - http://curl.haxx.se/libcurl/c/curl_global_init.html curl_global_init(CURL_GLOBAL_ALL); #if SAFE_SSL S32 mutex_count = CRYPTO_num_locks(); for (S32 i=0; i<mutex_count; i++) { sSSLMutex.push_back(new LLMutex(gAPRPoolp)); } CRYPTO_set_id_callback(&LLCurl::ssl_thread_id); CRYPTO_set_locking_callback(&LLCurl::ssl_locking_callback); #endif }
void start() { Platform::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...")); } } // Force OpenSSL loading if it is linked in Qt, // so that we won't mess with our OpenSSL locking with Qt OpenSSL locking. auto sslSupported = QSslSocket::supportsSsl(); if (!sslSupported) { LOG(("Error: current Qt build doesn't support SSL requests.")); } if (!CRYPTO_get_locking_callback()) { // Qt didn't initialize OpenSSL, so we will. auto 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); } if (!CRYPTO_get_dynlock_create_callback()) { CRYPTO_set_dynlock_create_callback(_sslCreateFunction); CRYPTO_set_dynlock_lock_callback(_sslLockFunction); CRYPTO_set_dynlock_destroy_callback(_sslDestroyFunction); } else if (!CRYPTO_get_dynlock_lock_callback()) { LOG(("MTP Error: dynlock_create callback is set without dynlock_lock callback!")); } av_register_all(); avcodec_register_all(); av_lockmgr_register(_ffmpegLockManager); _sslInited = true; }
/* 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){ LOG(L_CRIT, "BUG: tls: tls_init_locking: bad CRYPTO_num_locks %d\n", n_static_locks); n_static_locks=0; } if (n_static_locks){ static_locks=lock_set_alloc(n_static_locks); if (static_locks==0){ LOG(L_CRIT, "ERROR: tls_init_locking: could not allocate lockset" " with %d locks\n", n_static_locks); goto error; } if (lock_set_init(static_locks)==0){ LOG(L_CRIT, "ERROR: tls_init_locking: 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); /* thread id callback: not needed because ser doesn't use thread and * openssl already uses getpid() (by default) * CRYPTO_set_id_callback(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; }
static void SetupOpenSSLThreadLocks(void) { #if defined(HAVE_PTHREAD) const int numLocks = CRYPTO_num_locks(); cf_openssl_locks = OPENSSL_malloc(numLocks * sizeof(pthread_mutex_t)); for (int i = 0; i < numLocks; i++) { pthread_mutex_init(&(cf_openssl_locks[i]),NULL); } #ifndef __MINGW32__ CRYPTO_set_id_callback((unsigned long (*)())ThreadId_callback); #endif CRYPTO_set_locking_callback((void (*)())OpenSSLLock_callback); #endif }
int torque_stop_ssl(void){ int ret = 0; unsigned z; RAND_cleanup(); CRYPTO_set_locking_callback(NULL); CRYPTO_set_id_callback(NULL); for(z = 0 ; z < numlocks ; ++z){ if(pthread_mutex_destroy(&openssl_locks[z])){ ret = -1; } } numlocks = 0; free(openssl_locks); openssl_locks = NULL; return ret; }
void thread_setup(void) { int i; lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(MPKMutex)); lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long)); for (i=0; i<CRYPTO_num_locks(); i++) { lock_count[i]=0; lock_cs[i]=MPKMutexAlloc("OpenSSL mutex"); } ThreadSem = MPKSemaphoreAlloc("OpenSSL mttest semaphore", 0 ); CRYPTO_set_id_callback((unsigned long (*)())netware_thread_id); CRYPTO_set_locking_callback((void (*)())netware_locking_callback); }
void CRYPTO_thread_setup(void) { int i; syslog(LOG_DEBUG, "Setting up pthreads TLS."); lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t)); lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long)); 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); }
void 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 */ for(i=0; i<CRYPTO_NUM_LOCKS; i++) pthread_mutex_init(lock_cs+i, NULL); CRYPTO_set_id_callback(stunnel_thread_id); CRYPTO_set_locking_callback(locking_callback); pthread_attr_init(&pth_attr); pthread_attr_setdetachstate(&pth_attr, PTHREAD_CREATE_DETACHED); pthread_attr_setstacksize(&pth_attr, STACK_SIZE); }
int sdns_openssl_lock_init(void) { int i; sdns_openssl_locks = (lock_basic_t*)malloc( sizeof(lock_basic_t)*CRYPTO_num_locks()); if(!sdns_openssl_locks) return 0; for(i=0; i<CRYPTO_num_locks(); i++) { lock_basic_init(&sdns_openssl_locks[i]); } //openssl 1.0.0 CRYPTO_set_id_callback was replaced by CRYPTO_THREADID_set_callback openssl_set_id_callback(sdns_openssl_id_cb); CRYPTO_set_locking_callback(&sdns_openssl_lock_cb); return 1; }
int THREAD_setup(void) { int i; mutex_buf = (MUTEX_TYPE *) malloc(CRYPTO_num_locks() * sizeof(MUTEX_TYPE)); 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); return 1; }
void ff_openssl_deinit(void) { avpriv_lock_avformat(); openssl_init--; if (!openssl_init) { #if HAVE_THREADS if (CRYPTO_get_locking_callback() == openssl_lock) { int i; CRYPTO_set_locking_callback(NULL); for (i = 0; i < CRYPTO_num_locks(); i++) pthread_mutex_destroy(&openssl_mutexes[i]); av_free(openssl_mutexes); } #endif } avpriv_unlock_avformat(); }
int SSLSocket_initialize() { int rc = 0; /*int prc;*/ int i; int lockMemSize; FUNC_ENTRY; if ((rc = SSL_library_init()) != 1) rc = -1; ERR_load_crypto_strings(); SSL_load_error_strings(); /* OpenSSL 0.9.8o and 1.0.0a and later added SHA2 algorithms to SSL_library_init(). Applications which need to use SHA2 in earlier versions of OpenSSL should call OpenSSL_add_all_algorithms() as well. */ OpenSSL_add_all_algorithms(); lockMemSize = CRYPTO_num_locks() * sizeof(ssl_mutex_type); sslLocks = malloc(lockMemSize); if (!sslLocks) { rc = -1; goto exit; } else memset(sslLocks, 0, lockMemSize); for (i = 0; i < CRYPTO_num_locks(); i++) { /* prc = */SSL_create_mutex(&sslLocks[i]); } CRYPTO_THREADID_set_callback(SSLThread_id); CRYPTO_set_locking_callback(SSLLocks_callback); SSL_create_mutex(&sslCoreMutex); exit: FUNC_EXIT_RC(rc); return rc; }
void thread_cleanup(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); fprintf(stderr,"done cleanup\n"); }
void TlsSocket::Init() { debug("Initializing TLS library"); #ifdef HAVE_LIBGNUTLS int error_code; #ifdef NEED_GCRYPT_LOCKING error_code = gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_Mutex); if (error_code != 0) { error("Could not initialize libcrypt"); return; } #endif /* NEED_GCRYPT_LOCKING */ error_code = gnutls_global_init(); if (error_code != 0) { error("Could not initialize libgnutls"); return; } #endif /* HAVE_LIBGNUTLS */ #ifdef HAVE_OPENSSL for (int i = 0, num = CRYPTO_num_locks(); i < num; i++) { g_OpenSSLMutexes.emplace_back(std::make_unique<Mutex>()); } SSL_load_error_strings(); SSL_library_init(); OpenSSL_add_all_algorithms(); CRYPTO_set_locking_callback(openssl_locking); //CRYPTO_set_id_callback(openssl_thread_id); CRYPTO_set_dynlock_create_callback(openssl_dynlock_create); CRYPTO_set_dynlock_destroy_callback(openssl_dynlock_destroy); CRYPTO_set_dynlock_lock_callback(openssl_dynlock_lock); #endif /* HAVE_OPENSSL */ m_tlsSocketFinalizer = std::make_unique<TlsSocketFinalizer>(); }
int neo4j_openssl_init(void) { SSL_library_init(); SSL_load_error_strings(); ERR_load_BIO_strings(); OpenSSL_add_all_algorithms(); int num_locks = CRYPTO_num_locks(); thread_locks = calloc(num_locks, sizeof(neo4j_mutex_t)); if (thread_locks == NULL) { return -1; } for (int i = 0; i < num_locks; i++) { int err = neo4j_mutex_init(&(thread_locks[i])); if (err) { for (; i > 0; --i) { neo4j_mutex_destroy(&(thread_locks[i-1])); } free(thread_locks); errno = err; return -1; } } if (CRYPTO_get_locking_callback() == NULL) { CRYPTO_set_locking_callback(locking_callback); CRYPTO_set_id_callback(neo4j_current_thread_id); } SSL_CTX *ctx = SSL_CTX_new(TLSv1_method()); if (ctx == NULL) { errno = openssl_error(NULL, NEO4J_LOG_ERROR, __FILE__, __LINE__); return -1; } SSL_CTX_free(ctx); return 0; }
static BOOL _winpr_openssl_cleanup_locking(void) { /* undo our static locking modifications */ if (CRYPTO_get_locking_callback() == _winpr_openssl_locking) { int i; CRYPTO_set_locking_callback(NULL); for (i = 0; i < g_winpr_openssl_num_locks; i++) { CloseHandle(g_winpr_openssl_locks[i]); } g_winpr_openssl_num_locks = 0; free(g_winpr_openssl_locks); g_winpr_openssl_locks = NULL; } /* unset our dynamic locking callbacks */ if (CRYPTO_get_dynlock_create_callback() == _winpr_openssl_dynlock_create) { CRYPTO_set_dynlock_create_callback(NULL); } if (CRYPTO_get_dynlock_lock_callback() == _winpr_openssl_dynlock_lock) { CRYPTO_set_dynlock_lock_callback(NULL); } if (CRYPTO_get_dynlock_destroy_callback() == _winpr_openssl_dynlock_destroy) { CRYPTO_set_dynlock_destroy_callback(NULL); } #if (OPENSSL_VERSION_NUMBER < 0x10000000L) if (CRYPTO_get_id_callback() == _winpr_openssl_id) { CRYPTO_set_id_callback(NULL); } #endif return TRUE; }
void dst__openssl_destroy(void) { /* * Sequence taken from apps_shutdown() in <apps/apps.h>. */ if (rm != NULL) { #if OPENSSL_VERSION_NUMBER >= 0x00907000L RAND_cleanup(); #endif mem_free(rm); rm = NULL; } #if (OPENSSL_VERSION_NUMBER >= 0x00907000L) CONF_modules_free(); #endif OBJ_cleanup(); EVP_cleanup(); #if defined(USE_ENGINE) if (e != NULL) ENGINE_free(e); e = NULL; #if defined(USE_ENGINE) && OPENSSL_VERSION_NUMBER >= 0x00907000L ENGINE_cleanup(); #endif #endif #if (OPENSSL_VERSION_NUMBER >= 0x00907000L) CRYPTO_cleanup_all_ex_data(); #endif ERR_clear_error(); #if OPENSSL_VERSION_NUMBER < 0x10100000L ERR_remove_state(0); #endif ERR_free_strings(); #ifdef DNS_CRYPTO_LEAKS CRYPTO_mem_leaks_fp(stderr); #endif if (locks != NULL) { CRYPTO_set_locking_callback(NULL); DESTROYMUTEXBLOCK(locks, nlocks); mem_free(locks); locks = NULL; } }
static void internal_idevice_init(void) { #ifdef HAVE_OPENSSL int i; SSL_library_init(); mutex_buf = (mutex_t*)malloc(CRYPTO_num_locks() * sizeof(mutex_t)); if (!mutex_buf) return; for (i = 0; i < CRYPTO_num_locks(); i++) mutex_init(&mutex_buf[i]); CRYPTO_set_id_callback(id_function); CRYPTO_set_locking_callback(locking_function); #else gnutls_global_init(); #endif }
int neo4j_openssl_cleanup(void) { if (CRYPTO_get_locking_callback() == locking_callback) { CRYPTO_set_locking_callback(NULL); CRYPTO_set_id_callback(NULL); } int num_locks = CRYPTO_num_locks(); for (int i = 0; i < num_locks; i++) { neo4j_mutex_destroy(&(thread_locks[i])); } free(thread_locks); EVP_cleanup(); return 0; }
void seafile_curl_init() { int i; curl_locks = malloc (sizeof(pthread_mutex_t) * CRYPTO_num_locks()); for (i = 0; i < CRYPTO_num_locks(); ++i) { pthread_mutex_init (&curl_locks[i], NULL); } #ifndef WIN32 /* On Windows it's better to use the default id_function. * As per http://linux.die.net/man/3/crypto_set_id_callback, * the default id_functioin uses system's default thread * identifying API. */ CRYPTO_set_id_callback (pthread_self); #endif CRYPTO_set_locking_callback (seafile_curl_locking_callback); }
/* Do any extra initialization related to ssl */ void mstoneSslInit(void) { #ifdef USE_PTHREADS int n; num_locks = CRYPTO_num_locks(); locks = xcalloc(num_locks * sizeof(*locks)); for (n = 0; n < num_locks; n++) { if (pthread_mutex_init(&locks[n], NULL)) { returnerr(stderr, "Failed to initialize mutex %d\n", n); } } CRYPTO_set_id_callback(thread_id); CRYPTO_set_locking_callback(thread_lock); D_PRINTF(stderr, "Initialized SSL for threading\n"); #endif /* USE_PTHREADS */ }
void CRYPTO_thread_setup(void) { int i; lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(HANDLE)); if(!lock_cs) { /* Nothing we can do about this...void function! */ return; } for (i = 0; i < CRYPTO_num_locks(); i++) { lock_cs[i] = CreateMutex(NULL, FALSE, NULL); } CRYPTO_set_locking_callback((void (*)(int, int, char *, int)) win32_locking_callback); /* id callback defined */ return (1); }
void init_ssl() { #ifdef ENABLE_TCMALLOC HeapLeakChecker::Disabler disabler; #endif load_ssl_library(); if ((CRYPTO_get_id_callback() == NULL) && (CRYPTO_get_locking_callback() == NULL)) { //cuint_t n; CRYPTO_set_id_callback (__get_thread_id); CRYPTO_set_locking_callback (__lock_thread); int locks_num = CRYPTO_num_locks(); ssl_lock = new KMutex[locks_num]; } }
/** * Called from code in arch/ */ void net_initialize(void) { #if ENABLE_OPENSSL SSL_library_init(); SSL_load_error_strings(); showtime_ssl_ctx = SSL_CTX_new(SSLv23_client_method()); int i, n = CRYPTO_num_locks(); ssl_locks = malloc(sizeof(pthread_mutex_t) * n); for(i = 0; i < n; i++) pthread_mutex_init(&ssl_locks[i], NULL); CRYPTO_set_locking_callback(ssl_lock_fn); CRYPTO_set_id_callback(ssl_tid_fn); #endif }
static int ssl_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]); hfree(mutex_buf); mutex_buf = NULL; return 0; }
int thread_openssl_cleanup(void) { int i; if (! mutex_arr) return -1; CRYPTO_set_id_callback(NULL); CRYPTO_set_locking_callback(NULL); for (i = 0; i < CRYPTO_num_locks( ); i++) MUTEX_CLEANUP(mutex_arr[i]); free(mutex_arr); mutex_arr = NULL; return 0; }
int CRYPTO_thread_setup() { //dzlog_info("thread = %ld", pthread_self()); int i; mutex_buf = (pthread_mutex_t*)malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t)); if (!mutex_buf) return SOAP_EOM; for (i = 0; i < CRYPTO_num_locks(); i++) { pthread_mutex_init(&mutex_buf[i], NULL); } 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); return SOAP_OK; }
void OsSSL::OpenSSL_thread_setup() { if (sInitialized) { return; } for (int i=0 ; i<CRYPTO_NUM_LOCKS ; i++) { spOpenSSL_locks[i] = new OsMutex(OsMutex::Q_FIFO); } // set locking callback to make SSL thread-safe CRYPTO_set_locking_callback((void (*)(int,int,const char*, int))OpenSSL_locking_function); // set ID callback for linux, where getpid() returns the same for multiple threads CRYPTO_set_id_callback(OpenSSL_id_function); }
void CRYPTO_thread_cleanup() { //dzlog_info("thread = %ld", pthread_self()); 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++) { pthread_mutex_destroy(&mutex_buf[i]); } free(mutex_buf); mutex_buf = NULL; }