Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-30 05:02:38 +00:00
Code Issues Projects Releases Packages Wiki Activity

created stubs for the rest of the functions listed in mingw's tlhelp.h and exported them.

Browse source 
svn path=/trunk/; revision=3937
This commit is contained in:
Robert Dickenson 2003-01-05 14:32:32 +00:00
parent c374e4ed3e
commit d110568a5c
3 changed files with 286 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

11
reactos/lib/kernel32/kernel32.def
View file

@ -386,6 +386,10 @@ GlobalUnWire@4
GlobalUnfix@4
GlobalUnlock@4
GlobalWire@4
Heap32First@12
Heap32ListFirst@8
Heap32ListNext@8
Heap32Next@4
HeapAlloc@12
HeapCompact@8
HeapCreate@12
@ -448,6 +452,10 @@ LockFileEx@24
LockResource@4
MapViewOfFile@20
MapViewOfFileEx@24
Module32First@8
Module32FirstW@8
Module32Next@8
Module32NextW@8
MoveFileA@8
MoveFileExA@12
MoveFileWithProgressA@20
@ -608,10 +616,13 @@ SystemTimeToFileTime@8
SystemTimeToTzSpecificLocalTime@12
TerminateProcess@8
TerminateThread@8
Thread32First@8
Thread32Next@8
TlsAlloc@0
TlsFree@4
TlsGetValue@4
TlsSetValue@8
Toolhelp32ReadProcessMemory@20
TransactNamedPipe@28
TransmitCommChar@8
TrimVirtualBuffer@4

13
reactos/lib/kernel32/kernel32.edf
View file

@ -1,4 +1,4 @@
; $Id: kernel32.edf,v 1.18 2003/01/04 18:33:18 robd Exp $
; $Id: kernel32.edf,v 1.19 2003/01/05 14:32:32 robd Exp $
;
; kernel32.edf
;
@ -390,6 +390,10 @@ GlobalUnWire=GlobalUnWire@4
GlobalUnfix=GlobalUnfix@4
GlobalUnlock=GlobalUnlock@4
GlobalWire=GlobalWire@4
Heap32First=Heap32First@12
Heap32ListFirst=Heap32ListFirst@8
Heap32ListNext=Heap32ListNext@8
Heap32Next=Heap32Next@4
HeapAlloc=NTDLL.RtlAllocateHeap
HeapCompact=HeapCompact@8
HeapCreate=HeapCreate@12
@ -452,6 +456,10 @@ LockFileEx=LockFileEx@24
LockResource=LockResource@4
MapViewOfFile=MapViewOfFile@20
MapViewOfFileEx=MapViewOfFileEx@24
Module32First=Module32First@8
Module32FirstW=Module32FirstW@8
Module32Next=Module32Next@8
Module32NextW=Module32NextW@8
MoveFileA=MoveFileA@8
MoveFileExA=MoveFileExA@12
MoveFileWithProgressA=MoveFileWithProgressA@20
@ -612,10 +620,13 @@ SystemTimeToFileTime=SystemTimeToFileTime@8
SystemTimeToTzSpecificLocalTime=SystemTimeToTzSpecificLocalTime@12
TerminateProcess=TerminateProcess@8
TerminateThread=TerminateThread@8
Thread32First=Thread32First@8
Thread32Next=Thread32Next@8
TlsAlloc=TlsAlloc@0
TlsFree=TlsFree@4
TlsGetValue=TlsGetValue@4
TlsSetValue=TlsSetValue@8
Toolhelp32ReadProcessMemory=Toolhelp32ReadProcessMemory@20
TransactNamedPipe=TransactNamedPipe@28
TransmitCommChar=TransmitCommChar@8
TrimVirtualBuffer=TrimVirtualBuffer@4

302
reactos/lib/kernel32/misc/toolhelp.c
View file

