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