/********************************************************************** * get_default_res_handler */ static inline FARPROC16 get_default_res_handler(void) { static FARPROC16 handler; if (!handler) handler = GetProcAddress16( GetModuleHandle16("KERNEL"), "DefResourceHandler" ); return handler; }
/************************************************************************* * RegisterShellHook [SHELL.102] */ BOOL WINAPI RegisterShellHook16(HWND16 hWnd, UINT16 uAction) { TRACE("%04x [%u]\n", hWnd, uAction ); switch( uAction ) { case 2: /* register hWnd as a shell window */ if( !SHELL_hHook ) { HMODULE16 hShell = GetModuleHandle16( "SHELL" ); HOOKPROC16 hookProc = (HOOKPROC16)GetProcAddress16( hShell, (LPCSTR)103 ); SHELL_hHook = SetWindowsHookEx16( WH_SHELL, hookProc, hShell, 0 ); if ( SHELL_hHook ) { uMsgWndCreated = RegisterWindowMessageA( lpstrMsgWndCreated ); uMsgWndDestroyed = RegisterWindowMessageA( lpstrMsgWndDestroyed ); uMsgShellActivate = RegisterWindowMessageA( lpstrMsgShellActivate ); } else WARN("-- unable to install ShellHookProc()!\n"); } if ( SHELL_hHook ) return ((SHELL_hWnd = hWnd) != 0); break; default: WARN("-- unknown code %i\n", uAction ); SHELL_hWnd = 0; /* just in case */ } return FALSE; }
/****************************************************************************** * IMalloc16_Constructor [VTABLE] */ static LPMALLOC16 IMalloc16_Constructor(void) { static IMalloc16Vtbl vt16; static SEGPTR msegvt16; IMalloc16Impl* This; HMODULE16 hcomp = GetModuleHandle16("COMPOBJ"); This = HeapAlloc( GetProcessHeap(), 0, sizeof(IMalloc16Impl) ); if (!msegvt16) { #define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"IMalloc16_"#x);assert(vt16.x) VTENT(QueryInterface); VTENT(AddRef); VTENT(Release); VTENT(Alloc); VTENT(Realloc); VTENT(Free); VTENT(GetSize); VTENT(DidAlloc); VTENT(HeapMinimize); #undef VTENT msegvt16 = MapLS( &vt16 ); } This->IMalloc16_iface.lpVtbl = (const IMalloc16Vtbl*)msegvt16; This->ref = 1; return (LPMALLOC16)MapLS( This ); }
/****************************************************************************** * This is the constructor for the HGLOBALLockBytesImpl16 class. * * Params: * hGlobal - Handle that will support the stream. can be NULL. * fDeleteOnRelease - Flag set to TRUE if the HGLOBAL16 will be released * when the IStream object is destroyed. */ static HGLOBALLockBytesImpl16* HGLOBALLockBytesImpl16_Construct(HGLOBAL16 hGlobal, BOOL16 fDeleteOnRelease) { HGLOBALLockBytesImpl16* newLockBytes; static ILockBytes16Vtbl vt16; static SEGPTR msegvt16; HMODULE16 hcomp = GetModuleHandle16("OLE2"); TRACE("(%x,%d)\n",hGlobal,fDeleteOnRelease); newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl16)); if (newLockBytes == NULL) return NULL; /* * Set up the virtual function table and reference count. */ if (!msegvt16) { #define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"HGLOBALLockBytesImpl16_"#x);assert(vt16.x) VTENT(QueryInterface); VTENT(AddRef); VTENT(Release); VTENT(ReadAt); VTENT(WriteAt); VTENT(Flush); VTENT(SetSize); VTENT(LockRegion); VTENT(UnlockRegion); #undef VTENT msegvt16 = MapLS( &vt16 ); } newLockBytes->lpVtbl = (const ILockBytes16Vtbl*)msegvt16; newLockBytes->ref = 0; /* * Initialize the support. */ newLockBytes->supportHandle = hGlobal; newLockBytes->deleteOnRelease = fDeleteOnRelease; /* * This method will allocate a handle if one is not supplied. */ if (newLockBytes->supportHandle == 0) newLockBytes->supportHandle = GlobalAlloc16(GMEM_MOVEABLE | GMEM_NODISCARD, 0); /* * Initialize the size of the array to the size of the handle. */ newLockBytes->byteArraySize.u.HighPart = 0; newLockBytes->byteArraySize.u.LowPart = GlobalSize16( newLockBytes->supportHandle); return (HGLOBALLockBytesImpl16*)MapLS(newLockBytes); }
/********************************************************************** * DOSVM_GetRMVector * * Return pointer to real mode interrupt vector. These are not at fixed * location because those Win16 programs that do not use any real mode * code have protected NULL pointer catching block at low linear memory * and interrupt vectors have been moved to another location. */ static FARPROC16* DOSVM_GetRMVector( BYTE intnum ) { LDT_ENTRY entry; FARPROC16 proc; proc = GetProcAddress16( GetModuleHandle16( "KERNEL" ), (LPCSTR)(ULONG_PTR)183 ); wine_ldt_get_entry( LOWORD(proc), &entry ); return (FARPROC16*)wine_ldt_get_base( &entry ) + intnum; }
/********************************************************************** * FreeResource (KERNEL.63) */ BOOL16 WINAPI FreeResource16( HGLOBAL16 handle ) { FARPROC16 proc; HMODULE16 user; NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) ); TRACE("(%04x)\n", handle ); /* Try NE resource first */ if (pModule && pModule->ne_rsrctab) { NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2); while (pTypeInfo->type_id) { WORD count; NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1); for (count = pTypeInfo->count; count > 0; count--) { if (pNameInfo->handle == handle) { if (pNameInfo->usage > 0) pNameInfo->usage--; if (pNameInfo->usage == 0) { GlobalFree16( pNameInfo->handle ); pNameInfo->handle = 0; pNameInfo->flags &= ~NE_SEGFLAGS_LOADED; } return FALSE; } pNameInfo++; } pTypeInfo = (NE_TYPEINFO *)pNameInfo; } } /* If this failed, call USER.DestroyIcon32; this will check whether it is a shared cursor/icon; if not it will call GlobalFree16() */ user = GetModuleHandle16( "user" ); if (user && (proc = GetProcAddress16( user, "DestroyIcon32" ))) { WORD args[2]; DWORD result; args[1] = handle; args[0] = 1; /* CID_RESOURCE */ WOWCallback16Ex( (SEGPTR)proc, WCB16_PASCAL, sizeof(args), args, &result ); return LOWORD(result); } else return GlobalFree16( handle ); }
void NE_CallUserSignalProc( HMODULE16 hModule, UINT16 code ) { FARPROC16 proc; HMODULE16 user = GetModuleHandle16("user.exe"); if (!user) return; if ((proc = GetProcAddress16( user, "SignalProc" ))) { /* USER is always a builtin dll */ pSignalProc sigproc = (pSignalProc)((ENTRYPOINT16 *)MapSL( (SEGPTR)proc ))->target; sigproc( hModule, code, 0, 0, 0 ); } }
/*********************************************************************** * NE_LoadAllSegments */ BOOL NE_LoadAllSegments( NE_MODULE *pModule ) { int i; SEGTABLEENTRY * pSegTable = NE_SEG_TABLE(pModule); if (pModule->ne_flags & NE_FFLAGS_SELFLOAD) { HFILE16 hFile16; HGLOBAL16 sel; /* Handle self-loading modules */ SELFLOADHEADER *selfloadheader; HMODULE16 mod = GetModuleHandle16("KERNEL"); void *oldstack; WORD args[2]; TRACE_(module)("%.*s is a self-loading module!\n", *((BYTE*)pModule + pModule->ne_restab), (char *)pModule + pModule->ne_restab + 1); if (!NE_LoadSegment( pModule, 1 )) return FALSE; selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) ); selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc"); selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc"); selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner"); sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 ); pModule->self_loading_sel = SEL(sel); FarSetOwner16( sel, pModule->self ); oldstack = getWOW32Reserved(); setWOW32Reserved((void *)MAKESEGPTR(pModule->self_loading_sel, 0xff00 - sizeof(STACK16FRAME) )); hFile16 = NE_OpenFile(pModule); TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n", pModule->self,hFile16); args[1] = pModule->self; args[0] = hFile16; WOWCallback16Ex( (DWORD)selfloadheader->BootApp, WCB16_PASCAL, sizeof(args), args, NULL ); TRACE_(dll)("Return from CallBootAppProc\n"); _lclose16(hFile16); setWOW32Reserved(oldstack); for (i = 2; i <= pModule->ne_cseg; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } else { for (i = 1; i <= pModule->ne_cseg; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } return TRUE; }
/*********************************************************************** * NE_LoadAllSegments */ BOOL NE_LoadAllSegments( NE_MODULE *pModule ) { int i; SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule); if (pModule->flags & NE_FFLAGS_SELFLOAD) { HANDLE hf; HFILE16 hFile16; HGLOBAL16 sel; /* Handle self-loading modules */ SELFLOADHEADER *selfloadheader; HMODULE16 mod = GetModuleHandle16("KERNEL"); DWORD oldstack; TRACE_(module)("%.*s is a self-loading module!\n", *((BYTE*)pModule + pModule->name_table), (char *)pModule + pModule->name_table + 1); if (!NE_LoadSegment( pModule, 1 )) return FALSE; selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) ); selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc"); selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc"); selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner"); sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 ); pModule->self_loading_sel = SEL(sel); FarSetOwner16( sel, pModule->self ); oldstack = NtCurrentTeb()->WOW32Reserved; NtCurrentTeb()->WOW32Reserved = MAKESEGPTR(pModule->self_loading_sel, 0xff00 - sizeof(STACK16FRAME) ); DuplicateHandle( GetCurrentProcess(), NE_OpenFile(pModule), GetCurrentProcess(), &hf, 0, FALSE, DUPLICATE_SAME_ACCESS ); hFile16 = Win32HandleToDosFileHandle( hf ); TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n", pModule->self,hFile16); NE_CallTo16_word_ww(selfloadheader->BootApp, pModule->self,hFile16); TRACE_(dll)("Return from CallBootAppProc\n"); _lclose16(hFile16); NtCurrentTeb()->WOW32Reserved = oldstack; for (i = 2; i <= pModule->seg_count; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } else { for (i = 1; i <= pModule->seg_count; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } return TRUE; }
/********************************************************************** * INT_GetPMHandler * * Return the protected mode interrupt vector for a given interrupt. */ FARPROC16 INT_GetPMHandler( BYTE intnum ) { if (!INT_Vectors[intnum]) { static HMODULE16 wprocs; if (!wprocs) { if (((wprocs = GetModuleHandle16( "wprocs" )) < 32) && ((wprocs = LoadLibrary16( "wprocs" )) < 32)) { ERR("could not load wprocs.dll\n"); return 0; } } if (!(INT_Vectors[intnum] = GetProcAddress16( wprocs, (LPCSTR)(FIRST_INTERRUPT + intnum)))) { WARN("int%x not implemented, returning dummy handler\n", intnum ); INT_Vectors[intnum] = GetProcAddress16( wprocs, (LPCSTR)(FIRST_INTERRUPT + 256) ); } } return INT_Vectors[intnum]; }
/**************************************************************************** * UTAlloc */ static UTINFO *UTAlloc( HMODULE hModule, HMODULE16 hModule16, FARPROC16 target16, FARPROC target32 ) { static FARPROC16 UTGlue16_Segptr = NULL; UTINFO *ut; if ( !UTGlue16_Segptr ) { HMODULE16 hMod = GetModuleHandle16( "KERNEL" ); UTGlue16_Segptr = GetProcAddress16( hMod, "UTGlue16" ); if ( !UTGlue16_Segptr ) return NULL; } ut = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(UTINFO) ); if ( !ut ) return NULL; ut->hModule = hModule; ut->hModule16 = hModule16; ut->ut16.popl_eax = 0x58; ut->ut16.pushl = 0x68; ut->ut16.target = (DWORD)target32; ut->ut16.pushl_eax = 0x50; ut->ut16.ljmp = 0xea; ut->ut16.utglue16 = (DWORD)UTGlue16_Segptr; ut->ut32.popl_eax = 0x58; ut->ut32.pushl = 0x68; ut->ut32.target = (DWORD)target16; ut->ut32.pushl_eax = 0x50; ut->ut32.jmp = 0xe9; ut->ut32.utglue32 = (DWORD)UTGlue32 - ((DWORD)&ut->ut32.utglue32 + sizeof(DWORD)); ut->next = UT_head; UT_head = ut; return ut; }
/*********************************************************************** * TASK_Create * * NOTE: This routine might be called by a Win32 thread. Thus, we need * to be careful to protect global data structures. We do this * by entering the Win16Lock while linking the task into the * global task list. */ static TDB *TASK_Create( NE_MODULE *pModule, UINT16 cmdShow, LPCSTR cmdline, BYTE len ) { HTASK16 hTask; TDB *pTask; FARPROC16 proc; char curdir[MAX_PATH]; HMODULE16 hModule = pModule ? pModule->self : 0; /* Allocate the task structure */ hTask = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, sizeof(TDB) ); if (!hTask) return NULL; pTask = TASK_GetPtr( hTask ); FarSetOwner16( hTask, hModule ); /* Fill the task structure */ pTask->hSelf = hTask; pTask->version = pModule ? pModule->ne_expver : 0x0400; pTask->hModule = hModule; pTask->hParent = GetCurrentTask(); pTask->magic = TDB_MAGIC; pTask->nCmdShow = cmdShow; GetCurrentDirectoryA( sizeof(curdir), curdir ); GetShortPathNameA( curdir, curdir, sizeof(curdir) ); pTask->curdrive = (curdir[0] - 'A') | 0x80; lstrcpynA( pTask->curdir, curdir + 2, sizeof(pTask->curdir) ); /* Create the thunks block */ TASK_CreateThunks( hTask, (char *)pTask->thunks - (char *)pTask, 7 ); /* Copy the module name */ if (hModule) { char name[sizeof(pTask->module_name)+1]; size_t len; GetModuleName16( hModule, name, sizeof(name) ); len = strlen(name) + 1; memcpy(pTask->module_name, name, min(len,sizeof(pTask->module_name))); pTask->compat_flags = GetProfileIntA( "Compatibility", name, 0 ); } /* Allocate a selector for the PDB */ pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB16), hModule, WINE_LDT_FLAGS_DATA ); /* Fill the PDB */ pTask->pdb.int20 = 0x20cd; pTask->pdb.dispatcher[0] = 0x9a; /* ljmp */ proc = GetProcAddress16( GetModuleHandle16("KERNEL"), "DOS3Call" ); memcpy( &pTask->pdb.dispatcher[1], &proc, sizeof(proc) ); pTask->pdb.savedint22 = 0; pTask->pdb.savedint23 = 0; pTask->pdb.savedint24 = 0; pTask->pdb.fileHandlesPtr = MAKESEGPTR( GlobalHandleToSel16(pTask->hPDB), FIELD_OFFSET( PDB16, fileHandles )); pTask->pdb.hFileHandles = 0; memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) ); /* FIXME: should we make a copy of the environment? */ pTask->pdb.environment = SELECTOROF(GetDOSEnvironment16()); pTask->pdb.nbFiles = 20; /* Fill the command line */ if (!cmdline) { cmdline = GetCommandLineA(); /* remove the first word (program name) */ if (*cmdline == '"') if (!(cmdline = strchr( cmdline+1, '"' ))) cmdline = GetCommandLineA(); while (*cmdline && (*cmdline != ' ') && (*cmdline != '\t')) cmdline++; while ((*cmdline == ' ') || (*cmdline == '\t')) cmdline++; len = strlen(cmdline); } if (len >= sizeof(pTask->pdb.cmdLine)) len = sizeof(pTask->pdb.cmdLine)-1; pTask->pdb.cmdLine[0] = len; memcpy( pTask->pdb.cmdLine + 1, cmdline, len ); /* pTask->pdb.cmdLine[len+1] = 0; */ TRACE("cmdline='%.*s' task=%04x\n", len, cmdline, hTask ); /* Allocate a code segment alias for the TDB */ pTask->hCSAlias = GLOBAL_CreateBlock( GMEM_FIXED, pTask, sizeof(TDB), pTask->hPDB, WINE_LDT_FLAGS_CODE ); /* Default DTA overwrites command line */ pTask->dta = MAKESEGPTR( pTask->hPDB, FIELD_OFFSET( PDB16, cmdLine )); /* Create scheduler event for 16-bit tasks */ if ( !(pTask->flags & TDBF_WIN32) ) NtCreateEvent( &pTask->hEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE ); if (!initial_task) initial_task = hTask; return pTask; }
void WINAPI VXD_Win32s( CONTEXT86 *context ) { switch (AX_reg(context)) { case 0x0000: /* Get Version */ /* * Input: None * * Output: EAX: LoWord: Win32s Version (1.30) * HiWord: VxD Version (200) * * EBX: Build (172) * * ECX: ??? (1) * * EDX: Debugging Flags * * EDI: Error Flag * 0 if OK, * 1 if VMCPD VxD not found */ TRACE("GetVersion()\n"); context->Eax = VXD_WinVersion() | (200 << 16); context->Ebx = 0; context->Ecx = 0; context->Edx = 0; context->Edi = 0; /* * If this is the first time we are called for this process, * hack the memory image of WIN32S16 so that it doesn't try * to access the GDT directly ... * * The first code segment of WIN32S16 (version 1.30) contains * an unexported function somewhere between the exported functions * SetFS and StackLinearToSegmented that tries to find a selector * in the LDT that maps to the memory image of the LDT itself. * If it succeeds, it stores this selector into a global variable * which will be used to speed up execution by using this selector * to modify the LDT directly instead of using the DPMI calls. * * To perform this search of the LDT, this function uses the * sgdt and sldt instructions to find the linear address of * the (GDT and then) LDT. While those instructions themselves * execute without problem, the linear address that sgdt returns * points (at least under Linux) to the kernel address space, so * that any subsequent access leads to a segfault. * * Fortunately, WIN32S16 still contains as a fallback option the * mechanism of using DPMI calls to modify LDT selectors instead * of direct writes to the LDT. Thus we can circumvent the problem * by simply replacing the first byte of the offending function * with an 'retf' instruction. This means that the global variable * supposed to contain the LDT alias selector will remain zero, * and hence WIN32S16 will fall back to using DPMI calls. * * The heuristic we employ to _find_ that function is as follows: * We search between the addresses of the exported symbols SetFS * and StackLinearToSegmented for the byte sequence '0F 01 04' * (this is the opcode of 'sgdt [si]'). We then search backwards * from this address for the last occurrence of 'CB' (retf) that marks * the end of the preceeding function. The following byte (which * should now be the first byte of the function we are looking for) * will be replaced by 'CB' (retf). * * This heuristic works for the retail as well as the debug version * of Win32s version 1.30. For versions earlier than that this * hack should not be necessary at all, since the whole mechanism * ('PERF130') was introduced only in 1.30 to improve the overall * performance of Win32s. */ if (!W32S_offset) { HMODULE16 hModule = GetModuleHandle16("win32s16"); SEGPTR func1 = (SEGPTR)GetProcAddress16(hModule, "SetFS"); SEGPTR func2 = (SEGPTR)GetProcAddress16(hModule, "StackLinearToSegmented"); if ( hModule && func1 && func2 && SELECTOROF(func1) == SELECTOROF(func2)) { BYTE *start = MapSL(func1); BYTE *end = MapSL(func2); BYTE *p, *retv = NULL; int found = 0; for (p = start; p < end; p++) if (*p == 0xCB) found = 0, retv = p; else if (*p == 0x0F) found = 1; else if (*p == 0x01 && found == 1) found = 2; else if (*p == 0x04 && found == 2) { found = 3; break; } else found = 0; if (found == 3 && retv) { TRACE("PERF130 hack: " "Replacing byte %02X at offset %04X:%04X\n", *(retv+1), SELECTOROF(func1), OFFSETOF(func1) + retv+1-start); *(retv+1) = (BYTE)0xCB; } } } /* * Mark process as Win32s, so that subsequent DPMI calls * will perform the W32S_APP2WINE/W32S_WINE2APP address shift. */ W32S_offset = 0x10000; break; case 0x0001: /* Install Exception Handling */ /* * Input: EBX: Flat address of W32SKRNL Exception Data * * ECX: LoWord: Flat Code Selector * HiWord: Flat Data Selector * * EDX: Flat address of W32SKRNL Exception Handler * (this is equal to W32S_BackTo32 + 0x40) * * ESI: SEGPTR KERNEL.HASGPHANDLER * * EDI: SEGPTR phCurrentTask (KERNEL.THHOOK + 0x10) * * Output: EAX: 0 if OK */ TRACE("[0001] EBX=%lx ECX=%lx EDX=%lx ESI=%lx EDI=%lx\n", context->Ebx, context->Ecx, context->Edx, context->Esi, context->Edi); /* FIXME */ context->Eax = 0; break; case 0x0002: /* Set Page Access Flags */ /* * Input: EBX: New access flags * Bit 2: User Page if set, Supervisor Page if clear * Bit 1: Read-Write if set, Read-Only if clear * * ECX: Size of memory area to change * * EDX: Flat start address of memory area * * Output: EAX: Size of area changed */ TRACE("[0002] EBX=%lx ECX=%lx EDX=%lx\n", context->Ebx, context->Ecx, context->Edx); /* FIXME */ context->Eax = context->Ecx; break; case 0x0003: /* Get Page Access Flags */ /* * Input: EDX: Flat address of page to query * * Output: EAX: Page access flags * Bit 2: User Page if set, Supervisor Page if clear * Bit 1: Read-Write if set, Read-Only if clear */ TRACE("[0003] EDX=%lx\n", context->Edx); /* FIXME */ context->Eax = 6; break; case 0x0004: /* Map Module */ /* * Input: ECX: IMTE (offset in Module Table) of new module * * EDX: Flat address of Win32s Module Table * * Output: EAX: 0 if OK */ if (!context->Edx || CX_reg(context) == 0xFFFF) { TRACE("MapModule: Initialization call\n"); context->Eax = 0; } else { /* * Structure of a Win32s Module Table Entry: */ struct Win32sModule { DWORD flags; DWORD flatBaseAddr; LPCSTR moduleName; LPCSTR pathName; LPCSTR unknown; LPBYTE baseAddr; DWORD hModule; DWORD relocDelta; }; /* * Note: This function should set up a demand-paged memory image * of the given module. Since mmap does not allow file offsets * not aligned at 1024 bytes, we simply load the image fully * into memory. */ struct Win32sModule *moduleTable = (struct Win32sModule *)W32S_APP2WINE(context->Edx); struct Win32sModule *module = moduleTable + context->Ecx; IMAGE_NT_HEADERS *nt_header = PE_HEADER(module->baseAddr); IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(module->baseAddr); HFILE image = _lopen(module->pathName, OF_READ); BOOL error = (image == HFILE_ERROR); UINT i; TRACE("MapModule: Loading %s\n", module->pathName); for (i = 0; !error && i < nt_header->FileHeader.NumberOfSections; i++, pe_seg++) if(!(pe_seg->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)) { DWORD off = pe_seg->PointerToRawData; DWORD len = pe_seg->SizeOfRawData; LPBYTE addr = module->baseAddr + pe_seg->VirtualAddress; TRACE("MapModule: " "Section %d at %08lx from %08lx len %08lx\n", i, (DWORD)addr, off, len); if ( _llseek(image, off, SEEK_SET) != off || _lread(image, addr, len) != len) error = TRUE; } _lclose(image); if (error) ERR("MapModule: Unable to load %s\n", module->pathName); else if (module->relocDelta != 0) { IMAGE_DATA_DIRECTORY *dir = nt_header->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_BASERELOC; IMAGE_BASE_RELOCATION *r = (IMAGE_BASE_RELOCATION *) (dir->Size? module->baseAddr + dir->VirtualAddress : 0); TRACE("MapModule: Reloc delta %08lx\n", module->relocDelta); while (r && r->VirtualAddress) { LPBYTE page = module->baseAddr + r->VirtualAddress; WORD *TypeOffset = (WORD *)(r + 1); int count = (r->SizeOfBlock - sizeof(*r)) / sizeof(*TypeOffset); TRACE("MapModule: %d relocations for page %08lx\n", count, (DWORD)page); for(i = 0; i < count; i++) { int offset = TypeOffset[i] & 0xFFF; int type = TypeOffset[i] >> 12; switch(type) { case IMAGE_REL_BASED_ABSOLUTE: break; case IMAGE_REL_BASED_HIGH: *(WORD *)(page+offset) += HIWORD(module->relocDelta); break; case IMAGE_REL_BASED_LOW: *(WORD *)(page+offset) += LOWORD(module->relocDelta); break; case IMAGE_REL_BASED_HIGHLOW: *(DWORD*)(page+offset) += module->relocDelta; break; default: WARN("MapModule: Unsupported fixup type\n"); break; } } r = (IMAGE_BASE_RELOCATION *)((LPBYTE)r + r->SizeOfBlock); } } context->Eax = 0; RESET_CFLAG(context); } break; case 0x0005: /* UnMap Module */ /* * Input: EDX: Flat address of module image * * Output: EAX: 1 if OK */ TRACE("UnMapModule: %lx\n", (DWORD)W32S_APP2WINE(context->Edx)); /* As we didn't map anything, there's nothing to unmap ... */ context->Eax = 1; break; case 0x0006: /* VirtualAlloc */ /* * Input: ECX: Current Process * * EDX: Flat address of arguments on stack * * DWORD *retv [out] Flat base address of allocated region * LPVOID base [in] Flat address of region to reserve/commit * DWORD size [in] Size of region * DWORD type [in] Type of allocation * DWORD prot [in] Type of access protection * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]); LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]); DWORD size = stack[2]; DWORD type = stack[3]; DWORD prot = stack[4]; DWORD result; TRACE("VirtualAlloc(%lx, %lx, %lx, %lx, %lx)\n", (DWORD)retv, (DWORD)base, size, type, prot); if (type & 0x80000000) { WARN("VirtualAlloc: strange type %lx\n", type); type &= 0x7fffffff; } if (!base && (type & MEM_COMMIT) && prot == PAGE_READONLY) { WARN("VirtualAlloc: NLS hack, allowing write access!\n"); prot = PAGE_READWRITE; } result = (DWORD)VirtualAlloc(base, size, type, prot); if (W32S_WINE2APP(result)) *retv = W32S_WINE2APP(result), context->Eax = STATUS_SUCCESS; else *retv = 0, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x0007: /* VirtualFree */ /* * Input: ECX: Current Process * * EDX: Flat address of arguments on stack * * DWORD *retv [out] TRUE if success, FALSE if failure * LPVOID base [in] Flat address of region * DWORD size [in] Size of region * DWORD type [in] Type of operation * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]); LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]); DWORD size = stack[2]; DWORD type = stack[3]; DWORD result; TRACE("VirtualFree(%lx, %lx, %lx, %lx)\n", (DWORD)retv, (DWORD)base, size, type); result = VirtualFree(base, size, type); if (result) *retv = TRUE, context->Eax = STATUS_SUCCESS; else *retv = FALSE, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x0008: /* VirtualProtect */ /* * Input: ECX: Current Process * * EDX: Flat address of arguments on stack * * DWORD *retv [out] TRUE if success, FALSE if failure * LPVOID base [in] Flat address of region * DWORD size [in] Size of region * DWORD new_prot [in] Desired access protection * DWORD *old_prot [out] Previous access protection * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]); LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]); DWORD size = stack[2]; DWORD new_prot = stack[3]; DWORD *old_prot = (DWORD *)W32S_APP2WINE(stack[4]); DWORD result; TRACE("VirtualProtect(%lx, %lx, %lx, %lx, %lx)\n", (DWORD)retv, (DWORD)base, size, new_prot, (DWORD)old_prot); result = VirtualProtect(base, size, new_prot, old_prot); if (result) *retv = TRUE, context->Eax = STATUS_SUCCESS; else *retv = FALSE, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x0009: /* VirtualQuery */ /* * Input: ECX: Current Process * * EDX: Flat address of arguments on stack * * DWORD *retv [out] Nr. bytes returned * LPVOID base [in] Flat address of region * LPMEMORY_BASIC_INFORMATION info [out] Info buffer * DWORD len [in] Size of buffer * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]); LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]); LPMEMORY_BASIC_INFORMATION info = (LPMEMORY_BASIC_INFORMATION)W32S_APP2WINE(stack[2]); DWORD len = stack[3]; DWORD result; TRACE("VirtualQuery(%lx, %lx, %lx, %lx)\n", (DWORD)retv, (DWORD)base, (DWORD)info, len); result = VirtualQuery(base, info, len); *retv = result; context->Eax = STATUS_SUCCESS; } break; case 0x000A: /* SetVirtMemProcess */ /* * Input: ECX: Process Handle * * EDX: Flat address of region * * Output: EAX: NtStatus */ TRACE("[000a] ECX=%lx EDX=%lx\n", context->Ecx, context->Edx); /* FIXME */ context->Eax = STATUS_SUCCESS; break; case 0x000B: /* ??? some kind of cleanup */ /* * Input: ECX: Process Handle * * Output: EAX: NtStatus */ TRACE("[000b] ECX=%lx\n", context->Ecx); /* FIXME */ context->Eax = STATUS_SUCCESS; break; case 0x000C: /* Set Debug Flags */ /* * Input: EDX: Debug Flags * * Output: EDX: Previous Debug Flags */ FIXME("[000c] EDX=%lx\n", context->Edx); /* FIXME */ context->Edx = 0; break; case 0x000D: /* NtCreateSection */ /* * Input: EDX: Flat address of arguments on stack * * HANDLE32 *retv [out] Handle of Section created * DWORD flags1 [in] (?? unknown ??) * DWORD atom [in] Name of Section to create * LARGE_INTEGER *size [in] Size of Section * DWORD protect [in] Access protection * DWORD flags2 [in] (?? unknown ??) * HFILE32 hFile [in] Handle of file to map * DWORD psp [in] (Win32s: PSP that hFile belongs to) * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *) W32S_APP2WINE(context->Edx); HANDLE *retv = (HANDLE *)W32S_APP2WINE(stack[0]); DWORD flags1 = stack[1]; DWORD atom = stack[2]; LARGE_INTEGER *size = (LARGE_INTEGER *)W32S_APP2WINE(stack[3]); DWORD protect = stack[4]; DWORD flags2 = stack[5]; HANDLE hFile = DosFileHandleToWin32Handle(stack[6]); DWORD psp = stack[7]; HANDLE result = INVALID_HANDLE_VALUE; char name[128]; TRACE("NtCreateSection(%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx)\n", (DWORD)retv, flags1, atom, (DWORD)size, protect, flags2, (DWORD)hFile, psp); if (!atom || GlobalGetAtomNameA(atom, name, sizeof(name))) { TRACE("NtCreateSection: name=%s\n", atom? name : NULL); result = CreateFileMappingA(hFile, NULL, protect, size? size->s.HighPart : 0, size? size->s.LowPart : 0, atom? name : NULL); } if (result == INVALID_HANDLE_VALUE) WARN("NtCreateSection: failed!\n"); else TRACE("NtCreateSection: returned %lx\n", (DWORD)result); if (result != INVALID_HANDLE_VALUE) *retv = result, context->Eax = STATUS_SUCCESS; else *retv = result, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x000E: /* NtOpenSection */ /* * Input: EDX: Flat address of arguments on stack * * HANDLE32 *retv [out] Handle of Section opened * DWORD protect [in] Access protection * DWORD atom [in] Name of Section to create * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); HANDLE *retv = (HANDLE *)W32S_APP2WINE(stack[0]); DWORD protect = stack[1]; DWORD atom = stack[2]; HANDLE result = INVALID_HANDLE_VALUE; char name[128]; TRACE("NtOpenSection(%lx, %lx, %lx)\n", (DWORD)retv, protect, atom); if (atom && GlobalGetAtomNameA(atom, name, sizeof(name))) { TRACE("NtOpenSection: name=%s\n", name); result = OpenFileMappingA(protect, FALSE, name); } if (result == INVALID_HANDLE_VALUE) WARN("NtOpenSection: failed!\n"); else TRACE("NtOpenSection: returned %lx\n", (DWORD)result); if (result != INVALID_HANDLE_VALUE) *retv = result, context->Eax = STATUS_SUCCESS; else *retv = result, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x000F: /* NtCloseSection */ /* * Input: EDX: Flat address of arguments on stack * * HANDLE32 handle [in] Handle of Section to close * DWORD *id [out] Unique ID (?? unclear ??) * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); HANDLE handle = stack[0]; DWORD *id = (DWORD *)W32S_APP2WINE(stack[1]); TRACE("NtCloseSection(%lx, %lx)\n", (DWORD)handle, (DWORD)id); CloseHandle(handle); if (id) *id = 0; /* FIXME */ context->Eax = STATUS_SUCCESS; } break; case 0x0010: /* NtDupSection */ /* * Input: EDX: Flat address of arguments on stack * * HANDLE32 handle [in] Handle of Section to duplicate * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); HANDLE handle = stack[0]; HANDLE new_handle; TRACE("NtDupSection(%lx)\n", (DWORD)handle); DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(), &new_handle, 0, FALSE, DUPLICATE_SAME_ACCESS ); context->Eax = STATUS_SUCCESS; } break; case 0x0011: /* NtMapViewOfSection */ /* * Input: EDX: Flat address of arguments on stack * * HANDLE32 SectionHandle [in] Section to be mapped * DWORD ProcessHandle [in] Process to be mapped into * DWORD * BaseAddress [in/out] Address to be mapped at * DWORD ZeroBits [in] (?? unclear ??) * DWORD CommitSize [in] (?? unclear ??) * LARGE_INTEGER *SectionOffset [in] Offset within section * DWORD * ViewSize [in] Size of view * DWORD InheritDisposition [in] (?? unclear ??) * DWORD AllocationType [in] (?? unclear ??) * DWORD Protect [in] Access protection * * Output: EAX: NtStatus */ { DWORD * stack = (DWORD *)W32S_APP2WINE(context->Edx); HANDLE SectionHandle = stack[0]; DWORD ProcessHandle = stack[1]; /* ignored */ DWORD * BaseAddress = (DWORD *)W32S_APP2WINE(stack[2]); DWORD ZeroBits = stack[3]; DWORD CommitSize = stack[4]; LARGE_INTEGER *SectionOffset = (LARGE_INTEGER *)W32S_APP2WINE(stack[5]); DWORD * ViewSize = (DWORD *)W32S_APP2WINE(stack[6]); DWORD InheritDisposition = stack[7]; DWORD AllocationType = stack[8]; DWORD Protect = stack[9]; LPBYTE address = (LPBYTE)(BaseAddress? W32S_APP2WINE(*BaseAddress) : 0); DWORD access = 0, result; switch (Protect & ~(PAGE_GUARD|PAGE_NOCACHE)) { case PAGE_READONLY: access = FILE_MAP_READ; break; case PAGE_READWRITE: access = FILE_MAP_WRITE; break; case PAGE_WRITECOPY: access = FILE_MAP_COPY; break; case PAGE_EXECUTE_READ: access = FILE_MAP_READ; break; case PAGE_EXECUTE_READWRITE: access = FILE_MAP_WRITE; break; case PAGE_EXECUTE_WRITECOPY: access = FILE_MAP_COPY; break; } TRACE("NtMapViewOfSection" "(%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx)\n", (DWORD)SectionHandle, ProcessHandle, (DWORD)BaseAddress, ZeroBits, CommitSize, (DWORD)SectionOffset, (DWORD)ViewSize, InheritDisposition, AllocationType, Protect); TRACE("NtMapViewOfSection: " "base=%lx, offset=%lx, size=%lx, access=%lx\n", (DWORD)address, SectionOffset? SectionOffset->s.LowPart : 0, ViewSize? *ViewSize : 0, access); result = (DWORD)MapViewOfFileEx(SectionHandle, access, SectionOffset? SectionOffset->s.HighPart : 0, SectionOffset? SectionOffset->s.LowPart : 0, ViewSize? *ViewSize : 0, address); TRACE("NtMapViewOfSection: result=%lx\n", result); if (W32S_WINE2APP(result)) { if (BaseAddress) *BaseAddress = W32S_WINE2APP(result); context->Eax = STATUS_SUCCESS; } else context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x0012: /* NtUnmapViewOfSection */ /* * Input: EDX: Flat address of arguments on stack * * DWORD ProcessHandle [in] Process (defining address space) * LPBYTE BaseAddress [in] Base address of view to be unmapped * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD ProcessHandle = stack[0]; /* ignored */ LPBYTE BaseAddress = (LPBYTE)W32S_APP2WINE(stack[1]); TRACE("NtUnmapViewOfSection(%lx, %lx)\n", ProcessHandle, (DWORD)BaseAddress); UnmapViewOfFile(BaseAddress); context->Eax = STATUS_SUCCESS; } break; case 0x0013: /* NtFlushVirtualMemory */ /* * Input: EDX: Flat address of arguments on stack * * DWORD ProcessHandle [in] Process (defining address space) * LPBYTE *BaseAddress [in?] Base address of range to be flushed * DWORD *ViewSize [in?] Number of bytes to be flushed * DWORD *unknown [???] (?? unknown ??) * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD ProcessHandle = stack[0]; /* ignored */ DWORD *BaseAddress = (DWORD *)W32S_APP2WINE(stack[1]); DWORD *ViewSize = (DWORD *)W32S_APP2WINE(stack[2]); DWORD *unknown = (DWORD *)W32S_APP2WINE(stack[3]); LPBYTE address = (LPBYTE)(BaseAddress? W32S_APP2WINE(*BaseAddress) : 0); DWORD size = ViewSize? *ViewSize : 0; TRACE("NtFlushVirtualMemory(%lx, %lx, %lx, %lx)\n", ProcessHandle, (DWORD)BaseAddress, (DWORD)ViewSize, (DWORD)unknown); TRACE("NtFlushVirtualMemory: base=%lx, size=%lx\n", (DWORD)address, size); FlushViewOfFile(address, size); context->Eax = STATUS_SUCCESS; } break; case 0x0014: /* Get/Set Debug Registers */ /* * Input: ECX: 0 if Get, 1 if Set * * EDX: Get: Flat address of buffer to receive values of * debug registers DR0 .. DR7 * Set: Flat address of buffer containing values of * debug registers DR0 .. DR7 to be set * Output: None */ FIXME("[0014] ECX=%lx EDX=%lx\n", context->Ecx, context->Edx); /* FIXME */ break; case 0x0015: /* Set Coprocessor Emulation Flag */ /* * Input: EDX: 0 to deactivate, 1 to activate coprocessor emulation * * Output: None */ TRACE("[0015] EDX=%lx\n", context->Edx); /* We don't care, as we always have a coprocessor anyway */ break; case 0x0016: /* Init Win32S VxD PSP */ /* * If called to query required PSP size: * * Input: EBX: 0 * Output: EDX: Required size of Win32s VxD PSP * * If called to initialize allocated PSP: * * Input: EBX: LoWord: Selector of Win32s VxD PSP * HiWord: Paragraph of Win32s VxD PSP (DOSMEM) * Output: None */ if (context->Ebx == 0) context->Edx = 0x80; else { PDB16 *psp = MapSL( MAKESEGPTR( BX_reg(context), 0 )); psp->nbFiles = 32; psp->fileHandlesPtr = MAKELONG(HIWORD(context->Ebx), 0x5c); memset((LPBYTE)psp + 0x5c, '\xFF', 32); } break; case 0x0017: /* Set Break Point */ /* * Input: EBX: Offset of Break Point * CX: Selector of Break Point * * Output: None */ FIXME("[0017] EBX=%lx CX=%x\n", context->Ebx, CX_reg(context)); /* FIXME */ break; case 0x0018: /* VirtualLock */ /* * Input: ECX: Current Process * * EDX: Flat address of arguments on stack * * DWORD *retv [out] TRUE if success, FALSE if failure * LPVOID base [in] Flat address of range to lock * DWORD size [in] Size of range * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]); LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]); DWORD size = stack[2]; DWORD result; TRACE("VirtualLock(%lx, %lx, %lx)\n", (DWORD)retv, (DWORD)base, size); result = VirtualLock(base, size); if (result) *retv = TRUE, context->Eax = STATUS_SUCCESS; else *retv = FALSE, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x0019: /* VirtualUnlock */ /* * Input: ECX: Current Process * * EDX: Flat address of arguments on stack * * DWORD *retv [out] TRUE if success, FALSE if failure * LPVOID base [in] Flat address of range to unlock * DWORD size [in] Size of range * * Output: EAX: NtStatus */ { DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx); DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]); LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]); DWORD size = stack[2]; DWORD result; TRACE("VirtualUnlock(%lx, %lx, %lx)\n", (DWORD)retv, (DWORD)base, size); result = VirtualUnlock(base, size); if (result) *retv = TRUE, context->Eax = STATUS_SUCCESS; else *retv = FALSE, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x001A: /* KGetSystemInfo */ /* * Input: None * * Output: ECX: Start of sparse memory arena * EDX: End of sparse memory arena */ TRACE("KGetSystemInfo()\n"); /* * Note: Win32s reserves 0GB - 2GB for Win 3.1 and uses 2GB - 4GB as * sparse memory arena. We do it the other way around, since * we have to reserve 3GB - 4GB for Linux, and thus use * 0GB - 3GB as sparse memory arena. * * FIXME: What about other OSes ? */ context->Ecx = W32S_WINE2APP(0x00000000); context->Edx = W32S_WINE2APP(0xbfffffff); break; case 0x001B: /* KGlobalMemStat */ /* * Input: ESI: Flat address of buffer to receive memory info * * Output: None */ { struct Win32sMemoryInfo { DWORD DIPhys_Count; /* Total physical pages */ DWORD DIFree_Count; /* Free physical pages */ DWORD DILin_Total_Count; /* Total virtual pages (private arena) */ DWORD DILin_Total_Free; /* Free virtual pages (private arena) */ DWORD SparseTotal; /* Total size of sparse arena (bytes ?) */ DWORD SparseFree; /* Free size of sparse arena (bytes ?) */ }; struct Win32sMemoryInfo *info = (struct Win32sMemoryInfo *)W32S_APP2WINE(context->Esi); FIXME("KGlobalMemStat(%lx)\n", (DWORD)info); /* FIXME */ } break; case 0x001C: /* Enable/Disable Exceptions */ /* * Input: ECX: 0 to disable, 1 to enable exception handling * * Output: None */ TRACE("[001c] ECX=%lx\n", context->Ecx); /* FIXME */ break; case 0x001D: /* VirtualAlloc called from 16-bit code */ /* * Input: EDX: Segmented address of arguments on stack * * LPVOID base [in] Flat address of region to reserve/commit * DWORD size [in] Size of region * DWORD type [in] Type of allocation * DWORD prot [in] Type of access protection * * Output: EAX: NtStatus * EDX: Flat base address of allocated region */ { DWORD *stack = MapSL( MAKESEGPTR( LOWORD(context->Edx), HIWORD(context->Edx) )); LPVOID base = (LPVOID)W32S_APP2WINE(stack[0]); DWORD size = stack[1]; DWORD type = stack[2]; DWORD prot = stack[3]; DWORD result; TRACE("VirtualAlloc16(%lx, %lx, %lx, %lx)\n", (DWORD)base, size, type, prot); if (type & 0x80000000) { WARN("VirtualAlloc16: strange type %lx\n", type); type &= 0x7fffffff; } result = (DWORD)VirtualAlloc(base, size, type, prot); if (W32S_WINE2APP(result)) context->Edx = W32S_WINE2APP(result), context->Eax = STATUS_SUCCESS; else context->Edx = 0, context->Eax = STATUS_NO_MEMORY; /* FIXME */ TRACE("VirtualAlloc16: returning base %lx\n", context->Edx); } break; case 0x001E: /* VirtualFree called from 16-bit code */ /* * Input: EDX: Segmented address of arguments on stack * * LPVOID base [in] Flat address of region * DWORD size [in] Size of region * DWORD type [in] Type of operation * * Output: EAX: NtStatus * EDX: TRUE if success, FALSE if failure */ { DWORD *stack = MapSL( MAKESEGPTR( LOWORD(context->Edx), HIWORD(context->Edx) )); LPVOID base = (LPVOID)W32S_APP2WINE(stack[0]); DWORD size = stack[1]; DWORD type = stack[2]; DWORD result; TRACE("VirtualFree16(%lx, %lx, %lx)\n", (DWORD)base, size, type); result = VirtualFree(base, size, type); if (result) context->Edx = TRUE, context->Eax = STATUS_SUCCESS; else context->Edx = FALSE, context->Eax = STATUS_NO_MEMORY; /* FIXME */ } break; case 0x001F: /* FWorkingSetSize */ /* * Input: EDX: 0 if Get, 1 if Set * * ECX: Get: Buffer to receive Working Set Size * Set: Buffer containing Working Set Size * * Output: NtStatus */ { DWORD *ptr = (DWORD *)W32S_APP2WINE(context->Ecx); BOOL set = context->Edx; TRACE("FWorkingSetSize(%lx, %lx)\n", (DWORD)ptr, (DWORD)set); if (set) /* We do it differently ... */; else *ptr = 0x100; context->Eax = STATUS_SUCCESS; } break; default: VXD_BARF( context, "W32S" ); }
/********************************************************************** * DOSVM_Int31Handler (WINEDOS16.149) * * Handler for int 31h (DPMI). */ void WINAPI DOSVM_Int31Handler( CONTEXT86 *context ) { RESET_CFLAG(context); switch(AX_reg(context)) { case 0x0000: /* Allocate LDT descriptors */ TRACE( "allocate LDT descriptors (%d)\n", CX_reg(context) ); { WORD sel = AllocSelectorArray16( CX_reg(context) ); if(!sel) { TRACE( "failed\n" ); SET_AX( context, 0x8011 ); /* descriptor unavailable */ SET_CFLAG( context ); } else { TRACE( "success, array starts at 0x%04x\n", sel ); SET_AX( context, sel ); } } break; case 0x0001: /* Free LDT descriptor */ TRACE( "free LDT descriptor (0x%04x)\n", BX_reg(context) ); if (FreeSelector16( BX_reg(context) )) { SET_AX( context, 0x8022 ); /* invalid selector */ SET_CFLAG( context ); } else { /* If a segment register contains the selector being freed, */ /* set it to zero. */ if (!((context->SegDs^BX_reg(context)) & ~3)) context->SegDs = 0; if (!((context->SegEs^BX_reg(context)) & ~3)) context->SegEs = 0; if (!((context->SegFs^BX_reg(context)) & ~3)) context->SegFs = 0; if (!((context->SegGs^BX_reg(context)) & ~3)) context->SegGs = 0; } break; case 0x0002: /* Real mode segment to descriptor */ TRACE( "real mode segment to descriptor (0x%04x)\n", BX_reg(context) ); { WORD entryPoint = 0; /* KERNEL entry point for descriptor */ switch(BX_reg(context)) { case 0x0000: entryPoint = 183; break; /* __0000H */ case 0x0040: entryPoint = 193; break; /* __0040H */ case 0xa000: entryPoint = 174; break; /* __A000H */ case 0xb000: entryPoint = 181; break; /* __B000H */ case 0xb800: entryPoint = 182; break; /* __B800H */ case 0xc000: entryPoint = 195; break; /* __C000H */ case 0xd000: entryPoint = 179; break; /* __D000H */ case 0xe000: entryPoint = 190; break; /* __E000H */ case 0xf000: entryPoint = 194; break; /* __F000H */ default: FIXME("Real mode segment (%x) to descriptor: no longer supported\n", BX_reg(context)); SET_CFLAG( context ); break; } if (entryPoint) { FARPROC16 proc = GetProcAddress16( GetModuleHandle16( "KERNEL" ), (LPCSTR)(ULONG_PTR)entryPoint ); SET_AX( context, LOWORD(proc) ); } } break; case 0x0003: /* Get next selector increment */ TRACE("get selector increment (__AHINCR)\n"); context->Eax = __AHINCR; break; case 0x0004: /* Lock selector (not supported) */ FIXME("lock selector not supported\n"); context->Eax = 0; /* FIXME: is this a correct return value? */ break; case 0x0005: /* Unlock selector (not supported) */ FIXME("unlock selector not supported\n"); context->Eax = 0; /* FIXME: is this a correct return value? */ break; case 0x0006: /* Get selector base address */ TRACE( "get selector base address (0x%04x)\n", BX_reg(context) ); { LDT_ENTRY entry; WORD sel = BX_reg(context); wine_ldt_get_entry( sel, &entry ); if (wine_ldt_is_empty(&entry)) { context->Eax = 0x8022; /* invalid selector */ SET_CFLAG(context); } else { void *base = wine_ldt_get_base(&entry); SET_CX( context, HIWORD(base) ); SET_DX( context, LOWORD(base) ); } } break; case 0x0007: /* Set selector base address */ { DWORD base = MAKELONG( DX_reg(context), CX_reg(context) ); WORD sel = BX_reg(context); TRACE( "set selector base address (0x%04x,0x%08lx)\n", sel, base ); /* check if Win16 app wants to access lower 64K of DOS memory */ if (base < 0x10000 && DOSVM_IsWin16()) DOSMEM_MapDosLayout(); SetSelectorBase( sel, base ); } break; case 0x0008: /* Set selector limit */ { DWORD limit = MAKELONG( DX_reg(context), CX_reg(context) ); TRACE( "set selector limit (0x%04x,0x%08lx)\n", BX_reg(context), limit ); SetSelectorLimit16( BX_reg(context), limit ); } break; case 0x0009: /* Set selector access rights */ TRACE( "set selector access rights(0x%04x,0x%04x)\n", BX_reg(context), CX_reg(context) ); SelectorAccessRights16( BX_reg(context), 1, CX_reg(context) ); break; case 0x000a: /* Allocate selector alias */ TRACE( "allocate selector alias (0x%04x)\n", BX_reg(context) ); SET_AX( context, AllocCStoDSAlias16( BX_reg(context) ) ); if (!AX_reg(context)) { SET_AX( context, 0x8011 ); /* descriptor unavailable */ SET_CFLAG(context); } break; case 0x000b: /* Get descriptor */ TRACE( "get descriptor (0x%04x)\n", BX_reg(context) ); { LDT_ENTRY *entry = (LDT_ENTRY*)CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi ); wine_ldt_get_entry( BX_reg(context), entry ); } break; case 0x000c: /* Set descriptor */ TRACE( "set descriptor (0x%04x)\n", BX_reg(context) ); { LDT_ENTRY *entry = (LDT_ENTRY*)CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi ); wine_ldt_set_entry( BX_reg(context), entry ); } break; case 0x000d: /* Allocate specific LDT descriptor */ FIXME( "allocate descriptor (0x%04x), stub!\n", BX_reg(context) ); SET_AX( context, 0x8011 ); /* descriptor unavailable */ SET_CFLAG( context ); break; case 0x000e: /* Get Multiple Descriptors (1.0) */ FIXME( "get multiple descriptors - unimplemented\n" ); break; case 0x000f: /* Set Multiple Descriptors (1.0) */ FIXME( "set multiple descriptors - unimplemented\n" ); break; case 0x0100: /* Allocate DOS memory block */ TRACE( "allocate DOS memory block (0x%x paragraphs)\n", BX_reg(context) ); { DWORD dw = GlobalDOSAlloc16( (DWORD)BX_reg(context) << 4 ); if (dw) { SET_AX( context, HIWORD(dw) ); SET_DX( context, LOWORD(dw) ); } else { SET_AX( context, 0x0008 ); /* insufficient memory */ SET_BX( context, DOSMEM_Available() >> 4 ); SET_CFLAG(context); } break; } case 0x0101: /* Free DOS memory block */ TRACE( "free DOS memory block (0x%04x)\n", DX_reg(context) ); { WORD error = GlobalDOSFree16( DX_reg(context) ); if (error) { SET_AX( context, 0x0009 ); /* memory block address invalid */ SET_CFLAG( context ); } } break; case 0x0102: /* Resize DOS Memory Block */ FIXME( "resize DOS memory block (0x%04x, 0x%x paragraphs) - unimplemented\n", DX_reg(context), BX_reg(context) ); break; case 0x0200: /* get real mode interrupt vector */ TRACE( "get realmode interupt vector (0x%02x)\n", BL_reg(context) ); { FARPROC16 proc = DOSVM_GetRMHandler( BL_reg(context) ); SET_CX( context, SELECTOROF(proc) ); SET_DX( context, OFFSETOF(proc) ); } break; case 0x0201: /* set real mode interrupt vector */ TRACE( "set realmode interrupt vector (0x%02x, 0x%04x:0x%04x)\n", BL_reg(context), CX_reg(context), DX_reg(context) ); DOSVM_SetRMHandler( BL_reg(context), (FARPROC16)MAKESEGPTR(CX_reg(context), DX_reg(context)) ); break; case 0x0202: /* Get Processor Exception Handler Vector */ FIXME( "Get Processor Exception Handler Vector (0x%02x)\n", BL_reg(context) ); if (DOSVM_IsDos32()) { SET_CX( context, 0 ); context->Edx = 0; } else { SET_CX( context, 0 ); SET_DX( context, 0 ); } break; case 0x0203: /* Set Processor Exception Handler Vector */ FIXME( "Set Processor Exception Handler Vector (0x%02x)\n", BL_reg(context) ); break; case 0x0204: /* Get protected mode interrupt vector */ TRACE("get protected mode interrupt handler (0x%02x)\n", BL_reg(context)); if (DOSVM_IsDos32()) { FARPROC48 handler = DOSVM_GetPMHandler48( BL_reg(context) ); SET_CX( context, handler.selector ); context->Edx = handler.offset; } else { FARPROC16 handler = DOSVM_GetPMHandler16( BL_reg(context) ); SET_CX( context, SELECTOROF(handler) ); SET_DX( context, OFFSETOF(handler) ); } break; case 0x0205: /* Set protected mode interrupt vector */ TRACE("set protected mode interrupt handler (0x%02x,0x%04x:0x%08lx)\n", BL_reg(context), CX_reg(context), context->Edx); if (DOSVM_IsDos32()) { FARPROC48 handler; handler.selector = CX_reg(context); handler.offset = context->Edx; DOSVM_SetPMHandler48( BL_reg(context), handler ); } else { FARPROC16 handler; handler = (FARPROC16)MAKESEGPTR( CX_reg(context), DX_reg(context)); DOSVM_SetPMHandler16( BL_reg(context), handler ); } break; case 0x0300: /* Simulate real mode interrupt */ TRACE( "Simulate real mode interrupt %02x.\n", BL_reg(context)); DOSVM_CallRMInt( context ); break; case 0x0301: /* Call real mode procedure with far return */ TRACE( "Call real mode procedure with far return.\n" ); DOSVM_CallRMProc( context, FALSE ); break; case 0x0302: /* Call real mode procedure with interrupt return */ TRACE( "Call real mode procedure with interrupt return.\n" ); DOSVM_CallRMProc( context, TRUE ); break; case 0x0303: /* Allocate Real Mode Callback Address */ TRACE( "Allocate real mode callback address.\n" ); DOSVM_AllocRMCB( context ); break; case 0x0304: /* Free Real Mode Callback Address */ TRACE( "Free real mode callback address.\n" ); DOSVM_FreeRMCB( context ); break; case 0x0305: /* Get State Save/Restore Addresses */ TRACE("get state save/restore addresses\n"); /* we probably won't need this kind of state saving */ SET_AX( context, 0 ); /* real mode: just point to the lret */ SET_BX( context, DOSVM_dpmi_segments->wrap_seg ); SET_CX( context, 2 ); /* protected mode: don't have any handler yet... */ /* FIXME: Use DI in 16-bit DPMI and EDI in 32-bit DPMI */ FIXME("no protected-mode dummy state save/restore handler yet\n"); SET_SI( context, 0 ); context->Edi = 0; break; case 0x0306: /* Get Raw Mode Switch Addresses */ TRACE("get raw mode switch addresses\n"); /* real mode, point to standard DPMI return wrapper */ SET_BX( context, DOSVM_dpmi_segments->wrap_seg ); SET_CX( context, 0 ); /* protected mode, point to DPMI call wrapper */ /* FIXME: Use DI in 16-bit DPMI and EDI in 32-bit DPMI */ /* FIXME: Doesn't work in DPMI32... */ SET_SI( context, DOSVM_dpmi_segments->dpmi_sel ); context->Edi = 8; /* offset of the INT 0x31 call */ break; case 0x0400: /* Get DPMI version */ TRACE("get DPMI version\n"); { SYSTEM_INFO si; GetSystemInfo(&si); SET_AX( context, 0x005a ); /* DPMI version 0.90 */ SET_BX( context, 0x0005 ); /* Flags: 32-bit, virtual memory */ SET_CL( context, si.wProcessorLevel ); SET_DX( context, 0x0870 ); /* Master/slave interrupt controller base */ } break; case 0x0401: /* Get DPMI Capabilities (1.0) */ FIXME( "get dpmi capabilities - unimplemented\n"); break; case 0x0500: /* Get free memory information */ TRACE("get free memory information\n"); { MEMORYSTATUS status; /* the layout is just the same as MEMMANINFO, but without * the dwSize entry. */ struct { DWORD dwLargestFreeBlock; DWORD dwMaxPagesAvailable; DWORD dwMaxPagesLockable; DWORD dwTotalLinearSpace; DWORD dwTotalUnlockedPages; DWORD dwFreePages; DWORD dwTotalPages; DWORD dwFreeLinearSpace; DWORD dwSwapFilePages; WORD wPageSize; } *info = CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi ); GlobalMemoryStatus( &status ); info->wPageSize = getpagesize(); info->dwLargestFreeBlock = status.dwAvailVirtual; info->dwMaxPagesAvailable = info->dwLargestFreeBlock / info->wPageSize; info->dwMaxPagesLockable = info->dwMaxPagesAvailable; info->dwTotalLinearSpace = status.dwTotalVirtual / info->wPageSize; info->dwTotalUnlockedPages = info->dwTotalLinearSpace; info->dwFreePages = info->dwMaxPagesAvailable; info->dwTotalPages = info->dwTotalLinearSpace; info->dwFreeLinearSpace = info->dwMaxPagesAvailable; info->dwSwapFilePages = status.dwTotalPageFile / info->wPageSize; break; } case 0x0501: /* Allocate memory block */ { DWORD size = MAKELONG( CX_reg(context), BX_reg(context) ); BYTE *ptr; TRACE( "allocate memory block (%ld bytes)\n", size ); ptr = (BYTE *)DPMI_xalloc( size ); if (!ptr) { SET_AX( context, 0x8012 ); /* linear memory not available */ SET_CFLAG(context); } else { SET_BX( context, HIWORD(ptr) ); SET_CX( context, LOWORD(ptr) ); SET_SI( context, HIWORD(ptr) ); SET_DI( context, LOWORD(ptr) ); } break; } case 0x0502: /* Free memory block */ { DWORD handle = MAKELONG( DI_reg(context), SI_reg(context) ); TRACE( "free memory block (0x%08lx)\n", handle ); DPMI_xfree( (void *)handle ); } break; case 0x0503: /* Resize memory block */ { DWORD size = MAKELONG( CX_reg(context), BX_reg(context) ); DWORD handle = MAKELONG( DI_reg(context), SI_reg(context) ); BYTE *ptr; TRACE( "resize memory block (0x%08lx, %ld bytes)\n", handle, size ); ptr = (BYTE *)DPMI_xrealloc( (void *)handle, size ); if (!ptr) { SET_AX( context, 0x8012 ); /* linear memory not available */ SET_CFLAG(context); } else { SET_BX( context, HIWORD(ptr) ); SET_CX( context, LOWORD(ptr) ); SET_SI( context, HIWORD(ptr) ); SET_DI( context, LOWORD(ptr) ); } } break; case 0x0507: /* Set page attributes (1.0) */ FIXME( "set page attributes - unimplemented\n" ); break; /* Just ignore it */ case 0x0600: /* Lock linear region */ TRACE( "lock linear region - ignored (no paging)\n" ); break; case 0x0601: /* Unlock linear region */ TRACE( "unlock linear region - ignored (no paging)\n" ); break; case 0x0602: /* Mark real mode region as pageable */ TRACE( "mark real mode region as pageable - ignored (no paging)\n" ); break; case 0x0603: /* Relock real mode region */ TRACE( "relock real mode region - ignored (no paging)\n" ); break; case 0x0604: /* Get page size */ TRACE("get pagesize\n"); SET_BX( context, HIWORD(getpagesize()) ); SET_CX( context, LOWORD(getpagesize()) ); break; case 0x0700: /* Mark pages as paging candidates */ TRACE( "mark pages as paging candidates - ignored (no paging)\n" ); break; case 0x0701: /* Discard pages */ TRACE( "discard pages - ignored (no paging)\n" ); break; case 0x0702: /* Mark page as demand-paging candidate */ TRACE( "mark page as demand-paging candidate - ignored (no paging)\n" ); break; case 0x0703: /* Discard page contents */ TRACE( "discard page contents - ignored (no paging)\n" ); break; case 0x0800: /* Physical address mapping */ FIXME( "physical address mapping (0x%08lx) - unimplemented\n", MAKELONG(CX_reg(context),BX_reg(context)) ); break; case 0x0900: /* Get and Disable Virtual Interrupt State */ TRACE( "Get and Disable Virtual Interrupt State: %ld\n", NtCurrentTeb()->dpmi_vif ); SET_AL( context, NtCurrentTeb()->dpmi_vif ? 1 : 0 ); NtCurrentTeb()->dpmi_vif = 0; break; case 0x0901: /* Get and Enable Virtual Interrupt State */ TRACE( "Get and Enable Virtual Interrupt State: %ld\n", NtCurrentTeb()->dpmi_vif ); SET_AL( context, NtCurrentTeb()->dpmi_vif ? 1 : 0 ); NtCurrentTeb()->dpmi_vif = 1; break; case 0x0902: /* Get Virtual Interrupt State */ TRACE( "Get Virtual Interrupt State: %ld\n", NtCurrentTeb()->dpmi_vif ); SET_AL( context, NtCurrentTeb()->dpmi_vif ? 1 : 0 ); break; case 0x0e00: /* Get Coprocessor Status (1.0) */ /* * Return status in AX bits: * B0 - MPv (MP bit in the virtual MSW/CR0) * 0 = numeric coprocessor is disabled for this client * 1 = numeric coprocessor is enabled for this client * B1 - EMv (EM bit in the virtual MSW/CR0) * 0 = client is not emulating coprocessor instructions * 1 = client is emulating coprocessor instructions * B2 - MPr (MP bit from the actual MSW/CR0) * 0 = numeric coprocessor is not present * 1 = numeric coprocessor is present * B3 - EMr (EM bit from the actual MSW/CR0) * 0 = host is not emulating coprocessor instructions * 1 = host is emulating coprocessor instructions * B4-B7 - coprocessor type * 00H = no coprocessor * 02H = 80287 * 03H = 80387 * 04H = 80486 with numeric coprocessor * 05H-0FH = reserved for future numeric processors */ TRACE( "Get Coprocessor Status\n" ); SET_AX( context, 69 ); /* 486, coprocessor present and enabled */ break; case 0x0e01: /* Set Coprocessor Emulation (1.0) */ /* * See function 0x0e00. * BX bit B0 is new value for MPv. * BX bit B1 is new value for EMv. */ if (BX_reg(context) != 1) FIXME( "Set Coprocessor Emulation to %d - unimplemented\n", BX_reg(context) ); else TRACE( "Set Coprocessor Emulation - ignored\n" ); break; default: INT_BARF( context, 0x31 ); SET_AX( context, 0x8001 ); /* unsupported function */ SET_CFLAG(context); break; } }
/*********************************************************************** * VERSION_GetFileVersionInfo_16 [internal] * * NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF * in the case if file exists, but VERSION_INFO not found. * FIXME: handle is not used. */ static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, LPDWORD handle, DWORD datasize, LPVOID data ) { VS_FIXEDFILEINFO *vffi; DWORD len; BYTE *buf; HMODULE16 hModule; HRSRC16 hRsrc; HGLOBAL16 hMem; BOOL do_free_library = FALSE; TRACE("(%s,%p)\n", debugstr_a(filename), handle ); hModule = GetModuleHandle16(filename); if(hModule < 32) { hModule = LoadLibrary16(filename); do_free_library = TRUE; } if(hModule < 32) { WARN("Could not load %s\n", debugstr_a(filename)); return 0; } hRsrc = FindResource16(hModule, MAKEINTRESOURCEA(VS_VERSION_INFO), MAKEINTRESOURCEA(VS_FILE_INFO)); if(!hRsrc) { WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename)); if(do_free_library) FreeLibrary16(hModule); return 0xFFFFFFFF; } len = SizeofResource16(hModule, hRsrc); hMem = LoadResource16(hModule, hRsrc); if(!hMem) { WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename)); if(do_free_library) FreeLibrary16(hModule); return 0xFFFFFFFF; } buf = LockResource16(hMem); if(!VersionInfoIs16(buf)) goto END; vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf ); if ( vffi->dwSignature != VS_FFI_SIGNATURE ) { WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n", vffi->dwSignature, VS_FFI_SIGNATURE ); len = 0xFFFFFFFF; goto END; } if ( TRACE_ON(ver) ) print_vffi_debug( vffi ); if(data) { if(datasize < len) len = datasize; /* truncate data */ if(len) memcpy(data, buf, len); else len = 0xFFFFFFFF; } END: FreeResource16(hMem); if(do_free_library) FreeLibrary16(hModule); return len; }