seven-zip 1.4.0

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipIn.h

@@ -0,0 +1,125 @@
+// Archive/ZipIn.h
+
+#ifndef __ZIP_IN_H
+#define __ZIP_IN_H
+
+#include "Common/MyCom.h"
+
+#include "../../IStream.h"
+
+#include "../../Common/InBuffer.h"
+
+#include "ZipHeader.h"
+#include "ZipItemEx.h"
+
+namespace NArchive {
+namespace NZip {
+  
+class CInArchiveException
+{
+public:
+  enum ECauseType
+  {
+    kUnexpectedEndOfArchive = 0,
+    kArchiceHeaderCRCError,
+    kFileHeaderCRCError,
+    kIncorrectArchive,
+    kDataDescroptorsAreNotSupported,
+    kMultiVolumeArchiveAreNotSupported,
+    kReadStreamError,
+    kSeekStreamError
+  }
+  Cause;
+  CInArchiveException(ECauseType cause): Cause(cause) {}
+};
+
+class CInArchiveInfo
+{
+public:
+  UInt64 Base;
+  UInt64 StartPosition;
+  UInt64 FinishPosition;
+  CByteBuffer Comment;
+
+  CInArchiveInfo(): Base(0), StartPosition(0) {}
+  UInt64 GetPhySize() const { return FinishPosition - StartPosition; }
+  void Clear()
+  {
+    Base = 0;
+    StartPosition = 0;
+    Comment.SetCapacity(0);
+  }
+};
+
+class CProgressVirt
+{
+public:
+  STDMETHOD(SetTotal)(UInt64 numFiles) PURE;
+  STDMETHOD(SetCompleted)(UInt64 numFiles) PURE;
+};
+
+struct CCdInfo
+{
+  // UInt64 NumEntries;
+  UInt64 Size;
+  UInt64 Offset;
+};
+
+class CInArchive
+{
+  CMyComPtr<IInStream> m_Stream;
+  UInt32 m_Signature;
+  UInt64 m_StreamStartPosition;
+  UInt64 m_Position;
+ 
+  bool _inBufMode;
+  CInBuffer _inBuffer;
+  
+  HRESULT Seek(UInt64 offset);
+
+  HRESULT FindAndReadMarker(IInStream *stream, const UInt64 *searchHeaderSizeLimit);
+  void ReadFileName(UInt32 nameSize, AString &dest);
+  
+  HRESULT ReadBytes(void *data, UInt32 size, UInt32 *processedSize);
+  bool ReadBytesAndTestSize(void *data, UInt32 size);
+  void SafeReadBytes(void *data, UInt32 size);
+  void ReadBuffer(CByteBuffer &buffer, UInt32 size);
+  Byte ReadByte();
+  UInt16 ReadUInt16();
+  UInt32 ReadUInt32();
+  UInt64 ReadUInt64();
+  bool ReadUInt32(UInt32 &signature);
+  
+  void Skip(UInt64 num);
+  void IncreaseRealPosition(UInt64 addValue);
+ 
+  void ReadExtra(UInt32 extraSize, CExtraBlock &extraBlock,
+      UInt64 &unpackSize, UInt64 &packSize, UInt64 &localHeaderOffset, UInt32 &diskStartNumber);
+  HRESULT ReadLocalItem(CItemEx &item);
+  HRESULT ReadLocalItemDescriptor(CItemEx &item);
+  HRESULT ReadCdItem(CItemEx &item);
+  HRESULT TryEcd64(UInt64 offset, CCdInfo &cdInfo);
+  HRESULT FindCd(CCdInfo &cdInfo);
+  HRESULT TryReadCd(CObjectVector<CItemEx> &items, UInt64 cdOffset, UInt64 cdSize, CProgressVirt *progress);
+  HRESULT ReadCd(CObjectVector<CItemEx> &items, UInt64 &cdOffset, UInt64 &cdSize, CProgressVirt *progress);
+  HRESULT ReadLocalsAndCd(CObjectVector<CItemEx> &items, CProgressVirt *progress, UInt64 &cdOffset, int &numCdItems);
+public:
+  CInArchiveInfo ArcInfo;
+  bool IsZip64;
+  bool IsOkHeaders;
+
+  HRESULT ReadHeaders(CObjectVector<CItemEx> &items, CProgressVirt *progress);
+  HRESULT ReadLocalItemAfterCdItem(CItemEx &item);
+  HRESULT ReadLocalItemAfterCdItemFull(CItemEx &item);
+  HRESULT Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit);
+  void Close();
+  bool SeekInArchive(UInt64 position);
+  ISequentialInStream *CreateLimitedStream(UInt64 position, UInt64 size);
+  IInStream* CreateStream();
+
+  bool IsOpen() const { return m_Stream != NULL; }
+};
+  
+}}
+  
+#endif

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipItem.cpp

