1 /* 7zArcIn.c -- 7z Input functions
2 2018-12-31 : 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) to = 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
SzBitUi32s_Alloc(CSzBitUi32s * p,size_t num,ISzAllocPtr alloc)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
SzBitUi32s_Free(CSzBitUi32s * p,ISzAllocPtr alloc)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
SzBitUi64s_Free(CSzBitUi64s * p,ISzAllocPtr alloc)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
SzAr_Init(CSzAr * p)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
SzAr_Free(CSzAr * p,ISzAllocPtr alloc)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
SzArEx_Init(CSzArEx * p)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
SzArEx_Free(CSzArEx * p,ISzAllocPtr alloc)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
TestSignatureCandidate(const Byte * testBytes)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
ReadNumber(CSzData * sd,UInt64 * value)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
SzReadNumber32(CSzData * sd,UInt32 * value)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
SkipData(CSzData * sd)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
WaitId(CSzData * sd,UInt32 id)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
RememberBitVector(CSzData * sd,UInt32 numItems,const Byte ** v)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
CountDefinedBits(const Byte * bits,UInt32 numItems)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
ReadBitVector(CSzData * sd,UInt32 numItems,Byte ** v,ISzAllocPtr alloc)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
ReadUi32s(CSzData * sd2,UInt32 numItems,CSzBitUi32s * crcs,ISzAllocPtr alloc)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
ReadBitUi32s(CSzData * sd,UInt32 numItems,CSzBitUi32s * crcs,ISzAllocPtr alloc)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
SkipBitUi32s(CSzData * sd,UInt32 numItems)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
ReadPackInfo(CSzAr * p,CSzData * sd,ISzAllocPtr alloc)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
SzGetNextFolderItem(CSzFolder * f,CSzData * sd)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
SkipNumbers(CSzData * sd2,UInt32 num)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
ReadUnpackInfo(CSzAr * p,CSzData * sd2,UInt32 numFoldersMax,const CBuf * tempBufs,UInt32 numTempBufs,ISzAllocPtr alloc)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_ZE(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
SzAr_GetFolderUnpackSize(const CSzAr * p,UInt32 folderIndex)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
ReadSubStreamsInfo(CSzAr * p,CSzData * sd,CSubStreamInfo * ssi)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
SzReadStreamsInfo(CSzAr * p,CSzData * sd,UInt32 numFoldersMax,const CBuf * tempBufs,UInt32 numTempBufs,UInt64 * dataOffset,CSubStreamInfo * ssi,ISzAllocPtr alloc)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
SzReadAndDecodePackedStreams(ILookInStream * inStream,CSzData * sd,CBuf * tempBufs,UInt32 numFoldersMax,UInt64 baseOffset,CSzAr * p,ISzAllocPtr allocTemp)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
SzReadFileNames(const Byte * data,size_t size,UInt32 numFiles,size_t * offsets)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
ReadTime(CSzBitUi64s * p,UInt32 num,CSzData * sd2,const CBuf * tempBufs,UInt32 numTempBufs,ISzAllocPtr alloc)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
SzReadHeader2(CSzArEx * p,CSzData * sd,ILookInStream * inStream,CBuf * tempBufs,UInt32 * numTempBufs,ISzAllocPtr allocMain,ISzAllocPtr allocTemp)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
SzReadHeader(CSzArEx * p,CSzData * sd,ILookInStream * inStream,ISzAllocPtr allocMain,ISzAllocPtr allocTemp)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
SzArEx_Open2(CSzArEx * p,ILookInStream * inStream,ISzAllocPtr allocMain,ISzAllocPtr allocTemp)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
SzArEx_Open(CSzArEx * p,ILookInStream * inStream,ISzAllocPtr allocMain,ISzAllocPtr allocTemp)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
SzArEx_Extract(const CSzArEx * p,ILookInStream * inStream,UInt32 fileIndex,UInt32 * blockIndex,Byte ** tempBuf,size_t * outBufferSize,size_t * offset,size_t * outSizeProcessed,ISzAllocPtr allocMain,ISzAllocPtr allocTemp)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
SzArEx_GetFileNameUtf16(const CSzArEx * p,size_t fileIndex,UInt16 * dest)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 BoolInt 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 */
1772