seven_zip_ruby_am 1.2.5.1

data/ext/p7zip/CPP/7zip/Archive/Rar/RarIn.h

@@ -0,0 +1,123 @@
+// RarIn.h
+
+#ifndef __ARCHIVE_RAR_IN_H
+#define __ARCHIVE_RAR_IN_H
+
+#include "Common/DynamicBuffer.h"
+#include "Common/MyCom.h"
+
+#include "../../ICoder.h"
+#include "../../IStream.h"
+
+#include "../../Common/StreamObjects.h"
+
+#include "../../Crypto/RarAes.h"
+
+#include "RarHeader.h"
+#include "RarItem.h"
+
+namespace NArchive {
+namespace NRar {
+
+class CInArchiveException
+{
+public:
+  enum CCauseType
+  {
+    kUnexpectedEndOfArchive = 0,
+    kArchiveHeaderCRCError,
+    kFileHeaderCRCError,
+    kIncorrectArchive
+  }
+  Cause;
+  CInArchiveException(CCauseType cause) :   Cause(cause) {}
+};
+
+
+struct CInArchiveInfo
+{
+  UInt32 Flags;
+  Byte EncryptVersion;
+  UInt64 StartPosition;
+  
+  bool IsSolid() const { return (Flags & NHeader::NArchive::kSolid) != 0; }
+  bool IsCommented() const {  return (Flags & NHeader::NArchive::kComment) != 0; }
+  bool IsVolume() const {  return (Flags & NHeader::NArchive::kVolume) != 0; }
+  bool HaveNewVolumeName() const {  return (Flags & NHeader::NArchive::kNewVolName) != 0; }
+  bool IsEncrypted() const { return (Flags & NHeader::NArchive::kBlockEncryption) != 0; }
+  bool IsThereEncryptVer() const { return (Flags & NHeader::NArchive::kEncryptVer) != 0; }
+  bool IsEncryptOld() const { return (!IsThereEncryptVer() || EncryptVersion < 36); }
+};
+
+class CInArchive
+{
+  CMyComPtr<IInStream> m_Stream;
+  
+  UInt64 m_StreamStartPosition;
+  
+  CInArchiveInfo _header;
+  CDynamicBuffer<char> m_NameBuffer;
+  CDynamicBuffer<wchar_t> _unicodeNameBuffer;
+
+  CByteBuffer _comment;
+  
+  void ReadName(CItemEx &item, int nameSize);
+  void ReadHeaderReal(CItemEx &item);
+  
+  HRESULT ReadBytesSpec(void *data, size_t *size);
+  bool ReadBytesAndTestSize(void *data, UInt32 size);
+  
+  HRESULT Open2(IInStream *stream, const UInt64 *searchHeaderSizeLimit);
+
+  void ThrowExceptionWithCode(CInArchiveException::CCauseType cause);
+  void ThrowUnexpectedEndOfArchiveException();
+  
+  void AddToSeekValue(UInt64 addValue);
+  
+  CDynamicBuffer<Byte> m_FileHeaderData;
+  
+  NHeader::NBlock::CBlock m_BlockHeader;
+
+  NCrypto::NRar29::CDecoder *m_RarAESSpec;
+  CMyComPtr<ICompressFilter> m_RarAES;
+  
+  Byte *m_CurData; // it must point to start of Rar::Block
+  UInt32 m_CurPos;
+  UInt32 m_PosLimit;
+  Byte ReadByte();
+  UInt16 ReadUInt16();
+  UInt32 ReadUInt32();
+  void ReadTime(Byte mask, CRarTime &rarTime);
+
+  CBuffer<Byte> m_DecryptedData;
+  Byte *m_DecryptedDataAligned;
+  UInt32 m_DecryptedDataSize;
+
+  bool m_CryptoMode;
+  UInt32 m_CryptoPos;
+  void FinishCryptoBlock()
+  {
+    if (m_CryptoMode)
+      while ((m_CryptoPos & 0xF) != 0)
+      {
+        m_CryptoPos++;
+        m_Position++;
+      }
+  }
+
+public:
+  UInt64 m_Position;
+
+  HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit);
+  void Close();
+  HRESULT GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPassword, bool &decryptionError, AString &errorMessage);
+  
+  void GetArchiveInfo(CInArchiveInfo &archiveInfo) const;
+  
+  void SeekInArchive(UInt64 position);
+  ISequentialInStream *CreateLimitedStream(UInt64 position, UInt64 size);
+};
+  
+}}
+  
+#endif

