1045 lines
23 KiB
C++
1045 lines
23 KiB
C++
// GzHandler.cpp
|
|
|
|
#include "StdAfx.h"
|
|
|
|
// #include <stdio.h>
|
|
|
|
#include "../../../C/CpuArch.h"
|
|
|
|
#include "../../Common/ComTry.h"
|
|
#include "../../Common/Defs.h"
|
|
#include "../../Common/StringConvert.h"
|
|
|
|
#include "../../Windows/PropVariant.h"
|
|
#include "../../Windows/TimeUtils.h"
|
|
|
|
#include "../Common/ProgressUtils.h"
|
|
#include "../Common/RegisterArc.h"
|
|
#include "../Common/StreamUtils.h"
|
|
|
|
#include "../Compress/CopyCoder.h"
|
|
#include "../Compress/DeflateDecoder.h"
|
|
#include "../Compress/DeflateEncoder.h"
|
|
|
|
#include "Common/HandlerOut.h"
|
|
#include "Common/InStreamWithCRC.h"
|
|
#include "Common/OutStreamWithCRC.h"
|
|
|
|
#define Get32(p) GetUi32(p)
|
|
|
|
using namespace NWindows;
|
|
|
|
using namespace NCompress;
|
|
using namespace NDeflate;
|
|
|
|
namespace NArchive {
|
|
namespace NGz {
|
|
|
|
static const Byte kSignature_0 = 0x1F;
|
|
static const Byte kSignature_1 = 0x8B;
|
|
static const Byte kSignature_2 = 8; // NCompressionMethod::kDeflate
|
|
|
|
// Latest versions of gzip program don't write comment field to gz archive.
|
|
// We also don't write comment field to gz archive.
|
|
|
|
namespace NFlags
|
|
{
|
|
const Byte kIsText = 1 << 0;
|
|
const Byte kCrc = 1 << 1;
|
|
const Byte kExtra = 1 << 2;
|
|
const Byte kName = 1 << 3;
|
|
const Byte kComment = 1 << 4;
|
|
const Byte kReserved = 0xE0;
|
|
}
|
|
|
|
namespace NExtraFlags
|
|
{
|
|
const Byte kMaximum = 2;
|
|
const Byte kFastest = 4;
|
|
}
|
|
|
|
namespace NHostOS
|
|
{
|
|
enum EEnum
|
|
{
|
|
kFAT = 0,
|
|
kAMIGA,
|
|
kVMS,
|
|
kUnix,
|
|
kVM_CMS,
|
|
kAtari,
|
|
kHPFS,
|
|
kMac,
|
|
kZ_System,
|
|
kCPM,
|
|
kTOPS20,
|
|
kNTFS,
|
|
kQDOS,
|
|
kAcorn,
|
|
kVFAT,
|
|
kMVS,
|
|
kBeOS,
|
|
kTandem,
|
|
|
|
kUnknown = 255
|
|
};
|
|
}
|
|
|
|
static const char * const kHostOSes[] =
|
|
{
|
|
"FAT"
|
|
, "AMIGA"
|
|
, "VMS"
|
|
, "Unix"
|
|
, "VM/CMS"
|
|
, "Atari"
|
|
, "HPFS"
|
|
, "Macintosh"
|
|
, "Z-System"
|
|
, "CP/M"
|
|
, "TOPS-20"
|
|
, "NTFS"
|
|
, "SMS/QDOS"
|
|
, "Acorn"
|
|
, "VFAT"
|
|
, "MVS"
|
|
, "BeOS"
|
|
, "Tandem"
|
|
, "OS/400"
|
|
, "OS/X"
|
|
};
|
|
|
|
static const char *kUnknownOS = "Unknown";
|
|
|
|
class CItem
|
|
{
|
|
bool TestFlag(Byte flag) const { return (Flags & flag) != 0; }
|
|
public:
|
|
Byte Flags;
|
|
Byte ExtraFlags;
|
|
Byte HostOS;
|
|
UInt32 Time;
|
|
UInt32 Crc;
|
|
UInt32 Size32;
|
|
|
|
AString Name;
|
|
AString Comment;
|
|
// CByteBuffer Extra;
|
|
|
|
CItem():
|
|
Flags(0),
|
|
ExtraFlags(0),
|
|
HostOS(0),
|
|
Time(0),
|
|
Crc(0),
|
|
Size32(0) {}
|
|
|
|
void Clear()
|
|
{
|
|
Name.Empty();
|
|
Comment.Empty();
|
|
// Extra.Free();
|
|
}
|
|
|
|
void CopyMetaPropsFrom(const CItem &a)
|
|
{
|
|
Flags = a.Flags;
|
|
HostOS = a.HostOS;
|
|
Time = a.Time;
|
|
Name = a.Name;
|
|
Comment = a.Comment;
|
|
// Extra = a.Extra;
|
|
}
|
|
|
|
void CopyDataPropsFrom(const CItem &a)
|
|
{
|
|
ExtraFlags = a.ExtraFlags;
|
|
Crc = a.Crc;
|
|
Size32 = a.Size32;
|
|
}
|
|
|
|
// bool IsText() const { return TestFlag(NFlags::kIsText); }
|
|
bool HeaderCrcIsPresent() const { return TestFlag(NFlags::kCrc); }
|
|
bool ExtraFieldIsPresent() const { return TestFlag(NFlags::kExtra); }
|
|
bool NameIsPresent() const { return TestFlag(NFlags::kName); }
|
|
bool CommentIsPresent() const { return TestFlag(NFlags::kComment); }
|
|
bool IsSupported() const { return (Flags & NFlags::kReserved) == 0; }
|
|
|
|
HRESULT ReadHeader(NDecoder::CCOMCoder *stream);
|
|
HRESULT ReadFooter1(NDecoder::CCOMCoder *stream);
|
|
HRESULT ReadFooter2(ISequentialInStream *stream);
|
|
|
|
HRESULT WriteHeader(ISequentialOutStream *stream);
|
|
HRESULT WriteFooter(ISequentialOutStream *stream);
|
|
};
|
|
|
|
static HRESULT ReadBytes(NDecoder::CCOMCoder *stream, Byte *data, UInt32 size)
|
|
{
|
|
for (UInt32 i = 0; i < size; i++)
|
|
data[i] = stream->ReadAlignedByte();
|
|
return stream->InputEofError() ? S_FALSE : S_OK;
|
|
}
|
|
|
|
static HRESULT SkipBytes(NDecoder::CCOMCoder *stream, UInt32 size)
|
|
{
|
|
for (UInt32 i = 0; i < size; i++)
|
|
stream->ReadAlignedByte();
|
|
return stream->InputEofError() ? S_FALSE : S_OK;
|
|
}
|
|
|
|
static HRESULT ReadUInt16(NDecoder::CCOMCoder *stream, UInt32 &value /* , UInt32 &crc */)
|
|
{
|
|
value = 0;
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
Byte b = stream->ReadAlignedByte();
|
|
if (stream->InputEofError())
|
|
return S_FALSE;
|
|
// crc = CRC_UPDATE_BYTE(crc, b);
|
|
value |= ((UInt32)(b) << (8 * i));
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT ReadString(NDecoder::CCOMCoder *stream, AString &s, size_t limit /* , UInt32 &crc */)
|
|
{
|
|
s.Empty();
|
|
for (size_t i = 0; i < limit; i++)
|
|
{
|
|
Byte b = stream->ReadAlignedByte();
|
|
if (stream->InputEofError())
|
|
return S_FALSE;
|
|
// crc = CRC_UPDATE_BYTE(crc, b);
|
|
if (b == 0)
|
|
return S_OK;
|
|
s += (char)b;
|
|
}
|
|
return S_FALSE;
|
|
}
|
|
|
|
static UInt32 Is_Deflate(const Byte *p, size_t size)
|
|
{
|
|
if (size < 1)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
Byte b = *p;
|
|
p++;
|
|
size--;
|
|
unsigned type = ((unsigned)b >> 1) & 3;
|
|
if (type == 3)
|
|
return k_IsArc_Res_NO;
|
|
if (type == 0)
|
|
{
|
|
// Stored (uncompreessed data)
|
|
if ((b >> 3) != 0)
|
|
return k_IsArc_Res_NO;
|
|
if (size < 4)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
if (GetUi16(p) != (UInt16)~GetUi16(p + 2))
|
|
return k_IsArc_Res_NO;
|
|
}
|
|
else if (type == 2)
|
|
{
|
|
// Dynamic Huffman
|
|
if (size < 1)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
if ((*p & 0x1F) + 1 > 30) // numDistLevels
|
|
return k_IsArc_Res_NO;
|
|
}
|
|
return k_IsArc_Res_YES;
|
|
}
|
|
|
|
static unsigned kNameMaxLen = 1 << 12;
|
|
static unsigned kCommentMaxLen = 1 << 16;
|
|
|
|
API_FUNC_static_IsArc IsArc_Gz(const Byte *p, size_t size)
|
|
{
|
|
if (size < 10)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
if (p[0] != kSignature_0 ||
|
|
p[1] != kSignature_1 ||
|
|
p[2] != kSignature_2)
|
|
return k_IsArc_Res_NO;
|
|
|
|
Byte flags = p[3];
|
|
if ((flags & NFlags::kReserved) != 0)
|
|
return k_IsArc_Res_NO;
|
|
|
|
Byte extraFlags = p[8];
|
|
// maybe that flag can have another values for some gz archives?
|
|
if (extraFlags != 0 &&
|
|
extraFlags != NExtraFlags::kMaximum &&
|
|
extraFlags != NExtraFlags::kFastest)
|
|
return k_IsArc_Res_NO;
|
|
|
|
size -= 10;
|
|
p += 10;
|
|
|
|
if ((flags & NFlags::kExtra) != 0)
|
|
{
|
|
if (size < 2)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
unsigned xlen = GetUi16(p);
|
|
size -= 2;
|
|
p += 2;
|
|
while (xlen != 0)
|
|
{
|
|
if (xlen < 4)
|
|
return k_IsArc_Res_NO;
|
|
if (size < 4)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
unsigned len = GetUi16(p + 2);
|
|
size -= 4;
|
|
xlen -= 4;
|
|
p += 4;
|
|
if (len > xlen)
|
|
return k_IsArc_Res_NO;
|
|
if (len > size)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
size -= len;
|
|
xlen -= len;
|
|
p += len;
|
|
}
|
|
}
|
|
|
|
if ((flags & NFlags::kName) != 0)
|
|
{
|
|
size_t limit = kNameMaxLen;
|
|
if (limit > size)
|
|
limit = size;
|
|
size_t i;
|
|
for (i = 0; i < limit && p[i] != 0; i++);
|
|
if (i == size)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
if (i == limit)
|
|
return k_IsArc_Res_NO;
|
|
i++;
|
|
p += i;
|
|
size -= i;
|
|
}
|
|
|
|
if ((flags & NFlags::kComment) != 0)
|
|
{
|
|
size_t limit = kCommentMaxLen;
|
|
if (limit > size)
|
|
limit = size;
|
|
size_t i;
|
|
for (i = 0; i < limit && p[i] != 0; i++);
|
|
if (i == size)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
if (i == limit)
|
|
return k_IsArc_Res_NO;
|
|
i++;
|
|
p += i;
|
|
size -= i;
|
|
}
|
|
|
|
if ((flags & NFlags::kCrc) != 0)
|
|
{
|
|
if (size < 2)
|
|
return k_IsArc_Res_NEED_MORE;
|
|
p += 2;
|
|
size -= 2;
|
|
}
|
|
|
|
return Is_Deflate(p, size);
|
|
}
|
|
}
|
|
|
|
HRESULT CItem::ReadHeader(NDecoder::CCOMCoder *stream)
|
|
{
|
|
Clear();
|
|
|
|
// Header-CRC field had another meaning in old version of gzip!
|
|
// UInt32 crc = CRC_INIT_VAL;
|
|
Byte buf[10];
|
|
|
|
RINOK(ReadBytes(stream, buf, 10));
|
|
|
|
if (buf[0] != kSignature_0 ||
|
|
buf[1] != kSignature_1 ||
|
|
buf[2] != kSignature_2)
|
|
return S_FALSE;
|
|
|
|
Flags = buf[3];
|
|
if (!IsSupported())
|
|
return S_FALSE;
|
|
|
|
Time = Get32(buf + 4);
|
|
ExtraFlags = buf[8];
|
|
HostOS = buf[9];
|
|
|
|
// crc = CrcUpdate(crc, buf, 10);
|
|
|
|
if (ExtraFieldIsPresent())
|
|
{
|
|
UInt32 xlen;
|
|
RINOK(ReadUInt16(stream, xlen /* , crc */));
|
|
RINOK(SkipBytes(stream, xlen));
|
|
// Extra.SetCapacity(xlen);
|
|
// RINOK(ReadStream_FALSE(stream, Extra, xlen));
|
|
// crc = CrcUpdate(crc, Extra, xlen);
|
|
}
|
|
if (NameIsPresent())
|
|
RINOK(ReadString(stream, Name, kNameMaxLen /* , crc */));
|
|
if (CommentIsPresent())
|
|
RINOK(ReadString(stream, Comment, kCommentMaxLen /* , crc */));
|
|
|
|
if (HeaderCrcIsPresent())
|
|
{
|
|
UInt32 headerCRC;
|
|
// UInt32 dummy = 0;
|
|
RINOK(ReadUInt16(stream, headerCRC /* , dummy */));
|
|
/*
|
|
if ((UInt16)CRC_GET_DIGEST(crc) != headerCRC)
|
|
return S_FALSE;
|
|
*/
|
|
}
|
|
return stream->InputEofError() ? S_FALSE : S_OK;
|
|
}
|
|
|
|
HRESULT CItem::ReadFooter1(NDecoder::CCOMCoder *stream)
|
|
{
|
|
Byte buf[8];
|
|
RINOK(ReadBytes(stream, buf, 8));
|
|
Crc = Get32(buf);
|
|
Size32 = Get32(buf + 4);
|
|
return stream->InputEofError() ? S_FALSE : S_OK;
|
|
}
|
|
|
|
HRESULT CItem::ReadFooter2(ISequentialInStream *stream)
|
|
{
|
|
Byte buf[8];
|
|
RINOK(ReadStream_FALSE(stream, buf, 8));
|
|
Crc = Get32(buf);
|
|
Size32 = Get32(buf + 4);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CItem::WriteHeader(ISequentialOutStream *stream)
|
|
{
|
|
Byte buf[10];
|
|
buf[0] = kSignature_0;
|
|
buf[1] = kSignature_1;
|
|
buf[2] = kSignature_2;
|
|
buf[3] = (Byte)(Flags & NFlags::kName);
|
|
// buf[3] |= NFlags::kCrc;
|
|
SetUi32(buf + 4, Time);
|
|
buf[8] = ExtraFlags;
|
|
buf[9] = HostOS;
|
|
RINOK(WriteStream(stream, buf, 10));
|
|
// crc = CrcUpdate(CRC_INIT_VAL, buf, 10);
|
|
if (NameIsPresent())
|
|
{
|
|
// crc = CrcUpdate(crc, (const char *)Name, Name.Len() + 1);
|
|
RINOK(WriteStream(stream, (const char *)Name, Name.Len() + 1));
|
|
}
|
|
// SetUi16(buf, (UInt16)CRC_GET_DIGEST(crc));
|
|
// RINOK(WriteStream(stream, buf, 2));
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CItem::WriteFooter(ISequentialOutStream *stream)
|
|
{
|
|
Byte buf[8];
|
|
SetUi32(buf, Crc);
|
|
SetUi32(buf + 4, Size32);
|
|
return WriteStream(stream, buf, 8);
|
|
}
|
|
|
|
class CHandler:
|
|
public IInArchive,
|
|
public IArchiveOpenSeq,
|
|
public IOutArchive,
|
|
public ISetProperties,
|
|
public CMyUnknownImp
|
|
{
|
|
CItem _item;
|
|
|
|
bool _isArc;
|
|
bool _needSeekToStart;
|
|
bool _dataAfterEnd;
|
|
bool _needMoreInput;
|
|
|
|
bool _packSize_Defined;
|
|
bool _unpackSize_Defined;
|
|
bool _numStreams_Defined;
|
|
|
|
UInt64 _packSize;
|
|
UInt64 _unpackSize; // real unpack size (NOT from footer)
|
|
UInt64 _numStreams;
|
|
UInt64 _headerSize; // only start header (without footer)
|
|
|
|
CMyComPtr<IInStream> _stream;
|
|
CMyComPtr<ICompressCoder> _decoder;
|
|
NDecoder::CCOMCoder *_decoderSpec;
|
|
|
|
CSingleMethodProps _props;
|
|
|
|
public:
|
|
MY_UNKNOWN_IMP4(
|
|
IInArchive,
|
|
IArchiveOpenSeq,
|
|
IOutArchive,
|
|
ISetProperties)
|
|
INTERFACE_IInArchive(;)
|
|
INTERFACE_IOutArchive(;)
|
|
STDMETHOD(OpenSeq)(ISequentialInStream *stream);
|
|
STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
|
|
|
|
CHandler()
|
|
{
|
|
_decoderSpec = new NDecoder::CCOMCoder;
|
|
_decoder = _decoderSpec;
|
|
}
|
|
};
|
|
|
|
static const Byte kProps[] =
|
|
{
|
|
kpidPath,
|
|
kpidSize,
|
|
kpidPackSize,
|
|
kpidMTime,
|
|
kpidHostOS,
|
|
kpidCRC
|
|
// kpidComment
|
|
};
|
|
|
|
static const Byte kArcProps[] =
|
|
{
|
|
kpidHeadersSize,
|
|
kpidNumStreams
|
|
};
|
|
|
|
|
|
IMP_IInArchive_Props
|
|
IMP_IInArchive_ArcProps
|
|
|
|
STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
|
|
{
|
|
COM_TRY_BEGIN
|
|
NCOM::CPropVariant prop;
|
|
switch (propID)
|
|
{
|
|
case kpidPhySize: if (_packSize_Defined) prop = _packSize; break;
|
|
case kpidUnpackSize: if (_unpackSize_Defined) prop = _unpackSize; break;
|
|
case kpidNumStreams: if (_numStreams_Defined) prop = _numStreams; break;
|
|
case kpidHeadersSize: if (_headerSize != 0) prop = _headerSize; break;
|
|
case kpidErrorFlags:
|
|
{
|
|
UInt32 v = 0;
|
|
if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;;
|
|
if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
|
|
if (_dataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
|
|
prop = v;
|
|
break;
|
|
}
|
|
case kpidName:
|
|
if (_item.NameIsPresent())
|
|
{
|
|
UString s = MultiByteToUnicodeString(_item.Name, CP_ACP);
|
|
s.AddAscii(".gz");
|
|
prop = s;
|
|
}
|
|
break;
|
|
}
|
|
prop.Detach(value);
|
|
return S_OK;
|
|
COM_TRY_END
|
|
}
|
|
|
|
|
|
STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
|
|
{
|
|
*numItems = 1;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value)
|
|
{
|
|
COM_TRY_BEGIN
|
|
NCOM::CPropVariant prop;
|
|
switch (propID)
|
|
{
|
|
case kpidPath:
|
|
if (_item.NameIsPresent())
|
|
prop = MultiByteToUnicodeString(_item.Name, CP_ACP);
|
|
break;
|
|
// case kpidComment: if (_item.CommentIsPresent()) prop = MultiByteToUnicodeString(_item.Comment, CP_ACP); break;
|
|
case kpidMTime:
|
|
if (_item.Time != 0)
|
|
{
|
|
FILETIME utc;
|
|
NTime::UnixTimeToFileTime(_item.Time, utc);
|
|
prop = utc;
|
|
}
|
|
break;
|
|
case kpidSize:
|
|
{
|
|
if (_unpackSize_Defined)
|
|
prop = _unpackSize;
|
|
else if (_stream)
|
|
prop = (UInt64)_item.Size32;
|
|
break;
|
|
}
|
|
case kpidPackSize:
|
|
{
|
|
if (_packSize_Defined || _stream)
|
|
prop = _packSize;
|
|
break;
|
|
}
|
|
case kpidHostOS: prop = (_item.HostOS < ARRAY_SIZE(kHostOSes)) ?
|
|
kHostOSes[_item.HostOS] : kUnknownOS; break;
|
|
case kpidCRC: if (_stream) prop = _item.Crc; break;
|
|
}
|
|
prop.Detach(value);
|
|
return S_OK;
|
|
COM_TRY_END
|
|
}
|
|
|
|
class CCompressProgressInfoImp:
|
|
public ICompressProgressInfo,
|
|
public CMyUnknownImp
|
|
{
|
|
CMyComPtr<IArchiveOpenCallback> Callback;
|
|
public:
|
|
UInt64 Offset;
|
|
MY_UNKNOWN_IMP1(ICompressProgressInfo)
|
|
STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
|
|
void Init(IArchiveOpenCallback *callback) { Callback = callback; }
|
|
};
|
|
|
|
STDMETHODIMP CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
|
|
{
|
|
if (Callback)
|
|
{
|
|
UInt64 files = 0;
|
|
UInt64 value = Offset + *inSize;
|
|
return Callback->SetCompleted(&files, &value);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
*/
|
|
|
|
STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *)
|
|
{
|
|
COM_TRY_BEGIN
|
|
RINOK(OpenSeq(stream));
|
|
_isArc = false;
|
|
UInt64 endPos;
|
|
RINOK(stream->Seek(-8, STREAM_SEEK_END, &endPos));
|
|
_packSize = endPos + 8;
|
|
RINOK(_item.ReadFooter2(stream));
|
|
_stream = stream;
|
|
_isArc = true;
|
|
_needSeekToStart = true;
|
|
return S_OK;
|
|
COM_TRY_END
|
|
}
|
|
|
|
STDMETHODIMP CHandler::OpenSeq(ISequentialInStream *stream)
|
|
{
|
|
COM_TRY_BEGIN
|
|
try
|
|
{
|
|
Close();
|
|
_decoderSpec->SetInStream(stream);
|
|
_decoderSpec->InitInStream(true);
|
|
RINOK(_item.ReadHeader(_decoderSpec));
|
|
if (_decoderSpec->InputEofError())
|
|
return S_FALSE;
|
|
_headerSize = _decoderSpec->GetInputProcessedSize();
|
|
_isArc = true;
|
|
return S_OK;
|
|
}
|
|
catch(const CInBufferException &e) { return e.ErrorCode; }
|
|
COM_TRY_END
|
|
}
|
|
|
|
STDMETHODIMP CHandler::Close()
|
|
{
|
|
_isArc = false;
|
|
_needSeekToStart = false;
|
|
_dataAfterEnd = false;
|
|
_needMoreInput = false;
|
|
|
|
_packSize_Defined = false;
|
|
_unpackSize_Defined = false;
|
|
_numStreams_Defined = false;
|
|
|
|
_packSize = 0;
|
|
_headerSize = 0;
|
|
|
|
_stream.Release();
|
|
_decoderSpec->ReleaseInStream();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
|
|
Int32 testMode, IArchiveExtractCallback *extractCallback)
|
|
{
|
|
COM_TRY_BEGIN
|
|
if (numItems == 0)
|
|
return S_OK;
|
|
if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
|
|
return E_INVALIDARG;
|
|
|
|
if (_packSize_Defined)
|
|
extractCallback->SetTotal(_packSize);
|
|
// UInt64 currentTotalPacked = 0;
|
|
// RINOK(extractCallback->SetCompleted(¤tTotalPacked));
|
|
CMyComPtr<ISequentialOutStream> realOutStream;
|
|
Int32 askMode = testMode ?
|
|
NExtract::NAskMode::kTest :
|
|
NExtract::NAskMode::kExtract;
|
|
RINOK(extractCallback->GetStream(0, &realOutStream, askMode));
|
|
if (!testMode && !realOutStream)
|
|
return S_OK;
|
|
|
|
extractCallback->PrepareOperation(askMode);
|
|
|
|
COutStreamWithCRC *outStreamSpec = new COutStreamWithCRC;
|
|
CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
|
|
outStreamSpec->SetStream(realOutStream);
|
|
outStreamSpec->Init();
|
|
realOutStream.Release();
|
|
|
|
CLocalProgress *lps = new CLocalProgress;
|
|
CMyComPtr<ICompressProgressInfo> progress = lps;
|
|
lps->Init(extractCallback, true);
|
|
|
|
bool needReadFirstItem = _needSeekToStart;
|
|
|
|
if (_needSeekToStart)
|
|
{
|
|
if (!_stream)
|
|
return E_FAIL;
|
|
RINOK(_stream->Seek(0, STREAM_SEEK_SET, NULL));
|
|
_decoderSpec->InitInStream(true);
|
|
// printf("\nSeek");
|
|
}
|
|
else
|
|
_needSeekToStart = true;
|
|
|
|
bool firstItem = true;
|
|
|
|
UInt64 packSize = _decoderSpec->GetInputProcessedSize();
|
|
// printf("\npackSize = %d", (unsigned)packSize);
|
|
|
|
UInt64 unpackedSize = 0;
|
|
UInt64 numStreams = 0;
|
|
|
|
bool crcError = false;
|
|
|
|
HRESULT result = S_OK;
|
|
|
|
try {
|
|
|
|
for (;;)
|
|
{
|
|
lps->InSize = packSize;
|
|
lps->OutSize = unpackedSize;
|
|
|
|
RINOK(lps->SetCur());
|
|
|
|
CItem item;
|
|
|
|
if (!firstItem || needReadFirstItem)
|
|
{
|
|
result = item.ReadHeader(_decoderSpec);
|
|
|
|
if (result != S_OK && result != S_FALSE)
|
|
return result;
|
|
|
|
if (_decoderSpec->InputEofError())
|
|
result = S_FALSE;
|
|
|
|
if (result != S_OK && firstItem)
|
|
{
|
|
_isArc = false;
|
|
break;
|
|
}
|
|
|
|
if (packSize == _decoderSpec->GetStreamSize())
|
|
{
|
|
result = S_OK;
|
|
break;
|
|
}
|
|
|
|
if (result != S_OK)
|
|
{
|
|
_dataAfterEnd = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
numStreams++;
|
|
firstItem = false;
|
|
|
|
UInt64 startOffset = outStreamSpec->GetSize();
|
|
outStreamSpec->InitCRC();
|
|
|
|
result = _decoderSpec->CodeResume(outStream, NULL, progress);
|
|
|
|
packSize = _decoderSpec->GetInputProcessedSize();
|
|
unpackedSize = outStreamSpec->GetSize();
|
|
|
|
if (result != S_OK && result != S_FALSE)
|
|
return result;
|
|
|
|
if (_decoderSpec->InputEofError())
|
|
{
|
|
packSize = _decoderSpec->GetStreamSize();
|
|
_needMoreInput = true;
|
|
result = S_FALSE;
|
|
}
|
|
|
|
if (result != S_OK)
|
|
break;
|
|
|
|
_decoderSpec->AlignToByte();
|
|
|
|
result = item.ReadFooter1(_decoderSpec);
|
|
|
|
packSize = _decoderSpec->GetInputProcessedSize();
|
|
|
|
if (result != S_OK && result != S_FALSE)
|
|
return result;
|
|
|
|
if (result != S_OK)
|
|
{
|
|
if (_decoderSpec->InputEofError())
|
|
{
|
|
_needMoreInput = true;
|
|
result = S_FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (item.Crc != outStreamSpec->GetCRC() ||
|
|
item.Size32 != (UInt32)(unpackedSize - startOffset))
|
|
{
|
|
crcError = true;
|
|
result = S_FALSE;
|
|
break;
|
|
}
|
|
|
|
// break; // we can use break, if we need only first stream
|
|
}
|
|
|
|
} catch(const CInBufferException &e) { return e.ErrorCode; }
|
|
|
|
if (!firstItem)
|
|
{
|
|
_packSize = packSize;
|
|
_unpackSize = unpackedSize;
|
|
_numStreams = numStreams;
|
|
|
|
_packSize_Defined = true;
|
|
_unpackSize_Defined = true;
|
|
_numStreams_Defined = true;
|
|
}
|
|
|
|
outStream.Release();
|
|
|
|
Int32 retResult = NExtract::NOperationResult::kDataError;
|
|
|
|
if (!_isArc)
|
|
retResult = NExtract::NOperationResult::kIsNotArc;
|
|
else if (_needMoreInput)
|
|
retResult = NExtract::NOperationResult::kUnexpectedEnd;
|
|
else if (crcError)
|
|
retResult = NExtract::NOperationResult::kCRCError;
|
|
else if (_dataAfterEnd)
|
|
retResult = NExtract::NOperationResult::kDataAfterEnd;
|
|
else if (result == S_FALSE)
|
|
retResult = NExtract::NOperationResult::kDataError;
|
|
else if (result == S_OK)
|
|
retResult = NExtract::NOperationResult::kOK;
|
|
else
|
|
return result;
|
|
|
|
return extractCallback->SetOperationResult(retResult);
|
|
|
|
|
|
COM_TRY_END
|
|
}
|
|
|
|
static const Byte kHostOS =
|
|
#ifdef _WIN32
|
|
NHostOS::kFAT;
|
|
#else
|
|
NHostOS::kUnix;
|
|
#endif
|
|
|
|
static HRESULT UpdateArchive(
|
|
ISequentialOutStream *outStream,
|
|
UInt64 unpackSize,
|
|
CItem &item,
|
|
const CSingleMethodProps &props,
|
|
IArchiveUpdateCallback *updateCallback)
|
|
{
|
|
UInt64 complexity = 0;
|
|
RINOK(updateCallback->SetTotal(unpackSize));
|
|
RINOK(updateCallback->SetCompleted(&complexity));
|
|
|
|
CMyComPtr<ISequentialInStream> fileInStream;
|
|
|
|
RINOK(updateCallback->GetStream(0, &fileInStream));
|
|
|
|
CSequentialInStreamWithCRC *inStreamSpec = new CSequentialInStreamWithCRC;
|
|
CMyComPtr<ISequentialInStream> crcStream(inStreamSpec);
|
|
inStreamSpec->SetStream(fileInStream);
|
|
inStreamSpec->Init();
|
|
|
|
CLocalProgress *lps = new CLocalProgress;
|
|
CMyComPtr<ICompressProgressInfo> progress = lps;
|
|
lps->Init(updateCallback, true);
|
|
|
|
item.ExtraFlags = props.GetLevel() >= 7 ?
|
|
NExtraFlags::kMaximum :
|
|
NExtraFlags::kFastest;
|
|
|
|
item.HostOS = kHostOS;
|
|
|
|
RINOK(item.WriteHeader(outStream));
|
|
|
|
NEncoder::CCOMCoder *deflateEncoderSpec = new NEncoder::CCOMCoder;
|
|
CMyComPtr<ICompressCoder> deflateEncoder = deflateEncoderSpec;
|
|
RINOK(props.SetCoderProps(deflateEncoderSpec, NULL));
|
|
RINOK(deflateEncoder->Code(crcStream, outStream, NULL, NULL, progress));
|
|
|
|
item.Crc = inStreamSpec->GetCRC();
|
|
item.Size32 = (UInt32)inStreamSpec->GetSize();
|
|
RINOK(item.WriteFooter(outStream));
|
|
return updateCallback->SetOperationResult(NUpdate::NOperationResult::kOK);
|
|
}
|
|
|
|
STDMETHODIMP CHandler::GetFileTimeType(UInt32 *timeType)
|
|
{
|
|
*timeType = NFileTimeType::kUnix;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
|
|
IArchiveUpdateCallback *updateCallback)
|
|
{
|
|
COM_TRY_BEGIN
|
|
|
|
if (numItems != 1)
|
|
return E_INVALIDARG;
|
|
|
|
Int32 newData, newProps;
|
|
UInt32 indexInArchive;
|
|
if (!updateCallback)
|
|
return E_FAIL;
|
|
RINOK(updateCallback->GetUpdateItemInfo(0, &newData, &newProps, &indexInArchive));
|
|
|
|
CItem newItem;
|
|
|
|
if (!IntToBool(newProps))
|
|
{
|
|
newItem.CopyMetaPropsFrom(_item);
|
|
}
|
|
else
|
|
{
|
|
newItem.HostOS = kHostOS;
|
|
{
|
|
NCOM::CPropVariant prop;
|
|
RINOK(updateCallback->GetProperty(0, kpidMTime, &prop));
|
|
if (prop.vt == VT_FILETIME)
|
|
NTime::FileTimeToUnixTime(prop.filetime, newItem.Time);
|
|
else if (prop.vt == VT_EMPTY)
|
|
newItem.Time = 0;
|
|
else
|
|
return E_INVALIDARG;
|
|
}
|
|
{
|
|
NCOM::CPropVariant prop;
|
|
RINOK(updateCallback->GetProperty(0, kpidPath, &prop));
|
|
if (prop.vt == VT_BSTR)
|
|
{
|
|
UString name = prop.bstrVal;
|
|
int slashPos = name.ReverseFind_PathSepar();
|
|
if (slashPos >= 0)
|
|
name.DeleteFrontal(slashPos + 1);
|
|
newItem.Name = UnicodeStringToMultiByte(name, CP_ACP);
|
|
if (!newItem.Name.IsEmpty())
|
|
newItem.Flags |= NFlags::kName;
|
|
}
|
|
else if (prop.vt != VT_EMPTY)
|
|
return E_INVALIDARG;
|
|
}
|
|
{
|
|
NCOM::CPropVariant prop;
|
|
RINOK(updateCallback->GetProperty(0, kpidIsDir, &prop));
|
|
if (prop.vt != VT_EMPTY)
|
|
if (prop.vt != VT_BOOL || prop.boolVal != VARIANT_FALSE)
|
|
return E_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
if (IntToBool(newData))
|
|
{
|
|
UInt64 size;
|
|
{
|
|
NCOM::CPropVariant prop;
|
|
RINOK(updateCallback->GetProperty(0, kpidSize, &prop));
|
|
if (prop.vt != VT_UI8)
|
|
return E_INVALIDARG;
|
|
size = prop.uhVal.QuadPart;
|
|
}
|
|
return UpdateArchive(outStream, size, newItem, _props, updateCallback);
|
|
}
|
|
|
|
if (indexInArchive != 0)
|
|
return E_INVALIDARG;
|
|
|
|
if (!_stream)
|
|
return E_NOTIMPL;
|
|
|
|
CLocalProgress *lps = new CLocalProgress;
|
|
CMyComPtr<ICompressProgressInfo> progress = lps;
|
|
lps->Init(updateCallback, true);
|
|
|
|
CMyComPtr<IArchiveUpdateCallbackFile> opCallback;
|
|
updateCallback->QueryInterface(IID_IArchiveUpdateCallbackFile, (void **)&opCallback);
|
|
if (opCallback)
|
|
{
|
|
RINOK(opCallback->ReportOperation(
|
|
NEventIndexType::kInArcIndex, 0,
|
|
NUpdateNotifyOp::kReplicate))
|
|
}
|
|
|
|
newItem.CopyDataPropsFrom(_item);
|
|
|
|
UInt64 offset = 0;
|
|
if (IntToBool(newProps))
|
|
{
|
|
newItem.WriteHeader(outStream);
|
|
offset += _headerSize;
|
|
}
|
|
RINOK(_stream->Seek(offset, STREAM_SEEK_SET, NULL));
|
|
|
|
return NCompress::CopyStream(_stream, outStream, progress);
|
|
|
|
COM_TRY_END
|
|
}
|
|
|
|
STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
|
|
{
|
|
return _props.SetProperties(names, values, numProps);
|
|
}
|
|
|
|
static const Byte k_Signature[] = { kSignature_0, kSignature_1, kSignature_2 };
|
|
|
|
REGISTER_ARC_IO(
|
|
"gzip", "gz gzip tgz tpz", "* * .tar .tar", 0xEF,
|
|
k_Signature,
|
|
0,
|
|
NArcInfoFlags::kKeepName,
|
|
IsArc_Gz)
|
|
|
|
}}
|