// CkTar.h: interface for the CkTar class. // ////////////////////////////////////////////////////////////////////// // This header is generated for Chilkat 11.3.0 #define _CkVersion 11.3.0 #ifndef _CkTar_H #define _CkTar_H #include "chilkatDefs.h" #include "CkString.h" #include "CkClassWithCallbacks.h" class CkTask; class CkBinData; class CkByteData; class CkTarProgress; #if !defined(__sun__) && !defined(__sun) #pragma pack (push, 8) #endif #undef Copy // CLASS: CkTar class CK_VISIBLE_PUBLIC CkTar : public CkClassWithCallbacks { private: // Don't allow assignment or copying these objects. CkTar(const CkTar &); CkTar &operator=(const CkTar &); public: CkTar(void); virtual ~CkTar(void); static CkTar *createNew(void); static CkTar *createNew2(int progLang); void CK_VISIBLE_PRIVATE inject(void *impl); // May be called when finished with the object to free/dispose of any // internal resources held by the object. void dispose(void); CkTarProgress *get_EventCallbackObject(void) const; void put_EventCallbackObject(CkTarProgress *progress); // BEGIN PUBLIC INTERFACE // ---------------------- // Properties // ---------------------- // If true, then untar methods, such as Untar, UntarGz, UntarBz2, and UntarZ, // will also capture an XML listing of the contents in the XmlListing property. The // format of the XML contained in XmlListing is identical to what is returned by // the ListXml method. The default value is false. bool get_CaptureXmlListing(void); // If true, then untar methods, such as Untar, UntarGz, UntarBz2, and UntarZ, // will also capture an XML listing of the contents in the XmlListing property. The // format of the XML contained in XmlListing is identical to what is returned by // the ListXml method. The default value is false. void put_CaptureXmlListing(bool newVal); // Character encoding to be used when interpreting filenames within .tar archives // for untar operations. The default is utf-8 , and this is typically not changed. // (The WriteTar methods always uses utf-8 to store filenames within the TAR // archive.) void get_Charset(CkString &str); // Character encoding to be used when interpreting filenames within .tar archives // for untar operations. The default is utf-8 , and this is typically not changed. // (The WriteTar methods always uses utf-8 to store filenames within the TAR // archive.) const char *charset(void); // Character encoding to be used when interpreting filenames within .tar archives // for untar operations. The default is utf-8 , and this is typically not changed. // (The WriteTar methods always uses utf-8 to store filenames within the TAR // archive.) void put_Charset(const char *newVal); // The directory permissions to used in WriteTar* methods. The default is octal // 0755. This is the value to be stored in the mode field of each TAR header for a // directory entries. int get_DirMode(void); // The directory permissions to used in WriteTar* methods. The default is octal // 0755. This is the value to be stored in the mode field of each TAR header for a // directory entries. void put_DirMode(int newVal); // A prefix to be added to each file's path within the TAR archive as it is being // created. For example, if this property is set to the string subdir1 , then // subdir1/ will be prepended to each file's path within the TAR. // // Note: This property does not apply to files added using the AddFile2 method, // which directly specifies the path-in-tar. // void get_DirPrefix(CkString &str); // A prefix to be added to each file's path within the TAR archive as it is being // created. For example, if this property is set to the string subdir1 , then // subdir1/ will be prepended to each file's path within the TAR. // // Note: This property does not apply to files added using the AddFile2 method, // which directly specifies the path-in-tar. // const char *dirPrefix(void); // A prefix to be added to each file's path within the TAR archive as it is being // created. For example, if this property is set to the string subdir1 , then // subdir1/ will be prepended to each file's path within the TAR. // // Note: This property does not apply to files added using the AddFile2 method, // which directly specifies the path-in-tar. // void put_DirPrefix(const char *newVal); // The file permissions to used in WriteTar* methods. The default is octal 0644. // This is the value to be stored in the mode field of each TAR header for a file // entries. int get_FileMode(void); // The file permissions to used in WriteTar* methods. The default is octal 0644. // This is the value to be stored in the mode field of each TAR header for a file // entries. void put_FileMode(int newVal); // The default numerical GID to be stored in each TAR header when writing TAR // archives. The default value is 1000. int get_GroupId(void); // The default numerical GID to be stored in each TAR header when writing TAR // archives. The default value is 1000. void put_GroupId(int newVal); // The default group name to be stored in each TAR header when writing TAR // archives. The default value is the logged-on username of the application's // process. void get_GroupName(CkString &str); // The default group name to be stored in each TAR header when writing TAR // archives. The default value is the logged-on username of the application's // process. const char *groupName(void); // The default group name to be stored in each TAR header when writing TAR // archives. The default value is the logged-on username of the application's // process. void put_GroupName(const char *newVal); // The interval in milliseconds between each AbortCheck event callback, which // enables an application to abort certain method calls before they complete. By // default, HeartbeatMs is set to 0 , meaning no AbortCheck event callbacks will // trigger. // // References: // 1: #AbortCheck int get_HeartbeatMs(void); // The interval in milliseconds between each AbortCheck event callback, which // enables an application to abort certain method calls before they complete. By // default, HeartbeatMs is set to 0 , meaning no AbortCheck event callbacks will // trigger. // // References: // 1: #AbortCheck void put_HeartbeatMs(int newVal); // Determines whether pattern matching for the MustMatch and MustNotMatch // properties is case-sensitive or not. The default value is false. bool get_MatchCaseSensitive(void); // Determines whether pattern matching for the MustMatch and MustNotMatch // properties is case-sensitive or not. The default value is false. void put_MatchCaseSensitive(bool newVal); // If set, then file paths must match this pattern when creating TAR archives, or // when extracting from TAR archives. If a file does not match, it will not be // included when creating a TAR, or it will not be extracted when extracting from a // TAR. This property also applies to methods that create or extract from // compressed TAR archives. // // The must-match pattern may include 0 or more asterisk characters, each of which // represents 0 or more of any character. For example, the pattern *.txt causes // only .txt files to be included or extracted. The default value is an empty // string, indicating that all files are implicitly matched. // void get_MustMatch(CkString &str); // If set, then file paths must match this pattern when creating TAR archives, or // when extracting from TAR archives. If a file does not match, it will not be // included when creating a TAR, or it will not be extracted when extracting from a // TAR. This property also applies to methods that create or extract from // compressed TAR archives. // // The must-match pattern may include 0 or more asterisk characters, each of which // represents 0 or more of any character. For example, the pattern *.txt causes // only .txt files to be included or extracted. The default value is an empty // string, indicating that all files are implicitly matched. // const char *mustMatch(void); // If set, then file paths must match this pattern when creating TAR archives, or // when extracting from TAR archives. If a file does not match, it will not be // included when creating a TAR, or it will not be extracted when extracting from a // TAR. This property also applies to methods that create or extract from // compressed TAR archives. // // The must-match pattern may include 0 or more asterisk characters, each of which // represents 0 or more of any character. For example, the pattern *.txt causes // only .txt files to be included or extracted. The default value is an empty // string, indicating that all files are implicitly matched. // void put_MustMatch(const char *newVal); // If set, then file paths must NOT match this pattern when creating TAR archives, // or when extracting from TAR archives. If a file path matches, it will not be // included when creating a TAR, or it will not be extracted when extracting from a // TAR. This property also applies to methods that create or extract from // compressed TAR archives. // // The must-not-match pattern may include 0 or more asterisk characters, each of // which represents 0 or more of any character. For example, the pattern *.obj // causes all .obj files to be skipped. The default value is an empty string, // indicating that no files are skipped. // void get_MustNotMatch(CkString &str); // If set, then file paths must NOT match this pattern when creating TAR archives, // or when extracting from TAR archives. If a file path matches, it will not be // included when creating a TAR, or it will not be extracted when extracting from a // TAR. This property also applies to methods that create or extract from // compressed TAR archives. // // The must-not-match pattern may include 0 or more asterisk characters, each of // which represents 0 or more of any character. For example, the pattern *.obj // causes all .obj files to be skipped. The default value is an empty string, // indicating that no files are skipped. // const char *mustNotMatch(void); // If set, then file paths must NOT match this pattern when creating TAR archives, // or when extracting from TAR archives. If a file path matches, it will not be // included when creating a TAR, or it will not be extracted when extracting from a // TAR. This property also applies to methods that create or extract from // compressed TAR archives. // // The must-not-match pattern may include 0 or more asterisk characters, each of // which represents 0 or more of any character. For example, the pattern *.obj // causes all .obj files to be skipped. The default value is an empty string, // indicating that no files are skipped. // void put_MustNotMatch(const char *newVal); // If true, then absolute paths are converted to relative paths by removing the // leading / or \ character when untarring. This protects your system from // unknowingly untarring files into important system directories, such as // C:\Windows\system32. The default value is true. bool get_NoAbsolutePaths(void); // If true, then absolute paths are converted to relative paths by removing the // leading / or \ character when untarring. This protects your system from // unknowingly untarring files into important system directories, such as // C:\Windows\system32. The default value is true. void put_NoAbsolutePaths(bool newVal); // The total number of directory roots set by calling AddDirRoot (i.e. the number // of times AddDirRoot was called by the application). A TAR archive is created by // calling AddDirRoot for one or more directory tree roots, followed by a single // call to WriteTar (or WriteTarBz2, WriteTarGz, WriteTarZ). This allows for TAR // archives containing multiple directory trees to be created. int get_NumDirRoots(void); // This property is only valid in programming environment and languages that allow // for event callbacks. // // Sets the value to be defined as 100% complete for the purpose of PercentDone // event callbacks. The defaut value of 100 means that at most 100 event // PercentDone callbacks will occur in a method that (1) is event enabled and (2) // is such that it is possible to measure progress as a percentage completed. This // property may be set to larger numbers to get more fine-grained PercentDone // callbacks. For example, setting this property equal to 1000 will provide // callbacks with .1 percent granularity. For example, a value of 453 would // indicate 45.3% competed. This property is clamped to a minimum value of 10, and // a maximum value of 100000. // int get_PercentDoneScale(void); // This property is only valid in programming environment and languages that allow // for event callbacks. // // Sets the value to be defined as 100% complete for the purpose of PercentDone // event callbacks. The defaut value of 100 means that at most 100 event // PercentDone callbacks will occur in a method that (1) is event enabled and (2) // is such that it is possible to measure progress as a percentage completed. This // property may be set to larger numbers to get more fine-grained PercentDone // callbacks. For example, setting this property equal to 1000 will provide // callbacks with .1 percent granularity. For example, a value of 453 would // indicate 45.3% competed. This property is clamped to a minimum value of 10, and // a maximum value of 100000. // void put_PercentDoneScale(int newVal); // The file permissions to used in WriteTar* methods for shell script files (.sh, // .csh, .bash, .bsh). The default is octal 0755. This is the value to be stored in // the mode field of each TAR header for a file entries. int get_ScriptFileMode(void); // The file permissions to used in WriteTar* methods for shell script files (.sh, // .csh, .bash, .bsh). The default is octal 0755. This is the value to be stored in // the mode field of each TAR header for a file entries. void put_ScriptFileMode(int newVal); // If true, then untar methods, such as Untar, UntarGz, UntarBz2, and UntarZ, do // not produce any output. Setting this value equal to true is useful when the // CaptureXmlListing is also set to true, which enables an application to get the // contents of a TAR archive without extracting. The default value is false. bool get_SuppressOutput(void); // If true, then untar methods, such as Untar, UntarGz, UntarBz2, and UntarZ, do // not produce any output. Setting this value equal to true is useful when the // CaptureXmlListing is also set to true, which enables an application to get the // contents of a TAR archive without extracting. The default value is false. void put_SuppressOutput(bool newVal); // This property is deprecated. Applications should instead use the // MatchCaseSensitive property. Until this property is officially removed, it will // behave the same as the MatchCaseSensitive property. bool get_UntarCaseSensitive(void); // This property is deprecated. Applications should instead use the // MatchCaseSensitive property. Until this property is officially removed, it will // behave the same as the MatchCaseSensitive property. void put_UntarCaseSensitive(bool newVal); // Similar to the VerboseLogging property. If set to true, then information about // each file/directory extracted in an untar method call is logged to LastErrorText // (or LastErrorXml / LastErrorHtml). The default value is false. bool get_UntarDebugLog(void); // Similar to the VerboseLogging property. If set to true, then information about // each file/directory extracted in an untar method call is logged to LastErrorText // (or LastErrorXml / LastErrorHtml). The default value is false. void put_UntarDebugLog(bool newVal); // If true, then discard all path information when untarring. This causes all // files to be untarred into a single directory. The default value is false. bool get_UntarDiscardPaths(void); // If true, then discard all path information when untarring. This causes all // files to be untarred into a single directory. The default value is false. void put_UntarDiscardPaths(bool newVal); // The directory path where files are extracted when untarring. The default value // is . , meaning that the current working directory of the calling process is // used. If UntarDiscardPaths is set, then all files are untarred into this // directory. Otherwise, the untar operation will re-create a directory tree rooted // in this directory. void get_UntarFromDir(CkString &str); // The directory path where files are extracted when untarring. The default value // is . , meaning that the current working directory of the calling process is // used. If UntarDiscardPaths is set, then all files are untarred into this // directory. Otherwise, the untar operation will re-create a directory tree rooted // in this directory. const char *untarFromDir(void); // The directory path where files are extracted when untarring. The default value // is . , meaning that the current working directory of the calling process is // used. If UntarDiscardPaths is set, then all files are untarred into this // directory. Otherwise, the untar operation will re-create a directory tree rooted // in this directory. void put_UntarFromDir(const char *newVal); // Limits the number of files extracted during an untar to this count. The default // value is 0 to indicate no maximum. To untar a single file, one might set the // UntarMatchPattern such that it will match only the file to be extracted, and // also set UntarMaxCount equal to 1. This causes an untar to scan the TAR archive // until it finds the matching file, extract it, and then return. int get_UntarMaxCount(void); // Limits the number of files extracted during an untar to this count. The default // value is 0 to indicate no maximum. To untar a single file, one might set the // UntarMatchPattern such that it will match only the file to be extracted, and // also set UntarMaxCount equal to 1. This causes an untar to scan the TAR archive // until it finds the matching file, extract it, and then return. void put_UntarMaxCount(int newVal); // The default numerical UID to be stored in each TAR header when writing TAR // archives. The default value is 1000. int get_UserId(void); // The default numerical UID to be stored in each TAR header when writing TAR // archives. The default value is 1000. void put_UserId(int newVal); // The default user name to be stored in each TAR header when writing TAR archives. // The default value is the logged-on username of the application's process. void get_UserName(CkString &str); // The default user name to be stored in each TAR header when writing TAR archives. // The default value is the logged-on username of the application's process. const char *userName(void); // The default user name to be stored in each TAR header when writing TAR archives. // The default value is the logged-on username of the application's process. void put_UserName(const char *newVal); // The TAR format to use when writing a TAR archive. Valid values are gnu , pax , // and ustar . The default value is gnu . void get_WriteFormat(CkString &str); // The TAR format to use when writing a TAR archive. Valid values are gnu , pax , // and ustar . The default value is gnu . const char *writeFormat(void); // The TAR format to use when writing a TAR archive. Valid values are gnu , pax , // and ustar . The default value is gnu . void put_WriteFormat(const char *newVal); // Contains the XML listing of the contents of the TAR archive for the last untar // method call (such as Untar, UntarGz, etc.) where the CaptureXmlListing property // was set to true. void get_XmlListing(CkString &str); // Contains the XML listing of the contents of the TAR archive for the last untar // method call (such as Untar, UntarGz, etc.) where the CaptureXmlListing property // was set to true. const char *xmlListing(void); // Contains the XML listing of the contents of the TAR archive for the last untar // method call (such as Untar, UntarGz, etc.) where the CaptureXmlListing property // was set to true. void put_XmlListing(const char *newVal); // ---------------------- // Methods // ---------------------- // Adds a directory tree to be included in the next call to one of the WriteTar* // methods. To include multiple directory trees in a .tar, call AddDirRoot multiple // times followed by a single call to WriteTar. bool AddDirRoot(const char *dirPath); // Adds a directory tree to be included in the next call to one of the WriteTar* // methods. To include multiple directory trees in a .tar, call AddDirRoot2 (and/or // AddDirRoot) multiple times followed by a single call to WriteTar. // // The rootPrefix adds a prefix to the path in the TAR for all files added under this // root. The rootPrefix should not end with a forward-slash char. For example: This is // good: abc/123 , but this is not good: abc/123/ . If the DirPrefix property is // also set, its prefix will added first. // bool AddDirRoot2(const char *rootPrefix, const char *rootPath); // Adds a local file to be included in the next call to one of the WriteTar* // methods. To include multiple files or directory trees in a .tar, call // AddFile/AddDirRoot multiple times followed by a single call to WriteTar (or // WriteTarGz, or WriteTarBz2). bool AddFile(const char *path); // Adds a local file to be included in the next call to one of the WriteTar* // methods. Allows for the path within the TAR to be specified. To include multiple // files or directory trees in a .tar, call AddFile/AddFile2/AddDirRoot multiple // times followed by a single call to WriteTar (or WriteTarGz, or WriteTarBz2). // // Note: The DirPrefix property does not apply to files added via this method // because this method explicilty specifies the path-in-tar. // bool AddFile2(const char *filePath, const char *pathWithinTar); // Clears all directory roots and files previously added by calls to AddDirRoot, // AddDirRoot2, AddFile, and AddFile2. bool ClearDirRootsAndFiles(void); // Creates a .deb Debian binary package archive from a control.tar.gz and // data.tar.gz. The controlPath is the path to the control.tar.gz file (or equivalent), // and the dataPath is the path to the data.tar.gz file. The output file path (.deb) is // specified in debPath. bool CreateDeb(const char *controlPath, const char *dataPath, const char *debPath); // Returns the value of the Nth directory root. For example, if an application // calls AddDirRoot twice, then the NumDirRoots property would have a value of 2, // and GetDirRoot(0) would return the path passed to AddDirRoot in the 1st call, // and GetDirRoot(1) would return the directory path in the 2nd call to AddDirRoot. bool GetDirRoot(int index, CkString &outStr); // Returns the value of the Nth directory root. For example, if an application // calls AddDirRoot twice, then the NumDirRoots property would have a value of 2, // and GetDirRoot(0) would return the path passed to AddDirRoot in the 1st call, // and GetDirRoot(1) would return the directory path in the 2nd call to AddDirRoot. const char *getDirRoot(int index); // Returns the value of the Nth directory root. For example, if an application // calls AddDirRoot twice, then the NumDirRoots property would have a value of 2, // and GetDirRoot(0) would return the path passed to AddDirRoot in the 1st call, // and GetDirRoot(1) would return the directory path in the 2nd call to AddDirRoot. const char *dirRoot(int index); // Scans a TAR archive and returns XML detailing the files and directories found // within the TAR. bool ListXml(const char *tarPath, CkString &outStr); // Scans a TAR archive and returns XML detailing the files and directories found // within the TAR. const char *listXml(const char *tarPath); // Scans a TAR archive and returns XML detailing the files and directories found // within the TAR. CkTask *ListXmlAsync(const char *tarPath); // Loads the caller of the task's async method. bool LoadTaskCaller(CkTask &task); // Extracts the files and directories from a TAR archive, reconstructing the // directory tree(s) in the local filesystem. The files are extracted to the // directory specified by the UntarFromDir property. Returns the number of files // and directories extracted, or -1 for failure. int Untar(const char *tarPath); // Extracts the files and directories from a TAR archive, reconstructing the // directory tree(s) in the local filesystem. The files are extracted to the // directory specified by the UntarFromDir property. Returns the number of files // and directories extracted, or -1 for failure. CkTask *UntarAsync(const char *tarPath); // Extracts the files and directories from a tar.bz2 (or tar.bzip2) archive, // reconstructing the directory tree(s) in the local filesystem. The files are // extracted to the directory specified by the UntarFromDir property. bool UntarBz2(const char *tarPath); // Extracts the files and directories from a tar.bz2 (or tar.bzip2) archive, // reconstructing the directory tree(s) in the local filesystem. The files are // extracted to the directory specified by the UntarFromDir property. CkTask *UntarBz2Async(const char *tarPath); // Untars the first file matching the matchPattern into bd. bool UntarFirstMatchingToBd(const char *tarPath, const char *matchPattern, CkBinData &bd); // Memory-to-memory untar. The first file matching the matchPattern is extracted and // returned. bool UntarFirstMatchingToMemory(CkByteData &tarFileBytes, const char *matchPattern, CkByteData &outBytes); // Extracts the files and directories from an in-memory TAR archive, reconstructing // the directory tree(s) in the local filesystem. The files are extracted to the // directory specified by the UntarFromDir property. Returns the number of files // and directories extracted, or -1 for failure. int UntarFromMemory(CkByteData &tarFileBytes); // Extracts the files and directories from an in-memory TAR archive, reconstructing // the directory tree(s) in the local filesystem. The files are extracted to the // directory specified by the UntarFromDir property. Returns the number of files // and directories extracted, or -1 for failure. CkTask *UntarFromMemoryAsync(CkByteData &tarFileBytes); // Extracts the files and directories from a tar.gz (or tar.gzip) archive, // reconstructing the directory tree(s) in the local filesystem. The files are // extracted to the directory specified by the UntarFromDir property. bool UntarGz(const char *tarPath); // Extracts the files and directories from a tar.gz (or tar.gzip) archive, // reconstructing the directory tree(s) in the local filesystem. The files are // extracted to the directory specified by the UntarFromDir property. CkTask *UntarGzAsync(const char *tarPath); // Extracts the files and directories from a tar.Z archive, reconstructing the // directory tree(s) in the local filesystem. The files are extracted to the // directory specified by the UntarFromDir property. bool UntarZ(const char *tarPath); // Extracts the files and directories from a tar.Z archive, reconstructing the // directory tree(s) in the local filesystem. The files are extracted to the // directory specified by the UntarFromDir property. CkTask *UntarZAsync(const char *tarPath); // Verifies that a TAR archive is valid. This method opens the TAR archive and // scans the entire file by walking the TAR headers. Returns true if no errors // were found. Otherwise returns false. bool VerifyTar(const char *tarPath); // Verifies that a TAR archive is valid. This method opens the TAR archive and // scans the entire file by walking the TAR headers. Returns true if no errors // were found. Otherwise returns false. CkTask *VerifyTarAsync(const char *tarPath); // Writes a TAR archive. The directory trees previously added by calling AddDirRoot // one or more times are included in the output TAR archive. bool WriteTar(const char *tarPath); // Writes a TAR archive. The directory trees previously added by calling AddDirRoot // one or more times are included in the output TAR archive. CkTask *WriteTarAsync(const char *tarPath); // Writes a .tar.bz2 compressed TAR archive. The directory trees previously added // by calling AddDirRoot one or more times are included in the output file. bool WriteTarBz2(const char *bz2Path); // Writes a .tar.bz2 compressed TAR archive. The directory trees previously added // by calling AddDirRoot one or more times are included in the output file. CkTask *WriteTarBz2Async(const char *bz2Path); // Writes a .tar.gz (also known as .tgz) compressed TAR archive. The directory // trees previously added by calling AddDirRoot one or more times are included in // the output file. bool WriteTarGz(const char *gzPath); // Writes a .tar.gz (also known as .tgz) compressed TAR archive. The directory // trees previously added by calling AddDirRoot one or more times are included in // the output file. CkTask *WriteTarGzAsync(const char *gzPath); // END PUBLIC INTERFACE }; #if !defined(__sun__) && !defined(__sun) #pragma pack (pop) #endif #endif