cabinet.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_CAB_SEARCH
struct	_CABINET_CONTEXT

Macros
#define	CAB_STATUS_SUCCESS   0x00000000
#define	CAB_STATUS_FAILURE   0x00000001
#define	CAB_STATUS_NOMEMORY   0x00000002
#define	CAB_STATUS_CANNOT_OPEN   0x00000003
#define	CAB_STATUS_CANNOT_CREATE   0x00000004
#define	CAB_STATUS_CANNOT_READ   0x00000005
#define	CAB_STATUS_CANNOT_WRITE   0x00000006
#define	CAB_STATUS_FILE_EXISTS   0x00000007
#define	CAB_STATUS_INVALID_CAB   0x00000008
#define	CAB_STATUS_NOFILE   0x00000009
#define	CAB_STATUS_UNSUPPCOMP   0x0000000A
#define	CS_SUCCESS   0x0000 /* All data consumed */
#define	CS_NOMEMORY   0x0001 /* Not enough free memory */
#define	CS_BADSTREAM   0x0002 /* Bad data stream */
#define	CAB_CODEC_RAW   0x00
#define	CAB_CODEC_LZX   0x01
#define	CAB_CODEC_MSZIP   0x02

Typedefs
typedef struct _CFHEADER *	PCFHEADER
typedef struct _CFFOLDER *	PCFFOLDER
typedef struct _CFFILE *	PCFFILE
typedef struct _CFDATA *	PCFDATA
typedef struct _CAB_CODEC *	PCAB_CODEC
typedef BOOL(*	PCABINET_OVERWRITE) (IN struct _CABINET_CONTEXT *CabinetContext, IN PCFFILE File, IN PCWSTR FileName)
typedef VOID(*	PCABINET_EXTRACT) (IN struct _CABINET_CONTEXT *CabinetContext, IN PCFFILE File, IN PCWSTR FileName)
typedef VOID(*	PCABINET_DISK_CHANGE) (IN struct _CABINET_CONTEXT *CabinetContext, IN PCWSTR CabinetName, IN PCWSTR DiskLabel)
typedef PVOID(*	PCABINET_CREATE_FILE) (IN struct _CABINET_CONTEXT *CabinetContext, IN ULONG FileSize)
typedef struct _CAB_SEARCH	CAB_SEARCH
typedef struct _CAB_SEARCH *	PCAB_SEARCH
typedef struct _CABINET_CONTEXT	CABINET_CONTEXT
typedef struct _CABINET_CONTEXT *	PCABINET_CONTEXT

Functions
VOID	CabinetInitialize (IN OUT PCABINET_CONTEXT CabinetContext)
VOID	CabinetCleanup (IN OUT PCABINET_CONTEXT CabinetContext)
PCWSTR	CabinetGetCabinetName (IN PCABINET_CONTEXT CabinetContext)
VOID	CabinetSetCabinetName (IN PCABINET_CONTEXT CabinetContext, IN PCWSTR FileName)
VOID	CabinetSetDestinationPath (IN PCABINET_CONTEXT CabinetContext, IN PCWSTR DestinationPath)
PCWSTR	CabinetGetDestinationPath (IN PCABINET_CONTEXT CabinetContext)
ULONG	CabinetOpen (IN OUT PCABINET_CONTEXT CabinetContext)
VOID	CabinetClose (IN OUT PCABINET_CONTEXT CabinetContext)
ULONG	CabinetFindFirst (IN PCABINET_CONTEXT CabinetContext, IN PCWSTR FileName, IN OUT PCAB_SEARCH Search)
ULONG	CabinetFindNext (IN PCABINET_CONTEXT CabinetContext, IN OUT PCAB_SEARCH Search)
ULONG	CabinetFindNextFileSequential (IN PCABINET_CONTEXT CabinetContext, IN PCWSTR FileName, IN OUT PCAB_SEARCH Search)
ULONG	CabinetExtractFile (IN PCABINET_CONTEXT CabinetContext, IN PCAB_SEARCH Search)
VOID	CabinetSelectCodec (IN PCABINET_CONTEXT CabinetContext, IN ULONG Id)
VOID	CabinetSetEventHandlers (IN PCABINET_CONTEXT CabinetContext, IN PCABINET_OVERWRITE Overwrite, IN PCABINET_EXTRACT Extract, IN PCABINET_DISK_CHANGE DiskChange, IN PCABINET_CREATE_FILE CreateFile)
PVOID	CabinetGetCabinetReservedArea (IN PCABINET_CONTEXT CabinetContext, OUT PULONG Size)

Macro Definition Documentation

CAB_CODEC_LZX

#define CAB_CODEC_LZX   0x01

Definition at line 47 of file cabinet.h.

CAB_CODEC_MSZIP

#define CAB_CODEC_MSZIP   0x02

Definition at line 48 of file cabinet.h.

