ZipArchive: Modification of Archives: Replacing, Renaming, Deleting and Changing Data

Modification of Archives: Replacing, Renaming, Deleting and Changing Data

Applies To: All But Multi-Segment Archives

Introduction
Replacing
- Callbacks Called
Deleting
- Callbacks Called
Committing Modification Changes
- Commit Mode
- Callback Called
Renaming
Changing the Modification Time of Files Inside an Archive
Storing Modification, Creation and Last Access File Time (High Resolution)
Writing and Reading File and Archive Comments
Controlling Windows System File Cache

Introduction

The operations described in this article report progress using callback objects. For more information about using callback objects, see Progress Notifications: Using Callback Objects.
To read about preventing archive corruption in some cases, see Compressing Data.
To access a file inside an archive, request its information using methods described here: Requesting Information, Predicting Names and Sizes.

Replacing

To replace an existing file in an archive with a new file, use the
CZipArchive::AddNewFile(CZipAddNewFileInfo&) method and specify the index of the file to be replaced in CZipAddNewFileInfo::m_uReplaceIndex.
The operation replaces the file physically and no information from the file being replaced is retained (such as attributes, modification time, encryption method, etc.).
If CZipAddNewFileInfo::m_iComprLevel is not 0 then a file to be added is first compressed to a temporary archive which is created in:
- the temporary directory (see the CZipArchive::SetTempPath() method)
- or in the memory, if you specify CZipArchive::zipsmMemoryFlag in CZipAddNewFileInfo::m_iSmartLevel.

Sample Code

CZipArchive zip;
zip.Open(_T("C:\\Temp\\test.zip"));
CZipAddNewFileInfo info(_T("C:\\Temp\\file.dat"), _T("replacement.dat"));
// replace the first file in the archive
info.m_uReplaceIndex = 0;
zip.AddNewFile(info);
zip.Close();

Callbacks Called

If a temporary archive is used (see above), then the CZipActionCallback::cbAdd callback is called while compressing a file to a temporary archive.
If you have additionally specified CZipArchive::zipsmCheckForEff in CZipAddNewFileInfo::m_iSmartLevel and the compression to the temporary archive proved to be inefficient, then the file is stored instead in a temporary archive and this process calls the CZipActionCallback::cbAddStore callback.
If the space size taken by the old file is different from the space size needed by the new file, the space needs to be adjusted for the new file to fit and this operation calls the CZipActionCallback::cbMoveData callback.

Deleting

You can delete files in an archive by specifying either of:

an index of the file to delete with the method
CZipArchive::RemoveFile,
an array of indexes of files to delete with the method
CZipArchive::RemoveFiles(CZipIndexesArray&),
an array of names of files to delete with the method
CZipArchive::RemoveFiles(const CZipStringArray&).

If you plan to delete more files at once, use the methods that take arrays as arguments - they are optimized for multiple file deletion.

If you don't want to physically remove the file from the archive, but only from the central directory (e.g. to save the processing time or for safer archive modifications), use the CZipArchive::RemoveFile method and set the bRemoveData parameter to false.

Sample Code

CZipArchive zip;
zip.Open(_T("C:\\Temp\\test.zip"));
// delete the first file
zip.RemoveFile(0);
// delete two first files
CZipIndexesArray indexes;
indexes.Add(0);
indexes.Add(1);
zip.RemoveFiles(indexes);
// delete files by their names
CZipStringArray names;
names.Add(_T("Temp\\file1.dat"));
names.Add(_T("file4.dat"));
zip.RemoveFiles(names);
zip.Close();

Callbacks Called

When a map of areas of data to be moved inside an archive is being calculated, the CZipActionCallback::cbDeleteCnt callback is called.
When the space inside the archive needs to be adjusted, this operation notifies about the progress using the CZipActionCallback::cbDelete callback.

Committing Modification Changes

Commit changes functionality currently concerns only renaming of files.
The ZipArchive Library allows grouping multiple operations and writing the necessary changes to an archive at once, which is more efficient than modifying files separately.
To examine, if a file has been modified, call the CZipFileHeader::IsModified() method.
To examine, if there are any pending modification in an archive, call the CZipArchive::IsModified() method.

Commit Mode

The commit mode can be set with the CZipArchive::SetCommitMode() method to one of CZipArchive::CommitMode values.
Regardless of the mode, all uncommitted changes will committed when closing an archive.
When using CZipArchive::cmManual mode, you can commit the changes manually with the CZipArchive::CommitChanges() method.

Callback Called

If data sizes of modified files differ after modifications, then the space inside the archive needs to be adjusted and the CZipArchive::CommitChanges() method notifies about the progress using the CZipActionCallback::cbModify callback.

Sample Code

CZipArchive zip;
zip.Open(_T("C:\\Temp\\test.zip"));
zip.SetCommitMode(CZipArchive::cmManual);
// rename the first file in the archive
zip[0]->SetFileName(_T("renamed.dat"));    
zip[2]->SetFileName(_T("renamed2.dat"));
zip.CommitChanges();
// perform possibly some other operations
zip.Close();

Renaming

To rename files, use the CZipFileHeader::SetFileName() method.
To rename a file in the central directory only (faster, but not compatible with XCeed), set the bInCentralOnly parameter to true.
When calling this method, the current Unicode mode will be used (see Unicode Support: Using Non-English Characters in Filenames, Comments and Passwords for more information) - this may result in changing a Unicode mode for the file being renamed.
To rename multiple files at once, you may want to use the CZipArchive::cmManual commit changes mode.

Sample Code

CZipArchive zip;
zip.Open(_T("C:\\Temp\\test.zip"));
zip.SetCommitMode(CZipArchive::cmManual);
// rename the first file in the archive
zip[0]->SetFileName(_T("renamed.dat"));    
zip[2]->SetFileName(_T("renamed2.dat"));
// this will call CommitChanges
zip.Close();

Changing the Modification Time of Files Inside an Archive

The modification time of the file is written in both local and central headers. To modify it, you need to update the time stamp in these both locations to keep the archive consistent. Follow the steps below to do it:

Be sure that the existing local header information was already read from the archive. It happens when a file is opened for extraction. Otherwise, you can also update it by calling the CZipArchive::ReadLocalHeader() method.
Request the CZipFileHeader object for the file which time stamp you want to change. Use the CZipArchive::GetFileInfo(ZIP_INDEX_TYPE) or CZipArchive::operator[]() methods.
Change the time by calling the CZipFileHeader::SetModificationTime() method.
Write the local information back to the archive by calling the CZipArchive::OverwriteLocalHeader() method.
To update the central directory, it first needs to be removed from the archive. The central directory is removed from an archive, when a modification such as adding, deleting, renaming, encrypting or other takes place. However, if you have not performed such a modification on the archive, you can call the CZipArchive::RemoveCentralDirectoryFromArchive() method to force the central directory removal.
- You can check, if the central directory is currently in the archive by requesting the central directory information with the CZipArchive::GetCentralDirInfo() method and then examining the CZipCentralDir::CInfo::m_bInArchive value.
The central directory is written to the archive when the archive is closed, but you can also force this by calling the CZipArchive::Finalize() method.
To use UTC times, call CZipArchive::SetFullFileTimes() method.

Sample Code

CZipArchive zip;
zip.Open(_T("C:\\Temp\\test.zip"));
int iIndexOfFile = 1;
// read the local header information
zip.ReadLocalHeader(iIndexOfFile);
CZipFileHeader* pHeader = zip.GetFileInfo(iIndexOfFile);
// set the time
pHeader->SetModificationTime(time(0));
// write the local header information
zip.OverwriteLocalHeader(iIndexOfFile);
zip.RemoveCentralDirectoryFromArchive();
// the central directory will be written back to the archive
// during closing
zip.Close();

Storing Modification, Creation and Last Access File Time (High Resolution)

The default file modification time has 2 seconds resolution. To store the modification time in full resolution and additionally store creation and last access times, call the CZipArchive::SetFullFileTimes() method after opening an archive. It will affect all files added afterwards to the archive.

The file times storage format is compatible with other software (e.g. WinZip) and the software that doesn't support it, will just use the regular modification time stored inside of the archive the standard way.
The information is stored inside of an extra header in the central directory only, so modification of the high resolution file times doesn't need the local header to be removed. Only the central directory needs to be updated (see Modification of Archives: Replacing, Renaming, Deleting and Changing Data for more information). However, when updating the modification time, it is recommended to update the local header as well (as described previously) to keep the standard modification time in sync with the high resolution time, so that the software that doesn't support the high resolution times can still set the modification time properly.
To set modification time in full resolution for an existing file inside of an archive, use the CZipFileHeader::SetModificationTime() method and set the bFullResolution parameter to true. To set other file times, use CZipFileHeader::SetLastAccessTime() and CZipFileHeader::SetCreationTime() methods.
To use UTC times, call CZipArchive::SetFullFileTimes() method.
Windows - Some file systems do not support full resolution file times, so the accuracy may be lost when extracting such a file.
- NT FAT - modification time has a resolution of 2 seconds, create time - 10 ms and last access time - 1 day.
- NTFS - last access time has a resolution of 1 hour.
- See File Times for more information.
Linux does not store the file creation time.

Sample Code

CZipArchive zip;
zip.Open(_T("C:\\Temp\\test.zip"));
CZipFileHeader* pHeader = zip.GetFileInfo(0);
pHeader->SetLastAccessTime(time(0));
zip.SetFullFileTimes();
// add a new file, it will have full file times stored
zip.AddNewFile(_T("C:\\Temp\\file.dat"));
zip.RemoveCentralDirectoryFromArchive();
// the central directory will be written back to the archive
// during closing
zip.Close();

Writing and Reading File and Archive Comments

The ZipArchive Library provides the following methods to write and read comments.

To write a comment for a single file in an archive, use the CZipFileHeader::SetComment() method.
To read a file comment from an existing archive, use the CZipFileHeader::GetComment() method.
To write a comment for the whole archive, use the
CZipArchive::SetGlobalComment() method.
To read a global comment from an existing archive, use the
CZipArchive::GetGlobalComment() method.
The Unicode mode used will be the same as the Unicode mode for the filename (see Unicode Support: Using Non-English Characters in Filenames, Comments and Passwords for more information).

Controlling Windows System File Cache

When performing extensive file operations (especially on large files under a 64-bit system) you may notice that large amount of memory is being used. This is may be related to the growing size of Windows System File Cache. Resolving of the issue is beyond the scope of the ZipArchive Library, but here are possible solutions:

Use SetSystemFileCacheSize Windows API function in your software (only Windows Server 2003 SP1 and newer).
Use Microsoft Windows Dynamic Cache Service under 64-bit systems.
Use NT Cache Setter by Uwe Sieber.

Some more information can be also found for example in these articles:

Article ID: 0610231944