Merge branch 'develop'

Author: saturneric

.github/workflows/testing-nightly.yml

@@ -276,7 +276,7 @@ jobs:
       - name: Build GpgFrontend (Linux)
         # Build your GpgFrontend with the given configuration
         run: |
-          cmake -B ${{github.workspace}}/build -G Ninja -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DDGPGFRONTEND_BUILD_TYPE_ONLY_APPLICATION=ON
+          cmake -B ${{github.workspace}}/build -G Ninja -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DGPGFRONTEND_BUILD_TYPE_ONLY_APPLICATION=ON
           cmake --build ${{github.workspace}}/build --config {{$env.BUILD_TYPE}} -- -v
         if: runner.os == 'Linux'
 

resource/lfs/locale/ts/GpgFrontend.de_DE.ts

@@ -225,17 +225,17 @@ auto InitGpgME() -> bool {
       "core", "gpgme.ctx.gnupg_version", QString{});
 
   if (!has_gpgconf) {
-    FLOG_E() << "cannot get gpgconf backend engine, abort...";
+    LOG_E() << "cannot get gpgconf backend engine, abort...";
     return false;
   }
 
   if (!has_openpgp) {
-    FLOG_E() << "cannot get openpgp backend engine, abort...";
+    LOG_E() << "cannot get openpgp backend engine, abort...";
     return false;
   }
 
   if (!has_cms) {
-    FLOG_E() << "cannot get cms backend engine, abort...";
+    LOG_E() << "cannot get cms backend engine, abort...";
     return false;
   }
 
@@ -387,6 +387,56 @@ auto DecideGnuPGPath(const QString& default_gnupg_path) -> QString {
   return default_gnupg_path;
 }
 
+void EnsureGpgAgentConfHasPinentry(GpgContext& ctx) {
+  auto pinentry_path = DecidePinentry();
+  if (pinentry_path.isEmpty()) {
+    LOG_W() << "no suitable pinentry found.";
+    return;
+  }
+
+  QDir gnupg_dir(ctx.HomeDirectory());
+  if (!gnupg_dir.exists()) {
+    gnupg_dir.mkpath(".");
+  }
+
+  QString config_path = gnupg_dir.filePath("gpg-agent.conf");
+  QFile config_file(config_path);
+  QStringList lines;
+
+  LOG_D() << "checking pinentry config at:" << gnupg_dir;
+
+  bool has_pinentry_line = false;
+  if (config_file.exists()) {
+    if (config_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+      QTextStream in(&config_file);
+      while (!in.atEnd()) {
+        QString line = in.readLine();
+        if (line.trimmed().startsWith("pinentry-program")) {
+          has_pinentry_line = true;
+        }
+        lines.append(line);
+      }
+      config_file.close();
+    }
+  }
+
+  if (!has_pinentry_line) {
+    lines.append(QString("pinentry-program %1").arg(pinentry_path));
+    if (config_file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+      QTextStream out(&config_file);
+      for (const QString& line : lines) {
+        out << line << '\n';
+      }
+      config_file.close();
+      LOG_D() << "updated gpg-agent.conf with pinentry:" << pinentry_path;
+    } else {
+      LOG_W() << "failed to write to gpg-agent.conf";
+    }
+  } else {
+    LOG_D() << "gpg-agent.conf already contains pinentry-program";
+  }
+}
+
 auto InitBasicPath() -> bool {
   auto default_gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
       "core", "gpgme.ctx.gpgconf_path", QString{});
@@ -520,8 +570,8 @@ auto InitGpgFrontendCore(CoreInitArgs args) -> int {
   assert(!key_dbs.isEmpty());
 
   if (key_dbs.isEmpty()) {
-    FLOG_E() << "Cannot find any valid key database!"
-             << "GpgFrontend cannot start under this situation!";
+    LOG_E() << "Cannot find any valid key database!"
+            << "GpgFrontend cannot start under this situation!";
     Module::UpsertRTValue("core", "env.state.ctx", -1);
     CoreSignalStation::GetInstance()->SignalBadGnupgEnv(
         QCoreApplication::tr("No valid Key Database"));
@@ -548,20 +598,26 @@ auto InitGpgFrontendCore(CoreInitArgs args) -> int {
         return ConvertToChannelObjectPtr<>(SecureCreateUniqueObject<GpgContext>(
             args, kGpgFrontendDefaultChannel));
       });
+
   if (!default_ctx.Good()) {
-    FLOG_E() << "Init GpgME Default Context failed!"
-             << "GpgFrontend cannot start under this situation!";
+    LOG_E() << "Init GpgME Default Context failed!"
+            << "GpgFrontend cannot start under this situation!";
     Module::UpsertRTValue("core", "env.state.ctx", -1);
     CoreSignalStation::GetInstance()->SignalBadGnupgEnv(
         QCoreApplication::tr("GpgME Default Context Initiation Failed"));
     return -1;
   }
 
+#if !(defined(_WIN32) || defined(WIN32))
+  // auto config pinentry-program
+  EnsureGpgAgentConfHasPinentry(default_ctx);
+#endif
+
   Module::UpsertRTValue("core", "env.state.ctx", 1);
 
   if (!GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).FlushKeyCache()) {
-    FLOG_E() << "Init GpgME Default Key Database failed!"
-             << "GpgFrontend cannot start under this situation!";
+    LOG_E() << "Init GpgME Default Key Database failed!"
+            << "GpgFrontend cannot start under this situation!";
     Module::UpsertRTValue("core", "env.state.ctx", -1);
     CoreSignalStation::GetInstance()->SignalBadGnupgEnv(
         QCoreApplication::tr("Gpg Default Key Database Initiation Failed"));
@@ -602,13 +658,21 @@ auto InitGpgFrontendCore(CoreInitArgs args) -> int {
               });
 
           if (!ctx.Good()) {
-            FLOG_E() << "gpgme context init failed, index:" << channel_index;
+            LOG_E() << "gpgme context init failed, index:" << channel_index;
             continue;
           }
 
