7zip-native 0.0.0-stage → 0.0.5

package/vendor/7zip/CPP/7zip/Archive/Iso/IsoIn.h

@@ -0,0 +1,328 @@
+// Archive/IsoIn.h
+
+#ifndef ZIP7_INC_ARCHIVE_ISO_IN_H
+#define ZIP7_INC_ARCHIVE_ISO_IN_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IStream.h"
+
+#include "IsoHeader.h"
+#include "IsoItem.h"
+
+namespace NArchive {
+namespace NIso {
+
+struct CDir: public CDirRecord
+{
+  CDir *Parent;
+  CObjectVector<CDir> _subItems;
+
+  void Clear()
+  {
+    Parent = NULL;
+    _subItems.Clear();
+  }
+  
+  AString GetPath(bool checkSusp, unsigned skipSize) const
+  {
+    AString s;
+
+    unsigned len = 0;
+    const CDir *cur = this;
+
+    for (;;)
+    {
+      unsigned curLen;
+      cur->GetNameCur(checkSusp, skipSize, curLen);
+      len += curLen;
+      cur = cur->Parent;
+      if (!cur || !cur->Parent)
+        break;
+      len++;
+    }
+
+    char *p = s.GetBuf_SetEnd(len) + len;
+    
+    cur = this;
+    
+    for (;;)
+    {
+      unsigned curLen;
+      const Byte *name = cur->GetNameCur(checkSusp, skipSize, curLen);
+      p -= curLen;
+      if (curLen != 0)
+        memcpy(p, name, curLen);
+      cur = cur->Parent;
+      if (!cur || !cur->Parent)
+        break;
+      p--;
+      *p = CHAR_PATH_SEPARATOR;
+    }
+    
+    return s;
+  }
+
+  void GetPathU(UString &s) const
+  {
+    s.Empty();
+    
+    unsigned len = 0;
+    const CDir *cur = this;
+
+    for (;;)
+    {
+      unsigned curLen = (unsigned)(cur->FileId.Size() / 2);
+      const Byte *fid = cur->FileId;
+
+      unsigned i;
+      for (i = 0; i < curLen; i++)
+        if (fid[i * 2] == 0 && fid[i * 2 + 1] == 0)
+          break;
+      len += i;
+      cur = cur->Parent;
+      if (!cur || !cur->Parent)
+        break;
+      len++;
+    }
+
+    wchar_t *p = s.GetBuf_SetEnd(len) + len;
+    
+    cur = this;
+    
+    for (;;)
+    {
+      unsigned curLen = (unsigned)(cur->FileId.Size() / 2);
+      const Byte *fid = cur->FileId;
+
+      unsigned i;
+      for (i = 0; i < curLen; i++)
+        if (fid[i * 2] == 0 && fid[i * 2 + 1] == 0)
+          break;
+      curLen = i;
+
+      p -= curLen;
+      for (i = 0; i < curLen; i++)
+        p[i] = (wchar_t)(((wchar_t)fid[i * 2] << 8) | fid[i * 2 + 1]);
+      cur = cur->Parent;
+      if (!cur || !cur->Parent)
+        break;
+      p--;
+      *p = WCHAR_PATH_SEPARATOR;
+    }
+  }
+};
+
+struct CDateTime
+{
+  UInt16 Year;
+  Byte Month;
+  Byte Day;
+  Byte Hour;
+  Byte Minute;
+  Byte Second;
+  Byte Hundredths;
+  signed char GmtOffset; // min intervals from -48 (West) to +52 (East) recorded.
+  
+  bool NotSpecified() const { return Year == 0 && Month == 0 && Day == 0 &&
+      Hour == 0 && Minute == 0 && Second == 0 && GmtOffset == 0; }
+
+  bool GetFileTime(NWindows::NCOM::CPropVariant &prop) const
+  {
+    UInt64 v;
+    const bool res = NWindows::NTime::GetSecondsSince1601(Year, Month, Day, Hour, Minute, Second, v);
+    if (res)
+    {
+      v = (UInt64)((Int64)v - (Int64)((Int32)GmtOffset * 15 * 60));
+      v *= 10000000;
+      if (Hundredths < 100)
+        v += (UInt32)Hundredths * 100000;
+      prop.SetAsTimeFrom_Ft64_Prec(v, k_PropVar_TimePrec_Base + 2);
+    }
+    return res;
+  }
+};
+
+struct CBootRecordDescriptor
+{
+  Byte BootSystemId[32];  // a-characters
+  Byte BootId[32];        // a-characters
+  Byte BootSystemUse[1977];
+};
+
+struct CBootValidationEntry
+{
+  Byte PlatformId;
+  Byte Id[24]; // to identify the manufacturer/developer of the CD-ROM.
+};
+
+struct CBootInitialEntry
+{
+  bool Bootable;
+  Byte BootMediaType;
+  UInt16 LoadSegment;
+  /* This is the load segment for the initial boot image. If this
+     value is 0 the system will use the traditional segment of 7C0. If this value
+     is non-zero the system will use the specified segment. This applies to x86
+     architectures only. For "flat" model architectures (such as Motorola) this
+     is the address divided by 10. */
+  Byte SystemType;    // This must be a copy of byte 5 (System Type) from the
+                      // Partition Table found in the boot image.
+  UInt16 SectorCount; // This is the number of virtual/emulated sectors the system
+                      // will store at Load Segment during the initial boot procedure.
+  UInt32 LoadRBA;     // This is the start address of the virtual disk. CDs use
+                      // Relative/Logical block addressing.
+
+  Byte VendorSpec[20];
+
+  UInt32 GetSize() const
+  {
+    // if (BootMediaType == NBootMediaType::k1d44Floppy) (1440 << 10);
+    return (UInt32)SectorCount * 512;
+  }
+
+  bool Parse(const Byte *p);
+  AString GetName() const;
+};
+
+struct CVolumeDescriptor
+{
+  Byte VolFlags;
+  Byte SystemId[32]; // a-characters. An identification of a system
+                     // which can recognize and act upon the content of the Logical
+                     // Sectors with logical Sector Numbers 0 to 15 of the volume.
+  Byte VolumeId[32]; // d-characters. An identification of the volume.
+  UInt32 VolumeSpaceSize; // the number of Logical Blocks in which the Volume Space of the volume is recorded
+  Byte EscapeSequence[32];
+  UInt16 VolumeSetSize;
+  UInt16 VolumeSequenceNumber; // the ordinal number of the volume in the Volume Set of which the volume is a member.
+  UInt16 LogicalBlockSize;
+  UInt32 PathTableSize;
+  UInt32 LPathTableLocation;
+  UInt32 LOptionalPathTableLocation;
+  UInt32 MPathTableLocation;
+  UInt32 MOptionalPathTableLocation;
+  CDirRecord RootDirRecord;
+  Byte VolumeSetId[128];
+  Byte PublisherId[128];
+  Byte DataPreparerId[128];
+  Byte ApplicationId[128];
+  Byte CopyrightFileId[37];
+  Byte AbstractFileId[37];
+  Byte BibFileId[37];
+  CDateTime CTime;
+  CDateTime MTime;
+  CDateTime ExpirationTime;
+  CDateTime EffectiveTime;
+  // Byte FileStructureVersion; // = 1;
+  Byte ApplicationUse[512];
+
+  bool IsJoliet() const
+  {
+    if ((VolFlags & 1) != 0)
+      return false;
+    const Byte b = EscapeSequence[2];
+    return (EscapeSequence[0] == 0x25 && EscapeSequence[1] == 0x2F &&
+      (b == 0x40 || b == 0x43 || b == 0x45));
+  }
+
+  UInt64 Get_VolumeSpaceSize_inBytes() const { return (UInt64)VolumeSpaceSize * LogicalBlockSize; }
+};
+
+struct CRef
+{
+  const CDir *Dir;
+  UInt32 Index;
+  UInt32 NumExtents;
+  UInt64 TotalSize;
+};
+
+const unsigned kBlockSize = 1 << 11;
+
+class CInArchive
+{
+  UInt64 _position;
+  unsigned m_BufferPos;
+  
+  void Skip(size_t size);
+  void SkipZeros(size_t size);
+  Byte ReadByte();
+  void ReadBytes(Byte *data, UInt32 size);
+  UInt16 ReadUInt16();
+  UInt32 ReadUInt32Le();
+  UInt32 ReadUInt32Be();
+  UInt32 ReadUInt32();
+  UInt64 ReadUInt64();
+  unsigned ReadDigits(unsigned numDigits);
+  void ReadDateTime(CDateTime &d);
+  void ReadRecordingDateTime(CRecordingDateTime &t);
+  void ReadDirRecord(CDirRecord &r, unsigned len, bool isJolietDescriptor = false);
+
+  void ReadBootRecordDescriptor(CBootRecordDescriptor &d);
+  void ReadVolumeDescriptor(CVolumeDescriptor &d);
+
+  void SeekToBlock(UInt32 blockIndex);
+  HRESULT ReadDir(CDir &d, unsigned level);
+  void CreateRefs(CDir &d);
+
+  void ReadBootInfo();
+  HRESULT Open2();
+public:
+  HRESULT Open(IInStream *inStream, IArchiveOpenCallback *openCallback);
+  void Clear();
+
+  UInt64 _fileSize;
+  UInt64 PhySize;
+
+  CRecordVector<CRef> Refs;
+  CObjectVector<CVolumeDescriptor> VolDescs;
+  int MainVolDescIndex;
+  // UInt32 BlockSize;
+  CObjectVector<CBootInitialEntry> BootEntries;
+
+private:
+  bool _bootIsDefined;
+public:
+  bool IsArc;
+  bool UnexpectedEnd;
+  bool HeadersError;
+  bool IncorrectBigEndian;
+  bool TooDeepDirs;
+  bool TooBigMetadata;
+  bool SelfLinkedDirs;
+  bool IsSusp;
+  unsigned SuspSkipSize;
+
+private:
+  int _expand_BootEntries_index;
+
+  CRecordVector<UInt32> UniqStartLocations;
+
+  void UpdatePhySize(const UInt32 blockIndex, const UInt64 size)
+  {
+    const UInt64 alignedSize = (size + kBlockSize - 1) & ~((UInt64)kBlockSize - 1);
+    const UInt64 end = (UInt64)blockIndex * kBlockSize + alignedSize;
+    if (PhySize < end)
+      PhySize = end;
+  }
+
+public:
+  bool IsJoliet() const { return VolDescs[MainVolDescIndex].IsJoliet(); }
+
+  UInt64 GetBootItemSize(unsigned index) const;
+
+private:
+  CDir _rootDir;
+  IInStream *_stream;
+  IArchiveOpenCallback *_openCallback;
+  UInt64 _numFiles;
+  UInt64 _processedBytes;
+  UInt64 _processedBytes_prev;
+
+  Byte m_Buffer[kBlockSize];
+  CBootRecordDescriptor _bootDesc;
+};
+  
+}}
+  
+#endif

