seven_zip_ruby 1.0.0

data/ext/p7zip/CPP/7zip/Archive/Cab/CabHandler.h

@@ -0,0 +1,28 @@
+// CabHandler.h
+
+#ifndef __CAB_HANDLER_H
+#define __CAB_HANDLER_H
+
+#include "Common/MyCom.h"
+#include "../IArchive.h"
+#include "CabIn.h"
+
+namespace NArchive {
+namespace NCab {
+
+class CHandler:
+  public IInArchive,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1(IInArchive)
+
+  INTERFACE_IInArchive(;)
+
+private:
+  CMvDatabaseEx m_Database;
+};
+
+}}
+
+#endif

data/ext/p7zip/CPP/7zip/Archive/Cab/CabHeader.cpp

@@ -0,0 +1,15 @@
+// CabHeader.cpp
+
+#include "StdAfx.h"
+
+#include "CabHeader.h"
+
+namespace NArchive {
+namespace NCab {
+namespace NHeader {
+
+Byte kMarker[kMarkerSize] = {'M', 'S', 'C', 'F', 0, 0, 0, 0 };
+
+// struct CSignatureInitializer { CSignatureInitializer() { kMarker[0]--; }; } g_SignatureInitializer;
+
+}}}

data/ext/p7zip/CPP/7zip/Archive/Cab/CabHeader.h

@@ -0,0 +1,44 @@
+// Archive/Cab/Header.h
+
+#ifndef __ARCHIVE_CAB_HEADER_H
+#define __ARCHIVE_CAB_HEADER_H
+
+#include "Common/Types.h"
+
+namespace NArchive {
+namespace NCab {
+namespace NHeader {
+
+const unsigned kMarkerSize = 8;
+extern Byte kMarker[kMarkerSize];
+
+namespace NArchive
+{
+  namespace NFlags
+  {
+    const int kPrevCabinet = 0x0001;
+    const int kNextCabinet = 0x0002;
+    const int kReservePresent = 0x0004;
+  }
+}
+
+namespace NCompressionMethodMajor
+{
+  const Byte kNone = 0;
+  const Byte kMSZip = 1;
+  const Byte kQuantum = 2;
+  const Byte kLZX = 3;
+}
+
+const int kFileNameIsUTFAttributeMask = 0x80;
+
+namespace NFolderIndex
+{
+  const int kContinuedFromPrev    = 0xFFFD;
+  const int kContinuedToNext      = 0xFFFE;
+  const int kContinuedPrevAndNext = 0xFFFF;
+}
+
+}}}
+
+#endif

data/ext/p7zip/CPP/7zip/Archive/Cab/CabIn.cpp

