////////////////////////////////////////////////////////////////////////////////
|
// This source file is part of the ZipArchive library source distribution and
|
// is Copyrighted 2000 - 2011 by Artpol Software - Tadeusz Dracz
|
//
|
// This program is free software; you can redistribute it and/or
|
// modify it under the terms of the GNU General Public License
|
// as published by the Free Software Foundation; either version 2
|
// of the License, or (at your option) any later version.
|
//
|
// For the licensing details refer to the License.txt file.
|
//
|
// Web Site: http://www.artpol-software.com
|
////////////////////////////////////////////////////////////////////////////////
|
|
/**
|
* \file ZipStorage.h
|
* Includes the CZipStorage class.
|
*
|
*/
|
|
#if !defined(ZIPARCHIVE_ZIPSTORAGE_DOT_H)
|
#define ZIPARCHIVE_ZIPSTORAGE_DOT_H
|
|
#if _MSC_VER > 1000
|
#pragma once
|
#if defined ZIP_HAS_DLL
|
#pragma warning (push)
|
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
|
#endif
|
#endif
|
|
#include "ZipFile.h"
|
#include "ZipAutoBuffer.h"
|
#include "ZipString.h"
|
#include "ZipMemFile.h"
|
#include "ZipExport.h"
|
#include "ZipCallback.h"
|
#include "BitFlag.h"
|
#include "ZipSplitNamesHandler.h"
|
#include "ZipException.h"
|
#include "ZipCollections.h"
|
|
/**
|
Represents the storage layer for an archive.
|
*/
|
class ZIP_API CZipStorage
|
{
|
friend class CZipArchive;
|
friend class CZipCentralDir;
|
public:
|
/**
|
Storage state.
|
*/
|
enum State
|
{
|
stateOpened = 0x0001, ///< The storage file is opened.
|
stateReadOnly = 0x0002, ///< The storage file is opened as read-only.
|
stateAutoClose = 0x0004, ///< The storage file will be closed when the storage is closed.
|
stateExisting = 0x0008, ///< The storage file existed before opening.
|
stateSegmented = 0x0010, ///< The current archive is segmented.
|
stateSplit = stateSegmented | 0x0020, ///< The current archive is split.
|
stateBinarySplit = stateSplit | 0x0040, ///< The current archive is binary split.
|
stateSpan = stateSegmented | 0x0080 ///< The current archive is spanned.
|
};
|
|
/**
|
The direction of the seeking operation.
|
|
\see
|
CZipStorage::Seek
|
*/
|
enum SeekType
|
{
|
seekFromBeginning, ///< Start seeking from the beginning of a file.
|
seekFromEnd, ///< Start seeking from the end of a file.
|
/**
|
Start seeking from the current position in the archive.
|
This value can cause a volume change when a segmented archive is opened for reading.
|
*/
|
seekCurrent
|
};
|
CZipStorage();
|
virtual ~CZipStorage();
|
|
void Initialize();
|
/**
|
Opens a new or existing archive in memory.
|
The meaning for the parameters is the same as in the CZipArchive::Open(CZipAbstractFile& , int, bool) method.
|
*/
|
void Open(CZipAbstractFile& af, int iMode, bool bAutoClose);
|
|
/**
|
Opens or creates an archive.
|
|
The meaning for the parameters is the same as in the CZipArchive::Open(LPCTSTR, int, ZIP_SIZE_TYPE) method.
|
*/
|
void Open(LPCTSTR lpszPathName, int iMode, ZIP_SIZE_TYPE uVolumeSize);
|
|
|
/**
|
Closes a segmented archive in creation and reopens it as an existing segmented archive.
|
No modifications are allowed afterwards.
|
The archive may also turn out to be a not segmented archive.
|
*/
|
void FinalizeSegm();
|
|
|
/**
|
Called only by CZipCentralDir::Read when opening an existing archive.
|
|
\param uLastVolume
|
The number of the volume the central directory is on.
|
*/
|
void UpdateSegmMode(ZIP_VOLUME_TYPE uLastVolume);
|
|
/**
|
Ensures than in a segmented archive, there is enough free space on the current volume.
|
|
\param uNeeded
|
The size of the required free space in bytes.
|
|
\return
|
The number of free bytes on the current volume.
|
|
*/
|
ZIP_SIZE_TYPE AssureFree(ZIP_SIZE_TYPE uNeeded);
|
|
/**
|
Writes a chunk of data to the archive.
|
|
\param pBuf
|
The buffer with data.
|
|
\param iSize
|
The number of bytes to write.
|
|
\param bAtOnce
|
If \c true, the whole chunk must fit in the current volume.
|
If there is not enough free space, a volume change is performed.
|
|
*/
|
void Write(const void *pBuf, DWORD iSize, bool bAtOnce);
|
|
/**
|
Returns the total size currently occupied by the archive.
|
|
\return
|
The length of the current archive file increased by the number of bytes in the write buffer.
|
*/
|
ZIP_SIZE_TYPE GetOccupiedSpace() const
|
{
|
return ZIP_SIZE_TYPE(m_pFile->GetLength() + m_uBytesInWriteBuffer);
|
}
|
|
/**
|
The same as the CZipArchive::IsClosed method.
|
*/
|
bool IsClosed(bool bArchive) const
|
{
|
if (bArchive)
|
return !m_state.IsSetAny(stateOpened);
|
else
|
// assume not auto-close files always opened
|
return !m_pFile || m_state.IsSetAny(stateAutoClose) && m_pFile->IsClosed();
|
}
|
|
/**
|
Reads a chunk of data from the archive.
|
|
\param pBuf
|
The buffer to receive the data.
|
|
\param iSize
|
The number of bytes to read.
|
|
\param bAtOnce
|
If \c true, no volume change is allowed during reading.
|
If the requested number of bytes cannot be read from a single volume, an exception is thrown.
|
|
*/
|
DWORD Read(void* pBuf, DWORD iSize, bool bAtOnce);
|
|
/**
|
Returns the position in the file, taking into account the number of bytes in the write buffer
|
and the number of bytes before the archive.
|
|
\return
|
The position in the file.
|
|
\note
|
For binary split archives, it returns the position from the beginning of the first part.
|
*/
|
ZIP_SIZE_TYPE GetPosition() const
|
{
|
ZIP_SIZE_TYPE uPos = (ZIP_SIZE_TYPE)(m_pFile->GetPosition()) + m_uBytesInWriteBuffer;
|
if (m_uCurrentVolume == 0)
|
uPos -= m_uBytesBeforeZip;
|
else if (IsBinarySplit()) // not for the first volume
|
{
|
ZIP_VOLUME_TYPE uVolume = m_uCurrentVolume;
|
ASSERT(m_pCachedSizes->GetSize() > (ZIP_ARRAY_SIZE_TYPE)(uVolume - 1));
|
do
|
{
|
uVolume--;
|
uPos += (ZIP_SIZE_TYPE)m_pCachedSizes->GetAt((ZIP_ARRAY_SIZE_TYPE)uVolume);
|
}
|
while (uVolume > 0);
|
}
|
return uPos;
|
}
|
|
|
/**
|
Flushes the data from the read buffer to the disk.
|
|
*/
|
void Flush();
|
|
|
/**
|
Forces any data remaining in the file buffer to be written to the disk.
|
*/
|
void FlushFile()
|
{
|
if (!IsReadOnly())
|
m_pFile->Flush();
|
}
|
|
void FlushBuffers()
|
{
|
Flush();
|
FlushFile();
|
}
|
|
/**
|
Changes volumes during writing to a segmented archive.
|
|
\param uNeeded
|
The number of bytes needed in the volume.
|
|
*/
|
void NextVolume(ZIP_SIZE_TYPE uNeeded);
|
|
|
/**
|
Returns a zero-based number of the current volume.
|
*/
|
ZIP_VOLUME_TYPE GetCurrentVolume() const {return m_uCurrentVolume;}
|
|
|
/**
|
Changes the volume during extract operations.
|
|
\param uNumber
|
A zero-based number of the requested volume.
|
*/
|
void ChangeVolume(ZIP_VOLUME_TYPE uNumber);
|
|
/**
|
Changes the current volume to the next volume during extract operations.
|
*/
|
void ChangeVolume()
|
{
|
ChangeVolume((ZIP_VOLUME_TYPE)(m_uCurrentVolume + 1));
|
}
|
|
/**
|
Changes the current volume to the previous volume during extract operations.
|
*/
|
void ChangeVolumeDec()
|
{
|
if (m_uCurrentVolume == 0)
|
ThrowError(CZipException::badZipFile);
|
ChangeVolume((ZIP_VOLUME_TYPE)(m_uCurrentVolume - 1));
|
}
|
|
/**
|
Returns the value indicating whether the archive is a split archive (binary or regular).
|
|
\return
|
\c true, if the archive is a split archive; \c false otherwise.
|
*/
|
bool IsSplit() const
|
{
|
return m_state.IsSetAll(stateSplit);
|
}
|
|
/**
|
Returns the value indicating whether the archive is a binary split archive.
|
|
\return
|
\c true, if the archive is a binary split archive; \c false otherwise.
|
*/
|
bool IsBinarySplit() const
|
{
|
return m_state.IsSetAll(stateBinarySplit);
|
}
|
|
/**
|
Returns the value indicating whether the archive is a regular split archive (not binary).
|
|
\return
|
\c true, if the archive is a regular split archive; \c false otherwise.
|
*/
|
bool IsRegularSplit() const
|
{
|
return m_state.IsSetAll(stateSplit) && !m_state.IsSetAll(stateBinarySplit);
|
}
|
|
/**
|
Returns the value indicating whether the archive is a spanned archive.
|
|
\return
|
\c true, if the archive is a spanned archive; \c false otherwise.
|
*/
|
bool IsSpanned() const
|
{
|
return m_state.IsSetAll(stateSpan);
|
}
|
|
/**
|
The same as the CZipArchive::IsReadOnly method.
|
*/
|
bool IsReadOnly() const
|
{
|
return m_state.IsSetAny(stateReadOnly) || IsExistingSegmented();
|
}
|
|
/**
|
Returns the value indicating whether the archive is an existing segmented archive.
|
|
\return
|
\c true, if the archive is an existing segmented archive; \c false otherwise.
|
*/
|
bool IsExistingSegmented() const
|
{
|
return m_state.IsSetAll(stateSegmented | stateExisting);
|
}
|
|
/**
|
Returns the value indicating whether the archive is a new segmented archive.
|
|
\return
|
\c true, if the archive is a new segmented archive; \c false otherwise.
|
*/
|
bool IsNewSegmented() const
|
{
|
return m_state.IsSetAny(stateSegmented) && !IsExisting();
|
}
|
|
/**
|
Returns the value indicating whether the archive is a segmented archive.
|
|
\return
|
\c true, if the archive is a segmented archive; \c false otherwise.
|
*/
|
bool IsSegmented() const
|
{
|
return m_state.IsSetAny(stateSegmented);
|
}
|
|
/**
|
Returns the value indicating whether the archive is an existing archive.
|
|
\return
|
\c true, if the archive is an existing archive; \c false, if the archive is a new archive.
|
*/
|
bool IsExisting() const
|
{
|
return m_state.IsSetAny(stateExisting);
|
}
|
|
/**
|
Sets the split names handler.
|
|
\see
|
CZipArchive::SetSplitNamesHandler(CZipSplitNamesHandler*, bool)
|
\see
|
CZipSplitNamesHandler
|
*/
|
bool SetSplitNamesHandler(CZipSplitNamesHandler* pNames, bool bAutoDelete)
|
{
|
if (m_state != 0)
|
{
|
ZIPTRACE("%s(%i) : The archive is already opened.\n");
|
return false;
|
}
|
ClearSplitNames();
|
m_pSplitNames = pNames;
|
m_bAutoDeleteSplitNames = bAutoDelete;
|
return true;
|
}
|
|
/**
|
Returns the current split names handler.
|
|
\return
|
The current split names handler.
|
\see
|
CZipSplitNamesHandler
|
*/
|
CZipSplitNamesHandler* GetSplitNamesHandler()
|
{
|
return m_pSplitNames;
|
}
|
|
/**
|
Returns the current split names handler (const).
|
|
\return
|
The current split names handler.
|
\see
|
CZipSplitNamesHandler
|
*/
|
const CZipSplitNamesHandler* GetSplitNamesHandler() const
|
{
|
return m_pSplitNames;
|
}
|
|
/**
|
Performs the seeking operation on the #m_pFile.
|
|
\param lOff
|
The new position in the file.
|
|
\param iSeekType
|
The direction of the seek operation.
|
It can be one of the #SeekType values.
|
*/
|
ULONGLONG Seek(ULONGLONG lOff, SeekType iSeekType = seekFromBeginning);
|
|
/**
|
Performs the seeking operation in a binary split archive.
|
|
\param lOff
|
The offset to move the file pointer.
|
|
\param bSeekToBegin
|
If \c true, the file pointer is moved to the beginning before seeking.
|
If \c false, the file pointer is moved relatively to the current position.
|
*/
|
void SeekInBinary(ZIP_FILE_SIZE lOff, bool bSeekToBegin = false);
|
|
/**
|
Returns the number of free bytes on the current volume.
|
|
\return
|
The number of free bytes on the current volume.
|
*/
|
ZIP_SIZE_TYPE VolumeLeft() const;
|
|
/**
|
Closes the storage.
|
|
\param bWrite
|
Set to \c false, if the storage should not perform any write operations.
|
\param bGetLastVolumeName
|
Set to \c true, if the storage should return the path.
|
|
\return
|
The file path of the archive or of the last volume in the archive.
|
Only if \a bGetLastVolumeName is set to \c true.
|
|
*/
|
CZipString Close(bool bWrite, bool bGetLastVolumeName = false);
|
|
/**
|
Represents the physical storage for the archive (or the current archive segment in segmented archives).
|
*/
|
CZipAbstractFile* m_pFile;
|
|
/**
|
The signature of the extended header.
|
*/
|
static char m_gszExtHeaderSignat[];
|
|
ZipArchiveLib::CBitFlag& GetState()
|
{
|
return m_state;
|
}
|
|
protected:
|
|
/**
|
Returns the file offset after the last data byte in the archive.
|
|
\return
|
The file offset after the last data byte in the archive.
|
*/
|
ZIP_SIZE_TYPE GetLastDataOffset()
|
{
|
return (ZIP_SIZE_TYPE)m_pFile->GetLength() - m_uBytesBeforeZip;
|
}
|
|
/**
|
Reverse-finds the location of the given signature starting from the current position in file.
|
|
\param szSignature
|
The signature to locate.
|
|
\param uMaxDepth
|
The maximum number of bytes to search for \a szSignature.
|
|
\return
|
The location of the signature.
|
|
*/
|
ZIP_FILE_USIZE LocateSignature(char* szSignature, ZIP_SIZE_TYPE uMaxDepth);
|
|
|
/**
|
Flushes without writing. It can be used only on not segmented archives.
|
*/
|
void EmptyWriteBuffer()
|
{
|
m_uBytesInWriteBuffer = 0;
|
}
|
|
/**
|
Opens a physical file.
|
|
\param lpszName
|
The name of the file to open.
|
|
\param uFlags
|
The file open flags.
|
|
\param bThrow
|
If \c true, throw an exception in case of failure.
|
|
\return
|
\c true if successful; \c false otherwise.
|
*/
|
bool OpenFile(LPCTSTR lpszName, UINT uFlags, bool bThrow = true);
|
|
/**
|
Renames the last segment file in a split archive when finalizing the archive.
|
|
\return
|
The name of the last segment.
|
*/
|
CZipString RenameLastFileInSplitArchive();
|
|
/**
|
Writes data to the internal buffer.
|
|
\param *pBuf
|
The buffer to copy the data from.
|
|
\param uSize
|
The number of bytes to write.
|
|
*/
|
void WriteInternalBuffer(const char *pBuf, DWORD uSize);
|
|
/**
|
Returns the free space size on the current removable disk.
|
|
\return
|
The free space in bytes.
|
*/
|
ZIP_SIZE_TYPE GetFreeVolumeSpace() const;
|
|
/**
|
Calls the segmented callback object.
|
Throws an exception if the callback method returns \c false.
|
|
\param uNeeded
|
The minimum number of free bytes required on the disk.
|
|
\param iCode
|
The code to be passed to the callback method.
|
|
\param szTemp
|
The string to be used as a filename (as an argument
|
in the CZipException::Throw method) when an exception must be thrown.
|
|
\see
|
CZipArchive::SetSegmCallback
|
*/
|
void CallCallback(ZIP_SIZE_TYPE uNeeded, int iCode, CZipString szTemp);
|
|
/**
|
Changes a file when processing a split archive.
|
*/
|
CZipString ChangeSplitRead();
|
|
/**
|
Changes a disk when processing a spanned archive.
|
*/
|
CZipString ChangeSpannedRead();
|
|
/**
|
Returns the free space left in the write buffer.
|
|
\return
|
The free space in bytes.
|
*/
|
DWORD GetFreeInBuffer() const {return m_pWriteBuffer.GetSize() - m_uBytesInWriteBuffer;}
|
|
/**
|
The value it holds, depends on the current mode:
|
- An opened existing split archive: the number of the last volume ( usually the one with the "zip" extension).
|
- A split archive in creation: the size of the volume.
|
|
This method is used only when processing split archives.
|
*/
|
ZIP_SIZE_TYPE m_uSplitData;
|
|
/**
|
The number of bytes available in the write buffer.
|
*/
|
DWORD m_uBytesInWriteBuffer;
|
|
/**
|
The value it holds depends on the segmentation mode:
|
- A split archive: the total size of the current volume.
|
- A spanned archive: the free space on the current volume.
|
*/
|
ZIP_SIZE_TYPE m_uCurrentVolSize;
|
|
/**
|
The write buffer caching data.
|
*/
|
CZipAutoBuffer m_pWriteBuffer;
|
|
/**
|
Stores the number of bytes that have been written physically to the current segment.
|
Used only when processing a segmented archive in creation.
|
*/
|
ZIP_SIZE_TYPE m_uBytesWritten;
|
|
/**
|
The current volume number in a segmented archive.
|
The value is zero-based.
|
*/
|
ZIP_VOLUME_TYPE m_uCurrentVolume;
|
|
/**
|
The number of bytes before the actual zip archive in a file.
|
\see
|
CZipArchive::GetBytesBeforeZip
|
*/
|
ZIP_SIZE_TYPE m_uBytesBeforeZip;
|
|
|
/**
|
The size of the write buffer.
|
|
\see
|
CZipArchive::SetAdvanced
|
*/
|
int m_iWriteBufferSize;
|
|
/**
|
The size of the buffer used in searching for the central directory.
|
|
\see
|
CZipArchive::SetAdvanced
|
*/
|
int m_iLocateBufferSize;
|
|
/**
|
A callback object called when there is a need for a volume change
|
in a spanned archive.
|
|
\see
|
CZipArchive::SetSegmCallback
|
*/
|
CZipSegmCallback* m_pSpanChangeVolumeFunc;
|
|
/**
|
A callback object called when there is a need for a volume change
|
in a split archive.
|
|
\see
|
CZipArchive::SetSegmCallback
|
*/
|
CZipSegmCallback* m_pSplitChangeVolumeFunc;
|
|
private:
|
ZIP_FILE_USIZE LocateSignature(char* szSignature, ZIP_SIZE_TYPE uMaxDepth, int& leftToFind, bool& found, ZIP_FILE_USIZE uFileLength);
|
CZipString GetSplitVolumeName(bool bLast)
|
{
|
if (m_pSplitNames == NULL)
|
{
|
ThrowError(CZipException::genericError);
|
}
|
int flags = bLast ? CZipSplitNamesHandler::flLast : CZipSplitNamesHandler::flNone;
|
if (IsExisting())
|
flags |= CZipSplitNamesHandler::flExisting;
|
return m_pSplitNames->GetVolumeName(m_szArchiveName, (ZIP_VOLUME_TYPE)(m_uCurrentVolume + 1), flags);
|
}
|
|
void ClearSplitNames()
|
{
|
if (m_pSplitNames)
|
{
|
if (m_bAutoDeleteSplitNames)
|
delete m_pSplitNames;
|
m_pSplitNames = NULL;
|
m_bAutoDeleteSplitNames = false;
|
}
|
}
|
|
void ClearCachedSizes()
|
{
|
if (m_pCachedSizes)
|
{
|
delete m_pCachedSizes;
|
m_pCachedSizes = NULL;
|
}
|
}
|
|
void EnsureSplitNames()
|
{
|
if (IsSplit())
|
{
|
if (m_pSplitNames == NULL)
|
{
|
m_bAutoDeleteSplitNames = true;
|
if (m_state.IsSetAll(stateBinarySplit))
|
m_pSplitNames = new CZipBinSplitNamesHandler();
|
else
|
m_pSplitNames = new CZipRegularSplitNamesHandler();
|
}
|
m_pSplitNames->Initialize(m_szArchiveName);
|
}
|
}
|
|
ZIP_FILE_USIZE GetCachedSize(ZIP_VOLUME_TYPE uVolume)
|
{
|
ASSERT(m_pCachedSizes);
|
if (m_pCachedSizes->GetSize() > (ZIP_ARRAY_SIZE_TYPE)uVolume)
|
return m_pCachedSizes->GetAt((ZIP_ARRAY_SIZE_TYPE)uVolume);
|
ThrowError(CZipException::genericError);
|
// for a compiler
|
return 0;
|
}
|
|
void CacheSizes();
|
|
ZipArchiveLib::CBitFlag m_state;
|
CZipSegmCallback* m_pChangeVolumeFunc;
|
CZipString m_szArchiveName;
|
CZipFile m_internalfile;
|
CZipSplitNamesHandler* m_pSplitNames;
|
CZipArray<ZIP_FILE_USIZE>* m_pCachedSizes;
|
bool m_bAutoDeleteSplitNames;
|
static const ZIP_FILE_USIZE SignatureNotFound;
|
void ThrowError(int err) const;
|
};
|
|
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
|
#pragma warning (pop)
|
#endif
|
|
|
#endif // !defined(ZIPARCHIVE_ZIPSTORAGE_DOT_H)
|
