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])); } }
int ndoit(SSL_CTX *ssl_ctx[2]) { int i; int ret; char *ctx[4]; ctx[0]=(char *)ssl_ctx[0]; ctx[1]=(char *)ssl_ctx[1]; if (reconnect) { ctx[2]=(char *)SSL_new(ssl_ctx[0]); ctx[3]=(char *)SSL_new(ssl_ctx[1]); } else { ctx[2]=NULL; ctx[3]=NULL; } fprintf(stdout,"started thread %lu\n",CRYPTO_thread_id()); for (i=0; i<number_of_loops; i++) { /* fprintf(stderr,"%4d %2d ctx->ref (%3d,%3d)\n", CRYPTO_thread_id(),i, ssl_ctx[0]->references, ssl_ctx[1]->references); */ /* pthread_delay_np(&tm);*/ ret=doit(ctx); if (ret != 0) { fprintf(stdout,"error[%d] %lu - %d\n", i,CRYPTO_thread_id(),ret); return(ret); } } fprintf(stdout,"DONE %lu\n",CRYPTO_thread_id()); if (reconnect) { SSL_free((SSL *)ctx[2]); SSL_free((SSL *)ctx[3]); } # ifdef OPENSSL_SYS_NETWARE MPKSemaphoreSignal(ThreadSem); # endif return(0); }
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 void ssl_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); }
int CRYPTO_push_info_(const char *info, const char *file, int line) { APP_INFO *ami, *amim; int ret=0; if (is_MemCheck_on()) { MemCheck_off(); /* obtain MALLOC2 lock */ if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL) { ret=0; goto err; } if (amih == NULL) { if ((amih=lh_new(app_info_hash, app_info_cmp)) == NULL) { OPENSSL_free(ami); ret=0; goto err; } } ami->thread=CRYPTO_thread_id(); ami->file=file; ami->line=line; ami->info=info; ami->references=1; ami->next=NULL; if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL) { #ifdef LEVITTE_DEBUG_MEM if (ami->thread != amim->thread) { fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n", amim->thread, ami->thread); abort(); } #endif ami->next=amim; } err: MemCheck_on(); /* release MALLOC2 lock */ } 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(); } }
int CRYPTO_is_mem_check_on(void) { int ret = 0; if (mh_mode & CRYPTO_MEM_CHECK_ON) { CRYPTO_r_lock(CRYPTO_LOCK_MALLOC); ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE) || (disabling_thread != CRYPTO_thread_id()); CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC); } return(ret); }
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 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 (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) { mutex_lock(&(lock_cs[type])); lock_count[type]++; } else { mutex_unlock(&(lock_cs[type])); } }
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); }
static APP_INFO *pop_info(void) { APP_INFO tmp; APP_INFO *ret = NULL; if (amih != NULL) { tmp.thread=CRYPTO_thread_id(); if ((ret=(APP_INFO *)lh_delete(amih,&tmp)) != NULL) { APP_INFO *next=ret->next; if (next != NULL) { next->references++; lh_insert(amih,(char *)next); } #ifdef LEVITTE_DEBUG_MEM if (ret->thread != tmp.thread) { fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n", ret->thread, tmp.thread); abort(); } #endif if (--(ret->references) <= 0) { ret->next = NULL; if (next != NULL) next->references--; OPENSSL_free(ret); } } } return(ret); }
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; }