@@ -0,0 +1,272 @@
+// Archive/CabIn.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/FindSignature.h"
+
+#include "CabIn.h"
+
+namespace NArchive {
+namespace NCab {
+
+Byte CInArchive::Read8()
+{
+  Byte b;
+  if (!inBuffer.ReadByte(b))
+    throw CInArchiveException(CInArchiveException::kUnsupported);
+  return b;
+}
+
+UInt16 CInArchive::Read16()
+{
+  UInt16 value = 0;
+  for (int i = 0; i < 2; i++)
+  {
+    Byte b = Read8();
+    value |= (UInt16(b) << (8 * i));
+  }
+  return value;
+}
+
+UInt32 CInArchive::Read32()
+{
+  UInt32 value = 0;
+  for (int i = 0; i < 4; i++)
+  {
+    Byte b = Read8();
+    value |= (UInt32(b) << (8 * i));
+  }
+  return value;
+}
+
+AString CInArchive::SafeReadName()
+{
+  AString name;
+  for (;;)
+  {
+    Byte b = Read8();
+    if (b == 0)
+      return name;
+    name += (char)b;
+  }
+}
+
+void CInArchive::ReadOtherArchive(COtherArchive &oa)
+{
+  oa.FileName = SafeReadName();
+  oa.DiskName = SafeReadName();
+}
+
+void CInArchive::Skip(UInt32 size)
+{
+  while (size-- != 0)
+    Read8();
+}
+
+HRESULT CInArchive::Open(const UInt64 *searchHeaderSizeLimit, CDatabaseEx &db)
+{
+  IInStream *stream = db.Stream;
+  db.Clear();
+  RINOK(stream->Seek(0, STREAM_SEEK_SET, &db.StartPosition));
+
+  RINOK(FindSignatureInStream(stream, NHeader::kMarker, NHeader::kMarkerSize,
+      searchHeaderSizeLimit, db.StartPosition));
+
+  RINOK(stream->Seek(db.StartPosition + NHeader::kMarkerSize, STREAM_SEEK_SET, NULL));
+  if (!inBuffer.Create(1 << 17))
+    return E_OUTOFMEMORY;
+  inBuffer.SetStream(stream);
+  inBuffer.Init();
+
+  CInArchiveInfo &ai = db.ArchiveInfo;
+
+  ai.Size = Read32();
+  if (Read32() != 0)
+    return S_FALSE;
+  ai.FileHeadersOffset = Read32();
+  if (Read32() != 0)
+    return S_FALSE;
+
+  ai.VersionMinor = Read8();
+  ai.VersionMajor = Read8();
+  ai.NumFolders = Read16();
+  ai.NumFiles = Read16();
+  ai.Flags = Read16();
+  if (ai.Flags > 7)
+    return S_FALSE;
+  ai.SetID = Read16();
+  ai.CabinetNumber = Read16();
+
+  if (ai.ReserveBlockPresent())
+  {
+    ai.PerCabinetAreaSize = Read16();
+    ai.PerFolderAreaSize = Read8();
+    ai.PerDataBlockAreaSize = Read8();
+
+    Skip(ai.PerCabinetAreaSize);
+  }
+
+  {
+    if (ai.IsTherePrev())
+      ReadOtherArchive(ai.PrevArc);
+    if (ai.IsThereNext())
+      ReadOtherArchive(ai.NextArc);
+  }
+  
+  int i;
+  for (i = 0; i < ai.NumFolders; i++)
+  {
+    CFolder folder;
+
+    folder.DataStart = Read32();
+    folder.NumDataBlocks = Read16();
+    folder.CompressionTypeMajor = Read8();
+    folder.CompressionTypeMinor = Read8();
+
+    Skip(ai.PerFolderAreaSize);
+    db.Folders.Add(folder);
+  }
+  
+  RINOK(stream->Seek(db.StartPosition + ai.FileHeadersOffset, STREAM_SEEK_SET, NULL));
+
+  inBuffer.SetStream(stream);
+  inBuffer.Init();
+  for (i = 0; i < ai.NumFiles; i++)
+  {
+    CItem item;
+    item.Size = Read32();
+    item.Offset = Read32();
+    item.FolderIndex = Read16();
+    UInt16 pureDate = Read16();
+    UInt16 pureTime = Read16();
+    item.Time = ((UInt32(pureDate) << 16)) | pureTime;
+    item.Attributes = Read16();
+    item.Name = SafeReadName();
+    int folderIndex = item.GetFolderIndex(db.Folders.Size());
+    if (folderIndex >= db.Folders.Size())
+      return S_FALSE;
+    db.Items.Add(item);
+  }
+  return S_OK;
+}
+
+#define RINOZ(x) { int __tt = (x); if (__tt != 0) return __tt; }
+
+static int CompareMvItems(const CMvItem *p1, const CMvItem *p2, void *param)
+{
+  const CMvDatabaseEx &mvDb = *(const CMvDatabaseEx *)param;
+  const CDatabaseEx &db1 = mvDb.Volumes[p1->VolumeIndex];
+  const CDatabaseEx &db2 = mvDb.Volumes[p2->VolumeIndex];
+  const CItem &item1 = db1.Items[p1->ItemIndex];
+  const CItem &item2 = db2.Items[p2->ItemIndex];;
+  bool isDir1 = item1.IsDir();
+  bool isDir2 = item2.IsDir();
+  if (isDir1 && !isDir2)
+    return -1;
+  if (isDir2 && !isDir1)
+    return 1;
+  int f1 = mvDb.GetFolderIndex(p1);
+  int f2 = mvDb.GetFolderIndex(p2);
+  RINOZ(MyCompare(f1, f2));
+  RINOZ(MyCompare(item1.Offset, item2.Offset));
+  RINOZ(MyCompare(item1.Size, item2.Size));
+  RINOZ(MyCompare(p1->VolumeIndex, p2->VolumeIndex));
+  return MyCompare(p1->ItemIndex, p2->ItemIndex);
+}
+
+bool CMvDatabaseEx::AreItemsEqual(int i1, int i2)
+{
+  const CMvItem *p1 = &Items[i1];
+  const CMvItem *p2 = &Items[i2];
+  const CDatabaseEx &db1 = Volumes[p1->VolumeIndex];
+  const CDatabaseEx &db2 = Volumes[p2->VolumeIndex];
+  const CItem &item1 = db1.Items[p1->ItemIndex];
+  const CItem &item2 = db2.Items[p2->ItemIndex];;
+  return GetFolderIndex(p1) == GetFolderIndex(p2) &&
+    item1.Offset == item2.Offset &&
+    item1.Size == item2.Size &&
+    item1.Name == item2.Name;
+}
+
+void CMvDatabaseEx::FillSortAndShrink()
+{
+  Items.Clear();
+  StartFolderOfVol.Clear();
+  FolderStartFileIndex.Clear();
+  int offset = 0;
+  for (int v = 0; v < Volumes.Size(); v++)
+  {
+    const CDatabaseEx &db = Volumes[v];
+    int curOffset = offset;
+    if (db.IsTherePrevFolder())
+      curOffset--;
+    StartFolderOfVol.Add(curOffset);
+    offset += db.GetNumberOfNewFolders();
+
+    CMvItem mvItem;
+    mvItem.VolumeIndex = v;
+    for (int i = 0 ; i < db.Items.Size(); i++)
+    {
+      mvItem.ItemIndex = i;
+      Items.Add(mvItem);
+    }
+  }
+
+  Items.Sort(CompareMvItems, (void *)this);
+  int j = 1;
+  int i;
+  for (i = 1; i < Items.Size(); i++)
+    if (!AreItemsEqual(i, i -1))
+      Items[j++] = Items[i];
+  Items.DeleteFrom(j);
+
+  for (i = 0; i < Items.Size(); i++)
+  {
+    int folderIndex = GetFolderIndex(&Items[i]);
+    if (folderIndex >= FolderStartFileIndex.Size())
+      FolderStartFileIndex.Add(i);
+  }
+}
+
+bool CMvDatabaseEx::Check()
+{
+  for (int v = 1; v < Volumes.Size(); v++)
+  {
+    const CDatabaseEx &db1 = Volumes[v];
+    if (db1.IsTherePrevFolder())
+    {
+      const CDatabaseEx &db0 = Volumes[v - 1];
+      if (db0.Folders.IsEmpty() || db1.Folders.IsEmpty())
+        return false;
+      const CFolder &f0 = db0.Folders.Back();
+      const CFolder &f1 = db1.Folders.Front();
+      if (f0.CompressionTypeMajor != f1.CompressionTypeMajor ||
+          f0.CompressionTypeMinor != f1.CompressionTypeMinor)
+        return false;
+    }
+  }
+  UInt32 beginPos = 0;
+  UInt64 endPos = 0;
+  int prevFolder = -2;
+  for (int i = 0; i < Items.Size(); i++)
+  {
+    const CMvItem &mvItem = Items[i];
+    int fIndex = GetFolderIndex(&mvItem);
+    if (fIndex >= FolderStartFileIndex.Size())
+      return false;
+    const CItem &item = Volumes[mvItem.VolumeIndex].Items[mvItem.ItemIndex];
+    if (item.IsDir())
+      continue;
+    int folderIndex = GetFolderIndex(&mvItem);
+    if (folderIndex != prevFolder)
+      prevFolder = folderIndex;
+    else if (item.Offset < endPos &&
+        (item.Offset != beginPos || item.GetEndOffset() != endPos))
+      return false;
+    beginPos = item.Offset;
+    endPos = item.GetEndOffset();
+  }
+  return true;
+}
+
+}}

