seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Common/FilterCoder.h

@@ -3,102 +3,212 @@
 #ifndef __FILTER_CODER_H
 #define __FILTER_CODER_H
 
+#include "../../../C/Alloc.h"
+
 #include "../../Common/MyCom.h"
 #include "../ICoder.h"
+
+#ifndef _NO_CRYPTO
 #include "../IPassword.h"
+#endif
+
+#define MY_QUERYINTERFACE_ENTRY_AG(i, sub0, sub) else if (iid == IID_ ## i) \
+  { if (!sub) RINOK(sub0->QueryInterface(IID_ ## i, (void **)&sub)) \
+    *outObject = (void *)(i *)this; }
+
+
+struct CAlignedMidBuffer
+{
+  #ifdef _WIN32
 
-#define MY_QUERYINTERFACE_ENTRY_AG(i, sub0, sub) if (iid == IID_ ## i) \
-{ if (!sub) RINOK(sub0->QueryInterface(IID_ ## i, (void **)&sub)) \
-*outObject = (void *)(i *)this; AddRef(); return S_OK; }
+  Byte *_buf;
+
+  CAlignedMidBuffer(): _buf(NULL) {}
+  ~CAlignedMidBuffer() { ::MidFree(_buf); }
+  
+  void AllocAlignedMask(size_t size, size_t)
+  {
+    ::MidFree(_buf);
+    _buf = (Byte *)::MidAlloc(size);
+  }
+  
+  #else
+  
+  Byte *_bufBase;
+  Byte *_buf;
+
+  CAlignedMidBuffer(): _bufBase(NULL), _buf(NULL) {}
+  ~CAlignedMidBuffer() { ::MidFree(_bufBase); }
+  
+  void AllocAlignedMask(size_t size, size_t alignMask)
+  {
+    ::MidFree(_bufBase);
+    _buf = NULL;
+    _bufBase = (Byte *)::MidAlloc(size + alignMask);
+    
+    if (_bufBase)
+    {
+      // _buf = (Byte *)(((uintptr_t)_bufBase + alignMask) & ~(uintptr_t)alignMask);
+         _buf = (Byte *)(((ptrdiff_t)_bufBase + alignMask) & ~(ptrdiff_t)alignMask);
+    }
+  }
+  
+  #endif
+};
 
 class CFilterCoder:
   public ICompressCoder,
+  
+  public ICompressSetOutStreamSize,
+  public ICompressInitEncoder,
+ 
   public ICompressSetInStream,
   public ISequentialInStream,
+  
   public ICompressSetOutStream,
   public ISequentialOutStream,
-  public IOutStreamFlush,
+  public IOutStreamFinish,
+  
+  public ICompressSetBufSize,
 
   #ifndef _NO_CRYPTO
   public ICryptoSetPassword,
+  public ICryptoProperties,
   #endif
+  
   #ifndef EXTRACT_ONLY
   public ICompressSetCoderProperties,
   public ICompressWriteCoderProperties,
   // public ICryptoResetSalt,
   public ICryptoResetInitVector,
   #endif
+  
   public ICompressSetDecoderProperties2,
-  public CMyUnknownImp
+  public CMyUnknownImp,
+  public CAlignedMidBuffer
 {
-protected:
-  Byte *_buffer;
-  CMyComPtr<ISequentialInStream> _inStream;
-  CMyComPtr<ISequentialOutStream> _outStream;
-  UInt32 _bufferPos;
-  UInt32 _convertedPosBegin;
-  UInt32 _convertedPosEnd;
+  UInt32 _bufSize;
+  UInt32 _inBufSize;
+  UInt32 _outBufSize;
+
+  bool _encodeMode;
   bool _outSizeIsDefined;
   UInt64 _outSize;
   UInt64 _nowPos64;
 
-  HRESULT Init()
+  CMyComPtr<ISequentialInStream> _inStream;
+  CMyComPtr<ISequentialOutStream> _outStream;
+  UInt32 _bufPos;
+  UInt32 _convPos;    // current pos in buffer for converted data
+  UInt32 _convSize;   // size of converted data starting from _convPos
+  
+  void InitSpecVars()
   {
-    _nowPos64 = 0;
+    _bufPos = 0;
+    _convPos = 0;
+    _convSize = 0;
+
     _outSizeIsDefined = false;
-    return Filter->Init();
+    _outSize = 0;
+    _nowPos64 = 0;
   }
 
-  CMyComPtr<ICryptoSetPassword> _setPassword;
+  HRESULT Alloc();
+  HRESULT Init_and_Alloc();
+  HRESULT Flush2();
+
+  #ifndef _NO_CRYPTO
+  CMyComPtr<ICryptoSetPassword> _SetPassword;
+  CMyComPtr<ICryptoProperties> _CryptoProperties;
+  #endif
+
   #ifndef EXTRACT_ONLY
   CMyComPtr<ICompressSetCoderProperties> _SetCoderProperties;
-  CMyComPtr<ICompressWriteCoderProperties> _writeCoderProperties;
+  CMyComPtr<ICompressWriteCoderProperties> _WriteCoderProperties;
   // CMyComPtr<ICryptoResetSalt> _CryptoResetSalt;
   CMyComPtr<ICryptoResetInitVector> _CryptoResetInitVector;
   #endif
-  CMyComPtr<ICompressSetDecoderProperties2> _setDecoderProperties;
+
+  CMyComPtr<ICompressSetDecoderProperties2> _SetDecoderProperties2;
+
 public:
   CMyComPtr<ICompressFilter> Filter;
 
-  CFilterCoder();
+  CFilterCoder(bool encodeMode);
   ~CFilterCoder();
-  HRESULT WriteWithLimit(ISequentialOutStream *outStream, UInt32 size);
 
-public:
+  class C_InStream_Releaser
+  {
+  public:
+    CFilterCoder *FilterCoder;
+    C_InStream_Releaser(): FilterCoder(NULL) {}
+    ~C_InStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseInStream(); }
+  };
+  
+  class C_OutStream_Releaser
+  {
+  public:
+    CFilterCoder *FilterCoder;
+    C_OutStream_Releaser(): FilterCoder(NULL) {}
+    ~C_OutStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseOutStream(); }
+  };
+
   MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
+
+    MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
+    MY_QUERYINTERFACE_ENTRY(ICompressInitEncoder)
+    
     MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
     MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
+    
     MY_QUERYINTERFACE_ENTRY(ICompressSetOutStream)
     MY_QUERYINTERFACE_ENTRY(ISequentialOutStream)
-    MY_QUERYINTERFACE_ENTRY(IOutStreamFlush)
+    MY_QUERYINTERFACE_ENTRY(IOutStreamFinish)
+    
+    MY_QUERYINTERFACE_ENTRY(ICompressSetBufSize)
 
     #ifndef _NO_CRYPTO
-    MY_QUERYINTERFACE_ENTRY_AG(ICryptoSetPassword, Filter, _setPassword)
+    MY_QUERYINTERFACE_ENTRY_AG(ICryptoSetPassword, Filter, _SetPassword)
+    MY_QUERYINTERFACE_ENTRY_AG(ICryptoProperties, Filter, _CryptoProperties)
     #endif
 
     #ifndef EXTRACT_ONLY
     MY_QUERYINTERFACE_ENTRY_AG(ICompressSetCoderProperties, Filter, _SetCoderProperties)
-    MY_QUERYINTERFACE_ENTRY_AG(ICompressWriteCoderProperties, Filter, _writeCoderProperties)
+    MY_QUERYINTERFACE_ENTRY_AG(ICompressWriteCoderProperties, Filter, _WriteCoderProperties)
     // MY_QUERYINTERFACE_ENTRY_AG(ICryptoResetSalt, Filter, _CryptoResetSalt)
     MY_QUERYINTERFACE_ENTRY_AG(ICryptoResetInitVector, Filter, _CryptoResetInitVector)
     #endif
 
-    MY_QUERYINTERFACE_ENTRY_AG(ICompressSetDecoderProperties2, Filter, _setDecoderProperties)
+    MY_QUERYINTERFACE_ENTRY_AG(ICompressSetDecoderProperties2, Filter, _SetDecoderProperties2)
   MY_QUERYINTERFACE_END
   MY_ADDREF_RELEASE
+  
+  
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
-  STDMETHOD(ReleaseInStream)();
+  
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
+  STDMETHOD(InitEncoder)();
+
   STDMETHOD(SetInStream)(ISequentialInStream *inStream);
-  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize); \
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+
   STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);
   STDMETHOD(ReleaseOutStream)();
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-  STDMETHOD(Flush)();
+  STDMETHOD(OutStreamFinish)();
+  
+  STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
+  STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
 
   #ifndef _NO_CRYPTO
   STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+
+  STDMETHOD(SetKey)(const Byte *data, UInt32 size);
+  STDMETHOD(SetInitVector)(const Byte *data, UInt32 size);
   #endif
+  
   #ifndef EXTRACT_ONLY
   STDMETHOD(SetCoderProperties)(const PROPID *propIDs,
       const PROPVARIANT *properties, UInt32 numProperties);
@@ -106,23 +216,11 @@ public:
   // STDMETHOD(ResetSalt)();
   STDMETHOD(ResetInitVector)();
   #endif
+  
   STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
-};
 
