From: <th...@us...> - 2013-06-05 18:42:16
|
Revision: 726 http://sourceforge.net/p/py2exe/svn/726 Author: theller Date: 2013-06-05 18:42:13 +0000 (Wed, 05 Jun 2013) Log Message: ----------- Work in progress: Using the latest MemoryModule from Joachim Bauch which works on 64-bit builds. Still missing: Using binary search in MemoryGetProcAddress. Modified Paths: -------------- trunk/py2exe/py2exe/build_exe.py trunk/py2exe/setup.py trunk/py2exe/source/MemoryModule.c trunk/py2exe/source/MemoryModule.h trunk/py2exe/source/Python-dynload.c trunk/py2exe/source/_memimporter.c trunk/py2exe/source/run_ctypes_dll.c trunk/py2exe/source/run_dll.c trunk/py2exe/source/start.c trunk/py2exe/zipextimporter.py Added Paths: ----------- trunk/py2exe/source/MyLoadLibrary.c trunk/py2exe/source/MyLoadLibrary.h trunk/py2exe/source/actctx.h Removed Paths: ------------- trunk/py2exe/source/_memimporter_module.c Modified: trunk/py2exe/py2exe/build_exe.py =================================================================== --- trunk/py2exe/py2exe/build_exe.py 2013-05-31 18:50:41 UTC (rev 725) +++ trunk/py2exe/py2exe/build_exe.py 2013-06-05 18:42:13 UTC (rev 726) @@ -215,8 +215,6 @@ self.bundle_files = int(self.bundle_files) if self.bundle_files < 1 or self.bundle_files > 3: raise DistutilsOptionError("bundle-files must be 1, 2, or 3, not %s" % self.bundle_files) - if is_win64 and self.bundle_files < 3: - raise DistutilsOptionError("bundle-files %d not yet supported on win64" % self.bundle_files) if self.skip_archive: if self.compressed: raise DistutilsOptionError("can't compress when skipping archive") @@ -1094,7 +1092,7 @@ tcl_src_dir = tcl_dst_dir = None if "Tkinter" in mf.modules.keys(): - import tkinter + import Tkinter import _tkinter tk = _tkinter.create() tcl_dir = tk.call("info", "library") Modified: trunk/py2exe/setup.py =================================================================== --- trunk/py2exe/setup.py 2013-05-31 18:50:41 UTC (rev 725) +++ trunk/py2exe/setup.py 2013-06-05 18:42:13 UTC (rev 726) @@ -376,16 +376,18 @@ _memimporter = Extension("_memimporter", ["source/MemoryModule.c", - "source/_memimporter_module.c", + "source/MyLoadLibrary.c", + "source/_memimporter.c", "source/actctx.c"], - depends=depends + ["source/_memimporter.c"], - define_macros=macros, + depends=depends, + define_macros=macros + [("STANDALONE", "1")], ) run = Interpreter("py2exe.run", ["source/run.c", "source/start.c", "source/icon.rc", "source/Python-dynload.c", "source/MemoryModule.c", + "source/MyLoadLibrary.c", "source/_memimporter.c", "source/actctx.c", ], @@ -397,6 +399,7 @@ ["source/run_w.c", "source/start.c", "source/icon.rc", "source/Python-dynload.c", "source/MemoryModule.c", + "source/MyLoadLibrary.c", "source/_memimporter.c", "source/actctx.c", ], @@ -409,6 +412,7 @@ ["source/run_dll.c", "source/start.c", "source/icon.rc", "source/Python-dynload.c", "source/MemoryModule.c", + "source/MyLoadLibrary.c", "source/_memimporter.c", "source/actctx.c", ], @@ -427,6 +431,7 @@ ["source/run_ctypes_dll.c", "source/start.c", "source/icon.rc", "source/Python-dynload.c", "source/MemoryModule.c", + "source/MyLoadLibrary.c", "source/_memimporter.c", "source/actctx.c", ], @@ -445,6 +450,7 @@ ["source/run_isapi.c", "source/start.c", "source/Python-dynload.c", "source/MemoryModule.c", + "source/MyLoadLibrary.c", "source/_memimporter.c", "source/actctx.c", "source/icon.rc"], Modified: trunk/py2exe/source/MemoryModule.c =================================================================== --- trunk/py2exe/source/MemoryModule.c 2013-05-31 18:50:41 UTC (rev 725) +++ trunk/py2exe/source/MemoryModule.c 2013-06-05 18:42:13 UTC (rev 726) @@ -1,12 +1,12 @@ /* * Memory DLL loading code - * Version 0.0.2 with additions from Thomas Heller + * Version 0.0.3 * - * Copyright (c) 2004-2005 by Joachim Bauch / ma...@jo... + * Copyright (c) 2004-2013 by Joachim Bauch / ma...@jo... * http://www.joachim-bauch.de * * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (the "License"); you may not use this file except in compliance with + * 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * @@ -19,671 +19,715 @@ * * The Initial Developer of the Original Code is Joachim Bauch. * - * Portions created by Joachim Bauch are Copyright (C) 2004-2005 + * Portions created by Joachim Bauch are Copyright (C) 2004-2013 * Joachim Bauch. All Rights Reserved. * - * Portions Copyright (C) 2005 Thomas Heller. - * */ +#ifndef __GNUC__ // disable warnings about pointer <-> DWORD conversions #pragma warning( disable : 4311 4312 ) +#endif -#include <Windows.h> +#ifdef _WIN64 +#define POINTER_TYPE ULONGLONG +#else +#define POINTER_TYPE DWORD +#endif + +#include <windows.h> #include <winnt.h> -#if DEBUG_OUTPUT +#include <tchar.h> +#ifdef DEBUG_OUTPUT #include <stdio.h> #endif #ifndef IMAGE_SIZEOF_BASE_RELOCATION // Vista SDKs no longer define IMAGE_SIZEOF_BASE_RELOCATION!? -# define IMAGE_SIZEOF_BASE_RELOCATION (sizeof(IMAGE_BASE_RELOCATION)) +#define IMAGE_SIZEOF_BASE_RELOCATION (sizeof(IMAGE_BASE_RELOCATION)) #endif + #include "MemoryModule.h" -/* - XXX We need to protect at least walking the 'loaded' linked list with a lock! -*/ - -/******************************************************************/ -FINDPROC findproc; -void *findproc_data; - -struct NAME_TABLE { - char *name; - DWORD ordinal; -}; - -typedef struct tagMEMORYMODULE { - PIMAGE_NT_HEADERS headers; - unsigned char *codeBase; - HMODULE *modules; - int numModules; - int initialized; - - struct NAME_TABLE *name_table; - - char *name; - int refcount; - struct tagMEMORYMODULE *next, *prev; +typedef struct { + PIMAGE_NT_HEADERS headers; + unsigned char *codeBase; + HCUSTOMMODULE *modules; + int numModules; + int initialized; + CustomLoadLibraryFunc loadLibrary; + CustomGetProcAddressFunc getProcAddress; + CustomFreeLibraryFunc freeLibrary; + void *userdata; } MEMORYMODULE, *PMEMORYMODULE; typedef BOOL (WINAPI *DllEntryProc)(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved); #define GET_HEADER_DICTIONARY(module, idx) &(module)->headers->OptionalHeader.DataDirectory[idx] -MEMORYMODULE *loaded; /* linked list of loaded memory modules */ - -/* private - insert a loaded library in a linked list */ -static void _Register(char *name, MEMORYMODULE *module) -{ - module->next = loaded; - if (loaded) - loaded->prev = module; - module->prev = NULL; - loaded = module; -} - -/* private - remove a loaded library from a linked list */ -static void _Unregister(MEMORYMODULE *module) -{ - free(module->name); - if (module->prev) - module->prev->next = module->next; - if (module->next) - module->next->prev = module->prev; - if (module == loaded) - loaded = module->next; -} - -/* public - replacement for GetModuleHandle() */ -HMODULE MyGetModuleHandle(LPCTSTR lpModuleName) -{ - MEMORYMODULE *p = loaded; - while (p) { - // If already loaded, only increment the reference count - if (0 == _stricmp(lpModuleName, p->name)) { - return (HMODULE)p; - } - p = p->next; - } - return GetModuleHandle(lpModuleName); -} - -/* public - replacement for LoadLibrary, but searches FIRST for memory - libraries, then for normal libraries. So, it will load libraries AS memory - module if they are found by findproc(). -*/ -HMODULE MyLoadLibrary(char *lpFileName) -{ - MEMORYMODULE *p = loaded; - HMODULE hMod; - - while (p) { - // If already loaded, only increment the reference count - if (0 == _stricmp(lpFileName, p->name)) { - p->refcount++; - return (HMODULE)p; - } - p = p->next; - } - if (findproc) { - void *pdata = findproc(lpFileName, findproc_data); - if (pdata) { - hMod = MemoryLoadLibrary(lpFileName, pdata); - free(p); - return hMod; - } - } - hMod = LoadLibrary(lpFileName); - return hMod; -} - -/* public - replacement for GetProcAddress() */ -FARPROC MyGetProcAddress(HMODULE hModule, LPCSTR lpProcName) -{ - MEMORYMODULE *p = loaded; - while (p) { - if ((HMODULE)p == hModule) - return MemoryGetProcAddress(p, lpProcName); - p = p->next; - } - return GetProcAddress(hModule, lpProcName); -} - -/* public - replacement for FreeLibrary() */ -BOOL MyFreeLibrary(HMODULE hModule) -{ - MEMORYMODULE *p = loaded; - while (p) { - if ((HMODULE)p == hModule) { - if (--p->refcount == 0) { - _Unregister(p); - MemoryFreeLibrary(p); - } - return TRUE; - } - p = p->next; - } - return FreeLibrary(hModule); -} - -#if DEBUG_OUTPUT +#ifdef DEBUG_OUTPUT static void OutputLastError(const char *msg) { - LPVOID tmp; - char *tmpmsg; - FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&tmp, 0, NULL); - tmpmsg = (char *)LocalAlloc(LPTR, strlen(msg) + strlen(tmp) + 3); - sprintf(tmpmsg, "%s: %s", msg, tmp); - OutputDebugString(tmpmsg); - LocalFree(tmpmsg); - LocalFree(tmp); + LPVOID tmp; + char *tmpmsg; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&tmp, 0, NULL); + tmpmsg = (char *)LocalAlloc(LPTR, strlen(msg) + strlen(tmp) + 3); + sprintf(tmpmsg, "%s: %s", msg, tmp); + OutputDebugString(tmpmsg); + LocalFree(tmpmsg); + LocalFree(tmp); } #endif -/* -static int dprintf(char *fmt, ...) -{ - char Buffer[4096]; - va_list marker; - int result; - - va_start(marker, fmt); - result = vsprintf(Buffer, fmt, marker); - OutputDebugString(Buffer); - return result; -} -*/ - static void CopySections(const unsigned char *data, PIMAGE_NT_HEADERS old_headers, PMEMORYMODULE module) { - int i, size; - unsigned char *codeBase = module->codeBase; - unsigned char *dest; - PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(module->headers); - for (i=0; i<module->headers->FileHeader.NumberOfSections; i++, section++) - { - if (section->SizeOfRawData == 0) - { - // section doesn't contain data in the dll itself, but may define - // uninitialized data - size = old_headers->OptionalHeader.SectionAlignment; - if (size > 0) - { - dest = (unsigned char *)VirtualAlloc(codeBase + section->VirtualAddress, - size, - MEM_COMMIT, - PAGE_READWRITE); + int i, size; + unsigned char *codeBase = module->codeBase; + unsigned char *dest; + PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(module->headers); + for (i=0; i<module->headers->FileHeader.NumberOfSections; i++, section++) { + if (section->SizeOfRawData == 0) { + // section doesn't contain data in the dll itself, but may define + // uninitialized data + size = old_headers->OptionalHeader.SectionAlignment; + if (size > 0) { + dest = (unsigned char *)VirtualAlloc(codeBase + section->VirtualAddress, + size, + MEM_COMMIT, + PAGE_READWRITE); - section->Misc.PhysicalAddress = (DWORD)dest; - memset(dest, 0, size); - } + section->Misc.PhysicalAddress = (DWORD) (POINTER_TYPE) dest; + memset(dest, 0, size); + } - // section is empty - continue; - } + // section is empty + continue; + } - // commit memory block and copy data from dll - dest = (unsigned char *)VirtualAlloc(codeBase + section->VirtualAddress, - section->SizeOfRawData, - MEM_COMMIT, - PAGE_READWRITE); - memcpy(dest, data + section->PointerToRawData, section->SizeOfRawData); - section->Misc.PhysicalAddress = (DWORD)dest; - } + // commit memory block and copy data from dll + dest = (unsigned char *)VirtualAlloc(codeBase + section->VirtualAddress, + section->SizeOfRawData, + MEM_COMMIT, + PAGE_READWRITE); + memcpy(dest, data + section->PointerToRawData, section->SizeOfRawData); + section->Misc.PhysicalAddress = (DWORD) (POINTER_TYPE) dest; + } } // Protection flags for memory pages (Executable, Readable, Writeable) static int ProtectionFlags[2][2][2] = { - { - // not executable - {PAGE_NOACCESS, PAGE_WRITECOPY}, - {PAGE_READONLY, PAGE_READWRITE}, - }, { - // executable - {PAGE_EXECUTE, PAGE_EXECUTE_WRITECOPY}, - {PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE}, - }, + { + // not executable + {PAGE_NOACCESS, PAGE_WRITECOPY}, + {PAGE_READONLY, PAGE_READWRITE}, + }, { + // executable + {PAGE_EXECUTE, PAGE_EXECUTE_WRITECOPY}, + {PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE}, + }, }; static void FinalizeSections(PMEMORYMODULE module) { - int i; - PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(module->headers); - - // loop through all sections and change access flags - for (i=0; i<module->headers->FileHeader.NumberOfSections; i++, section++) - { - DWORD protect, oldProtect, size; - int executable = (section->Characteristics & IMAGE_SCN_MEM_EXECUTE) != 0; - int readable = (section->Characteristics & IMAGE_SCN_MEM_READ) != 0; - int writeable = (section->Characteristics & IMAGE_SCN_MEM_WRITE) != 0; + int i; + PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(module->headers); +#ifdef _WIN64 + POINTER_TYPE imageOffset = (module->headers->OptionalHeader.ImageBase & 0xffffffff00000000); +#else + #define imageOffset 0 +#endif + + // loop through all sections and change access flags + for (i=0; i<module->headers->FileHeader.NumberOfSections; i++, section++) { + DWORD protect, oldProtect, size; + int executable = (section->Characteristics & IMAGE_SCN_MEM_EXECUTE) != 0; + int readable = (section->Characteristics & IMAGE_SCN_MEM_READ) != 0; + int writeable = (section->Characteristics & IMAGE_SCN_MEM_WRITE) != 0; - if (section->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) - { - // section is not needed any more and can safely be freed - VirtualFree((LPVOID)section->Misc.PhysicalAddress, section->SizeOfRawData, MEM_DECOMMIT); - continue; - } + if (section->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) { + // section is not needed any more and can safely be freed + VirtualFree((LPVOID)((POINTER_TYPE)section->Misc.PhysicalAddress | imageOffset), section->SizeOfRawData, MEM_DECOMMIT); + continue; + } - // determine protection flags based on characteristics - protect = ProtectionFlags[executable][readable][writeable]; - if (section->Characteristics & IMAGE_SCN_MEM_NOT_CACHED) - protect |= PAGE_NOCACHE; + // determine protection flags based on characteristics + protect = ProtectionFlags[executable][readable][writeable]; + if (section->Characteristics & IMAGE_SCN_MEM_NOT_CACHED) { + protect |= PAGE_NOCACHE; + } - // determine size of region - size = section->SizeOfRawData; - if (size == 0) - { - if (section->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) - size = module->headers->OptionalHeader.SizeOfInitializedData; - else if (section->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) - size = module->headers->OptionalHeader.SizeOfUninitializedData; - } + // determine size of region + size = section->SizeOfRawData; + if (size == 0) { + if (section->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) { + size = module->headers->OptionalHeader.SizeOfInitializedData; + } else if (section->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) { + size = module->headers->OptionalHeader.SizeOfUninitializedData; + } + } - if (size > 0) - { - // change memory access flags - if (VirtualProtect((LPVOID)section->Misc.PhysicalAddress, section->SizeOfRawData, protect, &oldProtect) == 0) -#if DEBUG_OUTPUT - OutputLastError("Error protecting memory page") + if (size > 0) { + // change memory access flags + if (VirtualProtect((LPVOID)((POINTER_TYPE)section->Misc.PhysicalAddress | imageOffset), size, protect, &oldProtect) == 0) +#ifdef DEBUG_OUTPUT + OutputLastError("Error protecting memory page") #endif - ; - } - } + ; + } + } +#ifndef _WIN64 +#undef imageOffset +#endif } static void -PerformBaseRelocation(PMEMORYMODULE module, DWORD delta) +PerformBaseRelocation(PMEMORYMODULE module, SIZE_T delta) { - DWORD i; - unsigned char *codeBase = module->codeBase; + DWORD i; + unsigned char *codeBase = module->codeBase; - PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY(module, IMAGE_DIRECTORY_ENTRY_BASERELOC); - if (directory->Size > 0) - { - PIMAGE_BASE_RELOCATION relocation = (PIMAGE_BASE_RELOCATION)(codeBase + directory->VirtualAddress); - for (; relocation->VirtualAddress > 0; ) - { - unsigned char *dest = (unsigned char *)(codeBase + relocation->VirtualAddress); - unsigned short *relInfo = (unsigned short *)((unsigned char *)relocation + IMAGE_SIZEOF_BASE_RELOCATION); - for (i=0; i<((relocation->SizeOfBlock-IMAGE_SIZEOF_BASE_RELOCATION) / 2); i++, relInfo++) - { - DWORD *patchAddrHL; - int type, offset; + PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY(module, IMAGE_DIRECTORY_ENTRY_BASERELOC); + if (directory->Size > 0) { + PIMAGE_BASE_RELOCATION relocation = (PIMAGE_BASE_RELOCATION) (codeBase + directory->VirtualAddress); + for (; relocation->VirtualAddress > 0; ) { + unsigned char *dest = codeBase + relocation->VirtualAddress; + unsigned short *relInfo = (unsigned short *)((unsigned char *)relocation + IMAGE_SIZEOF_BASE_RELOCATION); + for (i=0; i<((relocation->SizeOfBlock-IMAGE_SIZEOF_BASE_RELOCATION) / 2); i++, relInfo++) { + DWORD *patchAddrHL; +#ifdef _WIN64 + ULONGLONG *patchAddr64; +#endif + int type, offset; - // the upper 4 bits define the type of relocation - type = *relInfo >> 12; - // the lower 12 bits define the offset - offset = *relInfo & 0xfff; - - switch (type) - { - case IMAGE_REL_BASED_ABSOLUTE: - // skip relocation - break; + // the upper 4 bits define the type of relocation + type = *relInfo >> 12; + // the lower 12 bits define the offset + offset = *relInfo & 0xfff; + + switch (type) + { + case IMAGE_REL_BASED_ABSOLUTE: + // skip relocation + break; - case IMAGE_REL_BASED_HIGHLOW: - // change complete 32 bit address - patchAddrHL = (DWORD *)(dest + offset); - *patchAddrHL += delta; - break; + case IMAGE_REL_BASED_HIGHLOW: + // change complete 32 bit address + patchAddrHL = (DWORD *) (dest + offset); + *patchAddrHL += (DWORD) delta; + break; + +#ifdef _WIN64 + case IMAGE_REL_BASED_DIR64: + patchAddr64 = (ULONGLONG *) (dest + offset); + *patchAddr64 += (ULONGLONG) delta; + break; +#endif - default: - //printf("Unknown relocation: %d\n", type); - break; - } - } + default: + //printf("Unknown relocation: %d\n", type); + break; + } + } - // advance to next relocation block - relocation = (PIMAGE_BASE_RELOCATION)(((DWORD)relocation) + relocation->SizeOfBlock); - } - } + // advance to next relocation block + relocation = (PIMAGE_BASE_RELOCATION) (((char *) relocation) + relocation->SizeOfBlock); + } + } } static int BuildImportTable(PMEMORYMODULE module) { - int result=1; - unsigned char *codeBase = module->codeBase; + int result=1; + unsigned char *codeBase = module->codeBase; + HCUSTOMMODULE *tmp; - PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY(module, IMAGE_DIRECTORY_ENTRY_IMPORT); - if (directory->Size > 0) - { - PIMAGE_IMPORT_DESCRIPTOR importDesc = (PIMAGE_IMPORT_DESCRIPTOR)(codeBase + directory->VirtualAddress); - for (; !IsBadReadPtr(importDesc, sizeof(IMAGE_IMPORT_DESCRIPTOR)) && importDesc->Name; importDesc++) - { - DWORD *thunkRef, *funcRef; - HMODULE handle; + PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY(module, IMAGE_DIRECTORY_ENTRY_IMPORT); + if (directory->Size > 0) { + PIMAGE_IMPORT_DESCRIPTOR importDesc = (PIMAGE_IMPORT_DESCRIPTOR) (codeBase + directory->VirtualAddress); + for (; !IsBadReadPtr(importDesc, sizeof(IMAGE_IMPORT_DESCRIPTOR)) && importDesc->Name; importDesc++) { + POINTER_TYPE *thunkRef; + FARPROC *funcRef; + HCUSTOMMODULE handle = module->loadLibrary((LPCSTR) (codeBase + importDesc->Name), module->userdata); + if (handle == NULL) { + SetLastError(ERROR_MOD_NOT_FOUND); + result = 0; + break; + } - handle = MyLoadLibrary(codeBase + importDesc->Name); - if (handle == INVALID_HANDLE_VALUE) - { - //LastError should already be set -#if DEBUG_OUTPUT - OutputLastError("Can't load library"); -#endif - result = 0; - break; - } + tmp = (HCUSTOMMODULE *) realloc(module->modules, (module->numModules+1)*(sizeof(HCUSTOMMODULE))); + if (tmp == NULL) { + module->freeLibrary(handle, module->userdata); + SetLastError(ERROR_OUTOFMEMORY); + result = 0; + break; + } + module->modules = tmp; - module->modules = (HMODULE *)realloc(module->modules, (module->numModules+1)*(sizeof(HMODULE))); - if (module->modules == NULL) - { - SetLastError(ERROR_NOT_ENOUGH_MEMORY); - result = 0; - break; - } + module->modules[module->numModules++] = handle; + if (importDesc->OriginalFirstThunk) { + thunkRef = (POINTER_TYPE *) (codeBase + importDesc->OriginalFirstThunk); + funcRef = (FARPROC *) (codeBase + importDesc->FirstThunk); + } else { + // no hint table + thunkRef = (POINTER_TYPE *) (codeBase + importDesc->FirstThunk); + funcRef = (FARPROC *) (codeBase + importDesc->FirstThunk); + } + for (; *thunkRef; thunkRef++, funcRef++) { + if (IMAGE_SNAP_BY_ORDINAL(*thunkRef)) { + *funcRef = module->getProcAddress(handle, (LPCSTR)IMAGE_ORDINAL(*thunkRef), module->userdata); + } else { + PIMAGE_IMPORT_BY_NAME thunkData = (PIMAGE_IMPORT_BY_NAME) (codeBase + (*thunkRef)); + *funcRef = module->getProcAddress(handle, (LPCSTR)&thunkData->Name, module->userdata); + } + if (*funcRef == 0) { + result = 0; + break; + } + } - module->modules[module->numModules++] = handle; - if (importDesc->OriginalFirstThunk) - { - thunkRef = (DWORD *)(codeBase + importDesc->OriginalFirstThunk); - funcRef = (DWORD *)(codeBase + importDesc->FirstThunk); - } else { - // no hint table - thunkRef = (DWORD *)(codeBase + importDesc->FirstThunk); - funcRef = (DWORD *)(codeBase + importDesc->FirstThunk); - } - for (; *thunkRef; thunkRef++, funcRef++) - { - if IMAGE_SNAP_BY_ORDINAL(*thunkRef) { - *funcRef = (DWORD)MyGetProcAddress(handle, (LPCSTR)IMAGE_ORDINAL(*thunkRef)); - } else { - PIMAGE_IMPORT_BY_NAME thunkData = (PIMAGE_IMPORT_BY_NAME)(codeBase + *thunkRef); - *funcRef = (DWORD)MyGetProcAddress(handle, (LPCSTR)&thunkData->Name); - } - if (*funcRef == 0) - { - SetLastError(ERROR_PROC_NOT_FOUND); - result = 0; - break; - } - } + if (!result) { + module->freeLibrary(handle, module->userdata); + SetLastError(ERROR_PROC_NOT_FOUND); + break; + } + } + } - if (!result) - break; - } - } + return result; +} - return result; +static HCUSTOMMODULE _LoadLibrary(LPCSTR filename, void *userdata) +{ + HMODULE result = LoadLibraryA(filename); + if (result == NULL) { + return NULL; + } + + return (HCUSTOMMODULE) result; } -/* - MemoryLoadLibrary - load a library AS MEMORY MODULE, or return - existing MEMORY MODULE with increased refcount. +static FARPROC _GetProcAddress(HCUSTOMMODULE module, LPCSTR name, void *userdata) +{ + return (FARPROC) GetProcAddress((HMODULE) module, name); +} - This allows to load a library AGAIN as memory module which is - already loaded as HMODULE! +static void _FreeLibrary(HCUSTOMMODULE module, void *userdata) +{ + FreeLibrary((HMODULE) module); +} -*/ -HMEMORYMODULE MemoryLoadLibrary(char *name, const void *data) +HMEMORYMODULE MemoryLoadLibrary(const void *data) { - PMEMORYMODULE result; - PIMAGE_DOS_HEADER dos_header; - PIMAGE_NT_HEADERS old_header; - unsigned char *code, *headers; - DWORD locationDelta; - DllEntryProc DllEntry; - BOOL successfull; - MEMORYMODULE *p = loaded; + return MemoryLoadLibraryEx(data, _LoadLibrary, _GetProcAddress, _FreeLibrary, NULL); +} - while (p) { - // If already loaded, only increment the reference count - if (0 == _stricmp(name, p->name)) { - p->refcount++; - return (HMODULE)p; - } - p = p->next; - } +HMEMORYMODULE MemoryLoadLibraryEx(const void *data, + CustomLoadLibraryFunc loadLibrary, + CustomGetProcAddressFunc getProcAddress, + CustomFreeLibraryFunc freeLibrary, + void *userdata) +{ + PMEMORYMODULE result; + PIMAGE_DOS_HEADER dos_header; + PIMAGE_NT_HEADERS old_header; + unsigned char *code, *headers; + SIZE_T locationDelta; + DllEntryProc DllEntry; + BOOL successfull; - /* Do NOT check for GetModuleHandle here! */ + dos_header = (PIMAGE_DOS_HEADER)data; + if (dos_header->e_magic != IMAGE_DOS_SIGNATURE) { + SetLastError(ERROR_BAD_EXE_FORMAT); + return NULL; + } - dos_header = (PIMAGE_DOS_HEADER)data; - if (dos_header->e_magic != IMAGE_DOS_SIGNATURE) - { - SetLastError(ERROR_BAD_FORMAT); -#if DEBUG_OUTPUT - OutputDebugString("Not a valid executable file.\n"); -#endif - return NULL; - } + old_header = (PIMAGE_NT_HEADERS)&((const unsigned char *)(data))[dos_header->e_lfanew]; + if (old_header->Signature != IMAGE_NT_SIGNATURE) { + SetLastError(ERROR_BAD_EXE_FORMAT); + return NULL; + } - old_header = (PIMAGE_NT_HEADERS)&((const unsigned char *)(data))[dos_header->e_lfanew]; - if (old_header->Signature != IMAGE_NT_SIGNATURE) - { - SetLastError(ERROR_BAD_FORMAT); -#if DEBUG_OUTPUT - OutputDebugString("No PE header found.\n"); -#endif - return NULL; - } + // reserve memory for image of library + // XXX: is it correct to commit the complete memory region at once? + // calling DllEntry raises an exception if we don't... + code = (unsigned char *)VirtualAlloc((LPVOID)(old_header->OptionalHeader.ImageBase), + old_header->OptionalHeader.SizeOfImage, + MEM_RESERVE | MEM_COMMIT, + PAGE_READWRITE); - // reserve memory for image of library - code = (unsigned char *)VirtualAlloc((LPVOID)(old_header->OptionalHeader.ImageBase), - old_header->OptionalHeader.SizeOfImage, - MEM_RESERVE, - PAGE_READWRITE); - - if (code == NULL) + if (code == NULL) { // try to allocate memory at arbitrary position code = (unsigned char *)VirtualAlloc(NULL, old_header->OptionalHeader.SizeOfImage, - MEM_RESERVE, + MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + if (code == NULL) { + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + } - if (code == NULL) - { - SetLastError(ERROR_NOT_ENOUGH_MEMORY); -#if DEBUG_OUTPUT - OutputLastError("Can't reserve memory"); -#endif - return NULL; - } + result = (PMEMORYMODULE)HeapAlloc(GetProcessHeap(), 0, sizeof(MEMORYMODULE)); + if (result == NULL) { + SetLastError(ERROR_OUTOFMEMORY); + VirtualFree(code, 0, MEM_RELEASE); + return NULL; + } - result = (PMEMORYMODULE)HeapAlloc(GetProcessHeap(), 0, sizeof(MEMORYMODULE)); - result->codeBase = code; - result->numModules = 0; - result->modules = NULL; - result->initialized = 0; - result->next = result->prev = NULL; - result->refcount = 1; - result->name = _strdup(name); - result->name_table = NULL; + result->codeBase = code; + result->numModules = 0; + result->modules = NULL; + result->initialized = 0; + result->loadLibrary = loadLibrary; + result->getProcAddress = getProcAddress; + result->freeLibrary = freeLibrary; + result->userdata = userdata; - // XXX: is it correct to commit the complete memory region at once? - // calling DllEntry raises an exception if we don't... - VirtualAlloc(code, - old_header->OptionalHeader.SizeOfImage, - MEM_COMMIT, - PAGE_READWRITE); + // commit memory for headers + headers = (unsigned char *)VirtualAlloc(code, + old_header->OptionalHeader.SizeOfHeaders, + MEM_COMMIT, + PAGE_READWRITE); + + // copy PE header to code + memcpy(headers, dos_header, dos_header->e_lfanew + old_header->OptionalHeader.SizeOfHeaders); + result->headers = (PIMAGE_NT_HEADERS)&((const unsigned char *)(headers))[dos_header->e_lfanew]; - // commit memory for headers - headers = (unsigned char *)VirtualAlloc(code, - old_header->OptionalHeader.SizeOfHeaders, - MEM_COMMIT, - PAGE_READWRITE); - - // copy PE header to code - memcpy(headers, dos_header, dos_header->e_lfanew + old_header->OptionalHeader.SizeOfHeaders); - result->headers = (PIMAGE_NT_HEADERS)&((const unsigned char *)(headers))[dos_header->e_lfanew]; + // update position + result->headers->OptionalHeader.ImageBase = (POINTER_TYPE)code; - // update position - result->headers->OptionalHeader.ImageBase = (DWORD)code; + // copy sections from DLL file block to new memory location + CopySections(data, old_header, result); - // copy sections from DLL file block to new memory location - CopySections(data, old_header, result); + // adjust base address of imported data + locationDelta = (SIZE_T)(code - old_header->OptionalHeader.ImageBase); + if (locationDelta != 0) { + PerformBaseRelocation(result, locationDelta); + } - // adjust base address of imported data - locationDelta = (DWORD)(code - old_header->OptionalHeader.ImageBase); - if (locationDelta != 0) - PerformBaseRelocation(result, locationDelta); + // load required dlls and adjust function table of imports + if (!BuildImportTable(result)) { + goto error; + } - // load required dlls and adjust function table of imports - if (!BuildImportTable(result)) - goto error; + // mark memory pages depending on section headers and release + // sections that are marked as "discardable" + FinalizeSections(result); - // mark memory pages depending on section headers and release - // sections that are marked as "discardable" - FinalizeSections(result); + // get entry point of loaded library + if (result->headers->OptionalHeader.AddressOfEntryPoint != 0) { + DllEntry = (DllEntryProc) (code + result->headers->OptionalHeader.AddressOfEntryPoint); + // notify library about attaching to process + successfull = (*DllEntry)((HINSTANCE)code, DLL_PROCESS_ATTACH, 0); + if (!successfull) { + SetLastError(ERROR_DLL_INIT_FAILED); + goto error; + } + result->initialized = 1; + } - // get entry point of loaded library - if (result->headers->OptionalHeader.AddressOfEntryPoint != 0) - { - DllEntry = (DllEntryProc)(code + result->headers->OptionalHeader.AddressOfEntryPoint); - if (DllEntry == 0) - { - SetLastError(ERROR_BAD_FORMAT); /* XXX ? */ -#if DEBUG_OUTPUT - OutputDebugString("Library has no entry point.\n"); -#endif - goto error; - } + return (HMEMORYMODULE)result; - // notify library about attaching to process - successfull = (*DllEntry)((HINSTANCE)code, DLL_PROCESS_ATTACH, 0); - if (!successfull) - { -#if DEBUG_OUTPUT - OutputDebugString("Can't attach library.\n"); -#endif - goto error; - } - result->initialized = 1; - } - - _Register(name, result); - - return (HMEMORYMODULE)result; - error: - // cleanup - free(result->name); - MemoryFreeLibrary(result); - return NULL; + // cleanup + MemoryFreeLibrary(result); + return NULL; } -int _compare(const struct NAME_TABLE *p1, const struct NAME_TABLE *p2) +FARPROC MemoryGetProcAddress(HMEMORYMODULE module, LPCSTR name) { - return _stricmp(p1->name, p2->name); -} + unsigned char *codeBase = ((PMEMORYMODULE)module)->codeBase; + int idx=-1; + DWORD i, *nameRef; + WORD *ordinal; + PIMAGE_EXPORT_DIRECTORY exports; + PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY((PMEMORYMODULE)module, IMAGE_DIRECTORY_ENTRY_EXPORT); + if (directory->Size == 0) { + // no export table found + SetLastError(ERROR_PROC_NOT_FOUND); + return NULL; + } -int _find(const char **name, const struct NAME_TABLE *p) -{ - return _stricmp(*name, p->name); -} + exports = (PIMAGE_EXPORT_DIRECTORY) (codeBase + directory->VirtualAddress); + if (exports->NumberOfNames == 0 || exports->NumberOfFunctions == 0) { + // DLL doesn't export anything + SetLastError(ERROR_PROC_NOT_FOUND); + return NULL; + } -struct NAME_TABLE *GetNameTable(PMEMORYMODULE module) -{ - unsigned char *codeBase; - PIMAGE_EXPORT_DIRECTORY exports; - PIMAGE_DATA_DIRECTORY directory; - DWORD i, *nameRef; - WORD *ordinal; - struct NAME_TABLE *p, *ptab; + // search function name in list of exported names + nameRef = (DWORD *) (codeBase + exports->AddressOfNames); + ordinal = (WORD *) (codeBase + exports->AddressOfNameOrdinals); + for (i=0; i<exports->NumberOfNames; i++, nameRef++, ordinal++) { + if (_stricmp(name, (const char *) (codeBase + (*nameRef))) == 0) { + idx = *ordinal; + break; + } + } - if (module->name_table) - return module->name_table; + if (idx == -1) { + // exported symbol not found + SetLastError(ERROR_PROC_NOT_FOUND); + return NULL; + } - codeBase = module->codeBase; - directory = GET_HEADER_DICTIONARY(module, IMAGE_DIRECTORY_ENTRY_EXPORT); - exports = (PIMAGE_EXPORT_DIRECTORY)(codeBase + directory->VirtualAddress); + if ((DWORD)idx > exports->NumberOfFunctions) { + // name <-> ordinal number don't match + SetLastError(ERROR_PROC_NOT_FOUND); + return NULL; + } - nameRef = (DWORD *)(codeBase + exports->AddressOfNames); - ordinal = (WORD *)(codeBase + exports->AddressOfNameOrdinals); - - p = ((PMEMORYMODULE)module)->name_table = (struct NAME_TABLE *)malloc(sizeof(struct NAME_TABLE) - * exports->NumberOfNames); - if (p == NULL) - return NULL; - ptab = p; - for (i=0; i<exports->NumberOfNames; ++i) { - p->name = (char *)(codeBase + *nameRef++); - p->ordinal = *ordinal++; - ++p; - } - qsort(ptab, exports->NumberOfNames, sizeof(struct NAME_TABLE), _compare); - return ptab; + // AddressOfFunctions contains the RVAs to the "real" functions + return (FARPROC) (codeBase + (*(DWORD *) (codeBase + exports->AddressOfFunctions + (idx*4)))); } -FARPROC MemoryGetProcAddress(HMEMORYMODULE module, const char *name) +void MemoryFreeLibrary(HMEMORYMODULE mod) { - unsigned char *codeBase = ((PMEMORYMODULE)module)->codeBase; - int idx=-1; - PIMAGE_EXPORT_DIRECTORY exports; - PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY((PMEMORYMODULE)module, IMAGE_DIRECTORY_ENTRY_EXPORT); + int i; + PMEMORYMODULE module = (PMEMORYMODULE)mod; - if (directory->Size == 0) - // no export table found - return NULL; + if (module != NULL) { + if (module->initialized != 0) { + // notify library about detaching from process + DllEntryProc DllEntry = (DllEntryProc) (module->codeBase + module->headers->OptionalHeader.AddressOfEntryPoint); + (*DllEntry)((HINSTANCE)module->codeBase, DLL_PROCESS_DETACH, 0); + module->initialized = 0; + } - exports = (PIMAGE_EXPORT_DIRECTORY)(codeBase + directory->VirtualAddress); - if (exports->NumberOfNames == 0 || exports->NumberOfFunctions == 0) - // DLL doesn't export anything - return NULL; + if (module->modules != NULL) { + // free previously opened libraries + for (i=0; i<module->numModules; i++) { + if (module->modules[i] != NULL) { + module->freeLibrary(module->modules[i], module->userdata); + } + } - if (HIWORD(name)) { - struct NAME_TABLE *ptab; - struct NAME_TABLE *found; - ptab = GetNameTable((PMEMORYMODULE)module); - if (ptab == NULL) - // some failure - return NULL; - found = bsearch(&name, ptab, exports->NumberOfNames, sizeof(struct NAME_TABLE), _find); - if (found == NULL) - // exported symbol not found - return NULL; - - idx = found->ordinal; - } - else - idx = LOWORD(name) - exports->Base; + free(module->modules); + } - if ((DWORD)idx > exports->NumberOfFunctions) - // name <-> ordinal number don't match - return NULL; - - // AddressOfFunctions contains the RVAs to the "real" functions - return (FARPROC)(codeBase + *(DWORD *)(codeBase + exports->AddressOfFunctions + (idx*4))); + if (module->codeBase != NULL) { + // release memory of library + VirtualFree(module->codeBase, 0, MEM_RELEASE); + } + + HeapFree(GetProcessHeap(), 0, module); + } } -void MemoryFreeLibrary(HMEMORYMODULE mod) +#define DEFAULT_LANGUAGE MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL) + +HMEMORYRSRC MemoryFindResource(HMEMORYMODULE module, LPCTSTR name, LPCTSTR type) { - int i; - PMEMORYMODULE module = (PMEMORYMODULE)mod; + return MemoryFindResourceEx(module, name, type, DEFAULT_LANGUAGE); +} - if (module != NULL) - { - if (module->initialized != 0) - { - // notify library about detaching from process - DllEntryProc DllEntry = (DllEntryProc)(module->codeBase + module->headers->OptionalHeader.AddressOfEntryPoint); - (*DllEntry)((HINSTANCE)module->codeBase, DLL_PROCESS_DETACH, 0); - module->initialized = 0; - } +static PIMAGE_RESOURCE_DIRECTORY_ENTRY _MemorySearchResourceEntry( + void *root, + PIMAGE_RESOURCE_DIRECTORY resources, + LPCTSTR key) +{ + PIMAGE_RESOURCE_DIRECTORY_ENTRY entries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (resources + 1); + PIMAGE_RESOURCE_DIRECTORY_ENTRY result = NULL; + DWORD start; + DWORD end; + DWORD middle; + + if (!IS_INTRESOURCE(key) && key[0] == TEXT('#')) { + // special case: resource id given as string + TCHAR *endpos = NULL; +#if defined(UNICODE) + long int tmpkey = (WORD) wcstol((TCHAR *) &key[1], &endpos, 10); +#else + long int tmpkey = (WORD) strtol((TCHAR *) &key[1], &endpos, 10); +#endif + if (tmpkey <= 0xffff && lstrlen(endpos) == 0) { + key = MAKEINTRESOURCE(tmpkey); + } + } + + // entries are stored as ordered list of named entries, + // followed by an ordered list of id entries - we can do + // a binary search to find faster... + if (IS_INTRESOURCE(key)) { + WORD check = (WORD) (POINTER_TYPE) key; + start = resources->NumberOfNamedEntries; + end = start + resources->NumberOfIdEntries; + + while (end > start) { + WORD entryName; + middle = (start + end) >> 1; + entryName = (WORD) entries[middle].Name; + if (check < entryName) { + end = (end != middle ? middle : middle-1); + } else if (check > entryName) { + start = (start != middle ? middle : middle+1); + } else { + result = &entries[middle]; + break; + } + } + } else { +#if !defined(UNICODE) + char *searchKey = NULL; + int searchKeyLength = 0; +#endif + start = 0; + end = resources->NumberOfIdEntries; + while (end > start) { + // resource names are always stored using 16bit characters + int cmp; + PIMAGE_RESOURCE_DIR_STRING_U resourceString; + middle = (start + end) >> 1; + resourceString = (PIMAGE_RESOURCE_DIR_STRING_U) (((char *) root) + (entries[middle].Name & 0x7FFFFFFF)); +#if !defined(UNICODE) + if (searchKey == NULL || searchKeyLength < resourceString->Length) { + void *tmp = realloc(searchKey, resourceString->Length); + if (tmp == NULL) { + break; + } + + searchKey = (char *) tmp; + } + wcstombs(searchKey, resourceString->NameString, resourceString->Length); + cmp = strncmp(key, searchKey, resourceString->Length); +#else + cmp = wcsncmp(key, resourceString->NameString, resourceString->Length); +#endif + if (cmp < 0) { + end = (middle != end ? middle : middle-1); + } else if (cmp > 0) { + start = (middle != start ? middle : middle+1); + } else { + result = &entries[middle]; + break; + } + } +#if !defined(UNICODE) + free(searchKey); +#endif + } + + + return result; +} - if (module->modules != NULL) - { - // free previously opened libraries - for (i=0; i<module->numModules; i++) - if (module->modules[i] != INVALID_HANDLE_VALUE) - MyFreeLibrary(module->modules[i]); +HMEMORYRSRC MemoryFindResourceEx(HMEMORYMODULE module, LPCTSTR name, LPCTSTR type, WORD language) +{ + unsigned char *codeBase = ((PMEMORYMODULE) module)->codeBase; + PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY((PMEMORYMODULE) module, IMAGE_DIRECTORY_ENTRY_RESOURCE); + PIMAGE_RESOURCE_DIRECTORY rootResources; + PIMAGE_RESOURCE_DIRECTORY nameResources; + PIMAGE_RESOURCE_DIRECTORY typeResources; + PIMAGE_RESOURCE_DIRECTORY_ENTRY foundType; + PIMAGE_RESOURCE_DIRECTORY_ENTRY foundName; + PIMAGE_RESOURCE_DIRECTORY_ENTRY foundLanguage; + if (directory->Size == 0) { + // no resource table found + SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); + return NULL; + } + + if (language == DEFAULT_LANGUAGE) { + // use language from current thread + language = LANGIDFROMLCID(GetThreadLocale()); + } - free(module->modules); - } + // resources are stored as three-level tree + // - first node is the type + // - second node is the name + // - third node is the language + rootResources = (PIMAGE_RESOURCE_DIRECTORY) (codeBase + directory->VirtualAddress); + foundType = _MemorySearchResourceEntry(rootResources, rootResources, type); + if (foundType == NULL) { + SetLastError(ERROR_RESOURCE_TYPE_NOT_FOUND); + return NULL; + } + + typeResources = (PIMAGE_RESOURCE_DIRECTORY) (codeBase + directory->VirtualAddress + (foundType->OffsetToData & 0x7fffffff)); + foundName = _MemorySearchResourceEntry(rootResources, typeResources, name); + if (foundName == NULL) { + SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND); + return NULL; + } + + nameResources = (PIMAGE_RESOURCE_DIRECTORY) (codeBase + directory->VirtualAddress + (foundName->OffsetToData & 0x7fffffff)); + foundLanguage = _MemorySearchResourceEntry(rootResources, nameResources, (LPCTSTR) (POINTER_TYPE) language); + if (foundLanguage == NULL) { + // requested language not found, use first available + if (nameResources->NumberOfIdEntries == 0) { + SetLastError(ERROR_RESOURCE_LANG_NOT_FOUND); + return NULL; + } + + foundLanguage = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (nameResources + 1); + } + + return (codeBase + directory->VirtualAddress + (foundLanguage->OffsetToData & 0x7fffffff)); +} - if (module->codeBase != NULL) - // release memory of library - VirtualFree(module->codeBase, 0, MEM_RELEASE); +DWORD MemorySizeofResource(HMEMORYMODULE module, HMEMORYRSRC resource) +{ + PIMAGE_RESOURCE_DATA_ENTRY entry = (PIMAGE_RESOURCE_DATA_ENTRY) resource; + + return entry->Size; +} - if (module->name_table != NULL) - free(module->name_table); +LPVOID MemoryLoadResource(HMEMORYMODULE module, HMEMORYRSRC resource) +{ + unsigned char *codeBase = ((PMEMORYMODULE) module)->codeBase; + PIMAGE_RESOURCE_DATA_ENTRY entry = (PIMAGE_RESOURCE_DATA_ENTRY) resource; + + return codeBase + entry->OffsetToData; +} - HeapFree(GetProcessHeap(), 0, module); - } +int +MemoryLoadString(HMEMORYMODULE module, UINT id, LPTSTR buffer, int maxsize) +{ + return MemoryLoadStringEx(module, id, buffer, maxsize, DEFAULT_LANGUAGE); } + +int +MemoryLoadStringEx(HMEMORYMODULE module, UINT id, LPTSTR buffer, int maxsize, WORD language) +{ + HMEMORYRSRC resource; + PIMAGE_RESOURCE_DIR_STRING_U data; + DWORD size; + if (maxsize == 0) { + return 0; + } + + resource = MemoryFindResourceEx(module, MAKEINTRESOURCE((id >> 4) + 1), RT_STRING, language); + if (resource == NULL) { + buffer[0] = 0; + return 0; + } + + data = MemoryLoadResource(module, resource); + id = id & 0x0f; + while (id--) { + data = (PIMAGE_RESOURCE_DIR_STRING_U) (((char *) data) + (data->Length + 1) * sizeof(WCHAR)); + } + if (data->Length == 0) { + SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND); + buffer[0] = 0; + return 0; + } + + size = data->Length; + if (size >= (DWORD) maxsize) { + size = maxsize; + } else { + buffer[size] = 0; + } +#if defined(UNICODE) + wcsncpy(buffer, data->NameString, size); +#else + wcstombs(buffer, data->NameString, size); +#endif + return size; +} Modified: trunk/py2exe/source/MemoryModule.h =================================================================== --- trunk/py2exe/source/MemoryModule.h 2013-05-31 18:50:41 UTC (rev 725) +++ trunk/py2exe/source/MemoryModule.h 2013-06-05 18:42:13 UTC (rev 726) @@ -1,12 +1,12 @@ /* * Memory DLL loading code - * Version 0.0.2 + * Version 0.0.3 * - * Copyright (c) 2004-2005 by Joachim Bauch / ma...@jo... + * Copyright (c) 2004-2013 by Joachim Bauch / ma...@jo... * http://www.joachim-bauch.de * * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (the "License"); you may not use this file except in compliance with + * 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * @@ -19,7 +19,7 @@ * * The Initial Developer of the Original Code is Joachim Bauch. * - * Portions created by Joachim Bauch are Copyright (C) 2004-2005 + * Portions created by Joachim Bauch are Copyright (C) 2004-2013 * Joachim Bauch. All Rights Reserved. * */ @@ -27,30 +27,81 @@ #ifndef __MEMORY_MODULE_HEADER #define __MEMORY_MODULE_HEADER -#include <Windows.h> +#include <windows.h> typedef void *HMEMORYMODULE; +typedef void *HMEMORYRSRC; + +typedef void *HCUSTOMMODULE; + #ifdef __cplusplus extern "C" { #endif -typedef void *(*FINDPROC)(); +typedef HCUSTOMMODULE (*CustomLoadLibraryFunc)(LPCSTR, void *); +typedef FARPROC (*CustomGetProcAddressFunc)(HCUSTOMMODULE, LPCSTR, void *); +typedef void (*CustomFreeLibraryFunc)(HCUSTOMMODULE, void *); -extern FINDPROC findproc; -extern void *findproc_data; +/** + * Load DLL from memory location. + * + * All dependencies are resolved using default LoadLibrary/GetProcAddress + * calls through the Windows API. + */ +HMEMORYMODULE MemoryLoadLibrary(const void *); -HMEMORYMODULE MemoryLoadLibrary(char *, const void *); +/** + * Load DLL from memory location using custom dependency resolvers. + * + * Dependencies will be resolved using passed callback methods. + */ +HMEMORYMODULE MemoryLoadLibraryEx(const void *, + CustomLoadLibraryFunc, + CustomGetProcAddressFunc, + CustomFreeLibraryFunc, + void *); -FARPROC MemoryGetProcAddress(HMEMORYMODULE, const char *); +/** + * Get address of exported method. + */ +FARPROC MemoryGetProcAddress(HMEMORYMODULE, LPCSTR); +/** + * Free previously loaded DLL. + */ void MemoryFreeLibrary(HMEMORYMODULE); -BOOL MyFreeLibrary(HMODULE hModule); -HMODULE MyLoadLibrary(char *lpFileName); -FARPROC MyGetProcAddress(HMODULE hModule, LPCSTR lpProcName); -HMODULE MyGetModuleHandle(LPCTSTR lpModuleName); +/** + * Find the location of a resource with the specified type and name. + */ +HMEMORYRSRC MemoryFindResource(HMEMORYMODULE, LPCTSTR, LPCTSTR); +/** + * Find the location of a resource with the specified type, name and language. + */ +HMEMORYRSRC MemoryFindResourceEx(HMEMORYMODULE, LPCTSTR, LPCTSTR, WORD); + +/** + * Get the size of the resource in bytes. + */ +DWORD MemorySizeofResource(HMEMORYMODULE, HMEMORYRSRC); + +/** + * Get a pointer to the contents of the resource. + */ +LPVOID MemoryLoadResource(HMEMORYMODULE, HMEMORYRSRC); + +/** + * Load a string resource. + */ +int MemoryLoadString(HMEMORYMODULE, UINT, LPTSTR, int); + +/** + * Load a string resource with a given language. + */ +int MemoryLoadStringEx(HMEMORYMODULE, UINT, LPTSTR, int, WORD); + #ifdef __cplusplus } #endif Added: trunk/py2exe/source/MyLoadLibrary.c =================================================================== --- trunk/py2exe/source/MyLoadLibrary.c (rev 0) +++ trunk/py2exe/source/MyLoadLibrary.c 2013-06-05 18:42:13 UTC (rev 726) @@ -0,0 +1,207 @@ +#ifdef STANDALONE +# include <Python.h> +# include "Python-version.h" +#else +# include "Python-dynload.h" +# include <stdio.h> +#endif +#include <windows.h> + +#include "MemoryModule.h" +#include "MyLoadLibrary.h" + +/* + +Windows API: +============ + +HMODULE LoadLibraryA(LPCSTR) +HMODULE GetModuleHandleA(LPCSTR) +BOOL FreeLibrary(HMODULE) +FARPROC GetProcAddress(HMODULE, LPCSTR) + + +MemoryModule API: +================= + +HMEMORYMODULE MemoryLoadLibrary(void *) +void MemoryFreeLibrary(HMEMORYMODULE) +FARPROC MemoryGetProcAddress(HMEMORYMODULE, LPCSTR) + +HMEMORYMODULE MemoryLoadLibrayEx(void *, + load_func, getproc_func, free_func, userdata) + +(there are also some resource functions which are not used here...) + +General API in this file: +========================= + +HMODULE MyLoadLibrary(LPCSTR, void *, userdata) +HMODULE MyGetModuleHandle(LPCSTR) +BOOL MyFreeLibrary(HMODULE) +FARPROC MyGetProcAddress(HMODULE, LPCSTR) + + */ + +/**************************************************************** + * A linked list of loaded MemoryModules. + */ +typedef struct tagLIST { + HCUSTOMMODULE module; + LPCSTR name; + struct tagLIST *next; + struct tagLIST *prev; + int refcount; +} LIST; + +static LIST *libraries; + +/**************************************************************** + * Search for a loaded MemoryModule in the linked list, either by name + * or by module handle. + */ +static LIST *_FindMemoryModule(LPCSTR name, HMODULE module) +{ + LIST *lib = libraries; + while (lib) { + if (name && 0 == stricmp(name, lib->name)) { +// printf("_FindMemoryModule(%s, %p) -> %s\n", name, module, lib->name); + return lib; + } else if (module == lib->module) { +// printf("_FindMemoryModule(%s, %p) -> %s\n", name, module, lib->name); + return lib; + } else { + lib = lib->next; + } + } +// printf("_FindMemoryModule(%s, %p) -> NULL\n", name, module); + return NULL; +} + +/**************************************************************** + * Insert a MemoryModule into the linked list of loaded modules + */ +static LIST *_AddMemoryModule(LPCSTR name, HCUSTOMMODULE module) +{ + LIST *entry = (LIST *)malloc(sizeof(LIST)); + entry->name = strdup(name); + entry->module = module; + entry->next = libraries; + entry->prev = NULL; + entry->refcount = 1; + libraries = entry; +// printf("_AddMemoryModule(%s, %p) -> %p\n", name, module, entry); + return entry; +} + +/**************************************************************** + * Helper functions for MemoryLoadLibraryEx + */ +static FARPROC _GetProcAddress(HCUSTOMMODULE module, LPCSTR name, void *userdata) +{ + FARPROC res; + res = (FARPROC)GetProcAddress((HMODULE)module, name); + if (res == NULL) { + SetLastError(0); + return MemoryGetProcAddress(module, name); + } else + return res; +} + +static void _FreeLibrary(HCUSTOMMODULE module, void *userdata) +{ + LIST *lib = _FindMemoryModule(NULL, module); + if (lib && --lib->refcount == 0) + MemoryFreeLibrary(module); + else + FreeLibrary((HMODULE) module); +} + +static HCUSTOMMODULE _LoadLibrary(LPCSTR filename, void *userdata) +{ + HCUSTOMMODULE result; + LIST *lib = _FindMemoryModule(filename, NULL); + if (lib) { + lib->refcount += 1; + return lib->module; + } + if (userdata) { + PyObject *findproc = (PyObject *)userdata; + PyObject *res = PyObject_CallFunction(findproc, "s", filename); + if (res && PyString_AsString(res)) { + result = MemoryLoadLibraryEx(PyString_AsString(res), + _LoadLibrary, _GetProcAddress, _FreeLibrary, + userdata); + Py_DECREF(res); + lib = _AddMemoryModule(filename, result); + return lib->module; + } else { + PyErr_Clear(); + } + PyErr_Clear(); + } + return (HCUSTOMMODULE)LoadLibraryA(filename); +} + +/**************************************************************** + * Public functions + */ +HMODULE MyGetModuleHandle(LPCSTR name) +{ + LIST *lib; + lib = _FindMemoryModule(name, NULL); + if (lib) + return lib->module; + return GetModuleHandle(name); +} + +HMODULE MyLoadLibrary(LPCSTR name, void *data, void *userdata) +{ + LIST *lib; +// printf("MyLoadLibrary(%s, %p, %p)\n", name, data, userdata); + lib = _FindMemoryModule(name, NULL); + if (lib) { + ++lib->refcount; + return lib->module; + } + if (userdata) { + HCUSTOMMODULE mod = _LoadLibrary(name, userdata); + if (mod) { + LIST *lib = _AddMemoryModule(name, mod); + return lib->module; + } + } else if (data) { + HCUSTOMMODULE mod = MemoryLoadLibraryEx(data, + _LoadLibrary, + _GetProcAddress, + _FreeLibrary, + userdata); + if (mod) { + LIST *lib = _AddMemoryModule(name, mod); + return lib->module; + } + } + return LoadLibrary(name); +} + +BOOL MyFreeLibrary(HMODULE module) +{ + LIST *lib = _FindMemoryModule(NULL, module); + if (lib) { + if (--lib->refcount == 0) { + MemoryFreeLibrary(module); + /* remove lib entry from linked list */ + } + return TRUE; + } else + return FreeLibrary(module); +} + +FARPROC MyGetProcAddress(HMODULE module, LPCSTR procname) +{ + LIST *lib = _FindMemoryModule(NULL, module); + if (lib) + return MemoryGetProcAddress(lib->module, procname); + else + return GetProcAddress(module, procname); +} Added: trunk/py2exe/source/MyLoadLibrary.h =================================================================== --- trunk/py2exe/source/MyLoadLibrary.h (rev 0) +++ trunk/py2exe/source/MyLoadLibrary.h 2013-06-05 18:42:13 UTC (rev 726) @@ -0,0 +1,13 @@ +#ifndef GENERALLOADLIBRARY_H +#define GENERALLOADLIBRARY_H + +HMODULE MyLoadLibrary(LPCSTR, void *, void *); + +HMODULE MyGetModuleHandle(LPCSTR); + +BOOL MyFreeLibrary(HMODULE); + +FARPROC MyGetProcAddress(HMODULE, LPCSTR); + + +#endif Modified: trunk/py2exe/source/Python-dynload.c =================================================================== --- trunk/py2exe/source/Python-dynload.c 2013-05-31 18:50:41 UTC (rev 725) +++ trunk/py2exe/source/Python-dynload.c 2013-06-05 18:42:13 UTC (rev 726) @@ -1,6 +1,7 @@ /* **************** Python-dynload.c **************** */ #include "Python-dynload.h" -#include "MemoryModule.h" +#include <windows.h> +#include "MyLoadLibrary.h" #include "actctx.h" #include <stdio.h> @@ -70,13 +71,13 @@ return _load_python_FromFile(dllname); cookie = _My_ActivateActCtx();//try some windows manifest magic... - hmod = MemoryLoadLibrary(dllname, bytes); + hmod = MyLoadLibrary(dllname, bytes, NULL); _My_DeactivateActCtx(cookie); if (hmod == NULL) { return 0; } for (i = 0; p->name; ++i, ++p) { - p->proc = (void (*)())MemoryGetProcAddress(hmod, p->name); + p->proc = (void (*)())MyGetProcAddress(hmod, p->name); if (p->proc == NULL) { OutputDebugString("undef symbol"); fprintf(stderr, "undefined symbol %s -> exit(-1)\n", p->name); Modified: trunk/py2exe/source/_memimporter.c =================================================================== --- trunk/py2exe/source/_memimporter.c 2013-05-31 18:50:41 UTC (rev 725) +++ trunk/py2exe/source/_memimporter.c 2013-06-05 18:42:13 UTC (rev 726) @@ -15,87 +15,40 @@ static char module_doc[] = "Importer which can load extension modules from memory"; -#include "MemoryModule.h" +#include "MyLoadLibrary.h" #include "actctx.h" -static void *memdup(void *ptr, Py_ssize_t size) -{ - void *p = malloc(size); - if (p == NULL) - return NULL; - memcpy(p, ptr, size); - return p; -} - -/* - Be sure to detect errors in FindLibrary - undetected errors lead to - very strange bahaviour. -*/ -static void* FindLibrary(char *name, PyObject *callback) -{ - PyObject *result; - char *p; - Py_ssize_t size; - - if (callback == NULL) - return NULL; - result = PyObject_CallFunction(callback, "s", name); - if (result == NULL) { - PyErr_Clear(); - return NULL; - } - if (-1 == PyString_AsStringAndSize(result, &p, &size)) { - PyErr_Clear(); - Py_DECREF(result); - return NULL; - } - p = memdup(p, size); - Py_DECREF(result); - return p; -} - -static PyObject *set_find_proc(PyObject *self, PyObject *args) -{ - PyObject *callback = NULL; - if (!PyArg_ParseTuple(args, "|O:set_find_proc", &callback)) - return NULL; - Py_XDECREF((PyObject *)findproc_data); - Py_XINCREF(callback); - findproc_data = (void *)callback; - Py_INCREF(Py_None); - return Py_None; -} - static PyObject * import_module(PyObject *self, PyObject *args) { - char *data; - int size; char *initfuncname; char *modname; char *pathname; - HMEMORYMODULE hmem; + HMODULE hmem; FARPROC do_init; char *oldcontext; ULONG_PTR cookie = 0; + PyObject *findproc; /* code, initfuncname, fqmodulename, path */ - if (!PyArg_ParseTuple(args, "s#sss:import_module", - &data, &size, - &initfuncname, &modname, &pathname)) + if (!PyArg_ParseTuple(args, "sssO:import_module", + &modname, &pathname, + &initfuncname, + &findproc)) return NULL; cookie = _My_ActivateActCtx();//try some windows manifest magic... - hmem = MemoryLoadLibrary(pathname, data); + hmem = MyLoadLibrary(pathname, NULL, findproc); _My_DeactivateActCtx(cookie); + if (!hmem) { PyErr_Format(PyExc_ImportError, "MemoryLoadLibrary failed loading %s", pathname); return NULL; } - do_init = MemoryGetProcAddress(hmem, initfuncname); + do_init = MyGetProcAddress(hmem, initfuncname); if (!do_init) { ... [truncated message content] |