| /* | |
| * Win32 builtin functions | |
| * | |
| * Copyright 1997 Alexandre Julliard | |
| */ | |
| #include <assert.h> | |
| #include <string.h> | |
| #include <ctype.h> | |
| #include "winuser.h" | |
| #include "builtin32.h" | |
| #include "peexe.h" | |
| #include "neexe.h" | |
| #include "heap.h" | |
| #include "debug.h" | |
| #include "main.h" | |
| typedef struct | |
| { | |
| BYTE call; /* 0xe8 call callfrom32 (relative) */ | |
| DWORD callfrom32 WINE_PACKED; /* RELAY_CallFrom32 relative addr */ | |
| BYTE ret; /* 0xc2 ret $n or 0xc3 ret */ | |
| WORD args; /* nb of args to remove from the stack */ | |
| } DEBUG_ENTRY_POINT; | |
| typedef struct | |
| { | |
| const BUILTIN32_DESCRIPTOR *descr; /* DLL descriptor */ | |
| BOOL used; /* Used by default */ | |
| } BUILTIN32_DLL; | |
| extern const BUILTIN32_DESCRIPTOR ADVAPI32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR AVIFIL32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR COMCTL32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR COMDLG32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR CRTDLL_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR DCIMAN32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR DDRAW_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR DINPUT_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR DPLAY_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR DPLAYX_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR DSOUND_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR GDI32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR IMAGEHLP_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR IMM32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR KERNEL32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR LZ32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR MPR_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR MSACM32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR MSNET32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR MSVFW32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR NTDLL_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR OLE32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR OLEAUT32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR OLECLI32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR OLEDLG_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR OLESVR32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR PSAPI_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR RASAPI32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR SHELL32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR TAPI32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR USER32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR VERSION_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR W32SKRNL_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR WINMM_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR WINSPOOL_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR WNASPI32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR WOW32_Descriptor; | |
| extern const BUILTIN32_DESCRIPTOR WSOCK32_Descriptor; | |
| static BUILTIN32_DLL BuiltinDLLs[] = | |
| { | |
| { &ADVAPI32_Descriptor, TRUE }, | |
| { &AVIFIL32_Descriptor, FALSE }, | |
| { &COMCTL32_Descriptor, FALSE }, | |
| { &COMDLG32_Descriptor, TRUE }, | |
| { &CRTDLL_Descriptor, TRUE }, | |
| { &DCIMAN32_Descriptor, FALSE }, | |
| { &DDRAW_Descriptor, TRUE }, | |
| { &DINPUT_Descriptor, TRUE }, | |
| { &DPLAY_Descriptor, FALSE }, | |
| { &DPLAYX_Descriptor, FALSE }, | |
| { &DSOUND_Descriptor, TRUE }, | |
| { &GDI32_Descriptor, TRUE }, | |
| { &IMAGEHLP_Descriptor, FALSE }, | |
| { &IMM32_Descriptor, FALSE }, | |
| { &KERNEL32_Descriptor, TRUE }, | |
| { &LZ32_Descriptor, TRUE }, | |
| { &MPR_Descriptor, TRUE }, | |
| { &MSACM32_Descriptor, FALSE }, | |
| { &MSNET32_Descriptor, FALSE }, | |
| { &MSVFW32_Descriptor, TRUE }, | |
| { &NTDLL_Descriptor, TRUE }, | |
| { &OLE32_Descriptor, FALSE }, | |
| { &OLEAUT32_Descriptor, FALSE }, | |
| { &OLECLI32_Descriptor, FALSE }, | |
| { &OLEDLG_Descriptor, FALSE }, | |
| { &OLESVR32_Descriptor, FALSE }, | |
| { &PSAPI_Descriptor, FALSE }, | |
| { &RASAPI32_Descriptor, FALSE }, | |
| { &SHELL32_Descriptor, TRUE }, | |
| { &TAPI32_Descriptor, FALSE }, | |
| { &USER32_Descriptor, TRUE }, | |
| { &VERSION_Descriptor, TRUE }, | |
| { &W32SKRNL_Descriptor, TRUE }, | |
| { &WINMM_Descriptor, TRUE }, | |
| { &WINSPOOL_Descriptor, TRUE }, | |
| { &WNASPI32_Descriptor, TRUE }, | |
| { &WOW32_Descriptor, TRUE }, | |
| { &WSOCK32_Descriptor, TRUE }, | |
| /* Last entry */ | |
| { NULL, FALSE } | |
| }; | |
| extern void RELAY_CallFrom32(); | |
| /*********************************************************************** | |
| * BUILTIN32_DoLoadImage | |
| * | |
| * Load a built-in Win32 module. Helper function for BUILTIN32_LoadImage. | |
| */ | |
| static HMODULE BUILTIN32_DoLoadImage( BUILTIN32_DLL *dll ) | |
| { | |
| IMAGE_DATA_DIRECTORY *dir; | |
| IMAGE_DOS_HEADER *dos; | |
| IMAGE_NT_HEADERS *nt; | |
| IMAGE_SECTION_HEADER *sec; | |
| IMAGE_EXPORT_DIRECTORY *exp; | |
| LPVOID *funcs; | |
| LPSTR *names; | |
| DEBUG_ENTRY_POINT *debug; | |
| INT i, size; | |
| BYTE *addr; | |
| /* Allocate the module */ | |
| size = (sizeof(IMAGE_DOS_HEADER) | |
| + sizeof(IMAGE_NT_HEADERS) | |
| + 2 * sizeof(IMAGE_SECTION_HEADER) | |
| + sizeof(IMAGE_EXPORT_DIRECTORY) | |
| + dll->descr->nb_funcs * sizeof(LPVOID) | |
| + dll->descr->nb_names * sizeof(LPSTR)); | |
| #ifdef __i386__ | |
| if (WARN_ON(relay) || TRACE_ON(relay)) | |
| size += dll->descr->nb_funcs * sizeof(DEBUG_ENTRY_POINT); | |
| #endif | |
| addr = VirtualAlloc( NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE ); | |
| if (!addr) return 0; | |
| dos = (IMAGE_DOS_HEADER *)addr; | |
| nt = (IMAGE_NT_HEADERS *)(dos + 1); | |
| sec = (IMAGE_SECTION_HEADER *)(nt + 1); | |
| exp = (IMAGE_EXPORT_DIRECTORY *)(sec + 2); | |
| funcs = (LPVOID *)(exp + 1); | |
| names = (LPSTR *)(funcs + dll->descr->nb_funcs); | |
| debug = (DEBUG_ENTRY_POINT *)(names + dll->descr->nb_names); | |
| /* Build the DOS and NT headers */ | |
| dos->e_magic = IMAGE_DOS_SIGNATURE; | |
| dos->e_lfanew = sizeof(*dos); | |
| nt->Signature = IMAGE_NT_SIGNATURE; | |
| nt->FileHeader.Machine = IMAGE_FILE_MACHINE_I386; | |
| nt->FileHeader.NumberOfSections = 2; /* exports + code */ | |
| nt->FileHeader.SizeOfOptionalHeader = sizeof(nt->OptionalHeader); | |
| nt->FileHeader.Characteristics = IMAGE_FILE_DLL; | |
| nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; | |
| nt->OptionalHeader.SizeOfCode = 0x1000; | |
| nt->OptionalHeader.SizeOfInitializedData = 0; | |
| nt->OptionalHeader.SizeOfUninitializedData = 0; | |
| nt->OptionalHeader.ImageBase = (DWORD)addr; | |
| nt->OptionalHeader.SectionAlignment = 0x1000; | |
| nt->OptionalHeader.FileAlignment = 0x1000; | |
| nt->OptionalHeader.MajorOperatingSystemVersion = 1; | |
| nt->OptionalHeader.MinorOperatingSystemVersion = 0; | |
| nt->OptionalHeader.MajorSubsystemVersion = 4; | |
| nt->OptionalHeader.MinorSubsystemVersion = 0; | |
| nt->OptionalHeader.SizeOfImage = size; | |
| nt->OptionalHeader.SizeOfHeaders = (BYTE *)exp - addr; | |
| nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES; | |
| if (dll->descr->dllentrypoint) | |
| nt->OptionalHeader.AddressOfEntryPoint = (DWORD)dll->descr->dllentrypoint - (DWORD)addr; | |
| /* Build the export directory */ | |
| dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY]; | |
| dir->VirtualAddress = (BYTE *)exp - addr; | |
| dir->Size = sizeof(*exp) | |
| + dll->descr->nb_funcs * sizeof(LPVOID) | |
| + dll->descr->nb_names * sizeof(LPSTR); | |
| /* Build the exports section */ | |
| strcpy( sec->Name, ".edata" ); | |
| sec->Misc.VirtualSize = dir->Size; | |
| sec->VirtualAddress = (BYTE *)exp - addr; | |
| sec->SizeOfRawData = dir->Size; | |
| sec->PointerToRawData = (BYTE *)exp - addr; | |
| sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA | | |
| IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ | | |
| IMAGE_SCN_MEM_WRITE); | |
| /* Build the code section */ | |
| sec++; | |
| strcpy( sec->Name, ".code" ); | |
| sec->SizeOfRawData = 0; | |
| #ifdef __i386__ | |
| if (WARN_ON(relay) || TRACE_ON(relay)) | |
| sec->SizeOfRawData += dll->descr->nb_funcs * sizeof(DEBUG_ENTRY_POINT); | |
| #endif | |
| sec->Misc.VirtualSize = sec->SizeOfRawData; | |
| sec->VirtualAddress = (BYTE *)debug - addr; | |
| sec->PointerToRawData = (BYTE *)debug - addr; | |
| sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA | | |
| IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ); | |
| /* Build the exports section data */ | |
| exp->Name = ((BYTE *)dll->descr->name) - addr; /*??*/ | |
| exp->Base = dll->descr->base; | |
| exp->NumberOfFunctions = dll->descr->nb_funcs; | |
| exp->NumberOfNames = dll->descr->nb_names; | |
| exp->AddressOfFunctions = (LPDWORD *)((BYTE *)funcs - addr); | |
| exp->AddressOfNames = (LPDWORD *)((BYTE *)names - addr); | |
| exp->AddressOfNameOrdinals = (LPWORD *)((BYTE *)dll->descr->ordinals - addr); | |
| /* Build the funcs table */ | |
| for (i = 0; i < dll->descr->nb_funcs; i++, funcs++, debug++) | |
| { | |
| BYTE args = dll->descr->args[i]; | |
| int j; | |
| if (!dll->descr->functions[i]) continue; | |
| *funcs = (LPVOID)((BYTE *)dll->descr->functions[i] - addr); | |
| #ifdef __i386__ | |
| if (!(WARN_ON(relay) || TRACE_ON(relay))) continue; | |
| for (j=0;j<dll->descr->nb_names;j++) | |
| if (dll->descr->ordinals[j] == i) | |
| break; | |
| if (j<dll->descr->nb_names) { | |
| if (dll->descr->names[j]) { | |
| char buffer[200]; | |
| sprintf(buffer,"%s.%d: %s",dll->descr->name,i,dll->descr->names[j]); | |
| if (!RELAY_ShowDebugmsgRelay(buffer)) | |
| continue; | |
| } | |
| } | |
| switch(args) | |
| { | |
| case 0xfe: /* register func */ | |
| debug->call = 0xe8; | |
| debug->callfrom32 = (DWORD)dll->descr->functions[i] - | |
| (DWORD)&debug->ret; | |
| debug->ret = 0x90; /* nop */ | |
| debug->args = 0; | |
| *funcs = (LPVOID)((BYTE *)debug - addr); | |
| break; | |
| case 0xff: /* stub or extern */ | |
| break; | |
| default: /* normal function (stdcall or cdecl) */ | |
| if (TRACE_ON(relay)) { | |
| debug->call = 0xe8; /* lcall relative */ | |
| debug->callfrom32 = (DWORD)RELAY_CallFrom32 - | |
| (DWORD)&debug->ret; | |
| } else { | |
| debug->call = 0xe9; /* ljmp relative */ | |
| debug->callfrom32 = (DWORD)dll->descr->functions[i] - | |
| (DWORD)&debug->ret; | |
| } | |
| debug->ret = (args & 0x80) ? 0xc3 : 0xc2; /*ret/ret $n*/ | |
| debug->args = (args & 0x7f) * sizeof(int); | |
| *funcs = (LPVOID)((BYTE *)debug - addr); | |
| break; | |
| } | |
| #endif /* __i386__ */ | |
| } | |
| /* Build the names table */ | |
| for (i = 0; i < exp->NumberOfNames; i++, names++) | |
| if (dll->descr->names[i]) | |
| *names = (LPSTR)((BYTE *)dll->descr->names[i] - addr); | |
| return (HMODULE)addr; | |
| } | |
| /*********************************************************************** | |
| * BUILTIN32_LoadImage | |
| * | |
| * Load a built-in module. If the 'force' parameter is FALSE, we only | |
| * load the module if it has not been disabled via the -dll option. | |
| */ | |
| HMODULE BUILTIN32_LoadImage( LPCSTR name, OFSTRUCT *ofs, BOOL force ) | |
| { | |
| BUILTIN32_DLL *table; | |
| char dllname[16], *p; | |
| /* Fix the name in case we have a full path and extension */ | |
| if ((p = strrchr( name, '\\' ))) name = p + 1; | |
| lstrcpynA( dllname, name, sizeof(dllname) ); | |
| if ((p = strrchr( dllname, '.' ))) *p = '\0'; | |
| for (table = BuiltinDLLs; table->descr; table++) | |
| if (!lstrcmpiA( table->descr->name, dllname )) break; | |
| if (!table->descr) return 0; | |
| if (!table->used) | |
| { | |
| if (!force) return 0; | |
| table->used = TRUE; /* So next time we use it at once */ | |
| } | |
| sprintf( ofs->szPathName, "%s.DLL", table->descr->name ); | |
| return BUILTIN32_DoLoadImage( table ); | |
| } | |
| /*********************************************************************** | |
| * BUILTIN32_GetEntryPoint | |
| * | |
| * Return the name of the DLL entry point corresponding | |
| * to a relay entry point address. This is used only by relay debugging. | |
| * | |
| * This function _must_ return the real entry point to call | |
| * after the debug info is printed. | |
| */ | |
| ENTRYPOINT32 BUILTIN32_GetEntryPoint( char *buffer, void *relay, | |
| unsigned int *typemask ) | |
| { | |
| BUILTIN32_DLL *dll; | |
| HMODULE hModule; | |
| int ordinal = 0, i; | |
| /* First find the module */ | |
| for (dll = BuiltinDLLs; dll->descr; dll++) | |
| if (dll->used | |
| && ((hModule = GetModuleHandleA(dll->descr->name)) != 0)) | |
| { | |
| IMAGE_SECTION_HEADER *sec = PE_SECTIONS(hModule); | |
| DEBUG_ENTRY_POINT *debug = | |
| (DEBUG_ENTRY_POINT *)((DWORD)hModule + sec[1].VirtualAddress); | |
| DEBUG_ENTRY_POINT *func = (DEBUG_ENTRY_POINT *)relay; | |
| if (debug <= func && func < debug + dll->descr->nb_funcs) | |
| { | |
| ordinal = func - debug; | |
| break; | |
| } | |
| } | |
| if (!dll->descr) | |
| return (ENTRYPOINT32)NULL; | |
| /* Now find the function */ | |
| for (i = 0; i < dll->descr->nb_names; i++) | |
| if (dll->descr->ordinals[i] == ordinal) break; | |
| assert( i < dll->descr->nb_names ); | |
| sprintf( buffer, "%s.%d: %s", dll->descr->name, ordinal + dll->descr->base, | |
| dll->descr->names[i] ); | |
| *typemask = dll->descr->argtypes[ordinal]; | |
| return dll->descr->functions[ordinal]; | |
| } | |
| /*********************************************************************** | |
| * BUILTIN32_SwitchRelayDebug | |
| * | |
| * FIXME: enhance to do it module relative. | |
| */ | |
| void BUILTIN32_SwitchRelayDebug(BOOL onoff) { | |
| BUILTIN32_DLL *dll; | |
| HMODULE hModule; | |
| int i; | |
| #ifdef __i386__ | |
| if (!(TRACE_ON(relay) || WARN_ON(relay))) | |
| return; | |
| for (dll = BuiltinDLLs; dll->descr; dll++) { | |
| IMAGE_SECTION_HEADER *sec; | |
| DEBUG_ENTRY_POINT *debug; | |
| if (!dll->used || !(hModule = GetModuleHandleA(dll->descr->name))) | |
| continue; | |
| sec = PE_SECTIONS(hModule); | |
| debug = (DEBUG_ENTRY_POINT *)((DWORD)hModule + sec[1].VirtualAddress); | |
| for (i = 0; i < dll->descr->nb_funcs; i++,debug++) { | |
| if (!dll->descr->functions[i]) continue; | |
| if ((dll->descr->args[i]==0xff) || (dll->descr->args[i]==0xfe)) | |
| continue; | |
| if (onoff) { | |
| debug->call = 0xe8; /* lcall relative */ | |
| debug->callfrom32 = (DWORD)RELAY_CallFrom32 - | |
| (DWORD)&debug->ret; | |
| } else { | |
| debug->call = 0xe9; /* ljmp relative */ | |
| debug->callfrom32 = (DWORD)dll->descr->functions[i] - | |
| (DWORD)&debug->ret; | |
| } | |
| } | |
| } | |
| #endif /* __i386__ */ | |
| return; | |
| } | |
| /*********************************************************************** | |
| * BUILTIN32_Unimplemented | |
| * | |
| * This function is called for unimplemented 32-bit entry points (declared | |
| * as 'stub' in the spec file). | |
| */ | |
| void BUILTIN32_Unimplemented( const BUILTIN32_DESCRIPTOR *descr, int ordinal ) | |
| { | |
| const char *func_name = "???"; | |
| int i; | |
| __RESTORE_ES; /* Just in case */ | |
| for (i = 0; i < descr->nb_names; i++) | |
| if (descr->ordinals[i] + descr->base == ordinal) break; | |
| if (i < descr->nb_names) func_name = descr->names[i]; | |
| MSG( "No handler for Win32 routine %s.%d: %s", | |
| descr->name, ordinal, func_name ); | |
| #ifdef __GNUC__ | |
| MSG( " (called from %p)", __builtin_return_address(1) ); | |
| #endif | |
| MSG( "\n" ); | |
| ExitProcess(1); | |
| } | |
| /*********************************************************************** | |
| * BUILTIN32_ParseDLLOptions | |
| * | |
| * Set runtime DLL usage flags | |
| */ | |
| BOOL BUILTIN32_ParseDLLOptions( char *str ) | |
| { | |
| BUILTIN32_DLL *dll; | |
| char *p,*last; | |
| last = str; | |
| while (*str) | |
| { | |
| while (*str && (*str==',' || isspace(*str))) str++; | |
| if (!*str) { | |
| *last = '\0'; /* cut off garbage at end at */ | |
| return TRUE; | |
| } | |
| if ((*str != '+') && (*str != '-')) return FALSE; | |
| str++; | |
| if (!(p = strchr( str, ',' ))) p = str + strlen(str); | |
| while ((p > str) && isspace(p[-1])) p--; | |
| if (p == str) return FALSE; | |
| for (dll = BuiltinDLLs; dll->descr; dll++) | |
| { | |
| if (!lstrncmpiA( dll->descr->name, str, (int)(p-str) )) | |
| { | |
| if (dll->descr->name[p-str]) /* partial match - skip */ | |
| continue; | |
| dll->used = (str[-1]!='-'); | |
| break; | |
| } | |
| } | |
| if (!dll->descr) { | |
| /* not found, but could get handled by BUILTIN_, so move last */ | |
| last = p; | |
| str = p; | |
| } else { | |
| /* handled. cut out the "[+-]DLL," string, so it isn't handled | |
| * by BUILTIN | |
| */ | |
| if (*p) { | |
| memcpy(last,p,strlen(p)+1); | |
| str = last; | |
| } else { | |
| *last = '\0'; | |
| break; | |
| } | |
| } | |
| } | |
| return TRUE; | |
| } | |
| /*********************************************************************** | |
| * BUILTIN32_PrintDLLs | |
| * | |
| * Print the list of built-in DLLs that can be disabled. | |
| */ | |
| void BUILTIN32_PrintDLLs(void) | |
| { | |
| int i; | |
| BUILTIN32_DLL *dll; | |
| MSG("Available Win32 DLLs:\n"); | |
| for (i = 0, dll = BuiltinDLLs; dll->descr; dll++) | |
| MSG("%-9s%c", dll->descr->name, | |
| ((++i) % 8) ? ' ' : '\n' ); | |
| MSG("\n"); | |
| } |