void Test_RtlInitializeBitMap(void) { RTL_BITMAP BitMapHeader; ULONG Buffer[2]; BOOLEAN Exception = FALSE; _SEH2_TRY { RtlInitializeBitMap(NULL, NULL, 0); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Exception = TRUE; } _SEH2_END; ok_int(Exception, 1); memset(Buffer, 0xcc, sizeof(Buffer)); RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(BitMapHeader.SizeOfBitMap, 0); ok_ptr(BitMapHeader.Buffer, Buffer); ok_hex(Buffer[0], 0xcccccccc); RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(BitMapHeader.SizeOfBitMap, 8); ok_hex(Buffer[0], 0xcccccccc); }
void Test_RtlAreBitsSet(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); RtlInitializeBitMap(&BitMapHeader, Buffer, 19); Buffer[0] = 0xff00ff00; Buffer[1] = 0x3F303F30; ok_hex(RtlAreBitsSet(&BitMapHeader, 0, 8), FALSE); ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 8), TRUE); ok_hex(RtlAreBitsSet(&BitMapHeader, 7, 8), FALSE); ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 9), FALSE); ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), FALSE); RtlInitializeBitMap(&BitMapHeader, Buffer, 31); ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), TRUE); ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 7), TRUE); ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 8), FALSE); RtlInitializeBitMap(&BitMapHeader, Buffer, 64); ok_hex(RtlAreBitsSet(&BitMapHeader, 60, 4), FALSE); FreeGuarded(Buffer); }
static BOOLEAN ReAllocBuffer( PUCHAR *Buffer, SIZE_T Size, SIZE_T *OldSizePtr, PCSTR Action) { PUCHAR NewBuffer; SIZE_T OldSize = *OldSizePtr; RtlFillMemory(*Buffer, OldSize, 0x7a); NewBuffer = RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, *Buffer, Size); if (!NewBuffer) { skip("RtlReAllocateHeap failed for size %lu (%s)\n", Size, Action); return FALSE; } *Buffer = NewBuffer; ok_hex(RtlSizeHeap(RtlGetProcessHeap(), 0, NewBuffer), Size); if (OldSize < Size) { ok(CheckBuffer(NewBuffer, OldSize, 0x7a), "CheckBuffer failed at size 0x%lx -> 0x%lx\n", OldSize, Size); ok(CheckBuffer(NewBuffer + OldSize, Size - OldSize, 0), "HEAP_ZERO_MEMORY not respected for 0x%lx -> 0x%lx\n", OldSize, Size); } else { ok(CheckBuffer(NewBuffer, Size, 0x7a), "CheckBuffer failed at size 0x%lx -> 0x%lx\n", OldSize, Size); } *OldSizePtr = Size; return TRUE; }
void Test_RtlSetAllBits(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; ULONG BufferSize = 2 * sizeof(*Buffer); Buffer = AllocateGuarded(BufferSize); RtlInitializeBitMap(&BitMapHeader, Buffer, 19); memset(Buffer, 0xcc, BufferSize); RtlSetAllBits(&BitMapHeader); ok_hex(Buffer[0], 0xffffffff); ok_hex(Buffer[1], 0xcccccccc); RtlInitializeBitMap(&BitMapHeader, Buffer, 0); memset(Buffer, 0xcc, BufferSize); RtlSetAllBits(&BitMapHeader); ok_hex(Buffer[0], 0xcccccccc); ok_hex(Buffer[1], 0xcccccccc); RtlInitializeBitMap(&BitMapHeader, Buffer, 64); memset(Buffer, 0xcc, BufferSize); RtlSetAllBits(&BitMapHeader); ok_hex(Buffer[0], 0xffffffff); ok_hex(Buffer[1], 0xffffffff); FreeGuarded(Buffer); }
static void Test_Data(PTEST_IMAGE TestImage) { LDR_RESOURCE_INFO ResourceInfo; LDR_ENUM_RESOURCE_INFO EnumRes[8]; ULONG ResourceCount; NTSTATUS Status; InitializeTestImage(TestImage); memset(EnumRes, 0xcc, sizeof(EnumRes)); ResourceInfo.Type = 1; ResourceInfo.Name = 1; ResourceInfo.Language = 0x408; ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 0, &ResourceCount, EnumRes); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 8); ok_ptr((PVOID)EnumRes[0].Data, TestImage->Resources.StringBuffer); ok_dec(EnumRes[0].Size, 2); ok_enumres(&EnumRes[0], 1, L"TEST", 0x409, TestImage->Resources.StringBuffer, 2) ok_enumres(&EnumRes[1], 1, L"TEST", 0x407, TestImage->Resources.StringBuffer + 2, 4) ok_enumres(&EnumRes[2], 1, 7, 0x408, TestImage->Resources.StringBuffer + 4, 6) ok_enumres(&EnumRes[3], 1, 7, 0x406, TestImage->Resources.StringBuffer + 6, 8) ok_enumres(&EnumRes[4], 2, L"LOL", 0x405, TestImage->Resources.StringBuffer + 8, 10) ok_enumres(&EnumRes[5], 2, L"LOL", 0x403, TestImage->Resources.StringBuffer + 10, 12) ok_enumres(&EnumRes[6], 2, L"xD", 0x402, TestImage->Resources.StringBuffer + 12, 14) ok_enumres(&EnumRes[7], 2, L"xD", 0x404, TestImage->Resources.StringBuffer + 14, 16) Status = LdrEnumResources(TestImage, &ResourceInfo, 1, &ResourceCount, EnumRes); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 4); }
void Test_WSAIoctl_GetInterfaceList() { WSADATA wdata; INT iResult; SOCKET sck; ULONG buflen, BytesReturned, BCastAddr; ULONG infoCount, i1, j1, iiFlagsExpected; BYTE* buf = NULL; LPINTERFACE_INFO ifInfo; PMIB_IPADDRTABLE pTable = NULL; PMIB_IPADDRROW pRow; /* Get PMIB_IPADDRTABE - these results we should get from wshtcpip.dll too. */ /* pTable is allocated by Test_WSAIoctl_InitTest! */ if (!Test_WSAIoctl_InitTest(&pTable)) goto cleanup; /* Start up Winsock */ iResult = WSAStartup(MAKEWORD(2, 2), &wdata); ok(iResult == 0, "WSAStartup failed. iResult = %d\n", iResult); /* Create the socket */ sck = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_IP, 0, 0, 0); ok(sck != INVALID_SOCKET, "WSASocket failed. sck = %d\n", (INT)sck); if (sck == INVALID_SOCKET) { skip("Failed to create socket!\n"); goto cleanup; } /* Do the Ioctl (buffer to small) */ buflen = sizeof(INTERFACE_INFO)-1; buf = (BYTE*)HeapAlloc(GetProcessHeap(), 0, buflen); if (buf == NULL) { skip("Failed to allocate memory!\n"); goto cleanup; } BytesReturned = 0; iResult = WSAIoctl(sck, SIO_GET_INTERFACE_LIST, 0, 0, buf, buflen, &BytesReturned, 0, 0); ok(iResult == -1, "WSAIoctl/SIO_GET_INTERFACE_LIST did not fail! iResult = %d.\n", iResult); ok_hex(WSAGetLastError(), WSAEFAULT); ok(BytesReturned == 0, "WSAIoctl/SIO_GET_INTERFACE_LIST: BytesReturned should be 0, not %ld.\n", BytesReturned); HeapFree(GetProcessHeap(), 0, buf); buf = NULL; /* Do the Ioctl In most cases no loop is done. Only if WSAIoctl fails with WSAEFAULT (buffer to small) we need to retry with a larger buffer */ i1 = 0; while (TRUE) { if (buf != NULL) { HeapFree(GetProcessHeap(), 0, buf); buf = NULL; } buflen = sizeof(INTERFACE_INFO) * (i1+1) * 32; buf = (BYTE*)HeapAlloc(GetProcessHeap(), 0, buflen); if (buf == NULL) { skip("Failed to allocate memory!\n"); goto cleanup; } BytesReturned = 0; iResult = WSAIoctl(sck, SIO_GET_INTERFACE_LIST, 0, 0, buf, buflen, &BytesReturned, 0, 0); /* we have what we want ... leave loop */ if (iResult == NO_ERROR) break; /* only retry if buffer was to small */ /* to avoid infinite loop we maximum retry count is 4 */ if ((i1 >= 4) || (WSAGetLastError() != WSAEFAULT)) { ok_hex(iResult, NO_ERROR); skip("WSAIoctl / SIO_GET_INTERFACE_LIST\n"); goto cleanup; } /* buffer to small -> retry */ i1++; } ok_dec(BytesReturned % sizeof(INTERFACE_INFO), 0); /* Calculate how many INTERFACE_INFO we got */ infoCount = BytesReturned / sizeof(INTERFACE_INFO); ok(infoCount == pTable->dwNumEntries, "Wrong count of entries! Got %ld, expected %ld.\n", pTable->dwNumEntries, infoCount); if (winetest_debug >= 2) { trace("WSAIoctl\n"); trace(" BytesReturned %ld - InfoCount %ld\n ", BytesReturned, infoCount); ifInfo = (LPINTERFACE_INFO)buf; for (i1 = 0; i1 < infoCount; i1++) { trace("entry-index %ld\n", i1); trace(" iiFlags %ld\n", ifInfo->iiFlags); traceaddr("ifInfo^.iiAddress", ifInfo->iiAddress); traceaddr("ifInfo^.iiBroadcastAddress", ifInfo->iiBroadcastAddress); traceaddr("ifInfo^.iiNetmask", ifInfo->iiNetmask); ifInfo++; } } /* compare entries */ ifInfo = (LPINTERFACE_INFO)buf; for (i1 = 0; i1 < infoCount; i1++) { if (winetest_debug >= 2) trace("Entry %ld\n", i1); for (j1 = 0; j1 < pTable->dwNumEntries; j1++) { if (ifInfo[i1].iiAddress.AddressIn.sin_addr.s_addr == pTable->table[j1].dwAddr) { pRow = &pTable->table[j1]; break; } } if (j1 == pTable->dwNumEntries) { skip("Skipping interface\n"); continue; } /* iiFlags * Don't know if this value is fix for SIO_GET_INTERFACE_LIST! */ iiFlagsExpected = IFF_BROADCAST | IFF_MULTICAST; if ((pRow->wType & MIB_IPADDR_DISCONNECTED) == 0) iiFlagsExpected |= IFF_UP; if (pRow->dwAddr == ntohl(INADDR_LOOPBACK)) { iiFlagsExpected |= IFF_LOOPBACK; /* on Windows 7 loopback has broadcast flag cleared */ //iiFlagsExpected &= ~IFF_BROADCAST; } ok_hex(ifInfo[i1].iiFlags, iiFlagsExpected); ok_hex(ifInfo[i1].iiAddress.AddressIn.sin_addr.s_addr, pRow->dwAddr); // dwBCastAddr is not the "real" Broadcast-Address. BCastAddr = (pRow->dwBCastAddr == 1 && (iiFlagsExpected & IFF_BROADCAST) != 0) ? 0xFFFFFFFF : 0x0; ok_hex(ifInfo[i1].iiBroadcastAddress.AddressIn.sin_addr.s_addr, BCastAddr); ok_hex(ifInfo[i1].iiNetmask.AddressIn.sin_addr.s_addr, pRow->dwMask); } cleanup: if (sck != 0) closesocket(sck); if (pTable != NULL) free(pTable); if (buf != NULL) HeapFree(GetProcessHeap(), 0, buf); WSACleanup(); }
static void Test_Parameters(PTEST_IMAGE TestImage) { LDR_RESOURCE_INFO ResourceInfo; LDR_ENUM_RESOURCE_INFO Resources[8]; ULONG ResourceCount; NTSTATUS Status; InitializeTestImage(TestImage); ResourceInfo.Type = 6; ResourceInfo.Name = 1; ResourceInfo.Language = 0x409; ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 3, &ResourceCount, Resources); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 0); ResourceInfo.Type = 1; ResourceInfo.Name = 7; ResourceInfo.Language = 0x406; ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 0, &ResourceCount, Resources); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 8); ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 1, &ResourceCount, Resources); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 4); ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 2, &ResourceCount, Resources); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 2); ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 3, &ResourceCount, Resources); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 1); ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 99, &ResourceCount, Resources); ok_hex(Status, STATUS_SUCCESS); ok_dec(ResourceCount, 1); ResourceCount = 0; Status = LdrEnumResources(TestImage, &ResourceInfo, 0, &ResourceCount, Resources); ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH); ok_dec(ResourceCount, 8); ResourceCount = 7; Status = LdrEnumResources(TestImage, &ResourceInfo, 0, &ResourceCount, Resources); ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH); ok_dec(ResourceCount, 8); ResourceCount = 8; Status = LdrEnumResources(NULL, &ResourceInfo, 1, &ResourceCount, Resources); ok_hex(Status, STATUS_RESOURCE_DATA_NOT_FOUND); ok_dec(ResourceCount, 0); ResourceCount = 8; Status = LdrEnumResources(TestImage, &ResourceInfo, 1, &ResourceCount, NULL); ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH); ok_dec(ResourceCount, 4); ResourceCount = 8; _SEH2_TRY { Status = LdrEnumResources(NULL, NULL, 0, NULL, NULL); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Status = 0xDeadC0de; } _SEH2_END ok_hex(Status, 0xDeadC0de); ResourceCount = 42; _SEH2_TRY { Status = LdrEnumResources(TestImage, &ResourceInfo, 1, NULL, Resources); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Status = 0xDeadC0de; } _SEH2_END ok_hex(Status, 0xDeadC0de); ok_dec(ResourceCount, 42); ResourceCount = 8; Status = LdrEnumResources(TestImage + 2, &ResourceInfo, 1, &ResourceCount, NULL); ok_hex(Status, STATUS_RESOURCE_DATA_NOT_FOUND); ok_dec(ResourceCount, 0); TestImage->Resources.TypeEntries[0].DataIsDirectory = 0; Status = LdrEnumResources(TestImage, &ResourceInfo, 1, &ResourceCount, NULL); ok_hex(Status, STATUS_INVALID_IMAGE_FORMAT); ok_dec(ResourceCount, 0); }
void Test_RtlFindSetBitsAndClear(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0xF9F078B2; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 0), 0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 3), 0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), -1); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), -1); ok_hex(Buffer[0], 0xF9F078B2); Buffer[0] = 0xF9F078B2; RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), 1); ok_hex(Buffer[0], 0xf9f078b0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), 4); ok_hex(Buffer[0], 0xf9f078a0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 2), 5); ok_hex(Buffer[0], 0xf9f07880); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 0), -1); ok_hex(Buffer[0], 0xf9f07880); Buffer[0] = 0xF9F078B2; RtlInitializeBitMap(&BitMapHeader, Buffer, 32); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 0), 11); ok_hex(Buffer[0], 0xf9f000b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 5, 0), 20); ok_hex(Buffer[0], 0xf80000b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 11), 27); ok_hex(Buffer[0], 0x800000b2); Buffer[0] = 0xF9F078B2; ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 12), 20); ok_hex(Buffer[0], 0xf90078b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 11), 11); ok_hex(Buffer[0], 0xf90060b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 12), 13); ok_hex(Buffer[0], 0xf90000b2); FreeGuarded(Buffer); }
void Test_RtlFindClearBitsAndSet(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0x060F874D; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 0), 0); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 3), 0); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), -1); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), -1); ok_hex(Buffer[0], 0x060F874D); Buffer[0] = 0x060F874D; RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), 1); ok_hex(Buffer[0], 0x60f874f); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), 4); ok_hex(Buffer[0], 0x60f875f); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 2), 5); ok_hex(Buffer[0], 0x60f877f); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 0), -1); ok_hex(Buffer[0], 0x60f877f); Buffer[0] = 0x060F874D; RtlInitializeBitMap(&BitMapHeader, Buffer, 32); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 0), 11); ok_hex(Buffer[0], 0x60fff4d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 5, 0), 20); ok_hex(Buffer[0], 0x7ffff4d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 11), 27); ok_hex(Buffer[0], 0x7fffff4d); Buffer[0] = 0x060F874D; ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 12), 20); ok_hex(Buffer[0], 0x6ff874d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 11), 11); ok_hex(Buffer[0], 0x6ff9f4d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 12), 13); ok_hex(Buffer[0], 0x6ffff4d); FreeGuarded(Buffer); }
void Test_RtlSetBits(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; ULONG BufferSize = 2 * sizeof(*Buffer); Buffer = AllocateGuarded(BufferSize); RtlInitializeBitMap(&BitMapHeader, Buffer, 19); memset(Buffer, 0x00, BufferSize); RtlSetBits(&BitMapHeader, 0, 0); ok_hex(Buffer[0], 0x00000000); ok_hex(Buffer[1], 0x00000000); memset(Buffer, 0x00, BufferSize); RtlSetBits(&BitMapHeader, 0, 1); ok_hex(Buffer[0], 0x00000001); ok_hex(Buffer[1], 0x00000000); memset(Buffer, 0x00, BufferSize); RtlSetBits(&BitMapHeader, 21, 1); ok_hex(Buffer[0], 0x00200000); ok_hex(Buffer[1], 0x00000000); memset(Buffer, 0x00, BufferSize); RtlSetBits(&BitMapHeader, 7, 9); ok_hex(Buffer[0], 0x0000ff80); ok_hex(Buffer[1], 0x00000000); memset(Buffer, 0x00, BufferSize); RtlSetBits(&BitMapHeader, 13, 22); ok_hex(Buffer[0], 0xffffe000); ok_hex(Buffer[1], 0x00000007); memset(Buffer, 0x00, BufferSize); RtlSetBits(&BitMapHeader, 63, 1); ok_hex(Buffer[0], 0x00000000); ok_hex(Buffer[1], 0x80000000); memset(Buffer, 0xcc, BufferSize); RtlSetBits(&BitMapHeader, 3, 6); RtlSetBits(&BitMapHeader, 11, 5); RtlSetBits(&BitMapHeader, 21, 7); RtlSetBits(&BitMapHeader, 37, 4); ok_hex(Buffer[0], 0xcfecfdfc); ok_hex(Buffer[1], 0xcccccdec); FreeGuarded(Buffer); }
void Test_RtlClearBits(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; ULONG BufferSize = 2 * sizeof(*Buffer); Buffer = AllocateGuarded(BufferSize); RtlInitializeBitMap(&BitMapHeader, Buffer, 19); memset(Buffer, 0xff, BufferSize); RtlClearBits(&BitMapHeader, 0, 0); ok_hex(Buffer[0], 0xffffffff); ok_hex(Buffer[1], 0xffffffff); memset(Buffer, 0xff, BufferSize); RtlClearBits(&BitMapHeader, 0, 1); ok_hex(Buffer[0], 0xfffffffe); ok_hex(Buffer[1], 0xffffffff); memset(Buffer, 0xff, BufferSize); RtlClearBits(&BitMapHeader, 21, 1); ok_hex(Buffer[0], 0xffdfffff); ok_hex(Buffer[1], 0xffffffff); memset(Buffer, 0xff, BufferSize); RtlClearBits(&BitMapHeader, 7, 9); ok_hex(Buffer[0], 0xffff007f); ok_hex(Buffer[1], 0xffffffff); memset(Buffer, 0xff, BufferSize); RtlClearBits(&BitMapHeader, 13, 22); ok_hex(Buffer[0], 0x00001fff); ok_hex(Buffer[1], 0xfffffff8); memset(Buffer, 0xff, BufferSize); RtlClearBits(&BitMapHeader, 63, 1); ok_hex(Buffer[0], 0xffffffff); ok_hex(Buffer[1], 0x7fffffff); memset(Buffer, 0xcc, BufferSize); RtlClearBits(&BitMapHeader, 3, 6); RtlClearBits(&BitMapHeader, 11, 5); RtlClearBits(&BitMapHeader, 21, 7); RtlClearBits(&BitMapHeader, 37, 4); ok_hex(Buffer[0], 0xc00c0404); ok_hex(Buffer[1], 0xcccccc0c); FreeGuarded(Buffer); }
void Test_ImageSection(void) { UNICODE_STRING FileName; NTSTATUS Status; OBJECT_ATTRIBUTES FileObjectAttributes; IO_STATUS_BLOCK IoStatusBlock; HANDLE FileHandle, DataSectionHandle, ImageSectionHandle; PVOID DataBase, ImageBase; SIZE_T ViewSize; if (!RtlDosPathNameToNtPathName_U(L"testdata\\test.dll", &FileName, NULL, NULL)) { ok(0, "RtlDosPathNameToNtPathName_U failed\n"); return; } InitializeObjectAttributes(&FileObjectAttributes, &FileName, 0, NULL, NULL); Status = NtOpenFile(&FileHandle, GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE, &FileObjectAttributes, &IoStatusBlock, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT); ok(Status == STATUS_SUCCESS, "NtOpenFile failed, Status 0x%lx\n", Status); /* Create a data section with write access */ Status = NtCreateSection(&DataSectionHandle, SECTION_ALL_ACCESS, // DesiredAccess NULL, // ObjectAttributes NULL, // MaximumSize PAGE_READWRITE, // SectionPageProtection SEC_COMMIT, // AllocationAttributes FileHandle); ok(Status == STATUS_SUCCESS, "NtCreateSection failed, Status 0x%lx\n", Status); /* Map the data section */ DataBase = NULL; ViewSize = 0; Status = NtMapViewOfSection(DataSectionHandle, NtCurrentProcess(), &DataBase, 0, 0, NULL, &ViewSize, ViewShare, 0, PAGE_READWRITE); ok(Status == STATUS_SUCCESS, "NtMapViewOfSection failed, Status 0x%lx\n", Status); /* Check the original data */ ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n"); /* Modify the PE header (but do not flush!) */ *(ULONG*)DataBase = 0xdeadbabe; ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n"); /* Modify data in the .data section (but do not flush!) */ ok(*(ULONG*)((PUCHAR)DataBase + 0x800) == 0x12345678, "Data in .data section invalid: 0x%lx!\n", *(ULONG*)((PUCHAR)DataBase + 0x800)); *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x87654321; /* Now try to create an image section (should fail) */ Status = NtCreateSection(&ImageSectionHandle, SECTION_ALL_ACCESS, // DesiredAccess NULL, // ObjectAttributes NULL, // MaximumSize PAGE_READWRITE, // SectionPageProtection SEC_IMAGE, // AllocationAttributes FileHandle); ok(Status == STATUS_INVALID_IMAGE_NOT_MZ, "NtCreateSection failed, Status 0x%lx\n", Status); /* Restore the original header */ *(ULONG*)DataBase = 0x00905a4d; /* Modify data in the .data section (but do not flush!) */ ok_hex(*(ULONG*)((PUCHAR)DataBase + 0x800), 0x87654321); *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xdeadbabe; /* Try to create an image section again */ Status = NtCreateSection(&ImageSectionHandle, SECTION_ALL_ACCESS, // DesiredAccess NULL, // ObjectAttributes NULL, // MaximumSize PAGE_READWRITE, // SectionPageProtection SEC_IMAGE, // AllocationAttributes FileHandle); ok(Status == STATUS_SUCCESS, "NtCreateSection failed, Status 0x%lx\n", Status); /* Map the image section */ ImageBase = NULL; ViewSize = 0; Status = NtMapViewOfSection(ImageSectionHandle, NtCurrentProcess(), &ImageBase, 0, 0, NULL, &ViewSize, ViewShare, 0, PAGE_READONLY); #ifdef _M_IX86 ok(Status == STATUS_SUCCESS, "NtMapViewOfSection failed, Status 0x%lx\n", Status); #else ok(Status == STATUS_IMAGE_MACHINE_TYPE_MISMATCH, "NtMapViewOfSection failed, Status 0x%lx\n", Status); #endif /* Check the header */ ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n"); ok(*(ULONG*)ImageBase == 0x00905a4d, "Header not ok\n"); /* Check the data section. Either of these can be present! */ ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) || (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678), "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000)); /* Now modify the data again */ *(ULONG*)DataBase = 0xdeadbabe; *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xf00dada; /* Check the data */ ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n"); ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n"); ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) || (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678), "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000)); /* Flush the view */ ViewSize = 0x1000; Status = NtFlushVirtualMemory(NtCurrentProcess(), &DataBase, &ViewSize, &IoStatusBlock); ok(Status == STATUS_SUCCESS, "NtFlushVirtualMemory failed, Status 0x%lx\n", Status); /* Check the data again */ ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n"); ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) || (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678), "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000)); /* Restore the original header */ *(ULONG*)DataBase = 0x00905a4d; ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n"); /* Close the image mapping */ NtUnmapViewOfSection(NtCurrentProcess(), ImageBase); NtClose(ImageSectionHandle); /* Create an image section again */ Status = NtCreateSection(&ImageSectionHandle, SECTION_ALL_ACCESS, // DesiredAccess NULL, // ObjectAttributes NULL, // MaximumSize PAGE_READWRITE, // SectionPageProtection SEC_IMAGE, // AllocationAttributes FileHandle); ok(Status == STATUS_SUCCESS, "NtCreateSection failed, Status 0x%lx\n", Status); /* Map the image section again */ ImageBase = NULL; ViewSize = 0; Status = NtMapViewOfSection(ImageSectionHandle, NtCurrentProcess(), &ImageBase, 0, 0, NULL, &ViewSize, ViewShare, 0, PAGE_READONLY); #ifdef _M_IX86 ok(Status == STATUS_SUCCESS, "NtMapViewOfSection failed, Status 0x%lx\n", Status); #else ok(Status == STATUS_IMAGE_MACHINE_TYPE_MISMATCH, "NtMapViewOfSection failed, Status 0x%lx\n", Status); #endif /* Check the .data section again */ ok(*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0xf00dada, "Data should be synced: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000)); /* Restore the original data */ *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x12345678; /* Close the data mapping */ NtUnmapViewOfSection(NtCurrentProcess(), DataBase); NtClose(DataSectionHandle); /* Try to allocate memory inside the image mapping */ DataBase = (PUCHAR)ImageBase + 0x20000; ViewSize = 0x1000; Status = NtAllocateVirtualMemory(NtCurrentProcess(), &DataBase, 0, &ViewSize, MEM_RESERVE, PAGE_NOACCESS); ok(Status == STATUS_CONFLICTING_ADDRESSES, "Wrong Status: 0x%lx\n", Status); /* Cleanup */ NtClose(FileHandle); NtClose(ImageSectionHandle); NtUnmapViewOfSection(NtCurrentProcess(), ImageBase); }