CAB_CODEC_RAW

#define CAB_CODEC_RAW   0x00

Definition at line 46 of file cabinet.h.

CAB_STATUS_CANNOT_CREATE

#define CAB_STATUS_CANNOT_CREATE   0x00000004

Definition at line 27 of file cabinet.h.

CAB_STATUS_CANNOT_OPEN

#define CAB_STATUS_CANNOT_OPEN   0x00000003

Definition at line 26 of file cabinet.h.

CAB_STATUS_CANNOT_READ

#define CAB_STATUS_CANNOT_READ   0x00000005

Definition at line 28 of file cabinet.h.

CAB_STATUS_CANNOT_WRITE

#define CAB_STATUS_CANNOT_WRITE   0x00000006

Definition at line 29 of file cabinet.h.

CAB_STATUS_FAILURE

#define CAB_STATUS_FAILURE   0x00000001

Definition at line 24 of file cabinet.h.

CAB_STATUS_FILE_EXISTS

#define CAB_STATUS_FILE_EXISTS   0x00000007

Definition at line 30 of file cabinet.h.

CAB_STATUS_INVALID_CAB

#define CAB_STATUS_INVALID_CAB   0x00000008

Definition at line 31 of file cabinet.h.

CAB_STATUS_NOFILE

#define CAB_STATUS_NOFILE   0x00000009

Definition at line 32 of file cabinet.h.

CAB_STATUS_NOMEMORY

#define CAB_STATUS_NOMEMORY   0x00000002

Definition at line 25 of file cabinet.h.

CAB_STATUS_SUCCESS

#define CAB_STATUS_SUCCESS   0x00000000

Definition at line 23 of file cabinet.h.

CAB_STATUS_UNSUPPCOMP

#define CAB_STATUS_UNSUPPCOMP   0x0000000A

Definition at line 33 of file cabinet.h.

CS_BADSTREAM

#define CS_BADSTREAM   0x0002 /* Bad data stream */

Definition at line 43 of file cabinet.h.

CS_NOMEMORY

#define CS_NOMEMORY   0x0001 /* Not enough free memory */

Definition at line 42 of file cabinet.h.

CS_SUCCESS

#define CS_SUCCESS   0x0000 /* All data consumed */

Definition at line 41 of file cabinet.h.

Typedef Documentation

CAB_SEARCH

typedef struct _CAB_SEARCH CAB_SEARCH

CABINET_CONTEXT

typedef struct _CABINET_CONTEXT CABINET_CONTEXT

PCAB_CODEC

typedef struct _CAB_CODEC* PCAB_CODEC

Definition at line 38 of file cabinet.h.

PCAB_SEARCH

typedef struct _CAB_SEARCH * PCAB_SEARCH

PCABINET_CONTEXT

typedef struct _CABINET_CONTEXT * PCABINET_CONTEXT

PCABINET_CREATE_FILE

typedef PVOID(* PCABINET_CREATE_FILE) (IN struct _CABINET_CONTEXT *CabinetContext, IN ULONG FileSize)

Definition at line 68 of file cabinet.h.

PCABINET_DISK_CHANGE

typedef VOID(* PCABINET_DISK_CHANGE) (IN struct _CABINET_CONTEXT *CabinetContext, IN PCWSTR CabinetName, IN PCWSTR DiskLabel)

Definition at line 63 of file cabinet.h.

PCABINET_EXTRACT

typedef VOID(* PCABINET_EXTRACT) (IN struct _CABINET_CONTEXT *CabinetContext, IN PCFFILE File, IN PCWSTR FileName)

Definition at line 58 of file cabinet.h.

PCABINET_OVERWRITE

typedef BOOL(* PCABINET_OVERWRITE) (IN struct _CABINET_CONTEXT *CabinetContext, IN PCFFILE File, IN PCWSTR FileName)

Definition at line 53 of file cabinet.h.

PCFDATA

typedef struct _CFDATA* PCFDATA

Definition at line 15 of file cabinet.h.

PCFFILE

typedef struct _CFFILE* PCFFILE

Definition at line 14 of file cabinet.h.

PCFFOLDER

typedef struct _CFFOLDER* PCFFOLDER

Definition at line 13 of file cabinet.h.

PCFHEADER

typedef struct _CFHEADER* PCFHEADER

Definition at line 12 of file cabinet.h.

Function Documentation

CabinetCleanup()

VOID CabinetCleanup

(

IN OUT PCABINET_CONTEXT

CabinetContext

)

Definition at line 529 of file cabinet.c.

{
    CabinetClose(CabinetContext);
}

Referenced by PrepareFileCopy(), and SetupExtractFile().

CabinetClose()

VOID CabinetClose

(

IN OUT PCABINET_CONTEXT

CabinetContext

)

Definition at line 801 of file cabinet.c.