package/vendor/7zip/CPP/7zip/Archive/Iso/IsoItem.h

@@ -0,0 +1,316 @@
+// Archive/IsoItem.h
+
+#ifndef ZIP7_INC_ARCHIVE_ISO_ITEM_H
+#define ZIP7_INC_ARCHIVE_ISO_ITEM_H
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyString.h"
+#include "../../../Common/MyBuffer.h"
+
+#include "../../../Windows/TimeUtils.h"
+
+#include "IsoHeader.h"
+
+namespace NArchive {
+namespace NIso {
+
+struct CRecordingDateTime
+{
+  Byte Year;
+  Byte Month;
+  Byte Day;
+  Byte Hour;
+  Byte Minute;
+  Byte Second;
+  signed char GmtOffset; // min intervals from -48 (West) to +52 (East) recorded.
+  
+  bool GetFileTime(NWindows::NCOM::CPropVariant &prop) const
+  {
+    UInt64 v;
+    const bool res = NWindows::NTime::GetSecondsSince1601(Year + 1900, Month, Day, Hour, Minute, Second, v);
+    if (res)
+    {
+      v = (UInt64)((Int64)v - (Int64)((Int32)GmtOffset * 15 * 60));
+      v *= 10000000;
+      prop.SetAsTimeFrom_Ft64_Prec(v, k_PropVar_TimePrec_Base);
+    }
+    return res;
+  }
+};
+
+enum EPx
+{
+  k_Px_Mode,
+  k_Px_Links,
+  k_Px_User,
+  k_Px_Group,
+  k_Px_SerialNumber
+
+  // k_Px_Num
+};
+
+/*
+enum ETf
+{
+  k_Tf_CTime,
+  k_Tf_MTime,
+  k_Tf_ATime,
+  k_Tf_Attrib,
+  k_Tf_Backup,
+  k_Tf_Expiration,
+  k_Tf_Effective
+
+  // k_Tf_Num
+};
+*/
+
+struct CDirRecord
+{
+  UInt32 ExtentLocation;
+  UInt32 Size;
+  CRecordingDateTime DateTime;
+  Byte FileFlags;
+  Byte FileUnitSize;
+  Byte InterleaveGapSize;
+  Byte ExtendedAttributeRecordLen;
+  UInt16 VolSequenceNumber;
+  CByteBuffer FileId;
+  CByteBuffer SystemUse;
+
+  bool AreMultiPartEqualWith(const CDirRecord &a) const
+  {
+    return FileId == a.FileId
+        && ((FileFlags ^ a.FileFlags) & ~NFileFlags::kNonFinalExtent) == 0;
+  }
+
+  bool IsDir() const { return (FileFlags & NFileFlags::kDirectory) != 0; }
+  bool IsNonFinalExtent() const { return (FileFlags & NFileFlags::kNonFinalExtent) != 0; }
+
+  bool IsSystemItem() const
+  {
+    return FileId.Size() == 1 && *(const Byte *)FileId < 2;
+  }
+
+  
+  const Byte* FindSuspRecord(unsigned skipSize, Byte id0, Byte id1, unsigned &lenRes) const
+  {
+    lenRes = 0;
+    if (SystemUse.Size() < skipSize)
+      return NULL;
+    const Byte *p = (const Byte *)SystemUse + skipSize;
+    unsigned rem = (unsigned)(SystemUse.Size() - skipSize);
+    while (rem >= 5)
+    {
+      unsigned len = p[2];
+      if (len < 3 || len > rem)
+        return NULL;
+      if (p[0] == id0 && p[1] == id1 && p[3] == 1)
+      {
+        if (len < 4)
+          return NULL; // Check it
+        lenRes = len - 4;
+        return p + 4;
+      }
+      p += len;
+      rem -= len;
+    }
+    return NULL;
+  }
+
+  
+  const Byte* GetNameCur(bool checkSusp, unsigned skipSize, unsigned &nameLenRes) const
+  {
+    const Byte *res = NULL;
+    unsigned len = 0;
+    if (checkSusp)
+      res = FindSuspRecord(skipSize, 'N', 'M', len);
+    if (!res || len < 1)
+    {
+      res = (const Byte *)FileId;
+      len = (unsigned)FileId.Size();
+    }
+    else
+    {
+      res++;
+      len--;
+    }
+    unsigned i;
+    for (i = 0; i < len; i++)
+      if (res[i] == 0)
+        break;
+    nameLenRes = i;
+    return res;
+  }
+
+
+  bool GetSymLink(unsigned skipSize, AString &link) const
+  {
+    link.Empty();
+    const Byte *p = NULL;
+    unsigned len = 0;
+    p = FindSuspRecord(skipSize, 'S', 'L', len);
+    if (!p || len < 1)
+      return false;
+
+    if (*p != 0)
+      return false;
+
+    p++;
+    len--;
+
+    while (len != 0)
+    {
+      if (len < 2)
+        return false;
+      unsigned flags = p[0];
+      unsigned cl = p[1];
+      p += 2;
+      len -= 2;
+
+      if (cl > len)
+        return false;
+
+      bool needSlash = false;
+      
+           if (flags & (1 << 1)) link += "./";
+      else if (flags & (1 << 2)) link += "../";
+      else if (flags & (1 << 3)) link.Add_Slash();
+      else
+        needSlash = true;
+
+      for (unsigned i = 0; i < cl; i++)
+      {
+        const Byte c = p[i];
+        if (c == 0)
+        {
+          break;
+          // return false;
+        }
+        link += (char)c;
+      }
+
+      p += cl;
+      len -= cl;
+
+      if (len == 0)
+        break;
+
+      if (needSlash)
+        link.Add_Slash();
+    }
+
+    return true;
+  }
+
+  static bool GetLe32Be32(const Byte *p, UInt32 &dest)
+  {
+    UInt32 v1 = GetUi32(p);
+    UInt32 v2 = GetBe32(p + 4);
+    if (v1 == v2)
+    {
+      dest = v1;
+      return true;
+    }
+    return false;
+  }
+
+
+  bool GetPx(unsigned skipSize, unsigned pxType, UInt32 &val) const
+  {
+    val = 0;
+    const Byte *p = NULL;
+    unsigned len = 0;
+    p = FindSuspRecord(skipSize, 'P', 'X', len);
+    if (!p)
+      return false;
+    // px.Clear();
+    if (len < (pxType + 1) * 8)
+      return false;
+
+    return GetLe32Be32(p + pxType * 8, val);
+  }
+
+  /*
+  bool GetTf(int skipSize, unsigned pxType, CRecordingDateTime &t) const
+  {
+    const Byte *p = NULL;
+    unsigned len = 0;
+    p = FindSuspRecord(skipSize, 'T', 'F', len);
+    if (!p)
+      return false;
+    if (len < 1)
+      return false;
+    Byte flags = *p++;
+    len--;
+
+    unsigned step = 7;
+    if (flags & 0x80)
+    {
+      step = 17;
+      return false;
+    }
+
+    if ((flags & (1 << pxType)) == 0)
+      return false;
+
+    for (unsigned i = 0; i < pxType; i++)
+    {
+      if (len < step)
+        return false;
+      if (flags & (1 << i))
+      {
+        p += step;
+        len -= step;
+      }
+    }
+
+    if (len < step)
+      return false;
+    
+    t.Year = p[0];
+    t.Month = p[1];
+    t.Day = p[2];
+    t.Hour = p[3];
+    t.Minute = p[4];
+    t.Second = p[5];
+    t.GmtOffset = (signed char)p[6];
+
+    return true;
+  }
+  */
+
+  bool CheckSusp(const Byte *p, unsigned &startPos) const
+  {
+    if (p[0] == 'S' &&
+        p[1] == 'P' &&
+        p[2] == 0x7 &&
+        p[3] == 0x1 &&
+        p[4] == 0xBE &&
+        p[5] == 0xEF)
+    {
+      startPos = p[6];
+      return true;
+    }
+    return false;
+  }
+
+  bool CheckSusp(unsigned &startPos) const
+  {
+    const Byte *p = (const Byte *)SystemUse;
+    const size_t len = SystemUse.Size();
+    const unsigned kMinLen = 7;
+    if (len < kMinLen)
+      return false;
+    if (CheckSusp(p, startPos))
+      return true;
+    const unsigned kOffset2 = 14;
+    if (len < kOffset2 + kMinLen)
+      return false;
+    return CheckSusp(p + kOffset2, startPos);
+  }
+};
+
+}}
+
+#endif

package/vendor/7zip/CPP/7zip/Archive/Iso/IsoRegister.cpp

@@ -0,0 +1,21 @@
+// IsoRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "IsoHandler.h"
+
+namespace NArchive {
+namespace NIso {
+
+static const Byte k_Signature[] = { 'C', 'D', '0', '0', '1' };
+
+REGISTER_ARC_I(
+  "Iso", "iso img", NULL, 0xE7,
+  k_Signature,
+  NArchive::NIso::kStartPos + 1,
+  0,
+  NULL)
+
+}}

package/vendor/7zip/CPP/7zip/Archive/Iso/StdAfx.h

@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif