The-Homebrew-Cloud/snes9xgx
2
0
Fork 0
mirror of https://github.com/dborth/snes9xgx.git synced 2024-12-27 19:51:49 +01:00
Code Issues Packages Projects Releases Wiki Activity
62e529c6e7
snes9xgx/source/utils/sz/7zIn.c
dborth d7018c0a23 reorg
2010-03-21 20:26:00 +00:00

1282 lines
32 KiB
C
Raw Blame History

/* 7zIn.c */
#include "7zIn.h"
#include "7zCrc.h"
#include "7zDecode.h"
#define RINOM(x) { if((x) == 0) return SZE_OUTOFMEMORY; }
void SzArDbExInit(CArchiveDatabaseEx *db)
{
SzArchiveDatabaseInit(&db->Database);
db->FolderStartPackStreamIndex = 0;
db->PackStreamStartPositions = 0;
db->FolderStartFileIndex = 0;
db->FileIndexToFolderIndexMap = 0;
}
void SzArDbExFree(CArchiveDatabaseEx *db, void (*freeFunc)(void *))
{
freeFunc(db->FolderStartPackStreamIndex);
freeFunc(db->PackStreamStartPositions);
freeFunc(db->FolderStartFileIndex);
freeFunc(db->FileIndexToFolderIndexMap);
SzArchiveDatabaseFree(&db->Database, freeFunc);
SzArDbExInit(db);
}
/*
CFileSize GetFolderPackStreamSize(int folderIndex, int streamIndex) const
{
return PackSizes[FolderStartPackStreamIndex[folderIndex] + streamIndex];
}
CFileSize GetFilePackSize(int fileIndex) const
{
int folderIndex = FileIndexToFolderIndexMap[fileIndex];
if (folderIndex >= 0)
{
const CFolder &folderInfo = Folders[folderIndex];
if (FolderStartFileIndex[folderIndex] == fileIndex)
return GetFolderFullPackSize(folderIndex);
}
return 0;
}
*/
#define MY_ALLOC(T, p, size, allocFunc) { if ((size) == 0) p = 0; else \
if ((p = (T *)allocFunc((size) * sizeof(T))) == 0) return SZE_OUTOFMEMORY; }
SZ_RESULT SzArDbExFill(CArchiveDatabaseEx *db, void * (*allocFunc)(size_t size))
{
UInt32 startPos = 0;
CFileSize startPosSize = 0;
UInt32 i;
UInt32 folderIndex = 0;
UInt32 indexInFolder = 0;
MY_ALLOC(UInt32, db->FolderStartPackStreamIndex, db->Database.NumFolders, allocFunc);
for(i = 0; i < db->Database.NumFolders; i++)
{
db->FolderStartPackStreamIndex[i] = startPos;
startPos += db->Database.Folders[i].NumPackStreams;
}
MY_ALLOC(CFileSize, db->PackStreamStartPositions, db->Database.NumPackStreams, allocFunc);
for(i = 0; i < db->Database.NumPackStreams; i++)
{
db->PackStreamStartPositions[i] = startPosSize;
startPosSize += db->Database.PackSizes[i];
}
MY_ALLOC(UInt32, db->FolderStartFileIndex, db->Database.NumFolders, allocFunc);
MY_ALLOC(UInt32, db->FileIndexToFolderIndexMap, db->Database.NumFiles, allocFunc);
for (i = 0; i < db->Database.NumFiles; i++)
{
CFileItem *file = db->Database.Files + i;
int emptyStream = !file->HasStream;
if (emptyStream && indexInFolder == 0)
{
db->FileIndexToFolderIndexMap[i] = (UInt32)-1;
continue;
}
if (indexInFolder == 0)
{
/*
v3.13 incorrectly worked with empty folders
v4.07: Loop for skipping empty folders
*/
while(1)
{
if (folderIndex >= db->Database.NumFolders)
return SZE_ARCHIVE_ERROR;
db->FolderStartFileIndex[folderIndex] = i;
if (db->Database.Folders[folderIndex].NumUnPackStreams != 0)
break;
folderIndex++;
}
}
db->FileIndexToFolderIndexMap[i] = folderIndex;
if (emptyStream)
continue;
indexInFolder++;
if (indexInFolder >= db->Database.Folders[folderIndex].NumUnPackStreams)
{
folderIndex++;
indexInFolder = 0;
}
}
return SZ_OK;
}
CFileSize SzArDbGetFolderStreamPos(CArchiveDatabaseEx *db, UInt32 folderIndex, UInt32 indexInFolder)
{
return db->ArchiveInfo.DataStartPosition +
db->PackStreamStartPositions[db->FolderStartPackStreamIndex[folderIndex] + indexInFolder];
}
CFileSize SzArDbGetFolderFullPackSize(CArchiveDatabaseEx *db, UInt32 folderIndex)
{
UInt32 packStreamIndex = db->FolderStartPackStreamIndex[folderIndex];
CFolder *folder = db->Database.Folders + folderIndex;
CFileSize size = 0;
UInt32 i;
for (i = 0; i < folder->NumPackStreams; i++)
size += db->Database.PackSizes[packStreamIndex + i];
return size;
}
/*
SZ_RESULT SzReadTime(const CObjectVector<CSzByteBuffer> &dataVector,
CObjectVector<CFileItem> &files, UInt64 type)
{
CBoolVector boolVector;
RINOK(ReadBoolVector2(files.Size(), boolVector))
CStreamSwitch streamSwitch;
RINOK(streamSwitch.Set(this, &dataVector));
for(int i = 0; i < files.Size(); i++)
{
CFileItem &file = files[i];
CArchiveFileTime fileTime;
bool defined = boolVector[i];
if (defined)
{
UInt32 low, high;
RINOK(SzReadUInt32(low));
RINOK(SzReadUInt32(high));
fileTime.dwLowDateTime = low;
fileTime.dwHighDateTime = high;
}
switch(type)
{
case k7zIdCreationTime:
file.IsCreationTimeDefined = defined;
if (defined)
file.CreationTime = fileTime;
break;
case k7zIdLastWriteTime:
file.IsLastWriteTimeDefined = defined;
if (defined)
file.LastWriteTime = fileTime;
break;
case k7zIdLastAccessTime:
file.IsLastAccessTimeDefined = defined;
if (defined)
file.LastAccessTime = fileTime;
break;
}
}
return SZ_OK;
}
*/
SZ_RESULT SafeReadDirect(ISzInStream *inStream, Byte *data, size_t size)
{
#ifdef _LZMA_IN_CB
while (size > 0)
{
Byte *inBuffer;
size_t processedSize;
RINOK(inStream->Read(inStream, (void **)&inBuffer, size, &processedSize));
if (processedSize == 0 || processedSize > size)
return SZE_FAIL;
size -= processedSize;
do
{
*data++ = *inBuffer++;
}
while (--processedSize != 0);
}
#else
size_t processedSize;
RINOK(inStream->Read(inStream, data, size, &processedSize));
if (processedSize != size)
return SZE_FAIL;
#endif
return SZ_OK;
}
SZ_RESULT SafeReadDirectByte(ISzInStream *inStream, Byte *data)
{
return SafeReadDirect(inStream, data, 1);
}
SZ_RESULT SafeReadDirectUInt32(ISzInStream *inStream, UInt32 *value)
{
int i;
*value = 0;
for (i = 0; i < 4; i++)
{
Byte b;
RINOK(SafeReadDirectByte(inStream, &b));
*value |= ((UInt32)b << (8 * i));
}
return SZ_OK;
}
SZ_RESULT SafeReadDirectUInt64(ISzInStream *inStream, UInt64 *value)
{
int i;
*value = 0;
for (i = 0; i < 8; i++)
{
Byte b;
RINOK(SafeReadDirectByte(inStream, &b));
*value |= ((UInt32)b << (8 * i));
}
return SZ_OK;
}
int TestSignatureCandidate(Byte *testBytes)
{
size_t i;
for (i = 0; i < k7zSignatureSize; i++)
if (testBytes[i] != k7zSignature[i])
return 0;
return 1;
}
typedef struct _CSzState
{
Byte *Data;
size_t Size;
}CSzData;
SZ_RESULT SzReadByte(CSzData *sd, Byte *b)
{
if (sd->Size == 0)
return SZE_ARCHIVE_ERROR;
sd->Size--;
*b = *sd->Data++;
return SZ_OK;
}
SZ_RESULT SzReadBytes(CSzData *sd, Byte *data, size_t size)
{
size_t i;
for (i = 0; i < size; i++)
{
RINOK(SzReadByte(sd, data + i));
}
return SZ_OK;
}
SZ_RESULT SzReadUInt32(CSzData *sd, UInt32 *value)
{
int i;
*value = 0;
for (i = 0; i < 4; i++)
{
Byte b;
RINOK(SzReadByte(sd, &b));
*value |= ((UInt32)(b) << (8 * i));
}
return SZ_OK;
}
SZ_RESULT SzReadNumber(CSzData *sd, UInt64 *value)
{
Byte firstByte;
Byte mask = 0x80;
int i;
RINOK(SzReadByte(sd, &firstByte));
*value = 0;
for (i = 0; i < 8; i++)
{
Byte b;
if ((firstByte & mask) == 0)
{
UInt64 highPart = firstByte & (mask - 1);
*value += (highPart << (8 * i));
return SZ_OK;
}
RINOK(SzReadByte(sd, &b));
*value |= ((UInt64)b << (8 * i));
mask >>= 1;
}
return SZ_OK;
}
SZ_RESULT SzReadSize(CSzData *sd, CFileSize *value)
{
UInt64 value64;
RINOK(SzReadNumber(sd, &value64));
*value = (CFileSize)value64;
return SZ_OK;
}
SZ_RESULT SzReadNumber32(CSzData *sd, UInt32 *value)
{
UInt64 value64;
RINOK(SzReadNumber(sd, &value64));
if (value64 >= 0x80000000)
return SZE_NOTIMPL;
if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 2)))
return SZE_NOTIMPL;
*value = (UInt32)value64;
return SZ_OK;
}
SZ_RESULT SzReadID(CSzData *sd, UInt64 *value)
{
return SzReadNumber(sd, value);
}
SZ_RESULT SzSkeepDataSize(CSzData *sd, UInt64 size)
{
if (size > sd->Size)
return SZE_ARCHIVE_ERROR;
sd->Size -= (size_t)size;
sd->Data += (size_t)size;
return SZ_OK;
}
SZ_RESULT SzSkeepData(CSzData *sd)
{
UInt64 size;
RINOK(SzReadNumber(sd, &size));
return SzSkeepDataSize(sd, size);
}
SZ_RESULT SzReadArchiveProperties(CSzData *sd)
{
while(1)
{
UInt64 type;
RINOK(SzReadID(sd, &type));
if (type == k7zIdEnd)
break;
SzSkeepData(sd);
}
return SZ_OK;
}
SZ_RESULT SzWaitAttribute(CSzData *sd, UInt64 attribute)
{
while(1)
{
UInt64 type;
RINOK(SzReadID(sd, &type));
if (type == attribute)
return SZ_OK;
if (type == k7zIdEnd)
return SZE_ARCHIVE_ERROR;
RINOK(SzSkeepData(sd));
}
}
SZ_RESULT SzReadBoolVector(CSzData *sd, size_t numItems, Byte **v, void * (*allocFunc)(size_t size))
{
Byte b = 0;
Byte mask = 0;
size_t i;
MY_ALLOC(Byte, *v, numItems, allocFunc);
for(i = 0; i < numItems; i++)
{
if (mask == 0)
{
RINOK(SzReadByte(sd, &b));
mask = 0x80;
}
(*v)[i] = (Byte)(((b & mask) != 0) ? 1 : 0);
mask >>= 1;
}
return SZ_OK;
}
SZ_RESULT SzReadBoolVector2(CSzData *sd, size_t numItems, Byte **v, void * (*allocFunc)(size_t size))
{
Byte allAreDefined;
size_t i;
RINOK(SzReadByte(sd, &allAreDefined));
if (allAreDefined == 0)
return SzReadBoolVector(sd, numItems, v, allocFunc);
MY_ALLOC(Byte, *v, numItems, allocFunc);
for(i = 0; i < numItems; i++)
(*v)[i] = 1;
return SZ_OK;
}
SZ_RESULT SzReadHashDigests(
CSzData *sd,
size_t numItems,
Byte **digestsDefined,
UInt32 **digests,
void * (*allocFunc)(size_t size))
{
size_t i;
RINOK(SzReadBoolVector2(sd, numItems, digestsDefined, allocFunc));
MY_ALLOC(UInt32, *digests, numItems, allocFunc);
for(i = 0; i < numItems; i++)
if ((*digestsDefined)[i])
{
RINOK(SzReadUInt32(sd, (*digests) + i));
}
return SZ_OK;
}
SZ_RESULT SzReadPackInfo(
CSzData *sd,
CFileSize *dataOffset,
UInt32 *numPackStreams,
CFileSize **packSizes,
Byte **packCRCsDefined,
UInt32 **packCRCs,
void * (*allocFunc)(size_t size))
{
UInt32 i;
RINOK(SzReadSize(sd, dataOffset));
RINOK(SzReadNumber32(sd, numPackStreams));
RINOK(SzWaitAttribute(sd, k7zIdSize));
MY_ALLOC(CFileSize, *packSizes, (size_t)*numPackStreams, allocFunc);
for(i = 0; i < *numPackStreams; i++)
{
RINOK(SzReadSize(sd, (*packSizes) + i));
}
while(1)
{
UInt64 type;
RINOK(SzReadID(sd, &type));
if (type == k7zIdEnd)
break;
if (type == k7zIdCRC)
{
RINOK(SzReadHashDigests(sd, (size_t)*numPackStreams, packCRCsDefined, packCRCs, allocFunc));
continue;
}
RINOK(SzSkeepData(sd));
}
if (*packCRCsDefined == 0)
{
MY_ALLOC(Byte, *packCRCsDefined, (size_t)*numPackStreams, allocFunc);
MY_ALLOC(UInt32, *packCRCs, (size_t)*numPackStreams, allocFunc);
for(i = 0; i < *numPackStreams; i++)
{
(*packCRCsDefined)[i] = 0;
(*packCRCs)[i] = 0;
}
}
return SZ_OK;
}
SZ_RESULT SzReadSwitch(CSzData *sd)
{
Byte external;
RINOK(SzReadByte(sd, &external));
return (external == 0) ? SZ_OK: SZE_ARCHIVE_ERROR;
}
SZ_RESULT SzGetNextFolderItem(CSzData *sd, CFolder *folder, void * (*allocFunc)(size_t size))
{
UInt32 numCoders;
UInt32 numBindPairs;
UInt32 numPackedStreams;
UInt32 i;
UInt32 numInStreams = 0;
UInt32 numOutStreams = 0;
RINOK(SzReadNumber32(sd, &numCoders));
folder->NumCoders = numCoders;
MY_ALLOC(CCoderInfo, folder->Coders, (size_t)numCoders, allocFunc);
for (i = 0; i < numCoders; i++)
SzCoderInfoInit(folder->Coders + i);
for (i = 0; i < numCoders; i++)
{
Byte mainByte;
CCoderInfo *coder = folder->Coders + i;
{
RINOK(SzReadByte(sd, &mainByte));
coder->MethodID.IDSize = (Byte)(mainByte & 0xF);
RINOK(SzReadBytes(sd, coder->MethodID.ID, coder->MethodID.IDSize));
if ((mainByte & 0x10) != 0)
{
RINOK(SzReadNumber32(sd, &coder->NumInStreams));
RINOK(SzReadNumber32(sd, &coder->NumOutStreams));
}
else
{
coder->NumInStreams = 1;
coder->NumOutStreams = 1;
}
if ((mainByte & 0x20) != 0)
{
UInt64 propertiesSize = 0;
RINOK(SzReadNumber(sd, &propertiesSize));
if (!SzByteBufferCreate(&coder->Properties, (size_t)propertiesSize, allocFunc))
return SZE_OUTOFMEMORY;
RINOK(SzReadBytes(sd, coder->Properties.Items, (size_t)propertiesSize));
}
}
while ((mainByte & 0x80) != 0)
{
RINOK(SzReadByte(sd, &mainByte));
RINOK(SzSkeepDataSize(sd, (mainByte & 0xF)));
if ((mainByte & 0x10) != 0)
{
UInt32 n;
RINOK(SzReadNumber32(sd, &n));
RINOK(SzReadNumber32(sd, &n));
}
if ((mainByte & 0x20) != 0)
{
UInt64 propertiesSize = 0;
RINOK(SzReadNumber(sd, &propertiesSize));
RINOK(SzSkeepDataSize(sd, propertiesSize));
}
}
numInStreams += (UInt32)coder->NumInStreams;
numOutStreams += (UInt32)coder->NumOutStreams;
}
numBindPairs = numOutStreams - 1;
folder->NumBindPairs = numBindPairs;
MY_ALLOC(CBindPair, folder->BindPairs, (size_t)numBindPairs, allocFunc);
for (i = 0; i < numBindPairs; i++)
{
CBindPair *bindPair = folder->BindPairs + i;;
RINOK(SzReadNumber32(sd, &bindPair->InIndex));
RINOK(SzReadNumber32(sd, &bindPair->OutIndex));
}
numPackedStreams = numInStreams - (UInt32)numBindPairs;
folder->NumPackStreams = numPackedStreams;
MY_ALLOC(UInt32, folder->PackStreams, (size_t)numPackedStreams, allocFunc);
if (numPackedStreams == 1)
{
UInt32 j;
UInt32 pi = 0;
for (j = 0; j < numInStreams; j++)
if (SzFolderFindBindPairForInStream(folder, j) < 0)
{
folder->PackStreams[pi++] = j;
break;
}
}
else
for(i = 0; i < numPackedStreams; i++)
{
RINOK(SzReadNumber32(sd, folder->PackStreams + i));
}
return SZ_OK;
}
SZ_RESULT SzReadUnPackInfo(
CSzData *sd,
UInt32 *numFolders,
CFolder **folders, /* for allocFunc */
void * (*allocFunc)(size_t size),
ISzAlloc *allocTemp)
{
UInt32 i;
RINOK(SzWaitAttribute(sd, k7zIdFolder));
RINOK(SzReadNumber32(sd, numFolders));
{
RINOK(SzReadSwitch(sd));
MY_ALLOC(CFolder, *folders, (size_t)*numFolders, allocFunc);
for(i = 0; i < *numFolders; i++)
SzFolderInit((*folders) + i);
for(i = 0; i < *numFolders; i++)
{
RINOK(SzGetNextFolderItem(sd, (*folders) + i, allocFunc));
}
}
RINOK(SzWaitAttribute(sd, k7zIdCodersUnPackSize));
for(i = 0; i < *numFolders; i++)
{
UInt32 j;
CFolder *folder = (*folders) + i;
UInt32 numOutStreams = SzFolderGetNumOutStreams(folder);
MY_ALLOC(CFileSize, folder->UnPackSizes, (size_t)numOutStreams, allocFunc);
for(j = 0; j < numOutStreams; j++)
{
RINOK(SzReadSize(sd, folder->UnPackSizes + j));
}
}
while(1)
{
UInt64 type;
RINOK(SzReadID(sd, &type));
if (type == k7zIdEnd)
return SZ_OK;
if (type == k7zIdCRC)
{
SZ_RESULT res;
Byte *crcsDefined = 0;
UInt32 *crcs = 0;
res = SzReadHashDigests(sd, *numFolders, &crcsDefined, &crcs, allocTemp->Alloc);
if (res == SZ_OK)
{
for(i = 0; i < *numFolders; i++)
{
CFolder *folder = (*folders) + i;
folder->UnPackCRCDefined = crcsDefined[i];
folder->UnPackCRC = crcs[i];
}
}
allocTemp->Free(crcs);
allocTemp->Free(crcsDefined);
RINOK(res);
continue;
}
RINOK(SzSkeepData(sd));
}
}
SZ_RESULT SzReadSubStreamsInfo(
CSzData *sd,
UInt32 numFolders,
CFolder *folders,
UInt32 *numUnPackStreams,
CFileSize **unPackSizes,
Byte **digestsDefined,
UInt32 **digests,
ISzAlloc *allocTemp)
{
UInt64 type = 0;
UInt32 i;
UInt32 si = 0;
UInt32 numDigests = 0;
for(i = 0; i < numFolders; i++)
folders[i].NumUnPackStreams = 1;
*numUnPackStreams = numFolders;
while(1)
{
RINOK(SzReadID(sd, &type));
if (type == k7zIdNumUnPackStream)
{
*numUnPackStreams = 0;
for(i = 0; i < numFolders; i++)
{
UInt32 numStreams;
RINOK(SzReadNumber32(sd, &numStreams));
folders[i].NumUnPackStreams = numStreams;
*numUnPackStreams += numStreams;
}
continue;
}
if (type == k7zIdCRC || type == k7zIdSize)
break;
if (type == k7zIdEnd)
break;
RINOK(SzSkeepData(sd));
}
if (*numUnPackStreams == 0)
{
*unPackSizes = 0;
*digestsDefined = 0;
*digests = 0;
}
else
{
*unPackSizes = (CFileSize *)allocTemp->Alloc((size_t)*numUnPackStreams * sizeof(CFileSize));
RINOM(*unPackSizes);
*digestsDefined = (Byte *)allocTemp->Alloc((size_t)*numUnPackStreams * sizeof(Byte));
RINOM(*digestsDefined);
*digests = (UInt32 *)allocTemp->Alloc((size_t)*numUnPackStreams * sizeof(UInt32));
RINOM(*digests);
}
for(i = 0; i < numFolders; i++)
{
/*
v3.13 incorrectly worked with empty folders
v4.07: we check that folder is empty
*/
CFileSize sum = 0;
UInt32 j;
UInt32 numSubstreams = folders[i].NumUnPackStreams;
if (numSubstreams == 0)
continue;
if (type == k7zIdSize)
for (j = 1; j < numSubstreams; j++)
{
CFileSize size;
RINOK(SzReadSize(sd, &size));
(*unPackSizes)[si++] = size;
sum += size;
}
(*unPackSizes)[si++] = SzFolderGetUnPackSize(folders + i) - sum;
}
if (type == k7zIdSize)
{
RINOK(SzReadID(sd, &type));
}
for(i = 0; i < *numUnPackStreams; i++)
{
(*digestsDefined)[i] = 0;
(*digests)[i] = 0;
}
for(i = 0; i < numFolders; i++)
{
UInt32 numSubstreams = folders[i].NumUnPackStreams;
if (numSubstreams != 1 || !folders[i].UnPackCRCDefined)
numDigests += numSubstreams;
}
si = 0;
while(1)
{
if (type == k7zIdCRC)
{
int digestIndex = 0;
Byte *digestsDefined2 = 0;
UInt32 *digests2 = 0;
SZ_RESULT res = SzReadHashDigests(sd, numDigests, &digestsDefined2, &digests2, allocTemp->Alloc);
if (res == SZ_OK)
{
for (i = 0; i < numFolders; i++)
{
CFolder *folder = folders + i;
UInt32 numSubstreams = folder->NumUnPackStreams;
if (numSubstreams == 1 && folder->UnPackCRCDefined)
{
(*digestsDefined)[si] = 1;
(*digests)[si] = folder->UnPackCRC;
si++;
}
else
{
UInt32 j;
for (j = 0; j < numSubstreams; j++, digestIndex++)
{
(*digestsDefined)[si] = digestsDefined2[digestIndex];
(*digests)[si] = digests2[digestIndex];
si++;
}
}
}
}
allocTemp->Free(digestsDefined2);
allocTemp->Free(digests2);
RINOK(res);
}
else if (type == k7zIdEnd)
return SZ_OK;
else
{
RINOK(SzSkeepData(sd));
}
RINOK(SzReadID(sd, &type));
}
}
SZ_RESULT SzReadStreamsInfo(
CSzData *sd,
CFileSize *dataOffset,
CArchiveDatabase *db,
UInt32 *numUnPackStreams,
CFileSize **unPackSizes, /* allocTemp */
Byte **digestsDefined, /* allocTemp */
UInt32 **digests, /* allocTemp */
void * (*allocFunc)(size_t size),
ISzAlloc *allocTemp)
{
while(1)
{
UInt64 type;
RINOK(SzReadID(sd, &type));
if ((UInt64)(int)type != type)
return SZE_FAIL;
switch((int)type)
{
case k7zIdEnd:
return SZ_OK;
case k7zIdPackInfo:
{
RINOK(SzReadPackInfo(sd, dataOffset, &db->NumPackStreams,
&db->PackSizes, &db->PackCRCsDefined, &db->PackCRCs, allocFunc));
break;
}
case k7zIdUnPackInfo:
{
RINOK(SzReadUnPackInfo(sd, &db->NumFolders, &db->Folders, allocFunc, allocTemp));
break;
}
case k7zIdSubStreamsInfo:
{
RINOK(SzReadSubStreamsInfo(sd, db->NumFolders, db->Folders,
numUnPackStreams, unPackSizes, digestsDefined, digests, allocTemp));
break;
}
default:
return SZE_FAIL;
}
}
}
Byte kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
SZ_RESULT SzReadFileNames(CSzData *sd, UInt32 numFiles, CFileItem *files,
void * (*allocFunc)(size_t size))
{
UInt32 i;
for(i = 0; i < numFiles; i++)
{
UInt32 len = 0;
UInt32 pos = 0;
CFileItem *file = files + i;
while(pos + 2 <= sd->Size)
{
int numAdds;
UInt32 value = (UInt32)(sd->Data[pos] | (((UInt32)sd->Data[pos + 1]) << 8));
pos += 2;
len++;
if (value == 0)
break;
if (value < 0x80)
continue;
if (value >= 0xD800 && value < 0xE000)
{
UInt32 c2;
if (value >= 0xDC00)
return SZE_ARCHIVE_ERROR;
if (pos + 2 > sd->Size)
return SZE_ARCHIVE_ERROR;
c2 = (UInt32)(sd->Data[pos] | (((UInt32)sd->Data[pos + 1]) << 8));
pos += 2;
if (c2 < 0xDC00 || c2 >= 0xE000)
return SZE_ARCHIVE_ERROR;
value = ((value - 0xD800) << 10) | (c2 - 0xDC00);
}
for (numAdds = 1; numAdds < 5; numAdds++)
if (value < (((UInt32)1) << (numAdds * 5 + 6)))
break;
len += numAdds;
}
MY_ALLOC(char, file->Name, (size_t)len, allocFunc);
len = 0;
while(2 <= sd->Size)
{
int numAdds;
UInt32 value = (UInt32)(sd->Data[0] | (((UInt32)sd->Data[1]) << 8));
SzSkeepDataSize(sd, 2);
if (value < 0x80)
{
file->Name[len++] = (char)value;
if (value == 0)
break;
continue;
}
if (value >= 0xD800 && value < 0xE000)
{
UInt32 c2 = (UInt32)(sd->Data[0] | (((UInt32)sd->Data[1]) << 8));
SzSkeepDataSize(sd, 2);
value = ((value - 0xD800) << 10) | (c2 - 0xDC00);
}
for (numAdds = 1; numAdds < 5; numAdds++)
if (value < (((UInt32)1) << (numAdds * 5 + 6)))
break;
file->Name[len++] = (char)(kUtf8Limits[numAdds - 1] + (value >> (6 * numAdds)));
do
{
numAdds--;
file->Name[len++] = (char)(0x80 + ((value >> (6 * numAdds)) & 0x3F));
}
while(numAdds > 0);
len += numAdds;
}
}
return SZ_OK;
}
SZ_RESULT SzReadHeader2(
CSzData *sd,
CArchiveDatabaseEx *db, /* allocMain */
CFileSize **unPackSizes, /* allocTemp */
Byte **digestsDefined, /* allocTemp */
UInt32 **digests, /* allocTemp */
Byte **emptyStreamVector, /* allocTemp */
Byte **emptyFileVector, /* allocTemp */
ISzAlloc *allocMain,
ISzAlloc *allocTemp)
{
UInt64 type;
UInt32 numUnPackStreams = 0;
UInt32 numFiles = 0;
CFileItem *files = 0;
UInt32 numEmptyStreams = 0;
UInt32 i;
RINOK(SzReadID(sd, &type));
if (type == k7zIdArchiveProperties)
{
RINOK(SzReadArchiveProperties(sd));
RINOK(SzReadID(sd, &type));
}
if (type == k7zIdMainStreamsInfo)
{
RINOK(SzReadStreamsInfo(sd,
&db->ArchiveInfo.DataStartPosition,
&db->Database,
&numUnPackStreams,
unPackSizes,
digestsDefined,
digests, allocMain->Alloc, allocTemp));
db->ArchiveInfo.DataStartPosition += db->ArchiveInfo.StartPositionAfterHeader;
RINOK(SzReadID(sd, &type));
}
if (type == k7zIdEnd)
return SZ_OK;
if (type != k7zIdFilesInfo)
return SZE_ARCHIVE_ERROR;
RINOK(SzReadNumber32(sd, &numFiles));
db->Database.NumFiles = numFiles;
MY_ALLOC(CFileItem, files, (size_t)numFiles, allocMain->Alloc);
db->Database.Files = files;
for(i = 0; i < numFiles; i++)
SzFileInit(files + i);
while(1)
{
UInt64 type;
UInt64 size;
RINOK(SzReadID(sd, &type));
if (type == k7zIdEnd)
break;
RINOK(SzReadNumber(sd, &size));
if ((UInt64)(int)type != type)
{
RINOK(SzSkeepDataSize(sd, size));
}
else
switch((int)type)
{
case k7zIdName:
{
RINOK(SzReadSwitch(sd));
RINOK(SzReadFileNames(sd, numFiles, files, allocMain->Alloc))
break;
}
case k7zIdEmptyStream:
{
RINOK(SzReadBoolVector(sd, numFiles, emptyStreamVector, allocTemp->Alloc));
numEmptyStreams = 0;
for (i = 0; i < numFiles; i++)
if ((*emptyStreamVector)[i])
numEmptyStreams++;
break;
}
case k7zIdEmptyFile:
{
RINOK(SzReadBoolVector(sd, numEmptyStreams, emptyFileVector, allocTemp->Alloc));
break;
}
default:
{
RINOK(SzSkeepDataSize(sd, size));
}
}
}
{
UInt32 emptyFileIndex = 0;
UInt32 sizeIndex = 0;
for(i = 0; i < numFiles; i++)
{
CFileItem *file = files + i;
file->IsAnti = 0;
if (*emptyStreamVector == 0)
file->HasStream = 1;
else
file->HasStream = (Byte)((*emptyStreamVector)[i] ? 0 : 1);
if(file->HasStream)
{
file->IsDirectory = 0;
file->Size = (*unPackSizes)[sizeIndex];
file->FileCRC = (*digests)[sizeIndex];
file->IsFileCRCDefined = (Byte)(*digestsDefined)[sizeIndex];
sizeIndex++;
}
else
{
if (*emptyFileVector == 0)
file->IsDirectory = 1;
else
file->IsDirectory = (Byte)((*emptyFileVector)[emptyFileIndex] ? 0 : 1);
emptyFileIndex++;
file->Size = 0;
file->IsFileCRCDefined = 0;
}
}
}
return SzArDbExFill(db, allocMain->Alloc);
}
SZ_RESULT SzReadHeader(
CSzData *sd,
CArchiveDatabaseEx *db,
ISzAlloc *allocMain,
ISzAlloc *allocTemp)
{
CFileSize *unPackSizes = 0;
Byte *digestsDefined = 0;
UInt32 *digests = 0;
Byte *emptyStreamVector = 0;
Byte *emptyFileVector = 0;
SZ_RESULT res = SzReadHeader2(sd, db,
&unPackSizes, &digestsDefined, &digests,
&emptyStreamVector, &emptyFileVector,
allocMain, allocTemp);
allocTemp->Free(unPackSizes);
allocTemp->Free(digestsDefined);
allocTemp->Free(digests);
allocTemp->Free(emptyStreamVector);
allocTemp->Free(emptyFileVector);
return res;
}
SZ_RESULT SzReadAndDecodePackedStreams2(
ISzInStream *inStream,
CSzData *sd,
CSzByteBuffer *outBuffer,
CFileSize baseOffset,
CArchiveDatabase *db,
CFileSize **unPackSizes,
Byte **digestsDefined,
UInt32 **digests,
#ifndef _LZMA_IN_CB
Byte **inBuffer,
#endif
ISzAlloc *allocTemp)
{
UInt32 numUnPackStreams = 0;
CFileSize dataStartPos;
CFolder *folder;
#ifndef _LZMA_IN_CB
CFileSize packSize = 0;
UInt32 i = 0;
#endif
CFileSize unPackSize;
size_t outRealSize;
SZ_RESULT res;
RINOK(SzReadStreamsInfo(sd, &dataStartPos, db,
&numUnPackStreams, unPackSizes, digestsDefined, digests,
allocTemp->Alloc, allocTemp));
dataStartPos += baseOffset;
if (db->NumFolders != 1)
return SZE_ARCHIVE_ERROR;
folder = db->Folders;
unPackSize = SzFolderGetUnPackSize(folder);
RINOK(inStream->Seek(inStream, dataStartPos));
#ifndef _LZMA_IN_CB
for (i = 0; i < db->NumPackStreams; i++)
packSize += db->PackSizes[i];
MY_ALLOC(Byte, *inBuffer, (size_t)packSize, allocTemp->Alloc);
RINOK(SafeReadDirect(inStream, *inBuffer, (size_t)packSize));
#endif
if (!SzByteBufferCreate(outBuffer, (size_t)unPackSize, allocTemp->Alloc))
return SZE_OUTOFMEMORY;
res = SzDecode(db->PackSizes, folder,
#ifdef _LZMA_IN_CB
inStream,
#else
*inBuffer,
#endif
outBuffer->Items, (size_t)unPackSize,
&outRealSize, allocTemp);
RINOK(res)
if (outRealSize != (UInt32)unPackSize)
return SZE_FAIL;
if (folder->UnPackCRCDefined)
if (!CrcVerifyDigest(folder->UnPackCRC, outBuffer->Items, (size_t)unPackSize))
return SZE_FAIL;
return SZ_OK;
}
SZ_RESULT SzReadAndDecodePackedStreams(
ISzInStream *inStream,
CSzData *sd,
CSzByteBuffer *outBuffer,
CFileSize baseOffset,
ISzAlloc *allocTemp)
{
CArchiveDatabase db;
CFileSize *unPackSizes = 0;
Byte *digestsDefined = 0;
UInt32 *digests = 0;
#ifndef _LZMA_IN_CB
Byte *inBuffer = 0;
#endif
SZ_RESULT res;
SzArchiveDatabaseInit(&db);
res = SzReadAndDecodePackedStreams2(inStream, sd, outBuffer, baseOffset,
&db, &unPackSizes, &digestsDefined, &digests,
#ifndef _LZMA_IN_CB
&inBuffer,
#endif
allocTemp);
SzArchiveDatabaseFree(&db, allocTemp->Free);
allocTemp->Free(unPackSizes);
allocTemp->Free(digestsDefined);
allocTemp->Free(digests);
#ifndef _LZMA_IN_CB
allocTemp->Free(inBuffer);
#endif
return res;
}
SZ_RESULT SzArchiveOpen2(
ISzInStream *inStream,
CArchiveDatabaseEx *db,
ISzAlloc *allocMain,
ISzAlloc *allocTemp)
{
Byte signature[k7zSignatureSize];
Byte version;
UInt32 crcFromArchive;
UInt64 nextHeaderOffset;
UInt64 nextHeaderSize;
UInt32 nextHeaderCRC;
UInt32 crc;
CFileSize pos = 0;
CSzByteBuffer buffer;
CSzData sd;
SZ_RESULT res;
RINOK(SafeReadDirect(inStream, signature, k7zSignatureSize));
if (!TestSignatureCandidate(signature))
return SZE_ARCHIVE_ERROR;
/*
db.Clear();
db.ArchiveInfo.StartPosition = _arhiveBeginStreamPosition;
*/
RINOK(SafeReadDirectByte(inStream, &version));
if (version != k7zMajorVersion)
return SZE_ARCHIVE_ERROR;
RINOK(SafeReadDirectByte(inStream, &version));
RINOK(SafeReadDirectUInt32(inStream, &crcFromArchive));
CrcInit(&crc);
RINOK(SafeReadDirectUInt64(inStream, &nextHeaderOffset));
CrcUpdateUInt64(&crc, nextHeaderOffset);
RINOK(SafeReadDirectUInt64(inStream, &nextHeaderSize));
CrcUpdateUInt64(&crc, nextHeaderSize);
RINOK(SafeReadDirectUInt32(inStream, &nextHeaderCRC));
CrcUpdateUInt32(&crc, nextHeaderCRC);
pos = k7zStartHeaderSize;
db->ArchiveInfo.StartPositionAfterHeader = pos;
if (CrcGetDigest(&crc) != crcFromArchive)
return SZE_ARCHIVE_ERROR;
if (nextHeaderSize == 0)
return SZ_OK;
RINOK(inStream->Seek(inStream, (CFileSize)(pos + nextHeaderOffset)));
if (!SzByteBufferCreate(&buffer, (size_t)nextHeaderSize, allocTemp->Alloc))
return SZE_OUTOFMEMORY;
res = SafeReadDirect(inStream, buffer.Items, (size_t)nextHeaderSize);
if (res == SZ_OK)
{
if (CrcVerifyDigest(nextHeaderCRC, buffer.Items, (UInt32)nextHeaderSize))
{
while (1)
{
UInt64 type;
sd.Data = buffer.Items;
sd.Size = buffer.Capacity;
res = SzReadID(&sd, &type);
if (res != SZ_OK)
break;
if (type == k7zIdHeader)
{
res = SzReadHeader(&sd, db, allocMain, allocTemp);
break;
}
if (type != k7zIdEncodedHeader)
{
res = SZE_ARCHIVE_ERROR;
break;
}
{
CSzByteBuffer outBuffer;
res = SzReadAndDecodePackedStreams(inStream, &sd, &outBuffer,
db->ArchiveInfo.StartPositionAfterHeader,
allocTemp);
if (res != SZ_OK)
{
SzByteBufferFree(&outBuffer, allocTemp->Free);
break;
}
SzByteBufferFree(&buffer, allocTemp->Free);
buffer.Items = outBuffer.Items;
buffer.Capacity = outBuffer.Capacity;
}
}
}
}
SzByteBufferFree(&buffer, allocTemp->Free);
return res;
}
SZ_RESULT SzArchiveOpen(
ISzInStream *inStream,
CArchiveDatabaseEx *db,
ISzAlloc *allocMain,
ISzAlloc *allocTemp)
{
SZ_RESULT res = SzArchiveOpen2(inStream, db, allocMain, allocTemp);
if (res != SZ_OK)
SzArDbExFree(db, allocMain->Free);
return res;
}
Reference in New Issue View Git Blame Copy Permalink