#include "cryptlib.h"
#include <openssl/dso.h>
-#ifndef OPENSSL_SYS_WIN32
+#if !defined(DSO_WIN32)
DSO_METHOD *DSO_METHOD_win32(void)
{
return NULL;
}
#else
+#ifdef _WIN32_WCE
+# if _WIN32_WCE < 300
+static FARPROC GetProcAddressA(HMODULE hModule,LPCSTR lpProcName)
+ {
+ WCHAR lpProcNameW[64];
+ int i;
+
+ for (i=0;lpProcName[i] && i<64;i++)
+ lpProcNameW[i] = (WCHAR)lpProcName[i];
+ if (i==64) return NULL;
+ lpProcNameW[i] = 0;
+
+ return GetProcAddressW(hModule,lpProcNameW);
+ }
+# endif
+# undef GetProcAddress
+# define GetProcAddress GetProcAddressA
+
+static HINSTANCE LoadLibraryA(LPCSTR lpLibFileName)
+ {
+ WCHAR *fnamw;
+ size_t len_0=strlen(lpLibFileName)+1,i;
+
+#ifdef _MSC_VER
+ fnamw = (WCHAR *)_alloca (len_0*sizeof(WCHAR));
+#else
+ fnamw = (WCHAR *)alloca (len_0*sizeof(WCHAR));
+#endif
+ if (fnamw == NULL)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return NULL;
+ }
+
+#if defined(_WIN32_WCE) && _WIN32_WCE>=101
+ if (!MultiByteToWideChar(CP_ACP,0,lpLibFileName,len_0,fnamw,len_0))
+#endif
+ for (i=0;i<len_0;i++) fnamw[i]=(WCHAR)lpLibFileName[i];
+
+ return LoadLibraryW(fnamw);
+ }
+#endif
+
/* Part of the hack in "win32_load" ... */
#define DSO_MAX_TRANSLATED_SIZE 256
static char *win32_name_converter(DSO *dso, const char *filename);
static char *win32_merger(DSO *dso, const char *filespec1,
const char *filespec2);
+static int win32_pathbyaddr(void *addr,char *path,int sz);
+
+static const char *openssl_strnchr(const char *string, int c, size_t len);
static DSO_METHOD dso_meth_win32 = {
"OpenSSL 'win32' shared library method",
win32_name_converter,
win32_merger,
NULL, /* init */
- NULL /* finish */
+ NULL, /* finish */
+ win32_pathbyaddr
};
DSO_METHOD *DSO_METHOD_win32(void)
DSOerr(DSO_F_WIN32_LOAD,DSO_R_NO_FILENAME);
goto err;
}
- h = LoadLibrary(filename);
+ h = LoadLibraryA(filename);
if(h == NULL)
{
DSOerr(DSO_F_WIN32_LOAD,DSO_R_LOAD_FAILED);
const char *predir; int predirlen;
const char *dir; int dirlen;
const char *file; int filelen;
- }
+ };
static struct file_st *win32_splitter(DSO *dso, const char *filename,
int assume_last_is_dir)
if (!filename)
{
- DSOerr(DSO_F_WIN32_MERGER,DSO_R_NO_FILENAME);
- goto err;
+ DSOerr(DSO_F_WIN32_SPLITTER,DSO_R_NO_FILENAME);
+ /*goto err;*/
+ return(NULL);
}
result = OPENSSL_malloc(sizeof(struct file_st));
if(result == NULL)
{
- DSOerr(DSO_F_WIN32_MERGER,
+ DSOerr(DSO_F_WIN32_SPLITTER,
ERR_R_MALLOC_FAILURE);
return(NULL);
}
memset(result, 0, sizeof(struct file_st));
position = IN_DEVICE;
- if(filename[0] == '\\' && filename[1] == '\\'
- || filename[0] == '/' && filename[1] == '/')
+ if((filename[0] == '\\' && filename[1] == '\\')
+ || (filename[0] == '/' && filename[1] == '/'))
{
position = IN_NODE;
filename += 2;
case ':':
if(position != IN_DEVICE)
{
- DSOerr(DSO_F_WIN32_MERGER,
+ DSOerr(DSO_F_WIN32_SPLITTER,
DSO_R_INCORRECT_FILE_SYNTAX);
- goto err;
+ /*goto err;*/
+ return(NULL);
}
result->device = start;
result->devicelen = filename - start;
while(*filename);
if(!result->nodelen) result->node = NULL;
- if(!result->devicelen) result->devicce = NULL;
+ if(!result->devicelen) result->device = NULL;
if(!result->dirlen) result->dir = NULL;
if(!result->filelen) result->file = NULL;
return(result);
}
-static char *win32_joiner(DSO *dso, const file_st *file_split)
+static char *win32_joiner(DSO *dso, const struct file_st *file_split)
{
int len = 0, offset = 0;
char *result = NULL;
if(!file_split)
{
- DSOerr(DSO_F_WIN32_MERGER,
+ DSOerr(DSO_F_WIN32_JOINER,
ERR_R_PASSED_NULL_PARAMETER);
return(NULL);
}
if(!len)
{
- DSOerr(DSO_F_WIN32_MERGER, DSO_R_EMPTY_FILE_STRUCTURE);
+ DSOerr(DSO_F_WIN32_JOINER, DSO_R_EMPTY_FILE_STRUCTURE);
return(NULL);
}
result = OPENSSL_malloc(len + 1);
if (!result)
{
- DSOerr(DSO_F_WIN32_MERGER,
+ DSOerr(DSO_F_WIN32_JOINER,
ERR_R_MALLOC_FAILURE);
return(NULL);
}
start = file_split->predir;
while(file_split->predirlen > (start - file_split->predir))
{
- const char *end = strnchr(start, '/',
+ const char *end = openssl_strnchr(start, '/',
file_split->predirlen - (start - file_split->predir));
if(!end)
end = start
start = file_split->dir;
while(file_split->dirlen > (start - file_split->dir))
{
- const char *end = strnchr(start, '/',
+ const char *end = openssl_strnchr(start, '/',
file_split->dirlen - (start - file_split->dir));
if(!end)
end = start
return(translated);
}
-#endif /* OPENSSL_SYS_WIN32 */
+static const char *openssl_strnchr(const char *string, int c, size_t len)
+ {
+ size_t i;
+ const char *p;
+ for (i = 0, p = string; i < len && *p; i++, p++)
+ {
+ if (*p == c)
+ return p;
+ }
+ return NULL;
+ }
+
+#include <tlhelp32.h>
+#ifdef _WIN32_WCE
+# define DLLNAME "TOOLHELP.DLL"
+#else
+# ifdef MODULEENTRY32
+# undef MODULEENTRY32 /* unmask the ASCII version! */
+# endif
+# define DLLNAME "KERNEL32.DLL"
+#endif
+
+typedef HANDLE (WINAPI *CREATETOOLHELP32SNAPSHOT)(DWORD, DWORD);
+typedef BOOL (WINAPI *CLOSETOOLHELP32SNAPSHOT)(HANDLE);
+typedef BOOL (WINAPI *MODULE32)(HANDLE, MODULEENTRY32 *);
+
+static int win32_pathbyaddr(void *addr,char *path,int sz)
+ {
+ HMODULE dll;
+ HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
+ MODULEENTRY32 me32;
+ CREATETOOLHELP32SNAPSHOT create_snap;
+ CLOSETOOLHELP32SNAPSHOT close_snap;
+ MODULE32 module_first, module_next;
+ int len;
+
+ if (addr == NULL)
+ {
+ union { int(*f)(void*,char*,int); void *p; } t =
+ { win32_pathbyaddr };
+ addr = t.p;
+ }
+
+ dll = LoadLibrary(TEXT(DLLNAME));
+ if (dll == NULL)
+ {
+ DSOerr(DSO_F_PATHBYADDR,DSO_R_UNSUPPORTED);
+ return -1;
+ }
+
+ create_snap = (CREATETOOLHELP32SNAPSHOT)
+ GetProcAddress(dll,"CreateToolhelp32Snapshot");
+ if (create_snap == NULL)
+ {
+ DSOerr(DSO_F_PATHBYADDR,DSO_R_UNSUPPORTED);
+ return -1;
+ }
+ /* We take the rest for granted... */
+#ifdef _WIN32_WCE
+ close_snap = (CLOSETOOLHELP32SNAPSHOT)
+ GetProcAddress(dll,"CloseToolhelp32Snapshot");
+#else
+ close_snap = (CLOSETOOLHELP32SNAPSHOT)CloseHandle;
+#endif
+ module_first = (MODULE32)GetProcAddress(dll,"Module32First");
+ module_next = (MODULE32)GetProcAddress(dll,"Module32Next");
+
+ hModuleSnap = (*create_snap)(TH32CS_SNAPMODULE,0);
+ if( hModuleSnap == INVALID_HANDLE_VALUE )
+ {
+ FreeLibrary(dll);
+ DSOerr(DSO_F_PATHBYADDR,DSO_R_UNSUPPORTED);
+ return -1;
+ }
+
+ me32.dwSize = sizeof(me32);
+
+ if(!(*module_first)(hModuleSnap,&me32))
+ {
+ (*close_snap)(hModuleSnap);
+ FreeLibrary(dll);
+ DSOerr(DSO_F_PATHBYADDR,DSO_R_FAILURE);
+ return -1;
+ }
+
+ do {
+ if ((BYTE *)addr >= me32.modBaseAddr &&
+ (BYTE *)addr < me32.modBaseAddr+me32.modBaseSize)
+ {
+ (*close_snap)(hModuleSnap);
+ FreeLibrary(dll);
+#ifdef _WIN32_WCE
+# if _WIN32_WCE >= 101
+ return WideCharToMultiByte(CP_ACP,0,me32.szExePath,-1,
+ path,sz,NULL,NULL);
+# else
+ len = (int)wcslen(me32.szExePath);
+ if (sz <= 0) return len+1;
+ if (len >= sz) len=sz-1;
+ for(i=0;i<len;i++)
+ path[i] = (char)me32.szExePath[i];
+ path[len++] = 0;
+ return len;
+# endif
+#else
+ len = (int)strlen(me32.szExePath);
+ if (sz <= 0) return len+1;
+ if (len >= sz) len=sz-1;
+ memcpy(path,me32.szExePath,len);
+ path[len++] = 0;
+ return len;
+#endif
+ }
+ } while((*module_next)(hModuleSnap, &me32));
+
+ (*close_snap)(hModuleSnap);
+ FreeLibrary(dll);
+ return 0;
+ }
+#endif /* DSO_WIN32 */
projects / openssl.git / blobdiff