-class CInStreamReleaser
-{
-public:
-  CFilterCoder *FilterCoder;
-  CInStreamReleaser(): FilterCoder(0) {}
-  ~CInStreamReleaser() { if (FilterCoder) FilterCoder->ReleaseInStream(); }
-};
-
-class COutStreamReleaser
-{
-public:
-  CFilterCoder *FilterCoder;
-  COutStreamReleaser(): FilterCoder(0) {}
-  ~COutStreamReleaser() { if (FilterCoder) FilterCoder->ReleaseOutStream(); }
+  
+  HRESULT Init_NoSubFilterInit();
 };
 
 #endif

data/ext/p7zip/CPP/7zip/Common/InBuffer.cpp

@@ -6,50 +6,49 @@
 
 #include "InBuffer.h"
 
-CInBuffer::CInBuffer():
-  _buffer(0),
-  _bufferLimit(0),
-  _bufferBase(0),
+CInBufferBase::CInBufferBase() throw():
+  _buf(0),
+  _bufLim(0),
+  _bufBase(0),
   _stream(0),
-  _bufferSize(0)
+  _processedSize(0),
+  _bufSize(0),
+  _wasFinished(false),
+  NumExtraBytes(0)
 {}
 
-bool CInBuffer::Create(UInt32 bufferSize)
+bool CInBuffer::Create(size_t bufSize) throw()
 {
-  const UInt32 kMinBlockSize = 1;
-  if (bufferSize < kMinBlockSize)
-    bufferSize = kMinBlockSize;
-  if (_bufferBase != 0 && _bufferSize == bufferSize)
+  const unsigned kMinBlockSize = 1;
+  if (bufSize < kMinBlockSize)
+    bufSize = kMinBlockSize;
+  if (_bufBase != 0 && _bufSize == bufSize)
     return true;
   Free();
-  _bufferSize = bufferSize;
-  _bufferBase = (Byte *)::MidAlloc(bufferSize);
-  return (_bufferBase != 0);
+  _bufSize = bufSize;
+  _bufBase = (Byte *)::MidAlloc(bufSize);
+  return (_bufBase != 0);
 }
 
