seven-zip 1.4.0

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

@@ -0,0 +1,128 @@
+// FilterCoder.h
+
+#ifndef __FILTER_CODER_H
+#define __FILTER_CODER_H
+
+#include "../../Common/MyCom.h"
+#include "../ICoder.h"
+#include "../IPassword.h"
+
+#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; }
+
+class CFilterCoder:
+  public ICompressCoder,
+  public ICompressSetInStream,
+  public ISequentialInStream,
+  public ICompressSetOutStream,
+  public ISequentialOutStream,
+  public IOutStreamFlush,
+
+  #ifndef _NO_CRYPTO
+  public ICryptoSetPassword,
+  #endif
+  #ifndef EXTRACT_ONLY
+  public ICompressSetCoderProperties,
+  public ICompressWriteCoderProperties,
+  // public ICryptoResetSalt,
+  public ICryptoResetInitVector,
+  #endif
+  public ICompressSetDecoderProperties2,
+  public CMyUnknownImp
+{
+protected:
+  Byte *_buffer;
+  CMyComPtr<ISequentialInStream> _inStream;
+  CMyComPtr<ISequentialOutStream> _outStream;
+  UInt32 _bufferPos;
+  UInt32 _convertedPosBegin;
+  UInt32 _convertedPosEnd;
+  bool _outSizeIsDefined;
+  UInt64 _outSize;
+  UInt64 _nowPos64;
+
+  HRESULT Init()
+  {
+    _nowPos64 = 0;
+    _outSizeIsDefined = false;
+    return Filter->Init();
+  }
+
+  CMyComPtr<ICryptoSetPassword> _setPassword;
+  #ifndef EXTRACT_ONLY
+  CMyComPtr<ICompressSetCoderProperties> _SetCoderProperties;
+  CMyComPtr<ICompressWriteCoderProperties> _writeCoderProperties;
+  // CMyComPtr<ICryptoResetSalt> _CryptoResetSalt;
+  CMyComPtr<ICryptoResetInitVector> _CryptoResetInitVector;
+  #endif
+  CMyComPtr<ICompressSetDecoderProperties2> _setDecoderProperties;
+public:
+  CMyComPtr<ICompressFilter> Filter;
+
+  CFilterCoder();
+  ~CFilterCoder();
+  HRESULT WriteWithLimit(ISequentialOutStream *outStream, UInt32 size);
+
+public:
+  MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
+    MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
+    MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
+    MY_QUERYINTERFACE_ENTRY(ICompressSetOutStream)
+    MY_QUERYINTERFACE_ENTRY(ISequentialOutStream)
+    MY_QUERYINTERFACE_ENTRY(IOutStreamFlush)
+
+    #ifndef _NO_CRYPTO
+    MY_QUERYINTERFACE_ENTRY_AG(ICryptoSetPassword, Filter, _setPassword)
+    #endif
+
+    #ifndef EXTRACT_ONLY
+    MY_QUERYINTERFACE_ENTRY_AG(ICompressSetCoderProperties, Filter, _SetCoderProperties)
+    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_END
+  MY_ADDREF_RELEASE
+  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  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)();
+
+  #ifndef _NO_CRYPTO
+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+  #endif
+  #ifndef EXTRACT_ONLY
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs,
+      const PROPVARIANT *properties, UInt32 numProperties);
+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
+  // 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(); }
+};
+
+#endif

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

