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

void pthreads_locking_callback(int mode, int type, char *file,	     int line)      {#if 0	TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"thread=%4d mode=%s lock=%s %s:%d/n",		CRYPTO_thread_id(),		(mode&CRYPTO_LOCK)?"l":"u",		(type&CRYPTO_READ)?"r":"w",file,line);#endif#if 0	if (CRYPTO_LOCK_SSL_CERT == type)		TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"(t,m,f,l) %ld %d %s %d/n",		CRYPTO_thread_id(),		mode,file,line);#endif	if (mode & CRYPTO_LOCK)		{		pthread_mutex_lock(&(lock_cs[type]));		lock_count[type]++;		}	else		{		pthread_mutex_unlock(&(lock_cs[type]));		}	}

void pthreads_locking_callback(int mode, int type, char *file,	     int line)      {#if 0	fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d/n",		CRYPTO_thread_id(),		(mode&CRYPTO_LOCK)?"l":"u",		(type&CRYPTO_READ)?"r":"w",file,line);#endif#if 0	if (CRYPTO_LOCK_SSL_CERT == type)		fprintf(stderr,"(t,m,f,l) %ld %d %s %d/n",		CRYPTO_thread_id(),		mode,file,line);#endif	if (mode & CRYPTO_LOCK)		{		pthread_mutex_lock(&(lock_cs[type]));		lock_count[type]++;		}	else		{		pthread_mutex_unlock(&(lock_cs[type]));		}	}

void solaris_locking_callback(int mode, int type, char *file, int line){# ifdef undef    fprintf(stderr, "thread=%4d mode=%s lock=%s %s:%d/n",            CRYPTO_thread_id(),            (mode & CRYPTO_LOCK) ? "l" : "u",            (type & CRYPTO_READ) ? "r" : "w", file, line);# endif    /*-    if (CRYPTO_LOCK_SSL_CERT == type)    fprintf(stderr,"(t,m,f,l) %ld %d %s %d/n",            CRYPTO_thread_id(),            mode,file,line);    */    if (mode & CRYPTO_LOCK) {        /*-        if (mode & CRYPTO_READ)                rw_rdlock(&(lock_cs[type]));        else                rw_wrlock(&(lock_cs[type])); */        mutex_lock(&(lock_cs[type]));        lock_count[type]++;    } else {/*      rw_unlock(&(lock_cs[type]));  */        mutex_unlock(&(lock_cs[type]));    }}

void CRYPTO_lock(int mode, int type, const char *file, int line)	{#ifdef LOCK_DEBUG		{		char *rw_text,*operation_text;		if (mode & CRYPTO_LOCK)			operation_text="lock  ";		else if (mode & CRYPTO_UNLOCK)			operation_text="unlock";		else			operation_text="ERROR ";		if (mode & CRYPTO_READ)			rw_text="r";		else if (mode & CRYPTO_WRITE)			rw_text="w";		else			rw_text="ERROR";		fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d/n",			CRYPTO_thread_id(), rw_text, operation_text,			CRYPTO_get_lock_name(type), file, line);		}#endif	if (type < 0)		{		if (do_dynlock_cb)			do_dynlock_cb(mode, type, file, line);		}	else		if (locking_callback != NULL)			locking_callback(mode,type,file,line);	}

static BN_BLINDING *rsa_get_blinding(RSA *rsa, int *local, BN_CTX *ctx){	BN_BLINDING *ret;	int got_write_lock = 0;	CRYPTO_r_lock(CRYPTO_LOCK_RSA);	if (rsa->blinding == NULL)		{		CRYPTO_r_unlock(CRYPTO_LOCK_RSA);		CRYPTO_w_lock(CRYPTO_LOCK_RSA);		got_write_lock = 1;		if (rsa->blinding == NULL)			rsa->blinding = RSA_setup_blinding(rsa, ctx);		}	ret = rsa->blinding;	if (ret == NULL)		goto err;	if (BN_BLINDING_get_thread_id(ret) == CRYPTO_thread_id())		{		/* rsa->blinding is ours! */		*local = 1;		}	else		{		/* resort to rsa->mt_blinding instead */		*local = 0; /* instructs rsa_blinding_convert(), rsa_blinding_invert()		             * that the BN_BLINDING is shared, meaning that accesses		             * require locks, and that the blinding factor must be		             * stored outside the BN_BLINDING		             */		if (rsa->mt_blinding == NULL)			{			if (!got_write_lock)				{				CRYPTO_r_unlock(CRYPTO_LOCK_RSA);				CRYPTO_w_lock(CRYPTO_LOCK_RSA);				got_write_lock = 1;				}						if (rsa->mt_blinding == NULL)				rsa->mt_blinding = RSA_setup_blinding(rsa, ctx);			}		ret = rsa->mt_blinding;		} err:	if (got_write_lock)		CRYPTO_w_unlock(CRYPTO_LOCK_RSA);	else		CRYPTO_r_unlock(CRYPTO_LOCK_RSA);	return ret;}

static int ssleay_rand_status(void)	{	int ret;	int do_not_lock;	/* check if we already have the lock	 * (could happen if a RAND_poll() implementation calls RAND_status()) */	if (crypto_lock_rand)		{		CRYPTO_r_lock(CRYPTO_LOCK_RAND2);		do_not_lock = (locking_thread == CRYPTO_thread_id());		CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);		}	else		do_not_lock = 0;		if (!do_not_lock)		{		CRYPTO_w_lock(CRYPTO_LOCK_RAND);				/* prevent ssleay_rand_bytes() from trying to obtain the lock again */		CRYPTO_w_lock(CRYPTO_LOCK_RAND2);		locking_thread = CRYPTO_thread_id();		CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);		crypto_lock_rand = 1;		}		if (!initialized)		{		RAND_poll();		initialized = 1;		}	ret = entropy >= ENTROPY_NEEDED;	if (!do_not_lock)		{		/* before unlocking, we must clear 'crypto_lock_rand' */		crypto_lock_rand = 0;				CRYPTO_w_unlock(CRYPTO_LOCK_RAND);		}		return ret;	}

ERR_STATE *ERR_get_state(void)	{	ERR_STATE *ret=NULL,tmp,*tmpp;	int i;	unsigned long pid;	pid=(unsigned long)CRYPTO_thread_id();	CRYPTO_r_lock(CRYPTO_LOCK_ERR);	if (thread_hash == NULL)		{		CRYPTO_r_unlock(CRYPTO_LOCK_ERR);		CRYPTO_w_lock(CRYPTO_LOCK_ERR);		if (thread_hash == NULL)			{			MemCheck_off();			thread_hash=lh_new(pid_hash,pid_cmp);			MemCheck_on();			CRYPTO_w_unlock(CRYPTO_LOCK_ERR);			if (thread_hash == NULL) return(getFallback());			}		else			CRYPTO_w_unlock(CRYPTO_LOCK_ERR);		}	else		{		tmp.pid=pid;		ret=(ERR_STATE *)lh_retrieve(thread_hash,&tmp);		CRYPTO_r_unlock(CRYPTO_LOCK_ERR);		}	/* ret == the error state, if NULL, make a new one */	if (ret == NULL)		{		ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE));		if (ret == NULL) return(getFallback());		ret->pid=pid;		ret->top=0;		ret->bottom=0;		for (i=0; i<ERR_NUM_ERRORS; i++)			{			ret->err_data[i]=NULL;			ret->err_data_flags[i]=0;			}		CRYPTO_w_lock(CRYPTO_LOCK_ERR);		tmpp=(ERR_STATE *)lh_insert(thread_hash,ret);		CRYPTO_w_unlock(CRYPTO_LOCK_ERR);		if (tmpp != NULL) /* old entry - should not happen */			{			ERR_STATE_free(tmpp);			}		}	return(ret);	}

