/* 7zArcIn.c -- 7z Input functions | |
2018-07-04 : Igor Pavlov : Public domain */ | |
#include "Precomp.h" | |
#include <string.h> | |
#include "7z.h" | |
#include "7zBuf.h" | |
#include "7zCrc.h" | |
#include "CpuArch.h" | |
#define MY_ALLOC(T, p, size, alloc) { \ | |
if ((p = (T *)ISzAlloc_Alloc(alloc, (size) * sizeof(T))) == NULL) return SZ_ERROR_MEM; } | |
#define MY_ALLOC_ZE(T, p, size, alloc) { if ((size) == 0) p = NULL; else MY_ALLOC(T, p, size, alloc) } | |
#define MY_ALLOC_AND_CPY(to, size, from, alloc) \ | |
{ MY_ALLOC(Byte, to, size, alloc); memcpy(to, from, size); } | |
#define MY_ALLOC_ZE_AND_CPY(to, size, from, alloc) \ | |
{ if ((size) == 0) p = NULL; else { MY_ALLOC_AND_CPY(to, size, from, alloc) } } | |
#define k7zMajorVersion 0 | |
enum EIdEnum | |
{ | |
k7zIdEnd, | |
k7zIdHeader, | |
k7zIdArchiveProperties, | |
k7zIdAdditionalStreamsInfo, | |
k7zIdMainStreamsInfo, | |
k7zIdFilesInfo, | |
k7zIdPackInfo, | |
k7zIdUnpackInfo, | |
k7zIdSubStreamsInfo, | |
k7zIdSize, | |
k7zIdCRC, | |
k7zIdFolder, | |
k7zIdCodersUnpackSize, | |
k7zIdNumUnpackStream, | |
k7zIdEmptyStream, | |
k7zIdEmptyFile, | |
k7zIdAnti, | |
k7zIdName, | |
k7zIdCTime, | |
k7zIdATime, | |
k7zIdMTime, | |
k7zIdWinAttrib, | |
k7zIdComment, | |
k7zIdEncodedHeader, | |
k7zIdStartPos, | |
k7zIdDummy | |
// k7zNtSecure, | |
// k7zParent, | |
// k7zIsReal | |
}; | |
const Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C}; | |
#define SzBitUi32s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; } | |
static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAllocPtr alloc) | |
{ | |
if (num == 0) | |
{ | |
p->Defs = NULL; | |
p->Vals = NULL; | |
} | |
else | |
{ | |
MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc); | |
MY_ALLOC(UInt32, p->Vals, num, alloc); | |
} | |
return SZ_OK; | |
} | |
void SzBitUi32s_Free(CSzBitUi32s *p, ISzAllocPtr alloc) | |
{ | |
ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL; | |
ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL; | |
} | |
#define SzBitUi64s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; } | |
void SzBitUi64s_Free(CSzBitUi64s *p, ISzAllocPtr alloc) | |
{ | |
ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL; | |
ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL; | |
} | |
static void SzAr_Init(CSzAr *p) | |
{ | |
p->NumPackStreams = 0; | |
p->NumFolders = 0; | |
p->PackPositions = NULL; | |
SzBitUi32s_Init(&p->FolderCRCs); | |
p->FoCodersOffsets = NULL; | |
p->FoStartPackStreamIndex = NULL; | |
p->FoToCoderUnpackSizes = NULL; | |
p->FoToMainUnpackSizeIndex = NULL; | |
p->CoderUnpackSizes = NULL; | |
p->CodersData = NULL; | |
} | |
static void SzAr_Free(CSzAr *p, ISzAllocPtr alloc) | |
{ | |
ISzAlloc_Free(alloc, p->PackPositions); | |
SzBitUi32s_Free(&p->FolderCRCs, alloc); | |
ISzAlloc_Free(alloc, p->FoCodersOffsets); | |
ISzAlloc_Free(alloc, p->FoStartPackStreamIndex); | |
ISzAlloc_Free(alloc, p->FoToCoderUnpackSizes); | |
ISzAlloc_Free(alloc, p->FoToMainUnpackSizeIndex); | |
ISzAlloc_Free(alloc, p->CoderUnpackSizes); | |
ISzAlloc_Free(alloc, p->CodersData); | |
SzAr_Init(p); | |
} | |
void SzArEx_Init(CSzArEx *p) | |
{ | |
SzAr_Init(&p->db); | |
p->NumFiles = 0; | |
p->dataPos = 0; | |
p->UnpackPositions = NULL; | |
p->IsDirs = NULL; | |
p->FolderToFile = NULL; | |
p->FileToFolder = NULL; | |
p->FileNameOffsets = NULL; | |
p->FileNames = NULL; | |
SzBitUi32s_Init(&p->CRCs); | |
SzBitUi32s_Init(&p->Attribs); | |
// SzBitUi32s_Init(&p->Parents); | |
SzBitUi64s_Init(&p->MTime); | |
SzBitUi64s_Init(&p->CTime); | |
} | |
void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc) | |
{ | |
ISzAlloc_Free(alloc, p->UnpackPositions); | |
ISzAlloc_Free(alloc, p->IsDirs); | |
ISzAlloc_Free(alloc, p->FolderToFile); | |
ISzAlloc_Free(alloc, p->FileToFolder); | |
ISzAlloc_Free(alloc, p->FileNameOffsets); | |
ISzAlloc_Free(alloc, p->FileNames); | |
SzBitUi32s_Free(&p->CRCs, alloc); | |
SzBitUi32s_Free(&p->Attribs, alloc); | |
// SzBitUi32s_Free(&p->Parents, alloc); | |
SzBitUi64s_Free(&p->MTime, alloc); | |
SzBitUi64s_Free(&p->CTime, alloc); | |
SzAr_Free(&p->db, alloc); | |
SzArEx_Init(p); | |
} | |
static int TestSignatureCandidate(const Byte *testBytes) | |
{ | |
unsigned i; | |
for (i = 0; i < k7zSignatureSize; i++) | |
if (testBytes[i] != k7zSignature[i]) | |
return 0; | |
return 1; | |
} | |
#define SzData_Clear(p) { (p)->Data = NULL; (p)->Size = 0; } | |
#define SZ_READ_BYTE_SD(_sd_, dest) if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; (_sd_)->Size--; dest = *(_sd_)->Data++; | |
#define SZ_READ_BYTE(dest) SZ_READ_BYTE_SD(sd, dest) | |
#define SZ_READ_BYTE_2(dest) if (sd.Size == 0) return SZ_ERROR_ARCHIVE; sd.Size--; dest = *sd.Data++; | |
#define SKIP_DATA(sd, size) { sd->Size -= (size_t)(size); sd->Data += (size_t)(size); } | |
#define SKIP_DATA2(sd, size) { sd.Size -= (size_t)(size); sd.Data += (size_t)(size); } | |
#define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \ | |
dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4); | |
static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value) | |
{ | |
Byte firstByte, mask; | |
unsigned i; | |
UInt32 v; | |
SZ_READ_BYTE(firstByte); | |
if ((firstByte & 0x80) == 0) | |
{ | |
*value = firstByte; | |
return SZ_OK; | |
} | |
SZ_READ_BYTE(v); | |
if ((firstByte & 0x40) == 0) | |
{ | |
*value = (((UInt32)firstByte & 0x3F) << 8) | v; | |
return SZ_OK; | |
} | |
SZ_READ_BYTE(mask); | |
*value = v | ((UInt32)mask << 8); | |
mask = 0x20; | |
for (i = 2; i < 8; i++) | |
{ | |
Byte b; | |
if ((firstByte & mask) == 0) | |
{ | |
UInt64 highPart = (unsigned)firstByte & (unsigned)(mask - 1); | |
*value |= (highPart << (8 * i)); | |
return SZ_OK; | |
} | |
SZ_READ_BYTE(b); | |
*value |= ((UInt64)b << (8 * i)); | |
mask >>= 1; | |
} | |
return SZ_OK; | |
} | |
static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value) | |
{ | |
Byte firstByte; | |
UInt64 value64; | |
if (sd->Size == 0) | |
return SZ_ERROR_ARCHIVE; | |
firstByte = *sd->Data; | |
if ((firstByte & 0x80) == 0) | |
{ | |
*value = firstByte; | |
sd->Data++; | |
sd->Size--; | |
return SZ_OK; | |
} | |
RINOK(ReadNumber(sd, &value64)); | |
if (value64 >= (UInt32)0x80000000 - 1) | |
return SZ_ERROR_UNSUPPORTED; | |
if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4))) | |
return SZ_ERROR_UNSUPPORTED; | |
*value = (UInt32)value64; | |
return SZ_OK; | |
} | |
#define ReadID(sd, value) ReadNumber(sd, value) | |
static SRes SkipData(CSzData *sd) | |
{ | |
UInt64 size; | |
RINOK(ReadNumber(sd, &size)); | |
if (size > sd->Size) | |
return SZ_ERROR_ARCHIVE; | |
SKIP_DATA(sd, size); | |
return SZ_OK; | |
} | |
static SRes WaitId(CSzData *sd, UInt32 id) | |
{ | |
for (;;) | |
{ | |
UInt64 type; | |
RINOK(ReadID(sd, &type)); | |
if (type == id) | |
return SZ_OK; | |
if (type == k7zIdEnd) | |
return SZ_ERROR_ARCHIVE; | |
RINOK(SkipData(sd)); | |
} | |
} | |
static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v) | |
{ | |
UInt32 numBytes = (numItems + 7) >> 3; | |
if (numBytes > sd->Size) | |
return SZ_ERROR_ARCHIVE; | |
*v = sd->Data; | |
SKIP_DATA(sd, numBytes); | |
return SZ_OK; | |
} | |
static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems) | |
{ | |
Byte b = 0; | |
unsigned m = 0; | |
UInt32 sum = 0; | |
for (; numItems != 0; numItems--) | |
{ | |
if (m == 0) | |
{ | |
b = *bits++; | |
m = 8; | |
} | |
m--; | |
sum += ((b >> m) & 1); | |
} | |
return sum; | |
} | |
static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAllocPtr alloc) | |
{ | |
Byte allAreDefined; | |
Byte *v2; | |
UInt32 numBytes = (numItems + 7) >> 3; | |
*v = NULL; | |
SZ_READ_BYTE(allAreDefined); | |
if (numBytes == 0) | |
return SZ_OK; | |
if (allAreDefined == 0) | |
{ | |
if (numBytes > sd->Size) | |
return SZ_ERROR_ARCHIVE; | |
MY_ALLOC_AND_CPY(*v, numBytes, sd->Data, alloc); | |
SKIP_DATA(sd, numBytes); | |
return SZ_OK; | |
} | |
MY_ALLOC(Byte, *v, numBytes, alloc); | |
v2 = *v; | |
memset(v2, 0xFF, (size_t)numBytes); | |
{ | |
unsigned numBits = (unsigned)numItems & 7; | |
if (numBits != 0) | |
v2[(size_t)numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits)); | |
} | |
return SZ_OK; | |
} | |
static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc) | |
{ | |
UInt32 i; | |
CSzData sd; | |
UInt32 *vals; | |
const Byte *defs; | |
MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc); | |
sd = *sd2; | |
defs = crcs->Defs; | |
vals = crcs->Vals; | |
for (i = 0; i < numItems; i++) | |
if (SzBitArray_Check(defs, i)) | |
{ | |
SZ_READ_32(vals[i]); | |
} | |
else | |
vals[i] = 0; | |
*sd2 = sd; | |
return SZ_OK; | |
} | |
static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc) | |
{ | |
SzBitUi32s_Free(crcs, alloc); | |
RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc)); | |
return ReadUi32s(sd, numItems, crcs, alloc); | |
} | |
static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems) | |
{ | |
Byte allAreDefined; | |
UInt32 numDefined = numItems; | |
SZ_READ_BYTE(allAreDefined); | |
if (!allAreDefined) | |
{ | |
size_t numBytes = (numItems + 7) >> 3; | |
if (numBytes > sd->Size) | |
return SZ_ERROR_ARCHIVE; | |
numDefined = CountDefinedBits(sd->Data, numItems); | |
SKIP_DATA(sd, numBytes); | |
} | |
if (numDefined > (sd->Size >> 2)) | |
return SZ_ERROR_ARCHIVE; | |
SKIP_DATA(sd, (size_t)numDefined * 4); | |
return SZ_OK; | |
} | |
static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAllocPtr alloc) | |
{ | |
RINOK(SzReadNumber32(sd, &p->NumPackStreams)); | |
RINOK(WaitId(sd, k7zIdSize)); | |
MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc); | |
{ | |
UInt64 sum = 0; | |
UInt32 i; | |
UInt32 numPackStreams = p->NumPackStreams; | |
for (i = 0; i < numPackStreams; i++) | |
{ | |
UInt64 packSize; | |
p->PackPositions[i] = sum; | |
RINOK(ReadNumber(sd, &packSize)); | |
sum += packSize; | |
if (sum < packSize) | |
return SZ_ERROR_ARCHIVE; | |
} | |
p->PackPositions[i] = sum; | |
} | |
for (;;) | |
{ | |
UInt64 type; | |
RINOK(ReadID(sd, &type)); | |
if (type == k7zIdEnd) | |
return SZ_OK; | |
if (type == k7zIdCRC) | |
{ | |
/* CRC of packed streams is unused now */ | |
RINOK(SkipBitUi32s(sd, p->NumPackStreams)); | |
continue; | |
} | |
RINOK(SkipData(sd)); | |
} | |
} | |
/* | |
static SRes SzReadSwitch(CSzData *sd) | |
{ | |
Byte external; | |
RINOK(SzReadByte(sd, &external)); | |
return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED; | |
} | |
*/ | |
#define k_NumCodersStreams_in_Folder_MAX (SZ_NUM_BONDS_IN_FOLDER_MAX + SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX) | |
SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd) | |
{ | |
UInt32 numCoders, i; | |
UInt32 numInStreams = 0; | |
const Byte *dataStart = sd->Data; | |
f->NumCoders = 0; | |
f->NumBonds = 0; | |
f->NumPackStreams = 0; | |
f->UnpackStream = 0; | |
RINOK(SzReadNumber32(sd, &numCoders)); | |
if (numCoders == 0 || numCoders > SZ_NUM_CODERS_IN_FOLDER_MAX) | |
return SZ_ERROR_UNSUPPORTED; | |
for (i = 0; i < numCoders; i++) | |
{ | |
Byte mainByte; | |
CSzCoderInfo *coder = f->Coders + i; | |
unsigned idSize, j; | |
UInt64 id; | |
SZ_READ_BYTE(mainByte); | |
if ((mainByte & 0xC0) != 0) | |
return SZ_ERROR_UNSUPPORTED; | |
idSize = (unsigned)(mainByte & 0xF); | |
if (idSize > sizeof(id)) | |
return SZ_ERROR_UNSUPPORTED; | |
if (idSize > sd->Size) | |
return SZ_ERROR_ARCHIVE; | |
id = 0; | |
for (j = 0; j < idSize; j++) | |
{ | |
id = ((id << 8) | *sd->Data); | |
sd->Data++; | |
sd->Size--; | |
} | |
if (id > (UInt32)0xFFFFFFFF) | |
return SZ_ERROR_UNSUPPORTED; | |
coder->MethodID = (UInt32)id; | |
coder->NumStreams = 1; | |
coder->PropsOffset = 0; | |
coder->PropsSize = 0; | |
if ((mainByte & 0x10) != 0) | |
{ | |
UInt32 numStreams; | |
RINOK(SzReadNumber32(sd, &numStreams)); | |
if (numStreams > k_NumCodersStreams_in_Folder_MAX) | |
return SZ_ERROR_UNSUPPORTED; | |
coder->NumStreams = (Byte)numStreams; | |
RINOK(SzReadNumber32(sd, &numStreams)); | |
if (numStreams != 1) | |
return SZ_ERROR_UNSUPPORTED; | |
} | |
numInStreams += coder->NumStreams; | |
if (numInStreams > k_NumCodersStreams_in_Folder_MAX) | |
return SZ_ERROR_UNSUPPORTED; | |
if ((mainByte & 0x20) != 0) | |
{ | |
UInt32 propsSize = 0; | |
RINOK(SzReadNumber32(sd, &propsSize)); | |
if (propsSize > sd->Size) | |
return SZ_ERROR_ARCHIVE; | |
if (propsSize >= 0x80) | |
return SZ_ERROR_UNSUPPORTED; | |
coder->PropsOffset = sd->Data - dataStart; | |
coder->PropsSize = (Byte)propsSize; | |
sd->Data += (size_t)propsSize; | |
sd->Size -= (size_t)propsSize; | |
} | |
} | |
/* | |
if (numInStreams == 1 && numCoders == 1) | |
{ | |
f->NumPackStreams = 1; | |
f->PackStreams[0] = 0; | |
} | |
else | |
*/ | |
{ | |
Byte streamUsed[k_NumCodersStreams_in_Folder_MAX]; | |
UInt32 numBonds, numPackStreams; | |
numBonds = numCoders - 1; | |
if (numInStreams < numBonds) | |
return SZ_ERROR_ARCHIVE; | |
if (numBonds > SZ_NUM_BONDS_IN_FOLDER_MAX) | |
return SZ_ERROR_UNSUPPORTED; | |
f->NumBonds = numBonds; | |
numPackStreams = numInStreams - numBonds; | |
if (numPackStreams > SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX) | |
return SZ_ERROR_UNSUPPORTED; | |
f->NumPackStreams = numPackStreams; | |
for (i = 0; i < numInStreams; i++) | |
streamUsed[i] = False; | |
if (numBonds != 0) | |
{ | |
Byte coderUsed[SZ_NUM_CODERS_IN_FOLDER_MAX]; | |
for (i = 0; i < numCoders; i++) | |
coderUsed[i] = False; | |
for (i = 0; i < numBonds; i++) | |
{ | |
CSzBond *bp = f->Bonds + i; | |
RINOK(SzReadNumber32(sd, &bp->InIndex)); | |
if (bp->InIndex >= numInStreams || streamUsed[bp->InIndex]) | |
return SZ_ERROR_ARCHIVE; | |
streamUsed[bp->InIndex] = True; | |
RINOK(SzReadNumber32(sd, &bp->OutIndex)); | |
if (bp->OutIndex >= numCoders || coderUsed[bp->OutIndex]) | |
return SZ_ERROR_ARCHIVE; | |
coderUsed[bp->OutIndex] = True; | |
} | |
for (i = 0; i < numCoders; i++) | |
if (!coderUsed[i]) | |
{ | |
f->UnpackStream = i; | |
break; | |
} | |
if (i == numCoders) | |
return SZ_ERROR_ARCHIVE; | |
} | |
if (numPackStreams == 1) | |
{ | |
for (i = 0; i < numInStreams; i++) | |
if (!streamUsed[i]) | |
break; | |
if (i == numInStreams) | |
return SZ_ERROR_ARCHIVE; | |
f->PackStreams[0] = i; | |
} | |
else | |
for (i = 0; i < numPackStreams; i++) | |
{ | |
UInt32 index; | |
RINOK(SzReadNumber32(sd, &index)); | |
if (index >= numInStreams || streamUsed[index]) | |
return SZ_ERROR_ARCHIVE; | |
streamUsed[index] = True; | |
f->PackStreams[i] = index; | |
} | |
} | |
f->NumCoders = numCoders; | |
return SZ_OK; | |
} | |
static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num) | |
{ | |
CSzData sd; | |
sd = *sd2; | |
for (; num != 0; num--) | |
{ | |
Byte firstByte, mask; | |
unsigned i; | |
SZ_READ_BYTE_2(firstByte); | |
if ((firstByte & 0x80) == 0) | |
continue; | |
if ((firstByte & 0x40) == 0) | |
{ | |
if (sd.Size == 0) | |
return SZ_ERROR_ARCHIVE; | |
sd.Size--; | |
sd.Data++; | |
continue; | |
} | |
mask = 0x20; | |
for (i = 2; i < 8 && (firstByte & mask) != 0; i++) | |
mask >>= 1; | |
if (i > sd.Size) | |
return SZ_ERROR_ARCHIVE; | |
SKIP_DATA2(sd, i); | |
} | |
*sd2 = sd; | |
return SZ_OK; | |
} | |
#define k_Scan_NumCoders_MAX 64 | |
#define k_Scan_NumCodersStreams_in_Folder_MAX 64 | |
static SRes ReadUnpackInfo(CSzAr *p, | |
CSzData *sd2, | |
UInt32 numFoldersMax, | |
const CBuf *tempBufs, UInt32 numTempBufs, | |
ISzAllocPtr alloc) | |
{ | |
CSzData sd; | |
UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex; | |
const Byte *startBufPtr; | |
Byte external; | |
RINOK(WaitId(sd2, k7zIdFolder)); | |
RINOK(SzReadNumber32(sd2, &numFolders)); | |
if (numFolders > numFoldersMax) | |
return SZ_ERROR_UNSUPPORTED; | |
p->NumFolders = numFolders; | |
SZ_READ_BYTE_SD(sd2, external); | |
if (external == 0) | |
sd = *sd2; | |
else | |
{ | |
UInt32 index; | |
RINOK(SzReadNumber32(sd2, &index)); | |
if (index >= numTempBufs) | |
return SZ_ERROR_ARCHIVE; | |
sd.Data = tempBufs[index].data; | |
sd.Size = tempBufs[index].size; | |
} | |
MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc); | |
MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc); | |
MY_ALLOC(UInt32, p->FoToCoderUnpackSizes, (size_t)numFolders + 1, alloc); | |
MY_ALLOC(Byte, p->FoToMainUnpackSizeIndex, (size_t)numFolders, alloc); | |
startBufPtr = sd.Data; | |
packStreamIndex = 0; | |
numCodersOutStreams = 0; | |
for (fo = 0; fo < numFolders; fo++) | |
{ | |
UInt32 numCoders, ci, numInStreams = 0; | |
p->FoCodersOffsets[fo] = sd.Data - startBufPtr; | |
RINOK(SzReadNumber32(&sd, &numCoders)); | |
if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX) | |
return SZ_ERROR_UNSUPPORTED; | |
for (ci = 0; ci < numCoders; ci++) | |
{ | |
Byte mainByte; | |
unsigned idSize; | |
UInt32 coderInStreams; | |
SZ_READ_BYTE_2(mainByte); | |
if ((mainByte & 0xC0) != 0) | |
return SZ_ERROR_UNSUPPORTED; | |
idSize = (mainByte & 0xF); | |
if (idSize > 8) | |
return SZ_ERROR_UNSUPPORTED; | |
if (idSize > sd.Size) | |
return SZ_ERROR_ARCHIVE; | |
SKIP_DATA2(sd, idSize); | |
coderInStreams = 1; | |
if ((mainByte & 0x10) != 0) | |
{ | |
UInt32 coderOutStreams; | |
RINOK(SzReadNumber32(&sd, &coderInStreams)); | |
RINOK(SzReadNumber32(&sd, &coderOutStreams)); | |
if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX || coderOutStreams != 1) | |
return SZ_ERROR_UNSUPPORTED; | |
} | |
numInStreams += coderInStreams; | |
if ((mainByte & 0x20) != 0) | |
{ | |
UInt32 propsSize; | |
RINOK(SzReadNumber32(&sd, &propsSize)); | |
if (propsSize > sd.Size) | |
return SZ_ERROR_ARCHIVE; | |
SKIP_DATA2(sd, propsSize); | |
} | |
} | |
{ | |
UInt32 indexOfMainStream = 0; | |
UInt32 numPackStreams = 1; | |
if (numCoders != 1 || numInStreams != 1) | |
{ | |
Byte streamUsed[k_Scan_NumCodersStreams_in_Folder_MAX]; | |
Byte coderUsed[k_Scan_NumCoders_MAX]; | |
UInt32 i; | |
UInt32 numBonds = numCoders - 1; | |
if (numInStreams < numBonds) | |
return SZ_ERROR_ARCHIVE; | |
if (numInStreams > k_Scan_NumCodersStreams_in_Folder_MAX) | |
return SZ_ERROR_UNSUPPORTED; | |
for (i = 0; i < numInStreams; i++) | |
streamUsed[i] = False; | |
for (i = 0; i < numCoders; i++) | |
coderUsed[i] = False; | |
for (i = 0; i < numBonds; i++) | |
{ | |
UInt32 index; | |
RINOK(SzReadNumber32(&sd, &index)); | |
if (index >= numInStreams || streamUsed[index]) | |
return SZ_ERROR_ARCHIVE; | |
streamUsed[index] = True; | |
RINOK(SzReadNumber32(&sd, &index)); | |
if (index >= numCoders || coderUsed[index]) | |
return SZ_ERROR_ARCHIVE; | |
coderUsed[index] = True; | |
} | |
numPackStreams = numInStreams - numBonds; | |
if (numPackStreams != 1) | |
for (i = 0; i < numPackStreams; i++) | |
{ | |
UInt32 index; | |
RINOK(SzReadNumber32(&sd, &index)); | |
if (index >= numInStreams || streamUsed[index]) | |
return SZ_ERROR_ARCHIVE; | |
streamUsed[index] = True; | |
} | |
for (i = 0; i < numCoders; i++) | |
if (!coderUsed[i]) | |
{ | |
indexOfMainStream = i; | |
break; | |
} | |
if (i == numCoders) | |
return SZ_ERROR_ARCHIVE; | |
} | |
p->FoStartPackStreamIndex[fo] = packStreamIndex; | |
p->FoToCoderUnpackSizes[fo] = numCodersOutStreams; | |
p->FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream; | |
numCodersOutStreams += numCoders; | |
if (numCodersOutStreams < numCoders) | |
return SZ_ERROR_UNSUPPORTED; | |
if (numPackStreams > p->NumPackStreams - packStreamIndex) | |
return SZ_ERROR_ARCHIVE; | |
packStreamIndex += numPackStreams; | |
} | |
} | |
p->FoToCoderUnpackSizes[fo] = numCodersOutStreams; | |
{ | |
size_t dataSize = sd.Data - startBufPtr; | |
p->FoStartPackStreamIndex[fo] = packStreamIndex; | |
p->FoCodersOffsets[fo] = dataSize; | |
MY_ALLOC_ZE_AND_CPY(p->CodersData, dataSize, startBufPtr, alloc); | |
} | |
if (external != 0) | |
{ | |
if (sd.Size != 0) | |
return SZ_ERROR_ARCHIVE; | |
sd = *sd2; | |
} | |
RINOK(WaitId(&sd, k7zIdCodersUnpackSize)); | |
MY_ALLOC_ZE(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc); | |
{ | |
UInt32 i; | |
for (i = 0; i < numCodersOutStreams; i++) | |
{ | |
RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i)); | |
} | |
} | |
for (;;) | |
{ | |
UInt64 type; | |
RINOK(ReadID(&sd, &type)); | |
if (type == k7zIdEnd) | |
{ | |
*sd2 = sd; | |
return SZ_OK; | |
} | |
if (type == k7zIdCRC) | |
{ | |
RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc)); | |
continue; | |
} | |
RINOK(SkipData(&sd)); | |
} | |
} | |
UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex) | |
{ | |
return p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex] + p->FoToMainUnpackSizeIndex[folderIndex]]; | |
} | |
typedef struct | |
{ | |
UInt32 NumTotalSubStreams; | |
UInt32 NumSubDigests; | |
CSzData sdNumSubStreams; | |
CSzData sdSizes; | |
CSzData sdCRCs; | |
} CSubStreamInfo; | |
static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi) | |
{ | |
UInt64 type = 0; | |
UInt32 numSubDigests = 0; | |
UInt32 numFolders = p->NumFolders; | |
UInt32 numUnpackStreams = numFolders; | |
UInt32 numUnpackSizesInData = 0; | |
for (;;) | |
{ | |
RINOK(ReadID(sd, &type)); | |
if (type == k7zIdNumUnpackStream) | |
{ | |
UInt32 i; | |
ssi->sdNumSubStreams.Data = sd->Data; | |
numUnpackStreams = 0; | |
numSubDigests = 0; | |
for (i = 0; i < numFolders; i++) | |
{ | |
UInt32 numStreams; | |
RINOK(SzReadNumber32(sd, &numStreams)); | |
if (numUnpackStreams > numUnpackStreams + numStreams) | |
return SZ_ERROR_UNSUPPORTED; | |
numUnpackStreams += numStreams; | |
if (numStreams != 0) | |
numUnpackSizesInData += (numStreams - 1); | |
if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i)) | |
numSubDigests += numStreams; | |
} | |
ssi->sdNumSubStreams.Size = sd->Data - ssi->sdNumSubStreams.Data; | |
continue; | |
} | |
if (type == k7zIdCRC || type == k7zIdSize || type == k7zIdEnd) | |
break; | |
RINOK(SkipData(sd)); | |
} | |
if (!ssi->sdNumSubStreams.Data) | |
{ | |
numSubDigests = numFolders; | |
if (p->FolderCRCs.Defs) | |
numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders); | |
} | |
ssi->NumTotalSubStreams = numUnpackStreams; | |
ssi->NumSubDigests = numSubDigests; | |
if (type == k7zIdSize) | |
{ | |
ssi->sdSizes.Data = sd->Data; | |
RINOK(SkipNumbers(sd, numUnpackSizesInData)); | |
ssi->sdSizes.Size = sd->Data - ssi->sdSizes.Data; | |
RINOK(ReadID(sd, &type)); | |
} | |
for (;;) | |
{ | |
if (type == k7zIdEnd) | |
return SZ_OK; | |
if (type == k7zIdCRC) | |
{ | |
ssi->sdCRCs.Data = sd->Data; | |
RINOK(SkipBitUi32s(sd, numSubDigests)); | |
ssi->sdCRCs.Size = sd->Data - ssi->sdCRCs.Data; | |
} | |
else | |
{ | |
RINOK(SkipData(sd)); | |
} | |
RINOK(ReadID(sd, &type)); | |
} | |
} | |
static SRes SzReadStreamsInfo(CSzAr *p, | |
CSzData *sd, | |
UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs, | |
UInt64 *dataOffset, | |
CSubStreamInfo *ssi, | |
ISzAllocPtr alloc) | |
{ | |
UInt64 type; | |
SzData_Clear(&ssi->sdSizes); | |
SzData_Clear(&ssi->sdCRCs); | |
SzData_Clear(&ssi->sdNumSubStreams); | |
*dataOffset = 0; | |
RINOK(ReadID(sd, &type)); | |
if (type == k7zIdPackInfo) | |
{ | |
RINOK(ReadNumber(sd, dataOffset)); | |
RINOK(ReadPackInfo(p, sd, alloc)); | |
RINOK(ReadID(sd, &type)); | |
} | |
if (type == k7zIdUnpackInfo) | |
{ | |
RINOK(ReadUnpackInfo(p, sd, numFoldersMax, tempBufs, numTempBufs, alloc)); | |
RINOK(ReadID(sd, &type)); | |
} | |
if (type == k7zIdSubStreamsInfo) | |
{ | |
RINOK(ReadSubStreamsInfo(p, sd, ssi)); | |
RINOK(ReadID(sd, &type)); | |
} | |
else | |
{ | |
ssi->NumTotalSubStreams = p->NumFolders; | |
// ssi->NumSubDigests = 0; | |
} | |
return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED); | |
} | |
static SRes SzReadAndDecodePackedStreams( | |
ILookInStream *inStream, | |
CSzData *sd, | |
CBuf *tempBufs, | |
UInt32 numFoldersMax, | |
UInt64 baseOffset, | |
CSzAr *p, | |
ISzAllocPtr allocTemp) | |
{ | |
UInt64 dataStartPos; | |
UInt32 fo; | |
CSubStreamInfo ssi; | |
RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp)); | |
dataStartPos += baseOffset; | |
if (p->NumFolders == 0) | |
return SZ_ERROR_ARCHIVE; | |
for (fo = 0; fo < p->NumFolders; fo++) | |
Buf_Init(tempBufs + fo); | |
for (fo = 0; fo < p->NumFolders; fo++) | |
{ | |
CBuf *tempBuf = tempBufs + fo; | |
UInt64 unpackSize = SzAr_GetFolderUnpackSize(p, fo); | |
if ((size_t)unpackSize != unpackSize) | |
return SZ_ERROR_MEM; | |
if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp)) | |
return SZ_ERROR_MEM; | |
} | |
for (fo = 0; fo < p->NumFolders; fo++) | |
{ | |
const CBuf *tempBuf = tempBufs + fo; | |
RINOK(LookInStream_SeekTo(inStream, dataStartPos)); | |
RINOK(SzAr_DecodeFolder(p, fo, inStream, dataStartPos, tempBuf->data, tempBuf->size, allocTemp)); | |
} | |
return SZ_OK; | |
} | |
static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets) | |
{ | |
size_t pos = 0; | |
*offsets++ = 0; | |
if (numFiles == 0) | |
return (size == 0) ? SZ_OK : SZ_ERROR_ARCHIVE; | |
if (size < 2) | |
return SZ_ERROR_ARCHIVE; | |
if (data[size - 2] != 0 || data[size - 1] != 0) | |
return SZ_ERROR_ARCHIVE; | |
do | |
{ | |
const Byte *p; | |
if (pos == size) | |
return SZ_ERROR_ARCHIVE; | |
for (p = data + pos; | |
#ifdef _WIN32 | |
*(const UInt16 *)p != 0 | |
#else | |
p[0] != 0 || p[1] != 0 | |
#endif | |
; p += 2); | |
pos = p - data + 2; | |
*offsets++ = (pos >> 1); | |
} | |
while (--numFiles); | |
return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE; | |
} | |
static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num, | |
CSzData *sd2, | |
const CBuf *tempBufs, UInt32 numTempBufs, | |
ISzAllocPtr alloc) | |
{ | |
CSzData sd; | |
UInt32 i; | |
CNtfsFileTime *vals; | |
Byte *defs; | |
Byte external; | |
RINOK(ReadBitVector(sd2, num, &p->Defs, alloc)); | |
SZ_READ_BYTE_SD(sd2, external); | |
if (external == 0) | |
sd = *sd2; | |
else | |
{ | |
UInt32 index; | |
RINOK(SzReadNumber32(sd2, &index)); | |
if (index >= numTempBufs) | |
return SZ_ERROR_ARCHIVE; | |
sd.Data = tempBufs[index].data; | |
sd.Size = tempBufs[index].size; | |
} | |
MY_ALLOC_ZE(CNtfsFileTime, p->Vals, num, alloc); | |
vals = p->Vals; | |
defs = p->Defs; | |
for (i = 0; i < num; i++) | |
if (SzBitArray_Check(defs, i)) | |
{ | |
if (sd.Size < 8) | |
return SZ_ERROR_ARCHIVE; | |
vals[i].Low = GetUi32(sd.Data); | |
vals[i].High = GetUi32(sd.Data + 4); | |
SKIP_DATA2(sd, 8); | |
} | |
else | |
vals[i].High = vals[i].Low = 0; | |
if (external == 0) | |
*sd2 = sd; | |
return SZ_OK; | |
} | |
#define NUM_ADDITIONAL_STREAMS_MAX 8 | |
static SRes SzReadHeader2( | |
CSzArEx *p, /* allocMain */ | |
CSzData *sd, | |
ILookInStream *inStream, | |
CBuf *tempBufs, UInt32 *numTempBufs, | |
ISzAllocPtr allocMain, | |
ISzAllocPtr allocTemp | |
) | |
{ | |
CSubStreamInfo ssi; | |
{ | |
UInt64 type; | |
SzData_Clear(&ssi.sdSizes); | |
SzData_Clear(&ssi.sdCRCs); | |
SzData_Clear(&ssi.sdNumSubStreams); | |
ssi.NumSubDigests = 0; | |
ssi.NumTotalSubStreams = 0; | |
RINOK(ReadID(sd, &type)); | |
if (type == k7zIdArchiveProperties) | |
{ | |
for (;;) | |
{ | |
UInt64 type2; | |
RINOK(ReadID(sd, &type2)); | |
if (type2 == k7zIdEnd) | |
break; | |
RINOK(SkipData(sd)); | |
} | |
RINOK(ReadID(sd, &type)); | |
} | |
if (type == k7zIdAdditionalStreamsInfo) | |
{ | |
CSzAr tempAr; | |
SRes res; | |
SzAr_Init(&tempAr); | |
res = SzReadAndDecodePackedStreams(inStream, sd, tempBufs, NUM_ADDITIONAL_STREAMS_MAX, | |
p->startPosAfterHeader, &tempAr, allocTemp); | |
*numTempBufs = tempAr.NumFolders; | |
SzAr_Free(&tempAr, allocTemp); | |
if (res != SZ_OK) | |
return res; | |
RINOK(ReadID(sd, &type)); | |
} | |
if (type == k7zIdMainStreamsInfo) | |
{ | |
RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs, | |
&p->dataPos, &ssi, allocMain)); | |
p->dataPos += p->startPosAfterHeader; | |
RINOK(ReadID(sd, &type)); | |
} | |
if (type == k7zIdEnd) | |
{ | |
return SZ_OK; | |
} | |
if (type != k7zIdFilesInfo) | |
return SZ_ERROR_ARCHIVE; | |
} | |
{ | |
UInt32 numFiles = 0; | |
UInt32 numEmptyStreams = 0; | |
const Byte *emptyStreams = NULL; | |
const Byte *emptyFiles = NULL; | |
RINOK(SzReadNumber32(sd, &numFiles)); | |
p->NumFiles = numFiles; | |
for (;;) | |
{ | |
UInt64 type; | |
UInt64 size; | |
RINOK(ReadID(sd, &type)); | |
if (type == k7zIdEnd) | |
break; | |
RINOK(ReadNumber(sd, &size)); | |
if (size > sd->Size) | |
return SZ_ERROR_ARCHIVE; | |
if (type >= ((UInt32)1 << 8)) | |
{ | |
SKIP_DATA(sd, size); | |
} | |
else switch ((unsigned)type) | |
{ | |
case k7zIdName: | |
{ | |
size_t namesSize; | |
const Byte *namesData; | |
Byte external; | |
SZ_READ_BYTE(external); | |
if (external == 0) | |
{ | |
namesSize = (size_t)size - 1; | |
namesData = sd->Data; | |
} | |
else | |
{ | |
UInt32 index; | |
RINOK(SzReadNumber32(sd, &index)); | |
if (index >= *numTempBufs) | |
return SZ_ERROR_ARCHIVE; | |
namesData = (tempBufs)[index].data; | |
namesSize = (tempBufs)[index].size; | |
} | |
if ((namesSize & 1) != 0) | |
return SZ_ERROR_ARCHIVE; | |
MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain); | |
MY_ALLOC_ZE_AND_CPY(p->FileNames, namesSize, namesData, allocMain); | |
RINOK(SzReadFileNames(p->FileNames, namesSize, numFiles, p->FileNameOffsets)) | |
if (external == 0) | |
{ | |
SKIP_DATA(sd, namesSize); | |
} | |
break; | |
} | |
case k7zIdEmptyStream: | |
{ | |
RINOK(RememberBitVector(sd, numFiles, &emptyStreams)); | |
numEmptyStreams = CountDefinedBits(emptyStreams, numFiles); | |
emptyFiles = NULL; | |
break; | |
} | |
case k7zIdEmptyFile: | |
{ | |
RINOK(RememberBitVector(sd, numEmptyStreams, &emptyFiles)); | |
break; | |
} | |
case k7zIdWinAttrib: | |
{ | |
Byte external; | |
CSzData sdSwitch; | |
CSzData *sdPtr; | |
SzBitUi32s_Free(&p->Attribs, allocMain); | |
RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain)); | |
SZ_READ_BYTE(external); | |
if (external == 0) | |
sdPtr = sd; | |
else | |
{ | |
UInt32 index; | |
RINOK(SzReadNumber32(sd, &index)); | |
if (index >= *numTempBufs) | |
return SZ_ERROR_ARCHIVE; | |
sdSwitch.Data = (tempBufs)[index].data; | |
sdSwitch.Size = (tempBufs)[index].size; | |
sdPtr = &sdSwitch; | |
} | |
RINOK(ReadUi32s(sdPtr, numFiles, &p->Attribs, allocMain)); | |
break; | |
} | |
/* | |
case k7zParent: | |
{ | |
SzBitUi32s_Free(&p->Parents, allocMain); | |
RINOK(ReadBitVector(sd, numFiles, &p->Parents.Defs, allocMain)); | |
RINOK(SzReadSwitch(sd)); | |
RINOK(ReadUi32s(sd, numFiles, &p->Parents, allocMain)); | |
break; | |
} | |
*/ | |
case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break; | |
case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break; | |
default: | |
{ | |
SKIP_DATA(sd, size); | |
} | |
} | |
} | |
if (numFiles - numEmptyStreams != ssi.NumTotalSubStreams) | |
return SZ_ERROR_ARCHIVE; | |
for (;;) | |
{ | |
UInt64 type; | |
RINOK(ReadID(sd, &type)); | |
if (type == k7zIdEnd) | |
break; | |
RINOK(SkipData(sd)); | |
} | |
{ | |
UInt32 i; | |
UInt32 emptyFileIndex = 0; | |
UInt32 folderIndex = 0; | |
UInt32 remSubStreams = 0; | |
UInt32 numSubStreams = 0; | |
UInt64 unpackPos = 0; | |
const Byte *digestsDefs = NULL; | |
const Byte *digestsVals = NULL; | |
UInt32 digestsValsIndex = 0; | |
UInt32 digestIndex; | |
Byte allDigestsDefined = 0; | |
Byte isDirMask = 0; | |
Byte crcMask = 0; | |
Byte mask = 0x80; | |
MY_ALLOC(UInt32, p->FolderToFile, p->db.NumFolders + 1, allocMain); | |
MY_ALLOC_ZE(UInt32, p->FileToFolder, p->NumFiles, allocMain); | |
MY_ALLOC(UInt64, p->UnpackPositions, p->NumFiles + 1, allocMain); | |
MY_ALLOC_ZE(Byte, p->IsDirs, (p->NumFiles + 7) >> 3, allocMain); | |
RINOK(SzBitUi32s_Alloc(&p->CRCs, p->NumFiles, allocMain)); | |
if (ssi.sdCRCs.Size != 0) | |
{ | |
SZ_READ_BYTE_SD(&ssi.sdCRCs, allDigestsDefined); | |
if (allDigestsDefined) | |
digestsVals = ssi.sdCRCs.Data; | |
else | |
{ | |
size_t numBytes = (ssi.NumSubDigests + 7) >> 3; | |
digestsDefs = ssi.sdCRCs.Data; | |
digestsVals = digestsDefs + numBytes; | |
} | |
} | |
digestIndex = 0; | |
for (i = 0; i < numFiles; i++, mask >>= 1) | |
{ | |
if (mask == 0) | |
{ | |
UInt32 byteIndex = (i - 1) >> 3; | |
p->IsDirs[byteIndex] = isDirMask; | |
p->CRCs.Defs[byteIndex] = crcMask; | |
isDirMask = 0; | |
crcMask = 0; | |
mask = 0x80; | |
} | |
p->UnpackPositions[i] = unpackPos; | |
p->CRCs.Vals[i] = 0; | |
if (emptyStreams && SzBitArray_Check(emptyStreams, i)) | |
{ | |
if (emptyFiles) | |
{ | |
if (!SzBitArray_Check(emptyFiles, emptyFileIndex)) | |
isDirMask |= mask; | |
emptyFileIndex++; | |
} | |
else | |
isDirMask |= mask; | |
if (remSubStreams == 0) | |
{ | |
p->FileToFolder[i] = (UInt32)-1; | |
continue; | |
} | |
} | |
if (remSubStreams == 0) | |
{ | |
for (;;) | |
{ | |
if (folderIndex >= p->db.NumFolders) | |
return SZ_ERROR_ARCHIVE; | |
p->FolderToFile[folderIndex] = i; | |
numSubStreams = 1; | |
if (ssi.sdNumSubStreams.Data) | |
{ | |
RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams)); | |
} | |
remSubStreams = numSubStreams; | |
if (numSubStreams != 0) | |
break; | |
{ | |
UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex); | |
unpackPos += folderUnpackSize; | |
if (unpackPos < folderUnpackSize) | |
return SZ_ERROR_ARCHIVE; | |
} | |
folderIndex++; | |
} | |
} | |
p->FileToFolder[i] = folderIndex; | |
if (emptyStreams && SzBitArray_Check(emptyStreams, i)) | |
continue; | |
if (--remSubStreams == 0) | |
{ | |
UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex); | |
UInt64 startFolderUnpackPos = p->UnpackPositions[p->FolderToFile[folderIndex]]; | |
if (folderUnpackSize < unpackPos - startFolderUnpackPos) | |
return SZ_ERROR_ARCHIVE; | |
unpackPos = startFolderUnpackPos + folderUnpackSize; | |
if (unpackPos < folderUnpackSize) | |
return SZ_ERROR_ARCHIVE; | |
if (numSubStreams == 1 && SzBitWithVals_Check(&p->db.FolderCRCs, i)) | |
{ | |
p->CRCs.Vals[i] = p->db.FolderCRCs.Vals[folderIndex]; | |
crcMask |= mask; | |
} | |
else if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex))) | |
{ | |
p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4); | |
digestsValsIndex++; | |
crcMask |= mask; | |
} | |
folderIndex++; | |
} | |
else | |
{ | |
UInt64 v; | |
RINOK(ReadNumber(&ssi.sdSizes, &v)); | |
unpackPos += v; | |
if (unpackPos < v) | |
return SZ_ERROR_ARCHIVE; | |
if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex))) | |
{ | |
p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4); | |
digestsValsIndex++; | |
crcMask |= mask; | |
} | |
} | |
} | |
if (mask != 0x80) | |
{ | |
UInt32 byteIndex = (i - 1) >> 3; | |
p->IsDirs[byteIndex] = isDirMask; | |
p->CRCs.Defs[byteIndex] = crcMask; | |
} | |
p->UnpackPositions[i] = unpackPos; | |
if (remSubStreams != 0) | |
return SZ_ERROR_ARCHIVE; | |
for (;;) | |
{ | |
p->FolderToFile[folderIndex] = i; | |
if (folderIndex >= p->db.NumFolders) | |
break; | |
if (!ssi.sdNumSubStreams.Data) | |
return SZ_ERROR_ARCHIVE; | |
RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams)); | |
if (numSubStreams != 0) | |
return SZ_ERROR_ARCHIVE; | |
/* | |
{ | |
UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex); | |
unpackPos += folderUnpackSize; | |
if (unpackPos < folderUnpackSize) | |
return SZ_ERROR_ARCHIVE; | |
} | |
*/ | |
folderIndex++; | |
} | |
if (ssi.sdNumSubStreams.Data && ssi.sdNumSubStreams.Size != 0) | |
return SZ_ERROR_ARCHIVE; | |
} | |
} | |
return SZ_OK; | |
} | |
static SRes SzReadHeader( | |
CSzArEx *p, | |
CSzData *sd, | |
ILookInStream *inStream, | |
ISzAllocPtr allocMain, | |
ISzAllocPtr allocTemp) | |
{ | |
UInt32 i; | |
UInt32 numTempBufs = 0; | |
SRes res; | |
CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX]; | |
for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++) | |
Buf_Init(tempBufs + i); | |
res = SzReadHeader2(p, sd, inStream, | |
tempBufs, &numTempBufs, | |
allocMain, allocTemp); | |
for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++) | |
Buf_Free(tempBufs + i, allocTemp); | |
RINOK(res); | |
if (sd->Size != 0) | |
return SZ_ERROR_FAIL; | |
return res; | |
} | |
static SRes SzArEx_Open2( | |
CSzArEx *p, | |
ILookInStream *inStream, | |
ISzAllocPtr allocMain, | |
ISzAllocPtr allocTemp) | |
{ | |
Byte header[k7zStartHeaderSize]; | |
Int64 startArcPos; | |
UInt64 nextHeaderOffset, nextHeaderSize; | |
size_t nextHeaderSizeT; | |
UInt32 nextHeaderCRC; | |
CBuf buf; | |
SRes res; | |
startArcPos = 0; | |
RINOK(ILookInStream_Seek(inStream, &startArcPos, SZ_SEEK_CUR)); | |
RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE)); | |
if (!TestSignatureCandidate(header)) | |
return SZ_ERROR_NO_ARCHIVE; | |
if (header[6] != k7zMajorVersion) | |
return SZ_ERROR_UNSUPPORTED; | |
nextHeaderOffset = GetUi64(header + 12); | |
nextHeaderSize = GetUi64(header + 20); | |
nextHeaderCRC = GetUi32(header + 28); | |
p->startPosAfterHeader = startArcPos + k7zStartHeaderSize; | |
if (CrcCalc(header + 12, 20) != GetUi32(header + 8)) | |
return SZ_ERROR_CRC; | |
nextHeaderSizeT = (size_t)nextHeaderSize; | |
if (nextHeaderSizeT != nextHeaderSize) | |
return SZ_ERROR_MEM; | |
if (nextHeaderSizeT == 0) | |
return SZ_OK; | |
if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize || | |
nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize) | |
return SZ_ERROR_NO_ARCHIVE; | |
{ | |
Int64 pos = 0; | |
RINOK(ILookInStream_Seek(inStream, &pos, SZ_SEEK_END)); | |
if ((UInt64)pos < startArcPos + nextHeaderOffset || | |
(UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset || | |
(UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize) | |
return SZ_ERROR_INPUT_EOF; | |
} | |
RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset)); | |
if (!Buf_Create(&buf, nextHeaderSizeT, allocTemp)) | |
return SZ_ERROR_MEM; | |
res = LookInStream_Read(inStream, buf.data, nextHeaderSizeT); | |
if (res == SZ_OK) | |
{ | |
res = SZ_ERROR_ARCHIVE; | |
if (CrcCalc(buf.data, nextHeaderSizeT) == nextHeaderCRC) | |
{ | |
CSzData sd; | |
UInt64 type; | |
sd.Data = buf.data; | |
sd.Size = buf.size; | |
res = ReadID(&sd, &type); | |
if (res == SZ_OK && type == k7zIdEncodedHeader) | |
{ | |
CSzAr tempAr; | |
CBuf tempBuf; | |
Buf_Init(&tempBuf); | |
SzAr_Init(&tempAr); | |
res = SzReadAndDecodePackedStreams(inStream, &sd, &tempBuf, 1, p->startPosAfterHeader, &tempAr, allocTemp); | |
SzAr_Free(&tempAr, allocTemp); | |
if (res != SZ_OK) | |
{ | |
Buf_Free(&tempBuf, allocTemp); | |
} | |
else | |
{ | |
Buf_Free(&buf, allocTemp); | |
buf.data = tempBuf.data; | |
buf.size = tempBuf.size; | |
sd.Data = buf.data; | |
sd.Size = buf.size; | |
res = ReadID(&sd, &type); | |
} | |
} | |
if (res == SZ_OK) | |
{ | |
if (type == k7zIdHeader) | |
{ | |
/* | |
CSzData sd2; | |
unsigned ttt; | |
for (ttt = 0; ttt < 40000; ttt++) | |
{ | |
SzArEx_Free(p, allocMain); | |
sd2 = sd; | |
res = SzReadHeader(p, &sd2, inStream, allocMain, allocTemp); | |
if (res != SZ_OK) | |
break; | |
} | |
*/ | |
res = SzReadHeader(p, &sd, inStream, allocMain, allocTemp); | |
} | |
else | |
res = SZ_ERROR_UNSUPPORTED; | |
} | |
} | |
} | |
Buf_Free(&buf, allocTemp); | |
return res; | |
} | |
SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, | |
ISzAllocPtr allocMain, ISzAllocPtr allocTemp) | |
{ | |
SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp); | |
if (res != SZ_OK) | |
SzArEx_Free(p, allocMain); | |
return res; | |
} | |
SRes SzArEx_Extract( | |
const CSzArEx *p, | |
ILookInStream *inStream, | |
UInt32 fileIndex, | |
UInt32 *blockIndex, | |
Byte **tempBuf, | |
size_t *outBufferSize, | |
size_t *offset, | |
size_t *outSizeProcessed, | |
ISzAllocPtr allocMain, | |
ISzAllocPtr allocTemp) | |
{ | |
UInt32 folderIndex = p->FileToFolder[fileIndex]; | |
SRes res = SZ_OK; | |
*offset = 0; | |
*outSizeProcessed = 0; | |
if (folderIndex == (UInt32)-1) | |
{ | |
ISzAlloc_Free(allocMain, *tempBuf); | |
*blockIndex = folderIndex; | |
*tempBuf = NULL; | |
*outBufferSize = 0; | |
return SZ_OK; | |
} | |
if (*tempBuf == NULL || *blockIndex != folderIndex) | |
{ | |
UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex); | |
/* | |
UInt64 unpackSizeSpec = | |
p->UnpackPositions[p->FolderToFile[(size_t)folderIndex + 1]] - | |
p->UnpackPositions[p->FolderToFile[folderIndex]]; | |
*/ | |
size_t unpackSize = (size_t)unpackSizeSpec; | |
if (unpackSize != unpackSizeSpec) | |
return SZ_ERROR_MEM; | |
*blockIndex = folderIndex; | |
ISzAlloc_Free(allocMain, *tempBuf); | |
*tempBuf = NULL; | |
if (res == SZ_OK) | |
{ | |
*outBufferSize = unpackSize; | |
if (unpackSize != 0) | |
{ | |
*tempBuf = (Byte *)ISzAlloc_Alloc(allocMain, unpackSize); | |
if (*tempBuf == NULL) | |
res = SZ_ERROR_MEM; | |
} | |
if (res == SZ_OK) | |
{ | |
res = SzAr_DecodeFolder(&p->db, folderIndex, | |
inStream, p->dataPos, *tempBuf, unpackSize, allocTemp); | |
} | |
} | |
} | |
if (res == SZ_OK) | |
{ | |
UInt64 unpackPos = p->UnpackPositions[fileIndex]; | |
*offset = (size_t)(unpackPos - p->UnpackPositions[p->FolderToFile[folderIndex]]); | |
*outSizeProcessed = (size_t)(p->UnpackPositions[(size_t)fileIndex + 1] - unpackPos); | |
if (*offset + *outSizeProcessed > *outBufferSize) | |
return SZ_ERROR_FAIL; | |
if (SzBitWithVals_Check(&p->CRCs, fileIndex)) | |
if (CrcCalc(*tempBuf + *offset, *outSizeProcessed) != p->CRCs.Vals[fileIndex]) | |
res = SZ_ERROR_CRC; | |
} | |
return res; | |
} | |
size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest) | |
{ | |
size_t offs = p->FileNameOffsets[fileIndex]; | |
size_t len = p->FileNameOffsets[fileIndex + 1] - offs; | |
if (dest != 0) | |
{ | |
size_t i; | |
const Byte *src = p->FileNames + offs * 2; | |
for (i = 0; i < len; i++) | |
dest[i] = GetUi16(src + i * 2); | |
} | |
return len; | |
} | |
/* | |
size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex) | |
{ | |
size_t len; | |
if (!p->FileNameOffsets) | |
return 1; | |
len = 0; | |
for (;;) | |
{ | |
UInt32 parent = (UInt32)(Int32)-1; | |
len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex]; | |
if SzBitWithVals_Check(&p->Parents, fileIndex) | |
parent = p->Parents.Vals[fileIndex]; | |
if (parent == (UInt32)(Int32)-1) | |
return len; | |
fileIndex = parent; | |
} | |
} | |
UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest) | |
{ | |
BoolInt needSlash; | |
if (!p->FileNameOffsets) | |
{ | |
*(--dest) = 0; | |
return dest; | |
} | |
needSlash = False; | |
for (;;) | |
{ | |
UInt32 parent = (UInt32)(Int32)-1; | |
size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex]; | |
SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen); | |
if (needSlash) | |
*(dest - 1) = '/'; | |
needSlash = True; | |
dest -= curLen; | |
if SzBitWithVals_Check(&p->Parents, fileIndex) | |
parent = p->Parents.Vals[fileIndex]; | |
if (parent == (UInt32)(Int32)-1) | |
return dest; | |
fileIndex = parent; | |
} | |
} | |
*/ |