示例#1
0
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
}
示例#2
0
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);

}
示例#3
0
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);
}
示例#4
0
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");)
示例#5
0
/**
 * 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);

}
示例#6
0
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
}
示例#7
0
文件: tls_openssl.c 项目: AVLeo/libav
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();
}
示例#8
0
文件: th-lock.c 项目: 03050903/godot
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);
}
示例#9
0
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;
}
示例#10
0
文件: openssl.cpp 项目: tarruda/encfs
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 );
  }
}
示例#11
0
文件: ssl.c 项目: AsydSolutions/monit
/**
 * 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();
        }
}
示例#12
0
文件: ws.c 项目: davehorton/sofia-sip
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);

}
示例#13
0
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;
}
示例#14
0
文件: global.c 项目: junmei/libgit2
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
}
示例#15
0
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;
}
示例#16
0
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);
}
示例#17
0
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;
}
示例#18
0
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);
	}
示例#19
0
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);
}
示例#20
0
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 */
}
示例#21
0
/**
 * 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);
}
示例#23
0
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);
}
示例#24
0
/* 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;
}
示例#25
0
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);
}
示例#26
0
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;
}
示例#27
0
////////////////////////////////////////////////////////////////////////////////
//
//	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;
}
示例#28
0
文件: ossl.c 项目: dennyc/openssl
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);
}
示例#29
0
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");
}
示例#30
0
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);
}