wine/wine-staging
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-staging.git synced 2025-01-28 22:04:43 -08:00
Code Issues Packages Projects Releases Wiki Activity

Rebase against acb879c9d2feae69e8b5b1ede28523a29aef1b89

Browse Source
This commit is contained in:
Alistair Leslie-Hughes 2018-07-12 10:17:14 +10:00
parent 292a0e67f4
commit fd81bd7755
8 changed files with 17 additions and 1166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

267
patches/advapi32-Performance_Counters/0001-advapi32-tests-Add-more-tests-for-performance-counte.patch
View File

@ -1,267 +0,0 @@
From e950724c38a4f81efb97bb9595dc59c5fb925da0 Mon Sep 17 00:00:00 2001
From: Dmitry Timoshkov <dmitry@baikal.ru>
Date: Wed, 12 Apr 2017 12:33:31 +0800
Subject: advapi32/tests: Add more tests for performance counters.
---
dlls/advapi32/tests/registry.c | 196 ++++++++++++++++++++++++++++++++++++++++-
include/winreg.h | 2 +
2 files changed, 194 insertions(+), 4 deletions(-)
diff --git a/dlls/advapi32/tests/registry.c b/dlls/advapi32/tests/registry.c
index 846f1c49628..d850f6a3aa7 100644
--- a/dlls/advapi32/tests/registry.c
+++ b/dlls/advapi32/tests/registry.c
@@ -3520,35 +3520,73 @@ static void test_RegNotifyChangeKeyValue(void)
CloseHandle(event);
}
+static const char *dbgstr_longlong(ULONGLONG ll)
+{
+ static char buf[16][64];
+ static int idx;
+
+ idx &= 0x0f;
+
+ if (sizeof(ll) > sizeof(unsigned long) && ll >> 32)
+ sprintf(buf[idx], "0x%lx%08lx", (unsigned long)(ll >> 32), (unsigned long)ll);
+ else
+ sprintf(buf[idx], "0x%08lx", (unsigned long)ll);
+
+ return buf[idx++];
+}
+
+#define cmp_li(a, b, c) cmp_li_real(a, b, c, __LINE__)
+static void cmp_li_real(LARGE_INTEGER *l1, LARGE_INTEGER *l2, LONGLONG slack, int line)
+{
+ LONGLONG diff = l2->QuadPart - l1->QuadPart;
+ if (diff < 0) diff = -diff;
+ ok_(__FILE__, line)(diff <= slack, "values don't match: %s/%s\n",
+ dbgstr_longlong(l1->QuadPart), dbgstr_longlong(l2->QuadPart));
+}
+
static void test_RegQueryValueExPerformanceData(void)
{
- DWORD cbData, len;
+ static const WCHAR globalW[] = { 'G','l','o','b','a','l',0 };
+ static const WCHAR dummyW[5] = { 'd','u','m','m','y' };
+ static const char * const names[] = { NULL, "", "Global", "2" "invalid counter name" };
+ DWORD cbData, len, i, type;
BYTE *value;
DWORD dwret;
LONG limit = 6;
PERF_DATA_BLOCK *pdb;
+ HKEY hkey;
+ BYTE buf[256 + sizeof(PERF_DATA_BLOCK)];
/* Test with data == NULL */
dwret = RegQueryValueExA( HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, NULL, &cbData );
todo_wine ok( dwret == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", dwret );
+ dwret = RegQueryValueExW( HKEY_PERFORMANCE_DATA, globalW, NULL, NULL, NULL, &cbData );
+ todo_wine ok( dwret == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", dwret );
+
/* Test ERROR_MORE_DATA, start with small buffer */
len = 10;
value = HeapAlloc(GetProcessHeap(), 0, len);
cbData = len;
- dwret = RegQueryValueExA( HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, value, &cbData );
+ type = 0xdeadbeef;
+ dwret = RegQueryValueExA( HKEY_PERFORMANCE_DATA, "Global", NULL, &type, value, &cbData );
todo_wine ok( dwret == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", dwret );
+todo_wine
+ ok(type == REG_BINARY, "got %u\n", type);
while( dwret == ERROR_MORE_DATA && limit)
{
len = len * 10;
value = HeapReAlloc( GetProcessHeap(), 0, value, len );
cbData = len;
- dwret = RegQueryValueExA( HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, value, &cbData );
+ type = 0xdeadbeef;
+ dwret = RegQueryValueExA( HKEY_PERFORMANCE_DATA, "Global", NULL, &type, value, &cbData );
limit--;
}
ok(limit > 0, "too many times ERROR_MORE_DATA returned\n");
todo_wine ok(dwret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", dwret);
+todo_wine
+ ok(type == REG_BINARY, "got %u\n", type);
/* Check returned data */
if (dwret == ERROR_SUCCESS)
@@ -3565,8 +3603,158 @@ static void test_RegQueryValueExPerformanceData(void)
}
HeapFree(GetProcessHeap(), 0, value);
-}
+ for (i = 0; i < sizeof(names)/sizeof(names[0]); i++)
+ {
+ cbData = 0xdeadbeef;
+ dwret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, names[i], NULL, NULL, NULL, &cbData);
+todo_wine
+ ok(dwret == ERROR_MORE_DATA, "%u/%s: got %u\n", i, names[i], dwret);
+ ok(cbData == 0, "got %u\n", cbData);
+
+ cbData = 0;
+ dwret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, names[i], NULL, NULL, NULL, &cbData);
+todo_wine
+ ok(dwret == ERROR_MORE_DATA, "%u/%s: got %u\n", i, names[i], dwret);
+ ok(cbData == 0, "got %u\n", cbData);
+
+ cbData = 0xdeadbeef;
+ dwret = RegQueryValueExA(HKEY_PERFORMANCE_TEXT, names[i], NULL, NULL, NULL, &cbData);
+todo_wine
+ ok(dwret == ERROR_MORE_DATA, "%u/%s: got %u\n", i, names[i], dwret);
+ ok(cbData == 0, "got %u\n", cbData);
+
+ cbData = 0;
+ dwret = RegQueryValueExA(HKEY_PERFORMANCE_TEXT, names[i], NULL, NULL, NULL, &cbData);
+todo_wine
+ ok(dwret == ERROR_MORE_DATA, "%u/%s: got %u\n", i, names[i], dwret);
+ ok(cbData == 0, "got %u\n", cbData);
+
+ cbData = 0xdeadbeef;
+ dwret = RegQueryValueExA(HKEY_PERFORMANCE_NLSTEXT, names[i], NULL, NULL, NULL, &cbData);
+todo_wine
+ ok(dwret == ERROR_MORE_DATA, "%u/%s: got %u\n", i, names[i], dwret);
+ ok(cbData == 0, "got %u\n", cbData);
+
+ cbData = 0;
+ dwret = RegQueryValueExA(HKEY_PERFORMANCE_NLSTEXT, names[i], NULL, NULL, NULL, &cbData);
+todo_wine
+ ok(dwret == ERROR_MORE_DATA, "%u/%s: got %u\n", i, names[i], dwret);
+ ok(cbData == 0, "got %u\n", cbData);
+ }
+
+ memset(buf, 0x77, sizeof(buf));
+ type = 0xdeadbeef;
+ cbData = sizeof(buf);
+ dwret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "invalid counter name", NULL, &type, buf, &cbData);
+todo_wine
+ ok(dwret == ERROR_SUCCESS, "got %u\n", dwret);
+todo_wine
+ ok(type == REG_BINARY, "got %u\n", type);
+ if (dwret == ERROR_SUCCESS)
+ {
+ SYSTEMTIME st;
+ WCHAR sysname[MAX_COMPUTERNAME_LENGTH + 1];
+ DWORD sysname_len;
+ LARGE_INTEGER counter, freq, ftime;
+
+ GetSystemTime(&st);
+ GetSystemTimeAsFileTime((FILETIME *)&ftime);
+ QueryPerformanceCounter(&counter);
+ QueryPerformanceFrequency(&freq);
+
+ sysname_len = MAX_COMPUTERNAME_LENGTH + 1;
+ GetComputerNameW(sysname, &sysname_len);
+
+ pdb = (PERF_DATA_BLOCK *)buf;
+ ok(pdb->Signature[0] == 'P', "got '%c'\n", pdb->Signature[0]);
+ ok(pdb->Signature[1] == 'E', "got '%c'\n", pdb->Signature[1]);
+ ok(pdb->Signature[2] == 'R', "got '%c'\n", pdb->Signature[2]);
+ ok(pdb->Signature[3] == 'F', "got '%c'\n", pdb->Signature[3]);
+
+ ok(pdb->LittleEndian == 1, "got %u\n", pdb->LittleEndian);
+ ok(pdb->Version == 1, "got %u\n", pdb->Version);
+ ok(pdb->Revision == 1, "got %u\n", pdb->Revision);
+ len = (sizeof(*pdb) + pdb->SystemNameLength + 7) & ~7;
+ ok(pdb->TotalByteLength == len, "got %u vs %u\n", pdb->TotalByteLength, len);
+ ok(pdb->HeaderLength == pdb->TotalByteLength, "got %u\n", pdb->HeaderLength);
+ ok(pdb->NumObjectTypes == 0, "got %u\n", pdb->NumObjectTypes);
+ ok(pdb->DefaultObject != 0, "got %u\n", pdb->DefaultObject);
+ ok(pdb->SystemTime.wYear == st.wYear, "got %u\n", pdb->SystemTime.wYear);
+ ok(pdb->SystemTime.wMonth == st.wMonth, "got %u\n", pdb->SystemTime.wMonth);
+ ok(pdb->SystemTime.wDayOfWeek == st.wDayOfWeek, "got %u\n", pdb->SystemTime.wDayOfWeek);
+ ok(pdb->SystemTime.wDay == st.wDay, "got %u\n", pdb->SystemTime.wDay);
+ if (U(pdb->PerfTime).LowPart != 0x77777777) /* TestBot is broken */
+ cmp_li(&pdb->PerfTime, &counter, freq.QuadPart);
+ if (U(pdb->PerfFreq).LowPart != 0x77777777) /* TestBot is broken */
+ cmp_li(&pdb->PerfFreq, &freq, 0);
+ cmp_li(&pdb->PerfTime100nSec, &ftime, 200000); /* TestBot needs huge slack value */
+ ok(pdb->SystemNameLength == (sysname_len + 1) * sizeof(WCHAR), "expected %u, got %u\n",
+ (sysname_len + 1) * sizeof(WCHAR), pdb->SystemNameLength);
+ ok(pdb->SystemNameOffset == sizeof(*pdb), "got %u\n", pdb->SystemNameOffset);
+ ok(!lstrcmpW(sysname, (LPCWSTR)(pdb + 1)), "%s != %s\n",
+ wine_dbgstr_w(sysname), wine_dbgstr_w((LPCWSTR)(pdb + 1)));
+
+ len = pdb->TotalByteLength - (sizeof(*pdb) + pdb->SystemNameLength);
+ if (len)
+ {
+ BYTE remainder[8], *p;
+
+ memset(remainder, 0x77, sizeof(remainder));
+ p = buf + sizeof(*pdb) + pdb->SystemNameLength;
+ ok(!memcmp(p, remainder, len), "remainder: %02x,%02x...\n", p[0], p[1]);
+ }
+ }
+
+ dwret = RegOpenKeyA(HKEY_PERFORMANCE_DATA, NULL, &hkey);
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+
+ dwret = RegOpenKeyA(HKEY_PERFORMANCE_DATA, "Global", &hkey);
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+
+ dwret = RegOpenKeyExA(HKEY_PERFORMANCE_DATA, "Global", 0, KEY_READ, &hkey);
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+
+ dwret = RegQueryValueA(HKEY_PERFORMANCE_DATA, "Global", NULL, (LONG *)&cbData);
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+
+ dwret = RegSetValueA(HKEY_PERFORMANCE_DATA, "Global", REG_SZ, "dummy", 4);
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+
+ dwret = RegSetValueExA(HKEY_PERFORMANCE_DATA, "Global", 0, REG_SZ, (const BYTE *)"dummy", 40);
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+
+ cbData = sizeof(buf);
+ dwret = RegEnumKeyA(HKEY_PERFORMANCE_DATA, 0, (LPSTR)buf, cbData);
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+
+ cbData = sizeof(buf);
+ dwret = RegEnumValueA(HKEY_PERFORMANCE_DATA, 0, (LPSTR)buf, &cbData, NULL, NULL, NULL, NULL);
+todo_wine
+ ok(dwret == ERROR_MORE_DATA, "got %u\n", dwret);
+todo_wine
+ ok(cbData == sizeof(buf), "got %u\n", cbData);
+
+ dwret = RegEnumValueA(HKEY_PERFORMANCE_DATA, 0, NULL, &cbData, NULL, NULL, NULL, NULL);
+ ok(dwret == ERROR_INVALID_PARAMETER, "got %u\n", dwret);
+
+ if (pRegSetKeyValueW)
+ {
+ dwret = pRegSetKeyValueW(HKEY_PERFORMANCE_DATA, NULL, globalW, REG_SZ, dummyW, sizeof(dummyW));
+todo_wine
+ ok(dwret == ERROR_INVALID_HANDLE, "got %u\n", dwret);
+ }
+
+ dwret = RegCloseKey(HKEY_PERFORMANCE_DATA);
+ ok(dwret == ERROR_SUCCESS, "got %u\n", dwret);
+}
START_TEST(registry)
{
diff --git a/include/winreg.h b/include/winreg.h
index 42b77251ae4..ddbd9293783 100644
--- a/include/winreg.h
+++ b/include/winreg.h
@@ -32,6 +32,8 @@ extern "C" {
#define HKEY_PERFORMANCE_DATA ((HKEY)(LONG_PTR)(LONG)0x80000004)
#define HKEY_CURRENT_CONFIG ((HKEY)(LONG_PTR)(LONG)0x80000005)
#define HKEY_DYN_DATA ((HKEY)(LONG_PTR)(LONG)0x80000006)
+#define HKEY_PERFORMANCE_TEXT ((HKEY)(LONG_PTR)(LONG)0x80000050)
+#define HKEY_PERFORMANCE_NLSTEXT ((HKEY)(LONG_PTR)(LONG)0x80000060)
/*
* registry provider structs
--
2.13.1

139
patches/advapi32-Performance_Counters/0002-include-Add-more-definitions-for-performance-counter.patch
View File

@ -1,139 +0,0 @@
From f72de28ee3a7a3cb25165f0aaee0c7e17eb7e6d7 Mon Sep 17 00:00:00 2001
From: Dmitry Timoshkov <dmitry@baikal.ru>
Date: Wed, 12 Apr 2017 12:48:29 +0800
Subject: include: Add more definitions for performance counters.
---
include/winperf.h | 113 ++++++++++++++++++++++++++++++++++++++++++++++--------
1 file changed, 97 insertions(+), 16 deletions(-)
diff --git a/include/winperf.h b/include/winperf.h
index dce1a6d648d..113bfbae40f 100644
--- a/include/winperf.h
+++ b/include/winperf.h
@@ -67,25 +67,106 @@
#define PERF_DETAIL_EXPERT 300
#define PERF_DETAIL_WIZARD 400
+#include <pshpack8.h>
+
/* Performance data structure header
* returned in answer to HKEY_PERFORMANCE_DATA request
*/
-typedef struct _PERF_DATA_BLOCK {
- WCHAR Signature[4];
- DWORD LittleEndian;
- DWORD Version;
- DWORD Revision;
- DWORD TotalByteLength;
- DWORD HeaderLength;
- DWORD NumObjectTypes;
- DWORD DefaultObject;
- SYSTEMTIME SystemTime;
- LARGE_INTEGER PerfTime;
- LARGE_INTEGER PerfFreq;
- LARGE_INTEGER PerfTime100nSec;
- DWORD SystemNameLength;
- DWORD SystemNameOffset;
-} PERF_DATA_BLOCK, *PPERF_DATA_BLOCK, *LPPERF_DATA_BLOCK;
+#define PERF_DATA_VERSION 1
+#define PERF_DATA_REVISION 1
+
+typedef struct _PERF_DATA_BLOCK
+{
+ WCHAR Signature[4];
+ DWORD LittleEndian;
+ DWORD Version;
+ DWORD Revision;
+ DWORD TotalByteLength;
+ DWORD HeaderLength;
+ DWORD NumObjectTypes;
+ DWORD DefaultObject;
+ SYSTEMTIME SystemTime;
+ LARGE_INTEGER PerfTime;
+ LARGE_INTEGER PerfFreq;
+ LARGE_INTEGER PerfTime100nSec;
+ DWORD SystemNameLength;
+ DWORD SystemNameOffset;
+} PERF_DATA_BLOCK, *PPERF_DATA_BLOCK;
+
+#define PERF_NO_INSTANCES -1
+
+typedef struct _PERF_OBJECT_TYPE
+{
+ DWORD TotalByteLength;
+ DWORD DefinitionLength;
+ DWORD HeaderLength;
+ DWORD ObjectNameTitleIndex;
+#ifdef _WIN64
+ DWORD ObjectNameTitle;
+#else
+ LPWSTR ObjectNameTitle;
+#endif
+ DWORD ObjectHelpTitleIndex;
+#ifdef _WIN64
+ DWORD ObjectHelpTitle;
+#else
+ LPWSTR ObjectHelpTitle;
+#endif
+ DWORD DetailLevel;
+ DWORD NumCounters;
+ LONG DefaultCounter;
+ LONG NumInstances;
+ DWORD CodePage;
+ LARGE_INTEGER PerfTime;
+ LARGE_INTEGER PerfFreq;
+} PERF_OBJECT_TYPE, *PPERF_OBJECT_TYPE;
+
+typedef struct _PERF_COUNTER_DEFINITION
+{
+ DWORD ByteLength;
+ DWORD CounterNameTitleIndex;
+#ifdef _WIN64
+ DWORD CounterNameTitle;
+#else
+ LPWSTR CounterNameTitle;
+#endif
+ DWORD CounterHelpTitleIndex;
+#ifdef _WIN64
+ DWORD CounterHelpTitle;
+#else
+ LPWSTR CounterHelpTitle;
+#endif
+ LONG DefaultScale;
+ DWORD DetailLevel;
+ DWORD CounterType;
+ DWORD CounterSize;
+ DWORD CounterOffset;
+} PERF_COUNTER_DEFINITION, *PPERF_COUNTER_DEFINITION;
+
+#define PERF_NO_UNIQUE_ID -1
+
+typedef struct _PERF_INSTANCE_DEFINITION
+{
+ DWORD ByteLength;
+ DWORD ParentObjectTitleIndex;
+ DWORD ParentObjectInstance;
+ LONG UniqueID;
+ DWORD NameOffset;
+ DWORD NameLength;
+} PERF_INSTANCE_DEFINITION, *PPERF_INSTANCE_DEFINITION;
+
+typedef struct _PERF_COUNTER_BLOCK
+{
+ DWORD ByteLength;
+} PERF_COUNTER_BLOCK, *PPERF_COUNTER_BLOCK;
+
+
+#include <poppack.h>
+
+typedef DWORD (APIENTRY PM_OPEN_PROC)(LPWSTR);
+typedef DWORD (APIENTRY PM_COLLECT_PROC)(LPWSTR,LPVOID *,LPDWORD,LPDWORD);
+typedef DWORD (APIENTRY PM_CLOSE_PROC)(void);
+typedef DWORD (APIENTRY PM_QUERY_PROC)(LPDWORD,LPVOID *,LPDWORD,LPDWORD);
#endif /* _WINPERF_ */
--
2.13.1

53
patches/browseui-Progress_Dialog/0001-browseui-Implement-IProgressDialog-SetAnimation.patch
View File

@ -1,53 +0,0 @@
From fe4f06bfdb1a53e0be15aca8f1f8f897f7fef632 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20M=C3=BCller?= <michael@fds-team.de>
Date: Fri, 27 Feb 2015 17:46:11 +0100
Subject: browseui: Implement IProgressDialog::SetAnimation.
---
dlls/browseui/progressdlg.c | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/dlls/browseui/progressdlg.c b/dlls/browseui/progressdlg.c
index 598197b..a14fa17 100644
--- a/dlls/browseui/progressdlg.c
+++ b/dlls/browseui/progressdlg.c
@@ -175,6 +175,7 @@ static INT_PTR CALLBACK dialog_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM l
case WM_INITDIALOG:
{
struct create_params *params = (struct create_params *)lParam;
+ LONG_PTR style;
/* Note: until we set the hEvent, the object is protected by
* the critical section held by StartProgress */
@@ -191,6 +192,10 @@ static INT_PTR CALLBACK dialog_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM l
if (This->dwFlags & PROGDLG_NOMINIMIZE)
SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) & (~WS_MINIMIZEBOX));
+ style = GetWindowLongPtrW(GetDlgItem(hwnd, IDC_ANIMATION), GWL_STYLE);
+ style |= ACS_AUTOPLAY | ACS_TRANSPARENT;
+ SetWindowLongPtrW(GetDlgItem(hwnd, IDC_ANIMATION), GWL_STYLE, style);
+
update_dialog(This, 0xffffffff);
This->dwUpdate = 0;
This->isCancelled = FALSE;
@@ -396,7 +401,16 @@ static HRESULT WINAPI ProgressDialog_SetTitle(IProgressDialog *iface, LPCWSTR pw
static HRESULT WINAPI ProgressDialog_SetAnimation(IProgressDialog *iface, HINSTANCE hInstance, UINT uiResourceId)
{
- FIXME("(%p, %p, %d) - stub\n", iface, hInstance, uiResourceId);
+ ProgressDialog *This = impl_from_IProgressDialog(iface);
+
+ TRACE("(%p, %p, %d)\n", iface, hInstance, uiResourceId);
+
+ if (uiResourceId & ~0xFFFF)
+ return S_OK;
+
+ if (!SendDlgItemMessageW(This->hwnd, IDC_ANIMATION, ACM_OPENW, (WPARAM)hInstance, uiResourceId))
+ WARN("Failed to load animation\n");
+
return S_OK;
}
--
2.3.0

364
patches/ntdll-RtlIpStringToAddress_Tests/0003-ntdll-tests-Tests-for-RtlIpv4StringToAddressEx-try-5.patch
View File

@ -1,364 +0,0 @@
From 9d8678d25267e66aff7134f064fddb4eac5c5641 Mon Sep 17 00:00:00 2001
From: Mark Jansen <learn0more+wine@gmail.com>
Date: Sun, 8 Mar 2015 18:24:48 +0100
Subject: [PATCH] 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 | 284 ++++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 246 insertions(+), 38 deletions(-)
diff --git a/dlls/ntdll/tests/rtl.c b/dlls/ntdll/tests/rtl.c
index cf14e65..941a92c 100644
--- a/dlls/ntdll/tests/rtl.c
+++ b/dlls/ntdll/tests/rtl.c
@@ -92,6 +92,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);
@@ -159,6 +160,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");
@@ -1157,6 +1159,102 @@ 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;
@@ -1270,65 +1368,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
@@ -3300,6 +3507,7 @@ START_TEST(rtl)
test_RtlIpv4AddressToString();
test_RtlIpv4AddressToStringEx();
test_RtlIpv4StringToAddress();
+ test_RtlIpv4StringToAddressEx();
test_RtlIpv6StringToAddress();
test_RtlIpv6StringToAddressEx();
test_LdrAddRefDll();
--
1.9.1

291
patches/ntdll-RtlIpStringToAddress_Tests/0004-ntdll-tests-Add-tests-for-RtlIpv6AddressToString-and.patch
View File

@ -1,291 +0,0 @@
From 5f505a4a315272fd39a30d73fbfb59526b07be22 Mon Sep 17 00:00:00 2001
From: Mark Jansen <learn0more@gmail.com>
Date: Mon, 6 Apr 2015 00:48:33 +0200
Subject: ntdll/tests: Add tests for RtlIpv6AddressToString and
RtlIpv6AddressToStringEx.
---
dlls/ntdll/tests/rtl.c | 246 +++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 246 insertions(+)
diff --git a/dlls/ntdll/tests/rtl.c b/dlls/ntdll/tests/rtl.c
index b0facba..e443ec2 100644
--- a/dlls/ntdll/tests/rtl.c
+++ b/dlls/ntdll/tests/rtl.c
@@ -94,6 +94,8 @@ 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 CHAR * (WINAPI *pRtlIpv6AddressToStringA)(struct in6_addr *, PSTR);
+static NTSTATUS (WINAPI *pRtlIpv6AddressToStringExA)(struct in6_addr *, ULONG, USHORT, PCHAR, PULONG);
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);
@@ -155,6 +157,8 @@ static void InitFunctionPtrs(void)
pRtlIpv4AddressToStringExA = (void *)GetProcAddress(hntdll, "RtlIpv4AddressToStringExA");
pRtlIpv4StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressA");
pRtlIpv4StringToAddressExA = (void *)GetProcAddress(hntdll, "RtlIpv4StringToAddressExA");
+ pRtlIpv6AddressToStringA = (void *)GetProcAddress(hntdll, "RtlIpv6AddressToStringA");
+ pRtlIpv6AddressToStringExA = (void *)GetProcAddress(hntdll, "RtlIpv6AddressToStringExA");
pRtlIpv6StringToAddressA = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressA");
pRtlIpv6StringToAddressW = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressW");
pRtlIpv6StringToAddressExA = (void *)GetProcAddress(hntdll, "RtlIpv6StringToAddressExA");
@@ -1729,6 +1733,246 @@ static void init_ip6(IN6_ADDR* addr, const int src[8])
}
}
+static void test_RtlIpv6AddressToString(void)
+{
+ CHAR buffer[50];
+ LPCSTR result;
+ IN6_ADDR ip;
+ DWORD_PTR len;
+ struct
+ {
+ PCSTR address;
+ int ip[8];
+ } tests[] =
+ {
+ /* ipv4 addresses & ISATAP addresses */
+ { "::13.1.68.3", { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } },
+ { "::ffff:13.1.68.3", { 0, 0, 0, 0, 0, 0xffff, 0x10d, 0x344 } },
+ { "::feff:d01:4403", { 0, 0, 0, 0, 0, 0xfffe, 0x10d, 0x344 } },
+ { "::fffe:d01:4403", { 0, 0, 0, 0, 0, 0xfeff, 0x10d, 0x344 } },
+ { "::100:d01:4403", { 0, 0, 0, 0, 0, 1, 0x10d, 0x344 } },
+ { "::1:d01:4403", { 0, 0, 0, 0, 0, 0x100, 0x10d, 0x344 } },
+ { "::ffff:0:4403", { 0, 0, 0, 0, 0, 0xffff, 0, 0x344 } },
+ { "::ffff:13.1.0.0", { 0, 0, 0, 0, 0, 0xffff, 0x10d, 0 } },
+ { "::ffff:0:0", { 0, 0, 0, 0, 0, 0xffff, 0, 0 } },
+ { "::ffff:0:13.1.68.3", { 0, 0, 0, 0, 0xffff, 0, 0x10d, 0x344 } },
+ { "::ffff:ffff:d01:4403", { 0, 0, 0, 0, 0xffff, 0xffff, 0x10d, 0x344 } },
+ { "::ffff:0:0:d01:4403", { 0, 0, 0, 0xffff, 0, 0, 0x10d, 0x344 } },
+ { "::ffff:255.255.255.255", { 0, 0, 0, 0, 0, 0xffff, 0xffff, 0xffff } },
+ { "::ffff:129.144.52.38", { 0, 0, 0, 0, 0, 0xffff, 0x9081, 0x2634 } },
+ { "::5efe:129.144.52.38", { 0, 0, 0, 0, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "1111:2222:3333:4444:0:5efe:129.144.52.38", { 0x1111, 0x2222, 0x3333, 0x4444, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "1111:2222:3333::5efe:129.144.52.38", { 0x1111, 0x2222, 0x3333, 0, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "1111:2222::5efe:129.144.52.38", { 0x1111, 0x2222, 0, 0, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "1111::5efe:129.144.52.38", { 0x1111, 0, 0, 0, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "::200:5efe:129.144.52.38", { 0, 0, 0, 0, 2, 0xfe5e, 0x9081, 0x2634 } },
+ { "::100:5efe:8190:3426", { 0, 0, 0, 0, 1, 0xfe5e, 0x9081, 0x2634 } },
+ /* 'normal' addresses */
+ { "::1", { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
+ { "0:1:2:3:4:5:6:7", { 0, 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x700 } },
+ { "1080::8:800:200c:417a", { 0x8010, 0, 0, 0, 0x800, 0x8, 0x0c20, 0x7a41 } },
+ { "1111:2222:3333:4444:5555:6666:7b7b:7b7b", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "1111:2222:3333:4444:5555:6666:7777:8888", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 } },
+ { "1111:2222:3333:4444:5555:6666::", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0, 0 } },
+ { "1111:2222:3333:4444:5555:6666:0:8888", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0, 0x8888 } },
+ { "1111:2222:3333:4444:5555::", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0 } },
+ { "1111:2222:3333:4444:5555:0:7b7b:7b7b", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0x7b7b, 0x7b7b } },
+ { "1111:2222:3333:4444:5555:0:7777:8888", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0x7777, 0x8888 } },
+ { "1111:2222:3333:4444:5555::8888", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0, 0, 0x8888 } },
+ { "1111::", { 0x1111, 0, 0, 0, 0, 0, 0, 0 } },
+ { "1111::7b7b:7b7b", { 0x1111, 0, 0, 0, 0, 0, 0x7b7b, 0x7b7b } },
+ { "1111:0:3333:4444:5555:6666:7b7b:7b7b", { 0x1111, 0, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "1111:0:3333:4444:5555:6666:7777:8888", { 0x1111, 0, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 } },
+ { "1111::4444:5555:6666:7b7b:7b7b", { 0x1111, 0, 0, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "1111::4444:5555:6666:7777:8888", { 0x1111, 0, 0, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 } },
+ { "1111::5555:6666:7b7b:7b7b", { 0x1111, 0, 0, 0, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "1111::5555:6666:7777:8888", { 0x1111, 0, 0, 0, 0x5555, 0x6666, 0x7777, 0x8888 } },
+ { "1111::6666:7b7b:7b7b", { 0x1111, 0, 0, 0, 0, 0x6666, 0x7b7b, 0x7b7b } },
+ { "1111::6666:7777:8888", { 0x1111, 0, 0, 0, 0, 0x6666, 0x7777, 0x8888 } },
+ { "1111::7777:8888", { 0x1111, 0, 0, 0, 0, 0, 0x7777, 0x8888 } },
+ { "1111::8888", { 0x1111, 0, 0, 0, 0, 0, 0, 0x8888 } },
+ { "1:2:3:4:5:6:102:304", { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x201, 0x403 } },
+ { "1:2:3:4:5:6:7:8", { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x700, 0x800 } },
+ { "1:2:3:4:5:6::", { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0, 0 } },
+ { "1:2:3:4:5:6:0:8", { 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0, 0x800 } },
+ { "2001:0:1234::c1c0:abcd:876", { 0x120, 0, 0x3412, 0, 0, 0xc0c1, 0xcdab, 0x7608 } },
+ { "2001:0:4136:e378:8000:63bf:3fff:fdd2", { 0x120, 0, 0x3641, 0x78e3, 0x80, 0xbf63, 0xff3f, 0xd2fd } },
+ { "2001:db8::1428:57ab", { 0x120, 0xb80d, 0, 0, 0, 0, 0x2814, 0xab57 } },
+ { "2001:db8:1234:ffff:ffff:ffff:ffff:ffff", { 0x120, 0xb80d, 0x3412, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff } },
+ { "2001:0:ce49:7601:2cad:dfff:7c94:fffe", { 0x120, 0, 0x49ce, 0x176, 0xad2c, 0xffdf, 0x947c, 0xfeff } },
+ { "2001:db8:85a3::8a2e:370:7334", { 0x120, 0xb80d, 0xa385, 0, 0, 0x2e8a, 0x7003, 0x3473 } },
+ { "3ffe:b00::1:0:0:a", { 0xfe3f, 0xb, 0, 0, 0x100, 0, 0, 0xa00 } },
+ { "::a:b:c:d:e", { 0, 0, 0, 0xa00, 0xb00, 0xc00, 0xd00, 0xe00 } },
+ { "::123.123.123.123", { 0, 0, 0, 0, 0, 0, 0x7b7b, 0x7b7b } },
+ { "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", { 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff } },
+ { "1111:2222:3333:4444:5555:6666:7777:1", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x100 } },
+ { "1111:2222:3333:4444:5555:6666:7777:8888", { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 } },
+ { "1111:2222::", { 0x1111, 0x2222, 0, 0, 0, 0, 0, 0 } },
+ { "1111::3333:4444:5555:6666:7777", { 0x1111, 0, 0, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777 } },
+ { "1111:2222::", { 0x1111, 0x2222, 0, 0, 0, 0, 0, 0 } },
+ { "1111::3333", { 0x1111, 0, 0, 0, 0, 0, 0, 0x3333 } },
+ { "2001:0:1234::c1c0:abcd:876", { 0x120, 0, 0x3412, 0, 0, 0xc0c1, 0xcdab, 0x7608 } },
+ { "2001::ffd3", { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff } },
+ };
+ const size_t testcount = sizeof(tests) / sizeof(tests[0]);
+ unsigned int i;
+
+ if (!pRtlIpv6AddressToStringA)
+ {
+ skip("RtlIpv6AddressToStringA not available\n");
+ return;
+ }
+
+ memset(buffer, '#', sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+ memset(&ip, 0, sizeof(ip));
+ result = pRtlIpv6AddressToStringA(&ip, buffer);
+
+ len = strlen(buffer);
+ ok(result == (buffer + len) && !strcmp(buffer, "::"),
+ "got %p with '%s' (expected %p with '::')\n", result, buffer, buffer + len);
+
+ result = pRtlIpv6AddressToStringA(&ip, NULL);
+ ok(result == (LPCSTR)~0 || broken(result == (LPCSTR)len) /* WinXP / Win2k3 */,
+ "got %p, expected %p\n", result, (LPCSTR)~0);
+
+ for (i = 0; i < testcount; i++)
+ {
+ init_ip6(&ip, tests[i].ip);
+ memset(buffer, '#', sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+
+ result = pRtlIpv6AddressToStringA(&ip, buffer);
+ len = strlen(buffer);
+ ok(result == (buffer + len) && !strcmp(buffer, tests[i].address),
+ "got %p with '%s' (expected %p with '%s')\n", result, buffer, buffer + len, tests[i].address);
+
+ ok(buffer[45] == 0 || broken(buffer[45] != 0) /* WinXP / Win2k3 */,
+ "expected data at buffer[45] to always be NULL\n");
+ ok(buffer[46] == '#', "expected data at buffer[46] not to change\n");
+ }
+}
+
+static void test_RtlIpv6AddressToStringEx(void)
+{
+ CHAR buffer[70];
+ NTSTATUS res;
+ IN6_ADDR ip;
+ ULONG len;
+ struct
+ {
+ PCSTR address;
+ ULONG scopeid;
+ USHORT port;
+ int ip[8];
+ } tests[] =
+ {
+ /* ipv4 addresses & ISATAP addresses */
+ { "::13.1.68.3", 0, 0, { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } },
+ { "::13.1.68.3%1", 1, 0, { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } },
+ { "::13.1.68.3%4294949819", 0xffffbbbb, 0, { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } },
+ { "[::13.1.68.3%4294949819]:65518", 0xffffbbbb, 0xeeff, { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } },
+ { "[::13.1.68.3%4294949819]:256", 0xffffbbbb, 1, { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } },
+ { "[::13.1.68.3]:256", 0, 1, { 0, 0, 0, 0, 0, 0, 0x10d, 0x344 } },
+
+ { "::1:d01:4403", 0, 0, { 0, 0, 0, 0, 0, 0x100, 0x10d, 0x344 } },
+ { "::1:d01:4403%1", 1, 0, { 0, 0, 0, 0, 0, 0x100, 0x10d, 0x344 } },
+ { "::1:d01:4403%4294949819", 0xffffbbbb, 0, { 0, 0, 0, 0, 0, 0x100, 0x10d, 0x344 } },
+ { "[::1:d01:4403%4294949819]:65518", 0xffffbbbb, 0xeeff, { 0, 0, 0, 0, 0, 0x100, 0x10d, 0x344 } },
+ { "[::1:d01:4403%4294949819]:256", 0xffffbbbb, 1, { 0, 0, 0, 0, 0, 0x100, 0x10d, 0x344 } },
+ { "[::1:d01:4403]:256", 0, 1, { 0, 0, 0, 0, 0, 0x100, 0x10d, 0x344 } },
+
+ { "1111:2222:3333:4444:0:5efe:129.144.52.38", 0, 0, { 0x1111, 0x2222, 0x3333, 0x4444, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "1111:2222:3333:4444:0:5efe:129.144.52.38%1", 1, 0, { 0x1111, 0x2222, 0x3333, 0x4444, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "1111:2222:3333:4444:0:5efe:129.144.52.38%4294949819", 0xffffbbbb, 0, { 0x1111, 0x2222, 0x3333, 0x4444, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "[1111:2222:3333:4444:0:5efe:129.144.52.38%4294949819]:65518",0xffffbbbb, 0xeeff, { 0x1111, 0x2222, 0x3333, 0x4444, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "[1111:2222:3333:4444:0:5efe:129.144.52.38%4294949819]:256", 0xffffbbbb, 1, { 0x1111, 0x2222, 0x3333, 0x4444, 0, 0xfe5e, 0x9081, 0x2634 } },
+ { "[1111:2222:3333:4444:0:5efe:129.144.52.38]:256", 0, 1, { 0x1111, 0x2222, 0x3333, 0x4444, 0, 0xfe5e, 0x9081, 0x2634 } },
+
+ { "::1", 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
+ { "::1%1", 1, 0, { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
+ { "::1%4294949819", 0xffffbbbb, 0, { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
+ { "[::1%4294949819]:65518", 0xffffbbbb, 0xeeff, { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
+ { "[::1%4294949819]:256", 0xffffbbbb, 1, { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
+ { "[::1]:256", 0, 1, { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
+
+ { "1111:2222:3333:4444:5555:6666:7b7b:7b7b", 0, 0, { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "1111:2222:3333:4444:5555:6666:7b7b:7b7b%1", 1, 0, { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "1111:2222:3333:4444:5555:6666:7b7b:7b7b%4294949819", 0xffffbbbb, 0, { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "[1111:2222:3333:4444:5555:6666:7b7b:7b7b%4294949819]:65518", 0xffffbbbb, 0xeeff, { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "[1111:2222:3333:4444:5555:6666:7b7b:7b7b%4294949819]:256", 0xffffbbbb, 1, { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+ { "[1111:2222:3333:4444:5555:6666:7b7b:7b7b]:256", 0, 1, { 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7b7b, 0x7b7b } },
+
+ { "1111::", 0, 0, { 0x1111, 0, 0, 0, 0, 0, 0, 0 } },
+ { "1111::%1", 1, 0, { 0x1111, 0, 0, 0, 0, 0, 0, 0 } },
+ { "1111::%4294949819", 0xffffbbbb, 0, { 0x1111, 0, 0, 0, 0, 0, 0, 0 } },
+ { "[1111::%4294949819]:65518", 0xffffbbbb, 0xeeff, { 0x1111, 0, 0, 0, 0, 0, 0, 0 } },
+ { "[1111::%4294949819]:256", 0xffffbbbb, 1, { 0x1111, 0, 0, 0, 0, 0, 0, 0 } },
+ { "[1111::]:256", 0, 1, { 0x1111, 0, 0, 0, 0, 0, 0, 0 } },
+
+ { "2001::ffd3", 0, 0, { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff } },
+ { "2001::ffd3%1", 1, 0, { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff } },
+ { "2001::ffd3%4294949819", 0xffffbbbb, 0, { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff } },
+ { "[2001::ffd3%4294949819]:65518", 0xffffbbbb, 0xeeff, { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff } },
+ { "[2001::ffd3%4294949819]:256", 0xffffbbbb, 1, { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff } },
+ { "[2001::ffd3]:256", 0, 1, { 0x120, 0, 0, 0, 0, 0, 0, 0xd3ff } },
+ };
+ const size_t testcount = sizeof(tests) / sizeof(tests[0]);
+ unsigned int i;
+
+ if (!pRtlIpv6AddressToStringExA)
+ {
+ skip("RtlIpv6AddressToStringExA not available\n");
+ return;
+ }
+
+ memset(buffer, '#', sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+ memset(&ip, 0, sizeof(ip));
+ len = sizeof(buffer);
+ res = pRtlIpv6AddressToStringExA(&ip, 0, 0, buffer, &len);
+
+ ok(res == STATUS_SUCCESS, "[validate] res = 0x%08x, expected STATUS_SUCCESS\n", res);
+ ok(len == 3 && !strcmp(buffer, "::"),
+ "got len %d with '%s' (expected 3 with '::')\n", len, buffer);
+
+ memset(buffer, '#', sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+
+ len = sizeof(buffer);
+ res = pRtlIpv6AddressToStringExA(NULL, 0, 0, buffer, &len);
+ ok(res == STATUS_INVALID_PARAMETER, "[null ip] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res);
+
+ len = sizeof(buffer);
+ res = pRtlIpv6AddressToStringExA(&ip, 0, 0, NULL, &len);
+ ok(res == STATUS_INVALID_PARAMETER, "[null buffer] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res);
+
+ res = pRtlIpv6AddressToStringExA(&ip, 0, 0, buffer, NULL);
+ ok(res == STATUS_INVALID_PARAMETER, "[null length] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res);
+
+ len = 2;
+ memset(buffer, '#', sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+ res = pRtlIpv6AddressToStringExA(&ip, 0, 0, buffer, &len);
+ ok(res == STATUS_INVALID_PARAMETER, "[null length] res = 0x%08x, expected STATUS_INVALID_PARAMETER\n", res);
+ ok(buffer[0] == '#', "got first char %c (expected '#')\n", buffer[0]);
+ ok(len == 3, "got len %d (expected len 3)\n", len);
+
+ for (i = 0; i < testcount; i++)
+ {
+ init_ip6(&ip, tests[i].ip);
+ len = sizeof(buffer);
+ memset(buffer, '#', sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+
+ res = pRtlIpv6AddressToStringExA(&ip, tests[i].scopeid, tests[i].port, buffer, &len);
+
+ ok(res == STATUS_SUCCESS, "[validate] res = 0x%08x, expected STATUS_SUCCESS\n", res);
+ ok(len == (strlen(tests[i].address) + 1) && !strcmp(buffer, tests[i].address),
+ "got len %d with '%s' (expected %d with '%s')\n", len, buffer, (int)strlen(tests[i].address), tests[i].address);
+ }
+}
+
static void compare_RtlIpv6StringToAddressW(PCSTR name_a, int terminator_offset_a,
const struct in6_addr *addr_a, NTSTATUS res_a)
{
@@ -3009,6 +3253,8 @@ START_TEST(rtl)
test_RtlIpv4AddressToStringEx();
test_RtlIpv4StringToAddress();
test_RtlIpv4StringToAddressEx();
+ test_RtlIpv6AddressToString();
+ test_RtlIpv6AddressToStringEx();
test_RtlIpv6StringToAddress();
test_RtlIpv6StringToAddressEx();
test_LdrAddRefDll();
--
2.7.1

1
patches/ntdll-RtlIpStringToAddress_Tests/definition
View File

@ -1 +0,0 @@
Depends: ntdll-RtlQueryPackageIdentity

38
patches/patchinstall.sh
View File

@ -52,7 +52,7 @@ usage()
# Get the upstream commit sha
upstream_commit()
{
echo "3d5d8903b89803f5b2ec12a2d20ae9a171047fdc"
echo "acb879c9d2feae69e8b5b1ede28523a29aef1b89"
}
# Show version information
@ -234,7 +234,6 @@ patch_enable_all ()
enable_ntdll_Purist_Mode="$1"
enable_ntdll_RtlCaptureStackBackTrace="$1"
enable_ntdll_RtlGetUnloadEventTraceEx="$1"
enable_ntdll_RtlIpStringToAddress_Tests="$1"
enable_ntdll_RtlQueryPackageIdentity="$1"
enable_ntdll_Serial_Port_Detection="$1"
enable_ntdll_Signal_Handler="$1"
@ -878,9 +877,6 @@ patch_enable ()
ntdll-RtlGetUnloadEventTraceEx)
enable_ntdll_RtlGetUnloadEventTraceEx="$2"
;;
ntdll-RtlIpStringToAddress_Tests)
enable_ntdll_RtlIpStringToAddress_Tests="$2"
;;
ntdll-RtlQueryPackageIdentity)
enable_ntdll_RtlQueryPackageIdentity="$2"
;;
@ -2080,13 +2076,6 @@ if test "$enable_ntdll_WRITECOPY" -eq 1; then
enable_ntdll_User_Shared_Data=1
fi
if test "$enable_ntdll_RtlIpStringToAddress_Tests" -eq 1; then
if test "$enable_ntdll_RtlQueryPackageIdentity" -gt 1; then
abort "Patchset ntdll-RtlQueryPackageIdentity disabled, but ntdll-RtlIpStringToAddress_Tests depends on that."
fi
enable_ntdll_RtlQueryPackageIdentity=1
fi
if test "$enable_ntdll_RtlGetUnloadEventTraceEx" -eq 1; then
if test "$enable_ntdll_RtlQueryPackageIdentity" -gt 1; then
abort "Patchset ntdll-RtlQueryPackageIdentity disabled, but ntdll-RtlGetUnloadEventTraceEx depends on that."
@ -2512,19 +2501,15 @@ fi
# |
# | Modified files:
# | * dlls/advapi32/registry.c, dlls/advapi32/tests/registry.c, dlls/winspool.drv/info.c, dlls/winspool.drv/winspool.drv.spec,
# | include/winperf.h, include/winreg.h, loader/wine.inf.in
# | loader/wine.inf.in
# |
if test "$enable_advapi32_Performance_Counters" -eq 1; then
patch_apply advapi32-Performance_Counters/0001-advapi32-tests-Add-more-tests-for-performance-counte.patch
patch_apply advapi32-Performance_Counters/0002-include-Add-more-definitions-for-performance-counter.patch
patch_apply advapi32-Performance_Counters/0003-advapi32-Add-initial-support-for-querying-performanc.patch
patch_apply advapi32-Performance_Counters/0004-winspool.drv-Add-performance-counters-service-stubs.patch
patch_apply advapi32-Performance_Counters/0005-advapi32-Performance-providers-Open-expects-to-see-t.patch
patch_apply advapi32-Performance_Counters/0006-advapi32-If-the-query-is-not-specified-the-default-q.patch
patch_apply advapi32-Performance_Counters/0007-advapi32-Read-the-configured-object-list-for-the-per.patch
(
printf '%s\n' '+ { "Dmitry Timoshkov", "advapi32/tests: Add more tests for performance counters.", 1 },';
printf '%s\n' '+ { "Dmitry Timoshkov", "include: Add more definitions for performance counters.", 1 },';
printf '%s\n' '+ { "Dmitry Timoshkov", "advapi32: Add initial support for querying performance counters data.", 2 },';
printf '%s\n' '+ { "Dmitry Timoshkov", "winspool.drv: Add performance counters service stubs.", 1 },';
printf '%s\n' '+ { "Dmitry Timoshkov", "advapi32: Performance providers'\'' Open() expects to see the configured name as its parameter.", 1 },';
@ -2747,10 +2732,8 @@ fi
# | * dlls/browseui/browseui.rc, dlls/browseui/progressdlg.c, dlls/browseui/resids.h
# |
if test "$enable_browseui_Progress_Dialog" -eq 1; then
patch_apply browseui-Progress_Dialog/0001-browseui-Implement-IProgressDialog-SetAnimation.patch
patch_apply browseui-Progress_Dialog/0002-browseui-Implement-PROGDLG_AUTOTIME-flag-for-IProgre.patch
(
printf '%s\n' '+ { "Michael Müller", "browseui: Implement IProgressDialog::SetAnimation.", 1 },';
printf '%s\n' '+ { "Michael Müller", "browseui: Implement PROGDLG_AUTOTIME flag for IProgressDialog.", 1 },';
) >> "$patchlist"
fi
@ -5278,23 +5261,6 @@ if test "$enable_ntdll_RtlGetUnloadEventTraceEx" -eq 1; then
) >> "$patchlist"
fi
# Patchset ntdll-RtlIpStringToAddress_Tests
# |
# | This patchset has the following (direct or indirect) dependencies:
# | * ntdll-RtlQueryPackageIdentity
# |
# | Modified files:
# | * dlls/ntdll/tests/rtl.c
# |
if test "$enable_ntdll_RtlIpStringToAddress_Tests" -eq 1; then
patch_apply ntdll-RtlIpStringToAddress_Tests/0003-ntdll-tests-Tests-for-RtlIpv4StringToAddressEx-try-5.patch
patch_apply ntdll-RtlIpStringToAddress_Tests/0004-ntdll-tests-Add-tests-for-RtlIpv6AddressToString-and.patch
(
printf '%s\n' '+ { "Mark Jansen", "ntdll/tests: Tests for RtlIpv4StringToAddressEx (try 5, resend).", 1 },';
printf '%s\n' '+ { "Mark Jansen", "ntdll/tests: Add tests for RtlIpv6AddressToString and RtlIpv6AddressToStringEx.", 1 },';
) >> "$patchlist"
fi
# Patchset ntdll-Serial_Port_Detection
# |
# | This patchset fixes the following Wine bugs:

30
patches/user32-Mouse_Message_Hwnd/0005-server-Add-support-for-a-layered-window-region.-v2.patch
View File

@ -1,4 +1,4 @@
From 584864e30e0ef73e0196fa3b2f43735d597578a5 Mon Sep 17 00:00:00 2001
From 8d68c50ae8593769c5f5281b4895fae0b467a890 Mon Sep 17 00:00:00 2001
From: Dmitry Timoshkov <dmitry@baikal.ru>
Date: Wed, 17 May 2017 23:55:55 +0800
Subject: [PATCH] server: Add support for a layered window region. (v3)
@ -11,10 +11,10 @@ Subject: [PATCH] server: Add support for a layered window region. (v3)
4 files changed, 84 insertions(+), 2 deletions(-)
diff --git a/dlls/user32/tests/input.c b/dlls/user32/tests/input.c
index 4a2d9c92a5..fa249c5f90 100644
index 858e7d6..5fa15af 100644
--- a/dlls/user32/tests/input.c
+++ b/dlls/user32/tests/input.c
@@ -2393,13 +2393,11 @@ static void test_Input_mouse(void)
@@ -2388,13 +2388,11 @@ static void test_Input_mouse(void)
if (msg.message == WM_LBUTTONDOWN)
{
@ -29,7 +29,7 @@ index 4a2d9c92a5..fa249c5f90 100644
got_button_up = TRUE;
break;
diff --git a/dlls/winex11.drv/bitblt.c b/dlls/winex11.drv/bitblt.c
index 165633c64e..c5a3ed338d 100644
index 0343d96..b07c9be 100644
--- a/dlls/winex11.drv/bitblt.c
+++ b/dlls/winex11.drv/bitblt.c
@@ -48,6 +48,7 @@
@ -106,10 +106,10 @@ index 165633c64e..c5a3ed338d 100644
#endif
}
diff --git a/server/protocol.def b/server/protocol.def
index 37c3f43921..e7c2b1091b 100644
index b87c69e..506d2e2 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -2754,6 +2754,13 @@ enum coords_relative
@@ -2762,6 +2762,13 @@ enum coords_relative
@END
@ -124,18 +124,18 @@ index 37c3f43921..e7c2b1091b 100644
@REQ(get_update_region)
user_handle_t window; /* handle to the window */
diff --git a/server/window.c b/server/window.c
index 2f2aae483d..f66f1d6ac6 100644
index e58d7e4..682c7db 100644
--- a/server/window.c
+++ b/server/window.c
@@ -72,6 +72,7 @@ struct window
rectangle_t visible_rect; /* visible part of window rect (relative to parent client area) */
@@ -73,6 +73,7 @@ struct window
rectangle_t surface_rect; /* window surface rectangle (relative to parent client area) */
rectangle_t client_rect; /* client rectangle (relative to parent client area) */
struct region *win_region; /* region for shaped windows (relative to window rect) */
+ struct region *layer_region; /* region for layered windows (relative to window rect) */
struct region *update_region; /* update region (relative to window rect) */
unsigned int style; /* window style */
unsigned int ex_style; /* window extended style */
@@ -477,6 +478,7 @@ static struct window *create_window( struct window *parent, struct window *owner
@@ -494,6 +495,7 @@ static struct window *create_window( struct window *parent, struct window *owner
win->atom = atom;
win->last_active = win->handle;
win->win_region = NULL;
@ -143,7 +143,7 @@ index 2f2aae483d..f66f1d6ac6 100644
win->update_region = NULL;
win->style = 0;
win->ex_style = 0;
@@ -653,6 +655,9 @@ static inline int is_point_in_window( struct window *win, int x, int y )
@@ -671,6 +673,9 @@ static inline int is_point_in_window( struct window *win, int x, int y )
if (win->win_region &&
!point_in_region( win->win_region, x - win->window_rect.left, y - win->window_rect.top ))
return 0; /* not in window region */
@ -153,7 +153,7 @@ index 2f2aae483d..f66f1d6ac6 100644
return 1;
}
@@ -1825,6 +1830,14 @@ static void set_window_region( struct window *win, struct region *region, int re
@@ -1820,6 +1825,14 @@ static void set_window_region( struct window *win, struct region *region, int re
}
@ -168,7 +168,7 @@ index 2f2aae483d..f66f1d6ac6 100644
/* destroy a window */
void destroy_window( struct window *win )
{
@@ -1873,6 +1886,7 @@ void destroy_window( struct window *win )
@@ -1868,6 +1881,7 @@ void destroy_window( struct window *win )
detach_window_thread( win );
if (win->win_region) free_region( win->win_region );
@ -176,7 +176,7 @@ index 2f2aae483d..f66f1d6ac6 100644
if (win->update_region) free_region( win->update_region );
if (win->class) release_class( win->class );
free( win->text );
@@ -2538,6 +2552,24 @@ DECL_HANDLER(set_window_region)
@@ -2527,6 +2541,24 @@ DECL_HANDLER(set_window_region)
}
@ -202,5 +202,5 @@ index 2f2aae483d..f66f1d6ac6 100644
DECL_HANDLER(get_update_region)
{
--
2.16.2
1.9.1