-void CInBuffer::Free()
+void CInBuffer::Free() throw()
 {
-  ::MidFree(_bufferBase);
-  _bufferBase = 0;
+  ::MidFree(_bufBase);
+  _bufBase = 0;
 }
 
-void CInBuffer::SetStream(ISequentialInStream *stream)
-{
-  _stream = stream;
-}
-
-void CInBuffer::Init()
+void CInBufferBase::Init() throw()
 {
   _processedSize = 0;
-  _buffer = _bufferBase;
-  _bufferLimit = _buffer;
+  _buf = _bufBase;
+  _bufLim = _buf;
   _wasFinished = false;
   #ifdef _NO_EXCEPTIONS
   ErrorCode = S_OK;
   #endif
+  NumExtraBytes = 0;
 }
 
-bool CInBuffer::ReadBlock()
+bool CInBufferBase::ReadBlock()
 {
   #ifdef _NO_EXCEPTIONS
   if (ErrorCode != S_OK)
@@ -57,27 +56,80 @@ bool CInBuffer::ReadBlock()
   #endif
   if (_wasFinished)
     return false;
-  _processedSize += (_buffer - _bufferBase);
-  UInt32 numProcessedBytes;
-  HRESULT result = _stream->Read(_bufferBase, _bufferSize, &numProcessedBytes);
+  _processedSize += (_buf - _bufBase);
+  _buf = _bufBase;
+  _bufLim = _bufBase;
+  UInt32 processed;
+  // FIX_ME: we can improve it to support (_bufSize >= (1 << 32))
+  HRESULT result = _stream->Read(_bufBase, (UInt32)_bufSize, &processed);
   #ifdef _NO_EXCEPTIONS
   ErrorCode = result;
   #else
   if (result != S_OK)
     throw CInBufferException(result);
   #endif
-  _buffer = _bufferBase;
-  _bufferLimit = _buffer + numProcessedBytes;
-  _wasFinished = (numProcessedBytes == 0);
-  return (!_wasFinished);
+  _bufLim = _buf + processed;
+  _wasFinished = (processed == 0);
+  return !_wasFinished;
 }
 
