statt->desc , waitt->desc);
WriteFile(stdout, buf1, lstrlen(buf1), &r, NULL);
- EnumThreadWindows((DWORD)CurrentProcess->Threads[ti].ClientId.UniqueThread,
+ EnumThreadWindows(PtrToUlong(CurrentProcess->Threads[ti].ClientId.UniqueThread),
(WNDENUMPROC) EnumThreadProc,
(LPARAM)(LPTSTR) szWindowName );
}
+typedef __attribute__((mode (__pointer__))) unsigned long ULONG_PTRX;
+CurrentProcess = (PSYSTEM_PROCESSES)((ULONG_PTRX)CurrentProcess + 1);
CurrentProcess = (PSYSTEM_PROCESSES)((ULONG_PTR)CurrentProcess +
- CurrentProcess->NextEntryOffset);
+ (ULONG_PTR)CurrentProcess->NextEntryOffset);
}
return (0);
}
IN HANDLE ProcessHandle,
IN OUT PVOID *BaseAddress,
IN ULONG ZeroBits,
- IN OUT PULONG RegionSize,
+ IN OUT PSIZE_T RegionSize,
IN ULONG AllocationType,
IN ULONG Protect
);
NtFreeVirtualMemory(
IN HANDLE ProcessHandle,
IN PVOID *BaseAddress,
- IN PULONG RegionSize,
+ IN PSIZE_T RegionSize,
IN ULONG FreeType
);
IN ULONG ZeroBits,
IN ULONG CommitSize,
IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
- IN OUT PULONG ViewSize,
+ IN OUT PSIZE_T ViewSize,
IN SECTION_INHERIT InheritDisposition,
IN ULONG AllocationType,
IN ULONG AccessProtection
IN HANDLE ProcessHandle,
IN OUT PVOID *BaseAddress,
IN ULONG ZeroBits,
- IN OUT PULONG RegionSize,
+ IN OUT PSIZE_T RegionSize,
IN ULONG AllocationType,
IN ULONG Protect
);
ZwFreeVirtualMemory(
IN HANDLE ProcessHandle,
IN PVOID *BaseAddress,
- IN PULONG RegionSize,
+ IN PSIZE_T RegionSize,
IN ULONG FreeType
);
IN ULONG ZeroBits,
IN ULONG CommitSize,
IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
- IN OUT PULONG ViewSize,
+ IN OUT PSIZE_T ViewSize,
IN SECTION_INHERIT InheritDisposition,
IN ULONG AllocationType,
IN ULONG AccessProtection
NTSTATUS errCode;
IO_STATUS_BLOCK IoStatusBlock;
UCHAR *lpBuffer = NULL;
- ULONG RegionSize = 0x10000;
+ SIZE_T RegionSize = 0x10000;
LARGE_INTEGER BytesCopied;
DWORD CallbackReason;
DWORD ProgressResult;
LPVOID STDCALL
VirtualAllocEx(HANDLE hProcess,
LPVOID lpAddress,
- DWORD dwSize,
+ SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect)
{
Status = NtAllocateVirtualMemory(hProcess,
(PVOID *)&lpAddress,
0,
- (PULONG)&dwSize,
+ &dwSize,
flAllocationType,
flProtect);
if (!NT_SUCCESS(Status))
*/
LPVOID STDCALL
VirtualAlloc(LPVOID lpAddress,
- DWORD dwSize,
+ SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect)
{
BOOL STDCALL
VirtualFreeEx(HANDLE hProcess,
LPVOID lpAddress,
- DWORD dwSize,
+ SIZE_T dwSize,
DWORD dwFreeType)
{
NTSTATUS Status;
*/
BOOL STDCALL
VirtualFree(LPVOID lpAddress,
- DWORD dwSize,
+ SIZE_T dwSize,
DWORD dwFreeType)
{
return(VirtualFreeEx(GetCurrentProcess(),
*/
BOOL STDCALL
VirtualProtect(LPVOID lpAddress,
- DWORD dwSize,
+ SIZE_T dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect)
{
BOOL STDCALL
VirtualProtectEx(HANDLE hProcess,
LPVOID lpAddress,
- DWORD dwSize,
+ SIZE_T dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect)
{
*/
BOOL STDCALL
VirtualLock(LPVOID lpAddress,
- DWORD dwSize)
+ SIZE_T dwSize)
{
ULONG BytesLocked;
NTSTATUS Status;
DWORD STDCALL
VirtualQuery(LPCVOID lpAddress,
PMEMORY_BASIC_INFORMATION lpBuffer,
- DWORD dwLength)
+ SIZE_T dwLength)
{
return(VirtualQueryEx(NtCurrentProcess(),
lpAddress,
VirtualQueryEx(HANDLE hProcess,
LPCVOID lpAddress,
PMEMORY_BASIC_INFORMATION lpBuffer,
- DWORD dwLength)
+ SIZE_T dwLength)
{
NTSTATUS Status;
ULONG ResultLength;
*/
BOOL STDCALL
VirtualUnlock(LPVOID lpAddress,
- DWORD dwSize)
+ SIZE_T dwSize)
{
ULONG BytesLocked;
NTSTATUS Status;
TH32FreeAllocatedResources(PRTL_DEBUG_BUFFER HeapDebug,
PRTL_DEBUG_BUFFER ModuleDebug,
PVOID ProcThrdInfo,
- ULONG ProcThrdInfoSize)
+ SIZE_T ProcThrdInfoSize)
{
if(HeapDebug != NULL)
{
PRTL_DEBUG_BUFFER *HeapDebug,
PRTL_DEBUG_BUFFER *ModuleDebug,
PVOID *ProcThrdInfo,
- ULONG *ProcThrdInfoSize)
+ SIZE_T *ProcThrdInfoSize)
{
NTSTATUS Status = STATUS_SUCCESS;
{
PRTL_DEBUG_BUFFER HeapDebug, ModuleDebug;
PVOID ProcThrdInfo;
- ULONG ProcThrdInfoSize;
+ SIZE_T ProcThrdInfoSize;
NTSTATUS Status;
HANDLE hSnapShotSection = NULL;
NTSTATUS Status;
PWCHAR ScanChar;
ULONG EnviroSize;
- ULONG Size;
+ SIZE_T Size;
UNICODE_STRING Desktop, Shell, Runtime, Title;
PPEB OurPeb = NtCurrentPeb();
LPVOID Environment = lpEnvironment;
{
NTSTATUS Status;
PRTL_DEBUG_BUFFER Buf = NULL;
- ULONG SectionSize = 100 * PAGE_SIZE;
+ SIZE_T SectionSize = 100 * PAGE_SIZE;
Status = NtAllocateVirtualMemory( NtCurrentProcess(),
- (PVOID)&Buf,
+ (PVOID*)&Buf,
0,
- &SectionSize,
+ &SectionSize,
MEM_COMMIT,
PAGE_READWRITE);
if (!NT_SUCCESS(Status))
PVOID ptr,
ULONG flags)
{
- ULONG size = (ULONG)((char *)ptr - (char *)subheap);
+ SIZE_T size = (SIZE_T)((char *)ptr - (char *)subheap);
NTSTATUS Status;
PVOID address;
- ULONG commitsize;
+ SIZE_T commitsize;
size = (size + COMMIT_MASK) & ~COMMIT_MASK;
if (size > subheap->size)
* HEAP_InitSubHeap
*/
static BOOLEAN HEAP_InitSubHeap( HEAP *heap, PVOID address, ULONG flags,
- ULONG commitSize, ULONG totalSize,
+ SIZE_T commitSize, ULONG totalSize,
PRTL_HEAP_PARAMETERS Parameters )
{
SUBHEAP *subheap = (SUBHEAP *)address;
static PSUBHEAP
HEAP_CreateSubHeap(PVOID BaseAddress,
HEAP *heap, ULONG flags,
- ULONG commitSize, ULONG totalSize,
+ SIZE_T commitSize, ULONG totalSize,
PRTL_HEAP_PARAMETERS Parameters )
{
PVOID address;
* Find a free block at least as large as the requested size, and make sure
* the requested size is committed.
*/
-static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, ULONG size,
+static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, SIZE_T size,
SUBHEAP **ppSubHeap )
{
SUBHEAP *subheap;
VOID
NTAPI
-MmInitialiseRegion(
+MmInitializeRegion(
PLIST_ENTRY RegionListHead,
- ULONG Length,
+ SIZE_T Length,
ULONG Type,
ULONG Protect
);
#define ProbeForWritePointer(Ptr) ProbeForWriteGenericType(Ptr, PVOID)
#define ProbeForWriteHandle(Ptr) ProbeForWriteGenericType(Ptr, HANDLE)
#define ProbeForWriteLangid(Ptr) ProbeForWriteGenericType(Ptr, LANGID)
+#define ProbeForWriteSize_t(Ptr) ProbeForWriteGenericType(Ptr, SIZE_T)
#define ProbeForWriteLargeInteger(Ptr) ProbeForWriteGenericType(&(Ptr)->QuadPart, LONGLONG)
#define ProbeForWriteUlargeInteger(Ptr) ProbeForWriteGenericType(&(Ptr)->QuadPart, ULONGLONG)
#define ProbeForWriteUnicodeString(Ptr) ProbeForWriteGenericType(Ptr, UNICODE_STRING)
#define ProbeForReadPointer(Ptr) ProbeForReadGenericType(Ptr, PVOID, NULL)
#define ProbeForReadHandle(Ptr) ProbeForReadGenericType(Ptr, HANDLE, NULL)
#define ProbeForReadLangid(Ptr) ProbeForReadGenericType(Ptr, LANGID, 0)
+#define ProbeForReadSize_t(Ptr) ProbeForReadGenericType(Ptr, SIZE_T, 0)
#define ProbeForReadLargeInteger(Ptr) ProbeForReadGenericType(Ptr, LARGE_INTEGER, __emptyLargeInteger)
#define ProbeForReadUlargeInteger(Ptr) ProbeForReadGenericType(Ptr, ULARGE_INTEGER, __emptyULargeInteger)
#define ProbeForReadUnicodeString(Ptr) ProbeForReadGenericType(Ptr, UNICODE_STRING, __emptyUnicodeString)
MemoryAreaLength = (ULONG_PTR)MemoryArea->EndingAddress -
(ULONG_PTR)MemoryArea->StartingAddress;
- MmInitialiseRegion(&MemoryArea->Data.VirtualMemoryData.RegionListHead,
+ MmInitializeRegion(&MemoryArea->Data.VirtualMemoryData.RegionListHead,
MemoryAreaLength, Type, Protect);
if ((AllocationType & MEM_COMMIT) &&
} while (Status != STATUS_SUCCESS);
/* Initialize the Region */
- MmInitialiseRegion(&MemoryArea->Data.VirtualMemoryData.RegionListHead,
+ MmInitializeRegion(&MemoryArea->Data.VirtualMemoryData.RegionListHead,
PAGE_SIZE,
MEM_COMMIT,
PAGE_READWRITE);
{
PPEB Peb = NULL;
LARGE_INTEGER SectionOffset;
- ULONG ViewSize = 0;
+ SIZE_T ViewSize = 0;
PVOID TableBase = NULL;
PIMAGE_NT_HEADERS NtHeaders;
PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigData;
PVOID BaseAddress;
PMEMORY_AREA MemoryArea;
PHYSICAL_ADDRESS BoundaryAddressMultiple;
- ULONG ViewSize = 0;
+ SIZE_T ViewSize = 0;
PVOID ImageBase = 0;
BoundaryAddressMultiple.QuadPart = 0;
VOID
NTAPI
-MmInitialiseRegion(PLIST_ENTRY RegionListHead, ULONG Length, ULONG Type,
+MmInitializeRegion(PLIST_ENTRY RegionListHead, ULONG Length, ULONG Type,
ULONG Protect)
{
PMM_REGION Region;
PSECTION_OBJECT Section,
PMM_SECTION_SEGMENT Segment,
PVOID* BaseAddress,
- ULONG ViewSize,
+ SIZE_T ViewSize,
ULONG Protect,
ULONG ViewOffset,
ULONG AllocationType)
MArea->Data.SectionData.Section = Section;
MArea->Data.SectionData.ViewOffset = ViewOffset;
MArea->Data.SectionData.WriteCopyView = FALSE;
- MmInitialiseRegion(&MArea->Data.SectionData.RegionListHead,
+ MmInitializeRegion(&MArea->Data.SectionData.RegionListHead,
ViewSize, 0, Protect);
return(STATUS_SUCCESS);
IN ULONG ZeroBits OPTIONAL,
IN ULONG CommitSize,
IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
- IN OUT PULONG ViewSize,
+ IN OUT PSIZE_T ViewSize,
IN SECTION_INHERIT InheritDisposition,
IN ULONG AllocationType OPTIONAL,
IN ULONG Protect)
{
PVOID SafeBaseAddress;
LARGE_INTEGER SafeSectionOffset;
- ULONG SafeViewSize;
+ SIZE_T SafeViewSize;
PSECTION_OBJECT Section;
PEPROCESS Process;
KPROCESSOR_MODE PreviousMode;
ProbeForWriteLargeInteger(SectionOffset);
SafeSectionOffset = *SectionOffset;
}
- ProbeForWriteUlong(ViewSize);
+ ProbeForWriteSize_t(ViewSize);
SafeViewSize = *ViewSize;
}
_SEH_HANDLE
IN ULONG ZeroBits,
IN ULONG CommitSize,
IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
- IN OUT PULONG ViewSize,
+ IN OUT PSIZE_T ViewSize,
IN SECTION_INHERIT InheritDisposition,
IN ULONG AllocationType,
IN ULONG Protect)
PVOID *DllBase)
{
NTSTATUS Status;
- ULONG ViewSize = 0;
+ SIZE_T ViewSize = 0;
PVOID ImageBase = 0;
/* Map the System DLL */
BOOL WINAPI UpdateResourceW(HANDLE,LPCWSTR,LPCWSTR,WORD,PVOID,DWORD);
BOOL WINAPI VerifyVersionInfoA(LPOSVERSIONINFOEXA,DWORD,DWORDLONG);
BOOL WINAPI VerifyVersionInfoW(LPOSVERSIONINFOEXW,DWORD,DWORDLONG);
-PVOID WINAPI VirtualAlloc(PVOID,DWORD,DWORD,DWORD);
-PVOID WINAPI VirtualAllocEx(HANDLE,PVOID,DWORD,DWORD,DWORD);
-BOOL WINAPI VirtualFree(PVOID,DWORD,DWORD);
-BOOL WINAPI VirtualFreeEx(HANDLE,PVOID,DWORD,DWORD);
-BOOL WINAPI VirtualLock(PVOID,DWORD);
-BOOL WINAPI VirtualProtect(PVOID,DWORD,DWORD,PDWORD);
-BOOL WINAPI VirtualProtectEx(HANDLE,PVOID,DWORD,DWORD,PDWORD);
-DWORD WINAPI VirtualQuery(LPCVOID,PMEMORY_BASIC_INFORMATION,DWORD);
-DWORD WINAPI VirtualQueryEx(HANDLE,LPCVOID,PMEMORY_BASIC_INFORMATION,DWORD);
-BOOL WINAPI VirtualUnlock(PVOID,DWORD);
+PVOID WINAPI VirtualAlloc(PVOID,SIZE_T,DWORD,DWORD);
+PVOID WINAPI VirtualAllocEx(HANDLE,PVOID,SIZE_T,DWORD,DWORD);
+BOOL WINAPI VirtualFree(PVOID,SIZE_T,DWORD);
+BOOL WINAPI VirtualFreeEx(HANDLE,PVOID,SIZE_T,DWORD);
+BOOL WINAPI VirtualLock(PVOID,SIZE_T);
+BOOL WINAPI VirtualProtect(PVOID,SIZE_T,DWORD,PDWORD);
+BOOL WINAPI VirtualProtectEx(HANDLE,PVOID,SIZE_T,DWORD,PDWORD);
+DWORD WINAPI VirtualQuery(LPCVOID,PMEMORY_BASIC_INFORMATION,SIZE_T);
+DWORD WINAPI VirtualQueryEx(HANDLE,LPCVOID,PMEMORY_BASIC_INFORMATION,SIZE_T);
+BOOL WINAPI VirtualUnlock(PVOID,SIZE_T);
BOOL WINAPI WaitCommEvent(HANDLE,PDWORD,LPOVERLAPPED);
BOOL WINAPI WaitForDebugEvent(LPDEBUG_EVENT,DWORD);
DWORD WINAPI WaitForMultipleObjects(DWORD,const HANDLE*,BOOL,DWORD);
typedef int INT;
typedef unsigned int UINT,*PUINT,*LPUINT;
+#ifndef NT_INCLUDED
#include <winnt.h>
+#endif
typedef UINT_PTR WPARAM;
typedef LONG_PTR LPARAM;