seven-zip 1.4.0

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

@@ -0,0 +1,88 @@
+// 7zUpdate.h
+
+#ifndef __7Z_UPDATE_H
+#define __7Z_UPDATE_H
+
+#include "7zCompressionMode.h"
+#include "7zIn.h"
+#include "7zOut.h"
+
+#include "../IArchive.h"
+
+namespace NArchive {
+namespace N7z {
+
+struct CUpdateItem
+{
+  int IndexInArchive;
+  int IndexInClient;
+  
+  UInt64 CTime;
+  UInt64 ATime;
+  UInt64 MTime;
+
+  UInt64 Size;
+  UString Name;
+
+  UInt32 Attrib;
+  
+  bool NewData;
+  bool NewProps;
+
+  bool IsAnti;
+  bool IsDir;
+
+  bool AttribDefined;
+  bool CTimeDefined;
+  bool ATimeDefined;
+  bool MTimeDefined;
+
+  bool HasStream() const { return !IsDir && !IsAnti && Size != 0; }
+
+  CUpdateItem():
+      IsAnti(false),
+      IsDir(false),
+      AttribDefined(false),
+      CTimeDefined(false),
+      ATimeDefined(false),
+      MTimeDefined(false)
+      {}
+  void SetDirStatusFromAttrib() { IsDir = ((Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0); };
+
+  int GetExtensionPos() const;
+  UString GetExtension() const;
+};
+
+struct CUpdateOptions
+{
+  const CCompressionMethodMode *Method;
+  const CCompressionMethodMode *HeaderMethod;
+  bool UseFilters;
+  bool MaxFilter;
+
+  CHeaderOptions HeaderOptions;
+
+  UInt64 NumSolidFiles;
+  UInt64 NumSolidBytes;
+  bool SolidExtension;
+  bool RemoveSfxBlock;
+  bool VolumeMode;
+};
+
+HRESULT Update(
+    DECL_EXTERNAL_CODECS_LOC_VARS
+    IInStream *inStream,
+    const CArchiveDatabaseEx *db,
+    const CObjectVector<CUpdateItem> &updateItems,
+    COutArchive &archive,
+    CArchiveDatabase &newDatabase,
+    ISequentialOutStream *seqOutStream,
+    IArchiveUpdateCallback *updateCallback,
+    const CUpdateOptions &options
+    #ifndef _NO_CRYPTO
+    , ICryptoGetTextPassword *getDecoderPassword
+    #endif
+    );
+}}
+
+#endif

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

@@ -0,0 +1,356 @@
+// ApmHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "Common/ComTry.h"
+#include "Common/IntToString.h"
+#include "Common/MyString.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"
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NApm {
+
+struct CItem
+{
+  UInt32 StartBlock;
+  UInt32 NumBlocks;
+  char Name[32];
+  char Type[32];
+  /*
+  UInt32 DataStartBlock;
+  UInt32 NumDataBlocks;
+  UInt32 Status;
+  UInt32 BootStartBlock;
+  UInt32 BootSize;
+  UInt32 BootAddr;
+  UInt32 BootEntry;
+  UInt32 BootChecksum;
+  char Processor[16];
+  */
+
+  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);
+    /*
+    DataStartBlock = Get32(p + 0x50);
+    NumDataBlocks = Get32(p + 0x54);
+    Status = Get32(p + 0x58);
+    BootStartBlock = Get32(p + 0x5C);
+    BootSize = Get32(p + 0x60);
+    BootAddr = Get32(p + 0x64);
+    if (Get32(p + 0x68) != 0)
+      return false;
+    BootEntry = Get32(p + 0x6C);
+    if (Get32(p + 0x70) != 0)
+      return false;
+    BootChecksum = Get32(p + 0x74);
+    memcpy(Processor, p + 0x78, 16);
+    */
+    return true;
+  }
+};
+
+class CHandler:
+  public IInArchive,
+  public IInArchiveGetStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<IInStream> _stream;
+  CRecordVector<CItem> _items;
+
+  int _blockSizeLog;
+  UInt32 _numBlocks;
+
+  HRESULT ReadTables(IInStream *stream);
+  UInt64 BlocksToBytes(UInt32 i) const { return (UInt64)i << _blockSizeLog; }
+  UInt64 GetItemSize(const CItem &item) { return BlocksToBytes(item.NumBlocks); }
+public:
+  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
+  INTERFACE_IInArchive(;)
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+};
+
+static inline int GetLog(UInt32 num)
+{
+  for (int i = 0; i < 31; i++)
+    if (((UInt32)1 << i) == num)
+      return i;
+  return -1;
+}
+
+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)
+      return S_FALSE;
+    _numBlocks = Get32(buf + 4);
+    for (int i = 8; i < 16; i++)
+      if (buf[i] != 0)
+        return S_FALSE;
+  }
+
+  unsigned numSkips = (unsigned)1 << (_blockSizeLog - 9);
+  for (unsigned j = 1; j < numSkips; j++)
+  {
+    RINOK(ReadStream_FALSE(stream, buf, kSectorSize));
+  }
+
+  UInt32 numBlocksInMap = 0;
+  for (unsigned i = 0;;)
+  {
+    RINOK(ReadStream_FALSE(stream, buf, kSectorSize));
+ 
+    CItem item;
+    
+    UInt32 numBlocksInMap2;
+    if (!item.Parse(buf, numBlocksInMap2))
+      return S_FALSE;
+    if (i == 0)
+    {
+      numBlocksInMap = numBlocksInMap2;
+      if (numBlocksInMap > (1 << 8))
+        return S_FALSE;
+    }
+    else if (numBlocksInMap2 != numBlocksInMap)
+      return S_FALSE;
+
+    UInt32 finish = item.StartBlock + item.NumBlocks;
+    if (finish < item.StartBlock)
+      return S_FALSE;
+    _numBlocks = MyMax(_numBlocks, finish);
+    
+    _items.Add(item);
+    for (unsigned j = 1; j < numSkips; j++)
+    {
+      RINOK(ReadStream_FALSE(stream, buf, kSectorSize));
+    }
+    if (++i == numBlocksInMap)
+      break;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Open(IInStream *stream,
+    const UInt64 * /* maxCheckStartPosition */,
+    IArchiveOpenCallback * /* openArchiveCallback */)
+{
+  COM_TRY_BEGIN
+  Close();
+  RINOK(ReadTables(stream));
+  _stream = stream;
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  _items.Clear();
+  _stream.Release();
+  return S_OK;
+}
+
+STATPROPSTG kProps[] =
+{
+  { NULL, kpidPath, VT_BSTR},
+  { NULL, kpidSize, VT_UI8},
+  { NULL, kpidOffset, VT_UI8}
+};
+
+STATPROPSTG kArcProps[] =
+{
+  { NULL, kpidClusterSize, VT_UI4},
+  { NULL, kpidPhySize, VT_UI8}
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+static AString GetString(const char *s)
+{
+  AString res;
+  for (int i = 0; i < 32 && s[i] != 0; i++)
+    res += s[i];
+  return res;
+}
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  switch(propID)
+  {
+    case kpidMainSubfile:
+    {
+      int mainIndex = -1;
+      for (int i = 0; i < _items.Size(); i++)
+      {
+        AString s = GetString(_items[i].Type);
+        if (s != "Apple_Free" &&
+            s != "Apple_partition_map")
+        {
+          if (mainIndex >= 0)
+          {
+            mainIndex = -1;
+            break;
+          }
+          mainIndex = i;
+        }
+      }
+      if (mainIndex >= 0)
+        prop = (UInt32)mainIndex;
+      break;
+    }
+    case kpidClusterSize: prop = (UInt32)1 << _blockSizeLog; break;
+    case kpidPhySize: prop = BlocksToBytes(_numBlocks); break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _items.Size();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  const CItem &item = _items[index];
+  switch(propID)
+  {
+    case kpidPath:
+    {
+      AString s = GetString(item.Name);
+      if (s.IsEmpty())
+      {
+        char s2[32];
+        ConvertUInt32ToString(index, s2);
+        s = s2;
+      }
+      AString type = GetString(item.Type);
+      if (type == "Apple_HFS")
+        type = "hfs";
+      if (!type.IsEmpty())
+      {
+        s += '.';
+        s += type;
+      }
+      prop = s;
+      break;
+    }
+    case kpidSize:
+    case kpidPackSize:
+      prop = GetItemSize(item);
+      break;
+    case kpidOffset: prop = BlocksToBytes(item.StartBlock); break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  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 };
+
+REGISTER_ARC(Apm)
+
+}}

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

@@ -0,0 +1,135 @@
+// ArchiveExports.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+
+static const unsigned int kNumArcsMax = 48;
+static unsigned int g_NumArcs = 0;
+static unsigned int g_DefaultArcIndex = 0;
+static const CArcInfo *g_Arcs[kNumArcsMax];
+void RegisterArc(const CArcInfo *arcInfo)
+{
+  if (g_NumArcs < kNumArcsMax)
+  {
+    const wchar_t *p = arcInfo->Name;
+    if (p[0] == '7' && p[1] == 'z' && p[2] == 0)
+      g_DefaultArcIndex = g_NumArcs;
+    g_Arcs[g_NumArcs++] = arcInfo;
+  }
+}
+
+DEFINE_GUID(CLSID_CArchiveHandler,
+0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00);
+
+#define CLS_ARC_ID_ITEM(cls) ((cls).Data4[5])
+
+static inline HRESULT SetPropString(const char *s, unsigned int size, PROPVARIANT *value)
+{
+  if ((value->bstrVal = ::SysAllocStringByteLen(s, size)) != 0)
+    value->vt = VT_BSTR;
+  return S_OK;
+}
+
+static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value)
+{
+  return SetPropString((const char *)&guid, sizeof(GUID), value);
+}
+
+int FindFormatCalssId(const GUID *clsID)
+{
+  GUID cls = *clsID;
+  CLS_ARC_ID_ITEM(cls) = 0;
+  if (cls != CLSID_CArchiveHandler)
+    return -1;
+  Byte id = CLS_ARC_ID_ITEM(*clsID);
+  for (unsigned i = 0; i < g_NumArcs; i++)
+    if (g_Arcs[i]->ClassId == id)
+      return (int)i;
+  return -1;
+}
+
+STDAPI CreateArchiver(const GUID *clsid, const GUID *iid, void **outObject)
+{
+  COM_TRY_BEGIN
+  {
+    int needIn = (*iid == IID_IInArchive);
+    int needOut = (*iid == IID_IOutArchive);
+    if (!needIn && !needOut)
+      return E_NOINTERFACE;
+    int formatIndex = FindFormatCalssId(clsid);
+    if (formatIndex < 0)
+      return CLASS_E_CLASSNOTAVAILABLE;
+    
+    const CArcInfo &arc = *g_Arcs[formatIndex];
+    if (needIn)
+    {
+      *outObject = arc.CreateInArchive();
+      ((IInArchive *)*outObject)->AddRef();
+    }
+    else
+    {
+      if (!arc.CreateOutArchive)
+        return CLASS_E_CLASSNOTAVAILABLE;
+      *outObject = arc.CreateOutArchive();
+      ((IOutArchive *)*outObject)->AddRef();
+    }
+  }
+  COM_TRY_END
+  return S_OK;
+}
+
+STDAPI GetHandlerProperty2(UInt32 formatIndex, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  if (formatIndex >= g_NumArcs)
+    return E_INVALIDARG;
+  const CArcInfo &arc = *g_Arcs[formatIndex];
+  NWindows::NCOM::CPropVariant prop;
+  switch(propID)
+  {
+    case NArchive::kName:
+      prop = arc.Name;
+      break;
+    case NArchive::kClassID:
+    {
+      GUID clsId = CLSID_CArchiveHandler;
+      CLS_ARC_ID_ITEM(clsId) = arc.ClassId;
+      return SetPropGUID(clsId, value);
+    }
+    case NArchive::kExtension:
+      if (arc.Ext != 0)
+        prop = arc.Ext;
+      break;
+    case NArchive::kAddExtension:
+      if (arc.AddExt != 0)
+        prop = arc.AddExt;
+      break;
+    case NArchive::kUpdate:
+      prop = (bool)(arc.CreateOutArchive != 0);
+      break;
+    case NArchive::kKeepName:
+      prop = arc.KeepName;
+      break;
+    case NArchive::kStartSignature:
+      return SetPropString((const char *)arc.Signature, arc.SignatureSize, value);
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDAPI GetHandlerProperty(PROPID propID, PROPVARIANT *value)
+{
+  return GetHandlerProperty2(g_DefaultArcIndex, propID, value);
+}
+
+STDAPI GetNumberOfFormats(UINT32 *numFormats)
+{
+  *numFormats = g_NumArcs;
+  return S_OK;
+}