seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipAddCommon.cpp

@@ -3,8 +3,9 @@
 #include "StdAfx.h"
 
 #include "../../../../C/7zCrc.h"
+#include "../../../../C/Alloc.h"
 
-#include "Windows/PropVariant.h"
+#include "../../../Windows/PropVariant.h"
 
 #include "../../ICoder.h"
 #include "../../IPassword.h"
@@ -33,6 +34,7 @@ static const UInt32 kLzmaHeaderSize = 4 + kLzmaPropsSize;
 
 class CLzmaEncoder:
   public ICompressCoder,
+  public ICompressSetCoderProperties,
   public CMyUnknownImp
 {
   NCompress::NLzma::CEncoder *EncoderSpec;
@@ -41,12 +43,12 @@ class CLzmaEncoder:
 public:
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
-  HRESULT SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
 
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP1(ICompressSetCoderProperties)
 };
 
-HRESULT CLzmaEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
+STDMETHODIMP CLzmaEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
 {
   if (!Encoder)
   {
@@ -67,7 +69,7 @@ HRESULT CLzmaEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIAN
   return S_OK;
 }
 
-HRESULT CLzmaEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+STDMETHODIMP CLzmaEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
     const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
 {
   RINOK(WriteStream(outStream, Header, kLzmaHeaderSize));
@@ -76,41 +78,62 @@ HRESULT CLzmaEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *
 
 
 CAddCommon::CAddCommon(const CCompressionMethodMode &options):
-  _options(options),
-  _copyCoderSpec(NULL),
-  _cryptoStreamSpec(0)
-  {}
+    _options(options),
+    _copyCoderSpec(NULL),
+    _cryptoStreamSpec(NULL),
+    _buf(NULL)
+    {}
 
-static HRESULT GetStreamCRC(ISequentialInStream *inStream, UInt32 &resultCRC)
+CAddCommon::~CAddCommon()
 {
+  MidFree(_buf);
+}
+
+static const UInt32 kBufSize = ((UInt32)1 << 16);
+
+HRESULT CAddCommon::CalcStreamCRC(ISequentialInStream *inStream, UInt32 &resultCRC)
+{
+  if (!_buf)
+  {
+    _buf = (Byte *)MidAlloc(kBufSize);
+    if (!_buf)
+      return E_OUTOFMEMORY;
+  }
+
   UInt32 crc = CRC_INIT_VAL;
-  const UInt32 kBufferSize = (1 << 14);
-  Byte buffer[kBufferSize];
   for (;;)
   {
-    UInt32 realProcessedSize;
-    RINOK(inStream->Read(buffer, kBufferSize, &realProcessedSize));
-    if (realProcessedSize == 0)
+    UInt32 processed;
+    RINOK(inStream->Read(_buf, kBufSize, &processed));
+    if (processed == 0)
     {
       resultCRC = CRC_GET_DIGEST(crc);
       return S_OK;
     }
-    crc = CrcUpdate(crc, buffer, (size_t)realProcessedSize);
+    crc = CrcUpdate(crc, _buf, (size_t)processed);
   }
 }
 
 HRESULT CAddCommon::Compress(
     DECL_EXTERNAL_CODECS_LOC_VARS
     ISequentialInStream *inStream, IOutStream *outStream,
+    UInt32 /* fileTime */,
     ICompressProgressInfo *progress, CCompressingResult &opRes)
 {
-  CSequentialInStreamWithCRC *inSecCrcStreamSpec = 0;
-  CInStreamWithCRC *inCrcStreamSpec = 0;
+  if (!inStream)
+  {
+    // We can create empty stream here. But it was already implemented in caller code in 9.33+
+    return E_INVALIDARG;
+  }
+
+  // CSequentialInStreamWithCRC *inSecCrcStreamSpec = NULL;
+  CInStreamWithCRC *inCrcStreamSpec = NULL;
   CMyComPtr<ISequentialInStream> inCrcStream;
   {
     CMyComPtr<IInStream> inStream2;
-    // we don't support stdin, since stream from stdin can require 64-bit size header
-    RINOK(inStream->QueryInterface(IID_IInStream, (void **)&inStream2));
+    
+    inStream->QueryInterface(IID_IInStream, (void **)&inStream2);
+
     if (inStream2)
     {
       inCrcStreamSpec = new CInStreamWithCRC;
@@ -120,42 +143,48 @@ HRESULT CAddCommon::Compress(
     }
     else
     {
+      // we don't support stdin, since stream from stdin can require 64-bit size header
+      return E_NOTIMPL;
+      /*
       inSecCrcStreamSpec = new CSequentialInStreamWithCRC;
       inCrcStream = inSecCrcStreamSpec;
       inSecCrcStreamSpec->SetStream(inStream);
       inSecCrcStreamSpec->Init();
+      */
     }
   }
 
-  int numTestMethods = _options.MethodSequence.Size();
-  if (numTestMethods > 1 || _options.PasswordIsDefined)
-  {
-    if (inCrcStreamSpec == 0)
-    {
-      if (_options.PasswordIsDefined)
-        return E_NOTIMPL;
-      numTestMethods = 1;
-    }
-  }
+  unsigned numTestMethods = _options.MethodSequence.Size();
+  
+  if (numTestMethods > 1 && !inCrcStreamSpec)
+    numTestMethods = 1;
+
+  UInt32 crc = 0;
+  bool crc_IsCalculated = false;
+  
   Byte method = 0;
-  COutStreamReleaser outStreamReleaser;
+  CFilterCoder::C_OutStream_Releaser outStreamReleaser;
   opRes.ExtractVersion = NFileHeader::NCompressionMethod::kExtractVersion_Default;
-  for (int i = 0; i < numTestMethods; i++)
+  opRes.FileTimeWasUsed = false;
+  
+  for (unsigned i = 0; i < numTestMethods; i++)
   {
     opRes.ExtractVersion = NFileHeader::NCompressionMethod::kExtractVersion_Default;
-    if (inCrcStreamSpec != 0)
+    if (inCrcStreamSpec)
       RINOK(inCrcStreamSpec->Seek(0, STREAM_SEEK_SET, NULL));
     RINOK(outStream->SetSize(0));
     RINOK(outStream->Seek(0, STREAM_SEEK_SET, NULL));
+    
     if (_options.PasswordIsDefined)
     {
       opRes.ExtractVersion = NFileHeader::NCompressionMethod::kExtractVersion_ZipCrypto;
 
       if (!_cryptoStream)
       {
-        _cryptoStreamSpec = new CFilterCoder;
+        _cryptoStreamSpec = new CFilterCoder(true);
         _cryptoStream = _cryptoStreamSpec;
       }
+      
       if (_options.IsAesMode)
       {
         opRes.ExtractVersion = NFileHeader::NCompressionMethod::kExtractVersion_Aes;
@@ -163,7 +192,7 @@ HRESULT CAddCommon::Compress(
         {
           _cryptoStreamSpec->Filter = _filterAesSpec = new NCrypto::NWzAes::CEncoder;
           _filterAesSpec->SetKeyMode(_options.AesKeyMode);
-          RINOK(_filterAesSpec->CryptoSetPassword((const Byte *)(const char *)_options.Password, _options.Password.Length()));
+          RINOK(_filterAesSpec->CryptoSetPassword((const Byte *)(const char *)_options.Password, _options.Password.Len()));
         }
         RINOK(_filterAesSpec->WriteHeader(outStream));
       }
@@ -172,19 +201,40 @@ HRESULT CAddCommon::Compress(
         if (!_cryptoStreamSpec->Filter)
         {
           _cryptoStreamSpec->Filter = _filterSpec = new NCrypto::NZip::CEncoder;
-          _filterSpec->CryptoSetPassword((const Byte *)(const char *)_options.Password, _options.Password.Length());
+          _filterSpec->CryptoSetPassword((const Byte *)(const char *)_options.Password, _options.Password.Len());
+        }
+        
+        UInt32 check;
+        
+        // if (inCrcStreamSpec)
+        {
+          if (!crc_IsCalculated)
+          {
+            RINOK(CalcStreamCRC(inStream, crc));
+            crc_IsCalculated = true;
+            RINOK(inCrcStreamSpec->Seek(0, STREAM_SEEK_SET, NULL));
+          }
+          check = (crc >> 16);
+        }
+        /*
+        else
+        {
+          opRes.FileTimeWasUsed = true;
+          check = (fileTime & 0xFFFF);
         }
-        UInt32 crc = 0;
-        RINOK(GetStreamCRC(inStream, crc));
-        RINOK(inCrcStreamSpec->Seek(0, STREAM_SEEK_SET, NULL));
-        RINOK(_filterSpec->WriteHeader(outStream, crc));
+        */
+        
+        RINOK(_filterSpec->WriteHeader_Check16(outStream, (UInt16)check));
       }
+      
       RINOK(_cryptoStreamSpec->SetOutStream(outStream));
+      RINOK(_cryptoStreamSpec->InitEncoder());
       outStreamReleaser.FilterCoder = _cryptoStreamSpec;
     }
 
     method = _options.MethodSequence[i];
-    switch(method)
+    
+    switch (method)
     {
       case NFileHeader::NCompressionMethod::kStored:
       {
@@ -201,6 +251,7 @@ HRESULT CAddCommon::Compress(
         RINOK(_copyCoder->Code(inCrcStream, outStreamNew, NULL, NULL, progress));
         break;
       }
+      
       default:
       {
         if (!_compressEncoder)
@@ -210,57 +261,17 @@ HRESULT CAddCommon::Compress(
             _compressExtractVersion = NFileHeader::NCompressionMethod::kExtractVersion_LZMA;
             CLzmaEncoder *_lzmaEncoder = new CLzmaEncoder();
             _compressEncoder = _lzmaEncoder;
-            NWindows::NCOM::CPropVariant props[] =
-            {
-              #ifndef _7ZIP_ST
-              _options.NumThreads,
-              #endif
-              _options.Algo,
-              _options.DicSize,
-              _options.NumFastBytes,
-              const_cast<BSTR>((const wchar_t *)_options.MatchFinder),
-              _options.NumMatchFinderCycles
-            };
-            PROPID propIDs[] =
-            {
-              #ifndef _7ZIP_ST
-              NCoderPropID::kNumThreads,
-              #endif
-              NCoderPropID::kAlgorithm,
-              NCoderPropID::kDictionarySize,
-              NCoderPropID::kNumFastBytes,
-              NCoderPropID::kMatchFinder,
-              NCoderPropID::kMatchFinderCycles
-            };
-            int numProps = sizeof(propIDs) / sizeof(propIDs[0]);
-            if (!_options.NumMatchFinderCyclesDefined)
-              numProps--;
-            RINOK(_lzmaEncoder->SetCoderProperties(propIDs, props, numProps));
           }
           else if (method == NFileHeader::NCompressionMethod::kPPMd)
           {
             _compressExtractVersion = NFileHeader::NCompressionMethod::kExtractVersion_PPMd;
             NCompress::NPpmdZip::CEncoder *encoder = new NCompress::NPpmdZip::CEncoder();
             _compressEncoder = encoder;
-            NWindows::NCOM::CPropVariant props[] =
-            {
-              _options.Algo,
-              _options.MemSize,
-              _options.Order
-              
-            };
-            PROPID propIDs[] =
-            {
-              NCoderPropID::kAlgorithm,
-              NCoderPropID::kUsedMemorySize,
-              NCoderPropID::kOrder
-            };
-            RINOK(encoder->SetCoderProperties(propIDs, props, sizeof(propIDs) / sizeof(propIDs[0])));
           }
           else
           {
           CMethodId methodId;
-          switch(method)
+          switch (method)
           {
             case NFileHeader::NCompressionMethod::kBZip2:
               methodId = kMethodId_BZip2;
@@ -275,63 +286,27 @@ HRESULT CAddCommon::Compress(
           }
           RINOK(CreateCoder(
               EXTERNAL_CODECS_LOC_VARS
-              methodId, _compressEncoder, true));
+              methodId, true, _compressEncoder));
           if (!_compressEncoder)
             return E_NOTIMPL;
 
           if (method == NFileHeader::NCompressionMethod::kDeflated ||
               method == NFileHeader::NCompressionMethod::kDeflated64)
           {
-            NWindows::NCOM::CPropVariant props[] =
-            {
-              _options.Algo,
-              _options.NumPasses,
-              _options.NumFastBytes,
-              _options.NumMatchFinderCycles
-            };
-            PROPID propIDs[] =
-            {
-              NCoderPropID::kAlgorithm,
-              NCoderPropID::kNumPasses,
-              NCoderPropID::kNumFastBytes,
-              NCoderPropID::kMatchFinderCycles
-            };
-            int numProps = sizeof(propIDs) / sizeof(propIDs[0]);
-            if (!_options.NumMatchFinderCyclesDefined)
-              numProps--;
-            CMyComPtr<ICompressSetCoderProperties> setCoderProperties;
-            _compressEncoder.QueryInterface(IID_ICompressSetCoderProperties, &setCoderProperties);
-            if (setCoderProperties)
-            {
-              RINOK(setCoderProperties->SetCoderProperties(propIDs, props, numProps));
-            }
           }
           else if (method == NFileHeader::NCompressionMethod::kBZip2)
           {
-            NWindows::NCOM::CPropVariant props[] =
-            {
-              _options.DicSize,
-              _options.NumPasses
-              #ifndef _7ZIP_ST
-              , _options.NumThreads
-              #endif
-            };
-            PROPID propIDs[] =
-            {
-              NCoderPropID::kDictionarySize,
-              NCoderPropID::kNumPasses
-              #ifndef _7ZIP_ST
-              , NCoderPropID::kNumThreads
-              #endif
-            };
-            CMyComPtr<ICompressSetCoderProperties> setCoderProperties;
-            _compressEncoder.QueryInterface(IID_ICompressSetCoderProperties, &setCoderProperties);
-            if (setCoderProperties)
+          }
+          }
+          {
+            CMyComPtr<ICompressSetCoderProperties> setCoderProps;
+            _compressEncoder.QueryInterface(IID_ICompressSetCoderProperties, &setCoderProps);
+            if (setCoderProps)
             {
-              RINOK(setCoderProperties->SetCoderProperties(propIDs, props, sizeof(propIDs) / sizeof(propIDs[0])));
+              RINOK(_options.MethodInfo.SetCoderProps(setCoderProps,
+                  _options._dataSizeReduceDefined ? &_options._dataSizeReduce : NULL));
             }
           }
-          }
         }
         CMyComPtr<ISequentialOutStream> outStreamNew;
         if (_options.PasswordIsDefined)
@@ -345,33 +320,42 @@ HRESULT CAddCommon::Compress(
       }
     }
 
+    if (_options.PasswordIsDefined)
+    {
+      RINOK(_cryptoStreamSpec->OutStreamFinish());
+      
+      if (_options.IsAesMode)
+      {
+        RINOK(_filterAesSpec->WriteFooter(outStream));
+      }
+    }
+    
     RINOK(outStream->Seek(0, STREAM_SEEK_CUR, &opRes.PackSize));
 
-    if (inCrcStreamSpec != 0)
+    // if (inCrcStreamSpec)
     {
       opRes.CRC = inCrcStreamSpec->GetCRC();
       opRes.UnpackSize = inCrcStreamSpec->GetSize();
     }
+    /*
     else
     {
       opRes.CRC = inSecCrcStreamSpec->GetCRC();
       opRes.UnpackSize = inSecCrcStreamSpec->GetSize();
     }
+    */
 
     if (_options.PasswordIsDefined)
     {
       if (opRes.PackSize < opRes.UnpackSize +
-          (_options.IsAesMode ? _filterAesSpec->GetHeaderSize() : NCrypto::NZip::kHeaderSize))
+          (_options.IsAesMode ? _filterAesSpec->GetAddPackSize() : NCrypto::NZip::kHeaderSize))
         break;
     }
     else if (opRes.PackSize < opRes.UnpackSize)
       break;
   }
-  if (_options.IsAesMode)
-  {
-    RINOK(_filterAesSpec->WriteFooter(outStream));
-    RINOK(outStream->Seek(0, STREAM_SEEK_CUR, &opRes.PackSize));
-  }
+
+
   opRes.Method = method;
   return S_OK;
 }

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipAddCommon.h

@@ -26,6 +26,7 @@ struct CCompressingResult
   UInt32 CRC;
   UInt16 Method;
   Byte ExtractVersion;
+  bool FileTimeWasUsed;
 };
 
 class CAddCommon
@@ -43,11 +44,16 @@ class CAddCommon
   NCrypto::NZip::CEncoder *_filterSpec;
   NCrypto::NWzAes::CEncoder *_filterAesSpec;
 
+  Byte *_buf;
+  
+  HRESULT CalcStreamCRC(ISequentialInStream *inStream, UInt32 &resultCRC);
 public:
   CAddCommon(const CCompressionMethodMode &options);
+  ~CAddCommon();
   HRESULT Compress(
       DECL_EXTERNAL_CODECS_LOC_VARS
       ISequentialInStream *inStream, IOutStream *outStream,
+      UInt32 fileTime,
       ICompressProgressInfo *progress, CCompressingResult &operationResult);
 };
 

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipCompressionMode.h

