/* * Toolhelp functions * * Copyright 1996 Marcus Meissner * Copyright 2009 Alexandre Julliard * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #define NONAMELESSUNION #define NONAMELESSSTRUCT #include <stdarg.h> #include <stdlib.h> #include <string.h> #ifdef HAVE_UNISTD_H # include <unistd.h> #endif #include <ctype.h> #include <assert.h> #include "windef.h" #include "winbase.h" #include "winternl.h" #include "wownt32.h" #include "wine/winbase16.h" #include "toolhelp.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(toolhelp); #include "pshpack1.h" typedef struct { void *base; /* Base address (0 if discarded) */ DWORD size; /* Size in bytes (0 indicates a free block) */ HGLOBAL16 handle; /* Handle for this block */ HGLOBAL16 hOwner; /* Owner of this block */ BYTE lockCount; /* Count of GlobalFix() calls */ BYTE pageLockCount; /* Count of GlobalPageLock() calls */ BYTE flags; /* Allocation flags */ BYTE selCount; /* Number of selectors allocated for this block */ } GLOBALARENA; #define GLOBAL_MAX_COUNT 8192 /* Max number of allocated blocks */ typedef struct { WORD check; /* 00 Heap checking flag */ WORD freeze; /* 02 Heap frozen flag */ WORD items; /* 04 Count of items on the heap */ WORD first; /* 06 First item of the heap */ WORD pad1; /* 08 Always 0 */ WORD last; /* 0a Last item of the heap */ WORD pad2; /* 0c Always 0 */ BYTE ncompact; /* 0e Compactions counter */ BYTE dislevel; /* 0f Discard level */ DWORD distotal; /* 10 Total bytes discarded */ WORD htable; /* 14 Pointer to handle table */ WORD hfree; /* 16 Pointer to free handle table */ WORD hdelta; /* 18 Delta to expand the handle table */ WORD expand; /* 1a Pointer to expand function (unused) */ WORD pstat; /* 1c Pointer to status structure (unused) */ FARPROC16 notify; /* 1e Pointer to LocalNotify() function */ WORD lock; /* 22 Lock count for the heap */ WORD extra; /* 24 Extra bytes to allocate when expanding */ WORD minsize; /* 26 Minimum size of the heap */ WORD magic; /* 28 Magic number */ } LOCALHEAPINFO; typedef struct { /* Arena header */ WORD prev; /* Previous arena | arena type */ WORD next; /* Next arena */ /* Start of the memory block or free-list info */ WORD size; /* Size of the free block */ WORD free_prev; /* Previous free block */ WORD free_next; /* Next free block */ } LOCALARENA; #define LOCAL_ARENA_HEADER_SIZE 4 #define LOCAL_ARENA_HEADER( handle) ((handle) - LOCAL_ARENA_HEADER_SIZE) #define LOCAL_ARENA_PTR(ptr,arena) ((LOCALARENA *)((char *)(ptr)+(arena))) typedef struct { WORD null; /* Always 0 */ DWORD old_ss_sp; /* Stack pointer; used by SwitchTaskTo() */ WORD heap; /* Pointer to the local heap information (if any) */ WORD atomtable; /* Pointer to the local atom table (if any) */ WORD stacktop; /* Top of the stack */ WORD stackmin; /* Lowest stack address used so far */ WORD stackbottom; /* Bottom of the stack */ } INSTANCEDATA; typedef struct _THHOOK { HANDLE16 hGlobalHeap; /* 00 (handle BURGERMASTER) */ WORD pGlobalHeap; /* 02 (selector BURGERMASTER) */ HMODULE16 hExeHead; /* 04 hFirstModule */ HMODULE16 hExeSweep; /* 06 (unused) */ HANDLE16 TopPDB; /* 08 (handle of KERNEL PDB) */ HANDLE16 HeadPDB; /* 0A (first PDB in list) */ HANDLE16 TopSizePDB; /* 0C (unused) */ HTASK16 HeadTDB; /* 0E hFirstTask */ HTASK16 CurTDB; /* 10 hCurrentTask */ HTASK16 LoadTDB; /* 12 (unused) */ HTASK16 LockTDB; /* 14 hLockedTask */ } THHOOK; typedef struct _NE_MODULE { WORD ne_magic; /* 00 'NE' signature */ WORD count; /* 02 Usage count (ne_ver/ne_rev on disk) */ WORD ne_enttab; /* 04 Near ptr to entry table */ HMODULE16 next; /* 06 Selector to next module (ne_cbenttab on disk) */ WORD dgroup_entry; /* 08 Near ptr to segment entry for DGROUP (ne_crc on disk) */ WORD fileinfo; /* 0a Near ptr to file info (OFSTRUCT) (ne_crc on disk) */ WORD ne_flags; /* 0c Module flags */ WORD ne_autodata; /* 0e Logical segment for DGROUP */ WORD ne_heap; /* 10 Initial heap size */ WORD ne_stack; /* 12 Initial stack size */ DWORD ne_csip; /* 14 Initial cs:ip */ DWORD ne_sssp; /* 18 Initial ss:sp */ WORD ne_cseg; /* 1c Number of segments in segment table */ WORD ne_cmod; /* 1e Number of module references */ WORD ne_cbnrestab; /* 20 Size of non-resident names table */ WORD ne_segtab; /* 22 Near ptr to segment table */ WORD ne_rsrctab; /* 24 Near ptr to resource table */ WORD ne_restab; /* 26 Near ptr to resident names table */ WORD ne_modtab; /* 28 Near ptr to module reference table */ WORD ne_imptab; /* 2a Near ptr to imported names table */ DWORD ne_nrestab; /* 2c File offset of non-resident names table */ WORD ne_cmovent; /* 30 Number of moveable entries in entry table*/ WORD ne_align; /* 32 Alignment shift count */ WORD ne_cres; /* 34 # of resource segments */ BYTE ne_exetyp; /* 36 Operating system flags */ BYTE ne_flagsothers; /* 37 Misc. flags */ HANDLE16 dlls_to_init; /* 38 List of DLLs to initialize (ne_pretthunks on disk) */ HANDLE16 nrname_handle; /* 3a Handle to non-resident name table (ne_psegrefbytes on disk) */ WORD ne_swaparea; /* 3c Min. swap area size */ WORD ne_expver; /* 3e Expected Windows version */ /* From here, these are extra fields not present in normal Windows */ HMODULE module32; /* PE module handle for Win32 modules */ HMODULE owner32; /* PE module containing this one for 16-bit builtins */ HMODULE16 self; /* Handle for this module */ WORD self_loading_sel; /* Selector used for self-loading apps. */ LPVOID rsrc32_map; /* HRSRC 16->32 map (for 32-bit modules) */ LPCVOID mapping; /* mapping of the binary file */ SIZE_T mapping_size; /* size of the file mapping */ } NE_MODULE; #include "poppack.h" #define TDB_MAGIC ('T' | ('D' << 8)) /* FIXME: to make this work, we have to call back all these registered * functions from all over the WINE code. Someone with more knowledge than * me please do that. -Marcus */ static struct notify { HTASK16 htask; FARPROC16 lpfnCallback; WORD wFlags; } *notifys = NULL; static int nrofnotifys = 0; static THHOOK *get_thhook(void) { static THHOOK *thhook; if (!thhook) thhook = MapSL( (SEGPTR)GetProcAddress16( GetModuleHandle16("KERNEL"), (LPCSTR)332 )); return thhook; } static GLOBALARENA *get_global_arena(void) { return *(GLOBALARENA **)get_thhook(); } static LOCALHEAPINFO *get_local_heap( HANDLE16 ds ) { INSTANCEDATA *ptr = MapSL( MAKESEGPTR( ds, 0 )); if (!ptr || !ptr->heap) return NULL; return (LOCALHEAPINFO*)((char*)ptr + ptr->heap); } /*********************************************************************** * GlobalHandleToSel (TOOLHELP.50) */ WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle ) { if (!handle) return 0; if (!(handle & 7)) return handle - 1; return handle | 7; } /*********************************************************************** * GlobalFirst (TOOLHELP.51) */ BOOL16 WINAPI GlobalFirst16( GLOBALENTRY *pGlobal, WORD wFlags ) { if (wFlags == GLOBAL_LRU) return FALSE; pGlobal->dwNext = 0; return GlobalNext16( pGlobal, wFlags ); } /*********************************************************************** * GlobalNext (TOOLHELP.52) */ BOOL16 WINAPI GlobalNext16( GLOBALENTRY *pGlobal, WORD wFlags) { GLOBALARENA *pGlobalArena = get_global_arena(); GLOBALARENA *pArena; if (pGlobal->dwNext >= GLOBAL_MAX_COUNT) return FALSE; pArena = pGlobalArena + pGlobal->dwNext; if (wFlags == GLOBAL_FREE) /* only free blocks */ { int i; for (i = pGlobal->dwNext; i < GLOBAL_MAX_COUNT; i++, pArena++) if (pArena->size == 0) break; /* block is free */ if (i >= GLOBAL_MAX_COUNT) return FALSE; pGlobal->dwNext = i; } pGlobal->dwAddress = (DWORD_PTR)pArena->base; pGlobal->dwBlockSize = pArena->size; pGlobal->hBlock = pArena->handle; pGlobal->wcLock = pArena->lockCount; pGlobal->wcPageLock = pArena->pageLockCount; pGlobal->wFlags = (GetCurrentPDB16() == pArena->hOwner); pGlobal->wHeapPresent = FALSE; pGlobal->hOwner = pArena->hOwner; pGlobal->wType = GT_UNKNOWN; pGlobal->wData = 0; pGlobal->dwNext++; return TRUE; } /*********************************************************************** * GlobalInfo (TOOLHELP.53) */ BOOL16 WINAPI GlobalInfo16( GLOBALINFO *pInfo ) { GLOBALARENA *pGlobalArena = get_global_arena(); GLOBALARENA *pArena; int i; pInfo->wcItems = GLOBAL_MAX_COUNT; pInfo->wcItemsFree = 0; pInfo->wcItemsLRU = 0; for (i = 0, pArena = pGlobalArena; i < GLOBAL_MAX_COUNT; i++, pArena++) if (pArena->size == 0) pInfo->wcItemsFree++; return TRUE; } /*********************************************************************** * GlobalEntryHandle (TOOLHELP.54) */ BOOL16 WINAPI GlobalEntryHandle16( GLOBALENTRY *pGlobal, HGLOBAL16 hItem ) { GLOBALARENA *pGlobalArena = get_global_arena(); GLOBALARENA *pArena = pGlobalArena + (hItem >> __AHSHIFT); pGlobal->dwAddress = (DWORD_PTR)pArena->base; pGlobal->dwBlockSize = pArena->size; pGlobal->hBlock = pArena->handle; pGlobal->wcLock = pArena->lockCount; pGlobal->wcPageLock = pArena->pageLockCount; pGlobal->wFlags = (GetCurrentPDB16() == pArena->hOwner); pGlobal->wHeapPresent = FALSE; pGlobal->hOwner = pArena->hOwner; pGlobal->wType = GT_UNKNOWN; pGlobal->wData = 0; pGlobal->dwNext++; return TRUE; } /*********************************************************************** * GlobalEntryModule (TOOLHELP.55) */ BOOL16 WINAPI GlobalEntryModule16( GLOBALENTRY *pGlobal, HMODULE16 hModule, WORD wSeg ) { FIXME("(%p, 0x%04x, 0x%04x), stub.\n", pGlobal, hModule, wSeg); return FALSE; } /*********************************************************************** * LocalInfo (TOOLHELP.56) */ BOOL16 WINAPI LocalInfo16( LOCALINFO *pLocalInfo, HGLOBAL16 handle ) { LOCALHEAPINFO *pInfo = get_local_heap( SELECTOROF(WOWGlobalLock16(handle)) ); if (!pInfo) return FALSE; pLocalInfo->wcItems = pInfo->items; return TRUE; } /*********************************************************************** * LocalFirst (TOOLHELP.57) */ BOOL16 WINAPI LocalFirst16( LOCALENTRY *pLocalEntry, HGLOBAL16 handle ) { WORD ds = GlobalHandleToSel16( handle ); char *ptr = MapSL( MAKESEGPTR( ds, 0 ) ); LOCALHEAPINFO *pInfo = get_local_heap( ds ); if (!pInfo) return FALSE; pLocalEntry->hHandle = pInfo->first + LOCAL_ARENA_HEADER_SIZE; pLocalEntry->wAddress = pLocalEntry->hHandle; pLocalEntry->wFlags = LF_FIXED; pLocalEntry->wcLock = 0; pLocalEntry->wType = LT_NORMAL; pLocalEntry->hHeap = handle; pLocalEntry->wHeapType = NORMAL_HEAP; pLocalEntry->wNext = LOCAL_ARENA_PTR(ptr,pInfo->first)->next; pLocalEntry->wSize = pLocalEntry->wNext - pLocalEntry->hHandle; return TRUE; } /*********************************************************************** * LocalNext (TOOLHELP.58) */ BOOL16 WINAPI LocalNext16( LOCALENTRY *pLocalEntry ) { WORD ds = GlobalHandleToSel16( pLocalEntry->hHeap ); char *ptr = MapSL( MAKESEGPTR( ds, 0 ) ); LOCALARENA *pArena; if (!get_local_heap( ds )) return FALSE; if (!pLocalEntry->wNext) return FALSE; pArena = LOCAL_ARENA_PTR( ptr, pLocalEntry->wNext ); pLocalEntry->hHandle = pLocalEntry->wNext + LOCAL_ARENA_HEADER_SIZE; pLocalEntry->wAddress = pLocalEntry->hHandle; pLocalEntry->wFlags = (pArena->prev & 3) + 1; pLocalEntry->wcLock = 0; pLocalEntry->wType = LT_NORMAL; if (pArena->next != pLocalEntry->wNext) /* last one? */ pLocalEntry->wNext = pArena->next; else pLocalEntry->wNext = 0; pLocalEntry->wSize = pLocalEntry->wNext - pLocalEntry->hHandle; return TRUE; } /********************************************************************** * ModuleFirst (TOOLHELP.59) */ BOOL16 WINAPI ModuleFirst16( MODULEENTRY *lpme ) { lpme->wNext = get_thhook()->hExeHead; return ModuleNext16( lpme ); } /********************************************************************** * ModuleNext (TOOLHELP.60) */ BOOL16 WINAPI ModuleNext16( MODULEENTRY *lpme ) { NE_MODULE *pModule; char *name; if (!lpme->wNext) return FALSE; if (!(pModule = GlobalLock16( GetExePtr(lpme->wNext) ))) return FALSE; name = (char *)pModule + pModule->ne_restab; memcpy( lpme->szModule, name + 1, min(*name, MAX_MODULE_NAME) ); lpme->szModule[min(*name, MAX_MODULE_NAME)] = '\0'; lpme->hModule = lpme->wNext; lpme->wcUsage = pModule->count; name = ((OFSTRUCT *)((char*)pModule + pModule->fileinfo))->szPathName; lstrcpynA( lpme->szExePath, name, sizeof(lpme->szExePath) ); lpme->wNext = pModule->next; return TRUE; } /********************************************************************** * ModuleFindName (TOOLHELP.61) */ BOOL16 WINAPI ModuleFindName16( MODULEENTRY *lpme, LPCSTR name ) { lpme->wNext = GetModuleHandle16( name ); return ModuleNext16( lpme ); } /********************************************************************** * ModuleFindHandle (TOOLHELP.62) */ BOOL16 WINAPI ModuleFindHandle16( MODULEENTRY *lpme, HMODULE16 hModule ) { hModule = GetExePtr( hModule ); lpme->wNext = hModule; return ModuleNext16( lpme ); } /*********************************************************************** * TaskFirst (TOOLHELP.63) */ BOOL16 WINAPI TaskFirst16( TASKENTRY *lpte ) { lpte->hNext = get_thhook()->HeadTDB; return TaskNext16( lpte ); } /*********************************************************************** * TaskNext (TOOLHELP.64) */ BOOL16 WINAPI TaskNext16( TASKENTRY *lpte ) { TDB *pTask; INSTANCEDATA *pInstData; TRACE_(toolhelp)("(%p): task=%04x\n", lpte, lpte->hNext ); if (!lpte->hNext) return FALSE; /* make sure that task and hInstance are valid (skip initial Wine task !) */ while (1) { pTask = GlobalLock16( lpte->hNext ); if (!pTask || pTask->magic != TDB_MAGIC) return FALSE; if (pTask->hInstance) break; lpte->hNext = pTask->hNext; } pInstData = MapSL( MAKESEGPTR( GlobalHandleToSel16(pTask->hInstance), 0 ) ); lpte->hTask = lpte->hNext; lpte->hTaskParent = pTask->hParent; lpte->hInst = pTask->hInstance; lpte->hModule = pTask->hModule; lpte->wSS = SELECTOROF( pTask->teb->WOW32Reserved ); lpte->wSP = OFFSETOF( pTask->teb->WOW32Reserved ); lpte->wStackTop = pInstData->stacktop; lpte->wStackMinimum = pInstData->stackmin; lpte->wStackBottom = pInstData->stackbottom; lpte->wcEvents = pTask->nEvents; lpte->hQueue = pTask->hQueue; lstrcpynA( lpte->szModule, pTask->module_name, sizeof(lpte->szModule) ); lpte->wPSPOffset = 0x100; /*??*/ lpte->hNext = pTask->hNext; return TRUE; } /*********************************************************************** * TaskFindHandle (TOOLHELP.65) */ BOOL16 WINAPI TaskFindHandle16( TASKENTRY *lpte, HTASK16 hTask ) { lpte->hNext = hTask; return TaskNext16( lpte ); } /*********************************************************************** * MemManInfo (TOOLHELP.72) */ BOOL16 WINAPI MemManInfo16( MEMMANINFO *info ) { MEMORYSTATUS status; /* * Not unsurprisingly although the documentation says you * _must_ provide the size in the dwSize field, this function * (under Windows) always fills the structure and returns true. */ 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; return TRUE; } /*********************************************************************** * NotifyRegister (TOOLHELP.73) */ BOOL16 WINAPI NotifyRegister16( HTASK16 htask, FARPROC16 lpfnCallback, WORD wFlags ) { int i; FIXME("(%x,%x,%x), semi-stub.\n", htask, (DWORD)lpfnCallback, wFlags ); if (!htask) htask = GetCurrentTask(); for (i=0;i<nrofnotifys;i++) if (notifys[i].htask==htask) break; if (i==nrofnotifys) { if (notifys==NULL) notifys=HeapAlloc( GetProcessHeap(), 0, sizeof(struct notify) ); else notifys=HeapReAlloc( GetProcessHeap(), 0, notifys, sizeof(struct notify)*(nrofnotifys+1)); if (!notifys) return FALSE; nrofnotifys++; } notifys[i].htask=htask; notifys[i].lpfnCallback=lpfnCallback; notifys[i].wFlags=wFlags; return TRUE; } /*********************************************************************** * NotifyUnregister (TOOLHELP.74) */ BOOL16 WINAPI NotifyUnregister16( HTASK16 htask ) { int i; FIXME("(%x), semi-stub.\n", htask ); if (!htask) htask = GetCurrentTask(); for (i=nrofnotifys;i--;) if (notifys[i].htask==htask) break; if (i==-1) return FALSE; memcpy(notifys+i,notifys+(i+1),sizeof(struct notify)*(nrofnotifys-i-1)); notifys=HeapReAlloc( GetProcessHeap(), 0, notifys, (nrofnotifys-1)*sizeof(struct notify)); nrofnotifys--; return TRUE; } /*********************************************************************** * StackTraceCSIPFirst (TOOLHELP.67) */ BOOL16 WINAPI StackTraceCSIPFirst16(STACKTRACEENTRY *ste, WORD wSS, WORD wCS, WORD wIP, WORD wBP) { FIXME("(%p, ss %04x, cs %04x, ip %04x, bp %04x): stub.\n", ste, wSS, wCS, wIP, wBP); return TRUE; } /*********************************************************************** * StackTraceFirst (TOOLHELP.66) */ BOOL16 WINAPI StackTraceFirst16(STACKTRACEENTRY *ste, HTASK16 Task) { FIXME("(%p, %04x), stub.\n", ste, Task); return TRUE; } /*********************************************************************** * StackTraceNext (TOOLHELP.68) */ BOOL16 WINAPI StackTraceNext16(STACKTRACEENTRY *ste) { FIXME("(%p), stub.\n", ste); return TRUE; } /*********************************************************************** * InterruptRegister (TOOLHELP.75) */ BOOL16 WINAPI InterruptRegister16( HTASK16 task, FARPROC callback ) { FIXME("(%04x, %p), stub.\n", task, callback); return TRUE; } /*********************************************************************** * InterruptUnRegister (TOOLHELP.76) */ BOOL16 WINAPI InterruptUnRegister16( HTASK16 task ) { FIXME("(%04x), stub.\n", task); return TRUE; } /*********************************************************************** * TerminateApp (TOOLHELP.77) * * See "Undocumented Windows". */ void WINAPI TerminateApp16(HTASK16 hTask, WORD wFlags) { if (hTask && hTask != GetCurrentTask()) { FIXME("cannot terminate task %x\n", hTask); return; } #if 0 /* FIXME */ /* check undocumented flag */ if (!(wFlags & 0x8000)) TASK_CallTaskSignalProc( USIG16_TERMINATION, hTask ); #endif /* UndocWin says to call int 0x21/0x4c exit=0xff here, but let's just call ExitThread */ ExitThread(0xff); } /*********************************************************************** * MemoryRead (TOOLHELP.78) */ DWORD WINAPI MemoryRead16( WORD sel, DWORD offset, void *buffer, DWORD count ) { LDT_ENTRY entry; DWORD limit; wine_ldt_get_entry( sel, &entry ); if (wine_ldt_is_empty( &entry )) return 0; limit = wine_ldt_get_limit( &entry ); if (offset > limit) return 0; if (offset + count > limit + 1) count = limit + 1 - offset; memcpy( buffer, (char *)wine_ldt_get_base(&entry) + offset, count ); return count; } /*********************************************************************** * MemoryWrite (TOOLHELP.79) */ DWORD WINAPI MemoryWrite16( WORD sel, DWORD offset, void *buffer, DWORD count ) { LDT_ENTRY entry; DWORD limit; wine_ldt_get_entry( sel, &entry ); if (wine_ldt_is_empty( &entry )) return 0; limit = wine_ldt_get_limit( &entry ); if (offset > limit) return 0; if (offset + count > limit) count = limit + 1 - offset; memcpy( (char *)wine_ldt_get_base(&entry) + offset, buffer, count ); return count; } /*********************************************************************** * TimerCount (TOOLHELP.80) */ BOOL16 WINAPI TimerCount16( TIMERINFO *pTimerInfo ) { /* FIXME * In standard mode, dwmsSinceStart = dwmsThisVM * * I tested this, under Windows in enhanced mode, and * if you never switch VM (ie start/stop DOS) these * values should be the same as well. * * Also, Wine should adjust for the hardware timer * to reduce the amount of error to ~1ms. * I can't be bothered, can you? */ pTimerInfo->dwmsSinceStart = pTimerInfo->dwmsThisVM = GetTickCount(); return TRUE; } /*********************************************************************** * SystemHeapInfo (TOOLHELP.71) */ BOOL16 WINAPI SystemHeapInfo16( SYSHEAPINFO *pHeapInfo ) { STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved); HANDLE16 oldDS = stack16->ds; WORD user = LoadLibrary16( "USER.EXE" ); WORD gdi = LoadLibrary16( "GDI.EXE" ); stack16->ds = user; pHeapInfo->wUserFreePercent = (int)LocalCountFree16() * 100 / LocalHeapSize16(); stack16->ds = gdi; pHeapInfo->wGDIFreePercent = (int)LocalCountFree16() * 100 / LocalHeapSize16(); stack16->ds = oldDS; pHeapInfo->hUserSegment = user; pHeapInfo->hGDISegment = gdi; FreeLibrary16( user ); FreeLibrary16( gdi ); return TRUE; } /*********************************************************************** * Local32Info (TOOLHELP.84) */ BOOL16 WINAPI Local32Info16( LOCAL32INFO *pLocal32Info, HGLOBAL16 handle ) { FIXME( "Call Local32Info16 in kernel\n" ); return FALSE; } /*********************************************************************** * Local32First (TOOLHELP.85) */ BOOL16 WINAPI Local32First16( LOCAL32ENTRY *pLocal32Entry, HGLOBAL16 handle ) { FIXME( "Call Local32First16 in kernel\n" ); return FALSE; } /*********************************************************************** * Local32Next (TOOLHELP.86) */ BOOL16 WINAPI Local32Next16( LOCAL32ENTRY *pLocal32Entry ) { FIXME( "Call Local32Next16 in kernel\n" ); return FALSE; }