ReactOS 0.4.16-dev-2284-g3529151
NtMapViewOfSection.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS API Tests
3 * LICENSE: LGPLv2.1+ - See COPYING.LIB in the top level directory
4 * PURPOSE: Test for NtMapViewOfSection
5 * PROGRAMMERS: Timo Kreuzer
6 * Thomas Faber
7 */
8
9#include "precomp.h"
10
11#include <pseh/pseh2.h>
12
13#ifdef _M_IX86
14#define IsX86() TRUE
15#else
16#define IsX86() FALSE
17#endif
18
19void
20Test_PageFileSection(void)
21{
22 NTSTATUS Status;
23 HANDLE SectionHandle;
24 LARGE_INTEGER MaximumSize, SectionOffset;
25 PVOID BaseAddress, BaseAddress2;
26 SIZE_T ViewSize;
27 ULONG OldProtect;
28
29 /* Create a page file backed section with SEC_COMMIT */
30 MaximumSize.QuadPart = 0x20000;
31 Status = NtCreateSection(&SectionHandle,
32 SECTION_ALL_ACCESS,
33 NULL,
34 &MaximumSize,
35 PAGE_READWRITE,
36 SEC_COMMIT,
37 NULL);
38 ok_ntstatus(Status, STATUS_SUCCESS);
39 if (!NT_SUCCESS(Status))
40 return;
41
42 /* Try to map a page at an address that is not 64k aligned */
43 BaseAddress = (PVOID)0x30001000;
44 SectionOffset.QuadPart = 0;
45 ViewSize = 0x1000;
46 Status = NtMapViewOfSection(SectionHandle,
47 NtCurrentProcess(),
48 &BaseAddress,
49 0,
50 0,
51 &SectionOffset,
52 &ViewSize,
53 ViewShare,
54 0,
55 PAGE_READWRITE);
56 ok_ntstatus(Status, STATUS_MAPPED_ALIGNMENT);
57
58 /* Try to map a page with execute rights */
59 BaseAddress = (PVOID)0x30000000;
60 SectionOffset.QuadPart = 0;
61 ViewSize = 0x1000;
62 Status = NtMapViewOfSection(SectionHandle,
63 NtCurrentProcess(),
64 &BaseAddress,
65 0,
66 0,
67 &SectionOffset,
68 &ViewSize,
69 ViewShare,
70 0,
71 PAGE_EXECUTE_READWRITE);
72 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
73
74 /* Try to map 2 pages with MEM_COMMIT */
75 BaseAddress = (PVOID)0x30000000;
76 SectionOffset.QuadPart = 0;
77 ViewSize = 0x2000;
78 Status = NtMapViewOfSection(SectionHandle,
79 NtCurrentProcess(),
80 &BaseAddress,
81 0,
82 PAGE_SIZE,
83 &SectionOffset,
84 &ViewSize,
85 ViewShare,
86 MEM_COMMIT,
87 PAGE_READWRITE);
88 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_9);
89
90 /* Try to map 1 page, with free base address and zero bits compatible with 64k granularity */
91 BaseAddress = NULL;
92 SectionOffset.QuadPart = 0;
93 ViewSize = 0x1000;
94 Status = NtMapViewOfSection(SectionHandle,
95 NtCurrentProcess(),
96 &BaseAddress,
97 10,
98 0,
99 &SectionOffset,
100 &ViewSize,
101 ViewShare,
102 0,
103 PAGE_READWRITE);
104 ok_ntstatus(Status, STATUS_SUCCESS);
105 ok(((ULONG_PTR)BaseAddress & 0x0000FFFF) == 0, "BaseAddress not 64k aligned: %p\n", BaseAddress);
106 ok(((ULONG_PTR)BaseAddress & (ULONG_PTR)0xFFFFFFFFFFC00000ULL) == 0, "Upper bits are not all zero: %p\n", BaseAddress);
107 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
108 ok_ntstatus(Status, STATUS_SUCCESS);
109
110 /* Try to map 1 page, with free base address and zero bits incompatible with 64k granularity.
111 * Note: On 64 bit Windows, ZeroBits != 0 means that the upper (32 + ZeroBits) bits must be zero.
112 * While the documented maximum for ZeroBits is "less than 21", to not break 64 bit alignment,
113 * we need to keep at least 17 bits (i.e., ZeroBits must be less than 16). */
114 BaseAddress = NULL;
115 SectionOffset.QuadPart = 0;
116 ViewSize = 0x1000;
117 Status = NtMapViewOfSection(SectionHandle,
118 NtCurrentProcess(),
119 &BaseAddress,
120 (32 - 16),
121 0,
122 &SectionOffset,
123 &ViewSize,
124 ViewShare,
125 0,
126 PAGE_READWRITE);
127 ok_ntstatus(Status, STATUS_NO_MEMORY);
128
129 /* Try to map 1 page, with base address and zero bits being compatible */
130 BaseAddress = (PVOID)0x30000000;
131 SectionOffset.QuadPart = 0;
132 ViewSize = 0x1000;
133 Status = NtMapViewOfSection(SectionHandle,
134 NtCurrentProcess(),
135 &BaseAddress,
136 2,
137 0,
138 &SectionOffset,
139 &ViewSize,
140 ViewShare,
141 0,
142 PAGE_READWRITE);
143 ok_ntstatus(Status, STATUS_SUCCESS);
144 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
145 ok_ntstatus(Status, STATUS_SUCCESS);
146
147 /* Try to map 1 page, with base address and zero bits being incompatible */
148 BaseAddress = (PVOID)0x30000000;
149 SectionOffset.QuadPart = 0;
150 ViewSize = 0x1000;
151 Status = NtMapViewOfSection(SectionHandle,
152 NtCurrentProcess(),
153 &BaseAddress,
154 3,
155 0,
156 &SectionOffset,
157 &ViewSize,
158 ViewShare,
159 0,
160 PAGE_READWRITE);
161 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_4);
162
163 /* Try using ZeroBits like a bitmask */
164 BaseAddress = NULL;
165 SectionOffset.QuadPart = 0;
166 ViewSize = 0x1000;
167 Status = NtMapViewOfSection(SectionHandle,
168 NtCurrentProcess(),
169 &BaseAddress,
170 0x0FFFFFFF,
171 0,
172 &SectionOffset,
173 &ViewSize,
174 ViewShare,
175 0,
176 PAGE_READWRITE);
177 if (GetNTVersion() >= _WIN32_WINNT_VISTA)
178 {
179 ok_ntstatus(Status, STATUS_SUCCESS);
180 ok(((ULONG_PTR)BaseAddress & 0x0000FFFF) == 0, "BaseAddress not 64k aligned: %p\n", BaseAddress);
181 ok(((ULONG_PTR)BaseAddress & (ULONG_PTR)0xFFFFFFFFF0000000ULL) == 0, "Upper bits are not all zero: %p\n", BaseAddress);
182 }
183 else
184 {
185 ok_ntstatus(Status, STATUS_INVALID_PARAMETER_4);
186 if (!NT_SUCCESS(Status))
187 return;
188 }
189
190 /* Map 2 pages, without MEM_COMMIT */
191 BaseAddress = (PVOID)0x30000000;
192 SectionOffset.QuadPart = 0;
193 ViewSize = 0x2000;
194 Status = NtMapViewOfSection(SectionHandle,
195 NtCurrentProcess(),
196 &BaseAddress,
197 0,
198 0,
199 &SectionOffset,
200 &ViewSize,
201 ViewShare,
202 0,
203 PAGE_READWRITE);
204 ok_ntstatus(Status, STATUS_SUCCESS);
205
206 /* We must be able to access the memory */
207 _SEH2_TRY
208 {
209 *(PULONG)BaseAddress = 1;
210 }
211 _SEH2_EXCEPT(1)
212 {
213 ok(FALSE, "Got an exception\n");
214 }
215 _SEH2_END;
216
217 /* Commit a page in the section */
218 BaseAddress = (PVOID)0x30000000;
219 ViewSize = 0x1000;
220 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
221 &BaseAddress,
222 0,
223 &ViewSize,
224 MEM_COMMIT,
225 PAGE_READWRITE);
226 ok_ntstatus(Status, STATUS_SUCCESS);
227
228 /* Try to decommit a page in the section */
229 Status = NtFreeVirtualMemory(NtCurrentProcess(),
230 &BaseAddress,
231 &ViewSize,
232 MEM_DECOMMIT);
233 ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
234
235 /* Try to commit a range larger than the section */
236 BaseAddress = (PVOID)0x30000000;
237 ViewSize = 0x3000;
238 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
239 &BaseAddress,
240 0,
241 &ViewSize,
242 MEM_COMMIT,
243 PAGE_READWRITE);
244 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
245
246 /* Try to commit a page after the section */
247 BaseAddress = (PVOID)0x30002000;
248 ViewSize = 0x1000;
249 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
250 &BaseAddress,
251 0,
252 &ViewSize,
253 MEM_COMMIT,
254 PAGE_READWRITE);
255 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
256
257 /* Try to allocate a page after the section */
258 BaseAddress = (PVOID)0x30002000;
259 ViewSize = 0x1000;
260 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
261 &BaseAddress,
262 0,
263 &ViewSize,
264 MEM_RESERVE | MEM_COMMIT,
265 PAGE_READWRITE);
266 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
267
268 /* Need to go to next 64k boundary */
269 BaseAddress = (PVOID)0x30010000;
270 ViewSize = 0x1000;
271 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
272 &BaseAddress,
273 0,
274 &ViewSize,
275 MEM_RESERVE | MEM_COMMIT,
276 PAGE_READWRITE);
277 ok_ntstatus(Status, STATUS_SUCCESS);
278 if (!NT_SUCCESS(Status))
279 return;
280
281 /* Free the allocation */
282 BaseAddress = (PVOID)0x30010000;
283 ViewSize = 0x1000;
284 Status = NtFreeVirtualMemory(NtCurrentProcess(),
285 &BaseAddress,
286 &ViewSize,
287 MEM_RELEASE);
288 ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed with Status %lx\n", Status);
289
290 /* Try to release the section mapping with NtFreeVirtualMemory */
291 BaseAddress = (PVOID)0x30000000;
292 ViewSize = 0x1000;
293 Status = NtFreeVirtualMemory(NtCurrentProcess(),
294 &BaseAddress,
295 &ViewSize,
296 MEM_RELEASE);
297 ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
298
299 /* Commit a page in the section */
300 BaseAddress = (PVOID)0x30001000;
301 ViewSize = 0x1000;
302 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
303 &BaseAddress,
304 0,
305 &ViewSize,
306 MEM_COMMIT,
307 PAGE_READWRITE);
308 ok_ntstatus(Status, STATUS_SUCCESS);
309
310 /* Try to decommit the page */
311 BaseAddress = (PVOID)0x30001000;
312 ViewSize = 0x1000;
313 Status = NtFreeVirtualMemory(NtCurrentProcess(),
314 &BaseAddress,
315 &ViewSize,
316 MEM_DECOMMIT);
317 ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
318
319 BaseAddress = UlongToPtr(0x40000000);
320 SectionOffset.QuadPart = 0;
321 ViewSize = 0x1000;
322 Status = NtMapViewOfSection(SectionHandle,
323 NtCurrentProcess(),
324 &BaseAddress,
325 0,
326 0,
327 &SectionOffset,
328 &ViewSize,
329 ViewShare,
330 0,
331 PAGE_READWRITE);
332 ok_ntstatus(Status, STATUS_SUCCESS);
333 if (!NT_SUCCESS(Status))
334 return;
335
336 ok(BaseAddress == UlongToPtr(0x40000000), "Invalid BaseAddress: %p\n", BaseAddress);
337
338 BaseAddress = (PVOID)0x40080000;
339 SectionOffset.QuadPart = 0x10000;
340 ViewSize = 0x1000;
341 Status = NtMapViewOfSection(SectionHandle,
342 NtCurrentProcess(),
343 &BaseAddress,
344 0,
345 0,
346 &SectionOffset,
347 &ViewSize,
348 ViewShare,
349 0,
350 PAGE_READWRITE);
351 ok_ntstatus(Status, STATUS_SUCCESS);
352
353 ok(BaseAddress == (PVOID)0x40080000, "Invalid BaseAddress: %p\n", BaseAddress);
354
355 /* Commit a page in the section */
356 BaseAddress = (PVOID)0x40000000;
357 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
358 &BaseAddress,
359 0,
360 &ViewSize,
361 MEM_COMMIT,
362 PAGE_READWRITE);
363 ok_ntstatus(Status, STATUS_SUCCESS);
364
365 /* Close the mapping */
366 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
367 ok_ntstatus(Status, STATUS_SUCCESS);
368 BaseAddress = (PVOID)0x30000000;
369 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
370 ok_ntstatus(Status, STATUS_SUCCESS);
371 Status = NtClose(SectionHandle);
372 ok_ntstatus(Status, STATUS_SUCCESS);
373
374 /* Create a page file backed section, but only reserved */
375 MaximumSize.QuadPart = 0x20000;
376 Status = NtCreateSection(&SectionHandle,
377 SECTION_ALL_ACCESS,
378 NULL,
379 &MaximumSize,
380 PAGE_READWRITE,
381 SEC_RESERVE,
382 NULL);
383 ok_ntstatus(Status, STATUS_SUCCESS);
384
385 /* Try to map 1 page, passing MEM_RESERVE */
386 BaseAddress = NULL;
387 SectionOffset.QuadPart = 0;
388 ViewSize = PAGE_SIZE;
389 Status = NtMapViewOfSection(SectionHandle,
390 NtCurrentProcess(),
391 &BaseAddress,
392 0,
393 PAGE_SIZE,
394 &SectionOffset,
395 &ViewSize,
396 ViewShare,
397 MEM_RESERVE,
398 PAGE_READWRITE);
399 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_9);
400
401 /* Try to map 1 page using MEM_COMMIT */
402 BaseAddress = NULL;
403 SectionOffset.QuadPart = 0;
404 ViewSize = PAGE_SIZE;
405 Status = NtMapViewOfSection(SectionHandle,
406 NtCurrentProcess(),
407 &BaseAddress,
408 0,
409 PAGE_SIZE,
410 &SectionOffset,
411 &ViewSize,
412 ViewShare,
413 MEM_COMMIT,
414 PAGE_READWRITE);
415 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_9);
416
417 /* Map 2 pages, but commit 1 */
418 BaseAddress = NULL;
419 SectionOffset.QuadPart = 0;
420 ViewSize = 2 * PAGE_SIZE;
421 Status = NtMapViewOfSection(SectionHandle,
422 NtCurrentProcess(),
423 &BaseAddress,
424 0,
425 PAGE_SIZE,
426 &SectionOffset,
427 &ViewSize,
428 ViewShare,
429 0,
430 PAGE_READWRITE);
431 ok_ntstatus(Status, STATUS_SUCCESS);
432
433 /* We must be able to access the 1st page */
434 Status = STATUS_SUCCESS;
435 _SEH2_TRY
436 {
437 *(PUCHAR)BaseAddress = 1;
438 }
439 _SEH2_EXCEPT(1)
440 {
441 Status = _SEH2_GetExceptionCode();
442 }
443 _SEH2_END;
444 ok_ntstatus(Status, STATUS_SUCCESS);
445
446 /* We must not be able to access the 2nd page */
447 Status = STATUS_SUCCESS;
448 _SEH2_TRY
449 {
450 *((PUCHAR)BaseAddress + PAGE_SIZE) = 1;
451 }
452 _SEH2_EXCEPT(1)
453 {
454 Status = _SEH2_GetExceptionCode();
455 }
456 _SEH2_END;
457 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
458
459 /* Map the 2 pages again into a different memory location */
460 BaseAddress2 = NULL;
461 Status = NtMapViewOfSection(SectionHandle,
462 NtCurrentProcess(),
463 &BaseAddress2,
464 0,
465 0,
466 &SectionOffset,
467 &ViewSize,
468 ViewShare,
469 0,
470 PAGE_READWRITE);
471 ok_ntstatus(Status, STATUS_SUCCESS);
472
473 /* Commit a the 2nd page in the 2nd memory location */
474 BaseAddress2 = (PUCHAR)BaseAddress2 + PAGE_SIZE;
475 ViewSize = PAGE_SIZE;
476 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
477 &BaseAddress2,
478 0,
479 &ViewSize,
480 MEM_COMMIT,
481 PAGE_READONLY);
482 ok_ntstatus(Status, STATUS_SUCCESS);
483
484 /* Try to commit again (the already committed page) */
485 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
486 &BaseAddress2,
487 0,
488 &ViewSize,
489 MEM_COMMIT,
490 PAGE_READONLY);
491 ok_ntstatus(Status, STATUS_SUCCESS);
492
493 /* We must be able to access the memory in the 2nd page of the 1st memory location */
494 Status = STATUS_SUCCESS;
495 _SEH2_TRY
496 {
497 *((PUCHAR)BaseAddress + PAGE_SIZE) = 2;
498 }
499 _SEH2_EXCEPT(1)
500 {
501 Status = _SEH2_GetExceptionCode();
502 }
503 _SEH2_END;
504 ok_ntstatus(Status, STATUS_SUCCESS);
505
506 ok(*(PULONG)BaseAddress2 == 2, "Value in memory was wrong\n");
507
508 /* Close the mapping */
509 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
510 ok_ntstatus(Status, STATUS_SUCCESS);
511 Status = NtUnmapViewOfSection(NtCurrentProcess(), (PUCHAR)BaseAddress2 - PAGE_SIZE);
512 ok_ntstatus(Status, STATUS_SUCCESS);
513 Status = NtClose(SectionHandle);
514 ok_ntstatus(Status, STATUS_SUCCESS);
515
516 /* Try to create a 512 GB page file backed section with committed pages */
517 MaximumSize.QuadPart = 0x8000000000;
518 Status = NtCreateSection(&SectionHandle,
519 SECTION_ALL_ACCESS,
520 NULL,
521 &MaximumSize,
522 PAGE_READWRITE,
523 SEC_COMMIT,
524 NULL);
525 ok_ntstatus(Status, STATUS_COMMITMENT_LIMIT);
526
527 /* Try to create a huge page file backed section with PAGE_NOACCESS protection */
528 MaximumSize.QuadPart = 0x8000000000;
529 Status = NtCreateSection(&SectionHandle,
530 SECTION_ALL_ACCESS,
531 NULL,
532 &MaximumSize,
533 PAGE_NOACCESS,
534 SEC_COMMIT,
535 NULL);
536 ok_ntstatus(Status, STATUS_INVALID_PAGE_PROTECTION);
537
538 /* Try to create a very huge page file backed section, but only reserved */
539 MaximumSize.QuadPart = 0x80000000000;
540 Status = NtCreateSection(&SectionHandle,
541 SECTION_ALL_ACCESS,
542 NULL,
543 &MaximumSize,
544 PAGE_READWRITE,
545 SEC_RESERVE,
546 NULL);
547#ifdef _WIN64
548 ok_ntstatus(Status, STATUS_INSUFFICIENT_RESOURCES);
549#else
550 /* WoW64 returns STATUS_INSUFFICIENT_RESOURCES */
551 ok((Status == STATUS_INSUFFICIENT_RESOURCES) || (Status == STATUS_SECTION_TOO_BIG),
552 "got wrong Status: 0x%lx\n", Status);
553#endif
554
555 /* Try to create a even huger page file backed section, but only reserved */
556 MaximumSize.QuadPart = 0x800000000000;
557 Status = NtCreateSection(&SectionHandle,
558 SECTION_ALL_ACCESS,
559 NULL,
560 &MaximumSize,
561 PAGE_READWRITE,
562 SEC_RESERVE,
563 NULL);
564 ok_ntstatus(Status, STATUS_SECTION_TOO_BIG);
565
566 /* Create a 8 GB page file backed section, but only reserved */
567 MaximumSize.QuadPart = 0x200000000;
568 Status = NtCreateSection(&SectionHandle,
569 SECTION_ALL_ACCESS,
570 NULL,
571 &MaximumSize,
572 PAGE_READWRITE,
573 SEC_RESERVE,
574 NULL);
575 ok_ntstatus(Status, STATUS_SUCCESS);
576
577 /* Pass a too large region size */
578 BaseAddress = NULL;
579 SectionOffset.QuadPart = 0;
580 ViewSize = MAXULONG_PTR;
581 Status = NtMapViewOfSection(SectionHandle,
582 NtCurrentProcess(),
583 &BaseAddress,
584 0,
585 0,
586 &SectionOffset,
587 &ViewSize,
588 ViewShare,
589 0,
590 PAGE_READWRITE);
591#ifdef _WIN64
592 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_3);
593#else
594 /* WoW64 returns STATUS_INVALID_PARAMETER_4 */
595 if (GetNTVersion() >= _WIN32_WINNT_WIN10)
596 ok(Status == STATUS_INVALID_PARAMETER, "got wrong Status: 0x%lx\n", Status);
597 else
598 ok((Status == STATUS_INVALID_PARAMETER_4) || (Status == STATUS_INVALID_PARAMETER_3),
599 "got wrong Status: 0x%lx\n", Status);
600#endif
601
602 /* Pass 0 region size */
603 BaseAddress = NULL;
604 SectionOffset.QuadPart = 0;
605 ViewSize = 0;
606 Status = NtMapViewOfSection(SectionHandle,
607 NtCurrentProcess(),
608 &BaseAddress,
609 0,
610 0,
611 &SectionOffset,
612 &ViewSize,
613 ViewShare,
614 0,
615 PAGE_READWRITE);
616#ifdef _WIN64
617 ok_ntstatus(Status, STATUS_SUCCESS);
618 ok(ViewSize == 0x200000000, "wrong ViewSize: 0x%Ix\n", ViewSize);
619#else
620 /* WoW64 returns STATUS_NO_MEMORY */
621 ok((Status == STATUS_NO_MEMORY) || (Status == STATUS_INVALID_VIEW_SIZE),
622 "got wrong Status: 0x%lx\n", Status);
623 ok(ViewSize == 0, "wrong ViewSize: 0x%Ix\n", ViewSize);
624#endif
625
626 /* Map with PAGE_NOACCESS */
627 BaseAddress = NULL;
628 SectionOffset.QuadPart = 0;
629 ViewSize = 0x20000000;
630 Status = NtMapViewOfSection(SectionHandle,
631 NtCurrentProcess(),
632 &BaseAddress,
633 0,
634 0,
635 &SectionOffset,
636 &ViewSize,
637 ViewShare,
638 0,
639 PAGE_NOACCESS);
640 ok_ntstatus(Status, STATUS_SUCCESS);
641
642 /* Try to change protection to read/write */
643 ViewSize = 0x1000;
644 OldProtect = -1;
645 BaseAddress2 = BaseAddress;
646 Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READWRITE, &OldProtect);
647 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
648 // Windows 2003 returns bogus
649 //ok(OldProtect == PAGE_READWRITE, "Wrong protection returned: %u\n", OldProtect);
650
651 /* Test read access */
652 Status = STATUS_SUCCESS;
653 _SEH2_TRY
654 {
655 (void)(*(volatile char*)BaseAddress2);
656 }
657 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
658 {
659 Status = _SEH2_GetExceptionCode();
660 }
661 _SEH2_END;
662 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
663
664 /* Try to change protection to read/write */
665 ViewSize = 0x1000;
666 OldProtect = -1;
667 BaseAddress2 = BaseAddress;
668 Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READWRITE, &OldProtect);
669 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
670#ifdef _WIN64
671 ok(OldProtect == PAGE_NOACCESS, "Wrong protection returned: 0x%lx\n", OldProtect);
672#else
673 // Windows 2003 returns bogus
674#endif
675
676 /* Try to change protection to readonly */
677 ViewSize = 0x1000;
678 OldProtect = -1;
679 BaseAddress2 = BaseAddress;
680 Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READONLY, &OldProtect);
681 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
682#ifdef _WIN64
683 //ok(OldProtect == 0, "Wrong protection returned: 0x%lx\n", OldProtect);
684#else
685 // Windows 2003 returns bogus
686#endif
687
688 /* Commit a page */
689 ViewSize = 0x1000;
690 BaseAddress2 = BaseAddress;
691 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READONLY);
692 ok_ntstatus(Status, STATUS_SUCCESS);
693 ok(BaseAddress2 == BaseAddress, "Invalid base address: %p\n", BaseAddress2);
694
695 /* Commit the page again */
696 ViewSize = 0x1000;
697 BaseAddress2 = BaseAddress;
698 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READONLY);
699 ok_ntstatus(Status, STATUS_SUCCESS);
700 ok(BaseAddress2 == BaseAddress, "Invalid base address: %p\n", BaseAddress2);
701
702 /* Test read access */
703 Status = STATUS_SUCCESS;
704 _SEH2_TRY
705 {
706 (void)(*(volatile char*)BaseAddress2);
707 }
708 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
709 {
710 Status = _SEH2_GetExceptionCode();
711 }
712 _SEH2_END;
713 ok_ntstatus(Status, STATUS_SUCCESS);
714
715 /* Test write access */
716 Status = STATUS_SUCCESS;
717 _SEH2_TRY
718 {
719 *(char*)BaseAddress2 = 1;
720 }
721 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
722 {
723 Status = _SEH2_GetExceptionCode();
724 }
725 _SEH2_END;
726 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
727
728 /* Update protection to PAGE_READWRITE */
729 ViewSize = 0x1000;
730 BaseAddress2 = BaseAddress;
731 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READWRITE);
732 ok_ntstatus(Status, STATUS_SUCCESS);
733
734 /* Test write access */
735 Status = STATUS_SUCCESS;
736 _SEH2_TRY
737 {
738 *(char*)BaseAddress2 = 1;
739 }
740 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
741 {
742 Status = _SEH2_GetExceptionCode();
743 }
744 _SEH2_END;
745 ok_ntstatus(Status, STATUS_SUCCESS);
746
747 /* Update protection to PAGE_EXECUTE_READWRITE (1 page) */
748 ViewSize = 0x1000;
749 BaseAddress2 = BaseAddress;
750 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
751 ok_ntstatus(Status, STATUS_SUCCESS);
752
753 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
754 ok_ntstatus(Status, STATUS_SUCCESS);
755 Status = NtClose(SectionHandle);
756 ok_ntstatus(Status, STATUS_SUCCESS);
757}
758
759void
760Test_ImageSection(void)
761{
762 UNICODE_STRING FileName;
763 NTSTATUS Status;
764 OBJECT_ATTRIBUTES FileObjectAttributes;
765 IO_STATUS_BLOCK IoStatusBlock;
766 WCHAR TestDllPath[MAX_PATH];
767 HANDLE FileHandle, DataSectionHandle, ImageSectionHandle;
768 PVOID DataBase, ImageBase;
769 SIZE_T ViewSize;
770
771 GetModuleFileNameW(NULL, TestDllPath, RTL_NUMBER_OF(TestDllPath));
772 wcsrchr(TestDllPath, L'\\')[1] = UNICODE_NULL;
773 StringCbCatW(TestDllPath, sizeof(TestDllPath), L"testdata\\test.dll");
774 if (!RtlDosPathNameToNtPathName_U(TestDllPath,
775 &FileName,
776 NULL,
777 NULL))
778 {
779 ok(0, "RtlDosPathNameToNtPathName_U failed\n");
780 return;
781 }
782
783 InitializeObjectAttributes(&FileObjectAttributes,
784 &FileName,
785 0,
786 NULL,
787 NULL);
788
789 Status = NtOpenFile(&FileHandle,
790 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
791 &FileObjectAttributes,
792 &IoStatusBlock,
793 FILE_SHARE_READ,
794 FILE_SYNCHRONOUS_IO_NONALERT);
795 ok_ntstatus(Status, STATUS_SUCCESS);
796 if (!NT_SUCCESS(Status))
797 {
798 skip("Failed to open file %s\n", wine_dbgstr_wn(FileName.Buffer, FileName.Length / sizeof(WCHAR)));
799 return;
800 }
801
802 /* Create a data section with write access */
803 Status = NtCreateSection(&DataSectionHandle,
804 SECTION_ALL_ACCESS, // DesiredAccess
805 NULL, // ObjectAttributes
806 NULL, // MaximumSize
807 PAGE_READWRITE, // SectionPageProtection
808 SEC_COMMIT, // AllocationAttributes
809 FileHandle);
810 ok_ntstatus(Status, STATUS_SUCCESS);
811 if (!NT_SUCCESS(Status))
812 {
813 skip("Failed to create data section\n");
814 NtClose(FileHandle);
815 return;
816 }
817
818 /* Map the data section as flat mapping */
819 DataBase = NULL;
820 ViewSize = 0;
821 Status = NtMapViewOfSection(DataSectionHandle,
822 NtCurrentProcess(),
823 &DataBase,
824 0,
825 0,
826 NULL,
827 &ViewSize,
828 ViewShare,
829 0,
830 PAGE_READWRITE);
831 ok_ntstatus(Status, STATUS_SUCCESS);
832 //ok(ViewSize == 0x3f95cc48, "ViewSize wrong: 0x%lx\n");
833 if (!NT_SUCCESS(Status))
834 {
835 skip("Failed to map view of data section\n");
836 NtClose(DataSectionHandle);
837 NtClose(FileHandle);
838 return;
839 }
840
841 /* Check the original data */
842 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
843
844 /* Modify the PE header (but do not flush!) */
845 *(ULONG*)DataBase = 0xdeadbabe;
846 ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
847
848 /* Modify data in the .data section (but do not flush!) */
849 ok(*(ULONG*)((PUCHAR)DataBase + 0x800) == 0x12345678,
850 "Data in .data section invalid: 0x%lx!\n", *(ULONG*)((PUCHAR)DataBase + 0x800));
851 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x87654321;
852
853 /* Now try to create an image section (should fail) */
854 Status = NtCreateSection(&ImageSectionHandle,
855 SECTION_ALL_ACCESS, // DesiredAccess
856 NULL, // ObjectAttributes
857 NULL, // MaximumSize
858 PAGE_READWRITE, // SectionPageProtection
859 SEC_IMAGE, // AllocationAttributes
860 FileHandle);
861 ok_ntstatus(Status, STATUS_INVALID_IMAGE_NOT_MZ);
862 if (NT_SUCCESS(Status)) NtClose(ImageSectionHandle);
863
864 /* Restore the original header */
865 *(ULONG*)DataBase = 0x00905a4d;
866
867 /* Modify data in the .data section (but do not flush!) */
868 ok_hex(*(ULONG*)((PUCHAR)DataBase + 0x800), 0x87654321);
869 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xdeadbabe;
870
871 /* Try to create an image section again */
872 Status = NtCreateSection(&ImageSectionHandle,
873 SECTION_ALL_ACCESS, // DesiredAccess
874 NULL, // ObjectAttributes
875 NULL, // MaximumSize
876 PAGE_READWRITE, // SectionPageProtection
877 SEC_IMAGE, // AllocationAttributes
878 FileHandle);
879 ok_ntstatus(Status, STATUS_SUCCESS);
880 if (!NT_SUCCESS(Status))
881 {
882 skip("Failed to create image section\n");
883 NtClose(DataSectionHandle);
884 NtClose(FileHandle);
885 return;
886 }
887
888 /* Map the image section */
889 ImageBase = NULL;
890 ViewSize = 0;
891 Status = NtMapViewOfSection(ImageSectionHandle,
892 NtCurrentProcess(),
893 &ImageBase,
894 0, // ZeroBits
895 0, // CommitSize
896 NULL, // SectionOffset
897 &ViewSize,
898 ViewShare,
899 0, // AllocationType
900 PAGE_READONLY);
901#ifdef _M_IX86
902 ok_ntstatus(Status, STATUS_SUCCESS);
903#else
904 ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
905#endif
906 if (!NT_SUCCESS(Status))
907 {
908 skip("Failed to map view of image section\n");
909 NtClose(ImageSectionHandle);
910 NtClose(DataSectionHandle);
911 NtClose(FileHandle);
912 return;
913 }
914
915 /* Check the header */
916 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
917 ok(*(ULONG*)ImageBase == 0x00905a4d, "Header not ok\n");
918
919 /* Check the data section. Either of these can be present! */
920 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
921 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
922 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
923
924 /* Now modify the data again */
925 *(ULONG*)DataBase = 0xdeadbabe;
926 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xf00dada;
927
928 /* Check the data */
929 ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
930 ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
931 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
932 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
933 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
934
935 /* Flush the view */
936 ViewSize = 0x1000;
937 Status = NtFlushVirtualMemory(NtCurrentProcess(),
938 &DataBase,
939 &ViewSize,
940 &IoStatusBlock);
941 ok_ntstatus(Status, STATUS_SUCCESS);
942
943 /* Check the data again */
944 ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
945 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
946 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
947 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
948
949 /* Restore the original header */
950 *(ULONG*)DataBase = 0x00905a4d;
951 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
952
953 /* Close the image mapping */
954 NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
955 NtClose(ImageSectionHandle);
956
957 /* Create an image section again */
958 Status = NtCreateSection(&ImageSectionHandle,
959 SECTION_ALL_ACCESS, // DesiredAccess
960 NULL, // ObjectAttributes
961 NULL, // MaximumSize
962 PAGE_READWRITE, // SectionPageProtection
963 SEC_IMAGE, // AllocationAttributes
964 FileHandle);
965 ok_ntstatus(Status, STATUS_SUCCESS);
966 if (!NT_SUCCESS(Status))
967 {
968 skip("Failed to create image section\n");
969 NtClose(DataSectionHandle);
970 NtClose(FileHandle);
971 return;
972 }
973
974 /* Map the image section again */
975 ImageBase = NULL;
976 ViewSize = 0;
977 Status = NtMapViewOfSection(ImageSectionHandle,
978 NtCurrentProcess(),
979 &ImageBase,
980 0,
981 0,
982 NULL,
983 &ViewSize,
984 ViewShare,
985 0,
986 PAGE_READONLY);
987#ifdef _M_IX86
988 ok_ntstatus(Status, STATUS_SUCCESS);
989#else
990 ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
991#endif
992 if (!NT_SUCCESS(Status))
993 {
994 skip("Failed to map view of image section\n");
995 NtClose(ImageSectionHandle);
996 NtClose(DataSectionHandle);
997 NtClose(FileHandle);
998 return;
999 }
1000
1001 // This one doesn't always work, needs investigation
1002 /* Check the .data section again */
1003 //ok(*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0xf00dada,
1004 // "Data should be synced: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
1005
1006 /* Restore the original data */
1007 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x12345678;
1008
1009 /* Close the data mapping */
1010 NtUnmapViewOfSection(NtCurrentProcess(), DataBase);
1011
1012 NtClose(DataSectionHandle);
1013
1014 /* Try to allocate memory inside the image mapping */
1015 DataBase = (PUCHAR)ImageBase + 0x20000;
1016 ViewSize = 0x1000;
1017 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &DataBase, 0, &ViewSize, MEM_RESERVE, PAGE_NOACCESS);
1018 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1019
1020 /* Cleanup */
1021 NtClose(FileHandle);
1022 NtClose(ImageSectionHandle);
1023 NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
1024}
1025
1026void
1027Test_ImageSection2(void)
1028{
1029 UNICODE_STRING FileName;
1030 NTSTATUS Status;
1031 OBJECT_ATTRIBUTES FileObjectAttributes;
1032 IO_STATUS_BLOCK IoStatusBlock;
1033 HANDLE FileHandle, ImageSectionHandle;
1034 PVOID ImageBase, BaseAddress;
1035 SIZE_T ViewSize;
1036 LARGE_INTEGER MaximumSize, SectionOffset;
1037
1038 if (!RtlDosPathNameToNtPathName_U(L"testdata\\nvoglv32.dll",
1039 &FileName,
1040 NULL,
1041 NULL))
1042 {
1043 ok(0, "RtlDosPathNameToNtPathName_U failed\n");
1044 return;
1045 }
1046
1047 InitializeObjectAttributes(&FileObjectAttributes,
1048 &FileName,
1049 0,
1050 NULL,
1051 NULL);
1052
1053 Status = NtOpenFile(&FileHandle,
1054 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
1055 &FileObjectAttributes,
1056 &IoStatusBlock,
1057 FILE_SHARE_READ,
1058 FILE_SYNCHRONOUS_IO_NONALERT);
1059 ok_ntstatus(Status, STATUS_SUCCESS);
1060 printf("Opened file with handle %p\n", FileHandle);
1061
1062 /* Create a data section with write access */
1063 MaximumSize.QuadPart = 0x20000;
1064 Status = NtCreateSection(&ImageSectionHandle,
1065 SECTION_ALL_ACCESS, // DesiredAccess
1066 NULL, // ObjectAttributes
1067 &MaximumSize, // MaximumSize
1068 PAGE_READWRITE, // SectionPageProtection
1069 SEC_IMAGE, // AllocationAttributes
1070 FileHandle);
1071 ok_ntstatus(Status, STATUS_SUCCESS);
1072
1073 printf("Created image section with handle %p\n", ImageSectionHandle);
1074 //system("PAUSE");
1075
1076 /* Map the image section */
1077 ImageBase = NULL;
1078 ViewSize = 0x0000;
1079 SectionOffset.QuadPart = 0x00000;
1080 Status = NtMapViewOfSection(ImageSectionHandle,
1081 NtCurrentProcess(),
1082 &ImageBase,
1083 0,
1084 0,
1085 &SectionOffset,
1086 &ViewSize,
1087 ViewShare,
1088 0,
1089 PAGE_READWRITE);
1090 ok_ntstatus(Status, STATUS_SUCCESS);
1091
1092 printf("Mapped image section at %p, value in text section: %lx\n",
1093 ImageBase, *((ULONG*)((PCHAR)ImageBase + 0x1196)));
1094 system("PAUSE");
1095
1096 /* Try to allocate a page after the section */
1097 BaseAddress = (PUCHAR)ImageBase + 0x10000;
1098 ViewSize = 0x1000;
1099 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
1100 &BaseAddress,
1101 0,
1102 &ViewSize,
1103 MEM_RESERVE | MEM_COMMIT,
1104 PAGE_READWRITE);
1105 printf("allocation status: %lx\n", Status);
1106 system("PAUSE");
1107
1108}
1109
1110// doesn't work with WoW64!
1111void
1112Test_BasedSection(void)
1113{
1114 NTSTATUS Status;
1115 HANDLE SectionHandle1, SectionHandle2;
1116 LARGE_INTEGER MaximumSize, SectionOffset;
1117 PVOID BaseAddress1, BaseAddress2;
1118 SIZE_T ViewSize;
1119
1120 /* Create a based section with SEC_COMMIT */
1121 MaximumSize.QuadPart = 0x1000;
1122 Status = NtCreateSection(&SectionHandle1,
1123 SECTION_ALL_ACCESS,
1124 NULL,
1125 &MaximumSize,
1126 PAGE_READWRITE,
1127 SEC_COMMIT | SEC_BASED,
1128 NULL);
1129 ok_ntstatus(Status, STATUS_SUCCESS);
1130
1131 /* Map the 1st section */
1132 BaseAddress1 = NULL;
1133 SectionOffset.QuadPart = 0;
1134 ViewSize = 0;
1135 Status = NtMapViewOfSection(SectionHandle1,
1136 NtCurrentProcess(),
1137 &BaseAddress1,
1138 0,
1139 0,
1140 &SectionOffset,
1141 &ViewSize,
1142 ViewShare,
1143 0,
1144 PAGE_READWRITE);
1145#if 0 // WOW64?
1146 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1147#else
1148 ok_ntstatus(Status, STATUS_SUCCESS);
1149#endif
1150
1151 /* Create a 2nd based section with SEC_COMMIT */
1152 MaximumSize.QuadPart = 0x1000;
1153 Status = NtCreateSection(&SectionHandle2,
1154 SECTION_ALL_ACCESS,
1155 NULL,
1156 &MaximumSize,
1157 PAGE_READWRITE,
1158 SEC_COMMIT | SEC_BASED,
1159 NULL);
1160 ok_ntstatus(Status, STATUS_SUCCESS);//
1161
1162 /* Map the 2nd section */
1163 BaseAddress2 = NULL;
1164 SectionOffset.QuadPart = 0;
1165 ViewSize = 0;
1166 Status = NtMapViewOfSection(SectionHandle2,
1167 NtCurrentProcess(),
1168 &BaseAddress2,
1169 0,
1170 0,
1171 &SectionOffset,
1172 &ViewSize,
1173 ViewShare,
1174 0,
1175 PAGE_READWRITE);
1176#if 0 // WOW64?
1177 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1178#else
1179 ok_ntstatus(Status, STATUS_SUCCESS);
1180 ok((ULONG_PTR)BaseAddress2 < (ULONG_PTR)BaseAddress1,
1181 "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1182 ok(((ULONG_PTR)BaseAddress1 - (ULONG_PTR)BaseAddress2) == 0x10000,
1183 "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1184#endif
1185}
1186
1187#define BYTES4(x) x, x, x, x
1188#define BYTES8(x) BYTES4(x), BYTES4(x)
1189#define BYTES16(x) BYTES8(x), BYTES8(x)
1190#define BYTES32(x) BYTES16(x), BYTES16(x)
1191#define BYTES64(x) BYTES32(x), BYTES32(x)
1192#define BYTES128(x) BYTES64(x), BYTES64(x)
1193#define BYTES256(x) BYTES128(x), BYTES128(x)
1194#define BYTES512(x) BYTES256(x), BYTES256(x)
1195#define BYTES1024(x) BYTES512(x), BYTES512(x)
1196
1197static struct _SECTION_CONTENTS_IMAGE_FILE
1198{
1199 IMAGE_DOS_HEADER doshdr;
1200 WORD stub[32];
1201 IMAGE_NT_HEADERS nthdrs;
1202 IMAGE_SECTION_HEADER text_header;
1203 IMAGE_SECTION_HEADER rossym_header;
1204 IMAGE_SECTION_HEADER rsrc_header;
1205 IMAGE_SECTION_HEADER clc_header;
1206#ifdef _WIN64
1207 BYTE pad[472];
1208#else
1209 BYTE pad[488];
1210#endif
1211 BYTE text_data[0x400];
1212 BYTE rossym_data[0x400];
1213 BYTE rsrc_data[0x400];
1214 BYTE clc_data[0x1000];
1215} SectionContentsImageFile =
1216{
1217 /* IMAGE_DOS_HEADER */
1218 {
1219 IMAGE_DOS_SIGNATURE, 144, 3, 0, 4, 0, 0xFFFF, 0, 0xB8, 0, 0, 0, 0x40,
1220 0, { 0 }, 0, 0, { 0 }, 0x80
1221 },
1222 /* binary to print "This program cannot be run in DOS mode." */
1223 {
1224 0x1F0E, 0x0EBA, 0xB400, 0xCD09, 0xB821, 0x4C01, 0x21CD, 0x6854, 0x7369,
1225 0x7020, 0x6F72, 0x7267, 0x6D61, 0x6320, 0x6E61, 0x6F6E, 0x2074, 0x6562,
1226 0x7220, 0x6E75, 0x6920, 0x206E, 0x4F44, 0x2053, 0x6F6D, 0x6564, 0x0D2E,
1227 0x0A0D, 0x0024, 0x0000, 0x0000, 0x0000
1228 },
1229 /* IMAGE_NT_HEADERS */
1230 {
1231 IMAGE_NT_SIGNATURE, /* Signature */
1232 /* IMAGE_FILE_HEADER */
1233 {
1234 IMAGE_FILE_MACHINE_NATIVE, /* Machine */
1235 4, /* NumberOfSections */
1236 0x47EFDF09, /* TimeDateStamp */
1237 0, /* PointerToSymbolTable */
1238 0, /* NumberOfSymbols */
1239#ifdef _WIN64
1240 0xF0, /* SizeOfOptionalHeader */
1241#else
1242 0xE0, /* SizeOfOptionalHeader */
1243#endif
1244 IMAGE_FILE_32BIT_MACHINE | IMAGE_FILE_LOCAL_SYMS_STRIPPED |
1245 IMAGE_FILE_LINE_NUMS_STRIPPED | IMAGE_FILE_EXECUTABLE_IMAGE |
1246 IMAGE_FILE_DLL, /* Characteristics */
1247 },
1248 /* IMAGE_OPTIONAL_HEADER */
1249 {
1250#ifdef _WIN64
1251 IMAGE_NT_OPTIONAL_HDR64_MAGIC, /* Magic */
1252#else
1253 IMAGE_NT_OPTIONAL_HDR32_MAGIC, /* Magic */
1254#endif
1255 8, /* MajorLinkerVersion */
1256 0, /* MinorLinkerVersion */
1257 0x400, /* SizeOfCode */
1258 0x000, /* SizeOfInitializedData */
1259 0, /* SizeOfUninitializedData */
1260 0x2000, /* AddressOfEntryPoint */
1261 0x2000, /* BaseOfCode */
1262#ifndef _WIN64
1263 0x0000, /* BaseOfData */
1264#endif
1265 0x400000, /* ImageBase */
1266 0x2000, /* SectionAlignment */
1267 0x200, /* FileAlignment */
1268 4, /* MajorOperatingSystemVersion */
1269 0, /* MinorOperatingSystemVersion */
1270 0, /* MajorImageVersion */
1271 0, /* MinorImageVersion */
1272 4, /* MajorSubsystemVersion */
1273 0, /* MinorSubsystemVersion */
1274 0, /* Win32VersionValue */
1275 0xa000, /* SizeOfImage */
1276 0x400, /* SizeOfHeaders */
1277 0x0, /* CheckSum */
1278 IMAGE_SUBSYSTEM_WINDOWS_CUI, /* Subsystem */
1279 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE |
1280 IMAGE_DLLCHARACTERISTICS_NO_SEH |
1281 IMAGE_DLLCHARACTERISTICS_NX_COMPAT, /* DllCharacteristics */
1282 0x100000, /* SizeOfStackReserve */
1283 0x1000, /* SizeOfStackCommit */
1284 0x100000, /* SizeOfHeapReserve */
1285 0x1000, /* SizeOfHeapCommit */
1286 0, /* LoaderFlags */
1287 0x10, /* NumberOfRvaAndSizes */
1288 /* IMAGE_DATA_DIRECTORY */
1289 {
1290 { 0 }, /* Export Table */
1291 { 0 }, /* Import Table */
1292 { 0 }, /* Resource Table */
1293 { 0 }, /* Exception Table */
1294 { 0 }, /* Certificate Table */
1295 { 0 }, /* Base Relocation Table */
1296 { 0 }, /* Debug */
1297 { 0 }, /* Copyright */
1298 { 0 }, /* Global Ptr */
1299 { 0 }, /* TLS Table */
1300 { 0 }, /* Load Config Table */
1301 { 0 }, /* Bound Import */
1302 { 0 }, /* IAT */
1303 { 0 }, /* Delay Import Descriptor */
1304 { 0 }, /* CLI Header */
1305 { 0 } /* Reserved */
1306 }
1307 }
1308 },
1309 /* IMAGE_SECTION_HEADER */
1310 {
1311 ".text", /* Name */
1312 { 0x394 }, /* Misc.VirtualSize */
1313 0x2000, /* VirtualAddress */
1314 0x400, /* SizeOfRawData */
1315 0x400, /* PointerToRawData */
1316 0, /* PointerToRelocations */
1317 0, /* PointerToLinenumbers */
1318 0, /* NumberOfRelocations */
1319 0, /* NumberOfLinenumbers */
1320 IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE |
1321 IMAGE_SCN_CNT_CODE, /* Characteristics */
1322 },
1323 /* IMAGE_SECTION_HEADER */
1324 {
1325 ".rossym", /* Name */
1326 { 0x100 }, /* Misc.VirtualSize */
1327 0x4000, /* VirtualAddress */
1328 0x400, /* SizeOfRawData */
1329 0x800, /* PointerToRawData */
1330 0, /* PointerToRelocations */
1331 0, /* PointerToLinenumbers */
1332 0, /* NumberOfRelocations */
1333 0, /* NumberOfLinenumbers */
1334 /* CORE-8384 */
1335 IMAGE_SCN_MEM_READ | IMAGE_SCN_TYPE_NOLOAD, /* Characteristics */
1336 },
1337 /* IMAGE_SECTION_HEADER */
1338 {
1339 ".rsrc", /* Name */
1340 { 0x100 }, /* Misc.VirtualSize */
1341 0x6000, /* VirtualAddress */
1342 0x400, /* SizeOfRawData */
1343 0xC00, /* PointerToRawData */
1344 0, /* PointerToRelocations */
1345 0, /* PointerToLinenumbers */
1346 0, /* NumberOfRelocations */
1347 0, /* NumberOfLinenumbers */
1348 IMAGE_SCN_MEM_READ |
1349 IMAGE_SCN_CNT_INITIALIZED_DATA, /* Characteristics */
1350 },
1351 /* IMAGE_SECTION_HEADER */
1352 {
1353 ".clc", /* Name */
1354 { 0x2000 }, /* Misc.VirtualSize */
1355 0x8000, /* VirtualAddress */
1356 0x1000, /* SizeOfRawData */
1357 0x1000, /* PointerToRawData */
1358 0, /* PointerToRelocations */
1359 0, /* PointerToLinenumbers */
1360 0, /* NumberOfRelocations */
1361 0, /* NumberOfLinenumbers */
1362 /* CORE-12582 */
1363 IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE |
1364 IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_CODE, /* Characteristics */
1365 },
1366 /* fill */
1367 { 0 },
1368 /* text */
1369 { 0xc3, 0 },
1370 /* rossym */
1371 {
1372 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1373 BYTES8(0xaa),
1374 BYTES16(0xbb),
1375 BYTES32(0xcc),
1376 BYTES64(0xdd),
1377 BYTES64(0xee),
1378 BYTES64(0xff),
1379 },
1380 /* rsrc */
1381 {
1382 BYTES128(0xee),
1383 BYTES128(0x55),
1384 BYTES128(0xee),
1385 BYTES128(0x11),
1386 BYTES128(0xff),
1387 BYTES128(0x00),
1388 BYTES128(0x00),
1389 BYTES128(0xdd),
1390 },
1391 /* clc */
1392 {
1393 BYTES512(0x11),
1394 BYTES512(0x22),
1395 BYTES512(0x33),
1396 BYTES512(0x44),
1397 BYTES512(0x55),
1398 BYTES512(0x66),
1399 BYTES512(0x77),
1400 BYTES512(0x88),
1401 },
1402};
1403
1404C_ASSERT(FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, text_data) == 0x400);
1405C_ASSERT(FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, rossym_data) == 0x800);
1406C_ASSERT(FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, rsrc_data) == 0xc00);
1407C_ASSERT(FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, clc_data) == 0x1000);
1408
1409static
1410void
1411Test_SectionContents(BOOL Relocate)
1412{
1413 NTSTATUS Status;
1414 WCHAR TempPath[MAX_PATH];
1415 WCHAR FileName[MAX_PATH];
1416 HANDLE Handle;
1417 HANDLE SectionHandle;
1418 LARGE_INTEGER SectionOffset;
1419 PVOID BaseAddress;
1420 SIZE_T ViewSize;
1421 ULONG Written;
1422 ULONG Length;
1423 BOOL Success;
1424
1425 Length = GetTempPathW(MAX_PATH, TempPath);
1426 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1427 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1428 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1429 Handle = CreateFileW(FileName,
1430 FILE_ALL_ACCESS,
1431 0,
1432 NULL,
1433 CREATE_ALWAYS,
1434 0,
1435 NULL);
1436 if (Handle == INVALID_HANDLE_VALUE)
1437 {
1438 skip("Failed to create temp file %ls, error %lu\n", FileName, GetLastError());
1439 return;
1440 }
1441 if (Relocate)
1442 {
1443#ifdef _WIN64
1444 ok((ULONG_PTR)GetModuleHandle(NULL) <= 0x00007FFFFFFFFFFF, "Module at %p\n", GetModuleHandle(NULL));
1445#else
1446 ok((ULONG_PTR)GetModuleHandle(NULL) <= 0x80000000, "Module at %p\n", GetModuleHandle(NULL));
1447#endif
1448 SectionContentsImageFile.nthdrs.OptionalHeader.ImageBase = (ULONG_PTR)GetModuleHandle(NULL);
1449 }
1450 else
1451 {
1452 SectionContentsImageFile.nthdrs.OptionalHeader.ImageBase = 0xe400000;
1453 }
1454
1455 Success = WriteFile(Handle,
1456 &SectionContentsImageFile,
1457 sizeof(SectionContentsImageFile),
1458 &Written,
1459 NULL);
1460 ok(Success == TRUE, "WriteFile failed with %lu\n", GetLastError());
1461 ok(Written == sizeof(SectionContentsImageFile), "WriteFile wrote %lu bytes\n", Written);
1462
1463 Status = NtCreateSection(&SectionHandle,
1464 SECTION_ALL_ACCESS,
1465 NULL,
1466 NULL,
1467 PAGE_EXECUTE_READWRITE,
1468 SEC_IMAGE,
1469 Handle);
1470 ok_ntstatus(Status, STATUS_SUCCESS);
1471
1472 if (NT_SUCCESS(Status))
1473 {
1474 /* Map the section with */
1475 BaseAddress = NULL;
1476 SectionOffset.QuadPart = 0;
1477 ViewSize = 0;
1478 Status = NtMapViewOfSection(SectionHandle,
1479 NtCurrentProcess(),
1480 &BaseAddress,
1481 0,
1482 0,
1483 &SectionOffset,
1484 &ViewSize,
1485 ViewShare,
1486 0,
1487 PAGE_READWRITE);
1488 if (Relocate)
1489 ok_ntstatus(Status, STATUS_IMAGE_NOT_AT_BASE);
1490 else
1491 ok_ntstatus(Status, STATUS_SUCCESS);
1492 if (NT_SUCCESS(Status))
1493 {
1494 PUCHAR Bytes = BaseAddress;
1495#define TEST_BYTE(n, v) StartSeh() ok_hex(Bytes[n], v); EndSeh(STATUS_SUCCESS);
1496#define TEST_WRITE(n) StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_SUCCESS);
1497#define TEST_NOWRITE(n) StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_ACCESS_VIOLATION);
1498 TEST_NOWRITE(0x2000);
1499 TEST_BYTE(0x2000, 0xc3);
1500 TEST_BYTE(0x2001, 0x00);
1501 TEST_NOWRITE(0x4000);
1502 TEST_BYTE(0x4000, 0x01);
1503 TEST_BYTE(0x4001, 0x23);
1504 TEST_BYTE(0x4007, 0xef);
1505 TEST_BYTE(0x4008, 0xaa);
1506 TEST_BYTE(0x4010, 0xbb);
1507 TEST_BYTE(0x4020, 0xcc);
1508 TEST_BYTE(0x4040, 0xdd);
1509 TEST_BYTE(0x4080, 0xee);
1510 TEST_BYTE(0x40c0, 0xff);
1511 TEST_BYTE(0x40ff, 0xff);
1512 TEST_BYTE(0x4100, 0x00);
1513 TEST_BYTE(0x41ff, 0x00);
1514 TEST_NOWRITE(0x6000);
1515 TEST_BYTE(0x6000, 0xee);
1516 TEST_BYTE(0x60ff, 0x55);
1517 TEST_BYTE(0x6100, 0xee);
1518 TEST_BYTE(0x63ff, 0xdd);
1519 TEST_BYTE(0x6400, 0x00);
1520 TEST_WRITE(0x8000);
1521 TEST_BYTE(0x8000, 0x11);
1522 TEST_BYTE(0x8400, 0x33);
1523#undef TEST_BYTE
1524#undef TEST_WRITE
1525#undef TEST_NOWRITE
1526 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
1527 ok_ntstatus(Status, STATUS_SUCCESS);
1528 }
1529 Status = NtClose(SectionHandle);
1530 ok_ntstatus(Status, STATUS_SUCCESS);
1531 }
1532
1533 CloseHandle(Handle);
1534 DeleteFileW(FileName);
1535}
1536
1537static struct _RAW_SIZE_IMAGE_FILE
1538{
1539 IMAGE_DOS_HEADER doshdr;
1540 WORD stub[32];
1541 IMAGE_NT_HEADERS32 nthdrs;
1542 IMAGE_SECTION_HEADER text_header;
1543 IMAGE_SECTION_HEADER data_header;
1544 IMAGE_SECTION_HEADER zdata_header;
1545 IMAGE_SECTION_HEADER rsrc_header;
1546 IMAGE_SECTION_HEADER bss_header;
1547 BYTE pad[448];
1548 BYTE text_data[0x1200];
1549 BYTE data_data[0x1200];
1550 BYTE rsrc_data[0x400];
1551} RawSizeImageFile =
1552{
1553 /* IMAGE_DOS_HEADER */
1554 {
1555 IMAGE_DOS_SIGNATURE, 144, 3, 0, 4, 0, 0xFFFF, 0, 0xB8, 0, 0, 0, 0x40,
1556 0, { 0 }, 0, 0, { 0 }, 0x80
1557 },
1558 /* binary to print "This program cannot be run in DOS mode." */
1559 {
1560 0x1F0E, 0x0EBA, 0xB400, 0xCD09, 0xB821, 0x4C01, 0x21CD, 0x6854, 0x7369,
1561 0x7020, 0x6F72, 0x7267, 0x6D61, 0x6320, 0x6E61, 0x6F6E, 0x2074, 0x6562,
1562 0x7220, 0x6E75, 0x6920, 0x206E, 0x4F44, 0x2053, 0x6F6D, 0x6564, 0x0D2E,
1563 0x0A0D, 0x0024, 0x0000, 0x0000, 0x0000
1564 },
1565 /* IMAGE_NT_HEADERS32 */
1566 {
1567 IMAGE_NT_SIGNATURE, /* Signature */
1568 /* IMAGE_FILE_HEADER */
1569 {
1570 IMAGE_FILE_MACHINE_I386, /* Machine */
1571 5, /* NumberOfSections */
1572 0x47EFDF09, /* TimeDateStamp */
1573 0, /* PointerToSymbolTable */
1574 0, /* NumberOfSymbols */
1575 0xE0, /* SizeOfOptionalHeader */
1576 IMAGE_FILE_32BIT_MACHINE | IMAGE_FILE_LOCAL_SYMS_STRIPPED |
1577 IMAGE_FILE_LINE_NUMS_STRIPPED | IMAGE_FILE_EXECUTABLE_IMAGE |
1578 IMAGE_FILE_DLL, /* Characteristics */
1579 },
1580 /* IMAGE_OPTIONAL_HEADER32 */
1581 {
1582 IMAGE_NT_OPTIONAL_HDR32_MAGIC, /* Magic */
1583 8, /* MajorLinkerVersion */
1584 0, /* MinorLinkerVersion */
1585 0x400, /* SizeOfCode */
1586 0x000, /* SizeOfInitializedData */
1587 0, /* SizeOfUninitializedData */
1588 0x1000, /* AddressOfEntryPoint */
1589 0x1000, /* BaseOfCode */
1590 0x0000, /* BaseOfData */
1591 0x400000, /* ImageBase */
1592 0x1000, /* SectionAlignment */
1593 0x200, /* FileAlignment */
1594 4, /* MajorOperatingSystemVersion */
1595 0, /* MinorOperatingSystemVersion */
1596 0, /* MajorImageVersion */
1597 0, /* MinorImageVersion */
1598 4, /* MajorSubsystemVersion */
1599 0, /* MinorSubsystemVersion */
1600 0, /* Win32VersionValue */
1601 0x6000, /* SizeOfImage */
1602 0x400, /* SizeOfHeaders */
1603 0x0, /* CheckSum */
1604 IMAGE_SUBSYSTEM_WINDOWS_CUI, /* Subsystem */
1605 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE |
1606 IMAGE_DLLCHARACTERISTICS_NO_SEH |
1607 IMAGE_DLLCHARACTERISTICS_NX_COMPAT, /* DllCharacteristics */
1608 0x100000, /* SizeOfStackReserve */
1609 0x1000, /* SizeOfStackCommit */
1610 0x100000, /* SizeOfHeapReserve */
1611 0x1000, /* SizeOfHeapCommit */
1612 0, /* LoaderFlags */
1613 0x10, /* NumberOfRvaAndSizes */
1614 /* IMAGE_DATA_DIRECTORY */
1615 {
1616 { 0 }, /* Export Table */
1617 { 0 }, /* Import Table */
1618 { 0 }, /* Resource Table */
1619 { 0 }, /* Exception Table */
1620 { 0 }, /* Certificate Table */
1621 { 0 }, /* Base Relocation Table */
1622 { 0 }, /* Debug */
1623 { 0 }, /* Copyright */
1624 { 0 }, /* Global Ptr */
1625 { 0 }, /* TLS Table */
1626 { 0 }, /* Load Config Table */
1627 { 0 }, /* Bound Import */
1628 { 0 }, /* IAT */
1629 { 0 }, /* Delay Import Descriptor */
1630 { 0 }, /* CLI Header */
1631 { 0 } /* Reserved */
1632 }
1633 }
1634 },
1635 /* IMAGE_SECTION_HEADER */
1636 {
1637 /* SizeOfRawData larger than VirtualSize */
1638 ".text", /* Name */
1639 { 0x1000 }, /* Misc.VirtualSize */
1640 0x1000, /* VirtualAddress */
1641 0x1200, /* SizeOfRawData */
1642 0x400, /* PointerToRawData */
1643 0, /* PointerToRelocations */
1644 0, /* PointerToLinenumbers */
1645 0, /* NumberOfRelocations */
1646 0, /* NumberOfLinenumbers */
1647 IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE |
1648 IMAGE_SCN_CNT_CODE, /* Characteristics */
1649 },
1650 /* IMAGE_SECTION_HEADER */
1651 {
1652 /* SizeOfRawData larger than VirtualSize */
1653 ".data", /* Name */
1654 { 0x100 }, /* Misc.VirtualSize */
1655 0x2000, /* VirtualAddress */
1656 0x1200, /* SizeOfRawData */
1657 0x1600, /* PointerToRawData */
1658 0, /* PointerToRelocations */
1659 0, /* PointerToLinenumbers */
1660 0, /* NumberOfRelocations */
1661 0, /* NumberOfLinenumbers */
1662 IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ |
1663 IMAGE_SCN_CNT_INITIALIZED_DATA, /* Characteristics */
1664 },
1665 /* IMAGE_SECTION_HEADER */
1666 {
1667 /* SizeOfRawData = 0 */
1668 ".zdata", /* Name */
1669 { 0x100 }, /* Misc.VirtualSize */
1670 0x3000, /* VirtualAddress */
1671 0, /* SizeOfRawData */
1672 0x2800, /* PointerToRawData */
1673 0, /* PointerToRelocations */
1674 0, /* PointerToLinenumbers */
1675 0, /* NumberOfRelocations */
1676 0, /* NumberOfLinenumbers */
1677 IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ |
1678 IMAGE_SCN_CNT_UNINITIALIZED_DATA, /* Characteristics */
1679 },
1680 /* IMAGE_SECTION_HEADER */
1681 {
1682 /* VirtualSize larger than SizeOfRawData */
1683 ".rsrc", /* Name */
1684 { 0x300 }, /* Misc.VirtualSize */
1685 0x4000, /* VirtualAddress */
1686 0x200, /* SizeOfRawData */
1687 0x2800, /* PointerToRawData */
1688 0, /* PointerToRelocations */
1689 0, /* PointerToLinenumbers */
1690 0, /* NumberOfRelocations */
1691 0, /* NumberOfLinenumbers */
1692 IMAGE_SCN_MEM_READ |
1693 IMAGE_SCN_CNT_INITIALIZED_DATA, /* Characteristics */
1694 },
1695 /* IMAGE_SECTION_HEADER */
1696 {
1697 /* PointerToRawData = 0 while SizeOfRawData != 0, CORE-18797 */
1698 ".bss", /* Name */
1699 { 0x400 }, /* Misc.VirtualSize */
1700 0x5000, /* VirtualAddress */
1701 0x600, /* SizeOfRawData */
1702 0, /* PointerToRawData */
1703 0, /* PointerToRelocations */
1704 0, /* PointerToLinenumbers */
1705 0, /* NumberOfRelocations */
1706 0, /* NumberOfLinenumbers */
1707 IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ |
1708 IMAGE_SCN_CNT_UNINITIALIZED_DATA, /* Characteristics */
1709 },
1710 /* fill */
1711 { 0 },
1712 /* text */
1713 {
1714 0xc3, 0, 0, 0, 0, 0, 0, 0,
1715 BYTES8(1),
1716 BYTES16(2),
1717 BYTES32(3),
1718 BYTES64(4),
1719 BYTES128(5),
1720 BYTES256(6),
1721 BYTES512(7),
1722 BYTES1024(8),
1723 BYTES1024(9),
1724 BYTES1024(0xa),
1725 BYTES512(0xb),
1726 },
1727 /* data */
1728 {
1729 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1730 BYTES8(0xaa),
1731 BYTES16(0xbb),
1732 BYTES32(0xcc),
1733 BYTES64(0xdd),
1734 BYTES128(0xee),
1735 BYTES256(0xff),
1736 BYTES512(0xee),
1737 BYTES1024(0xdd),
1738 BYTES1024(0xcc),
1739 BYTES1024(0xbb),
1740 BYTES512(0xaa),
1741 },
1742 /* rsrc */
1743 {
1744 BYTES256(0xff),
1745 BYTES128(0xee),
1746 BYTES64(0xdd),
1747 BYTES32(0xcc),
1748 BYTES16(0xbb),
1749 BYTES8(0xaa),
1750 0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0x01,
1751 },
1752};
1753
1754C_ASSERT(FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, text_data) == 0x400);
1755C_ASSERT(FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, data_data) == 0x1600);
1756C_ASSERT(FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, rsrc_data) == 0x2800);
1757
1758// CORE-17284
1759static
1760void
1761Test_RawSize(ULONG TestNumber)
1762{
1763 NTSTATUS Status;
1764 WCHAR TempPath[MAX_PATH];
1765 WCHAR FileName[MAX_PATH];
1766 HANDLE Handle;
1767 HANDLE SectionHandle;
1768 LARGE_INTEGER SectionOffset;
1769 PVOID BaseAddress;
1770 SIZE_T ViewSize;
1771 ULONG Written;
1772 ULONG Length;
1773 BOOL Success;
1774
1775 Length = GetTempPathW(MAX_PATH, TempPath);
1776 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1777 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1778 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1779 Handle = CreateFileW(FileName,
1780 FILE_ALL_ACCESS,
1781 0,
1782 NULL,
1783 CREATE_ALWAYS,
1784 0,
1785 NULL);
1786 if (Handle == INVALID_HANDLE_VALUE)
1787 {
1788 skip("Failed to create temp file %ls, error %lu\n", FileName, GetLastError());
1789 return;
1790 }
1791 RawSizeImageFile.nthdrs.OptionalHeader.ImageBase = 0xe400000;
1792 if (TestNumber == 1)
1793 {
1794 /* Just for fun, show that these flags don't matter. */
1795 RawSizeImageFile.text_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1796 RawSizeImageFile.data_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1797 RawSizeImageFile.zdata_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1798 RawSizeImageFile.rsrc_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1799 }
1800 else if (TestNumber == 2)
1801 {
1802 /* SizeOfRawData is too large and will overflow.
1803 * This should cause failure to load the file */
1804 RawSizeImageFile.rsrc_header.SizeOfRawData = (ULONG)-0x200;
1805 }
1806
1807 Success = WriteFile(Handle,
1808 &RawSizeImageFile,
1809 sizeof(RawSizeImageFile),
1810 &Written,
1811 NULL);
1812 ok(Success == TRUE, "WriteFile failed with %lu\n", GetLastError());
1813 ok(Written == sizeof(RawSizeImageFile), "WriteFile wrote %lu bytes\n", Written);
1814
1815 Status = NtCreateSection(&SectionHandle,
1816 SECTION_ALL_ACCESS,
1817 NULL,
1818 NULL,
1819 PAGE_EXECUTE_READWRITE,
1820 SEC_IMAGE,
1821 Handle);
1822 if (TestNumber == 2)
1823 {
1824 /* overflow in SizeOfRawData */
1825 ok_ntstatus(Status, STATUS_INVALID_IMAGE_FORMAT);
1826 }
1827 else
1828 {
1829 ok_ntstatus(Status, STATUS_SUCCESS);
1830 }
1831
1832 if (NT_SUCCESS(Status))
1833 {
1834 /* Map the section with */
1835 BaseAddress = NULL;
1836 SectionOffset.QuadPart = 0;
1837 ViewSize = 0;
1838 Status = NtMapViewOfSection(SectionHandle,
1839 NtCurrentProcess(),
1840 &BaseAddress,
1841 0,
1842 0,
1843 &SectionOffset,
1844 &ViewSize,
1845 ViewShare,
1846 0,
1847 PAGE_READWRITE);
1848 ok_ntstatus(Status, IsX86() ? STATUS_SUCCESS : STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
1849 if (NT_SUCCESS(Status))
1850 {
1851 PUCHAR Bytes = BaseAddress;
1852 struct _RAW_SIZE_IMAGE_FILE *ImageFile = BaseAddress;
1853
1854 /* .text section header is unmodified */
1855 ok_hex(ImageFile->text_header.Misc.VirtualSize, RawSizeImageFile.text_header.Misc.VirtualSize);
1856 ok_hex(ImageFile->text_header.VirtualAddress, RawSizeImageFile.text_header.VirtualAddress);
1857 ok_hex(ImageFile->text_header.SizeOfRawData, RawSizeImageFile.text_header.SizeOfRawData);
1858 ok_hex(ImageFile->text_header.PointerToRawData, RawSizeImageFile.text_header.PointerToRawData);
1859
1860 /* SizeOfRawData = 0 resets PointerToRawData to 0 */
1861 ok_hex(ImageFile->zdata_header.Misc.VirtualSize, RawSizeImageFile.zdata_header.Misc.VirtualSize);
1862 ok_hex(ImageFile->zdata_header.VirtualAddress, RawSizeImageFile.zdata_header.VirtualAddress);
1863 ok_hex(ImageFile->zdata_header.SizeOfRawData, RawSizeImageFile.zdata_header.SizeOfRawData);
1864 ok_hex(ImageFile->zdata_header.PointerToRawData, 0);
1865
1866 /* .bss section is unmodified */
1867 ok_hex(ImageFile->bss_header.SizeOfRawData, 0x600);
1868 ok_hex(ImageFile->bss_header.PointerToRawData, 0);
1869
1870#define TEST_BYTE(n, v) \
1871 StartSeh() \
1872 ok(Bytes[n] == v, "[%lu] Bytes[%u] = 0x%x, expected 0x%x\n", \
1873 TestNumber, n, Bytes[n], v); \
1874 EndSeh(STATUS_SUCCESS);
1875 /* .text section data matches file up to 0x1000 */
1876 TEST_BYTE(0x1000, 0xc3);
1877 TEST_BYTE(0x1001, 0x00);
1878 TEST_BYTE(0x1008, 0x01);
1879 TEST_BYTE(0x1010, 0x02);
1880 TEST_BYTE(0x1fff, 0x0a);
1881
1882 /* .data section data matches file up to 0x1000 */
1883 TEST_BYTE(0x2000, 0x01);
1884 TEST_BYTE(0x2001, 0x23);
1885 TEST_BYTE(0x20ff, 0xee);
1886 TEST_BYTE(0x2100, 0xff);
1887 TEST_BYTE(0x2fff, 0xbb);
1888
1889 /* .zdata section data is all zeroes */
1890 TEST_BYTE(0x3000, 0x00);
1891 TEST_BYTE(0x3001, 0x00);
1892 TEST_BYTE(0x3800, 0x00);
1893 TEST_BYTE(0x3fff, 0x00);
1894
1895 /* .rsrc section data matches file up to VirtualSize 0x200 */
1896 TEST_BYTE(0x4000, 0xff);
1897 TEST_BYTE(0x4100, 0xee);
1898 TEST_BYTE(0x4180, 0xdd);
1899 TEST_BYTE(0x41c0, 0xcc);
1900 TEST_BYTE(0x41e0, 0xbb);
1901 TEST_BYTE(0x41f0, 0xaa);
1902 TEST_BYTE(0x41fe, 0x23);
1903 TEST_BYTE(0x41ff, 0x01);
1904 TEST_BYTE(0x4200, 0x00);
1905 TEST_BYTE(0x4fff, 0x00);
1906#undef TEST_BYTE
1907 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
1908 ok_ntstatus(Status, STATUS_SUCCESS);
1909 }
1910 Status = NtClose(SectionHandle);
1911 ok_ntstatus(Status, STATUS_SUCCESS);
1912 }
1913
1914 CloseHandle(Handle);
1915 DeleteFileW(FileName);
1916}
1917
1918static void
1919Test_EmptyFile(VOID)
1920{
1921 NTSTATUS Status;
1922 WCHAR TempPath[MAX_PATH];
1923 WCHAR FileName[MAX_PATH];
1924 HANDLE Handle;
1925 HANDLE SectionHandle;
1926 ULONG Length;
1927
1928 Length = GetTempPathW(MAX_PATH, TempPath);
1929 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1930 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1931 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1932 Handle = CreateFileW(FileName,
1933 FILE_ALL_ACCESS,
1934 0,
1935 NULL,
1936 CREATE_ALWAYS,
1937 0,
1938 NULL);
1939 if (Handle == INVALID_HANDLE_VALUE)
1940 {
1941 skip("Failed to create temp file %ls, error %lu\n", FileName, GetLastError());
1942 return;
1943 }
1944
1945 Status = NtCreateSection(&SectionHandle,
1946 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1947 0, 0, PAGE_READONLY, SEC_COMMIT, Handle);
1948 ok_ntstatus(Status, STATUS_MAPPED_FILE_SIZE_ZERO);
1949
1950 if (NT_SUCCESS(Status))
1951 NtClose(SectionHandle);
1952
1953 Status = NtCreateSection(&SectionHandle,
1954 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1955 0, 0, PAGE_READONLY, SEC_IMAGE, Handle);
1956 ok_ntstatus(Status, STATUS_INVALID_FILE_FOR_SECTION);
1957
1958 if (NT_SUCCESS(Status))
1959 NtClose(SectionHandle);
1960
1961 CloseHandle(Handle);
1962 DeleteFileW(FileName);
1963}
1964
1965// CORE-11206
1966static void
1967Test_Truncate(VOID)
1968{
1969 WCHAR TempPath[MAX_PATH];
1970 WCHAR FileName[MAX_PATH];
1971 NTSTATUS Status;
1972 SIZE_T ViewSize = 0;
1973 HANDLE Handle;
1974 HANDLE SectionHandle;
1975
1976 SIZE_T Length;
1977 BOOL Success;
1978 DWORD Written, Error;
1979 VOID* BaseAddress;
1980
1981 Length = GetTempPathW(MAX_PATH, TempPath);
1982 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1983 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1984 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1985 Handle = CreateFileW(FileName, FILE_ALL_ACCESS, 0, NULL, CREATE_ALWAYS, 0, NULL);
1986
1987 Success = WriteFile(Handle, "TESTDATA", 8, &Written, NULL);
1988 ok(Success == TRUE, "WriteFile failed with %lu\n", GetLastError());
1989 ok(Written == 8, "WriteFile wrote %lu bytes\n", Written);
1990
1991 Written = SetFilePointer(Handle, 6, NULL, FILE_BEGIN);
1992 ok(Written == 6, "SetFilePointer returned %lu bytes\n", Written);
1993 Success = SetEndOfFile(Handle);
1994 ok(Success == TRUE, "SetEndOfFile failed with %lu\n", GetLastError());
1995
1996 Status = NtCreateSection(&SectionHandle,
1997 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1998 0, 0, PAGE_READONLY, SEC_COMMIT, Handle);
1999 ok_ntstatus(Status, STATUS_SUCCESS);
2000 BaseAddress = NULL;
2001 ViewSize = 0;
2002 Status = NtMapViewOfSection(SectionHandle, NtCurrentProcess(), &BaseAddress, 0,
2003 0, 0, &ViewSize, ViewShare, 0, PAGE_READONLY);
2004 ok_ntstatus(Status, STATUS_SUCCESS);
2005
2006 if (BaseAddress)
2007 {
2008 // First we test data that was truncated even before the file mapping was opened
2009 Length = strlen((char*)BaseAddress);
2010 ok(Length == 6, "Old data was not properly erased! (Length=%lu)\n", Length);
2011 }
2012
2013 // Now we truncate the file on disk some more
2014 Written = SetFilePointer(Handle, 4, NULL, FILE_BEGIN);
2015 ok(Written == 4, "SetFilePointer returned %lu bytes\n", Written);
2016 Success = SetEndOfFile(Handle);
2017 Error = GetLastError();
2018 ok(Success == FALSE, "SetEndOfFile succeeded\n");
2019 ok(Error == ERROR_USER_MAPPED_FILE, "SetEndOfFile did not set error to ERROR_USER_MAPPED_FILE (%lu)\n", Error);
2020
2021 if (BaseAddress)
2022 {
2023 Length = strlen((char*)BaseAddress);
2024 ok(Length == 6, "Length should not have changed! (Length=%lu)\n", Length);
2025 }
2026
2027 // Unmap and set the end shorter.
2028 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
2029 ok_ntstatus(Status, STATUS_SUCCESS);
2030 Success = CloseHandle(SectionHandle);
2031 ok(Success == TRUE, "CloseHandle failed with %lu\n", GetLastError());
2032
2033 Written = SetFilePointer(Handle, 4, NULL, FILE_BEGIN);
2034 ok(Written == 4, "SetFilePointer returned %lu bytes\n", Written);
2035 Success = SetEndOfFile(Handle);
2036 ok(Success == TRUE, "SetEndOfFile failed with %lu\n", GetLastError());
2037
2038 Status = NtCreateSection(&SectionHandle,
2039 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
2040 0, 0, PAGE_READONLY, SEC_COMMIT, Handle);
2041 ok_ntstatus(Status, STATUS_SUCCESS);
2042 BaseAddress = NULL;
2043 ViewSize = 0;
2044 Status = NtMapViewOfSection(SectionHandle, NtCurrentProcess(), &BaseAddress, 0,
2045 0, 0, &ViewSize, ViewShare, 0, PAGE_READONLY);
2046 ok_ntstatus(Status, STATUS_SUCCESS);
2047
2048 // CLEANUP
2049 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
2050 ok_ntstatus(Status, STATUS_SUCCESS);
2051 Success = CloseHandle(SectionHandle);
2052 ok(Success == TRUE, "CloseHandle failed with %lu\n", GetLastError());
2053 Success = CloseHandle(Handle);
2054 ok(Success == TRUE, "CloseHandle failed with %lu\n", GetLastError());
2055
2056 Success = DeleteFileW(FileName);
2057 ok(Success == TRUE, "DeleteFileW failed with %lu\n", GetLastError());
2058}
2059
2060START_TEST(NtMapViewOfSection)
2061{
2062 Test_PageFileSection();
2063 Test_ImageSection();
2064 Test_BasedSection();
2065 Test_SectionContents(FALSE);
2066 Test_SectionContents(TRUE);
2067 Test_RawSize(0);
2068 Test_RawSize(1);
2069 Test_RawSize(2);
2070 Test_EmptyFile();
2071 Test_Truncate();
2072}
NtUnmapViewOfSection
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3483
NtCreateSection
NTSTATUS NTAPI NtCreateSection(OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize OPTIONAL, IN ULONG SectionPageProtection OPTIONAL, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL)
Definition: section.c:3076
NtMapViewOfSection
NTSTATUS NTAPI NtMapViewOfSection(IN HANDLE SectionHandle, IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:3257
BYTES512
#define BYTES512(x)
Definition: NtMapViewOfSection.c:1194
BYTES256
#define BYTES256(x)
Definition: NtMapViewOfSection.c:1193
BYTES128
#define BYTES128(x)
Definition: NtMapViewOfSection.c:1192
BYTES32
#define BYTES32(x)
Definition: NtMapViewOfSection.c:1190
BYTES1024
#define BYTES1024(x)
Definition: NtMapViewOfSection.c:1195
Test_ImageSection2
void Test_ImageSection2(void)
Definition: NtMapViewOfSection.c:1027
TEST_WRITE
#define TEST_WRITE(n)
Test_SectionContents
static void Test_SectionContents(BOOL Relocate)
Definition: NtMapViewOfSection.c:1411
TEST_NOWRITE
#define TEST_NOWRITE(n)
Test_PageFileSection
void Test_PageFileSection(void)
Definition: NtMapViewOfSection.c:20
BYTES64
#define BYTES64(x)
Definition: NtMapViewOfSection.c:1191
TEST_BYTE
#define TEST_BYTE(n, v)
Test_ImageSection
void Test_ImageSection(void)
Definition: NtMapViewOfSection.c:760
Test_EmptyFile
static void Test_EmptyFile(VOID)
Definition: NtMapViewOfSection.c:1919
IsX86
#define IsX86()
Definition: NtMapViewOfSection.c:16
BYTES8
#define BYTES8(x)
Definition: NtMapViewOfSection.c:1188
SectionContentsImageFile
static struct _SECTION_CONTENTS_IMAGE_FILE SectionContentsImageFile
Test_BasedSection
void Test_BasedSection(void)
Definition: NtMapViewOfSection.c:1112
RawSizeImageFile
static struct _RAW_SIZE_IMAGE_FILE RawSizeImageFile
Test_RawSize
static void Test_RawSize(ULONG TestNumber)
Definition: NtMapViewOfSection.c:1761
Test_Truncate
static void Test_Truncate(VOID)
Definition: NtMapViewOfSection.c:1967
BYTES16
#define BYTES16(x)
Definition: NtMapViewOfSection.c:1189
RTL_NUMBER_OF
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17
ok_hex
#define ok_hex(expression, result)
Definition: atltest.h:94
ok_ntstatus
#define ok_ntstatus(status, expected)
Definition: atltest.h:135
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
Error
BOOL Error
Definition: chkdsk.c:66
MAXULONG_PTR
#define MAXULONG_PTR
Definition: basetsd.h:97
STATUS_NO_MEMORY
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
CloseHandle
#define CloseHandle
Definition: compat.h:739
PAGE_READONLY
#define PAGE_READONLY
Definition: compat.h:138
FILE_BEGIN
#define FILE_BEGIN
Definition: compat.h:761
SECTION_MAP_READ
#define SECTION_MAP_READ
Definition: compat.h:139
wcsrchr
#define wcsrchr
Definition: compat.h:16
SetFilePointer
#define SetFilePointer
Definition: compat.h:743
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
CreateFileW
#define CreateFileW
Definition: compat.h:741
FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:136
DeleteFileW
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
SetEndOfFile
BOOL WINAPI SetEndOfFile(HANDLE hFile)
Definition: fileinfo.c:988
WriteFile
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
GetModuleFileNameW
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
GetTempPathW
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:1999
system
_ACRTIMP int __cdecl system(const char *)
Definition: process.c:1297
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1592
L
#define L(x)
Definition: resources.c:13
UlongToPtr
#define UlongToPtr(u)
Definition: config.h:106
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
PAGE_SIZE
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Success
@ Success
Definition: eventcreate.c:712
FileName
struct _FileName FileName
Definition: fatprocs.h:897
GetTempFileNameW
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
FileHandle
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
printf
#define printf
Definition: freeldr.h:104
FILE_SYNCHRONOUS_IO_NONALERT
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
Handle
ULONG Handle
Definition: gdb_input.c:15
Status
Status
Definition: gdiplustypes.h:25
ImageFile
static PWSTR ImageFile
Definition: imagefile.c:10
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
C_ASSERT
#define C_ASSERT(e)
Definition: intsafe.h:73
Bytes
_In_ UINT Bytes
Definition: mmcopy.h:9
CREATE_ALWAYS
#define CREATE_ALWAYS
Definition: disk.h:72
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
MaximumSize
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_opt_ PLARGE_INTEGER MaximumSize
Definition: mmfuncs.h:362
BaseAddress
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
SectionOffset
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER SectionOffset
Definition: mmfuncs.h:407
ViewSize
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
SEC_COMMIT
#define SEC_COMMIT
Definition: mmtypes.h:100
SEC_IMAGE
#define SEC_IMAGE
Definition: mmtypes.h:97
RtlDosPathNameToNtPathName_U
NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToNtPathName_U(_In_opt_z_ PCWSTR DosPathName, _Out_ PUNICODE_STRING NtPathName, _Out_opt_ PCWSTR *NtFileNamePart, _Out_opt_ PRTL_RELATIVE_NAME_U DirectoryInfo)
NtOpenFile
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3953
SYNCHRONIZE
#define SYNCHRONIZE
Definition: nt_native.h:61
MEM_DECOMMIT
#define MEM_DECOMMIT
Definition: nt_native.h:1318
PAGE_READWRITE
#define PAGE_READWRITE
Definition: nt_native.h:1307
SECTION_ALL_ACCESS
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1296
SECTION_QUERY
#define SECTION_QUERY
Definition: nt_native.h:1290
SEC_RESERVE
#define SEC_RESERVE
Definition: nt_native.h:1326
NtCurrentProcess
#define NtCurrentProcess()
Definition: nt_native.h:1660
ViewShare
@ ViewShare
Definition: nt_native.h:1281
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
MEM_RESERVE
#define MEM_RESERVE
Definition: nt_native.h:1317
FILE_ALL_ACCESS
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
MEM_RELEASE
#define MEM_RELEASE
Definition: nt_native.h:1319
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
MEM_COMMIT
#define MEM_COMMIT
Definition: nt_native.h:1316
PAGE_NOACCESS
#define PAGE_NOACCESS
Definition: nt_native.h:1305
PAGE_EXECUTE_READWRITE
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1311
STANDARD_RIGHTS_REQUIRED
#define STANDARD_RIGHTS_REQUIRED
Definition: nt_native.h:63
UNICODE_NULL
#define UNICODE_NULL
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
IoStatusBlock
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
SEC_BASED
#define SEC_BASED
Definition: ntifs.template.h:1357
IMAGE_SCN_MEM_WRITE
#define IMAGE_SCN_MEM_WRITE
Definition: ntimage.h:241
IMAGE_NT_OPTIONAL_HDR32_MAGIC
#define IMAGE_NT_OPTIONAL_HDR32_MAGIC
Definition: ntimage.h:376
IMAGE_SUBSYSTEM_WINDOWS_CUI
#define IMAGE_SUBSYSTEM_WINDOWS_CUI
Definition: ntimage.h:438
IMAGE_DLLCHARACTERISTICS_NX_COMPAT
#define IMAGE_DLLCHARACTERISTICS_NX_COMPAT
Definition: ntimage.h:457
IMAGE_SCN_CNT_INITIALIZED_DATA
#define IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: ntimage.h:231
IMAGE_NT_OPTIONAL_HDR64_MAGIC
#define IMAGE_NT_OPTIONAL_HDR64_MAGIC
Definition: ntimage.h:377
IMAGE_SCN_CNT_CODE
#define IMAGE_SCN_CNT_CODE
Definition: ntimage.h:230
IMAGE_SCN_MEM_EXECUTE
#define IMAGE_SCN_MEM_EXECUTE
Definition: ntimage.h:239
IMAGE_DLLCHARACTERISTICS_NO_SEH
#define IMAGE_DLLCHARACTERISTICS_NO_SEH
Definition: ntimage.h:459
IMAGE_SCN_MEM_READ
#define IMAGE_SCN_MEM_READ
Definition: ntimage.h:240
IMAGE_SCN_CNT_UNINITIALIZED_DATA
#define IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition: ntimage.h:232
IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
#define IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
Definition: ntimage.h:455
NtFreeVirtualMemory
NTSTATUS NTAPI NtFreeVirtualMemory(IN HANDLE ProcessHandle, IN PVOID *UBaseAddress, IN PSIZE_T URegionSize, IN ULONG FreeType)
Definition: virtual.c:5192
NtProtectVirtualMemory
NTSTATUS NTAPI NtProtectVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UnsafeBaseAddress, IN OUT SIZE_T *UnsafeNumberOfBytesToProtect, IN ULONG NewAccessProtection, OUT PULONG UnsafeOldAccessProtection)
Definition: virtual.c:3076
NtFlushVirtualMemory
NTSTATUS NTAPI NtFlushVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN OUT PSIZE_T NumberOfBytesToFlush, OUT PIO_STATUS_BLOCK IoStatusBlock)
Definition: virtual.c:4000
NtAllocateVirtualMemory
NTSTATUS NTAPI NtAllocateVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UBaseAddress, IN ULONG_PTR ZeroBits, IN OUT PSIZE_T URegionSize, IN ULONG AllocationType, IN ULONG Protect)
Definition: virtual.c:4457
STATUS_INVALID_VIEW_SIZE
#define STATUS_INVALID_VIEW_SIZE
Definition: ntstatus.h:361
STATUS_MAPPED_ALIGNMENT
#define STATUS_MAPPED_ALIGNMENT
Definition: ntstatus.h:798
STATUS_SECTION_PROTECTION
#define STATUS_SECTION_PROTECTION
Definition: ntstatus.h:408
STATUS_UNABLE_TO_DELETE_SECTION
#define STATUS_UNABLE_TO_DELETE_SECTION
Definition: ntstatus.h:357
STATUS_INVALID_IMAGE_FORMAT
#define STATUS_INVALID_IMAGE_FORMAT
Definition: ntstatus.h:453
STATUS_IMAGE_MACHINE_TYPE_MISMATCH
#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH
Definition: ntstatus.h:203
STATUS_INVALID_PARAMETER_9
#define STATUS_INVALID_PARAMETER_9
Definition: ntstatus.h:577
STATUS_INVALID_PARAMETER_4
#define STATUS_INVALID_PARAMETER_4
Definition: ntstatus.h:572
STATUS_INVALID_IMAGE_NOT_MZ
#define STATUS_INVALID_IMAGE_NOT_MZ
Definition: ntstatus.h:633
STATUS_INVALID_FILE_FOR_SECTION
#define STATUS_INVALID_FILE_FOR_SECTION
Definition: ntstatus.h:362
STATUS_MAPPED_FILE_SIZE_ZERO
#define STATUS_MAPPED_FILE_SIZE_ZERO
Definition: ntstatus.h:616
STATUS_CONFLICTING_ADDRESSES
#define STATUS_CONFLICTING_ADDRESSES
Definition: ntstatus.h:354
STATUS_INVALID_PAGE_PROTECTION
#define STATUS_INVALID_PAGE_PROTECTION
Definition: ntstatus.h:399
STATUS_SECTION_TOO_BIG
#define STATUS_SECTION_TOO_BIG
Definition: ntstatus.h:394
STATUS_INVALID_PARAMETER_3
#define STATUS_INVALID_PARAMETER_3
Definition: ntstatus.h:571
STATUS_IMAGE_NOT_AT_BASE
#define STATUS_IMAGE_NOT_AT_BASE
Definition: ntstatus.h:192
STATUS_COMMITMENT_LIMIT
#define STATUS_COMMITMENT_LIMIT
Definition: ntstatus.h:631
IMAGE_SCN_TYPE_NOLOAD
#define IMAGE_SCN_TYPE_NOLOAD
Definition: pecoff.h:20
IMAGE_FILE_EXECUTABLE_IMAGE
#define IMAGE_FILE_EXECUTABLE_IMAGE
Definition: pedump.c:160
IMAGE_FILE_MACHINE_I386
#define IMAGE_FILE_MACHINE_I386
Definition: pedump.c:174
IMAGE_FILE_LOCAL_SYMS_STRIPPED
#define IMAGE_FILE_LOCAL_SYMS_STRIPPED
Definition: pedump.c:162
IMAGE_NT_SIGNATURE
#define IMAGE_NT_SIGNATURE
Definition: pedump.c:93
IMAGE_FILE_DLL
#define IMAGE_FILE_DLL
Definition: pedump.c:169
IMAGE_FILE_LINE_NUMS_STRIPPED
#define IMAGE_FILE_LINE_NUMS_STRIPPED
Definition: pedump.c:161
IMAGE_DOS_SIGNATURE
#define IMAGE_DOS_SIGNATURE
Definition: pedump.c:89
IMAGE_FILE_32BIT_MACHINE
#define IMAGE_FILE_32BIT_MACHINE
Definition: pedump.c:164
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71
wine_dbgstr_wn
#define wine_dbgstr_wn
Definition: testlist.c:2
_WIN32_WINNT_WIN10
#define _WIN32_WINNT_WIN10
Definition: sdkddkver.h:32
_WIN32_WINNT_VISTA
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
StringCbCatW
STRSAFEAPI StringCbCatW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:342
_FileName
Definition: filecomp.c:348
_IMAGE_DOS_HEADER
Definition: ntddk_ex.h:99
_IMAGE_NT_HEADERS
Definition: ntddk_ex.h:181
_IMAGE_SECTION_HEADER
Definition: pedump.c:280
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_OBJECT_ATTRIBUTES
Definition: umtypes.h:184
_RAW_SIZE_IMAGE_FILE
Definition: NtMapViewOfSection.c:1538
_RAW_SIZE_IMAGE_FILE::text_data
BYTE text_data[0x1200]
Definition: NtMapViewOfSection.c:1548
_RAW_SIZE_IMAGE_FILE::nthdrs
IMAGE_NT_HEADERS32 nthdrs
Definition: NtMapViewOfSection.c:1541
_RAW_SIZE_IMAGE_FILE::pad
BYTE pad[448]
Definition: NtMapViewOfSection.c:1547
_RAW_SIZE_IMAGE_FILE::zdata_header
IMAGE_SECTION_HEADER zdata_header
Definition: NtMapViewOfSection.c:1544
_RAW_SIZE_IMAGE_FILE::doshdr
IMAGE_DOS_HEADER doshdr
Definition: NtMapViewOfSection.c:1539
_RAW_SIZE_IMAGE_FILE::rsrc_data
BYTE rsrc_data[0x400]
Definition: NtMapViewOfSection.c:1550
_RAW_SIZE_IMAGE_FILE::data_header
IMAGE_SECTION_HEADER data_header
Definition: NtMapViewOfSection.c:1543
_RAW_SIZE_IMAGE_FILE::bss_header
IMAGE_SECTION_HEADER bss_header
Definition: NtMapViewOfSection.c:1546
_RAW_SIZE_IMAGE_FILE::text_header
IMAGE_SECTION_HEADER text_header
Definition: NtMapViewOfSection.c:1542
_RAW_SIZE_IMAGE_FILE::data_data
BYTE data_data[0x1200]
Definition: NtMapViewOfSection.c:1549
_RAW_SIZE_IMAGE_FILE::rsrc_header
IMAGE_SECTION_HEADER rsrc_header
Definition: NtMapViewOfSection.c:1545
_SECTION_CONTENTS_IMAGE_FILE
Definition: NtMapViewOfSection.c:1198
_SECTION_CONTENTS_IMAGE_FILE::rossym_header
IMAGE_SECTION_HEADER rossym_header
Definition: NtMapViewOfSection.c:1203
_SECTION_CONTENTS_IMAGE_FILE::rossym_data
BYTE rossym_data[0x400]
Definition: NtMapViewOfSection.c:1212
_SECTION_CONTENTS_IMAGE_FILE::clc_header
IMAGE_SECTION_HEADER clc_header
Definition: NtMapViewOfSection.c:1205
_SECTION_CONTENTS_IMAGE_FILE::clc_data
BYTE clc_data[0x1000]
Definition: NtMapViewOfSection.c:1214
_SECTION_CONTENTS_IMAGE_FILE::nthdrs
IMAGE_NT_HEADERS nthdrs
Definition: NtMapViewOfSection.c:1201
_SECTION_CONTENTS_IMAGE_FILE::doshdr
IMAGE_DOS_HEADER doshdr
Definition: NtMapViewOfSection.c:1199
_SECTION_CONTENTS_IMAGE_FILE::text_header
IMAGE_SECTION_HEADER text_header
Definition: NtMapViewOfSection.c:1202
_SECTION_CONTENTS_IMAGE_FILE::rsrc_data
BYTE rsrc_data[0x400]
Definition: NtMapViewOfSection.c:1213
_SECTION_CONTENTS_IMAGE_FILE::rsrc_header
IMAGE_SECTION_HEADER rsrc_header
Definition: NtMapViewOfSection.c:1204
_SECTION_CONTENTS_IMAGE_FILE::pad
BYTE pad[488]
Definition: NtMapViewOfSection.c:1209
_SECTION_CONTENTS_IMAGE_FILE::text_data
BYTE text_data[0x400]
Definition: NtMapViewOfSection.c:1211
_UNICODE_STRING
Definition: env_spec_w32.h:368
_stub
Definition: stubgen.c:11
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
PVOID
void * PVOID
Definition: typedefs.h:50
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
ULONG
uint32_t ULONG
Definition: typedefs.h:59
PCHAR
char * PCHAR
Definition: typedefs.h:51
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_LARGE_INTEGER
Definition: typedefs.h:103
FileObjectAttributes
_In_ PWDFDEVICE_INIT _In_ PWDF_FILEOBJECT_CONFIG _In_opt_ PWDF_OBJECT_ATTRIBUTES FileObjectAttributes
Definition: wdfdevice.h:3406
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
GetModuleHandle
#define GetModuleHandle
Definition: winbase.h:3576
ERROR_USER_MAPPED_FILE
#define ERROR_USER_MAPPED_FILE
Definition: winerror.h:1056
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
BYTE
unsigned char BYTE
Definition: xxhash.c:193