dlls/setupapi/tests/setupcab.c

   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 static UINT CALLBACK simple_callbackA(PVOID Context, UINT Notification,
 303                                       UINT_PTR Param1, UINT_PTR Param2)
 304 {
 305     static int index;
 306     int *file_count = Context;
 307
 308     switch (Notification)
 309     {
 310     case SPFILENOTIFY_CABINETINFO:
 311         index = 0;
 312         return NO_ERROR;
 313     case SPFILENOTIFY_FILEINCABINET:
 314     {
 315         FILE_IN_CABINET_INFO_A *info = (FILE_IN_CABINET_INFO_A *)Param1;
 316
 317         (*file_count)++;
 318
 319         if (index < sizeof(expected_files)/sizeof(char *))
 320         {
 321             ok(!strcmp(expected_files[index], info->NameInCabinet),
 322                "[%d] Expected file \"%s\", got \"%s\"\n",
 323                index, expected_files[index], info->NameInCabinet);
 324             index++;
 325             return FILEOP_SKIP;
 326         }
 327         else
 328         {
 329             ok(0, "Unexpectedly enumerated more than number of files in cabinet, index = %d\n", index);
 330             return FILEOP_ABORT;
 331         }
 332     }
 333     default:
 334         return NO_ERROR;
 335     }
 336 }
 337
 338 static void test_simple_enumerationA(void)
 339 {
 340     BOOL ret;
 341     char source[MAX_PATH], temp[MAX_PATH];
 342     int enum_count = 0;
 343
 344     GetTempPathA(sizeof(temp), temp);
 345     GetTempFileNameA(temp, "doc", 0, source);
 346
 347     create_source_fileA(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
 348
 349     ret = SetupIterateCabinetA(source, 0, simple_callbackA, &enum_count);
 350     ok(ret == 1, "Expected SetupIterateCabinetA to return 1, got %d\n", ret);
 351     ok(enum_count == sizeof(expected_files)/sizeof(char *),
 352        "Unexpectedly enumerated %d files\n", enum_count);
 353
 354     DeleteFileA(source);
 355 }
 356
 357 static const WCHAR tristramW[] = {'t','r','i','s','t','r','a','m',0};
 358 static const WCHAR wineW[] = {'w','i','n','e',0};
 359 static const WCHAR shandyW[] = {'s','h','a','n','d','y',0};
 360 static const WCHAR *expected_filesW[] = {tristramW, wineW, shandyW};
 361
 362 static UINT CALLBACK simple_callbackW(PVOID Context, UINT Notification,
 363                                       UINT_PTR Param1, UINT_PTR Param2)
 364 {
 365     static int index;
 366     int *file_count = Context;
 367
 368     switch (Notification)
 369     {
 370     case SPFILENOTIFY_CABINETINFO:
 371         index = 0;
 372         return NO_ERROR;
 373     case SPFILENOTIFY_FILEINCABINET:
 374     {
 375         FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)Param1;
 376
 377         (*file_count)++;
 378
 379         if (index < sizeof(expected_filesW)/sizeof(WCHAR *))
 380         {
 381             ok(!lstrcmpW(expected_filesW[index], info->NameInCabinet),
 382                "[%d] Expected file %s, got %s\n",
 383                index, wine_dbgstr_w(expected_filesW[index]), wine_dbgstr_w(info->NameInCabinet));
 384             index++;
 385             return FILEOP_SKIP;
 386         }
 387         else
 388         {
 389             ok(0, "Unexpectedly enumerated more than number of files in cabinet, index = %d\n", index);
 390             return FILEOP_ABORT;
 391         }
 392     }
 393     default:
 394         return NO_ERROR;
 395     }
 396 }
 397
 398 static void test_simple_enumerationW(void)
 399 {
 400     BOOL ret;
 401     WCHAR source[MAX_PATH], temp[MAX_PATH];
 402     int enum_count = 0;
 403
 404     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
 405     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 406     {
 407         win_skip("SetupIterateCabinetW is not available\n");
 408         return;
 409     }
 410
 411     GetTempPathW(sizeof(temp)/sizeof(WCHAR), temp);
 412     GetTempFileNameW(temp, docW, 0, source);
 413
 414     create_source_fileW(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
 415
 416     ret = SetupIterateCabinetW(source, 0, simple_callbackW, &enum_count);
 417     ok(ret == 1, "Expected SetupIterateCabinetW to return 1, got %d\n", ret);
 418     ok(enum_count == sizeof(expected_files)/sizeof(WCHAR *),
 419        "Unexpectedly enumerated %d files\n", enum_count);
 420
 421     DeleteFileW(source);
 422 }
 423
 424 START_TEST(setupcab)
 425 {
 426     test_invalid_parametersA();
 427     test_invalid_parametersW();
 428
 429     /* Tests crash on NT4/Win9x/Win2k and Wine. */
 430     if (0)
 431     {
 432         test_invalid_callbackA();
 433         test_invalid_callbackW();
 434     }
 435
 436     test_simple_enumerationA();
 437     test_simple_enumerationW();
 438 }