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     WCHAR exe[MAX_PATH];
 304     DWORD len;
 305
 306     if (lppe->dwSize < sizeof(PROCESSENTRY32))
 307     {
 308         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 309         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32), lppe->dwSize);
 310         return FALSE;
 311     }
 312     SERVER_START_REQ( next_process )
 313     {
 314         req->handle = handle;
 315         req->reset = first;
 316         wine_server_set_reply( req, exe, sizeof(exe) );
 317         if ((ret = !wine_server_call_err( req )))
 318         {
 319             lppe->cntUsage            = reply->count;
 320             lppe->th32ProcessID       = reply->pid;
 321             lppe->th32DefaultHeapID   = (DWORD)reply->heap;
 322             lppe->th32ModuleID        = (DWORD)reply->module;
 323             lppe->cntThreads          = reply->threads;
 324             lppe->th32ParentProcessID = reply->ppid;
 325             lppe->pcPriClassBase      = reply->priority;
 326             lppe->dwFlags             = -1; /* FIXME */
 327             len = WideCharToMultiByte( CP_ACP, 0, exe, wine_server_reply_size(reply) / sizeof(WCHAR),
 328                                        lppe->szExeFile, sizeof(lppe->szExeFile), NULL, NULL );
 329             lppe->szExeFile[len] = 0;
 330         }
 331     }
 332     SERVER_END_REQ;
 333     return ret;
 334 }
 335
 336
 337 /***********************************************************************
 338  *              Process32First    (KERNEL32.@)
 339  *
 340  * Return info about the first process in a toolhelp32 snapshot
 341  */
 342 BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 343 {
 344     return TOOLHELP_Process32Next( hSnapshot, lppe, TRUE );
 345 }
 346
 347 /***********************************************************************
 348  *              Process32Next   (KERNEL32.@)
 349  *
 350  * Return info about the "next" process in a toolhelp32 snapshot
 351  */
 352 BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 353 {
 354     return TOOLHELP_Process32Next( hSnapshot, lppe, FALSE );
 355 }
 356
 357
 358 /***********************************************************************
 359  *              TOOLHELP_Module32Next
 360  *
 361  * Implementation of Module32First/Next
 362  */
 363 static BOOL TOOLHELP_Module32Next( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
 364 {
 365     BOOL ret;
 366     WCHAR exe[MAX_PATH];
 367     DWORD len;
 368
 369     if (lpme->dwSize < sizeof (MODULEENTRY32))
 370     {
 371         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 372         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
 373         return FALSE;
 374     }
 375     SERVER_START_REQ( next_module )
 376     {
 377         req->handle = handle;
 378         req->reset = first;
 379         wine_server_set_reply( req, exe, sizeof(exe) );
 380         if ((ret = !wine_server_call_err( req )))
 381         {
 382             lpme->th32ModuleID   = 0;  /* toolhelp internal id, never used */
 383             lpme->th32ProcessID  = reply->pid;
 384             lpme->GlblcntUsage   = 0; /* FIXME */
 385             lpme->ProccntUsage   = 0; /* FIXME */
 386             lpme->modBaseAddr    = reply->base;
 387             lpme->modBaseSize    = reply->size;
 388             lpme->hModule        = reply->base;
 389             lpme->szModule[0]    = 0;  /* FIXME */
 390             len = WideCharToMultiByte( CP_ACP, 0, exe, wine_server_reply_size(reply) / sizeof(WCHAR),
 391                                        lpme->szExePath, sizeof(lpme->szExePath), NULL, NULL );
 392             lpme->szExePath[len] = 0;
 393         }
 394     }
 395     SERVER_END_REQ;
 396     return ret;
 397 }
 398
 399 /***********************************************************************
 400  *              Module32First   (KERNEL32.@)
 401  *
 402  * Return info about the "first" module in a toolhelp32 snapshot
 403  */
 404 BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
 405 {
 406     return TOOLHELP_Module32Next( hSnapshot, lpme, TRUE );
 407 }
 408
 409 /***********************************************************************
 410  *              Module32Next   (KERNEL32.@)
 411  *
 412  * Return info about the "next" module in a toolhelp32 snapshot
 413  */
 414 BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
 415 {
 416     return TOOLHELP_Module32Next( hSnapshot, lpme, FALSE );
 417 }
 418
 419 /************************************************************************
 420  *              GlobalMasterHandle (KERNEL.28)
 421  *
 422  *
 423  * Should return selector and handle of the information structure for
 424  * the global heap. selector and handle are stored in the THHOOK as
 425  * pGlobalHeap and hGlobalHeap.
 426  * As Wine doesn't have this structure, we return both values as zero
 427  * Applications should interpret this as "No Global Heap"
 428  */
 429 DWORD WINAPI GlobalMasterHandle16(void)
 430 {
 431     FIXME(": stub\n");
 432     return 0;
 433 }
 434
 435 /************************************************************************
 436  *              Heap32ListFirst (KERNEL.@)
 437  *
 438  */
 439 BOOL WINAPI Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
 440 {
 441     FIXME(": stub\n");
 442     return FALSE;
 443 }
 444
 445 /******************************************************************
 446  *              Toolhelp32ReadProcessMemory (KERNEL.@)
 447  *
 448  *
 449  */
 450 BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD pid, const void* base,
 451                                         void* buf, SIZE_T len, SIZE_T* r)
 452 {
 453     HANDLE h;
 454     BOOL   ret = FALSE;
 455
 456     h = (pid) ? OpenProcess(PROCESS_VM_READ, FALSE, pid) : GetCurrentProcess();
 457     if (h != NULL)
 458     {
 459         ret = ReadProcessMemory(h, base, buf, len, r);
 460         if (pid) CloseHandle(h);
 461     }
 462     return ret;
 463 }