Add m-esr52 at 52.6.0

8 files changed, 1325 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/ArchiveOpenCallback.cpp b/other-licenses/7zstub/src/7zip/UI/Common/ArchiveOpenCallback.cpp
new file mode 100644
index 000000000..bef05786b
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/ArchiveOpenCallback.cpp
@@ -0,0 +1,117 @@
+// ArchiveOpenCallback.cpp

+

+#include "StdAfx.h"

+

+#include "ArchiveOpenCallback.h"

+

+#include "Common/StringConvert.h"

+#include "Windows/PropVariant.h"

+

+#include "../../Common/FileStreams.h"

+

+using namespace NWindows;

+

+STDMETHODIMP COpenCallbackImp::SetTotal(const UInt64 *files, const UInt64 *bytes)

+{

+  return Callback->SetTotal(files, bytes);

+}

+

+STDMETHODIMP COpenCallbackImp::SetCompleted(const UInt64 *files, const UInt64 *bytes)

+{

+  return Callback->SetTotal(files, bytes);

+}

+  

+STDMETHODIMP COpenCallbackImp::GetProperty(PROPID propID, PROPVARIANT *value)

+{

+  NCOM::CPropVariant propVariant;

+  if (_subArchiveMode)

+  {

+    switch(propID)

+    {

+      case kpidName:

+        propVariant = _subArchiveName;

+        break;

+    }

+    propVariant.Detach(value);

+    return S_OK;

+  }

+  switch(propID)

+  {

+    case kpidName:

+      propVariant = _fileInfo.Name;

+      break;

+    case kpidIsFolder:

+      propVariant = _fileInfo.IsDirectory();

+      break;

+    case kpidSize:

+      propVariant = _fileInfo.Size;

+      break;

+    case kpidAttributes:

+      propVariant = (UInt32)_fileInfo.Attributes;

+      break;

+    case kpidLastAccessTime:

+      propVariant = _fileInfo.LastAccessTime;

+      break;

+    case kpidCreationTime:

+      propVariant = _fileInfo.CreationTime;

+      break;

+    case kpidLastWriteTime:

+      propVariant = _fileInfo.LastWriteTime;

+      break;

+    }

+  propVariant.Detach(value);

+  return S_OK;

+}

+

+int COpenCallbackImp::FindName(const UString &name)

+{

+  for (int i = 0; i < FileNames.Size(); i++)

+    if (name.CompareNoCase(FileNames[i]) == 0)

+      return i;

+  return -1;

+}

+

+struct CInFileStreamVol: public CInFileStream

+{

+  UString Name;

+  COpenCallbackImp *OpenCallbackImp;

+  CMyComPtr<IArchiveOpenCallback> OpenCallbackRef;

+  ~CInFileStreamVol()

+  {

+    int index = OpenCallbackImp->FindName(Name);

+    if (index >= 0)

+      OpenCallbackImp->FileNames.Delete(index);

+  }

+};

+

+STDMETHODIMP COpenCallbackImp::GetStream(const wchar_t *name, 

+    IInStream **inStream)

+{

+  if (_subArchiveMode)

+    return S_FALSE;

+  RINOK(Callback->CheckBreak());

+  *inStream = NULL;

+  UString fullPath = _folderPrefix + name;

+  if (!NFile::NFind::FindFile(fullPath, _fileInfo))

+    return S_FALSE;

+  if (_fileInfo.IsDirectory())

+    return S_FALSE;

+  CInFileStreamVol *inFile = new CInFileStreamVol;

+  CMyComPtr<IInStream> inStreamTemp = inFile;

+  if (!inFile->Open(fullPath))

+    return ::GetLastError();

+  *inStream = inStreamTemp.Detach();

+  inFile->Name = name;

+  inFile->OpenCallbackImp = this;

+  inFile->OpenCallbackRef = this;

+  FileNames.Add(name);

+  return S_OK;

+}

+

+#ifndef _NO_CRYPTO

+STDMETHODIMP COpenCallbackImp::CryptoGetTextPassword(BSTR *password)

+{

+  return Callback->CryptoGetTextPassword(password);

+}

+#endif

+  

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/ArchiveOpenCallback.h b/other-licenses/7zstub/src/7zip/UI/Common/ArchiveOpenCallback.h
new file mode 100644
index 000000000..84d13edc5
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/ArchiveOpenCallback.h
@@ -0,0 +1,87 @@
+// ArchiveOpenCallback.h

+

+#ifndef __ARCHIVE_OPEN_CALLBACK_H

+#define __ARCHIVE_OPEN_CALLBACK_H

+

+#include "Common/String.h"

+#include "Common/MyCom.h"

+#include "Windows/FileFind.h"

+

+#ifndef _NO_CRYPTO

+#include "../../IPassword.h"

+#endif  

+#include "../../Archive/IArchive.h"

+

+struct IOpenCallbackUI

+{

+  virtual HRESULT CheckBreak() = 0;

+  virtual HRESULT SetTotal(const UInt64 *files, const UInt64 *bytes) = 0;

+  virtual HRESULT SetCompleted(const UInt64 *files, const UInt64 *bytes) = 0;

+  #ifndef _NO_CRYPTO

+  virtual HRESULT CryptoGetTextPassword(BSTR *password) = 0;

+  virtual HRESULT GetPasswordIfAny(UString &password) = 0;

+  #endif  

+};

+

+class COpenCallbackImp: 

+  public IArchiveOpenCallback,

+  public IArchiveOpenVolumeCallback,

+  public IArchiveOpenSetSubArchiveName,

+  #ifndef _NO_CRYPTO

+  public ICryptoGetTextPassword,

+  #endif  

+  public CMyUnknownImp

