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