+#if defined(__linux__)
+          EnsureGpgAgentConfHasPinentry(ctx);
+#endif
+
+#if defined(__APPLE__) && defined(__MACH__)
+          EnsureGpgAgentConfHasPinentry(ctx);
+#endif
+
           if (!GpgKeyGetter::GetInstance(ctx.GetChannel()).FlushKeyCache()) {
-            FLOG_E() << "gpgme context init key cache failed, index:"
-                     << channel_index;
+            LOG_E() << "gpgme context init key cache failed, index:"
+                    << channel_index;
             continue;
           }
 
@@ -631,9 +695,16 @@ auto InitGpgFrontendCore(CoreInitArgs args) -> int {
       .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
       ->PostTask(task);
 
-  if (!args.unit_test_mode && restart_all_gnupg_components_on_start) {
-    GpgAdvancedOperator::RestartGpgComponents(nullptr);
+  const auto size = GpgContext::GetAllChannelId().size();
+  for (auto i = 0; i < size; i++) {
+    if (!args.unit_test_mode && restart_all_gnupg_components_on_start) {
+      assert(GpgAdvancedOperator::GetInstance().RestartGpgComponents());
+    } else {
+      // ensure gpg-agent is running
+      assert(GpgAdvancedOperator::GetInstance().LaunchAllGpgComponents());
+    }
   }
+
   return 0;
 }
 

resource/lfs/locale/ts/GpgFrontend.en_US.ts

@@ -33,91 +33,38 @@
 #include "GpgAdvancedOperator.h"
 
 #include "core/function/gpg/GpgCommandExecutor.h"
-#include "core/module/ModuleManager.h"
-#include "core/utils/GpgUtils.h"
-
 namespace GpgFrontend {
 
-void ExecuteGpgCommand(const QString &operation, const QStringList &extra_args,
-                       OperationCallback cb) {
-  const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
-      "core", "gpgme.ctx.gpgconf_path", QString{});
-
-  if (gpgconf_path.isEmpty()) {
-    FLOG_W("cannot get valid gpgconf path from rt, abort.");
-    if (cb) cb(-1, TransferParams());
-    return;
-  }
-
-  auto key_dbs = GetGpgKeyDatabaseInfos();
-  auto total_tasks = static_cast<int>(key_dbs.size());
-  std::atomic<int> completed_tasks{0};
-  std::vector<int> results(total_tasks, 0);
-
-  // kill default gpg-agent
-  key_dbs.push_back({});
-
-  int task_index = 0;
-  for (const auto &key_db : key_dbs) {
-    const int current_index = task_index++;
-    const auto target_home_dir =
-        QDir::toNativeSeparators(QFileInfo(key_db.path).canonicalFilePath());
-
-    QStringList arguments = !target_home_dir.isEmpty()
-                                ? QStringList{"--homedir", target_home_dir}
-                                : QStringList{};
-    arguments.append(extra_args);
-
-    GpgCommandExecutor::ExecuteSync(
-        {gpgconf_path, arguments,
-         [=, &completed_tasks, &results](int exit_code, const QString &,
-                                         const QString &) {
-           FLOG_D("%s exit code: %d", qPrintable(operation), exit_code);
-
-           results[current_index] = exit_code;
-
-           if (++completed_tasks == total_tasks && cb) {
-             int final_result =
-                 std::all_of(results.begin(), results.end(),
-                             [](int result) { return result >= 0; })
-                     ? 0
-                     : -1;
-             cb(final_result, TransferParams());
-           }
-         }});
-  }
-}
-
-void GpgAdvancedOperator::ClearGpgPasswordCache(OperationCallback cb) {
-  ExecuteGpgCommand("Clear GPG Password Cache", {"--reload", "gpg-agent"},
-                    std::move(cb));
+auto GpgAdvancedOperator::ClearGpgPasswordCache() -> bool {
+  auto [ret, out] = exec_.GpgConfExecuteSync({{"--reload", "gpg-agent"}});
+  return ret == 0;
 }
 
-void GpgAdvancedOperator::ReloadGpgComponents(OperationCallback cb) {
-  const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
-      "core", "gpgme.ctx.gpgconf_path", QString{});
-  ExecuteGpgCommand("Reload GPG Components", {"--reload", "all"},
-                    std::move(cb));
+auto GpgAdvancedOperator::ReloadAllGpgComponents() -> bool {
+  auto [ret, out] = exec_.GpgConfExecuteSync({{"--reload", "all"}});
+  return ret == 0;
 }
 
-void GpgAdvancedOperator::KillAllGpgComponents(OperationCallback cb) {
-  ExecuteGpgCommand("Kill All GPG Components", {"--kill", "all"},
-                    std::move(cb));
+auto GpgAdvancedOperator::KillAllGpgComponents() -> bool {
+  auto [ret, out] = exec_.GpgConfExecuteSync({{"--kill", "all"}});
+  return ret == 0;
 }
 
-void GpgAdvancedOperator::ResetConfigures(OperationCallback cb) {
-  ExecuteGpgCommand("Reset Gnupg Configures", {"--apply-defaults"},
-                    std::move(cb));
+auto GpgAdvancedOperator::ResetConfigures() -> bool {
+  auto [ret, out] = exec_.GpgConfExecuteSync({{"--apply-defaults"}});
+  return ret == 0;
 }
 
-void GpgAdvancedOperator::LaunchGpgComponents(OperationCallback cb) {
-  ExecuteGpgCommand("Launch All GPG Components", {"--launch", "all"},
-                    std::move(cb));
+auto GpgAdvancedOperator::LaunchAllGpgComponents() -> bool {
+  auto [ret, out] = exec_.GpgConfExecuteSync({{"--launch", "all"}});
+  return ret == 0;
 }
 
-void GpgAdvancedOperator::RestartGpgComponents(OperationCallback cb) {
-  KillAllGpgComponents(nullptr);
-  LaunchGpgComponents(std::move(cb));
+auto GpgAdvancedOperator::RestartGpgComponents() -> bool {
+  if (!KillAllGpgComponents()) return false;
+  return LaunchAllGpgComponents();
 }
 
+GpgAdvancedOperator::GpgAdvancedOperator(int channel)
+    : SingletonFunctionObject<GpgAdvancedOperator>(channel) {}
 }  // namespace GpgFrontend

resource/lfs/locale/ts/GpgFrontend.fr_FR.ts

@@ -32,57 +32,71 @@
 
 #pragma once
 
+#include "core/function/basic/GpgFunctionObject.h"
+#include "core/function/gpg/GpgCommandExecutor.h"
 #include "core/model/DataObject.h"
 
 namespace GpgFrontend {
 
-class GPGFRONTEND_CORE_EXPORT GpgAdvancedOperator {
+class GPGFRONTEND_CORE_EXPORT GpgAdvancedOperator
+    : public SingletonFunctionObject<GpgAdvancedOperator> {
  public:
+  /**
+   * @brief Construct a new Gpg Advanced Operator object
+   *
+   * @param channel
+   */
+  explicit GpgAdvancedOperator(int channel);
+
   /**
    * @brief
    *
    * @return true
    * @return false
    */
-  static void ClearGpgPasswordCache(OperationCallback);
+  auto ClearGpgPasswordCache() -> bool;
 
   /**
    * @brief
    *
    * @return true
    * @return false
    */
-  static void ReloadGpgComponents(OperationCallback);
+  auto ReloadAllGpgComponents() -> bool;
 
   /**
    * @brief
    *
    * @return true
    * @return false
    */
-  static void RestartGpgComponents(OperationCallback);
+  auto RestartGpgComponents() -> bool;
 
   /**
    * @brief
    *
    * @return true
    * @return false
    */
-  static void ResetConfigures(OperationCallback);
+  auto ResetConfigures() -> bool;
 
   /**
    * @brief
    *
    * @return true
    * @return false
    */
-  static void LaunchGpgComponents(OperationCallback);
+  auto LaunchAllGpgComponents() -> bool;
 
   /**
    * @brief
    *
    */
-  static void KillAllGpgComponents(OperationCallback);
+  auto KillAllGpgComponents() -> bool;
+
+ private:
+  GpgCommandExecutor& exec_ =
+      GpgCommandExecutor::GetInstance(SingletonFunctionObject::GetChannel());
 };
 
 }  // namespace GpgFrontend