@@ -0,0 +1,83 @@
+// InBuffer.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "InBuffer.h"
+
+CInBuffer::CInBuffer():
+  _buffer(0),
+  _bufferLimit(0),
+  _bufferBase(0),
+  _stream(0),
+  _bufferSize(0)
+{}
+
+bool CInBuffer::Create(UInt32 bufferSize)
+{
+  const UInt32 kMinBlockSize = 1;
+  if (bufferSize < kMinBlockSize)
+    bufferSize = kMinBlockSize;
+  if (_bufferBase != 0 && _bufferSize == bufferSize)
+    return true;
+  Free();
+  _bufferSize = bufferSize;
+  _bufferBase = (Byte *)::MidAlloc(bufferSize);
+  return (_bufferBase != 0);
+}
+
+void CInBuffer::Free()
+{
+  ::MidFree(_bufferBase);
+  _bufferBase = 0;
+}
+
+void CInBuffer::SetStream(ISequentialInStream *stream)
+{
+  _stream = stream;
+}
+
+void CInBuffer::Init()
+{
+  _processedSize = 0;
+  _buffer = _bufferBase;
+  _bufferLimit = _buffer;
+  _wasFinished = false;
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = S_OK;
+  #endif
+}
+
+bool CInBuffer::ReadBlock()
+{
+  #ifdef _NO_EXCEPTIONS
+  if (ErrorCode != S_OK)
+    return false;
+  #endif
+  if (_wasFinished)
+    return false;
+  _processedSize += (_buffer - _bufferBase);
+  UInt32 numProcessedBytes;
+  HRESULT result = _stream->Read(_bufferBase, _bufferSize, &numProcessedBytes);
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = result;
+  #else
+  if (result != S_OK)
+    throw CInBufferException(result);
+  #endif
+  _buffer = _bufferBase;
+  _bufferLimit = _buffer + numProcessedBytes;
+  _wasFinished = (numProcessedBytes == 0);
+  return (!_wasFinished);
+}
+
+Byte CInBuffer::ReadBlock2()
+{
+  if (!ReadBlock())
+  {
+    _processedSize++;
+    return 0xFF;
+  }
+  return *_buffer++;
+}

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

@@ -0,0 +1,81 @@
+// InBuffer.h
+
+#ifndef __INBUFFER_H
+#define __INBUFFER_H
+
+#include "../IStream.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyException.h"
+
+#ifndef _NO_EXCEPTIONS
+struct CInBufferException: public CSystemException
+{
+  CInBufferException(HRESULT errorCode): CSystemException(errorCode) {}
+};
+#endif
+
+class CInBuffer
+{
+  Byte *_buffer;
+  Byte *_bufferLimit;
+  Byte *_bufferBase;
+  CMyComPtr<ISequentialInStream> _stream;
+  UInt64 _processedSize;
+  UInt32 _bufferSize;
+  bool _wasFinished;
+
+  bool ReadBlock();
+  Byte ReadBlock2();
+
+public:
+  #ifdef _NO_EXCEPTIONS
+  HRESULT ErrorCode;
+  #endif
+
+  CInBuffer();
+  ~CInBuffer() { Free(); }
+
+  bool Create(UInt32 bufferSize);
+  void Free();
+  
+  void SetStream(ISequentialInStream *stream);
+  void Init();
+  void ReleaseStream() { _stream.Release(); }
+
+  bool ReadByte(Byte &b)
+  {
+    if (_buffer >= _bufferLimit)
+      if (!ReadBlock())
+        return false;
+    b = *_buffer++;
+    return true;
+  }
+  Byte ReadByte()
+  {
+    if (_buffer >= _bufferLimit)
+      return ReadBlock2();
+    return *_buffer++;
+  }
+  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; }
+};
+
+#endif

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

