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