1 /* 7zArcIn.c -- 7z Input functions
\r
2 2016-05-16 : Igor Pavlov : Public domain */
\r
11 #include "CpuArch.h"
\r
13 #define MY_ALLOC(T, p, size, alloc) { \
\r
14 if ((p = (T *)IAlloc_Alloc(alloc, (size) * sizeof(T))) == NULL) return SZ_ERROR_MEM; }
\r
16 #define MY_ALLOC_ZE(T, p, size, alloc) { if ((size) == 0) p = NULL; else MY_ALLOC(T, p, size, alloc) }
\r
18 #define MY_ALLOC_AND_CPY(to, size, from, alloc) \
\r
19 { MY_ALLOC(Byte, to, size, alloc); memcpy(to, from, size); }
\r
21 #define MY_ALLOC_ZE_AND_CPY(to, size, from, alloc) \
\r
22 { if ((size) == 0) p = NULL; else { MY_ALLOC_AND_CPY(to, size, from, alloc) } }
\r
24 #define k7zMajorVersion 0
\r
30 k7zIdArchiveProperties,
\r
31 k7zIdAdditionalStreamsInfo,
\r
32 k7zIdMainStreamsInfo,
\r
36 k7zIdSubStreamsInfo,
\r
40 k7zIdCodersUnpackSize,
\r
41 k7zIdNumUnpackStream,
\r
59 const Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
\r
61 #define SzBitUi32s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }
\r
63 static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAlloc *alloc)
\r
72 MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc);
\r
73 MY_ALLOC(UInt32, p->Vals, num, alloc);
\r
78 void SzBitUi32s_Free(CSzBitUi32s *p, ISzAlloc *alloc)
\r
80 IAlloc_Free(alloc, p->Defs); p->Defs = NULL;
\r
81 IAlloc_Free(alloc, p->Vals); p->Vals = NULL;
\r
84 #define SzBitUi64s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }
\r
86 void SzBitUi64s_Free(CSzBitUi64s *p, ISzAlloc *alloc)
\r
88 IAlloc_Free(alloc, p->Defs); p->Defs = NULL;
\r
89 IAlloc_Free(alloc, p->Vals); p->Vals = NULL;
\r
93 static void SzAr_Init(CSzAr *p)
\r
95 p->NumPackStreams = 0;
\r
98 p->PackPositions = NULL;
\r
99 SzBitUi32s_Init(&p->FolderCRCs);
\r
101 p->FoCodersOffsets = NULL;
\r
102 p->FoStartPackStreamIndex = NULL;
\r
103 p->FoToCoderUnpackSizes = NULL;
\r
104 p->FoToMainUnpackSizeIndex = NULL;
\r
105 p->CoderUnpackSizes = NULL;
\r
107 p->CodersData = NULL;
\r
110 static void SzAr_Free(CSzAr *p, ISzAlloc *alloc)
\r
112 IAlloc_Free(alloc, p->PackPositions);
\r
113 SzBitUi32s_Free(&p->FolderCRCs, alloc);
\r
115 IAlloc_Free(alloc, p->FoCodersOffsets);
\r
116 IAlloc_Free(alloc, p->FoStartPackStreamIndex);
\r
117 IAlloc_Free(alloc, p->FoToCoderUnpackSizes);
\r
118 IAlloc_Free(alloc, p->FoToMainUnpackSizeIndex);
\r
119 IAlloc_Free(alloc, p->CoderUnpackSizes);
\r
121 IAlloc_Free(alloc, p->CodersData);
\r
127 void SzArEx_Init(CSzArEx *p)
\r
134 p->UnpackPositions = NULL;
\r
137 p->FolderToFile = NULL;
\r
138 p->FileToFolder = NULL;
\r
140 p->FileNameOffsets = NULL;
\r
141 p->FileNames = NULL;
\r
143 SzBitUi32s_Init(&p->CRCs);
\r
144 SzBitUi32s_Init(&p->Attribs);
\r
145 // SzBitUi32s_Init(&p->Parents);
\r
146 SzBitUi64s_Init(&p->MTime);
\r
147 SzBitUi64s_Init(&p->CTime);
\r
150 void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc)
\r
152 IAlloc_Free(alloc, p->UnpackPositions);
\r
153 IAlloc_Free(alloc, p->IsDirs);
\r
155 IAlloc_Free(alloc, p->FolderToFile);
\r
156 IAlloc_Free(alloc, p->FileToFolder);
\r
158 IAlloc_Free(alloc, p->FileNameOffsets);
\r
159 IAlloc_Free(alloc, p->FileNames);
\r
161 SzBitUi32s_Free(&p->CRCs, alloc);
\r
162 SzBitUi32s_Free(&p->Attribs, alloc);
\r
163 // SzBitUi32s_Free(&p->Parents, alloc);
\r
164 SzBitUi64s_Free(&p->MTime, alloc);
\r
165 SzBitUi64s_Free(&p->CTime, alloc);
\r
167 SzAr_Free(&p->db, alloc);
\r
172 static int TestSignatureCandidate(const Byte *testBytes)
\r
175 for (i = 0; i < k7zSignatureSize; i++)
\r
176 if (testBytes[i] != k7zSignature[i])
\r
181 #define SzData_Clear(p) { (p)->Data = NULL; (p)->Size = 0; }
\r
183 #define SZ_READ_BYTE_SD(_sd_, dest) if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; (_sd_)->Size--; dest = *(_sd_)->Data++;
\r
184 #define SZ_READ_BYTE(dest) SZ_READ_BYTE_SD(sd, dest)
\r
185 #define SZ_READ_BYTE_2(dest) if (sd.Size == 0) return SZ_ERROR_ARCHIVE; sd.Size--; dest = *sd.Data++;
\r
187 #define SKIP_DATA(sd, size) { sd->Size -= (size_t)(size); sd->Data += (size_t)(size); }
\r
188 #define SKIP_DATA2(sd, size) { sd.Size -= (size_t)(size); sd.Data += (size_t)(size); }
\r
190 #define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \
\r
191 dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4);
\r
193 static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
\r
195 Byte firstByte, mask;
\r
199 SZ_READ_BYTE(firstByte);
\r
200 if ((firstByte & 0x80) == 0)
\r
202 *value = firstByte;
\r
206 if ((firstByte & 0x40) == 0)
\r
208 *value = (((UInt32)firstByte & 0x3F) << 8) | v;
\r
211 SZ_READ_BYTE(mask);
\r
212 *value = v | ((UInt32)mask << 8);
\r
214 for (i = 2; i < 8; i++)
\r
217 if ((firstByte & mask) == 0)
\r
219 UInt64 highPart = (unsigned)firstByte & (unsigned)(mask - 1);
\r
220 *value |= (highPart << (8 * i));
\r
224 *value |= ((UInt64)b << (8 * i));
\r
231 static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
\r
236 return SZ_ERROR_ARCHIVE;
\r
237 firstByte = *sd->Data;
\r
238 if ((firstByte & 0x80) == 0)
\r
240 *value = firstByte;
\r
245 RINOK(ReadNumber(sd, &value64));
\r
246 if (value64 >= (UInt32)0x80000000 - 1)
\r
247 return SZ_ERROR_UNSUPPORTED;
\r
248 if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4)))
\r
249 return SZ_ERROR_UNSUPPORTED;
\r
250 *value = (UInt32)value64;
\r
254 #define ReadID(sd, value) ReadNumber(sd, value)
\r
256 static SRes SkipData(CSzData *sd)
\r
259 RINOK(ReadNumber(sd, &size));
\r
260 if (size > sd->Size)
\r
261 return SZ_ERROR_ARCHIVE;
\r
262 SKIP_DATA(sd, size);
\r
266 static SRes WaitId(CSzData *sd, UInt32 id)
\r
271 RINOK(ReadID(sd, &type));
\r
274 if (type == k7zIdEnd)
\r
275 return SZ_ERROR_ARCHIVE;
\r
276 RINOK(SkipData(sd));
\r
280 static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)
\r
282 UInt32 numBytes = (numItems + 7) >> 3;
\r
283 if (numBytes > sd->Size)
\r
284 return SZ_ERROR_ARCHIVE;
\r
286 SKIP_DATA(sd, numBytes);
\r
290 static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
\r
295 for (; numItems != 0; numItems--)
\r
303 sum += ((b >> m) & 1);
\r
308 static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAlloc *alloc)
\r
310 Byte allAreDefined;
\r
312 UInt32 numBytes = (numItems + 7) >> 3;
\r
314 SZ_READ_BYTE(allAreDefined);
\r
317 if (allAreDefined == 0)
\r
319 if (numBytes > sd->Size)
\r
320 return SZ_ERROR_ARCHIVE;
\r
321 MY_ALLOC_AND_CPY(*v, numBytes, sd->Data, alloc);
\r
322 SKIP_DATA(sd, numBytes);
\r
325 MY_ALLOC(Byte, *v, numBytes, alloc);
\r
327 memset(v2, 0xFF, (size_t)numBytes);
\r
329 unsigned numBits = (unsigned)numItems & 7;
\r
331 v2[numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));
\r
336 static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)
\r
342 MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc);
\r
346 for (i = 0; i < numItems; i++)
\r
347 if (SzBitArray_Check(defs, i))
\r
349 SZ_READ_32(vals[i]);
\r
357 static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)
\r
359 SzBitUi32s_Free(crcs, alloc);
\r
360 RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc));
\r
361 return ReadUi32s(sd, numItems, crcs, alloc);
\r
364 static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
\r
366 Byte allAreDefined;
\r
367 UInt32 numDefined = numItems;
\r
368 SZ_READ_BYTE(allAreDefined);
\r
369 if (!allAreDefined)
\r
371 size_t numBytes = (numItems + 7) >> 3;
\r
372 if (numBytes > sd->Size)
\r
373 return SZ_ERROR_ARCHIVE;
\r
374 numDefined = CountDefinedBits(sd->Data, numItems);
\r
375 SKIP_DATA(sd, numBytes);
\r
377 if (numDefined > (sd->Size >> 2))
\r
378 return SZ_ERROR_ARCHIVE;
\r
379 SKIP_DATA(sd, (size_t)numDefined * 4);
\r
383 static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAlloc *alloc)
\r
385 RINOK(SzReadNumber32(sd, &p->NumPackStreams));
\r
387 RINOK(WaitId(sd, k7zIdSize));
\r
388 MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc);
\r
392 UInt32 numPackStreams = p->NumPackStreams;
\r
393 for (i = 0; i < numPackStreams; i++)
\r
396 p->PackPositions[i] = sum;
\r
397 RINOK(ReadNumber(sd, &packSize));
\r
399 if (sum < packSize)
\r
400 return SZ_ERROR_ARCHIVE;
\r
402 p->PackPositions[i] = sum;
\r
408 RINOK(ReadID(sd, &type));
\r
409 if (type == k7zIdEnd)
\r
411 if (type == k7zIdCRC)
\r
413 /* CRC of packed streams is unused now */
\r
414 RINOK(SkipBitUi32s(sd, p->NumPackStreams));
\r
417 RINOK(SkipData(sd));
\r
422 static SRes SzReadSwitch(CSzData *sd)
\r
425 RINOK(SzReadByte(sd, &external));
\r
426 return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;
\r
430 #define k_NumCodersStreams_in_Folder_MAX (SZ_NUM_BONDS_IN_FOLDER_MAX + SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)
\r
432 SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
\r
434 UInt32 numCoders, i;
\r
435 UInt32 numInStreams = 0;
\r
436 const Byte *dataStart = sd->Data;
\r
440 f->NumPackStreams = 0;
\r
441 f->UnpackStream = 0;
\r
443 RINOK(SzReadNumber32(sd, &numCoders));
\r
444 if (numCoders == 0 || numCoders > SZ_NUM_CODERS_IN_FOLDER_MAX)
\r
445 return SZ_ERROR_UNSUPPORTED;
\r
447 for (i = 0; i < numCoders; i++)
\r
450 CSzCoderInfo *coder = f->Coders + i;
\r
451 unsigned idSize, j;
\r
454 SZ_READ_BYTE(mainByte);
\r
455 if ((mainByte & 0xC0) != 0)
\r
456 return SZ_ERROR_UNSUPPORTED;
\r
458 idSize = (unsigned)(mainByte & 0xF);
\r
459 if (idSize > sizeof(id))
\r
460 return SZ_ERROR_UNSUPPORTED;
\r
461 if (idSize > sd->Size)
\r
462 return SZ_ERROR_ARCHIVE;
\r
464 for (j = 0; j < idSize; j++)
\r
466 id = ((id << 8) | *sd->Data);
\r
470 if (id > (UInt32)0xFFFFFFFF)
\r
471 return SZ_ERROR_UNSUPPORTED;
\r
472 coder->MethodID = (UInt32)id;
\r
474 coder->NumStreams = 1;
\r
475 coder->PropsOffset = 0;
\r
476 coder->PropsSize = 0;
\r
478 if ((mainByte & 0x10) != 0)
\r
482 RINOK(SzReadNumber32(sd, &numStreams));
\r
483 if (numStreams > k_NumCodersStreams_in_Folder_MAX)
\r
484 return SZ_ERROR_UNSUPPORTED;
\r
485 coder->NumStreams = (Byte)numStreams;
\r
487 RINOK(SzReadNumber32(sd, &numStreams));
\r
488 if (numStreams != 1)
\r
489 return SZ_ERROR_UNSUPPORTED;
\r
492 numInStreams += coder->NumStreams;
\r
494 if (numInStreams > k_NumCodersStreams_in_Folder_MAX)
\r
495 return SZ_ERROR_UNSUPPORTED;
\r
497 if ((mainByte & 0x20) != 0)
\r
499 UInt32 propsSize = 0;
\r
500 RINOK(SzReadNumber32(sd, &propsSize));
\r
501 if (propsSize > sd->Size)
\r
502 return SZ_ERROR_ARCHIVE;
\r
503 if (propsSize >= 0x80)
\r
504 return SZ_ERROR_UNSUPPORTED;
\r
505 coder->PropsOffset = sd->Data - dataStart;
\r
506 coder->PropsSize = (Byte)propsSize;
\r
507 sd->Data += (size_t)propsSize;
\r
508 sd->Size -= (size_t)propsSize;
\r
513 if (numInStreams == 1 && numCoders == 1)
\r
515 f->NumPackStreams = 1;
\r
516 f->PackStreams[0] = 0;
\r
521 Byte streamUsed[k_NumCodersStreams_in_Folder_MAX];
\r
522 UInt32 numBonds, numPackStreams;
\r
524 numBonds = numCoders - 1;
\r
525 if (numInStreams < numBonds)
\r
526 return SZ_ERROR_ARCHIVE;
\r
527 if (numBonds > SZ_NUM_BONDS_IN_FOLDER_MAX)
\r
528 return SZ_ERROR_UNSUPPORTED;
\r
529 f->NumBonds = numBonds;
\r
531 numPackStreams = numInStreams - numBonds;
\r
532 if (numPackStreams > SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)
\r
533 return SZ_ERROR_UNSUPPORTED;
\r
534 f->NumPackStreams = numPackStreams;
\r
536 for (i = 0; i < numInStreams; i++)
\r
537 streamUsed[i] = False;
\r
541 Byte coderUsed[SZ_NUM_CODERS_IN_FOLDER_MAX];
\r
543 for (i = 0; i < numCoders; i++)
\r
544 coderUsed[i] = False;
\r
546 for (i = 0; i < numBonds; i++)
\r
548 CSzBond *bp = f->Bonds + i;
\r
550 RINOK(SzReadNumber32(sd, &bp->InIndex));
\r
551 if (bp->InIndex >= numInStreams || streamUsed[bp->InIndex])
\r
552 return SZ_ERROR_ARCHIVE;
\r
553 streamUsed[bp->InIndex] = True;
\r
555 RINOK(SzReadNumber32(sd, &bp->OutIndex));
\r
556 if (bp->OutIndex >= numCoders || coderUsed[bp->OutIndex])
\r
557 return SZ_ERROR_ARCHIVE;
\r
558 coderUsed[bp->OutIndex] = True;
\r
561 for (i = 0; i < numCoders; i++)
\r
564 f->UnpackStream = i;
\r
568 if (i == numCoders)
\r
569 return SZ_ERROR_ARCHIVE;
\r
572 if (numPackStreams == 1)
\r
574 for (i = 0; i < numInStreams; i++)
\r
575 if (!streamUsed[i])
\r
577 if (i == numInStreams)
\r
578 return SZ_ERROR_ARCHIVE;
\r
579 f->PackStreams[0] = i;
\r
582 for (i = 0; i < numPackStreams; i++)
\r
585 RINOK(SzReadNumber32(sd, &index));
\r
586 if (index >= numInStreams || streamUsed[index])
\r
587 return SZ_ERROR_ARCHIVE;
\r
588 streamUsed[index] = True;
\r
589 f->PackStreams[i] = index;
\r
593 f->NumCoders = numCoders;
\r
599 static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
\r
603 for (; num != 0; num--)
\r
605 Byte firstByte, mask;
\r
607 SZ_READ_BYTE_2(firstByte);
\r
608 if ((firstByte & 0x80) == 0)
\r
610 if ((firstByte & 0x40) == 0)
\r
613 return SZ_ERROR_ARCHIVE;
\r
619 for (i = 2; i < 8 && (firstByte & mask) != 0; i++)
\r
622 return SZ_ERROR_ARCHIVE;
\r
630 #define k_Scan_NumCoders_MAX 64
\r
631 #define k_Scan_NumCodersStreams_in_Folder_MAX 64
\r
634 static SRes ReadUnpackInfo(CSzAr *p,
\r
636 UInt32 numFoldersMax,
\r
637 const CBuf *tempBufs, UInt32 numTempBufs,
\r
642 UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;
\r
643 const Byte *startBufPtr;
\r
646 RINOK(WaitId(sd2, k7zIdFolder));
\r
648 RINOK(SzReadNumber32(sd2, &numFolders));
\r
649 if (numFolders > numFoldersMax)
\r
650 return SZ_ERROR_UNSUPPORTED;
\r
651 p->NumFolders = numFolders;
\r
653 SZ_READ_BYTE_SD(sd2, external);
\r
659 RINOK(SzReadNumber32(sd2, &index));
\r
660 if (index >= numTempBufs)
\r
661 return SZ_ERROR_ARCHIVE;
\r
662 sd.Data = tempBufs[index].data;
\r
663 sd.Size = tempBufs[index].size;
\r
666 MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc);
\r
667 MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc);
\r
668 MY_ALLOC(UInt32, p->FoToCoderUnpackSizes, (size_t)numFolders + 1, alloc);
\r
669 MY_ALLOC(Byte, p->FoToMainUnpackSizeIndex, (size_t)numFolders, alloc);
\r
671 startBufPtr = sd.Data;
\r
673 packStreamIndex = 0;
\r
674 numCodersOutStreams = 0;
\r
676 for (fo = 0; fo < numFolders; fo++)
\r
678 UInt32 numCoders, ci, numInStreams = 0;
\r
680 p->FoCodersOffsets[fo] = sd.Data - startBufPtr;
\r
682 RINOK(SzReadNumber32(&sd, &numCoders));
\r
683 if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)
\r
684 return SZ_ERROR_UNSUPPORTED;
\r
686 for (ci = 0; ci < numCoders; ci++)
\r
690 UInt32 coderInStreams;
\r
692 SZ_READ_BYTE_2(mainByte);
\r
693 if ((mainByte & 0xC0) != 0)
\r
694 return SZ_ERROR_UNSUPPORTED;
\r
695 idSize = (mainByte & 0xF);
\r
697 return SZ_ERROR_UNSUPPORTED;
\r
698 if (idSize > sd.Size)
\r
699 return SZ_ERROR_ARCHIVE;
\r
700 SKIP_DATA2(sd, idSize);
\r
702 coderInStreams = 1;
\r
704 if ((mainByte & 0x10) != 0)
\r
706 UInt32 coderOutStreams;
\r
707 RINOK(SzReadNumber32(&sd, &coderInStreams));
\r
708 RINOK(SzReadNumber32(&sd, &coderOutStreams));
\r
709 if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX || coderOutStreams != 1)
\r
710 return SZ_ERROR_UNSUPPORTED;
\r
713 numInStreams += coderInStreams;
\r
715 if ((mainByte & 0x20) != 0)
\r
718 RINOK(SzReadNumber32(&sd, &propsSize));
\r
719 if (propsSize > sd.Size)
\r
720 return SZ_ERROR_ARCHIVE;
\r
721 SKIP_DATA2(sd, propsSize);
\r
726 UInt32 indexOfMainStream = 0;
\r
727 UInt32 numPackStreams = 1;
\r
729 if (numCoders != 1 || numInStreams != 1)
\r
731 Byte streamUsed[k_Scan_NumCodersStreams_in_Folder_MAX];
\r
732 Byte coderUsed[k_Scan_NumCoders_MAX];
\r
735 UInt32 numBonds = numCoders - 1;
\r
736 if (numInStreams < numBonds)
\r
737 return SZ_ERROR_ARCHIVE;
\r
739 if (numInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)
\r
740 return SZ_ERROR_UNSUPPORTED;
\r
742 for (i = 0; i < numInStreams; i++)
\r
743 streamUsed[i] = False;
\r
744 for (i = 0; i < numCoders; i++)
\r
745 coderUsed[i] = False;
\r
747 for (i = 0; i < numBonds; i++)
\r
751 RINOK(SzReadNumber32(&sd, &index));
\r
752 if (index >= numInStreams || streamUsed[index])
\r
753 return SZ_ERROR_ARCHIVE;
\r
754 streamUsed[index] = True;
\r
756 RINOK(SzReadNumber32(&sd, &index));
\r
757 if (index >= numCoders || coderUsed[index])
\r
758 return SZ_ERROR_ARCHIVE;
\r
759 coderUsed[index] = True;
\r
762 numPackStreams = numInStreams - numBonds;
\r
764 if (numPackStreams != 1)
\r
765 for (i = 0; i < numPackStreams; i++)
\r
768 RINOK(SzReadNumber32(&sd, &index));
\r
769 if (index >= numInStreams || streamUsed[index])
\r
770 return SZ_ERROR_ARCHIVE;
\r
771 streamUsed[index] = True;
\r
774 for (i = 0; i < numCoders; i++)
\r
777 indexOfMainStream = i;
\r
781 if (i == numCoders)
\r
782 return SZ_ERROR_ARCHIVE;
\r
785 p->FoStartPackStreamIndex[fo] = packStreamIndex;
\r
786 p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;
\r
787 p->FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;
\r
788 numCodersOutStreams += numCoders;
\r
789 if (numCodersOutStreams < numCoders)
\r
790 return SZ_ERROR_UNSUPPORTED;
\r
791 if (numPackStreams > p->NumPackStreams - packStreamIndex)
\r
792 return SZ_ERROR_ARCHIVE;
\r
793 packStreamIndex += numPackStreams;
\r
797 p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;
\r
800 size_t dataSize = sd.Data - startBufPtr;
\r
801 p->FoStartPackStreamIndex[fo] = packStreamIndex;
\r
802 p->FoCodersOffsets[fo] = dataSize;
\r
803 MY_ALLOC_ZE_AND_CPY(p->CodersData, dataSize, startBufPtr, alloc);
\r
809 return SZ_ERROR_ARCHIVE;
\r
813 RINOK(WaitId(&sd, k7zIdCodersUnpackSize));
\r
815 MY_ALLOC_ZE(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc);
\r
818 for (i = 0; i < numCodersOutStreams; i++)
\r
820 RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i));
\r
827 RINOK(ReadID(&sd, &type));
\r
828 if (type == k7zIdEnd)
\r
833 if (type == k7zIdCRC)
\r
835 RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc));
\r
838 RINOK(SkipData(&sd));
\r
843 UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)
\r
845 return p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex] + p->FoToMainUnpackSizeIndex[folderIndex]];
\r
851 UInt32 NumTotalSubStreams;
\r
852 UInt32 NumSubDigests;
\r
853 CSzData sdNumSubStreams;
\r
859 static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
\r
862 UInt32 numSubDigests = 0;
\r
863 UInt32 numFolders = p->NumFolders;
\r
864 UInt32 numUnpackStreams = numFolders;
\r
865 UInt32 numUnpackSizesInData = 0;
\r
869 RINOK(ReadID(sd, &type));
\r
870 if (type == k7zIdNumUnpackStream)
\r
873 ssi->sdNumSubStreams.Data = sd->Data;
\r
874 numUnpackStreams = 0;
\r
876 for (i = 0; i < numFolders; i++)
\r
879 RINOK(SzReadNumber32(sd, &numStreams));
\r
880 if (numUnpackStreams > numUnpackStreams + numStreams)
\r
881 return SZ_ERROR_UNSUPPORTED;
\r
882 numUnpackStreams += numStreams;
\r
883 if (numStreams != 0)
\r
884 numUnpackSizesInData += (numStreams - 1);
\r
885 if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i))
\r
886 numSubDigests += numStreams;
\r
888 ssi->sdNumSubStreams.Size = sd->Data - ssi->sdNumSubStreams.Data;
\r
891 if (type == k7zIdCRC || type == k7zIdSize || type == k7zIdEnd)
\r
893 RINOK(SkipData(sd));
\r
896 if (!ssi->sdNumSubStreams.Data)
\r
898 numSubDigests = numFolders;
\r
899 if (p->FolderCRCs.Defs)
\r
900 numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);
\r
903 ssi->NumTotalSubStreams = numUnpackStreams;
\r
904 ssi->NumSubDigests = numSubDigests;
\r
906 if (type == k7zIdSize)
\r
908 ssi->sdSizes.Data = sd->Data;
\r
909 RINOK(SkipNumbers(sd, numUnpackSizesInData));
\r
910 ssi->sdSizes.Size = sd->Data - ssi->sdSizes.Data;
\r
911 RINOK(ReadID(sd, &type));
\r
916 if (type == k7zIdEnd)
\r
918 if (type == k7zIdCRC)
\r
920 ssi->sdCRCs.Data = sd->Data;
\r
921 RINOK(SkipBitUi32s(sd, numSubDigests));
\r
922 ssi->sdCRCs.Size = sd->Data - ssi->sdCRCs.Data;
\r
926 RINOK(SkipData(sd));
\r
928 RINOK(ReadID(sd, &type));
\r
932 static SRes SzReadStreamsInfo(CSzAr *p,
\r
934 UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,
\r
935 UInt64 *dataOffset,
\r
936 CSubStreamInfo *ssi,
\r
941 SzData_Clear(&ssi->sdSizes);
\r
942 SzData_Clear(&ssi->sdCRCs);
\r
943 SzData_Clear(&ssi->sdNumSubStreams);
\r
946 RINOK(ReadID(sd, &type));
\r
947 if (type == k7zIdPackInfo)
\r
949 RINOK(ReadNumber(sd, dataOffset));
\r
950 RINOK(ReadPackInfo(p, sd, alloc));
\r
951 RINOK(ReadID(sd, &type));
\r
953 if (type == k7zIdUnpackInfo)
\r
955 RINOK(ReadUnpackInfo(p, sd, numFoldersMax, tempBufs, numTempBufs, alloc));
\r
956 RINOK(ReadID(sd, &type));
\r
958 if (type == k7zIdSubStreamsInfo)
\r
960 RINOK(ReadSubStreamsInfo(p, sd, ssi));
\r
961 RINOK(ReadID(sd, &type));
\r
965 ssi->NumTotalSubStreams = p->NumFolders;
\r
966 // ssi->NumSubDigests = 0;
\r
969 return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED);
\r
972 static SRes SzReadAndDecodePackedStreams(
\r
973 ILookInStream *inStream,
\r
976 UInt32 numFoldersMax,
\r
979 ISzAlloc *allocTemp)
\r
981 UInt64 dataStartPos;
\r
983 CSubStreamInfo ssi;
\r
985 RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp));
\r
987 dataStartPos += baseOffset;
\r
988 if (p->NumFolders == 0)
\r
989 return SZ_ERROR_ARCHIVE;
\r
991 for (fo = 0; fo < p->NumFolders; fo++)
\r
992 Buf_Init(tempBufs + fo);
\r
994 for (fo = 0; fo < p->NumFolders; fo++)
\r
996 CBuf *tempBuf = tempBufs + fo;
\r
997 UInt64 unpackSize = SzAr_GetFolderUnpackSize(p, fo);
\r
998 if ((size_t)unpackSize != unpackSize)
\r
999 return SZ_ERROR_MEM;
\r
1000 if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp))
\r
1001 return SZ_ERROR_MEM;
\r
1004 for (fo = 0; fo < p->NumFolders; fo++)
\r
1006 const CBuf *tempBuf = tempBufs + fo;
\r
1007 RINOK(LookInStream_SeekTo(inStream, dataStartPos));
\r
1008 RINOK(SzAr_DecodeFolder(p, fo, inStream, dataStartPos, tempBuf->data, tempBuf->size, allocTemp));
\r
1014 static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets)
\r
1018 if (numFiles == 0)
\r
1019 return (size == 0) ? SZ_OK : SZ_ERROR_ARCHIVE;
\r
1021 return SZ_ERROR_ARCHIVE;
\r
1022 if (data[size - 2] != 0 || data[size - 1] != 0)
\r
1023 return SZ_ERROR_ARCHIVE;
\r
1028 return SZ_ERROR_ARCHIVE;
\r
1029 for (p = data + pos;
\r
1031 *(const UInt16 *)p != 0
\r
1033 p[0] != 0 || p[1] != 0
\r
1036 pos = p - data + 2;
\r
1037 *offsets++ = (pos >> 1);
\r
1039 while (--numFiles);
\r
1040 return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
\r
1043 static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,
\r
1045 const CBuf *tempBufs, UInt32 numTempBufs,
\r
1050 CNtfsFileTime *vals;
\r
1054 RINOK(ReadBitVector(sd2, num, &p->Defs, alloc));
\r
1056 SZ_READ_BYTE_SD(sd2, external);
\r
1057 if (external == 0)
\r
1062 RINOK(SzReadNumber32(sd2, &index));
\r
1063 if (index >= numTempBufs)
\r
1064 return SZ_ERROR_ARCHIVE;
\r
1065 sd.Data = tempBufs[index].data;
\r
1066 sd.Size = tempBufs[index].size;
\r
1069 MY_ALLOC_ZE(CNtfsFileTime, p->Vals, num, alloc);
\r
1072 for (i = 0; i < num; i++)
\r
1073 if (SzBitArray_Check(defs, i))
\r
1076 return SZ_ERROR_ARCHIVE;
\r
1077 vals[i].Low = GetUi32(sd.Data);
\r
1078 vals[i].High = GetUi32(sd.Data + 4);
\r
1079 SKIP_DATA2(sd, 8);
\r
1082 vals[i].High = vals[i].Low = 0;
\r
1084 if (external == 0)
\r
1091 #define NUM_ADDITIONAL_STREAMS_MAX 8
\r
1094 static SRes SzReadHeader2(
\r
1095 CSzArEx *p, /* allocMain */
\r
1097 ILookInStream *inStream,
\r
1098 CBuf *tempBufs, UInt32 *numTempBufs,
\r
1099 ISzAlloc *allocMain,
\r
1100 ISzAlloc *allocTemp
\r
1103 CSubStreamInfo ssi;
\r
1108 SzData_Clear(&ssi.sdSizes);
\r
1109 SzData_Clear(&ssi.sdCRCs);
\r
1110 SzData_Clear(&ssi.sdNumSubStreams);
\r
1112 ssi.NumSubDigests = 0;
\r
1113 ssi.NumTotalSubStreams = 0;
\r
1115 RINOK(ReadID(sd, &type));
\r
1117 if (type == k7zIdArchiveProperties)
\r
1122 RINOK(ReadID(sd, &type2));
\r
1123 if (type2 == k7zIdEnd)
\r
1125 RINOK(SkipData(sd));
\r
1127 RINOK(ReadID(sd, &type));
\r
1130 if (type == k7zIdAdditionalStreamsInfo)
\r
1135 SzAr_Init(&tempAr);
\r
1136 res = SzReadAndDecodePackedStreams(inStream, sd, tempBufs, NUM_ADDITIONAL_STREAMS_MAX,
\r
1137 p->startPosAfterHeader, &tempAr, allocTemp);
\r
1138 *numTempBufs = tempAr.NumFolders;
\r
1139 SzAr_Free(&tempAr, allocTemp);
\r
1143 RINOK(ReadID(sd, &type));
\r
1146 if (type == k7zIdMainStreamsInfo)
\r
1148 RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs,
\r
1149 &p->dataPos, &ssi, allocMain));
\r
1150 p->dataPos += p->startPosAfterHeader;
\r
1151 RINOK(ReadID(sd, &type));
\r
1154 if (type == k7zIdEnd)
\r
1159 if (type != k7zIdFilesInfo)
\r
1160 return SZ_ERROR_ARCHIVE;
\r
1164 UInt32 numFiles = 0;
\r
1165 UInt32 numEmptyStreams = 0;
\r
1166 const Byte *emptyStreams = NULL;
\r
1167 const Byte *emptyFiles = NULL;
\r
1169 RINOK(SzReadNumber32(sd, &numFiles));
\r
1170 p->NumFiles = numFiles;
\r
1176 RINOK(ReadID(sd, &type));
\r
1177 if (type == k7zIdEnd)
\r
1179 RINOK(ReadNumber(sd, &size));
\r
1180 if (size > sd->Size)
\r
1181 return SZ_ERROR_ARCHIVE;
\r
1183 if (type >= ((UInt32)1 << 8))
\r
1185 SKIP_DATA(sd, size);
\r
1187 else switch ((unsigned)type)
\r
1192 const Byte *namesData;
\r
1195 SZ_READ_BYTE(external);
\r
1196 if (external == 0)
\r
1198 namesSize = (size_t)size - 1;
\r
1199 namesData = sd->Data;
\r
1204 RINOK(SzReadNumber32(sd, &index));
\r
1205 if (index >= *numTempBufs)
\r
1206 return SZ_ERROR_ARCHIVE;
\r
1207 namesData = (tempBufs)[index].data;
\r
1208 namesSize = (tempBufs)[index].size;
\r
1211 if ((namesSize & 1) != 0)
\r
1212 return SZ_ERROR_ARCHIVE;
\r
1213 MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain);
\r
1214 MY_ALLOC_ZE_AND_CPY(p->FileNames, namesSize, namesData, allocMain);
\r
1215 RINOK(SzReadFileNames(p->FileNames, namesSize, numFiles, p->FileNameOffsets))
\r
1216 if (external == 0)
\r
1218 SKIP_DATA(sd, namesSize);
\r
1222 case k7zIdEmptyStream:
\r
1224 RINOK(RememberBitVector(sd, numFiles, &emptyStreams));
\r
1225 numEmptyStreams = CountDefinedBits(emptyStreams, numFiles);
\r
1226 emptyFiles = NULL;
\r
1229 case k7zIdEmptyFile:
\r
1231 RINOK(RememberBitVector(sd, numEmptyStreams, &emptyFiles));
\r
1234 case k7zIdWinAttrib:
\r
1239 SzBitUi32s_Free(&p->Attribs, allocMain);
\r
1240 RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain));
\r
1242 SZ_READ_BYTE(external);
\r
1243 if (external == 0)
\r
1248 RINOK(SzReadNumber32(sd, &index));
\r
1249 if (index >= *numTempBufs)
\r
1250 return SZ_ERROR_ARCHIVE;
\r
1251 sdSwitch.Data = (tempBufs)[index].data;
\r
1252 sdSwitch.Size = (tempBufs)[index].size;
\r
1253 sdPtr = &sdSwitch;
\r
1255 RINOK(ReadUi32s(sdPtr, numFiles, &p->Attribs, allocMain));
\r
1261 SzBitUi32s_Free(&p->Parents, allocMain);
\r
1262 RINOK(ReadBitVector(sd, numFiles, &p->Parents.Defs, allocMain));
\r
1263 RINOK(SzReadSwitch(sd));
\r
1264 RINOK(ReadUi32s(sd, numFiles, &p->Parents, allocMain));
\r
1268 case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
\r
1269 case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
\r
1272 SKIP_DATA(sd, size);
\r
1277 if (numFiles - numEmptyStreams != ssi.NumTotalSubStreams)
\r
1278 return SZ_ERROR_ARCHIVE;
\r
1283 RINOK(ReadID(sd, &type));
\r
1284 if (type == k7zIdEnd)
\r
1286 RINOK(SkipData(sd));
\r
1291 UInt32 emptyFileIndex = 0;
\r
1292 UInt32 folderIndex = 0;
\r
1293 UInt32 remSubStreams = 0;
\r
1294 UInt32 numSubStreams = 0;
\r
1295 UInt64 unpackPos = 0;
\r
1296 const Byte *digestsDefs = NULL;
\r
1297 const Byte *digestsVals = NULL;
\r
1298 UInt32 digestsValsIndex = 0;
\r
1299 UInt32 digestIndex;
\r
1300 Byte allDigestsDefined = 0;
\r
1301 Byte isDirMask = 0;
\r
1305 MY_ALLOC(UInt32, p->FolderToFile, p->db.NumFolders + 1, allocMain);
\r
1306 MY_ALLOC_ZE(UInt32, p->FileToFolder, p->NumFiles, allocMain);
\r
1307 MY_ALLOC(UInt64, p->UnpackPositions, p->NumFiles + 1, allocMain);
\r
1308 MY_ALLOC_ZE(Byte, p->IsDirs, (p->NumFiles + 7) >> 3, allocMain);
\r
1310 RINOK(SzBitUi32s_Alloc(&p->CRCs, p->NumFiles, allocMain));
\r
1312 if (ssi.sdCRCs.Size != 0)
\r
1314 SZ_READ_BYTE_SD(&ssi.sdCRCs, allDigestsDefined);
\r
1315 if (allDigestsDefined)
\r
1316 digestsVals = ssi.sdCRCs.Data;
\r
1319 size_t numBytes = (ssi.NumSubDigests + 7) >> 3;
\r
1320 digestsDefs = ssi.sdCRCs.Data;
\r
1321 digestsVals = digestsDefs + numBytes;
\r
1327 for (i = 0; i < numFiles; i++, mask >>= 1)
\r
1331 UInt32 byteIndex = (i - 1) >> 3;
\r
1332 p->IsDirs[byteIndex] = isDirMask;
\r
1333 p->CRCs.Defs[byteIndex] = crcMask;
\r
1339 p->UnpackPositions[i] = unpackPos;
\r
1340 p->CRCs.Vals[i] = 0;
\r
1342 if (emptyStreams && SzBitArray_Check(emptyStreams, i))
\r
1346 if (!SzBitArray_Check(emptyFiles, emptyFileIndex))
\r
1347 isDirMask |= mask;
\r
1351 isDirMask |= mask;
\r
1352 if (remSubStreams == 0)
\r
1354 p->FileToFolder[i] = (UInt32)-1;
\r
1359 if (remSubStreams == 0)
\r
1363 if (folderIndex >= p->db.NumFolders)
\r
1364 return SZ_ERROR_ARCHIVE;
\r
1365 p->FolderToFile[folderIndex] = i;
\r
1366 numSubStreams = 1;
\r
1367 if (ssi.sdNumSubStreams.Data)
\r
1369 RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams));
\r
1371 remSubStreams = numSubStreams;
\r
1372 if (numSubStreams != 0)
\r
1375 UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
\r
1376 unpackPos += folderUnpackSize;
\r
1377 if (unpackPos < folderUnpackSize)
\r
1378 return SZ_ERROR_ARCHIVE;
\r
1385 p->FileToFolder[i] = folderIndex;
\r
1387 if (emptyStreams && SzBitArray_Check(emptyStreams, i))
\r
1390 if (--remSubStreams == 0)
\r
1392 UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
\r
1393 UInt64 startFolderUnpackPos = p->UnpackPositions[p->FolderToFile[folderIndex]];
\r
1394 if (folderUnpackSize < unpackPos - startFolderUnpackPos)
\r
1395 return SZ_ERROR_ARCHIVE;
\r
1396 unpackPos = startFolderUnpackPos + folderUnpackSize;
\r
1397 if (unpackPos < folderUnpackSize)
\r
1398 return SZ_ERROR_ARCHIVE;
\r
1400 if (numSubStreams == 1 && SzBitWithVals_Check(&p->db.FolderCRCs, i))
\r
1402 p->CRCs.Vals[i] = p->db.FolderCRCs.Vals[folderIndex];
\r
1405 else if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
\r
1407 p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
\r
1408 digestsValsIndex++;
\r
1417 RINOK(ReadNumber(&ssi.sdSizes, &v));
\r
1419 if (unpackPos < v)
\r
1420 return SZ_ERROR_ARCHIVE;
\r
1421 if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
\r
1423 p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
\r
1424 digestsValsIndex++;
\r
1432 UInt32 byteIndex = (i - 1) >> 3;
\r
1433 p->IsDirs[byteIndex] = isDirMask;
\r
1434 p->CRCs.Defs[byteIndex] = crcMask;
\r
1437 p->UnpackPositions[i] = unpackPos;
\r
1439 if (remSubStreams != 0)
\r
1440 return SZ_ERROR_ARCHIVE;
\r
1444 p->FolderToFile[folderIndex] = i;
\r
1445 if (folderIndex >= p->db.NumFolders)
\r
1447 if (!ssi.sdNumSubStreams.Data)
\r
1448 return SZ_ERROR_ARCHIVE;
\r
1449 RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &numSubStreams));
\r
1450 if (numSubStreams != 0)
\r
1451 return SZ_ERROR_ARCHIVE;
\r
1454 UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
\r
1455 unpackPos += folderUnpackSize;
\r
1456 if (unpackPos < folderUnpackSize)
\r
1457 return SZ_ERROR_ARCHIVE;
\r
1463 if (ssi.sdNumSubStreams.Data && ssi.sdNumSubStreams.Size != 0)
\r
1464 return SZ_ERROR_ARCHIVE;
\r
1471 static SRes SzReadHeader(
\r
1474 ILookInStream *inStream,
\r
1475 ISzAlloc *allocMain,
\r
1476 ISzAlloc *allocTemp)
\r
1479 UInt32 numTempBufs = 0;
\r
1481 CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX];
\r
1483 for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)
\r
1484 Buf_Init(tempBufs + i);
\r
1486 res = SzReadHeader2(p, sd, inStream,
\r
1487 tempBufs, &numTempBufs,
\r
1488 allocMain, allocTemp);
\r
1490 for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)
\r
1491 Buf_Free(tempBufs + i, allocTemp);
\r
1495 if (sd->Size != 0)
\r
1496 return SZ_ERROR_FAIL;
\r
1501 static SRes SzArEx_Open2(
\r
1503 ILookInStream *inStream,
\r
1504 ISzAlloc *allocMain,
\r
1505 ISzAlloc *allocTemp)
\r
1507 Byte header[k7zStartHeaderSize];
\r
1508 Int64 startArcPos;
\r
1509 UInt64 nextHeaderOffset, nextHeaderSize;
\r
1510 size_t nextHeaderSizeT;
\r
1511 UInt32 nextHeaderCRC;
\r
1516 RINOK(inStream->Seek(inStream, &startArcPos, SZ_SEEK_CUR));
\r
1518 RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE));
\r
1520 if (!TestSignatureCandidate(header))
\r
1521 return SZ_ERROR_NO_ARCHIVE;
\r
1522 if (header[6] != k7zMajorVersion)
\r
1523 return SZ_ERROR_UNSUPPORTED;
\r
1525 nextHeaderOffset = GetUi64(header + 12);
\r
1526 nextHeaderSize = GetUi64(header + 20);
\r
1527 nextHeaderCRC = GetUi32(header + 28);
\r
1529 p->startPosAfterHeader = startArcPos + k7zStartHeaderSize;
\r
1531 if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
\r
1532 return SZ_ERROR_CRC;
\r
1534 nextHeaderSizeT = (size_t)nextHeaderSize;
\r
1535 if (nextHeaderSizeT != nextHeaderSize)
\r
1536 return SZ_ERROR_MEM;
\r
1537 if (nextHeaderSizeT == 0)
\r
1539 if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||
\r
1540 nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)
\r
1541 return SZ_ERROR_NO_ARCHIVE;
\r
1545 RINOK(inStream->Seek(inStream, &pos, SZ_SEEK_END));
\r
1546 if ((UInt64)pos < startArcPos + nextHeaderOffset ||
\r
1547 (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
\r
1548 (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
\r
1549 return SZ_ERROR_INPUT_EOF;
\r
1552 RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset));
\r
1554 if (!Buf_Create(&buf, nextHeaderSizeT, allocTemp))
\r
1555 return SZ_ERROR_MEM;
\r
1557 res = LookInStream_Read(inStream, buf.data, nextHeaderSizeT);
\r
1561 res = SZ_ERROR_ARCHIVE;
\r
1562 if (CrcCalc(buf.data, nextHeaderSizeT) == nextHeaderCRC)
\r
1566 sd.Data = buf.data;
\r
1567 sd.Size = buf.size;
\r
1569 res = ReadID(&sd, &type);
\r
1571 if (res == SZ_OK && type == k7zIdEncodedHeader)
\r
1575 Buf_Init(&tempBuf);
\r
1577 SzAr_Init(&tempAr);
\r
1578 res = SzReadAndDecodePackedStreams(inStream, &sd, &tempBuf, 1, p->startPosAfterHeader, &tempAr, allocTemp);
\r
1579 SzAr_Free(&tempAr, allocTemp);
\r
1583 Buf_Free(&tempBuf, allocTemp);
\r
1587 Buf_Free(&buf, allocTemp);
\r
1588 buf.data = tempBuf.data;
\r
1589 buf.size = tempBuf.size;
\r
1590 sd.Data = buf.data;
\r
1591 sd.Size = buf.size;
\r
1592 res = ReadID(&sd, &type);
\r
1598 if (type == k7zIdHeader)
\r
1603 for (ttt = 0; ttt < 40000; ttt++)
\r
1605 SzArEx_Free(p, allocMain);
\r
1607 res = SzReadHeader(p, &sd2, inStream, allocMain, allocTemp);
\r
1612 res = SzReadHeader(p, &sd, inStream, allocMain, allocTemp);
\r
1615 res = SZ_ERROR_UNSUPPORTED;
\r
1620 Buf_Free(&buf, allocTemp);
\r
1625 SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
\r
1626 ISzAlloc *allocMain, ISzAlloc *allocTemp)
\r
1628 SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);
\r
1630 SzArEx_Free(p, allocMain);
\r
1635 SRes SzArEx_Extract(
\r
1637 ILookInStream *inStream,
\r
1639 UInt32 *blockIndex,
\r
1641 size_t *outBufferSize,
\r
1643 size_t *outSizeProcessed,
\r
1644 ISzAlloc *allocMain,
\r
1645 ISzAlloc *allocTemp)
\r
1647 UInt32 folderIndex = p->FileToFolder[fileIndex];
\r
1651 *outSizeProcessed = 0;
\r
1653 if (folderIndex == (UInt32)-1)
\r
1655 IAlloc_Free(allocMain, *tempBuf);
\r
1656 *blockIndex = folderIndex;
\r
1658 *outBufferSize = 0;
\r
1662 if (*tempBuf == NULL || *blockIndex != folderIndex)
\r
1664 UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
\r
1666 UInt64 unpackSizeSpec =
\r
1667 p->UnpackPositions[p->FolderToFile[folderIndex + 1]] -
\r
1668 p->UnpackPositions[p->FolderToFile[folderIndex]];
\r
1670 size_t unpackSize = (size_t)unpackSizeSpec;
\r
1672 if (unpackSize != unpackSizeSpec)
\r
1673 return SZ_ERROR_MEM;
\r
1674 *blockIndex = folderIndex;
\r
1675 IAlloc_Free(allocMain, *tempBuf);
\r
1680 *outBufferSize = unpackSize;
\r
1681 if (unpackSize != 0)
\r
1683 *tempBuf = (Byte *)IAlloc_Alloc(allocMain, unpackSize);
\r
1684 if (*tempBuf == NULL)
\r
1685 res = SZ_ERROR_MEM;
\r
1690 res = SzAr_DecodeFolder(&p->db, folderIndex,
\r
1691 inStream, p->dataPos, *tempBuf, unpackSize, allocTemp);
\r
1698 UInt64 unpackPos = p->UnpackPositions[fileIndex];
\r
1699 *offset = (size_t)(unpackPos - p->UnpackPositions[p->FolderToFile[folderIndex]]);
\r
1700 *outSizeProcessed = (size_t)(p->UnpackPositions[fileIndex + 1] - unpackPos);
\r
1701 if (*offset + *outSizeProcessed > *outBufferSize)
\r
1702 return SZ_ERROR_FAIL;
\r
1703 if (SzBitWithVals_Check(&p->CRCs, fileIndex))
\r
1704 if (CrcCalc(*tempBuf + *offset, *outSizeProcessed) != p->CRCs.Vals[fileIndex])
\r
1705 res = SZ_ERROR_CRC;
\r
1712 size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
\r
1714 size_t offs = p->FileNameOffsets[fileIndex];
\r
1715 size_t len = p->FileNameOffsets[fileIndex + 1] - offs;
\r
1719 const Byte *src = p->FileNames + offs * 2;
\r
1720 for (i = 0; i < len; i++)
\r
1721 dest[i] = GetUi16(src + i * 2);
\r
1727 size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex)
\r
1730 if (!p->FileNameOffsets)
\r
1735 UInt32 parent = (UInt32)(Int32)-1;
\r
1736 len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
\r
1737 if SzBitWithVals_Check(&p->Parents, fileIndex)
\r
1738 parent = p->Parents.Vals[fileIndex];
\r
1739 if (parent == (UInt32)(Int32)-1)
\r
1741 fileIndex = parent;
\r
1745 UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
\r
1748 if (!p->FileNameOffsets)
\r
1753 needSlash = False;
\r
1756 UInt32 parent = (UInt32)(Int32)-1;
\r
1757 size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
\r
1758 SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen);
\r
1760 *(dest - 1) = '/';
\r
1764 if SzBitWithVals_Check(&p->Parents, fileIndex)
\r
1765 parent = p->Parents.Vals[fileIndex];
\r
1766 if (parent == (UInt32)(Int32)-1)
\r
1768 fileIndex = parent;
\r