lib/kernel32/misc/toolhelp.c

   1 /* $Id$
   2  *
   3  * KERNEL32.DLL toolhelp functions
   4  *
   5  * COPYRIGHT:       See COPYING in the top level directory
   6  * PROJECT:         ReactOS system libraries
   7  * FILE:            lib/kernel32/misc/toolhelp.c
   8  * PURPOSE:         Toolhelp functions
   9  * PROGRAMMER:      Robert Dickenson (robd@mok.lvcm.com)
  10  * UPDATE HISTORY:
  11  *                  Created 05 January 2003
  12  */
  13
  14 #include <windows.h>
  15 #include <tlhelp32.h>
  16
  17
  18 #define CHECK_PARAM_SIZE(ptr, siz) \
  19     if (!ptr || ptr->dwSize != siz) { \
  20         SetLastError(ERROR_INVALID_PARAMETER); \
  21         return FALSE; \
  22     }
  23
  24
  25 /*
  26  * @unimplemented
  27  */
  28 BOOL WINAPI
  29 Heap32First(LPHEAPENTRY32 lphe, DWORD th32ProcessID, DWORD th32HeapID)
  30 {
  31     CHECK_PARAM_SIZE(lphe, sizeof(HEAPENTRY32));
  32
  33     SetLastError(ERROR_NO_MORE_FILES);
  34     return FALSE;
  35 }
  36
  37
  38 /*
  39  * @unimplemented
  40  */
  41 BOOL WINAPI
  42 Heap32Next(LPHEAPENTRY32 lphe)
  43 {
  44 /*
  45 typedef struct tagHEAPENTRY32 {
  46         DWORD dwSize;
  47         HANDLE hHandle;
  48         DWORD dwAddress;
  49         DWORD dwBlockSize;
  50         DWORD dwFlags;
  51         DWORD dwLockCount;
  52         DWORD dwResvd;
  53         DWORD th32ProcessID;
  54         DWORD th32HeapID;
  55 } HEAPENTRY32,*PHEAPENTRY32,*LPHEAPENTRY32;
  56  */
  57     SetLastError(ERROR_NO_MORE_FILES);
  58     return FALSE;
  59 }
  60
  61
  62 /*
  63  * @unimplemented
  64  */
  65 BOOL WINAPI
  66 Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
  67 {
  68     CHECK_PARAM_SIZE(lphl, sizeof(HEAPLIST32));
  69
  70     SetLastError(ERROR_NO_MORE_FILES);
  71     return FALSE;
  72 }
  73
  74
  75 /*
  76  * @unimplemented
  77  */
  78 BOOL WINAPI
  79 Heap32ListNext(HANDLE hSnapshot, LPHEAPLIST32 lph1)
  80 {
  81 /*
  82 typedef struct tagHEAPLIST32 {
  83         DWORD dwSize;
  84         DWORD th32ProcessID;
  85         DWORD th32HeapID;
  86         DWORD dwFlags;
  87 } HEAPLIST32,*PHEAPLIST32,*LPHEAPLIST32;
  88  */
  89     SetLastError(ERROR_NO_MORE_FILES);
  90     return FALSE;
  91 }
  92
  93
  94 /*
  95  * @unimplemented
  96  */
  97 BOOL WINAPI
  98 Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
  99 {
 100     CHECK_PARAM_SIZE(lpme, sizeof(MODULEENTRY32));
 101
 102     SetLastError(ERROR_NO_MORE_FILES);
 103     return FALSE;
 104 }
 105
 106
 107 /*
 108  * @unimplemented
 109  */
 110 BOOL WINAPI
 111 Module32FirstW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
 112 {
 113     CHECK_PARAM_SIZE(lpme, sizeof(MODULEENTRY32W));
 114
 115     SetLastError(ERROR_NO_MORE_FILES);
 116     return FALSE;
 117 }
 118
 119
 120 /*
 121  * @unimplemented
 122  */
 123 BOOL WINAPI
 124 Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
 125 {
 126 /*
 127 typedef struct tagMODULEENTRY32 {
 128         DWORD dwSize;
 129         DWORD th32ModuleID;
 130         DWORD th32ProcessID;
 131         DWORD GlblcntUsage;
 132         DWORD ProccntUsage;
 133         BYTE *modBaseAddr;
 134         DWORD modBaseSize;
 135         HMODULE hModule;
 136         char szModule[MAX_MODULE_NAME32 + 1];
 137         char szExePath[MAX_PATH];
 138 } MODULEENTRY32,*PMODULEENTRY32,*LPMODULEENTRY32;
 139  */
 140     SetLastError(ERROR_NO_MORE_FILES);
 141     return FALSE;
 142 }
 143
 144 BOOL WINAPI
 145 Module32NextW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
 146 {
 147 /*
 148 typedef struct tagMODULEENTRY32W {
 149         DWORD dwSize;
 150         DWORD th32ModuleID;
 151         DWORD th32ProcessID;
 152         DWORD GlblcntUsage;
 153         DWORD ProccntUsage;
 154         BYTE *modBaseAddr;
 155         DWORD modBaseSize;
 156         HMODULE hModule;
 157         WCHAR szModule[MAX_MODULE_NAME32 + 1];
 158         WCHAR szExePath[MAX_PATH];
 159 } MODULEENTRY32W,*PMODULEENTRY32W,*LPMODULEENTRY32W;
 160
 161  */
 162     SetLastError(ERROR_NO_MORE_FILES);
 163     return FALSE;
 164 }
 165
 166
 167 /*
 168  * @unimplemented
 169  */
 170 BOOL STDCALL
 171 Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 172 {
 173     CHECK_PARAM_SIZE(lppe, sizeof(PROCESSENTRY32));
 174
 175     SetLastError(ERROR_NO_MORE_FILES);
 176     return FALSE;
 177 }
 178
 179
 180 /*
 181  * @unimplemented
 182  */
 183 BOOL STDCALL
 184 Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 185 {
 186 /*
 187 typedef struct tagPROCESSENTRY32 {
 188         DWORD dwSize;
 189         DWORD cntUsage;
 190         DWORD th32ProcessID;
 191         DWORD th32DefaultHeapID;
 192         DWORD th32ModuleID;
 193         DWORD cntThreads;
 194         DWORD th32ParentProcessID;
 195         LONG pcPriClassBase;
 196         DWORD dwFlags;
 197         CHAR  szExeFile[MAX_PATH];
 198 } PROCESSENTRY32,*PPROCESSENTRY32,*LPPROCESSENTRY32;
 199  */
 200     SetLastError(ERROR_NO_MORE_FILES);
 201     return FALSE;
 202 }
 203
 204
 205 /*
 206  * @unimplemented
 207  */
 208 BOOL STDCALL
 209 Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
 210 {
 211     CHECK_PARAM_SIZE(lppe, sizeof(PROCESSENTRY32W));
 212
 213     SetLastError(ERROR_NO_MORE_FILES);
 214     return FALSE;
 215 }
 216
 217
 218 /*
 219  * @unimplemented
 220  */
 221 BOOL STDCALL
 222 Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
 223 {
 224 /*
 225 typedef struct tagPROCESSENTRY32W {
 226         DWORD dwSize;
 227         DWORD cntUsage;
 228         DWORD th32ProcessID;
 229         DWORD th32DefaultHeapID;
 230         DWORD th32ModuleID;
 231         DWORD cntThreads;
 232         DWORD th32ParentProcessID;
 233         LONG pcPriClassBase;
 234         DWORD dwFlags;
 235         WCHAR szExeFile[MAX_PATH];
 236 } PROCESSENTRY32W,*PPROCESSENTRY32W,*LPPROCESSENTRY32W;
 237  */
 238     SetLastError(ERROR_NO_MORE_FILES);
 239     return FALSE;
 240 }
 241
 242
 243 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 244 {
 245     CHECK_PARAM_SIZE(lpte, sizeof(THREADENTRY32));
 246
 247     SetLastError(ERROR_NO_MORE_FILES);
 248     return FALSE;
 249 }
 250
 251
 252 /*
 253  * @unimplemented
 254  */
 255 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 256 {
 257 /*
 258 typedef struct tagTHREADENTRY32 {
 259         DWORD dwSize;
 260         DWORD cntUsage;
 261         DWORD th32ThreadID;
 262         DWORD th32OwnerProcessID;
 263         LONG tpBasePri;
 264         LONG tpDeltaPri;
 265         DWORD dwFlags;
 266 } THREADENTRY32,*PTHREADENTRY32,*LPTHREADENTRY32;
 267  */
 268     SetLastError(ERROR_NO_MORE_FILES);
 269     return FALSE;
 270 }
 271
 272
 273 /*
 274  * @unimplemented
 275  */
 276 BOOL WINAPI
 277 Toolhelp32ReadProcessMemory(DWORD th32ProcessID,
 278   LPCVOID lpBaseAddress, LPVOID lpBuffer,
 279   DWORD cbRead, LPDWORD lpNumberOfBytesRead)
 280 {
 281     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 282     return FALSE;
 283 }
 284
 285
 286 #define TL_DEV_NAME L"\\??\\TlHelpDevice"
 287
 288 /*
 289  * @unimplemented
 290  */
 291 HANDLE STDCALL
 292 CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID)
 293 {
 294     // return open handle to snapshot on success, -1 on failure
 295     // the snapshot handle behavies like an object handle
 296     SECURITY_ATTRIBUTES sa;
 297     HANDLE hSnapshot = (HANDLE)-1;
 298
 299     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 300
 301     if (dwFlags & TH32CS_INHERIT) {
 302     }
 303     if (dwFlags & TH32CS_SNAPHEAPLIST) {
 304     }
 305     if (dwFlags & TH32CS_SNAPMODULE) {
 306     }
 307     if (dwFlags & TH32CS_SNAPPROCESS) {
 308     }
 309     if (dwFlags & TH32CS_SNAPTHREAD) {
 310     }
 311     hSnapshot = CreateFileW(TL_DEV_NAME,
 312                            GENERIC_READ, FILE_SHARE_READ + FILE_SHARE_WRITE,
 313                            &sa, OPEN_EXISTING, 0L/*FILE_ATTRIBUTE_SYSTEM*/, 0);
 314     if (hSnapshot != INVALID_HANDLE_VALUE) {
 315
 316     }
 317     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 318
 319     // caller must use CloseHandle to destroy the returned snapshot handle
 320     return hSnapshot;
 321 }
 322
 323
 324 #if 0 /* extracted from mingw tlhelp32.h for easy reference while working above */
 325 /*
 326 #define HF32_DEFAULT    1
 327 #define HF32_SHARED     2
 328 #define LF32_FIXED      0x1
 329 #define LF32_FREE       0x2
 330 #define LF32_MOVEABLE   0x4
 331 #define MAX_MODULE_NAME32       255
 332 #define TH32CS_SNAPHEAPLIST     0x1
 333 #define TH32CS_SNAPPROCESS      0x2
 334 #define TH32CS_SNAPTHREAD       0x4
 335 #define TH32CS_SNAPMODULE       0x8
 336 #define TH32CS_SNAPALL  (TH32CS_SNAPHEAPLIST|TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)
 337 #define TH32CS_INHERIT  0x80000000
 338
 339 BOOL WINAPI Heap32First(LPHEAPENTRY32,DWORD,DWORD);
 340 BOOL WINAPI Heap32ListFirst(HANDLE,LPHEAPLIST32);
 341 BOOL WINAPI Heap32ListNext(HANDLE,LPHEAPLIST32);
 342 BOOL WINAPI Heap32Next(LPHEAPENTRY32);
 343 BOOL WINAPI Module32First(HANDLE,LPMODULEENTRY32);
 344 BOOL WINAPI Module32FirstW(HANDLE,LPMODULEENTRY32W);
 345 BOOL WINAPI Module32Next(HANDLE,LPMODULEENTRY32);
 346 BOOL WINAPI Module32NextW(HANDLE,LPMODULEENTRY32W);
 347 BOOL WINAPI Process32First(HANDLE,LPPROCESSENTRY32);
 348 BOOL WINAPI Process32FirstW(HANDLE,LPPROCESSENTRY32W);
 349 BOOL WINAPI Process32Next(HANDLE,LPPROCESSENTRY32);
 350 BOOL WINAPI Process32NextW(HANDLE,LPPROCESSENTRY32W);
 351 BOOL WINAPI Thread32First(HANDLE,LPTHREADENTRY32);
 352 BOOL WINAPI Thread32Next(HANDLE,LPTHREADENTRY32);
 353 BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD,LPCVOID,LPVOID,DWORD,LPDWORD);
 354 HANDLE WINAPI CreateToolhelp32Snapshot(DWORD,DWORD);
 355
 356 #ifdef UNICODE
 357 #define LPMODULEENTRY32 LPMODULEENTRY32W
 358 #define LPPROCESSENTRY32 LPPROCESSENTRY32W
 359 #define MODULEENTRY32 MODULEENTRY32W
 360 #define Module32First Module32FirstW
 361 #define Module32Next Module32NextW
 362 #define PMODULEENTRY32 PMODULEENTRY32W
 363 #define PPROCESSENTRY32 PPROCESSENTRY32W
 364 #define PROCESSENTRY32 PROCESSENTRY32W
 365 #define Process32First Process32FirstW
 366 #define Process32Next Process32NextW
 367 #endif // UNICODE
 368  */
 369 #endif /* 0 */
 370
 371 /* EOF */