Simone/nsis-plugin-ns7zip
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 8 Wiki Activity
Files
2b01cf9e753fb1c984a917799f87d6b761ffdc18
nsis-plugin-ns7zip/versions/26.00/CPP/7zip/Archive/DmgHandler.cpp
T
Simone d074cc7c07 chore: initial commit (extracted from Launchers monorepo) 
Plugin: ns7zip v2.0.0
Architectures: x86-ansi, x86-unicode, amd64-unicode
License: LGPL-2.1-or-later
2026-04-29 14:07:51 +02:00

2337 lines
59 KiB
C++
Raw Blame History

// DmgHandler.cpp
#include "StdAfx.h"
#include "../../../C/Alloc.h"
#include "../../../C/CpuArch.h"
#include "../../Common/AutoPtr.h"
#include "../../Common/ComTry.h"
#include "../../Common/IntToString.h"
#include "../../Common/MyBuffer2.h"
#include "../../Common/MyXml.h"
#include "../../Common/UTFConvert.h"
#include "../../Windows/PropVariant.h"
#include "../Common/LimitedStreams.h"
#include "../Common/ProgressUtils.h"
#include "../Common/RegisterArc.h"
#include "../Common/StreamObjects.h"
#include "../Common/StreamUtils.h"
#include "../Compress/BZip2Decoder.h"
#include "../Compress/CopyCoder.h"
#include "../Compress/LzfseDecoder.h"
#include "../Compress/XzDecoder.h"
#include "../Compress/ZlibDecoder.h"
#include "Common/OutStreamWithCRC.h"
// #define DMG_SHOW_RAW
// #define SHOW_DEBUG_INFO
/* for debug only: we can use block cache also for METHOD_COPY blocks.
It can reduce the number of Stream->Read() requests.
But it can increase memory usage.
Note: METHOD_COPY blocks are not fused usually.
But if METHOD_COPY blocks is fused in some dmg example,
block size can exceed k_Chunk_Size_MAX.
So we don't use cache for METHOD_COPY block, if (block_size > k_Chunk_Size_MAX)
*/
// for debug only:
// #define Z7_DMG_USE_CACHE_FOR_COPY_BLOCKS
#ifdef SHOW_DEBUG_INFO
#include <stdio.h>
#define PRF(x) x
#else
#define PRF(x)
#endif
#define Get16(p) GetBe16(p)
#define Get32(p) GetBe32(p)
#define Get64(p) GetBe64(p)
#define Get32a(p) GetBe32a(p)
#define Get64a(p) GetBe64a(p)
Byte *Base64ToBin(Byte *dest, const char *src);
namespace NArchive {
namespace NDmg {
// allocation limits for compressed blocks for GetStream() interface:
static const unsigned k_NumChunks_MAX = 128;
static const size_t k_Chunk_Size_MAX = (size_t)1 << 28;
// 256 MB cache for 32-bit:
// 4 GB cache for 64-bit:
static const size_t k_Chunks_TotalSize_MAX = (size_t)1 << (sizeof(size_t) + 24);
// 2 GB limit for 32-bit:
// 4 GB limit for 64-bit:
// that limit can be increased for 64-bit mode, if there are such dmg files
static const size_t k_XmlSize_MAX =
((size_t)1 << (sizeof(size_t) / 4 + 30)) - 256;
static const UInt32 METHOD_ZERO_0 = 0; // sparse
static const UInt32 METHOD_COPY = 1;
static const UInt32 METHOD_ZERO_2 = 2; // sparse : without file CRC calculation
static const UInt32 METHOD_ADC = 0x80000004;
static const UInt32 METHOD_ZLIB = 0x80000005;
static const UInt32 METHOD_BZIP2 = 0x80000006;
static const UInt32 METHOD_LZFSE = 0x80000007;
static const UInt32 METHOD_XZ = 0x80000008;
static const UInt32 METHOD_COMMENT = 0x7FFFFFFE; // is used to comment "+beg" and "+end" in extra field.
static const UInt32 METHOD_END = 0xFFFFFFFF;
struct CBlock
{
UInt32 Type;
UInt64 UnpPos;
// UInt64 UnpSize;
UInt64 PackPos;
UInt64 PackSize;
bool NeedCrc() const { return Type != METHOD_ZERO_2; }
bool IsZeroMethod() const
{
return (Type & ~(UInt32)METHOD_ZERO_2) == 0;
// return Type == METHOD_ZERO_0 || Type == METHOD_ZERO_2;
}
bool IsClusteredMethod() const
{
// most of dmg files have non-fused COPY_METHOD blocks.
// so we don't exclude COPY_METHOD blocks when we try to detect size of cluster.
return !IsZeroMethod(); // include COPY_METHOD blocks.
// Type > METHOD_ZERO_2; // for debug: exclude COPY_METHOD blocks.
}
bool NeedAllocateBuffer() const
{
return
#ifdef Z7_DMG_USE_CACHE_FOR_COPY_BLOCKS
!IsZeroMethod();
#else
Type > METHOD_ZERO_2;
// !IsZeroMethod() && Type != METHOD_COPY;
#endif
}
// we don't store non-data blocks now
// bool ThereAreDataInBlock() const { return Type != METHOD_COMMENT && Type != METHOD_END; }
};
static const UInt32 kCheckSumType_CRC = 2;
static const unsigned kChecksumSize_Max = 0x80;
struct CChecksum
{
UInt32 Type;
UInt32 NumBits;
Byte Data[kChecksumSize_Max];
bool IsCrc32() const { return Type == kCheckSumType_CRC && NumBits == 32; }
UInt32 GetCrc32() const { return Get32(Data); }
void Parse(const Byte *p);
void PrintType(AString &s) const;
void Print(AString &s) const;
void Print_with_Name(AString &s) const;
void AddToComment(AString &s, const char *name) const;
};
void CChecksum::Parse(const Byte *p)
{
Type = Get32(p);
NumBits = Get32(p + 4);
memcpy(Data, p + 8, kChecksumSize_Max);
}
void CChecksum::PrintType(AString &s) const
{
if (NumBits == 0)
return;
if (IsCrc32())
s += "CRC";
else
{
s += "Checksum";
s.Add_UInt32(Type);
s.Add_Minus();
s.Add_UInt32(NumBits);
}
}
void CChecksum::Print(AString &s) const
{
if (NumBits == 0)
return;
char temp[kChecksumSize_Max * 2 + 2];
/*
if (IsCrc32())
ConvertUInt32ToHex8Digits(GetCrc32(), temp);
else
*/
{
UInt32 numBits = kChecksumSize_Max * 8;
if (numBits > NumBits)
numBits = NumBits;
const unsigned numBytes = (numBits + 7) >> 3;
if (numBytes <= 8)
ConvertDataToHex_Upper(temp, Data, numBytes);
else
ConvertDataToHex_Lower(temp, Data, numBytes);
}
s += temp;
}
void CChecksum::Print_with_Name(AString &s) const
{
if (NumBits == 0)
return;
PrintType(s);
s += ": ";
Print(s);
}
static void AddToComment_Prop(AString &s, const char *name, const char *val)
{
s += name;
s += ": ";
s += val;
s.Add_LF();
}
void CChecksum::AddToComment(AString &s, const char *name) const
{
AString s2;
Print_with_Name(s2);
if (!s2.IsEmpty())
AddToComment_Prop(s, name, s2);
}
struct CFile
{
UInt64 Size;
CRecordVector<CBlock> Blocks;
UInt64 PackSize;
UInt64 StartPackPos;
UInt64 BlockSize_MAX;
UInt64 StartUnpackSector; // unpack sector position of this file from all files
UInt64 NumUnpackSectors;
Int32 Descriptor;
bool IsCorrect;
bool FullFileChecksum;
AString Name;
// AString Id;
CChecksum Checksum;
UInt64 GetUnpackSize_of_Block(unsigned blockIndex) const
{
return (blockIndex == Blocks.Size() - 1 ?
Size : Blocks[blockIndex + 1].UnpPos) - Blocks[blockIndex].UnpPos;
}
CFile():
Size(0),
PackSize(0),
StartPackPos(0),
BlockSize_MAX(0),
StartUnpackSector(0),
NumUnpackSectors(0),
Descriptor(0),
IsCorrect(false),
FullFileChecksum(false)
{
Checksum.Type = 0;
Checksum.NumBits = 0;
}
HRESULT Parse(const Byte *p, UInt32 size);
};
#ifdef DMG_SHOW_RAW
struct CExtraFile
{
CByteBuffer Data;
AString Name;
};
#endif
static void AddToComment_UInt64(AString &s, UInt64 v, const char *name)
{
s += name;
s += ": ";
s.Add_UInt64(v);
s.Add_LF();
}
struct CForkPair
{
UInt64 Offset;
UInt64 Len;
// (p) is aligned for 8-bytes
void Parse(const Byte *p)
{
Offset = Get64a(p);
Len = Get64a(p + 8);
}
bool GetEndPos(UInt64 &endPos)
{
endPos = Offset + Len;
return endPos >= Offset;
}
bool UpdateTop(UInt64 limit, UInt64 &top)
{
if (Offset > limit || Len > limit - Offset)
return false;
const UInt64 top2 = Offset + Len;
if (top <= top2)
top = top2;
return true;
}
void Print(AString &s, const char *name) const;
};
void CForkPair::Print(AString &s, const char *name) const
{
if (Offset != 0 || Len != 0)
{
s += name; s.Add_Minus(); AddToComment_UInt64(s, Offset, "offset");
s += name; s.Add_Minus(); AddToComment_UInt64(s, Len, "length");
}
}
Z7_CLASS_IMP_CHandler_IInArchive_1(
IInArchiveGetStream
)
bool _masterCrcError;
bool _headersError;
bool _dataForkError;
bool _rsrcMode_wasUsed;
CMyComPtr<IInStream> _inStream;
CObjectVector<CFile> _files;
// UInt32 _dataStartOffset;
UInt64 _startPos;
UInt64 _phySize;
AString _name;
CForkPair _dataForkPair;
CForkPair rsrcPair, xmlPair, blobPair;
// UInt64 _runningDataForkOffset;
// UInt32 _segmentNumber;
// UInt32 _segmentCount;
UInt64 _numSectors; // total unpacked number of sectors
Byte _segmentGUID[16];
CChecksum _dataForkChecksum;
CChecksum _masterChecksum;
#ifdef DMG_SHOW_RAW
CObjectVector<CExtraFile> _extras;
#endif
HRESULT ReadData(IInStream *stream, const CForkPair &pair, CByteBuffer &buf);
bool ParseBlob(const CByteBuffer &data);
HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCallback);
HRESULT Extract(IInStream *stream);
};
struct CMethods
{
CRecordVector<UInt32> Types;
void Update(const CFile &file);
void AddToString(AString &s) const;
};
void CMethods::Update(const CFile &file)
{
FOR_VECTOR (i, file.Blocks)
{
if (Types.Size() >= (1 << 8))
break;
Types.AddToUniqueSorted(file.Blocks[i].Type);
}
}
void CMethods::AddToString(AString &res) const
{
FOR_VECTOR (i, Types)
{
const UInt32 type = Types[i];
/*
if (type == METHOD_COMMENT || type == METHOD_END)
continue;
*/
char buf[16];
const char *s;
switch (type)
{
// case METHOD_COMMENT: s = "Comment"; break;
case METHOD_ZERO_0: s = "Zero0"; break;
case METHOD_ZERO_2: s = "Zero2"; break;
case METHOD_COPY: s = "Copy"; break;
case METHOD_ADC: s = "ADC"; break;
case METHOD_ZLIB: s = "ZLIB"; break;
case METHOD_BZIP2: s = "BZip2"; break;
case METHOD_LZFSE: s = "LZFSE"; break;
case METHOD_XZ: s = "XZ"; break;
default: ConvertUInt32ToHex(type, buf); s = buf;
}
res.Add_OptSpaced(s);
}
}
struct CAppleName
{
bool IsFs;
const char *Ext;
const char *AppleName;
};
static const CAppleName k_Names[] =
{
{ true, "hfs", "Apple_HFS" },
{ true, "hfsx", "Apple_HFSX" },
{ true, "ufs", "Apple_UFS" },
{ true, "apfs", "Apple_APFS" },
{ true, "iso", "Apple_ISO" },
// efi_sys partition is FAT32, but it's not main file. So we use (IsFs = false)
{ false, "efi_sys", "C12A7328-F81F-11D2-BA4B-00A0C93EC93B" },
{ false, "free", "Apple_Free" },
{ false, "ddm", "DDM" },
{ false, NULL, "Apple_partition_map" },
{ false, NULL, " GPT " },
/* " GPT " is substring of full name entry in dmg that contains
some small metadata GPT entry. It's not real FS entry:
"Primary GPT Header",
"Primary GPT Table"
"Backup GPT Header",
"Backup GPT Table",
*/
{ false, NULL, "MBR" },
{ false, NULL, "Driver" },
{ false, NULL, "Patches" }
};
static const unsigned kNumAppleNames = Z7_ARRAY_SIZE(k_Names);
const char *Find_Apple_FS_Ext(const AString &name);
const char *Find_Apple_FS_Ext(const AString &name)
{
for (unsigned i = 0; i < kNumAppleNames; i++)
{
const CAppleName &a = k_Names[i];
if (a.Ext)
if (name.IsEqualTo(a.AppleName))
return a.Ext;
}
return NULL;
}
bool Is_Apple_FS_Or_Unknown(const AString &name);
bool Is_Apple_FS_Or_Unknown(const AString &name)
{
for (unsigned i = 0; i < kNumAppleNames; i++)
{
const CAppleName &a = k_Names[i];
// if (name.Find(a.AppleName) >= 0)
if (strstr(name, a.AppleName))
return a.IsFs;
}
return true;
}
// define it for debug only:
// #define Z7_DMG_SINGLE_FILE_MODE
static const Byte kProps[] =
{
kpidPath,
kpidSize,
kpidPackSize,
kpidComment,
kpidMethod,
kpidNumBlocks,
kpidClusterSize,
kpidChecksum,
kpidCRC,
kpidId
// kpidOffset
#ifdef Z7_DMG_SINGLE_FILE_MODE
, kpidPosition
#endif
};
IMP_IInArchive_Props
static const Byte kArcProps[] =
{
kpidMethod,
kpidNumBlocks,
kpidClusterSize,
kpidComment
};
Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
{
COM_TRY_BEGIN
NWindows::NCOM::CPropVariant prop;
switch (propID)
{
case kpidMethod:
{
CMethods m;
CRecordVector<UInt32> ChecksumTypes;
{
FOR_VECTOR (i, _files)
{
const CFile &file = _files[i];
m.Update(file);
if (ChecksumTypes.Size() < (1 << 8))
ChecksumTypes.AddToUniqueSorted(file.Checksum.Type);
}
}
AString s;
m.AddToString(s);
FOR_VECTOR (i, ChecksumTypes)
{
const UInt32 type = ChecksumTypes[i];
switch (type)
{
case kCheckSumType_CRC:
s.Add_OptSpaced("CRC");
break;
default:
s.Add_OptSpaced("Checksum");
s.Add_UInt32(type);
}
}
if (!s.IsEmpty())
prop = s;
break;
}
case kpidNumBlocks:
{
UInt64 numBlocks = 0;
FOR_VECTOR (i, _files)
numBlocks += _files[i].Blocks.Size();
prop = numBlocks;
break;
}
case kpidClusterSize:
{
UInt64 blockSize_MAX = 0;
FOR_VECTOR (i, _files)
{
const UInt64 a = _files[i].BlockSize_MAX;
if (blockSize_MAX < a)
blockSize_MAX = a;
}
prop = blockSize_MAX;
break;
}
case kpidMainSubfile:
{
int mainIndex = -1;
FOR_VECTOR (i, _files)
{
if (Is_Apple_FS_Or_Unknown(_files[i].Name))
{
if (mainIndex != -1)
{
mainIndex = -1;
break;
}
mainIndex = (int)i;
}
}
if (mainIndex != -1)
prop = (UInt32)(Int32)mainIndex;
break;
}
case kpidWarning:
if (_masterCrcError)
prop = "Master CRC error";
break;
case kpidWarningFlags:
{
UInt32 v = 0;
if (_headersError) v |= kpv_ErrorFlags_HeadersError;
if (_dataForkError) v |= kpv_ErrorFlags_CrcError;
if (v != 0)
prop = v;
break;
}
case kpidOffset: prop = _startPos; break;
case kpidPhySize: prop = _phySize; break;
case kpidComment:
{
AString s;
if (!_name.IsEmpty())
AddToComment_Prop(s, "Name", _name);
AddToComment_UInt64(s, _numSectors << 9, "unpack-size");
{
char temp[sizeof(_segmentGUID) * 2 + 2];
ConvertDataToHex_Lower(temp, _segmentGUID, sizeof(_segmentGUID));
AddToComment_Prop(s, "ID", temp);
}
_masterChecksum.AddToComment(s, "master-checksum");
_dataForkChecksum.AddToComment(s, "pack-checksum");
{
/*
if (_dataStartOffset != 0)
AddToComment_UInt64(s, _dataStartOffset, "payload-start-offset");
*/
// if (_dataForkPair.Offset != 0)
_dataForkPair.Print(s, "pack");
rsrcPair.Print(s, "rsrc");
xmlPair.Print(s, "xml");
blobPair.Print(s, "blob");
}
if (_rsrcMode_wasUsed)
s += "RSRC_MODE\n";
if (!s.IsEmpty())
prop = s;
}
break;
case kpidName:
if (!_name.IsEmpty())
prop = _name + ".dmg";
break;
}
prop.Detach(value);
return S_OK;
COM_TRY_END
}
IMP_IInArchive_ArcProps
static const UInt64 kSectorNumber_LIMIT = (UInt64)1 << (63 - 9);
HRESULT CFile::Parse(const Byte *p, UInt32 size)
{
// CFile was initialized to default values: 0 in size variables and (IsCorrect == false)
const unsigned kHeadSize = 0xCC;
if (size < kHeadSize)
return S_FALSE;
if (Get32(p) != 0x6D697368) // "mish" signature
return S_FALSE;
if (Get32(p + 4) != 1) // version
return S_FALSE;
StartUnpackSector = Get64(p + 8);
NumUnpackSectors = Get64(p + 0x10);
StartPackPos = Get64(p + 0x18);
#ifdef SHOW_DEBUG_INFO
/* the number of sectors that must be allocated.
== 0x208 for 256KB clusters
== 0x808 for 1MB clusters
== 0x1001 for 1MB clusters in some example
*/
const UInt32 decompressedBufRequested = Get32(p + 0x20);
#endif
// Descriptor is file index. usually started from -1
// in one dmg it was started from 0
Descriptor = (Int32)Get32(p + 0x24);
// char Reserved1[24];
Checksum.Parse(p + 0x40);
PRF(printf("\n" " Checksum Type = %2u"
"\n StartUnpackSector = %8x"
"\n NumUnpackSectors = %8x"
"\n StartPos = %8x"
"\n decompressedBufRequested=%8x"
"\n blocksDescriptor=%8x"
, (unsigned)Checksum.Type
, (unsigned)StartUnpackSector
, (unsigned)NumUnpackSectors
, (unsigned)StartPackPos
, (unsigned)decompressedBufRequested
, (unsigned)Descriptor
);)
const UInt32 numBlocks = Get32(p + 0xC8);
const unsigned kRecordSize = 40;
if ((UInt64)numBlocks * kRecordSize + kHeadSize != size)
return S_FALSE;
Blocks.ClearAndReserve(numBlocks);
FullFileChecksum = true;
/* IsCorrect = false; by default
So we return S_OK, if we can ignore some error in headers.
*/
p += kHeadSize;
UInt32 i;
for (i = 0; i < numBlocks; i++, p += kRecordSize)
{
CBlock b;
b.Type = Get32(p);
{
const UInt64 a = Get64(p + 0x08);
if (a >= kSectorNumber_LIMIT)
return S_OK;
b.UnpPos = a << 9;
}
UInt64 unpSize;
{
const UInt64 a = Get64(p + 0x10);
if (a >= kSectorNumber_LIMIT)
return S_OK;
unpSize = a << 9;
}
const UInt64 newSize = b.UnpPos + unpSize;
if (newSize >= ((UInt64)1 << 63))
return S_OK;
b.PackPos = Get64(p + 0x18);
b.PackSize = Get64(p + 0x20);
// b.PackPos can be 0 for some types. So we don't check it
if (b.UnpPos != Size)
return S_OK;
PRF(printf("\nType=%8x comment=%8x uPos=%8x uSize=%7x pPos=%8x pSize=%7x",
(unsigned)b.Type, Get32(p + 4), (unsigned)b.UnpPos, (unsigned)unpSize, (unsigned)b.PackPos, (unsigned)b.PackSize));
if (b.Type == METHOD_COMMENT)
{
// some files contain 2 comment block records:
// record[0] : Type=METHOD_COMMENT, comment_field = "+beg"
// record[num-2] : Type=METHOD_COMMENT, comment_field = "+end"
// we skip these useless records.
continue;
}
if (b.Type == METHOD_END)
break;
// we add only blocks that have non empty unpacked data:
if (unpSize != 0)
{
const UInt64 k_max_pos = (UInt64)1 << 63;
if (b.PackPos >= k_max_pos ||
b.PackSize >= k_max_pos - b.PackPos)
return S_OK;
/* we don't count non-ZERO blocks here, because
ZERO blocks in dmg files are not limited by some cluster size.
note: COPY blocks also sometimes are fused to larger blocks.
*/
if (b.IsClusteredMethod())
if (BlockSize_MAX < unpSize)
BlockSize_MAX = unpSize;
PackSize += b.PackSize;
if (!b.NeedCrc())
FullFileChecksum = false;
Blocks.AddInReserved(b);
Size = newSize;
}
}
PRF(printf("\n");)
if (i != numBlocks - 1)
{
// return S_FALSE;
return S_OK;
}
if ((Size >> 9) == NumUnpackSectors)
IsCorrect = true;
return S_OK;
}
static const CXmlItem *FindKeyPair(const CXmlItem &item, const char *key, const char *nextTag)
{
for (unsigned i = 0; i + 1 < item.SubItems.Size(); i++)
{
const CXmlItem &si = item.SubItems[i];
if (si.IsTagged("key") && si.GetSubString().IsEqualTo(key))
{
const CXmlItem *si_1 = &item.SubItems[i + 1];
if (si_1->IsTagged(nextTag))
return si_1;
}
}
return NULL;
}
static const AString *GetStringFromKeyPair(const CXmlItem &item, const char *key, const char *nextTag)
{
const CXmlItem *si_1 = FindKeyPair(item, key, nextTag);
if (si_1)
return si_1->GetSubStringPtr();
return NULL;
}
static const Byte k_Signature[] = { 'k','o','l','y', 0, 0, 0, 4, 0, 0, 2, 0 };
static inline bool IsKoly(const Byte *p)
{
return memcmp(p, k_Signature, Z7_ARRAY_SIZE(k_Signature)) == 0;
/*
if (Get32(p) != 0x6B6F6C79) // "koly" signature
return false;
if (Get32(p + 4) != 4) // version
return false;
if (Get32(p + 8) != HEADER_SIZE)
return false;
return true;
*/
}
HRESULT CHandler::ReadData(IInStream *stream, const CForkPair &pair, CByteBuffer &buf)
{
size_t size = (size_t)pair.Len;
if (size != pair.Len)
return E_OUTOFMEMORY;
buf.Alloc(size);
RINOK(InStream_SeekSet(stream, _startPos + pair.Offset))
return ReadStream_FALSE(stream, buf, size);
}
bool CHandler::ParseBlob(const CByteBuffer &data)
{
const unsigned kHeaderSize = 3 * 4;
if (data.Size() < kHeaderSize)
return false;
const Byte * const p = (const Byte *)data;
if (Get32a(p) != 0xfade0cc0) // CSMAGIC_EMBEDDED_SIGNATURE
return true;
const UInt32 size = Get32a(p + 4);
if (size != data.Size())
return false;
const UInt32 num = Get32a(p + 8);
if (num > (size - kHeaderSize) / 8)
return false;
const UInt32 limit = num * 8 + kHeaderSize;
for (size_t i = kHeaderSize; i < limit; i += 8)
{
// type == 0 == CSSLOT_CODEDIRECTORY for CSMAGIC_CODEDIRECTORY item
// UInt32 type = Get32(p + i);
const UInt32 offset = Get32a(p + i + 4);
if (offset < limit || offset > size - 8)
return false;
// offset is not aligned for 4 here !!!
const Byte * const p2 = p + offset;
const UInt32 magic = Get32(p2);
const UInt32 len = Get32(p2 + 4);
if (size - offset < len || len < 8)
return false;
#ifdef DMG_SHOW_RAW
CExtraFile &extra = _extras.AddNew();
extra.Name = "_blob_";
extra.Data.CopyFrom(p2, len);
#endif
if (magic == 0xfade0c02) // CSMAGIC_CODEDIRECTORY
{
#ifdef DMG_SHOW_RAW
extra.Name += "codedir";
#endif
if (len < 11 * 4)
return false;
const UInt32 idOffset = Get32(p2 + 5 * 4);
if (idOffset >= len)
return false;
UInt32 len2 = len - idOffset;
const UInt32 kNameLenMax = 1 << 8;
if (len2 > kNameLenMax)
len2 = kNameLenMax;
_name.SetFrom_CalcLen((const char *)(p2 + idOffset), len2);
/*
// #define kSecCodeSignatureHashSHA1 1
// #define kSecCodeSignatureHashSHA256 2
const UInt32 hashOffset = Get32(p2 + 4 * 4);
const UInt32 nSpecialSlots = Get32(p2 + 6 * 4);
const UInt32 nCodeSlots = Get32(p2 + 7 * 4);
const unsigned hashSize = p2[36];
const unsigned hashType = p2[37];
// const unsigned unused = p2[38];
const unsigned pageSize = p2[39];
*/
}
#ifdef DMG_SHOW_RAW
else if (magic == 0xfade0c01) extra.Name += "requirements";
else if (magic == 0xfade0b01) extra.Name += "signed";
else
{
char temp[16];
ConvertUInt32ToHex8Digits(magic, temp);
extra.Name += temp;
}
#endif
}
return true;
}
HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCallback)
{
/*
- usual dmg contains Koly Header at the end:
- rare case old dmg contains Koly Header at the begin.
*/
// _dataStartOffset = 0;
UInt64 fileSize;
RINOK(InStream_GetPos_GetSize(stream, _startPos, fileSize))
const unsigned HEADER_SIZE = 0x200;
UInt64 buf[HEADER_SIZE / sizeof(UInt64)];
RINOK(ReadStream_FALSE(stream, buf, HEADER_SIZE))
UInt64 headerPos;
bool front_Koly_Mode = false;
/*
_dataForkChecksum.Offset == 0 for koly-at-the-end
_dataForkChecksum.Offset == 512 for koly-at-the-start
so we can use (_dataForkChecksum.Offset) to detect "koly-at-the-start" mode
*/
if (IsKoly((const Byte *)(const void *)buf))
{
// it can be normal koly-at-the-end or koly-at-the-start
headerPos = _startPos;
/*
if (_startPos <= (1 << 8))
{
// we want to support front_Koly_Mode, even if there is
// some data before dmg file, like 128 bytes MacBin header
_dataStartOffset = HEADER_SIZE;
front_Koly_Mode = true;
}
*/
}
else
{
/* we try to open in backward mode only for first attempt
when (_startPos == 0) */
if (_startPos != 0)
return S_FALSE;
headerPos = fileSize;
if (headerPos < HEADER_SIZE)
return S_FALSE;
headerPos -= HEADER_SIZE;
RINOK(InStream_SeekSet(stream, headerPos))
RINOK(ReadStream_FALSE(stream, buf, HEADER_SIZE))
if (!IsKoly((const Byte *)(const void *)buf))
return S_FALSE;
}
// UInt32 flags = Get32a((const Byte *)(const void *)buf + 12);
// _runningDataForkOffset = Get64a((const Byte *)(const void *)buf + 0x10);
_dataForkPair.Parse((const Byte *)(const void *)buf + 0x18);
rsrcPair.Parse((const Byte *)(const void *)buf + 0x28);
// _segmentNumber = Get32a(buf + 0x38); // 0 or 1
// _segmentCount = Get32a(buf + 0x3C); // 0 (if not set) or 1
memcpy(_segmentGUID, (const Byte *)(const void *)buf + 0x40, 16);
_dataForkChecksum.Parse((const Byte *)(const void *)buf + 0x50);
xmlPair.Parse((const Byte *)(const void *)buf + 0xD8);
// Byte resereved[]
blobPair.Parse((const Byte *)(const void *)buf + 0x128);
_masterChecksum.Parse((const Byte *)(const void *)buf + 0x160);
// UInt32 imageVariant = Get32a((const Byte *)(const void *)buf + 0x1E8); imageVariant = imageVariant;
_numSectors = Get64((const Byte *)(const void *)buf + 0x1EC); // it's not aligned for 8-bytes
// Byte resereved[12];
if (_dataForkPair.Offset == HEADER_SIZE
&& headerPos + HEADER_SIZE < fileSize)
front_Koly_Mode = true;
const UInt64 limit = front_Koly_Mode ? fileSize : headerPos;
UInt64 top = 0;
if (!_dataForkPair.UpdateTop(limit, top)) return S_FALSE;
if (!xmlPair.UpdateTop(limit, top)) return S_FALSE;
if (!rsrcPair.UpdateTop(limit, top)) return S_FALSE;
/* Some old dmg files contain garbage data in blobPair field.
So we need to ignore such garbage case;
And we still need to detect offset of start of archive for "parser" mode. */
const bool useBlob = blobPair.UpdateTop(limit, top);
if (front_Koly_Mode)
_phySize = top;
else
{
_phySize = headerPos + HEADER_SIZE;
_startPos = 0;
if (top != headerPos)
{
/*
if expected absolute offset is not equal to real header offset,
2 cases are possible:
- additional (unknown) headers
- archive with offset.
So we try to read XML with absolute offset to select from these two ways.
*/
CForkPair xmlPair2 = xmlPair;
const char *sz = "<?xml version";
const unsigned len = (unsigned)strlen(sz);
if (xmlPair2.Len > len)
xmlPair2.Len = len;
CByteBuffer buf2;
if (xmlPair2.Len < len
|| ReadData(stream, xmlPair2, buf2) != S_OK
|| memcmp(buf2, sz, len) != 0)
{
// if absolute offset is not OK, probably it's archive with offset
_startPos = headerPos - top;
_phySize = top + HEADER_SIZE;
}
}
}
if (useBlob
&& blobPair.Len != 0
&& blobPair.Len <= (1u << 24)) // we don't want parsing of big blobs
{
#ifdef DMG_SHOW_RAW
CExtraFile &extra = _extras.AddNew();
extra.Name = "_blob.bin";
CByteBuffer &blobBuf = extra.Data;
#else
CByteBuffer blobBuf;
#endif
RINOK(ReadData(stream, blobPair, blobBuf))
if (!ParseBlob(blobBuf))
_headersError = true;
}
UInt64 openTotal = 0;
UInt64 openCur = 0;
if (_dataForkChecksum.IsCrc32())
openTotal = _dataForkPair.Len;
const UInt32 RSRC_HEAD_SIZE = 0x100;
/* we have 2 ways to read files and blocks metadata:
via Xml or via Rsrc.
But some images have no Rsrc fork.
Is it possible that there is no Xml?
Rsrc method will not work for big files. */
// v23.02: we use xml mode by default
// if (rsrcPair.Len >= RSRC_HEAD_SIZE && rsrcPair.Len <= ((UInt32)1 << 24)) // for debug
if (xmlPair.Len == 0)
{
// We don't know the size of the field "offset" in Rsrc.
// We suppose that it uses 24 bits. So we use Rsrc, only if the rsrcPair.Len <= (1 << 24).
const bool canUseRsrc = (rsrcPair.Len >= RSRC_HEAD_SIZE && rsrcPair.Len <= ((UInt32)1 << 24));
if (!canUseRsrc)
return S_FALSE;
_rsrcMode_wasUsed = true;
#ifdef DMG_SHOW_RAW
CExtraFile &extra = _extras.AddNew();
extra.Name = "rsrc.bin";
CByteBuffer &rsrcBuf = extra.Data;
#else
CByteBuffer rsrcBuf;
#endif
RINOK(ReadData(stream, rsrcPair, rsrcBuf))
const Byte *p = rsrcBuf;
const UInt32 headSize = Get32a(p + 0);
const UInt32 footerOffset = Get32a(p + 4);
const UInt32 mainDataSize = Get32a(p + 8);
const UInt32 footerSize = Get32a(p + 12);
if (headSize != RSRC_HEAD_SIZE
|| footerOffset >= rsrcPair.Len
|| mainDataSize >= rsrcPair.Len
|| footerOffset < mainDataSize
|| footerOffset != headSize + mainDataSize)
return S_FALSE;
{
const UInt32 footerEnd = footerOffset + footerSize;
if (footerEnd != rsrcPair.Len)
{
// there is rare case dmg example, where there are 4 additional bytes
const UInt64 rem = rsrcPair.Len - footerOffset;
if (rem < footerSize
|| rem - footerSize != 4
|| Get32(p + footerEnd) != 0)
return S_FALSE;
}
}
if (footerSize < 0x1e)
return S_FALSE;
if (memcmp(p, p + footerOffset, 16) != 0)
return S_FALSE;
p += footerOffset;
if ((UInt32)Get16(p + 0x18) != 0x1c)
return S_FALSE;
const UInt32 namesOffset = Get16(p + 0x1a);
if (namesOffset > footerSize)
return S_FALSE;
const UInt32 numItems = (UInt32)Get16(p + 0x1c) + 1;
if (numItems * 8 + 0x1e > namesOffset)
return S_FALSE;
for (UInt32 i = 0; i < numItems; i++)
{
const Byte *p2 = p + 0x1e + (size_t)i * 8;
const UInt32 typeId = Get32(p2);
const UInt32 k_typeId_blkx = 0x626c6b78; // blkx
#ifndef DMG_SHOW_RAW
if (typeId != k_typeId_blkx)
continue;
#endif
const UInt32 numFiles = (UInt32)Get16(p2 + 4) + 1;
const UInt32 offs = Get16(p2 + 6);
if (0x1c + offs + 12 * numFiles > namesOffset)
return S_FALSE;
for (UInt32 k = 0; k < numFiles; k++)
{
const Byte *p3 = p + 0x1c + offs + k * 12;
// UInt32 id = Get16(p3);
const UInt32 namePos = Get16(p3 + 2);
// Byte attributes = p3[4]; // = 0x50 for blkx #define (ATTRIBUTE_HDIUTIL)
// we don't know how many bits we can use. So we use 24 bits only
UInt32 blockOffset = Get32(p3 + 4);
blockOffset &= ((UInt32)1 << 24) - 1;
// UInt32 unknown2 = Get32(p3 + 8); // ???
if (blockOffset + 4 >= mainDataSize)
return S_FALSE;
const Byte *pBlock = rsrcBuf + headSize + blockOffset;
const UInt32 blockSize = Get32(pBlock);
if (mainDataSize - (blockOffset + 4) < blockSize)
return S_FALSE;
AString name;
if (namePos != 0xffff)
{
const UInt32 namesBlockSize = footerSize - namesOffset;
if (namePos >= namesBlockSize)
return S_FALSE;
const Byte *namePtr = p + namesOffset + namePos;
const UInt32 nameLen = *namePtr;
if (namesBlockSize - namePos <= nameLen)
return S_FALSE;
for (UInt32 r = 1; r <= nameLen; r++)
{
const Byte c = namePtr[r];
if (c < 0x20 || c >= 0x80)
break;
name += (char)c;
}
}
if (typeId == k_typeId_blkx)
{
CFile &file = _files.AddNew();
file.Name = name;
RINOK(file.Parse(pBlock + 4, blockSize))
if (!file.IsCorrect)
_headersError = true;
}
#ifdef DMG_SHOW_RAW
{
AString name2;
name2.Add_UInt32(i);
name2 += '_';
{
char temp[4 + 1] = { 0 };
memcpy(temp, p2, 4);
name2 += temp;
}
name2.Trim();
name2 += '_';
name2.Add_UInt32(k);
if (!name.IsEmpty())
{
name2 += '_';
name2 += name;
}
CExtraFile &extra2 = _extras.AddNew();
extra2.Name = name2;
extra2.Data.CopyFrom(pBlock + 4, blockSize);
}
#endif
}
}
}
else
{
if (xmlPair.Len > k_XmlSize_MAX)
return S_FALSE;
// if (!canUseXml) return S_FALSE;
const size_t size = (size_t)xmlPair.Len;
// if (size + 1 <= xmlPair.Len) return S_FALSE; // optional check
RINOK(InStream_SeekSet(stream, _startPos + xmlPair.Offset))
CXml xml;
{
openTotal += size;
if (openArchiveCallback)
{
RINOK(openArchiveCallback->SetTotal(NULL, &openTotal))
}
size_t pos = 0;
CAlignedBuffer1 xmlStr(size + 1);
for (;;)
{
const size_t k_OpenStep = 1 << 24;
const size_t cur = MyMin(k_OpenStep, size - pos);
RINOK(ReadStream_FALSE(stream, xmlStr + pos, cur))
pos += cur;
openCur += cur;
if (pos == size)
break;
if (openArchiveCallback)
{
RINOK(openArchiveCallback->SetCompleted(NULL, &openCur))
}
}
xmlStr[size] = 0;
// if (strlen((const char *)(const void *)(const Byte *)xmlStr) != size) return S_FALSE;
if (!xml.Parse((char *)(void *)(Byte *)xmlStr))
return S_FALSE;
#ifdef DMG_SHOW_RAW
CExtraFile &extra = _extras.AddNew();
extra.Name = "a.xml";
extra.Data.CopyFrom(xmlStr, size);
#endif
}
if (!xml.Root.Name.IsEqualTo("plist"))
return S_FALSE;
const CXmlItem *dictItem = xml.Root.FindSubTag_GetPtr("dict");
if (!dictItem)
return S_FALSE;
const CXmlItem *rfDictItem = FindKeyPair(*dictItem, "resource-fork", "dict");
if (!rfDictItem)
return S_FALSE;
const CXmlItem *arrItem = FindKeyPair(*rfDictItem, "blkx", "array");
if (!arrItem)
return S_FALSE;
FOR_VECTOR (i, arrItem->SubItems)
{
const CXmlItem &item = arrItem->SubItems[i];
if (!item.IsTagged("dict"))
continue;
CByteBuffer rawBuf;
unsigned destLen = 0;
{
const AString *dataString = GetStringFromKeyPair(item, "Data", "data");
if (!dataString)
return S_FALSE;
destLen = dataString->Len() / 4 * 3 + 4;
rawBuf.Alloc(destLen);
{
const Byte *endPtr = Base64ToBin(rawBuf, *dataString);
if (!endPtr)
return S_FALSE;
destLen = (unsigned)(endPtr - (const Byte *)rawBuf);
}
#ifdef DMG_SHOW_RAW
CExtraFile &extra = _extras.AddNew();
extra.Name.Add_UInt32(_files.Size());
extra.Data.CopyFrom(rawBuf, destLen);
#endif
}
CFile &file = _files.AddNew();
{
/* xml code removes front space for such string:
<string> (Apple_Free : 3)</string>
maybe we shoud fix xml code and return full string with space.
*/
const AString *name = GetStringFromKeyPair(item, "Name", "string");
if (!name || name->IsEmpty())
name = GetStringFromKeyPair(item, "CFName", "string");
if (name)
file.Name = *name;
}
/*
{
const AString *s = GetStringFromKeyPair(item, "ID", "string");
if (s)
file.Id = *s;
}
*/
RINOK(file.Parse(rawBuf, destLen))
if (!file.IsCorrect)
_headersError = true;
}
}
if (_masterChecksum.IsCrc32())
{
UInt32 crc = CRC_INIT_VAL;
unsigned i;
for (i = 0; i < _files.Size(); i++)
{
const CChecksum &cs = _files[i].Checksum;
if ((cs.NumBits & 0x7) != 0)
break;
const UInt32 len = cs.NumBits >> 3;
if (len > kChecksumSize_Max)
break;
crc = CrcUpdate(crc, cs.Data, (size_t)len);
}
if (i == _files.Size())
_masterCrcError = (CRC_GET_DIGEST(crc) != _masterChecksum.GetCrc32());
}
{
UInt64 sec = 0;
FOR_VECTOR (i, _files)
{
const CFile &file = _files[i];
/*
if (file.Descriptor != (Int32)i - 1)
_headersError = true;
*/
if (file.StartUnpackSector != sec)
_headersError = true;
if (file.NumUnpackSectors >= kSectorNumber_LIMIT)
_headersError = true;
sec += file.NumUnpackSectors;
if (sec >= kSectorNumber_LIMIT)
_headersError = true;
}
if (sec != _numSectors)
_headersError = true;
}
// data checksum calculation can be slow for big dmg file
if (_dataForkChecksum.IsCrc32())
{
UInt64 endPos;
if (!_dataForkPair.GetEndPos(endPos)
|| _dataForkPair.Offset >= ((UInt64)1 << 63))
_headersError = true;
else
{
const UInt64 seekPos = _startPos + _dataForkPair.Offset;
if (seekPos > fileSize
|| endPos > fileSize - _startPos)
{
_headersError = true;
// kpv_ErrorFlags_UnexpectedEnd
}
else
{
const size_t kBufSize = 1 << 15;
CAlignedBuffer1 buf2(kBufSize);
RINOK(InStream_SeekSet(stream, seekPos))
if (openArchiveCallback)
{
RINOK(openArchiveCallback->SetTotal(NULL, &openTotal))
}
UInt32 crc = CRC_INIT_VAL;
UInt64 pos = 0;
for (;;)
{
const UInt64 rem = _dataForkPair.Len - pos;
size_t cur = kBufSize;
if (cur > rem)
cur = (UInt32)rem;
if (cur == 0)
break;
RINOK(ReadStream_FALSE(stream, buf2, cur))
crc = CrcUpdate(crc, buf2, cur);
pos += cur;
openCur += cur;
if ((pos & ((1 << 24) - 1)) == 0 && openArchiveCallback)
{
RINOK(openArchiveCallback->SetCompleted(NULL, &openCur))
}
}
if (_dataForkChecksum.GetCrc32() != CRC_GET_DIGEST(crc))
_dataForkError = true;
}
}
}
return S_OK;
}
Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
const UInt64 * /* maxCheckStartPosition */,
IArchiveOpenCallback *openArchiveCallback))
{
COM_TRY_BEGIN
Close();
RINOK(Open2(stream, openArchiveCallback))
_inStream = stream;
return S_OK;
COM_TRY_END
}
Z7_COM7F_IMF(CHandler::Close())
{
_masterCrcError = false;
_headersError = false;
_dataForkError = false;
_rsrcMode_wasUsed = false;
_phySize = 0;
_startPos = 0;
_name.Empty();
_inStream.Release();
_files.Clear();
#ifdef DMG_SHOW_RAW
_extras.Clear();
#endif
return S_OK;
}
Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
{
*numItems = _files.Size()
#ifdef DMG_SHOW_RAW
+ _extras.Size()
#endif
;
return S_OK;
}
#ifdef DMG_SHOW_RAW
#define RAW_PREFIX "raw" STRING_PATH_SEPARATOR
#endif
Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
{
COM_TRY_BEGIN
NWindows::NCOM::CPropVariant prop;
#ifdef DMG_SHOW_RAW
if (index >= _files.Size())
{
const CExtraFile &extra = _extras[index - _files.Size()];
switch (propID)
{
case kpidPath:
prop = (AString)RAW_PREFIX + extra.Name;
break;
case kpidSize:
case kpidPackSize:
prop = (UInt64)extra.Data.Size();
break;
}
}
else
#endif
{
const CFile &item = _files[index];
switch (propID)
{
case kpidSize: prop = item.Size; break;
case kpidPackSize: prop = item.PackSize; break;
case kpidCRC:
{
if (item.Checksum.IsCrc32() && item.FullFileChecksum)
prop = item.Checksum.GetCrc32();
break;
}
case kpidChecksum:
{
AString s;
item.Checksum.Print(s);
if (!s.IsEmpty())
prop = s;
break;
}
/*
case kpidOffset:
{
prop = item.StartPackPos;
break;
}
*/
case kpidNumBlocks:
prop = (UInt32)item.Blocks.Size();
break;
case kpidClusterSize:
prop = item.BlockSize_MAX;
break;
case kpidMethod:
{
AString s;
if (!item.IsCorrect)
s.Add_OptSpaced("CORRUPTED");
CMethods m;
m.Update(item);
m.AddToString(s);
{
AString s2;
item.Checksum.PrintType(s2);
if (!s2.IsEmpty())
s.Add_OptSpaced(s2);
}
if (!s.IsEmpty())
prop = s;
break;
}
case kpidPath:
{
#ifdef Z7_DMG_SINGLE_FILE_MODE
prop = "a.img";
#else
UString name;
name.Add_UInt32(index);
unsigned num = 10;
unsigned numDigits;
for (numDigits = 1; num < _files.Size(); numDigits++)
num *= 10;
while (name.Len() < numDigits)
name.InsertAtFront(L'0');
AString subName;
int pos1 = item.Name.Find('(');
if (pos1 >= 0)
{
pos1++;
const int pos2 = item.Name.Find(')', pos1);
if (pos2 >= 0)
{
subName.SetFrom(item.Name.Ptr(pos1), pos2 - pos1);
pos1 = subName.Find(':');
if (pos1 >= 0)
subName.DeleteFrom(pos1);
}
}
else
subName = item.Name; // new apfs dmg can be without braces
subName.Trim();
if (!subName.IsEmpty())
{
const char *ext = Find_Apple_FS_Ext(subName);
if (ext)
subName = ext;
UString name2;
ConvertUTF8ToUnicode(subName, name2);
name.Add_Dot();
name += name2;
}
else
{
UString name2;
ConvertUTF8ToUnicode(item.Name, name2);
if (!name2.IsEmpty())
name += "_";
name += name2;
}
prop = name;
#endif
break;
}
case kpidComment:
{
UString name;
ConvertUTF8ToUnicode(item.Name, name);
prop = name;
break;
}
case kpidId:
{
prop.Set_Int32((Int32)item.Descriptor);
/*
if (!item.Id.IsEmpty())
{
UString s;
ConvertUTF8ToUnicode(item.Id, s);
prop = s;
}
*/
break;
}
#ifdef Z7_DMG_SINGLE_FILE_MODE
case kpidPosition:
prop = item.StartUnpackSector << 9;
break;
#endif
}
}
prop.Detach(value);
return S_OK;
COM_TRY_END
}
class CAdcDecoder
{
CLzOutWindow m_OutWindowStream;
CInBuffer m_InStream;
class CCoderReleaser Z7_final
{
CAdcDecoder *m_Coder;
public:
bool NeedFlush;
CCoderReleaser(CAdcDecoder *coder): m_Coder(coder), NeedFlush(true) {}
~CCoderReleaser()
{
if (NeedFlush)
m_Coder->m_OutWindowStream.Flush();
}
};
friend class CCoderReleaser;
public:
HRESULT Code(ISequentialInStream * const inStream,
ISequentialOutStream *outStream,
const UInt64 * const inSize,
const UInt64 * const outSize,
ICompressProgressInfo * const progress);
};
HRESULT CAdcDecoder::Code(ISequentialInStream * const inStream,
ISequentialOutStream *outStream,
const UInt64 * const inSize,
const UInt64 * const outSizePtr,
ICompressProgressInfo * const progress)
{
try {
if (!m_OutWindowStream.Create(1 << 18)) // at least (1 << 16) is required here
return E_OUTOFMEMORY;
if (!m_InStream.Create(1 << 18))
return E_OUTOFMEMORY;
m_OutWindowStream.SetStream(outStream);
m_OutWindowStream.Init(false);
m_InStream.SetStream(inStream);
m_InStream.Init();
CCoderReleaser coderReleaser(this);
const UInt32 kStep = 1 << 22;
UInt64 nextLimit = kStep;
const UInt64 outSize = *outSizePtr;
UInt64 pos = 0;
/* match sequences and literal sequences do not cross 64KB range
in some dmg archive examples. But is it so for any Adc stream? */
while (pos < outSize)
{
if (pos >= nextLimit && progress)
{
nextLimit += kStep;
const UInt64 packSize = m_InStream.GetProcessedSize();
RINOK(progress->SetRatioInfo(&packSize, &pos))
}
Byte b;
if (!m_InStream.ReadByte(b))
return S_FALSE;
const UInt64 rem = outSize - pos;
if (b & 0x80)
{
unsigned num = (unsigned)b - 0x80 + 1;
if (num > rem)
return S_FALSE;
pos += num;
do
{
if (!m_InStream.ReadByte(b))
return S_FALSE;
m_OutWindowStream.PutByte(b);
}
while (--num);
continue;
}
Byte b1;
if (!m_InStream.ReadByte(b1))
return S_FALSE;
UInt32 len, dist;
if (b & 0x40)
{
len = (UInt32)b - 0x40 + 4;
Byte b2;
if (!m_InStream.ReadByte(b2))
return S_FALSE;
dist = ((UInt32)b1 << 8) + b2;
}
else
{
len = ((UInt32)b >> 2) + 3;
dist = (((UInt32)b & 3) << 8) + b1;
}
if (/* dist >= pos || */ len > rem)
return S_FALSE;
if (!m_OutWindowStream.CopyBlock(dist, len))
return S_FALSE;
pos += len;
}
if (*inSize != m_InStream.GetProcessedSize())
return S_FALSE;
coderReleaser.NeedFlush = false;
return m_OutWindowStream.Flush();
}
catch(const CInBufferException &e) { return e.ErrorCode; }
catch(const CLzOutWindowException &e) { return e.ErrorCode; }
catch(...) { return S_FALSE; }
}
struct CDecoders
{
CMyComPtr2<ICompressCoder, NCompress::NZlib::CDecoder> zlib;
CMyComPtr2<ICompressCoder, NCompress::NBZip2::CDecoder> bzip2;
CMyComPtr2<ICompressCoder, NCompress::NLzfse::CDecoder> lzfse;
CMyUniquePtr<NCompress::NXz::CDecoder> xz;
CMyUniquePtr<CAdcDecoder> adc;
HRESULT Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
const CBlock &block, const UInt64 *unpSize, ICompressProgressInfo *progress);
};
HRESULT CDecoders::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
const CBlock &block, const UInt64 *unpSize, ICompressProgressInfo *progress)
{
HRESULT hres;
UInt64 processed;
switch (block.Type)
{
case METHOD_ADC:
adc.Create_if_Empty();
return adc->Code(inStream, outStream, &block.PackSize, unpSize, progress);
case METHOD_LZFSE:
lzfse.Create_if_Empty();
return lzfse.Interface()->Code(inStream, outStream, &block.PackSize, unpSize, progress);
case METHOD_ZLIB:
zlib.Create_if_Empty();
hres = zlib.Interface()->Code(inStream, outStream, NULL, unpSize, progress);
processed = zlib->GetInputProcessedSize();
break;
case METHOD_BZIP2:
bzip2.Create_if_Empty();
hres = bzip2.Interface()->Code(inStream, outStream, NULL, unpSize, progress);
processed = bzip2->GetInputProcessedSize();
break;
case METHOD_XZ:
xz.Create_if_Empty();
hres = xz->Decode(inStream, outStream, unpSize, true, progress);
processed = xz->Stat.InSize;
break;
default:
return E_NOTIMPL;
}
if (hres == S_OK && processed != block.PackSize)
hres = S_FALSE;
return hres;
}
Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
Int32 testMode, IArchiveExtractCallback *extractCallback))
{
COM_TRY_BEGIN
const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
if (allFilesMode)
numItems = _files.Size()
#ifdef DMG_SHOW_RAW
+ _extras.Size()
#endif
;
if (numItems == 0)
return S_OK;
UInt64 totalSize = 0;
UInt32 i;
for (i = 0; i < numItems; i++)
{
const UInt32 index = allFilesMode ? i : indices[i];
#ifdef DMG_SHOW_RAW
if (index >= _files.Size())
totalSize += _extras[index - _files.Size()].Data.Size();
else
#endif
totalSize += _files[index].Size;
}
RINOK(extractCallback->SetTotal(totalSize))
const size_t kZeroBufSize = 1 << 14;
CAlignedBuffer1 zeroBuf(kZeroBufSize);
memset(zeroBuf, 0, kZeroBufSize);
CDecoders decoders;
CMyComPtr2_Create<ICompressCoder, NCompress::CCopyCoder> copyCoder;
CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
lps->Init(extractCallback, false);
CMyComPtr2_Create<ISequentialInStream, CLimitedSequentialInStream> inStream;
inStream->SetStream(_inStream);
UInt64 total_PackSize = 0;
UInt64 total_UnpackSize = 0;
UInt64 cur_PackSize = 0;
UInt64 cur_UnpackSize = 0;
for (i = 0;; i++,
total_PackSize += cur_PackSize,
total_UnpackSize += cur_UnpackSize)
{
lps->InSize = total_PackSize;
lps->OutSize = total_UnpackSize;
cur_PackSize = 0;
cur_UnpackSize = 0;
RINOK(lps->SetCur())
if (i >= numItems)
return S_OK;
Int32 opRes = NExtract::NOperationResult::kOK;
{
CMyComPtr<ISequentialOutStream> realOutStream;
const Int32 askMode = testMode ?
NExtract::NAskMode::kTest :
NExtract::NAskMode::kExtract;
const UInt32 index = allFilesMode ? i : indices[i];
RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
if (!testMode && !realOutStream)
continue;
RINOK(extractCallback->PrepareOperation(askMode))
#ifdef DMG_SHOW_RAW
if (index >= _files.Size())
{
const CByteBuffer &buf = _extras[index - _files.Size()].Data;
if (realOutStream)
RINOK(WriteStream(realOutStream, buf, buf.Size()))
cur_PackSize = cur_UnpackSize = buf.Size();
}
else
#endif
{
const CFile &item = _files[index];
cur_PackSize = item.PackSize;
cur_UnpackSize = item.Size;
if (!item.IsCorrect)
opRes = NExtract::NOperationResult::kHeadersError;
else
{
CMyComPtr2_Create<ISequentialOutStream, COutStreamWithCRC> outCrcStream;
outCrcStream->SetStream(realOutStream);
// realOutStream.Release();
const bool needCrc = item.Checksum.IsCrc32();
outCrcStream->Init(needCrc);
CMyComPtr2_Create<ISequentialOutStream, CLimitedSequentialOutStream> outStream;
outStream->SetStream(outCrcStream);
UInt64 unpPos = 0;
UInt64 packPos = 0;
FOR_VECTOR (blockIndex, item.Blocks)
{
lps->InSize = total_PackSize + packPos;
lps->OutSize = total_UnpackSize + unpPos;
RINOK(lps->SetCur())
const CBlock &block = item.Blocks[blockIndex];
// if (!block.ThereAreDataInBlock()) continue;
packPos += block.PackSize;
if (block.UnpPos != unpPos)
{
opRes = NExtract::NOperationResult::kHeadersError;
break;
}
RINOK(InStream_SeekSet(_inStream, _startPos + _dataForkPair.Offset + item.StartPackPos + block.PackPos))
inStream->Init(block.PackSize);
const UInt64 unpSize = item.GetUnpackSize_of_Block(blockIndex);
outStream->Init(unpSize);
HRESULT res = S_OK;
outCrcStream->EnableCalc(needCrc && block.NeedCrc());
if (block.IsZeroMethod())
{
if (block.PackSize != 0)
opRes = NExtract::NOperationResult::kUnsupportedMethod;
}
else if (block.Type == METHOD_COPY)
{
if (unpSize != block.PackSize)
opRes = NExtract::NOperationResult::kUnsupportedMethod;
else
res = copyCoder.Interface()->Code(inStream, outStream, NULL, NULL, lps);
}
else
res = decoders.Code(inStream, outStream, block, &unpSize, lps);
if (res != S_OK)
{
if (res != S_FALSE)
{
if (res != E_NOTIMPL)
return res;
opRes = NExtract::NOperationResult::kUnsupportedMethod;
}
if (opRes == NExtract::NOperationResult::kOK)
opRes = NExtract::NOperationResult::kDataError;
}
unpPos += unpSize;
if (!outStream->IsFinishedOK())
{
if (!block.IsZeroMethod() && opRes == NExtract::NOperationResult::kOK)
opRes = NExtract::NOperationResult::kDataError;
for (unsigned k = 0;;)
{
const UInt64 rem = outStream->GetRem();
if (rem == 0)
break;
size_t size = kZeroBufSize;
if (size > rem)
size = (size_t)rem;
RINOK(WriteStream(outStream, zeroBuf, size))
k++;
if ((k & 0xfff) == 0)
{
lps->OutSize = total_UnpackSize + unpPos - outStream->GetRem();
RINOK(lps->SetCur())
}
}
}
}
if (needCrc && opRes == NExtract::NOperationResult::kOK)
{
if (outCrcStream->GetCRC() != item.Checksum.GetCrc32())
opRes = NExtract::NOperationResult::kCRCError;
}
}
}
}
RINOK(extractCallback->SetOperationResult(opRes))
}
COM_TRY_END
}
struct CChunk
{
int BlockIndex;
UInt64 AccessMark;
Byte *Buf;
size_t BufSize;
void Free()
{
z7_AlignedFree(Buf);
Buf = NULL;
BufSize = 0;
}
void Alloc(size_t size)
{
Buf = (Byte *)z7_AlignedAlloc(size);
}
};
Z7_CLASS_IMP_IInStream(
CInStream
)
bool _errorMode;
UInt64 _virtPos;
int _latestChunk;
int _latestBlock;
UInt64 _accessMark;
UInt64 _chunks_TotalSize;
CRecordVector<CChunk> _chunks;
public:
CMyComPtr<IInStream> Stream;
const CFile *File;
UInt64 Size;
private:
UInt64 _startPos;
~CInStream();
CMyComPtr2<ISequentialOutStream, CBufPtrSeqOutStream> outStream;
CMyComPtr2<ISequentialInStream, CLimitedSequentialInStream> inStream;
CDecoders decoders;
public:
// HRESULT
void Init(UInt64 startPos)
{
_errorMode = false;
_startPos = startPos;
_virtPos = 0;
_latestChunk = -1;
_latestBlock = -1;
_accessMark = 0;
_chunks_TotalSize = 0;
inStream.Create_if_Empty();
inStream->SetStream(Stream);
outStream.Create_if_Empty();
// return S_OK;
}
};
CInStream::~CInStream()
{
unsigned i = _chunks.Size();
while (i)
_chunks[--i].Free();
}
static unsigned FindBlock(const CRecordVector<CBlock> &blocks, UInt64 pos)
{
unsigned left = 0, right = blocks.Size();
for (;;)
{
const unsigned mid = (left + right) / 2;
if (mid == left)
return left;
if (pos < blocks[mid].UnpPos)
right = mid;
else
left = mid;
}
}
Z7_COM7F_IMF(CInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
{
// COM_TRY_BEGIN
try {
if (_errorMode)
return E_OUTOFMEMORY;
if (processedSize)
*processedSize = 0;
if (size == 0)
return S_OK;
if (_virtPos >= Size)
return S_OK; // (Size == _virtPos) ? S_OK: E_FAIL;
{
const UInt64 rem = Size - _virtPos;
if (size > rem)
size = (UInt32)rem;
}
if (_latestBlock >= 0)
{
const CBlock &block = File->Blocks[(unsigned)_latestBlock];
if (_virtPos < block.UnpPos ||
_virtPos - block.UnpPos >= File->GetUnpackSize_of_Block((unsigned)_latestBlock))
_latestBlock = -1;
}
if (_latestBlock < 0)
{
_latestChunk = -1;
const unsigned blockIndex = FindBlock(File->Blocks, _virtPos);
const CBlock &block = File->Blocks[blockIndex];
const UInt64 unpSize = File->GetUnpackSize_of_Block(blockIndex);
if (block.NeedAllocateBuffer()
&& unpSize <= k_Chunk_Size_MAX)
{
unsigned i = 0;
{
unsigned numChunks = _chunks.Size();
if (numChunks)
{
const CChunk *chunk = _chunks.ConstData();
do
{
if (chunk->BlockIndex == (int)blockIndex)
break;
chunk++;
}
while (--numChunks);
i = _chunks.Size() - numChunks;
}
}
if (i != _chunks.Size())
_latestChunk = (int)i;
else
{
unsigned chunkIndex;
for (;;)
{
if (_chunks.IsEmpty() ||
(_chunks.Size() < k_NumChunks_MAX
&& _chunks_TotalSize + unpSize <= k_Chunks_TotalSize_MAX))
{
CChunk chunk;
chunk.Buf = NULL;
chunk.BufSize = 0;
chunk.BlockIndex = -1;
chunk.AccessMark = 0;
chunkIndex = _chunks.Add(chunk);
break;
}
chunkIndex = 0;
if (_chunks.Size() == 1)
break;
{
const CChunk *chunks = _chunks.ConstData();
UInt64 accessMark_min = chunks[chunkIndex].AccessMark;
const unsigned numChunks = _chunks.Size();
for (i = 1; i < numChunks; i++)
{
if (chunks[i].AccessMark < accessMark_min)
{
chunkIndex = i;
accessMark_min = chunks[i].AccessMark;
}
}
}
{
CChunk &chunk = _chunks[chunkIndex];
const UInt64 newTotalSize = _chunks_TotalSize - chunk.BufSize;
if (newTotalSize + unpSize <= k_Chunks_TotalSize_MAX)
break;
_chunks_TotalSize = newTotalSize;
chunk.Free();
}
// we have called chunk.Free() before, because
// _chunks.Delete() doesn't call chunk.Free().
_chunks.Delete(chunkIndex);
PRF(printf("\n++num_chunks=%u, _chunks_TotalSize = %u\n", (unsigned)_chunks.Size(), (unsigned)_chunks_TotalSize);)
}
CChunk &chunk = _chunks[chunkIndex];
chunk.BlockIndex = -1;
chunk.AccessMark = 0;
if (chunk.BufSize < unpSize)
{
_chunks_TotalSize -= chunk.BufSize;
chunk.Free();
// if (unpSize > k_Chunk_Size_MAX) return E_FAIL;
chunk.Alloc((size_t)unpSize);
if (!chunk.Buf)
return E_OUTOFMEMORY;
chunk.BufSize = (size_t)unpSize;
_chunks_TotalSize += chunk.BufSize;
}
RINOK(InStream_SeekSet(Stream, _startPos + File->StartPackPos + block.PackPos))
inStream->Init(block.PackSize);
#ifdef Z7_DMG_USE_CACHE_FOR_COPY_BLOCKS
if (block.Type == METHOD_COPY)
{
if (block.PackSize != unpSize)
return E_FAIL;
RINOK(ReadStream_FAIL(inStream, chunk.Buf, (size_t)unpSize))
}
else
#endif
{
outStream->Init(chunk.Buf, (size_t)unpSize);
RINOK(decoders.Code(inStream, outStream, block, &unpSize, NULL))
if (outStream->GetPos() != unpSize)
return E_FAIL;
}
chunk.BlockIndex = (int)blockIndex;
_latestChunk = (int)chunkIndex;
}
_chunks[_latestChunk].AccessMark = _accessMark++;
}
_latestBlock = (int)blockIndex;
}
const CBlock &block = File->Blocks[(unsigned)_latestBlock];
const UInt64 offset = _virtPos - block.UnpPos;
{
const UInt64 rem = File->GetUnpackSize_of_Block((unsigned)_latestBlock) - offset;
if (size > rem)
size = (UInt32)rem;
if (size == 0) // it's unexpected case. but we check it.
return S_OK;
}
HRESULT res = S_OK;
if (block.IsZeroMethod())
memset(data, 0, size);
else if (_latestChunk >= 0)
memcpy(data, _chunks[_latestChunk].Buf + (size_t)offset, size);
else
{
if (block.Type != METHOD_COPY)
return E_FAIL;
RINOK(InStream_SeekSet(Stream, _startPos + File->StartPackPos + block.PackPos + offset))
res = Stream->Read(data, size, &size);
}
_virtPos += size;
if (processedSize)
*processedSize = size;
return res;
// COM_TRY_END
}
catch(...)
{
_errorMode = true;
return E_OUTOFMEMORY;
}
}
Z7_COM7F_IMF(CInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
{
switch (seekOrigin)
{
case STREAM_SEEK_SET: break;
case STREAM_SEEK_CUR: offset += _virtPos; break;
case STREAM_SEEK_END: offset += Size; break;
default: return STG_E_INVALIDFUNCTION;
}
if (offset < 0)
return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
_virtPos = (UInt64)offset;
if (newPosition)
*newPosition = (UInt64)offset;
return S_OK;
}
Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
{
COM_TRY_BEGIN
#ifdef DMG_SHOW_RAW
if (index >= _files.Size())
return S_FALSE;
#endif
CMyComPtr2<ISequentialInStream, CInStream> spec;
spec.Create_if_Empty();
spec->File = &_files[index];
const CFile &file = *spec->File;
if (!file.IsCorrect)
return S_FALSE;
FOR_VECTOR (i, file.Blocks)
{
const CBlock &block = file.Blocks[i];
if (!block.NeedAllocateBuffer())
continue;
switch (block.Type)
{
#ifdef Z7_DMG_USE_CACHE_FOR_COPY_BLOCKS
case METHOD_COPY:
break;
#endif
case METHOD_ADC:
case METHOD_ZLIB:
case METHOD_BZIP2:
case METHOD_LZFSE:
case METHOD_XZ:
// case METHOD_END:
if (file.GetUnpackSize_of_Block(i) > k_Chunk_Size_MAX)
return S_FALSE;
break;
default:
return S_FALSE;
}
}
spec->Stream = _inStream;
spec->Size = spec->File->Size;
// RINOK(
spec->Init(_startPos + _dataForkPair.Offset);
*stream = spec.Detach();
return S_OK;
COM_TRY_END
}
REGISTER_ARC_I(
"Dmg", "dmg", NULL, 0xE4,
k_Signature,
0,
NArcInfoFlags::kBackwardOpen |
NArcInfoFlags::kUseGlobalOffset,
NULL)
}}
Reference in New Issue View Git Blame Copy Permalink