Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/dso/dso_win32.c

 /* dso_win32.c -*- mode:C; c-file-style: "eay" -*- */
 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
  * project 2000.
  */
 /* ====================================================================
  * Copyright (c) 2000 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
  * are met:
@@ skipping 78 matching lines @@
 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) return NULL;
+        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 int win32_load(DSO *dso);
 static int win32_unload(DSO *dso);
 static void *win32_bind_var(DSO *dso, const char *symname);
 static DSO_FUNC_TYPE win32_bind_func(DSO *dso, const char *symname);
 #if 0
 static int win32_unbind_var(DSO *dso, char *symname, void *symptr);
 static int win32_unbind_func(DSO *dso, char *symname, DSO_FUNC_TYPE symptr);
 static int win32_init(DSO *dso);
 static int win32_finish(DSO *dso);
 static long win32_ctrl(DSO *dso, int cmd, long larg, void *parg);
 #endif
 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 void *win32_globallookup(const char *name);
 
 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_load,
         win32_unload,
         win32_bind_var,
         win32_bind_func,
 /* For now, "unbind" doesn't exist */
 #if 0
         NULL, /* unbind_var */
         NULL, /* unbind_func */
 #endif
         NULL, /* ctrl */
         win32_name_converter,
         win32_merger,
         NULL, /* init */
-        NULL  /* finish */
+        NULL, /* finish */
+        win32_pathbyaddr,
+        win32_globallookup
         };
 
 DSO_METHOD *DSO_METHOD_win32(void)
         {
         return(&dso_meth_win32);
         }
 
 /* For this DSO_METHOD, our meth_data STACK will contain;
  * (i) a pointer to the handle (HINSTANCE) returned from
  *     LoadLibrary(), and copied.
@@ skipping 17 matching lines @@
                 ERR_add_error_data(3, "filename(", filename, ")");
                 goto err;
                 }
         p = (HINSTANCE *)OPENSSL_malloc(sizeof(HINSTANCE));
         if(p == NULL)
                 {
                 DSOerr(DSO_F_WIN32_LOAD,ERR_R_MALLOC_FAILURE);
                 goto err;
                 }
         *p = h;
-        if(!sk_push(dso->meth_data, (char *)p))
+        if(!sk_void_push(dso->meth_data, p))
                 {
                 DSOerr(DSO_F_WIN32_LOAD,DSO_R_STACK_ERROR);
                 goto err;
                 }
         /* Success */
         dso->loaded_filename = filename;
         return(1);
 err:
         /* Cleanup !*/
         if(filename != NULL)
                 OPENSSL_free(filename);
         if(p != NULL)
                 OPENSSL_free(p);
         if(h != NULL)
                 FreeLibrary(h);
         return(0);
         }
 
 static int win32_unload(DSO *dso)
         {
         HINSTANCE *p;
         if(dso == NULL)
                 {
                 DSOerr(DSO_F_WIN32_UNLOAD,ERR_R_PASSED_NULL_PARAMETER);
                 return(0);
                 }
-        if(sk_num(dso->meth_data) < 1)
+        if(sk_void_num(dso->meth_data) < 1)
                 return(1);
-        p = (HINSTANCE *)sk_pop(dso->meth_data);
+        p = sk_void_pop(dso->meth_data);
         if(p == NULL)
                 {
                 DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_NULL_HANDLE);
                 return(0);
                 }
         if(!FreeLibrary(*p))
                 {
                 DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_UNLOAD_FAILED);
                 /* We should push the value back onto the stack in
                  * case of a retry. */
