CCABManager Class Reference

#include <cabman.h>

Inheritance diagram for CCABManager:

Collaboration diagram for CCABManager:

Public Member Functions
	CCABManager ()
virtual	~CCABManager ()
bool	ParseCmdline (int argc, char *argv[])
bool	Run ()
bool	IsVerbose ()
Public Member Functions inherited from CDFParser
	CDFParser ()
virtual	~CDFParser ()
ULONG	Load (char *FileName)
ULONG	Parse ()
void	SetFileRelativePath (char *Path)
Public Member Functions inherited from CCabinet
	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
void	Usage ()
bool	CreateCabinet ()
bool	DisplayCabinet ()
bool	ExtractFromCabinet ()
virtual bool	OnOverwrite (PCFFILE File, const char *FileName) override
virtual void	OnExtract (PCFFILE File, const char *FileName) override
virtual void	OnDiskChange (const char *CabinetName, const char *DiskLabel) override
virtual void	OnAdd (PCFFILE Entry, const char *FileName) override
virtual void	OnVerboseMessage (const char *Message) override

Private Attributes
bool	ProcessAll
ULONG	Mode
bool	PromptOnOverwrite
char	FileName [PATH_MAX]
bool	Verbose

Additional Inherited Members
Public Attributes inherited from CDFParser
bool	InfFileOnly
bool	DontGenerateInf
std::string	FileRelativePath

Detailed Description

Definition at line 21 of file cabman.h.

Constructor & Destructor Documentation

CCABManager()

CCABManager::CCABManager

(

)

Definition at line 167 of file cabman.cxx.

{
    ProcessAll = false;
    InfFileOnly = false;
    Mode = CM_MODE_DISPLAY;
    FileName[0] = 0;
    Verbose = false;
}

~CCABManager()

CCABManager::~CCABManager ( )

virtual

Definition at line 180 of file cabman.cxx.

{
}

Member Function Documentation

CreateCabinet()

bool CCABManager::CreateCabinet ( )

private

Definition at line 423 of file cabman.cxx.

{
    ULONG Status;
 
    Status = Load(FileName);
    if (Status != CAB_STATUS_SUCCESS)
    {
        printf("ERROR: Specified directive file could not be found: %s.\n", FileName);
        return false;
    }
 
    Status = Parse();
 
    return (Status == CAB_STATUS_SUCCESS ? true : false);
}

Referenced by Run().

DisplayCabinet()

bool CCABManager::DisplayCabinet ( )

private

Definition at line 442 of file cabman.cxx.

{
    CAB_SEARCH Search;
    char Str[20];
    ULONG FileCount = 0;
    ULONG ByteCount = 0;
 
    if (Open() == CAB_STATUS_SUCCESS)
    {
        if (Verbose)
        {
            printf("Cabinet %s\n\n", GetCabinetName());
        }
 
        if (FindFirst(&Search) == CAB_STATUS_SUCCESS)
        {
            do
            {
                if (Search.File->FileControlID != CAB_FILE_CONTINUED)
                {
                    printf("%s ", Date2Str(Str, Search.File->FileDate));
                    printf("%s ", Time2Str(Str, Search.File->FileTime));
                    printf("%s ", Attr2Str(Str, Search.File->Attributes));
                    sprintf(Str, "%u", (UINT)Search.File->FileSize);
                    printf("%s ", Pad(Str, ' ', 13));
                    printf("%s\n", Search.FileName.c_str());
 
                    FileCount++;
                    ByteCount += Search.File->FileSize;
                }
            } while (FindNext(&Search) == CAB_STATUS_SUCCESS);
        }
 
        DestroySearchCriteria();
 
        if (FileCount > 0) {
            if (FileCount == 1)
                printf("                 1 file    ");
            else
            {
                sprintf(Str, "%u", (UINT)FileCount);
                printf("      %s files   ", Pad(Str, ' ', 12));
            }
 
            if (ByteCount == 1)
                printf("           1 byte\n");
            else
            {
                sprintf(Str, "%u", (UINT)ByteCount);
                printf("%s bytes\n", Pad(Str, ' ', 12));
            }
        }
        else
        {
            /* There should be at least one file in a cabinet */
            printf("WARNING: No files in cabinet.");
        }
        return true;
    }
    else
        printf("ERROR: Cannot open file: %s\n", GetCabinetName());
 
    return false;
}

