ReactOS 0.4.15-dev-8138-g1e75ea8
layerapi.c
Go to the documentation of this file.
1/*
2 * PROJECT: apphelp_apitest
3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4 * PURPOSE: Tests for (registry)layer manipulation api's
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#include <shlwapi.h>
12#include <winnt.h>
13#ifdef __REACTOS__
14#include <ntndk.h>
15#else
16#include <winternl.h>
17#endif
18#include <winerror.h>
19#include <stdio.h>
20#include <strsafe.h>
21
22#include "wine/test.h"
23#include "apitest_iathook.h"
24#include "apphelp_apitest.h"
25
26#define GPLK_USER 1
27#define GPLK_MACHINE 2
28#define MAX_LAYER_LENGTH 256
29#define LAYER_APPLY_TO_SYSTEM_EXES 1
30
31
33static BOOL(WINAPI *pAllowPermLayer)(PCWSTR path);
34static BOOL(WINAPI *pSdbSetPermLayerKeys)(PCWSTR wszPath, PCWSTR wszLayers, BOOL bMachine);
35static BOOL(WINAPI *pSdbGetPermLayerKeys)(PCWSTR wszPath, PWSTR pwszLayers, PDWORD pdwBytes, DWORD dwFlags);
36static BOOL(WINAPI *pSetPermLayerState)(PCWSTR wszPath, PCWSTR wszLayer, DWORD dwFlags, BOOL bMachine, BOOL bEnable);
37
38
39/* Helper function to disable Wow64 redirection on an os that reports it being enabled. */
40static DWORD g_QueryFlag = 0xffffffff;
41static DWORD QueryFlag(void)
42{
43 if (g_QueryFlag == 0xffffffff)
44 {
45 ULONG_PTR wow64_ptr = 0;
47 g_QueryFlag = (NT_SUCCESS(status) && wow64_ptr != 0) ? KEY_WOW64_64KEY : 0;
48 }
49 return g_QueryFlag;
50}
51
52/* Helper function to prepare the registry key with a value. */
53static BOOL setLayerValue(BOOL bMachine, const char* valueName, const char* value)
54{
55 HKEY key = NULL;
57 "Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers", 0, NULL, 0, QueryFlag() | KEY_SET_VALUE, NULL, &key, NULL);
58 if (lstatus == ERROR_SUCCESS)
59 {
60 if (value)
61 lstatus = RegSetValueExA(key, valueName, 0, REG_SZ, (const BYTE*)value, (DWORD)strlen(value)+1);
62 else
63 {
64 lstatus = RegDeleteValueA(key, valueName);
65 lstatus = (lstatus == ERROR_FILE_NOT_FOUND ? ERROR_SUCCESS : lstatus);
66 }
68 }
69 return lstatus == ERROR_SUCCESS;
70}
71
72
73static void expect_LayerValue_imp(BOOL bMachine, const char* valueName, const char* value)
74{
75 HKEY key = NULL;
77 "Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers", 0, NULL, 0, QueryFlag() | KEY_QUERY_VALUE, NULL, &key, NULL);
78 winetest_ok(lstatus == ERROR_SUCCESS, "Expected to be able to open a registry key\n");
79 if (lstatus == ERROR_SUCCESS)
80 {
81 char data[512] = { 0 };
82 DWORD dwType = 0;
83 DWORD dwDataLen = sizeof(data);
84 lstatus = RegQueryValueExA(key, valueName, NULL, &dwType, (LPBYTE)data, &dwDataLen);
85 if (value)
86 {
87 winetest_ok(lstatus == ERROR_SUCCESS, "Expected to get a valid value, err: %u\n", lstatus);
88 if (lstatus == ERROR_SUCCESS)
89 {
90 winetest_ok(dwType == REG_SZ, "Expected the type to be REG_SZ, was: %u\n", dwType);
91 winetest_ok(!strcmp(data, value), "Expected the data to be: '%s', was: '%s'\n", value, data);
92 }
93 }
94 else
95 {
96 winetest_ok(lstatus == ERROR_FILE_NOT_FOUND, "Expected not to find the value %s\n", valueName);
97 }
99 }
100}
101
102static void expect_LayerValue_imp2(BOOL bMachine, const char* valueName, const char* value, int use_alt, const char* alt_value)
103{
104 expect_LayerValue_imp(bMachine, valueName, use_alt ? alt_value : value);
105}
106
107
108void expect_Sdb_imp(PCSTR path, DWORD type, BOOL result, DWORD lenResult, PCSTR stringResult)
109{
110 WCHAR pathW[MAX_PATH], buffer[MAX_LAYER_LENGTH] = { 0 };
111 char resultBuffer[MAX_LAYER_LENGTH] = { 0 };
112 DWORD dwBufSize = sizeof(buffer);
113
114 /* In case of a failure, the buffer size is sometimes set to 0, and sometimes not touched,
115 depending on the version. Either case is fine, since the function returns FALSE anyway. */
116
117 MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, MAX_PATH);
118
119 winetest_ok(pSdbGetPermLayerKeys(pathW, buffer, &dwBufSize, type) == result, "Expected pSdbGetPermLayerKeys to %s\n", (result ? "succeed" : "fail"));
120 if (!result && lenResult == 0xffffffff)
121 winetest_ok(dwBufSize == 0 || dwBufSize == sizeof(buffer), "Expected dwBufSize to be 0 or %u, was %u\n", sizeof(buffer), dwBufSize);
122 else
123 winetest_ok(dwBufSize == lenResult ||
124 /* W2k3 is off by 2 when concatenating user / machine */
125 broken(g_WinVersion < WINVER_VISTA && type == (GPLK_MACHINE|GPLK_USER) && (lenResult + 2) == dwBufSize),
126 "Expected dwBufSize to be %u, was %u\n", lenResult, dwBufSize);
127 if (result)
128 {
129 winetest_ok(lstrlenW(buffer) * sizeof(WCHAR) + sizeof(WCHAR) == lenResult, "Expected lstrlenW(buffer)*2+2 to be %u, was %u\n",
130 lenResult, lstrlenW(buffer) * sizeof(WCHAR) + sizeof(WCHAR));
131 }
132 WideCharToMultiByte(CP_ACP, 0, buffer, -1, resultBuffer, sizeof(resultBuffer), NULL, NULL);
133 winetest_ok(!strcmp(stringResult, resultBuffer), "Expected the result to be '%s', was '%s'\n", stringResult, resultBuffer);
134
135 if (result)
136 {
137 UNICODE_STRING pathNT;
138
139 if (RtlDosPathNameToNtPathName_U(pathW, &pathNT, NULL, NULL))
140 {
141 memset(buffer, 0, sizeof(buffer));
142 dwBufSize = sizeof(buffer);
143 winetest_ok(pSdbGetPermLayerKeys(pathNT.Buffer, buffer, &dwBufSize, type) == FALSE, "Expected pSdbGetPermLayerKeys to fail for NT path\n");
144
145 RtlFreeUnicodeString(&pathNT);
146 }
147 }
148
149}
150
151
152/* In case of a failure, let the location be from where the function was invoked, not inside the function itself. */
153#define expect_Sdb (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_Sdb_imp
154#define expect_LayerValue (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_LayerValue_imp
155#define expect_LayerValue2 (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_LayerValue_imp2
156
157
159{
160 WCHAR buf[100];
161 MultiByteToWideChar(CP_ACP, 0, str, -1, buf, 100);
162 return pAllowPermLayer(buf);
163}
164
165/* Brute forcing all ascii chars in the first 2 places seems to indicate that all it cares for is:
166 - Second char has to be a ':'
167 if it's not a ':', display a diagnostic message (and a different one for '\\').
168 - First char does not really matter, as long as it's not on a DRIVE_REMOTE (but, according to the logging this is meant to check for a CDROM drive...)
169*/
170static void test_AllowPermLayer(void)
171{
172 char buf[20];
173 char drive_letter;
174 UINT drivetype = 0;
175 ok(pAllowPermLayer(NULL) == FALSE, "Expected AllowPermLayer to fail for NULL\n");
177 {
178 ok(wrapAllowPermLayer("-:"), "Expected AllowPermLayer to succeed\n");
179 ok(wrapAllowPermLayer("@:"), "Expected AllowPermLayer to succeed\n");
180 ok(wrapAllowPermLayer("4:"), "Expected AllowPermLayer to succeed\n");
181 ok(wrapAllowPermLayer("*:"), "Expected AllowPermLayer to succeed\n");
182 }
183 ok(wrapAllowPermLayer("*a") == FALSE, "Expected AllowPermLayer to fail\n");
184 ok(wrapAllowPermLayer("*\\") == FALSE, "Expected AllowPermLayer to fail\n");
185 for (drive_letter = 'a'; drive_letter <= 'z'; ++drive_letter)
186 {
187 sprintf(buf, "%c:\\", drive_letter);
188 drivetype = GetDriveTypeA(buf);
189 ok(wrapAllowPermLayer(buf) == (drivetype != DRIVE_REMOTE), "Expected AllowPermLayer to be %d for %c:\\\n", (drivetype != DRIVE_REMOTE), drive_letter);
190 }
191}
192
194{
197 return pSdbSetPermLayerKeys(wszPath, wszLayers, bMachine);
198}
199
201{
202 WCHAR fileW[MAX_PATH+20];
203 WCHAR emptyString[1] = { 0 };
204
206
207 /* Test some parameter validation. */
208 ok(pSdbSetPermLayerKeys(NULL, NULL, bMachine) == FALSE, "Expected SdbSetPermLayerKeys to fail\n");
209 ok(pSdbSetPermLayerKeys(NULL, emptyString, bMachine) == FALSE, "Expected SdbSetPermLayerKeys to fail\n");
210 ok(pSdbSetPermLayerKeys(emptyString, emptyString, bMachine) == FALSE, "Expected SdbSetPermLayerKeys to fail\n");
211 ok(pSdbSetPermLayerKeys(fileW, NULL, bMachine) == TRUE, "Expected SdbSetPermLayerKeys to succeed\n");
212 ok(pSdbSetPermLayerKeys(fileW, emptyString, bMachine) == TRUE, "Expected SdbSetPermLayerKeys to fail\n");
213
214 /* Basic tests */
215 ok(wrapSdbSetPermLayerKeys(fileW, "TEST1", bMachine), "Expected SdbSetPermLayerKeys to succeed\n");
217
218 ok(wrapSdbSetPermLayerKeys(fileW, "TEST1 TEST2", bMachine), "Expected SdbSetPermLayerKeys to succeed\n");
219 expect_LayerValue(bMachine, file, "TEST1 TEST2");
220
221 /* SdbSetPermLayerKeys does not do any validation of the value passed in. */
222 ok(wrapSdbSetPermLayerKeys(fileW, "!#$% TEST1 TEST2", bMachine), "Expected SdbSetPermLayerKeys to succeed\n");
223 expect_LayerValue(bMachine, file, "!#$% TEST1 TEST2");
224
225 ok(wrapSdbSetPermLayerKeys(fileW, "!#$% TEST1 TEST2", bMachine), "Expected SdbSetPermLayerKeys to succeed\n");
226 expect_LayerValue(bMachine, file, "!#$% TEST1 TEST2");
227
228 ok(pSdbSetPermLayerKeys(fileW, NULL, bMachine) == TRUE, "Expected SdbSetPermLayerKeys to succeed\n");
230
231 ok(wrapSdbSetPermLayerKeys(fileW, " ", bMachine), "Expected SdbSetPermLayerKeys to succeed\n");
233
234 ok(pSdbSetPermLayerKeys(fileW, NULL, bMachine) == TRUE, "Expected SdbSetPermLayerKeys to fail\n");
236}
237
239{
240 WCHAR pathW[MAX_PATH], buffer[MAX_LAYER_LENGTH] = { 0 };
241 char file[MAX_PATH + 20], tmp[MAX_PATH + 20];
242 BOOL bUser, bMachine;
243 HANDLE hfile;
244 DWORD dwBufSize = sizeof(buffer);
245
247 GetLongPathNameA(tmp, file, sizeof(file));
248 PathCombineA(tmp, file, "notexist.exe");
249 PathAppendA(file, "test_file.exe");
250
251 /* Check that we can access the keys */
252 bUser = setLayerValue(FALSE, file, "RUNASADMIN WINXPSP3");
253 expect_LayerValue(FALSE, file, "RUNASADMIN WINXPSP3");
254 ok(bUser, "Expected to be able to set atleast the flags for the user\n");
255 if (!bUser)
256 {
257 skip("Cannot do any tests if I cannot set some values\n");
258 return;
259 }
260 bMachine = setLayerValue(TRUE, file, "WINXPSP3 WINXPSP2");
261 if (bMachine)
262 {
263 expect_LayerValue(TRUE, file, "WINXPSP3 WINXPSP2");
264 }
265
266
268 ok(hfile != INVALID_HANDLE_VALUE, "CreateFile failed on '%s'..\n", file);
269 if (hfile == INVALID_HANDLE_VALUE)
270 {
271 skip("Running these tests is useless without a file present\n");
272 return;
273 }
274 CloseHandle(hfile);
275
276 MultiByteToWideChar(CP_ACP, 0, file, -1, pathW, MAX_PATH);
277
278 /* Parameter validation */
279 ok(pSdbGetPermLayerKeys(NULL, NULL, NULL, 0) == FALSE, "Expected pSdbGetPermLayerKeys to fail\n");
280 ok(pSdbGetPermLayerKeys(pathW, NULL, NULL, 0) == FALSE, "Expected pSdbGetPermLayerKeys to fail\n");
281 ok(pSdbGetPermLayerKeys(pathW, buffer, NULL, 0) == FALSE, "Expected pSdbGetPermLayerKeys to fail\n");
282 ok(pSdbGetPermLayerKeys(pathW, buffer, &dwBufSize, 0) == FALSE, "Expected pSdbGetPermLayerKeys to fail\n");
283 ok(dwBufSize == 0, "Expected dwBufSize to be %u, was %u\n", 0, dwBufSize);
284
285 /* It fails on a nonexisting file */
286 expect_Sdb(tmp, GPLK_USER | GPLK_MACHINE, FALSE, 0xffffffff, "");
287 expect_Sdb(file, GPLK_USER, TRUE, 40, "RUNASADMIN WINXPSP3");
288 GetShortPathNameA(file, tmp, sizeof(tmp));
289 expect_Sdb(tmp, GPLK_USER, TRUE, 40, "RUNASADMIN WINXPSP3");
290
291 if (bMachine)
292 {
293 /* Query from HKLM */
294 expect_Sdb(file, GPLK_MACHINE, TRUE, 36, "WINXPSP3 WINXPSP2");
295 /* Query from both, showing that duplicates are not removed */
296 expect_Sdb(file, GPLK_USER | GPLK_MACHINE, TRUE, 76, "WINXPSP3 WINXPSP2 RUNASADMIN WINXPSP3");
297
298 /* Showing that no validation is done on the value read. */
299 ok(setLayerValue(TRUE, file, "!#!# WINXPSP3 WINXPSP3 !# WINXPSP2 "), "Expected setLayerValue not to fail\n");
300 expect_Sdb(file, GPLK_MACHINE, TRUE, 82, "!#!# WINXPSP3 WINXPSP3 !# WINXPSP2 ");
301 /* Showing that a space is inserted, even if the last char was already a space. */
302 expect_Sdb(file, GPLK_USER | GPLK_MACHINE, TRUE, 122, "!#!# WINXPSP3 WINXPSP3 !# WINXPSP2 RUNASADMIN WINXPSP3");
303 /* Now clear the user key */
305 /* Request both, to show that the last space (from the key) is not cut off. */
306 expect_Sdb(file, GPLK_USER | GPLK_MACHINE, TRUE, 82, "!#!# WINXPSP3 WINXPSP3 !# WINXPSP2 ");
307 setLayerValue(FALSE, file, "RUNASADMIN WINXPSP3");
308 }
309 else
310 {
311 skip("Skipping tests for HKLM, cannot alter the registry\n");
312 }
313 /* Fail from these paths */
314 StringCbPrintfA(tmp, sizeof(tmp), "\\?\\%s", file);
315 expect_Sdb(tmp, GPLK_USER, FALSE, 0xffffffff, "");
316 StringCbPrintfA(tmp, sizeof(tmp), "\\??\\%s", file);
317 expect_Sdb(tmp, GPLK_USER, FALSE, 0xffffffff, "");
318
319 ok(setLayerValue(FALSE, file, "!#!# RUNASADMIN RUNASADMIN !# WINXPSP3 "), "Expected setLayerValue not to fail\n");
320 /* There is no validation on information read back. */
321 expect_Sdb(file, GPLK_USER, TRUE, 90, "!#!# RUNASADMIN RUNASADMIN !# WINXPSP3 ");
322
323
324 /* Cleanup */
325 ok(DeleteFileA(file), "DeleteFile failed....\n");
328}
329
330
332{
335 return pSetPermLayerState(wszPath, wszLayer, dwFlags, bMachine, bEnable);
336}
337
339{
340 WCHAR fileW[MAX_PATH+20];
341 WCHAR emptyString[1] = { 0 };
342 DWORD dwFlag;
343
345
346 /* Test some parameter validation. */
347 ok(pSetPermLayerState(fileW, NULL, 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
349
350 ok(pSetPermLayerState(fileW, NULL, 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
352
353 ok(wrapSetPermLayerState(fileW, "", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
355
356 ok(wrapSetPermLayerState(fileW, "", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
358
359 ok(wrapSetPermLayerState(NULL, NULL, 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
361
362 ok(wrapSetPermLayerState(NULL, NULL, 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
364
365 ok(wrapSetPermLayerState(emptyString, "", 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
367
368 ok(wrapSetPermLayerState(emptyString, "", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
370
371 ok(wrapSetPermLayerState(emptyString, "TEST", 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
373
375 {
376 ok(wrapSetPermLayerState(emptyString, "TEST", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
378 }
379
380
381 /* Now, on to the actual tests. */
383 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
385
386 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
388
389 ok(wrapSetPermLayerState(fileW, "", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
391
392 ok(wrapSetPermLayerState(fileW, "test", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
394
395 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
397
398 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
400
401 ok(wrapSetPermLayerState(fileW, "TEST1", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
402 expect_LayerValue2(bMachine, file, "TEST TEST1", g_WinVersion >= WINVER_WIN8, "TEST1 TEST");
403
404 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
405 expect_LayerValue2(bMachine, file, "TEST TEST1 TEST2", g_WinVersion >= WINVER_WIN8, "TEST2 TEST1 TEST");
406
407 ok(wrapSetPermLayerState(fileW, "TEST1", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
408 expect_LayerValue2(bMachine, file, "TEST TEST2", g_WinVersion >= WINVER_WIN8, "TEST2 TEST");
409
410 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
412
413 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
415
416 /* Valid flags until win8: !# */
417 /* Key is empty, now play around with the flags. */
418 for (dwFlag = ((g_WinVersion >= WINVER_WIN8) ? 6 : 2); dwFlag < 32; ++dwFlag)
419 {
420 ok(wrapSetPermLayerState(fileW, "TEST", (1<<dwFlag), bMachine, 1) == FALSE, "Expected SetPermLayerState to fail on 0x%x\n", (1<<dwFlag));
421 }
423
424 /* Add layer flags */
425 ok(wrapSetPermLayerState(fileW, "TEST", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
426 expect_LayerValue(bMachine, file, "# TEST");
427
428 ok(wrapSetPermLayerState(fileW, "TEST2", 2, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
429 expect_LayerValue2(bMachine, file, "!# TEST TEST2", g_WinVersion >= WINVER_WIN8, "!# TEST2 TEST");
430
431 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
432 expect_LayerValue2(bMachine, file, "!# TEST2 TEST", g_WinVersion >= WINVER_WIN8, "!# TEST TEST2");
433
434 ok(wrapSetPermLayerState(fileW, "TEST3", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
435 expect_LayerValue2(bMachine, file, "!# TEST2 TEST TEST3", g_WinVersion >= WINVER_WIN8, "!# TEST3 TEST TEST2");
436
437 /* Remove on a flag removes that flag from the start. */
438 ok(wrapSetPermLayerState(fileW, "TEST2", 2, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
439 expect_LayerValue2(bMachine, file, "# TEST TEST3", g_WinVersion >= WINVER_WIN8, "# TEST3 TEST");
440
441 ok(wrapSetPermLayerState(fileW, "", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
442 expect_LayerValue2(bMachine, file, "TEST TEST3", g_WinVersion >= WINVER_WIN8, "TEST3 TEST");
443
444 ok(wrapSetPermLayerState(fileW, "", LAYER_APPLY_TO_SYSTEM_EXES | 2, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
445 expect_LayerValue2(bMachine, file, "!# TEST TEST3", g_WinVersion >= WINVER_WIN8, "!# TEST3 TEST");
446
447 ok(wrapSetPermLayerState(fileW, "TEST3", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
448 expect_LayerValue(bMachine, file, "! TEST");
449
450 ok(wrapSetPermLayerState(fileW, "TEST", 2, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
452
453 /* Try adding multiple layers: */
454 ok(wrapSetPermLayerState(fileW, "TEST TEST2", LAYER_APPLY_TO_SYSTEM_EXES | 2, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
456
457 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
459
460 /* Try adding flags in via layer string */
461 ok(wrapSetPermLayerState(fileW, "#", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
463
464 ok(wrapSetPermLayerState(fileW, "!", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
466
467 /* Now we prepare the registry with some crap to see how data is validated. */
468 setLayerValue(bMachine, file, "!#!# TEST2 TEST2 !# TEST ");
469
470 ok(wrapSetPermLayerState(fileW, "TEST1", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
471 expect_LayerValue2(bMachine, file, "!# TEST2 TEST2 !# TEST TEST1", g_WinVersion >= WINVER_WIN8, "!# TEST1 TEST2 TEST2 !# TEST");
472
473 /* Removing a duplicate entry will remove all instances of it */
474 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
475 expect_LayerValue2(bMachine, file, "!# !# TEST TEST1", g_WinVersion >= WINVER_WIN8, "!# TEST1 !# TEST");
476
477 /* Adding a flag cleans other flags (from the start) */
478 ok(wrapSetPermLayerState(fileW, "", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
479 expect_LayerValue2(bMachine, file, "!# TEST TEST1", g_WinVersion >= WINVER_WIN8, "!# TEST1 !# TEST");
480
482 {
483 ok(wrapSetPermLayerState(fileW, "$%$%^^", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
484 expect_LayerValue(bMachine, file, "!# TEST TEST1 $%$%^^");
485 }
486
487 setLayerValue(bMachine, file, "!#!# TEST2 !# TEST ");
488 ok(wrapSetPermLayerState(fileW, "", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
489 expect_LayerValue(bMachine, file, "! TEST2 !# TEST");
490
491 /* Tabs are treated as spaces */
492 setLayerValue(bMachine, file, "!#!# TEST2 \t TEST2 !# \t TEST ");
493 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
494 expect_LayerValue2(bMachine, file, "!# !# TEST TEST2", g_WinVersion >= WINVER_WIN8, "!# TEST2 !# TEST");
495
496 /* Newlines are left as-is */
497 setLayerValue(bMachine, file, "!#!# TEST2 \n TEST2 !# \r\n TEST ");
498 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
499 expect_LayerValue2(bMachine, file, "!# \n !# \r\n TEST TEST2", g_WinVersion >= WINVER_WIN8, "!# TEST2 \n !# \r\n TEST");
500
501 /* Whitespace and duplicate flags are eaten from the start */
502 setLayerValue(bMachine, file, " !#!# TEST2 \t TEST2 !# \t TEST ");
503 ok(wrapSetPermLayerState(fileW, "", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
504 expect_LayerValue(bMachine, file, "! TEST2 TEST2 !# TEST");
505
506 setLayerValue(bMachine, file, "!# !# TEST2 !# TEST ");
507 ok(wrapSetPermLayerState(fileW, "", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
508 expect_LayerValue(bMachine, file, "! TEST2 !# TEST");
509
510 ok(wrapSetPermLayerState(fileW, "", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
511 expect_LayerValue(bMachine, file, "! TEST2 !# TEST");
512
513 ok(wrapSetPermLayerState(fileW, "", 2, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
514 expect_LayerValue(bMachine, file, "TEST2 !# TEST");
515
516 /* First flags are cleaned, then a layer is removed. */
517 ok(wrapSetPermLayerState(fileW, "TEST2", 2, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
518 expect_LayerValue(bMachine, file, "!# TEST");
519
520 /* Nothing is changed, still it succeeds. */
521 ok(wrapSetPermLayerState(fileW, "TEST2", 2, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
522 expect_LayerValue(bMachine, file, "# TEST");
523
524 /* And remove the last bits. */
525 ok(wrapSetPermLayerState(fileW, "TEST", LAYER_APPLY_TO_SYSTEM_EXES, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
527}
528
529static void test_SetPermLayer(void)
530{
531 char file[MAX_PATH + 20], tmp[MAX_PATH + 20];
532 HANDLE hfile;
533
535 GetLongPathNameA(tmp, file, sizeof(file));
536 PathAppendA(file, "test_file.exe");
537
539 ok(hfile != INVALID_HANDLE_VALUE, "CreateFile failed for '%s'\n", file);
540 if (hfile == INVALID_HANDLE_VALUE)
541 {
542 skip("Running these tests is useless without a file present\n");
543 return;
544 }
545 CloseHandle(hfile);
546
548 {
551 }
552 else
553 {
554 skip("Skipping SetPermLayerStateLevel tests for User, because I cannot prepare the environment\n");
555 }
557 {
560 }
561 else
562 {
563 skip("Skipping SetPermLayerStateLevel tests for Machine (HKLM), because I cannot prepare the environment\n");
564 }
565 ok(DeleteFileA(file), "DeleteFile failed....\n");
566}
567
569{
570 char target[MAX_PATH], *tmp;
571 HANDLE file;
572
573 tmp = malloc(size);
574 if (tmp == NULL)
575 {
577 return FALSE;
578 }
579
581
584 {
585 free(tmp);
586 return FALSE;
587 }
588
589 memset(tmp, filler, size);
590 WriteFile(file, tmp, size, &size, NULL);
591
593 free(tmp);
594 return TRUE;
595}
596
598{
599 char target[MAX_PATH];
601 return DeleteFileA(target);
602}
603
604static char g_FakeDrive = 0;
605
606UINT (WINAPI *pGetDriveTypeW)(LPCWSTR target) = NULL;
608{
609 UINT uRet = pGetDriveTypeW(target);
610 if(g_FakeDrive && target && (char)*target == g_FakeDrive)
611 return DRIVE_CDROM;
612 return uRet;
613}
614
616{
617 char szPath[MAX_PATH];
621 MultiByteToWideChar(CP_ACP, 0, szPath, -1, wszPath, MAX_PATH);
622 return pSdbSetPermLayerKeys(wszPath, wszLayers, bMachine);
623}
624
625
626BOOL expect_files(const char* dir, int num, ...)
627{
628 char finddir[MAX_PATH + 20];
630 WIN32_FIND_DATAA find = { 0 };
631 HANDLE hFind;
632 int cmp = 0;
633
634 va_start(args, num);
635
636 PathCombineA(finddir, dir, "*");
637 hFind = FindFirstFileA(finddir, &find);
638 if (hFind != INVALID_HANDLE_VALUE)
639 {
640 const char* file;
641 do
642 {
643 if (!(find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
644 {
645 if (--num < 0)
646 break;
647 file = va_arg(args, const char*);
648 cmp = strcmp(file, find.cFileName);
649 }
650 } while (cmp == 0 && FindNextFileA(hFind, &find));
651 FindClose(hFind);
652 }
653 va_end(args);
654 return cmp == 0 && num == 0;
655}
656
657
658static void test_Sign_Media(void)
659{
660 char workdir[MAX_PATH], subdir[MAX_PATH], drive[5] = "Z:";
661 BOOL ret;
662
663 DWORD logical_drives = GetLogicalDrives();
664 g_FakeDrive = 0;
665 for (drive[0] = 'D'; drive[0] <= 'Z'; drive[0]++)
666 {
667 DWORD idx = 1 << (drive[0] - 'D' + 3);
668 if (!(logical_drives & idx))
669 {
670 g_FakeDrive = drive[0];
671 break;
672 }
673 }
674 if (!g_FakeDrive)
675 {
676 skip("Unable to find a free drive\n");
677 return;
678 }
679
681 ok(ret, "GetTempPathA error: %d\n", GetLastError());
682 PathAppendA(workdir, "apphelp_test");
683
685 ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
686
687 PathCombineA(subdir, workdir, "sub");
688 ret = CreateDirectoryA(subdir, NULL);
689 ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
690
692 ok(ret, "DefineDosDeviceA error: %d\n", GetLastError());
693 if(ret)
694 {
695 ret = RedirectIat(GetModuleHandleA("apphelp.dll"), "kernel32.dll", "GetDriveTypeW",
696 (ULONG_PTR)mGetDriveTypeW, (ULONG_PTR*)&pGetDriveTypeW);
698 ok(ret, "Expected redirect_iat to succeed\n");
699 if(ret)
700 {
701 ret = create_file(workdir, "test.exe", 'a', 4);
702 ok(ret, "create_file error: %d\n", GetLastError());
703
704 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
705 /* 4 */
706 /* test.exe */
707 expect_LayerValue(0, "SIGN.MEDIA=4 test.exe", "TEST");
708 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
709
710 ret = create_file(workdir, "test.txt", 'a', 1);
711 ok(ret, "create_file error: %d\n", GetLastError());
712
713 if (!expect_files(workdir, 2, "test.exe", "test.txt"))
714 {
715 skip("Skipping test, files are not returned in the expected order by the FS\n");
716 }
717 else
718 {
719 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
720 /* (4 << 1) ^ 1 */
721 /* test.exe test.txt */
722 expect_LayerValue(0, "SIGN.MEDIA=9 test.exe", "TEST");
723 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
724 }
725
726 ret = create_file(workdir, "test.zz", 'a', 0x1000);
727 ok(ret, "create_file error: %d\n", GetLastError());
728
729 if (!expect_files(workdir, 3, "test.exe", "test.txt", "test.zz"))
730 {
731 skip("Skipping test, files are not returned in the expected order by the FS\n");
732 }
733 else
734 {
735 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
736 /* (((4 << 1) ^ 1) << 1) ^ 0x1000 */
737 /* test.exe test.txt test.zz */
738 expect_LayerValue(0, "SIGN.MEDIA=1012 test.exe", "TEST");
739 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
740 }
741
742 ret = create_file(subdir, "test.exe", 'a', 0x10203);
743 ok(ret, "create_file error: %d\n", GetLastError());
744
745 if (!expect_files(subdir, 1, "test.exe"))
746 {
747 skip("Skipping test, files are not returned in the expected order by the FS\n");
748 }
749 else
750 {
751 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
752 /* 0x10203 */
753 /* test.exe */
754 expect_LayerValue(0, "SIGN.MEDIA=10203 sub\\test.exe", "TEST");
755 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
756 }
757
758 ret = create_file(subdir, "test.bbb", 'a', 0);
759 ok(ret, "create_file error: %d\n", GetLastError());
760
761 if (!expect_files(subdir, 2, "test.bbb", "test.exe"))
762 {
763 skip("Skipping test, files are not returned in the expected order by the FS\n");
764 }
765 else
766 {
767 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
768 /* 0x10203 */
769 /* test.exe */
770 expect_LayerValue(0, "SIGN.MEDIA=10203 sub\\test.exe", "TEST");
771 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
772 }
773
774 ret = create_file(subdir, "TEST.txt", 'a', 0x30201);
775 ok(ret, "create_file error: %d\n", GetLastError());
776
777 if (!expect_files(subdir, 3, "test.bbb", "test.exe", "TEST.txt"))
778 {
779 skip("Skipping test, files are not returned in the expected order by the FS\n");
780 }
781 else
782 {
783 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
784 /* (0x10203 << 1) ^ 0x30201 */
785 /* test.exe TEST.txt */
786 expect_LayerValue(0, "SIGN.MEDIA=10607 sub\\test.exe", "TEST");
787 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
788 }
789
790 ret = create_file(subdir, "TEST.aaa", 'a', 0x3a2a1);
791 ok(ret, "create_file error: %d\n", GetLastError());
792
793 if (!expect_files(subdir, 4, "TEST.aaa", "test.bbb", "test.exe", "TEST.txt"))
794 {
795 skip("Skipping test, files are not returned in the expected order by the FS\n");
796 }
797 else
798 {
799 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
800 /* (((0x3a2a1 << 1) ^ 0x10203) << 1) ^ 0x30201 */
801 /* TEST.aaa test.exe TEST.txt */
802 expect_LayerValue(0, "SIGN.MEDIA=F8C83 sub\\test.exe", "TEST");
803 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
804 }
805
806 ret = RestoreIat(GetModuleHandleA("apphelp.dll"), "kernel32.dll", "GetDriveTypeW", (ULONG_PTR)pGetDriveTypeW);
807 ok(ret, "Expected restore_iat to succeed\n");
808
809 ret = delete_file(subdir, "test.bbb");
810 ok(ret, "delete_file error: %d\n", GetLastError());
811 ret = delete_file(subdir, "TEST.aaa");
812 ok(ret, "delete_file error: %d\n", GetLastError());
813 ret = delete_file(subdir, "TEST.txt");
814 ok(ret, "delete_file error: %d\n", GetLastError());
815 ret = delete_file(subdir, "test.exe");
816 ok(ret, "delete_file error: %d\n", GetLastError());
817 ret = delete_file(workdir, "test.zz");
818 ok(ret, "delete_file error: %d\n", GetLastError());
819 ret = delete_file(workdir, "test.txt");
820 ok(ret, "delete_file error: %d\n", GetLastError());
821 ret = delete_file(workdir, "test.exe");
822 ok(ret, "delete_file error: %d\n", GetLastError());
823 }
825 ok(ret, "DefineDosDeviceA error: %d\n", GetLastError());
826 }
827 ret = RemoveDirectoryA(subdir);
828 ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
830 ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
831}
832
833
834START_TEST(layerapi)
835{
837 /*SetEnvironmentVariable("SHIM_DEBUG_LEVEL", "4");*/
838 hdll = LoadLibraryA("apphelp.dll");
839 pAllowPermLayer = (void *)GetProcAddress(hdll, "AllowPermLayer");
840 pSdbSetPermLayerKeys = (void *)GetProcAddress(hdll, "SdbSetPermLayerKeys");
841 pSdbGetPermLayerKeys = (void *)GetProcAddress(hdll, "SdbGetPermLayerKeys");
842 pSetPermLayerState = (void *)GetProcAddress(hdll, "SetPermLayerState");
844
845 if (!pAllowPermLayer)
846 {
847 skip("Skipping tests with AllowPermLayer, function not found\n");
848 }
849 else
850 {
852 }
853
854 if (!pSdbSetPermLayerKeys)
855 {
856 skip("Skipping tests with SdbSetPermLayerKeys, function not found\n");
857 }
858 else
859 {
860 if (!pSdbGetPermLayerKeys)
861 {
862 skip("Skipping tests with SdbGetPermLayerKeys, function not found\n");
863 }
864 else
865 {
867 }
868
869 if (!pSetPermLayerState)
870 {
871 skip("Skipping tests with SetPermLayerState, function not found\n");
872 }
873 else
874 {
877 }
878 }
879}
#define broken(x)
Definition: _sntprintf.h:21
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * va_list
Definition: acmsvcex.h:78
#define va_end(ap)
Definition: acmsvcex.h:90
#define va_start(ap, A)
Definition: acmsvcex.h:91
#define va_arg(ap, T)
Definition: acmsvcex.h:89
static BOOL RestoreIat(HMODULE TargetDll, PCSTR DllName, PCSTR FunctionName, ULONG_PTR OriginalFunction)
static BOOL RedirectIat(HMODULE TargetDll, PCSTR DllName, PCSTR FunctionName, ULONG_PTR NewFunction, ULONG_PTR *OriginalFunction)
DWORD get_host_winver(void)
Definition: data.c:796
void silence_debug_output(void)
Definition: data.c:841
DWORD g_WinVersion
Definition: data.c:795
#define WINVER_WIN8
#define WINVER_VISTA
unsigned int dir
Definition: maze.c:112
#define ok(value,...)
Definition: atltest.h:57
#define skip(...)
Definition: atltest.h:64
#define START_TEST(x)
Definition: atltest.h:75
LONG NTSTATUS
Definition: precomp.h:26
#define RegCloseKey(hKey)
Definition: registry.h:49
static TAGID TAGID find
Definition: db.cpp:155
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_SUCCESS
Definition: deptool.c:10
static LSTATUS(WINAPI *pRegDeleteTreeW)(HKEY
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
unsigned int idx
Definition: utils.c:41
LONG WINAPI RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
Definition: reg.c:4799
LONG WINAPI RegDeleteValueA(HKEY hKey, LPCSTR lpValueName)
Definition: reg.c:2287
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4009
LONG WINAPI RegCreateKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD Reserved, _In_ LPSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_ LPDWORD lpdwDisposition)
Definition: reg.c:1034
#define CloseHandle
Definition: compat.h:739
#define CP_ACP
Definition: compat.h:109
#define SetLastError(x)
Definition: compat.h:752
#define GetProcAddress(x, y)
Definition: compat.h:753
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
#define MAX_PATH
Definition: compat.h:34
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define WideCharToMultiByte
Definition: compat.h:111
#define MultiByteToWideChar
Definition: compat.h:110
#define lstrlenW
Definition: compat.h:750
BOOL WINAPI DefineDosDeviceA(DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath)
Definition: dosdev.c:162
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
BOOL WINAPI RemoveDirectoryA(IN LPCSTR lpPathName)
Definition: dir.c:714
BOOL WINAPI CreateDirectoryA(IN LPCSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:37
UINT WINAPI GetDriveTypeA(IN LPCSTR lpRootPathName)
Definition: disk.c:468
HANDLE WINAPI FindFirstFileA(IN LPCSTR lpFileName, OUT LPWIN32_FIND_DATAA lpFindFileData)
Definition: find.c:263
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
BOOL WINAPI FindNextFileA(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAA lpFindFileData)
Definition: find.c:336
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
DWORD WINAPI GetShortPathNameA(IN LPCSTR lpszLongPath, OUT LPSTR lpszShortPath, IN DWORD cchBuffer)
Definition: path.c:1752
DWORD WINAPI GetLongPathNameA(IN LPCSTR lpszShortPath, OUT LPSTR lpszLongPath, IN DWORD cchBuffer)
Definition: path.c:1671
DWORD WINAPI GetTempPathA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2054
static const WCHAR fileW[]
Definition: url.c:111
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
GLuint buffer
Definition: glext.h:5915
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLuint GLuint num
Definition: glext.h:9618
GLuint64EXT * result
Definition: glext.h:11304
GLenum target
Definition: glext.h:7315
@ ProcessWow64Information
Definition: winternl.h:396
#define REG_SZ
Definition: layer.c:22
static PCWSTR BOOL bMachine
Definition: layerapi.c:34
static void test_Sign_Media(void)
Definition: layerapi.c:658
static DWORD QueryFlag(void)
Definition: layerapi.c:41
static PCWSTR wszLayer
Definition: layerapi.c:36
BOOL wrapAllowPermLayer(const char *str)
Definition: layerapi.c:158
static PCWSTR wszLayers
Definition: layerapi.c:34
static char g_FakeDrive
Definition: layerapi.c:604
static void test_SdbGetPermLayerKeys(void)
Definition: layerapi.c:238
void expect_Sdb_imp(PCSTR path, DWORD type, BOOL result, DWORD lenResult, PCSTR stringResult)
Definition: layerapi.c:108
static PWSTR PDWORD pdwBytes
Definition: layerapi.c:35
static void expect_LayerValue_imp(BOOL bMachine, const char *valueName, const char *value)
Definition: layerapi.c:73
static HMODULE hdll
Definition: layerapi.c:32
static BOOL wrapSdbSetPermLayerKeys2(LPCSTR dir, LPCSTR name, PCSTR szLayers, BOOL bMachine)
Definition: layerapi.c:615
#define GPLK_USER
Definition: layerapi.c:26
#define LAYER_APPLY_TO_SYSTEM_EXES
Definition: layerapi.c:29
static void expect_LayerValue_imp2(BOOL bMachine, const char *valueName, const char *value, int use_alt, const char *alt_value)
Definition: layerapi.c:102
static void test_SdbSetPermLayerKeysLevel(BOOL bMachine, const char *file)
Definition: layerapi.c:200
static BOOL wrapSetPermLayerState(PCWSTR wszPath, PCSTR szLayer, DWORD dwFlags, BOOL bMachine, BOOL bEnable)
Definition: layerapi.c:331
#define GPLK_MACHINE
Definition: layerapi.c:27
#define expect_Sdb
Definition: layerapi.c:153
#define expect_LayerValue2
Definition: layerapi.c:155
static PWSTR pwszLayers
Definition: layerapi.c:35
static PWSTR PDWORD DWORD dwFlags
Definition: layerapi.c:35
#define MAX_LAYER_LENGTH
Definition: layerapi.c:28
static BOOL setLayerValue(BOOL bMachine, const char *valueName, const char *value)
Definition: layerapi.c:53
#define expect_LayerValue
Definition: layerapi.c:154
static DWORD g_QueryFlag
Definition: layerapi.c:40
UINT WINAPI mGetDriveTypeW(LPCWSTR target)
Definition: layerapi.c:607
static void test_AllowPermLayer(void)
Definition: layerapi.c:170
static BOOL wrapSdbSetPermLayerKeys(PCWSTR wszPath, PCSTR szLayers, BOOL bMachine)
Definition: layerapi.c:193
static PCWSTR DWORD BOOL BOOL bEnable
Definition: layerapi.c:36
BOOL expect_files(const char *dir, int num,...)
Definition: layerapi.c:626
static void test_SetPermLayerStateLevel(BOOL bMachine, const char *file)
Definition: layerapi.c:338
static void test_SetPermLayer(void)
Definition: layerapi.c:529
#define DRIVE_CDROM
Definition: machpc98.h:119
#define CREATE_ALWAYS
Definition: disk.h:72
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
LPCWSTR szPath
Definition: env.c:37
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static char workdir[MAX_PATH]
Definition: batch.c:26
#define create_file(name, size)
Definition: asmcache.c:813
static const char filler[0x1000]
Definition: loader.c:167
#define cmp(status, error)
Definition: error.c:114
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToNtPathName_U(_In_opt_z_ PCWSTR DosPathName, _Out_ PUNICODE_STRING NtPathName, _Out_opt_ PCWSTR *NtFileNamePart, _Out_opt_ PRTL_RELATIVE_NAME_U DirectoryInfo)
#define BOOL
Definition: nt_native.h:43
#define NtCurrentProcess()
Definition: nt_native.h:1657
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define GENERIC_WRITE
Definition: nt_native.h:90
#define KEY_SET_VALUE
Definition: nt_native.h:1017
NTSTATUS NTAPI NtQueryInformationProcess(_In_ HANDLE ProcessHandle, _In_ PROCESSINFOCLASS ProcessInformationClass, _Out_ PVOID ProcessInformation, _In_ ULONG ProcessInformationLength, _Out_opt_ PULONG ReturnLength)
Definition: query.c:59
#define PathCombineA
Definition: pathcch.h:316
#define PathAppendA
Definition: pathcch.h:308
DWORD * PDWORD
Definition: pedump.c:68
#define delete_file(f)
Definition: reg_test.h:97
const WCHAR * str
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
#define memset(x, y, z)
Definition: compat.h:39
#define args
Definition: format.c:66
STRSAFEAPI StringCbPrintfA(STRSAFE_LPSTR pszDest, size_t cbDest, STRSAFE_LPCSTR pszFormat,...)
Definition: strsafe.h:547
Definition: match.c:390
Definition: fci.c:127
Definition: copy.c:22
Definition: name.c:39
Definition: ps.c:97
uint16_t * PWSTR
Definition: typedefs.h:56
const uint16_t * PCWSTR
Definition: typedefs.h:57
unsigned char * LPBYTE
Definition: typedefs.h:53
const char * PCSTR
Definition: typedefs.h:52
uint32_t ULONG_PTR
Definition: typedefs.h:65
Definition: pdh_main.c:94
int ret
#define DDD_NO_BROADCAST_SYSTEM
Definition: winbase.h:526
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define DRIVE_REMOTE
Definition: winbase.h:253
DWORD WINAPI GetLogicalDrives(void)
Definition: disk.c:110
#define DDD_REMOVE_DEFINITION
Definition: winbase.h:524
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ BOOL bEnable
Definition: winddi.h:3426
#define WINAPI
Definition: msvc.h:6
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_USER
Definition: winreg.h:11
#define KEY_WOW64_64KEY
Definition: cmtypes.h:46
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193