-                sk_push(dso->meth_data, (char *)p);
+                sk_void_push(dso->meth_data, p);
                 return(0);
                 }
         /* Cleanup */
         OPENSSL_free(p);
         return(1);
         }
 
 /* Using GetProcAddress for variables? TODO: Check this out in
  * the Win32 API docs, there's probably a variant for variables. */
 static void *win32_bind_var(DSO *dso, const char *symname)
         {
         HINSTANCE *ptr;
         void *sym;
 
         if((dso == NULL) || (symname == NULL))
                 {
                 DSOerr(DSO_F_WIN32_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);
                 return(NULL);
                 }
-        if(sk_num(dso->meth_data) < 1)
+        if(sk_void_num(dso->meth_data) < 1)
                 {
                 DSOerr(DSO_F_WIN32_BIND_VAR,DSO_R_STACK_ERROR);
                 return(NULL);
                 }
-        ptr = (HINSTANCE *)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
+        ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
         if(ptr == NULL)
                 {
                 DSOerr(DSO_F_WIN32_BIND_VAR,DSO_R_NULL_HANDLE);
                 return(NULL);
                 }
         sym = GetProcAddress(*ptr, symname);
         if(sym == NULL)
                 {
                 DSOerr(DSO_F_WIN32_BIND_VAR,DSO_R_SYM_FAILURE);
                 ERR_add_error_data(3, "symname(", symname, ")");
                 return(NULL);
                 }
         return(sym);
         }
 
 static DSO_FUNC_TYPE win32_bind_func(DSO *dso, const char *symname)
         {
         HINSTANCE *ptr;
         void *sym;
 
         if((dso == NULL) || (symname == NULL))
                 {
                 DSOerr(DSO_F_WIN32_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
                 return(NULL);
                 }
-        if(sk_num(dso->meth_data) < 1)
+        if(sk_void_num(dso->meth_data) < 1)
                 {
                 DSOerr(DSO_F_WIN32_BIND_FUNC,DSO_R_STACK_ERROR);
                 return(NULL);
                 }
-        ptr = (HINSTANCE *)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
+        ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
         if(ptr == NULL)
                 {
                 DSOerr(DSO_F_WIN32_BIND_FUNC,DSO_R_NULL_HANDLE);
                 return(NULL);
                 }
         sym = GetProcAddress(*ptr, symname);
         if(sym == NULL)
                 {
                 DSOerr(DSO_F_WIN32_BIND_FUNC,DSO_R_SYM_FAILURE);
                 ERR_add_error_data(3, "symname(", symname, ")");
@@ skipping 54 matching lines @@
                 case ':':
                         if(position != IN_DEVICE)
                                 {
                                 DSOerr(DSO_F_WIN32_SPLITTER,
                                         DSO_R_INCORRECT_FILE_SYNTAX);
                                 /*goto err;*/
                                 OPENSSL_free(result);
                                 return(NULL);
                                 }
                         result->device = start;
-                        result->devicelen = filename - start;
+                        result->devicelen = (int)(filename - start);
                         position = IN_FILE;
                         start = ++filename;
                         result->dir = start;
                         break;
                 case '\\':
                 case '/':
                         if(position == IN_NODE)
                                 {
-                                result->nodelen = filename - start;
+                                result->nodelen = (int)(filename - start);
                                 position = IN_FILE;
                                 start = ++filename;
                                 result->dir = start;
                                 }
                         else if(position == IN_DEVICE)
                                 {
                                 position = IN_FILE;
                                 filename++;
                                 result->dir = start;
-                                result->dirlen = filename - start;
+                                result->dirlen = (int)(filename - start);
                                 start = filename;
                                 }
                         else
                                 {
                                 filename++;
-                                result->dirlen += filename - start;
+                                result->dirlen += (int)(filename - start);
                                 start = filename;
                                 }
                         break;
                 case '\0':
                         if(position == IN_NODE)
                                 {
-                                result->nodelen = filename - start;
+                                result->nodelen = (int)(filename - start);
                                 }
                         else
                                 {
                                 if(filename - start > 0)
                                         {
                                         if (assume_last_is_dir)
                                                 {
                                                 if (position == IN_DEVICE)
                                                         {
                                                         result->dir = start;
                                                         result->dirlen = 0;
                                                         }
                                                 result->dirlen +=
-                                                        filename - start;
+                                                        (int)(filename - start);
                                                 }
                                         else
                                                 {
                                                 result->file = start;
                                                 result->filelen =
-                                                        filename - start;
+                                                        (int)(filename - start);
                                                 }
                                         }
                                 }
                         break;
                 default:
                         filename++;
                         break;
                         }
                 }
         while(last);
@@ skipping 73 matching lines @@
         start = file_split->predir;
         while(file_split->predirlen > (start - file_split->predir))
                 {
                 const char *end = openssl_strnchr(start, '/',
                         file_split->predirlen - (start - file_split->predir));
                 if(!end)
                         end = start
                                 + file_split->predirlen
                                 - (start - file_split->predir);
                 strncpy(&result[offset], start,
-                        end - start); offset += end - start;
+                        end - start); offset += (int)(end - start);
                 result[offset] = '\\'; offset++;
                 start = end + 1;
                 }
 #if 0 /* Not needed, since the directory converter above already appeneded
          a backslash */
         if(file_split->predir && (file_split->dir || file_split->file))
                 {
                 result[offset] = '\\'; offset++;
                 }
 #endif
         start = file_split->dir;
         while(file_split->dirlen > (start - file_split->dir))
                 {
                 const char *end = openssl_strnchr(start, '/',
                         file_split->dirlen - (start - file_split->dir));
                 if(!end)
                         end = start
                                 + file_split->dirlen
                                 - (start - file_split->dir);
                 strncpy(&result[offset], start,
-                        end - start); offset += end - start;
+                        end - start); offset += (int)(end - start);
                 result[offset] = '\\'; offset++;
                 start = end + 1;
                 }
 #if 0 /* Not needed, since the directory converter above already appeneded
          a backslash */
         if(file_split->dir && file_split->file)
                 {
                 result[offset] = '\\'; offset++;
                 }
 #endif