@@ -3,38 +3,58 @@
 #ifndef __ZIP_COMPRESSION_MODE_H
 #define __ZIP_COMPRESSION_MODE_H
 
-#include "Common/MyString.h"
+#include "../../../Common/MyString.h"
+
+#ifndef _7ZIP_ST
+#include "../../../Windows/System.h"
+#endif
+
+#include "../Common/HandlerOut.h"
 
 namespace NArchive {
 namespace NZip {
 
-struct CCompressionMethodMode
+struct CBaseProps
 {
-  CRecordVector<Byte> MethodSequence;
-  UString MatchFinder;
-  UInt32 Algo;
-  UInt32 NumPasses;
-  UInt32 NumFastBytes;
-  bool NumMatchFinderCyclesDefined;
-  UInt32 NumMatchFinderCycles;
-  UInt32 DicSize;
-  UInt32 MemSize;
-  UInt32 Order;
+  CMethodProps MethodInfo;
+  Int32 Level;
 
   #ifndef _7ZIP_ST
   UInt32 NumThreads;
+  bool NumThreadsWasChanged;
   #endif
-  bool PasswordIsDefined;
-  AString Password;
   bool IsAesMode;
   Byte AesKeyMode;
+
+  void Init()
+  {
+    MethodInfo.Clear();
+    Level = -1;
+    #ifndef _7ZIP_ST
+    NumThreads = NWindows::NSystem::GetNumberOfProcessors();;
+    NumThreadsWasChanged = false;
+    #endif
+    IsAesMode = false;
+    AesKeyMode = 3;
+  }
+};
+
+struct CCompressionMethodMode: public CBaseProps
+{
+  CRecordVector<Byte> MethodSequence;
+  bool PasswordIsDefined;
+  AString Password;
+
+  UInt64 _dataSizeReduce;
+  bool _dataSizeReduceDefined;
   
-  CCompressionMethodMode():
-      NumMatchFinderCyclesDefined(false),
-      PasswordIsDefined(false),
-      IsAesMode(false),
-      AesKeyMode(3)
-      {}
+  bool IsRealAesMode() const { return PasswordIsDefined && IsAesMode; }
+
+  CCompressionMethodMode(): PasswordIsDefined(false)
+  {
+    _dataSizeReduceDefined = false;
+    _dataSizeReduce = 0;
+  }
 };
 
 }}