| /* |
| * Win32 virtual memory functions |
| * |
| * Copyright 1997 Alexandre Julliard |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <fcntl.h> |
| #include <stdarg.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #ifdef HAVE_UNISTD_H |
| # include <unistd.h> |
| #endif |
| |
| #define NONAMELESSUNION |
| #define NONAMELESSSTRUCT |
| #include "ntstatus.h" |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winnls.h" |
| #include "winreg.h" |
| #include "winternl.h" |
| #include "winerror.h" |
| #include "wine/exception.h" |
| #include "excpt.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(virtual); |
| |
| static unsigned int page_size; |
| |
| /* filter for page-fault exceptions */ |
| static WINE_EXCEPTION_FILTER(page_fault) |
| { |
| if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION) |
| return EXCEPTION_EXECUTE_HANDLER; |
| return EXCEPTION_CONTINUE_SEARCH; |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualAlloc (KERNEL32.@) |
| * Reserves or commits a region of pages in virtual address space |
| * |
| * RETURNS |
| * Base address of allocated region of pages |
| * NULL: Failure |
| */ |
| LPVOID WINAPI VirtualAlloc( |
| LPVOID addr, /* [in] Address of region to reserve or commit */ |
| SIZE_T size, /* [in] Size of region */ |
| DWORD type, /* [in] Type of allocation */ |
| DWORD protect)/* [in] Type of access protection */ |
| { |
| return VirtualAllocEx( GetCurrentProcess(), addr, size, type, protect ); |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualAllocEx (KERNEL32.@) |
| * |
| * Seems to be just as VirtualAlloc, but with process handle. |
| */ |
| LPVOID WINAPI VirtualAllocEx( |
| HANDLE hProcess, /* [in] Handle of process to do mem operation */ |
| LPVOID addr, /* [in] Address of region to reserve or commit */ |
| SIZE_T size, /* [in] Size of region */ |
| DWORD type, /* [in] Type of allocation */ |
| DWORD protect ) /* [in] Type of access protection */ |
| { |
| LPVOID ret; |
| NTSTATUS status; |
| |
| if ((status = NtAllocateVirtualMemory( hProcess, &ret, addr, &size, type, protect ))) |
| { |
| SetLastError( RtlNtStatusToDosError(status) ); |
| ret = NULL; |
| } |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualFree (KERNEL32.@) |
| * Release or decommits a region of pages in virtual address space. |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI VirtualFree( |
| LPVOID addr, /* [in] Address of region of committed pages */ |
| SIZE_T size, /* [in] Size of region */ |
| DWORD type /* [in] Type of operation */ |
| ) { |
| return VirtualFreeEx( GetCurrentProcess(), addr, size, type ); |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualFreeEx (KERNEL32.@) |
| * Release or decommits a region of pages in virtual address space. |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI VirtualFreeEx( HANDLE process, LPVOID addr, SIZE_T size, DWORD type ) |
| { |
| NTSTATUS status = NtFreeVirtualMemory( process, &addr, &size, type ); |
| if (status) SetLastError( RtlNtStatusToDosError(status) ); |
| return !status; |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualLock (KERNEL32.@) |
| * Locks the specified region of virtual address space |
| * |
| * NOTE |
| * Always returns TRUE |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI VirtualLock( LPVOID addr, /* [in] Address of first byte of range to lock */ |
| SIZE_T size ) /* [in] Number of bytes in range to lock */ |
| { |
| NTSTATUS status = NtLockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 ); |
| if (status) SetLastError( RtlNtStatusToDosError(status) ); |
| return !status; |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualUnlock (KERNEL32.@) |
| * Unlocks a range of pages in the virtual address space |
| * |
| * NOTE |
| * Always returns TRUE |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI VirtualUnlock( LPVOID addr, /* [in] Address of first byte of range */ |
| SIZE_T size ) /* [in] Number of bytes in range */ |
| { |
| NTSTATUS status = NtUnlockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 ); |
| if (status) SetLastError( RtlNtStatusToDosError(status) ); |
| return !status; |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualProtect (KERNEL32.@) |
| * Changes the access protection on a region of committed pages |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI VirtualProtect( |
| LPVOID addr, /* [in] Address of region of committed pages */ |
| SIZE_T size, /* [in] Size of region */ |
| DWORD new_prot, /* [in] Desired access protection */ |
| LPDWORD old_prot /* [out] Address of variable to get old protection */ |
| ) { |
| return VirtualProtectEx( GetCurrentProcess(), addr, size, new_prot, old_prot ); |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualProtectEx (KERNEL32.@) |
| * Changes the access protection on a region of committed pages in the |
| * virtual address space of a specified process |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI VirtualProtectEx( |
| HANDLE process, /* [in] Handle of process */ |
| LPVOID addr, /* [in] Address of region of committed pages */ |
| SIZE_T size, /* [in] Size of region */ |
| DWORD new_prot, /* [in] Desired access protection */ |
| LPDWORD old_prot /* [out] Address of variable to get old protection */ ) |
| { |
| NTSTATUS status = NtProtectVirtualMemory( process, &addr, &size, new_prot, old_prot ); |
| if (status) SetLastError( RtlNtStatusToDosError(status) ); |
| return !status; |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualQuery (KERNEL32.@) |
| * Provides info about a range of pages in virtual address space |
| * |
| * RETURNS |
| * Number of bytes returned in information buffer |
| * or 0 if addr is >= 0xc0000000 (kernel space). |
| */ |
| SIZE_T WINAPI VirtualQuery( |
| LPCVOID addr, /* [in] Address of region */ |
| PMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */ |
| SIZE_T len /* [in] Size of buffer */ |
| ) { |
| return VirtualQueryEx( GetCurrentProcess(), addr, info, len ); |
| } |
| |
| |
| /*********************************************************************** |
| * VirtualQueryEx (KERNEL32.@) |
| * Provides info about a range of pages in virtual address space of a |
| * specified process |
| * |
| * RETURNS |
| * Number of bytes returned in information buffer |
| */ |
| SIZE_T WINAPI VirtualQueryEx( |
| HANDLE process, /* [in] Handle of process */ |
| LPCVOID addr, /* [in] Address of region */ |
| PMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */ |
| SIZE_T len /* [in] Size of buffer */ ) |
| { |
| DWORD ret; |
| NTSTATUS status; |
| |
| if ((status = NtQueryVirtualMemory( process, addr, MemoryBasicInformation, info, len, &ret ))) |
| { |
| SetLastError( RtlNtStatusToDosError(status) ); |
| ret = 0; |
| } |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * CreateFileMappingA (KERNEL32.@) |
| * Creates a named or unnamed file-mapping object for the specified file |
| * |
| * RETURNS |
| * Handle: Success |
| * 0: Mapping object does not exist |
| * NULL: Failure |
| */ |
| HANDLE WINAPI CreateFileMappingA( |
| HANDLE hFile, /* [in] Handle of file to map */ |
| SECURITY_ATTRIBUTES *sa, /* [in] Optional security attributes*/ |
| DWORD protect, /* [in] Protection for mapping object */ |
| DWORD size_high, /* [in] High-order 32 bits of object size */ |
| DWORD size_low, /* [in] Low-order 32 bits of object size */ |
| LPCSTR name /* [in] Name of file-mapping object */ ) |
| { |
| WCHAR buffer[MAX_PATH]; |
| |
| if (!name) return CreateFileMappingW( hFile, sa, protect, size_high, size_low, NULL ); |
| |
| if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH )) |
| { |
| SetLastError( ERROR_FILENAME_EXCED_RANGE ); |
| return 0; |
| } |
| return CreateFileMappingW( hFile, sa, protect, size_high, size_low, buffer ); |
| } |
| |
| |
| /*********************************************************************** |
| * CreateFileMappingW (KERNEL32.@) |
| * See CreateFileMappingA |
| */ |
| HANDLE WINAPI CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES sa, |
| DWORD protect, DWORD size_high, |
| DWORD size_low, LPCWSTR name ) |
| { |
| static const int sec_flags = SEC_FILE | SEC_IMAGE | SEC_RESERVE | SEC_COMMIT | SEC_NOCACHE; |
| |
| HANDLE ret; |
| OBJECT_ATTRIBUTES attr; |
| UNICODE_STRING nameW; |
| NTSTATUS status; |
| DWORD access, sec_type; |
| LARGE_INTEGER size; |
| |
| attr.Length = sizeof(attr); |
| attr.RootDirectory = 0; |
| attr.ObjectName = NULL; |
| attr.Attributes = (sa && sa->bInheritHandle) ? OBJ_INHERIT : 0; |
| attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL; |
| attr.SecurityQualityOfService = NULL; |
| |
| if (name) |
| { |
| RtlInitUnicodeString( &nameW, name ); |
| attr.ObjectName = &nameW; |
| } |
| |
| sec_type = protect & sec_flags; |
| protect &= ~sec_flags; |
| if (!sec_type) sec_type = SEC_COMMIT; |
| |
| switch(protect) |
| { |
| case 0: |
| protect = PAGE_READONLY; /* Win9x compatibility */ |
| /* fall through */ |
| case PAGE_READONLY: |
| case PAGE_WRITECOPY: |
| access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ; |
| break; |
| case PAGE_READWRITE: |
| access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE; |
| break; |
| default: |
| SetLastError( ERROR_INVALID_PARAMETER ); |
| return 0; |
| } |
| |
| if (hFile == INVALID_HANDLE_VALUE) |
| { |
| hFile = 0; |
| if (!size_low && !size_high) |
| { |
| SetLastError( ERROR_INVALID_PARAMETER ); |
| return 0; |
| } |
| } |
| |
| size.u.LowPart = size_low; |
| size.u.HighPart = size_high; |
| |
| status = NtCreateSection( &ret, access, &attr, &size, protect, sec_type, hFile ); |
| SetLastError( RtlNtStatusToDosError(status) ); |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * OpenFileMappingA (KERNEL32.@) |
| * Opens a named file-mapping object. |
| * |
| * RETURNS |
| * Handle: Success |
| * NULL: Failure |
| */ |
| HANDLE WINAPI OpenFileMappingA( |
| DWORD access, /* [in] Access mode */ |
| BOOL inherit, /* [in] Inherit flag */ |
| LPCSTR name ) /* [in] Name of file-mapping object */ |
| { |
| WCHAR buffer[MAX_PATH]; |
| |
| if (!name) return OpenFileMappingW( access, inherit, NULL ); |
| |
| if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH )) |
| { |
| SetLastError( ERROR_FILENAME_EXCED_RANGE ); |
| return 0; |
| } |
| return OpenFileMappingW( access, inherit, buffer ); |
| } |
| |
| |
| /*********************************************************************** |
| * OpenFileMappingW (KERNEL32.@) |
| * See OpenFileMappingA |
| */ |
| HANDLE WINAPI OpenFileMappingW( DWORD access, BOOL inherit, LPCWSTR name) |
| { |
| OBJECT_ATTRIBUTES attr; |
| UNICODE_STRING nameW; |
| HANDLE ret; |
| NTSTATUS status; |
| |
| if (!name) |
| { |
| SetLastError( ERROR_INVALID_PARAMETER ); |
| return 0; |
| } |
| attr.Length = sizeof(attr); |
| attr.RootDirectory = 0; |
| attr.ObjectName = &nameW; |
| attr.Attributes = inherit ? OBJ_INHERIT : 0; |
| attr.SecurityDescriptor = NULL; |
| attr.SecurityQualityOfService = NULL; |
| RtlInitUnicodeString( &nameW, name ); |
| |
| if (access == FILE_MAP_COPY) access = FILE_MAP_READ; |
| |
| if ((status = NtOpenSection( &ret, access, &attr ))) |
| { |
| SetLastError( RtlNtStatusToDosError(status) ); |
| ret = 0; |
| } |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * MapViewOfFile (KERNEL32.@) |
| * Maps a view of a file into the address space |
| * |
| * RETURNS |
| * Starting address of mapped view |
| * NULL: Failure |
| */ |
| LPVOID WINAPI MapViewOfFile( |
| HANDLE mapping, /* [in] File-mapping object to map */ |
| DWORD access, /* [in] Access mode */ |
| DWORD offset_high, /* [in] High-order 32 bits of file offset */ |
| DWORD offset_low, /* [in] Low-order 32 bits of file offset */ |
| SIZE_T count /* [in] Number of bytes to map */ |
| ) { |
| return MapViewOfFileEx( mapping, access, offset_high, |
| offset_low, count, NULL ); |
| } |
| |
| |
| /*********************************************************************** |
| * MapViewOfFileEx (KERNEL32.@) |
| * Maps a view of a file into the address space |
| * |
| * RETURNS |
| * Starting address of mapped view |
| * NULL: Failure |
| */ |
| LPVOID WINAPI MapViewOfFileEx( |
| HANDLE handle, /* [in] File-mapping object to map */ |
| DWORD access, /* [in] Access mode */ |
| DWORD offset_high, /* [in] High-order 32 bits of file offset */ |
| DWORD offset_low, /* [in] Low-order 32 bits of file offset */ |
| SIZE_T count, /* [in] Number of bytes to map */ |
| LPVOID addr /* [in] Suggested starting address for mapped view */ |
| ) { |
| NTSTATUS status; |
| LARGE_INTEGER offset; |
| ULONG protect; |
| |
| offset.u.LowPart = offset_low; |
| offset.u.HighPart = offset_high; |
| |
| if (access & FILE_MAP_WRITE) protect = PAGE_READWRITE; |
| else if (access & FILE_MAP_READ) protect = PAGE_READONLY; |
| else if (access & FILE_MAP_COPY) protect = PAGE_WRITECOPY; |
| else protect = PAGE_NOACCESS; |
| |
| if ((status = NtMapViewOfSection( handle, GetCurrentProcess(), &addr, 0, 0, &offset, |
| &count, ViewShare, 0, protect ))) |
| { |
| SetLastError( RtlNtStatusToDosError(status) ); |
| addr = NULL; |
| } |
| return addr; |
| } |
| |
| |
| /*********************************************************************** |
| * UnmapViewOfFile (KERNEL32.@) |
| * Unmaps a mapped view of a file. |
| * |
| * NOTES |
| * Should addr be an LPCVOID? |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI UnmapViewOfFile( LPVOID addr ) /* [in] Address where mapped view begins */ |
| { |
| NTSTATUS status = NtUnmapViewOfSection( GetCurrentProcess(), addr ); |
| if (status) SetLastError( RtlNtStatusToDosError(status) ); |
| return !status; |
| } |
| |
| |
| /*********************************************************************** |
| * FlushViewOfFile (KERNEL32.@) |
| * Writes to the disk a byte range within a mapped view of a file |
| * |
| * RETURNS |
| * TRUE: Success |
| * FALSE: Failure |
| */ |
| BOOL WINAPI FlushViewOfFile( LPCVOID base, /* [in] Start address of byte range to flush */ |
| SIZE_T size ) /* [in] Number of bytes in range */ |
| { |
| NTSTATUS status = NtFlushVirtualMemory( GetCurrentProcess(), &base, &size, 0 ); |
| if (status) |
| { |
| if (status == STATUS_NOT_MAPPED_DATA) status = STATUS_SUCCESS; |
| else SetLastError( RtlNtStatusToDosError(status) ); |
| } |
| return !status; |
| } |
| |
| |
| /*********************************************************************** |
| * IsBadReadPtr (KERNEL32.@) |
| * |
| * RETURNS |
| * FALSE: Process has read access to entire block |
| * TRUE: Otherwise |
| */ |
| BOOL WINAPI IsBadReadPtr( |
| LPCVOID ptr, /* [in] Address of memory block */ |
| UINT size ) /* [in] Size of block */ |
| { |
| if (!size) return FALSE; /* handle 0 size case w/o reference */ |
| if (!page_size) page_size = getpagesize(); |
| __TRY |
| { |
| volatile const char *p = ptr; |
| char dummy; |
| UINT count = size; |
| |
| while (count > page_size) |
| { |
| dummy = *p; |
| p += page_size; |
| count -= page_size; |
| } |
| dummy = p[0]; |
| dummy = p[count - 1]; |
| } |
| __EXCEPT(page_fault) { return TRUE; } |
| __ENDTRY |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * IsBadWritePtr (KERNEL32.@) |
| * |
| * RETURNS |
| * FALSE: Process has write access to entire block |
| * TRUE: Otherwise |
| */ |
| BOOL WINAPI IsBadWritePtr( |
| LPVOID ptr, /* [in] Address of memory block */ |
| UINT size ) /* [in] Size of block in bytes */ |
| { |
| if (!size) return FALSE; /* handle 0 size case w/o reference */ |
| if (!page_size) page_size = getpagesize(); |
| __TRY |
| { |
| volatile char *p = ptr; |
| UINT count = size; |
| |
| while (count > page_size) |
| { |
| *p |= 0; |
| p += page_size; |
| count -= page_size; |
| } |
| p[0] |= 0; |
| p[count - 1] |= 0; |
| } |
| __EXCEPT(page_fault) { return TRUE; } |
| __ENDTRY |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * IsBadHugeReadPtr (KERNEL32.@) |
| * RETURNS |
| * FALSE: Process has read access to entire block |
| * TRUE: Otherwise |
| */ |
| BOOL WINAPI IsBadHugeReadPtr( |
| LPCVOID ptr, /* [in] Address of memory block */ |
| UINT size /* [in] Size of block */ |
| ) { |
| return IsBadReadPtr( ptr, size ); |
| } |
| |
| |
| /*********************************************************************** |
| * IsBadHugeWritePtr (KERNEL32.@) |
| * RETURNS |
| * FALSE: Process has write access to entire block |
| * TRUE: Otherwise |
| */ |
| BOOL WINAPI IsBadHugeWritePtr( |
| LPVOID ptr, /* [in] Address of memory block */ |
| UINT size /* [in] Size of block */ |
| ) { |
| return IsBadWritePtr( ptr, size ); |
| } |
| |
| |
| /*********************************************************************** |
| * IsBadCodePtr (KERNEL32.@) |
| * |
| * RETURNS |
| * FALSE: Process has read access to specified memory |
| * TRUE: Otherwise |
| */ |
| BOOL WINAPI IsBadCodePtr( FARPROC ptr ) /* [in] Address of function */ |
| { |
| return IsBadReadPtr( ptr, 1 ); |
| } |
| |
| |
| /*********************************************************************** |
| * IsBadStringPtrA (KERNEL32.@) |
| * |
| * RETURNS |
| * FALSE: Read access to all bytes in string |
| * TRUE: Else |
| */ |
| BOOL WINAPI IsBadStringPtrA( |
| LPCSTR str, /* [in] Address of string */ |
| UINT max ) /* [in] Maximum size of string */ |
| { |
| __TRY |
| { |
| volatile const char *p = str; |
| while (p != str + max) if (!*p++) break; |
| } |
| __EXCEPT(page_fault) { return TRUE; } |
| __ENDTRY |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * IsBadStringPtrW (KERNEL32.@) |
| * See IsBadStringPtrA |
| */ |
| BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT max ) |
| { |
| __TRY |
| { |
| volatile const WCHAR *p = str; |
| while (p != str + max) if (!*p++) break; |
| } |
| __EXCEPT(page_fault) { return TRUE; } |
| __ENDTRY |
| return FALSE; |
| } |
