lib/kernel32/mem/section.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:            See COPYING in the top level directory
   4  * PROJECT:              ReactOS kernel
   5  * FILE:                 lib/kernel32/mem/section.c
   6  * PURPOSE:              Implementing file mapping
   7  * PROGRAMMER:           David Welch (welch@mcmail.com)
   8  */
   9
  10 /* INCLUDES ******************************************************************/
  11
  12 #include <k32.h>
  13
  14 #define NDEBUG
  15 #include <kernel32/kernel32.h>
  16
  17 /* FUNCTIONS *****************************************************************/
  18
  19 HANDLE STDCALL
  20 CreateFileMappingA(HANDLE hFile,
  21                    LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
  22                    DWORD flProtect,
  23                    DWORD dwMaximumSizeHigh,
  24                    DWORD dwMaximumSizeLow,
  25                    LPCSTR lpName)
  26 {
  27    NTSTATUS Status;
  28    HANDLE SectionHandle;
  29    LARGE_INTEGER MaximumSize;
  30    OBJECT_ATTRIBUTES ObjectAttributes;
  31    ANSI_STRING AnsiName;
  32    UNICODE_STRING UnicodeName;
  33    PSECURITY_DESCRIPTOR SecurityDescriptor;
  34
  35    if (lpFileMappingAttributes)
  36      {
  37         SecurityDescriptor = lpFileMappingAttributes->lpSecurityDescriptor;
  38      }
  39    else
  40      {
  41         SecurityDescriptor = NULL;
  42      }
  43
  44    MaximumSize.u.LowPart = dwMaximumSizeLow;
  45    MaximumSize.u.HighPart = dwMaximumSizeHigh;
  46    RtlInitAnsiString(&AnsiName,
  47                      (LPSTR)lpName);
  48    RtlAnsiStringToUnicodeString(&UnicodeName,
  49                                 &AnsiName,
  50                                 TRUE);
  51    InitializeObjectAttributes(&ObjectAttributes,
  52                               &UnicodeName,
  53                               0,
  54                               hBaseDir,
  55                               SecurityDescriptor);
  56    Status = NtCreateSection(&SectionHandle,
  57                             SECTION_ALL_ACCESS,
  58                             &ObjectAttributes,
  59                             &MaximumSize,
  60                             flProtect,
  61                             0,
  62                             hFile);
  63    RtlFreeUnicodeString(&UnicodeName);
  64    if (!NT_SUCCESS(Status))
  65      {
  66         SetLastErrorByStatus(Status);
  67         return NULL;
  68      }
  69    return SectionHandle;
  70 }
  71
  72
  73 HANDLE STDCALL
  74 CreateFileMappingW(HANDLE hFile,
  75                    LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
  76                    DWORD flProtect,
  77                    DWORD dwMaximumSizeHigh,
  78                    DWORD dwMaximumSizeLow,
  79                    LPCWSTR lpName)
  80 {
  81    NTSTATUS Status;
  82    HANDLE SectionHandle;
  83    LARGE_INTEGER MaximumSize;
  84    PLARGE_INTEGER MaximumSizePointer;
  85    OBJECT_ATTRIBUTES ObjectAttributes;
  86    UNICODE_STRING UnicodeName;
  87    PSECURITY_DESCRIPTOR SecurityDescriptor;
  88
  89    if (lpFileMappingAttributes)
  90      {
  91         SecurityDescriptor = lpFileMappingAttributes->lpSecurityDescriptor;
  92      }
  93    else
  94      {
  95         SecurityDescriptor = NULL;
  96      }
  97
  98    if ((dwMaximumSizeLow == 0) && (dwMaximumSizeHigh == 0))
  99      {
 100        MaximumSizePointer = NULL;
 101      }
 102    else
 103      {
 104        MaximumSize.u.LowPart = dwMaximumSizeLow;
 105        MaximumSize.u.HighPart = dwMaximumSizeHigh;
 106        MaximumSizePointer = &MaximumSize;
 107      }
 108    RtlInitUnicodeString(&UnicodeName,
 109                         lpName);
 110    InitializeObjectAttributes(&ObjectAttributes,
 111                               &UnicodeName,
 112                               0,
 113                               hBaseDir,
 114                               SecurityDescriptor);
 115    Status = NtCreateSection(&SectionHandle,
 116                             SECTION_ALL_ACCESS,
 117                             &ObjectAttributes,
 118                             MaximumSizePointer,
 119                             flProtect,
 120                             0,
 121                             hFile);
 122    if (!NT_SUCCESS(Status))
 123      {
 124         SetLastErrorByStatus(Status);
 125         return NULL;
 126      }
 127    return SectionHandle;
 128 }
 129
 130
 131 LPVOID STDCALL
 132 MapViewOfFileEx(HANDLE hFileMappingObject,
 133                 DWORD dwDesiredAccess,
 134                 DWORD dwFileOffsetHigh,
 135                 DWORD dwFileOffsetLow,
 136                 DWORD dwNumberOfBytesToMap,
 137                 LPVOID lpBaseAddress)
 138 {
 139    NTSTATUS Status;
 140    LARGE_INTEGER SectionOffset;
 141    ULONG ViewSize;
 142    ULONG Protect;
 143    LPVOID BaseAddress;
 144
 145    SectionOffset.u.LowPart = dwFileOffsetLow;
 146    SectionOffset.u.HighPart = dwFileOffsetHigh;
 147
 148    if ( ( dwDesiredAccess & FILE_MAP_WRITE) == FILE_MAP_WRITE)
 149         Protect  = PAGE_READWRITE;
 150    else if ((dwDesiredAccess & FILE_MAP_READ) == FILE_MAP_READ)
 151         Protect = PAGE_READONLY;
 152    else if ((dwDesiredAccess & FILE_MAP_ALL_ACCESS) == FILE_MAP_ALL_ACCESS)
 153         Protect  = PAGE_READWRITE;
 154    else if ((dwDesiredAccess & FILE_MAP_COPY) == FILE_MAP_COPY)
 155         Protect = PAGE_WRITECOPY;
 156    else
 157         Protect = PAGE_READWRITE;
 158
 159    if (lpBaseAddress == NULL)
 160      {
 161         BaseAddress = NULL;
 162      }
 163    else
 164      {
 165         BaseAddress = lpBaseAddress;
 166      }
 167
 168    ViewSize = (ULONG) dwNumberOfBytesToMap;
 169
 170    Status = ZwMapViewOfSection(hFileMappingObject,
 171                                NtCurrentProcess(),
 172                                &BaseAddress,
 173                                0,
 174                                dwNumberOfBytesToMap,
 175                                &SectionOffset,
 176                                &ViewSize,
 177                                ViewShare,
 178                                0,
 179                                Protect);
 180    if (!NT_SUCCESS(Status))
 181      {
 182         SetLastErrorByStatus(Status);
 183         return NULL;
 184      }
 185    return BaseAddress;
 186 }
 187
 188
 189 LPVOID STDCALL
 190 MapViewOfFile(HANDLE hFileMappingObject,
 191               DWORD dwDesiredAccess,
 192               DWORD dwFileOffsetHigh,
 193               DWORD dwFileOffsetLow,
 194               DWORD dwNumberOfBytesToMap)
 195 {
 196    return MapViewOfFileEx(hFileMappingObject,
 197                           dwDesiredAccess,
 198                           dwFileOffsetHigh,
 199                           dwFileOffsetLow,
 200                           dwNumberOfBytesToMap,
 201                           NULL);
 202 }
 203
 204
 205 WINBOOL STDCALL
 206 UnmapViewOfFile(LPVOID lpBaseAddress)
 207 {
 208    NTSTATUS Status;
 209
 210    Status = NtUnmapViewOfSection(NtCurrentProcess(),
 211                                  lpBaseAddress);
 212    if (!NT_SUCCESS(Status))
 213      {
 214         SetLastErrorByStatus(Status);
 215         return FALSE;
 216      }
 217    return TRUE;
 218 }
 219
 220
 221 HANDLE STDCALL
 222 OpenFileMappingA(DWORD dwDesiredAccess,
 223                  WINBOOL bInheritHandle,
 224                  LPCSTR lpName)
 225 {
 226    NTSTATUS Status;
 227    HANDLE SectionHandle;
 228    OBJECT_ATTRIBUTES ObjectAttributes;
 229    ANSI_STRING AnsiName;
 230    UNICODE_STRING UnicodeName;
 231
 232    ULONG Attributes = 0;
 233
 234    if (bInheritHandle)
 235      {
 236         Attributes = OBJ_INHERIT;
 237      }
 238
 239    RtlInitAnsiString(&AnsiName,
 240                      (LPSTR)lpName);
 241    RtlAnsiStringToUnicodeString(&UnicodeName,
 242                                 &AnsiName,
 243                                 TRUE);
 244
 245    InitializeObjectAttributes(&ObjectAttributes,
 246                               &UnicodeName,
 247                               Attributes,
 248                               hBaseDir,
 249                               NULL);
 250    Status = NtOpenSection(&SectionHandle,
 251                             SECTION_ALL_ACCESS,
 252                             &ObjectAttributes);
 253    RtlFreeUnicodeString (&UnicodeName);
 254    if (!NT_SUCCESS(Status))
 255      {
 256         SetLastErrorByStatus (Status);
 257         return NULL;
 258      }
 259    return SectionHandle;
 260 }
 261
 262
 263 HANDLE STDCALL
 264 OpenFileMappingW(DWORD dwDesiredAccess,
 265                  WINBOOL bInheritHandle,
 266                  LPCWSTR lpName)
 267 {
 268    NTSTATUS Status;
 269    HANDLE SectionHandle;
 270    OBJECT_ATTRIBUTES ObjectAttributes;
 271    UNICODE_STRING UnicodeName;
 272    ULONG Attributes = 0;
 273
 274    if (bInheritHandle)
 275      {
 276         Attributes = OBJ_INHERIT;
 277      }
 278
 279    RtlInitUnicodeString(&UnicodeName,
 280                         lpName);
 281    InitializeObjectAttributes(&ObjectAttributes,
 282                               &UnicodeName,
 283                               Attributes,
 284                               hBaseDir,
 285                               NULL);
 286    Status = ZwOpenSection(&SectionHandle,
 287                             SECTION_ALL_ACCESS,
 288                             &ObjectAttributes);
 289    if (!NT_SUCCESS(Status))
 290      {
 291         SetLastErrorByStatus(Status);
 292         return NULL;
 293      }
 294    return SectionHandle;
 295 }
 296
 297
 298 WINBOOL STDCALL
 299 FlushViewOfFile(LPCVOID lpBaseAddress,
 300                 DWORD dwNumberOfBytesToFlush)
 301 {
 302    NTSTATUS Status;
 303    ULONG NumberOfBytesFlushed;
 304
 305    Status = NtFlushVirtualMemory(NtCurrentProcess(),
 306                                  (LPVOID)lpBaseAddress,
 307                                  dwNumberOfBytesToFlush,
 308                                  &NumberOfBytesFlushed);
 309    if (!NT_SUCCESS(Status))
 310      {
 311         SetLastErrorByStatus(Status);
 312         return FALSE;
 313      }
 314    return TRUE;
 315 }
 316
 317 /* EOF */