bool CBondsChecks::Check()
{
BoolVector_Fill_False(_coderUsed, BindInfo->Coders.Size());
if (!CheckCoder(BindInfo->UnpackCoder))
return false;
FOR_VECTOR(i, _coderUsed)
if (!_coderUsed[i])
return false;
return true;
}
void CInArchive::ReadPackInfo(
UInt64 &dataOffset,
CRecordVector<UInt64> &packSizes,
CBoolVector &packCRCsDefined,
CRecordVector<UInt32> &packCRCs)
{
dataOffset = ReadNumber();
CNum numPackStreams = ReadNum();
WaitAttribute(NID::kSize);
packSizes.Clear();
packSizes.Reserve(numPackStreams);
for (CNum i = 0; i < numPackStreams; i++)
packSizes.Add(ReadNumber());
UInt64 type;
for (;;)
{
type = ReadID();
if (type == NID::kEnd)
break;
if (type == NID::kCRC)
{
ReadHashDigests(numPackStreams, packCRCsDefined, packCRCs);
continue;
}
SkipData();
}
if (packCRCsDefined.IsEmpty())
{
BoolVector_Fill_False(packCRCsDefined, numPackStreams);
packCRCs.Reserve(numPackStreams);
packCRCs.Clear();
for (CNum i = 0; i < numPackStreams; i++)
packCRCs.Add(0);
}
}
HRESULT CInArchive::ReadHeader(
DECL_EXTERNAL_CODECS_LOC_VARS
CArchiveDatabaseEx &db
#ifndef _NO_CRYPTO
, ICryptoGetTextPassword *getTextPassword, bool &passwordIsDefined
#endif
)
{
UInt64 type = ReadID();
if (type == NID::kArchiveProperties)
{
ReadArchiveProperties(db.ArchiveInfo);
type = ReadID();
}
CObjectVector<CByteBuffer> dataVector;
if (type == NID::kAdditionalStreamsInfo)
{
HRESULT result = ReadAndDecodePackedStreams(
EXTERNAL_CODECS_LOC_VARS
db.ArchiveInfo.StartPositionAfterHeader,
db.ArchiveInfo.DataStartPosition2,
dataVector
#ifndef _NO_CRYPTO
, getTextPassword, passwordIsDefined
#endif
);
RINOK(result);
db.ArchiveInfo.DataStartPosition2 += db.ArchiveInfo.StartPositionAfterHeader;
type = ReadID();
}
CRecordVector<UInt64> unpackSizes;
CBoolVector digestsDefined;
CRecordVector<UInt32> digests;
if (type == NID::kMainStreamsInfo)
{
ReadStreamsInfo(&dataVector,
db.ArchiveInfo.DataStartPosition,
db.PackSizes,
db.PackCRCsDefined,
db.PackCRCs,
db.Folders,
db.NumUnpackStreamsVector,
unpackSizes,
digestsDefined,
digests);
db.ArchiveInfo.DataStartPosition += db.ArchiveInfo.StartPositionAfterHeader;
type = ReadID();
}
else
{
for (int i = 0; i < db.Folders.Size(); i++)
{
db.NumUnpackStreamsVector.Add(1);
CFolder &folder = db.Folders[i];
unpackSizes.Add(folder.GetUnpackSize());
digestsDefined.Add(folder.UnpackCRCDefined);
digests.Add(folder.UnpackCRC);
}
}
db.Files.Clear();
if (type == NID::kEnd)
return S_OK;
if (type != NID::kFilesInfo)
ThrowIncorrect();
CNum numFiles = ReadNum();
db.Files.Reserve(numFiles);
CNum i;
for (i = 0; i < numFiles; i++)
db.Files.Add(CFileItem());
db.ArchiveInfo.FileInfoPopIDs.Add(NID::kSize);
if (!db.PackSizes.IsEmpty())
db.ArchiveInfo.FileInfoPopIDs.Add(NID::kPackInfo);
if (numFiles > 0 && !digests.IsEmpty())
db.ArchiveInfo.FileInfoPopIDs.Add(NID::kCRC);
CBoolVector emptyStreamVector;
BoolVector_Fill_False(emptyStreamVector, (int)numFiles);
CBoolVector emptyFileVector;
CBoolVector antiFileVector;
CNum numEmptyStreams = 0;
for (;;)
{
UInt64 type = ReadID();
if (type == NID::kEnd)
break;
UInt64 size = ReadNumber();
size_t ppp = _inByteBack->_pos;
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);
for (int i = 0; i < db.Files.Size(); i++)
_inByteBack->ReadString(db.Files[i].Name);
break;
}
case NID::kWinAttributes:
{
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::kEmptyStream:
{
ReadBoolVector(numFiles, emptyStreamVector);
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, (int)numFiles); break;
case NID::kCTime: ReadUInt64DefVector(dataVector, db.CTime, (int)numFiles); break;
case NID::kATime: ReadUInt64DefVector(dataVector, db.ATime, (int)numFiles); break;
case NID::kMTime: ReadUInt64DefVector(dataVector, db.MTime, (int)numFiles); break;
case NID::kDummy:
{
for (UInt64 j = 0; j < size; j++)
if (ReadByte() != 0)
ThrowIncorrect();
addPropIdToList = false;
break;
}
default:
addPropIdToList = isKnownType = false;
}
if (isKnownType)
{
if(addPropIdToList)
db.ArchiveInfo.FileInfoPopIDs.Add(type);
}
else
SkipData(size);
bool checkRecordsSize = (db.ArchiveInfo.Version.Major > 0 ||
db.ArchiveInfo.Version.Minor > 2);
if (checkRecordsSize && _inByteBack->_pos - ppp != size)
ThrowIncorrect();
}
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];
if (file.HasStream)
{
file.IsDir = false;
isAnti = false;
file.Size = unpackSizes[sizeIndex];
file.Crc = digests[sizeIndex];
file.CrcDefined = digestsDefined[sizeIndex];
sizeIndex++;
}
else
{
file.IsDir = !emptyFileVector[emptyFileIndex];
isAnti = antiFileVector[emptyFileIndex];
emptyFileIndex++;
file.Size = 0;
file.CrcDefined = false;
}
if (numAntiItems != 0)
db.IsAnti.Add(isAnti);
}
return S_OK;
}
void CInArchive::ReadSubStreamsInfo(
const CObjectVector<CFolder> &folders,
CRecordVector<CNum> &numUnpackStreamsInFolders,
CRecordVector<UInt64> &unpackSizes,
CBoolVector &digestsDefined,
CRecordVector<UInt32> &digests)
{
numUnpackStreamsInFolders.Clear();
numUnpackStreamsInFolders.Reserve(folders.Size());
UInt64 type;
for (;;)
{
type = ReadID();
if (type == NID::kNumUnpackStream)
{
for (int i = 0; i < folders.Size(); i++)
numUnpackStreamsInFolders.Add(ReadNum());
continue;
}
if (type == NID::kCRC || type == NID::kSize)
break;
if (type == NID::kEnd)
break;
SkipData();
}
if (numUnpackStreamsInFolders.IsEmpty())
for (int i = 0; i < folders.Size(); i++)
numUnpackStreamsInFolders.Add(1);
int i;
for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
{
// v3.13 incorrectly worked with empty folders
// v4.07: we check that folder is empty
CNum numSubstreams = numUnpackStreamsInFolders[i];
if (numSubstreams == 0)
continue;
UInt64 sum = 0;
for (CNum j = 1; j < numSubstreams; j++)
if (type == NID::kSize)
{
UInt64 size = ReadNumber();
unpackSizes.Add(size);
sum += size;
}
unpackSizes.Add(folders[i].GetUnpackSize() - sum);
}
if (type == NID::kSize)
type = ReadID();
int numDigests = 0;
int numDigestsTotal = 0;
for (i = 0; i < folders.Size(); i++)
{
CNum numSubstreams = numUnpackStreamsInFolders[i];
if (numSubstreams != 1 || !folders[i].UnpackCRCDefined)
numDigests += numSubstreams;
numDigestsTotal += numSubstreams;
}
for (;;)
{
if (type == NID::kCRC)
{
CBoolVector digestsDefined2;
CRecordVector<UInt32> digests2;
ReadHashDigests(numDigests, digestsDefined2, digests2);
int digestIndex = 0;
for (i = 0; i < folders.Size(); i++)
{
CNum numSubstreams = numUnpackStreamsInFolders[i];
const CFolder &folder = folders[i];
if (numSubstreams == 1 && folder.UnpackCRCDefined)
{
digestsDefined.Add(true);
digests.Add(folder.UnpackCRC);
}
else
for (CNum j = 0; j < numSubstreams; j++, digestIndex++)
{
digestsDefined.Add(digestsDefined2[digestIndex]);
digests.Add(digests2[digestIndex]);
}
}
}
else if (type == NID::kEnd)
{
if (digestsDefined.IsEmpty())
{
BoolVector_Fill_False(digestsDefined, numDigestsTotal);
digests.Clear();
for (int i = 0; i < numDigestsTotal; i++)
digests.Add(0);
}
return;
}
else
SkipData();
type = ReadID();
}
}