void ERR_remove_state(unsigned long pid)	{	ERR_STATE tmp;	err_fns_check();	if (pid == 0)		pid=(unsigned long)CRYPTO_thread_id();	tmp.pid=pid;	/* thread_del_item automatically destroys the LHASH if the number of	 * items reaches zero. */	ERRFN(thread_del_item)(&tmp);	}

int fips_is_owning_thread(void)	{	int ret = 0;	if (fips_is_started())		{		CRYPTO_r_lock(CRYPTO_LOCK_FIPS2);		if (fips_thread != 0 && fips_thread == CRYPTO_thread_id())			ret = 1;		CRYPTO_r_unlock(CRYPTO_LOCK_FIPS2);		}	return ret;	}

static voidssl_pthreads_locking_callback (int mode, int type, char *file, int line){  dmsg (D_OPENSSL_LOCK, "SSL LOCK thread=%4lu mode=%s lock=%s %s:%d",	   CRYPTO_thread_id (),	   (mode & CRYPTO_LOCK) ? "l" : "u",	   (type & CRYPTO_READ) ? "r" : "w", file, line);  if (mode & CRYPTO_LOCK)    pthread_mutex_lock (&ssl_mutex[type].mutex);  else    pthread_mutex_unlock (&ssl_mutex[type].mutex);}