+{

+public:

+  #ifndef _NO_CRYPTO

+  MY_UNKNOWN_IMP3(

+      IArchiveOpenVolumeCallback, 

+      ICryptoGetTextPassword,

+      IArchiveOpenSetSubArchiveName

+      )

+  #else

+  MY_UNKNOWN_IMP2(

+      IArchiveOpenVolumeCallback, 

+      IArchiveOpenSetSubArchiveName

+      )

+  #endif

+

+  STDMETHOD(SetTotal)(const UInt64 *files, const UInt64 *bytes);

+  STDMETHOD(SetCompleted)(const UInt64 *files, const UInt64 *bytes);

+

+  // IArchiveOpenVolumeCallback

+  STDMETHOD(GetProperty)(PROPID propID, PROPVARIANT *value);

+  STDMETHOD(GetStream)(const wchar_t *name, IInStream **inStream);

+

+  #ifndef _NO_CRYPTO

+  // ICryptoGetTextPassword

+  STDMETHOD(CryptoGetTextPassword)(BSTR *password);

+  #endif

+

+  STDMETHOD(SetSubArchiveName(const wchar_t *name))

+  {

+    _subArchiveMode = true;

+    _subArchiveName = name;

+    return  S_OK;

+  }

+

+private:

+  UString _folderPrefix;

+  NWindows::NFile::NFind::CFileInfoW _fileInfo;

+  bool _subArchiveMode;

+  UString _subArchiveName;

+public:

+  UStringVector FileNames;

+  IOpenCallbackUI *Callback;

+  void Init(const UString &folderPrefix,  const UString &fileName)

+  {

+    _folderPrefix = folderPrefix;

+    if (!NWindows::NFile::NFind::FindFile(_folderPrefix + fileName, _fileInfo))

+      throw 1;

+    FileNames.Clear();

+    _subArchiveMode = false;

+  }

+  int FindName(const UString &name);

+};

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/ArchiverInfo.cpp b/other-licenses/7zstub/src/7zip/UI/Common/ArchiverInfo.cpp
new file mode 100644
index 000000000..08c352190
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/ArchiverInfo.cpp
@@ -0,0 +1,359 @@
+// ArchiverInfo.cpp

+

+#include "StdAfx.h"

+

+#include "ArchiverInfo.h"

+

+#ifndef EXCLUDE_COM

+

+#include "Common/StringConvert.h"

+#include "Windows/FileFind.h"

+#include "Windows/FileName.h"

+#include "Windows/DLL.h"

+#ifdef _WIN32

+#include "Windows/Registry.h"

+#endif

+#include "Windows/PropVariant.h"

+#include "../../Archive/IArchive.h"

+

+using namespace NWindows;

+using namespace NFile;

+

+#endif

+

+extern HINSTANCE g_hInstance;

+

+#ifndef EXCLUDE_COM

+

+static void SplitString(const UString &srcString, UStringVector &destStrings)

+{

+  destStrings.Clear();

+  UString string;

+  int len = srcString.Length();

+  if (len == 0)

+    return;

+  for (int i = 0; i < len; i++)

+  {

+    wchar_t c = srcString[i];

+    if (c == L' ')

+    {

+      if (!string.IsEmpty())

+      {

+        destStrings.Add(string);

+        string.Empty();

+      }

+    }

+    else

+      string += c;

+  }

+  if (!string.IsEmpty())

+    destStrings.Add(string);

+}

+

+typedef UInt32 (WINAPI * GetHandlerPropertyFunc)(

+    PROPID propID, PROPVARIANT *value);

+

+static UString GetModuleFolderPrefix()

+{

+  UString path;

+  NDLL::MyGetModuleFileName(g_hInstance, path);

+  int pos = path.ReverseFind(WCHAR_PATH_SEPARATOR);

+  return path.Left(pos + 1);

+}

+

+static wchar_t *kFormatFolderName = L"Formats";

+

+#ifdef _WIN32

+static LPCTSTR kRegistryPath = TEXT("Software\\7-zip");

+static LPCWSTR kProgramPathValue = L"Path";

+static bool ReadPathFromRegistry(HKEY baseKey, UString &path)

+{

+  NRegistry::CKey key;

+  if(key.Open(baseKey, kRegistryPath, KEY_READ) == ERROR_SUCCESS)

+    if (key.QueryValue(kProgramPathValue, path) == ERROR_SUCCESS)

+    {

+      NName::NormalizeDirPathPrefix(path);

+      return true;

+    }

+  return false;

+}

+#endif

+

+static UString GetBaseFolderPrefixFromRegistry()

+{

+  UString moduleFolderPrefix = GetModuleFolderPrefix();

+  NFind::CFileInfoW fileInfo;

+  if (NFind::FindFile(moduleFolderPrefix + kFormatFolderName, fileInfo))

+    if (fileInfo.IsDirectory())

+      return moduleFolderPrefix;

+  UString path;

+  #ifdef _WIN32

+  if(ReadPathFromRegistry(HKEY_CURRENT_USER, path))

+    return path;

+  if(ReadPathFromRegistry(HKEY_LOCAL_MACHINE, path))

+    return path;

+  #endif

+  return moduleFolderPrefix;

+}

+

+typedef UInt32 (WINAPI *CreateObjectPointer)(

+    const GUID *clsID, 

+    const GUID *interfaceID, 

+    void **outObject);

+

+#endif

+

+#ifndef _SFX

+static void SetBuffer(CByteBuffer &bb, const Byte *data, int size)

+{

+  bb.SetCapacity(size);

+  memmove((Byte *)bb, data, size);

+}

+#endif

+

+void ReadArchiverInfoList(CObjectVector<CArchiverInfo> &archivers)