@@ -0,0 +1,122 @@
+// InOutTempBuffer.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+
+#include "InOutTempBuffer.h"
+#include "StreamUtils.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDirectory;
+
+static const UInt32 kTempBufSize = (1 << 20);
+
+static LPCTSTR kTempFilePrefixString = TEXT("7zt");
+
+CInOutTempBuffer::CInOutTempBuffer(): _buf(NULL) { }
+
+void CInOutTempBuffer::Create()
+{
+  if (!_buf)
+    _buf = new Byte[kTempBufSize];
+}
+
+CInOutTempBuffer::~CInOutTempBuffer()
+{
+  delete []_buf;
+}
+
+void CInOutTempBuffer::InitWriting()
+{
+  _bufPos = 0;
+  _tempFileCreated = false;
+  _size = 0;
+  _crc = CRC_INIT_VAL;
+}
+
+bool CInOutTempBuffer::WriteToFile(const void *data, UInt32 size)
+{
+  if (size == 0)
+    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))
+      return false;
+    _tempFileCreated = true;
+  }
+  UInt32 processed;
+  if (!_outFile.Write(data, size, processed))
+    return false;
+  _crc = CrcUpdate(_crc, data, processed);
+  _size += processed;
+  return (processed == size);
+}
+
+bool CInOutTempBuffer::Write(const void *data, UInt32 size)
+{
+  if (_bufPos < kTempBufSize)
+  {
+    UInt32 cur = MyMin(kTempBufSize - _bufPos, size);
+    memcpy(_buf + _bufPos, data, cur);
+    _crc = CrcUpdate(_crc, data, cur);
+    _bufPos += cur;
+    size -= cur;
+    data = ((const Byte *)data) + cur;
+    _size += cur;
+  }
+  return WriteToFile(data, size);
+}
+
+HRESULT CInOutTempBuffer::WriteToStream(ISequentialOutStream *stream)
+{
+  if (!_outFile.Close())
+    return E_FAIL;
+
+  UInt64 size = 0;
+  UInt32 crc = CRC_INIT_VAL;
+
+  if (_bufPos > 0)
+  {
+    RINOK(WriteStream(stream, _buf, _bufPos));
+    crc = CrcUpdate(crc, _buf, _bufPos);
+    size += _bufPos;
+  }
+  if (_tempFileCreated)
+  {
+    NIO::CInFile inFile;
+    if (!inFile.Open(_tempFileName))
+      return E_FAIL;
+    while (size < _size)
+    {
+      UInt32 processed;
+      if (!inFile.ReadPart(_buf, kTempBufSize, processed))
+        return E_FAIL;
+      if (processed == 0)
+        break;
+      RINOK(WriteStream(stream, _buf, processed));
+      crc = CrcUpdate(crc, _buf, processed);
+      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)
+      *processed = 0;
+    return E_FAIL;
+  }
+  if (processed != NULL)
+    *processed = size;
+  return S_OK;
+}

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

@@ -0,0 +1,48 @@
+// InOutTempBuffer.h
+
+#ifndef __IN_OUT_TEMP_BUFFER_H
+#define __IN_OUT_TEMP_BUFFER_H
+
+#include "../../Common/MyCom.h"
+#include "../../Windows/FileDir.h"
+#include "../../Windows/FileIO.h"
+
+#include "../IStream.h"
+
+class CInOutTempBuffer
+{
+  NWindows::NFile::NDirectory::CTempFile _tempFile;
+  NWindows::NFile::NIO::COutFile _outFile;
+  Byte *_buf;
+  UInt32 _bufPos;
+  CSysString _tempFileName;
+  bool _tempFileCreated;
+  UInt64 _size;
+  UInt32 _crc;
+
+  bool WriteToFile(const void *data, UInt32 size);
+public:
+  CInOutTempBuffer();
+  ~CInOutTempBuffer();
+  void Create();
+
+  void InitWriting();
+  bool Write(const void *data, UInt32 size);
+
+  HRESULT WriteToStream(ISequentialOutStream *stream);
+  UInt64 GetDataSize() const { return _size; }
+};
+
+class CSequentialOutTempBufferImp:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  CInOutTempBuffer *_buf;
+public:
+  void Init(CInOutTempBuffer *buffer)  { _buf = buffer; }
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+#endif

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

