git.oblomov.eu Git - wine/blob - dlls/kernel32/tests/loader.c

   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 <assert.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winternl.h"
  29 #include "wine/test.h"
  30
  31 #define ALIGN_SIZE(size, alignment) (((size) + (alignment - 1)) & ~((alignment - 1)))
  32
  33 static NTSTATUS (WINAPI *pNtMapViewOfSection)(HANDLE, HANDLE, PVOID *, ULONG, SIZE_T, const LARGE_INTEGER *, SIZE_T *, ULONG, ULONG, ULONG);
  34 static NTSTATUS (WINAPI *pNtUnmapViewOfSection)(HANDLE, PVOID);
  35
  36 static PVOID RVAToAddr(DWORD_PTR rva, HMODULE module)
  37 {
  38     if (rva == 0)
  39         return NULL;
  40     return ((char*) module) + rva;
  41 }
  42
  43 static const struct
  44 {
  45     WORD e_magic;      /* 00: MZ Header signature */
  46     WORD unused[29];
  47     DWORD e_lfanew;    /* 3c: Offset to extended header */
  48 } dos_header =
  49 {
  50     IMAGE_DOS_SIGNATURE, { 0 }, sizeof(dos_header)
  51 };
  52
  53 static IMAGE_NT_HEADERS nt_header =
  54 {
  55     IMAGE_NT_SIGNATURE, /* Signature */
  56     {
  57 #if defined __i386__
  58       IMAGE_FILE_MACHINE_I386, /* Machine */
  59 #elif defined __x86_64__
  60       IMAGE_FILE_MACHINE_AMD64, /* Machine */
  61 #elif defined __powerpc__
  62       IMAGE_FILE_MACHINE_POWERPC, /* Machine */
  63 #elif defined __sparc__
  64       IMAGE_FILE_MACHINE_SPARC, /* Machine */
  65 #elif defined __arm__
  66       IMAGE_FILE_MACHINE_ARMNT, /* Machine */
  67 #elif defined __aarch64__
  68       IMAGE_FILE_MACHINE_ARM64, /* Machine */
  69 #else
  70 # error You must specify the machine type
  71 #endif
  72       1, /* NumberOfSections */
  73       0, /* TimeDateStamp */
  74       0, /* PointerToSymbolTable */
  75       0, /* NumberOfSymbols */
  76       sizeof(IMAGE_OPTIONAL_HEADER), /* SizeOfOptionalHeader */
  77       IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL /* Characteristics */
  78     },
  79     { IMAGE_NT_OPTIONAL_HDR_MAGIC, /* Magic */
  80       1, /* MajorLinkerVersion */
  81       0, /* MinorLinkerVersion */
  82       0, /* SizeOfCode */
  83       0, /* SizeOfInitializedData */
  84       0, /* SizeOfUninitializedData */
  85       0, /* AddressOfEntryPoint */
  86       0x10, /* BaseOfCode, also serves as e_lfanew in the truncated MZ header */
  87 #ifndef _WIN64
  88       0, /* BaseOfData */
  89 #endif
  90       0x10000000, /* ImageBase */
  91       0, /* SectionAlignment */
  92       0, /* FileAlignment */
  93       4, /* MajorOperatingSystemVersion */
  94       0, /* MinorOperatingSystemVersion */
  95       1, /* MajorImageVersion */
  96       0, /* MinorImageVersion */
  97       4, /* MajorSubsystemVersion */
  98       0, /* MinorSubsystemVersion */
  99       0, /* Win32VersionValue */
 100       sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x1000, /* SizeOfImage */
 101       sizeof(dos_header) + sizeof(nt_header), /* SizeOfHeaders */
 102       0, /* CheckSum */
 103       IMAGE_SUBSYSTEM_WINDOWS_CUI, /* Subsystem */
 104       0, /* DllCharacteristics */
 105       0, /* SizeOfStackReserve */
 106       0, /* SizeOfStackCommit */
 107       0, /* SizeOfHeapReserve */
 108       0, /* SizeOfHeapCommit */
 109       0, /* LoaderFlags */
 110       0, /* NumberOfRvaAndSizes */
 111       { { 0 } } /* DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] */
 112     }
 113 };
 114
 115 static IMAGE_SECTION_HEADER section =
 116 {
 117     ".rodata", /* Name */
 118     { 0x10 }, /* Misc */
 119     0, /* VirtualAddress */
 120     0x0a, /* SizeOfRawData */
 121     0, /* PointerToRawData */
 122     0, /* PointerToRelocations */
 123     0, /* PointerToLinenumbers */
 124     0, /* NumberOfRelocations */
 125     0, /* NumberOfLinenumbers */
 126     IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ, /* Characteristics */
 127 };
 128
 129 static void test_Loader(void)
 130 {
 131     static const struct test_data
 132     {
 133         const void *dos_header;
 134         DWORD size_of_dos_header;
 135         WORD number_of_sections, size_of_optional_header;
 136         DWORD section_alignment, file_alignment;
 137         DWORD size_of_image, size_of_headers;
 138         DWORD errors[4]; /* 0 means LoadLibrary should succeed */
 139     } td[] =
 140     {
 141         { &dos_header, sizeof(dos_header),
 142           1, 0, 0, 0, 0, 0,
 143           { ERROR_BAD_EXE_FORMAT }
 144         },
 145         { &dos_header, sizeof(dos_header),
 146           1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x1000,
 147           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0xe00,
 148           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER),
 149           { ERROR_BAD_EXE_FORMAT } /* XP doesn't like too small image size */
 150         },
 151         { &dos_header, sizeof(dos_header),
 152           1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x1000,
 153           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
 154           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER),
 155           { ERROR_SUCCESS }
 156         },
 157         { &dos_header, sizeof(dos_header),
 158           1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x1000,
 159           0x1f00,
 160           0x1000,
 161           { ERROR_SUCCESS }
 162         },
 163         { &dos_header, sizeof(dos_header),
 164           1, sizeof(IMAGE_OPTIONAL_HEADER), 0x200, 0x200,
 165           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x200,
 166           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER),
 167           { ERROR_SUCCESS, ERROR_INVALID_ADDRESS } /* vista is more strict */
 168         },
 169         { &dos_header, sizeof(dos_header),
 170           1, sizeof(IMAGE_OPTIONAL_HEADER), 0x200, 0x1000,
 171           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
 172           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER),
 173           { ERROR_BAD_EXE_FORMAT } /* XP doesn't like alignments */
 174         },
 175         { &dos_header, sizeof(dos_header),
 176           1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x200,
 177           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
 178           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER),
 179           { ERROR_SUCCESS }
 180         },
 181         { &dos_header, sizeof(dos_header),
 182           1, sizeof(IMAGE_OPTIONAL_HEADER), 0x1000, 0x200,
 183           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
 184           0x200,
 185           { ERROR_SUCCESS }
 186         },
 187         /* Mandatory are all fields up to SizeOfHeaders, everything else
 188          * is really optional (at least that's true for XP).
 189          */
 190         { &dos_header, sizeof(dos_header),
 191           1, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
 192           sizeof(dos_header) + sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER) + FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum) + sizeof(IMAGE_SECTION_HEADER) + 0x10,
 193           sizeof(dos_header) + sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER) + FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum) + sizeof(IMAGE_SECTION_HEADER),
 194           { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT, ERROR_INVALID_ADDRESS,
 195             ERROR_NOACCESS }
 196         },
 197         { &dos_header, sizeof(dos_header),
 198           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
 199           0xd0, /* beyond of the end of file */
 200           0xc0, /* beyond of the end of file */
 201           { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
 202         },
 203         { &dos_header, sizeof(dos_header),
 204           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
 205           0x1000,
 206           0,
 207           { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
 208         },
 209         { &dos_header, sizeof(dos_header),
 210           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
 211           1,
 212           0,
 213           { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
 214         },
 215 #if 0 /* not power of 2 alignments need more test cases */
 216         { &dos_header, sizeof(dos_header),
 217           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x300, 0x300,
 218           1,
 219           0,
 220           { ERROR_BAD_EXE_FORMAT } /* alignment is not power of 2 */
 221         },
 222 #endif
 223         { &dos_header, sizeof(dos_header),
 224           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 4, 4,
 225           1,
 226           0,
 227           { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
 228         },
 229         { &dos_header, sizeof(dos_header),
 230           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 1, 1,
 231           1,
 232           0,
 233           { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
 234         },
 235         { &dos_header, sizeof(dos_header),
 236           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum), 0x200, 0x200,
 237           0,
 238           0,
 239           { ERROR_BAD_EXE_FORMAT } /* image size == 0 -> failure */
 240         },
 241         /* the following data mimics the PE image which upack creates */
 242         { &dos_header, 0x10,
 243           1, 0x148, 0x1000, 0x200,
 244           sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + 0x1000,
 245           0x200,
 246           { ERROR_SUCCESS }
 247         },
 248         /* Minimal PE image that XP is able to load: 92 bytes */
 249         { &dos_header, 0x04,
 250           0, FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, CheckSum),
 251           0x04 /* also serves as e_lfanew in the truncated MZ header */, 0x04,
 252           1,
 253           0,
 254           { ERROR_SUCCESS, ERROR_BAD_EXE_FORMAT } /* vista is more strict */
 255         }
 256     };
 257     static const char filler[0x1000];
 258     static const char section_data[0x10] = "section data";
 259     int i;
 260     DWORD dummy, file_size, file_align;
 261     HANDLE hfile;
 262     HMODULE hlib, hlib_as_data_file;
 263     SYSTEM_INFO si;
 264     char temp_path[MAX_PATH];
 265     char dll_name[MAX_PATH];
 266     SIZE_T size;
 267     BOOL ret;
 268
 269     GetSystemInfo(&si);
 270     trace("system page size 0x%04x\n", si.dwPageSize);
 271
 272     /* prevent displaying of the "Unable to load this DLL" message box */
 273     SetErrorMode(SEM_FAILCRITICALERRORS);
 274
 275     GetTempPath(MAX_PATH, temp_path);
 276
 277     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
 278     {
 279         GetTempFileName(temp_path, "ldr", 0, dll_name);
 280
 281         /*trace("creating %s\n", dll_name);*/
 282         hfile = CreateFileA(dll_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 283         if (hfile == INVALID_HANDLE_VALUE)
 284         {
 285             ok(0, "could not create %s\n", dll_name);
 286             break;
 287         }
 288
 289         SetLastError(0xdeadbeef);
 290         ret = WriteFile(hfile, td[i].dos_header, td[i].size_of_dos_header, &dummy, NULL);
 291         ok(ret, "WriteFile error %d\n", GetLastError());
 292
 293         nt_header.FileHeader.NumberOfSections = td[i].number_of_sections;
 294         nt_header.FileHeader.SizeOfOptionalHeader = td[i].size_of_optional_header;
 295
 296         nt_header.OptionalHeader.SectionAlignment = td[i].section_alignment;
 297         nt_header.OptionalHeader.FileAlignment = td[i].file_alignment;
 298         nt_header.OptionalHeader.SizeOfImage = td[i].size_of_image;
 299         nt_header.OptionalHeader.SizeOfHeaders = td[i].size_of_headers;
 300         SetLastError(0xdeadbeef);
 301         ret = WriteFile(hfile, &nt_header, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), &dummy, NULL);
 302         ok(ret, "WriteFile error %d\n", GetLastError());
 303
 304         if (nt_header.FileHeader.SizeOfOptionalHeader)
 305         {
 306             SetLastError(0xdeadbeef);
 307             ret = WriteFile(hfile, &nt_header.OptionalHeader,
 308                             min(nt_header.FileHeader.SizeOfOptionalHeader, sizeof(IMAGE_OPTIONAL_HEADER)),
 309                             &dummy, NULL);
 310             ok(ret, "WriteFile error %d\n", GetLastError());
 311             if (nt_header.FileHeader.SizeOfOptionalHeader > sizeof(IMAGE_OPTIONAL_HEADER))
 312             {
 313                 file_align = nt_header.FileHeader.SizeOfOptionalHeader - sizeof(IMAGE_OPTIONAL_HEADER);
 314                 assert(file_align < sizeof(filler));
 315                 SetLastError(0xdeadbeef);
 316                 ret = WriteFile(hfile, filler, file_align, &dummy, NULL);
 317                 ok(ret, "WriteFile error %d\n", GetLastError());
 318             }
 319         }
 320
 321         assert(nt_header.FileHeader.NumberOfSections <= 1);
 322         if (nt_header.FileHeader.NumberOfSections)
 323         {
 324             if (nt_header.OptionalHeader.SectionAlignment >= si.dwPageSize)
 325             {
 326                 section.PointerToRawData = td[i].size_of_dos_header;
 327                 section.VirtualAddress = nt_header.OptionalHeader.SectionAlignment;
 328                 section.Misc.VirtualSize = section.SizeOfRawData * 10;
 329             }
 330             else
 331             {
 332                 section.PointerToRawData = nt_header.OptionalHeader.SizeOfHeaders;
 333                 section.VirtualAddress = nt_header.OptionalHeader.SizeOfHeaders;
 334                 section.Misc.VirtualSize = 5;
 335             }
 336
 337             SetLastError(0xdeadbeef);
 338             ret = WriteFile(hfile, &section, sizeof(section), &dummy, NULL);
 339             ok(ret, "WriteFile error %d\n", GetLastError());
 340
 341             /* section data */
 342             SetLastError(0xdeadbeef);
 343             ret = WriteFile(hfile, section_data, sizeof(section_data), &dummy, NULL);
 344             ok(ret, "WriteFile error %d\n", GetLastError());
 345         }
 346
 347         file_size = GetFileSize(hfile, NULL);
 348         CloseHandle(hfile);
 349
 350         SetLastError(0xdeadbeef);
 351         hlib = LoadLibrary(dll_name);
 352         if (hlib)
 353         {
 354             MEMORY_BASIC_INFORMATION info;
 355
 356             ok( td[i].errors[0] == ERROR_SUCCESS, "%d: should have failed\n", i );
 357
 358             SetLastError(0xdeadbeef);
 359             size = VirtualQuery(hlib, &info, sizeof(info));
 360             ok(size == sizeof(info),
 361                 "%d: VirtualQuery error %d\n", i, GetLastError());
 362             ok(info.BaseAddress == hlib, "%d: %p != %p\n", i, info.BaseAddress, hlib);
 363             ok(info.AllocationBase == hlib, "%d: %p != %p\n", i, info.AllocationBase, hlib);
 364             ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
 365             ok(info.RegionSize == ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, si.dwPageSize), "%d: got %lx != expected %x\n",
 366                i, info.RegionSize, ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, si.dwPageSize));
 367             ok(info.State == MEM_COMMIT, "%d: %x != MEM_COMMIT\n", i, info.State);
 368             if (nt_header.OptionalHeader.SectionAlignment < si.dwPageSize)
 369                 ok(info.Protect == PAGE_EXECUTE_WRITECOPY, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i, info.Protect);
 370             else
 371                 ok(info.Protect == PAGE_READONLY, "%d: %x != PAGE_READONLY\n", i, info.Protect);
 372             ok(info.Type == SEC_IMAGE, "%d: %x != SEC_IMAGE\n", i, info.Type);
 373
 374             SetLastError(0xdeadbeef);
 375             size = VirtualQuery((char *)hlib + info.RegionSize, &info, sizeof(info));
 376             ok(size == sizeof(info),
 377                 "%d: VirtualQuery error %d\n", i, GetLastError());
 378             if (nt_header.OptionalHeader.SectionAlignment == si.dwPageSize ||
 379                 nt_header.OptionalHeader.SectionAlignment == nt_header.OptionalHeader.FileAlignment)
 380             {
 381                 ok(info.BaseAddress == (char *)hlib + ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, si.dwPageSize), "%d: got %p != expected %p\n",
 382                    i, info.BaseAddress, (char *)hlib + ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, si.dwPageSize));
 383                 ok(info.AllocationBase == 0, "%d: %p != 0\n", i, info.AllocationBase);
 384                 ok(info.AllocationProtect == 0, "%d: %x != 0\n", i, info.AllocationProtect);
 385                 /*ok(info.RegionSize == not_practical_value, "%d: %lx != not_practical_value\n", i, info.RegionSize);*/
 386                 ok(info.State == MEM_FREE, "%d: %x != MEM_FREE\n", i, info.State);
 387                 ok(info.Type == 0, "%d: %x != 0\n", i, info.Type);
 388                 ok(info.Protect == PAGE_NOACCESS, "%d: %x != PAGE_NOACCESS\n", i, info.Protect);
 389             }
 390             else
 391             {
 392                 ok(info.Protect == PAGE_EXECUTE_WRITECOPY, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i, info.Protect);
 393                 ok(info.BaseAddress == hlib, "%d: got %p != expected %p\n", i, info.BaseAddress, hlib);
 394                 ok(info.AllocationBase == hlib, "%d: %p != %p\n", i, info.AllocationBase, hlib);
 395                 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
 396                 ok(info.RegionSize == ALIGN_SIZE(file_size, si.dwPageSize), "%d: got %lx != expected %x\n",
 397                    i, info.RegionSize, ALIGN_SIZE(file_size, si.dwPageSize));
 398                 ok(info.State == MEM_COMMIT, "%d: %x != MEM_COMMIT\n", i, info.State);
 399                 ok(info.Protect == PAGE_READONLY, "%d: %x != PAGE_READONLY\n", i, info.Protect);
 400                 ok(info.Type == SEC_IMAGE, "%d: %x != SEC_IMAGE\n", i, info.Type);
 401             }
 402
 403             /* header: check the zeroing of alignment */
 404             if (nt_header.OptionalHeader.SectionAlignment >= si.dwPageSize)
 405             {
 406                 const char *start;
 407                 int size;
 408
 409                 start = (const char *)hlib + nt_header.OptionalHeader.SizeOfHeaders;
 410                 size = ALIGN_SIZE((ULONG_PTR)start, si.dwPageSize) - (ULONG_PTR)start;
 411                 ok(!memcmp(start, filler, size), "%d: header alignment is not cleared\n", i);
 412             }
 413
 414             if (nt_header.FileHeader.NumberOfSections)
 415             {
 416                 SetLastError(0xdeadbeef);
 417                 size = VirtualQuery((char *)hlib + section.VirtualAddress, &info, sizeof(info));
 418                 ok(size == sizeof(info),
 419                     "%d: VirtualQuery error %d\n", i, GetLastError());
 420                 if (nt_header.OptionalHeader.SectionAlignment < si.dwPageSize)
 421                 {
 422                     ok(info.BaseAddress == hlib, "%d: got %p != expected %p\n", i, info.BaseAddress, hlib);
 423                     ok(info.RegionSize == ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, si.dwPageSize), "%d: got %lx != expected %x\n",
 424                        i, info.RegionSize, ALIGN_SIZE(nt_header.OptionalHeader.SizeOfImage, si.dwPageSize));
 425                     ok(info.Protect == PAGE_EXECUTE_WRITECOPY, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i, info.Protect);
 426                 }
 427                 else
 428                 {
 429                     ok(info.BaseAddress == (char *)hlib + section.VirtualAddress, "%d: got %p != expected %p\n", i, info.BaseAddress, (char *)hlib + section.VirtualAddress);
 430                     ok(info.RegionSize == ALIGN_SIZE(section.Misc.VirtualSize, si.dwPageSize), "%d: got %lx != expected %x\n",
 431                        i, info.RegionSize, ALIGN_SIZE(section.Misc.VirtualSize, si.dwPageSize));
 432                     ok(info.Protect == PAGE_READONLY, "%d: %x != PAGE_READONLY\n", i, info.Protect);
 433                 }
 434                 ok(info.AllocationBase == hlib, "%d: %p != %p\n", i, info.AllocationBase, hlib);
 435                 ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %x != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
 436                 ok(info.State == MEM_COMMIT, "%d: %x != MEM_COMMIT\n", i, info.State);
 437                 ok(info.Type == SEC_IMAGE, "%d: %x != SEC_IMAGE\n", i, info.Type);
 438
 439                 if (nt_header.OptionalHeader.SectionAlignment >= si.dwPageSize)
 440                     ok(!memcmp((const char *)hlib + section.VirtualAddress + section.PointerToRawData, &nt_header, section.SizeOfRawData), "wrong section data\n");
 441                 else
 442                     ok(!memcmp((const char *)hlib + section.PointerToRawData, section_data, section.SizeOfRawData), "wrong section data\n");
 443
 444                 /* check the zeroing of alignment */
 445                 if (nt_header.OptionalHeader.SectionAlignment >= si.dwPageSize)
 446                 {
 447                     const char *start;
 448                     int size;
 449
 450                     start = (const char *)hlib + section.VirtualAddress + section.PointerToRawData + section.SizeOfRawData;
 451                     size = ALIGN_SIZE((ULONG_PTR)start, si.dwPageSize) - (ULONG_PTR)start;
 452                     ok(memcmp(start, filler, size), "%d: alignment should not be cleared\n", i);
 453                 }
 454             }
 455
 456             SetLastError(0xdeadbeef);
 457             hlib_as_data_file = LoadLibraryEx(dll_name, 0, LOAD_LIBRARY_AS_DATAFILE);
 458             ok(hlib_as_data_file != 0, "LoadLibraryEx error %u\n", GetLastError());
 459             ok(hlib_as_data_file == hlib, "hlib_as_file and hlib are different\n");
 460
 461             SetLastError(0xdeadbeef);
 462             ret = FreeLibrary(hlib);
 463             ok(ret, "FreeLibrary error %d\n", GetLastError());
 464
 465             SetLastError(0xdeadbeef);
 466             hlib = GetModuleHandle(dll_name);
 467             ok(hlib != 0, "GetModuleHandle error %u\n", GetLastError());
 468
 469             SetLastError(0xdeadbeef);
 470             ret = FreeLibrary(hlib_as_data_file);
 471             ok(ret, "FreeLibrary error %d\n", GetLastError());
 472
 473             hlib = GetModuleHandle(dll_name);
 474             ok(!hlib, "GetModuleHandle should fail\n");
 475
 476             SetLastError(0xdeadbeef);
 477             hlib_as_data_file = LoadLibraryEx(dll_name, 0, LOAD_LIBRARY_AS_DATAFILE);
 478             ok(hlib_as_data_file != 0, "LoadLibraryEx error %u\n", GetLastError());
 479             ok((ULONG_PTR)hlib_as_data_file & 1, "hlib_as_data_file is even\n");
 480
 481             hlib = GetModuleHandle(dll_name);
 482             ok(!hlib, "GetModuleHandle should fail\n");
 483
 484             SetLastError(0xdeadbeef);
 485             ret = FreeLibrary(hlib_as_data_file);
 486             ok(ret, "FreeLibrary error %d\n", GetLastError());
 487         }
 488         else
 489         {
 490             BOOL error_match;
 491             int error_index;
 492
 493             error_match = FALSE;
 494             for (error_index = 0;
 495                  ! error_match && error_index < sizeof(td[i].errors) / sizeof(DWORD);
 496                  error_index++)
 497             {
 498                 error_match = td[i].errors[error_index] == GetLastError();
 499             }
 500             ok(error_match, "%d: unexpected error %d\n", i, GetLastError());
 501         }
 502
 503         SetLastError(0xdeadbeef);
 504         ret = DeleteFile(dll_name);
 505         ok(ret, "DeleteFile error %d\n", GetLastError());
 506     }
 507 }
 508
 509 /* Verify linking style of import descriptors */
 510 static void test_ImportDescriptors(void)
 511 {
 512     HMODULE kernel32_module = NULL;
 513     PIMAGE_DOS_HEADER d_header;
 514     PIMAGE_NT_HEADERS nt_headers;
 515     DWORD import_dir_size;
 516     DWORD_PTR dir_offset;
 517     PIMAGE_IMPORT_DESCRIPTOR import_chunk;
 518
 519     /* Load kernel32 module */
 520     kernel32_module = GetModuleHandleA("kernel32.dll");
 521     assert( kernel32_module != NULL );
 522
 523     /* Get PE header info from module image */
 524     d_header = (PIMAGE_DOS_HEADER) kernel32_module;
 525     nt_headers = (PIMAGE_NT_HEADERS) (((char*) d_header) +
 526             d_header->e_lfanew);
 527
 528     /* Get size of import entry directory */
 529     import_dir_size = nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size;
 530     if (!import_dir_size)
 531     {
 532         skip("Unable to continue testing due to missing import directory.\n");
 533         return;
 534     }
 535
 536     /* Get address of first import chunk */
 537     dir_offset = nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
 538     import_chunk = RVAToAddr(dir_offset, kernel32_module);
 539     ok(import_chunk != 0, "Invalid import_chunk: %p\n", import_chunk);
 540     if (!import_chunk) return;
 541
 542     /* Iterate through import descriptors and verify set name,
 543      * OriginalFirstThunk, and FirstThunk.  Core Windows DLLs, such as
 544      * kernel32.dll, don't use Borland-style linking, where the table of
 545      * imported names is stored directly in FirstThunk and overwritten
 546      * by the relocation, instead of being stored in OriginalFirstThunk.
 547      * */
 548     for (; import_chunk->FirstThunk; import_chunk++)
 549     {
 550         LPCSTR module_name = RVAToAddr(import_chunk->Name, kernel32_module);
 551         PIMAGE_THUNK_DATA name_table = RVAToAddr(
 552                 U(*import_chunk).OriginalFirstThunk, kernel32_module);
 553         PIMAGE_THUNK_DATA iat = RVAToAddr(
 554                 import_chunk->FirstThunk, kernel32_module);
 555         ok(module_name != NULL, "Imported module name should not be NULL\n");
 556         ok(name_table != NULL,
 557                 "Name table for imported module %s should not be NULL\n",
 558                 module_name);
 559         ok(iat != NULL, "IAT for imported module %s should not be NULL\n",
 560                 module_name);
 561     }
 562 }
 563
 564 static void test_image_mapping(const char *dll_name, DWORD scn_page_access, BOOL is_dll)
 565 {
 566     HANDLE hfile, hmap;
 567     NTSTATUS status;
 568     LARGE_INTEGER offset;
 569     SIZE_T size;
 570     void *addr1, *addr2;
 571     MEMORY_BASIC_INFORMATION info;
 572     SYSTEM_INFO si;
 573
 574     if (!pNtMapViewOfSection) return;
 575
 576     GetSystemInfo(&si);
 577
 578     SetLastError(0xdeadbeef);
 579     hfile = CreateFile(dll_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 580     ok(hfile != INVALID_HANDLE_VALUE, "CreateFile error %d\n", GetLastError());
 581
 582     SetLastError(0xdeadbeef);
 583     hmap = CreateFileMapping(hfile, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, 0);
 584     ok(hmap != 0, "CreateFileMapping error %d\n", GetLastError());
 585
 586     offset.u.LowPart  = 0;
 587     offset.u.HighPart = 0;
 588
 589     addr1 = NULL;
 590     size = 0;
 591     status = pNtMapViewOfSection(hmap, GetCurrentProcess(), &addr1, 0, 0, &offset,
 592                                  &size, 1 /* ViewShare */, 0, PAGE_READONLY);
 593     ok(status == STATUS_SUCCESS, "NtMapViewOfSection error %x\n", status);
 594     ok(addr1 != 0, "mapped address should be valid\n");
 595
 596     SetLastError(0xdeadbeef);
 597     size = VirtualQuery((char *)addr1 + section.VirtualAddress, &info, sizeof(info));
 598     ok(size == sizeof(info), "VirtualQuery error %d\n", GetLastError());
 599     ok(info.BaseAddress == (char *)addr1 + section.VirtualAddress, "got %p != expected %p\n", info.BaseAddress, (char *)addr1 + section.VirtualAddress);
 600     ok(info.RegionSize == si.dwPageSize, "got %#lx != expected %#x\n", info.RegionSize, si.dwPageSize);
 601     ok(info.Protect == scn_page_access, "got %#x != expected %#x\n", info.Protect, scn_page_access);
 602     ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
 603     ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%#x != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
 604     ok(info.State == MEM_COMMIT, "%#x != MEM_COMMIT\n", info.State);
 605     ok(info.Type == SEC_IMAGE, "%#x != SEC_IMAGE\n", info.Type);
 606
 607     addr2 = NULL;
 608     size = 0;
 609     status = pNtMapViewOfSection(hmap, GetCurrentProcess(), &addr2, 0, 0, &offset,
 610                                  &size, 1 /* ViewShare */, 0, PAGE_READONLY);
 611     /* FIXME: remove once Wine is fixed */
 612     if (status != STATUS_IMAGE_NOT_AT_BASE)
 613     {
 614         todo_wine {
 615         ok(status == STATUS_IMAGE_NOT_AT_BASE, "expected STATUS_IMAGE_NOT_AT_BASE, got %x\n", status);
 616         ok(addr2 != 0, "mapped address should be valid\n");
 617         }
 618         goto wine_is_broken;
 619     }
 620     ok(status == STATUS_IMAGE_NOT_AT_BASE, "expected STATUS_IMAGE_NOT_AT_BASE, got %x\n", status);
 621     ok(addr2 != 0, "mapped address should be valid\n");
 622     ok(addr2 != addr1, "mapped addresses should be different\n");
 623
 624     SetLastError(0xdeadbeef);
 625     size = VirtualQuery((char *)addr2 + section.VirtualAddress, &info, sizeof(info));
 626     ok(size == sizeof(info), "VirtualQuery error %d\n", GetLastError());
 627     ok(info.BaseAddress == (char *)addr2 + section.VirtualAddress, "got %p != expected %p\n", info.BaseAddress, (char *)addr2 + section.VirtualAddress);
 628     ok(info.RegionSize == si.dwPageSize, "got %#lx != expected %#x\n", info.RegionSize, si.dwPageSize);
 629     ok(info.Protect == scn_page_access, "got %#x != expected %#x\n", info.Protect, scn_page_access);
 630     ok(info.AllocationBase == addr2, "%p != %p\n", info.AllocationBase, addr2);
 631     ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%#x != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
 632     ok(info.State == MEM_COMMIT, "%#x != MEM_COMMIT\n", info.State);
 633     ok(info.Type == SEC_IMAGE, "%#x != SEC_IMAGE\n", info.Type);
 634
 635     status = pNtUnmapViewOfSection(GetCurrentProcess(), addr2);
 636     ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection error %x\n", status);
 637
 638     addr2 = MapViewOfFile(hmap, 0, 0, 0, 0);
 639     ok(addr2 != 0, "mapped address should be valid\n");
 640     ok(addr2 != addr1, "mapped addresses should be different\n");
 641
 642     SetLastError(0xdeadbeef);
 643     size = VirtualQuery((char *)addr2 + section.VirtualAddress, &info, sizeof(info));
 644     ok(size == sizeof(info), "VirtualQuery error %d\n", GetLastError());
 645     ok(info.BaseAddress == (char *)addr2 + section.VirtualAddress, "got %p != expected %p\n", info.BaseAddress, (char *)addr2 + section.VirtualAddress);
 646     ok(info.RegionSize == si.dwPageSize, "got %#lx != expected %#x\n", info.RegionSize, si.dwPageSize);
 647     ok(info.Protect == scn_page_access, "got %#x != expected %#x\n", info.Protect, scn_page_access);
 648     ok(info.AllocationBase == addr2, "%p != %p\n", info.AllocationBase, addr2);
 649     ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%#x != PAGE_EXECUTE_WRITECOPY\n", info.AllocationProtect);
 650     ok(info.State == MEM_COMMIT, "%#x != MEM_COMMIT\n", info.State);
 651     ok(info.Type == SEC_IMAGE, "%#x != SEC_IMAGE\n", info.Type);
 652
 653     UnmapViewOfFile(addr2);
 654
 655     SetLastError(0xdeadbeef);
 656     addr2 = LoadLibrary(dll_name);
 657     if (is_dll)
 658     {
 659         ok(!addr2, "LoadLibrary should fail, is_dll %d\n", is_dll);
 660         ok(GetLastError() == ERROR_INVALID_ADDRESS, "expected ERROR_INVALID_ADDRESS, got %d\n", GetLastError());
 661     }
 662     else
 663     {
 664         BOOL ret;
 665         ok(addr2 != 0, "LoadLibrary error %d, is_dll %d\n", GetLastError(), is_dll);
 666         ok(addr2 != addr1, "mapped addresses should be different\n");
 667
 668         SetLastError(0xdeadbeef);
 669         ret = FreeLibrary(addr2);
 670         ok(ret, "FreeLibrary error %d\n", GetLastError());
 671     }
 672
 673 wine_is_broken:
 674     status = pNtUnmapViewOfSection(GetCurrentProcess(), addr1);
 675     ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection error %x\n", status);
 676
 677     CloseHandle(hmap);
 678     CloseHandle(hfile);
 679 }
 680
 681 static BOOL is_mem_writable(DWORD prot)
 682 {
 683     switch (prot & 0xff)
 684     {
 685         case PAGE_READWRITE:
 686         case PAGE_WRITECOPY:
 687         case PAGE_EXECUTE_READWRITE:
 688         case PAGE_EXECUTE_WRITECOPY:
 689             return TRUE;
 690
 691         default:
 692             return FALSE;
 693     }
 694 }
 695
 696 static void test_VirtualProtect(void *base, void *section)
 697 {
 698     static const struct test_data
 699     {
 700         DWORD prot_set, prot_get;
 701     } td[] =
 702     {
 703         { 0, 0 }, /* 0x00 */
 704         { PAGE_NOACCESS, PAGE_NOACCESS }, /* 0x01 */
 705         { PAGE_READONLY, PAGE_READONLY }, /* 0x02 */
 706         { PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x03 */
 707         { PAGE_READWRITE, PAGE_WRITECOPY }, /* 0x04 */
 708         { PAGE_READWRITE | PAGE_NOACCESS, 0 }, /* 0x05 */
 709         { PAGE_READWRITE | PAGE_READONLY, 0 }, /* 0x06 */
 710         { PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x07 */
 711         { PAGE_WRITECOPY, PAGE_WRITECOPY }, /* 0x08 */
 712         { PAGE_WRITECOPY | PAGE_NOACCESS, 0 }, /* 0x09 */
 713         { PAGE_WRITECOPY | PAGE_READONLY, 0 }, /* 0x0a */
 714         { PAGE_WRITECOPY | PAGE_NOACCESS | PAGE_READONLY, 0 }, /* 0x0b */
 715         { PAGE_WRITECOPY | PAGE_READWRITE, 0 }, /* 0x0c */
 716         { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_NOACCESS, 0 }, /* 0x0d */
 717         { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY, 0 }, /* 0x0e */
 718         { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x0f */
 719
 720         { PAGE_EXECUTE, PAGE_EXECUTE }, /* 0x10 */
 721         { PAGE_EXECUTE_READ, PAGE_EXECUTE_READ }, /* 0x20 */
 722         { PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0x30 */
 723         { PAGE_EXECUTE_READWRITE, PAGE_EXECUTE_WRITECOPY }, /* 0x40 */
 724         { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, 0 }, /* 0x50 */
 725         { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, 0 }, /* 0x60 */
 726         { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0x70 */
 727         { PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_WRITECOPY }, /* 0x80 */
 728         { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE, 0 }, /* 0x90 */
 729         { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ, 0 }, /* 0xa0 */
 730         { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0xb0 */
 731         { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE, 0 }, /* 0xc0 */
 732         { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, 0 }, /* 0xd0 */
 733         { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, 0 }, /* 0xe0 */
 734         { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 } /* 0xf0 */
 735     };
 736     DWORD ret, orig_prot, old_prot, rw_prot, exec_prot, i, j;
 737     MEMORY_BASIC_INFORMATION info;
 738     SYSTEM_INFO si;
 739
 740     GetSystemInfo(&si);
 741     trace("system page size %#x\n", si.dwPageSize);
 742
 743     SetLastError(0xdeadbeef);
 744     ret = VirtualProtect(section, si.dwPageSize, PAGE_NOACCESS, &old_prot);
 745     ok(ret, "VirtualProtect error %d\n", GetLastError());
 746
 747     orig_prot = old_prot;
 748
 749     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
 750     {
 751         SetLastError(0xdeadbeef);
 752         ret = VirtualQuery(section, &info, sizeof(info));
 753         ok(ret, "VirtualQuery failed %d\n", GetLastError());
 754         ok(info.BaseAddress == section, "%d: got %p != expected %p\n", i, info.BaseAddress, section);
 755         ok(info.RegionSize == si.dwPageSize, "%d: got %#lx != expected %#x\n", i, info.RegionSize, si.dwPageSize);
 756         ok(info.Protect == PAGE_NOACCESS, "%d: got %#x != expected PAGE_NOACCESS\n", i, info.Protect);
 757         ok(info.AllocationBase == base, "%d: %p != %p\n", i, info.AllocationBase, base);
 758         ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
 759         ok(info.State == MEM_COMMIT, "%d: %#x != MEM_COMMIT\n", i, info.State);
 760         ok(info.Type == SEC_IMAGE, "%d: %#x != SEC_IMAGE\n", i, info.Type);
 761
 762         old_prot = 0xdeadbeef;
 763         SetLastError(0xdeadbeef);
 764         ret = VirtualProtect(section, si.dwPageSize, td[i].prot_set, &old_prot);
 765         if (td[i].prot_get)
 766         {
 767             ok(ret, "%d: VirtualProtect error %d, requested prot %#x\n", i, GetLastError(), td[i].prot_set);
 768             ok(old_prot == PAGE_NOACCESS, "%d: got %#x != expected PAGE_NOACCESS\n", i, old_prot);
 769
 770             SetLastError(0xdeadbeef);
 771             ret = VirtualQuery(section, &info, sizeof(info));
 772             ok(ret, "VirtualQuery failed %d\n", GetLastError());
 773             ok(info.BaseAddress == section, "%d: got %p != expected %p\n", i, info.BaseAddress, section);
 774             ok(info.RegionSize == si.dwPageSize, "%d: got %#lx != expected %#x\n", i, info.RegionSize, si.dwPageSize);
 775             ok(info.Protect == td[i].prot_get, "%d: got %#x != expected %#x\n", i, info.Protect, td[i].prot_get);
 776             ok(info.AllocationBase == base, "%d: %p != %p\n", i, info.AllocationBase, base);
 777             ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
 778             ok(info.State == MEM_COMMIT, "%d: %#x != MEM_COMMIT\n", i, info.State);
 779             ok(info.Type == SEC_IMAGE, "%d: %#x != SEC_IMAGE\n", i, info.Type);
 780         }
 781         else
 782         {
 783             ok(!ret, "%d: VirtualProtect should fail\n", i);
 784             ok(GetLastError() == ERROR_INVALID_PARAMETER, "%d: expected ERROR_INVALID_PARAMETER, got %d\n", i, GetLastError());
 785         }
 786
 787         old_prot = 0xdeadbeef;
 788         SetLastError(0xdeadbeef);
 789         ret = VirtualProtect(section, si.dwPageSize, PAGE_NOACCESS, &old_prot);
 790         ok(ret, "%d: VirtualProtect error %d\n", i, GetLastError());
 791         if (td[i].prot_get)
 792             ok(old_prot == td[i].prot_get, "%d: got %#x != expected %#x\n", i, old_prot, td[i].prot_get);
 793         else
 794             ok(old_prot == PAGE_NOACCESS, "%d: got %#x != expected PAGE_NOACCESS\n", i, old_prot);
 795     }
 796
 797     exec_prot = 0;
 798
 799     for (i = 0; i <= 4; i++)
 800     {
 801         rw_prot = 0;
 802
 803         for (j = 0; j <= 4; j++)
 804         {
 805             DWORD prot = exec_prot | rw_prot;
 806
 807             SetLastError(0xdeadbeef);
 808             ret = VirtualProtect(section, si.dwPageSize, prot, &old_prot);
 809             if ((rw_prot && exec_prot) || (!rw_prot && !exec_prot))
 810             {
 811                 ok(!ret, "VirtualProtect(%02x) should fail\n", prot);
 812                 ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 813             }
 814             else
 815                 ok(ret, "VirtualProtect(%02x) error %d\n", prot, GetLastError());
 816
 817             rw_prot = 1 << j;
 818         }
 819
 820         exec_prot = 1 << (i + 4);
 821     }
 822
 823     SetLastError(0xdeadbeef);
 824     ret = VirtualProtect(section, si.dwPageSize, orig_prot, &old_prot);
 825     ok(ret, "VirtualProtect error %d\n", GetLastError());
 826 }
 827
 828 static void test_section_access(void)
 829 {
 830     static const struct test_data
 831     {
 832         DWORD scn_file_access, scn_page_access, scn_page_access_after_write;
 833     } td[] =
 834     {
 835         { 0, PAGE_NOACCESS, 0 },
 836         { IMAGE_SCN_MEM_READ, PAGE_READONLY, 0 },
 837         { IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
 838         { IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE, 0 },
 839         { IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
 840         { IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_READ },
 841         { IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
 842         { IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
 843
 844         { IMAGE_SCN_CNT_INITIALIZED_DATA, PAGE_NOACCESS, 0 },
 845         { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ, PAGE_READONLY, 0 },
 846         { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
 847         { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE, 0 },
 848         { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
 849         { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_READ, 0 },
 850         { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
 851         { IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
 852
 853         { IMAGE_SCN_CNT_UNINITIALIZED_DATA, PAGE_NOACCESS, 0 },
 854         { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ, PAGE_READONLY, 0 },
 855         { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
 856         { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE, 0 },
 857         { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, PAGE_WRITECOPY, PAGE_READWRITE },
 858         { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_READ, 0 },
 859         { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE },
 860         { IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE, PAGE_EXECUTE_WRITECOPY, PAGE_EXECUTE_READWRITE }
 861     };
 862     static const char filler[0x1000];
 863     static const char section_data[0x10] = "section data";
 864     char buf[256];
 865     int i;
 866     DWORD dummy, file_align;
 867     HANDLE hfile;
 868     HMODULE hlib;
 869     SYSTEM_INFO si;
 870     char temp_path[MAX_PATH];
 871     char dll_name[MAX_PATH];
 872     SIZE_T size;
 873     MEMORY_BASIC_INFORMATION info;
 874     STARTUPINFO sti;
 875     PROCESS_INFORMATION pi;
 876     DWORD ret;
 877
 878     GetSystemInfo(&si);
 879     trace("system page size %#x\n", si.dwPageSize);
 880
 881     /* prevent displaying of the "Unable to load this DLL" message box */
 882     SetErrorMode(SEM_FAILCRITICALERRORS);
 883
 884     GetTempPath(MAX_PATH, temp_path);
 885
 886     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
 887     {
 888         GetTempFileName(temp_path, "ldr", 0, dll_name);
 889
 890         /*trace("creating %s\n", dll_name);*/
 891         hfile = CreateFileA(dll_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 892         if (hfile == INVALID_HANDLE_VALUE)
 893         {
 894             ok(0, "could not create %s\n", dll_name);
 895             return;
 896         }
 897
 898         SetLastError(0xdeadbeef);
 899         ret = WriteFile(hfile, &dos_header, sizeof(dos_header), &dummy, NULL);
 900         ok(ret, "WriteFile error %d\n", GetLastError());
 901
 902         nt_header.FileHeader.NumberOfSections = 1;
 903         nt_header.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER);
 904         nt_header.FileHeader.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL | IMAGE_FILE_RELOCS_STRIPPED;
 905
 906         nt_header.OptionalHeader.SectionAlignment = si.dwPageSize;
 907         nt_header.OptionalHeader.FileAlignment = 0x200;
 908         nt_header.OptionalHeader.SizeOfImage = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER) + si.dwPageSize;
 909         nt_header.OptionalHeader.SizeOfHeaders = sizeof(dos_header) + sizeof(nt_header) + sizeof(IMAGE_SECTION_HEADER);
 910         SetLastError(0xdeadbeef);
 911         ret = WriteFile(hfile, &nt_header, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), &dummy, NULL);
 912         ok(ret, "WriteFile error %d\n", GetLastError());
 913         SetLastError(0xdeadbeef);
 914         ret = WriteFile(hfile, &nt_header.OptionalHeader, sizeof(IMAGE_OPTIONAL_HEADER), &dummy, NULL);
 915         ok(ret, "WriteFile error %d\n", GetLastError());
 916
 917         section.SizeOfRawData = sizeof(section_data);
 918         section.PointerToRawData = nt_header.OptionalHeader.FileAlignment;
 919         section.VirtualAddress = nt_header.OptionalHeader.SectionAlignment;
 920         section.Misc.VirtualSize = section.SizeOfRawData;
 921         section.Characteristics = td[i].scn_file_access;
 922         SetLastError(0xdeadbeef);
 923         ret = WriteFile(hfile, &section, sizeof(section), &dummy, NULL);
 924         ok(ret, "WriteFile error %d\n", GetLastError());
 925
 926         file_align = nt_header.OptionalHeader.FileAlignment - nt_header.OptionalHeader.SizeOfHeaders;
 927         assert(file_align < sizeof(filler));
 928         SetLastError(0xdeadbeef);
 929         ret = WriteFile(hfile, filler, file_align, &dummy, NULL);
 930         ok(ret, "WriteFile error %d\n", GetLastError());
 931
 932         /* section data */
 933         SetLastError(0xdeadbeef);
 934         ret = WriteFile(hfile, section_data, sizeof(section_data), &dummy, NULL);
 935         ok(ret, "WriteFile error %d\n", GetLastError());
 936
 937         CloseHandle(hfile);
 938
 939         SetLastError(0xdeadbeef);
 940         hlib = LoadLibrary(dll_name);
 941         ok(hlib != 0, "LoadLibrary error %d\n", GetLastError());
 942
 943         SetLastError(0xdeadbeef);
 944         size = VirtualQuery((char *)hlib + section.VirtualAddress, &info, sizeof(info));
 945         ok(size == sizeof(info),
 946             "%d: VirtualQuery error %d\n", i, GetLastError());
 947         ok(info.BaseAddress == (char *)hlib + section.VirtualAddress, "%d: got %p != expected %p\n", i, info.BaseAddress, (char *)hlib + section.VirtualAddress);
 948         ok(info.RegionSize == si.dwPageSize, "%d: got %#lx != expected %#x\n", i, info.RegionSize, si.dwPageSize);
 949         ok(info.Protect == td[i].scn_page_access, "%d: got %#x != expected %#x\n", i, info.Protect, td[i].scn_page_access);
 950         ok(info.AllocationBase == hlib, "%d: %p != %p\n", i, info.AllocationBase, hlib);
 951         ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
 952         ok(info.State == MEM_COMMIT, "%d: %#x != MEM_COMMIT\n", i, info.State);
 953         ok(info.Type == SEC_IMAGE, "%d: %#x != SEC_IMAGE\n", i, info.Type);
 954         if (info.Protect != PAGE_NOACCESS)
 955             ok(!memcmp((const char *)info.BaseAddress, section_data, section.SizeOfRawData), "wrong section data\n");
 956
 957         test_VirtualProtect(hlib, (char *)hlib + section.VirtualAddress);
 958
 959         /* Windows changes the WRITECOPY to WRITE protection on an image section write (for a changed page only) */
 960         if (is_mem_writable(info.Protect))
 961         {
 962             char *p = info.BaseAddress;
 963             *p = 0xfe;
 964             SetLastError(0xdeadbeef);
 965             size = VirtualQuery((char *)hlib + section.VirtualAddress, &info, sizeof(info));
 966             ok(size == sizeof(info), "%d: VirtualQuery error %d\n", i, GetLastError());
 967             /* FIXME: remove the condition below once Wine is fixed */
 968             if (info.Protect == PAGE_WRITECOPY || info.Protect == PAGE_EXECUTE_WRITECOPY)
 969                 todo_wine ok(info.Protect == td[i].scn_page_access_after_write, "%d: got %#x != expected %#x\n", i, info.Protect, td[i].scn_page_access_after_write);
 970             else
 971                 ok(info.Protect == td[i].scn_page_access_after_write, "%d: got %#x != expected %#x\n", i, info.Protect, td[i].scn_page_access_after_write);
 972         }
 973
 974         SetLastError(0xdeadbeef);
 975         ret = FreeLibrary(hlib);
 976         ok(ret, "FreeLibrary error %d\n", GetLastError());
 977
 978         test_image_mapping(dll_name, td[i].scn_page_access, TRUE);
 979
 980         /* reset IMAGE_FILE_DLL otherwise CreateProcess fails */
 981         nt_header.FileHeader.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_RELOCS_STRIPPED;
 982         SetLastError(0xdeadbeef);
 983         hfile = CreateFile(dll_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
 984         /* LoadLibrary called on an already memory-mapped file in
 985          * test_image_mapping() above leads to a file handle leak
 986          * under nt4, and inability to overwrite and delete the file
 987          * due to sharing violation error. Ignore it and skip the test,
 988          * but leave a not deletable temporary file.
 989          */
 990         ok(hfile != INVALID_HANDLE_VALUE || broken(hfile == INVALID_HANDLE_VALUE) /* nt4 */,
 991             "CreateFile error %d\n", GetLastError());
 992         if (hfile == INVALID_HANDLE_VALUE) goto nt4_is_broken;
 993         SetFilePointer(hfile, sizeof(dos_header), NULL, FILE_BEGIN);
 994         SetLastError(0xdeadbeef);
 995         ret = WriteFile(hfile, &nt_header, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), &dummy, NULL);
 996         ok(ret, "WriteFile error %d\n", GetLastError());
 997         CloseHandle(hfile);
 998
 999         memset(&sti, 0, sizeof(sti));
1000         sti.cb = sizeof(sti);
1001         SetLastError(0xdeadbeef);
1002         ret = CreateProcess(dll_name, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &sti, &pi);
1003         ok(ret, "CreateProcess() error %d\n", GetLastError());
1004
1005         SetLastError(0xdeadbeef);
1006         size = VirtualQueryEx(pi.hProcess, (char *)hlib + section.VirtualAddress, &info, sizeof(info));
1007         ok(size == sizeof(info),
1008             "%d: VirtualQuery error %d\n", i, GetLastError());
1009         ok(info.BaseAddress == (char *)hlib + section.VirtualAddress, "%d: got %p != expected %p\n", i, info.BaseAddress, (char *)hlib + section.VirtualAddress);
1010         ok(info.RegionSize == si.dwPageSize, "%d: got %#lx != expected %#x\n", i, info.RegionSize, si.dwPageSize);
1011         ok(info.Protect == td[i].scn_page_access, "%d: got %#x != expected %#x\n", i, info.Protect, td[i].scn_page_access);
1012         ok(info.AllocationBase == hlib, "%d: %p != %p\n", i, info.AllocationBase, hlib);
1013         ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%d: %#x != PAGE_EXECUTE_WRITECOPY\n", i, info.AllocationProtect);
1014         ok(info.State == MEM_COMMIT, "%d: %#x != MEM_COMMIT\n", i, info.State);
1015         ok(info.Type == SEC_IMAGE, "%d: %#x != SEC_IMAGE\n", i, info.Type);
1016         if (info.Protect != PAGE_NOACCESS)
1017         {
1018             SetLastError(0xdeadbeef);
1019             ret = ReadProcessMemory(pi.hProcess, info.BaseAddress, buf, section.SizeOfRawData, NULL);
1020             ok(ret, "ReadProcessMemory() error %d\n", GetLastError());
1021             ok(!memcmp(buf, section_data, section.SizeOfRawData), "wrong section data\n");
1022         }
1023
1024         SetLastError(0xdeadbeef);
1025         ret = TerminateProcess(pi.hProcess, 0);
1026         ok(ret, "TerminateProcess() error %d\n", GetLastError());
1027         ret = WaitForSingleObject(pi.hProcess, 3000);
1028         ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed: %x\n", ret);
1029
1030         CloseHandle(pi.hThread);
1031         CloseHandle(pi.hProcess);
1032
1033         test_image_mapping(dll_name, td[i].scn_page_access, FALSE);
1034
1035 nt4_is_broken:
1036         SetLastError(0xdeadbeef);
1037         ret = DeleteFile(dll_name);
1038         ok(ret || broken(!ret) /* nt4 */, "DeleteFile error %d\n", GetLastError());
1039     }
1040 }
1041
1042 START_TEST(loader)
1043 {
1044     pNtMapViewOfSection = (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtMapViewOfSection");
1045     pNtUnmapViewOfSection = (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtUnmapViewOfSection");
1046
1047     test_Loader();
1048     test_ImportDescriptors();
1049     test_section_access();
1050 }