xref: /aosp_15_r20/external/lzma/CPP/7zip/Archive/DmgHandler.cpp (revision f6dc9357d832569d4d1f5d24eacdb3935a1ae8e6)

// 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 == 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() == 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 != "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)

}}