Referenced by Run().

ExtractFromCabinet()

bool CCABManager::ExtractFromCabinet ( )

private

Definition at line 511 of file cabman.cxx.

{
    bool bRet = true;
    CAB_SEARCH Search;
    ULONG Status;
 
    if (Open() == CAB_STATUS_SUCCESS)
    {
        if (Verbose)
        {
            printf("Cabinet %s\n\n", GetCabinetName());
        }
 
        if (FindFirst(&Search) == CAB_STATUS_SUCCESS)
        {
            do
            {
                switch (Status = ExtractFile(Search.FileName.c_str()))
                {
                    case CAB_STATUS_SUCCESS:
                        break;
 
                    case CAB_STATUS_INVALID_CAB:
                        printf("ERROR: Cabinet contains errors.\n");
                        bRet = false;
                        break;
 
                    case CAB_STATUS_UNSUPPCOMP:
                        printf("ERROR: Cabinet uses unsupported compression type.\n");
                        bRet = false;
                        break;
 
                    case CAB_STATUS_CANNOT_WRITE:
                        printf("ERROR: You've run out of free space on the destination volume or the volume is damaged.\n");
                        bRet = false;
                        break;
 
                    default:
                        printf("ERROR: Unspecified error code (%u).\n", (UINT)Status);
                        bRet = false;
                        break;
                }
 
                if(!bRet)
                    break;
            } while (FindNext(&Search) == CAB_STATUS_SUCCESS);
 
            DestroySearchCriteria();
        }
 
        return bRet;
    }
    else
        printf("ERROR: Cannot open file: %s.\n", GetCabinetName());
 
    return false;
}

Referenced by Run().

IsVerbose()

bool CCABManager::IsVerbose ( )

inline

Definition at line 28 of file cabman.h.

{ return Verbose; }

OnAdd()

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

overrideprivatevirtual

Reimplemented from CCabinet.

Definition at line 658 of file cabman.cxx.

{
    if (Verbose)
    {
        printf("Adding %s\n", GetFileName(FileName).c_str());
    }
}

OnDiskChange()

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

overrideprivatevirtual

Reimplemented from CCabinet.

Definition at line 642 of file cabman.cxx.

{
    if (Verbose)
    {
        printf("\nChanging to cabinet %s - %s\n\n", CabinetName, DiskLabel);
    }
}

OnExtract()

void CCABManager::OnExtract ( PCFFILE  File, const char *  FileName  )

overrideprivatevirtual

Reimplemented from CCabinet.

Definition at line 625 of file cabman.cxx.

{
    if (Verbose)
    {
        printf("Extracting %s\n", GetFileName(FileName).c_str());
    }
}

OnOverwrite()

bool CCABManager::OnOverwrite ( PCFFILE  File, const char *  FileName  )

overrideprivatevirtual

Reimplemented from CCabinet.

Definition at line 606 of file cabman.cxx.

{
    if (Mode == CM_MODE_CREATE)
        return true;
 
    /* Always overwrite */
    return true;
}

OnVerboseMessage()

void CCABManager::OnVerboseMessage ( const char *  Message )

overrideprivatevirtual

Reimplemented from CCabinet.

Definition at line 673 of file cabman.cxx.

{
    if (Verbose)
    {
        printf("%s", Message);
    }
}

ParseCmdline()

bool CCABManager::ParseCmdline	(	int	argc,
		char *	argv[]
	)

