2 * Unit test suite for Virtual* family of APIs.
4 * Copyright 2004 Dmitry Timoshkov
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wine/test.h"
30 #define MAPPING_SIZE 0x100000
32 static HINSTANCE hkernel32
;
33 static LPVOID (WINAPI
*pVirtualAllocEx
)(HANDLE
, LPVOID
, SIZE_T
, DWORD
, DWORD
);
34 static BOOL (WINAPI
*pVirtualFreeEx
)(HANDLE
, LPVOID
, SIZE_T
, DWORD
);
35 static UINT (WINAPI
*pGetWriteWatch
)(DWORD
,LPVOID
,SIZE_T
,LPVOID
*,ULONG_PTR
*,ULONG
*);
36 static UINT (WINAPI
*pResetWriteWatch
)(LPVOID
,SIZE_T
);
38 /* ############################### */
40 static HANDLE
create_target_process(const char *arg
)
43 char cmdline
[MAX_PATH
];
44 PROCESS_INFORMATION pi
;
45 STARTUPINFO si
= { 0 };
48 winetest_get_mainargs( &argv
);
49 sprintf(cmdline
, "%s %s %s", argv
[0], argv
[1], arg
);
50 ok(CreateProcess(NULL
, cmdline
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
,
51 &si
, &pi
) != 0, "error: %u\n", GetLastError());
52 ok(CloseHandle(pi
.hThread
) != 0, "error %u\n", GetLastError());
56 static void test_VirtualAllocEx(void)
58 const unsigned int alloc_size
= 1<<15;
60 SIZE_T bytes_written
= 0, bytes_read
= 0, i
;
64 MEMORY_BASIC_INFORMATION info
;
67 /* not exported in all windows-versions */
68 if ((!pVirtualAllocEx
) || (!pVirtualFreeEx
)) {
69 win_skip("Virtual{Alloc,Free}Ex not available\n");
73 hProcess
= create_target_process("sleep");
74 ok(hProcess
!= NULL
, "Can't start process\n");
76 SetLastError(0xdeadbeef);
77 addr1
= pVirtualAllocEx(hProcess
, NULL
, alloc_size
, MEM_COMMIT
,
78 PAGE_EXECUTE_READWRITE
);
79 if (!addr1
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
81 win_skip("VirtualAllocEx not implemented\n");
82 TerminateProcess(hProcess
, 0);
83 CloseHandle(hProcess
);
87 src
= VirtualAlloc( NULL
, alloc_size
, MEM_COMMIT
, PAGE_READWRITE
);
88 dst
= VirtualAlloc( NULL
, alloc_size
, MEM_COMMIT
, PAGE_READWRITE
);
89 for (i
= 0; i
< alloc_size
; i
++)
92 ok(addr1
!= NULL
, "VirtualAllocEx error %u\n", GetLastError());
93 b
= WriteProcessMemory(hProcess
, addr1
, src
, alloc_size
, &bytes_written
);
94 ok(b
&& (bytes_written
== alloc_size
), "%lu bytes written\n",
96 b
= ReadProcessMemory(hProcess
, addr1
, dst
, alloc_size
, &bytes_read
);
97 ok(b
&& (bytes_read
== alloc_size
), "%lu bytes read\n", bytes_read
);
98 ok(!memcmp(src
, dst
, alloc_size
), "Data from remote process differs\n");
100 /* test invalid source buffers */
102 b
= VirtualProtect( src
+ 0x2000, 0x2000, PAGE_NOACCESS
, &old_prot
);
103 ok( b
, "VirtualProtect failed error %u\n", GetLastError() );
104 b
= WriteProcessMemory(hProcess
, addr1
, src
, alloc_size
, &bytes_written
);
105 ok( !b
, "WriteProcessMemory succeeded\n" );
106 ok( GetLastError() == ERROR_NOACCESS
||
107 GetLastError() == ERROR_PARTIAL_COPY
, /* vista */
108 "wrong error %u\n", GetLastError() );
109 ok( bytes_written
== 0, "%lu bytes written\n", bytes_written
);
110 b
= ReadProcessMemory(hProcess
, addr1
, src
, alloc_size
, &bytes_read
);
111 ok( !b
, "ReadProcessMemory succeeded\n" );
112 ok( GetLastError() == ERROR_NOACCESS
, "wrong error %u\n", GetLastError() );
113 ok( bytes_read
== 0, "%lu bytes written\n", bytes_read
);
115 b
= VirtualProtect( src
, 0x2000, PAGE_NOACCESS
, &old_prot
);
116 ok( b
, "VirtualProtect failed error %u\n", GetLastError() );
117 b
= WriteProcessMemory(hProcess
, addr1
, src
, alloc_size
, &bytes_written
);
118 ok( !b
, "WriteProcessMemory succeeded\n" );
119 ok( GetLastError() == ERROR_NOACCESS
||
120 GetLastError() == ERROR_PARTIAL_COPY
, /* vista */
121 "wrong error %u\n", GetLastError() );
122 ok( bytes_written
== 0, "%lu bytes written\n", bytes_written
);
123 b
= ReadProcessMemory(hProcess
, addr1
, src
, alloc_size
, &bytes_read
);
124 ok( !b
, "ReadProcessMemory succeeded\n" );
125 ok( GetLastError() == ERROR_NOACCESS
, "wrong error %u\n", GetLastError() );
126 ok( bytes_read
== 0, "%lu bytes written\n", bytes_read
);
128 b
= pVirtualFreeEx(hProcess
, addr1
, 0, MEM_RELEASE
);
129 ok(b
!= 0, "VirtualFreeEx, error %u\n", GetLastError());
131 VirtualFree( src
, 0, MEM_FREE
);
132 VirtualFree( dst
, 0, MEM_FREE
);
135 * The following tests parallel those in test_VirtualAlloc()
138 SetLastError(0xdeadbeef);
139 addr1
= pVirtualAllocEx(hProcess
, 0, 0, MEM_RESERVE
, PAGE_NOACCESS
);
140 ok(addr1
== NULL
, "VirtualAllocEx should fail on zero-sized allocation\n");
141 ok(GetLastError() == ERROR_INVALID_PARAMETER
/* NT */ ||
142 GetLastError() == ERROR_NOT_ENOUGH_MEMORY
, /* Win9x */
143 "got %u, expected ERROR_INVALID_PARAMETER\n", GetLastError());
145 addr1
= pVirtualAllocEx(hProcess
, 0, 0xFFFC, MEM_RESERVE
, PAGE_NOACCESS
);
146 ok(addr1
!= NULL
, "VirtualAllocEx failed\n");
148 /* test a not committed memory */
149 memset(&info
, 'q', sizeof(info
));
150 ok(VirtualQueryEx(hProcess
, addr1
, &info
, sizeof(info
)) == sizeof(info
), "VirtualQueryEx failed\n");
151 ok(info
.BaseAddress
== addr1
, "%p != %p\n", info
.BaseAddress
, addr1
);
152 ok(info
.AllocationBase
== addr1
, "%p != %p\n", info
.AllocationBase
, addr1
);
153 ok(info
.AllocationProtect
== PAGE_NOACCESS
, "%x != PAGE_NOACCESS\n", info
.AllocationProtect
);
154 ok(info
.RegionSize
== 0x10000, "%lx != 0x10000\n", info
.RegionSize
);
155 ok(info
.State
== MEM_RESERVE
, "%x != MEM_RESERVE\n", info
.State
);
156 /* NT reports Protect == 0 for a not committed memory block */
157 ok(info
.Protect
== 0 /* NT */ ||
158 info
.Protect
== PAGE_NOACCESS
, /* Win9x */
159 "%x != PAGE_NOACCESS\n", info
.Protect
);
160 ok(info
.Type
== MEM_PRIVATE
, "%x != MEM_PRIVATE\n", info
.Type
);
162 SetLastError(0xdeadbeef);
163 ok(!VirtualProtectEx(hProcess
, addr1
, 0xFFFC, PAGE_READONLY
, &old_prot
),
164 "VirtualProtectEx should fail on a not committed memory\n");
165 ok(GetLastError() == ERROR_INVALID_ADDRESS
/* NT */ ||
166 GetLastError() == ERROR_INVALID_PARAMETER
, /* Win9x */
167 "got %u, expected ERROR_INVALID_ADDRESS\n", GetLastError());
169 addr2
= pVirtualAllocEx(hProcess
, addr1
, 0x1000, MEM_COMMIT
, PAGE_NOACCESS
);
170 ok(addr1
== addr2
, "VirtualAllocEx failed\n");
172 /* test a committed memory */
173 ok(VirtualQueryEx(hProcess
, addr1
, &info
, sizeof(info
)) == sizeof(info
),
174 "VirtualQueryEx failed\n");
175 ok(info
.BaseAddress
== addr1
, "%p != %p\n", info
.BaseAddress
, addr1
);
176 ok(info
.AllocationBase
== addr1
, "%p != %p\n", info
.AllocationBase
, addr1
);
177 ok(info
.AllocationProtect
== PAGE_NOACCESS
, "%x != PAGE_NOACCESS\n", info
.AllocationProtect
);
178 ok(info
.RegionSize
== 0x1000, "%lx != 0x1000\n", info
.RegionSize
);
179 ok(info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
180 /* this time NT reports PAGE_NOACCESS as well */
181 ok(info
.Protect
== PAGE_NOACCESS
, "%x != PAGE_NOACCESS\n", info
.Protect
);
182 ok(info
.Type
== MEM_PRIVATE
, "%x != MEM_PRIVATE\n", info
.Type
);
184 /* this should fail, since not the whole range is committed yet */
185 SetLastError(0xdeadbeef);
186 ok(!VirtualProtectEx(hProcess
, addr1
, 0xFFFC, PAGE_READONLY
, &old_prot
),
187 "VirtualProtectEx should fail on a not committed memory\n");
188 ok(GetLastError() == ERROR_INVALID_ADDRESS
/* NT */ ||
189 GetLastError() == ERROR_INVALID_PARAMETER
, /* Win9x */
190 "got %u, expected ERROR_INVALID_ADDRESS\n", GetLastError());
193 ok(VirtualProtectEx(hProcess
, addr1
, 0x1000, PAGE_READONLY
, &old_prot
), "VirtualProtectEx failed\n");
194 ok(old_prot
== PAGE_NOACCESS
, "wrong old protection: got %04x instead of PAGE_NOACCESS\n", old_prot
);
197 ok(VirtualProtectEx(hProcess
, addr1
, 0x1000, PAGE_READWRITE
, &old_prot
), "VirtualProtectEx failed\n");
198 ok(old_prot
== PAGE_READONLY
, "wrong old protection: got %04x instead of PAGE_READONLY\n", old_prot
);
200 ok(!pVirtualFreeEx(hProcess
, addr1
, 0x10000, 0),
201 "VirtualFreeEx should fail with type 0\n");
202 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
203 "got %u, expected ERROR_INVALID_PARAMETER\n", GetLastError());
205 ok(pVirtualFreeEx(hProcess
, addr1
, 0x10000, MEM_DECOMMIT
), "VirtualFreeEx failed\n");
207 /* if the type is MEM_RELEASE, size must be 0 */
208 ok(!pVirtualFreeEx(hProcess
, addr1
, 1, MEM_RELEASE
),
209 "VirtualFreeEx should fail\n");
210 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
211 "got %u, expected ERROR_INVALID_PARAMETER\n", GetLastError());
213 ok(pVirtualFreeEx(hProcess
, addr1
, 0, MEM_RELEASE
), "VirtualFreeEx failed\n");
215 TerminateProcess(hProcess
, 0);
216 CloseHandle(hProcess
);
219 static void test_VirtualAlloc(void)
223 MEMORY_BASIC_INFORMATION info
;
225 SetLastError(0xdeadbeef);
226 addr1
= VirtualAlloc(0, 0, MEM_RESERVE
, PAGE_NOACCESS
);
227 ok(addr1
== NULL
, "VirtualAlloc should fail on zero-sized allocation\n");
228 ok(GetLastError() == ERROR_INVALID_PARAMETER
/* NT */ ||
229 GetLastError() == ERROR_NOT_ENOUGH_MEMORY
, /* Win9x */
230 "got %d, expected ERROR_INVALID_PARAMETER\n", GetLastError());
232 addr1
= VirtualAlloc(0, 0xFFFC, MEM_RESERVE
, PAGE_NOACCESS
);
233 ok(addr1
!= NULL
, "VirtualAlloc failed\n");
235 /* test a not committed memory */
236 ok(VirtualQuery(addr1
, &info
, sizeof(info
)) == sizeof(info
),
237 "VirtualQuery failed\n");
238 ok(info
.BaseAddress
== addr1
, "%p != %p\n", info
.BaseAddress
, addr1
);
239 ok(info
.AllocationBase
== addr1
, "%p != %p\n", info
.AllocationBase
, addr1
);
240 ok(info
.AllocationProtect
== PAGE_NOACCESS
, "%x != PAGE_NOACCESS\n", info
.AllocationProtect
);
241 ok(info
.RegionSize
== 0x10000, "%lx != 0x10000\n", info
.RegionSize
);
242 ok(info
.State
== MEM_RESERVE
, "%x != MEM_RESERVE\n", info
.State
);
243 /* NT reports Protect == 0 for a not committed memory block */
244 ok(info
.Protect
== 0 /* NT */ ||
245 info
.Protect
== PAGE_NOACCESS
, /* Win9x */
246 "%x != PAGE_NOACCESS\n", info
.Protect
);
247 ok(info
.Type
== MEM_PRIVATE
, "%x != MEM_PRIVATE\n", info
.Type
);
249 SetLastError(0xdeadbeef);
250 ok(!VirtualProtect(addr1
, 0xFFFC, PAGE_READONLY
, &old_prot
),
251 "VirtualProtect should fail on a not committed memory\n");
252 ok(GetLastError() == ERROR_INVALID_ADDRESS
/* NT */ ||
253 GetLastError() == ERROR_INVALID_PARAMETER
, /* Win9x */
254 "got %d, expected ERROR_INVALID_ADDRESS\n", GetLastError());
256 addr2
= VirtualAlloc(addr1
, 0x1000, MEM_COMMIT
, PAGE_NOACCESS
);
257 ok(addr1
== addr2
, "VirtualAlloc failed\n");
259 /* test a committed memory */
260 ok(VirtualQuery(addr1
, &info
, sizeof(info
)) == sizeof(info
),
261 "VirtualQuery failed\n");
262 ok(info
.BaseAddress
== addr1
, "%p != %p\n", info
.BaseAddress
, addr1
);
263 ok(info
.AllocationBase
== addr1
, "%p != %p\n", info
.AllocationBase
, addr1
);
264 ok(info
.AllocationProtect
== PAGE_NOACCESS
, "%x != PAGE_NOACCESS\n", info
.AllocationProtect
);
265 ok(info
.RegionSize
== 0x1000, "%lx != 0x1000\n", info
.RegionSize
);
266 ok(info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
267 /* this time NT reports PAGE_NOACCESS as well */
268 ok(info
.Protect
== PAGE_NOACCESS
, "%x != PAGE_NOACCESS\n", info
.Protect
);
269 ok(info
.Type
== MEM_PRIVATE
, "%x != MEM_PRIVATE\n", info
.Type
);
271 /* this should fail, since not the whole range is committed yet */
272 SetLastError(0xdeadbeef);
273 ok(!VirtualProtect(addr1
, 0xFFFC, PAGE_READONLY
, &old_prot
),
274 "VirtualProtect should fail on a not committed memory\n");
275 ok(GetLastError() == ERROR_INVALID_ADDRESS
/* NT */ ||
276 GetLastError() == ERROR_INVALID_PARAMETER
, /* Win9x */
277 "got %d, expected ERROR_INVALID_ADDRESS\n", GetLastError());
279 ok(VirtualProtect(addr1
, 0x1000, PAGE_READONLY
, &old_prot
), "VirtualProtect failed\n");
280 ok(old_prot
== PAGE_NOACCESS
,
281 "wrong old protection: got %04x instead of PAGE_NOACCESS\n", old_prot
);
283 ok(VirtualProtect(addr1
, 0x1000, PAGE_READWRITE
, &old_prot
), "VirtualProtect failed\n");
284 ok(old_prot
== PAGE_READONLY
,
285 "wrong old protection: got %04x instead of PAGE_READONLY\n", old_prot
);
287 ok(VirtualQuery(addr1
, &info
, sizeof(info
)) == sizeof(info
),
288 "VirtualQuery failed\n");
289 ok(info
.RegionSize
== 0x1000, "%lx != 0x1000\n", info
.RegionSize
);
290 ok(info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
291 ok(info
.Protect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.Protect
);
292 memset( addr1
, 0x55, 20 );
293 ok( *(DWORD
*)addr1
== 0x55555555, "wrong data %x\n", *(DWORD
*)addr1
);
295 addr2
= VirtualAlloc( addr1
, 0x1000, MEM_RESET
, PAGE_NOACCESS
);
296 ok( addr2
== addr1
|| broken( !addr2
&& GetLastError() == ERROR_INVALID_PARAMETER
), /* win9x */
297 "VirtualAlloc failed err %u\n", GetLastError() );
298 ok( *(DWORD
*)addr1
== 0x55555555 || *(DWORD
*)addr1
== 0, "wrong data %x\n", *(DWORD
*)addr1
);
301 ok(VirtualQuery(addr1
, &info
, sizeof(info
)) == sizeof(info
),
302 "VirtualQuery failed\n");
303 ok(info
.RegionSize
== 0x1000, "%lx != 0x1000\n", info
.RegionSize
);
304 ok(info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
305 ok(info
.Protect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.Protect
);
307 addr2
= VirtualAlloc( (char *)addr1
+ 0x1000, 0x1000, MEM_RESET
, PAGE_NOACCESS
);
308 ok( (char *)addr2
== (char *)addr1
+ 0x1000, "VirtualAlloc failed\n" );
310 ok(VirtualQuery(addr2
, &info
, sizeof(info
)) == sizeof(info
),
311 "VirtualQuery failed\n");
312 ok(info
.RegionSize
== 0xf000, "%lx != 0xf000\n", info
.RegionSize
);
313 ok(info
.State
== MEM_RESERVE
, "%x != MEM_RESERVE\n", info
.State
);
314 ok(info
.Protect
== 0, "%x != 0\n", info
.Protect
);
316 addr2
= VirtualAlloc( (char *)addr1
+ 0xf000, 0x2000, MEM_RESET
, PAGE_NOACCESS
);
317 ok( !addr2
, "VirtualAlloc failed\n" );
318 ok( GetLastError() == ERROR_INVALID_ADDRESS
, "wrong error %u\n", GetLastError() );
321 /* invalid protection values */
322 SetLastError(0xdeadbeef);
323 addr2
= VirtualAlloc(NULL
, 0x1000, MEM_RESERVE
, 0);
324 ok(!addr2
, "VirtualAlloc succeeded\n");
325 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError());
327 SetLastError(0xdeadbeef);
328 addr2
= VirtualAlloc(NULL
, 0x1000, MEM_COMMIT
, 0);
329 ok(!addr2
, "VirtualAlloc succeeded\n");
330 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError());
332 SetLastError(0xdeadbeef);
333 addr2
= VirtualAlloc(addr1
, 0x1000, MEM_COMMIT
, PAGE_READONLY
| PAGE_EXECUTE
);
334 ok(!addr2
, "VirtualAlloc succeeded\n");
335 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError());
337 SetLastError(0xdeadbeef);
338 ok(!VirtualProtect(addr1
, 0x1000, PAGE_READWRITE
| PAGE_EXECUTE_WRITECOPY
, &old_prot
),
339 "VirtualProtect succeeded\n");
340 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError());
342 SetLastError(0xdeadbeef);
343 ok(!VirtualProtect(addr1
, 0x1000, 0, &old_prot
), "VirtualProtect succeeded\n");
344 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError());
346 SetLastError(0xdeadbeef);
347 ok(!VirtualFree(addr1
, 0x10000, 0), "VirtualFree should fail with type 0\n");
348 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
349 "got %d, expected ERROR_INVALID_PARAMETER\n", GetLastError());
351 ok(VirtualFree(addr1
, 0x10000, MEM_DECOMMIT
), "VirtualFree failed\n");
353 /* if the type is MEM_RELEASE, size must be 0 */
354 ok(!VirtualFree(addr1
, 1, MEM_RELEASE
), "VirtualFree should fail\n");
355 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
356 "got %d, expected ERROR_INVALID_PARAMETER\n", GetLastError());
358 ok(VirtualFree(addr1
, 0, MEM_RELEASE
), "VirtualFree failed\n");
361 static void test_MapViewOfFile(void)
363 static const char testfile
[] = "testfile.xxx";
365 HANDLE file
, mapping
, map2
;
366 void *ptr
, *ptr2
, *addr
;
367 MEMORY_BASIC_INFORMATION info
;
370 SetLastError(0xdeadbeef);
371 file
= CreateFileA( testfile
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
372 ok( file
!= INVALID_HANDLE_VALUE
, "CreateFile error %u\n", GetLastError() );
373 SetFilePointer( file
, 4096, NULL
, FILE_BEGIN
);
374 SetEndOfFile( file
);
376 /* read/write mapping */
378 SetLastError(0xdeadbeef);
379 mapping
= CreateFileMappingA( file
, NULL
, PAGE_READWRITE
, 0, 4096, NULL
);
380 ok( mapping
!= 0, "CreateFileMapping error %u\n", GetLastError() );
382 SetLastError(0xdeadbeef);
383 ptr
= MapViewOfFile( mapping
, FILE_MAP_READ
, 0, 0, 4096 );
384 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAPE_READ error %u\n", GetLastError() );
385 UnmapViewOfFile( ptr
);
387 /* this fails on win9x but succeeds on NT */
388 SetLastError(0xdeadbeef);
389 ptr
= MapViewOfFile( mapping
, FILE_MAP_COPY
, 0, 0, 4096 );
390 if (ptr
) UnmapViewOfFile( ptr
);
391 else ok( GetLastError() == ERROR_INVALID_PARAMETER
, "Wrong error %d\n", GetLastError() );
393 SetLastError(0xdeadbeef);
394 ptr
= MapViewOfFile( mapping
, 0, 0, 0, 4096 );
395 ok( ptr
!= NULL
, "MapViewOfFile 0 error %u\n", GetLastError() );
396 UnmapViewOfFile( ptr
);
398 SetLastError(0xdeadbeef);
399 ptr
= MapViewOfFile( mapping
, FILE_MAP_WRITE
, 0, 0, 4096 );
400 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_WRITE error %u\n", GetLastError() );
401 UnmapViewOfFile( ptr
);
403 ret
= DuplicateHandle( GetCurrentProcess(), mapping
, GetCurrentProcess(), &map2
,
404 FILE_MAP_READ
|FILE_MAP_WRITE
, FALSE
, 0 );
405 ok( ret
, "DuplicateHandle failed error %u\n", GetLastError());
406 ptr
= MapViewOfFile( map2
, FILE_MAP_WRITE
, 0, 0, 4096 );
407 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_WRITE error %u\n", GetLastError() );
408 UnmapViewOfFile( ptr
);
411 ret
= DuplicateHandle( GetCurrentProcess(), mapping
, GetCurrentProcess(), &map2
,
412 FILE_MAP_READ
, FALSE
, 0 );
413 ok( ret
, "DuplicateHandle failed error %u\n", GetLastError());
414 ptr
= MapViewOfFile( map2
, FILE_MAP_WRITE
, 0, 0, 4096 );
417 ok( GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
419 ret
= DuplicateHandle( GetCurrentProcess(), mapping
, GetCurrentProcess(), &map2
, 0, FALSE
, 0 );
420 ok( ret
, "DuplicateHandle failed error %u\n", GetLastError());
421 ptr
= MapViewOfFile( map2
, 0, 0, 0, 4096 );
422 ok( !ptr
, "MapViewOfFile succeeded\n" );
423 ok( GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
425 ret
= DuplicateHandle( GetCurrentProcess(), mapping
, GetCurrentProcess(), &map2
,
426 FILE_MAP_READ
, FALSE
, 0 );
427 ok( ret
, "DuplicateHandle failed error %u\n", GetLastError());
428 ptr
= MapViewOfFile( map2
, 0, 0, 0, 4096 );
429 ok( ptr
!= NULL
, "MapViewOfFile NO_ACCESS error %u\n", GetLastError() );
431 else win_skip( "no access checks on win9x\n" );
433 UnmapViewOfFile( ptr
);
435 CloseHandle( mapping
);
437 /* read-only mapping */
439 SetLastError(0xdeadbeef);
440 mapping
= CreateFileMappingA( file
, NULL
, PAGE_READONLY
, 0, 4096, NULL
);
441 ok( mapping
!= 0, "CreateFileMapping error %u\n", GetLastError() );
443 SetLastError(0xdeadbeef);
444 ptr
= MapViewOfFile( mapping
, FILE_MAP_READ
, 0, 0, 4096 );
445 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_READ error %u\n", GetLastError() );
446 UnmapViewOfFile( ptr
);
448 /* this fails on win9x but succeeds on NT */
449 SetLastError(0xdeadbeef);
450 ptr
= MapViewOfFile( mapping
, FILE_MAP_COPY
, 0, 0, 4096 );
451 if (ptr
) UnmapViewOfFile( ptr
);
452 else ok( GetLastError() == ERROR_INVALID_PARAMETER
, "Wrong error %d\n", GetLastError() );
454 SetLastError(0xdeadbeef);
455 ptr
= MapViewOfFile( mapping
, 0, 0, 0, 4096 );
456 ok( ptr
!= NULL
, "MapViewOfFile 0 error %u\n", GetLastError() );
457 UnmapViewOfFile( ptr
);
459 SetLastError(0xdeadbeef);
460 ptr
= MapViewOfFile( mapping
, FILE_MAP_WRITE
, 0, 0, 4096 );
461 ok( !ptr
, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
462 ok( GetLastError() == ERROR_INVALID_PARAMETER
||
463 GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
464 CloseHandle( mapping
);
466 /* copy-on-write mapping */
468 SetLastError(0xdeadbeef);
469 mapping
= CreateFileMappingA( file
, NULL
, PAGE_WRITECOPY
, 0, 4096, NULL
);
470 ok( mapping
!= 0, "CreateFileMapping error %u\n", GetLastError() );
472 SetLastError(0xdeadbeef);
473 ptr
= MapViewOfFile( mapping
, FILE_MAP_READ
, 0, 0, 4096 );
474 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_READ error %u\n", GetLastError() );
475 UnmapViewOfFile( ptr
);
477 SetLastError(0xdeadbeef);
478 ptr
= MapViewOfFile( mapping
, FILE_MAP_COPY
, 0, 0, 4096 );
479 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_COPY error %u\n", GetLastError() );
480 UnmapViewOfFile( ptr
);
482 SetLastError(0xdeadbeef);
483 ptr
= MapViewOfFile( mapping
, 0, 0, 0, 4096 );
484 ok( ptr
!= NULL
, "MapViewOfFile 0 error %u\n", GetLastError() );
485 UnmapViewOfFile( ptr
);
487 SetLastError(0xdeadbeef);
488 ptr
= MapViewOfFile( mapping
, FILE_MAP_WRITE
, 0, 0, 4096 );
489 ok( !ptr
, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
490 ok( GetLastError() == ERROR_INVALID_PARAMETER
||
491 GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
492 CloseHandle( mapping
);
494 /* no access mapping */
496 SetLastError(0xdeadbeef);
497 mapping
= CreateFileMappingA( file
, NULL
, PAGE_NOACCESS
, 0, 4096, NULL
);
498 /* fails on NT but succeeds on win9x */
499 if (!mapping
) ok( GetLastError() == ERROR_INVALID_PARAMETER
, "Wrong error %d\n", GetLastError() );
502 SetLastError(0xdeadbeef);
503 ptr
= MapViewOfFile( mapping
, FILE_MAP_READ
, 0, 0, 4096 );
504 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_READ error %u\n", GetLastError() );
505 UnmapViewOfFile( ptr
);
507 SetLastError(0xdeadbeef);
508 ptr
= MapViewOfFile( mapping
, FILE_MAP_COPY
, 0, 0, 4096 );
509 ok( !ptr
, "MapViewOfFile FILE_MAP_COPY succeeded\n" );
510 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "Wrong error %d\n", GetLastError() );
512 SetLastError(0xdeadbeef);
513 ptr
= MapViewOfFile( mapping
, 0, 0, 0, 4096 );
514 ok( ptr
!= NULL
, "MapViewOfFile 0 error %u\n", GetLastError() );
515 UnmapViewOfFile( ptr
);
517 SetLastError(0xdeadbeef);
518 ptr
= MapViewOfFile( mapping
, FILE_MAP_WRITE
, 0, 0, 4096 );
519 ok( !ptr
, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
520 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "Wrong error %d\n", GetLastError() );
522 CloseHandle( mapping
);
527 /* now try read-only file */
529 SetLastError(0xdeadbeef);
530 file
= CreateFileA( testfile
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
531 ok( file
!= INVALID_HANDLE_VALUE
, "CreateFile error %u\n", GetLastError() );
533 SetLastError(0xdeadbeef);
534 mapping
= CreateFileMappingA( file
, NULL
, PAGE_READWRITE
, 0, 4096, NULL
);
535 ok( !mapping
, "CreateFileMapping PAGE_READWRITE succeeded\n" );
536 ok( GetLastError() == ERROR_INVALID_PARAMETER
||
537 GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
539 SetLastError(0xdeadbeef);
540 mapping
= CreateFileMappingA( file
, NULL
, PAGE_WRITECOPY
, 0, 4096, NULL
);
541 ok( mapping
!= 0, "CreateFileMapping PAGE_WRITECOPY error %u\n", GetLastError() );
542 CloseHandle( mapping
);
544 SetLastError(0xdeadbeef);
545 mapping
= CreateFileMappingA( file
, NULL
, PAGE_READONLY
, 0, 4096, NULL
);
546 ok( mapping
!= 0, "CreateFileMapping PAGE_READONLY error %u\n", GetLastError() );
547 CloseHandle( mapping
);
550 /* now try no access file */
552 SetLastError(0xdeadbeef);
553 file
= CreateFileA( testfile
, 0, 0, NULL
, OPEN_EXISTING
, 0, 0 );
554 ok( file
!= INVALID_HANDLE_VALUE
, "CreateFile error %u\n", GetLastError() );
556 SetLastError(0xdeadbeef);
557 mapping
= CreateFileMappingA( file
, NULL
, PAGE_READWRITE
, 0, 4096, NULL
);
558 ok( !mapping
, "CreateFileMapping PAGE_READWRITE succeeded\n" );
559 ok( GetLastError() == ERROR_INVALID_PARAMETER
||
560 GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
562 SetLastError(0xdeadbeef);
563 mapping
= CreateFileMappingA( file
, NULL
, PAGE_WRITECOPY
, 0, 4096, NULL
);
564 ok( !mapping
, "CreateFileMapping PAGE_WRITECOPY succeeded\n" );
565 ok( GetLastError() == ERROR_INVALID_PARAMETER
||
566 GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
568 SetLastError(0xdeadbeef);
569 mapping
= CreateFileMappingA( file
, NULL
, PAGE_READONLY
, 0, 4096, NULL
);
570 ok( !mapping
, "CreateFileMapping PAGE_READONLY succeeded\n" );
571 ok( GetLastError() == ERROR_INVALID_PARAMETER
||
572 GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
575 DeleteFileA( testfile
);
577 SetLastError(0xdeadbeef);
579 file
= CreateFileMapping( INVALID_HANDLE_VALUE
, NULL
, PAGE_READWRITE
, 0, 4096, name
);
580 /* nt4 doesn't have Local\\ */
581 if (!file
&& GetLastError() == ERROR_PATH_NOT_FOUND
)
584 file
= CreateFileMapping( INVALID_HANDLE_VALUE
, NULL
, PAGE_READWRITE
, 0, 4096, name
);
586 ok( file
!= 0, "CreateFileMapping PAGE_READWRITE error %u\n", GetLastError() );
588 SetLastError(0xdeadbeef);
589 mapping
= OpenFileMapping( FILE_MAP_READ
, FALSE
, name
);
590 ok( mapping
!= 0, "OpenFileMapping FILE_MAP_READ error %u\n", GetLastError() );
591 SetLastError(0xdeadbeef);
592 ptr
= MapViewOfFile( mapping
, FILE_MAP_WRITE
, 0, 0, 0 );
595 ok( GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
596 SetLastError(0xdeadbeef);
597 ptr
= MapViewOfFile( mapping
, FILE_MAP_READ
, 0, 0, 0 );
598 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_READ error %u\n", GetLastError() );
599 SetLastError(0xdeadbeef);
600 ok( VirtualQuery( ptr
, &info
, sizeof(info
) ) == sizeof(info
),
601 "VirtualQuery error %u\n", GetLastError() );
602 ok( info
.BaseAddress
== ptr
, "%p != %p\n", info
.BaseAddress
, ptr
);
603 ok( info
.AllocationBase
== ptr
, "%p != %p\n", info
.AllocationBase
, ptr
);
604 ok( info
.AllocationProtect
== PAGE_READONLY
, "%x != PAGE_READONLY\n", info
.AllocationProtect
);
605 ok( info
.RegionSize
== 4096, "%lx != 4096\n", info
.RegionSize
);
606 ok( info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
607 ok( info
.Protect
== PAGE_READONLY
, "%x != PAGE_READONLY\n", info
.Protect
);
609 else win_skip( "no access checks on win9x\n" );
610 UnmapViewOfFile( ptr
);
611 CloseHandle( mapping
);
613 SetLastError(0xdeadbeef);
614 mapping
= OpenFileMapping( FILE_MAP_WRITE
, FALSE
, name
);
615 ok( mapping
!= 0, "OpenFileMapping FILE_MAP_WRITE error %u\n", GetLastError() );
616 SetLastError(0xdeadbeef);
617 ptr
= MapViewOfFile( mapping
, FILE_MAP_READ
, 0, 0, 0 );
620 ok( GetLastError() == ERROR_ACCESS_DENIED
, "Wrong error %d\n", GetLastError() );
621 SetLastError(0xdeadbeef);
622 ptr
= MapViewOfFile( mapping
, FILE_MAP_WRITE
, 0, 0, 0 );
623 ok( ptr
!= NULL
, "MapViewOfFile FILE_MAP_WRITE error %u\n", GetLastError() );
624 SetLastError(0xdeadbeef);
625 ok( VirtualQuery( ptr
, &info
, sizeof(info
) ) == sizeof(info
),
626 "VirtualQuery error %u\n", GetLastError() );
627 ok( info
.BaseAddress
== ptr
, "%p != %p\n", info
.BaseAddress
, ptr
);
628 ok( info
.AllocationBase
== ptr
, "%p != %p\n", info
.AllocationBase
, ptr
);
629 ok( info
.AllocationProtect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.AllocationProtect
);
630 ok( info
.RegionSize
== 4096, "%lx != 4096\n", info
.RegionSize
);
631 ok( info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
632 ok( info
.Protect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.Protect
);
634 else win_skip( "no access checks on win9x\n" );
635 UnmapViewOfFile( ptr
);
636 CloseHandle( mapping
);
640 /* read/write mapping with SEC_RESERVE */
641 mapping
= CreateFileMappingA(INVALID_HANDLE_VALUE
, NULL
, PAGE_READWRITE
| SEC_RESERVE
, 0, MAPPING_SIZE
, NULL
);
642 ok(mapping
!= INVALID_HANDLE_VALUE
, "CreateFileMappingA failed with error %d\n", GetLastError());
644 ptr
= MapViewOfFile(mapping
, FILE_MAP_WRITE
, 0, 0, 0);
645 ok(ptr
!= NULL
, "MapViewOfFile failed with error %d\n", GetLastError());
647 ptr2
= MapViewOfFile(mapping
, FILE_MAP_WRITE
, 0, 0, 0);
648 /* on NT ptr != ptr2 but on Win9x ptr == ptr2 */
649 ok(ptr2
!= NULL
, "MapViewOfFile failed with error %d\n", GetLastError());
650 trace("mapping same section resulted in views %p and %p\n", ptr
, ptr2
);
652 ret
= VirtualQuery(ptr
, &info
, sizeof(info
));
653 ok(ret
, "VirtualQuery failed with error %d\n", GetLastError());
654 ok(info
.BaseAddress
== ptr
, "BaseAddress should have been %p but was %p instead\n", ptr
, info
.BaseAddress
);
655 ok(info
.AllocationBase
== ptr
, "AllocationBase should have been %p but was %p instead\n", ptr
, info
.AllocationBase
);
656 ok(info
.RegionSize
== MAPPING_SIZE
, "RegionSize should have been 0x%x but was 0x%x\n", MAPPING_SIZE
, (unsigned int)info
.RegionSize
);
657 ok(info
.State
== MEM_RESERVE
, "State should have been MEM_RESERVE instead of 0x%x\n", info
.State
);
658 if (info
.Type
== MEM_PRIVATE
) /* win9x is different for uncommitted mappings */
660 ok(info
.AllocationProtect
== PAGE_NOACCESS
,
661 "AllocationProtect should have been PAGE_NOACCESS but was 0x%x\n", info
.AllocationProtect
);
662 ok(info
.Protect
== PAGE_NOACCESS
,
663 "Protect should have been PAGE_NOACCESS instead of 0x%x\n", info
.Protect
);
667 ok(info
.AllocationProtect
== PAGE_READWRITE
,
668 "AllocationProtect should have been PAGE_READWRITE but was 0x%x\n", info
.AllocationProtect
);
669 ok(info
.Protect
== 0, "Protect should have been 0 instead of 0x%x\n", info
.Protect
);
670 ok(info
.Type
== MEM_MAPPED
, "Type should have been MEM_MAPPED instead of 0x%x\n", info
.Type
);
675 ret
= VirtualQuery(ptr2
, &info
, sizeof(info
));
676 ok(ret
, "VirtualQuery failed with error %d\n", GetLastError());
677 ok(info
.BaseAddress
== ptr2
,
678 "BaseAddress should have been %p but was %p instead\n", ptr2
, info
.BaseAddress
);
679 ok(info
.AllocationBase
== ptr2
,
680 "AllocationBase should have been %p but was %p instead\n", ptr2
, info
.AllocationBase
);
681 ok(info
.AllocationProtect
== PAGE_READWRITE
,
682 "AllocationProtect should have been PAGE_READWRITE but was 0x%x\n", info
.AllocationProtect
);
683 ok(info
.RegionSize
== MAPPING_SIZE
,
684 "RegionSize should have been 0x%x but was 0x%x\n", MAPPING_SIZE
, (unsigned int)info
.RegionSize
);
685 ok(info
.State
== MEM_RESERVE
,
686 "State should have been MEM_RESERVE instead of 0x%x\n", info
.State
);
687 ok(info
.Protect
== 0,
688 "Protect should have been 0 instead of 0x%x\n", info
.Protect
);
689 ok(info
.Type
== MEM_MAPPED
,
690 "Type should have been MEM_MAPPED instead of 0x%x\n", info
.Type
);
693 ptr
= VirtualAlloc(ptr
, 0x10000, MEM_COMMIT
, PAGE_READONLY
);
694 ok(ptr
!= NULL
, "VirtualAlloc failed with error %d\n", GetLastError());
696 ret
= VirtualQuery(ptr
, &info
, sizeof(info
));
697 ok(ret
, "VirtualQuery failed with error %d\n", GetLastError());
698 ok(info
.BaseAddress
== ptr
, "BaseAddress should have been %p but was %p instead\n", ptr
, info
.BaseAddress
);
699 ok(info
.AllocationBase
== ptr
, "AllocationBase should have been %p but was %p instead\n", ptr
, info
.AllocationBase
);
700 ok(info
.RegionSize
== 0x10000, "RegionSize should have been 0x10000 but was 0x%x\n", (unsigned int)info
.RegionSize
);
701 ok(info
.State
== MEM_COMMIT
, "State should have been MEM_RESERVE instead of 0x%x\n", info
.State
);
702 ok(info
.Protect
== PAGE_READONLY
, "Protect should have been 0 instead of 0x%x\n", info
.Protect
);
703 if (info
.Type
== MEM_PRIVATE
) /* win9x is different for uncommitted mappings */
705 ok(info
.AllocationProtect
== PAGE_NOACCESS
,
706 "AllocationProtect should have been PAGE_NOACCESS but was 0x%x\n", info
.AllocationProtect
);
710 ok(info
.AllocationProtect
== PAGE_READWRITE
,
711 "AllocationProtect should have been PAGE_READWRITE but was 0x%x\n", info
.AllocationProtect
);
712 ok(info
.Type
== MEM_MAPPED
, "Type should have been MEM_MAPPED instead of 0x%x\n", info
.Type
);
715 /* shows that the VirtualAlloc above affects the mapping, not just the
716 * virtual memory in this process - it also affects all other processes
717 * with a view of the mapping, but that isn't tested here */
720 ret
= VirtualQuery(ptr2
, &info
, sizeof(info
));
721 ok(ret
, "VirtualQuery failed with error %d\n", GetLastError());
722 ok(info
.BaseAddress
== ptr2
,
723 "BaseAddress should have been %p but was %p instead\n", ptr2
, info
.BaseAddress
);
724 ok(info
.AllocationBase
== ptr2
,
725 "AllocationBase should have been %p but was %p instead\n", ptr2
, info
.AllocationBase
);
726 ok(info
.AllocationProtect
== PAGE_READWRITE
,
727 "AllocationProtect should have been PAGE_READWRITE but was 0x%x\n", info
.AllocationProtect
);
728 ok(info
.RegionSize
== 0x10000,
729 "RegionSize should have been 0x10000 but was 0x%x\n", (unsigned int)info
.RegionSize
);
730 ok(info
.State
== MEM_COMMIT
,
731 "State should have been MEM_RESERVE instead of 0x%x\n", info
.State
);
732 ok(info
.Protect
== PAGE_READWRITE
,
733 "Protect should have been 0 instead of 0x%x\n", info
.Protect
);
734 ok(info
.Type
== MEM_MAPPED
, "Type should have been MEM_MAPPED instead of 0x%x\n", info
.Type
);
737 addr
= VirtualAlloc( ptr
, MAPPING_SIZE
, MEM_RESET
, PAGE_READONLY
);
738 ok( addr
== ptr
|| broken(!addr
&& GetLastError() == ERROR_INVALID_PARAMETER
), /* win9x */
739 "VirtualAlloc failed with error %u\n", GetLastError() );
741 ret
= VirtualFree( ptr
, 0x10000, MEM_DECOMMIT
);
742 ok( !ret
|| broken(ret
) /* win9x */, "VirtualFree succeeded\n" );
744 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "VirtualFree failed with %u\n", GetLastError() );
746 ret
= UnmapViewOfFile(ptr2
);
747 ok(ret
, "UnmapViewOfFile failed with error %d\n", GetLastError());
748 ret
= UnmapViewOfFile(ptr
);
749 ok(ret
, "UnmapViewOfFile failed with error %d\n", GetLastError());
750 CloseHandle(mapping
);
752 addr
= VirtualAlloc(NULL
, 0x10000, MEM_COMMIT
, PAGE_READONLY
);
753 ok( addr
!= NULL
, "VirtualAlloc failed with error %u\n", GetLastError() );
755 SetLastError(0xdeadbeef);
756 ok( !UnmapViewOfFile(addr
), "UnmapViewOfFile should fail on VirtualAlloc mem\n" );
757 ok( GetLastError() == ERROR_INVALID_ADDRESS
,
758 "got %u, expected ERROR_INVALID_ADDRESS\n", GetLastError());
759 SetLastError(0xdeadbeef);
760 ok( !UnmapViewOfFile((char *)addr
+ 0x3000), "UnmapViewOfFile should fail on VirtualAlloc mem\n" );
761 ok( GetLastError() == ERROR_INVALID_ADDRESS
,
762 "got %u, expected ERROR_INVALID_ADDRESS\n", GetLastError());
763 SetLastError(0xdeadbeef);
764 ok( !UnmapViewOfFile((void *)0xdeadbeef), "UnmapViewOfFile should fail on VirtualAlloc mem\n" );
765 ok( GetLastError() == ERROR_INVALID_ADDRESS
,
766 "got %u, expected ERROR_INVALID_ADDRESS\n", GetLastError());
768 ok( VirtualFree(addr
, 0, MEM_RELEASE
), "VirtualFree failed\n" );
771 static DWORD (WINAPI
*pNtMapViewOfSection
)( HANDLE handle
, HANDLE process
, PVOID
*addr_ptr
,
772 ULONG zero_bits
, SIZE_T commit_size
,
773 const LARGE_INTEGER
*offset_ptr
, SIZE_T
*size_ptr
,
774 ULONG inherit
, ULONG alloc_type
, ULONG protect
);
775 static DWORD (WINAPI
*pNtUnmapViewOfSection
)( HANDLE process
, PVOID addr
);
777 static void test_NtMapViewOfSection(void)
781 static const char testfile
[] = "testfile.xxx";
782 static const char data
[] = "test data for NtMapViewOfSection";
783 char buffer
[sizeof(data
)];
784 HANDLE file
, mapping
;
787 DWORD status
, written
;
789 LARGE_INTEGER offset
;
791 pNtMapViewOfSection
= (void *)GetProcAddress( GetModuleHandle("ntdll.dll"), "NtMapViewOfSection" );
792 pNtUnmapViewOfSection
= (void *)GetProcAddress( GetModuleHandle("ntdll.dll"), "NtUnmapViewOfSection" );
793 if (!pNtMapViewOfSection
|| !pNtUnmapViewOfSection
)
795 win_skip( "NtMapViewOfSection not available\n" );
799 file
= CreateFileA( testfile
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
800 ok( file
!= INVALID_HANDLE_VALUE
, "Failed to create test file\n" );
801 WriteFile( file
, data
, sizeof(data
), &written
, NULL
);
802 SetFilePointer( file
, 4096, NULL
, FILE_BEGIN
);
803 SetEndOfFile( file
);
805 /* read/write mapping */
807 mapping
= CreateFileMappingA( file
, NULL
, PAGE_READWRITE
, 0, 4096, NULL
);
808 ok( mapping
!= 0, "CreateFileMapping failed\n" );
810 hProcess
= create_target_process("sleep");
811 ok(hProcess
!= NULL
, "Can't start process\n");
816 status
= pNtMapViewOfSection( mapping
, hProcess
, &ptr
, 0, 0, &offset
, &size
, 1, 0, PAGE_READWRITE
);
817 ok( !status
, "NtMapViewOfSection failed status %x\n", status
);
819 ret
= ReadProcessMemory( hProcess
, ptr
, buffer
, sizeof(buffer
), &result
);
820 ok( ret
, "ReadProcessMemory failed\n" );
821 ok( result
== sizeof(buffer
), "ReadProcessMemory didn't read all data (%lx)\n", result
);
822 ok( !memcmp( buffer
, data
, sizeof(buffer
) ), "Wrong data read\n" );
824 status
= pNtUnmapViewOfSection( hProcess
, ptr
);
825 ok( !status
, "NtUnmapViewOfSection failed status %x\n", status
);
827 CloseHandle( mapping
);
829 DeleteFileA( testfile
);
831 TerminateProcess(hProcess
, 0);
832 CloseHandle(hProcess
);
835 static void test_CreateFileMapping(void)
837 HANDLE handle
, handle2
;
839 /* test case sensitivity */
841 SetLastError(0xdeadbeef);
842 handle
= CreateFileMappingA( INVALID_HANDLE_VALUE
, NULL
, SEC_COMMIT
| PAGE_READWRITE
, 0, 0x1000,
843 "Wine Test Mapping");
844 ok( handle
!= NULL
, "CreateFileMapping failed with error %u\n", GetLastError());
845 ok( GetLastError() == 0, "wrong error %u\n", GetLastError());
847 SetLastError(0xdeadbeef);
848 handle2
= CreateFileMappingA( INVALID_HANDLE_VALUE
, NULL
, SEC_COMMIT
| PAGE_READWRITE
, 0, 0x1000,
849 "Wine Test Mapping");
850 ok( handle2
!= NULL
, "CreateFileMapping failed with error %d\n", GetLastError());
851 ok( GetLastError() == ERROR_ALREADY_EXISTS
, "wrong error %u\n", GetLastError());
852 CloseHandle( handle2
);
854 SetLastError(0xdeadbeef);
855 handle2
= CreateFileMappingA( INVALID_HANDLE_VALUE
, NULL
, SEC_COMMIT
| PAGE_READWRITE
, 0, 0x1000,
856 "WINE TEST MAPPING");
857 ok( handle2
!= NULL
, "CreateFileMapping failed with error %d\n", GetLastError());
858 ok( GetLastError() == 0, "wrong error %u\n", GetLastError());
859 CloseHandle( handle2
);
861 SetLastError(0xdeadbeef);
862 handle2
= OpenFileMappingA( FILE_MAP_ALL_ACCESS
, FALSE
, "Wine Test Mapping");
863 ok( handle2
!= NULL
, "OpenFileMapping failed with error %d\n", GetLastError());
864 CloseHandle( handle2
);
866 SetLastError(0xdeadbeef);
867 handle2
= OpenFileMappingA( FILE_MAP_ALL_ACCESS
, FALSE
, "WINE TEST MAPPING");
868 ok( !handle2
, "OpenFileMapping succeeded\n");
869 ok( GetLastError() == ERROR_FILE_NOT_FOUND
|| GetLastError() == ERROR_INVALID_NAME
/* win9x */,
870 "wrong error %u\n", GetLastError());
872 CloseHandle( handle
);
875 static void test_BadPtr(void)
877 void *ptr
= (void*)1;
878 /* We assume address 1 is not mapped. */
879 ok(IsBadReadPtr(ptr
,1),"IsBadReadPtr(1) failed.\n");
880 ok(IsBadWritePtr(ptr
,1),"IsBadWritePtr(1) failed.\n");
881 ok(IsBadCodePtr(ptr
),"IsBadCodePtr(1) failed.\n");
884 static void test_write_watch(void)
887 DWORD ret
, size
, old_prot
;
888 MEMORY_BASIC_INFORMATION info
;
893 if (!pGetWriteWatch
|| !pResetWriteWatch
)
895 win_skip( "GetWriteWatch not supported\n" );
900 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_COMMIT
| MEM_WRITE_WATCH
, PAGE_READWRITE
);
902 (GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == ERROR_NOT_SUPPORTED
))
904 win_skip( "MEM_WRITE_WATCH not supported\n" );
907 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
908 ret
= VirtualQuery( base
, &info
, sizeof(info
) );
909 ok(ret
, "VirtualQuery failed %u\n", GetLastError());
910 ok( info
.BaseAddress
== base
, "BaseAddress %p instead of %p\n", info
.BaseAddress
, base
);
911 ok( info
.AllocationProtect
== PAGE_READWRITE
, "wrong AllocationProtect %x\n", info
.AllocationProtect
);
912 ok( info
.RegionSize
== size
, "wrong RegionSize 0x%lx\n", info
.RegionSize
);
913 ok( info
.State
== MEM_COMMIT
, "wrong State 0x%x\n", info
.State
);
914 ok( info
.Protect
== PAGE_READWRITE
, "wrong Protect 0x%x\n", info
.Protect
);
915 ok( info
.Type
== MEM_PRIVATE
, "wrong Type 0x%x\n", info
.Type
);
918 SetLastError( 0xdeadbeef );
919 ret
= pGetWriteWatch( 0, NULL
, size
, results
, &count
, &pagesize
);
920 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
921 ok( GetLastError() == ERROR_INVALID_PARAMETER
||
922 broken( GetLastError() == 0xdeadbeef ), /* win98 */
923 "wrong error %u\n", GetLastError() );
925 SetLastError( 0xdeadbeef );
926 ret
= pGetWriteWatch( 0, GetModuleHandle(0), size
, results
, &count
, &pagesize
);
929 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
930 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
934 ok( count
== 0, "wrong count %lu\n", count
);
937 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
938 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
939 ok( count
== 0, "wrong count %lu\n", count
);
941 base
[pagesize
+ 1] = 0x44;
944 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
945 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
946 ok( count
== 1, "wrong count %lu\n", count
);
947 ok( results
[0] == base
+ pagesize
, "wrong result %p\n", results
[0] );
950 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
951 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
952 ok( count
== 1, "wrong count %lu\n", count
);
953 ok( results
[0] == base
+ pagesize
, "wrong result %p\n", results
[0] );
956 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
957 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
958 ok( count
== 0, "wrong count %lu\n", count
);
960 base
[2*pagesize
+ 3] = 0x11;
961 base
[4*pagesize
+ 8] = 0x11;
964 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
965 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
966 ok( count
== 2, "wrong count %lu\n", count
);
967 ok( results
[0] == base
+ 2*pagesize
, "wrong result %p\n", results
[0] );
968 ok( results
[1] == base
+ 4*pagesize
, "wrong result %p\n", results
[1] );
971 ret
= pGetWriteWatch( 0, base
+ 3*pagesize
, 2*pagesize
, results
, &count
, &pagesize
);
972 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
973 ok( count
== 1, "wrong count %lu\n", count
);
974 ok( results
[0] == base
+ 4*pagesize
, "wrong result %p\n", results
[0] );
976 ret
= pResetWriteWatch( base
, 3*pagesize
);
977 ok( !ret
, "pResetWriteWatch failed %u\n", GetLastError() );
980 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
981 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
982 ok( count
== 1, "wrong count %lu\n", count
);
983 ok( results
[0] == base
+ 4*pagesize
, "wrong result %p\n", results
[0] );
985 *(DWORD
*)(base
+ 2*pagesize
- 2) = 0xdeadbeef;
988 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
989 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
990 ok( count
== 3, "wrong count %lu\n", count
);
991 ok( results
[0] == base
+ pagesize
, "wrong result %p\n", results
[0] );
992 ok( results
[1] == base
+ 2*pagesize
, "wrong result %p\n", results
[1] );
993 ok( results
[2] == base
+ 4*pagesize
, "wrong result %p\n", results
[2] );
996 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
997 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
998 ok( count
== 1, "wrong count %lu\n", count
);
999 ok( results
[0] == base
+ pagesize
, "wrong result %p\n", results
[0] );
1002 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
1003 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
1004 ok( count
== 2, "wrong count %lu\n", count
);
1005 ok( results
[0] == base
+ 2*pagesize
, "wrong result %p\n", results
[0] );
1006 ok( results
[1] == base
+ 4*pagesize
, "wrong result %p\n", results
[1] );
1008 /* changing protections doesn't affect watches */
1010 ret
= VirtualProtect( base
, 3*pagesize
, PAGE_READONLY
, &old_prot
);
1011 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
1012 ok( old_prot
== PAGE_READWRITE
, "wrong old prot %x\n", old_prot
);
1014 ret
= VirtualQuery( base
, &info
, sizeof(info
) );
1015 ok(ret
, "VirtualQuery failed %u\n", GetLastError());
1016 ok( info
.BaseAddress
== base
, "BaseAddress %p instead of %p\n", info
.BaseAddress
, base
);
1017 ok( info
.RegionSize
== 3*pagesize
, "wrong RegionSize 0x%lx\n", info
.RegionSize
);
1018 ok( info
.State
== MEM_COMMIT
, "wrong State 0x%x\n", info
.State
);
1019 ok( info
.Protect
== PAGE_READONLY
, "wrong Protect 0x%x\n", info
.Protect
);
1021 ret
= VirtualProtect( base
, 3*pagesize
, PAGE_READWRITE
, &old_prot
);
1022 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
1023 ok( old_prot
== PAGE_READONLY
, "wrong old prot %x\n", old_prot
);
1026 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
1027 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
1028 ok( count
== 2, "wrong count %lu\n", count
);
1029 ok( results
[0] == base
+ 2*pagesize
, "wrong result %p\n", results
[0] );
1030 ok( results
[1] == base
+ 4*pagesize
, "wrong result %p\n", results
[1] );
1032 ret
= VirtualQuery( base
, &info
, sizeof(info
) );
1033 ok(ret
, "VirtualQuery failed %u\n", GetLastError());
1034 ok( info
.BaseAddress
== base
, "BaseAddress %p instead of %p\n", info
.BaseAddress
, base
);
1035 ok( info
.RegionSize
== size
, "wrong RegionSize 0x%lx\n", info
.RegionSize
);
1036 ok( info
.State
== MEM_COMMIT
, "wrong State 0x%x\n", info
.State
);
1037 ok( info
.Protect
== PAGE_READWRITE
, "wrong Protect 0x%x\n", info
.Protect
);
1039 /* some invalid parameter tests */
1041 SetLastError( 0xdeadbeef );
1043 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
1046 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1047 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1049 SetLastError( 0xdeadbeef );
1050 ret
= pGetWriteWatch( 0, base
, size
, results
, NULL
, &pagesize
);
1051 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1052 ok( GetLastError() == ERROR_NOACCESS
, "wrong error %u\n", GetLastError() );
1054 SetLastError( 0xdeadbeef );
1056 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, NULL
);
1057 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1058 ok( GetLastError() == ERROR_NOACCESS
, "wrong error %u\n", GetLastError() );
1060 SetLastError( 0xdeadbeef );
1062 ret
= pGetWriteWatch( 0, base
, size
, NULL
, &count
, &pagesize
);
1063 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1064 ok( GetLastError() == ERROR_NOACCESS
, "wrong error %u\n", GetLastError() );
1066 SetLastError( 0xdeadbeef );
1068 ret
= pGetWriteWatch( 0, base
, size
, NULL
, &count
, &pagesize
);
1069 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1070 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1072 SetLastError( 0xdeadbeef );
1074 ret
= pGetWriteWatch( 0xdeadbeef, base
, size
, results
, &count
, &pagesize
);
1075 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1076 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1078 SetLastError( 0xdeadbeef );
1080 ret
= pGetWriteWatch( 0, base
, 0, results
, &count
, &pagesize
);
1081 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1082 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1084 SetLastError( 0xdeadbeef );
1086 ret
= pGetWriteWatch( 0, base
, size
* 2, results
, &count
, &pagesize
);
1087 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1088 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1090 SetLastError( 0xdeadbeef );
1092 ret
= pGetWriteWatch( 0, base
+ size
- pagesize
, pagesize
+ 1, results
, &count
, &pagesize
);
1093 ok( ret
== ~0u, "GetWriteWatch succeeded %u\n", ret
);
1094 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1096 SetLastError( 0xdeadbeef );
1097 ret
= pResetWriteWatch( base
, 0 );
1098 ok( ret
== ~0u, "ResetWriteWatch succeeded %u\n", ret
);
1099 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1101 SetLastError( 0xdeadbeef );
1102 ret
= pResetWriteWatch( GetModuleHandle(0), size
);
1103 ok( ret
== ~0u, "ResetWriteWatch succeeded %u\n", ret
);
1104 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1106 else /* win98 is completely different */
1108 SetLastError( 0xdeadbeef );
1110 ret
= pGetWriteWatch( 0, base
, size
, NULL
, &count
, &pagesize
);
1111 ok( ret
== ERROR_INVALID_PARAMETER
, "GetWriteWatch succeeded %u\n", ret
);
1112 ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() );
1115 ret
= pGetWriteWatch( 0, base
, size
, NULL
, &count
, &pagesize
);
1116 ok( !ret
, "GetWriteWatch failed %u\n", ret
);
1119 ret
= pGetWriteWatch( 0xdeadbeef, base
, size
, results
, &count
, &pagesize
);
1120 ok( !ret
, "GetWriteWatch failed %u\n", ret
);
1123 ret
= pGetWriteWatch( 0, base
, 0, results
, &count
, &pagesize
);
1124 ok( !ret
, "GetWriteWatch failed %u\n", ret
);
1126 ret
= pResetWriteWatch( base
, 0 );
1127 ok( !ret
, "ResetWriteWatch failed %u\n", ret
);
1129 ret
= pResetWriteWatch( GetModuleHandle(0), size
);
1130 ok( !ret
, "ResetWriteWatch failed %u\n", ret
);
1133 VirtualFree( base
, 0, MEM_FREE
);
1135 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_WRITE_WATCH
, PAGE_READWRITE
);
1136 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
1137 VirtualFree( base
, 0, MEM_FREE
);
1139 base
= VirtualAlloc( 0, size
, MEM_WRITE_WATCH
, PAGE_READWRITE
);
1140 ok( !base
, "VirtualAlloc succeeded\n" );
1141 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError() );
1143 /* initial protect doesn't matter */
1145 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_WRITE_WATCH
, PAGE_NOACCESS
);
1146 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
1147 base
= VirtualAlloc( base
, size
, MEM_COMMIT
, PAGE_NOACCESS
);
1148 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
1151 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
1152 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
1153 ok( count
== 0, "wrong count %lu\n", count
);
1155 ret
= VirtualProtect( base
, 6*pagesize
, PAGE_READWRITE
, &old_prot
);
1156 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
1157 ok( old_prot
== PAGE_NOACCESS
, "wrong old prot %x\n", old_prot
);
1159 base
[5*pagesize
+ 200] = 3;
1161 ret
= VirtualProtect( base
, 6*pagesize
, PAGE_NOACCESS
, &old_prot
);
1162 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
1163 ok( old_prot
== PAGE_READWRITE
, "wrong old prot %x\n", old_prot
);
1166 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
1167 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
1168 ok( count
== 1, "wrong count %lu\n", count
);
1169 ok( results
[0] == base
+ 5*pagesize
, "wrong result %p\n", results
[0] );
1171 ret
= VirtualFree( base
, size
, MEM_DECOMMIT
);
1172 ok( ret
, "VirtualFree failed %u\n", GetLastError() );
1175 ret
= pGetWriteWatch( 0, base
, size
, results
, &count
, &pagesize
);
1176 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
1177 ok( count
== 1 || broken(count
== 0), /* win98 */
1178 "wrong count %lu\n", count
);
1179 if (count
) ok( results
[0] == base
+ 5*pagesize
, "wrong result %p\n", results
[0] );
1181 VirtualFree( base
, 0, MEM_FREE
);
1188 argc
= winetest_get_mainargs( &argv
);
1192 if (!strcmp(argv
[2], "sleep"))
1194 Sleep(5000); /* spawned process runs for at most 5 seconds */
1201 mem
= VirtualAlloc(NULL
, 1<<20, MEM_COMMIT
|MEM_RESERVE
,
1202 PAGE_EXECUTE_READWRITE
);
1203 ok(mem
!= NULL
, "VirtualAlloc failed %u\n", GetLastError());
1204 if (mem
== NULL
) break;
1205 ret
= VirtualFree(mem
, 0, MEM_RELEASE
);
1206 ok(ret
, "VirtualFree failed %u\n", GetLastError());
1212 hkernel32
= GetModuleHandleA("kernel32.dll");
1213 pVirtualAllocEx
= (void *) GetProcAddress(hkernel32
, "VirtualAllocEx");
1214 pVirtualFreeEx
= (void *) GetProcAddress(hkernel32
, "VirtualFreeEx");
1215 pGetWriteWatch
= (void *) GetProcAddress(hkernel32
, "GetWriteWatch");
1216 pResetWriteWatch
= (void *) GetProcAddress(hkernel32
, "ResetWriteWatch");
1218 test_VirtualAllocEx();
1219 test_VirtualAlloc();
1220 test_MapViewOfFile();
1221 test_NtMapViewOfSection();
1222 test_CreateFileMapping();