chore: initial commit (extracted from Launchers monorepo)

Plugin: ns7zip v2.0.0 Architectures: x86-ansi, x86-unicode, amd64-unicode License: LGPL-2.1-or-later
2026-04-29 14:07:51 +02:00
commit d074cc7c07
3848 changed files with 1076682 additions and 0 deletions
@@ -0,0 +1,394 @@
+// FileFolderPluginOpen.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Thread.h"
+
+#include "../Agent/Agent.h"
+#include "../GUI/ExtractRes.h"
+
+#include "FileFolderPluginOpen.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "OpenCallback.h"
+#include "PluginLoader.h"
+#include "PropertyName.h"
+#include "RegistryPlugins.h"
+
+using namespace NWindows;
+
+struct CThreadArchiveOpen
+{
+  UString Path;
+  UString ArcFormat;
+  CMyComPtr<IInStream> InStream;
+  CMyComPtr<IFolderManager> FolderManager;
+  CMyComPtr<IProgress> OpenCallbackProgress;
+  
+  COpenArchiveCallback *OpenCallbackSpec;
+  /*
+  CMyComPtr<IUnknown>
+  // CMyComPtr<IProgress>
+  // CMyComPtr<IArchiveOpenCallback>
+    OpenCallbackSpec_Ref;
+  */
+
+  CMyComPtr<IFolderFolder> Folder;
+  HRESULT Result;
+
+  void Process()
+  {
+    try
+    {
+      CProgressCloser closer(OpenCallbackSpec->ProgressDialog);
+      Result = FolderManager->OpenFolderFile(InStream, Path, ArcFormat, &Folder, OpenCallbackProgress);
+    }
+    catch(...) { Result = E_FAIL; }
+  }
+  
+  static THREAD_FUNC_DECL MyThreadFunction(void *param)
+  {
+    ((CThreadArchiveOpen *)param)->Process();
+    return 0;
+  }
+};
+
+/*
+static int FindPlugin(const CObjectVector<CPluginInfo> &plugins, const UString &pluginName)
+{
+  for (int i = 0; i < plugins.Size(); i++)
+    if (plugins[i].Name.CompareNoCase(pluginName) == 0)
+      return i;
+  return -1;
+}
+*/
+
+static void SplitNameToPureNameAndExtension(const FString &fullName,
+    FString &pureName, FString &extensionDelimiter, FString &extension)
+{
+  const int index = fullName.ReverseFind_Dot();
+  if (index < 0)
+  {
+    pureName = fullName;
+    extensionDelimiter.Empty();
+    extension.Empty();
+  }
+  else
+  {
+    pureName.SetFrom(fullName, (unsigned)index);
+    extensionDelimiter = '.';
+    extension = fullName.Ptr((unsigned)index + 1);
+  }
+}
+
+
+struct CArcLevelInfo
+{
+  UString Error;
+  UString Path;
+  UString Type;
+  UString ErrorType;
+  UString ErrorFlags;
+};
+
+
+struct CArcLevelsInfo
+{
+  CObjectVector<CArcLevelInfo> Levels; // LastLevel Is NON-OPEN
+};
+
+
+UString GetOpenArcErrorMessage(UInt32 errorFlags);
+
+
+static void GetFolderLevels(CMyComPtr<IFolderFolder> &folder, CArcLevelsInfo &levels)
+{
+  levels.Levels.Clear();
+
+  CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+  folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+  
+  if (!getFolderArcProps)
+    return;
+  CMyComPtr<IFolderArcProps> arcProps;
+  getFolderArcProps->GetFolderArcProps(&arcProps);
+  if (!arcProps)
+    return;
+
+  UInt32 numLevels;
+  if (arcProps->GetArcNumLevels(&numLevels) != S_OK)
+    numLevels = 0;
+  
+  for (UInt32 level = 0; level <= numLevels; level++)
+  {
+    const PROPID propIDs[] = { kpidError, kpidPath, kpidType, kpidErrorType };
+
+    CArcLevelInfo lev;
+    
+    for (Int32 i = 0; i < 4; i++)
+    {
+      CMyComBSTR name;
+      NCOM::CPropVariant prop;
+      if (arcProps->GetArcProp(level, propIDs[i], &prop) != S_OK)
+        continue;
+      if (prop.vt != VT_EMPTY)
+      {
+        UString *s = NULL;
+        switch (propIDs[i])
+        {
+          case kpidError: s = &lev.Error; break;
+          case kpidPath: s = &lev.Path; break;
+          case kpidType: s = &lev.Type; break;
+          case kpidErrorType: s = &lev.ErrorType; break;
+        }
+        *s = (prop.vt == VT_BSTR) ? prop.bstrVal : L"?";
+      }
+    }
+
+    {
+      NCOM::CPropVariant prop;
+      if (arcProps->GetArcProp(level, kpidErrorFlags, &prop) == S_OK)
+      {
+        UInt32 flags = GetOpenArcErrorFlags(prop);
+        if (flags != 0)
+          lev.ErrorFlags = GetOpenArcErrorMessage(flags);
+      }
+    }
+
+    levels.Levels.Add(lev);
+  }
+}
+    
+static UString GetBracedType(const wchar_t *type)
+{
+  UString s ('[');
+  s += type;
+  s.Add_Char(']');
+  return s;
+}
+
+static void GetFolderError(CMyComPtr<IFolderFolder> &folder, UString &open_Errors, UString &nonOpen_Errors)
+{
+  CArcLevelsInfo levs;
+  GetFolderLevels(folder, levs);
+  open_Errors.Empty();
+  nonOpen_Errors.Empty();
+
+  FOR_VECTOR (i, levs.Levels)
+  {
+    bool isNonOpenLevel = (i == 0);
+    const CArcLevelInfo &lev = levs.Levels[levs.Levels.Size() - 1 - i];
+
+    UString m;
+    
+    if (!lev.ErrorType.IsEmpty())
+    {
+      m = MyFormatNew(IDS_CANT_OPEN_AS_TYPE, GetBracedType(lev.ErrorType));
+      if (!isNonOpenLevel)
+      {
+        m.Add_LF();
+        m += MyFormatNew(IDS_IS_OPEN_AS_TYPE, GetBracedType(lev.Type));
+      }
+    }
+
+    if (!lev.Error.IsEmpty())
+    {
+      if (!m.IsEmpty())
+        m.Add_LF();
+      m += GetBracedType(lev.Type);
+      m += " : ";
+      m += GetNameOfProperty(kpidError, L"Error");
+      m += " : ";
+      m += lev.Error;
+    }
+
+    if (!lev.ErrorFlags.IsEmpty())
+    {
+      if (!m.IsEmpty())
+        m.Add_LF();
+      m += GetNameOfProperty(kpidErrorFlags, L"Errors");
+      m += ": ";
+      m += lev.ErrorFlags;
+    }
+    
+    if (!m.IsEmpty())
+    {
+      if (isNonOpenLevel)
+      {
+        UString &s = nonOpen_Errors;
+        s += lev.Path;
+        s.Add_LF();
+        s += m;
+      }
+      else
+      {
+        UString &s = open_Errors;
+        if (!s.IsEmpty())
+          s += "--------------------\n";
+        s += lev.Path;
+        s.Add_LF();
+        s += m;
+      }
+    }
+  }
+}
+
+#ifdef _MSC_VER
+#pragma warning(error : 4702) // unreachable code
+#endif
+
+HRESULT CFfpOpen::OpenFileFolderPlugin(IInStream *inStream,
+    const FString &path, const UString &arcFormat, HWND parentWindow)
+{
+  /*
+  CObjectVector<CPluginInfo> plugins;
+  ReadFileFolderPluginInfoList(plugins);
+  */
+
+  FString extension, name, pureName, dot;
+
+  const int slashPos = path.ReverseFind_PathSepar();
+  FString dirPrefix;
+  FString fileName;
+  if (slashPos >= 0)
+  {
+    dirPrefix.SetFrom(path, (unsigned)(slashPos + 1));
+    fileName = path.Ptr((unsigned)(slashPos + 1));
+  }
+  else
+    fileName = path;
+
+  SplitNameToPureNameAndExtension(fileName, pureName, dot, extension);
+
+  /*
+  if (!extension.IsEmpty())
+  {
+    CExtInfo extInfo;
+    if (ReadInternalAssociation(extension, extInfo))
+    {
+      for (int i = extInfo.Plugins.Size() - 1; i >= 0; i--)
+      {
+        int pluginIndex = FindPlugin(plugins, extInfo.Plugins[i]);
+        if (pluginIndex >= 0)
+        {
+          const CPluginInfo plugin = plugins[pluginIndex];
+          plugins.Delete(pluginIndex);
+          plugins.Insert(0, plugin);
+        }
+      }
+    }
+  }
+  */
+
+  ErrorMessage.Empty();
+
+  // FOR_VECTOR (i, plugins)
+  // {
+    /*
+    const CPluginInfo &plugin = plugins[i];
+    if (!plugin.ClassID_Defined && !plugin.FilePath.IsEmpty())
+      continue;
+    */
+    CPluginLibrary library;
+
+    CThreadArchiveOpen t;
+
+    // if (plugin.FilePath.IsEmpty())
+      t.FolderManager = new CArchiveFolderManager;
+    /*
+    else if (library.LoadAndCreateManager(plugin.FilePath, plugin.ClassID, &t.FolderManager) != S_OK)
+      continue;
+    */
+
+    COpenArchiveCallback OpenCallbackSpec_loc;
+    t.OpenCallbackSpec = &OpenCallbackSpec_loc;
+    /*
+    t.OpenCallbackSpec = new COpenArchiveCallback;
+    t.OpenCallbackSpec_Ref = t.OpenCallbackSpec;
+    */
+    t.OpenCallbackSpec->PasswordIsDefined = Encrypted;
+    t.OpenCallbackSpec->Password = Password;
+    t.OpenCallbackSpec->ParentWindow = parentWindow;
+
+    /* COpenCallbackImp object will exist after Open stage for multivolume archives */
+    COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
+    t.OpenCallbackProgress = openCallbackSpec;
+    // openCallbackSpec->Callback_Ref = t.OpenCallbackSpec;
+    // we set pointer without reference counter:
+    openCallbackSpec->Callback =
+    // openCallbackSpec->ReOpenCallback =
+      t.OpenCallbackSpec;
+
+    if (inStream)
+      openCallbackSpec->SetSubArchiveName(fs2us(fileName));
+    else
+    {
+      RINOK(openCallbackSpec->Init2(dirPrefix, fileName))
+    }
+
+    t.InStream = inStream;
+    t.Path = fs2us(path);
+    t.ArcFormat = arcFormat;
+
+    const UString progressTitle = LangString(IDS_OPENNING);
+    {
+      CProgressDialog &pd = t.OpenCallbackSpec->ProgressDialog;
+      pd.MainWindow = parentWindow;
+      pd.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+      pd.MainAddTitle = progressTitle + L' ';
+      pd.WaitMode = true;
+    }
+
+    {
+      NWindows::CThread thread;
+      const WRes wres = thread.Create(CThreadArchiveOpen::MyThreadFunction, &t);
+      if (wres != 0)
+        return HRESULT_FROM_WIN32(wres);
+      t.OpenCallbackSpec->StartProgressDialog(progressTitle, thread);
+    }
+
+    /*
+      if archive is multivolume:
+      COpenCallbackImp object will exist after Open stage.
+      COpenCallbackImp object will be deleted when last reference
+      from each volume object (CInFileStreamVol) will be closed (when archive will be closed).
+    */
+    t.OpenCallbackProgress.Release();
+
+    if (t.Result != S_FALSE && t.Result != S_OK)
+      return t.Result;
+
+    if (t.Folder)
+    {
+      UString open_Errors, nonOpen_Errors;
+      GetFolderError(t.Folder, open_Errors, nonOpen_Errors);
+      if (!nonOpen_Errors.IsEmpty())
+      {
+        ErrorMessage = nonOpen_Errors;
+        // if (t.Result != S_OK) return t.Result;
+        /* if there are good open leves, and non0open level,
+           we could force error as critical error and return error here
+           but it's better to allow to open such rachives */
+        // return S_FALSE;
+      }
+    }
+
+    // if (openCallbackSpec->PasswordWasAsked)
+    {
+      Encrypted = t.OpenCallbackSpec->PasswordIsDefined;
+      Password = t.OpenCallbackSpec->Password;
+    }
+
+    if (t.Result == S_OK)
+    {
+      Library.Attach(library.Detach());
+      // Folder.Attach(t.Folder.Detach());
+      Folder = t.Folder;
+    }
+    
+    return t.Result;
+  // }
+}