7zip-native 0.0.0-stage → 0.0.1

package/vendor/7zip/CPP/7zip/Archive/Chm/ChmIn.cpp

@@ -0,0 +1,1026 @@
+// Archive/ChmIn.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/StreamUtils.h"
+
+#include "ChmIn.h"
+
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+namespace NArchive {
+namespace NChm {
+
+static const UInt32 kSignature_ITSP = 0x50535449;
+static const UInt32 kSignature_PMGL = 0x4C474D50;
+static const UInt32 kSignature_LZXC = 0x43585A4C;
+
+static const UInt32 kSignature_IFCM = 0x4D434649;
+static const UInt32 kSignature_AOLL = 0x4C4C4F41;
+static const UInt32 kSignature_CAOL = 0x4C4F4143;
+
+static const UInt32 kSignature_ITSF = 0x46535449;
+static const UInt32 kSignature_ITOL = 0x4C4F5449;
+static const UInt32 kSignature_ITLS = 0x534C5449;
+
+struct CEnexpectedEndException {};
+struct CHeaderErrorException {};
+
+// define CHM_LOW, if you want to see low level items
+// #define CHM_LOW
+
+static const Byte kChmLzxGuid[16]   = { 0x40, 0x89, 0xC2, 0x7F, 0x31, 0x9D, 0xD0, 0x11, 0x9B, 0x27, 0x00, 0xA0, 0xC9, 0x1E, 0x9C, 0x7C };
+static const Byte kHelp2LzxGuid[16] = { 0xC6, 0x07, 0x90, 0x0A, 0x76, 0x40, 0xD3, 0x11, 0x87, 0x89, 0x00, 0x00, 0xF8, 0x10, 0x57, 0x54 };
+static const Byte kDesGuid[16]      = { 0xA2, 0xE4, 0xF6, 0x67, 0xBF, 0x60, 0xD3, 0x11, 0x85, 0x40, 0x00, 0xC0, 0x4F, 0x58, 0xC3, 0xCF };
+
+static bool inline AreGuidsEqual(const Byte *g1, const Byte *g2)
+{
+  return memcmp(g1, g2, 16) == 0;
+}
+
+static void PrintByte(unsigned b, AString &s)
+{
+  s += (char)GET_HEX_CHAR_UPPER(b >> 4);
+  s += (char)GET_HEX_CHAR_LOWER(b & 0xF);
+}
+
+AString CMethodInfo::GetGuidString() const
+{
+  char s[16 * 2 + 8];
+  RawLeGuidToString_Braced(Guid, s);
+  // MyStringUpper_Ascii(s);
+  return (AString)s;
+}
+
+bool CMethodInfo::IsLzx() const
+{
+  if (AreGuidsEqual(Guid, kChmLzxGuid))
+    return true;
+  return AreGuidsEqual(Guid, kHelp2LzxGuid);
+}
+
+bool CMethodInfo::IsDes() const
+{
+  return AreGuidsEqual(Guid, kDesGuid);
+}
+
+AString CMethodInfo::GetName() const
+{
+  AString s;
+  if (IsLzx())
+  {
+    s = "LZX:";
+    s.Add_UInt32(LzxInfo.GetNumDictBits());
+  }
+  else
+  {
+    if (IsDes())
+      s = "DES";
+    else
+    {
+      s = GetGuidString();
+      /*
+      if (ControlData.Size() > 0 && ControlData.Size() <= (1 << 6))
+      {
+        s.Add_Colon();
+        for (size_t i = 0; i < ControlData.Size(); i++)
+          PrintByte(ControlData[i], s);
+      }
+      */
+    }
+  }
+  return s;
+}
+
+bool CSectionInfo::IsLzx() const
+{
+  if (Methods.Size() != 1)
+    return false;
+  return Methods[0].IsLzx();
+}
+
+UString CSectionInfo::GetMethodName() const
+{
+  UString s;
+  if (!IsLzx())
+  {
+    UString temp;
+    ConvertUTF8ToUnicode(Name, temp);
+      s += temp;
+    s += ": ";
+  }
+  FOR_VECTOR (i, Methods)
+  {
+    if (i != 0)
+      s.Add_Space();
+    s += Methods[i].GetName();
+  }
+  return s;
+}
+
+Byte CInArchive::ReadByte()
+{
+  Byte b;
+  if (!_inBuffer.ReadByte(b))
+    throw CEnexpectedEndException();
+  return b;
+}
+
+void CInArchive::Skip(size_t size)
+{
+  if (_inBuffer.Skip(size) != size)
+    throw CEnexpectedEndException();
+}
+
+void CInArchive::ReadBytes(Byte *data, UInt32 size)
+{
+  if (_inBuffer.ReadBytes(data, size) != size)
+    throw CEnexpectedEndException();
+}
+
+UInt16 CInArchive::ReadUInt16()
+{
+  Byte b0, b1;
+  if (!_inBuffer.ReadByte(b0)) throw CEnexpectedEndException();
+  if (!_inBuffer.ReadByte(b1)) throw CEnexpectedEndException();
+  return (UInt16)(((UInt16)b1 << 8) | b0);
+}
+
+UInt32 CInArchive::ReadUInt32()
+{
+  Byte p[4];
+  ReadBytes(p, 4);
+  return Get32(p);
+}
+
+UInt64 CInArchive::ReadUInt64()
+{
+  Byte p[8];
+  ReadBytes(p, 8);
+  return Get64(p);
+}
+
+UInt64 CInArchive::ReadEncInt()
+{
+  UInt64 val = 0;
+  for (int i = 0; i < 9; i++)
+  {
+    const unsigned b = ReadByte();
+    val |= (b & 0x7F);
+    if (b < 0x80)
+      return val;
+    val <<= 7;
+  }
+  throw CHeaderErrorException();
+}
+
+void CInArchive::ReadGUID(Byte *g)
+{
+  ReadBytes(g, 16);
+}
+
+void CInArchive::ReadString(unsigned size, AString &s)
+{
+  s.Empty();
+  if (size != 0)
+  {
+    ReadBytes((Byte *)s.GetBuf(size), size);
+    s.ReleaseBuf_CalcLen(size);
+  }
+}
+
+void CInArchive::ReadUString(unsigned size, UString &s)
+{
+  s.Empty();
+  while (size-- != 0)
+  {
+    const wchar_t c = ReadUInt16();
+    if (c == 0)
+    {
+      Skip(2 * size);
+      return;
+    }
+    s += c;
+  }
+}
+
+HRESULT CInArchive::ReadChunk(IInStream *inStream, UInt64 pos, UInt64 size)
+{
+  RINOK(InStream_SeekSet(inStream, pos))
+  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+  CMyComPtr<ISequentialInStream> limitedStream(streamSpec);
+  streamSpec->SetStream(inStream);
+  streamSpec->Init(size);
+  m_InStreamRef = limitedStream;
+  _inBuffer.SetStream(limitedStream);
+  _inBuffer.Init();
+  return S_OK;
+}
+
+HRESULT CInArchive::ReadDirEntry(CDatabase &database)
+{
+  CItem item;
+  const UInt64 nameLen = ReadEncInt();
+  if (nameLen == 0 || nameLen > (1 << 13))
+    return S_FALSE;
+  ReadString((unsigned)nameLen, item.Name);
+  item.Section = ReadEncInt();
+  item.Offset = ReadEncInt();
+  item.Size = ReadEncInt();
+  database.Items.Add(item);
+  return S_OK;
+}
+
+HRESULT CInArchive::OpenChm(IInStream *inStream, CDatabase &database)
+{
+  UInt32 headerSize = ReadUInt32();
+  if (headerSize != 0x60)
+    return S_FALSE;
+  database.PhySize = headerSize;
+
+  UInt32 unknown1 = ReadUInt32();
+  if (unknown1 != 0 && unknown1 != 1) // it's 0 in one .sll file
+    return S_FALSE;
+
+  IsArc = true;
+
+  /* UInt32 timeStamp = */ ReadUInt32();
+      // Considered as a big-endian DWORD, it appears to contain seconds (MSB) and
+      // fractional seconds (second byte).
+      // The third and fourth bytes may contain even more fractional bits.
+      // The 4 least significant bits in the last byte are constant.
+  /* UInt32 lang = */ ReadUInt32();
+  Byte g[16];
+  ReadGUID(g); // {7C01FD10-7BAA-11D0-9E0C-00A0-C922-E6EC}
+  ReadGUID(g); // {7C01FD11-7BAA-11D0-9E0C-00A0-C922-E6EC}
+  const unsigned kNumSections = 2;
+  UInt64 sectionOffsets[kNumSections];
+  UInt64 sectionSizes[kNumSections];
+  unsigned i;
+  for (i = 0; i < kNumSections; i++)
+  {
+    sectionOffsets[i] = ReadUInt64();
+    sectionSizes[i] = ReadUInt64();
+    UInt64 end = sectionOffsets[i] + sectionSizes[i];
+    database.UpdatePhySize(end);
+  }
+  // if (chmVersion == 3)
+    database.ContentOffset = ReadUInt64();
+  /*
+  else
+    database.ContentOffset = database.StartPosition + 0x58
+  */
+
+  // Section 0
+  ReadChunk(inStream, sectionOffsets[0], sectionSizes[0]);
+  if (sectionSizes[0] < 0x18)
+    return S_FALSE;
+  if (ReadUInt32() != 0x01FE)
+    return S_FALSE;
+  ReadUInt32(); // unknown:  0
+  UInt64 fileSize = ReadUInt64();
+  database.UpdatePhySize(fileSize);
+  ReadUInt32(); // unknown:  0
+  ReadUInt32(); // unknown:  0
+
+  // Section 1: The Directory Listing
+  ReadChunk(inStream, sectionOffsets[1], sectionSizes[1]);
+  if (ReadUInt32() != kSignature_ITSP)
+    return S_FALSE;
+  if (ReadUInt32() != 1) // version
+    return S_FALSE;
+  /* UInt32 dirHeaderSize = */ ReadUInt32();
+  ReadUInt32(); // 0x0A (unknown)
+  UInt32 dirChunkSize = ReadUInt32(); // $1000
+  if (dirChunkSize < 32)
+    return S_FALSE;
+  /* UInt32 density = */ ReadUInt32(); //  "Density" of quickref section, usually 2.
+  /* UInt32 depth = */ ReadUInt32(); //  Depth of the index tree: 1 there is no index,
+                               // 2 if there is one level of PMGI chunks.
+
+  /* UInt32 chunkNumber = */ ReadUInt32(); //  Chunk number of root index chunk, -1 if there is none
+                                     // (though at least one file has 0 despite there being no
+                                     // index chunk, probably a bug.)
+  /* UInt32 firstPmglChunkNumber = */ ReadUInt32(); // Chunk number of first PMGL (listing) chunk
+  /* UInt32 lastPmglChunkNumber = */ ReadUInt32();  // Chunk number of last PMGL (listing) chunk
+  ReadUInt32(); // -1 (unknown)
+  UInt32 numDirChunks = ReadUInt32(); // Number of directory chunks (total)
+  /* UInt32 windowsLangId = */ ReadUInt32();
+  ReadGUID(g);  // {5D02926A-212E-11D0-9DF9-00A0C922E6EC}
+  ReadUInt32(); // 0x54 (This is the length again)
+  ReadUInt32(); // -1 (unknown)
+  ReadUInt32(); // -1 (unknown)
+  ReadUInt32(); // -1 (unknown)
+
+  for (UInt32 ci = 0; ci < numDirChunks; ci++)
+  {
+    UInt64 chunkPos = _inBuffer.GetProcessedSize();
+    if (ReadUInt32() == kSignature_PMGL)
+    {
+      // The quickref area is written backwards from the end of the chunk.
+      // One quickref entry exists for every n entries in the file, where n
+      // is calculated as 1 + (1 << quickref density). So for density = 2, n = 5.
+
+      const UInt32 quickrefLength = ReadUInt32(); // Len of free space and/or quickref area at end of directory chunk
+      if (quickrefLength > dirChunkSize || quickrefLength < 2)
+        return S_FALSE;
+      ReadUInt32(); // Always 0
+      ReadUInt32(); // Chunk number of previous listing chunk when reading
+                    // directory in sequence (-1 if this is the first listing chunk)
+      ReadUInt32(); // Chunk number of next  listing chunk when reading
+                    // directory in sequence (-1 if this is the last listing chunk)
+      unsigned numItems = 0;
+      
+      for (;;)
+      {
+        const UInt64 offset = _inBuffer.GetProcessedSize() - chunkPos;
+        const UInt32 offsetLimit = dirChunkSize - quickrefLength;
+        if (offset > offsetLimit)
+          return S_FALSE;
+        if (offset == offsetLimit)
+          break;
+        RINOK(ReadDirEntry(database))
+        numItems++;
+      }
+      
+      Skip(quickrefLength - 2);
+      
+      const unsigned rrr = ReadUInt16();
+      if (rrr != numItems)
+      {
+        // Lazarus 9-26-2 chm contains 0 here.
+        if (rrr != 0)
+          return S_FALSE;
+      }
+    }
+    else
+      Skip(dirChunkSize - 4);
+  }
+  return S_OK;
+}
+
+HRESULT CInArchive::OpenHelp2(IInStream *inStream, CDatabase &database)
+{
+  if (ReadUInt32() != 1) // version
+    return S_FALSE;
+  if (ReadUInt32() != 0x28) // Location of header section table
+    return S_FALSE;
+  UInt32 numHeaderSections = ReadUInt32();
+  const unsigned kNumHeaderSectionsMax = 5;
+  if (numHeaderSections != kNumHeaderSectionsMax)
+    return S_FALSE;
+
+  IsArc = true;
+
+  ReadUInt32(); // Len of post-header table
+  Byte g[16];
+  ReadGUID(g);  // {0A9007C1-4076-11D3-8789-0000F8105754}
+
+  // header section table
+  UInt64 sectionOffsets[kNumHeaderSectionsMax];
+  UInt64 sectionSizes[kNumHeaderSectionsMax];
+  UInt32 i;
+  for (i = 0; i < numHeaderSections; i++)
+  {
+    sectionOffsets[i] = ReadUInt64();
+    sectionSizes[i] = ReadUInt64();
+    UInt64 end = sectionOffsets[i] + sectionSizes[i];
+    database.UpdatePhySize(end);
+  }
+  
+  // Post-Header
+  ReadUInt32(); // 2
+  ReadUInt32(); // 0x98: offset to CAOL from beginning of post-header)
+  // ----- Directory information
+  ReadUInt64(); // Chunk number of top-level AOLI chunk in directory, or -1
+  ReadUInt64(); // Chunk number of first AOLL chunk in directory
+  ReadUInt64(); // Chunk number of last AOLL chunk in directory
+  ReadUInt64(); // 0 (unknown)
+  ReadUInt32(); // $2000 (Directory chunk size of directory)
+  ReadUInt32(); // Quickref density for main directory, usually 2
+  ReadUInt32(); // 0 (unknown)
+  ReadUInt32(); // Depth of main directory index tree
+                // 1 there is no index, 2 if there is one level of AOLI chunks.
+  ReadUInt64(); // 0 (unknown)
+  UInt64 numDirEntries = ReadUInt64(); // Number of directory entries
+  // ----- Directory Index Information
+  ReadUInt64(); // -1 (unknown, probably chunk number of top-level AOLI in directory index)
+  ReadUInt64(); // Chunk number of first AOLL chunk in directory index
+  ReadUInt64(); // Chunk number of last AOLL chunk in directory index
+  ReadUInt64(); // 0 (unknown)
+  ReadUInt32(); // $200 (Directory chunk size of directory index)
+  ReadUInt32(); // Quickref density for directory index, usually 2
+  ReadUInt32(); // 0 (unknown)
+  ReadUInt32(); // Depth of directory index index tree.
+  ReadUInt64(); // Possibly flags -- sometimes 1, sometimes 0.
+  ReadUInt64(); // Number of directory index entries (same as number of AOLL
+               // chunks in main directory)
+  
+  // (The obvious guess for the following two fields, which recur in a number
+  // of places, is they are maximum sizes for the directory and directory index.
+  // However, I have seen no direct evidence that this is the case.)
+
+  ReadUInt32(); // $100000 (Same as field following chunk size in directory)
+  ReadUInt32(); // $20000 (Same as field following chunk size in directory index)
+
+  ReadUInt64(); // 0 (unknown)
+  if (ReadUInt32() != kSignature_CAOL)
+    return S_FALSE;
+  if (ReadUInt32() != 2) // (Most likely a version number)
+    return S_FALSE;
+  UInt32 caolLength = ReadUInt32(); // $50 (Len of the CAOL section, which includes the ITSF section)
+  if (caolLength >= 0x2C)
+  {
+    /* UInt32 c7 = */ ReadUInt16(); // Unknown.  Remains the same when identical files are built.
+              // Does not appear to be a checksum.  Many files have
+              // 'HH' (HTML Help?) here, indicating this may be a compiler ID
+              //  field.  But at least one ITOL/ITLS compiler does not set this
+              // field to a constant value.
+    ReadUInt16(); // 0 (Unknown.  Possibly part of 00A4 field)
+    ReadUInt32(); // Unknown.  Two values have been seen -- $43ED, and 0.
+    ReadUInt32(); // $2000 (Directory chunk size of directory)
+    ReadUInt32(); // $200 (Directory chunk size of directory index)
+    ReadUInt32(); // $100000 (Same as field following chunk size in directory)
+    ReadUInt32(); // $20000 (Same as field following chunk size in directory index)
+    ReadUInt32(); // 0 (unknown)
+    ReadUInt32(); // 0 (Unknown)
+    if (caolLength == 0x2C)
+    {
+      // fprintf(stdout, "\n !!!NewFormat\n");
+      // fflush(stdout);
+      database.ContentOffset = 0; // maybe we must add database.StartPosition here?
+      database.NewFormat = true;
+    }
+    else if (caolLength == 0x50)
+    {
+      ReadUInt32(); // 0 (Unknown)
+      if (ReadUInt32() != kSignature_ITSF)
+        return S_FALSE;
+      if (ReadUInt32() != 4) // $4 (Version number -- CHM uses 3)
+        return S_FALSE;
+      if (ReadUInt32() != 0x20) // $20 (length of ITSF)
+        return S_FALSE;
+      UInt32 unknown = ReadUInt32();
+      if (unknown != 0 && unknown != 1) // = 0 for some HxW files, 1 in other cases;
+        return S_FALSE;
+      database.ContentOffset = database.StartPosition + ReadUInt64();
+      /* UInt32 timeStamp = */ ReadUInt32();
+          // A timestamp of some sort.
+          // Considered as a big-endian DWORD, it appears to contain
+          // seconds (MSB) and fractional seconds (second byte).
+          // The third and fourth bytes may contain even more fractional
+          // bits.  The 4 least significant bits in the last byte are constant.
+      /* UInt32 lang = */ ReadUInt32(); // BE?
+    }
+    else
+      return S_FALSE;
+  }
+
+  // Section 0
+  ReadChunk(inStream, database.StartPosition + sectionOffsets[0], sectionSizes[0]);
+  if (sectionSizes[0] < 0x18)
+    return S_FALSE;
+  if (ReadUInt32() != 0x01FE)
+    return S_FALSE;
+  ReadUInt32(); // unknown:  0
+  UInt64 fileSize = ReadUInt64();
+  database.UpdatePhySize(fileSize);
+  ReadUInt32(); // unknown:  0
+  ReadUInt32(); // unknown:  0
+
+  // Section 1: The Directory Listing
+  ReadChunk(inStream, database.StartPosition + sectionOffsets[1], sectionSizes[1]);
+  if (ReadUInt32() != kSignature_IFCM)
+    return S_FALSE;
+  if (ReadUInt32() != 1) // (probably a version number)
+    return S_FALSE;
+  UInt32 dirChunkSize = ReadUInt32(); // $2000
+  if (dirChunkSize < 64)
+    return S_FALSE;
+  ReadUInt32(); // $100000  (unknown)
+  ReadUInt32(); // -1 (unknown)
+  ReadUInt32(); // -1 (unknown)
+  UInt32 numDirChunks = ReadUInt32();
+  ReadUInt32(); // 0 (unknown, probably high word of above)
+
+  for (UInt32 ci = 0; ci < numDirChunks; ci++)
+  {
+    UInt64 chunkPos = _inBuffer.GetProcessedSize();
+    if (ReadUInt32() == kSignature_AOLL)
+    {
+      UInt32 quickrefLength = ReadUInt32(); // Len of quickref area at end of directory chunk
+      if (quickrefLength > dirChunkSize || quickrefLength < 2)
+        return S_FALSE;
+      ReadUInt64(); // Directory chunk number
+            // This must match physical position in file, that is
+            // the chunk size times the chunk number must be the
+            // offset from the end of the directory header.
+      ReadUInt64(); // Chunk number of previous listing chunk when reading
+                    // directory in sequence (-1 if first listing chunk)
+      ReadUInt64(); // Chunk number of next listing chunk when reading
+                    // directory in sequence (-1 if last listing chunk)
+      ReadUInt64(); // Number of first listing entry in this chunk
+      ReadUInt32(); // 1 (unknown -- other values have also been seen here)
+      ReadUInt32(); // 0 (unknown)
+      
+      unsigned numItems = 0;
+      for (;;)
+      {
+        const UInt64 offset = _inBuffer.GetProcessedSize() - chunkPos;
+        const UInt32 offsetLimit = dirChunkSize - quickrefLength;
+        if (offset > offsetLimit)
+          return S_FALSE;
+        if (offset == offsetLimit)
+          break;
+        if (database.NewFormat)
+        {
+          const unsigned nameLen = ReadUInt16();
+          if (nameLen == 0)
+            return S_FALSE;
+          UString name;
+          ReadUString(nameLen, name);
+          AString s;
+          ConvertUnicodeToUTF8(name, s);
+          {
+            const unsigned b = ReadByte();
+            s.Add_Space();
+            PrintByte(b, s);
+          }
+          s.Add_Space();
+          UInt64 len = ReadEncInt();
+          // then number of items ?
+          // then length ?
+          // then some data (binary encoding?)
+          if (len > 1u << 29) // what limit here we need?
+            return S_FALSE;
+          if (len)
+          do
+          {
+            const unsigned b = ReadByte();
+            PrintByte(b, s);
+          }
+          while (--len);
+          database.NewFormatString += s;
+          database.NewFormatString += "\r\n";
+        }
+        else
+        {
+          RINOK(ReadDirEntry(database))
+        }
+        numItems++;
+      }
+      Skip(quickrefLength - 2);
+      if (ReadUInt16() != numItems)
+        return S_FALSE;
+      if (numItems > numDirEntries)
+        return S_FALSE;
+      numDirEntries -= numItems;
+    }
+    else
+      Skip(dirChunkSize - 4);
+  }
+  return numDirEntries == 0 ? S_OK : S_FALSE;
+}
+
+HRESULT CInArchive::DecompressStream(IInStream *inStream, const CDatabase &database, const AString &name)
+{
+  int index = database.FindItem(name);
+  if (index < 0)
+    return S_FALSE;
+  const CItem &item = database.Items[index];
+  _chunkSize = item.Size;
+  return ReadChunk(inStream, database.ContentOffset + item.Offset, item.Size);
+}
+
+
+#define DATA_SPACE "::DataSpace/"
+#define kNameList DATA_SPACE "NameList"
+#define kStorage DATA_SPACE "Storage/"
+#define kContent "Content"
+#define kControlData "ControlData"
+#define kSpanInfo "SpanInfo"
+#define kTransform "Transform/"
+#define kResetTable "/InstanceData/ResetTable"
+#define kTransformList "List"
+
+static AString GetSectionPrefix(const AString &name)
+{
+  AString s (kStorage);
+  s += name;
+  s.Add_Slash();
+  return s;
+}
+
+#define RINOZ(x) { int _tt_ = (x); if (_tt_ != 0) return _tt_; }
+
+static int CompareFiles(const unsigned *p1, const unsigned *p2, void *param)
+{
+  const CObjectVector<CItem> &items = *(const CObjectVector<CItem> *)param;
+  const CItem &item1 = items[*p1];
+  const CItem &item2 = items[*p2];
+  bool isDir1 = item1.IsDir();
+  bool isDir2 = item2.IsDir();
+  if (isDir1 && !isDir2)
+    return -1;
+  if (isDir2)
+  {
+    if (!isDir1)
+      return 1;
+  }
+  else
+  {
+    RINOZ(MyCompare(item1.Section, item2.Section))
+    RINOZ(MyCompare(item1.Offset, item2.Offset))
+    RINOZ(MyCompare(item1.Size, item2.Size))
+  }
+  return MyCompare(*p1, *p2);
+}
+
+void CFilesDatabase::SetIndices()
+{
+  FOR_VECTOR (i, Items)
+  {
+    const CItem &item = Items[i];
+    if (item.IsUserItem() && item.Name.Len() != 1)
+      Indices.Add(i);
+  }
+}
+
+void CFilesDatabase::Sort()
+{
+  Indices.Sort(CompareFiles, (void *)&Items);
+}
+
+bool CFilesDatabase::Check()
+{
+  UInt64 maxPos = 0;
+  UInt64 prevSection = 0;
+  FOR_VECTOR (i, Indices)
+  {
+    const CItem &item = Items[Indices[i]];
+    if (item.Section == 0 || item.IsDir())
+      continue;
+    if (item.Section != prevSection)
+    {
+      prevSection = item.Section;
+      maxPos = 0;
+      continue;
+    }
+    if (item.Offset < maxPos)
+      return false;
+    maxPos = item.Offset + item.Size;
+    if (maxPos < item.Offset)
+      return false;
+  }
+  return true;
+}
+
+bool CFilesDatabase::CheckSectionRefs()
+{
+  FOR_VECTOR (i, Indices)
+  {
+    const CItem &item = Items[Indices[i]];
+    if (item.Section == 0 || item.IsDir())
+      continue;
+    if (item.Section >= Sections.Size())
+      return false;
+  }
+  return true;
+}
+
+static int inline GetLog(UInt32 num)
+{
+  for (int i = 0; i < 32; i++)
+    if (((UInt32)1 << i) == num)
+      return i;
+  return -1;
+}
+
+HRESULT CInArchive::OpenHighLevel(IInStream *inStream, CFilesDatabase &database)
+{
+  {
+    // The NameList file
+    RINOK(DecompressStream(inStream, database, (AString)kNameList))
+    /* UInt16 length = */ ReadUInt16();
+    UInt16 numSections = ReadUInt16();
+    for (unsigned i = 0; i < numSections; i++)
+    {
+      CSectionInfo section;
+      const unsigned nameLen = ReadUInt16();
+      UString name;
+      ReadUString(nameLen, name);
+      if (ReadUInt16() != 0)
+        return S_FALSE;
+      ConvertUnicodeToUTF8(name, section.Name);
+      // if (!ConvertUnicodeToUTF8(name, section.Name)) return S_FALSE;
+      database.Sections.Add(section);
+    }
+  }
+
+  unsigned si;
+  for (si = 1; si < database.Sections.Size(); si++)
+  {
+    CSectionInfo &section = database.Sections[si];
+    AString sectionPrefix (GetSectionPrefix(section.Name));
+    {
+      // Content
+      int index = database.FindItem(sectionPrefix + kContent);
+      if (index < 0)
+        return S_FALSE;
+      const CItem &item = database.Items[index];
+      section.Offset = item.Offset;
+      section.CompressedSize = item.Size;
+    }
+    AString transformPrefix (sectionPrefix + kTransform);
+    if (database.Help2Format)
+    {
+      // Transform List
+      RINOK(DecompressStream(inStream, database, transformPrefix + kTransformList))
+      if ((_chunkSize & 0xF) != 0)
+        return S_FALSE;
+      unsigned numGuids = (unsigned)(_chunkSize / 0x10);
+      if (numGuids < 1)
+        return S_FALSE;
+      for (unsigned i = 0; i < numGuids; i++)
+      {
+        CMethodInfo method;
+        ReadGUID(method.Guid);
+        section.Methods.Add(method);
+      }
+    }
+    else
+    {
+      CMethodInfo method;
+      memcpy(method.Guid, kChmLzxGuid, 16);
+      section.Methods.Add(method);
+    }
+
+    {
+      // Control Data
+      RINOK(DecompressStream(inStream, database, sectionPrefix + kControlData))
+      
+      FOR_VECTOR (mi, section.Methods)
+      {
+        CMethodInfo &method = section.Methods[mi];
+        UInt32 numDWORDS = ReadUInt32();
+        if (method.IsLzx())
+        {
+          if (numDWORDS < 5)
+            return S_FALSE;
+          if (ReadUInt32() != kSignature_LZXC)
+            return S_FALSE;
+          CLzxInfo &li = method.LzxInfo;
+          li.Version = ReadUInt32();
+          if (li.Version != 2 && li.Version != 3)
+            return S_FALSE;
+          
+          {
+            // There is bug in VC6, if we use function call as parameter for inline function
+            const UInt32 val32 = ReadUInt32();
+            const int n = GetLog(val32);
+            if (n < 0 || n > 16)
+              return S_FALSE;
+            li.ResetIntervalBits = (unsigned)n;
+          }
+          
+          {
+            const UInt32 val32 = ReadUInt32();
+            const int n = GetLog(val32);
+            if (n < 0 || n > 16)
+              return S_FALSE;
+            li.WindowSizeBits = (unsigned)n;
+          }
+
+          li.CacheSize = ReadUInt32();
+          numDWORDS -= 5;
+          if (numDWORDS)
+          do
+            ReadUInt32();
+          while (--numDWORDS);
+        }
+        else
+        {
+          if (numDWORDS > 1u << 27)
+            return S_FALSE;
+          const size_t numBytes = (size_t)numDWORDS * 4;
+          // method.ControlData.Alloc(numBytes);
+          // ReadBytes(method.ControlData, numBytes);
+          Skip(numBytes);
+        }
+      }
+    }
+
+    {
+      // SpanInfo
+      RINOK(DecompressStream(inStream, database, sectionPrefix + kSpanInfo))
+      section.UncompressedSize = ReadUInt64();
+    }
+
+    // read ResetTable for LZX
+    FOR_VECTOR (mi, section.Methods)
+    {
+      CMethodInfo &method = section.Methods[mi];
+      if (method.IsLzx())
+      {
+        // ResetTable;
+        RINOK(DecompressStream(inStream, database, transformPrefix +
+            method.GetGuidString() + kResetTable))
+        CResetTable &rt = method.LzxInfo.ResetTable;
+        
+        if (_chunkSize < 4)
+        {
+          if (_chunkSize != 0)
+            return S_FALSE;
+          // ResetTable is empty in .chw files
+          if (section.UncompressedSize != 0)
+            return S_FALSE;
+          rt.UncompressedSize = 0;
+          rt.CompressedSize = 0;
+          // rt.BlockSize = 0;
+        }
+        else
+        {
+          const UInt32 ver = ReadUInt32(); // 2  unknown (possibly a version number)
+          if (ver != 2 && ver != 3)
+            return S_FALSE;
+          const UInt32 numEntries = ReadUInt32();
+          const unsigned kEntrySize = 8;
+          if (ReadUInt32() != kEntrySize)
+            return S_FALSE;
+          const unsigned kRtHeaderSize = 4 * 4 + 8 * 3;
+          if (ReadUInt32() != kRtHeaderSize)
+            return S_FALSE;
+          if (kRtHeaderSize + kEntrySize * (UInt64)numEntries != _chunkSize)
+            return S_FALSE;
+
+          rt.UncompressedSize = ReadUInt64();
+          rt.CompressedSize = ReadUInt64();
+          UInt64 blockSize = ReadUInt64();
+          if (blockSize != kBlockSize)
+            return S_FALSE;
+          UInt64 numBlocks = (rt.UncompressedSize + kBlockSize + 1) / kBlockSize;
+          if (numEntries != numBlocks &&
+              numEntries != numBlocks + 1)
+            return S_FALSE;
+  
+          rt.ResetOffsets.ClearAndReserve(numEntries);
+          
+          for (UInt32 i = 0; i < numEntries; i++)
+          {
+            UInt64 v = ReadUInt64();
+            if (i != 0 && v < rt.ResetOffsets[i - 1])
+              return S_FALSE;
+            rt.ResetOffsets.AddInReserved(v);
+          }
+
+          if (numEntries != 0)
+            if (rt.ResetOffsets[0] != 0)
+              return S_FALSE;
+
+          if (numEntries == numBlocks + 1)
+          {
+            // Lazarus 9-26-2 chm contains additional entty
+            if (rt.ResetOffsets.Back() != rt.CompressedSize)
+              return S_FALSE;
+          }
+        }
+      }
+    }
+  }
+
+  database.SetIndices();
+  database.Sort();
+  return database.Check() ? S_OK : S_FALSE;
+}
+
+HRESULT CInArchive::Open2(IInStream *inStream,
+    const UInt64 *searchHeaderSizeLimit,
+    CFilesDatabase &database)
+{
+  IsArc = false;
+  HeadersError = false;
+  UnexpectedEnd = false;
+  UnsupportedFeature = false;
+
+  database.Clear();
+  database.Help2Format = _help2;
+  const UInt32 chmVersion = 3;
+
+  RINOK(InStream_GetPos(inStream, database.StartPosition))
+
+  if (!_inBuffer.Create(1 << 14))
+    return E_OUTOFMEMORY;
+  _inBuffer.SetStream(inStream);
+  _inBuffer.Init();
+  
+  if (_help2)
+  {
+    const unsigned kSignatureSize = 8;
+    const UInt64 signature = ((UInt64)kSignature_ITLS << 32) | kSignature_ITOL;
+    UInt64 limit = 1 << 18;
+    
+    if (searchHeaderSizeLimit)
+      if (limit > *searchHeaderSizeLimit)
+        limit = *searchHeaderSizeLimit;
+
+    UInt64 val = 0;
+    
+    for (;;)
+    {
+      Byte b;
+      if (!_inBuffer.ReadByte(b))
+        return S_FALSE;
+      val >>= 8;
+      val |= ((UInt64)b) << ((kSignatureSize - 1) * 8);
+      if (_inBuffer.GetProcessedSize() >= kSignatureSize)
+      {
+        if (val == signature)
+          break;
+        if (_inBuffer.GetProcessedSize() > limit)
+          return S_FALSE;
+      }
+    }
+    
+    database.StartPosition += _inBuffer.GetProcessedSize() - kSignatureSize;
+    RINOK(OpenHelp2(inStream, database))
+    if (database.NewFormat)
+      return S_OK;
+  }
+  else
+  {
+    if (ReadUInt32() != kSignature_ITSF)
+      return S_FALSE;
+    if (ReadUInt32() != chmVersion)
+      return S_FALSE;
+    RINOK(OpenChm(inStream, database))
+  }
+
+
+  #ifndef CHM_LOW
+  
+  try
+  {
+    try
+    {
+      HRESULT res = OpenHighLevel(inStream, database);
+      if (res == S_FALSE)
+      {
+        UnsupportedFeature = true;
+        database.HighLevelClear();
+        return S_OK;
+      }
+      RINOK(res)
+      if (!database.CheckSectionRefs())
+        HeadersError = true;
+      database.LowLevel = false;
+    }
+    catch(...)
+    {
+      database.HighLevelClear();
+      throw;
+    }
+  }
+  // catch(const CInBufferException &e) { return e.ErrorCode; }
+  catch(CEnexpectedEndException &) { UnexpectedEnd = true; }
+  catch(CHeaderErrorException &) { HeadersError = true; }
+  catch(...) { throw; }
+
+  #endif
+
+  return S_OK;
+}
+
+HRESULT CInArchive::Open(IInStream *inStream,
+    const UInt64 *searchHeaderSizeLimit,
+    CFilesDatabase &database)
+{
+  try
+  {
+    try
+    {
+      HRESULT res = Open2(inStream, searchHeaderSizeLimit, database);
+      m_InStreamRef.Release();
+      return res;
+    }
+    catch(...)
+    {
+      m_InStreamRef.Release();
+      throw;
+    }
+  }
+  catch(const CInBufferException &e) { return e.ErrorCode; }
+  catch(CEnexpectedEndException &) { UnexpectedEnd = true; }
+  catch(CHeaderErrorException &) { HeadersError = true; }
+  return S_FALSE;
+}
+
+}}