base/setup/usetup/cabinet.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS text-mode setup
   4  * FILE:        subsys/system/usetup/cabinet.c
   5  * PURPOSE:     Cabinet routines
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 15/08-2003 Created
   9  */
  10
  11 #include "usetup.h"
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 #define SEEK_BEGIN    0
  17 #define SEEK_CURRENT  1
  18 #ifndef SEEK_END
  19 #define SEEK_END      2
  20 #endif
  21
  22 typedef struct _DOSTIME
  23 {
  24     WORD Second:5;
  25     WORD Minute:6;
  26     WORD Hour:5;
  27 } DOSTIME, *PDOSTIME;
  28
  29
  30 typedef struct _DOSDATE
  31 {
  32     WORD Day:5;
  33     WORD Month:4;
  34     WORD Year:5;
  35 } DOSDATE, *PDOSDATE;
  36
  37 static WCHAR CabinetName[256];          // Filename of current cabinet
  38 static WCHAR CabinetPrev[256];          // Filename of previous cabinet
  39 static WCHAR DiskPrev[256];             // Label of cabinet in file CabinetPrev
  40 static WCHAR CabinetNext[256];          // Filename of next cabinet
  41 static WCHAR DiskNext[256];             // Label of cabinet in file CabinetNext
  42 static ULONG FolderUncompSize = 0;      // Uncompressed size of folder
  43 static ULONG BytesLeftInBlock = 0;      // Number of bytes left in current block
  44 static WCHAR DestPath[MAX_PATH];
  45 static HANDLE FileHandle;
  46 static HANDLE FileSectionHandle;
  47 static PUCHAR FileBuffer;
  48 static SIZE_T DestFileSize;
  49 static SIZE_T FileSize;
  50 static BOOL FileOpen = FALSE;
  51 static PCFHEADER PCABHeader;
  52 static PCFFOLDER CabinetFolders;
  53 static ULONG CabinetReserved = 0;
  54 static ULONG FolderReserved = 0;
  55 static ULONG DataReserved = 0;
  56 static ULONG CodecId;
  57 static PCABINET_CODEC_UNCOMPRESS CodecUncompress = NULL;
  58 static BOOL CodecSelected = FALSE;
  59 static ULONG LastFileOffset = 0;    // Uncompressed offset of last extracted file
  60 static PCABINET_OVERWRITE OverwriteHandler = NULL;
  61 static PCABINET_EXTRACT ExtractHandler = NULL;
  62 static PCABINET_DISK_CHANGE DiskChangeHandler = NULL;
  63 static z_stream ZStream;
  64 static PVOID CabinetReservedArea = NULL;
  65
  66
  67 /* Needed by zlib, but we don't want the dependency on msvcrt.dll */
  68 void *__cdecl
  69 malloc(size_t size)
  70 {
  71     return RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, size);
  72 }
  73
  74 void __cdecl
  75 free(void *ptr)
  76 {
  77     RtlFreeHeap(ProcessHeap, 0, ptr);
  78 }
  79
  80 void *__cdecl
  81 calloc(size_t nmemb, size_t size)
  82 {
  83     return (void *)RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, nmemb * size);
  84 }
  85
  86 /* RAW codec */
  87
  88 /*
  89  * FUNCTION: Uncompresses data in a buffer
  90  * ARGUMENTS:
  91  *     OutputBuffer = Pointer to buffer to place uncompressed data
  92  *     InputBuffer  = Pointer to buffer with data to be uncompressed
  93  *     InputLength  = Length of input buffer before, and amount consumed after
  94  *                    Negative to indicate that this is not the start of a new block
  95  *     OutputLength = Length of output buffer before, amount filled after
  96  *                    Negative to indicate that this is not the end of the block
  97  */
  98 ULONG
  99 RawCodecUncompress(PVOID OutputBuffer,
 100                    PVOID InputBuffer,
 101                    PLONG InputLength,
 102                    PLONG OutputLength)
 103 {
 104     LONG Len = min(abs(*InputLength), abs(*OutputLength));
 105
 106     memcpy(OutputBuffer, InputBuffer, Len);
 107     *InputLength = *OutputLength = Len;
 108
 109     return CS_SUCCESS;
 110 }
 111
 112 /* MSZIP codec */
 113
 114 /*
 115  * FUNCTION: Uncompresses data in a buffer
 116  * ARGUMENTS:
 117  *     OutputBuffer = Pointer to buffer to place uncompressed data
 118  *     InputBuffer  = Pointer to buffer with data to be uncompressed
 119  *     InputLength  = Length of input buffer before, and amount consumed after
 120  *                    Negative to indicate that this is not the start of a new block
 121  *     OutputLength = Length of output buffer before, amount filled after
 122  *                    Negative to indicate that this is not the end of the block
 123  */
 124 ULONG
 125 MSZipCodecUncompress(PVOID OutputBuffer,
 126                      PVOID InputBuffer,
 127                      PLONG InputLength,
 128                      PLONG OutputLength)
 129 {
 130     USHORT Magic;
 131     INT Status;
 132
 133     DPRINT("MSZipCodecUncompress(OutputBuffer = %x, InputBuffer = %x, "
 134            "InputLength = %d, OutputLength = %d)\n", OutputBuffer,
 135            InputBuffer, *InputLength, *OutputLength);
 136     if (*InputLength > 0)
 137     {
 138         Magic = *(PUSHORT)InputBuffer;
 139
 140         if (Magic != MSZIP_MAGIC)
 141         {
 142             DPRINT("Bad MSZIP block header magic (0x%X)\n", Magic);
 143             return CS_BADSTREAM;
 144         }
 145
 146         ZStream.next_in = (PUCHAR)InputBuffer + 2;
 147         ZStream.avail_in = *InputLength - 2;
 148         ZStream.next_out = (PUCHAR)OutputBuffer;
 149         ZStream.avail_out = abs(*OutputLength);
 150
 151         /* WindowBits is passed < 0 to tell that there is no zlib header.
 152          * Note that in this case inflate *requires* an extra "dummy" byte
 153          * after the compressed stream in order to complete decompression and
 154          * return Z_STREAM_END.
 155          */
 156         Status = inflateInit2(&ZStream, -MAX_WBITS);
 157         if (Status != Z_OK)
 158         {
 159             DPRINT("inflateInit2() returned (%d)\n", Status);
 160             return CS_BADSTREAM;
 161         }
 162         ZStream.total_in = 2;
 163     }
 164     else
 165     {
 166         ZStream.avail_in = -*InputLength;
 167         ZStream.next_in = (PUCHAR)InputBuffer;
 168         ZStream.next_out = (PUCHAR)OutputBuffer;
 169         ZStream.avail_out = abs(*OutputLength);
 170         ZStream.total_in = 0;
 171     }
 172
 173     ZStream.total_out = 0;
 174     Status = inflate(&ZStream, Z_SYNC_FLUSH);
 175     if (Status != Z_OK && Status != Z_STREAM_END)
 176     {
 177         DPRINT("inflate() returned (%d) (%s)\n", Status, ZStream.msg);
 178         if (Status == Z_MEM_ERROR)
 179             return CS_NOMEMORY;
 180         return CS_BADSTREAM;
 181     }
 182
 183     if (*OutputLength > 0)
 184     {
 185         Status = inflateEnd(&ZStream);
 186         if (Status != Z_OK)
 187         {
 188             DPRINT("inflateEnd() returned (%d)\n", Status);
 189             return CS_BADSTREAM;
 190         }
 191     }
 192
 193     *OutputLength = ZStream.total_out;
 194     *InputLength = ZStream.total_in;
 195
 196     return CS_SUCCESS;
 197 }
 198
 199 /* Memory functions */
 200
 201 voidpf
 202 MSZipAlloc(voidpf opaque, uInt items, uInt size)
 203 {
 204     return (voidpf)RtlAllocateHeap(ProcessHeap, 0, items * size);
 205 }
 206
 207 void
 208 MSZipFree(voidpf opaque, voidpf address)
 209 {
 210     RtlFreeHeap(ProcessHeap, 0, address);
 211 }
 212
 213 static BOOL
 214 ConvertSystemTimeToFileTime(CONST SYSTEMTIME *lpSystemTime,
 215                             LPFILETIME lpFileTime)
 216 {
 217     TIME_FIELDS TimeFields;
 218     LARGE_INTEGER liTime;
 219
 220     TimeFields.Year = lpSystemTime->wYear;
 221     TimeFields.Month = lpSystemTime->wMonth;
 222     TimeFields.Day = lpSystemTime->wDay;
 223     TimeFields.Hour = lpSystemTime->wHour;
 224     TimeFields.Minute = lpSystemTime->wMinute;
 225     TimeFields.Second = lpSystemTime->wSecond;
 226     TimeFields.Milliseconds = lpSystemTime->wMilliseconds;
 227
 228     if (RtlTimeFieldsToTime(&TimeFields, &liTime))
 229     {
 230         lpFileTime->dwLowDateTime = liTime.u.LowPart;
 231         lpFileTime->dwHighDateTime = liTime.u.HighPart;
 232         return TRUE;
 233     }
 234
 235     return FALSE;
 236 }
 237
 238 static BOOL
 239 ConvertDosDateTimeToFileTime(WORD wFatDate,
 240                              WORD wFatTime,
 241                              LPFILETIME lpFileTime)
 242 {
 243     PDOSTIME pdtime = (PDOSTIME)&wFatTime;
 244     PDOSDATE pddate = (PDOSDATE)&wFatDate;
 245     SYSTEMTIME SystemTime;
 246
 247     if (lpFileTime == NULL)
 248         return FALSE;
 249
 250     SystemTime.wMilliseconds = 0;
 251     SystemTime.wSecond = pdtime->Second;
 252     SystemTime.wMinute = pdtime->Minute;
 253     SystemTime.wHour = pdtime->Hour;
 254
 255     SystemTime.wDay = pddate->Day;
 256     SystemTime.wMonth = pddate->Month;
 257     SystemTime.wYear = 1980 + pddate->Year;
 258
 259     ConvertSystemTimeToFileTime(&SystemTime, lpFileTime);
 260
 261     return TRUE;
 262 }
 263
 264 /*
 265  * FUNCTION: Returns a pointer to file name
 266  * ARGUMENTS:
 267  *     Path = Pointer to string with pathname
 268  * RETURNS:
 269  *     Pointer to filename
 270  */
 271 static PWCHAR
 272 GetFileName(PWCHAR Path)
 273 {
 274     ULONG i, j;
 275
 276     j = i = 0;
 277
 278     while (Path[i++])
 279     {
 280         if (Path[i - 1] == L'\\')
 281             j = i;
 282     }
 283
 284     return Path + j;
 285 }
 286
 287 /*
 288  * FUNCTION: Removes a file name from a path
 289  * ARGUMENTS:
 290  *     Path = Pointer to string with path
 291  */
 292 static VOID
 293 RemoveFileName(PWCHAR Path)
 294 {
 295     PWCHAR FileName;
 296     DWORD i;
 297
 298     i = 0;
 299     FileName = GetFileName(Path + i);
 300
 301     if (FileName != Path + i && FileName[-1] == L'\\')
 302         FileName--;
 303
 304     if (FileName == Path + i && FileName[0] == L'\\')
 305         FileName++;
 306
 307     FileName[0] = 0;
 308 }
 309
 310 /*
 311  * FUNCTION: Sets attributes on a file
 312  * ARGUMENTS:
 313  *      File = Pointer to CFFILE node for file
 314  * RETURNS:
 315  *     Status of operation
 316  */
 317 static BOOL
 318 SetAttributesOnFile(PCFFILE File,
 319                     HANDLE hFile)
 320 {
 321     FILE_BASIC_INFORMATION FileBasic;
 322     IO_STATUS_BLOCK IoStatusBlock;
 323     NTSTATUS NtStatus;
 324     ULONG Attributes = 0;
 325
 326     if (File->Attributes & CAB_ATTRIB_READONLY)
 327         Attributes |= FILE_ATTRIBUTE_READONLY;
 328
 329     if (File->Attributes & CAB_ATTRIB_HIDDEN)
 330         Attributes |= FILE_ATTRIBUTE_HIDDEN;
 331
 332     if (File->Attributes & CAB_ATTRIB_SYSTEM)
 333         Attributes |= FILE_ATTRIBUTE_SYSTEM;
 334
 335     if (File->Attributes & CAB_ATTRIB_DIRECTORY)
 336         Attributes |= FILE_ATTRIBUTE_DIRECTORY;
 337
 338     if (File->Attributes & CAB_ATTRIB_ARCHIVE)
 339         Attributes |= FILE_ATTRIBUTE_ARCHIVE;
 340
 341     NtStatus = NtQueryInformationFile(hFile,
 342                                       &IoStatusBlock,
 343                                       &FileBasic,
 344                                       sizeof(FILE_BASIC_INFORMATION),
 345                                       FileBasicInformation);
 346     if (!NT_SUCCESS(NtStatus))
 347     {
 348         DPRINT("NtQueryInformationFile() failed (%x)\n", NtStatus);
 349     }
 350     else
 351     {
 352         FileBasic.FileAttributes = Attributes;
 353
 354         NtStatus = NtSetInformationFile(hFile,
 355                                         &IoStatusBlock,
 356                                         &FileBasic,
 357                                         sizeof(FILE_BASIC_INFORMATION),
 358                                         FileBasicInformation);
 359         if (!NT_SUCCESS(NtStatus))
 360         {
 361             DPRINT("NtSetInformationFile() failed (%x)\n", NtStatus);
 362         }
 363     }
 364
 365     return NT_SUCCESS(NtStatus);
 366 }
 367
 368 /*
 369  * FUNCTION: Closes the current cabinet
 370  * RETURNS:
 371  *     Status of operation
 372  */
 373 static ULONG
 374 CloseCabinet(VOID)
 375 {
 376     if (FileBuffer)
 377     {
 378         NtUnmapViewOfSection(NtCurrentProcess(), FileBuffer);
 379         NtClose(FileSectionHandle);
 380         NtClose(FileHandle);
 381         FileBuffer = NULL;
 382     }
 383
 384     return 0;
 385 }
 386
 387 /*
 388  * FUNCTION: Initialize archiver
 389  */
 390 VOID
 391 CabinetInitialize(VOID)
 392 {
 393     ZStream.zalloc = MSZipAlloc;
 394     ZStream.zfree = MSZipFree;
 395     ZStream.opaque = (voidpf)0;
 396
 397     FileOpen = FALSE;
 398     wcscpy(DestPath, L"");
 399
 400     CodecId = CAB_CODEC_RAW;
 401     CodecSelected = TRUE;
 402
 403     FolderUncompSize = 0;
 404     BytesLeftInBlock = 0;
 405     CabinetReserved = 0;
 406     FolderReserved = 0;
 407     DataReserved = 0;
 408     CabinetReservedArea = NULL;
 409     LastFileOffset = 0;
 410 }
 411
 412 /*
 413  * FUNCTION: Cleanup archiver
 414  */
 415 VOID
 416 CabinetCleanup(VOID)
 417 {
 418     CabinetClose();
 419 }
 420
 421 /*
 422  * FUNCTION: Normalizes a path
 423  * ARGUMENTS:
 424  *     Path   = Pointer to string with pathname
 425  *     Length = Number of characters in Path
 426  * RETURNS:
 427  *     TRUE if there was enough room in Path, or FALSE
 428  */
 429 BOOL
 430 CabinetNormalizePath(PWCHAR Path,
 431                      ULONG Length)
 432 {
 433     ULONG n;
 434     BOOL Ok;
 435
 436     n = wcslen(Path);
 437     Ok = (n + 1) < Length;
 438
 439     if (n != 0 && Path[n - 1] != L'\\' && Ok)
 440     {
 441         Path[n] = L'\\';
 442         Path[n + 1] = 0;
 443     }
 444
 445     return Ok;
 446 }
 447
 448 /*
 449  * FUNCTION: Returns pointer to cabinet file name
 450  * RETURNS:
 451  *     Pointer to string with name of cabinet
 452  */
 453 PWCHAR
 454 CabinetGetCabinetName(VOID)
 455 {
 456     return CabinetName;
 457 }
 458
 459 /*
 460  * FUNCTION: Sets cabinet file name
 461  * ARGUMENTS:
 462  *     FileName = Pointer to string with name of cabinet
 463  */
 464 VOID
 465 CabinetSetCabinetName(PWCHAR FileName)
 466 {
 467     wcscpy(CabinetName, FileName);
 468 }
 469
 470 /*
 471  * FUNCTION: Sets destination path
 472  * ARGUMENTS:
 473  *    DestinationPath = Pointer to string with name of destination path
 474  */
 475 VOID
 476 CabinetSetDestinationPath(PWCHAR DestinationPath)
 477 {
 478     wcscpy(DestPath, DestinationPath);
 479
 480     if (wcslen(DestPath) > 0)
 481         CabinetNormalizePath(DestPath, MAX_PATH);
 482 }
 483
 484 /*
 485  * FUNCTION: Returns destination path
 486  * RETURNS:
 487  *    Pointer to string with name of destination path
 488  */
 489 PWCHAR
 490 CabinetGetDestinationPath(VOID)
 491 {
 492     return DestPath;
 493 }
 494
 495 /*
 496  * FUNCTION: Opens a cabinet file
 497  * RETURNS:
 498  *     Status of operation
 499  */
 500 ULONG
 501 CabinetOpen(VOID)
 502 {
 503     PUCHAR Buffer;
 504     UNICODE_STRING ustring;
 505     ANSI_STRING astring;
 506
 507     if (!FileOpen)
 508     {
 509         OBJECT_ATTRIBUTES ObjectAttributes;
 510         IO_STATUS_BLOCK IoStatusBlock;
 511         UNICODE_STRING FileName;
 512         NTSTATUS NtStatus;
 513
 514         RtlInitUnicodeString(&FileName, CabinetName);
 515
 516         InitializeObjectAttributes(&ObjectAttributes,
 517                                    &FileName,
 518                                    OBJ_CASE_INSENSITIVE,
 519                                    NULL, NULL);
 520
 521         NtStatus = NtOpenFile(&FileHandle,
 522                               GENERIC_READ | SYNCHRONIZE,
 523                               &ObjectAttributes,
 524                               &IoStatusBlock,
 525                               FILE_SHARE_READ,
 526                               FILE_SYNCHRONOUS_IO_NONALERT);
 527
 528         if (!NT_SUCCESS(NtStatus))
 529         {
 530             DPRINT("Cannot open file (%S) (%x)\n", CabinetName, NtStatus);
 531             return CAB_STATUS_CANNOT_OPEN;
 532         }
 533
 534         FileOpen = TRUE;
 535
 536         NtStatus = NtCreateSection(&FileSectionHandle,
 537                                    SECTION_ALL_ACCESS,
 538                                    0, 0,
 539                                    PAGE_READONLY,
 540                                    SEC_COMMIT,
 541                                    FileHandle);
 542
 543         if (!NT_SUCCESS(NtStatus))
 544         {
 545             DPRINT("NtCreateSection failed: %x\n", NtStatus);
 546             return CAB_STATUS_NOMEMORY;
 547         }
 548
 549         FileBuffer = 0;
 550         FileSize = 0;
 551
 552         NtStatus = NtMapViewOfSection(FileSectionHandle,
 553                                       NtCurrentProcess(),
 554                                       (PVOID *)&FileBuffer,
 555                                       0, 0, 0,
 556                                       &FileSize,
 557                                       ViewUnmap,
 558                                       0,
 559                                       PAGE_READONLY);
 560
 561         if (!NT_SUCCESS(NtStatus))
 562         {
 563             DPRINT("NtMapViewOfSection failed: %x\n", NtStatus);
 564             return CAB_STATUS_NOMEMORY;
 565         }
 566
 567         DPRINT("Cabinet file %S opened and mapped to %x\n", CabinetName, FileBuffer);
 568         PCABHeader = (PCFHEADER) FileBuffer;
 569
 570         /* Check header */
 571         if (FileSize <= sizeof(CFHEADER) ||
 572             PCABHeader->Signature != CAB_SIGNATURE ||
 573             PCABHeader->Version != CAB_VERSION ||
 574             PCABHeader->FolderCount == 0 ||
 575             PCABHeader->FileCount == 0 ||
 576             PCABHeader->FileTableOffset < sizeof(CFHEADER))
 577         {
 578             CloseCabinet();
 579             DPRINT("File has invalid header\n");
 580             return CAB_STATUS_INVALID_CAB;
 581         }
 582
 583         Buffer = (PUCHAR)(PCABHeader + 1);
 584
 585         /* Read/skip any reserved bytes */
 586         if (PCABHeader->Flags & CAB_FLAG_RESERVE)
 587         {
 588             CabinetReserved = *(PUSHORT)Buffer;
 589             Buffer += 2;
 590             FolderReserved = *Buffer;
 591             Buffer++;
 592             DataReserved = *Buffer;
 593             Buffer++;
 594
 595             if (CabinetReserved > 0)
 596             {
 597                 CabinetReservedArea = Buffer;
 598                 Buffer += CabinetReserved;
 599             }
 600         }
 601
 602         if (PCABHeader->Flags & CAB_FLAG_HASPREV)
 603         {
 604             /* The previous cabinet file is in
 605                the same directory as the current */
 606             wcscpy(CabinetPrev, CabinetName);
 607             RemoveFileName(CabinetPrev);
 608             CabinetNormalizePath(CabinetPrev, 256);
 609             RtlInitAnsiString(&astring, (LPSTR)Buffer);
 610             ustring.Length = wcslen(CabinetPrev);
 611             ustring.Buffer = CabinetPrev + ustring.Length;
 612             ustring.MaximumLength = sizeof(CabinetPrev) - ustring.Length;
 613             RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
 614             Buffer += astring.Length + 1;
 615
 616             /* Read label of prev disk */
 617             RtlInitAnsiString(&astring, (LPSTR)Buffer);
 618             ustring.Length = 0;
 619             ustring.Buffer = DiskPrev;
 620             ustring.MaximumLength = sizeof(DiskPrev);
 621             RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
 622             Buffer += astring.Length + 1;
 623         }
 624         else
 625         {
 626             wcscpy(CabinetPrev, L"");
 627             wcscpy(DiskPrev, L"");
 628         }
 629
 630         if (PCABHeader->Flags & CAB_FLAG_HASNEXT)
 631         {
 632             /* The next cabinet file is in
 633                the same directory as the previous */
 634             wcscpy(CabinetNext, CabinetName);
 635             RemoveFileName(CabinetNext);
 636             CabinetNormalizePath(CabinetNext, 256);
 637             RtlInitAnsiString(&astring, (LPSTR)Buffer);
 638             ustring.Length = wcslen(CabinetNext);
 639             ustring.Buffer = CabinetNext + ustring.Length;
 640             ustring.MaximumLength = sizeof(CabinetNext) - ustring.Length;
 641             RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
 642             Buffer += astring.Length + 1;
 643
 644             /* Read label of next disk */
 645             RtlInitAnsiString(&astring, (LPSTR)Buffer);
 646             ustring.Length = 0;
 647             ustring.Buffer = DiskNext;
 648             ustring.MaximumLength = sizeof(DiskNext);
 649             RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
 650             Buffer += astring.Length + 1;
 651         }
 652         else
 653         {
 654             wcscpy(CabinetNext, L"");
 655             wcscpy(DiskNext, L"");
 656         }
 657         CabinetFolders = (PCFFOLDER)Buffer;
 658     }
 659
 660     DPRINT("CabinetOpen returning SUCCESS\n");
 661     return CAB_STATUS_SUCCESS;
 662 }
 663
 664 /*
 665  * FUNCTION: Closes the cabinet file
 666  */
 667 VOID
 668 CabinetClose(VOID)
 669 {
 670     if (FileOpen)
 671     {
 672         CloseCabinet();
 673         FileOpen = FALSE;
 674     }
 675 }
 676
 677 /*
 678  * FUNCTION: Finds the first file in the cabinet that matches a search criteria
 679  * ARGUMENTS:
 680  *     FileName = Pointer to search criteria
 681  *     Search   = Pointer to search structure
 682  * RETURNS:
 683  *     Status of operation
 684  */
 685 ULONG
 686 CabinetFindFirst(PWCHAR FileName,
 687                  PCAB_SEARCH Search)
 688 {
 689     DPRINT("CabinetFindFirst( FileName = %S )\n", FileName);
 690     wcsncpy(Search->Search, FileName, MAX_PATH);
 691     wcsncpy(Search->Cabinet, CabinetName, MAX_PATH);
 692     Search->File = 0;
 693     return CabinetFindNext(Search);
 694 }
 695
 696 /*
 697  * FUNCTION: Finds the next file in the cabinet that matches a search criteria
 698  * ARGUMENTS:
 699  *     FileName = Pointer to search criteria
 700  *     Search   = Pointer to search structure
 701  * RETURNS:
 702  *     Status of operation
 703  */
 704 ULONG
 705 CabinetFindNextFileSequential(PWCHAR FileName,
 706                               PCAB_SEARCH Search)
 707 {
 708     DPRINT("CabinetFindNextFileSequential( FileName = %S )\n", FileName);
 709     wcsncpy(Search->Search, FileName, MAX_PATH);
 710     return CabinetFindNext(Search);
 711 }
 712
 713 /*
 714  * FUNCTION: Finds next file in the cabinet that matches a search criteria
 715  * ARGUMENTS:
 716  *     Search = Pointer to search structure
 717  * RETURNS:
 718  *     Status of operation
 719  */
 720 ULONG
 721 CabinetFindNext(PCAB_SEARCH Search)
 722 {
 723     PCFFILE Prev;
 724     ANSI_STRING AnsiString;
 725     UNICODE_STRING UnicodeString;
 726     WCHAR FileName[MAX_PATH];
 727
 728     if (wcscmp(Search->Cabinet, CabinetName) != 0)
 729     {
 730         /* restart search of cabinet has changed since last find */
 731         Search->File = 0;
 732     }
 733
 734     if (!Search->File)
 735     {
 736         /* starting new search or cabinet */
 737         Search->File = (PCFFILE)(FileBuffer + PCABHeader->FileTableOffset);
 738         Search->Index = 0;
 739         Prev = 0;
 740     }
 741     else
 742         Prev = Search->File;
 743
 744     while (TRUE)
 745     {
 746         /* look at each file in the archive and see if we found a match */
 747         if (Search->File->FolderIndex == 0xFFFD ||
 748             Search->File->FolderIndex == 0xFFFF)
 749         {
 750             /* skip files continued from previous cab */
 751             DPRINT("Skipping file (%s): FileOffset (0x%X), "
 752                    "LastFileOffset (0x%X)\n", (char *)(Search->File + 1),
 753                    Search->File->FileOffset, LastFileOffset);
 754         }
 755         else
 756         {
 757             // FIXME: check for match against search criteria
 758             if (Search->File != Prev)
 759             {
 760                 if (Prev == NULL || Search->File->FolderIndex != Prev->FolderIndex)
 761                 {
 762                     Search->CFData = NULL;
 763                     Search->Offset = 0;
 764                 }
 765
 766                 /* don't match the file we started with */
 767                 if (wcscmp(Search->Search, L"*") == 0)
 768                 {
 769                     /* take any file */
 770                     break;
 771                 }
 772                 else
 773                 {
 774                     /* otherwise, try to match the exact file name */
 775                     RtlInitAnsiString(&AnsiString, Search->File->FileName);
 776                     UnicodeString.Buffer = FileName;
 777                     UnicodeString.Buffer[0] = 0;
 778                     UnicodeString.Length = 0;
 779                     UnicodeString.MaximumLength = sizeof(FileName);
 780                     RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
 781                     if (wcscmp(Search->Search, UnicodeString.Buffer) == 0)
 782                         break;
 783                 }
 784             }
 785         }
 786
 787         /* if we make it here we found no match, so move to the next file */
 788         Search->Index++;
 789         if (Search->Index >= PCABHeader->FileCount)
 790         {
 791             /* we have reached the end of this cabinet */
 792             DPRINT("End of cabinet reached\n");
 793             return CAB_STATUS_NOFILE;
 794         }
 795         else
 796             Search->File = (PCFFILE)(strchr((char *)(Search->File + 1), 0) + 1);
 797     }
 798
 799     DPRINT("Found file %s\n", Search->File->FileName);
 800     return CAB_STATUS_SUCCESS;
 801 }
 802
 803 #if 0
 804 int
 805 Validate()
 806 {
 807     return (int)RtlValidateHeap(ProcessHeap, 0, 0);
 808 }
 809 #endif
 810
 811 /*
 812  * FUNCTION: Extracts a file from the cabinet
 813  * ARGUMENTS:
 814  *     Search = Pointer to PCAB_SEARCH structure used to locate the file
 815  * RETURNS
 816  *     Status of operation
 817  */
 818 ULONG
 819 CabinetExtractFile(PCAB_SEARCH Search)
 820 {
 821     ULONG Size;                 // remaining file bytes to decompress
 822     ULONG CurrentOffset;        // current uncompressed offset within the folder
 823     PUCHAR CurrentBuffer;       // current pointer to compressed data in the block
 824     LONG RemainingBlock;        // remaining comp data in the block
 825     HANDLE DestFile;
 826     HANDLE DestFileSection;
 827     PVOID DestFileBuffer;       // mapped view of dest file
 828     PVOID CurrentDestBuffer;    // pointer to the current position in the dest view
 829     PCFDATA CFData;             // current data block
 830     ULONG Status;
 831     FILETIME FileTime;
 832     WCHAR DestName[MAX_PATH];
 833     NTSTATUS NtStatus;
 834     UNICODE_STRING UnicodeString;
 835     ANSI_STRING AnsiString;
 836     IO_STATUS_BLOCK IoStatusBlock;
 837     OBJECT_ATTRIBUTES ObjectAttributes;
 838     FILE_BASIC_INFORMATION FileBasic;
 839     PCFFOLDER CurrentFolder;
 840     LARGE_INTEGER MaxDestFileSize;
 841     LONG InputLength, OutputLength;
 842     char Junk[512];
 843
 844     if (wcscmp(Search->Cabinet, CabinetName) != 0)
 845     {
 846         /* the file is not in the current cabinet */
 847         DPRINT("File is not in this cabinet (%S != %S)\n",
 848                Search->Cabinet, CabinetName);
 849         return CAB_STATUS_NOFILE;
 850     }
 851
 852     /* look up the folder that the file specifies */
 853     if (Search->File->FolderIndex == 0xFFFD ||
 854         Search->File->FolderIndex == 0xFFFF)
 855     {
 856         /* folder is continued from previous cabinet,
 857            that shouldn't happen here */
 858         return CAB_STATUS_NOFILE;
 859     }
 860     else if (Search->File->FolderIndex == 0xFFFE)
 861     {
 862         /* folder is the last in this cabinet and continues into next */
 863         CurrentFolder = &CabinetFolders[PCABHeader->FolderCount - 1];
 864     }
 865     else
 866     {
 867         /* folder is completely contained within this cabinet */
 868         CurrentFolder = &CabinetFolders[Search->File->FolderIndex];
 869     }
 870
 871     switch (CurrentFolder->CompressionType & CAB_COMP_MASK)
 872     {
 873         case CAB_COMP_NONE:
 874             CabinetSelectCodec(CAB_CODEC_RAW);
 875             break;
 876         case CAB_COMP_MSZIP:
 877             CabinetSelectCodec(CAB_CODEC_MSZIP);
 878             break;
 879         default:
 880             return CAB_STATUS_UNSUPPCOMP;
 881     }
 882
 883     DPRINT("Extracting file at uncompressed offset (0x%X) Size (%d bytes)\n",
 884            (UINT)Search->File->FileOffset, (UINT)Search->File->FileSize);
 885
 886     RtlInitAnsiString(&AnsiString, Search->File->FileName);
 887     wcscpy(DestName, DestPath);
 888     UnicodeString.MaximumLength = sizeof(DestName) - wcslen(DestName) * sizeof(WCHAR);
 889     UnicodeString.Buffer = DestName + wcslen(DestName);
 890     UnicodeString.Length = 0;
 891     RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
 892
 893     /* Create destination file, fail if it already exists */
 894     RtlInitUnicodeString(&UnicodeString, DestName);
 895
 896     InitializeObjectAttributes(&ObjectAttributes,
 897                                &UnicodeString,
 898                                OBJ_CASE_INSENSITIVE,
 899                                NULL, NULL);
 900
 901     NtStatus = NtCreateFile(&DestFile,
 902                             GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
 903                             &ObjectAttributes,
 904                             &IoStatusBlock,
 905                             NULL,
 906                             FILE_ATTRIBUTE_NORMAL,
 907                             0,
 908                             FILE_CREATE,
 909                             FILE_SYNCHRONOUS_IO_NONALERT,
 910                             NULL, 0);
 911
 912     if (!NT_SUCCESS(NtStatus))
 913     {
 914         DPRINT("NtCreateFile() failed (%S) (%x)\n", DestName, NtStatus);
 915
 916         /* If file exists, ask to overwrite file */
 917         if (OverwriteHandler == NULL || OverwriteHandler(Search->File, DestName))
 918         {
 919             /* Create destination file, overwrite if it already exists */
 920             NtStatus = NtCreateFile(&DestFile,
 921                                     GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
 922                                     &ObjectAttributes,
 923                                     &IoStatusBlock,
 924                                     NULL,
 925                                     FILE_ATTRIBUTE_NORMAL,
 926                                     0,
 927                                     FILE_OVERWRITE,
 928                                     FILE_SYNCHRONOUS_IO_ALERT,
 929                                     NULL, 0);
 930
 931             if (!NT_SUCCESS(NtStatus))
 932             {
 933                 DPRINT("NtCreateFile() failed (%S) (%x)\n", DestName, NtStatus);
 934                 return CAB_STATUS_CANNOT_CREATE;
 935             }
 936         }
 937         else
 938         {
 939             DPRINT("File (%S) exists\n", DestName);
 940             return CAB_STATUS_FILE_EXISTS;
 941         }
 942     }
 943
 944     MaxDestFileSize.QuadPart = Search->File->FileSize;
 945     NtStatus = NtCreateSection(&DestFileSection,
 946                                SECTION_ALL_ACCESS,
 947                                0,
 948                                &MaxDestFileSize,
 949                                PAGE_READWRITE,
 950                                SEC_COMMIT,
 951                                DestFile);
 952
 953     if (!NT_SUCCESS(NtStatus))
 954     {
 955         DPRINT("NtCreateSection failed: %x\n", NtStatus);
 956         Status = CAB_STATUS_NOMEMORY;
 957         goto CloseDestFile;
 958     }
 959
 960     DestFileBuffer = 0;
 961     DestFileSize = 0;
 962     NtStatus = NtMapViewOfSection(DestFileSection,
 963                                   NtCurrentProcess(),
 964                                   &DestFileBuffer,
 965                                   0, 0, 0,
 966                                   &DestFileSize,
 967                                   ViewUnmap,
 968                                   0,
 969                                   PAGE_READWRITE);
 970
 971     if (!NT_SUCCESS(NtStatus))
 972     {
 973         DPRINT("NtMapViewOfSection failed: %x\n", NtStatus);
 974         Status = CAB_STATUS_NOMEMORY;
 975         goto CloseDestFileSection;
 976     }
 977
 978     CurrentDestBuffer = DestFileBuffer;
 979     if (!ConvertDosDateTimeToFileTime(Search->File->FileDate,
 980                                       Search->File->FileTime,
 981                                       &FileTime))
 982     {
 983         DPRINT("DosDateTimeToFileTime() failed\n");
 984         Status = CAB_STATUS_CANNOT_WRITE;
 985         goto UnmapDestFile;
 986     }
 987
 988     NtStatus = NtQueryInformationFile(DestFile,
 989                                       &IoStatusBlock,
 990                                       &FileBasic,
 991                                       sizeof(FILE_BASIC_INFORMATION),
 992                                       FileBasicInformation);
 993     if (!NT_SUCCESS(NtStatus))
 994     {
 995         DPRINT("NtQueryInformationFile() failed (%x)\n", NtStatus);
 996     }
 997     else
 998     {
 999         memcpy(&FileBasic.LastAccessTime, &FileTime, sizeof(FILETIME));
1000
1001         NtStatus = NtSetInformationFile(DestFile,
1002                                         &IoStatusBlock,
1003                                         &FileBasic,
1004                                         sizeof(FILE_BASIC_INFORMATION),
1005                                         FileBasicInformation);
1006         if (!NT_SUCCESS(NtStatus))
1007         {
1008             DPRINT("NtSetInformationFile() failed (%x)\n", NtStatus);
1009         }
1010     }
1011
1012     SetAttributesOnFile(Search->File, DestFile);
1013
1014     /* Call extract event handler */
1015     if (ExtractHandler != NULL)
1016     {
1017         ExtractHandler(Search->File, DestName);
1018     }
1019
1020     if (Search->CFData)
1021         CFData = Search->CFData;
1022     else
1023         CFData = (PCFDATA)(CabinetFolders[Search->File->FolderIndex].DataOffset + FileBuffer);
1024
1025     CurrentOffset = Search->Offset;
1026     while (CurrentOffset + CFData->UncompSize <= Search->File->FileOffset)
1027     {
1028         /* walk the data blocks until we reach
1029            the one containing the start of the file */
1030         CurrentOffset += CFData->UncompSize;
1031         CFData = (PCFDATA)((char *)(CFData + 1) + DataReserved + CFData->CompSize);
1032     }
1033
1034     Search->CFData = CFData;
1035     Search->Offset = CurrentOffset;
1036
1037     /* now decompress and discard any data in
1038        the block before the start of the file */
1039
1040     /* start of comp data */
1041     CurrentBuffer = ((unsigned char *)(CFData + 1)) + DataReserved;
1042     RemainingBlock = CFData->CompSize;
1043     InputLength = RemainingBlock;
1044
1045     while (CurrentOffset < Search->File->FileOffset)
1046     {
1047         /* compute remaining uncomp bytes to start
1048            of file, bounded by sizeof junk */
1049         OutputLength = Search->File->FileOffset - CurrentOffset;
1050         if (OutputLength > (LONG)sizeof(Junk))
1051             OutputLength = sizeof (Junk);
1052
1053         /* negate to signal NOT end of block */
1054         OutputLength = -OutputLength;
1055         CodecUncompress(Junk, CurrentBuffer, &InputLength, &OutputLength);
1056         /* add the uncomp bytes extracted to current folder offset */
1057         CurrentOffset += OutputLength;
1058         /* add comp bytes consumed to CurrentBuffer */
1059         CurrentBuffer += InputLength;
1060         /* subtract bytes consumed from bytes remaining in block */
1061         RemainingBlock -= InputLength;
1062         /* neg for resume decompression of the same block */
1063         InputLength = -RemainingBlock;
1064     }
1065
1066     /* now CurrentBuffer points to the first comp byte
1067        of the file, so we can begin decompressing */
1068
1069     /* Size = remaining uncomp bytes of the file to decompress */
1070     Size = Search->File->FileSize;
1071     while (Size > 0)
1072     {
1073         OutputLength = Size;
1074         DPRINT("Decompressing block at %x with RemainingBlock = %d, Size = %d\n",
1075                CurrentBuffer, RemainingBlock, Size);
1076
1077         Status = CodecUncompress(CurrentDestBuffer,
1078                                  CurrentBuffer,
1079                                  &InputLength,
1080                                  &OutputLength);
1081
1082         if (Status != CS_SUCCESS)
1083         {
1084             DPRINT("Cannot uncompress block\n");
1085             if (Status == CS_NOMEMORY)
1086                 Status = CAB_STATUS_NOMEMORY;
1087             Status = CAB_STATUS_INVALID_CAB;
1088             goto UnmapDestFile;
1089         }
1090
1091         /* advance dest buffer by bytes produced */
1092         CurrentDestBuffer = (PVOID)((ULONG_PTR)CurrentDestBuffer + OutputLength);
1093         /* advance src buffer by bytes consumed */
1094         CurrentBuffer += InputLength;
1095         /* reduce remaining file bytes by bytes produced */
1096         Size -= OutputLength;
1097         /* reduce remaining block size by bytes consumed */
1098         RemainingBlock -= InputLength;
1099         if (RemainingBlock == 0)
1100         {
1101             /* used up this block, move on to the next */
1102             DPRINT("Out of block data\n");
1103             CFData = (PCFDATA)CurrentBuffer;
1104             RemainingBlock = CFData->CompSize;
1105             CurrentBuffer = (unsigned char *)(CFData + 1) + DataReserved;
1106             InputLength = RemainingBlock;
1107         }
1108     }
1109
1110     Status = CAB_STATUS_SUCCESS;
1111
1112 UnmapDestFile:
1113     NtUnmapViewOfSection(NtCurrentProcess(), DestFileBuffer);
1114
1115 CloseDestFileSection:
1116     NtClose(DestFileSection);
1117
1118 CloseDestFile:
1119     NtClose(DestFile);
1120
1121     return Status;
1122 }
1123
1124 /*
1125  * FUNCTION: Selects codec engine to use
1126  * ARGUMENTS:
1127  *     Id = Codec identifier
1128  */
1129 VOID
1130 CabinetSelectCodec(ULONG Id)
1131 {
1132     if (CodecSelected)
1133     {
1134         if (Id == CodecId)
1135             return;
1136
1137         CodecSelected = FALSE;
1138     }
1139
1140     switch (Id)
1141     {
1142         case CAB_CODEC_RAW:
1143             CodecUncompress = RawCodecUncompress;
1144             break;
1145         case CAB_CODEC_MSZIP:
1146             CodecUncompress = MSZipCodecUncompress;
1147             break;
1148         default:
1149             return;
1150     }
1151
1152     CodecId = Id;
1153     CodecSelected = TRUE;
1154 }
1155
1156 /*
1157  * FUNCTION: Set event handlers
1158  * ARGUMENTS:
1159  *     Overwrite = Handler called when a file is to be overwritten
1160  *     Extract = Handler called when a file is to be extracted
1161  *     DiskChange = Handler called when changing the disk
1162  */
1163 VOID
1164 CabinetSetEventHandlers(PCABINET_OVERWRITE Overwrite,
1165                         PCABINET_EXTRACT Extract,
1166                         PCABINET_DISK_CHANGE DiskChange)
1167 {
1168     OverwriteHandler = Overwrite;
1169     ExtractHandler = Extract;
1170     DiskChangeHandler = DiskChange;
1171 }
1172
1173 /*
1174  * FUNCTION: Get pointer to cabinet reserved area. NULL if none
1175  */
1176 PVOID
1177 CabinetGetCabinetReservedArea(PULONG Size)
1178 {
1179     if (CabinetReservedArea != NULL)
1180     {
1181         if (Size != NULL)
1182         {
1183             *Size = CabinetReserved;
1184         }
1185
1186         return CabinetReservedArea;
1187     }
1188     else
1189     {
1190         if (Size != NULL)
1191         {
1192             *Size = 0;
1193         }
1194
1195         return NULL;
1196     }
1197 }