seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/7z/7zUpdate.h

@@ -3,15 +3,31 @@
 #ifndef __7Z_UPDATE_H
 #define __7Z_UPDATE_H
 
+#include "../IArchive.h"
+
+// #include "../../Common/UniqBlocks.h"
+
 #include "7zCompressionMode.h"
 #include "7zIn.h"
 #include "7zOut.h"
 
-#include "../IArchive.h"
-
 namespace NArchive {
 namespace N7z {
 
+/*
+struct CTreeFolder
+{
+  UString Name;
+  int Parent;
+  CIntVector SubFolders;
+  int UpdateItemIndex;
+  int SortIndex;
+  int SortIndexEnd;
+
+  CTreeFolder(): UpdateItemIndex(-1) {}
+};
+*/
+
 struct CUpdateItem
 {
   int IndexInArchive;
@@ -23,6 +39,15 @@ struct CUpdateItem
 
   UInt64 Size;
   UString Name;
+  /*
+  bool IsAltStream;
+  int ParentFolderIndex;
+  int TreeFolderIndex;
+  */
+
+  // that code is not used in 9.26
+  // int ParentSortIndex;
+  // int ParentSortIndexEnd;
 
   UInt32 Attrib;
   
@@ -37,45 +62,71 @@ struct CUpdateItem
   bool ATimeDefined;
   bool MTimeDefined;
 
+  // int SecureIndex; // 0 means (no_security)
+
   bool HasStream() const { return !IsDir && !IsAnti && Size != 0; }
+  // bool HasStream() const { return !IsDir && !IsAnti /* && Size != 0 */; } // for test purposes
 
   CUpdateItem():
+      // ParentSortIndex(-1),
+      // IsAltStream(false),
       IsAnti(false),
       IsDir(false),
       AttribDefined(false),
       CTimeDefined(false),
       ATimeDefined(false),
       MTimeDefined(false)
+      // SecureIndex(0)
       {}
-  void SetDirStatusFromAttrib() { IsDir = ((Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0); };
+  void SetDirStatusFromAttrib() { IsDir = ((Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0); }
 
-  int GetExtensionPos() const;
-  UString GetExtension() const;
+  // unsigned GetExtensionPos() const;
+  // UString GetExtension() const;
 };
 
 struct CUpdateOptions
 {
   const CCompressionMethodMode *Method;
   const CCompressionMethodMode *HeaderMethod;
-  bool UseFilters;
-  bool MaxFilter;
+  bool UseFilters; // use additional filters for some files
+  bool MaxFilter;  // use BCJ2 filter instead of BCJ
+  int AnalysisLevel;
 
   CHeaderOptions HeaderOptions;
 
   UInt64 NumSolidFiles;
   UInt64 NumSolidBytes;
   bool SolidExtension;
+  
+  bool UseTypeSorting;
+  
   bool RemoveSfxBlock;
-  bool VolumeMode;
+  bool MultiThreadMixer;
+
+  CUpdateOptions():
+      Method(NULL),
+      HeaderMethod(NULL),
+      UseFilters(false),
+      MaxFilter(false),
+      AnalysisLevel(-1),
+      NumSolidFiles((UInt64)(Int64)(-1)),
+      NumSolidBytes((UInt64)(Int64)(-1)),
+      SolidExtension(false),
+      UseTypeSorting(true),
+      RemoveSfxBlock(false),
+      MultiThreadMixer(true)
+    {}
 };
 
 HRESULT Update(
     DECL_EXTERNAL_CODECS_LOC_VARS
     IInStream *inStream,
-    const CArchiveDatabaseEx *db,
+    const CDbEx *db,
     const CObjectVector<CUpdateItem> &updateItems,
+    // const CObjectVector<CTreeFolder> &treeFolders, // treeFolders[0] is root
+    // const CUniqBlocks &secureBlocks,
     COutArchive &archive,
-    CArchiveDatabase &newDatabase,
+    CArchiveDatabaseOut &newDatabase,
     ISequentialOutStream *seqOutStream,
     IArchiveUpdateCallback *updateCallback,
     const CUpdateOptions &options

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

@@ -4,18 +4,16 @@
 
 #include "../../../C/CpuArch.h"
 
-#include "Common/ComTry.h"
-#include "Common/IntToString.h"
-#include "Common/MyString.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/Defs.h"
+#include "../../Common/IntToString.h"
 
-#include "Windows/PropVariant.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"
+#include "HandlerCont.h"
 
 #define Get16(p) GetBe16(p)
 #define Get32(p) GetBe32(p)
@@ -25,6 +23,9 @@ using namespace NWindows;
 namespace NArchive {
 namespace NApm {
 
+static const Byte kSig0 = 'E';
+static const Byte kSig1 = 'R';
+
 struct CItem
 {
   UInt32 StartBlock;
@@ -45,13 +46,13 @@ struct CItem
 
   bool Parse(const Byte *p, UInt32 &numBlocksInMap)
   {
-    if (p[0] != 0x50 || p[1] != 0x4D || p[2] != 0 || p[3] != 0)
-      return false;
     numBlocksInMap = Get32(p + 4);
     StartBlock = Get32(p + 8);
     NumBlocks = Get32(p + 0xC);
     memcpy(Name, p + 0x10, 32);
     memcpy(Type, p + 0x30, 32);
+    if (p[0] != 0x50 || p[1] != 0x4D || p[2] != 0 || p[3] != 0)
+      return false;
     /*
     DataStartBlock = Get32(p + 0x50);
     NumDataBlocks = Get32(p + 0x54);
@@ -71,47 +72,64 @@ struct CItem
   }
 };
 
-class CHandler:
-  public IInArchive,
-  public IInArchiveGetStream,
-  public CMyUnknownImp
+class CHandler: public CHandlerCont
 {
-  CMyComPtr<IInStream> _stream;
   CRecordVector<CItem> _items;
-
-  int _blockSizeLog;
+  unsigned _blockSizeLog;
   UInt32 _numBlocks;
+  UInt64 _phySize;
+  bool _isArc;
 
   HRESULT ReadTables(IInStream *stream);
   UInt64 BlocksToBytes(UInt32 i) const { return (UInt64)i << _blockSizeLog; }
-  UInt64 GetItemSize(const CItem &item) { return BlocksToBytes(item.NumBlocks); }
+
+  virtual int GetItem_ExtractInfo(UInt32 index, UInt64 &pos, UInt64 &size) const
+  {
+    const CItem &item = _items[index];
+    pos = BlocksToBytes(item.StartBlock);
+    size = BlocksToBytes(item.NumBlocks);
+    return NExtract::NOperationResult::kOK;
+  }
+
 public:
-  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
-  INTERFACE_IInArchive(;)
-  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+  INTERFACE_IInArchive_Cont(;)
 };
 
-static inline int GetLog(UInt32 num)
+static const UInt32 kSectorSize = 512;
+
+API_FUNC_static_IsArc IsArc_Apm(const Byte *p, size_t size)
 {
-  for (int i = 0; i < 31; i++)
-    if (((UInt32)1 << i) == num)
-      return i;
-  return -1;
+  if (size < kSectorSize)
+    return k_IsArc_Res_NEED_MORE;
+  if (p[0] != kSig0 || p[1] != kSig1)
+    return k_IsArc_Res_NO;
+  unsigned i;
+  for (i = 8; i < 16; i++)
+    if (p[i] != 0)
+      return k_IsArc_Res_NO;
+  UInt32 blockSize = Get16(p + 2);
+  for (i = 9; ((UInt32)1 << i) != blockSize; i++)
+    if (i >= 12)
+      return k_IsArc_Res_NO;
+  return k_IsArc_Res_YES;
+}
 }
 
 HRESULT CHandler::ReadTables(IInStream *stream)
 {
-  const UInt32 kSectorSize = 512;
   Byte buf[kSectorSize];
   {
     RINOK(ReadStream_FALSE(stream, buf, kSectorSize));
-    if (buf[0] != 0x45 || buf[1] != 0x52)
-      return S_FALSE;
-    _blockSizeLog = GetLog(Get16(buf + 2));
-    if (_blockSizeLog < 9 || _blockSizeLog > 14)
+    if (buf[0] != kSig0 || buf[1] != kSig1)
       return S_FALSE;
+    UInt32 blockSize = Get16(buf + 2);
+    unsigned i;
+    for (i = 9; ((UInt32)1 << i) != blockSize; i++)
+      if (i >= 12)
+        return S_FALSE;
+    _blockSizeLog = i;
     _numBlocks = Get32(buf + 4);
-    for (int i = 8; i < 16; i++)
+    for (i = 8; i < 16; i++)
       if (buf[i] != 0)
         return S_FALSE;
   }
@@ -123,13 +141,14 @@ HRESULT CHandler::ReadTables(IInStream *stream)
   }
 
   UInt32 numBlocksInMap = 0;
+  
   for (unsigned i = 0;;)
   {
     RINOK(ReadStream_FALSE(stream, buf, kSectorSize));
  
     CItem item;
     
-    UInt32 numBlocksInMap2;
+    UInt32 numBlocksInMap2 = 0;
     if (!item.Parse(buf, numBlocksInMap2))
       return S_FALSE;
     if (i == 0)
@@ -154,12 +173,13 @@ HRESULT CHandler::ReadTables(IInStream *stream)
     if (++i == numBlocksInMap)
       break;
   }
+  
+  _phySize = BlocksToBytes(_numBlocks);
+  _isArc = true;
   return S_OK;
 }
 
-STDMETHODIMP CHandler::Open(IInStream *stream,
-    const UInt64 * /* maxCheckStartPosition */,
-    IArchiveOpenCallback * /* openArchiveCallback */)
+STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* callback */)
 {
   COM_TRY_BEGIN
   Close();
@@ -171,22 +191,23 @@ STDMETHODIMP CHandler::Open(IInStream *stream,
 
 STDMETHODIMP CHandler::Close()
 {
+  _isArc = false;
+  _phySize = 0;
   _items.Clear();
   _stream.Release();
   return S_OK;
 }
 
-STATPROPSTG kProps[] =
+static const Byte kProps[] =
 {
-  { NULL, kpidPath, VT_BSTR},
-  { NULL, kpidSize, VT_UI8},
-  { NULL, kpidOffset, VT_UI8}
+  kpidPath,
+  kpidSize,
+  kpidOffset
 };
 
-STATPROPSTG kArcProps[] =
+static const Byte kArcProps[] =
 {
-  { NULL, kpidClusterSize, VT_UI4},
-  { NULL, kpidPhySize, VT_UI8}
+  kpidClusterSize
 };
 
 IMP_IInArchive_Props
@@ -195,7 +216,7 @@ IMP_IInArchive_ArcProps
 static AString GetString(const char *s)
 {
   AString res;
-  for (int i = 0; i < 32 && s[i] != 0; i++)
+  for (unsigned i = 0; i < 32 && s[i] != 0; i++)
     res += s[i];
   return res;
 }
@@ -204,12 +225,12 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
   NCOM::CPropVariant prop;
-  switch(propID)
+  switch (propID)
   {
     case kpidMainSubfile:
     {
       int mainIndex = -1;
-      for (int i = 0; i < _items.Size(); i++)
+      FOR_VECTOR (i, _items)
       {
         AString s = GetString(_items[i].Type);
         if (s != "Apple_Free" &&
@@ -228,7 +249,15 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
       break;
     }
     case kpidClusterSize: prop = (UInt32)1 << _blockSizeLog; break;
-    case kpidPhySize: prop = BlocksToBytes(_numBlocks); break;
+    case kpidPhySize: prop = _phySize; break;
+
+    case kpidErrorFlags:
+    {
+      UInt32 v = 0;
+      if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+      prop = v;
+      break;
+    }
   }
   prop.Detach(value);
   return S_OK;
@@ -246,7 +275,7 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
   COM_TRY_BEGIN
   NCOM::CPropVariant prop;
   const CItem &item = _items[index];
-  switch(propID)
+  switch (propID)
   {
     case kpidPath:
     {
@@ -270,7 +299,7 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
     }
     case kpidSize:
     case kpidPackSize:
-      prop = GetItemSize(item);
+      prop = BlocksToBytes(item.NumBlocks);
       break;
     case kpidOffset: prop = BlocksToBytes(item.StartBlock); break;
   }
@@ -279,78 +308,13 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
   COM_TRY_END
 }
 
-STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
-    Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
-  COM_TRY_BEGIN
-  bool allFilesMode = (numItems == (UInt32)-1);
-  if (allFilesMode)
-    numItems = _items.Size();
-  if (numItems == 0)
-    return S_OK;
-  UInt64 totalSize = 0;
-  UInt32 i;
-  for (i = 0; i < numItems; i++)
-    totalSize += GetItemSize(_items[allFilesMode ? i : indices[i]]);
-  extractCallback->SetTotal(totalSize);
-
-  totalSize = 0;
-  
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
-  lps->Init(extractCallback, false);
-
-  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
-  CMyComPtr<ISequentialInStream> inStream(streamSpec);
-  streamSpec->SetStream(_stream);
-
-  for (i = 0; i < numItems; i++)
-  {
-    lps->InSize = totalSize;
-    lps->OutSize = totalSize;
-    RINOK(lps->SetCur());
-    CMyComPtr<ISequentialOutStream> outStream;
-    Int32 askMode = testMode ?
-        NExtract::NAskMode::kTest :
-        NExtract::NAskMode::kExtract;
-    Int32 index = allFilesMode ? i : indices[i];
-    const CItem &item = _items[index];
-
-    RINOK(extractCallback->GetStream(index, &outStream, askMode));
-    UInt64 size = GetItemSize(item);
-    totalSize += size;
-    if (!testMode && !outStream)
-      continue;
-    RINOK(extractCallback->PrepareOperation(askMode));
-
-    RINOK(_stream->Seek(BlocksToBytes(item.StartBlock), STREAM_SEEK_SET, NULL));
-    streamSpec->Init(size);
-    RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
-    outStream.Release();
-    RINOK(extractCallback->SetOperationResult(copyCoderSpec->TotalSize == size ?
-        NExtract::NOperationResult::kOK:
-        NExtract::NOperationResult::kDataError));
-  }
-  return S_OK;
-  COM_TRY_END
-}
-
-STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
-{
-  COM_TRY_BEGIN
-  const CItem &item = _items[index];
-  return CreateLimitedInStream(_stream, BlocksToBytes(item.StartBlock), GetItemSize(item), stream);
-  COM_TRY_END
-}
-
-static IInArchive *CreateArc() { return new CHandler; }
-
-static CArcInfo g_ArcInfo =
-  { L"APM", L"", 0, 0xD4, { 0x50, 0x4D, 0, 0, 0, 0, 0 }, 7, false, CreateArc, 0 };
+static const Byte k_Signature[] = { kSig0, kSig1 };
 
-REGISTER_ARC(Apm)
+REGISTER_ARC_I(
+  "APM", "apm", 0, 0xD4,
+  k_Signature,
+  0,
+  0,
+  IsArc_Apm)
 
 }}