/* crypto/cryptlib.c */
/* ====================================================================
- * Copyright (c) 1998-2003 The OpenSSL Project. All rights reserved.
+ * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
IMPLEMENT_STACK_OF(CRYPTO_dynlock)
/* real #defines in crypto.h, keep these upto date */
-static const char* lock_names[CRYPTO_NUM_LOCKS] =
+static const char* const lock_names[CRYPTO_NUM_LOCKS] =
{
"<<ERROR>>",
"err",
static void (MS_FAR *locking_callback)(int mode,int type,
- const char *file,int line)=NULL;
+ const char *file,int line)=0;
static int (MS_FAR *add_lock_callback)(int *pointer,int amount,
- int type,const char *file,int line)=NULL;
-static unsigned long (MS_FAR *id_callback)(void)=NULL;
+ int type,const char *file,int line)=0;
+static unsigned long (MS_FAR *id_callback)(void)=0;
+static void *(MS_FAR *idptr_callback)(void)=0;
static struct CRYPTO_dynlock_value *(MS_FAR *dynlock_create_callback)
- (const char *file,int line)=NULL;
+ (const char *file,int line)=0;
static void (MS_FAR *dynlock_lock_callback)(int mode,
- struct CRYPTO_dynlock_value *l, const char *file,int line)=NULL;
+ struct CRYPTO_dynlock_value *l, const char *file,int line)=0;
static void (MS_FAR *dynlock_destroy_callback)(struct CRYPTO_dynlock_value *l,
- const char *file,int line)=NULL;
+ const char *file,int line)=0;
int CRYPTO_get_new_lockid(char *name)
{
else
/* If we found a place with a NULL pointer, put our pointer
in it. */
- sk_CRYPTO_dynlock_set(dyn_locks,i,pointer);
+ (void)sk_CRYPTO_dynlock_set(dyn_locks,i,pointer);
CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
if (i == -1)
#endif
if (pointer->references <= 0)
{
- sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
+ (void)sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
}
else
pointer = NULL;
add_lock_callback=func;
}
-unsigned long (*CRYPTO_get_id_callback(void))(void)
- {
- return(id_callback);
- }
+/* Thread IDs. So ... if we build without OPENSSL_NO_DEPRECATED, then we leave
+ * the existing implementations and just layer CRYPTO_THREADID_[get|cmp]
+ * harmlessly on top. Otherwise, we only use 'id_callback' or 'idptr_callback'
+ * if they're non-NULL, ie. we ignore CRYPTO_thread_id()'s fallbacks and we
+ * move CRYPTO_thread_idptr()'s "&errno" fallback trick into
+ * CRYPTO_THREADID_set(). */
void CRYPTO_set_id_callback(unsigned long (*func)(void))
{
id_callback=func;
}
+void CRYPTO_set_idptr_callback(void *(*func)(void))
+ {
+ idptr_callback=func;
+ }
+
+void CRYPTO_THREADID_set(CRYPTO_THREADID *id)
+ {
+ if (id_callback)
+ id->ulong = id_callback();
+ else
+ id->ulong = 0;
+
+ if (idptr_callback)
+ id->ptr = idptr_callback();
+ else
+ id->ptr = &errno;
+ }
+
+int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *id1, const CRYPTO_THREADID *id2)
+ {
+ if (id1->ulong != id2->ulong)
+ return ((id1->ulong < id2->ulong) ? -1 : 1);
+ if (id1->ptr != id2->ptr)
+ return ((id1->ptr < id2->ptr) ? -1 : 1);
+ return 0;
+ }
+
+unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id)
+ {
+ /* will need further processing to arrive at a good hash (mem_dbg.c uses this) */
+ return id->ulong + (unsigned long)id->ptr;
+ }
+
+void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dst, const CRYPTO_THREADID *src)
+ {
+ memcpy(dst, src, sizeof(*src));
+ }
+
+#ifndef OPENSSL_NO_DEPRECATED
+unsigned long (*CRYPTO_get_id_callback(void))(void)
+ {
+ return(id_callback);
+ }
+
unsigned long CRYPTO_thread_id(void)
{
unsigned long ret=0;
ret=(unsigned long)GetCurrentThreadId();
#elif defined(GETPID_IS_MEANINGLESS)
ret=1L;
+#elif defined(OPENSSL_SYS_BEOS)
+ ret=(unsigned long)find_thread(NULL);
#else
ret=(unsigned long)getpid();
#endif
ret=id_callback();
return(ret);
}
+#endif
void CRYPTO_lock(int mode, int type, const char *file, int line)
{
#ifdef LOCK_DEBUG
{
char *rw_text,*operation_text;
+ CRYPTO_THREADID tid;
if (mode & CRYPTO_LOCK)
operation_text="lock ";
else
rw_text="ERROR";
+ CRYPTO_THREADID_set(&tid);
fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d\n",
- CRYPTO_thread_id(), rw_text, operation_text,
+ CRYPTO_THREADID_hash(&tid), rw_text, operation_text,
CRYPTO_get_lock_name(type), file, line);
}
#endif
int line)
{
int ret = 0;
+#ifdef LOCK_DEBUG
+ CRYPTO_THREADID tid;
+ CRYPTO_THREADID_set(&tid);
+#endif
if (add_lock_callback != NULL)
{
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_THREADID_hash(&tid), before,amount,ret,
CRYPTO_get_lock_name(type),
file,line);
#endif
ret= *pointer+amount;
#ifdef LOCK_DEBUG
fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
- CRYPTO_thread_id(),
- *pointer,amount,ret,
+ CRYPTO_THREADID_hash(&tid), *pointer,amount,ret,
CRYPTO_get_lock_name(type),
file,line);
#endif
unsigned long OPENSSL_ia32cap_P=0;
unsigned long *OPENSSL_ia32cap_loc(void) { return &OPENSSL_ia32cap_P; }
-int OPENSSL_NONPIC_relocated=0;
#if defined(OPENSSL_CPUID_OBJ) && !defined(OPENSSL_NO_ASM) && !defined(I386_ONLY)
#define OPENSSL_CPUID_SETUP
#else
unsigned long *OPENSSL_ia32cap_loc(void) { return NULL; }
#endif
-#if !defined(OPENSSL_CPUID_SETUP)
+int OPENSSL_NONPIC_relocated = 0;
+#if !defined(OPENSSL_CPUID_SETUP) && !defined(OPENSSL_CPUID_OBJ)
void OPENSSL_cpuid_setup(void) {}
#endif
#include <tchar.h>
#if defined(_WIN32_WINNT) && _WIN32_WINNT>=0x0333
-static int IsService(void)
+int OPENSSL_isservice(void)
{ HWINSTA h;
DWORD len;
WCHAR *name;
#endif
else return 0;
}
+#else
+int OPENSSL_isservice(void) { return 0; }
#endif
void OPENSSL_showfatal (const char *fmta,...)
{ va_list ap;
TCHAR buf[256];
const TCHAR *fmt;
+#ifdef STD_ERROR_HANDLE /* what a dirty trick! */
HANDLE h;
if ((h=GetStdHandle(STD_ERROR_HANDLE)) != NULL &&
va_end (ap);
return;
}
+#endif
if (sizeof(TCHAR)==sizeof(char))
- fmt=fmta;
+ fmt=(const TCHAR *)fmta;
else do
{ int keepgoing;
size_t len_0=strlen(fmta)+1,i;
#if defined(_WIN32_WINNT) && _WIN32_WINNT>=0x0333
/* this -------------v--- guards NT-specific calls */
- if (GetVersion() < 0x80000000 && IsService())
+ if (GetVersion() < 0x80000000 && OPENSSL_isservice())
{ HANDLE h = RegisterEventSource(0,_T("OPENSSL"));
const TCHAR *pmsg=buf;
ReportEvent(h,EVENTLOG_ERROR_TYPE,0,0,0,1,0,&pmsg,0);
}
else
#endif
- { MSGBOXPARAMS m;
-
- m.cbSize = sizeof(m);
- m.hwndOwner = NULL;
- m.lpszCaption = _T("OpenSSL: FATAL");
- m.dwStyle = MB_OK;
- m.hInstance = NULL;
- m.lpszIcon = IDI_ERROR;
- m.dwContextHelpId = 0;
- m.lpfnMsgBoxCallback = NULL;
- m.dwLanguageId = MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US);
- m.lpszText = buf;
-
- MessageBoxIndirect (&m);
- }
+ MessageBox (NULL,buf,_T("OpenSSL: FATAL"),MB_OK|MB_ICONSTOP);
}
#else
void OPENSSL_showfatal (const char *fmta,...)
vfprintf (stderr,fmta,ap);
va_end (ap);
}
+int OPENSSL_isservice (void) { return 0; }
#endif
void OpenSSLDie(const char *file,int line,const char *assertion)
projects / openssl.git / blobdiff