#ifndef WINELIB /* * Copyright 1994 Eric Youndale & Erik Bos * * based on Eric Youndale's pe-test and: * * ftp.microsoft.com:/pub/developer/MSDN/CD8/PEFILE.ZIP * make that: * ftp.microsoft.com:/developr/MSDN/OctCD/PEFILE.ZIP */ #include #include #include #include #include #include #include #include "windows.h" #include "dlls.h" #include "neexe.h" #include "peexe.h" #include "pe_image.h" #include "relay32.h" #include "module.h" #include "alias.h" #include "global.h" #include "task.h" #include "ldt.h" #include "registers.h" #include "selectors.h" #include "stddebug.h" #include "debug.h" #include "xmalloc.h" struct w_files *wine_files = NULL; void my_wcstombs(char * result, u_short * source, int len) { while(len--) { /* this used to be isascii, but see isascii implementation in Linux' ctype.h */ if(*source<255) *result++ = *source++; else { printf("Unable to handle unicode right now\n"); exit(0); } }; } #if 0 char * xmmap(char * vaddr, unsigned int v_size, unsigned int r_size, int prot, int flags, int fd, unsigned int file_offset) { char * result; /* .bss has no associated storage in the PE file */ if(r_size) v_size=r_size; else #ifdef __svr4__ fprintf(stderr,"xmmap: %s line %d doesn't support MAP_ANON\n",__FILE__, __LINE__); #else flags |= MAP_ANON; #endif result = mmap(vaddr, v_size, prot, flags, fd, file_offset); if((unsigned int) result != 0xffffffff) return result; /* Sigh. Alignment must be wrong for mmap. Do this the hard way. */ if(!(flags & MAP_FIXED)) { vaddr = (char *)0x40000000; flags |= MAP_FIXED; }; mmap(vaddr, v_size, prot, MAP_ANONYMOUS | flags, 0, 0); lseek(fd, file_offset, SEEK_SET); read(fd, vaddr, v_size); return vaddr; }; #endif void dump_exports(struct PE_Export_Directory * pe_exports, unsigned int load_addr) { char * Module; int i; u_short * ordinal; u_long * function; u_char ** name, *ename; Module = ((char *) load_addr) + pe_exports->Name; dprintf_win32(stddeb,"\n*******EXPORT DATA*******\nModule name is %s, %ld functions, %ld names\n", Module, pe_exports->Number_Of_Functions, pe_exports->Number_Of_Names); ordinal = (u_short *) (((char *) load_addr) + (int) pe_exports->Address_Of_Name_Ordinals); function = (u_long *) (((char *) load_addr) + (int) pe_exports->AddressOfFunctions); name = (u_char **) (((char *) load_addr) + (int) pe_exports->AddressOfNames); dprintf_win32(stddeb,"%-32s Ordinal Virt Addr\n", "Function Name"); for(i=0; i< pe_exports->Number_Of_Functions; i++) { ename = (char *) (((char *) load_addr) + (int) *name++); dprintf_win32(stddeb,"%-32s %4d %8.8lx\n", ename, *ordinal++, *function++); } } DWORD PE_FindExportedFunction(struct w_files* wpnt, char* funcName) { struct PE_Export_Directory * exports = wpnt->pe->pe_export; unsigned load_addr = wpnt->pe->load_addr; u_short * ordinal; u_long * function; u_char ** name, *ename; int i; if(!exports)return 0; ordinal = (u_short *) (((char *) load_addr) + (int) exports->Address_Of_Name_Ordinals); function = (u_long *) (((char *) load_addr) + (int) exports->AddressOfFunctions); name = (u_char **) (((char *) load_addr) + (int) exports->AddressOfNames); for(i=0; iNumber_Of_Functions; i++) { ename = (char *) (((char *) load_addr) + (int) *name); if(strcmp(ename,funcName)==0) return load_addr+*function; function++; ordinal++; name++; } return 0; } DWORD PE_GetProcAddress(HMODULE hModule, char* function) { struct w_files *wpnt; for(wpnt=wine_files;wpnt;wpnt=wpnt->next) if(wpnt->hModule==hModule) break; if(!wpnt)return 0; return PE_FindExportedFunction(wpnt,function); } void fixup_imports(struct w_files* wpnt) { struct PE_Import_Directory * pe_imp; int fixup_failed=0; unsigned int load_addr = wpnt->pe->load_addr; int i; NE_MODULE *ne_mod; HMODULE *mod_ptr; /* OK, now dump the import list */ dprintf_win32(stddeb, "\nDumping imports list\n"); /* first, count the number of imported non-internal modules */ pe_imp = wpnt->pe->pe_import; for(i=0;pe_imp->ModuleName;pe_imp++) i++; /* Now, allocate memory for dlls_to_init */ ne_mod = GlobalLock(wpnt->hModule); ne_mod->dlls_to_init = GLOBAL_Alloc(GMEM_ZEROINIT,(i+1) * sizeof(HMODULE), wpnt->hModule, FALSE, FALSE, FALSE ); mod_ptr = GlobalLock(ne_mod->dlls_to_init); /* load the modules and put their handles into the list */ for(i=0,pe_imp = wpnt->pe->pe_import;pe_imp->ModuleName;pe_imp++) { char *name = (char*)load_addr+pe_imp->ModuleName; if(RELAY32_GetBuiltinDLL(name)) continue; mod_ptr[i] = LoadModule(name,(LPVOID)-1); if(mod_ptr[i]<=(HMODULE)32) { fprintf(stderr,"Module %s not found\n",name); exit(0); } i++; } pe_imp = wpnt->pe->pe_import; while (pe_imp->ModuleName) { char * Module; struct pe_import_name * pe_name; unsigned int * import_list, *thunk_list; #if 0 char * c; #endif Module = ((char *) load_addr) + pe_imp->ModuleName; dprintf_win32(stddeb, "%s\n", Module); #if 0 c = strchr(Module, '.'); if (c) *c = 0; #endif if(pe_imp->Import_List != 0) { /* original microsoft style */ dprintf_win32(stddeb, "Microsoft style imports used\n"); import_list = (unsigned int *) (((unsigned int) load_addr) + pe_imp->Import_List); thunk_list = (unsigned int *) (((unsigned int) load_addr) + pe_imp->Thunk_List); while(*import_list) { pe_name = (struct pe_import_name *) ((int) load_addr + *import_list); if((unsigned)pe_name & 0x80000000) { fprintf(stderr,"Import by ordinal not supported\n"); exit(0); } dprintf_win32(stddeb, "--- %s %s.%d\n", pe_name->Name, Module, pe_name->Hint); #ifndef WINELIB /* FIXME: JBP: Should this happen in libwine.a? */ /* FIXME: Both calls should be unified into GetProcAddress */ *thunk_list=(unsigned int)RELAY32_GetEntryPoint(Module,pe_name->Name,pe_name->Hint); if(*thunk_list == 0) *thunk_list = WIN32_GetProcAddress(MODULE_FindModule(Module), pe_name->Name); #else fprintf(stderr,"JBP: Call to RELAY32_GetEntryPoint being ignored.\n"); #endif if(!*thunk_list) { fprintf(stderr,"No implementation for %s.%d\n",Module, pe_name->Hint); fixup_failed=1; } import_list++; thunk_list++; } } else { /* Borland style */ dprintf_win32(stddeb, "Borland style imports used\n"); thunk_list = (unsigned int *) (((unsigned int) load_addr) + pe_imp->Thunk_List); while(*thunk_list) { pe_name = (struct pe_import_name *) ((int) load_addr + *thunk_list); if((unsigned)pe_name & 0x80000000) { fprintf(stderr,"Import by ordinal not supported\n"); exit(0); } dprintf_win32(stddeb, "--- %s %s.%d\n", pe_name->Name, Module, pe_name->Hint); #ifndef WINELIB /* FIXME: JBP: Should this happen in libwine.a? */ /* FIXME: Both calls should be unified into GetProcAddress */ *thunk_list=(unsigned int)RELAY32_GetEntryPoint(Module,pe_name->Name,pe_name->Hint); if(*thunk_list == 0) *thunk_list = WIN32_GetProcAddress(MODULE_FindModule(Module), pe_name->Name); #else fprintf(stderr,"JBP: Call to RELAY32_GetEntryPoint being ignored.\n"); #endif if(!*thunk_list) { fprintf(stderr,"No implementation for %s.%d\n",Module, pe_name->Hint); fixup_failed=1; } thunk_list++; } } pe_imp++; } if(fixup_failed)exit(1); } static void calc_vma_size(struct w_files *wpnt) { int i; dprintf_win32(stddeb, "Dump of segment table\n"); dprintf_win32(stddeb, " Name VSz Vaddr SzRaw Fileadr *Reloc *Lineum #Reloc #Linum Char\n"); for(i=0; i< wpnt->pe->pe_header->coff.NumberOfSections; i++) { dprintf_win32(stddeb, "%8s: %4.4lx %8.8lx %8.8lx %8.8lx %8.8lx %8.8lx %4.4x %4.4x %8.8lx\n", wpnt->pe->pe_seg[i].Name, wpnt->pe->pe_seg[i].Virtual_Size, wpnt->pe->pe_seg[i].Virtual_Address, wpnt->pe->pe_seg[i].Size_Of_Raw_Data, wpnt->pe->pe_seg[i].PointerToRawData, wpnt->pe->pe_seg[i].PointerToRelocations, wpnt->pe->pe_seg[i].PointerToLinenumbers, wpnt->pe->pe_seg[i].NumberOfRelocations, wpnt->pe->pe_seg[i].NumberOfLinenumbers, wpnt->pe->pe_seg[i].Characteristics); wpnt->pe->vma_size = max(wpnt->pe->vma_size, wpnt->pe->pe_seg[i].Virtual_Address + wpnt->pe->pe_seg[i].Size_Of_Raw_Data); } } static void do_relocations(struct w_files *wpnt) { int delta = wpnt->pe->load_addr - wpnt->pe->base_addr; struct PE_Reloc_Block *r = wpnt->pe->pe_reloc; int hdelta = (delta >> 16) & 0xFFFF; int ldelta = delta & 0xFFFF; /* int reloc_size = */ if(delta == 0) /* Nothing to do */ return; while(r->PageRVA) { char *page = (char*)wpnt->pe->load_addr + r->PageRVA; int count = (r->BlockSize - 8)/2; int i; dprintf_fixup(stddeb, "%x relocations for page %lx\n", count, r->PageRVA); /* patching in reverse order */ for(i=0;iRelocations[i] & 0xFFF; int type = r->Relocations[i] >> 12; dprintf_fixup(stddeb,"patching %x type %x\n", offset, type); switch(type) { case IMAGE_REL_BASED_ABSOLUTE: break; case IMAGE_REL_BASED_HIGH: *(short*)(page+offset) += hdelta; break; case IMAGE_REL_BASED_LOW: *(short*)(page+offset) += ldelta; break; case IMAGE_REL_BASED_HIGHLOW: #if 1 *(int*)(page+offset) += delta; #else { int h=*(unsigned short*)(page+offset); int l=r->Relocations[++i]; *(unsigned int*)(page + offset) = (h<<16) + l + delta; } #endif break; case IMAGE_REL_BASED_HIGHADJ: fprintf(stderr, "Don't know what to do with IMAGE_REL_BASED_HIGHADJ\n"); break; case IMAGE_REL_BASED_MIPS_JMPADDR: fprintf(stderr, "Is this a MIPS machine ???\n"); break; default: fprintf(stderr, "Unknown fixup type\n"); break; } } r = (struct PE_Reloc_Block*)((char*)r + r->BlockSize); } } /********************************************************************** * PE_LoadImage * Load one PE format executable into memory */ static HINSTANCE PE_LoadImage( int fd, struct w_files *wpnt ) { int i, result; unsigned int load_addr; struct Directory dir; wpnt->pe = xmalloc(sizeof(struct pe_data)); memset(wpnt->pe,0,sizeof(struct pe_data)); wpnt->pe->pe_header = xmalloc(sizeof(struct pe_header_s)); /* read PE header */ lseek( fd, wpnt->mz_header->ne_offset, SEEK_SET); read( fd, wpnt->pe->pe_header, sizeof(struct pe_header_s)); /* read sections */ wpnt->pe->pe_seg = xmalloc(sizeof(struct pe_segment_table) * wpnt->pe->pe_header->coff.NumberOfSections); read( fd, wpnt->pe->pe_seg, sizeof(struct pe_segment_table) * wpnt->pe->pe_header->coff.NumberOfSections); load_addr = wpnt->pe->pe_header->opt_coff.BaseOfImage; wpnt->pe->base_addr=load_addr; wpnt->pe->vma_size=0; dprintf_win32(stddeb, "Load addr is %x\n",load_addr); calc_vma_size(wpnt); /* We use malloc here, while a huge part of that address space does not be supported by actual memory. It has to be contiguous, though. I don't know if mmap("/dev/null"); would do any better. What I'd really like to do is a Win32 style VirtualAlloc/MapViewOfFile sequence */ load_addr = wpnt->pe->load_addr = malloc(wpnt->pe->vma_size); dprintf_win32(stddeb, "Load addr is really %x, range %x\n", wpnt->pe->load_addr, wpnt->pe->vma_size); for(i=0; i < wpnt->pe->pe_header->coff.NumberOfSections; i++) { /* load only non-BSS segments */ if(wpnt->pe->pe_seg[i].Characteristics & ~ IMAGE_SCN_TYPE_CNT_UNINITIALIZED_DATA) if(lseek(fd,wpnt->pe->pe_seg[i].PointerToRawData,SEEK_SET) == -1 || read(fd,load_addr + wpnt->pe->pe_seg[i].Virtual_Address, wpnt->pe->pe_seg[i].Size_Of_Raw_Data) != wpnt->pe->pe_seg[i].Size_Of_Raw_Data) { fprintf(stderr,"Failed to load section %x\n", i); exit(0); } result = load_addr + wpnt->pe->pe_seg[i].Virtual_Address; #if 0 if(!load_addr) { result = (int)xmmap((char *)0, wpnt->pe->pe_seg[i].Virtual_Size, wpnt->pe->pe_seg[i].Size_Of_Raw_Data, 7, MAP_PRIVATE, fd, wpnt->pe->pe_seg[i].PointerToRawData); load_addr = (unsigned int) result - wpnt->pe->pe_seg[i].Virtual_Address; } else { result = (int)xmmap((char *) load_addr + wpnt->pe->pe_seg[i].Virtual_Address, wpnt->pe->pe_seg[i].Virtual_Size, wpnt->pe->pe_seg[i].Size_Of_Raw_Data, 7, MAP_PRIVATE | MAP_FIXED, fd, wpnt->pe->pe_seg[i].PointerToRawData); } if(result==-1){ fprintf(stderr,"Could not load section %x to desired address %lx\n", i, load_addr+wpnt->pe->pe_seg[i].Virtual_Address); fprintf(stderr,"Need to implement relocations now\n"); exit(0); } #endif if(strcmp(wpnt->pe->pe_seg[i].Name, ".bss") == 0) memset((void *)result, 0, wpnt->pe->pe_seg[i].Virtual_Size ? wpnt->pe->pe_seg[i].Virtual_Size : wpnt->pe->pe_seg[i].Size_Of_Raw_Data); if(strcmp(wpnt->pe->pe_seg[i].Name, ".idata") == 0) wpnt->pe->pe_import = (struct PE_Import_Directory *) result; if(strcmp(wpnt->pe->pe_seg[i].Name, ".edata") == 0) wpnt->pe->pe_export = (struct PE_Export_Directory *) result; if(strcmp(wpnt->pe->pe_seg[i].Name, ".rsrc") == 0) { wpnt->pe->pe_resource = (struct PE_Resource_Directory *) result; #if 0 /* FIXME pe->resource_offset should be deleted from structure if this ifdef doesn't break anything */ /* save offset for PE_FindResource */ wpnt->pe->resource_offset = wpnt->pe->pe_seg[i].Virtual_Address - wpnt->pe->pe_seg[i].PointerToRawData; #endif } if(strcmp(wpnt->pe->pe_seg[i].Name, ".reloc") == 0) wpnt->pe->pe_reloc = (struct PE_Reloc_Block *) result; } /* There is word that the actual loader does not care about the section names, and only goes for the DataDirectory */ dir=wpnt->pe->pe_header->opt_coff.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY]; if(dir.Size) { if(wpnt->pe->pe_export && wpnt->pe->pe_export!=load_addr+dir.Virtual_address) fprintf(stderr,"wrong export directory??\n"); else wpnt->pe->pe_export = load_addr+dir.Virtual_address; } dir=wpnt->pe->pe_header->opt_coff.DataDirectory[IMAGE_FILE_IMPORT_DIRECTORY]; if(dir.Size) { if(wpnt->pe->pe_import && wpnt->pe->pe_import!=load_addr+dir.Virtual_address) fprintf(stderr,"wrong export directory??\n"); else wpnt->pe->pe_import = load_addr+dir.Virtual_address; } dir=wpnt->pe->pe_header->opt_coff.DataDirectory[IMAGE_FILE_RESOURCE_DIRECTORY]; if(dir.Size) { if(wpnt->pe->pe_resource && wpnt->pe->pe_resource!=load_addr+dir.Virtual_address) fprintf(stderr,"wrong resource directory??\n"); else wpnt->pe->pe_resource = load_addr+dir.Virtual_address; } dir=wpnt->pe->pe_header->opt_coff.DataDirectory[IMAGE_FILE_BASE_RELOCATION_TABLE]; if(dir.Size) { if(wpnt->pe->pe_reloc && wpnt->pe->pe_reloc!=load_addr+dir.Virtual_address) fprintf(stderr,"wrong export directory??\n"); else wpnt->pe->pe_reloc = load_addr+dir.Virtual_address; } if(wpnt->pe->pe_header->opt_coff.DataDirectory [IMAGE_FILE_EXCEPTION_DIRECTORY].Size) dprintf_win32(stdnimp,"Exception directory ignored\n"); if(wpnt->pe->pe_header->opt_coff.DataDirectory [IMAGE_FILE_SECURITY_DIRECTORY].Size) dprintf_win32(stdnimp,"Security directory ignored\n"); if(wpnt->pe->pe_header->opt_coff.DataDirectory [IMAGE_FILE_DEBUG_DIRECTORY].Size) dprintf_win32(stdnimp,"Debug directory ignored\n"); if(wpnt->pe->pe_header->opt_coff.DataDirectory [IMAGE_FILE_DESCRIPTION_STRING].Size) dprintf_win32(stdnimp,"Description string ignored\n"); if(wpnt->pe->pe_header->opt_coff.DataDirectory [IMAGE_FILE_MACHINE_VALUE].Size) dprintf_win32(stdnimp,"Machine Value ignored\n"); if(wpnt->pe->pe_header->opt_coff.DataDirectory [IMAGE_FILE_THREAD_LOCAL_STORAGE].Size) dprintf_win32(stdnimp,"Thread local storage ignored\n"); if(wpnt->pe->pe_header->opt_coff.DataDirectory [IMAGE_FILE_CALLBACK_DIRECTORY].Size) dprintf_win32(stdnimp,"Callback directory ignored\n"); if(wpnt->pe->pe_import) fixup_imports(wpnt); if(wpnt->pe->pe_export) dump_exports(wpnt->pe->pe_export,load_addr); if(wpnt->pe->pe_reloc) do_relocations(wpnt); wpnt->hinstance = (HINSTANCE)0x8000; wpnt->load_addr = load_addr; return (wpnt->hinstance); } HINSTANCE MODULE_CreateInstance(HMODULE hModule,LOADPARAMS *params); void InitTask(struct sigcontext_struct context); HINSTANCE PE_LoadModule(int fd, OFSTRUCT *ofs, LOADPARAMS* params) { struct w_files *wpnt; int size; NE_MODULE *pModule; LOADEDFILEINFO *pFileInfo; SEGTABLEENTRY *pSegment; char *pStr; DWORD cts; HMODULE hModule; HINSTANCE hInstance; ALIAS_UseAliases=1; wpnt=xmalloc(sizeof(struct w_files)); wpnt->ofs=*ofs; wpnt->type=0; wpnt->hinstance=0; wpnt->hModule=0; wpnt->initialised=0; lseek(fd,0,SEEK_SET); wpnt->mz_header=xmalloc(sizeof(struct mz_header_s)); read(fd,wpnt->mz_header,sizeof(struct mz_header_s)); size=sizeof(NE_MODULE) + /* loaded file info */ sizeof(LOADEDFILEINFO) + strlen(ofs->szPathName) + /* segment table: DS,CS */ 2 * sizeof(SEGTABLEENTRY) + /* name table */ 9 + /* several empty tables */ 8; hModule = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, size ); wpnt->hModule=hModule; if (!hModule) return (HINSTANCE)11; /* invalid exe */ FarSetOwner( hModule, hModule ); pModule = (NE_MODULE*)GlobalLock(hModule); /* Set all used entries */ pModule->magic=PE_SIGNATURE; pModule->count=1; pModule->next=0; pModule->flags=0; pModule->dgroup=1; pModule->ss=1; pModule->cs=2; /* Who wants to LocalAlloc for a PE Module? */ pModule->heap_size=0x1000; pModule->stack_size=0xF000; pModule->seg_count=1; pModule->modref_count=0; pModule->nrname_size=0; pModule->seg_table=sizeof(NE_MODULE)+ sizeof(LOADEDFILEINFO)+strlen(ofs->szPathName); pModule->fileinfo=sizeof(NE_MODULE); pModule->os_flags=NE_OSFLAGS_WINDOWS; pModule->expected_version=0x30A; pFileInfo=(LOADEDFILEINFO *)(pModule + 1); pFileInfo->length = sizeof(LOADEDFILEINFO)+strlen(ofs->szPathName)-1; strcpy(pFileInfo->filename,ofs->szPathName); pSegment=(SEGTABLEENTRY*)((char*)pFileInfo+pFileInfo->length+1); pModule->dgroup_entry=(int)pSegment-(int)pModule; pSegment->size=0; pSegment->flags=NE_SEGFLAGS_DATA; pSegment->minsize=0x1000; pSegment++; cts=(DWORD)GetWndProcEntry16("Win32CallToStart"); #ifdef WINELIB32 pSegment->selector=(void*)cts; pModule->ip=0; #else pSegment->selector=cts>>16; pModule->ip=cts & 0xFFFF; #endif pSegment++; pStr=(char*)pSegment; pModule->name_table=(int)pStr-(int)pModule; strcpy(pStr,"\x08W32SXXXX"); pStr+=9; /* All tables zero terminated */ pModule->res_table=pModule->import_table=pModule->entry_table= (int)pStr-(int)pModule; MODULE_RegisterModule(hModule); PE_LoadImage( fd, wpnt ); pModule->heap_size=0x1000; pModule->stack_size=0xE000; /* CreateInstance allocates now 64KB */ hInstance=MODULE_CreateInstance(hModule,NULL /* FIX: NULL? really? */); wpnt->hinstance=hInstance; if (wpnt->pe->pe_export) { pStr = ((unsigned char *)(wpnt->load_addr))+wpnt->pe->pe_export->Name; wpnt->name = xstrdup(pStr); } else { wpnt->name = xstrdup( ofs->szPathName ); } wpnt->next=wine_files; wine_files=wpnt; /* FIXME: Is this really the correct place to initialise the DLL? */ if ((wpnt->pe->pe_header->coff.Characteristics & IMAGE_FILE_DLL)) { PE_InitDLL(wpnt); } else { TASK_CreateTask(hModule,hInstance,0, params->hEnvironment,(LPSTR)PTR_SEG_TO_LIN(params->cmdLine), *((WORD*)PTR_SEG_TO_LIN(params->showCmd)+1)); } return hInstance; } int USER_InitApp(HINSTANCE hInstance); void PE_InitTEB(int hTEB); void PE_Win32CallToStart(struct sigcontext_struct context) { int fs; struct w_files *wpnt=wine_files; dprintf_win32(stddeb,"Going to start Win32 program\n"); InitTask(context); USER_InitApp(wpnt->hModule); fs=(int)GlobalAlloc(GHND,0x10000); PE_InitTEB(fs); __asm__ __volatile__("movw %w0,%%fs"::"r" (fs)); ((void(*)())(wpnt->load_addr+wpnt->pe->pe_header->opt_coff.AddressOfEntryPoint))(); } int PE_UnloadImage(struct w_files *wpnt) { printf("PEunloadImage() called!\n"); /* free resources, image, unmap */ return 1; } void PE_InitDLL(HMODULE hModule) { struct w_files *wpnt; hModule = GetExePtr(hModule); for(wpnt = wine_files;wpnt && wpnt->hModule != hModule; wpnt = wpnt->next) /*nothing*/; if(!wpnt || wpnt->initialised) return; /* FIXME: What are the correct values for parameters 2 and 3? */ /* Is this a library? */ if (wpnt->pe->pe_header->coff.Characteristics & IMAGE_FILE_DLL) { /* Should call DLLEntryPoint here */ printf("InitPEDLL() called!\n"); wpnt->initialised = 1; ((void(*)())(wpnt->load_addr+wpnt->pe->pe_header->opt_coff.AddressOfEntryPoint))(wpnt->hModule, 0, 0); } } /* FIXME: This stuff is all on a "well it works" basis. An implementation based on some kind of documentation would be greatly appreciated :-) */ typedef struct { void *Except; void *stack; int dummy1[4]; struct TEB *TEBDSAlias; int dummy2[2]; int taskid; } TEB; void PE_InitTEB(int hTEB) { TDB *pTask; TEB *pTEB; pTask = (TDB *)(GlobalLock(GetCurrentTask() & 0xffff)); pTEB = (TEB *)(PTR_SEG_OFF_TO_LIN(hTEB, 0)); pTEB->stack = (void *)(GlobalLock(pTask->hStack32)); pTEB->Except = (void *)(-1); pTEB->TEBDSAlias = pTEB; pTEB->taskid = getpid(); } void PE_InitializeDLLs(HMODULE hModule) { NE_MODULE *pModule; HMODULE *pDLL; pModule = (NE_MODULE *)GlobalLock( GetExePtr(hModule) ); if (pModule->dlls_to_init) { HANDLE to_init = pModule->dlls_to_init; pModule->dlls_to_init = 0; for (pDLL = (HMODULE *)GlobalLock( to_init ); *pDLL; pDLL++) { PE_InitializeDLLs( *pDLL ); PE_InitDLL( *pDLL ); } GlobalFree( to_init ); } PE_InitDLL( hModule ); } #endif /* WINELIB */