@@ skipping 120 matching lines @@
         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
 
-#endif /* OPENSSL_SYS_WIN32 */
+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_WIN32_PATHBYADDR,DSO_R_UNSUPPORTED);
+                return -1;
+                }
+
+        create_snap = (CREATETOOLHELP32SNAPSHOT)
+                GetProcAddress(dll,"CreateToolhelp32Snapshot");
+        if (create_snap == NULL)
+                {
+                FreeLibrary(dll);
+                DSOerr(DSO_F_WIN32_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_WIN32_PATHBYADDR,DSO_R_UNSUPPORTED);
+                return -1;
+                } 
+ 
+        me32.dwSize = sizeof(me32); 
+ 
+        if(!(*module_first)(hModuleSnap,&me32)) 
+                { 
+                (*close_snap)(hModuleSnap);
+                FreeLibrary(dll);
+                DSOerr(DSO_F_WIN32_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;
+        }
+
+static void *win32_globallookup(const char *name)
+        {
+        HMODULE dll;
+        HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
+        MODULEENTRY32 me32;
+        CREATETOOLHELP32SNAPSHOT create_snap;
+        CLOSETOOLHELP32SNAPSHOT  close_snap;
+        MODULE32 module_first, module_next;
+        FARPROC ret=NULL;
+
+        dll = LoadLibrary(TEXT(DLLNAME));
+        if (dll == NULL)
+                {
+                DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);
+                return NULL;
+                }
+
+        create_snap = (CREATETOOLHELP32SNAPSHOT)
+                GetProcAddress(dll,"CreateToolhelp32Snapshot");
+        if (create_snap == NULL)
+                {
+                FreeLibrary(dll);
+                DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);
+                return NULL;
+                }
+        /* 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_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);
+                return NULL;
+                }
+
+        me32.dwSize = sizeof(me32);
+
+        if (!(*module_first)(hModuleSnap,&me32))
+                {
+                (*close_snap)(hModuleSnap);
+                FreeLibrary(dll);
+                return NULL;
+                }
+
+        do      {
+                if ((ret = GetProcAddress(me32.hModule,name)))
+                        {
+                        (*close_snap)(hModuleSnap);
+                        FreeLibrary(dll);
+                        return ret;
+                        }
+                } while((*module_next)(hModuleSnap,&me32));
+
+        (*close_snap)(hModuleSnap); 
+        FreeLibrary(dll);
+        return NULL;
+        }
+#endif /* DSO_WIN32 */