CCabinet Class Reference

#include <cabinet.h>

Inheritance diagram for CCabinet:

Collaboration diagram for CCabinet:

Public Member Functions
	CCabinet ()
virtual	~CCabinet ()
bool	IsSeparator (char Char)
void	ConvertPath (std::string &Path)
std::string	GetFileName (const std::string &Path)
void	NormalizePath (std::string &Path)
char *	GetCabinetName ()
void	SetCabinetName (const char *FileName)
void	SetDestinationPath (const char *DestinationPath)
bool	SetCabinetReservedFile (const char *FileName)
const char *	GetDestinationPath ()
ULONG	GetCurrentDiskNumber ()
ULONG	Open ()
void	Close ()
ULONG	FindFirst (PCAB_SEARCH Search)
ULONG	FindNext (PCAB_SEARCH Search)
ULONG	ExtractFile (const char *FileName)
void	SelectCodec (LONG Id)
bool	IsCodecSelected ()
ULONG	AddSearchCriteria (const std::string &SearchCriteria, const std::string &TargetFolder)
void	DestroySearchCriteria ()
bool	HasSearchCriteria ()
std::string	CreateCabFilename (PCFFILE_NODE Node)
bool	CreateSimpleCabinet ()
bool	SetCompressionCodec (const char *CodecName)
ULONG	NewCabinet ()
ULONG	NewDisk ()
ULONG	NewFolder ()
ULONG	WriteFileToScratchStorage (PCFFILE_NODE FileNode)
ULONG	WriteDisk (ULONG MoreDisks)
ULONG	CommitDisk (ULONG MoreDisks)
ULONG	CloseDisk ()
ULONG	CloseCabinet ()
ULONG	AddFile (const std::string &FileName, const std::string &TargetFolder)
void	SetMaxDiskSize (ULONG Size)
virtual bool	OnOverwrite (PCFFILE Entry, const char *FileName)
virtual void	OnExtract (PCFFILE Entry, const char *FileName)
virtual void	OnDiskChange (const char *CabinetName, const char *DiskLabel)
virtual void	OnVerboseMessage (const char *Message)
virtual void	OnAdd (PCFFILE Entry, const char *FileName)
virtual bool	OnCabinetName (ULONG Number, char *Name)
virtual bool	OnDiskLabel (ULONG Number, char *Label)

Private Member Functions
PCFFOLDER_NODE	LocateFolderNode (ULONG Index)
ULONG	GetAbsoluteOffset (PCFFILE_NODE File)
ULONG	LocateFile (const char *FileName, PCFFILE_NODE *File)
ULONG	ReadString (char *String, LONG MaxLength)
ULONG	ReadFileTable ()
ULONG	ReadDataBlocks (PCFFOLDER_NODE FolderNode)
PCFFOLDER_NODE	NewFolderNode ()
PCFFILE_NODE	NewFileNode ()
PCFDATA_NODE	NewDataNode (PCFFOLDER_NODE FolderNode)
void	DestroyDataNodes (PCFFOLDER_NODE FolderNode)
void	DestroyFileNodes ()
void	DestroyDeletedFileNodes ()
void	DestroyFolderNodes ()
void	DestroyDeletedFolderNodes ()
ULONG	ComputeChecksum (void *Buffer, ULONG Size, ULONG Seed)
ULONG	ReadBlock (void *Buffer, ULONG Size, PULONG BytesRead)
bool	MatchFileNamePattern (const char *FileName, const char *Pattern)
ULONG	InitCabinetHeader ()
ULONG	WriteCabinetHeader (bool MoreDisks)
ULONG	WriteFolderEntries ()
ULONG	WriteFileEntries ()
ULONG	CommitDataBlocks (PCFFOLDER_NODE FolderNode)
ULONG	WriteDataBlock ()
ULONG	GetAttributesOnFile (PCFFILE_NODE File)
ULONG	SetAttributesOnFile (char *FileName, USHORT FileAttributes)
ULONG	GetFileTimes (FILE *FileHandle, PCFFILE_NODE File)
void	ConvertDateAndTime (time_t *Time, PUSHORT DosDate, PUSHORT DosTime)

Private Attributes
ULONG	CurrentDiskNumber
char	CabinetName [256]
char	CabinetPrev [256]
char	DiskPrev [256]
char	CabinetNext [256]
char	DiskNext [256]
ULONG	TotalHeaderSize
ULONG	NextFieldsSize
ULONG	TotalFolderSize
ULONG	TotalFileSize
ULONG	FolderUncompSize
ULONG	BytesLeftInBlock
bool	ReuseBlock
std::string	DestPath
std::string	CabinetReservedFile
void *	CabinetReservedFileBuffer
ULONG	CabinetReservedFileSize
FILE *	FileHandle
bool	FileOpen
CFHEADER	CABHeader
ULONG	CabinetReserved
ULONG	FolderReserved
ULONG	DataReserved
std::list< PCFFOLDER_NODE >	FolderList
PCFFOLDER_NODE	CurrentFolderNode
PCFDATA_NODE	CurrentDataNode
std::list< PCFFILE_NODE >	FileList
std::list< PSEARCH_CRITERIA >	CriteriaList
CCABCodec *	Codec
LONG	CodecId
bool	CodecSelected
void *	InputBuffer
void *	CurrentIBuffer
ULONG	CurrentIBufferSize
void *	OutputBuffer
ULONG	TotalCompSize
void *	CurrentOBuffer
ULONG	CurrentOBufferSize
ULONG	BytesLeftInCabinet
bool	RestartSearch
ULONG	LastFileOffset
ULONG	LastBlockStart
ULONG	MaxDiskSize
ULONG	DiskSize
ULONG	PrevCabinetNumber
bool	CreateNewDisk
bool	CreateNewFolder
class CCFDATAStorage *	ScratchFile
FILE *	SourceFile
bool	ContinueFile
ULONG	TotalBytesLeft
bool	BlockIsSplit
ULONG	NextFolderNumber

Detailed Description

Definition at line 305 of file cabinet.h.

Constructor & Destructor Documentation

CCabinet()

CCabinet::CCabinet

(

)

Definition at line 71 of file cabinet.cxx.

{
    *CabinetName = '\0';
    *CabinetPrev = '\0';
    *DiskPrev = '\0';
    *CabinetNext = '\0';
    *DiskNext = '\0';
 
    FileOpen = false;
    CabinetReservedFileBuffer = NULL;
    CabinetReservedFileSize = 0;
 
    Codec          = NULL;
    CodecId        = -1;
    CodecSelected  = false;
 
    OutputBuffer = NULL;
    InputBuffer  = NULL;
    MaxDiskSize  = 0;
    BlockIsSplit = false;
    ScratchFile  = NULL;
 
    FolderUncompSize = 0;
    BytesLeftInBlock = 0;
    ReuseBlock       = false;
    CurrentDataNode  = NULL;
}

~CCabinet()

CCabinet::~CCabinet ( )

virtual

Definition at line 103 of file cabinet.cxx.

{
    if (CabinetReservedFileBuffer != NULL)
    {
        free(CabinetReservedFileBuffer);
        CabinetReservedFileBuffer = NULL;
        CabinetReservedFileSize = 0;
    }
 
    if (CodecSelected)
        delete Codec;
}

Member Function Documentation

AddFile()

ULONG CCabinet::AddFile	(	const std::string &	FileName,
		const std::string &	TargetFolder
	)

Definition at line 1515 of file cabinet.cxx.

