The Tor Browser / file comparison

comparison: other-licenses/7zstub/src/7zip/Archive/7z/7zIn.cpp

other-licenses/7zstub/src/7zip/Archive/7z/7zIn.cpp

branch
TOR_BUG_9701
changeset 8
97036ab72558
equal deleted inserted replaced
-1:000000000000 0:3239fe83e85b
1 // 7zIn.cpp
2
3 #include "StdAfx.h"
4
5 #include "7zIn.h"
6 #include "7zMethods.h"
7 #include "7zDecode.h"
8 #include "../../Common/StreamObjects.h"
9 #include "../../Common/StreamUtils.h"
10 #include "../../../Common/CRC.h"
11
12 namespace NArchive {
13 namespace N7z {
14
15 class CStreamSwitch
16 {
17 CInArchive *_archive;
18 bool _needRemove;
19 public:
20 CStreamSwitch(): _needRemove(false) {}
21 ~CStreamSwitch() { Remove(); }
22 void Remove();
23 void Set(CInArchive *archive, const Byte *data, size_t size);
24 void Set(CInArchive *archive, const CByteBuffer &byteBuffer);
25 HRESULT Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector);
26 };
27
28 void CStreamSwitch::Remove()
29 {
30 if (_needRemove)
31 {
32 _archive->DeleteByteStream();
33 _needRemove = false;
34 }
35 }
36
37 void CStreamSwitch::Set(CInArchive *archive, const Byte *data, size_t size)
38 {
39 Remove();
40 _archive = archive;
41 _archive->AddByteStream(data, size);
42 _needRemove = true;
43 }
44
45 void CStreamSwitch::Set(CInArchive *archive, const CByteBuffer &byteBuffer)
46 {
47 Set(archive, byteBuffer, byteBuffer.GetCapacity());
48 }
49
50 HRESULT CStreamSwitch::Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector)
51 {
52 Remove();
53 Byte external;
54 RINOK(archive->ReadByte(external));
55 if (external != 0)
56 {
57 CNum dataIndex;
58 RINOK(archive->ReadNum(dataIndex));
59 Set(archive, (*dataVector)[dataIndex]);
60 }
61 return S_OK;
62 }
63
64
65 CInArchiveException::CInArchiveException(CCauseType cause):
66 Cause(cause)
67 {}
68
69 HRESULT CInArchive::ReadDirect(IInStream *stream, void *data, UInt32 size,
70 UInt32 *processedSize)
71 {
72 UInt32 realProcessedSize;
73 HRESULT result = ReadStream(stream, data, size, &realProcessedSize);
74 if(processedSize != NULL)
75 *processedSize = realProcessedSize;
76 _position += realProcessedSize;
77 return result;
78 }
79
80 HRESULT CInArchive::ReadDirect(void *data, UInt32 size, UInt32 *processedSize)
81 {
82 return ReadDirect(_stream, data, size, processedSize);
83 }
84
85 HRESULT CInArchive::SafeReadDirect(void *data, UInt32 size)
86 {
87 UInt32 realProcessedSize;
88 RINOK(ReadDirect(data, size, &realProcessedSize));
89 if (realProcessedSize != size)
90 throw CInArchiveException(CInArchiveException::kUnexpectedEndOfArchive);
91 return S_OK;
92 }
93
94 HRESULT CInArchive::SafeReadDirectByte(Byte &b)
95 {
96 return SafeReadDirect(&b, 1);
97 }
98
99 HRESULT CInArchive::SafeReadDirectUInt32(UInt32 &value)
100 {
101 value = 0;
102 for (int i = 0; i < 4; i++)
103 {
104 Byte b;
105 RINOK(SafeReadDirectByte(b));
106 value |= (UInt32(b) << (8 * i));
107 }
108 return S_OK;
109 }
110
111 HRESULT CInArchive::SafeReadDirectUInt64(UInt64 &value)
112 {
113 value = 0;
114 for (int i = 0; i < 8; i++)
115 {
116 Byte b;
117 RINOK(SafeReadDirectByte(b));
118 value |= (UInt64(b) << (8 * i));
119 }
120 return S_OK;
121 }
122
123 HRESULT CInArchive::ReadNumber(UInt64 &value)
124 {
125 Byte firstByte;
126 RINOK(ReadByte(firstByte));
127 Byte mask = 0x80;
128 value = 0;
129 for (int i = 0; i < 8; i++)
130 {
131 if ((firstByte & mask) == 0)
132 {
133 UInt64 highPart = firstByte & (mask - 1);
134 value += (highPart << (i * 8));
135 return S_OK;
136 }
137 Byte b;
138 RINOK(ReadByte(b));
139 value |= (UInt64(b) << (8 * i));
140 mask >>= 1;
141 }
142 return S_OK;
143 }
144
145 HRESULT CInArchive::ReadNum(CNum &value)
146 {
147 UInt64 value64;
148 RINOK(ReadNumber(value64));
149 if (value64 > kNumMax)
150 return E_FAIL;
151 value = (CNum)value64;
152 return S_OK;
153 }
154
155 HRESULT CInArchive::ReadUInt32(UInt32 &value)
156 {
157 value = 0;
158 for (int i = 0; i < 4; i++)
159 {
160 Byte b;
161 RINOK(ReadByte(b));
162 value |= (UInt32(b) << (8 * i));
163 }
164 return S_OK;
165 }
166
167 HRESULT CInArchive::ReadUInt64(UInt64 &value)
168 {
169 value = 0;
170 for (int i = 0; i < 8; i++)
171 {
172 Byte b;
173 RINOK(ReadByte(b));
174 value |= (UInt64(b) << (8 * i));
175 }
176 return S_OK;
177 }
178
179 static inline bool TestSignatureCandidate(const void *testBytes)
180 {
181 for (int i = 0; i < kSignatureSize; i++)
182 if (((const Byte *)testBytes)[i] != kSignature[i])
183 return false;
184 return true;
185 }
186
187 #ifdef _7Z_VOL
188 static inline bool TestFinishSignatureCandidate(const void *testBytes)
189 {
190 for (int i = 0; i < kSignatureSize; i++)
191 if (((const Byte *)testBytes)[i] != kFinishSignature[i])
192 return false;
193 return true;
194 }
195 #endif
196
197 HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
198 {
199 _position = _arhiveBeginStreamPosition;
200 RINOK(stream->Seek(_arhiveBeginStreamPosition, STREAM_SEEK_SET, NULL));
201
202 Byte signature[kSignatureSize];
203 UInt32 processedSize;
204 RINOK(ReadDirect(stream, signature, kSignatureSize, &processedSize));
205 if(processedSize != kSignatureSize)
206 return S_FALSE;
207 if (TestSignatureCandidate(signature))
208 return S_OK;
209
210 CByteBuffer byteBuffer;
211 const UInt32 kBufferSize = (1 << 16);
212 byteBuffer.SetCapacity(kBufferSize);
213 Byte *buffer = byteBuffer;
214 UInt32 numPrevBytes = kSignatureSize - 1;
215 memmove(buffer, signature + 1, numPrevBytes);
216 UInt64 curTestPos = _arhiveBeginStreamPosition + 1;
217 while(true)
218 {
219 if (searchHeaderSizeLimit != NULL)
220 if (curTestPos - _arhiveBeginStreamPosition > *searchHeaderSizeLimit)
221 return S_FALSE;
222 UInt32 numReadBytes = kBufferSize - numPrevBytes;
223 RINOK(ReadDirect(stream, buffer + numPrevBytes, numReadBytes, &processedSize));
224 UInt32 numBytesInBuffer = numPrevBytes + processedSize;
225 if (numBytesInBuffer < kSignatureSize)
226 return S_FALSE;
227 UInt32 numTests = numBytesInBuffer - kSignatureSize + 1;
228 for(UInt32 pos = 0; pos < numTests; pos++, curTestPos++)
229 {
230 if (TestSignatureCandidate(buffer + pos))
231 {
232 _arhiveBeginStreamPosition = curTestPos;
233 _position = curTestPos + kSignatureSize;
234 return stream->Seek(_position, STREAM_SEEK_SET, NULL);
235 }
236 }
237 numPrevBytes = numBytesInBuffer - numTests;
238 memmove(buffer, buffer + numTests, numPrevBytes);
239 }
240 }
241
242 // Out: _position must point to end of signature
243
244 #ifdef _7Z_VOL
245 HRESULT CInArchive::FindFinishSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
246 {
247 RINOK(stream->Seek(0, STREAM_SEEK_END, &_position));
248 if (_position < kSignatureSize)
249 return S_FALSE;
250
251 CByteBuffer byteBuffer;
252 const UInt32 kBufferSize = (1 << 18);
253 byteBuffer.SetCapacity(kBufferSize);
254 Byte *buffer = byteBuffer;
255 UInt32 numPrevBytes = 0;
256 UInt64 limitPos = 0;
257 if (searchHeaderSizeLimit != NULL)
258 if (*searchHeaderSizeLimit < _position)
259 limitPos = _position - *searchHeaderSizeLimit;
260
261 while(_position >= limitPos)
262 {
263 UInt32 numReadBytes = kBufferSize - numPrevBytes;
264 if (numReadBytes > _position)
265 numReadBytes = (UInt32)_position;
266 UInt32 numBytesInBuffer = numPrevBytes + numReadBytes;
267 if (numBytesInBuffer < kSignatureSize)
268 return S_FALSE;
269 _position -= numReadBytes;
270 RINOK(stream->Seek(_position, STREAM_SEEK_SET, &_position));
271 UInt32 startPos = kBufferSize - numBytesInBuffer;
272 UInt32 processedSize;
273 RINOK(ReadDirect(stream, buffer + startPos, numReadBytes, &processedSize));
274 if (processedSize != numReadBytes)
275 return S_FALSE;
276 _position -= processedSize;
277 for(UInt32 pos = kBufferSize; pos >= startPos + kSignatureSize; pos--)
278 {
279 if (TestFinishSignatureCandidate(buffer + pos - kSignatureSize))
280 {
281 _position += pos - startPos;
282 return stream->Seek(_position, STREAM_SEEK_SET, NULL);
283 }
284 }
285 numPrevBytes = kSignatureSize - 1;
286 memmove(buffer + kBufferSize - numPrevBytes, buffer + startPos + 1, numPrevBytes);
287 }
288 return S_FALSE;
289 }
290 #endif
291
292 // S_FALSE means that file is not archive
293 HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
294 {
295 Close();
296 RINOK(stream->Seek(0, STREAM_SEEK_CUR, &_arhiveBeginStreamPosition))
297 _position = _arhiveBeginStreamPosition;
298 #ifdef _7Z_VOL
299 HRESULT result = FindFinishSignature(stream, searchHeaderSizeLimit);
300 if (result == S_OK)
301 _finishSignature = true;
302 else
303 {
304 if (result != S_FALSE)
305 return result;
306 _finishSignature = false;
307 RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit));
308 }
309 #else
310 RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit));
311 #endif
312 _stream = stream;
313 return S_OK;
314 }
315
316 void CInArchive::Close()
317 {
318 _stream.Release();
319 }
320
321 HRESULT CInArchive::SkeepData(UInt64 size)
322 {
323 for (UInt64 i = 0; i < size; i++)
324 {
325 Byte temp;
326 RINOK(ReadByte(temp));
327 }
328 return S_OK;
329 }
330
331 HRESULT CInArchive::SkeepData()
332 {
333 UInt64 size;
334 RINOK(ReadNumber(size));
335 return SkeepData(size);
336 }
337
338 HRESULT CInArchive::ReadArchiveProperties(CInArchiveInfo &archiveInfo)
339 {
340 while(true)
341 {
342 UInt64 type;
343 RINOK(ReadID(type));
344 if (type == NID::kEnd)
345 break;
346 SkeepData();
347 }
348 return S_OK;
349 }
350
351 HRESULT CInArchive::GetNextFolderItem(CFolder &folder)
352 {
353 CNum numCoders;
354 RINOK(ReadNum(numCoders));
355
356 folder.Coders.Clear();
357 folder.Coders.Reserve((int)numCoders);
358 CNum numInStreams = 0;
359 CNum numOutStreams = 0;
360 CNum i;
361 for (i = 0; i < numCoders; i++)
362 {
363 folder.Coders.Add(CCoderInfo());
364 CCoderInfo &coder = folder.Coders.Back();
365
366 while (true)
367 {
368 coder.AltCoders.Add(CAltCoderInfo());
369 CAltCoderInfo &altCoder = coder.AltCoders.Back();
370 Byte mainByte;
371 RINOK(ReadByte(mainByte));
372 altCoder.MethodID.IDSize = mainByte & 0xF;
373 RINOK(ReadBytes(altCoder.MethodID.ID, altCoder.MethodID.IDSize));
374 if ((mainByte & 0x10) != 0)
375 {
376 RINOK(ReadNum(coder.NumInStreams));
377 RINOK(ReadNum(coder.NumOutStreams));
378 }
379 else
380 {
381 coder.NumInStreams = 1;
382 coder.NumOutStreams = 1;
383 }
384 if ((mainByte & 0x20) != 0)
385 {
386 CNum propertiesSize = 0;
387 RINOK(ReadNum(propertiesSize));
388 altCoder.Properties.SetCapacity((size_t)propertiesSize);
389 RINOK(ReadBytes((Byte *)altCoder.Properties, (size_t)propertiesSize));
390 }
391 if ((mainByte & 0x80) == 0)
392 break;
393 }
394 numInStreams += coder.NumInStreams;
395 numOutStreams += coder.NumOutStreams;
396 }
397
398 CNum numBindPairs;
399 // RINOK(ReadNumber(numBindPairs));
400 numBindPairs = numOutStreams - 1;
401 folder.BindPairs.Clear();
402 folder.BindPairs.Reserve(numBindPairs);
403 for (i = 0; i < numBindPairs; i++)
404 {
405 CBindPair bindPair;
406 RINOK(ReadNum(bindPair.InIndex));
407 RINOK(ReadNum(bindPair.OutIndex));
408 folder.BindPairs.Add(bindPair);
409 }
410
411 CNum numPackedStreams = numInStreams - numBindPairs;
412 folder.PackStreams.Reserve(numPackedStreams);
413 if (numPackedStreams == 1)
414 {
415 for (CNum j = 0; j < numInStreams; j++)
416 if (folder.FindBindPairForInStream(j) < 0)
417 {
418 folder.PackStreams.Add(j);
419 break;
420 }
421 }
422 else
423 for(i = 0; i < numPackedStreams; i++)
424 {
425 CNum packStreamInfo;
426 RINOK(ReadNum(packStreamInfo));
427 folder.PackStreams.Add(packStreamInfo);
428 }
429
430 return S_OK;
431 }
432
433 HRESULT CInArchive::WaitAttribute(UInt64 attribute)
434 {
435 while(true)
436 {
437 UInt64 type;
438 RINOK(ReadID(type));
439 if (type == attribute)
440 return S_OK;
441 if (type == NID::kEnd)
442 return S_FALSE;
443 RINOK(SkeepData());
444 }
445 }
446
447 HRESULT CInArchive::ReadHashDigests(int numItems,
448 CRecordVector<bool> &digestsDefined,
449 CRecordVector<UInt32> &digests)
450 {
451 RINOK(ReadBoolVector2(numItems, digestsDefined));
452 digests.Clear();
453 digests.Reserve(numItems);
454 for(int i = 0; i < numItems; i++)
455 {
456 UInt32 crc;
457 if (digestsDefined[i])
458 RINOK(ReadUInt32(crc));
459 digests.Add(crc);
460 }
461 return S_OK;
462 }
463
464 HRESULT CInArchive::ReadPackInfo(
465 UInt64 &dataOffset,
466 CRecordVector<UInt64> &packSizes,
467 CRecordVector<bool> &packCRCsDefined,
468 CRecordVector<UInt32> &packCRCs)
469 {
470 RINOK(ReadNumber(dataOffset));
471 CNum numPackStreams;
472 RINOK(ReadNum(numPackStreams));
473
474 RINOK(WaitAttribute(NID::kSize));
475 packSizes.Clear();
476 packSizes.Reserve(numPackStreams);
477 for(CNum i = 0; i < numPackStreams; i++)
478 {
479 UInt64 size;
480 RINOK(ReadNumber(size));
481 packSizes.Add(size);
482 }
483
484 UInt64 type;
485 while(true)
486 {
487 RINOK(ReadID(type));
488 if (type == NID::kEnd)
489 break;
490 if (type == NID::kCRC)
491 {
492 RINOK(ReadHashDigests(numPackStreams, packCRCsDefined, packCRCs));
493 continue;
494 }
495 RINOK(SkeepData());
496 }
497 if (packCRCsDefined.IsEmpty())
498 {
499 packCRCsDefined.Reserve(numPackStreams);
500 packCRCsDefined.Clear();
501 packCRCs.Reserve(numPackStreams);
502 packCRCs.Clear();
503 for(CNum i = 0; i < numPackStreams; i++)
504 {
505 packCRCsDefined.Add(false);
506 packCRCs.Add(0);
507 }
508 }
509 return S_OK;
510 }
511
512 HRESULT CInArchive::ReadUnPackInfo(
513 const CObjectVector<CByteBuffer> *dataVector,
514 CObjectVector<CFolder> &folders)
515 {
516 RINOK(WaitAttribute(NID::kFolder));
517 CNum numFolders;
518 RINOK(ReadNum(numFolders));
519
520 {
521 CStreamSwitch streamSwitch;
522 RINOK(streamSwitch.Set(this, dataVector));
523 folders.Clear();
524 folders.Reserve((UInt32)numFolders);
525 for(CNum i = 0; i < numFolders; i++)
526 {
527 folders.Add(CFolder());
528 RINOK(GetNextFolderItem(folders.Back()));
529 }
530 }
531
532 RINOK(WaitAttribute(NID::kCodersUnPackSize));
533
534 CNum i;
535 for(i = 0; i < numFolders; i++)
536 {
537 CFolder &folder = folders[i];
538 CNum numOutStreams = folder.GetNumOutStreams();
539 folder.UnPackSizes.Reserve(numOutStreams);
540 for(CNum j = 0; j < numOutStreams; j++)
541 {
542 UInt64 unPackSize;
543 RINOK(ReadNumber(unPackSize));
544 folder.UnPackSizes.Add(unPackSize);
545 }
546 }
547
548 while(true)
549 {
550 UInt64 type;
551 RINOK(ReadID(type));
552 if (type == NID::kEnd)
553 return S_OK;
554 if (type == NID::kCRC)
555 {
556 CRecordVector<bool> crcsDefined;
557 CRecordVector<UInt32> crcs;
558 RINOK(ReadHashDigests(numFolders, crcsDefined, crcs));
559 for(i = 0; i < numFolders; i++)
560 {
561 CFolder &folder = folders[i];
562 folder.UnPackCRCDefined = crcsDefined[i];
563 folder.UnPackCRC = crcs[i];
564 }
565 continue;
566 }
567 RINOK(SkeepData());
568 }
569 }
570
571 HRESULT CInArchive::ReadSubStreamsInfo(
572 const CObjectVector<CFolder> &folders,
573 CRecordVector<CNum> &numUnPackStreamsInFolders,
574 CRecordVector<UInt64> &unPackSizes,
575 CRecordVector<bool> &digestsDefined,
576 CRecordVector<UInt32> &digests)
577 {
578 numUnPackStreamsInFolders.Clear();
579 numUnPackStreamsInFolders.Reserve(folders.Size());
580 UInt64 type;
581 while(true)
582 {
583 RINOK(ReadID(type));
584 if (type == NID::kNumUnPackStream)
585 {
586 for(int i = 0; i < folders.Size(); i++)
587 {
588 CNum value;
589 RINOK(ReadNum(value));
590 numUnPackStreamsInFolders.Add(value);
591 }
592 continue;
593 }
594 if (type == NID::kCRC || type == NID::kSize)
595 break;
596 if (type == NID::kEnd)
597 break;
598 RINOK(SkeepData());
599 }
600
601 if (numUnPackStreamsInFolders.IsEmpty())
602 for(int i = 0; i < folders.Size(); i++)
603 numUnPackStreamsInFolders.Add(1);
604
605 int i;
606 for(i = 0; i < numUnPackStreamsInFolders.Size(); i++)
607 {
608 // v3.13 incorrectly worked with empty folders
609 // v4.07: we check that folder is empty
610 CNum numSubstreams = numUnPackStreamsInFolders[i];
611 if (numSubstreams == 0)
612 continue;
613 UInt64 sum = 0;
614 for (CNum j = 1; j < numSubstreams; j++)
615 {
616 UInt64 size;
617 if (type == NID::kSize)
618 {
619 RINOK(ReadNumber(size));
620 unPackSizes.Add(size);
621 sum += size;
622 }
623 }
624 unPackSizes.Add(folders[i].GetUnPackSize() - sum);
625 }
626 if (type == NID::kSize)
627 {
628 RINOK(ReadID(type));
629 }
630
631 int numDigests = 0;
632 int numDigestsTotal = 0;
633 for(i = 0; i < folders.Size(); i++)
634 {
635 CNum numSubstreams = numUnPackStreamsInFolders[i];
636 if (numSubstreams != 1 || !folders[i].UnPackCRCDefined)
637 numDigests += numSubstreams;
638 numDigestsTotal += numSubstreams;
639 }
640
641 while(true)
642 {
643 if (type == NID::kCRC)
644 {
645 CRecordVector<bool> digestsDefined2;
646 CRecordVector<UInt32> digests2;
647 RINOK(ReadHashDigests(numDigests, digestsDefined2, digests2));
648 int digestIndex = 0;
649 for (i = 0; i < folders.Size(); i++)
650 {
651 CNum numSubstreams = numUnPackStreamsInFolders[i];
652 const CFolder &folder = folders[i];
653 if (numSubstreams == 1 && folder.UnPackCRCDefined)
654 {
655 digestsDefined.Add(true);
656 digests.Add(folder.UnPackCRC);
657 }
658 else
659 for (CNum j = 0; j < numSubstreams; j++, digestIndex++)
660 {
661 digestsDefined.Add(digestsDefined2[digestIndex]);
662 digests.Add(digests2[digestIndex]);
663 }
664 }
665 }
666 else if (type == NID::kEnd)
667 {
668 if (digestsDefined.IsEmpty())
669 {
670 digestsDefined.Clear();
671 digests.Clear();
672 for (int i = 0; i < numDigestsTotal; i++)
673 {
674 digestsDefined.Add(false);
675 digests.Add(0);
676 }
677 }
678 return S_OK;
679 }
680 else
681 {
682 RINOK(SkeepData());
683 }
684 RINOK(ReadID(type));
685 }
686 }
687
688 HRESULT CInArchive::ReadStreamsInfo(
689 const CObjectVector<CByteBuffer> *dataVector,
690 UInt64 &dataOffset,
691 CRecordVector<UInt64> &packSizes,
692 CRecordVector<bool> &packCRCsDefined,
693 CRecordVector<UInt32> &packCRCs,
694 CObjectVector<CFolder> &folders,
695 CRecordVector<CNum> &numUnPackStreamsInFolders,
696 CRecordVector<UInt64> &unPackSizes,
697 CRecordVector<bool> &digestsDefined,
698 CRecordVector<UInt32> &digests)
699 {
700 while(true)
701 {
702 UInt64 type;
703 RINOK(ReadID(type));
704 switch(type)
705 {
706 case NID::kEnd:
707 return S_OK;
708 case NID::kPackInfo:
709 {
710 RINOK(ReadPackInfo(dataOffset, packSizes,
711 packCRCsDefined, packCRCs));
712 break;
713 }
714 case NID::kUnPackInfo:
715 {
716 RINOK(ReadUnPackInfo(dataVector, folders));
717 break;
718 }
719 case NID::kSubStreamsInfo:
720 {
721 RINOK(ReadSubStreamsInfo(folders, numUnPackStreamsInFolders,
722 unPackSizes, digestsDefined, digests));
723 break;
724 }
725 }
726 }
727 }
728
729 HRESULT CInArchive::ReadFileNames(CObjectVector<CFileItem> &files)
730 {
731 for(int i = 0; i < files.Size(); i++)
732 {
733 UString &name = files[i].Name;
734 name.Empty();
735 while (true)
736 {
737 wchar_t c;
738 RINOK(ReadWideCharLE(c));
739 if (c == L'\0')
740 break;
741 name += c;
742 }
743 }
744 return S_OK;
745 }
746
747 HRESULT CInArchive::ReadBoolVector(int numItems, CBoolVector &v)
748 {
749 v.Clear();
750 v.Reserve(numItems);
751 Byte b;
752 Byte mask = 0;
753 for(int i = 0; i < numItems; i++)
754 {
755 if (mask == 0)
756 {
757 RINOK(ReadByte(b));
758 mask = 0x80;
759 }
760 v.Add((b & mask) != 0);
761 mask >>= 1;
762 }
763 return S_OK;
764 }
765
766 HRESULT CInArchive::ReadBoolVector2(int numItems, CBoolVector &v)
767 {
768 Byte allAreDefined;
769 RINOK(ReadByte(allAreDefined));
770 if (allAreDefined == 0)
771 return ReadBoolVector(numItems, v);
772 v.Clear();
773 v.Reserve(numItems);
774 for (int i = 0; i < numItems; i++)
775 v.Add(true);
776 return S_OK;
777 }
778
779 HRESULT CInArchive::ReadTime(const CObjectVector<CByteBuffer> &dataVector,
780 CObjectVector<CFileItem> &files, UInt64 type)
781 {
782 CBoolVector boolVector;
783 RINOK(ReadBoolVector2(files.Size(), boolVector))
784
785 CStreamSwitch streamSwitch;
786 RINOK(streamSwitch.Set(this, &dataVector));
787
788 for(int i = 0; i < files.Size(); i++)
789 {
790 CFileItem &file = files[i];
791 CArchiveFileTime fileTime;
792 bool defined = boolVector[i];
793 if (defined)
794 {
795 UInt32 low, high;
796 RINOK(ReadUInt32(low));
797 RINOK(ReadUInt32(high));
798 fileTime.dwLowDateTime = low;
799 fileTime.dwHighDateTime = high;
800 }
801 switch(type)
802 {
803 case NID::kCreationTime:
804 file.IsCreationTimeDefined = defined;
805 if (defined)
806 file.CreationTime = fileTime;
807 break;
808 case NID::kLastWriteTime:
809 file.IsLastWriteTimeDefined = defined;
810 if (defined)
811 file.LastWriteTime = fileTime;
812 break;
813 case NID::kLastAccessTime:
814 file.IsLastAccessTimeDefined = defined;
815 if (defined)
816 file.LastAccessTime = fileTime;
817 break;
818 }
819 }
820 return S_OK;
821 }
822
823 HRESULT CInArchive::ReadAndDecodePackedStreams(UInt64 baseOffset,
824 UInt64 &dataOffset, CObjectVector<CByteBuffer> &dataVector
825 #ifndef _NO_CRYPTO
826 , ICryptoGetTextPassword *getTextPassword
827 #endif
828 )
829 {
830 CRecordVector<UInt64> packSizes;
831 CRecordVector<bool> packCRCsDefined;
832 CRecordVector<UInt32> packCRCs;
833 CObjectVector<CFolder> folders;
834
835 CRecordVector<CNum> numUnPackStreamsInFolders;
836 CRecordVector<UInt64> unPackSizes;
837 CRecordVector<bool> digestsDefined;
838 CRecordVector<UInt32> digests;
839
840 RINOK(ReadStreamsInfo(NULL,
841 dataOffset,
842 packSizes,
843 packCRCsDefined,
844 packCRCs,
845 folders,
846 numUnPackStreamsInFolders,
847 unPackSizes,
848 digestsDefined,
849 digests));
850
851 // database.ArchiveInfo.DataStartPosition2 += database.ArchiveInfo.StartPositionAfterHeader;
852
853 CNum packIndex = 0;
854 CDecoder decoder(
855 #ifdef _ST_MODE
856 false
857 #else
858 true
859 #endif
860 );
861 UInt64 dataStartPos = baseOffset + dataOffset;
862 for(int i = 0; i < folders.Size(); i++)
863 {
864 const CFolder &folder = folders[i];
865 dataVector.Add(CByteBuffer());
866 CByteBuffer &data = dataVector.Back();
867 UInt64 unPackSize = folder.GetUnPackSize();
868 if (unPackSize > kNumMax)
869 return E_FAIL;
870 if (unPackSize > 0xFFFFFFFF)
871 return E_FAIL;
872 data.SetCapacity((size_t)unPackSize);
873
874 CSequentialOutStreamImp2 *outStreamSpec = new CSequentialOutStreamImp2;
875 CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
876 outStreamSpec->Init(data, (size_t)unPackSize);
877
878 HRESULT result = decoder.Decode(_stream, dataStartPos,
879 &packSizes[packIndex], folder, outStream, NULL
880 #ifndef _NO_CRYPTO
881 , getTextPassword
882 #endif
883 #ifdef COMPRESS_MT
884 , false, 1
885 #endif
886 );
887 RINOK(result);
888
889 if (folder.UnPackCRCDefined)
890 if (!CCRC::VerifyDigest(folder.UnPackCRC, data, (UInt32)unPackSize))
891 throw CInArchiveException(CInArchiveException::kIncorrectHeader);
892 for (int j = 0; j < folder.PackStreams.Size(); j++)
893 dataStartPos += packSizes[packIndex++];
894 }
895 return S_OK;
896 }
897
898 HRESULT CInArchive::ReadHeader(CArchiveDatabaseEx &database
899 #ifndef _NO_CRYPTO
900 , ICryptoGetTextPassword *getTextPassword
901 #endif
902 )
903 {
904 UInt64 type;
905 RINOK(ReadID(type));
906
907 if (type == NID::kArchiveProperties)
908 {
909 RINOK(ReadArchiveProperties(database.ArchiveInfo));
910 RINOK(ReadID(type));
911 }
912
913 CObjectVector<CByteBuffer> dataVector;
914
915 if (type == NID::kAdditionalStreamsInfo)
916 {
917 HRESULT result = ReadAndDecodePackedStreams(
918 database.ArchiveInfo.StartPositionAfterHeader,
919 database.ArchiveInfo.DataStartPosition2,
920 dataVector
921 #ifndef _NO_CRYPTO
922 , getTextPassword
923 #endif
924 );
925 RINOK(result);
926 database.ArchiveInfo.DataStartPosition2 += database.ArchiveInfo.StartPositionAfterHeader;
927 RINOK(ReadID(type));
928 }
929
930 CRecordVector<UInt64> unPackSizes;
931 CRecordVector<bool> digestsDefined;
932 CRecordVector<UInt32> digests;
933
934 if (type == NID::kMainStreamsInfo)
935 {
936 RINOK(ReadStreamsInfo(&dataVector,
937 database.ArchiveInfo.DataStartPosition,
938 database.PackSizes,
939 database.PackCRCsDefined,
940 database.PackCRCs,
941 database.Folders,
942 database.NumUnPackStreamsVector,
943 unPackSizes,
944 digestsDefined,
945 digests));
946 database.ArchiveInfo.DataStartPosition += database.ArchiveInfo.StartPositionAfterHeader;
947 RINOK(ReadID(type));
948 }
949 else
950 {
951 for(int i = 0; i < database.Folders.Size(); i++)
952 {
953 database.NumUnPackStreamsVector.Add(1);
954 CFolder &folder = database.Folders[i];
955 unPackSizes.Add(folder.GetUnPackSize());
956 digestsDefined.Add(folder.UnPackCRCDefined);
957 digests.Add(folder.UnPackCRC);
958 }
959 }
960
961 database.Files.Clear();
962
963 if (type == NID::kEnd)
964 return S_OK;
965 if (type != NID::kFilesInfo)
966 throw CInArchiveException(CInArchiveException::kIncorrectHeader);
967
968 CNum numFiles;
969 RINOK(ReadNum(numFiles));
970 database.Files.Reserve(numFiles);
971 CNum i;
972 for(i = 0; i < numFiles; i++)
973 database.Files.Add(CFileItem());
974
975 database.ArchiveInfo.FileInfoPopIDs.Add(NID::kSize);
976 if (!database.PackSizes.IsEmpty())
977 database.ArchiveInfo.FileInfoPopIDs.Add(NID::kPackInfo);
978 if (numFiles > 0 && !digests.IsEmpty())
979 database.ArchiveInfo.FileInfoPopIDs.Add(NID::kCRC);
980
981 CBoolVector emptyStreamVector;
982 emptyStreamVector.Reserve((int)numFiles);
983 for(i = 0; i < numFiles; i++)
984 emptyStreamVector.Add(false);
985 CBoolVector emptyFileVector;
986 CBoolVector antiFileVector;
987 CNum numEmptyStreams = 0;
988
989 // int sizePrev = -1;
990 // int posPrev = 0;
991
992 while(true)
993 {
994 /*
995 if (sizePrev >= 0)
996 if (sizePrev != _inByteBack->GetProcessedSize() - posPrev)
997 throw 2;
998 */
999 UInt64 type;
1000 RINOK(ReadID(type));
1001 if (type == NID::kEnd)
1002 break;
1003 UInt64 size;
1004 RINOK(ReadNumber(size));
1005
1006 // sizePrev = size;
1007 // posPrev = _inByteBack->GetProcessedSize();
1008
1009 database.ArchiveInfo.FileInfoPopIDs.Add(type);
1010 switch(type)
1011 {
1012 case NID::kName:
1013 {
1014 CStreamSwitch streamSwitch;
1015 RINOK(streamSwitch.Set(this, &dataVector));
1016 RINOK(ReadFileNames(database.Files))
1017 break;
1018 }
1019 case NID::kWinAttributes:
1020 {
1021 CBoolVector boolVector;
1022 RINOK(ReadBoolVector2(database.Files.Size(), boolVector))
1023 CStreamSwitch streamSwitch;
1024 RINOK(streamSwitch.Set(this, &dataVector));
1025 for(i = 0; i < numFiles; i++)
1026 {
1027 CFileItem &file = database.Files[i];
1028 if (file.AreAttributesDefined = boolVector[i])
1029 {
1030 RINOK(ReadUInt32(file.Attributes));
1031 }
1032 }
1033 break;
1034 }
1035 case NID::kStartPos:
1036 {
1037 CBoolVector boolVector;
1038 RINOK(ReadBoolVector2(database.Files.Size(), boolVector))
1039 CStreamSwitch streamSwitch;
1040 RINOK(streamSwitch.Set(this, &dataVector));
1041 for(i = 0; i < numFiles; i++)
1042 {
1043 CFileItem &file = database.Files[i];
1044 if (file.IsStartPosDefined = boolVector[i])
1045 {
1046 RINOK(ReadUInt64(file.StartPos));
1047 }
1048 }
1049 break;
1050 }
1051 case NID::kEmptyStream:
1052 {
1053 RINOK(ReadBoolVector(numFiles, emptyStreamVector))
1054 for (i = 0; i < (CNum)emptyStreamVector.Size(); i++)
1055 if (emptyStreamVector[i])
1056 numEmptyStreams++;
1057 emptyFileVector.Reserve(numEmptyStreams);
1058 antiFileVector.Reserve(numEmptyStreams);
1059 for (i = 0; i < numEmptyStreams; i++)
1060 {
1061 emptyFileVector.Add(false);
1062 antiFileVector.Add(false);
1063 }
1064 break;
1065 }
1066 case NID::kEmptyFile:
1067 {
1068 RINOK(ReadBoolVector(numEmptyStreams, emptyFileVector))
1069 break;
1070 }
1071 case NID::kAnti:
1072 {
1073 RINOK(ReadBoolVector(numEmptyStreams, antiFileVector))
1074 break;
1075 }
1076 case NID::kCreationTime:
1077 case NID::kLastWriteTime:
1078 case NID::kLastAccessTime:
1079 {
1080 RINOK(ReadTime(dataVector, database.Files, type))
1081 break;
1082 }
1083 default:
1084 {
1085 database.ArchiveInfo.FileInfoPopIDs.DeleteBack();
1086 RINOK(SkeepData(size));
1087 }
1088 }
1089 }
1090
1091 CNum emptyFileIndex = 0;
1092 CNum sizeIndex = 0;
1093 for(i = 0; i < numFiles; i++)
1094 {
1095 CFileItem &file = database.Files[i];
1096 file.HasStream = !emptyStreamVector[i];
1097 if(file.HasStream)
1098 {
1099 file.IsDirectory = false;
1100 file.IsAnti = false;
1101 file.UnPackSize = unPackSizes[sizeIndex];
1102 file.FileCRC = digests[sizeIndex];
1103 file.IsFileCRCDefined = digestsDefined[sizeIndex];
1104 sizeIndex++;
1105 }
1106 else
1107 {
1108 file.IsDirectory = !emptyFileVector[emptyFileIndex];
1109 file.IsAnti = antiFileVector[emptyFileIndex];
1110 emptyFileIndex++;
1111 file.UnPackSize = 0;
1112 file.IsFileCRCDefined = false;
1113 }
1114 }
1115 return S_OK;
1116 }
1117
1118
1119 void CArchiveDatabaseEx::FillFolderStartPackStream()
1120 {
1121 FolderStartPackStreamIndex.Clear();
1122 FolderStartPackStreamIndex.Reserve(Folders.Size());
1123 CNum startPos = 0;
1124 for(int i = 0; i < Folders.Size(); i++)
1125 {
1126 FolderStartPackStreamIndex.Add(startPos);
1127 startPos += (CNum)Folders[i].PackStreams.Size();
1128 }
1129 }
1130
1131 void CArchiveDatabaseEx::FillStartPos()
1132 {
1133 PackStreamStartPositions.Clear();
1134 PackStreamStartPositions.Reserve(PackSizes.Size());
1135 UInt64 startPos = 0;
1136 for(int i = 0; i < PackSizes.Size(); i++)
1137 {
1138 PackStreamStartPositions.Add(startPos);
1139 startPos += PackSizes[i];
1140 }
1141 }
1142
1143 void CArchiveDatabaseEx::FillFolderStartFileIndex()
1144 {
1145 FolderStartFileIndex.Clear();
1146 FolderStartFileIndex.Reserve(Folders.Size());
1147 FileIndexToFolderIndexMap.Clear();
1148 FileIndexToFolderIndexMap.Reserve(Files.Size());
1149
1150 int folderIndex = 0;
1151 CNum indexInFolder = 0;
1152 for (int i = 0; i < Files.Size(); i++)
1153 {
1154 const CFileItem &file = Files[i];
1155 bool emptyStream = !file.HasStream;
1156 if (emptyStream && indexInFolder == 0)
1157 {
1158 FileIndexToFolderIndexMap.Add(kNumNoIndex);
1159 continue;
1160 }
1161 if (indexInFolder == 0)
1162 {
1163 // v3.13 incorrectly worked with empty folders
1164 // v4.07: Loop for skipping empty folders
1165 while(true)
1166 {
1167 if (folderIndex >= Folders.Size())
1168 throw CInArchiveException(CInArchiveException::kIncorrectHeader);
1169 FolderStartFileIndex.Add(i); // check it
1170 if (NumUnPackStreamsVector[folderIndex] != 0)
1171 break;
1172 folderIndex++;
1173 }
1174 }
1175 FileIndexToFolderIndexMap.Add(folderIndex);
1176 if (emptyStream)
1177 continue;
1178 indexInFolder++;
1179 if (indexInFolder >= NumUnPackStreamsVector[folderIndex])
1180 {
1181 folderIndex++;
1182 indexInFolder = 0;
1183 }
1184 }
1185 }
1186
1187 HRESULT CInArchive::ReadDatabase(CArchiveDatabaseEx &database
1188 #ifndef _NO_CRYPTO
1189 , ICryptoGetTextPassword *getTextPassword
1190 #endif
1191 )
1192 {
1193 database.Clear();
1194 database.ArchiveInfo.StartPosition = _arhiveBeginStreamPosition;
1195
1196
1197 RINOK(SafeReadDirect(&database.ArchiveInfo.Version.Major, 1));
1198 RINOK(SafeReadDirect(&database.ArchiveInfo.Version.Minor, 1));
1199 if (database.ArchiveInfo.Version.Major != kMajorVersion)
1200 throw CInArchiveException(CInArchiveException::kUnsupportedVersion);
1201
1202 #ifdef _7Z_VOL
1203 if (_finishSignature)
1204 {
1205 RINOK(_stream->Seek(_position - (4 + kFinishHeaderSize) -
1206 (kSignatureSize + 2), STREAM_SEEK_SET, &_position));
1207 }
1208 #endif
1209
1210 UInt32 crcFromArchive;
1211 RINOK(SafeReadDirectUInt32(crcFromArchive));
1212
1213 UInt64 nextHeaderOffset;
1214 UInt64 nextHeaderSize;
1215 UInt32 nextHeaderCRC;
1216 CCRC crc;
1217 RINOK(SafeReadDirectUInt64(nextHeaderOffset));
1218 crc.UpdateUInt64(nextHeaderOffset);
1219 RINOK(SafeReadDirectUInt64(nextHeaderSize));
1220 crc.UpdateUInt64(nextHeaderSize);
1221 RINOK(SafeReadDirectUInt32(nextHeaderCRC));
1222 crc.UpdateUInt32(nextHeaderCRC);
1223
1224 #ifdef _7Z_VOL
1225 UInt64 archiveStartOffset; // data offset from end if that struct
1226 UInt64 additionalStartBlockSize; // start signature & start header size
1227 if (_finishSignature)
1228 {
1229 RINOK(SafeReadDirectUInt64(archiveStartOffset));
1230 crc.UpdateUInt64(archiveStartOffset);
1231 RINOK(SafeReadDirectUInt64(additionalStartBlockSize));
1232 crc.UpdateUInt64(additionalStartBlockSize);
1233 database.ArchiveInfo.StartPositionAfterHeader = _position + archiveStartOffset;
1234 }
1235 else
1236 #endif
1237 {
1238 database.ArchiveInfo.StartPositionAfterHeader = _position;
1239 }
1240 if (crc.GetDigest() != crcFromArchive)
1241 throw CInArchiveException(CInArchiveException::kIncorrectHeader);
1242
1243 if (nextHeaderSize == 0)
1244 return S_OK;
1245
1246 if (nextHeaderSize >= 0xFFFFFFFF)
1247 return E_FAIL;
1248
1249 RINOK(_stream->Seek(nextHeaderOffset, STREAM_SEEK_CUR, &_position));
1250
1251 CByteBuffer buffer2;
1252 buffer2.SetCapacity((size_t)nextHeaderSize);
1253 RINOK(SafeReadDirect(buffer2, (UInt32)nextHeaderSize));
1254 if (!CCRC::VerifyDigest(nextHeaderCRC, buffer2, (UInt32)nextHeaderSize))
1255 throw CInArchiveException(CInArchiveException::kIncorrectHeader);
1256
1257 CStreamSwitch streamSwitch;
1258 streamSwitch.Set(this, buffer2);
1259
1260 CObjectVector<CByteBuffer> dataVector;
1261
1262 while (true)
1263 {
1264 UInt64 type;
1265 RINOK(ReadID(type));
1266 if (type == NID::kHeader)
1267 break;
1268 if (type != NID::kEncodedHeader)
1269 throw CInArchiveException(CInArchiveException::kIncorrectHeader);
1270 HRESULT result = ReadAndDecodePackedStreams(
1271 database.ArchiveInfo.StartPositionAfterHeader,
1272 database.ArchiveInfo.DataStartPosition2,
1273 dataVector
1274 #ifndef _NO_CRYPTO
1275 , getTextPassword
1276 #endif
1277 );
1278 RINOK(result);
1279 if (dataVector.Size() == 0)
1280 return S_OK;
1281 if (dataVector.Size() > 1)
1282 throw CInArchiveException(CInArchiveException::kIncorrectHeader);
1283 streamSwitch.Remove();
1284 streamSwitch.Set(this, dataVector.Front());
1285 }
1286
1287 return ReadHeader(database
1288 #ifndef _NO_CRYPTO
1289 , getTextPassword
1290 #endif
1291 );
1292 }
1293
1294 }}

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial