Initialer Commit

CPP/7zip/Archive/Chm/ChmHandler.cpp

@@ -0,0 +1,828 @@
+// ChmHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.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"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "ChmHandler.h"
+
+using namespace NWindows;
+using namespace NTime;
+
+namespace NArchive {
+namespace NChm {
+
+// #define _CHM_DETAILS
+
+#ifdef _CHM_DETAILS
+
+enum
+{
+  kpidSection = kpidUserDefined
+};
+
+#endif
+
+static const Byte kProps[] =
+{
+  kpidPath,
+  kpidSize,
+  kpidMethod,
+  kpidBlock
+  
+  #ifdef _CHM_DETAILS
+  ,
+  L"Section", kpidSection,
+  kpidOffset
+  #endif
+};
+
+/*
+static const Byte kArcProps[] =
+{
+  // kpidNumBlocks,
+};
+*/
+
+IMP_IInArchive_Props
+
+IMP_IInArchive_ArcProps_NO_Table
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  // COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    /*
+    case kpidNumBlocks:
+    {
+      UInt64 numBlocks = 0;
+      FOR_VECTOR(i, m_Database.Sections)
+      {
+        const CSectionInfo &s = m_Database.Sections[i];
+        FOR_VECTOR(j, s.Methods)
+        {
+          const CMethodInfo &m = s.Methods[j];
+          if (m.IsLzx())
+            numBlocks += m.LzxInfo.ResetTable.GetNumBlocks();
+        }
+      }
+      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
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  
+  if (m_Database.NewFormat)
+  {
+    switch (propID)
+    {
+      case kpidSize:
+        prop = (UInt64)m_Database.NewFormatString.Len();
+      break;
+    }
+    prop.Detach(value);
+    return S_OK;
+  }
+  
+  unsigned entryIndex;
+  if (m_Database.LowLevel)
+    entryIndex = index;
+  else
+    entryIndex = m_Database.Indices[index];
+  
+  const CItem &item = m_Database.Items[entryIndex];
+  
+  switch (propID)
+  {
+    case kpidPath:
+    {
+      UString us;
+      // if (
+      ConvertUTF8ToUnicode(item.Name, us);
+      {
+        if (!m_Database.LowLevel)
+        {
+          if (us.Len() > 1 && us[0] == L'/')
+            us.Delete(0);
+        }
+        NItemName::ConvertToOSName2(us);
+        prop = us;
+      }
+      break;
+    }
+    case kpidIsDir:  prop = item.IsDir(); break;
+    case kpidSize:  prop = item.Size; break;
+    case kpidMethod:
+    {
+      if (!item.IsDir())
+        if (item.Section == 0)
+          prop = "Copy";
+        else if (item.Section < m_Database.Sections.Size())
+          prop = m_Database.Sections[(unsigned)item.Section].GetMethodName();
+      break;
+    }
+    case kpidBlock:
+      if (m_Database.LowLevel)
+        prop = item.Section;
+      else if (item.Section != 0 && item.Section < m_Database.Sections.Size())
+        prop = m_Database.GetFolder(index);
+      break;
+    
+    #ifdef _CHM_DETAILS
+    
+    case kpidSection:  prop = (UInt32)item.Section; break;
+    case kpidOffset:  prop = (UInt32)item.Offset; break;
+
+    #endif
+  }
+  
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+/*
+class CProgressImp: public CProgressVirt
+{
+  CMyComPtr<IArchiveOpenCallback> _callback;
+public:
+  STDMETHOD(SetTotal)(const UInt64 *numFiles);
+  STDMETHOD(SetCompleted)(const UInt64 *numFiles);
+  CProgressImp(IArchiveOpenCallback *callback): _callback(callback) {};
+};
+
+STDMETHODIMP CProgressImp::SetTotal(const UInt64 *numFiles)
+{
+  if (_callback)
+    return _callback->SetCompleted(numFiles, NULL);
+  return S_OK;
+}
+
+STDMETHODIMP CProgressImp::SetCompleted(const UInt64 *numFiles)
+{
+  if (_callback)
+    return _callback->SetCompleted(numFiles, NULL);
+  return S_OK;
+}
+*/
+
+STDMETHODIMP CHandler::Open(IInStream *inStream,
+    const UInt64 *maxCheckStartPosition,
+    IArchiveOpenCallback * /* openArchiveCallback */)
+{
+  COM_TRY_BEGIN
+  Close();
+  try
+  {
+    CInArchive archive(_help2);
+    // CProgressImp progressImp(openArchiveCallback);
+    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;
+    */
+    m_Stream = inStream;
+  }
+  catch(...)
+  {
+    return S_FALSE;
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  m_ErrorFlags = 0;
+  m_Database.Clear();
+  m_Stream.Release();
+  return S_OK;
+}
+
+class CChmFolderOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP
+
+  HRESULT Write2(const void *data, UInt32 size, UInt32 *processedSize, bool isOK);
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+
+  UInt64 m_FolderSize;
+  UInt64 m_PosInFolder;
+  UInt64 m_PosInSection;
+  const CRecordVector<bool> *m_ExtractStatuses;
+  unsigned m_StartIndex;
+  unsigned m_CurrentIndex;
+  unsigned m_NumFiles;
+
+private:
+  const CFilesDatabase *m_Database;
+  CMyComPtr<IArchiveExtractCallback> m_ExtractCallback;
+  bool m_TestMode;
+
+  bool m_IsOk;
+  bool m_FileIsOpen;
+  UInt64 m_RemainFileSize;
+  CMyComPtr<ISequentialOutStream> m_RealOutStream;
+
+  HRESULT OpenFile();
+  HRESULT WriteEmptyFiles();
+public:
+  void Init(
+    const CFilesDatabase *database,
+    IArchiveExtractCallback *extractCallback,
+    bool testMode);
+  HRESULT FlushCorrupted(UInt64 maxSize);
+};
+
+void CChmFolderOutStream::Init(
+    const CFilesDatabase *database,
+    IArchiveExtractCallback *extractCallback,
+    bool testMode)
+{
+  m_Database = database;
+  m_ExtractCallback = extractCallback;
+  m_TestMode = testMode;
+
+  m_CurrentIndex = 0;
+  m_FileIsOpen = false;
+}
+
+HRESULT CChmFolderOutStream::OpenFile()
+{
+  Int32 askMode = (*m_ExtractStatuses)[m_CurrentIndex] ? (m_TestMode ?
+      NExtract::NAskMode::kTest :
+      NExtract::NAskMode::kExtract) :
+      NExtract::NAskMode::kSkip;
+  m_RealOutStream.Release();
+  RINOK(m_ExtractCallback->GetStream(m_StartIndex + m_CurrentIndex, &m_RealOutStream, askMode));
+  if (!m_RealOutStream && !m_TestMode)
+    askMode = NExtract::NAskMode::kSkip;
+  return m_ExtractCallback->PrepareOperation(askMode);
+}
+
+HRESULT CChmFolderOutStream::WriteEmptyFiles()
+{
+  if (m_FileIsOpen)
+    return S_OK;
+  for (; m_CurrentIndex < m_NumFiles; m_CurrentIndex++)
+  {
+    UInt64 fileSize = m_Database->GetFileSize(m_StartIndex + m_CurrentIndex);
+    if (fileSize != 0)
+      return S_OK;
+    HRESULT result = OpenFile();
+    m_RealOutStream.Release();
+    RINOK(result);
+    RINOK(m_ExtractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
+  }
+  return S_OK;
+}
+
+// This is WritePart function
+HRESULT CChmFolderOutStream::Write2(const void *data, UInt32 size, UInt32 *processedSize, bool isOK)
+{
+  UInt32 realProcessed = 0;
+  if (processedSize)
+   *processedSize = 0;
+  
+  while (size != 0)
+  {
+    if (m_FileIsOpen)
+    {
+      UInt32 numBytesToWrite = (UInt32)MyMin(m_RemainFileSize, (UInt64)(size));
+      HRESULT res = S_OK;
+      if (numBytesToWrite > 0)
+      {
+        if (!isOK)
+          m_IsOk = false;
+        if (m_RealOutStream)
+        {
+          UInt32 processedSizeLocal = 0;
+          res = m_RealOutStream->Write((const Byte *)data, numBytesToWrite, &processedSizeLocal);
+          numBytesToWrite = processedSizeLocal;
+        }
+      }
+      realProcessed += numBytesToWrite;
+      if (processedSize)
+        *processedSize = realProcessed;
+      data = (const void *)((const Byte *)data + numBytesToWrite);
+      size -= numBytesToWrite;
+      m_RemainFileSize -= numBytesToWrite;
+      m_PosInSection += numBytesToWrite;
+      m_PosInFolder += numBytesToWrite;
+      if (res != S_OK)
+        return res;
+      if (m_RemainFileSize == 0)
+      {
+        m_RealOutStream.Release();
+        RINOK(m_ExtractCallback->SetOperationResult(
+          m_IsOk ?
+            NExtract::NOperationResult::kOK:
+            NExtract::NOperationResult::kDataError));
+        m_FileIsOpen = false;
+      }
+      if (realProcessed > 0)
+        break; // with this break this function works as write part
+    }
+    else
+    {
+      if (m_CurrentIndex >= m_NumFiles)
+      {
+        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)
+          *processedSize = realProcessed;
+        data = (const void *)((const Byte *)data + numBytesToWrite);
+        size -= numBytesToWrite;
+        m_PosInSection += numBytesToWrite;
+        m_PosInFolder += numBytesToWrite;
+      }
+      
+      if (fileOffset == m_PosInSection)
+      {
+        RINOK(OpenFile());
+        m_FileIsOpen = true;
+        m_CurrentIndex++;
+        m_IsOk = true;
+      }
+    }
+  }
+  
+  return WriteEmptyFiles();
+}
+
+STDMETHODIMP CChmFolderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  return Write2(data, size, processedSize, true);
+}
+
+HRESULT CChmFolderOutStream::FlushCorrupted(UInt64 maxSize)
+{
+  const UInt32 kBufferSize = (1 << 10);
+  Byte buffer[kBufferSize];
+  for (unsigned i = 0; i < kBufferSize; i++)
+    buffer[i] = 0;
+  if (maxSize > m_FolderSize)
+    maxSize = m_FolderSize;
+  while (m_PosInFolder < maxSize)
+  {
+    UInt32 size = (UInt32)MyMin(maxSize - m_PosInFolder, (UInt64)kBufferSize);
+    UInt32 processedSizeLocal = 0;
+    RINOK(Write2(buffer, size, &processedSizeLocal, false));
+    if (processedSizeLocal == 0)
+      return S_OK;
+  }
+  return S_OK;
+}
+
+
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testModeSpec, IArchiveExtractCallback *extractCallback)
+{
+  COM_TRY_BEGIN
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+
+  if (allFilesMode)
+    numItems = m_Database.NewFormat ? 1:
+      (m_Database.LowLevel ?
+      m_Database.Items.Size():
+      m_Database.Indices.Size());
+  if (numItems == 0)
+    return S_OK;
+  bool testMode = (testModeSpec != 0);
+
+  UInt64 currentTotalSize = 0;
+
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+  UInt32 i;
+
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
+  lps->Init(extractCallback, false);
+
+  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+  CMyComPtr<ISequentialInStream> inStream(streamSpec);
+  streamSpec->SetStream(m_Stream);
+
+  if (m_Database.LowLevel)
+  {
+    UInt64 currentItemSize = 0;
+    UInt64 totalSize = 0;
+    
+    if (m_Database.NewFormat)
+      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)
+    {
+      currentItemSize = 0;
+      lps->InSize = currentTotalSize; // Change it
+      lps->OutSize = currentTotalSize;
+
+      RINOK(lps->SetCur());
+      CMyComPtr<ISequentialOutStream> realOutStream;
+      Int32 askMode= testMode ?
+          NExtract::NAskMode::kTest :
+          NExtract::NAskMode::kExtract;
+      Int32 index = allFilesMode ? i : indices[i];
+      RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+
+      if (m_Database.NewFormat)
+      {
+        if (index != 0)
+          return E_FAIL;
+        if (!testMode && !realOutStream)
+          continue;
+        if (!testMode)
+        {
+          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;
+      
+      if (!testMode && !realOutStream)
+        continue;
+      RINOK(extractCallback->PrepareOperation(askMode));
+      if (item.Section != 0)
+      {
+        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod));
+        continue;
+      }
+
+      if (testMode)
+      {
+        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
+        continue;
+      }
+      
+      RINOK(m_Stream->Seek(m_Database.ContentOffset + item.Offset, STREAM_SEEK_SET, NULL));
+      streamSpec->Init(item.Size);
+      
+      RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress));
+      realOutStream.Release();
+      RINOK(extractCallback->SetOperationResult((copyCoderSpec->TotalSize == item.Size) ?
+          NExtract::NOperationResult::kOK:
+          NExtract::NOperationResult::kDataError));
+    }
+    return S_OK;
+  }
+  
+  UInt64 lastFolderIndex = ((UInt64)0 - 1);
+  
+  for (i = 0; i < numItems; i++)
+  {
+    UInt32 index = allFilesMode ? i : indices[i];
+    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)
+    {
+      currentTotalSize += item.Size;
+      continue;
+    }
+
+    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;
+      UInt64 folderIndex = m_Database.GetFolder(index);
+      if (lastFolderIndex == folderIndex)
+        folderIndex++;
+      lastFolderIndex = m_Database.GetLastFolder(index);
+      for (; folderIndex <= lastFolderIndex; folderIndex++)
+        currentTotalSize += lzxInfo.GetFolderSize();
+    }
+  }
+
+  RINOK(extractCallback->SetTotal(currentTotalSize));
+
+  NCompress::NLzx::CDecoder *lzxDecoderSpec = NULL;
+  CMyComPtr<IUnknown> lzxDecoder;
+  CChmFolderOutStream *chmFolderOutStream = 0;
+  CMyComPtr<ISequentialOutStream> outStream;
+
+  currentTotalSize = 0;
+
+  CRecordVector<bool> extractStatuses;
+
+  CByteBuffer packBuf;
+  
+  for (i = 0;;)
+  {
+    RINOK(extractCallback->SetCompleted(&currentTotalSize));
+
+    if (i >= numItems)
+      break;
+
+    UInt32 index = allFilesMode ? i : indices[i];
+    i++;
+    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;
+      RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+      RINOK(extractCallback->PrepareOperation(askMode));
+      realOutStream.Release();
+      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
+      continue;
+    }
+
+    lps->InSize = currentTotalSize; // Change it
+    lps->OutSize = currentTotalSize;
+
+    if (item.Size == 0 || sectionIndex == 0)
+    {
+      CMyComPtr<ISequentialOutStream> realOutStream;
+      RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+      if (!testMode && !realOutStream)
+        continue;
+      RINOK(extractCallback->PrepareOperation(askMode));
+      Int32 opRes = NExtract::NOperationResult::kOK;
+      if (!testMode && item.Size != 0)
+      {
+        RINOK(m_Stream->Seek(m_Database.ContentOffset + item.Offset, STREAM_SEEK_SET, NULL));
+        streamSpec->Init(item.Size);
+        RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress));
+        if (copyCoderSpec->TotalSize != item.Size)
+          opRes = NExtract::NOperationResult::kDataError;
+      }
+      realOutStream.Release();
+      RINOK(extractCallback->SetOperationResult(opRes));
+      currentTotalSize += item.Size;
+      continue;
+    }
+  
+    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())
+    {
+      CMyComPtr<ISequentialOutStream> realOutStream;
+      RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+      if (!testMode && !realOutStream)
+        continue;
+      RINOK(extractCallback->PrepareOperation(askMode));
+      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod));
+      continue;
+    }
+
+    const CLzxInfo &lzxInfo = section.Methods[0].LzxInfo;
+
+    if (!chmFolderOutStream)
+    {
+      chmFolderOutStream = new CChmFolderOutStream;
+      outStream = chmFolderOutStream;
+    }
+
+    chmFolderOutStream->Init(&m_Database, extractCallback, testMode);
+
+    if (!lzxDecoderSpec)
+    {
+      lzxDecoderSpec = new NCompress::NLzx::CDecoder;
+      lzxDecoder = lzxDecoderSpec;
+    }
+
+    UInt64 folderIndex = m_Database.GetFolder(index);
+
+    const UInt64 compressedPos = m_Database.ContentOffset + section.Offset;
+    RINOK(lzxDecoderSpec->SetParams_and_Alloc(lzxInfo.GetNumDictBits()));
+
+    const CItem *lastItem = &item;
+    extractStatuses.Clear();
+    extractStatuses.Add(true);
+
+    for (;; folderIndex++)
+    {
+      RINOK(extractCallback->SetCompleted(&currentTotalSize));
+
+      UInt64 startPos = lzxInfo.GetFolderPos(folderIndex);
+      UInt64 finishPos = lastItem->Offset + lastItem->Size;
+      UInt64 limitFolderIndex = lzxInfo.GetFolder(finishPos);
+
+      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++)
+        {
+          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);
+          if (nextFolderIndex != folderIndex)
+            break;
+          for (index++; index < nextIndex; index++)
+            extractStatuses.Add(false);
+          extractStatuses.Add(true);
+          index = nextIndex;
+          lastItem = &nextItem;
+          if (nextItem.Size != 0)
+            finishPos = nextItem.Offset + nextItem.Size;
+          lastFolderIndex = m_Database.GetLastFolder(index);
+        }
+      }
+      
+      unPackSize = MyMin(finishPos - startPos, unPackSize);
+
+      chmFolderOutStream->m_FolderSize = folderSize;
+      chmFolderOutStream->m_PosInFolder = 0;
+      chmFolderOutStream->m_PosInSection = startPos;
+      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;
+          RINOK(extractCallback->SetCompleted(&completedSize));
+          UInt64 bCur = startBlock + b;
+          if (bCur >= rt.ResetOffsets.Size())
+            return E_FAIL;
+          UInt64 offset = rt.ResetOffsets[(unsigned)bCur];
+          UInt64 compressedSize;
+          rt.GetCompressedSizeOfBlock(bCur, compressedSize);
+          
+          // 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);
+      
+          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)
+              return res;
+            throw 1;
+          }
+        }
+      }
+      catch(...)
+      {
+        RINOK(chmFolderOutStream->FlushCorrupted(unPackSize));
+      }
+      
+      currentTotalSize += folderSize;
+      if (folderIndex == lastFolderIndex)
+        break;
+      extractStatuses.Clear();
+    }
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+    *numItems = m_Database.NewFormat ? 1:
+      (m_Database.LowLevel ?
+      m_Database.Items.Size():
+      m_Database.Indices.Size());
+  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)
+
+}
+
+}}

