git.oblomov.eu Git - wine/blob - dlls/kernel/toolhelp.c

   1 /*
   2  * Misc Toolhelp functions
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #ifdef HAVE_UNISTD_H
  27 # include <unistd.h>
  28 #endif
  29 #include <ctype.h>
  30 #include <assert.h>
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wine/winbase16.h"
  34 #include "winerror.h"
  35 #include "local.h"
  36 #include "tlhelp32.h"
  37 #include "toolhelp.h"
  38 #include "wine/server.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(toolhelp);
  42
  43
  44 /* FIXME: to make this work, we have to call back all these registered
  45  * functions from all over the WINE code. Someone with more knowledge than
  46  * me please do that. -Marcus
  47  */
  48 static struct notify
  49 {
  50     HTASK16   htask;
  51     FARPROC16 lpfnCallback;
  52     WORD     wFlags;
  53 } *notifys = NULL;
  54
  55 static int nrofnotifys = 0;
  56
  57 static FARPROC16 HookNotify = NULL;
  58
  59 /***********************************************************************
  60  *              NotifyRegister (TOOLHELP.73)
  61  */
  62 BOOL16 WINAPI NotifyRegister16( HTASK16 htask, FARPROC16 lpfnCallback,
  63                               WORD wFlags )
  64 {
  65     int i;
  66
  67     FIXME("(%x,%lx,%x), semi-stub.\n",
  68                       htask, (DWORD)lpfnCallback, wFlags );
  69     if (!htask) htask = GetCurrentTask();
  70     for (i=0;i<nrofnotifys;i++)
  71         if (notifys[i].htask==htask)
  72             break;
  73     if (i==nrofnotifys) {
  74         if (notifys==NULL)
  75             notifys=(struct notify*)HeapAlloc( GetProcessHeap(), 0,
  76                                                sizeof(struct notify) );
  77         else
  78             notifys=(struct notify*)HeapReAlloc( GetProcessHeap(), 0, notifys,
  79                                         sizeof(struct notify)*(nrofnotifys+1));
  80         if (!notifys) return FALSE;
  81         nrofnotifys++;
  82     }
  83     notifys[i].htask=htask;
  84     notifys[i].lpfnCallback=lpfnCallback;
  85     notifys[i].wFlags=wFlags;
  86     return TRUE;
  87 }
  88
  89 /***********************************************************************
  90  *              NotifyUnregister (TOOLHELP.74)
  91  */
  92 BOOL16 WINAPI NotifyUnregister16( HTASK16 htask )
  93 {
  94     int i;
  95
  96     FIXME("(%x), semi-stub.\n", htask );
  97     if (!htask) htask = GetCurrentTask();
  98     for (i=nrofnotifys;i--;)
  99         if (notifys[i].htask==htask)
 100             break;
 101     if (i==-1)
 102         return FALSE;
 103     memcpy(notifys+i,notifys+(i+1),sizeof(struct notify)*(nrofnotifys-i-1));
 104     notifys=(struct notify*)HeapReAlloc( GetProcessHeap(), 0, notifys,
 105                                         (nrofnotifys-1)*sizeof(struct notify));
 106     nrofnotifys--;
 107     return TRUE;
 108 }
 109
 110 /***********************************************************************
 111  *              StackTraceCSIPFirst (TOOLHELP.67)
 112  */
 113 BOOL16 WINAPI StackTraceCSIPFirst16(STACKTRACEENTRY *ste, WORD wSS, WORD wCS, WORD wIP, WORD wBP)
 114 {
 115     FIXME("(%p, ss %04x, cs %04x, ip %04x, bp %04x): stub.\n", ste, wSS, wCS, wIP, wBP);
 116     return TRUE;
 117 }
 118
 119 /***********************************************************************
 120  *              StackTraceFirst (TOOLHELP.66)
 121  */
 122 BOOL16 WINAPI StackTraceFirst16(STACKTRACEENTRY *ste, HTASK16 Task)
 123 {
 124     FIXME("(%p, %04x), stub.\n", ste, Task);
 125     return TRUE;
 126 }
 127
 128 /***********************************************************************
 129  *              StackTraceNext (TOOLHELP.68)
 130  */
 131 BOOL16 WINAPI StackTraceNext16(STACKTRACEENTRY *ste)
 132 {
 133     FIXME("(%p), stub.\n", ste);
 134     return TRUE;
 135 }
 136
 137 /***********************************************************************
 138  *              InterruptRegister (TOOLHELP.75)
 139  */
 140 BOOL16 WINAPI InterruptRegister16( HTASK16 task, FARPROC callback )
 141 {
 142     FIXME("(%04x, %p), stub.\n", task, callback);
 143     return TRUE;
 144 }
 145
 146 /***********************************************************************
 147  *              InterruptUnRegister (TOOLHELP.76)
 148  */
 149 BOOL16 WINAPI InterruptUnRegister16( HTASK16 task )
 150 {
 151     FIXME("(%04x), stub.\n", task);
 152     return TRUE;
 153 }
 154
 155 /***********************************************************************
 156  *           TimerCount   (TOOLHELP.80)
 157  */
 158 BOOL16 WINAPI TimerCount16( TIMERINFO *pTimerInfo )
 159 {
 160     /* FIXME
 161      * In standard mode, dwmsSinceStart = dwmsThisVM
 162      *
 163      * I tested this, under Windows in enhanced mode, and
 164      * if you never switch VM (ie start/stop DOS) these
 165      * values should be the same as well.
 166      *
 167      * Also, Wine should adjust for the hardware timer
 168      * to reduce the amount of error to ~1ms.
 169      * I can't be bothered, can you?
 170      */
 171     pTimerInfo->dwmsSinceStart = pTimerInfo->dwmsThisVM = GetTickCount();
 172     return TRUE;
 173 }
 174
 175 /***********************************************************************
 176  *           SystemHeapInfo   (TOOLHELP.71)
 177  */
 178 BOOL16 WINAPI SystemHeapInfo16( SYSHEAPINFO *pHeapInfo )
 179 {
 180     WORD user = LoadLibrary16( "USER.EXE" );
 181     WORD gdi = LoadLibrary16( "GDI.EXE" );
 182     pHeapInfo->wUserFreePercent = (int)LOCAL_CountFree(user) * 100 / LOCAL_HeapSize(user);
 183     pHeapInfo->wGDIFreePercent  = (int)LOCAL_CountFree(gdi) * 100 / LOCAL_HeapSize(gdi);
 184     pHeapInfo->hUserSegment = user;
 185     pHeapInfo->hGDISegment  = gdi;
 186     FreeLibrary16( user );
 187     FreeLibrary16( gdi );
 188     return TRUE;
 189 }
 190
 191
 192 /***********************************************************************
 193  *           ToolHelpHook                             (KERNEL.341)
 194  *      see "Undocumented Windows"
 195  */
 196 FARPROC16 WINAPI ToolHelpHook16(FARPROC16 lpfnNotifyHandler)
 197 {
 198         FARPROC16 tmp;
 199
 200         FIXME("(%p), stub.\n", lpfnNotifyHandler);
 201         tmp = HookNotify;
 202         HookNotify = lpfnNotifyHandler;
 203         /* just return previously installed notification function */
 204         return tmp;
 205 }
 206
 207
 208 /***********************************************************************
 209  *           CreateToolhelp32Snapshot                   (KERNEL32.@)
 210  */
 211 HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
 212 {
 213     HANDLE ret;
 214
 215     TRACE("%lx,%lx\n", flags, process );
 216     if (!(flags & (TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)))
 217     {
 218         FIXME("flags %lx not implemented\n", flags );
 219         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 220         return INVALID_HANDLE_VALUE;
 221     }
 222
 223     /* Now do the snapshot */
 224     SERVER_START_REQ( create_snapshot )
 225     {
 226         req->flags = 0;
 227         if (flags & TH32CS_SNAPMODULE)   req->flags |= SNAP_MODULE;
 228         if (flags & TH32CS_SNAPPROCESS)  req->flags |= SNAP_PROCESS;
 229         if (flags & TH32CS_SNAPTHREAD)   req->flags |= SNAP_THREAD;
 230
 231         req->inherit = (flags & TH32CS_INHERIT) != 0;
 232         req->pid     = process;
 233         wine_server_call_err( req );
 234         ret = reply->handle;
 235     }
 236     SERVER_END_REQ;
 237     if (!ret) ret = INVALID_HANDLE_VALUE;
 238     return ret;
 239 }
 240
 241
 242 /***********************************************************************
 243  *              TOOLHELP_Thread32Next
 244  *
 245  * Implementation of Thread32First/Next
 246  */
 247 static BOOL TOOLHELP_Thread32Next( HANDLE handle, LPTHREADENTRY32 lpte, BOOL first )
 248 {
 249     BOOL ret;
 250
 251     if (lpte->dwSize < sizeof(THREADENTRY32))
 252     {
 253         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 254         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(THREADENTRY32), lpte->dwSize);
 255         return FALSE;
 256     }
 257     SERVER_START_REQ( next_thread )
 258     {
 259         req->handle = handle;
 260         req->reset = first;
 261         if ((ret = !wine_server_call_err( req )))
 262         {
 263             lpte->cntUsage           = reply->count;
 264             lpte->th32ThreadID       = (DWORD)reply->tid;
 265             lpte->th32OwnerProcessID = (DWORD)reply->pid;
 266             lpte->tpBasePri          = reply->base_pri;
 267             lpte->tpDeltaPri         = reply->delta_pri;
 268             lpte->dwFlags            = 0;  /* SDK: "reserved; do not use" */
 269         }
 270     }
 271     SERVER_END_REQ;
 272     return ret;
 273 }
 274
 275 /***********************************************************************
 276  *              Thread32First    (KERNEL32.@)
 277  *
 278  * Return info about the first thread in a toolhelp32 snapshot
 279  */
 280 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 281 {
 282     return TOOLHELP_Thread32Next(hSnapshot, lpte, TRUE);
 283 }
 284
 285 /***********************************************************************
 286  *              Thread32Next   (KERNEL32.@)
 287  *
 288  * Return info about the "next" thread in a toolhelp32 snapshot
 289  */
 290 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 291 {
 292     return TOOLHELP_Thread32Next(hSnapshot, lpte, FALSE);
 293 }
 294
 295 /***********************************************************************
 296  *              TOOLHELP_Process32Next
 297  *
 298  * Implementation of Process32First/Next
 299  */
 300 static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32 lppe, BOOL first )
 301 {
 302     BOOL ret;
 303
 304     if (lppe->dwSize < sizeof(PROCESSENTRY32))
 305     {
 306         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 307         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32), lppe->dwSize);
 308         return FALSE;
 309     }
 310     SERVER_START_REQ( next_process )
 311     {
 312         req->handle = handle;
 313         req->reset = first;
 314         wine_server_set_reply( req, lppe->szExeFile, sizeof(lppe->szExeFile)-1 );
 315         if ((ret = !wine_server_call_err( req )))
 316         {
 317             lppe->cntUsage            = reply->count;
 318             lppe->th32ProcessID       = (DWORD)reply->pid;
 319             lppe->th32DefaultHeapID   = (DWORD)reply->heap;
 320             lppe->th32ModuleID        = (DWORD)reply->module;
 321             lppe->cntThreads          = reply->threads;
 322             lppe->th32ParentProcessID = (DWORD)reply->ppid;
 323             lppe->pcPriClassBase      = reply->priority;
 324             lppe->dwFlags             = -1; /* FIXME */
 325             lppe->szExeFile[wine_server_reply_size(reply)] = 0;
 326         }
 327     }
 328     SERVER_END_REQ;
 329     return ret;
 330 }
 331
 332
 333 /***********************************************************************
 334  *              Process32First    (KERNEL32.@)
 335  *
 336  * Return info about the first process in a toolhelp32 snapshot
 337  */
 338 BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 339 {
 340     return TOOLHELP_Process32Next( hSnapshot, lppe, TRUE );
 341 }
 342
 343 /***********************************************************************
 344  *              Process32Next   (KERNEL32.@)
 345  *
 346  * Return info about the "next" process in a toolhelp32 snapshot
 347  */
 348 BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 349 {
 350     return TOOLHELP_Process32Next( hSnapshot, lppe, FALSE );
 351 }
 352
 353
 354 /***********************************************************************
 355  *              TOOLHELP_Module32Next
 356  *
 357  * Implementation of Module32First/Next
 358  */
 359 static BOOL TOOLHELP_Module32Next( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
 360 {
 361     BOOL ret;
 362
 363     if (lpme->dwSize < sizeof (MODULEENTRY32))
 364     {
 365         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 366         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
 367         return FALSE;
 368     }
 369     SERVER_START_REQ( next_module )
 370     {
 371         req->handle = handle;
 372         req->reset = first;
 373         wine_server_set_reply( req, lpme->szExePath, sizeof(lpme->szExePath)-1 );
 374         if ((ret = !wine_server_call_err( req )))
 375         {
 376             lpme->th32ModuleID   = 0;  /* toolhelp internal id, never used */
 377             lpme->th32ProcessID  = (DWORD)reply->pid;
 378             lpme->GlblcntUsage   = 0; /* FIXME */
 379             lpme->ProccntUsage   = 0; /* FIXME */
 380             lpme->modBaseAddr    = reply->base;
 381             lpme->modBaseSize    = reply->size;
 382             lpme->hModule        = (HMODULE)reply->base;
 383             lpme->szModule[0]    = 0;  /* FIXME */
 384             lpme->szExePath[wine_server_reply_size(reply)] = 0;
 385         }
 386     }
 387     SERVER_END_REQ;
 388     return ret;
 389 }
 390
 391 /***********************************************************************
 392  *              Module32First   (KERNEL32.@)
 393  *
 394  * Return info about the "first" module in a toolhelp32 snapshot
 395  */
 396 BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
 397 {
 398     return TOOLHELP_Module32Next( hSnapshot, lpme, TRUE );
 399 }
 400
 401 /***********************************************************************
 402  *              Module32Next   (KERNEL32.@)
 403  *
 404  * Return info about the "next" module in a toolhelp32 snapshot
 405  */
 406 BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
 407 {
 408     return TOOLHELP_Module32Next( hSnapshot, lpme, FALSE );
 409 }
 410
 411 /************************************************************************
 412  *              GlobalMasterHandle (KERNEL.28)
 413  *
 414  *
 415  * Should return selector and handle of the information structure for
 416  * the global heap. selector and handle are stored in the THHOOK as
 417  * pGlobalHeap and hGlobalHeap.
 418  * As Wine doesn't have this structure, we return both values as zero
 419  * Applications should interpret this as "No Global Heap"
 420  */
 421 DWORD WINAPI GlobalMasterHandle16(void)
 422 {
 423     FIXME(": stub\n");
 424     return 0;
 425 }
 426
 427 /************************************************************************
 428  *              Heap32ListFirst (KERNEL.@)
 429  *
 430  */
 431 BOOL WINAPI Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
 432 {
 433     FIXME(": stub\n");
 434     return FALSE;
 435 }