+{

+  archivers.Clear();

+  

+  #ifdef EXCLUDE_COM

+  

+  #ifdef FORMAT_7Z

+  {

+    CArchiverInfo item;

+    item.UpdateEnabled = true;

+    item.Name = L"7z";

+    item.Extensions.Add(CArchiverExtInfo(L"7z"));

+    #ifndef _SFX

+    const unsigned char kSig[] = {'7' , 'z', 0xBC, 0xAF, 0x27, 0x1C};

+    SetBuffer(item.StartSignature, kSig, 6);

+    #endif

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_BZIP2

+  {

+    CArchiverInfo item;

+    item.UpdateEnabled = true;

+    item.KeepName = true;

+    item.Name = L"BZip2";

+    item.Extensions.Add(CArchiverExtInfo(L"bz2"));

+    item.Extensions.Add(CArchiverExtInfo(L"tbz2", L".tar"));

+    #ifndef _SFX

+    const unsigned char sig[] = {'B' , 'Z', 'h' };

+    SetBuffer(item.StartSignature, sig, 3);

+    #endif

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_GZIP

+  {

+    CArchiverInfo item;

+    item.UpdateEnabled = true;

+    item.Name = L"GZip";

+    item.Extensions.Add(CArchiverExtInfo(L"gz"));

+    item.Extensions.Add(CArchiverExtInfo(L"tgz", L".tar"));

+    #ifndef _SFX

+    const unsigned char sig[] = { 0x1F, 0x8B };

+    SetBuffer(item.StartSignature, sig, 2);

+    #endif

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_SPLIT

+  {

+    CArchiverInfo item;

+    item.UpdateEnabled = false;

+    item.KeepName = true;

+    item.Name = L"Split";

+    item.Extensions.Add(CArchiverExtInfo(L"001"));

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_TAR

+  {

+    CArchiverInfo item;

+    item.UpdateEnabled = true;

+    item.Name = L"Tar";

+    item.Extensions.Add(CArchiverExtInfo(L"tar"));

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_ZIP

+  {

+    CArchiverInfo item;

+    item.UpdateEnabled = true;

+    item.Name = L"Zip";

+    item.Extensions.Add(CArchiverExtInfo(L"zip"));

+    #ifndef _SFX

+    const unsigned char sig[] = { 0x50, 0x4B, 0x03, 0x04 };

+    SetBuffer(item.StartSignature, sig, 4);

+    #endif

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_CPIO

+  {

+    CArchiverInfo item;

+    item.Name = L"Cpio";

+    item.Extensions.Add(CArchiverExtInfo(L"cpio"));

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_RPM

+  {

+    CArchiverInfo item;

+    item.Name = L"Rpm";

+    item.Extensions.Add(CArchiverExtInfo(L"rpm", L".cpio.gz"));

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_ARJ

+  {

+    CArchiverInfo item;

+    item.Name = L"Arj";

+    item.Extensions.Add(CArchiverExtInfo(L"arj"));

+    #ifndef _SFX

+    const unsigned char sig[] = { 0x60, 0xEA };

+    SetBuffer(item.StartSignature, sig, 2);

+    #endif

+    archivers.Add(item);

+  }

+  #endif

+

+  #ifdef FORMAT_Z

+  {

+    CArchiverInfo item;

+    item.Name = L"Z";

+    item.Extensions.Add(CArchiverExtInfo(L"Z"));

+    #ifndef _SFX

+    const unsigned char sig[] = { 0x1F, 0x9D };

+    SetBuffer(item.StartSignature, sig, 2);

+    #endif

+    archivers.Add(item);

+  }

+  #endif

+  

+  #else

+

+  UString folderPath = GetBaseFolderPrefixFromRegistry() + 

+      (UString)kFormatFolderName + (UString)WSTRING_PATH_SEPARATOR;

+  NFind::CEnumeratorW enumerator(folderPath + L"*");

+  NFind::CFileInfoW fileInfo;

+  while (enumerator.Next(fileInfo))

+  {

+    if (fileInfo.IsDirectory())

+      continue;

+    UString filePath = folderPath + fileInfo.Name;

+    {

+      NDLL::CLibrary library;

+      if (!library.LoadEx(filePath, LOAD_LIBRARY_AS_DATAFILE))

+        continue;

+    }

+

+    NDLL::CLibrary library;

+    if (!library.Load(filePath))

+      continue;

+    GetHandlerPropertyFunc getHandlerProperty = (GetHandlerPropertyFunc)

+        library.GetProcAddress("GetHandlerProperty");

+    if (getHandlerProperty == NULL)

+      continue;

+

+    CArchiverInfo item;

+    item.FilePath = filePath;

+    

+    NWindows::NCOM::CPropVariant prop;

+    if (getHandlerProperty(NArchive::kName, &prop) != S_OK)

+      continue;

+    if (prop.vt != VT_BSTR)

+      continue;

+    item.Name = prop.bstrVal;

+    prop.Clear();

+

+    if (getHandlerProperty(NArchive::kClassID, &prop) != S_OK)

+      continue;

+    if (prop.vt != VT_BSTR)

+      continue;

+    item.ClassID = *(const GUID *)prop.bstrVal;

+    prop.Clear();

+

+    if (getHandlerProperty(NArchive::kExtension, &prop) != S_OK)

+      continue;

+    if (prop.vt != VT_BSTR)

+      continue;

+

+    UString ext  = prop.bstrVal;

+    UString addExt;

+

+    prop.Clear();

+

+    if (getHandlerProperty(NArchive::kAddExtension, &prop) != S_OK)

+      continue;

+    if (prop.vt == VT_BSTR)

+    {

+      addExt = prop.bstrVal;

+    }

+    else if (prop.vt != VT_EMPTY)

+      continue;

+    prop.Clear();

+

+    UStringVector exts, addExts;

+    SplitString(ext, exts);

+    SplitString(addExt, addExts);

+

+    prop.Clear();

+    for (int i = 0; i < exts.Size(); i++)

+    {

+      CArchiverExtInfo extInfo;

+      extInfo.Ext = exts[i];

+      if (addExts.Size() > 0)

+        extInfo.AddExt = addExts[i];

+      if (extInfo.AddExt == L"*")

+        extInfo.AddExt.Empty();

+      item.Extensions.Add(extInfo);

+    }

+

+    if (getHandlerProperty(NArchive::kUpdate, &prop) == S_OK)

+      if (prop.vt == VT_BOOL)

+        item.UpdateEnabled = VARIANT_BOOLToBool(prop.boolVal);

+    prop.Clear();

+

+    if (item.UpdateEnabled)

+    {

+      if (getHandlerProperty(NArchive::kKeepName, &prop) == S_OK)

+        if (prop.vt == VT_BOOL)

+          item.KeepName = VARIANT_BOOLToBool(prop.boolVal);

+      prop.Clear();

+    }

+

+    if (getHandlerProperty(NArchive::kStartSignature, &prop) == S_OK)

+    {

+      if (prop.vt == VT_BSTR)

+      {

+        UINT len = ::SysStringByteLen(prop.bstrVal);

+        item.StartSignature.SetCapacity(len);

+        memmove(item.StartSignature, prop.bstrVal, len);

+      }

+    }

+    prop.Clear();

+

+    if (getHandlerProperty(NArchive::kAssociate, &prop) == S_OK)

+      if (prop.vt == VT_BOOL)

+        item.Associate = VARIANT_BOOLToBool(prop.boolVal);

+    prop.Clear();

+

+

+    archivers.Add(item);

+  }

+

+  #endif

+}

+

+

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/ArchiverInfo.h b/other-licenses/7zstub/src/7zip/UI/Common/ArchiverInfo.h
new file mode 100644
index 000000000..8c42f7c5b
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/ArchiverInfo.h
@@ -0,0 +1,66 @@
+// ArchiverInfo.h

+

+#ifndef __ARCHIVERINFO_H

+#define __ARCHIVERINFO_H

+

+#include "Common/String.h"

+#include "Common/Types.h"

+#include "Common/Buffer.h"

+

+struct CArchiverExtInfo

+{

+  UString Ext;

+  UString AddExt;

+  CArchiverExtInfo() {}

+  CArchiverExtInfo(const UString &ext): Ext(ext) {}

+  CArchiverExtInfo(const UString &ext, const UString &addExt): Ext(ext), AddExt(addExt) {}

+};

+

+struct CArchiverInfo

+{

+  #ifndef EXCLUDE_COM

+  UString FilePath;

+  CLSID ClassID;

+  #endif

+  UString Name;

+  CObjectVector<CArchiverExtInfo> Extensions;

+  #ifndef _SFX

+  CByteBuffer StartSignature;

+  CByteBuffer FinishSignature;

+  bool Associate;

+  #endif

+  int FindExtension(const UString &ext) const

+  {

+    for (int i = 0; i < Extensions.Size(); i++)

+      if (ext.CompareNoCase(Extensions[i].Ext) == 0)

+        return i;

+    return -1;

+  }

+  UString GetAllExtensions() const

+  {

+    UString s;

+    for (int i = 0; i < Extensions.Size(); i++)

+    {

+      if (i > 0)

+        s += ' ';

+      s += Extensions[i].Ext;

+    }

+    return s;

+  }

+  const UString &GetMainExtension() const 

+  { 

+    return Extensions[0].Ext;

+  }

+  bool UpdateEnabled;

+  bool KeepName;

+

+  CArchiverInfo(): UpdateEnabled(false), KeepName(false)

+  #ifndef _SFX

+  ,Associate(true)

+  #endif

+  {}

+};

+

+void ReadArchiverInfoList(CObjectVector<CArchiverInfo> &archivers);

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/DefaultName.cpp b/other-licenses/7zstub/src/7zip/UI/Common/DefaultName.cpp
new file mode 100644
index 000000000..1ada83a89
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/DefaultName.cpp
@@ -0,0 +1,23 @@
+// DefaultName.cpp

+

+#include "StdAfx.h"

+

+#include "DefaultName.h"

+

+static const wchar_t *kEmptyFileAlias = L"[Content]";

+

+UString GetDefaultName2(const UString &fileName, 

+    const UString &extension, const UString &addSubExtension)

+{

+  int extLength = extension.Length();

+  int fileNameLength = fileName.Length();

+  if (fileNameLength > extLength + 1)

+  {

+    int dotPos = fileNameLength - (extLength + 1);

+    if (fileName[dotPos] == '.')

+      if (extension.CompareNoCase(fileName.Mid(dotPos + 1)) == 0)

+        return fileName.Left(dotPos) + addSubExtension;

+  }

+  return kEmptyFileAlias;

+}

+

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/DefaultName.h b/other-licenses/7zstub/src/7zip/UI/Common/DefaultName.h
new file mode 100644
index 000000000..1788cb856
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/DefaultName.h
@@ -0,0 +1,11 @@
+// DefaultName.h

+

+#ifndef __DEFAULTNAME_H

+#define __DEFAULTNAME_H

+

+#include "Common/String.h"

+

+UString GetDefaultName2(const UString &fileName, 

+    const UString &extension, const UString &addSubExtension);

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp b/other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp
new file mode 100644
index 000000000..59cb31cc5
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.cpp
@@ -0,0 +1,528 @@
+// OpenArchive.cpp

+

+#include "StdAfx.h"

+

+#include "OpenArchive.h"

+

+#include "Common/Wildcard.h"

+

+#include "Windows/FileName.h"

+#include "Windows/FileDir.h"

+#include "Windows/Defs.h"

+#include "Windows/PropVariant.h"

+

+#include "../../Common/FileStreams.h"

+#include "../../Common/StreamUtils.h"

+

+#include "Common/StringConvert.h"

+

+#ifdef FORMAT_7Z

+#include "../../Archive/7z/7zHandler.h"

+#endif

+

+#ifdef FORMAT_BZIP2

+#include "../../Archive/BZip2/BZip2Handler.h"

+#endif

+

+#ifdef FORMAT_GZIP

+#include "../../Archive/GZip/GZipHandler.h"

+#endif

+

+#ifdef FORMAT_SPLIT

+#include "../../Archive/Split/SplitHandler.h"

+#endif

+

+#ifdef FORMAT_TAR

+#include "../../Archive/Tar/TarHandler.h"

+#endif

+

+#ifdef FORMAT_ZIP

+#include "../../Archive/Zip/ZipHandler.h"

+#endif

+

+#ifdef FORMAT_Z

+#include "../../Archive/Z/ZHandler.h"

+#endif

+

+#ifndef EXCLUDE_COM

+#include "HandlerLoader.h"

+#endif

+

+#include "DefaultName.h"

+

+using namespace NWindows;

+

+HRESULT GetArchiveItemPath(IInArchive *archive, UInt32 index, UString &result)

+{

+  NCOM::CPropVariant prop;

+  RINOK(archive->GetProperty(index, kpidPath, &prop));

+  if(prop.vt == VT_BSTR)

+    result = prop.bstrVal;

+  else if (prop.vt == VT_EMPTY)

+    result.Empty();

+  else

+    return E_FAIL;

+  return S_OK;

+}

+

+HRESULT GetArchiveItemPath(IInArchive *archive, UInt32 index, const UString &defaultName, UString &result)

+{

+  RINOK(GetArchiveItemPath(archive, index, result));

+  if (result.IsEmpty())

+    result = defaultName;

+  return S_OK;

+}

+

+HRESULT GetArchiveItemFileTime(IInArchive *archive, UInt32 index, 

+    const FILETIME &defaultFileTime, FILETIME &fileTime)

+{

+  NCOM::CPropVariant prop;

+  RINOK(archive->GetProperty(index, kpidLastWriteTime, &prop));

+  if (prop.vt == VT_FILETIME)

+    fileTime = prop.filetime;

+  else if (prop.vt == VT_EMPTY)

+    fileTime = defaultFileTime;

+  else

+    return E_FAIL;

+  return S_OK;

+}

+

+static HRESULT IsArchiveItemProp(IInArchive *archive, UInt32 index, PROPID propID, bool &result)

+{

+  NCOM::CPropVariant prop;

+  RINOK(archive->GetProperty(index, propID, &prop));

+  if(prop.vt == VT_BOOL)

+    result = VARIANT_BOOLToBool(prop.boolVal);

+  else if (prop.vt == VT_EMPTY)

+    result = false;

+  else

+    return E_FAIL;

+  return S_OK;

+}

+

+HRESULT IsArchiveItemFolder(IInArchive *archive, UInt32 index, bool &result)

+{

+  return IsArchiveItemProp(archive, index, kpidIsFolder, result);

+}

+

+HRESULT IsArchiveItemAnti(IInArchive *archive, UInt32 index, bool &result)

+{

+  return IsArchiveItemProp(archive, index, kpidIsAnti, result);

+}

+

+// Static-SFX (for Linux) can be big

+const UInt64 kMaxCheckStartPosition = 

+#ifdef _WIN32

+1 << 20;

+#else

+1 << 22;

+#endif

+

+

+HRESULT ReOpenArchive(IInArchive *archive, const UString &fileName)

+{

+  CInFileStream *inStreamSpec = new CInFileStream;

+  CMyComPtr<IInStream> inStream(inStreamSpec);

+  inStreamSpec->Open(fileName);

+  return archive->Open(inStream, &kMaxCheckStartPosition, NULL);

+}

+

+#ifndef _SFX

+static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)

+{

+  for (size_t i = 0; i < size; i++)

+    if (p1[i] != p2[i])

+      return false;

+  return true;

+}

+#endif

+

+HRESULT OpenArchive(

+    IInStream *inStream,

+    const UString &fileName, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module,

+    #endif

+    IInArchive **archiveResult, 

+    CArchiverInfo &archiverInfoResult,

+    UString &defaultItemName,

+    IArchiveOpenCallback *openArchiveCallback)

+{

+  *archiveResult = NULL;

+  CObjectVector<CArchiverInfo> archiverInfoList;

+  ReadArchiverInfoList(archiverInfoList);

+  UString extension;

+  {

+    int dotPos = fileName.ReverseFind(L'.');

+    if (dotPos >= 0)

+      extension = fileName.Mid(dotPos + 1);

+  }

+  CIntVector orderIndices;

+  int i;

+  bool finded = false;

+  for(i = 0; i < archiverInfoList.Size(); i++)

+  {

+    if (archiverInfoList[i].FindExtension(extension) >= 0)

+    {

+      orderIndices.Insert(0, i);

+      finded = true;

+    }

+    else

+      orderIndices.Add(i);

+  }

+  

+  #ifndef _SFX

+  if (!finded)

+  {

+    CByteBuffer byteBuffer;

+    const UInt32 kBufferSize = (200 << 10);

+    byteBuffer.SetCapacity(kBufferSize);

+    Byte *buffer = byteBuffer;

+    RINOK(inStream->Seek(0, STREAM_SEEK_SET, NULL));

+    UInt32 processedSize;

+    RINOK(ReadStream(inStream, buffer, kBufferSize, &processedSize));

+    int numFinded = 0;

+    for (int pos = (int)processedSize; pos >= 0 ; pos--)

+    {

+      for(int i = numFinded; i < orderIndices.Size(); i++)

+      {

+        int index = orderIndices[i];

+        const CArchiverInfo &ai = archiverInfoList[index];

+        const CByteBuffer &sig = ai.StartSignature;

+        if (sig.GetCapacity() == 0)

+          continue;

+        if (pos + sig.GetCapacity() > processedSize)

+          continue;

+        if (TestSignature(buffer + pos, sig, sig.GetCapacity()))

+        {

+          orderIndices.Delete(i);

+          orderIndices.Insert(0, index);

+          numFinded++;

+        }

+      }

+    }

+  }

+  #endif

+

+  HRESULT badResult = S_OK;

+  for(i = 0; i < orderIndices.Size(); i++)

+  {

+    inStream->Seek(0, STREAM_SEEK_SET, NULL);

+    const CArchiverInfo &archiverInfo = archiverInfoList[orderIndices[i]];

+    #ifndef EXCLUDE_COM

+    CHandlerLoader loader;

+    #endif

+    CMyComPtr<IInArchive> archive;

+

+    #ifdef FORMAT_7Z

+    if (archiverInfo.Name.CompareNoCase(L"7z") == 0)

+      archive = new NArchive::N7z::CHandler;

+    #endif

+

+    #ifdef FORMAT_BZIP2

+    if (archiverInfo.Name.CompareNoCase(L"BZip2") == 0)

+      archive = new NArchive::NBZip2::CHandler;

+    #endif

+

+    #ifdef FORMAT_GZIP

+    if (archiverInfo.Name.CompareNoCase(L"GZip") == 0)

+      archive = new NArchive::NGZip::CHandler;

+    #endif

+

+    #ifdef FORMAT_SPLIT

+    if (archiverInfo.Name.CompareNoCase(L"Split") == 0)

+      archive = new NArchive::NSplit::CHandler;

+    #endif

+

+    #ifdef FORMAT_TAR

+    if (archiverInfo.Name.CompareNoCase(L"Tar") == 0)

+      archive = new NArchive::NTar::CHandler;

+    #endif

+

+    #ifdef FORMAT_ZIP

+    if (archiverInfo.Name.CompareNoCase(L"Zip") == 0)

+      archive = new NArchive::NZip::CHandler;

+    #endif

+

+    #ifdef FORMAT_Z

+    if (archiverInfo.Name.CompareNoCase(L"Z") == 0)

+      archive = new NArchive::NZ::CHandler;

+    #endif

+

+

+    #ifndef EXCLUDE_COM

+    if (!archive)

+    {

+      HRESULT result = loader.CreateHandler(archiverInfo.FilePath, 

+          archiverInfo.ClassID, (void **)&archive, false);

+      if (result != S_OK)

+        continue;

+    }

+    #endif

+    

+    if (!archive)

+      return E_FAIL;

+    

+    HRESULT result = archive->Open(inStream, &kMaxCheckStartPosition, openArchiveCallback);

+    if(result == S_FALSE)

+      continue;

+    if(result != S_OK)

+    {

+      badResult = result;

+      if(result == E_ABORT)

+        break;

+      continue;

+    }

+    *archiveResult = archive.Detach();

+    #ifndef EXCLUDE_COM

+    *module = loader.Detach();

+    #endif

+    archiverInfoResult = archiverInfo;

+    int subExtIndex = archiverInfo.FindExtension(extension);

+    if (subExtIndex < 0)

+      subExtIndex = 0;

+    defaultItemName = GetDefaultName2(fileName, 

+        archiverInfo.Extensions[subExtIndex].Ext, 

+        archiverInfo.Extensions[subExtIndex].AddExt);

+

+    return S_OK;

+  }

+  if (badResult != S_OK)

+    return badResult;

+  return S_FALSE;

+}

+

+HRESULT OpenArchive(const UString &filePath, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module,

+    #endif

+    IInArchive **archiveResult, 

+    CArchiverInfo &archiverInfo,

+    UString &defaultItemName,

+    IArchiveOpenCallback *openArchiveCallback)

+{

+  CInFileStream *inStreamSpec = new CInFileStream;

+  CMyComPtr<IInStream> inStream(inStreamSpec);

+  if (!inStreamSpec->Open(filePath))

+    return GetLastError();

+  return OpenArchive(inStream, ExtractFileNameFromPath(filePath),

+    #ifndef EXCLUDE_COM

+    module,

+    #endif

+    archiveResult, archiverInfo,

+    defaultItemName, openArchiveCallback);

+}

+

+static void MakeDefaultName(UString &name)

+{

+  int dotPos = name.ReverseFind(L'.');

+  if (dotPos < 0)

+    return;

+  UString ext = name.Mid(dotPos + 1);

+  if (ext.IsEmpty())

+    return;

+  for (int pos = 0; pos < ext.Length(); pos++)

+    if (ext[pos] < L'0' || ext[pos] > L'9')

+      return;

+  name = name.Left(dotPos);

+}

+

+HRESULT OpenArchive(const UString &fileName, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module0,

+    HMODULE *module1,

+    #endif

+    IInArchive **archive0, 

+    IInArchive **archive1, 

+    CArchiverInfo &archiverInfo0,

+    CArchiverInfo &archiverInfo1,

+    UString &defaultItemName0,

+    UString &defaultItemName1,

+    IArchiveOpenCallback *openArchiveCallback)

+{

+  HRESULT result = OpenArchive(fileName, 

+    #ifndef EXCLUDE_COM

+    module0,

+    #endif

+    archive0, archiverInfo0, defaultItemName0, openArchiveCallback);

+  RINOK(result);

+  CMyComPtr<IInArchiveGetStream> getStream;

+  result = (*archive0)->QueryInterface(IID_IInArchiveGetStream, (void **)&getStream);

+  if (result != S_OK || getStream == 0)

+    return S_OK;

+

+  CMyComPtr<ISequentialInStream> subSeqStream;

+  result = getStream->GetStream(0, &subSeqStream);

+  if (result != S_OK)

+    return S_OK;

+

+  CMyComPtr<IInStream> subStream;

+  if (subSeqStream.QueryInterface(IID_IInStream, &subStream) != S_OK)

+    return S_OK;

+  if (!subStream)

+    return S_OK;

+

+  UInt32 numItems;

+  RINOK((*archive0)->GetNumberOfItems(&numItems));

+  if (numItems < 1)

+    return S_OK;

+

+  UString subPath;

+  RINOK(GetArchiveItemPath(*archive0, 0, subPath))

+  if (subPath.IsEmpty())

+  {

+    MakeDefaultName(defaultItemName0);

+    subPath = defaultItemName0;

+    if (archiverInfo0.Name.CompareNoCase(L"7z") == 0)

+    {

+      if (subPath.Right(3).CompareNoCase(L".7z") != 0)

+        subPath += L".7z";

+    }

+  }

+  else

+    subPath = ExtractFileNameFromPath(subPath);

+

+  CMyComPtr<IArchiveOpenSetSubArchiveName> setSubArchiveName;

+  openArchiveCallback->QueryInterface(IID_IArchiveOpenSetSubArchiveName, (void **)&setSubArchiveName);

+  if (setSubArchiveName)

+    setSubArchiveName->SetSubArchiveName(subPath);

+

+  result = OpenArchive(subStream, subPath, 

+    #ifndef EXCLUDE_COM

+    module1,

+    #endif

+    archive1, archiverInfo1, defaultItemName1, openArchiveCallback);

+  return S_OK;

+}

+

+HRESULT MyOpenArchive(const UString &archiveName, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module,

+    #endif

+    IInArchive **archive,

+    UString &defaultItemName,

+    IOpenCallbackUI *openCallbackUI)

+{

+  COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;

+  CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackSpec;

+  openCallbackSpec->Callback = openCallbackUI;

+

+  UString fullName;

+  int fileNamePartStartIndex;

+  NFile::NDirectory::MyGetFullPathName(archiveName, fullName, fileNamePartStartIndex);

+  openCallbackSpec->Init(

+      fullName.Left(fileNamePartStartIndex), 

+      fullName.Mid(fileNamePartStartIndex));

+

+  CArchiverInfo archiverInfo;

+  return OpenArchive(archiveName, 

+      #ifndef EXCLUDE_COM

+      module,

+      #endif

+      archive, 

+      archiverInfo, 

+      defaultItemName,

+      openCallback);

+}

+

+HRESULT MyOpenArchive(const UString &archiveName, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module0,

+    HMODULE *module1,

+    #endif

+    IInArchive **archive0,

+    IInArchive **archive1,

+    UString &defaultItemName0,

+    UString &defaultItemName1,

+    UStringVector &volumePaths,

+    IOpenCallbackUI *openCallbackUI)

+{

+  COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;

+  CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackSpec;

+  openCallbackSpec->Callback = openCallbackUI;

+

+  UString fullName;

+  int fileNamePartStartIndex;

+  NFile::NDirectory::MyGetFullPathName(archiveName, fullName, fileNamePartStartIndex);

+  UString prefix = fullName.Left(fileNamePartStartIndex);

+  UString name = fullName.Mid(fileNamePartStartIndex);

+  openCallbackSpec->Init(prefix, name);

+

+  CArchiverInfo archiverInfo0, archiverInfo1;

+  HRESULT result = OpenArchive(archiveName, 

+      #ifndef EXCLUDE_COM

+      module0,

+      module1,

+      #endif

+      archive0, 

+      archive1, 

+      archiverInfo0, 

+      archiverInfo1, 

+      defaultItemName0,

+      defaultItemName1,

+      openCallback);

+  RINOK(result);

+  volumePaths.Add(prefix + name);

+  for (int i = 0; i < openCallbackSpec->FileNames.Size(); i++)

+    volumePaths.Add(prefix + openCallbackSpec->FileNames[i]);

+  return S_OK;

+}

+

+HRESULT CArchiveLink::Close()

+{

+  if (Archive1 != 0)

+    RINOK(Archive1->Close());

+  if (Archive0 != 0)

+    RINOK(Archive0->Close());

+  return S_OK;

+}

+

+void CArchiveLink::Release()

+{

+  if (Archive1 != 0)

+    Archive1.Release();

+  if (Archive0 != 0)

+    Archive0.Release();

+  #ifndef EXCLUDE_COM

+  Library1.Free();

+  Library0.Free();

+  #endif

+}

+

+HRESULT OpenArchive(const UString &archiveName, 

+    CArchiveLink &archiveLink,

+    IArchiveOpenCallback *openCallback)

+{

+  return OpenArchive(archiveName, 

+    #ifndef EXCLUDE_COM

+    &archiveLink.Library0, &archiveLink.Library1,

+    #endif

+    &archiveLink.Archive0, &archiveLink.Archive1, 

+    archiveLink.ArchiverInfo0, archiveLink.ArchiverInfo1, 

+    archiveLink.DefaultItemName0, archiveLink.DefaultItemName1, 

+    openCallback);

+}

+

+HRESULT MyOpenArchive(const UString &archiveName, 

+    CArchiveLink &archiveLink,

+    IOpenCallbackUI *openCallbackUI)

+{

+  return MyOpenArchive(archiveName, 

+    #ifndef EXCLUDE_COM

+    &archiveLink.Library0, &archiveLink.Library1,

+    #endif

+    &archiveLink.Archive0, &archiveLink.Archive1, 

+    archiveLink.DefaultItemName0, archiveLink.DefaultItemName1, 

+    archiveLink.VolumePaths,

+    openCallbackUI);

+}

+

+HRESULT ReOpenArchive(CArchiveLink &archiveLink, 

+    const UString &fileName)

+{

+  if (archiveLink.GetNumLevels() > 1)

+    return E_NOTIMPL;

+  if (archiveLink.GetNumLevels() == 0)

+    return MyOpenArchive(fileName, archiveLink, 0);

+  return ReOpenArchive(archiveLink.GetArchive(), fileName);

+}

diff --git a/other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.h b/other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.h
new file mode 100644
index 000000000..be6d757d7
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/UI/Common/OpenArchive.h
@@ -0,0 +1,134 @@
+// OpenArchive.h

+

+#ifndef __OPENARCHIVE_H

+#define __OPENARCHIVE_H

+

+#include "Common/String.h"

+#include "Windows/FileFind.h"

+

+#include "../../Archive/IArchive.h"

+#include "ArchiverInfo.h"

+#include "ArchiveOpenCallback.h"

+

+#ifndef EXCLUDE_COM

+#include "Windows/DLL.h"

+#endif

+

+HRESULT GetArchiveItemPath(IInArchive *archive, UInt32 index, UString &result);

+HRESULT GetArchiveItemPath(IInArchive *archive, UInt32 index, const UString &defaultName, UString &result);

+HRESULT GetArchiveItemFileTime(IInArchive *archive, UInt32 index, 

+    const FILETIME &defaultFileTime, FILETIME &fileTime);

+HRESULT IsArchiveItemFolder(IInArchive *archive, UInt32 index, bool &result);

+HRESULT IsArchiveItemAnti(IInArchive *archive, UInt32 index, bool &result);

+

+struct ISetSubArchiveName

+{

+  virtual void SetSubArchiveName(const wchar_t *name) = 0;

+};

+

+HRESULT OpenArchive(

+    IInStream *inStream,

+    const UString &fileName, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module,

+    #endif

+    IInArchive **archiveResult, 

+    CArchiverInfo &archiverInfoResult,

+    UString &defaultItemName,

+    IArchiveOpenCallback *openArchiveCallback);

+

+HRESULT OpenArchive(const UString &filePath, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module,

+    #endif

+    IInArchive **archive, 

+    CArchiverInfo &archiverInfo,

+    UString &defaultItemName,

+    IArchiveOpenCallback *openArchiveCallback);

+

+HRESULT OpenArchive(const UString &filePath, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module0,

+    HMODULE *module1,

+    #endif

+    IInArchive **archive0, 

+    IInArchive **archive1, 

+    CArchiverInfo &archiverInfo0,

+    CArchiverInfo &archiverInfo1,

+    UString &defaultItemName0,

+    UString &defaultItemName1,

+    IArchiveOpenCallback *openArchiveCallback);

+

+

+HRESULT ReOpenArchive(IInArchive *archive, 

+    const UString &fileName);

+

+HRESULT MyOpenArchive(const UString &archiveName, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module,

+    #endif

+    IInArchive **archive,

+    UString &defaultItemName,

+    IOpenCallbackUI *openCallbackUI);

+

+HRESULT MyOpenArchive(const UString &archiveName, 

+    #ifndef EXCLUDE_COM

+    HMODULE *module0,

+    HMODULE *module1,

+    #endif

+    IInArchive **archive0,

+    IInArchive **archive1,

+    UString &defaultItemName0,

+    UString &defaultItemName1,

+    UStringVector &volumePaths,

+    IOpenCallbackUI *openCallbackUI);

+

+struct CArchiveLink

+{

+  #ifndef EXCLUDE_COM

+  NWindows::NDLL::CLibrary Library0;

+  NWindows::NDLL::CLibrary Library1;

+  #endif

+  CMyComPtr<IInArchive> Archive0;

+  CMyComPtr<IInArchive> Archive1;

+  UString DefaultItemName0;

+  UString DefaultItemName1;

+

+  CArchiverInfo ArchiverInfo0;

+  CArchiverInfo ArchiverInfo1;

+  

+  UStringVector VolumePaths;

+

+  int GetNumLevels() const

+  { 

+    int result = 0;

+    if (Archive0)

+    {

+      result++;

+      if (Archive1)

+        result++;

+    }

+    return result;

+  }

+

+

+  IInArchive *GetArchive() { return Archive1 != 0 ? Archive1: Archive0; }

+  UString GetDefaultItemName()  { return Archive1 != 0 ? DefaultItemName1: DefaultItemName0; }

+  const CArchiverInfo &GetArchiverInfo() { return Archive1 != 0 ? ArchiverInfo1: ArchiverInfo0; }

+  HRESULT Close();

+  void Release();

+};

+

+HRESULT OpenArchive(const UString &archiveName, 

+    CArchiveLink &archiveLink,

+    IArchiveOpenCallback *openCallback);

+

+HRESULT MyOpenArchive(const UString &archiveName, 

+    CArchiveLink &archiveLink,

+    IOpenCallbackUI *openCallbackUI);

+

+HRESULT ReOpenArchive(CArchiveLink &archiveLink, 

+    const UString &fileName);

+

+#endif

+