Chip 2002 March

home *** CD-ROM | disk | FTP | other *** search

/ Chip 2002 March / Chip_2002-03_cd1.bin / zkuste / delphi / kompon / d5 / cak / CAKDIR.ZIP / UNACEV2.PAS < prev next >

Wrap

Pascal/Delphi Source File | 2001-05-20 | 97.9 KB | 2,188 lines

//////////////////////////////////////////////////////////////////////// // UnAceV2.pas v1.00 // // Date created: 2001-02-24 // Author: nikse@post11.tele.dk unit UnAceV2; interface uses Windows, SysUtils; //////////////////////////////////////////////////////////////////////// // Functions to be called from user program function LoadAceDll(unpackdllpath : string) : Boolean; procedure UnLoadAceDll; function CallACEList(ArchiveName : string) : integer; function CallACETest(ArchiveName : string) : integer; function CallACEExtract(ArchiveName : string; DestinationDir : string; DecryptPassword : string; DoExcludePath : LongBool) : integer; //////////////////////////////////////////////////////////////////////// // ACE constants //////////////////////////////////////////////////////////////////////// const // Constants for the tACECommentStruc.State field, which tells about // the result of the last comment extraction. ACE_COMMENT_OK = 0; // comment extraction went fine ACE_COMMENT_SMALLBUF = 1; // comment buffer too small to // store the whole comment in ACE_COMMENT_NONE = 255; // No comment present // Flag constants for tACEArchiveDataStruc.Flags field. ACE_ARCFLAG_MAINCOMMENT = 2; ACE_ARCFLAG_SFX = 512; ACE_ARCFLAG_LIMITSFXJR = 1024; // is an SFX archive // that supports 256k // dictionary only ACE_ARCFLAG_MULTIVOLUME = 2048; ACE_ARCFLAG_AV = 4096; // not used in ACL ACE_ARCFLAG_RECOVERYREC = 8192; ACE_ARCFLAG_LOCK = 16384; ACE_ARCFLAG_SOLID = 32768; // Host system used to create an archive. Used at // tACEArchiveDataStruc.HostCreated field. ACE_HOST_MSDOS = 0; // archive created by // MSDOS ACE archiver ACE_HOST_OS2 = 1; // created by OS2 ACE ACE_HOST_WIN32 = 2; // created by Win32 ACE // Flag constants for the tACEFileData.Flags field. ACE_FILEFLAG_FILECOMMENT = 2; // file has comment ACE_FILEFLAG_SPLITBEFORE = 4096; // continued from // previous volume ACE_FILEFLAG_SPLITAFTER = 8192; // continued on // next volume ACE_FILEFLAG_PASSWORD = 16384; // is encrypted ACE_FILEFLAG_SOLID = 32768; // uses data of previous // files (solid mode) // Tells the Dll which compression level to use. (ACE only) ACE_LEVEL_STORE = 0; // save file only; do not compress ACE_LEVEL_FASTEST = 1; // compress very fast ACE_LEVEL_FAST = 2; // compress fast ACE_LEVEL_NORMAL = 3; // good compromise between speed and // compression rate ACE_LEVEL_GOOD = 4; // achieves good compression ACE_LEVEL_BEST = 5; // best compression; bit slow //////////////////////////////////////////////////////////////////////// // Part 2.1: operation codes // // Passed to callback functions indicating the current operation. ACE_CALLBACK_OPERATION_LIST = 0; ACE_CALLBACK_OPERATION_TEST = 1; ACE_CALLBACK_OPERATION_ANALYZE = 2; ACE_CALLBACK_OPERATION_EXTRACT = 3; ACE_CALLBACK_OPERATION_ADD = 4; ACE_CALLBACK_OPERATION_REPACK = 5; ACE_CALLBACK_OPERATION_DELETE = 6; ACE_CALLBACK_OPERATION_REPAIR = 7; // repair without // recovery record ACE_CALLBACK_OPERATION_SETCMT = 8; ACE_CALLBACK_OPERATION_ENCRYPT = 9; ACE_CALLBACK_OPERATION_KEEP = 10; // file is to be // taken along // without recompress ACE_CALLBACK_OPERATION_RECOVER = 11; // begin of // recovering archive // by recovery record ACE_CALLBACK_OPERATION_HEADSEARCH = 12; // begin of searching // for file headers ACE_CALLBACK_OPERATION_RECRECSEARCH = 13; // begin of searching // for recovery record ACE_CALLBACK_OPERATION_ADDSFX = 14; ACE_CALLBACK_OPERATION_LOCK = 15; ACE_CALLBACK_OPERATION_ADDAV = 16; // not used in ACL ACE_CALLBACK_OPERATION_ADDRECOVREC = 17; ACE_CALLBACK_OPERATION_REGISTER = 18; // not used in ACL //////////////////////////////////////////////////////////////////////// // Part 2.2: callback function return codes // One of these result codes has to be returned by the application-based // callback functions. ACE_CALLBACK_RETURN_OK = 0; // also "yes" at // requests ACE_CALLBACK_RETURN_NO = 1; // no, do not/ // do not retry ACE_CALLBACK_RETURN_CANCEL = 2; // abort operation //////////////////////////////////////////////////////////////////////// // Part 2.3: callback structure types // States of which type the passed structure is when a callback function // is called. The type is written to the StructureType field. ACE_CALLBACK_TYPE_GLOBAL = 0; // type of structure is // tACECallbackGlobalStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // InfoCallbackProc | ACE_CALLBACK_INFO_GENERALKEY // not used in ACL // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // ErrorCallbackProc | ACE_CALLBACK_ERROR_MEMORY // für ManyFilesError und ExtractMem andere Codes verwenden!? // | ACE_CALLBACK_ERROR_REGISTER // not used in ACL // | ACE_CALLBACK_ERROR_READKEY // not used in ACL // | ACE_CALLBACK_ERROR_WRITEKEY // not used in ACL // | ACE_CALLBACK_ERROR_NOWINACEKEY // not used in ACL // | ACE_CALLBACK_ERROR_NOACTIVEACEKEY // not used in ACL // | ACE_CALLBACK_ERROR_UNCSPACE // wird noch nicht verwendet! // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RequestCallbackProc | ACE_CALLBACK_REQUEST_REGISTER // not used in ACL // ACE_CALLBACK_TYPE_ARCHIVE = 1; // type of structure is // tACECallbackArchiveStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // InfoCallbackProc | ACE_CALLBACK_INFO_TMPARCCREATE // | ACE_CALLBACK_INFO_TMPARCCREATEEND // | ACE_CALLBACK_INFO_ADDRECREC // | ACE_CALLBACK_INFO_ADDRECRECEND // | ACE_CALLBACK_INFO_RECREC // | ACE_CALLBACK_INFO_NORECREC // | ACE_CALLBACK_INFO_RECOVERED // | ACE_CALLBACK_INFO_NODAMAGE // | ACE_CALLBACK_INFO_FNDMAINHEAD // | ACE_CALLBACK_INFO_FILELISTCREATE // | ACE_CALLBACK_INFO_FILELISTCREATEEND // | ACE_CALLBACK_INFO_FILESORT // | ACE_CALLBACK_INFO_FILESORTEND // | ACE_CALLBACK_INFO_COPYEND // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // ErrorCallbackProc | ACE_CALLBACK_ERROR_MODIFYVOLUME // | ACE_CALLBACK_ERROR_MODIFYLOCKEDARCHIVE // | ACE_CALLBACK_ERROR_AV // not used in ACL // | ACE_CALLBACK_ERROR_TOODAMAGED // | ACE_CALLBACK_ERROR_ARCHIVEEXISTS // | ACE_CALLBACK_ERROR_OPENREPAIRARCHIVE // | ACE_CALLBACK_ERROR_OPENARCHIVEREAD // | ACE_CALLBACK_ERROR_OPENARCHIVEWRITE // | ACE_CALLBACK_ERROR_READARCHIVE // | ACE_CALLBACK_ERROR_WRITEARCHIVE // | ACE_CALLBACK_ERROR_ALREADYSFX // | ACE_CALLBACK_ERROR_ADDSFXTOVOLUME // | ACE_CALLBACK_ERROR_ARCHIVEBROKEN // | ACE_CALLBACK_ERROR_ARCHIVESAVE // | ACE_CALLBACK_ERROR_NOFILES // | ACE_CALLBACK_ERROR_ISNOTANARCHIVE // | ACE_CALLBACK_ERROR_TEMPDIRCREATE // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RequestCallbackProc | ACE_CALLBACK_REQUEST_MARKASSOLID // | ACE_CALLBACK_REQUEST_CHANGEVOLUME // | ACE_CALLBACK_REQUEST_ARCHIVEEXISTS // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // StateCallbackProc | ACE_CALLBACK_STATE_STARTARCHIVE // ACE_CALLBACK_TYPE_ARCHIVEDFILE = 2; // type of structure is // tACECallbackArchivedFileStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // InfoCallbackProc | ACE_CALLBACK_INFO_TMPARCCREATE // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // ErrorCallbackProc | ACE_CALLBACK_ERROR_CREATIONNAMEINUSE // | ACE_CALLBACK_ERROR_HIGHERVERSION // | ACE_CALLBACK_ERROR_ENCRYPTIONCRC // | ACE_CALLBACK_ERROR_WRITE // | ACE_CALLBACK_ERROR_READ // | ACE_CALLBACK_ERROR_OPENREAD // | ACE_CALLBACK_ERROR_OPENWRITE //wird noch gar nich benutzt?? sollte aber - bei extract! // | ACE_CALLBACK_ERROR_FILENAMETOOLONG // | ACE_CALLBACK_ERROR_REPACKCRC // | ACE_CALLBACK_ERROR_EXCLUDEPATH // | ACE_CALLBACK_ERROR_METHOD // | ACE_CALLBACK_ERROR_EXTRACTSPACE // | ACE_CALLBACK_ERROR_CREATION // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RequestCallbackProc | ACE_CALLBACK_REQUEST_OVERWRITE // | ACE_CALLBACK_REQUEST_DELETEARCHIVEDSYSFILE // | ACE_CALLBACK_REQUEST_ADDBROKENFILE // | ACE_CALLBACK_REQUEST_PASSWORD // | ACE_CALLBACK_REQUEST_OVERWRITESYSFILE // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // StateCallbackProc | ACE_CALLBACK_STATE_STARTFILE // | ACE_CALLBACK_STATE_ENDNOCRCCHECK // ACE_CALLBACK_TYPE_REALFILE = 3; // type of structure is // tACECallbackRealFileStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // InfoCallbackProc | ACE_CALLBACK_INFO_FILELISTADD // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // ErrorCallbackProc | ACE_CALLBACK_ERROR_MOVEDELETE // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RequestCallbackProc | ACE_CALLBACK_REQUEST_MOVEDELETEREALSYSFILE // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // StateCallbackProc | ACE_CALLBACK_STATE_STARTFILE // ACE_CALLBACK_TYPE_SPACE = 4; // type of structure is // tACECallbackSpaceStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // ErrorCallbackProc | ACE_CALLBACK_ERROR_TEMPDIRSPACE // | ACE_CALLBACK_ERROR_ARCHIVESPACE // ACE_CALLBACK_TYPE_SFXFILE = 5; // type of structure is // tACECallbackSFXFileStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // ErrorCallbackProc | ACE_CALLBACK_ERROR_READINGSFXFILE // ACE_CALLBACK_TYPE_COPY = 6; // type of structure is // tACECallbackCopyStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // InfoCallbackProc | ACE_CALLBACK_INFO_COPY // ACE_CALLBACK_TYPE_PROGRESS = 7; // type of structure is // tACECallbackProgressStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // StateCallbackProc | ACE_CALLBACK_STATE_PROGRESS // ACE_CALLBACK_TYPE_CRCCHECK = 8; // type of structure is // tACECallbackCRCCheckStruc //------------------------------------------------------------- // callback function | codes using this structure // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- // StateCallbackProc | ACE_CALLBACK_STATE_ENDCRCCHECK // //----------------------------------------------------------------------- // These values are passed to the ACEInfoCallbackProc callback function // to inform the application about actions (smaller parts of operations) // which may take some time or other things that might be of interest. //----------------------------------------------------------------------- ACE_CALLBACK_INFO_GENERALKEY = $100; // key is a general one (no own AV; own key // is obtainable for a special price!?) // not used in ACL //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // ACERegister ACE_CALLBACK_INFO_TMPARCCREATE = $110; // creating temporary archive for changes //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACERepair ACE_CALLBACK_INFO_TMPARCCREATEEND = $111; // finished creating temporary archive //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACERepair ACE_CALLBACK_INFO_ADDRECREC = $112; // adding recovery record //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord // ACERepair ACE_CALLBACK_INFO_ADDRECRECEND = $113; // finished adding recovery record //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord // ACERepair ACE_CALLBACK_INFO_RECREC = $114; // trying to recover files by recovery // record; end indicated by // ACE_CALLBACK_INFO_RECOVERED or // ACE_CALLBACK_INFO_NODAMAGE //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_INFO_NORECREC = $115; // found no recovery record //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_INFO_RECOVERED = $116; // archive has been fully recovered //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_INFO_NODAMAGE = $117; // ACERepair detected by recovery record that // the archive is not damaged //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_INFO_FNDMAINHEAD = $118; // found archive header //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_INFO_FILELISTCREATE = $119; // creating a file list of specified files //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACESetComments // ACEEncryptFiles ACE_CALLBACK_INFO_FILELISTCREATEEND = $11a; // sent when creating the list of files // is finished //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACESetComments // ACEEncryptFiles ACE_CALLBACK_INFO_FILESORT = $11b; // sorting files (for solid compression) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd ACE_CALLBACK_INFO_FILESORTEND = $11c; // sorting files (for solid compression) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd ACE_CALLBACK_INFO_COPYEND = $11d; // copying a file finished //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACERepair ACE_CALLBACK_INFO_FILELISTADD = $140; // called at creation of file list; the name // of the file just added to file list is // passed in tACECallbackRealFileStruc //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_REALFILE // operations: // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACESetComments // ACEEncryptFiles ACE_CALLBACK_INFO_COPY = $150; // copying a file; file name, file size and // copied bytes are passed via // tACECallbackCopyStruc //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_COPY // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACERepair ACE_CALLBACK_ERROR_MEMORY = $200; // not enough memory to perform operation // (dictionary too large?) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // all ACE_CALLBACK_ERROR_REGISTER = $201; // registration key is invalid (or wrong // format?); not used in ACL //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // ACERegister ACE_CALLBACK_ERROR_READKEY = $202; // key could not be read (does not exist or // is invalid); not used in ACL //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // ACEInitDll ACE_CALLBACK_ERROR_WRITEKEY = $203; // could not write key; not used in ACL //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // ACERegister ACE_CALLBACK_ERROR_NOWINACEKEY = $204; // key not valid for WinACE; not used in ACL //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // ACERegister ACE_CALLBACK_ERROR_NOACTIVEACEKEY = $205; // key not valid for ActiveACE; not used in ACL //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // ACERegister ACE_CALLBACK_ERROR_UNCSPACE = $206; // Win95_OSR1-bug: it is impossible to // get available space of network drives by // an UNC name; ACE will not stop but // assumes there are 4Gb free // --> the operation might fail if free // disk space is low //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // all ACE_CALLBACK_ERROR_MODIFYVOLUME = $220; // modification of volumes not possible //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord ACE_CALLBACK_ERROR_MODIFYLOCKEDARCHIVE = $221; // modification of locked archive not possible //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord ACE_CALLBACK_ERROR_AV = $222; // AV of archive is NOT ok or does not match // to the users AV (not used in ACL) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEReadArchiveData // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACERepair // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACEAddAV // ACELock // ACEAddRecoveryRecord ACE_CALLBACK_ERROR_TOODAMAGED = $223; // can not repair by recovery record but // can continue with normal repair //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_ERROR_ARCHIVEEXISTS = $224; // destination file name already used; // may occur if at // ACE_CALLBACK_ERROR_ARCHIVESPACE a // direcory is specified where a file // with the same name as the current archive // already exists //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd ACE_CALLBACK_ERROR_OPENREPAIRARCHIVE = $225; // could not create archive for repairing //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_ERROR_OPENARCHIVEREAD = $226; // could not open archive/volume for reading //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEReadArchiveData // ACEList // ACETest // ACEExtract // ACERepair ACE_CALLBACK_ERROR_OPENARCHIVEWRITE = $227; // could not open archive/volume for writing //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEDelete // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord // ACERepair ACE_CALLBACK_ERROR_READARCHIVE = $228; // error reading from archive // (source disk removed?) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEReadArchiveData // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACERepair // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACEAddAV // ACELock // ACEAddRecoveryRecord ACE_CALLBACK_ERROR_WRITEARCHIVE = $229; // error writing to archive // (destination disk removed?) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEDelete // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord // ACERepair ACE_CALLBACK_ERROR_ALREADYSFX = $22a; // ca not make to SFX: is already SFX //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAddSFX ACE_CALLBACK_ERROR_ADDSFXTOVOLUME = $22b; // adding SFX to volumes not possible //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAddSFX ACE_CALLBACK_ERROR_ARCHIVEBROKEN = $22c; // archive is broken (damaged) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEReadArchiveData // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACERepair // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACEAddAV // ACELock // ACEAddRecoveryRecord ACE_CALLBACK_ERROR_ARCHIVESAVE = $22d; // not enough space to save archive; // but normally // ACE_CALLBACK_ERROR_ARCHIVESPACE // should allow to change destination //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord // ACERepair ACE_CALLBACK_ERROR_NOFILES = $22e; // no files specified/could not find files //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACESetComments // ACEEncryptFiles ACE_CALLBACK_ERROR_ISNOTANARCHIVE = $22f; // specified archive file is not an // ACE archive //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEReadArchiveData // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACERepair // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACEAddAV // ACELock // ACEAddRecoveryRecord ACE_CALLBACK_ERROR_TEMPDIRCREATE = $230; // could not create file in temp directory // (write protected or directory does // not exist) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord // ACERepair ACE_CALLBACK_ERROR_HIGHERVERSION = $231; // this Dll version is not able to handle // the archive //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord ACE_CALLBACK_ERROR_CREATIONNAMEINUSE = $240; // name used by directory //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEExtract ACE_CALLBACK_ERROR_ENCRYPTIONCRC = $242; // encryption failed because of CRC-Error at // decompression //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEEncryptFiles ACE_CALLBACK_ERROR_READ = $243; // error reading file to be added // (source disk removed?) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEAdd ACE_CALLBACK_ERROR_WRITE = $244; // error at extraction // (destination disk removed?) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEExtract ACE_CALLBACK_ERROR_OPENREAD = $245; // error opening file for reading //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEAdd ACE_CALLBACK_ERROR_OPENWRITE = $246; // error opening file for writing //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEExtract ACE_CALLBACK_ERROR_FILENAMETOOLONG = $247; // resulting file name too long //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEAdd ACE_CALLBACK_ERROR_REPACKCRC = $248; // CRC-check error at recompression // (archive broken or wrong password) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEDelete // ACEAdd ACE_CALLBACK_ERROR_EXCLUDEPATH = $249; // could not exclude path of file names; two // or more files would have the same name //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEAdd ACE_CALLBACK_ERROR_METHOD = $24a; // compression method not known to this // Dll version //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEDelete // ACETest // ACEExtract // ACEAdd // ACEEncryptFiles ACE_CALLBACK_ERROR_EXTRACTSPACE = $24b; // not enough space to extract file //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEExtract ACE_CALLBACK_ERROR_CREATION = $24c; // creation failed (write-protection?) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEExtract ACE_CALLBACK_ERROR_OVERWRITEDELETE = $24d; // could not overwrite because deletion of // file failed //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEExtract ACE_CALLBACK_ERROR_MOVEDELETE = $260; // deletion of file or directory failed // (move operation) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_REALFILE // operations: // ACEAdd ACE_CALLBACK_ERROR_TEMPDIRSPACE = $270; // not enough space at current temp directory //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_SPACE // operations: // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACEAddAV ACE_CALLBACK_ERROR_ARCHIVESPACE = $271; // not enough space to save archive //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_SPACE // operations: // ACEDelete // ACEAdd // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACELock // ACEAddAV // ACEAddRecoveryRecord // ACERepair ACE_CALLBACK_ERROR_READINGSFXFILE = $280; // error reading SFX file: // is no SFX file, // file does not exist or could not be opened // for reading //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_SFXFILE // operations: // ACEAdd // ACEAddSFX ACE_CALLBACK_REQUEST_REGISTER = $300; // Global.UserAV has to be set // to continue registration process; // not used in ACL //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_GLOBAL // operations: // ACERegister ACE_CALLBACK_REQUEST_MARKASSOLID = $320; // ArchiveHeader damaged, // set solid flag for the new archive? // (in case of doubt return yes!) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACERepair ACE_CALLBACK_REQUEST_CHANGEVOLUME = $321; // Asks for permission to process next volume. // If operation is ACE_CALLBACK_OPERATION_ADD // then a new volume will be created. // The application may change the name // of the archive by modifying // ArchiveData->ArchiveName //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEDelete // ACEAdd // ACESetComments // ACEEncryptFiles // ACEList // ACETest // ACEExtract ACE_CALLBACK_REQUEST_ARCHIVEEXISTS = $322; // Asks whether to overwrite a file with // the same name as the archive. //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEDelete // ACEAdd // ACESetComments // ACEEncryptFiles ACE_CALLBACK_REQUEST_OVERWRITE = $340; // Overwrite existing file? //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEAdd // ACEExtract ACE_CALLBACK_REQUEST_DELARCHIVEDSYSFILE = $341; // Delete rdonly/hidden/system file //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEDelete ACE_CALLBACK_REQUEST_ADDBROKENFILE = $342; // repair function found file with // broken header, add file? //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACERepair ACE_CALLBACK_REQUEST_PASSWORD = $343; // password required; attention: may be // decryption _and_ encryption; but passwords // can be different --> better changing // passwords at StateCallbackProc //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEDelete // ACETest // ACEExtract // ACEAdd // ACEEncryptFiles ACE_CALLBACK_REQUEST_OVERWRITESYSFILE = $344; // Overwrite rdonly/hidden/system file //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEAdd // ACEExtract ACE_CALLBACK_REQUEST_MOVEDELREALSYSFILE = $360; // Delete rdonly/hidden/system file // (move to archive operation) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_REALFILE // operations: // ACEAdd ACE_CALLBACK_STATE_STARTARCHIVE = $400; // procession of archive is about to begin //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVE // operations: // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACERepair // ACESetComments // ACEEncryptFiles // ACEAddSFX // ACEAddAV // ACELock // ACEAddRecoveryRecord ACE_CALLBACK_STATE_STARTFILE = $410; // procession of file is about to begin //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEList // ACEDelete // ACETest // ACEExtract // ACEAdd // ACERepair // ACESetComments // ACEEncryptFiles ACE_CALLBACK_STATE_ENDNOCRCCHECK = $411; // end of file procession // (no CRC chceck for this operation) //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_ARCHIVEDFILE // operations: // ACEList // ACEDelete // ACEAdd // ACERepair // ACESetComments // ACEEncryptFiles ACE_CALLBACK_STATE_PROGRESS = $420; // informs about the progress of a file // operation //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_PROGRESS // operations: // ACEDelete // ACETest // ACEExtract // ACEAdd // ACERepair // ACEEncryptFiles ACE_CALLBACK_STATE_ENDCRCCHECK = $430; // end of file procession, CRC-check // result is passed //--------------------------------------------- // structure type: // ACE_CALLBACK_TYPE_CRCCHECK // operations: // ACETest // ACEExtract // ACEDelete // ACEAdd //////////////////////////////////////////////////////////////////////// // PART 3.1: ACE.DLL FUNCTION RETURN CODES //////////////////////////////////////////////////////////////////////// // These error codes are returned by the ACE.DLL-functions. The meanings // of the codes are the same, as they are for the exit codes of ACE.EXE. ACE_ERROR_NOERROR = 0; // no error; operation succesful ACE_ERROR_MEM = 1; // insufficient memory ACE_ERROR_FILES = 2; // no files specified ACE_ERROR_FOUND = 3; // specified archive not found ACE_ERROR_FULL = 4; // disk full ACE_ERROR_OPEN = 5; // could not open file ACE_ERROR_READ = 6; // read error ACE_ERROR_WRITE = 7; // write error ACE_ERROR_CLINE = 8; // invalid command line ACE_ERROR_CRC = 9; // CRC error ACE_ERROR_OTHER = 10; // other error ACE_ERROR_EXISTS = 11; // file already exists ACE_ERROR_USER = 255; // user break (application // returned cancel code at // callback function) // These error codes are returned by the ACE.DLL-functions. They are not // used by ACE.EXE yet. ACE_ERROR_PARAM = 128; // might be used later //////////////////////////////////////////////////////////////////////// // PART 1: DIFFERENT STRUCTURES //////////////////////////////////////////////////////////////////////// // // Here in different structures used at callback functions and // ACE.DLL functions are declared. // // Contents: // Part 1.1: structures used in callback structures // Part 1.2: structures used in function structures // //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // Part 1.1: structures used in callback structures //////////////////////////////////////////////////////////////////////// // comment buffer structure // Used in tACEGlobalDataStruc. Application has to specify where the // comment is or should be stored. type tACECommentStruc = packed record Buf : PByteArray; Bufsize : integer; State : integer; end; pACECommentStruc = ^tACECommentStruc; // Global data structure // This structure contains information for the Dll being interesting for // nearly all functions. The Dll has to be initialized with this // structure passed to tACEInitDll(). This structure is also passed // by the callback functions. tACEGlobalDataStruc = packed record Obj : Pointer; // ---- reserved for application! ---- // thought to be used as a pointer to // an object; when a callback-function is // called, the object pointer can be used to // handle the callback in a specific way; // the pointer has to be initialized by // ACEInitDll() MaxArchiveTestBytes : ulong; // how many bytes of a file should be // looked upon at archive header search? MaxFileBufSize : ulong; // maximum buffer size for buffered // I/O operations Comment : tACECommentStruc; // used to exchange comment data // between application and Dll // using callback functions DecryptPassword : PChar; // the DecryptPassword specified at // ACEInitDll() is overwritten by the // DecryptPassword field of tACEAddStruc and // other function-specific structures; // but this field can be used to change the // password at callback function calls Reserved1 : array[0..63] of char; // fields for ACE only EncryptPassword : PChar; // things stated at the description of the // DecryptPassword field apply here as well TempDir : PChar; // directory to save temporary archive // registration (ACE DLLs only, but not used at ACL) KeyPath : PChar; // necessary for reading and writing key file UserAV : PChar; // Dll returns the AV string (if registered) // in this field IsGeneralKey : PChar; // DLL returns the key, if it is a general key OwnerWindow : HWND ; // specifies the applications window to be // parent of the registration reminder dialog // fields for ACE only CompressionLevel : ulong; // contains the currently used compression // level - may be changed during compression // operation Reserved2 : array[0..55] of char; // has to be filled with zeros // Callback routine addresses InfoCallbackProc : Pointer; ErrorCallbackProc : Pointer; RequestCallbackProc : Pointer; StateCallbackProc : Pointer; // different new fields Reserved3 : array[0..63] of char; // has to be filled with zeros end; pACEGlobalDataStruc = ^tACEGlobalDataStruc; //////////////////////////////////////////////////////////////////////// // archive data structure // Informs the callback functions about the current archive, its volume // number, the archive-flags (see ACE_FLAG constants), the creation host // system (see ACE_HOST constants) and the AV if present in archive. // Also used at ACEReadArchiveData(). tACEArchiveDataStruc = packed record ArchiveName : PChar; VolumeNumber, Flags, // see ACE_ARCFLAG defines below HostCreated, // see ACE_HOST defines below TimeCreated, // in MS-DOS format VersionCreated, VersionExtract: ulong; // version needed to extract files AV : PChar; // not used in ACL Reserved : array[0..63] of char; // filled with zeros end; pACEArchiveDataStruc = ^tACEArchiveDataStruc; //////////////////////////////////////////////////////////////////////// // Contains information about an archived file. tACEFileDataStruc = packed record SourceFileName : PChar; // relative file name DestinationFileName : PCHAR; // absolute file name; // valid for add and extract only! Flags, // see ACE_FILEFLAG defines below CRC32, Method, // 0=stored, 1=LZ77, 2=V20Compression Dictionary // DictionarySize = 2^Dictionary : ulong; CompressedSize, Size : Int64; Time, Attributes : ulong; Reserved : array[0..63] of char; // filled with zeros end; pACEFileDataStruc = ^tACEFileDataStruc; //////////////////////////////////////////////////////////////////////// // Is passed to ACEInfoCallbackProc with ACE_CALLBACK_INFO_COPY as code. // Informs application about the progress of copying either an archive to // a temporary archive, or a temporary archive back to a normal archive. tACECopyInfoStruc = packed record SourceFileName : PChar; // source file DestinationFileName : PChar; // the file copying the source to CopiedBytes, // bytes already copied FileSize : int64; // source file size Reserved : array[0..63] of char; // filled with zeros end; pACECopyInfoStruc = ^tACECopyInfoStruc; //////////////////////////////////////////////////////////////////////// // operation progress structure // Used to state the progress of the current operation. tACEProgressDataStruc = packed record Addr : PChar; // address of uncompressed data block Size : ulong; // size of uncompressed data block TotalProcessedSize : int64; // counted by Dll: // total uncompressed bytes processed TotalCompressedSize : int64; // total compressed bytes processed TotalSize : int64; // total uncompressed bytes to process // (sum of all original file sizes) FileProcessedSize : int64; // uncompr. bytes of file processed FileCompressedSize : int64; // compr. bytes of file processed FileSize : int64; // uncompressed file size end; pACEProgressDataStruc = ^tACEProgressDataStruc; //////////////////////////////////////////////////////////////////////// // Part 1.2: structures used in function structures //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // file list structure // This structure is used in the function specific structures. // The application has to use this structure to indicate which files // have to be processed by the DLL. tACEFilesStruc = packed record SourceDir : PChar; // maybe a real or an archive directory FileList : PChar; // pointer to list of files to process; // zero-terminated; files have to be // separated by carriage-return (0xd); // FileList may/will be modified by the // Dll; if nothing is specified, "*" // will be used // (attention at ACEDelete!!) ExcludeList : PChar; // list of files to exclude from process FullMatch : LongBool; // specifications must fully match // (no files with the same name in // subdirs are processed) RecurseSubDirs: LongBool; // recurse subdirectories // (valid for add operations only) Reserved : array[0..59] of char; // has to be filled with zeros // for future: possibly in-/excluding // file attributes and date/time range end; pACEFilesStruc = ^tACEFilesStruc; //////////////////////////////////////////////////////////////////////// // V2.0 compression structure // Specifies whether to use v2.0 compression or not. If you use v2.0 // compression you can also specify which v2.0 compression techniques // you want to use. (ACE only) tACEV20CompressionStruc = packed record DoUse, // if DoUse=1 and all other fields are DoUseDelta, // zero, then all v2.0 compression DoUseExe, // techniques will be used DoUsePic, DoUseSound : LongBool; Reserved : array[0..63] of char; // has to be filled with zeros end; //////////////////////////////////////////////////////////////////////// // compression parameter structure // Used in tACEAddStruc and tACEDeleteStruc. (ACE only) // typedef struct sACECompressParamsStruc tACECompressParamsStruc = packed record Level, // see ACE_LEVEL constants below Dictionary : ulong; // 15(32k)..22(4Mb) V20Compression : tACEV20CompressionStruc; // indicates if (or which) v2.0 // compression techniques shall be used TestAfter : LongBool; // make a test for CRC check errors // after compression Reserved : array[0..63] of char; // has to be filled with zeros end; //////////////////////////////////////////////////////////////////////// // PART 2: ACE.DLL CALLBACK DECLARATIONS //////////////////////////////////////////////////////////////////////// // // ACE.DLL makes use of four callback functions to exchange data // with the application: // // 1) InfoCallbackProc (pACEInfoCallbackProcStruc Info) // 2) ErrorCallbackProc (pACEErrorCallbackProcStruc Error) // 3) RequestCallbackProc(pACERequestCallbackProcStruc Request) // 4) StateCallbackProc (pACEStateCallbackProcStruc State) // // Meaning of different callback types: // Info - lets the application know about actions that take some // time but are not essential // (Code is one of ACE_CALLBACK_INFO constants) // Error - an error occured; if the reason for this error can // be solved by the application then the Dll can continue // the current operation, otherwise the operation has to // be canceled // (Code is one of ACE_CALLBACK_ERROR constants) // Request - the Dll needs some user input // for ex.: "Overwrite file? (yes/no/cancel)" // (Code is one of ACE_CALLBACK_REQUEST constants) // State - Dll informs application about the progress of an operation // (Code is one of ACE_CALLBACK_STATE constants) // // The pointers to the callback functions has to be set by the application // when calling ACEInitDll(). If the application does not install // a callback function, is has set the corresponding pointer to NULL. // If the ACE.DLL has to call the Error or Request callback function // and they are not installed, the ACE.DLL will cancel the operation. // // The application has the possibility to cancel the current operation // at each callback function call. So if the user clicks on a Cancel-button, // the application should return ACE_CALLBACK_RETURN_CANCEL at the next // callback function call. // // All callback function parameters are declared as unions. // The StructureType field contains he type of the structure which is used. // When the application knows which type of structure it has to use, // it will have to interpret the Code field to get to know the reason // for the callback function call. // // Contents: // Part 2.1: operation types // Part 2.2: callback function return codes // Part 2.3: callback structure types // Part 2.4: callback structures // Part 2.5: info callback function // Part 2.6: error callback function // Part 2.7: request callback function // Part 2.8: state callback function //////////////////////////////////////////////////////////////////////// // Part 2.4: different callback structures // These are the declarations of the different structures used in the // unions passed by the callback functions. //----------------------------------------------------------------------- // Only the Dll GlobalData is passed to the application. //----------------------------------------------------------------------- tACECallbackGlobalStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_GLOBAL Code : ulong; // see definition of // ACE_CALLBACK_TYPE_GLOBAL Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc end; pACECallbackGlobalStruc = ^tACECallbackGlobalStruc; //----------------------------------------------------------------------- // The Dll GlobalData and the ArchiveData are passed. //----------------------------------------------------------------------- tACECallbackArchiveStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_ARCHIVE Code : ulong; // see definition of // ACE_CALLBACK_TYPE_ARCHIVE Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc end; pACECallbackArchiveStruc = ^tACECallbackArchiveStruc; //----------------------------------------------------------------------- // GlobalData, ArchiveData and FileData are passed. //----------------------------------------------------------------------- tACECallbackArchivedFileStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_ARCHIVEDFILE Code : ulong; // see definition of // ACE_CALLBACK_TYPE_ARCHIVEDFILE Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc FileData : pACEFileDataStruc; // see tACEFileDataStruc end; pACECallbackArchivedFileStruc = ^tACECallbackArchivedFileStruc; //----------------------------------------------------------------------- // GlobalData, ArchiveData and a FileName are passed. //----------------------------------------------------------------------- tACECallbackRealFileStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_REALFILE Code : ulong; // see definition of // ACE_CALLBACK_TYPE_REALFILE Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc FileName : PChar; // name of file end; pACECallbackRealFileStruc = ^tACECallbackRealFileStruc; //----------------------------------------------------------------------- // GlobalData, ArchiveData, the path of temp directory and the // bytes required in temp directory (archive size) are passed. //----------------------------------------------------------------------- tACECallbackSpaceStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_SPACE Code : ulong; // see definition of // ACE_CALLBACK_TYPE_SPACE Operation : ulong; GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc Directory : PChar; // path of directory ArchiveSize : int64; // bytes required in temp dir end; pACECallbackSpaceStruc = ^tACECallbackSpaceStruc; //----------------------------------------------------------------------- // GlobalData, ArchiveData and SFXFileName are passed. //----------------------------------------------------------------------- tACECallbackSFXFileStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_SFXFILE Code : ulong; // see definition of // ACE_CALLBACK_TYPE_SFXFILE Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc SFXFileName : PChar; // name of SFX end; pACECallbackSFXFileStruc = ^tACECallbackSFXFileStruc; //----------------------------------------------------------------------- // GlobalData, ArchiveData and CopyData are passed. //----------------------------------------------------------------------- tACECallbackCopyStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_COPY Code : ulong; // see definition of // ACE_CALLBACK_TYPE_COPY Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc CopyData : pACECopyInfoStruc; // see tACECopyInfoStruc end; pACECallbackCopyStruc = ^tACECallbackCopyStruc; //----------------------------------------------------------------------- // GlobalData, ArchiveData, FileData and ProgressData are passed. //----------------------------------------------------------------------- tACECallbackProgressStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_COPY Code : ulong; // see definition of // ACE_CALLBACK_TYPE_COPY Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc FileData : pACEFileDataStruc; // see tACEFileDataStruc ProgressData : pACEProgressDataStruc; // see tACEProgressDataStruc end; pACECallbackProgressStruc = ^tACECallbackProgressStruc; //----------------------------------------------------------------------- // GlobalData, ArchiveData, FileData and CRC-check result are passed. //----------------------------------------------------------------------- tACECallbackCRCCheckStruc = packed record //??? StructureType : ulong; // is ACE_CALLBACK_TYPE_COPY Code : ulong; // see definition of // ACE_CALLBACK_TYPE_COPY Operation : ulong; // ACE_CALLBACK_OPERATION constant GlobalData : pACEGlobalDataStruc; // see tACEGlobalDataStruc ArchiveData : pACEArchiveDataStruc; // see tACEArchiveDataStruc FileData : pACEFileDataStruc; // see tACEFileDataStruc CRCOk : LongBool; // CRC-check result end; pACECallbackCRCCheckStruc = ^tACECallbackCRCCheckStruc; //////////////////////////////////////////////////////////////////////// // Part 2.5: info callback function // Declaration of ACEInfoCallbackProc() parameter and explanation of // callback info codes. //----------------------------------------------------------------------- // Union parameter used at ACEInfoCallbackProc(). //----------------------------------------------------------------------- tACEInfoCallbackProcStruc = packed record case StructureType : ulong of 0 : (Global : tACECallbackGlobalStruc); 1 : (Archive : tACECallbackArchiveStruc); 2 : (RealFile : tACECallbackRealFileStruc); 3 : (Copy : tACECallbackCopyStruc); end; pACEInfoCallbackProcStruc = ^tACEInfoCallbackProcStruc; //═══════════════════════════════════════════════════════════════════════════ //=================--- Part 2.6: error callback function ---=============== //═══════════════════════════════════════════════════════════════════════════ // Declaration of ACEErrorCallbackProc() parameter and explanation of // callback error codes. //--------------------------------------------------------------------------- //----------------------------------------------------------------------- // Union parameter used at ACEErrorCallbackProc(). //----------------------------------------------------------------------- tACEErrorCallbackProcStruc = packed record case StructureType : ulong of 0 : (Global : tACECallbackGlobalStruc); 1 : (Archive : tACECallbackArchiveStruc); 2 : (ArchivedFile : tACECallbackArchivedFileStruc); 3 : (RealFile : tACECallbackRealFileStruc); 4 : (Space : tACECallbackSpaceStruc); 5 : (SFXFile : tACECallbackSFXFileStruc); end; pACEErrorCallbackProcStruc = ^tACEErrorCallbackProcStruc; //----------------------------------------------------------------------- // This structure is used by the ACEErrorCallback function to inform // the application about errors. The Code field of the used structure // contains an ACE_CALLBACK_ERROR value. At most problems modifications // to the passed structure can be made to fix it. Other problems can not // be solved and cause an operation abort immediately. // ErrorCallbackProc() has to return either ACE_CALLBACK_RETURN_OK or // ACE_CALLBACK_RETURN_CANCEL. //----------------------------------------------------------------------- //═══════════════════════════════════════════════════════════════════════════ //================--- Part 2.7: request callback function ---============== //═══════════════════════════════════════════════════════════════════════════ // Declaration of ACERequestCallbackProc() parameter and explanation of // callback request codes. //--------------------------------------------------------------------------- //----------------------------------------------------------------------- // Union parameter used at ACERequestCallbackProc(). //----------------------------------------------------------------------- tACERequestCallbackProcStruc = packed record case StructureType : ulong of 0 : (Global : tACECallbackGlobalStruc); 1 : (Archive : tACECallbackArchiveStruc); 2 : (ArchivedFile : tACECallbackArchivedFileStruc); 3 : (RealFile : tACECallbackRealFileStruc); end; pACERequestCallbackProcStruc = ^tACERequestCallbackProcStruc; //----------------------------------------------------------------------- // Question constants are passed to the RequestCallbackProc callback // function to request further data. // RequestCallbackProc may return ACE_CALLBACK_RETURN_OK, // ACE_CALLBACK_RETURN_NO or ACE_CALLBACK_RETURN_CANCEL. //----------------------------------------------------------------------- //═══════════════════════════════════════════════════════════════════════════ //=================--- Part 2.8: state callback function ---=============== //═══════════════════════════════════════════════════════════════════════════ // Declaration of ACEStateCallbackProc() parameter and explanation of // callback state codes. //--------------------------------------------------------------------------- //----------------------------------------------------------------------- // Union parameter used at ACEStateCallbackProc(). //----------------------------------------------------------------------- tACEStateCallbackProcStruc = packed record case StructureType : ulong of 0 : (Archive : tACECallbackArchiveStruc); 1 : (ArchivedFile : tACECallbackArchivedFileStruc); 2 : (RealFile : tACECallbackArchivedFileStruc); 3 : (Progress : tACECallbackProgressStruc); 4 : (CRCCheck : tACECallbackCRCCheckStruc); end; pACEStateCallbackProcStruc = ^tACEStateCallbackProcStruc; //----------------------------------------------------------------------- // Calls to (*StateCallbackProc)() with ACE_CALLBACK_STATE values in the // Code field are made to enable the application to show the progress of // an operation. //----------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////// // Part 3.2: functions and parameter structures //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // ACEInitDll // Initializes ACE dynamic link library. Has to be called before any // other function call. May be called more than one time. // ACEInitDll() parameter structure. tACEInitDllStruc = packed record GlobalData : tACEGlobalDataStruc; Reserved : array[0..63] of char; // has to be filled with zeroes end; pACEInitDllStruc = ^tACEInitDllStruc; // ACEInitDll() function declaration. TACEInitDllProc = function(DllDate : pACEInitDllStruc) : integer; stdcall; //////////////////////////////////////////////////////////////////////// // ACEReadArchiveData // Tests a file whether it is an archive or not and reads out the archive // data. // ACEReadArchiveData() parameter structure. tACEReadArchiveDataStruc = packed record ArchiveData : tACEArchiveDataStruc; // if this pointer is NULL, the // file passed to ACEReadArchiveData // is no archive; otherwise it points // to a tACEArchiveDataStruc structure // that contains information about the // archive Reserved : array[0..63] of char; // has to be filled with zeroes end; pACEReadArchiveDataStruc = ^tACEReadArchiveDataStruc; // ACEReadArchiveData() function declaration. TACEReadArchiveDataProc = function(ArchiveName : PChar; ArchiveData : pACEReadArchiveDataStruc) : integer; stdcall; //////////////////////////////////////////////////////////////////////// // ACEList // Passes the specified files in the archive to StateCallbackProc(). // ACEList() parameter structure. tACEListStruc = packed record Files : tACEFilesStruc; // specifies files to be listed; // see tACEFilesStruc structure Reserved : array[0..63] of char; // has to be filled with zeroes end; pACEListStruc = ^tACEListStruc; // ACEList() function declaration. TACEListProc = function(ArchiveName : PChar; List : pACEListStruc) : integer; stdcall; //////////////////////////////////////////////////////////////////////// // ACETest // Tests specified files in archive. // ACETest() parameter structure. tACETestStruc = packed record Files : tACEFilesStruc; // specifies files to test; // see tACEFilesStruc structure DecryptPassword : PChar; // zero-terminated string, // case-sensitive (maxlen=56) Reserved : array[0..63] of char; // has to be filled with zeroes end; pACETestStruc = ^tACETestStruc; // ACETest() function declaration. TACETestProc = function(ArchiveName : PChar; List : pACETestStruc) : integer; stdcall; //////////////////////////////////////////////////////////////////////// // ACEExtract // Extracts specified files. // ACEExtract() parameter structure. tACEExtractStruc = packed record Files : tACEFilesStruc; // specifies files to extract; // see tACEFilesStruc structure DestinationDir : PChar; // directory to extract files to ExcludePath : LongBool; // extract files without path DecryptPassword : PChar; // password for decryption (if files // are encrypted); // zero-terminated string, // case-sensitive (maxlen=56) Reserved : array[0..63] of char; // has to be filled with zeroes end; pACEExtractStruc = ^tACEExtractStruc; // ACEExtract() function declaration. TACEExtractProc = function(ArchiveName : PChar; Extract : pACEExtractStruc) : integer; stdcall; const FILELISTSIZE = 32768; // pretty much for this this example: // only the commandline can be used to // specify files.. COMMENTBUFSIZE = 8192; // comments may be up to 32k in size // increase it if you want to put that // large comments to archives, or if // you want to receive all of these large // comments (ACE_COMMENT_SMALLBUF returned // if comment does not fit into buffer) var AceDllInstance : THandle; FileList : array[0..FILELISTSIZE-1] of char; CommentBuf : array[0..COMMENTBUFSIZE-1] of char; ACEInitDll : TACEInitDllProc; ACEReadArchiveData : TACEReadArchiveDataProc; ACEList : TACEListProc; ACETest : TACETestProc; ACEExtract : TACEExtractProc; implementation //////////////////////////////////////////////////////////////////////// // LoadAceDll function LoadAceDll(unpackdllpath : string) : Boolean; begin if (Length(unpackdllpath)>0) and (unpackdllpath[Length(unpackdllpath)]<>'\') then AceDllInstance := LoadLibrary(PChar(unpackdllpath + '\UnAceV2.Dll')) else AceDllInstance := LoadLibrary(PChar(unpackdllpath + 'UnAceV2.Dll')); if (AceDllInstance <> 0) then begin // get addresses of functions @ACEInitDll :=GetProcAddress(AceDllInstance,'ACEInitDll'); @ACEReadArchiveData :=GetProcAddress(AceDllInstance,'ACEReadArchiveData'); @ACEList :=GetProcAddress(AceDllInstance,'ACEList'); @ACETest :=GetProcAddress(AceDllInstance,'ACETest'); @ACEExtract :=GetProcAddress(AceDllInstance,'ACEExtract'); if (@ACEInitDll=nil) or (@ACEReadArchiveData=nil) or (@ACEList=nil) or (@ACETest=nil) or (@ACEExtract=nil) then begin // one or more functions not found FreeLibrary(AceDllInstance); AceDllInstance:=0; end; end; Result:= AceDllInstance <> 0; end; //////////////////////////////////////////////////////////////////////// // Unload ACE dll from memory procedure UnLoadAceDll; begin if AceDllInstance <> 0 then FreeLibrary(AceDllInstance); end; //////////////////////////////////////////////////////////////////////// // ACE List function CallACEList(ArchiveName : string) : integer; var List : tACEListStruc; begin FillChar(List, SizeOf(List), 0); // set all fields to zero List.Files.SourceDir := ''; // archive main directory is // base directory for FileList List.Files.FileList := FileList; // set FileList List.Files.ExcludeList := ''; // no files to exclude List.Files.FullMatch := False; // also list files partially matching // (for instance: list DIR1\TEST.DAT // if FileList specifies TEST.DAT) Result:=ACEList(PChar(ArchiveName), @List); end; //////////////////////////////////////////////////////////////////////// // ACE Test function CallACETest(ArchiveName : string) : integer; var Test : tACETestStruc; begin FillChar(Test, SizeOf(Test), 0); // set all fields to zero Test.Files.SourceDir := ''; // archive main directory is // base directory for FileList Test.Files.FileList := FileList; // set FileList Test.Files.ExcludeList := ''; // no files to exclude Test.Files.FullMatch := False; // also test files partially matching Test.DecryptPassword := ''; // no encrypted file expected Result:=ACETest(PChar(ArchiveName), @Test); end; //////////////////////////////////////////////////////////////////////// // ACE Extract function CallACEExtract(ArchiveName : string; DestinationDir : string; DecryptPassword : string; DoExcludePath : LongBool) : integer; var Extract : tACEExtractStruc; zDestinationDir : array[0..255] of char; zDecryptPassword : array[0..255] of char; begin // memset(&Extract, 0, sizeof(Extract)); // set all fields to zero FillChar(Extract, SizeOf(Extract), 0); // set all fields to zero Extract.Files.SourceDir := ''; // archive main directory is // base dir for FileList Extract.Files.FileList := FileList; // set FileList Extract.Files.ExcludeList := ''; // no files to exclude Extract.Files.FullMatch := False; // also extract files // partially matching Extract.DestinationDir := StrPCopy(zDestinationDir, DestinationDir); // directory to extract to Extract.ExcludePath := DoExcludePath; // extract files with path? Extract.DecryptPassword := StrPCopy(zDecryptPassword, DecryptPassword); Result:=ACEExtract(PChar(ArchiveName), @Extract); end; //////////////////////////////////////////////////////////////////////// initialization finalization UnLoadAceDll; end.