Definition at line 224 of file cabman.cxx.

{
    int i;
    bool ShowUsage;
    bool FoundCabinet = false;
    std::string NextFolder;
    ShowUsage = (argc < 2);
 
    for (i = 1; i < argc; i++)
    {
        if (argv[i][0] == '-')
        {
            switch (argv[i][1])
            {
                case 'a':
                case 'A':
                    ProcessAll = true;
                    break;
 
                case 'c':
                case 'C':
                    Mode = CM_MODE_CREATE;
                    break;
 
                case 'd':
                case 'D':
                    Mode = CM_MODE_DISPLAY;
                    break;
 
                case 'e':
                case 'E':
                    Mode = CM_MODE_EXTRACT;
                    break;
 
                case 'f':
                case 'F':
                    if (argv[i][2] == 0)
                    {
                        i++;
                        NextFolder = argv[i];
                    }
                    else
                    {
                        NextFolder = argv[i] + 2;
                    }
                    break;
 
                case 'i':
                case 'I':
                    InfFileOnly = true;
                    break;
 
                case 'l':
                case 'L':
                    if (argv[i][2] == 0)
                    {
                        i++;
                        SetDestinationPath(&argv[i][0]);
                    }
                    else
                        SetDestinationPath(&argv[i][2]);
 
                    break;
 
                case 'm':
                case 'M':
                    // Set the compression codec (only affects compression, not decompression)
                    if(argv[i][2] == 0)
                    {
                        i++;
 
                        if( !SetCompressionCodec(&argv[i][0]) )
                            return false;
                    }
                    else
                    {
                        if( !SetCompressionCodec(&argv[i][2]) )
                            return false;
                    }
 
                    break;
 
                case 'n':
                case 'N':
                    DontGenerateInf = true;
                    break;
 
                case 'R':
                    switch (argv[i][2])
                    {
                        case 'C': /* File to put in cabinet reserved area */
                            if (argv[i][3] == 0)
                            {
                                i++;
                                if (!SetCabinetReservedFile(&argv[i][0]))
                                {
                                    printf("ERROR: Cannot open cabinet reserved area file.\n");
                                    return false;
                                }
                            }
                            else
                            {
                                if (!SetCabinetReservedFile(&argv[i][3]))
                                {
                                    printf("ERROR: Cannot open cabinet reserved area file.\n");
                                    return false;
                                }
                            }
                            break;
 
                        default:
                            printf("ERROR: Bad parameter %s.\n", argv[i]);
                            return false;
                    }
                    break;
 
                case 's':
                case 'S':
                    Mode = CM_MODE_CREATE_SIMPLE;
                    break;
 
                case 'P':
                    if (argv[i][2] == 0)
                    {
                        i++;
                        SetFileRelativePath(&argv[i][0]);
                    }
                    else
                        SetFileRelativePath(&argv[i][2]);
 
                    break;
 
                case 'V':
                    Verbose = true;
                    break;
 
                default:
                    printf("ERROR: Bad parameter %s.\n", argv[i]);
                    return false;
            }
        }
        else
        {
            if(Mode == CM_MODE_CREATE)
            {
                if(FileName[0])
                {
                    printf("ERROR: You may only specify one directive file!\n");
                    return false;
                }
                else
                {
                    // For creating cabinets, this argument is the path to the directive file
                    strcpy(FileName, argv[i]);
                }
            }
            else if(FoundCabinet)
            {
                // For creating simple cabinets, displaying or extracting them, add the argument as a search criteria
                AddSearchCriteria(argv[i], NextFolder);
                NextFolder.clear();
            }
            else
            {
                SetCabinetName(argv[i]);
                FoundCabinet = true;
            }
        }
    }
 
    if (ShowUsage)
    {
        Usage();
        return false;
    }
 
    // Select MsZip by default for creating cabinets
    if( (Mode == CM_MODE_CREATE || Mode == CM_MODE_CREATE_SIMPLE) && !IsCodecSelected() )
        SelectCodec(CAB_CODEC_MSZIP);
 
    // Search criteria (= the filename argument) is necessary for creating a simple cabinet
    if( Mode == CM_MODE_CREATE_SIMPLE && !HasSearchCriteria())
    {
        printf("ERROR: You have to enter input file names!\n");
        return false;
    }
 
    return true;
}

