seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/Chm/ChmHandler.cpp

@@ -2,17 +2,17 @@
 
 #include "StdAfx.h"
 
-#include "Common/ComTry.h"
-#include "Common/Defs.h"
-#include "Common/StringConvert.h"
-#include "Common/UTFConvert.h"
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
 
-#include "Windows/PropVariant.h"
-#include "Windows/Time.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
 
 #include "../../Common/LimitedStreams.h"
 #include "../../Common/ProgressUtils.h"
 #include "../../Common/StreamUtils.h"
+#include "../../Common/RegisterArc.h"
 
 #include "../../Compress/CopyCoder.h"
 #include "../../Compress/LzxDecoder.h"
@@ -38,44 +38,45 @@ enum
 
 #endif
 
-STATPROPSTG kProps[] =
+static const Byte kProps[] =
 {
-  { NULL, kpidPath, VT_BSTR},
-  { NULL, kpidSize, VT_UI8},
-  { NULL, kpidMethod, VT_BSTR},
-  { NULL, kpidBlock, VT_UI4}
+  kpidPath,
+  kpidSize,
+  kpidMethod,
+  kpidBlock
   
   #ifdef _CHM_DETAILS
   ,
-  { L"Section", kpidSection, VT_UI4},
-  { NULL, kpidOffset, VT_UI4}
+  L"Section", kpidSection,
+  kpidOffset
   #endif
 };
 
-STATPROPSTG kArcProps[] =
+/*
+static const Byte kArcProps[] =
 {
-  { NULL, kpidNumBlocks, VT_UI8}
+  // kpidNumBlocks,
 };
+*/
 
 IMP_IInArchive_Props
 
-IMP_IInArchive_ArcProps_NO
-/*
-IMP_IInArchive_ArcProps
+IMP_IInArchive_ArcProps_NO_Table
 
 STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
-  COM_TRY_BEGIN
-  NWindows::NCOM::CPropVariant prop;
-  switch(propID)
+  // COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  switch (propID)
   {
+    /*
     case kpidNumBlocks:
     {
       UInt64 numBlocks = 0;
-      for (int i = 0; i < m_Database.Sections.Size(); i++)
+      FOR_VECTOR(i, m_Database.Sections)
       {
         const CSectionInfo &s = m_Database.Sections[i];
-        for (int j = 0; j < s.Methods.Size(); j++)
+        FOR_VECTOR(j, s.Methods)
         {
           const CMethodInfo &m = s.Methods[j];
           if (m.IsLzx())
@@ -85,48 +86,57 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
       prop = numBlocks;
       break;
     }
+    */
+    case kpidOffset: prop = m_Database.StartPosition; break;
+    case kpidPhySize: prop = m_Database.PhySize; break;
+
+    case kpidErrorFlags: prop = m_ErrorFlags; break;
   }
   prop.Detach(value);
   return S_OK;
-  COM_TRY_END
+  // COM_TRY_END
 }
-*/
 
-STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID,  PROPVARIANT *value)
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
-  NWindows::NCOM::CPropVariant prop;
+  NCOM::CPropVariant prop;
+  
   if (m_Database.NewFormat)
   {
-    switch(propID)
+    switch (propID)
     {
       case kpidSize:
-        prop = (UInt64)m_Database.NewFormatString.Length();
+        prop = (UInt64)m_Database.NewFormatString.Len();
       break;
     }
     prop.Detach(value);
     return S_OK;
   }
-  int entryIndex;
+  
+  unsigned entryIndex;
   if (m_Database.LowLevel)
     entryIndex = index;
   else
     entryIndex = m_Database.Indices[index];
+  
   const CItem &item = m_Database.Items[entryIndex];
-  switch(propID)
+  
+  switch (propID)
   {
     case kpidPath:
     {
       UString us;
-      if (ConvertUTF8ToUnicode(item.Name, us))
+      // if (
+      ConvertUTF8ToUnicode(item.Name, us);
       {
         if (!m_Database.LowLevel)
         {
-          if (us.Length() > 1)
-            if (us[0] == L'/')
-              us.Delete(0);
+          if (us.Len() > 1 && us[0] == L'/')
+            us.Delete(0);
         }
-        prop = NItemName::GetOSName2(us);
+        NItemName::ConvertToOSName2(us);
+        prop = us;
       }
       break;
     }
@@ -136,15 +146,15 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID,  PROPVARIANT *va
     {
       if (!item.IsDir())
         if (item.Section == 0)
-          prop = L"Copy";
+          prop = "Copy";
         else if (item.Section < m_Database.Sections.Size())
-          prop = m_Database.Sections[(int)item.Section].GetMethodName();
+          prop = m_Database.Sections[(unsigned)item.Section].GetMethodName();
       break;
     }
     case kpidBlock:
       if (m_Database.LowLevel)
         prop = item.Section;
-      else if (item.Section != 0)
+      else if (item.Section != 0 && item.Section < m_Database.Sections.Size())
         prop = m_Database.GetFolder(index);
       break;
     
@@ -155,11 +165,13 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID,  PROPVARIANT *va
 
     #endif
   }