{
    if (!CabinetContext->FileOpen)
        return;
 
    CloseCabinet(CabinetContext);
    CabinetContext->FileOpen = FALSE;
}

Referenced by CabinetCleanup(), and SetConsoleOutputCP().

CabinetExtractFile()

ULONG CabinetExtractFile	(	IN PCABINET_CONTEXT	CabinetContext,
		IN PCAB_SEARCH	Search
	)

Definition at line 959 of file cabinet.c.

{
    ULONG Size;                 // remaining file bytes to decompress
    ULONG CurrentOffset;        // current uncompressed offset within the folder
    PUCHAR CurrentBuffer;       // current pointer to compressed data in the block
    LONG RemainingBlock;        // remaining comp data in the block
    HANDLE DestFile;
    HANDLE DestFileSection;
    PVOID DestFileBuffer;       // mapped view of dest file
    PVOID CurrentDestBuffer;    // pointer to the current position in the dest view
    PCFDATA CFData;             // current data block
    ULONG Status;
    FILETIME FileTime;
    WCHAR DestName[MAX_PATH];
    NTSTATUS NtStatus;
    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES ObjectAttributes;
    FILE_BASIC_INFORMATION FileBasic;
    PCFFOLDER CurrentFolder;
    LARGE_INTEGER MaxDestFileSize;
    LONG InputLength, OutputLength;
    SIZE_T StringLength;
    char Chunk[512];
 
    if (wcscmp(Search->Cabinet, CabinetContext->CabinetName) != 0)
    {
        /* the file is not in the current cabinet */
        DPRINT("File is not in this cabinet (%S != %S)\n",
               Search->Cabinet, CabinetContext->CabinetName);
        return CAB_STATUS_NOFILE;
    }
 
    /* look up the folder that the file specifies */
    if (Search->File->FolderIndex == 0xFFFD ||
        Search->File->FolderIndex == 0xFFFF)
    {
        /* folder is continued from previous cabinet,
           that shouldn't happen here */
        return CAB_STATUS_NOFILE;
    }
    else if (Search->File->FolderIndex == 0xFFFE)
    {
        /* folder is the last in this cabinet and continues into next */
        CurrentFolder = &CabinetContext->CabinetFolders[CabinetContext->PCABHeader->FolderCount - 1];
    }
    else
    {
        /* folder is completely contained within this cabinet */
        CurrentFolder = &CabinetContext->CabinetFolders[Search->File->FolderIndex];
    }
 
    switch (CurrentFolder->CompressionType & CAB_COMP_MASK)
    {
        case CAB_COMP_NONE:
            CabinetSelectCodec(CabinetContext, CAB_CODEC_RAW);
            break;
        case CAB_COMP_MSZIP:
            CabinetSelectCodec(CabinetContext, CAB_CODEC_MSZIP);
            break;
        default:
            return CAB_STATUS_UNSUPPCOMP;
    }
 
    DPRINT("Extracting file at uncompressed offset (0x%X) Size (%d bytes)\n",
           (UINT)Search->File->FileOffset, (UINT)Search->File->FileSize);
 
    if (CabinetContext->CreateFileHandler)
    {
        /* Call create context */
        CurrentDestBuffer = CabinetContext->CreateFileHandler(CabinetContext, Search->File->FileSize);
        if (!CurrentDestBuffer)
        {
            DPRINT1("CreateFileHandler() failed\n");
            return CAB_STATUS_CANNOT_CREATE;
        }
    }
    else
    {
        RtlInitAnsiString(&AnsiString, Search->File->FileName);
        wcscpy(DestName, CabinetContext->DestPath);
        StringLength = wcslen(DestName);
        UnicodeString.MaximumLength = sizeof(DestName) - (USHORT)StringLength * sizeof(WCHAR);
        UnicodeString.Buffer = DestName + StringLength;
        UnicodeString.Length = 0;
        RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
 
        /* Create destination file, fail if it already exists */
        RtlInitUnicodeString(&UnicodeString, DestName);
 
        InitializeObjectAttributes(&ObjectAttributes,
                                   &UnicodeString,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL, NULL);
 
        NtStatus = NtCreateFile(&DestFile,
                                GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                                &ObjectAttributes,
                                &IoStatusBlock,
                                NULL,
                                FILE_ATTRIBUTE_NORMAL,
                                0,
                                FILE_CREATE,
                                FILE_SYNCHRONOUS_IO_NONALERT,
                                NULL, 0);
 
        if (!NT_SUCCESS(NtStatus))
        {
            DPRINT("NtCreateFile() failed (%S) (%x)\n", DestName, NtStatus);
 
            /* If file exists, ask to overwrite file */
            if (CabinetContext->OverwriteHandler == NULL ||
                CabinetContext->OverwriteHandler(CabinetContext, Search->File, DestName))
            {
                /* Create destination file, overwrite if it already exists */
                NtStatus = NtCreateFile(&DestFile,
                                        GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                                        &ObjectAttributes,
                                        &IoStatusBlock,
                                        NULL,
                                        FILE_ATTRIBUTE_NORMAL,
                                        0,
                                        FILE_OVERWRITE,
                                        FILE_SYNCHRONOUS_IO_ALERT,
                                        NULL, 0);
 
                if (!NT_SUCCESS(NtStatus))
                {
                    DPRINT1("NtCreateFile() failed (%S) (%x)\n", DestName, NtStatus);
                    return CAB_STATUS_CANNOT_CREATE;
                }
            }
            else
            {
                DPRINT1("File (%S) exists\n", DestName);
                return CAB_STATUS_FILE_EXISTS;
            }
        }
 
        MaxDestFileSize.QuadPart = Search->File->FileSize;
        NtStatus = NtCreateSection(&DestFileSection,
                                   SECTION_ALL_ACCESS,
                                   0,
                                   &MaxDestFileSize,
                                   PAGE_READWRITE,
                                   SEC_COMMIT,
                                   DestFile);
 
        if (!NT_SUCCESS(NtStatus))
        {
            DPRINT1("NtCreateSection failed for %ls: %x\n", DestName, NtStatus);
            Status = CAB_STATUS_NOMEMORY;
            goto CloseDestFile;
        }
 
        DestFileBuffer = 0;
        CabinetContext->DestFileSize = 0;
        NtStatus = NtMapViewOfSection(DestFileSection,
                                      NtCurrentProcess(),
                                      &DestFileBuffer,
                                      0, 0, 0,
                                      &CabinetContext->DestFileSize,
                                      ViewUnmap,
                                      0,
                                      PAGE_READWRITE);
 
        if (!NT_SUCCESS(NtStatus))
        {
            DPRINT1("NtMapViewOfSection failed: %x\n", NtStatus);
            Status = CAB_STATUS_NOMEMORY;
            goto CloseDestFileSection;
        }
 
        CurrentDestBuffer = DestFileBuffer;
        if (!ConvertDosDateTimeToFileTime(Search->File->FileDate,
                                          Search->File->FileTime,
                                          &FileTime))
        {
            DPRINT1("DosDateTimeToFileTime() failed\n");
            Status = CAB_STATUS_CANNOT_WRITE;
            goto UnmapDestFile;
        }
 
        NtStatus = NtQueryInformationFile(DestFile,
                                          &IoStatusBlock,
                                          &FileBasic,
                                          sizeof(FILE_BASIC_INFORMATION),
                                          FileBasicInformation);
        if (!NT_SUCCESS(NtStatus))
        {
            DPRINT("NtQueryInformationFile() failed (%x)\n", NtStatus);
        }
        else
        {
            memcpy(&FileBasic.LastAccessTime, &FileTime, sizeof(FILETIME));
 
            NtStatus = NtSetInformationFile(DestFile,
                                            &IoStatusBlock,
                                            &FileBasic,
                                            sizeof(FILE_BASIC_INFORMATION),
                                            FileBasicInformation);
            if (!NT_SUCCESS(NtStatus))
            {
                DPRINT("NtSetInformationFile() failed (%x)\n", NtStatus);
            }
        }
 
        SetAttributesOnFile(Search->File, DestFile);
    }
 
    /* Call extract event handler */
    if (CabinetContext->ExtractHandler != NULL)
        CabinetContext->ExtractHandler(CabinetContext, Search->File, DestName);
 
    if (Search->CFData)
        CFData = Search->CFData;
    else
        CFData = (PCFDATA)(CabinetContext->CabinetFolders[Search->File->FolderIndex].DataOffset + CabinetContext->FileBuffer);
 
    CurrentOffset = Search->Offset;
    while (CurrentOffset + CFData->UncompSize <= Search->File->FileOffset)
    {
        /* walk the data blocks until we reach
           the one containing the start of the file */
        CurrentOffset += CFData->UncompSize;
        CFData = (PCFDATA)((char *)(CFData + 1) + CabinetContext->DataReserved + CFData->CompSize);
    }
 
    Search->CFData = CFData;
    Search->Offset = CurrentOffset;
 
    /* now decompress and discard any data in
       the block before the start of the file */
 
    /* start of comp data */
    CurrentBuffer = ((unsigned char *)(CFData + 1)) + CabinetContext->DataReserved;
    RemainingBlock = CFData->CompSize;
    InputLength = RemainingBlock;
 
    while (CurrentOffset < Search->File->FileOffset)
    {
        /* compute remaining uncomp bytes to start
           of file, bounded by size of chunk */
        OutputLength = Search->File->FileOffset - CurrentOffset;
        if (OutputLength > (LONG)sizeof(Chunk))
            OutputLength = sizeof(Chunk);
 
        /* negate to signal NOT end of block */
        OutputLength = -OutputLength;
 
        CabinetContext->Codec->Uncompress(CabinetContext->Codec,
                                          Chunk,
                                          CurrentBuffer,
                                          &InputLength,
                                          &OutputLength);
 
        /* add the uncomp bytes extracted to current folder offset */
        CurrentOffset += OutputLength;
        /* add comp bytes consumed to CurrentBuffer */
        CurrentBuffer += InputLength;
        /* subtract bytes consumed from bytes remaining in block */
        RemainingBlock -= InputLength;
        /* neg for resume decompression of the same block */
        InputLength = -RemainingBlock;
    }
 
    /* now CurrentBuffer points to the first comp byte
       of the file, so we can begin decompressing */
 
    /* Size = remaining uncomp bytes of the file to decompress */
    Size = Search->File->FileSize;
    while (Size > 0)
    {
        OutputLength = Size;
        DPRINT("Decompressing block at %x with RemainingBlock = %d, Size = %d\n",
               CurrentBuffer, RemainingBlock, Size);
 
        Status = CabinetContext->Codec->Uncompress(CabinetContext->Codec,
                                                   CurrentDestBuffer,
                                                   CurrentBuffer,
                                                   &InputLength,
                                                   &OutputLength);
        if (Status != CS_SUCCESS)
        {
            DPRINT("Cannot uncompress block\n");
            if (Status == CS_NOMEMORY)
                Status = CAB_STATUS_NOMEMORY;
            Status = CAB_STATUS_INVALID_CAB;
            goto UnmapDestFile;
        }
 
        /* advance dest buffer by bytes produced */
        CurrentDestBuffer = (PVOID)((ULONG_PTR)CurrentDestBuffer + OutputLength);
        /* advance src buffer by bytes consumed */
        CurrentBuffer += InputLength;
        /* reduce remaining file bytes by bytes produced */
        Size -= OutputLength;
        /* reduce remaining block size by bytes consumed */
        RemainingBlock -= InputLength;
        if (Size > 0 && RemainingBlock == 0)
        {
            /* used up this block, move on to the next */
            DPRINT("Out of block data\n");
            CFData = (PCFDATA)CurrentBuffer;
            RemainingBlock = CFData->CompSize;
            CurrentBuffer = (unsigned char *)(CFData + 1) + CabinetContext->DataReserved;
            InputLength = RemainingBlock;
        }
    }
 
    Status = CAB_STATUS_SUCCESS;
 
UnmapDestFile:
    if (!CabinetContext->CreateFileHandler)
        NtUnmapViewOfSection(NtCurrentProcess(), DestFileBuffer);
 
CloseDestFileSection:
    if (!CabinetContext->CreateFileHandler)
        NtClose(DestFileSection);
 
CloseDestFile:
    if (!CabinetContext->CreateFileHandler)
        NtClose(DestFile);
 
    return Status;
}

