seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -1,4 +1,4 @@
-// Rar/Handler.h
+// RarHandler.h
 
 #ifndef __RAR_HANDLER_H
 #define __RAR_HANDLER_H
@@ -7,44 +7,94 @@
 
 #include "../../Common/CreateCoder.h"
 
-#include "RarIn.h"
-#include "RarVolumeInStream.h"
+#include "RarItem.h"
 
 namespace NArchive {
 namespace NRar {
 
+struct CInArcInfo
+{
+  UInt32 Flags;
+  Byte EncryptVersion;
+  
+  UInt64 StartPos;
+  UInt64 EndPos;
+  UInt64 FileSize;
+
+  UInt32 EndFlags;
+  UInt32 VolNumber;
+  UInt32 DataCRC;
+  bool EndOfArchive_was_Read;
+
+  CInArcInfo(): EndFlags(0), EndOfArchive_was_Read(false) {}
+
+  UInt64 GetPhySize() const { return EndPos - StartPos; }
+
+  bool ExtraZeroTail_is_Possible() const { return IsVolume() && IsRecovery() && EndOfArchive_was_Read; }
+
+  bool IsVolume()           const { return (Flags & NHeader::NArchive::kVolume) != 0; }
+  bool IsCommented()        const { return (Flags & NHeader::NArchive::kComment) != 0; }
+  // kLock
+  bool IsSolid()            const { return (Flags & NHeader::NArchive::kSolid) != 0; }
+  bool HaveNewVolumeName()  const { return (Flags & NHeader::NArchive::kNewVolName) != 0; }
+  // kAuthenticity
+  bool IsRecovery()         const { return (Flags & NHeader::NArchive::kRecovery) != 0; }
+  bool IsEncrypted()        const { return (Flags & NHeader::NArchive::kBlockEncryption) != 0; }
+  bool IsFirstVolume()      const { return (Flags & NHeader::NArchive::kFirstVolume) != 0; }
+
+  // bool IsThereEncryptVer()  const { return (Flags & NHeader::NArchive::kEncryptVer) != 0; }
+  // bool IsEncryptOld()       const { return (!IsThereEncryptVer() || EncryptVersion < 36); }
+
+  bool AreMoreVolumes()       const { return (EndFlags & NHeader::NArchive::kEndOfArc_Flags_NextVol) != 0; }
+  bool Is_VolNumber_Defined() const { return (EndFlags & NHeader::NArchive::kEndOfArc_Flags_VolNumber) != 0; }
+  bool Is_DataCRC_Defined()   const { return (EndFlags & NHeader::NArchive::kEndOfArc_Flags_DataCRC) != 0; }
+};
+
+struct CArc
+{
+  CMyComPtr<IInStream> Stream;
+  UInt64 PhySize;
+  // CByteBuffer Comment;
+
+  CArc(): PhySize(0) {}
+  ISequentialInStream *CreateLimitedStream(UInt64 offset, UInt64 size) const;
+};
+
+struct CRefItem
+{
+  unsigned VolumeIndex;
+  unsigned ItemIndex;
+  unsigned NumItems;
+};
+
 class CHandler:
   public IInArchive,
   PUBLIC_ISetCompressCodecsInfo
   public CMyUnknownImp
 {
   CRecordVector<CRefItem> _refItems;
-  CObjectVector<CItemEx> _items;
-  CObjectVector<CInArchive> _archives;
-  NArchive::NRar::CInArchiveInfo _archiveInfo;
-  AString _errorMessage;
+  CObjectVector<CItem> _items;
+  CObjectVector<CArc> _arcs;
+  NArchive::NRar::CInArcInfo _arcInfo;
+  // AString _errorMessage;
+  UInt32 _errorFlags;
+  UInt32 _warningFlags;
+  bool _isArc;
+  UString _missingVolName;
 
   DECL_EXTERNAL_CODECS_VARS
 
-  UInt64 GetPackSize(int refIndex) const;
-
-  bool IsSolid(int refIndex)
-  {
-    const CItemEx &item = _items[_refItems[refIndex].ItemIndex];
-    if (item.UnPackVersion < 20)
-    {
-      if (_archiveInfo.IsSolid())
-        return (refIndex > 0);
-      return false;
-    }
-    return item.IsSolid();
-  }
+  UInt64 GetPackSize(unsigned refIndex) const;
+  bool IsSolid(unsigned refIndex) const;
+  
+  /*
   void AddErrorMessage(const AString &s)
   {
     if (!_errorMessage.IsEmpty())
       _errorMessage += '\n';
     _errorMessage += s;
   }
+  */
 
   HRESULT Open2(IInStream *stream,
       const UInt64 *maxCheckStartPosition,

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

@@ -3,16 +3,15 @@
 #ifndef __ARCHIVE_RAR_HEADER_H
 #define __ARCHIVE_RAR_HEADER_H
 
-#include "Common/Types.h"
+#include "../../../Common/MyTypes.h"
 
 namespace NArchive {
 namespace NRar {
 namespace NHeader {
 
-const int kMarkerSize = 7;
-extern Byte kMarker[kMarkerSize];
+const unsigned kMarkerSize = 7;
   
-const int kArchiveSolid = 0x1;
+const unsigned kArchiveSolid = 0x1;
 
 namespace NBlockType
 {
@@ -42,38 +41,43 @@ namespace NArchive
   const UInt16 kRecovery = 0x40;
   const UInt16 kBlockEncryption  = 0x80;
   const UInt16 kFirstVolume = 0x100; // (set only by RAR 3.0 and later)
-  const UInt16 kEncryptVer = 0x200; // RAR 3.6 there is EncryptVer Byte in End of MainHeader
 
-  const int kHeaderSizeMin = 7;
-  
-  const int kArchiveHeaderSize = 13;
+  // const UInt16 kEncryptVer = 0x200; // RAR 3.6 : that feature was discarded by origial RAR
+
+  const UInt16 kEndOfArc_Flags_NextVol   = 1;
+  const UInt16 kEndOfArc_Flags_DataCRC   = 2;
+  const UInt16 kEndOfArc_Flags_RevSpace  = 4;
+  const UInt16 kEndOfArc_Flags_VolNumber = 8;
 
-  const int kBlockHeadersAreEncrypted = 0x80;
+  const unsigned kHeaderSizeMin = 7;
+  
+  const unsigned kArchiveHeaderSize = 13;
 
+  const unsigned kBlockHeadersAreEncrypted = 0x80;
 }
 
 namespace NFile
 {
-  const int kSplitBefore = 1 << 0;
-  const int kSplitAfter  = 1 << 1;
-  const int kEncrypted   = 1 << 2;
-  const int kComment     = 1 << 3;
-  const int kSolid       = 1 << 4;
+  const unsigned kSplitBefore = 1 << 0;
+  const unsigned kSplitAfter  = 1 << 1;
+  const unsigned kEncrypted   = 1 << 2;
+  const unsigned kComment     = 1 << 3;
+  const unsigned kSolid       = 1 << 4;
   
-  const int kDictBitStart     = 5;
-  const int kNumDictBits  = 3;
-  const int kDictMask         = (1 << kNumDictBits) - 1;
-  const int kDictDirectoryValue  = 0x7;
+  const unsigned kDictBitStart     = 5;
+  const unsigned kNumDictBits  = 3;
+  const unsigned kDictMask         = (1 << kNumDictBits) - 1;
+  const unsigned kDictDirectoryValue  = 0x7;
   
-  const int kSize64Bits    = 1 << 8;
-  const int kUnicodeName   = 1 << 9;
-  const int kSalt          = 1 << 10;
-  const int kOldVersion    = 1 << 11;
-  const int kExtTime       = 1 << 12;
-  // const int kExtFlags      = 1 << 13;
-  // const int kSkipIfUnknown = 1 << 14;
-
-  const int kLongBlock    = 1 << 15;
+  const unsigned kSize64Bits    = 1 << 8;
+  const unsigned kUnicodeName   = 1 << 9;
+  const unsigned kSalt          = 1 << 10;
+  const unsigned kOldVersion    = 1 << 11;
+  const unsigned kExtTime       = 1 << 12;
+  // const unsigned kExtFlags      = 1 << 13;
+  // const unsigned kSkipIfUnknown = 1 << 14;
+
+  const unsigned kLongBlock    = 1 << 15;
   
   /*
   struct CBlock
@@ -134,17 +138,17 @@ namespace NFile
   };
   */
   
-  const int kLabelFileAttribute            = 0x08;
-  const int kWinFileDirectoryAttributeMask = 0x10;
+  const unsigned kLabelFileAttribute            = 0x08;
+  const unsigned kWinFileDirectoryAttributeMask = 0x10;
   
   enum CHostOS
   {
     kHostMSDOS = 0,
-      kHostOS2   = 1,
-      kHostWin32 = 2,
-      kHostUnix  = 3,
-      kHostMacOS = 4,
-      kHostBeOS = 5
+    kHostOS2   = 1,
+    kHostWin32 = 2,
+    kHostUnix  = 3,
+    kHostMacOS = 4,
+    kHostBeOS  = 5
   };
 }
 

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

@@ -3,13 +3,12 @@
 #ifndef __ARCHIVE_RAR_ITEM_H
 #define __ARCHIVE_RAR_ITEM_H
 
-#include "Common/Types.h"
-#include "Common/MyString.h"
+#include "../../../Common/StringConvert.h"
 
 #include "RarHeader.h"
 
-namespace NArchive{
-namespace NRar{
+namespace NArchive {
+namespace NRar {
 
 struct CRarTime
 {
@@ -43,6 +42,8 @@ struct CItem
 
   Byte Salt[8];
   
+  bool Is_Size_Defined() const { return Size != (UInt64)(Int64)-1; }
+
   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; }
@@ -56,22 +57,39 @@ struct CItem
   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) {}
-};
+  UInt32 GetWinAttrib() const;
 
-class CItemEx: public CItem
-{
-public:
   UInt64 Position;
-  UInt16 MainPartSize;
+  unsigned 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; };
+
+  // int BaseFileIndex;
+  // bool IsAltStream;
+
+  UString GetName() const
+  {
+    if (( /* IsAltStream || */ HasUnicodeName()) && !UnicodeName.IsEmpty())
+      return UnicodeName;
+    return MultiByteToUnicodeString(Name, CP_OEMCP);
+  }
+
+  void Clear()
+  {
+    CTimeDefined = false;
+    ATimeDefined = false;
+    Name.Empty();
+    UnicodeName.Empty();
+    // IsAltStream = false;
+    // BaseFileIndex = -1;
+  }
+
+  CItem() { Clear(); }
+
+  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; }
 };
 
 }}

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

@@ -0,0 +1,129 @@
+// RarVol.h
+
+#ifndef __ARCHIVE_RAR_VOL_H
+#define __ARCHIVE_RAR_VOL_H
+
+#include "../../../Common/StringConvert.h"
+
+#include "RarHeader.h"
+
+namespace NArchive {
+namespace NRar {
+
+inline bool IsDigit(wchar_t c)
+{
+  return c >= L'0' && c <= L'9';
+}
+
+class CVolumeName
+{
+  bool _needChangeForNext;
+  UString _before;
+  UString _changed;
+  UString _after;
+public:
+  CVolumeName(): _needChangeForNext(true) {};
+
+  bool InitName(const UString &name, bool newStyle = true)
+  {
+    _needChangeForNext = true;
+    _after.Empty();
+    UString base = name;
+    int dotPos = name.ReverseFind_Dot();
+
+    if (dotPos >= 0)
+    {
+      const UString ext = name.Ptr(dotPos + 1);
+      if (ext.IsEqualTo_Ascii_NoCase("rar"))
+      {
+        _after = name.Ptr(dotPos);
+        base.DeleteFrom(dotPos);
+      }
+      else if (ext.IsEqualTo_Ascii_NoCase("exe"))
+      {
+        _after.SetFromAscii(".rar");
+        base.DeleteFrom(dotPos);
+      }
+      else if (!newStyle)
+      {
+        if (ext.IsEqualTo_Ascii_NoCase("000") ||
+            ext.IsEqualTo_Ascii_NoCase("001") ||
+            ext.IsEqualTo_Ascii_NoCase("r00") ||
+            ext.IsEqualTo_Ascii_NoCase("r01"))
+        {
+          _changed = ext;
+          _before = name.Left(dotPos + 1);
+          return true;
+        }
+      }
+    }
+
+    if (newStyle)
+    {
+      unsigned i = base.Len();
+
+      for (; i != 0; i--)
+        if (!IsDigit(base[i - 1]))
+          break;
+
+      if (i != base.Len())
+      {
+        _before = base.Left(i);
+        _changed = base.Ptr(i);
+        return true;
+      }
+    }
+    
+    _after.Empty();
+    _before = base;
+    _before += L'.';
+    _changed.SetFromAscii("r00");
+    _needChangeForNext = false;
+    return true;
+  }
+
+  /*
+  void MakeBeforeFirstName()
+  {
+    unsigned len = _changed.Len();
+    _changed.Empty();
+    for (unsigned i = 0; i < len; i++)
+      _changed += L'0';
+  }
+  */
+
+  UString GetNextName()
+  {
+    if (_needChangeForNext)
+    {
+      unsigned i = _changed.Len();
+      if (i == 0)
+        return UString();
+      for (;;)
+      {
+        wchar_t c = _changed[--i];
+        if (c == L'9')
+        {
+          c = L'0';
+          _changed.ReplaceOneCharAtPos(i, c);
+          if (i == 0)
+          {
+            _changed.InsertAtFront(L'1');
+            break;
+          }
+          continue;
+        }
+        c++;
+        _changed.ReplaceOneCharAtPos(i, c);
+        break;
+      }
+    }
+    
+    _needChangeForNext = true;
+    return _before + _changed + _after;
+  }
+};
+
+}}
+
+#endif