// 7zIn.cpp
#include "StdAfx.h"
#ifdef _WIN32
#include <wchar.h>
#else
#include <ctype.h>
#endif
#include "../../../../C/7zCrc.h"
#include "../../../../C/CpuArch.h"
#include "../../Common/StreamObjects.h"
#include "../../Common/StreamUtils.h"
#include "7zDecode.h"
#include "7zIn.h"
#define Get16(p) GetUi16(p)
#define Get32(p) GetUi32(p)
#define Get64(p) GetUi64(p)
// define FORMAT_7Z_RECOVERY if you want to recover multivolume archives with empty StartHeader
#ifndef _SFX
#define FORMAT_7Z_RECOVERY
#endif
using namespace NWindows;
using namespace NCOM;
namespace NArchive {
namespace N7z {
static const UInt32 k_LZMA2 = 0x21;
static const UInt32 k_LZMA = 0x030101;
static void BoolVector_Fill_False(CBoolVector &v, unsigned size)
{
v.ClearAndSetSize(size);
bool *p = &v[0];
for (unsigned i = 0; i < size; i++)
p[i] = false;
}
static bool BoolVector_GetAndSet(CBoolVector &v, UInt32 index)
{
if (index >= (UInt32)v.Size())
return true;
bool res = v[index];
v[index] = true;
return res;
}
bool CFolder::CheckStructure(unsigned numUnpackSizes) const
{
const unsigned kNumCodersMax = sizeof(UInt32) * 8; // don't change it
const unsigned kMaskSize = sizeof(UInt32) * 8; // it must be >= kNumCodersMax
const unsigned kNumBindsMax = 32;
if (Coders.Size() > kNumCodersMax || BindPairs.Size() > kNumBindsMax)
return false;
{
CBoolVector v;
BoolVector_Fill_False(v, BindPairs.Size() + PackStreams.Size());
unsigned i;
for (i = 0; i < BindPairs.Size(); i++)
if (BoolVector_GetAndSet(v, BindPairs[i].InIndex))
return false;
for (i = 0; i < PackStreams.Size(); i++)
if (BoolVector_GetAndSet(v, PackStreams[i]))
return false;
BoolVector_Fill_False(v, numUnpackSizes);
for (i = 0; i < BindPairs.Size(); i++)
if (BoolVector_GetAndSet(v, BindPairs[i].OutIndex))
return false;
}
UInt32 mask[kMaskSize];
unsigned i;
for (i = 0; i < kMaskSize; i++)
mask[i] = 0;
{
CUIntVector inStreamToCoder, outStreamToCoder;
for (i = 0; i < Coders.Size(); i++)
{
CNum j;
const CCoderInfo &coder = Coders[i];
for (j = 0; j < coder.NumInStreams; j++)
inStreamToCoder.Add(i);
for (j = 0; j < coder.NumOutStreams; j++)
outStreamToCoder.Add(i);
}
for (i = 0; i < BindPairs.Size(); i++)
{
const CBindPair &bp = BindPairs[i];
mask[inStreamToCoder[bp.InIndex]] |= (1 << outStreamToCoder[bp.OutIndex]);
}
}
for (i = 0; i < kMaskSize; i++)
for (unsigned j = 0; j < kMaskSize; j++)
if (((1 << j) & mask[i]) != 0)
mask[i] |= mask[j];
for (i = 0; i < kMaskSize; i++)
if (((1 << i) & mask[i]) != 0)
return false;
return true;
}
class CInArchiveException {};
class CUnsupportedFeatureException: public CInArchiveException {};
static void ThrowException() { throw CInArchiveException(); }
static inline void ThrowEndOfData() { ThrowException(); }
static inline void ThrowUnsupported() { throw CUnsupportedFeatureException(); }
static inline void ThrowIncorrect() { ThrowException(); }
class CStreamSwitch
{
CInArchive *_archive;
bool _needRemove;
bool _needUpdatePos;
public:
CStreamSwitch(): _needRemove(false), _needUpdatePos(false) {}
~CStreamSwitch() { Remove(); }
void Remove();
void Set(CInArchive *archive, const Byte *data, size_t size, bool needUpdatePos);
void Set(CInArchive *archive, const CByteBuffer &byteBuffer);
void Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector);
};
void CStreamSwitch::Remove()
{
if (_needRemove)
{
if (_archive->_inByteBack->GetRem() != 0)
_archive->ThereIsHeaderError = true;
_archive->DeleteByteStream(_needUpdatePos);
_needRemove = false;
}
}
void CStreamSwitch::Set(CInArchive *archive, const Byte *data, size_t size, bool needUpdatePos)
{
Remove();
_archive = archive;
_archive->AddByteStream(data, size);
_needRemove = true;
_needUpdatePos = needUpdatePos;
}
void CStreamSwitch::Set(CInArchive *archive, const CByteBuffer &byteBuffer)
{
Set(archive, byteBuffer, byteBuffer.Size(), false);
}
void CStreamSwitch::Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector)
{
Remove();
Byte external = archive->ReadByte();
if (external != 0)
{
CNum dataIndex = archive->ReadNum();
if (dataIndex >= dataVector->Size())
ThrowIncorrect();
Set(archive, (*dataVector)[dataIndex]);
}
}
void CInArchive::AddByteStream(const Byte *buf, size_t size)
{
if (_numInByteBufs == kNumBufLevelsMax)
ThrowIncorrect();
_inByteBack = &_inByteVector[_numInByteBufs++];
_inByteBack->Init(buf, size);
}
Byte CInByte2::ReadByte()
{
if (_pos >= _size)
ThrowEndOfData();
return _buffer[_pos++];
}
void CInByte2::ReadBytes(Byte *data, size_t size)
{
if (size > _size - _pos)
ThrowEndOfData();
memcpy(data, _buffer + _pos, size);
_pos += size;
}
void CInByte2::SkipData(UInt64 size)
{
if (size > _size - _pos)
ThrowEndOfData();
_pos += (size_t)size;
}
void CInByte2::SkipData()
{
SkipData(ReadNumber());
}
static UInt64 ReadNumberSpec(const Byte *p, size_t size, size_t &processed)
{
if (size == 0)
{
processed = 0;
return 0;
}
Byte firstByte = *p++;
size--;
if ((firstByte & 0x80) == 0)
{
processed = 1;
return firstByte;
}
Byte mask = 0x40;
if (size == 0)
{
processed = 0;
return 0;
}
UInt64 value = (UInt64)*p;
p++;
size--;
for (unsigned i = 1; i < 8; i++)
{
if ((firstByte & mask) == 0)
{
UInt64 highPart = firstByte & (mask - 1);
value += (highPart << (i * 8));
processed = i + 1;
return value;
}
if (size == 0)
{
processed = 0;
return 0;
}
value |= ((UInt64)*p << (i * 8));
p++;
size--;
mask >>= 1;
}
processed = 9;
return value;
}
UInt64 CInByte2::ReadNumber()
{
size_t processed;
UInt64 res = ReadNumberSpec(_buffer + _pos, _size - _pos, processed);
if (processed == 0)
ThrowEndOfData();
_pos += processed;
return res;
}
CNum CInByte2::ReadNum()
{
/*
if (_pos < _size)
{
Byte val = _buffer[_pos];
if ((unsigned)val < 0x80)
{
_pos++;
return (unsigned)val;
}
}
*/
UInt64 value = ReadNumber();
if (value > kNumMax)
ThrowUnsupported();
return (CNum)value;
}
UInt32 CInByte2::ReadUInt32()
{
if (_pos + 4 > _size)
ThrowEndOfData();
UInt32 res = Get32(_buffer + _pos);
_pos += 4;
return res;
}
UInt64 CInByte2::ReadUInt64()
{
if (_pos + 8 > _size)
ThrowEndOfData();
UInt64 res = Get64(_buffer + _pos);
_pos += 8;
return res;
}
#define CHECK_SIGNATURE if (p[0] != '7' || p[1] != 'z' || p[2] != 0xBC || p[3] != 0xAF || p[4] != 0x27 || p[5] != 0x1C) return false;
static inline bool TestSignature(const Byte *p)
{
CHECK_SIGNATURE
return CrcCalc(p + 12, 20) == Get32(p + 8);
}
#ifdef FORMAT_7Z_RECOVERY
static inline bool TestSignature2(const Byte *p)
{
CHECK_SIGNATURE;
if (CrcCalc(p + 12, 20) == Get32(p + 8))
return true;
for (unsigned i = 8; i < kHeaderSize; i++)
if (p[i] != 0)
return false;
return (p[6] != 0 || p[7] != 0);
}
#else
#define TestSignature2(p) TestSignature(p)
#endif
HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
{
RINOK(ReadStream_FALSE(stream, _header, kHeaderSize));
if (TestSignature2(_header))
return S_OK;
if (searchHeaderSizeLimit && *searchHeaderSizeLimit == 0)
return S_FALSE;
const UInt32 kBufSize = 1 << 15;
CByteArr buf(kBufSize);
memcpy(buf, _header, kHeaderSize);
UInt64 offset = 0;
for (;;)
{
UInt32 readSize = kBufSize - kHeaderSize;
{
UInt64 rem = *searchHeaderSizeLimit - offset;
if (readSize > rem)
readSize = (UInt32)rem;
if (readSize == 0)
return S_FALSE;
}
UInt32 processed = 0;
RINOK(stream->Read(buf + kHeaderSize, readSize, &processed));
if (processed == 0)
return S_FALSE;
for (UInt32 pos = 0;;)
{
const Byte *p = buf + pos + 1;
const Byte *lim = buf + processed;
for (; p <= lim; p += 4)
{
if (p[0] == '7') break;
if (p[1] == '7') { p += 1; break; }
if (p[2] == '7') { p += 2; break; }
if (p[3] == '7') { p += 3; break; }
};
if (p > lim)
break;
pos = (UInt32)(p - buf);
if (TestSignature(p))
{
memcpy(_header, p, kHeaderSize);
_arhiveBeginStreamPosition += offset + pos;
return stream->Seek(_arhiveBeginStreamPosition + kHeaderSize, STREAM_SEEK_SET, NULL);
}
}
offset += processed;
memmove(buf, buf + processed, kHeaderSize);
}
}
// S_FALSE means that file is not archive
HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
{
HeadersSize = 0;
Close();
RINOK(stream->Seek(0, STREAM_SEEK_CUR, &_arhiveBeginStreamPosition))
RINOK(stream->Seek(0, STREAM_SEEK_END, &_fileEndPosition))
RINOK(stream->Seek(_arhiveBeginStreamPosition, STREAM_SEEK_SET, NULL))
RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit));
_stream = stream;
return S_OK;
}
void CInArchive::Close()
{
_numInByteBufs = 0;
_stream.Release();
ThereIsHeaderError = false;
}
void CInArchive::ReadArchiveProperties(CInArchiveInfo & /* archiveInfo */)
{
for (;;)
{
if (ReadID() == NID::kEnd)
break;
SkipData();
}
}
// CFolder &folder can be non empty. So we must set all fields
void CInByte2::ParseFolder(CFolder &folder)
{
CNum numCoders = ReadNum();
folder.Coders.SetSize(numCoders);
CNum numInStreams = 0;
CNum numOutStreams = 0;
CNum i;
for (i = 0; i < numCoders; i++)
{
CCoderInfo &coder = folder.Coders[i];
{
Byte mainByte = ReadByte();
if ((mainByte & 0xC0) != 0)
ThrowUnsupported();
unsigned idSize = (mainByte & 0xF);
if (idSize > 8 || idSize > GetRem())
ThrowUnsupported();
const Byte *longID = GetPtr();
UInt64 id = 0;
for (unsigned j = 0; j < idSize; j++)
id = ((id << 8) | longID[j]);
SkipDataNoCheck(idSize);
coder.MethodID = id;
if ((mainByte & 0x10) != 0)
{
coder.NumInStreams = ReadNum();
coder.NumOutStreams = ReadNum();
}
else
{
coder.NumInStreams = 1;
coder.NumOutStreams = 1;
}
if ((mainByte & 0x20) != 0)
{
CNum propsSize = ReadNum();
coder.Props.Alloc((size_t)propsSize);
ReadBytes((Byte *)coder.Props, (size_t)propsSize);
}
else
coder.Props.Free();
}
numInStreams += coder.NumInStreams;
numOutStreams += coder.NumOutStreams;
}
CNum numBindPairs = numOutStreams - 1;
folder.BindPairs.SetSize(numBindPairs);
for (i = 0; i < numBindPairs; i++)
{
CBindPair &bp = folder.BindPairs[i];
bp.InIndex = ReadNum();
bp.OutIndex = ReadNum();
}
if (numInStreams < numBindPairs)
ThrowUnsupported();
CNum numPackStreams = numInStreams - numBindPairs;
folder.PackStreams.SetSize(numPackStreams);
if (numPackStreams == 1)
{
for (i = 0; i < numInStreams; i++)
if (folder.FindBindPairForInStream(i) < 0)
{
folder.PackStreams[0] = i;
break;
}
if (i == numInStreams)
ThrowUnsupported();
}
else
for (i = 0; i < numPackStreams; i++)
folder.PackStreams[i] = ReadNum();
}
void CFolders::ParseFolderInfo(unsigned folderIndex, CFolder &folder) const
{
size_t startPos = FoCodersDataOffset[folderIndex];
CInByte2 inByte;
inByte.Init(CodersData + startPos, FoCodersDataOffset[folderIndex + 1] - startPos);
inByte.ParseFolder(folder);
if (inByte.GetRem() != 0)
throw 20120424;
}
void CDatabase::GetPath(unsigned index, UString &path) const
{
path.Empty();
if (!NameOffsets || !NamesBuf)
return;
size_t offset = NameOffsets[index];
size_t size = NameOffsets[index + 1] - offset - 1;
if (size >= (1 << 20))
return;
wchar_t *s = path.GetBuffer((unsigned)size);
const Byte *p = ((const Byte *)NamesBuf + offset * 2);
#if defined(_WIN32) && defined(MY_CPU_LE)
wmemcpy(s, (const wchar_t *)p, size);
#else
for (size_t i = 0; i < size; i++)
{
*s = Get16(p);
p += 2;
s++;
}
#endif
path.ReleaseBuffer((unsigned)size);
}
HRESULT CDatabase::GetPath_Prop(unsigned index, PROPVARIANT *path) const throw()
{
PropVariant_Clear(path);
if (!NameOffsets || !NamesBuf)
return S_OK;
size_t offset = NameOffsets[index];
size_t size = NameOffsets[index + 1] - offset;
if (size >= (1 << 14))
return S_OK;
RINOK(PropVarEm_Alloc_Bstr(path, (unsigned)size - 1));
wchar_t *s = path->bstrVal;
const Byte *p = ((const Byte *)NamesBuf + offset * 2);
for (size_t i = 0; i < size; i++)
{
wchar_t c = Get16(p);
p += 2;
#if WCHAR_PATH_SEPARATOR != L'/'
if (c == L'/')
c = WCHAR_PATH_SEPARATOR;
#endif
*s++ = c;
}
return S_OK;
/*
unsigned cur = index;
unsigned size = 0;
for (int i = 0;; i++)
{
size_t len = NameOffsets[cur + 1] - NameOffsets[cur];
size += (unsigned)len;
if (i > 256 || len > (1 << 14) || size > (1 << 14))
return PropVarEm_Set_Str(path, "[TOO-LONG]");
cur = Files[cur].Parent;
if (cur < 0)
break;
}
size--;
RINOK(PropVarEm_Alloc_Bstr(path, size));
wchar_t *s = path->bstrVal;
s += size;
*s = 0;
cur = index;
for (;;)
{
unsigned len = (unsigned)(NameOffsets[cur + 1] - NameOffsets[cur] - 1);
const Byte *p = (const Byte *)NamesBuf + (NameOffsets[cur + 1] * 2) - 2;
do
{
p -= 2;
--s;
wchar_t c = Get16(p);
if (c == '/')
c = WCHAR_PATH_SEPARATOR;
*s = c;
}
while (--len);
const CFileItem &file = Files[cur];
cur = file.Parent;
if (cur < 0)
return S_OK;
*(--s) = (file.IsAltStream ? ':' : WCHAR_PATH_SEPARATOR);
}
*/
}
void CInArchive::WaitId(UInt64 id)
{
for (;;)
{
UInt64 type = ReadID();
if (type == id)
return;
if (type == NID::kEnd)
ThrowIncorrect();
SkipData();
}
}
void CInArchive::ReadHashDigests(unsigned numItems, CUInt32DefVector &crcs)
{
ReadBoolVector2(numItems, crcs.Defs);
crcs.Vals.ClearAndSetSize(numItems);
UInt32 *p = &crcs.Vals[0];
const bool *defs = &crcs.Defs[0];
for (unsigned i = 0; i < numItems; i++)
{
UInt32 crc = 0;
if (defs[i])
crc = ReadUInt32();
p[i] = crc;
}
}
void CInArchive::ReadPackInfo(CFolders &f)
{
CNum numPackStreams = ReadNum();
WaitId(NID::kSize);
f.PackPositions.Alloc(numPackStreams + 1);
f.NumPackStreams = numPackStreams;
UInt64 sum = 0;
for (CNum i = 0; i < numPackStreams; i++)
{
f.PackPositions[i] = sum;
UInt64 packSize = ReadNumber();
sum += packSize;
if (sum < packSize)
ThrowIncorrect();
}
f.PackPositions[numPackStreams] = sum;
UInt64 type;
for (;;)
{
type = ReadID();
if (type == NID::kEnd)
return;
if (type == NID::kCRC)
{
CUInt32DefVector PackCRCs;
ReadHashDigests(numPackStreams, PackCRCs);
continue;
}
SkipData();
}
}
void CInArchive::ReadUnpackInfo(
const CObjectVector<CByteBuffer> *dataVector,
CFolders &folders)
{
WaitId(NID::kFolder);
CNum numFolders = ReadNum();
CNum numCodersOutStreams = 0;
{
CStreamSwitch streamSwitch;
streamSwitch.Set(this, dataVector);
const Byte *startBufPtr = _inByteBack->GetPtr();
folders.NumFolders = numFolders;
folders.FoStartPackStreamIndex.Alloc(numFolders + 1);
folders.FoToMainUnpackSizeIndex.Alloc(numFolders);
folders.FoCodersDataOffset.Alloc(numFolders + 1);
folders.FoToCoderUnpackSizes.Alloc(numFolders + 1);
CRecordVector<bool> InStreamUsed;
CRecordVector<bool> OutStreamUsed;
CNum packStreamIndex = 0;
CNum fo;
CInByte2 *inByte = _inByteBack;
for (fo = 0; fo < numFolders; fo++)
{
UInt32 numOutStreams = 0;
UInt32 indexOfMainStream = 0;
UInt32 numPackStreams = 0;
folders.FoCodersDataOffset[fo] = _inByteBack->GetPtr() - startBufPtr;
numOutStreams = 0;
CNum numInStreams = 0;
CNum numCoders = inByte->ReadNum();
for (CNum ci = 0; ci < numCoders; ci++)
{
Byte mainByte = inByte->ReadByte();
if ((mainByte & 0xC0) != 0)
ThrowUnsupported();
unsigned idSize = (mainByte & 0xF);
if (idSize > 8)
ThrowUnsupported();
if (idSize > inByte->GetRem())
ThrowEndOfData();
const Byte *longID = inByte->GetPtr();
UInt64 id = 0;
for (unsigned j = 0; j < idSize; j++)
id = ((id << 8) | longID[j]);
inByte->SkipDataNoCheck(idSize);
if (folders.ParsedMethods.IDs.Size() < 128)
folders.ParsedMethods.IDs.AddToUniqueSorted(id);
CNum coderInStreams = 1;
CNum coderOutStreams = 1;
if ((mainByte & 0x10) != 0)
{
coderInStreams = inByte->ReadNum();
coderOutStreams = inByte->ReadNum();
}
numInStreams += coderInStreams;
if (numInStreams < coderInStreams)
ThrowUnsupported();
numOutStreams += coderOutStreams;
if (numOutStreams < coderOutStreams)
ThrowUnsupported();
if ((mainByte & 0x20) != 0)
{
CNum propsSize = inByte->ReadNum();
if (propsSize > inByte->GetRem())
ThrowEndOfData();
if (id == k_LZMA2 && propsSize == 1)
{
Byte v = *_inByteBack->GetPtr();
if (folders.ParsedMethods.Lzma2Prop < v)
folders.ParsedMethods.Lzma2Prop = v;
}
else if (id == k_LZMA && propsSize == 5)
{
UInt32 dicSize = GetUi32(_inByteBack->GetPtr() + 1);
if (folders.ParsedMethods.LzmaDic < dicSize)
folders.ParsedMethods.LzmaDic = dicSize;
}
inByte->SkipDataNoCheck((size_t)propsSize);
}
}
if (numOutStreams == 1 && numInStreams == 1)
{
indexOfMainStream = 0;
numPackStreams = 1;
}
else
{
UInt32 i;
if (numOutStreams == 0)
ThrowUnsupported();
CNum numBindPairs = numOutStreams - 1;
if (numInStreams < numBindPairs)
ThrowUnsupported();
if (numInStreams >= 256 || numOutStreams >= 256)
ThrowUnsupported();
InStreamUsed.ClearAndSetSize(numInStreams);
for (i = 0; i < numInStreams; i++)
InStreamUsed[i] = false;
OutStreamUsed.ClearAndSetSize(numOutStreams);
for (i = 0; i < numOutStreams; i++)
OutStreamUsed[i] = false;
for (i = 0; i < numBindPairs; i++)
{
CNum index = ReadNum();
if (index >= numInStreams || InStreamUsed[index])
ThrowUnsupported();
InStreamUsed[index] = true;
index = ReadNum();
if (index >= numOutStreams || OutStreamUsed[index])
ThrowUnsupported();
OutStreamUsed[index] = true;
}
numPackStreams = numInStreams - numBindPairs;
if (numPackStreams != 1)
for (i = 0; i < numPackStreams; i++)
inByte->ReadNum(); // PackStreams
for (i = 0; i < numOutStreams; i++)
if (!OutStreamUsed[i])
{
indexOfMainStream = i;
break;
}
if (i == numOutStreams)
ThrowUnsupported();
}
folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
numCodersOutStreams += numOutStreams;
folders.FoStartPackStreamIndex[fo] = packStreamIndex;
packStreamIndex += numPackStreams;
folders.FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;
}
size_t dataSize = _inByteBack->GetPtr() - startBufPtr;
folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
folders.FoStartPackStreamIndex[fo] = packStreamIndex;
folders.FoCodersDataOffset[fo] = _inByteBack->GetPtr() - startBufPtr;
folders.CodersData.CopyFrom(startBufPtr, dataSize);
}
WaitId(NID::kCodersUnpackSize);
folders.CoderUnpackSizes.Alloc(numCodersOutStreams);
for (CNum i = 0; i < numCodersOutStreams; i++)
folders.CoderUnpackSizes[i] = ReadNumber();
for (;;)
{
UInt64 type = ReadID();
if (type == NID::kEnd)
return;
if (type == NID::kCRC)
{
ReadHashDigests(numFolders, folders.FolderCRCs);
continue;
}
SkipData();
}
}
void CInArchive::ReadSubStreamsInfo(
CFolders &folders,
CRecordVector<UInt64> &unpackSizes,
CUInt32DefVector &digests)
{
folders.NumUnpackStreamsVector.Alloc(folders.NumFolders);
CNum i;
for (i = 0; i < folders.NumFolders; i++)
folders.NumUnpackStreamsVector[i] = 1;
UInt64 type;
for (;;)
{
type = ReadID();
if (type == NID::kNumUnpackStream)
{
for (i = 0; i < folders.NumFolders; i++)
folders.NumUnpackStreamsVector[i] = ReadNum();
continue;
}
if (type == NID::kCRC || type == NID::kSize || type == NID::kEnd)
break;
SkipData();
}
if (type == NID::kSize)
{
for (i = 0; i < folders.NumFolders; i++)
{
// v3.13 incorrectly worked with empty folders
// v4.07: we check that folder is empty
CNum numSubstreams = folders.NumUnpackStreamsVector[i];
if (numSubstreams == 0)
continue;
UInt64 sum = 0;
for (CNum j = 1; j < numSubstreams; j++)
{
UInt64 size = ReadNumber();
unpackSizes.Add(size);
sum += size;
if (sum < size)
ThrowIncorrect();
}
UInt64 folderUnpackSize = folders.GetFolderUnpackSize(i);
if (folderUnpackSize < sum)
ThrowIncorrect();
unpackSizes.Add(folderUnpackSize - sum);
}
type = ReadID();
}
else
{
for (i = 0; i < folders.NumFolders; i++)
{
/* v9.26 - v9.29 incorrectly worked:
if (folders.NumUnpackStreamsVector[i] == 0), it threw error */
CNum val = folders.NumUnpackStreamsVector[i];
if (val > 1)
ThrowIncorrect();
if (val == 1)
unpackSizes.Add(folders.GetFolderUnpackSize(i));
}
}
unsigned numDigests = 0;
for (i = 0; i < folders.NumFolders; i++)
{
CNum numSubstreams = folders.NumUnpackStreamsVector[i];
if (numSubstreams != 1 || !folders.FolderCRCs.ValidAndDefined(i))
numDigests += numSubstreams;
}
for (;;)
{
if (type == NID::kEnd)
break;
if (type == NID::kCRC)
{
// CUInt32DefVector digests2;
// ReadHashDigests(numDigests, digests2);
CBoolVector digests2;
ReadBoolVector2(numDigests, digests2);
digests.ClearAndSetSize(unpackSizes.Size());
unsigned k = 0;
unsigned k2 = 0;
for (i = 0; i < folders.NumFolders; i++)
{
CNum numSubstreams = folders.NumUnpackStreamsVector[i];
if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
{
digests.Defs[k] = true;
digests.Vals[k] = folders.FolderCRCs.Vals[i];
k++;
}
else for (CNum j = 0; j < numSubstreams; j++)
{
bool defined = digests2[k2++];
digests.Defs[k] = defined;
UInt32 crc = 0;
if (defined)
crc = ReadUInt32();
digests.Vals[k] = crc;
k++;
}
}
// if (k != unpackSizes.Size()) throw 1234567;
}
else
SkipData();
type = ReadID();
}
if (digests.Defs.Size() != unpackSizes.Size())
{
digests.ClearAndSetSize(unpackSizes.Size());
unsigned k = 0;
for (i = 0; i < folders.NumFolders; i++)
{
CNum numSubstreams = folders.NumUnpackStreamsVector[i];
if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
{
digests.Defs[k] = true;
digests.Vals[k] = folders.FolderCRCs.Vals[i];
k++;
}
else for (CNum j = 0; j < numSubstreams; j++)
{
digests.Defs[k] = false;
digests.Vals[k] = 0;
k++;
}
}
}
}
void CInArchive::ReadStreamsInfo(
const CObjectVector<CByteBuffer> *dataVector,
UInt64 &dataOffset,
CFolders &folders,
CRecordVector<UInt64> &unpackSizes,
CUInt32DefVector &digests)
{
UInt64 type = ReadID();
if (type == NID::kPackInfo)
{
dataOffset = ReadNumber();
ReadPackInfo(folders);
type = ReadID();
}
if (type == NID::kUnpackInfo)
{
ReadUnpackInfo(dataVector, folders);
type = ReadID();
}
if (folders.NumFolders != 0 && !folders.PackPositions)
{
// if there are folders, we need PackPositions also
folders.PackPositions.Alloc(1);
folders.PackPositions[0] = 0;
}
if (type == NID::kSubStreamsInfo)
{
ReadSubStreamsInfo(folders, unpackSizes, digests);
type = ReadID();
}
else
{
folders.NumUnpackStreamsVector.Alloc(folders.NumFolders);
/* If digests.Defs.Size() == 0, it means that there are no crcs.
So we don't need to fill digests with values. */
// digests.Vals.ClearAndSetSize(folders.NumFolders);
// BoolVector_Fill_False(digests.Defs, folders.NumFolders);
for (CNum i = 0; i < folders.NumFolders; i++)
{
folders.NumUnpackStreamsVector[i] = 1;
unpackSizes.Add(folders.GetFolderUnpackSize(i));
// digests.Vals[i] = 0;
}
}
if (type != NID::kEnd)
ThrowIncorrect();
}
void CInArchive::ReadBoolVector(unsigned numItems, CBoolVector &v)
{
v.ClearAndSetSize(numItems);
Byte b = 0;
Byte mask = 0;
bool *p = &v[0];
for (unsigned i = 0; i < numItems; i++)
{
if (mask == 0)
{
b = ReadByte();
mask = 0x80;
}
p[i] = ((b & mask) != 0);
mask >>= 1;
}
}
void CInArchive::ReadBoolVector2(unsigned numItems, CBoolVector &v)
{
Byte allAreDefined = ReadByte();
if (allAreDefined == 0)
{
ReadBoolVector(numItems, v);
return;
}
v.ClearAndSetSize(numItems);
bool *p = &v[0];
for (unsigned i = 0; i < numItems; i++)
p[i] = true;
}
void CInArchive::ReadUInt64DefVector(const CObjectVector<CByteBuffer> &dataVector,
CUInt64DefVector &v, unsigned numItems)
{
ReadBoolVector2(numItems, v.Defs);
CStreamSwitch streamSwitch;
streamSwitch.Set(this, &dataVector);
v.Vals.ClearAndSetSize(numItems);
UInt64 *p = &v.Vals[0];
const bool *defs = &v.Defs[0];
for (unsigned i = 0; i < numItems; i++)
{
UInt64 t = 0;
if (defs[i])
t = ReadUInt64();
p[i] = t;
}
}
HRESULT CInArchive::ReadAndDecodePackedStreams(
DECL_EXTERNAL_CODECS_LOC_VARS
UInt64 baseOffset,
UInt64 &dataOffset, CObjectVector<CByteBuffer> &dataVector
_7Z_DECODER_CRYPRO_VARS_DECL
)
{
CFolders folders;
CRecordVector<UInt64> unpackSizes;
CUInt32DefVector digests;
ReadStreamsInfo(NULL,
dataOffset,
folders,
unpackSizes,
digests);
CDecoder decoder(
#ifdef _ST_MODE
false
#else
true
#endif
);
for (CNum i = 0; i < folders.NumFolders; i++)
{
CByteBuffer &data = dataVector.AddNew();
UInt64 unpackSize64 = folders.GetFolderUnpackSize(i);
size_t unpackSize = (size_t)unpackSize64;
if (unpackSize != unpackSize64)
ThrowUnsupported();
data.Alloc(unpackSize);
CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
outStreamSpec->Init(data, unpackSize);
HRESULT result = decoder.Decode(
EXTERNAL_CODECS_LOC_VARS
_stream, baseOffset + dataOffset,
folders, i,
outStream, NULL
_7Z_DECODER_CRYPRO_VARS
#if !defined(_7ZIP_ST) && !defined(_SFX)
, false, 1
#endif
);
RINOK(result);
if (folders.FolderCRCs.ValidAndDefined(i))
if (CrcCalc(data, unpackSize) != folders.FolderCRCs.Vals[i])
ThrowIncorrect();
}
HeadersSize += folders.PackPositions[folders.NumPackStreams];
return S_OK;
}
HRESULT CInArchive::ReadHeader(
DECL_EXTERNAL_CODECS_LOC_VARS
CDbEx &db
_7Z_DECODER_CRYPRO_VARS_DECL
)
{
UInt64 type = ReadID();
if (type == NID::kArchiveProperties)
{
ReadArchiveProperties(db.ArcInfo);
type = ReadID();
}
CObjectVector<CByteBuffer> dataVector;
if (type == NID::kAdditionalStreamsInfo)
{
HRESULT result = ReadAndDecodePackedStreams(
EXTERNAL_CODECS_LOC_VARS
db.ArcInfo.StartPositionAfterHeader,
db.ArcInfo.DataStartPosition2,
dataVector
_7Z_DECODER_CRYPRO_VARS
);
RINOK(result);
db.ArcInfo.DataStartPosition2 += db.ArcInfo.StartPositionAfterHeader;
type = ReadID();
}
CRecordVector<UInt64> unpackSizes;
CUInt32DefVector digests;
if (type == NID::kMainStreamsInfo)
{
ReadStreamsInfo(&dataVector,
db.ArcInfo.DataStartPosition,
(CFolders &)db,
unpackSizes,
digests);
db.ArcInfo.DataStartPosition += db.ArcInfo.StartPositionAfterHeader;
type = ReadID();
}
db.Files.Clear();
if (type == NID::kFilesInfo)
{
CNum numFiles = ReadNum();
db.Files.ClearAndSetSize(numFiles);
CNum i;
/*
db.Files.Reserve(numFiles);
CNum i;
for (i = 0; i < numFiles; i++)
db.Files.Add(CFileItem());
*/
db.ArcInfo.FileInfoPopIDs.Add(NID::kSize);
// if (!db.PackSizes.IsEmpty())
db.ArcInfo.FileInfoPopIDs.Add(NID::kPackInfo);
if (numFiles > 0 && !digests.Defs.IsEmpty())
db.ArcInfo.FileInfoPopIDs.Add(NID::kCRC);
CBoolVector emptyStreamVector;
BoolVector_Fill_False(emptyStreamVector, (unsigned)numFiles);
CBoolVector emptyFileVector;
CBoolVector antiFileVector;
CNum numEmptyStreams = 0;
for (;;)
{
UInt64 type = ReadID();
if (type == NID::kEnd)
break;
UInt64 size = ReadNumber();
if (size > _inByteBack->GetRem())
ThrowIncorrect();
CStreamSwitch switchProp;
switchProp.Set(this, _inByteBack->GetPtr(), (size_t)size, true);
bool addPropIdToList = true;
bool isKnownType = true;
if (type > ((UInt32)1 << 30))
isKnownType = false;
else switch((UInt32)type)
{
case NID::kName:
{
CStreamSwitch streamSwitch;
streamSwitch.Set(this, &dataVector);
size_t rem = _inByteBack->GetRem();
db.NamesBuf.Alloc(rem);
ReadBytes(db.NamesBuf, rem);
db.NameOffsets.Alloc(db.Files.Size() + 1);
size_t pos = 0;
unsigned i;
for (i = 0; i < db.Files.Size(); i++)
{
size_t curRem = (rem - pos) / 2;
const UInt16 *buf = (const UInt16 *)(db.NamesBuf + pos);
size_t j;
for (j = 0; j < curRem && buf[j] != 0; j++);
if (j == curRem)
ThrowEndOfData();
db.NameOffsets[i] = pos / 2;
pos += j * 2 + 2;
}
db.NameOffsets[i] = pos / 2;
if (pos != rem)
ThereIsHeaderError = true;
break;
}
case NID::kWinAttrib:
{
CBoolVector boolVector;
ReadBoolVector2(db.Files.Size(), boolVector);
CStreamSwitch streamSwitch;
streamSwitch.Set(this, &dataVector);
for (i = 0; i < numFiles; i++)
{
CFileItem &file = db.Files[i];
file.AttribDefined = boolVector[i];
if (file.AttribDefined)
file.Attrib = ReadUInt32();
}
break;
}
/*
case NID::kIsAux:
{
ReadBoolVector(db.Files.Size(), db.IsAux);
break;
}
case NID::kParent:
{
db.IsTree = true;
// CBoolVector boolVector;
// ReadBoolVector2(db.Files.Size(), boolVector);
// CStreamSwitch streamSwitch;
// streamSwitch.Set(this, &dataVector);
CBoolVector boolVector;
ReadBoolVector2(db.Files.Size(), boolVector);
db.ThereAreAltStreams = false;
for (i = 0; i < numFiles; i++)
{
CFileItem &file = db.Files[i];
// file.Parent = -1;
// if (boolVector[i])
file.Parent = (int)ReadUInt32();
file.IsAltStream = !boolVector[i];
if (file.IsAltStream)
db.ThereAreAltStreams = true;
}
break;
}
*/
case NID::kEmptyStream:
{
ReadBoolVector(numFiles, emptyStreamVector);
numEmptyStreams = 0;
for (i = 0; i < (CNum)emptyStreamVector.Size(); i++)
if (emptyStreamVector[i])
numEmptyStreams++;
BoolVector_Fill_False(emptyFileVector, numEmptyStreams);
BoolVector_Fill_False(antiFileVector, numEmptyStreams);
break;
}
case NID::kEmptyFile: ReadBoolVector(numEmptyStreams, emptyFileVector); break;
case NID::kAnti: ReadBoolVector(numEmptyStreams, antiFileVector); break;
case NID::kStartPos: ReadUInt64DefVector(dataVector, db.StartPos, (unsigned)numFiles); break;
case NID::kCTime: ReadUInt64DefVector(dataVector, db.CTime, (unsigned)numFiles); break;
case NID::kATime: ReadUInt64DefVector(dataVector, db.ATime, (unsigned)numFiles); break;
case NID::kMTime: ReadUInt64DefVector(dataVector, db.MTime, (unsigned)numFiles); break;
case NID::kDummy:
{
for (UInt64 j = 0; j < size; j++)
if (ReadByte() != 0)
ThereIsHeaderError = true;
addPropIdToList = false;
break;
}
/*
case NID::kNtSecure:
{
try
{
{
CStreamSwitch streamSwitch;
streamSwitch.Set(this, &dataVector);
UInt32 numDescriptors = ReadUInt32();
size_t offset = 0;
db.SecureOffsets.Clear();
for (i = 0; i < numDescriptors; i++)
{
UInt32 size = ReadUInt32();
db.SecureOffsets.Add(offset);
offset += size;
}
// ThrowIncorrect();;
db.SecureOffsets.Add(offset);
db.SecureBuf.SetCapacity(offset);
for (i = 0; i < numDescriptors; i++)
{
offset = db.SecureOffsets[i];
ReadBytes(db.SecureBuf + offset, db.SecureOffsets[i + 1] - offset);
}
db.SecureIDs.Clear();
for (unsigned i = 0; i < db.Files.Size(); i++)
{
db.SecureIDs.Add(ReadNum());
// db.SecureIDs.Add(ReadUInt32());
}
// ReadUInt32();
if (_inByteBack->GetRem() != 0)
ThrowIncorrect();;
}
}
catch(CInArchiveException &)
{
ThereIsHeaderError = true;
addPropIdToList = isKnownType = false;
db.ClearSecure();
}
break;
}
*/
default:
addPropIdToList = isKnownType = false;
}
if (isKnownType)
{
if (addPropIdToList)
db.ArcInfo.FileInfoPopIDs.Add(type);
}
else
{
db.UnsupportedFeatureWarning = true;
_inByteBack->SkipRem();
}
// SkipData worked incorrectly in some versions before v4.59 (7zVer <= 00.02)
if (_inByteBack->GetRem() != 0)
ThrowIncorrect();
}
type = ReadID(); // Read (NID::kEnd) end of headers
CNum emptyFileIndex = 0;
CNum sizeIndex = 0;
CNum numAntiItems = 0;
for (i = 0; i < numEmptyStreams; i++)
if (antiFileVector[i])
numAntiItems++;
for (i = 0; i < numFiles; i++)
{
CFileItem &file = db.Files[i];
bool isAnti;
file.HasStream = !emptyStreamVector[i];
file.Crc = 0;
if (file.HasStream)
{
file.IsDir = false;
isAnti = false;
file.Size = unpackSizes[sizeIndex];
file.CrcDefined = digests.ValidAndDefined(sizeIndex);
if (file.CrcDefined)
file.Crc = digests.Vals[sizeIndex];
sizeIndex++;
}
else
{
file.IsDir = !emptyFileVector[emptyFileIndex];
isAnti = antiFileVector[emptyFileIndex];
emptyFileIndex++;
file.Size = 0;
file.CrcDefined = false;
}
if (numAntiItems != 0)
db.IsAnti.Add(isAnti);
}
}
db.FillLinks();
/*
if (type != NID::kEnd)
ThrowIncorrect();
if (_inByteBack->GetRem() != 0)
ThrowIncorrect();
*/
return S_OK;
}
void CDbEx::FillLinks()
{
FolderStartFileIndex.ClearAndSetSize(NumFolders);
FileIndexToFolderIndexMap.ClearAndSetSize(Files.Size());
CNum folderIndex = 0;
CNum indexInFolder = 0;
unsigned i;
for (i = 0; i < Files.Size(); i++)
{
bool emptyStream = !Files[i].HasStream;
if (indexInFolder == 0)
{
if (emptyStream)
{
FileIndexToFolderIndexMap[i] = kNumNoIndex;
continue;
}
// v3.13 incorrectly worked with empty folders
// v4.07: we skip empty folders
for (;;)
{
if (folderIndex >= NumFolders)
ThrowIncorrect();
FolderStartFileIndex[folderIndex] = i;
if (NumUnpackStreamsVector[folderIndex] != 0)
break;
folderIndex++;
}
}
FileIndexToFolderIndexMap[i] = folderIndex;
if (emptyStream)
continue;
if (++indexInFolder >= NumUnpackStreamsVector[folderIndex])
{
folderIndex++;
indexInFolder = 0;
}
}
if (indexInFolder != 0)
folderIndex++;
/*
if (indexInFolder != 0)
ThrowIncorrect();
*/
for (;;)
{
if (folderIndex >= NumFolders)
return;
FolderStartFileIndex[folderIndex] = i;
/*
if (NumUnpackStreamsVector[folderIndex] != 0)
ThrowIncorrect();;
*/
folderIndex++;
}
}
HRESULT CInArchive::ReadDatabase2(
DECL_EXTERNAL_CODECS_LOC_VARS
CDbEx &db
_7Z_DECODER_CRYPRO_VARS_DECL
)
{
db.Clear();
db.ArcInfo.StartPosition = _arhiveBeginStreamPosition;
db.ArcInfo.Version.Major = _header[6];
db.ArcInfo.Version.Minor = _header[7];
if (db.ArcInfo.Version.Major != kMajorVersion)
{
// db.UnsupportedVersion = true;
return S_FALSE;
}
UInt64 nextHeaderOffset = Get64(_header + 12);
UInt64 nextHeaderSize = Get64(_header + 20);
UInt32 nextHeaderCRC = Get32(_header + 28);
#ifdef FORMAT_7Z_RECOVERY
UInt32 crcFromArc = Get32(_header + 8);
if (crcFromArc == 0 && nextHeaderOffset == 0 && nextHeaderSize == 0 && nextHeaderCRC == 0)
{
UInt64 cur, fileSize;
RINOK(_stream->Seek(0, STREAM_SEEK_CUR, &cur));
const unsigned kCheckSize = 512;
Byte buf[kCheckSize];
RINOK(_stream->Seek(0, STREAM_SEEK_END, &fileSize));
UInt64 rem = fileSize - cur;
unsigned checkSize = kCheckSize;
if (rem < kCheckSize)
checkSize = (unsigned)(rem);
if (checkSize < 3)
return S_FALSE;
RINOK(_stream->Seek(fileSize - checkSize, STREAM_SEEK_SET, NULL));
RINOK(ReadStream_FALSE(_stream, buf, (size_t)checkSize));
if (buf[checkSize - 1] != 0)
return S_FALSE;
unsigned i;
for (i = checkSize - 2;; i--)
{
if (buf[i] == NID::kEncodedHeader && buf[i + 1] == NID::kPackInfo ||
buf[i] == NID::kHeader && buf[i + 1] == NID::kMainStreamsInfo)
break;
if (i == 0)
return S_FALSE;
}
nextHeaderSize = checkSize - i;
nextHeaderOffset = rem - nextHeaderSize;
nextHeaderCRC = CrcCalc(buf + i, (size_t)nextHeaderSize);
RINOK(_stream->Seek(cur, STREAM_SEEK_SET, NULL));
db.StartHeaderWasRecovered = true;
}
else
#endif
{
// Crc was tested already at signature check
// if (CrcCalc(_header + 12, 20) != crcFromArchive) ThrowIncorrect();
}
db.ArcInfo.StartPositionAfterHeader = _arhiveBeginStreamPosition + kHeaderSize;
db.PhySize = kHeaderSize;
db.IsArc = false;
if ((Int64)nextHeaderOffset < 0 ||
nextHeaderSize > ((UInt64)1 << 62))
return S_FALSE;
if (nextHeaderSize == 0)
{
if (nextHeaderOffset != 0)
return S_FALSE;
db.IsArc = true;
return S_OK;
}
if (!db.StartHeaderWasRecovered)
db.IsArc = true;
HeadersSize += kHeaderSize + nextHeaderSize;
db.PhySize = kHeaderSize + nextHeaderOffset + nextHeaderSize;
if (_fileEndPosition - db.ArcInfo.StartPositionAfterHeader < nextHeaderOffset + nextHeaderSize)
{
db.UnexpectedEnd = true;
return S_FALSE;
}
RINOK(_stream->Seek(nextHeaderOffset, STREAM_SEEK_CUR, NULL));
size_t nextHeaderSize_t = (size_t)nextHeaderSize;
if (nextHeaderSize_t != nextHeaderSize)
return E_OUTOFMEMORY;
CByteBuffer buffer2(nextHeaderSize_t);
RINOK(ReadStream_FALSE(_stream, buffer2, nextHeaderSize_t));
if (CrcCalc(buffer2, nextHeaderSize_t) != nextHeaderCRC)
ThrowIncorrect();
if (!db.StartHeaderWasRecovered)
db.PhySizeWasConfirmed = true;
CStreamSwitch streamSwitch;
streamSwitch.Set(this, buffer2);
CObjectVector<CByteBuffer> dataVector;
UInt64 type = ReadID();
if (type != NID::kHeader)
{
if (type != NID::kEncodedHeader)
ThrowIncorrect();
HRESULT result = ReadAndDecodePackedStreams(
EXTERNAL_CODECS_LOC_VARS
db.ArcInfo.StartPositionAfterHeader,
db.ArcInfo.DataStartPosition2,
dataVector
_7Z_DECODER_CRYPRO_VARS
);
RINOK(result);
if (dataVector.Size() == 0)
return S_OK;
if (dataVector.Size() > 1)
ThrowIncorrect();
streamSwitch.Remove();
streamSwitch.Set(this, dataVector.Front());
if (ReadID() != NID::kHeader)
ThrowIncorrect();
}
db.IsArc = true;
db.HeadersSize = HeadersSize;
return ReadHeader(
EXTERNAL_CODECS_LOC_VARS
db
_7Z_DECODER_CRYPRO_VARS
);
}
HRESULT CInArchive::ReadDatabase(
DECL_EXTERNAL_CODECS_LOC_VARS
CDbEx &db
_7Z_DECODER_CRYPRO_VARS_DECL
)
{
try
{
HRESULT res = ReadDatabase2(
EXTERNAL_CODECS_LOC_VARS db
_7Z_DECODER_CRYPRO_VARS
);
if (ThereIsHeaderError)
db.ThereIsHeaderError = true;
if (res == E_NOTIMPL)
ThrowUnsupported();
return res;
}
catch(CUnsupportedFeatureException &)
{
db.UnsupportedFeatureError = true;
return S_FALSE;
}
catch(CInArchiveException &)
{
db.ThereIsHeaderError = true;
return S_FALSE;
}
}
}}