Referenced by SetConsoleOutputCP(), and SetupExtractFile().

CabinetFindFirst()

ULONG CabinetFindFirst	(	IN PCABINET_CONTEXT	CabinetContext,
		IN PCWSTR	FileName,
		IN OUT PCAB_SEARCH	Search
	)

Definition at line 820 of file cabinet.c.

{
    DPRINT("CabinetFindFirst(FileName = %S)\n", FileName);
    wcsncpy(Search->Search, FileName, MAX_PATH);
    wcsncpy(Search->Cabinet, CabinetContext->CabinetName, MAX_PATH);
    Search->File = 0;
    return CabinetFindNext(CabinetContext, Search);
}

Referenced by SetConsoleOutputCP(), and SetupExtractFile().

CabinetFindNext()

ULONG CabinetFindNext	(	IN PCABINET_CONTEXT	CabinetContext,
		IN OUT PCAB_SEARCH	Search
	)

Definition at line 840 of file cabinet.c.

{
    PCFFILE Prev;
    ANSI_STRING AnsiString;
    UNICODE_STRING UnicodeString;
    WCHAR FileName[MAX_PATH];
 
    if (wcscmp(Search->Cabinet, CabinetContext->CabinetName) != 0)
    {
        /* restart search of cabinet has changed since last find */
        Search->File = 0;
    }
 
    if (!Search->File)
    {
        /* starting new search or cabinet */
        Search->File = (PCFFILE)(CabinetContext->FileBuffer + CabinetContext->PCABHeader->FileTableOffset);
        Search->Index = 0;
        Prev = 0;
    }
    else
        Prev = Search->File;
 
    while (TRUE)
    {
        /* look at each file in the archive and see if we found a match */
        if (Search->File->FolderIndex == 0xFFFD ||
            Search->File->FolderIndex == 0xFFFF)
        {
            /* skip files continued from previous cab */
            DPRINT("Skipping file (%s): FileOffset (0x%X), "
                   "LastFileOffset (0x%X)\n", (char *)(Search->File + 1),
                   Search->File->FileOffset, CabinetContext->LastFileOffset);
        }
        else
        {
            // FIXME: check for match against search criteria
            if (Search->File != Prev)
            {
                if (Prev == NULL || Search->File->FolderIndex != Prev->FolderIndex)
                {
                    Search->CFData = NULL;
                    Search->Offset = 0;
                }
 
                /* don't match the file we started with */
                if (wcscmp(Search->Search, L"*") == 0)
                {
                    /* take any file */
                    break;
                }
                else
                {
                    /* otherwise, try to match the exact file name */
                    RtlInitAnsiString(&AnsiString, Search->File->FileName);
                    UnicodeString.Buffer = FileName;
                    UnicodeString.Buffer[0] = 0;
                    UnicodeString.Length = 0;
                    UnicodeString.MaximumLength = sizeof(FileName);
                    RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
                    if (wcscmp(Search->Search, UnicodeString.Buffer) == 0)
                        break;
                }
            }
        }
 
        /* if we make it here we found no match, so move to the next file */
        Search->Index++;
        if (Search->Index >= CabinetContext->PCABHeader->FileCount)
        {
            /* we have reached the end of this cabinet */
            DPRINT("End of cabinet reached\n");
            return CAB_STATUS_NOFILE;
        }
        else
            Search->File = (PCFFILE)(strchr((char *)(Search->File + 1), 0) + 1);
    }
 
    DPRINT("Found file %s\n", Search->File->FileName);
    return CAB_STATUS_SUCCESS;
}

