1 /* Unit test suite for wintrust crypt functions
3 * Copyright 2007 Paul Vriens
4 * Copyright 2008 Hans Leidekker for CodeWeavers
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #include "wine/test.h"
30 static char selfname
[MAX_PATH
];
31 static CHAR CURR_DIR
[MAX_PATH
];
32 static CHAR catroot
[MAX_PATH
];
33 static CHAR catroot2
[MAX_PATH
];
35 static const WCHAR hashmeW
[] = {'h','a','s','h','m','e',0};
36 static const WCHAR attr1W
[] = {'a','t','t','r','1',0};
37 static const WCHAR attr2W
[] = {'a','t','t','r','2',0};
40 * Minimalistic catalog file. To reconstruct, save text below as winetest.cdf,
41 * convert to DOS line endings and run 'makecat /cat winetest.cdf'
48 PublicVersion=0x00000001
50 CATATTR1=0x10010001:attr1:value1
51 CATATTR2=0x10010001:attr2:value2
57 static const CHAR test_cdf
[] =
59 "Name=winetest.cat\r\n"
61 "PublicVersion=0x00000001\r\n"
63 "CATATTR1=0x10010001:attr1:value1\r\n"
64 "CATATTR2=0x10010001:attr2:value2\r\n"
67 "hashme=.\\winetest.cdf\r\n";
69 static const BYTE test_catalog
[] = {
70 0x30, 0x82, 0x01, 0xbc, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x02, 0xa0,
71 0x82, 0x01, 0xad, 0x30, 0x82, 0x01, 0xa9, 0x02, 0x01, 0x01, 0x31, 0x00, 0x30, 0x82, 0x01, 0x9e,
72 0x06, 0x09, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0a, 0x01, 0xa0, 0x82, 0x01, 0x8f, 0x30,
73 0x82, 0x01, 0x8b, 0x30, 0x0c, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x01,
74 0x01, 0x04, 0x10, 0xfa, 0x55, 0x2c, 0xc2, 0xf6, 0xcc, 0xdd, 0x11, 0x2a, 0x9c, 0x00, 0x14, 0x22,
75 0xec, 0x8f, 0x3b, 0x17, 0x0d, 0x30, 0x38, 0x31, 0x32, 0x31, 0x38, 0x31, 0x31, 0x32, 0x36, 0x34,
76 0x38, 0x5a, 0x30, 0x0e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x01, 0x02,
77 0x05, 0x00, 0x30, 0x81, 0xdd, 0x30, 0x81, 0xda, 0x04, 0x0e, 0x68, 0x00, 0x61, 0x00, 0x73, 0x00,
78 0x68, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x00, 0x00, 0x31, 0x81, 0xc7, 0x30, 0x61, 0x06, 0x0a, 0x2b,
79 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x04, 0x31, 0x53, 0x30, 0x51, 0x30, 0x2c, 0x06,
80 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x19, 0xa2, 0x1e, 0x80, 0x1c, 0x00,
81 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x4f, 0x00, 0x62, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x6c, 0x00,
82 0x65, 0x00, 0x74, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x3e, 0x00, 0x3e, 0x30, 0x21, 0x30, 0x09, 0x06,
83 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, 0xed, 0xd6, 0x9c, 0x9c, 0xb2, 0xfc,
84 0xaa, 0x03, 0xe8, 0xd3, 0x20, 0xf6, 0xab, 0x28, 0xc3, 0xff, 0xbd, 0x07, 0x36, 0xf5, 0x30, 0x62,
85 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x02, 0x02, 0x31, 0x54, 0x30, 0x52,
86 0x1e, 0x4c, 0x00, 0x7b, 0x00, 0x44, 0x00, 0x45, 0x00, 0x33, 0x00, 0x35, 0x00, 0x31, 0x00, 0x41,
87 0x00, 0x34, 0x00, 0x32, 0x00, 0x2d, 0x00, 0x38, 0x00, 0x45, 0x00, 0x35, 0x00, 0x39, 0x00, 0x2d,
88 0x00, 0x31, 0x00, 0x31, 0x00, 0x44, 0x00, 0x30, 0x00, 0x2d, 0x00, 0x38, 0x00, 0x43, 0x00, 0x34,
89 0x00, 0x37, 0x00, 0x2d, 0x00, 0x30, 0x00, 0x30, 0x00, 0x43, 0x00, 0x30, 0x00, 0x34, 0x00, 0x46,
90 0x00, 0x43, 0x00, 0x32, 0x00, 0x39, 0x00, 0x35, 0x00, 0x45, 0x00, 0x45, 0x00, 0x7d, 0x02, 0x02,
91 0x02, 0x00, 0xa0, 0x6a, 0x30, 0x68, 0x30, 0x32, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82,
92 0x37, 0x0c, 0x02, 0x01, 0x04, 0x24, 0x30, 0x22, 0x1e, 0x0a, 0x00, 0x61, 0x00, 0x74, 0x00, 0x74,
93 0x00, 0x72, 0x00, 0x32, 0x02, 0x04, 0x10, 0x01, 0x00, 0x01, 0x04, 0x0e, 0x76, 0x00, 0x61, 0x00,
94 0x6c, 0x00, 0x75, 0x00, 0x65, 0x00, 0x32, 0x00, 0x00, 0x00, 0x30, 0x32, 0x06, 0x0a, 0x2b, 0x06,
95 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x02, 0x01, 0x04, 0x24, 0x30, 0x22, 0x1e, 0x0a, 0x00, 0x61,
96 0x00, 0x74, 0x00, 0x74, 0x00, 0x72, 0x00, 0x31, 0x02, 0x04, 0x10, 0x01, 0x00, 0x01, 0x04, 0x0e,
97 0x76, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x75, 0x00, 0x65, 0x00, 0x31, 0x00, 0x00, 0x00, 0x31, 0x00,
100 static BOOL (WINAPI
* pCryptCATAdminAcquireContext
)(HCATADMIN
*, const GUID
*, DWORD
);
101 static BOOL (WINAPI
* pCryptCATAdminReleaseContext
)(HCATADMIN
, DWORD
);
102 static BOOL (WINAPI
* pCryptCATAdminCalcHashFromFileHandle
)(HANDLE hFile
, DWORD
*, BYTE
*, DWORD
);
103 static HCATINFO (WINAPI
* pCryptCATAdminAddCatalog
)(HCATADMIN
, PWSTR
, PWSTR
, DWORD
);
104 static BOOL (WINAPI
* pCryptCATAdminRemoveCatalog
)(HCATADMIN
, LPCWSTR
, DWORD
);
105 static BOOL (WINAPI
* pCryptCATAdminReleaseCatalogContext
)(HCATADMIN
, HCATINFO
, DWORD
);
106 static HANDLE (WINAPI
* pCryptCATOpen
)(LPWSTR
, DWORD
, HCRYPTPROV
, DWORD
, DWORD
);
107 static BOOL (WINAPI
* pCryptCATCatalogInfoFromContext
)(HCATINFO
, CATALOG_INFO
*, DWORD
);
108 static BOOL (WINAPI
* pCryptCATCDFClose
)(CRYPTCATCDF
*);
109 static CRYPTCATATTRIBUTE
* (WINAPI
* pCryptCATCDFEnumCatAttributes
)(CRYPTCATCDF
*, CRYPTCATATTRIBUTE
*,
110 PFN_CDF_PARSE_ERROR_CALLBACK
);
111 static LPWSTR (WINAPI
* pCryptCATCDFEnumMembersByCDFTagEx
)(CRYPTCATCDF
*, LPWSTR
, PFN_CDF_PARSE_ERROR_CALLBACK
,
112 CRYPTCATMEMBER
**, BOOL
, LPVOID
);
113 static CRYPTCATCDF
* (WINAPI
* pCryptCATCDFOpen
)(LPWSTR
, PFN_CDF_PARSE_ERROR_CALLBACK
);
114 static CRYPTCATATTRIBUTE
* (WINAPI
* pCryptCATEnumerateCatAttr
)(HANDLE
, CRYPTCATATTRIBUTE
*);
115 static CRYPTCATMEMBER
* (WINAPI
* pCryptCATEnumerateMember
)(HANDLE
, CRYPTCATMEMBER
*);
116 static CRYPTCATATTRIBUTE
* (WINAPI
* pCryptCATEnumerateAttr
)(HANDLE
, CRYPTCATMEMBER
*, CRYPTCATATTRIBUTE
*);
117 static BOOL (WINAPI
* pCryptCATClose
)(HANDLE
);
119 static void InitFunctionPtrs(void)
121 HMODULE hWintrust
= GetModuleHandleA("wintrust.dll");
123 #define WINTRUST_GET_PROC(func) \
124 p ## func = (void*)GetProcAddress(hWintrust, #func); \
126 trace("GetProcAddress(%s) failed\n", #func); \
129 WINTRUST_GET_PROC(CryptCATAdminAcquireContext
)
130 WINTRUST_GET_PROC(CryptCATAdminReleaseContext
)
131 WINTRUST_GET_PROC(CryptCATAdminCalcHashFromFileHandle
)
132 WINTRUST_GET_PROC(CryptCATAdminAddCatalog
)
133 WINTRUST_GET_PROC(CryptCATAdminRemoveCatalog
)
134 WINTRUST_GET_PROC(CryptCATAdminReleaseCatalogContext
)
135 WINTRUST_GET_PROC(CryptCATOpen
)
136 WINTRUST_GET_PROC(CryptCATCatalogInfoFromContext
)
137 WINTRUST_GET_PROC(CryptCATCDFClose
)
138 WINTRUST_GET_PROC(CryptCATCDFEnumCatAttributes
)
139 WINTRUST_GET_PROC(CryptCATCDFEnumMembersByCDFTagEx
)
140 WINTRUST_GET_PROC(CryptCATCDFOpen
)
141 WINTRUST_GET_PROC(CryptCATEnumerateCatAttr
)
142 WINTRUST_GET_PROC(CryptCATEnumerateMember
)
143 WINTRUST_GET_PROC(CryptCATEnumerateAttr
)
144 WINTRUST_GET_PROC(CryptCATClose
)
146 #undef WINTRUST_GET_PROC
149 static GUID dummy
= {0xdeadbeef,0xdead,0xbeef,{0xde,0xad,0xbe,0xef,0xde,0xad,0xbe,0xef}};
151 static void test_context(void)
155 static GUID unknown
= { 0xC689AABA, 0x8E78, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }}; /* WINTRUST.DLL */
156 CHAR dummydir
[MAX_PATH
];
159 /* When CryptCATAdminAcquireContext is successful it will create
160 * several directories if they don't exist:
162 * ...\system32\CatRoot\{GUID}, this directory holds the .cat files
163 * ...\system32\CatRoot2\{GUID} (WinXP and up), here we find the catalog database for that GUID
165 * Windows Vista uses lowercase catroot and catroot2.
167 * When passed a NULL GUID it will create the following directories although on
168 * WinXP and up these directories are already present when Windows is installed:
170 * ...\system32\CatRoot\{127D0A1D-4EF2-11D1-8608-00C04FC295EE}
171 * ...\system32\CatRoot2\{127D0A1D-4EF2-11D1-8608-00C04FC295EE} (WinXP up)
173 * TODO: Find out what this GUID is/does.
175 * On WinXP and up there is also a TimeStamp file in some of directories that
176 * seem to indicate the last change to the catalog database for that GUID.
178 * On Windows 2000 some files are created/updated:
180 * ...\system32\CatRoot\SYSMAST.cbk
181 * ...\system32\CatRoot\SYSMAST.cbd
182 * ...\system32\CatRoot\{GUID}\CATMAST.cbk
183 * ...\system32\CatRoot\{GUID}\CATMAST.cbd
188 SetLastError(0xdeadbeef);
189 ret
= pCryptCATAdminAcquireContext(NULL
, NULL
, 0);
190 ok(!ret
, "Expected failure\n");
191 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
192 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
195 ret
= pCryptCATAdminAcquireContext(&hca
, NULL
, 0);
196 ok(ret
, "Expected success\n");
197 ok(hca
!= NULL
, "Expected a context handle, got NULL\n");
200 SetLastError(0xdeadbeef);
201 ret
= pCryptCATAdminReleaseContext(NULL
, 0);
202 ok(!ret
, "Expected failure\n");
203 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
204 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
207 SetLastError(0xdeadbeef);
208 ret
= pCryptCATAdminReleaseContext(hca
, 0);
209 ok(ret
, "Expected success, got FALSE with %d\n", GetLastError());
211 /* Try to release a second time */
212 SetLastError(0xdeadbeef);
213 ret
= pCryptCATAdminReleaseContext(hca
, 0);
214 ok(!ret
, "Expected failure\n");
215 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
216 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
218 /* NULL context handle and dummy GUID */
219 SetLastError(0xdeadbeef);
220 ret
= pCryptCATAdminAcquireContext(NULL
, &dummy
, 0);
221 ok(!ret
, "Expected failure\n");
222 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
223 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
225 /* Correct context handle and dummy GUID
227 * The tests run in the past unfortunately made sure that some directories were created.
230 * We don't want to mess too much with these for now so we should delete only the ones
231 * that shouldn't be there like the deadbeef ones. We first have to figure out if it's
232 * save to remove files and directories from CatRoot/CatRoot2.
235 ret
= pCryptCATAdminAcquireContext(&hca
, &dummy
, 0);
236 ok(ret
, "Expected success\n");
237 ok(hca
!= NULL
, "Expected a context handle, got NULL\n");
239 attrs
= GetFileAttributes(catroot
);
240 ok(attrs
!= INVALID_FILE_ATTRIBUTES
, "Expected the CatRoot directory to exist\n");
242 /* Windows creates the GUID directory in capitals */
243 lstrcpyA(dummydir
, catroot
);
244 lstrcatA(dummydir
, "\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF}");
245 attrs
= GetFileAttributes(dummydir
);
246 ok(attrs
!= INVALID_FILE_ATTRIBUTES
,
247 "Expected CatRoot\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF} directory to exist\n");
249 /* Only present on XP or higher. */
250 attrs
= GetFileAttributes(catroot2
);
251 if (attrs
!= INVALID_FILE_ATTRIBUTES
)
253 lstrcpyA(dummydir
, catroot2
);
254 lstrcatA(dummydir
, "\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF}");
255 attrs
= GetFileAttributes(dummydir
);
256 ok(attrs
!= INVALID_FILE_ATTRIBUTES
,
257 "Expected CatRoot2\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF} directory to exist\n");
260 ret
= pCryptCATAdminReleaseContext(hca
, 0);
261 ok(ret
, "Expected success\n");
263 /* Correct context handle and GUID */
264 ret
= pCryptCATAdminAcquireContext(&hca
, &unknown
, 0);
265 ok(ret
, "Expected success\n");
266 ok(hca
!= NULL
, "Expected a context handle, got NULL\n");
268 ret
= pCryptCATAdminReleaseContext(hca
, 0);
269 ok(ret
, "Expected success\n");
271 /* Flags not equal to 0 */
272 ret
= pCryptCATAdminAcquireContext(&hca
, &unknown
, 1);
273 ok(ret
, "Expected success\n");
274 ok(hca
!= NULL
, "Expected a context handle, got NULL\n");
276 ret
= pCryptCATAdminReleaseContext(hca
, 0);
277 ok(ret
, "Expected success\n");
280 /* TODO: Check whether SHA-1 is the algorithm that's always used */
281 static void test_calchash(void)
287 BYTE expectedhash
[20] = {0x3a,0xa1,0x19,0x08,0xec,0xa6,0x0d,0x2e,0x7e,0xcc,0x7a,0xca,0xf5,0xb8,0x2e,0x62,0x6a,0xda,0xf0,0x19};
292 SetLastError(0xdeadbeef);
293 ret
= pCryptCATAdminCalcHashFromFileHandle(NULL
, NULL
, NULL
, 0);
294 ok(!ret
, "Expected failure\n");
295 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
296 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
298 /* NULL filehandle, rest is legal */
299 SetLastError(0xdeadbeef);
300 ret
= pCryptCATAdminCalcHashFromFileHandle(NULL
, &hashsize
, NULL
, 0);
301 ok(!ret
, "Expected failure\n");
302 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
303 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
305 /* Correct filehandle, rest is NULL */
306 file
= CreateFileA(selfname
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
307 SetLastError(0xdeadbeef);
308 ret
= pCryptCATAdminCalcHashFromFileHandle(file
, NULL
, NULL
, 0);
309 ok(!ret
, "Expected failure\n");
310 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
311 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
314 /* All OK, but dwFlags set to 1 */
315 file
= CreateFileA(selfname
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
316 SetLastError(0xdeadbeef);
317 ret
= pCryptCATAdminCalcHashFromFileHandle(file
, &hashsize
, NULL
, 1);
318 ok(!ret
, "Expected failure\n");
319 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
320 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
323 /* All OK, requesting the size of the hash */
324 file
= CreateFileA(selfname
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, NULL
);
325 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFile failed %u\n", GetLastError());
326 SetLastError(0xdeadbeef);
327 ret
= pCryptCATAdminCalcHashFromFileHandle(file
, &hashsize
, NULL
, 0);
328 ok(ret
, "Expected success %u\n", GetLastError());
329 ok(hashsize
== 20," Expected a hash size of 20, got %d\n", hashsize
);
330 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
,
331 "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
334 /* All OK, retrieve the hash
335 * Double the hash buffer to see what happens to the size parameter
337 file
= CreateFileA(selfname
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, NULL
);
339 hash
= HeapAlloc(GetProcessHeap(), 0, hashsize
);
340 SetLastError(0xdeadbeef);
341 ret
= pCryptCATAdminCalcHashFromFileHandle(file
, &hashsize
, hash
, 0);
342 ok(ret
, "Expected success %u\n", GetLastError());
343 ok(hashsize
== 20," Expected a hash size of 20, got %d\n", hashsize
);
344 ok(GetLastError() == ERROR_SUCCESS
,
345 "Expected ERROR_SUCCESS, got %d\n", GetLastError());
347 HeapFree(GetProcessHeap(), 0, hash
);
349 /* Do the same test with a file created and filled by ourselves (and we thus
350 * have a known hash for).
352 GetTempFileNameA(CURR_DIR
, "hsh", 0, temp
);
353 file
= CreateFileA(temp
, GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
354 WriteFile(file
, "Text in this file is needed to create a know hash", 49, &written
, NULL
);
357 /* All OK, first request the size and then retrieve the hash */
358 file
= CreateFileA(temp
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
360 pCryptCATAdminCalcHashFromFileHandle(file
, &hashsize
, NULL
, 0);
361 hash
= HeapAlloc(GetProcessHeap(), 0, hashsize
);
362 SetLastError(0xdeadbeef);
363 ret
= pCryptCATAdminCalcHashFromFileHandle(file
, &hashsize
, hash
, 0);
364 ok(ret
, "Expected success\n");
365 ok(GetLastError() == ERROR_SUCCESS
,
366 "Expected ERROR_SUCCESS, got %d\n", GetLastError());
367 ok(hashsize
== sizeof(expectedhash
) &&
368 !memcmp(hash
, expectedhash
, sizeof(expectedhash
)),
369 "Hashes didn't match\n");
372 HeapFree(GetProcessHeap(), 0, hash
);
376 static DWORD error_area
;
377 static DWORD local_error
;
379 static void WINAPI
cdf_callback(DWORD area
, DWORD error
, WCHAR
* line
)
381 ok(error_area
!= -2, "Didn't expect cdf_callback() to be called (%08x, %08x)\n",
388 static void test_CryptCATCDF_params(void)
390 static WCHAR nonexistent
[] = {'d','e','a','d','b','e','e','f','.','c','d','f',0};
394 if (!pCryptCATCDFOpen
)
396 win_skip("CryptCATCDFOpen is not available\n");
400 SetLastError(0xdeadbeef);
401 catcdf
= pCryptCATCDFOpen(NULL
, NULL
);
402 ok(catcdf
== NULL
, "CryptCATCDFOpen succeeded\n");
404 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
406 SetLastError(0xdeadbeef);
407 catcdf
= pCryptCATCDFOpen(NULL
, cdf_callback
);
408 ok(catcdf
== NULL
, "CryptCATCDFOpen succeeded\n");
410 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
412 /* File doesn't exist */
413 SetLastError(0xdeadbeef);
414 catcdf
= pCryptCATCDFOpen(nonexistent
, cdf_callback
);
415 ok(catcdf
== NULL
, "CryptCATCDFOpen succeeded\n");
417 ok(GetLastError() == ERROR_FILE_NOT_FOUND
, "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
419 SetLastError(0xdeadbeef);
420 ret
= pCryptCATCDFClose(NULL
);
421 ok(!ret
, "Expected failure\n");
423 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
426 SetLastError(0xdeadbeef);
427 ret
= pCryptCATCDFClose(catcdf
);
428 ok(!ret
, "Expected failure\n");
430 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
433 /* FIXME: Once Wine can create catalog files we should use the created catalog file in this test */
434 static void test_CryptCATAdminAddRemoveCatalog(void)
436 static WCHAR basenameW
[] = {'w','i','n','e','t','e','s','t','.','c','a','t',0};
437 static CHAR basename
[] = "winetest.cat";
441 WCHAR tmpfileW
[MAX_PATH
];
442 char tmpfile
[MAX_PATH
];
443 char catfile
[MAX_PATH
], catfilepath
[MAX_PATH
], *p
;
444 WCHAR catfileW
[MAX_PATH
];
446 DWORD error
, written
;
450 if (!pCryptCATAdminRemoveCatalog
)
452 /* NT4 and W2K do have CryptCATAdminAddCatalog !! */
453 win_skip("CryptCATAdminRemoveCatalog is not available\n");
457 if (!GetTempFileNameA(CURR_DIR
, "cat", 0, tmpfile
)) return;
458 DeleteFileA(tmpfile
);
459 file
= CreateFileA(tmpfile
, GENERIC_WRITE
, 0, NULL
, CREATE_NEW
, 0, NULL
);
460 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFileA failed %u\n", GetLastError());
463 ret
= pCryptCATAdminAcquireContext(&hcatadmin
, &dummy
, 0);
464 ok(ret
, "CryptCATAdminAcquireContext failed %u\n", GetLastError());
466 SetLastError(0xdeadbeef);
467 hcatinfo
= pCryptCATAdminAddCatalog(NULL
, NULL
, NULL
, 0);
468 error
= GetLastError();
469 ok(hcatinfo
== NULL
, "CryptCATAdminAddCatalog succeeded\n");
470 ok(error
== ERROR_INVALID_PARAMETER
, "got %u expected ERROR_INVALID_PARAMETER\n", GetLastError());
472 SetLastError(0xdeadbeef);
473 hcatinfo
= pCryptCATAdminAddCatalog(hcatadmin
, NULL
, NULL
, 0);
474 error
= GetLastError();
475 ok(hcatinfo
== NULL
, "CryptCATAdminAddCatalog succeeded\n");
476 ok(error
== ERROR_INVALID_PARAMETER
, "got %u expected ERROR_INVALID_PARAMETER\n", GetLastError());
478 MultiByteToWideChar(0, 0, tmpfile
, -1, tmpfileW
, MAX_PATH
);
480 SetLastError(0xdeadbeef);
481 hcatinfo
= pCryptCATAdminAddCatalog(hcatadmin
, tmpfileW
, basenameW
, 0);
482 error
= GetLastError();
484 ok(hcatinfo
== NULL
, "CryptCATAdminAddCatalog succeeded\n");
485 ok(error
== ERROR_BAD_FORMAT
, "got %u expected ERROR_BAD_FORMAT\n", GetLastError());
488 SetLastError(0xdeadbeef);
489 hcatinfo
= pCryptCATAdminAddCatalog(hcatadmin
, tmpfileW
, basenameW
, 1);
490 error
= GetLastError();
491 ok(hcatinfo
== NULL
, "CryptCATAdminAddCatalog succeeded\n");
492 ok(error
== ERROR_INVALID_PARAMETER
, "got %u expected ERROR_INVALID_PARAMETER\n", GetLastError());
494 SetLastError(0xdeadbeef);
495 hcatinfo
= pCryptCATAdminAddCatalog(hcatadmin
, tmpfileW
, NULL
, 0);
496 error
= GetLastError();
497 ok(hcatinfo
== NULL
, "CryptCATAdminAddCatalog succeeded\n");
498 todo_wine
ok(error
== ERROR_BAD_FORMAT
, "got %u expected ERROR_BAD_FORMAT\n", GetLastError());
500 DeleteFileA(tmpfile
);
501 file
= CreateFileA(tmpfile
, GENERIC_WRITE
, 0, NULL
, CREATE_NEW
, 0, NULL
);
502 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFileA failed %u\n", GetLastError());
503 WriteFile(file
, test_catalog
, sizeof(test_catalog
), &written
, NULL
);
506 /* Unique name will be created */
507 hcatinfo
= pCryptCATAdminAddCatalog(hcatadmin
, tmpfileW
, NULL
, 0);
508 todo_wine
ok(hcatinfo
!= NULL
, "CryptCATAdminAddCatalog failed %u\n", GetLastError());
510 info
.cbStruct
= sizeof(info
);
511 info
.wszCatalogFile
[0] = 0;
512 ret
= pCryptCATCatalogInfoFromContext(hcatinfo
, &info
, 0);
515 ok(ret
, "CryptCATCatalogInfoFromContext failed %u\n", GetLastError());
516 ok(info
.wszCatalogFile
[0] != 0, "Expected a filename\n");
518 WideCharToMultiByte(CP_ACP
, 0, info
.wszCatalogFile
, -1, catfile
, MAX_PATH
, 0, 0);
519 if ((p
= strrchr(catfile
, '\\'))) p
++;
520 memset(catfileW
, 0, sizeof(catfileW
));
521 MultiByteToWideChar(0, 0, p
, -1, catfileW
, MAX_PATH
);
523 /* Set the file attributes so we can check what happens with them during the 'copy' */
524 attrs
= FILE_ATTRIBUTE_READONLY
;
525 ret
= SetFileAttributesA(tmpfile
, attrs
);
526 ok(ret
, "SetFileAttributesA failed : %u\n", GetLastError());
528 /* winetest.cat will be created */
529 hcatinfo
= pCryptCATAdminAddCatalog(hcatadmin
, tmpfileW
, basenameW
, 0);
530 ok(hcatinfo
!= NULL
, "CryptCATAdminAddCatalog failed %u\n", GetLastError());
532 lstrcpyA(catfilepath
, catroot
);
533 lstrcatA(catfilepath
, "\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF}\\winetest.cat");
534 attrs
= GetFileAttributes(catfilepath
);
535 ok(attrs
!= INVALID_FILE_ATTRIBUTES
, "Expected %s to exist\n", catfilepath
);
537 ok(attrs
== FILE_ATTRIBUTE_SYSTEM
||
538 attrs
== (FILE_ATTRIBUTE_NOT_CONTENT_INDEXED
| FILE_ATTRIBUTE_SYSTEM
), /* Vista */
539 "File has wrong attributes : %08x\n", attrs
);
541 info
.cbStruct
= sizeof(info
);
542 info
.wszCatalogFile
[0] = 0;
543 ret
= pCryptCATCatalogInfoFromContext(hcatinfo
, &info
, 0);
544 ok(ret
, "CryptCATCatalogInfoFromContext failed %u\n", GetLastError());
545 ok(info
.wszCatalogFile
[0] != 0, "Expected a filename\n");
546 WideCharToMultiByte(CP_ACP
, 0, info
.wszCatalogFile
, -1, catfile
, MAX_PATH
, 0, 0);
547 if ((p
= strrchr(catfile
, '\\'))) p
++;
548 ok(!lstrcmpA(basename
, p
), "Expected %s, got %s\n", basename
, p
);
550 ret
= pCryptCATAdminReleaseCatalogContext(hcatadmin
, hcatinfo
, 0);
551 ok(ret
, "CryptCATAdminReleaseCatalogContext failed %u\n", GetLastError());
553 /* Remove the catalog file with the unique name */
554 ret
= pCryptCATAdminRemoveCatalog(hcatadmin
, catfileW
, 0);
555 ok(ret
, "CryptCATAdminRemoveCatalog failed %u\n", GetLastError());
557 /* Remove the winetest.cat catalog file, first with the full path. This should not succeed
558 * according to MSDN */
559 ret
= pCryptCATAdminRemoveCatalog(hcatadmin
, info
.wszCatalogFile
, 0);
560 ok(ret
, "CryptCATAdminRemoveCatalog failed %u\n", GetLastError());
561 /* The call succeeded with the full path but the file is not removed */
562 attrs
= GetFileAttributes(catfilepath
);
563 ok(attrs
!= INVALID_FILE_ATTRIBUTES
, "Expected %s to exist\n", catfilepath
);
564 /* Given only the filename the file is removed */
565 ret
= pCryptCATAdminRemoveCatalog(hcatadmin
, basenameW
, 0);
566 ok(ret
, "CryptCATAdminRemoveCatalog failed %u\n", GetLastError());
567 attrs
= GetFileAttributes(catfilepath
);
568 ok(attrs
== INVALID_FILE_ATTRIBUTES
, "Expected %s to be removed\n", catfilepath
);
570 ret
= pCryptCATAdminReleaseContext(hcatadmin
, 0);
571 ok(ret
, "CryptCATAdminReleaseContext failed %u\n", GetLastError());
573 /* Set the attributes so we can delete the file */
574 attrs
= FILE_ATTRIBUTE_NORMAL
;
575 ret
= SetFileAttributesA(tmpfile
, attrs
);
576 DeleteFileA(tmpfile
);
579 static void test_catalog_properties(CHAR
*catfile
, int attributes
, int members
)
581 static const GUID subject
= {0xde351a42,0x8e59,0x11d0,{0x8c,0x47,0x00,0xc0,0x4f,0xc2,0x95,0xee}};
585 CRYPTCATATTRIBUTE
*attr
;
586 char catalog
[MAX_PATH
];
587 WCHAR catalogW
[MAX_PATH
];
590 int attrcount
= 0, membercount
= 0;
592 /* FIXME: Wine can't create catalog files out of catalog definition files yet. Remove this piece
595 attrs
= GetFileAttributesA(catfile
);
596 if (attrs
== INVALID_FILE_ATTRIBUTES
)
601 trace("Creating the catalog file\n");
602 if (!GetTempFileNameA(CURR_DIR
, "cat", 0, catalog
)) return;
603 file
= CreateFileA(catalog
, GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
604 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFileA failed %u\n", GetLastError());
605 WriteFile(file
, test_catalog
, sizeof(test_catalog
), &written
, NULL
);
610 MultiByteToWideChar(CP_ACP
, 0, catalog
, -1, catalogW
, MAX_PATH
);
614 MultiByteToWideChar(CP_ACP
, 0, catfile
, -1, catalogW
, MAX_PATH
);
618 hcat
= pCryptCATOpen(NULL
, 0, 0, 0, 0);
619 ok(hcat
== INVALID_HANDLE_VALUE
, "CryptCATOpen succeeded\n");
621 hcat
= pCryptCATOpen(catalogW
, 0, 0, 0, 0);
622 if (hcat
== INVALID_HANDLE_VALUE
&& members
== 0)
624 win_skip("CryptCATOpen on W2K can't handle catalog files with no members\n");
627 ok(hcat
!= INVALID_HANDLE_VALUE
, "CryptCATOpen failed %u\n", GetLastError());
629 m
= pCryptCATEnumerateMember(NULL
, NULL
);
630 ok(m
== NULL
, "CryptCATEnumerateMember succeeded\n");
633 while ((m
= pCryptCATEnumerateMember(hcat
, m
)))
635 ok(m
->cbStruct
== sizeof(CRYPTCATMEMBER
), "unexpected size %u\n", m
->cbStruct
);
636 todo_wine
ok(!lstrcmpW(m
->pwszReferenceTag
, hashmeW
), "unexpected tag\n");
637 ok(!memcmp(&m
->gSubjectType
, &subject
, sizeof(subject
)), "guid differs\n");
638 ok(!m
->fdwMemberFlags
, "got %x expected 0\n", m
->fdwMemberFlags
);
639 ok(m
->dwCertVersion
== 0x200, "got %x expected 0x200\n", m
->dwCertVersion
);
640 ok(!m
->dwReserved
, "got %x expected 0\n", m
->dwReserved
);
641 ok(m
->hReserved
== NULL
, "got %p expected NULL\n", m
->hReserved
);
643 attr
= pCryptCATEnumerateAttr(hcat
, m
, NULL
);
644 ok(attr
== NULL
, "CryptCATEnumerateAttr succeeded\n");
648 ok(membercount
== members
, "Expected %d members, got %d\n", members
, membercount
);
650 attr
= pCryptCATEnumerateAttr(NULL
, NULL
, NULL
);
651 ok(attr
== NULL
, "CryptCATEnumerateAttr succeeded\n");
653 attr
= pCryptCATEnumerateAttr(hcat
, NULL
, NULL
);
654 ok(attr
== NULL
, "CryptCATEnumerateAttr succeeded\n");
657 while ((attr
= pCryptCATEnumerateCatAttr(hcat
, attr
)))
659 ok(!lstrcmpW(attr
->pwszReferenceTag
, attr1W
) ||
660 !lstrcmpW(attr
->pwszReferenceTag
, attr2W
),
661 "Expected 'attr1' or 'attr2'\n");
666 ok(attrcount
== attributes
, "Expected %d catalog attributes, got %d\n", attributes
, attrcount
);
668 ret
= pCryptCATClose(hcat
);
669 ok(ret
, "CryptCATClose failed\n");
670 if (catalog
[0]) DeleteFileA( catalog
);
673 static void test_create_catalog_file(void)
675 static CHAR catfileA
[] = "winetest.cat";
676 static CHAR cdffileA
[] = "winetest.cdf";
677 static WCHAR cdffileW
[] = {'w','i','n','e','t','e','s','t','.','c','d','f',0};
679 CRYPTCATATTRIBUTE
*catattr
;
680 CRYPTCATMEMBER
*catmember
;
682 DWORD written
, attrs
;
685 int attrcount
, membercount
;
687 if (!pCryptCATCDFOpen
)
689 win_skip("CryptCATCDFOpen is not available\n");
693 /* Create the cdf file */
694 file
= CreateFileA(cdffileA
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
695 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFileA failed %u\n", GetLastError());
696 WriteFile(file
, test_cdf
, sizeof(test_cdf
) - 1, &written
, NULL
);
699 /* Don't enumerate attributes and members */
700 trace("No attribs and members\n");
701 SetLastError(0xdeadbeef);
702 catcdf
= pCryptCATCDFOpen(cdffileW
, NULL
);
705 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
706 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
709 ret
= pCryptCATCDFClose(catcdf
);
712 ok(ret
, "Expected success\n");
713 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
716 attrs
= GetFileAttributesA(catfileA
);
718 ok(attrs
!= INVALID_FILE_ATTRIBUTES
, "Expected the catalog file to exist\n");
720 test_catalog_properties(catfileA
, 0, 0);
721 DeleteFileA(catfileA
);
723 /* Only enumerate the attributes */
724 trace("Only attributes\n");
725 attrcount
= membercount
= 0;
726 catcdf
= pCryptCATCDFOpen(cdffileW
, NULL
);
729 while ((catattr
= pCryptCATCDFEnumCatAttributes(catcdf
, catattr
, NULL
)))
731 ok(!lstrcmpW(catattr
->pwszReferenceTag
, attr1W
) ||
732 !lstrcmpW(catattr
->pwszReferenceTag
, attr2W
),
733 "Expected 'attr1' or 'attr2'\n");
738 ok(attrcount
== 2, "Expected 2 attributes, got %d\n", attrcount
);
740 pCryptCATCDFClose(catcdf
);
741 /* Even though the resulting catalog file shows the attributes, they will not be enumerated */
742 test_catalog_properties(catfileA
, 0, 0);
743 DeleteFileA(catfileA
);
745 /* Only enumerate the members */
746 trace("Only members\n");
747 attrcount
= membercount
= 0;
748 catcdf
= pCryptCATCDFOpen(cdffileW
, NULL
);
752 while ((catmembertag
= pCryptCATCDFEnumMembersByCDFTagEx(catcdf
, catmembertag
, NULL
, &catmember
, FALSE
, NULL
)))
754 ok(!lstrcmpW(catmembertag
, hashmeW
), "Expected 'hashme'\n");
758 ok(membercount
== 1, "Expected 1 member, got %d\n", membercount
);
760 pCryptCATCDFClose(catcdf
);
761 test_catalog_properties(catfileA
, 0, 1);
762 DeleteFileA(catfileA
);
764 /* Enumerate members and attributes */
765 trace("Attributes and members\n");
766 attrcount
= membercount
= 0;
767 catcdf
= pCryptCATCDFOpen(cdffileW
, NULL
);
770 while ((catattr
= pCryptCATCDFEnumCatAttributes(catcdf
, catattr
, NULL
)))
773 ok(attrcount
== 2, "Expected 2 attributes, got %d\n", attrcount
);
777 while ((catmembertag
= pCryptCATCDFEnumMembersByCDFTagEx(catcdf
, catmembertag
, NULL
, &catmember
, FALSE
, NULL
)))
780 ok(membercount
== 1, "Expected 1 member, got %d\n", membercount
);
782 pCryptCATCDFClose(catcdf
);
783 test_catalog_properties(catfileA
, 2, 1);
784 DeleteFileA(catfileA
);
786 DeleteFileA(cdffileA
);
789 static void create_cdf_file(const CHAR
*filename
, const CHAR
*contents
)
794 file
= CreateFileA(filename
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
795 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFileA failed %u\n", GetLastError());
796 WriteFile(file
, contents
, lstrlenA(contents
), &written
, NULL
);
800 #define CHECK_EXPECT(a, b) \
802 ok(a == error_area, "Expected %08x, got %08x\n", a, error_area); \
803 ok(b == local_error, "Expected %08x, got %08x\n", b, local_error); \
806 /* Clear the variables (can't use 0) */
807 #define CLEAR_EXPECT \
808 error_area = local_error = -1
810 /* Set both variables so the callback routine can check if a call to it was unexpected */
811 #define SET_UNEXPECTED \
812 error_area = local_error = -2
814 static void test_cdf_parsing(void)
816 static CHAR catfileA
[] = "tempfile.cat";
817 static CHAR cdffileA
[] = "tempfile.cdf";
818 static WCHAR cdffileW
[] = {'t','e','m','p','f','i','l','e','.','c','d','f',0};
819 CHAR cdf_contents
[4096];
821 CRYPTCATATTRIBUTE
*catattr
;
822 CRYPTCATMEMBER
*catmember
;
825 if (!pCryptCATCDFOpen
)
827 win_skip("CryptCATCDFOpen is not available\n");
832 DeleteFileA(cdffileA
);
833 create_cdf_file(cdffileA
, "");
836 SetLastError(0xdeadbeef);
837 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
839 CHECK_EXPECT(CRYPTCAT_E_AREA_HEADER
, CRYPTCAT_E_CDF_TAGNOTFOUND
);
840 ok(catcdf
== NULL
, "CryptCATCDFOpen succeeded\n");
842 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
843 DeleteFileA(cdffileA
);
844 ok(!DeleteFileA(catfileA
), "Didn't expect a catalog file to be created\n");
846 /* Just the header */
847 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
848 create_cdf_file(cdffileA
, cdf_contents
);
851 SetLastError(0xdeadbeef);
852 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
853 ok(catcdf
== NULL
, "CryptCATCDFOpen succeeded\n");
855 ok(GetLastError() == ERROR_SHARING_VIOLATION
||
856 broken(GetLastError() == ERROR_SUCCESS
), /* win9x */
857 "Expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
858 DeleteFileA(cdffileA
);
860 /* Header and member only */
861 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
862 lstrcatA(cdf_contents
, "[CatalogFiles]\r\n");
863 lstrcatA(cdf_contents
, "hashme=.\\tempfile.cdf\r\n");
864 create_cdf_file(cdffileA
, cdf_contents
);
867 SetLastError(0xdeadbeef);
868 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
869 ok(catcdf
== NULL
, "CryptCATCDFOpen succeeded\n");
871 ok(GetLastError() == ERROR_SHARING_VIOLATION
||
872 broken(GetLastError() == ERROR_SUCCESS
), /* win9x */
873 "Expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
874 DeleteFileA(cdffileA
);
875 ok(!DeleteFileA(catfileA
), "Didn't expect a catalog file to be created\n");
877 /* Header and Name (no value) */
878 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
879 lstrcatA(cdf_contents
, "Name=\r\n");
880 create_cdf_file(cdffileA
, cdf_contents
);
883 SetLastError(0xdeadbeef);
884 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
885 ok(catcdf
== NULL
, "CryptCATCDFOpen succeeded\n");
887 ok(GetLastError() == ERROR_SHARING_VIOLATION
||
888 broken(GetLastError() == ERROR_SUCCESS
), /* win9x */
889 "Expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
890 DeleteFileA(cdffileA
);
891 ok(!DeleteFileA(catfileA
), "Didn't expect a catalog file to be created\n");
893 /* Header and Name */
894 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
895 lstrcatA(cdf_contents
, "Name=tempfile.cat\r\n");
896 create_cdf_file(cdffileA
, cdf_contents
);
899 SetLastError(0xdeadbeef);
900 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
903 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
904 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
906 pCryptCATCDFClose(catcdf
);
907 DeleteFileA(cdffileA
);
909 ok(DeleteFileA(catfileA
), "Expected a catalog file to be created\n");
911 /* Header and nonexistent member */
912 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
913 lstrcatA(cdf_contents
, "Name=tempfile.cat\r\n");
914 lstrcatA(cdf_contents
, "[CatalogFiles]\r\n");
915 lstrcatA(cdf_contents
, "hashme=.\\deadbeef.cdf\r\n");
916 create_cdf_file(cdffileA
, cdf_contents
);
919 SetLastError(0xdeadbeef);
920 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
923 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
924 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
926 /* Loop through the members */
930 while ((catmembertag
= pCryptCATCDFEnumMembersByCDFTagEx(catcdf
, catmembertag
, cdf_callback
, &catmember
, FALSE
, NULL
))) ;
932 CHECK_EXPECT(CRYPTCAT_E_AREA_MEMBER
, CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND
);
933 pCryptCATCDFClose(catcdf
);
934 DeleteFileA(cdffileA
);
936 ok(DeleteFileA(catfileA
), "Expected a catalog file to be created\n");
938 /* Header, correct member but no explicit newline */
939 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
940 lstrcatA(cdf_contents
, "Name=tempfile.cat\r\n");
941 lstrcatA(cdf_contents
, "[CatalogFiles]\r\n");
942 lstrcatA(cdf_contents
, "hashme=.\\tempfile.cdf\r");
943 create_cdf_file(cdffileA
, cdf_contents
);
946 SetLastError(0xdeadbeef);
947 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
950 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
951 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
953 /* Loop through the members */
957 while ((catmembertag
= pCryptCATCDFEnumMembersByCDFTagEx(catcdf
, catmembertag
, cdf_callback
, &catmember
, FALSE
, NULL
))) ;
959 CHECK_EXPECT(CRYPTCAT_E_AREA_MEMBER
, CRYPTCAT_E_CDF_MEMBER_FILE_PATH
);
960 pCryptCATCDFClose(catcdf
);
961 DeleteFileA(cdffileA
);
963 ok(DeleteFileA(catfileA
), "Expected a catalog file to be created\n");
965 /* Header and 2 duplicate members */
966 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
967 lstrcatA(cdf_contents
, "Name=tempfile.cat\r\n");
968 lstrcatA(cdf_contents
, "[CatalogFiles]\r\n");
969 lstrcatA(cdf_contents
, "hashme=.\\tempfile.cdf\r\n");
970 lstrcatA(cdf_contents
, "hashme=.\\tempfile.cdf\r\n");
971 create_cdf_file(cdffileA
, cdf_contents
);
974 SetLastError(0xdeadbeef);
975 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
978 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
979 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
981 /* Loop through the members */
985 while ((catmembertag
= pCryptCATCDFEnumMembersByCDFTagEx(catcdf
, catmembertag
, cdf_callback
, &catmember
, FALSE
, NULL
))) ;
986 pCryptCATCDFClose(catcdf
);
987 test_catalog_properties(catfileA
, 0, 1);
988 DeleteFileA(cdffileA
);
990 ok(DeleteFileA(catfileA
), "Expected a catalog file to be created\n");
992 /* Wrong attribute */
993 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
994 lstrcatA(cdf_contents
, "Name=tempfile.cat\r\n");
995 lstrcatA(cdf_contents
, "CATATTR1=0x10010001:attr1\r\n");
996 create_cdf_file(cdffileA
, cdf_contents
);
999 SetLastError(0xdeadbeef);
1000 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
1003 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
1004 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1006 /* Loop through the attributes */
1009 while ((catattr
= pCryptCATCDFEnumCatAttributes(catcdf
, catattr
, cdf_callback
))) ;
1011 CHECK_EXPECT(CRYPTCAT_E_AREA_ATTRIBUTE
, CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES
);
1012 pCryptCATCDFClose(catcdf
);
1013 DeleteFileA(cdffileA
);
1015 ok(DeleteFileA(catfileA
), "Expected a catalog file to be created\n");
1017 /* Two identical attributes */
1018 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
1019 lstrcatA(cdf_contents
, "Name=tempfile.cat\r\n");
1020 lstrcatA(cdf_contents
, "CATATTR1=0x10010001:attr1:value1\r\n");
1021 lstrcatA(cdf_contents
, "CATATTR1=0x10010001:attr1:value1\r\n");
1022 lstrcatA(cdf_contents
, "[CatalogFiles]\r\n");
1023 lstrcatA(cdf_contents
, "hashme=.\\tempfile.cdf\r\n");
1024 create_cdf_file(cdffileA
, cdf_contents
);
1027 SetLastError(0xdeadbeef);
1028 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
1031 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
1032 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1034 /* Loop through the members */
1037 catmembertag
= NULL
;
1038 while ((catmembertag
= pCryptCATCDFEnumMembersByCDFTagEx(catcdf
, catmembertag
, cdf_callback
, &catmember
, FALSE
, NULL
))) ;
1039 /* Loop through the attributes */
1042 while ((catattr
= pCryptCATCDFEnumCatAttributes(catcdf
, catattr
, cdf_callback
))) ;
1043 pCryptCATCDFClose(catcdf
);
1044 test_catalog_properties(catfileA
, 1, 1);
1045 DeleteFileA(cdffileA
);
1047 ok(DeleteFileA(catfileA
), "Expected a catalog file to be created\n");
1049 /* Two different attribute values with the same tag */
1050 lstrcpyA(cdf_contents
, "[CatalogHeader]\r\n");
1051 lstrcatA(cdf_contents
, "Name=tempfile.cat\r\n");
1052 lstrcatA(cdf_contents
, "CATATTR1=0x10010001:attr1:value1\r\n");
1053 lstrcatA(cdf_contents
, "CATATTR1=0x10010001:attr2:value2\r\n");
1054 lstrcatA(cdf_contents
, "[CatalogFiles]\r\n");
1055 lstrcatA(cdf_contents
, "hashme=.\\tempfile.cdf\r\n");
1056 create_cdf_file(cdffileA
, cdf_contents
);
1059 SetLastError(0xdeadbeef);
1060 catcdf
= pCryptCATCDFOpen(cdffileW
, cdf_callback
);
1063 ok(catcdf
!= NULL
, "CryptCATCDFOpen failed\n");
1064 ok(GetLastError() == ERROR_SUCCESS
, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1066 /* Loop through the members */
1069 catmembertag
= NULL
;
1070 while ((catmembertag
= pCryptCATCDFEnumMembersByCDFTagEx(catcdf
, catmembertag
, cdf_callback
, &catmember
, FALSE
, NULL
))) ;
1071 /* Loop through the attributes */
1074 while ((catattr
= pCryptCATCDFEnumCatAttributes(catcdf
, catattr
, cdf_callback
))) ;
1075 pCryptCATCDFClose(catcdf
);
1076 test_catalog_properties(catfileA
, 1, 1);
1077 DeleteFileA(cdffileA
);
1079 ok(DeleteFileA(catfileA
), "Expected a catalog file to be created\n");
1086 char sysdir
[MAX_PATH
];
1090 if (!pCryptCATAdminAcquireContext
)
1092 win_skip("CryptCATAdmin functions are not available\n");
1096 GetSystemDirectoryA(sysdir
, MAX_PATH
);
1097 lstrcpyA(catroot
, sysdir
);
1098 lstrcatA(catroot
, "\\CatRoot");
1099 lstrcpyA(catroot2
, sysdir
);
1100 lstrcatA(catroot2
, "\\CatRoot2");
1102 myARGC
= winetest_get_mainargs(&myARGV
);
1103 strcpy(selfname
, myARGV
[0]);
1105 GetCurrentDirectoryA(MAX_PATH
, CURR_DIR
);
1109 /* Parameter checking only */
1110 test_CryptCATCDF_params();
1111 /* Test the parsing of a cdf file */
1113 /* Create a catalog file out of our own catalog definition file */
1114 test_create_catalog_file();
1115 test_CryptCATAdminAddRemoveCatalog();