seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/CramfsHandler.cpp

@@ -3,13 +3,15 @@
 #include "StdAfx.h"
 
 #include "../../../C/7zCrc.h"
-#include "../../../C/CpuArch.h"
 #include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+#include "../../../C/LzmaDec.h"
 
-#include "Common/ComTry.h"
-#include "Common/StringConvert.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/StringConvert.h"
 
-#include "Windows/PropVariantUtils.h"
+#include "../../Windows/PropVariantUtils.h"
 
 #include "../Common/LimitedStreams.h"
 #include "../Common/ProgressUtils.h"
@@ -25,8 +27,7 @@ namespace NCramfs {
 
 #define SIGNATURE { 'C','o','m','p','r','e','s','s','e','d',' ','R','O','M','F','S' }
 
-static const UInt32 kSignatureSize = 16;
-static const char kSignature[kSignatureSize] = SIGNATURE;
+static const Byte kSignature[] = SIGNATURE;
 
 static const UInt32 kArcSizeMax = (256 + 16) << 20;
 static const UInt32 kNumFilesMax = (1 << 19);
@@ -38,6 +39,30 @@ static const UInt32 kNodeSize = 12;
 
 static const UInt32 kFlag_FsVer2 = (1 << 0);
 
+static const unsigned k_Flags_BlockSize_Shift = 11;
+static const unsigned k_Flags_BlockSize_Mask = 7;
+static const unsigned k_Flags_Method_Shift = 14;
+static const unsigned k_Flags_Method_Mask = 3;
+
+/*
+  There is possible collision in flags:
+    - Original CramFS writes 0 in method field. But it uses ZLIB.
+    - Modified CramFS writes 0 in method field for "NONE" compression?
+  How to solve that collision?
+*/
+
+#define k_Flags_Method_NONE 0
+#define k_Flags_Method_ZLIB 1
+#define k_Flags_Method_LZMA 2
+
+static const char * const k_Methods[] =
+{
+    "Copy"
+  , "ZLIB"
+  , "LZMA"
+  , "Unknown"
+};
+
 static const CUInt32PCharPair k_Flags[] =
 {
   { 0, "Ver2" },
@@ -48,7 +73,6 @@ static const CUInt32PCharPair k_Flags[] =
 };
 
 static const unsigned kBlockSizeLog = 12;
-static const UInt32 kBlockSize = 1 << kBlockSizeLog;
 
 /*
 struct CNode
@@ -75,7 +99,7 @@ struct CNode
 #define Get32(p) (be ? GetBe32(p) : GetUi32(p))
 
 static UInt32 GetMode(const Byte *p, bool be) { return be ? GetBe16(p) : GetUi16(p); }
-static bool IsDir(const Byte *p, bool be) { return (GetMode(p, be) & 0xF000) == 0x4000; }
+static bool IsDir(const Byte *p, bool be) { return MY_LIN_S_ISDIR(GetMode(p, be)); }
 
 static UInt32 GetSize(const Byte *p, bool be)
 {
@@ -121,9 +145,9 @@ struct CHeader
 
   bool Parse(const Byte *p)
   {
-    if (memcmp(p + 16, kSignature, kSignatureSize) != 0)
+    if (memcmp(p + 16, kSignature, ARRAY_SIZE(kSignature)) != 0)
       return false;
-    switch(GetUi32(p))
+    switch (GetUi32(p))
     {
       case 0x28CD3D45: be = false; break;
       case 0x453DCD28: be = true; break;
@@ -141,6 +165,8 @@ struct CHeader
   }
 
   bool IsVer2() const { return (Flags & kFlag_FsVer2) != 0; }
+  unsigned GetBlockSizeShift() const { return (unsigned)(Flags >> k_Flags_BlockSize_Shift) & k_Flags_BlockSize_Mask; }
+  unsigned GetMethod() const { return (unsigned)(Flags >> k_Flags_Method_Shift) & k_Flags_Method_Mask; }
 };
 
 class CHandler:
@@ -153,14 +179,21 @@ class CHandler:
   Byte *_data;
   UInt32 _size;
   UInt32 _headersSize;
-  AString _errorMessage;
+
+  UInt32 _errorFlags;
+  bool _isArc;
+
   CHeader _h;
+  UInt32 _phySize;
+
+  unsigned _method;
+  unsigned _blockSizeLog;
 
   // Current file
 
   NCompress::NZlib::CDecoder *_zlibDecoderSpec;
   CMyComPtr<ICompressCoder> _zlibDecoder;
-  
+
   CBufInStream *_inStreamSpec;
   CMyComPtr<ISequentialInStream> _inStream;
 
@@ -175,6 +208,18 @@ class CHandler:
   AString GetPath(int index) const;
   bool GetPackSize(int index, UInt32 &res) const;
   void Free();
+
+  UInt32 GetNumBlocks(UInt32 size) const
+  {
+    return (size + ((UInt32)1 << _blockSizeLog) - 1) >> _blockSizeLog;
+  }
+
+  void UpdatePhySize(UInt32 s)
+  {
+    if (_phySize < s)
+      _phySize = s;
+  }
+
 public:
   CHandler(): _data(0) {}
   ~CHandler() { Free(); }
@@ -184,25 +229,26 @@ public:
   HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize);
 };
 
-static const STATPROPSTG kProps[] =
+static const Byte kProps[] =
 {
-  { NULL, kpidPath, VT_BSTR},
-  { NULL, kpidIsDir, VT_BOOL},
-  { NULL, kpidSize, VT_UI4},
-  { NULL, kpidPackSize, VT_UI4},
-  { NULL, kpidPosixAttrib, VT_UI4}
-  // { NULL, kpidOffset, VT_UI4}
+  kpidPath,
+  kpidIsDir,
+  kpidSize,
+  kpidPackSize,
+  kpidPosixAttrib
+  // kpidOffset
 };
 
-static const STATPROPSTG kArcProps[] =
+static const Byte kArcProps[] =
 {
-  { NULL, kpidName, VT_BSTR},
-  { NULL, kpidBigEndian, VT_BOOL},
-  { NULL, kpidCharacts, VT_BSTR},
-  { NULL, kpidPhySize, VT_UI4},
-  { NULL, kpidHeadersSize, VT_UI4},
-  { NULL, kpidNumSubFiles, VT_UI4},
-  { NULL, kpidNumBlocks, VT_UI4}
+  kpidVolumeName,
+  kpidBigEndian,
+  kpidCharacts,
+  kpidClusterSize,
+  kpidMethod,
+  kpidHeadersSize,
+  kpidNumSubFiles,
+  kpidNumBlocks
 };
 
 IMP_IInArchive_Props
@@ -221,10 +267,11 @@ HRESULT CHandler::OpenDir(int parent, UInt32 baseOffset, unsigned level)
   UInt32 end = offset + size;
   if (offset < kHeaderSize || end > _size || level > kNumDirLevelsMax)
     return S_FALSE;
+  UpdatePhySize(end);
   if (end > _headersSize)
     _headersSize = end;
 
-  int startIndex = _items.Size();
+  unsigned startIndex = _items.Size();
   
   while (size != 0)
   {
@@ -241,8 +288,8 @@ HRESULT CHandler::OpenDir(int parent, UInt32 baseOffset, unsigned level)
     size -= nodeLen;
   }
 
-  int endIndex = _items.Size();
-  for (int i = startIndex; i < endIndex; i++)
+  unsigned endIndex = _items.Size();
+  for (unsigned i = startIndex; i < endIndex; i++)
   {
     RINOK(OpenDir(i, _items[i].Offset, level + 1));
   }
@@ -255,17 +302,26 @@ HRESULT CHandler::Open2(IInStream *inStream)
   RINOK(ReadStream_FALSE(inStream, buf, kHeaderSize));
   if (!_h.Parse(buf))
     return S_FALSE;
+  _method = k_Flags_Method_ZLIB;
+  _blockSizeLog = kBlockSizeLog;
+  _phySize = kHeaderSize;
   if (_h.IsVer2())
   {
+    _method = _h.GetMethod();
+    // FIT IT. Now we don't know correct way to work with collision in method field.
+    if (_method == k_Flags_Method_NONE)
+      _method = k_Flags_Method_ZLIB;
+    _blockSizeLog = kBlockSizeLog + _h.GetBlockSizeShift();
     if (_h.Size < kHeaderSize || _h.Size > kArcSizeMax || _h.NumFiles > kNumFilesMax)
       return S_FALSE;
+    _phySize = _h.Size;
   }
   else
   {
     UInt64 size;
     RINOK(inStream->Seek(0, STREAM_SEEK_END, &size));
     if (size > kArcSizeMax)
-      return S_FALSE;
+      size = kArcSizeMax;
     _h.Size = (UInt32)size;
     RINOK(inStream->Seek(kHeaderSize, STREAM_SEEK_SET, NULL));
   }
@@ -278,18 +334,59 @@ HRESULT CHandler::Open2(IInStream *inStream)
   if (processed < kNodeSize)
     return S_FALSE;
   _size = kHeaderSize + (UInt32)processed;
-  if (_size != _h.Size)
-    _errorMessage = "Unexpected end of archive";
-  else
+  if (_h.IsVer2())
   {
-    SetUi32(_data + 0x20, 0);
-    if (_h.IsVer2())
+    if (_size != _h.Size)
+      _errorFlags = kpv_ErrorFlags_UnexpectedEnd;
+    else
+    {
+      SetUi32(_data + 0x20, 0);
       if (CrcCalc(_data, _h.Size) != _h.Crc)
-        _errorMessage = "CRC error";
+      {
+        _errorFlags = kpv_ErrorFlags_HeadersError;
+        // _errorMessage = "CRC error";
+      }
+    }
+    if (_h.NumFiles >= 1)
+      _items.ClearAndReserve(_h.NumFiles - 1);
   }
-  if (_h.IsVer2())
-    _items.Reserve(_h.NumFiles - 1);
-  return OpenDir(-1, kHeaderSize, 0);
+  
+  RINOK(OpenDir(-1, kHeaderSize, 0));
+  
+  if (!_h.IsVer2())
+  {
+    FOR_VECTOR (i, _items)
+    {
+      const CItem &item = _items[i];
+      const Byte *p = _data + item.Offset;
+      bool be = _h.be;
+      if (IsDir(p, be))
+        continue;
+      UInt32 offset = GetOffset(p, be);
+      if (offset < kHeaderSize)
+        continue;
+      UInt32 numBlocks = GetNumBlocks(GetSize(p, be));
+      if (numBlocks == 0)
+        continue;
+      UInt32 start = offset + numBlocks * 4;
+      if (start > _size)
+        continue;
+      UInt32 end = Get32(_data + start - 4);
+      if (end >= start)
+        UpdatePhySize(end);
+    }
+
+    // Read tailing zeros. Most cramfs archives use 4096-bytes aligned zeros
+    const UInt32 kTailSize_MAX = 1 << 12;
+    UInt32 endPos = (_phySize + kTailSize_MAX - 1) & ~(kTailSize_MAX - 1);
+    if (endPos > _size)
+      endPos = _size;
+    UInt32 pos;
+    for (pos = _phySize; pos < endPos && _data[pos] == 0; pos++);
+    if (pos == endPos)
+      _phySize = endPos;
+  }
+  return S_OK;
 }
 
 AString CHandler::GetPath(int index) const
@@ -311,7 +408,7 @@ AString CHandler::GetPath(int index) const
   len--;
 
   AString path;
-  char *dest = path.GetBuffer(len) + len;
+  char *dest = path.GetBuf_SetEnd(len) + len;
   index = indexMem;
   for (;;)
   {
@@ -328,19 +425,21 @@ AString CHandler::GetPath(int index) const
       break;
     *(--dest) = CHAR_PATH_SEPARATOR;
   }
-  path.ReleaseBuffer(len);
   return path;
 }
 
 bool CHandler::GetPackSize(int index, UInt32 &res) const
 {
+  res = 0;
   const CItem &item = _items[index];
   const Byte *p = _data + item.Offset;
   bool be = _h.be;
   UInt32 offset = GetOffset(p, be);
   if (offset < kHeaderSize)
     return false;
-  UInt32 numBlocks = (GetSize(p, be) + kBlockSize - 1) >> kBlockSizeLog;
+  UInt32 numBlocks = GetNumBlocks(GetSize(p, be));
+  if (numBlocks == 0)
+    return true;
   UInt32 start = offset + numBlocks * 4;
   if (start > _size)
     return false;
@@ -357,6 +456,7 @@ STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
   {
     Close();
     RINOK(Open2(stream));
+    _isArc = true;
     _stream = stream;
   }
   return S_OK;
@@ -371,10 +471,12 @@ void CHandler::Free()
 
 STDMETHODIMP CHandler::Close()
 {
+  _isArc = false;
+  _phySize = 0;
+  _errorFlags = 0;
   _headersSize = 0;
   _items.Clear();
   _stream.Release();
-  _errorMessage.Empty();
   Free();
   return S_OK;
 }
@@ -389,9 +491,9 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
   NWindows::NCOM::CPropVariant prop;
-  switch(propID)
+  switch (propID)
   {
-    case kpidName:
+    case kpidVolumeName:
     {
       char dest[kHeaderNameSize + 4];
       memcpy(dest, _h.Name, kHeaderNameSize);
@@ -401,11 +503,20 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
     }
     case kpidBigEndian: prop = _h.be; break;
     case kpidCharacts: FLAGS_TO_PROP(k_Flags, _h.Flags, prop); break;
+    case kpidMethod: prop = k_Methods[_method]; break;
+    case kpidClusterSize: prop = (UInt32)1 << _blockSizeLog; break;
     case kpidNumBlocks: if (_h.IsVer2()) prop = _h.NumBlocks; break;
     case kpidNumSubFiles: if (_h.IsVer2()) prop = _h.NumFiles; break;
-    case kpidPhySize: if (_h.IsVer2()) prop = _h.Size; break;
+    case kpidPhySize: prop = _phySize; break;
     case kpidHeadersSize: prop = _headersSize; break;
-    case kpidError: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
+    case kpidErrorFlags:
+    {
+      UInt32 v = _errorFlags;
+      if (!_isArc)
+        v |= kpv_ErrorFlags_IsNotArc;
+      prop = v;
+      break;
+    }
   }
   prop.Detach(value);
   return S_OK;
@@ -420,7 +531,7 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
   const Byte *p = _data + item.Offset;
   bool be = _h.be;
   bool isDir = IsDir(p, be);
-  switch(propID)
+  switch (propID)
   {
     case kpidPath: prop = MultiByteToUnicodeString(GetPath(index), CP_OEMCP); break;
     case kpidIsDir: prop = isDir; break;
@@ -455,11 +566,54 @@ HRESULT CCramfsInStream::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSi
 
 HRESULT CHandler::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
 {
-  if (!_zlibDecoder)
+  if (_method == k_Flags_Method_ZLIB)
   {
-    _zlibDecoderSpec = new NCompress::NZlib::CDecoder();
-    _zlibDecoder = _zlibDecoderSpec;
+    if (!_zlibDecoder)
+    {
+      _zlibDecoderSpec = new NCompress::NZlib::CDecoder();
+      _zlibDecoder = _zlibDecoderSpec;
+    }
+  }
+  else
+  {
+    if (_method != k_Flags_Method_LZMA)
+    {
+      // probably we must support no-compression archives here.
+      return E_NOTIMPL;
+    }
   }
+
+  const bool be = _h.be;
+  const Byte *p2 = _data + (_curBlocksOffset + (UInt32)blockIndex * 4);
+  const UInt32 start = (blockIndex == 0 ? _curBlocksOffset + _curNumBlocks * 4: Get32(p2 - 4));
+  const UInt32 end = Get32(p2);
+  if (end < start || end > _size)
+    return S_FALSE;
+  const UInt32 inSize = end - start;
+
+  if (_method == k_Flags_Method_LZMA)
+  {
+    const unsigned kLzmaHeaderSize = LZMA_PROPS_SIZE + 4;
+    if (inSize < kLzmaHeaderSize)
+      return S_FALSE;
+    const Byte *p = _data + start;
+    UInt32 destSize32 = GetUi32(p + LZMA_PROPS_SIZE);
+    if (destSize32 > blockSize)
+      return S_FALSE;
+    SizeT destLen = destSize32;
+    SizeT srcLen = inSize - kLzmaHeaderSize;
+    ELzmaStatus status;
+    SRes res = LzmaDecode(dest, &destLen, p + kLzmaHeaderSize, &srcLen,
+        p, LZMA_PROPS_SIZE, LZMA_FINISH_END, &status, &g_Alloc);
+    if (res != SZ_OK
+        || (status != LZMA_STATUS_FINISHED_WITH_MARK &&
+            status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+        || destLen != destSize32
+        || srcLen != inSize - kLzmaHeaderSize)
+      return S_FALSE;
+    return S_OK;
+  }
+
   if (!_inStream)
   {
     _inStreamSpec = new CBufInStream();
@@ -470,17 +624,10 @@ HRESULT CHandler::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
     _outStreamSpec = new CBufPtrSeqOutStream();
     _outStream = _outStreamSpec;
   }
-  bool be = _h.be;
-  const Byte *p = _data + (_curBlocksOffset + (UInt32)blockIndex * 4);
-  UInt32 start = (blockIndex == 0 ? _curBlocksOffset + _curNumBlocks * 4: Get32(p - 4));
-  UInt32 end = Get32(p);
-  if (end < start || end > _size)
-    return S_FALSE;
-  UInt32 inSize = end - start;
   _inStreamSpec->Init(_data + start, inSize);
   _outStreamSpec->Init(dest, blockSize);
   RINOK(_zlibDecoder->Code(_inStream, _outStream, NULL, NULL, NULL));
-  return (_zlibDecoderSpec->GetInputProcessedSize() == inSize &&
+  return (inSize == _zlibDecoderSpec->GetInputProcessedSize() &&
       _outStreamSpec->GetPos() == blockSize) ? S_OK : S_FALSE;
 }
 
@@ -488,7 +635,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     Int32 testMode, IArchiveExtractCallback *extractCallback)
 {
   COM_TRY_BEGIN
-  bool allFilesMode = (numItems == (UInt32)-1);
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
   if (allFilesMode)
     numItems = _items.Size();
   if (numItems == 0)
@@ -514,10 +661,6 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   CMyComPtr<ICompressProgressInfo> progress = lps;
   lps->Init(extractCallback, false);
 
-  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
-  CMyComPtr<ISequentialInStream> inStream(streamSpec);
-  streamSpec->SetStream(_stream);
-
   for (i = 0; i < numItems; i++)
   {
     lps->InSize = totalPackSize;
@@ -555,31 +698,31 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     int res = NExtract::NOperationResult::kDataError;
     {
       CMyComPtr<ISequentialInStream> inSeqStream;
-      CMyComPtr<IInStream> inStream;
       HRESULT hres = GetStream(index, &inSeqStream);
-      if (inSeqStream)
-        inSeqStream.QueryInterface(IID_IInStream, &inStream);
       if (hres == E_OUTOFMEMORY)
         return E_OUTOFMEMORY;
-      if (hres == S_FALSE || !inStream)
-        res = NExtract::NOperationResult::kUnSupportedMethod;
+      if (hres == S_FALSE || !inSeqStream)
+        res = NExtract::NOperationResult::kUnsupportedMethod;
       else
       {
         RINOK(hres);
-        if (inStream)
         {
-          HRESULT hres = copyCoder->Code(inStream, outStream, NULL, NULL, progress);
-          if (hres != S_OK && hres != S_FALSE)
+          hres = copyCoder->Code(inSeqStream, outStream, NULL, NULL, progress);
+          if (hres == S_OK)
           {
-            RINOK(hres);
+            if (copyCoderSpec->TotalSize == curSize)
+              res = NExtract::NOperationResult::kOK;
           }
-          if (copyCoderSpec->TotalSize == curSize && hres == S_OK)
-            res = NExtract::NOperationResult::kOK;
+          else if (hres == E_NOTIMPL)
+            res = NExtract::NOperationResult::kUnsupportedMethod;
+          else if (hres != S_FALSE)
+            return hres;
         }
       }
     }
     RINOK(extractCallback->SetOperationResult(res));
   }
+
   return S_OK;
   COM_TRY_END
 }
@@ -596,7 +739,7 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
     return E_FAIL;
 
   UInt32 size = GetSize(p, be);
-  UInt32 numBlocks = (size + kBlockSize - 1) >> kBlockSizeLog;
+  UInt32 numBlocks = GetNumBlocks(size);
   UInt32 offset = GetOffset(p, be);
   if (offset < kHeaderSize)
   {
@@ -625,7 +768,7 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
   _curNumBlocks = numBlocks;
   _curBlocksOffset = offset;
   streamSpec->Handler = this;
-  if (!streamSpec->Alloc(kBlockSizeLog, 21 - kBlockSizeLog))
+  if (!streamSpec->Alloc(_blockSizeLog, 21 - _blockSizeLog))
     return E_OUTOFMEMORY;
   streamSpec->Init(size);
   *stream = streamTemp.Detach();
@@ -634,11 +777,11 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
   COM_TRY_END
 }
 
-static IInArchive *CreateArc() { return new NArchive::NCramfs::CHandler; }
-
-static CArcInfo g_ArcInfo =
-  { L"CramFS", L"cramfs", 0, 0xD3, SIGNATURE, kSignatureSize, false, CreateArc, 0 };
-
-REGISTER_ARC(Cramfs)
+REGISTER_ARC_I(
+  "CramFS", "cramfs", 0, 0xD3,
+  kSignature,
+  16,
+  0,
+  NULL)
 
 }}

data/ext/p7zip/CPP/7zip/Archive/DeflateProps.cpp

@@ -1,118 +1,3 @@
 // DeflateProps.cpp
 
 #include "StdAfx.h"
-
-#include "Windows/PropVariant.h"
-
-#include "Common/ParseProperties.h"
-
-#include "DeflateProps.h"
-
-namespace NArchive {
-
-static const UInt32 kAlgo1 = 0;
-static const UInt32 kAlgo5 = 1;
-
-static const UInt32 kPasses1 = 1;
-static const UInt32 kPasses7 = 3;
-static const UInt32 kPasses9 = 10;
-
-static const UInt32 kFb1 = 32;
-static const UInt32 kFb7 = 64;
-static const UInt32 kFb9 = 128;
-
-void CDeflateProps::Normalize()
-{
-  UInt32 level = Level;
-  if (level == 0xFFFFFFFF)
-    level = 5;
-  
-  if (Algo == 0xFFFFFFFF)
-    Algo = (level >= 5 ?
-      kAlgo5 :
-      kAlgo1);
-
-  if (NumPasses == 0xFFFFFFFF)
-    NumPasses =
-      (level >= 9 ? kPasses9 :
-      (level >= 7 ? kPasses7 :
-                    kPasses1));
-  if (Fb == 0xFFFFFFFF)
-    Fb =
-      (level >= 9 ? kFb9 :
-      (level >= 7 ? kFb7 :
-                    kFb1));
-}
-
-HRESULT CDeflateProps::SetCoderProperties(ICompressSetCoderProperties *setCoderProperties)
-{
-  Normalize();
-
-  NWindows::NCOM::CPropVariant props[] =
-  {
-    Algo,
-    NumPasses,
-    Fb,
-    Mc
-  };
-  PROPID propIDs[] =
-  {
-    NCoderPropID::kAlgorithm,
-    NCoderPropID::kNumPasses,
-    NCoderPropID::kNumFastBytes,
-    NCoderPropID::kMatchFinderCycles
-  };
-  int numProps = sizeof(propIDs) / sizeof(propIDs[0]);
-  if (!McDefined)
-    numProps--;
-  return setCoderProperties->SetCoderProperties(propIDs, props, numProps);
-}
-
-HRESULT CDeflateProps::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps)
-{
-  Init();
-  for (int i = 0; i < numProps; i++)
-  {
-    UString name = names[i];
-    name.MakeUpper();
-    if (name.IsEmpty())
-      return E_INVALIDARG;
-    const PROPVARIANT &prop = values[i];
-    if (name[0] == L'X')
-    {
-      UInt32 a = 9;
-      RINOK(ParsePropValue(name.Mid(1), prop, a));
-      Level = a;
-    }
-    else if (name.Left(1) == L"A")
-    {
-      UInt32 a = kAlgo5;
-      RINOK(ParsePropValue(name.Mid(1), prop, a));
-      Algo = a;
-    }
-    else if (name.Left(4) == L"PASS")
-    {
-      UInt32 a = kPasses9;
-      RINOK(ParsePropValue(name.Mid(4), prop, a));
-      NumPasses = a;
-    }
-    else if (name.Left(2) == L"FB")
-    {
-      UInt32 a = kFb9;
-      RINOK(ParsePropValue(name.Mid(2), prop, a));
-      Fb = a;
-    }
-    else if (name.Left(2) == L"MC")
-    {
-      UInt32 a = 0xFFFFFFFF;
-      RINOK(ParsePropValue(name.Mid(2), prop, a));
-      Mc = a;
-      McDefined = true;
-    }
-    else
-      return E_INVALIDARG;
-  }
-  return S_OK;
-}
-
-}