Referenced by CabinetFindFirst(), and CabinetFindNextFileSequential().

CabinetFindNextFileSequential()

ULONG CabinetFindNextFileSequential	(	IN PCABINET_CONTEXT	CabinetContext,
		IN PCWSTR	FileName,
		IN OUT PCAB_SEARCH	Search
	)

Definition at line 933 of file cabinet.c.

{
    DPRINT("CabinetFindNextFileSequential(FileName = %S)\n", FileName);
    wcsncpy(Search->Search, FileName, MAX_PATH);
    return CabinetFindNext(CabinetContext, Search);
}

Referenced by SetupExtractFile().

CabinetGetCabinetName()

PCWSTR CabinetGetCabinetName

(

IN PCABINET_CONTEXT

CabinetContext

)

Definition at line 568 of file cabinet.c.

{
    return CabinetContext->CabinetName;
}

Referenced by SetupExtractFile().

CabinetGetCabinetReservedArea()

PVOID CabinetGetCabinetReservedArea	(	IN PCABINET_CONTEXT	CabinetContext,
		OUT PULONG	Size
	)

Definition at line 1357 of file cabinet.c.

{
    if (CabinetContext->CabinetReservedArea != NULL)
    {
        if (Size != NULL)
        {
            *Size = CabinetContext->CabinetReserved;
        }
 
        return CabinetContext->CabinetReservedArea;
    }
    else
    {
        if (Size != NULL)
        {
            *Size = 0;
        }
 
        return NULL;
    }
}