CPP/7zip/Archive/Chm/ChmHandler.h

@@ -0,0 +1,35 @@
+// ChmHandler.h
+
+#ifndef __ARCHIVE_CHM_HANDLER_H
+#define __ARCHIVE_CHM_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../IArchive.h"
+
+#include "ChmIn.h"
+
+namespace NArchive {
+namespace NChm {
+
+class CHandler:
+  public IInArchive,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1(IInArchive)
+
+  INTERFACE_IInArchive(;)
+
+  bool _help2;
+  CHandler(bool help2): _help2(help2) {}
+
+private:
+  CFilesDatabase m_Database;
+  CMyComPtr<IInStream> m_Stream;
+  UInt32 m_ErrorFlags;
+};
+
+}}
+
+#endif

CPP/7zip/Archive/Chm/ChmIn.h

@@ -0,0 +1,270 @@
+// Archive/ChmIn.h
+
+#ifndef __ARCHIVE_CHM_IN_H
+#define __ARCHIVE_CHM_IN_H
+
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyString.h"
+
+#include "../../IStream.h"
+
+#include "../../Common/InBuffer.h"
+
+namespace NArchive {
+namespace NChm {
+
+struct CItem
+{
+  UInt64 Section;
+  UInt64 Offset;
+  UInt64 Size;
+  AString Name;
+
+  bool IsFormatRelatedItem() const
+  {
+    if (Name.Len() < 2)
+      return false;
+    return Name[0] == ':' && Name[1] == ':';
+  }
+  
+  bool IsUserItem() const
+  {
+    if (Name.Len() < 2)
+      return false;
+    return Name[0] == '/';
+  }
+  
+  bool IsDir() const
+  {
+    if (Name.IsEmpty())
+      return false;
+    return (Name.Back() == '/');
+  }
+};
+
+
+struct CDatabase
+{
+  UInt64 StartPosition;
+  UInt64 ContentOffset;
+  CObjectVector<CItem> Items;
+  AString NewFormatString;
+  bool Help2Format;
+  bool NewFormat;
+  UInt64 PhySize;
+
+  void UpdatePhySize(UInt64 v) { if (PhySize < v) PhySize = v; }
+
+  int FindItem(const AString &name) const
+  {
+    FOR_VECTOR (i, Items)
+      if (Items[i].Name == name)
+        return i;
+    return -1;
+  }
+
+  void Clear()
+  {
+    NewFormat = false;
+    NewFormatString.Empty();
+    Help2Format = false;
+    Items.Clear();
+    StartPosition = 0;
+    PhySize = 0;
+  }
+};
+
+
+const UInt32 kBlockSize = 1 << 15;
+
+struct CResetTable
+{
+  UInt64 UncompressedSize;
+  UInt64 CompressedSize;
+  // unsigned BlockSizeBits;
+  CRecordVector<UInt64> ResetOffsets;
+  
+  bool GetCompressedSizeOfBlocks(UInt64 blockIndex, UInt32 numBlocks, UInt64 &size) const
+  {
+    if (blockIndex >= ResetOffsets.Size())
+      return false;
+    UInt64 startPos = ResetOffsets[(unsigned)blockIndex];
+    if (blockIndex + numBlocks >= ResetOffsets.Size())
+      size = CompressedSize - startPos;
+    else
+      size = ResetOffsets[(unsigned)(blockIndex + numBlocks)] - startPos;
+    return true;
+  }
+
+  bool GetCompressedSizeOfBlock(UInt64 blockIndex, UInt64 &size) const
+  {
+    return GetCompressedSizeOfBlocks(blockIndex, 1, size);
+  }
+  
+  UInt64 GetNumBlocks(UInt64 size) const
+  {
+    return (size + kBlockSize - 1) / kBlockSize;
+  }
+};
+
+
+struct CLzxInfo
+{
+  UInt32 Version;
+  
+  unsigned ResetIntervalBits;
+  unsigned WindowSizeBits;
+  UInt32 CacheSize;
+  
+  CResetTable ResetTable;
+
+  unsigned GetNumDictBits() const
+  {
+    if (Version == 2 || Version == 3)
+      return 15 + WindowSizeBits;
+    return 0;
+  }
+
+  UInt64 GetFolderSize() const { return kBlockSize << ResetIntervalBits; }
+  UInt64 GetFolder(UInt64 offset) const { return offset / GetFolderSize(); }
+  UInt64 GetFolderPos(UInt64 folderIndex) const { return folderIndex * GetFolderSize(); }
+  UInt64 GetBlockIndexFromFolderIndex(UInt64 folderIndex) const { return folderIndex << ResetIntervalBits; }
+
+  bool GetOffsetOfFolder(UInt64 folderIndex, UInt64 &offset) const
+  {
+    UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
+    if (blockIndex >= ResetTable.ResetOffsets.Size())
+      return false;
+    offset = ResetTable.ResetOffsets[(unsigned)blockIndex];
+    return true;
+  }
+  
+  bool GetCompressedSizeOfFolder(UInt64 folderIndex, UInt64 &size) const
+  {
+    UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
+    return ResetTable.GetCompressedSizeOfBlocks(blockIndex, (UInt32)1 << ResetIntervalBits, size);
+  }
+};
+
+
+struct CMethodInfo
+{
+  GUID Guid;
+  CByteBuffer ControlData;
+  CLzxInfo LzxInfo;
+  
+  bool IsLzx() const;
+  bool IsDes() const;
+  AString GetGuidString() const;
+  UString GetName() const;
+};
+
+
+struct CSectionInfo
+{
+  UInt64 Offset;
+  UInt64 CompressedSize;
+  UInt64 UncompressedSize;
+
+  AString Name;
+  CObjectVector<CMethodInfo> Methods;
+
+  bool IsLzx() const;
+  UString GetMethodName() const;
+};
+
+class CFilesDatabase: public CDatabase
+{
+public:
+  bool LowLevel;
+  CUIntVector Indices;
+  CObjectVector<CSectionInfo> Sections;
+
+  UInt64 GetFileSize(unsigned fileIndex) const { return Items[Indices[fileIndex]].Size; }
+  UInt64 GetFileOffset(unsigned fileIndex) const { return Items[Indices[fileIndex]].Offset; }
+
+  UInt64 GetFolder(unsigned fileIndex) const
+  {
+    const CItem &item = Items[Indices[fileIndex]];
+    if (item.Section < Sections.Size())
+    {
+      const CSectionInfo &section = Sections[(unsigned)item.Section];
+      if (section.IsLzx())
+        return section.Methods[0].LzxInfo.GetFolder(item.Offset);
+    }
+    return 0;
+  }
+
+  UInt64 GetLastFolder(unsigned fileIndex) const
+  {
+    const CItem &item = Items[Indices[fileIndex]];
+    if (item.Section < Sections.Size())
+    {
+      const CSectionInfo &section = Sections[(unsigned)item.Section];
+      if (section.IsLzx())
+        return section.Methods[0].LzxInfo.GetFolder(item.Offset + item.Size - 1);
+    }
+    return 0;
+  }
+
+  void HighLevelClear()
+  {
+    LowLevel = true;
+    Indices.Clear();
+    Sections.Clear();
+  }
+
+  void Clear()
+  {
+    CDatabase::Clear();
+    HighLevelClear();
+  }
+  
+  void SetIndices();
+  void Sort();
+  bool Check();
+  bool CheckSectionRefs();
+};
+
+
+class CInArchive
+{
+  CMyComPtr<ISequentialInStream> m_InStreamRef;
+  ::CInBuffer _inBuffer;
+  UInt64 _chunkSize;
+  bool _help2;
+
+  Byte ReadByte();
+  void ReadBytes(Byte *data, UInt32 size);
+  void Skip(size_t size);
+  UInt16 ReadUInt16();
+  UInt32 ReadUInt32();
+  UInt64 ReadUInt64();
+  UInt64 ReadEncInt();
+  void ReadString(unsigned size, AString &s);
+  void ReadUString(unsigned size, UString &s);
+  void ReadGUID(GUID &g);
+
+  HRESULT ReadChunk(IInStream *inStream, UInt64 pos, UInt64 size);
+
+  HRESULT ReadDirEntry(CDatabase &database);
+  HRESULT DecompressStream(IInStream *inStream, const CDatabase &database, const AString &name);
+
+public:
+  bool IsArc;
+  bool HeadersError;
+  bool UnexpectedEnd;
+  bool UnsupportedFeature;
+
+  CInArchive(bool help2) { _help2 = help2; }
+
+  HRESULT OpenChm(IInStream *inStream, CDatabase &database);
+  HRESULT OpenHelp2(IInStream *inStream, CDatabase &database);
+  HRESULT OpenHighLevel(IInStream *inStream, CFilesDatabase &database);
+  HRESULT Open2(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
+  HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
+};
+  
+}}
+  
+#endif

CPP/7zip/Archive/Chm/StdAfx.h

@@ -0,0 +1,8 @@
+// StdAfx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+#include "../../../Common/Common.h"
+
+#endif