ReactOS 0.4.16-dev-2206-gc56950d
loader.c
Go to the documentation of this file.
1/*
2 * Unit test suite for the PE loader.
3 *
4 * Copyright 2006,2011 Dmitry Timoshkov
5 *
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.
10 *
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.
15 *
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
19 */
20
21#include <stdarg.h>
22#include <stdio.h>
23#include <assert.h>
24
25#include "ntstatus.h"
26#define WIN32_NO_STATUS
27#include "windef.h"
28#include "winbase.h"
29#include "winternl.h"
30#include "winnls.h"
31#include "wine/test.h"
32#include "delayloadhandler.h"
33#ifdef __REACTOS__
34#include "winehacks.h"
35#endif
36
37/* PROCESS_ALL_ACCESS in Vista+ PSDKs is incompatible with older Windows versions */
38#define PROCESS_ALL_ACCESS_NT4 (PROCESS_ALL_ACCESS & ~0xf000)
39
40#define ALIGN_SIZE(size, alignment) (((size) + ((ULONG_PTR)(alignment) - 1)) & ~(((ULONG_PTR)(alignment) - 1)))
41
42struct PROCESS_BASIC_INFORMATION_PRIVATE
43{
44 NTSTATUS ExitStatus;
45 PPEB PebBaseAddress;
46 DWORD_PTR AffinityMask;
47 DWORD_PTR BasePriority;
48 ULONG_PTR UniqueProcessId;
49 ULONG_PTR InheritedFromUniqueProcessId;
50};
51
52static LONG *child_failures;
53static WORD cb_count, cb_count_sys;
54static DWORD page_size;
55static BOOL is_win64 = sizeof(void *) > sizeof(int);
56static BOOL is_wow64;
57static char system_dir[MAX_PATH];
58static char syswow_dir[MAX_PATH]; /* only available if is_wow64 */
59
60static NTSTATUS (WINAPI *pNtCreateSection)(HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *,
61 const LARGE_INTEGER *, ULONG, ULONG, HANDLE );
62static NTSTATUS (WINAPI *pNtQuerySection)(HANDLE, SECTION_INFORMATION_CLASS, void *, SIZE_T, SIZE_T *);
63static NTSTATUS (WINAPI *pNtMapViewOfSection)(HANDLE, HANDLE, PVOID *, ULONG_PTR, SIZE_T, const LARGE_INTEGER *, SIZE_T *, ULONG, ULONG, ULONG);
64static NTSTATUS (WINAPI *pNtUnmapViewOfSection)(HANDLE, PVOID);
65static NTSTATUS (WINAPI *pNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
66static NTSTATUS (WINAPI *pNtSetInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG);
67static NTSTATUS (WINAPI *pNtTerminateProcess)(HANDLE, DWORD);
68static void (WINAPI *pLdrShutdownProcess)(void);
69static BOOLEAN (WINAPI *pRtlDllShutdownInProgress)(void);
70static NTSTATUS (WINAPI *pNtAllocateVirtualMemory)(HANDLE, PVOID *, ULONG_PTR, SIZE_T *, ULONG, ULONG);
71static NTSTATUS (WINAPI *pNtFreeVirtualMemory)(HANDLE, PVOID *, SIZE_T *, ULONG);
72static NTSTATUS (WINAPI *pLdrLockLoaderLock)(ULONG, ULONG *, ULONG_PTR *);
73static NTSTATUS (WINAPI *pLdrUnlockLoaderLock)(ULONG, ULONG_PTR);
74static NTSTATUS (WINAPI *pLdrLoadDll)(LPCWSTR,DWORD,const UNICODE_STRING *,HMODULE*);
75static NTSTATUS (WINAPI *pLdrUnloadDll)(HMODULE);
76static void (WINAPI *pRtlInitUnicodeString)(PUNICODE_STRING,LPCWSTR);
77static void (WINAPI *pRtlAcquirePebLock)(void);
78static void (WINAPI *pRtlReleasePebLock)(void);
79static PVOID (WINAPI *pResolveDelayLoadedAPI)(PVOID, PCIMAGE_DELAYLOAD_DESCRIPTOR,
80 PDELAYLOAD_FAILURE_DLL_CALLBACK,
81 PDELAYLOAD_FAILURE_SYSTEM_ROUTINE,
82 PIMAGE_THUNK_DATA ThunkAddress,ULONG);
83static PVOID (WINAPI *pRtlImageDirectoryEntryToData)(HMODULE,BOOL,WORD,ULONG *);
84static PIMAGE_NT_HEADERS (WINAPI *pRtlImageNtHeader)(HMODULE);
85static DWORD (WINAPI *pFlsAlloc)(PFLS_CALLBACK_FUNCTION);
86static BOOL (WINAPI *pFlsSetValue)(DWORD, PVOID);
87static PVOID (WINAPI *pFlsGetValue)(DWORD);
88static BOOL (WINAPI *pFlsFree)(DWORD);
89static BOOL (WINAPI *pIsWow64Process)(HANDLE,PBOOL);
90static BOOL (WINAPI *pWow64DisableWow64FsRedirection)(void **);
91static BOOL (WINAPI *pWow64RevertWow64FsRedirection)(void *);
92static HMODULE (WINAPI *pLoadPackagedLibrary)(LPCWSTR lpwLibFileName, DWORD Reserved);
93static NTSTATUS (WINAPI *pLdrRegisterDllNotification)(ULONG, PLDR_DLL_NOTIFICATION_FUNCTION, void *, void **);
94
95static PVOID RVAToAddr(DWORD_PTR rva, HMODULE module)
96{
97 if (rva == 0)
98 return NULL;
99 return ((char*) module) + rva;
100}
101
102static IMAGE_DOS_HEADER dos_header;
103
104static const IMAGE_NT_HEADERS nt_header_template =
105{
106 IMAGE_NT_SIGNATURE, /* Signature */
107 {
108#if defined __i386__
109 IMAGE_FILE_MACHINE_I386, /* Machine */
110#elif defined __x86_64__
111 IMAGE_FILE_MACHINE_AMD64, /* Machine */
112#elif defined __arm__
113 IMAGE_FILE_MACHINE_ARMNT, /* Machine */
114#elif defined __aarch64__
115 IMAGE_FILE_MACHINE_ARM64, /* Machine */
116#else
117# error You must specify the machine type
118#endif
119 1, /* NumberOfSections */
120 0, /* TimeDateStamp */
121 0, /* PointerToSymbolTable */
122 0, /* NumberOfSymbols */
123 sizeof(IMAGE_OPTIONAL_HEADER), /* SizeOfOptionalHeader */
124 IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL /* Characteristics */
125 },
126 { IMAGE_NT_OPTIONAL_HDR_MAGIC, /* Magic */
127 1, /* MajorLinkerVersion */
128 0, /* MinorLinkerVersion */
129 0, /* SizeOfCode */
130 0, /* SizeOfInitializedData */
131 0, /* SizeOfUninitializedData */
132 0, /* AddressOfEntryPoint */
133 0x10, /* BaseOfCode, also serves as e_lfanew in the truncated MZ header */
134#ifndef _WIN64
135 0, /* BaseOfData */
136 0x10000000, /* ImageBase */
137#else
138 0x123450000, /* ImageBase */
139#endif
140 0, /* SectionAlignment */
141 0, /* FileAlignment */
142 4, /* MajorOperatingSystemVersion */
143 0, /* MinorOperatingSystemVersion */
144 1, /* MajorImageVersion */
145 0, /* MinorImageVersion */
146 4, /* MajorSubsystemVersion */
147 0, /* MinorSubsystemVersion */
148 0, /* Win32VersionValue */
149 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0x1000, /* SizeOfImage */
150 sizeof(dos_header) + sizeof(nt_header_template), /* SizeOfHeaders */
151 0, /* CheckSum */
152 IMAGE_SUBSYSTEM_WINDOWS_CUI, /* Subsystem */
153 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE | IMAGE_DLLCHARACTERISTICS_NX_COMPAT, /* DllCharacteristics */
154 0x100000, /* SizeOfStackReserve */
155 0x1000, /* SizeOfStackCommit */
156 0x100000, /* SizeOfHeapReserve */
157 0x1000, /* SizeOfHeapCommit */
158 0, /* LoaderFlags */
159 IMAGE_NUMBEROF_DIRECTORY_ENTRIES, /* NumberOfRvaAndSizes */
160 { { 0 } } /* DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] */
161 }
162};
163
164static IMAGE_SECTION_HEADER section =
165{
166 ".rodata", /* Name */
167 { 0 }, /* Misc */
168 0, /* VirtualAddress */
169 0, /* SizeOfRawData */
170 0, /* PointerToRawData */
171 0, /* PointerToRelocations */
172 0, /* PointerToLinenumbers */
173 0, /* NumberOfRelocations */
174 0, /* NumberOfLinenumbers */
175 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ, /* Characteristics */
176};
177
178
179static const char filler[0x1000];
180static const char section_data[0x10] = "section data";
181
182/* return an alternate machine of the same 32/64 bitness */
183static WORD get_alt_machine( WORD orig_machine )
184{
185 switch (orig_machine)
186 {
187 case IMAGE_FILE_MACHINE_I386: return IMAGE_FILE_MACHINE_ARMNT;
188 case IMAGE_FILE_MACHINE_AMD64: return IMAGE_FILE_MACHINE_ARM64;
189 case IMAGE_FILE_MACHINE_ARMNT: return IMAGE_FILE_MACHINE_I386;
190 case IMAGE_FILE_MACHINE_ARM64: return IMAGE_FILE_MACHINE_AMD64;
191 }
192 return 0;
193}
194
195/* return the machine of the alternate 32/64 bitness */
196static WORD get_alt_bitness_machine( WORD orig_machine )
197{
198 switch (orig_machine)
199 {
200 case IMAGE_FILE_MACHINE_I386: return IMAGE_FILE_MACHINE_AMD64;
201 case IMAGE_FILE_MACHINE_AMD64: return IMAGE_FILE_MACHINE_I386;
202 case IMAGE_FILE_MACHINE_ARMNT: return IMAGE_FILE_MACHINE_ARM64;
203 case IMAGE_FILE_MACHINE_ARM64: return IMAGE_FILE_MACHINE_ARMNT;
204 }
205 return 0;
206}
207
208static DWORD create_test_dll( const IMAGE_DOS_HEADER *dos_header, UINT dos_size,
209 const IMAGE_NT_HEADERS *nt_header, char dll_name[MAX_PATH] )
210{
211 char temp_path[MAX_PATH];
212 DWORD dummy, size, file_align;
213 HANDLE hfile;
214 BOOL ret;
215
216 GetTempPathA(MAX_PATH, temp_path);
217 GetTempFileNameA(temp_path, "ldr", 0, dll_name);
218
219 hfile = CreateFileA(dll_name, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, 0, 0);
220 ok( hfile != INVALID_HANDLE_VALUE, "failed to create %s err %lu\n", dll_name, GetLastError() );
221 if (hfile == INVALID_HANDLE_VALUE) return 0;
222
223 SetLastError(0xdeadbeef);
224 ret = WriteFile(hfile, dos_header, dos_size, &dummy, NULL);
225 ok(ret, "WriteFile error %ld\n", GetLastError());
226
227 SetLastError(0xdeadbeef);
228 ret = WriteFile(hfile, nt_header, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), &dummy, NULL);
229 ok(ret, "WriteFile error %ld\n", GetLastError());
230
231 if (nt_header->FileHeader.SizeOfOptionalHeader)
232 {
233 SetLastError(0xdeadbeef);
234 ret = WriteFile(hfile, &nt_header->OptionalHeader,
235 sizeof(IMAGE_OPTIONAL_HEADER),
236 &dummy, NULL);
237 ok(ret, "WriteFile error %ld\n", GetLastError());
238 if (nt_header->FileHeader.SizeOfOptionalHeader > sizeof(IMAGE_OPTIONAL_HEADER))
239 {
240 file_align = nt_header->FileHeader.SizeOfOptionalHeader - sizeof(IMAGE_OPTIONAL_HEADER);
241 assert(file_align < sizeof(filler));
242 SetLastError(0xdeadbeef);
243 ret = WriteFile(hfile, filler, file_align, &dummy, NULL);
244 ok(ret, "WriteFile error %ld\n", GetLastError());
245 }
246 }
247
248 assert(nt_header->FileHeader.NumberOfSections <= 1);
249 if (nt_header->FileHeader.NumberOfSections)
250 {
251 SetFilePointer(hfile, dos_size + sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER) + nt_header->FileHeader.SizeOfOptionalHeader, NULL, FILE_BEGIN);
252
253 section.SizeOfRawData = 10;
254
255 if (nt_header->OptionalHeader.SectionAlignment >= page_size)
256 {
257 section.PointerToRawData = dos_size;
258 section.VirtualAddress = nt_header->OptionalHeader.SectionAlignment;
259 section.Misc.VirtualSize = section.SizeOfRawData * 10;
260 }
261 else
262 {
263 section.PointerToRawData = nt_header->OptionalHeader.SizeOfHeaders;
264 section.VirtualAddress = nt_header->OptionalHeader.SizeOfHeaders;
265 section.Misc.VirtualSize = 5;
266 }
267
268 SetLastError(0xdeadbeef);
269 ret = WriteFile(hfile, &section, sizeof(section), &dummy, NULL);
270 ok(ret, "WriteFile error %ld\n", GetLastError());
271
272 /* section data */
273 SetLastError(0xdeadbeef);
274 ret = WriteFile(hfile, section_data, sizeof(section_data), &dummy, NULL);
275 ok(ret, "WriteFile error %ld\n", GetLastError());
276 }
277
278 /* Minimal PE image that Windows7+ is able to load: 268 bytes */
279 size = GetFileSize(hfile, NULL);
280 if (size < 268)
281 {
282 file_align = 268 - size;
283 SetLastError(0xdeadbeef);
284 ret = WriteFile(hfile, filler, file_align, &dummy, NULL);
285 ok(ret, "WriteFile error %ld\n", GetLastError());
286 }
287
288 size = GetFileSize(hfile, NULL);
289 CloseHandle(hfile);
290 return size;
291}
292
293static DWORD create_test_dll_sections( const IMAGE_DOS_HEADER *dos_header, const IMAGE_NT_HEADERS *nt_header,
294 const IMAGE_SECTION_HEADER *sections, const void *section_data,
295 char dll_name[MAX_PATH] )
296{
297 char temp_path[MAX_PATH];
298 DWORD dummy, i, size;
299 HANDLE hfile;
300 BOOL ret;
301
302 GetTempPathA(MAX_PATH, temp_path);
303 GetTempFileNameA(temp_path, "ldr", 0, dll_name);
304
305 hfile = CreateFileA(dll_name, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, 0, 0);
306 ok( hfile != INVALID_HANDLE_VALUE, "failed to create %s err %lu\n", dll_name, GetLastError() );
307 if (hfile == INVALID_HANDLE_VALUE) return 0;
308
309 SetLastError(0xdeadbeef);
310 ret = WriteFile(hfile, dos_header, sizeof(*dos_header), &dummy, NULL);
311 ok(ret, "WriteFile error %ld\n", GetLastError());
312
313 SetLastError(0xdeadbeef);
314 ret = WriteFile(hfile, nt_header, offsetof(IMAGE_NT_HEADERS, OptionalHeader) + nt_header->FileHeader.SizeOfOptionalHeader, &dummy, NULL);
315 ok(ret, "WriteFile error %ld\n", GetLastError());
316
317 SetLastError(0xdeadbeef);
318 ret = WriteFile(hfile, sections, sizeof(*sections) * nt_header->FileHeader.NumberOfSections,
319 &dummy, NULL);
320 ok(ret, "WriteFile error %ld\n", GetLastError());
321
322 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
323 {
324 SetFilePointer(hfile, sections[i].PointerToRawData, NULL, FILE_BEGIN);
325 SetLastError(0xdeadbeef);
326 ret = WriteFile(hfile, section_data, sections[i].SizeOfRawData, &dummy, NULL);
327 ok(ret, "WriteFile error %ld\n", GetLastError());
328 }
329 size = GetFileSize(hfile, NULL);
330 CloseHandle(hfile);
331 return size;
332}
333
334static BOOL query_image_section( int id, const char *dll_name, const IMAGE_NT_HEADERS *nt_header,
335 const void *section_data )
336{
337 SECTION_BASIC_INFORMATION info;
338 SECTION_IMAGE_INFORMATION image;
339 const IMAGE_COR20_HEADER *cor_header = NULL;
340 SIZE_T info_size = (SIZE_T)0xdeadbeef << 16;
341 NTSTATUS status;
342 HANDLE file, mapping;
343 ULONG file_size;
344 LARGE_INTEGER map_size;
345 SIZE_T max_stack, commit_stack;
346 void *entry_point;
347 BOOL truncated;
348
349 file = CreateFileA( dll_name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
350 NULL, OPEN_EXISTING, 0, 0 );
351 ok( file != INVALID_HANDLE_VALUE, "%u: CreateFile error %ld\n", id, GetLastError() );
352 file_size = GetFileSize( file, NULL );
353
354 status = pNtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_MAP_READ | SECTION_QUERY,
355 NULL, NULL, PAGE_READONLY, SEC_IMAGE, file );
356 ok( !status, "%u: NtCreateSection failed err %lx\n", id, status );
357 if (status)
358 {
359 CloseHandle( file );
360 return FALSE;
361 }
362 status = pNtQuerySection( mapping, SectionImageInformation, &image, sizeof(image), &info_size );
363 ok( !status, "%u: NtQuerySection failed err %lx\n", id, status );
364 ok( info_size == sizeof(image), "%u: NtQuerySection wrong size %Iu\n", id, info_size );
365 if (nt_header->OptionalHeader.Magic == (is_win64 ? IMAGE_NT_OPTIONAL_HDR64_MAGIC
366 : IMAGE_NT_OPTIONAL_HDR32_MAGIC))
367 {
368 max_stack = nt_header->OptionalHeader.SizeOfStackReserve;
369 commit_stack = nt_header->OptionalHeader.SizeOfStackCommit;
370 entry_point = (char *)nt_header->OptionalHeader.ImageBase + nt_header->OptionalHeader.AddressOfEntryPoint;
371 truncated = nt_header->FileHeader.SizeOfOptionalHeader < sizeof(IMAGE_OPTIONAL_HEADER);
372 if (!truncated &&
373 nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress &&
374 nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size)
375 cor_header = section_data;
376 }
377 else if (nt_header->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
378 {
379 const IMAGE_NT_HEADERS64 *nt64 = (const IMAGE_NT_HEADERS64 *)nt_header;
380 max_stack = 0x100000;
381 commit_stack = 0x10000;
382 entry_point = (void *)0x81231234;
383 truncated = nt_header->FileHeader.SizeOfOptionalHeader < sizeof(IMAGE_OPTIONAL_HEADER64);
384 if (!truncated &&
385 nt64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress &&
386 nt64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size)
387 cor_header = section_data;
388 }
389 else
390 {
391 const IMAGE_NT_HEADERS32 *nt32 = (const IMAGE_NT_HEADERS32 *)nt_header;
392 max_stack = nt32->OptionalHeader.SizeOfStackReserve;
393 commit_stack = nt32->OptionalHeader.SizeOfStackCommit;
394 entry_point = (char *)(ULONG_PTR)nt32->OptionalHeader.ImageBase + nt32->OptionalHeader.AddressOfEntryPoint;
395 truncated = nt_header->FileHeader.SizeOfOptionalHeader < sizeof(IMAGE_OPTIONAL_HEADER32);
396 if (!truncated &&
397 nt32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress &&
398 nt32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size)
399 cor_header = section_data;
400 }
401 ok( (char *)image.TransferAddress == (char *)entry_point ||
402 (image.ImageDynamicallyRelocated && LOWORD(image.TransferAddress) == LOWORD(entry_point)),
403 "%u: TransferAddress wrong %p / %p (%08lx)\n", id,
404 image.TransferAddress, entry_point, nt_header->OptionalHeader.AddressOfEntryPoint );
405 ok( image.ZeroBits == 0, "%u: ZeroBits wrong %08lx\n", id, image.ZeroBits );
406 ok( image.MaximumStackSize == max_stack,
407 "%u: MaximumStackSize wrong %Ix / %Ix\n", id, image.MaximumStackSize, max_stack );
408 ok( image.CommittedStackSize == commit_stack,
409 "%u: CommittedStackSize wrong %Ix / %Ix\n", id, image.CommittedStackSize, commit_stack );
410 ok( image.SubSystemType == nt_header->OptionalHeader.Subsystem,
411 "%u: SubSystemType wrong %08lx / %08x\n", id,
412 image.SubSystemType, nt_header->OptionalHeader.Subsystem );
413 ok( image.MinorSubsystemVersion == nt_header->OptionalHeader.MinorSubsystemVersion,
414 "%u: MinorSubsystemVersion wrong %04x / %04x\n", id,
415 image.MinorSubsystemVersion, nt_header->OptionalHeader.MinorSubsystemVersion );
416 ok( image.MajorSubsystemVersion == nt_header->OptionalHeader.MajorSubsystemVersion,
417 "%u: MajorSubsystemVersion wrong %04x / %04x\n", id,
418 image.MajorSubsystemVersion, nt_header->OptionalHeader.MajorSubsystemVersion );
419 ok( image.MajorOperatingSystemVersion == nt_header->OptionalHeader.MajorOperatingSystemVersion ||
420 broken( !image.MajorOperatingSystemVersion), /* before win10 */
421 "%u: MajorOperatingSystemVersion wrong %04x / %04x\n", id,
422 image.MajorOperatingSystemVersion, nt_header->OptionalHeader.MajorOperatingSystemVersion );
423 ok( image.MinorOperatingSystemVersion == nt_header->OptionalHeader.MinorOperatingSystemVersion,
424 "%u: MinorOperatingSystemVersion wrong %04x / %04x\n", id,
425 image.MinorOperatingSystemVersion, nt_header->OptionalHeader.MinorOperatingSystemVersion );
426 ok( image.ImageCharacteristics == nt_header->FileHeader.Characteristics,
427 "%u: ImageCharacteristics wrong %04x / %04x\n", id,
428 image.ImageCharacteristics, nt_header->FileHeader.Characteristics );
429 ok( image.DllCharacteristics == nt_header->OptionalHeader.DllCharacteristics,
430 "%u: DllCharacteristics wrong %04x / %04x\n", id,
431 image.DllCharacteristics, nt_header->OptionalHeader.DllCharacteristics );
432 ok( image.Machine == nt_header->FileHeader.Machine, "%u: Machine wrong %04x / %04x\n", id,
433 image.Machine, nt_header->FileHeader.Machine );
434 ok( image.LoaderFlags == (cor_header != NULL), "%u: LoaderFlags wrong %08lx\n", id, image.LoaderFlags );
435 ok( image.ImageFileSize == file_size,
436 "%u: ImageFileSize wrong %08lx / %08lx\n", id, image.ImageFileSize, file_size );
437 ok( image.CheckSum == nt_header->OptionalHeader.CheckSum,
438 "%u: CheckSum wrong %08lx / %08lx\n", id,
439 image.CheckSum, nt_header->OptionalHeader.CheckSum );
440
441 if (nt_header->OptionalHeader.SizeOfCode || nt_header->OptionalHeader.AddressOfEntryPoint)
442 ok( image.ImageContainsCode == TRUE, "%u: ImageContainsCode wrong %u\n", id,
443 image.ImageContainsCode );
444 else if ((nt_header->OptionalHeader.SectionAlignment % page_size) ||
445 (nt_header->FileHeader.NumberOfSections == 1 &&
446 (section.Characteristics & IMAGE_SCN_MEM_EXECUTE)))
447 ok( image.ImageContainsCode == TRUE || broken(!image.ImageContainsCode), /* <= win8 */
448 "%u: ImageContainsCode wrong %u\n", id, image.ImageContainsCode );
449 else
450 ok( !image.ImageContainsCode, "%u: ImageContainsCode wrong %u\n", id, image.ImageContainsCode );
451
452 if (cor_header &&
453 (cor_header->Flags & COMIMAGE_FLAGS_ILONLY) &&
454 (cor_header->MajorRuntimeVersion > 2 ||
455 (cor_header->MajorRuntimeVersion == 2 && cor_header->MinorRuntimeVersion >= 5)))
456 {
457#ifdef __REACTOS__
458 ok( image.ComPlusILOnly || broken(GetNTVersion() < _WIN32_WINNT_VISTA),
459#else
460 ok( image.ComPlusILOnly,
461#endif
462 "%u: wrong ComPlusILOnly flags %02x\n", id, image.ImageFlags );
463 if (nt_header->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC &&
464 !(cor_header->Flags & COMIMAGE_FLAGS_32BITREQUIRED))
465#ifdef __REACTOS__
466 ok( image.ComPlusNativeReady || broken(GetNTVersion() < _WIN32_WINNT_VISTA),
467#else
468 ok( image.ComPlusNativeReady,
469#endif
470 "%u: wrong ComPlusNativeReady flags %02x\n", id, image.ImageFlags );
471 else
472 ok( !image.ComPlusNativeReady,
473 "%u: wrong ComPlusNativeReady flags %02x\n", id, image.ImageFlags );
474 if (nt_header->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC &&
475 (cor_header->Flags & COMIMAGE_FLAGS_32BITPREFERRED))
476 ok( image.ComPlusPrefer32bit ||
477 broken( !image.MajorOperatingSystemVersion ), /* before win10 */
478 "%u: wrong ComPlusPrefer32bit flags %02x\n", id, image.ImageFlags );
479 else
480 ok( !image.ComPlusPrefer32bit, "%u: wrong ComPlusPrefer32bit flags %02x\n", id, image.ImageFlags );
481 }
482 else
483 {
484 ok( !image.ComPlusILOnly, "%u: wrong ComPlusILOnly flags %02x\n", id, image.ImageFlags );
485 ok( !image.ComPlusNativeReady, "%u: wrong ComPlusNativeReady flags %02x\n", id, image.ImageFlags );
486 ok( !image.ComPlusPrefer32bit, "%u: wrong ComPlusPrefer32bit flags %02x\n", id, image.ImageFlags );
487 }
488 if (!(nt_header->OptionalHeader.SectionAlignment % page_size))
489 ok( !image.ImageMappedFlat, "%u: wrong ImageMappedFlat flags %02x\n", id, image.ImageFlags );
490 else
491#ifdef __REACTOS__
492 ok( image.ImageMappedFlat || broken(GetNTVersion() < _WIN32_WINNT_VISTA),
493#else
494 ok( image.ImageMappedFlat,
495#endif
496 "%u: wrong ImageMappedFlat flags %02x\n", id, image.ImageFlags );
497
498 if (!(nt_header->OptionalHeader.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE))
499 ok( !image.ImageDynamicallyRelocated || broken( image.ComPlusILOnly ), /* <= win7 */
500 "%u: wrong ImageDynamicallyRelocated flags %02x\n", id, image.ImageFlags );
501 else if (image.ImageContainsCode && !image.ImageMappedFlat && !cor_header)
502#ifdef __REACTOS__
503 ok( image.ImageDynamicallyRelocated || broken(GetNTVersion() < _WIN32_WINNT_VISTA),
504#else
505 ok( image.ImageDynamicallyRelocated,
506#endif
507 "%u: wrong ImageDynamicallyRelocated flags %02x\n", id, image.ImageFlags );
508 else
509 ok( !image.ImageDynamicallyRelocated || broken(TRUE), /* <= win8 */
510 "%u: wrong ImageDynamicallyRelocated flags %02x\n", id, image.ImageFlags );
511 ok( !image.BaseBelow4gb, "%u: wrong BaseBelow4gb flags %02x\n", id, image.ImageFlags );
512
513 map_size.QuadPart = (nt_header->OptionalHeader.SizeOfImage + page_size - 1) & ~(page_size - 1);
514 status = pNtQuerySection( mapping, SectionBasicInformation, &info, sizeof(info), NULL );
515 ok( !status, "NtQuerySection failed err %lx\n", status );
516 ok( info.Size.QuadPart == map_size.QuadPart, "NtQuerySection wrong size %lx%08lx / %lx%08lx\n",
517 info.Size.u.HighPart, info.Size.u.LowPart, map_size.u.HighPart, map_size.u.LowPart );
518 CloseHandle( mapping );
519
520 map_size.QuadPart = (nt_header->OptionalHeader.SizeOfImage + page_size - 1) & ~(page_size - 1);
521 status = pNtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_MAP_READ | SECTION_QUERY,
522 NULL, &map_size, PAGE_READONLY, SEC_IMAGE, file );
523 ok( !status, "%u: NtCreateSection failed err %lx\n", id, status );
524 status = pNtQuerySection( mapping, SectionBasicInformation, &info, sizeof(info), NULL );
525 ok( !status, "NtQuerySection failed err %lx\n", status );
526 ok( info.Size.QuadPart == map_size.QuadPart, "NtQuerySection wrong size %lx%08lx / %lx%08lx\n",
527 info.Size.u.HighPart, info.Size.u.LowPart, map_size.u.HighPart, map_size.u.LowPart );
528 CloseHandle( mapping );
529
530 map_size.QuadPart++;
531 status = pNtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_MAP_READ | SECTION_QUERY,
532 NULL, &map_size, PAGE_READONLY, SEC_IMAGE, file );
533 ok( status == STATUS_SECTION_TOO_BIG, "%u: NtCreateSection failed err %lx\n", id, status );
534
535 SetFilePointerEx( file, map_size, NULL, FILE_BEGIN );
536 SetEndOfFile( file );
537 status = pNtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_MAP_READ | SECTION_QUERY,
538 NULL, &map_size, PAGE_READONLY, SEC_IMAGE, file );
539 ok( status == STATUS_SECTION_TOO_BIG, "%u: NtCreateSection failed err %lx\n", id, status );
540
541 map_size.QuadPart = 1;
542 status = pNtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_MAP_READ | SECTION_QUERY,
543 NULL, &map_size, PAGE_READONLY, SEC_IMAGE, file );
544 ok( !status, "%u: NtCreateSection failed err %lx\n", id, status );
545 status = pNtQuerySection( mapping, SectionBasicInformation, &info, sizeof(info), NULL );
546 ok( !status, "NtQuerySection failed err %lx\n", status );
547 ok( info.Size.QuadPart == map_size.QuadPart, "NtQuerySection wrong size %lx%08lx / %lx%08lx\n",
548 info.Size.u.HighPart, info.Size.u.LowPart, map_size.u.HighPart, map_size.u.LowPart );
549 CloseHandle( mapping );
550
551 CloseHandle( file );
552 return image.ImageContainsCode && (!cor_header || !(cor_header->Flags & COMIMAGE_FLAGS_ILONLY));
553}
554
555static const WCHAR wldr_nameW[] = {'w','l','d','r','t','e','s','t','.','d','l','l',0};
556static WCHAR load_test_name[MAX_PATH], load_fallback_name[MAX_PATH];
557static WCHAR load_path[MAX_PATH];
558
559static void init_load_path( const char *fallback_dll )
560{
561 static const WCHAR pathW[] = {'P','A','T','H',0};
562 static const WCHAR ldrW[] = {'l','d','r',0};
563 static const WCHAR sepW[] = {';',0};
564 static const WCHAR bsW[] = {'\\',0};
565 WCHAR path[MAX_PATH];
566
567 GetTempPathW( MAX_PATH, path );
568 GetTempFileNameW( path, ldrW, 0, load_test_name );
569 GetTempFileNameW( path, ldrW, 0, load_fallback_name );
570 DeleteFileW( load_test_name );
571 ok( CreateDirectoryW( load_test_name, NULL ), "failed to create dir\n" );
572 DeleteFileW( load_fallback_name );
573 ok( CreateDirectoryW( load_fallback_name, NULL ), "failed to create dir\n" );
574 lstrcpyW( load_path, load_test_name );
575 lstrcatW( load_path, sepW );
576 lstrcatW( load_path, load_fallback_name );
577 lstrcatW( load_path, sepW );
578 GetEnvironmentVariableW( pathW, load_path + lstrlenW(load_path),
579 ARRAY_SIZE(load_path) - lstrlenW(load_path) );
580 lstrcatW( load_test_name, bsW );
581 lstrcatW( load_test_name, wldr_nameW );
582 lstrcatW( load_fallback_name, bsW );
583 lstrcatW( load_fallback_name, wldr_nameW );
584 MultiByteToWideChar( CP_ACP, 0, fallback_dll, -1, path, MAX_PATH );
585 MoveFileW( path, load_fallback_name );
586}
587
588static void delete_load_path(void)
589{
590 WCHAR *p;
591
592 DeleteFileW( load_test_name );
593 for (p = load_test_name + lstrlenW(load_test_name) - 1; *p != '\\'; p--) ;
594 *p = 0;
595 RemoveDirectoryW( load_test_name );
596 DeleteFileW( load_fallback_name );
597 for (p = load_fallback_name + lstrlenW(load_fallback_name) - 1; *p != '\\'; p--) ;
598 *p = 0;
599 RemoveDirectoryW( load_fallback_name );
600}
601
602static UINT get_com_dir_size( const IMAGE_NT_HEADERS *nt )
603{
604 if (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
605 return ((const IMAGE_NT_HEADERS32 *)nt)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size;
606 else if (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
607 return ((const IMAGE_NT_HEADERS64 *)nt)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size;
608 else
609 return 0;
610}
611
612/* helper to test image section mapping */
613static NTSTATUS map_image_section( const IMAGE_NT_HEADERS *nt_header, const IMAGE_SECTION_HEADER *sections,
614 const void *section_data, int line )
615{
616 char dll_name[MAX_PATH];
617 WCHAR path[MAX_PATH];
618 UNICODE_STRING name;
619 LARGE_INTEGER size;
620 HANDLE file, map;
621 NTSTATUS status, expect_status, ldr_status;
622 ULONG file_size;
623 BOOL has_code = FALSE, il_only = FALSE, want_32bit = FALSE, expect_fallback = FALSE, wrong_machine = FALSE;
624 HMODULE mod = 0, ldr_mod;
625
626 file_size = create_test_dll_sections( &dos_header, nt_header, sections, section_data, dll_name );
627
628 file = CreateFileA(dll_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
629 ok(file != INVALID_HANDLE_VALUE, "CreateFile error %ld\n", GetLastError());
630
631 size.QuadPart = file_size;
632 status = pNtCreateSection(&map, STANDARD_RIGHTS_REQUIRED | SECTION_MAP_READ | SECTION_QUERY,
633 NULL, &size, PAGE_READONLY, SEC_IMAGE, file );
634 expect_status = status;
635
636 if (get_com_dir_size( nt_header ))
637 {
638 /* invalid COR20 header seems to corrupt internal loader state on Windows */
639 if (get_com_dir_size( nt_header ) < sizeof(IMAGE_COR20_HEADER)) goto done;
640 if (!((const IMAGE_COR20_HEADER *)section_data)->Flags) goto done;
641 }
642
643 if (!status)
644 {
645 SECTION_BASIC_INFORMATION info;
646 SIZE_T info_size = 0xdeadbeef;
647 NTSTATUS ret = pNtQuerySection( map, SectionBasicInformation, &info, sizeof(info), &info_size );
648 ok( !ret, "NtQuerySection failed err %lx\n", ret );
649 ok( info_size == sizeof(info), "NtQuerySection wrong size %Iu\n", info_size );
650 ok( info.Attributes == (SEC_IMAGE | SEC_FILE), "NtQuerySection wrong attr %lx\n", info.Attributes );
651 ok( info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", info.BaseAddress );
652 ok( info.Size.QuadPart == file_size, "NtQuerySection wrong size %lx%08lx / %08lx\n",
653 info.Size.u.HighPart, info.Size.u.LowPart, file_size );
654 has_code = query_image_section( line, dll_name, nt_header, section_data );
655
656 if (get_com_dir_size( nt_header ))
657 {
658 const IMAGE_COR20_HEADER *cor_header = section_data;
659 il_only = (cor_header->Flags & COMIMAGE_FLAGS_ILONLY) != 0;
660 if (il_only) want_32bit = (cor_header->Flags & COMIMAGE_FLAGS_32BITREQUIRED) != 0;
661 }
662
663 SetLastError( 0xdeadbeef );
664 mod = LoadLibraryExA( dll_name, 0, DONT_RESOLVE_DLL_REFERENCES );
665 /* test loading dll of wrong 32/64 bitness */
666 if (nt_header->OptionalHeader.Magic == (is_win64 ? IMAGE_NT_OPTIONAL_HDR32_MAGIC
667 : IMAGE_NT_OPTIONAL_HDR64_MAGIC))
668 {
669 if (!has_code && is_win64)
670 {
671 ok_(__FILE__,line)( mod != NULL || want_32bit || broken(il_only), /* <= win7 */
672 "loading failed err %lu\n", GetLastError() );
673 }
674 else
675 {
676 ok_(__FILE__, line)( !mod, "loading succeeded\n" );
677 ok_(__FILE__, line)( GetLastError() == ERROR_BAD_EXE_FORMAT, "wrong error %lu\n", GetLastError() );
678 if (nt_header_template.FileHeader.Machine == IMAGE_FILE_MACHINE_ARM64)
679 {
680 wrong_machine = TRUE;
681 expect_status = STATUS_INVALID_IMAGE_FORMAT;
682 }
683 }
684 }
685 else
686 {
687 wrong_machine = (nt_header->FileHeader.Machine == get_alt_machine( nt_header_template.FileHeader.Machine ));
688
689 ok( mod != NULL || broken(il_only) || /* <= win7 */
690 broken( wrong_machine ), /* win8 */
691 "%u: loading failed err %lu\n", line, GetLastError() );
692 }
693 if (mod) FreeLibrary( mod );
694 expect_fallback = !mod;
695 }
696
697 /* test fallback to another dll further in the load path */
698
699 MultiByteToWideChar( CP_ACP, 0, dll_name, -1, path, MAX_PATH );
700 CopyFileW( path, load_test_name, FALSE );
701 pRtlInitUnicodeString( &name, wldr_nameW );
702 ldr_status = pLdrLoadDll( load_path, 0, &name, &ldr_mod );
703 if (!ldr_status)
704 {
705 GetModuleFileNameW( ldr_mod, path, MAX_PATH );
706 if (!lstrcmpiW( path, load_test_name ))
707 {
708 if (!expect_status)
709 ok( !expect_fallback, "%u: got test dll but expected fallback\n", line );
710 else
711 ok( !expect_fallback, "%u: got test dll but expected failure %lx\n", line, expect_status );
712 }
713 else if (!lstrcmpiW( path, load_fallback_name ))
714 {
715 trace( "%u: loaded fallback\n", line );
716#ifdef __REACTOS__
717 ok( !expect_status || broken(is_win64) /* Broken on Vista, 8.1 x64 */, "%u: got fallback but expected failure %lx\n", line, expect_status );
718 ok( expect_fallback || broken(is_win64) /* Broken on Vista, 8.1 x64 */ ||
719#else
720 ok( !expect_status, "%u: got fallback but expected failure %lx\n", line, expect_status );
721 ok( expect_fallback ||
722#endif
723 /* win10 also falls back for 32-bit dll without code, even though it could be loaded */
724 (is_win64 && !has_code &&
725 nt_header->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC),
726 "%u: got fallback but expected test dll\n", line );
727 }
728 else ok( 0, "%u: got unexpected path %s instead of %s\n", line, wine_dbgstr_w(path), wine_dbgstr_w(load_test_name));
729 pLdrUnloadDll( ldr_mod );
730 }
731 else if (ldr_status == STATUS_DLL_INIT_FAILED ||
732 ldr_status == STATUS_ACCESS_VIOLATION ||
733 ldr_status == STATUS_ILLEGAL_INSTRUCTION)
734 {
735 /* some dlls with invalid entry point will crash, but this means we loaded the test dll */
736#ifdef __REACTOS__
737 ok( !expect_fallback || broken(is_win64 && GetNTVersion() == _WIN32_WINNT_WIN8) /* Broken on 8.1 x64 */, "%u: got test dll but expected fallback\n", line );
738#else
739 ok( !expect_fallback, "%u: got test dll but expected fallback\n", line );
740#endif
741 }
742 else
743 {
744 ok( ldr_status == expect_status ||
745 (wrong_machine && !expect_status && ldr_status == STATUS_INVALID_IMAGE_FORMAT) ||
746 broken(il_only && !expect_status && ldr_status == STATUS_INVALID_IMAGE_FORMAT) ||
747 broken(nt_header->Signature == IMAGE_OS2_SIGNATURE && ldr_status == STATUS_INVALID_IMAGE_NE_FORMAT),
748 "%u: wrong status %lx/%lx\n", line, ldr_status, expect_status );
749 ok( !expect_fallback || wrong_machine || broken(il_only),
750 "%u: failed with %lx expected fallback\n", line, ldr_status );
751 }
752
753done:
754 if (map) CloseHandle( map );
755 CloseHandle( file );
756 DeleteFileA( dll_name );
757 return status;
758}
759
760
761static void test_Loader(void)
762{
763 static const struct test_data
764 {
765 DWORD size_of_dos_header;
766 WORD number_of_sections, size_of_optional_header;
767 DWORD section_alignment, file_alignment;
768 DWORD size_of_image, size_of_headers;
769 DWORD errors[4]; /* 0 means LoadLibrary should succeed */
770 } td[] =
771 {
772 { sizeof(dos_header),
773 1, 0, 0, 0, 0, 0,
774 { ERROR_BAD_EXE_FORMAT }
775 },
776 { sizeof(dos_header),
777 1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x1000,
778 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0xe00,
779 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER),
780 { ERROR_BAD_EXE_FORMAT } /* XP doesn't like too small image size */
781 },
782 { sizeof(dos_header),
783 1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x1000,
784 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
785 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER),
786 { ERROR_SUCCESS }
787 },
788 { sizeof(dos_header),
789 1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x1000,
790 0x1f00,
791 0x1000,
792 { ERROR_SUCCESS }
793 },
794 { sizeof(dos_header),
795 1, sizeof(IMAGE_OPTIONAL_HEADER), 0x200, 0x200,
796 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0x200,
797 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER),
798 { ERROR_SUCCESS, ERROR_INVALID_ADDRESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
799 },
800 { sizeof(dos_header),
801 1, sizeof(IMAGE_OPTIONAL_HEADER), 0x200, 0x1000,
802 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
803 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER),
804 { ERROR_BAD_EXE_FORMAT } /* XP doesn't like alignments */
805 },
806 { sizeof(dos_header),
807 1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x200,
808 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
809 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER),
810 { ERROR_SUCCESS }
811 },
812 { sizeof(dos_header),
813 1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x200,
814 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
815 0x200,
816 { ERROR_SUCCESS }
817 },
818 /* Mandatory are all fields up to SizeOfHeaders, everything else
819 * is really optional (at least that's true for XP).
820 */
821#if 0 /* 32-bit Windows 8 crashes inside of LoadLibrary */
822 { sizeof(dos_header),
823 1, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
824 sizeof(dos_header) + sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER) + FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum) + sizeof(IMAGE_SECTION_HEADER) + 0x10,
825 sizeof(dos_header) + sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER) + FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum) + sizeof(IMAGE_SECTION_HEADER),
826 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT, ERROR_INVALID_ADDRESS,
827 ERROR_NOACCESS }
828 },
829#endif
830 { sizeof(dos_header),
831 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
832 0xd0, /* beyond of the end of file */
833 0xc0, /* beyond of the end of file */
834 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
835 },
836 { sizeof(dos_header),
837 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
838 0x1000,
839 0,
840 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
841 },
842 { sizeof(dos_header),
843 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
844 1,
845 0,
846 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
847 },
848#if 0 /* not power of 2 alignments need more test cases */
849 { sizeof(dos_header),
850 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x300, 0x300,
851 1,
852 0,
853 { ERROR_BAD_EXE_FORMAT } /* alignment is not power of 2 */
854 },
855#endif
856 { sizeof(dos_header),
857 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 4, 4,
858 1,
859 0,
860 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
861 },
862 { sizeof(dos_header),
863 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 1, 1,
864 1,
865 0,
866 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
867 },
868 { sizeof(dos_header),
869 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
870 0,
871 0,
872 { ERROR_BAD_EXE_FORMAT } /* image size == 0 -> failure */
873 },
874 /* the following data mimics the PE image which upack creates */
875 { 0x10,
876 1, 0x148, 0x1000, 0x200,
877 sizeof(dos_header) + sizeof(nt_header_template) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
878 0x200,
879 { ERROR_SUCCESS }
880 },
881 /* Minimal PE image that XP is able to load: 92 bytes */
882 { 0x04,
883 0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum),
884 0x04 /* also serves as e_lfanew in the truncated MZ header */, 0x04,
885 1,
886 0,
887 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
888 },
889 /* Minimal PE image initially created for Windows 7 and accepted from
890 * Vista up to Windows 10 1709 with some unexplained exceptions:
891 * 268 bytes
892 */
893 { 0x04,
894 0, 0xf0, /* optional header size just forces 0xf0 bytes to be written,
895 0 or another number don't change the behaviour, what really
896 matters is file size regardless of values in the headers */
897 0x04 /* also serves as e_lfanew in the truncated MZ header */, 0x04,
898 0x40, /* minimal image size that Windows7 accepts */
899 0,
900 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* rejected by win10 1809+ */
901 },
902 /* the following data mimics the PE image which 8k demos have */
903 { 0x04,
904 0, 0x08,
905 0x04 /* also serves as e_lfanew in the truncated MZ header */, 0x04,
906 0x2000,
907 0x40,
908 { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT }
909 }
910 };
911 int i;
912 DWORD file_size;
913 HANDLE h;
914 HMODULE hlib, hlib_as_data_file;
915 char dll_name[MAX_PATH];
916 SIZE_T size;
917 BOOL ret;
918 NTSTATUS status;
919 WORD orig_machine = nt_header_template.FileHeader.Machine;
920 IMAGE_NT_HEADERS nt_header;
921 IMAGE_COR20_HEADER cor_header;
922
923 /* prevent displaying of the "Unable to load this DLL" message box */
924 SetErrorMode(SEM_FAILCRITICALERRORS);
925
926 for (i = 0; i < ARRAY_SIZE(td); i++)
927 {
928 winetest_push_context("%d", i);
929 nt_header = nt_header_template;
930 nt_header.FileHeader.NumberOfSections = td[i].number_of_sections;
931 nt_header.FileHeader.SizeOfOptionalHeader = td[i].size_of_optional_header;
932
933 nt_header.OptionalHeader.SectionAlignment = td[i].section_alignment;
934 nt_header.OptionalHeader.FileAlignment = td[i].file_alignment;
935 nt_header.OptionalHeader.SizeOfImage = td[i].size_of_image;
936 nt_header.OptionalHeader.SizeOfHeaders = td[i].size_of_headers;
937
938 section.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
939 file_size = create_test_dll( &dos_header, td[i].size_of_dos_header, &nt_header, dll_name );
940
941 SetLastError(0xdeadbeef);
942 hlib = LoadLibraryA(dll_name);
943 if (hlib)
944 {
945 MEMORY_BASIC_INFORMATION info;
946 void *ptr;
947
948 ok( td[i].errors[0] == ERROR_SUCCESS, "should have failed\n" );
949
950 SetLastError(0xdeadbeef);
951 size = VirtualQuery(hlib, &info, sizeof(info));
952 ok(size == sizeof(info),
953 "%d: VirtualQuery error %ld\n", i, GetLastError());
954 ok(info.BaseAddress == hlib, "%p != %p\n", info.BaseAddress, hlib);
955 ok(info.AllocationBase == hlib, "%p != %p\n", info.AllocationBase, hlib);
956 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%lx != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
957 ok(info.RegionSize == ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, page_size), "got %Ix != expected %x\n",
958 info.RegionSize, (UINT)ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, page_size));
959 ok(info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State);
960 if (nt_header.OptionalHeader.SectionAlignment < page_size)
961 ok(info.Protect == PAGE_EXECUTE_WRITECOPY, "%lx != PAGE_EXECUTE_WRITECOPY\n", info.Protect);
962 else
963 ok(info.Protect == PAGE_READONLY, "%lx != PAGE_READONLY\n", info.Protect);
964 ok(info.Type == SEC_IMAGE, "%lx != SEC_IMAGE\n", info.Type);
965
966 SetLastError(0xdeadbeef);
967 ptr = VirtualAlloc(hlib, page_size, MEM_COMMIT, info.Protect);
968 ok(!ptr, "VirtualAlloc should fail\n");
969 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
970
971 SetLastError(0xdeadbeef);
972 size = VirtualQuery((char *)hlib + info.RegionSize, &info, sizeof(info));
973 ok(size == sizeof(info), "VirtualQuery error %ld\n", GetLastError());
974 if (nt_header.OptionalHeader.SectionAlignment == page_size ||
975 nt_header.OptionalHeader.SectionAlignment == nt_header.OptionalHeader.FileAlignment)
976 {
977 ok(info.BaseAddress == (char *)hlib + ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, page_size), "got %p != expected %p\n",
978 info.BaseAddress, (char *)hlib + ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, page_size));
979 ok(info.AllocationBase == 0, "%p != 0\n", info.AllocationBase);
980 ok(info.AllocationProtect == 0, "%lx != 0\n", info.AllocationProtect);
981 /*ok(info.RegionSize == not_practical_value, "%d: %lx != not_practical_value\n", i, info.RegionSize);*/
982 ok(info.State == MEM_FREE, "%lx != MEM_FREE\n", info.State);
983 ok(info.Type == 0, "%lx != 0\n", info.Type);
984 ok(info.Protect == PAGE_NOACCESS, "%lx != PAGE_NOACCESS\n", info.Protect);
985 }
986 else
987 {
988 ok(info.Protect == PAGE_EXECUTE_WRITECOPY, "%lx != PAGE_EXECUTE_WRITECOPY\n", info.Protect);
989 ok(info.BaseAddress == hlib, "got %p != expected %p\n", info.BaseAddress, hlib);
990 ok(info.AllocationBase == hlib, "%p != %p\n", info.AllocationBase, hlib);
991 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%lx != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
992 ok(info.RegionSize == ALIGN_SIZE(file_size, page_size), "got %Ix != expected %x\n",
993 info.RegionSize, (UINT)ALIGN_SIZE(file_size, page_size));
994 ok(info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State);
995 ok(info.Protect == PAGE_READONLY, "%lx != PAGE_READONLY\n", info.Protect);
996 ok(info.Type == SEC_IMAGE, "%lx != SEC_IMAGE\n", info.Type);
997 }
998
999 /* header: check the zeroing of alignment */
1000 if (nt_header.OptionalHeader.SectionAlignment >= page_size)
1001 {
1002 const char *start;
1003
1004 start = (const char *)hlib + nt_header.OptionalHeader.SizeOfHeaders;
1005 size = ALIGN_SIZE((ULONG_PTR)start, page_size) - (ULONG_PTR)start;
1006 ok(!memcmp(start, filler, size), "header alignment is not cleared\n");
1007 }
1008
1009 if (nt_header.FileHeader.NumberOfSections)
1010 {
1011 SetLastError(0xdeadbeef);
1012 size = VirtualQuery((char *)hlib + section.VirtualAddress, &info, sizeof(info));
1013 ok(size == sizeof(info),
1014 "VirtualQuery error %ld\n", GetLastError());
1015 if (nt_header.OptionalHeader.SectionAlignment < page_size)
1016 {
1017 ok(info.BaseAddress == hlib, "got %p != expected %p\n", info.BaseAddress, hlib);
1018 ok(info.RegionSize == ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, page_size), "got %Ix != expected %x\n",
1019 info.RegionSize, (UINT)ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, page_size));
1020 ok(info.Protect == PAGE_EXECUTE_WRITECOPY, "%lx != PAGE_EXECUTE_WRITECOPY\n", info.Protect);
1021 }
1022 else
1023 {
1024 ok(info.BaseAddress == (char *)hlib + section.VirtualAddress, "got %p != expected %p\n", info.BaseAddress, (char *)hlib + section.VirtualAddress);
1025 ok(info.RegionSize == ALIGN_SIZE(section.Misc.VirtualSize, page_size), "got %Ix != expected %x\n",
1026 info.RegionSize, (UINT)ALIGN_SIZE(section.Misc.VirtualSize, page_size));
1027 ok(info.Protect == PAGE_READONLY, "%lx != PAGE_READONLY\n", info.Protect);
1028 }
1029 ok(info.AllocationBase == hlib, "%p != %p\n", info.AllocationBase, hlib);
1030 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%lx != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
1031 ok(info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State);
1032 ok(info.Type == SEC_IMAGE, "%lx != SEC_IMAGE\n", info.Type);
1033
1034 if (nt_header.OptionalHeader.SectionAlignment >= page_size)
1035 ok(!memcmp((const char *)hlib + section.VirtualAddress + section.PointerToRawData, &nt_header, section.SizeOfRawData), "wrong section data\n");
1036 else
1037 ok(!memcmp((const char *)hlib + section.PointerToRawData, section_data, section.SizeOfRawData), "wrong section data\n");
1038
1039 /* check the zeroing of alignment */
1040 if (nt_header.OptionalHeader.SectionAlignment >= page_size)
1041 {
1042 const char *start;
1043
1044 start = (const char *)hlib + section.VirtualAddress + section.PointerToRawData + section.SizeOfRawData;
1045 size = ALIGN_SIZE((ULONG_PTR)start, page_size) - (ULONG_PTR)start;
1046 ok(memcmp(start, filler, size), "alignment should not be cleared\n");
1047 }
1048
1049 SetLastError(0xdeadbeef);
1050 ptr = VirtualAlloc((char *)hlib + section.VirtualAddress, page_size, MEM_COMMIT, info.Protect);
1051 ok(!ptr, "VirtualAlloc should fail\n");
1052 ok(GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == ERROR_INVALID_ADDRESS,
1053 "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
1054 }
1055
1056 SetLastError(0xdeadbeef);
1057 hlib_as_data_file = LoadLibraryExA(dll_name, 0, LOAD_LIBRARY_AS_DATAFILE);
1058 ok(hlib_as_data_file != 0, "LoadLibraryEx error %lu\n", GetLastError());
1059 ok(hlib_as_data_file == hlib, "hlib_as_file and hlib are different\n");
1060
1061 SetLastError(0xdeadbeef);
1062 ret = FreeLibrary(hlib);
1063 ok(ret, "FreeLibrary error %ld\n", GetLastError());
1064
1065 SetLastError(0xdeadbeef);
1066 hlib = GetModuleHandleA(dll_name);
1067 ok(hlib != 0, "GetModuleHandle error %lu\n", GetLastError());
1068
1069 SetLastError(0xdeadbeef);
1070 ret = FreeLibrary(hlib_as_data_file);
1071 ok(ret, "FreeLibrary error %ld\n", GetLastError());
1072
1073 hlib = GetModuleHandleA(dll_name);
1074 ok(!hlib, "GetModuleHandle should fail\n");
1075
1076 SetLastError(0xdeadbeef);
1077 hlib_as_data_file = LoadLibraryExA(dll_name, 0, LOAD_LIBRARY_AS_DATAFILE);
1078 ok(hlib_as_data_file != 0, "LoadLibraryEx error %lu\n", GetLastError());
1079 ok(((ULONG_PTR)hlib_as_data_file & 3) == 1, "hlib_as_data_file got %p\n", hlib_as_data_file);
1080
1081 hlib = GetModuleHandleA(dll_name);
1082 ok(!hlib, "GetModuleHandle should fail\n");
1083
1084 SetLastError(0xdeadbeef);
1085 h = CreateFileA( dll_name, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1086 ok( h != INVALID_HANDLE_VALUE, "open failed err %lu\n", GetLastError() );
1087 CloseHandle( h );
1088
1089 SetLastError(0xdeadbeef);
1090 ret = FreeLibrary(hlib_as_data_file);
1091 ok(ret, "FreeLibrary error %ld\n", GetLastError());
1092
1093 SetLastError(0xdeadbeef);
1094 hlib_as_data_file = LoadLibraryExA(dll_name, 0, LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE);
1095#ifdef __REACTOS__
1096 if (!hlib_as_data_file && GetLastError() == ERROR_INVALID_PARAMETER) {
1097 skip("LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE not supported\n");
1098 FreeLibrary(hlib_as_data_file);
1099 } else {
1100#endif
1101 ok(hlib_as_data_file != 0, "LoadLibraryEx error %lu\n", GetLastError());
1102
1103 SetLastError(0xdeadbeef);
1104 h = CreateFileA( dll_name, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1105 ok( h == INVALID_HANDLE_VALUE, "open succeeded\n" );
1106 ok( GetLastError() == ERROR_SHARING_VIOLATION, "wrong error %lu\n", GetLastError() );
1107 CloseHandle( h );
1108
1109 SetLastError(0xdeadbeef);
1110 h = CreateFileA( dll_name, GENERIC_READ | DELETE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1111 ok( h != INVALID_HANDLE_VALUE, "open failed err %lu\n", GetLastError() );
1112 CloseHandle( h );
1113
1114 SetLastError(0xdeadbeef);
1115 ret = FreeLibrary(hlib_as_data_file);
1116 ok(ret, "FreeLibrary error %ld\n", GetLastError());
1117#ifdef __REACTOS__
1118 }
1119#endif
1120
1121 SetLastError(0xdeadbeef);
1122 hlib_as_data_file = LoadLibraryExA(dll_name, 0, LOAD_LIBRARY_AS_IMAGE_RESOURCE);
1123#ifdef __REACTOS__
1124 if (!hlib_as_data_file && GetLastError() == ERROR_INVALID_PARAMETER) {
1125 skip("LOAD_LIBRARY_AS_IMAGE_RESOURCE not supported\n");
1126 FreeLibrary(hlib_as_data_file);
1127 } else {
1128#endif
1129 ok(hlib_as_data_file != 0, "LoadLibraryEx error %lu\n", GetLastError());
1130 ok(((ULONG_PTR)hlib_as_data_file & 3) == 2, "hlib_as_data_file got %p\n",
1131 hlib_as_data_file);
1132
1133 hlib = GetModuleHandleA(dll_name);
1134 ok(!hlib, "GetModuleHandle should fail\n");
1135
1136 SetLastError(0xdeadbeef);
1137 ret = FreeLibrary(hlib_as_data_file);
1138 ok(ret, "FreeLibrary error %ld\n", GetLastError());
1139#ifdef __REACTOS__
1140 }
1141#endif
1142
1143 SetLastError(0xdeadbeef);
1144 ret = DeleteFileA(dll_name);
1145 ok(ret, "DeleteFile error %ld\n", GetLastError());
1146
1147 nt_header.OptionalHeader.AddressOfEntryPoint = 0x12345678;
1148 file_size = create_test_dll( &dos_header, td[i].size_of_dos_header, &nt_header, dll_name );
1149 if (!file_size)
1150 {
1151 ok(0, "could not create %s\n", dll_name);
1152 winetest_pop_context();
1153 break;
1154 }
1155
1156 query_image_section( i, dll_name, &nt_header, NULL );
1157 }
1158 else
1159 {
1160 BOOL error_match;
1161 int error_index;
1162
1163 error_match = FALSE;
1164 for (error_index = 0;
1165 ! error_match && error_index < ARRAY_SIZE(td[i].errors);
1166 error_index++)
1167 {
1168 error_match = td[i].errors[error_index] == GetLastError();
1169 }
1170 ok(error_match, "unexpected error %ld\n", GetLastError());
1171 }
1172
1173 SetLastError(0xdeadbeef);
1174 ret = DeleteFileA(dll_name);
1175 ok(ret, "DeleteFile error %ld\n", GetLastError());
1176 winetest_pop_context();
1177 }
1178
1179 nt_header = nt_header_template;
1180 nt_header.FileHeader.NumberOfSections = 1;
1181 nt_header.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER);
1182
1183 nt_header.OptionalHeader.SectionAlignment = page_size;
1184 nt_header.OptionalHeader.DllCharacteristics = IMAGE_DLLCHARACTERISTICS_NX_COMPAT;
1185 nt_header.OptionalHeader.FileAlignment = page_size;
1186 nt_header.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER);
1187 nt_header.OptionalHeader.SizeOfImage = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + page_size;
1188
1189 section.SizeOfRawData = sizeof(section_data);
1190 section.PointerToRawData = page_size;
1191 section.VirtualAddress = page_size;
1192 section.Misc.VirtualSize = page_size;
1193
1194 create_test_dll_sections( &dos_header, &nt_header, &section, section_data, dll_name );
1195 init_load_path( dll_name );
1196
1197 nt_header.OptionalHeader.AddressOfEntryPoint = 0x1234;
1198 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1199 ok( status == (nt_header.FileHeader.Machine == IMAGE_FILE_MACHINE_ARM64 ? STATUS_INVALID_IMAGE_FORMAT : STATUS_SUCCESS),
1200 "NtCreateSection error %08lx\n", status );
1201
1202 nt_header.OptionalHeader.DllCharacteristics = IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE;
1203 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1204 ok( status == (nt_header.FileHeader.Machine == IMAGE_FILE_MACHINE_ARM64 ? STATUS_INVALID_IMAGE_FORMAT : STATUS_SUCCESS),
1205 "NtCreateSection error %08lx\n", status );
1206
1207 nt_header.OptionalHeader.SizeOfCode = 0x1000;
1208 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1209 ok( status == (nt_header.FileHeader.Machine == IMAGE_FILE_MACHINE_ARM64 ? STATUS_INVALID_IMAGE_FORMAT : STATUS_SUCCESS),
1210 "NtCreateSection error %08lx\n", status );
1211
1212 nt_header.OptionalHeader.SizeOfCode = 0;
1213 nt_header.OptionalHeader.DllCharacteristics = IMAGE_DLLCHARACTERISTICS_NX_COMPAT | IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE;
1214
1215 dos_header.e_magic = 0;
1216 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1217 ok( status == STATUS_INVALID_IMAGE_NOT_MZ, "NtCreateSection error %08lx\n", status );
1218
1219 dos_header.e_magic = IMAGE_DOS_SIGNATURE;
1220 nt_header.Signature = IMAGE_OS2_SIGNATURE;
1221 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1222 ok( status == STATUS_INVALID_IMAGE_NE_FORMAT, "NtCreateSection error %08lx\n", status );
1223 for (i = 0; i < 16; i++)
1224 {
1225 ((IMAGE_OS2_HEADER *)&nt_header)->ne_exetyp = i;
1226 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1227 switch (i)
1228 {
1229 case 2:
1230 ok( status == STATUS_INVALID_IMAGE_WIN_16, "NtCreateSection %u error %08lx\n", i, status );
1231 break;
1232 case 5:
1233 ok( status == STATUS_INVALID_IMAGE_PROTECT, "NtCreateSection %u error %08lx\n", i, status );
1234 break;
1235 default:
1236 ok( status == STATUS_INVALID_IMAGE_NE_FORMAT, "NtCreateSection %u error %08lx\n", i, status );
1237 break;
1238 }
1239 }
1240 ((IMAGE_OS2_HEADER *)&nt_header)->ne_exetyp = ((IMAGE_OS2_HEADER *)&nt_header_template)->ne_exetyp;
1241
1242 dos_header.e_lfanew = 0x98760000;
1243 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1244 ok( status == STATUS_INVALID_IMAGE_PROTECT, "NtCreateSection error %08lx\n", status );
1245
1246 dos_header.e_lfanew = sizeof(dos_header);
1247 nt_header.Signature = 0xdeadbeef;
1248 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1249 ok( status == STATUS_INVALID_IMAGE_PROTECT, "NtCreateSection error %08lx\n", status );
1250
1251 nt_header.Signature = IMAGE_NT_SIGNATURE;
1252 nt_header.OptionalHeader.Magic = 0xdead;
1253 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1254 ok( status == STATUS_INVALID_IMAGE_FORMAT, "NtCreateSection error %08lx\n", status );
1255
1256 nt_header.OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
1257 nt_header.FileHeader.Machine = 0xdead;
1258 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1259 ok( status == STATUS_INVALID_IMAGE_FORMAT, "NtCreateSection error %08lx\n", status );
1260
1261 nt_header.FileHeader.Machine = IMAGE_FILE_MACHINE_UNKNOWN;
1262 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1263 ok( status == STATUS_INVALID_IMAGE_FORMAT, "NtCreateSection error %08lx\n", status );
1264
1265 nt_header.FileHeader.Machine = get_alt_bitness_machine( orig_machine );
1266 status = map_image_section( &nt_header, &section, section_data, __LINE__ );
1267 ok( status == STATUS_INVALID_IMAGE_FORMAT, "NtCreateSection error %08lx\n", status );
1268
1269 nt_header.FileHeader.Machine = orig_machine;
1270 nt_header.OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
1271 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = page_size;
1272 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = sizeof(cor_header);
1273 section.SizeOfRawData = sizeof(cor_header);
1274
1275 memset( &cor_header, 0, sizeof(cor_header) );
1276 cor_header.cb = sizeof(cor_header);
1277 cor_header.MajorRuntimeVersion = 2;
1278 cor_header.MinorRuntimeVersion = 4;
1279 cor_header.Flags = COMIMAGE_FLAGS_ILONLY;
1280 cor_header.EntryPointToken = 0xbeef;
1281 status = map_image_section( &nt_header, &section, &cor_header, __LINE__ );
1282 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1283
1284 cor_header.MinorRuntimeVersion = 5;
1285 status = map_image_section( &nt_header, &section, &cor_header, __LINE__ );
1286 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1287
1288 cor_header.MajorRuntimeVersion = 3;
1289 cor_header.MinorRuntimeVersion = 0;
1290 status = map_image_section( &nt_header, &section, &cor_header, __LINE__ );
1291 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1292
1293 cor_header.Flags = COMIMAGE_FLAGS_ILONLY | COMIMAGE_FLAGS_32BITREQUIRED;
1294 status = map_image_section( &nt_header, &section, &cor_header, __LINE__ );
1295 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1296
1297 cor_header.Flags = COMIMAGE_FLAGS_ILONLY | COMIMAGE_FLAGS_32BITPREFERRED;
1298 status = map_image_section( &nt_header, &section, &cor_header, __LINE__ );
1299 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1300
1301 cor_header.Flags = 0;
1302 status = map_image_section( &nt_header, &section, &cor_header, __LINE__ );
1303 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1304
1305 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = 1;
1306 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = 1;
1307 status = map_image_section( &nt_header, &section, &cor_header, __LINE__ );
1308 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1309
1310 if (nt_header.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
1311 {
1312 IMAGE_NT_HEADERS64 nt64;
1313
1314 memset( &nt64, 0, sizeof(nt64) );
1315 nt64.Signature = IMAGE_NT_SIGNATURE;
1316 nt64.FileHeader.Machine = orig_machine;
1317 nt64.FileHeader.NumberOfSections = 1;
1318 nt64.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER64);
1319 nt64.FileHeader.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL;
1320 nt64.OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
1321 nt64.OptionalHeader.MajorLinkerVersion = 1;
1322 nt64.OptionalHeader.SizeOfCode = 0x1000;
1323 nt64.OptionalHeader.AddressOfEntryPoint = 0x1000;
1324 nt64.OptionalHeader.ImageBase = 0x10000000;
1325 nt64.OptionalHeader.SectionAlignment = 0x1000;
1326 nt64.OptionalHeader.FileAlignment = 0x1000;
1327 nt64.OptionalHeader.MajorOperatingSystemVersion = 4;
1328 nt64.OptionalHeader.MajorImageVersion = 1;
1329 nt64.OptionalHeader.MajorSubsystemVersion = 4;
1330 nt64.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt64) + sizeof(IMAGE_SECTION_HEADER);
1331 nt64.OptionalHeader.SizeOfImage = nt64.OptionalHeader.SizeOfHeaders + 0x1000;
1332 nt64.OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
1333 nt64.OptionalHeader.SizeOfStackReserve = 0x321000;
1334 nt64.OptionalHeader.SizeOfStackCommit = 0x123000;
1335 section.Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
1336
1337 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, section_data, __LINE__ );
1338 ok( status == (is_wow64 ? STATUS_INVALID_IMAGE_FORMAT : STATUS_INVALID_IMAGE_WIN_64),
1339 "NtCreateSection error %08lx\n", status );
1340
1341 switch (orig_machine)
1342 {
1343 case IMAGE_FILE_MACHINE_I386: nt64.FileHeader.Machine = IMAGE_FILE_MACHINE_ARM64; break;
1344 case IMAGE_FILE_MACHINE_ARMNT: nt64.FileHeader.Machine = IMAGE_FILE_MACHINE_AMD64; break;
1345 }
1346 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, section_data, __LINE__ );
1347 ok( status == (is_wow64 ? STATUS_INVALID_IMAGE_FORMAT : STATUS_INVALID_IMAGE_WIN_64),
1348 "NtCreateSection error %08lx\n", status );
1349
1350 nt64.FileHeader.Machine = get_alt_bitness_machine( orig_machine );
1351 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, section_data, __LINE__ );
1352 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1353 "NtCreateSection error %08lx\n", status );
1354
1355 nt64.OptionalHeader.SizeOfCode = 0;
1356 nt64.OptionalHeader.AddressOfEntryPoint = 0x1000;
1357 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE;
1358 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, section_data, __LINE__ );
1359 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1360 "NtCreateSection error %08lx\n", status );
1361
1362 nt64.OptionalHeader.SizeOfCode = 0;
1363 nt64.OptionalHeader.AddressOfEntryPoint = 0;
1364 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE;
1365 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, section_data, __LINE__ );
1366 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1367 "NtCreateSection error %08lx\n", status );
1368
1369 nt64.OptionalHeader.SizeOfCode = 0x1000;
1370 nt64.OptionalHeader.AddressOfEntryPoint = 0;
1371 nt64.OptionalHeader.DllCharacteristics = IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE;
1372 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE;
1373 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, section_data, __LINE__ );
1374 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1375 "NtCreateSection error %08lx\n", status );
1376
1377 nt64.OptionalHeader.SizeOfCode = 0;
1378 nt64.OptionalHeader.AddressOfEntryPoint = 0;
1379 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE;
1380 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, section_data, __LINE__ );
1381 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1382 "NtCreateSection error %08lx\n", status );
1383
1384 nt64.OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
1385 nt64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = page_size;
1386 nt64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = sizeof(cor_header);
1387 cor_header.MajorRuntimeVersion = 2;
1388 cor_header.MinorRuntimeVersion = 4;
1389 cor_header.Flags = COMIMAGE_FLAGS_ILONLY;
1390 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, &cor_header, __LINE__ );
1391 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1392 "NtCreateSection error %08lx\n", status );
1393
1394 nt64.OptionalHeader.SizeOfCode = 0x1000;
1395 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, &cor_header, __LINE__ );
1396 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1397 "NtCreateSection error %08lx\n", status );
1398
1399 cor_header.MinorRuntimeVersion = 5;
1400 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, &cor_header, __LINE__ );
1401 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1402 "NtCreateSection error %08lx\n", status );
1403
1404 cor_header.Flags = COMIMAGE_FLAGS_ILONLY | COMIMAGE_FLAGS_32BITREQUIRED;
1405 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, &cor_header, __LINE__ );
1406 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1407 "NtCreateSection error %08lx\n", status );
1408
1409 cor_header.Flags = COMIMAGE_FLAGS_ILONLY | COMIMAGE_FLAGS_32BITPREFERRED;
1410 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, &cor_header, __LINE__ );
1411 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1412 "NtCreateSection error %08lx\n", status );
1413
1414 cor_header.Flags = 0;
1415 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, &cor_header, __LINE__ );
1416 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1417 "NtCreateSection error %08lx\n", status );
1418
1419 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = 1;
1420 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = 1;
1421 status = map_image_section( (IMAGE_NT_HEADERS *)&nt64, &section, &cor_header, __LINE__ );
1422 ok( status == (is_wow64 ? STATUS_SUCCESS : STATUS_INVALID_IMAGE_WIN_64),
1423 "NtCreateSection error %08lx\n", status );
1424 }
1425#ifdef __REACTOS__
1426 else if (is_reactos() && orig_machine == IMAGE_FILE_MACHINE_AMD64)
1427 {
1428 ok(FALSE, "FIXME: These tests crash on ReactOS x64!\n");
1429 }
1430 else
1431#else
1432 else
1433#endif
1434 {
1435 IMAGE_NT_HEADERS32 nt32;
1436
1437 memset( &nt32, 0, sizeof(nt32) );
1438 nt32.Signature = IMAGE_NT_SIGNATURE;
1439 nt32.FileHeader.Machine = orig_machine;
1440 nt32.FileHeader.NumberOfSections = 1;
1441 nt32.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER32);
1442 nt32.FileHeader.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL;
1443 nt32.OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR32_MAGIC;
1444 nt32.OptionalHeader.MajorLinkerVersion = 1;
1445 nt32.OptionalHeader.SizeOfCode = 0x1000;
1446 nt32.OptionalHeader.AddressOfEntryPoint = 0x1000;
1447 nt32.OptionalHeader.ImageBase = 0x10000000;
1448 nt32.OptionalHeader.SectionAlignment = 0x1000;
1449 nt32.OptionalHeader.FileAlignment = 0x1000;
1450 nt32.OptionalHeader.MajorOperatingSystemVersion = 4;
1451 nt32.OptionalHeader.MajorImageVersion = 1;
1452 nt32.OptionalHeader.MajorSubsystemVersion = 4;
1453 nt32.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt32) + sizeof(IMAGE_SECTION_HEADER);
1454 nt32.OptionalHeader.SizeOfImage = nt32.OptionalHeader.SizeOfHeaders + 0x1000;
1455 nt32.OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
1456 nt32.OptionalHeader.SizeOfStackReserve = 0x321000;
1457 nt32.OptionalHeader.SizeOfStackCommit = 0x123000;
1458 section.Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
1459
1460 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, section_data, __LINE__ );
1461 ok( status == STATUS_INVALID_IMAGE_FORMAT, "NtCreateSection error %08lx\n", status );
1462
1463 if (orig_machine == IMAGE_FILE_MACHINE_AMD64)
1464 {
1465 nt32.FileHeader.Machine = IMAGE_FILE_MACHINE_ARMNT;
1466 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, section_data, __LINE__ );
1467 ok( status == STATUS_INVALID_IMAGE_FORMAT || broken(!status) /* win8 */,
1468 "NtCreateSection error %08lx\n", status );
1469 }
1470
1471 nt32.FileHeader.Machine = IMAGE_FILE_MACHINE_I386;
1472 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, section_data, __LINE__ );
1473 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1474
1475 nt32.OptionalHeader.SizeOfCode = 0;
1476 nt32.OptionalHeader.AddressOfEntryPoint = 0x1000;
1477 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE;
1478 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, section_data, __LINE__ );
1479 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1480
1481 nt32.OptionalHeader.SizeOfCode = 0;
1482 nt32.OptionalHeader.AddressOfEntryPoint = 0;
1483 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE;
1484 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, section_data, __LINE__ );
1485 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1486
1487 nt32.OptionalHeader.SizeOfCode = 0x1000;
1488 nt32.OptionalHeader.AddressOfEntryPoint = 0;
1489 nt32.OptionalHeader.DllCharacteristics = IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE;
1490 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE;
1491 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, section_data, __LINE__ );
1492 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1493
1494 nt32.OptionalHeader.SizeOfCode = 0;
1495 nt32.OptionalHeader.AddressOfEntryPoint = 0;
1496 section.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE;
1497 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, section_data, __LINE__ );
1498 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1499
1500 nt32.OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
1501 nt32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = page_size;
1502 nt32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = sizeof(cor_header);
1503 cor_header.MajorRuntimeVersion = 2;
1504 cor_header.MinorRuntimeVersion = 4;
1505 cor_header.Flags = COMIMAGE_FLAGS_ILONLY;
1506 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, &cor_header, __LINE__ );
1507 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1508
1509 nt32.OptionalHeader.SizeOfCode = 0x1000;
1510 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, &cor_header, __LINE__ );
1511 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1512
1513 cor_header.MinorRuntimeVersion = 5;
1514 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, &cor_header, __LINE__ );
1515 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1516
1517 cor_header.Flags = COMIMAGE_FLAGS_ILONLY | COMIMAGE_FLAGS_32BITREQUIRED;
1518 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, &cor_header, __LINE__ );
1519 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1520
1521 cor_header.Flags = COMIMAGE_FLAGS_ILONLY | COMIMAGE_FLAGS_32BITPREFERRED;
1522 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, &cor_header, __LINE__ );
1523 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1524
1525 cor_header.Flags = 0;
1526 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, &cor_header, __LINE__ );
1527 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1528
1529 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = 1;
1530 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = 1;
1531 status = map_image_section( (IMAGE_NT_HEADERS *)&nt32, &section, &cor_header, __LINE__ );
1532 ok( status == STATUS_SUCCESS, "NtCreateSection error %08lx\n", status );
1533 }
1534
1535 section.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
1536 delete_load_path();
1537}
1538
1539static void test_filenames(void)
1540{
1541 IMAGE_NT_HEADERS nt_header = nt_header_template;
1542 char dll_name[MAX_PATH], long_path[MAX_PATH], short_path[MAX_PATH], buffer[MAX_PATH];
1543 HMODULE mod, mod2;
1544 BOOL ret;
1545
1546 nt_header.FileHeader.NumberOfSections = 1;
1547 nt_header.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER);
1548
1549 nt_header.OptionalHeader.SectionAlignment = page_size;
1550 nt_header.OptionalHeader.DllCharacteristics = IMAGE_DLLCHARACTERISTICS_NX_COMPAT | IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE;
1551 nt_header.OptionalHeader.FileAlignment = page_size;
1552 nt_header.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER);
1553 nt_header.OptionalHeader.SizeOfImage = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + page_size;
1554
1555 create_test_dll( &dos_header, sizeof(dos_header), &nt_header, dll_name );
1556 strcpy( long_path, dll_name );
1557 strcpy( strrchr( long_path, '\\' ), "\\this-is-a-long-name.dll" );
1558 ret = MoveFileA( dll_name, long_path );
1559 ok( ret, "MoveFileA failed err %lu\n", GetLastError() );
1560 GetShortPathNameA( long_path, short_path, MAX_PATH );
1561
1562 mod = LoadLibraryA( short_path );
1563 ok( mod != NULL, "loading failed err %lu\n", GetLastError() );
1564 GetModuleFileNameA( mod, buffer, MAX_PATH );
1565 ok( !lstrcmpiA( buffer, short_path ), "got wrong path %s / %s\n", buffer, short_path );
1566 mod2 = GetModuleHandleA( short_path );
1567 ok( mod == mod2, "wrong module %p for %s\n", mod2, short_path );
1568 mod2 = GetModuleHandleA( long_path );
1569 ok( mod == mod2, "wrong module %p for %s\n", mod2, long_path );
1570 mod2 = LoadLibraryA( long_path );
1571 ok( mod2 != NULL, "loading failed err %lu\n", GetLastError() );
1572 ok( mod == mod2, "library loaded twice\n" );
1573 GetModuleFileNameA( mod2, buffer, MAX_PATH );
1574 ok( !lstrcmpiA( buffer, short_path ), "got wrong path %s / %s\n", buffer, short_path );
1575 FreeLibrary( mod2 );
1576 FreeLibrary( mod );
1577
1578 mod = LoadLibraryA( long_path );
1579 ok( mod != NULL, "loading failed err %lu\n", GetLastError() );
1580 GetModuleFileNameA( mod, buffer, MAX_PATH );
1581 ok( !lstrcmpiA( buffer, long_path ), "got wrong path %s / %s\n", buffer, long_path );
1582 mod2 = GetModuleHandleA( short_path );
1583 ok( mod == mod2, "wrong module %p for %s\n", mod2, short_path );
1584 mod2 = GetModuleHandleA( long_path );
1585 ok( mod == mod2, "wrong module %p for %s\n", mod2, long_path );
1586 mod2 = LoadLibraryA( short_path );
1587 ok( mod2 != NULL, "loading failed err %lu\n", GetLastError() );
1588 ok( mod == mod2, "library loaded twice\n" );
1589 GetModuleFileNameA( mod2, buffer, MAX_PATH );
1590 ok( !lstrcmpiA( buffer, long_path ), "got wrong path %s / %s\n", buffer, long_path );
1591 FreeLibrary( mod2 );
1592 FreeLibrary( mod );
1593
1594 strcpy( dll_name, long_path );
1595 strcpy( strrchr( dll_name, '\\' ), "\\this-is-another-name.dll" );
1596 ret = CreateHardLinkA( dll_name, long_path, NULL );
1597 ok( ret, "CreateHardLinkA failed err %lu\n", GetLastError() );
1598 if (ret)
1599 {
1600 mod = LoadLibraryA( dll_name );
1601 ok( mod != NULL, "loading failed err %lu\n", GetLastError() );
1602 GetModuleFileNameA( mod, buffer, MAX_PATH );
1603 ok( !lstrcmpiA( buffer, dll_name ), "got wrong path %s / %s\n", buffer, dll_name );
1604 mod2 = GetModuleHandleA( long_path );
1605 ok( mod == mod2, "wrong module %p for %s\n", mod2, long_path );
1606 mod2 = LoadLibraryA( long_path );
1607 ok( mod2 != NULL, "loading failed err %lu\n", GetLastError() );
1608 ok( mod == mod2, "library loaded twice\n" );
1609 GetModuleFileNameA( mod2, buffer, MAX_PATH );
1610 ok( !lstrcmpiA( buffer, dll_name ), "got wrong path %s / %s\n", buffer, short_path );
1611 FreeLibrary( mod2 );
1612 FreeLibrary( mod );
1613 DeleteFileA( dll_name );
1614 }
1615 DeleteFileA( long_path );
1616}
1617
1618/* Verify linking style of import descriptors */
1619static void test_ImportDescriptors(void)
1620{
1621 HMODULE kernel32_module = NULL;
1622 PIMAGE_DOS_HEADER d_header;
1623 PIMAGE_NT_HEADERS nt_headers;
1624 DWORD import_dir_size;
1625 DWORD_PTR dir_offset;
1626 PIMAGE_IMPORT_DESCRIPTOR import_chunk;
1627
1628 /* Load kernel32 module */
1629 kernel32_module = GetModuleHandleA("kernel32.dll");
1630 assert( kernel32_module != NULL );
1631
1632 /* Get PE header info from module image */
1633 d_header = (PIMAGE_DOS_HEADER) kernel32_module;
1634 nt_headers = (PIMAGE_NT_HEADERS) (((char*) d_header) +
1635 d_header->e_lfanew);
1636
1637 /* Get size of import entry directory */
1638 import_dir_size = nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size;
1639 if (!import_dir_size)
1640 {
1641 skip("Unable to continue testing due to missing import directory.\n");
1642 return;
1643 }
1644
1645 /* Get address of first import chunk */
1646 dir_offset = nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
1647 import_chunk = RVAToAddr(dir_offset, kernel32_module);
1648 ok(import_chunk != 0, "Invalid import_chunk: %p\n", import_chunk);
1649 if (!import_chunk) return;
1650
1651 /* Iterate through import descriptors and verify set name,
1652 * OriginalFirstThunk, and FirstThunk. Core Windows DLLs, such as
1653 * kernel32.dll, don't use Borland-style linking, where the table of
1654 * imported names is stored directly in FirstThunk and overwritten
1655 * by the relocation, instead of being stored in OriginalFirstThunk.
1656 * */
1657 for (; import_chunk->FirstThunk; import_chunk++)
1658 {
1659 LPCSTR module_name = RVAToAddr(import_chunk->Name, kernel32_module);
1660 PIMAGE_THUNK_DATA name_table = RVAToAddr(
1661 import_chunk->OriginalFirstThunk, kernel32_module);
1662 PIMAGE_THUNK_DATA iat = RVAToAddr(
1663 import_chunk->FirstThunk, kernel32_module);
1664 ok(module_name != NULL, "Imported module name should not be NULL\n");
1665 ok(name_table != NULL,
1666 "Name table for imported module %s should not be NULL\n",
1667 module_name);
1668 ok(iat != NULL, "IAT for imported module %s should not be NULL\n",
1669 module_name);
1670 }
1671}
1672
1673static void test_image_mapping(const char *dll_name, DWORD scn_page_access, BOOL is_dll)
1674{
1675 HANDLE hfile, hmap;
1676 NTSTATUS status;
1677 LARGE_INTEGER offset;
1678 SIZE_T size;
1679 void *addr1, *addr2;
1680 MEMORY_BASIC_INFORMATION info;
1681
1682 if (!pNtMapViewOfSection) return;
1683
1684 SetLastError(0xdeadbeef);
1685 hfile = CreateFileA(dll_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
1686 ok(hfile != INVALID_HANDLE_VALUE, "CreateFile error %ld\n", GetLastError());
1687
1688 SetLastError(0xdeadbeef);
1689 hmap = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, 0);
1690 ok(hmap != 0, "CreateFileMapping error %ld\n", GetLastError());
1691
1692 offset.u.LowPart = 0;
1693 offset.u.HighPart = 0;
1694
1695 addr1 = NULL;
1696 size = 0;
1697 status = pNtMapViewOfSection(hmap, GetCurrentProcess(), &addr1, 0, 0, &offset,
1698 &size, 1 /* ViewShare */, 0, PAGE_READONLY);
1699 ok(NT_SUCCESS(status), "NtMapViewOfSection error %lx\n", status);
1700 ok(addr1 != 0, "mapped address should be valid\n");
1701
1702 SetLastError(0xdeadbeef);
1703 size = VirtualQuery((char *)addr1 + section.VirtualAddress, &info, sizeof(info));
1704 ok(size == sizeof(info), "VirtualQuery error %ld\n", GetLastError());
1705 ok(info.BaseAddress == (char *)addr1 + section.VirtualAddress, "got %p != expected %p\n", info.BaseAddress, (char *)addr1 + section.VirtualAddress);
1706 ok(info.RegionSize == page_size, "got %#Ix != expected %#lx\n", info.RegionSize, page_size);
1707 ok(info.Protect == scn_page_access, "got %#lx != expected %#lx\n", info.Protect, scn_page_access);
1708 ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
1709 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%#lx != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
1710 ok(info.State == MEM_COMMIT, "%#lx != MEM_COMMIT\n", info.State);
1711 ok(info.Type == SEC_IMAGE, "%#lx != SEC_IMAGE\n", info.Type);
1712
1713 addr2 = NULL;
1714 size = 0;
1715 status = pNtMapViewOfSection(hmap, GetCurrentProcess(), &addr2, 0, 0, &offset,
1716 &size, 1 /* ViewShare */, 0, PAGE_READONLY);
1717 ok(status == STATUS_IMAGE_NOT_AT_BASE, "expected STATUS_IMAGE_NOT_AT_BASE, got %lx\n", status);
1718 ok(addr2 != 0, "mapped address should be valid\n");
1719 ok(addr2 != addr1, "mapped addresses should be different\n");
1720
1721 SetLastError(0xdeadbeef);
1722 size = VirtualQuery((char *)addr2 + section.VirtualAddress, &info, sizeof(info));
1723 ok(size == sizeof(info), "VirtualQuery error %ld\n", GetLastError());
1724 ok(info.BaseAddress == (char *)addr2 + section.VirtualAddress, "got %p != expected %p\n", info.BaseAddress, (char *)addr2 + section.VirtualAddress);
1725 ok(info.RegionSize == page_size, "got %#Ix != expected %#lx\n", info.RegionSize, page_size);
1726 ok(info.Protect == scn_page_access, "got %#lx != expected %#lx\n", info.Protect, scn_page_access);
1727 ok(info.AllocationBase == addr2, "%p != %p\n", info.AllocationBase, addr2);
1728 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%#lx != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
1729 ok(info.State == MEM_COMMIT, "%#lx != MEM_COMMIT\n", info.State);
1730 ok(info.Type == SEC_IMAGE, "%#lx != SEC_IMAGE\n", info.Type);
1731
1732 status = pNtUnmapViewOfSection(GetCurrentProcess(), addr2);
1733 ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection error %lx\n", status);
1734
1735 addr2 = MapViewOfFile(hmap, 0, 0, 0, 0);
1736 ok(addr2 != 0, "mapped address should be valid\n");
1737 ok(addr2 != addr1, "mapped addresses should be different\n");
1738
1739 SetLastError(0xdeadbeef);
1740 size = VirtualQuery((char *)addr2 + section.VirtualAddress, &info, sizeof(info));
1741 ok(size == sizeof(info), "VirtualQuery error %ld\n", GetLastError());
1742 ok(info.BaseAddress == (char *)addr2 + section.VirtualAddress, "got %p != expected %p\n", info.BaseAddress, (char *)addr2 + section.VirtualAddress);
1743 ok(info.RegionSize == page_size, "got %#Ix != expected %#lx\n", info.RegionSize, page_size);
1744 ok(info.Protect == scn_page_access, "got %#lx != expected %#lx\n", info.Protect, scn_page_access);
1745 ok(info.AllocationBase == addr2, "%p != %p\n", info.AllocationBase, addr2);
1746 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%#lx != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
1747 ok(info.State == MEM_COMMIT, "%#lx != MEM_COMMIT\n", info.State);
1748 ok(info.Type == SEC_IMAGE, "%#lx != SEC_IMAGE\n", info.Type);
1749
1750 UnmapViewOfFile(addr2);
1751
1752 SetLastError(0xdeadbeef);
1753 addr2 = LoadLibraryA(dll_name);
1754 if (!addr2)
1755 {
1756 ok(is_dll, "LoadLibrary should fail, is_dll %d\n", is_dll);
1757 ok(GetLastError() == ERROR_INVALID_ADDRESS, "expected ERROR_INVALID_ADDRESS, got %ld\n", GetLastError());
1758 }
1759 else
1760 {
1761 BOOL ret;
1762 ok(addr2 != 0, "LoadLibrary error %ld, is_dll %d\n", GetLastError(), is_dll);
1763 ok(addr2 != addr1, "mapped addresses should be different\n");
1764
1765 SetLastError(0xdeadbeef);
1766 ret = FreeLibrary(addr2);
1767 ok(ret, "FreeLibrary error %ld\n", GetLastError());
1768 }
1769
1770 status = pNtUnmapViewOfSection(GetCurrentProcess(), addr1);
1771 ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection error %lx\n", status);
1772
1773 CloseHandle(hmap);
1774 CloseHandle(hfile);
1775}
1776
1777static BOOL is_mem_writable(DWORD prot)
1778{
1779 switch (prot & 0xff)
1780 {
1781 case PAGE_READWRITE:
1782 case PAGE_WRITECOPY:
1783 case PAGE_EXECUTE_READWRITE:
1784 case PAGE_EXECUTE_WRITECOPY:
1785 return TRUE;
1786
1787 default:
1788 return FALSE;
1789 }
1790}
1791
1792static void test_VirtualProtect(void *base, void *section)
1793{
1794 static const struct test_data
1795 {
1796 DWORD prot_set, prot_get;
1797 } td[] =
1798 {
1799 { 0, 0 }, /* 0x00 */
1800 { PAGE_NOACCESS, PAGE_NOACCESS }, /* 0x01 */
1801 { PAGE_READONLY, PAGE_READONLY }, /* 0x02 */
1802 { PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x03 */
1803 { PAGE_READWRITE, PAGE_WRITECOPY }, /* 0x04 */
1804 { PAGE_READWRITE | PAGE_NOACCESS, 0 }, /* 0x05 */
1805 { PAGE_READWRITE | PAGE_READONLY, 0 }, /* 0x06 */
1806 { PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x07 */
1807 { PAGE_WRITECOPY, PAGE_WRITECOPY }, /* 0x08 */
1808 { PAGE_WRITECOPY | PAGE_NOACCESS, 0 }, /* 0x09 */
1809 { PAGE_WRITECOPY | PAGE_READONLY, 0 }, /* 0x0a */
1810 { PAGE_WRITECOPY | PAGE_NOACCESS | PAGE_READONLY, 0 }, /* 0x0b */
1811 { PAGE_WRITECOPY | PAGE_READWRITE, 0 }, /* 0x0c */
1812 { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_NOACCESS, 0 }, /* 0x0d */
1813 { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY, 0 }, /* 0x0e */
1814 { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x0f */
1815
1816 { PAGE_EXECUTE, PAGE_EXECUTE }, /* 0x10 */
1817 { PAGE_EXECUTE_READ, PAGE_EXECUTE_READ }, /* 0x20 */
1818 { PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0x30 */
1819 { PAGE_EXECUTE_READWRITE, PAGE_EXECUTE_WRITECOPY }, /* 0x40 */
1820 { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, 0 }, /* 0x50 */
1821 { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, 0 }, /* 0x60 */
1822 { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0x70 */
1823 { PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_WRITECOPY }, /* 0x80 */
1824 { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE, 0 }, /* 0x90 */
1825 { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ, 0 }, /* 0xa0 */
1826 { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0xb0 */
1827 { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE, 0 }, /* 0xc0 */
1828 { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, 0 }, /* 0xd0 */
1829 { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, 0 }, /* 0xe0 */
1830 { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 } /* 0xf0 */
1831 };
1832 DWORD ret, orig_prot, old_prot, rw_prot, exec_prot, i, j;
1833 MEMORY_BASIC_INFORMATION info;
1834
1835 SetLastError(0xdeadbeef);
1836 ret = VirtualProtect(section, page_size, PAGE_NOACCESS, &old_prot);
1837 ok(ret, "VirtualProtect error %ld\n", GetLastError());
1838
1839 orig_prot = old_prot;
1840
1841 for (i = 0; i < ARRAY_SIZE(td); i++)
1842 {
1843 SetLastError(0xdeadbeef);
1844 ret = VirtualQuery(section, &info, sizeof(info));
1845 ok(ret, "VirtualQuery failed %ld\n", GetLastError());
1846 ok(info.BaseAddress == section, "%ld: got %p != expected %p\n", i, info.BaseAddress, section);
1847 ok(info.RegionSize == page_size, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, page_size);
1848 ok(info.Protect == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, info.Protect);
1849 ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
1850 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%ld: %#lx != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
1851 ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
1852 ok(info.Type == SEC_IMAGE, "%ld: %#lx != SEC_IMAGE\n", i, info.Type);
1853
1854 old_prot = 0xdeadbeef;
1855 SetLastError(0xdeadbeef);
1856 ret = VirtualProtect(section, page_size, td[i].prot_set, &old_prot);
1857 if (td[i].prot_get)
1858 {
1859 ok(ret, "%ld: VirtualProtect error %ld, requested prot %#lx\n", i, GetLastError(), td[i].prot_set);
1860 ok(old_prot == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, old_prot);
1861
1862 SetLastError(0xdeadbeef);
1863 ret = VirtualQuery(section, &info, sizeof(info));
1864 ok(ret, "VirtualQuery failed %ld\n", GetLastError());
1865 ok(info.BaseAddress == section, "%ld: got %p != expected %p\n", i, info.BaseAddress, section);
1866 ok(info.RegionSize == page_size, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, page_size);
1867 ok(info.Protect == td[i].prot_get, "%ld: got %#lx != expected %#lx\n", i, info.Protect, td[i].prot_get);
1868 ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
1869 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%ld: %#lx != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
1870 ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
1871 ok(info.Type == SEC_IMAGE, "%ld: %#lx != SEC_IMAGE\n", i, info.Type);
1872 }
1873 else
1874 {
1875 ok(!ret, "%ld: VirtualProtect should fail\n", i);
1876 ok(GetLastError() == ERROR_INVALID_PARAMETER, "%ld: expected ERROR_INVALID_PARAMETER, got %ld\n", i, GetLastError());
1877 }
1878
1879 old_prot = 0xdeadbeef;
1880 SetLastError(0xdeadbeef);
1881 ret = VirtualProtect(section, page_size, PAGE_NOACCESS, &old_prot);
1882 ok(ret, "%ld: VirtualProtect error %ld\n", i, GetLastError());
1883 if (td[i].prot_get)
1884 ok(old_prot == td[i].prot_get, "%ld: got %#lx != expected %#lx\n", i, old_prot, td[i].prot_get);
1885 else
1886 ok(old_prot == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, old_prot);
1887 }
1888
1889 exec_prot = 0;
1890
1891 for (i = 0; i <= 4; i++)
1892 {
1893 rw_prot = 0;
1894
1895 for (j = 0; j <= 4; j++)
1896 {
1897 DWORD prot = exec_prot | rw_prot;
1898
1899 SetLastError(0xdeadbeef);
1900 ret = VirtualProtect(section, page_size, prot, &old_prot);
1901 if ((rw_prot && exec_prot) || (!rw_prot && !exec_prot))
1902 {
1903 ok(!ret, "VirtualProtect(%02lx) should fail\n", prot);
1904 ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
1905 }
1906 else
1907 ok(ret, "VirtualProtect(%02lx) error %ld\n", prot, GetLastError());
1908
1909 rw_prot = 1 << j;
1910 }
1911
1912 exec_prot = 1 << (i + 4);
1913 }
1914
1915 SetLastError(0xdeadbeef);
1916 ret = VirtualProtect(section, page_size, orig_prot, &old_prot);
1917 ok(ret, "VirtualProtect error %ld\n", GetLastError());
1918}
1919
1920static void test_section_access(void)
1921{
1922 static const struct test_data
1923 {
1924 DWORD scn_file_access, scn_page_access, scn_page_access_after_write;
1925 } td[] =
1926 {
1927 { 0, PAGE_NOACCESS, 0 },
1928 { IMAGE_SCN_MEM_READ, PAGE_READONLY, 0 },
1929 { IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
1930 { IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE, 0 },
1931 { IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
1932 { IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_READ },
1933 { IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
1934 { IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
1935
1936 { IMAGE_SCN_CNT_INITIALIZED_DATA, PAGE_NOACCESS, 0 },
1937 { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ, PAGE_READONLY, 0 },
1938 { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
1939 { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE, 0 },
1940 { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
1941 { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_READ, 0 },
1942 { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
1943 { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
1944
1945 { IMAGE_SCN_CNT_UNINITIALIZED_DATA, PAGE_NOACCESS, 0 },
1946 { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ, PAGE_READONLY, 0 },
1947 { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
1948 { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE, 0 },
1949 { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
1950 { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_READ, 0 },
1951 { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
1952 { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE }
1953 };
1954 char buf[256];
1955 int i;
1956 DWORD dummy;
1957 HANDLE hfile;
1958 HMODULE hlib;
1959 char temp_path[MAX_PATH];
1960 char dll_name[MAX_PATH];
1961 SIZE_T size;
1962 PEB child_peb;
1963 PROCESS_BASIC_INFORMATION pbi;
1964 SECTION_IMAGE_INFORMATION image_info;
1965 MEMORY_BASIC_INFORMATION info;
1966 STARTUPINFOA sti;
1967 PROCESS_INFORMATION pi;
1968 NTSTATUS status;
1969 DWORD ret;
1970
1971 /* prevent displaying of the "Unable to load this DLL" message box */
1972 SetErrorMode(SEM_FAILCRITICALERRORS);
1973
1974 GetTempPathA(MAX_PATH, temp_path);
1975
1976 for (i = 0; i < ARRAY_SIZE(td); i++)
1977 {
1978 IMAGE_NT_HEADERS nt_header;
1979
1980 GetTempFileNameA(temp_path, "ldr", 0, dll_name);
1981
1982 /*trace("creating %s\n", dll_name);*/
1983 hfile = CreateFileA(dll_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
1984 if (hfile == INVALID_HANDLE_VALUE)
1985 {
1986 ok(0, "could not create %s\n", dll_name);
1987 return;
1988 }
1989
1990 SetLastError(0xdeadbeef);
1991 ret = WriteFile(hfile, &dos_header, sizeof(dos_header), &dummy, NULL);
1992 ok(ret, "WriteFile error %ld\n", GetLastError());
1993
1994 nt_header = nt_header_template;
1995 nt_header.OptionalHeader.SectionAlignment = page_size;
1996 nt_header.OptionalHeader.FileAlignment = 0x200;
1997 nt_header.OptionalHeader.SizeOfImage = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + page_size;
1998 nt_header.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER);
1999
2000 section.SizeOfRawData = sizeof(section_data);
2001 section.PointerToRawData = nt_header.OptionalHeader.FileAlignment;
2002 section.VirtualAddress = nt_header.OptionalHeader.SectionAlignment;
2003 section.Misc.VirtualSize = section.SizeOfRawData;
2004 section.Characteristics = td[i].scn_file_access;
2005 SetLastError(0xdeadbeef);
2006
2007 SetLastError(0xdeadbeef);
2008 ret = WriteFile(hfile, &nt_header, sizeof(nt_header), &dummy, NULL);
2009 ok(ret, "WriteFile error %ld\n", GetLastError());
2010
2011 ret = WriteFile(hfile, &section, sizeof(section), &dummy, NULL);
2012 ok(ret, "WriteFile error %ld\n", GetLastError());
2013
2014 /* section data */
2015 SetFilePointer( hfile, nt_header.OptionalHeader.FileAlignment, NULL, FILE_BEGIN );
2016 SetLastError(0xdeadbeef);
2017 ret = WriteFile(hfile, section_data, sizeof(section_data), &dummy, NULL);
2018 ok(ret, "WriteFile error %ld\n", GetLastError());
2019
2020 CloseHandle(hfile);
2021 SetLastError(0xdeadbeef);
2022 hlib = LoadLibraryExA(dll_name, NULL, DONT_RESOLVE_DLL_REFERENCES);
2023 ok(hlib != 0, "LoadLibrary error %ld\n", GetLastError());
2024
2025 SetLastError(0xdeadbeef);
2026 size = VirtualQuery((char *)hlib + section.VirtualAddress, &info, sizeof(info));
2027 ok(size == sizeof(info),
2028 "%d: VirtualQuery error %ld\n", i, GetLastError());
2029 ok(info.BaseAddress == (char *)hlib + section.VirtualAddress, "%d: got %p != expected %p\n", i, info.BaseAddress, (char *)hlib + section.VirtualAddress);
2030 ok(info.RegionSize == page_size, "%d: got %#Ix != expected %#lx\n", i, info.RegionSize, page_size);
2031 ok(info.Protect == td[i].scn_page_access, "%d: got %#lx != expected %#lx\n", i, info.Protect, td[i].scn_page_access);
2032 ok(info.AllocationBase == hlib, "%d: %p != %p\n", i, info.AllocationBase, hlib);
2033 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %#lx != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
2034 ok(info.State == MEM_COMMIT, "%d: %#lx != MEM_COMMIT\n", i, info.State);
2035 ok(info.Type == SEC_IMAGE, "%d: %#lx != SEC_IMAGE\n", i, info.Type);
2036 if (info.Protect != PAGE_NOACCESS)
2037 ok(!memcmp((const char *)info.BaseAddress, section_data, section.SizeOfRawData), "wrong section data\n");
2038
2039 test_VirtualProtect(hlib, (char *)hlib + section.VirtualAddress);
2040
2041 /* Windows changes the WRITECOPY to WRITE protection on an image section write (for a changed page only) */
2042 if (is_mem_writable(info.Protect))
2043 {
2044 char *p = info.BaseAddress;
2045 *p = 0xfe;
2046 SetLastError(0xdeadbeef);
2047 size = VirtualQuery((char *)hlib + section.VirtualAddress, &info, sizeof(info));
2048 ok(size == sizeof(info), "%d: VirtualQuery error %ld\n", i, GetLastError());
2049 /* FIXME: remove the condition below once Wine is fixed */
2050 todo_wine_if (info.Protect == PAGE_WRITECOPY || info.Protect == PAGE_EXECUTE_WRITECOPY)
2051 ok(info.Protect == td[i].scn_page_access_after_write, "%d: got %#lx != expected %#lx\n", i, info.Protect, td[i].scn_page_access_after_write);
2052 }
2053
2054 SetLastError(0xdeadbeef);
2055 ret = FreeLibrary(hlib);
2056 ok(ret, "FreeLibrary error %ld\n", GetLastError());
2057
2058 test_image_mapping(dll_name, td[i].scn_page_access, TRUE);
2059
2060 /* reset IMAGE_FILE_DLL otherwise CreateProcess fails */
2061 nt_header.FileHeader.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
2062 SetLastError(0xdeadbeef);
2063 hfile = CreateFileA(dll_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
2064 /* LoadLibrary called on an already memory-mapped file in
2065 * test_image_mapping() above leads to a file handle leak
2066 * under nt4, and inability to overwrite and delete the file
2067 * due to sharing violation error. Ignore it and skip the test,
2068 * but leave a not deletable temporary file.
2069 */
2070 ok(hfile != INVALID_HANDLE_VALUE, "CreateFile error %ld\n", GetLastError());
2071 SetFilePointer(hfile, sizeof(dos_header), NULL, FILE_BEGIN);
2072 SetLastError(0xdeadbeef);
2073 ret = WriteFile(hfile, &nt_header, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), &dummy, NULL);
2074 ok(ret, "WriteFile error %ld\n", GetLastError());
2075 CloseHandle(hfile);
2076
2077 memset(&sti, 0, sizeof(sti));
2078 sti.cb = sizeof(sti);
2079 SetLastError(0xdeadbeef);
2080 ret = CreateProcessA(dll_name, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &sti, &pi);
2081 ok(ret, "CreateProcess() error %ld\n", GetLastError());
2082
2083 status = pNtQueryInformationProcess( pi.hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL );
2084 ok( !status, "ProcessBasicInformation got %lx\n", status );
2085 ret = ReadProcessMemory( pi.hProcess, pbi.PebBaseAddress, &child_peb, sizeof(child_peb), NULL );
2086 ok( ret, "ReadProcessMemory failed err %lu\n", GetLastError() );
2087 hlib = child_peb.ImageBaseAddress;
2088
2089 SetLastError(0xdeadbeef);
2090 size = VirtualQueryEx(pi.hProcess, (char *)hlib + section.VirtualAddress, &info, sizeof(info));
2091 ok(size == sizeof(info),
2092 "%d: VirtualQuery error %ld\n", i, GetLastError());
2093 ok(info.BaseAddress == (char *)hlib + section.VirtualAddress, "%d: got %p != expected %p\n", i, info.BaseAddress, (char *)hlib + section.VirtualAddress);
2094 ok(info.RegionSize == page_size, "%d: got %#Ix != expected %#lx\n", i, info.RegionSize, page_size);
2095 ok(info.Protect == td[i].scn_page_access, "%d: got %#lx != expected %#lx\n", i, info.Protect, td[i].scn_page_access);
2096 ok(info.AllocationBase == hlib, "%d: %p != %p\n", i, info.AllocationBase, hlib);
2097 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %#lx != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
2098 ok(info.State == MEM_COMMIT, "%d: %#lx != MEM_COMMIT\n", i, info.State);
2099 ok(info.Type == SEC_IMAGE, "%d: %#lx != SEC_IMAGE\n", i, info.Type);
2100 if (info.Protect != PAGE_NOACCESS)
2101 {
2102 SetLastError(0xdeadbeef);
2103 ret = ReadProcessMemory(pi.hProcess, info.BaseAddress, buf, section.SizeOfRawData, NULL);
2104 ok(ret, "ReadProcessMemory() error %ld\n", GetLastError());
2105 ok(!memcmp(buf, section_data, section.SizeOfRawData), "wrong section data\n");
2106 }
2107
2108#ifdef __REACTOS__
2109 if (GetNTVersion() >= _WIN32_WINNT_VISTA) { // Crashes on WS03
2110#endif
2111 status = NtQueryInformationProcess(pi.hProcess, ProcessImageInformation,
2112 &image_info, sizeof(image_info), NULL );
2113 ok(!status, "Got unexpected status %#lx.\n", status);
2114 ok(!(image_info.ImageCharacteristics & IMAGE_FILE_DLL),
2115 "Got unexpected characteristics %#x.\n", nt_header.FileHeader.Characteristics);
2116 status = NtUnmapViewOfSection(pi.hProcess, info.BaseAddress);
2117 ok(!status, "Got unexpected status %#lx.\n", status);
2118 status = NtQueryInformationProcess(pi.hProcess, ProcessImageInformation,
2119 &image_info, sizeof(image_info), NULL );
2120 ok(!status, "Got unexpected status %#lx.\n", status);
2121 ok(!(image_info.ImageCharacteristics & IMAGE_FILE_DLL),
2122 "Got unexpected characteristics %#x.\n", nt_header.FileHeader.Characteristics);
2123#ifdef __REACTOS__
2124 }
2125#endif
2126
2127 SetLastError(0xdeadbeef);
2128 ret = TerminateProcess(pi.hProcess, 0);
2129 ok(ret, "TerminateProcess() error %ld\n", GetLastError());
2130 ret = WaitForSingleObject(pi.hProcess, 3000);
2131 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed: %lx\n", ret);
2132
2133 CloseHandle(pi.hThread);
2134 CloseHandle(pi.hProcess);
2135
2136 test_image_mapping(dll_name, td[i].scn_page_access, FALSE);
2137
2138 DeleteFileA(dll_name);
2139 }
2140}
2141
2142static void check_tls_index(HANDLE dll, BOOL tls_initialized)
2143{
2144 BOOL found_dll = FALSE;
2145 LIST_ENTRY *root = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
2146 for (LIST_ENTRY *entry = root->Flink; entry != root; entry = entry->Flink)
2147 {
2148 LDR_DATA_TABLE_ENTRY *mod = CONTAINING_RECORD(entry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
2149 if (wcsicmp(L"ntdll.dll", mod->BaseDllName.Buffer) == 0)
2150 {
2151 /* Pick ntdll as a dll that definitely won't have TLS */
2152 ok(mod->TlsIndex == 0, "ntdll.dll TlsIndex: %d instead of 0\n", mod->TlsIndex);
2153 }
2154 else if (mod->DllBase == dll)
2155 {
2156 SHORT expected = tls_initialized ? -1 : 0;
2157 ok(mod->TlsIndex == expected, "Test exe TlsIndex: %d instead of %d\n", mod->TlsIndex, expected);
2158 found_dll = TRUE;
2159 }
2160 else
2161 {
2162 ok(mod->TlsIndex == 0 || mod->TlsIndex == -1, "%s TlsIndex: %d\n",
2163 debugstr_w(mod->BaseDllName.Buffer), mod->TlsIndex);
2164 }
2165 }
2166 ok(found_dll, "Couldn't find dll %p in module list\n", dll);
2167}
2168
2169static int tls_init_fn_output;
2170
2171static DWORD WINAPI tls_thread_fn(void* tlsidx_v)
2172{
2173 int tls_index = (int)(DWORD_PTR)(tlsidx_v);
2174 const char* str = ((char **)NtCurrentTeb()->ThreadLocalStoragePointer)[tls_index];
2175 ok( !strcmp( str, "hello world" ), "wrong tls data '%s' at %p\n", str, str );
2176 ok( tls_init_fn_output == DLL_THREAD_ATTACH,
2177 "tls init function didn't run or got wrong reason: %d instead of %d\n", tls_init_fn_output, DLL_THREAD_ATTACH );
2178 tls_init_fn_output = 9999;
2179 return 0;
2180}
2181
2182static void test_import_resolution(void)
2183{
2184 char temp_path[MAX_PATH];
2185 char dll_name[MAX_PATH];
2186 DWORD dummy;
2187 void *expect, *tmp;
2188 char *str;
2189 SIZE_T size;
2190 HANDLE hfile, mapping;
2191 HMODULE mod, mod2;
2192 NTSTATUS status;
2193 LARGE_INTEGER offset;
2194 struct imports
2195 {
2196 IMAGE_IMPORT_DESCRIPTOR descr[2];
2197 IMAGE_THUNK_DATA original_thunks[2];
2198 IMAGE_THUNK_DATA thunks[2];
2199 char module[16];
2200 struct { WORD hint; char name[32]; } function;
2201 IMAGE_TLS_DIRECTORY tls;
2202 UINT_PTR tls_init_fn_list[2];
2203 char tls_data[16];
2204 SHORT tls_index;
2205 SHORT tls_index_hi;
2206 int* tls_init_fn_output;
2207 UCHAR tls_init_fn[64]; /* Note: Uses rip-relative address of tls_init_fn_output, don't separate */
2208 UCHAR entry_point_fn[16];
2209 struct
2210 {
2211 IMAGE_BASE_RELOCATION reloc;
2212 USHORT type_off[32];
2213 } rel;
2214 } data, *ptr;
2215 IMAGE_NT_HEADERS nt, *pnt;
2216 IMAGE_SECTION_HEADER section;
2217 SECTION_IMAGE_INFORMATION image;
2218 int test, tls_index_save, nb_rel;
2219#if defined(__i386__)
2220 static const UCHAR tls_init_code[] = {
2221 0xE8, 0x00, 0x00, 0x00, 0x00, /* call 1f */
2222 0x59, /* 1: pop ecx */
2223 0x8B, 0x49, 0xF7, /* mov ecx, [ecx - 9] ; mov ecx, [tls_init_fn_output] */
2224 0x8B, 0x54, 0x24, 0x08, /* mov edx, [esp + 8] */
2225 0x89, 0x11, /* mov [ecx], edx */
2226 0xB8, 0x01, 0x00, 0x00, 0x00, /* mov eax, 1 */
2227 0xC2, 0x0C, 0x00, /* ret 12 */
2228 };
2229 static const UCHAR entry_point_code[] = {
2230 0xB8, 0x01, 0x00, 0x00, 0x00, /* mov eax, 1 */
2231 0xC2, 0x0C, 0x00, /* ret 12 */
2232 };
2233#elif defined(__x86_64__)
2234 static const UCHAR tls_init_code[] = {
2235 0x48, 0x8B, 0x0D, 0xF1, 0xFF, 0xFF, 0xFF, /* mov rcx, [rip + tls_init_fn_output] */
2236 0x89, 0x11, /* mov [rcx], edx */
2237 0xB8, 0x01, 0x00, 0x00, 0x00, /* mov eax, 1 */
2238 0xC3, /* ret */
2239 };
2240 static const UCHAR entry_point_code[] = {
2241 0xB8, 0x01, 0x00, 0x00, 0x00, /* mov eax, 1 */
2242 0xC3, /* ret */
2243 };
2244#else
2245 static const UCHAR tls_init_code[] = { 0x00 };
2246 static const UCHAR entry_point_code[] = { 0x00 };
2247#endif
2248
2249 for (test = 0; test < 7; test++)
2250 {
2251#define DATA_RVA(ptr) (page_size + ((char *)(ptr) - (char *)&data))
2252#ifdef _WIN64
2253#define ADD_RELOC(field) data.rel.type_off[nb_rel++] = (IMAGE_REL_BASED_DIR64 << 12) + offsetof( struct imports, field )
2254#else
2255#define ADD_RELOC(field) data.rel.type_off[nb_rel++] = (IMAGE_REL_BASED_HIGHLOW << 12) + offsetof( struct imports, field )
2256#endif
2257 winetest_push_context( "%u", test );
2258 nt = nt_header_template;
2259 nt.FileHeader.NumberOfSections = 1;
2260 nt.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER);
2261 nt.FileHeader.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
2262 if (test != 2 && test != 5) nt.FileHeader.Characteristics |= IMAGE_FILE_DLL;
2263 nt.OptionalHeader.SectionAlignment = page_size;
2264 nt.OptionalHeader.FileAlignment = 0x200;
2265 nt.OptionalHeader.SizeOfImage = 2 * page_size;
2266 nt.OptionalHeader.SizeOfHeaders = nt.OptionalHeader.FileAlignment;
2267 nt.OptionalHeader.DllCharacteristics = IMAGE_DLLCHARACTERISTICS_NX_COMPAT;
2268 if (test < 6) nt.OptionalHeader.DllCharacteristics |= IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE;
2269 nt.OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
2270 memset( nt.OptionalHeader.DataDirectory, 0, sizeof(nt.OptionalHeader.DataDirectory) );
2271 nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size = sizeof(data.descr);
2272 nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = DATA_RVA(data.descr);
2273 nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].Size = sizeof(data.tls);
2274 nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress = DATA_RVA(&data.tls);
2275
2276 memset( &data, 0, sizeof(data) );
2277 data.descr[0].OriginalFirstThunk = DATA_RVA( data.original_thunks );
2278 data.descr[0].FirstThunk = DATA_RVA( data.thunks );
2279 data.descr[0].Name = DATA_RVA( data.module );
2280 strcpy( data.module, "kernel32.dll" );
2281 strcpy( data.function.name, "CreateEventA" );
2282 data.original_thunks[0].u1.AddressOfData = DATA_RVA( &data.function );
2283 data.thunks[0].u1.AddressOfData = 0xdeadbeef;
2284 nb_rel = 0;
2285
2286 data.tls.StartAddressOfRawData = nt.OptionalHeader.ImageBase + DATA_RVA( data.tls_data );
2287 ADD_RELOC( tls.StartAddressOfRawData );
2288 data.tls.EndAddressOfRawData = data.tls.StartAddressOfRawData + sizeof(data.tls_data);
2289 ADD_RELOC( tls.EndAddressOfRawData );
2290 data.tls.AddressOfIndex = nt.OptionalHeader.ImageBase + DATA_RVA( &data.tls_index );
2291 ADD_RELOC( tls.AddressOfIndex );
2292 strcpy( data.tls_data, "hello world" );
2293 data.tls_index = 9999;
2294 data.tls_index_hi = 9999;
2295
2296 if (test == 3 && sizeof(tls_init_code) > 1)
2297 {
2298 /* Windows doesn't consistently call tls init functions on dlls without entry points */
2299 assert(sizeof(tls_init_code) <= sizeof(data.tls_init_fn));
2300 assert(sizeof(entry_point_code) <= sizeof(data.entry_point_fn));
2301 memcpy(data.tls_init_fn, tls_init_code, sizeof(tls_init_code));
2302 memcpy(data.entry_point_fn, entry_point_code, sizeof(entry_point_code));
2303 tls_init_fn_output = 9999;
2304 data.tls_init_fn_output = &tls_init_fn_output;
2305 data.tls_init_fn_list[0] = nt.OptionalHeader.ImageBase + DATA_RVA(&data.tls_init_fn);
2306 ADD_RELOC( tls_init_fn_list[0] );
2307 data.tls.AddressOfCallBacks = nt.OptionalHeader.ImageBase + DATA_RVA(&data.tls_init_fn_list);
2308 ADD_RELOC( tls.AddressOfCallBacks );
2309 nt.OptionalHeader.AddressOfEntryPoint = DATA_RVA(&data.entry_point_fn);
2310 }
2311
2312 if (nb_rel % 2) nb_rel++;
2313 data.rel.reloc.VirtualAddress = nt.OptionalHeader.SectionAlignment;
2314 data.rel.reloc.SizeOfBlock = (char *)&data.rel.type_off[nb_rel] - (char *)&data.rel.reloc;
2315 nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = data.rel.reloc.SizeOfBlock;
2316 nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = DATA_RVA(&data.rel);
2317
2318 GetTempPathA(MAX_PATH, temp_path);
2319 GetTempFileNameA(temp_path, "ldr", 0, dll_name);
2320
2321 hfile = CreateFileA(dll_name, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, 0, 0);
2322 ok( hfile != INVALID_HANDLE_VALUE, "creation failed\n" );
2323
2324 memset( &section, 0, sizeof(section) );
2325 memcpy( section.Name, ".text", sizeof(".text") );
2326 section.PointerToRawData = nt.OptionalHeader.FileAlignment;
2327 section.VirtualAddress = nt.OptionalHeader.SectionAlignment;
2328 section.Misc.VirtualSize = sizeof(data);
2329 section.SizeOfRawData = sizeof(data);
2330 section.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
2331 if (test == 3) section.Characteristics |= IMAGE_SCN_MEM_EXECUTE;
2332
2333 WriteFile(hfile, &dos_header, sizeof(dos_header), &dummy, NULL);
2334 WriteFile(hfile, &nt, sizeof(nt), &dummy, NULL);
2335 WriteFile(hfile, &section, sizeof(section), &dummy, NULL);
2336
2337 SetFilePointer( hfile, section.PointerToRawData, NULL, SEEK_SET );
2338 WriteFile(hfile, &data, sizeof(data), &dummy, NULL);
2339
2340 CloseHandle( hfile );
2341
2342 switch (test)
2343 {
2344 case 0: /* normal load */
2345 mod = LoadLibraryA( dll_name );
2346 ok( mod != NULL, "failed to load err %lu\n", GetLastError() );
2347 if (!mod) break;
2348 ptr = (struct imports *)((char *)mod + page_size);
2349 expect = GetProcAddress( GetModuleHandleA( data.module ), data.function.name );
2350 ok( (void *)ptr->thunks[0].u1.Function == expect, "thunk %p instead of %p for %s.%s\n",
2351 (void *)ptr->thunks[0].u1.Function, expect, data.module, data.function.name );
2352#ifdef __REACTOS__
2353 ok( ptr->tls_index < 32 || broken(ptr->tls_index == 9999) /* WS03 */, "wrong tls index %d\n", ptr->tls_index );
2354 if (ptr->tls_index != 9999) {
2355#else
2356 ok( ptr->tls_index < 32, "wrong tls index %d\n", ptr->tls_index );
2357#endif
2358 str = ((char **)NtCurrentTeb()->ThreadLocalStoragePointer)[ptr->tls_index];
2359 ok( !strcmp( str, "hello world" ), "wrong tls data '%s' at %p\n", str, str );
2360 ok(ptr->tls_index_hi == 0, "TLS Index written as a short, high half: %d\n", ptr->tls_index_hi);
2361#ifdef __REACTOS__
2362 }
2363#endif
2364 check_tls_index(mod, ptr->tls_index != 9999);
2365 FreeLibrary( mod );
2366 break;
2367 case 1: /* load with DONT_RESOLVE_DLL_REFERENCES doesn't resolve imports */
2368 mod = LoadLibraryExA( dll_name, 0, DONT_RESOLVE_DLL_REFERENCES );
2369 ok( mod != NULL, "failed to load err %lu\n", GetLastError() );
2370 if (!mod) break;
2371 ptr = (struct imports *)((char *)mod + page_size);
2372 ok( ptr->thunks[0].u1.Function == 0xdeadbeef, "thunk resolved to %p for %s.%s\n",
2373 (void *)ptr->thunks[0].u1.Function, data.module, data.function.name );
2374 ok( ptr->tls_index == 9999, "wrong tls index %d\n", ptr->tls_index );
2375
2376 mod2 = LoadLibraryA( dll_name );
2377 ok( mod2 == mod, "loaded twice %p / %p\n", mod, mod2 );
2378 ok( ptr->thunks[0].u1.Function == 0xdeadbeef, "thunk resolved to %p for %s.%s\n",
2379 (void *)ptr->thunks[0].u1.Function, data.module, data.function.name );
2380 ok( ptr->tls_index == 9999, "wrong tls index %d\n", ptr->tls_index );
2381 check_tls_index(mod, ptr->tls_index != 9999);
2382 FreeLibrary( mod2 );
2383 FreeLibrary( mod );
2384 break;
2385 case 2: /* load without IMAGE_FILE_DLL doesn't resolve imports */
2386 mod = LoadLibraryA( dll_name );
2387 ok( mod != NULL, "failed to load err %lu\n", GetLastError() );
2388 if (!mod) break;
2389 ptr = (struct imports *)((char *)mod + page_size);
2390 ok( ptr->thunks[0].u1.Function == 0xdeadbeef, "thunk resolved to %p for %s.%s\n",
2391 (void *)ptr->thunks[0].u1.Function, data.module, data.function.name );
2392 ok( ptr->tls_index == 9999, "wrong tls index %d\n", ptr->tls_index );
2393 check_tls_index(mod, ptr->tls_index != 9999);
2394 FreeLibrary( mod );
2395 break;
2396 case 3: /* load with tls init function */
2397 mod = LoadLibraryA( dll_name );
2398 ok( mod != NULL, "failed to load err %lu\n", GetLastError() );
2399 if (!mod) break;
2400 ptr = (struct imports *)((char *)mod + page_size);
2401 tls_index_save = ptr->tls_index;
2402#ifdef __REACTOS__
2403 ok( ptr->tls_index < 32 || broken(ptr->tls_index == 9999) /* WS03 */, "wrong tls index %d\n", ptr->tls_index );
2404 if (sizeof(tls_init_code) > 1 && ptr->tls_index != 9999)
2405#else
2406 ok( ptr->tls_index < 32, "wrong tls index %d\n", ptr->tls_index );
2407 if (sizeof(tls_init_code) > 1)
2408#endif
2409 {
2410 str = ((char **)NtCurrentTeb()->ThreadLocalStoragePointer)[ptr->tls_index];
2411 ok( !strcmp( str, "hello world" ), "wrong tls data '%s' at %p\n", str, str );
2412 /* tls init function will write the reason to *tls_init_fn_output */
2413 ok( tls_init_fn_output == DLL_PROCESS_ATTACH,
2414 "tls init function didn't run or got wrong reason: %d instead of %d\n", tls_init_fn_output, DLL_PROCESS_ATTACH );
2415 tls_init_fn_output = 9999;
2416 WaitForSingleObject(CreateThread(NULL, 0, tls_thread_fn, (void*)(DWORD_PTR)ptr->tls_index, 0, NULL), INFINITE);
2417 ok( tls_init_fn_output == DLL_THREAD_DETACH,
2418 "tls init function didn't run or got wrong reason: %d instead of %d\n", tls_init_fn_output, DLL_THREAD_DETACH );
2419 }
2420 check_tls_index(mod, ptr->tls_index != 9999);
2421 tls_init_fn_output = 9999;
2422 FreeLibrary( mod );
2423 if (tls_index_save != 9999 && sizeof(tls_init_code) > 1)
2424 ok( tls_init_fn_output == DLL_PROCESS_DETACH,
2425 "tls init function didn't run or got wrong reason: %d instead of %d\n", tls_init_fn_output, DLL_PROCESS_DETACH );
2426 break;
2427 case 4: /* map with ntdll */
2428 case 5: /* map with ntdll, without IMAGE_FILE_DLL */
2429 case 6: /* map with ntdll, without IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE */
2430 hfile = CreateFileA(dll_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2431 ok( hfile != INVALID_HANDLE_VALUE, "CreateFile failed err %lu\n", GetLastError() );
2432 mapping = CreateFileMappingA( hfile, NULL, SEC_IMAGE | PAGE_READONLY, 0, 0, NULL );
2433 CloseHandle( hfile );
2434 if (test == 6 &&
2435 (nt_header_template.FileHeader.Machine == IMAGE_FILE_MACHINE_ARMNT ||
2436 nt_header_template.FileHeader.Machine == IMAGE_FILE_MACHINE_ARM64))
2437 {
2438 ok( !mapping, "CreateFileMappingA succeeded\n" );
2439 ok( GetLastError() == ERROR_BAD_EXE_FORMAT, "wrong error %lu\n", GetLastError() );
2440 break;
2441 }
2442 status = pNtQuerySection( mapping, SectionImageInformation, &image, sizeof(image), &size );
2443 ok( !status, "NtQuerySection failed %lx\n", status );
2444#ifdef __REACTOS__
2445 ok( test == 6 ? !image.ImageDynamicallyRelocated : image.ImageDynamicallyRelocated || broken(GetNTVersion() < _WIN32_WINNT_VISTA),
2446#else
2447 ok( test == 6 ? !image.ImageDynamicallyRelocated : image.ImageDynamicallyRelocated,
2448#endif
2449 "image flags %x\n", image.ImageFlags);
2450 ok( !image.ImageContainsCode, "contains code %x\n", image.ImageContainsCode);
2451 ok( mapping != 0, "CreateFileMappingA failed err %lu\n", GetLastError() );
2452 /* make sure that the address is not available */
2453 tmp = VirtualAlloc( (void *)nt.OptionalHeader.ImageBase, 0x10000,
2454 MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE );
2455 mod = NULL;
2456 size = 0;
2457 offset.QuadPart = 0;
2458 status = pNtMapViewOfSection( mapping, GetCurrentProcess(), (void **)&mod, 0, 0, &offset,
2459 &size, 1 /* ViewShare */, 0, PAGE_READONLY );
2460 todo_wine_if (test == 5)
2461#ifdef __REACTOS__
2462 ok( status == (test == 6 ? STATUS_IMAGE_NOT_AT_BASE : STATUS_SUCCESS) || broken(GetNTVersion() < _WIN32_WINNT_VISTA),
2463#else
2464 ok( status == (test == 6 ? STATUS_IMAGE_NOT_AT_BASE : STATUS_SUCCESS),
2465#endif
2466 "NtMapViewOfSection failed %lx\n", status );
2467 ok( mod != (void *)nt.OptionalHeader.ImageBase, "loaded at image base %p\n", mod );
2468 pnt = pRtlImageNtHeader( mod );
2469 ptr = (void *)((char *)mod + page_size);
2470 if (test == 6)
2471 {
2472 ok( (void *)pnt->OptionalHeader.ImageBase != mod, "not relocated from %p\n", mod );
2473 ok( (char *)ptr->tls.StartAddressOfRawData == (char *)nt.OptionalHeader.ImageBase + DATA_RVA( data.tls_data ),
2474 "tls relocated %p / %p\n", (void *)ptr->tls.StartAddressOfRawData,
2475 (char *)nt.OptionalHeader.ImageBase + DATA_RVA( data.tls_data ));
2476 }
2477 else todo_wine_if (test == 5)
2478 {
2479#ifdef __REACTOS__
2480 if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
2481#endif
2482 ok( (void *)pnt->OptionalHeader.ImageBase == mod, "not at base %p / %p\n",
2483 (void *)pnt->OptionalHeader.ImageBase, mod );
2484 ok( (char *)ptr->tls.StartAddressOfRawData == (char *)mod + DATA_RVA( data.tls_data ),
2485 "tls not relocated %p / %p\n", (void *)ptr->tls.StartAddressOfRawData,
2486 (char *)mod + DATA_RVA( data.tls_data ));
2487#ifdef __REACTOS__
2488 }
2489#endif
2490 }
2491 UnmapViewOfFile( mod );
2492 CloseHandle( mapping );
2493 if (tmp) VirtualFree( tmp, 0, MEM_RELEASE );
2494 break;
2495 }
2496 DeleteFileA( dll_name );
2497 winetest_pop_context();
2498#undef DATA_RVA
2499 }
2500}
2501
2502static HANDLE gen_forward_chain_testdll( char testdll_path[MAX_PATH],
2503 const char source_dll[MAX_PATH],
2504 BOOL is_export, BOOL is_import,
2505 DWORD *exp_func_base_rva,
2506 DWORD *imp_thunk_base_rva )
2507{
2508 DWORD text_rva = page_size; /* assumes that the PE/COFF headers fit in a page */
2509 DWORD text_size = page_size;
2510 DWORD edata_rva = text_rva + text_size;
2511 DWORD edata_size = page_size;
2512 DWORD idata_rva = edata_rva + text_size;
2513 DWORD idata_size = page_size;
2514 DWORD eof_rva = idata_rva + edata_size;
2515 const IMAGE_SECTION_HEADER sections[3] = {
2516 {
2517 .Name = ".text",
2518 .Misc = { .VirtualSize = text_size },
2519 .VirtualAddress = text_rva,
2520 .SizeOfRawData = text_size,
2521 .PointerToRawData = text_rva,
2522 .Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE,
2523 },
2524 {
2525 .Name = ".edata",
2526 .Misc = { .VirtualSize = edata_size },
2527 .VirtualAddress = edata_rva,
2528 .SizeOfRawData = edata_size,
2529 .PointerToRawData = edata_rva,
2530 .Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ,
2531 },
2532 {
2533 .Name = ".idata",
2534 .Misc = { .VirtualSize = edata_size },
2535 .VirtualAddress = idata_rva,
2536 .SizeOfRawData = idata_size,
2537 .PointerToRawData = idata_rva,
2538 .Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE,
2539 },
2540 };
2541 struct expdesc
2542 {
2543 const IMAGE_EXPORT_DIRECTORY dir;
2544
2545 DWORD functions[2];
2546
2547 const DWORD names[2];
2548 const WORD name_ords[2];
2549 const char str_forward_test_func[32];
2550 const char str_forward_test_func2[32];
2551
2552 char dll_name[MAX_PATH]; /* dynamically populated */
2553 char strpool[2][MAX_PATH + 16]; /* for names of export forwarders */
2554 } expdesc = {
2555 .dir = {
2556 .Characteristics = 0,
2557 .TimeDateStamp = 0x12345678,
2558 .Name = edata_rva + offsetof(struct expdesc, dll_name),
2559 .Base = 1,
2560 .NumberOfFunctions = ARRAY_SIZE(expdesc.functions),
2561 .NumberOfNames = ARRAY_SIZE(expdesc.names),
2562 .AddressOfFunctions = edata_rva + offsetof(struct expdesc, functions),
2563 .AddressOfNames = edata_rva + offsetof(struct expdesc, names),
2564 .AddressOfNameOrdinals = edata_rva + offsetof(struct expdesc, name_ords),
2565 },
2566 .functions = {
2567 text_rva + 0x4, /* may be overwritten */
2568 text_rva + 0x8, /* may be overwritten */
2569 },
2570 .names = {
2571 edata_rva + offsetof(struct expdesc, str_forward_test_func),
2572 edata_rva + offsetof(struct expdesc, str_forward_test_func2),
2573 },
2574 .name_ords = {
2575 0,
2576 1,
2577 },
2578 .str_forward_test_func = "forward_test_func",
2579 .str_forward_test_func2 = "forward_test_func2",
2580 };
2581 struct impdesc
2582 {
2583 const IMAGE_IMPORT_DESCRIPTOR descr[2];
2584 const IMAGE_THUNK_DATA original_thunks[3];
2585 const IMAGE_THUNK_DATA thunks[3];
2586 const struct { WORD hint; char name[32]; } impname_forward_test_func;
2587
2588 char module[MAX_PATH]; /* dynamically populated */
2589 } impdesc = {
2590 .descr = {
2591 {
2592 .OriginalFirstThunk = idata_rva + offsetof(struct impdesc, original_thunks),
2593 .TimeDateStamp = 0,
2594 .ForwarderChain = -1,
2595 .Name = idata_rva + offsetof(struct impdesc, module),
2596 .FirstThunk = idata_rva + offsetof(struct impdesc, thunks),
2597 },
2598 {{ 0 }},
2599 },
2600 .original_thunks = {
2601 {{ idata_rva + offsetof(struct impdesc, impname_forward_test_func) }},
2602 {{ IMAGE_ORDINAL_FLAG | 2 }},
2603 {{ 0 }},
2604 },
2605 .thunks = {
2606 {{ idata_rva + offsetof(struct impdesc, impname_forward_test_func) }},
2607 {{ IMAGE_ORDINAL_FLAG | 2 }},
2608 {{ 0 }},
2609 },
2610 .impname_forward_test_func = { 0, "forward_test_func" },
2611 };
2612 IMAGE_NT_HEADERS nt_header;
2613 char temp_path[MAX_PATH];
2614 HANDLE file, file_w;
2615 LARGE_INTEGER qpc;
2616 DWORD outlen;
2617 BOOL ret;
2618 int res;
2619
2620 QueryPerformanceCounter( &qpc );
2621 res = snprintf( expdesc.dll_name, ARRAY_SIZE(expdesc.dll_name),
2622 "ldr%05lx.dll", qpc.LowPart & 0xfffffUL );
2623 ok( res > 0 && res < ARRAY_SIZE(expdesc.dll_name), "snprintf failed\n" );
2624
2625 if (source_dll)
2626 {
2627 const char *export_names[2] = {
2628 "forward_test_func",
2629 "#2",
2630 };
2631 const char *backslash = strrchr( source_dll, '\\' );
2632 const char *dllname = backslash ? backslash + 1 : source_dll;
2633 const char *dot = strrchr( dllname, '.' );
2634 size_t ext_start = dot ? dot - dllname : strlen(dllname);
2635 size_t i;
2636
2637 res = snprintf( impdesc.module, ARRAY_SIZE(impdesc.module), "%s", dllname );
2638 ok( res > 0 && res < ARRAY_SIZE(impdesc.module), "snprintf() failed\n" );
2639
2640 for (i = 0; i < ARRAY_SIZE(export_names); i++)
2641 {
2642 char *buf;
2643 size_t buf_size;
2644
2645 assert( i < ARRAY_SIZE(expdesc.strpool) );
2646 buf = expdesc.strpool[i];
2647 buf_size = ARRAY_SIZE(expdesc.strpool[i]);
2648
2649 assert( ext_start < buf_size );
2650 memcpy( buf, dllname, ext_start );
2651 buf += ext_start;
2652 buf_size -= ext_start;
2653
2654 res = snprintf( buf, buf_size, ".%s", export_names[i] );
2655 ok( res > 0 && res < buf_size, "snprintf() failed\n" );
2656
2657 assert( i < ARRAY_SIZE(expdesc.functions) );
2658 expdesc.functions[i] = edata_rva + (expdesc.strpool[i] - (char *)&expdesc);
2659 }
2660 }
2661
2662 nt_header = nt_header_template;
2663 nt_header.FileHeader.TimeDateStamp = 0x12345678;
2664 nt_header.FileHeader.NumberOfSections = ARRAY_SIZE(sections);
2665 nt_header.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER);
2666
2667 nt_header.OptionalHeader.SizeOfCode = text_size;
2668 nt_header.OptionalHeader.SectionAlignment = page_size;
2669 nt_header.OptionalHeader.FileAlignment = page_size;
2670 nt_header.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt_header) + sizeof(sections);
2671 nt_header.OptionalHeader.SizeOfImage = eof_rva;
2672 if (is_export)
2673 {
2674 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress = edata_rva;
2675 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size = sizeof(expdesc);
2676 }
2677 /* Always have an import descriptor (even if empty) just like a real DLL */
2678 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = idata_rva;
2679 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size = is_import ? sizeof(impdesc) : sizeof(IMAGE_IMPORT_DESCRIPTOR);
2680
2681 ok( nt_header.OptionalHeader.SizeOfHeaders <= text_rva,
2682 "headers (size %#lx) should not overlap with text area (RVA %#lx)\n",
2683 nt_header.OptionalHeader.SizeOfHeaders, text_rva );
2684
2685 outlen = GetTempPathA( ARRAY_SIZE(temp_path), temp_path );
2686 ok( outlen > 0 && outlen < ARRAY_SIZE(temp_path), "GetTempPathA() err=%lu\n", GetLastError() );
2687
2688 res = snprintf( testdll_path, MAX_PATH, "%s\\%s", temp_path, expdesc.dll_name );
2689 ok( res > 0 && res < MAX_PATH, "snprintf failed\n" );
2690
2691 /* Open file handle that will be deleted on close or process termination */
2692 file = CreateFileA( testdll_path,
2693 DELETE,
2694 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2695 NULL,
2696 CREATE_NEW,
2697 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,
2698 NULL );
2699 ok( file != INVALID_HANDLE_VALUE, "CreateFile(%s) for delete returned error %lu\n",
2700 wine_dbgstr_a( testdll_path ), GetLastError() );
2701
2702 /* Open file again with write access */
2703 file_w = CreateFileA( testdll_path,
2704 GENERIC_WRITE,
2705 FILE_SHARE_READ | FILE_SHARE_DELETE,
2706 NULL,
2707 OPEN_EXISTING,
2708 FILE_ATTRIBUTE_NORMAL,
2709 NULL );
2710 ok( file_w != INVALID_HANDLE_VALUE, "CreateFile(%s) for write returned error %lu\n",
2711 wine_dbgstr_a( testdll_path ), GetLastError() );
2712
2713 ret = WriteFile( file_w, &dos_header, sizeof(dos_header), &outlen, NULL );
2714 ok( ret && outlen == sizeof(dos_header), "write dos_header: err=%lu outlen=%lu\n", GetLastError(), outlen );
2715
2716 ret = WriteFile( file_w, &nt_header, sizeof(nt_header), &outlen, NULL );
2717 ok( ret && outlen == sizeof(nt_header), "write nt_header: err=%lu outlen=%lu\n", GetLastError(), outlen );
2718
2719 ret = WriteFile( file_w, sections, sizeof(sections), &outlen, NULL );
2720 ok( ret && outlen == sizeof(sections), "write sections: err=%lu outlen=%lu\n", GetLastError(), outlen );
2721
2722 if (is_export)
2723 {
2724 SetFilePointer( file_w, edata_rva, NULL, FILE_BEGIN );
2725 ret = WriteFile( file_w, &expdesc, sizeof(expdesc), &outlen, NULL );
2726 ok( ret && outlen == sizeof(expdesc), "write expdesc: err=%lu outlen=%lu\n", GetLastError(), outlen );
2727 }
2728
2729 if (is_import)
2730 {
2731 SetFilePointer( file_w, idata_rva, NULL, FILE_BEGIN );
2732 ret = WriteFile( file_w, &impdesc, sizeof(impdesc), &outlen, NULL );
2733 ok( ret && outlen == sizeof(impdesc), "write impdesc: err=%lu outlen=%lu\n", GetLastError(), outlen );
2734 }
2735
2736 ret = SetFilePointer( file_w, eof_rva, NULL, FILE_BEGIN );
2737 ok( ret, "%lu\n", GetLastError() );
2738 ret = SetEndOfFile( file_w );
2739 ok( ret, "%lu\n", GetLastError() );
2740
2741 ret = CloseHandle( file_w );
2742 ok( ret, "%lu\n", GetLastError() );
2743
2744 if (exp_func_base_rva)
2745 {
2746 *exp_func_base_rva = is_export ? edata_rva + ((char *)&expdesc.functions - (char *)&expdesc) : 0;
2747 }
2748
2749 if (imp_thunk_base_rva)
2750 {
2751 *imp_thunk_base_rva = is_import ? idata_rva + ((char *)&impdesc.thunks - (char *)&impdesc) : 0;
2752 }
2753
2754 return file;
2755}
2756
2757static void subtest_export_forwarder_dep_chain( size_t num_chained_export_modules,
2758 size_t exporter_index,
2759 BOOL test_static_import )
2760{
2761 size_t num_modules = num_chained_export_modules + !!test_static_import;
2762 size_t importer_index = test_static_import ? num_modules - 1 : 0;
2763 DWORD imp_thunk_base_rva, exp_func_base_rva;
2764 size_t ultimate_depender_index = 0; /* latest module depending on modules earlier in chain */
2765 char temp_paths[4][MAX_PATH];
2766 HANDLE temp_files[4];
2767 UINT_PTR exports[2];
2768 HMODULE modules[4];
2769 BOOL res;
2770 size_t i;
2771
2772 assert(exporter_index < num_chained_export_modules);
2773 assert(num_modules > 1);
2774 assert(num_modules <= ARRAY_SIZE(temp_paths));
2775 assert(num_modules <= ARRAY_SIZE(temp_files));
2776 assert(num_modules <= ARRAY_SIZE(modules));
2777
2778 if (winetest_debug > 1)
2779 trace( "Generate a chain of test DLL fixtures\n" );
2780
2781 for (i = 0; i < num_modules; i++)
2782 {
2783 temp_files[i] = gen_forward_chain_testdll( temp_paths[i],
2784 i >= 1 ? temp_paths[i - 1] : NULL,
2785 i < num_chained_export_modules,
2786 importer_index && i == importer_index,
2787 i == 0 ? &exp_func_base_rva : NULL,
2788 i == importer_index ? &imp_thunk_base_rva : NULL );
2789 }
2790
2791 if (winetest_debug > 1)
2792 trace( "Load the entire test DLL chain\n" );
2793
2794 for (i = 0; i < num_modules; i++)
2795 {
2796 HMODULE module;
2797
2798 ok( !GetModuleHandleA( temp_paths[i] ), "%s already loaded\n",
2799 wine_dbgstr_a( temp_paths[i] ) );
2800
2801 modules[i] = LoadLibraryA( temp_paths[i] );
2802 ok( !!modules[i], "LoadLibraryA(temp_paths[%Iu] = %s) err=%lu\n",
2803 i, wine_dbgstr_a( temp_paths[i] ), GetLastError() );
2804
2805 if (i == importer_index)
2806 {
2807 /* Statically importing export forwarder introduces a load-time dependency */
2808 ultimate_depender_index = max( ultimate_depender_index, importer_index );
2809 }
2810
2811 module = GetModuleHandleA( temp_paths[i] );
2812 ok( module == modules[i], "modules[%Iu] expected %p, got %p err=%lu\n",
2813 i, modules[i], module, GetLastError() );
2814 }
2815
2816 if (winetest_debug > 1)
2817 trace( "Get address of exported functions from the source module\n" );
2818
2819 for (i = 0; i < ARRAY_SIZE(exports); i++)
2820 {
2821 char *mod_base = (char *)modules[0]; /* source (non-forward) DLL */
2822 exports[i] = (UINT_PTR)(mod_base + ((DWORD *)(mod_base + exp_func_base_rva))[i]);
2823 }
2824
2825 if (winetest_debug > 1)
2826 trace( "Check import address table of the importer DLL, if any\n" );
2827
2828 if (importer_index)
2829 {
2830 UINT_PTR *imp_thunk_base = (UINT_PTR *)((char *)modules[importer_index] + imp_thunk_base_rva);
2831 for (i = 0; i < ARRAY_SIZE(exports); i++)
2832 {
2833 ok( imp_thunk_base[i] == exports[i], "import thunk mismatch [%Iu]: (%#Ix, %#Ix)\n",
2834 i, imp_thunk_base[i], exports[i] );
2835 }
2836 }
2837
2838 if (winetest_debug > 1)
2839 trace( "Call GetProcAddress() on the exporter DLL, if any\n" );
2840
2841 if (exporter_index)
2842 {
2843 UINT_PTR proc;
2844
2845 proc = (UINT_PTR)GetProcAddress( modules[exporter_index], "forward_test_func" );
2846 ok( proc == exports[0], "GetProcAddress mismatch [0]: (%#Ix, %#Ix)\n", proc, exports[0] );
2847
2848 proc = (UINT_PTR)GetProcAddress( modules[exporter_index], (LPSTR)2 );
2849 ok( proc == exports[1], "GetProcAddress mismatch [1]: (%#Ix, %#Ix)\n", proc, exports[1] );
2850
2851 /* Dynamically importing export forwarder introduces a runtime dependency */
2852 ultimate_depender_index = max( ultimate_depender_index, exporter_index );
2853 }
2854
2855 if (winetest_debug > 1)
2856 trace( "Unreference modules except the ultimate dependant DLL\n" );
2857
2858 for (i = 0; i < ultimate_depender_index; i++)
2859 {
2860 HMODULE module;
2861
2862 res = FreeLibrary( modules[i] );
2863 ok( res, "FreeLibrary(modules[%Iu]) err=%lu\n", i, GetLastError() );
2864
2865 /* FreeLibrary() should *not* unload the DLL immediately */
2866 module = GetModuleHandleA( temp_paths[i] );
2867 todo_wine_if(i < ultimate_depender_index && i + 1 != importer_index)
2868 ok( module == modules[i], "modules[%Iu] expected %p, got %p (unloaded?) err=%lu\n",
2869 i, modules[i], module, GetLastError() );
2870 }
2871
2872 if (winetest_debug > 1)
2873 trace( "The ultimate dependant DLL should keep other DLLs from being unloaded\n" );
2874
2875 for (i = 0; i < num_modules; i++)
2876 {
2877 HMODULE module = GetModuleHandleA( temp_paths[i] );
2878
2879 todo_wine_if(i < ultimate_depender_index && i + 1 != importer_index)
2880 ok( module == modules[i], "modules[%Iu] expected %p, got %p (unloaded?) err=%lu\n",
2881 i, modules[i], module, GetLastError() );
2882 }
2883
2884 if (winetest_debug > 1)
2885 trace( "Unreference the remaining modules (including the dependant DLL)\n" );
2886
2887 for (i = ultimate_depender_index; i < num_modules; i++)
2888 {
2889 res = FreeLibrary( modules[i] );
2890 ok( res, "FreeLibrary(modules[%Iu]) err=%lu\n", i, GetLastError() );
2891
2892 /* FreeLibrary() should unload the DLL immediately */
2893 ok( !GetModuleHandleA( temp_paths[i] ), "modules[%Iu] should not be kept loaded (2)\n", i );
2894 }
2895
2896 if (winetest_debug > 1)
2897 trace( "All modules should be unloaded; the unloading process should not reload any DLL\n" );
2898
2899#ifdef __REACTOS__
2900 if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
2901#endif
2902 for (i = 0; i < num_modules; i++)
2903 {
2904 ok( !GetModuleHandleA( temp_paths[i] ), "modules[%Iu] should not be kept loaded (3)\n", i );
2905 }
2906#ifdef __REACTOS__
2907 }
2908#endif
2909
2910 if (winetest_debug > 1)
2911 trace( "Close and delete temp files\n" );
2912
2913 for (i = 0; i < num_modules; i++)
2914 {
2915 /* handles should be delete-on-close */
2916 CloseHandle( temp_files[i] );
2917 }
2918}
2919
2920static void test_export_forwarder_dep_chain(void)
2921{
2922 winetest_push_context( "no import" );
2923 /* export forwarder does not introduce a dependency on its own */
2924 subtest_export_forwarder_dep_chain( 2, 0, FALSE );
2925 winetest_pop_context();
2926
2927 winetest_push_context( "static import of export forwarder" );
2928 subtest_export_forwarder_dep_chain( 2, 0, TRUE );
2929 winetest_pop_context();
2930
2931 winetest_push_context( "static import of chained export forwarder" );
2932 subtest_export_forwarder_dep_chain( 3, 0, TRUE );
2933 winetest_pop_context();
2934
2935 winetest_push_context( "dynamic import of export forwarder" );
2936 subtest_export_forwarder_dep_chain( 2, 1, FALSE );
2937 winetest_pop_context();
2938
2939 winetest_push_context( "dynamic import of chained export forwarder" );
2940 subtest_export_forwarder_dep_chain( 3, 2, FALSE );
2941 winetest_pop_context();
2942}
2943
2944#define MAX_COUNT 10
2945static HANDLE attached_thread[MAX_COUNT];
2946static DWORD attached_thread_count;
2947static HANDLE event, mutex, semaphore;
2948static HANDLE stop_event, loader_lock_event, peb_lock_event, heap_lock_event, cs_lock_event, ack_event;
2949static CRITICAL_SECTION cs_lock;
2950static int test_dll_phase, inside_loader_lock, inside_peb_lock, inside_heap_lock, inside_cs_lock;
2951static LONG fls_callback_count;
2952
2953static DWORD WINAPI mutex_thread_proc(void *param)
2954{
2955 HANDLE wait_list[5];
2956 DWORD ret;
2957
2958 ret = WaitForSingleObject(mutex, 0);
2959 ok(ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %#lx\n", ret);
2960
2961 SetEvent(param);
2962
2963 wait_list[0] = stop_event;
2964 wait_list[1] = loader_lock_event;
2965 wait_list[2] = peb_lock_event;
2966 wait_list[3] = heap_lock_event;
2967 wait_list[4] = cs_lock_event;
2968
2969 trace("%04lx: mutex_thread_proc: starting\n", GetCurrentThreadId());
2970 while (1)
2971 {
2972 ret = WaitForMultipleObjects(ARRAY_SIZE(wait_list), wait_list, FALSE, 50);
2973 if (ret == WAIT_OBJECT_0) break;
2974 else if (ret == WAIT_OBJECT_0 + 1)
2975 {
2976 ULONG_PTR loader_lock_magic;
2977 trace("%04lx: mutex_thread_proc: Entering loader lock\n", GetCurrentThreadId());
2978 ret = pLdrLockLoaderLock(0, NULL, &loader_lock_magic);
2979 ok(!ret, "LdrLockLoaderLock error %#lx\n", ret);
2980 inside_loader_lock++;
2981 SetEvent(ack_event);
2982 }
2983 else if (ret == WAIT_OBJECT_0 + 2)
2984 {
2985 trace("%04lx: mutex_thread_proc: Entering PEB lock\n", GetCurrentThreadId());
2986 pRtlAcquirePebLock();
2987 inside_peb_lock++;
2988 SetEvent(ack_event);
2989 }
2990 else if (ret == WAIT_OBJECT_0 + 3)
2991 {
2992 trace("%04lx: mutex_thread_proc: Entering heap lock\n", GetCurrentThreadId());
2993 HeapLock(GetProcessHeap());
2994 inside_heap_lock++;
2995 SetEvent(ack_event);
2996 }
2997 else if (ret == WAIT_OBJECT_0 + 4)
2998 {
2999 trace("%04lx: mutex_thread_proc: Entering CS lock\n", GetCurrentThreadId());
3000 EnterCriticalSection(&cs_lock);
3001 inside_cs_lock++;
3002 SetEvent(ack_event);
3003 }
3004 }
3005
3006 trace("%04lx: mutex_thread_proc: exiting\n", GetCurrentThreadId());
3007 return 196;
3008}
3009
3010static DWORD WINAPI semaphore_thread_proc(void *param)
3011{
3012 DWORD ret;
3013
3014 ret = WaitForSingleObject(semaphore, 0);
3015 ok(ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %#lx\n", ret);
3016
3017 SetEvent(param);
3018
3019 while (1)
3020 {
3021 if (winetest_debug > 1)
3022 trace("%04lx: semaphore_thread_proc: still alive\n", GetCurrentThreadId());
3023 if (WaitForSingleObject(stop_event, 50) != WAIT_TIMEOUT) break;
3024 }
3025
3026 trace("%04lx: semaphore_thread_proc: exiting\n", GetCurrentThreadId());
3027 return 196;
3028}
3029
3030static DWORD WINAPI noop_thread_proc(void *param)
3031{
3032 if (param)
3033 {
3034 LONG *noop_thread_started = param;
3035 InterlockedIncrement(noop_thread_started);
3036 }
3037
3038 trace("%04lx: noop_thread_proc: exiting\n", GetCurrentThreadId());
3039 return 195;
3040}
3041
3042static VOID WINAPI fls_callback(PVOID lpFlsData)
3043{
3044 ok(lpFlsData == (void*) 0x31415, "lpFlsData is %p, expected %p\n", lpFlsData, (void*) 0x31415);
3045 InterlockedIncrement(&fls_callback_count);
3046}
3047
3048static LIST_ENTRY *fls_list_head;
3049
3050static unsigned int check_linked_list(const LIST_ENTRY *le, const LIST_ENTRY *search_entry, unsigned int *index_found)
3051{
3052 unsigned int count = 0;
3053 LIST_ENTRY *entry;
3054
3055 *index_found = ~0;
3056
3057 for (entry = le->Flink; entry != le; entry = entry->Flink)
3058 {
3059 if (entry == search_entry)
3060 {
3061 ok(*index_found == ~0, "Duplicate list entry.\n");
3062 *index_found = count;
3063 }
3064 ++count;
3065 }
3066 return count;
3067}
3068
3069static BOOL WINAPI dll_entry_point(HINSTANCE hinst, DWORD reason, LPVOID param)
3070{
3071 static LONG noop_thread_started;
3072 static DWORD fls_index = FLS_OUT_OF_INDEXES, fls_index2 = FLS_OUT_OF_INDEXES;
3073 static int fls_count = 0;
3074 static int thread_detach_count = 0;
3075 static int thread_count;
3076 DWORD ret;
3077
3078 ok(!inside_loader_lock, "inside_loader_lock should not be set\n");
3079 ok(!inside_peb_lock, "inside_peb_lock should not be set\n");
3080
3081 switch (reason)
3082 {
3083 case DLL_PROCESS_ATTACH:
3084 trace("dll: %p, DLL_PROCESS_ATTACH, %p\n", hinst, param);
3085
3086 ret = pRtlDllShutdownInProgress();
3087 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3088
3089 /* Set up the FLS slot, if FLS is available */
3090 if (pFlsGetValue)
3091 {
3092 void* value;
3093 BOOL bret;
3094 ret = pFlsAlloc(&fls_callback);
3095 ok(ret != FLS_OUT_OF_INDEXES, "FlsAlloc returned %ld\n", ret);
3096 fls_index = ret;
3097 SetLastError(0xdeadbeef);
3098 value = pFlsGetValue(fls_index);
3099 ok(!value, "FlsGetValue returned %p, expected NULL\n", value);
3100 ok(GetLastError() == ERROR_SUCCESS, "FlsGetValue failed with error %lu\n", GetLastError());
3101 bret = pFlsSetValue(fls_index, (void*) 0x31415);
3102 ok(bret, "FlsSetValue failed\n");
3103 fls_count++;
3104
3105 fls_index2 = pFlsAlloc(&fls_callback);
3106 ok(fls_index2 != FLS_OUT_OF_INDEXES, "FlsAlloc returned %ld\n", ret);
3107 }
3108 ++thread_count;
3109 break;
3110 case DLL_PROCESS_DETACH:
3111 {
3112 DWORD code, expected_code, i;
3113 HANDLE handle, process;
3114 void *addr;
3115 SIZE_T size;
3116 LARGE_INTEGER offset;
3117 DEBUG_EVENT de;
3118
3119 trace("dll: %p, DLL_PROCESS_DETACH, %p\n", hinst, param);
3120
3121 if (test_dll_phase == 4 || test_dll_phase == 5)
3122 {
3123 ok(0, "dll_entry_point(DLL_PROCESS_DETACH) should not be called\n");
3124 break;
3125 }
3126
3127 /* The process should already deadlock at this point */
3128 if (test_dll_phase == 6)
3129 {
3130 /* In reality, code below never gets executed, probably some other
3131 * code tries to access process heap and deadlocks earlier, even XP
3132 * doesn't call the DLL entry point on process detach either.
3133 */
3134 HeapLock(GetProcessHeap());
3135 todo_wine
3136 ok(0, "dll_entry_point: process should already deadlock\n");
3137 break;
3138 }
3139 else if (test_dll_phase == 7)
3140 {
3141 EnterCriticalSection(&cs_lock);
3142 }
3143
3144 if (test_dll_phase == 0 || test_dll_phase == 1 || test_dll_phase == 3 || test_dll_phase == 7)
3145 ok(param != NULL, "dll: param %p\n", param);
3146 else
3147 ok(!param, "dll: param %p\n", param);
3148
3149 if (test_dll_phase == 0 || test_dll_phase == 1) expected_code = 195;
3150 else if (test_dll_phase == 3) expected_code = 196;
3151 else if (test_dll_phase == 7) expected_code = 199;
3152 else expected_code = STILL_ACTIVE;
3153
3154 ret = pRtlDllShutdownInProgress();
3155 if (test_dll_phase == 0 || test_dll_phase == 1 || test_dll_phase == 3)
3156 {
3157 ok(ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3158 }
3159 else
3160 {
3161 /* FIXME: remove once Wine is fixed */
3162 todo_wine_if (!(expected_code == STILL_ACTIVE || expected_code == 196))
3163#ifdef __REACTOS__
3164 ok(!ret || broken(GetNTVersion() < _WIN32_WINNT_VISTA), "RtlDllShutdownInProgress returned %ld\n", ret);
3165#else
3166 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3167#endif
3168 }
3169
3170 /* In the case that the process is terminating, FLS slots should still be accessible, but
3171 * the callback should be already run for this thread and the contents already NULL.
3172 */
3173 if (param && pFlsGetValue)
3174 {
3175 void* value;
3176 SetLastError(0xdeadbeef);
3177 value = pFlsGetValue(fls_index);
3178#ifdef __REACTOS__
3179 ok(value == NULL || broken(value == (void*)0x31415) /* WS03 */, "FlsGetValue returned %p, expected NULL\n", value);
3180#else
3181 ok(value == NULL, "FlsGetValue returned %p, expected NULL\n", value);
3182#endif
3183 ok(GetLastError() == ERROR_SUCCESS, "FlsGetValue failed with error %lu\n", GetLastError());
3184#ifdef __REACTOS__
3185 ok(fls_callback_count == thread_detach_count + 1 || broken(GetNTVersion() < _WIN32_WINNT_VISTA),
3186 "wrong FLS callback count %ld, expected %d\n", fls_callback_count, thread_detach_count + 1);
3187#else
3188 ok(fls_callback_count == thread_detach_count + 1,
3189 "wrong FLS callback count %ld, expected %d\n", fls_callback_count, thread_detach_count + 1);
3190#endif
3191 }
3192 if (pFlsFree)
3193 {
3194 BOOL ret;
3195 /* Call FlsFree now and run the remaining callbacks from uncleanly terminated threads */
3196 ret = pFlsFree(fls_index);
3197 ok(ret, "FlsFree failed with error %lu\n", GetLastError());
3198 fls_index = FLS_OUT_OF_INDEXES;
3199#ifdef __REACTOS__
3200 if (GetNTVersion() >= _WIN32_WINNT_VISTA)
3201#endif
3202 ok(fls_callback_count == fls_count,
3203 "wrong FLS callback count %ld, expected %d\n", fls_callback_count, fls_count);
3204 }
3205
3206 ok(attached_thread_count >= 2, "attached thread count should be >= 2\n");
3207
3208 for (i = 0; i < attached_thread_count; i++)
3209 {
3210 /* Calling GetExitCodeThread() without waiting for thread termination
3211 * leads to different results due to a race condition.
3212 */
3213 if (expected_code != STILL_ACTIVE)
3214 {
3215 ret = WaitForSingleObject(attached_thread[i], 1000);
3216 ok(ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %#lx\n", ret);
3217 }
3218 ret = GetExitCodeThread(attached_thread[i], &code);
3219 trace("dll: GetExitCodeThread(%lu) => %ld,%lu\n", i, ret, code);
3220 ok(ret == 1, "GetExitCodeThread returned %ld, expected 1\n", ret);
3221 ok(code == expected_code, "expected thread exit code %lu, got %lu\n", expected_code, code);
3222 }
3223
3224 ret = WaitForSingleObject(event, 0);
3225 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3226
3227 ret = WaitForSingleObject(mutex, 0);
3228 if (expected_code == STILL_ACTIVE)
3229 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3230 else
3231 ok(ret == WAIT_ABANDONED, "expected WAIT_ABANDONED, got %#lx\n", ret);
3232
3233 /* semaphore is not abandoned on thread termination */
3234 ret = WaitForSingleObject(semaphore, 0);
3235 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3236
3237 if (expected_code == STILL_ACTIVE)
3238 {
3239 ret = WaitForSingleObject(attached_thread[0], 0);
3240 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3241 ret = WaitForSingleObject(attached_thread[1], 0);
3242 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3243 }
3244 else
3245 {
3246 ret = WaitForSingleObject(attached_thread[0], 0);
3247 ok(ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %#lx\n", ret);
3248 ret = WaitForSingleObject(attached_thread[1], 0);
3249 ok(ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %#lx\n", ret);
3250 }
3251
3252 /* win7 doesn't allow creating a thread during process shutdown but
3253 * earlier Windows versions allow it.
3254 */
3255 noop_thread_started = 0;
3256 SetLastError(0xdeadbeef);
3257 handle = CreateThread(NULL, 0, noop_thread_proc, &noop_thread_started, 0, &ret);
3258 if (param)
3259 {
3260#ifdef __REACTOS__
3261 ok(!handle || broken(handle != 0) /* Pre-Win7 */, "CreateThread should fail\n");
3262
3263 if (!handle)
3264 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
3265 else
3266 {
3267 ret = WaitForSingleObject(handle, 1000);
3268 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#x\n", ret);
3269 CloseHandle(handle);
3270 }
3271#else
3272 ok(!handle, "CreateThread should fail\n");
3273 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
3274#endif
3275 }
3276 else
3277 {
3278 ok(handle != 0, "CreateThread error %ld\n", GetLastError());
3279 ret = WaitForSingleObject(handle, 1000);
3280 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3281 ok(!noop_thread_started, "thread shouldn't start yet\n");
3282 CloseHandle(handle);
3283 }
3284
3285 SetLastError(0xdeadbeef);
3286 process = OpenProcess(PROCESS_ALL_ACCESS_NT4, FALSE, GetCurrentProcessId());
3287 ok(process != NULL, "OpenProcess error %ld\n", GetLastError());
3288
3289 noop_thread_started = 0;
3290 SetLastError(0xdeadbeef);
3291 handle = CreateRemoteThread(process, NULL, 0, noop_thread_proc, &noop_thread_started, 0, &ret);
3292 if (param)
3293 {
3294#ifdef __REACTOS__
3295 ok(!handle || broken(handle != 0) /* Pre-Win7 */, "CreateRemoteThread should fail\n");
3296
3297 if (!handle)
3298 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
3299 else
3300 {
3301 ret = WaitForSingleObject(handle, 1000);
3302 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#x\n", ret);
3303 CloseHandle(handle);
3304 }
3305#else
3306 ok(!handle, "CreateRemoteThread should fail\n");
3307 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
3308#endif
3309 }
3310 else
3311 {
3312 ok(handle != 0, "CreateRemoteThread error %ld\n", GetLastError());
3313 ret = WaitForSingleObject(handle, 1000);
3314 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3315 ok(!noop_thread_started, "thread shouldn't start yet\n");
3316 CloseHandle(handle);
3317 }
3318
3319 SetLastError(0xdeadbeef);
3320 handle = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, NULL);
3321 ok(handle != 0, "CreateFileMapping error %ld\n", GetLastError());
3322
3323 offset.u.LowPart = 0;
3324 offset.u.HighPart = 0;
3325 addr = NULL;
3326 size = 0;
3327 ret = pNtMapViewOfSection(handle, process, &addr, 0, 0, &offset,
3328 &size, 1 /* ViewShare */, 0, PAGE_READONLY);
3329 ok(ret == STATUS_SUCCESS, "NtMapViewOfSection error %#lx\n", ret);
3330 ret = pNtUnmapViewOfSection(process, addr);
3331 ok(ret == STATUS_SUCCESS, "NtUnmapViewOfSection error %#lx\n", ret);
3332
3333 CloseHandle(handle);
3334 CloseHandle(process);
3335
3336 handle = GetModuleHandleA("winver.exe");
3337 ok(!handle, "winver.exe shouldn't be loaded yet\n");
3338 SetLastError(0xdeadbeef);
3339 handle = LoadLibraryA("winver.exe");
3340 ok(handle != 0, "LoadLibrary error %ld\n", GetLastError());
3341 SetLastError(0xdeadbeef);
3342 ret = FreeLibrary(handle);
3343 ok(ret, "FreeLibrary error %ld\n", GetLastError());
3344 handle = GetModuleHandleA("winver.exe");
3345 if (param)
3346 ok(handle != 0, "winver.exe should not be unloaded\n");
3347 else
3348 todo_wine
3349 ok(!handle, "winver.exe should be unloaded\n");
3350
3351 SetLastError(0xdeadbeef);
3352 ret = WaitForDebugEvent(&de, 0);
3353 ok(!ret, "WaitForDebugEvent should fail\n");
3354 ok(GetLastError() == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %ld\n", GetLastError());
3355
3356 SetLastError(0xdeadbeef);
3357 ret = DebugActiveProcess(GetCurrentProcessId());
3358 ok(!ret, "DebugActiveProcess should fail\n");
3359 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
3360
3361 SetLastError(0xdeadbeef);
3362 ret = WaitForDebugEvent(&de, 0);
3363 ok(!ret, "WaitForDebugEvent should fail\n");
3364 ok(GetLastError() == ERROR_SEM_TIMEOUT, "expected ERROR_SEM_TIMEOUT, got %ld\n", GetLastError());
3365
3366 if (test_dll_phase == 2)
3367 {
3368 trace("dll: call ExitProcess()\n");
3369 *child_failures = winetest_get_failures();
3370 ExitProcess(197);
3371 }
3372 trace("dll: %p, DLL_PROCESS_DETACH, %p => DONE\n", hinst, param);
3373 break;
3374 }
3375 case DLL_THREAD_ATTACH:
3376 trace("dll: %p, DLL_THREAD_ATTACH, %p\n", hinst, param);
3377
3378 ++thread_count;
3379
3380 ret = pRtlDllShutdownInProgress();
3381 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3382
3383 if (attached_thread_count < MAX_COUNT)
3384 {
3385 DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &attached_thread[attached_thread_count],
3386 0, TRUE, DUPLICATE_SAME_ACCESS);
3387 attached_thread_count++;
3388 }
3389
3390 /* Make sure the FLS slot is empty, if FLS is available */
3391 if (pFlsGetValue)
3392 {
3393 void* value;
3394 BOOL ret;
3395 SetLastError(0xdeadbeef);
3396 value = pFlsGetValue(fls_index);
3397 ok(!value, "FlsGetValue returned %p, expected NULL\n", value);
3398 ok(GetLastError() == ERROR_SUCCESS, "FlsGetValue failed with error %lu\n", GetLastError());
3399 ret = pFlsSetValue(fls_index, (void*) 0x31415);
3400 ok(ret, "FlsSetValue failed\n");
3401 fls_count++;
3402 }
3403
3404 break;
3405 case DLL_THREAD_DETACH:
3406 trace("dll: %p, DLL_THREAD_DETACH, %p\n", hinst, param);
3407 --thread_count;
3408 thread_detach_count++;
3409
3410 ret = pRtlDllShutdownInProgress();
3411 /* win7 doesn't allow creating a thread during process shutdown but
3412 * earlier Windows versions allow it. In that case DLL_THREAD_DETACH is
3413 * sent on thread exit, but DLL_THREAD_ATTACH is never received.
3414 */
3415 if (noop_thread_started)
3416 ok(ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3417 else
3418 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3419
3420 /* FLS data should already be destroyed, if FLS is available.
3421 */
3422 if (pFlsGetValue && fls_index != FLS_OUT_OF_INDEXES)
3423 {
3424 unsigned int index, count;
3425 void* value;
3426 BOOL bret;
3427
3428 SetLastError(0xdeadbeef);
3429 value = pFlsGetValue(fls_index);
3430#ifdef __REACTOS__
3431 ok(!value || broken(value == (void*)0x31415) /* WS03 */, "FlsGetValue returned %p, expected NULL\n", value);
3432#else
3433 ok(!value, "FlsGetValue returned %p, expected NULL\n", value);
3434#endif
3435 ok(GetLastError() == ERROR_SUCCESS, "FlsGetValue failed with error %lu\n", GetLastError());
3436
3437 bret = pFlsSetValue(fls_index2, (void*) 0x31415);
3438 ok(bret, "FlsSetValue failed\n");
3439
3440 if (fls_list_head)
3441 {
3442 count = check_linked_list(fls_list_head, &NtCurrentTeb()->FlsSlots->fls_list_entry, &index);
3443#ifdef __REACTOS__
3444 if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
3445#endif
3446 ok(count <= thread_count, "Got unexpected count %u, thread_count %u.\n", count, thread_count);
3447 ok(index == ~0, "Got unexpected index %u.\n", index);
3448#ifdef __REACTOS__
3449 }
3450#endif
3451 }
3452 }
3453
3454 break;
3455 default:
3456 trace("dll: %p, %ld, %p\n", hinst, reason, param);
3457 break;
3458 }
3459
3460 *child_failures = winetest_get_failures();
3461
3462 return TRUE;
3463}
3464
3465static void CALLBACK ldr_notify_callback(ULONG reason, LDR_DLL_NOTIFICATION_DATA *data, void *context)
3466{
3467 /* If some DLL happens to be loaded during process shutdown load notification is called but never unload
3468 * notification. */
3469 ok(reason == LDR_DLL_NOTIFICATION_REASON_LOADED, "got reason %lu.\n", reason);
3470}
3471
3472static void child_process(const char *dll_name, DWORD target_offset)
3473{
3474 void *target;
3475 DWORD ret, dummy, i, code, expected_code;
3476 HANDLE file, thread, process;
3477 HMODULE hmod;
3478 struct PROCESS_BASIC_INFORMATION_PRIVATE pbi;
3479 DWORD_PTR affinity;
3480 void *cookie;
3481
3482 trace("phase %d: writing %p at %#lx\n", test_dll_phase, dll_entry_point, target_offset);
3483
3484 if (pFlsAlloc)
3485 {
3486 fls_list_head = NtCurrentTeb()->Peb->FlsListHead.Flink ? &NtCurrentTeb()->Peb->FlsListHead
3487 : NtCurrentTeb()->FlsSlots->fls_list_entry.Flink;
3488 }
3489
3490 SetLastError(0xdeadbeef);
3491 mutex = CreateMutexW(NULL, FALSE, NULL);
3492 ok(mutex != 0, "CreateMutex error %ld\n", GetLastError());
3493
3494 SetLastError(0xdeadbeef);
3495 semaphore = CreateSemaphoreW(NULL, 1, 1, NULL);
3496 ok(semaphore != 0, "CreateSemaphore error %ld\n", GetLastError());
3497
3498 SetLastError(0xdeadbeef);
3499 event = CreateEventW(NULL, TRUE, FALSE, NULL);
3500 ok(event != 0, "CreateEvent error %ld\n", GetLastError());
3501
3502 SetLastError(0xdeadbeef);
3503 loader_lock_event = CreateEventW(NULL, FALSE, FALSE, NULL);
3504 ok(loader_lock_event != 0, "CreateEvent error %ld\n", GetLastError());
3505
3506 SetLastError(0xdeadbeef);
3507 peb_lock_event = CreateEventW(NULL, FALSE, FALSE, NULL);
3508 ok(peb_lock_event != 0, "CreateEvent error %ld\n", GetLastError());
3509
3510 SetLastError(0xdeadbeef);
3511 heap_lock_event = CreateEventW(NULL, FALSE, FALSE, NULL);
3512 ok(heap_lock_event != 0, "CreateEvent error %ld\n", GetLastError());
3513
3514 InitializeCriticalSection(&cs_lock);
3515 SetLastError(0xdeadbeef);
3516 cs_lock_event = CreateEventW(NULL, FALSE, FALSE, NULL);
3517 ok(cs_lock_event != 0, "CreateEvent error %ld\n", GetLastError());
3518
3519 SetLastError(0xdeadbeef);
3520 ack_event = CreateEventW(NULL, FALSE, FALSE, NULL);
3521 ok(ack_event != 0, "CreateEvent error %ld\n", GetLastError());
3522
3523 file = CreateFileA(dll_name, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
3524 if (file == INVALID_HANDLE_VALUE)
3525 {
3526 ok(0, "could not open %s\n", dll_name);
3527 return;
3528 }
3529 SetFilePointer(file, target_offset, NULL, FILE_BEGIN);
3530 SetLastError(0xdeadbeef);
3531 target = dll_entry_point;
3532 ret = WriteFile(file, &target, sizeof(target), &dummy, NULL);
3533 ok(ret, "WriteFile error %ld\n", GetLastError());
3534 CloseHandle(file);
3535
3536 SetLastError(0xdeadbeef);
3537 hmod = LoadLibraryA(dll_name);
3538 ok(hmod != 0, "LoadLibrary error %ld\n", GetLastError());
3539
3540 SetLastError(0xdeadbeef);
3541 stop_event = CreateEventW(NULL, TRUE, FALSE, NULL);
3542 ok(stop_event != 0, "CreateEvent error %ld\n", GetLastError());
3543
3544 SetLastError(0xdeadbeef);
3545 thread = CreateThread(NULL, 0, mutex_thread_proc, event, 0, &dummy);
3546 ok(thread != 0, "CreateThread error %ld\n", GetLastError());
3547 WaitForSingleObject(event, 3000);
3548 CloseHandle(thread);
3549
3550 ResetEvent(event);
3551
3552 SetLastError(0xdeadbeef);
3553 thread = CreateThread(NULL, 0, semaphore_thread_proc, event, 0, &dummy);
3554 ok(thread != 0, "CreateThread error %ld\n", GetLastError());
3555 WaitForSingleObject(event, 3000);
3556 CloseHandle(thread);
3557
3558 ResetEvent(event);
3559 Sleep(100);
3560
3561 ok(attached_thread_count == 2, "attached thread count should be 2\n");
3562 for (i = 0; i < attached_thread_count; i++)
3563 {
3564 ret = GetExitCodeThread(attached_thread[i], &code);
3565 trace("child: GetExitCodeThread(%lu) => %ld,%lu\n", i, ret, code);
3566 ok(ret == 1, "GetExitCodeThread returned %ld, expected 1\n", ret);
3567 ok(code == STILL_ACTIVE, "expected thread exit code STILL_ACTIVE, got %lu\n", code);
3568 }
3569
3570 ret = WaitForSingleObject(attached_thread[0], 0);
3571 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3572 ret = WaitForSingleObject(attached_thread[1], 0);
3573 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3574
3575 ret = WaitForSingleObject(event, 0);
3576 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3577 ret = WaitForSingleObject(mutex, 0);
3578 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3579 ret = WaitForSingleObject(semaphore, 0);
3580 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3581
3582 ret = pRtlDllShutdownInProgress();
3583 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3584
3585 SetLastError(0xdeadbeef);
3586 process = OpenProcess(PROCESS_ALL_ACCESS_NT4, FALSE, GetCurrentProcessId());
3587 ok(process != NULL, "OpenProcess error %ld\n", GetLastError());
3588
3589 SetLastError(0xdeadbeef);
3590 ret = TerminateProcess(0, 195);
3591 ok(!ret, "TerminateProcess(0) should fail\n");
3592 ok(GetLastError() == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %ld\n", GetLastError());
3593
3594 Sleep(100);
3595
3596 affinity = 1;
3597 ret = pNtSetInformationProcess(process, ProcessAffinityMask, &affinity, sizeof(affinity));
3598 ok(!ret, "NtSetInformationProcess error %#lx\n", ret);
3599
3600 switch (test_dll_phase)
3601 {
3602 case 0:
3603 ret = pRtlDllShutdownInProgress();
3604 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3605
3606 trace("call NtTerminateProcess(0, 195)\n");
3607 ret = pNtTerminateProcess(0, 195);
3608 ok(!ret, "NtTerminateProcess error %#lx\n", ret);
3609
3610 memset(&pbi, 0, sizeof(pbi));
3611 ret = pNtQueryInformationProcess(process, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
3612 ok(!ret, "NtQueryInformationProcess error %#lx\n", ret);
3613 ok(pbi.ExitStatus == STILL_ACTIVE || pbi.ExitStatus == 195,
3614 "expected STILL_ACTIVE, got %lu\n", pbi.ExitStatus);
3615 affinity = 1;
3616 ret = pNtSetInformationProcess(process, ProcessAffinityMask, &affinity, sizeof(affinity));
3617 ok(!ret, "NtSetInformationProcess error %#lx\n", ret);
3618
3619 ret = pRtlDllShutdownInProgress();
3620 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3621
3622 hmod = GetModuleHandleA(dll_name);
3623 ok(hmod != 0, "DLL should not be unloaded\n");
3624
3625#ifdef __REACTOS__
3626 if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
3627#endif
3628 SetLastError(0xdeadbeef);
3629 thread = CreateThread(NULL, 0, noop_thread_proc, &dummy, 0, &ret);
3630 ok(!thread, "CreateThread should fail\n");
3631 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
3632#ifdef __REACTOS__
3633 }
3634#endif
3635
3636 trace("call LdrShutdownProcess()\n");
3637 pLdrRegisterDllNotification(0, ldr_notify_callback, NULL, &cookie);
3638 pLdrShutdownProcess();
3639
3640 ret = pRtlDllShutdownInProgress();
3641 ok(ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3642
3643 hmod = GetModuleHandleA(dll_name);
3644 ok(hmod != 0, "DLL should not be unloaded\n");
3645
3646 memset(&pbi, 0, sizeof(pbi));
3647 ret = pNtQueryInformationProcess(process, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
3648 ok(!ret, "NtQueryInformationProcess error %#lx\n", ret);
3649 ok(pbi.ExitStatus == STILL_ACTIVE || pbi.ExitStatus == 195,
3650 "expected STILL_ACTIVE, got %lu\n", pbi.ExitStatus);
3651 affinity = 1;
3652 ret = pNtSetInformationProcess(process, ProcessAffinityMask, &affinity, sizeof(affinity));
3653 ok(!ret, "NtSetInformationProcess error %#lx\n", ret);
3654 break;
3655
3656 case 1: /* normal ExitProcess */
3657 ret = pRtlDllShutdownInProgress();
3658 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3659 break;
3660
3661 case 2: /* ExitProcess will be called by the PROCESS_DETACH handler */
3662 ret = pRtlDllShutdownInProgress();
3663 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3664
3665 trace("call FreeLibrary(%p)\n", hmod);
3666 SetLastError(0xdeadbeef);
3667 ret = FreeLibrary(hmod);
3668 ok(ret, "FreeLibrary error %ld\n", GetLastError());
3669 hmod = GetModuleHandleA(dll_name);
3670 ok(!hmod, "DLL should be unloaded\n");
3671
3672 if (test_dll_phase == 2)
3673 ok(0, "FreeLibrary+ExitProcess should never return\n");
3674
3675 ret = pRtlDllShutdownInProgress();
3676 ok(!ret, "RtlDllShutdownInProgress returned %ld\n", ret);
3677
3678 break;
3679
3680 case 3:
3681 trace("signalling thread exit\n");
3682 SetEvent(stop_event);
3683 break;
3684
3685 case 4:
3686 trace("setting loader_lock_event\n");
3687 SetEvent(loader_lock_event);
3688 WaitForSingleObject(ack_event, 1000);
3689 ok(inside_loader_lock != 0, "inside_loader_lock is not set\n");
3690
3691 /* calling NtTerminateProcess should not cause a deadlock */
3692 trace("call NtTerminateProcess(0, 198)\n");
3693 ret = pNtTerminateProcess(0, 198);
3694 ok(!ret, "NtTerminateProcess error %#lx\n", ret);
3695
3696 *child_failures = winetest_get_failures();
3697
3698 /* Windows fails to release loader lock acquired from another thread,
3699 * so the LdrUnlockLoaderLock call fails here and ExitProcess deadlocks
3700 * later on, so NtTerminateProcess is used instead.
3701 */
3702 trace("call NtTerminateProcess(GetCurrentProcess(), 198)\n");
3703 pNtTerminateProcess(GetCurrentProcess(), 198);
3704 ok(0, "NtTerminateProcess should not return\n");
3705 break;
3706
3707 case 5:
3708 trace("setting peb_lock_event\n");
3709 SetEvent(peb_lock_event);
3710 WaitForSingleObject(ack_event, 1000);
3711 ok(inside_peb_lock != 0, "inside_peb_lock is not set\n");
3712
3713 *child_failures = winetest_get_failures();
3714
3715 /* calling ExitProcess should cause a deadlock */
3716 trace("call ExitProcess(198)\n");
3717 ExitProcess(198);
3718 ok(0, "ExitProcess should not return\n");
3719 break;
3720
3721 case 6:
3722 trace("setting heap_lock_event\n");
3723 SetEvent(heap_lock_event);
3724 WaitForSingleObject(ack_event, 1000);
3725 ok(inside_heap_lock != 0, "inside_heap_lock is not set\n");
3726
3727 *child_failures = winetest_get_failures();
3728
3729 /* calling ExitProcess should cause a deadlock */
3730 trace("call ExitProcess(1)\n");
3731 ExitProcess(1);
3732 ok(0, "ExitProcess should not return\n");
3733 break;
3734
3735 case 7:
3736 trace("setting cs_lock_event\n");
3737 SetEvent(cs_lock_event);
3738 WaitForSingleObject(ack_event, 1000);
3739 ok(inside_cs_lock != 0, "inside_cs_lock is not set\n");
3740
3741 *child_failures = winetest_get_failures();
3742
3743 /* calling ExitProcess should not cause a deadlock */
3744 trace("call ExitProcess(199)\n");
3745 ExitProcess(199);
3746 ok(0, "ExitProcess should not return\n");
3747 break;
3748
3749 default:
3750 assert(0);
3751 break;
3752 }
3753
3754 if (test_dll_phase == 0) expected_code = 195;
3755 else if (test_dll_phase == 3) expected_code = 196;
3756 else if (test_dll_phase == 4) expected_code = 198;
3757 else expected_code = STILL_ACTIVE;
3758
3759 if (expected_code == STILL_ACTIVE)
3760 {
3761 ret = WaitForSingleObject(attached_thread[0], 100);
3762 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3763 ret = WaitForSingleObject(attached_thread[1], 100);
3764 ok(ret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %#lx\n", ret);
3765 }
3766 else
3767 {
3768 ret = WaitForSingleObject(attached_thread[0], 2000);
3769 ok(ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %#lx\n", ret);
3770 ret = WaitForSingleObject(attached_thread[1], 2000);
3771 ok(ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %#lx\n", ret);
3772 }
3773
3774 for (i = 0; i < attached_thread_count; i++)
3775 {
3776 ret = GetExitCodeThread(attached_thread[i], &code);
3777 trace("child: GetExitCodeThread(%lu) => %ld,%lu\n", i, ret, code);
3778 ok(ret == 1, "GetExitCodeThread returned %ld, expected 1\n", ret);
3779 ok(code == expected_code, "expected thread exit code %lu, got %lu\n", expected_code, code);
3780 }
3781
3782 *child_failures = winetest_get_failures();
3783
3784 trace("call ExitProcess(195)\n");
3785 ExitProcess(195);
3786}
3787
3788static void test_ExitProcess(void)
3789{
3790#if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
3791#include "pshpack1.h"
3792#ifdef __x86_64__
3793 static struct section_data
3794 {
3795 BYTE mov_rax[2];
3796 void *target;
3797 BYTE jmp_rax[2];
3798 } section_data = { { 0x48,0xb8 }, dll_entry_point, { 0xff,0xe0 } };
3799#elif defined(__i386__)
3800 static struct section_data
3801 {
3802 BYTE mov_eax;
3803 void *target;
3804 BYTE jmp_eax[2];
3805 } section_data = { 0xb8, dll_entry_point, { 0xff,0xe0 } };
3806#elif defined(__aarch64__)
3807 static struct section_data
3808 {
3809 DWORD ldr; /* ldr x0,target */
3810 DWORD br; /* br x0 */
3811 void *target;
3812 } section_data = { 0x58000040, 0xd61f0000, dll_entry_point };
3813#endif
3814#include "poppack.h"
3815 DWORD dummy, file_align;
3816 HANDLE file, thread, process, hmap, hmap_dup;
3817 char temp_path[MAX_PATH], dll_name[MAX_PATH], cmdline[MAX_PATH * 2];
3818 DWORD ret, target_offset, old_prot;
3819 char **argv, buf[256];
3820 PROCESS_INFORMATION pi;
3821 STARTUPINFOA si = { sizeof(si) };
3822 CONTEXT ctx;
3823 struct PROCESS_BASIC_INFORMATION_PRIVATE pbi;
3824 MEMORY_BASIC_INFORMATION mbi;
3825 DWORD_PTR affinity;
3826 void *addr;
3827 LARGE_INTEGER offset;
3828 SIZE_T size;
3829 IMAGE_NT_HEADERS nt_header;
3830
3831 if (!pRtlDllShutdownInProgress)
3832 {
3833 win_skip("RtlDllShutdownInProgress is not available on this platform (XP+)\n");
3834 return;
3835 }
3836 if (!pNtQueryInformationProcess || !pNtSetInformationProcess)
3837 {
3838 win_skip("NtQueryInformationProcess/NtSetInformationProcess are not available on this platform\n");
3839 return;
3840 }
3841 if (!pNtAllocateVirtualMemory || !pNtFreeVirtualMemory)
3842 {
3843 win_skip("NtAllocateVirtualMemory/NtFreeVirtualMemory are not available on this platform\n");
3844 return;
3845 }
3846
3847 /* prevent displaying of the "Unable to load this DLL" message box */
3848 SetErrorMode(SEM_FAILCRITICALERRORS);
3849
3850 GetTempPathA(MAX_PATH, temp_path);
3851 GetTempFileNameA(temp_path, "ldr", 0, dll_name);
3852
3853 /*trace("creating %s\n", dll_name);*/
3854 file = CreateFileA(dll_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
3855 if (file == INVALID_HANDLE_VALUE)
3856 {
3857 ok(0, "could not create %s\n", dll_name);
3858 return;
3859 }
3860
3861 SetLastError(0xdeadbeef);
3862 ret = WriteFile(file, &dos_header, sizeof(dos_header), &dummy, NULL);
3863 ok(ret, "WriteFile error %ld\n", GetLastError());
3864
3865 nt_header = nt_header_template;
3866 nt_header.OptionalHeader.AddressOfEntryPoint = 0x1000;
3867 nt_header.OptionalHeader.SectionAlignment = 0x1000;
3868 nt_header.OptionalHeader.FileAlignment = 0x200;
3869 nt_header.OptionalHeader.SizeOfImage = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x1000;
3870 nt_header.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER);
3871 SetLastError(0xdeadbeef);
3872 ret = WriteFile(file, &nt_header, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), &dummy, NULL);
3873 ok(ret, "WriteFile error %ld\n", GetLastError());
3874 SetLastError(0xdeadbeef);
3875 ret = WriteFile(file, &nt_header.OptionalHeader, sizeof(IMAGE_OPTIONAL_HEADER), &dummy, NULL);
3876 ok(ret, "WriteFile error %ld\n", GetLastError());
3877
3878 section.SizeOfRawData = sizeof(section_data);
3879 section.PointerToRawData = nt_header.OptionalHeader.FileAlignment;
3880 section.VirtualAddress = nt_header.OptionalHeader.SectionAlignment;
3881 section.Misc.VirtualSize = sizeof(section_data);
3882 section.Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
3883 SetLastError(0xdeadbeef);
3884 ret = WriteFile(file, &section, sizeof(section), &dummy, NULL);
3885 ok(ret, "WriteFile error %ld\n", GetLastError());
3886
3887 file_align = nt_header.OptionalHeader.FileAlignment - nt_header.OptionalHeader.SizeOfHeaders;
3888 assert(file_align < sizeof(filler));
3889 SetLastError(0xdeadbeef);
3890 ret = WriteFile(file, filler, file_align, &dummy, NULL);
3891 ok(ret, "WriteFile error %ld\n", GetLastError());
3892
3893 target_offset = SetFilePointer(file, 0, NULL, FILE_CURRENT) + FIELD_OFFSET(struct section_data, target);
3894
3895 /* section data */
3896 SetLastError(0xdeadbeef);
3897 ret = WriteFile(file, &section_data, sizeof(section_data), &dummy, NULL);
3898 ok(ret, "WriteFile error %ld\n", GetLastError());
3899
3900 CloseHandle(file);
3901
3902 winetest_get_mainargs(&argv);
3903
3904 /* phase 0 */
3905 *child_failures = -1;
3906 sprintf(cmdline, "\"%s\" loader %s %lu 0", argv[0], dll_name, target_offset);
3907 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
3908 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
3909 ret = WaitForSingleObject(pi.hProcess, 10000);
3910 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
3911 if (ret != WAIT_OBJECT_0) TerminateProcess(pi.hProcess, 0);
3912 GetExitCodeProcess(pi.hProcess, &ret);
3913#ifdef __REACTOS__
3914 ok(ret == 195 || broken(ret == 0xc0000005) /* WS03 */, "expected exit code 195, got %lu\n", ret);
3915#else
3916 ok(ret == 195, "expected exit code 195, got %lu\n", ret);
3917#endif
3918 if (*child_failures)
3919 {
3920 trace("%ld failures in child process\n", *child_failures);
3921 winetest_add_failures(*child_failures);
3922 }
3923 CloseHandle(pi.hThread);
3924 CloseHandle(pi.hProcess);
3925
3926 /* phase 1 */
3927 *child_failures = -1;
3928 sprintf(cmdline, "\"%s\" loader %s %lu 1", argv[0], dll_name, target_offset);
3929 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
3930 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
3931 ret = WaitForSingleObject(pi.hProcess, 10000);
3932 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
3933 if (ret != WAIT_OBJECT_0) TerminateProcess(pi.hProcess, 0);
3934 GetExitCodeProcess(pi.hProcess, &ret);
3935 ok(ret == 195, "expected exit code 195, got %lu\n", ret);
3936 if (*child_failures)
3937 {
3938 trace("%ld failures in child process\n", *child_failures);
3939 winetest_add_failures(*child_failures);
3940 }
3941 CloseHandle(pi.hThread);
3942 CloseHandle(pi.hProcess);
3943
3944 /* phase 2 */
3945 *child_failures = -1;
3946 sprintf(cmdline, "\"%s\" loader %s %lu 2", argv[0], dll_name, target_offset);
3947 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
3948 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
3949 ret = WaitForSingleObject(pi.hProcess, 10000);
3950 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
3951 if (ret != WAIT_OBJECT_0) TerminateProcess(pi.hProcess, 0);
3952 GetExitCodeProcess(pi.hProcess, &ret);
3953 ok(ret == 197, "expected exit code 197, got %lu\n", ret);
3954 if (*child_failures)
3955 {
3956 trace("%ld failures in child process\n", *child_failures);
3957 winetest_add_failures(*child_failures);
3958 }
3959 CloseHandle(pi.hThread);
3960 CloseHandle(pi.hProcess);
3961
3962 /* phase 3 */
3963 *child_failures = -1;
3964 sprintf(cmdline, "\"%s\" loader %s %lu 3", argv[0], dll_name, target_offset);
3965 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
3966 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
3967 ret = WaitForSingleObject(pi.hProcess, 10000);
3968 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
3969 if (ret != WAIT_OBJECT_0) TerminateProcess(pi.hProcess, 0);
3970 GetExitCodeProcess(pi.hProcess, &ret);
3971 ok(ret == 195, "expected exit code 195, got %lu\n", ret);
3972 if (*child_failures)
3973 {
3974 trace("%ld failures in child process\n", *child_failures);
3975 winetest_add_failures(*child_failures);
3976 }
3977 CloseHandle(pi.hThread);
3978 CloseHandle(pi.hProcess);
3979
3980 /* phase 4 */
3981 if (pLdrLockLoaderLock && pLdrUnlockLoaderLock)
3982 {
3983 *child_failures = -1;
3984 sprintf(cmdline, "\"%s\" loader %s %lu 4", argv[0], dll_name, target_offset);
3985 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
3986 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
3987 ret = WaitForSingleObject(pi.hProcess, 10000);
3988 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
3989 if (ret != WAIT_OBJECT_0) TerminateProcess(pi.hProcess, 0);
3990 GetExitCodeProcess(pi.hProcess, &ret);
3991 ok(ret == 198, "expected exit code 198, got %lu\n", ret);
3992 if (*child_failures)
3993 {
3994 trace("%ld failures in child process\n", *child_failures);
3995 winetest_add_failures(*child_failures);
3996 }
3997 CloseHandle(pi.hThread);
3998 CloseHandle(pi.hProcess);
3999 }
4000 else
4001 win_skip("LdrLockLoaderLock/LdrUnlockLoaderLock are not available on this platform\n");
4002
4003 /* phase 5 */
4004 if (pRtlAcquirePebLock && pRtlReleasePebLock)
4005 {
4006 *child_failures = -1;
4007 sprintf(cmdline, "\"%s\" loader %s %lu 5", argv[0], dll_name, target_offset);
4008 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
4009 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
4010 ret = WaitForSingleObject(pi.hProcess, 5000);
4011 ok(ret == WAIT_TIMEOUT, "child process should fail to terminate\n");
4012 if (ret != WAIT_OBJECT_0)
4013 {
4014 trace("terminating child process\n");
4015 TerminateProcess(pi.hProcess, 199);
4016 }
4017 ret = WaitForSingleObject(pi.hProcess, 1000);
4018 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
4019 GetExitCodeProcess(pi.hProcess, &ret);
4020 ok(ret == 199, "expected exit code 199, got %lu\n", ret);
4021 if (*child_failures)
4022 {
4023 trace("%ld failures in child process\n", *child_failures);
4024 winetest_add_failures(*child_failures);
4025 }
4026 CloseHandle(pi.hThread);
4027 CloseHandle(pi.hProcess);
4028 }
4029 else
4030 win_skip("RtlAcquirePebLock/RtlReleasePebLock are not available on this platform\n");
4031
4032 /* phase 6 */
4033 *child_failures = -1;
4034 sprintf(cmdline, "\"%s\" loader %s %lu 6", argv[0], dll_name, target_offset);
4035 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
4036 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
4037 ret = WaitForSingleObject(pi.hProcess, 5000);
4038 todo_wine
4039#ifdef __REACTOS__
4040 ok(ret == WAIT_TIMEOUT || broken(ret == WAIT_OBJECT_0) /* WS03 */, "child process should fail to terminate\n");
4041#else
4042 ok(ret == WAIT_TIMEOUT, "child process should fail to terminate\n");
4043#endif
4044 if (ret != WAIT_OBJECT_0)
4045 {
4046 trace("terminating child process\n");
4047 TerminateProcess(pi.hProcess, 201);
4048 }
4049 ret = WaitForSingleObject(pi.hProcess, 1000);
4050 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
4051 GetExitCodeProcess(pi.hProcess, &ret);
4052 todo_wine
4053#ifdef __REACTOS__
4054 ok(ret == 201 || broken(ret == 1) /* WS03 */, "expected exit code 201, got %lu\n", ret);
4055#else
4056 ok(ret == 201, "expected exit code 201, got %lu\n", ret);
4057#endif
4058 if (*child_failures)
4059 {
4060 trace("%ld failures in child process\n", *child_failures);
4061 winetest_add_failures(*child_failures);
4062 }
4063 CloseHandle(pi.hThread);
4064 CloseHandle(pi.hProcess);
4065
4066 /* phase 7 */
4067 *child_failures = -1;
4068 sprintf(cmdline, "\"%s\" loader %s %lu 7", argv[0], dll_name, target_offset);
4069 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
4070 ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
4071 ret = WaitForSingleObject(pi.hProcess, 5000);
4072 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
4073 if (ret != WAIT_OBJECT_0)
4074 {
4075 trace("terminating child process\n");
4076 TerminateProcess(pi.hProcess, 199);
4077 }
4078 ret = WaitForSingleObject(pi.hProcess, 1000);
4079 ok(ret == WAIT_OBJECT_0, "child process failed to terminate\n");
4080 GetExitCodeProcess(pi.hProcess, &ret);
4081 ok(ret == 199, "expected exit code 199, got %lu\n", ret);
4082 if (*child_failures)
4083 {
4084 trace("%ld failures in child process\n", *child_failures);
4085 winetest_add_failures(*child_failures);
4086 }
4087 CloseHandle(pi.hThread);
4088 CloseHandle(pi.hProcess);
4089
4090 /* test remote process termination */
4091 SetLastError(0xdeadbeef);
4092 ret = CreateProcessA(argv[0], NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
4093 ok(ret, "CreateProcess(%s) error %ld\n", argv[0], GetLastError());
4094
4095 SetLastError(0xdeadbeef);
4096 addr = VirtualAllocEx(pi.hProcess, NULL, 4096, MEM_COMMIT, PAGE_READWRITE);
4097 ok(addr != NULL, "VirtualAllocEx error %ld\n", GetLastError());
4098 SetLastError(0xdeadbeef);
4099 ret = VirtualProtectEx(pi.hProcess, addr, 4096, PAGE_READONLY, &old_prot);
4100 ok(ret, "VirtualProtectEx error %ld\n", GetLastError());
4101 ok(old_prot == PAGE_READWRITE, "expected PAGE_READWRITE, got %#lx\n", old_prot);
4102 SetLastError(0xdeadbeef);
4103 size = VirtualQueryEx(pi.hProcess, NULL, &mbi, sizeof(mbi));
4104 ok(size == sizeof(mbi), "VirtualQueryEx error %ld\n", GetLastError());
4105
4106 SetLastError(0xdeadbeef);
4107 ret = ReadProcessMemory(pi.hProcess, addr, buf, 4, &size);
4108 ok(ret, "ReadProcessMemory error %ld\n", GetLastError());
4109 ok(size == 4, "expected 4, got %Iu\n", size);
4110
4111 SetLastError(0xdeadbeef);
4112 hmap = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, NULL);
4113 ok(hmap != 0, "CreateFileMapping error %ld\n", GetLastError());
4114
4115 SetLastError(0xdeadbeef);
4116 ret = DuplicateHandle(GetCurrentProcess(), hmap, pi.hProcess, &hmap_dup,
4117 0, FALSE, DUPLICATE_SAME_ACCESS);
4118 ok(ret, "DuplicateHandle error %ld\n", GetLastError());
4119
4120 offset.u.LowPart = 0;
4121 offset.u.HighPart = 0;
4122 addr = NULL;
4123 size = 0;
4124 ret = pNtMapViewOfSection(hmap, pi.hProcess, &addr, 0, 0, &offset,
4125 &size, 1 /* ViewShare */, 0, PAGE_READONLY);
4126 ok(!ret, "NtMapViewOfSection error %#lx\n", ret);
4127 ret = pNtUnmapViewOfSection(pi.hProcess, addr);
4128 ok(!ret, "NtUnmapViewOfSection error %#lx\n", ret);
4129
4130 SetLastError(0xdeadbeef);
4131 thread = CreateRemoteThread(pi.hProcess, NULL, 0, (void *)0xdeadbeef, NULL, CREATE_SUSPENDED, &ret);
4132 ok(thread != 0, "CreateRemoteThread error %ld\n", GetLastError());
4133 SetLastError(0xdeadbeef);
4134 ctx.ContextFlags = CONTEXT_INTEGER;
4135 ret = GetThreadContext(thread, &ctx);
4136 ok(ret, "GetThreadContext error %ld\n", GetLastError());
4137 SetLastError(0xdeadbeef);
4138 ctx.ContextFlags = CONTEXT_INTEGER;
4139 ret = SetThreadContext(thread, &ctx);
4140 ok(ret, "SetThreadContext error %ld\n", GetLastError());
4141 SetLastError(0xdeadbeef);
4142 ret = SetThreadPriority(thread, 0);
4143 ok(ret, "SetThreadPriority error %ld\n", GetLastError());
4144
4145 SetLastError(0xdeadbeef);
4146 ret = TerminateThread(thread, 199);
4147 ok(ret, "TerminateThread error %ld\n", GetLastError());
4148 /* Calling GetExitCodeThread() without waiting for thread termination
4149 * leads to different results due to a race condition.
4150 */
4151 ret = WaitForSingleObject(thread, 1000);
4152 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed: %lx\n", ret);
4153 GetExitCodeThread(thread, &ret);
4154 ok(ret == 199, "expected exit code 199, got %lu\n", ret);
4155
4156 SetLastError(0xdeadbeef);
4157 ret = TerminateProcess(pi.hProcess, 198);
4158 ok(ret, "TerminateProcess error %ld\n", GetLastError());
4159 /* Checking process state without waiting for process termination
4160 * leads to different results due to a race condition.
4161 */
4162 ret = WaitForSingleObject(pi.hProcess, 1000);
4163 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed: %lx\n", ret);
4164
4165 SetLastError(0xdeadbeef);
4166 process = OpenProcess(PROCESS_ALL_ACCESS_NT4, FALSE, pi.dwProcessId);
4167 ok(process != NULL, "OpenProcess error %ld\n", GetLastError());
4168 CloseHandle(process);
4169
4170 memset(&pbi, 0, sizeof(pbi));
4171 ret = pNtQueryInformationProcess(pi.hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
4172 ok(!ret, "NtQueryInformationProcess error %#lx\n", ret);
4173 ok(pbi.ExitStatus == 198, "expected 198, got %lu\n", pbi.ExitStatus);
4174 affinity = 1;
4175 ret = pNtSetInformationProcess(pi.hProcess, ProcessAffinityMask, &affinity, sizeof(affinity));
4176 ok(ret == STATUS_PROCESS_IS_TERMINATING, "expected STATUS_PROCESS_IS_TERMINATING, got %#lx\n", ret);
4177
4178 SetLastError(0xdeadbeef);
4179 ctx.ContextFlags = CONTEXT_INTEGER;
4180 ret = GetThreadContext(thread, &ctx);
4181 ok(!ret, "GetThreadContext should fail\n");
4182 ok(GetLastError() == ERROR_INVALID_PARAMETER ||
4183 GetLastError() == ERROR_GEN_FAILURE /* win7 64-bit */ ||
4184 GetLastError() == ERROR_INVALID_FUNCTION /* vista 64-bit */ ||
4185 GetLastError() == ERROR_ACCESS_DENIED /* Win10 32-bit */,
4186 "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
4187 SetLastError(0xdeadbeef);
4188 ctx.ContextFlags = CONTEXT_INTEGER;
4189 ret = SetThreadContext(thread, &ctx);
4190 ok(!ret, "SetThreadContext should fail\n");
4191 ok(GetLastError() == ERROR_ACCESS_DENIED ||
4192 GetLastError() == ERROR_GEN_FAILURE /* win7 64-bit */ ||
4193 GetLastError() == ERROR_INVALID_FUNCTION /* vista 64-bit */,
4194 "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4195 SetLastError(0xdeadbeef);
4196 ret = SetThreadPriority(thread, 0);
4197 ok(ret, "SetThreadPriority error %ld\n", GetLastError());
4198 CloseHandle(thread);
4199
4200 ret = WaitForSingleObject(pi.hThread, 1000);
4201 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed: %lx\n", ret);
4202 SetLastError(0xdeadbeef);
4203 ctx.ContextFlags = CONTEXT_INTEGER;
4204 ret = GetThreadContext(pi.hThread, &ctx);
4205 ok(!ret, "GetThreadContext should fail\n");
4206 ok(GetLastError() == ERROR_INVALID_PARAMETER ||
4207 GetLastError() == ERROR_GEN_FAILURE /* win7 64-bit */ ||
4208 GetLastError() == ERROR_INVALID_FUNCTION /* vista 64-bit */ ||
4209 GetLastError() == ERROR_ACCESS_DENIED /* Win10 32-bit */,
4210 "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
4211 SetLastError(0xdeadbeef);
4212 ctx.ContextFlags = CONTEXT_INTEGER;
4213 ret = SetThreadContext(pi.hThread, &ctx);
4214 ok(!ret, "SetThreadContext should fail\n");
4215 ok(GetLastError() == ERROR_ACCESS_DENIED ||
4216 GetLastError() == ERROR_GEN_FAILURE /* win7 64-bit */ ||
4217 GetLastError() == ERROR_INVALID_FUNCTION /* vista 64-bit */,
4218 "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4219 SetLastError(0xdeadbeef);
4220 ret = VirtualProtectEx(pi.hProcess, addr, 4096, PAGE_READWRITE, &old_prot);
4221 ok(!ret, "VirtualProtectEx should fail\n");
4222 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4223 SetLastError(0xdeadbeef);
4224 size = 0;
4225 ret = ReadProcessMemory(pi.hProcess, addr, buf, 4, &size);
4226 ok(!ret, "ReadProcessMemory should fail\n");
4227 ok(GetLastError() == ERROR_PARTIAL_COPY || GetLastError() == ERROR_ACCESS_DENIED,
4228 "expected ERROR_PARTIAL_COPY, got %ld\n", GetLastError());
4229 ok(!size, "expected 0, got %Iu\n", size);
4230 SetLastError(0xdeadbeef);
4231 ret = VirtualFreeEx(pi.hProcess, addr, 0, MEM_RELEASE);
4232 ok(!ret, "VirtualFreeEx should fail\n");
4233 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4234 SetLastError(0xdeadbeef);
4235 addr = VirtualAllocEx(pi.hProcess, NULL, 4096, MEM_COMMIT, PAGE_READWRITE);
4236 ok(!addr, "VirtualAllocEx should fail\n");
4237 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4238 SetLastError(0xdeadbeef);
4239 size = VirtualQueryEx(pi.hProcess, NULL, &mbi, sizeof(mbi));
4240 ok(!size, "VirtualQueryEx should fail\n");
4241 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4242
4243 /* CloseHandle() call below leads to premature process termination
4244 * under some Windows versions.
4245 */
4246if (0)
4247{
4248 SetLastError(0xdeadbeef);
4249 ret = CloseHandle(hmap_dup);
4250 ok(ret, "CloseHandle should not fail\n");
4251}
4252
4253 SetLastError(0xdeadbeef);
4254 ret = DuplicateHandle(GetCurrentProcess(), hmap, pi.hProcess, &hmap_dup,
4255 0, FALSE, DUPLICATE_SAME_ACCESS);
4256 ok(!ret, "DuplicateHandle should fail\n");
4257 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4258
4259 offset.u.LowPart = 0;
4260 offset.u.HighPart = 0;
4261 addr = NULL;
4262 size = 0;
4263 ret = pNtMapViewOfSection(hmap, pi.hProcess, &addr, 0, 0, &offset,
4264 &size, 1 /* ViewShare */, 0, PAGE_READONLY);
4265 ok(ret == STATUS_PROCESS_IS_TERMINATING, "expected STATUS_PROCESS_IS_TERMINATING, got %#lx\n", ret);
4266
4267 SetLastError(0xdeadbeef);
4268 thread = CreateRemoteThread(pi.hProcess, NULL, 0, (void *)0xdeadbeef, NULL, CREATE_SUSPENDED, &ret);
4269 ok(!thread, "CreateRemoteThread should fail\n");
4270 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4271
4272 SetLastError(0xdeadbeef);
4273 ret = DebugActiveProcess(pi.dwProcessId);
4274 ok(!ret, "DebugActiveProcess should fail\n");
4275 ok(GetLastError() == ERROR_ACCESS_DENIED /* 64-bit */ || GetLastError() == ERROR_NOT_SUPPORTED /* 32-bit */,
4276 "ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
4277
4278 GetExitCodeProcess(pi.hProcess, &ret);
4279 ok(ret == 198, "expected exit code 198, got %lu\n", ret);
4280 CloseHandle(pi.hThread);
4281 CloseHandle(pi.hProcess);
4282
4283 ret = DeleteFileA(dll_name);
4284 ok(ret, "DeleteFile error %ld\n", GetLastError());
4285#else
4286 skip("x86 specific ExitProcess test\n");
4287#endif
4288}
4289
4290static PVOID WINAPI failuredllhook(ULONG ul, DELAYLOAD_INFO* pd)
4291{
4292 ok(ul == 4, "expected 4, got %lu\n", ul);
4293 ok(!!pd, "no delayload info supplied\n");
4294 if (pd)
4295 {
4296 ok(pd->Size == sizeof(*pd), "got %lu\n", pd->Size);
4297 ok(!!pd->DelayloadDescriptor, "no DelayloadDescriptor supplied\n");
4298 if (pd->DelayloadDescriptor)
4299 {
4300 ok(pd->DelayloadDescriptor->Attributes.AllAttributes == 1,
4301 "expected 1, got %lu\n", pd->DelayloadDescriptor->Attributes.AllAttributes);
4302 ok(pd->DelayloadDescriptor->DllNameRVA == 0x2000,
4303 "expected 0x2000, got %lx\n", pd->DelayloadDescriptor->DllNameRVA);
4304 ok(pd->DelayloadDescriptor->ModuleHandleRVA == 0x201a,
4305 "expected 0x201a, got %lx\n", pd->DelayloadDescriptor->ModuleHandleRVA);
4306 ok(pd->DelayloadDescriptor->ImportAddressTableRVA > pd->DelayloadDescriptor->ModuleHandleRVA,
4307 "expected %lx > %lx\n", pd->DelayloadDescriptor->ImportAddressTableRVA,
4308 pd->DelayloadDescriptor->ModuleHandleRVA);
4309 ok(pd->DelayloadDescriptor->ImportNameTableRVA > pd->DelayloadDescriptor->ImportAddressTableRVA,
4310 "expected %lx > %lx\n", pd->DelayloadDescriptor->ImportNameTableRVA,
4311 pd->DelayloadDescriptor->ImportAddressTableRVA);
4312 ok(pd->DelayloadDescriptor->BoundImportAddressTableRVA == 0,
4313 "expected 0, got %lx\n", pd->DelayloadDescriptor->BoundImportAddressTableRVA);
4314 ok(pd->DelayloadDescriptor->UnloadInformationTableRVA == 0,
4315 "expected 0, got %lx\n", pd->DelayloadDescriptor->UnloadInformationTableRVA);
4316 ok(pd->DelayloadDescriptor->TimeDateStamp == 0,
4317 "expected 0, got %lx\n", pd->DelayloadDescriptor->TimeDateStamp);
4318 }
4319
4320 ok(!!pd->ThunkAddress, "no ThunkAddress supplied\n");
4321 if (pd->ThunkAddress)
4322 ok(pd->ThunkAddress->u1.Ordinal, "no ThunkAddress value supplied\n");
4323
4324 ok(!!pd->TargetDllName, "no TargetDllName supplied\n");
4325 if (pd->TargetDllName)
4326 ok(!strcmp(pd->TargetDllName, "secur32.dll"),
4327 "expected \"secur32.dll\", got \"%s\"\n", pd->TargetDllName);
4328
4329 ok(pd->TargetApiDescriptor.ImportDescribedByName == 0,
4330 "expected 0, got %lx\n", pd->TargetApiDescriptor.ImportDescribedByName);
4331 ok(pd->TargetApiDescriptor.Description.Ordinal == 0 ||
4332 pd->TargetApiDescriptor.Description.Ordinal == 999,
4333 "expected 0, got %lx\n", pd->TargetApiDescriptor.Description.Ordinal);
4334
4335 ok(!!pd->TargetModuleBase, "no TargetModuleBase supplied\n");
4336 ok(pd->Unused == NULL, "expected NULL, got %p\n", pd->Unused);
4337 ok(pd->LastError, "no LastError supplied\n");
4338 }
4339 cb_count++;
4340 return (void*)0xdeadbeef;
4341}
4342
4343static PVOID WINAPI failuresyshook(const char *dll, const char *function)
4344{
4345 ok(!strcmp(dll, "secur32.dll"), "wrong dll: %s\n", dll);
4346 ok(!((ULONG_PTR)function >> 16), "expected ordinal, got %p\n", function);
4347 cb_count_sys++;
4348 return (void*)0x12345678;
4349}
4350
4351static void test_ResolveDelayLoadedAPI(void)
4352{
4353 static const char test_dll[] = "secur32.dll";
4354 static const char test_func[] = "SealMessage";
4355 char temp_path[MAX_PATH];
4356 char dll_name[MAX_PATH];
4357 IMAGE_DELAYLOAD_DESCRIPTOR idd, *delaydir;
4358 IMAGE_THUNK_DATA itd32;
4359 HANDLE hfile;
4360 HMODULE hlib;
4361 DWORD dummy, file_size, i;
4362 WORD hint = 0;
4363 BOOL ret;
4364 IMAGE_NT_HEADERS nt_header;
4365
4366 static const struct test_data
4367 {
4368 BOOL func;
4369 UINT_PTR ordinal;
4370 BOOL succeeds;
4371 } td[] =
4372 {
4373 {
4374 TRUE, 0, TRUE
4375 },
4376 {
4377 FALSE, IMAGE_ORDINAL_FLAG | 2, TRUE
4378 },
4379 {
4380 FALSE, IMAGE_ORDINAL_FLAG | 5, TRUE
4381 },
4382 {
4383 FALSE, IMAGE_ORDINAL_FLAG | 0, FALSE
4384 },
4385 {
4386 FALSE, IMAGE_ORDINAL_FLAG | 999, FALSE
4387 },
4388 };
4389
4390 if (!pResolveDelayLoadedAPI)
4391 {
4392 win_skip("ResolveDelayLoadedAPI is not available\n");
4393 return;
4394 }
4395
4396 if (0) /* crashes on native */
4397 {
4398 SetLastError(0xdeadbeef);
4399 ok(!pResolveDelayLoadedAPI(NULL, NULL, NULL, NULL, NULL, 0),
4400 "ResolveDelayLoadedAPI succeeded\n");
4401 ok(GetLastError() == 0xdeadbeef, "GetLastError changed to %lx\n", GetLastError());
4402
4403 cb_count = 0;
4404 SetLastError(0xdeadbeef);
4405 ok(!pResolveDelayLoadedAPI(NULL, NULL, failuredllhook, NULL, NULL, 0),
4406 "ResolveDelayLoadedAPI succeeded\n");
4407 ok(GetLastError() == 0xdeadbeef, "GetLastError changed to %lx\n", GetLastError());
4408 ok(cb_count == 1, "Wrong callback count: %d\n", cb_count);
4409 }
4410
4411 GetTempPathA(MAX_PATH, temp_path);
4412 GetTempFileNameA(temp_path, "ldr", 0, dll_name);
4413 trace("creating %s\n", dll_name);
4414 hfile = CreateFileA(dll_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
4415 if (hfile == INVALID_HANDLE_VALUE)
4416 {
4417 ok(0, "could not create %s\n", dll_name);
4418 return;
4419 }
4420
4421 SetLastError(0xdeadbeef);
4422 ret = WriteFile(hfile, &dos_header, sizeof(dos_header), &dummy, NULL);
4423 ok(ret, "WriteFile error %ld\n", GetLastError());
4424
4425 nt_header = nt_header_template;
4426 nt_header.FileHeader.NumberOfSections = 2;
4427 nt_header.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER);
4428
4429 nt_header.OptionalHeader.SectionAlignment = 0x1000;
4430 nt_header.OptionalHeader.FileAlignment = 0x1000;
4431 nt_header.OptionalHeader.SizeOfImage = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x2200;
4432 nt_header.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt_header) + 2 * sizeof(IMAGE_SECTION_HEADER);
4433 nt_header.OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
4434 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress = 0x1000;
4435 nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].Size = 2 * sizeof(idd);
4436
4437 SetLastError(0xdeadbeef);
4438 ret = WriteFile(hfile, &nt_header, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), &dummy, NULL);
4439 ok(ret, "WriteFile error %ld\n", GetLastError());
4440
4441 SetLastError(0xdeadbeef);
4442 ret = WriteFile(hfile, &nt_header.OptionalHeader, sizeof(IMAGE_OPTIONAL_HEADER), &dummy, NULL);
4443 ok(ret, "WriteFile error %ld\n", GetLastError());
4444
4445 /* sections */
4446 section.PointerToRawData = nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress;
4447 section.VirtualAddress = nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress;
4448 section.Misc.VirtualSize = 0x1000;
4449 section.SizeOfRawData = 2 * sizeof(idd);
4450 section.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
4451 SetLastError(0xdeadbeef);
4452 ret = WriteFile(hfile, &section, sizeof(section), &dummy, NULL);
4453 ok(ret, "WriteFile error %ld\n", GetLastError());
4454
4455 section.PointerToRawData = 0x2000;
4456 section.VirtualAddress = 0x2000;
4457 i = ARRAY_SIZE(td);
4458 section.SizeOfRawData = sizeof(test_dll) + sizeof(hint) + sizeof(test_func) + sizeof(HMODULE) +
4459 2 * (i + 1) * sizeof(IMAGE_THUNK_DATA);
4460 ok(section.SizeOfRawData <= 0x1000, "Too much tests, add a new section!\n");
4461 section.Misc.VirtualSize = 0x1000;
4462 section.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
4463 SetLastError(0xdeadbeef);
4464 ret = WriteFile(hfile, &section, sizeof(section), &dummy, NULL);
4465 ok(ret, "WriteFile error %ld\n", GetLastError());
4466
4467 /* fill up to delay data */
4468 SetFilePointer( hfile, nt_header.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress, NULL, SEEK_SET );
4469
4470 /* delay data */
4471 idd.Attributes.AllAttributes = 1;
4472 idd.DllNameRVA = 0x2000;
4473 idd.ModuleHandleRVA = idd.DllNameRVA + sizeof(test_dll) + sizeof(hint) + sizeof(test_func);
4474 idd.ImportAddressTableRVA = idd.ModuleHandleRVA + sizeof(HMODULE);
4475 idd.ImportNameTableRVA = idd.ImportAddressTableRVA + (i + 1) * sizeof(IMAGE_THUNK_DATA);
4476 idd.BoundImportAddressTableRVA = 0;
4477 idd.UnloadInformationTableRVA = 0;
4478 idd.TimeDateStamp = 0;
4479
4480 SetLastError(0xdeadbeef);
4481 ret = WriteFile(hfile, &idd, sizeof(idd), &dummy, NULL);
4482 ok(ret, "WriteFile error %ld\n", GetLastError());
4483
4484 SetLastError(0xdeadbeef);
4485 ret = WriteFile(hfile, filler, sizeof(idd), &dummy, NULL);
4486 ok(ret, "WriteFile error %ld\n", GetLastError());
4487
4488 /* fill up to extended delay data */
4489 SetFilePointer( hfile, idd.DllNameRVA, NULL, SEEK_SET );
4490
4491 /* extended delay data */
4492 SetLastError(0xdeadbeef);
4493 ret = WriteFile(hfile, test_dll, sizeof(test_dll), &dummy, NULL);
4494 ok(ret, "WriteFile error %ld\n", GetLastError());
4495
4496 SetLastError(0xdeadbeef);
4497 ret = WriteFile(hfile, &hint, sizeof(hint), &dummy, NULL);
4498 ok(ret, "WriteFile error %ld\n", GetLastError());
4499
4500 SetLastError(0xdeadbeef);
4501 ret = WriteFile(hfile, test_func, sizeof(test_func), &dummy, NULL);
4502 ok(ret, "WriteFile error %ld\n", GetLastError());
4503
4504 SetFilePointer( hfile, idd.ImportAddressTableRVA, NULL, SEEK_SET );
4505
4506 for (i = 0; i < ARRAY_SIZE(td); i++)
4507 {
4508 /* 0x1a00 is an empty space between delay data and extended delay data, real thunks are not necessary */
4509 itd32.u1.Function = nt_header.OptionalHeader.ImageBase + 0x1a00 + i * 0x20;
4510 SetLastError(0xdeadbeef);
4511 ret = WriteFile(hfile, &itd32, sizeof(itd32), &dummy, NULL);
4512 ok(ret, "WriteFile error %ld\n", GetLastError());
4513 }
4514
4515 itd32.u1.Function = 0;
4516 SetLastError(0xdeadbeef);
4517 ret = WriteFile(hfile, &itd32, sizeof(itd32), &dummy, NULL);
4518 ok(ret, "WriteFile error %ld\n", GetLastError());
4519
4520 for (i = 0; i < ARRAY_SIZE(td); i++)
4521 {
4522 if (td[i].func)
4523 itd32.u1.AddressOfData = idd.DllNameRVA + sizeof(test_dll);
4524 else
4525 itd32.u1.Ordinal = td[i].ordinal;
4526 SetLastError(0xdeadbeef);
4527 ret = WriteFile(hfile, &itd32, sizeof(itd32), &dummy, NULL);
4528 ok(ret, "WriteFile error %ld\n", GetLastError());
4529 }
4530
4531 itd32.u1.Ordinal = 0;
4532 SetLastError(0xdeadbeef);
4533 ret = WriteFile(hfile, &itd32, sizeof(itd32), &dummy, NULL);
4534 ok(ret, "WriteFile error %ld\n", GetLastError());
4535
4536 /* fill up to eof */
4537 SetFilePointer( hfile, section.VirtualAddress + section.Misc.VirtualSize, NULL, SEEK_SET );
4538 SetEndOfFile( hfile );
4539 CloseHandle(hfile);
4540
4541 SetLastError(0xdeadbeef);
4542 hlib = LoadLibraryA(dll_name);
4543 ok(hlib != NULL, "LoadLibrary error %lu\n", GetLastError());
4544 if (!hlib)
4545 {
4546 skip("couldn't load %s.\n", dll_name);
4547 DeleteFileA(dll_name);
4548 return;
4549 }
4550
4551 delaydir = pRtlImageDirectoryEntryToData(hlib, TRUE, IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT, &file_size);
4552 if (!delaydir)
4553 {
4554 skip("haven't found section for delay import directory.\n");
4555 FreeLibrary(hlib);
4556 DeleteFileA(dll_name);
4557 return;
4558 }
4559
4560 for (;;)
4561 {
4562 IMAGE_THUNK_DATA *itdn, *itda;
4563 HMODULE htarget;
4564
4565 if (!delaydir->DllNameRVA ||
4566 !delaydir->ImportAddressTableRVA ||
4567 !delaydir->ImportNameTableRVA) break;
4568
4569 itdn = RVAToAddr(delaydir->ImportNameTableRVA, hlib);
4570 itda = RVAToAddr(delaydir->ImportAddressTableRVA, hlib);
4571 htarget = LoadLibraryA(RVAToAddr(delaydir->DllNameRVA, hlib));
4572
4573 for (i = 0; i < ARRAY_SIZE(td); i++)
4574 {
4575 void *ret, *load;
4576
4577 /* relocate thunk address by hand since we don't generate reloc records */
4578 itda[i].u1.AddressOfData += (char *)hlib - (char *)nt_header.OptionalHeader.ImageBase;
4579
4580 if (IMAGE_SNAP_BY_ORDINAL(itdn[i].u1.Ordinal))
4581 load = (void *)GetProcAddress(htarget, (LPSTR)IMAGE_ORDINAL(itdn[i].u1.Ordinal));
4582 else
4583 {
4584 const IMAGE_IMPORT_BY_NAME* iibn = RVAToAddr(itdn[i].u1.AddressOfData, hlib);
4585 load = (void *)GetProcAddress(htarget, (char*)iibn->Name);
4586 }
4587
4588 /* test without failure dll callback */
4589 cb_count = cb_count_sys = 0;
4590 ret = pResolveDelayLoadedAPI(hlib, delaydir, NULL, failuresyshook, &itda[i], 0);
4591 if (td[i].succeeds)
4592 {
4593 ok(ret != NULL, "Test %lu: ResolveDelayLoadedAPI failed\n", i);
4594 ok(ret == load, "Test %lu: expected %p, got %p\n", i, load, ret);
4595 ok(ret == (void*)itda[i].u1.AddressOfData, "Test %lu: expected %p, got %p\n",
4596 i, ret, (void*)itda[i].u1.AddressOfData);
4597 ok(!cb_count, "Test %lu: Wrong callback count: %d\n", i, cb_count);
4598 ok(!cb_count_sys, "Test %lu: Wrong sys callback count: %d\n", i, cb_count_sys);
4599 }
4600 else
4601 {
4602 ok(ret == (void*)0x12345678, "Test %lu: ResolveDelayLoadedAPI succeeded with %p\n", i, ret);
4603 ok(!cb_count, "Test %lu: Wrong callback count: %d\n", i, cb_count);
4604 ok(cb_count_sys == 1, "Test %lu: Wrong sys callback count: %d\n", i, cb_count_sys);
4605 }
4606
4607 /* test with failure dll callback */
4608 cb_count = cb_count_sys = 0;
4609 ret = pResolveDelayLoadedAPI(hlib, delaydir, failuredllhook, failuresyshook, &itda[i], 0);
4610 if (td[i].succeeds)
4611 {
4612 ok(ret != NULL, "Test %lu: ResolveDelayLoadedAPI failed\n", i);
4613 ok(ret == load, "Test %lu: expected %p, got %p\n", i, load, ret);
4614 ok(ret == (void*)itda[i].u1.AddressOfData, "Test %lu: expected %p, got %p\n",
4615 i, ret, (void*)itda[i].u1.AddressOfData);
4616 ok(!cb_count, "Test %lu: Wrong callback count: %d\n", i, cb_count);
4617 ok(!cb_count_sys, "Test %lu: Wrong sys callback count: %d\n", i, cb_count_sys);
4618 }
4619 else
4620 {
4621 if (ret == (void*)0x12345678)
4622 {
4623 /* Win10+ sometimes buffers the address of the stub function */
4624 ok(!cb_count, "Test %lu: Wrong callback count: %d\n", i, cb_count);
4625 ok(!cb_count_sys, "Test %lu: Wrong sys callback count: %d\n", i, cb_count_sys);
4626 }
4627 else if (ret == (void*)0xdeadbeef)
4628 {
4629 ok(cb_count == 1, "Test %lu: Wrong callback count: %d\n", i, cb_count);
4630 ok(!cb_count_sys, "Test %lu: Wrong sys callback count: %d\n", i, cb_count_sys);
4631 }
4632 else
4633 ok(0, "Test %lu: ResolveDelayLoadedAPI succeeded with %p\n", i, ret);
4634 }
4635 }
4636 delaydir++;
4637 }
4638
4639 FreeLibrary(hlib);
4640 trace("deleting %s\n", dll_name);
4641 DeleteFileA(dll_name);
4642}
4643
4644static void test_InMemoryOrderModuleList(void)
4645{
4646 PEB_LDR_DATA *ldr = NtCurrentTeb()->Peb->LdrData;
4647 LIST_ENTRY *entry1, *mark1 = &ldr->InLoadOrderModuleList;
4648 LIST_ENTRY *entry2, *mark2 = &ldr->InMemoryOrderModuleList;
4649 LDR_DATA_TABLE_ENTRY *module1, *module2;
4650
4651 ok(ldr->Initialized == TRUE, "expected TRUE, got %u\n", ldr->Initialized);
4652
4653 for (entry1 = mark1->Flink, entry2 = mark2->Flink;
4654 entry1 != mark1 && entry2 != mark2;
4655 entry1 = entry1->Flink, entry2 = entry2->Flink)
4656 {
4657 module1 = CONTAINING_RECORD(entry1, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
4658 module2 = CONTAINING_RECORD(entry2, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);
4659 ok(module1 == module2, "expected module1 == module2, got %p and %p\n", module1, module2);
4660 }
4661 ok(entry1 == mark1, "expected entry1 == mark1, got %p and %p\n", entry1, mark1);
4662 ok(entry2 == mark2, "expected entry2 == mark2, got %p and %p\n", entry2, mark2);
4663}
4664
4665static BOOL is_path_made_of(const char *filename, const char *pfx, const char *sfx)
4666{
4667 const size_t len = strlen(pfx);
4668 return !strncasecmp(filename, pfx, len) && filename[len] == '\\' &&
4669 !strcasecmp(filename + len + 1, sfx);
4670}
4671
4672static void test_wow64_redirection_for_dll(const char *libname, BOOL will_fail)
4673{
4674 HMODULE lib;
4675 char buf[256];
4676 const char *modname;
4677
4678 if (!GetModuleHandleA(libname))
4679 {
4680 lib = LoadLibraryExA(libname, NULL, 0);
4681 ok(lib != NULL, "Loading %s should succeed with WOW64 redirection disabled\n", libname);
4682 /* Win 7/2008R2 return the un-redirected path (i.e. c:\windows\system32\dwrite.dll), test loading it. */
4683 GetModuleFileNameA(lib, buf, sizeof(buf));
4684 FreeLibrary(lib);
4685 lib = LoadLibraryExA(buf, NULL, 0);
4686 ok(lib != NULL, "Loading %s from full path should succeed with WOW64 redirection disabled\n", libname);
4687 if (lib)
4688 FreeLibrary(lib);
4689 modname = strrchr(libname, '\\');
4690 modname = modname ? modname + 1 : libname;
4691 todo_wine_if(will_fail)
4692 ok(is_path_made_of(buf, system_dir, modname) ||
4693 /* Win7 report from syswow64 */ broken(is_path_made_of(buf, syswow_dir, modname)),
4694 "Unexpected loaded DLL name %s for %s\n", buf, libname);
4695 }
4696 else
4697 {
4698 skip("%s was already loaded in the process\n", libname);
4699 }
4700}
4701
4702static void test_wow64_redirection(void)
4703{
4704 void *OldValue;
4705 char buffer[MAX_PATH];
4706 static const char *dlls[] = {"wlanapi.dll", "dxgi.dll", "dwrite.dll"};
4707 unsigned i;
4708
4709 if (!is_wow64)
4710 return;
4711
4712 /* Disable FS redirection, then test loading system libraries (pick ones that shouldn't
4713 * already be loaded in this process).
4714 */
4715 ok(pWow64DisableWow64FsRedirection(&OldValue), "Disabling FS redirection failed\n");
4716 for (i = 0; i < ARRAY_SIZE(dlls); i++)
4717 {
4718 test_wow64_redirection_for_dll(dlls[i], FALSE);
4719 /* even absolute paths to syswow64 are loaded with path to system32 */
4720 snprintf(buffer, ARRAY_SIZE(buffer), "%s\\%s", syswow_dir, dlls[i]);
4721 test_wow64_redirection_for_dll(buffer, TRUE);
4722 }
4723
4724 ok(pWow64RevertWow64FsRedirection(OldValue), "Re-enabling FS redirection failed\n");
4725 /* and results don't depend whether redirection is enabled or not */
4726 for (i = 0; i < ARRAY_SIZE(dlls); i++)
4727 {
4728 test_wow64_redirection_for_dll(dlls[i], FALSE);
4729 snprintf(buffer, ARRAY_SIZE(buffer), "%s\\%s", syswow_dir, dlls[i]);
4730 test_wow64_redirection_for_dll(buffer, TRUE);
4731 }
4732}
4733
4734static void test_dll_file( const char *name )
4735{
4736 HMODULE module = GetModuleHandleA( name );
4737 IMAGE_NT_HEADERS *nt, *nt_file;
4738 IMAGE_SECTION_HEADER *sec, *sec_file;
4739 char path[MAX_PATH];
4740 HANDLE file, mapping;
4741 int i = 0;
4742 void *ptr;
4743
4744 GetModuleFileNameA( module, path, MAX_PATH );
4745 file = CreateFileA( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
4746 ok( file != INVALID_HANDLE_VALUE, "can't open '%s': %lu\n", path, GetLastError() );
4747
4748 mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 0, NULL );
4749 ok( mapping != NULL, "%s: CreateFileMappingW failed err %lu\n", name, GetLastError() );
4750 ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
4751 ok( ptr != NULL, "%s: MapViewOfFile failed err %lu\n", name, GetLastError() );
4752 CloseHandle( mapping );
4753 CloseHandle( file );
4754
4755 nt = pRtlImageNtHeader( module );
4756 nt_file = pRtlImageNtHeader( ptr );
4757 ok( nt_file != NULL, "%s: invalid header\n", path );
4758#define OK_FIELD(x, f) ok( nt->x == nt_file->x, "%s:%u: wrong " #x " " f " / " f "\n", name, i, nt->x, nt_file->x )
4759 OK_FIELD( FileHeader.NumberOfSections, "%x" );
4760 OK_FIELD( OptionalHeader.AddressOfEntryPoint, "%lx" );
4761 OK_FIELD( OptionalHeader.NumberOfRvaAndSizes, "%lx" );
4762 for (i = 0; i < nt->OptionalHeader.NumberOfRvaAndSizes; i++)
4763 {
4764 OK_FIELD( OptionalHeader.DataDirectory[i].VirtualAddress, "%lx" );
4765 OK_FIELD( OptionalHeader.DataDirectory[i].Size, "%lx" );
4766 }
4767 sec = IMAGE_FIRST_SECTION( nt );
4768 sec_file = IMAGE_FIRST_SECTION( nt_file );
4769 for (i = 0; i < nt->FileHeader.NumberOfSections; i++)
4770 ok( !memcmp( sec + i, sec_file + i, sizeof(*sec) ), "%s: wrong section %d\n", name, i );
4771 UnmapViewOfFile( ptr );
4772#undef OK_FIELD
4773}
4774
4775static void test_LoadPackagedLibrary(void)
4776{
4777 HMODULE h;
4778
4779 if (!pLoadPackagedLibrary)
4780 {
4781 win_skip("LoadPackagedLibrary is not available.\n");
4782 return;
4783 }
4784
4785 SetLastError( 0xdeadbeef );
4786 h = pLoadPackagedLibrary(L"kernel32.dll", 0);
4787 ok(!h && GetLastError() == APPMODEL_ERROR_NO_PACKAGE, "Got unexpected handle %p, GetLastError() %lu.\n",
4788 h, GetLastError());
4789}
4790
4791static void test_Wow64Transition(void)
4792{
4793 char buffer[400];
4794 MEMORY_SECTION_NAME *name = (MEMORY_SECTION_NAME *)buffer;
4795 const WCHAR *filepart;
4796 void **pWow64Transition;
4797 NTSTATUS status;
4798
4799 if (!(pWow64Transition = (void *)GetProcAddress(GetModuleHandleA("ntdll"), "Wow64Transition")))
4800 {
4801 skip("Wow64Transition is not present\n");
4802 return;
4803 }
4804 if (!is_wow64)
4805 {
4806 skip("Wow64Transition is not patched\n");
4807 return;
4808 }
4809
4810 status = NtQueryVirtualMemory(GetCurrentProcess(), *pWow64Transition,
4811 MemoryMappedFilenameInformation, name, sizeof(buffer), NULL);
4812 ok(!status, "got %#lx\n", status);
4813 filepart = name->SectionFileName.Buffer + name->SectionFileName.Length / sizeof(WCHAR);
4814 while (*filepart != '\\') --filepart;
4815 ok(!wcsnicmp(filepart, L"\\wow64cpu.dll", wcslen(L"\\wow64cpu.dll")), "got file name %s\n",
4816 debugstr_wn(name->SectionFileName.Buffer, name->SectionFileName.Length / sizeof(WCHAR)));
4817}
4818
4819START_TEST(loader)
4820{
4821 int argc;
4822 char **argv;
4823 HANDLE ntdll, mapping, kernel32;
4824 SYSTEM_INFO si;
4825 DWORD len;
4826
4827 ntdll = GetModuleHandleA("ntdll.dll");
4828 kernel32 = GetModuleHandleA("kernel32.dll");
4829 pNtCreateSection = (void *)GetProcAddress(ntdll, "NtCreateSection");
4830 pNtQuerySection = (void *)GetProcAddress(ntdll, "NtQuerySection");
4831 pNtMapViewOfSection = (void *)GetProcAddress(ntdll, "NtMapViewOfSection");
4832 pNtUnmapViewOfSection = (void *)GetProcAddress(ntdll, "NtUnmapViewOfSection");
4833 pNtTerminateProcess = (void *)GetProcAddress(ntdll, "NtTerminateProcess");
4834 pNtQueryInformationProcess = (void *)GetProcAddress(ntdll, "NtQueryInformationProcess");
4835 pNtSetInformationProcess = (void *)GetProcAddress(ntdll, "NtSetInformationProcess");
4836 pLdrShutdownProcess = (void *)GetProcAddress(ntdll, "LdrShutdownProcess");
4837 pRtlDllShutdownInProgress = (void *)GetProcAddress(ntdll, "RtlDllShutdownInProgress");
4838 pNtAllocateVirtualMemory = (void *)GetProcAddress(ntdll, "NtAllocateVirtualMemory");
4839 pNtFreeVirtualMemory = (void *)GetProcAddress(ntdll, "NtFreeVirtualMemory");
4840 pLdrLockLoaderLock = (void *)GetProcAddress(ntdll, "LdrLockLoaderLock");
4841 pLdrUnlockLoaderLock = (void *)GetProcAddress(ntdll, "LdrUnlockLoaderLock");
4842 pLdrLoadDll = (void *)GetProcAddress(ntdll, "LdrLoadDll");
4843 pLdrUnloadDll = (void *)GetProcAddress(ntdll, "LdrUnloadDll");
4844 pRtlInitUnicodeString = (void *)GetProcAddress(ntdll, "RtlInitUnicodeString");
4845 pRtlAcquirePebLock = (void *)GetProcAddress(ntdll, "RtlAcquirePebLock");
4846 pRtlReleasePebLock = (void *)GetProcAddress(ntdll, "RtlReleasePebLock");
4847 pRtlImageDirectoryEntryToData = (void *)GetProcAddress(ntdll, "RtlImageDirectoryEntryToData");
4848 pRtlImageNtHeader = (void *)GetProcAddress(ntdll, "RtlImageNtHeader");
4849 pLdrRegisterDllNotification = (void *)GetProcAddress(ntdll, "LdrRegisterDllNotification");
4850 pFlsAlloc = (void *)GetProcAddress(kernel32, "FlsAlloc");
4851 pFlsSetValue = (void *)GetProcAddress(kernel32, "FlsSetValue");
4852 pFlsGetValue = (void *)GetProcAddress(kernel32, "FlsGetValue");
4853 pFlsFree = (void *)GetProcAddress(kernel32, "FlsFree");
4854 pIsWow64Process = (void *)GetProcAddress(kernel32, "IsWow64Process");
4855 pWow64DisableWow64FsRedirection = (void *)GetProcAddress(kernel32, "Wow64DisableWow64FsRedirection");
4856 pWow64RevertWow64FsRedirection = (void *)GetProcAddress(kernel32, "Wow64RevertWow64FsRedirection");
4857 pResolveDelayLoadedAPI = (void *)GetProcAddress(kernel32, "ResolveDelayLoadedAPI");
4858 pLoadPackagedLibrary = (void *)GetProcAddress(kernel32, "LoadPackagedLibrary");
4859
4860 if (pIsWow64Process) pIsWow64Process( GetCurrentProcess(), &is_wow64 );
4861 GetSystemInfo( &si );
4862 page_size = si.dwPageSize;
4863 dos_header.e_magic = IMAGE_DOS_SIGNATURE;
4864 dos_header.e_lfanew = sizeof(dos_header);
4865
4866 mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_loader");
4867 ok(mapping != 0, "CreateFileMapping failed\n");
4868 child_failures = MapViewOfFile(mapping, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, 4096);
4869 if (*child_failures == -1)
4870 {
4871 *child_failures = 0;
4872 }
4873 else
4874 *child_failures = -1;
4875
4876 argc = winetest_get_mainargs(&argv);
4877 if (argc > 4)
4878 {
4879 test_dll_phase = atoi(argv[4]);
4880 child_process(argv[2], atol(argv[3]));
4881 return;
4882 }
4883
4884 len = GetSystemDirectoryA(system_dir, ARRAY_SIZE(system_dir));
4885 ok(len && len < ARRAY_SIZE(system_dir), "Couldn't get system directory: %lu\n", GetLastError());
4886 if (is_wow64)
4887 {
4888 len = GetSystemWow64DirectoryA(syswow_dir, ARRAY_SIZE(syswow_dir));
4889 ok(len && len < ARRAY_SIZE(syswow_dir), "Couldn't get wow directory: %lu\n", GetLastError());
4890 }
4891
4892 test_filenames();
4893 test_ResolveDelayLoadedAPI();
4894 test_ImportDescriptors();
4895 test_section_access();
4896 test_import_resolution();
4897 test_export_forwarder_dep_chain();
4898 test_ExitProcess();
4899 test_InMemoryOrderModuleList();
4900 test_LoadPackagedLibrary();
4901 test_wow64_redirection();
4902 test_dll_file( "ntdll.dll" );
4903 test_dll_file( "kernel32.dll" );
4904 test_dll_file( "advapi32.dll" );
4905 test_dll_file( "user32.dll" );
4906 test_Wow64Transition();
4907 /* loader test must be last, it can corrupt the internal loader state on Windows */
4908 test_Loader();
4909}
NtUnmapViewOfSection
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3483
mod
std::map< E_MODULE, HMODULE > mod
Definition: LocaleTests.cpp:66
argc
static int argc
Definition: ServiceArgs.c:12
expect
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17
dir
unsigned int dir
Definition: maze.c:112
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
trace
#define trace
Definition: atltest.h:70
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
broken
#define broken(x)
Definition: atltest.h:178
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
index
#define index(s, c)
Definition: various.h:29
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
thread
static HANDLE thread
Definition: service.c:33
ProcessBasicInformation
@ ProcessBasicInformation
Definition: cicbase.cpp:63
map
Definition: _map.h:48
STATUS_ILLEGAL_INSTRUCTION
#define STATUS_ILLEGAL_INSTRUCTION
Definition: d3dkmdt.h:41
module_name
static LPCWSTR LPCWSTR module_name
Definition: db.cpp:171
WAIT_TIMEOUT
#define WAIT_TIMEOUT
Definition: dderror.h:14
ERROR_INVALID_FUNCTION
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
mod2
#define mod2(n)
Definition: vgavideo.h:71
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
NTSTATUS
#define NTSTATUS
Definition: precomp.h:19
reason
static WCHAR reason[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1904
CloseHandle
#define CloseHandle
Definition: compat.h:739
IMAGE_DIRECTORY_ENTRY_EXPORT
#define IMAGE_DIRECTORY_ENTRY_EXPORT
Definition: compat.h:151
ReadProcessMemory
#define ReadProcessMemory(a, b, c, d, e)
Definition: compat.h:758
IMAGE_FILE_MACHINE_ARMNT
#define IMAGE_FILE_MACHINE_ARMNT
Definition: compat.h:127
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
ERROR_INVALID_ADDRESS
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
PAGE_READONLY
#define PAGE_READONLY
Definition: compat.h:138
FILE_BEGIN
#define FILE_BEGIN
Definition: compat.h:761
SECTION_MAP_READ
#define SECTION_MAP_READ
Definition: compat.h:139
DLL_THREAD_DETACH
#define DLL_THREAD_DETACH
Definition: compat.h:133
DLL_PROCESS_ATTACH
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
DLL_PROCESS_DETACH
#define DLL_PROCESS_DETACH
Definition: compat.h:130
wcsnicmp
#define wcsnicmp
Definition: compat.h:14
UnmapViewOfFile
#define UnmapViewOfFile
Definition: compat.h:746
CP_ACP
#define CP_ACP
Definition: compat.h:109
GetEnvironmentVariableW
#define GetEnvironmentVariableW(x, y, z)
Definition: compat.h:755
OPEN_EXISTING
#define OPEN_EXISTING
Definition: compat.h:775
SetFilePointer
#define SetFilePointer
Definition: compat.h:743
SetLastError
#define SetLastError(x)
Definition: compat.h:752
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
CreateFileMappingW
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:744
CreateFileA
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
FreeLibrary
#define FreeLibrary(x)
Definition: compat.h:748
GetCurrentProcess
#define GetCurrentProcess()
Definition: compat.h:759
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
ERROR_NOT_SUPPORTED
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
ERROR_INVALID_HANDLE
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
FILE_MAP_READ
#define FILE_MAP_READ
Definition: compat.h:776
IMAGE_FILE_MACHINE_ARM64
#define IMAGE_FILE_MACHINE_ARM64
Definition: compat.h:129
FILE_ATTRIBUTE_NORMAL
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
CALLBACK
#define CALLBACK
Definition: compat.h:35
lstrcpyW
#define lstrcpyW
Definition: compat.h:749
DLL_THREAD_ATTACH
#define DLL_THREAD_ATTACH
Definition: compat.h:132
MapViewOfFile
#define MapViewOfFile
Definition: compat.h:745
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
ERROR_ACCESS_DENIED
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:136
wcsicmp
#define wcsicmp
Definition: compat.h:15
lstrlenW
#define lstrlenW
Definition: compat.h:750
DebugActiveProcess
BOOL WINAPI DebugActiveProcess(IN DWORD dwProcessId)
Definition: debugger.c:445
WaitForDebugEvent
BOOL WINAPI WaitForDebugEvent(IN LPDEBUG_EVENT lpDebugEvent, IN DWORD dwMilliseconds)
Definition: debugger.c:590
SetErrorMode
UINT WINAPI SetErrorMode(IN UINT uMode)
Definition: except.c:751
CopyFileW
BOOL WINAPI CopyFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:439
DeleteFileA
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
DeleteFileW
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
CreateDirectoryW
BOOL WINAPI CreateDirectoryW(IN LPCWSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:90
RemoveDirectoryW
BOOL WINAPI RemoveDirectoryW(IN LPCWSTR lpPathName)
Definition: dir.c:732
SetEndOfFile
BOOL WINAPI SetEndOfFile(HANDLE hFile)
Definition: fileinfo.c:1004
GetFileSize
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:331
SetFilePointerEx
BOOL WINAPI SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod)
Definition: fileinfo.c:177
MoveFileA
BOOL WINAPI MoveFileA(IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName)
Definition: move.c:1137
MoveFileW
BOOL WINAPI MoveFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName)
Definition: move.c:1104
WriteFile
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
DuplicateHandle
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
LoadLibraryExA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryExA(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
Definition: loader.c:159
GetModuleFileNameW
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
GetModuleFileNameA
DWORD WINAPI GetModuleFileNameA(HINSTANCE hModule, LPSTR lpFilename, DWORD nSize)
Definition: loader.c:539
GetSystemWow64DirectoryA
UINT WINAPI GetSystemWow64DirectoryA(OUT LPSTR lpBuffer, IN UINT uSize)
Definition: path.c:2438
GetShortPathNameA
DWORD WINAPI GetShortPathNameA(IN LPCSTR lpszLongPath, OUT LPSTR lpszShortPath, IN DWORD cchBuffer)
Definition: path.c:1752
GetTempPathW
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2080
GetTempPathA
DWORD WINAPI GetTempPathA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2054
GetSystemDirectoryA
UINT WINAPI GetSystemDirectoryA(OUT LPSTR lpBuffer, IN UINT uSize)
Definition: path.c:2283
QueryPerformanceCounter
BOOL WINAPI QueryPerformanceCounter(OUT PLARGE_INTEGER lpPerformanceCount)
Definition: perfcnt.c:23
GetExitCodeProcess
BOOL WINAPI GetExitCodeProcess(IN HANDLE hProcess, IN LPDWORD lpExitCode)
Definition: proc.c:1168
ExitProcess
VOID WINAPI ExitProcess(IN UINT uExitCode)
Definition: proc.c:1489
CreateProcessA
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4749
TerminateProcess
BOOL WINAPI TerminateProcess(IN HANDLE hProcess, IN UINT uExitCode)
Definition: proc.c:1534
OpenProcess
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
GetSystemInfo
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:143
SetThreadPriority
BOOL WINAPI SetThreadPriority(IN HANDLE hThread, IN int nPriority)
Definition: thread.c:700
CreateRemoteThread
HANDLE WINAPI CreateRemoteThread(IN HANDLE hProcess, IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:159
SetThreadContext
BOOL WINAPI SetThreadContext(IN HANDLE hThread, IN CONST CONTEXT *lpContext)
Definition: thread.c:521
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
TerminateThread
BOOL WINAPI TerminateThread(IN HANDLE hThread, IN DWORD dwExitCode)
Definition: thread.c:587
GetExitCodeThread
BOOL WINAPI GetExitCodeThread(IN HANDLE hThread, OUT LPDWORD lpExitCode)
Definition: thread.c:541
GetThreadContext
BOOL WINAPI GetThreadContext(IN HANDLE hThread, OUT LPCONTEXT lpContext)
Definition: thread.c:501
lstrcmpiW
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4265
lstrcmpiA
int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4227
assert
#define assert(_expr)
Definition: assert.h:32
wcslen
_ACRTIMP size_t __cdecl wcslen(const wchar_t *)
Definition: wcs.c:2983
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2802
atol
_ACRTIMP __msvcrt_long __cdecl atol(const char *)
Definition: string.c:1782
atoi
_ACRTIMP int __cdecl atoi(const char *)
Definition: string.c:1715
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1592
strcmp
_ACRTIMP int __cdecl strcmp(const char *, const char *)
Definition: string.c:3319
strrchr
_ACRTIMP char *__cdecl strrchr(const char *, int)
Definition: string.c:3298
bsW
static const WCHAR bsW[]
Definition: filesystem.c:45
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
ret
return ret
Definition: mutex.c:146
L
#define L(x)
Definition: resources.c:13
affinity
KAFFINITY affinity
Definition: wave.h:2
INFINITE
#define INFINITE
Definition: serial.h:102
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
PUNICODE_STRING
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
strncasecmp
#define strncasecmp
Definition: fake.h:10
strcasecmp
#define strcasecmp
Definition: fake.h:9
CreateFileMappingA
HANDLE NTAPI CreateFileMappingA(IN HANDLE hFile, IN LPSECURITY_ATTRIBUTES lpFileMappingAttributes, IN DWORD flProtect, IN DWORD dwMaximumSizeHigh, IN DWORD dwMaximumSizeLow, IN LPCSTR lpName)
Definition: filemap.c:23
GetTempFileNameW
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
GetTempFileNameA
UINT WINAPI GetTempFileNameA(IN LPCSTR lpPathName, IN LPCSTR lpPrefixString, IN UINT uUnique, OUT LPSTR lpTempFileName)
Definition: filename.c:26
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
IMAGE_FILE_HEADER
struct _IMAGE_FILE_HEADER IMAGE_FILE_HEADER
IMAGE_NUMBEROF_DIRECTORY_ENTRIES
#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES
Definition: ntddk_ex.h:135
PIMAGE_NT_HEADERS
PIMAGE_NT_HEADERS32 PIMAGE_NT_HEADERS
Definition: ntddk_ex.h:187
IMAGE_OPTIONAL_HEADER32
struct _IMAGE_OPTIONAL_HEADER IMAGE_OPTIONAL_HEADER32
PIMAGE_DOS_HEADER
struct _IMAGE_DOS_HEADER * PIMAGE_DOS_HEADER
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
start
GLuint start
Definition: gl.h:1545
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
image
GLeglImageOES image
Definition: gl.h:2204
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
func
GLenum func
Definition: glext.h:6028
event
struct _cl_event * event
Definition: glext.h:7739
res
GLuint res
Definition: glext.h:9613
names
GLuint GLuint * names
Definition: glext.h:11545
buffer
GLuint buffer
Definition: glext.h:5915
size
GLsizeiptr size
Definition: glext.h:5919
offset
GLintptr offset
Definition: glext.h:5920
index
GLuint index
Definition: glext.h:6031
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
addr
GLenum const GLvoid * addr
Definition: glext.h:9621
mapping
GLenum GLenum GLenum GLenum mapping
Definition: glext.h:9031
p
GLfloat GLfloat p
Definition: glext.h:8902
param
GLfloat param
Definition: glext.h:5796
len
GLenum GLsizei len
Definition: glext.h:6722
u1
GLdouble u1
Definition: glext.h:8308
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
HeapLock
BOOL WINAPI HeapLock(HANDLE hHeap)
Definition: heapmem.c:123
MemoryMappedFilenameInformation
@ MemoryMappedFilenameInformation
Definition: winternl.h:2387
ProcessAffinityMask
@ ProcessAffinityMask
Definition: winternl.h:1903
ProcessImageInformation
@ ProcessImageInformation
Definition: winternl.h:1919
filename
const char * filename
Definition: ioapi.h:137
NtCurrentTeb
#define NtCurrentTeb
Definition: iphlpapi_private.h:4
entry
uint32_t entry
Definition: isohybrid.c:63
SEEK_SET
#define SEEK_SET
Definition: jmemansi.c:26
debugstr_wn
#define debugstr_wn
Definition: kernel32.h:33
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
LDR_DLL_NOTIFICATION_REASON_LOADED
#define LDR_DLL_NOTIFICATION_REASON_LOADED
Definition: ldrtypes.h:203
if
if(dx< 0)
Definition: linetemp.h:194
lstrcatW
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
winetest_debug
int winetest_debug
winetest_push_context
void __cdecl void __cdecl void __cdecl void __cdecl void __cdecl winetest_push_context(const char *fmt,...) __WINE_PRINTF_ATTR(1
win_skip
#define win_skip
Definition: minitest.h:67
winetest_get_failures
LONG winetest_get_failures(void)
todo_wine_if
#define todo_wine_if(is_todo)
Definition: minitest.h:81
winetest_pop_context
void __cdecl void __cdecl void __cdecl void __cdecl void __cdecl void winetest_pop_context(void)
winetest_add_failures
void winetest_add_failures(LONG new_failures)
todo_wine
#define todo_wine
Definition: minitest.h:80
STILL_ACTIVE
#define STILL_ACTIVE
Definition: minwinbase.h:43
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
CREATE_ALWAYS
#define CREATE_ALWAYS
Definition: disk.h:72
FILE_FLAG_DELETE_ON_CLOSE
#define FILE_FLAG_DELETE_ON_CLOSE
Definition: disk.h:42
CREATE_NEW
#define CREATE_NEW
Definition: disk.h:69
nt_header
static IMAGE_NT_HEADERS32 nt_header
Definition: data.c:36
ptr
static PVOID ptr
Definition: dispmode.c:27
sprintf
#define sprintf
Definition: sprintf.c:45
hmod
static PEXPLICIT_ACCESSW *static HMODULE hmod
Definition: security.c:143
hinst
static HINSTANCE hinst
Definition: edit.c:551
expected
BOOL expected
Definition: store.c:2000
ntdll
static HMODULE ntdll
Definition: debugger.c:59
pi
static PROCESS_INFORMATION pi
Definition: debugger.c:2303
inside_loader_lock
static int inside_loader_lock
Definition: loader.c:2950
ACCESS_MASK
static ACCESS_MASK
Definition: loader.c:60
cb_count_sys
static WORD cb_count_sys
Definition: loader.c:53
section
static IMAGE_SECTION_HEADER section
Definition: loader.c:164
get_com_dir_size
static UINT get_com_dir_size(const IMAGE_NT_HEADERS *nt)
Definition: loader.c:602
failuresyshook
static PVOID WINAPI failuresyshook(const char *dll, const char *function)
Definition: loader.c:4343
RVAToAddr
static void void **static PVOID RVAToAddr(DWORD_PTR rva, HMODULE module)
Definition: loader.c:95
test_dll_phase
static int test_dll_phase
Definition: loader.c:2950
HANDLE
static const OBJECT_ATTRIBUTES const LARGE_INTEGER HANDLE
Definition: loader.c:61
SIZE_T
static void SIZE_T
Definition: loader.c:62
test_LoadPackagedLibrary
static void test_LoadPackagedLibrary(void)
Definition: loader.c:4775
peb_lock_event
static HANDLE peb_lock_event
Definition: loader.c:2948
semaphore
static HANDLE semaphore
Definition: loader.c:2947
test_ImportDescriptors
static void test_ImportDescriptors(void)
Definition: loader.c:1619
wldr_nameW
static const WCHAR wldr_nameW[]
Definition: loader.c:555
Reserved
static DWORD Reserved
Definition: loader.c:92
PLDR_DLL_NOTIFICATION_FUNCTION
static PLDR_DLL_NOTIFICATION_FUNCTION
Definition: loader.c:93
test_export_forwarder_dep_chain
static void test_export_forwarder_dep_chain(void)
Definition: loader.c:2920
noop_thread_proc
static DWORD WINAPI noop_thread_proc(void *param)
Definition: loader.c:3030
system_dir
static char system_dir[MAX_PATH]
Definition: loader.c:57
fls_callback
static VOID WINAPI fls_callback(PVOID lpFlsData)
Definition: loader.c:3042
BOOL
static BOOL
Definition: loader.c:83
child_failures
static LONG * child_failures
Definition: loader.c:52
PCIMAGE_DELAYLOAD_DESCRIPTOR
static PCIMAGE_DELAYLOAD_DESCRIPTOR
Definition: loader.c:79
nt_header_template
static const IMAGE_NT_HEADERS nt_header_template
Definition: loader.c:104
PROCESS_ALL_ACCESS_NT4
#define PROCESS_ALL_ACCESS_NT4
Definition: loader.c:38
test_image_mapping
static void test_image_mapping(const char *dll_name, DWORD scn_page_access, BOOL is_dll)
Definition: loader.c:1673
filler
static const char filler[0x1000]
Definition: loader.c:179
inside_cs_lock
static int inside_cs_lock
Definition: loader.c:2950
query_image_section
static BOOL query_image_section(int id, const char *dll_name, const IMAGE_NT_HEADERS *nt_header, const void *section_data)
Definition: loader.c:334
is_path_made_of
static BOOL is_path_made_of(const char *filename, const char *pfx, const char *sfx)
Definition: loader.c:4665
heap_lock_event
static HANDLE heap_lock_event
Definition: loader.c:2948
ADD_RELOC
#define ADD_RELOC(field)
event
static HANDLE event
Definition: loader.c:2947
syswow_dir
static char syswow_dir[MAX_PATH]
Definition: loader.c:58
dos_header
static IMAGE_DOS_HEADER dos_header
Definition: loader.c:102
PDELAYLOAD_FAILURE_SYSTEM_ROUTINE
static PDELAYLOAD_FAILURE_SYSTEM_ROUTINE
Definition: loader.c:81
attached_thread
static HANDLE attached_thread[MAX_COUNT]
Definition: loader.c:2945
is_wow64
static BOOL is_wow64
Definition: loader.c:56
PROCESSINFOCLASS
static PROCESSINFOCLASS
Definition: loader.c:65
failuredllhook
static PVOID WINAPI failuredllhook(ULONG ul, DELAYLOAD_INFO *pd)
Definition: loader.c:4290
dll_entry_point
static BOOL WINAPI dll_entry_point(HINSTANCE hinst, DWORD reason, LPVOID param)
Definition: loader.c:3069
cb_count
static WORD cb_count
Definition: loader.c:53
loader_lock_event
static HANDLE loader_lock_event
Definition: loader.c:2948
load_path
static WCHAR load_path[MAX_PATH]
Definition: loader.c:557
ack_event
static HANDLE ack_event
Definition: loader.c:2948
subtest_export_forwarder_dep_chain
static void subtest_export_forwarder_dep_chain(size_t num_chained_export_modules, size_t exporter_index, BOOL test_static_import)
Definition: loader.c:2757
fls_list_head
static LIST_ENTRY * fls_list_head
Definition: loader.c:3048
test_dll_file
static void test_dll_file(const char *name)
Definition: loader.c:4734
WORD
static WORD
Definition: loader.c:83
DWORD
static DWORD
Definition: loader.c:67
ThunkAddress
static PIMAGE_THUNK_DATA ThunkAddress
Definition: loader.c:82
PBOOL
static PBOOL
Definition: loader.c:89
stop_event
static HANDLE stop_event
Definition: loader.c:2948
get_alt_bitness_machine
static WORD get_alt_bitness_machine(WORD orig_machine)
Definition: loader.c:196
inside_heap_lock
static int inside_heap_lock
Definition: loader.c:2950
inside_peb_lock
static int inside_peb_lock
Definition: loader.c:2950
DATA_RVA
#define DATA_RVA(ptr)
PDELAYLOAD_FAILURE_DLL_CALLBACK
static PDELAYLOAD_FAILURE_DLL_CALLBACK
Definition: loader.c:80
gen_forward_chain_testdll
static HANDLE gen_forward_chain_testdll(char testdll_path[MAX_PATH], const char source_dll[MAX_PATH], BOOL is_export, BOOL is_import, DWORD *exp_func_base_rva, DWORD *imp_thunk_base_rva)
Definition: loader.c:2502
SECTION_INFORMATION_CLASS
static SECTION_INFORMATION_CLASS
Definition: loader.c:62
test_ExitProcess
static void test_ExitProcess(void)
Definition: loader.c:3788
delete_load_path
static void delete_load_path(void)
Definition: loader.c:588
test_ResolveDelayLoadedAPI
static void test_ResolveDelayLoadedAPI(void)
Definition: loader.c:4351
map_image_section
static NTSTATUS map_image_section(const IMAGE_NT_HEADERS *nt_header, const IMAGE_SECTION_HEADER *sections, const void *section_data, int line)
Definition: loader.c:613
test_wow64_redirection_for_dll
static void test_wow64_redirection_for_dll(const char *libname, BOOL will_fail)
Definition: loader.c:4672
cs_lock
static CRITICAL_SECTION cs_lock
Definition: loader.c:2949
LPCWSTR
static LPCWSTR
Definition: loader.c:76
test_Loader
static void test_Loader(void)
Definition: loader.c:761
test_section_access
static void test_section_access(void)
Definition: loader.c:1920
test_InMemoryOrderModuleList
static void test_InMemoryOrderModuleList(void)
Definition: loader.c:4644
tls_init_fn_output
static int tls_init_fn_output
Definition: loader.c:2169
check_tls_index
static void check_tls_index(HANDLE dll, BOOL tls_initialized)
Definition: loader.c:2142
test_filenames
static void test_filenames(void)
Definition: loader.c:1539
create_test_dll_sections
static DWORD create_test_dll_sections(const IMAGE_DOS_HEADER *dos_header, const IMAGE_NT_HEADERS *nt_header, const IMAGE_SECTION_HEADER *sections, const void *section_data, char dll_name[MAX_PATH])
Definition: loader.c:293
OK_FIELD
#define OK_FIELD(x, f)
load_fallback_name
static WCHAR load_fallback_name[MAX_PATH]
Definition: loader.c:556
create_test_dll
static DWORD create_test_dll(const IMAGE_DOS_HEADER *dos_header, UINT dos_size, const IMAGE_NT_HEADERS *nt_header, char dll_name[MAX_PATH])
Definition: loader.c:208
cs_lock_event
static HANDLE cs_lock_event
Definition: loader.c:2948
init_load_path
static void init_load_path(const char *fallback_dll)
Definition: loader.c:559
fls_callback_count
static LONG fls_callback_count
Definition: loader.c:2951
load_test_name
static WCHAR load_test_name[MAX_PATH]
Definition: loader.c:556
semaphore_thread_proc
static DWORD WINAPI semaphore_thread_proc(void *param)
Definition: loader.c:3010
ALIGN_SIZE
#define ALIGN_SIZE(size, alignment)
Definition: loader.c:40
MAX_COUNT
#define MAX_COUNT
Definition: loader.c:2944
attached_thread_count
static DWORD attached_thread_count
Definition: loader.c:2946
is_win64
static BOOL is_win64
Definition: loader.c:55
test_import_resolution
static void test_import_resolution(void)
Definition: loader.c:2182
check_linked_list
static unsigned int check_linked_list(const LIST_ENTRY *le, const LIST_ENTRY *search_entry, unsigned int *index_found)
Definition: loader.c:3050
mutex_thread_proc
static DWORD WINAPI mutex_thread_proc(void *param)
Definition: loader.c:2953
ldr_notify_callback
static void CALLBACK ldr_notify_callback(ULONG reason, LDR_DLL_NOTIFICATION_DATA *data, void *context)
Definition: loader.c:3465
is_mem_writable
static BOOL is_mem_writable(DWORD prot)
Definition: loader.c:1777
mutex
static HANDLE mutex
Definition: loader.c:2947
test_wow64_redirection
static void test_wow64_redirection(void)
Definition: loader.c:4702
tls_thread_fn
static DWORD WINAPI tls_thread_fn(void *tlsidx_v)
Definition: loader.c:2171
test_Wow64Transition
static void test_Wow64Transition(void)
Definition: loader.c:4791
PULONG
static PULONG
Definition: loader.c:65
get_alt_machine
static WORD get_alt_machine(WORD orig_machine)
Definition: loader.c:183
section_data
static const char section_data[0x10]
Definition: loader.c:180
page_size
static DWORD page_size
Definition: loader.c:54
nt
IMAGE_NT_HEADERS nt
Definition: module.c:68
pathW
static const WCHAR pathW[]
Definition: path.c:2368
si
static SYSTEM_INFO si
Definition: virtual.c:39
test_VirtualProtect
static void test_VirtualProtect(void)
Definition: virtual.c:3269
test_func
static void test_func(IDispatchEx *obj)
Definition: script.c:1872
sections
struct section sections[2]
Definition: diskspace.c:792
child_process
static HANDLE child_process
Definition: cursoricon.c:300
argv
#define argv
Definition: mplay32.c:18
load
int load
Definition: msacm.c:1365
temp_path
char temp_path[MAX_PATH]
Definition: mspatcha.c:123
UINT_PTR
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
UINT
unsigned int UINT
Definition: ndis.h:50
SEC_IMAGE
#define SEC_IMAGE
Definition: mmtypes.h:97
SEC_FILE
#define SEC_FILE
Definition: mmtypes.h:96
SectionBasicInformation
@ SectionBasicInformation
Definition: mmtypes.h:195
SectionImageInformation
@ SectionImageInformation
Definition: mmtypes.h:196
SEM_FAILCRITICALERRORS
#define SEM_FAILCRITICALERRORS
Definition: rtltypes.h:69
FILE_SHARE_WRITE
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
PAGE_WRITECOPY
#define PAGE_WRITECOPY
Definition: nt_native.h:1308
MEM_FREE
#define MEM_FREE
Definition: nt_native.h:1320
PAGE_READWRITE
#define PAGE_READWRITE
Definition: nt_native.h:1307
PAGE_EXECUTE_READ
#define PAGE_EXECUTE_READ
Definition: nt_native.h:1310
SECTION_QUERY
#define SECTION_QUERY
Definition: nt_native.h:1290
PAGE_EXECUTE
#define PAGE_EXECUTE
Definition: nt_native.h:1309
CONTEXT_INTEGER
#define CONTEXT_INTEGER
Definition: nt_native.h:1373
FILE_SHARE_DELETE
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
PAGE_EXECUTE_WRITECOPY
#define PAGE_EXECUTE_WRITECOPY
Definition: nt_native.h:1312
DELETE
#define DELETE
Definition: nt_native.h:57
MEM_RESERVE
#define MEM_RESERVE
Definition: nt_native.h:1317
MEM_RELEASE
#define MEM_RELEASE
Definition: nt_native.h:1319
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
MEM_COMMIT
#define MEM_COMMIT
Definition: nt_native.h:1316
PAGE_NOACCESS
#define PAGE_NOACCESS
Definition: nt_native.h:1305
PAGE_EXECUTE_READWRITE
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1311
STANDARD_RIGHTS_REQUIRED
#define STANDARD_RIGHTS_REQUIRED
Definition: nt_native.h:63
IMAGE_SCN_MEM_WRITE
#define IMAGE_SCN_MEM_WRITE
Definition: ntimage.h:241
IMAGE_SNAP_BY_ORDINAL
#define IMAGE_SNAP_BY_ORDINAL(Ordinal)
Definition: ntimage.h:567
IMAGE_OPTIONAL_HEADER64
struct _IMAGE_OPTIONAL_HEADER64 IMAGE_OPTIONAL_HEADER64
IMAGE_NT_OPTIONAL_HDR32_MAGIC
#define IMAGE_NT_OPTIONAL_HDR32_MAGIC
Definition: ntimage.h:376
IMAGE_SUBSYSTEM_WINDOWS_CUI
#define IMAGE_SUBSYSTEM_WINDOWS_CUI
Definition: ntimage.h:438
IMAGE_DLLCHARACTERISTICS_NX_COMPAT
#define IMAGE_DLLCHARACTERISTICS_NX_COMPAT
Definition: ntimage.h:457
IMAGE_SCN_CNT_INITIALIZED_DATA
#define IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: ntimage.h:231
IMAGE_NT_OPTIONAL_HDR64_MAGIC
#define IMAGE_NT_OPTIONAL_HDR64_MAGIC
Definition: ntimage.h:377
IMAGE_SCN_CNT_CODE
#define IMAGE_SCN_CNT_CODE
Definition: ntimage.h:230
IMAGE_SCN_MEM_EXECUTE
#define IMAGE_SCN_MEM_EXECUTE
Definition: ntimage.h:239
IMAGE_FIRST_SECTION
#define IMAGE_FIRST_SECTION(NtHeader)
Definition: ntimage.h:427
IMAGE_FILE_MACHINE_AMD64
#define IMAGE_FILE_MACHINE_AMD64
Definition: ntimage.h:17
IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR
#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR
Definition: ntimage.h:489
IMAGE_SCN_MEM_READ
#define IMAGE_SCN_MEM_READ
Definition: ntimage.h:240
IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT
Definition: ntimage.h:488
IMAGE_SCN_CNT_UNINITIALIZED_DATA
#define IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition: ntimage.h:232
IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
#define IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
Definition: ntimage.h:455
IMAGE_NT_OPTIONAL_HDR_MAGIC
#define IMAGE_NT_OPTIONAL_HDR_MAGIC
Definition: ntimage.h:387
NtQueryVirtualMemory
NTSTATUS NTAPI NtQueryVirtualMemory(IN HANDLE ProcessHandle, IN PVOID BaseAddress, IN MEMORY_INFORMATION_CLASS MemoryInformationClass, OUT PVOID MemoryInformation, IN SIZE_T MemoryInformationLength, OUT PSIZE_T ReturnLength)
Definition: virtual.c:4374
NtQueryInformationProcess
NTSTATUS NTAPI NtQueryInformationProcess(_In_ HANDLE ProcessHandle, _In_ PROCESSINFOCLASS ProcessInformationClass, _Out_writes_bytes_to_opt_(ProcessInformationLength, *ReturnLength) PVOID ProcessInformation, _In_ ULONG ProcessInformationLength, _Out_opt_ PULONG ReturnLength)
Definition: query.c:211
STATUS_INVALID_IMAGE_WIN_64
#define STATUS_INVALID_IMAGE_WIN_64
Definition: ntstatus.h:1029
STATUS_INVALID_IMAGE_WIN_16
#define STATUS_INVALID_IMAGE_WIN_16
Definition: ntstatus.h:635
STATUS_INVALID_IMAGE_NE_FORMAT
#define STATUS_INVALID_IMAGE_NE_FORMAT
Definition: ntstatus.h:613
STATUS_INVALID_IMAGE_FORMAT
#define STATUS_INVALID_IMAGE_FORMAT
Definition: ntstatus.h:453
STATUS_INVALID_IMAGE_NOT_MZ
#define STATUS_INVALID_IMAGE_NOT_MZ
Definition: ntstatus.h:633
STATUS_INVALID_IMAGE_PROTECT
#define STATUS_INVALID_IMAGE_PROTECT
Definition: ntstatus.h:634
STATUS_PROCESS_IS_TERMINATING
#define STATUS_PROCESS_IS_TERMINATING
Definition: ntstatus.h:596
STATUS_DLL_INIT_FAILED
#define STATUS_DLL_INIT_FAILED
Definition: ntstatus.h:652
STATUS_SECTION_TOO_BIG
#define STATUS_SECTION_TOO_BIG
Definition: ntstatus.h:394
STATUS_IMAGE_NOT_AT_BASE
#define STATUS_IMAGE_NOT_AT_BASE
Definition: ntstatus.h:192
proc
static HANDLE proc()
Definition: pdb.c:34
LOWORD
#define LOWORD(l)
Definition: pedump.c:82
IMAGE_FILE_EXECUTABLE_IMAGE
#define IMAGE_FILE_EXECUTABLE_IMAGE
Definition: pedump.c:160
IMAGE_DIRECTORY_ENTRY_IMPORT
#define IMAGE_DIRECTORY_ENTRY_IMPORT
Definition: pedump.c:260
IMAGE_FILE_MACHINE_I386
#define IMAGE_FILE_MACHINE_I386
Definition: pedump.c:174
IMAGE_ORDINAL_FLAG
#define IMAGE_ORDINAL_FLAG
Definition: pedump.c:336
IMAGE_FILE_MACHINE_UNKNOWN
#define IMAGE_FILE_MACHINE_UNKNOWN
Definition: pedump.c:173
IMAGE_OPTIONAL_HEADER
struct _IMAGE_OPTIONAL_HEADER IMAGE_OPTIONAL_HEADER
BOOLEAN
#define BOOLEAN
Definition: pedump.c:73
IMAGE_DIRECTORY_ENTRY_BASERELOC
#define IMAGE_DIRECTORY_ENTRY_BASERELOC
Definition: pedump.c:264
IMAGE_NT_SIGNATURE
#define IMAGE_NT_SIGNATURE
Definition: pedump.c:93
IMAGE_FILE_DLL
#define IMAGE_FILE_DLL
Definition: pedump.c:169
SHORT
short SHORT
Definition: pedump.c:59
LONG
long LONG
Definition: pedump.c:60
IMAGE_OS2_SIGNATURE
#define IMAGE_OS2_SIGNATURE
Definition: pedump.c:90
IMAGE_DIRECTORY_ENTRY_TLS
#define IMAGE_DIRECTORY_ENTRY_TLS
Definition: pedump.c:268
USHORT
unsigned short USHORT
Definition: pedump.c:61
IMAGE_DOS_SIGNATURE
#define IMAGE_DOS_SIGNATURE
Definition: pedump.c:89
IMAGE_ORDINAL
#define IMAGE_ORDINAL(Ordinal)
Definition: pedump.c:337
IMAGE_SECTION_HEADER
struct _IMAGE_SECTION_HEADER IMAGE_SECTION_HEADER
thread_count
static uint32_t thread_count(IN pnfs_layout_state *state, IN enum pnfs_iomode iomode, IN uint64_t offset, IN uint64_t length)
Definition: pnfs_io.c:137
file_size
static unsigned int file_size
Definition: regtests2xml.c:47
test
#define test
Definition: rosglue.h:37
str
const WCHAR * str
Definition: rpc_transport.c:2696
offsetof
#define offsetof(TYPE, MEMBER)
Definition: sdbstringtable.c:26
strcpy
strcpy
Definition: string.h:131
wine_dbgstr_a
const char int int int static __inline const char * wine_dbgstr_a(const char *s)
Definition: debug.h:187
is_reactos
#define is_reactos()
Definition: test.h:1041
winetest_get_mainargs
int winetest_get_mainargs(char ***pargv)
tls_index
DWORD tls_index
descr
const char * descr
Definition: boot.c:45
memset
#define memset(x, y, z)
Definition: compat.h:39
temp_files
struct strarray temp_files
Definition: widl.c:133
_WIN32_WINNT_WIN8
#define _WIN32_WINNT_WIN8
Definition: sdkddkver.h:29
_WIN32_WINNT_VISTA
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
tls
static DWORD tls
Definition: sock.c:229
cmdline
TCHAR * cmdline
Definition: stretchblt.cpp:32
IMAGE_COR20_HEADER
Definition: winnt_old.h:3520
IMAGE_COR20_HEADER::MinorRuntimeVersion
WORD MinorRuntimeVersion
Definition: winnt_old.h:3523
IMAGE_COR20_HEADER::EntryPointToken
DWORD EntryPointToken
Definition: winnt_old.h:3527
IMAGE_COR20_HEADER::MajorRuntimeVersion
WORD MajorRuntimeVersion
Definition: winnt_old.h:3522
IMAGE_COR20_HEADER::cb
DWORD cb
Definition: winnt_old.h:3521
IMAGE_COR20_HEADER::Flags
DWORD Flags
Definition: winnt_old.h:3525
MEMORY_SECTION_NAME
Definition: mmtypes.h:325
PROCESS_BASIC_INFORMATION_PRIVATE
Definition: loader.c:43
PROCESS_BASIC_INFORMATION_PRIVATE::BasePriority
DWORD_PTR BasePriority
Definition: loader.c:47
PROCESS_BASIC_INFORMATION_PRIVATE::ExitStatus
NTSTATUS ExitStatus
Definition: loader.c:44
PROCESS_BASIC_INFORMATION_PRIVATE::UniqueProcessId
ULONG_PTR UniqueProcessId
Definition: loader.c:48
PROCESS_BASIC_INFORMATION_PRIVATE::InheritedFromUniqueProcessId
ULONG_PTR InheritedFromUniqueProcessId
Definition: loader.c:49
PROCESS_BASIC_INFORMATION_PRIVATE::AffinityMask
DWORD_PTR AffinityMask
Definition: loader.c:46
PROCESS_BASIC_INFORMATION_PRIVATE::PebBaseAddress
PPEB PebBaseAddress
Definition: loader.c:45
_CONTEXT
Definition: nt_native.h:1409
_DEBUG_EVENT
Definition: dbgktypes.h:229
_DELAYLOAD_INFO
Definition: delayloadhandler.h:38
_DELAYLOAD_INFO::DelayloadDescriptor
PCIMAGE_DELAYLOAD_DESCRIPTOR DelayloadDescriptor
Definition: delayloadhandler.h:40
_DELAYLOAD_INFO::Unused
PVOID Unused
Definition: delayloadhandler.h:45
_DELAYLOAD_INFO::TargetApiDescriptor
DELAYLOAD_PROC_DESCRIPTOR TargetApiDescriptor
Definition: delayloadhandler.h:43
_DELAYLOAD_INFO::Size
ULONG Size
Definition: delayloadhandler.h:39
_DELAYLOAD_INFO::TargetDllName
LPCSTR TargetDllName
Definition: delayloadhandler.h:42
_DELAYLOAD_INFO::LastError
ULONG LastError
Definition: delayloadhandler.h:46
_DELAYLOAD_INFO::ThunkAddress
PIMAGE_THUNK_DATA ThunkAddress
Definition: delayloadhandler.h:41
_DELAYLOAD_INFO::TargetModuleBase
PVOID TargetModuleBase
Definition: delayloadhandler.h:44
_DELAYLOAD_PROC_DESCRIPTOR::Ordinal
ULONG Ordinal
Definition: delayloadhandler.h:33
_DELAYLOAD_PROC_DESCRIPTOR::ImportDescribedByName
ULONG ImportDescribedByName
Definition: delayloadhandler.h:30
_DELAYLOAD_PROC_DESCRIPTOR::Description
union _DELAYLOAD_PROC_DESCRIPTOR::@3113 Description
_IMAGE_BASE_RELOCATION
Definition: ntimage.h:162
_IMAGE_DATA_DIRECTORY::VirtualAddress
DWORD VirtualAddress
Definition: ntddk_ex.h:132
_IMAGE_DATA_DIRECTORY::Size
DWORD Size
Definition: ntddk_ex.h:133
_IMAGE_DELAYLOAD_DESCRIPTOR
Definition: winnt_old.h:3674
_IMAGE_DELAYLOAD_DESCRIPTOR::TimeDateStamp
DWORD TimeDateStamp
Definition: winnt_old.h:3688
_IMAGE_DELAYLOAD_DESCRIPTOR::DllNameRVA
DWORD DllNameRVA
Definition: winnt_old.h:3682
_IMAGE_DELAYLOAD_DESCRIPTOR::AllAttributes
DWORD AllAttributes
Definition: winnt_old.h:3676
_IMAGE_DELAYLOAD_DESCRIPTOR::ModuleHandleRVA
DWORD ModuleHandleRVA
Definition: winnt_old.h:3683
_IMAGE_DELAYLOAD_DESCRIPTOR::ImportAddressTableRVA
DWORD ImportAddressTableRVA
Definition: winnt_old.h:3684
_IMAGE_DELAYLOAD_DESCRIPTOR::ImportNameTableRVA
DWORD ImportNameTableRVA
Definition: winnt_old.h:3685
_IMAGE_DELAYLOAD_DESCRIPTOR::UnloadInformationTableRVA
DWORD UnloadInformationTableRVA
Definition: winnt_old.h:3687
_IMAGE_DELAYLOAD_DESCRIPTOR::Attributes
union _IMAGE_DELAYLOAD_DESCRIPTOR::@4531 Attributes
_IMAGE_DELAYLOAD_DESCRIPTOR::BoundImportAddressTableRVA
DWORD BoundImportAddressTableRVA
Definition: winnt_old.h:3686
_IMAGE_DOS_HEADER
Definition: ntddk_ex.h:99
_IMAGE_DOS_HEADER::e_magic
WORD e_magic
Definition: ntddk_ex.h:100
_IMAGE_DOS_HEADER::e_lfanew
LONG e_lfanew
Definition: ntddk_ex.h:118
_IMAGE_EXPORT_DIRECTORY
Definition: compat.h:156
_IMAGE_FILE_HEADER
Definition: ntddk_ex.h:121
_IMAGE_FILE_HEADER::Characteristics
WORD Characteristics
Definition: ntddk_ex.h:128
_IMAGE_FILE_HEADER::SizeOfOptionalHeader
WORD SizeOfOptionalHeader
Definition: ntddk_ex.h:127
_IMAGE_FILE_HEADER::Machine
WORD Machine
Definition: ntddk_ex.h:122
_IMAGE_FILE_HEADER::NumberOfSections
WORD NumberOfSections
Definition: ntddk_ex.h:123
_IMAGE_FILE_HEADER::TimeDateStamp
DWORD TimeDateStamp
Definition: ntddk_ex.h:124
_IMAGE_IMPORT_BY_NAME
Definition: pedump.c:329
_IMAGE_IMPORT_BY_NAME::Name
BYTE Name[1]
Definition: pedump.c:331
_IMAGE_IMPORT_DESCRIPTOR
Definition: ntimage.h:572
_IMAGE_IMPORT_DESCRIPTOR::FirstThunk
ULONG FirstThunk
Definition: ntimage.h:580
_IMAGE_IMPORT_DESCRIPTOR::Name
ULONG Name
Definition: ntimage.h:579
_IMAGE_IMPORT_DESCRIPTOR::OriginalFirstThunk
ULONG OriginalFirstThunk
Definition: ntimage.h:575
_IMAGE_NT_HEADERS64
Definition: ntimage.h:393
_IMAGE_NT_HEADERS64::OptionalHeader
IMAGE_OPTIONAL_HEADER64 OptionalHeader
Definition: ntimage.h:396
_IMAGE_NT_HEADERS64::Signature
ULONG Signature
Definition: ntimage.h:394
_IMAGE_NT_HEADERS64::FileHeader
IMAGE_FILE_HEADER FileHeader
Definition: ntimage.h:395
_IMAGE_NT_HEADERS
Definition: ntddk_ex.h:181
_IMAGE_NT_HEADERS::Signature
DWORD Signature
Definition: ntddk_ex.h:182
_IMAGE_NT_HEADERS::OptionalHeader
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
_IMAGE_NT_HEADERS::FileHeader
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
_IMAGE_OPTIONAL_HEADER64::DataDirectory
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]
Definition: ntimage.h:370
_IMAGE_OPTIONAL_HEADER64::MajorLinkerVersion
UCHAR MajorLinkerVersion
Definition: ntimage.h:342
_IMAGE_OPTIONAL_HEADER64::ImageBase
ULONGLONG ImageBase
Definition: ntimage.h:349
_IMAGE_OPTIONAL_HEADER64::FileAlignment
ULONG FileAlignment
Definition: ntimage.h:351
_IMAGE_OPTIONAL_HEADER64::MajorSubsystemVersion
USHORT MajorSubsystemVersion
Definition: ntimage.h:356
_IMAGE_OPTIONAL_HEADER64::SectionAlignment
ULONG SectionAlignment
Definition: ntimage.h:350
_IMAGE_OPTIONAL_HEADER64::MajorImageVersion
USHORT MajorImageVersion
Definition: ntimage.h:354
_IMAGE_OPTIONAL_HEADER64::SizeOfStackReserve
ULONGLONG SizeOfStackReserve
Definition: ntimage.h:364
_IMAGE_OPTIONAL_HEADER64::AddressOfEntryPoint
ULONG AddressOfEntryPoint
Definition: ntimage.h:347
_IMAGE_OPTIONAL_HEADER64::NumberOfRvaAndSizes
ULONG NumberOfRvaAndSizes
Definition: ntimage.h:369
_IMAGE_OPTIONAL_HEADER64::SizeOfImage
ULONG SizeOfImage
Definition: ntimage.h:359
_IMAGE_OPTIONAL_HEADER64::Magic
USHORT Magic
Definition: ntimage.h:341
_IMAGE_OPTIONAL_HEADER64::SizeOfStackCommit
ULONGLONG SizeOfStackCommit
Definition: ntimage.h:365
_IMAGE_OPTIONAL_HEADER64::DllCharacteristics
USHORT DllCharacteristics
Definition: ntimage.h:363
_IMAGE_OPTIONAL_HEADER64::MajorOperatingSystemVersion
USHORT MajorOperatingSystemVersion
Definition: ntimage.h:352
_IMAGE_OPTIONAL_HEADER64::SizeOfCode
ULONG SizeOfCode
Definition: ntimage.h:344
_IMAGE_OPTIONAL_HEADER64::SizeOfHeaders
ULONG SizeOfHeaders
Definition: ntimage.h:360
_IMAGE_OPTIONAL_HEADER64::Subsystem
USHORT Subsystem
Definition: ntimage.h:362
_IMAGE_OPTIONAL_HEADER
Definition: ntddk_ex.h:138
_IMAGE_OPTIONAL_HEADER::SizeOfCode
DWORD SizeOfCode
Definition: ntddk_ex.h:146
_IMAGE_OPTIONAL_HEADER::NumberOfRvaAndSizes
DWORD NumberOfRvaAndSizes
Definition: ntddk_ex.h:177
_IMAGE_OPTIONAL_HEADER::MinorOperatingSystemVersion
WORD MinorOperatingSystemVersion
Definition: ntddk_ex.h:161
_IMAGE_OPTIONAL_HEADER::SizeOfImage
DWORD SizeOfImage
Definition: ntddk_ex.h:167
_IMAGE_OPTIONAL_HEADER::SizeOfHeaders
DWORD SizeOfHeaders
Definition: ntddk_ex.h:168
_IMAGE_OPTIONAL_HEADER::DllCharacteristics
WORD DllCharacteristics
Definition: ntddk_ex.h:171
_IMAGE_OPTIONAL_HEADER::MajorOperatingSystemVersion
WORD MajorOperatingSystemVersion
Definition: ntddk_ex.h:160
_IMAGE_OPTIONAL_HEADER::AddressOfEntryPoint
DWORD AddressOfEntryPoint
Definition: ntddk_ex.h:149
_IMAGE_OPTIONAL_HEADER::Subsystem
WORD Subsystem
Definition: ntddk_ex.h:170
_IMAGE_OPTIONAL_HEADER::MajorSubsystemVersion
WORD MajorSubsystemVersion
Definition: ntddk_ex.h:164
_IMAGE_OPTIONAL_HEADER::MajorImageVersion
WORD MajorImageVersion
Definition: ntddk_ex.h:162
_IMAGE_OPTIONAL_HEADER::Magic
WORD Magic
Definition: ntddk_ex.h:143
_IMAGE_OPTIONAL_HEADER::FileAlignment
DWORD FileAlignment
Definition: ntddk_ex.h:159
_IMAGE_OPTIONAL_HEADER::SizeOfStackReserve
DWORD SizeOfStackReserve
Definition: ntddk_ex.h:172
_IMAGE_OPTIONAL_HEADER::ImageBase
DWORD ImageBase
Definition: ntddk_ex.h:157
_IMAGE_OPTIONAL_HEADER::CheckSum
DWORD CheckSum
Definition: ntddk_ex.h:169
_IMAGE_OPTIONAL_HEADER::MajorLinkerVersion
BYTE MajorLinkerVersion
Definition: ntddk_ex.h:144
_IMAGE_OPTIONAL_HEADER::DataDirectory
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]
Definition: ntddk_ex.h:178
_IMAGE_OPTIONAL_HEADER::SectionAlignment
DWORD SectionAlignment
Definition: ntddk_ex.h:158
_IMAGE_OPTIONAL_HEADER::SizeOfStackCommit
DWORD SizeOfStackCommit
Definition: ntddk_ex.h:173
_IMAGE_OPTIONAL_HEADER::MinorSubsystemVersion
WORD MinorSubsystemVersion
Definition: ntddk_ex.h:165
_IMAGE_OS2_HEADER
Definition: winnt_old.h:3226
_IMAGE_SECTION_HEADER
Definition: pedump.c:280
_IMAGE_THUNK_DATA32
Definition: ntimage.h:510
_IMAGE_THUNK_DATA32::u1
union _IMAGE_THUNK_DATA32::@2337 u1
_IMAGE_THUNK_DATA32::Ordinal
ULONG Ordinal
Definition: ntimage.h:514
_IMAGE_THUNK_DATA32::Function
ULONG Function
Definition: ntimage.h:513
_IMAGE_THUNK_DATA32::AddressOfData
ULONG AddressOfData
Definition: ntimage.h:515
_IMAGE_TLS_DIRECTORY32
Definition: ntimage.h:545
_LDR_DATA_TABLE_ENTRY
Definition: btrfs_drv.h:1876
_LIST_ENTRY
Definition: typedefs.h:120
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_MEMORY_BASIC_INFORMATION
Definition: mmtypes.h:971
_OBJECT_ATTRIBUTES
Definition: umtypes.h:184
_PEB_LDR_DATA
Definition: btrfs_drv.h:1892
_PEB_LDR_DATA::InMemoryOrderModuleList
LIST_ENTRY InMemoryOrderModuleList
Definition: btrfs_drv.h:1895
_PEB_LDR_DATA::InLoadOrderModuleList
LIST_ENTRY InLoadOrderModuleList
Definition: ldrtypes.h:124
_PEB_LDR_DATA::Initialized
BOOLEAN Initialized
Definition: ntddk_ex.h:222
_PEB
Definition: btrfs_drv.h:1907
_PEB::ImageBaseAddress
PVOID ImageBaseAddress
Definition: ntddk_ex.h:245
_PROCESS_BASIC_INFORMATION
Definition: winternl.h:404
_PROCESS_INFORMATION
Definition: processthreadsapi.h:65
_PROCESS_INFORMATION::hThread
HANDLE hThread
Definition: processthreadsapi.h:67
_PROCESS_INFORMATION::hProcess
HANDLE hProcess
Definition: processthreadsapi.h:66
_PROCESS_INFORMATION::dwProcessId
DWORD dwProcessId
Definition: processthreadsapi.h:68
_RTL_CRITICAL_SECTION
Definition: rtltypes.h:1449
_SECTION_BASIC_INFORMATION
Definition: mmtypes.h:333
_SECTION_IMAGE_INFORMATION
Definition: mmtypes.h:340
_SECTION_IMAGE_INFORMATION::ImageCharacteristics
USHORT ImageCharacteristics
Definition: mmtypes.h:356
_STARTUPINFOA
Definition: processthreadsapi.h:15
_STARTUPINFOA::cb
DWORD cb
Definition: processthreadsapi.h:16
_SYSTEM_INFO
Definition: winbase.h:890
_SYSTEM_INFO::dwPageSize
DWORD dwPageSize
Definition: winbase.h:898
_UNICODE_STRING
Definition: env_spec_w32.h:368
_root
Definition: btrfs_drv.h:450
code
Definition: inflate.c:139
context
Definition: http.c:7252
cookie
Definition: cookie.c:34
define::name
char * name
Definition: compiler.c:66
file
Definition: fci.c:127
line
Definition: parser.c:49
mutex
Definition: module.h:456
name
Definition: name.c:39
section
Definition: parser.c:56
status
Definition: ps.c:97
target
Definition: tools.h:99
test_data
Definition: RtlDosApplyFileIsolationRedirection_Ustr.c:15
max
#define max(a, b)
Definition: svc.c:63
WaitForMultipleObjects
DWORD WINAPI WaitForMultipleObjects(IN DWORD nCount, IN CONST HANDLE *lpHandles, IN BOOL bWaitAll, IN DWORD dwMilliseconds)
Definition: synch.c:151
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
Sleep
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
InitializeCriticalSection
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
CreateMutexW
HANDLE WINAPI DECLSPEC_HOTPATCH CreateMutexW(IN LPSECURITY_ATTRIBUTES lpMutexAttributes OPTIONAL, IN BOOL bInitialOwner, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:576
CreateEventW
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
ResetEvent
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:714
CreateSemaphoreW
HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreW(IN LPSECURITY_ATTRIBUTES lpSemaphoreAttributes OPTIONAL, IN LONG lInitialCount, IN LONG lMaximumCount, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:444
DWORD_PTR
uint32_t DWORD_PTR
Definition: typedefs.h:65
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
PVOID
void * PVOID
Definition: typedefs.h:50
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
HMODULE
HANDLE HMODULE
Definition: typedefs.h:77
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
ULONG
uint32_t ULONG
Definition: typedefs.h:59
_LARGE_INTEGER
Definition: typedefs.h:103
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
_LARGE_INTEGER::LowPart
ULONG LowPart
Definition: typedefs.h:106
_LARGE_INTEGER::u
struct _LARGE_INTEGER::@2502 u
_LDR_DLL_NOTIFICATION_DATA
Definition: ldrtypes.h:225
value
Definition: pdh_main.c:96
hint
DWORD hint
Definition: vfdcmd.c:88
VirtualAlloc
LPVOID NTAPI VirtualAlloc(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flAllocationType, IN DWORD flProtect)
Definition: virtmem.c:65
VirtualProtect
BOOL NTAPI VirtualProtect(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flNewProtect, OUT PDWORD lpflOldProtect)
Definition: virtmem.c:135
VirtualAllocEx
LPVOID NTAPI VirtualAllocEx(IN HANDLE hProcess, IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flAllocationType, IN DWORD flProtect)
Definition: virtmem.c:23
VirtualProtectEx
BOOL NTAPI VirtualProtectEx(IN HANDLE hProcess, IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flNewProtect, OUT PDWORD lpflOldProtect)
Definition: virtmem.c:153
VirtualFree
BOOL NTAPI VirtualFree(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD dwFreeType)
Definition: virtmem.c:119
VirtualQueryEx
SIZE_T NTAPI VirtualQueryEx(IN HANDLE hProcess, IN LPCVOID lpAddress, OUT PMEMORY_BASIC_INFORMATION lpBuffer, IN SIZE_T dwLength)
Definition: virtmem.c:227
VirtualQuery
SIZE_T NTAPI VirtualQuery(IN LPCVOID lpAddress, OUT PMEMORY_BASIC_INFORMATION lpBuffer, IN SIZE_T dwLength)
Definition: virtmem.c:211
VirtualFreeEx
BOOL NTAPI VirtualFreeEx(IN HANDLE hProcess, IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD dwFreeType)
Definition: virtmem.c:83
WAIT_ABANDONED
#define WAIT_ABANDONED
Definition: winbase.h:389
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
FILE_MAP_WRITE
#define FILE_MAP_WRITE
Definition: winbase.h:156
GetCurrentThread
HANDLE WINAPI GetCurrentThread(void)
Definition: proc.c:1148
FLS_OUT_OF_INDEXES
#define FLS_OUT_OF_INDEXES
Definition: winbase.h:556
LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE
#define LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE
Definition: winbase.h:344
GetCurrentThreadId
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459
LOAD_LIBRARY_AS_IMAGE_RESOURCE
#define LOAD_LIBRARY_AS_IMAGE_RESOURCE
Definition: winbase.h:343
LOAD_LIBRARY_AS_DATAFILE
#define LOAD_LIBRARY_AS_DATAFILE
Definition: winbase.h:338
GetCurrentProcessId
DWORD WINAPI GetCurrentProcessId(void)
Definition: proc.c:1158
FILE_CURRENT
#define FILE_CURRENT
Definition: winbase.h:115
CREATE_SUSPENDED
#define CREATE_SUSPENDED
Definition: winbase.h:182
PFLS_CALLBACK_FUNCTION
VOID(WINAPI * PFLS_CALLBACK_FUNCTION)(PVOID)
Definition: winbase.h:1202
EnterCriticalSection
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
WAIT_OBJECT_0
#define WAIT_OBJECT_0
Definition: winbase.h:383
DONT_RESOLVE_DLL_REFERENCES
#define DONT_RESOLVE_DLL_REFERENCES
Definition: winbase.h:337
pbi
_Inout_ PERBANDINFO * pbi
Definition: winddi.h:3917
WINAPI
#define WINAPI
Definition: msvc.h:6
ERROR_PARTIAL_COPY
#define ERROR_PARTIAL_COPY
Definition: winerror.h:424
ERROR_SEM_TIMEOUT
#define ERROR_SEM_TIMEOUT
Definition: winerror.h:315
ERROR_SHARING_VIOLATION
#define ERROR_SHARING_VIOLATION
Definition: winerror.h:257
APPMODEL_ERROR_NO_PACKAGE
#define APPMODEL_ERROR_NO_PACKAGE
Definition: winerror.h:3400
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:256
ERROR_BAD_EXE_FORMAT
#define ERROR_BAD_EXE_FORMAT
Definition: winerror.h:373
ERROR_NOACCESS
#define ERROR_NOACCESS
Definition: winerror.h:902
COMIMAGE_FLAGS_ILONLY
@ COMIMAGE_FLAGS_ILONLY
Definition: winnt_old.h:3493
COMIMAGE_FLAGS_32BITREQUIRED
@ COMIMAGE_FLAGS_32BITREQUIRED
Definition: winnt_old.h:3494
COMIMAGE_FLAGS_32BITPREFERRED
@ COMIMAGE_FLAGS_32BITPREFERRED
Definition: winnt_old.h:3499
snprintf
#define snprintf
Definition: wintirpc.h:48
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
DUPLICATE_SAME_ACCESS
#define DUPLICATE_SAME_ACCESS
LPCSTR
const char * LPCSTR
Definition: xmlstorage.h:183
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPSTR
char * LPSTR
Definition: xmlstorage.h:182
BYTE
unsigned char BYTE
Definition: xxhash.c:193