data/ext/p7zip/CPP/7zip/Archive/Rar/RarItem.cpp

@@ -0,0 +1,55 @@
+// RarItem.cpp
+
+#include "StdAfx.h"
+
+#include "RarItem.h"
+
+namespace NArchive{
+namespace NRar{
+
+bool CItem::IgnoreItem() const
+{
+  switch(HostOS)
+  {
+    case NHeader::NFile::kHostMSDOS:
+    case NHeader::NFile::kHostOS2:
+    case NHeader::NFile::kHostWin32:
+      return ((Attrib & NHeader::NFile::kLabelFileAttribute) != 0);
+  }
+  return false;
+}
+
+bool CItem::IsDir() const
+{
+  if (GetDictSize() == NHeader::NFile::kDictDirectoryValue)
+    return true;
+  switch(HostOS)
+  {
+    case NHeader::NFile::kHostMSDOS:
+    case NHeader::NFile::kHostOS2:
+    case NHeader::NFile::kHostWin32:
+      if ((Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+        return true;
+  }
+  return false;
+}
+
+UInt32 CItem::GetWinAttributes() const
+{
+  UInt32 winAttributes;
+  switch(HostOS)
+  {
+    case NHeader::NFile::kHostMSDOS:
+    case NHeader::NFile::kHostOS2:
+    case NHeader::NFile::kHostWin32:
+      winAttributes = Attrib;
+      break;
+    default:
+      winAttributes = 0; // must be converted from unix value;
+  }
+  if (IsDir())
+    winAttributes |= NHeader::NFile::kWinFileDirectoryAttributeMask;
+  return winAttributes;
+}
+
+}}

data/ext/p7zip/CPP/7zip/Archive/Rar/RarItem.h

@@ -0,0 +1,79 @@
+// RarItem.h
+
+#ifndef __ARCHIVE_RAR_ITEM_H
+#define __ARCHIVE_RAR_ITEM_H
+
+#include "Common/Types.h"
+#include "Common/MyString.h"
+
+#include "RarHeader.h"
+
+namespace NArchive{
+namespace NRar{
+
+struct CRarTime
+{
+  UInt32 DosTime;
+  Byte LowSecond;
+  Byte SubTime[3];
+};
+
+struct CItem
+{
+  UInt64 Size;
+  UInt64 PackSize;
+  
+  CRarTime CTime;
+  CRarTime ATime;
+  CRarTime MTime;
+
+  UInt32 FileCRC;
+  UInt32 Attrib;
+
+  UInt16 Flags;
+  Byte HostOS;
+  Byte UnPackVersion;
+  Byte Method;
+
+  bool CTimeDefined;
+  bool ATimeDefined;
+
+  AString Name;
+  UString UnicodeName;
+
+  Byte Salt[8];
+  
+  bool IsEncrypted()   const { return (Flags & NHeader::NFile::kEncrypted) != 0; }
+  bool IsSolid()       const { return (Flags & NHeader::NFile::kSolid) != 0; }
+  bool IsCommented()   const { return (Flags & NHeader::NFile::kComment) != 0; }
+  bool IsSplitBefore() const { return (Flags & NHeader::NFile::kSplitBefore) != 0; }
+  bool IsSplitAfter()  const { return (Flags & NHeader::NFile::kSplitAfter) != 0; }
+  bool HasSalt()       const { return (Flags & NHeader::NFile::kSalt) != 0; }
+  bool HasExtTime()    const { return (Flags & NHeader::NFile::kExtTime) != 0; }
+  bool HasUnicodeName()const { return (Flags & NHeader::NFile::kUnicodeName) != 0; }
+  bool IsOldVersion()  const { return (Flags & NHeader::NFile::kOldVersion) != 0; }
+  
+  UInt32 GetDictSize() const { return (Flags >> NHeader::NFile::kDictBitStart) & NHeader::NFile::kDictMask; }
+  bool IsDir() const;
+  bool IgnoreItem() const;
+  UInt32 GetWinAttributes() const;
+  
+  CItem(): CTimeDefined(false), ATimeDefined(false) {}
+};
+
+class CItemEx: public CItem
+{
+public:
+  UInt64 Position;
+  UInt16 MainPartSize;
+  UInt16 CommentSize;
+  UInt16 AlignSize;
+  UInt64 GetFullSize()  const { return MainPartSize + CommentSize + AlignSize + PackSize; };
+  //  DWORD GetHeaderWithCommentSize()  const { return MainPartSize + CommentSize; };
+  UInt64 GetCommentPosition() const { return Position + MainPartSize; };
+  UInt64 GetDataPosition()    const { return GetCommentPosition() + CommentSize + AlignSize; };
+};
+
+}}
+
+#endif

data/ext/p7zip/CPP/7zip/Archive/Rar/RarRegister.cpp

@@ -0,0 +1,13 @@
+// RarRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "RarHandler.h"
+static IInArchive *CreateArc() { return new NArchive::NRar::CHandler; }
+
+static CArcInfo g_ArcInfo =
+  { L"Rar", L"rar r00", 0, 3, {0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00}, 7, false, CreateArc, 0,  };
+
+REGISTER_ARC(Rar)

data/ext/p7zip/CPP/7zip/Archive/Rar/RarVolumeInStream.cpp

@@ -0,0 +1,78 @@
+// RarVolumeInStream.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/7zCrc.h"
+
+#include "RarVolumeInStream.h"
+
+namespace NArchive {
+namespace NRar {
+
+void CFolderInStream::Init(
+    CObjectVector<CInArchive> *archives,
+    const CObjectVector<CItemEx> *items,
+    const CRefItem &refItem)
+{
+  _archives = archives;
+  _items = items;
+  _refItem = refItem;
+  _curIndex = 0;
+  CRCs.Clear();
+  _fileIsOpen = false;
+}
+
+HRESULT CFolderInStream::OpenStream()
+{
+  while (_curIndex < _refItem.NumItems)
+  {
+    const CItemEx &item = (*_items)[_refItem.ItemIndex + _curIndex];
+    _stream.Attach((*_archives)[_refItem.VolumeIndex + _curIndex].
+        CreateLimitedStream(item.GetDataPosition(), item.PackSize));
+    _curIndex++;
+    _fileIsOpen = true;
+    _crc = CRC_INIT_VAL;
+    return S_OK;
+  }
+  return S_OK;
+}
+
+HRESULT CFolderInStream::CloseStream()
+{
+  CRCs.Add(CRC_GET_DIGEST(_crc));
+  _stream.Release();
+  _fileIsOpen = false;
+  return S_OK;
+}
+
+STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 realProcessedSize = 0;
+  while ((_curIndex < _refItem.NumItems || _fileIsOpen) && size > 0)
+  {
+    if (_fileIsOpen)
+    {
+      UInt32 localProcessedSize;
+      RINOK(_stream->Read(
+          ((Byte *)data) + realProcessedSize, size, &localProcessedSize));
+      _crc = CrcUpdate(_crc, ((Byte *)data) + realProcessedSize, localProcessedSize);
+      if (localProcessedSize == 0)
+      {
+        RINOK(CloseStream());
+        continue;
+      }
+      realProcessedSize += localProcessedSize;
+      size -= localProcessedSize;
+      break;
+    }
+    else
+    {
+      RINOK(OpenStream());
+    }
+  }
+  if (processedSize != 0)
+    *processedSize = realProcessedSize;
+  return S_OK;
+}
+
+}}

data/ext/p7zip/CPP/7zip/Archive/Rar/RarVolumeInStream.h

@@ -0,0 +1,49 @@
+// RarVolumeInStream.h
+
+#ifndef __RAR_VOLUME_IN_STREAM_H
+#define __RAR_VOLUME_IN_STREAM_H
+
+#include "../../IStream.h"
+#include "RarIn.h"
+
+namespace NArchive {
+namespace NRar {
+
+struct CRefItem
+{
+  int VolumeIndex;
+  int ItemIndex;
+  int NumItems;
+};
+
+class CFolderInStream:
+  public ISequentialInStream,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+
+private:
+  CObjectVector<CInArchive> *_archives;
+  const CObjectVector<CItemEx> *_items;
+  CRefItem _refItem;
+  int _curIndex;
+  UInt32 _crc;
+  bool _fileIsOpen;
+  CMyComPtr<ISequentialInStream> _stream;
+
+  HRESULT OpenStream();
+  HRESULT CloseStream();
+public:
+  void Init(CObjectVector<CInArchive> *archives,
+      const CObjectVector<CItemEx> *items,
+      const CRefItem &refItem);
+
+  CRecordVector<UInt32> CRCs;
+};
+  
+}}
+
+#endif

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

