misc/toolhelp.c

   1 /*
   2  * Misc Toolhelp functions
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <unistd.h>
  10 #include <ctype.h>
  11 #include <assert.h>
  12 #include "windows.h"
  13 #include "win.h"
  14 #include "winerror.h"
  15 #include "tlhelp32.h"
  16 #include "toolhelp.h"
  17 #include "debug.h"
  18 #include "heap.h"
  19 #include "process.h"
  20 #include "k32obj.h"
  21
  22 /*
  23  * Support for toolhelp's snapshots.  They
  24  * are supposed to be Kernel32 Objects.
  25  * Only the Destroy() method is implemented
  26  */
  27
  28 static void SNAPSHOT_Destroy( K32OBJ *obj );
  29
  30 const K32OBJ_OPS SNAPSHOT_Ops =
  31 {
  32   NULL,                 /* signaled */
  33   NULL,                 /* satisfied */
  34   NULL,                 /* add_wait */
  35   NULL,                 /* remove_wait */
  36   NULL,                 /* read */
  37   NULL,                 /* write */
  38   SNAPSHOT_Destroy      /* destroy */
  39 };
  40
  41 /* The K32 snapshot object object */
  42 /* Process snapshot kernel32 object */
  43 typedef struct _Process32Snapshot
  44 {
  45   K32OBJ                header;
  46
  47   DWORD                 numProcs;
  48   DWORD                 arrayCounter;
  49   /*
  50    * Store a reference to the PDB list.
  51    * Insuure in the alloc and dealloc routines for this structure that
  52    * I increment and decrement the pdb->head.refcount, so that the
  53    * original pdb will stay around for as long as I use it, but it's
  54    * not locked forver into memory.
  55    */
  56   PDB32         **processArray;
  57 }
  58 SNAPSHOT_OBJECT;
  59
  60 /* FIXME: to make this working, we have to callback all these registered
  61  * functions from all over the WINE code. Someone with more knowledge than
  62  * me please do that. -Marcus
  63  */
  64 static struct notify
  65 {
  66     HTASK16   htask;
  67     FARPROC16 lpfnCallback;
  68     WORD     wFlags;
  69 } *notifys = NULL;
  70
  71 static int nrofnotifys = 0;
  72
  73 static FARPROC16 HookNotify = NULL;
  74
  75 BOOL16 WINAPI NotifyRegister( HTASK16 htask, FARPROC16 lpfnCallback,
  76                               WORD wFlags )
  77 {
  78     int i;
  79
  80     TRACE(toolhelp, "(%x,%lx,%x) called.\n",
  81                       htask, (DWORD)lpfnCallback, wFlags );
  82     if (!htask) htask = GetCurrentTask();
  83     for (i=0;i<nrofnotifys;i++)
  84         if (notifys[i].htask==htask)
  85             break;
  86     if (i==nrofnotifys) {
  87         if (notifys==NULL)
  88             notifys=(struct notify*)HeapAlloc( SystemHeap, 0,
  89                                                sizeof(struct notify) );
  90         else
  91             notifys=(struct notify*)HeapReAlloc( SystemHeap, 0, notifys,
  92                                         sizeof(struct notify)*(nrofnotifys+1));
  93         if (!notifys) return FALSE;
  94         nrofnotifys++;
  95     }
  96     notifys[i].htask=htask;
  97     notifys[i].lpfnCallback=lpfnCallback;
  98     notifys[i].wFlags=wFlags;
  99     return TRUE;
 100 }
 101
 102 BOOL16 WINAPI NotifyUnregister( HTASK16 htask )
 103 {
 104     int i;
 105
 106     TRACE(toolhelp, "(%x) called.\n", htask );
 107     if (!htask) htask = GetCurrentTask();
 108     for (i=nrofnotifys;i--;)
 109         if (notifys[i].htask==htask)
 110             break;
 111     if (i==-1)
 112         return FALSE;
 113     memcpy(notifys+i,notifys+(i+1),sizeof(struct notify)*(nrofnotifys-i-1));
 114     notifys=(struct notify*)HeapReAlloc( SystemHeap, 0, notifys,
 115                                         (nrofnotifys-1)*sizeof(struct notify));
 116     nrofnotifys--;
 117     return TRUE;
 118 }
 119
 120 BOOL16 WINAPI StackTraceCSIPFirst(STACKTRACEENTRY *ste, WORD wSS, WORD wCS, WORD wIP, WORD wBP)
 121 {
 122     return TRUE;
 123 }
 124
 125 BOOL16 WINAPI StackTraceFirst(STACKTRACEENTRY *ste, HTASK16 Task)
 126 {
 127     return TRUE;
 128 }
 129
 130 BOOL16 WINAPI StackTraceNext(STACKTRACEENTRY *ste)
 131 {
 132     return TRUE;
 133 }
 134
 135 /***********************************************************************
 136  *           ToolHelpHook                             (KERNEL.341)
 137  *      see "Undocumented Windows"
 138  */
 139 FARPROC16 WINAPI ToolHelpHook(FARPROC16 lpfnNotifyHandler)
 140 {
 141 FARPROC16 tmp;
 142         tmp = HookNotify;
 143         HookNotify = lpfnNotifyHandler;
 144         /* just return previously installed notification function */
 145         return tmp;
 146 }
 147
 148 /***********************************************************************
 149  *           SNAPSHOT_Destroy
 150  *
 151  * Deallocate K32 snapshot objects
 152  */
 153 static void SNAPSHOT_Destroy (K32OBJ *obj)
 154 {
 155   int   i;
 156   SNAPSHOT_OBJECT *snapshot = (SNAPSHOT_OBJECT *) obj;
 157   assert (obj->type == K32OBJ_CHANGE);
 158
 159   if (snapshot->processArray)
 160     {
 161       for (i = 0; snapshot->processArray[i] && i <snapshot->numProcs; i++)
 162         {
 163           K32OBJ_DecCount (&snapshot->processArray[i]->header);
 164         }
 165       HeapFree (GetProcessHeap (), 0, snapshot->processArray);
 166       snapshot->processArray = NULL;
 167     }
 168
 169   obj->type = K32OBJ_UNKNOWN;
 170   HeapFree (GetProcessHeap (), 0, snapshot);
 171 }
 172
 173 /***********************************************************************
 174  *           CreateToolHelp32Snapshot                   (KERNEL32.179)
 175  *      see "Undocumented Windows"
 176  */
 177 HANDLE32 WINAPI CreateToolhelp32Snapshot(DWORD dwFlags, DWORD
 178                                          th32ProcessID)
 179 {
 180   HANDLE32              ssHandle;
 181   SNAPSHOT_OBJECT       *snapshot;
 182   int                   numProcesses;
 183   int                   i;
 184   PDB32*                pdb;
 185
 186   TRACE(toolhelp, "%lx & TH32CS_INHERIT (%x) = %lx %s\n", dwFlags,
 187           TH32CS_INHERIT,
 188           dwFlags & TH32CS_INHERIT,
 189           dwFlags & TH32CS_INHERIT ? "TRUE" : "FALSE");
 190   TRACE(toolhelp, "%lx & TH32CS_SNAPHEAPLIST (%x) = %lx %s\n", dwFlags,
 191           TH32CS_SNAPHEAPLIST,
 192           dwFlags & TH32CS_SNAPHEAPLIST,
 193           dwFlags & TH32CS_SNAPHEAPLIST ? "TRUE" : "FALSE");
 194   TRACE(toolhelp, "%lx & TH32CS_SNAPMODULE (%x) = %lx %s\n", dwFlags,
 195           TH32CS_SNAPMODULE,
 196           dwFlags & TH32CS_SNAPMODULE,
 197           dwFlags & TH32CS_SNAPMODULE ? "TRUE" : "FALSE");
 198   TRACE(toolhelp, "%lx & TH32CS_SNAPPROCESS (%x) = %lx %s\n", dwFlags,
 199           TH32CS_SNAPPROCESS,
 200           dwFlags & TH32CS_SNAPPROCESS,
 201           dwFlags & TH32CS_SNAPPROCESS ? "TRUE" : "FALSE");
 202   TRACE(toolhelp, "%lx & TH32CS_SNAPTHREAD (%x) = %lx %s\n", dwFlags,
 203           TH32CS_SNAPTHREAD,
 204           dwFlags & TH32CS_SNAPTHREAD,
 205           dwFlags & TH32CS_SNAPTHREAD ? "TRUE" : "FALSE");
 206
 207   /**** FIXME: Not implmented ***/
 208   if (dwFlags & TH32CS_INHERIT)
 209     {
 210       FIXME(toolhelp,"(0x%08lx (TH32CS_INHERIT),0x%08lx), stub!\n",
 211             dwFlags,th32ProcessID);
 212
 213       return INVALID_HANDLE_VALUE32;
 214     }
 215   if (dwFlags & TH32CS_SNAPHEAPLIST)
 216     {
 217       FIXME(toolhelp,"(0x%08lx (TH32CS_SNAPHEAPLIST),0x%08lx), stub!\n",
 218             dwFlags,th32ProcessID);
 219       return INVALID_HANDLE_VALUE32;
 220     }
 221   if (dwFlags & TH32CS_SNAPMODULE)
 222     {
 223       FIXME(toolhelp,"(0x%08lx (TH32CS_SNAPMODULE),0x%08lx), stub!\n",
 224             dwFlags,th32ProcessID);
 225       return INVALID_HANDLE_VALUE32;
 226     }
 227
 228   if (dwFlags & TH32CS_SNAPPROCESS)
 229     {
 230       TRACE (toolhelp, "(0x%08lx (TH32CS_SNAPMODULE),0x%08lx)\n",
 231             dwFlags,th32ProcessID);
 232       snapshot = HeapAlloc (GetProcessHeap (), 0, sizeof
 233                             (SNAPSHOT_OBJECT));
 234       if (!snapshot)
 235         {
 236           return INVALID_HANDLE_VALUE32;
 237         }
 238
 239       snapshot->header.type = K32OBJ_TOOLHELP_SNAPSHOT;
 240       snapshot->header.refcount = 1;
 241       snapshot->arrayCounter = 0;
 242
 243       /*
 244        * Lock here, to prevent processes from being created or
 245        * destroyed while the snapshot is gathered
 246        */
 247
 248       SYSTEM_LOCK ();
 249       numProcesses = PROCESS_PDBList_Getsize ();
 250
 251       snapshot->processArray = (PDB32**)
 252         HeapAlloc (GetProcessHeap (), 0, sizeof (PDB32*) * numProcesses);
 253
 254       if (!snapshot->processArray)
 255         {
 256           HeapFree (GetProcessHeap (), 0, snapshot->processArray);
 257           SetLastError (INVALID_HANDLE_VALUE32);
 258           ERR (toolhelp, "Error allocating %d bytes for snapshot\n",
 259                sizeof (PDB32*) * numProcesses);
 260           return INVALID_HANDLE_VALUE32;
 261         }
 262
 263       snapshot->numProcs = numProcesses;
 264
 265       pdb = PROCESS_PDBList_Getfirst ();
 266       for (i = 0; pdb && i < numProcesses; i++)
 267         {
 268           TRACE (toolhelp, "Saving ref to pdb %ld\n", PDB_TO_PROCESS_ID(pdb));
 269           snapshot->processArray[i] = pdb;
 270           K32OBJ_IncCount (&pdb->header);
 271           pdb = PROCESS_PDBList_Getnext (pdb);
 272         }
 273       SYSTEM_UNLOCK ();
 274
 275       ssHandle = HANDLE_Alloc (PROCESS_Current (), &snapshot->header,
 276                                FILE_ALL_ACCESS, TRUE, -1);
 277       if (ssHandle == INVALID_HANDLE_VALUE32)
 278         {
 279           /*  HANDLE_Alloc is supposed to deallocate the
 280            *  heap memory if it fails.  This code doesn't need to.
 281            */
 282           SetLastError (INVALID_HANDLE_VALUE32);
 283           ERR (toolhelp, "Error allocating handle\n");
 284           return INVALID_HANDLE_VALUE32;
 285         }
 286
 287       TRACE (toolhelp, "snapshotted %d processes, expected %d\n",
 288             i, numProcesses);
 289       return ssHandle;
 290     }
 291
 292   if (dwFlags & TH32CS_SNAPTHREAD)
 293     {
 294       FIXME(toolhelp,"(0x%08lx (TH32CS_SNAPMODULE),0x%08lx), stub!\n",
 295             dwFlags,th32ProcessID);
 296       return INVALID_HANDLE_VALUE32;
 297     }
 298
 299   return INVALID_HANDLE_VALUE32;
 300 }
 301
 302 /***********************************************************************
 303  *              Process32First
 304  * Return info about the first process in a toolhelp32 snapshot
 305  */
 306 BOOL32 WINAPI Process32First(HANDLE32 hSnapshot, LPPROCESSENTRY32 lppe)
 307 {
 308   PDB32           *pdb;
 309   SNAPSHOT_OBJECT *snapshot;
 310   int             i;
 311
 312   TRACE (toolhelp, "(0x%08lx,0x%08lx)\n", (DWORD) hSnapshot,
 313          (DWORD) lppe);
 314
 315   if (lppe->dwSize < sizeof (PROCESSENTRY32))
 316     {
 317       SetLastError (ERROR_INSUFFICIENT_BUFFER);
 318       ERR (toolhelp, "Result buffer too small\n");
 319       return FALSE;
 320     }
 321
 322   SYSTEM_LOCK ();
 323   snapshot = (SNAPSHOT_OBJECT*) HANDLE_GetObjPtr (PROCESS_Current (),
 324                                                   hSnapshot,
 325                                                   K32OBJ_UNKNOWN,
 326                                                   FILE_ALL_ACCESS,
 327                                                   NULL);
 328   if (!snapshot)
 329     {
 330       SYSTEM_UNLOCK ();
 331       SetLastError (ERROR_INVALID_HANDLE);
 332       ERR (toolhelp, "Error retreiving snapshot\n");
 333       return FALSE;
 334     }
 335
 336   snapshot->arrayCounter = i = 0;
 337   pdb = snapshot->processArray[i];
 338
 339   if (!pdb)
 340     {
 341       SetLastError (ERROR_NO_MORE_FILES);
 342       ERR (toolhelp, "End of snapshot array\n");
 343       return FALSE;
 344     }
 345
 346   TRACE (toolhelp, "Returning info on process %d, id %ld\n",
 347          i, PDB_TO_PROCESS_ID (pdb));
 348
 349   lppe->cntUsage = 1;
 350   lppe->th32ProcessID = PDB_TO_PROCESS_ID (pdb);
 351   lppe->th32DefaultHeapID = (DWORD) pdb->heap;
 352   lppe->cntThreads = pdb->threads;
 353   lppe->th32ParentProcessID = PDB_TO_PROCESS_ID (pdb->parent);
 354   lppe->pcPriClassBase = 6; /* FIXME: this is a made-up value */
 355   lppe->dwFlags = -1;       /* FIXME: RESERVED by Microsoft :-) */
 356   if (pdb->exe_modref)
 357     {
 358       lppe->th32ModuleID = (DWORD) pdb->exe_modref->module;
 359       strncpy (lppe->szExeFile, pdb->exe_modref->longname,
 360                sizeof (lppe->szExeFile));
 361     }
 362   else
 363     {
 364       lppe->th32ModuleID = (DWORD) 0;
 365       strcpy (lppe->szExeFile, "");
 366     }
 367
 368   SYSTEM_UNLOCK ();
 369
 370   return TRUE;
 371 }
 372
 373 /***********************************************************************
 374  *              Process32Next
 375  * Return info about the "next" process in a toolhelp32 snapshot
 376  */
 377 BOOL32 WINAPI Process32Next(HANDLE32 hSnapshot, LPPROCESSENTRY32 lppe)
 378 {
 379   PDB32           *pdb;
 380   SNAPSHOT_OBJECT *snapshot;
 381   int             i;
 382
 383   TRACE (toolhelp, "(0x%08lx,0x%08lx)\n", (DWORD) hSnapshot,
 384          (DWORD) lppe);
 385
 386   if (lppe->dwSize < sizeof (PROCESSENTRY32))
 387     {
 388       SetLastError (ERROR_INSUFFICIENT_BUFFER);
 389       ERR (toolhelp, "Result buffer too small\n");
 390       return FALSE;
 391     }
 392
 393   SYSTEM_LOCK ();
 394   snapshot = (SNAPSHOT_OBJECT*) HANDLE_GetObjPtr (PROCESS_Current (),
 395                                                   hSnapshot,
 396                                                   K32OBJ_UNKNOWN,
 397                                                   FILE_ALL_ACCESS,
 398                                                   NULL);
 399   if (!snapshot)
 400     {
 401       SYSTEM_UNLOCK ();
 402       SetLastError (ERROR_INVALID_HANDLE);
 403       ERR (toolhelp, "Error retreiving snapshot\n");
 404       return FALSE;
 405     }
 406
 407   snapshot->arrayCounter ++;
 408   i = snapshot->arrayCounter;
 409   pdb = snapshot->processArray[i];
 410
 411   if (!pdb || snapshot->arrayCounter >= snapshot->numProcs)
 412     {
 413       SetLastError (ERROR_NO_MORE_FILES);
 414       ERR (toolhelp, "End of snapshot array\n");
 415       return FALSE;
 416     }
 417
 418   TRACE (toolhelp, "Returning info on process %d, id %ld\n",
 419          i, PDB_TO_PROCESS_ID (pdb));
 420
 421   lppe->cntUsage = 1;
 422   lppe->th32ProcessID = PDB_TO_PROCESS_ID (pdb);
 423   lppe->th32DefaultHeapID = (DWORD) pdb->heap;
 424   lppe->cntThreads = pdb->threads;
 425   lppe->th32ParentProcessID = PDB_TO_PROCESS_ID (pdb->parent);
 426   lppe->pcPriClassBase = 6; /* FIXME: this is a made-up value */
 427   lppe->dwFlags = -1;       /* FIXME: RESERVED by Microsoft :-) */
 428   if (pdb->exe_modref)
 429     {
 430       lppe->th32ModuleID = (DWORD) pdb->exe_modref->module;
 431       strncpy (lppe->szExeFile, pdb->exe_modref->longname,
 432                sizeof (lppe->szExeFile));
 433     }
 434   else
 435     {
 436       lppe->th32ModuleID = (DWORD) 0;
 437       strcpy (lppe->szExeFile, "");
 438     }
 439
 440   SYSTEM_UNLOCK ();
 441
 442   return TRUE;
 443 }