data/ext/p7zip/CPP/7zip/Archive/Cab/CabIn.h

@@ -0,0 +1,161 @@
+// Archive/CabIn.h
+
+#ifndef __ARCHIVE_CAB_IN_H
+#define __ARCHIVE_CAB_IN_H
+
+#include "../../IStream.h"
+#include "../../Common/InBuffer.h"
+#include "CabHeader.h"
+#include "CabItem.h"
+
+namespace NArchive {
+namespace NCab {
+
+class CInArchiveException
+{
+public:
+  enum CCauseType
+  {
+    kUnexpectedEndOfArchive = 0,
+    kIncorrectArchive,
+    kUnsupported
+  } Cause;
+  CInArchiveException(CCauseType cause) : Cause(cause) {}
+};
+
+struct COtherArchive
+{
+  AString FileName;
+  AString DiskName;
+};
+
+struct CArchiveInfo
+{
+  Byte VersionMinor; /* cabinet file format version, minor */
+  Byte VersionMajor; /* cabinet file format version, major */
+  UInt16 NumFolders; /* number of CFFOLDER entries in this cabinet */
+  UInt16 NumFiles;   /* number of CFFILE entries in this cabinet */
+  UInt16 Flags;      /* cabinet file option indicators */
+  UInt16 SetID;      /* must be the same for all cabinets in a set */
+  UInt16 CabinetNumber; /* number of this cabinet file in a set */
+
+  bool ReserveBlockPresent() const { return (Flags & NHeader::NArchive::NFlags::kReservePresent) != 0; }
+
+  bool IsTherePrev() const { return (Flags & NHeader::NArchive::NFlags::kPrevCabinet) != 0; }
+  bool IsThereNext() const { return (Flags & NHeader::NArchive::NFlags::kNextCabinet) != 0; }
+
+  UInt16 PerCabinetAreaSize; // (optional) size of per-cabinet reserved area
+  Byte PerFolderAreaSize;    // (optional) size of per-folder reserved area
+  Byte PerDataBlockAreaSize; // (optional) size of per-datablock reserved area
+
+  Byte GetDataBlockReserveSize() const { return (Byte)(ReserveBlockPresent() ? PerDataBlockAreaSize : 0); }
+
+  COtherArchive PrevArc;
+  COtherArchive NextArc;
+
+  CArchiveInfo()
+  {
+    Clear();
+  }
+
+  void Clear()
+  {
+    PerCabinetAreaSize = 0;
+    PerFolderAreaSize = 0;
+    PerDataBlockAreaSize = 0;
+  }
+};
+
+struct CInArchiveInfo: public CArchiveInfo
+{
+  UInt32 Size; /* size of this cabinet file in bytes */
+  UInt32 FileHeadersOffset; // offset of the first CFFILE entry
+};
+
+
+struct CDatabase
+{
+  UInt64 StartPosition;
+  CInArchiveInfo ArchiveInfo;
+  CObjectVector<CFolder> Folders;
+  CObjectVector<CItem> Items;
+  
+  void Clear()
+  {
+    ArchiveInfo.Clear();
+    Folders.Clear();
+    Items.Clear();
+  }
+  bool IsTherePrevFolder() const
+  {
+    for (int i = 0; i < Items.Size(); i++)
+      if (Items[i].ContinuedFromPrev())
+        return true;
+    return false;
+  }
+  int GetNumberOfNewFolders() const
+  {
+    int res = Folders.Size();
+    if (IsTherePrevFolder())
+      res--;
+    return res;
+  }
+  UInt32 GetFileOffset(int index) const { return Items[index].Offset; }
+  UInt32 GetFileSize(int index) const { return Items[index].Size; }
+};
+
+struct CDatabaseEx: public CDatabase
+{
+  CMyComPtr<IInStream> Stream;
+};
+
+struct CMvItem
+{
+  int VolumeIndex;
+  int ItemIndex;
+};
+
+class CMvDatabaseEx
+{
+  bool AreItemsEqual(int i1, int i2);
+public:
+  CObjectVector<CDatabaseEx> Volumes;
+  CRecordVector<CMvItem> Items;
+  CRecordVector<int> StartFolderOfVol;
+  CRecordVector<int> FolderStartFileIndex;
+  
+  int GetFolderIndex(const CMvItem *mvi) const
+  {
+    const CDatabaseEx &db = Volumes[mvi->VolumeIndex];
+    return StartFolderOfVol[mvi->VolumeIndex] +
+        db.Items[mvi->ItemIndex].GetFolderIndex(db.Folders.Size());
+  }
+  void Clear()
+  {
+    Volumes.Clear();
+    Items.Clear();
+    StartFolderOfVol.Clear();
+    FolderStartFileIndex.Clear();
+  }
+  void FillSortAndShrink();
+  bool Check();
+};
+
+class CInArchive
+{
+  CInBuffer inBuffer;
+
+  Byte Read8();
+  UInt16 Read16();
+  UInt32 Read32();
+  AString SafeReadName();
+  void Skip(UInt32 size);
+  void ReadOtherArchive(COtherArchive &oa);
+
+public:
+  HRESULT Open(const UInt64 *searchHeaderSizeLimit, CDatabaseEx &db);
+};
+  
+}}
+  
+#endif