Referenced by main().

Run()

bool CCABManager::Run

(

)

Definition at line 573 of file cabman.cxx.

{
    if (Verbose)
    {
        printf("ReactOS Cabinet Manager\n\n");
    }
 
    switch (Mode)
    {
        case CM_MODE_CREATE:
            return CreateCabinet();
 
        case CM_MODE_DISPLAY:
            return DisplayCabinet();
 
        case CM_MODE_EXTRACT:
            return ExtractFromCabinet();
 
        case CM_MODE_CREATE_SIMPLE:
            return CreateSimpleCabinet();
 
        default:
            break;
    }
    return false;
}

Referenced by main().

Usage()

void CCABManager::Usage ( )

private

Definition at line 188 of file cabman.cxx.

{
    printf("ReactOS Cabinet Manager\n\n");
    printf("CABMAN [-D | -E] [-A] [-L dir] cabinet [filename ...]\n");
    printf("CABMAN [-M mode] -C dirfile [-I] [-RC file] [-P dir]\n");
    printf("CABMAN [-M mode] -S cabinet filename [-F folder] [filename] [...]\n");
    printf("  cabinet   Cabinet file.\n");
    printf("  filename  Name of the file to add to or extract from the cabinet.\n");
    printf("            Wild cards and multiple filenames\n");
    printf("            (separated by blanks) may be used.\n\n");
 
    printf("  dirfile   Name of the directive file to use.\n");
 
    printf("  -A        Process ALL cabinets. Follows cabinet chain\n");
    printf("            starting in first cabinet mentioned.\n");
    printf("  -C        Create cabinet.\n");
    printf("  -D        Display cabinet directory.\n");
    printf("  -E        Extract files from cabinet.\n");
    printf("  -F        Put the files from the next 'filename' filter in the cab in folder\filename.\n");
    printf("  -I        Don't create the cabinet, only the .inf file.\n");
    printf("  -L dir    Location to place extracted or generated files\n");
    printf("            (default is current directory).\n");
    printf("  -M mode   Specify the compression method to use:\n");
    printf("               raw    - No compression\n");
    printf("               mszip  - MsZip compression (default)\n");
    printf("  -N        Don't create the .inf file, only the cabinet.\n");
    printf("  -RC       Specify file to put in cabinet reserved area\n");
    printf("            (size must be less than 64KB).\n");
    printf("  -S        Create simple cabinet.\n");
    printf("  -P dir    Files in the .dff are relative to this directory.\n");
    printf("  -V        Verbose mode (prints more messages).\n");
}

Referenced by ParseCmdline().

Member Data Documentation

FileName

char CCABManager::FileName[PATH_MAX]

private

Definition at line 46 of file cabman.h.

Mode

ULONG CCABManager::Mode

private

Definition at line 44 of file cabman.h.

Referenced by CCABManager(), OnOverwrite(), ParseCmdline(), and Run().

ProcessAll

bool CCABManager::ProcessAll

private

Definition at line 43 of file cabman.h.

Referenced by CCABManager(), and ParseCmdline().

PromptOnOverwrite

bool CCABManager::PromptOnOverwrite

private

Definition at line 45 of file cabman.h.

Verbose

bool CCABManager::Verbose

private

Definition at line 47 of file cabman.h.

Referenced by CCABManager(), DisplayCabinet(), ExtractFromCabinet(), IsVerbose(), OnAdd(), OnDiskChange(), OnExtract(), OnVerboseMessage(), ParseCmdline(), and Run().

---

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

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