@@ -0,0 +1,154 @@
+// LimitedStreams.cpp
+
+#include "StdAfx.h"
+
+#include "LimitedStreams.h"
+#include "../../Common/Defs.h"
+
+STDMETHODIMP CLimitedSequentialInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 realProcessedSize = 0;
+  UInt32 sizeToRead = (UInt32)MyMin((_size - _pos), (UInt64)size);
+  HRESULT result = S_OK;
+  if (sizeToRead > 0)
+  {
+    result = _stream->Read(data, sizeToRead, &realProcessedSize);
+    _pos += realProcessedSize;
+    if (realProcessedSize == 0)
+      _wasFinished = true;
+  }
+  if (processedSize != NULL)
+    *processedSize = realProcessedSize;
+  return result;
+}
+
+STDMETHODIMP CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize != NULL)
+    *processedSize = 0;
+  if (_virtPos >= _size)
+    return (_virtPos == _size) ? S_OK: E_FAIL;
+  UInt64 rem = _size - _virtPos;
+  if (rem < size)
+    size = (UInt32)rem;
+  UInt64 newPos = _startOffset + _virtPos;
+  if (newPos != _physPos)
+  {
+    _physPos = newPos;
+    RINOK(SeekToPhys());
+  }
+  HRESULT res = _stream->Read(data, size, &size);
+  if (processedSize != NULL)
+    *processedSize = size;
+  _physPos += size;
+  _virtPos += size;
+  return res;
+}
+
+STDMETHODIMP CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  switch(seekOrigin)
+  {
+    case STREAM_SEEK_SET: _virtPos = offset; break;
+    case STREAM_SEEK_CUR: _virtPos += offset; break;
+    case STREAM_SEEK_END: _virtPos = _size + offset; break;
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (newPosition)
+    *newPosition = _virtPos;
+  return S_OK;
+}
+
+STDMETHODIMP CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize != NULL)
+    *processedSize = 0;
+  if (_virtPos >= Size)
+    return (_virtPos == Size) ? S_OK: E_FAIL;
+
+  if (_curRem == 0)
+  {
+    UInt32 blockSize = (UInt32)1 << BlockSizeLog;
+    UInt32 virtBlock = (UInt32)(_virtPos >> BlockSizeLog);
+    UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
+    UInt32 phyBlock = Vector[virtBlock];
+    UInt64 newPos = StartOffset + ((UInt64)phyBlock << BlockSizeLog) + offsetInBlock;
+    if (newPos != _physPos)
+    {
+      _physPos = newPos;
+      RINOK(SeekToPhys());
+    }
+    _curRem = blockSize - offsetInBlock;
+    for (int i = 1; i < 64 && (virtBlock + i) < (UInt32)Vector.Size() && phyBlock + i == Vector[virtBlock + i]; i++)
+      _curRem += (UInt32)1 << BlockSizeLog;
+    UInt64 rem = Size - _virtPos;
+    if (_curRem > rem)
+      _curRem = (UInt32)rem;
+  }
+  if (size > _curRem)
+    size = _curRem;
+  HRESULT res = Stream->Read(data, size, &size);
+  if (processedSize != NULL)
+    *processedSize = size;
+  _physPos += size;
+  _virtPos += size;
+  _curRem -= size;
+  return res;
+}
+ 
+STDMETHODIMP CClusterInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  UInt64 newVirtPos = offset;
+  switch(seekOrigin)
+  {
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: newVirtPos += _virtPos; break;
+    case STREAM_SEEK_END: newVirtPos += Size; break;
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (_virtPos != newVirtPos)
+    _curRem = 0;
+  _virtPos = newVirtPos;
+  if (newPosition)
+    *newPosition = newVirtPos;
+  return S_OK;
+}
+
+
+HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream)
+{
+  *resStream = 0;
+  CLimitedInStream *streamSpec = new CLimitedInStream;
+  CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+  streamSpec->SetStream(inStream);
+  RINOK(streamSpec->InitAndSeek(pos, size));
+  streamSpec->SeekToStart();
+  *resStream = streamTemp.Detach();
+  return S_OK;
+}
+
+STDMETHODIMP CLimitedSequentialOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  HRESULT result = S_OK;
+  if (processedSize != NULL)
+    *processedSize = 0;
+  if (size > _size)
+  {
+    if (_size == 0)
+    {
+      _overflow = true;
+      if (!_overflowIsAllowed)
+        return E_FAIL;
+      if (processedSize != NULL)
+        *processedSize = size;
+      return S_OK;
+    }
+    size = (UInt32)_size;
+  }
+  if (_stream)
+    result = _stream->Write(data, size, &size);
+  _size -= size;
+  if (processedSize != NULL)
+    *processedSize = size;
+  return result;
+}