diff --git a/debian/changelog b/debian/changelog index 28f60d74..9e2345df 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,4 +1,5 @@ wine-staging (1.7.39) UNRELEASED; urgency=low + * Added patch for tests of RtlIpv6StringToAddress, RtlIpv{4,6}StringToAddressEx (by Mark Jansen). -- Sebastian Lackner Mon, 09 Mar 2015 16:52:35 +0100 wine-staging (1.7.38) unstable; urgency=low diff --git a/patches/ntdll-LZNT1_Compression/0004-ntdll-tests-Add-tests-for-Rtl-Decompress-Compress-Bu.patch b/patches/ntdll-LZNT1_Compression/0004-ntdll-tests-Add-tests-for-Rtl-Decompress-Compress-Bu.patch index e1927c85..655bc086 100644 --- a/patches/ntdll-LZNT1_Compression/0004-ntdll-tests-Add-tests-for-Rtl-Decompress-Compress-Bu.patch +++ b/patches/ntdll-LZNT1_Compression/0004-ntdll-tests-Add-tests-for-Rtl-Decompress-Compress-Bu.patch @@ -1,4 +1,4 @@ -From cced4a3d6938fe54b949dcff24a645d6f3e8b015 Mon Sep 17 00:00:00 2001 +From 6b246b16957c097a43fa5b37399cd97a24ad045b Mon Sep 17 00:00:00 2001 From: Sebastian Lackner Date: Thu, 30 Oct 2014 17:41:11 +0100 Subject: ntdll/tests: Add tests for Rtl[Decompress|Compress]Buffer and @@ -9,13 +9,13 @@ Subject: ntdll/tests: Add tests for Rtl[Decompress|Compress]Buffer and 1 file changed, 740 insertions(+) diff --git a/dlls/ntdll/tests/rtl.c b/dlls/ntdll/tests/rtl.c -index e8eb04a..2f6c421 100644 +index 79c4974..0c4d684 100644 --- a/dlls/ntdll/tests/rtl.c +++ b/dlls/ntdll/tests/rtl.c -@@ -92,6 +92,10 @@ static NTSTATUS (WINAPI *pRtlIpv4StringToAddressA)(PCSTR, BOOLEAN, PCSTR *, IN_ - static NTSTATUS (WINAPI *pLdrAddRefDll)(ULONG, HMODULE); +@@ -99,6 +99,10 @@ static NTSTATUS (WINAPI *pLdrAddRefDll)(ULONG, HMODULE); static NTSTATUS (WINAPI *pLdrLockLoaderLock)(ULONG, ULONG*, ULONG_PTR*); static NTSTATUS (WINAPI *pLdrUnlockLoaderLock)(ULONG, ULONG_PTR); + static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD); +static NTSTATUS (WINAPI *pRtlGetCompressionWorkSpaceSize)(USHORT, PULONG, PULONG); +static NTSTATUS (WINAPI *pRtlDecompressBuffer)(USHORT, PUCHAR, ULONG, const UCHAR*, ULONG, PULONG); +static NTSTATUS (WINAPI *pRtlDecompressFragment)(USHORT, PUCHAR, ULONG, const UCHAR*, ULONG, ULONG, PULONG, PVOID); @@ -23,10 +23,10 @@ index e8eb04a..2f6c421 100644 static HMODULE hkernel32 = 0; static BOOL (WINAPI *pIsWow64Process)(HANDLE, PBOOL); -@@ -139,6 +143,10 @@ static void InitFunctionPtrs(void) - pLdrAddRefDll = (void *)GetProcAddress(hntdll, "LdrAddRefDll"); +@@ -152,6 +156,10 @@ static void InitFunctionPtrs(void) pLdrLockLoaderLock = (void *)GetProcAddress(hntdll, "LdrLockLoaderLock"); pLdrUnlockLoaderLock = (void *)GetProcAddress(hntdll, "LdrUnlockLoaderLock"); + pRtlMultiByteToUnicodeN = (void *)GetProcAddress(hntdll, "RtlMultiByteToUnicodeN"); + pRtlGetCompressionWorkSpaceSize = (void *)GetProcAddress(hntdll, "RtlGetCompressionWorkSpaceSize"); + pRtlDecompressBuffer = (void *)GetProcAddress(hntdll, "RtlDecompressBuffer"); + pRtlDecompressFragment = (void *)GetProcAddress(hntdll, "RtlDecompressFragment"); @@ -34,7 +34,7 @@ index e8eb04a..2f6c421 100644 } hkernel32 = LoadLibraryA("kernel32.dll"); ok(hkernel32 != 0, "LoadLibrary failed\n"); -@@ -1599,6 +1607,735 @@ static void test_LdrLockLoaderLock(void) +@@ -2416,6 +2424,735 @@ static void test_LdrLockLoaderLock(void) pLdrUnlockLoaderLock(0, magic); } @@ -770,7 +770,8 @@ index e8eb04a..2f6c421 100644 START_TEST(rtl) { InitFunctionPtrs(); -@@ -1626,3 +2363,6 @@ START_TEST(rtl) +@@ -2445,4 +3182,7 @@ START_TEST(rtl) + test_RtlIpv6StringToAddressEx(); test_LdrAddRefDll(); test_LdrLockLoaderLock(); + test_RtlGetCompressionWorkSpaceSize(); @@ -778,5 +779,5 @@ index e8eb04a..2f6c421 100644 + test_RtlCompressBuffer(); } -- -2.2.1 +2.3.1 diff --git a/patches/ntdll-LZNT1_Compression/definition b/patches/ntdll-LZNT1_Compression/definition index 9f1ffb54..f064e7ad 100644 --- a/patches/ntdll-LZNT1_Compression/definition +++ b/patches/ntdll-LZNT1_Compression/definition @@ -1 +1,2 @@ Fixes: [37449] Support for RtlDecompressBuffer +Depends: ntdll-RtlIpStringToAddress diff --git a/patches/ntdll-RtlIpStringToAddress/0001-ntdll-tests-Tests-for-RtlIpv6StringToAddress-try-6.patch b/patches/ntdll-RtlIpStringToAddress/0001-ntdll-tests-Tests-for-RtlIpv6StringToAddress-try-6.patch new file mode 100644 index 00000000..0a4cc15b --- /dev/null +++ b/patches/ntdll-RtlIpStringToAddress/0001-ntdll-tests-Tests-for-RtlIpv6StringToAddress-try-6.patch @@ -0,0 +1,501 @@ +From bced9dedb0501192c6d7ac1bfcba0edb83964ade Mon Sep 17 00:00:00 2001 +From: Mark Jansen +Date: Sun, 8 Mar 2015 18:24:45 +0100 +Subject: ntdll/tests: Tests for RtlIpv6StringToAddress (try 6) + +Changes from try5: +-Reformat ipv6 table to be less wide +-Remove _s6_un from memcmp calls + +Changes from try4: +-Use RtlMultiByteToUnicodeN for A->W conversion as suggested by stefand on + +Changes from try3: +-Also test the W version against the A version +-Expand the test with more corner cases +-replace the 'broken' int with an enum as suggested by stefand +-add comments to the flags, explaining their purpose. +-initialize ipv6 from int array in a small function to avoid code +duplication +--- + dlls/ntdll/tests/rtl.c | 430 +++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 430 insertions(+) + +diff --git a/dlls/ntdll/tests/rtl.c b/dlls/ntdll/tests/rtl.c +index e8eb04a..8030c86 100644 +--- a/dlls/ntdll/tests/rtl.c ++++ b/dlls/ntdll/tests/rtl.c +@@ -25,6 +25,7 @@ + + #include "ntdll_test.h" + #include "inaddr.h" ++#include "in6addr.h" + + #ifndef __WINE_WINTERNL_H + +@@ -89,9 +90,12 @@ static IMAGE_BASE_RELOCATION *(WINAPI *pLdrProcessRelocationBlock)(void*,UINT,US + static CHAR * (WINAPI *pRtlIpv4AddressToStringA)(const IN_ADDR *, LPSTR); + static NTSTATUS (WINAPI *pRtlIpv4AddressToStringExA)(const IN_ADDR *, USHORT, LPSTR, PULONG); + static NTSTATUS (WINAPI *pRtlIpv4StringToAddressA)(PCSTR, BOOLEAN, PCSTR *, IN_ADDR *); ++static NTSTATUS (WINAPI *pRtlIpv6StringToAddressA)(PCSTR, PCSTR *, struct in6_addr *); ++static NTSTATUS (WINAPI *pRtlIpv6StringToAddressW)(PCWSTR, PCWSTR *, struct in6_addr *); + static NTSTATUS (WINAPI *pLdrAddRefDll)(ULONG, HMODULE); + static NTSTATUS (WINAPI *pLdrLockLoaderLock)(ULONG, ULONG*, ULONG_PTR*); + static NTSTATUS (WINAPI *pLdrUnlockLoaderLock)(ULONG, ULONG_PTR); ++static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD); + + static HMODULE hkernel32 = 0; + static BOOL (WINAPI *pIsWow64Process)(HANDLE, PBOOL); +@@ -136,9 +140,12 @@ static void InitFunctionPtrs(void) + pRtlIpv4AddressToStringA = (void *)GetProcAddress(hntdll, "RtlIpv4AddressToStringA"); + pRtlIpv4AddressToStringExA = (void *)GetProcAddress(hntdll, "RtlIpv4AddressToStringExA"); + pRtlIpv4StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressA"); ++ pRtlIpv6StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressA"); ++ pRtlIpv6StringToAddressW = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressW"); + pLdrAddRefDll = (void *)GetProcAddress(hntdll, "LdrAddRefDll"); + pLdrLockLoaderLock = (void *)GetProcAddress(hntdll, "LdrLockLoaderLock"); + pLdrUnlockLoaderLock = (void *)GetProcAddress(hntdll, "LdrUnlockLoaderLock"); ++ pRtlMultiByteToUnicodeN = (void *)GetProcAddress(hntdll, "RtlMultiByteToUnicodeN"); + } + hkernel32 = LoadLibraryA("kernel32.dll"); + ok(hkernel32 != 0, "LoadLibrary failed\n"); +@@ -1492,6 +1499,428 @@ static void test_RtlIpv4StringToAddress(void) + } + } + ++ ++/* ipv6 addresses based on the set from https://github.com/beaugunderson/javascript-ipv6/tree/master/test/data */ ++static const struct ++{ ++ PCSTR address; ++ NTSTATUS res; ++ int terminator_offset; ++ int ip[8]; ++ /* win_broken: older versions of windows do not handle this correct ++ ex_fail: Ex function does need the string to be terminated, non-Ex does not. ++ ex_skip: test doesnt make sense for Ex (f.e. it's invalid for non-Ex but valid for Ex) */ ++ enum { normal_6, win_broken_6 = 1, ex_fail_6 = 2, ex_skip_6 = 4 } flags; ++} ipv6_tests[] = ++{ ++ { "0000:0000:0000:0000:0000:0000:0000:0000", STATUS_SUCCESS, 39, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "0000:0000:0000:0000:0000:0000:0000:0001", STATUS_SUCCESS, 39, ++ { 0, 0, 0, 0, 0, 0, 0, 0x100 } }, ++ { "0:0:0:0:0:0:0:0", STATUS_SUCCESS, 15, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "0:0:0:0:0:0:0:1", STATUS_SUCCESS, 15, ++ { 0, 0, 0, 0, 0, 0, 0, 0x100 } }, ++ { "0:0:0:0:0:0:0::", STATUS_SUCCESS, 13, ++ { 0, 0, 0, 0, 0, 0, 0, 0 }, win_broken_6 }, ++ { "0:0:0:0:0:0:13.1.68.3", STATUS_SUCCESS, 21, ++ { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } }, ++ { "0:0:0:0:0:0::", STATUS_SUCCESS, 13, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "0:0:0:0:0::", STATUS_SUCCESS, 11, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "0:0:0:0:0:FFFF:129.144.52.38", STATUS_SUCCESS, 28, ++ { 0, 0, 0, 0, 0, 0xffff, 0x9081, 0x2634 } }, ++ { "0::", STATUS_SUCCESS, 3, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "0:1:2:3:4:5:6:7", STATUS_SUCCESS, 15, ++ { 0, 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x700 } }, ++ { "1080:0:0:0:8:800:200c:417a", STATUS_SUCCESS, 26, ++ { 0x8010, 0, 0, 0, 0x800, 0x8, 0x0c20, 0x7a41 } }, ++ { "0:a:b:c:d:e:f::", STATUS_SUCCESS, 13, ++ { 0, 0xa00, 0xb00, 0xc00, 0xd00, 0xe00, 0xf00, 0 }, win_broken_6 }, ++ { "1111:2222:3333:4444:5555:6666:123.123.123.123", STATUS_SUCCESS, 45, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } }, ++ { "1111:2222:3333:4444:5555:6666:7777:8888", STATUS_SUCCESS, 39, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 } }, ++ { "1111:2222:3333:4444:0x5555:6666:7777:8888", STATUS_INVALID_PARAMETER, 21, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444:x555:6666:7777:8888", STATUS_INVALID_PARAMETER, 20, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444:0r5555:6666:7777:8888", STATUS_INVALID_PARAMETER, 21, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444:r5555:6666:7777:8888", STATUS_INVALID_PARAMETER, 20, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444:5555:6666:7777::", STATUS_SUCCESS, 34, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0 }, win_broken_6 }, ++ { "1111:2222:3333:4444:5555:6666::", STATUS_SUCCESS, 31, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0, 0 } }, ++ { "1111:2222:3333:4444:5555:6666::8888", STATUS_SUCCESS, 35, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0, 0x8888 } }, ++ { "1111:2222:3333:4444:5555::", STATUS_SUCCESS, 26, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0 } }, ++ { "1111:2222:3333:4444:5555::123.123.123.123", STATUS_SUCCESS, 41, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0x7b7b, 0x7b7b } }, ++ { "1111:2222:3333:4444:5555::0x1.123.123.123", STATUS_SUCCESS, 27, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0x100 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555::0x88", STATUS_SUCCESS, 27, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0x8800 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555::0X88", STATUS_SUCCESS, 27, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0x8800 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555::0X", STATUS_SUCCESS, 27, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555::0X88:7777", STATUS_SUCCESS, 27, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0x8800 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555::0x8888", STATUS_SUCCESS, 27, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0x8888 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555::08888", STATUS_INVALID_PARAMETER, 31, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444:5555::fffff", STATUS_INVALID_PARAMETER, 31, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444::fffff", STATUS_INVALID_PARAMETER, 26, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333::fffff", STATUS_INVALID_PARAMETER, 21, ++ { 0x1111, 0x2222, 0x3333, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444:5555::7777:8888", STATUS_SUCCESS, 35, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0x7777, 0x8888 } }, ++ { "1111:2222:3333:4444:5555::8888", STATUS_SUCCESS, 30, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0x8888 } }, ++ { "1111::", STATUS_SUCCESS, 6, ++ { 0x1111, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "1111::123.123.123.123", STATUS_SUCCESS, 21, ++ { 0x1111, 0, 0, 0, 0, 0, 0x7b7b, 0x7b7b } }, ++ { "1111::3333:4444:5555:6666:123.123.123.123", STATUS_SUCCESS, 41, ++ { 0x1111, 0, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } }, ++ { "1111::3333:4444:5555:6666:7777:8888", STATUS_SUCCESS, 35, ++ { 0x1111, 0, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 } }, ++ { "1111::4444:5555:6666:123.123.123.123", STATUS_SUCCESS, 36, ++ { 0x1111, 0, 0, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } }, ++ { "1111::4444:5555:6666:7777:8888", STATUS_SUCCESS, 30, ++ { 0x1111, 0, 0, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 } }, ++ { "1111::5555:6666:123.123.123.123", STATUS_SUCCESS, 31, ++ { 0x1111, 0, 0, 0, 0x5555, 0x6666, 0x7b7b, 0x7b7b } }, ++ { "1111::5555:6666:7777:8888", STATUS_SUCCESS, 25, ++ { 0x1111, 0, 0, 0, 0x5555, 0x6666, 0x7777, 0x8888 } }, ++ { "1111::6666:123.123.123.123", STATUS_SUCCESS, 26, ++ { 0x1111, 0, 0, 0, 0, 0x6666, 0x7b7b, 0x7b7b } }, ++ { "1111::6666:7777:8888", STATUS_SUCCESS, 20, ++ { 0x1111, 0, 0, 0, 0, 0x6666, 0x7777, 0x8888 } }, ++ { "1111::7777:8888", STATUS_SUCCESS, 15, ++ { 0x1111, 0, 0, 0, 0, 0, 0x7777, 0x8888 } }, ++ { "1111::8888", STATUS_SUCCESS, 10, ++ { 0x1111, 0, 0, 0, 0, 0, 0, 0x8888 } }, ++ { "1:2:3:4:5:6:1.2.3.4", STATUS_SUCCESS, 19, ++ { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x201, 0x403 } }, ++ { "1:2:3:4:5:6:7:8", STATUS_SUCCESS, 15, ++ { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x700, 0x800 } }, ++ { "1:2:3:4:5:6::", STATUS_SUCCESS, 13, ++ { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0, 0 } }, ++ { "1:2:3:4:5:6::8", STATUS_SUCCESS, 14, ++ { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0, 0x800 } }, ++ { "2001:0000:1234:0000:0000:C1C0:ABCD:0876", STATUS_SUCCESS, 39, ++ { 0x120, 0, 0x3412, 0, 0, 0xc0c1, 0xcdab, 0x7608 } }, ++ { "2001:0000:4136:e378:8000:63bf:3fff:fdd2", STATUS_SUCCESS, 39, ++ { 0x120, 0, 0x3641, 0x78e3, 0x80, 0xbf63, 0xff3f, 0xd2fd } }, ++ { "2001:0db8:0:0:0:0:1428:57ab", STATUS_SUCCESS, 27, ++ { 0x120, 0xb80d, 0, 0, 0, 0, 0x2814, 0xab57 } }, ++ { "2001:0db8:1234:ffff:ffff:ffff:ffff:ffff", STATUS_SUCCESS, 39, ++ { 0x120, 0xb80d, 0x3412, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff } }, ++ { "2001::CE49:7601:2CAD:DFFF:7C94:FFFE", STATUS_SUCCESS, 35, ++ { 0x120, 0, 0x49ce, 0x176, 0xad2c, 0xffdf, 0x947c, 0xfeff } }, ++ { "2001:db8:85a3::8a2e:370:7334", STATUS_SUCCESS, 28, ++ { 0x120, 0xb80d, 0xa385, 0, 0, 0x2e8a, 0x7003, 0x3473 } }, ++ { "3ffe:0b00:0000:0000:0001:0000:0000:000a", STATUS_SUCCESS, 39, ++ { 0xfe3f, 0xb, 0, 0, 0x100, 0, 0, 0xa00 } }, ++ { "::", STATUS_SUCCESS, 2, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "::%16", STATUS_SUCCESS, 2, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "::/16", STATUS_SUCCESS, 2, ++ { 0, 0, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "::0", STATUS_SUCCESS, 3, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "::0:0", STATUS_SUCCESS, 5, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "::0:0:0", STATUS_SUCCESS, 7, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "::0:0:0:0", STATUS_SUCCESS, 9, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "::0:0:0:0:0", STATUS_SUCCESS, 11, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "::0:0:0:0:0:0", STATUS_SUCCESS, 13, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ /* this one and the next one are incorrectly parsed by windows, ++ it adds one zero too many in front, cutting off the last digit. */ ++ { "::0:0:0:0:0:0:0", STATUS_SUCCESS, 13, ++ { 0, 0, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "::0:a:b:c:d:e:f", STATUS_SUCCESS, 13, ++ { 0, 0, 0, 0xa00, 0xb00, 0xc00, 0xd00, 0xe00 }, ex_fail_6 }, ++ { "::123.123.123.123", STATUS_SUCCESS, 17, ++ { 0, 0, 0, 0, 0, 0, 0x7b7b, 0x7b7b } }, ++ { "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", STATUS_SUCCESS, 39, ++ { 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff } }, ++ ++ { "':10.0.0.1", STATUS_INVALID_PARAMETER, 0, ++ { -1 } }, ++ { "-1", STATUS_INVALID_PARAMETER, 0, ++ { -1 } }, ++ { "02001:0000:1234:0000:0000:C1C0:ABCD:0876", STATUS_INVALID_PARAMETER, -1, ++ { -1 } }, ++ { "2001:00000:1234:0000:0000:C1C0:ABCD:0876", STATUS_INVALID_PARAMETER, -1, ++ { 0x120, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "2001:0000:01234:0000:0000:C1C0:ABCD:0876", STATUS_INVALID_PARAMETER, -1, ++ { 0x120, 0, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1.2.3.4", STATUS_INVALID_PARAMETER, 7, ++ { 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1.2.3.4:1111::5555", STATUS_INVALID_PARAMETER, 7, ++ { 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1.2.3.4::5555", STATUS_INVALID_PARAMETER, 7, ++ { 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "11112222:3333:4444:5555:6666:1.2.3.4", STATUS_INVALID_PARAMETER, -1, ++ { -1 } }, ++ { "11112222:3333:4444:5555:6666:7777:8888", STATUS_INVALID_PARAMETER, -1, ++ { -1 } }, ++ { "1111", STATUS_INVALID_PARAMETER, 4, ++ { -1 } }, ++ { "1111:22223333:4444:5555:6666:1.2.3.4", STATUS_INVALID_PARAMETER, -1, ++ { 0x1111, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:22223333:4444:5555:6666:7777:8888", STATUS_INVALID_PARAMETER, -1, ++ { 0x1111, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:", STATUS_INVALID_PARAMETER, 10, ++ { 0x1111, 0x2222, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:1.2.3.4", STATUS_INVALID_PARAMETER, 17, ++ { 0x1111, 0x2222, 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333", STATUS_INVALID_PARAMETER, 14, ++ { 0x1111, 0x2222, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111:2222:3333:4444:5555:6666:7777:1.2.3.4", STATUS_SUCCESS, 36, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x100 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555:6666:7777:8888:", STATUS_SUCCESS, 39, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555:6666:7777:8888:1.2.3.4",STATUS_SUCCESS, 39, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 }, ex_fail_6 }, ++ { "1111:2222:3333:4444:5555:6666:7777:8888:9999", STATUS_SUCCESS, 39, ++ { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 }, ex_fail_6 }, ++ { "1111:2222:::", STATUS_SUCCESS, 11, ++ { 0x1111, 0x2222, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "1111::5555:", STATUS_INVALID_PARAMETER, 11, ++ { 0x1111, 0x5555, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1111::3333:4444:5555:6666:7777::", STATUS_SUCCESS, 30, ++ { 0x1111, 0, 0, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777 }, ex_fail_6 }, ++ { "1111:2222:::4444:5555:6666:1.2.3.4", STATUS_SUCCESS, 11, ++ { 0x1111, 0x2222, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "1111::3333::5555:6666:1.2.3.4", STATUS_SUCCESS, 10, ++ { 0x1111, 0, 0, 0, 0, 0, 0, 0x3333 }, ex_fail_6 }, ++ { "12345::6:7:8", STATUS_INVALID_PARAMETER, -1, ++ { -1 } }, ++ { "1::1.2.256.4", STATUS_INVALID_PARAMETER, -1, ++ { 0x100, 0x201, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.3.256", STATUS_INVALID_PARAMETER, 12, ++ { 0x100, 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.3.300", STATUS_INVALID_PARAMETER, 12, ++ { 0x100, 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2::1", STATUS_INVALID_PARAMETER, 6, ++ { 0x100, 0xab01, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.3.4::1", STATUS_SUCCESS, 10, ++ { 0x100, 0, 0, 0, 0, 0, 0x201, 0x403 }, ex_fail_6 }, ++ { "1::1.", STATUS_INVALID_PARAMETER, 5, ++ { 0x100, 0xab01, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2", STATUS_INVALID_PARAMETER, 6, ++ { 0x100, 0xab01, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.", STATUS_INVALID_PARAMETER, 7, ++ { 0x100, 0x201, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.3", STATUS_INVALID_PARAMETER, 8, ++ { 0x100, 0x201, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.3.", STATUS_INVALID_PARAMETER, 9, ++ { 0x100, 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.3.4", STATUS_SUCCESS, 10, ++ { 0x100, 0, 0, 0, 0, 0, 0x201, 0x403 } }, ++ { "1::1.2.3.900", STATUS_INVALID_PARAMETER, 12, ++ { 0x100, 0x201, 0xab03, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.2.300.4", STATUS_INVALID_PARAMETER, -1, ++ { 0x100, 0x201, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::1.256.3.4", STATUS_INVALID_PARAMETER, -1, ++ { 0x100, 0xab01, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::256.2.3.4", STATUS_INVALID_PARAMETER, -1, ++ { 0x100, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "1::2::3", STATUS_SUCCESS, 4, ++ { 0x100, 0, 0, 0, 0, 0, 0, 0x200 }, ex_fail_6 }, ++ { "2001:0000:1234: 0000:0000:C1C0:ABCD:0876", STATUS_INVALID_PARAMETER, 15, ++ { 0x120, 0, 0x3412, 0xabab, 0xabab, 0xabab, 0xabab, 0xabab } }, ++ { "2001:0000:1234:0000:0000:C1C0:ABCD:0876 0", STATUS_SUCCESS, 39, ++ { 0x120, 0, 0x3412, 0, 0, 0xc0c1, 0xcdab, 0x7608 }, ex_fail_6 }, ++ { "2001:1:1:1:1:1:255Z255X255Y255", STATUS_INVALID_PARAMETER, 18, ++ { 0x120, 0x100, 0x100, 0x100, 0x100, 0x100, 0xabab, 0xabab } }, ++ { "2001::FFD3::57ab", STATUS_SUCCESS, 10, ++ { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff }, ex_fail_6 }, ++ { ":", STATUS_INVALID_PARAMETER, 0, ++ { -1 } }, ++ { ":1111:2222:3333:4444:5555:6666:1.2.3.4", STATUS_INVALID_PARAMETER, 0, ++ { -1 } }, ++ { ":1111:2222:3333:4444:5555:6666:7777:8888", STATUS_INVALID_PARAMETER, 0, ++ { -1 } }, ++ { ":1111::", STATUS_INVALID_PARAMETER, 0, ++ { -1 } }, ++ { "::-1", STATUS_SUCCESS, 2, ++ { 0, 0, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "::.", STATUS_SUCCESS, 2, ++ { 0, 0, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "::..", STATUS_SUCCESS, 2, ++ { 0, 0, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "::...", STATUS_SUCCESS, 2, ++ { 0, 0, 0, 0, 0, 0, 0, 0 }, ex_fail_6 }, ++ { "XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:1.2.3.4", STATUS_INVALID_PARAMETER, 0, ++ { -1 } }, ++ { "[::]", STATUS_INVALID_PARAMETER, 0, ++ { -1 }, ex_skip_6 }, ++}; ++const unsigned int ipv6_testcount = sizeof(ipv6_tests) / sizeof(ipv6_tests[0]); ++ ++ ++static void init_ip6(IN6_ADDR* addr, const int src[8]) ++{ ++ unsigned int j; ++ if (!src || src[0] == -1) ++ { ++ for (j = 0; j < 8; ++j) ++ addr->s6_words[j] = 0xabab; ++ } ++ else ++ { ++ for (j = 0; j < 8; ++j) ++ addr->s6_words[j] = src[j]; ++ } ++} ++ ++static void compare_RtlIpv6StringToAddressW(PCSTR name_a, int terminator_offset_a, ++ const struct in6_addr *addr_a, NTSTATUS res_a) ++{ ++ WCHAR name[512]; ++ NTSTATUS res; ++ IN6_ADDR ip; ++ PCWSTR terminator; ++ ++ if (!pRtlIpv6StringToAddressW) ++ return; ++ ++ pRtlMultiByteToUnicodeN(name, sizeof(name), NULL, name_a, strlen(name_a) + 1); ++ ++ init_ip6(&ip, NULL); ++ terminator = (void *)0xdeadbeef; ++ res = pRtlIpv6StringToAddressW(name, &terminator, &ip); ++ ok(res == res_a, "[W:%s] res = 0x%08x, expected 0x%08x\n", name_a, res, res_a); ++ ++ if (terminator_offset_a < 0) ++ { ++ ok(terminator == (void *)0xdeadbeef, ++ "[W:%s] terminator = %p, expected it not to change\n", ++ name_a, terminator); ++ } ++ else ++ { ++ ok(terminator == name + terminator_offset_a, ++ "[W:%s] terminator = %p, expected %p\n", ++ name_a, terminator, name + terminator_offset_a); ++ } ++ ++ ok(!memcmp(&ip, addr_a, sizeof(ip)), ++ "[W:%s] ip = %x:%x:%x:%x:%x:%x:%x:%x, expected %x:%x:%x:%x:%x:%x:%x:%x\n", ++ name_a, ++ ip.s6_words[0], ip.s6_words[1], ip.s6_words[2], ip.s6_words[3], ++ ip.s6_words[4], ip.s6_words[5], ip.s6_words[6], ip.s6_words[7], ++ addr_a->s6_words[0], addr_a->s6_words[1], addr_a->s6_words[2], addr_a->s6_words[3], ++ addr_a->s6_words[4], addr_a->s6_words[5], addr_a->s6_words[6], addr_a->s6_words[7]); ++} ++ ++static void test_RtlIpv6StringToAddress(void) ++{ ++ NTSTATUS res; ++ IN6_ADDR ip, expected_ip; ++ PCSTR terminator; ++ unsigned int i; ++ ++ if (!pRtlIpv6StringToAddressW) ++ { ++ skip("RtlIpv6StringToAddressW not available\n"); ++ /* we can continue, just not test W */ ++ } ++ ++ if (!pRtlIpv6StringToAddressA) ++ { ++ skip("RtlIpv6StringToAddressA not available\n"); ++ return; /* all tests are centered around A, we cannot continue */ ++ } ++ ++ res = pRtlIpv6StringToAddressA("::", &terminator, &ip); ++ ok(res == STATUS_SUCCESS, "[validate] res = 0x%08x, expected STATUS_SUCCESS\n", res); ++ if (0) ++ { ++ /* any of these crash */ ++ res = pRtlIpv6StringToAddressA(NULL, &terminator, &ip); ++ ok(res == STATUS_INVALID_PARAMETER, "[null string] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res); ++ res = pRtlIpv6StringToAddressA("::", NULL, &ip); ++ ok(res == STATUS_INVALID_PARAMETER, "[null terminator] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res); ++ res = pRtlIpv6StringToAddressA("::", &terminator, NULL); ++ ok(res == STATUS_INVALID_PARAMETER, "[null result] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res); ++ } ++ ++ /* sanity check */ ++ ok(sizeof(ip) == sizeof(USHORT)* 8, "sizeof(ip)\n"); ++ ++ for (i = 0; i < ipv6_testcount; i++) ++ { ++ init_ip6(&ip, NULL); ++ terminator = (void *)0xdeadbeef; ++ res = pRtlIpv6StringToAddressA(ipv6_tests[i].address, &terminator, &ip); ++ compare_RtlIpv6StringToAddressW(ipv6_tests[i].address, (terminator != (void *)0xdeadbeef) ? ++ (terminator - ipv6_tests[i].address) : -1, &ip, res); ++ ++ if (ipv6_tests[i].flags & win_broken_6) ++ { ++ ok(res == ipv6_tests[i].res || broken(res == STATUS_INVALID_PARAMETER), ++ "[%s] res = 0x%08x, expected 0x%08x\n", ++ ipv6_tests[i].address, res, ipv6_tests[i].res); ++ ++ if (res == STATUS_INVALID_PARAMETER) ++ continue; ++ } ++ else ++ { ++ ok(res == ipv6_tests[i].res, ++ "[%s] res = 0x%08x, expected 0x%08x\n", ++ ipv6_tests[i].address, res, ipv6_tests[i].res); ++ } ++ ++ if (ipv6_tests[i].terminator_offset < 0) ++ { ++ ok(terminator == (void *)0xdeadbeef, ++ "[%s] terminator = %p, expected it not to change\n", ++ ipv6_tests[i].address, terminator); ++ } ++ else if (ipv6_tests[i].flags & win_broken_6) ++ { ++ PCSTR expected = ipv6_tests[i].address + ipv6_tests[i].terminator_offset; ++ ok(terminator == expected || broken(terminator == expected + 2), ++ "[%s] terminator = %p, expected %p\n", ++ ipv6_tests[i].address, terminator, expected); ++ } ++ else ++ { ++ ok(terminator == ipv6_tests[i].address + ipv6_tests[i].terminator_offset, ++ "[%s] terminator = %p, expected %p\n", ++ ipv6_tests[i].address, terminator, ipv6_tests[i].address + ipv6_tests[i].terminator_offset); ++ } ++ ++ init_ip6(&expected_ip, ipv6_tests[i].ip); ++ ok(!memcmp(&ip, &expected_ip, sizeof(ip)), ++ "[%s] ip = %x:%x:%x:%x:%x:%x:%x:%x, expected %x:%x:%x:%x:%x:%x:%x:%x\n", ++ ipv6_tests[i].address, ++ ip.s6_words[0], ip.s6_words[1], ip.s6_words[2], ip.s6_words[3], ++ ip.s6_words[4], ip.s6_words[5], ip.s6_words[6], ip.s6_words[7], ++ expected_ip.s6_words[0], expected_ip.s6_words[1], expected_ip.s6_words[2], expected_ip.s6_words[3], ++ expected_ip.s6_words[4], expected_ip.s6_words[5], expected_ip.s6_words[6], expected_ip.s6_words[7]); ++ } ++} ++ + static void test_LdrAddRefDll(void) + { + HMODULE mod, mod2; +@@ -1623,6 +2052,7 @@ START_TEST(rtl) + test_RtlIpv4AddressToString(); + test_RtlIpv4AddressToStringEx(); + test_RtlIpv4StringToAddress(); ++ test_RtlIpv6StringToAddress(); + test_LdrAddRefDll(); + test_LdrLockLoaderLock(); + } +-- +2.3.1 + diff --git a/patches/ntdll-RtlIpStringToAddress/0002-ntdll-tests-Tests-for-RtlIpv6StringToAddressEx-try-6.patch b/patches/ntdll-RtlIpStringToAddress/0002-ntdll-tests-Tests-for-RtlIpv6StringToAddressEx-try-6.patch new file mode 100644 index 00000000..ae7352c9 --- /dev/null +++ b/patches/ntdll-RtlIpStringToAddress/0002-ntdll-tests-Tests-for-RtlIpv6StringToAddressEx-try-6.patch @@ -0,0 +1,333 @@ +From 61f51c445a223aaceb0b404f4c13eda296133f25 Mon Sep 17 00:00:00 2001 +From: Mark Jansen +Date: Sun, 8 Mar 2015 18:24:50 +0100 +Subject: ntdll/tests: Tests for RtlIpv6StringToAddressEx (try 6) + +Changes from try5: +-Reformat ipv6 table to be less wide +-Remove _s6_un from memcmp calls + +Changes from try4 (all suggestions from stefand in #winehackers): +-Use RtlMultiByteToUnicodeN for A->W conversion +-Fix warning +-Clarify comment / move init_ip6 inside if branch + +Changes from try3: +-Also test the W version against the A version +-Test the ip against the non-ex version as suggested by stefand +-Add more testcases +--- + dlls/ntdll/tests/rtl.c | 269 ++++++++++++++++++++++++++++++++++++++++++++++++- + 1 file changed, 268 insertions(+), 1 deletion(-) + +diff --git a/dlls/ntdll/tests/rtl.c b/dlls/ntdll/tests/rtl.c +index 8030c86..5d789d1 100644 +--- a/dlls/ntdll/tests/rtl.c ++++ b/dlls/ntdll/tests/rtl.c +@@ -92,6 +92,8 @@ static NTSTATUS (WINAPI *pRtlIpv4AddressToStringExA)(const IN_ADDR *, USHORT, L + static NTSTATUS (WINAPI *pRtlIpv4StringToAddressA)(PCSTR, BOOLEAN, PCSTR *, IN_ADDR *); + static NTSTATUS (WINAPI *pRtlIpv6StringToAddressA)(PCSTR, PCSTR *, struct in6_addr *); + static NTSTATUS (WINAPI *pRtlIpv6StringToAddressW)(PCWSTR, PCWSTR *, struct in6_addr *); ++static NTSTATUS (WINAPI *pRtlIpv6StringToAddressExA)(PCSTR, struct in6_addr *, PULONG, PUSHORT); ++static NTSTATUS (WINAPI *pRtlIpv6StringToAddressExW)(PCWSTR, struct in6_addr *, PULONG, PUSHORT); + static NTSTATUS (WINAPI *pLdrAddRefDll)(ULONG, HMODULE); + static NTSTATUS (WINAPI *pLdrLockLoaderLock)(ULONG, ULONG*, ULONG_PTR*); + static NTSTATUS (WINAPI *pLdrUnlockLoaderLock)(ULONG, ULONG_PTR); +@@ -142,6 +144,8 @@ static void InitFunctionPtrs(void) + pRtlIpv4StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressA"); + pRtlIpv6StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressA"); + pRtlIpv6StringToAddressW = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressW"); ++ pRtlIpv6StringToAddressExA = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressExA"); ++ pRtlIpv6StringToAddressExW = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressExW"); + pLdrAddRefDll = (void *)GetProcAddress(hntdll, "LdrAddRefDll"); + pLdrLockLoaderLock = (void *)GetProcAddress(hntdll, "LdrLockLoaderLock"); + pLdrUnlockLoaderLock = (void *)GetProcAddress(hntdll, "LdrUnlockLoaderLock"); +@@ -1775,7 +1779,6 @@ static const struct + }; + const unsigned int ipv6_testcount = sizeof(ipv6_tests) / sizeof(ipv6_tests[0]); + +- + static void init_ip6(IN6_ADDR* addr, const int src[8]) + { + unsigned int j; +@@ -1921,6 +1924,269 @@ static void test_RtlIpv6StringToAddress(void) + } + } + ++static void compare_RtlIpv6StringToAddressExW(PCSTR name_a, const struct in6_addr *addr_a, HRESULT res_a, ULONG scope_a, USHORT port_a) ++{ ++ WCHAR name[512]; ++ NTSTATUS res; ++ IN6_ADDR ip; ++ ULONG scope = 0xbadf00d; ++ USHORT port = 0xbeef; ++ ++ if (!pRtlIpv6StringToAddressExW) ++ return; ++ ++ pRtlMultiByteToUnicodeN(name, sizeof(name), NULL, name_a, strlen(name_a) + 1); ++ ++ init_ip6(&ip, NULL); ++ res = pRtlIpv6StringToAddressExW(name, &ip, &scope, &port); ++ ++ ok(res == res_a, "[W:%s] res = 0x%08x, expected 0x%08x\n", name_a, res, res_a); ++ ok(scope == scope_a, "[W:%s] scope = 0x%08x, expected 0x%08x\n", name_a, scope, scope_a); ++ ok(port == port_a, "[W:%s] port = 0x%08x, expected 0x%08x\n", name_a, port, port_a); ++ ++ ok(!memcmp(&ip, addr_a, sizeof(ip)), ++ "[W:%s] ip = %x:%x:%x:%x:%x:%x:%x:%x, expected %x:%x:%x:%x:%x:%x:%x:%x\n", ++ name_a, ++ ip.s6_words[0], ip.s6_words[1], ip.s6_words[2], ip.s6_words[3], ++ ip.s6_words[4], ip.s6_words[5], ip.s6_words[6], ip.s6_words[7], ++ addr_a->s6_words[0], addr_a->s6_words[1], addr_a->s6_words[2], addr_a->s6_words[3], ++ addr_a->s6_words[4], addr_a->s6_words[5], addr_a->s6_words[6], addr_a->s6_words[7]); ++} ++ ++static void test_RtlIpv6StringToAddressEx(void) ++{ ++ NTSTATUS res; ++ IN6_ADDR ip, expected_ip; ++ ULONG scope; ++ USHORT port; ++ static const struct ++ { ++ PCSTR address; ++ NTSTATUS res; ++ ULONG scope; ++ USHORT port; ++ int ip[8]; ++ } ipv6_ex_tests[] = ++ { ++ { "[::]", STATUS_SUCCESS, 0, 0, ++ { 0, 0, 0, 0, 0, 0, 0, 0 } }, ++ { "[::1]:8080", STATUS_SUCCESS, 0, 0x901f, ++ { 0, 0, 0, 0, 0, 0, 0, 0x100 } }, ++ { "[::1]:0x80", STATUS_SUCCESS, 0, 0x8000, ++ { 0, 0, 0, 0, 0, 0, 0, 0x100 } }, ++ { "[::1]:0X80", STATUS_SUCCESS, 0, 0x8000, ++ { 0, 0, 0, 0, 0, 0, 0, 0x100 } }, ++ { "[::1]:080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0, 0, 0, 0, 0, 0, 0, 0x100 } }, ++ { "[::1]:800000000080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0, 0, 0, 0, 0, 0, 0, 0x100 } }, ++ { "[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80", STATUS_SUCCESS, 0, 0x5000, ++ { 0xdcfe, 0x98ba, 0x5476, 0x1032, 0xdcfe, 0x98ba, 0x5476, 0x1032 } }, ++ { "[1080:0:0:0:8:800:200C:417A]:1234", STATUS_SUCCESS, 0, 0xd204, ++ { 0x8010, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[3ffe:2a00:100:7031::1]:8080", STATUS_SUCCESS, 0, 0x901f, ++ { 0xfe3f, 0x2a, 1, 0x3170, 0, 0, 0, 0x100 } }, ++ { "[ 3ffe:2a00:100:7031::1]:8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { -1 } }, ++ { "[3ffe:2a00:100:7031::1 ]:8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0xfe3f, 0x2a, 1, 0x3170, 0, 0, 0, 0x100 } }, ++ { "[3ffe:2a00:100:7031::1].8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0xfe3f, 0x2a, 1, 0x3170, 0, 0, 0, 0x100 } }, ++ { "[1080::8:800:200C:417A]:8080", STATUS_SUCCESS, 0, 0x901f, ++ { 0x8010, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[1080::8:800:200C:417A]!8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0x8010, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[::FFFF:129.144.52.38]:80", STATUS_SUCCESS, 0, 0x5000, ++ { 0, 0, 0, 0, 0, 0xffff, 0x9081, 0x2634 } }, ++ { "[::FFFF:129.144.52.38]:-80", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0, 0, 0, 0, 0, 0xffff, 0x9081, 0x2634 } }, ++ { "[::FFFF:129.144.52.38]:999999999999", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0, 0, 0, 0, 0, 0xffff, 0x9081, 0x2634 } }, ++ { "[::FFFF:129.144.52.38%-8]:80", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0, 0, 0, 0, 0, 0xffff, 0x9081, 0x2634 } }, ++ { "[::FFFF:129.144.52.38]:80", STATUS_SUCCESS, 0, 0x5000, ++ { 0, 0, 0, 0, 0, 0xffff, 0x9081, 0x2634 } }, ++ { "[12345::6:7:8]:80", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { -1 } }, ++ { "[ff01::8:800:200C:417A%16]:8080", STATUS_SUCCESS, 16, 0x901f, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%100]:8080", STATUS_SUCCESS, 100, 0x901f, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%1000]:8080", STATUS_SUCCESS, 1000, 0x901f, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%10000]:8080", STATUS_SUCCESS, 10000, 0x901f, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%1000000]:8080", STATUS_SUCCESS, 1000000, 0x901f, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%4294967295]:8080", STATUS_SUCCESS, 0xffffffff, 0x901f, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%4294967296]:8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%-1]:8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%0]:8080", STATUS_SUCCESS, 0, 0x901f, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%1", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A%0x1000]:8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ { "[ff01::8:800:200C:417A/16]:8080", STATUS_INVALID_PARAMETER, 0xbadf00d, 0xbeef, ++ { 0x1ff, 0, 0, 0, 0x800, 8, 0xc20, 0x7a41 } }, ++ }; ++ const unsigned int ipv6_ex_testcount = sizeof(ipv6_ex_tests) / sizeof(ipv6_ex_tests[0]); ++ const char *simple_ip = "::"; ++ unsigned int i; ++ ++ if (!pRtlIpv6StringToAddressExW) ++ { ++ skip("RtlIpv6StringToAddressExW not available\n"); ++ /* we can continue, just not test W */ ++ } ++ ++ if (!pRtlIpv6StringToAddressExA) ++ { ++ skip("RtlIpv6StringToAddressExA not available\n"); ++ return; ++ } ++ ++ res = pRtlIpv6StringToAddressExA(simple_ip, &ip, &scope, &port); ++ ok(res == STATUS_SUCCESS, "[validate] res = 0x%08x, expected STATUS_SUCCESS\n", res); ++ ++ init_ip6(&ip, NULL); ++ init_ip6(&expected_ip, NULL); ++ scope = 0xbadf00d; ++ port = 0xbeef; ++ res = pRtlIpv6StringToAddressExA(NULL, &ip, &scope, &port); ++ ok(res == STATUS_INVALID_PARAMETER, ++ "[null string] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res); ++ ok(scope == 0xbadf00d, "[null string] scope = 0x%08x, expected 0xbadf00d\n", scope); ++ ok(port == 0xbeef, "[null string] port = 0x%08x, expected 0xbeef\n", port); ++ ok(!memcmp(&ip, &expected_ip, sizeof(ip)), ++ "[null string] ip is changed, expected it not to change\n"); ++ ++ ++ init_ip6(&ip, NULL); ++ scope = 0xbadf00d; ++ port = 0xbeef; ++ res = pRtlIpv6StringToAddressExA(simple_ip, NULL, &scope, &port); ++ ok(res == STATUS_INVALID_PARAMETER, ++ "[null result] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res); ++ ok(scope == 0xbadf00d, "[null result] scope = 0x%08x, expected 0xbadf00d\n", scope); ++ ok(port == 0xbeef, "[null result] port = 0x%08x, expected 0xbeef\n", port); ++ ok(!memcmp(&ip, &expected_ip, sizeof(ip)), ++ "[null result] ip is changed, expected it not to change\n"); ++ ++ init_ip6(&ip, NULL); ++ scope = 0xbadf00d; ++ port = 0xbeef; ++ res = pRtlIpv6StringToAddressExA(simple_ip, &ip, NULL, &port); ++ ok(res == STATUS_INVALID_PARAMETER, ++ "[null scope] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res); ++ ok(scope == 0xbadf00d, "[null scope] scope = 0x%08x, expected 0xbadf00d\n", scope); ++ ok(port == 0xbeef, "[null scope] port = 0x%08x, expected 0xbeef\n", port); ++ ok(!memcmp(&ip, &expected_ip, sizeof(ip)), ++ "[null scope] ip is changed, expected it not to change\n"); ++ ++ init_ip6(&ip, NULL); ++ scope = 0xbadf00d; ++ port = 0xbeef; ++ res = pRtlIpv6StringToAddressExA(simple_ip, &ip, &scope, NULL); ++ ok(res == STATUS_INVALID_PARAMETER, ++ "[null port] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res); ++ ok(scope == 0xbadf00d, "[null port] scope = 0x%08x, expected 0xbadf00d\n", scope); ++ ok(port == 0xbeef, "[null port] port = 0x%08x, expected 0xbeef\n", port); ++ ok(!memcmp(&ip, &expected_ip, sizeof(ip)), ++ "[null port] ip is changed, expected it not to change\n"); ++ ++ /* sanity check */ ++ ok(sizeof(ip) == sizeof(USHORT)* 8, "sizeof(ip)\n"); ++ ++ /* first we run all ip related tests, to make sure someone didnt accidentally reimplement instead of re-use. */ ++ for (i = 0; i < ipv6_testcount; i++) ++ { ++ ULONG scope = 0xbadf00d; ++ USHORT port = 0xbeef; ++ NTSTATUS expect_ret = (ipv6_tests[i].flags & ex_fail_6) ? STATUS_INVALID_PARAMETER : ipv6_tests[i].res; ++ ++ if (ipv6_tests[i].flags & ex_skip_6) ++ continue; ++ ++ init_ip6(&ip, NULL); ++ res = pRtlIpv6StringToAddressExA(ipv6_tests[i].address, &ip, &scope, &port); ++ compare_RtlIpv6StringToAddressExW(ipv6_tests[i].address, &ip, res, scope, port); ++ ++ /* make sure nothing was changed if this function fails. */ ++ if (res == STATUS_INVALID_PARAMETER) ++ { ++ ok(scope == 0xbadf00d, "[%s] scope = 0x%08x, expected 0xbadf00d\n", ++ ipv6_tests[i].address, scope); ++ ok(port == 0xbeef, "[%s] port = 0x%08x, expected 0xbeef\n", ++ ipv6_tests[i].address, port); ++ } ++ else ++ { ++ ok(scope != 0xbadf00d, "[%s] scope = 0x%08x, not expected 0xbadf00d\n", ++ ipv6_tests[i].address, scope); ++ ok(port != 0xbeef, "[%s] port = 0x%08x, not expected 0xbeef\n", ++ ipv6_tests[i].address, port); ++ } ++ ++ if (ipv6_tests[i].flags & win_broken_6) ++ { ++ ok(res == expect_ret || broken(res == STATUS_INVALID_PARAMETER), ++ "[%s] res = 0x%08x, expected 0x%08x\n", ipv6_tests[i].address, res, expect_ret); ++ ++ if (res == STATUS_INVALID_PARAMETER) ++ continue; ++ } ++ else ++ { ++ ok(res == expect_ret, "[%s] res = 0x%08x, expected 0x%08x\n", ++ ipv6_tests[i].address, res, expect_ret); ++ } ++ ++ /* If ex fails but non-ex does not we cannot check if the part that is converted ++ before it failed was correct, since there is no data for it in the table. */ ++ if (res == expect_ret) ++ { ++ init_ip6(&expected_ip, ipv6_tests[i].ip); ++ ok(!memcmp(&ip, &expected_ip, sizeof(ip)), ++ "[%s] ip = %x:%x:%x:%x:%x:%x:%x:%x, expected %x:%x:%x:%x:%x:%x:%x:%x\n", ++ ipv6_tests[i].address, ++ ip.s6_words[0], ip.s6_words[1], ip.s6_words[2], ip.s6_words[3], ++ ip.s6_words[4], ip.s6_words[5], ip.s6_words[6], ip.s6_words[7], ++ expected_ip.s6_words[0], expected_ip.s6_words[1], expected_ip.s6_words[2], expected_ip.s6_words[3], ++ expected_ip.s6_words[4], expected_ip.s6_words[5], expected_ip.s6_words[6], expected_ip.s6_words[7]); ++ } ++ } ++ ++ /* now we run scope / port related tests */ ++ for (i = 0; i < ipv6_ex_testcount; i++) ++ { ++ scope = 0xbadf00d; ++ port = 0xbeef; ++ init_ip6(&ip, NULL); ++ res = pRtlIpv6StringToAddressExA(ipv6_ex_tests[i].address, &ip, &scope, &port); ++ compare_RtlIpv6StringToAddressExW(ipv6_ex_tests[i].address, &ip, res, scope, port); ++ ++ ok(res == ipv6_ex_tests[i].res, "[%s] res = 0x%08x, expected 0x%08x\n", ++ ipv6_ex_tests[i].address, res, ipv6_ex_tests[i].res); ++ ok(scope == ipv6_ex_tests[i].scope, "[%s] scope = 0x%08x, expected 0x%08x\n", ++ ipv6_ex_tests[i].address, scope, ipv6_ex_tests[i].scope); ++ ok(port == ipv6_ex_tests[i].port, "[%s] port = 0x%08x, expected 0x%08x\n", ++ ipv6_ex_tests[i].address, port, ipv6_ex_tests[i].port); ++ ++ init_ip6(&expected_ip, ipv6_ex_tests[i].ip); ++ ok(!memcmp(&ip, &expected_ip, sizeof(ip)), ++ "[%s] ip = %x:%x:%x:%x:%x:%x:%x:%x, expected %x:%x:%x:%x:%x:%x:%x:%x\n", ++ ipv6_ex_tests[i].address, ++ ip.s6_words[0], ip.s6_words[1], ip.s6_words[2], ip.s6_words[3], ++ ip.s6_words[4], ip.s6_words[5], ip.s6_words[6], ip.s6_words[7], ++ expected_ip.s6_words[0], expected_ip.s6_words[1], expected_ip.s6_words[2], expected_ip.s6_words[3], ++ expected_ip.s6_words[4], expected_ip.s6_words[5], expected_ip.s6_words[6], expected_ip.s6_words[7]); ++ } ++} ++ + static void test_LdrAddRefDll(void) + { + HMODULE mod, mod2; +@@ -2053,6 +2319,7 @@ START_TEST(rtl) + test_RtlIpv4AddressToStringEx(); + test_RtlIpv4StringToAddress(); + test_RtlIpv6StringToAddress(); ++ test_RtlIpv6StringToAddressEx(); + test_LdrAddRefDll(); + test_LdrLockLoaderLock(); + } +-- +2.3.1 + diff --git a/patches/ntdll-RtlIpStringToAddress/0003-ntdll-tests-Tests-for-RtlIpv4StringToAddressEx-try-5.patch b/patches/ntdll-RtlIpStringToAddress/0003-ntdll-tests-Tests-for-RtlIpv4StringToAddressEx-try-5.patch new file mode 100644 index 00000000..3a065f35 --- /dev/null +++ b/patches/ntdll-RtlIpStringToAddress/0003-ntdll-tests-Tests-for-RtlIpv4StringToAddressEx-try-5.patch @@ -0,0 +1,456 @@ +From a2f2703bd49023e395090c6ed8b7b6d2e7722680 Mon Sep 17 00:00:00 2001 +From: Mark Jansen +Date: Sun, 8 Mar 2015 18:24:48 +0100 +Subject: ntdll/tests: Tests for RtlIpv4StringToAddressEx (try 5, resend) + +Changes from try4: +-Remove leftover comments + +Changes from try3: +-Test the ip against the non-ex version as suggested by stefand +-Change strict_is_different to a flag +-Add ipv4 init function to avoid code duplication +--- + dlls/ntdll/tests/rtl.c | 371 ++++++++++++++++++++++++++++++++----------------- + 1 file changed, 247 insertions(+), 124 deletions(-) + +diff --git a/dlls/ntdll/tests/rtl.c b/dlls/ntdll/tests/rtl.c +index 5d789d1..79c4974 100644 +--- a/dlls/ntdll/tests/rtl.c ++++ b/dlls/ntdll/tests/rtl.c +@@ -90,6 +90,7 @@ static IMAGE_BASE_RELOCATION *(WINAPI *pLdrProcessRelocationBlock)(void*,UINT,US + static CHAR * (WINAPI *pRtlIpv4AddressToStringA)(const IN_ADDR *, LPSTR); + static NTSTATUS (WINAPI *pRtlIpv4AddressToStringExA)(const IN_ADDR *, USHORT, LPSTR, PULONG); + static NTSTATUS (WINAPI *pRtlIpv4StringToAddressA)(PCSTR, BOOLEAN, PCSTR *, IN_ADDR *); ++static NTSTATUS (WINAPI *pRtlIpv4StringToAddressExA)(PCSTR, BOOLEAN, IN_ADDR *, PUSHORT); + static NTSTATUS (WINAPI *pRtlIpv6StringToAddressA)(PCSTR, PCSTR *, struct in6_addr *); + static NTSTATUS (WINAPI *pRtlIpv6StringToAddressW)(PCWSTR, PCWSTR *, struct in6_addr *); + static NTSTATUS (WINAPI *pRtlIpv6StringToAddressExA)(PCSTR, struct in6_addr *, PULONG, PUSHORT); +@@ -142,6 +143,7 @@ static void InitFunctionPtrs(void) + pRtlIpv4AddressToStringA = (void *)GetProcAddress(hntdll, "RtlIpv4AddressToStringA"); + pRtlIpv4AddressToStringExA = (void *)GetProcAddress(hntdll, "RtlIpv4AddressToStringExA"); + pRtlIpv4StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressA"); ++ pRtlIpv4StringToAddressExA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressExA"); + pRtlIpv6StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressA"); + pRtlIpv6StringToAddressW = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressW"); + pRtlIpv6StringToAddressExA = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressExA"); +@@ -1331,98 +1333,109 @@ static void test_RtlIpv4AddressToStringEx(void) + res, size, buffer); + } + ++static struct ++{ ++ PCSTR address; ++ NTSTATUS res; ++ int terminator_offset; ++ int ip[4]; ++ enum { normal_4, strict_diff_4 = 1, ex_fail_4 = 2 } flags; ++ NTSTATUS res_strict; ++ int terminator_offset_strict; ++ int ip_strict[4]; ++} ipv4_tests[] = ++{ ++ { "", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { " ", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { "1.1.1.1", STATUS_SUCCESS, 7, { 1, 1, 1, 1 } }, ++ { "0.0.0.0", STATUS_SUCCESS, 7, { 0, 0, 0, 0 } }, ++ { "255.255.255.255", STATUS_SUCCESS, 15, { 255, 255, 255, 255 } }, ++ { "255.255.255.255:123", STATUS_SUCCESS, 15, { 255, 255, 255, 255 } }, ++ { "255.255.255.256", STATUS_INVALID_PARAMETER, 15, { -1 } }, ++ { "255.255.255.4294967295", STATUS_INVALID_PARAMETER, 22, { -1 } }, ++ { "255.255.255.4294967296", STATUS_INVALID_PARAMETER, 21, { -1 } }, ++ { "255.255.255.4294967297", STATUS_INVALID_PARAMETER, 21, { -1 } }, ++ { "a", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { "1.1.1.0xaA", STATUS_SUCCESS, 10, { 1, 1, 1, 170 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "1.1.1.0XaA", STATUS_SUCCESS, 10, { 1, 1, 1, 170 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "1.1.1.0x", STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "1.1.1.0xff", STATUS_SUCCESS, 10, { 1, 1, 1, 255 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "1.1.1.0x100", STATUS_INVALID_PARAMETER, 11, { -1 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "1.1.1.0xffffffff", STATUS_INVALID_PARAMETER, 16, { -1 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "1.1.1.0x100000000", STATUS_INVALID_PARAMETER, 16, { -1, 0, 0, 0 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "1.1.1.010", STATUS_SUCCESS, 9, { 1, 1, 1, 8 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "1.1.1.00", STATUS_SUCCESS, 8, { 1, 1, 1, 0 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "1.1.1.007", STATUS_SUCCESS, 9, { 1, 1, 1, 7 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "1.1.1.08", STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "1.1.1.008", STATUS_SUCCESS, 8, { 1, 1, 1, 0 }, strict_diff_4 | ex_fail_4, ++ STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "1.1.1.0a", STATUS_SUCCESS, 7, { 1, 1, 1, 0 }, ex_fail_4 }, ++ { "1.1.1.0o10", STATUS_SUCCESS, 7, { 1, 1, 1, 0 }, ex_fail_4 }, ++ { "1.1.1.0b10", STATUS_SUCCESS, 7, { 1, 1, 1, 0 }, ex_fail_4 }, ++ { "1.1.1.-2", STATUS_INVALID_PARAMETER, 6, { -1 } }, ++ { "1", STATUS_SUCCESS, 1, { 0, 0, 0, 1 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 1, { -1 } }, ++ { "-1", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { "203569230", STATUS_SUCCESS, 9, { 12, 34, 56, 78 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 9, { -1 } }, ++ { "1.223756", STATUS_SUCCESS, 8, { 1, 3, 106, 12 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 8, { -1 } }, ++ { "3.4.756", STATUS_SUCCESS, 7, { 3, 4, 2, 244 }, strict_diff_4, ++ STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "3.4.756.1", STATUS_INVALID_PARAMETER, 9, { -1 } }, ++ { "3.4.65536", STATUS_INVALID_PARAMETER, 9, { -1 } }, ++ { "3.4.5.6.7", STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "3.4.5.+6", STATUS_INVALID_PARAMETER, 6, { -1 } }, ++ { " 3.4.5.6", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { "\t3.4.5.6", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { "3.4.5.6 ", STATUS_SUCCESS, 7, { 3, 4, 5, 6 }, ex_fail_4 }, ++ { "3. 4.5.6", STATUS_INVALID_PARAMETER, 2, { -1 } }, ++ { ".", STATUS_INVALID_PARAMETER, 1, { -1 } }, ++ { "..", STATUS_INVALID_PARAMETER, 1, { -1 } }, ++ { "1.", STATUS_INVALID_PARAMETER, 2, { -1 } }, ++ { "1..", STATUS_INVALID_PARAMETER, 3, { -1 } }, ++ { ".1", STATUS_INVALID_PARAMETER, 1, { -1 } }, ++ { ".1.", STATUS_INVALID_PARAMETER, 1, { -1 } }, ++ { ".1.2.3", STATUS_INVALID_PARAMETER, 1, { -1 } }, ++ { "0.1.2.3", STATUS_SUCCESS, 7, { 0, 1, 2, 3 } }, ++ { "0.1.2.3.", STATUS_INVALID_PARAMETER, 7, { -1 } }, ++ { "[0.1.2.3]", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { "::1", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++ { ":1", STATUS_INVALID_PARAMETER, 0, { -1 } }, ++}; ++const unsigned int ipv4_testcount = sizeof(ipv4_tests) / sizeof(ipv4_tests[0]); ++ ++static void init_ip4(IN_ADDR* addr, const int src[4]) ++{ ++ if (!src || src[0] == -1) ++ { ++ addr->S_un.S_addr = 0xabababab; ++ } ++ else ++ { ++ addr->S_un.S_un_b.s_b1 = src[0]; ++ addr->S_un.S_un_b.s_b2 = src[1]; ++ addr->S_un.S_un_b.s_b3 = src[2]; ++ addr->S_un.S_un_b.s_b4 = src[3]; ++ } ++} ++ + static void test_RtlIpv4StringToAddress(void) + { + NTSTATUS res; + IN_ADDR ip, expected_ip; + PCSTR terminator; + CHAR dummy; +- struct +- { +- PCSTR address; +- NTSTATUS res; +- int terminator_offset; +- int ip[4]; +- BOOL strict_is_different; +- NTSTATUS res_strict; +- int terminator_offset_strict; +- int ip_strict[4]; +- } tests[] = +- { +- { "", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { " ", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { "1.1.1.1", STATUS_SUCCESS, 7, { 1, 1, 1, 1 } }, +- { "0.0.0.0", STATUS_SUCCESS, 7, { 0, 0, 0, 0 } }, +- { "255.255.255.255", STATUS_SUCCESS, 15, { 255, 255, 255, 255 } }, +- { "255.255.255.255:123", +- STATUS_SUCCESS, 15, { 255, 255, 255, 255 } }, +- { "255.255.255.256", STATUS_INVALID_PARAMETER, 15, { -1 } }, +- { "255.255.255.4294967295", +- STATUS_INVALID_PARAMETER, 22, { -1 } }, +- { "255.255.255.4294967296", +- STATUS_INVALID_PARAMETER, 21, { -1 } }, +- { "255.255.255.4294967297", +- STATUS_INVALID_PARAMETER, 21, { -1 } }, +- { "a", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { "1.1.1.0xaA", STATUS_SUCCESS, 10, { 1, 1, 1, 170 }, +- TRUE, STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "1.1.1.0XaA", STATUS_SUCCESS, 10, { 1, 1, 1, 170 }, +- TRUE, STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "1.1.1.0x", STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "1.1.1.0xff", STATUS_SUCCESS, 10, { 1, 1, 1, 255 }, +- TRUE, STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "1.1.1.0x100", STATUS_INVALID_PARAMETER, 11, { -1 }, +- TRUE, STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "1.1.1.0xffffffff",STATUS_INVALID_PARAMETER, 16, { -1 }, +- TRUE, STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "1.1.1.0x100000000", +- STATUS_INVALID_PARAMETER, 16, { -1, 0, 0, 0 }, +- TRUE, STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "1.1.1.010", STATUS_SUCCESS, 9, { 1, 1, 1, 8 }, +- TRUE, STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "1.1.1.00", STATUS_SUCCESS, 8, { 1, 1, 1, 0 }, +- TRUE, STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "1.1.1.007", STATUS_SUCCESS, 9, { 1, 1, 1, 7 }, +- TRUE, STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "1.1.1.08", STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "1.1.1.008", STATUS_SUCCESS, 8, { 1, 1, 1, 0 }, +- TRUE, STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "1.1.1.0a", STATUS_SUCCESS, 7, { 1, 1, 1, 0 } }, +- { "1.1.1.0o10", STATUS_SUCCESS, 7, { 1, 1, 1, 0 } }, +- { "1.1.1.0b10", STATUS_SUCCESS, 7, { 1, 1, 1, 0 } }, +- { "1.1.1.-2", STATUS_INVALID_PARAMETER, 6, { -1 } }, +- { "1", STATUS_SUCCESS, 1, { 0, 0, 0, 1 }, +- TRUE, STATUS_INVALID_PARAMETER, 1, { -1 } }, +- { "-1", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { "203569230", STATUS_SUCCESS, 9, { 12, 34, 56, 78 }, +- TRUE, STATUS_INVALID_PARAMETER, 9, { -1 } }, +- { "1.223756", STATUS_SUCCESS, 8, { 1, 3, 106, 12 }, +- TRUE, STATUS_INVALID_PARAMETER, 8, { -1 } }, +- { "3.4.756", STATUS_SUCCESS, 7, { 3, 4, 2, 244 }, +- TRUE, STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "3.4.756.1", STATUS_INVALID_PARAMETER, 9, { -1 } }, +- { "3.4.65536", STATUS_INVALID_PARAMETER, 9, { -1 } }, +- { "3.4.5.6.7", STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "3.4.5.+6", STATUS_INVALID_PARAMETER, 6, { -1 } }, +- { " 3.4.5.6", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { "\t3.4.5.6", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { "3.4.5.6 ", STATUS_SUCCESS, 7, { 3, 4, 5, 6 } }, +- { "3. 4.5.6", STATUS_INVALID_PARAMETER, 2, { -1 } }, +- { ".", STATUS_INVALID_PARAMETER, 1, { -1 } }, +- { "..", STATUS_INVALID_PARAMETER, 1, { -1 } }, +- { "1.", STATUS_INVALID_PARAMETER, 2, { -1 } }, +- { "1..", STATUS_INVALID_PARAMETER, 3, { -1 } }, +- { ".1", STATUS_INVALID_PARAMETER, 1, { -1 } }, +- { ".1.", STATUS_INVALID_PARAMETER, 1, { -1 } }, +- { ".1.2.3", STATUS_INVALID_PARAMETER, 1, { -1 } }, +- { "0.1.2.3", STATUS_SUCCESS, 7, { 0, 1, 2, 3 } }, +- { "0.1.2.3.", STATUS_INVALID_PARAMETER, 7, { -1 } }, +- { "[0.1.2.3]", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { "::1", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- { ":1", STATUS_INVALID_PARAMETER, 0, { -1 } }, +- }; +- const int testcount = sizeof(tests) / sizeof(tests[0]); +- int i; ++ unsigned int i; + + if (!pRtlIpv4StringToAddressA) + { +@@ -1444,65 +1457,174 @@ static void test_RtlIpv4StringToAddress(void) + */ + } + +- for (i = 0; i < testcount; i++) ++ for (i = 0; i < ipv4_testcount; i++) + { + /* non-strict */ + terminator = &dummy; + ip.S_un.S_addr = 0xabababab; +- res = pRtlIpv4StringToAddressA(tests[i].address, FALSE, &terminator, &ip); +- ok(res == tests[i].res, ++ res = pRtlIpv4StringToAddressA(ipv4_tests[i].address, FALSE, &terminator, &ip); ++ ok(res == ipv4_tests[i].res, + "[%s] res = 0x%08x, expected 0x%08x\n", +- tests[i].address, res, tests[i].res); +- ok(terminator == tests[i].address + tests[i].terminator_offset, ++ ipv4_tests[i].address, res, ipv4_tests[i].res); ++ ok(terminator == ipv4_tests[i].address + ipv4_tests[i].terminator_offset, + "[%s] terminator = %p, expected %p\n", +- tests[i].address, terminator, tests[i].address + tests[i].terminator_offset); +- if (tests[i].ip[0] == -1) +- expected_ip.S_un.S_addr = 0xabababab; +- else +- { +- expected_ip.S_un.S_un_b.s_b1 = tests[i].ip[0]; +- expected_ip.S_un.S_un_b.s_b2 = tests[i].ip[1]; +- expected_ip.S_un.S_un_b.s_b3 = tests[i].ip[2]; +- expected_ip.S_un.S_un_b.s_b4 = tests[i].ip[3]; +- } ++ ipv4_tests[i].address, terminator, ipv4_tests[i].address + ipv4_tests[i].terminator_offset); ++ ++ init_ip4(&expected_ip, ipv4_tests[i].ip); + ok(ip.S_un.S_addr == expected_ip.S_un.S_addr, + "[%s] ip = %08x, expected %08x\n", +- tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); ++ ipv4_tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); + +- if (!tests[i].strict_is_different) ++ if (!(ipv4_tests[i].flags & strict_diff_4)) + { +- tests[i].res_strict = tests[i].res; +- tests[i].terminator_offset_strict = tests[i].terminator_offset; +- tests[i].ip_strict[0] = tests[i].ip[0]; +- tests[i].ip_strict[1] = tests[i].ip[1]; +- tests[i].ip_strict[2] = tests[i].ip[2]; +- tests[i].ip_strict[3] = tests[i].ip[3]; ++ ipv4_tests[i].res_strict = ipv4_tests[i].res; ++ ipv4_tests[i].terminator_offset_strict = ipv4_tests[i].terminator_offset; ++ ipv4_tests[i].ip_strict[0] = ipv4_tests[i].ip[0]; ++ ipv4_tests[i].ip_strict[1] = ipv4_tests[i].ip[1]; ++ ipv4_tests[i].ip_strict[2] = ipv4_tests[i].ip[2]; ++ ipv4_tests[i].ip_strict[3] = ipv4_tests[i].ip[3]; + } + /* strict */ + terminator = &dummy; + ip.S_un.S_addr = 0xabababab; +- res = pRtlIpv4StringToAddressA(tests[i].address, TRUE, &terminator, &ip); +- ok(res == tests[i].res_strict, ++ res = pRtlIpv4StringToAddressA(ipv4_tests[i].address, TRUE, &terminator, &ip); ++ ok(res == ipv4_tests[i].res_strict, + "[%s] res = 0x%08x, expected 0x%08x\n", +- tests[i].address, res, tests[i].res_strict); +- ok(terminator == tests[i].address + tests[i].terminator_offset_strict, ++ ipv4_tests[i].address, res, ipv4_tests[i].res_strict); ++ ok(terminator == ipv4_tests[i].address + ipv4_tests[i].terminator_offset_strict, + "[%s] terminator = %p, expected %p\n", +- tests[i].address, terminator, tests[i].address + tests[i].terminator_offset_strict); +- if (tests[i].ip_strict[0] == -1) +- expected_ip.S_un.S_addr = 0xabababab; +- else +- { +- expected_ip.S_un.S_un_b.s_b1 = tests[i].ip_strict[0]; +- expected_ip.S_un.S_un_b.s_b2 = tests[i].ip_strict[1]; +- expected_ip.S_un.S_un_b.s_b3 = tests[i].ip_strict[2]; +- expected_ip.S_un.S_un_b.s_b4 = tests[i].ip_strict[3]; +- } ++ ipv4_tests[i].address, terminator, ipv4_tests[i].address + ipv4_tests[i].terminator_offset_strict); ++ ++ init_ip4(&expected_ip, ipv4_tests[i].ip_strict); + ok(ip.S_un.S_addr == expected_ip.S_un.S_addr, + "[%s] ip = %08x, expected %08x\n", +- tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); ++ ipv4_tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); + } + } + ++static void test_RtlIpv4StringToAddressEx(void) ++{ ++ NTSTATUS res; ++ IN_ADDR ip, expected_ip; ++ USHORT port; ++ static const struct ++ { ++ PCSTR address; ++ NTSTATUS res; ++ int ip[4]; ++ USHORT port; ++ } ipv4_ex_tests[] = ++ { ++ { "", STATUS_INVALID_PARAMETER, { -1 }, 0xdead }, ++ { " ", STATUS_INVALID_PARAMETER, { -1 }, 0xdead }, ++ { "1.1.1.1:", STATUS_INVALID_PARAMETER, { 1, 1, 1, 1 }, 0xdead }, ++ { "1.1.1.1+", STATUS_INVALID_PARAMETER, { 1, 1, 1, 1 }, 0xdead }, ++ { "1.1.1.1:1", STATUS_SUCCESS, { 1, 1, 1, 1 }, 0x100 }, ++ { "256.1.1.1:1", STATUS_INVALID_PARAMETER, { -1 }, 0xdead }, ++ { "-1.1.1.1:1", STATUS_INVALID_PARAMETER, { -1 }, 0xdead }, ++ { "0.0.0.0:0", STATUS_INVALID_PARAMETER, { 0, 0, 0, 0 }, 0xdead }, ++ { "0.0.0.0:1", STATUS_SUCCESS, { 0, 0, 0, 0 }, 0x100 }, ++ { "1.2.3.4:65535", STATUS_SUCCESS, { 1, 2, 3, 4 }, 65535 }, ++ { "1.2.3.4:65536", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, ++ { "1.2.3.4:0xffff", STATUS_SUCCESS, { 1, 2, 3, 4 }, 65535 }, ++ { "1.2.3.4:0XfFfF", STATUS_SUCCESS, { 1, 2, 3, 4 }, 65535 }, ++ { "1.2.3.4:011064", STATUS_SUCCESS, { 1, 2, 3, 4 }, 0x3412 }, ++ { "1.2.3.4:1234a", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, ++ { "1.2.3.4:1234+", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, ++ { "1.2.3.4: 1234", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, ++ { "1.2.3.4:\t1234", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, ++ }; ++ const unsigned int ipv4_ex_testcount = sizeof(ipv4_ex_tests) / sizeof(ipv4_ex_tests[0]); ++ unsigned int i; ++ BOOLEAN strict; ++ ++ if (!pRtlIpv4StringToAddressExA) ++ { ++ skip("RtlIpv4StringToAddressEx not available\n"); ++ return; ++ } ++ ++ /* do not crash, and do not touch the ip / port. */ ++ ip.S_un.S_addr = 0xabababab; ++ port = 0xdead; ++ res = pRtlIpv4StringToAddressExA(NULL, FALSE, &ip, &port); ++ ok(res == STATUS_INVALID_PARAMETER, "[null address] res = 0x%08x, expected 0x%08x\n", ++ res, STATUS_INVALID_PARAMETER); ++ ok(ip.S_un.S_addr == 0xabababab, "RtlIpv4StringToAddressExA should not touch the ip!, ip == %x\n", ip.S_un.S_addr); ++ ok(port == 0xdead, "RtlIpv4StringToAddressExA should not touch the port!, port == %x\n", port); ++ ++ port = 0xdead; ++ res = pRtlIpv4StringToAddressExA("1.1.1.1", FALSE, NULL, &port); ++ ok(res == STATUS_INVALID_PARAMETER, "[null ip] res = 0x%08x, expected 0x%08x\n", ++ res, STATUS_INVALID_PARAMETER); ++ ok(port == 0xdead, "RtlIpv4StringToAddressExA should not touch the port!, port == %x\n", port); ++ ++ ip.S_un.S_addr = 0xabababab; ++ port = 0xdead; ++ res = pRtlIpv4StringToAddressExA("1.1.1.1", FALSE, &ip, NULL); ++ ok(res == STATUS_INVALID_PARAMETER, "[null port] res = 0x%08x, expected 0x%08x\n", ++ res, STATUS_INVALID_PARAMETER); ++ ok(ip.S_un.S_addr == 0xabababab, "RtlIpv4StringToAddressExA should not touch the ip!, ip == %x\n", ip.S_un.S_addr); ++ ok(port == 0xdead, "RtlIpv4StringToAddressExA should not touch the port!, port == %x\n", port); ++ ++ /* first we run the non-ex testcases on the ex function */ ++ for (i = 0; i < ipv4_testcount; i++) ++ { ++ NTSTATUS expect_res = (ipv4_tests[i].flags & ex_fail_4) ? STATUS_INVALID_PARAMETER : ipv4_tests[i].res; ++ ++ /* non-strict */ ++ port = 0xdead; ++ ip.S_un.S_addr = 0xabababab; ++ res = pRtlIpv4StringToAddressExA(ipv4_tests[i].address, FALSE, &ip, &port); ++ ok(res == expect_res, "[%s] res = 0x%08x, expected 0x%08x\n", ++ ipv4_tests[i].address, res, expect_res); ++ ++ init_ip4(&expected_ip, ipv4_tests[i].ip); ++ ok(ip.S_un.S_addr == expected_ip.S_un.S_addr, "[%s] ip = %08x, expected %08x\n", ++ ipv4_tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); ++ ++ if (!(ipv4_tests[i].flags & strict_diff_4)) ++ { ++ ipv4_tests[i].res_strict = ipv4_tests[i].res; ++ ipv4_tests[i].terminator_offset_strict = ipv4_tests[i].terminator_offset; ++ ipv4_tests[i].ip_strict[0] = ipv4_tests[i].ip[0]; ++ ipv4_tests[i].ip_strict[1] = ipv4_tests[i].ip[1]; ++ ipv4_tests[i].ip_strict[2] = ipv4_tests[i].ip[2]; ++ ipv4_tests[i].ip_strict[3] = ipv4_tests[i].ip[3]; ++ } ++ /* strict */ ++ expect_res = (ipv4_tests[i].flags & ex_fail_4) ? STATUS_INVALID_PARAMETER : ipv4_tests[i].res_strict; ++ port = 0xdead; ++ ip.S_un.S_addr = 0xabababab; ++ res = pRtlIpv4StringToAddressExA(ipv4_tests[i].address, TRUE, &ip, &port); ++ ok(res == expect_res, "[%s] res = 0x%08x, expected 0x%08x\n", ++ ipv4_tests[i].address, res, expect_res); ++ ++ init_ip4(&expected_ip, ipv4_tests[i].ip_strict); ++ ok(ip.S_un.S_addr == expected_ip.S_un.S_addr, "[%s] ip = %08x, expected %08x\n", ++ ipv4_tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); ++ } ++ ++ ++ for (i = 0; i < ipv4_ex_testcount; i++) ++ { ++ /* Strict is only relevant for the ip address, so make sure that it does not influence the port */ ++ for (strict = 0; strict < 2; strict++) ++ { ++ ip.S_un.S_addr = 0xabababab; ++ port = 0xdead; ++ res = pRtlIpv4StringToAddressExA(ipv4_ex_tests[i].address, strict, &ip, &port); ++ ok(res == ipv4_ex_tests[i].res, "[%s] res = 0x%08x, expected 0x%08x\n", ++ ipv4_ex_tests[i].address, res, ipv4_ex_tests[i].res); ++ ++ init_ip4(&expected_ip, ipv4_ex_tests[i].ip); ++ ok(ip.S_un.S_addr == expected_ip.S_un.S_addr, "[%s] ip = %08x, expected %08x\n", ++ ipv4_ex_tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); ++ ok(port == ipv4_ex_tests[i].port, "[%s] port = %u, expected %u\n", ++ ipv4_ex_tests[i].address, port, ipv4_ex_tests[i].port); ++ } ++ } ++} + + /* ipv6 addresses based on the set from https://github.com/beaugunderson/javascript-ipv6/tree/master/test/data */ + static const struct +@@ -2318,6 +2440,7 @@ START_TEST(rtl) + test_RtlIpv4AddressToString(); + test_RtlIpv4AddressToStringEx(); + test_RtlIpv4StringToAddress(); ++ test_RtlIpv4StringToAddressEx(); + test_RtlIpv6StringToAddress(); + test_RtlIpv6StringToAddressEx(); + test_LdrAddRefDll(); +-- +2.3.1 + diff --git a/patches/ntdll-RtlIpv4StringToAddressExA/0001-ntdll-tests-Add-tests-for-RtlIpv4StringToAddressExA.patch b/patches/ntdll-RtlIpv4StringToAddressExA/0001-ntdll-tests-Add-tests-for-RtlIpv4StringToAddressExA.patch deleted file mode 100644 index 35a87187..00000000 --- a/patches/ntdll-RtlIpv4StringToAddressExA/0001-ntdll-tests-Add-tests-for-RtlIpv4StringToAddressExA.patch +++ /dev/null @@ -1,133 +0,0 @@ -From 83f6efa0d3001beb6b4b3ba4f510502ebeae9bb3 Mon Sep 17 00:00:00 2001 -From: Sebastian Lackner -Date: Sat, 20 Dec 2014 20:08:31 +0100 -Subject: ntdll/tests: Add tests for RtlIpv4StringToAddressExA. - ---- - dlls/ntdll/tests/rtl.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++ - 1 file changed, 91 insertions(+) - -diff --git a/dlls/ntdll/tests/rtl.c b/dlls/ntdll/tests/rtl.c -index e8eb04a..d51588c 100644 ---- a/dlls/ntdll/tests/rtl.c -+++ b/dlls/ntdll/tests/rtl.c -@@ -89,6 +89,7 @@ static IMAGE_BASE_RELOCATION *(WINAPI *pLdrProcessRelocationBlock)(void*,UINT,US - static CHAR * (WINAPI *pRtlIpv4AddressToStringA)(const IN_ADDR *, LPSTR); - static NTSTATUS (WINAPI *pRtlIpv4AddressToStringExA)(const IN_ADDR *, USHORT, LPSTR, PULONG); - static NTSTATUS (WINAPI *pRtlIpv4StringToAddressA)(PCSTR, BOOLEAN, PCSTR *, IN_ADDR *); -+static NTSTATUS (WINAPI *pRtlIpv4StringToAddressExA)(PCSTR, BOOLEAN, IN_ADDR *, PUSHORT); - static NTSTATUS (WINAPI *pLdrAddRefDll)(ULONG, HMODULE); - static NTSTATUS (WINAPI *pLdrLockLoaderLock)(ULONG, ULONG*, ULONG_PTR*); - static NTSTATUS (WINAPI *pLdrUnlockLoaderLock)(ULONG, ULONG_PTR); -@@ -136,6 +137,7 @@ static void InitFunctionPtrs(void) - pRtlIpv4AddressToStringA = (void *)GetProcAddress(hntdll, "RtlIpv4AddressToStringA"); - pRtlIpv4AddressToStringExA = (void *)GetProcAddress(hntdll, "RtlIpv4AddressToStringExA"); - pRtlIpv4StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressA"); -+ pRtlIpv4StringToAddressExA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressExA"); - pLdrAddRefDll = (void *)GetProcAddress(hntdll, "LdrAddRefDll"); - pLdrLockLoaderLock = (void *)GetProcAddress(hntdll, "LdrLockLoaderLock"); - pLdrUnlockLoaderLock = (void *)GetProcAddress(hntdll, "LdrUnlockLoaderLock"); -@@ -1492,6 +1494,94 @@ static void test_RtlIpv4StringToAddress(void) - } - } - -+static void test_RtlIpv4StringToAddressEx(void) -+{ -+ NTSTATUS res; -+ IN_ADDR ip, expected_ip; -+ USHORT port; -+ struct -+ { -+ PCSTR address; -+ NTSTATUS res; -+ int ip[4]; -+ USHORT port; -+ } tests[] = -+ { -+ { "", STATUS_INVALID_PARAMETER, { -1 }, 0xdead }, -+ { " ", STATUS_INVALID_PARAMETER, { -1 }, 0xdead }, -+ { "1.1.1.1:", STATUS_INVALID_PARAMETER, { 1, 1, 1, 1 }, 0xdead }, -+ { "1.1.1.1+", STATUS_INVALID_PARAMETER, { 1, 1, 1, 1 }, 0xdead }, -+ { "1.1.1.1:1", STATUS_SUCCESS, { 1, 1, 1, 1 }, 0x100 }, -+ { "0.0.0.0:0", STATUS_INVALID_PARAMETER, { 0, 0, 0, 0 }, 0xdead }, -+ { "0.0.0.0:1", STATUS_SUCCESS, { 0, 0, 0, 0 }, 0x100 }, -+ { "1.2.3.4:65535", STATUS_SUCCESS, { 1, 2, 3, 4 }, 65535 }, -+ { "1.2.3.4:65536", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, -+ { "1.2.3.4:0xffff", STATUS_SUCCESS, { 1, 2, 3, 4 }, 65535 }, -+ { "1.2.3.4:0XfFfF", STATUS_SUCCESS, { 1, 2, 3, 4 }, 65535 }, -+ { "1.2.3.4:011064", STATUS_SUCCESS, { 1, 2, 3, 4 }, 0x3412 }, -+ { "1.2.3.4:1234a", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, -+ { "1.2.3.4:1234+", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, -+ { "1.2.3.4: 1234", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, -+ { "1.2.3.4:\t1234", STATUS_INVALID_PARAMETER, { 1, 2, 3, 4 }, 0xdead }, -+ }; -+ const int testcount = sizeof(tests) / sizeof(tests[0]); -+ int i, Strict; -+ -+ if (!pRtlIpv4StringToAddressExA) -+ { -+ skip("RtlIpv4StringToAddressEx not available\n"); -+ return; -+ } -+ -+ /* do not crash, and do not touch the ip / port. */ -+ ip.S_un.S_addr = 0xabababab; -+ port = 0xdead; -+ res = pRtlIpv4StringToAddressExA(NULL, FALSE, &ip, &port); -+ ok(res == STATUS_INVALID_PARAMETER, "[null address] res = 0x%08x, expected 0x%08x\n", res, STATUS_INVALID_PARAMETER); -+ ok(ip.S_un.S_addr == 0xabababab, "RtlIpv4StringToAddressExA should not touch the ip!, ip == %x\n", ip.S_un.S_addr); -+ ok(port == 0xdead, "RtlIpv4StringToAddressExA should not touch the port!, port == %x\n", port); -+ -+ port = 0xdead; -+ res = pRtlIpv4StringToAddressExA("1.1.1.1", FALSE, NULL, &port); -+ ok(res == STATUS_INVALID_PARAMETER, "[null ip] res = 0x%08x, expected 0x%08x\n", res, STATUS_INVALID_PARAMETER); -+ ok(port == 0xdead, "RtlIpv4StringToAddressExA should not touch the port!, port == %x\n", port); -+ -+ ip.S_un.S_addr = 0xabababab; -+ port = 0xdead; -+ res = pRtlIpv4StringToAddressExA("1.1.1.1", FALSE, &ip, NULL); -+ ok(res == STATUS_INVALID_PARAMETER, "[null port] res = 0x%08x, expected 0x%08x\n", res, STATUS_INVALID_PARAMETER); -+ ok(ip.S_un.S_addr == 0xabababab, "RtlIpv4StringToAddressExA should not touch the ip!, ip == %x\n", ip.S_un.S_addr); -+ ok(port == 0xdead, "RtlIpv4StringToAddressExA should not touch the port!, port == %x\n", port); -+ -+ for (i = 0; i < testcount; i++) -+ { -+ /* Strict is only relevant for the ip address, so make sure that it does not influence the port */ -+ for (Strict = 0; Strict < 2; Strict++) -+ { -+ ip.S_un.S_addr = 0xabababab; -+ port = 0xdead; -+ res = pRtlIpv4StringToAddressExA(tests[i].address, Strict, &ip, &port); -+ if (tests[i].ip[0] == -1) -+ { -+ expected_ip.S_un.S_addr = 0xabababab; -+ } -+ else -+ { -+ expected_ip.S_un.S_un_b.s_b1 = tests[i].ip[0]; -+ expected_ip.S_un.S_un_b.s_b2 = tests[i].ip[1]; -+ expected_ip.S_un.S_un_b.s_b3 = tests[i].ip[2]; -+ expected_ip.S_un.S_un_b.s_b4 = tests[i].ip[3]; -+ } -+ ok(res == tests[i].res, "[%s] res = 0x%08x, expected 0x%08x\n", -+ tests[i].address, res, tests[i].res); -+ ok(ip.S_un.S_addr == expected_ip.S_un.S_addr, "[%s] ip = %08x, expected %08x\n", -+ tests[i].address, ip.S_un.S_addr, expected_ip.S_un.S_addr); -+ ok(port == tests[i].port, "[%s] port = %u, expected %u\n", -+ tests[i].address, port, tests[i].port); -+ } -+ } -+} -+ - static void test_LdrAddRefDll(void) - { - HMODULE mod, mod2; -@@ -1624,4 +1714,5 @@ START_TEST(rtl) - test_RtlIpv4AddressToStringEx(); - test_RtlIpv4StringToAddress(); -+ test_RtlIpv4StringToAddressEx(); - test_LdrAddRefDll(); - test_LdrLockLoaderLock(); --- -2.1.3 - diff --git a/patches/patchinstall.sh b/patches/patchinstall.sh index adcc2a05..503218fa 100755 --- a/patches/patchinstall.sh +++ b/patches/patchinstall.sh @@ -138,7 +138,7 @@ patch_enable_all () enable_ntdll_NtQuerySection="$1" enable_ntdll_NtSetLdtEntries="$1" enable_ntdll_Pipe_SpecialCharacters="$1" - enable_ntdll_RtlIpv4StringToAddressExA="$1" + enable_ntdll_RtlIpStringToAddress="$1" enable_ntdll_RtlUnwindEx="$1" enable_ntdll_ThreadTime="$1" enable_ntdll_Threading="$1" @@ -457,8 +457,8 @@ patch_enable () ntdll-Pipe_SpecialCharacters) enable_ntdll_Pipe_SpecialCharacters="$2" ;; - ntdll-RtlIpv4StringToAddressExA) - enable_ntdll_RtlIpv4StringToAddressExA="$2" + ntdll-RtlIpStringToAddress) + enable_ntdll_RtlIpStringToAddress="$2" ;; ntdll-RtlUnwindEx) enable_ntdll_RtlUnwindEx="$2" @@ -1018,6 +1018,13 @@ if test "$enable_ntdll_WriteWatches" -eq 1; then enable_ws2_32_WriteWatches=1 fi +if test "$enable_ntdll_LZNT1_Compression" -eq 1; then + if test "$enable_ntdll_RtlIpStringToAddress" -gt 1; then + abort "Patchset ntdll-RtlIpStringToAddress disabled, but ntdll-LZNT1_Compression depends on that." + fi + enable_ntdll_RtlIpStringToAddress=1 +fi + if test "$enable_ntdll_Junction_Points" -eq 1; then if test "$enable_ntdll_Fix_Free" -gt 1; then abort "Patchset ntdll-Fix_Free disabled, but ntdll-Junction_Points depends on that." @@ -2833,6 +2840,22 @@ if test "$enable_ntdll_Junction_Points" -eq 1; then ) >> "$patchlist" fi +# Patchset ntdll-RtlIpStringToAddress +# | +# | Modified files: +# | * dlls/ntdll/tests/rtl.c +# | +if test "$enable_ntdll_RtlIpStringToAddress" -eq 1; then + patch_apply ntdll-RtlIpStringToAddress/0001-ntdll-tests-Tests-for-RtlIpv6StringToAddress-try-6.patch + patch_apply ntdll-RtlIpStringToAddress/0002-ntdll-tests-Tests-for-RtlIpv6StringToAddressEx-try-6.patch + patch_apply ntdll-RtlIpStringToAddress/0003-ntdll-tests-Tests-for-RtlIpv4StringToAddressEx-try-5.patch + ( + echo '+ { "Mark Jansen", "ntdll/tests: Tests for RtlIpv6StringToAddress.", 6 },'; + echo '+ { "Mark Jansen", "ntdll/tests: Tests for RtlIpv6StringToAddressEx.", 6 },'; + echo '+ { "Mark Jansen", "ntdll/tests: Tests for RtlIpv4StringToAddressEx (try 5, resend).", 1 },'; + ) >> "$patchlist" +fi + # Patchset ntdll-LZNT1_Compression # | # | This patchset fixes the following Wine bugs: @@ -2902,18 +2925,6 @@ if test "$enable_ntdll_Pipe_SpecialCharacters" -eq 1; then ) >> "$patchlist" fi -# Patchset ntdll-RtlIpv4StringToAddressExA -# | -# | Modified files: -# | * dlls/ntdll/tests/rtl.c -# | -if test "$enable_ntdll_RtlIpv4StringToAddressExA" -eq 1; then - patch_apply ntdll-RtlIpv4StringToAddressExA/0001-ntdll-tests-Add-tests-for-RtlIpv4StringToAddressExA.patch - ( - echo '+ { "Sebastian Lackner", "ntdll/tests: Add tests for RtlIpv4StringToAddressExA.", 1 },'; - ) >> "$patchlist" -fi - # Patchset ntdll-RtlUnwindEx # | # | This patchset fixes the following Wine bugs: