f84c70c062a0a41855d178221f5a0ee7527060cd
[reactos.git] / rostests / apitests / apphelp / layerapi.c
1 /*
2 * Copyright 2015 Mark Jansen
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <ntstatus.h>
20 #define WIN32_NO_STATUS
21 #include <windows.h>
22 #include <shlwapi.h>
23 #include <winnt.h>
24 #ifdef __REACTOS__
25 #include <ntndk.h>
26 #else
27 #include <winternl.h>
28 #endif
29 #include <winerror.h>
30 #include <stdio.h>
31
32 #include "wine/test.h"
33
34
35 #define GPLK_USER 1
36 #define GPLK_MACHINE 2
37 #define MAX_LAYER_LENGTH 256
38 #define LAYER_APPLY_TO_SYSTEM_EXES 1
39
40
41 static HMODULE hdll;
42 static BOOL(WINAPI *pAllowPermLayer)(PCWSTR path);
43 static BOOL(WINAPI *pSdbSetPermLayerKeys)(PCWSTR wszPath, PCWSTR wszLayers, BOOL bMachine);
44 static BOOL(WINAPI *pSdbGetPermLayerKeys)(PCWSTR wszPath, PWSTR pwszLayers, PDWORD pdwBytes, DWORD dwFlags);
45 static BOOL(WINAPI *pSetPermLayerState)(PCWSTR wszPath, PCWSTR wszLayer, DWORD dwFlags, BOOL bMachine, BOOL bEnable);
46
47
48 static DWORD g_Version;
49 #define APPHELP_VISTA 0x0600
50 #define APPHELP_WIN8 0x0602
51 #define APPHELP_WIN10 0x1000
52
53
54 /* Helper function to disable Wow64 redirection on an os that reports it being enabled. */
55 static DWORD g_QueryFlag = 0xffffffff;
56 static DWORD QueryFlag(void)
57 {
58 if (g_QueryFlag == 0xffffffff)
59 {
60 ULONG_PTR wow64_ptr = 0;
61 NTSTATUS status = NtQueryInformationProcess(NtCurrentProcess(), ProcessWow64Information, &wow64_ptr, sizeof(wow64_ptr), NULL);
62 g_QueryFlag = (NT_SUCCESS(status) && wow64_ptr != 0) ? KEY_WOW64_64KEY : 0;
63 }
64 return g_QueryFlag;
65 }
66
67 /* Helper function to prepare the registry key with a value. */
68 static BOOL setLayerValue(BOOL bMachine, const char* valueName, const char* value)
69 {
70 HKEY key = NULL;
71 LSTATUS lstatus = RegCreateKeyExA(bMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
72 "Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers", 0, NULL, 0, QueryFlag() | KEY_SET_VALUE, NULL, &key, NULL);
73 if (lstatus == ERROR_SUCCESS)
74 {
75 if (value)
76 lstatus = RegSetValueExA(key, valueName, 0, REG_SZ, (const BYTE*)value, strlen(value)+1);
77 else
78 {
79 lstatus = RegDeleteValueA(key, valueName);
80 lstatus = (lstatus == ERROR_FILE_NOT_FOUND ? ERROR_SUCCESS : lstatus);
81 }
82 RegCloseKey(key);
83 }
84 return lstatus == ERROR_SUCCESS;
85 }
86
87
88 static void expect_LayerValue_imp(BOOL bMachine, const char* valueName, const char* value)
89 {
90 HKEY key = NULL;
91 LSTATUS lstatus = RegCreateKeyExA(bMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
92 "Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers", 0, NULL, 0, QueryFlag() | KEY_QUERY_VALUE, NULL, &key, NULL);
93 winetest_ok(lstatus == ERROR_SUCCESS, "Expected to be able to open a registry key\n");
94 if (lstatus == ERROR_SUCCESS)
95 {
96 char data[512] = { 0 };
97 DWORD dwType = 0;
98 DWORD dwDataLen = sizeof(data);
99 lstatus = RegQueryValueExA(key, valueName, NULL, &dwType, (LPBYTE)data, &dwDataLen);
100 if (value)
101 {
102 winetest_ok(lstatus == ERROR_SUCCESS, "Expected to get a valid value, err: %u\n", lstatus);
103 if (lstatus == ERROR_SUCCESS)
104 {
105 winetest_ok(dwType == REG_SZ, "Expected the type to be REG_SZ, was: %u\n", dwType);
106 winetest_ok(!strcmp(data, value), "Expected the data to be: '%s', was: '%s'\n", value, data);
107 }
108 }
109 else
110 {
111 winetest_ok(lstatus == ERROR_FILE_NOT_FOUND, "Expected not to find the value %s\n", valueName);
112 }
113 RegCloseKey(key);
114 }
115 }
116
117 static void expect_LayerValue_imp2(BOOL bMachine, const char* valueName, const char* value, int use_alt, const char* alt_value)
118 {
119 expect_LayerValue_imp(bMachine, valueName, use_alt ? alt_value : value);
120 }
121
122
123 void expect_Sdb_imp(PCSTR path, DWORD type, BOOL result, DWORD lenResult, PCSTR stringResult)
124 {
125 WCHAR pathW[MAX_PATH], buffer[MAX_LAYER_LENGTH] = { 0 };
126 char resultBuffer[MAX_LAYER_LENGTH] = { 0 };
127 DWORD dwBufSize = sizeof(buffer);
128
129 /* In case of a failure, the buffer size is sometimes set to 0, and sometimes not touched,
130 depending on the version. Either case is fine, since the function returns FALSE anyway. */
131
132 MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, MAX_PATH);
133
134 winetest_ok(pSdbGetPermLayerKeys(pathW, buffer, &dwBufSize, type) == result, "Expected pSdbGetPermLayerKeys to %s\n", (result ? "succeed" : "fail"));
135 if (!result && lenResult == 0xffffffff)
136 winetest_ok(dwBufSize == 0 || dwBufSize == sizeof(buffer), "Expected dwBufSize to be 0 or %u, was %u\n", sizeof(buffer), dwBufSize);
137 else
138 winetest_ok(dwBufSize == lenResult ||
139 /* W2k3 is off by 2 when concatenating user / machine */
140 broken(g_Version < APPHELP_VISTA && type == (GPLK_MACHINE|GPLK_USER) && (lenResult + 2) == dwBufSize),
141 "Expected dwBufSize to be %u, was %u\n", lenResult, dwBufSize);
142 if (result)
143 {
144 winetest_ok(lstrlenW(buffer) * sizeof(WCHAR) + sizeof(WCHAR) == lenResult, "Expected lstrlenW(buffer)*2+2 to be %u, was %u\n",
145 lenResult, lstrlenW(buffer) * sizeof(WCHAR) + sizeof(WCHAR));
146 }
147 WideCharToMultiByte(CP_ACP, 0, buffer, -1, resultBuffer, sizeof(resultBuffer), NULL, NULL);
148 winetest_ok(!strcmp(stringResult, resultBuffer), "Expected the result to be '%s', was '%s'\n", stringResult, resultBuffer);
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
158 BOOL wrapAllowPermLayer(const char* str)
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 */
170 static 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");
176 if (g_Version < APPHELP_WIN8)
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
193 static BOOL wrapSdbSetPermLayerKeys(PCWSTR wszPath, PCSTR szLayers, BOOL bMachine)
194 {
195 WCHAR wszLayers[MAX_LAYER_LENGTH];
196 MultiByteToWideChar(CP_ACP, 0, szLayers, -1, wszLayers, MAX_LAYER_LENGTH);
197 return pSdbSetPermLayerKeys(wszPath, wszLayers, bMachine);
198 }
199
200 static void test_SdbSetPermLayerKeysLevel(BOOL bMachine, const char* file)
201 {
202 WCHAR fileW[MAX_PATH+20];
203 WCHAR emptyString[1] = { 0 };
204
205 MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, MAX_PATH+20);
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");
216 expect_LayerValue(bMachine, file, "TEST1");
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");
229 expect_LayerValue(bMachine, file, NULL);
230
231 ok(wrapSdbSetPermLayerKeys(fileW, " ", bMachine), "Expected SdbSetPermLayerKeys to succeed\n");
232 expect_LayerValue(bMachine, file, " ");
233
234 ok(pSdbSetPermLayerKeys(fileW, NULL, bMachine) == TRUE, "Expected SdbSetPermLayerKeys to fail\n");
235 expect_LayerValue(bMachine, file, NULL);
236 }
237
238 static void test_SdbGetPermLayerKeys(void)
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
246 GetTempPathA(MAX_PATH, tmp);
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
267 hfile = CreateFileA(file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
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 */
304 setLayerValue(FALSE, file, NULL);
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 sprintf(tmp, "\\?\\%s", file);
315 expect_Sdb(tmp, GPLK_USER, FALSE, 0xffffffff, "");
316 sprintf(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");
326 setLayerValue(FALSE, file, NULL);
327 setLayerValue(TRUE, file, NULL);
328 }
329
330
331 static BOOL wrapSetPermLayerState(PCWSTR wszPath, PCSTR szLayer, DWORD dwFlags, BOOL bMachine, BOOL bEnable)
332 {
333 WCHAR wszLayer[MAX_LAYER_LENGTH];
334 MultiByteToWideChar(CP_ACP, 0, szLayer, -1, wszLayer, MAX_LAYER_LENGTH);
335 return pSetPermLayerState(wszPath, wszLayer, dwFlags, bMachine, bEnable);
336 }
337
338 static void test_SetPermLayerStateLevel(BOOL bMachine, const char* file)
339 {
340 WCHAR fileW[MAX_PATH+20];
341 WCHAR emptyString[1] = { 0 };
342 DWORD dwFlag;
343
344 MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, MAX_PATH+20);
345
346 /* Test some parameter validation. */
347 ok(pSetPermLayerState(fileW, NULL, 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
348 expect_LayerValue(bMachine, file, NULL);
349
350 ok(pSetPermLayerState(fileW, NULL, 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
351 expect_LayerValue(bMachine, file, NULL);
352
353 ok(wrapSetPermLayerState(fileW, "", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
354 expect_LayerValue(bMachine, file, NULL);
355
356 ok(wrapSetPermLayerState(fileW, "", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
357 expect_LayerValue(bMachine, file, NULL);
358
359 ok(wrapSetPermLayerState(NULL, NULL, 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
360 expect_LayerValue(bMachine, NULL, NULL);
361
362 ok(wrapSetPermLayerState(NULL, NULL, 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
363 expect_LayerValue(bMachine, NULL, NULL);
364
365 ok(wrapSetPermLayerState(emptyString, "", 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
366 expect_LayerValue(bMachine, NULL, NULL);
367
368 ok(wrapSetPermLayerState(emptyString, "", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
369 expect_LayerValue(bMachine, NULL, NULL);
370
371 ok(wrapSetPermLayerState(emptyString, "TEST", 0, bMachine, 0) == FALSE, "Expected SetPermLayerState to fail\n");
372 expect_LayerValue(bMachine, NULL, NULL);
373
374 if (g_Version <= APPHELP_WIN8)
375 {
376 ok(wrapSetPermLayerState(emptyString, "TEST", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
377 expect_LayerValue(bMachine, NULL, NULL);
378 }
379
380
381 /* Now, on to the actual tests. */
382 expect_LayerValue(bMachine, file, NULL);
383 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
384 expect_LayerValue(bMachine, file, NULL);
385
386 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
387 expect_LayerValue(bMachine, file, "TEST");
388
389 ok(wrapSetPermLayerState(fileW, "", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
390 expect_LayerValue(bMachine, file, "TEST");
391
392 ok(wrapSetPermLayerState(fileW, "test", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
393 expect_LayerValue(bMachine, file, "test");
394
395 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
396 expect_LayerValue(bMachine, file, NULL);
397
398 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
399 expect_LayerValue(bMachine, file, "TEST");
400
401 ok(wrapSetPermLayerState(fileW, "TEST1", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
402 expect_LayerValue2(bMachine, file, "TEST TEST1", g_Version >= APPHELP_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_Version >= APPHELP_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_Version >= APPHELP_WIN8, "TEST2 TEST");
409
410 ok(wrapSetPermLayerState(fileW, "TEST", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
411 expect_LayerValue(bMachine, file, "TEST2");
412
413 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 0) == TRUE, "Expected SetPermLayerState to succeed\n");
414 expect_LayerValue(bMachine, file, NULL);
415
416 /* Valid flags until win8: !# */
417 /* Key is empty, now play around with the flags. */
418 for (dwFlag = ((g_Version >= APPHELP_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 }
422 expect_LayerValue(bMachine, file, NULL);
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_Version >= APPHELP_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_Version >= APPHELP_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_Version >= APPHELP_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_Version >= APPHELP_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_Version >= APPHELP_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_Version >= APPHELP_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");
451 expect_LayerValue(bMachine, file, NULL);
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");
455 expect_LayerValue(bMachine, file, NULL);
456
457 ok(wrapSetPermLayerState(fileW, "TEST2", 0, bMachine, 1) == TRUE, "Expected SetPermLayerState to succeed\n");
458 expect_LayerValue(bMachine, file, "TEST2");
459
460 /* Try adding flags in via layer string */
461 ok(wrapSetPermLayerState(fileW, "#", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
462 expect_LayerValue(bMachine, file, "TEST2");
463
464 ok(wrapSetPermLayerState(fileW, "!", 0, bMachine, 1) == FALSE, "Expected SetPermLayerState to fail\n");
465 expect_LayerValue(bMachine, file, "TEST2");
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_Version >= APPHELP_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_Version >= APPHELP_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_Version >= APPHELP_WIN8, "!# TEST1 !# TEST");
480
481 if(g_Version < APPHELP_WIN8)
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_Version >= APPHELP_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_Version >= APPHELP_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");
526 expect_LayerValue(bMachine, file, NULL);
527 }
528
529 static void test_SetPermLayer(void)
530 {
531 char file[MAX_PATH + 20], tmp[MAX_PATH + 20];
532 HANDLE hfile;
533
534 GetTempPathA(MAX_PATH, tmp);
535 GetLongPathNameA(tmp, file, sizeof(file));
536 PathAppendA(file, "test_file.exe");
537
538 hfile = CreateFileA(file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
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
547 if (setLayerValue(FALSE, file, NULL))
548 {
549 test_SdbSetPermLayerKeysLevel(FALSE, file);
550 test_SetPermLayerStateLevel(FALSE, file);
551 }
552 else
553 {
554 skip("Skipping SetPermLayerStateLevel tests for User, because I cannot prepare the environment\n");
555 }
556 if (setLayerValue(TRUE, file, NULL))
557 {
558 test_SdbSetPermLayerKeysLevel(TRUE, file);
559 test_SetPermLayerStateLevel(TRUE, file);
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
568 static BOOL create_file(LPCSTR dir, LPCSTR name, int filler, size_t size)
569 {
570 char target[MAX_PATH], *tmp;
571 HANDLE file;
572 PathCombineA(target, dir, name);
573
574 tmp = malloc(size);
575 memset(tmp, filler, size);
576
577 file = CreateFileA(target, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
578 if(file == INVALID_HANDLE_VALUE)
579 return FALSE;
580
581 WriteFile(file, tmp, size, &size, NULL);
582 CloseHandle(file);
583 free(tmp);
584 return TRUE;
585 }
586
587 static BOOL delete_file(LPCSTR dir, LPCSTR name)
588 {
589 char target[MAX_PATH];
590 PathCombineA(target, dir, name);
591 return DeleteFileA(target);
592 }
593
594 static char g_FakeDrive = 0;
595
596 UINT (WINAPI *pGetDriveTypeW)(LPCWSTR target) = NULL;
597 UINT WINAPI mGetDriveTypeW(LPCWSTR target)
598 {
599 UINT uRet = pGetDriveTypeW(target);
600 if(g_FakeDrive && target && (char)*target == g_FakeDrive)
601 return DRIVE_CDROM;
602 return uRet;
603 }
604
605
606 static PIMAGE_IMPORT_DESCRIPTOR FindImportDescriptor(PBYTE DllBase, PCSTR DllName)
607 {
608 ULONG Size;
609 PIMAGE_IMPORT_DESCRIPTOR ImportDescriptor = RtlImageDirectoryEntryToData((HMODULE)DllBase, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &Size);
610 while (ImportDescriptor->Name && ImportDescriptor->OriginalFirstThunk)
611 {
612 PCHAR Name = (PCHAR)(DllBase + ImportDescriptor->Name);
613 if (!lstrcmpiA(Name, DllName))
614 {
615 return ImportDescriptor;
616 }
617 ImportDescriptor++;
618 }
619 return NULL;
620 }
621
622 static BOOL RedirectIat(PCSTR TargetDllName, PCSTR DllName, PCSTR FunctionName, ULONG_PTR NewFunction, ULONG_PTR* OriginalFunction)
623 {
624 PBYTE DllBase = (PBYTE)GetModuleHandleA(TargetDllName);
625 if (DllBase)
626 {
627 PIMAGE_IMPORT_DESCRIPTOR ImportDescriptor = FindImportDescriptor(DllBase, DllName);
628 if (ImportDescriptor)
629 {
630 // On loaded images, OriginalFirstThunk points to the name / ordinal of the function
631 PIMAGE_THUNK_DATA OriginalThunk = (PIMAGE_THUNK_DATA)(DllBase + ImportDescriptor->OriginalFirstThunk);
632 // FirstThunk points to the resolved address.
633 PIMAGE_THUNK_DATA FirstThunk = (PIMAGE_THUNK_DATA)(DllBase + ImportDescriptor->FirstThunk);
634 while (OriginalThunk->u1.AddressOfData && FirstThunk->u1.Function)
635 {
636 if (!IMAGE_SNAP_BY_ORDINAL32(OriginalThunk->u1.AddressOfData))
637 {
638 PIMAGE_IMPORT_BY_NAME ImportName = (PIMAGE_IMPORT_BY_NAME)(DllBase + OriginalThunk->u1.AddressOfData);
639 if (!lstrcmpiA((PCSTR)ImportName->Name, FunctionName))
640 {
641 DWORD dwOld;
642 VirtualProtect(&FirstThunk->u1.Function, sizeof(ULONG_PTR), PAGE_EXECUTE_READWRITE, &dwOld);
643 *OriginalFunction = FirstThunk->u1.Function;
644 FirstThunk->u1.Function = NewFunction;
645 VirtualProtect(&FirstThunk->u1.Function, sizeof(ULONG_PTR), dwOld, &dwOld);
646 return TRUE;
647 }
648 }
649 OriginalThunk++;
650 FirstThunk++;
651 }
652 skip("Unable to find the Import '%s' from '%s' in %s'\n", FunctionName, DllName, TargetDllName);
653 }
654 else
655 {
656 skip("Unable to find the ImportDescriptor for '%s' in '%s'\n", DllName, TargetDllName);
657 }
658 }
659 else
660 {
661 skip("Unable to find the loaded module '%s'\n", TargetDllName);
662 }
663 return FALSE;
664 }
665
666 static BOOL RestoreIat(PCSTR target, PCSTR DllName, PCSTR FunctionName, ULONG_PTR OriginalFunction)
667 {
668 ULONG_PTR old = 0;
669 return RedirectIat(target, DllName, FunctionName, OriginalFunction, &old);
670 }
671
672 static BOOL wrapSdbSetPermLayerKeys2(LPCSTR dir, LPCSTR name, PCSTR szLayers, BOOL bMachine)
673 {
674 char szPath[MAX_PATH];
675 WCHAR wszPath[MAX_PATH], wszLayers[MAX_LAYER_LENGTH];
676 PathCombineA(szPath, dir, name);
677 MultiByteToWideChar(CP_ACP, 0, szLayers, -1, wszLayers, MAX_LAYER_LENGTH);
678 MultiByteToWideChar(CP_ACP, 0, szPath, -1, wszPath, MAX_PATH);
679 return pSdbSetPermLayerKeys(wszPath, wszLayers, bMachine);
680 }
681
682
683 BOOL expect_files(const char* dir, int num, ...)
684 {
685 char finddir[MAX_PATH + 20];
686 va_list args;
687 WIN32_FIND_DATAA find = { 0 };
688 HANDLE hFind;
689 int cmp = 0;
690
691 va_start(args, num);
692
693 PathCombineA(finddir, dir, "*");
694 hFind = FindFirstFileA(finddir, &find);
695 if (hFind != INVALID_HANDLE_VALUE)
696 {
697 const char* file;
698 do
699 {
700 if (!(find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
701 {
702 if (--num < 0)
703 break;
704 file = va_arg(args, const char*);
705 cmp = strcmp(file, find.cFileName);
706 }
707 } while (cmp == 0 && FindNextFileA(hFind, &find));
708 FindClose(hFind);
709 }
710 va_end(args);
711 return cmp == 0 && num == 0;
712 }
713
714
715 static void test_Sign_Media(void)
716 {
717 char workdir[MAX_PATH], subdir[MAX_PATH], drive[5] = "Z:";
718 BOOL ret;
719
720 DWORD logical_drives = GetLogicalDrives();
721 g_FakeDrive = 0;
722 for (drive[0] = 'D'; drive[0] <= 'Z'; drive[0]++)
723 {
724 DWORD idx = 1 << (drive[0] - 'D' + 3);
725 if (!(logical_drives & idx))
726 {
727 g_FakeDrive = drive[0];
728 break;
729 }
730 }
731 if (!g_FakeDrive)
732 {
733 skip("Unable to find a free drive\n");
734 return;
735 }
736
737 ret = GetTempPathA(MAX_PATH, workdir);
738 ok(ret, "GetTempPathA error: %d\n", GetLastError());
739 PathAppendA(workdir, "apphelp_test");
740
741 ret = CreateDirectoryA(workdir, NULL);
742 ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
743
744 PathCombineA(subdir, workdir, "sub");
745 ret = CreateDirectoryA(subdir, NULL);
746 ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
747
748 ret = DefineDosDeviceA(DDD_NO_BROADCAST_SYSTEM, drive, workdir);
749 ok(ret, "DefineDosDeviceA error: %d\n", GetLastError());
750 if(ret)
751 {
752 ret = RedirectIat("apphelp.dll", "kernel32.dll", "GetDriveTypeW", (ULONG_PTR)mGetDriveTypeW, (ULONG_PTR*)&pGetDriveTypeW);
753 if (g_Version < APPHELP_WIN8)
754 ok(ret, "Expected redirect_iat to succeed\n");
755 if(ret)
756 {
757 ok(create_file(workdir, "test.exe", 'a', 4), "create_file error: %d\n", GetLastError());
758
759 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
760 /* 4 */
761 /* test.exe */
762 expect_LayerValue(0, "SIGN.MEDIA=4 test.exe", "TEST");
763 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
764
765 ok(create_file(workdir, "test.txt", 'a', 1), "create_file error: %d\n", GetLastError());
766
767 if (!expect_files(workdir, 2, "test.exe", "test.txt"))
768 {
769 skip("Skipping test, files are not returned in the expected order by the FS\n");
770 }
771 else
772 {
773 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
774 /* (4 << 1) ^ 1 */
775 /* test.exe test.txt */
776 expect_LayerValue(0, "SIGN.MEDIA=9 test.exe", "TEST");
777 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
778 }
779
780 ok(create_file(workdir, "test.zz", 'a', 0x1000), "create_file error: %d\n", GetLastError());
781
782 if (!expect_files(workdir, 3, "test.exe", "test.txt", "test.zz"))
783 {
784 skip("Skipping test, files are not returned in the expected order by the FS\n");
785 }
786 else
787 {
788 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
789 /* (((4 << 1) ^ 1) << 1) ^ 0x1000 */
790 /* test.exe test.txt test.zz */
791 expect_LayerValue(0, "SIGN.MEDIA=1012 test.exe", "TEST");
792 ok(wrapSdbSetPermLayerKeys2(drive, "test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
793 }
794
795 ok(create_file(subdir, "test.exe", 'a', 0x10203), "create_file error: %d\n", GetLastError());
796
797 if (!expect_files(subdir, 1, "test.exe"))
798 {
799 skip("Skipping test, files are not returned in the expected order by the FS\n");
800 }
801 else
802 {
803 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
804 /* 0x10203 */
805 /* test.exe */
806 expect_LayerValue(0, "SIGN.MEDIA=10203 sub\\test.exe", "TEST");
807 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
808 }
809
810 ok(create_file(subdir, "test.bbb", 'a', 0), "create_file error: %d\n", GetLastError());
811
812 if (!expect_files(subdir, 2, "test.bbb", "test.exe"))
813 {
814 skip("Skipping test, files are not returned in the expected order by the FS\n");
815 }
816 else
817 {
818 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
819 /* 0x10203 */
820 /* test.exe */
821 expect_LayerValue(0, "SIGN.MEDIA=10203 sub\\test.exe", "TEST");
822 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
823 }
824
825 ok(create_file(subdir, "TEST.txt", 'a', 0x30201), "create_file error: %d\n", GetLastError());
826
827 if (!expect_files(subdir, 3, "test.bbb", "test.exe", "TEST.txt"))
828 {
829 skip("Skipping test, files are not returned in the expected order by the FS\n");
830 }
831 else
832 {
833 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
834 /* (0x10203 << 1) ^ 0x30201 */
835 /* test.exe TEST.txt */
836 expect_LayerValue(0, "SIGN.MEDIA=10607 sub\\test.exe", "TEST");
837 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
838 }
839
840 ok(create_file(subdir, "TEST.aaa", 'a', 0x3a2a1), "create_file error: %d\n", GetLastError());
841
842 if (!expect_files(subdir, 4, "TEST.aaa", "test.bbb", "test.exe", "TEST.txt"))
843 {
844 skip("Skipping test, files are not returned in the expected order by the FS\n");
845 }
846 else
847 {
848 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "TEST", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
849 /* (((0x3a2a1 << 1) ^ 0x10203) << 1) ^ 0x30201 */
850 /* TEST.aaa test.exe TEST.txt */
851 expect_LayerValue(0, "SIGN.MEDIA=F8C83 sub\\test.exe", "TEST");
852 ok(wrapSdbSetPermLayerKeys2(drive, "sub\\test.exe", "", 0), "Expected wrapSdbSetPermLayerKeys2 to succeed\n");
853 }
854
855 ret = RestoreIat("apphelp.dll", "kernel32.dll", "GetDriveTypeW", (ULONG_PTR)pGetDriveTypeW);
856 ok(ret, "Expected restore_iat to succeed\n");
857
858 ok(delete_file(subdir, "test.bbb"), "delete_file error: %d\n", GetLastError());
859 ok(delete_file(subdir, "TEST.aaa"), "delete_file error: %d\n", GetLastError());
860 ok(delete_file(subdir, "TEST.txt"), "delete_file error: %d\n", GetLastError());
861 ok(delete_file(subdir, "test.exe"), "delete_file error: %d\n", GetLastError());
862 ok(delete_file(workdir, "test.zz"), "delete_file error: %d\n", GetLastError());
863 ok(delete_file(workdir, "test.txt"), "delete_file error: %d\n", GetLastError());
864 ok(delete_file(workdir, "test.exe"), "delete_file error: %d\n", GetLastError());
865 }
866 ret = DefineDosDeviceA(DDD_REMOVE_DEFINITION | DDD_NO_BROADCAST_SYSTEM, drive, NULL);
867 ok(ret, "DefineDosDeviceA error: %d\n", GetLastError());
868 }
869 ret = RemoveDirectoryA(subdir);
870 ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
871 ret = RemoveDirectoryA(workdir);
872 ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
873 }
874
875
876 START_TEST(layerapi)
877 {
878 RTL_OSVERSIONINFOEXW rtlinfo;
879 /*SetEnvironmentVariable("SHIM_DEBUG_LEVEL", "4");*/
880 hdll = LoadLibraryA("apphelp.dll");
881 pAllowPermLayer = (void *)GetProcAddress(hdll, "AllowPermLayer");
882 pSdbSetPermLayerKeys = (void *)GetProcAddress(hdll, "SdbSetPermLayerKeys");
883 pSdbGetPermLayerKeys = (void *)GetProcAddress(hdll, "SdbGetPermLayerKeys");
884 pSetPermLayerState = (void *)GetProcAddress(hdll, "SetPermLayerState");
885 rtlinfo.dwOSVersionInfoSize = sizeof(rtlinfo);
886 #ifdef __REACTOS__
887 RtlGetVersion((PRTL_OSVERSIONINFOW)&rtlinfo);
888 #else
889 RtlGetVersion(&rtlinfo);
890 #endif
891 g_Version = (rtlinfo.dwMajorVersion << 8) | rtlinfo.dwMinorVersion;
892
893 if (!pAllowPermLayer)
894 {
895 skip("Skipping tests with AllowPermLayer, function not found\n");
896 }
897 else
898 {
899 test_AllowPermLayer();
900 }
901
902 if (!pSdbSetPermLayerKeys)
903 {
904 skip("Skipping tests with SdbSetPermLayerKeys, function not found\n");
905 }
906 else
907 {
908 if (!pSdbGetPermLayerKeys)
909 {
910 skip("Skipping tests with SdbGetPermLayerKeys, function not found\n");
911 }
912 else
913 {
914 test_SdbGetPermLayerKeys();
915 }
916
917 if (!pSetPermLayerState)
918 {
919 skip("Skipping tests with SetPermLayerState, function not found\n");
920 }
921 else
922 {
923 test_SetPermLayer();
924 test_Sign_Media();
925 }
926 }
927 }