Referenced by PrepareFileCopy().

CabinetGetDestinationPath()

PCWSTR CabinetGetDestinationPath

(

IN PCABINET_CONTEXT

CabinetContext

)

Definition at line 609 of file cabinet.c.

{
    return CabinetContext->DestPath;
}

CabinetInitialize()

VOID CabinetInitialize

(

IN OUT PCABINET_CONTEXT

CabinetContext

)

Definition at line 501 of file cabinet.c.

{
    RtlZeroMemory(CabinetContext, sizeof(*CabinetContext));
 
    CabinetContext->FileOpen = FALSE;
    wcscpy(CabinetContext->DestPath, L"");
 
    CabinetContext->CodecSelected = FALSE;
    CabinetSelectCodec(CabinetContext, CAB_CODEC_RAW);
 
    CabinetContext->OverwriteHandler = NULL;
    CabinetContext->ExtractHandler = NULL;
    CabinetContext->DiskChangeHandler = NULL;
 
    CabinetContext->FolderUncompSize = 0;
    CabinetContext->BytesLeftInBlock = 0;
    CabinetContext->CabinetReserved = 0;
    CabinetContext->FolderReserved = 0;
    CabinetContext->DataReserved = 0;
    CabinetContext->CabinetReservedArea = NULL;
    CabinetContext->LastFileOffset = 0;
}

Referenced by PrepareFileCopy(), SetConsoleOutputCP(), and SetupExtractFile().

CabinetOpen()

ULONG CabinetOpen

(

IN OUT PCABINET_CONTEXT

CabinetContext

)

Definition at line 621 of file cabinet.c.