-Byte CInBuffer::ReadBlock2()
+bool CInBufferBase::ReadByte_FromNewBlock(Byte &b)
 {
   if (!ReadBlock())
   {
-    _processedSize++;
+    NumExtraBytes++;
+    b = 0xFF;
+    return false;
+  }
+  b = *_buf++;
+  return true;
+}
+
+Byte CInBufferBase::ReadByte_FromNewBlock()
+{
+  if (!ReadBlock())
+  {
+    NumExtraBytes++;
     return 0xFF;
   }
-  return *_buffer++;
+  return *_buf++;
+}
+
+size_t CInBufferBase::ReadBytes(Byte *buf, size_t size)
+{
+  if ((size_t)(_bufLim - _buf) >= size)
+  {
+    const Byte *src = _buf;
+    for (size_t i = 0; i < size; i++)
+      buf[i] = src[i];
+    _buf += size;
+    return size;
+  }
+  for (size_t i = 0; i < size; i++)
+  {
+    if (_buf >= _bufLim)
+      if (!ReadBlock())
+        return i;
+    buf[i] = *_buf++;
+  }
+  return size;
+}
+
+size_t CInBufferBase::Skip(size_t size)
+{
+  size_t processed = 0;
+  for (;;)
+  {
+    size_t rem = (_bufLim - _buf);
+    if (rem >= size)
+    {
+      _buf += size;
+      return processed + size;
+    }
+    _buf += rem;
+    processed += rem;
+    size -= rem;
+    if (!ReadBlock())
+      return processed;
+  }
 }

data/ext/p7zip/CPP/7zip/Common/InBuffer.h

@@ -1,11 +1,10 @@
 // InBuffer.h
 
-#ifndef __INBUFFER_H
-#define __INBUFFER_H
+#ifndef __IN_BUFFER_H
+#define __IN_BUFFER_H
 
-#include "../IStream.h"
-#include "../../Common/MyCom.h"
 #include "../../Common/MyException.h"
+#include "../IStream.h"
 
 #ifndef _NO_EXCEPTIONS
 struct CInBufferException: public CSystemException
@@ -14,68 +13,78 @@ struct CInBufferException: public CSystemException
 };
 #endif
 
-class CInBuffer
+class CInBufferBase
 {
-  Byte *_buffer;
-  Byte *_bufferLimit;
-  Byte *_bufferBase;
-  CMyComPtr<ISequentialInStream> _stream;
+protected:
+  Byte *_buf;
+  Byte *_bufLim;
+  Byte *_bufBase;
+
+  ISequentialInStream *_stream;
   UInt64 _processedSize;
-  UInt32 _bufferSize;
+  size_t _bufSize; // actually it's number of Bytes for next read. The buf can be larger
+                   // only up to 32-bits values now are supported!
   bool _wasFinished;
 
   bool ReadBlock();
-  Byte ReadBlock2();
+  bool ReadByte_FromNewBlock(Byte &b);
+  Byte ReadByte_FromNewBlock();
 
 public:
   #ifdef _NO_EXCEPTIONS
   HRESULT ErrorCode;
   #endif
+  UInt32 NumExtraBytes;
 
-  CInBuffer();
-  ~CInBuffer() { Free(); }
+  CInBufferBase() throw();
+
+  UInt64 GetStreamSize() const { return _processedSize + (_buf - _bufBase); }
+  UInt64 GetProcessedSize() const { return _processedSize + NumExtraBytes + (_buf - _bufBase); }
+  bool WasFinished() const { return _wasFinished; }
 
-  bool Create(UInt32 bufferSize);
-  void Free();
+  void SetStream(ISequentialInStream *stream) { _stream = stream; }
   
-  void SetStream(ISequentialInStream *stream);
-  void Init();
-  void ReleaseStream() { _stream.Release(); }
+  void SetBuf(Byte *buf, size_t bufSize, size_t end, size_t pos)
+  {
+    _bufBase = buf;
+    _bufSize = bufSize;
+    _processedSize = 0;
+    _buf = buf + pos;
+    _bufLim = buf + end;
+    _wasFinished = false;
+    #ifdef _NO_EXCEPTIONS
+    ErrorCode = S_OK;
+    #endif
+    NumExtraBytes = 0;
+  }
+
+  void Init() throw();
 
   bool ReadByte(Byte &b)
   {
-    if (_buffer >= _bufferLimit)
-      if (!ReadBlock())
-        return false;
-    b = *_buffer++;
+    if (_buf >= _bufLim)
+      return ReadByte_FromNewBlock(b);
+    b = *_buf++;
     return true;
   }
+  
   Byte ReadByte()
   {
-    if (_buffer >= _bufferLimit)
-      return ReadBlock2();
-    return *_buffer++;
+    if (_buf >= _bufLim)
+      return ReadByte_FromNewBlock();
+    return *_buf++;
   }
-  UInt32 ReadBytes(Byte *buf, UInt32 size)
-  {
-    if ((UInt32)(_bufferLimit - _buffer) >= size)
-    {
-      for (UInt32 i = 0; i < size; i++)
-        buf[i] = _buffer[i];
-      _buffer += size;
-      return size;
-    }
-    for (UInt32 i = 0; i < size; i++)
-    {
-      if (_buffer >= _bufferLimit)
-        if (!ReadBlock())
-          return i;
-      buf[i] = *_buffer++;
-    }
-    return size;
-  }
-  UInt64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }
-  bool WasFinished() const { return _wasFinished; }
+  
+  size_t ReadBytes(Byte *buf, size_t size);
+  size_t Skip(size_t size);
+};
+
+class CInBuffer: public CInBufferBase
+{
+public:
+  ~CInBuffer() { Free(); }
+  bool Create(size_t bufSize) throw(); // only up to 32-bits values now are supported!
+  void Free() throw();
 };
 
 #endif

