Debian Codegraph @

utils/lzma/SRC/7zip/Archive/7z_C/7zIn.c

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