| /* 7zIn.c -- 7z Input functions |
| 2010-10-29 : Igor Pavlov : Public domain */ |
| |
| #include <string.h> |
| |
| #include "7z.h" |
| #include "7zCrc.h" |
| #include "CpuArch.h" |
| |
| Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C}; |
| |
| #define RINOM(x) { if ((x) == 0) return SZ_ERROR_MEM; } |
| |
| #define NUM_FOLDER_CODERS_MAX 32 |
| #define NUM_CODER_STREAMS_MAX 32 |
| |
| void SzCoderInfo_Init(CSzCoderInfo *p) |
| { |
| Buf_Init(&p->Props); |
| } |
| |
| void SzCoderInfo_Free(CSzCoderInfo *p, ISzAlloc *alloc) |
| { |
| Buf_Free(&p->Props, alloc); |
| SzCoderInfo_Init(p); |
| } |
| |
| void SzFolder_Init(CSzFolder *p) |
| { |
| p->Coders = 0; |
| p->BindPairs = 0; |
| p->PackStreams = 0; |
| p->UnpackSizes = 0; |
| p->NumCoders = 0; |
| p->NumBindPairs = 0; |
| p->NumPackStreams = 0; |
| p->UnpackCRCDefined = 0; |
| p->UnpackCRC = 0; |
| p->NumUnpackStreams = 0; |
| } |
| |
| void SzFolder_Free(CSzFolder *p, ISzAlloc *alloc) |
| { |
| UInt32 i; |
| if (p->Coders) |
| for (i = 0; i < p->NumCoders; i++) |
| SzCoderInfo_Free(&p->Coders[i], alloc); |
| IAlloc_Free(alloc, p->Coders); |
| IAlloc_Free(alloc, p->BindPairs); |
| IAlloc_Free(alloc, p->PackStreams); |
| IAlloc_Free(alloc, p->UnpackSizes); |
| SzFolder_Init(p); |
| } |
| |
| UInt32 SzFolder_GetNumOutStreams(CSzFolder *p) |
| { |
| UInt32 result = 0; |
| UInt32 i; |
| for (i = 0; i < p->NumCoders; i++) |
| result += p->Coders[i].NumOutStreams; |
| return result; |
| } |
| |
| int SzFolder_FindBindPairForInStream(CSzFolder *p, UInt32 inStreamIndex) |
| { |
| UInt32 i; |
| for (i = 0; i < p->NumBindPairs; i++) |
| if (p->BindPairs[i].InIndex == inStreamIndex) |
| return i; |
| return -1; |
| } |
| |
| |
| int SzFolder_FindBindPairForOutStream(CSzFolder *p, UInt32 outStreamIndex) |
| { |
| UInt32 i; |
| for (i = 0; i < p->NumBindPairs; i++) |
| if (p->BindPairs[i].OutIndex == outStreamIndex) |
| return i; |
| return -1; |
| } |
| |
| UInt64 SzFolder_GetUnpackSize(CSzFolder *p) |
| { |
| int i = (int)SzFolder_GetNumOutStreams(p); |
| if (i == 0) |
| return 0; |
| for (i--; i >= 0; i--) |
| if (SzFolder_FindBindPairForOutStream(p, i) < 0) |
| return p->UnpackSizes[i]; |
| /* throw 1; */ |
| return 0; |
| } |
| |
| void SzFile_Init(CSzFileItem *p) |
| { |
| p->HasStream = 1; |
| p->IsDir = 0; |
| p->IsAnti = 0; |
| p->CrcDefined = 0; |
| p->MTimeDefined = 0; |
| } |
| |
| void SzAr_Init(CSzAr *p) |
| { |
| p->PackSizes = 0; |
| p->PackCRCsDefined = 0; |
| p->PackCRCs = 0; |
| p->Folders = 0; |
| p->Files = 0; |
| p->NumPackStreams = 0; |
| p->NumFolders = 0; |
| p->NumFiles = 0; |
| } |
| |
| void SzAr_Free(CSzAr *p, ISzAlloc *alloc) |
| { |
| UInt32 i; |
| if (p->Folders) |
| for (i = 0; i < p->NumFolders; i++) |
| SzFolder_Free(&p->Folders[i], alloc); |
| |
| IAlloc_Free(alloc, p->PackSizes); |
| IAlloc_Free(alloc, p->PackCRCsDefined); |
| IAlloc_Free(alloc, p->PackCRCs); |
| IAlloc_Free(alloc, p->Folders); |
| IAlloc_Free(alloc, p->Files); |
| SzAr_Init(p); |
| } |
| |
| |
| void SzArEx_Init(CSzArEx *p) |
| { |
| SzAr_Init(&p->db); |
| p->FolderStartPackStreamIndex = 0; |
| p->PackStreamStartPositions = 0; |
| p->FolderStartFileIndex = 0; |
| p->FileIndexToFolderIndexMap = 0; |
| p->FileNameOffsets = 0; |
| Buf_Init(&p->FileNames); |
| } |
| |
| void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc) |
| { |
| IAlloc_Free(alloc, p->FolderStartPackStreamIndex); |
| IAlloc_Free(alloc, p->PackStreamStartPositions); |
| IAlloc_Free(alloc, p->FolderStartFileIndex); |
| IAlloc_Free(alloc, p->FileIndexToFolderIndexMap); |
| |
| IAlloc_Free(alloc, p->FileNameOffsets); |
| Buf_Free(&p->FileNames, alloc); |
| |
| SzAr_Free(&p->db, alloc); |
| SzArEx_Init(p); |
| } |
| |
| /* |
| UInt64 GetFolderPackStreamSize(int folderIndex, int streamIndex) const |
| { |
| return PackSizes[FolderStartPackStreamIndex[folderIndex] + streamIndex]; |
| } |
| |
| UInt64 GetFilePackSize(int fileIndex) const |
| { |
| int folderIndex = FileIndexToFolderIndexMap[fileIndex]; |
| if (folderIndex >= 0) |
| { |
| const CSzFolder &folderInfo = Folders[folderIndex]; |
| if (FolderStartFileIndex[folderIndex] == fileIndex) |
| return GetFolderFullPackSize(folderIndex); |
| } |
| return 0; |
| } |
| */ |
| |
| #define MY_ALLOC(T, p, size, alloc) { if ((size) == 0) p = 0; else \ |
| if ((p = (T *)IAlloc_Alloc(alloc, (size) * sizeof(T))) == 0) return SZ_ERROR_MEM; } |
| |
| static SRes SzArEx_Fill(CSzArEx *p, ISzAlloc *alloc) |
| { |
| UInt32 startPos = 0; |
| UInt64 startPosSize = 0; |
| UInt32 i; |
| UInt32 folderIndex = 0; |
| UInt32 indexInFolder = 0; |
| MY_ALLOC(UInt32, p->FolderStartPackStreamIndex, p->db.NumFolders, alloc); |
| for (i = 0; i < p->db.NumFolders; i++) |
| { |
| p->FolderStartPackStreamIndex[i] = startPos; |
| startPos += p->db.Folders[i].NumPackStreams; |
| } |
| |
| MY_ALLOC(UInt64, p->PackStreamStartPositions, p->db.NumPackStreams, alloc); |
| |
| for (i = 0; i < p->db.NumPackStreams; i++) |
| { |
| p->PackStreamStartPositions[i] = startPosSize; |
| startPosSize += p->db.PackSizes[i]; |
| } |
| |
| MY_ALLOC(UInt32, p->FolderStartFileIndex, p->db.NumFolders, alloc); |
| MY_ALLOC(UInt32, p->FileIndexToFolderIndexMap, p->db.NumFiles, alloc); |
| |
| for (i = 0; i < p->db.NumFiles; i++) |
| { |
| CSzFileItem *file = p->db.Files + i; |
| int emptyStream = !file->HasStream; |
| if (emptyStream && indexInFolder == 0) |
| { |
| p->FileIndexToFolderIndexMap[i] = (UInt32)-1; |
| continue; |
| } |
| if (indexInFolder == 0) |
| { |
| /* |
| v3.13 incorrectly worked with empty folders |
| v4.07: Loop for skipping empty folders |
| */ |
| for (;;) |
| { |
| if (folderIndex >= p->db.NumFolders) |
| return SZ_ERROR_ARCHIVE; |
| p->FolderStartFileIndex[folderIndex] = i; |
| if (p->db.Folders[folderIndex].NumUnpackStreams != 0) |
| break; |
| folderIndex++; |
| } |
| } |
| p->FileIndexToFolderIndexMap[i] = folderIndex; |
| if (emptyStream) |
| continue; |
| indexInFolder++; |
| if (indexInFolder >= p->db.Folders[folderIndex].NumUnpackStreams) |
| { |
| folderIndex++; |
| indexInFolder = 0; |
| } |
| } |
| return SZ_OK; |
| } |
| |
| |
| UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder) |
| { |
| return p->dataPos + |
| p->PackStreamStartPositions[p->FolderStartPackStreamIndex[folderIndex] + indexInFolder]; |
| } |
| |
| int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize) |
| { |
| UInt32 packStreamIndex = p->FolderStartPackStreamIndex[folderIndex]; |
| CSzFolder *folder = p->db.Folders + folderIndex; |
| UInt64 size = 0; |
| UInt32 i; |
| for (i = 0; i < folder->NumPackStreams; i++) |
| { |
| UInt64 t = size + p->db.PackSizes[packStreamIndex + i]; |
| if (t < size) /* check it */ |
| return SZ_ERROR_FAIL; |
| size = t; |
| } |
| *resSize = size; |
| return SZ_OK; |
| } |
| |
| |
| /* |
| SRes SzReadTime(const CObjectVector<CBuf> &dataVector, |
| CObjectVector<CSzFileItem> &files, UInt64 type) |
| { |
| CBoolVector boolVector; |
| RINOK(ReadBoolVector2(files.Size(), boolVector)) |
| |
| CStreamSwitch streamSwitch; |
| RINOK(streamSwitch.Set(this, &dataVector)); |
| |
| for (int i = 0; i < files.Size(); i++) |
| { |
| CSzFileItem &file = files[i]; |
| CArchiveFileTime fileTime; |
| bool defined = boolVector[i]; |
| if (defined) |
| { |
| UInt32 low, high; |
| RINOK(SzReadUInt32(low)); |
| RINOK(SzReadUInt32(high)); |
| fileTime.dwLowDateTime = low; |
| fileTime.dwHighDateTime = high; |
| } |
| switch(type) |
| { |
| case k7zIdCTime: file.IsCTimeDefined = defined; if (defined) file.CTime = fileTime; break; |
| case k7zIdATime: file.IsATimeDefined = defined; if (defined) file.ATime = fileTime; break; |
| case k7zIdMTime: file.IsMTimeDefined = defined; if (defined) file.MTime = fileTime; break; |
| } |
| } |
| return SZ_OK; |
| } |
| */ |
| |
| static int TestSignatureCandidate(Byte *testBytes) |
| { |
| size_t i; |
| for (i = 0; i < k7zSignatureSize; i++) |
| if (testBytes[i] != k7zSignature[i]) |
| return 0; |
| return 1; |
| } |
| |
| typedef struct _CSzState |
| { |
| Byte *Data; |
| size_t Size; |
| }CSzData; |
| |
| static SRes SzReadByte(CSzData *sd, Byte *b) |
| { |
| if (sd->Size == 0) |
| return SZ_ERROR_ARCHIVE; |
| sd->Size--; |
| *b = *sd->Data++; |
| return SZ_OK; |
| } |
| |
| static SRes SzReadBytes(CSzData *sd, Byte *data, size_t size) |
| { |
| size_t i; |
| for (i = 0; i < size; i++) |
| { |
| RINOK(SzReadByte(sd, data + i)); |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzReadUInt32(CSzData *sd, UInt32 *value) |
| { |
| int i; |
| *value = 0; |
| for (i = 0; i < 4; i++) |
| { |
| Byte b; |
| RINOK(SzReadByte(sd, &b)); |
| *value |= ((UInt32)(b) << (8 * i)); |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzReadNumber(CSzData *sd, UInt64 *value) |
| { |
| Byte firstByte; |
| Byte mask = 0x80; |
| int i; |
| RINOK(SzReadByte(sd, &firstByte)); |
| *value = 0; |
| for (i = 0; i < 8; i++) |
| { |
| Byte b; |
| if ((firstByte & mask) == 0) |
| { |
| UInt64 highPart = firstByte & (mask - 1); |
| *value += (highPart << (8 * i)); |
| return SZ_OK; |
| } |
| RINOK(SzReadByte(sd, &b)); |
| *value |= ((UInt64)b << (8 * i)); |
| mask >>= 1; |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzReadNumber32(CSzData *sd, UInt32 *value) |
| { |
| UInt64 value64; |
| RINOK(SzReadNumber(sd, &value64)); |
| if (value64 >= 0x80000000) |
| return SZ_ERROR_UNSUPPORTED; |
| if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 2))) |
| return SZ_ERROR_UNSUPPORTED; |
| *value = (UInt32)value64; |
| return SZ_OK; |
| } |
| |
| static SRes SzReadID(CSzData *sd, UInt64 *value) |
| { |
| return SzReadNumber(sd, value); |
| } |
| |
| static SRes SzSkeepDataSize(CSzData *sd, UInt64 size) |
| { |
| if (size > sd->Size) |
| return SZ_ERROR_ARCHIVE; |
| sd->Size -= (size_t)size; |
| sd->Data += (size_t)size; |
| return SZ_OK; |
| } |
| |
| static SRes SzSkeepData(CSzData *sd) |
| { |
| UInt64 size; |
| RINOK(SzReadNumber(sd, &size)); |
| return SzSkeepDataSize(sd, size); |
| } |
| |
| static SRes SzReadArchiveProperties(CSzData *sd) |
| { |
| for (;;) |
| { |
| UInt64 type; |
| RINOK(SzReadID(sd, &type)); |
| if (type == k7zIdEnd) |
| break; |
| SzSkeepData(sd); |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzWaitAttribute(CSzData *sd, UInt64 attribute) |
| { |
| for (;;) |
| { |
| UInt64 type; |
| RINOK(SzReadID(sd, &type)); |
| if (type == attribute) |
| return SZ_OK; |
| if (type == k7zIdEnd) |
| return SZ_ERROR_ARCHIVE; |
| RINOK(SzSkeepData(sd)); |
| } |
| } |
| |
| static SRes SzReadBoolVector(CSzData *sd, size_t numItems, Byte **v, ISzAlloc *alloc) |
| { |
| Byte b = 0; |
| Byte mask = 0; |
| size_t i; |
| MY_ALLOC(Byte, *v, numItems, alloc); |
| for (i = 0; i < numItems; i++) |
| { |
| if (mask == 0) |
| { |
| RINOK(SzReadByte(sd, &b)); |
| mask = 0x80; |
| } |
| (*v)[i] = (Byte)(((b & mask) != 0) ? 1 : 0); |
| mask >>= 1; |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzReadBoolVector2(CSzData *sd, size_t numItems, Byte **v, ISzAlloc *alloc) |
| { |
| Byte allAreDefined; |
| size_t i; |
| RINOK(SzReadByte(sd, &allAreDefined)); |
| if (allAreDefined == 0) |
| return SzReadBoolVector(sd, numItems, v, alloc); |
| MY_ALLOC(Byte, *v, numItems, alloc); |
| for (i = 0; i < numItems; i++) |
| (*v)[i] = 1; |
| return SZ_OK; |
| } |
| |
| static SRes SzReadHashDigests( |
| CSzData *sd, |
| size_t numItems, |
| Byte **digestsDefined, |
| UInt32 **digests, |
| ISzAlloc *alloc) |
| { |
| size_t i; |
| RINOK(SzReadBoolVector2(sd, numItems, digestsDefined, alloc)); |
| MY_ALLOC(UInt32, *digests, numItems, alloc); |
| for (i = 0; i < numItems; i++) |
| if ((*digestsDefined)[i]) |
| { |
| RINOK(SzReadUInt32(sd, (*digests) + i)); |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzReadPackInfo( |
| CSzData *sd, |
| UInt64 *dataOffset, |
| UInt32 *numPackStreams, |
| UInt64 **packSizes, |
| Byte **packCRCsDefined, |
| UInt32 **packCRCs, |
| ISzAlloc *alloc) |
| { |
| UInt32 i; |
| RINOK(SzReadNumber(sd, dataOffset)); |
| RINOK(SzReadNumber32(sd, numPackStreams)); |
| |
| RINOK(SzWaitAttribute(sd, k7zIdSize)); |
| |
| MY_ALLOC(UInt64, *packSizes, (size_t)*numPackStreams, alloc); |
| |
| for (i = 0; i < *numPackStreams; i++) |
| { |
| RINOK(SzReadNumber(sd, (*packSizes) + i)); |
| } |
| |
| for (;;) |
| { |
| UInt64 type; |
| RINOK(SzReadID(sd, &type)); |
| if (type == k7zIdEnd) |
| break; |
| if (type == k7zIdCRC) |
| { |
| RINOK(SzReadHashDigests(sd, (size_t)*numPackStreams, packCRCsDefined, packCRCs, alloc)); |
| continue; |
| } |
| RINOK(SzSkeepData(sd)); |
| } |
| if (*packCRCsDefined == 0) |
| { |
| MY_ALLOC(Byte, *packCRCsDefined, (size_t)*numPackStreams, alloc); |
| MY_ALLOC(UInt32, *packCRCs, (size_t)*numPackStreams, alloc); |
| for (i = 0; i < *numPackStreams; i++) |
| { |
| (*packCRCsDefined)[i] = 0; |
| (*packCRCs)[i] = 0; |
| } |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzReadSwitch(CSzData *sd) |
| { |
| Byte external; |
| RINOK(SzReadByte(sd, &external)); |
| return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED; |
| } |
| |
| static SRes SzGetNextFolderItem(CSzData *sd, CSzFolder *folder, ISzAlloc *alloc) |
| { |
| UInt32 numCoders, numBindPairs, numPackStreams, i; |
| UInt32 numInStreams = 0, numOutStreams = 0; |
| |
| RINOK(SzReadNumber32(sd, &numCoders)); |
| if (numCoders > NUM_FOLDER_CODERS_MAX) |
| return SZ_ERROR_UNSUPPORTED; |
| folder->NumCoders = numCoders; |
| |
| MY_ALLOC(CSzCoderInfo, folder->Coders, (size_t)numCoders, alloc); |
| |
| for (i = 0; i < numCoders; i++) |
| SzCoderInfo_Init(folder->Coders + i); |
| |
| for (i = 0; i < numCoders; i++) |
| { |
| Byte mainByte; |
| CSzCoderInfo *coder = folder->Coders + i; |
| { |
| unsigned idSize, j; |
| Byte longID[15]; |
| RINOK(SzReadByte(sd, &mainByte)); |
| idSize = (unsigned)(mainByte & 0xF); |
| RINOK(SzReadBytes(sd, longID, idSize)); |
| if (idSize > sizeof(coder->MethodID)) |
| return SZ_ERROR_UNSUPPORTED; |
| coder->MethodID = 0; |
| for (j = 0; j < idSize; j++) |
| coder->MethodID |= (UInt64)longID[idSize - 1 - j] << (8 * j); |
| |
| if ((mainByte & 0x10) != 0) |
| { |
| RINOK(SzReadNumber32(sd, &coder->NumInStreams)); |
| RINOK(SzReadNumber32(sd, &coder->NumOutStreams)); |
| if (coder->NumInStreams > NUM_CODER_STREAMS_MAX || |
| coder->NumOutStreams > NUM_CODER_STREAMS_MAX) |
| return SZ_ERROR_UNSUPPORTED; |
| } |
| else |
| { |
| coder->NumInStreams = 1; |
| coder->NumOutStreams = 1; |
| } |
| if ((mainByte & 0x20) != 0) |
| { |
| UInt64 propertiesSize = 0; |
| RINOK(SzReadNumber(sd, &propertiesSize)); |
| if (!Buf_Create(&coder->Props, (size_t)propertiesSize, alloc)) |
| return SZ_ERROR_MEM; |
| RINOK(SzReadBytes(sd, coder->Props.data, (size_t)propertiesSize)); |
| } |
| } |
| while ((mainByte & 0x80) != 0) |
| { |
| RINOK(SzReadByte(sd, &mainByte)); |
| RINOK(SzSkeepDataSize(sd, (mainByte & 0xF))); |
| if ((mainByte & 0x10) != 0) |
| { |
| UInt32 n; |
| RINOK(SzReadNumber32(sd, &n)); |
| RINOK(SzReadNumber32(sd, &n)); |
| } |
| if ((mainByte & 0x20) != 0) |
| { |
| UInt64 propertiesSize = 0; |
| RINOK(SzReadNumber(sd, &propertiesSize)); |
| RINOK(SzSkeepDataSize(sd, propertiesSize)); |
| } |
| } |
| numInStreams += coder->NumInStreams; |
| numOutStreams += coder->NumOutStreams; |
| } |
| |
| if (numOutStreams == 0) |
| return SZ_ERROR_UNSUPPORTED; |
| |
| folder->NumBindPairs = numBindPairs = numOutStreams - 1; |
| MY_ALLOC(CSzBindPair, folder->BindPairs, (size_t)numBindPairs, alloc); |
| |
| for (i = 0; i < numBindPairs; i++) |
| { |
| CSzBindPair *bp = folder->BindPairs + i; |
| RINOK(SzReadNumber32(sd, &bp->InIndex)); |
| RINOK(SzReadNumber32(sd, &bp->OutIndex)); |
| } |
| |
| if (numInStreams < numBindPairs) |
| return SZ_ERROR_UNSUPPORTED; |
| |
| folder->NumPackStreams = numPackStreams = numInStreams - numBindPairs; |
| MY_ALLOC(UInt32, folder->PackStreams, (size_t)numPackStreams, alloc); |
| |
| if (numPackStreams == 1) |
| { |
| for (i = 0; i < numInStreams ; i++) |
| if (SzFolder_FindBindPairForInStream(folder, i) < 0) |
| break; |
| if (i == numInStreams) |
| return SZ_ERROR_UNSUPPORTED; |
| folder->PackStreams[0] = i; |
| } |
| else |
| for (i = 0; i < numPackStreams; i++) |
| { |
| RINOK(SzReadNumber32(sd, folder->PackStreams + i)); |
| } |
| return SZ_OK; |
| } |
| |
| static SRes SzReadUnpackInfo( |
| CSzData *sd, |
| UInt32 *numFolders, |
| CSzFolder **folders, /* for alloc */ |
| ISzAlloc *alloc, |
| ISzAlloc *allocTemp) |
| { |
| UInt32 i; |
| RINOK(SzWaitAttribute(sd, k7zIdFolder)); |
| RINOK(SzReadNumber32(sd, numFolders)); |
| { |
| RINOK(SzReadSwitch(sd)); |
| |
| MY_ALLOC(CSzFolder, *folders, (size_t)*numFolders, alloc); |
| |
| for (i = 0; i < *numFolders; i++) |
| SzFolder_Init((*folders) + i); |
| |
| for (i = 0; i < *numFolders; i++) |
| { |
| RINOK(SzGetNextFolderItem(sd, (*folders) + i, alloc)); |
| } |
| } |
| |
| RINOK(SzWaitAttribute(sd, k7zIdCodersUnpackSize)); |
| |
| for (i = 0; i < *numFolders; i++) |
| { |
| UInt32 j; |
| CSzFolder *folder = (*folders) + i; |
| UInt32 numOutStreams = SzFolder_GetNumOutStreams(folder); |
| |
| MY_ALLOC(UInt64, folder->UnpackSizes, (size_t)numOutStreams, alloc); |
| |
| for (j = 0; j < numOutStreams; j++) |
| { |
| RINOK(SzReadNumber(sd, folder->UnpackSizes + j)); |
| } |
| } |
| |
| for (;;) |
| { |
| UInt64 type; |
| RINOK(SzReadID(sd, &type)); |
| if (type == k7zIdEnd) |
| return SZ_OK; |
| if (type == k7zIdCRC) |
| { |
| SRes res; |
| Byte *crcsDefined = 0; |
| UInt32 *crcs = 0; |
| res = SzReadHashDigests(sd, *numFolders, &crcsDefined, &crcs, allocTemp); |
| if (res == SZ_OK) |
| { |
| for (i = 0; i < *numFolders; i++) |
| { |
| CSzFolder *folder = (*folders) + i; |
| folder->UnpackCRCDefined = crcsDefined[i]; |
| folder->UnpackCRC = crcs[i]; |
| } |
| } |
| IAlloc_Free(allocTemp, crcs); |
| IAlloc_Free(allocTemp, crcsDefined); |
| RINOK(res); |
| continue; |
| } |
| RINOK(SzSkeepData(sd)); |
| } |
| } |
| |
| static SRes SzReadSubStreamsInfo( |
| CSzData *sd, |
| UInt32 numFolders, |
| CSzFolder *folders, |
| UInt32 *numUnpackStreams, |
| UInt64 **unpackSizes, |
| Byte **digestsDefined, |
| UInt32 **digests, |
| ISzAlloc *allocTemp) |
| { |
| UInt64 type = 0; |
| UInt32 i; |
| UInt32 si = 0; |
| UInt32 numDigests = 0; |
| |
| for (i = 0; i < numFolders; i++) |
| folders[i].NumUnpackStreams = 1; |
| *numUnpackStreams = numFolders; |
| |
| for (;;) |
| { |
| RINOK(SzReadID(sd, &type)); |
| if (type == k7zIdNumUnpackStream) |
| { |
| *numUnpackStreams = 0; |
| for (i = 0; i < numFolders; i++) |
| { |
| UInt32 numStreams; |
| RINOK(SzReadNumber32(sd, &numStreams)); |
| folders[i].NumUnpackStreams = numStreams; |
| *numUnpackStreams += numStreams; |
| } |
| continue; |
| } |
| if (type == k7zIdCRC || type == k7zIdSize) |
| break; |
| if (type == k7zIdEnd) |
| break; |
| RINOK(SzSkeepData(sd)); |
| } |
| |
| if (*numUnpackStreams == 0) |
| { |
| *unpackSizes = 0; |
| *digestsDefined = 0; |
| *digests = 0; |
| } |
| else |
| { |
| *unpackSizes = (UInt64 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt64)); |
| RINOM(*unpackSizes); |
| *digestsDefined = (Byte *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(Byte)); |
| RINOM(*digestsDefined); |
| *digests = (UInt32 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt32)); |
| RINOM(*digests); |
| } |
| |
| for (i = 0; i < numFolders; i++) |
| { |
| /* |
| v3.13 incorrectly worked with empty folders |
| v4.07: we check that folder is empty |
| */ |
| UInt64 sum = 0; |
| UInt32 j; |
| UInt32 numSubstreams = folders[i].NumUnpackStreams; |
| if (numSubstreams == 0) |
| continue; |
| if (type == k7zIdSize) |
| for (j = 1; j < numSubstreams; j++) |
| { |
| UInt64 size; |
| RINOK(SzReadNumber(sd, &size)); |
| (*unpackSizes)[si++] = size; |
| sum += size; |
| } |
| (*unpackSizes)[si++] = SzFolder_GetUnpackSize(folders + i) - sum; |
| } |
| if (type == k7zIdSize) |
| { |
| RINOK(SzReadID(sd, &type)); |
| } |
| |
| for (i = 0; i < *numUnpackStreams; i++) |
| { |
| (*digestsDefined)[i] = 0; |
| (*digests)[i] = 0; |
| } |
| |
| |
| for (i = 0; i < numFolders; i++) |
| { |
| UInt32 numSubstreams = folders[i].NumUnpackStreams; |
| if (numSubstreams != 1 || !folders[i].UnpackCRCDefined) |
| numDigests += numSubstreams; |
| } |
| |
| |
| si = 0; |
| for (;;) |
| { |
| if (type == k7zIdCRC) |
| { |
| int digestIndex = 0; |
| Byte *digestsDefined2 = 0; |
| UInt32 *digests2 = 0; |
| SRes res = SzReadHashDigests(sd, numDigests, &digestsDefined2, &digests2, allocTemp); |
| if (res == SZ_OK) |
| { |
| for (i = 0; i < numFolders; i++) |
| { |
| CSzFolder *folder = folders + i; |
| UInt32 numSubstreams = folder->NumUnpackStreams; |
| if (numSubstreams == 1 && folder->UnpackCRCDefined) |
| { |
| (*digestsDefined)[si] = 1; |
| (*digests)[si] = folder->UnpackCRC; |
| si++; |
| } |
| else |
| { |
| UInt32 j; |
| for (j = 0; j < numSubstreams; j++, digestIndex++) |
| { |
| (*digestsDefined)[si] = digestsDefined2[digestIndex]; |
| (*digests)[si] = digests2[digestIndex]; |
| si++; |
| } |
| } |
| } |
| } |
| IAlloc_Free(allocTemp, digestsDefined2); |
| IAlloc_Free(allocTemp, digests2); |
| RINOK(res); |
| } |
| else if (type == k7zIdEnd) |
| return SZ_OK; |
| else |
| { |
| RINOK(SzSkeepData(sd)); |
| } |
| RINOK(SzReadID(sd, &type)); |
| } |
| } |
| |
| |
| static SRes SzReadStreamsInfo( |
| CSzData *sd, |
| UInt64 *dataOffset, |
| CSzAr *p, |
| UInt32 *numUnpackStreams, |
| UInt64 **unpackSizes, /* allocTemp */ |
| Byte **digestsDefined, /* allocTemp */ |
| UInt32 **digests, /* allocTemp */ |
| ISzAlloc *alloc, |
| ISzAlloc *allocTemp) |
| { |
| for (;;) |
| { |
| UInt64 type; |
| RINOK(SzReadID(sd, &type)); |
| if ((UInt64)(int)type != type) |
| return SZ_ERROR_UNSUPPORTED; |
| switch((int)type) |
| { |
| case k7zIdEnd: |
| return SZ_OK; |
| case k7zIdPackInfo: |
| { |
| RINOK(SzReadPackInfo(sd, dataOffset, &p->NumPackStreams, |
| &p->PackSizes, &p->PackCRCsDefined, &p->PackCRCs, alloc)); |
| break; |
| } |
| case k7zIdUnpackInfo: |
| { |
| RINOK(SzReadUnpackInfo(sd, &p->NumFolders, &p->Folders, alloc, allocTemp)); |
| break; |
| } |
| case k7zIdSubStreamsInfo: |
| { |
| RINOK(SzReadSubStreamsInfo(sd, p->NumFolders, p->Folders, |
| numUnpackStreams, unpackSizes, digestsDefined, digests, allocTemp)); |
| break; |
| } |
| default: |
| return SZ_ERROR_UNSUPPORTED; |
| } |
| } |
| } |
| |
| size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest) |
| { |
| size_t len = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex]; |
| if (dest != 0) |
| { |
| size_t i; |
| const Byte *src = p->FileNames.data + (p->FileNameOffsets[fileIndex] * 2); |
| for (i = 0; i < len; i++) |
| dest[i] = GetUi16(src + i * 2); |
| } |
| return len; |
| } |
| |
| static SRes SzReadFileNames(const Byte *p, size_t size, UInt32 numFiles, size_t *sizes) |
| { |
| UInt32 i; |
| size_t pos = 0; |
| for (i = 0; i < numFiles; i++) |
| { |
| sizes[i] = pos; |
| for (;;) |
| { |
| if (pos >= size) |
| return SZ_ERROR_ARCHIVE; |
| if (p[pos * 2] == 0 && p[pos * 2 + 1] == 0) |
| break; |
| pos++; |
| } |
| pos++; |
| } |
| sizes[i] = pos; |
| return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE; |
| } |
| |
| static SRes SzReadHeader2( |
| CSzArEx *p, /* allocMain */ |
| CSzData *sd, |
| UInt64 **unpackSizes, /* allocTemp */ |
| Byte **digestsDefined, /* allocTemp */ |
| UInt32 **digests, /* allocTemp */ |
| Byte **emptyStreamVector, /* allocTemp */ |
| Byte **emptyFileVector, /* allocTemp */ |
| Byte **lwtVector, /* allocTemp */ |
| ISzAlloc *allocMain, |
| ISzAlloc *allocTemp) |
| { |
| UInt64 type; |
| UInt32 numUnpackStreams = 0; |
| UInt32 numFiles = 0; |
| CSzFileItem *files = 0; |
| UInt32 numEmptyStreams = 0; |
| UInt32 i; |
| |
| RINOK(SzReadID(sd, &type)); |
| |
| if (type == k7zIdArchiveProperties) |
| { |
| RINOK(SzReadArchiveProperties(sd)); |
| RINOK(SzReadID(sd, &type)); |
| } |
| |
| |
| if (type == k7zIdMainStreamsInfo) |
| { |
| RINOK(SzReadStreamsInfo(sd, |
| &p->dataPos, |
| &p->db, |
| &numUnpackStreams, |
| unpackSizes, |
| digestsDefined, |
| digests, allocMain, allocTemp)); |
| p->dataPos += p->startPosAfterHeader; |
| RINOK(SzReadID(sd, &type)); |
| } |
| |
| if (type == k7zIdEnd) |
| return SZ_OK; |
| if (type != k7zIdFilesInfo) |
| return SZ_ERROR_ARCHIVE; |
| |
| RINOK(SzReadNumber32(sd, &numFiles)); |
| p->db.NumFiles = numFiles; |
| |
| MY_ALLOC(CSzFileItem, files, (size_t)numFiles, allocMain); |
| |
| p->db.Files = files; |
| for (i = 0; i < numFiles; i++) |
| SzFile_Init(files + i); |
| |
| for (;;) |
| { |
| UInt64 type; |
| UInt64 size; |
| RINOK(SzReadID(sd, &type)); |
| if (type == k7zIdEnd) |
| break; |
| RINOK(SzReadNumber(sd, &size)); |
| if (size > sd->Size) |
| return SZ_ERROR_ARCHIVE; |
| if ((UInt64)(int)type != type) |
| { |
| RINOK(SzSkeepDataSize(sd, size)); |
| } |
| else |
| switch((int)type) |
| { |
| case k7zIdName: |
| { |
| size_t namesSize; |
| RINOK(SzReadSwitch(sd)); |
| namesSize = (size_t)size - 1; |
| if ((namesSize & 1) != 0) |
| return SZ_ERROR_ARCHIVE; |
| if (!Buf_Create(&p->FileNames, namesSize, allocMain)) |
| return SZ_ERROR_MEM; |
| MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain); |
| memcpy(p->FileNames.data, sd->Data, namesSize); |
| RINOK(SzReadFileNames(sd->Data, namesSize >> 1, numFiles, p->FileNameOffsets)) |
| RINOK(SzSkeepDataSize(sd, namesSize)); |
| break; |
| } |
| case k7zIdEmptyStream: |
| { |
| RINOK(SzReadBoolVector(sd, numFiles, emptyStreamVector, allocTemp)); |
| numEmptyStreams = 0; |
| for (i = 0; i < numFiles; i++) |
| if ((*emptyStreamVector)[i]) |
| numEmptyStreams++; |
| break; |
| } |
| case k7zIdEmptyFile: |
| { |
| RINOK(SzReadBoolVector(sd, numEmptyStreams, emptyFileVector, allocTemp)); |
| break; |
| } |
| case k7zIdWinAttributes: |
| { |
| RINOK(SzReadBoolVector2(sd, numFiles, lwtVector, allocTemp)); |
| RINOK(SzReadSwitch(sd)); |
| for (i = 0; i < numFiles; i++) |
| { |
| CSzFileItem *f = &files[i]; |
| Byte defined = (*lwtVector)[i]; |
| f->AttribDefined = defined; |
| f->Attrib = 0; |
| if (defined) |
| { |
| RINOK(SzReadUInt32(sd, &f->Attrib)); |
| } |
| } |
| IAlloc_Free(allocTemp, *lwtVector); |
| *lwtVector = NULL; |
| break; |
| } |
| case k7zIdMTime: |
| { |
| RINOK(SzReadBoolVector2(sd, numFiles, lwtVector, allocTemp)); |
| RINOK(SzReadSwitch(sd)); |
| for (i = 0; i < numFiles; i++) |
| { |
| CSzFileItem *f = &files[i]; |
| Byte defined = (*lwtVector)[i]; |
| f->MTimeDefined = defined; |
| f->MTime.Low = f->MTime.High = 0; |
| if (defined) |
| { |
| RINOK(SzReadUInt32(sd, &f->MTime.Low)); |
| RINOK(SzReadUInt32(sd, &f->MTime.High)); |
| } |
| } |
| IAlloc_Free(allocTemp, *lwtVector); |
| *lwtVector = NULL; |
| break; |
| } |
| default: |
| { |
| RINOK(SzSkeepDataSize(sd, size)); |
| } |
| } |
| } |
| |
| { |
| UInt32 emptyFileIndex = 0; |
| UInt32 sizeIndex = 0; |
| for (i = 0; i < numFiles; i++) |
| { |
| CSzFileItem *file = files + i; |
| file->IsAnti = 0; |
| if (*emptyStreamVector == 0) |
| file->HasStream = 1; |
| else |
| file->HasStream = (Byte)((*emptyStreamVector)[i] ? 0 : 1); |
| if (file->HasStream) |
| { |
| file->IsDir = 0; |
| file->Size = (*unpackSizes)[sizeIndex]; |
| file->Crc = (*digests)[sizeIndex]; |
| file->CrcDefined = (Byte)(*digestsDefined)[sizeIndex]; |
| sizeIndex++; |
| } |
| else |
| { |
| if (*emptyFileVector == 0) |
| file->IsDir = 1; |
| else |
| file->IsDir = (Byte)((*emptyFileVector)[emptyFileIndex] ? 0 : 1); |
| emptyFileIndex++; |
| file->Size = 0; |
| file->Crc = 0; |
| file->CrcDefined = 0; |
| } |
| } |
| } |
| return SzArEx_Fill(p, allocMain); |
| } |
| |
| static SRes SzReadHeader( |
| CSzArEx *p, |
| CSzData *sd, |
| ISzAlloc *allocMain, |
| ISzAlloc *allocTemp) |
| { |
| UInt64 *unpackSizes = 0; |
| Byte *digestsDefined = 0; |
| UInt32 *digests = 0; |
| Byte *emptyStreamVector = 0; |
| Byte *emptyFileVector = 0; |
| Byte *lwtVector = 0; |
| SRes res = SzReadHeader2(p, sd, |
| &unpackSizes, &digestsDefined, &digests, |
| &emptyStreamVector, &emptyFileVector, &lwtVector, |
| allocMain, allocTemp); |
| IAlloc_Free(allocTemp, unpackSizes); |
| IAlloc_Free(allocTemp, digestsDefined); |
| IAlloc_Free(allocTemp, digests); |
| IAlloc_Free(allocTemp, emptyStreamVector); |
| IAlloc_Free(allocTemp, emptyFileVector); |
| IAlloc_Free(allocTemp, lwtVector); |
| return res; |
| } |
| |
| static SRes SzReadAndDecodePackedStreams2( |
| ILookInStream *inStream, |
| CSzData *sd, |
| CBuf *outBuffer, |
| UInt64 baseOffset, |
| CSzAr *p, |
| UInt64 **unpackSizes, |
| Byte **digestsDefined, |
| UInt32 **digests, |
| ISzAlloc *allocTemp) |
| { |
| |
| UInt32 numUnpackStreams = 0; |
| UInt64 dataStartPos; |
| CSzFolder *folder; |
| UInt64 unpackSize; |
| SRes res; |
| |
| RINOK(SzReadStreamsInfo(sd, &dataStartPos, p, |
| &numUnpackStreams, unpackSizes, digestsDefined, digests, |
| allocTemp, allocTemp)); |
| |
| dataStartPos += baseOffset; |
| if (p->NumFolders != 1) |
| return SZ_ERROR_ARCHIVE; |
| |
| folder = p->Folders; |
| unpackSize = SzFolder_GetUnpackSize(folder); |
| |
| RINOK(LookInStream_SeekTo(inStream, dataStartPos)); |
| |
| if (!Buf_Create(outBuffer, (size_t)unpackSize, allocTemp)) |
| return SZ_ERROR_MEM; |
| |
| res = SzFolder_Decode(folder, p->PackSizes, |
| inStream, dataStartPos, |
| outBuffer->data, (size_t)unpackSize, allocTemp); |
| RINOK(res); |
| if (folder->UnpackCRCDefined) |
| if (CrcCalc(outBuffer->data, (size_t)unpackSize) != folder->UnpackCRC) |
| return SZ_ERROR_CRC; |
| return SZ_OK; |
| } |
| |
| static SRes SzReadAndDecodePackedStreams( |
| ILookInStream *inStream, |
| CSzData *sd, |
| CBuf *outBuffer, |
| UInt64 baseOffset, |
| ISzAlloc *allocTemp) |
| { |
| CSzAr p; |
| UInt64 *unpackSizes = 0; |
| Byte *digestsDefined = 0; |
| UInt32 *digests = 0; |
| SRes res; |
| SzAr_Init(&p); |
| res = SzReadAndDecodePackedStreams2(inStream, sd, outBuffer, baseOffset, |
| &p, &unpackSizes, &digestsDefined, &digests, |
| allocTemp); |
| SzAr_Free(&p, allocTemp); |
| IAlloc_Free(allocTemp, unpackSizes); |
| IAlloc_Free(allocTemp, digestsDefined); |
| IAlloc_Free(allocTemp, digests); |
| return res; |
| } |
| |
| static SRes SzArEx_Open2( |
| CSzArEx *p, |
| ILookInStream *inStream, |
| ISzAlloc *allocMain, |
| ISzAlloc *allocTemp) |
| { |
| Byte header[k7zStartHeaderSize]; |
| Int64 startArcPos; |
| UInt64 nextHeaderOffset, nextHeaderSize; |
| size_t nextHeaderSizeT; |
| UInt32 nextHeaderCRC; |
| CBuf buffer; |
| SRes res; |
| |
| startArcPos = 0; |
| RINOK(inStream->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(inStream->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(&buffer, nextHeaderSizeT, allocTemp)) |
| return SZ_ERROR_MEM; |
| |
| res = LookInStream_Read(inStream, buffer.data, nextHeaderSizeT); |
| if (res == SZ_OK) |
| { |
| res = SZ_ERROR_ARCHIVE; |
| if (CrcCalc(buffer.data, nextHeaderSizeT) == nextHeaderCRC) |
| { |
| CSzData sd; |
| UInt64 type; |
| sd.Data = buffer.data; |
| sd.Size = buffer.size; |
| res = SzReadID(&sd, &type); |
| if (res == SZ_OK) |
| { |
| if (type == k7zIdEncodedHeader) |
| { |
| CBuf outBuffer; |
| Buf_Init(&outBuffer); |
| res = SzReadAndDecodePackedStreams(inStream, &sd, &outBuffer, p->startPosAfterHeader, allocTemp); |
| if (res != SZ_OK) |
| Buf_Free(&outBuffer, allocTemp); |
| else |
| { |
| Buf_Free(&buffer, allocTemp); |
| buffer.data = outBuffer.data; |
| buffer.size = outBuffer.size; |
| sd.Data = buffer.data; |
| sd.Size = buffer.size; |
| res = SzReadID(&sd, &type); |
| } |
| } |
| } |
| if (res == SZ_OK) |
| { |
| if (type == k7zIdHeader) |
| res = SzReadHeader(p, &sd, allocMain, allocTemp); |
| else |
| res = SZ_ERROR_UNSUPPORTED; |
| } |
| } |
| } |
| Buf_Free(&buffer, allocTemp); |
| return res; |
| } |
| |
| SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *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 **outBuffer, |
| size_t *outBufferSize, |
| size_t *offset, |
| size_t *outSizeProcessed, |
| ISzAlloc *allocMain, |
| ISzAlloc *allocTemp) |
| { |
| UInt32 folderIndex = p->FileIndexToFolderIndexMap[fileIndex]; |
| SRes res = SZ_OK; |
| *offset = 0; |
| *outSizeProcessed = 0; |
| if (folderIndex == (UInt32)-1) |
| { |
| IAlloc_Free(allocMain, *outBuffer); |
| *blockIndex = folderIndex; |
| *outBuffer = 0; |
| *outBufferSize = 0; |
| return SZ_OK; |
| } |
| |
| if (*outBuffer == 0 || *blockIndex != folderIndex) |
| { |
| CSzFolder *folder = p->db.Folders + folderIndex; |
| UInt64 unpackSizeSpec = SzFolder_GetUnpackSize(folder); |
| size_t unpackSize = (size_t)unpackSizeSpec; |
| UInt64 startOffset = SzArEx_GetFolderStreamPos(p, folderIndex, 0); |
| |
| if (unpackSize != unpackSizeSpec) |
| return SZ_ERROR_MEM; |
| *blockIndex = folderIndex; |
| IAlloc_Free(allocMain, *outBuffer); |
| *outBuffer = 0; |
| |
| RINOK(LookInStream_SeekTo(inStream, startOffset)); |
| |
| if (res == SZ_OK) |
| { |
| *outBufferSize = unpackSize; |
| if (unpackSize != 0) |
| { |
| *outBuffer = (Byte *)IAlloc_Alloc(allocMain, unpackSize); |
| if (*outBuffer == 0) |
| res = SZ_ERROR_MEM; |
| } |
| if (res == SZ_OK) |
| { |
| res = SzFolder_Decode(folder, |
| p->db.PackSizes + p->FolderStartPackStreamIndex[folderIndex], |
| inStream, startOffset, |
| *outBuffer, unpackSize, allocTemp); |
| if (res == SZ_OK) |
| { |
| if (folder->UnpackCRCDefined) |
| { |
| if (CrcCalc(*outBuffer, unpackSize) != folder->UnpackCRC) |
| res = SZ_ERROR_CRC; |
| } |
| } |
| } |
| } |
| } |
| if (res == SZ_OK) |
| { |
| UInt32 i; |
| CSzFileItem *fileItem = p->db.Files + fileIndex; |
| *offset = 0; |
| for (i = p->FolderStartFileIndex[folderIndex]; i < fileIndex; i++) |
| *offset += (UInt32)p->db.Files[i].Size; |
| *outSizeProcessed = (size_t)fileItem->Size; |
| if (*offset + *outSizeProcessed > *outBufferSize) |
| return SZ_ERROR_FAIL; |
| if (fileItem->CrcDefined && CrcCalc(*outBuffer + *offset, *outSizeProcessed) != fileItem->Crc) |
| res = SZ_ERROR_CRC; |
| } |
| return res; |
| } |