?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
psapi: Implement semi-stub for K32EnumProcessModulesEx.
[wine.git] / dlls / toolhelp.dll16 / toolhelp.c
blob4fa1500e5ec5e6914d905ba2024dbc95157597a3
1 /*
2 * Toolhelp functions
3 *
4 * Copyright 1996 Marcus Meissner
5 * Copyright 2009 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <ctype.h>
33 #include <assert.h>
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winternl.h"
37 #include "wownt32.h"
38
39 #include "wine/winbase16.h"
40 #include "toolhelp.h"
41 #include "wine/debug.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(toolhelp);
44
45 #include "pshpack1.h"
46
47 typedef struct
48 {
49 void *base; /* Base address (0 if discarded) */
50 DWORD size; /* Size in bytes (0 indicates a free block) */
51 HGLOBAL16 handle; /* Handle for this block */
52 HGLOBAL16 hOwner; /* Owner of this block */
53 BYTE lockCount; /* Count of GlobalFix() calls */
54 BYTE pageLockCount; /* Count of GlobalPageLock() calls */
55 BYTE flags; /* Allocation flags */
56 BYTE selCount; /* Number of selectors allocated for this block */
57 } GLOBALARENA;
58
59 #define GLOBAL_MAX_COUNT 8192 /* Max number of allocated blocks */
60
61 typedef struct
62 {
63 WORD check; /* 00 Heap checking flag */
64 WORD freeze; /* 02 Heap frozen flag */
65 WORD items; /* 04 Count of items on the heap */
66 WORD first; /* 06 First item of the heap */
67 WORD pad1; /* 08 Always 0 */
68 WORD last; /* 0a Last item of the heap */
69 WORD pad2; /* 0c Always 0 */
70 BYTE ncompact; /* 0e Compactions counter */
71 BYTE dislevel; /* 0f Discard level */
72 DWORD distotal; /* 10 Total bytes discarded */
73 WORD htable; /* 14 Pointer to handle table */
74 WORD hfree; /* 16 Pointer to free handle table */
75 WORD hdelta; /* 18 Delta to expand the handle table */
76 WORD expand; /* 1a Pointer to expand function (unused) */
77 WORD pstat; /* 1c Pointer to status structure (unused) */
78 FARPROC16 notify; /* 1e Pointer to LocalNotify() function */
79 WORD lock; /* 22 Lock count for the heap */
80 WORD extra; /* 24 Extra bytes to allocate when expanding */
81 WORD minsize; /* 26 Minimum size of the heap */
82 WORD magic; /* 28 Magic number */
83 } LOCALHEAPINFO;
84
85 typedef struct
86 {
87 /* Arena header */
88 WORD prev; /* Previous arena | arena type */
89 WORD next; /* Next arena */
90 /* Start of the memory block or free-list info */
91 WORD size; /* Size of the free block */
92 WORD free_prev; /* Previous free block */
93 WORD free_next; /* Next free block */
94 } LOCALARENA;
95
96 #define LOCAL_ARENA_HEADER_SIZE 4
97 #define LOCAL_ARENA_HEADER( handle) ((handle) - LOCAL_ARENA_HEADER_SIZE)
98 #define LOCAL_ARENA_PTR(ptr,arena) ((LOCALARENA *)((char *)(ptr)+(arena)))
99
100 typedef struct
101 {
102 WORD null; /* Always 0 */
103 DWORD old_ss_sp; /* Stack pointer; used by SwitchTaskTo() */
104 WORD heap; /* Pointer to the local heap information (if any) */
105 WORD atomtable; /* Pointer to the local atom table (if any) */
106 WORD stacktop; /* Top of the stack */
107 WORD stackmin; /* Lowest stack address used so far */
108 WORD stackbottom; /* Bottom of the stack */
109 } INSTANCEDATA;
110
111 typedef struct _THHOOK
112 {
113 HANDLE16 hGlobalHeap; /* 00 (handle BURGERMASTER) */
114 WORD pGlobalHeap; /* 02 (selector BURGERMASTER) */
115 HMODULE16 hExeHead; /* 04 hFirstModule */
116 HMODULE16 hExeSweep; /* 06 (unused) */
117 HANDLE16 TopPDB; /* 08 (handle of KERNEL PDB) */
118 HANDLE16 HeadPDB; /* 0A (first PDB in list) */
119 HANDLE16 TopSizePDB; /* 0C (unused) */
120 HTASK16 HeadTDB; /* 0E hFirstTask */
121 HTASK16 CurTDB; /* 10 hCurrentTask */
122 HTASK16 LoadTDB; /* 12 (unused) */
123 HTASK16 LockTDB; /* 14 hLockedTask */
124 } THHOOK;
125
126 typedef struct _NE_MODULE
127 {
128 WORD ne_magic; /* 00 'NE' signature */
129 WORD count; /* 02 Usage count (ne_ver/ne_rev on disk) */
130 WORD ne_enttab; /* 04 Near ptr to entry table */
131 HMODULE16 next; /* 06 Selector to next module (ne_cbenttab on disk) */
132 WORD dgroup_entry; /* 08 Near ptr to segment entry for DGROUP (ne_crc on disk) */
133 WORD fileinfo; /* 0a Near ptr to file info (OFSTRUCT) (ne_crc on disk) */
134 WORD ne_flags; /* 0c Module flags */
135 WORD ne_autodata; /* 0e Logical segment for DGROUP */
136 WORD ne_heap; /* 10 Initial heap size */
137 WORD ne_stack; /* 12 Initial stack size */
138 DWORD ne_csip; /* 14 Initial cs:ip */
139 DWORD ne_sssp; /* 18 Initial ss:sp */
140 WORD ne_cseg; /* 1c Number of segments in segment table */
141 WORD ne_cmod; /* 1e Number of module references */
142 WORD ne_cbnrestab; /* 20 Size of non-resident names table */
143 WORD ne_segtab; /* 22 Near ptr to segment table */
144 WORD ne_rsrctab; /* 24 Near ptr to resource table */
145 WORD ne_restab; /* 26 Near ptr to resident names table */
146 WORD ne_modtab; /* 28 Near ptr to module reference table */
147 WORD ne_imptab; /* 2a Near ptr to imported names table */
148 DWORD ne_nrestab; /* 2c File offset of non-resident names table */
149 WORD ne_cmovent; /* 30 Number of moveable entries in entry table*/
150 WORD ne_align; /* 32 Alignment shift count */
151 WORD ne_cres; /* 34 # of resource segments */
152 BYTE ne_exetyp; /* 36 Operating system flags */
153 BYTE ne_flagsothers; /* 37 Misc. flags */
154 HANDLE16 dlls_to_init; /* 38 List of DLLs to initialize (ne_pretthunks on disk) */
155 HANDLE16 nrname_handle; /* 3a Handle to non-resident name table (ne_psegrefbytes on disk) */
156 WORD ne_swaparea; /* 3c Min. swap area size */
157 WORD ne_expver; /* 3e Expected Windows version */
158 /* From here, these are extra fields not present in normal Windows */
159 HMODULE module32; /* PE module handle for Win32 modules */
160 HMODULE owner32; /* PE module containing this one for 16-bit builtins */
161 HMODULE16 self; /* Handle for this module */
162 WORD self_loading_sel; /* Selector used for self-loading apps. */
163 LPVOID rsrc32_map; /* HRSRC 16->32 map (for 32-bit modules) */
164 LPCVOID mapping; /* mapping of the binary file */
165 SIZE_T mapping_size; /* size of the file mapping */
166 } NE_MODULE;
167
168 #include "poppack.h"
169
170 #define TDB_MAGIC ('T' | ('D' << 8))
171
172 /* FIXME: to make this work, we have to call back all these registered
173 * functions from all over the WINE code. Someone with more knowledge than
174 * me please do that. -Marcus
175 */
176
177 static struct notify
178 {
179 HTASK16 htask;
180 FARPROC16 lpfnCallback;
181 WORD wFlags;
182 } *notifys = NULL;
183
184 static int nrofnotifys = 0;
185
186 static THHOOK *get_thhook(void)
187 {
188 static THHOOK *thhook;
189
190 if (!thhook) thhook = MapSL( (SEGPTR)GetProcAddress16( GetModuleHandle16("KERNEL"), (LPCSTR)332 ));
191 return thhook;
192 }
193
194 static GLOBALARENA *get_global_arena(void)
195 {
196 return *(GLOBALARENA **)get_thhook();
197 }
198
199 static LOCALHEAPINFO *get_local_heap( HANDLE16 ds )
200 {
201 INSTANCEDATA *ptr = MapSL( MAKESEGPTR( ds, 0 ));
202
203 if (!ptr || !ptr->heap) return NULL;
204 return (LOCALHEAPINFO*)((char*)ptr + ptr->heap);
205 }
206
207
208 /***********************************************************************
209 * GlobalHandleToSel (TOOLHELP.50)
210 */
211 WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
212 {
213 if (!handle) return 0;
214 if (!(handle & 7)) return handle - 1;
215 return handle | 7;
216 }
217
218
219 /***********************************************************************
220 * GlobalFirst (TOOLHELP.51)
221 */
222 BOOL16 WINAPI GlobalFirst16( GLOBALENTRY *pGlobal, WORD wFlags )
223 {
224 if (wFlags == GLOBAL_LRU) return FALSE;
225 pGlobal->dwNext = 0;
226 return GlobalNext16( pGlobal, wFlags );
227 }
228
229
230 /***********************************************************************
231 * GlobalNext (TOOLHELP.52)
232 */
233 BOOL16 WINAPI GlobalNext16( GLOBALENTRY *pGlobal, WORD wFlags)
234 {
235 GLOBALARENA *pGlobalArena = get_global_arena();
236 GLOBALARENA *pArena;
237
238 if (pGlobal->dwNext >= GLOBAL_MAX_COUNT) return FALSE;
239 pArena = pGlobalArena + pGlobal->dwNext;
240 if (wFlags == GLOBAL_FREE) /* only free blocks */
241 {
242 int i;
243 for (i = pGlobal->dwNext; i < GLOBAL_MAX_COUNT; i++, pArena++)
244 if (pArena->size == 0) break; /* block is free */
245 if (i >= GLOBAL_MAX_COUNT) return FALSE;
246 pGlobal->dwNext = i;
247 }
248
249 pGlobal->dwAddress = (DWORD_PTR)pArena->base;
250 pGlobal->dwBlockSize = pArena->size;
251 pGlobal->hBlock = pArena->handle;
252 pGlobal->wcLock = pArena->lockCount;
253 pGlobal->wcPageLock = pArena->pageLockCount;
254 pGlobal->wFlags = (GetCurrentPDB16() == pArena->hOwner);
255 pGlobal->wHeapPresent = FALSE;
256 pGlobal->hOwner = pArena->hOwner;
257 pGlobal->wType = GT_UNKNOWN;
258 pGlobal->wData = 0;
259 pGlobal->dwNext++;
260 return TRUE;
261 }
262
263
264 /***********************************************************************
265 * GlobalInfo (TOOLHELP.53)
266 */
267 BOOL16 WINAPI GlobalInfo16( GLOBALINFO *pInfo )
268 {
269 GLOBALARENA *pGlobalArena = get_global_arena();
270 GLOBALARENA *pArena;
271 int i;
272
273 pInfo->wcItems = GLOBAL_MAX_COUNT;
274 pInfo->wcItemsFree = 0;
275 pInfo->wcItemsLRU = 0;
276 for (i = 0, pArena = pGlobalArena; i < GLOBAL_MAX_COUNT; i++, pArena++)
277 if (pArena->size == 0) pInfo->wcItemsFree++;
278 return TRUE;
279 }
280
281
282 /***********************************************************************
283 * GlobalEntryHandle (TOOLHELP.54)
284 */
285 BOOL16 WINAPI GlobalEntryHandle16( GLOBALENTRY *pGlobal, HGLOBAL16 hItem )
286 {
287 GLOBALARENA *pGlobalArena = get_global_arena();
288 GLOBALARENA *pArena = pGlobalArena + (hItem >> __AHSHIFT);
289
290 pGlobal->dwAddress = (DWORD_PTR)pArena->base;
291 pGlobal->dwBlockSize = pArena->size;
292 pGlobal->hBlock = pArena->handle;
293 pGlobal->wcLock = pArena->lockCount;
294 pGlobal->wcPageLock = pArena->pageLockCount;
295 pGlobal->wFlags = (GetCurrentPDB16() == pArena->hOwner);
296 pGlobal->wHeapPresent = FALSE;
297 pGlobal->hOwner = pArena->hOwner;
298 pGlobal->wType = GT_UNKNOWN;
299 pGlobal->wData = 0;
300 pGlobal->dwNext++;
301 return TRUE;
302 }
303
304
305 /***********************************************************************
306 * GlobalEntryModule (TOOLHELP.55)
307 */
308 BOOL16 WINAPI GlobalEntryModule16( GLOBALENTRY *pGlobal, HMODULE16 hModule,
309 WORD wSeg )
310 {
311 FIXME("(%p, 0x%04x, 0x%04x), stub.\n", pGlobal, hModule, wSeg);
312 return FALSE;
313 }
314
315
316 /***********************************************************************
317 * LocalInfo (TOOLHELP.56)
318 */
319 BOOL16 WINAPI LocalInfo16( LOCALINFO *pLocalInfo, HGLOBAL16 handle )
320 {
321 LOCALHEAPINFO *pInfo = get_local_heap( SELECTOROF(WOWGlobalLock16(handle)) );
322 if (!pInfo) return FALSE;
323 pLocalInfo->wcItems = pInfo->items;
324 return TRUE;
325 }
326
327
328 /***********************************************************************
329 * LocalFirst (TOOLHELP.57)
330 */
331 BOOL16 WINAPI LocalFirst16( LOCALENTRY *pLocalEntry, HGLOBAL16 handle )
332 {
333 WORD ds = GlobalHandleToSel16( handle );
334 char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
335 LOCALHEAPINFO *pInfo = get_local_heap( ds );
336 if (!pInfo) return FALSE;
337
338 pLocalEntry->hHandle = pInfo->first + LOCAL_ARENA_HEADER_SIZE;
339 pLocalEntry->wAddress = pLocalEntry->hHandle;
340 pLocalEntry->wFlags = LF_FIXED;
341 pLocalEntry->wcLock = 0;
342 pLocalEntry->wType = LT_NORMAL;
343 pLocalEntry->hHeap = handle;
344 pLocalEntry->wHeapType = NORMAL_HEAP;
345 pLocalEntry->wNext = LOCAL_ARENA_PTR(ptr,pInfo->first)->next;
346 pLocalEntry->wSize = pLocalEntry->wNext - pLocalEntry->hHandle;
347 return TRUE;
348 }
349
350
351 /***********************************************************************
352 * LocalNext (TOOLHELP.58)
353 */
354 BOOL16 WINAPI LocalNext16( LOCALENTRY *pLocalEntry )
355 {
356 WORD ds = GlobalHandleToSel16( pLocalEntry->hHeap );
357 char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
358 LOCALARENA *pArena;
359
360 if (!get_local_heap( ds )) return FALSE;
361 if (!pLocalEntry->wNext) return FALSE;
362 pArena = LOCAL_ARENA_PTR( ptr, pLocalEntry->wNext );
363
364 pLocalEntry->hHandle = pLocalEntry->wNext + LOCAL_ARENA_HEADER_SIZE;
365 pLocalEntry->wAddress = pLocalEntry->hHandle;
366 pLocalEntry->wFlags = (pArena->prev & 3) + 1;
367 pLocalEntry->wcLock = 0;
368 pLocalEntry->wType = LT_NORMAL;
369 if (pArena->next != pLocalEntry->wNext) /* last one? */
370 pLocalEntry->wNext = pArena->next;
371 else
372 pLocalEntry->wNext = 0;
373 pLocalEntry->wSize = pLocalEntry->wNext - pLocalEntry->hHandle;
374 return TRUE;
375 }
376
377
378 /**********************************************************************
379 * ModuleFirst (TOOLHELP.59)
380 */
381 BOOL16 WINAPI ModuleFirst16( MODULEENTRY *lpme )
382 {
383 lpme->wNext = get_thhook()->hExeHead;
384 return ModuleNext16( lpme );
385 }
386
387
388 /**********************************************************************
389 * ModuleNext (TOOLHELP.60)
390 */
391 BOOL16 WINAPI ModuleNext16( MODULEENTRY *lpme )
392 {
393 NE_MODULE *pModule;
394 char *name;
395
396 if (!lpme->wNext) return FALSE;
397 if (!(pModule = GlobalLock16( GetExePtr(lpme->wNext) ))) return FALSE;
398 name = (char *)pModule + pModule->ne_restab;
399 memcpy( lpme->szModule, name + 1, min(*name, MAX_MODULE_NAME) );
400 lpme->szModule[min(*name, MAX_MODULE_NAME)] = '\0';
401 lpme->hModule = lpme->wNext;
402 lpme->wcUsage = pModule->count;
403 name = ((OFSTRUCT *)((char*)pModule + pModule->fileinfo))->szPathName;
404 lstrcpynA( lpme->szExePath, name, sizeof(lpme->szExePath) );
405 lpme->wNext = pModule->next;
406 return TRUE;
407 }
408
409
410 /**********************************************************************
411 * ModuleFindName (TOOLHELP.61)
412 */
413 BOOL16 WINAPI ModuleFindName16( MODULEENTRY *lpme, LPCSTR name )
414 {
415 lpme->wNext = GetModuleHandle16( name );
416 return ModuleNext16( lpme );
417 }
418
419
420 /**********************************************************************
421 * ModuleFindHandle (TOOLHELP.62)
422 */
423 BOOL16 WINAPI ModuleFindHandle16( MODULEENTRY *lpme, HMODULE16 hModule )
424 {
425 hModule = GetExePtr( hModule );
426 lpme->wNext = hModule;
427 return ModuleNext16( lpme );
428 }
429
430
431 /***********************************************************************
432 * TaskFirst (TOOLHELP.63)
433 */
434 BOOL16 WINAPI TaskFirst16( TASKENTRY *lpte )
435 {
436 lpte->hNext = get_thhook()->HeadTDB;
437 return TaskNext16( lpte );
438 }
439
440
441 /***********************************************************************
442 * TaskNext (TOOLHELP.64)
443 */
444 BOOL16 WINAPI TaskNext16( TASKENTRY *lpte )
445 {
446 TDB *pTask;
447 INSTANCEDATA *pInstData;
448
449 TRACE_(toolhelp)("(%p): task=%04x\n", lpte, lpte->hNext );
450 if (!lpte->hNext) return FALSE;
451
452 /* make sure that task and hInstance are valid (skip initial Wine task !) */
453 while (1) {
454 pTask = GlobalLock16( lpte->hNext );
455 if (!pTask || pTask->magic != TDB_MAGIC) return FALSE;
456 if (pTask->hInstance)
457 break;
458 lpte->hNext = pTask->hNext;
459 }
460 pInstData = MapSL( MAKESEGPTR( GlobalHandleToSel16(pTask->hInstance), 0 ) );
461 lpte->hTask = lpte->hNext;
462 lpte->hTaskParent = pTask->hParent;
463 lpte->hInst = pTask->hInstance;
464 lpte->hModule = pTask->hModule;
465 lpte->wSS = SELECTOROF( pTask->teb->WOW32Reserved );
466 lpte->wSP = OFFSETOF( pTask->teb->WOW32Reserved );
467 lpte->wStackTop = pInstData->stacktop;
468 lpte->wStackMinimum = pInstData->stackmin;
469 lpte->wStackBottom = pInstData->stackbottom;
470 lpte->wcEvents = pTask->nEvents;
471 lpte->hQueue = pTask->hQueue;
472 lstrcpynA( lpte->szModule, pTask->module_name, sizeof(lpte->szModule) );
473 lpte->wPSPOffset = 0x100; /*??*/
474 lpte->hNext = pTask->hNext;
475 return TRUE;
476 }
477
478
479 /***********************************************************************
480 * TaskFindHandle (TOOLHELP.65)
481 */
482 BOOL16 WINAPI TaskFindHandle16( TASKENTRY *lpte, HTASK16 hTask )
483 {
484 lpte->hNext = hTask;
485 return TaskNext16( lpte );
486 }
487
488
489 /***********************************************************************
490 * MemManInfo (TOOLHELP.72)
491 */
492 BOOL16 WINAPI MemManInfo16( MEMMANINFO *info )
493 {
494 SYSTEM_BASIC_INFORMATION sbi;
495 MEMORYSTATUS status;
496
497 /*
498 * Not unsurprisingly although the documentation says you
499 * _must_ provide the size in the dwSize field, this function
500 * (under Windows) always fills the structure and returns true.
501 */
502 NtQuerySystemInformation( SystemBasicInformation, &sbi, sizeof(sbi), NULL );
503 GlobalMemoryStatus( &status );
504 info->wPageSize = sbi.PageSize;
505 info->dwLargestFreeBlock = status.dwAvailVirtual;
506 info->dwMaxPagesAvailable = info->dwLargestFreeBlock / info->wPageSize;
507 info->dwMaxPagesLockable = info->dwMaxPagesAvailable;
508 info->dwTotalLinearSpace = status.dwTotalVirtual / info->wPageSize;
509 info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
510 info->dwFreePages = info->dwMaxPagesAvailable;
511 info->dwTotalPages = info->dwTotalLinearSpace;
512 info->dwFreeLinearSpace = info->dwMaxPagesAvailable;
513 info->dwSwapFilePages = status.dwTotalPageFile / info->wPageSize;
514 return TRUE;
515 }
516
517
518 /***********************************************************************
519 * NotifyRegister (TOOLHELP.73)
520 */
521 BOOL16 WINAPI NotifyRegister16( HTASK16 htask, FARPROC16 lpfnCallback,
522 WORD wFlags )
523 {
524 int i;
525
526 FIXME("(%x,%x,%x), semi-stub.\n",
527 htask, (DWORD)lpfnCallback, wFlags );
528 if (!htask) htask = GetCurrentTask();
529 for (i=0;i<nrofnotifys;i++)
530 if (notifys[i].htask==htask)
531 break;
532 if (i==nrofnotifys) {
533 if (notifys==NULL)
534 notifys=HeapAlloc( GetProcessHeap(), 0,
535 sizeof(struct notify) );
536 else
537 notifys=HeapReAlloc( GetProcessHeap(), 0, notifys,
538 sizeof(struct notify)*(nrofnotifys+1));
539 if (!notifys) return FALSE;
540 nrofnotifys++;
541 }
542 notifys[i].htask=htask;
543 notifys[i].lpfnCallback=lpfnCallback;
544 notifys[i].wFlags=wFlags;
545 return TRUE;
546 }
547
548 /***********************************************************************
549 * NotifyUnregister (TOOLHELP.74)
550 */
551 BOOL16 WINAPI NotifyUnregister16( HTASK16 htask )
552 {
553 int i;
554
555 FIXME("(%x), semi-stub.\n", htask );
556 if (!htask) htask = GetCurrentTask();
557 for (i=nrofnotifys;i--;)
558 if (notifys[i].htask==htask)
559 break;
560 if (i==-1)
561 return FALSE;
562 memcpy(notifys+i,notifys+(i+1),sizeof(struct notify)*(nrofnotifys-i-1));
563 notifys=HeapReAlloc( GetProcessHeap(), 0, notifys,
564 (nrofnotifys-1)*sizeof(struct notify));
565 nrofnotifys--;
566 return TRUE;
567 }
568
569 /***********************************************************************
570 * StackTraceCSIPFirst (TOOLHELP.67)
571 */
572 BOOL16 WINAPI StackTraceCSIPFirst16(STACKTRACEENTRY *ste, WORD wSS, WORD wCS, WORD wIP, WORD wBP)
573 {
574 FIXME("(%p, ss %04x, cs %04x, ip %04x, bp %04x): stub.\n", ste, wSS, wCS, wIP, wBP);
575 return TRUE;
576 }
577
578 /***********************************************************************
579 * StackTraceFirst (TOOLHELP.66)
580 */
581 BOOL16 WINAPI StackTraceFirst16(STACKTRACEENTRY *ste, HTASK16 Task)
582 {
583 FIXME("(%p, %04x), stub.\n", ste, Task);
584 return TRUE;
585 }
586
587 /***********************************************************************
588 * StackTraceNext (TOOLHELP.68)
589 */
590 BOOL16 WINAPI StackTraceNext16(STACKTRACEENTRY *ste)
591 {
592 FIXME("(%p), stub.\n", ste);
593 return TRUE;
594 }
595
596 /***********************************************************************
597 * InterruptRegister (TOOLHELP.75)
598 */
599 BOOL16 WINAPI InterruptRegister16( HTASK16 task, FARPROC callback )
600 {
601 FIXME("(%04x, %p), stub.\n", task, callback);
602 return TRUE;
603 }
604
605 /***********************************************************************
606 * InterruptUnRegister (TOOLHELP.76)
607 */
608 BOOL16 WINAPI InterruptUnRegister16( HTASK16 task )
609 {
610 FIXME("(%04x), stub.\n", task);
611 return TRUE;
612 }
613
614 /***********************************************************************
615 * TerminateApp (TOOLHELP.77)
616 *
617 * See "Undocumented Windows".
618 */
619 void WINAPI TerminateApp16(HTASK16 hTask, WORD wFlags)
620 {
621 if (hTask && hTask != GetCurrentTask())
622 {
623 FIXME("cannot terminate task %x\n", hTask);
624 return;
625 }
626
627 #if 0 /* FIXME */
628 /* check undocumented flag */
629 if (!(wFlags & 0x8000))
630 TASK_CallTaskSignalProc( USIG16_TERMINATION, hTask );
631 #endif
632
633 /* UndocWin says to call int 0x21/0x4c exit=0xff here,
634 but let's just call ExitThread */
635 ExitThread(0xff);
636 }
637
638 /***********************************************************************
639 * MemoryRead (TOOLHELP.78)
640 */
641 DWORD WINAPI MemoryRead16( WORD sel, DWORD offset, void *buffer, DWORD count )
642 {
643 LDT_ENTRY entry;
644 DWORD limit;
645
646 wine_ldt_get_entry( sel, &entry );
647 if (wine_ldt_is_empty( &entry )) return 0;
648 limit = wine_ldt_get_limit( &entry );
649 if (offset > limit) return 0;
650 if (offset + count > limit + 1) count = limit + 1 - offset;
651 memcpy( buffer, (char *)wine_ldt_get_base(&entry) + offset, count );
652 return count;
653 }
654
655
656 /***********************************************************************
657 * MemoryWrite (TOOLHELP.79)
658 */
659 DWORD WINAPI MemoryWrite16( WORD sel, DWORD offset, void *buffer, DWORD count )
660 {
661 LDT_ENTRY entry;
662 DWORD limit;
663
664 wine_ldt_get_entry( sel, &entry );
665 if (wine_ldt_is_empty( &entry )) return 0;
666 limit = wine_ldt_get_limit( &entry );
667 if (offset > limit) return 0;
668 if (offset + count > limit) count = limit + 1 - offset;
669 memcpy( (char *)wine_ldt_get_base(&entry) + offset, buffer, count );
670 return count;
671 }
672
673 /***********************************************************************
674 * TimerCount (TOOLHELP.80)
675 */
676 BOOL16 WINAPI TimerCount16( TIMERINFO *pTimerInfo )
677 {
678 /* FIXME
679 * In standard mode, dwmsSinceStart = dwmsThisVM
680 *
681 * I tested this, under Windows in enhanced mode, and
682 * if you never switch VM (ie start/stop DOS) these
683 * values should be the same as well.
684 *
685 * Also, Wine should adjust for the hardware timer
686 * to reduce the amount of error to ~1ms.
687 * I can't be bothered, can you?
688 */
689 pTimerInfo->dwmsSinceStart = pTimerInfo->dwmsThisVM = GetTickCount();
690 return TRUE;
691 }
692
693 /***********************************************************************
694 * SystemHeapInfo (TOOLHELP.71)
695 */
696 BOOL16 WINAPI SystemHeapInfo16( SYSHEAPINFO *pHeapInfo )
697 {
698 STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
699 HANDLE16 oldDS = stack16->ds;
700 WORD user = LoadLibrary16( "USER.EXE" );
701 WORD gdi = LoadLibrary16( "GDI.EXE" );
702 stack16->ds = user;
703 pHeapInfo->wUserFreePercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
704 stack16->ds = gdi;
705 pHeapInfo->wGDIFreePercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
706 stack16->ds = oldDS;
707 pHeapInfo->hUserSegment = user;
708 pHeapInfo->hGDISegment = gdi;
709 FreeLibrary16( user );
710 FreeLibrary16( gdi );
711 return TRUE;
712 }
713
714 /***********************************************************************
715 * Local32Info (TOOLHELP.84)
716 */
717 BOOL16 WINAPI Local32Info16( LOCAL32INFO *pLocal32Info, HGLOBAL16 handle )
718 {
719 FIXME( "Call Local32Info16 in kernel\n" );
720 return FALSE;
721 }
722
723 /***********************************************************************
724 * Local32First (TOOLHELP.85)
725 */
726 BOOL16 WINAPI Local32First16( LOCAL32ENTRY *pLocal32Entry, HGLOBAL16 handle )
727 {
728 FIXME( "Call Local32First16 in kernel\n" );
729 return FALSE;
730 }
731
732 /***********************************************************************
733 * Local32Next (TOOLHELP.86)
734 */
735 BOOL16 WINAPI Local32Next16( LOCAL32ENTRY *pLocal32Entry )
736 {
737 FIXME( "Call Local32Next16 in kernel\n" );
738 return FALSE;
739 }
Windows API implementation