reactos/lib/kernel32/mem/virtual.c

   1 /*
   2  * COPYRIGHT:            See COPYING in the top level directory
   3  * PROJECT:              ReactOS kernel
   4  * FILE:                 lib/kernel32/mem/virtual.c
   5  * PURPOSE:              Passing the Virtualxxx functions onto the kernel
   6  * PROGRAMMER:           David Welch (welch@mcmail.com)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <windows.h>
  12 #include <ddk/ntddk.h>
  13
  14 /* FUNCTIONS *****************************************************************/
  15
  16 LPVOID STDCALL VirtualAllocEx(HANDLE hProcess,
  17                               LPVOID lpAddress,
  18                               DWORD dwSize,
  19                               DWORD flAllocationType,
  20                               DWORD flProtect)
  21 {
  22    NTSTATUS Status;
  23
  24    Status = ZwAllocateVirtualMemory(hProcess,
  25                                     (PVOID *)&lpAddress,
  26                                     0,
  27                                     (PULONG)&dwSize,
  28                                     flAllocationType,
  29                                     flProtect);
  30    if (!NT_SUCCESS(Status))
  31      {
  32         SetLastError(RtlNtStatusToDosError(Status));
  33         return(NULL);
  34      }
  35    return(lpAddress);
  36 }
  37
  38 LPVOID STDCALL VirtualAlloc(LPVOID lpAddress,
  39                             DWORD dwSize,
  40                             DWORD flAllocationType,
  41                             DWORD flProtect)
  42 {
  43    return(VirtualAllocEx(GetCurrentProcess(),lpAddress,dwSize,flAllocationType,
  44                          flProtect));
  45 }
  46
  47 WINBOOL STDCALL VirtualFreeEx(HANDLE hProcess,
  48                               LPVOID lpAddress,
  49                               DWORD dwSize,
  50                               DWORD dwFreeType)
  51 {
  52    NTSTATUS Status;
  53
  54    Status = ZwFreeVirtualMemory(hProcess,
  55                                 (PVOID *)&lpAddress,
  56                                 (PULONG)&dwSize,
  57                                 dwFreeType);
  58    if (!NT_SUCCESS(Status))
  59      {
  60         SetLastError(RtlNtStatusToDosError(Status));
  61         return(FALSE);
  62      }
  63    return(TRUE);
  64 }
  65
  66 WINBOOL STDCALL VirtualFree(LPVOID lpAddress, DWORD dwSize, DWORD dwFreeType)
  67 {
  68    return(VirtualFreeEx(GetCurrentProcess(),lpAddress,dwSize,dwFreeType));
  69 }
  70
  71 WINBOOL STDCALL VirtualProtect(LPVOID lpAddress,
  72                                DWORD dwSize,
  73                                DWORD flNewProtect,
  74                                PDWORD lpflOldProtect)
  75 {
  76    return(VirtualProtectEx(GetCurrentProcess(),
  77                            lpAddress,
  78                            dwSize,
  79                            flNewProtect,
  80                            lpflOldProtect));
  81 }
  82
  83
  84 WINBOOL STDCALL VirtualProtectEx(HANDLE hProcess,
  85                                  LPVOID lpAddress,
  86                                  DWORD dwSize,
  87                                  DWORD flNewProtect,
  88                                  PDWORD lpflOldProtect)
  89 {
  90    NTSTATUS Status;
  91
  92    Status = ZwProtectVirtualMemory(hProcess,
  93                                    (PVOID)lpAddress,
  94                                    dwSize,
  95                                    flNewProtect,
  96                                    (PULONG)lpflOldProtect);
  97    if (Status != STATUS_SUCCESS)
  98      {
  99         SetLastError(RtlNtStatusToDosError(Status));
 100         return(FALSE);
 101      }
 102    return(TRUE);
 103 }
 104
 105
 106 WINBOOL
 107 STDCALL
 108 VirtualLock (
 109         LPVOID  lpAddress,
 110         DWORD   dwSize
 111         )
 112 {
 113         ULONG BytesLocked;
 114         NTSTATUS Status;
 115         Status = NtLockVirtualMemory(NtCurrentProcess(),lpAddress,dwSize, &BytesLocked);
 116         if (!NT_SUCCESS(Status))
 117         {
 118                 SetLastError(RtlNtStatusToDosError(Status));
 119                 return FALSE;
 120         }
 121         return TRUE;
 122 }
 123
 124
 125 DWORD
 126 STDCALL
 127 VirtualQuery (
 128         LPCVOID                         lpAddress,
 129         PMEMORY_BASIC_INFORMATION       lpBuffer,
 130         DWORD                           dwLength
 131         )
 132 {
 133         return VirtualQueryEx (NtCurrentProcess(),lpAddress, lpBuffer, dwLength );
 134 }
 135
 136 #define MemoryBasicInformation 0
 137 DWORD
 138 STDCALL
 139 VirtualQueryEx (
 140         HANDLE                          hProcess,
 141         LPCVOID                         lpAddress,
 142         PMEMORY_BASIC_INFORMATION       lpBuffer,
 143         DWORD                           dwLength
 144         )
 145 {
 146         NTSTATUS Status;
 147         ULONG ResultLength;
 148
 149         Status = NtQueryVirtualMemory(
 150                 hProcess,(LPVOID)lpAddress,
 151                 MemoryBasicInformation, lpBuffer,
 152                 sizeof(MEMORY_BASIC_INFORMATION),
 153                 &ResultLength );
 154
 155         if (!NT_SUCCESS(Status))
 156         {
 157                 SetLastError(RtlNtStatusToDosError(Status));
 158                 return ResultLength;
 159         }
 160         return ResultLength;
 161 }
 162
 163
 164 WINBOOL
 165 STDCALL
 166 VirtualUnlock (
 167         LPVOID  lpAddress,
 168         DWORD   dwSize
 169         )
 170 {
 171         ULONG BytesLocked;
 172         NTSTATUS Status;
 173         Status = NtUnlockVirtualMemory(NtCurrentProcess(),lpAddress,dwSize, &BytesLocked);
 174         if (!NT_SUCCESS(Status))
 175         {
 176                 SetLastError(RtlNtStatusToDosError(Status));
 177                 return FALSE;
 178         }
 179         return TRUE;
 180 }