fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2008-09-03 15:47 UTC+0200 Viktor Szakats (harbour.01 syenar hu)

Browse Source 
* contrib/hbziparch/Makefile
   * contrib/hbziparch/common.mak
   + contrib/hbziparch/hbziparc.prg
   - contrib/hbziparch/hbzipnew.cpp
   + contrib/hbziparch/hbzipold.cpp
   * contrib/hbziparch/tests/bld_b32.bat
   * contrib/hbziparch/tests/bld_vc.bat
   - contrib/hbziparch/Wildcard.h
   - contrib/hbziparch/ZipString.h
   - contrib/hbziparch/FileInfo.h
   - contrib/hbziparch/ZipFileMapping_lnx.h
   - contrib/hbziparch/ZipMutex_win.h
   - contrib/hbziparch/ZipPathComponent.h
   - contrib/hbziparch/Aes.h
   - contrib/hbziparch/BaseLibCompressor.cpp
   - contrib/hbziparch/zlib
   - contrib/hbziparch/ZipCentralDir.h
   - contrib/hbziparch/RandomPool.h
   - contrib/hbziparch/ZipPathComponent_win.cpp
   - contrib/hbziparch/ZipString_stl.h
   - contrib/hbziparch/ZipPlatform_win.cpp
   - contrib/hbziparch/std_mfc.h
   - contrib/hbziparch/DeflateCompressor.h
   - contrib/hbziparch/ZipCrc32Cryptograph.h
   - contrib/hbziparch/Wildcard.cpp
   - contrib/hbziparch/ZipString.cpp
   - contrib/hbziparch/FileFilter.h
   - contrib/hbziparch/ZipMutex.h
   - contrib/hbziparch/ZipCompatibility.cpp
   - contrib/hbziparch/ZipFileMapping_win.h
   - contrib/hbziparch/ZipExtraData.cpp
   - contrib/hbziparch/Sha1.h
   - contrib/hbziparch/ZipArchive.cpp
   - contrib/hbziparch/ZipFileHeader.h
   - contrib/hbziparch/DirEnumerator.cpp
   - contrib/hbziparch/DeflateCompressor.cpp
   - contrib/hbziparch/ZipBaseException.h
   - contrib/hbziparch/std_stl.h
   - contrib/hbziparch/_features.h
   - contrib/hbziparch/ZipFileMapping.h
   - contrib/hbziparch/BaseLibCompressor.h
   - contrib/hbziparch/FileFilter.cpp
   - contrib/hbziparch/ZipException.h
   - contrib/hbziparch/ZipCryptograph.h
   - contrib/hbziparch/ZipAbstractFile.h
   - contrib/hbziparch/ZipStorage.h
   - contrib/hbziparch/ZipStringStoreSettings.h
   - contrib/hbziparch/stdafx.h
   - contrib/hbziparch/ZipCompatibility.h
   - contrib/hbziparch/ZipExtraData.h
   - contrib/hbziparch/ZipMemFile.h
   - contrib/hbziparch/Hmac.cpp
   - contrib/hbziparch/Bzip2Compressor.h
   - contrib/hbziparch/ZipExport.h
   - contrib/hbziparch/ZipArchive.h
   - contrib/hbziparch/ZipExtraField.cpp
   - contrib/hbziparch/ZipFileHeader.cpp
   - contrib/hbziparch/ZipPlatform.h
   - contrib/hbziparch/ZipAesCryptograph.cpp
   - contrib/hbziparch/ZipException.cpp
   - contrib/hbziparch/ZipCompressor.h
   - contrib/hbziparch/ZipFile_stl.cpp
   - contrib/hbziparch/DirEnumerator.h
   - contrib/hbziparch/ZipCryptograph.cpp
   - contrib/hbziparch/ZipStorage.cpp
   - contrib/hbziparch/ZipAutoBuffer.h
   - contrib/hbziparch/ZipCollections_mfc.h
   - contrib/hbziparch/ZipFile_mfc.h
   - contrib/hbziparch/resource.h
   - contrib/hbziparch/ZipCallbackProvider.h
   - contrib/hbziparch/ZipMemFile.cpp
   - contrib/hbziparch/Bzip2Compressor.cpp
   - contrib/hbziparch/ZipCollections.h
   - contrib/hbziparch/ZipFile.h
   - contrib/hbziparch/Aes.cpp
   - contrib/hbziparch/ZipCentralDir.cpp
   - contrib/hbziparch/RandomPool.cpp
   - contrib/hbziparch/ZipMutex_lnx.h
   - contrib/hbziparch/Hmac.h
   - contrib/hbziparch/ZipExtraField.h
   - contrib/hbziparch/ZipCompressor.cpp
   - contrib/hbziparch/License.txt
   - contrib/hbziparch/ZipCrc32Cryptograph.cpp
   - contrib/hbziparch/ZipAesCryptograph.h
   - contrib/hbziparch/ZipPathComponent_lnx.cpp
   - contrib/hbziparch/ZipPlatformComm.cpp
   - contrib/hbziparch/ZipString_mfc.h
   - contrib/hbziparch/ZipCallback.h
   - contrib/hbziparch/ZipAutoBuffer.cpp
   - contrib/hbziparch/ZipFile_mfc.cpp
   - contrib/hbziparch/ZipCollections_stl.h
   - contrib/hbziparch/BytesWriter.h
   - contrib/hbziparch/ZipPlatform_lnx.cpp
   - contrib/hbziparch/_platform.h
   - contrib/hbziparch/ZipFile_stl.h
   - contrib/hbziparch/readme.txt
   - contrib/hbziparch/Sha1.cpp
     + Added .prg level implementation of old hbziparch interface.
       It's based on Toninhos functions sent to the list, but 
       synced with old interface and extended with new features, 
       fixes and all the remaining interface functions, and old 
       doc.
       There are some non-implemented stuff, and a couple of 
       NOTEs and TOFIXes, if someone wants, these can be addressed.
       (some not, as hbmzip doesn't support multi-volume archives.)
     * Library renamed from hbziparch -> hbziparc to be short 
       filename. The dir itself will also be renamed so.
     * Make files modified to compile on all platforms and to 
       pull hbmzip to build tests.
     - Removed ZipArchive sources.
     ; Temporarily kept hbzipold.cpp to serve as reference.
     ; TOFIX: There is a problem with the loop adding new 
              files to the .zip.
This commit is contained in:
Viktor Szakats
2008-09-03 13:55:18 +00:00
parent 5c9d394ac2
commit 9bbe8421de
98 changed files with 1163 additions and 21908 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
harbour/ChangeLog
View File

@@ -8,6 +8,121 @@
2008-12-31 13:59 UTC+0100 Foo Bar (foo.bar foobar.org)
*/
2008-09-03 15:47 UTC+0200 Viktor Szakats (harbour.01 syenar hu)
* contrib/hbziparch/Makefile
* contrib/hbziparch/common.mak
+ contrib/hbziparch/hbziparc.prg
- contrib/hbziparch/hbzipnew.cpp
+ contrib/hbziparch/hbzipold.cpp
* contrib/hbziparch/tests/bld_b32.bat
* contrib/hbziparch/tests/bld_vc.bat
- contrib/hbziparch/Wildcard.h
- contrib/hbziparch/ZipString.h
- contrib/hbziparch/FileInfo.h
- contrib/hbziparch/ZipFileMapping_lnx.h
- contrib/hbziparch/ZipMutex_win.h
- contrib/hbziparch/ZipPathComponent.h
- contrib/hbziparch/Aes.h
- contrib/hbziparch/BaseLibCompressor.cpp
- contrib/hbziparch/zlib
- contrib/hbziparch/ZipCentralDir.h
- contrib/hbziparch/RandomPool.h
- contrib/hbziparch/ZipPathComponent_win.cpp
- contrib/hbziparch/ZipString_stl.h
- contrib/hbziparch/ZipPlatform_win.cpp
- contrib/hbziparch/std_mfc.h
- contrib/hbziparch/DeflateCompressor.h
- contrib/hbziparch/ZipCrc32Cryptograph.h
- contrib/hbziparch/Wildcard.cpp
- contrib/hbziparch/ZipString.cpp
- contrib/hbziparch/FileFilter.h
- contrib/hbziparch/ZipMutex.h
- contrib/hbziparch/ZipCompatibility.cpp
- contrib/hbziparch/ZipFileMapping_win.h
- contrib/hbziparch/ZipExtraData.cpp
- contrib/hbziparch/Sha1.h
- contrib/hbziparch/ZipArchive.cpp
- contrib/hbziparch/ZipFileHeader.h
- contrib/hbziparch/DirEnumerator.cpp
- contrib/hbziparch/DeflateCompressor.cpp
- contrib/hbziparch/ZipBaseException.h
- contrib/hbziparch/std_stl.h
- contrib/hbziparch/_features.h
- contrib/hbziparch/ZipFileMapping.h
- contrib/hbziparch/BaseLibCompressor.h
- contrib/hbziparch/FileFilter.cpp
- contrib/hbziparch/ZipException.h
- contrib/hbziparch/ZipCryptograph.h
- contrib/hbziparch/ZipAbstractFile.h
- contrib/hbziparch/ZipStorage.h
- contrib/hbziparch/ZipStringStoreSettings.h
- contrib/hbziparch/stdafx.h
- contrib/hbziparch/ZipCompatibility.h
- contrib/hbziparch/ZipExtraData.h
- contrib/hbziparch/ZipMemFile.h
- contrib/hbziparch/Hmac.cpp
- contrib/hbziparch/Bzip2Compressor.h
- contrib/hbziparch/ZipExport.h
- contrib/hbziparch/ZipArchive.h
- contrib/hbziparch/ZipExtraField.cpp
- contrib/hbziparch/ZipFileHeader.cpp
- contrib/hbziparch/ZipPlatform.h
- contrib/hbziparch/ZipAesCryptograph.cpp
- contrib/hbziparch/ZipException.cpp
- contrib/hbziparch/ZipCompressor.h
- contrib/hbziparch/ZipFile_stl.cpp
- contrib/hbziparch/DirEnumerator.h
- contrib/hbziparch/ZipCryptograph.cpp
- contrib/hbziparch/ZipStorage.cpp
- contrib/hbziparch/ZipAutoBuffer.h
- contrib/hbziparch/ZipCollections_mfc.h
- contrib/hbziparch/ZipFile_mfc.h
- contrib/hbziparch/resource.h
- contrib/hbziparch/ZipCallbackProvider.h
- contrib/hbziparch/ZipMemFile.cpp
- contrib/hbziparch/Bzip2Compressor.cpp
- contrib/hbziparch/ZipCollections.h
- contrib/hbziparch/ZipFile.h
- contrib/hbziparch/Aes.cpp
- contrib/hbziparch/ZipCentralDir.cpp
- contrib/hbziparch/RandomPool.cpp
- contrib/hbziparch/ZipMutex_lnx.h
- contrib/hbziparch/Hmac.h
- contrib/hbziparch/ZipExtraField.h
- contrib/hbziparch/ZipCompressor.cpp
- contrib/hbziparch/License.txt
- contrib/hbziparch/ZipCrc32Cryptograph.cpp
- contrib/hbziparch/ZipAesCryptograph.h
- contrib/hbziparch/ZipPathComponent_lnx.cpp
- contrib/hbziparch/ZipPlatformComm.cpp
- contrib/hbziparch/ZipString_mfc.h
- contrib/hbziparch/ZipCallback.h
- contrib/hbziparch/ZipAutoBuffer.cpp
- contrib/hbziparch/ZipFile_mfc.cpp
- contrib/hbziparch/ZipCollections_stl.h
- contrib/hbziparch/BytesWriter.h
- contrib/hbziparch/ZipPlatform_lnx.cpp
- contrib/hbziparch/_platform.h
- contrib/hbziparch/ZipFile_stl.h
- contrib/hbziparch/readme.txt
- contrib/hbziparch/Sha1.cpp
+ Added .prg level implementation of old hbziparch interface.
It's based on Toninhos functions sent to the list, but
synced with old interface and extended with new features,
fixes and all the remaining interface functions, and old
doc.
There are some non-implemented stuff, and a couple of
NOTEs and TOFIXes, if someone wants, these can be addressed.
(some not, as hbmzip doesn't support multi-volume archives.)
* Library renamed from hbziparch -> hbziparc to be short
filename. The dir itself will also be renamed so.
* Make files modified to compile on all platforms and to
pull hbmzip to build tests.
- Removed ZipArchive sources.
; Temporarily kept hbzipold.cpp to serve as reference.
; TOFIX: There is a problem with the loop adding new
files to the .zip.
2008-09-03 15:15 UTC+0200 Viktor Szakats (harbour.01 syenar hu)
* contrib/hbziparch/Makefile
* contrib/hbziparch/common.mak

16
harbour/contrib/hbziparch/Aes.cpp
View File

@@ -1,16 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"

14
harbour/contrib/hbziparch/Aes.h
View File

@@ -1,14 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////

44
harbour/contrib/hbziparch/BaseLibCompressor.cpp
View File

@@ -1,44 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "BaseLibCompressor.h"
namespace ZipArchiveLib
{
void CBaseLibCompressor::SetOpaque(void** opaque, const COptions* pOptions)
{
*opaque = pOptions->m_bDetectLibMemoryLeaks ? &m_list : 0;
}
void CBaseLibCompressor::EmptyPtrList()
{
if (m_list.GetCount())
{
// if some memory hasn't been freed due to an error in zlib, so free it now
CZipPtrListIter iter = m_list.GetHeadPosition();
while (m_list.IteratorValid(iter))
delete[] (char*) m_list.GetNext(iter);
}
m_list.RemoveAll();
}
} // namespace

198
harbour/contrib/hbziparch/BaseLibCompressor.h
View File

@@ -1,198 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 BaseLibCompressor.h
* Includes the ZipArchiveLib::CBaseLibCompressor class.
*
*/
#if !defined(ZIPARCHIVE_BASELIBCOMPRESSOR_DOT_H)
#define ZIPARCHIVE_BASELIBCOMPRESSOR_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipExport.h"
#include "ZipCompressor.h"
#include "ZipCollections.h"
#include "ZipException.h"
namespace ZipArchiveLib
{
/**
A base class for compressors that use external libraries, such as zlib or bzip2.
*/
class ZIP_API CBaseLibCompressor : public CZipCompressor
{
public:
/**
Represents options of compressors that use external libraries.
\see
<a href="kb">0610231446|options</a>
\see
CZipArchive::SetCompressionOptions
*/
struct ZIP_API COptions : CZipCompressor::COptions
{
COptions()
{
m_bDetectLibMemoryLeaks = true;
}
/**
\c true, if the ZipArchive Library should detect memory leaks in an external library; \c false otherwise.
Recommended to be set to \c true.
*/
bool m_bDetectLibMemoryLeaks;
};
/**
Initializes a new instance of the CBaseLibCompressor class.
\param pStorage
The current storage object.
*/
CBaseLibCompressor(CZipStorage* pStorage)
:CZipCompressor(pStorage)
{
}
void InitDecompression(CZipFileHeader* pFile, CZipCryptograph* pCryptograph)
{
CZipCompressor::InitDecompression(pFile, pCryptograph);
m_bDecompressionDone = false;
}
~CBaseLibCompressor()
{
EmptyPtrList();
}
protected:
/**
A memory allocation method called by an external library.
\param opaque
Internal data.
\param items
The number of blocks to allocate.
\param size
The size of each block to allocate.
\return
The address of a newly allocated memory.
*/
static void* _zipalloc(void* opaque, UINT items, UINT size)
{
void* p = new char[size * items];
if (opaque)
{
CZipPtrList<void*>* list = (CZipPtrList<void*>*) opaque;
list->AddTail(p);
}
return p;
}
/**
A memory deallocation method called by an external library.
\param opaque
Internal data.
\param address
Memory address to free.
*/
static void _zipfree(void* opaque, void* address)
{
if (opaque)
{
CZipPtrList<void*>* list = (CZipPtrList<void*>*) opaque;
CZipPtrListIter iter = list->Find(address);
if (list->IteratorValid(iter))
list->RemoveAt(iter);
}
delete[] (char*) address;
}
/**
Frees the memory allocated by an external library that hasn't been freed
due to an error in the library (usually never happens).
*/
void EmptyPtrList();
/**
Checks, if \a iErr value is an error code.
\param iErr
The code to check.
\return
\c true, if \a iErr is an error code; \c false otherwise.
*/
virtual bool IsCodeErrorOK(int iErr) const = 0;
/**
Checks, if \a iErr value is an error code and throws an exception, if it is.
\param iErr
The error code.
\note
Throws exceptions.
*/
void CheckForError(int iErr)
{
if (!IsCodeErrorOK(iErr))
ThrowError(iErr, true);
}
/**
Sets an address of internal data used in ZipArchive Library memory allocation and deallocation methods.
\param opaque
Receives an address on the internal data.
\param pOptions
The current decompressor options.
*/
void SetOpaque(void** opaque, const COptions* pOptions);
/**
Signalizes, that the decompression process reached the end of the compressed data. It is internally set by derived classes.
*/
bool m_bDecompressionDone;
private:
typedef CZipPtrList<void*>::iterator CZipPtrListIter;
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (push)
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
#endif
CZipPtrList<void*> m_list; ///< A list holding pointers to the memory areas allocated by an external library.
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning( pop)
#endif
};
} // namespace
#endif

180
harbour/contrib/hbziparch/BytesWriter.h
View File

@@ -1,180 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 BytesWriter.h
* Includes the ZipArchiveLib::CBytesWriter class.
*
*/
#if !defined(ZIPARCHIVE_BYTESWRITER_DOT_H)
#define ZIPARCHIVE_BYTESWRITER_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipCompatibility.h"
namespace ZipArchiveLib
{
/**
Provides implementation for various
buffer operations depending on the current platform and configuration.
*/
class ZIP_API CBytesWriter
{
public:
#ifdef ZIP_ARCHIVE_LITTLE_ENDIAN
/**
Reads \a iCount bytes from \a pSource into \a pDestination.
\param[out] pDestination
The buffer to retrieve data with byte-ordering depending on the machine.
\param[in] pSource
The buffer with little-endian ordered data.
\param iCount
The number of bytes to read.
*/
static void ReadBytes(WORD& uDestination, const char* pSource, int iCount = 2)
{
uDestination = 0;
memcpy(&uDestination, pSource, iCount);
}
static void ReadBytes(DWORD& uDestination, const char* pSource, int iCount = 4)
{
uDestination = 0;
memcpy(&uDestination, pSource, iCount);
}
#ifndef _ZIP_STRICT_U16
static void ReadBytes(int& iDestination, const char* pSource, int iCount)
{
iDestination = 0;
memcpy(&iDestination, pSource, iCount);
}
#endif
/**
Writes \a iCount bytes from \a pSource into \a pDestination.
\param[out] pDestination
The buffer to retrieve little-endian ordered data.
\param[in] pSource
The buffer with byte-ordering depending on the machine.
\param iCount
The number of bytes to write.
*/
static void WriteBytes(char* pDestination, WORD uSource)
{
memcpy(pDestination, &uSource, 2);
}
static void WriteBytes(char* pDestination, DWORD uSource, int iCount = 4)
{
memcpy(pDestination, &uSource, iCount);
}
#ifndef _ZIP_STRICT_U16
static void WriteBytes(char* pDestination, int uSource, int iCount)
{
memcpy(pDestination, &uSource, iCount);
}
#endif
#else
static void ReadBytes(char* pDestination, const char* pSource, int iDestSize, int iCount)
{
int i = iCount - iDestSize;
while (i < 0)
{
*pDestination++ = 0;
i++;
}
for (; i < iCount; i++)
(pDestination)[i] = pSource[iCount - i - 1];
}
static void ReadBytes(WORD& uDestination, const char* pSource, int iCount = 2)
{
ReadBytes((char*)&uDestination, pSource, 2, iCount);
}
static void ReadBytes(DWORD& uDestination, const char* pSource, int iCount = 4)
{
ReadBytes((char*)&uDestination, pSource, 4, iCount);
}
#ifndef _ZIP_STRICT_U16
static void ReadBytes(int& iDestination, const char* pSource, int iCount)
{
ReadBytes((char*)&iDestination, pSource, sizeof(int), iCount);
}
#endif
static void WriteBytes(char* pDestination, WORD uSource)
{
for (int i = 0; i < 2; i++)
pDestination[i] = ((char*)&uSource)[2 - i - 1];
}
static void WriteBytes(char* pDestination, DWORD uSource, int iCount = 4)
{
for (int i = 0; i < iCount; i++)
pDestination[i] = ((char*)&uSource)[4 - i - 1];
}
#ifndef _ZIP_STRICT_U16
static void WriteBytes(char* pDestination, int iSource, int iCount)
{
for (int i = 0; i < iCount; i++)
pDestination[i] = ((char*)&iSource)[sizeof(int) - i - 1];
}
#endif
#endif
static DWORD WriteSafeU32(DWORD uValue)
{
return uValue;
}
#ifdef _ZIP_STRICT_U16
static WORD WriteSafeU16(WORD uValue)
{
return uValue;
}
#else
static WORD WriteSafeU16(int uValue)
{
return (WORD)uValue;
}
#endif
};
}
#endif

16
harbour/contrib/hbziparch/Bzip2Compressor.cpp
View File

@@ -1,16 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"

14
harbour/contrib/hbziparch/Bzip2Compressor.h
View File

@@ -1,14 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////

251
harbour/contrib/hbziparch/DeflateCompressor.cpp
View File

@@ -1,251 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "DeflateCompressor.h"
#include "zlib/deflate.h"
namespace ZipArchiveLib
{
#ifndef DEF_MEM_LEVEL
#if MAX_MEM_LEVEL >= 8
# define DEF_MEM_LEVEL 8
#else
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
#endif
#endif
CDeflateCompressor::CDeflateCompressor(CZipStorage* pStorage)
:CBaseLibCompressor(pStorage)
{
m_stream.zalloc = (zarch_alloc_func)_zipalloc;
m_stream.zfree = (zarch_free_func)_zipfree;
}
void CDeflateCompressor::InitCompression(int iLevel, CZipFileHeader* pFile, CZipCryptograph* pCryptograph)
{
CZipCompressor::InitCompression(iLevel, pFile, pCryptograph);
m_stream.avail_in = (zarch_uInt)0;
m_stream.avail_out = (zarch_uInt)m_pBuffer.GetSize();
m_stream.next_out = (zarch_Bytef*)(char*)m_pBuffer;
m_stream.total_in = 0;
m_stream.total_out = 0;
if (pFile->m_uMethod == methodDeflate)
{
SetOpaque(&m_stream.opaque, &m_options);
int err = zarch_deflateInit2_(&m_stream, iLevel,
Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, ZLIB_VERSION, sizeof(zarch_z_stream));
CheckForError(err);
}
}
void CDeflateCompressor::Compress(const void *pBuffer, DWORD uSize)
{
m_stream.next_in = (zarch_Bytef*)pBuffer;
m_stream.avail_in = uSize;
UpdateFileCrc(pBuffer, uSize);
while (m_stream.avail_in > 0)
{
if (m_stream.avail_out == 0)
{
FlushWriteBuffer();
m_stream.avail_out = m_pBuffer.GetSize();
m_stream.next_out = (zarch_Bytef*)(char*)m_pBuffer;
}
if (m_pFile->m_uMethod == methodDeflate)
{
ZIP_ZLIB_TYPE uTotal = m_stream.total_out;
CheckForError(zarch_deflate(&m_stream, Z_NO_FLUSH));
m_uComprLeft += m_stream.total_out - uTotal;
}
else
{
DWORD uToCopy = (m_stream.avail_in < m_stream.avail_out)
? m_stream.avail_in : m_stream.avail_out;
memcpy(m_stream.next_out, m_stream.next_in, uToCopy);
m_stream.avail_in -= uToCopy;
m_stream.avail_out -= uToCopy;
m_stream.next_in += uToCopy;
m_stream.next_out += uToCopy;
m_stream.total_in += uToCopy;
m_stream.total_out += uToCopy;
m_uComprLeft += uToCopy;
}
}
}
void CDeflateCompressor::FinishCompression(bool bAfterException)
{
m_stream.avail_in = 0;
if (!bAfterException)
{
if (m_pFile->m_uMethod == methodDeflate)
{
int err;
do
{
if (m_stream.avail_out == 0)
{
FlushWriteBuffer();
m_stream.avail_out = m_pBuffer.GetSize();
m_stream.next_out = (zarch_Bytef*)(char*)m_pBuffer;
}
ZIP_SIZE_TYPE uTotal = m_stream.total_out;
err = zarch_deflate(&m_stream, Z_FINISH);
m_uComprLeft += m_stream.total_out - uTotal;
}
while (err == Z_OK);
if (err == Z_STREAM_END)
err = Z_OK;
CheckForError(err);
}
if (m_uComprLeft > 0)
FlushWriteBuffer();
if (m_pFile->m_uMethod == methodDeflate)
CheckForError(zarch_deflateEnd(&m_stream));
// it may be increased by the encrypted header size in CZipFileHeader::PrepareData
m_pFile->m_uComprSize += m_stream.total_out;
m_pFile->m_uUncomprSize = m_stream.total_in;
}
EmptyPtrList();
ReleaseBuffer();
}
void CDeflateCompressor::InitDecompression(CZipFileHeader* pFile, CZipCryptograph* pCryptograph)
{
CBaseLibCompressor::InitDecompression(pFile, pCryptograph);
if (m_pFile->m_uMethod == methodDeflate)
{
SetOpaque(&m_stream.opaque, &m_options);
CheckForError(zarch_inflateInit2_(&m_stream, -MAX_WBITS, ZLIB_VERSION, sizeof(zarch_z_stream)));
}
m_stream.total_out = 0;
m_stream.avail_in = 0;
}
DWORD CDeflateCompressor::Decompress(void *pBuffer, DWORD uSize)
{
if (m_bDecompressionDone)
return 0;
m_stream.next_out = (zarch_Bytef*)pBuffer;
m_stream.avail_out = uSize > m_uUncomprLeft
? (DWORD)m_uUncomprLeft : uSize;
DWORD uRead = 0;
// may happen when the file is 0 sized
bool bForce = m_stream.avail_out == 0 && m_uComprLeft > 0;
while (m_stream.avail_out > 0 || (bForce && m_uComprLeft > 0))
{
if ((m_stream.avail_in == 0) &&
(m_uComprLeft >= 0)) // Also when there are zero bytes left
{
DWORD uToRead = m_pBuffer.GetSize();
if (m_uComprLeft < uToRead)
uToRead = (DWORD)m_uComprLeft;
if (uToRead == 0)
uToRead = 1; // Add dummy byte at end of compressed data.
else
{
m_pStorage->Read(m_pBuffer, uToRead, false);
if (m_pCryptograph)
m_pCryptograph->Decode(m_pBuffer, uToRead);
}
m_uComprLeft -= uToRead;
m_stream.next_in = (zarch_Bytef*)(char*)m_pBuffer;
m_stream.avail_in = uToRead;
}
if (m_pFile->m_uMethod == methodStore)
{
DWORD uToCopy = m_stream.avail_out < m_stream.avail_in
? m_stream.avail_out : m_stream.avail_in;
memcpy(m_stream.next_out, m_stream.next_in, uToCopy);
UpdateCrc(m_stream.next_out, uToCopy);
m_uUncomprLeft -= uToCopy;
m_stream.avail_in -= uToCopy;
m_stream.avail_out -= uToCopy;
m_stream.next_out += uToCopy;
m_stream.next_in += uToCopy;
m_stream.total_out += uToCopy;
uRead += uToCopy;
}
else
{
ZIP_SIZE_TYPE uTotal = m_stream.total_out;
zarch_Bytef* pOldBuf = m_stream.next_out;
int ret = zarch_inflate(&m_stream, Z_SYNC_FLUSH);
// will not exceed DWORD
DWORD uToCopy = (DWORD)(m_stream.total_out - uTotal);
UpdateCrc(pOldBuf, uToCopy);
m_uUncomprLeft -= uToCopy;
uRead += uToCopy;
if (ret == Z_STREAM_END)
{
m_bDecompressionDone = true;
return uRead;
}
else
CheckForError(ret);
}
}
if (!uRead && m_options.m_bCheckLastBlock && uSize != 0 && m_pFile->m_uMethod == methodDeflate)
{
if (zarch_inflate(&m_stream, Z_SYNC_FLUSH) != Z_STREAM_END)
// there were no more bytes to read and there was no ending block,
// otherwise the method would return earlier
ThrowError(CZipException::badZipFile);
}
return uRead;
}
void CDeflateCompressor::FinishDecompression(bool bAfterException)
{
if (!bAfterException && m_pFile->m_uMethod == methodDeflate)
zarch_inflateEnd(&m_stream);
EmptyPtrList();
ReleaseBuffer();
}
} // namespace

148
harbour/contrib/hbziparch/DeflateCompressor.h
View File

@@ -1,148 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 DeflateCompressor.h
* Includes the ZipArchiveLib::CDeflateCompressor class.
*
*/
#if !defined(ZIPARCHIVE_DEFLATECOMPRESSOR_DOT_H)
#define ZIPARCHIVE_DEFLATECOMPRESSOR_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipExport.h"
#include "BaseLibCompressor.h"
#include "ZipException.h"
#include "zlib/zlib.h"
namespace ZipArchiveLib
{
/**
Compresses and decompresses data using the Zlib library.
*/
class ZIP_API CDeflateCompressor : public CBaseLibCompressor
{
public:
/**
Represents options of the CDeflateCompressor.
\see
<a href="kb">0610231446|options</a>
\see
CZipArchive::SetCompressionOptions
*/
struct ZIP_API COptions : CBaseLibCompressor::COptions
{
COptions()
{
m_bCheckLastBlock = true;
}
int GetType() const
{
return typeDeflate;
}
CZipCompressor::COptions* Clone() const
{
return new COptions(*this);
}
/**
Enables or disables checking, if the compressed data ends with an end-of-stream block.
This should be enabled to protect against malformed data.
\c true, if the checking of the last block should be enabled; \c false otherwise.
*/
bool m_bCheckLastBlock;
};
/**
Initializes a new instance of the CDeflateCompressor class.
\param pStorage
The current storage object.
*/
CDeflateCompressor(CZipStorage* pStorage);
bool CanProcess(WORD uMethod) {return uMethod == methodStore || uMethod == methodDeflate;}
void InitCompression(int iLevel, CZipFileHeader* pFile, CZipCryptograph* pCryptograph);
void InitDecompression(CZipFileHeader* pFile, CZipCryptograph* pCryptograph);
DWORD Decompress(void *pBuffer, DWORD uSize);
void Compress(const void *pBuffer, DWORD uSize);
void FinishCompression(bool bAfterException);
void FinishDecompression(bool bAfterException);
const CZipCompressor::COptions* GetOptions() const
{
return &m_options;
}
~CDeflateCompressor()
{
}
protected:
void UpdateOptions(const CZipCompressor::COptions* pOptions)
{
m_options = *(COptions*)pOptions;
}
int ConvertInternalError(int iErr) const
{
switch (iErr)
{
case Z_NEED_DICT:
return CZipException::needDict;
case Z_STREAM_END:
return CZipException::streamEnd;
case Z_ERRNO:
return CZipException::errNo;
case Z_STREAM_ERROR:
return CZipException::streamError;
case Z_DATA_ERROR:
return CZipException::dataError;
case Z_MEM_ERROR:
return CZipException::memError;
case Z_BUF_ERROR:
return CZipException::bufError;
case Z_VERSION_ERROR:
return CZipException::versionError;
default:
return CZipException::genericError;
}
}
bool IsCodeErrorOK(int iErr) const
{
return iErr == Z_OK || iErr == Z_NEED_DICT;
}
private:
COptions m_options;
zarch_z_stream m_stream;
};
} // namespace
#endif

185
harbour/contrib/hbziparch/DirEnumerator.cpp
View File

@@ -1,185 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#if defined _MSC_VER && _MSC_VER < 1300
// STL warnings
#pragma warning (push, 3)
#endif
#include "DirEnumerator.h"
#include "FileFilter.h"
#include <queue>
#if defined __GNUC__ && !defined __MINGW32__
#include <sys/stat.h>
#include <dirent.h>
#else
#include <io.h>
#ifdef __BORLANDC__
#ifndef _tfindfirsti64
#define _tfindfirsti64 __tfindfirsti64
#endif
#ifndef _tfindnexti64
#define _tfindnexti64 __tfindnexti64
#endif
#ifndef _tfinddatai64_t
#define _tfinddatai64_t __tfinddatai64_t
#endif
#endif
#endif
namespace ZipArchiveLib
{
#if defined __GNUC__ && !defined __MINGW32__
#define ZIP_ENUMERATOR_FOR_GNUC
#endif
bool CDirEnumerator::Start(CFileFilter& filter)
{
OnEnumerationBegin();
std::queue<CZipString> dirs;
dirs.push(CZipString(m_lpszDirectory));
bool ret = true;
do
{
m_szCurrentDirectory = dirs.front();
dirs.pop();
CZipPathComponent::AppendSeparator(m_szCurrentDirectory);
EnterDirectory();
#ifdef ZIP_ENUMERATOR_FOR_GNUC
DIR* dp = opendir(m_szCurrentDirectory);
if (dp)
{
while (true)
{
struct dirent* entry = readdir(dp);
if (!entry)
break;
CZipString path(m_szCurrentDirectory + entry->d_name);
#if !defined __APPLE__ && !defined __CYGWIN__
struct stat64 sStats;
if (stat64(path, &sStats) == -1)
#else
struct stat sStats;
if (stat(path, &sStats) == -1)
#endif
continue;
LPCTSTR name = entry->d_name;
CFileInfo info;
info.m_uAttributes = sStats.st_mode;
#else
CZipString szFullFileName = m_szCurrentDirectory + _T("*");
_tfinddatai64_t ffInfo;
#if _MSC_VER > 1200
intptr_t hFile;
#else
long hFile;
#endif
if( (hFile = _tfindfirsti64( (LPTSTR)(LPCTSTR)szFullFileName, &ffInfo )) != -1L )
{
do
{
LPCTSTR name = ffInfo.name;
CFileInfo info;
info.m_uAttributes = ffInfo.attrib;
#endif
bool isDir;
if (ZipPlatform::IsDirectory(info.m_uAttributes))
{
if (!m_bRecursive || IsDots(name))
continue;
isDir = true;
}
else
isDir = false;
#ifdef ZIP_ENUMERATOR_FOR_GNUC
info.m_uSize = (ZIP_FILE_USIZE)sStats.st_size;
info.m_uCreateTime = sStats.st_ctime;
info.m_uModTime = sStats.st_mtime;
info.m_uAccessTime = sStats.st_atime;
#else
info.m_uSize = (ZIP_FILE_USIZE)ffInfo.size;
info.m_uCreateTime = ffInfo.time_create;
info.m_uModTime = ffInfo.time_write;
info.m_uAccessTime = ffInfo.time_access;
CZipString path(m_szCurrentDirectory + ffInfo.name);
#endif
if (isDir)
{
bool bAllow;
if (filter.HandlesFile(info))
bAllow = filter.Evaluate(path, name, info);
else
// examine directory, if the filter cannot decide
bAllow = true;
if (bAllow)
dirs.push(path);
}
else
{
bool bAllow;
if (filter.HandlesFile(info))
bAllow = filter.Evaluate(path, name, info);
else
// skip file, if the filter cannot decide
bAllow = false;
if (bAllow && !Process(path, info))
{
ret = false;
break;
}
}
#ifdef ZIP_ENUMERATOR_FOR_GNUC
}
closedir(dp);
}
#else
}
while (_tfindnexti64(hFile, &ffInfo) == 0L);
_findclose(hFile);
}
#endif
ExitDirectory();
}
while(!dirs.empty() && ret);
OnEnumerationEnd(ret);
return ret;
}
bool CDirEnumerator::IsDots(LPCTSTR lpszName)
{
CZipString name(lpszName);
return name.Compare(_T(".")) == 0 || name.Compare(_T("..")) == 0;
}
} // namespace
#if defined _MSC_VER && _MSC_VER < 1300
// STL warnings
#pragma warning (pop)
#endif

198
harbour/contrib/hbziparch/DirEnumerator.h
View File

@@ -1,198 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 DirEnumerator.h
* Includes the ZipArchiveLib::CDirEnumerator class.
*
*/
#if !defined(ZIPARCHIVE_DIRENUMERATOR_DOT_H)
#define ZIPARCHIVE_DIRENUMERATOR_DOT_H
#if _MSC_VER > 1000
#pragma once
#pragma warning( push )
#pragma warning (disable : 4100) // unreferenced formal parameter
#if defined ZIP_HAS_DLL
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
#endif
#endif
#include "ZipString.h"
#include "ZipPathComponent.h"
#include "FileFilter.h"
/**
Includes helper classes. Some of them can be reused in other applications.
*/
namespace ZipArchiveLib
{
/**
A base class for processing multiple files in a directory.
It provides a directory enumeration functionality.
*/
class ZIP_API CDirEnumerator
{
LPCTSTR m_lpszDirectory;
LPCTSTR m_lpszFileNameMask;
bool m_bRecursive;
CZipString m_szCurrentDirectory;
protected:
/**
Initializes a new CDirEnumerator object.
\param lpszDirectory
A directory to process.
\param bRecursive
The value indicating whether the subfolders of \a lpszDirectory
should be processed recursively or not.
\see
GetDirectory
\see
IsRecursive
*/
CDirEnumerator(LPCTSTR lpszDirectory, bool bRecursive = true)
{
CZipString dir(lpszDirectory);
if (dir.IsEmpty())
m_lpszDirectory = _T(".");
else
m_lpszDirectory = lpszDirectory;
m_bRecursive = bRecursive;
}
/**
Override this method to perform file processing while enumerating directories.
This method is not called for directories, but for files only.
\param lpszPath
The full path to the current file.
\param info
A structure containing an information about the current file.
\return
Return \c true to continue the enumeration.
When you return \c false, the enumeration is aborted.
\see
CFileFilter::Evaluate
*/
virtual bool Process(LPCTSTR lpszPath, const CFileInfo& info) = 0;
/**
This method is called at the beginning of the enumeration process.
\see
OnEnumerationEnd
*/
virtual void OnEnumerationBegin(){}
/**
This method is called at the end of the enumeration process.
\param bResult
It is set to \c false, if the #Process method returned \c false (the enumeration
was aborted). Otherwise, it is set to \c true.
\see
OnEnumerationBegin
*/
virtual void OnEnumerationEnd(bool bResult){}
/**
This method is called when an enumeration process enters a new directory.
\see
GetCurrentDirectory
\see
ExitDirectory
*/
virtual void EnterDirectory(){}
/**
This method is method called when an enumeration process exits a directory.
\see
GetCurrentDirectory
\see
EnterDirectory
*/
virtual void ExitDirectory(){}
public:
/**
Returns the directory being enumerated.
\return
The directory being enumerated (root).
\see
CDirEnumerator::CDirEnumerator
*/
LPCTSTR GetDirectory() const {return m_lpszDirectory;}
/**
Returns the value indicating whether the subfolders of the root directory
are processed recursively or not.
\return
\c true, if the enumeration process is recursive; \c false otherwise.
\see
CDirEnumerator::CDirEnumerator
*/
bool IsRecursive() const {return m_bRecursive;}
/**
Returns the directory which the enumeration process is currently processing.
\return
The directory which the enumeration process is currently processing.
*/
LPCTSTR GetCurrentDirectory() const {return m_szCurrentDirectory;}
/**
Starts the enumeration process. Calls CFileFilter::Evaluate method for every file or directory found.
If CFileFilter::Evaluate returns \c true, the file is processed by the #Process method.
\param filter
A filter that decides which directories and/or files should be processed and which should not.
\return
\c false, if the process was aborted (the #Process method returned \c false); \c true otherwise.
\see
CFileFilter::Evaluate
*/
bool Start(CFileFilter& filter);
virtual ~CDirEnumerator(){}
private:
static bool IsDots(LPCTSTR lpszName);
};
}
#if _MSC_VER > 1000
#pragma warning( pop )
#endif
#endif

60
harbour/contrib/hbziparch/FileFilter.cpp
View File

@@ -1,60 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#if defined _MSC_VER && _MSC_VER < 1300
// STL warnings
#include "stdafx.h"
#pragma warning (push, 3)
#endif
#include "FileFilter.h"
namespace ZipArchiveLib
{
bool CGroupFileFilter::Accept(LPCTSTR lpszParentDir, LPCTSTR lpszName, const CFileInfo& info)
{
bool conditionToBreak;
bool valueToReturn;
// handle the evaluation as quickly as possible
if (m_iType == CGroupFileFilter::And)
{
conditionToBreak = false;
valueToReturn = m_bInverted;
}
else
{
conditionToBreak = true;
valueToReturn = !m_bInverted;
}
for (ZIP_ARRAY_SIZE_TYPE i = 0; i < m_filters.GetSize(); i++)
{
CFileFilter* pFilter = m_filters[i];
if (pFilter->HandlesFile(info) && pFilter->Evaluate(lpszParentDir, lpszName, info) == conditionToBreak)
return valueToReturn;
}
return !valueToReturn;
}
} // namespace
#if defined _MSC_VER && _MSC_VER < 1300
// STL warnings
#pragma warning (pop)
#endif

657
harbour/contrib/hbziparch/FileFilter.h
View File

@@ -1,657 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 FileFilter.h
* Includes the ZipArchiveLib::CFileFilter and the derived classes.
*
*/
#if !defined(ZIPARCHIVE_FILEFILTER_DOT_H)
#define ZIPARCHIVE_FILEFILTER_DOT_H
#if _MSC_VER > 1000
#pragma once
#pragma warning( push )
#pragma warning (disable : 4100) // unreferenced formal parameter
#endif
#include "stdafx.h"
#include "ZipExport.h"
#include "FileInfo.h"
#include "Wildcard.h"
#include "ZipPlatform.h"
#include "ZipCollections.h"
namespace ZipArchiveLib
{
/**
A base class for filters used in the directory enumeration process.
\see
<a href="kb">0610231446|filters</a>
\see
CDirEnumerator::Start
*/
class ZIP_API CFileFilter
{
public:
/**
Initializes a new instance of the CFileFilter class.
\param bInverted
Set to \c true to invert the behavior of the filter or to \c false for the normal behavior.
\see
SetInverted
*/
CFileFilter(bool bInverted = false)
:m_bInverted(bInverted)
{
}
/**
This method is directly called by the CDirEnumerator::Start for each file or directory that was
previously accepted with the #HandlesFile method.
It internally calls the #Accept method and inverts it's result, if the filter is in the inverted
mode and does not handle the inversion internally.
- If this method returns \c true for a file, then the file is processed (the CDirEnumerator::Process method
is called for the file). Otherwise the file is not processed.
- If this method returns \c true for a directory, then the directory can be traversed for files and subfolders
(depending on the CDirEnumerator::IsRecursive() method). Otherwise the directory is not traversed.
\param lpszParentDir
The parent directory containing the file to accept.
\param lpszName
The name of the file to accept (without a path).
\param info
A structure containing the information about the current file.
\return
\c true, if the file is accepted (taking inversion into account); \c false otherwise.
\see
Accept
\see
HandlesFile
\see
HandlesInversion
\see
SetInverted
\see
IsInverted
\see
CDirEnumerator::Start
\see
CDirEnumerator::Process
*/
bool Evaluate(LPCTSTR lpszParentDir, LPCTSTR lpszName, const CFileInfo& info)
{
bool ret = Accept(lpszParentDir, lpszName, info);
if (!HandlesInversion())
return m_bInverted ? !ret : ret;
return ret;
}
/**
Sets the filter to operate in the inverted or in the normal mode.
If the filter operates in an inverted mode, the file that this filer accepts
is \b not processed and vice versa. Normal mode means that a file is processed
(the CDirEnumerator::Process method is called for that file),
if the filter accepts the file.
\param bInverted
\c true to make the filter operate in an inverted mode or \c false to make
the filter operate in a normal mode.
\see
HandlesInversion
\see
IsInverted
*/
void SetInverted(bool bInverted = true) { m_bInverted = bInverted;}
/**
Returns the value indicating whether the filter operates in an inverted mode or in a normal mode.
\return
\c true, if the filter operates in an inverted mode; \c false otherwise.
\see
SetInverted
\see
HandlesInversion
*/
bool IsInverted() const {return m_bInverted;}
/**
Returns the value indicating whether the filter can decide about processing of the \a info file.
If it can, then the #Evaluate method will be called for the \a info file.
By default this method returns \c true for files and \c false for directories. Override this method
to change it's behavior.
- If \a info is a file and this method returns \c false, then the file is not processed.
- If \a info is a directory and this method returns \c false, then the directory can still be traversed for files
and subfolders (depending on the CDirEnumerator::IsRecursive() method).
The #Evaluate method is not called in both cases.
\param info
A structure containing the information about the file.
\return
\c true, if the \a info file should be evaluated by the #Evaluate method; \c false otherwise.
\note
This method is particularly useful when the filter operates in the inverted mode (see #SetInverted).
For example, if a filter should accept directories in both inverted and non-inverted mode, it would need
to particularly handle inversion for directories without this method. With this method it can just not accept
directories for evaluation and they still will be traversed.
*/
virtual bool HandlesFile(const CFileInfo& info)
{
return !info.IsDirectory();
}
virtual ~CFileFilter()
{
}
protected:
/**
This method is directly called by the #Evaluate method during an enumeration process.
If this method returns \c true, the file will later be processed
by the CDirEnumerator::Process method. If this method returns \c false for a directory,
the directory is not enumerated at all.
The meaning of the return value can be reversed by the #SetInverted method.
If this filter handles the inversion internally, the return value from this method
is not reversed by the #Evaluate method.
\param lpszParentDir
The parent directory containing the file to accept.
\param lpszName
The name of the file to accept (without a path).
\param info
A structure containing the information about the current file.
\return
\c true, if the file is accepted; \c false otherwise.
\see
Evaluate
\see
HandlesInversion
\see
CDirEnumerator::Start
\see
CDirEnumerator::Process
*/
virtual bool Accept(LPCTSTR lpszParentDir, LPCTSTR lpszName, const CFileInfo& info)
{
return true;
}
/**
Returns the value indicating, whether the current filter handles the inversion mode internally
or not.
- If the filter is in the inverted mode and it handles the inversion, then the return value \c true
from the #Accept method means that the file should be processed.
- If the filter is in the inverted mode and it does not handle the inversion, then the return value \c true
from the #Accept method means that the file should not be processed.
It may be more efficient to handle the inversion internally in some cases.
\return
\c true, if the filter handles the inversion internally; \c false otherwise.
\note
This method returns \c false by default. Override this method to change this behavior.
\see
SetInverted
\see
IsInverted
*/
virtual bool HandlesInversion() const
{
return false;
}
bool m_bInverted;
};
/**
A filter that allows filtering files by a filename mask while an enumeration process.
\see
<a href="kb">0610231446|filters</a>
\see
<a href="kb">0610242025|wildcards</a>
\see
CDirEnumerator::Start
*/
class ZIP_API CNameFileFilter : public CFileFilter
{
CWildcard m_matcher;
int m_iAppliesToTypes;
public:
/**
The file type to which the CNameFileFilter filter can be applied.
You can use the logical \c OR to combine them.
\see
SetAppliesToTypes
\see
GetAppliesToTypes
*/
enum AppliesToTypes
{
toFile = 0x1, ///< Regular files only.
toDirectory = 0x2, ///< Directories only.
toAll = toFile | toDirectory ///< Both regular files and directories.
};
/**
Initializes a new instance of the CNameFileFilter class.
\param lpszPattern
A mask to match against a filename. This filter uses the CWildcard functionality for this purpose.
\param iAppliesToTypes
The file type to which this filter applies. The file type to which this filter applies. Can be one or more of the #AppliesToTypes values.
\param bInverted
Set to \c true to invert the behavior of the filter or to \c false for the normal behavior.
\param bCaseSensitive
\c true, if the matching process is case-sensitive; \c false otherwise.
By default, a system case-sensitivity setting is used.
\see
<a href="kb">0610231446|filters</a>
\see
<a href="kb">0610242025|wildcards</a>
\see
SetInverted
\see
SetAppliesToTypes
\see
CWildcard
\see
ZipPlatform::GetSystemCaseSensitivity
*/
CNameFileFilter(LPCTSTR lpszPattern = _T("*.*"), bool bInverted = false, int iAppliesToTypes = toFile, bool bCaseSensitive = ZipPlatform::GetSystemCaseSensitivity())
:CFileFilter(bInverted), m_matcher(lpszPattern, bCaseSensitive)
{
m_iAppliesToTypes = iAppliesToTypes;
}
/**
Returns the value indicating whether the filter can be applied to the given \a iType type.
\param iType
Can be one or more of the #AppliesToTypes values.
\return
\c true, if the filter can be applied to \a iType type; \c false otherwise.
\see
SetAppliesToTypes
\see
GetAppliesToTypes
*/
bool AppliesToType(int iType)
{
return (m_iAppliesToTypes & iType) == iType;
}
/**
Set the file type to which this filter applies.
\param iType
The file type to which this filter applies. Can be one or more of the #AppliesToTypes values.
\see
GetAppliesToTypes
*/
void SetAppliesToTypes(int iType) { m_iAppliesToTypes = iType; }
/**
Return the file type to which this filter applies.
\return
The file type to which this filter applies. Can be one or more of the #AppliesToTypes values.
\see
SetAppliesToTypes
*/
int GetAppliesToTypes() {return m_iAppliesToTypes;}
/**
Returns the value indicating whether the filter can decide about processing of the \a info file.
The CNameFileFilter returns the value depending on the #GetAppliesToTypes value.
\param info
A structure containing the information about the file.
\return
\c true, if the \a info file will be evaluated by the #Evaluate method; \c false otherwise.
\see
GetAppliesToTypes
\see
SetAppliesToTypes
*/
bool HandlesFile(const CFileInfo& info)
{
return info.IsDirectory() ? AppliesToType(toDirectory) : AppliesToType(toFile);
}
protected:
virtual bool Accept(LPCTSTR, LPCTSTR lpszName, const CFileInfo& info)
{
return m_matcher.IsMatch(lpszName);
}
};
/**
A filter that allows grouping of other filters.
\see
<a href="kb">0610231446|filters</a>
\see
CDirEnumerator::Start
*/
class ZIP_API CGroupFileFilter : public CFileFilter
{
public:
/**
The grouping type.
*/
enum GroupType
{
And, ///< Logical AND. All the grouped filters must accept a file for the file to be processed.
Or ///< Logical OR. At least one of the grouped filters must accept a file for the file to be processed.
};
/**
Initializes a new instance of the CGroupFileFilter class.
\param groupType
The grouping type. Should be one of the #GroupType values.
\param bAutoDelete
\c true, if the grouped filters should be automatically destroyed by this filter; \c false otherwise.
\param bInverted
Set to \c true to invert the behavior of the filter or to \c false for the normal behavior.
This filter handles the inversion mode internally.
\see
<a href="kb">0610231446|filters</a>
\see
SetType
\see
SetAutoDelete
\see
SetInverted
\see
HandlesInversion
*/
CGroupFileFilter(GroupType groupType = CGroupFileFilter::And, bool bAutoDelete = true, bool bInverted = false)
:CFileFilter(bInverted), m_iType(groupType), m_bAutoDelete(bAutoDelete)
{
}
/**
Add \a pFilter to the filter's group.
\param pFilter
The filter to add.
*/
void Add(CFileFilter* pFilter)
{
m_filters.Add(pFilter);
}
/**
Returns the filter at the given position.
\param uIndex
The index of the filter to return.
*/
CFileFilter* GetAt(ZIP_ARRAY_SIZE_TYPE uIndex)
{
return m_filters[uIndex];
}
/**
Returns the filter at the given position.
\param uIndex
The index of the filter to return.
*/
const CFileFilter* GetAt(ZIP_ARRAY_SIZE_TYPE uIndex) const
{
return m_filters[uIndex];
}
/**
Returns the filter at the given position.
\param uIndex
The index of the filter to return.
*/
const CFileFilter* operator[] (ZIP_ARRAY_SIZE_TYPE uIndex) const
{
return GetAt(uIndex);
}
/**
Returns the filter at the given position.
\param uIndex
The index of the filter to return.
*/
CFileFilter* operator[] (ZIP_ARRAY_SIZE_TYPE uIndex)
{
return GetAt(uIndex);
}
/**
Remove the filter at the given position.
The removed filter is deleted from memory,
if the CGroupFileFilter object is in the auto-delete mode.
\param uIndex
The index of the filter to remove.
\see
SetAutoDelete
*/
void RemoveAt(ZIP_ARRAY_SIZE_TYPE uIndex)
{
CFileFilter* filter = m_filters[uIndex];
// first remove, then delete
m_filters.RemoveAt(uIndex);
if (m_bAutoDelete)
delete filter;
}
/**
Removes all contained filters from the collection.
The removed filters are deleted from memory,
if the CGroupFileFilter object is in the auto-delete mode.
\see
SetAutoDelete
*/
void Clear()
{
if (m_filters.GetSize() == 0)
return;
ZIP_ARRAY_SIZE_TYPE i = m_filters.GetSize() - 1;
for (; ;)
{
RemoveAt(i);
if (i == 0)
break;
i--;
}
}
/**
Returns the number of grouped filters.
\return
The number of grouped filters.
*/
ZIP_ARRAY_SIZE_TYPE GetSize()
{
return m_filters.GetSize();
}
/**
Sets the type of grouping.
\param iType
The type of grouping. Should be one of the #GroupType values.
\see
GetType
*/
void SetType(GroupType iType) {m_iType = iType;}
/**
Returns the type of grouping.
\return
The type of groupgroupeding. Can be one of the #GroupType values.
\see
SetType
*/
GroupType GetType() const {return m_iType;}
/**
Enable or disable auto-deletion of grouped filters.
If auto-deletion is enabled, the grouped filters are released from memory
when they are removed from the group or when the CGroupFileFilter
object is destroyed.
\param bAutoDelete
\c true, to enable auto-deletion; \c false to disable.
\see
IsAutoDelete
*/
void SetAutoDelete(bool bAutoDelete) {m_bAutoDelete = bAutoDelete;}
/**
Return the value indicating whether the auto-deletion is enabled or not.
\return
\c true, if the auto-deletion is enabled; \c false otherwise.
\see
SetAutoDelete
*/
bool IsAutoDelete() const {return m_bAutoDelete;}
/**
Returns the value indicating whether the filter can decide about processing of the \a info file.
The CGroupFileFilter returns the value depending on the value returned by the grouped filters.
\param info
A structure containing the information about the file.
\return
\c true, if any of the grouped filters accepts \a info; \c false otherwise.
*/
bool HandlesFile(const CFileInfo& info)
{
for (ZIP_ARRAY_SIZE_TYPE i = 0; i < m_filters.GetSize(); i++)
// it is enough that one filter handles it
if (m_filters[i]->HandlesFile(info))
return true;
return false;
}
~CGroupFileFilter()
{
Clear();
}
protected:
virtual bool Accept(LPCTSTR lpszParentDir, LPCTSTR lpszName, const CFileInfo& info);
/**
This filter handles inversion internally.
\return
This method returns \c true for this class.
\see
CFileFilter::HandlesInversion
*/
bool HandlesInversion() const
{
return true;
}
GroupType m_iType; ///< Set with the #SetType method or in constructor.
bool m_bAutoDelete; ///< Set with the #SetAutoDelete or in constructor.
private:
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (push)
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
#endif
CZipArray<CFileFilter*> m_filters;
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning( pop)
#endif
};
}
#if _MSC_VER > 1000
#pragma warning( pop )
#endif
#endif

69
harbour/contrib/hbziparch/FileInfo.h
View File

@@ -1,69 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 FileInfo.h
* Includes the ZipArchiveLib::CFileInfo class.
*
*/
#if !defined(ZIPARCHIVE_FILEINFO_DOT_H)
#define ZIPARCHIVE_FILEINFO_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "stdafx.h"
#include "ZipExport.h"
#include "ZipPlatform.h"
namespace ZipArchiveLib
{
/**
A structure holding a file or a directory information.
*/
struct ZIP_API CFileInfo
{
public:
/**
Initializes a new instance of the CFileInfo class.
*/
CFileInfo()
{
m_uSize = 0;
m_uAttributes = 0;
m_uCreateTime = m_uModTime = m_uAccessTime = 0;
}
ZIP_FILE_USIZE m_uSize; ///< The file size.
DWORD m_uAttributes; ///< The file system attributes.
time_t m_uCreateTime; ///< Creation time.
time_t m_uModTime; ///< Last modification time.
time_t m_uAccessTime; ///< Last access time.
/**
Returns the value indicating whether the current CFileInfo
object represents a directory or a regular file.
\return
\c true, if the current CFileInfo object represents
a directory; \c false, if it represents a regular file.
*/
bool IsDirectory() const
{
return ZipPlatform::IsDirectory(m_uAttributes);
}
};
}
#endif

16
harbour/contrib/hbziparch/Hmac.cpp
View File

@@ -1,16 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"

14
harbour/contrib/hbziparch/Hmac.h
View File

@@ -1,14 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////

284
harbour/contrib/hbziparch/License.txt
View File

@@ -1,284 +0,0 @@
The ZipArchive Library is Copyrighted 2000 - 2007 by Artpol Software - Tadeusz Dracz
For the licensing details, please visit:
http://www.artpol-software.com/ZipArchive/KB/license.aspx
------------------------------------------------------------------
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS

71
harbour/contrib/hbziparch/Makefile
View File

@@ -4,76 +4,9 @@
ROOT = ../../
LIBNAME=hbziparch
ifeq ($(HB_WITH_ZIPARCH),)
ifeq ($(HB_ARCHITECTURE),w32)
HB_WITH_ZIPARCH=yes
endif
ifeq ($(HB_ARCHITECTURE),linux)
HB_WITH_ZIPARCH=yes
endif
endif
ifeq ($(HB_WITH_ZIPARCH),yes)
PRG_HEADERS = \
C_SOURCES = \
CPP_SOURCES = \
hbzipnew.cpp \
\
Aes.cpp \
BaseLibCompressor.cpp \
Bzip2Compressor.cpp \
DeflateCompressor.cpp \
DirEnumerator.cpp \
FileFilter.cpp \
Hmac.cpp \
RandomPool.cpp \
Sha1.cpp \
Wildcard.cpp \
ZipAesCryptograph.cpp \
ZipArchive.cpp \
ZipAutoBuffer.cpp \
ZipCentralDir.cpp \
ZipCompatibility.cpp \
ZipCompressor.cpp \
ZipCrc32Cryptograph.cpp \
ZipCryptograph.cpp \
ZipException.cpp \
ZipExtraData.cpp \
ZipExtraField.cpp \
ZipFile_stl.cpp \
ZipFileHeader.cpp \
ZipMemFile.cpp \
ZipPlatformComm.cpp \
ZipStorage.cpp \
ZipString.cpp \
# ZipFile_mfc.cpp \
ifeq ($(HB_ARCHITECTURE),w32)
CPP_SOURCES += \
ZipPathComponent_win.cpp \
ZipPlatform_win.cpp \
else
CPP_SOURCES += \
ZipPathComponent_lnx.cpp \
ZipPlatform_lnx.cpp \
endif
PRG_SOURCES= \
hbziparc.prg \
ifeq ($(HB_ARCHITECTURE),linux)
C_USR += -DZIP_ARCHIVE_LNX
endif
LIBNAME=hbziparc
include $(TOP)$(ROOT)config/lib.cf
else
include $(TOP)$(ROOT)config/none.cf
endif

16
harbour/contrib/hbziparch/RandomPool.cpp
View File

@@ -1,16 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"

14
harbour/contrib/hbziparch/RandomPool.h
View File

@@ -1,14 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////

16
harbour/contrib/hbziparch/Sha1.cpp
View File

@@ -1,16 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"

14
harbour/contrib/hbziparch/Sha1.h
View File

@@ -1,14 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////

401
harbour/contrib/hbziparch/Wildcard.cpp
View File

@@ -1,401 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Wildcard.h"
namespace ZipArchiveLib
{
bool CWildcard::IsPatternValid(LPCTSTR lpszPattern, int* iErrorType)
{
try
{
/* loop through pattern to EOS */
while (*lpszPattern)
{
/* determine pattern type */
switch (*lpszPattern)
{
/* check literal escape, it cannot be at end of pattern */
case _T('\\'):
if (!*++lpszPattern)
throw patternEsc;
lpszPattern++;
break;
/* the [..] construct must be well formed */
case _T('['):
lpszPattern++;
/* if the next character is ']' then bad pattern */
if (*lpszPattern == _T(']'))
throw patternEmpty;
/* if end of pattern here then bad pattern */
if (!*lpszPattern)
throw patternClose;
/* loop to end of [..] construct */
while (*lpszPattern != _T(']'))
{
/* check for literal escape */
if (*lpszPattern == _T('\\'))
{
lpszPattern++;
/* if end of pattern here then bad pattern */
if (!*lpszPattern++)
throw patternEsc;
}
else lpszPattern++;
/* if end of pattern here then bad pattern */
if (!*lpszPattern)
throw patternClose;
/* if this a range */
if (*lpszPattern == _T('-'))
{
/* we must have an end of range */
if (!*++lpszPattern || *lpszPattern == ']')
throw patternRange;
else
{
/* check for literal escape */
if (*lpszPattern == _T('\\'))
lpszPattern++;
/* if end of pattern here
then bad pattern */
if (!*lpszPattern++)
throw patternEsc;
}
}
}
break;
/* all other characters are valid pattern elements */
case '*':
case '?':
default:
lpszPattern++; /* "normal" character */
break;
}
}
throw patternValid;
}
catch (int i)
{
if (iErrorType)
*iErrorType = i;
return i == patternValid;
}
}
bool CWildcard::IsPattern(LPCTSTR lpszPattern)
{
while (*lpszPattern)
{
switch (*lpszPattern++)
{
case _T('?'):
case _T('*'):
case _T('['):
case _T('\\'):
return true;
}
}
return false;
}
bool CWildcard::IsMatch(LPCTSTR lpszText, int *iRetCode)
{
CZipString sz;
if (!m_bCaseSensitive)
{
sz = lpszText;
sz.MakeLower();
lpszText = (LPCTSTR)sz;
}
int i = Match((LPCTSTR)m_szPattern, lpszText);
if (iRetCode)
*iRetCode = i;
return i == matchValid;
}
int CWildcard::MatchAfterStar(LPCTSTR p, LPCTSTR t)
{
int iMatch = matchNone;
TCHAR nextp;
/* pass over existing ? and * in pattern */
while ( *p == _T('?') || *p == _T('*') )
{
/* take one char for each ? and + */
if (*p == _T('?'))
{
/* if end of text then no match */
if (!*t++)
return matchAbort;
}
/* move to next char in pattern */
p++;
}
/* if end of pattern we have matched regardless of text left */
if (!*p)
return matchValid;
/* get the next character to match which must be a literal or '[' */
nextp = *p;
if (nextp == _T('\\'))
{
nextp = p[1];
/* if end of text then we have a bad pattern */
if (!nextp)
return matchPattern;
}
/* Continue until we run out of text or definite result seen */
do
{
/* a precondition for matching is that the next character
in the pattern match the next character in the text or that
the next pattern char is the beginning of a range. Increment
text pointer as we go here */
if (nextp == *t || nextp == _T('['))
iMatch = Match(p, t);
/* try finding another precondition */
if (iMatch == matchPattern)
iMatch = matchNone;
/* if the end of text is reached then no iMatch */
if (!*t++)
iMatch = matchAbort;
} while ( iMatch != matchValid &&
iMatch != matchAbort);
/* return result */
return iMatch;
}
int CWildcard::Match(LPCTSTR lpszPattern, LPCTSTR lpszText)
{
TCHAR range_start, range_end; /* start and end in range */
bool bInvert; /* is this [..] or [!..] */
bool bMemberMatch; /* have I matched the [..] construct? */
bool bLoop; /* should I terminate? */
for ( ; *lpszPattern; lpszPattern++, lpszText++)
{
/* if this is the end of the text
then this is the end of the match */
if (!*lpszText)
{
if ( *lpszPattern == _T('*') && *++lpszPattern == _T('\0') )
return matchValid;
else
return matchAbort;
}
/* determine and react to pattern type */
switch (*lpszPattern)
{
case _T('?'): /* single any character match */
break;
case _T('*'): /* multiple any character match */
return MatchAfterStar (lpszPattern, lpszText);
/* [..] construct, single member/exclusion character match */
case _T('['):
{
/* move to beginning of range */
lpszPattern++;
/* check if this is a member match or exclusion match */
bInvert = false;
if (*lpszPattern == _T('!') || *lpszPattern == _T('^'))
{
bInvert = true;
lpszPattern++;
}
/* if closing bracket here or at range start then we have a
malformed pattern */
if (*lpszPattern == _T(']'))
return matchPattern;
bMemberMatch = false;
bLoop = true;
while (bLoop)
{
/* if end of construct then bLoop is done */
if (*lpszPattern == _T(']'))
{
bLoop = false;
continue;
}
/* matching a '!', '^', '-', '\' or a ']' */
if (*lpszPattern == _T('\\'))
range_start = range_end = *++lpszPattern;
else
range_start = range_end = *lpszPattern;
/* if end of pattern then bad pattern (Missing ']') */
if (!*lpszPattern)
return matchPattern;
/* check for range bar */
if (*++lpszPattern == _T('-'))
{
/* get the range end */
range_end = *++lpszPattern;
/* if end of pattern or construct
then bad pattern */
if (range_end == _T('\0') || range_end == _T(']'))
return matchPattern;
/* special character range end */
if (range_end == _T('\\'))
{
range_end = *++lpszPattern;
/* if end of text then
we have a bad pattern */
if (!range_end)
return matchPattern;
}
/* move just beyond this range */
lpszPattern++;
}
/* if the text character is in range then match found.
make sure the range letters have the proper
relationship to one another before comparison */
if (range_start < range_end)
{
if (*lpszText >= range_start && *lpszText <= range_end)
{
bMemberMatch = true;
bLoop = false;
}
}
else
{
if (*lpszText >= range_end && *lpszText <= range_start)
{
bMemberMatch = true;
bLoop = false;
}
}
}
/* if there was a match in an exclusion set then no match */
/* if there was no match in a member set then no match */
if ((bInvert && bMemberMatch) || !(bInvert || bMemberMatch))
return matchRange;
/* if this is not an exclusion then skip the rest of
the [...] construct that already matched. */
if (bMemberMatch)
{
while (*lpszPattern != _T(']'))
{
/* bad pattern (Missing ']') */
if (!*lpszPattern)
return matchPattern;
/* skip exact match */
if (*lpszPattern == _T('\\'))
{
lpszPattern++;
/* if end of text then
we have a bad pattern */
if (!*lpszPattern)
return matchPattern;
}
/* move to next pattern char */
lpszPattern++;
}
}
break;
}
case _T('\\'): /* next character is quoted and must match exactly */
/* move pattern pointer to quoted char and fall through */
lpszPattern++;
/* if end of text then we have a bad pattern */
if (!*lpszPattern)
return matchPattern;
/* must match this character exactly */
default:
if (*lpszPattern != *lpszText)
return matchPattern;
}
}
/* if end of text not reached then the pattern fails */
if (*lpszText)
return matchEnd;
else
return matchValid;
}
} // namespace

195
harbour/contrib/hbziparch/Wildcard.h
View File

@@ -1,195 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
/*
This class is based on code by J. Kercheval, created 01/05/1991
and available as a public domain at http://www.snippets.org.
*/
/**
* \file Wildcard.h
* Includes the ZipArchiveLib::CWildcard class.
*
*/
#if !defined(ZIPARCHIVE_WILDCARD_DOT_H)
#define ZIPARCHIVE_WILDCARD_DOT_H
#if _MSC_VER > 1000
#pragma once
#if (_MSC_VER > 1000) && (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 "ZipString.h"
namespace ZipArchiveLib
{
/**
A class used in the wildcard pattern matching.
\see
<a href="kb">0610242025|wildcards</a>
*/
class ZIP_API CWildcard
{
public:
enum Match
{
matchNone, ///< For internal use.
matchValid, ///< Valid match.
matchEnd, ///< Premature end of the pattern string.
matchAbort, ///< Premature end of the text string.
matchRange, ///< Match failure on the \c [..] construct.
matchLiteral, ///< Match failure on a literal match
matchPattern ///< Bad pattern.
};
enum Pattern
{
patternEmpty = -4, ///< The \c [..] construct is empty
patternClose, ///< There is no end bracket in the \c [..] construct.
patternRange, ///< Malformed range in the \c [..] construct.
patternEsc, ///< Literal escape at the end of the pattern.
patternValid, ///< Valid pattern.
};
/**
Matches \a lpszText against the pattern.
A match means the entire \a lpszText is used up in matching.
Set the pattern with the #SetPattern method or in the constructor.
\param lpszText
The string to match against the pattern.
\param iRetCode
If not \c NULL, receives one of #Match values indicating a return code.
\return
\c true, if \a lpszText matches the pattern.
\see
SetPattern
*/
bool IsMatch(LPCTSTR lpszText, int* iRetCode = NULL);
/**
Gets a value indicating if \a lpszPattern has any special wildcard characters.
\param lpszPattern
The pattern to test.
\return
\c true, if the pattern has wildcard characters; \c false otherwise.
*/
static bool IsPattern(LPCTSTR lpszPattern);
/**
Tests \a lpszPattern for validity.
\param lpszPattern
The pattern to test.
\param iErrorType
If not \c NULL, receives one of the #Pattern values indicating a return code.
\return
\c true, if \a lpszPattern is a well formed regular expression according
to the CWildcard class syntax (see #SetPattern); \c false otherwise.
*/
static bool IsPatternValid(LPCTSTR lpszPattern, int* iErrorType = NULL);
/**
Matches \a lpszText against \a lpszPattern.
A match means the entire \a lpszText is used in matching.
\param lpszPattern
The pattern to match.
\param lpszText
The string to match against the pattern.
\return
One of #Match values.
\see
SetPattern
*/
static int Match(LPCTSTR lpszPattern, LPCTSTR lpszText);
/**
Initializes a new instance of the CWildcard class.
*/
CWildcard(){}
/**
Initializes a new instance of the CWildcard class.
\param lpszPattern
The pattern to use in matching.
\param bCaseSensitive
The case-sensitivity of matching.
\see
<a href="kb">0610242025|wildcards</a>
*/
CWildcard(LPCTSTR lpszPattern, bool bCaseSensitive)
{
SetPattern(lpszPattern, bCaseSensitive);
}
virtual ~CWildcard(){}
/**
Sets the current pattern
\param lpszPattern
The pattern used in matching.
\param bCaseSensitive
The case-sensitivity of matching.
\see
<a href="kb">0610242025|wildcards</a>
*/
void SetPattern(LPCTSTR lpszPattern, bool bCaseSensitive)
{
m_szPattern = lpszPattern;
m_bCaseSensitive=bCaseSensitive;
if (!bCaseSensitive)
m_szPattern.MakeLower();
}
operator LPCTSTR()
{
return (LPCTSTR)m_szPattern;
}
private:
bool m_bCaseSensitive;
static int MatchAfterStar(LPCTSTR p , LPCTSTR t);
CZipString m_szPattern;
};
}
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (pop)
#endif
#endif

74
harbour/contrib/hbziparch/ZipAbstractFile.h
View File

@@ -1,74 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipAbstractFile.h
* Includes the CZipAbstractFile class.
*
*/
#if !defined(ZIPARCHIVE_ZIPABSTRACTFILE_DOT_H)
#define ZIPARCHIVE_ZIPABSTRACTFILE_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipExport.h"
#include "ZipString.h"
class ZIP_API CZipAbstractFile
{
public:
enum { begin = SEEK_SET, // 0
current = SEEK_CUR, // 1
end = SEEK_END // 2
};
CZipAbstractFile(){}
virtual bool Open(LPCTSTR , UINT , bool ){return false;}
virtual void Close() = 0;
virtual void Flush() = 0;
virtual ZIP_FILE_USIZE GetPosition() const = 0;
virtual ZIP_FILE_USIZE Seek(ZIP_FILE_SIZE lOff, int nFrom) = 0;
ZIP_FILE_USIZE Seek(ZIP_FILE_USIZE lOff, bool fromBeginning = true)
{
ZIP_FILE_SIZE offset;
if (lOff > ZIP_FILE_SIZEMAX)
{
offset = GetLength() - lOff;
fromBeginning = !fromBeginning;
}
else
offset = (ZIP_FILE_USIZE)lOff;
if (fromBeginning)
return Seek(offset, CZipAbstractFile::begin);
else
return Seek(-offset, CZipAbstractFile::end);
}
virtual ZIP_FILE_USIZE GetLength() const = 0;
virtual void SetLength(ZIP_FILE_USIZE nNewLen) = 0;
virtual ZIP_FILE_USIZE SeekToBegin(){return Seek(0, begin);}
virtual ZIP_FILE_USIZE SeekToEnd(){return Seek(0, end);}
virtual CZipString GetFilePath() const = 0;
virtual UINT Read(void *lpBuf, UINT nCount) = 0;
virtual void Write(const void* lpBuf, UINT nCount) = 0;
virtual bool IsClosed() const = 0;
virtual ~CZipAbstractFile(){};
};
#endif // !defined(ZIPARCHIVE_ZIPABSTRACTFILE_DOT_H)

16
harbour/contrib/hbziparch/ZipAesCryptograph.cpp
View File

@@ -1,16 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"

14
harbour/contrib/hbziparch/ZipAesCryptograph.h
View File

@@ -1,14 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////

3152
harbour/contrib/hbziparch/ZipArchive.cpp
View File

File diff suppressed because it is too large Load Diff

3303
harbour/contrib/hbziparch/ZipArchive.h
View File

File diff suppressed because it is too large Load Diff

95
harbour/contrib/hbziparch/ZipAutoBuffer.cpp
View File

@@ -1,95 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipAutoBuffer.h"
#include <memory.h>
CZipAutoBuffer::CZipAutoBuffer()
{
m_iSize = 0;
m_pBuffer = NULL;
}
CZipAutoBuffer::CZipAutoBuffer(DWORD iSize, bool bZeroMemory)
{
m_iSize = 0;
m_pBuffer = NULL;
Allocate(iSize, bZeroMemory);
}
CZipAutoBuffer::~CZipAutoBuffer()
{
Release();
}
void CZipAutoBuffer::Release()
{
if (m_pBuffer)
{
delete [] m_pBuffer;
m_iSize = 0;
m_pBuffer = NULL;
}
}
char* CZipAutoBuffer::Allocate(DWORD iSize, bool bZeroMemory)
{
if (iSize != m_iSize)
Release();
else
{
if (bZeroMemory)
memset(m_pBuffer, 0, iSize); // zerowanie bufora
return m_pBuffer;
}
if (iSize > 0)
{
m_pBuffer = new char [iSize];
if (bZeroMemory)
memset(m_pBuffer, 0, iSize); // zerowanie bufora
m_iSize = iSize;
}
else
m_pBuffer = NULL;
return m_pBuffer;
}
CZipAutoBuffer::CZipAutoBuffer(const CZipAutoBuffer& buffer)
{
m_pBuffer = NULL;
m_iSize = 0;
if (buffer.m_pBuffer)
{
Allocate(buffer.m_iSize);
memcpy(m_pBuffer, buffer.m_pBuffer, buffer.m_iSize);
}
}
CZipAutoBuffer& CZipAutoBuffer::operator=(const CZipAutoBuffer& buffer)
{
if (this == &buffer)
return *this;
Release();
if (buffer.m_pBuffer)
{
Allocate(buffer.m_iSize);
memcpy(m_pBuffer, buffer.m_pBuffer, buffer.m_iSize);
}
return *this;
}

67
harbour/contrib/hbziparch/ZipAutoBuffer.h
View File

@@ -1,67 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipAutoBuffer.h
* Includes the CZipAutoBuffer class.
*
*/
#if !defined(ZIPARCHIVE_ZIPAUTOBUFFER_DOT_H)
#define ZIPARCHIVE_ZIPAUTOBUFFER_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipExport.h"
/**
A smart buffer freeing its contents on destruction.
*/
class ZIP_API CZipAutoBuffer
{
public:
operator char*()
{
return m_pBuffer;
}
#if !defined (__BORLANDC__) || (__BORLANDC__ > 0x560) // The actual version may be different.
operator const char*() const
{
return m_pBuffer;
}
#endif
const char* GetBuffer() const {return m_pBuffer;}
char* Allocate(DWORD iSize, bool bZeroMemory = false);
void Release();
DWORD GetSize() const
{
return m_iSize;
}
bool IsAllocated() const
{
return (m_pBuffer != NULL);
}
CZipAutoBuffer(DWORD iSize, bool bZeroMemory = false);
CZipAutoBuffer();
CZipAutoBuffer(const CZipAutoBuffer& buffer);
virtual ~CZipAutoBuffer();
CZipAutoBuffer& operator=(const CZipAutoBuffer& buffer);
protected:
char* m_pBuffer;
DWORD m_iSize;
};
#endif // !defined(ZIPARCHIVE_ZIPAUTOBUFFER_DOT_H)

30
harbour/contrib/hbziparch/ZipBaseException.h
View File

@@ -1,30 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipBaseException.h
* Contains a type definition of the base exception class.
*
*/
#ifndef ZIPARCHIVE_ZIPBASEEXCEPTION_DOT_H
#define ZIPARCHIVE_ZIPBASEEXCEPTION_DOT_H
#ifdef ZIP_ARCHIVE_STL
typedef std::exception CZipBaseException;
#else
typedef CException CZipBaseException;
#endif
#endif //ZIPARCHIVE_ZIPBASEEXCEPTION_DOT_H

730
harbour/contrib/hbziparch/ZipCallback.h
View File

@@ -1,730 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCallback.h
* Includes the CZipCallback and the derived classes.
*
*/
#if !defined(ZIPARCHIVE_ZIPCALLBACK_DOT_H)
#define ZIPARCHIVE_ZIPCALLBACK_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 "ZipString.h"
#include "ZipExport.h"
/*
When processing split archives, this value is passes as the argument to the CZipCallback::Callback method
to notify that the current volume is the last one.
*/
#define ZIP_SPLIT_LAST_VOLUME (ZIP_SIZE_TYPE)(-1)
/**
A base class for callback objects that are notified when various actions take place.
You need to derive your own class and overload the #Callback method to use it.
Do not derive from CZipCallback directly but derive from:
\li CZipSegmCallback, when you create a segmented archive - you will be notified
when there the next volume is processed in a segmented archive.
\li CZipActionCallback, for other notifications.
\see
<a href="kb">0610051553|span</a>
\see
<a href="kb">0610231200</a>
\see
CZipSegmCallback
\see
CZipActionCallback
*/
struct ZIP_API CZipCallback
{
/**
The method called as a callback.
Return \c false from inside the method to abort the current operation. If it is a segmented archive callback object,
a CZipException with CZipException::aborted code will be thrown, otherwise the code will be CZipException::abortedAction or CZipException::abortedSafely.
The following actions can be safely aborted (without corrupting the archive):
- counting bytes before deleting files
- testing
- saving the central directory in a not segmented archive
(saved data is removed in case of break and you can save it again).
If the archive is segmented and if saving is aborted, the archive
will not be damaged, but saved part of the central directory will be not removed
and the new central directory will have to be saved after it.
\param uProgress
The value depends on the type of the operation.
\return
\c false to abort the current operation; \c true to continue it.
\note
Override this method in the derived class. If you define this method inside the class declaration, consider inlining
it to make the action progress faster.
\see
CZipSegmCallback
*/
virtual bool Callback(ZIP_SIZE_TYPE uProgress) = 0;
/**
Stored the filename of an external file, if the action (adding, extracting or segmentation) uses such a file.
*/
CZipString m_szExternalFile;
virtual ~CZipCallback(){}
};
/**
When you derive from CZipSegmCallback, you can use the derived class as a callback object for:
- the disk change notification in a spanned archive,
- notification about the next part being processed in a split archive.
You need to override the CZipActionCallback::Callback method.
The value of the \a uProgress parameter in the callback method has the following meaning:
- the minimum number of free bytes required on the disk when writing a spanned archive
- it is set to \c 0 when reading a spanned archive
- when writing or reading a split archive it is set to \c 0 apart for the last volume when it is set to \c ZIP_SPLIT_LAST_VOLUME
Return \c false from the callback function to abort the operation: the proper exception will be thrown.
\see
<a href="kb">0610051553|span</a>
\see
CZipActionCallback::Callback
\see
CZipArchive::SetSegmCallback
*/
struct ZIP_API CZipSegmCallback : public CZipCallback
{
/**
Values indicating the reason for calling the callback.
*/
enum SegmCodes
{
scVolumeNeededForRead, ///< The next volume is needed when reading a segmented archive. The number of the volume is stored in #m_uVolumeNeeded.
scVolumeNeededForWrite, ///< The next volume is needed when writing a segmented archive. The number of the volume is stored in #m_uVolumeNeeded.
scFileNameDuplicated, ///< The file used for writing a new volume already exists.
scCannotSetVolLabel, ///< The disk label could not be set. The disk may be write-protected. Called only for spanned archives.
scFileCreationFailure, ///< The archive file could not be created. The disk may be write-protected.
scFileNotFound, ///< The given volume file was not found when reading a split archive. The number of the volume is stored in #m_uVolumeNeeded. Called only for split archives.
};
ZIP_VOLUME_TYPE m_uVolumeNeeded; ///< The number of the volume needed when reading or writing a segmented archive. Volumes are numbered starting from 1.
int m_iCode; ///< The reason for calling the callback. Can be one of the #SegmCodes values.
};
/**
When you derive from CZipActionCallback, you can use the new class as a callback object when adding, extracting, deleting, testing files
or saving the central directory.
You need to override the CZipActionCallback::Callback method.
The value of the \a uProgress parameter in the callback method is the amount of data just processed.
\see
<a href="kb">0610231200</a>
\see
CZipActionCallback::Callback
\see
CZipArchive::SetCallback
*/
struct ZIP_API CZipActionCallback : public CZipCallback
{
friend class CZipArchive;
friend class CZipCentralDir;
/**
Values used for specifying a callback type in the CZipArchive::SetCallback method.
You can assign several values to the same callback object (use the logical \c OR).
\see
<a href="kb">0610231200</a>
\see
CZipArchive::SetCallback
\see
CZipActionCallback
*/
enum CallbackType
{
/**
Not used.
You can use it for your own purposes.
*/
cbNothing = 0x0000,
/**
Compressing a file.
The callback called when adding a file with one of the CZipArchive::AddNewFile methods.
*/
cbAdd = 0x0001,
/**
Moving a file from a temporary archive.
The callback called while adding a file (only on a segmented archive) when the smartness level contains
CZipArchive::zipsmCheckForEff or CZipArchive::zipsmCheckForEffInMem
and if the just compressed file is being moved from a temporary place (file or memory) to the archive.
*/
cbAddTmp = 0x0002,
/**
Storing a file.
The callback called while adding a file and if its compressing has proven to be inefficient
and it is now being stored (instead of compressed) in the archive. The smartness level must
contain CZipArchive::zipsmCheckForEff or CZipArchive::zipsmCheckForEffInMem. The archive can be
segmented or not.
*/
cbAddStore = 0x0004,
/**
Extracting a file.
The callback called when extracting a file with one of the CZipArchive::ExtractFile methods.
*/
cbExtract = 0x0008,
/**
Counting data to process before deleting.
The callback called before the actual deletion takes place and the map of holes and continuous
areas is being created. It is safe to abort the operation (by returning \c false from
the callback method).
*/
cbDeleteCnt = 0x0010,
/**
Deleting files.
The callback called when moving data while deleting file(s) with the CZipArchive::RemoveFile
method or one of the CZipArchive::RemoveFiles methods.
*/
cbDelete = 0x0020,
/**
Testing a file.
The callback called when testing a file with the CZipArchive::TestFile method.
*/
cbTest = 0x0040,
/**
Saving the central directory.
The callback called when saving the central directory with the CZipCentralDir::Write method
(usually on close or flush). It is safe to abort the operation on a segmented archive -
the saved part of the central directory will be removed from disk.
*/
cbSave = 0x0080,
/**
Getting a file from another archive.
The callback called when using one of the CZipArchive::GetFromArchive methods.
*/
cbGet = 0x0100,
/**
Renaming a file.
The callback called when during renaming a file there is a need to make less or more space
for the new filename.
*/
cbRename = 0x0200,
/**
Moving data.
The callback called when moving data inside the archive. It happens while replacing files to make less or more space
for the new file or while shifting data with the CZipArchive::ShiftData() method.
*/
cbMoveData = 0x0400,
/**
The callback called when counting files and bytes to process when performing multiple actions.
When this callback is called, CZipActionCallback::m_uTotalToProcess is
not set (because it is not known and that's why the counting is performed),
but it allows to abort the counting process.
*/
cbCalculateForMulti= 0x0800,
/**
The callback called when adding multiple files with one of the CZipArchive::AddNewFiles
methods. This callback also registers for #cbAdd.
\see
<a href="kb">0610231200|multi</a>
*/
cbMultiAdd = 0x1000 | cbAdd,
/**
The callback called when preparing existing files for encryption.
\see
<a href="kb">0610201627|existing</a>
*/
cbEncryptPrepare= 0x2000,
/**
The callback called in order to report the progress of making space inside the archive before the actual encryption takes place.
\see
<a href="kb">0610201627|existing</a>
*/
cbEncryptMoveData= 0x4000,
/**
The callback called for every file being encrypted.
\see
<a href="kb">0610201627|existing</a>
*/
cbEncrypt = 0x8000,
/**
The callback called when encrypting existing files in the archive. This callback also registers for #cbEncryptMoveData and #cbEncrypt.
\see
<a href="kb">0610201627|existing</a>
\see
<a href="kb">0610231200|multi</a>
*/
cbMultiEncrypt = 0x10000 | cbEncryptMoveData | cbEncrypt,
/**
Reserved.
You can declare your own callback types above this value. Do not use the numeric value,
but the symbol name - the value may change in the future releases of the library.
*/
cbNextValue = 0x20000,
/**
All sub-actions.
Represents the sub-actions callbacks - they are called as a part of bigger actions
(#cbAddTmp | #cbAddStore | #cbDeleteCnt | #cbMoveData | #cbCalculateForMulti | #cbEncryptPrepare | #cbEncryptMoveData).
*/
cbSubActions = cbAddTmp | cbAddStore | cbDeleteCnt | cbMoveData | cbCalculateForMulti | cbEncryptPrepare | cbEncryptMoveData,
/**
Main callbacks.
Represents the main action callbacks (#cbAdd | #cbExtract | #cbDelete | #cbTest | #cbSave | #cbGet | #cbRename | #cbEncrypt).
*/
cbActions = cbAdd | cbExtract | cbDelete | cbTest | cbSave | cbGet | cbRename | cbEncrypt,
/**
Multiple action callbacks.
Represents the multiple action callbacks.
*/
cbMultiActions = cbMultiAdd | cbMultiEncrypt,
/**
All values.
Use this value to call one callback object for all callback types.
*/
cbAll = cbActions | cbSubActions | cbMultiActions
};
/**
A structure that provides global information in case of using multiple actions callbacks.
\see
<a href="kb">0610231200|multi</a>
\see
cbMultiActions
*/
struct ZIP_API CMultiActionsInfo
{
friend struct CZipActionCallback;
ZIP_SIZE_TYPE m_uTotalBytesToProcess; ///< The total number of bytes to process.
ZIP_SIZE_TYPE m_uTotalFilesToProcess; ///< The total number of files to process.
ZIP_SIZE_TYPE m_uBytesProcessed; ///< The total number of bytes processed so far.
ZIP_SIZE_TYPE m_uFilesProcessed; ///< The total number of files processed so far.
/**
Returns the number of files left to process.
\return
The number of files left to process.
*/
ZIP_SIZE_TYPE LeftFilesToProcess() const {return m_uTotalFilesToProcess - m_uFilesProcessed;}
/**
Returns the number of bytes left to process.
\return
The number of bytes left to process.
*/
ZIP_SIZE_TYPE LeftBytesToProcess() const {return m_uTotalBytesToProcess - m_uBytesProcessed;}
private:
void Init(ZIP_SIZE_TYPE uTotalItemsToProcess, ZIP_SIZE_TYPE uTotalBytesToProcess, int iReactType)
{
m_uTotalFilesToProcess = uTotalItemsToProcess;
m_uTotalBytesToProcess = uTotalBytesToProcess;
m_uBytesProcessed = m_uFilesProcessed = 0;
m_iReactType = iReactType;
m_bActive = false;
}
void OnCallbackInit(int iType)
{
// this assumes, that the callback type will stay unchanged
// between Init() and CallbackEnd()
m_bActive = iType == m_iReactType;
}
void OnCallCallback(ZIP_SIZE_TYPE uProgress)
{
if (m_bActive)
m_uBytesProcessed += uProgress;
}
bool OnNextFile()
{
if (m_bActive)
{
m_uFilesProcessed++;
return true;
}
else
return false;
}
bool m_bActive;
int m_iReactType;
};
CZipActionCallback()
{
m_uTotalToProcess = 0;
m_uProcessed = 0;
m_pMultiActionsInfo = NULL;
}
/**
Called when the multiple actions operation is about to begin. Initializes CMultiActionsInfo object.
\param uTotalFilesToProcess
The number of files to process.
\param uTotalBytesToProcess
The number of bytes to process.
\param iReactType
The type of the callback that will cause increasing of values in CMultiActionsInfo.
Can be one of #CallbackType values.
\see
<a href="kb">0610231200|multi</a>
\see
GetMultiActionsInfo
\note
When overriding this method, call the base method from your code.
*/
virtual void MultiActionsInit(ZIP_SIZE_TYPE uTotalFilesToProcess, ZIP_SIZE_TYPE uTotalBytesToProcess, int iReactType)
{
InitMultiActionsInfo();
m_pMultiActionsInfo->Init(uTotalFilesToProcess, uTotalBytesToProcess, iReactType);
}
/**
Called to initialize the callback object.
Sets the filenames and resets #m_uTotalToProcess and #m_uProcessed variables to \c 0.
#m_iType variable is already set to the proper value. Called at the beginning of the operation.
\param lpszFileInZip
The file that is being processed in the archive.
\param lpszExternalFile
The external file being processed. This is set to \c NULL, if the operation takes place in memory.
*/
virtual void Init(LPCTSTR lpszFileInZip = NULL, LPCTSTR lpszExternalFile = NULL)
{
m_szFileInZip = lpszFileInZip;
m_szExternalFile = lpszExternalFile;
m_uTotalToProcess = 0; // not yet known
m_uProcessed = 0; // nothing yet done
CacheStepSize();
ResetProgressStage();
if (m_pMultiActionsInfo)
// the type is known now
m_pMultiActionsInfo->OnCallbackInit(m_iType);
}
/**
Called after calculating the total amount of data to process.
\param uTotalToDo
Total amount of data to process. The method initializes #m_uTotalToProcess with this value.
*/
virtual void SetTotal(ZIP_SIZE_TYPE uTotalToDo)
{
m_uTotalToProcess = uTotalToDo;
// m_uProcessed = 0; // already done in CZipCallbackProvider::Get
}
/**
Called when a next action begins in multiple actions processing.
This method calls #Callback method with \a uProgress parameter set to \c 0.
\return
The value returned from the #Callback method.
\see
<a href="kb">0610231200|multi</a>
\note
When overriding this method, call the base method from your code.
*/
virtual bool MultiActionsNext()
{
if (m_pMultiActionsInfo && m_pMultiActionsInfo->OnNextFile())
return Callback(0);
else
return true;
}
/**
Called after the operation finishes.
It is not called in case of an exception, but
it is called before throwing CZipException::abortedAction or CZipException::abortedSafely.
*/
virtual void CallbackEnd()
{
//ASSERT(m_uProcessed == m_uTotalToProcess);
};
/**
Called at the end of the multiple actions operation.
Releases multiple actions information (CMultiActionsInfo).
Override this method, if you want this information to be persisted after
operation finishes. In that case, CMultiActionsInfo will be released
on destruction.
\see
<a href="kb">0610231200|multi</a>
*/
virtual void MultiActionsEnd()
{
ReleaseMultiActionsInfo();
}
/**
Gets the amount of data left to process.
\return
The amount of data left to process.
*/
ZIP_SIZE_TYPE LeftToProcess() const {return m_uTotalToProcess - m_uProcessed;}
/**
The total amount of data to process. This value is set when the #SetTotal method is called.
Depending on the action it is set then to:
- Adding a file : the size the external file being added (or if the type of the callback is CZipActionCallback::cbAddTmp,
the size of the compressed data: CZipFileHeader::m_uComprSize).
- Extracting a file : the size of the uncompressed data (CZipFileHeader::m_uUncomprSize).
- Testing a file : the same as above.
- Deleting a file : the number of bytes to move - the size of all files to remain above the first
file to delete (calculated from offsets in CZipFileHeader::m_uOffset).
- Saving the central directory : the number of files in the archive.
*/
ZIP_SIZE_TYPE m_uTotalToProcess;
ZIP_SIZE_TYPE m_uProcessed; ///< The total amount of data processed so far.
CZipString m_szFileInZip; ///< The name of the file that is being processed in the archive.
/**
The type of the callback. It is set to one of the #CallbackType values when the action begins.
It's useful, if you have more than one callback assigned to the same callback object.
*/
int m_iType;
/**
Returns the current CMultiActionsInfo object in multiple actions operation or \c NULL, if
the current operation is not one of CZipActionCallback::cbMultiActions actions.
\return
The current CMultiActionsInfo object.
\see
<a href="kb">0610231200|multi</a>
*/
CMultiActionsInfo* GetMultiActionsInfo()
{
return m_pMultiActionsInfo;
}
/**
Sets the type of the callback, that will cause the current CMultiActionsInfo object to update its progress.
\param iType
The type of the callback. It can be one of the #CallbackType values.
*/
void SetReactType(int iType)
{
m_pMultiActionsInfo->m_iReactType = iType;
}
/**
Specifies how often the Callback() method is called. The Callback() method is called every \b n-th callback request,
where \b n is the value returned from the GetStepSize() method.
Override this method to adjust the frequency of calling the callback.
\return
The value that determines the frequency of calling the Callback() method.
By default, it returns \c 256 for #cbSave, #cbDeleteCnt, #cbCalculateForMulti and #cbEncryptPrepare and \c 1
for other callback types.
\note
This method is called in the Init() method and the returned value is cached for further processing.
This means that when you override this method, even with some time-consuming operations, it will not affect
the in-action performance.
\note
Do not use a too low value, because it may increase significantly the time needed to process a huge number of files.
*/
virtual int GetStepSize()
{
return m_iType == cbSave || m_iType == cbDeleteCnt || m_iType == cbCalculateForMulti || m_iType == cbEncryptPrepare ? 256 : 1;
}
~CZipActionCallback()
{
ReleaseMultiActionsInfo();
}
/**
Called by processing classes when data processing progressed.
\param uProgress
The amount of data processed.
\return
The value returned from #Callback, if the method was called; \c true otherwise.
*/
bool RequestCallback(ZIP_SIZE_TYPE uProgress = 1)
{
if (!uProgress)
return true;
if (m_iCachedStepSize == 1)
return CallCallback(uProgress);
else
{
m_uAccumulatedProgress += uProgress;
if (m_iCurrentStep >= m_iCachedStepSize)
{
bool ret = CallCallback(m_uAccumulatedProgress);
ResetProgressStage();
return ret;
}
else
{
m_iCurrentStep++;
return true;
}
}
}
/**
Called by processing classes when data processing has finished to
allow calling the Callback() method for the amount of processed data for
which the Callback() has not been called. This usually happens,
when GetStepSize() does not return 1.
\param uProgress
The amount of data processed.
\return
The value returned from the #Callback method, if the method was called; \c true otherwise.
*/
bool RequestLastCallback(ZIP_SIZE_TYPE uProgress = 0)
{
bool ret;
if (m_uAccumulatedProgress == 0 && uProgress == 0)
ret = true;
else
ret = CallCallback(m_uAccumulatedProgress + uProgress);
ResetProgressStage();
return ret;
}
protected:
/**
Calls the Callback() method internally, increases CZipActionCallback::m_uProcessed and lets the CZipActionCallback
increase its values, if needed.
\param uProgress
The amount of data processed.
\return
The return value from the Callback() method.
*/
virtual bool CallCallback(ZIP_SIZE_TYPE uProgress)
{
m_uProcessed += uProgress;
if (m_pMultiActionsInfo)
m_pMultiActionsInfo->OnCallCallback(uProgress);
return Callback(uProgress);
}
/**
Caches the value returned from the GetStepSize() method. Called in the Init()method.
*/
void CacheStepSize()
{
m_iCachedStepSize = GetStepSize();
if (m_iCachedStepSize == 0)
m_iCachedStepSize = 1;
}
/**
Initializes the values that depend on the frequency of calling the Callback() method.
Called with every call to the Callback() method.
\see
GetStepSize
*/
void ResetProgressStage()
{
m_iCurrentStep = 1;
m_uAccumulatedProgress = 0;
}
private:
CMultiActionsInfo* m_pMultiActionsInfo;
void InitMultiActionsInfo()
{
ReleaseMultiActionsInfo();
m_pMultiActionsInfo = new CMultiActionsInfo();
}
void ReleaseMultiActionsInfo()
{
if (m_pMultiActionsInfo != NULL)
{
delete m_pMultiActionsInfo;
m_pMultiActionsInfo = NULL;
}
}
int m_iCachedStepSize; ///< The cached step value for the time of processing.
int m_iCurrentStep;
ZIP_SIZE_TYPE m_uAccumulatedProgress;
};
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (pop)
#endif
#endif

90
harbour/contrib/hbziparch/ZipCallbackProvider.h
View File

@@ -1,90 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCallbackProvider.h
* Includes the ZipArchiveLib::CZipCallbackProvider class.
*
*/
#if !defined(ZIPARCHIVE_ZIPCALLBACKPROVIDER_DOT_H)
#define ZIPARCHIVE_ZIPCALLBACKPROVIDER_DOT_H
#if _MSC_VER > 1000
#pragma once
#if defined ZIP_HAS_DLL
#pragma warning (push)
#pragma warning( disable : 4275 ) // non dll-interface used as base for dll-interface class
#endif
#endif
#include "ZipCallback.h"
#include "ZipExport.h"
#include "ZipCollections.h"
namespace ZipArchiveLib
{
/**
The storage for callback objects. A structure for the internal use only.
\see
CZipArchive::SetCallback
CZipArchive::GetCallback
*/
class ZIP_API CZipCallbackProvider : public CZipMap<CZipActionCallback::CallbackType, CZipActionCallback*>
{
public:
void Set(CZipActionCallback* pCallback, int iWhich)
{
CZipActionCallback::CallbackType cbs[] = {CZipActionCallback::cbAdd, CZipActionCallback::cbAddTmp, CZipActionCallback::cbAddStore, CZipActionCallback::cbExtract, CZipActionCallback::cbDeleteCnt, CZipActionCallback::cbDelete, CZipActionCallback::cbTest, CZipActionCallback::cbSave, CZipActionCallback::cbGet, CZipActionCallback::cbRename, CZipActionCallback::cbMoveData, CZipActionCallback::cbCalculateForMulti, CZipActionCallback::cbMultiAdd, CZipActionCallback::cbEncryptPrepare, CZipActionCallback::cbEncryptMoveData, CZipActionCallback::cbEncrypt, CZipActionCallback::cbMultiEncrypt};
int iCount = sizeof(cbs)/sizeof(CZipActionCallback::CallbackType);
for (int i = 0; i < iCount; i++)
{
CZipActionCallback::CallbackType iCallback = cbs[i];
if (iWhich & iCallback)
SetInternal(pCallback, iCallback);
}
}
CZipActionCallback* Get(CZipActionCallback::CallbackType iType)
{
CZipActionCallback* pCallback = NULL;
if (Lookup(iType, pCallback))
{
pCallback->m_iType = iType;
return pCallback;
}
else
return NULL;
}
protected:
void SetInternal(CZipActionCallback* pCallback, CZipActionCallback::CallbackType iType)
{
if (pCallback)
{
SetAt(iType, pCallback);
}
else
RemoveKey(iType);
}
};
} // namespace
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (pop)
#endif
#endif // !defined(ZIPARCHIVE_ZIPCALLBACKPROVIDER_DOT_H)

955
harbour/contrib/hbziparch/ZipCentralDir.cpp
View File

@@ -1,955 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
//#include <string>
#include "ZipCentralDir.h"
#include "ZipArchive.h"
#include "ZipFileMapping.h"
#include "ZipPlatform.h"
#include "BytesWriter.h"
#define CENTRAL_DIR_END_SIZE 22
using namespace ZipArchiveLib;
char CZipCentralDir::m_gszSignature[] = {0x50, 0x4b, 0x05, 0x06};
char CZipCentralDir::m_gszSignature64Locator[] = {0x50, 0x4b, 0x06, 0x07};
CZipCentralDir::CZipCentralDir()
{
m_pInfo = NULL;
m_pHeaders = NULL;
m_pFindArray = NULL;
m_pStorage = NULL;
m_pOpenedFile = NULL;
m_iIgnoredChecks = 0;
m_pCallbacks = NULL;
}
void CZipCentralDir::Init(CZipStorage* pStorage, ZipArchiveLib::CZipCallbackProvider* pCallbacks, CZipStringStoreSettings* pStringSettings, CZipCentralDir* pSource)
{
m_pStorage = pStorage;
m_pCallbacks = pCallbacks;
m_pStringSettings = pStringSettings;
m_pOpenedFile = NULL;
m_iIgnoredChecks = CZipArchive::checkIgnoredByDefault;
// just in case
DestroySharedData();
if (pSource != NULL)
{
#ifdef ZIP_ARCHIVE_USE_LOCKING
pSource->LockAccess();
#endif
m_pInfo = pSource->m_pInfo;
m_pInfo->m_iReference++;
m_pHeaders = pSource->m_pHeaders;
m_pFindArray = pSource->m_pFindArray;
#ifdef ZIP_ARCHIVE_USE_LOCKING
// points to the same object now
UnlockAccess();
#endif
m_pStorage->UpdateSegmMode(m_pInfo->m_uLastVolume);
m_pStorage->m_uBytesBeforeZip = pSource->m_pStorage->m_uBytesBeforeZip;
}
else
CreateSharedData();
}
CZipCentralDir::~CZipCentralDir()
{
DestroySharedData();
}
void CZipCentralDir::Read(bool bExhaustiveRead)
{
if (!m_pStorage)
{
ASSERT(FALSE);
return;
}
m_pStorage->m_pFile->SeekToEnd();
// maximum size of end of central dir record
m_pInfo->m_uEndOffset = (ZIP_SIZE_TYPE)m_pStorage->LocateSignature(m_gszSignature, 0xFFFF + CENTRAL_DIR_END_SIZE);
if (m_pInfo->m_uEndOffset == CZipStorage::SignatureNotFound)
ThrowError(CZipException::cdirNotFound);
m_pStorage->m_pFile->Seek((ZIP_FILE_USIZE)(m_pInfo->m_uEndOffset + 4));
CZipAutoBuffer buf(CENTRAL_DIR_END_SIZE);
// we can skip the signature, we already know it is good - it was found
int uRead = m_pStorage->m_pFile->Read(buf, CENTRAL_DIR_END_SIZE - 4);
if (uRead != CENTRAL_DIR_END_SIZE - 4)
ThrowError(CZipException::badZipFile);
WORD uCommentSize;
CBytesWriter::ReadBytes(m_pInfo->m_uLastVolume, buf, 2);
CBytesWriter::ReadBytes(m_pInfo->m_uVolumeWithCD, buf + 2, 2);
CBytesWriter::ReadBytes(m_pInfo->m_uVolumeEntriesNo,buf + 4, 2);
CBytesWriter::ReadBytes(m_pInfo->m_uEntriesNumber,buf + 6, 2);
CBytesWriter::ReadBytes(m_pInfo->m_uSize, buf + 8, 4);
CBytesWriter::ReadBytes(m_pInfo->m_uOffset, buf + 12, 4);
CBytesWriter::ReadBytes(uCommentSize, buf + 16);
buf.Release();
if (uCommentSize)
{
m_pInfo->m_pszComment.Allocate(uCommentSize);
uRead = m_pStorage->m_pFile->Read(m_pInfo->m_pszComment, uCommentSize);
if (uRead != uCommentSize)
ThrowError(CZipException::badZipFile);
}
if ( m_pInfo->NeedsZip64() )
{
m_pStorage->m_pFile->Seek((ZIP_FILE_USIZE)(m_pInfo->m_uEndOffset));
ULONGLONG uPosition = m_pStorage->LocateSignature(m_gszSignature64Locator, ZIP_SIZE_TYPE(-1));
if (uPosition != CZipStorage::SignatureNotFound)
ThrowError(CZipException::noZip64);
// when the zip64 locator is not found, try to treat this archive as normal
}
// if m_uLastVolume is not zero, it is enough to say that it is a multi-volume archive
ASSERT((!m_pInfo->m_uLastVolume && (m_pInfo->m_uEntriesNumber == m_pInfo->m_uVolumeEntriesNo) && !m_pInfo->m_uVolumeWithCD) || m_pInfo->m_uLastVolume);
m_pStorage->UpdateSegmMode(m_pInfo->m_uLastVolume);
if (!m_pStorage->IsSegmented() && !m_pInfo->CheckIfOK_1())
ThrowError(CZipException::badZipFile);
if (m_pStorage->m_uBytesBeforeZip == 0 && m_pInfo->m_uLastVolume == 0)
m_pStorage->m_uBytesBeforeZip = m_pInfo->CalculateBytesBeforeZip();
if (!m_pInfo->CheckIfOK_2())
ThrowError(CZipException::badZipFile);
m_pInfo->m_bInArchive = true;
m_pStorage->ChangeVolume(m_pInfo->m_uVolumeWithCD);
if (!m_pInfo->m_uSize)
return;
ReadHeaders(bExhaustiveRead);
}
void CZipCentralDir::ThrowError(int err) const
{
CZipException::Throw(err, m_pStorage->m_pFile->GetFilePath());
}
void CZipCentralDir::ReadHeaders(bool bExhaustiveRead)
{
m_pStorage->Seek(m_pInfo->m_uOffset);
RemoveHeaders(); //just in case
for (ZIP_INDEX_TYPE i = 0; i < m_pInfo->m_uEntriesNumber; i++)
{
CZipFileHeader* pHeader = new CZipFileHeader;
m_pHeaders->Add(pHeader);
if (!pHeader->Read(*this, true))
ThrowError(CZipException::badZipFile);
}
if (bExhaustiveRead)
{
ZIP_FILE_USIZE uPosition = m_pStorage->m_pFile->GetPosition();
// different offset, or different parts
if (uPosition != m_pInfo->m_uEndOffset || m_pStorage->IsSegmented() && m_pStorage->GetCurrentVolume() != m_pInfo->m_uLastVolume)
for(;;)
{
CZipAutoBuffer buf(4);
m_pStorage->Read(buf, 4, true);
if (!CZipFileHeader::VerifySignature(buf))
break;
CZipFileHeader* pHeader = new CZipFileHeader;
m_pHeaders->Add(pHeader);
if (!pHeader->Read(*this, false))
ThrowError(CZipException::badZipFile);
}
}
// this is necessary when removing data descriptors, CZipArchive::MakeSpaceForReplace, deleting, replacing or encrypting files
// sort always, to yield the same results in requesting files by index regardless of the reason for opening
m_pHeaders->Sort(CompareHeaders);
RebuildFindFastArray();
}
void CZipCentralDir::Close()
{
m_pOpenedFile = NULL;
DestroySharedData();
// do not reference it anymore
m_pInfo = NULL;
m_pHeaders = NULL;
m_pFindArray = NULL;
}
bool CZipCentralDir::IsValidIndex(ZIP_INDEX_TYPE uIndex)const
{
return uIndex < (ZIP_INDEX_TYPE)m_pHeaders->GetSize() && uIndex != ZIP_FILE_INDEX_UNSPECIFIED;
}
void CZipCentralDir::OpenFile(ZIP_INDEX_TYPE uIndex)
{
CZipFileHeader* pOpenedFile = (*this)[uIndex];
m_pStorage->ChangeVolume(pOpenedFile->m_uVolumeStart);
m_pStorage->Seek(pOpenedFile->m_uOffset);
if (!pOpenedFile->ReadLocal(*this))
ThrowError(CZipException::badZipFile);
m_pOpenedFile = pOpenedFile;
}
void CZipCentralDir::CloseFile(bool skipCheckingDataDescriptor)
{
if (!m_pOpenedFile)
return;
if (!skipCheckingDataDescriptor && IsConsistencyCheckOn(CZipArchive::checkDataDescriptor)
&& !m_pOpenedFile->CheckDataDescriptor(m_pStorage))
ThrowError(CZipException::badZipFile);
m_pOpenedFile = NULL;
}
// add new header using the argument as a template
CZipFileHeader* CZipCentralDir::AddNewFile(const CZipFileHeader & header, ZIP_INDEX_TYPE uReplaceIndex, int iLevel, bool bRichHeaderTemplateCopy)
{
// copy some of the template data
m_pOpenedFile = NULL;
ZIP_INDEX_TYPE uIndex;
CZipFileHeader* pHeader = new CZipFileHeader();
try
{
pHeader->m_uMethod = header.m_uMethod;
pHeader->m_uModDate = header.m_uModDate;
pHeader->m_uModTime = header.m_uModTime;
pHeader->m_uExternalAttr = header.m_uExternalAttr;
pHeader->m_uLocalComprSize = header.m_uLocalComprSize;
pHeader->m_uLocalUncomprSize = header.m_uLocalUncomprSize;
if (header.m_pszFileName != NULL)
pHeader->m_pszFileName = new CZipString(*header.m_pszFileName);
pHeader->m_pszFileNameBuffer = header.m_pszFileNameBuffer;
pHeader->m_pszComment = header.m_pszComment;
pHeader->m_aLocalExtraData = header.m_aLocalExtraData;
// local will be removed in a moment in PrepareData
pHeader->m_aCentralExtraData = header.m_aCentralExtraData;
pHeader->m_aCentralExtraData.RemoveInternalHeaders();
pHeader->SetSystemCompatibility(header.GetSystemCompatibility());
pHeader->m_uEncryptionMethod = header.m_uEncryptionMethod;
// current settings
pHeader->m_stringSettings = *m_pStringSettings;
// set only when adding a new file, not in PrepareData (which may be called under different circumstances)
// we need the proper encryption method to be set already
RemoveFromDisk();
bool bReplace = IsValidIndex(uReplaceIndex);
pHeader->PrepareData(iLevel, m_pStorage->IsSegmented() != 0);
if (bRichHeaderTemplateCopy)
{
// call here, because PrepareData will zero them
pHeader->m_uCrc32 = header.m_uCrc32;
pHeader->m_uComprSize = header.m_uComprSize;
pHeader->m_uUncomprSize = header.m_uUncomprSize;
}
// local extra field is updated if needed, so we can check the lengths
if (!pHeader->CheckLengths(true))
ThrowError(CZipException::tooLongData);
// now that everything is all right, we can add the new file
if (bReplace)
{
CZipFileHeader* pfh = (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)uReplaceIndex];
m_pStorage->Seek(pfh->m_uOffset);
RemoveFile(pfh, uReplaceIndex, false);
m_pHeaders->InsertAt((ZIP_ARRAY_SIZE_TYPE)uReplaceIndex, pHeader);
m_pOpenedFile = pHeader;
uIndex = uReplaceIndex;
}
else
{
uIndex = (ZIP_INDEX_TYPE)m_pHeaders->Add(pHeader);
m_pOpenedFile = pHeader;
m_pStorage->m_pFile->SeekToEnd();
}
}
catch(...)
{
// otherwise it is added to the collection and will be auto-deleted
if (pHeader != NULL && m_pOpenedFile == NULL)
delete pHeader;
throw;
}
if (m_pInfo->m_bFindFastEnabled)
InsertFindFastElement(pHeader, uIndex); // GetCount > 0, because we have just added a header
return pHeader;
}
void CZipCentralDir::SetComment(LPCTSTR lpszComment)
{
ZipCompatibility::ConvertStringToBuffer(lpszComment, m_pInfo->m_pszComment, m_pStringSettings->m_uCommentCodePage);
RemoveFromDisk();
}
bool CZipCentralDir::SetFileComment(ZIP_INDEX_TYPE uIndex, LPCTSTR lpszComment)
{
if (!IsValidIndex(uIndex))
{
ASSERT(FALSE);
return false;
}
CZipFileHeader* pHeader = (*this)[uIndex];
pHeader->m_stringSettings.m_uCommentCodePage = m_pStringSettings->m_uCommentCodePage;
pHeader->SetComment(lpszComment);
RemoveFromDisk();
return true;
}
void CZipCentralDir::RemoveFromDisk()
{
if (m_pInfo->m_bInArchive)
{
ASSERT(!m_pStorage->IsSegmented()); // you can't add files to an existing segmented archive or to delete them from it
m_pStorage->m_pFile->SetLength((ZIP_FILE_USIZE)(m_pStorage->m_uBytesBeforeZip + m_pInfo->m_uOffset));
m_pInfo->m_bInArchive = false;
}
else
m_pStorage->Flush(); // if remove from disk is requested, then the archive modification will follow, so flush the buffers
}
void CZipCentralDir::CloseNewFile()
{
m_pOpenedFile->OnNewFileClose(m_pStorage);
m_pOpenedFile = NULL;
}
void CZipCentralDir::Write()
{
if (m_pInfo->m_bInArchive)
return;
m_pInfo->m_uEntriesNumber = (ZIP_INDEX_TYPE)m_pHeaders->GetSize();
if (!m_pStorage->IsSegmented())
{
m_pStorage->Flush();
m_pStorage->m_pFile->SeekToEnd();
}
// else
// we are at the end already
m_pInfo->m_uSize = 0;
bool bDontAllowVolumeChange = false;
if (m_pStorage->IsSegmented())
{
// segmentation signature at the beginning (4 bytes) + the size of the data descr. for each file
ZIP_SIZE_TYPE uSize = GetSize(true);
// if there is a segmented archive in creation and it is only one-volume,
// (current volume number is 0 so far, no bytes has been written so we know they are
// all in the buffer) make sure that it will be after writing central dir
// and make it a not segmented archive
if (m_pStorage->GetCurrentVolume() == 0)
{
// calculate the size of data descriptors already in the buffer or on the disk
// (they will be removed in the not segmented archive).
ZIP_SIZE_TYPE uToGrow = uSize - 4;
for (ZIP_INDEX_TYPE i = 0; i < m_pInfo->m_uEntriesNumber; i++)
{
CZipFileHeader* pHeader = (*this)[i];
if (pHeader->NeedsDataDescriptor())
{
if (!pHeader->IsEncrypted())
uToGrow -= 4; // remove the signature only
}
else
uToGrow -= pHeader->GetDataDescriptorSize(true);
}
ZIP_SIZE_TYPE uVolumeFree = m_pStorage->VolumeLeft();
if (uVolumeFree >= uToGrow)
// lets make sure it will be one-volume archive
{
// can the operation be done only in the buffer?
if (!m_pStorage->m_uBytesWritten && // no bytes on the disk yet
(m_pStorage->GetFreeInBuffer() >= uToGrow)) // is the buffer big enough?
{
RemoveDataDescr(true);
bDontAllowVolumeChange = true; // if a volume change occurs somehow, we'll throw an error later
}
else
{
m_pStorage->Flush();
if (RemoveDataDescr(false))
bDontAllowVolumeChange = true; // if a volume change occurs somehow, we'll throw an error later
}
}
}
// make sure that in a segmented archive, the whole central directory will fit on the single volume
if (!bDontAllowVolumeChange)
m_pStorage->AssureFree(uSize);
}
try
{
WriteHeaders(bDontAllowVolumeChange || !m_pStorage->IsSegmented());
WriteCentralEnd();
if (bDontAllowVolumeChange)
{
if (m_pStorage->GetCurrentVolume() != 0)
ThrowError(CZipException::badZipFile);
}
}
catch (...)
{
if (bDontAllowVolumeChange)
{
m_pStorage->FinalizeSegm();
m_pInfo->m_uLastVolume = 0;
}
throw;
}
m_pInfo->m_bInArchive = true;
}
void CZipCentralDir::WriteHeaders(bool bOneDisk)
{
CZipActionCallback* pCallback = m_pCallbacks->Get(CZipActionCallback::cbSave);
m_pInfo->m_uVolumeEntriesNo = 0;
m_pInfo->m_uVolumeWithCD = m_pStorage->GetCurrentVolume();
m_pInfo->m_uOffset = m_pStorage->GetPosition();
if (!m_pInfo->m_uEntriesNumber)
return;
ZIP_VOLUME_TYPE uDisk = m_pInfo->m_uVolumeWithCD;
if (pCallback)
{
pCallback->Init();
pCallback->SetTotal(m_pInfo->m_uEntriesNumber);
}
int iAborted = 0;
if (m_pInfo->m_uEntriesNumber > 0)
{
ZIP_INDEX_TYPE uLast = (ZIP_INDEX_TYPE)(m_pInfo->m_uEntriesNumber - 1);
ZIP_INDEX_TYPE i = 0;
for (;;)
{
CZipFileHeader* pHeader = (*this)[i];
m_pInfo->m_uSize += pHeader->Write(m_pStorage);
if (m_pStorage->GetCurrentVolume() != uDisk)
{
m_pInfo->m_uVolumeEntriesNo = 1;
uDisk = m_pStorage->GetCurrentVolume();
// update the information about the offset and starting volume if the
// first header was written in the new volume
if (i == 0)
{
m_pInfo->m_uOffset = 0;
m_pInfo->m_uVolumeWithCD = uDisk;
}
}
else
m_pInfo->m_uVolumeEntriesNo++;
if (pCallback)
{
bool ret, last;
if (i == uLast)
{
ret = pCallback->RequestLastCallback(1);
last = true;
}
else
{
ret = pCallback->RequestCallback();
last = false;
}
if (ret)
{
if (last)
break;
}
else
{
if (bOneDisk)
{
ASSERT(!m_pStorage->IsSegmented());
// if segmented, would need to m_pStorage->Flush(), but the headers can span multiple volumes
m_pStorage->EmptyWriteBuffer();
// remove saved part from the volume
m_pStorage->m_pFile->SetLength((ZIP_FILE_USIZE)(m_pStorage->m_uBytesBeforeZip + m_pInfo->m_uOffset));
// We can now abort safely
iAborted = CZipException::abortedSafely;
}
else
iAborted = CZipException::abortedAction;
break;
}
}
else if (i == uLast)
break;
i++;
}
}
if (pCallback)
{
pCallback->CallbackEnd();
if (iAborted)
ThrowError(iAborted);
}
}
void CZipCentralDir::WriteCentralEnd()
{
ZIP_SIZE_TYPE uSize = CENTRAL_DIR_END_SIZE + m_pInfo->m_pszComment.GetSize();
CZipAutoBuffer buf((DWORD)uSize);
char* pBuf = buf;
ZIP_VOLUME_TYPE uDisk = m_pStorage->GetCurrentVolume();
if (m_pStorage->IsSegmented() != 0)
{
// update the volume number
m_pStorage->AssureFree(uSize);
m_pInfo->m_uLastVolume = m_pStorage->GetCurrentVolume();
}
if (m_pInfo->m_uLastVolume != uDisk)
m_pInfo->m_uVolumeEntriesNo = 0;
WORD uCommentSize = (WORD)m_pInfo->m_pszComment.GetSize();
memcpy(pBuf, m_gszSignature, 4);
CBytesWriter::WriteBytes(pBuf + 4, CBytesWriter::WriteSafeU16(m_pInfo->m_uLastVolume));
CBytesWriter::WriteBytes(pBuf + 6, CBytesWriter::WriteSafeU16(m_pInfo->m_uVolumeWithCD));
CBytesWriter::WriteBytes(pBuf + 8, CBytesWriter::WriteSafeU16(m_pInfo->m_uVolumeEntriesNo));
CBytesWriter::WriteBytes(pBuf + 10, CBytesWriter::WriteSafeU16(m_pInfo->m_uEntriesNumber));
CBytesWriter::WriteBytes(pBuf + 12, CBytesWriter::WriteSafeU32(m_pInfo->m_uSize));
CBytesWriter::WriteBytes(pBuf + 16, CBytesWriter::WriteSafeU32(m_pInfo->m_uOffset));
CBytesWriter::WriteBytes(pBuf + 20, uCommentSize);
memcpy(pBuf + 22, m_pInfo->m_pszComment, uCommentSize);
if (uSize > (DWORD)(-1))
CZipException::Throw(CZipException::internalError);
m_pStorage->Write(buf, (DWORD)uSize, true);
}
void CZipCentralDir::RemoveAll()
{
ClearFindFastArray();
RemoveHeaders();
}
void CZipCentralDir::RemoveFile(CZipFileHeader* pHeader, ZIP_INDEX_TYPE uIndex, bool bShift)
{
if (uIndex == ZIP_FILE_INDEX_UNSPECIFIED)
{
// we need to know the index to remove
ZIP_INDEX_TYPE uCount = (ZIP_INDEX_TYPE)m_pHeaders->GetSize();
for (ZIP_INDEX_TYPE i = 0; i < uCount; i++)
if (pHeader == (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)i])
{
uIndex = i;
break;
}
}
ASSERT(uIndex != ZIP_FILE_INDEX_UNSPECIFIED || pHeader);
if (!pHeader)
pHeader = (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)uIndex];
if (m_pInfo->m_bFindFastEnabled)
{
ZIP_INDEX_TYPE i = FindFileNameIndex(pHeader->GetFileName());
ASSERT(i != ZIP_FILE_INDEX_NOT_FOUND);
CZipFindFast* pFindFast = (*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)i];
ZIP_INDEX_TYPE uBorderIndex = pFindFast->m_uIndex;
delete pFindFast;
pFindFast = NULL;
m_pFindArray->RemoveAt((ZIP_ARRAY_SIZE_TYPE)i);
// shift down the indexes
if (bShift)
{
ZIP_INDEX_TYPE uSize = (ZIP_INDEX_TYPE)m_pFindArray->GetSize();
for (ZIP_INDEX_TYPE j = 0; j < uSize; j++)
{
if ((*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)j]->m_uIndex > uBorderIndex)
(*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)j]->m_uIndex--;
}
}
}
if (uIndex != ZIP_FILE_INDEX_UNSPECIFIED)
{
delete pHeader;
m_pHeaders->RemoveAt((ZIP_ARRAY_SIZE_TYPE)uIndex);
}
}
void CZipCentralDir::RemoveLastFile(CZipFileHeader* pHeader, ZIP_INDEX_TYPE uIndex)
{
if (uIndex == ZIP_FILE_INDEX_UNSPECIFIED)
{
if (m_pHeaders->GetSize() == 0)
return;
uIndex = (ZIP_VOLUME_TYPE)(m_pHeaders->GetSize() - 1);
}
if (!pHeader)
pHeader = (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)uIndex];
ZIP_SIZE_TYPE uNewSize = pHeader->m_uOffset + m_pStorage->m_uBytesBeforeZip;
// then remove
RemoveFile(pHeader, uIndex);
m_pStorage->Flush();
m_pStorage->m_pFile->SetLength((ZIP_FILE_USIZE)uNewSize);
m_pInfo->m_bInArchive = false; // it is true when AutoFlush is set to true
}
ZIP_SIZE_TYPE CZipCentralDir::GetSize(bool bWhole) const
{
ZIP_SIZE_TYPE uTotal = CENTRAL_DIR_END_SIZE + m_pInfo->m_pszComment.GetSize();
ZIP_INDEX_TYPE uCount = (ZIP_INDEX_TYPE)m_pHeaders->GetSize();
if (bWhole)
{
for (ZIP_INDEX_TYPE i = 0; i < uCount; i++)
{
const CZipFileHeader* pHeader = (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)i];
uTotal += pHeader->GetSize();
}
}
return uTotal;
}
bool CZipCentralDir::RemoveDataDescr(bool bFromBuffer)
{
// this will not work if there are bytes before zip
CZipFileMapping fm;
char* pFile;
ZIP_SIZE_TYPE uSize;
if (bFromBuffer)
{
uSize = m_pStorage->m_uBytesInWriteBuffer;
pFile = m_pStorage->m_pWriteBuffer;
}
else
{
uSize = (ZIP_SIZE_TYPE)m_pStorage->m_pFile->GetLength();
// we cannot use CZipMemFile in multi-volume archive
// so it must be CZipFile
if (!fm.CreateMapping(static_cast<CZipFile*>(m_pStorage->m_pFile)))
return false;
pFile = fm.GetMappedMemory();
}
ZIP_SIZE_TYPE uOffsetToChange = 4;
ZIP_SIZE_TYPE uPosInBuffer = 0;
WORD uExtraHeaderLen;
ZIP_INDEX_TYPE uCount = (ZIP_INDEX_TYPE)m_pHeaders->GetSize();
for (ZIP_INDEX_TYPE i = 0; i < uCount; i++)
{
CZipFileHeader* pHeader = (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)i];
char* pSour = pFile + pHeader->m_uOffset;
if (pHeader->NeedsDataDescriptor())
uExtraHeaderLen = (WORD)(pHeader->IsEncrypted() ? 0 : 4);
else
{
uExtraHeaderLen = pHeader->GetDataDescriptorSize(true);
// removing data descriptor
pHeader->m_uFlag &= ~8;
// update local header:
// write modified flag in the local header
CBytesWriter::WriteBytes(pSour + 6, pHeader->m_uFlag);
pHeader->WriteSmallDataDescriptor(pSour + 14, false);
}
ZIP_SIZE_TYPE uToCopy = (i == (uCount - 1) ? uSize : (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)(i + 1)]->m_uOffset)
- pHeader->m_uOffset - uExtraHeaderLen;
if (uToCopy > 0)
// TODO: [postponed] the size_t limit on uToCopy, but creating such a big segment is unlikely (at least at the moment of writing)
memmove(pFile + uPosInBuffer, pSour, (size_t)uToCopy);
uPosInBuffer += uToCopy;
pHeader->m_uOffset -= uOffsetToChange;
uOffsetToChange += uExtraHeaderLen;
}
if (bFromBuffer)
m_pStorage->m_uBytesInWriteBuffer = (DWORD)uPosInBuffer;
else
{
m_pStorage->m_uBytesWritten = uPosInBuffer;
fm.RemoveMapping();
m_pStorage->m_pFile->SetLength((ZIP_FILE_USIZE)uPosInBuffer);
}
return true;
}
void CZipCentralDir::RemoveHeaders()
{
ZIP_INDEX_TYPE uCount = (ZIP_INDEX_TYPE)m_pHeaders->GetSize();
for (ZIP_INDEX_TYPE i = 0; i < uCount; i++)
delete (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)i];
m_pHeaders->RemoveAll();
}
void CZipCentralDir::BuildFindFastArray( bool bCaseSensitive )
{
ClearFindFastArray();
m_pInfo->m_bCaseSensitive = bCaseSensitive;
// for later
m_pInfo->m_pCompare = GetCZipStrCompFunc(bCaseSensitive);
ZIP_INDEX_TYPE uCount = (ZIP_INDEX_TYPE)m_pHeaders->GetSize();
for (ZIP_INDEX_TYPE i = 0; i < uCount; i++)
m_pFindArray->Add(new CZipFindFast((*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)i], i));
m_pFindArray->Sort(bCaseSensitive ? CompareFindFastCollate : CompareFindFastCollateNoCase);
}
void CZipCentralDir::EnableFindFast(bool bEnable, bool bCaseSensitive)
{
if (m_pInfo->m_bFindFastEnabled == bEnable)
return;
m_pInfo->m_bFindFastEnabled = bEnable;
if (bEnable)
BuildFindFastArray(bCaseSensitive);
else
m_pFindArray->RemoveAll();
}
ZIP_INDEX_TYPE CZipCentralDir::FindFile(LPCTSTR lpszFileName, bool bCaseSensitive, bool bSporadically, bool bFileNameOnly)
{
if (!m_pInfo->m_bFindFastEnabled)
EnableFindFast(true, bSporadically ? !bCaseSensitive : bCaseSensitive);
ZIP_INDEX_TYPE uResult = ZIP_FILE_INDEX_NOT_FOUND;
if (bFileNameOnly)
{
// a non-effective search (treat an array as unsorted)
// set the proper compare function
ZIPSTRINGCOMPARE pCompare = bCaseSensitive == m_pInfo->m_bCaseSensitive ? m_pInfo->m_pCompare : GetCZipStrCompFunc(bCaseSensitive);
ZIP_INDEX_TYPE uSize = (ZIP_INDEX_TYPE)m_pFindArray->GetSize();
for (ZIP_INDEX_TYPE i = 0; i < uSize; i++)
{
CZipString sz = (*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)i]->m_pHeader->GetFileName();
CZipPathComponent::RemoveSeparators(sz); // to find a dir
CZipPathComponent zpc(sz);
sz = zpc.GetFileName();
if ((sz.*pCompare)(lpszFileName) == 0)
{
uResult = i;
break;
}
}
}
else if (bCaseSensitive == m_pInfo->m_bCaseSensitive)
uResult = FindFileNameIndex(lpszFileName);
else
{
if (bSporadically)
{
// a non-effective search (treat an array as unsorted)
// do not use m_pInfo->m_pCompare, as it may be shared
ZIPSTRINGCOMPARE pCompare = GetCZipStrCompFunc(bCaseSensitive);
ZIP_INDEX_TYPE uSize = (ZIP_INDEX_TYPE)m_pFindArray->GetSize();
for (ZIP_INDEX_TYPE i = 0; i < uSize; i++)
if (((*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)i]->m_pHeader->GetFileName().*pCompare)(lpszFileName) == 0)
{
uResult = i;
break;
}
}
else
{
BuildFindFastArray(bCaseSensitive);
uResult = FindFileNameIndex(lpszFileName);
}
}
return uResult == ZIP_FILE_INDEX_NOT_FOUND ? ZIP_FILE_INDEX_NOT_FOUND : (*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)uResult]->m_uIndex;
}
ZIP_INDEX_TYPE CZipCentralDir::InsertFindFastElement(CZipFileHeader* pHeader, ZIP_INDEX_TYPE uIndex)
{
CZipString fileName = pHeader->GetFileName();
ZIP_ARRAY_SIZE_TYPE uSize = m_pFindArray->GetSize();
// Our initial binary search range encompasses the entire array of filenames:
ZIP_ARRAY_SIZE_TYPE start = 0;
ZIP_ARRAY_SIZE_TYPE end = uSize;
// Keep halving our search range until we find the right place
// to insert the new element:
while ( start < end )
{
// Find the midpoint of the search range:
ZIP_ARRAY_SIZE_TYPE midpoint = ( start + end ) / 2;
// Compare the filename with the filename at the midpoint of the current search range:
int result = CompareElement(fileName, (ZIP_INDEX_TYPE)midpoint);
// If our filename is larger, it must fall in the first half of the search range:
if ( result > 0 )
{
end = midpoint;
}
// If it's smaller, it must fall in the last half:
else if ( result < 0 )
{
start = midpoint + 1;
}
// If they're equal, we can go ahead and insert here:
else
{
start = midpoint;
break;
}
}
m_pFindArray->InsertAt(start, new CZipFindFast(pHeader, uIndex == ZIP_FILE_INDEX_UNSPECIFIED ? (ZIP_INDEX_TYPE)uSize : uIndex /* just in case */));
return (ZIP_INDEX_TYPE)start;
}
ZIP_INDEX_TYPE CZipCentralDir::FindFileNameIndex(LPCTSTR lpszFileName) const
{
ZIP_ARRAY_SIZE_TYPE start = 0;
ZIP_ARRAY_SIZE_TYPE end = m_pFindArray->GetSize();
if (end == 0)
return ZIP_FILE_INDEX_NOT_FOUND;
else
end--;
// Keep halving our search range until we find the given element:
while ( start <= end )
{
// Find the midpoint of the search range:
ZIP_ARRAY_SIZE_TYPE midpoint = ( start + end ) / 2;
// Compare the given filename with the filename at the midpoint of the search range:
int result = CompareElement(lpszFileName, (ZIP_INDEX_TYPE)midpoint);
// If our filename is smaller, it must fall in the first half of the search range:
if ( result > 0 )
{
if (midpoint == 0)
return ZIP_FILE_INDEX_NOT_FOUND;
end = midpoint - 1;
}
// If it's larger, it must fall in the last half:
else if ( result < 0 )
{
start = midpoint + 1;
}
// If they're equal, return the result:
else
{
return (ZIP_INDEX_TYPE)midpoint;
}
}
// Signal failure:
return ZIP_FILE_INDEX_NOT_FOUND;
}
void CZipCentralDir::CreateSharedData()
{
m_pInfo = new CInfo();
m_pInfo->Init();
m_pHeaders = new CZipArray<CZipFileHeader*>();
m_pFindArray = new CZipArray<CZipFindFast*>();
}
void CZipCentralDir::DestroySharedData()
{
if (!m_pInfo)
return;
#ifdef ZIP_ARCHIVE_USE_LOCKING
LockAccess();
try
{
#endif
m_pInfo->m_iReference--;
if (m_pInfo->m_iReference <= 0) // <= is just in case instead of ==
{
if (m_pHeaders != NULL)
{
RemoveHeaders();
delete m_pHeaders;
m_pHeaders = NULL;
}
if (m_pFindArray != NULL)
{
ClearFindFastArray();
delete m_pFindArray;
m_pFindArray = NULL;
}
#ifdef ZIP_ARCHIVE_USE_LOCKING
UnlockAccess();
#endif
delete m_pInfo;
m_pInfo = NULL;
}
#ifdef ZIP_ARCHIVE_USE_LOCKING
}
catch(...)
{
UnlockAccess();
throw;
}
UnlockAccess();
#endif
}

822
harbour/contrib/hbziparch/ZipCentralDir.h
View File

@@ -1,822 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCentralDir.h
* Includes the CZipCentralDir class.
*
*/
#if !defined(ZIPARCHIVE_ZIPCENTRALDIR_DOT_H)
#define ZIPARCHIVE_ZIPCENTRALDIR_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (push)
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
#endif
#include "ZipException.h"
#include "ZipFileHeader.h"
#include "ZipAutoBuffer.h"
#include "ZipCollections.h"
#include "ZipCompatibility.h"
#include "ZipExport.h"
#include "ZipCallbackProvider.h"
#include "ZipMutex.h"
/**
Represents the central directory record in the archive.
*/
class ZIP_API CZipCentralDir
{
public:
/**
Used in fast finding files by the filename.
A structure for the internal use only.
\see
CZipCentralDir::m_pFindArray
\see
CZipArchive::FindFile
\see
CZipArchive::EnableFindFast
*/
struct ZIP_API CZipFindFast
{
CZipFindFast()
{
m_uIndex = 0;
m_pHeader= NULL;
}
CZipFindFast(CZipFileHeader* pHeader, ZIP_INDEX_TYPE uIndex):m_pHeader(pHeader), m_uIndex(uIndex){}
/**
A pointer to the structure in CZipCentralDir. We extract a name from it.
*/
CZipFileHeader* m_pHeader;
/**
The index in the central directory of the #m_pHeader.
*/
ZIP_INDEX_TYPE m_uIndex;
};
/**
Stores general information about the central directory.
\see
CZipArchive::GetCentralDirInfo
*/
struct ZIP_API CInfo
{
/**
The position of the End of Central Directory Record.
In the Zip64 it points to the Zip64 counterpart.
*/
ZIP_SIZE_TYPE m_uEndOffset;
/**
The zero-based number of the volume with the End of Central Directory Record. To determine the total number of segments in an archive,
add one to this value. Request this information with CZipArchive::GetCentralDirInfo.
*/
ZIP_VOLUME_TYPE m_uLastVolume;
ZIP_VOLUME_TYPE m_uVolumeWithCD; ///< The number of the volume with the start of the central directory.
ZIP_INDEX_TYPE m_uVolumeEntriesNo; ///< The total number of entries in the central directory on the last volume.
ZIP_INDEX_TYPE m_uEntriesNumber; ///< The total number of entries in the central directory.
/**
The size of the central directory.
This value is valid only if #m_bInArchive is \c true; in other cases use the #GetSize method instead.
*/
ZIP_SIZE_TYPE m_uSize;
/**
The offset of the start of the central directory with respect to the starting volume number.
It is the value written in the central directory record.
This value is valid only if #m_bInArchive is \c true.
*/
ZIP_SIZE_TYPE m_uOffset;
/**
This value is \c true if the central directory is physically present in the archive; \c false otherwise.
*/
bool m_bInArchive;
private:
friend class CZipCentralDir;
void Init()
{
m_iReference = 1;
#ifdef ZIP_ARCHIVE_USE_LOCKING
m_mutex.Open();
#endif
m_pCompare = GetCZipStrCompFunc(ZipPlatform::GetSystemCaseSensitivity());
m_bCaseSensitive = false;
m_bFindFastEnabled = false;
m_pszComment.Release();
// initialize ( necessary when using 64 bits - we are copying only 4 bytes in Read())
m_bInArchive = false;
m_uEndOffset = 0;
m_uLastVolume = 0;
m_uVolumeWithCD = 0;
m_uVolumeEntriesNo = 0;
m_uEntriesNumber = 0;
m_uSize = 0;
m_uOffset = 0;
}
bool CheckIfOK_1()
{
return (m_uEndOffset >= m_uOffset + m_uSize);
}
ZIP_SIZE_TYPE CalculateBytesBeforeZip()
{
return m_uEndOffset - m_uSize - m_uOffset;
}
bool CheckIfOK_2()
{
return (m_uSize || !m_uEntriesNumber) && (m_uEntriesNumber || !m_uSize);
}
void DiskChange(ZIP_VOLUME_TYPE uCurrentVolume)
{
m_uLastVolume = uCurrentVolume;
if (m_uEntriesNumber)
{
m_uVolumeEntriesNo = 0;
}
else
{
m_uVolumeWithCD = m_uLastVolume;
m_uOffset = 0;
}
}
/**
Gets a value indicating if the current archive properties requires the Zip64 format.
\return
\c true, if the Zip64 is needed; \c false otherwise.
\see
<a href="kb">0610051629</a>
*/
bool NeedsZip64() const
{
return m_uLastVolume >= USHRT_MAX || m_uVolumeWithCD >= USHRT_MAX || m_uVolumeEntriesNo >= USHRT_MAX || m_uEntriesNumber >= USHRT_MAX || m_uSize >= UINT_MAX || m_uOffset >= UINT_MAX;
}
CZipAutoBuffer m_pszComment; ///< The global archive comment.
/**
The case-sensitivity of CZipCentralDir::m_pFindArray sorting.
*/
bool m_bCaseSensitive;
/**
The value set with the CZipCentralDir::EnableFindFast method.
*/
bool m_bFindFastEnabled;
private:
/**
The method used in string comparisons. It is set depending on the current case-sensitivity.
*/
ZIPSTRINGCOMPARE m_pCompare;
int m_iReference;
#ifdef ZIP_ARCHIVE_USE_LOCKING
ZipArchiveLib::CZipMutex m_mutex;
#endif
};
CZipCentralDir();
virtual ~CZipCentralDir();
static char m_gszSignature[]; ///< The End of Central Directory Record signature.
static char m_gszSignature64Locator[]; ///< The Zip64 End of Central Directory Locator signature.
CZipFileHeader* m_pOpenedFile; ///< It points to the currently opened file or it is \c NULL, if no file is opened.
/**
Initializes the object.
\param pStorage
The current storage to use.
\param pCallbacks
The current callbacks provider.
\param pStringSettings
The current string settings.
\param pSource
If not \c NULL, then it specifies the central directory for sharing.
\note
Throws exceptions.
*/
void Init(CZipStorage* pStorage, ZipArchiveLib::CZipCallbackProvider* pCallbacks, CZipStringStoreSettings* pStringSettings, CZipCentralDir* pSource = NULL);
/**
Reads the central directory from the archive.
\param bExhaustiveRead
\c true, if the exhaustive read should be performed, \c false otherwise.
\note
Throws exceptions.
\see
CZipArchive::SetExhaustiveRead
*/
void Read(bool bExhaustiveRead);
/**
Opens the file with the given index.
\param uIndex
A zero-based index of the file to open.
\note
Throws exceptions.
*/
void OpenFile(ZIP_INDEX_TYPE uIndex);
/**
Tests if the given file index is valid.
\param uIndex
A zero-based index to test.
\return
\c true, if the file with the given index exists inside the archive; \c false otherwise.
*/
bool IsValidIndex(ZIP_INDEX_TYPE uIndex)const;
/**
Removes the file header from the central directory.
\param pHeader
The header to remove.
\param uIndex
The index of the header to remove. Use \c ZIP_FILE_INDEX_UNSPECIFIED, if the index is not known.
\param bShift
If \c true, the data inside the archive is moved over the hole created after removing the file.
If \c false, the unused area inside the archive remains.
\note
Throws exceptions.
*/
void RemoveFile(CZipFileHeader* pHeader, ZIP_INDEX_TYPE uIndex = ZIP_FILE_INDEX_UNSPECIFIED, bool bShift = true);
/**
Removes last file from the central directory.
\param pHeader
The header to remove.
\param uIndex
The index of the header to remove. Use \c ZIP_FILE_INDEX_UNSPECIFIED, if the index is not known.
*/
void RemoveLastFile(CZipFileHeader* pHeader = NULL, ZIP_INDEX_TYPE uIndex = ZIP_FILE_INDEX_UNSPECIFIED);
/**
Removes all files.
\note
Throws exceptions.
*/
void RemoveAll();
/**
Closes the central directory.
*/
void Close();
/**
Adds a new file to the central directory.
\param header
Used as a template for the data stored inside the archive.
\param uReplaceIndex
The index of the file to be replaced. Use \c ZIP_FILE_INDEX_UNSPECIFIED, if the index is not known.
\param iLevel
The compression level.
\param bRichHeaderTemplateCopy
\c true, if copy crc and sizes values from \a header; \c false otherwise.
\return
The new header.
\note
Throws exceptions.
*/
CZipFileHeader* AddNewFile(const CZipFileHeader & header, ZIP_INDEX_TYPE uReplaceIndex, int iLevel, bool bRichHeaderTemplateCopy = false);
/**
Removes physically the central directory from the archive.
\note
Throws exceptions.
*/
void RemoveFromDisk();
/**
Gets the central directory size.
\param bWhole
If \c true, include the size of the file headers.
If \c false, the size of the file headers is not included.
\return
The size of the central directory.
\see
CZipArchive::GetCentralDirSize
*/
ZIP_SIZE_TYPE GetSize(bool bWhole = false) const;
/**
Closes a file opened for reading inside the archive.
\param skipCheckingDataDescriptor
If \c true, the data descriptor that is located after the compressed data in the archive is checked for validity.
Set this value to \c false after closing the file after an exception was thrown.
\note
Throws exceptions.
*/
void CloseFile(bool skipCheckingDataDescriptor = false);
/**
Closes a file opened for reading inside the archive.
\note
Throws exceptions.
*/
void CloseNewFile();
/**
Writes the central directory to the archive.
\note
Throws exceptions.
*/
void Write();
/**
Enables Find Fast.
\see
CZipArchive::EnableFindFast
*/
void EnableFindFast(bool bEnable, bool bCaseSensitive);
/**
Searches for the file.
\see
CZipArchive::FindFile
*/
ZIP_INDEX_TYPE FindFile(LPCTSTR lpszFileName, bool bCaseSensitive, bool bSporadically, bool bFileNameOnly);
/**
Gets the Find Fast index.
\see
CZipArchive::GetFindFastIndex
*/
ZIP_INDEX_TYPE GetFindFastIndex(ZIP_INDEX_TYPE uFindFastIndex)const
{
if (!IsValidIndex(uFindFastIndex) || !m_pInfo->m_bFindFastEnabled)
return ZIP_FILE_INDEX_NOT_FOUND;
return (*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)uFindFastIndex]->m_uIndex;
}
/**
Points to CZipArchive::m_storage.
*/
CZipStorage* m_pStorage;
/**
Points to the current callback provider.
*/
ZipArchiveLib::CZipCallbackProvider* m_pCallbacks;
/**
Gets the information about the file with the given index.
\see
CZipArchive::operator[](ZIP_INDEX_TYPE)
*/
CZipFileHeader* operator[](ZIP_INDEX_TYPE uIndex)
{
return (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)uIndex];
}
/**
Gets the information about the file with the given index.
\see
CZipArchive::operator[](ZIP_INDEX_TYPE) const
*/
const CZipFileHeader* operator[](ZIP_INDEX_TYPE uIndex) const
{
return (*m_pHeaders)[(ZIP_ARRAY_SIZE_TYPE)uIndex];
}
/**
Gets the number of files in the archive.
\return
The number of files in the archive.
*/
ZIP_ARRAY_SIZE_TYPE GetCount() const
{
return m_pHeaders == NULL ? 0 : m_pHeaders->GetSize();
}
/**
Sets the global comment.
\see
CZipArchive::SetGlobalComment
*/
void SetComment(LPCTSTR lpszComment);
/**
Gets the global comment.
\see
CZipArchive::GetGlobalComment
*/
void GetComment(CZipString& szComment) const
{
ZipCompatibility::ConvertBufferToString(szComment, m_pInfo->m_pszComment, m_pStringSettings->m_uCommentCodePage);
}
/**
Sets the file comment.
\see
CZipArchive::SetFileComment
*/
bool SetFileComment(ZIP_INDEX_TYPE uIndex, LPCTSTR lpszComment);
/**
Finds the index of the file with the given name.
\param lpszFileName
The name of the file to find.
\return
The index in CZipCentralDir::m_pFindArray with the corresponding CZipFindFast structure
or \c ZIP_FILE_INDEX_NOT_FOUND, if there is no such file with the given name.
\see
CZipArchive::FindFile
*/
ZIP_INDEX_TYPE FindFileNameIndex(LPCTSTR lpszFileName) const;
/**
Gets the information about the central directory.
\see
CZipArchive::GetCentralDirInfo
*/
void GetInfo(CInfo& info) const {info = *m_pInfo;}
/**
Gets a value indicating whether the Find Fast feature is enabled or not.
\return
The value of CInfo::m_bFindFastEnabled.
*/
bool IsFindFastEnabled(){return m_pInfo->m_bFindFastEnabled;}
/**
Rebuilds the CZipCentralDir::m_pFindArray array.
*/
void RebuildFindFastArray()
{
if (m_pInfo->m_bFindFastEnabled)
BuildFindFastArray(m_pInfo->m_bCaseSensitive);
}
/**
The current string store settings.
\see
SetStringStoreSettings
*/
CZipStringStoreSettings* m_pStringSettings;
/**
Consistency checks to ignore. Can be one or more of the CZipArchive::ConsistencyCheck values.
\see
CZipArchive::SetIgnoredConsistencyChecks
*/
int m_iIgnoredChecks;
/**
Checks if the specified consistency check should be performed or not.
\param iLevel
The level to check. Can be one or more of CZipArchive::ConsistencyCheck values.
\return
\c true, if the specified check should be performed; \c false otherwise.
\see
m_iIgnoredChecks
*/
bool IsConsistencyCheckOn(int iLevel)
{
// check, if not ignored
return (m_iIgnoredChecks & iLevel) == 0;
}
protected:
#if _MSC_VER > 1000
#pragma warning( push )
#pragma warning (disable : 4702) // unreachable code
#endif
/**
The method used in comparison when sorting headers.
*/
static int CompareHeaders(const void *pArg1, const void *pArg2)
{
CZipFileHeader* pw1 = *(CZipFileHeader**)pArg1;
CZipFileHeader* pw2 = *(CZipFileHeader**)pArg2;
if (pw1 == pw2)
return 0;
if (pw1->m_uVolumeStart == pw2->m_uVolumeStart)
{
if (pw1->m_uOffset < pw2->m_uOffset)
return -1;
else if (pw1->m_uOffset > pw2->m_uOffset)
return 1;
ASSERT(FALSE);
// two files with the same offsets in the same volume???
CZipException::Throw(CZipException::badZipFile);
return 0; // just for the compiler comfort (and discomfort of another)
}
else if (pw1->m_uVolumeStart < pw2->m_uVolumeStart)
return -1;
else // if (pw1->m_uVolumeStart > pw2->m_uVolumeStart)
return 1;
}
#if _MSC_VER > 1000
#pragma warning( pop )
#endif
static int CompareFindFastCollate(const void* pArg1, const void* pArg2)
{
CZipFindFast* pHeader1 = *(CZipFindFast**)pArg1;
CZipFindFast* pHeader2 = *(CZipFindFast**)pArg2;
return pHeader1->m_pHeader->GetFileName().Collate(pHeader2->m_pHeader->GetFileName());
}
static int CompareFindFastCollateNoCase(const void* pArg1, const void* pArg2)
{
CZipFindFast* pHeader1 = *(CZipFindFast**)pArg1;
CZipFindFast* pHeader2 = *(CZipFindFast**)pArg2;
return pHeader1->m_pHeader->GetFileName().CollateNoCase(pHeader2->m_pHeader->GetFileName());
}
/**
Holds the information about all the files inside the archive.
\see
CZipFileHeader
*/
CZipArray<CZipFileHeader*>* m_pHeaders;
/**
Builds the CZipCentralDir::m_pFindArray array.
*/
void BuildFindFastArray( bool bCaseSensitive );
void ClearFindFastArray()
{
ZIP_ARRAY_SIZE_TYPE uCount = m_pFindArray->GetSize();
for (ZIP_ARRAY_SIZE_TYPE i = 0; i < uCount; i++)
delete (*m_pFindArray)[i];
m_pFindArray->RemoveAll();
}
/**
The Find Fast array.
\see
CZipFindFast
\see
CInfo::m_bFindFastEnabled
\see
CZipArchive::FindFile
*/
CZipArray<CZipFindFast*>* m_pFindArray;
/**
The method used in comparison involving the Find Fast feature.
\param lpszFileName
The name of the file.
\param uIndex
The index from the CZipCentralDir::m_pFindArray array.
\return
The return value has the following meaning:
- 0 if the filenames are the same
- < 0 if the filename stored in the array is less than \a lpszFileName
- > 0 if the filename stored in the array is greater than \a lpszFileName
*/
int CompareElement(LPCTSTR lpszFileName, ZIP_INDEX_TYPE uIndex) const
{
return ((*m_pFindArray)[(ZIP_ARRAY_SIZE_TYPE)uIndex]->m_pHeader->GetFileName().*(m_pInfo->m_pCompare))(lpszFileName);
}
/**
Inserts a new CZipFindFast element to the CZipCentralDir::m_pFindArray array
Initializes the CZipFindFast object with \a pHeader and \a uIndex values.
\param pHeader
The element to insert.
\param uIndex
The original index of \a pHeader in the central directory.
If set to \c ZIP_FILE_INDEX_UNSPECIFIED, it is assumed to be the last element.
\return
The index in the CZipCentralDir::m_pFindArray array.
*/
ZIP_INDEX_TYPE InsertFindFastElement(CZipFileHeader* pHeader, ZIP_INDEX_TYPE uIndex);
/**
The central directory information.
\see
CInfo
*/
CInfo* m_pInfo;
/**
Reads file headers from the archive.
\param bExhaustiveRead
\c true, if the exhaustive read should be performed, \c false otherwise.
\note
Throws exceptions.
\see
CZipArchive::SetExhaustiveRead
*/
void ReadHeaders(bool bExhaustiveRead);
/**
Frees the memory allocated for the CZipFileHeader structures.
*/
void RemoveHeaders();
/**
Removes data descriptors from a segmented archive that turned out to be one-segment only.
It is not called for encrypted files.
\param bFromBuffer
If \c true, removes from the write buffer in memory otherwise from the file on the disk.
\return
\c false, if the file mapping to memory was not successful
(can happen only when \a bFromBuffer is \c false); \c true otherwise.
\note
Throws exceptions.
*/
bool RemoveDataDescr(bool bFromBuffer);
/**
Writes the file headers to the archive.
\note
Throws exceptions.
*/
void WriteHeaders(bool bOneDisk);
/**
Writes the End of Central Directory Record.
\return
The size of the record.
\note
Throws exceptions.
*/
void WriteCentralEnd();
/**
Throws an exception with the given code.
*/
void ThrowError(int err) const;
/**
Creates data that can be shared between different archive objects.
\see
DestroySharedData
*/
void CreateSharedData();
/**
Destroys data shared between different archive objects, if the usage reference count
of the data is zero.
\note
Throws exceptions.
\see
CreateSharedData
*/
void DestroySharedData();
#ifdef ZIP_ARCHIVE_USE_LOCKING
/**
Locks the access to the shared data.
\note
Throws exceptions.
\see
UnlockAccess
\see
CreateSharedData
*/
void LockAccess()
{
ASSERT(m_pInfo);
m_pInfo->m_mutex.Lock();
}
/**
Unlocks the access to the shared data.
\note
Throws exceptions.
\see
LockAccess
\see
CreateSharedData
*/
void UnlockAccess()
{
if (m_pInfo)
m_pInfo->m_mutex.Unlock();
}
#endif
};
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (pop)
#endif
#endif // !defined(ZIPARCHIVE_ZIPCENTRALDIR_DOT_H)

41
harbour/contrib/hbziparch/ZipCollections.h
View File

@@ -1,41 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCollections.h
* Includes the collections classes used by the ZipArchive Library.
*
*/
#ifndef ZIPARCHIVE_ZIPCOLLECTIONS_DOT_H
#define ZIPARCHIVE_ZIPCOLLECTIONS_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "_platform.h"
#include "ZipExport.h"
#ifdef ZIP_ARCHIVE_STL
#include "ZipCollections_stl.h"
#else
#include "ZipCollections_mfc.h"
#endif
typedef CZipArray<ZIP_INDEX_TYPE> CZipIndexesArray;
#endif /* ZIPARCHIVE_ZIPCOLLECTIONS_DOT_H */

91
harbour/contrib/hbziparch/ZipCollections_mfc.h
View File

@@ -1,91 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPCOLLECTIONS_DOT_H
#error Do not include this file directly. Include ZipCollections.h instead
#endif
#if _MSC_VER > 1000
#pragma warning( push )
#pragma warning (disable:4786) // 'identifier' : identifier was truncated to 'number' characters in the debug information
#endif
#include <afxtempl.h>
#define ZIP_ARRAY_SIZE_TYPE INT_PTR
typedef CStringArray CZipStringArray;
template <class TYPE>
class CZipArray : public CArray<TYPE, TYPE>
{
public:
typedef int (*CompareFunction)(const void* pArg1, const void* pArg2);
private:
static int CompareAsc(const void *pArg1, const void *pArg2)
{
TYPE w1 = *(TYPE*)pArg1;
TYPE w2 = *(TYPE*)pArg2;
return w1 == w2 ? 0 :(w2 > w1 ? - 1 : 1);
}
static int CompareDesc(const void *pArg1, const void *pArg2)
{
TYPE w1 = *(TYPE*)pArg1;
TYPE w2 = *(TYPE*)pArg2;
return w1 == w2 ? 0 :(w1 > w2 ? - 1 : 1);
}
public:
void Sort(bool bAscending)
{
Sort(bAscending ? CompareAsc : CompareDesc);
}
void Sort(CompareFunction pFunction)
{
INT_PTR uSize = GetSize();
if (!uSize) // if ommitted operator [] will fail if empty
return;
qsort((void*)&((*this)[0]), (size_t)uSize , sizeof(TYPE), pFunction);
}
};
template<class TYPE>
class CZipPtrList : public CTypedPtrList<CPtrList, TYPE>
{
public:
typedef POSITION iterator;
typedef POSITION const_iterator;
bool IteratorValid(const iterator &iter) const
{
return iter != NULL;
}
};
template<class KEY, class VALUE>
class CZipMap : public CMap<KEY, KEY, VALUE, VALUE>
{
public:
typedef POSITION iterator;
typedef POSITION const_iterator;
bool IteratorValid(const iterator &iter) const
{
return iter != NULL;
}
};
#if _MSC_VER > 1000
#pragma warning( pop )
#endif

226
harbour/contrib/hbziparch/ZipCollections_stl.h
View File

@@ -1,226 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPCOLLECTIONS_DOT_H
#error Do not include this file directly. Include ZipCollections.h instead
#endif
#if _MSC_VER > 1000
#pragma warning( push, 3 ) // STL
#pragma warning (disable : 4284) //return type for 'identifier::operator >' is not a UDT or reference to a UDT. Will produce errors if applied using infix notation
#pragma warning (disable : 4018) //'expression' : signed/unsigned mismatch
#endif
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include <functional>
#include "ZipString.h"
#include "ZipException.h"
#define ZIP_ARRAY_SIZE_TYPE size_t
template<class TYPE>
class CZipArray : private std::vector<TYPE>
{
public:
typedef int (*CompareFunction)(const void* pArg1, const void* pArg2);
private:
struct Sorter
{
CompareFunction m_pFunction;
Sorter(CompareFunction pFunction)
{
m_pFunction = pFunction;
}
bool operator ()(TYPE const& t1, TYPE const& t2)
{
return (*m_pFunction)(&t1, &t2) < 0;
}
};
public:
typedef typename std::vector<TYPE>::iterator iterator;
typedef typename std::vector<TYPE> inherited;
protected:
iterator GetIterFromIndex(size_t uIndex)
{
iterator iter = this->begin();
iter += uIndex;
// int t = 0; while (t != uIndex) {iter++;t++;}
return iter;
}
public:
void Sort(bool bAscending)
{
if (bAscending)
std::sort (this->begin(), this->end(), std::less<TYPE>());
else
std::sort (this->begin(), this->end(), std::greater<TYPE>());
}
void Sort(CompareFunction pFunction)
{
std::sort(this->begin(), this->end(), Sorter(pFunction));
}
size_t GetSize() const{return this->size(); }
size_t GetCount() const{return this->size(); }
size_t GetUpperBound() const
{
size_t ret = this->size();
if (ret == 0)
CZipException::Throw(CZipException::outOfBounds);
return ret - 1;
}
TYPE& GetAt(size_t uIndex) {return this->at(uIndex);}
const TYPE& GetAt(size_t uIndex) const {return this->at(uIndex);}
size_t Add(const TYPE& x) {push_back(x);return GetUpperBound();}
void RemoveAll() {this->clear();}
void RemoveAt(size_t uIndex) { erase(GetIterFromIndex(uIndex));}
void InsertAt(size_t uIndex, const TYPE& x){insert(GetIterFromIndex(uIndex), x);}
TYPE& operator[](size_t uIndex)
{
return inherited::operator[](uIndex);
}
TYPE operator[](size_t uIndex) const
{
return inherited::operator[](uIndex);
}
};
typedef CZipArray<CZipString> CZipStringArray;
typedef CZipArray<WORD> CZipWordArray;
template<class TYPE>
class CZipPtrList : private std::list<TYPE>
{
public:
typedef typename std::list<TYPE>::iterator iterator;
typedef typename std::list<TYPE>::const_iterator const_iterator;
size_t GetCount() const {return this->size();}
void AddTail(const TYPE& x){push_back(x);}
void AddHead(const TYPE& x){push_front(x);}
void RemoveHead() {this->pop_front();}
void RemoveTail() {this->pop_back();}
void RemoveAll() {this->clear();}
TYPE& GetHead() {return this->front();}
TYPE GetHead() const {return this->front();}
TYPE& GetTail() {return this->back();}
TYPE GetTail() const {return this->back();}
iterator GetHeadPosition() { return this->begin();}
const_iterator GetHeadPosition() const { return this->begin();}
iterator GetTailPosition() { return this->back();}
TYPE& GetNext(iterator& pos) { return *pos++;}
const TYPE GetNext(const_iterator& pos) const{ return *pos++;}
TYPE& GetPrev(iterator& pos) { return *pos--;}
TYPE GetPrev(iterator& pos) const{ return *pos--;}
iterator Find(TYPE& x) { return std::find(this->begin(), this->end(), x);}
void RemoveAt(iterator& pos) { erase(pos);}
bool IteratorValid(const_iterator &iter) const
{
return iter != this->end();
}
bool IteratorValid(iterator &iter)
{
return iter != this->end();
}
iterator FindIndex(size_t uIndex)
{
iterator iter = this->begin();
size_t t = 0; while (t != uIndex) {iter++;t++;}
return iter;
}
const_iterator FindIndex(size_t uIndex) const
{
const_iterator iter = this->begin();
size_t t = 0; while (t != uIndex) {iter++;t++;}
return iter;
}
TYPE& GetAt(const iterator& pos) { return *pos;}
TYPE GetAt(const_iterator& pos) const{ return *pos;}
};
// simplified and partial only
template<class KEY, class VALUE>
class CZipMap : private std::map<KEY, VALUE>
{
public:
typedef typename std::map<KEY, VALUE>::iterator iterator;
typedef typename std::map<KEY, VALUE>::const_iterator const_iterator;
typedef typename std::map<KEY,VALUE, std::less<KEY>, std::allocator<std::pair<const KEY, VALUE> > >::value_type v_type;
void SetAt( KEY key, VALUE newValue)
{
insert(v_type(key, newValue));
}
ZBOOL RemoveKey( KEY key )
{
return erase(key) != 0;
}
ZBOOL Lookup( KEY key, VALUE& rValue ) const
{
#if (__GNUC__ >= 3) // The actual version number may be different.
const_iterator iter = std::map<KEY, VALUE>::find(key);
if (iter == std::map<KEY, VALUE>::end())
#else
const_iterator iter = find(key);
if (iter == end())
#endif
return FALSE;
else
{
rValue = iter->second;
return TRUE;
}
}
iterator GetStartPosition() { return this->begin();}
const_iterator GetStartPosition() const { return this->begin();}
bool IteratorValid(const_iterator &iter) const
{
return iter != this->end();
}
bool IteratorValid(iterator &iter)
{
return iter != this->end();
}
void GetNextAssoc(iterator &iter, KEY& key, VALUE& value)
{
key = iter->first;
value = iter->second;
iter++;
}
void GetNextAssoc(const_iterator &iter, KEY& key, VALUE& value)
{
key = iter->first;
value = iter->second;
iter++;
}
void RemoveAll() {this->clear();}
};
#if _MSC_VER > 1000
#pragma warning( pop)
#endif

219
harbour/contrib/hbziparch/ZipCompatibility.cpp
View File

@@ -1,219 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipCompatibility.h"
#include "ZipPlatform.h"
#include "ZipException.h"
#include "ZipAutoBuffer.h"
#include "ZipFileHeader.h"
enum iInternalAttr
{
attROnly = 0x01,
attHidd = 0x02,
attSys = 0x04,
attDir = 0x10,
attArch = 0x20
};
// *********************** WINDOWS **************************
#ifndef _WIN32
#define FILE_ATTRIBUTE_READONLY 0x00000001
#define FILE_ATTRIBUTE_HIDDEN 0x00000002
#define FILE_ATTRIBUTE_SYSTEM 0x00000004
#define FILE_ATTRIBUTE_DIRECTORY 0x00000010
#define FILE_ATTRIBUTE_ARCHIVE 0x00000020
#endif
// *********************** UINX **************************
#define USER_PERMISSIONS_MASK 0x01C0
#define EXTRACT_USER_PERMISSIONS(x) ((x & USER_PERMISSIONS_MASK) >> 6)
#define CREATE_USER_PERMISSIONS(x) ((x & 0x0007) << 6)
#define GROUP_PERMISSIONS_MASK 0x0038
#define CREATE_GROUP_PERMISSIONS(x) ((x & 0x0007) << 3)
#define OTHER_PERMISSIONS_MASK 0x0007
#define CREATE_OTHER_PERMISSIONS(x) (x & 0x0007)
#define UNIX_DIRECTORY_ATTRIBUTE 0x4000
#define UNIX_FILE_ATTRIBUTE 0x8000
#define UNIX_EXEC 1
#define UNIX_WRITE 2
#define UNIX_READ 4
using namespace ZipCompatibility;
typedef DWORD(*conv_func)(DWORD , bool );
DWORD AttrDos(DWORD , bool );
DWORD AttrUnix(DWORD, bool);
DWORD AttrMac(DWORD , bool );
conv_func conv_funcs[11] = {AttrDos,
NULL,
NULL,
AttrUnix,
NULL,
NULL,
AttrDos,
AttrMac,
NULL,
NULL,
AttrDos
};
DWORD ZipCompatibility::ConvertToSystem(DWORD uAttr, int iFromSystem, int iToSystem)
{
if (iToSystem != iFromSystem && iFromSystem < 11 && iToSystem < 11)
{
conv_func p = conv_funcs[iFromSystem], q = conv_funcs[iToSystem];
if (p && q)
uAttr = q( p(uAttr, true), false);
else
CZipException::Throw(CZipException::platfNotSupp);
}
return uAttr;
}
DWORD AttrDos(DWORD uAttr, bool )
{
return uAttr;
}
DWORD AttrUnix(DWORD uAttr, bool bFrom)
{
DWORD uNewAttr = 0;
if (bFrom)
{
bool isDir = (uAttr & UNIX_DIRECTORY_ATTRIBUTE) != 0;
if (isDir)
uNewAttr = attDir;
uAttr = EXTRACT_USER_PERMISSIONS (uAttr);
// we may set archive attribute if the file hasn't got the execute permissions
// and is not a directory
if (!isDir && !(uAttr & UNIX_EXEC))
uNewAttr |= attArch ;
if (!(uAttr & UNIX_WRITE))
uNewAttr |= attROnly;
if (!(uAttr & UNIX_READ))
uNewAttr |= attHidd;
}
else
{
uNewAttr = 0;
// we cannot assume that if the file hasn't the archive attribute set
// then it is executable and set execute permissions
if (!(uAttr & attHidd))
uNewAttr |= (CREATE_OTHER_PERMISSIONS (UNIX_READ) | CREATE_GROUP_PERMISSIONS (UNIX_READ)) |
CREATE_USER_PERMISSIONS (UNIX_READ);
if (!(uAttr & attROnly))
uNewAttr |= (CREATE_GROUP_PERMISSIONS (UNIX_WRITE) | CREATE_USER_PERMISSIONS (UNIX_WRITE));
if (uAttr & attDir)
{
uNewAttr |= UNIX_DIRECTORY_ATTRIBUTE;
uNewAttr |= (CREATE_OTHER_PERMISSIONS (UNIX_EXEC) | CREATE_GROUP_PERMISSIONS (UNIX_EXEC)) |
CREATE_USER_PERMISSIONS (UNIX_EXEC);
}
else
uNewAttr |= UNIX_FILE_ATTRIBUTE;
}
return uNewAttr;
}
DWORD AttrMac(DWORD uAttr, bool )
{
return uAttr & (attDir | attROnly);
}
// ************************************************************************
ZIPINLINE bool ZipCompatibility::IsPlatformSupported(int iCode)
{
return iCode == zcDosFat || iCode == zcUnix || iCode == zcMacintosh
|| iCode == zcNtfs || iCode == zcOs2Hpfs;
}
void ZipCompatibility::ConvertBufferToString(CZipString& szString, const CZipAutoBuffer& buffer, UINT uCodePage)
{
#ifdef _UNICODE
ZipPlatform::MultiByteToWide(buffer, szString, uCodePage);
#else
// iLen does not include the NULL character
int iLen;
if (uCodePage == CP_OEMCP)
{
CZipAutoBuffer buf;
buf = buffer;
ZipPlatform::AnsiOem(buf, false);
iLen = buf.GetSize();
memcpy(szString.GetBuffer(iLen), buf.GetBuffer(), iLen);
}
else
{
iLen = buffer.GetSize();
memcpy(szString.GetBuffer(iLen), buffer.GetBuffer(), iLen);
}
szString.ReleaseBuffer(iLen);
#endif
}
void ZipCompatibility::ConvertStringToBuffer(LPCTSTR lpszString, CZipAutoBuffer& buffer, UINT uCodePage)
{
#ifdef _UNICODE
ZipPlatform::WideToMultiByte(lpszString, buffer, uCodePage);
#else
int iLen = (int)strlen(lpszString);
// iLen does not include the NULL character
buffer.Allocate(iLen);
memcpy(buffer, lpszString, (size_t)iLen);
if (uCodePage == CP_OEMCP)
ZipPlatform::AnsiOem(buffer, true);
#endif
}
void ZipCompatibility::SlashBackslashChg(CZipString& szFileName, bool bReplaceSlash)
{
TCHAR t1 = _T('\\') /*backslash*/, t2 = _T('/'), c1, c2;
if (bReplaceSlash)
{
c1 = t1;
c2 = t2;
}
else
{
c1 = t2;
c2 = t1;
}
szFileName.Replace(c2, c1);
}

145
harbour/contrib/hbziparch/ZipCompatibility.h
View File

@@ -1,145 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCompatibility.h
* ZipCompatibility namespace declaration.
*
*/
#if !defined(ZIPARCHIVE_ZIPCOMPATIBILITY_DOT_H)
#define ZIPARCHIVE_ZIPCOMPATIBILITY_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
class CZipAutoBuffer;
class CZipFileHeader;
#include "ZipString.h"
/**
Includes functions that provide support for the proper conversion of attributes
and filenames between different system platforms.
*/
namespace ZipCompatibility
{
/**
The codes of the compatibility of the file attribute information.
\see
CZipArchive::GetSystemCompatibility
\see
CZipFileHeader::GetSystemCompatibility
\see
ZipPlatform::GetSystemID
*/
enum ZipPlatforms
{
zcDosFat, ///< MS-DOS and OS/2 (FAT / VFAT / FAT32 file systems)
zcAmiga, ///< Amiga
zcVaxVms, ///< VAX/VMS
zcUnix, ///< Unix / Linux
zcVmCms, ///< VM/CMS
zcAtari, ///< Atari ST
zcOs2Hpfs, ///< OS/2 H.P.F.S.
zcMacintosh, ///< Macintosh
zcZsystem, ///< Z-System
zcCpm, ///< CP/M
zcNtfs ///< Windows NTFS
};
/**
Checks whether the system with the given code is supported by the ZipArchive Library.
\param iCode
One of the #ZipPlatforms values to check.
\return
\c true, if supported; \c false otherwise.
*/
bool IsPlatformSupported(int iCode);
/**
Converts the system attributes between different system platforms.
\param uAttr
The attributes to convert.
\param iFromSystem
The system code to convert \a uAttr from.
\param iToSystem
The system code to convert \a uAttr to.
\return
The converted attributes.
\note
Throws exceptions.
\see
ZipPlatforms
*/
DWORD ConvertToSystem(DWORD uAttr, int iFromSystem, int iToSystem);
/**
Converts the string stored in \a buffer using the given code page.
\param buffer
The buffer to convert the string from.
\param szString
The string to receive the result.
\param uCodePage
The code page used in conversion.
\see
<a href="kb">0610051525</a>
*/
void ConvertBufferToString(CZipString& szString, const CZipAutoBuffer& buffer, UINT uCodePage);
/**
Converts the \a lpszString using the given code page.
\param lpszString
The string to convert from.
\param buffer
The buffer to receive the result.
\param uCodePage
The code page used in conversion.
\see
<a href="kb">0610051525</a>
*/
void ConvertStringToBuffer(LPCTSTR lpszString, CZipAutoBuffer& buffer, UINT uCodePage);
/**
Changes the path separators from slash to backslash or vice-versa in \a szFileName.
\param szFileName
The filename to have the path separators changed.
\param bReplaceSlash
If \c true, changes slash to backslash. If \c false, changes backslash to slash.
*/
void SlashBackslashChg(CZipString& szFileName, bool bReplaceSlash);
};
#endif // !defined(ZIPARCHIVE_ZIPCOMPATIBILITY_DOT_H)

104
harbour/contrib/hbziparch/ZipCompressor.cpp
View File

@@ -1,104 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipCompressor.h"
#include "BytesWriter.h"
#include "DeflateCompressor.h"
using namespace ZipArchiveLib;
CZipCompressor* CZipCompressor::CreateCompressor(WORD uMethod, CZipStorage* pStorage)
{
if (uMethod == methodStore || uMethod == methodDeflate)
return new CDeflateCompressor(pStorage);
return NULL;
}
void CZipCompressor::UpdateFileCrc(const void *pBuffer, DWORD uSize)
{
m_pFile->m_uCrc32 = zarch_crc32(m_pFile->m_uCrc32, (zarch_Bytef*)pBuffer, uSize);
}
void CZipCompressor::UpdateCrc(const void *pBuffer, DWORD uSize)
{
m_uCrc32 = zarch_crc32(m_uCrc32, (zarch_Bytef*)pBuffer, uSize);
}
void CZipCompressor::UpdateOptions(const COptionsMap& optionsMap)
{
const COptions* pOptions = GetOptions();
if (pOptions == NULL)
return;
const COptions* pNewOptions = optionsMap.Get(pOptions->GetType());
if (pNewOptions != NULL)
UpdateOptions(pNewOptions);
}
void CZipCompressor::InitBuffer()
{
// This should be greated that 64k for deflate when creating offsets pairs is enabled
// otherwise deflate will not be able to write one block in one go and will never report
// a flushed block for low-compressable data
const COptions* pOptions = GetOptions();
DWORD bufferSize = 0;
if (pOptions != NULL)
bufferSize = pOptions->m_iBufferSize;
if (bufferSize == 0)
bufferSize = COptions::cDefaultBufferSize;
m_pBuffer.Allocate(bufferSize);
}
void CZipCompressor::COptionsMap::Set(const CZipCompressor::COptions* pOptions)
{
if (pOptions == NULL)
return;
int iType = pOptions->GetType();
Remove(iType);
SetAt(iType, pOptions->Clone());
}
CZipCompressor::COptions* CZipCompressor::COptionsMap::Get(int iType) const
{
COptions* pTemp = NULL;
if (Lookup(iType, pTemp))
return pTemp;
else
return NULL;
}
void CZipCompressor::COptionsMap::Remove(int iType)
{
COptions* pTemp = Get(iType);
if (pTemp != NULL)
{
delete pTemp;
RemoveKey(iType);
}
}
CZipCompressor::COptionsMap::~COptionsMap()
{
COptionsMap::iterator iter = GetStartPosition();
while (IteratorValid(iter))
{
COptions* pOptions = NULL;
int iType = 0;
GetNextAssoc(iter, iType, pOptions);
delete pOptions;
}
RemoveAll();
}

485
harbour/contrib/hbziparch/ZipCompressor.h
View File

@@ -1,485 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCompressor.h
* Includes the CZipCompressor class.
*
*/
#if !defined(ZIPARCHIVE_ZIPCOMPRESSOR_DOT_H)
#define ZIPARCHIVE_ZIPCOMPRESSOR_DOT_H
#if _MSC_VER > 1000
#pragma once
#pragma warning( push )
#pragma warning (disable : 4100) // unreferenced formal parameter
#endif
#include "ZipExport.h"
#include "ZipAutoBuffer.h"
#include "ZipFileHeader.h"
#include "ZipStorage.h"
#include "ZipCryptograph.h"
#include "ZipException.h"
/**
A base class for compressors used in compression and decompression of data.
*/
class ZIP_API CZipCompressor
{
protected:
CZipStorage* m_pStorage; ///< The current storage object.
CZipAutoBuffer m_pBuffer; ///< A buffer that receives compressed data or provides data for decompression.
CZipCryptograph* m_pCryptograph; ///< Current cryptograph.
CZipFileHeader* m_pFile; ///< The file header being compressed or decompressed.
/**
Initializes a new instance of the CZipCompressor class.
\param pStorage
The current storage object.
*/
CZipCompressor(CZipStorage* pStorage)
:m_pStorage(pStorage)
{
m_pCryptograph = NULL;
m_uUncomprLeft = 0;
m_uComprLeft = 0;
m_uCrc32 = 0;
}
public:
/**
The type of a compressor.
*/
enum CompressorType
{
typeDeflate = 1, ///< Deflate compression (default in zip archives).
typeBzip2 ///< Bzip2 compression.
};
/**
The compression level.
*/
enum CompressionLevel
{
levelDefault = -1, ///< The default compression level (equals 6 for deflate).
levelStore = 0, ///< No compression used. Data is stored.
levelFastest = 1, ///< The fastest compression. The compression ratio is the lowest (apart from #levelStore).
levelBest = 9 ///< The highest compression ratio. It's usually the slowest.
};
/**
The compression method.
*/
enum CompressionMethod
{
methodStore = 0, ///< A file is stored, not compressed.
methodDeflate = 8, ///< The deflate compression method.
/**
A file is compressed using the bzip2 algorithm.
\see
<a href="kb">0610231446|bzip2</a>
*/
methodBzip2 = 12,
/**
This value means that WinZip AES encryption is used.
The original compression method is stored in a WinZip extra field.
It is only an informational value - you cannot set it as a compression method. The ZipArchive
Library handles this value internally.
\see
<a href="kb">0610201627|aes</a>
*/
methodWinZipAes = 99
};
/**
The base class for compressors options.
\see
<a href="kb">0610231446|options</a>
\see
CZipArchive::SetCompressionOptions
*/
struct ZIP_API COptions
{
/**
Helper constants.
*/
enum Constants
{
/**
The default size of the buffer used in compression and decompression operations.
*/
cDefaultBufferSize = 2 * 65536
};
COptions()
{
m_iBufferSize = cDefaultBufferSize;
}
/**
Gets the type of the compressor to which the current options apply.
\return
The type of the compressor. It can be one of the #CompressorType values.
*/
virtual int GetType() const = 0;
/**
Clones the current options object.
\return
The cloned object of the same type as the current object.
*/
virtual COptions* Clone() const = 0;
/**
The size of the buffer used in compression and decompression operations.
By default it is set to to #cDefaultBufferSize. For the optimal performance of the
deflate algorithm it should be set at least to 128kB.
\see
CZipArchive::SetAdvanced
*/
int m_iBufferSize;
virtual ~COptions()
{
}
};
/**
A dictionary used for keeping options for different types of compressors.
\see
CZipArchive::SetCompressionOptions
*/
class ZIP_API COptionsMap : public CZipMap<int, COptions*>
{
public:
void Set(const COptions* pOptions);
void Remove(int iType);
COptions* Get(int iType) const;
~COptionsMap();
};
/**
Returns the value indicating whether the given compression method is supported by the ZipArchive Library.
\param uCompressionMethod
The compression method. Can be one of the #CompressionMethod values.
\return
\c true, if the compression method is supported, \c false otherwise.
*/
static bool IsCompressionSupported(WORD uCompressionMethod)
{
return uCompressionMethod == methodStore || uCompressionMethod == methodDeflate
;
}
ZIP_SIZE_TYPE m_uUncomprLeft; ///< The number of bytes left to decompress.
ZIP_SIZE_TYPE m_uComprLeft; ///< The number of bytes left to compress.
DWORD m_uCrc32; ///< The CRC32 file checksum.
/**
Returns the value indicating, if the current #CZipCompressor object supports the given compression method.
\param uMethod
The compression method. Can be one of the #CompressionMethod values.
\return
\c true, if the compression method is supported; \c false otherwise.
*/
virtual bool CanProcess(WORD uMethod) = 0;
/**
The method called when a new file is opened for compression.
\param iLevel
The compression level.
\param pFile
The file being compressed.
\param pCryptograph
The current CZipCryptograph. Can be \c NULL, if no encryption is used.
\see
Compress
\see
FinishCompression
*/
virtual void InitCompression(int iLevel, CZipFileHeader* pFile, CZipCryptograph* pCryptograph)
{
InitBuffer();
m_uComprLeft = 0;
m_pFile = pFile;
m_pCryptograph = pCryptograph;
}
/**
The method called when a new file is opened for extraction.
\param pFile
The file being extracted.
\param pCryptograph
The current CZipCryptograph. Can be \c NULL, if no decryption is used.
\see
Decompress
\see
FinishDecompression
*/
virtual void InitDecompression(CZipFileHeader* pFile, CZipCryptograph* pCryptograph)
{
InitBuffer();
m_pFile = pFile;
m_pCryptograph = pCryptograph;
m_uComprLeft = m_pFile->GetDataSize(false, true);
m_uUncomprLeft = m_pFile->m_uUncomprSize;
m_uCrc32 = 0;
}
/**
Compresses the given data.
\param pBuffer
The buffer that holds the data to compress.
\param uSize
The size of \a pBuffer.
\see
InitCompression
\see
FinishCompression
*/
virtual void Compress(const void *pBuffer, DWORD uSize) = 0;
/**
Decompresses the given data.
\param pBuffer
The buffer that receives the decompressed data.
\param uSize
The size of \a pBuffer.
\return
The number of bytes decompressed and written to \a pBuffer.
\note
This method should be called repeatedly until it returns 0.
\see
InitDecompression
\see
FinishDecompression
*/
virtual DWORD Decompress(void *pBuffer, DWORD uSize) = 0;
/**
The method called at the end of the compression process.
\param bAfterException
Set to \c true, if an exception occurred before or to \c false otherwise.
\see
InitCompression
\see
Compress
*/
virtual void FinishCompression(bool bAfterException){}
/**
The method called at the end of the decompression process.
\param bAfterException
Set to \c true, if an exception occurred before or to \c false otherwise.
\see
InitDecompression
\see
Decompress
*/
virtual void FinishDecompression(bool bAfterException){}
/**
Returns the current options of the compressor.
\return
The current options for the compressor.
\see
<a href="kb">0610231446|options</a>
\see
CZipArchive::SetCompressionOptions
\see
UpdateOptions
*/
virtual const COptions* GetOptions() const
{
return NULL;
}
/**
Updates the current options with the options stored in \a optionsMap,
if the appropriate options are present in the map.
\param optionsMap
The map to get the new options from.
\see
<a href="kb">0610231446|options</a>
\see
GetOptions
*/
void UpdateOptions(const COptionsMap& optionsMap);
virtual ~CZipCompressor()
{
}
/**
A factory method that creates an appropriate compressor for the given compression method.
\param uMethod
The compression method to create a compressor for. Can be one of #CompressionMethod values.
\param pStorage
The current storage object.
*/
static CZipCompressor* CreateCompressor(WORD uMethod, CZipStorage* pStorage);
protected:
/**
Updates the current options with the new options.
\param pOptions
The new options to apply.
*/
virtual void UpdateOptions(const COptions* pOptions)
{
}
/**
Updates CRC value while compression.
\param pBuffer
A buffer with data for which the CRC value should be updated.
\param uSize
The size of the buffer.
*/
void UpdateFileCrc(const void *pBuffer, DWORD uSize);
/**
Updates CRC value while decompression.
\param pBuffer
A buffer with data for which the CRC value should be updated.
\param uSize
The size of the buffer.
*/
void UpdateCrc(const void *pBuffer, DWORD uSize);
/**
Flushes data in the buffer into the storage, encrypting the data if needed.
\note
Throws exceptions.
*/
void FlushWriteBuffer()
{
if (m_pCryptograph)
m_pCryptograph->Encode(m_pBuffer, (DWORD)m_uComprLeft);
m_pStorage->Write(m_pBuffer, (DWORD)m_uComprLeft, false);
m_uComprLeft = 0;
}
/**
Initializes the internal buffer.
\see
ReleaseBuffer
*/
void InitBuffer();
/**
Releases the internal buffer.
\see
InitBuffer
*/
void ReleaseBuffer()
{
m_pBuffer.Release();
}
/**
Converts internal error code of the compressor to the ZipArchive Library error code.
\param iErr
An internal error code.
\return
A ZipArchive Library error code.
*/
virtual int ConvertInternalError(int iErr) const
{
return iErr;
}
/**
Throws an exception with a given error code.
\param iErr
An error code.
\param bInternal
\c true, if \a iErr is an internal error code and needs a conversion to the ZipArchive Library error code; \c false otherwise.
\note
Throws exceptions.
\see
ConvertInternalError
*/
void ThrowError(int iErr, bool bInternal = false)
{
if (bInternal)
iErr = ConvertInternalError(iErr);
CZipException::Throw(iErr, m_pStorage->IsClosed(true) ? _T("") : (LPCTSTR)m_pStorage->m_pFile->GetFilePath());
}
};
#if _MSC_VER > 1000
#pragma warning( pop )
#endif
#endif

81
harbour/contrib/hbziparch/ZipCrc32Cryptograph.cpp
View File

@@ -1,81 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipCrc32Cryptograph.h"
bool CZipCrc32Cryptograph::InitDecode(CZipAutoBuffer& password, CZipFileHeader& currentFile, CZipStorage& storage)
{
CryptInitKeys(password);
CZipAutoBuffer buf(ZIPARCHIVE_ENCR_HEADER_LEN);
storage.Read(buf, ZIPARCHIVE_ENCR_HEADER_LEN, false);
BYTE b = 0;
for (int i = 0; i < ZIPARCHIVE_ENCR_HEADER_LEN; i++)
{
b = buf[i]; // only temporary
CryptDecode((char&)b);
}
// check the last byte
return currentFile.IsDataDescriptor() ?
(BYTE(currentFile.m_uModTime >> 8) == b) : (BYTE(currentFile.m_uCrc32 >> 24) == b);
}
void CZipCrc32Cryptograph::InitEncode(CZipAutoBuffer& password, CZipFileHeader& currentFile, CZipStorage& storage)
{
CZipAutoBuffer buf(ZIPARCHIVE_ENCR_HEADER_LEN);
// use pseudo-crc since we don't know it yet
CryptInitKeys(password);
srand(UINT(time(NULL)));
// genereate pseudo-random sequence
char c;
char* buffer = (char*)buf;
for (int i = 0; i < ZIPARCHIVE_ENCR_HEADER_LEN - 2; i++)
{
int t1 = rand();
c = (char)((t1 >> 6) & 0xFF);
if (!c)
c = (char)(t1 & 0xFF);
CryptEncode(c);
buffer[i] = c;
}
long iCrc = (long)currentFile.m_uModTime << 16;
c = (char)((iCrc >> 16) & 0xFF);
CryptEncode(c);
buffer[ZIPARCHIVE_ENCR_HEADER_LEN - 2] = c;
c = (char)((iCrc >> 24) & 0xFF);
CryptEncode(c);
buffer[ZIPARCHIVE_ENCR_HEADER_LEN - 1] = c;
storage.Write(buf, ZIPARCHIVE_ENCR_HEADER_LEN, false);
currentFile.m_uComprSize += ZIPARCHIVE_ENCR_HEADER_LEN;
}
void CZipCrc32Cryptograph::CryptInitKeys(CZipAutoBuffer& password)
{
m_keys[0] = 305419896L;
m_keys[1] = 591751049L;
m_keys[2] = 878082192L;
for (DWORD i = 0; i < password.GetSize(); i++)
CryptUpdateKeys(password[i]);
}
void CZipCrc32Cryptograph::CryptUpdateKeys(char c)
{
m_keys[0] = CryptCRC32(m_keys[0], c);
m_keys[1] += m_keys[0] & 0xff;
m_keys[1] = m_keys[1] * 134775813L + 1;
c = char(m_keys[1] >> 24);
m_keys[2] = CryptCRC32(m_keys[2], c);
}

120
harbour/contrib/hbziparch/ZipCrc32Cryptograph.h
View File

@@ -1,120 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCrc32Cryptograph.h
* Includes the CZipCrc32Cryptograph class.
*
*/
#if !defined(ZIPARCHIVE_ZIPCRC32CRYPTOGRAPH_DOT_H)
#define ZIPARCHIVE_ZIPCRC32CRYPTOGRAPH_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "zlib/zlib.h"
#include "ZipCryptograph.h"
#include "ZipFileHeader.h"
#include "ZipStorage.h"
#define ZIPARCHIVE_ENCR_HEADER_LEN 12
/**
Performs the traditional zip encryption.
\see
<a href="kb">0610201627|std</a>
*/
class ZIP_API CZipCrc32Cryptograph : public CZipCryptograph
{
public:
CZipCrc32Cryptograph(){}
bool InitDecode(CZipAutoBuffer& password, CZipFileHeader& currentFile, CZipStorage& storage);
void InitEncode(CZipAutoBuffer& password, CZipFileHeader& currentFile, CZipStorage& storage);
void Decode(char* pBuffer, DWORD uSize)
{
for (DWORD i = 0; i < uSize; i++)
CryptDecode(pBuffer[i]);
}
void Encode(char* pBuffer, DWORD uSize)
{
for (DWORD i = 0; i < uSize; i++)
CryptEncode(pBuffer[i]);
}
bool CanHandle(int iEncryptionMethod)
{
return iEncryptionMethod == CZipCryptograph::encStandard;
}
/**
See CZipCryptograph::GetEncryptedInfoSizeBeforeData
*/
static DWORD GetEncryptedInfoSizeBeforeData()
{
return ZIPARCHIVE_ENCR_HEADER_LEN;
}
/**
See CZipCryptograph::GetEncryptedInfoSizeAfterData
*/
static DWORD GetEncryptedInfoSizeAfterData()
{
return 0;
}
/**
Returns the CRC table.
*/
static const DWORD* GetCRCTable()
{
return zarch_get_crc_table();
}
private:
void CryptDecode(char &c)
{
c ^= CryptDecryptByte();
CryptUpdateKeys(c);
}
char CryptDecryptByte()
{
int temp = (m_keys[2] & 0xffff) | 2;
return (char)(((temp * (temp ^ 1)) >> 8) & 0xff);
}
void CryptInitKeys(CZipAutoBuffer& password);
void CryptUpdateKeys(char c);
DWORD CryptCRC32(DWORD l, char c)
{
const DWORD *CRC_TABLE = zarch_get_crc_table();
return CRC_TABLE[(l ^ c) & 0xff] ^ (l >> 8);
}
void CryptEncode(char &c)
{
char t = CryptDecryptByte();
CryptUpdateKeys(c);
c ^= t;
}
DWORD m_keys[3];
public:
~CZipCrc32Cryptograph(){}
};
#endif

57
harbour/contrib/hbziparch/ZipCryptograph.cpp
View File

@@ -1,57 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipCryptograph.h"
#include "ZipAesCryptograph.h"
#include "ZipCrc32Cryptograph.h"
CZipCryptograph* CZipCryptograph::CreateCryptograph(int iEncryptionMethod)
{
if (iEncryptionMethod == encNone)
return NULL;
return new CZipCrc32Cryptograph();
}
DWORD CZipCryptograph::GetEncryptedInfoSize(int iEncryptionMethod)
{
if (iEncryptionMethod != encNone)
{
if (iEncryptionMethod == encStandard)
return CZipCrc32Cryptograph::GetEncryptedInfoSizeBeforeData() + CZipCrc32Cryptograph::GetEncryptedInfoSizeAfterData();
}
return 0;
}
DWORD CZipCryptograph::GetEncryptedInfoSizeBeforeData(int iEncryptionMethod)
{
if (iEncryptionMethod != encNone)
{
if (iEncryptionMethod == encStandard)
return CZipCrc32Cryptograph::GetEncryptedInfoSizeBeforeData();
}
return 0;
}
DWORD CZipCryptograph::GetEncryptedInfoSizeAfterData(int iEncryptionMethod)
{
if (iEncryptionMethod != encNone)
{
if (iEncryptionMethod == encStandard)
return CZipCrc32Cryptograph::GetEncryptedInfoSizeAfterData();
}
return 0;
}

231
harbour/contrib/hbziparch/ZipCryptograph.h
View File

@@ -1,231 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipCryptograph.h
* Includes the CZipCryptograph class.
*
*/
#if !defined(ZIPARCHIVE_ZIPCRYPTOGRAPH_DOT_H)
#define ZIPARCHIVE_ZIPCRYPTOGRAPH_DOT_H
#if _MSC_VER > 1000
#pragma once
#pragma warning( push )
#pragma warning (disable : 4100) // unreferenced formal parameter
#endif // _MSC_VER > 1000
#include "ZipAutoBuffer.h"
#include "ZipStorage.h"
class CZipFileHeader;
/**
The base class for cryptographs used in encryption and decryption of file data.
\see
<a href="kb">0610201627</a>
*/
class ZIP_API CZipCryptograph
{
public:
/**
The encryption method.
\see
<a href="kb">0610201627</a>
*/
enum EncryptionMethod
{
encStandard, ///< The traditional zip encryption.
encWinZipAes128, ///< WinZip AES 128-bit encryption.
encWinZipAes192, ///< WinZip AES 192-bit encryption.
encWinZipAes256, ///< WinZip AES 256-bit encryption.
encNone = 0xFF ///< Indicates no encryption.
};
/**
A factory method that creates an appropriate cryptograph for the given method.
\param iEncryptionMethod
The encryption method to create a cryptograph for. Can be one of #EncryptionMethod values.
\return
The new cryptograph. The caller is responsible for destroying the object.
If the method is not supported, creates CZipCrc32Cryptograph.
*/
static CZipCryptograph* CreateCryptograph(int iEncryptionMethod);
/**
Determines if the given method is one of the WinZip AES encryption method.
\param iEncryptionMethod
The encryption method to test. Can be one of #EncryptionMethod values.
\return
\c true, if the method is one the WinZip AES encryption methods; \c false otherwise.
*/
static bool IsWinZipAesEncryption(int iEncryptionMethod)
{
return iEncryptionMethod == encWinZipAes128 || iEncryptionMethod == encWinZipAes192 || iEncryptionMethod == encWinZipAes256;
}
/**
Returns the total size of the extra data that is added to the compression stream during encryption with the given method.
\param iEncryptionMethod
The encryption method. Can be one of #EncryptionMethod values.
\return
The total size of extra data for the given encryption method.
*/
static DWORD GetEncryptedInfoSize(int iEncryptionMethod);
/**
Returns the size of the extra data that is added before the compression stream during encryption with the given method.
\param iEncryptionMethod
The encryption method. Can be one of #EncryptionMethod values.
\return
The size of extra data at the beginning of the compression stream for the given encryption method.
*/
static DWORD GetEncryptedInfoSizeBeforeData(int iEncryptionMethod);
/**
Returns the size of the extra data that is added after the compression stream during encryption with the given method.
\param iEncryptionMethod
The encryption method. Can be one of #EncryptionMethod values.
\return
The size of extra data at the end of the compression stream for the given encryption method.
*/
static DWORD GetEncryptedInfoSizeAfterData(int iEncryptionMethod);
/**
Determines if the given encryption method is supported by the current compilation of the ZipArchive Library.
\param iEncryptionMethod
The encryption method to test. Can be one of #EncryptionMethod values.
\return
\c true, if the method is supported; \c false otherwise.
*/
static bool IsEncryptionSupported(int iEncryptionMethod)
{
return iEncryptionMethod == encStandard;
}
/**
The method called when an existing file is opened for extraction.
\param password
The supplied password with the CZipArchive::SetPassword method.
\param currentFile
The file being decoded and extracted.
\param storage
The current CZipStorage.
\return
\c true, if the password is initially considered correct; \c false otherwise.
*/
virtual bool InitDecode(CZipAutoBuffer& password, CZipFileHeader& currentFile, CZipStorage& storage) = 0;
/**
The method called when a new file is opened for compression.
\param password
The supplied password with the CZipArchive::SetPassword method.
\param currentFile
The file being compressed and encoded.
\param storage
The current CZipStorage.
*/
virtual void InitEncode(CZipAutoBuffer& password, CZipFileHeader& currentFile, CZipStorage& storage) = 0;
/**
Decodes the given data.
\param pBuffer
The buffer that holds the data to decode and that receives the results.
\param uSize
The size of \a pBuffer.
*/
virtual void Decode(char* pBuffer, DWORD uSize) = 0;
/**
Encodes the given data.
\param pBuffer
The buffer that holds the data to encode and that receives the results.
\param uSize
The size of \a pBuffer.
*/
virtual void Encode(char* pBuffer, DWORD uSize) = 0;
/**
The method called at the end of the decoding process.
\param currentFile
The file being decoded and extracted.
\param storage
The current CZipStorage.
*/
virtual void FinishDecode(CZipFileHeader& currentFile, CZipStorage& storage){};
/**
The method called at the end of the decoding process.
\param currentFile
The file being compressed and encoded.
\param storage
The current CZipStorage.
*/
virtual void FinishEncode(CZipFileHeader& currentFile, CZipStorage& storage){};
/**
Returns the value indicating whether the current compressor can handle the given encryption method.
\param iEncryptionMethod
The encryption method to test. Can be one of #EncryptionMethod values.
\return
\c true, if the current compressor can handle the given encryption method; \c false otherwise.
*/
virtual bool CanHandle(int iEncryptionMethod)
{
return false;
}
virtual ~CZipCryptograph(){}
};
#if _MSC_VER > 1000
#pragma warning( pop )
#endif // _MSC_VER > 1000
#endif

279
harbour/contrib/hbziparch/ZipException.cpp
View File

@@ -1,279 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipException.h"
#include "zlib/zlib.h"
#include <errno.h>
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
#if defined _MFC_VER && defined ZIP_ARCHIVE_MFC
IMPLEMENT_DYNAMIC( CZipException, CException)
#endif
CZipException::CZipException(int iCause, LPCTSTR lpszZipName)
#ifdef _MFC_VER
:CException(TRUE)
#endif
{
m_iCause = iCause;
if (lpszZipName)
m_szFileName = lpszZipName;
}
CZipException::~CZipException() throw()
{
}
// inline void CZipException::Throw(int iZipError, LPCTSTR lpszZipName)
// {
// #ifdef _MFC_VER
// throw new CZipException(iZipError, lpszZipName);
// #else
// CZipException e(iZipError, lpszZipName);
// throw e;
// #endif
// MSVC++: ignore "Unreachable code" warning here, it's due to
// optimizations
// }
#ifdef ZIP_ENABLE_ERROR_DESCRIPTION
ZBOOL CZipException::GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
UINT* )
{
if (!lpszError || !nMaxError)
return FALSE;
CZipString sz = GetErrorDescription();
if (sz.IsEmpty())
return FALSE;
UINT iLen = sz.GetLength();
if (nMaxError - 1 < iLen)
iLen = nMaxError - 1;
LPTSTR lpsz = sz.GetBuffer(iLen);
#if _MSC_VER >= 1400
#ifdef _UNICODE
wcsncpy_s(lpszError, nMaxError, lpsz, iLen);
#else
strncpy_s(lpszError, nMaxError, lpsz, iLen);
#endif
#else
#ifdef _UNICODE
wcsncpy(lpszError, lpsz, iLen);
#else
strncpy(lpszError, lpsz, iLen);
#endif
#endif
lpszError[iLen] = _T('\0');
return TRUE;
}
CZipString CZipException::GetErrorDescription()
{
return GetInternalErrorDescription(m_iCause);
}
CZipString CZipException::GetSystemErrorDescription()
{
#ifdef WIN32
DWORD x = GetLastError();
if (x)
{
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, x, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf, 0, NULL);
CZipString sz = (LPCTSTR)lpMsgBuf;
LocalFree(lpMsgBuf);
return sz;
}
#endif
return GetInternalErrorDescription(errno == 0 ? genericError : errno, true);
}
CZipString CZipException::GetInternalErrorDescription(int iCause, bool bNoLoop)
{
CZipString sz;
switch (iCause)
{
case EROFS:
sz = _T("Read-only file system.");
break;
case ESPIPE:
sz = _T("Illegal seek.");
break;
case ENOSPC:
sz = _T("No space left on device.");
break;
case EFBIG:
sz = _T("File too large.");
break;
case EMFILE:
sz = _T("Too many open files.");
break;
case ENFILE:
sz = _T("File table overflow.");
break;
case EINVAL:
sz = _T("Invalid argument.");
break;
case EISDIR:
sz = _T("Is a directory.");
break;
case ENOTDIR:
sz = _T("Not a directory.");
break;
case ENODEV:
sz = _T("No such device.");
break;
case EXDEV:
sz = _T("Cross-device link.");
break;
case EEXIST:
sz = _T("File exists.");
break;
case EFAULT:
sz = _T("Bad address.");
break;
case EACCES:
sz = _T("Permission denied.");
break;
case ENOMEM:
sz = _T("Not enough space.");
break;
case EBADF:
sz = _T("Bad file number.");
break;
case ENXIO:
sz = _T("No such device or address.");
break;
case EIO:
sz = _T("I/O error.");
break;
case EINTR:
sz = _T("Interrupted system call.");
break;
case ENOENT:
sz = _T("No such file or directory.");
break;
case EPERM:
sz = _T("Not super-user.");
break;
case badZipFile:
sz = _T("Damaged or not a zip file.");
break;
case badCrc:
sz = _T("Crc is mismatched.");
break;
case noCallback:
sz = _T("There is no spanned archive callback object set.");
break;
case aborted:
sz = _T("Volume change aborted in a segmented archive.");
break;
case abortedAction:
sz = _T("Action aborted.");
break;
case abortedSafely:
sz = _T("Action aborted safely.");
break;
case nonRemovable:
sz = _T("The device selected for the spanned archive is not removable.");
break;
case tooManyVolumes:
sz = _T("The limit of the maximum volumes reached.");
break;
case tooManyFiles:
sz = _T("The limit of the maximum files in an archive reached.");
break;
case tooLongData:
sz = _T("The filename, the comment or the local or central extra field of the file added to the archive is too long.");
break;
case tooBigSize:
sz = _T("The file size is too large to be supported.");
break;
case badPassword:
sz = _T("An incorrect password set for the file being decrypted.");
break;
case dirWithSize:
sz = _T("The directory with a non-zero size found while testing.");
break;
case internalError:
sz = _T("An internal error.");
break;
case notRemoved:
sz.Format(_T("%s (%s)."), _T("Error while removing a file"), (LPCTSTR)GetSystemErrorDescription());
break;
case notRenamed:
sz.Format(_T("%s (%s)."), _T("Error while renaming a file"), (LPCTSTR)GetSystemErrorDescription());
break;
case platfNotSupp:
sz = _T("Cannot create a file for the specified platform.");
break;
case cdirNotFound:
sz = _T("The central directory was not found in the archive (or you were trying to open not the last volume of a segmented archive).");
break;
case noZip64:
sz = _T("The Zip64 format has not been enabled for the library, but is required to use the archive.");
break;
case noAES:
sz = _T("WinZip AES encryption has not been enabled for the library, but is required to decompress the archive.");
break;
#ifdef ZIP_ARCHIVE_STL
case outOfBounds:
sz = _T("The collection is empty and the bounds do not exist.");
break;
#endif
#ifdef ZIP_ARCHIVE_USE_LOCKING
case mutexError:
sz = _T("Locking or unlocking resources access was unsuccessful.");
break;
#endif
case streamEnd:
sz = _T("Zlib library error (end of stream).");
break;
case errNo:
sz = GetInternalErrorDescription(errno != errNo ? errno : genericError);
break;
case streamError:
sz = _T("Zlib library error (stream error).");
break;
case dataError:
sz = _T("Zlib library error (data error).");
break;
case memError:
sz = _T("Not enough memory.");
break;
case bufError:
sz = _T("Zlib library error (buffer error).");
break;
case versionError:
sz = _T("Zlib library error (version error).");
break;
default:
sz = bNoLoop ? _T("Unknown error") :(LPCTSTR) GetSystemErrorDescription();
}
return sz;
}
#endif //ZIP_ENABLE_ERROR_DESCRIPTION

223
harbour/contrib/hbziparch/ZipException.h
View File

@@ -1,223 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipException.h
* Includes the CZipException class.
*
*/
#if !defined(ZIPARCHIVE_ZIPEXCEPTION_DOT_H)
#define ZIPARCHIVE_ZIPEXCEPTION_DOT_H
#if _MSC_VER > 1000
#pragma once
#pragma warning( push )
#pragma warning (disable:4702) // disable "Unreachable code" warning in Throw function in the Release mode
#if defined ZIP_HAS_DLL
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
#pragma warning( disable : 4275 ) // non dll-interface used as base for dll-interface class
#endif
#endif
#include "ZipString.h"
#include "ZipBaseException.h"
#include "ZipExport.h"
/**
Represents exceptions specific to the ZipArchive Library.
\see
<a href="kb">0610222049</a>
*/
class ZIP_API CZipException : public CZipBaseException
{
public:
/**
Throws an exception.
Whether it throws an object or a pointer to it, depends
on the current version (STL or MFC correspondingly).
\param iCause
The error cause. Takes one of the #ZipErrors values.
\param lpszZipName
The name of the file where the error occurred (if applicable).
May be \c NULL.
\see
<a href="kb">0610222049</a>
*/
static void Throw(int iCause = CZipException::genericError, LPCTSTR lpszZipName = NULL)
{
#ifdef ZIP_ARCHIVE_MFC
throw new CZipException(iCause, lpszZipName);
#else
CZipException e(iCause, lpszZipName);
throw e;
#endif
}
/**
Initializes a new instance of the CZipException class.
\param iCause
The error cause. Takes one of the #ZipErrors values.
\param lpszZipName
The name of the file where the error occurred (if applicable).
May be \c NULL.
*/
CZipException(int iCause = genericError, LPCTSTR lpszZipName = NULL);
CZipException(CZipException& e)
{
m_szFileName = e.m_szFileName;
m_iCause = e.m_iCause;
}
#ifdef ZIP_ENABLE_ERROR_DESCRIPTION
/**
Gets the error description.
\return
The error description.
*/
CZipString GetErrorDescription();
/**
Gets the error description. This method is provided for compatibility with the MFC version (\c CException::GetErrorMessage).
\param lpszError
The buffer to receive the error message.
\param nMaxError
The maximum number of characters \a lpszError can hold,
including the ending \c NULL character.
\return
\c TRUE if the error string was successfully copied to \a lpszError; \c FALSE otherwise.
\note
The method will not copy more than \c nMaxError - 1 characters
to the buffer, and it always appends a \c NULL character.
If \a lpszError is too small, the error message will be truncated.
*/
ZBOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, UINT* = NULL);
#endif //ZIP_ENABLE_ERROR_DESCRIPTION
/**
The name of the zip file where the error occurred.
*/
CZipString m_szFileName;
/**
The codes of errors thrown by the ZipArchive Library.
*/
enum ZipErrors
{
noError, ///< No error.
// 1 - 42 reserved for errno (from STL) values - used only in non-MFC versions
// 43 - 99 reserved
genericError = 100, ///< An unknown error.
badZipFile, ///< Damaged or not a zip file.
badCrc, ///< Crc is mismatched.
noCallback, ///< There is no spanned archive callback object set.
aborted, ///< The volume change callback in a segmented archive method returned \c false.
abortedAction, ///< The action callback method returned \c false.
abortedSafely, ///< The action callback method returned \c false, but the data is not corrupted.
nonRemovable, ///< The device selected for the spanned archive is not removable.
tooManyVolumes, ///< The limit of the maximum volumes reached.
tooManyFiles, ///< The limit of the maximum files in an archive reached.
tooLongData, ///< The filename, the comment or the local or central extra field of the file added to the archive is too long.
tooBigSize, ///< The file size is too large to be supported.
badPassword, ///< An incorrect password set for the file being decrypted.
dirWithSize, ///< The directory with a non-zero size found while testing.
internalError, ///< An internal error.
notRemoved, ///< Error while removing a file (under Windows call \c GetLastError() to find out more).
notRenamed, ///< Error while renaming a file (under Windows call \c GetLastError() to find out more).
platfNotSupp, ///< Cannot create a file for the specified platform.
cdirNotFound, ///< The central directory was not found in the archive (or you were trying to open not the last disk of a segmented archive).
noZip64, ///< The Zip64 format has not been enabled for the library, but is required to use the archive.
noAES, ///< WinZip AES encryption has not been enabled for the library, but is required to decompress the archive.
#ifdef ZIP_ARCHIVE_STL
outOfBounds, ///< The collection is empty and the bounds do not exist.
#endif
#ifdef ZIP_ARCHIVE_USE_LOCKING
mutexError, ///< Locking or unlocking resources access was unsuccessful.
#endif
streamEnd = 500, ///< Zlib library error.
needDict, ///< Zlib library error.
errNo, ///< Zlib library error.
streamError, ///< Zlib library error.
dataError, ///< Zlib library error.
memError, ///< Zlib library or \c CZipMemFile error.
bufError, ///< Zlib library error.
versionError, ///< Zlib library error.
};
/**
The error code - takes one of the CZipException::ZipErrors values.
*/
int m_iCause;
virtual ~CZipException() throw();
protected:
#ifdef ZIP_ENABLE_ERROR_DESCRIPTION
/**
Gets the error description.
\param iCause
The error cause. Takes one of the #ZipErrors values.
\param bNoLoop
If \c true, does not search for en error description, it the error code is #genericError.
\return
The error description.
*/
CZipString GetInternalErrorDescription(int iCause, bool bNoLoop = false);
/**
Gets the error description based on system variables.
\return
The error description.
*/
CZipString GetSystemErrorDescription();
#endif //ZIP_ENABLE_ERROR_DESCRIPTION
#if defined _MFC_VER && defined ZIP_ARCHIVE_MFC
DECLARE_DYNAMIC(CZipException)
#endif
};
#if _MSC_VER > 1000
#pragma warning( pop )
#endif
#endif // !defined(ZIPARCHIVE_ZIPEXCEPTION_DOT_H)

35
harbour/contrib/hbziparch/ZipExport.h
View File

@@ -1,35 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipExport.h
* Contains the Windows DLL exports definitions.
*
*/
#if !defined (ZIPARCHIVE_ZIPEXPORT_DOT_H)
#define ZIPARCHIVE_ZIPEXPORT_DOT_H
#if defined (ZIP_HAS_DLL)
# if defined (ZIP_BUILD_DLL)
# define ZIP_API __declspec (dllexport)
# else
# define ZIP_API __declspec (dllimport)
# endif
#else
# define ZIP_API
#endif /* ZIP_HAS_DLL */
#endif /* ZIPARCHIVE_ZIPEXPORT_DOT_H */

43
harbour/contrib/hbziparch/ZipExtraData.cpp
View File

@@ -1,43 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipArchive.h"
#include "ZipExtraData.h"
#include "BytesWriter.h"
using namespace ZipArchiveLib;
bool CZipExtraData::Read(char* buffer, WORD uSize)
{
if (uSize < 4)
return false;
WORD size;
CBytesWriter::ReadBytes(m_uHeaderID, buffer);
CBytesWriter::ReadBytes(size, buffer + 2);
if (uSize - 4 < size)
return false;
m_data.Allocate(size);
memcpy(m_data, buffer + 4, size);
return true;
}
WORD CZipExtraData::Write(char* buffer)const
{
CBytesWriter::WriteBytes(buffer, m_uHeaderID);
WORD size = (WORD)m_data.GetSize();
CBytesWriter::WriteBytes(buffer + 2, size);
memcpy(buffer + 4, m_data, size);
return (WORD)(size + 4);
}

158
harbour/contrib/hbziparch/ZipExtraData.h
View File

@@ -1,158 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipExtraData.h
* Includes the CZipExtraData class.
*
*/
#if !defined(ZIPARCHIVE_ZIPEXTRADATA_DOT_H)
#define ZIPARCHIVE_ZIPEXTRADATA_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipExport.h"
#include "ZipAutoBuffer.h"
#include "ZipExtraField.h"
#include "memory.h"
/**
Represents a single data record in an extra field.
\see
<a href="kb">0610242300</a>
*/
class ZIP_API CZipExtraData
{
friend class CZipExtraField;
public:
/**
The custom data contained by this record.
*/
CZipAutoBuffer m_data;
CZipExtraData()
{
m_uHeaderID = 0;
}
CZipExtraData(const CZipExtraData& extra)
{
*this = extra;
}
/**
Initializes a new instance of the CZipExtraData class.
\param uHeaderID
The unique ID of the data.
*/
CZipExtraData(WORD uHeaderID)
{
m_uHeaderID = uHeaderID;
}
CZipExtraData& operator=(const CZipExtraData& extra)
{
m_uHeaderID = extra.m_uHeaderID;
DWORD uSize = extra.m_data.GetSize();
m_data.Allocate(uSize);
if (uSize > 0)
memcpy(m_data, extra.m_data, uSize);
return *this;
}
bool operator==(const CZipExtraData& extra)
{
return m_uHeaderID == extra.m_uHeaderID && m_data.GetSize() == extra.m_data.GetSize() && memcmp(m_data, extra.m_data, m_data.GetSize()) == 0;
}
bool operator != (const CZipExtraData& extra)
{
return !(*this == extra);
}
bool operator > (const CZipExtraData& extra)
{
return m_uHeaderID > extra.m_uHeaderID;
}
bool operator < (const CZipExtraData& extra)
{
return m_uHeaderID < extra.m_uHeaderID;
}
bool operator >= (const CZipExtraData& extra)
{
return m_uHeaderID > extra.m_uHeaderID || *this == extra;
}
bool operator <= (const CZipExtraData& extra)
{
return m_uHeaderID < extra.m_uHeaderID || *this == extra;
}
/**
Gets the total size, the extra data will occupy in the archive.
\return
The size in bytes.
*/
int GetTotalSize() const
{
return 4 + m_data.GetSize();
}
/**
Gets the data ID.
\return
The data ID.
*/
WORD GetHeaderID() const
{
return m_uHeaderID;
}
protected:
/**
Reads the extra data record from \a buffer.
\param buffer
The buffer to read the data from.
\param uSize
The size of the data to read.
\return
\c false, if \a uSize was smaller than the declared extra data size; \c true otherwise.
*/
bool Read(char* buffer, WORD uSize);
/**
Writes the extra data record to \a buffer.
\param buffer
The buffer to write to.
\return
The total size of extra data in bytes.
*/
WORD Write(char* buffer)const;
private:
WORD m_uHeaderID;
};
#endif // !defined(ZIPARCHIVE_ZIPEXTRADATA_DOT_H)

88
harbour/contrib/hbziparch/ZipExtraField.cpp
View File

@@ -1,88 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipExtraField.h"
bool CZipExtraField::Read(CZipStorage *pStorage, WORD uSize)
{
if (uSize == 0)
return true;
Clear();
CZipAutoBuffer buffer;
buffer.Allocate(uSize);
pStorage->Read(buffer, uSize, true);
char* position = (char*) buffer;
do
{
CZipExtraData* pExtra = new CZipExtraData();
if (!pExtra->Read(position, uSize))
{
delete pExtra;
return false;
}
int totalSize = pExtra->GetTotalSize();
if (totalSize > uSize || totalSize < 0)
return false;
position += totalSize;
uSize = (WORD)(uSize - totalSize);
Add(pExtra);
}
while (uSize > 0);
return true;
}
void CZipExtraField::Write(char* buffer)const
{
int offset = 0;
for (int i = 0; i < GetCount(); i++)
offset += GetAt(i)->Write(buffer + offset);
}
int CZipExtraField::GetTotalSize()const
{
int total = 0;
for (int i = 0; i < GetCount(); i++)
total += GetAt(i)->GetTotalSize();
return total;
}
void CZipExtraField::RemoveInternalHeaders()
{
for (int i = GetCount() - 1; i >= 0; i--)
{
WORD headerID = GetAt(i)->GetHeaderID();
if (
headerID == ZIP_EXTRA_ZARCH_NAME)
RemoveAt(i);
}
}
CZipExtraData* CZipExtraField::Lookup(WORD headerID, int& index) const
{
// we can do a non-efficient search here
// usually the number of extra fields is low, if any
for (int i = 0; i < GetCount(); i++)
{
CZipExtraData* pExtra = GetAt(i);
if (pExtra->m_uHeaderID == headerID)
{
index = i;
return pExtra;
}
}
return NULL;
}

273
harbour/contrib/hbziparch/ZipExtraField.h
View File

@@ -1,273 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipExtraField.h
* Includes the CZipExtraField class.
*
*/
#if !defined(ZIPARCHIVE_ZIPEXTRAFIELD_DOT_H)
#define ZIPARCHIVE_ZIPEXTRAFIELD_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipExport.h"
#include "ZipExtraData.h"
#include "ZipCollections.h"
#include "ZipStorage.h"
#define ZIP_EXTRA_ZARCH_NAME 0x5A4C // ZL - ZipArchive Library
#define ZIP_EXTRA_ZARCH_SEEK 0x5A4D
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
#endif
/**
Represents a local or central extra field in a zip archive.
This is a collection of extra data records (CZipExtraData).
\see
<a href="kb">0610242300</a>
\see
CZipExtraData
*/
class ZIP_API CZipExtraField
{
friend class CZipFileHeader;
public:
CZipExtraField(){}
CZipExtraField(const CZipExtraField& arr)
{
*this = arr;
}
CZipExtraField& operator=(const CZipExtraField& field)
{
Clear();
for (int i = 0; i < field.GetCount(); i++)
Add(new CZipExtraData(*field.GetAt(i)));
return *this;
}
/**
Gets the total size, the extra data will occupy in the archive.
\return
The size in bytes.
*/
int GetTotalSize() const;
/**
Validates the current size of the extra field.
\return
\c false, if the size is larger than allowed; \c false otherwise.
*/
bool Validate() const
{
return GetTotalSize() <= USHRT_MAX;
}
/**
Gets the number of extra data records included in the extra field.
\return
The number of extra fields included.
*/
int GetCount() const
{
return (int)m_aData.GetSize();
}
/**
Gets the extra data record at the given index.
\param index
The index of extra data record to retrieve.
\return
The extra data record.
*/
CZipExtraData* GetAt(int index) const
{
return m_aData.GetAt(index);
}
/**
Removes the extra data record at the given index.
\param index
The index of the extra data record to remove.
*/
void RemoveAt(int index)
{
delete (GetAt(index));
m_aData.RemoveAt(index);
}
/**
Adds a new extra data record to the extra field.
\param pExtra
The extra data record to add.
\return
The index of \a pExtra in the internal collection.
*/
int Add(CZipExtraData* pExtra)
{
return (int)m_aData.Add(pExtra);
}
/**
Creates a new extra data record with the given ID
and adds it to the extra field.
\param headerID
The extra data ID.
\return
The created extra data record.
\see
CZipExtraData::GetHeaderID
*/
CZipExtraData* CreateNew(WORD headerID)
{
int temp;
return CreateNew(headerID, temp);
}
/**
Creates a new extra data record with the given ID
and adds it to the extra field.
\param headerID
The extra data ID.
\param idx
Receives the value of the index of the new
extra data in the internal collection.
\return
The created extra data record.
\see
CZipExtraData::GetHeaderID
*/
CZipExtraData* CreateNew(WORD headerID, int& idx)
{
CZipExtraData* pData = new CZipExtraData(headerID);
idx = (int)m_aData.Add(pData);
return pData;
}
/**
Removes all extra data records from the extra field,
that are internally used by the ZipArchive Library.
*/
void RemoveInternalHeaders();
/**
Lookups the extra field for the extra data record with the given ID.
\param headerID
The ID of the extra data to lookup.
\return
The found extra data record or \c NULL, if the extra data could not be found.
*/
CZipExtraData* Lookup(WORD headerID) const
{
int temp;
return Lookup(headerID, temp);
}
/**
Returns the value indicating whether the extra data record with the given ID is present in the extra field.
\param headerID
The ID of the extra data to check.
\return
\c true, if the extra data record with the given ID is present in the extra field; \c false otherwise.
*/
bool HasHeader(WORD headerID)
{
return Lookup(headerID) != NULL;
}
/**
Lookups the extra field for the extra data record with the given ID.
\param headerID
The ID of the extra data to lookup.
\param index
Receives the value of the index of the found
extra data in the internal collection.
\return
The found extra data record or \c NULL, if the extra data could not be found.
*/
CZipExtraData* Lookup(WORD headerID, int& index) const;
~CZipExtraField()
{
Clear();
}
protected:
/**
Removes all extra data records from the extra field.
*/
void Clear()
{
for (int i = 0; i < GetCount(); i++)
delete (GetAt(i));
m_aData.RemoveAll();
}
/**
Reads the extra field from \a buffer.
\param pStorage
The storage to read the data from.
\param uSize
The size of the data to read.
\return
\c false, if \a uSize was smaller than the declared extra field size; \c true otherwise.
*/
bool Read(CZipStorage* pStorage, WORD uSize);
/**
Writes the extra field to \a buffer.
\param buffer
The buffer to write to.
*/
void Write(char* buffer) const;
private:
CZipArray<CZipExtraData*> m_aData;
};
#endif // !defined(ZIPARCHIVE_ZIPEXTRAFIELD_DOT_H)

39
harbour/contrib/hbziparch/ZipFile.h
View File

@@ -1,39 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipFile.h
* Includes the CZipFile class.
*
*/
#if !defined(ZIPARCHIVE_ZIPFILE_DOT_H)
#define ZIPARCHIVE_ZIPFILE_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "_features.h"
#if defined ZIP_ARCHIVE_STL || defined ZIP_FILE_USES_STL
#include "ZipFile_stl.h"
#else
#include "ZipFile_mfc.h"
#endif
#endif // !defined(ZIPARCHIVE_ZIPFILE_DOT_H)

792
harbour/contrib/hbziparch/ZipFileHeader.cpp
View File

@@ -1,792 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipFileHeader.h"
#include "ZipAutoBuffer.h"
#include "ZipArchive.h"
#include "ZipPlatform.h"
#include "ZipCompatibility.h"
#include <time.h>
#include "ZipCrc32Cryptograph.h"
#include "BytesWriter.h"
#define FILEHEADERSIZE 46
#define LOCALFILEHEADERSIZE 30
#define ZIP_EXTRA_ZARCH_NAME_VER 1
using namespace ZipArchiveLib;
char CZipFileHeader::m_gszSignature[] = {0x50, 0x4b, 0x01, 0x02};
char CZipFileHeader::m_gszLocalSignature[] = {0x50, 0x4b, 0x03, 0x04};
CZipFileHeader::CZipFileHeader()
{
m_uExternalAttr = 0;//ZipPlatform::GetDefaultAttributes();
m_uModDate = m_uModTime = 0;
m_uMethod = CZipCompressor::methodDeflate;
m_uVersionMadeBy = 0;
m_uCrc32 = 0;
// initialize to 0, because on 64 bit platform unsigned long is 8 byte and we are copying only 4 bytes in Read()
m_uComprSize = m_uUncomprSize = m_uOffset = 0;
m_uLocalFileNameSize = 0;
m_uLocalComprSize = m_uLocalUncomprSize = 0;
m_uVolumeStart = 0;
m_pszFileName = NULL;
m_uEncryptionMethod = CZipCryptograph::encNone;
m_bIgnoreCrc32 = false;
m_uFlag = 0;
}
CZipFileHeader::~CZipFileHeader()
{
if (m_pszFileName != NULL)
delete m_pszFileName;
}
bool CZipFileHeader::Read(CZipCentralDir& centralDir, bool bReadSignature)
{
CZipStorage *pStorage = centralDir.m_pStorage;
WORD uFileNameSize, uCommentSize, uExtraFieldSize;
CZipAutoBuffer buf(FILEHEADERSIZE);
if (bReadSignature)
{
pStorage->Read(buf, FILEHEADERSIZE, true);
if (!VerifySignature(buf))
return false;
}
else
pStorage->Read((char*)buf + 4, FILEHEADERSIZE - 4, true);
CBytesWriter::ReadBytes(m_uVersionMadeBy, buf + 4);
CBytesWriter::ReadBytes(m_uVersionNeeded, buf + 6);
CBytesWriter::ReadBytes(m_uFlag, buf + 8);
CBytesWriter::ReadBytes(m_uMethod, buf + 10);
CBytesWriter::ReadBytes(m_uModTime, buf + 12);
CBytesWriter::ReadBytes(m_uModDate, buf + 14);
CBytesWriter::ReadBytes(m_uCrc32, buf + 16);
CBytesWriter::ReadBytes(m_uComprSize, buf + 20, 4);
CBytesWriter::ReadBytes(m_uUncomprSize, buf + 24, 4);
CBytesWriter::ReadBytes(uFileNameSize, buf + 28);
CBytesWriter::ReadBytes(uExtraFieldSize, buf + 30);
CBytesWriter::ReadBytes(uCommentSize, buf + 32);
CBytesWriter::ReadBytes(m_uVolumeStart, buf + 34, 2);
CBytesWriter::ReadBytes(m_uInternalAttr, buf + 36);
CBytesWriter::ReadBytes(m_uExternalAttr, buf + 38);
CBytesWriter::ReadBytes(m_uOffset, buf + 42, 4);
buf.Release();
// we may need to modify this later
m_uEncryptionMethod = (BYTE)((m_uFlag & (WORD) 1) != 0 ? CZipCryptograph::encStandard : CZipCryptograph::encNone);
ZIP_VOLUME_TYPE uCurDsk = pStorage->GetCurrentVolume();
m_pszFileNameBuffer.Allocate(uFileNameSize); // don't add NULL at the end
pStorage->Read(m_pszFileNameBuffer, uFileNameSize, true);
if (centralDir.m_pStringSettings->IsStandardNameCodePage())
m_stringSettings.SetDefaultNameCodePage(GetSystemCompatibility());
else
m_stringSettings.m_uNameCodePage = centralDir.m_pStringSettings->m_uNameCodePage;
if (!centralDir.m_pStringSettings->IsStandardCommentCodePage())
m_stringSettings.m_uCommentCodePage = centralDir.m_pStringSettings->m_uCommentCodePage;
if (!m_aCentralExtraData.Read(pStorage, uExtraFieldSize))
return false;
CZipExtraData* pExtra = m_aCentralExtraData.Lookup(ZIP_EXTRA_ZARCH_NAME);
if (pExtra != NULL)
{
WORD uExtraDataSize = (WORD)pExtra->m_data.GetSize();
int offset = 1;
if (offset > uExtraDataSize)
return false;
if (pExtra->m_data[0] <= ZIP_EXTRA_ZARCH_NAME_VER) // else don't parse it
{
offset++;
if (offset > uExtraDataSize)
return false;
BYTE flag = pExtra->m_data[1];
bool bReadCommentCp = (flag & 4) != 0;
if ((flag & 1) != 0)
{
// code page present
if (offset + 4 > uExtraDataSize)
return false;
// avoid warnings
DWORD temp;
CBytesWriter::ReadBytes(temp, pExtra->m_data + offset);
m_stringSettings.m_uNameCodePage = temp;
offset += 4;
}
if ((flag & 3) == 3)
{
m_stringSettings.m_bStoreNameInExtraData = true;
int iFileNameSize = pExtra->m_data.GetSize() - 2 - 4;
if (bReadCommentCp)
iFileNameSize -= 4;
// code page present
if (offset + iFileNameSize > uExtraDataSize || iFileNameSize <= 0)
return false;
CZipAutoBuffer buffer;
buffer.Allocate(iFileNameSize);
memcpy(buffer, pExtra->m_data + offset, iFileNameSize);
m_pszFileName = new CZipString(_T(""));
ZipCompatibility::ConvertBufferToString(*m_pszFileName, buffer, m_stringSettings.m_uNameCodePage);
offset += iFileNameSize;
m_pszFileNameBuffer.Release();
}
else
m_stringSettings.m_bStoreNameInExtraData = false;
if (bReadCommentCp)
{
// code page present
if (offset + 4 > uExtraDataSize)
return false;
DWORD temp;
CBytesWriter::ReadBytes(temp, pExtra->m_data + offset);
m_stringSettings.m_uCommentCodePage = temp;
// offset += 4;
}
}
}
if (uCommentSize)
{
m_pszComment.Allocate(uCommentSize);
pStorage->Read(m_pszComment, uCommentSize, true);
}
return pStorage->GetCurrentVolume() == uCurDsk; // check that the whole header is in one volume
}
time_t CZipFileHeader::GetTime()const
{
struct tm atm;
atm.tm_sec = (m_uModTime & ~0xFFE0) << 1;
atm.tm_min = (m_uModTime & ~0xF800) >> 5;
atm.tm_hour = m_uModTime >> 11;
atm.tm_mday = m_uModDate & ~0xFFE0;
atm.tm_mon = ((m_uModDate & ~0xFE00) >> 5) - 1;
atm.tm_year = (m_uModDate >> 9) + 80;
atm.tm_isdst = -1;
return mktime(&atm);
}
// write the header to the central dir
DWORD CZipFileHeader::Write(CZipStorage *pStorage)
{
m_aCentralExtraData.RemoveInternalHeaders();
WORD uMethod = m_uMethod;
if (!CheckLengths(false))
CZipException::Throw(CZipException::tooLongData);
PrepareFileName();
if (m_stringSettings.m_bStoreNameInExtraData)
{
if (m_pszFileName == NULL && m_pszFileNameBuffer.IsAllocated())
GetFileName(false); // don't clear the buffer, it will be needed in a moment
ASSERT(m_pszFileName != NULL);
if (m_pszFileName->GetLength() == 0)
m_stringSettings.m_bStoreNameInExtraData = false;
}
int iSystemCompatibility = GetSystemCompatibility();
if (!m_stringSettings.IsStandard(iSystemCompatibility))
{
CZipExtraData* pExtra = m_aCentralExtraData.CreateNew(ZIP_EXTRA_ZARCH_NAME);
bool bWriteCommentCp = !m_stringSettings.IsStandardCommentCodePage();
BYTE flag = 0;
int offset = 2;
char* data = NULL;
if (m_stringSettings.m_bStoreNameInExtraData)
{
CZipAutoBuffer buffer;
// m_pszFileNameBuffer contains CP_ACP page, we don't check if the current page is CP_ACP - too large dependency on PrepareFileName
ZipCompatibility::ConvertStringToBuffer(*m_pszFileName, buffer, m_stringSettings.m_uNameCodePage);
int size = 2 + 4 + buffer.GetSize();
if (bWriteCommentCp)
size += 4;
pExtra->m_data.Allocate(size);
data = (char*)pExtra->m_data;
CBytesWriter::WriteBytes(data + offset, (DWORD)m_stringSettings.m_uNameCodePage);
offset += 4;
memcpy(data + offset, buffer, buffer.GetSize());
offset += buffer.GetSize();
flag = 3;
}
else if (!m_stringSettings.IsStandardNameCodePage(iSystemCompatibility))
{
int size = 2 + 4;
if (bWriteCommentCp)
size += 4;
pExtra->m_data.Allocate(size);
data = (char*)pExtra->m_data;
CBytesWriter::WriteBytes(data + offset, (DWORD)m_stringSettings.m_uNameCodePage);
offset += 4;
flag = 1;
}
if (bWriteCommentCp)
{
if (!pExtra->m_data.IsAllocated())
{
pExtra->m_data.Allocate(2 + 4);
data = (char*)pExtra->m_data;
}
ASSERT(data);
CBytesWriter::WriteBytes(data + offset, (DWORD)m_stringSettings.m_uCommentCodePage);
flag |= 4;
}
data[0] = ZIP_EXTRA_ZARCH_NAME_VER;
data[1] = flag;
}
WORD uFileNameSize = (WORD)m_pszFileNameBuffer.GetSize(), uCommentSize = (WORD)GetCommentSize(),
uExtraFieldSize = (WORD)m_aCentralExtraData.GetTotalSize();
DWORD uSize = FILEHEADERSIZE + uFileNameSize + uCommentSize + uExtraFieldSize;
CZipAutoBuffer buf(uSize);
char* dest = (char*)buf;
memcpy(dest, m_gszSignature, 4);
CBytesWriter::WriteBytes(dest + 4, m_uVersionMadeBy);
CBytesWriter::WriteBytes(dest + 6, m_uVersionNeeded);
CBytesWriter::WriteBytes(dest + 8, m_uFlag);
CBytesWriter::WriteBytes(dest + 10, uMethod);
CBytesWriter::WriteBytes(dest + 12, m_uModTime);
CBytesWriter::WriteBytes(dest + 14, m_uModDate);
WriteCrc32(dest + 16);
CBytesWriter::WriteBytes(dest + 20, CBytesWriter::WriteSafeU32(m_uComprSize));
CBytesWriter::WriteBytes(dest + 24, CBytesWriter::WriteSafeU32(m_uUncomprSize));
CBytesWriter::WriteBytes(dest + 28, uFileNameSize);
CBytesWriter::WriteBytes(dest + 30, uExtraFieldSize);
CBytesWriter::WriteBytes(dest + 32, uCommentSize);
CBytesWriter::WriteBytes(dest + 34, CBytesWriter::WriteSafeU16(m_uVolumeStart));
CBytesWriter::WriteBytes(dest + 36, m_uInternalAttr);
CBytesWriter::WriteBytes(dest + 38, m_uExternalAttr);
CBytesWriter::WriteBytes(dest + 42, CBytesWriter::WriteSafeU32(m_uOffset));
memcpy(dest + 46, m_pszFileNameBuffer, uFileNameSize);
if (uExtraFieldSize)
m_aCentralExtraData.Write(dest + 46 + uFileNameSize);
if (uCommentSize)
memcpy(dest + 46 + uFileNameSize + uExtraFieldSize, m_pszComment, uCommentSize);
pStorage->Write(dest, uSize, true);
// remove to avoid miscalculations in GetSize()
m_aCentralExtraData.RemoveInternalHeaders();
ClearFileName();
return uSize;
}
bool CZipFileHeader::ReadLocal(CZipCentralDir& centralDir)
{
char buf[LOCALFILEHEADERSIZE];
CZipStorage* pStorage = centralDir.m_pStorage;
pStorage->Read(buf, LOCALFILEHEADERSIZE, true);
if (memcmp(buf, m_gszLocalSignature, 4) != 0)
return false;
bool bIsDataDescr = (((WORD)*(buf + 6)) & 8) != 0;
WORD uTemp;
CBytesWriter::ReadBytes(uTemp, buf + 6);
// do not compare the whole flag - the bits reserved by PKWARE may differ
// in local and central headers
if (centralDir.IsConsistencyCheckOn( CZipArchive::checkLocalFlag)
&& (uTemp & 0xf) != (m_uFlag & 0xf))
return false;
// method
WORD uMethod;
CBytesWriter::ReadBytes(uMethod, buf + 8);
// this may be different in the local header (it may contain disk name for example)
CBytesWriter::ReadBytes(m_uLocalFileNameSize, buf + 26);
WORD uExtraFieldSize;
CBytesWriter::ReadBytes(uExtraFieldSize, buf + 28);
ZIP_VOLUME_TYPE uCurDsk = pStorage->GetCurrentVolume();
// skip reading the local file name
pStorage->m_pFile->Seek(m_uLocalFileNameSize, CZipAbstractFile::current);
if (!m_aLocalExtraData.Read(pStorage, uExtraFieldSize))
return false;
CBytesWriter::ReadBytes(m_uLocalComprSize, buf + 18, 4);
CBytesWriter::ReadBytes(m_uLocalUncomprSize, buf + 22, 4);
if (uMethod == CZipCompressor::methodWinZipAes && IsEncrypted())
CZipException::Throw(CZipException::noAES);
if (centralDir.IsConsistencyCheckOn( CZipArchive::checkLocalMethod)
&& uMethod != m_uMethod )
return false;
if (!bIsDataDescr && centralDir.IsConsistencyCheckOn( CZipArchive::checkLocalCRC | CZipArchive::checkLocalSizes))
{
// read all at once - probably overally faster than checking and reading separately
DWORD uCrc32;
CBytesWriter::ReadBytes(uCrc32, buf + 14);
if (centralDir.IsConsistencyCheckOn( CZipArchive::checkLocalCRC)
&& uCrc32 != m_uCrc32)
return false;
if (centralDir.IsConsistencyCheckOn( CZipArchive::checkLocalSizes)
// do not check, if local compressed size is 0 - this usually means, that some archiver
// could not update the compressed size after compression
&& ( m_uLocalComprSize != 0 && m_uLocalComprSize != m_uComprSize || m_uLocalUncomprSize != m_uUncomprSize))
return false;
}
return pStorage->GetCurrentVolume() == uCurDsk; // check that the whole header is in one volume
}
void CZipFileHeader::SetTime(const time_t & ttime)
{
#if _MSC_VER >= 1400
tm gts;
tm* gt = &gts;
localtime_s(gt, &ttime);
#else
tm* gt = localtime(&ttime);
#endif
WORD year, month, day, hour, min, sec;
if (gt == NULL)
{
year = 0;
month = day = 1;
hour = min = sec = 0;
}
else
{
year = (WORD)(gt->tm_year + 1900);
if (year <= 1980)
year = 0;
else
year -= 1980;
month = (WORD)gt->tm_mon + 1;
day = (WORD)gt->tm_mday;
hour = (WORD)gt->tm_hour;
min = (WORD)gt->tm_min;
sec = (WORD)gt->tm_sec;
}
m_uModDate = (WORD) (day + ( month << 5) + (year << 9));
m_uModTime = (WORD) ((sec >> 1) + (min << 5) + (hour << 11));
}
void CZipFileHeader::ConvertFileName(CZipAutoBuffer& buffer) const
{
if (m_pszFileName == NULL)
return;
CZipString temp = *m_pszFileName;
ZipCompatibility::SlashBackslashChg(temp, false);
if (m_stringSettings.m_bStoreNameInExtraData)
ZipCompatibility::ConvertStringToBuffer(temp, buffer, m_stringSettings.GetDefaultNameCodePage(GetSystemCompatibility()));
else
ZipCompatibility::ConvertStringToBuffer(temp, buffer, m_stringSettings.m_uNameCodePage);
}
void CZipFileHeader::ConvertFileName(CZipString& szFileName) const
{
if (!m_pszFileNameBuffer.IsAllocated() || m_pszFileNameBuffer.GetSize() == 0)
return;
ZipCompatibility::ConvertBufferToString(szFileName, m_pszFileNameBuffer, m_stringSettings.m_uNameCodePage);
int sc = ZipPlatform::GetSystemID();
if (sc == ZipCompatibility::zcDosFat || sc == ZipCompatibility::zcNtfs)
ZipCompatibility::SlashBackslashChg(szFileName, true);
else // some archives may have an invalid path separator stored
ZipCompatibility::SlashBackslashChg(szFileName, false);
}
// write the local header
void CZipFileHeader::WriteLocal(CZipStorage *pStorage)
{
if (IsDataDescriptor())
{
m_uLocalComprSize = 0;
// write, if we know it - WinZip 9.0 in segmented mode with AES encryption will
// complain otherwise (this seems like a bug, because the data descriptor is present and
// local descriptor should be discarded)
if (!IsWinZipAesEncryption())
m_uLocalUncomprSize = 0;
}
else
{
m_uLocalComprSize = GetDataSize(true, false);
}
WORD uMethod = m_uMethod;
PrepareFileName();
m_uLocalFileNameSize = (WORD)m_pszFileNameBuffer.GetSize();
DWORD uExtraFieldSize = m_aLocalExtraData.GetTotalSize();
DWORD iLocalSize = LOCALFILEHEADERSIZE + uExtraFieldSize + m_uLocalFileNameSize;
CZipAutoBuffer buf(iLocalSize);
char* dest = (char*) buf;
memcpy(dest, m_gszLocalSignature, 4);
CBytesWriter::WriteBytes(dest + 4, m_uVersionNeeded);
CBytesWriter::WriteBytes(dest + 6, m_uFlag);
CBytesWriter::WriteBytes(dest + 8, uMethod);
CBytesWriter::WriteBytes(dest + 10, m_uModTime);
CBytesWriter::WriteBytes(dest + 12, m_uModDate);
WriteSmallDataDescriptor(dest + 14);
CBytesWriter::WriteBytes(dest + 26, m_uLocalFileNameSize);
CBytesWriter::WriteBytes(dest + 28, (WORD)uExtraFieldSize);
memcpy(dest + 30, m_pszFileNameBuffer, m_uLocalFileNameSize);
if (uExtraFieldSize)
m_aLocalExtraData.Write(dest + 30 + m_uLocalFileNameSize);
// possible volume change before writing to the file in the segmented archive
// so write the local header first
pStorage->Write(dest, iLocalSize, true);
m_uVolumeStart = pStorage->GetCurrentVolume();
m_uOffset = pStorage->GetPosition() - iLocalSize;
ClearFileName();
}
WORD CZipFileHeader::GetDataDescriptorSize(bool bConsiderSignature) const
{
if (IsDataDescriptor())
{
WORD size = 12;
return (WORD)(bConsiderSignature ? size + 4 : size);
}
else
return 0;
}
bool CZipFileHeader::NeedsDataDescriptor() const
{
return m_uEncryptionMethod == CZipCryptograph::encStandard;
}
void CZipFileHeader::PrepareData(int iLevel, bool bSegm)
{
// could be == 1, but the way below it works for PredictMaximumFileSizeInArchive when used on an existing segmented archive - for whatever reason
m_uInternalAttr = 0;
// version made by
SetVersion((WORD)(0x14));
m_uCrc32 = 0;
m_uComprSize = 0;
m_uUncomprSize = 0;
ASSERT(CZipCompressor::IsCompressionSupported(m_uMethod) && ((iLevel == 0) == (m_uMethod == CZipCompressor::methodStore)));
m_uFlag = 0;
if (m_uMethod == CZipCompressor::methodDeflate)
switch (iLevel)
{
case 1:
m_uFlag |= 6;
break;
case 2:
m_uFlag |= 4;
break;
case 8:
case 9:
m_uFlag |= 2;
break;
}
UpdateFlag(bSegm);
m_uVersionNeeded = 0;
if (m_uVersionNeeded == 0)
m_uVersionNeeded = IsDirectory() ? 0xa : 0x14; // 1.0 or 2.0
}
void CZipFileHeader::GetCrcAndSizes(char * pBuffer)const
{
WriteCrc32(pBuffer);
CBytesWriter::WriteBytes(pBuffer + 4, m_uComprSize, 4);
CBytesWriter::WriteBytes(pBuffer + 8, m_uUncomprSize, 4);
}
bool CZipFileHeader::CheckDataDescriptor(CZipStorage* pStorage) const
{
if (!IsDataDescriptor())
return true;
const int sizeOfSize = 4;
const int size = 4 + 2 * sizeOfSize; // crc and two sizes
CZipAutoBuffer buf(size + 4);
pStorage->Read(buf, size, false);
char* pBuf;
// when an archive is segmented, files that are divided between volume have bit 3 of flag set
// which tell about the presence of the data descriptor after the compressed data
// This signature may be in a segmented archive that is one volume only
// (it is detected as a not segmented archive)
if (memcmp(buf, CZipStorage::m_gszExtHeaderSignat, 4) == 0) // there is a signature
{
pStorage->Read((char*)buf + size, 4, false);
pBuf = (char*)buf + 4;
}
else
pBuf = buf;
DWORD uCrc32 = 0;
ZIP_SIZE_TYPE uCompressed = 0, uUncompressed = 0;
CBytesWriter::ReadBytes(uCrc32, pBuf);
CBytesWriter::ReadBytes(uCompressed, pBuf + 4, sizeOfSize);
CBytesWriter::ReadBytes(uUncompressed, pBuf + 4 + sizeOfSize, sizeOfSize);
return uCrc32 == m_uCrc32 && uCompressed == m_uComprSize && uUncompressed == m_uUncomprSize;
}
DWORD CZipFileHeader::GetSize()const
{
DWORD uSize = FILEHEADERSIZE + PredictFileNameSize() + GetCommentSize();
uSize += m_aCentralExtraData.GetTotalSize();
if (m_stringSettings.m_bStoreNameInExtraData)
{
CZipString temp;
if (m_pszFileName != NULL)
temp = *m_pszFileName;
else
ConvertFileName(temp);
if (temp.GetLength() > 0)
{
uSize += 4 + 2 + 4; // headerID, size + version, flag + filename code page
CZipAutoBuffer buffer;
ZipCompatibility::ConvertStringToBuffer(temp, buffer, m_stringSettings.m_uNameCodePage);
uSize += buffer.GetSize();
if (!m_stringSettings.IsStandardCommentCodePage())
uSize += 4;
}
}
return uSize;
}
DWORD CZipFileHeader::GetLocalSize(bool bReal)const
{
DWORD uSize = LOCALFILEHEADERSIZE + m_aLocalExtraData.GetTotalSize();
if (bReal)
uSize += m_uLocalFileNameSize;
else
uSize += PredictFileNameSize();
return uSize;
}
void CZipFileHeader::SetComment(LPCTSTR lpszComment)
{
ZipCompatibility::ConvertStringToBuffer(lpszComment, m_pszComment, m_stringSettings.m_uCommentCodePage);
}
CZipString CZipFileHeader::GetComment() const
{
CZipString temp;
ZipCompatibility::ConvertBufferToString(temp, m_pszComment, m_stringSettings.m_uCommentCodePage);
return temp;
}
int CZipFileHeader::GetCompressionLevel() const
{
if (m_uMethod == CZipCompressor::methodStore)
return CZipCompressor::levelStore;
else if ((m_uFlag & (WORD) 6) != 0)
return 1;
else if ((m_uFlag & (WORD) 4) != 0)
return 2;
else if ((m_uFlag & (WORD) 2) != 0)
return CZipCompressor::levelBest;
else
return CZipCompressor::levelDefault;
}
void CZipFileHeader::SetFileName(LPCTSTR lpszFileName)
{
if (m_pszFileName == NULL)
m_pszFileName = new CZipString(lpszFileName);
else
*m_pszFileName = lpszFileName;
m_pszFileNameBuffer.Release();
}
CZipString& CZipFileHeader::GetFileName(bool bClearBuffer)
{
if (m_pszFileName != NULL)
return *m_pszFileName;
m_pszFileName = new CZipString(_T(""));
ConvertFileName(*m_pszFileName);
// don't keep it in memory
if (bClearBuffer)
m_pszFileNameBuffer.Release();
return *m_pszFileName;
}
bool CZipFileHeader::IsDirectory()
{
return ZipPlatform::IsDirectory(GetSystemAttr());
}
DWORD CZipFileHeader::GetSystemAttr()
{
int iSystemComp = GetSystemCompatibility();
if (ZipCompatibility::IsPlatformSupported(iSystemComp))
{
DWORD uAttr = iSystemComp == ZipCompatibility::zcUnix ? (m_uExternalAttr >> 16) : (m_uExternalAttr & 0xFFFF);
if (!uAttr && CZipPathComponent::HasEndingSeparator(GetFileName()))
return ZipPlatform::GetDefaultDirAttributes(); // can happen
else
{
uAttr = ZipCompatibility::ConvertToSystem(uAttr, iSystemComp, ZipPlatform::GetSystemID());
#ifdef ZIP_ARCHIVE_LNX
// converting from Windows attributes may create a not readable linux directory
if (iSystemComp != ZipCompatibility::zcUnix && ZipPlatform::IsDirectory(uAttr))
return ZipPlatform::GetDefaultDirAttributes();
#endif
return uAttr;
}
}
else
return CZipPathComponent::HasEndingSeparator(GetFileName()) ? ZipPlatform::GetDefaultDirAttributes() : ZipPlatform::GetDefaultAttributes();
}
void CZipFileHeader::SetSystemAttr(DWORD uAttr)
{
// make it readable under Unix as well, since it stores its attributes in HIWORD(uAttr)
int iSystemComp = GetSystemCompatibility();
m_uExternalAttr = ZipCompatibility::ConvertToSystem(uAttr, ZipPlatform::GetSystemID(), iSystemComp);
if (iSystemComp == ZipCompatibility::zcUnix)
{
m_uExternalAttr <<= 16;
if (ZipPlatform::IsDirectory(uAttr))
m_uExternalAttr |= 0x10; // make it recognizable under other systems (all use 0x10 for directory)
}
else
// make it readable under linux
m_uExternalAttr |= (ZipCompatibility::ConvertToSystem(uAttr, ZipPlatform::GetSystemID(), ZipCompatibility::zcUnix) << 16);
}
CZipFileHeader& CZipFileHeader::operator=(const CZipFileHeader& header)
{
m_uVersionMadeBy = header.m_uVersionMadeBy;
m_uVersionNeeded = header.m_uVersionNeeded;
m_uFlag = header.m_uFlag;
m_uMethod = header.m_uMethod;
m_uModTime = header.m_uModTime;
m_uModDate = header.m_uModDate;
m_uCrc32 = header.m_uCrc32;
m_uComprSize = header.m_uComprSize;
m_uUncomprSize = header.m_uUncomprSize;
m_uVolumeStart = header.m_uVolumeStart;
m_uInternalAttr = header.m_uInternalAttr;
m_uLocalComprSize = header.m_uLocalComprSize;
m_uLocalUncomprSize = header.m_uUncomprSize;
m_uExternalAttr = header.m_uExternalAttr;
m_uLocalFileNameSize = header.m_uLocalFileNameSize;;
m_uOffset = header.m_uOffset;
m_aLocalExtraData = header.m_aLocalExtraData;
m_aCentralExtraData = header.m_aCentralExtraData;
m_uEncryptionMethod = header.m_uEncryptionMethod;
if (m_pszFileName)
delete m_pszFileName;
if (header.m_pszFileName)
m_pszFileName = new CZipString(*header.m_pszFileName);
else
m_pszFileName = NULL;
m_pszFileNameBuffer = header.m_pszFileNameBuffer;
m_pszComment = header.m_pszComment;
m_stringSettings = header.m_stringSettings;
return *this;
}
void CZipFileHeader::WriteSmallDataDescriptor(char* pDest, bool bLocal)
{
WriteCrc32(pDest);
if (bLocal)
{
CBytesWriter::WriteBytes(pDest + 4, m_uLocalComprSize, 4);
CBytesWriter::WriteBytes(pDest + 8, m_uLocalUncomprSize, 4);
}
else
{
CBytesWriter::WriteBytes(pDest + 4, m_uComprSize, 4);
CBytesWriter::WriteBytes(pDest + 8, m_uUncomprSize, 4);
}
}
void CZipFileHeader::WriteDataDescriptor(CZipStorage* pStorage)
{
if (!IsDataDescriptor())
return;
bool signature = NeedsSignatureInDataDescriptor(pStorage);
CZipAutoBuffer buf;
buf.Allocate(GetDataDescriptorSize(signature));
char* pBuf;
if (signature)
{
memcpy(buf, CZipStorage::m_gszExtHeaderSignat, 4);
pBuf = (char*)buf + 4;
}
else
pBuf = buf;
WriteCrc32(pBuf);
CBytesWriter::WriteBytes(pBuf + 4, m_uComprSize, 4);
CBytesWriter::WriteBytes(pBuf + 8, m_uUncomprSize, 4);
pStorage->Write(buf, buf.GetSize(), true);
}
void CZipFileHeader::UpdateLocalHeader(CZipStorage* pStorage)
{
if (pStorage->IsSegmented() != 0 || IsDataDescriptor())
// there is nothing to fix
return;
pStorage->Flush();
ZIP_FILE_USIZE uPos = pStorage->m_pFile->GetPosition();
// update crc and sizes, the sizes may already be all right,
// but 8 more bytes won't make a difference, we need to update crc32 anyway
CZipAutoBuffer buf(12);
m_uLocalComprSize = CBytesWriter::WriteSafeU32(m_uComprSize);
m_uLocalUncomprSize = CBytesWriter::WriteSafeU32(m_uUncomprSize);
WriteSmallDataDescriptor(buf);
pStorage->Seek(m_uOffset + 14);
pStorage->m_pFile->Write(buf, 12);
pStorage->m_pFile->Seek(uPos);
}
void CZipFileHeader::WriteCrc32(char* pBuf) const
{
DWORD uCrc = m_bIgnoreCrc32 ? 0 : m_uCrc32;
CBytesWriter::WriteBytes(pBuf, uCrc);
}

709
harbour/contrib/hbziparch/ZipFileHeader.h
View File

@@ -1,709 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipFileHeader.h
* Includes the CZipFileHeader class.
*
*/
#if !defined(ZIPARCHIVE_ZIPFILEHEADER_DOT_H)
#define ZIPARCHIVE_ZIPFILEHEADER_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipExport.h"
#include "ZipStorage.h"
#include "ZipAutoBuffer.h"
#include "sys/types.h"
#include "ZipCompatibility.h"
#include "ZipCollections.h"
#include "ZipExtraField.h"
#include "ZipStringStoreSettings.h"
#include "ZipCryptograph.h"
class CZipCentralDir;
/**
Represents a single file stored in a zip archive.
*/
class ZIP_API CZipFileHeader
{
friend class CZipCentralDir;
friend class CZipArchive;
public:
CZipFileHeader();
CZipFileHeader(const CZipFileHeader& header)
{
*this = header;
}
CZipFileHeader& operator=(const CZipFileHeader& header);
virtual ~CZipFileHeader();
/**
Predicts the filename size after conversion using the current filename code page.
\return
The number of characters not including a terminating \c NULL character.
*/
int PredictFileNameSize() const
{
if (m_pszFileNameBuffer.IsAllocated())
return m_pszFileNameBuffer.GetSize();
CZipAutoBuffer buffer;
ConvertFileName(buffer);
return buffer.GetSize();
}
/**
Gets the comment size.
\return
The number of characters in the comment not including a terminating \c NULL character.
*/
WORD GetCommentSize() const {return (WORD)m_pszComment.GetSize();}
/**
Gets the filename. If necessary, performs the conversion using the current filename code page.
Caches the result of conversion for faster access the next time.
\param bClearBuffer
If \c true, releases the internal buffer after performing the filename conversion.
If \c false, the internal buffer is not released and both representations of the
filename are kept in memory (converted and not converted). This takes more memory, but the
conversion does not take place again when the central directory is written back to the archive.
\return
The converted filename.
\see
<a href="kb">0610051525</a>
\see
GetStringStoreSettings
\see
CZipStringStoreSettings::m_uNameCodePage
*/
CZipString& GetFileName(bool bClearBuffer = true);
/**
Sets the filename.
\param lpszFileName
The filename to set.
*/
void SetFileName(LPCTSTR lpszFileName);
/**
Gets the file comment.
\return
The file comment.
*/
CZipString GetComment() const;
/**
Sets the file comment.
\param lpszComment
The file comment.
*/
void SetComment(LPCTSTR lpszComment);
/**
Gets a value indicating whether the data descriptor is present or not.
\return
\c true, if the data descriptor is present; \c false otherwise.
*/
bool IsDataDescriptor()const { return (m_uFlag & (WORD) 8) != 0;}
/**
Gets the data descriptor size as it is required for the current file.
Takes into account various factors, such as the archive segmentation type,
encryption and the need for the Zip64 format.
\param pStorage
The storage to test for segmentation type.
\return
The required data descriptor size in bytes.
*/
WORD GetDataDescriptorSize(const CZipStorage* pStorage) const
{
return GetDataDescriptorSize(NeedsSignatureInDataDescriptor(pStorage));
}
/**
Gets the data descriptor size as it is required for the current file.
Takes into account various factors, such as the need for the data descriptor signature
or for the Zip64 format.
\param bConsiderSignature
\c true, if the data descriptor signature is needed; \c false otherwise.
\return
The required data descriptor size in bytes.
*/
WORD GetDataDescriptorSize(bool bConsiderSignature = false) const;
/**
Gets the size of the compressed data.
\param bUseLocal
If \c true, uses #m_uLocalComprSize; otherwise uses #m_uComprSize;
\param bReal
If \c true, the returned value does not include the encrypted information size, only the data size.
If \c false, the encrypted information size is added (you should not use this value
when the file exists in the archive).
\return
The compressed data size in bytes.
\see
GetEncryptedInfoSize
*/
ZIP_SIZE_TYPE GetDataSize(bool bUseLocal = false, bool bReal = true) const
{
ZIP_SIZE_TYPE uSize = bUseLocal ? m_uLocalComprSize : m_uComprSize;
DWORD uEncrSize = GetEncryptedInfoSize();
return bReal ? (uSize - uEncrSize) : (uSize + uEncrSize);
}
/**
Gets the encrypted information size. The returned value depends on the used encryption method.
\return
The encrypted information size in bytes.
*/
DWORD GetEncryptedInfoSize() const
{
return CZipCryptograph::GetEncryptedInfoSize(m_uEncryptionMethod);
}
/**
Gets the total size of the structure in the central directory.
\return
The total size in bytes.
*/
DWORD GetSize()const;
/**
Gets the local header size. Before calling this method, the local information must be up-to-date
(see <a href="kb">0610242128|local</a> for more information).
\param bReal
If \c true, uses the real local filename size.
If \c false, predicts the filename size.
\return
The local header size in bytes.
*/
DWORD GetLocalSize(bool bReal) const;
/**
Gets a value indicating if the compression is efficient.
\return
\c true if the compression is efficient; \c false if the file should be
stored without the compression instead.
*/
bool CompressionEfficient()
{
ZIP_SIZE_TYPE uBefore = m_uUncomprSize;
// ignore the length of encryption info
ZIP_SIZE_TYPE uAfter = GetDataSize(false, true);
return uAfter <= uBefore;
}
/**
Gets the compression ratio.
\return
The compression ratio of the file.
*/
float GetCompressionRatio()
{
#if _MSC_VER >= 1300 || !defined(_ZIP64)
return m_uUncomprSize ? ((float)m_uComprSize * 100 ) / m_uUncomprSize: 0;
#else
return m_uUncomprSize ? ((float)(__int64)(m_uComprSize) / (float)(__int64)m_uUncomprSize) * 100: 0;
#endif
}
/**
Sets the file modification date.
\param ttime
The date to set. If this value is incorrect, the date defaults to January 1, 1980.
\see
GetTime
*/
void SetTime(const time_t& ttime);
/**
Gets the file modification time.
\return
The modification time.
\see
SetTime
*/
time_t GetTime()const;
/**
Gets the file system compatibility.
External software can use this information e.g. to determine end-of-line
format for text files etc.
The ZipArchive Library uses it to perform a proper file attributes conversion.
\return
The file system compatibility. Can be one of the ZipCompatibility::ZipPlatforms values.
\see
CZipArchive::GetSystemComatibility
\see
ZipPlatform::GetSystemID
*/
int GetSystemCompatibility()const
{
return (m_uVersionMadeBy & 0xFF00) >> 8;
}
/**
Gets the file attributes.
\return
The file attributes, converted if necessary to be compatible with the current system.
\note
Throws an exception, if the archive system or the current system
is not supported by the ZipArchive Library.
\see
GetOriginalAttributes
*/
DWORD GetSystemAttr();
/**
Gets the file attributes exactly as they are stored in the archive.
\return
The file attributes as they are stored in the archive.
No conversion is performed.
\note
The attributes for Linux are stored shifted left by 16 bits in this field.
\see
GetSystemAttr
*/
DWORD GetOriginalAttributes() const {return m_uExternalAttr;}
/**
Gets a value indicating whether the file represents a directory or not.
This method checks the file attributes. If the attributes value is zero,
the method checks for the presence of a path
separator at the end of the filename. If the path separator is present,
the file is assumed to be a directory.
\return
\c true, if the file represents a directory; \c false otherwise.
*/
bool IsDirectory();
/**
Gets the string store settings for the file.
\return
The string store settings.
\see
<a href="kb">0610051525</a>
\see
CZipArchive::GetStringStoreSettings
*/
CZipStringStoreSettings GetStringStoreSettings()
{
return m_stringSettings;
}
/**
Gets a value indicating if the file is encrypted or not.
If the file is encrypted, you need to set the password with the
CZipArchive::SetPassword method before decompressing the file.
\return
\c true if the file is encrypted; \c false otherwise.
\see
CZipArchive::SetPassword
*/
bool IsEncrypted()const { return m_uEncryptionMethod != CZipCryptograph::encNone;}
/**
Gets the encryption method of the file.
\return
The file encryption method. Can be one of the CZipCryptograph::EncryptionMethod values.
*/
int GetEncryptionMethod() const {return m_uEncryptionMethod;}
/**
Gets a value indicating if the file is encrypted using WinZip AES encryption method or not.
\return
\c true, if the file is encrypted using WinZip AES encryption method; \c false otherwise.
*/
bool IsWinZipAesEncryption() const
{
return CZipCryptograph::IsWinZipAesEncryption(m_uEncryptionMethod);
}
/**
Gets an approximate file compression level.
\return
The compression level. May not be the real value used when compressing the file.
*/
int GetCompressionLevel() const;
/**
Returns the value indicating whether the current CZipFileHeader object has the time set or not.
\return
\c true, if the time is set; \c false otherwise.
*/
bool HasTime()
{
return m_uModTime != 0 || m_uModDate != 0;
}
static char m_gszSignature[]; ///< The central file header signature.
static char m_gszLocalSignature[]; ///< The local file header signature.
WORD m_uVersionMadeBy; ///< The "made by" version and the system compatibility.
WORD m_uVersionNeeded; ///< The version needed to extract the file.
WORD m_uFlag; ///< A general purpose bit flag.
WORD m_uMethod; ///< The compression method. Can be one of the CZipCompressor::CompressionMethod values.
WORD m_uModTime; ///< The file last modification time.
WORD m_uModDate; ///< The file last modification date.
DWORD m_uCrc32; ///< The crc-32 value.
ZIP_SIZE_TYPE m_uComprSize; ///< The compressed size.
ZIP_SIZE_TYPE m_uUncomprSize; ///< The uncompressed size.
ZIP_VOLUME_TYPE m_uVolumeStart; ///< The volume number at which the compressed file starts.
WORD m_uInternalAttr; ///< Internal file attributes.
ZIP_SIZE_TYPE m_uLocalComprSize; ///< The compressed size written in the local header.
ZIP_SIZE_TYPE m_uLocalUncomprSize; ///< The uncompressed size written in the local header.
ZIP_SIZE_TYPE m_uOffset; ///< Relative offset of the local header with respect to CZipFileHeader::m_uVolumeStart.
CZipExtraField m_aLocalExtraData; ///< The local extra field. Do not modify after you have started compressing the file.
CZipExtraField m_aCentralExtraData; ///< The central extra field.
protected:
DWORD m_uExternalAttr; ///< External file attributes.
WORD m_uLocalFileNameSize; ///< The local filename length.
BYTE m_uEncryptionMethod; ///< The file encryption method. Can be one of the CZipCryptograph::EncryptionMethod values.
bool m_bIgnoreCrc32; ///< A value indicating whether to ignore Crc32 checking or not.
/**
Sets the file system compatibility.
\param iSystemID
The file system compatibility. Can be one of the ZipCompatibility::ZipPlatforms values.
\see
GetSystemCompatibility
*/
void SetSystemCompatibility(int iSystemID)
{
m_uVersionMadeBy &= 0x00FF;
m_uVersionMadeBy |= (WORD)(iSystemID << 8);
}
/**
Sets the file attributes.
To set the attributes of this structure use the CZipArchive::SetFileHeaderAttr method.
\param uAttr
The attributes to set.
\note
Throws exceptions, if the archive system or the current system
is not supported by the ZipArchive Library.
\see
CZipArchive::SetFileHeaderAttr
\see
GetSystemAttr
*/
void SetSystemAttr(DWORD uAttr);
/**
Prepares the filename for writing to the archive.
*/
void PrepareFileName()
{
if (m_pszFileNameBuffer.IsAllocated() || m_pszFileName == NULL)
return;
ConvertFileName(m_pszFileNameBuffer);
}
/**
Validates an existing data descriptor after file decompression.
\param pStorage
The storage to read the data descriptor from.
\return
\c true, if the data descriptor is valid; \c false otherwise.
*/
bool CheckDataDescriptor(CZipStorage* pStorage) const;
/**
Prepares the data for writing when adding a new file. When Zip64 extensions are required for this file,
this method adds Zip64 extra data to #m_aLocalExtraData.
\param iLevel
The compression level.
\param bSegm
Set to \c true, if the archive is segmented; \c false otherwise.
*/
void PrepareData(int iLevel, bool bSegm);
/**
Writes the local file header to the \a pStorage.
The filename and extra field are the same as those that will be stored in the central directory.
\param pStorage
The storage to write the local file header to.
\note
Throws exceptions.
*/
void WriteLocal(CZipStorage *pStorage);
/**
Reads the local file header from an archive and validates the read data.
\param centralDir
The current central directory.
\return
\c true, if read data is consistent; \c false otherwise.
\note
Throws exceptions.
\see
CZipArchive::SetIgnoredConsistencyChecks
*/
bool ReadLocal(CZipCentralDir& centralDir);
/**
Writes the central file header to \a pStorage.
\param pStorage
The storage to write the central file header to.
\return
The size of the file header.
\note
Throws exceptions.
*/
DWORD Write(CZipStorage *pStorage);
/**
Reads the central file header from \a pStorage and validates the read data.
\param centralDir
The current central directory.
\param bReadSignature
\c true, if the the central header signature should be read; \c false otherwise.
\return
\c true, if the read data is consistent; \c false otherwise.
\note
Throws exceptions.
*/
bool Read(CZipCentralDir& centralDir, bool bReadSignature);
/**
Validates the member fields lengths.
The tested fields are: filename, extra fields and comment.
\return
\c false, if any of the lengths exceeds the allowed value.
*/
bool CheckLengths(bool local) const
{
if (m_pszComment.GetSize() > USHRT_MAX || m_pszFileNameBuffer.GetSize() > USHRT_MAX)
return false;
else if (local)
return m_aLocalExtraData.Validate();
else
return m_aCentralExtraData.Validate();
}
/**
Writes the Crc32 to \a pBuf.
\param pBuf
The buffer to write the Crc32 to. Must have be of at least 4 bytes size.
*/
void WriteCrc32(char* pBuf) const;
/**
Gets a value indicating whether the file needs the data descriptor.
The data descriptor is needed when a file is encrypted or the Zip64 format needs to be used.
\return
\c true, if the data descriptor is needed; \c false otherwise.
*/
bool NeedsDataDescriptor() const;
/**
Writes the data descriptor.
\param pDest
The buffer to receive the data.
\param bLocal
Set to \c true, if the local sizes are used; \c false otherwise.
*/
void WriteSmallDataDescriptor(char* pDest, bool bLocal = true);
/**
Writes the data descriptor taking into account the Zip64 format.
\param pStorage
The storage to write the data descriptor to.
*/
void WriteDataDescriptor(CZipStorage* pStorage);
bool NeedsSignatureInDataDescriptor(const CZipStorage* pStorage) const
{
return pStorage->IsSegmented() != 0 || IsEncrypted();
}
/**
Updates the local header in the archive after is has already been written.
\param pStorage
The storage to update the data descriptor in.
*/
void UpdateLocalHeader(CZipStorage* pStorage);
/**
Verifies the central header signature.
\param buf
The buffer that contains the signature to verify.
\return
\c true, if the signature is valid; \c false otherwise.
*/
static bool VerifySignature(CZipAutoBuffer& buf)
{
return memcmp(buf, m_gszSignature, 4) == 0;
}
/**
Updates the general purpose bit flag.
\param bSegm
\c true, if the current archive is a segmented archive; \c false otherwise.
*/
void UpdateFlag(bool bSegm)
{
if (bSegm || m_uEncryptionMethod == CZipCryptograph::encStandard)
m_uFlag |= 8; // data descriptor present
if (IsEncrypted())
m_uFlag |= 1; // encrypted file
}
private:
/**
Sets the "made by" version.
\param uVersion
The version to set.
*/
void SetVersion(WORD uVersion)
{
if ((m_uVersionMadeBy & 0x00FF) != (uVersion & 0x00FF))
{
m_uVersionMadeBy &= 0xFF00;
m_uVersionMadeBy |= (WORD)(uVersion & 0x00FF);
}
}
void ConvertFileName(CZipAutoBuffer& buffer) const;
void ConvertFileName(CZipString& szFileName) const;
void ClearFileName()
{
if (m_stringSettings.m_bStoreNameInExtraData)
// we are keeping m_pszFileName, clear the buffer, we need the original, when writing extra header and when accessing the filename
m_pszFileNameBuffer.Release();
else if (m_pszFileName != NULL)
{
delete m_pszFileName;
m_pszFileName = NULL;
}
}
void GetCrcAndSizes(char* pBuffer)const;
bool NeedsZip64() const
{
return m_uComprSize >= UINT_MAX || m_uUncomprSize >= UINT_MAX || m_uVolumeStart >= USHRT_MAX || m_uOffset >= UINT_MAX;
}
void OnNewFileClose(CZipStorage* pStorage)
{
UpdateLocalHeader(pStorage);
WriteDataDescriptor(pStorage);
pStorage->Flush();
}
CZipAutoBuffer m_pszFileNameBuffer;
CZipString* m_pszFileName;
CZipStringStoreSettings m_stringSettings;
CZipAutoBuffer m_pszComment;
};
#endif // !defined(ZIPARCHIVE_ZIPFILEHEADER_DOT_H)

37
harbour/contrib/hbziparch/ZipFileMapping.h
View File

@@ -1,37 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipFileMapping.h
* Includes the ZipArchiveLib::CZipFileMapping class.
*
*/
#if !defined(ZIPARCHIVE_ZIPFILEMAPPING_DOT_H)
#define ZIPARCHIVE_ZIPFILEMAPPING_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "_platform.h"
#ifdef ZIP_ARCHIVE_WIN
#include "ZipFileMapping_win.h"
#else
#include "ZipFileMapping_lnx.h"
#endif
#endif // !defined(ZIPARCHIVE_ZIPFILEMAPPING_DOT_H)

62
harbour/contrib/hbziparch/ZipFileMapping_lnx.h
View File

@@ -1,62 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPFILEMAPPING_DOT_H
#error Do not include this file directly. Include ZipFileMapping.h instead
#endif
#include <sys/mman.h>
namespace ZipArchiveLib
{
struct CZipFileMapping
{
CZipFileMapping()
{
m_iSize = 0;
m_pFileMap = NULL;
}
bool CreateMapping(CZipFile* pFile)
{
if (!pFile)
return false;
m_iSize = pFile->GetLength();
m_pFileMap = mmap(0, m_iSize, PROT_READ|PROT_WRITE, MAP_SHARED, pFile->m_hFile, 0);
return (m_pFileMap != NULL);
}
void RemoveMapping()
{
if (m_pFileMap)
{
munmap(m_pFileMap, m_iSize);
m_pFileMap = NULL;
}
}
~CZipFileMapping()
{
RemoveMapping();
}
char* GetMappedMemory()
{
return reinterpret_cast<char*> (m_pFileMap);
}
protected:
void* m_pFileMap;
size_t m_iSize;
};
}

68
harbour/contrib/hbziparch/ZipFileMapping_win.h
View File

@@ -1,68 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPFILEMAPPING_DOT_H
#error Do not include this file directly. Include ZipFileMapping.h instead
#endif
#include "ZipFile.h"
namespace ZipArchiveLib
{
struct CZipFileMapping
{
CZipFileMapping()
{
m_hFileMap = NULL;
m_pFileMap = NULL;
}
bool CreateMapping(CZipFile* pFile)
{
if (!pFile)
return false;
m_hFileMap = CreateFileMapping((*pFile), NULL, PAGE_READWRITE,
0, 0, _T("ZipArchive Mapping File"));
if (!m_hFileMap)
return false;
// Get pointer to memory representing file
m_pFileMap = MapViewOfFile(m_hFileMap, FILE_MAP_WRITE, 0, 0, 0);
return (m_pFileMap != NULL);
}
void RemoveMapping()
{
if (m_pFileMap)
{
UnmapViewOfFile(m_pFileMap);
m_pFileMap = NULL;
}
if (m_hFileMap)
{
CloseHandle(m_hFileMap);
m_hFileMap = NULL;
}
}
~CZipFileMapping()
{
RemoveMapping();
}
char* GetMappedMemory()
{
return reinterpret_cast<char*> (m_pFileMap);
}
protected:
HANDLE m_hFileMap;
LPVOID m_pFileMap;
};
}

39
harbour/contrib/hbziparch/ZipFile_mfc.cpp
View File

@@ -1,39 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"
#if defined ZIP_ARCHIVE_MFC && !defined ZIP_FILE_USES_STL
#include "stdafx.h"
#include "ZipFile.h"
// IMPLEMENT_DYNAMIC(CZipAbstractFile, CFile)
IMPLEMENT_DYNAMIC(CZipFile, CFile)
CZipFile::CZipFile()
{
}
CZipFile::~CZipFile()
{
Close();
}
CZipFile::operator HANDLE()
{
return (HANDLE)m_hFile;
}
#endif

87
harbour/contrib/hbziparch/ZipFile_mfc.h
View File

@@ -1,87 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPFILE_DOT_H
#error Do not include this file directly. Include ZipFile.h instead
#endif
#if _MSC_VER > 1000 && defined ZIP_HAS_DLL
#pragma warning (push)
#pragma warning( disable : 4275 ) // non dll-interface used as base for dll-interface class
#endif
#include "ZipAbstractFile.h"
#include "ZipExport.h"
class ZIP_API CZipFile : public CZipAbstractFile, public CFile
{
public:
DECLARE_DYNAMIC(CZipFile)
void Flush(){CFile::Flush();}
CZipString GetFilePath() const
{
try
{
// it throws an exception when working on an offline file
return CFile::GetFilePath();
}
catch (CException* e)
{
e->Delete();
return this->m_strFileName;
}
}
ZIP_FILE_USIZE GetPosition() const {return CFile::GetPosition() ;}
void SetLength(ZIP_FILE_USIZE nNewLen) {CFile::SetLength(nNewLen);}
ZIP_FILE_USIZE Seek(ZIP_FILE_SIZE lOff , int nFrom){return CFile::Seek(lOff, nFrom);}
ZIP_FILE_USIZE GetLength() const {return CFile::GetLength();}
UINT Read(void *lpBuf, UINT nCount){return CFile::Read(lpBuf, nCount);}
void Write(const void* lpBuf, UINT nCount){CFile::Write(lpBuf, nCount);}
bool Open( LPCTSTR lpszFileName, UINT nOpenFlags, bool bThrowExc)
{
CFileException* e = new CFileException;
bool bRet = CFile::Open(lpszFileName, nOpenFlags, e) != 0;
if (!bRet && bThrowExc)
throw e;
e->Delete();
return bRet;
}
CZipFile();
bool IsClosed() const
{
return m_hFile == CFile::hFileNull;
}
CZipFile( LPCTSTR lpszFileName, UINT nOpenFlags ):CFile(lpszFileName, nOpenFlags)
{
}
void Close( )
{
if (!IsClosed())
CFile::Close();
}
operator HANDLE();
virtual ~CZipFile();
};
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (pop)
#endif

144
harbour/contrib/hbziparch/ZipFile_stl.cpp
View File

@@ -1,144 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_features.h"
#if defined ZIP_ARCHIVE_STL || defined ZIP_FILE_USES_STL
#if defined __APPLE__ || defined __CYGWIN__
#define FILE_FUNCTIONS_64B_BY_DEFAULT
#else
#undef FILE_FUNCTIONS_64B_BY_DEFAULT
#endif
#include "stdafx.h"
#include "ZipFile.h"
#include "ZipException.h"
#include "ZipPlatform.h"
#include <fcntl.h>
CZipFile::CZipFile()
{
m_hFile = -1;
}
void CZipFile::ThrowError() const
{
CZipException::Throw(errno, m_szFileName);
}
ZIP_FILE_USIZE CZipFile::GetLength() const
{
// cannot use Seek here, Seek is not const
ZIP_SIZE_TYPE lLen, lCur;
lCur = _lseek(m_hFile, 0, current);
if (lCur == (ZIP_SIZE_TYPE)-1)
ThrowError();
lLen = _lseek(m_hFile, 0, end);
// first go back
bool err = _lseek(m_hFile, lCur, begin) == -1;
if (err || lLen == (ZIP_SIZE_TYPE)-1)
ThrowError();
return lLen;
}
bool CZipFile::Open(LPCTSTR lpszFileName, UINT openFlags, bool bThrow)
{
if (!IsClosed())
Close();
#ifdef O_BINARY
UINT iNewFlags = O_BINARY;
#else
UINT iNewFlags = 0;
#endif
bool bReadOnly = false;
if (openFlags & CZipFile::modeCreate)
iNewFlags |= O_CREAT;
if ((openFlags & CZipFile::modeReadWrite) == CZipFile::modeReadWrite)
iNewFlags |= O_RDWR;
else if (openFlags & CZipFile::modeRead)
{
// O_RDONLY is defined as 0
bReadOnly = true;
iNewFlags |= O_RDONLY;
}
else if (openFlags & CZipFile::modeWrite)
iNewFlags |= O_WRONLY;
if (!(openFlags & CZipFile::modeNoTruncate) && !bReadOnly)
iNewFlags |= O_TRUNC;
m_hFile = ZipPlatform::OpenFile(lpszFileName, iNewFlags, openFlags & 0x1C);
if (m_hFile == -1)
if (bThrow)
CZipException::Throw(errno, lpszFileName);
else
return false;
m_szFileName = lpszFileName;
return true;
}
void CZipFile::SetLength(ULONGLONG uNewLen)
{
ZipPlatform::TruncateFile(m_hFile, uNewLen);
}
ZIP_FILE_USIZE CZipFile::GetPosition() const
{
#ifndef __GNUC__
ZIP_FILE_USIZE ret = _tell(m_hFile);
#else
ZIP_FILE_USIZE ret = lseek(m_hFile, 0, SEEK_CUR);
#endif
if (ret == (ZIP_FILE_USIZE)-1)
ThrowError();
return ret;
}
ZIP_FILE_USIZE CZipFile::Seek(ZIP_FILE_SIZE dOff, int nFrom)
{
// restricted to signed
ZIP_FILE_SIZE ret = (ZIP_FILE_SIZE)_lseek(m_hFile, (long)dOff, nFrom);
if (ret == -1)
ThrowError();
return (ZIP_FILE_USIZE)ret;
}
void CZipFile::Flush()
{
if (!ZipPlatform::FlushFile(m_hFile))
ThrowError();
}
CZipFile::operator HANDLE()
{
intptr_t fh = ZipPlatform::GetFileSystemHandle(m_hFile);
if (fh == -1)
ThrowError();
#if _MSC_VER >= 1300
return (HANDLE)fh;
#else
return (HANDLE)fh;
#endif
}
#endif

119
harbour/contrib/hbziparch/ZipFile_stl.h
View File

@@ -1,119 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPFILE_DOT_H
#error Do not include this file directly. Include ZipFile.h instead
#endif
#include "ZipAbstractFile.h"
#include "ZipString.h"
#include "ZipExport.h"
#ifndef __GNUC__
#include <io.h>
#else
#include <unistd.h>
#include <errno.h>
#endif
#if !defined (_MSC_VER) || _MSC_VER < 1400
// there seems to be a problem under Windows sometimes when using one of the functions below
// without the underscore at the beginning
#ifndef _lseek
#define _lseek lseek
#endif
#ifndef _read
#define _read read
#endif
#ifndef _close
#define _close close
#endif
#ifndef _tell
#define _tell tell
#endif
#ifndef _write
#define _write write
#endif
#endif
class ZIP_API CZipFile : public CZipAbstractFile
{
void ThrowError() const;
public:
int m_hFile;
operator HANDLE();
enum OpenModes
{
modeRead = 0x0001,
modeWrite = 0x0002,
modeReadWrite = modeRead | modeWrite,
shareDenyWrite = 0x0004,
shareDenyRead = 0x0008,
shareDenyNone = 0x0010,
modeCreate = 0x0020,
modeNoTruncate = 0x0040,
};
CZipFile(LPCTSTR lpszFileName, UINT openFlags)
{
m_hFile = -1;
Open(lpszFileName, openFlags, true);
}
void Flush();
ZIP_FILE_USIZE GetLength() const;
CZipString GetFilePath() const {return m_szFileName;}
bool IsClosed()const { return m_hFile == -1;}
bool Open(LPCTSTR lpszFileName, UINT openFlags, bool bThrow);
void Close()
{
if (IsClosed())
return;
if (_close(m_hFile) != 0)
ThrowError();
else
{
m_szFileName.Empty();
m_hFile = -1;
}
}
void Write(const void* lpBuf, UINT nCount)
{
if (_write(m_hFile, lpBuf, nCount) != (int) nCount)
ThrowError();
}
ZIP_FILE_USIZE GetPosition() const;
void SetLength(ZIP_FILE_USIZE uNewLen);
UINT Read(void *lpBuf, UINT nCount)
{
errno = 0;
int ret = _read(m_hFile, lpBuf, nCount);
if (ret < (int) nCount && errno != 0)
ThrowError();
return ret;
}
ZIP_FILE_USIZE Seek(ZIP_FILE_SIZE dOff, int nFrom);
CZipFile ();
virtual ~CZipFile (){Close();};
protected:
CZipString m_szFileName;
};

110
harbour/contrib/hbziparch/ZipMemFile.cpp
View File

@@ -1,110 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipMemFile.h"
#include "ZipException.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
void CZipMemFile::Grow(size_t nGrowTo)
{
if (m_nBufSize < (UINT)nGrowTo)
{
if (m_nGrowBy == 0)
CZipException::Throw(CZipException::memError);
size_t nNewSize = m_nBufSize;
while (nNewSize < nGrowTo)
nNewSize += m_nGrowBy;
BYTE* lpNew;
if (m_lpBuf)
lpNew = (BYTE*)realloc((void*) m_lpBuf, nNewSize);
else
lpNew = (BYTE*)malloc(nNewSize);
if (!lpNew)
CZipException::Throw(CZipException::memError);
m_nBufSize = nNewSize;
m_lpBuf = lpNew;
}
}
void CZipMemFile::SetLength(ZIP_FILE_USIZE nNewLen)
{
if (m_nBufSize < (size_t)nNewLen)
Grow((size_t)nNewLen);
else
m_nPos = (size_t)nNewLen;
m_nDataSize = (size_t)nNewLen;
}
UINT CZipMemFile::Read(void *lpBuf, UINT nCount)
{
if (m_nPos >= m_nDataSize)
return 0;
UINT nToRead = (m_nPos + nCount > m_nDataSize) ? (UINT)(m_nDataSize - m_nPos) : nCount;
memcpy(lpBuf, m_lpBuf + m_nPos, nToRead);
m_nPos += nToRead;
return nToRead;
}
void CZipMemFile::Write(const void *lpBuf, UINT nCount)
{
if (!nCount)
return;
if (m_nPos + nCount > m_nBufSize)
Grow(m_nPos + nCount);
memcpy(m_lpBuf + m_nPos, lpBuf, nCount);
m_nPos += nCount;
if (m_nPos > m_nDataSize)
m_nDataSize = m_nPos;
}
ZIP_FILE_USIZE CZipMemFile::Seek(ZIP_FILE_SIZE lOff, int nFrom)
{
ZIP_FILE_USIZE lNew = m_nPos;
if (nFrom == CZipAbstractFile::begin)
{
if (lOff < 0)
CZipException::Throw(CZipException::memError);
lNew = lOff;
}
else if (nFrom == CZipAbstractFile::current)
{
if (lOff < 0 && (ZIP_FILE_USIZE)(-lOff) > lNew)
CZipException::Throw(CZipException::memError);
lNew += lOff;
}
else if (nFrom == CZipAbstractFile::end)
{
if (lOff < 0 && ZIP_FILE_USIZE(-lOff) > m_nDataSize)
CZipException::Throw(CZipException::memError);
lNew = m_nDataSize + lOff;
}
else
return lNew;
// assumption that size_t is always signed
if (lNew > (size_t)(-1)) // max of size_t
CZipException::Throw(CZipException::memError);
if (lNew > m_nDataSize)
Grow((size_t)lNew);
m_nPos = (size_t)lNew;
return lNew;
}

129
harbour/contrib/hbziparch/ZipMemFile.h
View File

@@ -1,129 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipMemFile.h
* Includes the CZipMemFile class.
*
*/
#if !defined(ZIPARCHIVE_ZIPMEMFILE_DOT_H)
#define ZIPARCHIVE_ZIPMEMFILE_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "ZipAbstractFile.h"
#include "ZipString.h"
#include "ZipExport.h"
/**
Represents a file in memory.
Automatically grows when necessary.
*/
class ZIP_API CZipMemFile : public CZipAbstractFile
{
protected:
size_t m_nGrowBy, m_nPos;
size_t m_nBufSize, m_nDataSize;
BYTE* m_lpBuf;
bool m_bAutoDelete;
void Free()
{
if (m_lpBuf)
{
free(m_lpBuf);
m_lpBuf = NULL;
}
}
void Init()
{
m_nGrowBy = m_nPos = 0;
m_nBufSize = m_nDataSize = 0;
m_lpBuf = NULL;
}
void Grow(size_t nBytes);
public:
bool IsClosed() const { return m_lpBuf == NULL;}
void Flush(){}
ZIP_FILE_USIZE Seek(ZIP_FILE_SIZE lOff, int nFrom);
ZIP_FILE_USIZE GetLength() const {return m_nDataSize;}
void Write(const void* lpBuf, UINT nCount);
UINT Read(void* lpBuf, UINT nCount);
void SetLength(ZIP_FILE_USIZE nNewLen);
CZipString GetFilePath() const {return _T("");}
CZipMemFile(long nGrowBy = 1024)
{
Init();
m_nGrowBy = nGrowBy;
m_bAutoDelete = true;
}
CZipMemFile(BYTE* lpBuf, UINT nBufSize, long nGrowBy = 0)
{
Init();
Attach(lpBuf, nBufSize, nGrowBy);
}
CZipMemFile(CZipMemFile& from)
{
Copy(from);
}
void Copy(CZipMemFile& from)
{
SetLength(from.m_nDataSize);
from.Read(m_lpBuf, (UINT)from.m_nDataSize);
}
ZIP_FILE_USIZE GetPosition() const { return m_nPos;}
void Attach(BYTE* lpBuf, UINT nBufSize, long nGrowBy = 0)
{
Close();
m_lpBuf = lpBuf;
m_nGrowBy = nGrowBy;
m_nBufSize = nBufSize;
m_nDataSize = nGrowBy == 0 ? nBufSize : 0;
m_bAutoDelete = false;
}
void ReInit(long nGrowBy = 1024)
{
Close();
Init();
m_nGrowBy = nGrowBy;
m_bAutoDelete = true;
}
BYTE* Detach()
{
BYTE* b = m_lpBuf;
Init();
return b;
}
void Close()
{
if (m_bAutoDelete)
Free();
Init();
}
virtual ~CZipMemFile(){Close();}
};
#endif // !defined(ZIPARCHIVE_ZIPMEMFILE_DOT_H)

38
harbour/contrib/hbziparch/ZipMutex.h
View File

@@ -1,38 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipMutex.h
* Includes the ZipArchiveLib::CZipMutex class.
*
*/
#if !defined(ZIPARCHIVE_ZIPMUTEX_DOT_H)
#define ZIPARCHIVE_ZIPMUTEX_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "_features.h"
#ifdef ZIP_ARCHIVE_LNX
#include "ZipMutex_lnx.h"
#else
#include "ZipMutex_win.h"
#endif
#endif

84
harbour/contrib/hbziparch/ZipMutex_lnx.h
View File

@@ -1,84 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPMUTEX_DOT_H
#error Do not include this file directly. Include ZipMutex.h instead
#endif
#ifdef ZIP_ARCHIVE_USE_LOCKING
#include <pthread.h>
namespace ZipArchiveLib
{
class ZIP_API CZipMutex
{
pthread_mutex_t m_mutex;
bool m_bOpened;
public:
CZipMutex(bool bOpen = false)
{
if (bOpen)
Open();
else
m_bOpened = false;
}
void Open()
{
Close();
if (pthread_mutex_init(&m_mutex, NULL) == 0)
m_bOpened = true;
else
CZipException::Throw(CZipException::mutexError);
}
void Lock()
{
if (pthread_mutex_lock(&m_mutex) != 0)
CZipException::Throw(CZipException::mutexError);
}
void Unlock()
{
if (pthread_mutex_unlock(&m_mutex) != 0)
CZipException::Throw(CZipException::mutexError);
}
CZipMutex& operator=(const CZipMutex&)
{
m_bOpened = false;
return *this;
}
void Close()
{
if (m_bOpened)
if (pthread_mutex_destroy(&m_mutex) == 0)
m_bOpened = false;
else
CZipException::Throw(CZipException::mutexError);
}
~CZipMutex()
{
Close();
}
};
}
#endif

81
harbour/contrib/hbziparch/ZipMutex_win.h
View File

@@ -1,81 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPMUTEX_DOT_H
#error Do not include this file directly. Include ZipMutex.h instead
#endif
#ifdef ZIP_ARCHIVE_USE_LOCKING
#include "ZipException.h"
namespace ZipArchiveLib
{
class ZIP_API CZipMutex
{
HANDLE m_handle;
public:
CZipMutex(bool bOpen = false)
{
if (bOpen)
Open();
else
m_handle = NULL;
}
void Open()
{
Close();
m_handle = ::CreateMutex(NULL, FALSE, NULL);
if (m_handle == NULL)
CZipException::Throw(CZipException::mutexError);
}
void Lock()
{
DWORD dwRet = ::WaitForSingleObject(m_handle, INFINITE);
if (dwRet != WAIT_OBJECT_0 && dwRet != WAIT_ABANDONED)
CZipException::Throw(CZipException::mutexError);
}
void Unlock()
{
if (!::ReleaseMutex(m_handle))
CZipException::Throw(CZipException::mutexError);
}
void Close()
{
if (m_handle != NULL)
{
::CloseHandle(m_handle);
m_handle = NULL;
}
}
CZipMutex& operator=(const CZipMutex&)
{
m_handle = NULL;
return *this;
}
~CZipMutex()
{
Close();
}
};
}
#endif

276
harbour/contrib/hbziparch/ZipPathComponent.h
View File

@@ -1,276 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipPathComponent.h
* Includes the CZipPathComponent class.
*
*/
#if !defined(ZIPARCHIVE_ZIPPATHCOMPONENT_DOT_H)
#define ZIPARCHIVE_ZIPPATHCOMPONENT_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 "ZipString.h"
#include "ZipExport.h"
/**
Splits a file path into components.
*/
class ZIP_API CZipPathComponent
{
public:
CZipPathComponent(){}
virtual ~CZipPathComponent();
static const TCHAR m_cSeparator; ///< A system - specific default path separator.
/**
Appends a path separator to \a szPath, if it is not already appended.
\param szPath
The path to have a separator appended.
*/
static void AppendSeparator(CZipString& szPath)
{
RemoveSeparators(szPath);
szPath += m_cSeparator;
}
/**
Combines a path information with a file name information.
\param szPath
Provides the path information and retrieves the result.
\param lpszName
The filename to be appended to the path.
*/
static void Combine(CZipString& szPath, LPCTSTR lpszName)
{
AppendSeparator(szPath);
if (lpszName != NULL)
szPath += lpszName;
}
/**
Removes path separators from the end of \a szPath
\param szPath
The path to have path separators removed.
*/
static void RemoveSeparators(CZipString& szPath)
{
// szPath.TrimRight(m_cSeparator);
szPath.TrimRight(_T("\\/"));
}
/**
Removes path separators from the beginning of \a szPath.
\param szPath
The path to have path separators removed.
*/
static void RemoveSeparatorsLeft(CZipString& szPath)
{
szPath.TrimLeft(_T("\\/"));
}
/**
Tests the character, if it is a separator or not.
\param c
The character to test.
\return
\c true, if \a c is a path separator; \c false otherwise.
*/
static bool IsSeparator(TCHAR c)
{
return c == _T('\\') || c == _T('/');
}
/**
Checks if \a szPath has a path separator appended.
\param szPath
The path to be tested.
\return
\c true, if \a szPath has a path separator at the end; \c false otherwise.
*/
static bool HasEndingSeparator(const CZipString& szPath)
{
int iLen = szPath.GetLength();
if (iLen)
return IsSeparator(szPath[iLen - 1]);
else
return false;
}
/**
Initializes a new instance of the CZipPathComponent class.
\param lpszFullPath
The full path to the file.
\see
SetFullPath
*/
CZipPathComponent(LPCTSTR lpszFullPath)
{
SetFullPath(lpszFullPath);
}
/**
Sets the full path to the file.
\param lpszFullPath
The full path to the file including a filename.
The last element in the path is assumed to be a filename.
*/
void SetFullPath(LPCTSTR lpszFullPath);
/**
Gets the name of the file without an extension (and without a path).
\return
The title of the file.
*/
CZipString GetFileTitle() const { return m_szFileTitle;}
/**
Sets the file title (the name without an extension and without a path).
\param lpszFileTitle
The title to set.
*/
void SetFileTitle(LPCTSTR lpszFileTitle) { m_szFileTitle = lpszFileTitle;}
/**
Sets the extension alone.
\param lpszExt
The extension to set. May contain a dot at the beginning, but doesn't have to.
*/
void SetExtension(LPCTSTR lpszExt)
{
m_szFileExt = lpszExt;
m_szFileExt.TrimLeft(_T('.'));
}
/**
Gets the extension of the file.
\return
The extension without a dot.
*/
CZipString GetFileExt() const { return m_szFileExt;}
/**
Gets the drive of the file.
\return
The drive without a path separator at the end.
*/
CZipString GetFileDrive() const { return m_szDrive;}
/**
Gets the full path to the file without the drive.
\return
The path without the drive and without a path separator at the beginning.
*/
CZipString GetNoDrive() const ;
/**
Get the filename.
\return
The filename including an extension and without a path.
*/
CZipString GetFileName() const
{
CZipString szFullFileName = m_szFileTitle;
if (!m_szFileExt.IsEmpty())
{
szFullFileName += _T(".");
szFullFileName += m_szFileExt;
}
return szFullFileName;
}
/**
Gets the full path to the file.
\return
The full path information including the filename.
*/
CZipString GetFullPath() const
{
CZipString szFullPath = GetFilePath();
CZipString szFileName = GetFileName();
if (!szFileName.IsEmpty())
{
if (szFullPath.IsEmpty())
szFullPath += _T('.');
szFullPath += m_cSeparator;
szFullPath += szFileName;
}
return szFullPath;
}
/**
Gets the path part only.
\return
The path to the file without a filename and without a path separator at the end.
*/
CZipString GetFilePath() const
{
CZipString szDrive = m_szDrive;
CZipString szDir = m_szDirectory;
if (!szDrive.IsEmpty() && !szDir.IsEmpty())
szDrive += m_cSeparator;
return m_szPrefix + szDrive + szDir;
}
protected:
/**
\name Path parts.
*/
//@{
CZipString m_szDirectory, ///< A directory(ies) only without path separators at the end and the beginning.
m_szFileTitle, ///< A filename without an extension.
m_szFileExt, ///< A file extension without a dot.
m_szDrive, ///< A drive (if the system path standard uses it) without a path separator at the end.
m_szPrefix; ///< A prefix (e.g. for the UNC path or Unicode path under Windows).
//@}
};
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (pop)
#endif
#endif // !defined(ZIPARCHIVE_ZIPPATHCOMPONENT_DOT_H)

94
harbour/contrib/hbziparch/ZipPathComponent_lnx.cpp
View File

@@ -1,94 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_platform.h"
#ifdef ZIP_ARCHIVE_LNX
#include "stdafx.h"
#include "ZipPathComponent.h"
CZipPathComponent::~CZipPathComponent()
{
}
void CZipPathComponent::SetFullPath(LPCTSTR lpszFullPath)
{
CZipString szTempPath(lpszFullPath);
const CZipString szPrefix = _T("\\\\?\\unc\\");
int i = -1, iLen = szPrefix.GetLength();
if (iLen > szTempPath.GetLength())
iLen = szTempPath.GetLength();
CZipString szPossiblePrefix = szTempPath.Left(iLen);
szPossiblePrefix.MakeLower(); // must perform case insensitive comparison
while (++i < iLen && szPossiblePrefix[i] == szPrefix[i]);
if (i == 2 || i == 4 || i == 8) // unc path, unicode path or unc path meeting windows file name conventions
{
m_szPrefix = szTempPath.Left(i);
szTempPath = szTempPath.Mid(i);
}
else
m_szPrefix.Empty();
m_szDrive.Empty();
m_szFileTitle.Empty();
m_szDirectory.Empty();
m_szFileExt.Empty();
int p;
for (p = szTempPath.GetLength() - 1; p >= 0; p--)
if (szTempPath[p] == m_cSeparator)
break;
if (p != -1)
{
m_szDirectory = szTempPath.Left(p);
if (p == szTempPath.GetLength() - 1 )
return; // no filename present
else
p++;
}
else
p = 0;
// p points at the beginning of the filename
m_szFileTitle = szTempPath.Mid(p);
for (p = m_szFileTitle.GetLength() - 1; p >= 0; p--)
if (m_szFileTitle[p] == _T('.'))
break;
if (p != -1)
{
m_szFileExt = m_szFileTitle.Mid(p+1);
m_szFileTitle = m_szFileTitle.Left(p);
}
}
CZipString CZipPathComponent::GetNoDrive() const
{
CZipString szPath = m_szDirectory;
CZipString szFileName = GetFileName();
if (!szFileName.IsEmpty() && !szPath.IsEmpty())
szPath += m_cSeparator;
szPath += szFileName;
return szPath;
}
#endif // ZIP_ARCHIVE_LNX

82
harbour/contrib/hbziparch/ZipPathComponent_win.cpp
View File

@@ -1,82 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_platform.h"
#ifdef ZIP_ARCHIVE_WIN
#include "stdafx.h"
#include "ZipPathComponent.h"
CZipPathComponent::~CZipPathComponent()
{
}
void CZipPathComponent::SetFullPath(LPCTSTR lpszFullPath)
{
TCHAR szDrive[_MAX_DRIVE];
#if defined _UNICODE && _MSC_VER >= 1400
TCHAR szDir[32767];
#else
TCHAR szDir[_MAX_DIR];
#endif
TCHAR szFname[_MAX_FNAME];
TCHAR szExt[_MAX_EXT];
CZipString szTempPath(lpszFullPath);
const CZipString szPrefix = _T("\\\\?\\unc\\");
int i = -1, iLen = szPrefix.GetLength();
if (iLen > szTempPath.GetLength())
iLen = szTempPath.GetLength();
CZipString szPossiblePrefix = szTempPath.Left(iLen);
szPossiblePrefix.MakeLower(); // must perform case insensitive comparison
while (++i < iLen && szPossiblePrefix[i] == szPrefix[i]);
if (i == 2 || i == 4 || i == 8) // unc path, unicode path or unc path meeting windows file name conventions
{
m_szPrefix = szTempPath.Left(i);
szTempPath = szTempPath.Mid(i);
}
else
m_szPrefix.Empty();
#if _MSC_VER >= 1400
_tsplitpath_s(szTempPath, szDrive , szDir, szFname, szExt);
#else
_tsplitpath(szTempPath, szDrive , szDir, szFname, szExt);
#endif
m_szDrive = szDrive;
m_szDirectory = szDir;
m_szDirectory.TrimLeft(m_cSeparator);
m_szDirectory.TrimRight(m_cSeparator);
SetExtension(szExt);
m_szFileTitle = szFname;
}
CZipString CZipPathComponent::GetNoDrive() const
{
CZipString szPath = m_szDirectory;
CZipString szFileName = GetFileName();
if (!szFileName.IsEmpty() && !szPath.IsEmpty())
szPath += m_cSeparator;
szPath += szFileName;
return szPath;
}
#endif // ZIP_ARCHIVE_WIN

265
harbour/contrib/hbziparch/ZipPlatform.h
View File

@@ -1,265 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipPlatform.h
* ZipPlatform namespace declaration.
*
*/
#if !defined(ZIPARCHIVE_ZIPPLATFORM_DOT_H)
#define ZIPARCHIVE_ZIPPLATFORM_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
class CZipFileHeader;
class CZipAutoBuffer;
#include "ZipString.h"
#include "ZipPathComponent.h"
#include <sys/types.h>
#include "ZipExport.h"
/**
Includes functions that require system-specific implementation.
*/
namespace ZipPlatform
{
/**
Gets the default case-sensitivity for the current file system.
\return
\c true, if the system is case-sensitive; \c false otherwise.
*/
ZIP_API bool GetSystemCaseSensitivity();
/**
Gets the current system identifier.
\return
One of the ZipCompatibility::ZipPlatforms values.
\see
CZipArchive::SetSystemCompatibility
*/
ZIP_API int GetSystemID();
/**
Gets the default file attributes for the current system.
\return
The default file attributes.
*/
ZIP_API DWORD GetDefaultAttributes();
/**
Gets the default directory attributes for the current system.
\return
The default directory attributes.
*/
ZIP_API DWORD GetDefaultDirAttributes();
/**
Gets the free space on the given device.
\param lpszPath
Points to the device to test.
\return
The free space in bytes.
*/
ZIP_API ULONGLONG GetDeviceFreeSpace(LPCTSTR lpszPath);
/**
Gets the name of a temporary file ensuring there is enough free space in the destination directory.
\param lpszPath
The path to the directory to initially create the file in.
\param uSizeNeeded
The requested free space size in bytes. If set to <code>ZIP_SIZE_TYPE(-1)</code>, the
space availability is not checked.
*/
ZIP_API CZipString GetTmpFileName(LPCTSTR lpszPath = NULL, ZIP_SIZE_TYPE uSizeNeeded = ZIP_SIZE_TYPE(-1));
/**
\name Various operations on files and directories.
If the functions returns a \c bool value, then \c true indicates that the operation was successful.
*/
//@{
ZIP_API bool GetCurrentDirectory(CZipString& sz); ///< Gets the current directory and stores it in \a sz.
ZIP_API bool ChangeDirectory(LPCTSTR lpDirectory); ///< Changes the current directory.
ZIP_API bool SetFileAttr(LPCTSTR lpFileName, DWORD uAttr); ///< Sets the file attributes.
ZIP_API bool GetFileAttr(LPCTSTR lpFileName, DWORD& uAttr); ///< Gets the file attributes.
ZIP_API bool GetFileModTime(LPCTSTR lpFileName, time_t & ttime); ///< Gets the file modification time.
ZIP_API bool SetFileModTime(LPCTSTR lpFileName, time_t ttime); ///< Set the file modification time.
ZIP_API bool GetFileSize(LPCTSTR lpszFileName, ZIP_SIZE_TYPE& dSize); ///< Gets the file size.
ZIP_API bool CreateDirectory(LPCTSTR lpDirectory); ///< Creates a new directory.
ZIP_API bool SetVolLabel(LPCTSTR lpszPath, LPCTSTR lpszLabel); ///< Sets a label on a removable device. \c lpszPath may point to a file on the device.
ZIP_API bool ForceDirectory(LPCTSTR lpDirectory); ///< Creates nested directories at once.
ZIP_API bool RemoveFile(LPCTSTR lpszFileName, bool bThrow = true); ///< Removes a file.
ZIP_API bool RenameFile( LPCTSTR lpszOldName, LPCTSTR lpszNewName, bool bThrow = true); ///< Renames a file.
#ifdef ZIP_ARCHIVE_LNX
ZIP_API bool SetExeAttr( LPCTSTR lpFileName ); ///< Sets executable permissions for a file.
#endif
#if defined ZIP_ARCHIVE_STL || defined ZIP_FILE_USES_STL
/**
Truncates the file.
\note
Defined only in the STL version.
*/
ZIP_API bool TruncateFile(int iDes, ULONGLONG uSize);
/**
Opens the file.
\note
Defined only in the STL version.
*/
ZIP_API int OpenFile(LPCTSTR lpszFileName, UINT iMode, int iShareMode);
/**
Flushes the file to the disk.
\note
Defined only in the STL version.
*/
ZIP_API bool FlushFile(int iDes);
/**
Gets the underlying system handle.
\note
Defined only in the STL version.
*/
ZIP_API intptr_t GetFileSystemHandle(int iDes);
#endif
//@}
/**
Checks if the given directory exists.
\param lpszDir
The directory to test.
\return
\c true, if \a lpszDir exists; \c false otherwise.
*/
ZIP_API bool DirectoryExists(LPCTSTR lpszDir);
/**
Checks if the given drive is removable.
\param lpszFilePath
The path to the drive. May point to a file path or a directory on the drive.
\return
\c true. if the drive is removable; \c false otherwise.
\note
Implemented only on Windows system, on all others always returns \c true.
*/
ZIP_API bool IsDriveRemovable(LPCTSTR lpszFilePath);
/**
Checks if the given attributes represent a directory.
\param uAttr
The attributes to test.
\return
\c true if the attributes represent a directory; \c false otherwise.
*/
ZIP_API bool IsDirectory(DWORD uAttr);
/**
Performs the translation between ANSI and OEM character sets.
\param buffer
The buffer containing characters to be translated.
\param bAnsiToOem
If \c true, convert ANSI to OEM; if \c false, OEM to ANSI.
*/
ZIP_API void AnsiOem(CZipAutoBuffer& buffer, bool bAnsiToOem);
/**
Checks if the given file or directory exists.
\param lpszName
The path to the file or directory to test.
\return
One of the following values:
- \c -1 : the given file exists and is a directory
- \c 1 : the given file exists and is a regular file
- \c 0 : there is no such a file
*/
ZIP_API int FileExists(LPCTSTR lpszName);
#ifdef _UNICODE
/**
Converts a wide character string to a multi-byte character string.
\param lpszIn
The wide character string to convert.
\param szOut
The buffer to receive the converted string.
Does not contain the terminating \c NULL character.
\param uCodePage
The code page used in conversion.
\return
The \a szOut buffer length, or \c -1 when not succeeded.
\note
Defined only in the UNICODE version.
*/
ZIP_API int WideToMultiByte(LPCWSTR lpszIn, CZipAutoBuffer &szOut, UINT uCodePage);
/**
Converts a multi-byte character string to a wide character string.
\param szIn
The multi-byte character string to convert.
Should not contain the terminating \c NULL character.
\param szOut
Receives the converted string.
\param uCodePage
The code page used in conversion.
\return
The length of the string after the conversion (without the terminating \c NULL character)
or \c -1 when the function did not succeed.
\note
Defined only in the UNICODE version.
*/
ZIP_API int MultiByteToWide(const CZipAutoBuffer &szIn, CZipString& szOut, UINT uCodePage);
#endif
};
#endif // !defined(ZIPARCHIVE_ZIPPLATFORM_DOT_H)

94
harbour/contrib/hbziparch/ZipPlatformComm.cpp
View File

@@ -1,94 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipFile.h"
#include "ZipPlatform.h"
#include "ZipException.h"
using namespace ZipPlatform;
bool ZipPlatform::DirectoryExists(LPCTSTR lpszDir)
{
CZipString sz;
if (!GetCurrentDirectory(sz))
return false;
if (!ChangeDirectory(lpszDir))
return false;
ChangeDirectory(sz);
return true;
}
bool ZipPlatform::ForceDirectory(LPCTSTR lpDirectory)
{
ASSERT(lpDirectory);
CZipString szDirectory = lpDirectory;
szDirectory.TrimRight(CZipPathComponent::m_cSeparator);
CZipPathComponent zpc(szDirectory);
if ((zpc.GetFilePath().Compare((LPCTSTR)szDirectory)) == 0 ||
(FileExists(szDirectory) == -1))
return true;
if (!ForceDirectory(zpc.GetFilePath()))
return false;
if (!CreateDirectory(szDirectory))
return false;
return true;
}
bool ZipPlatform::GetFileSize(LPCTSTR lpszFileName, ZIP_SIZE_TYPE& dSize)
{
CZipFile f;
if (!f.Open(lpszFileName, CZipFile::modeRead | CZipFile::shareDenyWrite, false))
return false;
bool ret;
try
{
ZIP_FILE_USIZE size = f.GetLength();
// the file may be too large if zip64 is not enabled
ret = size <= ZIP_SIZE_TYPE(-1);
if (ret)
dSize = (ZIP_SIZE_TYPE)size;
}
#ifdef ZIP_ARCHIVE_MFC
catch(CZipBaseException* e)
{
e->Delete();
ret = false;
}
#else
catch(CZipBaseException e)
{
ret = false;
}
#endif
try
{
f.Close();
}
#ifdef ZIP_ARCHIVE_MFC
catch(CZipBaseException* e)
{
e->Delete();
}
#else
catch(CZipBaseException e)
{
}
#endif
return ret;
}

269
harbour/contrib/hbziparch/ZipPlatform_lnx.cpp
View File

@@ -1,269 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_platform.h"
#ifdef ZIP_ARCHIVE_LNX
#if defined __APPLE__ || defined __CYGWIN__
#define FILE_FUNCTIONS_64B_BY_DEFAULT
#else
#undef FILE_FUNCTIONS_64B_BY_DEFAULT
#endif
#include "stdafx.h"
#include "ZipPlatform.h"
#include "ZipFileHeader.h"
#include "ZipException.h"
#include "ZipAutoBuffer.h"
#include <utime.h>
#include "ZipPathComponent.h"
#include "ZipCompatibility.h"
#include <sys/types.h>
#if defined (__FreeBSD__) || defined (__APPLE__)
#include <sys/param.h>
#include <sys/mount.h>
#else
#include <sys/vfs.h>
#endif
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
const TCHAR CZipPathComponent::m_cSeparator = _T('/');
#ifndef _UTIMBUF_DEFINED
#define _utimbuf utimbuf
#endif
#define ZIP_DEFAULT_DIR_ATTRIBUTES (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
ULONGLONG ZipPlatform::GetDeviceFreeSpace(LPCTSTR lpszPath)
{
struct statfs sStats;
#if defined (__SVR4) && defined (__sun)
if (statvfs(lpszPath, &sStats) == -1) // Solaris
#else
if (statfs(lpszPath, &sStats) == -1)
#endif
return 0;
return sStats.f_bsize * sStats.f_bavail;
}
CZipString ZipPlatform::GetTmpFileName(LPCTSTR lpszPath, ZIP_SIZE_TYPE uSizeNeeded)
{
TCHAR empty[] = _T(""), prefix [] = _T("zar");
CZipString tempPath = lpszPath;
if (tempPath.IsEmpty())
tempPath = "/tmp";
if (ZipPlatform::GetDeviceFreeSpace(tempPath) < uSizeNeeded)
return empty;
CZipPathComponent::AppendSeparator(tempPath);
tempPath += prefix;
tempPath += _T("XXXXXX");
int handle = mkstemp(tempPath.GetBuffer(tempPath.GetLength()));
tempPath.ReleaseBuffer();
if (handle != -1)
{
close(handle); // we just create the file and open it later
return tempPath;
}
else
return empty;
}
bool ZipPlatform::GetCurrentDirectory(CZipString& sz)
{
char* pBuf = getcwd(NULL, 0);
if (!pBuf)
return false;
sz = pBuf;
free(pBuf);
return true;
}
bool ZipPlatform::SetFileAttr(LPCTSTR lpFileName, DWORD uAttr)
{
return chmod(lpFileName, uAttr) == 0;
}
bool ZipPlatform::GetFileAttr(LPCTSTR lpFileName, DWORD& uAttr)
{
struct stat sStats;
if (stat(lpFileName, &sStats) == -1)
return false;
uAttr = (sStats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_IFMT));
return true;
}
bool ZipPlatform::SetExeAttr(LPCTSTR lpFileName)
{
DWORD uAttr;
if (!GetFileAttr(lpFileName, uAttr))
return false;
uAttr |= S_IXUSR;
return ZipPlatform::SetFileAttr(lpFileName, uAttr);
}
bool ZipPlatform::GetFileModTime(LPCTSTR lpFileName, time_t & ttime)
{
struct stat st;
if (stat(lpFileName, &st) != 0)
return false;
ttime = st.st_mtime;
if (ttime == (time_t)-1)
{
ttime = time(NULL);
return false;
}
else
return true;
}
bool ZipPlatform::SetFileModTime(LPCTSTR lpFileName, time_t ttime)
{
struct utimbuf ub;
ub.actime = time(NULL);
ub.modtime = ttime == -1 ? time(NULL) : ttime; // if wrong file time, set it to the current
return utime(lpFileName, &ub) == 0;
}
bool ZipPlatform::ChangeDirectory(LPCTSTR lpDirectory)
{
return chdir(lpDirectory) == 0;
}
int ZipPlatform::FileExists(LPCTSTR lpszName)
{
struct stat st;
if (stat(lpszName, &st) != 0)
return 0;
else
{
if (S_ISDIR(st.st_mode))
return -1;
else
return 1;
}
}
ZIPINLINE bool ZipPlatform::IsDriveRemovable(LPCTSTR lpszFilePath)
{
// not implemmented
return true;
}
ZIPINLINE bool ZipPlatform::SetVolLabel(LPCTSTR lpszPath, LPCTSTR lpszLabel)
{
// not implemmented
return true;
}
ZIPINLINE void ZipPlatform::AnsiOem(CZipAutoBuffer& buffer, bool bAnsiToOem)
{
// not implemmented
}
ZIPINLINE bool ZipPlatform::RemoveFile(LPCTSTR lpszFileName, bool bThrow)
{
if (unlink(lpszFileName) != 0)
if (bThrow)
CZipException::Throw(CZipException::notRemoved, lpszFileName);
else
return false;
return true;
}
ZIPINLINE bool ZipPlatform::RenameFile( LPCTSTR lpszOldName, LPCTSTR lpszNewName , bool bThrow)
{
if (rename(lpszOldName, lpszNewName) != 0)
if (bThrow)
CZipException::Throw(CZipException::notRenamed, lpszOldName);
else
return false;
return true;
}
ZIPINLINE bool ZipPlatform::IsDirectory(DWORD uAttr)
{
return S_ISDIR(uAttr) != 0;
}
ZIPINLINE bool ZipPlatform::CreateDirectory(LPCTSTR lpDirectory)
{
return mkdir(lpDirectory, ZIP_DEFAULT_DIR_ATTRIBUTES) == 0;
}
ZIPINLINE DWORD ZipPlatform::GetDefaultAttributes()
{
return S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
}
ZIPINLINE DWORD ZipPlatform::GetDefaultDirAttributes()
{
return S_IFDIR | ZIP_DEFAULT_DIR_ATTRIBUTES;
}
ZIPINLINE int ZipPlatform::GetSystemID()
{
return ZipCompatibility::zcUnix;
}
ZIPINLINE bool ZipPlatform::GetSystemCaseSensitivity()
{
return true;
}
bool ZipPlatform::TruncateFile(int iDes, ULONGLONG uSize)
{
return ftruncate(iDes, uSize) == 0;
}
int ZipPlatform::OpenFile(LPCTSTR lpszFileName, UINT iMode, int iShareMode)
{
return open(lpszFileName, iMode, S_IRUSR | S_IWUSR | S_IRGRP |S_IROTH );
}
bool ZipPlatform::FlushFile(int iDes)
{
return fsync(iDes) == 0;
}
intptr_t ZipPlatform::GetFileSystemHandle(int iDes)
{
return iDes;
}
#endif // ZIP_ARCHIVE_LNX

434
harbour/contrib/hbziparch/ZipPlatform_win.cpp
View File

@@ -1,434 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "_platform.h"
#ifdef ZIP_ARCHIVE_WIN
#define ZIP_USES_SAFE_WINDOWS_API
#include "stdafx.h"
#include "ZipPlatform.h"
#include "ZipFileHeader.h"
#include "ZipException.h"
#include "ZipAutoBuffer.h"
#include <sys/stat.h>
#ifndef __BORLANDC__
#include <sys/utime.h>
#else
#ifndef _UTIMBUF_DEFINED
#define _utimbuf utimbuf
#define _UTIMBUF_DEFINED
#endif
#include <utime.h>
#endif
#ifndef INVALID_FILE_ATTRIBUTES
#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
#endif
#include <direct.h>
#include <io.h>
#include <time.h>
#include "ZipPathComponent.h"
#include "ZipCompatibility.h"
const TCHAR CZipPathComponent::m_cSeparator = _T('\\');
ULONGLONG ZipPlatform::GetDeviceFreeSpace(LPCTSTR lpszPath)
{
ULONGLONG uFreeBytesToCaller = 0, uTotalBytes = 0, uFreeBytes = 0;
CZipPathComponent zpc (lpszPath);
CZipString szDrive = zpc.GetFileDrive();
if (!GetDiskFreeSpaceEx(
szDrive,
(PULARGE_INTEGER)&uFreeBytesToCaller,
(PULARGE_INTEGER)&uTotalBytes,
(PULARGE_INTEGER)&uFreeBytes))
{
CZipPathComponent::AppendSeparator(szDrive); // in spite of what is written in MSDN it is sometimes needed (on fixed disks)
if (!GetDiskFreeSpaceEx(
szDrive,
(PULARGE_INTEGER)&uFreeBytesToCaller,
(PULARGE_INTEGER)&uTotalBytes,
(PULARGE_INTEGER)&uFreeBytes))
return 0;
}
return uFreeBytes;
}
CZipString ZipPlatform::GetTmpFileName(LPCTSTR lpszPath, ZIP_SIZE_TYPE uSizeNeeded)
{
TCHAR empty[] = _T("");
CZipString tempPath;
bool bCheckTemp = true;
if (lpszPath)
{
tempPath = lpszPath;
bCheckTemp = GetDeviceFreeSpace(tempPath) < uSizeNeeded;
}
if (bCheckTemp)
{
DWORD size = GetTempPath(0, empty);
if (size == 0)
return (CZipString)empty;
GetTempPath(size, tempPath.GetBuffer(size));
tempPath.ReleaseBuffer();
if (GetDeviceFreeSpace(tempPath) < uSizeNeeded)
{
if (!GetCurrentDirectory(tempPath) || GetDeviceFreeSpace(tempPath) < uSizeNeeded)
return (CZipString)empty;
}
}
CZipString tempName;
if (!GetTempFileName(tempPath, _T("ZAR"), 0, tempName.GetBuffer(_MAX_PATH)))
return (CZipString)empty;
tempName.ReleaseBuffer();
return tempName;
}
bool ZipPlatform::GetCurrentDirectory(CZipString& sz)
{
DWORD i = ::GetCurrentDirectory(0, NULL);
if (!i)
return false;
TCHAR* pBuf = new TCHAR[i];
bool b = true;
if (!::GetCurrentDirectory(i, pBuf))
b = false;
else
sz = pBuf;
delete[] pBuf;
return b;
}
bool ZipPlatform::SetFileAttr(LPCTSTR lpFileName, DWORD uAttr)
{
return ::SetFileAttributes(lpFileName, uAttr) != 0;
}
bool ZipPlatform::GetFileAttr(LPCTSTR lpFileName, DWORD& uAttr)
{
// not using MFC due to MFC bug (attr is one byte there)
DWORD temp = ::GetFileAttributes(lpFileName);
if (temp == INVALID_FILE_ATTRIBUTES)
return false;
uAttr = temp;
return true;
}
bool ZipPlatform::GetFileModTime(LPCTSTR lpFileName, time_t & ttime)
{
#ifndef __BORLANDC__
struct _stat st;
if (_tstat(lpFileName, &st) != 0)
#else
struct stat st;
if (stat(lpFileName, &st) != 0)
#endif
return false;
ttime = st.st_mtime;
if (ttime == (time_t)-1)
{
ttime = time(NULL);
return false;
}
else
return true;
}
bool ZipPlatform::SetFileModTime(LPCTSTR lpFileName, time_t ttime)
{
struct _utimbuf ub;
ub.actime = time(NULL);
ub.modtime = ttime == -1 ? time(NULL) : ttime; // if wrong file time, set it to the current
return _tutime(lpFileName, &ub) == 0;
}
bool ZipPlatform::ChangeDirectory(LPCTSTR lpDirectory)
{
return _tchdir(lpDirectory) == 0; // returns 0 if ok
}
int ZipPlatform::FileExists(LPCTSTR lpszName)
{
#ifndef __BORLANDC__
#if _MSC_VER >= 1400
if (_taccess_s(lpszName, 0) == 0)
#else
if (_taccess(lpszName, 0) == 0)
#endif
#else
#ifdef _UNICODE
if (_waccess(lpszName, 0) == 0)
#else
if (access(lpszName, 0) == 0)
#endif
#endif
{
if (DirectoryExists(lpszName))
return -1;
return 1;
}
else
return 0;
}
ZIPINLINE bool ZipPlatform::IsDriveRemovable(LPCTSTR lpszFilePath)
{
CZipPathComponent zpc(lpszFilePath);
return ::GetDriveType(zpc.GetFileDrive()) == DRIVE_REMOVABLE;
}
ZIPINLINE bool ZipPlatform::SetVolLabel(LPCTSTR lpszPath, LPCTSTR lpszLabel)
{
CZipPathComponent zpc(lpszPath);
CZipString szDrive = zpc.GetFileDrive();
CZipPathComponent::AppendSeparator(szDrive);
return ::SetVolumeLabel(szDrive, lpszLabel) != 0;
}
ZIPINLINE void ZipPlatform::AnsiOem(CZipAutoBuffer& buffer, bool bAnsiToOem)
{
#ifdef ZIP_USES_SAFE_WINDOWS_API
UINT cpIn, cpOut;
if (bAnsiToOem)
{
cpIn = CP_ACP;
cpOut = CP_OEMCP;
}
else
{
cpIn = CP_OEMCP;
cpOut = CP_ACP;
}
CZipAutoBuffer interBuffer;
int size = buffer.GetSize();
// iLen doesn't include terminating character
int iLen = MultiByteToWideChar(cpIn, MB_PRECOMPOSED, buffer, size, NULL, 0);
if (iLen <= 0)
return;
interBuffer.Allocate(iLen * sizeof(wchar_t));
LPWSTR lpszWide = (LPWSTR)(char*)interBuffer;
iLen = MultiByteToWideChar(cpIn, MB_PRECOMPOSED, buffer, size, lpszWide, iLen);
ASSERT(iLen != 0);
// iLen does not include terminating character
size = WideCharToMultiByte(cpOut, 0, lpszWide, iLen, NULL, 0, NULL, NULL);
if (size <= 0)
return;
buffer.Allocate(size);
size = WideCharToMultiByte(cpOut, 0, lpszWide, iLen, buffer, size, NULL, NULL);
ASSERT(size != 0);
#else
if (bAnsiToOem)
CharToOemBuffA(buffer, buffer, buffer.GetSize());
else
OemToCharBuffA(buffer, buffer, buffer.GetSize());
#endif
}
ZIPINLINE bool ZipPlatform::RemoveFile(LPCTSTR lpszFileName, bool bThrow)
{
if (!::DeleteFile((LPTSTR)lpszFileName))
if (bThrow)
CZipException::Throw(CZipException::notRemoved, lpszFileName);
else
return false;
return true;
}
ZIPINLINE bool ZipPlatform::RenameFile( LPCTSTR lpszOldName, LPCTSTR lpszNewName, bool bThrow)
{
if (!::MoveFile((LPTSTR)lpszOldName, (LPTSTR)lpszNewName))
if (bThrow)
CZipException::Throw(CZipException::notRenamed, lpszOldName);
else
return false;
return true;
}
ZIPINLINE bool ZipPlatform::IsDirectory(DWORD uAttr)
{
return (uAttr & FILE_ATTRIBUTE_DIRECTORY) != 0;
}
ZIPINLINE bool ZipPlatform::CreateDirectory(LPCTSTR lpDirectory)
{
return ::CreateDirectory(lpDirectory, NULL) != 0;
}
ZIPINLINE DWORD ZipPlatform::GetDefaultAttributes()
{
return FILE_ATTRIBUTE_ARCHIVE;
}
ZIPINLINE DWORD ZipPlatform::GetDefaultDirAttributes()
{
return FILE_ATTRIBUTE_DIRECTORY;
}
ZIPINLINE int ZipPlatform::GetSystemID()
{
return ZipCompatibility::zcDosFat;
}
ZIPINLINE bool ZipPlatform::GetSystemCaseSensitivity()
{
return false;
}
#ifdef _UNICODE
int ZipPlatform::WideToMultiByte(LPCWSTR lpszIn, CZipAutoBuffer &szOut, UINT uCodePage)
{
size_t wideLen = wcslen(lpszIn);
if (wideLen == 0)
{
szOut.Release();
return 0;
}
// iLen does not include terminating character
int iLen = WideCharToMultiByte(uCodePage, 0, lpszIn, (int)wideLen, szOut,
0, NULL, NULL);
if (iLen > 0)
{
szOut.Allocate(iLen, true);
iLen = WideCharToMultiByte(uCodePage, 0, lpszIn , (int)wideLen, szOut,
iLen, NULL, NULL);
ASSERT(iLen != 0);
}
else // here it means error
{
szOut.Release();
iLen --;
}
return iLen;
}
int ZipPlatform::MultiByteToWide(const CZipAutoBuffer &szIn, CZipString& szOut, UINT uCodePage)
{
int singleLen = szIn.GetSize();
// iLen doesn't include terminating character
DWORD dwFlags = uCodePage <= CP_OEMCP ? MB_PRECOMPOSED : 0;
int iLen = MultiByteToWideChar(uCodePage, dwFlags, szIn.GetBuffer(), singleLen, NULL, 0);
if (iLen > 0)
{
iLen = MultiByteToWideChar(uCodePage, dwFlags, szIn.GetBuffer(), singleLen,
szOut.GetBuffer(iLen) , iLen);
szOut.ReleaseBuffer(iLen);
ASSERT(iLen != 0);
}
else
{
szOut.Empty();
iLen --; // return -1
}
return iLen;
}
#endif
#if defined ZIP_ARCHIVE_STL || defined ZIP_FILE_USES_STL
#if _MSC_VER > 1000
#pragma warning( push )
#pragma warning (disable : 4702) // unreachable code
#endif
#include <io.h>
#include <share.h>
bool ZipPlatform::TruncateFile(int iDes, ULONGLONG uSize)
{
#if (_MSC_VER >= 1400)
return _chsize_s(iDes, uSize) == 0;
#else
if (uSize <= LONG_MAX)
return chsize(iDes, (LONG)uSize) == 0;
else if (uSize > _I64_MAX)
CZipException::Throw(CZipException::tooBigSize);
else
{
HANDLE handle = (HANDLE)GetFileSystemHandle(iDes);
ULARGE_INTEGER li;
li.QuadPart = uSize;
li.LowPart = SetFilePointer(handle, li.LowPart, (LONG*)&li.HighPart, FILE_BEGIN);
if (li.LowPart == UINT_MAX && GetLastError() != NO_ERROR)
return false;
return SetEndOfFile(handle) != 0;
}
return false; // for the compiler
#endif
}
#if _MSC_VER > 1000
#pragma warning( pop )
#endif
int ZipPlatform::OpenFile(LPCTSTR lpszFileName, UINT iMode, int iShareMode)
{
switch (iShareMode)
{
case (CZipFile::shareDenyWrite & CZipFile::shareDenyRead):
iShareMode = SH_DENYRW;
break;
case (CZipFile::shareDenyRead):
iShareMode = SH_DENYRD;
break;
case (CZipFile::shareDenyWrite):
iShareMode = SH_DENYWR;
break;
default:
iShareMode = SH_DENYNO;
}
#if _MSC_VER >= 1400
int handle;
if (_tsopen_s(&handle, lpszFileName, iMode, iShareMode, S_IREAD | S_IWRITE /*required only when O_CREAT mode*/) != 0)
return -1;
else
return handle;
#else
return _tsopen(lpszFileName, iMode, iShareMode, S_IREAD | S_IWRITE /*required only when O_CREAT mode*/);
#endif
}
bool ZipPlatform::FlushFile(int iDes)
{
return _commit(iDes) == 0;
}
intptr_t ZipPlatform::GetFileSystemHandle(int iDes)
{
return _get_osfhandle(iDes);
}
#endif // ZIP_ARCHIVE_STL
#endif // ZIP_ARCHIVE_WIN

615
harbour/contrib/hbziparch/ZipStorage.cpp
View File

@@ -1,615 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipStorage.h"
#include "ZipArchive.h"
#include "ZipPlatform.h"
char CZipStorage::m_gszExtHeaderSignat[] = {0x50, 0x4b, 0x07, 0x08};
const ZIP_FILE_USIZE CZipStorage::SignatureNotFound = ZIP_FILE_USIZE(-1);
CZipStorage::CZipStorage()
{
Initialize();
}
void CZipStorage::Initialize()
{
m_pSplitChangeVolumeFunc = m_pSpanChangeVolumeFunc = m_pChangeVolumeFunc = NULL;
m_iWriteBufferSize = 65536;
m_pFile = NULL;
m_szSplitExtension = _T("zip");
m_iLocateBufferSize = 32768;
m_uBytesBeforeZip = 0;
m_uCurrentVolume = ZIP_VOLUME_NUMBER_UNSPECIFIED;
m_szArchiveName.Empty();
}
CZipStorage::~CZipStorage()
{
}
DWORD CZipStorage::Read(void *pBuf, DWORD iSize, bool bAtOnce)
{
if (iSize == 0)
return 0;
DWORD iRead;
for(;;)
{
iRead = m_pFile->Read(pBuf, iSize);
if (!iRead)
{
if (IsSegmented())
ChangeVolume();
else
ThrowError(CZipException::badZipFile);
}
else
break;
}
if (iRead == iSize)
return iRead;
else if (bAtOnce || !IsSegmented())
ThrowError(CZipException::badZipFile);
while (iRead < iSize)
{
ChangeVolume();
UINT iNewRead = m_pFile->Read((char*)pBuf + iRead, iSize - iRead);
if (!iNewRead && iRead < iSize)
ThrowError(CZipException::badZipFile);
iRead += iNewRead;
}
return iRead;
}
void CZipStorage::Open(LPCTSTR lpszPathName, int iMode, ZIP_SIZE_TYPE uVolumeSize)
{
m_uCurrentVolume = ZIP_VOLUME_NUMBER_UNSPECIFIED;
m_pWriteBuffer.Allocate(m_iWriteBufferSize);
m_uBytesInWriteBuffer = 0;
m_bNewSegm = false;
m_pFile = &m_internalfile;
m_bInMemory = false;
m_szArchiveName = lpszPathName;
m_pChangeVolumeFunc = NULL;
if (iMode == CZipArchive::zipCreate || iMode == CZipArchive::zipCreateSegm
|| iMode == CZipArchive::zipCreateAppend) // create new archive
{
m_bReadOnly = false;
m_uCurrentVolume = 0;
if (iMode == CZipArchive::zipCreate || iMode == CZipArchive::zipCreateAppend)
{
m_iSegmMode = noSegments;
OpenFile(lpszPathName, (iMode == CZipArchive::zipCreate ? CZipFile::modeCreate : CZipFile::modeNoTruncate) | CZipFile::modeReadWrite);
}
else // create a segmented archive
{
m_bNewSegm = true;
m_uBytesWritten = 0;
if (uVolumeSize == ZIP_AUTODETECT_VOLUME_SIZE) // spanned archive
{
if (!m_pSpanChangeVolumeFunc)
ThrowError(CZipException::noCallback);
if (!ZipPlatform::IsDriveRemovable(lpszPathName))
ThrowError(CZipException::nonRemovable);
m_iSegmMode = spannedArchive;
m_pChangeVolumeFunc = m_pSpanChangeVolumeFunc;
}
else
{
m_uSplitData = uVolumeSize;
m_iSegmMode = splitArchive;
m_pChangeVolumeFunc = m_pSplitChangeVolumeFunc;
}
NextVolume(4);
Write(m_gszExtHeaderSignat, 4, true);
}
}
else // open existing
{
m_bReadOnly = iMode == CZipArchive::zipOpenReadOnly;
OpenFile(lpszPathName, CZipFile::modeNoTruncate |
(m_bReadOnly ? CZipFile::modeRead : CZipFile::modeReadWrite));
// m_uData and m_iSegmMode are automatically set during reading the central dir
m_iSegmMode = uVolumeSize == 0 ? suggestedAuto : suggestedSplit;
}
}
void CZipStorage::Open(CZipAbstractFile& af, int iMode)
{
m_pWriteBuffer.Allocate(m_iWriteBufferSize);
m_uBytesInWriteBuffer = 0;
m_bNewSegm = false;
m_pFile = &af;
m_bInMemory = true;
if (iMode == CZipArchive::zipCreate || iMode == CZipArchive::zipCreateAppend)
{
m_uCurrentVolume = 0;
m_iSegmMode = noSegments;
if (iMode == CZipArchive::zipCreate)
af.SetLength(0);
else
af.SeekToEnd();
}
else // open existing
{
af.SeekToBegin();
m_iSegmMode = suggestedAuto;
}
}
void CZipStorage::ChangeVolume(ZIP_VOLUME_TYPE uNumber)
{
if (uNumber == m_uCurrentVolume || m_iSegmMode == noSegments) // the second condition may happen in some bad archives
return;
m_uCurrentVolume = uNumber;
OpenFile(IsSpanned() ? ChangeSpannedRead() : ChangeSplitRead(),
CZipFile::modeNoTruncate | CZipFile::modeRead);
}
void CZipStorage::ThrowError(int err)
{
CZipException::Throw(err, m_pFile->GetFilePath());
}
bool CZipStorage::OpenFile(LPCTSTR lpszName, UINT uFlags, bool bThrow)
{
return m_pFile->Open(lpszName, uFlags | CZipFile::shareDenyWrite, bThrow);
}
CZipString CZipStorage::ChangeSpannedRead()
{
CZipString szTemp = m_pFile->GetFilePath();
m_pFile->Close();
CallCallback(0, CZipSegmCallback::scVolumeNeededForRead, szTemp);
return szTemp;
}
CZipString CZipStorage::ChangeSplitRead()
{
bool lastPart = (ZIP_SIZE_TYPE)m_uCurrentVolume == m_uSplitData;
CZipString szTemp = GetSplitVolumeName(lastPart);
if (m_pChangeVolumeFunc)
{
int iCode = CZipSegmCallback::scVolumeNeededForRead;
for(;;)
{
CallCallback(lastPart ? ZIP_SPLIT_LAST_VOLUME : 0, iCode, szTemp);
if (ZipPlatform::FileExists(m_pChangeVolumeFunc->m_szExternalFile))
{
szTemp = m_pChangeVolumeFunc->m_szExternalFile;
break;
}
else
iCode = CZipSegmCallback::scFileNotFound;
}
}
m_pFile->Close();
return szTemp;
}
CZipString CZipStorage::RenameLastFileInSplitArchive()
{
ASSERT(IsSplit());
// give to the last volume the zip extension
CZipString szFileName = m_pFile->GetFilePath();
CZipString szNewFileName = GetSplitVolumeName(true);
if (m_pChangeVolumeFunc)
{
int code = CZipSegmCallback::scVolumeNeededForWrite;
for(;;)
{
CallCallback(ZIP_SPLIT_LAST_VOLUME, code, szNewFileName);
szNewFileName = m_pChangeVolumeFunc->m_szExternalFile;
if (ZipPlatform::FileExists(szNewFileName))
code = CZipSegmCallback::scFileNameDuplicated;
else
break;
}
}
if (!m_bInMemory)
{
m_pFile->Flush();
m_pFile->Close();
}
if (!m_pChangeVolumeFunc && ZipPlatform::FileExists(szNewFileName))
ZipPlatform::RemoveFile(szNewFileName);
ZipPlatform::RenameFile(szFileName, szNewFileName);
return szNewFileName;
}
CZipString CZipStorage::Close(bool bAfterException)
{
bool bClose = true;
CZipString sz;
if (!bAfterException)
{
Flush();
if (IsSplit() && m_bNewSegm)
{
sz = RenameLastFileInSplitArchive();
bClose = false;// already closed in RenameLastFileInSplitArchive
}
}
if (sz.IsEmpty())
sz = m_pFile->GetFilePath();
if (bClose && !m_bInMemory)
{
if (!bAfterException)
FlushFile();
m_pFile->Close();
}
m_pWriteBuffer.Release();
m_uCurrentVolume = ZIP_VOLUME_NUMBER_UNSPECIFIED;
m_iSegmMode = noSegments;
m_pFile = NULL;
m_uBytesBeforeZip = 0;
return sz;
}
CZipString CZipStorage::GetSplitVolumeName(bool bLast) const
{
CZipString szFilePath = m_szArchiveName;
CZipPathComponent zpc(szFilePath);
CZipString szExt;
if (bLast)
szExt = m_szSplitExtension;
else
{
DWORD vol = m_uCurrentVolume + 1;
if (vol < 100)
szExt.Format(_T("z%.2u"), vol);
else
szExt.Format(_T("z%u"), vol);
}
zpc.SetExtension(szExt);
return zpc.GetFullPath();
}
void CZipStorage::NextVolume(ZIP_SIZE_TYPE uNeeded)
{
Flush();
ASSERT(m_iSegmMode != noSegments);
bool bSpan = IsSpanned();
if (m_uBytesWritten)
{
m_uBytesWritten = 0;
m_uCurrentVolume++;
ZIP_VOLUME_TYPE uMaxVolumes = (ZIP_VOLUME_TYPE)(bSpan ? 999 : 0xFFFF);
if (m_uCurrentVolume >= uMaxVolumes) // m_uCurrentVolume is a zero-based index
ThrowError(CZipException::tooManyVolumes);
}
CZipString szFileName;
if (bSpan)
szFileName = m_szArchiveName;
else
szFileName = GetSplitVolumeName(false);
if (!m_pFile->IsClosed())
{
m_pFile->Flush();
m_pFile->Close();
}
if (m_pChangeVolumeFunc)
{
int iCode = CZipSegmCallback::scVolumeNeededForWrite;
for(;;)
{
CallCallback(uNeeded, iCode, szFileName);
if (!bSpan)
// allow the user to change the filename
szFileName = m_pChangeVolumeFunc->m_szExternalFile;
if (ZipPlatform::FileExists(szFileName))
iCode = CZipSegmCallback::scFileNameDuplicated;
else
{
if (bSpan)
{
CZipString label;
label.Format(_T("pkback# %.3d"), m_uCurrentVolume + 1);
if (!ZipPlatform::SetVolLabel(szFileName, label))
{
iCode = CZipSegmCallback::scCannotSetVolLabel;
continue;
}
}
if (OpenFile(szFileName, CZipFile::modeCreate | CZipFile::modeReadWrite, false))
break;
else
iCode = CZipSegmCallback::scFileCreationFailure;
}
}
m_uCurrentVolSize = bSpan ? GetFreeVolumeSpace() : m_uSplitData;
}
else
{
if (bSpan)
ThrowError(CZipException::internalError);
m_uCurrentVolSize = m_uSplitData;
OpenFile(szFileName, CZipFile::modeCreate | CZipFile::modeReadWrite);
}
}
void CZipStorage::CallCallback(ZIP_SIZE_TYPE uNeeded, int iCode, CZipString szTemp)
{
if (!m_pChangeVolumeFunc)
ThrowError(CZipException::internalError);
m_pChangeVolumeFunc->m_szExternalFile = szTemp;
m_pChangeVolumeFunc->m_uVolumeNeeded = (ZIP_VOLUME_TYPE)(m_uCurrentVolume + 1);
m_pChangeVolumeFunc->m_iCode = iCode;
if (!m_pChangeVolumeFunc->Callback(uNeeded))
CZipException::Throw(CZipException::aborted, szTemp);
}
ZIP_SIZE_TYPE CZipStorage::GetFreeVolumeSpace() const
{
ASSERT (IsSpanned());
CZipString szTemp = m_pFile->GetFilePath();
if (szTemp.IsEmpty()) // called once when creating a segmented archive
return 0;
else
{
CZipPathComponent zpc(szTemp);
ULONGLONG ret = ZipPlatform::GetDeviceFreeSpace(zpc.GetFilePath());
if (ret > (ZIP_SIZE_TYPE)(-1))
return (ZIP_SIZE_TYPE)(-1);
else
return (ZIP_SIZE_TYPE)ret;
}
}
void CZipStorage::UpdateSegmMode(ZIP_VOLUME_TYPE uLastDisk)
{
m_uCurrentVolume = uLastDisk;
if (uLastDisk)
{
// segmentation detected
CZipString szFilePath = m_pFile->GetFilePath();
if (m_iSegmMode == suggestedAuto)
m_iSegmMode = ZipPlatform::IsDriveRemovable(szFilePath) ?
spannedArchive : splitArchive;
else
{
ASSERT(m_iSegmMode == suggestedSplit);
m_iSegmMode = splitArchive;
}
if (IsSpanned())
{
if (!m_pSpanChangeVolumeFunc)
ThrowError(CZipException::noCallback);
m_pChangeVolumeFunc = m_pSpanChangeVolumeFunc;
}
else /*if (IsSplit())*/
{
m_uSplitData = uLastDisk; // volume with .zip extension ( the last one)
m_pChangeVolumeFunc = m_pSplitChangeVolumeFunc;
}
CZipPathComponent zpc(szFilePath);
m_szSplitExtension = zpc.GetFileExt();
m_pWriteBuffer.Release(); // no need for this in this case
}
else
m_iSegmMode = noSegments;
}
ZIP_SIZE_TYPE CZipStorage::AssureFree(ZIP_SIZE_TYPE uNeeded)
{
ZIP_SIZE_TYPE uFree;
while ((uFree = VolumeLeft()) < uNeeded)
{
if (IsSplit() && !m_uBytesWritten && !m_uBytesInWriteBuffer)
// in the splitArchive mode, if the size of the archive is less
// than the size of the packet to be written at once,
// increase once the size of the volume
m_uCurrentVolSize = uNeeded;
else
NextVolume(uNeeded);
}
return uFree;
}
void CZipStorage::Write(const void *pBuf, DWORD iSize, bool bAtOnce)
{
if (!IsSegmented())
WriteInternalBuffer((char*)pBuf, iSize);
else
{
// if not at once, one byte is enough free space
DWORD iNeeded = bAtOnce ? iSize : 1;
DWORD uTotal = 0;
while (uTotal < iSize)
{
ZIP_SIZE_TYPE uFree = AssureFree(iNeeded);
DWORD uLeftToWrite = iSize - uTotal;
DWORD uToWrite = uFree < uLeftToWrite ? (DWORD)uFree : uLeftToWrite;
WriteInternalBuffer((char*)pBuf + uTotal, uToWrite);
if (bAtOnce)
return;
else
uTotal += uToWrite;
}
}
}
void CZipStorage::WriteInternalBuffer(const char *pBuf, DWORD uSize)
{
DWORD uWritten = 0;
while (uWritten < uSize)
{
DWORD uFreeInBuffer = GetFreeInBuffer();
if (uFreeInBuffer == 0)
{
Flush();
uFreeInBuffer = m_pWriteBuffer.GetSize();
}
DWORD uLeftToWrite = uSize - uWritten;
DWORD uToCopy = uLeftToWrite < uFreeInBuffer ? uLeftToWrite : uFreeInBuffer;
memcpy((char*)m_pWriteBuffer + m_uBytesInWriteBuffer, pBuf + uWritten, uToCopy);
uWritten += uToCopy;
m_uBytesInWriteBuffer += uToCopy;
}
}
ZIP_SIZE_TYPE CZipStorage::VolumeLeft() const
{
// for spanned archives m_uCurrentVolSize is updated after each flush()
ZIP_SIZE_TYPE uBytes = m_uBytesInWriteBuffer + (IsSpanned() ? 0 : m_uBytesWritten);
return uBytes > m_uCurrentVolSize ? 0 : m_uCurrentVolSize - uBytes;
}
void CZipStorage::Flush()
{
if (m_uBytesInWriteBuffer)
{
m_pFile->Write(m_pWriteBuffer, m_uBytesInWriteBuffer);
if (m_iSegmMode != noSegments)
m_uBytesWritten += m_uBytesInWriteBuffer;
m_uBytesInWriteBuffer = 0;
}
if (IsSpanned())
// after writing it is difficult to predict the free space due to
// not completly written clusters, write operation may start from a new cluster
m_uCurrentVolSize = GetFreeVolumeSpace();
}
ZIP_FILE_USIZE CZipStorage::LocateSignature(char* szSignature, ZIP_SIZE_TYPE uMaxDepth)
{
const int recordSize = 4;
CZipAutoBuffer buffer(m_iLocateBufferSize);
ZIP_FILE_USIZE uFileLength = m_pFile->GetLength();
ZIP_SIZE_TYPE max = (ZIP_SIZE_TYPE)(uFileLength < uMaxDepth ? uFileLength : uMaxDepth);
ZIP_SIZE_TYPE position = (ZIP_SIZE_TYPE)(uFileLength - m_pFile->GetPosition());
int offset = 0;
int leftToFind = recordSize - 1;
int toRead = m_iLocateBufferSize;
bool found = false; // for fast checking if leftToFind needs resetting
while ( position < max )
{
position += toRead;
if ( position > max )
{
int diff = (int) ( position - max );
toRead -= diff;
offset = diff;
position = max;
}
Seek(position, seekFromEnd);
int actuallyRead = m_pFile->Read((char*)buffer + offset, toRead);
if (actuallyRead != toRead)
ThrowError(CZipException::badZipFile);
int pos = m_iLocateBufferSize - 1;
while ( pos >= offset )
{
if ( buffer[pos] == szSignature[leftToFind] )
{
if ( leftToFind == 0 )
return (ZIP_FILE_USIZE)(uFileLength - ( position - ( pos - offset ) ));
if ( !found )
found = true;
leftToFind--;
pos--;
}
else if ( found )
{
leftToFind = recordSize - 1;
found = false;
// do not decrease position, the current pos may be the first to find
}
else
pos--;
}
}
return SignatureNotFound;
}
ULONGLONG CZipStorage::Seek(ULONGLONG lOff, SeekType iSeekType)
{
if (iSeekType == seekCurrent)
{
ZIP_SIZE_TYPE uPosition = (ZIP_SIZE_TYPE)m_pFile->GetPosition();
if (IsSegmented() == -1)
{
ZIP_FILE_USIZE uLength = m_pFile->GetLength();
while (uPosition + lOff >= uLength)
{
ZIP_SIZE_TYPE uCanSeek = (ZIP_SIZE_TYPE)(uLength - uPosition);
lOff -= uCanSeek;
ChangeVolume();
uPosition = 0;
uLength = m_pFile->GetLength();
}
return lOff > 0 ? m_pFile->Seek((ZIP_FILE_USIZE)lOff) : 0;
}
else
return m_pFile->Seek((ZIP_FILE_SIZE)lOff, CZipAbstractFile::current);
}
else
{
if (m_uCurrentVolume == 0 && m_uBytesBeforeZip > 0)
lOff += m_uBytesBeforeZip;
return m_pFile->Seek((ZIP_FILE_USIZE)lOff, iSeekType == seekFromBeginning);
}
}
void CZipStorage::FinalizeSegm()
{
ASSERT(IsSegmented() == 1); // spanned archive in creation
ASSERT(!m_bInMemory);
CZipString szFileName;
if (IsSplit() && m_bNewSegm)
szFileName = RenameLastFileInSplitArchive();
else
{
szFileName = m_pFile->GetFilePath();
// the file is already closed
m_pFile->Close();
}
m_bNewSegm = false;
if (m_uCurrentVolume == 0) // one-volume segmented archive was converted to normal archive
m_iSegmMode = noSegments;
else
m_uSplitData = m_uCurrentVolume;
OpenFile(szFileName, CZipFile::modeNoTruncate | (m_iSegmMode == noSegments ? CZipFile::modeReadWrite : CZipFile::modeRead));
}

619
harbour/contrib/hbziparch/ZipStorage.h
View File

@@ -1,619 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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"
/**
Represents the storage layer for an archive.
*/
class ZIP_API CZipStorage
{
friend class CZipArchive;
friend class CZipCentralDir;
public:
/**
The type of the segmentation of the archive.
\see
<a href="kb">0610051553</a>
\see
CZipArchive::GetSegmMode
*/
enum ZipSegmentationMode
{
noSegments, ///< No archive segmentation.
spannedArchive, ///< A spanned archive.
splitArchive, ///< A split archive.
/**
The archive segmentation type will be auto-detected.
If the archive is on the removable device,
assume a spanned archive, otherwise assume a split archive.
*/
suggestedAuto,
/**
If a segmented archive is on a removable device, assume a split archive.
Normally you create spanned archives on removable devices.
*/
suggestedSplit
};
/**
The direction of 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 an 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) method.
*/
void Open(CZipAbstractFile& af, int iMode);
/**
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 allowed).
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 volme the central directory is on.
\note Throws exceptions.
*/
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.
\note
Throws exceptions.
*/
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.
\note
Throws exceptions.
*/
void Write(const void *pBuf, DWORD iSize, bool bAtOnce);
/**
Gets 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 GetCurrentVolume() == ZIP_VOLUME_NUMBER_UNSPECIFIED;
else
return !m_pFile || !m_bInMemory && 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, the specified number of bytes must be read
from the same volume (no volume change is allowed).
\note
Throws exceptions.
*/
DWORD Read(void* pBuf, DWORD iSize, bool bAtOnce);
/**
Gets 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
Throws exceptions.
*/
ZIP_SIZE_TYPE GetPosition() const
{
ZIP_SIZE_TYPE uPos = (ZIP_SIZE_TYPE)(m_pFile->GetPosition()) + m_uBytesInWriteBuffer;
if (m_uCurrentVolume == 0)
uPos -= m_uBytesBeforeZip;
return uPos;
}
/**
Flushes the data from the read buffer to the disk.
\note
Throws exceptions.
*/
void Flush();
/**
Forces any data remaining in the file buffer to be written to the disk.
*/
void FlushFile()
{
if (!m_bInMemory && !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.
\note
Throws exceptions.
*/
void NextVolume(ZIP_SIZE_TYPE uNeeded);
/**
Gets 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));
}
/**
Detects the segmentation mode.
\return
- \c -1 : An existing segmented archive is opened.
- \c 0 : The archive is not segmented.
- \c 1 : A segmented archive in creation.
*/
int IsSegmented() const
{
return m_iSegmMode == noSegments ? 0 : (m_bNewSegm ? 1 : -1);
}
/**
Checks, if the archive is a split archive.
\return
\c true, if the archive is a split archive; \c false otherwise.
*/
bool IsSplit() const
{
return m_iSegmMode == splitArchive;
}
/**
Checks, if the archive is a spanned archive.
\return
\c true, if the archive is a spanned archive; \c false otherwise.
*/
bool IsSpanned() const
{
return m_iSegmMode == spannedArchive;
}
/**
The same as the CZipArchive::IsReadOnly method.
*/
bool IsReadOnly()
{
return m_bReadOnly || IsSegmented() < 0;
}
/**
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);
/**
Gets 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 bAfterException
Set to \c true, if an exception was thrown before.
\return
The file path of the archive.
\note
Throws exceptions.
*/
CZipString Close(bool bAfterException);
/**
Represents the physical storage of the current archive segment.
*/
CZipAbstractFile* m_pFile;
/**
The signature of the extended header.
*/
static char m_gszExtHeaderSignat[];
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.
\note
Throws exceptions.
*/
ZIP_FILE_USIZE LocateSignature(char* szSignature, ZIP_SIZE_TYPE uMaxDepth);
/**
Flushes without writing. 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 whole 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.
\note
Throws exceptions.
*/
void WriteInternalBuffer(const char *pBuf, DWORD uSize);
/**
Gets the free space size on the current removable disk.
\return
The free space in bytes.
*/
ZIP_SIZE_TYPE GetFreeVolumeSpace() const;
/**
Notifies the 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.
\note
Throws exceptions.
\see
CZipArchive::SetSegmCallback
*/
void CallCallback(ZIP_SIZE_TYPE uNeeded, int iCode, CZipString szTemp);
/**
Constructs the name of a segment in a split archive.
\param bLast
Set it to \c true, if constructing the last volume name.
\return
The segment name.
*/
CZipString GetSplitVolumeName(bool bLast) const;
/**
Changes a file when processing a split archive.
*/
CZipString ChangeSplitRead();
/**
Changes a disk when processing a spanned archive.
*/
CZipString ChangeSpannedRead();
/**
Gets the free space left in the write buffer.
\return
The free space left in the write buffer 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 - stores the number of the last volume ( the one with "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 extension of the last segment.
*/
CZipString m_szSplitExtension;
/**
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;
/**
\c true, if the current archive is a new segmented archive; \c false otherwise.
*/
bool m_bNewSegm;
/**
The current volume number in a segmented archive.
The value is zero-based.
*/
ZIP_VOLUME_TYPE m_uCurrentVolume;
/**
\c true when the archive is created in memory; \c false otherwise.
*/
bool m_bInMemory;
/**
\c true if OpenMode::zipOpenReadOnly was specified when opening the archive.
*/
bool m_bReadOnly;
/**
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;
/**
Takes one of the #ZipSegmentationMode values.
*/
int m_iSegmMode;
/**
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:
CZipSegmCallback* m_pChangeVolumeFunc;
CZipString m_szArchiveName;
CZipFile m_internalfile;
static const ZIP_FILE_USIZE SignatureNotFound;
void ThrowError(int err);
};
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
#pragma warning (pop)
#endif
#endif // !defined(ZIPARCHIVE_ZIPSTORAGE_DOT_H)

24
harbour/contrib/hbziparch/ZipString.cpp
View File

@@ -1,24 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ZipString.h"
ZIPSTRINGCOMPARE GetCZipStrCompFunc(bool bCaseSensitive, bool bCollate)
{
if (bCollate)
return bCaseSensitive ? & CZipString::Collate : & CZipString::CollateNoCase;
else
return bCaseSensitive ? & CZipString::Compare : & CZipString::CompareNoCase;
}

37
harbour/contrib/hbziparch/ZipString.h
View File

@@ -1,37 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipString.h
* Includes the CZipString class.
*
*/
#ifndef ZIPARCHIVE_ZIPSTRING_DOT_H
#define ZIPARCHIVE_ZIPSTRING_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "_platform.h"
#ifdef ZIP_ARCHIVE_STL
#include "ZipString_stl.h"
#else
#include "ZipString_mfc.h"
#endif
#endif /* ZIPARCHIVE_ZIPSTRING_DOT_H */

210
harbour/contrib/hbziparch/ZipStringStoreSettings.h
View File

@@ -1,210 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 ZipStringStoreSettings.h
* Includes the CZipStringStoreSettings class.
*
*/
#if !defined(ZIPARCHIVE_ZIPSTRINGSTRINGSTORESETTINGS_DOT_H)
#define ZIPARCHIVE_ZIPSTRINGSTRINGSTORESETTINGS_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
#include "stdafx.h"
#include "ZipPlatform.h"
#include "ZipCompatibility.h"
/**
Settings used in storing strings inside archives.
\see
<a href="kb">0610051525</a>
\see
CZipArchive::SetStringStoreSettings.
*/
class ZIP_API CZipStringStoreSettings
{
public:
/**
Gets the default filename code page for the given platform.
\param iPlatform
One of the ZipCompatibility::ZipPlatforms values.
\return
The default filename code page.
*/
static UINT GetDefaultNameCodePage(int iPlatform)
{
return iPlatform == ZipCompatibility::zcDosFat ? CP_OEMCP : CP_ACP;
}
/**
Gets the default filename code page for the current platform.
\return
The default filename code page.
*/
static UINT GetDefaultNameCodePage()
{
return GetDefaultNameCodePage(ZipPlatform::GetSystemID());
}
/**
Gets the default comment code page. It is not platform-dependent.
*/
static UINT GetDefaultCommentCodePage()
{
return CP_ACP;
}
/**
Initializes a new instance of the CZipStringStoreSettings class.
*/
CZipStringStoreSettings()
{
Reset();
}
/**
Sets the default filename code page depening on the given platform.
\param iPlatform
One of the ZipCompatibility::ZipPlatforms values.
*/
void SetDefaultNameCodePage(int iPlatform)
{
m_uNameCodePage = GetDefaultNameCodePage(iPlatform);
}
/**
Gets a value indicating whether the current filename code page is
standard for the current platform or not.
\return
\c true, if the current filename code page is standard; \c false otherwise.
\see
ZipPlatform::GetSystemID
*/
bool IsStandardNameCodePage() const
{
return m_uNameCodePage == GetDefaultNameCodePage();
}
/**
Gets a value indicating whether the current filename code page is
standard for the given platform or not.
\param iPlatform
One of the ZipCompatibility::ZipPlatforms values.
\return
\c true, if the current filename code page is standard; \c false otherwise.
*/
bool IsStandardNameCodePage(int iPlatform) const
{
return m_uNameCodePage == GetDefaultNameCodePage(iPlatform);
}
/**
Gets a value indicating whether the current comment code page is standard.
\return
\c true, if the current comment code page is standard; \c false otherwise.
*/
bool IsStandardCommentCodePage() const
{
return m_uCommentCodePage == GetDefaultCommentCodePage();
}
/**
Gets a value indicating whether the current settings are
standard for the given platform or not.
\param iPlatform
One of the ZipCompatibility::ZipPlatforms values.
\return
\c true, if the current settings are standard; \c false otherwise.
*/
bool IsStandard(int iPlatform) const
{
return !m_bStoreNameInExtraData && IsStandardNameCodePage(iPlatform) && IsStandardCommentCodePage();
}
/**
Reset the settings to its default values for the given platform.
\param iPlatform
One of the ZipCompatibility::ZipPlatforms values.
\see
Reset
*/
void Reset(int iPlatform)
{
m_bStoreNameInExtraData = false;
SetDefaultNameCodePage(iPlatform);
m_uCommentCodePage = GetDefaultCommentCodePage();
}
/**
Reset the settings to its default values for the current platform.
\see
Reset(int)
\see
ZipPlatform::GetSystemID
*/
void Reset()
{
Reset(ZipPlatform::GetSystemID());
}
/**
Sets the string store settings.
\see
CZipArchive::SetStringStoreSettings(UINT, bool, UINT)
*/
void Set(UINT uFileNameCodePage, bool bStoreNameInExtraData, UINT uCommentCodePage)
{
m_uNameCodePage = uFileNameCodePage;
m_bStoreNameInExtraData = bStoreNameInExtraData;
m_uCommentCodePage = uCommentCodePage;
}
/**
If \c true, the converted filenames are stored in extra field in the archive.
*/
bool m_bStoreNameInExtraData;
/**
The current filename code page.
*/
UINT m_uNameCodePage;
/**
The current comment code page.
*/
UINT m_uCommentCodePage;
};
#endif // !defined(ZIPARCHIVE_ZIPSTRINGSTRINGSTORESETTINGS_DOT_H)

34
harbour/contrib/hbziparch/ZipString_mfc.h
View File

@@ -1,34 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPSTRING_DOT_H
#error Do not include this file directly. Include ZipString.h instead
#endif
#include "stdafx.h"
#include "ZipExport.h"
typedef CString CZipString;
/**
A pointer type to point to one of: Collate, CollateNoCase, Compare, CompareNoCase.
*/
typedef int (CZipString::*ZIPSTRINGCOMPARE)( LPCTSTR ) const;
/**
Return a pointer to a method in the CZipString structure,
used to compare elements depending on the arguments.
*/
ZIP_API ZIPSTRINGCOMPARE GetCZipStrCompFunc(bool bCaseSensitive, bool bCollate = true);

328
harbour/contrib/hbziparch/ZipString_stl.h
View File

@@ -1,328 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_ZIPSTRING_DOT_H
#error Do not include this file directly. Include ZipString.h instead
#endif
#include "stdafx.h"
#if _MSC_VER > 1000
#pragma warning( push, 3 ) // STL requirements
#endif
#include <string>
#include <algorithm>
#include <stdarg.h>
#include <stdio.h>
#include <cctype>
#include <locale>
#include "ZipExport.h"
#ifndef __GNUC__
#ifndef _vsntprintf
#ifdef _UNICODE
#define _vsntprintf _vsnwprintf
#else
#define _vsntprintf _vsnprintf
#endif
#endif
#elif !defined(_vsntprintf)
#define _vsntprintf vsnprintf
#endif
typedef std::basic_string<TCHAR> stdbs;
/**
It contains mostly the methods required by ZipArchive Library.
*/
class ZIP_API CZipString : public stdbs
{
void TrimInternalL(size_type iPos)
{
if (iPos == npos)
erase ();
if (iPos)
erase(0, iPos);
}
void TrimInternalR(size_type iPos)
{
if (iPos == npos)
erase ();
erase(++iPos);
}
#ifndef __GNUC__
static int zslen(const TCHAR* lpsz)
{
if (!lpsz) return 0;
// we want to take into account the locale stuff (by using standard templates)
#ifdef _UNICODE
return (int)std::wstring(lpsz).length();
#else
return (int)std::string(lpsz).length();
#endif
}
#else
static int zslen(const TCHAR* lpsz)
{
#if (__GNUC__ < 3) // I'm not sure which precisely version should be put here
return lpsz ? std::string_char_traits<TCHAR>::length(lpsz) : 0;
#else
return lpsz ? std::char_traits<TCHAR>::length(lpsz) : 0;
#endif
}
#endif
static TCHAR tl(TCHAR c)
{
// use_facet doesn't work here well (doesn't convert all the local characters properly)
return std::tolower(c, std::locale());
}
static TCHAR tu(TCHAR c)
{
// use_facet doesn't work here well (doesn't convert all the local characters properly)
return std::toupper(c, std::locale());
}
public:
CZipString(){}
explicit CZipString (TCHAR ch, int nRepeat = 1):stdbs(nRepeat, ch){}
CZipString( const CZipString& stringSrc ) {assign(stringSrc);}
CZipString( const stdbs& stringSrc ) {assign(stringSrc);}
CZipString( LPCTSTR lpsz ){if (!lpsz) Empty(); else assign(lpsz);}
operator LPCTSTR() const{return c_str();}
int GetLength() const {return (int) size();}
bool IsEmpty() const {return empty();}
void Empty() {erase(begin(), end());}
TCHAR GetAt (int iIndex) const{return at(iIndex);}
TCHAR operator[] (int iIndex) const{return at(iIndex);}
void SetAt( int nIndex, TCHAR ch ) {at(nIndex) = ch;}
LPTSTR GetBuffer(int nMinBufLength)
{
if ((int)size() < nMinBufLength)
resize(nMinBufLength);
return empty() ? const_cast<TCHAR*>(data()) : &(at(0));
}
void ReleaseBuffer( int nNewLength = -1 ) { resize(nNewLength > -1 ? nNewLength : zslen(c_str()));}
void TrimLeft( TCHAR chTarget )
{
TrimInternalL(find_first_not_of(chTarget));
}
void TrimLeft( LPCTSTR lpszTargets )
{
TrimInternalL(find_first_not_of(lpszTargets));
}
void TrimRight( TCHAR chTarget )
{
TrimInternalR(find_last_not_of(chTarget));
}
void TrimRight( LPCTSTR lpszTargets )
{
TrimInternalR(find_last_not_of(lpszTargets));
}
#if _MSC_VER >= 1300
#pragma warning( push )
#pragma warning (disable : 4793) // 'vararg' : causes native code generation for function 'void CZipString::Format(LPCTSTR,...)'
#endif
void Format(LPCTSTR lpszFormat, ...)
{
va_list arguments;
va_start (arguments, lpszFormat);
TCHAR* pBuf = NULL;
int iCounter = 1, uTotal = 0;
do
{
int nChars = iCounter * 1024;
int nLen = sizeof(TCHAR) * nChars;
TCHAR* pTempBuf = (TCHAR*)realloc((void*)pBuf, nLen);
if (!pTempBuf)
{
if (pBuf != NULL)
free(pBuf);
va_end (arguments);
return;
}
pBuf = pTempBuf;
#if _MSC_VER >= 1400
uTotal = _vsntprintf_s(pBuf, nChars, nChars - 1, lpszFormat, arguments);
#else
uTotal = _vsntprintf(pBuf, nChars - 1, lpszFormat, arguments);
#endif
if (uTotal == -1 || (uTotal == nChars - 1) ) // for some implementations
{
pBuf[nChars - 1] = _T('\0');
if (iCounter == 7)
break;
}
else
{
pBuf[uTotal] = _T('\0');
break;
}
iCounter++;
} while (true);
va_end (arguments);
*this = pBuf;
free(pBuf);
}
#if _MSC_VER >= 1300
#pragma warning( pop )
#endif
void Insert( int nIndex, LPCTSTR pstr ){insert(nIndex, pstr, zslen(pstr));}
void Insert( int nIndex, TCHAR ch ) {insert(nIndex, 1, ch);}
int Delete( int nIndex, int nCount = 1 )
{
int iSize = (int) size();
int iToDelete = iSize < nIndex + nCount ? iSize - nIndex : nCount;
if (iToDelete > 0)
{
erase(nIndex, iToDelete);
iSize -= iToDelete;
}
return iSize;
}
#ifndef __MINGW32__
void MakeLower()
{
std::transform(begin(),end(),begin(),tl);
}
void MakeUpper()
{
std::transform(begin(),end(),begin(),tu);
}
#else
void MakeLower()
{
std::transform(begin(),end(),begin(),tolower);
}
void MakeUpper()
{
std::transform(begin(),end(),begin(),toupper);
}
#endif
void MakeReverse()
{
std::reverse(begin(), end());
}
CZipString Left( int nCount ) const { return substr(0, nCount);}
CZipString Right( int nCount) const
{
nCount = (int)size() < nCount ? (int)size() : nCount;
return substr(size() - nCount);
}
CZipString Mid( int nFirst ) const {return substr(nFirst);}
CZipString Mid( int nFirst, int nCount ) const {return substr(nFirst, nCount);}
int Collate( LPCTSTR lpsz ) const
{
#if !defined __GNUC__ || defined __MINGW32__
return _tcscoll(c_str(), lpsz);
#else
//return compare(lpsz);
return strcoll(c_str(), lpsz);
#endif
}
int CollateNoCase( LPCTSTR lpsz ) const
{
#if !defined __GNUC__ || defined __MINGW32__
return _tcsicoll(c_str(), lpsz);
#else
if (std::locale() == std::locale::classic())
return strcasecmp(c_str(), lpsz);
else
// this may be not case-insensitive !!!
return strcoll(c_str(), lpsz);
//return stricoll(c_str(), lpsz);
#endif
}
int Compare( LPCTSTR lpsz ) const
{
return compare(lpsz);
}
int CompareNoCase( LPCTSTR lpsz ) const
{
#if !defined __GNUC__ || defined __MINGW32__
return _tcsicmp(c_str(), lpsz);
#else
return strcasecmp(c_str(), lpsz);
//return stricmp(c_str(), lpsz);
#endif
}
bool operator != (LPCTSTR lpsz)
{
return Compare(lpsz) != 0;
}
bool operator == (LPCTSTR lpsz)
{
return Compare(lpsz) == 0;
}
int Find( TCHAR ch, int nStart = 0) const
{
return (int) find(ch, nStart);
}
int Find( LPCTSTR pstr, int nStart = 0) const
{
return (int) find(pstr, nStart);
}
int Replace( TCHAR chOld, TCHAR chNew )
{
int iCount = 0;
for (iterator it = begin(); it != end(); ++it)
if (*it == chOld)
{
*it = chNew;
iCount++;
}
return iCount;
}
};
/**
A poiter type to point to CZipString to Collate or CollateNoCase
or Compare or CompareNoCase
*/
typedef int (CZipString::*ZIPSTRINGCOMPARE)( LPCTSTR ) const;
/**
return a pointer to the function in CZipString structure,
used to compare elements depending on the arguments
*/
ZIP_API ZIPSTRINGCOMPARE GetCZipStrCompFunc(bool bCaseSensitive, bool bCollate = true);
#if _MSC_VER > 1000
#pragma warning( pop)
#endif

97
harbour/contrib/hbziparch/_features.h
View File

@@ -1,97 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 _features.h
* Contains definitions that enable or disable certain features in the ZipArchive Library.
*
*/
#if !defined(ZIPARCHIVE_FEATURES_DOT_H)
/// @cond
#define ZIPARCHIVE_FEATURES_DOT_H
/// @endcond
#if _MSC_VER > 1000
#pragma once
#endif
#include "_platform.h"
#ifdef __GNUC__
#ifndef __int64
#define __int64 long long
#endif
#endif
/************ Feel free to adjust the definitions in the following block ************/
/************************************ BLOCK START ***********************************/
/**
Make sure it is defined, if you use ZIP64. Comment this out otherwise.
\see
<a href="kb">0610051629</a>
*/
// #define _ZIP64
/**
Make sure it is defined, if you use AES. Comment this out otherwise.
\see
<a href="kb">0610201627|aes</a>
*/
// #define _ZIP_AES
/**
Make sure it is defined, if you use the BZIP2 algorithm for compression. Comment this out otherwise.
\see
<a href="kb">0610231446|bzip2</a>
*/
// #define _BZIP2
/**
Make sure it is defined, if you want to create seekable data.
\see
<a href="kb">0711101739</a>
*/
// #define _ZIP_SEEK
/**
Make sure it is defined, if you use the AES encryption in a multithreaded environment or archive sharing (CZipArchive::OpenFrom). Comment this out otherwise.
\see
<a href="kb">0610201627|aes</a>
\see
<a href="kb">0610241003|thread</a>
*/
// #define ZIP_ARCHIVE_USE_LOCKING
#ifndef _ZIP64
// Uncomment this to have the index and volume numbers types defined as WORD. Otherwise they are defined as int.
#define _ZIP_STRICT_U16
#endif
/************************************* BLOCK END ***********************************/
/***** The contents below this line are usually not intended for modification ******/
#endif // !defined(ZIPARCHIVE_FEATURES_DOT_H)

76
harbour/contrib/hbziparch/_platform.h
View File

@@ -1,76 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 _platform.h
* Contains definitions that determine the target compilation platform.
*
*/
#if !defined(ZIPARCHIVE_PLATFORM_DOT_H)
#define ZIPARCHIVE_PLATFORM_DOT_H
#if _MSC_VER > 1000
#pragma once
#endif
/************ Feel free to adjust the definitions in the following block ************/
/************************************ BLOCK START ***********************************/
//#define ZIP_ARCHIVE_MFC
//#define ZIP_ARCHIVE_LNX
// simplified endianess detection
#ifdef __APPLE__
#ifdef __LITTLE_ENDIAN__
#define ZIP_ARCHIVE_LITTLE_ENDIAN
#endif
#else
#define ZIP_ARCHIVE_LITTLE_ENDIAN
#endif
/************************************* BLOCK END ***********************************/
/********* The contents below this line are not intended for modification **********/
#ifndef ZIP_ARCHIVE_MFC
#define ZIP_ARCHIVE_STL
#else
#ifdef ZIP_ARCHIVE_STL
#undef ZIP_ARCHIVE_STL
#endif
#endif
#ifndef ZIP_ARCHIVE_LNX
#define ZIP_ARCHIVE_WIN
#else
#ifdef ZIP_ARCHIVE_WIN
#undef ZIP_ARCHIVE_WIN
#endif
#endif
#ifndef ZIP_ARCHIVE_LITTLE_ENDIAN
#define ZIP_ARCHIVE_BIG_ENDIAN
#else
#ifdef ZIP_ARCHIVE_BIG_ENDIAN
#undef ZIP_ARCHIVE_BIG_ENDIAN
#endif
#endif
#if defined (ZIP_ARCHIVE_LNX) && defined (ZIP_ARCHIVE_MFC)
#undef ZIP_ARCHIVE_MFC
#define ZIP_ARCHIVE_STL
#error Using MFC under a non-Windows platform is not supported
#endif
#endif // !defined(ZIPARCHIVE_PLATFORM_DOT_H)

37
harbour/contrib/hbziparch/common.mak
View File

@@ -2,45 +2,12 @@
# $Id$
#
LIBNAME = $(LIBPREF)hbziparch
LIBNAME = $(LIBPREF)hbziparc
LIB_PATH = $(LIB_DIR)$(LIBNAME)$(LIBEXT)
LIB_OBJS = \
$(OBJ_DIR)hbzipnew$(OBJEXT) \
\
$(OBJ_DIR)Aes$(OBJEXT) \
$(OBJ_DIR)BaseLibCompressor$(OBJEXT) \
$(OBJ_DIR)Bzip2Compressor$(OBJEXT) \
$(OBJ_DIR)DeflateCompressor$(OBJEXT) \
$(OBJ_DIR)DirEnumerator$(OBJEXT) \
$(OBJ_DIR)FileFilter$(OBJEXT) \
$(OBJ_DIR)Hmac$(OBJEXT) \
$(OBJ_DIR)RandomPool$(OBJEXT) \
$(OBJ_DIR)Sha1$(OBJEXT) \
$(OBJ_DIR)Wildcard$(OBJEXT) \
$(OBJ_DIR)ZipAesCryptograph$(OBJEXT) \
$(OBJ_DIR)ZipArchive$(OBJEXT) \
$(OBJ_DIR)ZipAutoBuffer$(OBJEXT) \
$(OBJ_DIR)ZipCentralDir$(OBJEXT) \
$(OBJ_DIR)ZipCompatibility$(OBJEXT) \
$(OBJ_DIR)ZipCompressor$(OBJEXT) \
$(OBJ_DIR)ZipCrc32Cryptograph$(OBJEXT) \
$(OBJ_DIR)ZipCryptograph$(OBJEXT) \
$(OBJ_DIR)ZipException$(OBJEXT) \
$(OBJ_DIR)ZipExtraData$(OBJEXT) \
$(OBJ_DIR)ZipExtraField$(OBJEXT) \
# $(OBJ_DIR)ZipFile_mfc$(OBJEXT) \
$(OBJ_DIR)ZipFile_stl$(OBJEXT) \
$(OBJ_DIR)ZipFileHeader$(OBJEXT) \
$(OBJ_DIR)ZipMemFile$(OBJEXT) \
# $(OBJ_DIR)ZipPathComponent_lnx$(OBJEXT) \
$(OBJ_DIR)ZipPathComponent_win$(OBJEXT) \
# $(OBJ_DIR)ZipPlatform_lnx$(OBJEXT) \
$(OBJ_DIR)ZipPlatform_win$(OBJEXT) \
$(OBJ_DIR)ZipPlatformComm$(OBJEXT) \
$(OBJ_DIR)ZipStorage$(OBJEXT) \
$(OBJ_DIR)ZipString$(OBJEXT) \
$(OBJ_DIR)hbziparc$(OBJEXT) \
all: \
$(LIB_PATH) \

1041
harbour/contrib/hbziparch/hbziparc.prg Normal file
View File

File diff suppressed because it is too large Load Diff

1
harbour/contrib/hbziparch/hbzipnew.cpp → harbour/contrib/hbziparch/hbzipold.cpp
View File

@@ -6,6 +6,7 @@
* Harbour Project source code:
* ZipArchive interface for Harbour
*
* Copyright 2008 Viktor Szakats (harbour.01 syenar hu) (refactor/fix/reformat)
* Copyright 2000-2001 Luiz Rafael Culik <culik@sl.conex.net>
* Copyright 1999 Leslee Griffith <les.griffith@vantagesystems.ca> (hb_fsDirectory())
* www - http://www.harbour-project.org

73
harbour/contrib/hbziparch/readme.txt
View File

@@ -1,73 +0,0 @@
/** \page pageLic Licensing information
ZipArchive library - creation, modification and decompression of "zip" format archives <BR>
Copyright &copy; 2000 - 2002 Tadeusz Dracz. <BR>
E-Mail: \htmlonly<a href="mailto:tdracz@artpol-software.com"> tdracz@artpol-software.com</a><BR>
Web: <A HREF="http://www.artpol-software.com" target="_blank">http://www.artpol-software.com</A> \endhtmlonly
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.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
<HR>
*************************************************************************
An English version of the \ref pageGPL "GNU GPL" is in the gpl.txt file distributed with
this project. Translations to other languages are available at:
\htmlonly
<A HREF="http://www.gnu.org/copyleft/gpl.html" target="_blank">http://www.gnu.org/copyleft/gpl.html</A>
\endhtmlonly
<B><EM>
Distributing ZipArchive under GNU GPL implies ZipArchive can only be used
with software that is licensed under conditions compliant with the GPL.
Embedding in proprietary software requires an alternative license.
</B></EM>
\subsection s1 Alternative license for use with proprietary software
If you want to distribute software in a commercial context that incorporates
ZipArchive and you do not want to meet the conditions of GNU GPL
<B>(e.g. an obligation to provide a customer with the source code of your
software that uses the ZipArchive library)</B>, you need to have a commercial license.
- The commercial license provides you with the same rights as the GNU GPL, but in
addition allows you to embed ZipArchive library in proprietary software without
affecting the copyright of this software (it removes the GNU GPL obligation
to publish the source code)
- The license gives you royalty free distribution rights
- The license does not allow you to transfer these rights
- The license is granted per developer
- You won't need to purchase an additional license for the future versions of the library
The commercial license is available free of charge for using ZipArchive library in:
- freeware software <EM>(freeware is software that is available free of charge, but which is copyrighted by the developer, who retains the right to control its redistribution and to sell it in the future)</EM>
- excluded is software which is associated with an equipment that the same company manufactures and which has no practical usage value without it (e.g. software used for maintenace of machines) - unless the equipment is free as well (?)
- if you decide to sell the software in the future - you will need to purchase the commercial license for using the ZipArchive library, unless it is distributed in the shareware way - see below
- software distributed in the Shareware way <em>(Shareware distribution gives users a chance to try software before buying it. If you try a Shareware program and continue using it, you are expected to register. Individual programs differ on details -- some request registration while others require it, some specify a maximum trial period.
Copyright laws apply to both Shareware and commercial software and the copyright holder retains all rights, with the exception that copying and distributing the program for evaluation purposes is encouraged, subject to certain conditions. For example, some authors require written permission before a commercial disk vendor may copy their Shareware. )</em>
- excluded is software which price for a single copy is higher than the price of the ZipArchive library for a single developer
Extended Licence for HBZLIB (library for zip compression in \htmlonly <A HREF="http://www.harbour-project.org" target="_blank">Harbour</A>\endhtmlonly)<BR>
You can create proprietary software using hbzlib respecting the follow:
- ZipArchive library must be linked together with hbzlib
- you cannot use ZipArchive as a dynamic library (DLL), it must be linked staticaly with the software
- the commercial license for ZipArchive is free of charge, but these grants are valid only if the whole application is written with Harbour
There is a fee for the commercial license for using the library in the software not falling into the mentioned categories.
<BR>
It is recommended that you should print two copies of the commercial license
document after you receive it, sign them and send by post. One copy, signed by the author will be sent back to you.
Please \htmlonly <a href="mailto:tdracz@artpol-software.com">contact the author</a> or visit <A HREF="http://www.artpol-software.com" target="_blank">the Artpol Software web site</A>\endhtmlonly to find out more.
*/

15
harbour/contrib/hbziparch/resource.h
View File

@@ -1,15 +0,0 @@
//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by ZipArchive.rc
//
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 101
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1000
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

46
harbour/contrib/hbziparch/std_mfc.h
View File

@@ -1,46 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_STDAFX_DOT_H
#error Do not include this file directly. Include stdafx.h instead
#endif
#if _MSC_VER > 1000
#ifndef WINVER
#define WINVER 0x0400
#endif
#pragma once
#endif
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit
#ifndef VC_EXTRALEAN
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#endif
#include <afx.h>
#include <afxwin.h>
typedef BOOL ZBOOL;
#if _MSC_VER >= 1300 || defined ZIP_FILE_USES_STL
#define ZIP_FILE_USIZE ULONGLONG
#define ZIP_FILE_SIZE LONGLONG
#define ZIP_FILE_SIZEMAX _I64_MAX
#else
#define ZIP_FILE_USIZE DWORD
#define ZIP_FILE_SIZE LONG
#define ZIP_FILE_SIZEMAX MAXLONG
#endif

126
harbour/contrib/hbziparch/std_stl.h
View File

@@ -1,126 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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
////////////////////////////////////////////////////////////////////////////////
#ifndef ZIPARCHIVE_STDAFX_DOT_H
#error Do not include this file directly. Include stdafx.h instead
#endif
#include "_features.h"
#if _MSC_VER > 1000
// STL warnings
#pragma warning (disable : 4710) // 'function' : function not inlined
#pragma warning (disable : 4514) // unreferenced inline/local function has been removed
#pragma warning (disable : 4786) // 'identifier' : identifier was truncated to 'number' characters in the debug information
#pragma warning (disable : 4702) // unreachable code
#endif
#if defined (_UNICODE) && !defined (UNICODE)
#define UNICODE
#endif
#if defined (UNICODE) && !defined (_UNICODE)
#define _UNICODE
#endif
#ifndef _WIN32
#ifndef NULL
#define NULL 0
#endif
#include <ctype.h>
typedef int HFILE;
typedef void* HANDLE;
typedef unsigned long DWORD;
typedef long LONG;
typedef int ZBOOL; /* to avoid conflicts when using Objective-C under Mac */
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned int UINT;
#ifndef FALSE
#define FALSE (int)0
#endif
#ifndef TRUE
#define TRUE (int)1
#endif
typedef unsigned short WCHAR; // wc, 16-bit UNICODE character
typedef const WCHAR *LPCWSTR;
typedef const char *LPCSTR;
typedef WCHAR *LPWSTR;
typedef char *LPSTR;
#ifdef _UNICODE
typedef wchar_t TCHAR;
typedef LPCWSTR LPCTSTR;
typedef LPWSTR LPTSTR;
#define _T(x) L ## x
#else /* _UNICODE */ // r_winnt
typedef char TCHAR;
typedef LPCSTR LPCTSTR;
typedef LPSTR LPTSTR;
#ifdef _T
#undef _T
#endif
#define _T(x) x
#endif /* _UNICODE */ // r_winnt
typedef unsigned long long ULONGLONG;
typedef long long LONGLONG;
#define CP_ACP 0
#define CP_OEMCP 1
#ifndef _I64_MAX
#ifdef LLONG_MAX
#define _I64_MAX LLONG_MAX
#else
#define _I64_MAX LONG_LONG_MAX
#endif
#endif
#ifndef _UI64_MAX
#ifdef ULLONG_MAX
#define _UI64_MAX ULLONG_MAX
#else
#define _UI64_MAX ULONG_LONG_MAX
#endif
#endif
#define _lseeki64 lseek64
#else
#include <TCHAR.H>
#include <windows.h>
#include <stddef.h>
#ifndef STRICT
#define STRICT
#endif
typedef BOOL ZBOOL;
#endif // #ifndef _WIN32
#ifndef ASSERT
#include <assert.h>
#define ASSERT(f) assert((f))
#endif
#ifndef VERIFY
#ifdef _DEBUG
#define VERIFY(x) ASSERT((x))
#else
#define VERIFY(x) x
#endif
#endif
#define ZIP_FILE_USIZE ULONGLONG
#define ZIP_FILE_SIZE LONGLONG
#define ZIP_FILE_SIZEMAX _I64_MAX

84
harbour/contrib/hbziparch/stdafx.h
View File

@@ -1,84 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive library source distribution and
// is Copyrighted 2000 - 2007 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 stdafx.h
* Contains global definitions.
*
*/
#if !defined(ZIPARCHIVE_STDAFX_DOT_H)
#define ZIPARCHIVE_STDAFX_DOT_H
#include "_features.h"
#include "_platform.h"
#if _MSC_VER > 1000
#pragma once
#endif
// uncomment to disable compiling standard error messages into the library
#define ZIP_ENABLE_ERROR_DESCRIPTION
#if _MSC_VER < 1300 && !defined __BORLANDC__ && !defined (__GNUC__)
#define ZIPINLINE inline
#else
#define ZIPINLINE
#endif
#ifdef ZIP_ARCHIVE_STL
#include "std_stl.h"
#else
#include "std_mfc.h"
#endif
#ifdef TRACE
#if _MSC_VER >= 1300
#define ZIPTRACE(f) TRACE(f,__FILE__,__LINE__)
#else
#define ZIPTRACE(f) TRACE(_T(f))
#endif
#else
#define ZIPTRACE(f)
#define NOZIPTRACE
#endif
#ifdef _ZIP_STRICT_U16
#define ZIP_INDEX_TYPE WORD
#define ZIP_VOLUME_TYPE WORD
#else
#define ZIP_INDEX_TYPE int
#define ZIP_VOLUME_TYPE int
#endif
#define ZIP_SIZE_TYPE DWORD
#define ZIP_ZLIB_TYPE int
#if !defined(_INTPTR_T_DEFINED) && !defined(__GNUC__)
/* NOTE: Harbour modification to make it compile with BCC55. [vszakats] */
#if __BORLANDC__ > 0x551
#include <stdint.h>
#elif _MSC_VER <= 1200 || !defined _MSC_VER
typedef long intptr_t;
#endif
#endif
#define ZIP_FILE_INDEX_NOT_FOUND ZIP_INDEX_TYPE(-1)
#define ZIP_FILE_INDEX_UNSPECIFIED ZIP_FILE_INDEX_NOT_FOUND
#define ZIP_VOLUME_NUMBER_UNSPECIFIED ZIP_VOLUME_TYPE(-1)
#endif // !defined(ZIPARCHIVE_STDAFX_DOT_H)

2
harbour/contrib/hbziparch/tests/bld_b32.bat
View File

@@ -9,6 +9,6 @@ if "%HB_INC_INSTALL%" == "" set HB_INC_INSTALL=..\..\..\include
set HB_ARCHITECTURE=w32
set HB_COMPILER=bcc32
set HB_USER_LIBS=hbziparch.lib
set HB_USER_LIBS=hbziparc.lib hbmzip.lib
call %HB_BIN_INSTALL%\bld.bat %1 %2 %3 %4 %5 %6 %7 %8 %9

2
harbour/contrib/hbziparch/tests/bld_vc.bat
View File

@@ -9,6 +9,6 @@ if "%HB_INC_INSTALL%" == "" set HB_INC_INSTALL=..\..\..\include
set HB_ARCHITECTURE=w32
set HB_COMPILER=msvc
set HB_USER_LIBS=hbziparch.lib
set HB_USER_LIBS=hbziparc.lib hbmzip.lib
call %HB_BIN_INSTALL%\bld.bat %1 %2 %3 %4 %5 %6 %7 %8 %9

5
harbour/contrib/hbziparch/zlib/deflate.h
View File

@@ -1,5 +0,0 @@
/*
* $Id$
*/
#include "zlib.h"

94
harbour/contrib/hbziparch/zlib/zlib.h
View File

@@ -1,94 +0,0 @@
/*
* $Id$
*/
/* NOTE: This is a stub to plug the Harbour ZLIB library of Harbour,
without the need to modify ZipArchive sources. Notice that
ZipArchive uses a modified ZLIB sources for large file support,
but this is available only in the commercial version of the
lib anyway. [vszakats] */
#include "hbzlib.h"
//# define zarch_deflateInit deflateInit
# define zarch_deflateInit_ deflateInit_
# define zarch_deflate deflate
# define zarch_deflateEnd deflateEnd
//# define zarch_deflateInit2 deflateInit2
# define zarch_deflateInit2_ deflateInit2_
# define zarch_deflateSetDictionary deflateSetDictionary
# define zarch_deflateCopy deflateCopy
# define zarch_deflateReset deflateReset
# define zarch_deflateParams deflateParams
# define zarch_deflateBound deflateBound
# define zarch_deflatePrime deflatePrime
# define zarch_deflateSetHeader deflateSetHeader
# define zarch_deflateTune deflateTune
//# define zarch_inflateInit inflateInit
//# define zarch_inflateInit2 inflateInit2
# define zarch_inflateInit2_ inflateInit2_
# define zarch_inflateInit_ inflateInit_
# define zarch_inflate inflate
# define zarch_inflateEnd inflateEnd
# define zarch_inflateSetDictionary inflateSetDictionary
# define zarch_inflateSync inflateSync
# define zarch_inflateSyncPoint inflateSyncPoint
# define zarch_inflateCopy inflateCopy
# define zarch_inflateReset inflateReset
//# define zarch_inflateBackInit inflateBackInit
# define zarch_inflateBackInit_ inflateBackInit_
# define zarch_inflateBack inflateBack
# define zarch_inflateBackEnd inflateBackEnd
# define zarch_inflatePrime inflatePrime
# define zarch_inflateGetHeader inflateGetHeader
# define zarch_compress compress
# define zarch_compress2 compress2
# define zarch_compressBound compressBound
# define zarch_uncompress uncompress
# define zarch_adler32 adler32
# define zarch_adler32_combine adler32_combine
# define zarch_crc32_combine crc32_combine
# define zarch_deflate_copyright deflate_copyright
# define zarch_inflate_copyright inflate_copyright
# define zarch_crc32 crc32
# define zarch_get_crc_table get_crc_table
# define zarch_zError zError
# define zarch_z_stream z_stream
# define zarch_z_stream_s z_stream_s
# define zarch_alloc_func alloc_func
# define zarch_free_func free_func
# define zarch_in_func in_func
# define zarch_out_func out_func
# define zarch_Byte Byte
# define zarch_uInt uInt
# define zarch_uLong uLong
# define zarch_uLongLong uLongLong
# define zarch_Bytef Bytef
# define zarch_charf charf
# define zarch_intf intf
# define zarch_uIntf uIntf
# define zarch_uLongf uLongf
# define zarch_voidpf voidpf
# define zarch_voidp voidp
# define zarch_deflate_state deflate_state
# define zarch_deflate_slow deflate_slow
# define zarch_deflate_fast deflate_fast
# define zarch_deflate_stored deflate_stored
# define zarch_z_streamp z_streamp
# define zarch_deflate_rle deflate_rle
# define zarch_inflate_state inflate_state
# define zarch_inflate_fast inflate_fast
# define zarch_inflate_table inflate_table
# define zarch_updatewindow updatewindow
//# define zarch_inflate_mode inflate_mode
//# define zarch_send_bits send_bits
# define zarch_zlibVersion zlibVersion
# define zarch_zlibCompileFlags zlibCompileFlags
# define zarch_zError zError
# define zarch_tr_init _tr_init
# define zarch_tr_tally _tr_tally
# define zarch_tr_flush_block _tr_flush_block
# define zarch_tr_align _tr_align
# define zarch_tr_stored_block _tr_stored_block
# define zarch_dist_code _dist_code
# define zarch_length_code _length_code