seven_zip_ruby 1.0.0

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;
+}

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

@@ -0,0 +1,125 @@
+// LimitedStreams.h
+
+#ifndef __LIMITED_STREAMS_H
+#define __LIMITED_STREAMS_H
+
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+#include "../IStream.h"
+
+class CLimitedSequentialInStream:
+  public ISequentialInStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<ISequentialInStream> _stream;
+  UInt64 _size;
+  UInt64 _pos;
+  bool _wasFinished;
+public:
+  void SetStream(ISequentialInStream *stream) { _stream = stream; }
+  void ReleaseStream() { _stream.Release(); }
+  void Init(UInt64 streamSize)
+  {
+    _size = streamSize;
+    _pos = 0;
+    _wasFinished = false;
+  }
+ 
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  UInt64 GetSize() const { return _pos; }
+  bool WasFinished() const { return _wasFinished; }
+};
+
+class CLimitedInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<IInStream> _stream;
+  UInt64 _virtPos;
+  UInt64 _physPos;
+  UInt64 _size;
+  UInt64 _startOffset;
+
+  HRESULT SeekToPhys() { return _stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
+public:
+  void SetStream(IInStream *stream) { _stream = stream; }
+  HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
+  {
+    _startOffset = startOffset;
+    _physPos = startOffset;
+    _virtPos = 0;
+    _size = size;
+    return SeekToPhys();
+  }
+ 
+  MY_UNKNOWN_IMP1(IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+
+  HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
+};
+
+class CClusterInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  UInt64 _virtPos;
+  UInt64 _physPos;
+  UInt32 _curRem;
+public:
+  CMyComPtr<IInStream> Stream;
+  UInt64 StartOffset;
+  UInt64 Size;
+  int BlockSizeLog;
+  CRecordVector<UInt32> Vector;
+
+  HRESULT SeekToPhys() { return Stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
+
+  HRESULT InitAndSeek()
+  {
+    _curRem = 0;
+    _virtPos = 0;
+    _physPos = StartOffset;
+    if (Vector.Size() > 0)
+    {
+      _physPos = StartOffset + (Vector[0] << BlockSizeLog);
+      return SeekToPhys();
+    }
+    return S_OK;
+  }
+
+  MY_UNKNOWN_IMP1(IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+};
+
+HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream);
+
+class CLimitedSequentialOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt64 _size;
+  bool _overflow;
+  bool _overflowIsAllowed;
+public:
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+  void ReleaseStream() { _stream.Release(); }
+  void Init(UInt64 size, bool overflowIsAllowed = false)
+  {
+    _size = size;
+    _overflow = false;
+    _overflowIsAllowed = overflowIsAllowed;
+  }
+  bool IsFinishedOK() const { return (_size == 0 && !_overflow); }
+  UInt64 GetRem() const { return _size; }
+};
+
+#endif