data/ext/p7zip/CPP/7zip/Common/InOutTempBuffer.cpp

@@ -4,16 +4,18 @@
 
 #include "../../../C/7zCrc.h"
 
+#include "../../Common/Defs.h"
+
 #include "InOutTempBuffer.h"
 #include "StreamUtils.h"
 
 using namespace NWindows;
 using namespace NFile;
-using namespace NDirectory;
+using namespace NDir;
 
-static const UInt32 kTempBufSize = (1 << 20);
+static const size_t kTempBufSize = (1 << 20);
 
-static LPCTSTR kTempFilePrefixString = TEXT("7zt");
+static CFSTR kTempFilePrefixString = FTEXT("7zt");
 
 CInOutTempBuffer::CInOutTempBuffer(): _buf(NULL) { }
 
@@ -42,12 +44,7 @@ bool CInOutTempBuffer::WriteToFile(const void *data, UInt32 size)
     return true;
   if (!_tempFileCreated)
   {
-    CSysString tempDirPath;
-    if (!MyGetTempPath(tempDirPath))
-      return false;
-    if (_tempFile.Create(tempDirPath, kTempFilePrefixString, _tempFileName) == 0)
-      return false;
-    if (!_outFile.Create(_tempFileName, true))
+    if (!_tempFile.CreateRandomInTempFolder(kTempFilePrefixString, &_outFile))
       return false;
     _tempFileCreated = true;
   }
@@ -61,15 +58,19 @@ bool CInOutTempBuffer::WriteToFile(const void *data, UInt32 size)
 
 bool CInOutTempBuffer::Write(const void *data, UInt32 size)
 {
-  if (_bufPos < kTempBufSize)
+  if (size == 0)
+    return true;
+  size_t cur = kTempBufSize - _bufPos;
+  if (cur != 0)
   {
-    UInt32 cur = MyMin(kTempBufSize - _bufPos, size);
+    if (cur > size)
+      cur = size;
     memcpy(_buf + _bufPos, data, cur);
     _crc = CrcUpdate(_crc, data, cur);
     _bufPos += cur;
-    size -= cur;
-    data = ((const Byte *)data) + cur;
     _size += cur;
+    size -= (UInt32)cur;
+    data = ((const Byte *)data) + cur;
   }
   return WriteToFile(data, size);
 }
@@ -82,16 +83,17 @@ HRESULT CInOutTempBuffer::WriteToStream(ISequentialOutStream *stream)
   UInt64 size = 0;
   UInt32 crc = CRC_INIT_VAL;
 
-  if (_bufPos > 0)
+  if (_bufPos != 0)
   {
     RINOK(WriteStream(stream, _buf, _bufPos));
     crc = CrcUpdate(crc, _buf, _bufPos);
     size += _bufPos;
   }
+  
   if (_tempFileCreated)
   {
     NIO::CInFile inFile;
-    if (!inFile.Open(_tempFileName))
+    if (!inFile.Open(_tempFile.GetPath()))
       return E_FAIL;
     while (size < _size)
     {
@@ -105,18 +107,21 @@ HRESULT CInOutTempBuffer::WriteToStream(ISequentialOutStream *stream)
       size += processed;
     }
   }
+  
   return (_crc == crc && size == _size) ? S_OK : E_FAIL;
 }
 
+/*
 STDMETHODIMP CSequentialOutTempBufferImp::Write(const void *data, UInt32 size, UInt32 *processed)
 {
   if (!_buf->Write(data, size))
   {
-    if (processed != NULL)
+    if (processed)
       *processed = 0;
     return E_FAIL;
   }
-  if (processed != NULL)
+  if (processed)
     *processed = size;
   return S_OK;
 }
+*/