ReactOS  0.4.14-dev-583-g2a1ba2c
versionlie.c
Go to the documentation of this file.
1 /*
2  * PROJECT: appshim_apitest
3  * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4  * PURPOSE: Tests for versionlie shims
5  * COPYRIGHT: Copyright 2015-2018 Mark Jansen (mark.jansen@reactos.org)
6  */
7 
8 #include <ntstatus.h>
9 #define WIN32_NO_STATUS
10 #include <windows.h>
11 #ifdef __REACTOS__
12 #include <ntndk.h>
13 #else
14 #include <winternl.h>
15 #endif
16 #include "wine/test.h"
17 #include <strsafe.h>
18 
19 #include "appshim_apitest.h"
20 
22 
23 
25 
26 #define FLAG_BUGGY_ServicePackMajorMinor 1
27 #define FLAG_AlternateHookOrder 2
28 
29 typedef struct VersionLieInfo
30 {
40 
44 
45 void expect_shim_imp(PHOOKAPI hook, PCSTR library, PCSTR function, PCSTR shim, int* same)
46 {
47  int lib = lstrcmpA(library, hook->LibraryName);
48  int fn = lstrcmpA(function, hook->FunctionName);
49  winetest_ok(lib == 0, "Expected LibrarayName to be %s, was: %s for %s\n", library, hook->LibraryName, shim);
50  winetest_ok(fn == 0, "Expected FunctionName to be %s, was: %s for %s\n", function, hook->FunctionName, shim);
51  *same = (lib == 0 && fn == 0);
52 }
53 
54 static void verify_shima_imp(PHOOKAPI hook, const VersionLieInfo* info, PCSTR shim, int same)
55 {
56  OSVERSIONINFOEXA v1 = { sizeof(v1), 0 }, v2 = { sizeof(v2), 0 };
57  BOOL ok1, ok2;
58 
59  if (!same)
60  {
61  skip("Skipping implementation tests for %s\n", shim);
62  return;
63  }
64 
65  while (v1.dwOSVersionInfoSize)
66  {
68  hook->OriginalFunction = GetVersionExA;
69 
70  ok2 = ((GETVERSIONEXAPROC)hook->ReplacementFunction)(&v2);
71 
72  winetest_ok(ok1 == ok2, "Expected ok1 to equal ok2, was: %i, %i for %s\n", ok1, ok2, shim);
73  if (ok1 && ok2)
74  {
75  char szCSDVersion[128] = "";
76  winetest_ok(v1.dwOSVersionInfoSize == v2.dwOSVersionInfoSize, "Expected dwOSVersionInfoSize to be equal, was: %u, %u for %s\n", v1.dwOSVersionInfoSize, v2.dwOSVersionInfoSize, shim);
77  winetest_ok(info->dwMajorVersion == v2.dwMajorVersion, "Expected dwMajorVersion to be equal, was: %u, %u for %s\n", info->dwMajorVersion, v2.dwMajorVersion, shim);
78  winetest_ok(info->dwMinorVersion == v2.dwMinorVersion, "Expected dwMinorVersion to be equal, was: %u, %u for %s\n", info->dwMinorVersion, v2.dwMinorVersion, shim);
79  winetest_ok(info->dwBuildNumber == v2.dwBuildNumber, "Expected dwBuildNumber to be equal, was: %u, %u for %s\n", info->dwBuildNumber, v2.dwBuildNumber, shim);
80  winetest_ok(info->dwPlatformId == v2.dwPlatformId, "Expected dwPlatformId to be equal, was: %u, %u for %s\n", info->dwPlatformId, v2.dwPlatformId, shim);
81 
82  if (info->wServicePackMajor)
83  StringCchPrintfA(szCSDVersion, _countof(szCSDVersion), "Service Pack %u", info->wServicePackMajor);
84  winetest_ok(lstrcmpA(szCSDVersion, v2.szCSDVersion) == 0, "Expected szCSDVersion to be equal, was: %s, %s for %s\n", szCSDVersion, v2.szCSDVersion, shim);
85 
86  if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXA))
87  {
88  if (!(info->wFlags & FLAG_BUGGY_ServicePackMajorMinor))
89  {
90  winetest_ok(info->wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", info->wServicePackMajor, v2.wServicePackMajor, shim);
91  winetest_ok(info->wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", info->wServicePackMinor, v2.wServicePackMinor, shim);
92  }
93  else
94  {
95  winetest_ok(v1.wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
96  winetest_ok(v1.wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
97  }
98  winetest_ok(v1.wSuiteMask == v2.wSuiteMask, "Expected wSuiteMask to be equal, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
99  winetest_ok(v1.wProductType == v2.wProductType, "Expected wProductType to be equal, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
100  winetest_ok(v1.wReserved == v2.wReserved, "Expected wReserved to be equal, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
101  }
102  else
103  {
104  winetest_ok(v1.wServicePackMajor == 0 && v2.wServicePackMajor == 0, "Expected wServicePackMajor to be 0, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
105  winetest_ok(v1.wServicePackMinor == 0 && v2.wServicePackMinor == 0, "Expected wServicePackMinor to be 0, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
106  winetest_ok(v1.wSuiteMask == 0 && v2.wSuiteMask == 0, "Expected wSuiteMask to be 0, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
107  winetest_ok(v1.wProductType == 0 && v2.wProductType == 0, "Expected wProductType to be 0, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
108  winetest_ok(v1.wReserved == 0 && v2.wReserved == 0, "Expected wReserved to be 0, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
109  }
110  }
111 
112  ZeroMemory(&v1, sizeof(v1));
113  ZeroMemory(&v2, sizeof(v2));
114  if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXA))
115  v1.dwOSVersionInfoSize = v2.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
116  }
117 }
118 
119 static void verify_shimw_imp(PHOOKAPI hook, const VersionLieInfo* info, PCSTR shim, int same, int first_might_be_broken)
120 {
121  OSVERSIONINFOEXW v1 = { sizeof(v1), 0 }, v2 = { sizeof(v2), 0 };
122  BOOL ok1, ok2, first = TRUE;
123 
124  if (!same)
125  {
126  skip("Skipping implementation tests for %s\n", shim);
127  return;
128  }
129 
130  while (v1.dwOSVersionInfoSize)
131  {
133  hook->OriginalFunction = GetVersionExW;
134 
135  ok2 = ((GETVERSIONEXWPROC)hook->ReplacementFunction)(&v2);
136 
137  if (first_might_be_broken && first && ok1 == TRUE && ok2 == FALSE)
138  {
139  skip("Skipping first check because 0x%x is (falsely) not accepted by the shim %s\n", sizeof(v1), shim);
140  }
141  else
142  {
143  winetest_ok(ok1 == ok2, "Expected ok1 to equal ok2, was: %i, %i for %s(first:%d)\n", ok1, ok2, shim, first);
144  }
145  if (ok1 && ok2)
146  {
147  WCHAR szCSDVersion[128] = { 0 };
148  winetest_ok(v1.dwOSVersionInfoSize == v2.dwOSVersionInfoSize, "Expected dwOSVersionInfoSize to be equal, was: %u, %u for %s\n", v1.dwOSVersionInfoSize, v2.dwOSVersionInfoSize, shim);
149  winetest_ok(info->dwMajorVersion == v2.dwMajorVersion, "Expected dwMajorVersion to be equal, was: %u, %u for %s\n", info->dwMajorVersion, v2.dwMajorVersion, shim);
150  winetest_ok(info->dwMinorVersion == v2.dwMinorVersion, "Expected dwMinorVersion to be equal, was: %u, %u for %s\n", info->dwMinorVersion, v2.dwMinorVersion, shim);
151  winetest_ok(info->dwBuildNumber == v2.dwBuildNumber, "Expected dwBuildNumber to be equal, was: %u, %u for %s\n", info->dwBuildNumber, v2.dwBuildNumber, shim);
152  winetest_ok(info->dwPlatformId == v2.dwPlatformId, "Expected dwPlatformId to be equal, was: %u, %u for %s\n", info->dwPlatformId, v2.dwPlatformId, shim);
153 
154  if (info->wServicePackMajor)
155  StringCchPrintfW(szCSDVersion, _countof(szCSDVersion), L"Service Pack %u", info->wServicePackMajor);
156  winetest_ok(lstrcmpW(szCSDVersion, v2.szCSDVersion) == 0, "Expected szCSDVersion to be equal, was: %s, %s for %s\n", wine_dbgstr_w(szCSDVersion), wine_dbgstr_w(v2.szCSDVersion), shim);
157 
158  if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXW))
159  {
160  if (!(info->wFlags & FLAG_BUGGY_ServicePackMajorMinor))
161  {
162  winetest_ok(info->wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", info->wServicePackMajor, v2.wServicePackMajor, shim);
163  winetest_ok(info->wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", info->wServicePackMinor, v2.wServicePackMinor, shim);
164  }
165  else
166  {
167  winetest_ok(v1.wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
168  winetest_ok(v1.wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
169  }
170  winetest_ok(v1.wSuiteMask == v2.wSuiteMask, "Expected wSuiteMask to be equal, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
171  winetest_ok(v1.wProductType == v2.wProductType, "Expected wProductType to be equal, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
172  winetest_ok(v1.wReserved == v2.wReserved, "Expected wReserved to be equal, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
173  }
174  else
175  {
176  winetest_ok(v1.wServicePackMajor == 0 && v2.wServicePackMajor == 0, "Expected wServicePackMajor to be 0, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
177  winetest_ok(v1.wServicePackMinor == 0 && v2.wServicePackMinor == 0, "Expected wServicePackMinor to be 0, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
178  winetest_ok(v1.wSuiteMask == 0 && v2.wSuiteMask == 0, "Expected wSuiteMask to be 0, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
179  winetest_ok(v1.wProductType == 0 && v2.wProductType == 0, "Expected wProductType to be 0, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
180  winetest_ok(v1.wReserved == 0 && v2.wReserved == 0, "Expected wReserved to be 0, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
181  }
182  }
183 
184  ZeroMemory(&v1, sizeof(v1));
185  ZeroMemory(&v2, sizeof(v2));
186  if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXW))
187  v1.dwOSVersionInfoSize = v2.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
188  first = FALSE;
189  }
190 }
191 
192 static void verify_shim_imp(PHOOKAPI hook, const VersionLieInfo* info, PCSTR shim, int same)
193 {
194  DWORD ver;
195  if (!same)
196  {
197  skip("Skipping implementation tests for %s\n", shim);
198  return;
199  }
200  ver = ((GETVERSIONPROC)hook->ReplacementFunction)();
201  winetest_ok(info->FullVersion == ver, "Expected GetVersion to return 0x%x, was: 0x%x for %s\n", info->FullVersion, ver, shim);
202 }
203 
204 
205 #define verify_shima (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : verify_shima_imp
206 #define verify_shimw (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : verify_shimw_imp
207 #define verify_shim (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : verify_shim_imp
208 
209 
210 
211 
212 static void run_test(LPCSTR shim, const VersionLieInfo* info)
213 {
214  DWORD num_shims = 0;
215  WCHAR wide_shim[50] = { 0 };
216  PHOOKAPI hook;
217  DWORD ver;
218  MultiByteToWideChar(CP_ACP, 0, shim, -1, wide_shim, 50);
219  hook = pGetHookAPIs("", wide_shim, &num_shims);
220  ver = (info->dwMajorVersion << 8) | info->dwMinorVersion;
221  if (hook == NULL)
222  {
223  skip("Skipping tests for layers (%s) not present in this os (0x%x)\n", shim, g_WinVersion);
224  return;
225  }
226  ok(hook != NULL, "Expected hook to be a valid pointer for %s\n", shim);
227  if (info->wFlags & FLAG_AlternateHookOrder)
228  {
229  ok(num_shims == 3, "Expected num_shims to be 3, was: %u for %s\n", num_shims, shim);
230  if (hook && num_shims == 3)
231  {
232  int same = 0;
233  expect_shim(hook + 0, "KERNEL32.DLL", "GetVersion", shim, &same);
234  verify_shim(hook + 0, info, shim, same);
235  expect_shim(hook + 1, "KERNEL32.DLL", "GetVersionExA", shim, &same);
236  verify_shima(hook + 1, info, shim, same);
237  expect_shim(hook + 2, "KERNEL32.DLL", "GetVersionExW", shim, &same);
238  verify_shimw(hook + 2, info, shim, same, 0);
239  }
240  }
241  else
242  {
243  int shimnum_ok = num_shims == 4 || ((ver < _WIN32_WINNT_WINXP) && (num_shims == 3));
244  ok(shimnum_ok, "Expected num_shims to be 4%s, was: %u for %s\n", ((ver < _WIN32_WINNT_WINXP) ? " or 3":""), num_shims, shim);
245  if (hook && shimnum_ok)
246  {
247  int same = 0;
248  expect_shim(hook + 0, "KERNEL32.DLL", "GetVersionExA", shim, &same);
249  verify_shima(hook + 0, info, shim, same);
250  expect_shim(hook + 1, "KERNEL32.DLL", "GetVersionExW", shim, &same);
251  verify_shimw(hook + 1, info, shim, same, 0);
252  expect_shim(hook + 2, "KERNEL32.DLL", "GetVersion", shim, &same);
253  verify_shim(hook + 2, info, shim, same);
254  if (num_shims == 4)
255  {
256  expect_shim(hook + 3, "NTDLL.DLL", "RtlGetVersion", shim, &same);
257  verify_shimw(hook + 3, info, shim, same, 1);
258  }
259  }
260  }
261 }
262 
263 
267 
268 VersionLieInfo g_Win2000 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 0, 0 };
269 VersionLieInfo g_Win2000SP1 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 1, 0 };
270 VersionLieInfo g_Win2000SP2 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 2, 0 };
271 VersionLieInfo g_Win2000SP3 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 3, 0 };
272 
273 VersionLieInfo g_WinXP = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 0, 0 };
274 VersionLieInfo g_WinXPSP1 = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 1, 0 };
275 VersionLieInfo g_WinXPSP2 = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 2, 0 };
276 VersionLieInfo g_WinXPSP3 = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 3, 0 };
277 
278 VersionLieInfo g_Win2k3RTM = { 0x0ece0205, 5, 2, 3790, VER_PLATFORM_WIN32_NT, 0, 0 };
279 VersionLieInfo g_Win2k3SP1 = { 0x0ece0205, 5, 2, 3790, VER_PLATFORM_WIN32_NT, 1, 0 };
280 
281 VersionLieInfo g_WinVistaRTM = { 0x17700006, 6, 0, 6000, VER_PLATFORM_WIN32_NT, 0, 0 };
282 VersionLieInfo g_WinVistaSP1 = { 0x17710006, 6, 0, 6001, VER_PLATFORM_WIN32_NT, 1, 0 };
283 VersionLieInfo g_WinVistaSP2 = { 0x17720006, 6, 0, 6002, VER_PLATFORM_WIN32_NT, 2, 0 };
284 
285 VersionLieInfo g_Win7RTM = { 0x1db00106, 6, 1, 7600, VER_PLATFORM_WIN32_NT, 0, 0 };
286 VersionLieInfo g_Win7SP1 = { 0x1db10106, 6, 1, 7601, VER_PLATFORM_WIN32_NT, 1, 0 }; /* ReactOS specific. Windows does not have this version lie */
287 
288 VersionLieInfo g_Win8RTM = { 0x23f00206, 6, 2, 9200, VER_PLATFORM_WIN32_NT, 0, 0 };
289 VersionLieInfo g_Win81RTM = { 0x25800306, 6, 3, 9600, VER_PLATFORM_WIN32_NT, 0, 0 };
290 
291 
293 {
294  RTL_OSVERSIONINFOEXW rtlinfo = {0};
295  void (__stdcall* pRtlGetVersion)(RTL_OSVERSIONINFOEXW*);
296  pRtlGetVersion = (void (__stdcall*)(RTL_OSVERSIONINFOEXW*))GetProcAddress(GetModuleHandleA("ntdll"), "RtlGetVersion");
297 
298  rtlinfo.dwOSVersionInfoSize = sizeof(rtlinfo);
299  pRtlGetVersion(&rtlinfo);
300  return (rtlinfo.dwMajorVersion << 8) | rtlinfo.dwMinorVersion;
301 }
302 
303 BOOL LoadShimDLL(PCWSTR ShimDll, HMODULE* module, tGETHOOKAPIS* ppGetHookAPIs)
304 {
305  static tSDBGETAPPPATCHDIR pSdbGetAppPatchDir = NULL;
306  HMODULE dll;
307  WCHAR buf[MAX_PATH] = {0};
308  if (!pSdbGetAppPatchDir)
309  {
310  dll = LoadLibraryA("apphelp.dll");
311  pSdbGetAppPatchDir = (tSDBGETAPPPATCHDIR)GetProcAddress(dll, "SdbGetAppPatchDir");
312 
313  if (!pSdbGetAppPatchDir)
314  {
315  skip("Unable to retrieve SdbGetAppPatchDir (%p, %p)\n", dll, pSdbGetAppPatchDir);
316  }
317  }
318 
319  if (!pSdbGetAppPatchDir || !SUCCEEDED(pSdbGetAppPatchDir(NULL, buf, MAX_PATH)))
320  {
321  skip("Unable to retrieve AppPatch dir, building manually\n");
323  {
324  skip("Unable to build AppPatch name(1)\n");
325  return FALSE;
326  }
327  if (!SUCCEEDED(StringCchCatW(buf, _countof(buf), L"\\AppPatch")))
328  {
329  skip("Unable to build AppPatch name(2)\n");
330  return FALSE;
331  }
332  }
333  if (!SUCCEEDED(StringCchCatW(buf, _countof(buf), L"\\")) ||
334  !SUCCEEDED(StringCchCatW(buf, _countof(buf), ShimDll)))
335  {
336  skip("Unable to append dll name\n");
337  return FALSE;
338  }
339 
340  dll = LoadLibraryW(buf);
341  if (!dll)
342  {
343  skip("Unable to load shim dll from AppPatch\n");
345 
346  if (SUCCEEDED(StringCchCatW(buf, _countof(buf), L"\\System32\\")) &&
347  SUCCEEDED(StringCchCatW(buf, _countof(buf), ShimDll)))
348  {
349  dll = LoadLibraryW(buf);
350  }
351 
352  if (!dll)
353  {
354  skip("Unable to load shim dll from System32 (Recent Win10)\n");
355  return FALSE;
356  }
357  }
358  *module = dll;
359  *ppGetHookAPIs = (tGETHOOKAPIS)GetProcAddress(dll, "GetHookAPIs");
360 
361  return *ppGetHookAPIs != NULL;
362 }
363 
364 
366 {
367  HMODULE module;
369 
370  if (LoadShimDLL(ShimDll, &module, &pGetHookAPIs))
371  {
372  if (!pGetHookAPIs)
373  skip("No GetHookAPIs found\n");
374  return pGetHookAPIs;
375  }
376  return NULL;
377 }
378 
379 
380 START_TEST(versionlie)
381 {
382  pGetHookAPIs = LoadShimDLL2(L"aclayers.dll");
383 
384  if (!pGetHookAPIs)
385  return;
386 
388 
389  run_test("Win95VersionLie", &g_Win95);
390  run_test("WinNT4SP5VersionLie", &g_WinNT4SP5);
391  run_test("Win98VersionLie", &g_Win98);
392  run_test("Win2000VersionLie", &g_Win2000);
393  run_test("Win2000SP1VersionLie", &g_Win2000SP1);
394  run_test("Win2000SP2VersionLie", &g_Win2000SP2);
395  run_test("Win2000SP3VersionLie", &g_Win2000SP3);
396  run_test("WinXPVersionLie", &g_WinXP);
397  run_test("WinXPSP1VersionLie", &g_WinXPSP1);
398  run_test("WinXPSP2VersionLie", &g_WinXPSP2);
399  run_test("WinXPSP3VersionLie", &g_WinXPSP3);
400  run_test("Win2k3RTMVersionLie", &g_Win2k3RTM);
401  run_test("Win2k3SP1VersionLie", &g_Win2k3SP1);
402  run_test("VistaRTMVersionLie", &g_WinVistaRTM);
403  run_test("VistaSP1VersionLie", &g_WinVistaSP1);
404  run_test("VistaSP2VersionLie", &g_WinVistaSP2);
405  run_test("Win7RTMVersionLie", &g_Win7RTM);
406  run_test("Win7SP1VersionLie", &g_Win7SP1); /* ReactOS specific. Windows does not have this version lie */
407  run_test("Win8RTMVersionLie", &g_Win8RTM);
408  run_test("Win81RTMVersionLie", &g_Win81RTM);
409 }
ULONG dwOSVersionInfoSize
Definition: rtltypes.h:265
const uint16_t * PCWSTR
Definition: typedefs.h:55
UINT WINAPI GetSystemWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2396
#define VER_PLATFORM_WIN32_NT
Definition: rtltypes.h:236
VersionLieInfo g_WinXPSP2
Definition: versionlie.c:39
#define TRUE
Definition: types.h:120
VersionLieInfo g_WinVistaSP1
Definition: versionlie.c:46
HMODULE module
Definition: main.cpp:47
DWORD dwMajorVersion
Definition: versionlie.c:32
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
tGETHOOKAPIS LoadShimDLL2(PCWSTR ShimDll)
Definition: versionlie.c:365
static void run_test(LPCSTR shim, const VersionLieInfo *info)
Definition: versionlie.c:212
VersionLieInfo g_Win98
Definition: versionlie.c:30
BOOL(WINAPI * GETVERSIONEXAPROC)(LPOSVERSIONINFOEXA)
Definition: versionlie.c:92
#define _WIN32_WINNT_WINXP
Definition: sdkddkver.h:22
ULONG dwMinorVersion
Definition: rtltypes.h:267
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
#define CP_ACP
Definition: compat.h:99
#define _countof(array)
Definition: fontsub.cpp:30
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
#define verify_shimw
Definition: versionlie.c:206
const GLint * first
Definition: glext.h:5794
static void verify_shim_imp(PHOOKAPI hook, const VersionLieInfo *info, PCSTR shim, int same)
Definition: versionlie.c:192
VersionLieInfo g_Win95
Definition: versionlie.c:28
VersionLieInfo g_WinVistaRTM
Definition: versionlie.c:45
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18
#define ZeroMemory
Definition: winbase.h:1642
VersionLieInfo g_Win7RTM
Definition: versionlie.c:49
VersionLieInfo g_WinNT4SP5
Definition: versionlie.c:29
BOOL WINAPI GetVersionExW(IN LPOSVERSIONINFOW lpVersionInformation)
Definition: version.c:37
FT_Library library
Definition: cffdrivr.c:654
#define BOOL
Definition: nt_native.h:43
#define DWORD
Definition: nt_native.h:44
VersionLieInfo g_Win2000SP1
Definition: versionlie.c:33
STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:325
ULONG dwMajorVersion
Definition: rtltypes.h:266
DWORD dwMinorVersion
Definition: versionlie.c:33
static HMODULE dll
Definition: str.c:188
struct _OSVERSIONINFOEXW * LPOSVERSIONINFOEXW
DWORD FullVersion
Definition: versionlie.c:17
unsigned int BOOL
Definition: ntddk_ex.h:94
HRESULT(WINAPI * tSDBGETAPPPATCHDIR)(PVOID hsdb, LPWSTR path, DWORD size)
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
WORD wServicePackMinor
Definition: versionlie.c:23
WORD wServicePackMajor
Definition: versionlie.c:22
STRSAFEAPI StringCchPrintfA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszFormat,...)
Definition: strsafe.h:520
VersionLieInfo g_Win2k3RTM
Definition: versionlie.c:42
#define LoadLibraryW(x)
Definition: compat.h:412
smooth NULL
Definition: ftsmooth.c:416
VersionLieInfo g_Win2000SP2
Definition: versionlie.c:34
DWORD(WINAPI * GETVERSIONPROC)(void)
Definition: versionlie.c:43
const char * LPCSTR
Definition: xmlstorage.h:183
BOOL WINAPI GetVersionExA(IN LPOSVERSIONINFOA lpVersionInformation)
Definition: version.c:69
#define verify_shima
Definition: versionlie.c:205
struct VersionLieInfo VersionLieInfo
VersionLieInfo g_Win7SP1
Definition: versionlie.c:50
Definition: msg.h:42
#define FLAG_BUGGY_ServicePackMajorMinor
Definition: versionlie.c:26
PHOOKAPI(WINAPI * tGETHOOKAPIS)(LPCSTR szCommandLine, LPCWSTR wszShimName, PDWORD pdwHookCount)
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:6
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL(WINAPI * GETVERSIONEXWPROC)(LPOSVERSIONINFOEXW)
Definition: versionlie.c:42
#define __stdcall
Definition: typedefs.h:25
struct _OSVERSIONINFOW OSVERSIONINFOW
#define verify_shim
Definition: versionlie.c:207
static const WCHAR L[]
Definition: oid.c:1250
void expect_shim_imp(PHOOKAPI hook, PCSTR library, PCSTR function, PCSTR shim, int *same)
Definition: versionlie.c:45
DWORD get_host_winver(void)
Definition: versionlie.c:292
VersionLieInfo g_WinXP
Definition: versionlie.c:37
static tGETHOOKAPIS pGetHookAPIs
Definition: versionlie.c:21
#define expect_shim
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:821
DWORD dwBuildNumber
Definition: versionlie.c:20
VersionLieInfo g_Win8RTM
Definition: versionlie.c:52
VersionLieInfo g_Win2000SP3
Definition: versionlie.c:35
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
static void verify_shimw_imp(PHOOKAPI hook, const VersionLieInfo *info, PCSTR shim, int same, int first_might_be_broken)
Definition: versionlie.c:119
struct _OSVERSIONINFOEXA * LPOSVERSIONINFOEXA
struct _OSVERSIONINFOA OSVERSIONINFOA
#define ok(value,...)
Definition: atltest.h:57
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530
VersionLieInfo g_Win81RTM
Definition: versionlie.c:53
#define MultiByteToWideChar
Definition: compat.h:100
#define VER_PLATFORM_WIN32_WINDOWS
Definition: rtltypes.h:235
#define skip(...)
Definition: atltest.h:64
static DWORD g_WinVersion
Definition: versionlie.c:24
BOOL LoadShimDLL(PCWSTR ShimDll, HMODULE *module, tGETHOOKAPIS *ppGetHookAPIs)
Definition: versionlie.c:303
VersionLieInfo g_WinVistaSP2
Definition: versionlie.c:47
#define ok2(expression, text, expected, got)
#define GetProcAddress(x, y)
Definition: compat.h:418
const char * PCSTR
Definition: typedefs.h:51
VersionLieInfo g_WinXPSP3
Definition: versionlie.c:40
DWORD dwPlatformId
Definition: versionlie.c:35
START_TEST(versionlie)
Definition: versionlie.c:380
VersionLieInfo g_WinXPSP1
Definition: versionlie.c:38
GLfloat GLfloat v1
Definition: glext.h:6062
VersionLieInfo g_Win2k3SP1
Definition: versionlie.c:43
#define FLAG_AlternateHookOrder
Definition: versionlie.c:27
static void verify_shima_imp(PHOOKAPI hook, const VersionLieInfo *info, PCSTR shim, int same)
Definition: versionlie.c:54
#define SUCCEEDED(hr)
Definition: intsafe.h:57
VersionLieInfo g_Win2000
Definition: versionlie.c:32