other-licenses/7zstub/src/C/7zArcIn.c

   1 /* 7zArcIn.c -- 7z Input functions
   2 2017-04-03 : Igor Pavlov : Public domain */
   3
   4 #include "Precomp.h"
   5
   6 #include <string.h>
   7
   8 #include "7z.h"
   9 #include "7zBuf.h"
  10 #include "7zCrc.h"
  11 #include "CpuArch.h"
  12
  13 #define MY_ALLOC(T, p, size, alloc) { \
  14   if ((p = (T *)ISzAlloc_Alloc(alloc, (size) * sizeof(T))) == NULL) return SZ_ERROR_MEM; }
  15
  16 #define MY_ALLOC_ZE(T, p, size, alloc) { if ((size) == 0) p = NULL; else MY_ALLOC(T, p, size, alloc) }
  17
  18 #define MY_ALLOC_AND_CPY(to, size, from, alloc) \
  19   { MY_ALLOC(Byte, to, size, alloc); memcpy(to, from, size); }
  20
  21 #define MY_ALLOC_ZE_AND_CPY(to, size, from, alloc) \
  22   { if ((size) == 0) p = NULL; else { MY_ALLOC_AND_CPY(to, size, from, alloc) } }
  23
  24 #define k7zMajorVersion 0
  25
  26 enum EIdEnum
  27 {
  28   k7zIdEnd,
  29   k7zIdHeader,
  30   k7zIdArchiveProperties,
  31   k7zIdAdditionalStreamsInfo,
  32   k7zIdMainStreamsInfo,
  33   k7zIdFilesInfo,
  34   k7zIdPackInfo,
  35   k7zIdUnpackInfo,
  36   k7zIdSubStreamsInfo,
  37   k7zIdSize,
  38   k7zIdCRC,
  39   k7zIdFolder,
  40   k7zIdCodersUnpackSize,
  41   k7zIdNumUnpackStream,
  42   k7zIdEmptyStream,
  43   k7zIdEmptyFile,
  44   k7zIdAnti,
  45   k7zIdName,
  46   k7zIdCTime,
  47   k7zIdATime,
  48   k7zIdMTime,
  49   k7zIdWinAttrib,
  50   k7zIdComment,
  51   k7zIdEncodedHeader,
  52   k7zIdStartPos,
  53   k7zIdDummy
  54   // k7zNtSecure,
  55   // k7zParent,
  56   // k7zIsReal
  57 };
  58
  59 const Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
  60
  61 #define SzBitUi32s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }
  62
  63 static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAllocPtr alloc)
  64 {
  65   if (num == 0)
  66   {
  67     p->Defs = NULL;
  68     p->Vals = NULL;
  69   }
  70   else
  71   {
  72     MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc);
  73     MY_ALLOC(UInt32, p->Vals, num, alloc);
  74   }
  75   return SZ_OK;
  76 }
  77
  78 void SzBitUi32s_Free(CSzBitUi32s *p, ISzAllocPtr alloc)
  79 {
  80   ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;
  81   ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL;
  82 }
  83
  84 #define SzBitUi64s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }
  85
  86 void SzBitUi64s_Free(CSzBitUi64s *p, ISzAllocPtr alloc)
  87 {
  88   ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;
  89   ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL;
  90 }
  91
  92
  93 static void SzAr_Init(CSzAr *p)
  94 {
  95   p->NumPackStreams = 0;
  96   p->NumFolders = 0;
  97
  98   p->PackPositions = NULL;
  99   SzBitUi32s_Init(&p->FolderCRCs);
 100
 101   p->FoCodersOffsets = NULL;
 102   p->FoStartPackStreamIndex = NULL;
 103   p->FoToCoderUnpackSizes = NULL;
 104   p->FoToMainUnpackSizeIndex = NULL;
 105   p->CoderUnpackSizes = NULL;
 106
 107   p->CodersData = NULL;
 108 }
 109
 110 static void SzAr_Free(CSzAr *p, ISzAllocPtr alloc)
 111 {
 112   ISzAlloc_Free(alloc, p->PackPositions);
 113   SzBitUi32s_Free(&p->FolderCRCs, alloc);
 114
 115   ISzAlloc_Free(alloc, p->FoCodersOffsets);
 116   ISzAlloc_Free(alloc, p->FoStartPackStreamIndex);
 117   ISzAlloc_Free(alloc, p->FoToCoderUnpackSizes);
 118   ISzAlloc_Free(alloc, p->FoToMainUnpackSizeIndex);
 119   ISzAlloc_Free(alloc, p->CoderUnpackSizes);
 120
 121   ISzAlloc_Free(alloc, p->CodersData);
 122
 123   SzAr_Init(p);
 124 }
 125
 126
 127 void SzArEx_Init(CSzArEx *p)
 128 {
 129   SzAr_Init(&p->db);
 130
 131   p->NumFiles = 0;
 132   p->dataPos = 0;
 133
 134   p->UnpackPositions = NULL;
 135   p->IsDirs = NULL;
 136
 137   p->FolderToFile = NULL;
 138   p->FileToFolder = NULL;
 139
 140   p->FileNameOffsets = NULL;
 141   p->FileNames = NULL;
 142
 143   SzBitUi32s_Init(&p->CRCs);
 144   SzBitUi32s_Init(&p->Attribs);
 145   // SzBitUi32s_Init(&p->Parents);
 146   SzBitUi64s_Init(&p->MTime);
 147   SzBitUi64s_Init(&p->CTime);
 148 }
 149
 150 void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc)
 151 {
 152   ISzAlloc_Free(alloc, p->UnpackPositions);
 153   ISzAlloc_Free(alloc, p->IsDirs);
 154
 155   ISzAlloc_Free(alloc, p->FolderToFile);
 156   ISzAlloc_Free(alloc, p->FileToFolder);
 157
 158   ISzAlloc_Free(alloc, p->FileNameOffsets);
 159   ISzAlloc_Free(alloc, p->FileNames);
 160
 161   SzBitUi32s_Free(&p->CRCs, alloc);
 162   SzBitUi32s_Free(&p->Attribs, alloc);
 163   // SzBitUi32s_Free(&p->Parents, alloc);
 164   SzBitUi64s_Free(&p->MTime, alloc);
 165   SzBitUi64s_Free(&p->CTime, alloc);
 166
 167   SzAr_Free(&p->db, alloc);
 168   SzArEx_Init(p);
 169 }
 170
 171
 172 static int TestSignatureCandidate(const Byte *testBytes)
 173 {
 174   unsigned i;
 175   for (i = 0; i < k7zSignatureSize; i++)
 176     if (testBytes[i] != k7zSignature[i])
 177       return 0;
 178   return 1;
 179 }
 180
 181 #define SzData_Clear(p) { (p)->Data = NULL; (p)->Size = 0; }
 182
 183 #define SZ_READ_BYTE_SD(_sd_, dest) if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; (_sd_)->Size--; dest = *(_sd_)->Data++;
 184 #define SZ_READ_BYTE(dest) SZ_READ_BYTE_SD(sd, dest)
 185 #define SZ_READ_BYTE_2(dest) if (sd.Size == 0) return SZ_ERROR_ARCHIVE; sd.Size--; dest = *sd.Data++;
 186
 187 #define SKIP_DATA(sd, size) { sd->Size -= (size_t)(size); sd->Data += (size_t)(size); }
 188 #define SKIP_DATA2(sd, size) { sd.Size -= (size_t)(size); sd.Data += (size_t)(size); }
 189
 190 #define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \
 191    dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4);
 192
 193 static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
 194 {
 195   Byte firstByte, mask;
 196   unsigned i;
 197   UInt32 v;
 198
 199   SZ_READ_BYTE(firstByte);
 200   if ((firstByte & 0x80) == 0)
 201   {
 202     *value = firstByte;
 203     return SZ_OK;
 204   }
 205   SZ_READ_BYTE(v);
 206   if ((firstByte & 0x40) == 0)
 207   {
 208     *value = (((UInt32)firstByte & 0x3F) << 8) | v;
 209     return SZ_OK;
 210   }
 211   SZ_READ_BYTE(mask);
 212   *value = v | ((UInt32)mask << 8);
 213   mask = 0x20;
 214   for (i = 2; i < 8; i++)
 215   {
 216     Byte b;
 217     if ((firstByte & mask) == 0)
 218     {
 219       UInt64 highPart = (unsigned)firstByte & (unsigned)(mask - 1);
 220       *value |= (highPart << (8 * i));
 221       return SZ_OK;
 222     }
 223     SZ_READ_BYTE(b);
 224     *value |= ((UInt64)b << (8 * i));
 225     mask >>= 1;
 226   }
 227   return SZ_OK;
 228 }
 229
 230
 231 static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
 232 {
 233   Byte firstByte;
 234   UInt64 value64;
 235   if (sd->Size == 0)
 236     return SZ_ERROR_ARCHIVE;
 237   firstByte = *sd->Data;
 238   if ((firstByte & 0x80) == 0)
 239   {
 240     *value = firstByte;
 241     sd->Data++;
 242     sd->Size--;
 243     return SZ_OK;
 244   }
 245   RINOK(ReadNumber(sd, &value64));
 246   if (value64 >= (UInt32)0x80000000 - 1)
 247     return SZ_ERROR_UNSUPPORTED;
 248   if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4)))
 249     return SZ_ERROR_UNSUPPORTED;
 250   *value = (UInt32)value64;
 251   return SZ_OK;
 252 }
 253
 254 #define ReadID(sd, value) ReadNumber(sd, value)
 255
 256 static SRes SkipData(CSzData *sd)
 257 {
 258   UInt64 size;
 259   RINOK(ReadNumber(sd, &size));
 260   if (size > sd->Size)
 261     return SZ_ERROR_ARCHIVE;
 262   SKIP_DATA(sd, size);
 263   return SZ_OK;
 264 }
 265
 266 static SRes WaitId(CSzData *sd, UInt32 id)
 267 {
 268   for (;;)
 269   {
 270     UInt64 type;
 271     RINOK(ReadID(sd, &type));
 272     if (type == id)
 273       return SZ_OK;
 274     if (type == k7zIdEnd)
 275       return SZ_ERROR_ARCHIVE;
 276     RINOK(SkipData(sd));
 277   }
 278 }
 279
 280 static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)
 281 {
 282   UInt32 numBytes = (numItems + 7) >> 3;
 283   if (numBytes > sd->Size)
 284     return SZ_ERROR_ARCHIVE;
 285   *v = sd->Data;
 286   SKIP_DATA(sd, numBytes);
 287   return SZ_OK;
 288 }
 289
 290 static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
 291 {
 292   Byte b = 0;
 293   unsigned m = 0;
 294   UInt32 sum = 0;
 295   for (; numItems != 0; numItems--)
 296   {
 297     if (m == 0)
 298     {
 299       b = *bits++;
 300       m = 8;
 301     }
 302     m--;
 303     sum += ((b >> m) & 1);
 304   }
 305   return sum;
 306 }
 307
 308 static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAllocPtr alloc)
 309 {
 310   Byte allAreDefined;
 311   Byte *v2;
 312   UInt32 numBytes = (numItems + 7) >> 3;
 313   *v = NULL;
 314   SZ_READ_BYTE(allAreDefined);
 315   if (numBytes == 0)
 316     return SZ_OK;
 317   if (allAreDefined == 0)
 318   {
 319     if (numBytes > sd->Size)
 320       return SZ_ERROR_ARCHIVE;
 321     MY_ALLOC_AND_CPY(*v, numBytes, sd->Data, alloc);
 322     SKIP_DATA(sd, numBytes);
 323     return SZ_OK;
 324   }
 325   MY_ALLOC(Byte, *v, numBytes, alloc);
 326   v2 = *v;
 327   memset(v2, 0xFF, (size_t)numBytes);
 328   {
 329     unsigned numBits = (unsigned)numItems & 7;
 330     if (numBits != 0)
 331       v2[(size_t)numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));
 332   }
 333   return SZ_OK;
 334 }
 335
 336 static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
 337 {
 338   UInt32 i;
 339   CSzData sd;
 340   UInt32 *vals;
 341   const Byte *defs;
 342   MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc);
 343   sd = *sd2;
 344   defs = crcs->Defs;
 345   vals = crcs->Vals;
 346   for (i = 0; i < numItems; i++)
 347     if (SzBitArray_Check(defs, i))
 348     {
 349       SZ_READ_32(vals[i]);
 350     }
 351     else
 352       vals[i] = 0;
 353   *sd2 = sd;
 354   return SZ_OK;
 355 }
 356
 357 static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
 358 {
 359   SzBitUi32s_Free(crcs, alloc);
 360   RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc));
 361   return ReadUi32s(sd, numItems, crcs, alloc);
 362 }
 363
 364 static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
 365 {
 366   Byte allAreDefined;
 367   UInt32 numDefined = numItems;
 368   SZ_READ_BYTE(allAreDefined);
 369   if (!allAreDefined)
 370   {
 371     size_t numBytes = (numItems + 7) >> 3;
 372     if (numBytes > sd->Size)
 373       return SZ_ERROR_ARCHIVE;
 374     numDefined = CountDefinedBits(sd->Data, numItems);
 375     SKIP_DATA(sd, numBytes);
 376   }
 377   if (numDefined > (sd->Size >> 2))
 378     return SZ_ERROR_ARCHIVE;
 379   SKIP_DATA(sd, (size_t)numDefined * 4);
 380   return SZ_OK;
 381 }
 382
 383 static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAllocPtr alloc)
 384 {
 385   RINOK(SzReadNumber32(sd, &p->NumPackStreams));
 386
 387   RINOK(WaitId(sd, k7zIdSize));
 388   MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc);
 389   {
 390     UInt64 sum = 0;
 391     UInt32 i;
 392     UInt32 numPackStreams = p->NumPackStreams;
 393     for (i = 0; i < numPackStreams; i++)
 394     {
 395       UInt64 packSize;
 396       p->PackPositions[i] = sum;
 397       RINOK(ReadNumber(sd, &packSize));
 398       sum += packSize;
 399       if (sum < packSize)
 400         return SZ_ERROR_ARCHIVE;
 401     }
 402     p->PackPositions[i] = sum;
 403   }
 404
 405   for (;;)
 406   {
 407     UInt64 type;
 408     RINOK(ReadID(sd, &type));
 409     if (type == k7zIdEnd)
 410       return SZ_OK;
 411     if (type == k7zIdCRC)
 412     {
 413       /* CRC of packed streams is unused now */
 414       RINOK(SkipBitUi32s(sd, p->NumPackStreams));
 415       continue;
 416     }
 417     RINOK(SkipData(sd));
 418   }
 419 }
 420
 421 /*
 422 static SRes SzReadSwitch(CSzData *sd)
 423 {
 424   Byte external;
 425   RINOK(SzReadByte(sd, &external));
 426   return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;
 427 }
 428 */
 429
 430 #define k_NumCodersStreams_in_Folder_MAX (SZ_NUM_BONDS_IN_FOLDER_MAX + SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)
 431
 432 SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
 433 {
 434   UInt32 numCoders, i;
 435   UInt32 numInStreams = 0;
 436   const Byte *dataStart = sd->Data;
 437
 438   f->NumCoders = 0;
 439   f->NumBonds = 0;
 440   f->NumPackStreams = 0;
 441   f->UnpackStream = 0;
 442
 443   RINOK(SzReadNumber32(sd, &numCoders));
 444   if (numCoders == 0 || numCoders > SZ_NUM_CODERS_IN_FOLDER_MAX)
 445     return SZ_ERROR_UNSUPPORTED;
 446
 447   for (i = 0; i < numCoders; i++)
 448   {
 449     Byte mainByte;
 450     CSzCoderInfo *coder = f->Coders + i;
 451     unsigned idSize, j;
 452     UInt64 id;
 453
 454     SZ_READ_BYTE(mainByte);
 455     if ((mainByte & 0xC0) != 0)
 456       return SZ_ERROR_UNSUPPORTED;
 457
 458     idSize = (unsigned)(mainByte & 0xF);
 459     if (idSize > sizeof(id))
 460       return SZ_ERROR_UNSUPPORTED;
 461     if (idSize > sd->Size)
 462       return SZ_ERROR_ARCHIVE;
 463     id = 0;
 464     for (j = 0; j < idSize; j++)
 465     {
 466       id = ((id << 8) | *sd->Data);
 467       sd->Data++;
 468       sd->Size--;
 469     }
 470     if (id > (UInt32)0xFFFFFFFF)
 471       return SZ_ERROR_UNSUPPORTED;
 472     coder->MethodID = (UInt32)id;
 473
 474     coder->NumStreams = 1;
 475     coder->PropsOffset = 0;
 476     coder->PropsSize = 0;
 477
 478     if ((mainByte & 0x10) != 0)
 479     {
 480       UInt32 numStreams;
 481
 482       RINOK(SzReadNumber32(sd, &numStreams));
 483       if (numStreams > k_NumCodersStreams_in_Folder_MAX)
 484         return SZ_ERROR_UNSUPPORTED;
 485       coder->NumStreams = (Byte)numStreams;
 486
 487       RINOK(SzReadNumber32(sd, &numStreams));
 488       if (numStreams != 1)
 489         return SZ_ERROR_UNSUPPORTED;
 490     }
 491
 492     numInStreams += coder->NumStreams;
 493
 494     if (numInStreams > k_NumCodersStreams_in_Folder_MAX)
 495       return SZ_ERROR_UNSUPPORTED;
 496
 497     if ((mainByte & 0x20) != 0)
 498     {
 499       UInt32 propsSize = 0;
 500       RINOK(SzReadNumber32(sd, &propsSize));
 501       if (propsSize > sd->Size)
 502         return SZ_ERROR_ARCHIVE;
 503       if (propsSize >= 0x80)
 504         return SZ_ERROR_UNSUPPORTED;
 505       coder->PropsOffset = sd->Data - dataStart;
 506       coder->PropsSize = (Byte)propsSize;
 507       sd->Data += (size_t)propsSize;
 508       sd->Size -= (size_t)propsSize;
 509     }
 510   }
 511
 512   /*
 513   if (numInStreams == 1 && numCoders == 1)
 514   {
 515     f->NumPackStreams = 1;
 516     f->PackStreams[0] = 0;
 517   }
 518   else
 519   */
 520   {
 521     Byte streamUsed[k_NumCodersStreams_in_Folder_MAX];
 522     UInt32 numBonds, numPackStreams;
 523
 524     numBonds = numCoders - 1;
 525     if (numInStreams < numBonds)
 526       return SZ_ERROR_ARCHIVE;
 527     if (numBonds > SZ_NUM_BONDS_IN_FOLDER_MAX)
 528       return SZ_ERROR_UNSUPPORTED;
 529     f->NumBonds = numBonds;
 530
 531     numPackStreams = numInStreams - numBonds;
 532     if (numPackStreams > SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)
 533       return SZ_ERROR_UNSUPPORTED;
 534     f->NumPackStreams = numPackStreams;
 535
 536     for (i = 0; i < numInStreams; i++)
 537       streamUsed[i] = False;
 538
 539     if (numBonds != 0)
 540     {
 541       Byte coderUsed[SZ_NUM_CODERS_IN_FOLDER_MAX];
 542
 543       for (i = 0; i < numCoders; i++)
 544         coderUsed[i] = False;
 545
 546       for (i = 0; i < numBonds; i++)
 547       {
 548         CSzBond *bp = f->Bonds + i;
 549
 550         RINOK(SzReadNumber32(sd, &bp->InIndex));
 551         if (bp->InIndex >= numInStreams || streamUsed[bp->InIndex])
 552           return SZ_ERROR_ARCHIVE;
 553         streamUsed[bp->InIndex] = True;
 554
 555         RINOK(SzReadNumber32(sd, &bp->OutIndex));
 556         if (bp->OutIndex >= numCoders || coderUsed[bp->OutIndex])
 557           return SZ_ERROR_ARCHIVE;
 558         coderUsed[bp->OutIndex] = True;
 559       }
 560
 561       for (i = 0; i < numCoders; i++)
 562         if (!coderUsed[i])
 563         {
 564           f->UnpackStream = i;
 565           break;
 566         }
 567
 568       if (i == numCoders)
 569         return SZ_ERROR_ARCHIVE;
 570     }
 571
 572     if (numPackStreams == 1)
 573     {
 574       for (i = 0; i < numInStreams; i++)
 575         if (!streamUsed[i])
 576           break;
 577       if (i == numInStreams)
 578         return SZ_ERROR_ARCHIVE;
 579       f->PackStreams[0] = i;
 580     }
 581     else
 582       for (i = 0; i < numPackStreams; i++)
 583       {
 584         UInt32 index;
 585         RINOK(SzReadNumber32(sd, &index));
 586         if (index >= numInStreams || streamUsed[index])
 587           return SZ_ERROR_ARCHIVE;
 588         streamUsed[index] = True;
 589         f->PackStreams[i] = index;
 590       }
 591   }
 592
 593   f->NumCoders = numCoders;
 594
 595   return SZ_OK;
 596 }
 597
 598
 599 static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
 600 {
 601   CSzData sd;
 602   sd = *sd2;
 603   for (; num != 0; num--)
 604   {
 605     Byte firstByte, mask;
 606     unsigned i;
 607     SZ_READ_BYTE_2(firstByte);
 608     if ((firstByte & 0x80) == 0)
 609       continue;
 610     if ((firstByte & 0x40) == 0)
 611     {
 612       if (sd.Size == 0)
 613         return SZ_ERROR_ARCHIVE;
 614       sd.Size--;
 615       sd.Data++;
 616       continue;
 617     }
 618     mask = 0x20;
 619     for (i = 2; i < 8 && (firstByte & mask) != 0; i++)
 620       mask >>= 1;
 621     if (i > sd.Size)
 622       return SZ_ERROR_ARCHIVE;
 623     SKIP_DATA2(sd, i);
 624   }
 625   *sd2 = sd;
 626   return SZ_OK;
 627 }
 628
 629
 630 #define k_Scan_NumCoders_MAX 64
 631 #define k_Scan_NumCodersStreams_in_Folder_MAX 64
 632
 633
 634 static SRes ReadUnpackInfo(CSzAr *p,
 635     CSzData *sd2,
 636     UInt32 numFoldersMax,
 637     const CBuf *tempBufs, UInt32 numTempBufs,
 638     ISzAllocPtr alloc)
 639 {
 640   CSzData sd;
 641
 642   UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;
 643   const Byte *startBufPtr;
 644   Byte external;
 645
 646   RINOK(WaitId(sd2, k7zIdFolder));
 647
 648   RINOK(SzReadNumber32(sd2, &numFolders));
 649   if (numFolders > numFoldersMax)
 650     return SZ_ERROR_UNSUPPORTED;
 651   p->NumFolders = numFolders;
 652
 653   SZ_READ_BYTE_SD(sd2, external);
 654   if (external == 0)
 655     sd = *sd2;
 656   else
 657   {
 658     UInt32 index;
 659     RINOK(SzReadNumber32(sd2, &index));
 660     if (index >= numTempBufs)
 661       return SZ_ERROR_ARCHIVE;
 662     sd.Data = tempBufs[index].data;
 663     sd.Size = tempBufs[index].size;
 664   }
 665
 666   MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc);
 667   MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc);
 668   MY_ALLOC(UInt32, p->FoToCoderUnpackSizes, (size_t)numFolders + 1, alloc);
 669   MY_ALLOC(Byte, p->FoToMainUnpackSizeIndex, (size_t)numFolders, alloc);
 670
 671   startBufPtr = sd.Data;
 672
 673   packStreamIndex = 0;
 674   numCodersOutStreams = 0;
 675
 676   for (fo = 0; fo < numFolders; fo++)
 677   {
 678     UInt32 numCoders, ci, numInStreams = 0;
 679
 680     p->FoCodersOffsets[fo] = sd.Data - startBufPtr;
 681
 682     RINOK(SzReadNumber32(&sd, &numCoders));
 683     if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)
 684       return SZ_ERROR_UNSUPPORTED;
 685
 686     for (ci = 0; ci < numCoders; ci++)
 687     {
 688       Byte mainByte;
 689       unsigned idSize;
 690       UInt32 coderInStreams;
 691
 692       SZ_READ_BYTE_2(mainByte);
 693       if ((mainByte & 0xC0) != 0)
 694         return SZ_ERROR_UNSUPPORTED;
 695       idSize = (mainByte & 0xF);
 696       if (idSize > 8)
 697         return SZ_ERROR_UNSUPPORTED;
 698       if (idSize > sd.Size)
 699         return SZ_ERROR_ARCHIVE;
 700       SKIP_DATA2(sd, idSize);
 701
 702       coderInStreams = 1;
 703
 704       if ((mainByte & 0x10) != 0)
 705       {
 706         UInt32 coderOutStreams;
 707         RINOK(SzReadNumber32(&sd, &coderInStreams));
 708         RINOK(SzReadNumber32(&sd, &coderOutStreams));
 709         if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX || coderOutStreams != 1)
 710           return SZ_ERROR_UNSUPPORTED;
 711       }
 712
 713       numInStreams += coderInStreams;
 714
 715       if ((mainByte & 0x20) != 0)
 716       {
 717         UInt32 propsSize;
 718         RINOK(SzReadNumber32(&sd, &propsSize));
 719         if (propsSize > sd.Size)
 720           return SZ_ERROR_ARCHIVE;
 721         SKIP_DATA2(sd, propsSize);
 722       }
 723     }
 724
 725     {
 726       UInt32 indexOfMainStream = 0;
 727       UInt32 numPackStreams = 1;
 728
 729       if (numCoders != 1 || numInStreams != 1)
 730       {
 731         Byte streamUsed[k_Scan_NumCodersStreams_in_Folder_MAX];
 732         Byte coderUsed[k_Scan_NumCoders_MAX];
 733
 734         UInt32 i;
 735         UInt32 numBonds = numCoders - 1;
 736         if (numInStreams < numBonds)
 737           return SZ_ERROR_ARCHIVE;
 738
 739         if (numInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)
 740           return SZ_ERROR_UNSUPPORTED;
 741
 742         for (i = 0; i < numInStreams; i++)
 743           streamUsed[i] = False;
 744         for (i = 0; i < numCoders; i++)
 745           coderUsed[i] = False;
 746
 747         for (i = 0; i < numBonds; i++)
 748         {
 749           UInt32 index;
 750
 751           RINOK(SzReadNumber32(&sd, &index));
 752           if (index >= numInStreams || streamUsed[index])
 753             return SZ_ERROR_ARCHIVE;
 754           streamUsed[index] = True;
 755
 756           RINOK(SzReadNumber32(&sd, &index));
 757           if (index >= numCoders || coderUsed[index])
 758             return SZ_ERROR_ARCHIVE;
 759           coderUsed[index] = True;
 760         }
 761
 762         numPackStreams = numInStreams - numBonds;
 763
 764         if (numPackStreams != 1)
 765           for (i = 0; i < numPackStreams; i++)
 766           {
 767             UInt32 index;
 768             RINOK(SzReadNumber32(&sd, &index));
 769             if (index >= numInStreams || streamUsed[index])
 770               return SZ_ERROR_ARCHIVE;
 771             streamUsed[index] = True;
 772           }
 773
 774         for (i = 0; i < numCoders; i++)
 775           if (!coderUsed[i])
 776           {
 777             indexOfMainStream = i;
 778             break;
 779           }
 780
 781         if (i == numCoders)
 782           return SZ_ERROR_ARCHIVE;
 783       }
 784
 785       p->FoStartPackStreamIndex[fo] = packStreamIndex;
 786       p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;
 787       p->FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;
 788       numCodersOutStreams += numCoders;
 789       if (numCodersOutStreams < numCoders)
 790         return SZ_ERROR_UNSUPPORTED;
 791       if (numPackStreams > p->NumPackStreams - packStreamIndex)
 792         return SZ_ERROR_ARCHIVE;
 793       packStreamIndex += numPackStreams;
 794     }
 795   }
 796
 797   p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;
 798
 799   {
 800     size_t dataSize = sd.Data - startBufPtr;
 801     p->FoStartPackStreamIndex[fo] = packStreamIndex;
 802     p->FoCodersOffsets[fo] = dataSize;
 803     MY_ALLOC_ZE_AND_CPY(p->CodersData, dataSize, startBufPtr, alloc);
 804   }
 805
 806   if (external != 0)
 807   {
 808     if (sd.Size != 0)
 809       return SZ_ERROR_ARCHIVE;
 810     sd = *sd2;
 811   }
 812
 813   RINOK(WaitId(&sd, k7zIdCodersUnpackSize));
 814
 815   MY_ALLOC_ZE(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc);
 816   {
 817     UInt32 i;
 818     for (i = 0; i < numCodersOutStreams; i++)
 819     {
 820       RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i));
 821     }
 822   }
 823
 824   for (;;)
 825   {
 826     UInt64 type;
 827     RINOK(ReadID(&sd, &type));
 828     if (type == k7zIdEnd)
 829     {
 830       *sd2 = sd;
 831       return SZ_OK;
 832     }
 833     if (type == k7zIdCRC)
 834     {
 835       RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc));
 836       continue;
 837     }
 838     RINOK(SkipData(&sd));
 839   }
 840 }
 841
 842
 843 UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)
 844 {
 845   return p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex] + p->FoToMainUnpackSizeIndex[folderIndex]];
 846 }
 847
 848
 849 typedef struct
 850 {
 851   UInt32 NumTotalSubStreams;
 852   UInt32 NumSubDigests;
 853   CSzData sdNumSubStreams;
 854   CSzData sdSizes;
 855   CSzData sdCRCs;
 856 } CSubStreamInfo;
 857
 858
 859 static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
 860 {
 861   UInt64 type = 0;
 862   UInt32 numSubDigests = 0;
 863   UInt32 numFolders = p->NumFolders;
 864   UInt32 numUnpackStreams = numFolders;
 865   UInt32 numUnpackSizesInData = 0;
 866
 867   for (;;)
 868   {
 869     RINOK(ReadID(sd, &type));
 870     if (type == k7zIdNumUnpackStream)
 871     {
 872       UInt32 i;
 873       ssi->sdNumSubStreams.Data = sd->Data;
 874       numUnpackStreams = 0;
 875       numSubDigests = 0;
 876       for (i = 0; i < numFolders; i++)
 877       {
 878         UInt32 numStreams;
 879         RINOK(SzReadNumber32(sd, &numStreams));
 880         if (numUnpackStreams > numUnpackStreams + numStreams)
 881           return SZ_ERROR_UNSUPPORTED;
 882         numUnpackStreams += numStreams;
 883         if (numStreams != 0)
 884           numUnpackSizesInData += (numStreams - 1);
 885         if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i))
 886           numSubDigests += numStreams;
 887       }
 888       ssi->sdNumSubStreams.Size = sd->Data - ssi->sdNumSubStreams.Data;
 889       continue;
 890     }
 891     if (type == k7zIdCRC || type == k7zIdSize || type == k7zIdEnd)
 892       break;
 893     RINOK(SkipData(sd));
 894   }
 895
 896   if (!ssi->sdNumSubStreams.Data)
 897   {
 898     numSubDigests = numFolders;
 899     if (p->FolderCRCs.Defs)
 900       numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);
 901   }
 902
 903   ssi->NumTotalSubStreams = numUnpackStreams;
 904   ssi->NumSubDigests = numSubDigests;
 905
 906   if (type == k7zIdSize)
 907   {
 908     ssi->sdSizes.Data = sd->Data;
 909     RINOK(SkipNumbers(sd, numUnpackSizesInData));
 910     ssi->sdSizes.Size = sd->Data - ssi->sdSizes.Data;
 911     RINOK(ReadID(sd, &type));
 912   }
 913
 914   for (;;)
 915   {
 916     if (type == k7zIdEnd)
 917       return SZ_OK;
 918     if (type == k7zIdCRC)
 919     {
 920       ssi->sdCRCs.Data = sd->Data;
 921       RINOK(SkipBitUi32s(sd, numSubDigests));
 922       ssi->sdCRCs.Size = sd->Data - ssi->sdCRCs.Data;
 923     }
 924     else
 925     {
 926       RINOK(SkipData(sd));
 927     }
 928     RINOK(ReadID(sd, &type));
 929   }
 930 }
 931
 932 static SRes SzReadStreamsInfo(CSzAr *p,
 933     CSzData *sd,
 934     UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,
 935     UInt64 *dataOffset,
 936     CSubStreamInfo *ssi,
 937     ISzAllocPtr alloc)
 938 {
 939   UInt64 type;
 940
 941   SzData_Clear(&ssi->sdSizes);
 942   SzData_Clear(&ssi->sdCRCs);
 943   SzData_Clear(&ssi->sdNumSubStreams);
 944
 945   *dataOffset = 0;
 946   RINOK(ReadID(sd, &type));
 947   if (type == k7zIdPackInfo)
 948   {
 949     RINOK(ReadNumber(sd, dataOffset));
 950     RINOK(ReadPackInfo(p, sd, alloc));
 951     RINOK(ReadID(sd, &type));
 952   }
 953   if (type == k7zIdUnpackInfo)
 954   {
 955     RINOK(ReadUnpackInfo(p, sd, numFoldersMax, tempBufs, numTempBufs, alloc));
 956     RINOK(ReadID(sd, &type));
 957   }
 958   if (type == k7zIdSubStreamsInfo)
 959   {
 960     RINOK(ReadSubStreamsInfo(p, sd, ssi));
 961     RINOK(ReadID(sd, &type));
 962   }
 963   else
 964   {
 965     ssi->NumTotalSubStreams = p->NumFolders;
 966     // ssi->NumSubDigests = 0;
 967   }
 968
 969   return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED);
 970 }
 971
 972 static SRes SzReadAndDecodePackedStreams(
 973     ILookInStream *inStream,
 974     CSzData *sd,
 975     CBuf *tempBufs,
 976     UInt32 numFoldersMax,
 977     UInt64 baseOffset,
 978     CSzAr *p,
 979     ISzAllocPtr allocTemp)
 980 {
 981   UInt64 dataStartPos;
 982   UInt32 fo;
 983   CSubStreamInfo ssi;
 984
 985   RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp));
 986
 987   dataStartPos += baseOffset;
 988   if (p->NumFolders == 0)
 989     return SZ_ERROR_ARCHIVE;
 990
 991   for (fo = 0; fo < p->NumFolders; fo++)
 992     Buf_Init(tempBufs + fo);
 993
 994   for (fo = 0; fo < p->NumFolders; fo++)
 995   {
 996     CBuf *tempBuf = tempBufs + fo;
 997     UInt64 unpackSize = SzAr_GetFolderUnpackSize(p, fo);
 998     if ((size_t)unpackSize != unpackSize)
 999       return SZ_ERROR_MEM;
1000     if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp))
1001       return SZ_ERROR_MEM;
1002   }
1003
1004   for (fo = 0; fo < p->NumFolders; fo++)
1005   {
1006     const CBuf *tempBuf = tempBufs + fo;
1007     RINOK(LookInStream_SeekTo(inStream, dataStartPos));
1008     RINOK(SzAr_DecodeFolder(p, fo, inStream, dataStartPos, tempBuf->data, tempBuf->size, allocTemp));
1009   }
1010
1011   return SZ_OK;
1012 }
1013
1014 static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets)
1015 {
1016   size_t pos = 0;
1017   *offsets++ = 0;
1018   if (numFiles == 0)
1019     return (size == 0) ? SZ_OK : SZ_ERROR_ARCHIVE;
1020   if (size < 2)
1021     return SZ_ERROR_ARCHIVE;
1022   if (data[size - 2] != 0 || data[size - 1] != 0)
1023     return SZ_ERROR_ARCHIVE;
1024   do
1025   {
1026     const Byte *p;
1027     if (pos == size)
1028       return SZ_ERROR_ARCHIVE;
1029     for (p = data + pos;
1030       #ifdef _WIN32
1031       *(const UInt16 *)p != 0
1032       #else
1033       p[0] != 0 || p[1] != 0
1034       #endif
1035       ; p += 2);
1036     pos = p - data + 2;
1037     *offsets++ = (pos >> 1);
1038   }
1039   while (--numFiles);
1040   return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
1041 }
1042
1043 static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,
1044     CSzData *sd2,
1045     const CBuf *tempBufs, UInt32 numTempBufs,
1046     ISzAllocPtr alloc)
1047 {
1048   CSzData sd;
1049   UInt32 i;
1050   CNtfsFileTime *vals;
1051   Byte *defs;
1052   Byte external;
1053
1054   RINOK(ReadBitVector(sd2, num, &p->Defs, alloc));
1055
1056   SZ_READ_BYTE_SD(sd2, external);
1057   if (external == 0)
1058     sd = *sd2;
1059   else
1060   {
1061     UInt32 index;
1062     RINOK(SzReadNumber32(sd2, &index));
1063     if (index >= numTempBufs)
1064       return SZ_ERROR_ARCHIVE;
1065     sd.Data = tempBufs[index].data;
1066     sd.Size = tempBufs[index].size;
1067   }
1068
1069   MY_ALLOC_ZE(CNtfsFileTime, p->Vals, num, alloc);
1070   vals = p->Vals;
1071   defs = p->Defs;
1072   for (i = 0; i < num; i++)
1073     if (SzBitArray_Check(defs, i))
1074     {
1075       if (sd.Size < 8)
1076         return SZ_ERROR_ARCHIVE;
1077       vals[i].Low = GetUi32(sd.Data);
1078       vals[i].High = GetUi32(sd.Data + 4);
1079       SKIP_DATA2(sd, 8);
1080     }
1081     else
1082       vals[i].High = vals[i].Low = 0;
1083
1084   if (external == 0)
1085     *sd2 = sd;
1086
1087   return SZ_OK;
1088 }
1089
1090
1091 #define NUM_ADDITIONAL_STREAMS_MAX 8
1092
1093
1094 static SRes SzReadHeader2(
1095     CSzArEx *p,   /* allocMain */
1096     CSzData *sd,
1097     ILookInStream *inStream,
1098     CBuf *tempBufs, UInt32 *numTempBufs,
1099     ISzAllocPtr allocMain,
1100     ISzAllocPtr allocTemp
1101     )
1102 {
1103   CSubStreamInfo ssi;
1104
1105 {
1106   UInt64 type;
1107
1108   SzData_Clear(&ssi.sdSizes);
1109   SzData_Clear(&ssi.sdCRCs);
1110   SzData_Clear(&ssi.sdNumSubStreams);
1111
1112   ssi.NumSubDigests = 0;
1113   ssi.NumTotalSubStreams = 0;
1114
1115   RINOK(ReadID(sd, &type));
1116
1117   if (type == k7zIdArchiveProperties)
1118   {
1119     for (;;)
1120     {
1121       UInt64 type2;
1122       RINOK(ReadID(sd, &type2));
1123       if (type2 == k7zIdEnd)
1124         break;
1125       RINOK(SkipData(sd));
1126     }
1127     RINOK(ReadID(sd, &type));
1128   }
1129
1130   if (type == k7zIdAdditionalStreamsInfo)
1131   {
1132     CSzAr tempAr;
1133     SRes res;
1134
1135     SzAr_Init(&tempAr);
1136     res = SzReadAndDecodePackedStreams(inStream, sd, tempBufs, NUM_ADDITIONAL_STREAMS_MAX,
1137         p->startPosAfterHeader, &tempAr, allocTemp);
1138     *numTempBufs = tempAr.NumFolders;
1139     SzAr_Free(&tempAr, allocTemp);
1140
1141     if (res != SZ_OK)
1142       return res;
1143     RINOK(ReadID(sd, &type));
1144   }
1145
1146   if (type == k7zIdMainStreamsInfo)
1147   {
1148     RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs,
1149         &p->dataPos, &ssi, allocMain));
1150     p->dataPos += p->startPosAfterHeader;
1151     RINOK(ReadID(sd, &type));
1152   }
1153
1154   if (type == k7zIdEnd)
1155   {
1156     return SZ_OK;
1157   }
1158
1159   if (type != k7zIdFilesInfo)
1160     return SZ_ERROR_ARCHIVE;
1161 }
1162
1163 {
1164   UInt32 numFiles = 0;
1165   UInt32 numEmptyStreams = 0;
1166   const Byte *emptyStreams = NULL;
1167   const Byte *emptyFiles = NULL;
1168
1169   RINOK(SzReadNumber32(sd, &numFiles));
1170   p->NumFiles = numFiles;
1171
1172   for (;;)
1173   {
1174     UInt64 type;
1175     UInt64 size;
1176     RINOK(ReadID(sd, &type));
1177     if (type == k7zIdEnd)
1178       break;
1179     RINOK(ReadNumber(sd, &size));
1180     if (size > sd->Size)
1181       return SZ_ERROR_ARCHIVE;
1182
1183     if (type >= ((UInt32)1 << 8))
1184     {
1185       SKIP_DATA(sd, size);
1186     }
1187     else switch ((unsigned)type)
1188     {
1189       case k7zIdName:
1190       {
1191         size_t namesSize;
1192         const Byte *namesData;
1193         Byte external;
1194
1195         SZ_READ_BYTE(external);
1196         if (external == 0)
1197         {
1198           namesSize = (size_t)size - 1;
1199           namesData = sd->Data;
1200         }
1201         else
1202         {
1203           UInt32 index;
1204           RINOK(SzReadNumber32(sd, &index));
1205           if (index >= *numTempBufs)
1206             return SZ_ERROR_ARCHIVE;
1207           namesData = (tempBufs)[index].data;
1208           namesSize = (tempBufs)[index].size;
1209         }
1210
1211         if ((namesSize & 1) != 0)
1212           return SZ_ERROR_ARCHIVE;
1213         MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain);
1214         MY_ALLOC_ZE_AND_CPY(p->FileNames, namesSize, namesData, allocMain);
1215         RINOK(SzReadFileNames(p->FileNames, namesSize, numFiles, p->FileNameOffsets))
1216         if (external == 0)
1217         {
1218           SKIP_DATA(sd, namesSize);
1219         }
1220         break;
1221       }
1222       case k7zIdEmptyStream:
1223       {
1224         RINOK(RememberBitVector(sd, numFiles, &emptyStreams));
1225         numEmptyStreams = CountDefinedBits(emptyStreams, numFiles);
1226         emptyFiles = NULL;
1227         break;
1228       }
1229       case k7zIdEmptyFile:
1230       {
1231         RINOK(RememberBitVector(sd, numEmptyStreams, &emptyFiles));
1232         break;
1233       }
1234       case k7zIdWinAttrib:
1235       {
1236         Byte external;
1237         CSzData sdSwitch;
1238         CSzData *sdPtr;
1239         SzBitUi32s_Free(&p->Attribs, allocMain);
1240         RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain));
1241
1242         SZ_READ_BYTE(external);
1243         if (external == 0)
1244           sdPtr = sd;
1245         else
1246         {
1247           UInt32 index;
1248           RINOK(SzReadNumber32(sd, &index));
1249           if (index >= *numTempBufs)
1250             return SZ_ERROR_ARCHIVE;
1251           sdSwitch.Data = (tempBufs)[index].data;
1252           sdSwitch.Size = (tempBufs)[index].size;
1253           sdPtr = &sdSwitch;
1254         }
1255         RINOK(ReadUi32s(sdPtr, numFiles, &p->Attribs, allocMain));
1256         break;
1257       }
1258       /*
1259       case k7zParent:
1260       {
1261         SzBitUi32s_Free(&p->Parents, allocMain);
1262         RINOK(ReadBitVector(sd, numFiles, &p->Parents.Defs, allocMain));
1263         RINOK(SzReadSwitch(sd));
1264         RINOK(ReadUi32s(sd, numFiles, &p->Parents, allocMain));
1265         break;
1266       }
1267       */
1268       case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
1269       case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
1270       default:
1271       {
1272         SKIP_DATA(sd, size);
1273       }
1274     }
1275   }
1276
1277   if (numFiles - numEmptyStreams != ssi.NumTotalSubStreams)
1278     return SZ_ERROR_ARCHIVE;
1279
1280   for (;;)
1281   {
1282     UInt64 type;
1283     RINOK(ReadID(sd, &type));
1284     if (type == k7zIdEnd)
1285       break;
1286     RINOK(SkipData(sd));
1287   }
1288
1289   {
1290     UInt32 i;
1291     UInt32 emptyFileIndex = 0;
1292     UInt32 folderIndex = 0;
1293     UInt32 remSubStreams = 0;
1294     UInt32 numSubStreams = 0;
1295     UInt64 unpackPos = 0;
1296     const Byte *digestsDefs = NULL;
1297     const Byte *digestsVals = NULL;
1298     UInt32 digestsValsIndex = 0;
1299     UInt32 digestIndex;
1300     Byte allDigestsDefined = 0;
1301     Byte isDirMask = 0;
1302     Byte crcMask = 0;
1303     Byte mask = 0x80;
1304
1305     MY_ALLOC(UInt32, p->FolderToFile, p->db.NumFolders + 1, allocMain);
1306     MY_ALLOC_ZE(UInt32, p->FileToFolder, p->NumFiles, allocMain);
1307     MY_ALLOC(UInt64, p->UnpackPositions, p->NumFiles + 1, allocMain);
1308     MY_ALLOC_ZE(Byte, p->IsDirs, (p->NumFiles + 7) >> 3, allocMain);
1309
1310     RINOK(SzBitUi32s_Alloc(&p->CRCs, p->NumFiles, allocMain));
1311
1312     if (ssi.sdCRCs.Size != 0)
1313     {
1314       SZ_READ_BYTE_SD(&ssi.sdCRCs, allDigestsDefined);
1315       if (allDigestsDefined)
1316         digestsVals = ssi.sdCRCs.Data;
1317       else
1318       {
1319         size_t numBytes = (ssi.NumSubDigests + 7) >> 3;
1320         digestsDefs = ssi.sdCRCs.Data;
1321         digestsVals = digestsDefs + numBytes;
1322       }
1323     }
1324
1325     digestIndex = 0;
1326
1327     for (i = 0; i < numFiles; i++, mask >>= 1)
1328     {
1329       if (mask == 0)
1330       {
1331         UInt32 byteIndex = (i - 1) >> 3;
1332         p->IsDirs[byteIndex] = isDirMask;
1333         p->CRCs.Defs[byteIndex] = crcMask;
1334         isDirMask = 0;
1335         crcMask = 0;
1336         mask = 0x80;
1337       }
1338
1339       p->UnpackPositions[i] = unpackPos;
1340       p->CRCs.Vals[i] = 0;
1341
1342       if (emptyStreams && SzBitArray_Check(emptyStreams, i))
1343       {
1344         if (emptyFiles)
1345         {
1346           if (!SzBitArray_Check(emptyFiles, emptyFileIndex))
1347             isDirMask |= mask;
1348           emptyFileIndex++;
1349         }
1350         else
1351           isDirMask |= mask;
1352         if (remSubStreams == 0)
1353         {
1354           p->FileToFolder[i] = (UInt32)-1;
1355           continue;
1356         }
1357       }
1358
1359       if (remSubStreams == 0)
1360       {
1361         for (;;)
1362         {
1363           if (folderIndex >= p->db.NumFolders)
1364             return SZ_ERROR_ARCHIVE;
1365           p->FolderToFile[folderIndex] = i;
1366           numSubStreams = 1;
1367           if (ssi.sdNumSubStreams.Data)
1368           {
1369             RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams));
1370           }
1371           remSubStreams = numSubStreams;
1372           if (numSubStreams != 0)
1373             break;
1374           {
1375             UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
1376             unpackPos += folderUnpackSize;
1377             if (unpackPos < folderUnpackSize)
1378               return SZ_ERROR_ARCHIVE;
1379           }
1380
1381           folderIndex++;
1382         }
1383       }
1384
1385       p->FileToFolder[i] = folderIndex;
1386
1387       if (emptyStreams && SzBitArray_Check(emptyStreams, i))
1388         continue;
1389
1390       if (--remSubStreams == 0)
1391       {
1392         UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
1393         UInt64 startFolderUnpackPos = p->UnpackPositions[p->FolderToFile[folderIndex]];
1394         if (folderUnpackSize < unpackPos - startFolderUnpackPos)
1395           return SZ_ERROR_ARCHIVE;
1396         unpackPos = startFolderUnpackPos + folderUnpackSize;
1397         if (unpackPos < folderUnpackSize)
1398           return SZ_ERROR_ARCHIVE;
1399
1400         if (numSubStreams == 1 && SzBitWithVals_Check(&p->db.FolderCRCs, i))
1401         {
1402           p->CRCs.Vals[i] = p->db.FolderCRCs.Vals[folderIndex];
1403           crcMask |= mask;
1404         }
1405         else if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
1406         {
1407           p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
1408           digestsValsIndex++;
1409           crcMask |= mask;
1410         }
1411
1412         folderIndex++;
1413       }
1414       else
1415       {
1416         UInt64 v;
1417         RINOK(ReadNumber(&ssi.sdSizes, &v));
1418         unpackPos += v;
1419         if (unpackPos < v)
1420           return SZ_ERROR_ARCHIVE;
1421         if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
1422         {
1423           p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
1424           digestsValsIndex++;
1425           crcMask |= mask;
1426         }
1427       }
1428     }
1429
1430     if (mask != 0x80)
1431     {
1432       UInt32 byteIndex = (i - 1) >> 3;
1433       p->IsDirs[byteIndex] = isDirMask;
1434       p->CRCs.Defs[byteIndex] = crcMask;
1435     }
1436
1437     p->UnpackPositions[i] = unpackPos;
1438
1439     if (remSubStreams != 0)
1440       return SZ_ERROR_ARCHIVE;
1441
1442     for (;;)
1443     {
1444       p->FolderToFile[folderIndex] = i;
1445       if (folderIndex >= p->db.NumFolders)
1446         break;
1447       if (!ssi.sdNumSubStreams.Data)
1448         return SZ_ERROR_ARCHIVE;
1449       RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams));
1450       if (numSubStreams != 0)
1451         return SZ_ERROR_ARCHIVE;
1452       /*
1453       {
1454         UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
1455         unpackPos += folderUnpackSize;
1456         if (unpackPos < folderUnpackSize)
1457           return SZ_ERROR_ARCHIVE;
1458       }
1459       */
1460       folderIndex++;
1461     }
1462
1463     if (ssi.sdNumSubStreams.Data && ssi.sdNumSubStreams.Size != 0)
1464       return SZ_ERROR_ARCHIVE;
1465   }
1466 }
1467   return SZ_OK;
1468 }
1469
1470
1471 static SRes SzReadHeader(
1472     CSzArEx *p,
1473     CSzData *sd,
1474     ILookInStream *inStream,
1475     ISzAllocPtr allocMain,
1476     ISzAllocPtr allocTemp)
1477 {
1478   UInt32 i;
1479   UInt32 numTempBufs = 0;
1480   SRes res;
1481   CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX];
1482
1483   for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)
1484     Buf_Init(tempBufs + i);
1485
1486   res = SzReadHeader2(p, sd, inStream,
1487       tempBufs, &numTempBufs,
1488       allocMain, allocTemp);
1489
1490   for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)
1491     Buf_Free(tempBufs + i, allocTemp);
1492
1493   RINOK(res);
1494
1495   if (sd->Size != 0)
1496     return SZ_ERROR_FAIL;
1497
1498   return res;
1499 }
1500
1501 static SRes SzArEx_Open2(
1502     CSzArEx *p,
1503     ILookInStream *inStream,
1504     ISzAllocPtr allocMain,
1505     ISzAllocPtr allocTemp)
1506 {
1507   Byte header[k7zStartHeaderSize];
1508   Int64 startArcPos;
1509   UInt64 nextHeaderOffset, nextHeaderSize;
1510   size_t nextHeaderSizeT;
1511   UInt32 nextHeaderCRC;
1512   CBuf buf;
1513   SRes res;
1514
1515   startArcPos = 0;
1516   RINOK(ILookInStream_Seek(inStream, &startArcPos, SZ_SEEK_CUR));
1517
1518   RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE));
1519
1520   if (!TestSignatureCandidate(header))
1521     return SZ_ERROR_NO_ARCHIVE;
1522   if (header[6] != k7zMajorVersion)
1523     return SZ_ERROR_UNSUPPORTED;
1524
1525   nextHeaderOffset = GetUi64(header + 12);
1526   nextHeaderSize = GetUi64(header + 20);
1527   nextHeaderCRC = GetUi32(header + 28);
1528
1529   p->startPosAfterHeader = startArcPos + k7zStartHeaderSize;
1530
1531   if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
1532     return SZ_ERROR_CRC;
1533
1534   nextHeaderSizeT = (size_t)nextHeaderSize;
1535   if (nextHeaderSizeT != nextHeaderSize)
1536     return SZ_ERROR_MEM;
1537   if (nextHeaderSizeT == 0)
1538     return SZ_OK;
1539   if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||
1540       nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)
1541     return SZ_ERROR_NO_ARCHIVE;
1542
1543   {
1544     Int64 pos = 0;
1545     RINOK(ILookInStream_Seek(inStream, &pos, SZ_SEEK_END));
1546     if ((UInt64)pos < startArcPos + nextHeaderOffset ||
1547         (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
1548         (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
1549       return SZ_ERROR_INPUT_EOF;
1550   }
1551
1552   RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset));
1553
1554   if (!Buf_Create(&buf, nextHeaderSizeT, allocTemp))
1555     return SZ_ERROR_MEM;
1556
1557   res = LookInStream_Read(inStream, buf.data, nextHeaderSizeT);
1558
1559   if (res == SZ_OK)
1560   {
1561     res = SZ_ERROR_ARCHIVE;
1562     if (CrcCalc(buf.data, nextHeaderSizeT) == nextHeaderCRC)
1563     {
1564       CSzData sd;
1565       UInt64 type;
1566       sd.Data = buf.data;
1567       sd.Size = buf.size;
1568
1569       res = ReadID(&sd, &type);
1570
1571       if (res == SZ_OK && type == k7zIdEncodedHeader)
1572       {
1573         CSzAr tempAr;
1574         CBuf tempBuf;
1575         Buf_Init(&tempBuf);
1576
1577         SzAr_Init(&tempAr);
1578         res = SzReadAndDecodePackedStreams(inStream, &sd, &tempBuf, 1, p->startPosAfterHeader, &tempAr, allocTemp);
1579         SzAr_Free(&tempAr, allocTemp);
1580
1581         if (res != SZ_OK)
1582         {
1583           Buf_Free(&tempBuf, allocTemp);
1584         }
1585         else
1586         {
1587           Buf_Free(&buf, allocTemp);
1588           buf.data = tempBuf.data;
1589           buf.size = tempBuf.size;
1590           sd.Data = buf.data;
1591           sd.Size = buf.size;
1592           res = ReadID(&sd, &type);
1593         }
1594       }
1595
1596       if (res == SZ_OK)
1597       {
1598         if (type == k7zIdHeader)
1599         {
1600           /*
1601           CSzData sd2;
1602           unsigned ttt;
1603           for (ttt = 0; ttt < 40000; ttt++)
1604           {
1605             SzArEx_Free(p, allocMain);
1606             sd2 = sd;
1607             res = SzReadHeader(p, &sd2, inStream, allocMain, allocTemp);
1608             if (res != SZ_OK)
1609               break;
1610           }
1611           */
1612           res = SzReadHeader(p, &sd, inStream, allocMain, allocTemp);
1613         }
1614         else
1615           res = SZ_ERROR_UNSUPPORTED;
1616       }
1617     }
1618   }
1619
1620   Buf_Free(&buf, allocTemp);
1621   return res;
1622 }
1623
1624
1625 SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
1626     ISzAllocPtr allocMain, ISzAllocPtr allocTemp)
1627 {
1628   SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);
1629   if (res != SZ_OK)
1630     SzArEx_Free(p, allocMain);
1631   return res;
1632 }
1633
1634
1635 SRes SzArEx_Extract(
1636     const CSzArEx *p,
1637     ILookInStream *inStream,
1638     UInt32 fileIndex,
1639     UInt32 *blockIndex,
1640     Byte **tempBuf,
1641     size_t *outBufferSize,
1642     size_t *offset,
1643     size_t *outSizeProcessed,
1644     ISzAllocPtr allocMain,
1645     ISzAllocPtr allocTemp)
1646 {
1647   UInt32 folderIndex = p->FileToFolder[fileIndex];
1648   SRes res = SZ_OK;
1649
1650   *offset = 0;
1651   *outSizeProcessed = 0;
1652
1653   if (folderIndex == (UInt32)-1)
1654   {
1655     ISzAlloc_Free(allocMain, *tempBuf);
1656     *blockIndex = folderIndex;
1657     *tempBuf = NULL;
1658     *outBufferSize = 0;
1659     return SZ_OK;
1660   }
1661
1662   if (*tempBuf == NULL || *blockIndex != folderIndex)
1663   {
1664     UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
1665     /*
1666     UInt64 unpackSizeSpec =
1667         p->UnpackPositions[p->FolderToFile[(size_t)folderIndex + 1]] -
1668         p->UnpackPositions[p->FolderToFile[folderIndex]];
1669     */
1670     size_t unpackSize = (size_t)unpackSizeSpec;
1671
1672     if (unpackSize != unpackSizeSpec)
1673       return SZ_ERROR_MEM;
1674     *blockIndex = folderIndex;
1675     ISzAlloc_Free(allocMain, *tempBuf);
1676     *tempBuf = NULL;
1677
1678     if (res == SZ_OK)
1679     {
1680       *outBufferSize = unpackSize;
1681       if (unpackSize != 0)
1682       {
1683         *tempBuf = (Byte *)ISzAlloc_Alloc(allocMain, unpackSize);
1684         if (*tempBuf == NULL)
1685           res = SZ_ERROR_MEM;
1686       }
1687
1688       if (res == SZ_OK)
1689       {
1690         res = SzAr_DecodeFolder(&p->db, folderIndex,
1691             inStream, p->dataPos, *tempBuf, unpackSize, allocTemp);
1692       }
1693     }
1694   }
1695
1696   if (res == SZ_OK)
1697   {
1698     UInt64 unpackPos = p->UnpackPositions[fileIndex];
1699     *offset = (size_t)(unpackPos - p->UnpackPositions[p->FolderToFile[folderIndex]]);
1700     *outSizeProcessed = (size_t)(p->UnpackPositions[(size_t)fileIndex + 1] - unpackPos);
1701     if (*offset + *outSizeProcessed > *outBufferSize)
1702       return SZ_ERROR_FAIL;
1703     if (SzBitWithVals_Check(&p->CRCs, fileIndex))
1704       if (CrcCalc(*tempBuf + *offset, *outSizeProcessed) != p->CRCs.Vals[fileIndex])
1705         res = SZ_ERROR_CRC;
1706   }
1707
1708   return res;
1709 }
1710
1711
1712 size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
1713 {
1714   size_t offs = p->FileNameOffsets[fileIndex];
1715   size_t len = p->FileNameOffsets[fileIndex + 1] - offs;
1716   if (dest != 0)
1717   {
1718     size_t i;
1719     const Byte *src = p->FileNames + offs * 2;
1720     for (i = 0; i < len; i++)
1721       dest[i] = GetUi16(src + i * 2);
1722   }
1723   return len;
1724 }
1725
1726 /*
1727 size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex)
1728 {
1729   size_t len;
1730   if (!p->FileNameOffsets)
1731     return 1;
1732   len = 0;
1733   for (;;)
1734   {
1735     UInt32 parent = (UInt32)(Int32)-1;
1736     len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
1737     if SzBitWithVals_Check(&p->Parents, fileIndex)
1738       parent = p->Parents.Vals[fileIndex];
1739     if (parent == (UInt32)(Int32)-1)
1740       return len;
1741     fileIndex = parent;
1742   }
1743 }
1744
1745 UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
1746 {
1747   Bool needSlash;
1748   if (!p->FileNameOffsets)
1749   {
1750     *(--dest) = 0;
1751     return dest;
1752   }
1753   needSlash = False;
1754   for (;;)
1755   {
1756     UInt32 parent = (UInt32)(Int32)-1;
1757     size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
1758     SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen);
1759     if (needSlash)
1760       *(dest - 1) = '/';
1761     needSlash = True;
1762     dest -= curLen;
1763
1764     if SzBitWithVals_Check(&p->Parents, fileIndex)
1765       parent = p->Parents.Vals[fileIndex];
1766     if (parent == (UInt32)(Int32)-1)
1767       return dest;
1768     fileIndex = parent;
1769   }
1770 }
1771 */