@@ -0,0 +1,181 @@
+// Archive/ZipItem.cpp
+
+#include "StdAfx.h"
+
+#include "ZipHeader.h"
+#include "ZipItem.h"
+#include "../Common/ItemNameUtils.h"
+#include "../../../../C/CpuArch.h"
+
+namespace NArchive {
+namespace NZip {
+
+bool operator==(const CVersion &v1, const CVersion &v2)
+{
+  return (v1.Version == v2.Version) && (v1.HostOS == v2.HostOS);
+}
+
+bool operator!=(const CVersion &v1, const CVersion &v2)
+{
+  return !(v1 == v2);
+}
+
+bool CExtraSubBlock::ExtractNtfsTime(int index, FILETIME &ft) const
+{
+  ft.dwHighDateTime = ft.dwLowDateTime = 0;
+  UInt32 size = (UInt32)Data.GetCapacity();
+  if (ID != NFileHeader::NExtraID::kNTFS || size < 32)
+    return false;
+  const Byte *p = (const Byte *)Data;
+  p += 4; // for reserved
+  size -= 4;
+  while (size > 4)
+  {
+    UInt16 tag = GetUi16(p);
+    UInt32 attrSize = GetUi16(p + 2);
+    p += 4;
+    size -= 4;
+    if (attrSize > size)
+      attrSize = size;
+    
+    if (tag == NFileHeader::NNtfsExtra::kTagTime && attrSize >= 24)
+    {
+      p += 8 * index;
+      ft.dwLowDateTime = GetUi32(p);
+      ft.dwHighDateTime = GetUi32(p + 4);
+      return true;
+    }
+    p += attrSize;
+    size -= attrSize;
+  }
+  return false;
+}
+
+bool CExtraSubBlock::ExtractUnixTime(int index, UInt32 &res) const
+{
+  res = 0;
+  UInt32 size = (UInt32)Data.GetCapacity();
+  if (ID != NFileHeader::NExtraID::kUnixTime || size < 5)
+    return false;
+  const Byte *p = (const Byte *)Data;
+  Byte flags = *p++;
+  size--;
+  for (int i = 0; i < 3; i++)
+    if ((flags & (1 << i)) != 0)
+    {
+      if (size < 4)
+        return false;
+      if (index == i)
+      {
+        res = GetUi32(p);
+        return true;
+      }
+      p += 4;
+      size -= 4;
+    }
+  return false;
+}
+
+bool CLocalItem::IsDir() const
+{
+  return NItemName::HasTailSlash(Name, GetCodePage());
+}
+
+bool CItem::IsDir() const
+{
+  if (NItemName::HasTailSlash(Name, GetCodePage()))
+    return true;
+  if (!FromCentral)
+    return false;
+  WORD highAttributes = WORD((ExternalAttributes >> 16 ) & 0xFFFF);
+  switch(MadeByVersion.HostOS)
+  {
+    case NFileHeader::NHostOS::kAMIGA:
+      switch (highAttributes & NFileHeader::NAmigaAttribute::kIFMT)
+      {
+        case NFileHeader::NAmigaAttribute::kIFDIR: return true;
+        case NFileHeader::NAmigaAttribute::kIFREG: return false;
+        default: return false; // change it throw kUnknownAttributes;
+      }
+    case NFileHeader::NHostOS::kFAT:
+    case NFileHeader::NHostOS::kNTFS:
+    case NFileHeader::NHostOS::kHPFS:
+    case NFileHeader::NHostOS::kVFAT:
+      return ((ExternalAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
+    case NFileHeader::NHostOS::kAtari:
+    case NFileHeader::NHostOS::kMac:
+    case NFileHeader::NHostOS::kVMS:
+    case NFileHeader::NHostOS::kVM_CMS:
+    case NFileHeader::NHostOS::kAcorn:
+    case NFileHeader::NHostOS::kMVS:
+      return false; // change it throw kUnknownAttributes;
+    default:
+      /*
+      switch (highAttributes & NFileHeader::NUnixAttribute::kIFMT)
+      {
+        case NFileHeader::NUnixAttribute::kIFDIR:
+          return true;
+        default:
+          return false;
+      }
+      */
+      return false;
+  }
+}
+
+#ifndef FILE_ATTRIBUTE_UNIX_EXTENSION
+UInt32 CLocalItem::GetWinAttributes() const
+{
+  DWORD winAttributes = 0;
+  if (IsDir())
+    winAttributes |= FILE_ATTRIBUTE_DIRECTORY;
+  return winAttributes;
+}
+#endif
+
+UInt32 CItem::GetWinAttributes() const
+{
+  DWORD winAttributes = 0;
+  switch(MadeByVersion.HostOS)
+  {
+    case NFileHeader::NHostOS::kFAT:
+    case NFileHeader::NHostOS::kNTFS:
+      if (FromCentral)
+        winAttributes = ExternalAttributes;
+      break;
+#ifdef FILE_ATTRIBUTE_UNIX_EXTENSION
+    case NFileHeader::NHostOS::kUnix:
+        winAttributes = (ExternalAttributes & 0xFFFF0000) | FILE_ATTRIBUTE_UNIX_EXTENSION; 
+        if (winAttributes & (NFileHeader::NUnixAttribute::kIFDIR << 16))
+		winAttributes |= FILE_ATTRIBUTE_DIRECTORY;
+        return winAttributes;
+#endif
+    default:
+      winAttributes = 0; // must be converted from unix value;
+  }
+  if (IsDir())       // test it;
+    winAttributes |= FILE_ATTRIBUTE_DIRECTORY;
+  return winAttributes;
+}
+
+void CLocalItem::SetFlagBits(int startBitNumber, int numBits, int value)
+{
+  UInt16 mask = (UInt16)(((1 << numBits) - 1) << startBitNumber);
+  Flags &= ~mask;
+  Flags |= value << startBitNumber;
+}
+
+void CLocalItem::SetBitMask(int bitMask, bool enable)
+{
+  if(enable)
+    Flags |= bitMask;
+  else
+    Flags &= ~bitMask;
+}
+
+void CLocalItem::SetEncrypted(bool encrypted)
+  { SetBitMask(NFileHeader::NFlags::kEncrypted, encrypted); }
+void CLocalItem::SetUtf8(bool isUtf8)
+  { SetBitMask(NFileHeader::NFlags::kUtf8, isUtf8); }
+
+}}

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipItem.h

@@ -0,0 +1,281 @@
+// Archive/ZipItem.h
+
+#ifndef __ARCHIVE_ZIP_ITEM_H
+#define __ARCHIVE_ZIP_ITEM_H
+
+#include "Common/Types.h"
+#include "Common/MyString.h"
+#include "Common/Buffer.h"
+#include "Common/UTFConvert.h"
+#include "Common/StringConvert.h"
+
+#include "ZipHeader.h"
+
+namespace NArchive {
+namespace NZip {
+
+struct CVersion
+{
+  Byte Version;
+  Byte HostOS;
+};
+
+bool operator==(const CVersion &v1, const CVersion &v2);
+bool operator!=(const CVersion &v1, const CVersion &v2);
+
+struct CExtraSubBlock
+{
+  UInt16 ID;
+  CByteBuffer Data;
+  bool ExtractNtfsTime(int index, FILETIME &ft) const;
+  bool ExtractUnixTime(int index, UInt32 &res) const;
+};
+
+struct CWzAesExtraField
+{
+  UInt16 VendorVersion; // 0x0001 - AE-1, 0x0002 - AE-2,
+  // UInt16 VendorId; // "AE"
+  Byte Strength; // 1 - 128-bit , 2 - 192-bit , 3 - 256-bit
+  UInt16 Method;
+
+  CWzAesExtraField(): VendorVersion(2), Strength(3), Method(0) {}
+
+  bool NeedCrc() const { return (VendorVersion == 1); }
+
+  bool ParseFromSubBlock(const CExtraSubBlock &sb)
+  {
+    if (sb.ID != NFileHeader::NExtraID::kWzAES)
+      return false;
+    if (sb.Data.GetCapacity() < 7)
+      return false;
+    const Byte *p = (const Byte *)sb.Data;
+    VendorVersion = (((UInt16)p[1]) << 8) | p[0];
+    if (p[2] != 'A' || p[3] != 'E')
+      return false;
+    Strength = p[4];
+    Method = (((UInt16)p[6]) << 16) | p[5];
+    return true;
+  }
+  void SetSubBlock(CExtraSubBlock &sb) const
+  {
+    sb.Data.SetCapacity(7);
+    sb.ID = NFileHeader::NExtraID::kWzAES;
+    Byte *p = (Byte *)sb.Data;
+    p[0] = (Byte)VendorVersion;
+    p[1] = (Byte)(VendorVersion >> 8);
+    p[2] = 'A';
+    p[3] = 'E';
+    p[4] = Strength;
+    p[5] = (Byte)Method;
+    p[6] = (Byte)(Method >> 8);
+  }
+};
+
+namespace NStrongCryptoFlags
+{
+  const UInt16 kDES = 0x6601;
+  const UInt16 kRC2old = 0x6602;
+  const UInt16 k3DES168 = 0x6603;
+  const UInt16 k3DES112 = 0x6609;
+  const UInt16 kAES128 = 0x660E;
+  const UInt16 kAES192 = 0x660F;
+  const UInt16 kAES256 = 0x6610;
+  const UInt16 kRC2 = 0x6702;
+  const UInt16 kBlowfish = 0x6720;
+  const UInt16 kTwofish = 0x6721;
+  const UInt16 kRC4 = 0x6801;
+}
+
+struct CStrongCryptoField
+{
+  UInt16 Format;
+  UInt16 AlgId;
+  UInt16 BitLen;
+  UInt16 Flags;
+
+  bool ParseFromSubBlock(const CExtraSubBlock &sb)
+  {
+    if (sb.ID != NFileHeader::NExtraID::kStrongEncrypt)
+      return false;
+    const Byte *p = (const Byte *)sb.Data;
+    if (sb.Data.GetCapacity() < 8)
+      return false;
+    Format = (((UInt16)p[1]) << 8) | p[0];
+    AlgId  = (((UInt16)p[3]) << 8) | p[2];
+    BitLen = (((UInt16)p[5]) << 8) | p[4];
+    Flags  = (((UInt16)p[7]) << 8) | p[6];
+    return (Format == 2);
+  }
+};
+
+struct CExtraBlock
+{
+  CObjectVector<CExtraSubBlock> SubBlocks;
+  void Clear() { SubBlocks.Clear(); }
+  size_t GetSize() const
+  {
+    size_t res = 0;
+    for (int i = 0; i < SubBlocks.Size(); i++)
+      res += SubBlocks[i].Data.GetCapacity() + 2 + 2;
+    return res;
+  }
+  bool GetWzAesField(CWzAesExtraField &aesField) const
+  {
+    for (int i = 0; i < SubBlocks.Size(); i++)
+      if (aesField.ParseFromSubBlock(SubBlocks[i]))
+        return true;
+    return false;
+  }
+
+  bool GetStrongCryptoField(CStrongCryptoField &f) const
+  {
+    for (int i = 0; i < SubBlocks.Size(); i++)
+      if (f.ParseFromSubBlock(SubBlocks[i]))
+        return true;
+    return false;
+  }
+
+  bool HasWzAesField() const
+  {
+    CWzAesExtraField aesField;
+    return GetWzAesField(aesField);
+  }
+
+  bool GetNtfsTime(int index, FILETIME &ft) const
+  {
+    for (int i = 0; i < SubBlocks.Size(); i++)
+    {
+      const CExtraSubBlock &sb = SubBlocks[i];
+      if (sb.ID == NFileHeader::NExtraID::kNTFS)
+        return sb.ExtractNtfsTime(index, ft);
+    }
+    return false;
+  }
+
+  bool GetUnixTime(int index, UInt32 &res) const
+  {
+    for (int i = 0; i < SubBlocks.Size(); i++)
+    {
+      const CExtraSubBlock &sb = SubBlocks[i];
+      if (sb.ID == NFileHeader::NExtraID::kUnixTime)
+        return sb.ExtractUnixTime(index, res);
+    }
+    return false;
+  }
+
+  /*
+  bool HasStrongCryptoField() const
+  {
+    CStrongCryptoField f;
+    return GetStrongCryptoField(f);
+  }
+  */
+
+  void RemoveUnknownSubBlocks()
+  {
+    for (int i = SubBlocks.Size() - 1; i >= 0; i--)
+      if (SubBlocks[i].ID != NFileHeader::NExtraID::kWzAES)
+        SubBlocks.Delete(i);
+  }
+};
+
+
+class CLocalItem
+{
+public:
+  CVersion ExtractVersion;
+  UInt16 Flags;
+  UInt16 CompressionMethod;
+  UInt32 Time;
+  UInt32 FileCRC;
+  UInt64 PackSize;
+  UInt64 UnPackSize;
+  
+  AString Name;
+
+  CExtraBlock LocalExtra;
+
+  bool IsUtf8() const { return (Flags & NFileHeader::NFlags::kUtf8) != 0; }
+  
+  bool IsEncrypted() const { return (Flags & NFileHeader::NFlags::kEncrypted) != 0; }
+  bool IsStrongEncrypted() const { return IsEncrypted() && (Flags & NFileHeader::NFlags::kStrongEncrypted) != 0; };
+  bool IsAesEncrypted() const { return IsEncrypted() && (IsStrongEncrypted() || CompressionMethod == NFileHeader::NCompressionMethod::kWzAES); };
+  
+  bool IsLzmaEOS() const { return (Flags & NFileHeader::NFlags::kLzmaEOS) != 0; }
+  
+  bool IsDir() const;
+  bool IgnoreItem() const { return false; }
+  UInt32 GetWinAttributes() const;
+  
+  bool HasDescriptor() const  { return (Flags & NFileHeader::NFlags::kDescriptorUsedMask) != 0; }
+
+  UString GetUnicodeString(const AString &s) const
+  {
+    UString res;
+    if (IsUtf8())
+      if (!ConvertUTF8ToUnicode(s, res))
+        res.Empty();
+    if (res.IsEmpty())
+      res = MultiByteToUnicodeString(s, GetCodePage());
+    return res;
+  }
+  
+private:
+  void SetFlagBits(int startBitNumber, int numBits, int value);
+  void SetBitMask(int bitMask, bool enable);
+public:
+  void ClearFlags() { Flags = 0; }
+  void SetEncrypted(bool encrypted);
+  void SetUtf8(bool isUtf8);
+
+  WORD GetCodePage() const { return  CP_OEMCP; }
+};
+
+class CItem: public CLocalItem
+{
+public:
+  CVersion MadeByVersion;
+  UInt16 InternalAttributes;
+  UInt32 ExternalAttributes;
+  
+  UInt64 LocalHeaderPosition;
+  
+  FILETIME NtfsMTime;
+  FILETIME NtfsATime;
+  FILETIME NtfsCTime;
+
+  CExtraBlock CentralExtra;
+  CByteBuffer Comment;
+
+  bool FromLocal;
+  bool FromCentral;
+  bool NtfsTimeIsDefined;
+  
+  bool IsDir() const;
+  UInt32 GetWinAttributes() const;
+
+  bool IsThereCrc() const
+  {
+    if (CompressionMethod == NFileHeader::NCompressionMethod::kWzAES)
+    {
+      CWzAesExtraField aesField;
+      if (CentralExtra.GetWzAesField(aesField))
+        return aesField.NeedCrc();
+    }
+    return (FileCRC != 0 || !IsDir());
+  }
+  
+  WORD GetCodePage() const
+  {
+    return (WORD)((MadeByVersion.HostOS == NFileHeader::NHostOS::kFAT
+        || MadeByVersion.HostOS == NFileHeader::NHostOS::kNTFS
+        ) ? CP_OEMCP : CP_ACP);
+  }
+  CItem() : FromLocal(false), FromCentral(false), NtfsTimeIsDefined(false) {}
+};
+
+}}
+
+#endif
+
+

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipItemEx.h

@@ -0,0 +1,34 @@
+// Archive/ZipItemEx.h
+
+#ifndef __ARCHIVE_ZIP_ITEMEX_H
+#define __ARCHIVE_ZIP_ITEMEX_H
+
+#include "ZipHeader.h"
+#include "ZipItem.h"
+
+namespace NArchive {
+namespace NZip {
+  
+class CItemEx: public CItem
+{
+public:
+  UInt32 FileHeaderWithNameSize;
+  UInt16 LocalExtraSize;
+  
+  UInt64 GetLocalFullSize() const
+    { return FileHeaderWithNameSize + LocalExtraSize + PackSize +
+      (HasDescriptor() ? NFileHeader::kDataDescriptorSize : 0); };
+  /*
+  UInt64 GetLocalFullSize(bool isZip64) const
+    { return FileHeaderWithNameSize + LocalExtraSize + PackSize +
+    (HasDescriptor() ? (isZip64 ? NFileHeader::kDataDescriptor64Size : NFileHeader::kDataDescriptorSize) : 0); };
+  */
+  UInt64 GetLocalExtraPosition() const
+    { return LocalHeaderPosition + FileHeaderWithNameSize; };
+  UInt64 GetDataPosition() const
+    { return GetLocalExtraPosition() + LocalExtraSize; };
+};
+
+}}
+
+#endif