/* 7zIn.c -- 7z Input functions

 2010-10-29 : Igor Pavlov : Public domain */

 #include <string.h>

 #if defined(_WIN32)
 #include <WinSock2.h>
 #include <Windows.h>
 #endif
 

 #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 SzFolder_Free(CSzFolder *p, ISzAlloc *alloc);
 int SzFolder_FindBindPairForOutStream(CSzFolder *p, UInt32 outStreamIndex);
 

 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;

   /* bb#11514 - check for pre-allocation: free or error? */
   if (*v)
     return SZ_ERROR_FAIL;

   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);

   if (*v)
     return SZ_ERROR_FAIL;

   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));

   if (*digests)
     return SZ_ERROR_FAIL;

   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));
 

   if (*packSizes)
     return SZ_ERROR_FAIL;

   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)
   {

     if (*packCRCs)
       return SZ_ERROR_FAIL;

     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;

   UInt32 nfdrs;

   RINOK(SzWaitAttribute(sd, k7zIdFolder));

   RINOK(SzReadNumber32(sd, &nfdrs));

   {

     if (*folders)
       return SZ_ERROR_FAIL;
     MY_ALLOC(CSzFolder, *folders, (size_t)nfdrs, alloc);
     *numFolders = nfdrs;

 
     for (i = 0; i < *numFolders; i++)
       SzFolder_Init((*folders) + i);
 

     RINOK(SzReadSwitch(sd));
 

     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);
 

     if (folder->UnpackSizes)
       return SZ_ERROR_FAIL;

     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 (*unpackSizes || *digestsDefined || *digests)
     return SZ_ERROR_FAIL;
 

   if (*numUnpackStreams == 0)
   {
     *unpackSizes = 0;
     *digestsDefined = 0;
     *digests = 0;
   }
   else
   {

     *unpackSizes = (UInt64 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt64) + sizeof(UInt64));

     RINOM(*unpackSizes);

     *digestsDefined = (Byte *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(Byte) + 1);

     RINOM(*digestsDefined);

     *digests = (UInt32 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt32) + 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)
           {

             if (si >= *numUnpackStreams) {
               cli_dbgmsg("SzReadSubStreamsInfo: more streams exist than specified, ignoring.\n");
               continue;
             }

             (*digestsDefined)[si] = 1;
             (*digests)[si] = folder->UnpackCRC;
             si++;
           }
           else
           {
             UInt32 j;
             for (j = 0; j < numSubstreams; j++, digestIndex++)
             {

               if (si >= *numUnpackStreams) {
                 cli_dbgmsg("SzReadSubStreamsInfo: more streams exist than specified, ignoring(2).\n");
                 continue;
               }

               (*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;

         if (p->FileNameOffsets)
           return SZ_ERROR_FAIL;

         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;

         if (!(*unpackSizes) || (sizeIndex > numUnpackStreams))
           return SZ_ERROR_FAIL;

         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;

   /*aCaB - 2010-02-16 - START OF RECOVERY MODE
   if (CrcCalc(header + 12, 20) != GetUi32(header + 8)) {

     return SZ_ERROR_CRC;

   }*/

   if(!GetUi32(header + 8) && !nextHeaderOffset && !nextHeaderSize && !nextHeaderCRC) {
     int i, checkSize = 500;
     Byte buf[500];
     Int64 curpos=0, endpos=0, readpos;
     RINOK(inStream->Seek(inStream, &curpos, SZ_SEEK_CUR));
     RINOK(inStream->Seek(inStream, &endpos, SZ_SEEK_END));
     if(endpos-curpos < 500) checkSize = endpos-curpos;
     readpos = endpos - checkSize;
     RINOK(inStream->Seek(inStream, &readpos, SZ_SEEK_SET));
     RINOK(LookInStream_Read2(inStream, buf, checkSize, SZ_ERROR_ARCHIVE));
     for (i = (int)checkSize - 2; i >= 0; i--)
       if((buf[i] == 0x17 && buf[i + 1] == 0x6) || (buf[i] == 0x01 && buf[i + 1] == 0x04))
 	break;
     if (i < 0)
       return SZ_ERROR_ARCHIVE;
     nextHeaderSize = checkSize - i;
     nextHeaderOffset = readpos + i;
     if(nextHeaderOffset < k7zStartHeaderSize)
       return SZ_ERROR_INPUT_EOF;
     nextHeaderOffset -= k7zStartHeaderSize;
     nextHeaderCRC = CrcCalc(buf + i, (size_t)nextHeaderSize);
     RINOK(inStream->Seek(inStream, &curpos, SZ_SEEK_SET));

   } 
   /* aCaB - 2010-02-16 - END OF RECOVERY MODE */

 
   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;

   SRes res = SZ_OK;

   if (!(p->FileIndexToFolderIndexMap) || (fileIndex >= p->db.NumFiles))
     return SZ_ERROR_FAIL;
   folderIndex = p->FileIndexToFolderIndexMap[fileIndex];

   *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;
     if (!(p->PackStreamStartPositions) || !(p->FolderStartPackStreamIndex) || (folderIndex >= p->db.NumFolders) ||

         (p->FolderStartPackStreamIndex[folderIndex] >= p->db.NumPackStreams))

       return SZ_ERROR_FAIL;
     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;

     if (!(p->FolderStartFileIndex) || (folderIndex >= p->db.NumFolders))
       return SZ_ERROR_FAIL;

     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;
 }