{
    PUCHAR Buffer;
    UNICODE_STRING ustring;
    ANSI_STRING astring;
 
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING FileName;
    USHORT StringLength;
    NTSTATUS NtStatus;
 
    if (CabinetContext->FileOpen)
    {
        /* Cabinet file already opened */
        DPRINT("CabinetOpen returning SUCCESS\n");
        return CAB_STATUS_SUCCESS;
    }
 
    RtlInitUnicodeString(&FileName, CabinetContext->CabinetName);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &FileName,
                               OBJ_CASE_INSENSITIVE,
                               NULL, NULL);
 
    NtStatus = NtOpenFile(&CabinetContext->FileHandle,
                          GENERIC_READ | SYNCHRONIZE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          FILE_SHARE_READ,
                          FILE_SYNCHRONOUS_IO_NONALERT);
 
    if (!NT_SUCCESS(NtStatus))
    {
        DPRINT1("Cannot open file (%S) (%x)\n", CabinetContext->CabinetName, NtStatus);
        return CAB_STATUS_CANNOT_OPEN;
    }
 
    CabinetContext->FileOpen = TRUE;
 
    NtStatus = NtCreateSection(&CabinetContext->FileSectionHandle,
                               SECTION_ALL_ACCESS,
                               0, 0,
                               PAGE_READONLY,
                               SEC_COMMIT,
                               CabinetContext->FileHandle);
 
    if (!NT_SUCCESS(NtStatus))
    {
        DPRINT1("NtCreateSection failed for %ls: %x\n", CabinetContext->CabinetName, NtStatus);
        return CAB_STATUS_NOMEMORY;
    }
 
    CabinetContext->FileBuffer = 0;
    CabinetContext->FileSize = 0;
 
    NtStatus = NtMapViewOfSection(CabinetContext->FileSectionHandle,
                                  NtCurrentProcess(),
                                  (PVOID*)&CabinetContext->FileBuffer,
                                  0, 0, 0,
                                  &CabinetContext->FileSize,
                                  ViewUnmap,
                                  0,
                                  PAGE_READONLY);
 
    if (!NT_SUCCESS(NtStatus))
    {
        DPRINT1("NtMapViewOfSection failed: %x\n", NtStatus);
        return CAB_STATUS_NOMEMORY;
    }
 
    DPRINT("Cabinet file %S opened and mapped to %x\n",
           CabinetContext->CabinetName, CabinetContext->FileBuffer);
    CabinetContext->PCABHeader = (PCFHEADER)CabinetContext->FileBuffer;
 
    /* Check header */
    if (CabinetContext->FileSize <= sizeof(CFHEADER) ||
        CabinetContext->PCABHeader->Signature != CAB_SIGNATURE ||
        CabinetContext->PCABHeader->Version != CAB_VERSION ||
        CabinetContext->PCABHeader->FolderCount == 0 ||
        CabinetContext->PCABHeader->FileCount == 0 ||
        CabinetContext->PCABHeader->FileTableOffset < sizeof(CFHEADER))
    {
        CloseCabinet(CabinetContext);
        DPRINT1("File has invalid header\n");
        return CAB_STATUS_INVALID_CAB;
    }
 
    Buffer = (PUCHAR)(CabinetContext->PCABHeader + 1);
 
    /* Read/skip any reserved bytes */
    if (CabinetContext->PCABHeader->Flags & CAB_FLAG_RESERVE)
    {
        CabinetContext->CabinetReserved = *(PUSHORT)Buffer;
        Buffer += 2;
        CabinetContext->FolderReserved = *Buffer;
        Buffer++;
        CabinetContext->DataReserved = *Buffer;
        Buffer++;
 
        if (CabinetContext->CabinetReserved > 0)
        {
            CabinetContext->CabinetReservedArea = Buffer;
            Buffer += CabinetContext->CabinetReserved;
        }
    }
 
    if (CabinetContext->PCABHeader->Flags & CAB_FLAG_HASPREV)
    {
        /* The previous cabinet file is in
           the same directory as the current */
        wcscpy(CabinetContext->CabinetPrev, CabinetContext->CabinetName);
        RemoveFileName(CabinetContext->CabinetPrev);
        CabinetNormalizePath(CabinetContext->CabinetPrev, sizeof(CabinetContext->CabinetPrev));
        RtlInitAnsiString(&astring, (LPSTR)Buffer);
 
        /* Initialize ustring with the remaining buffer */
        StringLength = (USHORT)wcslen(CabinetContext->CabinetPrev) * sizeof(WCHAR);
        ustring.Buffer = CabinetContext->CabinetPrev + StringLength;
        ustring.MaximumLength = sizeof(CabinetContext->CabinetPrev) - StringLength;
        ustring.Length = 0;
        RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
        Buffer += astring.Length + 1;
 
        /* Read label of prev disk */
        RtlInitAnsiString(&astring, (LPSTR)Buffer);
        ustring.Length = 0;
        ustring.Buffer = CabinetContext->DiskPrev;
        ustring.MaximumLength = sizeof(CabinetContext->DiskPrev);
        RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
        Buffer += astring.Length + 1;
    }
    else
    {
        wcscpy(CabinetContext->CabinetPrev, L"");
        wcscpy(CabinetContext->DiskPrev, L"");
    }
 
    if (CabinetContext->PCABHeader->Flags & CAB_FLAG_HASNEXT)
    {
        /* The next cabinet file is in
           the same directory as the previous */
        wcscpy(CabinetContext->CabinetNext, CabinetContext->CabinetName);
        RemoveFileName(CabinetContext->CabinetNext);
        CabinetNormalizePath(CabinetContext->CabinetNext, 256);
        RtlInitAnsiString(&astring, (LPSTR)Buffer);
 
        /* Initialize ustring with the remaining buffer */
        StringLength = (USHORT)wcslen(CabinetContext->CabinetNext) * sizeof(WCHAR);
        ustring.Buffer = CabinetContext->CabinetNext + StringLength;
        ustring.MaximumLength = sizeof(CabinetContext->CabinetNext) - StringLength;
        ustring.Length = 0;
        RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
        Buffer += astring.Length + 1;
 
        /* Read label of next disk */
        RtlInitAnsiString(&astring, (LPSTR)Buffer);
        ustring.Length = 0;
        ustring.Buffer = CabinetContext->DiskNext;
        ustring.MaximumLength = sizeof(CabinetContext->DiskNext);
        RtlAnsiStringToUnicodeString(&ustring, &astring, FALSE);
        Buffer += astring.Length + 1;
    }
    else
    {
        wcscpy(CabinetContext->CabinetNext, L"");
        wcscpy(CabinetContext->DiskNext, L"");
    }
    CabinetContext->CabinetFolders = (PCFFOLDER)Buffer;
 
    DPRINT("CabinetOpen returning SUCCESS\n");
    return CAB_STATUS_SUCCESS;
}

