lib/kernel32/mem/virtual.c

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