@ -1,4 +1,4 @@
/* $Id: toolhelp.c,v 1.1 2003/01/05 10:07:08 robd Exp $
/* $Id: toolhelp.c,v 1.2 2003/01/05 14:32:32 robd Exp $
*
* KERNEL32.DLL toolhelp functions
*
@ -6,7 +6,7 @@
* PROJECT: ReactOS system libraries
* FILE: lib/kernel32/misc/toolhelp.c
* PURPOSE: Toolhelp functions
* PROGRAMMER: Robert Dickenson ( robd@mok.lvcm.com)
* PROGRAMMER: Robert Dickenson (robd@mok.lvcm.com)
* UPDATE HISTORY:
* Created 05 January 2003
*/
@ -15,72 +15,214 @@
#include <tlhelp32.h>
BOOL
STDCALL
#define CHECK_PARAM_SIZE(ptr, siz) \
if (!ptr || ptr->dwSize != siz) { \
SetLastError(ERROR_INVALID_PARAMETER); \
return FALSE; \
}
BOOL WINAPI
Heap32First(LPHEAPENTRY32 lphe, DWORD th32ProcessID, DWORD th32HeapID)
{
CHECK_PARAM_SIZE(lphe, sizeof(HEAPENTRY32));
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Heap32Next(LPHEAPENTRY32 lphe)
{
/*
typedef struct tagHEAPENTRY32 {
DWORD dwSize;
HANDLE hHandle;
DWORD dwAddress;
DWORD dwBlockSize;
DWORD dwFlags;
DWORD dwLockCount;
DWORD dwResvd;
DWORD th32ProcessID;
DWORD th32HeapID;
} HEAPENTRY32,*PHEAPENTRY32,*LPHEAPENTRY32;
*/
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
{
CHECK_PARAM_SIZE(lphl, sizeof(HEAPLIST32));
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Heap32ListNext(HANDLE hSnapshot, LPHEAPLIST32 lph1)
{
/*
typedef struct tagHEAPLIST32 {
DWORD dwSize;
DWORD th32ProcessID;
DWORD th32HeapID;
DWORD dwFlags;
} HEAPLIST32,*PHEAPLIST32,*LPHEAPLIST32;
*/
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
{
CHECK_PARAM_SIZE(lpme, sizeof(MODULEENTRY32));
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Module32FirstW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
{
CHECK_PARAM_SIZE(lpme, sizeof(MODULEENTRY32W));
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
{
/*
typedef struct tagMODULEENTRY32 {
DWORD dwSize;
DWORD th32ModuleID;
DWORD th32ProcessID;
DWORD GlblcntUsage;
DWORD ProccntUsage;
BYTE *modBaseAddr;
DWORD modBaseSize;
HMODULE hModule;
char szModule[MAX_MODULE_NAME32 + 1];
char szExePath[MAX_PATH];
} MODULEENTRY32,*PMODULEENTRY32,*LPMODULEENTRY32;
*/
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Module32NextW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
{
/*
typedef struct tagMODULEENTRY32W {
DWORD dwSize;
DWORD th32ModuleID;
DWORD th32ProcessID;
DWORD GlblcntUsage;
DWORD ProccntUsage;
BYTE *modBaseAddr;
DWORD modBaseSize;
HMODULE hModule;
WCHAR szModule[MAX_MODULE_NAME32 + 1];
WCHAR szExePath[MAX_PATH];
} MODULEENTRY32W,*PMODULEENTRY32W,*LPMODULEENTRY32W;
*/
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL STDCALL
Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
{
CHECK_PARAM_SIZE(lppe, sizeof(PROCESSENTRY32));
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL
STDCALL
BOOL STDCALL
Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
{
/*
typedef struct tagPROCESSENTRY32 {
DWORD dwSize;
DWORD cntUsage;
DWORD th32ProcessID;
DWORD th32DefaultHeapID;
DWORD th32ModuleID;
DWORD cntThreads;
DWORD th32ParentProcessID;
LONG pcPriClassBase;
DWORD dwFlags;
CHAR szExeFile[MAX_PATH];
} PROCESSENTRY32,*PPROCESSENTRY32,*LPPROCESSENTRY32;
*/
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL
STDCALL
BOOL STDCALL
Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
{
if (!lppe || lppe->dwSize != sizeof(PROCESSENTRY32W)) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
CHECK_PARAM_SIZE(lppe, sizeof(PROCESSENTRY32W));
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL
STDCALL
BOOL STDCALL
Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
{
/*
typedef struct tagPROCESSENTRY32W {
DWORD dwSize;
DWORD cntUsage;
DWORD th32ProcessID;
DWORD th32DefaultHeapID;
DWORD th32ModuleID;
DWORD cntThreads;
DWORD th32ParentProcessID;
LONG pcPriClassBase;
DWORD dwFlags;
WCHAR szExeFile[MAX_PATH];
} PROCESSENTRY32W,*PPROCESSENTRY32W,*LPPROCESSENTRY32W;
*/
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
HANDLE
STDCALL
CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID)
BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
{
// return open handle to snapshot on success, -1 on failure
// the snapshot handle behavies like an object handle
HANDLE hSnapshot = -1;
CHECK_PARAM_SIZE(lpte, sizeof(THREADENTRY32));
if (dwFlags & TH32CS_INHERIT) {
}
// if (dwFlags & TH32CS_SNAPALL) { // == (TH32CS_SNAPHEAPLIST + TH32CS_SNAPMODULE + TH32CS_SNAPPROCESS + TH32CS_SNAPTHREAD)
// }
if (dwFlags & TH32CS_SNAPHEAPLIST) {
}
if (dwFlags & TH32CS_SNAPMODULE) {
}
if (dwFlags & TH32CS_SNAPPROCESS) {
}
if (dwFlags & TH32CS_SNAPTHREAD) {
}
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
// caller must use CloseHandle to destroy the returned snapshot handle
return hSnapshot;
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL
WINAPI
BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
{
/*
typedef struct tagTHREADENTRY32 {
DWORD dwSize;
DWORD cntUsage;
DWORD th32ThreadID;
DWORD th32OwnerProcessID;
LONG tpBasePri;
LONG tpDeltaPri;
DWORD dwFlags;
} THREADENTRY32,*PTHREADENTRY32,*LPTHREADENTRY32;
*/
SetLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
BOOL WINAPI
Toolhelp32ReadProcessMemory(DWORD th32ProcessID,
LPCVOID lpBaseAddress, LPVOID lpBuffer,
DWORD cbRead, LPDWORD lpNumberOfBytesRead)
@ -90,4 +232,86 @@ Toolhelp32ReadProcessMemory(DWORD th32ProcessID,
}
#define TL_DEV_NAME L"\\??\\TlHelpDevice"
HANDLE STDCALL
CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID)
{
// return open handle to snapshot on success, -1 on failure
// the snapshot handle behavies like an object handle
SECURITY_ATTRIBUTES sa;
HANDLE hSnapshot = (HANDLE)-1;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
if (dwFlags & TH32CS_INHERIT) {
}
if (dwFlags & TH32CS_SNAPHEAPLIST) {
}
if (dwFlags & TH32CS_SNAPMODULE) {
}
if (dwFlags & TH32CS_SNAPPROCESS) {
}
if (dwFlags & TH32CS_SNAPTHREAD) {
}
hSnapshot = CreateFileW(TL_DEV_NAME,
GENERIC_READ, FILE_SHARE_READ + FILE_SHARE_WRITE,
&sa, OPEN_EXISTING, 0L/*FILE_ATTRIBUTE_SYSTEM*/, 0);
if (hSnapshot != INVALID_HANDLE_VALUE) {
}
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
// caller must use CloseHandle to destroy the returned snapshot handle
return hSnapshot;
}
#if 0 /* extracted from mingw tlhelp32.h for easy reference while working above */
/*
#define HF32_DEFAULT 1
#define HF32_SHARED 2
#define LF32_FIXED 0x1
#define LF32_FREE 0x2
#define LF32_MOVEABLE 0x4
#define MAX_MODULE_NAME32 255
#define TH32CS_SNAPHEAPLIST 0x1
#define TH32CS_SNAPPROCESS 0x2
#define TH32CS_SNAPTHREAD 0x4
#define TH32CS_SNAPMODULE 0x8
#define TH32CS_SNAPALL (TH32CS_SNAPHEAPLIST|TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)
#define TH32CS_INHERIT 0x80000000
BOOL WINAPI Heap32First(LPHEAPENTRY32,DWORD,DWORD);
BOOL WINAPI Heap32ListFirst(HANDLE,LPHEAPLIST32);
BOOL WINAPI Heap32ListNext(HANDLE,LPHEAPLIST32);
BOOL WINAPI Heap32Next(LPHEAPENTRY32);
BOOL WINAPI Module32First(HANDLE,LPMODULEENTRY32);
BOOL WINAPI Module32FirstW(HANDLE,LPMODULEENTRY32W);
BOOL WINAPI Module32Next(HANDLE,LPMODULEENTRY32);
BOOL WINAPI Module32NextW(HANDLE,LPMODULEENTRY32W);
BOOL WINAPI Process32First(HANDLE,LPPROCESSENTRY32);
BOOL WINAPI Process32FirstW(HANDLE,LPPROCESSENTRY32W);
BOOL WINAPI Process32Next(HANDLE,LPPROCESSENTRY32);
BOOL WINAPI Process32NextW(HANDLE,LPPROCESSENTRY32W);
BOOL WINAPI Thread32First(HANDLE,LPTHREADENTRY32);
BOOL WINAPI Thread32Next(HANDLE,LPTHREADENTRY32);
BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD,LPCVOID,LPVOID,DWORD,LPDWORD);
HANDLE WINAPI CreateToolhelp32Snapshot(DWORD,DWORD);
#ifdef UNICODE
#define LPMODULEENTRY32 LPMODULEENTRY32W
#define LPPROCESSENTRY32 LPPROCESSENTRY32W
#define MODULEENTRY32 MODULEENTRY32W
#define Module32First Module32FirstW
#define Module32Next Module32NextW
#define PMODULEENTRY32 PMODULEENTRY32W
#define PPROCESSENTRY32 PPROCESSENTRY32W
#define PROCESSENTRY32 PROCESSENTRY32W
#define Process32First Process32FirstW
#define Process32Next Process32NextW
#endif // UNICODE
*/
#endif /* 0 */
/* EOF */