mirror of
https://github.com/reactos/reactos.git
synced 2025-08-02 15:36:42 +00:00
[AUDIT] These files are clean and simple stubs around NT apis and/or WINE code.
- Reformat the files. - Fix A->W calling. - Simpliy WriteProcessMemory to use NtProtectVirtualMemory to query the current state. - Call some APIs with the right DesiredAccess instead of allways sending _ALL_ACCESS. (for example, only use SECTION_MAP_READ | QUERY unless the caller wants r/w. - Flush ITLB when writing to process memory. svn path=/trunk/; revision=22519
This commit is contained in:
Alex Ionescu
parent
b1d543c345
commit
3b350f6972
3 changed files with 577 additions and 555 deletions
|
|
@ -1,10 +1,9 @@
|
|||
/* $Id$
|
||||
*
|
||||
* COPYRIGHT: See COPYING in the top level directory
|
||||
* PROJECT: ReactOS kernel
|
||||
* FILE: lib/kernel32/mem/procmem.c
|
||||
* PURPOSE:
|
||||
* PROGRAMMER: Boudewijn Dekker
|
||||
/*
|
||||
* PROJECT: ReactOS Win32 Base API
|
||||
* LICENSE: GPL - See COPYING in the top level directory
|
||||
* FILE: dll/win32/kernel32/mem/procmem.c
|
||||
* PURPOSE: Handles virtual memory APIs
|
||||
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
|
||||
*/
|
||||
|
||||
/* INCLUDES ******************************************************************/
|
||||
|
|
@ -12,7 +11,7 @@
|
|||
#include <k32.h>
|
||||
|
||||
#define NDEBUG
|
||||
#include "../include/debug.h"
|
||||
#include "debug.h"
|
||||
|
||||
/* FUNCTIONS *****************************************************************/
|
||||
|
||||
|
|
@ -20,138 +19,138 @@
|
|||
* @implemented
|
||||
*/
|
||||
BOOL
|
||||
STDCALL
|
||||
ReadProcessMemory (
|
||||
HANDLE hProcess,
|
||||
LPCVOID lpBaseAddress,
|
||||
LPVOID lpBuffer,
|
||||
DWORD nSize,
|
||||
LPDWORD lpNumberOfBytesRead
|
||||
)
|
||||
NTAPI
|
||||
ReadProcessMemory(IN HANDLE hProcess,
|
||||
IN LPCVOID lpBaseAddress,
|
||||
IN LPVOID lpBuffer,
|
||||
IN DWORD nSize,
|
||||
OUT LPDWORD lpNumberOfBytesRead)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
|
||||
NTSTATUS Status;
|
||||
/* Do the read */
|
||||
Status = NtReadVirtualMemory(hProcess,
|
||||
(PVOID)lpBaseAddress,
|
||||
lpBuffer,
|
||||
nSize,
|
||||
lpNumberOfBytesRead);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus (Status);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
Status = NtReadVirtualMemory( hProcess, (PVOID)lpBaseAddress,lpBuffer, nSize,
|
||||
(PULONG)lpNumberOfBytesRead
|
||||
);
|
||||
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus (Status);
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
/* Return success */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL
|
||||
STDCALL
|
||||
WriteProcessMemory (
|
||||
HANDLE hProcess,
|
||||
LPVOID lpBaseAddress,
|
||||
LPCVOID lpBuffer,
|
||||
SIZE_T nSize,
|
||||
SIZE_T *lpNumberOfBytesWritten
|
||||
)
|
||||
NTAPI
|
||||
WriteProcessMemory(IN HANDLE hProcess,
|
||||
IN LPVOID lpBaseAddress,
|
||||
IN LPCVOID lpBuffer,
|
||||
IN SIZE_T nSize,
|
||||
OUT SIZE_T *lpNumberOfBytesWritten)
|
||||
{
|
||||
NTSTATUS Status, ProtectStatus = STATUS_SUCCESS;
|
||||
MEMORY_BASIC_INFORMATION MemInfo;
|
||||
ULONG Length;
|
||||
BOOLEAN UnProtect;
|
||||
NTSTATUS Status;
|
||||
ULONG OldValue;
|
||||
SIZE_T RegionSize;
|
||||
PVOID Base;
|
||||
BOOLEAN UnProtect;
|
||||
|
||||
if (lpNumberOfBytesWritten)
|
||||
/* Set parameters for protect call */
|
||||
RegionSize = nSize;
|
||||
Base = lpBaseAddress;
|
||||
|
||||
/* Check the current status */
|
||||
Status = NtProtectVirtualMemory(hProcess,
|
||||
&Base,
|
||||
&RegionSize,
|
||||
PAGE_EXECUTE_READWRITE,
|
||||
&OldValue);
|
||||
if (NT_SUCCESS(Status))
|
||||
{
|
||||
/* Check if we are unprotecting */
|
||||
UnProtect = OldValue & (PAGE_READWRITE |
|
||||
PAGE_WRITECOPY |
|
||||
PAGE_EXECUTE_READWRITE |
|
||||
PAGE_EXECUTE_WRITECOPY) ? FALSE : TRUE;
|
||||
if (UnProtect)
|
||||
{
|
||||
*lpNumberOfBytesWritten = 0;
|
||||
}
|
||||
|
||||
while (nSize)
|
||||
{
|
||||
Status = NtQueryVirtualMemory(hProcess,
|
||||
lpBaseAddress,
|
||||
MemoryBasicInformation,
|
||||
&MemInfo,
|
||||
sizeof(MEMORY_BASIC_INFORMATION),
|
||||
NULL);
|
||||
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
Length = MemInfo.RegionSize - ((ULONG_PTR)lpBaseAddress - (ULONG_PTR)MemInfo.BaseAddress);
|
||||
if (Length > nSize)
|
||||
{
|
||||
Length = nSize;
|
||||
}
|
||||
UnProtect = MemInfo.Protect & (PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY) ? FALSE : TRUE;
|
||||
if (UnProtect)
|
||||
{
|
||||
MemInfo.BaseAddress = lpBaseAddress;
|
||||
MemInfo.RegionSize = Length;
|
||||
if (MemInfo.Protect & (PAGE_EXECUTE|PAGE_EXECUTE_READ))
|
||||
{
|
||||
MemInfo.Protect &= ~(PAGE_EXECUTE|PAGE_EXECUTE_READ);
|
||||
MemInfo.Protect |= PAGE_EXECUTE_READWRITE;
|
||||
}
|
||||
else
|
||||
{
|
||||
MemInfo.Protect &= ~(PAGE_READONLY|PAGE_NOACCESS);
|
||||
MemInfo.Protect |= PAGE_READWRITE;
|
||||
}
|
||||
|
||||
ProtectStatus = NtProtectVirtualMemory(hProcess,
|
||||
&MemInfo.BaseAddress,
|
||||
&MemInfo.RegionSize,
|
||||
MemInfo.Protect,
|
||||
&MemInfo.Protect);
|
||||
if (!NT_SUCCESS(ProtectStatus))
|
||||
{
|
||||
SetLastErrorByStatus(ProtectStatus);
|
||||
return FALSE;
|
||||
}
|
||||
Length = MemInfo.RegionSize - ((ULONG_PTR)lpBaseAddress - (ULONG_PTR)MemInfo.BaseAddress);
|
||||
if (Length > nSize)
|
||||
{
|
||||
Length = nSize;
|
||||
}
|
||||
}
|
||||
/* Set the new protection */
|
||||
Status = NtProtectVirtualMemory(hProcess,
|
||||
&Base,
|
||||
&RegionSize,
|
||||
OldValue,
|
||||
&OldValue);
|
||||
|
||||
/* Write the memory */
|
||||
Status = NtWriteVirtualMemory(hProcess,
|
||||
lpBaseAddress,
|
||||
(LPVOID)lpBuffer,
|
||||
Length,
|
||||
&Length);
|
||||
if (UnProtect)
|
||||
{
|
||||
ProtectStatus = NtProtectVirtualMemory(hProcess,
|
||||
&MemInfo.BaseAddress,
|
||||
&MemInfo.RegionSize,
|
||||
MemInfo.Protect,
|
||||
&MemInfo.Protect);
|
||||
}
|
||||
nSize,
|
||||
lpNumberOfBytesWritten);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus (Status);
|
||||
return FALSE;
|
||||
}
|
||||
if (UnProtect && !NT_SUCCESS(ProtectStatus))
|
||||
{
|
||||
SetLastErrorByStatus (ProtectStatus);
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
lpBaseAddress = (LPVOID)((ULONG_PTR)lpBaseAddress + Length);
|
||||
lpBuffer = (LPCVOID)((ULONG_PTR)lpBuffer + Length);
|
||||
nSize -= Length;
|
||||
if (lpNumberOfBytesWritten)
|
||||
{
|
||||
*lpNumberOfBytesWritten += Length;
|
||||
}
|
||||
|
||||
/* Flush the ITLB */
|
||||
NtFlushInstructionCache(hProcess, lpBaseAddress, nSize);
|
||||
return TRUE;
|
||||
}
|
||||
return TRUE;
|
||||
else
|
||||
{
|
||||
/* Check if we were read only */
|
||||
if ((OldValue & PAGE_NOACCESS) || (OldValue & PAGE_READONLY))
|
||||
{
|
||||
/* Restore protection and fail */
|
||||
NtProtectVirtualMemory(hProcess,
|
||||
&Base,
|
||||
&RegionSize,
|
||||
OldValue,
|
||||
&OldValue);
|
||||
SetLastErrorByStatus(STATUS_ACCESS_VIOLATION);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Otherwise, do the write */
|
||||
Status = NtWriteVirtualMemory(hProcess,
|
||||
lpBaseAddress,
|
||||
(LPVOID)lpBuffer,
|
||||
nSize,
|
||||
lpNumberOfBytesWritten);
|
||||
|
||||
/* And restore the protection */
|
||||
NtProtectVirtualMemory(hProcess,
|
||||
&Base,
|
||||
&RegionSize,
|
||||
OldValue,
|
||||
&OldValue);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(STATUS_ACCESS_VIOLATION);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Flush the ITLB */
|
||||
NtFlushInstructionCache(hProcess, lpBaseAddress, nSize);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
/* EOF */
|
||||
|
|
|
|||
|
|
@ -1,10 +1,9 @@
|
|||
/* $Id$
|
||||
*
|
||||
* COPYRIGHT: See COPYING in the top level directory
|
||||
* PROJECT: ReactOS kernel
|
||||
* FILE: lib/kernel32/mem/section.c
|
||||
* PURPOSE: Implementing file mapping
|
||||
* PROGRAMMER: David Welch (welch@mcmail.com)
|
||||
/*
|
||||
* PROJECT: ReactOS Win32 Base API
|
||||
* LICENSE: GPL - See COPYING in the top level directory
|
||||
* FILE: dll/win32/kernel32/mem/section.c
|
||||
* PURPOSE: Handles virtual memory APIs
|
||||
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
|
||||
*/
|
||||
|
||||
/* INCLUDES ******************************************************************/
|
||||
|
|
@ -12,371 +11,367 @@
|
|||
#include <k32.h>
|
||||
|
||||
#define NDEBUG
|
||||
#include "../include/debug.h"
|
||||
#include "debug.h"
|
||||
|
||||
/* FUNCTIONS *****************************************************************/
|
||||
|
||||
#define MASK_PAGE_FLAGS (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY)
|
||||
#define MASK_SEC_FLAGS (SEC_COMMIT | SEC_IMAGE | SEC_NOCACHE | SEC_RESERVE)
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
HANDLE STDCALL
|
||||
CreateFileMappingA(HANDLE hFile,
|
||||
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
||||
DWORD flProtect,
|
||||
DWORD dwMaximumSizeHigh,
|
||||
DWORD dwMaximumSizeLow,
|
||||
LPCSTR lpName)
|
||||
HANDLE
|
||||
NTAPI
|
||||
CreateFileMappingA(IN HANDLE hFile,
|
||||
IN LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
||||
IN DWORD flProtect,
|
||||
IN DWORD dwMaximumSizeHigh,
|
||||
IN DWORD dwMaximumSizeLow,
|
||||
IN LPCSTR lpName)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
HANDLE SectionHandle;
|
||||
LARGE_INTEGER MaximumSize;
|
||||
PLARGE_INTEGER MaximumSizePointer;
|
||||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||||
ANSI_STRING AnsiName;
|
||||
UNICODE_STRING UnicodeName;
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor;
|
||||
NTSTATUS Status;
|
||||
ANSI_STRING AnsiName;
|
||||
PUNICODE_STRING UnicodeCache;
|
||||
LPCWSTR UnicodeName = NULL;
|
||||
|
||||
if ((flProtect & (MASK_PAGE_FLAGS | MASK_SEC_FLAGS)) != flProtect)
|
||||
{
|
||||
DPRINT1("Invalid flProtect 0x%08x\n", flProtect);
|
||||
SetLastError(ERROR_INVALID_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
if (lpFileMappingAttributes)
|
||||
{
|
||||
SecurityDescriptor = lpFileMappingAttributes->lpSecurityDescriptor;
|
||||
}
|
||||
else
|
||||
{
|
||||
SecurityDescriptor = NULL;
|
||||
}
|
||||
/* Check for a name */
|
||||
if (lpName)
|
||||
{
|
||||
/* Use TEB Cache */
|
||||
UnicodeCache = &NtCurrentTeb()->StaticUnicodeString;
|
||||
|
||||
if (dwMaximumSizeLow == 0 && dwMaximumSizeHigh == 0)
|
||||
{
|
||||
MaximumSizePointer = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
MaximumSize.u.LowPart = dwMaximumSizeLow;
|
||||
MaximumSize.u.HighPart = dwMaximumSizeHigh;
|
||||
MaximumSizePointer = &MaximumSize;
|
||||
}
|
||||
/* Convert to unicode */
|
||||
RtlInitAnsiString(&AnsiName, lpName);
|
||||
Status = RtlAnsiStringToUnicodeString(UnicodeCache, &AnsiName, FALSE);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* Conversion failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (lpName != NULL)
|
||||
{
|
||||
RtlInitAnsiString(&AnsiName,
|
||||
(LPSTR)lpName);
|
||||
RtlAnsiStringToUnicodeString(&UnicodeName,
|
||||
&AnsiName,
|
||||
TRUE);
|
||||
}
|
||||
/* Otherwise, save the buffer */
|
||||
UnicodeName = (LPCWSTR)UnicodeCache->Buffer;
|
||||
}
|
||||
|
||||
InitializeObjectAttributes(&ObjectAttributes,
|
||||
(lpName ? &UnicodeName : NULL),
|
||||
0,
|
||||
(lpName ? hBaseDir : NULL),
|
||||
SecurityDescriptor);
|
||||
|
||||
Status = NtCreateSection(&SectionHandle,
|
||||
SECTION_ALL_ACCESS,
|
||||
&ObjectAttributes,
|
||||
MaximumSizePointer,
|
||||
flProtect & MASK_PAGE_FLAGS,
|
||||
flProtect & MASK_SEC_FLAGS,
|
||||
((hFile != INVALID_HANDLE_VALUE) ? hFile : NULL));
|
||||
if (lpName != NULL)
|
||||
{
|
||||
RtlFreeUnicodeString(&UnicodeName);
|
||||
}
|
||||
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
return SectionHandle;
|
||||
/* Call the Unicode version */
|
||||
return CreateFileMappingW(hFile,
|
||||
lpFileMappingAttributes,
|
||||
flProtect,
|
||||
dwMaximumSizeHigh,
|
||||
dwMaximumSizeLow,
|
||||
UnicodeName);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
HANDLE STDCALL
|
||||
HANDLE
|
||||
NTAPI
|
||||
CreateFileMappingW(HANDLE hFile,
|
||||
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
||||
DWORD flProtect,
|
||||
DWORD dwMaximumSizeHigh,
|
||||
DWORD dwMaximumSizeLow,
|
||||
LPCWSTR lpName)
|
||||
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
||||
DWORD flProtect,
|
||||
DWORD dwMaximumSizeHigh,
|
||||
DWORD dwMaximumSizeLow,
|
||||
LPCWSTR lpName)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
HANDLE SectionHandle;
|
||||
LARGE_INTEGER MaximumSize;
|
||||
PLARGE_INTEGER MaximumSizePointer;
|
||||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||||
UNICODE_STRING UnicodeName;
|
||||
PSECURITY_DESCRIPTOR SecurityDescriptor;
|
||||
NTSTATUS Status;
|
||||
HANDLE SectionHandle;
|
||||
OBJECT_ATTRIBUTES LocalAttributes;
|
||||
POBJECT_ATTRIBUTES ObjectAttributes;
|
||||
UNICODE_STRING SectionName;
|
||||
ACCESS_MASK DesiredAccess;
|
||||
LARGE_INTEGER LocalSize;
|
||||
PLARGE_INTEGER SectionSize = NULL;
|
||||
ULONG Attributes;
|
||||
|
||||
if ((flProtect & (MASK_PAGE_FLAGS | MASK_SEC_FLAGS)) != flProtect)
|
||||
{
|
||||
DPRINT1("Invalid flProtect 0x%08x\n", flProtect);
|
||||
SetLastError(ERROR_INVALID_PARAMETER);
|
||||
/* Set default access */
|
||||
DesiredAccess = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ;
|
||||
|
||||
/* Get the attributes for the actual allocation and cleanup flProtect */
|
||||
Attributes = flProtect & (SEC_FILE | SEC_IMAGE | SEC_RESERVE | SEC_NOCACHE | SEC_COMMIT);
|
||||
flProtect ^= Attributes;
|
||||
|
||||
/* If the caller didn't say anything, assume SEC_COMMIT */
|
||||
if (!Attributes) Attributes = SEC_COMMIT;
|
||||
|
||||
/* Now check if the caller wanted write access */
|
||||
if (flProtect == PAGE_READWRITE)
|
||||
{
|
||||
/* Give it */
|
||||
DesiredAccess |= (SECTION_MAP_WRITE | SECTION_MAP_READ);
|
||||
}
|
||||
|
||||
/* Now check if we got a name */
|
||||
if (lpName) RtlInitUnicodeString(&SectionName, lpName);
|
||||
|
||||
/* Now convert the object attributes */
|
||||
ObjectAttributes = BasepConvertObjectAttributes(&LocalAttributes,
|
||||
lpFileMappingAttributes,
|
||||
lpName ? &SectionName : NULL);
|
||||
|
||||
/* Check if we got a size */
|
||||
if (dwMaximumSizeLow || dwMaximumSizeHigh)
|
||||
{
|
||||
/* Use a LARGE_INTEGER and convert */
|
||||
SectionSize = &LocalSize;
|
||||
SectionSize->LowPart = dwMaximumSizeLow;
|
||||
SectionSize->HighPart = dwMaximumSizeHigh;
|
||||
}
|
||||
|
||||
/* Make sure the handle is valid */
|
||||
if (hFile == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
/* It's not, we'll only go on if we have a size */
|
||||
hFile = NULL;
|
||||
if (!SectionSize)
|
||||
{
|
||||
/* No size, so this isn't a valid non-mapped section */
|
||||
SetLastError(ERROR_INVALID_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Now create the actual section */
|
||||
Status = NtCreateSection(&SectionHandle,
|
||||
DesiredAccess,
|
||||
ObjectAttributes,
|
||||
SectionSize,
|
||||
flProtect,
|
||||
Attributes,
|
||||
hFile);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
if (lpFileMappingAttributes)
|
||||
{
|
||||
SecurityDescriptor = lpFileMappingAttributes->lpSecurityDescriptor;
|
||||
}
|
||||
else
|
||||
{
|
||||
SecurityDescriptor = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (dwMaximumSizeLow == 0 && dwMaximumSizeHigh == 0)
|
||||
{
|
||||
MaximumSizePointer = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
MaximumSize.u.LowPart = dwMaximumSizeLow;
|
||||
MaximumSize.u.HighPart = dwMaximumSizeHigh;
|
||||
MaximumSizePointer = &MaximumSize;
|
||||
}
|
||||
|
||||
if (lpName != NULL)
|
||||
{
|
||||
RtlInitUnicodeString(&UnicodeName,
|
||||
lpName);
|
||||
}
|
||||
|
||||
InitializeObjectAttributes(&ObjectAttributes,
|
||||
(lpName ? &UnicodeName : NULL),
|
||||
0,
|
||||
(lpName ? hBaseDir : NULL),
|
||||
SecurityDescriptor);
|
||||
|
||||
Status = NtCreateSection(&SectionHandle,
|
||||
SECTION_ALL_ACCESS,
|
||||
&ObjectAttributes,
|
||||
MaximumSizePointer,
|
||||
flProtect & MASK_PAGE_FLAGS,
|
||||
flProtect & MASK_SEC_FLAGS,
|
||||
((hFile != INVALID_HANDLE_VALUE) ? hFile : NULL));
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
return SectionHandle;
|
||||
/* Return the section */
|
||||
return SectionHandle;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
LPVOID STDCALL
|
||||
LPVOID
|
||||
NTAPI
|
||||
MapViewOfFileEx(HANDLE hFileMappingObject,
|
||||
DWORD dwDesiredAccess,
|
||||
DWORD dwFileOffsetHigh,
|
||||
DWORD dwFileOffsetLow,
|
||||
DWORD dwNumberOfBytesToMap,
|
||||
LPVOID lpBaseAddress)
|
||||
DWORD dwDesiredAccess,
|
||||
DWORD dwFileOffsetHigh,
|
||||
DWORD dwFileOffsetLow,
|
||||
DWORD dwNumberOfBytesToMap,
|
||||
LPVOID lpBaseAddress)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
LARGE_INTEGER SectionOffset;
|
||||
ULONG ViewSize;
|
||||
ULONG Protect;
|
||||
LPVOID BaseAddress;
|
||||
NTSTATUS Status;
|
||||
LARGE_INTEGER SectionOffset;
|
||||
ULONG ViewSize;
|
||||
ULONG Protect;
|
||||
LPVOID ViewBase;
|
||||
|
||||
SectionOffset.u.LowPart = dwFileOffsetLow;
|
||||
SectionOffset.u.HighPart = dwFileOffsetHigh;
|
||||
/* Convert the offset */
|
||||
SectionOffset.LowPart = dwFileOffsetLow;
|
||||
SectionOffset.HighPart = dwFileOffsetHigh;
|
||||
|
||||
if ( ( dwDesiredAccess & FILE_MAP_WRITE) == FILE_MAP_WRITE)
|
||||
Protect = PAGE_READWRITE;
|
||||
else if ((dwDesiredAccess & FILE_MAP_READ) == FILE_MAP_READ)
|
||||
Protect = PAGE_READONLY;
|
||||
else if ((dwDesiredAccess & FILE_MAP_ALL_ACCESS) == FILE_MAP_ALL_ACCESS)
|
||||
Protect = PAGE_READWRITE;
|
||||
else if ((dwDesiredAccess & FILE_MAP_COPY) == FILE_MAP_COPY)
|
||||
Protect = PAGE_WRITECOPY;
|
||||
else
|
||||
Protect = PAGE_READWRITE;
|
||||
/* Save the size and base */
|
||||
ViewBase = lpBaseAddress;
|
||||
ViewSize = dwNumberOfBytesToMap;
|
||||
|
||||
if (lpBaseAddress == NULL)
|
||||
{
|
||||
BaseAddress = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
BaseAddress = lpBaseAddress;
|
||||
}
|
||||
/* Convert flags to NT Protection Attributes */
|
||||
if (dwDesiredAccess & FILE_MAP_WRITE)
|
||||
{
|
||||
Protect = PAGE_READWRITE;
|
||||
}
|
||||
else if (dwDesiredAccess & FILE_MAP_READ)
|
||||
{
|
||||
Protect = PAGE_READONLY;
|
||||
}
|
||||
else if (dwDesiredAccess & FILE_MAP_COPY)
|
||||
{
|
||||
Protect = PAGE_WRITECOPY;
|
||||
}
|
||||
else
|
||||
{
|
||||
Protect = PAGE_NOACCESS;
|
||||
}
|
||||
|
||||
ViewSize = (ULONG) dwNumberOfBytesToMap;
|
||||
/* Map the section */
|
||||
Status = ZwMapViewOfSection(hFileMappingObject,
|
||||
NtCurrentProcess(),
|
||||
&ViewBase,
|
||||
0,
|
||||
0,
|
||||
&SectionOffset,
|
||||
&ViewSize,
|
||||
ViewShare,
|
||||
0,
|
||||
Protect);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Status = ZwMapViewOfSection(hFileMappingObject,
|
||||
NtCurrentProcess(),
|
||||
&BaseAddress,
|
||||
0,
|
||||
dwNumberOfBytesToMap,
|
||||
&SectionOffset,
|
||||
&ViewSize,
|
||||
ViewShare,
|
||||
0,
|
||||
Protect);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
return BaseAddress;
|
||||
/* Return the base */
|
||||
return ViewBase;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
LPVOID STDCALL
|
||||
LPVOID
|
||||
NTAPI
|
||||
MapViewOfFile(HANDLE hFileMappingObject,
|
||||
DWORD dwDesiredAccess,
|
||||
DWORD dwFileOffsetHigh,
|
||||
DWORD dwFileOffsetLow,
|
||||
DWORD dwNumberOfBytesToMap)
|
||||
DWORD dwDesiredAccess,
|
||||
DWORD dwFileOffsetHigh,
|
||||
DWORD dwFileOffsetLow,
|
||||
DWORD dwNumberOfBytesToMap)
|
||||
{
|
||||
return MapViewOfFileEx(hFileMappingObject,
|
||||
dwDesiredAccess,
|
||||
dwFileOffsetHigh,
|
||||
dwFileOffsetLow,
|
||||
dwNumberOfBytesToMap,
|
||||
NULL);
|
||||
/* Call the extended API */
|
||||
return MapViewOfFileEx(hFileMappingObject,
|
||||
dwDesiredAccess,
|
||||
dwFileOffsetHigh,
|
||||
dwFileOffsetLow,
|
||||
dwNumberOfBytesToMap,
|
||||
NULL);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
BOOL
|
||||
NTAPI
|
||||
UnmapViewOfFile(LPVOID lpBaseAddress)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
NTSTATUS Status;
|
||||
|
||||
Status = NtUnmapViewOfSection(NtCurrentProcess(),
|
||||
lpBaseAddress);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
/* Unmap the section */
|
||||
Status = NtUnmapViewOfSection(NtCurrentProcess(), lpBaseAddress);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Otherwise, return sucess */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
HANDLE STDCALL
|
||||
HANDLE
|
||||
NTAPI
|
||||
OpenFileMappingA(DWORD dwDesiredAccess,
|
||||
BOOL bInheritHandle,
|
||||
LPCSTR lpName)
|
||||
BOOL bInheritHandle,
|
||||
LPCSTR lpName)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
HANDLE SectionHandle;
|
||||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||||
ANSI_STRING AnsiName;
|
||||
UNICODE_STRING UnicodeName;
|
||||
NTSTATUS Status;
|
||||
ANSI_STRING AnsiName;
|
||||
PUNICODE_STRING UnicodeCache;
|
||||
|
||||
if (lpName == NULL)
|
||||
{
|
||||
/* Check for a name */
|
||||
if (lpName)
|
||||
{
|
||||
/* Use TEB Cache */
|
||||
UnicodeCache = &NtCurrentTeb()->StaticUnicodeString;
|
||||
|
||||
/* Convert to unicode */
|
||||
RtlInitAnsiString(&AnsiName, lpName);
|
||||
Status = RtlAnsiStringToUnicodeString(UnicodeCache, &AnsiName, FALSE);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* Conversion failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* We need a name */
|
||||
SetLastError(ERROR_INVALID_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
RtlInitAnsiString(&AnsiName,
|
||||
(LPSTR)lpName);
|
||||
RtlAnsiStringToUnicodeString(&UnicodeName,
|
||||
&AnsiName,
|
||||
TRUE);
|
||||
|
||||
InitializeObjectAttributes(&ObjectAttributes,
|
||||
&UnicodeName,
|
||||
(bInheritHandle ? OBJ_INHERIT : 0),
|
||||
hBaseDir,
|
||||
NULL);
|
||||
Status = NtOpenSection(&SectionHandle,
|
||||
SECTION_ALL_ACCESS,
|
||||
&ObjectAttributes);
|
||||
RtlFreeUnicodeString (&UnicodeName);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus (Status);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return SectionHandle;
|
||||
/* Call the Unicode version */
|
||||
return OpenFileMappingW(dwDesiredAccess,
|
||||
bInheritHandle,
|
||||
(LPCWSTR)UnicodeCache->Buffer);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
HANDLE STDCALL
|
||||
HANDLE
|
||||
NTAPI
|
||||
OpenFileMappingW(DWORD dwDesiredAccess,
|
||||
BOOL bInheritHandle,
|
||||
LPCWSTR lpName)
|
||||
BOOL bInheritHandle,
|
||||
LPCWSTR lpName)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
HANDLE SectionHandle;
|
||||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||||
UNICODE_STRING UnicodeName;
|
||||
NTSTATUS Status;
|
||||
HANDLE SectionHandle;
|
||||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||||
UNICODE_STRING UnicodeName;
|
||||
|
||||
if (lpName == NULL)
|
||||
{
|
||||
/* We need a name */
|
||||
if (!lpName)
|
||||
{
|
||||
/* Otherwise, fail */
|
||||
SetLastError(ERROR_INVALID_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
RtlInitUnicodeString(&UnicodeName,
|
||||
lpName);
|
||||
InitializeObjectAttributes(&ObjectAttributes,
|
||||
&UnicodeName,
|
||||
(bInheritHandle ? OBJ_INHERIT : 0),
|
||||
hBaseDir,
|
||||
NULL);
|
||||
Status = ZwOpenSection(&SectionHandle,
|
||||
SECTION_ALL_ACCESS,
|
||||
&ObjectAttributes);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
/* Convert attributes */
|
||||
RtlInitUnicodeString(&UnicodeName, lpName);
|
||||
InitializeObjectAttributes(&ObjectAttributes,
|
||||
&UnicodeName,
|
||||
(bInheritHandle ? OBJ_INHERIT : 0),
|
||||
hBaseDir,
|
||||
NULL);
|
||||
|
||||
return SectionHandle;
|
||||
/* Convert COPY to READ */
|
||||
if (dwDesiredAccess == FILE_MAP_COPY) dwDesiredAccess = FILE_MAP_READ;
|
||||
|
||||
/* Open the section */
|
||||
Status = ZwOpenSection(&SectionHandle,
|
||||
dwDesiredAccess,
|
||||
&ObjectAttributes);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Otherwise, return the handle */
|
||||
return SectionHandle;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
BOOL
|
||||
NTAPI
|
||||
FlushViewOfFile(LPCVOID lpBaseAddress,
|
||||
DWORD dwNumberOfBytesToFlush)
|
||||
DWORD dwNumberOfBytesToFlush)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
ULONG NumberOfBytesFlushed;
|
||||
NTSTATUS Status;
|
||||
ULONG NumberOfBytesFlushed;
|
||||
|
||||
Status = NtFlushVirtualMemory(NtCurrentProcess(),
|
||||
(LPVOID)lpBaseAddress,
|
||||
dwNumberOfBytesToFlush,
|
||||
&NumberOfBytesFlushed);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
/* Flush the view */
|
||||
Status = NtFlushVirtualMemory(NtCurrentProcess(),
|
||||
(LPVOID)lpBaseAddress,
|
||||
dwNumberOfBytesToFlush,
|
||||
&NumberOfBytesFlushed);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Return success */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* EOF */
|
||||
|
|
|
|||
|
|
@ -1,10 +1,9 @@
|
|||
/* $Id$
|
||||
*
|
||||
* COPYRIGHT: See COPYING in the top level directory
|
||||
* PROJECT: ReactOS kernel
|
||||
* FILE: lib/kernel32/mem/virtual.c
|
||||
* PURPOSE: Passing the Virtualxxx functions onto the kernel
|
||||
* PROGRAMMER: David Welch (welch@mcmail.com)
|
||||
/*
|
||||
* PROJECT: ReactOS Win32 Base API
|
||||
* LICENSE: GPL - See COPYING in the top level directory
|
||||
* FILE: dll/win32/kernel32/mem/virtual.c
|
||||
* PURPOSE: Handles virtual memory APIs
|
||||
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
|
||||
*/
|
||||
|
||||
/* INCLUDES ******************************************************************/
|
||||
|
|
@ -12,221 +11,250 @@
|
|||
#include <k32.h>
|
||||
|
||||
#define NDEBUG
|
||||
#include "../include/debug.h"
|
||||
#include "debug.h"
|
||||
|
||||
/* FUNCTIONS *****************************************************************/
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
LPVOID STDCALL
|
||||
VirtualAllocEx(HANDLE hProcess,
|
||||
LPVOID lpAddress,
|
||||
SIZE_T dwSize,
|
||||
DWORD flAllocationType,
|
||||
DWORD flProtect)
|
||||
LPVOID
|
||||
NTAPI
|
||||
VirtualAllocEx(IN HANDLE hProcess,
|
||||
IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize,
|
||||
IN DWORD flAllocationType,
|
||||
IN DWORD flProtect)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
NTSTATUS Status;
|
||||
|
||||
Status = NtAllocateVirtualMemory(hProcess,
|
||||
(PVOID *)&lpAddress,
|
||||
0,
|
||||
&dwSize,
|
||||
flAllocationType,
|
||||
flProtect);
|
||||
if (!NT_SUCCESS(Status))
|
||||
/* Allocate the memory */
|
||||
Status = NtAllocateVirtualMemory(hProcess,
|
||||
(PVOID *)&lpAddress,
|
||||
0,
|
||||
&dwSize,
|
||||
flAllocationType,
|
||||
flProtect);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return(NULL);
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return NULL;
|
||||
}
|
||||
return(lpAddress);
|
||||
}
|
||||
|
||||
/* Return the allocated address */
|
||||
return lpAddress;
|
||||
}
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
LPVOID STDCALL
|
||||
VirtualAlloc(LPVOID lpAddress,
|
||||
SIZE_T dwSize,
|
||||
DWORD flAllocationType,
|
||||
DWORD flProtect)
|
||||
LPVOID
|
||||
NTAPI
|
||||
VirtualAlloc(IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize,
|
||||
IN DWORD flAllocationType,
|
||||
IN DWORD flProtect)
|
||||
{
|
||||
return(VirtualAllocEx(GetCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
flAllocationType,
|
||||
flProtect));
|
||||
/* Call the extended API */
|
||||
return VirtualAllocEx(GetCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
flAllocationType,
|
||||
flProtect);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
VirtualFreeEx(HANDLE hProcess,
|
||||
LPVOID lpAddress,
|
||||
SIZE_T dwSize,
|
||||
DWORD dwFreeType)
|
||||
BOOL
|
||||
NTAPI
|
||||
VirtualFreeEx(IN HANDLE hProcess,
|
||||
IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize,
|
||||
IN DWORD dwFreeType)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
NTSTATUS Status;
|
||||
|
||||
Status = NtFreeVirtualMemory(hProcess,
|
||||
(PVOID *)&lpAddress,
|
||||
(PULONG)&dwSize,
|
||||
dwFreeType);
|
||||
if (!NT_SUCCESS(Status))
|
||||
/* Free the memory */
|
||||
Status = NtFreeVirtualMemory(hProcess,
|
||||
(PVOID *)&lpAddress,
|
||||
(PULONG)&dwSize,
|
||||
dwFreeType);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return(FALSE);
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* Return success */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
VirtualFree(LPVOID lpAddress,
|
||||
SIZE_T dwSize,
|
||||
DWORD dwFreeType)
|
||||
BOOL
|
||||
NTAPI
|
||||
VirtualFree(IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize,
|
||||
IN DWORD dwFreeType)
|
||||
{
|
||||
return(VirtualFreeEx(GetCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
dwFreeType));
|
||||
/* Call the extended API */
|
||||
return VirtualFreeEx(GetCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
dwFreeType);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
VirtualProtect(LPVOID lpAddress,
|
||||
SIZE_T dwSize,
|
||||
DWORD flNewProtect,
|
||||
PDWORD lpflOldProtect)
|
||||
BOOL
|
||||
NTAPI
|
||||
VirtualProtect(IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize,
|
||||
IN DWORD flNewProtect,
|
||||
OUT PDWORD lpflOldProtect)
|
||||
{
|
||||
return(VirtualProtectEx(GetCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
flNewProtect,
|
||||
lpflOldProtect));
|
||||
/* Call the extended API */
|
||||
return VirtualProtectEx(GetCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
flNewProtect,
|
||||
lpflOldProtect);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
VirtualProtectEx(HANDLE hProcess,
|
||||
LPVOID lpAddress,
|
||||
SIZE_T dwSize,
|
||||
DWORD flNewProtect,
|
||||
PDWORD lpflOldProtect)
|
||||
BOOL
|
||||
NTAPI
|
||||
VirtualProtectEx(IN HANDLE hProcess,
|
||||
IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize,
|
||||
IN DWORD flNewProtect,
|
||||
OUT PDWORD lpflOldProtect)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
NTSTATUS Status;
|
||||
|
||||
Status = NtProtectVirtualMemory(hProcess,
|
||||
&lpAddress,
|
||||
&dwSize,
|
||||
flNewProtect,
|
||||
(PULONG)lpflOldProtect);
|
||||
if (!NT_SUCCESS(Status))
|
||||
/* Change the protection */
|
||||
Status = NtProtectVirtualMemory(hProcess,
|
||||
&lpAddress,
|
||||
&dwSize,
|
||||
flNewProtect,
|
||||
(PULONG)lpflOldProtect);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return(FALSE);
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* Return success */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
VirtualLock(LPVOID lpAddress,
|
||||
SIZE_T dwSize)
|
||||
BOOL
|
||||
NTAPI
|
||||
VirtualLock(IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize)
|
||||
{
|
||||
ULONG BytesLocked;
|
||||
NTSTATUS Status;
|
||||
ULONG BytesLocked;
|
||||
NTSTATUS Status;
|
||||
|
||||
Status = NtLockVirtualMemory(NtCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
&BytesLocked);
|
||||
if (!NT_SUCCESS(Status))
|
||||
/* Lock the memory */
|
||||
Status = NtLockVirtualMemory(NtCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
&BytesLocked);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return(FALSE);
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* Return success */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
DWORD STDCALL
|
||||
VirtualQuery(LPCVOID lpAddress,
|
||||
PMEMORY_BASIC_INFORMATION lpBuffer,
|
||||
SIZE_T dwLength)
|
||||
DWORD
|
||||
NTAPI
|
||||
VirtualQuery(IN LPCVOID lpAddress,
|
||||
OUT PMEMORY_BASIC_INFORMATION lpBuffer,
|
||||
IN SIZE_T dwLength)
|
||||
{
|
||||
return(VirtualQueryEx(NtCurrentProcess(),
|
||||
lpAddress,
|
||||
lpBuffer,
|
||||
dwLength));
|
||||
/* Call the extended API */
|
||||
return VirtualQueryEx(NtCurrentProcess(),
|
||||
lpAddress,
|
||||
lpBuffer,
|
||||
dwLength);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
DWORD STDCALL
|
||||
VirtualQueryEx(HANDLE hProcess,
|
||||
LPCVOID lpAddress,
|
||||
PMEMORY_BASIC_INFORMATION lpBuffer,
|
||||
SIZE_T dwLength)
|
||||
DWORD
|
||||
NTAPI
|
||||
VirtualQueryEx(IN HANDLE hProcess,
|
||||
IN LPCVOID lpAddress,
|
||||
OUT PMEMORY_BASIC_INFORMATION lpBuffer,
|
||||
IN SIZE_T dwLength)
|
||||
{
|
||||
NTSTATUS Status;
|
||||
ULONG ResultLength;
|
||||
NTSTATUS Status;
|
||||
ULONG ResultLength;
|
||||
|
||||
Status = NtQueryVirtualMemory(hProcess,
|
||||
(LPVOID)lpAddress,
|
||||
MemoryBasicInformation,
|
||||
lpBuffer,
|
||||
sizeof(MEMORY_BASIC_INFORMATION),
|
||||
&ResultLength );
|
||||
if (!NT_SUCCESS(Status))
|
||||
/* Query basic information */
|
||||
Status = NtQueryVirtualMemory(hProcess,
|
||||
(LPVOID)lpAddress,
|
||||
MemoryBasicInformation,
|
||||
lpBuffer,
|
||||
sizeof(MEMORY_BASIC_INFORMATION),
|
||||
&ResultLength);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return 0;
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return 0;
|
||||
}
|
||||
return(ResultLength);
|
||||
}
|
||||
|
||||
/* Return the length returned */
|
||||
return ResultLength;
|
||||
}
|
||||
|
||||
/*
|
||||
* @implemented
|
||||
*/
|
||||
BOOL STDCALL
|
||||
VirtualUnlock(LPVOID lpAddress,
|
||||
SIZE_T dwSize)
|
||||
BOOL
|
||||
NTAPI
|
||||
VirtualUnlock(IN LPVOID lpAddress,
|
||||
IN SIZE_T dwSize)
|
||||
{
|
||||
ULONG BytesLocked;
|
||||
NTSTATUS Status;
|
||||
ULONG BytesLocked;
|
||||
NTSTATUS Status;
|
||||
|
||||
Status = NtUnlockVirtualMemory(NtCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
&BytesLocked);
|
||||
if (!NT_SUCCESS(Status))
|
||||
/* Unlock the memory */
|
||||
Status = NtUnlockVirtualMemory(NtCurrentProcess(),
|
||||
lpAddress,
|
||||
dwSize,
|
||||
&BytesLocked);
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
SetLastErrorByStatus(Status);
|
||||
return(FALSE);
|
||||
/* We failed */
|
||||
SetLastErrorByStatus(Status);
|
||||
return FALSE;
|
||||
}
|
||||
return(TRUE);
|
||||
|
||||
/* Return success */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* EOF */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue