2 * Unit test suite for the PE loader.
4 * Copyright 2006,2011 Dmitry Timoshkov
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #define WIN32_NO_STATUS
30 #include "wine/test.h"
32 #define ALIGN_SIZE(size, alignment) (((size) + (alignment - 1)) & ~((alignment - 1)))
35 static LONG
*child_failures
;
37 static NTSTATUS (WINAPI
*pNtMapViewOfSection
)(HANDLE
, HANDLE
, PVOID
*, ULONG
, SIZE_T
, const LARGE_INTEGER
*, SIZE_T
*, ULONG
, ULONG
, ULONG
);
38 static NTSTATUS (WINAPI
*pNtUnmapViewOfSection
)(HANDLE
, PVOID
);
39 static NTSTATUS (WINAPI
*pNtTerminateProcess
)(HANDLE
, DWORD
);
40 static void (WINAPI
*pLdrShutdownProcess
)(void);
41 static BOOLEAN (WINAPI
*pRtlDllShutdownInProgress
)(void);
43 static PVOID
RVAToAddr(DWORD_PTR rva
, HMODULE module
)
47 return ((char*) module
) + rva
;
52 WORD e_magic
; /* 00: MZ Header signature */
54 DWORD e_lfanew
; /* 3c: Offset to extended header */
57 IMAGE_DOS_SIGNATURE
, { 0 }, sizeof(dos_header
)
60 static IMAGE_NT_HEADERS nt_header
=
62 IMAGE_NT_SIGNATURE
, /* Signature */
65 IMAGE_FILE_MACHINE_I386
, /* Machine */
66 #elif defined __x86_64__
67 IMAGE_FILE_MACHINE_AMD64
, /* Machine */
68 #elif defined __powerpc__
69 IMAGE_FILE_MACHINE_POWERPC
, /* Machine */
71 IMAGE_FILE_MACHINE_ARMNT
, /* Machine */
72 #elif defined __aarch64__
73 IMAGE_FILE_MACHINE_ARM64
, /* Machine */
75 # error You must specify the machine type
77 1, /* NumberOfSections */
78 0, /* TimeDateStamp */
79 0, /* PointerToSymbolTable */
80 0, /* NumberOfSymbols */
81 sizeof(IMAGE_OPTIONAL_HEADER
), /* SizeOfOptionalHeader */
82 IMAGE_FILE_EXECUTABLE_IMAGE
| IMAGE_FILE_DLL
/* Characteristics */
84 { IMAGE_NT_OPTIONAL_HDR_MAGIC
, /* Magic */
85 1, /* MajorLinkerVersion */
86 0, /* MinorLinkerVersion */
88 0, /* SizeOfInitializedData */
89 0, /* SizeOfUninitializedData */
90 0, /* AddressOfEntryPoint */
91 0x10, /* BaseOfCode, also serves as e_lfanew in the truncated MZ header */
95 0x10000000, /* ImageBase */
96 0, /* SectionAlignment */
97 0, /* FileAlignment */
98 4, /* MajorOperatingSystemVersion */
99 0, /* MinorOperatingSystemVersion */
100 1, /* MajorImageVersion */
101 0, /* MinorImageVersion */
102 4, /* MajorSubsystemVersion */
103 0, /* MinorSubsystemVersion */
104 0, /* Win32VersionValue */
105 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x1000, /* SizeOfImage */
106 sizeof(dos_header
) + sizeof(nt_header
), /* SizeOfHeaders */
108 IMAGE_SUBSYSTEM_WINDOWS_CUI
, /* Subsystem */
109 0, /* DllCharacteristics */
110 0, /* SizeOfStackReserve */
111 0, /* SizeOfStackCommit */
112 0, /* SizeOfHeapReserve */
113 0, /* SizeOfHeapCommit */
115 0, /* NumberOfRvaAndSizes */
116 { { 0 } } /* DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] */
120 static IMAGE_SECTION_HEADER section
=
122 ".rodata", /* Name */
124 0, /* VirtualAddress */
125 0x0a, /* SizeOfRawData */
126 0, /* PointerToRawData */
127 0, /* PointerToRelocations */
128 0, /* PointerToLinenumbers */
129 0, /* NumberOfRelocations */
130 0, /* NumberOfLinenumbers */
131 IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_READ
, /* Characteristics */
134 static void test_Loader(void)
136 static const struct test_data
138 const void *dos_header
;
139 DWORD size_of_dos_header
;
140 WORD number_of_sections
, size_of_optional_header
;
141 DWORD section_alignment
, file_alignment
;
142 DWORD size_of_image
, size_of_headers
;
143 DWORD errors
[4]; /* 0 means LoadLibrary should succeed */
146 { &dos_header
, sizeof(dos_header
),
148 { ERROR_BAD_EXE_FORMAT
}
150 { &dos_header
, sizeof(dos_header
),
151 1, sizeof(IMAGE_OPTIONAL_HEADER
), 0x1000, 0x1000,
152 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0xe00,
153 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
),
154 { ERROR_BAD_EXE_FORMAT
} /* XP doesn't like too small image size */
156 { &dos_header
, sizeof(dos_header
),
157 1, sizeof(IMAGE_OPTIONAL_HEADER
), 0x1000, 0x1000,
158 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x1000,
159 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
),
162 { &dos_header
, sizeof(dos_header
),
163 1, sizeof(IMAGE_OPTIONAL_HEADER
), 0x1000, 0x1000,
168 { &dos_header
, sizeof(dos_header
),
169 1, sizeof(IMAGE_OPTIONAL_HEADER
), 0x200, 0x200,
170 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x200,
171 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
),
172 { ERROR_SUCCESS
, ERROR_INVALID_ADDRESS
} /* vista is more strict */
174 { &dos_header
, sizeof(dos_header
),
175 1, sizeof(IMAGE_OPTIONAL_HEADER
), 0x200, 0x1000,
176 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x1000,
177 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
),
178 { ERROR_BAD_EXE_FORMAT
} /* XP doesn't like alignments */
180 { &dos_header
, sizeof(dos_header
),
181 1, sizeof(IMAGE_OPTIONAL_HEADER
), 0x1000, 0x200,
182 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x1000,
183 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
),
186 { &dos_header
, sizeof(dos_header
),
187 1, sizeof(IMAGE_OPTIONAL_HEADER
), 0x1000, 0x200,
188 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x1000,
192 /* Mandatory are all fields up to SizeOfHeaders, everything else
193 * is really optional (at least that's true for XP).
195 { &dos_header
, sizeof(dos_header
),
196 1, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 0x200, 0x200,
197 sizeof(dos_header
) + sizeof(DWORD
) + sizeof(IMAGE_FILE_HEADER
) + FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
) + sizeof(IMAGE_SECTION_HEADER
) + 0x10,
198 sizeof(dos_header
) + sizeof(DWORD
) + sizeof(IMAGE_FILE_HEADER
) + FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
) + sizeof(IMAGE_SECTION_HEADER
),
199 { ERROR_SUCCESS
, ERROR_BAD_EXE_FORMAT
, ERROR_INVALID_ADDRESS
,
202 { &dos_header
, sizeof(dos_header
),
203 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 0x200, 0x200,
204 0xd0, /* beyond of the end of file */
205 0xc0, /* beyond of the end of file */
206 { ERROR_SUCCESS
, ERROR_BAD_EXE_FORMAT
} /* vista is more strict */
208 { &dos_header
, sizeof(dos_header
),
209 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 0x200, 0x200,
212 { ERROR_SUCCESS
, ERROR_BAD_EXE_FORMAT
} /* vista is more strict */
214 { &dos_header
, sizeof(dos_header
),
215 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 0x200, 0x200,
218 { ERROR_SUCCESS
, ERROR_BAD_EXE_FORMAT
} /* vista is more strict */
220 #if 0 /* not power of 2 alignments need more test cases */
221 { &dos_header
, sizeof(dos_header
),
222 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 0x300, 0x300,
225 { ERROR_BAD_EXE_FORMAT
} /* alignment is not power of 2 */
228 { &dos_header
, sizeof(dos_header
),
229 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 4, 4,
232 { ERROR_SUCCESS
, ERROR_BAD_EXE_FORMAT
} /* vista is more strict */
234 { &dos_header
, sizeof(dos_header
),
235 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 1, 1,
238 { ERROR_SUCCESS
, ERROR_BAD_EXE_FORMAT
} /* vista is more strict */
240 { &dos_header
, sizeof(dos_header
),
241 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
), 0x200, 0x200,
244 { ERROR_BAD_EXE_FORMAT
} /* image size == 0 -> failure */
246 /* the following data mimics the PE image which upack creates */
248 1, 0x148, 0x1000, 0x200,
249 sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x1000,
253 /* Minimal PE image that XP is able to load: 92 bytes */
255 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER
, CheckSum
),
256 0x04 /* also serves as e_lfanew in the truncated MZ header */, 0x04,
259 { ERROR_SUCCESS
, ERROR_BAD_EXE_FORMAT
} /* vista is more strict */
262 static const char filler
[0x1000];
263 static const char section_data
[0x10] = "section data";
265 DWORD dummy
, file_size
, file_align
;
267 HMODULE hlib
, hlib_as_data_file
;
269 char temp_path
[MAX_PATH
];
270 char dll_name
[MAX_PATH
];
276 /* prevent displaying of the "Unable to load this DLL" message box */
277 SetErrorMode(SEM_FAILCRITICALERRORS
);
279 GetTempPath(MAX_PATH
, temp_path
);
281 for (i
= 0; i
< sizeof(td
)/sizeof(td
[0]); i
++)
283 GetTempFileName(temp_path
, "ldr", 0, dll_name
);
285 /*trace("creating %s\n", dll_name);*/
286 hfile
= CreateFileA(dll_name
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0);
287 if (hfile
== INVALID_HANDLE_VALUE
)
289 ok(0, "could not create %s\n", dll_name
);
293 SetLastError(0xdeadbeef);
294 ret
= WriteFile(hfile
, td
[i
].dos_header
, td
[i
].size_of_dos_header
, &dummy
, NULL
);
295 ok(ret
, "WriteFile error %d\n", GetLastError());
297 nt_header
.FileHeader
.NumberOfSections
= td
[i
].number_of_sections
;
298 nt_header
.FileHeader
.SizeOfOptionalHeader
= td
[i
].size_of_optional_header
;
300 nt_header
.OptionalHeader
.SectionAlignment
= td
[i
].section_alignment
;
301 nt_header
.OptionalHeader
.FileAlignment
= td
[i
].file_alignment
;
302 nt_header
.OptionalHeader
.SizeOfImage
= td
[i
].size_of_image
;
303 nt_header
.OptionalHeader
.SizeOfHeaders
= td
[i
].size_of_headers
;
304 SetLastError(0xdeadbeef);
305 ret
= WriteFile(hfile
, &nt_header
, sizeof(DWORD
) + sizeof(IMAGE_FILE_HEADER
), &dummy
, NULL
);
306 ok(ret
, "WriteFile error %d\n", GetLastError());
308 if (nt_header
.FileHeader
.SizeOfOptionalHeader
)
310 SetLastError(0xdeadbeef);
311 ret
= WriteFile(hfile
, &nt_header
.OptionalHeader
,
312 min(nt_header
.FileHeader
.SizeOfOptionalHeader
, sizeof(IMAGE_OPTIONAL_HEADER
)),
314 ok(ret
, "WriteFile error %d\n", GetLastError());
315 if (nt_header
.FileHeader
.SizeOfOptionalHeader
> sizeof(IMAGE_OPTIONAL_HEADER
))
317 file_align
= nt_header
.FileHeader
.SizeOfOptionalHeader
- sizeof(IMAGE_OPTIONAL_HEADER
);
318 assert(file_align
< sizeof(filler
));
319 SetLastError(0xdeadbeef);
320 ret
= WriteFile(hfile
, filler
, file_align
, &dummy
, NULL
);
321 ok(ret
, "WriteFile error %d\n", GetLastError());
325 assert(nt_header
.FileHeader
.NumberOfSections
<= 1);
326 if (nt_header
.FileHeader
.NumberOfSections
)
328 if (nt_header
.OptionalHeader
.SectionAlignment
>= si
.dwPageSize
)
330 section
.PointerToRawData
= td
[i
].size_of_dos_header
;
331 section
.VirtualAddress
= nt_header
.OptionalHeader
.SectionAlignment
;
332 section
.Misc
.VirtualSize
= section
.SizeOfRawData
* 10;
336 section
.PointerToRawData
= nt_header
.OptionalHeader
.SizeOfHeaders
;
337 section
.VirtualAddress
= nt_header
.OptionalHeader
.SizeOfHeaders
;
338 section
.Misc
.VirtualSize
= 5;
341 SetLastError(0xdeadbeef);
342 ret
= WriteFile(hfile
, §ion
, sizeof(section
), &dummy
, NULL
);
343 ok(ret
, "WriteFile error %d\n", GetLastError());
346 SetLastError(0xdeadbeef);
347 ret
= WriteFile(hfile
, section_data
, sizeof(section_data
), &dummy
, NULL
);
348 ok(ret
, "WriteFile error %d\n", GetLastError());
351 file_size
= GetFileSize(hfile
, NULL
);
354 SetLastError(0xdeadbeef);
355 hlib
= LoadLibrary(dll_name
);
358 MEMORY_BASIC_INFORMATION info
;
360 ok( td
[i
].errors
[0] == ERROR_SUCCESS
, "%d: should have failed\n", i
);
362 SetLastError(0xdeadbeef);
363 size
= VirtualQuery(hlib
, &info
, sizeof(info
));
364 ok(size
== sizeof(info
),
365 "%d: VirtualQuery error %d\n", i
, GetLastError());
366 ok(info
.BaseAddress
== hlib
, "%d: %p != %p\n", i
, info
.BaseAddress
, hlib
);
367 ok(info
.AllocationBase
== hlib
, "%d: %p != %p\n", i
, info
.AllocationBase
, hlib
);
368 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.AllocationProtect
);
369 ok(info
.RegionSize
== ALIGN_SIZE(nt_header
.OptionalHeader
.SizeOfImage
, si
.dwPageSize
), "%d: got %lx != expected %x\n",
370 i
, info
.RegionSize
, ALIGN_SIZE(nt_header
.OptionalHeader
.SizeOfImage
, si
.dwPageSize
));
371 ok(info
.State
== MEM_COMMIT
, "%d: %x != MEM_COMMIT\n", i
, info
.State
);
372 if (nt_header
.OptionalHeader
.SectionAlignment
< si
.dwPageSize
)
373 ok(info
.Protect
== PAGE_EXECUTE_WRITECOPY
, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.Protect
);
375 ok(info
.Protect
== PAGE_READONLY
, "%d: %x != PAGE_READONLY\n", i
, info
.Protect
);
376 ok(info
.Type
== SEC_IMAGE
, "%d: %x != SEC_IMAGE\n", i
, info
.Type
);
378 SetLastError(0xdeadbeef);
379 size
= VirtualQuery((char *)hlib
+ info
.RegionSize
, &info
, sizeof(info
));
380 ok(size
== sizeof(info
),
381 "%d: VirtualQuery error %d\n", i
, GetLastError());
382 if (nt_header
.OptionalHeader
.SectionAlignment
== si
.dwPageSize
||
383 nt_header
.OptionalHeader
.SectionAlignment
== nt_header
.OptionalHeader
.FileAlignment
)
385 ok(info
.BaseAddress
== (char *)hlib
+ ALIGN_SIZE(nt_header
.OptionalHeader
.SizeOfImage
, si
.dwPageSize
), "%d: got %p != expected %p\n",
386 i
, info
.BaseAddress
, (char *)hlib
+ ALIGN_SIZE(nt_header
.OptionalHeader
.SizeOfImage
, si
.dwPageSize
));
387 ok(info
.AllocationBase
== 0, "%d: %p != 0\n", i
, info
.AllocationBase
);
388 ok(info
.AllocationProtect
== 0, "%d: %x != 0\n", i
, info
.AllocationProtect
);
389 /*ok(info.RegionSize == not_practical_value, "%d: %lx != not_practical_value\n", i, info.RegionSize);*/
390 ok(info
.State
== MEM_FREE
, "%d: %x != MEM_FREE\n", i
, info
.State
);
391 ok(info
.Type
== 0, "%d: %x != 0\n", i
, info
.Type
);
392 ok(info
.Protect
== PAGE_NOACCESS
, "%d: %x != PAGE_NOACCESS\n", i
, info
.Protect
);
396 ok(info
.Protect
== PAGE_EXECUTE_WRITECOPY
, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.Protect
);
397 ok(info
.BaseAddress
== hlib
, "%d: got %p != expected %p\n", i
, info
.BaseAddress
, hlib
);
398 ok(info
.AllocationBase
== hlib
, "%d: %p != %p\n", i
, info
.AllocationBase
, hlib
);
399 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.AllocationProtect
);
400 ok(info
.RegionSize
== ALIGN_SIZE(file_size
, si
.dwPageSize
), "%d: got %lx != expected %x\n",
401 i
, info
.RegionSize
, ALIGN_SIZE(file_size
, si
.dwPageSize
));
402 ok(info
.State
== MEM_COMMIT
, "%d: %x != MEM_COMMIT\n", i
, info
.State
);
403 ok(info
.Protect
== PAGE_READONLY
, "%d: %x != PAGE_READONLY\n", i
, info
.Protect
);
404 ok(info
.Type
== SEC_IMAGE
, "%d: %x != SEC_IMAGE\n", i
, info
.Type
);
407 /* header: check the zeroing of alignment */
408 if (nt_header
.OptionalHeader
.SectionAlignment
>= si
.dwPageSize
)
412 start
= (const char *)hlib
+ nt_header
.OptionalHeader
.SizeOfHeaders
;
413 size
= ALIGN_SIZE((ULONG_PTR
)start
, si
.dwPageSize
) - (ULONG_PTR
)start
;
414 ok(!memcmp(start
, filler
, size
), "%d: header alignment is not cleared\n", i
);
417 if (nt_header
.FileHeader
.NumberOfSections
)
419 SetLastError(0xdeadbeef);
420 size
= VirtualQuery((char *)hlib
+ section
.VirtualAddress
, &info
, sizeof(info
));
421 ok(size
== sizeof(info
),
422 "%d: VirtualQuery error %d\n", i
, GetLastError());
423 if (nt_header
.OptionalHeader
.SectionAlignment
< si
.dwPageSize
)
425 ok(info
.BaseAddress
== hlib
, "%d: got %p != expected %p\n", i
, info
.BaseAddress
, hlib
);
426 ok(info
.RegionSize
== ALIGN_SIZE(nt_header
.OptionalHeader
.SizeOfImage
, si
.dwPageSize
), "%d: got %lx != expected %x\n",
427 i
, info
.RegionSize
, ALIGN_SIZE(nt_header
.OptionalHeader
.SizeOfImage
, si
.dwPageSize
));
428 ok(info
.Protect
== PAGE_EXECUTE_WRITECOPY
, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.Protect
);
432 ok(info
.BaseAddress
== (char *)hlib
+ section
.VirtualAddress
, "%d: got %p != expected %p\n", i
, info
.BaseAddress
, (char *)hlib
+ section
.VirtualAddress
);
433 ok(info
.RegionSize
== ALIGN_SIZE(section
.Misc
.VirtualSize
, si
.dwPageSize
), "%d: got %lx != expected %x\n",
434 i
, info
.RegionSize
, ALIGN_SIZE(section
.Misc
.VirtualSize
, si
.dwPageSize
));
435 ok(info
.Protect
== PAGE_READONLY
, "%d: %x != PAGE_READONLY\n", i
, info
.Protect
);
437 ok(info
.AllocationBase
== hlib
, "%d: %p != %p\n", i
, info
.AllocationBase
, hlib
);
438 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.AllocationProtect
);
439 ok(info
.State
== MEM_COMMIT
, "%d: %x != MEM_COMMIT\n", i
, info
.State
);
440 ok(info
.Type
== SEC_IMAGE
, "%d: %x != SEC_IMAGE\n", i
, info
.Type
);
442 if (nt_header
.OptionalHeader
.SectionAlignment
>= si
.dwPageSize
)
443 ok(!memcmp((const char *)hlib
+ section
.VirtualAddress
+ section
.PointerToRawData
, &nt_header
, section
.SizeOfRawData
), "wrong section data\n");
445 ok(!memcmp((const char *)hlib
+ section
.PointerToRawData
, section_data
, section
.SizeOfRawData
), "wrong section data\n");
447 /* check the zeroing of alignment */
448 if (nt_header
.OptionalHeader
.SectionAlignment
>= si
.dwPageSize
)
452 start
= (const char *)hlib
+ section
.VirtualAddress
+ section
.PointerToRawData
+ section
.SizeOfRawData
;
453 size
= ALIGN_SIZE((ULONG_PTR
)start
, si
.dwPageSize
) - (ULONG_PTR
)start
;
454 ok(memcmp(start
, filler
, size
), "%d: alignment should not be cleared\n", i
);
458 SetLastError(0xdeadbeef);
459 hlib_as_data_file
= LoadLibraryEx(dll_name
, 0, LOAD_LIBRARY_AS_DATAFILE
);
460 ok(hlib_as_data_file
!= 0, "LoadLibraryEx error %u\n", GetLastError());
461 ok(hlib_as_data_file
== hlib
, "hlib_as_file and hlib are different\n");
463 SetLastError(0xdeadbeef);
464 ret
= FreeLibrary(hlib
);
465 ok(ret
, "FreeLibrary error %d\n", GetLastError());
467 SetLastError(0xdeadbeef);
468 hlib
= GetModuleHandle(dll_name
);
469 ok(hlib
!= 0, "GetModuleHandle error %u\n", GetLastError());
471 SetLastError(0xdeadbeef);
472 ret
= FreeLibrary(hlib_as_data_file
);
473 ok(ret
, "FreeLibrary error %d\n", GetLastError());
475 hlib
= GetModuleHandle(dll_name
);
476 ok(!hlib
, "GetModuleHandle should fail\n");
478 SetLastError(0xdeadbeef);
479 hlib_as_data_file
= LoadLibraryEx(dll_name
, 0, LOAD_LIBRARY_AS_DATAFILE
);
480 ok(hlib_as_data_file
!= 0, "LoadLibraryEx error %u\n", GetLastError());
481 ok((ULONG_PTR
)hlib_as_data_file
& 1, "hlib_as_data_file is even\n");
483 hlib
= GetModuleHandle(dll_name
);
484 ok(!hlib
, "GetModuleHandle should fail\n");
486 SetLastError(0xdeadbeef);
487 ret
= FreeLibrary(hlib_as_data_file
);
488 ok(ret
, "FreeLibrary error %d\n", GetLastError());
496 for (error_index
= 0;
497 ! error_match
&& error_index
< sizeof(td
[i
].errors
) / sizeof(DWORD
);
500 error_match
= td
[i
].errors
[error_index
] == GetLastError();
502 ok(error_match
, "%d: unexpected error %d\n", i
, GetLastError());
505 SetLastError(0xdeadbeef);
506 ret
= DeleteFile(dll_name
);
507 ok(ret
, "DeleteFile error %d\n", GetLastError());
511 /* Verify linking style of import descriptors */
512 static void test_ImportDescriptors(void)
514 HMODULE kernel32_module
= NULL
;
515 PIMAGE_DOS_HEADER d_header
;
516 PIMAGE_NT_HEADERS nt_headers
;
517 DWORD import_dir_size
;
518 DWORD_PTR dir_offset
;
519 PIMAGE_IMPORT_DESCRIPTOR import_chunk
;
521 /* Load kernel32 module */
522 kernel32_module
= GetModuleHandleA("kernel32.dll");
523 assert( kernel32_module
!= NULL
);
525 /* Get PE header info from module image */
526 d_header
= (PIMAGE_DOS_HEADER
) kernel32_module
;
527 nt_headers
= (PIMAGE_NT_HEADERS
) (((char*) d_header
) +
530 /* Get size of import entry directory */
531 import_dir_size
= nt_headers
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_IMPORT
].Size
;
532 if (!import_dir_size
)
534 skip("Unable to continue testing due to missing import directory.\n");
538 /* Get address of first import chunk */
539 dir_offset
= nt_headers
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_IMPORT
].VirtualAddress
;
540 import_chunk
= RVAToAddr(dir_offset
, kernel32_module
);
541 ok(import_chunk
!= 0, "Invalid import_chunk: %p\n", import_chunk
);
542 if (!import_chunk
) return;
544 /* Iterate through import descriptors and verify set name,
545 * OriginalFirstThunk, and FirstThunk. Core Windows DLLs, such as
546 * kernel32.dll, don't use Borland-style linking, where the table of
547 * imported names is stored directly in FirstThunk and overwritten
548 * by the relocation, instead of being stored in OriginalFirstThunk.
550 for (; import_chunk
->FirstThunk
; import_chunk
++)
552 LPCSTR module_name
= RVAToAddr(import_chunk
->Name
, kernel32_module
);
553 PIMAGE_THUNK_DATA name_table
= RVAToAddr(
554 U(*import_chunk
).OriginalFirstThunk
, kernel32_module
);
555 PIMAGE_THUNK_DATA iat
= RVAToAddr(
556 import_chunk
->FirstThunk
, kernel32_module
);
557 ok(module_name
!= NULL
, "Imported module name should not be NULL\n");
558 ok(name_table
!= NULL
,
559 "Name table for imported module %s should not be NULL\n",
561 ok(iat
!= NULL
, "IAT for imported module %s should not be NULL\n",
566 static void test_image_mapping(const char *dll_name
, DWORD scn_page_access
, BOOL is_dll
)
570 LARGE_INTEGER offset
;
573 MEMORY_BASIC_INFORMATION info
;
576 if (!pNtMapViewOfSection
) return;
580 SetLastError(0xdeadbeef);
581 hfile
= CreateFile(dll_name
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
582 ok(hfile
!= INVALID_HANDLE_VALUE
, "CreateFile error %d\n", GetLastError());
584 SetLastError(0xdeadbeef);
585 hmap
= CreateFileMapping(hfile
, NULL
, PAGE_READONLY
| SEC_IMAGE
, 0, 0, 0);
586 ok(hmap
!= 0, "CreateFileMapping error %d\n", GetLastError());
588 offset
.u
.LowPart
= 0;
589 offset
.u
.HighPart
= 0;
593 status
= pNtMapViewOfSection(hmap
, GetCurrentProcess(), &addr1
, 0, 0, &offset
,
594 &size
, 1 /* ViewShare */, 0, PAGE_READONLY
);
595 ok(status
== STATUS_SUCCESS
, "NtMapViewOfSection error %x\n", status
);
596 ok(addr1
!= 0, "mapped address should be valid\n");
598 SetLastError(0xdeadbeef);
599 size
= VirtualQuery((char *)addr1
+ section
.VirtualAddress
, &info
, sizeof(info
));
600 ok(size
== sizeof(info
), "VirtualQuery error %d\n", GetLastError());
601 ok(info
.BaseAddress
== (char *)addr1
+ section
.VirtualAddress
, "got %p != expected %p\n", info
.BaseAddress
, (char *)addr1
+ section
.VirtualAddress
);
602 ok(info
.RegionSize
== si
.dwPageSize
, "got %#lx != expected %#x\n", info
.RegionSize
, si
.dwPageSize
);
603 ok(info
.Protect
== scn_page_access
, "got %#x != expected %#x\n", info
.Protect
, scn_page_access
);
604 ok(info
.AllocationBase
== addr1
, "%p != %p\n", info
.AllocationBase
, addr1
);
605 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%#x != PAGE_EXECUTE_WRITECOPY\n", info
.AllocationProtect
);
606 ok(info
.State
== MEM_COMMIT
, "%#x != MEM_COMMIT\n", info
.State
);
607 ok(info
.Type
== SEC_IMAGE
, "%#x != SEC_IMAGE\n", info
.Type
);
611 status
= pNtMapViewOfSection(hmap
, GetCurrentProcess(), &addr2
, 0, 0, &offset
,
612 &size
, 1 /* ViewShare */, 0, PAGE_READONLY
);
613 /* FIXME: remove once Wine is fixed */
614 if (status
!= STATUS_IMAGE_NOT_AT_BASE
)
617 ok(status
== STATUS_IMAGE_NOT_AT_BASE
, "expected STATUS_IMAGE_NOT_AT_BASE, got %x\n", status
);
618 ok(addr2
!= 0, "mapped address should be valid\n");
622 ok(status
== STATUS_IMAGE_NOT_AT_BASE
, "expected STATUS_IMAGE_NOT_AT_BASE, got %x\n", status
);
623 ok(addr2
!= 0, "mapped address should be valid\n");
624 ok(addr2
!= addr1
, "mapped addresses should be different\n");
626 SetLastError(0xdeadbeef);
627 size
= VirtualQuery((char *)addr2
+ section
.VirtualAddress
, &info
, sizeof(info
));
628 ok(size
== sizeof(info
), "VirtualQuery error %d\n", GetLastError());
629 ok(info
.BaseAddress
== (char *)addr2
+ section
.VirtualAddress
, "got %p != expected %p\n", info
.BaseAddress
, (char *)addr2
+ section
.VirtualAddress
);
630 ok(info
.RegionSize
== si
.dwPageSize
, "got %#lx != expected %#x\n", info
.RegionSize
, si
.dwPageSize
);
631 ok(info
.Protect
== scn_page_access
, "got %#x != expected %#x\n", info
.Protect
, scn_page_access
);
632 ok(info
.AllocationBase
== addr2
, "%p != %p\n", info
.AllocationBase
, addr2
);
633 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%#x != PAGE_EXECUTE_WRITECOPY\n", info
.AllocationProtect
);
634 ok(info
.State
== MEM_COMMIT
, "%#x != MEM_COMMIT\n", info
.State
);
635 ok(info
.Type
== SEC_IMAGE
, "%#x != SEC_IMAGE\n", info
.Type
);
637 status
= pNtUnmapViewOfSection(GetCurrentProcess(), addr2
);
638 ok(status
== STATUS_SUCCESS
, "NtUnmapViewOfSection error %x\n", status
);
640 addr2
= MapViewOfFile(hmap
, 0, 0, 0, 0);
641 ok(addr2
!= 0, "mapped address should be valid\n");
642 ok(addr2
!= addr1
, "mapped addresses should be different\n");
644 SetLastError(0xdeadbeef);
645 size
= VirtualQuery((char *)addr2
+ section
.VirtualAddress
, &info
, sizeof(info
));
646 ok(size
== sizeof(info
), "VirtualQuery error %d\n", GetLastError());
647 ok(info
.BaseAddress
== (char *)addr2
+ section
.VirtualAddress
, "got %p != expected %p\n", info
.BaseAddress
, (char *)addr2
+ section
.VirtualAddress
);
648 ok(info
.RegionSize
== si
.dwPageSize
, "got %#lx != expected %#x\n", info
.RegionSize
, si
.dwPageSize
);
649 ok(info
.Protect
== scn_page_access
, "got %#x != expected %#x\n", info
.Protect
, scn_page_access
);
650 ok(info
.AllocationBase
== addr2
, "%p != %p\n", info
.AllocationBase
, addr2
);
651 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%#x != PAGE_EXECUTE_WRITECOPY\n", info
.AllocationProtect
);
652 ok(info
.State
== MEM_COMMIT
, "%#x != MEM_COMMIT\n", info
.State
);
653 ok(info
.Type
== SEC_IMAGE
, "%#x != SEC_IMAGE\n", info
.Type
);
655 UnmapViewOfFile(addr2
);
657 SetLastError(0xdeadbeef);
658 addr2
= LoadLibrary(dll_name
);
661 ok(!addr2
, "LoadLibrary should fail, is_dll %d\n", is_dll
);
662 ok(GetLastError() == ERROR_INVALID_ADDRESS
, "expected ERROR_INVALID_ADDRESS, got %d\n", GetLastError());
667 ok(addr2
!= 0, "LoadLibrary error %d, is_dll %d\n", GetLastError(), is_dll
);
668 ok(addr2
!= addr1
, "mapped addresses should be different\n");
670 SetLastError(0xdeadbeef);
671 ret
= FreeLibrary(addr2
);
672 ok(ret
, "FreeLibrary error %d\n", GetLastError());
676 status
= pNtUnmapViewOfSection(GetCurrentProcess(), addr1
);
677 ok(status
== STATUS_SUCCESS
, "NtUnmapViewOfSection error %x\n", status
);
683 static BOOL
is_mem_writable(DWORD prot
)
689 case PAGE_EXECUTE_READWRITE
:
690 case PAGE_EXECUTE_WRITECOPY
:
698 static void test_VirtualProtect(void *base
, void *section
)
700 static const struct test_data
702 DWORD prot_set
, prot_get
;
706 { PAGE_NOACCESS
, PAGE_NOACCESS
}, /* 0x01 */
707 { PAGE_READONLY
, PAGE_READONLY
}, /* 0x02 */
708 { PAGE_READONLY
| PAGE_NOACCESS
, 0 }, /* 0x03 */
709 { PAGE_READWRITE
, PAGE_WRITECOPY
}, /* 0x04 */
710 { PAGE_READWRITE
| PAGE_NOACCESS
, 0 }, /* 0x05 */
711 { PAGE_READWRITE
| PAGE_READONLY
, 0 }, /* 0x06 */
712 { PAGE_READWRITE
| PAGE_READONLY
| PAGE_NOACCESS
, 0 }, /* 0x07 */
713 { PAGE_WRITECOPY
, PAGE_WRITECOPY
}, /* 0x08 */
714 { PAGE_WRITECOPY
| PAGE_NOACCESS
, 0 }, /* 0x09 */
715 { PAGE_WRITECOPY
| PAGE_READONLY
, 0 }, /* 0x0a */
716 { PAGE_WRITECOPY
| PAGE_NOACCESS
| PAGE_READONLY
, 0 }, /* 0x0b */
717 { PAGE_WRITECOPY
| PAGE_READWRITE
, 0 }, /* 0x0c */
718 { PAGE_WRITECOPY
| PAGE_READWRITE
| PAGE_NOACCESS
, 0 }, /* 0x0d */
719 { PAGE_WRITECOPY
| PAGE_READWRITE
| PAGE_READONLY
, 0 }, /* 0x0e */
720 { PAGE_WRITECOPY
| PAGE_READWRITE
| PAGE_READONLY
| PAGE_NOACCESS
, 0 }, /* 0x0f */
722 { PAGE_EXECUTE
, PAGE_EXECUTE
}, /* 0x10 */
723 { PAGE_EXECUTE_READ
, PAGE_EXECUTE_READ
}, /* 0x20 */
724 { PAGE_EXECUTE_READ
| PAGE_EXECUTE
, 0 }, /* 0x30 */
725 { PAGE_EXECUTE_READWRITE
, PAGE_EXECUTE_WRITECOPY
}, /* 0x40 */
726 { PAGE_EXECUTE_READWRITE
| PAGE_EXECUTE
, 0 }, /* 0x50 */
727 { PAGE_EXECUTE_READWRITE
| PAGE_EXECUTE_READ
, 0 }, /* 0x60 */
728 { PAGE_EXECUTE_READWRITE
| PAGE_EXECUTE_READ
| PAGE_EXECUTE
, 0 }, /* 0x70 */
729 { PAGE_EXECUTE_WRITECOPY
, PAGE_EXECUTE_WRITECOPY
}, /* 0x80 */
730 { PAGE_EXECUTE_WRITECOPY
| PAGE_EXECUTE
, 0 }, /* 0x90 */
731 { PAGE_EXECUTE_WRITECOPY
| PAGE_EXECUTE_READ
, 0 }, /* 0xa0 */
732 { PAGE_EXECUTE_WRITECOPY
| PAGE_EXECUTE_READ
| PAGE_EXECUTE
, 0 }, /* 0xb0 */
733 { PAGE_EXECUTE_WRITECOPY
| PAGE_EXECUTE_READWRITE
, 0 }, /* 0xc0 */
734 { PAGE_EXECUTE_WRITECOPY
| PAGE_EXECUTE_READWRITE
| PAGE_EXECUTE
, 0 }, /* 0xd0 */
735 { PAGE_EXECUTE_WRITECOPY
| PAGE_EXECUTE_READWRITE
| PAGE_EXECUTE_READ
, 0 }, /* 0xe0 */
736 { PAGE_EXECUTE_WRITECOPY
| PAGE_EXECUTE_READWRITE
| PAGE_EXECUTE_READ
| PAGE_EXECUTE
, 0 } /* 0xf0 */
738 DWORD ret
, orig_prot
, old_prot
, rw_prot
, exec_prot
, i
, j
;
739 MEMORY_BASIC_INFORMATION info
;
744 SetLastError(0xdeadbeef);
745 ret
= VirtualProtect(section
, si
.dwPageSize
, PAGE_NOACCESS
, &old_prot
);
746 ok(ret
, "VirtualProtect error %d\n", GetLastError());
748 orig_prot
= old_prot
;
750 for (i
= 0; i
< sizeof(td
)/sizeof(td
[0]); i
++)
752 SetLastError(0xdeadbeef);
753 ret
= VirtualQuery(section
, &info
, sizeof(info
));
754 ok(ret
, "VirtualQuery failed %d\n", GetLastError());
755 ok(info
.BaseAddress
== section
, "%d: got %p != expected %p\n", i
, info
.BaseAddress
, section
);
756 ok(info
.RegionSize
== si
.dwPageSize
, "%d: got %#lx != expected %#x\n", i
, info
.RegionSize
, si
.dwPageSize
);
757 ok(info
.Protect
== PAGE_NOACCESS
, "%d: got %#x != expected PAGE_NOACCESS\n", i
, info
.Protect
);
758 ok(info
.AllocationBase
== base
, "%d: %p != %p\n", i
, info
.AllocationBase
, base
);
759 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.AllocationProtect
);
760 ok(info
.State
== MEM_COMMIT
, "%d: %#x != MEM_COMMIT\n", i
, info
.State
);
761 ok(info
.Type
== SEC_IMAGE
, "%d: %#x != SEC_IMAGE\n", i
, info
.Type
);
763 old_prot
= 0xdeadbeef;
764 SetLastError(0xdeadbeef);
765 ret
= VirtualProtect(section
, si
.dwPageSize
, td
[i
].prot_set
, &old_prot
);
768 ok(ret
, "%d: VirtualProtect error %d, requested prot %#x\n", i
, GetLastError(), td
[i
].prot_set
);
769 ok(old_prot
== PAGE_NOACCESS
, "%d: got %#x != expected PAGE_NOACCESS\n", i
, old_prot
);
771 SetLastError(0xdeadbeef);
772 ret
= VirtualQuery(section
, &info
, sizeof(info
));
773 ok(ret
, "VirtualQuery failed %d\n", GetLastError());
774 ok(info
.BaseAddress
== section
, "%d: got %p != expected %p\n", i
, info
.BaseAddress
, section
);
775 ok(info
.RegionSize
== si
.dwPageSize
, "%d: got %#lx != expected %#x\n", i
, info
.RegionSize
, si
.dwPageSize
);
776 ok(info
.Protect
== td
[i
].prot_get
, "%d: got %#x != expected %#x\n", i
, info
.Protect
, td
[i
].prot_get
);
777 ok(info
.AllocationBase
== base
, "%d: %p != %p\n", i
, info
.AllocationBase
, base
);
778 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.AllocationProtect
);
779 ok(info
.State
== MEM_COMMIT
, "%d: %#x != MEM_COMMIT\n", i
, info
.State
);
780 ok(info
.Type
== SEC_IMAGE
, "%d: %#x != SEC_IMAGE\n", i
, info
.Type
);
784 ok(!ret
, "%d: VirtualProtect should fail\n", i
);
785 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "%d: expected ERROR_INVALID_PARAMETER, got %d\n", i
, GetLastError());
788 old_prot
= 0xdeadbeef;
789 SetLastError(0xdeadbeef);
790 ret
= VirtualProtect(section
, si
.dwPageSize
, PAGE_NOACCESS
, &old_prot
);
791 ok(ret
, "%d: VirtualProtect error %d\n", i
, GetLastError());
793 ok(old_prot
== td
[i
].prot_get
, "%d: got %#x != expected %#x\n", i
, old_prot
, td
[i
].prot_get
);
795 ok(old_prot
== PAGE_NOACCESS
, "%d: got %#x != expected PAGE_NOACCESS\n", i
, old_prot
);
800 for (i
= 0; i
<= 4; i
++)
804 for (j
= 0; j
<= 4; j
++)
806 DWORD prot
= exec_prot
| rw_prot
;
808 SetLastError(0xdeadbeef);
809 ret
= VirtualProtect(section
, si
.dwPageSize
, prot
, &old_prot
);
810 if ((rw_prot
&& exec_prot
) || (!rw_prot
&& !exec_prot
))
812 ok(!ret
, "VirtualProtect(%02x) should fail\n", prot
);
813 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
816 ok(ret
, "VirtualProtect(%02x) error %d\n", prot
, GetLastError());
821 exec_prot
= 1 << (i
+ 4);
824 SetLastError(0xdeadbeef);
825 ret
= VirtualProtect(section
, si
.dwPageSize
, orig_prot
, &old_prot
);
826 ok(ret
, "VirtualProtect error %d\n", GetLastError());
829 static void test_section_access(void)
831 static const struct test_data
833 DWORD scn_file_access
, scn_page_access
, scn_page_access_after_write
;
836 { 0, PAGE_NOACCESS
, 0 },
837 { IMAGE_SCN_MEM_READ
, PAGE_READONLY
, 0 },
838 { IMAGE_SCN_MEM_WRITE
, PAGE_WRITECOPY
, PAGE_READWRITE
},
839 { IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE
, 0 },
840 { IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
, PAGE_WRITECOPY
, PAGE_READWRITE
},
841 { IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_READ
},
842 { IMAGE_SCN_MEM_WRITE
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_WRITECOPY
, PAGE_EXECUTE_READWRITE
},
843 { IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_WRITECOPY
, PAGE_EXECUTE_READWRITE
},
845 { IMAGE_SCN_CNT_INITIALIZED_DATA
, PAGE_NOACCESS
, 0 },
846 { IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_READ
, PAGE_READONLY
, 0 },
847 { IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
, PAGE_WRITECOPY
, PAGE_READWRITE
},
848 { IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE
, 0 },
849 { IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
, PAGE_WRITECOPY
, PAGE_READWRITE
},
850 { IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_READ
, 0 },
851 { IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_WRITECOPY
, PAGE_EXECUTE_READWRITE
},
852 { IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_WRITECOPY
, PAGE_EXECUTE_READWRITE
},
854 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
, PAGE_NOACCESS
, 0 },
855 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_READ
, PAGE_READONLY
, 0 },
856 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
, PAGE_WRITECOPY
, PAGE_READWRITE
},
857 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE
, 0 },
858 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
, PAGE_WRITECOPY
, PAGE_READWRITE
},
859 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_READ
, 0 },
860 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_WRITECOPY
, PAGE_EXECUTE_READWRITE
},
861 { IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
| IMAGE_SCN_MEM_EXECUTE
, PAGE_EXECUTE_WRITECOPY
, PAGE_EXECUTE_READWRITE
}
863 static const char filler
[0x1000];
864 static const char section_data
[0x10] = "section data";
867 DWORD dummy
, file_align
;
871 char temp_path
[MAX_PATH
];
872 char dll_name
[MAX_PATH
];
874 MEMORY_BASIC_INFORMATION info
;
876 PROCESS_INFORMATION pi
;
881 /* prevent displaying of the "Unable to load this DLL" message box */
882 SetErrorMode(SEM_FAILCRITICALERRORS
);
884 GetTempPath(MAX_PATH
, temp_path
);
886 for (i
= 0; i
< sizeof(td
)/sizeof(td
[0]); i
++)
888 GetTempFileName(temp_path
, "ldr", 0, dll_name
);
890 /*trace("creating %s\n", dll_name);*/
891 hfile
= CreateFileA(dll_name
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0);
892 if (hfile
== INVALID_HANDLE_VALUE
)
894 ok(0, "could not create %s\n", dll_name
);
898 SetLastError(0xdeadbeef);
899 ret
= WriteFile(hfile
, &dos_header
, sizeof(dos_header
), &dummy
, NULL
);
900 ok(ret
, "WriteFile error %d\n", GetLastError());
902 nt_header
.FileHeader
.NumberOfSections
= 1;
903 nt_header
.FileHeader
.SizeOfOptionalHeader
= sizeof(IMAGE_OPTIONAL_HEADER
);
904 nt_header
.FileHeader
.Characteristics
= IMAGE_FILE_EXECUTABLE_IMAGE
| IMAGE_FILE_DLL
| IMAGE_FILE_RELOCS_STRIPPED
;
906 nt_header
.OptionalHeader
.SectionAlignment
= si
.dwPageSize
;
907 nt_header
.OptionalHeader
.FileAlignment
= 0x200;
908 nt_header
.OptionalHeader
.SizeOfImage
= sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + si
.dwPageSize
;
909 nt_header
.OptionalHeader
.SizeOfHeaders
= sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
);
910 SetLastError(0xdeadbeef);
911 ret
= WriteFile(hfile
, &nt_header
, sizeof(DWORD
) + sizeof(IMAGE_FILE_HEADER
), &dummy
, NULL
);
912 ok(ret
, "WriteFile error %d\n", GetLastError());
913 SetLastError(0xdeadbeef);
914 ret
= WriteFile(hfile
, &nt_header
.OptionalHeader
, sizeof(IMAGE_OPTIONAL_HEADER
), &dummy
, NULL
);
915 ok(ret
, "WriteFile error %d\n", GetLastError());
917 section
.SizeOfRawData
= sizeof(section_data
);
918 section
.PointerToRawData
= nt_header
.OptionalHeader
.FileAlignment
;
919 section
.VirtualAddress
= nt_header
.OptionalHeader
.SectionAlignment
;
920 section
.Misc
.VirtualSize
= section
.SizeOfRawData
;
921 section
.Characteristics
= td
[i
].scn_file_access
;
922 SetLastError(0xdeadbeef);
923 ret
= WriteFile(hfile
, §ion
, sizeof(section
), &dummy
, NULL
);
924 ok(ret
, "WriteFile error %d\n", GetLastError());
926 file_align
= nt_header
.OptionalHeader
.FileAlignment
- nt_header
.OptionalHeader
.SizeOfHeaders
;
927 assert(file_align
< sizeof(filler
));
928 SetLastError(0xdeadbeef);
929 ret
= WriteFile(hfile
, filler
, file_align
, &dummy
, NULL
);
930 ok(ret
, "WriteFile error %d\n", GetLastError());
933 SetLastError(0xdeadbeef);
934 ret
= WriteFile(hfile
, section_data
, sizeof(section_data
), &dummy
, NULL
);
935 ok(ret
, "WriteFile error %d\n", GetLastError());
939 SetLastError(0xdeadbeef);
940 hlib
= LoadLibrary(dll_name
);
941 ok(hlib
!= 0, "LoadLibrary error %d\n", GetLastError());
943 SetLastError(0xdeadbeef);
944 size
= VirtualQuery((char *)hlib
+ section
.VirtualAddress
, &info
, sizeof(info
));
945 ok(size
== sizeof(info
),
946 "%d: VirtualQuery error %d\n", i
, GetLastError());
947 ok(info
.BaseAddress
== (char *)hlib
+ section
.VirtualAddress
, "%d: got %p != expected %p\n", i
, info
.BaseAddress
, (char *)hlib
+ section
.VirtualAddress
);
948 ok(info
.RegionSize
== si
.dwPageSize
, "%d: got %#lx != expected %#x\n", i
, info
.RegionSize
, si
.dwPageSize
);
949 ok(info
.Protect
== td
[i
].scn_page_access
, "%d: got %#x != expected %#x\n", i
, info
.Protect
, td
[i
].scn_page_access
);
950 ok(info
.AllocationBase
== hlib
, "%d: %p != %p\n", i
, info
.AllocationBase
, hlib
);
951 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.AllocationProtect
);
952 ok(info
.State
== MEM_COMMIT
, "%d: %#x != MEM_COMMIT\n", i
, info
.State
);
953 ok(info
.Type
== SEC_IMAGE
, "%d: %#x != SEC_IMAGE\n", i
, info
.Type
);
954 if (info
.Protect
!= PAGE_NOACCESS
)
955 ok(!memcmp((const char *)info
.BaseAddress
, section_data
, section
.SizeOfRawData
), "wrong section data\n");
957 test_VirtualProtect(hlib
, (char *)hlib
+ section
.VirtualAddress
);
959 /* Windows changes the WRITECOPY to WRITE protection on an image section write (for a changed page only) */
960 if (is_mem_writable(info
.Protect
))
962 char *p
= info
.BaseAddress
;
964 SetLastError(0xdeadbeef);
965 size
= VirtualQuery((char *)hlib
+ section
.VirtualAddress
, &info
, sizeof(info
));
966 ok(size
== sizeof(info
), "%d: VirtualQuery error %d\n", i
, GetLastError());
967 /* FIXME: remove the condition below once Wine is fixed */
968 if (info
.Protect
== PAGE_WRITECOPY
|| info
.Protect
== PAGE_EXECUTE_WRITECOPY
)
969 todo_wine
ok(info
.Protect
== td
[i
].scn_page_access_after_write
, "%d: got %#x != expected %#x\n", i
, info
.Protect
, td
[i
].scn_page_access_after_write
);
971 ok(info
.Protect
== td
[i
].scn_page_access_after_write
, "%d: got %#x != expected %#x\n", i
, info
.Protect
, td
[i
].scn_page_access_after_write
);
974 SetLastError(0xdeadbeef);
975 ret
= FreeLibrary(hlib
);
976 ok(ret
, "FreeLibrary error %d\n", GetLastError());
978 test_image_mapping(dll_name
, td
[i
].scn_page_access
, TRUE
);
980 /* reset IMAGE_FILE_DLL otherwise CreateProcess fails */
981 nt_header
.FileHeader
.Characteristics
= IMAGE_FILE_EXECUTABLE_IMAGE
| IMAGE_FILE_RELOCS_STRIPPED
;
982 SetLastError(0xdeadbeef);
983 hfile
= CreateFile(dll_name
, GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0);
984 /* LoadLibrary called on an already memory-mapped file in
985 * test_image_mapping() above leads to a file handle leak
986 * under nt4, and inability to overwrite and delete the file
987 * due to sharing violation error. Ignore it and skip the test,
988 * but leave a not deletable temporary file.
990 ok(hfile
!= INVALID_HANDLE_VALUE
|| broken(hfile
== INVALID_HANDLE_VALUE
) /* nt4 */,
991 "CreateFile error %d\n", GetLastError());
992 if (hfile
== INVALID_HANDLE_VALUE
) goto nt4_is_broken
;
993 SetFilePointer(hfile
, sizeof(dos_header
), NULL
, FILE_BEGIN
);
994 SetLastError(0xdeadbeef);
995 ret
= WriteFile(hfile
, &nt_header
, sizeof(DWORD
) + sizeof(IMAGE_FILE_HEADER
), &dummy
, NULL
);
996 ok(ret
, "WriteFile error %d\n", GetLastError());
999 memset(&sti
, 0, sizeof(sti
));
1000 sti
.cb
= sizeof(sti
);
1001 SetLastError(0xdeadbeef);
1002 ret
= CreateProcess(dll_name
, NULL
, NULL
, NULL
, FALSE
, CREATE_SUSPENDED
, NULL
, NULL
, &sti
, &pi
);
1003 ok(ret
, "CreateProcess() error %d\n", GetLastError());
1005 SetLastError(0xdeadbeef);
1006 size
= VirtualQueryEx(pi
.hProcess
, (char *)hlib
+ section
.VirtualAddress
, &info
, sizeof(info
));
1007 ok(size
== sizeof(info
),
1008 "%d: VirtualQuery error %d\n", i
, GetLastError());
1009 ok(info
.BaseAddress
== (char *)hlib
+ section
.VirtualAddress
, "%d: got %p != expected %p\n", i
, info
.BaseAddress
, (char *)hlib
+ section
.VirtualAddress
);
1010 ok(info
.RegionSize
== si
.dwPageSize
, "%d: got %#lx != expected %#x\n", i
, info
.RegionSize
, si
.dwPageSize
);
1011 ok(info
.Protect
== td
[i
].scn_page_access
, "%d: got %#x != expected %#x\n", i
, info
.Protect
, td
[i
].scn_page_access
);
1012 ok(info
.AllocationBase
== hlib
, "%d: %p != %p\n", i
, info
.AllocationBase
, hlib
);
1013 ok(info
.AllocationProtect
== PAGE_EXECUTE_WRITECOPY
, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i
, info
.AllocationProtect
);
1014 ok(info
.State
== MEM_COMMIT
, "%d: %#x != MEM_COMMIT\n", i
, info
.State
);
1015 ok(info
.Type
== SEC_IMAGE
, "%d: %#x != SEC_IMAGE\n", i
, info
.Type
);
1016 if (info
.Protect
!= PAGE_NOACCESS
)
1018 SetLastError(0xdeadbeef);
1019 ret
= ReadProcessMemory(pi
.hProcess
, info
.BaseAddress
, buf
, section
.SizeOfRawData
, NULL
);
1020 ok(ret
, "ReadProcessMemory() error %d\n", GetLastError());
1021 ok(!memcmp(buf
, section_data
, section
.SizeOfRawData
), "wrong section data\n");
1024 SetLastError(0xdeadbeef);
1025 ret
= TerminateProcess(pi
.hProcess
, 0);
1026 ok(ret
, "TerminateProcess() error %d\n", GetLastError());
1027 ret
= WaitForSingleObject(pi
.hProcess
, 3000);
1028 ok(ret
== WAIT_OBJECT_0
, "WaitForSingleObject failed: %x\n", ret
);
1030 CloseHandle(pi
.hThread
);
1031 CloseHandle(pi
.hProcess
);
1033 test_image_mapping(dll_name
, td
[i
].scn_page_access
, FALSE
);
1036 SetLastError(0xdeadbeef);
1037 ret
= DeleteFile(dll_name
);
1038 ok(ret
|| broken(!ret
) /* nt4 */, "DeleteFile error %d\n", GetLastError());
1042 #define MAX_COUNT 10
1043 static HANDLE attached_thread
[MAX_COUNT
], stop_event
, event
, mutex
, semaphore
;
1044 static DWORD attached_thread_count
;
1045 static int test_dll_phase
;
1047 static DWORD WINAPI
mutex_thread_proc(void *param
)
1051 ret
= WaitForSingleObject(mutex
, 0);
1052 ok(ret
== WAIT_OBJECT_0
, "expected WAIT_OBJECT_0, got %#x\n", ret
);
1058 trace("%04u: mutex_thread_proc: still alive\n", GetCurrentThreadId());
1059 if (WaitForSingleObject(stop_event
, 50) != WAIT_TIMEOUT
) break;
1062 trace("%04u: mutex_thread_proc: exiting\n", GetCurrentThreadId());
1066 static DWORD WINAPI
semaphore_thread_proc(void *param
)
1070 ret
= WaitForSingleObject(semaphore
, 0);
1071 ok(ret
== WAIT_OBJECT_0
, "expected WAIT_OBJECT_0, got %#x\n", ret
);
1077 trace("%04u: semaphore_thread_proc: still alive\n", GetCurrentThreadId());
1078 if (WaitForSingleObject(stop_event
, 50) != WAIT_TIMEOUT
) break;
1081 trace("%04u: semaphore_thread_proc: exiting\n", GetCurrentThreadId());
1085 static BOOL WINAPI
dll_entry_point(HINSTANCE hinst
, DWORD reason
, LPVOID param
)
1091 case DLL_PROCESS_ATTACH
:
1092 trace("dll: %p, DLL_PROCESS_ATTACH, %p\n", hinst
, param
);
1094 ret
= pRtlDllShutdownInProgress();
1095 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1098 case DLL_PROCESS_DETACH
:
1100 DWORD code
, expected_code
, i
;
1102 trace("dll: %p, DLL_PROCESS_DETACH, %p\n", hinst
, param
);
1104 if (test_dll_phase
== 0) expected_code
= 195;
1105 else if (test_dll_phase
== 3) expected_code
= 196;
1106 else expected_code
= STILL_ACTIVE
;
1108 if (test_dll_phase
== 3 || test_dll_phase
== 4)
1110 ret
= pRtlDllShutdownInProgress();
1111 ok(ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1115 ret
= pRtlDllShutdownInProgress();
1117 /* FIXME: remove once Wine is fixed */
1118 if (expected_code
== STILL_ACTIVE
|| expected_code
== 196)
1119 ok(!ret
|| broken(ret
) /* before Vista */, "RtlDllShutdownInProgress returned %d\n", ret
);
1122 ok(!ret
|| broken(ret
) /* before Vista */, "RtlDllShutdownInProgress returned %d\n", ret
);
1125 ok(attached_thread_count
== 2, "attached thread count should be 2\n");
1127 for (i
= 0; i
< attached_thread_count
; i
++)
1129 ret
= GetExitCodeThread(attached_thread
[i
], &code
);
1130 trace("dll: GetExitCodeThread(%u) => %d,%u\n", i
, ret
, code
);
1131 ok(ret
== 1, "GetExitCodeThread returned %d, expected 1\n", ret
);
1132 ok(code
== expected_code
, "expected thread exit code %u, got %u\n", expected_code
, code
);
1135 ret
= WaitForSingleObject(event
, 0);
1136 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1138 ret
= WaitForSingleObject(mutex
, 0);
1139 if (expected_code
== STILL_ACTIVE
)
1140 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1142 ok(ret
== WAIT_ABANDONED
, "expected WAIT_ABANDONED, got %#x\n", ret
);
1144 /* semaphore is not abandoned on thread termination */
1145 ret
= WaitForSingleObject(semaphore
, 0);
1146 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1148 if (expected_code
== STILL_ACTIVE
)
1150 ret
= WaitForSingleObject(attached_thread
[0], 0);
1151 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1152 ret
= WaitForSingleObject(attached_thread
[1], 0);
1153 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1157 ret
= WaitForSingleObject(attached_thread
[0], 0);
1158 ok(ret
== WAIT_OBJECT_0
, "expected WAIT_OBJECT_0, got %#x\n", ret
);
1159 ret
= WaitForSingleObject(attached_thread
[1], 0);
1160 ok(ret
== WAIT_OBJECT_0
, "expected WAIT_OBJECT_0, got %#x\n", ret
);
1163 if (test_dll_phase
== 2)
1165 trace("dll: call ExitProcess()\n");
1166 *child_failures
= winetest_get_failures();
1171 case DLL_THREAD_ATTACH
:
1172 trace("dll: %p, DLL_THREAD_ATTACH, %p\n", hinst
, param
);
1174 ret
= pRtlDllShutdownInProgress();
1175 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1177 if (attached_thread_count
< MAX_COUNT
)
1179 DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &attached_thread
[attached_thread_count
],
1180 0, TRUE
, DUPLICATE_SAME_ACCESS
);
1181 attached_thread_count
++;
1184 case DLL_THREAD_DETACH
:
1185 trace("dll: %p, DLL_THREAD_DETACH, %p\n", hinst
, param
);
1187 ret
= pRtlDllShutdownInProgress();
1188 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1192 trace("dll: %p, %d, %p\n", hinst
, reason
, param
);
1196 *child_failures
= winetest_get_failures();
1201 static void child_process(const char *dll_name
, DWORD target_offset
)
1204 DWORD ret
, dummy
, i
, code
, expected_code
;
1205 HANDLE file
, thread
;
1209 trace("phase %d: writing %p at %#x\n", test_dll_phase
, dll_entry_point
, target_offset
);
1211 SetLastError(0xdeadbeef);
1212 mutex
= CreateMutex(NULL
, FALSE
, NULL
);
1213 ok(mutex
!= 0, "CreateMutex error %d\n", GetLastError());
1215 SetLastError(0xdeadbeef);
1216 semaphore
= CreateSemaphore(NULL
, 1, 1, NULL
);
1217 ok(semaphore
!= 0, "CreateSemaphore error %d\n", GetLastError());
1219 SetLastError(0xdeadbeef);
1220 event
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1221 ok(event
!= 0, "CreateEvent error %d\n", GetLastError());
1223 file
= CreateFile(dll_name
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0);
1224 if (file
== INVALID_HANDLE_VALUE
)
1226 ok(0, "could not open %s\n", dll_name
);
1229 SetFilePointer(file
, target_offset
, NULL
, FILE_BEGIN
);
1230 SetLastError(0xdeadbeef);
1231 target
= dll_entry_point
;
1232 ret
= WriteFile(file
, &target
, sizeof(target
), &dummy
, NULL
);
1233 ok(ret
, "WriteFile error %d\n", GetLastError());
1236 SetLastError(0xdeadbeef);
1237 hmod
= LoadLibrary(dll_name
);
1238 ok(hmod
!= 0, "LoadLibrary error %d\n", GetLastError());
1240 SetLastError(0xdeadbeef);
1241 stop_event
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1242 ok(stop_event
!= 0, "CreateEvent error %d\n", GetLastError());
1244 SetLastError(0xdeadbeef);
1245 thread
= CreateThread(NULL
, 0, mutex_thread_proc
, event
, 0, &dummy
);
1246 ok(thread
!= 0, "CreateThread error %d\n", GetLastError());
1247 WaitForSingleObject(event
, 3000);
1248 CloseHandle(thread
);
1252 SetLastError(0xdeadbeef);
1253 thread
= CreateThread(NULL
, 0, semaphore_thread_proc
, event
, 0, &dummy
);
1254 ok(thread
!= 0, "CreateThread error %d\n", GetLastError());
1255 WaitForSingleObject(event
, 3000);
1256 CloseHandle(thread
);
1261 ok(attached_thread_count
== 2, "attached thread count should be 2\n");
1262 for (i
= 0; i
< attached_thread_count
; i
++)
1264 ret
= GetExitCodeThread(attached_thread
[i
], &code
);
1265 trace("child: GetExitCodeThread(%u) => %d,%u\n", i
, ret
, code
);
1266 ok(ret
== 1, "GetExitCodeThread returned %d, expected 1\n", ret
);
1267 ok(code
== STILL_ACTIVE
, "expected thread exit code STILL_ACTIVE, got %u\n", code
);
1270 ret
= WaitForSingleObject(attached_thread
[0], 0);
1271 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1272 ret
= WaitForSingleObject(attached_thread
[1], 0);
1273 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1275 ret
= WaitForSingleObject(event
, 0);
1276 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1277 ret
= WaitForSingleObject(mutex
, 0);
1278 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1279 ret
= WaitForSingleObject(semaphore
, 0);
1280 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1282 ret
= pRtlDllShutdownInProgress();
1283 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1285 SetLastError(0xdeadbeef);
1286 ret
= TerminateProcess(0, 195);
1287 ok(!ret
, "TerminateProcess(0) should fail\n");
1288 ok(GetLastError() == ERROR_INVALID_HANDLE
, "expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1292 switch (test_dll_phase
)
1295 ret
= pRtlDllShutdownInProgress();
1296 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1298 trace("call NtTerminateProcess(0, 195)\n");
1299 status
= pNtTerminateProcess(0, 195);
1300 ok(!status
, "NtTerminateProcess error %#x\n", status
);
1302 ret
= pRtlDllShutdownInProgress();
1303 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1308 case 2: /* ExitProcess will be called by PROCESS_DETACH handler */
1309 ret
= pRtlDllShutdownInProgress();
1310 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1312 trace("call FreeLibrary(%p)\n", hmod
);
1315 ret
= pRtlDllShutdownInProgress();
1316 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1321 trace("signalling thread exit\n");
1322 SetEvent(stop_event
);
1323 CloseHandle(stop_event
);
1327 ret
= pRtlDllShutdownInProgress();
1328 ok(!ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1330 trace("call LdrShutdownProcess()\n");
1331 pLdrShutdownProcess();
1333 ret
= pRtlDllShutdownInProgress();
1334 ok(ret
, "RtlDllShutdownInProgress returned %d\n", ret
);
1345 if (test_dll_phase
== 0) expected_code
= 195;
1346 else if (test_dll_phase
== 3) expected_code
= 196;
1347 else expected_code
= STILL_ACTIVE
;
1349 if (expected_code
== STILL_ACTIVE
)
1351 ret
= WaitForSingleObject(attached_thread
[0], 0);
1352 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1353 ret
= WaitForSingleObject(attached_thread
[1], 0);
1354 ok(ret
== WAIT_TIMEOUT
, "expected WAIT_TIMEOUT, got %#x\n", ret
);
1358 ret
= WaitForSingleObject(attached_thread
[0], 50);
1359 ok(ret
== WAIT_OBJECT_0
, "expected WAIT_OBJECT_0, got %#x\n", ret
);
1360 ret
= WaitForSingleObject(attached_thread
[1], 50);
1361 ok(ret
== WAIT_OBJECT_0
, "expected WAIT_OBJECT_0, got %#x\n", ret
);
1364 for (i
= 0; i
< attached_thread_count
; i
++)
1366 ret
= GetExitCodeThread(attached_thread
[i
], &code
);
1367 trace("child: GetExitCodeThread(%u) => %d,%u\n", i
, ret
, code
);
1368 ok(ret
== 1, "GetExitCodeThread returned %d, expected 1\n", ret
);
1369 ok(code
== expected_code
, "expected thread exit code %u, got %u\n", expected_code
, code
);
1372 *child_failures
= winetest_get_failures();
1374 trace("call ExitProcess()\n");
1378 static void test_ExitProcess(void)
1380 #include "pshpack1.h"
1382 static struct section_data
1387 } section_data
= { { 0x48,0xb8 }, dll_entry_point
, { 0xff,0xe0 } };
1389 static struct section_data
1394 } section_data
= { 0xb8, dll_entry_point
, { 0xff,0xe0 } };
1396 #include "poppack.h"
1397 static const char filler
[0x1000];
1398 DWORD dummy
, file_align
;
1400 char temp_path
[MAX_PATH
], dll_name
[MAX_PATH
], cmdline
[MAX_PATH
* 2];
1401 DWORD ret
, target_offset
;
1403 PROCESS_INFORMATION pi
;
1404 STARTUPINFO si
= { sizeof(si
) };
1406 #if !defined(__i386__) && !defined(__x86_64__)
1407 skip("x86 specific ExitProcess test\n");
1411 if (!pRtlDllShutdownInProgress
)
1413 skip("RtlDllShutdownInProgress is not available on this platform (XP+)\n");
1417 /* prevent displaying of the "Unable to load this DLL" message box */
1418 SetErrorMode(SEM_FAILCRITICALERRORS
);
1420 GetTempPath(MAX_PATH
, temp_path
);
1421 GetTempFileName(temp_path
, "ldr", 0, dll_name
);
1423 /*trace("creating %s\n", dll_name);*/
1424 file
= CreateFile(dll_name
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0);
1425 if (file
== INVALID_HANDLE_VALUE
)
1427 ok(0, "could not create %s\n", dll_name
);
1431 SetLastError(0xdeadbeef);
1432 ret
= WriteFile(file
, &dos_header
, sizeof(dos_header
), &dummy
, NULL
);
1433 ok(ret
, "WriteFile error %d\n", GetLastError());
1435 nt_header
.FileHeader
.NumberOfSections
= 1;
1436 nt_header
.FileHeader
.SizeOfOptionalHeader
= sizeof(IMAGE_OPTIONAL_HEADER
);
1437 nt_header
.FileHeader
.Characteristics
= IMAGE_FILE_EXECUTABLE_IMAGE
| IMAGE_FILE_DLL
| IMAGE_FILE_RELOCS_STRIPPED
;
1439 nt_header
.OptionalHeader
.AddressOfEntryPoint
= 0x1000;
1440 nt_header
.OptionalHeader
.SectionAlignment
= 0x1000;
1441 nt_header
.OptionalHeader
.FileAlignment
= 0x200;
1442 nt_header
.OptionalHeader
.SizeOfImage
= sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
) + 0x1000;
1443 nt_header
.OptionalHeader
.SizeOfHeaders
= sizeof(dos_header
) + sizeof(nt_header
) + sizeof(IMAGE_SECTION_HEADER
);
1444 SetLastError(0xdeadbeef);
1445 ret
= WriteFile(file
, &nt_header
, sizeof(DWORD
) + sizeof(IMAGE_FILE_HEADER
), &dummy
, NULL
);
1446 ok(ret
, "WriteFile error %d\n", GetLastError());
1447 SetLastError(0xdeadbeef);
1448 ret
= WriteFile(file
, &nt_header
.OptionalHeader
, sizeof(IMAGE_OPTIONAL_HEADER
), &dummy
, NULL
);
1449 ok(ret
, "WriteFile error %d\n", GetLastError());
1451 section
.SizeOfRawData
= sizeof(section_data
);
1452 section
.PointerToRawData
= nt_header
.OptionalHeader
.FileAlignment
;
1453 section
.VirtualAddress
= nt_header
.OptionalHeader
.SectionAlignment
;
1454 section
.Misc
.VirtualSize
= sizeof(section_data
);
1455 section
.Characteristics
= IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_EXECUTE
;
1456 SetLastError(0xdeadbeef);
1457 ret
= WriteFile(file
, §ion
, sizeof(section
), &dummy
, NULL
);
1458 ok(ret
, "WriteFile error %d\n", GetLastError());
1460 file_align
= nt_header
.OptionalHeader
.FileAlignment
- nt_header
.OptionalHeader
.SizeOfHeaders
;
1461 assert(file_align
< sizeof(filler
));
1462 SetLastError(0xdeadbeef);
1463 ret
= WriteFile(file
, filler
, file_align
, &dummy
, NULL
);
1464 ok(ret
, "WriteFile error %d\n", GetLastError());
1466 target_offset
= SetFilePointer(file
, 0, NULL
, FILE_CURRENT
) + FIELD_OFFSET(struct section_data
, target
);
1469 SetLastError(0xdeadbeef);
1470 ret
= WriteFile(file
, §ion_data
, sizeof(section_data
), &dummy
, NULL
);
1471 ok(ret
, "WriteFile error %d\n", GetLastError());
1475 winetest_get_mainargs(&argv
);
1478 *child_failures
= -1;
1479 sprintf(cmdline
, "\"%s\" loader %s %u 0", argv
[0], dll_name
, target_offset
);
1480 ret
= CreateProcess(argv
[0], cmdline
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
);
1481 ok(ret
, "CreateProcess(%s) error %d\n", cmdline
, GetLastError());
1482 ret
= WaitForSingleObject(pi
.hProcess
, 30000);
1483 ok(ret
== WAIT_OBJECT_0
, "child process failed to terminate\n");
1484 GetExitCodeProcess(pi
.hProcess
, &ret
);
1485 ok(ret
== 195, "expected exit code 195, got %u\n", ret
);
1486 ok(!*child_failures
, "%u failures in child process\n", *child_failures
);
1487 CloseHandle(pi
.hThread
);
1488 CloseHandle(pi
.hProcess
);
1491 *child_failures
= -1;
1492 sprintf(cmdline
, "\"%s\" loader %s %u 1", argv
[0], dll_name
, target_offset
);
1493 ret
= CreateProcess(argv
[0], cmdline
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
);
1494 ok(ret
, "CreateProcess(%s) error %d\n", cmdline
, GetLastError());
1495 ret
= WaitForSingleObject(pi
.hProcess
, 30000);
1496 ok(ret
== WAIT_OBJECT_0
, "child process failed to terminate\n");
1497 GetExitCodeProcess(pi
.hProcess
, &ret
);
1498 ok(ret
== 195, "expected exit code 195, got %u\n", ret
);
1499 ok(!*child_failures
, "%u failures in child process\n", *child_failures
);
1500 CloseHandle(pi
.hThread
);
1501 CloseHandle(pi
.hProcess
);
1504 *child_failures
= -1;
1505 sprintf(cmdline
, "\"%s\" loader %s %u 2", argv
[0], dll_name
, target_offset
);
1506 ret
= CreateProcess(argv
[0], cmdline
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
);
1507 ok(ret
, "CreateProcess(%s) error %d\n", cmdline
, GetLastError());
1508 ret
= WaitForSingleObject(pi
.hProcess
, 30000);
1509 ok(ret
== WAIT_OBJECT_0
, "child process failed to terminate\n");
1510 GetExitCodeProcess(pi
.hProcess
, &ret
);
1511 ok(ret
== 197, "expected exit code 197, got %u\n", ret
);
1512 ok(!*child_failures
, "%u failures in child process\n", *child_failures
);
1513 CloseHandle(pi
.hThread
);
1514 CloseHandle(pi
.hProcess
);
1517 *child_failures
= -1;
1518 sprintf(cmdline
, "\"%s\" loader %s %u 3", argv
[0], dll_name
, target_offset
);
1519 ret
= CreateProcess(argv
[0], cmdline
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
);
1520 ok(ret
, "CreateProcess(%s) error %d\n", cmdline
, GetLastError());
1521 ret
= WaitForSingleObject(pi
.hProcess
, 30000);
1522 ok(ret
== WAIT_OBJECT_0
, "child process failed to terminate\n");
1523 GetExitCodeProcess(pi
.hProcess
, &ret
);
1524 ok(ret
== 195, "expected exit code 195, got %u\n", ret
);
1525 ok(!*child_failures
, "%u failures in child process\n", *child_failures
);
1526 CloseHandle(pi
.hThread
);
1527 CloseHandle(pi
.hProcess
);
1530 *child_failures
= -1;
1531 sprintf(cmdline
, "\"%s\" loader %s %u 4", argv
[0], dll_name
, target_offset
);
1532 ret
= CreateProcess(argv
[0], cmdline
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
);
1533 ok(ret
, "CreateProcess(%s) error %d\n", cmdline
, GetLastError());
1534 ret
= WaitForSingleObject(pi
.hProcess
, 30000);
1535 ok(ret
== WAIT_OBJECT_0
, "child process failed to terminate\n");
1536 GetExitCodeProcess(pi
.hProcess
, &ret
);
1538 ok(ret
== 0 || broken(ret
== 195) /* before win7 */, "expected exit code 0, got %u\n", ret
);
1539 ok(!*child_failures
, "%u failures in child process\n", *child_failures
);
1540 CloseHandle(pi
.hThread
);
1541 CloseHandle(pi
.hProcess
);
1543 ret
= DeleteFile(dll_name
);
1544 ok(ret
, "DeleteFile error %d\n", GetLastError());
1553 pNtMapViewOfSection
= (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtMapViewOfSection");
1554 pNtUnmapViewOfSection
= (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtUnmapViewOfSection");
1555 pNtTerminateProcess
= (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtTerminateProcess");
1556 pLdrShutdownProcess
= (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "LdrShutdownProcess");
1557 pRtlDllShutdownInProgress
= (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "RtlDllShutdownInProgress");
1559 mapping
= CreateFileMapping(INVALID_HANDLE_VALUE
, NULL
, PAGE_READWRITE
, 0, 4096, "winetest_loader");
1560 ok(mapping
!= 0, "CreateFileMapping failed\n");
1561 child_failures
= MapViewOfFile(mapping
, FILE_MAP_READ
|FILE_MAP_WRITE
, 0, 0, 4096);
1562 if (*child_failures
== -1)
1565 *child_failures
= 0;
1568 *child_failures
= -1;
1570 argc
= winetest_get_mainargs(&argv
);
1573 test_dll_phase
= atoi(argv
[4]);
1574 child_process(argv
[2], atol(argv
[3]));
1579 test_ImportDescriptors();
1580 test_section_access();