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 BOOL WINAPI
  26 Heap32First(LPHEAPENTRY32 lphe, DWORD th32ProcessID, DWORD th32HeapID)
  27 {
  28     CHECK_PARAM_SIZE(lphe, sizeof(HEAPENTRY32));
  29
  30     SetLastError(ERROR_NO_MORE_FILES);
  31     return FALSE;
  32 }
  33
  34 BOOL WINAPI
  35 Heap32Next(LPHEAPENTRY32 lphe)
  36 {
  37 /*
  38 typedef struct tagHEAPENTRY32 {
  39         DWORD dwSize;
  40         HANDLE hHandle;
  41         DWORD dwAddress;
  42         DWORD dwBlockSize;
  43         DWORD dwFlags;
  44         DWORD dwLockCount;
  45         DWORD dwResvd;
  46         DWORD th32ProcessID;
  47         DWORD th32HeapID;
  48 } HEAPENTRY32,*PHEAPENTRY32,*LPHEAPENTRY32;
  49  */
  50     SetLastError(ERROR_NO_MORE_FILES);
  51     return FALSE;
  52 }
  53
  54 BOOL WINAPI
  55 Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
  56 {
  57     CHECK_PARAM_SIZE(lphl, sizeof(HEAPLIST32));
  58
  59     SetLastError(ERROR_NO_MORE_FILES);
  60     return FALSE;
  61 }
  62
  63 BOOL WINAPI
  64 Heap32ListNext(HANDLE hSnapshot, LPHEAPLIST32 lph1)
  65 {
  66 /*
  67 typedef struct tagHEAPLIST32 {
  68         DWORD dwSize;
  69         DWORD th32ProcessID;
  70         DWORD th32HeapID;
  71         DWORD dwFlags;
  72 } HEAPLIST32,*PHEAPLIST32,*LPHEAPLIST32;
  73  */
  74     SetLastError(ERROR_NO_MORE_FILES);
  75     return FALSE;
  76 }
  77
  78 BOOL WINAPI
  79 Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
  80 {
  81     CHECK_PARAM_SIZE(lpme, sizeof(MODULEENTRY32));
  82
  83     SetLastError(ERROR_NO_MORE_FILES);
  84     return FALSE;
  85 }
  86
  87 BOOL WINAPI
  88 Module32FirstW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
  89 {
  90     CHECK_PARAM_SIZE(lpme, sizeof(MODULEENTRY32W));
  91
  92     SetLastError(ERROR_NO_MORE_FILES);
  93     return FALSE;
  94 }
  95
  96 BOOL WINAPI
  97 Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
  98 {
  99 /*
 100 typedef struct tagMODULEENTRY32 {
 101         DWORD dwSize;
 102         DWORD th32ModuleID;
 103         DWORD th32ProcessID;
 104         DWORD GlblcntUsage;
 105         DWORD ProccntUsage;
 106         BYTE *modBaseAddr;
 107         DWORD modBaseSize;
 108         HMODULE hModule;
 109         char szModule[MAX_MODULE_NAME32 + 1];
 110         char szExePath[MAX_PATH];
 111 } MODULEENTRY32,*PMODULEENTRY32,*LPMODULEENTRY32;
 112  */
 113     SetLastError(ERROR_NO_MORE_FILES);
 114     return FALSE;
 115 }
 116
 117 BOOL WINAPI
 118 Module32NextW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
 119 {
 120 /*
 121 typedef struct tagMODULEENTRY32W {
 122         DWORD dwSize;
 123         DWORD th32ModuleID;
 124         DWORD th32ProcessID;
 125         DWORD GlblcntUsage;
 126         DWORD ProccntUsage;
 127         BYTE *modBaseAddr;
 128         DWORD modBaseSize;
 129         HMODULE hModule;
 130         WCHAR szModule[MAX_MODULE_NAME32 + 1];
 131         WCHAR szExePath[MAX_PATH];
 132 } MODULEENTRY32W,*PMODULEENTRY32W,*LPMODULEENTRY32W;
 133
 134  */
 135     SetLastError(ERROR_NO_MORE_FILES);
 136     return FALSE;
 137 }
 138
 139 BOOL STDCALL
 140 Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 141 {
 142     CHECK_PARAM_SIZE(lppe, sizeof(PROCESSENTRY32));
 143
 144     SetLastError(ERROR_NO_MORE_FILES);
 145     return FALSE;
 146 }
 147
 148 BOOL STDCALL
 149 Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 150 {
 151 /*
 152 typedef struct tagPROCESSENTRY32 {
 153         DWORD dwSize;
 154         DWORD cntUsage;
 155         DWORD th32ProcessID;
 156         DWORD th32DefaultHeapID;
 157         DWORD th32ModuleID;
 158         DWORD cntThreads;
 159         DWORD th32ParentProcessID;
 160         LONG pcPriClassBase;
 161         DWORD dwFlags;
 162         CHAR  szExeFile[MAX_PATH];
 163 } PROCESSENTRY32,*PPROCESSENTRY32,*LPPROCESSENTRY32;
 164  */
 165     SetLastError(ERROR_NO_MORE_FILES);
 166     return FALSE;
 167 }
 168
 169 BOOL STDCALL
 170 Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
 171 {
 172     CHECK_PARAM_SIZE(lppe, sizeof(PROCESSENTRY32W));
 173
 174     SetLastError(ERROR_NO_MORE_FILES);
 175     return FALSE;
 176 }
 177
 178 BOOL STDCALL
 179 Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
 180 {
 181 /*
 182 typedef struct tagPROCESSENTRY32W {
 183         DWORD dwSize;
 184         DWORD cntUsage;
 185         DWORD th32ProcessID;
 186         DWORD th32DefaultHeapID;
 187         DWORD th32ModuleID;
 188         DWORD cntThreads;
 189         DWORD th32ParentProcessID;
 190         LONG pcPriClassBase;
 191         DWORD dwFlags;
 192         WCHAR szExeFile[MAX_PATH];
 193 } PROCESSENTRY32W,*PPROCESSENTRY32W,*LPPROCESSENTRY32W;
 194  */
 195     SetLastError(ERROR_NO_MORE_FILES);
 196     return FALSE;
 197 }
 198
 199
 200 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 201 {
 202     CHECK_PARAM_SIZE(lpte, sizeof(THREADENTRY32));
 203
 204     SetLastError(ERROR_NO_MORE_FILES);
 205     return FALSE;
 206 }
 207
 208 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 209 {
 210 /*
 211 typedef struct tagTHREADENTRY32 {
 212         DWORD dwSize;
 213         DWORD cntUsage;
 214         DWORD th32ThreadID;
 215         DWORD th32OwnerProcessID;
 216         LONG tpBasePri;
 217         LONG tpDeltaPri;
 218         DWORD dwFlags;
 219 } THREADENTRY32,*PTHREADENTRY32,*LPTHREADENTRY32;
 220  */
 221     SetLastError(ERROR_NO_MORE_FILES);
 222     return FALSE;
 223 }
 224
 225 BOOL WINAPI
 226 Toolhelp32ReadProcessMemory(DWORD th32ProcessID,
 227   LPCVOID lpBaseAddress, LPVOID lpBuffer,
 228   DWORD cbRead, LPDWORD lpNumberOfBytesRead)
 229 {
 230     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 231     return FALSE;
 232 }
 233
 234
 235 #define TL_DEV_NAME L"\\??\\TlHelpDevice"
 236
 237 HANDLE STDCALL
 238 CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID)
 239 {
 240     // return open handle to snapshot on success, -1 on failure
 241     // the snapshot handle behavies like an object handle
 242     SECURITY_ATTRIBUTES sa;
 243     HANDLE hSnapshot = (HANDLE)-1;
 244
 245     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 246
 247     if (dwFlags & TH32CS_INHERIT) {
 248     }
 249     if (dwFlags & TH32CS_SNAPHEAPLIST) {
 250     }
 251     if (dwFlags & TH32CS_SNAPMODULE) {
 252     }
 253     if (dwFlags & TH32CS_SNAPPROCESS) {
 254     }
 255     if (dwFlags & TH32CS_SNAPTHREAD) {
 256     }
 257     hSnapshot = CreateFileW(TL_DEV_NAME,
 258                            GENERIC_READ, FILE_SHARE_READ + FILE_SHARE_WRITE,
 259                            &sa, OPEN_EXISTING, 0L/*FILE_ATTRIBUTE_SYSTEM*/, 0);
 260     if (hSnapshot != INVALID_HANDLE_VALUE) {
 261
 262     }
 263     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 264
 265     // caller must use CloseHandle to destroy the returned snapshot handle
 266     return hSnapshot;
 267 }
 268
 269
 270 #if 0 /* extracted from mingw tlhelp32.h for easy reference while working above */
 271 /*
 272 #define HF32_DEFAULT    1
 273 #define HF32_SHARED     2
 274 #define LF32_FIXED      0x1
 275 #define LF32_FREE       0x2
 276 #define LF32_MOVEABLE   0x4
 277 #define MAX_MODULE_NAME32       255
 278 #define TH32CS_SNAPHEAPLIST     0x1
 279 #define TH32CS_SNAPPROCESS      0x2
 280 #define TH32CS_SNAPTHREAD       0x4
 281 #define TH32CS_SNAPMODULE       0x8
 282 #define TH32CS_SNAPALL  (TH32CS_SNAPHEAPLIST|TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)
 283 #define TH32CS_INHERIT  0x80000000
 284
 285 BOOL WINAPI Heap32First(LPHEAPENTRY32,DWORD,DWORD);
 286 BOOL WINAPI Heap32ListFirst(HANDLE,LPHEAPLIST32);
 287 BOOL WINAPI Heap32ListNext(HANDLE,LPHEAPLIST32);
 288 BOOL WINAPI Heap32Next(LPHEAPENTRY32);
 289 BOOL WINAPI Module32First(HANDLE,LPMODULEENTRY32);
 290 BOOL WINAPI Module32FirstW(HANDLE,LPMODULEENTRY32W);
 291 BOOL WINAPI Module32Next(HANDLE,LPMODULEENTRY32);
 292 BOOL WINAPI Module32NextW(HANDLE,LPMODULEENTRY32W);
 293 BOOL WINAPI Process32First(HANDLE,LPPROCESSENTRY32);
 294 BOOL WINAPI Process32FirstW(HANDLE,LPPROCESSENTRY32W);
 295 BOOL WINAPI Process32Next(HANDLE,LPPROCESSENTRY32);
 296 BOOL WINAPI Process32NextW(HANDLE,LPPROCESSENTRY32W);
 297 BOOL WINAPI Thread32First(HANDLE,LPTHREADENTRY32);
 298 BOOL WINAPI Thread32Next(HANDLE,LPTHREADENTRY32);
 299 BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD,LPCVOID,LPVOID,DWORD,LPDWORD);
 300 HANDLE WINAPI CreateToolhelp32Snapshot(DWORD,DWORD);
 301
 302 #ifdef UNICODE
 303 #define LPMODULEENTRY32 LPMODULEENTRY32W
 304 #define LPPROCESSENTRY32 LPPROCESSENTRY32W
 305 #define MODULEENTRY32 MODULEENTRY32W
 306 #define Module32First Module32FirstW
 307 #define Module32Next Module32NextW
 308 #define PMODULEENTRY32 PMODULEENTRY32W
 309 #define PPROCESSENTRY32 PPROCESSENTRY32W
 310 #define PROCESSENTRY32 PROCESSENTRY32W
 311 #define Process32First Process32FirstW
 312 #define Process32Next Process32NextW
 313 #endif // UNICODE
 314  */
 315 #endif /* 0 */
 316
 317 /* EOF */