@@ -0,0 +1,292 @@
+// RpmHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "Common/ComTry.h"
+#include "Common/MyString.h"
+
+#include "Windows/PropVariant.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+using namespace NWindows;
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+
+namespace NArchive {
+namespace NRpm {
+
+/* Reference: lib/signature.h of rpm package */
+#define RPMSIG_NONE         0  /* Do not change! */
+/* The following types are no longer generated */
+#define RPMSIG_PGP262_1024  1  /* No longer generated */ /* 256 byte */
+/* These are the new-style signatures.  They are Header structures.    */
+/* Inside them we can put any number of any type of signature we like. */
+
+#define RPMSIG_HEADERSIG    5  /* New Header style signature */
+
+const UInt32 kLeadSize = 96;
+struct CLead
+{
+  unsigned char Magic[4];
+  unsigned char Major;  // not supported  ver1, only support 2,3 and lator
+  unsigned char Minor;
+  UInt16 Type;
+  UInt16 ArchNum;
+  char Name[66];
+  UInt16 OSNum;
+  UInt16 SignatureType;
+  char Reserved[16];  // pad to 96 bytes -- 8 byte aligned
+  bool MagicCheck() const
+    { return Magic[0] == 0xed && Magic[1] == 0xab && Magic[2] == 0xee && Magic[3] == 0xdb; };
+};
+  
+const UInt32 kEntryInfoSize = 16;
+/*
+struct CEntryInfo
+{
+  int Tag;
+  int Type;
+  int Offset; // Offset from beginning of data segment, only defined on disk
+  int Count;
+};
+*/
+
+// case: SignatureType == RPMSIG_HEADERSIG
+const UInt32 kCSigHeaderSigSize = 16;
+struct CSigHeaderSig
+{
+  unsigned char Magic[4];
+  UInt32 Reserved;
+  UInt32 IndexLen;  // count of index entries
+  UInt32 DataLen;   // number of bytes
+  bool MagicCheck()
+    { return Magic[0] == 0x8e && Magic[1] == 0xad && Magic[2] == 0xe8 && Magic[3] == 0x01; };
+  UInt32 GetLostHeaderLen()
+    { return IndexLen * kEntryInfoSize + DataLen; };
+};
+
+static HRESULT RedSigHeaderSig(IInStream *inStream, CSigHeaderSig &h)
+{
+  char dat[kCSigHeaderSigSize];
+  char *cur = dat;
+  RINOK(ReadStream_FALSE(inStream, dat, kCSigHeaderSigSize));
+  memcpy(h.Magic, cur, 4);
+  cur += 4;
+  cur += 4;
+  h.IndexLen = Get32(cur);
+  cur += 4;
+  h.DataLen = Get32(cur);
+  return S_OK;
+}
+
+HRESULT OpenArchive(IInStream *inStream)
+{
+  UInt64 pos;
+  char leadData[kLeadSize];
+  char *cur = leadData;
+  CLead lead;
+  RINOK(ReadStream_FALSE(inStream, leadData, kLeadSize));
+  memcpy(lead.Magic, cur, 4);
+  cur += 4;
+  lead.Major = *cur++;
+  lead.Minor = *cur++;
+  lead.Type = Get16(cur);
+  cur += 2;
+  lead.ArchNum = Get16(cur);
+  cur += 2;
+  memcpy(lead.Name, cur, sizeof(lead.Name));
+  cur += sizeof(lead.Name);
+  lead.OSNum = Get16(cur);
+  cur += 2;
+  lead.SignatureType = Get16(cur);
+  cur += 2;
+
+  if (!lead.MagicCheck() || lead.Major < 3)
+    return S_FALSE;
+
+  CSigHeaderSig sigHeader, header;
+  if (lead.SignatureType == RPMSIG_NONE)
+  {
+    ;
+  }
+  else if (lead.SignatureType == RPMSIG_PGP262_1024)
+  {
+    UInt64 pos;
+    RINOK(inStream->Seek(256, STREAM_SEEK_CUR, &pos));
+  }
+  else if (lead.SignatureType == RPMSIG_HEADERSIG)
+  {
+    RINOK(RedSigHeaderSig(inStream, sigHeader));
+    if (!sigHeader.MagicCheck())
+      return S_FALSE;
+    UInt32 len = sigHeader.GetLostHeaderLen();
+    RINOK(inStream->Seek(len, STREAM_SEEK_CUR, &pos));
+    if ((pos % 8) != 0)
+    {
+      RINOK(inStream->Seek((pos / 8 + 1) * 8 - pos,
+          STREAM_SEEK_CUR, &pos));
+    }
+  }
+  else
+    return S_FALSE;
+
+  RINOK(RedSigHeaderSig(inStream, header));
+  if (!header.MagicCheck())
+    return S_FALSE;
+  int headerLen = header.GetLostHeaderLen();
+  if (headerLen == -1)
+    return S_FALSE;
+  RINOK(inStream->Seek(headerLen, STREAM_SEEK_CUR, &pos));
+  return S_OK;
+}
+
+class CHandler:
+  public IInArchive,
+  public IInArchiveGetStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<IInStream> _stream;
+  UInt64 _pos;
+  UInt64 _size;
+  Byte _sig[4];
+public:
+  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
+  INTERFACE_IInArchive(;)
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+};
+
+STATPROPSTG kProps[] =
+{
+  { NULL, kpidSize, VT_UI8}
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  switch(propID) { case kpidMainSubfile: prop = (UInt32)0; break; }
+  prop.Detach(value);
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Open(IInStream *inStream,
+    const UInt64 * /* maxCheckStartPosition */,
+    IArchiveOpenCallback * /* openArchiveCallback */)
+{
+  COM_TRY_BEGIN
+  try
+  {
+    Close();
+    if (OpenArchive(inStream) != S_OK)
+      return S_FALSE;
+    RINOK(inStream->Seek(0, STREAM_SEEK_CUR, &_pos));
+    RINOK(ReadStream_FALSE(inStream, _sig, sizeof(_sig) / sizeof(_sig[0])));
+    UInt64 endPosition;
+    RINOK(inStream->Seek(0, STREAM_SEEK_END, &endPosition));
+    _size = endPosition - _pos;
+    _stream = inStream;
+    return S_OK;
+  }
+  catch(...) { return S_FALSE; }
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  _stream.Release();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = 1;
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value)
+{
+  NWindows::NCOM::CPropVariant prop;
+  switch(propID)
+  {
+    case kpidSize:
+    case kpidPackSize:
+      prop = _size;
+      break;
+    case kpidExtension:
+    {
+      char s[32];
+      MyStringCopy(s, "cpio.");
+      const char *ext;
+      if (_sig[0] == 0x1F && _sig[1] == 0x8B)
+        ext = "gz";
+      else if (_sig[0] == 'B' && _sig[1] == 'Z' && _sig[2] == 'h')
+        ext = "bz2";
+      else
+        ext = "lzma";
+      MyStringCopy(s + MyStringLen(s), ext);
+      prop = s;
+      break;
+    }
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback)
+{
+  COM_TRY_BEGIN
+  if (numItems == 0)
+    return S_OK;
+  if (numItems != (UInt32)-1 && (numItems != 1 || indices[0] != 0))
+    return E_INVALIDARG;
+
+  RINOK(extractCallback->SetTotal(_size));
+  CMyComPtr<ISequentialOutStream> outStream;
+  Int32 askMode = testMode ?
+      NExtract::NAskMode::kTest :
+      NExtract::NAskMode::kExtract;
+  RINOK(extractCallback->GetStream(0, &outStream, askMode));
+  if (!testMode && !outStream)
+    return S_OK;
+  RINOK(extractCallback->PrepareOperation(askMode));
+
+  CMyComPtr<ICompressCoder> copyCoder = new NCompress::CCopyCoder;
+
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
+  lps->Init(extractCallback, false);
+  
+  RINOK(_stream->Seek(_pos, STREAM_SEEK_SET, NULL));
+  RINOK(copyCoder->Code(_stream, outStream, NULL, NULL, progress));
+  outStream.Release();
+  return extractCallback->SetOperationResult(NExtract::NOperationResult::kOK);
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream)
+{
+  COM_TRY_BEGIN
+  return CreateLimitedInStream(_stream, _pos, _size, stream);
+  COM_TRY_END
+}
+
+static IInArchive *CreateArc() { return new NArchive::NRpm::CHandler; }
+
+static CArcInfo g_ArcInfo =
+  { L"Rpm", L"rpm", 0, 0xEB, { 0xED, 0xAB, 0xEE, 0xDB}, 4, false, CreateArc, 0 };
+
+REGISTER_ARC(Rpm)
+
+}}