1 /*
2  * Unit tests for SetupIterateCabinet
3  *
4  * Copyright 2007 Hans Leidekker
5  * Copyright 2010 Andrew Nguyen
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21 
22 #include <stdarg.h>
23 
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wingdi.h"
27 #include "winuser.h"
28 #include "winreg.h"
29 #include "setupapi.h"
30 #include "wine/test.h"
31 
32 static const BYTE comp_cab_zip_multi[] = {
33     0x4d, 0x53, 0x43, 0x46, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
34     0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00,
35     0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00,
36     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x38, 0xf0, 0x48, 0x20, 0x00, 0x74, 0x72, 0x69, 0x73,
37     0x74, 0x72, 0x61, 0x6d, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd1,
38     0x38, 0xf0, 0x48, 0x20, 0x00, 0x77, 0x69, 0x6e, 0x65, 0x00, 0x08, 0x00, 0x00, 0x00, 0x18, 0x00,
39     0x00, 0x00, 0x00, 0x00, 0xd1, 0x38, 0xf0, 0x48, 0x20, 0x00, 0x73, 0x68, 0x61, 0x6e, 0x64, 0x79,
40     0x00, 0x67, 0x2c, 0x03, 0x85, 0x23, 0x00, 0x20, 0x00, 0x43, 0x4b, 0xcb, 0x49, 0x2c, 0x2d, 0x4a,
41     0xcd, 0x4b, 0x4e, 0xe5, 0xe5, 0x2a, 0xcd, 0x4b, 0xce, 0xcf, 0x2d, 0x28, 0x4a, 0x2d, 0x2e, 0x4e,
42     0x4d, 0xe1, 0xe5, 0x2a, 0x2e, 0x49, 0x2d, 0xca, 0x03, 0x8a, 0x02, 0x00
43 };
44 
45 static const WCHAR docW[] = {'d','o','c',0};
46 
47 static void create_source_fileA(LPSTR filename, const BYTE *data, DWORD size)
48 {
49     HANDLE handle;
50     DWORD written;
51 
52     handle = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
53                          FILE_ATTRIBUTE_NORMAL, NULL);
54     WriteFile(handle, data, size, &written, NULL);
55     CloseHandle(handle);
56 }
57 
58 static void create_source_fileW(LPWSTR filename, const BYTE *data, DWORD size)
59 {
60     HANDLE handle;
61     DWORD written;
62 
63     handle = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
64                          FILE_ATTRIBUTE_NORMAL, NULL);
65     WriteFile(handle, data, size, &written, NULL);
66     CloseHandle(handle);
67 }
68 
69 static UINT CALLBACK dummy_callbackA(PVOID Context, UINT Notification,
70                                      UINT_PTR Param1, UINT_PTR Param2)
71 {
72     ok(0, "Received unexpected notification (%p, %u, %lu, %lu)\n", Context,
73        Notification, Param1, Param2);
74     return 0;
75 }
76 
77 static UINT CALLBACK dummy_callbackW(PVOID Context, UINT Notification,
78                                      UINT_PTR Param1, UINT_PTR Param2)
79 {
80     ok(0, "Received unexpected notification (%p, %u, %lu, %lu)\n", Context,
81        Notification, Param1, Param2);
82     return 0;
83 }
84 
85 static void test_invalid_parametersA(void)
86 {
87     BOOL ret;
88     char source[MAX_PATH], temp[MAX_PATH];
89     int i;
90 
91     const struct
92     {
93         PCSTR CabinetFile;
94         PSP_FILE_CALLBACK_A MsgHandler;
95         DWORD expected_lasterror;
96         int todo_lasterror;
97     } invalid_parameters[] =
98     {
99         {NULL,                  NULL,            ERROR_INVALID_PARAMETER},
100         {NULL,                  dummy_callbackA, ERROR_INVALID_PARAMETER},
101         {"c:\\nonexistent.cab", NULL,            ERROR_FILE_NOT_FOUND},
102         {"c:\\nonexistent.cab", dummy_callbackA, ERROR_FILE_NOT_FOUND},
103         {source,                NULL,            ERROR_INVALID_DATA, 1},
104         {source,                dummy_callbackA, ERROR_INVALID_DATA, 1},
105     };
106 
107     GetTempPathA(sizeof(temp), temp);
108     GetTempFileNameA(temp, "doc", 0, source);
109 
110     create_source_fileA(source, NULL, 0);
111 
112     for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); i++)
113     {
114         SetLastError(0xdeadbeef);
115         ret = SetupIterateCabinetA(invalid_parameters[i].CabinetFile, 0,
116                                    invalid_parameters[i].MsgHandler, NULL);
117         ok(!ret, "[%d] Expected SetupIterateCabinetA to return 0, got %d\n", i, ret);
118         todo_wine_if (invalid_parameters[i].todo_lasterror)
119             ok(GetLastError() == invalid_parameters[i].expected_lasterror,
120                "[%d] Expected GetLastError() to return %u, got %u\n",
121                i, invalid_parameters[i].expected_lasterror, GetLastError());
122     }
123 
124     SetLastError(0xdeadbeef);
125     ret = SetupIterateCabinetA("", 0, NULL, NULL);
126     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
127     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
128        GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x/NT4/Win2k */
129        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
130        GetLastError());
131 
132     SetLastError(0xdeadbeef);
133     ret = SetupIterateCabinetA("", 0, dummy_callbackA, NULL);
134     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
135     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
136        GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x/NT4/Win2k */
137        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
138        GetLastError());
139 
140     DeleteFileA(source);
141 }
142 
143 static void test_invalid_parametersW(void)
144 {
145     static const WCHAR nonexistentW[] = {'c',':','\\','n','o','n','e','x','i','s','t','e','n','t','.','c','a','b',0};
146     static const WCHAR emptyW[] = {0};
147 
148     BOOL ret;
149     WCHAR source[MAX_PATH], temp[MAX_PATH];
150     int i;
151 
152     const struct
153     {
154         PCWSTR CabinetFile;
155         PSP_FILE_CALLBACK_W MsgHandler;
156         DWORD expected_lasterror;
157         int todo_lasterror;
158     } invalid_parameters[] =
159     {
160         {nonexistentW, NULL,            ERROR_FILE_NOT_FOUND},
161         {nonexistentW, dummy_callbackW, ERROR_FILE_NOT_FOUND},
162         {source,       NULL,            ERROR_INVALID_DATA, 1},
163         {source,       dummy_callbackW, ERROR_INVALID_DATA, 1},
164     };
165 
166     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
167     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
168     {
169         win_skip("SetupIterateCabinetW is not available\n");
170         return;
171     }
172 
173     GetTempPathW(sizeof(temp)/sizeof(WCHAR), temp);
174     GetTempFileNameW(temp, docW, 0, source);
175 
176     create_source_fileW(source, NULL, 0);
177 
178     for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); i++)
179     {
180         SetLastError(0xdeadbeef);
181         ret = SetupIterateCabinetW(invalid_parameters[i].CabinetFile, 0,
182                                    invalid_parameters[i].MsgHandler, NULL);
183         ok(!ret, "[%d] Expected SetupIterateCabinetW to return 0, got %d\n", i, ret);
184         todo_wine_if (invalid_parameters[i].todo_lasterror)
185             ok(GetLastError() == invalid_parameters[i].expected_lasterror,
186                "[%d] Expected GetLastError() to return %u, got %u\n",
187                i, invalid_parameters[i].expected_lasterror, GetLastError());
188     }
189 
190     SetLastError(0xdeadbeef);
191     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
192     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
193     ok(GetLastError() == ERROR_INVALID_PARAMETER ||
194        GetLastError() == ERROR_NOT_ENOUGH_MEMORY, /* Vista/Win2k8 */
195        "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
196        GetLastError());
197 
198     SetLastError(0xdeadbeef);
199     ret = SetupIterateCabinetW(NULL, 0, dummy_callbackW, NULL);
200     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
201     ok(GetLastError() == ERROR_INVALID_PARAMETER ||
202        GetLastError() == ERROR_NOT_ENOUGH_MEMORY, /* Vista/Win2k8 */
203        "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
204        GetLastError());
205 
206     SetLastError(0xdeadbeef);
207     ret = SetupIterateCabinetW(emptyW, 0, NULL, NULL);
208     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
209     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
210        GetLastError() == ERROR_FILE_NOT_FOUND, /* NT4/Win2k */
211        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
212        GetLastError());
213 
214     SetLastError(0xdeadbeef);
215     ret = SetupIterateCabinetW(emptyW, 0, dummy_callbackW, NULL);
216     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
217     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
218        GetLastError() == ERROR_FILE_NOT_FOUND, /* NT4/Win2k */
219        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
220        GetLastError());
221 
222     DeleteFileW(source);
223 }
224 
225 static UINT CALLBACK crash_callbackA(PVOID Context, UINT Notification,
226                                      UINT_PTR Param1, UINT_PTR Param2)
227 {
228     *(volatile char*)0 = 2;
229     return 0;
230 }
231 
232 static UINT CALLBACK crash_callbackW(PVOID Context, UINT Notification,
233                                      UINT_PTR Param1, UINT_PTR Param2)
234 {
235     *(volatile char*)0 = 2;
236     return 0;
237 }
238 
239 static void test_invalid_callbackA(void)
240 {
241     BOOL ret;
242     char source[MAX_PATH], temp[MAX_PATH];
243 
244     GetTempPathA(sizeof(temp), temp);
245     GetTempFileNameA(temp, "doc", 0, source);
246 
247     create_source_fileA(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
248 
249     SetLastError(0xdeadbeef);
250     ret = SetupIterateCabinetA(source, 0, NULL, NULL);
251     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
252     ok(GetLastError() == ERROR_INVALID_DATA,
253        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
254        GetLastError());
255 
256     SetLastError(0xdeadbeef);
257     ret = SetupIterateCabinetA(source, 0, crash_callbackA, NULL);
258     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
259     ok(GetLastError() == ERROR_INVALID_DATA,
260        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
261        GetLastError());
262 
263     DeleteFileA(source);
264 }
265 
266 static void test_invalid_callbackW(void)
267 {
268     BOOL ret;
269     WCHAR source[MAX_PATH], temp[MAX_PATH];
270 
271     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
272     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
273     {
274         win_skip("SetupIterateCabinetW is not available\n");
275         return;
276     }
277 
278     GetTempPathW(sizeof(temp)/sizeof(WCHAR), temp);
279     GetTempFileNameW(temp, docW, 0, source);
280 
281     create_source_fileW(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
282 
283     SetLastError(0xdeadbeef);
284     ret = SetupIterateCabinetW(source, 0, NULL, NULL);
285     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
286     ok(GetLastError() == ERROR_INVALID_DATA,
287        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
288        GetLastError());
289 
290     SetLastError(0xdeadbeef);
291     ret = SetupIterateCabinetW(source, 0, crash_callbackW, NULL);
292     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
293     ok(GetLastError() == ERROR_INVALID_DATA,
294        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
295        GetLastError());
296 
297     DeleteFileW(source);
298 }
299 
300 static const char *expected_files[] = {"tristram", "wine", "shandy"};
301 
302 struct contextA
303 {
304     int count;
305     const char *cabinet;
306     const char *target;
307 };
308 
309 static UINT CALLBACK simple_callbackA(PVOID Context, UINT Notification,
310                                       UINT_PTR Param1, UINT_PTR Param2)
311 {
312     static int index;
313     struct contextA *ctx = Context;
314 
315     switch (Notification)
316     {
317     case SPFILENOTIFY_CABINETINFO:
318     {
319         CABINET_INFO_A *info = (CABINET_INFO_A *)Param1;
320 
321         ok(!strcmp(info->CabinetFile, ""),
322            "Expected empty CabinetFile, got \"%s\"\n", info->CabinetFile);
323 
324         index = 0;
325         return NO_ERROR;
326     }
327     case SPFILENOTIFY_FILEINCABINET:
328     {
329         FILE_IN_CABINET_INFO_A *info = (FILE_IN_CABINET_INFO_A *)Param1;
330         const char *cabinet_file = (const char *)Param2;
331 
332         ctx->count++;
333 
334         if (index < sizeof(expected_files)/sizeof(char *))
335         {
336             ok(!strcmp(expected_files[index], info->NameInCabinet),
337                "[%d] Expected file \"%s\", got \"%s\"\n",
338                index, expected_files[index], info->NameInCabinet);
339             ok(!strcmp(ctx->cabinet, cabinet_file),
340                "[%d] Expected cabinet \"%s\", got \"%s\"\n",
341                index, ctx->cabinet, cabinet_file);
342 
343             strcpy(info->FullTargetName, ctx->target);
344             return FILEOP_DOIT;
345         }
346         else
347         {
348             ok(0, "Unexpectedly enumerated more than number of files in cabinet, index = %d\n", index);
349             return FILEOP_ABORT;
350         }
351     }
352     case SPFILENOTIFY_FILEEXTRACTED:
353     {
354         FILEPATHS_A *info = (FILEPATHS_A *)Param1;
355 
356         ok(!strcmp(ctx->cabinet, info->Source),
357            "[%d] Expected cabinet \"%s\", got \"%s\"\n",
358            index, ctx->cabinet, info->Source);
359         ok(!strcmp(ctx->target, info->Target),
360            "[%d] Expected target \"%s\", got \"%s\"\n",
361            index, ctx->target, info->Target);
362         ok(info->Win32Error == 0,
363            "[%d] Expected Win32Error 0, got %u\n",
364            index, info->Win32Error);
365 
366         index++;
367         return NO_ERROR;
368     }
369     default:
370         return NO_ERROR;
371     }
372 }
373 
374 static void test_simple_enumerationA(void)
375 {
376     BOOL ret;
377     char source[MAX_PATH], temp[MAX_PATH];
378     char target[MAX_PATH];
379     struct contextA ctx;
380 
381     GetTempPathA(sizeof(temp), temp);
382     GetTempFileNameA(temp, "doc", 0, source);
383     GetTempFileNameA(temp, "doc", 0, target);
384 
385     create_source_fileA(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
386 
387     ctx.count = 0;
388     ctx.cabinet = source;
389     ctx.target = target;
390     ret = SetupIterateCabinetA(source, 0, simple_callbackA, &ctx);
391     ok(ret == 1, "Expected SetupIterateCabinetA to return 1, got %d\n", ret);
392     ok(ctx.count == sizeof(expected_files)/sizeof(char *),
393        "Unexpectedly enumerated %d files\n", ctx.count);
394 
395     DeleteFileA(source);
396     DeleteFileA(target);
397 }
398 
399 static const WCHAR tristramW[] = {'t','r','i','s','t','r','a','m',0};
400 static const WCHAR wineW[] = {'w','i','n','e',0};
401 static const WCHAR shandyW[] = {'s','h','a','n','d','y',0};
402 static const WCHAR *expected_filesW[] = {tristramW, wineW, shandyW};
403 
404 struct contextW
405 {
406     int count;
407     const WCHAR *cabinet;
408     const WCHAR *target;
409 };
410 
411 static UINT CALLBACK simple_callbackW(PVOID Context, UINT Notification,
412                                       UINT_PTR Param1, UINT_PTR Param2)
413 {
414     static const WCHAR emptyW[] = {0};
415     static int index;
416     struct contextW *ctx = Context;
417 
418     switch (Notification)
419     {
420     case SPFILENOTIFY_CABINETINFO:
421     {
422         CABINET_INFO_W *info = (CABINET_INFO_W *)Param1;
423 
424         ok(!lstrcmpW(info->CabinetFile, emptyW),
425            "Expected empty CabinetFile, got %s\n", wine_dbgstr_w(info->CabinetFile));
426 
427         index = 0;
428         return NO_ERROR;
429     }
430     case SPFILENOTIFY_FILEINCABINET:
431     {
432         FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)Param1;
433         const WCHAR *cabinet_file = (const WCHAR *)Param2;
434 
435         ctx->count++;
436 
437         if (index < sizeof(expected_filesW)/sizeof(WCHAR *))
438         {
439             ok(!lstrcmpW(expected_filesW[index], info->NameInCabinet),
440                "[%d] Expected file %s, got %s\n",
441                index, wine_dbgstr_w(expected_filesW[index]), wine_dbgstr_w(info->NameInCabinet));
442             ok(!lstrcmpW(ctx->cabinet, cabinet_file),
443                "[%d] Expected cabinet %s, got %s\n",
444                index, wine_dbgstr_w(ctx->cabinet), wine_dbgstr_w(cabinet_file));
445 
446             lstrcpyW(info->FullTargetName, ctx->target);
447             return FILEOP_DOIT;
448         }
449         else
450         {
451             ok(0, "Unexpectedly enumerated more than number of files in cabinet, index = %d\n", index);
452             return FILEOP_ABORT;
453         }
454     }
455     case SPFILENOTIFY_FILEEXTRACTED:
456     {
457         FILEPATHS_W *info = (FILEPATHS_W *)Param1;
458 
459         ok(!lstrcmpW(ctx->cabinet, info->Source),
460            "[%d] Expected cabinet %s, got %s\n",
461            index, wine_dbgstr_w(ctx->cabinet), wine_dbgstr_w(info->Source));
462         ok(!lstrcmpW(ctx->target, info->Target),
463            "[%d] Expected target %s, got %s\n",
464            index, wine_dbgstr_w(ctx->target), wine_dbgstr_w(info->Target));
465         ok(info->Win32Error == 0,
466            "[%d] Expected Win32Error 0, got %u\n",
467            index, info->Win32Error);
468 
469         index++;
470         return NO_ERROR;
471     }
472     default:
473         return NO_ERROR;
474     }
475 }
476 
477 static void test_simple_enumerationW(void)
478 {
479     BOOL ret;
480     WCHAR source[MAX_PATH], temp[MAX_PATH];
481     WCHAR target[MAX_PATH];
482     struct contextW ctx;
483 
484     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
485     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
486     {
487         win_skip("SetupIterateCabinetW is not available\n");
488         return;
489     }
490 
491     GetTempPathW(sizeof(temp)/sizeof(WCHAR), temp);
492     GetTempFileNameW(temp, docW, 0, source);
493     GetTempFileNameW(temp, docW, 0, target);
494 
495     create_source_fileW(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
496 
497     ctx.count = 0;
498     ctx.cabinet = source;
499     ctx.target = target;
500     ret = SetupIterateCabinetW(source, 0, simple_callbackW, &ctx);
501     ok(ret == 1, "Expected SetupIterateCabinetW to return 1, got %d\n", ret);
502     ok(ctx.count == sizeof(expected_files)/sizeof(WCHAR *),
503        "Unexpectedly enumerated %d files\n", ctx.count);
504 
505     DeleteFileW(source);
506     DeleteFileW(target);
507 }
508 
509 START_TEST(setupcab)
510 {
511     test_invalid_parametersA();
512     test_invalid_parametersW();
513 
514     /* Tests crash on NT4/Win9x/Win2k and Wine. */
515     if (0)
516     {
517         test_invalid_callbackA();
518         test_invalid_callbackW();
519     }
520 
521     test_simple_enumerationA();
522     test_simple_enumerationW();
523 }
524