int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,	     int line)	{	int ret = 0;	if (add_lock_callback != NULL)		{#ifdef LOCK_DEBUG		int before= *pointer;#endif		ret=add_lock_callback(pointer,amount,type,file,line);#ifdef LOCK_DEBUG		fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d/n",			CRYPTO_thread_id(),			before,amount,ret,			CRYPTO_get_lock_name(type),			file,line);#endif		}	else		{		CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);		ret= *pointer+amount;#ifdef LOCK_DEBUG		fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d/n",			CRYPTO_thread_id(),			*pointer,amount,ret,			CRYPTO_get_lock_name(type),			file,line);#endif		*pointer=ret;		CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);		}	return(ret);	}

void ERR_remove_state(unsigned long pid)	{	ERR_STATE *p,tmp;	if (thread_hash == NULL)		return;	if (pid == 0)		pid=(unsigned long)CRYPTO_thread_id();	tmp.pid=pid;	CRYPTO_w_lock(CRYPTO_LOCK_ERR);	p=(ERR_STATE *)lh_delete(thread_hash,&tmp);	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);	if (p != NULL) ERR_STATE_free(p);	}

static void solaris_locking_callback(int mode, int type, const char *file, int line){#if 0  fprintf(stderr, "thread=%4d mode=%s lock=%s %s:%d/n",          CRYPTO_thread_id(),          (mode & CRYPTO_LOCK) ? "l" : "u",          (type & CRYPTO_READ) ? "r" : "w", file, line);#endif#if 0  if (CRYPTO_LOCK_SSL_CERT == type)    fprintf(stderr, "(t,m,f,l) %ld %d %s %d/n",            CRYPTO_thread_id(),            mode, file, line);#endif  if (mode & CRYPTO_LOCK)  {#ifdef USE_MUTEX    mutex_lock(&(lock_cs[type]));#else    if (mode & CRYPTO_READ)      rw_rdlock(&(lock_cs[type]));    else      rw_wrlock(&(lock_cs[type]));#endif    lock_count[type]++;  }  else  {#ifdef USE_MUTEX    mutex_unlock(&(lock_cs[type]));#else    rw_unlock(&(lock_cs[type]));#endif  }}

void beos_locking_callback(int mode, int type, const char *file, int line){# if 0    fprintf(stderr, "thread=%4d mode=%s lock=%s %s:%d/n",            CRYPTO_thread_id(),            (mode & CRYPTO_LOCK) ? "l" : "u",            (type & CRYPTO_READ) ? "r" : "w", file, line);# endif    if (mode & CRYPTO_LOCK) {        lock_cs[type]->Lock();        lock_count[type]++;    } else {        lock_cs[type]->Unlock();    }}

void ERR_print_errors_fp(FILE *fp)	{	unsigned long l;	char buf[200];	const char *file,*data;	int line,flags;	unsigned long es;	es=CRYPTO_thread_id();	while ((l=ERR_get_error_line_data(&file,&line,&data,&flags)) != 0)		{		fprintf(fp,"%lu:%s:%s:%d:%s/n",es,ERR_error_string(l,buf),			file,line,(flags&ERR_TXT_STRING)?data:"");		}	}

int fips_clear_owning_thread(void)	{	int ret = 0;	if (fips_is_started())		{		CRYPTO_w_lock(CRYPTO_LOCK_FIPS2);		if (fips_thread == CRYPTO_thread_id())			{			fips_thread = 0;			ret = 1;			}		CRYPTO_w_unlock(CRYPTO_LOCK_FIPS2);		}	return ret;	}

static void myLockingCallback(int mode, int type, const char *file,                  int line) {#ifdef undef    fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d/n",        CRYPTO_thread_id(),        (mode&CRYPTO_LOCK)?"l":"u",        (type&CRYPTO_READ)?"r":"w",file,line);#endif    if (mode & CRYPTO_LOCK) {    pthread_mutex_lock(&(lock_cs[type]));    lock_count[type]++;    }    else {    pthread_mutex_unlock(&(lock_cs[type]));    }}

void SSL_pthreads_locking_callback(int mode, int type, char *file, int line) {  if( my.debug == 4 ){    fprintf(      stderr,"thread=%4d mode=%s lock=%s %s:%d/n", (int)CRYPTO_thread_id(),      (mode&CRYPTO_LOCK)?"l":"u", (type&CRYPTO_READ)?"r":"w",file,line    );  }  if(mode & CRYPTO_LOCK){    pthread_mutex_lock(&(lock_cs[type]));    lock_count[type]++;  }   else{     pthread_mutex_unlock(&(lock_cs[type]));  }}

void CRYPTO_lock(int mode, int type, const char *file, int line)	{#ifdef LOCK_DEBUG		{		char *rw_text,*operation_text;		if (mode & CRYPTO_LOCK)			operation_text="lock  ";		else if (mode & CRYPTO_UNLOCK)			operation_text="unlock";		else			operation_text="ERROR ";		if (mode & CRYPTO_READ)			rw_text="r";		else if (mode & CRYPTO_WRITE)			rw_text="w";		else			rw_text="ERROR";		fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d/n",			CRYPTO_thread_id(), rw_text, operation_text,			CRYPTO_get_lock_name(type), file, line);		}#endif	if (type < 0)		{		if (dynlock_lock_callback != NULL)			{			struct CRYPTO_dynlock_value *pointer				= CRYPTO_get_dynlock_value(type);			OPENSSL_assert(pointer != NULL);			dynlock_lock_callback(mode, pointer, file, line);			CRYPTO_destroy_dynlockid(type);			}		}	else		if (locking_callback != NULL)			locking_callback(mode,type,file,line);	}

void ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),			 void *u)	{	unsigned long l;	char buf[256];	char buf2[4096];	const char *file,*data;	int line,flags;	unsigned long es;	es=CRYPTO_thread_id();	while ((l=ERR_get_error_line_data(&file,&line,&data,&flags)) != 0)		{		ERR_error_string_n(l, buf, sizeof buf);		BIO_snprintf(buf2, sizeof(buf2), "%lu:%s:%s:%d:%s/n", es, buf,			file, line, (flags & ERR_TXT_STRING) ? data : "");		cb(buf2, strlen(buf2), u);		}	}

void ERR_print_errors(BIO *bp)	{	unsigned long l;	char buf[256];	char buf2[256];	const char *file,*data;	int line,flags;	unsigned long es;	es=CRYPTO_thread_id();	while ((l=ERR_get_error_line_data(&file,&line,&data,&flags)) != 0)		{		sprintf(buf2,"%lu:%s:%s:%d:",es,ERR_error_string(l,buf),			file,line);		BIO_write(bp,buf2,strlen(buf2));		if (flags & ERR_TXT_STRING)			BIO_write(bp,data,strlen(data));		BIO_write(bp,"/n",1);		}	}

ERR_STATE *ERR_get_state(void)	{	static ERR_STATE fallback;	ERR_STATE *ret,tmp,*tmpp=NULL;	int i;	unsigned long pid;	err_fns_check();	pid=(unsigned long)CRYPTO_thread_id();	tmp.pid=pid;	ret=ERRFN(thread_get_item)(&tmp);	/* ret == the error state, if NULL, make a new one */	if (ret == NULL)		{		ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE));		if (ret == NULL) return(&fallback);		ret->pid=pid;		ret->top=0;		ret->bottom=0;		for (i=0; i<ERR_NUM_ERRORS; i++)			{			ret->err_data[i]=NULL;			ret->err_data_flags[i]=0;			}		tmpp = ERRFN(thread_set_item)(ret);		/* To check if insertion failed, do a get. */		if (ERRFN(thread_get_item)(ret) != ret)			{			ERR_STATE_free(ret); /* could not insert it */			return(&fallback);			}		/* If a race occured in this function and we came second, tmpp		 * is the first one that we just replaced. */		if (tmpp)			ERR_STATE_free(tmpp);		}	return ret;	}

static BN_BLINDING *rsa_get_blinding(RSA *rsa, BIGNUM **r, int *local, BN_CTX *ctx){	BN_BLINDING *ret;	if (rsa->blinding == NULL)		{		if (rsa->blinding == NULL)			{			CRYPTO_w_lock(CRYPTO_LOCK_RSA);			if (rsa->blinding == NULL)				rsa->blinding = RSA_setup_blinding(rsa, ctx);			CRYPTO_w_unlock(CRYPTO_LOCK_RSA);			}		}	ret = rsa->blinding;	if (ret == NULL)		return NULL;	if (BN_BLINDING_get_thread_id(ret) != CRYPTO_thread_id())		{		*local = 0;		if (rsa->mt_blinding == NULL)			{			CRYPTO_w_lock(CRYPTO_LOCK_RSA);			if (rsa->mt_blinding == NULL)				rsa->mt_blinding = RSA_setup_blinding(rsa, ctx);			CRYPTO_w_unlock(CRYPTO_LOCK_RSA);			}		ret = rsa->mt_blinding;		}	else		*local = 1;	return ret;}

void ERR_remove_state(unsigned long pid)	{	ERR_STATE *p = NULL,tmp;	if (thread_hash == NULL)		return;	if (pid == 0)		pid=(unsigned long)CRYPTO_thread_id();	tmp.pid=pid;	CRYPTO_w_lock(CRYPTO_LOCK_ERR);	if (thread_hash)		{		p=(ERR_STATE *)lh_delete(thread_hash,&tmp);		if (lh_num_items(thread_hash) == 0)			{			/* make sure we don't leak memory */			lh_free(thread_hash);			thread_hash = NULL;			}		}	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);	if (p != NULL) ERR_STATE_free(p);	}

BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *in_ctx){	BIGNUM local_n;	BIGNUM *e,*n;	BN_CTX *ctx;	BN_BLINDING *ret = NULL;	if (in_ctx == NULL)		{		if ((ctx = BN_CTX_new()) == NULL) return 0;		}	else		ctx = in_ctx;	BN_CTX_start(ctx);	e  = BN_CTX_get(ctx);	if (e == NULL)		{		RSAerr(RSA_F_RSA_SETUP_BLINDING, ERR_R_MALLOC_FAILURE);		goto err;		}	if (rsa->e == NULL)		{		e = rsa_get_public_exp(rsa->d, rsa->p, rsa->q, ctx);		if (e == NULL)			{			RSAerr(RSA_F_RSA_SETUP_BLINDING, RSA_R_NO_PUBLIC_EXPONENT);			goto err;			}		}	else		e = rsa->e;		if ((RAND_status() == 0) && rsa->d != NULL && rsa->d->d != NULL)		{		/* if PRNG is not properly seeded, resort to secret		 * exponent as unpredictable seed */		RAND_add(rsa->d->d, rsa->d->dmax * sizeof rsa->d->d[0], 0.0);		}	if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))		{		/* Set BN_FLG_CONSTTIME flag */		n = &local_n;		BN_with_flags(n, rsa->n, BN_FLG_CONSTTIME);		}	else		n = rsa->n;	ret = BN_BLINDING_create_param(NULL, e, n, ctx,			rsa->meth->bn_mod_exp, rsa->_method_mod_n);	if (ret == NULL)		{		RSAerr(RSA_F_RSA_SETUP_BLINDING, ERR_R_BN_LIB);		goto err;		}	BN_BLINDING_set_thread_id(ret, CRYPTO_thread_id());err:	BN_CTX_end(ctx);	if (in_ctx == NULL)		BN_CTX_free(ctx);	if(rsa->e == NULL)		BN_free(e);	return ret;}