Referenced by PrepareFileCopy(), SetConsoleOutputCP(), and SetupExtractFile().

CabinetSelectCodec()

VOID CabinetSelectCodec	(	IN PCABINET_CONTEXT	CabinetContext,
		IN ULONG	Id
	)

Definition at line 1295 of file cabinet.c.

{
    if (CabinetContext->CodecSelected)
    {
        if (Id == CabinetContext->CodecId)
            return;
 
        CabinetContext->CodecSelected = FALSE;
    }
 
    switch (Id)
    {
        case CAB_CODEC_RAW:
        {
            CabinetContext->Codec = &RawCodec;
            break;
        }
 
        case CAB_CODEC_MSZIP:
        {
            CabinetContext->Codec = &MSZipCodec;
            CabinetContext->Codec->ZStream.zalloc = MSZipAlloc;
            CabinetContext->Codec->ZStream.zfree = MSZipFree;
            CabinetContext->Codec->ZStream.opaque = (voidpf)0;
            break;
        }
 
        default:
            return;
    }
 
    CabinetContext->CodecId = Id;
    CabinetContext->CodecSelected = TRUE;
}

Referenced by CabinetExtractFile(), and CabinetInitialize().

CabinetSetCabinetName()

VOID CabinetSetCabinetName	(	IN PCABINET_CONTEXT	CabinetContext,
		IN PCWSTR	FileName
	)

Definition at line 580 of file cabinet.c.

{
    wcscpy(CabinetContext->CabinetName, FileName);
}

Referenced by PrepareFileCopy(), SetConsoleOutputCP(), and SetupExtractFile().

CabinetSetDestinationPath()

VOID CabinetSetDestinationPath	(	IN PCABINET_CONTEXT	CabinetContext,
		IN PCWSTR	DestinationPath
	)

Definition at line 593 of file cabinet.c.

{
    wcscpy(CabinetContext->DestPath, DestinationPath);
 
    if (wcslen(CabinetContext->DestPath) > 0)
        CabinetNormalizePath(CabinetContext->DestPath, MAX_PATH);
}

Referenced by SetupExtractFile().

CabinetSetEventHandlers()

VOID CabinetSetEventHandlers	(	IN PCABINET_CONTEXT	CabinetContext,
		IN PCABINET_OVERWRITE	Overwrite,
		IN PCABINET_EXTRACT	Extract,
		IN PCABINET_DISK_CHANGE	DiskChange,
		IN PCABINET_CREATE_FILE	CreateFile
	)

Definition at line 1340 of file cabinet.c.

{
    CabinetContext->OverwriteHandler = Overwrite;
    CabinetContext->ExtractHandler = Extract;
    CabinetContext->DiskChangeHandler = DiskChange;
    CabinetContext->CreateFileHandler = CreateFile;
}

Referenced by PrepareFileCopy(), SetConsoleOutputCP(), and SetupExtractFile().