{
    FILE* SrcFile;
    PCFFILE_NODE FileNode;
    std::string NewFileName;
 
    NewFileName = FileName;
    ConvertPath(NewFileName);
 
    /* Try to open file */
    SrcFile = fopen(NewFileName.c_str(), "rb");
    if (SrcFile == NULL)
    {
        DPRINT(MID_TRACE, ("File not found (%s).\n", NewFileName.c_str()));
        return CAB_STATUS_CANNOT_OPEN;
    }
 
    FileNode = NewFileNode();
    if (!FileNode)
    {
        DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
        fclose(SrcFile);
        return CAB_STATUS_NOMEMORY;
    }
 
    FileNode->FolderNode = CurrentFolderNode;
    FileNode->FileName = NewFileName;
    FileNode->TargetFolder = TargetFolder;
    if (FileNode->TargetFolder.length() > 0 && FileNode->TargetFolder[FileNode->TargetFolder.length() - 1] != '\\')
        FileNode->TargetFolder += '\\';
 
    /* FIXME: Check for and handle large files (>= 2GB) */
    FileNode->File.FileSize = GetSizeOfFile(SrcFile);
    if (FileNode->File.FileSize == (ULONG)-1)
    {
        DPRINT(MIN_TRACE, ("Cannot read from file.\n"));
        fclose(SrcFile);
        return CAB_STATUS_CANNOT_READ;
    }
 
    if (GetFileTimes(SrcFile, FileNode) != CAB_STATUS_SUCCESS)
    {
        DPRINT(MIN_TRACE, ("Cannot read file times.\n"));
        fclose(SrcFile);
        return CAB_STATUS_CANNOT_READ;
    }
 
    if (GetAttributesOnFile(FileNode) != CAB_STATUS_SUCCESS)
    {
        DPRINT(MIN_TRACE, ("Cannot read file attributes.\n"));
        fclose(SrcFile);
        return CAB_STATUS_CANNOT_READ;
    }
 
    fclose(SrcFile);
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CreateSimpleCabinet(), and CDFParser::PerformFileCopy().

AddSearchCriteria()

ULONG CCabinet::AddSearchCriteria	(	const std::string &	SearchCriteria,
		const std::string &	TargetFolder
	)

Definition at line 228 of file cabinet.cxx.

{
    PSEARCH_CRITERIA Criteria;
 
    // Add the criteria to the list of search criteria
    Criteria = new SEARCH_CRITERIA;
    if(!Criteria)
    {
        DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
        return CAB_STATUS_NOMEMORY;
    }
 
    CriteriaList.push_back(Criteria);
 
    // Set the actual criteria string
    Criteria->Search = SearchCriteria;
    Criteria->TargetFolder = TargetFolder;
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CCABManager::ParseCmdline().

Close()

void CCabinet::Close

(

)

Definition at line 538 of file cabinet.cxx.

{
    if (FileOpen)
    {
        fclose(FileHandle);
        FileOpen = false;
    }
}

Referenced by CloseCabinet().

CloseCabinet()

ULONG CCabinet::CloseCabinet

(

)

Definition at line 1477 of file cabinet.cxx.

{
    ULONG Status;
 
    DestroyFileNodes();
 
    DestroyFolderNodes();
 
    if (InputBuffer)
    {
        free(InputBuffer);
        InputBuffer = NULL;
    }
 
    if (OutputBuffer)
    {
        free(OutputBuffer);
        OutputBuffer = NULL;
    }
 
    Close();
 
    if (ScratchFile)
    {
        Status = ScratchFile->Destroy();
        delete ScratchFile;
        return Status;
    }
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CreateSimpleCabinet(), ExtractFile(), FindNext(), Open(), and CDFParser::Parse().

CloseDisk()

ULONG CCabinet::CloseDisk

(

)

Definition at line 1459 of file cabinet.cxx.

{
    DestroyDeletedFileNodes();
 
    /* Destroy folder nodes that are completely stored */
    DestroyDeletedFolderNodes();
 
    CurrentDiskNumber++;
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CreateSimpleCabinet(), CDFParser::Parse(), CDFParser::PerformNewCommand(), and WriteDisk().

CommitDataBlocks()

ULONG CCabinet::CommitDataBlocks ( PCFFOLDER_NODE  FolderNode )

private

Definition at line 2703 of file cabinet.cxx.

{
    ULONG BytesRead;
    ULONG Status;
 
    if (!FolderNode->DataList.empty())
        Status = ScratchFile->Seek(FolderNode->DataList.front()->ScratchFilePosition);
 
    for (PCFDATA_NODE DataNode : FolderNode->DataList)
    {
        DPRINT(MAX_TRACE, ("Reading block at (0x%X)  CompSize (%u)  UncompSize (%u).\n",
            (UINT)DataNode->ScratchFilePosition,
            DataNode->Data.CompSize,
            DataNode->Data.UncompSize));
 
        /* InputBuffer is free for us to use here, so we use it and avoid a
           memory allocation. OutputBuffer can't be used here because it may
           still contain valid data (if a data block spans two or more disks) */
        Status = ScratchFile->ReadBlock(&DataNode->Data, InputBuffer, &BytesRead);
        if (Status != CAB_STATUS_SUCCESS)
        {
            DPRINT(MIN_TRACE, ("Cannot read from scratch file (%u).\n", (UINT)Status));
            return Status;
        }
 
        if (fwrite(&DataNode->Data, sizeof(CFDATA), 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
 
        if (fwrite(InputBuffer, DataNode->Data.CompSize, 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
    }
    return CAB_STATUS_SUCCESS;
}

Referenced by CommitDisk().

CommitDisk()

ULONG CCabinet::CommitDisk

(

ULONG

MoreDisks

)

Definition at line 1393 of file cabinet.cxx.

{
    ULONG Status;
 
    OnCabinetName(CurrentDiskNumber, CabinetName);
 
    /* Create file, fail if it already exists */
    FileHandle = fopen(CabinetName, "rb");
    if (FileHandle != NULL)
    {
        fclose(FileHandle);
        /* If file exists, ask to overwrite file */
        if (OnOverwrite(NULL, CabinetName))
        {
            FileHandle = fopen(CabinetName, "w+b");
            if (FileHandle == NULL)
                return CAB_STATUS_CANNOT_CREATE;
        }
        else
            return CAB_STATUS_FILE_EXISTS;
 
    }
    else
    {
        FileHandle = fopen(CabinetName, "w+b");
        if (FileHandle == NULL)
            return CAB_STATUS_CANNOT_CREATE;
    }
 
    WriteCabinetHeader(MoreDisks != 0);
 
    Status = WriteFolderEntries();
    if (Status != CAB_STATUS_SUCCESS)
        return Status;
 
    /* Write file entries */
    WriteFileEntries();
 
    /* Write data blocks */
    for (PCFFOLDER_NODE FolderNode : FolderList)
    {
        if (FolderNode->Commit)
        {
            Status = CommitDataBlocks(FolderNode);
            if (Status != CAB_STATUS_SUCCESS)
                return Status;
            /* Remove data blocks for folder */
            DestroyDataNodes(FolderNode);
        }
    }
 
    fclose(FileHandle);
 
    ScratchFile->Truncate();
 
    return CAB_STATUS_SUCCESS;
}

Referenced by WriteDisk().

ComputeChecksum()

ULONG CCabinet::ComputeChecksum ( void *  Buffer, ULONG  Size, ULONG  Seed  )

private

Definition at line 2263 of file cabinet.cxx.

{
    int UlongCount; // Number of ULONGs in block
    ULONG Checksum; // Checksum accumulator
    unsigned char* pb;
    ULONG ul;
 
    /* FIXME: Doesn't seem to be correct. EXTRACT.EXE
       won't accept checksums computed by this routine */
 
    DPRINT(MIN_TRACE, ("Checksumming buffer (0x%p)  Size (%u)\n", Buffer, (UINT)Size));
 
    UlongCount = Size / 4;              // Number of ULONGs
    Checksum   = Seed;                  // Init checksum
    pb         = (unsigned char*)Buffer;         // Start at front of data block
 
    /* Checksum integral multiple of ULONGs */
    while (UlongCount-- > 0)
    {
        /* NOTE: Build ULONG in big/little-endian independent manner */
        ul = *pb++;                     // Get low-order byte
        ul |= (((ULONG)(*pb++)) <<  8); // Add 2nd byte
        ul |= (((ULONG)(*pb++)) << 16); // Add 3nd byte
        ul |= (((ULONG)(*pb++)) << 24); // Add 4th byte
 
        Checksum ^= ul;                 // Update checksum
    }
 
    /* Checksum remainder bytes */
    ul = 0;
    switch (Size % 4)
    {
        case 3:
            ul |= (((ULONG)(*pb++)) << 16); // Add 3rd byte
        case 2:
            ul |= (((ULONG)(*pb++)) <<  8); // Add 2nd byte
        case 1:
            ul |= *pb++;                    // Get low-order byte
        default:
            break;
    }
    Checksum ^= ul;                         // Update checksum
 
    /* Return computed checksum */
    return Checksum;
}

ConvertDateAndTime()

void CCabinet::ConvertDateAndTime ( time_t *  Time, PUSHORT  DosDate, PUSHORT  DosTime  )

private

Definition at line 2840 of file cabinet.cxx.

{
    struct tm *timedef;
 
    timedef = localtime(Time);
 
    DPRINT(MAX_TRACE, ("day: %d, mon: %d, year:%d, hour: %d, min: %d, sec: %d\n",
        timedef->tm_mday, timedef->tm_mon, timedef->tm_year,
        timedef->tm_sec, timedef->tm_min, timedef->tm_hour));
 
    *DosDate = ((timedef->tm_mday + 1) << 0)
        | ((timedef->tm_mon + 1) << 5)
        | (((timedef->tm_year + 1900) - 1980) << 9);
 
    *DosTime = (timedef->tm_sec << 0)
        | (timedef->tm_min << 5)
        | (timedef->tm_hour << 11);
}

Referenced by GetFileTimes().

ConvertPath()

void CCabinet::ConvertPath

(

std::string &

Path

)

Definition at line 134 of file cabinet.cxx.

{
    for (size_t i = 0; i < Path.size(); ++i)
    {
#if defined(_WIN32)
        if (Path[i] == '/')
            Path[i] = '\\';
#else
        if (Path[i] == '\\')
            Path[i] = '/';
#endif
    }
}

Referenced by AddFile(), CreateSimpleCabinet(), SetCabinetReservedFile(), SetDestinationPath(), and CDFParser::SetFileRelativePath().

CreateCabFilename()

std::string CCabinet::CreateCabFilename

(

PCFFILE_NODE

Node

)

Definition at line 278 of file cabinet.cxx.

{
    std::string fname = GetFileName(Node->FileName);
    if (!Node->TargetFolder.empty())
    {
        fname = Node->TargetFolder + fname;
    }
    return fname;
}

Referenced by DestroyDeletedFileNodes(), WriteFileEntries(), and WriteFileToScratchStorage().

CreateSimpleCabinet()

bool CCabinet::CreateSimpleCabinet

(

)

Definition at line 1581 of file cabinet.cxx.

{
    bool bRet = false;
    ULONG Status;
 
#if defined(_WIN32)
    HANDLE hFind;
    WIN32_FIND_DATA FindFileData;
#else
    DIR* dirp;
    struct dirent* dp;
    struct stat stbuf;
#endif
 
    // Initialize a new cabinet
    Status = NewCabinet();
    if (Status != CAB_STATUS_SUCCESS)
    {
        DPRINT(MIN_TRACE, ("Cannot create cabinet (%u).\n", (UINT)Status));
        goto cleanup2;
    }
 
    // Add each file in the criteria list
    for (PSEARCH_CRITERIA Criteria : CriteriaList)
    {
        // Store the file path with a trailing slash in szFilePath
        std::string szSearchPath = Criteria->Search;
        ConvertPath(szSearchPath);
        auto sep = szSearchPath.find_last_of(DIR_SEPARATOR_CHAR);
        std::string szFilePath;
        std::string pszFile;
 
        if (sep != std::string::npos)
        {
            pszFile = szSearchPath.substr(sep + 1); // We want the filename, not the dir separator!
 
            szFilePath = szSearchPath.substr(0, sep + 1);
        }
        else
        {
            pszFile = Criteria->Search;
 
#if !defined(_WIN32)
            // needed for opendir()
            szFilePath = "./";
#endif
        }
 
#if defined(_WIN32)
        // Windows: Use the easy FindFirstFile/FindNextFile API for getting all files and checking them against the pattern
        hFind = FindFirstFile(Criteria->Search.c_str(), &FindFileData);
 
        // Don't stop if a search criteria is not found
        if(hFind == INVALID_HANDLE_VALUE && GetLastError() != ERROR_FILE_NOT_FOUND)
        {
            DPRINT(MIN_TRACE, ("FindFirstFile failed, Criteria: %s, error code is %u\n", Criteria->Search.c_str(), (UINT)GetLastError()));
            goto cleanup;
        }
 
        do
        {
            if(!(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            {
                std::string szFile = szFilePath;
                szFile += FindFileData.cFileName;
 
                Status = AddFile(szFile, Criteria->TargetFolder);
 
                if(Status != CAB_STATUS_SUCCESS)
                {
                    DPRINT(MIN_TRACE, ("Cannot add file to cabinet (%u).\n", (UINT)Status));
                    FindClose(hFind);
                    goto cleanup;
                }
            }
        }
        while(FindNextFile(hFind, &FindFileData));
 
        FindClose(hFind);
#else
        // Unix: Use opendir/readdir to loop through all entries, stat to check if it's a file and MatchFileNamePattern to match the file against the pattern
        dirp = opendir(szFilePath.c_str());
 
        if(dirp)
        {
            while( (dp = readdir(dirp)) )
            {
                std::string szFile = szFilePath;
                szFile += dp->d_name;
 
                if(stat(szFile.c_str(), &stbuf) == 0)
                {
                    if(stbuf.st_mode != S_IFDIR)
                    {
                        if(MatchFileNamePattern(dp->d_name, pszFile.c_str()))
                        {
                            Status = AddFile(szFile, Criteria->TargetFolder);
 
                            if(Status != CAB_STATUS_SUCCESS)
                            {
                                DPRINT(MIN_TRACE, ("Cannot add file to cabinet (%u).\n", (UINT)Status));
                                goto cleanup;
                            }
                        }
                    }
                }
                else
                {
                    DPRINT(MIN_TRACE, ("stat failed, error code is %i\n", errno));
                    goto cleanup;
                }
            }
 
            closedir(dirp);
        }
#endif
    }
 
    Status = WriteDisk(false);
    if (Status == CAB_STATUS_SUCCESS)
        Status = CloseDisk();
    if (Status != CAB_STATUS_SUCCESS)
    {
        DPRINT(MIN_TRACE, ("Cannot write disk (%u).\n", (UINT)Status));
        goto cleanup;
    }
 
cleanup:
    CloseCabinet();
    bRet = true;
 
cleanup2:
    DestroySearchCriteria();
    return bRet;
}

Referenced by CCABManager::Run().

DestroyDataNodes()

void CCabinet::DestroyDataNodes ( PCFFOLDER_NODE  FolderNode )

private

Definition at line 2168 of file cabinet.cxx.

{
    for (PCFDATA_NODE Node : FolderNode->DataList)
    {
        delete Node;
    }
    FolderNode->DataList.clear();
}

Referenced by CommitDisk(), DestroyDeletedFolderNodes(), and DestroyFolderNodes().

DestroyDeletedFileNodes()

void CCabinet::DestroyDeletedFileNodes ( )

private

Definition at line 2196 of file cabinet.cxx.

{
    for (auto it = FileList.begin(); it != FileList.end(); )
    {
        PCFFILE_NODE CurNode = *it;
 
        if (CurNode->Delete)
        {
            it = FileList.erase(it);
 
            DPRINT(MAX_TRACE, ("Deleting file node: '%s'\n", CurNode->FileName.c_str()));
 
            TotalFileSize -= (sizeof(CFFILE) + (ULONG)CreateCabFilename(CurNode).length() + 1);
 
            delete CurNode;
        }
        else
        {
            it++;
        }
    }
}

Referenced by CloseDisk().

DestroyDeletedFolderNodes()

void CCabinet::DestroyDeletedFolderNodes ( )

private

Definition at line 2237 of file cabinet.cxx.

{
    for (auto it = FolderList.begin(); it != FolderList.end();)
    {
        PCFFOLDER_NODE CurNode = *it;
 
        if (CurNode->Delete)
        {
            it = FolderList.erase(it);
 
            DestroyDataNodes(CurNode);
            delete CurNode;
 
            TotalFolderSize -= sizeof(CFFOLDER);
        }
        else
        {
            it++;
        }
    }
}

Referenced by CloseDisk().

DestroyFileNodes()

void CCabinet::DestroyFileNodes ( )

private

Definition at line 2183 of file cabinet.cxx.

{
    for (PCFFILE_NODE Node : FileList)
    {
        delete Node;
    }
    FileList.clear();
}

Referenced by CloseCabinet().

DestroyFolderNodes()

void CCabinet::DestroyFolderNodes ( )

private

Definition at line 2223 of file cabinet.cxx.

{
    for (PCFFOLDER_NODE Node : FolderList)
    {
        DestroyDataNodes(Node);
        delete Node;
    }
    FolderList.clear();
}

Referenced by CloseCabinet().

DestroySearchCriteria()

void CCabinet::DestroySearchCriteria

(

)

Definition at line 256 of file cabinet.cxx.

{
    for (PSEARCH_CRITERIA Criteria : CriteriaList)
    {
        delete Criteria;
    }
    CriteriaList.clear();
}

Referenced by CreateSimpleCabinet(), CCABManager::DisplayCabinet(), and CCABManager::ExtractFromCabinet().

ExtractFile()

ULONG CCabinet::ExtractFile

(

const char *

FileName

)

Definition at line 648 of file cabinet.cxx.

{
    ULONG Size;
    ULONG Offset;
    ULONG BytesRead;
    ULONG BytesToRead;
    ULONG BytesWritten;
    ULONG BytesSkipped;
    ULONG BytesToWrite;
    ULONG TotalBytesRead;
    ULONG CurrentOffset;
    PUCHAR Buffer;
    PUCHAR CurrentBuffer;
    FILE* DestFile;
    PCFFILE_NODE File;
    CFDATA CFData;
    ULONG Status;
    bool Skip;
#if defined(_WIN32)
    FILETIME FileTime;
#endif
    CHAR DestName[PATH_MAX];
    CHAR TempName[PATH_MAX];
 
    Status = LocateFile(FileName, &File);
    if (Status != CAB_STATUS_SUCCESS)
    {
        DPRINT(MID_TRACE, ("Cannot locate file (%u).\n", (UINT)Status));
        return Status;
    }
 
    LastFileOffset = File->File.FileOffset;
 
    switch (CurrentFolderNode->Folder.CompressionType & CAB_COMP_MASK)
    {
        case CAB_COMP_NONE:
            SelectCodec(CAB_CODEC_RAW);
            break;
 
        case CAB_COMP_MSZIP:
            SelectCodec(CAB_CODEC_MSZIP);
            break;
 
        default:
            return CAB_STATUS_UNSUPPCOMP;
    }
 
    DPRINT(MAX_TRACE, ("Extracting file at uncompressed offset (0x%X)  Size (%u bytes)  AO (0x%X)  UO (0x%X).\n",
        (UINT)File->File.FileOffset,
        (UINT)File->File.FileSize,
        (UINT)File->DataBlock->AbsoluteOffset,
        (UINT)File->DataBlock->UncompOffset));
 
    strcpy(DestName, DestPath.c_str());
    strcat(DestName, FileName);
 
    /* Create destination file, fail if it already exists */
    DestFile = fopen(DestName, "rb");
    if (DestFile != NULL)
    {
        fclose(DestFile);
        /* If file exists, ask to overwrite file */
        if (OnOverwrite(&File->File, FileName))
        {
            DestFile = fopen(DestName, "w+b");
            if (DestFile == NULL)
                return CAB_STATUS_CANNOT_CREATE;
        }
        else
            return CAB_STATUS_FILE_EXISTS;
    }
    else
    {
        DestFile = fopen(DestName, "w+b");
        if (DestFile == NULL)
            return CAB_STATUS_CANNOT_CREATE;
    }
 
#if defined(_WIN32)
    if (!DosDateTimeToFileTime(File->File.FileDate, File->File.FileTime, &FileTime))
    {
        fclose(DestFile);
        DPRINT(MIN_TRACE, ("DosDateTimeToFileTime() failed (%u).\n", (UINT)GetLastError()));
        return CAB_STATUS_CANNOT_WRITE;
    }
 
    SetFileTime(DestFile, NULL, &FileTime, NULL);
#else
    //DPRINT(MIN_TRACE, ("FIXME: DosDateTimeToFileTime\n"));
#endif
 
    SetAttributesOnFile(DestName, File->File.Attributes);
 
    Buffer = (PUCHAR)malloc(CAB_BLOCKSIZE + 12); // This should be enough
    if (!Buffer)
    {
        fclose(DestFile);
        DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
        return CAB_STATUS_NOMEMORY;
    }
 
    /* Call OnExtract event handler */
    OnExtract(&File->File, FileName);
 
    /* Search to start of file */
    if (fseek(FileHandle, (off_t)File->DataBlock->AbsoluteOffset, SEEK_SET) != 0)
    {
        DPRINT(MIN_TRACE, ("fseek() failed.\n"));
        fclose(DestFile);
        free(Buffer);
        return CAB_STATUS_INVALID_CAB;
    }
 
    Size   = File->File.FileSize;
    Offset = File->File.FileOffset;
    CurrentOffset = File->DataBlock->UncompOffset;
 
    Skip = true;
 
    ReuseBlock = (CurrentDataNode == File->DataBlock);
    if (Size > 0)
    {
        do
        {
            DPRINT(MAX_TRACE, ("CO (0x%X)    ReuseBlock (%u)    Offset (0x%X)   Size (%d)  BytesLeftInBlock (%d)\n",
                (UINT)File->DataBlock->UncompOffset, (UINT)ReuseBlock, (UINT)Offset, (UINT)Size,
                (UINT)BytesLeftInBlock));
 
            if (/*(CurrentDataNode != File->DataBlock) &&*/ (!ReuseBlock) || (BytesLeftInBlock <= 0))
            {
                DPRINT(MAX_TRACE, ("Filling buffer. ReuseBlock (%u)\n", (UINT)ReuseBlock));
 
                CurrentBuffer  = Buffer;
                TotalBytesRead = 0;
                do
                {
                    DPRINT(MAX_TRACE, ("Size (%u bytes).\n", (UINT)Size));
 
                    if (((Status = ReadBlock(&CFData, sizeof(CFDATA), &BytesRead)) !=
                        CAB_STATUS_SUCCESS) || (BytesRead != sizeof(CFDATA)))
                    {
                        fclose(DestFile);
                        free(Buffer);
                        DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
                        return CAB_STATUS_INVALID_CAB;
                    }
 
                    DPRINT(MAX_TRACE, ("Data block: Checksum (0x%X)  CompSize (%u bytes)  UncompSize (%u bytes)\n",
                        (UINT)CFData.Checksum,
                        CFData.CompSize,
                        CFData.UncompSize));
 
                    ASSERT(CFData.CompSize <= CAB_BLOCKSIZE + 12);
 
                    BytesToRead = CFData.CompSize;
 
                    DPRINT(MAX_TRACE, ("Read: (0x%lX,0x%lX).\n",
                        (unsigned long)CurrentBuffer, (unsigned long)Buffer));
 
                    if (((Status = ReadBlock(CurrentBuffer, BytesToRead, &BytesRead)) !=
                        CAB_STATUS_SUCCESS) || (BytesToRead != BytesRead))
                    {
                        fclose(DestFile);
                        free(Buffer);
                        DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
                        return CAB_STATUS_INVALID_CAB;
                    }
 
                    /* FIXME: Does not work with files generated by makecab.exe */
/*
                    if (CFData.Checksum != 0)
                    {
                        ULONG Checksum = ComputeChecksum(CurrentBuffer, BytesRead, 0);
                        if (Checksum != CFData.Checksum)
                        {
                            CloseFile(DestFile);
                            free(Buffer);
                            DPRINT(MIN_TRACE, ("Bad checksum (is 0x%X, should be 0x%X).\n",
                                Checksum, CFData.Checksum));
                            return CAB_STATUS_INVALID_CAB;
                        }
                    }
*/
                    TotalBytesRead += BytesRead;
 
                    CurrentBuffer += BytesRead;
 
                    if (CFData.UncompSize == 0)
                    {
                        if (strlen(DiskNext) == 0)
                        {
                            fclose(DestFile);
                            free(Buffer);
                            return CAB_STATUS_NOFILE;
                        }
 
                        /* CloseCabinet() will destroy all file entries so in case
                           FileName refers to the FileName field of a CFFOLDER_NODE
                           structure, we have to save a copy of the filename */
                        strcpy(TempName, FileName);
 
                        CloseCabinet();
 
                        SetCabinetName(CabinetNext);
 
                        OnDiskChange(CabinetNext, DiskNext);
 
                        Status = Open();
                        if (Status != CAB_STATUS_SUCCESS)
                        {
                            fclose(DestFile);
                            free(Buffer);
                            return Status;
                        }
 
                        /* The first data block of the file will not be
                           found as it is located in the previous file */
                        Status = LocateFile(TempName, &File);
                        if (Status == CAB_STATUS_NOFILE)
                        {
                            DPRINT(MID_TRACE, ("Cannot locate file (%u).\n", (UINT)Status));
                            fclose(DestFile);
                            free(Buffer);
                            return Status;
                        }
 
                        /* The file is continued in the first data block in the folder */
                        File->DataBlock = CurrentFolderNode->DataList.front();
 
                        /* Search to start of file */
                        if (fseek(FileHandle, (off_t)File->DataBlock->AbsoluteOffset, SEEK_SET) != 0)
                        {
                            DPRINT(MIN_TRACE, ("fseek() failed.\n"));
                            fclose(DestFile);
                            free(Buffer);
                            return CAB_STATUS_INVALID_CAB;
                        }
 
                        DPRINT(MAX_TRACE, ("Continuing extraction of file at uncompressed offset (0x%X)  Size (%u bytes)  AO (0x%X)  UO (0x%X).\n",
                            (UINT)File->File.FileOffset,
                            (UINT)File->File.FileSize,
                            (UINT)File->DataBlock->AbsoluteOffset,
                            (UINT)File->DataBlock->UncompOffset));
 
                        CurrentDataNode = File->DataBlock;
                        ReuseBlock = true;
 
                        RestartSearch = true;
                    }
                } while (CFData.UncompSize == 0);
 
                DPRINT(MAX_TRACE, ("TotalBytesRead (%u).\n", (UINT)TotalBytesRead));
 
                Status = Codec->Uncompress(OutputBuffer, Buffer, TotalBytesRead, &BytesToWrite);
                if (Status != CS_SUCCESS)
                {
                    fclose(DestFile);
                    free(Buffer);
                    DPRINT(MID_TRACE, ("Cannot uncompress block.\n"));
                    if (Status == CS_NOMEMORY)
                        return CAB_STATUS_NOMEMORY;
                    return CAB_STATUS_INVALID_CAB;
                }
 
                if (BytesToWrite != CFData.UncompSize)
                {
                    DPRINT(MID_TRACE, ("BytesToWrite (%u) != CFData.UncompSize (%d)\n",
                        (UINT)BytesToWrite, CFData.UncompSize));
                    fclose(DestFile);
                    free(Buffer);
                    return CAB_STATUS_INVALID_CAB;
                }
 
                BytesLeftInBlock = BytesToWrite;
            }
            else
            {
                DPRINT(MAX_TRACE, ("Using same buffer. ReuseBlock (%u)\n", (UINT)ReuseBlock));
 
                BytesToWrite = BytesLeftInBlock;
 
                DPRINT(MAX_TRACE, ("Seeking to absolute offset 0x%X.\n",
                    (UINT)(CurrentDataNode->AbsoluteOffset + sizeof(CFDATA) + CurrentDataNode->Data.CompSize)));
 
                if (((Status = ReadBlock(&CFData, sizeof(CFDATA), &BytesRead)) !=
                    CAB_STATUS_SUCCESS) || (BytesRead != sizeof(CFDATA)))
                {
                    fclose(DestFile);
                    free(Buffer);
                    DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
                    return CAB_STATUS_INVALID_CAB;
                }
 
                DPRINT(MAX_TRACE, ("CFData.CompSize 0x%X  CFData.UncompSize 0x%X.\n",
                    CFData.CompSize, CFData.UncompSize));
 
                /* Go to next data block */
                if (fseek(FileHandle, (off_t)CurrentDataNode->AbsoluteOffset + sizeof(CFDATA) +
                    CurrentDataNode->Data.CompSize, SEEK_SET) != 0)
                {
                    DPRINT(MIN_TRACE, ("fseek() failed.\n"));
                    fclose(DestFile);
                    free(Buffer);
                    return CAB_STATUS_INVALID_CAB;
                }
 
                ReuseBlock = false;
            }
 
            if (Skip)
                BytesSkipped = (Offset - CurrentOffset);
            else
                BytesSkipped = 0;
 
            BytesToWrite -= BytesSkipped;
 
            if (Size < BytesToWrite)
                BytesToWrite = Size;
 
            DPRINT(MAX_TRACE, ("Offset (0x%X)  CurrentOffset (0x%X)  ToWrite (%u)  Skipped (%u)(%u)  Size (%u).\n",
                (UINT)Offset,
                (UINT)CurrentOffset,
                (UINT)BytesToWrite,
                (UINT)BytesSkipped, (UINT)Skip,
                (UINT)Size));
 
            BytesWritten = BytesToWrite;
            if (fwrite((void*)((PUCHAR)OutputBuffer + BytesSkipped),
                 BytesToWrite, 1, DestFile) < 1)
            {
                fclose(DestFile);
                free(Buffer);
                DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
 
                return CAB_STATUS_CANNOT_WRITE;
            }
 
            Size -= BytesToWrite;
 
            CurrentOffset += BytesToWrite;
 
            /* Don't skip any more bytes */
            Skip = false;
        } while (Size > 0);
    }
 
    fclose(DestFile);
 
    free(Buffer);
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CCABManager::ExtractFromCabinet().

FindFirst()

ULONG CCabinet::FindFirst

(

PCAB_SEARCH

Search

)

Definition at line 551 of file cabinet.cxx.

{
    RestartSearch = false;
    Search->Next = FileList.begin();
    return FindNext(Search);
}

Referenced by CCABManager::DisplayCabinet(), and CCABManager::ExtractFromCabinet().

FindNext()

ULONG CCabinet::FindNext

(

PCAB_SEARCH

Search

)

Definition at line 566 of file cabinet.cxx.

{
    bool bFound = false;
    ULONG Status;
 
    if (RestartSearch)
    {
        Search->Next  = FileList.begin();
 
        /* Skip split files already extracted */
        while ((Search->Next != FileList.end()) &&
            ((*Search->Next)->File.FileControlID > CAB_FILE_MAX_FOLDER) &&
            ((*Search->Next)->File.FileOffset <= LastFileOffset))
        {
            DPRINT(MAX_TRACE, ("Skipping file (%s)  FileOffset (0x%X)  LastFileOffset (0x%X).\n",
                (*Search->Next)->FileName.c_str(), (UINT)(*Search->Next)->File.FileOffset, (UINT)LastFileOffset));
            Search->Next++;
        }
 
        RestartSearch = false;
    }
 
    /* Check each search criteria against each file */
    while(Search->Next != FileList.end())
    {
        // Some features (like displaying cabinets) don't require search criteria, so we can just break here.
        // If a feature requires it, handle this in the ParseCmdline() function in "main.cxx".
        if (CriteriaList.empty())
            break;
 
        for (PSEARCH_CRITERIA Criteria : CriteriaList)
        {
            // FIXME: We could handle path\filename here
            if (MatchFileNamePattern((*Search->Next)->FileName.c_str(), Criteria->Search.c_str()))
            {
                bFound = true;
                break;
            }
        }
 
        if(bFound)
            break;
 
        Search->Next++;
    }
 
    if (Search->Next == FileList.end())
    {
        if (strlen(DiskNext) > 0)
        {
            CloseCabinet();
 
            SetCabinetName(CabinetNext);
 
            OnDiskChange(CabinetNext, DiskNext);
 
            Status = Open();
            if (Status != CAB_STATUS_SUCCESS)
                return Status;
 
            Search->Next = FileList.begin();
            if (Search->Next == FileList.end())
                return CAB_STATUS_NOFILE;
        }
        else
            return CAB_STATUS_NOFILE;
    }
 
    Search->File     = &(*Search->Next)->File;
    Search->FileName = (*Search->Next)->FileName;
    Search->Next++;
    return CAB_STATUS_SUCCESS;
}

Referenced by CCABManager::DisplayCabinet(), CCABManager::ExtractFromCabinet(), and FindFirst().

GetAbsoluteOffset()

ULONG CCabinet::GetAbsoluteOffset ( PCFFILE_NODE  File )

private

Definition at line 1849 of file cabinet.cxx.

{
    DPRINT(MAX_TRACE, ("FileName '%s'  FileOffset (0x%X)  FileSize (%u).\n",
        File->FileName.c_str(),
        (UINT)File->File.FileOffset,
        (UINT)File->File.FileSize));
 
    for (PCFDATA_NODE Node : CurrentFolderNode->DataList)
    {
        DPRINT(MAX_TRACE, ("GetAbsoluteOffset(): Comparing (0x%X, 0x%X) (%u).\n",
            (UINT)Node->UncompOffset,
            (UINT)(Node->UncompOffset + Node->Data.UncompSize),
            (UINT)Node->Data.UncompSize));
 
        /* Node->Data.UncompSize will be 0 if the block is split
           (ie. it is the last block in this cabinet) */
        if ((Node->Data.UncompSize == 0) ||
            ((File->File.FileOffset >= Node->UncompOffset) &&
            (File->File.FileOffset < Node->UncompOffset +
            Node->Data.UncompSize)))
        {
                File->DataBlock = Node;
                return CAB_STATUS_SUCCESS;
        }
    }
    return CAB_STATUS_INVALID_CAB;
}

Referenced by LocateFile().

GetAttributesOnFile()

ULONG CCabinet::GetAttributesOnFile ( PCFFILE_NODE  File )

private

Definition at line 2914 of file cabinet.cxx.

{
#if defined(_WIN32)
    LONG Attributes;
 
    Attributes = GetFileAttributes(File->FileName.c_str());
    if (Attributes == -1)
        return CAB_STATUS_CANNOT_READ;
 
    // 0x37 = READONLY | HIDDEN | SYSTEM | DIRECTORY | ARCHIVE
    // The IDs for these attributes are the same in the CAB file and under Windows
    // If the file has any other attributes, strip them off by the logical AND.
    File->File.Attributes = (USHORT)(Attributes & 0x37);
#else
    struct stat stbuf;
    char buf[PATH_MAX];
 
    // Check for an absolute path
    if (File->FileName.length() > 0 && IsSeparator(File->FileName[0]))
        strcpy(buf, File->FileName.c_str());
    else
    {
        if (!getcwd(buf, sizeof(buf)))
            return CAB_STATUS_CANNOT_READ;
        strcat(buf, DIR_SEPARATOR_STRING);
        strcat(buf, File->FileName.c_str());
    }
 
    if (stat(buf, &stbuf) == -1)
        return CAB_STATUS_CANNOT_READ;
 
#if 0
    File->File.Attributes |= CAB_ATTRIB_READONLY;
    File->File.Attributes |= CAB_ATTRIB_HIDDEN;
    File->File.Attributes |= CAB_ATTRIB_SYSTEM;
#endif
 
    if (stbuf.st_mode & S_IFDIR)
        File->File.Attributes |= CAB_ATTRIB_DIRECTORY;
 
    File->File.Attributes |= CAB_ATTRIB_ARCHIVE;
 
#endif
    return CAB_STATUS_SUCCESS;
}

Referenced by AddFile().

GetCabinetName()

char * CCabinet::GetCabinetName

(

)

Definition at line 194 of file cabinet.cxx.

{
    return CabinetName;
}

Referenced by CCABManager::DisplayCabinet(), and CCABManager::ExtractFromCabinet().

GetCurrentDiskNumber()

ULONG CCabinet::GetCurrentDiskNumber

(

)

Definition at line 376 of file cabinet.cxx.

{
    return CurrentDiskNumber;
}

Referenced by CDFParser::SetupNewDisk().

GetDestinationPath()

const char * CCabinet::GetDestinationPath

(

)

Definition at line 308 of file cabinet.cxx.

{
    return DestPath.c_str();
}

Referenced by CDFParser::OnCabinetName(), and CDFParser::WriteInfLine().

GetFileName()

std::string CCabinet::GetFileName

(

const std::string &

Path

)

Definition at line 158 of file cabinet.cxx.

{
    ULONG i, j;
 
    j = i = (Path[0] ? (Path[1] == ':' ? 2 : 0) : 0);
 
    while (Path [i++])
        if (IsSeparator(Path [i - 1]))
            j = i;
 
    return Path.c_str() + j;
}

Referenced by CreateCabFilename(), CCABManager::OnAdd(), CCABManager::OnExtract(), and CDFParser::PerformFileCopy().

GetFileTimes()

ULONG CCabinet::GetFileTimes ( FILE *  FileHandle, PCFFILE_NODE  File  )

private

Definition at line 2872 of file cabinet.cxx.

{
#if defined(_WIN32)
    FILETIME FileTime;
    HANDLE FileNo = UlongToHandle(_fileno(FileHandle));
 
    if (GetFileTime(FileNo, NULL, NULL, &FileTime))
        FileTimeToDosDateTime(&FileTime,
            &File->File.FileDate,
            &File->File.FileTime);
#else
    struct stat stbuf;
    char buf[PATH_MAX];
 
    // Check for an absolute path
    if (File->FileName.length() > 0 && IsSeparator(File->FileName[0]))
        strcpy(buf, File->FileName.c_str());
    else
    {
        if (!getcwd(buf, sizeof(buf)))
            return CAB_STATUS_CANNOT_READ;
        strcat(buf, DIR_SEPARATOR_STRING);
        strcat(buf, File->FileName.c_str());
    }
 
    if (stat(buf, &stbuf) == -1)
        return CAB_STATUS_CANNOT_READ;
 
    ConvertDateAndTime(&stbuf.st_mtime, &File->File.FileDate, &File->File.FileTime);
#endif
    return CAB_STATUS_SUCCESS;
}

Referenced by AddFile().

HasSearchCriteria()

bool CCabinet::HasSearchCriteria

(

)

Definition at line 268 of file cabinet.cxx.

{
    return !CriteriaList.empty();
}

Referenced by CCABManager::ParseCmdline().

InitCabinetHeader()

ULONG CCabinet::InitCabinetHeader ( )

private

Definition at line 2405 of file cabinet.cxx.

{
    ULONG TotalSize;
    ULONG Size;
 
    CABHeader.FileTableOffset = 0;    // Not known yet
    CABHeader.FolderCount     = 0;    // Not known yet
    CABHeader.FileCount       = 0;    // Not known yet
    CABHeader.Flags           = 0;    // Not known yet
 
    CABHeader.CabinetNumber = (USHORT)CurrentDiskNumber;
 
    if ((CurrentDiskNumber > 0) && (OnCabinetName(PrevCabinetNumber, CabinetPrev)))
    {
        CABHeader.Flags |= CAB_FLAG_HASPREV;
        if (!OnDiskLabel(PrevCabinetNumber, DiskPrev))
            strcpy(CabinetPrev, "");
    }
 
    if (OnCabinetName(CurrentDiskNumber + 1, CabinetNext))
    {
        CABHeader.Flags |= CAB_FLAG_HASNEXT;
        if (!OnDiskLabel(CurrentDiskNumber + 1, DiskNext))
            strcpy(DiskNext, "");
    }
 
    TotalSize = 0;
 
    if ((CABHeader.Flags & CAB_FLAG_HASPREV) > 0)
    {
 
        DPRINT(MAX_TRACE, ("CabinetPrev '%s'.\n", CabinetPrev));
 
        /* Calculate size of name of previous cabinet */
        TotalSize += (ULONG)strlen(CabinetPrev) + 1;
 
        /* Calculate size of label of previous disk */
        TotalSize += (ULONG)strlen(DiskPrev) + 1;
    }
 
    if ((CABHeader.Flags & CAB_FLAG_HASNEXT) > 0)
    {
 
        DPRINT(MAX_TRACE, ("CabinetNext '%s'.\n", CabinetNext));
 
        /* Calculate size of name of next cabinet */
        Size = (ULONG)strlen(CabinetNext) + 1;
        TotalSize += Size;
        NextFieldsSize = Size;
 
        /* Calculate size of label of next disk */
        Size = (ULONG)strlen(DiskNext) + 1;
        TotalSize += Size;
        NextFieldsSize += Size;
    }
    else
        NextFieldsSize = 0;
 
    /* Add cabinet reserved area size if present */
    if (CabinetReservedFileSize > 0)
    {
        CABHeader.Flags |= CAB_FLAG_RESERVE;
        TotalSize += CabinetReservedFileSize;
        TotalSize += sizeof(ULONG); /* For CabinetResSize, FolderResSize, and FileResSize fields */
    }
 
    DiskSize += TotalSize;
 
    TotalHeaderSize = sizeof(CFHEADER) + TotalSize;
 
    return CAB_STATUS_SUCCESS;
}

Referenced by NewCabinet(), and NewDisk().

IsCodecSelected()

bool CCabinet::IsCodecSelected

(

)

Definition at line 1008 of file cabinet.cxx.

{
    return CodecSelected;
}

Referenced by CCABManager::ParseCmdline().

IsSeparator()

bool CCabinet::IsSeparator

(

char

Char

)

Definition at line 119 of file cabinet.cxx.

{
    if ((Char == '\\') || (Char == '/'))
        return true;
    else
        return false;
}

Referenced by GetAttributesOnFile(), GetFileName(), GetFileTimes(), and NormalizePath().

LocateFile()

ULONG CCabinet::LocateFile ( const char *  FileName, PCFFILE_NODE *  File  )

private

Definition at line 1885 of file cabinet.cxx.

{
    ULONG Status;
 
    DPRINT(MAX_TRACE, ("FileName '%s'\n", FileName));
 
    for (PCFFILE_NODE Node : FileList)
    {
        // FIXME: We could handle path\filename here
        if (strcasecmp(FileName, Node->FileName.c_str()) == 0)
        {
            CurrentFolderNode = LocateFolderNode(Node->File.FileControlID);
            if (!CurrentFolderNode)
            {
                DPRINT(MID_TRACE, ("Folder with index number (%u) not found.\n",
                    Node->File.FileControlID));
                return CAB_STATUS_INVALID_CAB;
            }
 
            if (Node->DataBlock == NULL)
                Status = GetAbsoluteOffset(Node);
            else
                Status = CAB_STATUS_SUCCESS;
 
            *File = Node;
            return Status;
        }
    }
    return CAB_STATUS_NOFILE;
}

Referenced by ExtractFile().

LocateFolderNode()

PCFFOLDER_NODE CCabinet::LocateFolderNode ( ULONG  Index )

private

Definition at line 1821 of file cabinet.cxx.

{
    switch (Index)
    {
        case CAB_FILE_SPLIT:
            return FolderList.back();
 
        case CAB_FILE_CONTINUED:
        case CAB_FILE_PREV_NEXT:
            return FolderList.front();
    }
 
    for (PCFFOLDER_NODE Node : FolderList)
    {
        if (Node->Index == Index)
            return Node;
    }
    return NULL;
}

Referenced by LocateFile().

MatchFileNamePattern()

bool CCabinet::MatchFileNamePattern ( const char *  FileName, const char *  Pattern  )

private

Definition at line 2342 of file cabinet.cxx.

{
    const char* retryPattern = NULL;
    const char* retryFileName = NULL;
    char  ch;
 
    while (*FileName || *Pattern)
    {
        ch = *Pattern++;
 
        switch (ch)
        {
            case '*':
                retryPattern = Pattern;
                retryFileName = FileName;
                break;
 
            case '?':
                if (*FileName++ == '\0')
                    return false;
 
                break;
 
            default:
                if (*FileName == ch)
                {
                    if (*FileName)
                        FileName++;
                    break;
                }
 
                if (*FileName)
                {
                    Pattern = retryPattern;
                    FileName = ++retryFileName;
                    break;
                }
 
                return false;
        }
 
        if (!Pattern)
            return false;
    }
 
    return true;
}

Referenced by CreateSimpleCabinet(), and FindNext().

NewCabinet()

ULONG CCabinet::NewCabinet

(

)

Definition at line 1057 of file cabinet.cxx.

{
    ULONG Status;
 
    CurrentDiskNumber = 0;
 
    OutputBuffer = malloc(CAB_BLOCKSIZE + 12); // This should be enough
    InputBuffer  = malloc(CAB_BLOCKSIZE + 12); // This should be enough
    if ((!OutputBuffer) || (!InputBuffer))
    {
        DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
        return CAB_STATUS_NOMEMORY;
    }
    CurrentIBuffer     = InputBuffer;
    CurrentIBufferSize = 0;
 
    CABHeader.Signature     = CAB_SIGNATURE;
    CABHeader.Reserved1     = 0;            // Not used
    CABHeader.CabinetSize   = 0;            // Not yet known
    CABHeader.Reserved2     = 0;            // Not used
    CABHeader.Reserved3     = 0;            // Not used
    CABHeader.Version       = CAB_VERSION;
    CABHeader.FolderCount   = 0;            // Not yet known
    CABHeader.FileCount     = 0;            // Not yet known
    CABHeader.Flags         = 0;            // Not yet known
    // FIXME: Should be random
    CABHeader.SetID         = 0x534F;
    CABHeader.CabinetNumber = 0;
 
 
    TotalFolderSize = 0;
    TotalFileSize   = 0;
 
    DiskSize = sizeof(CFHEADER);
 
    InitCabinetHeader();
 
    // NextFolderNumber is 0-based
    NextFolderNumber = 0;
 
    CurrentFolderNode = NULL;
    Status = NewFolder();
    if (Status != CAB_STATUS_SUCCESS)
        return Status;
 
    CurrentFolderNode->Folder.DataOffset = DiskSize - TotalHeaderSize;
 
    ScratchFile = new CCFDATAStorage;
    if (!ScratchFile)
    {
        DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
        return CAB_STATUS_NOMEMORY;
    }
 
    Status = ScratchFile->Create();
 
    CreateNewFolder = false;
 
    CreateNewDisk = false;
 
    PrevCabinetNumber = 0;
 
    return Status;
}

Referenced by CreateSimpleCabinet(), CDFParser::PerformFileCopy(), and CDFParser::PerformNewCommand().

NewDataNode()

PCFDATA_NODE CCabinet::NewDataNode ( PCFFOLDER_NODE  FolderNode )

private

Definition at line 2147 of file cabinet.cxx.

{
    PCFDATA_NODE Node;
 
    Node = new CFDATA_NODE;
    if (!Node)
        return NULL;
 
    FolderNode->DataList.push_back(Node);
 
    return Node;
}

Referenced by ReadDataBlocks(), and WriteDataBlock().

NewDisk()

ULONG CCabinet::NewDisk

(

)

Definition at line 1128 of file cabinet.cxx.

{
    // NextFolderNumber is 0-based
    NextFolderNumber = 1;
 
    CreateNewDisk = false;
 
    DiskSize = sizeof(CFHEADER) + TotalFolderSize + TotalFileSize;
 
    InitCabinetHeader();
 
    CurrentFolderNode->TotalFolderSize = 0;
 
    CurrentFolderNode->Folder.DataBlockCount = 0;
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CDFParser::PerformFileCopy(), CDFParser::PerformNewCommand(), and WriteDisk().

NewFileNode()

PCFFILE_NODE CCabinet::NewFileNode ( )

private

Definition at line 2126 of file cabinet.cxx.

{
    PCFFILE_NODE Node;
 
    Node = new CFFILE_NODE;
    if (!Node)
        return NULL;
 
    FileList.push_back(Node);
 
    return Node;
}

Referenced by AddFile(), and ReadFileTable().

NewFolder()

ULONG CCabinet::NewFolder

(

)

Definition at line 1152 of file cabinet.cxx.

{
    DPRINT(MAX_TRACE, ("Creating new folder.\n"));
 
    CurrentFolderNode = NewFolderNode();
    if (!CurrentFolderNode)
    {
        DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
        return CAB_STATUS_NOMEMORY;
    }
 
    switch (CodecId) {
        case CAB_CODEC_RAW:
            CurrentFolderNode->Folder.CompressionType = CAB_COMP_NONE;
            break;
 
        case CAB_CODEC_MSZIP:
            CurrentFolderNode->Folder.CompressionType = CAB_COMP_MSZIP;
            break;
 
        default:
            return CAB_STATUS_UNSUPPCOMP;
    }
 
    /* FIXME: This won't work if no files are added to the new folder */
 
    DiskSize += sizeof(CFFOLDER);
 
    TotalFolderSize += sizeof(CFFOLDER);
 
    NextFolderNumber++;
 
    CABHeader.FolderCount++;
 
    LastBlockStart = 0;
 
    return CAB_STATUS_SUCCESS;
}

Referenced by NewCabinet(), CDFParser::PerformNewCommand(), and WriteFileToScratchStorage().

NewFolderNode()

PCFFOLDER_NODE CCabinet::NewFolderNode ( )

private

Definition at line 2105 of file cabinet.cxx.

{
    PCFFOLDER_NODE Node;
 
    Node = new CFFOLDER_NODE;
    if (!Node)
        return NULL;
 
    Node->Folder.CompressionType = CAB_COMP_NONE;
 
    FolderList.push_back(Node);
 
    return Node;
}

Referenced by NewFolder(), and Open().

NormalizePath()

void CCabinet::NormalizePath

(

std::string &

Path

)

Definition at line 179 of file cabinet.cxx.

{
    if (Path.length() > 0)
    {
        if (!IsSeparator(Path[Path.length() - 1]))
            Path += DIR_SEPARATOR_CHAR;
    }
}

Referenced by SetDestinationPath(), and CDFParser::SetFileRelativePath().

OnAdd()

void CCabinet::OnAdd ( PCFFILE  Entry, const char *  FileName  )

virtual

Reimplemented in CCABManager.

Definition at line 1780 of file cabinet.cxx.

{
}

Referenced by WriteFileToScratchStorage().

OnCabinetName()

bool CCabinet::OnCabinetName ( ULONG  Number, char *  Name  )

virtual

Reimplemented in CDFParser.

Definition at line 1806 of file cabinet.cxx.

{
    return false;
}

Referenced by CommitDisk(), and InitCabinetHeader().

OnDiskChange()

void CCabinet::OnDiskChange ( const char *  CabinetName, const char *  DiskLabel  )

virtual

Reimplemented in CCABManager.

Definition at line 1762 of file cabinet.cxx.

{
}

Referenced by ExtractFile(), and FindNext().

OnDiskLabel()

bool CCabinet::OnDiskLabel ( ULONG  Number, char *  Label  )

virtual

Reimplemented in CDFParser.

Definition at line 1792 of file cabinet.cxx.

{
    return false;
}

Referenced by InitCabinetHeader().

OnExtract()

void CCabinet::OnExtract ( PCFFILE  Entry, const char *  FileName  )

virtual

Reimplemented in CCABManager.

Definition at line 1750 of file cabinet.cxx.

{
}

Referenced by ExtractFile().

OnOverwrite()

bool CCabinet::OnOverwrite ( PCFFILE  Entry, const char *  FileName  )

virtual

Reimplemented in CCABManager.

Definition at line 1735 of file cabinet.cxx.

{
    return false;
}

Referenced by CommitDisk(), and ExtractFile().

OnVerboseMessage()

void CCabinet::OnVerboseMessage ( const char *  Message )

virtual

Reimplemented in CCABManager.

Definition at line 1773 of file cabinet.cxx.

{
 
}

Referenced by CDFParser::Parse().

Open()

ULONG CCabinet::Open

(

)

Definition at line 387 of file cabinet.cxx.

{
    ULONG Status;
    ULONG Index;
 
    if (!FileOpen)
    {
        ULONG BytesRead;
        ULONG Size;
 
        OutputBuffer = malloc(CAB_BLOCKSIZE + 12);    // This should be enough
        if (!OutputBuffer)
            return CAB_STATUS_NOMEMORY;
 
        FileHandle = fopen(CabinetName, "rb");
        if (FileHandle == NULL)
        {
            DPRINT(MID_TRACE, ("Cannot open file.\n"));
            return CAB_STATUS_CANNOT_OPEN;
        }
 
        FileOpen = true;
 
        /* Load CAB header */
        if ((Status = ReadBlock(&CABHeader, sizeof(CFHEADER), &BytesRead))
            != CAB_STATUS_SUCCESS)
        {
            DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
            return CAB_STATUS_INVALID_CAB;
        }
 
        /* Check header */
        if ((BytesRead                 != sizeof(CFHEADER)) ||
            (CABHeader.Signature       != CAB_SIGNATURE   ) ||
            (CABHeader.Version         != CAB_VERSION     ) ||
            (CABHeader.FolderCount     == 0               ) ||
            (CABHeader.FileCount       == 0               ) ||
            (CABHeader.FileTableOffset < sizeof(CFHEADER)))
        {
            CloseCabinet();
            DPRINT(MID_TRACE, ("File has invalid header.\n"));
            return CAB_STATUS_INVALID_CAB;
        }
 
        Size = 0;
 
        /* Read/skip any reserved bytes */
        if (CABHeader.Flags & CAB_FLAG_RESERVE)
        {
            if ((Status = ReadBlock(&Size, sizeof(ULONG), &BytesRead))
                != CAB_STATUS_SUCCESS)
            {
                DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
                return CAB_STATUS_INVALID_CAB;
            }
            CabinetReserved = Size & 0xFFFF;
            FolderReserved  = (Size >> 16) & 0xFF;
            DataReserved    = (Size >> 24) & 0xFF;
 
            if (fseek(FileHandle, CabinetReserved, SEEK_CUR) != 0)
            {
                DPRINT(MIN_TRACE, ("fseek() failed.\n"));
                return CAB_STATUS_FAILURE;
            }
        }
 
        if ((CABHeader.Flags & CAB_FLAG_HASPREV) > 0)
        {
            /* Read name of previous cabinet */
            Status = ReadString(CabinetPrev, 256);
            if (Status != CAB_STATUS_SUCCESS)
                return Status;
            /* Read label of previous disk */
            Status = ReadString(DiskPrev, 256);
            if (Status != CAB_STATUS_SUCCESS)
                return Status;
        }
        else
        {
            strcpy(CabinetPrev, "");
            strcpy(DiskPrev,    "");
        }
 
        if ((CABHeader.Flags & CAB_FLAG_HASNEXT) > 0)
        {
            /* Read name of next cabinet */
            Status = ReadString(CabinetNext, 256);
            if (Status != CAB_STATUS_SUCCESS)
                return Status;
            /* Read label of next disk */
            Status = ReadString(DiskNext, 256);
            if (Status != CAB_STATUS_SUCCESS)
                return Status;
        }
        else
        {
            strcpy(CabinetNext, "");
            strcpy(DiskNext,    "");
        }
 
        /* Read all folders */
        for (Index = 0; Index < CABHeader.FolderCount; Index++)
        {
            PCFFOLDER_NODE FolderNode = NewFolderNode();
            if (!FolderNode)
            {
                DPRINT(MIN_TRACE, ("Insufficient resources.\n"));
                return CAB_STATUS_NOMEMORY;
            }
 
            if (Index == 0)
                FolderNode->UncompOffset = FolderUncompSize;
 
            FolderNode->Index = Index;
 
            if ((Status = ReadBlock(&FolderNode->Folder,
                sizeof(CFFOLDER), &BytesRead)) != CAB_STATUS_SUCCESS)
            {
                DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
                return CAB_STATUS_INVALID_CAB;
            }
        }
 
        /* Read file entries */
        Status = ReadFileTable();
        if (Status != CAB_STATUS_SUCCESS)
        {
            DPRINT(MIN_TRACE, ("ReadFileTable() failed (%u).\n", (UINT)Status));
            return Status;
        }
 
        /* Read data blocks for all folders */
        for (PCFFOLDER_NODE Node : FolderList)
        {
            Status = ReadDataBlocks(Node);
            if (Status != CAB_STATUS_SUCCESS)
            {
                DPRINT(MIN_TRACE, ("ReadDataBlocks() failed (%u).\n", (UINT)Status));
                return Status;
            }
        }
    }
    return CAB_STATUS_SUCCESS;
}

Referenced by CCABManager::DisplayCabinet(), ExtractFile(), CCABManager::ExtractFromCabinet(), and FindNext().

ReadBlock()

ULONG CCabinet::ReadBlock ( void *  Buffer, ULONG  Size, PULONG  BytesRead  )

private

Definition at line 2322 of file cabinet.cxx.

{
    *BytesRead = fread(Buffer, 1, Size, FileHandle);
    if ( *BytesRead != Size )
        return CAB_STATUS_INVALID_CAB;
    return CAB_STATUS_SUCCESS;
}

Referenced by ExtractFile(), Open(), ReadDataBlocks(), ReadFileTable(), and ReadString().

ReadDataBlocks()

ULONG CCabinet::ReadDataBlocks ( PCFFOLDER_NODE  FolderNode )

private

Definition at line 2040 of file cabinet.cxx.

{
    ULONG AbsoluteOffset;
    ULONG UncompOffset;
    PCFDATA_NODE Node;
    ULONG BytesRead;
    ULONG Status;
    ULONG i;
 
    DPRINT(MAX_TRACE, ("Reading data blocks for folder (%u)  at absolute offset (0x%X).\n",
        (UINT)FolderNode->Index, (UINT)FolderNode->Folder.DataOffset));
 
    AbsoluteOffset = FolderNode->Folder.DataOffset;
    UncompOffset   = FolderNode->UncompOffset;
 
    for (i = 0; i < FolderNode->Folder.DataBlockCount; i++)
    {
        Node = NewDataNode(FolderNode);
        if (!Node)
        {
            DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
            return CAB_STATUS_NOMEMORY;
        }
 
        /* Seek to data block */
        if (fseek(FileHandle, (off_t)AbsoluteOffset, SEEK_SET) != 0)
        {
            DPRINT(MIN_TRACE, ("fseek() failed.\n"));
            return CAB_STATUS_INVALID_CAB;
        }
 
        if ((Status = ReadBlock(&Node->Data, sizeof(CFDATA),
            &BytesRead)) != CAB_STATUS_SUCCESS)
        {
            DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
            return CAB_STATUS_INVALID_CAB;
        }
 
        DPRINT(MAX_TRACE, ("AbsOffset (0x%X)  UncompOffset (0x%X)  Checksum (0x%X)  CompSize (%u)  UncompSize (%u).\n",
            (UINT)AbsoluteOffset,
            (UINT)UncompOffset,
            (UINT)Node->Data.Checksum,
            Node->Data.CompSize,
            Node->Data.UncompSize));
 
        Node->AbsoluteOffset = AbsoluteOffset;
        Node->UncompOffset   = UncompOffset;
 
        AbsoluteOffset += sizeof(CFDATA) + Node->Data.CompSize;
        UncompOffset   += Node->Data.UncompSize;
    }
 
    FolderUncompSize = UncompOffset;
 
    return CAB_STATUS_SUCCESS;
}

Referenced by Open().

ReadFileTable()

ULONG CCabinet::ReadFileTable ( )

private

Definition at line 1983 of file cabinet.cxx.

{
    ULONG i;
    ULONG Status;
    ULONG BytesRead;
    PCFFILE_NODE File;
 
    DPRINT(MAX_TRACE, ("Reading file table at absolute offset (0x%X).\n",
        (UINT)CABHeader.FileTableOffset));
 
    /* Seek to file table */
    if (fseek(FileHandle, (off_t)CABHeader.FileTableOffset, SEEK_SET) != 0)
    {
        DPRINT(MIN_TRACE, ("fseek() failed.\n"));
        return CAB_STATUS_INVALID_CAB;
    }
 
    for (i = 0; i < CABHeader.FileCount; i++)
    {
        File = NewFileNode();
        if (!File)
        {
            DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
            return CAB_STATUS_NOMEMORY;
        }
 
        if ((Status = ReadBlock(&File->File, sizeof(CFFILE),
            &BytesRead)) != CAB_STATUS_SUCCESS)
        {
            DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
            return CAB_STATUS_INVALID_CAB;
        }
 
        /* Read file name */
        char Buf[PATH_MAX];
        Status = ReadString(Buf, PATH_MAX);
        if (Status != CAB_STATUS_SUCCESS)
            return Status;
        // FIXME: We could split up folder\file.txt here
        File->FileName = Buf;
 
        DPRINT(MAX_TRACE, ("Found file '%s' at uncompressed offset (0x%X).  Size (%u bytes)  ControlId (0x%X).\n",
            File->FileName.c_str(),
            (UINT)File->File.FileOffset,
            (UINT)File->File.FileSize,
            File->File.FileControlID));
 
    }
    return CAB_STATUS_SUCCESS;
}

Referenced by Open().

ReadString()

ULONG CCabinet::ReadString ( char *  String, LONG  MaxLength  )

private

Definition at line 1928 of file cabinet.cxx.

{
    ULONG BytesRead;
    ULONG Status;
    LONG Size;
    bool Found;
 
    Found  = false;
 
    Status = ReadBlock(String, MaxLength, &BytesRead);
    if (Status != CAB_STATUS_SUCCESS)
    {
        DPRINT(MIN_TRACE, ("Cannot read from file (%u).\n", (UINT)Status));
        return CAB_STATUS_INVALID_CAB;
    }
 
    // Find the terminating NULL character
    for (Size = 0; Size < MaxLength; Size++)
    {
        if (String[Size] == '\0')
        {
            Found = true;
            break;
        }
    }
 
    if (!Found)
    {
        DPRINT(MIN_TRACE, ("Filename in the cabinet file is too long.\n"));
        return CAB_STATUS_INVALID_CAB;
    }
 
    // Compute the offset of the next CFFILE.
    // We have to subtract from the current offset here, because we read MaxLength characters above and most-probably the file name isn't MaxLength characters long.
    // + 1 to skip the terminating NULL character as well.
    Size = -(MaxLength - Size) + 1;
 
    if (fseek(FileHandle, (off_t)Size, SEEK_CUR) != 0)
    {
        DPRINT(MIN_TRACE, ("fseek() failed.\n"));
        return CAB_STATUS_INVALID_CAB;
    }
 
    return CAB_STATUS_SUCCESS;
}

Referenced by Open(), and ReadFileTable().

SelectCodec()

void CCabinet::SelectCodec

(

LONG

Id

)

Definition at line 1018 of file cabinet.cxx.

{
    if (CodecSelected)
    {
        if (Id == CodecId)
            return;
 
        CodecSelected = false;
        delete Codec;
    }
 
    switch (Id)
    {
        case CAB_CODEC_RAW:
            Codec = new CRawCodec();
            break;
 
        case CAB_CODEC_MSZIP:
            Codec = new CMSZipCodec();
            break;
 
        default:
            return;
    }
 
    CodecId       = Id;
    CodecSelected = true;
}

Referenced by ExtractFile(), CCABManager::ParseCmdline(), and SetCompressionCodec().

SetAttributesOnFile()

ULONG CCabinet::SetAttributesOnFile ( char *  FileName, USHORT  FileAttributes  )

private

Definition at line 2968 of file cabinet.cxx.

{
#if defined(_WIN32)
    // 0x37 = READONLY | HIDDEN | SYSTEM | DIRECTORY | ARCHIVE
    // The IDs for these attributes are the same in the CAB file and under Windows
    // If the file has any other attributes, strip them off by the logical AND.
    SetFileAttributes(FileName, (DWORD)(FileAttributes & 0x37));
 
    return CAB_STATUS_SUCCESS;
#else
    //DPRINT(MIN_TRACE, ("FIXME: SetAttributesOnFile() is unimplemented\n"));
    return CAB_STATUS_SUCCESS;
#endif
}

Referenced by ExtractFile().

SetCabinetName()

void CCabinet::SetCabinetName

(

const char *

FileName

)

Definition at line 205 of file cabinet.cxx.

{
    strcpy(CabinetName, FileName);
}

Referenced by ExtractFile(), FindNext(), and CCABManager::ParseCmdline().

SetCabinetReservedFile()

bool CCabinet::SetCabinetReservedFile

(

const char *

FileName

)

Definition at line 319 of file cabinet.cxx.

{
    FILE* FileHandle;
    ULONG BytesRead;
    std::string ConvertedFileName;
 
    ConvertedFileName = FileName;
    ConvertPath(ConvertedFileName);
 
    FileHandle = fopen(ConvertedFileName.c_str(), "rb");
    if (FileHandle == NULL)
    {
        DPRINT(MID_TRACE, ("Cannot open cabinet reserved file.\n"));
        return false;
    }
 
    CabinetReservedFileSize = GetSizeOfFile(FileHandle);
    if (CabinetReservedFileSize == (ULONG)-1)
    {
        DPRINT(MIN_TRACE, ("Cannot read from cabinet reserved file.\n"));
        fclose(FileHandle);
        return false;
    }
 
    if (CabinetReservedFileSize == 0)
    {
        fclose(FileHandle);
        return false;
    }
 
    CabinetReservedFileBuffer = malloc(CabinetReservedFileSize);
    if (!CabinetReservedFileBuffer)
    {
        fclose(FileHandle);
        return false;
    }
 
    BytesRead = fread(CabinetReservedFileBuffer, 1, CabinetReservedFileSize, FileHandle);
    if( BytesRead != CabinetReservedFileSize )
    {
        fclose(FileHandle);
        return false;
    }
 
    fclose(FileHandle);
 
    CabinetReservedFile = FileName;
 
    return true;
}

Referenced by CCABManager::ParseCmdline().

SetCompressionCodec()

bool CCabinet::SetCompressionCodec

(

const char *

CodecName

)

Definition at line 288 of file cabinet.cxx.

{
    if( !strcasecmp(CodecName, "raw") )
        SelectCodec(CAB_CODEC_RAW);
    else if( !strcasecmp(CodecName, "mszip") )
        SelectCodec(CAB_CODEC_MSZIP);
    else
    {
        printf("ERROR: Invalid codec specified!\n");
        return false;
    }
 
    return true;
}

Referenced by CCABManager::ParseCmdline().

SetDestinationPath()

void CCabinet::SetDestinationPath

(

const char *

DestinationPath

)

Definition at line 216 of file cabinet.cxx.

{
    DestPath = DestinationPath;
    ConvertPath(DestPath);
    NormalizePath(DestPath);
}

Referenced by CCABManager::ParseCmdline().

SetMaxDiskSize()

void CCabinet::SetMaxDiskSize

(

ULONG

Size

)

Definition at line 1720 of file cabinet.cxx.

{
    MaxDiskSize = Size;
}

Referenced by CDFParser::DoMaxDiskSize(), and CDFParser::SetupNewDisk().

WriteCabinetHeader()

ULONG CCabinet::WriteCabinetHeader ( bool  MoreDisks )

private

Definition at line 2484 of file cabinet.cxx.

{
    ULONG BytesWritten;
    ULONG Size;
 
    if (MoreDisks)
    {
        CABHeader.Flags |= CAB_FLAG_HASNEXT;
        Size = TotalHeaderSize;
    }
    else
    {
        CABHeader.Flags &= ~CAB_FLAG_HASNEXT;
        DiskSize -= NextFieldsSize;
        Size = TotalHeaderSize - NextFieldsSize;
    }
 
    /* Set absolute folder offsets */
    BytesWritten = Size + TotalFolderSize + TotalFileSize;
    CABHeader.FolderCount = 0;
    for (PCFFOLDER_NODE FolderNode : FolderList)
    {
        FolderNode->Folder.DataOffset = BytesWritten;
 
        BytesWritten += FolderNode->TotalFolderSize;
 
        CABHeader.FolderCount++;
    }
 
    /* Set absolute offset of file table */
    CABHeader.FileTableOffset = Size + TotalFolderSize;
 
    /* Count number of files to be committed */
    CABHeader.FileCount = 0;
    for (PCFFILE_NODE FileNode : FileList)
    {
        if (FileNode->Commit)
            CABHeader.FileCount++;
    }
 
    CABHeader.CabinetSize = DiskSize;
 
    /* Write header */
    if (fwrite(&CABHeader, sizeof(CFHEADER), 1, FileHandle) < 1)
    {
        DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
        return CAB_STATUS_CANNOT_WRITE;
    }
 
    /* Write per-cabinet reserved area if present */
    if (CABHeader.Flags & CAB_FLAG_RESERVE)
    {
        ULONG ReservedSize;
 
        ReservedSize = CabinetReservedFileSize & 0xffff;
        ReservedSize |= (0 << 16); /* Folder reserved area size */
        ReservedSize |= (0 << 24); /* Folder reserved area size */
 
        BytesWritten = sizeof(ULONG);
        if (fwrite(&ReservedSize, sizeof(ULONG), 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
 
        BytesWritten = CabinetReservedFileSize;
        if (fwrite(CabinetReservedFileBuffer, CabinetReservedFileSize, 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
    }
 
    if ((CABHeader.Flags & CAB_FLAG_HASPREV) > 0)
    {
        DPRINT(MAX_TRACE, ("CabinetPrev '%s'.\n", CabinetPrev));
 
        /* Write name of previous cabinet */
        Size = (ULONG)strlen(CabinetPrev) + 1;
        BytesWritten = Size;
        if (fwrite(CabinetPrev, Size, 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
 
        DPRINT(MAX_TRACE, ("DiskPrev '%s'.\n", DiskPrev));
 
        /* Write label of previous disk */
        Size = (ULONG)strlen(DiskPrev) + 1;
        BytesWritten = Size;
        if (fwrite(DiskPrev, Size, 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
    }
 
    if ((CABHeader.Flags & CAB_FLAG_HASNEXT) > 0)
    {
        DPRINT(MAX_TRACE, ("CabinetNext '%s'.\n", CabinetNext));
 
        /* Write name of next cabinet */
        Size = (ULONG)strlen(CabinetNext) + 1;
        BytesWritten = Size;
        if (fwrite(CabinetNext, Size, 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
 
        DPRINT(MAX_TRACE, ("DiskNext '%s'.\n", DiskNext));
 
        /* Write label of next disk */
        Size = (ULONG)strlen(DiskNext) + 1;
        BytesWritten = Size;
        if (fwrite(DiskNext, Size, 1, FileHandle) < 1)
        {
            DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
            return CAB_STATUS_CANNOT_WRITE;
        }
    }
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CommitDisk().

WriteDataBlock()

ULONG CCabinet::WriteDataBlock ( )

private

Definition at line 2751 of file cabinet.cxx.

{
    ULONG Status;
    ULONG BytesWritten;
    PCFDATA_NODE DataNode;
 
    if (!BlockIsSplit)
    {
        Status = Codec->Compress(OutputBuffer,
            InputBuffer,
            CurrentIBufferSize,
            &TotalCompSize);
 
        DPRINT(MAX_TRACE, ("Block compressed. CurrentIBufferSize (%u)  TotalCompSize(%u).\n",
            (UINT)CurrentIBufferSize, (UINT)TotalCompSize));
 
        CurrentOBuffer     = OutputBuffer;
        CurrentOBufferSize = TotalCompSize;
    }
 
    DataNode = NewDataNode(CurrentFolderNode);
    if (!DataNode)
    {
        DPRINT(MIN_TRACE, ("Insufficient memory.\n"));
        return CAB_STATUS_NOMEMORY;
    }
 
    DiskSize += sizeof(CFDATA);
 
    if (MaxDiskSize > 0)
        /* Disk size is limited */
        BlockIsSplit = (DiskSize + CurrentOBufferSize > MaxDiskSize);
    else
        BlockIsSplit = false;
 
    if (BlockIsSplit)
    {
        DataNode->Data.CompSize   = (USHORT)(MaxDiskSize - DiskSize);
        DataNode->Data.UncompSize = 0;
        CreateNewDisk = true;
    }
    else
    {
        DataNode->Data.CompSize   = (USHORT)CurrentOBufferSize;
        DataNode->Data.UncompSize = (USHORT)CurrentIBufferSize;
    }
 
    DataNode->Data.Checksum = 0;
    DataNode->ScratchFilePosition = ScratchFile->Position();
 
    // FIXME: MAKECAB.EXE does not like this checksum algorithm
    //DataNode->Data.Checksum = ComputeChecksum(CurrentOBuffer, DataNode->Data.CompSize, 0);
 
    DPRINT(MAX_TRACE, ("Writing block. Checksum (0x%X)  CompSize (%u)  UncompSize (%u).\n",
        (UINT)DataNode->Data.Checksum,
        DataNode->Data.CompSize,
        DataNode->Data.UncompSize));
 
    Status = ScratchFile->WriteBlock(&DataNode->Data,
        CurrentOBuffer, &BytesWritten);
    if (Status != CAB_STATUS_SUCCESS)
        return Status;
 
    DiskSize += BytesWritten;
 
    CurrentFolderNode->TotalFolderSize += (BytesWritten + sizeof(CFDATA));
    CurrentFolderNode->Folder.DataBlockCount++;
 
    CurrentOBuffer = (unsigned char*)CurrentOBuffer + DataNode->Data.CompSize;
    CurrentOBufferSize -= DataNode->Data.CompSize;
 
    LastBlockStart += DataNode->Data.UncompSize;
 
    if (!BlockIsSplit)
    {
        CurrentIBufferSize = 0;
        CurrentIBuffer     = InputBuffer;
    }
 
    return CAB_STATUS_SUCCESS;
}

Referenced by WriteDisk(), and WriteFileToScratchStorage().

WriteDisk()

ULONG CCabinet::WriteDisk

(

ULONG

MoreDisks

)

Definition at line 1311 of file cabinet.cxx.

{
    ULONG Status;
 
    ContinueFile = false;
    for (auto it = FileList.begin(); it != FileList.end();)
    {
        Status = WriteFileToScratchStorage(*it);
        if (Status != CAB_STATUS_SUCCESS)
            return Status;
 
        if (CreateNewDisk)
        {
            /* A data block could span more than two
               disks if MaxDiskSize is very small */
            while (CreateNewDisk)
            {
                DPRINT(MAX_TRACE, ("Creating new disk.\n"));
                CommitDisk(true);
                CloseDisk();
                NewDisk();
 
                ContinueFile = true;
                CreateNewDisk = false;
 
                DPRINT(MAX_TRACE, ("First on new disk. CurrentIBufferSize (%u)  CurrentOBufferSize (%u).\n",
                    (UINT)CurrentIBufferSize, (UINT)CurrentOBufferSize));
 
                if ((CurrentIBufferSize > 0) || (CurrentOBufferSize > 0))
                {
                    Status = WriteDataBlock();
                    if (Status != CAB_STATUS_SUCCESS)
                        return Status;
                }
            }
        }
        else
        {
            ContinueFile = false;
            it++;
        }
    }
 
    if ((CurrentIBufferSize > 0) || (CurrentOBufferSize > 0))
    {
        /* A data block could span more than two
           disks if MaxDiskSize is very small */
 
        ASSERT(CreateNewDisk == false);
 
        do
        {
            if (CreateNewDisk)
            {
                DPRINT(MID_TRACE, ("Creating new disk 2.\n"));
                CommitDisk(true);
                CloseDisk();
                NewDisk();
                CreateNewDisk = false;
            }
 
            if ((CurrentIBufferSize > 0) || (CurrentOBufferSize > 0))
            {
                Status = WriteDataBlock();
                if (Status != CAB_STATUS_SUCCESS)
                    return Status;
            }
        } while (CreateNewDisk);
    }
    CommitDisk(MoreDisks);
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CreateSimpleCabinet(), CDFParser::Parse(), and CDFParser::PerformNewCommand().

WriteFileEntries()

ULONG CCabinet::WriteFileEntries ( )

private

Definition at line 2646 of file cabinet.cxx.

{
    bool SetCont = false;
 
    DPRINT(MAX_TRACE, ("Writing file table.\n"));
 
    for (PCFFILE_NODE File : FileList)
    {
        if (File->Commit)
        {
            /* Remove any continued files that ends in this disk */
            if (File->File.FileControlID == CAB_FILE_CONTINUED)
                File->Delete = true;
 
            /* The file could end in the last (split) block and should therefore
               appear in the next disk too */
 
            if ((File->File.FileOffset + File->File.FileSize >= LastBlockStart) &&
                (File->File.FileControlID <= CAB_FILE_MAX_FOLDER) && (BlockIsSplit))
            {
                File->File.FileControlID = CAB_FILE_SPLIT;
                File->Delete = false;
                SetCont = true;
            }
 
            DPRINT(MAX_TRACE, ("Writing file entry. FileControlID (0x%X)  FileOffset (0x%X)  FileSize (%u)  FileName (%s).\n",
                File->File.FileControlID, (UINT)File->File.FileOffset, (UINT)File->File.FileSize, File->FileName.c_str()));
 
            if (fwrite(&File->File, sizeof(CFFILE), 1, FileHandle) < 1)
            {
                DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
                return CAB_STATUS_CANNOT_WRITE;
            }
 
            std::string fname = CreateCabFilename(File);
            if (fwrite(fname.c_str(), fname.length() + 1, 1, FileHandle) < 1)
            {
                DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
                return CAB_STATUS_CANNOT_WRITE;
            }
 
            if (SetCont)
            {
                File->File.FileControlID = CAB_FILE_CONTINUED;
                SetCont = false;
            }
        }
    }
    return CAB_STATUS_SUCCESS;
}

Referenced by CommitDisk().

WriteFileToScratchStorage()

ULONG CCabinet::WriteFileToScratchStorage

(

PCFFILE_NODE

FileNode

)

Definition at line 1197 of file cabinet.cxx.

{
    ULONG BytesToRead;
    ULONG BytesRead;
    ULONG Status;
    ULONG Size;
 
    if (!ContinueFile)
    {
        /* Try to open file */
        SourceFile = fopen(FileNode->FileName.c_str(), "rb");
        if (SourceFile == NULL)
        {
            DPRINT(MID_TRACE, ("File not found (%s).\n", FileNode->FileNameOnDisk.c_str()));
            return CAB_STATUS_NOFILE;
        }
 
        if (CreateNewFolder)
        {
            /* There is always a new folder after
               a split file is completely stored */
            Status = NewFolder();
            if (Status != CAB_STATUS_SUCCESS)
                return Status;
            CreateNewFolder = false;
        }
 
        /* Call OnAdd event handler */
        OnAdd(&FileNode->File, FileNode->FileName.c_str());
 
        TotalBytesLeft = FileNode->File.FileSize;
 
        FileNode->File.FileOffset        = CurrentFolderNode->UncompOffset;
        CurrentFolderNode->UncompOffset += TotalBytesLeft;
        FileNode->File.FileControlID     = (USHORT)(NextFolderNumber - 1);
        CurrentFolderNode->Commit        = true;
        PrevCabinetNumber                = CurrentDiskNumber;
 
        Size = sizeof(CFFILE) + (ULONG)CreateCabFilename(FileNode).length() + 1;
        CABHeader.FileTableOffset += Size;
        TotalFileSize += Size;
        DiskSize += Size;
    }
 
    FileNode->Commit = true;
 
    if (TotalBytesLeft > 0)
    {
        do
        {
            if (TotalBytesLeft > (ULONG)CAB_BLOCKSIZE - CurrentIBufferSize)
                BytesToRead = CAB_BLOCKSIZE - CurrentIBufferSize;
            else
                BytesToRead = TotalBytesLeft;
 
            if ( (BytesRead = fread(CurrentIBuffer, 1, BytesToRead, SourceFile)) != BytesToRead )
            {
                DPRINT(MIN_TRACE, ("Cannot read from file. BytesToRead (%u)  BytesRead (%u)  CurrentIBufferSize (%u).\n",
                    (UINT)BytesToRead, (UINT)BytesRead, (UINT)CurrentIBufferSize));
                return CAB_STATUS_INVALID_CAB;
            }
 
            CurrentIBuffer = (unsigned char*)CurrentIBuffer + BytesRead;
            CurrentIBufferSize += (USHORT)BytesRead;
 
            if (CurrentIBufferSize == CAB_BLOCKSIZE)
            {
                Status = WriteDataBlock();
                if (Status != CAB_STATUS_SUCCESS)
                    return Status;
            }
            TotalBytesLeft -= BytesRead;
        } while ((TotalBytesLeft > 0) && (!CreateNewDisk));
    }
 
    if (TotalBytesLeft == 0)
    {
        fclose(SourceFile);
        FileNode->Delete = true;
 
        if (FileNode->File.FileControlID > CAB_FILE_MAX_FOLDER)
        {
            FileNode->File.FileControlID = CAB_FILE_CONTINUED;
            CurrentFolderNode->Delete = true;
 
            if ((CurrentIBufferSize > 0) || (CurrentOBufferSize > 0))
            {
                Status = WriteDataBlock();
                if (Status != CAB_STATUS_SUCCESS)
                    return Status;
            }
 
            CreateNewFolder = true;
        }
    }
    else
    {
        if (FileNode->File.FileControlID <= CAB_FILE_MAX_FOLDER)
            FileNode->File.FileControlID = CAB_FILE_SPLIT;
        else
            FileNode->File.FileControlID = CAB_FILE_PREV_NEXT;
    }
 
    return CAB_STATUS_SUCCESS;
}

Referenced by WriteDisk().

WriteFolderEntries()

ULONG CCabinet::WriteFolderEntries ( )

private

Definition at line 2618 of file cabinet.cxx.

{
    DPRINT(MAX_TRACE, ("Writing folder table.\n"));
 
    for (PCFFOLDER_NODE FolderNode : FolderList)
    {
        if (FolderNode->Commit)
        {
            DPRINT(MAX_TRACE, ("Writing folder entry. CompressionType (0x%X)  DataBlockCount (%d)  DataOffset (0x%X).\n",
                FolderNode->Folder.CompressionType, FolderNode->Folder.DataBlockCount, (UINT)FolderNode->Folder.DataOffset));
 
            if (fwrite(&FolderNode->Folder, sizeof(CFFOLDER), 1, FileHandle) < 1)
            {
                DPRINT(MIN_TRACE, ("Cannot write to file.\n"));
                return CAB_STATUS_CANNOT_WRITE;
            }
        }
    }
 
    return CAB_STATUS_SUCCESS;
}

Referenced by CommitDisk().

Member Data Documentation

BlockIsSplit

bool CCabinet::BlockIsSplit

private

Definition at line 485 of file cabinet.h.

Referenced by CCabinet(), WriteDataBlock(), and WriteFileEntries().

BytesLeftInBlock

ULONG CCabinet::BytesLeftInBlock

private

Definition at line 443 of file cabinet.h.

Referenced by CCabinet(), and ExtractFile().

BytesLeftInCabinet

ULONG CCabinet::BytesLeftInCabinet

private

Definition at line 470 of file cabinet.h.

CABHeader

CFHEADER CCabinet::CABHeader

private

Definition at line 451 of file cabinet.h.

Referenced by InitCabinetHeader(), NewCabinet(), NewFolder(), Open(), ReadFileTable(), WriteCabinetHeader(), and WriteFileToScratchStorage().

CabinetName

char CCabinet::CabinetName[256]

private

Definition at line 433 of file cabinet.h.

Referenced by CCabinet(), CommitDisk(), GetCabinetName(), Open(), and SetCabinetName().

CabinetNext

char CCabinet::CabinetNext[256]

private

Definition at line 436 of file cabinet.h.

Referenced by CCabinet(), ExtractFile(), FindNext(), InitCabinetHeader(), Open(), and WriteCabinetHeader().

CabinetPrev

char CCabinet::CabinetPrev[256]

private

Definition at line 434 of file cabinet.h.

Referenced by CCabinet(), InitCabinetHeader(), Open(), and WriteCabinetHeader().

CabinetReserved

ULONG CCabinet::CabinetReserved

private

Definition at line 452 of file cabinet.h.

Referenced by Open().

CabinetReservedFile

std::string CCabinet::CabinetReservedFile

private

Definition at line 446 of file cabinet.h.

Referenced by SetCabinetReservedFile().

CabinetReservedFileBuffer

void* CCabinet::CabinetReservedFileBuffer

private

Definition at line 447 of file cabinet.h.

Referenced by CCabinet(), SetCabinetReservedFile(), WriteCabinetHeader(), and ~CCabinet().

CabinetReservedFileSize

ULONG CCabinet::CabinetReservedFileSize

private

Definition at line 448 of file cabinet.h.

Referenced by CCabinet(), InitCabinetHeader(), SetCabinetReservedFile(), WriteCabinetHeader(), and ~CCabinet().

Codec

CCABCodec* CCabinet::Codec

private

Definition at line 460 of file cabinet.h.

Referenced by CCabinet(), ExtractFile(), SelectCodec(), WriteDataBlock(), and ~CCabinet().

CodecId

LONG CCabinet::CodecId

private

Definition at line 461 of file cabinet.h.

Referenced by CCabinet(), NewFolder(), and SelectCodec().

CodecSelected

bool CCabinet::CodecSelected

private

Definition at line 462 of file cabinet.h.

Referenced by CCabinet(), IsCodecSelected(), SelectCodec(), and ~CCabinet().

ContinueFile

bool CCabinet::ContinueFile

private

Definition at line 483 of file cabinet.h.

Referenced by WriteDisk(), and WriteFileToScratchStorage().

CreateNewDisk

bool CCabinet::CreateNewDisk

private

Definition at line 478 of file cabinet.h.

Referenced by NewCabinet(), NewDisk(), WriteDataBlock(), WriteDisk(), and WriteFileToScratchStorage().

CreateNewFolder

bool CCabinet::CreateNewFolder

private

Definition at line 479 of file cabinet.h.

Referenced by NewCabinet(), and WriteFileToScratchStorage().

CriteriaList

std::list<PSEARCH_CRITERIA> CCabinet::CriteriaList

private

Definition at line 459 of file cabinet.h.

Referenced by AddSearchCriteria(), CreateSimpleCabinet(), DestroySearchCriteria(), FindNext(), and HasSearchCriteria().

CurrentDataNode

PCFDATA_NODE CCabinet::CurrentDataNode

private

Definition at line 457 of file cabinet.h.

Referenced by CCabinet(), and ExtractFile().

CurrentDiskNumber

ULONG CCabinet::CurrentDiskNumber

private

Definition at line 432 of file cabinet.h.

Referenced by CloseDisk(), CommitDisk(), GetCurrentDiskNumber(), InitCabinetHeader(), NewCabinet(), and WriteFileToScratchStorage().

CurrentFolderNode

PCFFOLDER_NODE CCabinet::CurrentFolderNode

private

Definition at line 456 of file cabinet.h.

Referenced by AddFile(), ExtractFile(), GetAbsoluteOffset(), LocateFile(), NewCabinet(), NewDisk(), NewFolder(), WriteDataBlock(), and WriteFileToScratchStorage().

CurrentIBuffer

void* CCabinet::CurrentIBuffer

private

Definition at line 464 of file cabinet.h.

Referenced by NewCabinet(), WriteDataBlock(), and WriteFileToScratchStorage().

CurrentIBufferSize

ULONG CCabinet::CurrentIBufferSize

private

Definition at line 465 of file cabinet.h.

Referenced by NewCabinet(), WriteDataBlock(), WriteDisk(), and WriteFileToScratchStorage().

CurrentOBuffer

void* CCabinet::CurrentOBuffer

private

Definition at line 468 of file cabinet.h.

Referenced by WriteDataBlock().

CurrentOBufferSize

ULONG CCabinet::CurrentOBufferSize

private

Definition at line 469 of file cabinet.h.

Referenced by WriteDataBlock(), WriteDisk(), and WriteFileToScratchStorage().

DataReserved

ULONG CCabinet::DataReserved

private

Definition at line 454 of file cabinet.h.

Referenced by Open().

DestPath

std::string CCabinet::DestPath

private

Definition at line 445 of file cabinet.h.

Referenced by ExtractFile(), GetDestinationPath(), and SetDestinationPath().

DiskNext

char CCabinet::DiskNext[256]

private

Definition at line 437 of file cabinet.h.

Referenced by CCabinet(), ExtractFile(), FindNext(), InitCabinetHeader(), Open(), and WriteCabinetHeader().

DiskPrev

char CCabinet::DiskPrev[256]

private

Definition at line 435 of file cabinet.h.

Referenced by CCabinet(), InitCabinetHeader(), Open(), and WriteCabinetHeader().

DiskSize

ULONG CCabinet::DiskSize

private

Definition at line 476 of file cabinet.h.

Referenced by InitCabinetHeader(), NewCabinet(), NewDisk(), NewFolder(), WriteCabinetHeader(), WriteDataBlock(), and WriteFileToScratchStorage().

FileHandle

FILE* CCabinet::FileHandle

private

Definition at line 449 of file cabinet.h.

Referenced by Close(), CommitDataBlocks(), CommitDisk(), ExtractFile(), GetFileTimes(), Open(), ReadBlock(), ReadDataBlocks(), ReadFileTable(), ReadString(), SetCabinetReservedFile(), WriteCabinetHeader(), WriteFileEntries(), and WriteFolderEntries().

FileList

std::list<PCFFILE_NODE> CCabinet::FileList

private

Definition at line 458 of file cabinet.h.

FileOpen

bool CCabinet::FileOpen

private

Definition at line 450 of file cabinet.h.

Referenced by CCabinet(), Close(), and Open().

FolderList

std::list<PCFFOLDER_NODE> CCabinet::FolderList

private

Definition at line 455 of file cabinet.h.

FolderReserved

ULONG CCabinet::FolderReserved

private

Definition at line 453 of file cabinet.h.

Referenced by Open().

FolderUncompSize

ULONG CCabinet::FolderUncompSize

private

Definition at line 442 of file cabinet.h.

Referenced by CCabinet(), Open(), and ReadDataBlocks().

InputBuffer

void* CCabinet::InputBuffer

private

Definition at line 463 of file cabinet.h.

Referenced by NewCabinet(), and WriteDataBlock().

LastBlockStart

ULONG CCabinet::LastBlockStart

private

Definition at line 474 of file cabinet.h.

Referenced by NewFolder(), WriteDataBlock(), and WriteFileEntries().

LastFileOffset

ULONG CCabinet::LastFileOffset

private

Definition at line 472 of file cabinet.h.

Referenced by ExtractFile(), and FindNext().

MaxDiskSize

ULONG CCabinet::MaxDiskSize

private

Definition at line 475 of file cabinet.h.

Referenced by CCabinet(), SetMaxDiskSize(), and WriteDataBlock().

NextFieldsSize

ULONG CCabinet::NextFieldsSize

private

Definition at line 439 of file cabinet.h.

Referenced by InitCabinetHeader(), and WriteCabinetHeader().

NextFolderNumber

ULONG CCabinet::NextFolderNumber

private

Definition at line 486 of file cabinet.h.

Referenced by NewCabinet(), NewDisk(), NewFolder(), and WriteFileToScratchStorage().

OutputBuffer

void* CCabinet::OutputBuffer

private

Definition at line 466 of file cabinet.h.

Referenced by WriteDataBlock().

PrevCabinetNumber

ULONG CCabinet::PrevCabinetNumber

private

Definition at line 477 of file cabinet.h.

Referenced by InitCabinetHeader(), NewCabinet(), and WriteFileToScratchStorage().

RestartSearch

bool CCabinet::RestartSearch

private

Definition at line 471 of file cabinet.h.

Referenced by ExtractFile(), FindFirst(), and FindNext().

ReuseBlock

bool CCabinet::ReuseBlock

private

Definition at line 444 of file cabinet.h.

Referenced by CCabinet(), and ExtractFile().

ScratchFile

class CCFDATAStorage* CCabinet::ScratchFile

private

Definition at line 481 of file cabinet.h.

Referenced by CCabinet(), CloseCabinet(), CommitDataBlocks(), CommitDisk(), NewCabinet(), and WriteDataBlock().

SourceFile

FILE* CCabinet::SourceFile

private

Definition at line 482 of file cabinet.h.

Referenced by WriteFileToScratchStorage().

TotalBytesLeft

ULONG CCabinet::TotalBytesLeft

private

Definition at line 484 of file cabinet.h.

Referenced by WriteFileToScratchStorage().

TotalCompSize

ULONG CCabinet::TotalCompSize

private

Definition at line 467 of file cabinet.h.

Referenced by WriteDataBlock().

TotalFileSize

ULONG CCabinet::TotalFileSize

private

Definition at line 441 of file cabinet.h.

Referenced by DestroyDeletedFileNodes(), NewCabinet(), NewDisk(), WriteCabinetHeader(), and WriteFileToScratchStorage().

TotalFolderSize

ULONG CCabinet::TotalFolderSize

private

Definition at line 440 of file cabinet.h.

Referenced by DestroyDeletedFolderNodes(), NewCabinet(), NewDisk(), NewFolder(), and WriteCabinetHeader().

TotalHeaderSize

ULONG CCabinet::TotalHeaderSize

private

Definition at line 438 of file cabinet.h.

Referenced by InitCabinetHeader(), NewCabinet(), and WriteCabinetHeader().

---

The documentation for this class was generated from the following files:

• sdk/tools/cabman/cabinet.h
• sdk/tools/cabman/cabinet.cxx