third_party/lzma_sdk/7zIn.c

   1 /* 7zIn.c -- 7z Input functions
   2 2010-10-29 : Igor Pavlov : Public domain */
   3
   4 #include <string.h>
   5
   6 #include "7z.h"
   7 #include "7zCrc.h"
   8 #include "CpuArch.h"
   9
  10 Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
  11
  12 #define RINOM(x) { if ((x) == 0) return SZ_ERROR_MEM; }
  13
  14 #define NUM_FOLDER_CODERS_MAX 32
  15 #define NUM_CODER_STREAMS_MAX 32
  16
  17 void SzCoderInfo_Init(CSzCoderInfo *p)
  18 {
  19   Buf_Init(&p->Props);
  20 }
  21
  22 void SzCoderInfo_Free(CSzCoderInfo *p, ISzAlloc *alloc)
  23 {
  24   Buf_Free(&p->Props, alloc);
  25   SzCoderInfo_Init(p);
  26 }
  27
  28 void SzFolder_Init(CSzFolder *p)
  29 {
  30   p->Coders = 0;
  31   p->BindPairs = 0;
  32   p->PackStreams = 0;
  33   p->UnpackSizes = 0;
  34   p->NumCoders = 0;
  35   p->NumBindPairs = 0;
  36   p->NumPackStreams = 0;
  37   p->UnpackCRCDefined = 0;
  38   p->UnpackCRC = 0;
  39   p->NumUnpackStreams = 0;
  40 }
  41
  42 void SzFolder_Free(CSzFolder *p, ISzAlloc *alloc)
  43 {
  44   UInt32 i;
  45   if (p->Coders)
  46     for (i = 0; i < p->NumCoders; i++)
  47       SzCoderInfo_Free(&p->Coders[i], alloc);
  48   IAlloc_Free(alloc, p->Coders);
  49   IAlloc_Free(alloc, p->BindPairs);
  50   IAlloc_Free(alloc, p->PackStreams);
  51   IAlloc_Free(alloc, p->UnpackSizes);
  52   SzFolder_Init(p);
  53 }
  54
  55 UInt32 SzFolder_GetNumOutStreams(CSzFolder *p)
  56 {
  57   UInt32 result = 0;
  58   UInt32 i;
  59   for (i = 0; i < p->NumCoders; i++)
  60     result += p->Coders[i].NumOutStreams;
  61   return result;
  62 }
  63
  64 int SzFolder_FindBindPairForInStream(CSzFolder *p, UInt32 inStreamIndex)
  65 {
  66   UInt32 i;
  67   for (i = 0; i < p->NumBindPairs; i++)
  68     if (p->BindPairs[i].InIndex == inStreamIndex)
  69       return i;
  70   return -1;
  71 }
  72
  73
  74 int SzFolder_FindBindPairForOutStream(CSzFolder *p, UInt32 outStreamIndex)
  75 {
  76   UInt32 i;
  77   for (i = 0; i < p->NumBindPairs; i++)
  78     if (p->BindPairs[i].OutIndex == outStreamIndex)
  79       return i;
  80   return -1;
  81 }
  82
  83 UInt64 SzFolder_GetUnpackSize(CSzFolder *p)
  84 {
  85   int i = (int)SzFolder_GetNumOutStreams(p);
  86   if (i == 0)
  87     return 0;
  88   for (i--; i >= 0; i--)
  89     if (SzFolder_FindBindPairForOutStream(p, i) < 0)
  90       return p->UnpackSizes[i];
  91   /* throw 1; */
  92   return 0;
  93 }
  94
  95 void SzFile_Init(CSzFileItem *p)
  96 {
  97   p->HasStream = 1;
  98   p->IsDir = 0;
  99   p->IsAnti = 0;
 100   p->CrcDefined = 0;
 101   p->MTimeDefined = 0;
 102 }
 103
 104 void SzAr_Init(CSzAr *p)
 105 {
 106   p->PackSizes = 0;
 107   p->PackCRCsDefined = 0;
 108   p->PackCRCs = 0;
 109   p->Folders = 0;
 110   p->Files = 0;
 111   p->NumPackStreams = 0;
 112   p->NumFolders = 0;
 113   p->NumFiles = 0;
 114 }
 115
 116 void SzAr_Free(CSzAr *p, ISzAlloc *alloc)
 117 {
 118   UInt32 i;
 119   if (p->Folders)
 120     for (i = 0; i < p->NumFolders; i++)
 121       SzFolder_Free(&p->Folders[i], alloc);
 122
 123   IAlloc_Free(alloc, p->PackSizes);
 124   IAlloc_Free(alloc, p->PackCRCsDefined);
 125   IAlloc_Free(alloc, p->PackCRCs);
 126   IAlloc_Free(alloc, p->Folders);
 127   IAlloc_Free(alloc, p->Files);
 128   SzAr_Init(p);
 129 }
 130
 131
 132 void SzArEx_Init(CSzArEx *p)
 133 {
 134   SzAr_Init(&p->db);
 135   p->FolderStartPackStreamIndex = 0;
 136   p->PackStreamStartPositions = 0;
 137   p->FolderStartFileIndex = 0;
 138   p->FileIndexToFolderIndexMap = 0;
 139   p->FileNameOffsets = 0;
 140   Buf_Init(&p->FileNames);
 141 }
 142
 143 void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc)
 144 {
 145   IAlloc_Free(alloc, p->FolderStartPackStreamIndex);
 146   IAlloc_Free(alloc, p->PackStreamStartPositions);
 147   IAlloc_Free(alloc, p->FolderStartFileIndex);
 148   IAlloc_Free(alloc, p->FileIndexToFolderIndexMap);
 149
 150   IAlloc_Free(alloc, p->FileNameOffsets);
 151   Buf_Free(&p->FileNames, alloc);
 152
 153   SzAr_Free(&p->db, alloc);
 154   SzArEx_Init(p);
 155 }
 156
 157 /*
 158 UInt64 GetFolderPackStreamSize(int folderIndex, int streamIndex) const
 159 {
 160   return PackSizes[FolderStartPackStreamIndex[folderIndex] + streamIndex];
 161 }
 162
 163 UInt64 GetFilePackSize(int fileIndex) const
 164 {
 165   int folderIndex = FileIndexToFolderIndexMap[fileIndex];
 166   if (folderIndex >= 0)
 167   {
 168     const CSzFolder &folderInfo = Folders[folderIndex];
 169     if (FolderStartFileIndex[folderIndex] == fileIndex)
 170     return GetFolderFullPackSize(folderIndex);
 171   }
 172   return 0;
 173 }
 174 */
 175
 176 #define MY_ALLOC(T, p, size, alloc) { if ((size) == 0) p = 0; else \
 177   if ((p = (T *)IAlloc_Alloc(alloc, (size) * sizeof(T))) == 0) return SZ_ERROR_MEM; }
 178
 179 static SRes SzArEx_Fill(CSzArEx *p, ISzAlloc *alloc)
 180 {
 181   UInt32 startPos = 0;
 182   UInt64 startPosSize = 0;
 183   UInt32 i;
 184   UInt32 folderIndex = 0;
 185   UInt32 indexInFolder = 0;
 186   MY_ALLOC(UInt32, p->FolderStartPackStreamIndex, p->db.NumFolders, alloc);
 187   for (i = 0; i < p->db.NumFolders; i++)
 188   {
 189     p->FolderStartPackStreamIndex[i] = startPos;
 190     startPos += p->db.Folders[i].NumPackStreams;
 191   }
 192
 193   MY_ALLOC(UInt64, p->PackStreamStartPositions, p->db.NumPackStreams, alloc);
 194
 195   for (i = 0; i < p->db.NumPackStreams; i++)
 196   {
 197     p->PackStreamStartPositions[i] = startPosSize;
 198     startPosSize += p->db.PackSizes[i];
 199   }
 200
 201   MY_ALLOC(UInt32, p->FolderStartFileIndex, p->db.NumFolders, alloc);
 202   MY_ALLOC(UInt32, p->FileIndexToFolderIndexMap, p->db.NumFiles, alloc);
 203
 204   for (i = 0; i < p->db.NumFiles; i++)
 205   {
 206     CSzFileItem *file = p->db.Files + i;
 207     int emptyStream = !file->HasStream;
 208     if (emptyStream && indexInFolder == 0)
 209     {
 210       p->FileIndexToFolderIndexMap[i] = (UInt32)-1;
 211       continue;
 212     }
 213     if (indexInFolder == 0)
 214     {
 215       /*
 216       v3.13 incorrectly worked with empty folders
 217       v4.07: Loop for skipping empty folders
 218       */
 219       for (;;)
 220       {
 221         if (folderIndex >= p->db.NumFolders)
 222           return SZ_ERROR_ARCHIVE;
 223         p->FolderStartFileIndex[folderIndex] = i;
 224         if (p->db.Folders[folderIndex].NumUnpackStreams != 0)
 225           break;
 226         folderIndex++;
 227       }
 228     }
 229     p->FileIndexToFolderIndexMap[i] = folderIndex;
 230     if (emptyStream)
 231       continue;
 232     indexInFolder++;
 233     if (indexInFolder >= p->db.Folders[folderIndex].NumUnpackStreams)
 234     {
 235       folderIndex++;
 236       indexInFolder = 0;
 237     }
 238   }
 239   return SZ_OK;
 240 }
 241
 242
 243 UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder)
 244 {
 245   return p->dataPos +
 246     p->PackStreamStartPositions[p->FolderStartPackStreamIndex[folderIndex] + indexInFolder];
 247 }
 248
 249 int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize)
 250 {
 251   UInt32 packStreamIndex = p->FolderStartPackStreamIndex[folderIndex];
 252   CSzFolder *folder = p->db.Folders + folderIndex;
 253   UInt64 size = 0;
 254   UInt32 i;
 255   for (i = 0; i < folder->NumPackStreams; i++)
 256   {
 257     UInt64 t = size + p->db.PackSizes[packStreamIndex + i];
 258     if (t < size) /* check it */
 259       return SZ_ERROR_FAIL;
 260     size = t;
 261   }
 262   *resSize = size;
 263   return SZ_OK;
 264 }
 265
 266
 267 /*
 268 SRes SzReadTime(const CObjectVector<CBuf> &dataVector,
 269     CObjectVector<CSzFileItem> &files, UInt64 type)
 270 {
 271   CBoolVector boolVector;
 272   RINOK(ReadBoolVector2(files.Size(), boolVector))
 273
 274   CStreamSwitch streamSwitch;
 275   RINOK(streamSwitch.Set(this, &dataVector));
 276
 277   for (int i = 0; i < files.Size(); i++)
 278   {
 279     CSzFileItem &file = files[i];
 280     CArchiveFileTime fileTime;
 281     bool defined = boolVector[i];
 282     if (defined)
 283     {
 284       UInt32 low, high;
 285       RINOK(SzReadUInt32(low));
 286       RINOK(SzReadUInt32(high));
 287       fileTime.dwLowDateTime = low;
 288       fileTime.dwHighDateTime = high;
 289     }
 290     switch(type)
 291     {
 292       case k7zIdCTime: file.IsCTimeDefined = defined; if (defined) file.CTime = fileTime; break;
 293       case k7zIdATime: file.IsATimeDefined = defined; if (defined) file.ATime = fileTime; break;
 294       case k7zIdMTime: file.IsMTimeDefined = defined; if (defined) file.MTime = fileTime; break;
 295     }
 296   }
 297   return SZ_OK;
 298 }
 299 */
 300
 301 static int TestSignatureCandidate(Byte *testBytes)
 302 {
 303   size_t i;
 304   for (i = 0; i < k7zSignatureSize; i++)
 305     if (testBytes[i] != k7zSignature[i])
 306       return 0;
 307   return 1;
 308 }
 309
 310 typedef struct _CSzState
 311 {
 312   Byte *Data;
 313   size_t Size;
 314 }CSzData;
 315
 316 static SRes SzReadByte(CSzData *sd, Byte *b)
 317 {
 318   if (sd->Size == 0)
 319     return SZ_ERROR_ARCHIVE;
 320   sd->Size--;
 321   *b = *sd->Data++;
 322   return SZ_OK;
 323 }
 324
 325 static SRes SzReadBytes(CSzData *sd, Byte *data, size_t size)
 326 {
 327   size_t i;
 328   for (i = 0; i < size; i++)
 329   {
 330     RINOK(SzReadByte(sd, data + i));
 331   }
 332   return SZ_OK;
 333 }
 334
 335 static SRes SzReadUInt32(CSzData *sd, UInt32 *value)
 336 {
 337   int i;
 338   *value = 0;
 339   for (i = 0; i < 4; i++)
 340   {
 341     Byte b;
 342     RINOK(SzReadByte(sd, &b));
 343     *value |= ((UInt32)(b) << (8 * i));
 344   }
 345   return SZ_OK;
 346 }
 347
 348 static SRes SzReadNumber(CSzData *sd, UInt64 *value)
 349 {
 350   Byte firstByte;
 351   Byte mask = 0x80;
 352   int i;
 353   RINOK(SzReadByte(sd, &firstByte));
 354   *value = 0;
 355   for (i = 0; i < 8; i++)
 356   {
 357     Byte b;
 358     if ((firstByte & mask) == 0)
 359     {
 360       UInt64 highPart = firstByte & (mask - 1);
 361       *value += (highPart << (8 * i));
 362       return SZ_OK;
 363     }
 364     RINOK(SzReadByte(sd, &b));
 365     *value |= ((UInt64)b << (8 * i));
 366     mask >>= 1;
 367   }
 368   return SZ_OK;
 369 }
 370
 371 static SRes SzReadNumber32(CSzData *sd, UInt32 *value)
 372 {
 373   UInt64 value64;
 374   RINOK(SzReadNumber(sd, &value64));
 375   if (value64 >= 0x80000000)
 376     return SZ_ERROR_UNSUPPORTED;
 377   if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 2)))
 378     return SZ_ERROR_UNSUPPORTED;
 379   *value = (UInt32)value64;
 380   return SZ_OK;
 381 }
 382
 383 static SRes SzReadID(CSzData *sd, UInt64 *value)
 384 {
 385   return SzReadNumber(sd, value);
 386 }
 387
 388 static SRes SzSkeepDataSize(CSzData *sd, UInt64 size)
 389 {
 390   if (size > sd->Size)
 391     return SZ_ERROR_ARCHIVE;
 392   sd->Size -= (size_t)size;
 393   sd->Data += (size_t)size;
 394   return SZ_OK;
 395 }
 396
 397 static SRes SzSkeepData(CSzData *sd)
 398 {
 399   UInt64 size;
 400   RINOK(SzReadNumber(sd, &size));
 401   return SzSkeepDataSize(sd, size);
 402 }
 403
 404 static SRes SzReadArchiveProperties(CSzData *sd)
 405 {
 406   for (;;)
 407   {
 408     UInt64 type;
 409     RINOK(SzReadID(sd, &type));
 410     if (type == k7zIdEnd)
 411       break;
 412     SzSkeepData(sd);
 413   }
 414   return SZ_OK;
 415 }
 416
 417 static SRes SzWaitAttribute(CSzData *sd, UInt64 attribute)
 418 {
 419   for (;;)
 420   {
 421     UInt64 type;
 422     RINOK(SzReadID(sd, &type));
 423     if (type == attribute)
 424       return SZ_OK;
 425     if (type == k7zIdEnd)
 426       return SZ_ERROR_ARCHIVE;
 427     RINOK(SzSkeepData(sd));
 428   }
 429 }
 430
 431 static SRes SzReadBoolVector(CSzData *sd, size_t numItems, Byte **v, ISzAlloc *alloc)
 432 {
 433   Byte b = 0;
 434   Byte mask = 0;
 435   size_t i;
 436   MY_ALLOC(Byte, *v, numItems, alloc);
 437   for (i = 0; i < numItems; i++)
 438   {
 439     if (mask == 0)
 440     {
 441       RINOK(SzReadByte(sd, &b));
 442       mask = 0x80;
 443     }
 444     (*v)[i] = (Byte)(((b & mask) != 0) ? 1 : 0);
 445     mask >>= 1;
 446   }
 447   return SZ_OK;
 448 }
 449
 450 static SRes SzReadBoolVector2(CSzData *sd, size_t numItems, Byte **v, ISzAlloc *alloc)
 451 {
 452   Byte allAreDefined;
 453   size_t i;
 454   RINOK(SzReadByte(sd, &allAreDefined));
 455   if (allAreDefined == 0)
 456     return SzReadBoolVector(sd, numItems, v, alloc);
 457   MY_ALLOC(Byte, *v, numItems, alloc);
 458   for (i = 0; i < numItems; i++)
 459     (*v)[i] = 1;
 460   return SZ_OK;
 461 }
 462
 463 static SRes SzReadHashDigests(
 464     CSzData *sd,
 465     size_t numItems,
 466     Byte **digestsDefined,
 467     UInt32 **digests,
 468     ISzAlloc *alloc)
 469 {
 470   size_t i;
 471   RINOK(SzReadBoolVector2(sd, numItems, digestsDefined, alloc));
 472   MY_ALLOC(UInt32, *digests, numItems, alloc);
 473   for (i = 0; i < numItems; i++)
 474     if ((*digestsDefined)[i])
 475     {
 476       RINOK(SzReadUInt32(sd, (*digests) + i));
 477     }
 478   return SZ_OK;
 479 }
 480
 481 static SRes SzReadPackInfo(
 482     CSzData *sd,
 483     UInt64 *dataOffset,
 484     UInt32 *numPackStreams,
 485     UInt64 **packSizes,
 486     Byte **packCRCsDefined,
 487     UInt32 **packCRCs,
 488     ISzAlloc *alloc)
 489 {
 490   UInt32 i;
 491   RINOK(SzReadNumber(sd, dataOffset));
 492   RINOK(SzReadNumber32(sd, numPackStreams));
 493
 494   RINOK(SzWaitAttribute(sd, k7zIdSize));
 495
 496   MY_ALLOC(UInt64, *packSizes, (size_t)*numPackStreams, alloc);
 497
 498   for (i = 0; i < *numPackStreams; i++)
 499   {
 500     RINOK(SzReadNumber(sd, (*packSizes) + i));
 501   }
 502
 503   for (;;)
 504   {
 505     UInt64 type;
 506     RINOK(SzReadID(sd, &type));
 507     if (type == k7zIdEnd)
 508       break;
 509     if (type == k7zIdCRC)
 510     {
 511       RINOK(SzReadHashDigests(sd, (size_t)*numPackStreams, packCRCsDefined, packCRCs, alloc));
 512       continue;
 513     }
 514     RINOK(SzSkeepData(sd));
 515   }
 516   if (*packCRCsDefined == 0)
 517   {
 518     MY_ALLOC(Byte, *packCRCsDefined, (size_t)*numPackStreams, alloc);
 519     MY_ALLOC(UInt32, *packCRCs, (size_t)*numPackStreams, alloc);
 520     for (i = 0; i < *numPackStreams; i++)
 521     {
 522       (*packCRCsDefined)[i] = 0;
 523       (*packCRCs)[i] = 0;
 524     }
 525   }
 526   return SZ_OK;
 527 }
 528
 529 static SRes SzReadSwitch(CSzData *sd)
 530 {
 531   Byte external;
 532   RINOK(SzReadByte(sd, &external));
 533   return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;
 534 }
 535
 536 static SRes SzGetNextFolderItem(CSzData *sd, CSzFolder *folder, ISzAlloc *alloc)
 537 {
 538   UInt32 numCoders, numBindPairs, numPackStreams, i;
 539   UInt32 numInStreams = 0, numOutStreams = 0;
 540
 541   RINOK(SzReadNumber32(sd, &numCoders));
 542   if (numCoders > NUM_FOLDER_CODERS_MAX)
 543     return SZ_ERROR_UNSUPPORTED;
 544   folder->NumCoders = numCoders;
 545
 546   MY_ALLOC(CSzCoderInfo, folder->Coders, (size_t)numCoders, alloc);
 547
 548   for (i = 0; i < numCoders; i++)
 549     SzCoderInfo_Init(folder->Coders + i);
 550
 551   for (i = 0; i < numCoders; i++)
 552   {
 553     Byte mainByte;
 554     CSzCoderInfo *coder = folder->Coders + i;
 555     {
 556       unsigned idSize, j;
 557       Byte longID[15];
 558       RINOK(SzReadByte(sd, &mainByte));
 559       idSize = (unsigned)(mainByte & 0xF);
 560       RINOK(SzReadBytes(sd, longID, idSize));
 561       if (idSize > sizeof(coder->MethodID))
 562         return SZ_ERROR_UNSUPPORTED;
 563       coder->MethodID = 0;
 564       for (j = 0; j < idSize; j++)
 565         coder->MethodID |= (UInt64)longID[idSize - 1 - j] << (8 * j);
 566
 567       if ((mainByte & 0x10) != 0)
 568       {
 569         RINOK(SzReadNumber32(sd, &coder->NumInStreams));
 570         RINOK(SzReadNumber32(sd, &coder->NumOutStreams));
 571         if (coder->NumInStreams > NUM_CODER_STREAMS_MAX ||
 572             coder->NumOutStreams > NUM_CODER_STREAMS_MAX)
 573           return SZ_ERROR_UNSUPPORTED;
 574       }
 575       else
 576       {
 577         coder->NumInStreams = 1;
 578         coder->NumOutStreams = 1;
 579       }
 580       if ((mainByte & 0x20) != 0)
 581       {
 582         UInt64 propertiesSize = 0;
 583         RINOK(SzReadNumber(sd, &propertiesSize));
 584         if (!Buf_Create(&coder->Props, (size_t)propertiesSize, alloc))
 585           return SZ_ERROR_MEM;
 586         RINOK(SzReadBytes(sd, coder->Props.data, (size_t)propertiesSize));
 587       }
 588     }
 589     while ((mainByte & 0x80) != 0)
 590     {
 591       RINOK(SzReadByte(sd, &mainByte));
 592       RINOK(SzSkeepDataSize(sd, (mainByte & 0xF)));
 593       if ((mainByte & 0x10) != 0)
 594       {
 595         UInt32 n;
 596         RINOK(SzReadNumber32(sd, &n));
 597         RINOK(SzReadNumber32(sd, &n));
 598       }
 599       if ((mainByte & 0x20) != 0)
 600       {
 601         UInt64 propertiesSize = 0;
 602         RINOK(SzReadNumber(sd, &propertiesSize));
 603         RINOK(SzSkeepDataSize(sd, propertiesSize));
 604       }
 605     }
 606     numInStreams += coder->NumInStreams;
 607     numOutStreams += coder->NumOutStreams;
 608   }
 609
 610   if (numOutStreams == 0)
 611     return SZ_ERROR_UNSUPPORTED;
 612
 613   folder->NumBindPairs = numBindPairs = numOutStreams - 1;
 614   MY_ALLOC(CSzBindPair, folder->BindPairs, (size_t)numBindPairs, alloc);
 615
 616   for (i = 0; i < numBindPairs; i++)
 617   {
 618     CSzBindPair *bp = folder->BindPairs + i;
 619     RINOK(SzReadNumber32(sd, &bp->InIndex));
 620     RINOK(SzReadNumber32(sd, &bp->OutIndex));
 621   }
 622
 623   if (numInStreams < numBindPairs)
 624     return SZ_ERROR_UNSUPPORTED;
 625
 626   folder->NumPackStreams = numPackStreams = numInStreams - numBindPairs;
 627   MY_ALLOC(UInt32, folder->PackStreams, (size_t)numPackStreams, alloc);
 628
 629   if (numPackStreams == 1)
 630   {
 631     for (i = 0; i < numInStreams ; i++)
 632       if (SzFolder_FindBindPairForInStream(folder, i) < 0)
 633         break;
 634     if (i == numInStreams)
 635       return SZ_ERROR_UNSUPPORTED;
 636     folder->PackStreams[0] = i;
 637   }
 638   else
 639     for (i = 0; i < numPackStreams; i++)
 640     {
 641       RINOK(SzReadNumber32(sd, folder->PackStreams + i));
 642     }
 643   return SZ_OK;
 644 }
 645
 646 static SRes SzReadUnpackInfo(
 647     CSzData *sd,
 648     UInt32 *numFolders,
 649     CSzFolder **folders,  /* for alloc */
 650     ISzAlloc *alloc,
 651     ISzAlloc *allocTemp)
 652 {
 653   UInt32 i;
 654   RINOK(SzWaitAttribute(sd, k7zIdFolder));
 655   RINOK(SzReadNumber32(sd, numFolders));
 656   {
 657     RINOK(SzReadSwitch(sd));
 658
 659     MY_ALLOC(CSzFolder, *folders, (size_t)*numFolders, alloc);
 660
 661     for (i = 0; i < *numFolders; i++)
 662       SzFolder_Init((*folders) + i);
 663
 664     for (i = 0; i < *numFolders; i++)
 665     {
 666       RINOK(SzGetNextFolderItem(sd, (*folders) + i, alloc));
 667     }
 668   }
 669
 670   RINOK(SzWaitAttribute(sd, k7zIdCodersUnpackSize));
 671
 672   for (i = 0; i < *numFolders; i++)
 673   {
 674     UInt32 j;
 675     CSzFolder *folder = (*folders) + i;
 676     UInt32 numOutStreams = SzFolder_GetNumOutStreams(folder);
 677
 678     MY_ALLOC(UInt64, folder->UnpackSizes, (size_t)numOutStreams, alloc);
 679
 680     for (j = 0; j < numOutStreams; j++)
 681     {
 682       RINOK(SzReadNumber(sd, folder->UnpackSizes + j));
 683     }
 684   }
 685
 686   for (;;)
 687   {
 688     UInt64 type;
 689     RINOK(SzReadID(sd, &type));
 690     if (type == k7zIdEnd)
 691       return SZ_OK;
 692     if (type == k7zIdCRC)
 693     {
 694       SRes res;
 695       Byte *crcsDefined = 0;
 696       UInt32 *crcs = 0;
 697       res = SzReadHashDigests(sd, *numFolders, &crcsDefined, &crcs, allocTemp);
 698       if (res == SZ_OK)
 699       {
 700         for (i = 0; i < *numFolders; i++)
 701         {
 702           CSzFolder *folder = (*folders) + i;
 703           folder->UnpackCRCDefined = crcsDefined[i];
 704           folder->UnpackCRC = crcs[i];
 705         }
 706       }
 707       IAlloc_Free(allocTemp, crcs);
 708       IAlloc_Free(allocTemp, crcsDefined);
 709       RINOK(res);
 710       continue;
 711     }
 712     RINOK(SzSkeepData(sd));
 713   }
 714 }
 715
 716 static SRes SzReadSubStreamsInfo(
 717     CSzData *sd,
 718     UInt32 numFolders,
 719     CSzFolder *folders,
 720     UInt32 *numUnpackStreams,
 721     UInt64 **unpackSizes,
 722     Byte **digestsDefined,
 723     UInt32 **digests,
 724     ISzAlloc *allocTemp)
 725 {
 726   UInt64 type = 0;
 727   UInt32 i;
 728   UInt32 si = 0;
 729   UInt32 numDigests = 0;
 730
 731   for (i = 0; i < numFolders; i++)
 732     folders[i].NumUnpackStreams = 1;
 733   *numUnpackStreams = numFolders;
 734
 735   for (;;)
 736   {
 737     RINOK(SzReadID(sd, &type));
 738     if (type == k7zIdNumUnpackStream)
 739     {
 740       *numUnpackStreams = 0;
 741       for (i = 0; i < numFolders; i++)
 742       {
 743         UInt32 numStreams;
 744         RINOK(SzReadNumber32(sd, &numStreams));
 745         folders[i].NumUnpackStreams = numStreams;
 746         *numUnpackStreams += numStreams;
 747       }
 748       continue;
 749     }
 750     if (type == k7zIdCRC || type == k7zIdSize)
 751       break;
 752     if (type == k7zIdEnd)
 753       break;
 754     RINOK(SzSkeepData(sd));
 755   }
 756
 757   if (*numUnpackStreams == 0)
 758   {
 759     *unpackSizes = 0;
 760     *digestsDefined = 0;
 761     *digests = 0;
 762   }
 763   else
 764   {
 765     *unpackSizes = (UInt64 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt64));
 766     RINOM(*unpackSizes);
 767     *digestsDefined = (Byte *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(Byte));
 768     RINOM(*digestsDefined);
 769     *digests = (UInt32 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt32));
 770     RINOM(*digests);
 771   }
 772
 773   for (i = 0; i < numFolders; i++)
 774   {
 775     /*
 776     v3.13 incorrectly worked with empty folders
 777     v4.07: we check that folder is empty
 778     */
 779     UInt64 sum = 0;
 780     UInt32 j;
 781     UInt32 numSubstreams = folders[i].NumUnpackStreams;
 782     if (numSubstreams == 0)
 783       continue;
 784     if (type == k7zIdSize)
 785     for (j = 1; j < numSubstreams; j++)
 786     {
 787       UInt64 size;
 788       RINOK(SzReadNumber(sd, &size));
 789       (*unpackSizes)[si++] = size;
 790       sum += size;
 791     }
 792     (*unpackSizes)[si++] = SzFolder_GetUnpackSize(folders + i) - sum;
 793   }
 794   if (type == k7zIdSize)
 795   {
 796     RINOK(SzReadID(sd, &type));
 797   }
 798
 799   for (i = 0; i < *numUnpackStreams; i++)
 800   {
 801     (*digestsDefined)[i] = 0;
 802     (*digests)[i] = 0;
 803   }
 804
 805
 806   for (i = 0; i < numFolders; i++)
 807   {
 808     UInt32 numSubstreams = folders[i].NumUnpackStreams;
 809     if (numSubstreams != 1 || !folders[i].UnpackCRCDefined)
 810       numDigests += numSubstreams;
 811   }
 812
 813
 814   si = 0;
 815   for (;;)
 816   {
 817     if (type == k7zIdCRC)
 818     {
 819       int digestIndex = 0;
 820       Byte *digestsDefined2 = 0;
 821       UInt32 *digests2 = 0;
 822       SRes res = SzReadHashDigests(sd, numDigests, &digestsDefined2, &digests2, allocTemp);
 823       if (res == SZ_OK)
 824       {
 825         for (i = 0; i < numFolders; i++)
 826         {
 827           CSzFolder *folder = folders + i;
 828           UInt32 numSubstreams = folder->NumUnpackStreams;
 829           if (numSubstreams == 1 && folder->UnpackCRCDefined)
 830           {
 831             (*digestsDefined)[si] = 1;
 832             (*digests)[si] = folder->UnpackCRC;
 833             si++;
 834           }
 835           else
 836           {
 837             UInt32 j;
 838             for (j = 0; j < numSubstreams; j++, digestIndex++)
 839             {
 840               (*digestsDefined)[si] = digestsDefined2[digestIndex];
 841               (*digests)[si] = digests2[digestIndex];
 842               si++;
 843             }
 844           }
 845         }
 846       }
 847       IAlloc_Free(allocTemp, digestsDefined2);
 848       IAlloc_Free(allocTemp, digests2);
 849       RINOK(res);
 850     }
 851     else if (type == k7zIdEnd)
 852       return SZ_OK;
 853     else
 854     {
 855       RINOK(SzSkeepData(sd));
 856     }
 857     RINOK(SzReadID(sd, &type));
 858   }
 859 }
 860
 861
 862 static SRes SzReadStreamsInfo(
 863     CSzData *sd,
 864     UInt64 *dataOffset,
 865     CSzAr *p,
 866     UInt32 *numUnpackStreams,
 867     UInt64 **unpackSizes, /* allocTemp */
 868     Byte **digestsDefined,   /* allocTemp */
 869     UInt32 **digests,        /* allocTemp */
 870     ISzAlloc *alloc,
 871     ISzAlloc *allocTemp)
 872 {
 873   for (;;)
 874   {
 875     UInt64 type;
 876     RINOK(SzReadID(sd, &type));
 877     if ((UInt64)(int)type != type)
 878       return SZ_ERROR_UNSUPPORTED;
 879     switch((int)type)
 880     {
 881       case k7zIdEnd:
 882         return SZ_OK;
 883       case k7zIdPackInfo:
 884       {
 885         RINOK(SzReadPackInfo(sd, dataOffset, &p->NumPackStreams,
 886             &p->PackSizes, &p->PackCRCsDefined, &p->PackCRCs, alloc));
 887         break;
 888       }
 889       case k7zIdUnpackInfo:
 890       {
 891         RINOK(SzReadUnpackInfo(sd, &p->NumFolders, &p->Folders, alloc, allocTemp));
 892         break;
 893       }
 894       case k7zIdSubStreamsInfo:
 895       {
 896         RINOK(SzReadSubStreamsInfo(sd, p->NumFolders, p->Folders,
 897             numUnpackStreams, unpackSizes, digestsDefined, digests, allocTemp));
 898         break;
 899       }
 900       default:
 901         return SZ_ERROR_UNSUPPORTED;
 902     }
 903   }
 904 }
 905
 906 size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
 907 {
 908   size_t len = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
 909   if (dest != 0)
 910   {
 911     size_t i;
 912     const Byte *src = p->FileNames.data + (p->FileNameOffsets[fileIndex] * 2);
 913     for (i = 0; i < len; i++)
 914       dest[i] = GetUi16(src + i * 2);
 915   }
 916   return len;
 917 }
 918
 919 static SRes SzReadFileNames(const Byte *p, size_t size, UInt32 numFiles, size_t *sizes)
 920 {
 921   UInt32 i;
 922   size_t pos = 0;
 923   for (i = 0; i < numFiles; i++)
 924   {
 925     sizes[i] = pos;
 926     for (;;)
 927     {
 928       if (pos >= size)
 929         return SZ_ERROR_ARCHIVE;
 930       if (p[pos * 2] == 0 && p[pos * 2 + 1] == 0)
 931         break;
 932       pos++;
 933     }
 934     pos++;
 935   }
 936   sizes[i] = pos;
 937   return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
 938 }
 939
 940 static SRes SzReadHeader2(
 941     CSzArEx *p,   /* allocMain */
 942     CSzData *sd,
 943     UInt64 **unpackSizes,  /* allocTemp */
 944     Byte **digestsDefined,    /* allocTemp */
 945     UInt32 **digests,         /* allocTemp */
 946     Byte **emptyStreamVector, /* allocTemp */
 947     Byte **emptyFileVector,   /* allocTemp */
 948     Byte **lwtVector,         /* allocTemp */
 949     ISzAlloc *allocMain,
 950     ISzAlloc *allocTemp)
 951 {
 952   UInt64 type;
 953   UInt32 numUnpackStreams = 0;
 954   UInt32 numFiles = 0;
 955   CSzFileItem *files = 0;
 956   UInt32 numEmptyStreams = 0;
 957   UInt32 i;
 958
 959   RINOK(SzReadID(sd, &type));
 960
 961   if (type == k7zIdArchiveProperties)
 962   {
 963     RINOK(SzReadArchiveProperties(sd));
 964     RINOK(SzReadID(sd, &type));
 965   }
 966
 967
 968   if (type == k7zIdMainStreamsInfo)
 969   {
 970     RINOK(SzReadStreamsInfo(sd,
 971         &p->dataPos,
 972         &p->db,
 973         &numUnpackStreams,
 974         unpackSizes,
 975         digestsDefined,
 976         digests, allocMain, allocTemp));
 977     p->dataPos += p->startPosAfterHeader;
 978     RINOK(SzReadID(sd, &type));
 979   }
 980
 981   if (type == k7zIdEnd)
 982     return SZ_OK;
 983   if (type != k7zIdFilesInfo)
 984     return SZ_ERROR_ARCHIVE;
 985
 986   RINOK(SzReadNumber32(sd, &numFiles));
 987   p->db.NumFiles = numFiles;
 988
 989   MY_ALLOC(CSzFileItem, files, (size_t)numFiles, allocMain);
 990
 991   p->db.Files = files;
 992   for (i = 0; i < numFiles; i++)
 993     SzFile_Init(files + i);
 994
 995   for (;;)
 996   {
 997     UInt64 type;
 998     UInt64 size;
 999     RINOK(SzReadID(sd, &type));
1000     if (type == k7zIdEnd)
1001       break;
1002     RINOK(SzReadNumber(sd, &size));
1003     if (size > sd->Size)
1004       return SZ_ERROR_ARCHIVE;
1005     if ((UInt64)(int)type != type)
1006     {
1007       RINOK(SzSkeepDataSize(sd, size));
1008     }
1009     else
1010     switch((int)type)
1011     {
1012       case k7zIdName:
1013       {
1014         size_t namesSize;
1015         RINOK(SzReadSwitch(sd));
1016         namesSize = (size_t)size - 1;
1017         if ((namesSize & 1) != 0)
1018           return SZ_ERROR_ARCHIVE;
1019         if (!Buf_Create(&p->FileNames, namesSize, allocMain))
1020           return SZ_ERROR_MEM;
1021         MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain);
1022         memcpy(p->FileNames.data, sd->Data, namesSize);
1023         RINOK(SzReadFileNames(sd->Data, namesSize >> 1, numFiles, p->FileNameOffsets))
1024         RINOK(SzSkeepDataSize(sd, namesSize));
1025         break;
1026       }
1027       case k7zIdEmptyStream:
1028       {
1029         RINOK(SzReadBoolVector(sd, numFiles, emptyStreamVector, allocTemp));
1030         numEmptyStreams = 0;
1031         for (i = 0; i < numFiles; i++)
1032           if ((*emptyStreamVector)[i])
1033             numEmptyStreams++;
1034         break;
1035       }
1036       case k7zIdEmptyFile:
1037       {
1038         RINOK(SzReadBoolVector(sd, numEmptyStreams, emptyFileVector, allocTemp));
1039         break;
1040       }
1041       case k7zIdWinAttributes:
1042       {
1043         RINOK(SzReadBoolVector2(sd, numFiles, lwtVector, allocTemp));
1044         RINOK(SzReadSwitch(sd));
1045         for (i = 0; i < numFiles; i++)
1046         {
1047           CSzFileItem *f = &files[i];
1048           Byte defined = (*lwtVector)[i];
1049           f->AttribDefined = defined;
1050           f->Attrib = 0;
1051           if (defined)
1052           {
1053             RINOK(SzReadUInt32(sd, &f->Attrib));
1054           }
1055         }
1056         IAlloc_Free(allocTemp, *lwtVector);
1057         *lwtVector = NULL;
1058         break;
1059       }
1060       case k7zIdMTime:
1061       {
1062         RINOK(SzReadBoolVector2(sd, numFiles, lwtVector, allocTemp));
1063         RINOK(SzReadSwitch(sd));
1064         for (i = 0; i < numFiles; i++)
1065         {
1066           CSzFileItem *f = &files[i];
1067           Byte defined = (*lwtVector)[i];
1068           f->MTimeDefined = defined;
1069           f->MTime.Low = f->MTime.High = 0;
1070           if (defined)
1071           {
1072             RINOK(SzReadUInt32(sd, &f->MTime.Low));
1073             RINOK(SzReadUInt32(sd, &f->MTime.High));
1074           }
1075         }
1076         IAlloc_Free(allocTemp, *lwtVector);
1077         *lwtVector = NULL;
1078         break;
1079       }
1080       default:
1081       {
1082         RINOK(SzSkeepDataSize(sd, size));
1083       }
1084     }
1085   }
1086
1087   {
1088     UInt32 emptyFileIndex = 0;
1089     UInt32 sizeIndex = 0;
1090     for (i = 0; i < numFiles; i++)
1091     {
1092       CSzFileItem *file = files + i;
1093       file->IsAnti = 0;
1094       if (*emptyStreamVector == 0)
1095         file->HasStream = 1;
1096       else
1097         file->HasStream = (Byte)((*emptyStreamVector)[i] ? 0 : 1);
1098       if (file->HasStream)
1099       {
1100         file->IsDir = 0;
1101         file->Size = (*unpackSizes)[sizeIndex];
1102         file->Crc = (*digests)[sizeIndex];
1103         file->CrcDefined = (Byte)(*digestsDefined)[sizeIndex];
1104         sizeIndex++;
1105       }
1106       else
1107       {
1108         if (*emptyFileVector == 0)
1109           file->IsDir = 1;
1110         else
1111           file->IsDir = (Byte)((*emptyFileVector)[emptyFileIndex] ? 0 : 1);
1112         emptyFileIndex++;
1113         file->Size = 0;
1114         file->Crc = 0;
1115         file->CrcDefined = 0;
1116       }
1117     }
1118   }
1119   return SzArEx_Fill(p, allocMain);
1120 }
1121
1122 static SRes SzReadHeader(
1123     CSzArEx *p,
1124     CSzData *sd,
1125     ISzAlloc *allocMain,
1126     ISzAlloc *allocTemp)
1127 {
1128   UInt64 *unpackSizes = 0;
1129   Byte *digestsDefined = 0;
1130   UInt32 *digests = 0;
1131   Byte *emptyStreamVector = 0;
1132   Byte *emptyFileVector = 0;
1133   Byte *lwtVector = 0;
1134   SRes res = SzReadHeader2(p, sd,
1135       &unpackSizes, &digestsDefined, &digests,
1136       &emptyStreamVector, &emptyFileVector, &lwtVector,
1137       allocMain, allocTemp);
1138   IAlloc_Free(allocTemp, unpackSizes);
1139   IAlloc_Free(allocTemp, digestsDefined);
1140   IAlloc_Free(allocTemp, digests);
1141   IAlloc_Free(allocTemp, emptyStreamVector);
1142   IAlloc_Free(allocTemp, emptyFileVector);
1143   IAlloc_Free(allocTemp, lwtVector);
1144   return res;
1145 }
1146
1147 static SRes SzReadAndDecodePackedStreams2(
1148     ILookInStream *inStream,
1149     CSzData *sd,
1150     CBuf *outBuffer,
1151     UInt64 baseOffset,
1152     CSzAr *p,
1153     UInt64 **unpackSizes,
1154     Byte **digestsDefined,
1155     UInt32 **digests,
1156     ISzAlloc *allocTemp)
1157 {
1158
1159   UInt32 numUnpackStreams = 0;
1160   UInt64 dataStartPos;
1161   CSzFolder *folder;
1162   UInt64 unpackSize;
1163   SRes res;
1164
1165   RINOK(SzReadStreamsInfo(sd, &dataStartPos, p,
1166       &numUnpackStreams,  unpackSizes, digestsDefined, digests,
1167       allocTemp, allocTemp));
1168
1169   dataStartPos += baseOffset;
1170   if (p->NumFolders != 1)
1171     return SZ_ERROR_ARCHIVE;
1172
1173   folder = p->Folders;
1174   unpackSize = SzFolder_GetUnpackSize(folder);
1175
1176   RINOK(LookInStream_SeekTo(inStream, dataStartPos));
1177
1178   if (!Buf_Create(outBuffer, (size_t)unpackSize, allocTemp))
1179     return SZ_ERROR_MEM;
1180
1181   res = SzFolder_Decode(folder, p->PackSizes,
1182           inStream, dataStartPos,
1183           outBuffer->data, (size_t)unpackSize, allocTemp);
1184   RINOK(res);
1185   if (folder->UnpackCRCDefined)
1186     if (CrcCalc(outBuffer->data, (size_t)unpackSize) != folder->UnpackCRC)
1187       return SZ_ERROR_CRC;
1188   return SZ_OK;
1189 }
1190
1191 static SRes SzReadAndDecodePackedStreams(
1192     ILookInStream *inStream,
1193     CSzData *sd,
1194     CBuf *outBuffer,
1195     UInt64 baseOffset,
1196     ISzAlloc *allocTemp)
1197 {
1198   CSzAr p;
1199   UInt64 *unpackSizes = 0;
1200   Byte *digestsDefined = 0;
1201   UInt32 *digests = 0;
1202   SRes res;
1203   SzAr_Init(&p);
1204   res = SzReadAndDecodePackedStreams2(inStream, sd, outBuffer, baseOffset,
1205     &p, &unpackSizes, &digestsDefined, &digests,
1206     allocTemp);
1207   SzAr_Free(&p, allocTemp);
1208   IAlloc_Free(allocTemp, unpackSizes);
1209   IAlloc_Free(allocTemp, digestsDefined);
1210   IAlloc_Free(allocTemp, digests);
1211   return res;
1212 }
1213
1214 static SRes SzArEx_Open2(
1215     CSzArEx *p,
1216     ILookInStream *inStream,
1217     ISzAlloc *allocMain,
1218     ISzAlloc *allocTemp)
1219 {
1220   Byte header[k7zStartHeaderSize];
1221   Int64 startArcPos;
1222   UInt64 nextHeaderOffset, nextHeaderSize;
1223   size_t nextHeaderSizeT;
1224   UInt32 nextHeaderCRC;
1225   CBuf buffer;
1226   SRes res;
1227
1228   startArcPos = 0;
1229   RINOK(inStream->Seek(inStream, &startArcPos, SZ_SEEK_CUR));
1230
1231   RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE));
1232
1233   if (!TestSignatureCandidate(header))
1234     return SZ_ERROR_NO_ARCHIVE;
1235   if (header[6] != k7zMajorVersion)
1236     return SZ_ERROR_UNSUPPORTED;
1237
1238   nextHeaderOffset = GetUi64(header + 12);
1239   nextHeaderSize = GetUi64(header + 20);
1240   nextHeaderCRC = GetUi32(header + 28);
1241
1242   p->startPosAfterHeader = startArcPos + k7zStartHeaderSize;
1243
1244   if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
1245     return SZ_ERROR_CRC;
1246
1247   nextHeaderSizeT = (size_t)nextHeaderSize;
1248   if (nextHeaderSizeT != nextHeaderSize)
1249     return SZ_ERROR_MEM;
1250   if (nextHeaderSizeT == 0)
1251     return SZ_OK;
1252   if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||
1253       nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)
1254     return SZ_ERROR_NO_ARCHIVE;
1255
1256   {
1257     Int64 pos = 0;
1258     RINOK(inStream->Seek(inStream, &pos, SZ_SEEK_END));
1259     if ((UInt64)pos < startArcPos + nextHeaderOffset ||
1260         (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
1261         (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
1262       return SZ_ERROR_INPUT_EOF;
1263   }
1264
1265   RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset));
1266
1267   if (!Buf_Create(&buffer, nextHeaderSizeT, allocTemp))
1268     return SZ_ERROR_MEM;
1269
1270   res = LookInStream_Read(inStream, buffer.data, nextHeaderSizeT);
1271   if (res == SZ_OK)
1272   {
1273     res = SZ_ERROR_ARCHIVE;
1274     if (CrcCalc(buffer.data, nextHeaderSizeT) == nextHeaderCRC)
1275     {
1276       CSzData sd;
1277       UInt64 type;
1278       sd.Data = buffer.data;
1279       sd.Size = buffer.size;
1280       res = SzReadID(&sd, &type);
1281       if (res == SZ_OK)
1282       {
1283         if (type == k7zIdEncodedHeader)
1284         {
1285           CBuf outBuffer;
1286           Buf_Init(&outBuffer);
1287           res = SzReadAndDecodePackedStreams(inStream, &sd, &outBuffer, p->startPosAfterHeader, allocTemp);
1288           if (res != SZ_OK)
1289             Buf_Free(&outBuffer, allocTemp);
1290           else
1291           {
1292             Buf_Free(&buffer, allocTemp);
1293             buffer.data = outBuffer.data;
1294             buffer.size = outBuffer.size;
1295             sd.Data = buffer.data;
1296             sd.Size = buffer.size;
1297             res = SzReadID(&sd, &type);
1298           }
1299         }
1300       }
1301       if (res == SZ_OK)
1302       {
1303         if (type == k7zIdHeader)
1304           res = SzReadHeader(p, &sd, allocMain, allocTemp);
1305         else
1306           res = SZ_ERROR_UNSUPPORTED;
1307       }
1308     }
1309   }
1310   Buf_Free(&buffer, allocTemp);
1311   return res;
1312 }
1313
1314 SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp)
1315 {
1316   SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);
1317   if (res != SZ_OK)
1318     SzArEx_Free(p, allocMain);
1319   return res;
1320 }
1321
1322 SRes SzArEx_Extract(
1323     const CSzArEx *p,
1324     ILookInStream *inStream,
1325     UInt32 fileIndex,
1326     UInt32 *blockIndex,
1327     Byte **outBuffer,
1328     size_t *outBufferSize,
1329     size_t *offset,
1330     size_t *outSizeProcessed,
1331     ISzAlloc *allocMain,
1332     ISzAlloc *allocTemp)
1333 {
1334   UInt32 folderIndex = p->FileIndexToFolderIndexMap[fileIndex];
1335   SRes res = SZ_OK;
1336   *offset = 0;
1337   *outSizeProcessed = 0;
1338   if (folderIndex == (UInt32)-1)
1339   {
1340     IAlloc_Free(allocMain, *outBuffer);
1341     *blockIndex = folderIndex;
1342     *outBuffer = 0;
1343     *outBufferSize = 0;
1344     return SZ_OK;
1345   }
1346
1347   if (*outBuffer == 0 || *blockIndex != folderIndex)
1348   {
1349     CSzFolder *folder = p->db.Folders + folderIndex;
1350     UInt64 unpackSizeSpec = SzFolder_GetUnpackSize(folder);
1351     size_t unpackSize = (size_t)unpackSizeSpec;
1352     UInt64 startOffset = SzArEx_GetFolderStreamPos(p, folderIndex, 0);
1353
1354     if (unpackSize != unpackSizeSpec)
1355       return SZ_ERROR_MEM;
1356     *blockIndex = folderIndex;
1357     IAlloc_Free(allocMain, *outBuffer);
1358     *outBuffer = 0;
1359
1360     RINOK(LookInStream_SeekTo(inStream, startOffset));
1361
1362     if (res == SZ_OK)
1363     {
1364       *outBufferSize = unpackSize;
1365       if (unpackSize != 0)
1366       {
1367         *outBuffer = (Byte *)IAlloc_Alloc(allocMain, unpackSize);
1368         if (*outBuffer == 0)
1369           res = SZ_ERROR_MEM;
1370       }
1371       if (res == SZ_OK)
1372       {
1373         res = SzFolder_Decode(folder,
1374           p->db.PackSizes + p->FolderStartPackStreamIndex[folderIndex],
1375           inStream, startOffset,
1376           *outBuffer, unpackSize, allocTemp);
1377         if (res == SZ_OK)
1378         {
1379           if (folder->UnpackCRCDefined)
1380           {
1381             if (CrcCalc(*outBuffer, unpackSize) != folder->UnpackCRC)
1382               res = SZ_ERROR_CRC;
1383           }
1384         }
1385       }
1386     }
1387   }
1388   if (res == SZ_OK)
1389   {
1390     UInt32 i;
1391     CSzFileItem *fileItem = p->db.Files + fileIndex;
1392     *offset = 0;
1393     for (i = p->FolderStartFileIndex[folderIndex]; i < fileIndex; i++)
1394       *offset += (UInt32)p->db.Files[i].Size;
1395     *outSizeProcessed = (size_t)fileItem->Size;
1396     if (*offset + *outSizeProcessed > *outBufferSize)
1397       return SZ_ERROR_FAIL;
1398     if (fileItem->CrcDefined && CrcCalc(*outBuffer + *offset, *outSizeProcessed) != fileItem->Crc)
1399       res = SZ_ERROR_CRC;
1400   }
1401   return res;
1402 }