+  
   prop.Detach(value);
   return S_OK;
   COM_TRY_END
 }
 
+/*
 class CProgressImp: public CProgressVirt
 {
   CMyComPtr<IArchiveOpenCallback> _callback;
@@ -182,18 +194,25 @@ STDMETHODIMP CProgressImp::SetCompleted(const UInt64 *numFiles)
     return _callback->SetCompleted(numFiles, NULL);
   return S_OK;
 }
+*/
 
 STDMETHODIMP CHandler::Open(IInStream *inStream,
     const UInt64 *maxCheckStartPosition,
     IArchiveOpenCallback * /* openArchiveCallback */)
 {
   COM_TRY_BEGIN
-  m_Stream.Release();
+  Close();
   try
   {
-    CInArchive archive;
+    CInArchive archive(_help2);
     // CProgressImp progressImp(openArchiveCallback);
-    RINOK(archive.Open(inStream, maxCheckStartPosition, m_Database));
+    HRESULT res = archive.Open(inStream, maxCheckStartPosition, m_Database);
+    if (!archive.IsArc) m_ErrorFlags |= kpv_ErrorFlags_IsNotArc;
+    if (archive.HeadersError) m_ErrorFlags |= kpv_ErrorFlags_HeadersError;
+    if (archive.UnexpectedEnd)  m_ErrorFlags |= kpv_ErrorFlags_UnexpectedEnd;
+    if (archive.UnsupportedFeature)  m_ErrorFlags |= kpv_ErrorFlags_UnsupportedFeature;
+    
+    RINOK(res);
     /*
     if (m_Database.LowLevel)
       return S_FALSE;
@@ -210,6 +229,7 @@ STDMETHODIMP CHandler::Open(IInStream *inStream,
 
 STDMETHODIMP CHandler::Close()
 {
+  m_ErrorFlags = 0;
   m_Database.Clear();
   m_Stream.Release();
   return S_OK;
@@ -229,9 +249,9 @@ public:
   UInt64 m_PosInFolder;
   UInt64 m_PosInSection;
   const CRecordVector<bool> *m_ExtractStatuses;
-  int m_StartIndex;
-  int m_CurrentIndex;
-  int m_NumFiles;
+  unsigned m_StartIndex;
+  unsigned m_CurrentIndex;
+  unsigned m_NumFiles;
 
 private:
   const CFilesDatabase *m_Database;
@@ -283,7 +303,7 @@ HRESULT CChmFolderOutStream::WriteEmptyFiles()
 {
   if (m_FileIsOpen)
     return S_OK;
-  for (;m_CurrentIndex < m_NumFiles; m_CurrentIndex++)
+  for (; m_CurrentIndex < m_NumFiles; m_CurrentIndex++)
   {
     UInt64 fileSize = m_Database->GetFileSize(m_StartIndex + m_CurrentIndex);
     if (fileSize != 0)
@@ -300,9 +320,10 @@ HRESULT CChmFolderOutStream::WriteEmptyFiles()
 HRESULT CChmFolderOutStream::Write2(const void *data, UInt32 size, UInt32 *processedSize, bool isOK)
 {
   UInt32 realProcessed = 0;
-  if (processedSize != NULL)
+  if (processedSize)
    *processedSize = 0;
-  while(size != 0)
+  
+  while (size != 0)
   {
     if (m_FileIsOpen)
     {
@@ -320,7 +341,7 @@ HRESULT CChmFolderOutStream::Write2(const void *data, UInt32 size, UInt32 *proce
         }
       }
       realProcessed += numBytesToWrite;
-      if (processedSize != NULL)
+      if (processedSize)
         *processedSize = realProcessed;
       data = (const void *)((const Byte *)data + numBytesToWrite);
       size -= numBytesToWrite;
@@ -344,23 +365,32 @@ HRESULT CChmFolderOutStream::Write2(const void *data, UInt32 size, UInt32 *proce
     else
     {
       if (m_CurrentIndex >= m_NumFiles)
-        return E_FAIL;
-      int fullIndex = m_StartIndex + m_CurrentIndex;
+      {
+        realProcessed += size;
+        if (processedSize)
+          *processedSize = realProcessed;
+        return S_OK;
+        // return E_FAIL;
+      }
+
+      unsigned fullIndex = m_StartIndex + m_CurrentIndex;
       m_RemainFileSize = m_Database->GetFileSize(fullIndex);
       UInt64 fileOffset = m_Database->GetFileOffset(fullIndex);
       if (fileOffset < m_PosInSection)
         return E_FAIL;
+      
       if (fileOffset > m_PosInSection)
       {
         UInt32 numBytesToWrite = (UInt32)MyMin(fileOffset - m_PosInSection, UInt64(size));
         realProcessed += numBytesToWrite;
-        if (processedSize != NULL)
+        if (processedSize)
           *processedSize = realProcessed;
         data = (const void *)((const Byte *)data + numBytesToWrite);
         size -= numBytesToWrite;
         m_PosInSection += numBytesToWrite;
         m_PosInFolder += numBytesToWrite;
       }
+      
       if (fileOffset == m_PosInSection)
       {
         RINOK(OpenFile());
@@ -370,6 +400,7 @@ HRESULT CChmFolderOutStream::Write2(const void *data, UInt32 size, UInt32 *proce
       }
     }
   }
+  
   return WriteEmptyFiles();
 }
 
@@ -382,7 +413,7 @@ HRESULT CChmFolderOutStream::FlushCorrupted(UInt64 maxSize)
 {
   const UInt32 kBufferSize = (1 << 10);
   Byte buffer[kBufferSize];
-  for (int i = 0; i < kBufferSize; i++)
+  for (unsigned i = 0; i < kBufferSize; i++)
     buffer[i] = 0;
   if (maxSize > m_FolderSize)
     maxSize = m_FolderSize;
@@ -402,7 +433,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     Int32 testModeSpec, IArchiveExtractCallback *extractCallback)
 {
   COM_TRY_BEGIN
-  bool allFilesMode = (numItems == (UInt32)-1);
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
 
   if (allFilesMode)
     numItems = m_Database.NewFormat ? 1:
@@ -415,7 +446,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
   UInt64 currentTotalSize = 0;
 
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
   CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
   UInt32 i;
 
@@ -431,11 +462,13 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   {
     UInt64 currentItemSize = 0;
     UInt64 totalSize = 0;
+    
     if (m_Database.NewFormat)
-      totalSize = m_Database.NewFormatString.Length();
+      totalSize = m_Database.NewFormatString.Len();
     else
       for (i = 0; i < numItems; i++)
         totalSize += m_Database.Items[allFilesMode ? i : indices[i]].Size;
+    
     extractCallback->SetTotal(totalSize);
     
     for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
@@ -460,12 +493,13 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           continue;
         if (!testMode)
         {
-          UInt32 size = m_Database.NewFormatString.Length();
+          UInt32 size = m_Database.NewFormatString.Len();
           RINOK(WriteStream(realOutStream, (const char *)m_Database.NewFormatString, size));
         }
         RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
         continue;
       }
+      
       const CItem &item = m_Database.Items[index];
       
       currentItemSize = item.Size;
@@ -475,7 +509,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       RINOK(extractCallback->PrepareOperation(askMode));
       if (item.Section != 0)
       {
-        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnSupportedMethod));
+        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod));
         continue;
       }
 
@@ -498,12 +532,12 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   }
   
   UInt64 lastFolderIndex = ((UInt64)0 - 1);
+  
   for (i = 0; i < numItems; i++)
   {
     UInt32 index = allFilesMode ? i : indices[i];
-    int entryIndex = m_Database.Indices[index];
-    const CItem &item = m_Database.Items[entryIndex];
-    UInt64 sectionIndex = item.Section;
+    const CItem &item = m_Database.Items[m_Database.Indices[index]];
+    const UInt64 sectionIndex = item.Section;
     if (item.IsDir() || item.Size == 0)
       continue;
     if (sectionIndex == 0)
@@ -511,7 +545,11 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       currentTotalSize += item.Size;
       continue;
     }
-    const CSectionInfo &section = m_Database.Sections[(int)item.Section];
+
+    if (sectionIndex >= m_Database.Sections.Size())
+      continue;
+
+    const CSectionInfo &section = m_Database.Sections[(unsigned)sectionIndex];
     if (section.IsLzx())
     {
       const CLzxInfo &lzxInfo = section.Methods[0].LzxInfo;
@@ -526,25 +564,32 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
   RINOK(extractCallback->SetTotal(currentTotalSize));
 
-  NCompress::NLzx::CDecoder *lzxDecoderSpec = 0;
-  CMyComPtr<ICompressCoder> lzxDecoder;
+  NCompress::NLzx::CDecoder *lzxDecoderSpec = NULL;
+  CMyComPtr<IUnknown> lzxDecoder;
   CChmFolderOutStream *chmFolderOutStream = 0;
   CMyComPtr<ISequentialOutStream> outStream;
 
   currentTotalSize = 0;
 
   CRecordVector<bool> extractStatuses;
-  for (i = 0; i < numItems;)
+
+  CByteBuffer packBuf;
+  
+  for (i = 0;;)
   {
     RINOK(extractCallback->SetCompleted(&currentTotalSize));
+
+    if (i >= numItems)
+      break;
+
     UInt32 index = allFilesMode ? i : indices[i];
     i++;
-    int entryIndex = m_Database.Indices[index];
-    const CItem &item = m_Database.Items[entryIndex];
-    UInt64 sectionIndex = item.Section;
+    const CItem &item = m_Database.Items[m_Database.Indices[index]];
+    const UInt64 sectionIndex = item.Section;
     Int32 askMode= testMode ?
         NExtract::NAskMode::kTest :
         NExtract::NAskMode::kExtract;
+    
     if (item.IsDir())
     {
       CMyComPtr<ISequentialOutStream> realOutStream;
@@ -580,7 +625,19 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       continue;
     }
   
-    const CSectionInfo &section = m_Database.Sections[(int)sectionIndex];
+    if (sectionIndex >= m_Database.Sections.Size())
+    {
+      // we must report error here;
+      CMyComPtr<ISequentialOutStream> realOutStream;
+      RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+      if (!testMode && !realOutStream)
+        continue;
+      RINOK(extractCallback->PrepareOperation(askMode));
+      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kHeadersError));
+      continue;
+    }
+
+    const CSectionInfo &section = m_Database.Sections[(unsigned)sectionIndex];
 
     if (!section.IsLzx())
     {
@@ -589,13 +646,13 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       if (!testMode && !realOutStream)
         continue;
       RINOK(extractCallback->PrepareOperation(askMode));
-      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnSupportedMethod));
+      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod));
       continue;
     }
 
     const CLzxInfo &lzxInfo = section.Methods[0].LzxInfo;
 
-    if (chmFolderOutStream == 0)
+    if (!chmFolderOutStream)
     {
       chmFolderOutStream = new CChmFolderOutStream;
       outStream = chmFolderOutStream;
@@ -603,7 +660,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
     chmFolderOutStream->Init(&m_Database, extractCallback, testMode);
 
-    if (lzxDecoderSpec == NULL)
+    if (!lzxDecoderSpec)
     {
       lzxDecoderSpec = new NCompress::NLzx::CDecoder;
       lzxDecoder = lzxDecoderSpec;
@@ -611,9 +668,8 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
     UInt64 folderIndex = m_Database.GetFolder(index);
 
-    UInt64 compressedPos = m_Database.ContentOffset + section.Offset;
-    UInt32 numDictBits = lzxInfo.GetNumDictBits();
-    RINOK(lzxDecoderSpec->SetParams(numDictBits));
+    const UInt64 compressedPos = m_Database.ContentOffset + section.Offset;
+    RINOK(lzxDecoderSpec->SetParams_and_Alloc(lzxInfo.GetNumDictBits()));
 
     const CItem *lastItem = &item;
     extractStatuses.Clear();
@@ -630,17 +686,18 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       lastFolderIndex = m_Database.GetLastFolder(index);
       UInt64 folderSize = lzxInfo.GetFolderSize();
       UInt64 unPackSize = folderSize;
+      
       if (extractStatuses.IsEmpty())
         chmFolderOutStream->m_StartIndex = index + 1;
       else
         chmFolderOutStream->m_StartIndex = index;
+      
       if (limitFolderIndex == folderIndex)
       {
         for (; i < numItems; i++)
         {
-          UInt32 nextIndex = allFilesMode ? i : indices[i];
-          int entryIndex = m_Database.Indices[nextIndex];
-          const CItem &nextItem = m_Database.Items[entryIndex];
+          const UInt32 nextIndex = allFilesMode ? i : indices[i];
+          const CItem &nextItem = m_Database.Items[m_Database.Indices[nextIndex]];
           if (nextItem.Section != sectionIndex)
             break;
           UInt64 nextFolderIndex = m_Database.GetFolder(nextIndex);
@@ -656,6 +713,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           lastFolderIndex = m_Database.GetLastFolder(index);
         }
       }
+      
       unPackSize = MyMin(finishPos - startPos, unPackSize);
 
       chmFolderOutStream->m_FolderSize = folderSize;
@@ -664,11 +722,13 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       chmFolderOutStream->m_ExtractStatuses = &extractStatuses;
       chmFolderOutStream->m_NumFiles = extractStatuses.Size();
       chmFolderOutStream->m_CurrentIndex = 0;
+      
       try
       {
         UInt64 startBlock = lzxInfo.GetBlockIndexFromFolderIndex(folderIndex);
         const CResetTable &rt = lzxInfo.ResetTable;
         UInt32 numBlocks = (UInt32)rt.GetNumBlocks(unPackSize);
+        
         for (UInt32 b = 0; b < numBlocks; b++)
         {
           UInt64 completedSize = currentTotalSize + chmFolderOutStream->m_PosInSection - startPos;
@@ -676,17 +736,35 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           UInt64 bCur = startBlock + b;
           if (bCur >= rt.ResetOffsets.Size())
             return E_FAIL;
-          UInt64 offset = rt.ResetOffsets[(int)bCur];
+          UInt64 offset = rt.ResetOffsets[(unsigned)bCur];
           UInt64 compressedSize;
           rt.GetCompressedSizeOfBlock(bCur, compressedSize);
-          UInt64 rem = finishPos - chmFolderOutStream->m_PosInSection;
-          if (rem > rt.BlockSize)
-            rem = rt.BlockSize;
+          
+          // chm writes full blocks. So we don't need to use reduced size for last block
+
           RINOK(m_Stream->Seek(compressedPos + offset, STREAM_SEEK_SET, NULL));
           streamSpec->SetStream(m_Stream);
           streamSpec->Init(compressedSize);
+          
           lzxDecoderSpec->SetKeepHistory(b > 0);
-          HRESULT res = lzxDecoder->Code(inStream, outStream, NULL, &rem, NULL);
+      
+          size_t compressedSizeT = (size_t)compressedSize;
+          if (compressedSizeT != compressedSize)
+            throw 2;
+          packBuf.AllocAtLeast(compressedSizeT);
+
+          HRESULT res = ReadStream_FALSE(inStream, packBuf, compressedSizeT);
+          
+          if (res == S_OK)
+          {
+            lzxDecoderSpec->KeepHistoryForNext = true;
+            res = lzxDecoderSpec->Code(packBuf, compressedSizeT, kBlockSize); // rt.BlockSize;
+            if (res == S_OK)
+              res = WriteStream(chmFolderOutStream,
+                  lzxDecoderSpec->GetUnpackData(),
+                  lzxDecoderSpec->GetUnpackSize());
+          }
+          
           if (res != S_OK)
           {
             if (res != S_FALSE)
@@ -699,6 +777,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       {
         RINOK(chmFolderOutStream->FlushCorrupted(unPackSize));
       }
+      
       currentTotalSize += folderSize;
       if (folderIndex == lastFolderIndex)
         break;
@@ -718,4 +797,32 @@ STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
   return S_OK;
 }
 
+namespace NChm {
+
+static const Byte k_Signature[] = { 'I', 'T', 'S', 'F', 3, 0, 0, 0, 0x60, 0,  0, 0 };
+
+REGISTER_ARC_I_CLS(
+  CHandler(false),
+  "Chm", "chm chi chq chw", 0, 0xE9,
+  k_Signature,
+  0,
+  0,
+  NULL)
+
+}
+
+namespace NHxs {
+
+static const Byte k_Signature[] = { 'I', 'T', 'O', 'L', 'I', 'T', 'L', 'S', 1, 0, 0, 0, 0x28, 0, 0, 0 };
+
+REGISTER_ARC_I_CLS(
+  CHandler(true),
+  "Hxs", "hxs hxi hxr hxq hxw lit", 0, 0xCE,
+  k_Signature,
+  0,
+  NArcInfoFlags::kFindSignature,
+  NULL)
+
+}
+
 }}

data/ext/p7zip/CPP/7zip/Archive/Chm/ChmHandler.h

@@ -3,8 +3,10 @@
 #ifndef __ARCHIVE_CHM_HANDLER_H
 #define __ARCHIVE_CHM_HANDLER_H
 
-#include "Common/MyCom.h"
+#include "../../../Common/MyCom.h"
+
 #include "../IArchive.h"
+
 #include "ChmIn.h"
 
 namespace NArchive {
@@ -19,9 +21,13 @@ public:
 
   INTERFACE_IInArchive(;)
 
+  bool _help2;
+  CHandler(bool help2): _help2(help2) {}
+
 private:
   CFilesDatabase m_Database;
   CMyComPtr<IInStream> m_Stream;
+  UInt32 m_ErrorFlags;
 };
 
 }}