aboutsummaryrefslogtreecommitdiffstats
path: root/src/core/function/gpg
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/function/gpg')
-rw-r--r--src/core/function/gpg/GpgAdvancedOperator.cpp62
-rw-r--r--src/core/function/gpg/GpgBasicOperator.cpp12
-rw-r--r--src/core/function/gpg/GpgCommandExecutor.cpp88
-rw-r--r--src/core/function/gpg/GpgContext.cpp152
-rw-r--r--src/core/function/gpg/GpgContext.h4
-rw-r--r--src/core/function/gpg/GpgFileOpera.cpp42
-rw-r--r--src/core/function/gpg/GpgKeyGetter.cpp45
-rw-r--r--src/core/function/gpg/GpgKeyGetter.h8
-rw-r--r--src/core/function/gpg/GpgKeyImportExporter.cpp26
-rw-r--r--src/core/function/gpg/GpgKeyManager.cpp152
-rw-r--r--src/core/function/gpg/GpgKeyManager.h2
-rw-r--r--src/core/function/gpg/GpgKeyOpera.cpp96
-rw-r--r--src/core/function/gpg/GpgUIDOperator.cpp10
13 files changed, 333 insertions, 366 deletions
diff --git a/src/core/function/gpg/GpgAdvancedOperator.cpp b/src/core/function/gpg/GpgAdvancedOperator.cpp
index cb8fec00..18b38460 100644
--- a/src/core/function/gpg/GpgAdvancedOperator.cpp
+++ b/src/core/function/gpg/GpgAdvancedOperator.cpp
@@ -39,10 +39,9 @@ void GpgFrontend::GpgAdvancedOperator::ClearGpgPasswordCache(
OperationCallback cb) {
const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.ctx.gpgconf_path", QString{});
- GF_CORE_LOG_DEBUG("got gpgconf path from rt: {}", gpgconf_path);
if (gpgconf_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid gpgconf path from rt, abort.");
+ qCWarning(core, "cannot get valid gpgconf path from rt, abort.");
cb(-1, TransferParams());
return;
}
@@ -51,7 +50,6 @@ void GpgFrontend::GpgAdvancedOperator::ClearGpgPasswordCache(
{gpgconf_path, QStringList{"--reload", "gpg-agent"},
[=](int exit_code, const QString & /*p_out*/,
const QString & /*p_err*/) {
- GF_CORE_LOG_DEBUG("gpgconf reload exit code: {}", exit_code);
cb(exit_code == 0 ? 0 : -1, TransferParams());
}});
}
@@ -60,10 +58,9 @@ void GpgFrontend::GpgAdvancedOperator::ReloadGpgComponents(
OperationCallback cb) {
const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.ctx.gpgconf_path", QString{});
- GF_CORE_LOG_DEBUG("got gpgconf path from rt: {}", gpgconf_path);
if (gpgconf_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid gpgconf path from rt, abort.");
+ qCWarning(core, "cannot get valid gpgconf path from rt, abort.");
cb(-1, TransferParams());
return;
}
@@ -71,7 +68,7 @@ void GpgFrontend::GpgAdvancedOperator::ReloadGpgComponents(
GpgFrontend::GpgCommandExecutor::ExecuteSync(
{gpgconf_path, QStringList{"--reload"},
[=](int exit_code, const QString &, const QString &) {
- GF_CORE_LOG_DEBUG("gpgconf reload exit code: {}", exit_code);
+ qCDebug(core, "gpgconf reload exit code: %d", exit_code);
cb(exit_code == 0 ? 0 : -1, TransferParams());
}});
}
@@ -79,59 +76,53 @@ void GpgFrontend::GpgAdvancedOperator::ReloadGpgComponents(
void GpgFrontend::GpgAdvancedOperator::KillAllGpgComponents() {
const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.ctx.gpgconf_path", QString{});
- GF_CORE_LOG_DEBUG("got gpgconf path from rt: {}", gpgconf_path);
if (gpgconf_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid gpgconf path from rt, abort.");
+ qCWarning(core, "cannot get valid gpgconf path from rt, abort.");
return;
}
GpgFrontend::GpgCommandExecutor::ExecuteSync(
{gpgconf_path, QStringList{"--verbose", "--kill", "all"},
[=](int exit_code, const QString &p_out, const QString &p_err) {
- GF_CORE_LOG_DEBUG("gpgconf --kill all command got exit code: {}",
- exit_code);
bool success = true;
if (exit_code != 0) {
success = false;
- GF_CORE_LOG_ERROR(
- "gpgconf execute error, process stderr: {}, process stdout: {}",
- p_err, p_out);
+ qCWarning(core) << "gpgconf execute error, process stderr: " << p_err
+ << ", process stdout: " << p_out;
return;
}
- GF_CORE_LOG_DEBUG("gpgconf --kill --all execute result: {}", success);
+ qCDebug(core, "gpgconf --kill --all execute result: %d", success);
}});
}
void GpgFrontend::GpgAdvancedOperator::RestartGpgComponents() {
const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.ctx.gpgconf_path", QString{});
- GF_CORE_LOG_DEBUG("got gpgconf path from rt: {}", gpgconf_path);
if (gpgconf_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid gpgconf path from rt, abort.");
+ qCWarning(core, "cannot get valid gpgconf path from rt, abort.");
return;
}
GpgFrontend::GpgCommandExecutor::ExecuteSync(
{gpgconf_path, QStringList{"--verbose", "--kill", "all"},
[=](int exit_code, const QString &p_out, const QString &p_err) {
- GF_CORE_LOG_DEBUG("gpgconf --kill all command got exit code: {}",
- exit_code);
+ qCDebug(core, "gpgconf --kill all command got exit code: %d",
+ exit_code);
bool success = true;
if (exit_code != 0) {
success = false;
- GF_CORE_LOG_ERROR(
- "gpgconf execute error, process stderr: {}, process stdout: {}",
- p_err, p_out);
+ qCWarning(core) << "gpgconf execute error, process stderr: " << p_err
+ << ", process stdout: " << p_out;
return;
}
- GF_CORE_LOG_DEBUG("gpgconf --kill --all execute result: {}", success);
+ qCDebug(core, "gpgconf --kill --all execute result: %d", success);
if (!success) {
- GF_CORE_LOG_ERROR(
- "restart all component after core initilized failed");
+ qCWarning(core,
+ "restart all component after core initilized failed");
Module::UpsertRTValue(
"core", "gpg_advanced_operator.restart_gpg_components", false);
return;
@@ -150,10 +141,9 @@ void GpgFrontend::GpgAdvancedOperator::RestartGpgComponents() {
void GpgFrontend::GpgAdvancedOperator::ResetConfigures(OperationCallback cb) {
const auto gpgconf_path = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.ctx.gpgconf_path", QString{});
- GF_CORE_LOG_DEBUG("got gpgconf path from rt: {}", gpgconf_path);
if (gpgconf_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid gpgconf path from rt, abort.");
+ qCWarning(core, "cannot get valid gpgconf path from rt, abort.");
cb(-1, TransferParams());
return;
}
@@ -161,7 +151,7 @@ void GpgFrontend::GpgAdvancedOperator::ResetConfigures(OperationCallback cb) {
GpgFrontend::GpgCommandExecutor::ExecuteSync(
{gpgconf_path, QStringList{"--apply-defaults"},
[=](int exit_code, const QString &, const QString &) {
- GF_CORE_LOG_DEBUG("gpgconf apply-defaults exit code: {}", exit_code);
+ qCDebug(core, "gpgconf apply-defaults exit code: %d", exit_code);
cb(exit_code == 0 ? 0 : -1, TransferParams());
}});
}
@@ -174,14 +164,12 @@ void GpgFrontend::GpgAdvancedOperator::StartGpgAgent(OperationCallback cb) {
const auto gpg_agent_path = Module::RetrieveRTValueTypedOrDefault<>(
kGnuPGInfoGatheringModuleID, "gnupg.gpg_agent_path", QString{});
- GF_CORE_LOG_DEBUG("got gnupg agent path from rt: {}", gpg_agent_path);
const auto home_path = Module::RetrieveRTValueTypedOrDefault<>(
kGnuPGInfoGatheringModuleID, "gnupg.home_path", QString{});
- GF_CORE_LOG_DEBUG("got gnupg home path from rt: {}", home_path);
if (gpg_agent_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid gpg agent path from rt, abort.");
+ qCWarning(core, "cannot get valid gpg agent path from rt, abort.");
cb(-1, TransferParams());
return;
}
@@ -189,7 +177,7 @@ void GpgFrontend::GpgAdvancedOperator::StartGpgAgent(OperationCallback cb) {
GpgFrontend::GpgCommandExecutor::ExecuteSync(
{gpg_agent_path, QStringList{"--homedir", home_path, "--daemon"},
[=](int exit_code, const QString &, const QString &) {
- GF_CORE_LOG_DEBUG("gpgconf daemon exit code: {}", exit_code);
+ qCDebug(core, "gpgconf daemon exit code: %d", exit_code);
cb(exit_code >= 0 ? 0 : -1, TransferParams());
}});
}
@@ -202,14 +190,12 @@ void GpgFrontend::GpgAdvancedOperator::StartDirmngr(OperationCallback cb) {
const auto dirmngr_path = Module::RetrieveRTValueTypedOrDefault<>(
kGnuPGInfoGatheringModuleID, "gnupg.dirmngr_path", QString{});
- GF_CORE_LOG_DEBUG("got gnupg dirmngr path from rt: {}", dirmngr_path);
const auto home_path = Module::RetrieveRTValueTypedOrDefault<>(
kGnuPGInfoGatheringModuleID, "gnupg.home_path", QString{});
- GF_CORE_LOG_DEBUG("got gnupg home path from rt: {}", home_path);
if (dirmngr_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid dirmngr path from rt, abort.");
+ qCWarning(core, "cannot get valid dirmngr path from rt, abort.");
cb(-1, TransferParams());
return;
}
@@ -217,7 +203,7 @@ void GpgFrontend::GpgAdvancedOperator::StartDirmngr(OperationCallback cb) {
GpgFrontend::GpgCommandExecutor::ExecuteSync(
{dirmngr_path, QStringList{"--homedir", home_path, "--daemon"},
[=](int exit_code, const QString &, const QString &) {
- GF_CORE_LOG_DEBUG("gpgconf daemon exit code: {}", exit_code);
+ qCDebug(core, "gpgconf daemon exit code: %d", exit_code);
cb(exit_code >= 0 ? 0 : -1, TransferParams());
}});
}
@@ -230,14 +216,12 @@ void GpgFrontend::GpgAdvancedOperator::StartKeyBoxd(OperationCallback cb) {
const auto keyboxd_path = Module::RetrieveRTValueTypedOrDefault<>(
kGnuPGInfoGatheringModuleID, "gnupg.keyboxd_path", QString{});
- GF_CORE_LOG_DEBUG("got gnupg keyboxd path from rt: {}", keyboxd_path);
const auto home_path = Module::RetrieveRTValueTypedOrDefault<>(
kGnuPGInfoGatheringModuleID, "gnupg.home_path", QString{});
- GF_CORE_LOG_DEBUG("got gnupg home path from rt: {}", home_path);
if (keyboxd_path.isEmpty()) {
- GF_CORE_LOG_ERROR("cannot get valid keyboxd path from rt, abort.");
+ qCWarning(core, "cannot get valid keyboxd path from rt, abort.");
cb(-1, TransferParams());
return;
}
@@ -245,7 +229,7 @@ void GpgFrontend::GpgAdvancedOperator::StartKeyBoxd(OperationCallback cb) {
GpgFrontend::GpgCommandExecutor::ExecuteSync(
{keyboxd_path, QStringList{"--homedir", home_path, "--daemon"},
[=](int exit_code, const QString &, const QString &) {
- GF_CORE_LOG_DEBUG("gpgconf daemon exit code: {}", exit_code);
+ qCDebug(core, "gpgconf daemon exit code: %d", exit_code);
cb(exit_code >= 0 ? 0 : -1, TransferParams());
}});
}
diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index 8b62aad0..d7106a33 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -251,10 +251,9 @@ void GpgBasicOperator::Sign(const KeyArgsList& signers,
cb, "gpgme_op_sign", "2.1.0");
}
-auto GpgBasicOperator::SignSync(const KeyArgsList& signers,
- const GFBuffer& in_buffer, GpgSignMode mode,
- bool ascii)
- -> std::tuple<GpgError, DataObjectPtr> {
+auto GpgBasicOperator::SignSync(
+ const KeyArgsList& signers, const GFBuffer& in_buffer, GpgSignMode mode,
+ bool ascii) -> std::tuple<GpgError, DataObjectPtr> {
return RunGpgOperaSync(
[=](const DataObjectPtr& data_object) -> GpgError {
if (signers.empty()) return GPG_ERR_CANCELED;
@@ -391,15 +390,14 @@ void GpgBasicOperator::SetSigners(const KeyArgsList& signers, bool ascii) {
gpgme_signers_clear(ctx);
for (const GpgKey& key : signers) {
- GF_CORE_LOG_DEBUG("key fpr: {}", key.GetFingerprint());
+ qCDebug(core) << "signer's key fpr: " << key.GetFingerprint();
if (key.IsHasActualSigningCapability()) {
- GF_CORE_LOG_DEBUG("signer");
auto error = gpgme_signers_add(ctx, gpgme_key_t(key));
CheckGpgError(error);
}
}
if (signers.size() != gpgme_signers_count(ctx_.DefaultContext()))
- GF_CORE_LOG_DEBUG("not all signers added");
+ qCDebug(core, "not all signers added");
}
auto GpgBasicOperator::GetSigners(bool ascii) -> std::unique_ptr<KeyArgsList> {
diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp
index 66c18ae1..5e0f3826 100644
--- a/src/core/function/gpg/GpgCommandExecutor.cpp
+++ b/src/core/function/gpg/GpgCommandExecutor.cpp
@@ -27,6 +27,8 @@
*/
#include "GpgCommandExecutor.h"
+#include <qglobal.h>
+
#include "core/model/DataObject.h"
#include "core/module/Module.h"
#include "core/thread/Task.h"
@@ -41,18 +43,14 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context)
const auto &interact_function = context.int_func;
const auto &cmd_executor_callback = context.cb_func;
- const QString joined_argument = arguments.join(" ");
-
- GF_CORE_LOG_DEBUG("building task: called cmd {} arguments size: {}", cmd,
- arguments.size());
-
Thread::Task::TaskCallback result_callback =
- [cmd, joined_argument](int /*rtn*/, const DataObjectPtr &data_object) {
- GF_CORE_LOG_DEBUG(
- "data object args count of cmd executor result callback: {}",
- data_object->GetObjectSize());
+ [cmd](int /*rtn*/, const DataObjectPtr &data_object) {
+ qCDebug(core,
+ "data object args count of cmd executor result callback: %ld",
+ data_object->GetObjectSize());
+
if (!data_object->Check<int, QString, GpgCommandExecutorCallback>()) {
- GF_CORE_LOG_ERROR("data object checking failed");
+ qCWarning(core, "data object checking failed");
return;
}
@@ -61,22 +59,17 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context)
auto callback =
ExtractParams<GpgCommandExecutorCallback>(data_object, 2);
- // call callback
- GF_CORE_LOG_DEBUG(
- "calling custom callback from caller of cmd {} {}, "
- "exit_code: {}",
- cmd, joined_argument, exit_code);
callback(exit_code, process_stdout, {});
};
Thread::Task::TaskRunnable runner =
- [joined_argument](const DataObjectPtr &data_object) -> int {
- GF_CORE_LOG_DEBUG("process runner called, data object size: {}",
- data_object->GetObjectSize());
+ [](const DataObjectPtr &data_object) -> int {
+ qCDebug(core, "process runner called, data object size: %lu",
+ data_object->GetObjectSize());
if (!data_object->Check<QString, QStringList, GpgCommandExecutorInteractor,
GpgCommandExecutorCallback>()) {
- GF_CORE_LOG_ERROR("data object checking failed");
+ qCWarning(core, "data object checking failed");
return -1;
}
@@ -86,6 +79,7 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context)
auto interact_func =
ExtractParams<GpgCommandExecutorInteractor>(data_object, 2);
auto callback = ExtractParams<GpgCommandExecutorCallback>(data_object, 3);
+ const QString joined_argument = arguments.join(" ");
// create process
auto *cmd_process = new QProcess();
@@ -106,26 +100,23 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context)
QObject::connect(
cmd_process, &QProcess::started, [cmd, joined_argument]() -> void {
- GF_CORE_LOG_DEBUG(
- "\n== Process Execute Started ==\nCommand: {}\nArguments: "
- "{}\n========================",
- cmd, joined_argument);
+ qCDebug(core) << "\n== Process Execute Started ==\nCommand: " << cmd
+ << "\nArguments: " << joined_argument
+ << " \n========================";
});
QObject::connect(
cmd_process, &QProcess::readyReadStandardOutput,
[interact_func, cmd_process]() { interact_func(cmd_process); });
- QObject::connect(
- cmd_process, &QProcess::errorOccurred,
- [=](QProcess::ProcessError error) {
- GF_CORE_LOG_ERROR(
- "caught error while executing command: {} {}, error: {}", cmd,
- joined_argument, error);
- });
+ QObject::connect(cmd_process, &QProcess::errorOccurred,
+ [=](QProcess::ProcessError error) {
+ qCWarning(core)
+ << "caught error while executing command: " << cmd
+ << joined_argument << ", error:" << error;
+ });
- GF_CORE_LOG_DEBUG(
- "\n== Process Execute Ready ==\nCommand: {}\nArguments: "
- "{}\n========================",
- cmd, joined_argument);
+ qCDebug(core) << "\n== Process Execute Ready ==\nCommand: " << cmd
+ << "\nArguments: " << joined_argument
+ << "\n========================";
cmd_process->start();
cmd_process->waitForFinished();
@@ -133,15 +124,13 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context)
QString process_stdout = cmd_process->readAllStandardOutput();
int exit_code = cmd_process->exitCode();
- GF_CORE_LOG_DEBUG(
- "\n==== Process Execution Summary ====\n"
- "Command: {}\n"
- "Arguments: {}\n"
- "Exit Code: {}\n"
- "---- Standard Output ----\n"
- "{}\n"
- "===============================",
- cmd, joined_argument, exit_code, process_stdout);
+ qCDebug(core) << "\n==== Process Execution Summary ====\n"
+ << "Command: " << cmd << "\n"
+ << "Arguments: " << joined_argument << "\n"
+ << "Exit Code: " << exit_code << "\n"
+ << "---- Standard Output ----\n"
+ << process_stdout << "\n"
+ << "===============================";
cmd_process->close();
cmd_process->deleteLater();
@@ -177,7 +166,7 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) {
// to arvoid dead lock issue we need to check if current thread is the same as
// target thread. if it is, we can't call exec() because it will block the
// current thread.
- GF_CORE_LOG_TRACE("blocking until gpg command finish...");
+ qCDebug(core, "blocking until gpg command finish...");
// block until task finished
// this is to keep reference vaild until task finished
looper.exec();
@@ -185,9 +174,6 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) {
void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) {
for (auto &context : contexts) {
- const auto &cmd = context.cmd;
- GF_CORE_LOG_INFO("gpg concurrently called cmd {}", cmd);
-
Thread::Task *task = BuildTaskFromExecCtx(context);
if (context.task_runner != nullptr) {
@@ -208,15 +194,15 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) {
for (auto &context : contexts) {
const auto &cmd = context.cmd;
- GF_CORE_LOG_DEBUG("gpg concurrently called cmd: {}", cmd);
+ qCDebug(core) << "gpg concurrently called cmd: " << cmd;
Thread::Task *task = BuildTaskFromExecCtx(context);
QObject::connect(task, &Thread::Task::SignalTaskEnd, [&]() {
--remaining_tasks;
- GF_CORE_LOG_DEBUG("remaining tasks: {}", remaining_tasks);
+ qCDebug(core, "remaining tasks: %lld", remaining_tasks);
if (remaining_tasks <= 0) {
- GF_CORE_LOG_DEBUG("no remaining task, quit");
+ qCDebug(core, "no remaining task, quit");
looper.quit();
}
});
@@ -232,7 +218,7 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) {
target_task_runner->PostTask(task);
}
- GF_CORE_LOG_TRACE("blocking until concurrent gpg commands finish...");
+ qCDebug(core, "blocking until concurrent gpg commands finish...");
// block until task finished
// this is to keep reference vaild until task finished
looper.exec();
diff --git a/src/core/function/gpg/GpgContext.cpp b/src/core/function/gpg/GpgContext.cpp
index 7dec318e..75e97e0c 100644
--- a/src/core/function/gpg/GpgContext.cpp
+++ b/src/core/function/gpg/GpgContext.cpp
@@ -32,6 +32,7 @@
#include <gpgme.h>
#include <cassert>
+#include <cstddef>
#include <mutex>
#include "core/function/CoreSignalStation.h"
@@ -77,8 +78,8 @@ class GpgContext::Impl {
[[nodiscard]] auto Good() const -> bool { return good_; }
- auto SetPassphraseCb(const gpgme_ctx_t &ctx, gpgme_passphrase_cb_t cb)
- -> bool {
+ auto SetPassphraseCb(const gpgme_ctx_t &ctx,
+ gpgme_passphrase_cb_t cb) -> bool {
if (gpgme_get_pinentry_mode(ctx) != GPGME_PINENTRY_MODE_LOOPBACK) {
if (CheckGpgError(gpgme_set_pinentry_mode(
ctx, GPGME_PINENTRY_MODE_LOOPBACK)) != GPG_ERR_NO_ERROR) {
@@ -92,31 +93,24 @@ class GpgContext::Impl {
static auto TestPassphraseCb(void *opaque, const char *uid_hint,
const char *passphrase_info, int last_was_bad,
int fd) -> gpgme_error_t {
- size_t res;
-#ifdef QT5_BUILD
- QString pass_qstr = "abcdefg\n";
- QByteArray pass = pass_qstr.toUtf8();
-#else
- QString pass = "abcdefg\n";
-#endif
-
- auto passpahrase_size = pass.size();
- size_t off = 0;
-
- do {
-#ifdef QT5_BUILD
- const char *p_pass = pass.data();
- res = gpgme_io_write(fd, &p_pass[off], passpahrase_size - off);
-#else
- res = gpgme_io_write(fd, &pass[off], passpahrase_size - off);
-#endif
- if (res > 0) off += res;
- } while (res > 0 && off != passpahrase_size);
+ QString passphrase = "abcdefg";
+ auto pass_bytes = passphrase.toLatin1();
+ auto pass_size = pass_bytes.size();
+ const auto *p_pass_bytes = pass_bytes.constData();
+
+ ssize_t res = 0;
+ if (pass_size > 0) {
+ ssize_t off = 0;
+ ssize_t ret = 0;
+ do {
+ ret = gpgme_io_write(fd, &p_pass_bytes[off], pass_size - off);
+ if (ret > 0) off += ret;
+ } while (ret > 0 && off != pass_size);
+ res = off;
+ }
res += gpgme_io_write(fd, "\n", 1);
- return res == passpahrase_size + 1
- ? 0
- : gpgme_error_from_errno(GPG_ERR_CANCELED);
+ return res == pass_size + 1 ? 0 : gpgme_error_from_errno(GPG_ERR_CANCELED);
}
static auto CustomPassphraseCb(void *hook, const char *uid_hint,
@@ -130,47 +124,54 @@ class GpgContext::Impl {
passphrase_info != nullptr ? passphrase_info : "",
prev_was_bad != 0, ask_for_new));
- GF_CORE_LOG_DEBUG(
- "custom passphrase cb called, uid: {}, info: {}, last_was_bad: {}",
- uid_hint == nullptr ? "<empty>" : QString{uid_hint},
- passphrase_info == nullptr ? "<empty>" : QString{passphrase_info},
- prev_was_bad);
+ qCDebug(core) << "custom passphrase cb called, uid: "
+ << (uid_hint == nullptr ? "<empty>" : QString{uid_hint})
+ << ", info: "
+ << (passphrase_info == nullptr ? "<empty>"
+ : QString{passphrase_info})
+ << ", last_was_bad: " << prev_was_bad;
QEventLoop looper;
- QObject::connect(CoreSignalStation::GetInstance(),
- &CoreSignalStation::SignalUserInputPassphraseCallback,
- &looper, &QEventLoop::quit);
+ QString passphrase = "";
+
+ Module::TriggerEvent(
+ "REQUEST_PIN_ENTRY",
+ {{"uid_hint", uid_hint != nullptr ? uid_hint : ""},
+ {"passphrase_info", passphrase_info != nullptr ? passphrase_info : ""},
+ {"prev_was_bad", (prev_was_bad != 0) ? "1" : "0"},
+ {"ask_for_new", ask_for_new ? "1" : "0"}},
+ [&passphrase, &looper](Module::EventIdentifier i,
+ Module::Event::ListenerIdentifier ei,
+ Module::Event::Params p) {
+ passphrase = p["passphrase"];
+ looper.quit();
+ });
- emit CoreSignalStation::GetInstance()->SignalNeedUserInputPassphrase(
- context);
looper.exec();
-
ResetCacheValue("PinentryContext");
- auto passphrase = context->GetPassphrase().toStdString();
- auto passpahrase_size = passphrase.size();
- GF_CORE_LOG_DEBUG("get passphrase from pinentry size: {}",
- passpahrase_size);
-
- size_t res = 0;
- if (passpahrase_size > 0) {
- size_t off = 0;
+
+ auto pass_bytes = passphrase.toLatin1();
+ auto pass_size = pass_bytes.size();
+ const auto *p_pass_bytes = pass_bytes.constData();
+
+ ssize_t res = 0;
+ if (pass_size > 0) {
+ ssize_t off = 0;
+ ssize_t ret = 0;
do {
- res = gpgme_io_write(fd, &passphrase[off], passpahrase_size - off);
- if (res > 0) off += res;
- } while (res > 0 && off != passpahrase_size);
+ ret = gpgme_io_write(fd, &p_pass_bytes[off], pass_size - off);
+ if (ret > 0) off += ret;
+ } while (ret > 0 && off != pass_size);
+ res = off;
}
res += gpgme_io_write(fd, "\n", 1);
-
- GF_CORE_LOG_DEBUG("custom passphrase cd is about to return, res: {}", res);
- return res == passpahrase_size + 1
- ? 0
- : gpgme_error_from_errno(GPG_ERR_CANCELED);
+ return res == pass_size + 1 ? 0 : gpgme_error_from_errno(GPG_ERR_CANCELED);
}
- static auto TestStatusCb(void *hook, const char *keyword, const char *args)
- -> gpgme_error_t {
- GF_CORE_LOG_DEBUG("keyword {}", keyword);
+ static auto TestStatusCb(void *hook, const char *keyword,
+ const char *args) -> gpgme_error_t {
+ qCDebug(core, "keyword %s", keyword);
return GPG_ERR_NO_ERROR;
}
@@ -188,10 +189,11 @@ class GpgContext::Impl {
const auto gpgme_version = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.version", QString{"0.0.0"});
- GF_CORE_LOG_DEBUG("got gpgme version version from rt: {}", gpgme_version);
+ qCDebug(core) << "got gpgme version version from rt: " << gpgme_version;
if (gpgme_get_keylist_mode(ctx) == 0) {
- GF_CORE_LOG_ERROR(
+ qCWarning(
+ core,
"ctx is not a valid pointer, reported by gpgme_get_keylist_mode");
return false;
}
@@ -210,8 +212,8 @@ class GpgContext::Impl {
const auto database_path = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.ctx.database_path", QString{});
- GF_CORE_LOG_DEBUG("ctx set engine info, db path: {}, app path: {}",
- database_path, app_path);
+ qCDebug(core) << "ctx set engine info, db path: " << database_path
+ << ", app path: " << app_path;
auto app_path_buffer = app_path.toUtf8();
auto database_path_buffer = database_path.toUtf8();
@@ -232,23 +234,22 @@ class GpgContext::Impl {
assert(ctx != nullptr);
if (args.custom_gpgconf && !args.custom_gpgconf_path.isEmpty()) {
- GF_CORE_LOG_DEBUG("set custom gpgconf path: {}",
- args.custom_gpgconf_path);
+ qCDebug(core) << "set custom gpgconf path: " << args.custom_gpgconf_path;
auto err =
gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_GPGCONF,
args.custom_gpgconf_path.toUtf8(), nullptr);
if (CheckGpgError(err) != GPG_ERR_NO_ERROR) {
- GF_CORE_LOG_ERROR("set gpg context engine info error: {}",
- DescribeGpgErrCode(err).second);
+ qCWarning(core) << "set gpg context engine info error: "
+ << DescribeGpgErrCode(err).second;
return false;
}
}
// set context offline mode
- GF_CORE_LOG_DEBUG("gpg context: offline mode: {}", args_.offline_mode);
- GF_CORE_LOG_DEBUG("gpg context: auto import missing key: {}",
- args_.auto_import_missing_key);
+ qCDebug(core, "gpg context: offline mode: %d", args_.offline_mode);
+ qCDebug(core, "gpg context: auto import missing key: %d",
+ args_.auto_import_missing_key);
gpgme_set_offline(ctx, args_.offline_mode ? 1 : 0);
// set option auto import missing key
@@ -260,19 +261,20 @@ class GpgContext::Impl {
}
if (!set_ctx_key_list_mode(ctx)) {
- GF_CORE_LOG_DEBUG("set ctx key list mode failed");
+ qCDebug(core, "set ctx key list mode failed");
return false;
}
// for unit test
if (args_.test_mode) {
if (!SetPassphraseCb(ctx, TestPassphraseCb)) {
- GF_CORE_LOG_ERROR("set passphrase cb failed, test");
+ qCWarning(core, "set passphrase cb failed, test");
return false;
};
- } else if (!args_.use_pinentry) {
+ } else if (!args_.use_pinentry &&
+ Module::IsModuleActivate(kPinentryModuleID)) {
if (!SetPassphraseCb(ctx, CustomPassphraseCb)) {
- GF_CORE_LOG_DEBUG("set passphrase cb failed, custom");
+ qCDebug(core, "set passphrase cb failed, custom");
return false;
}
}
@@ -283,7 +285,7 @@ class GpgContext::Impl {
}
if (!set_ctx_openpgp_engine_info(ctx)) {
- GF_CORE_LOG_ERROR("set gpgme context openpgp engine info failed");
+ qCWarning(core, "set gpgme context openpgp engine info failed");
return false;
}
@@ -293,15 +295,15 @@ class GpgContext::Impl {
auto binary_ctx_initialize(const GpgContextInitArgs &args) -> bool {
gpgme_ctx_t p_ctx;
if (auto err = CheckGpgError(gpgme_new(&p_ctx)); err != GPG_ERR_NO_ERROR) {
- GF_CORE_LOG_ERROR("get new gpg context error: {}",
- DescribeGpgErrCode(err).second);
+ qCWarning(core) << "get new gpg context error: "
+ << DescribeGpgErrCode(err).second;
return false;
}
assert(p_ctx != nullptr);
binary_ctx_ref_ = p_ctx;
if (!common_ctx_initialize(binary_ctx_ref_, args)) {
- GF_CORE_LOG_ERROR("get new ctx failed, binary");
+ qCWarning(core, "get new ctx failed, binary");
return false;
}
@@ -312,7 +314,7 @@ class GpgContext::Impl {
auto default_ctx_initialize(const GpgContextInitArgs &args) -> bool {
gpgme_ctx_t p_ctx;
if (CheckGpgError(gpgme_new(&p_ctx)) != GPG_ERR_NO_ERROR) {
- GF_CORE_LOG_ERROR("get new ctx failed, default");
+ qCWarning(core, "get new ctx failed, default");
return false;
}
assert(p_ctx != nullptr);
diff --git a/src/core/function/gpg/GpgContext.h b/src/core/function/gpg/GpgContext.h
index 2a8f6fdd..0fcf3e43 100644
--- a/src/core/function/gpg/GpgContext.h
+++ b/src/core/function/gpg/GpgContext.h
@@ -40,7 +40,7 @@ namespace GpgFrontend {
*
*/
struct GpgContextInitArgs {
- QString db_path = {}; ///<
+ QString db_path; ///<
bool test_mode = false; ///<
bool offline_mode = false; ///<
@@ -63,7 +63,7 @@ class GPGFRONTEND_CORE_EXPORT GpgContext
explicit GpgContext(GpgContextInitArgs args, int channel);
- virtual ~GpgContext() override;
+ ~GpgContext();
[[nodiscard]] auto Good() const -> bool;
diff --git a/src/core/function/gpg/GpgFileOpera.cpp b/src/core/function/gpg/GpgFileOpera.cpp
index ad506c4a..9ada4afa 100644
--- a/src/core/function/gpg/GpgFileOpera.cpp
+++ b/src/core/function/gpg/GpgFileOpera.cpp
@@ -69,10 +69,9 @@ void GpgFileOpera::EncryptFile(const KeyArgsList& keys, const QString& in_path,
cb, "gpgme_op_encrypt", "2.1.0");
}
-auto GpgFileOpera::EncryptFileSync(const KeyArgsList& keys,
- const QString& in_path, bool ascii,
- const QString& out_path)
- -> std::tuple<GpgError, DataObjectPtr> {
+auto GpgFileOpera::EncryptFileSync(
+ const KeyArgsList& keys, const QString& in_path, bool ascii,
+ const QString& out_path) -> std::tuple<GpgError, DataObjectPtr> {
return RunGpgOperaSync(
[=](const DataObjectPtr& data_object) -> GpgError {
std::vector<gpgme_key_t> recipients(keys.begin(), keys.end());
@@ -111,7 +110,7 @@ void GpgFileOpera::EncryptDirectory(const KeyArgsList& keys,
GpgData data_in(ex);
GpgData data_out(out_path, false);
- GF_CORE_LOG_DEBUG("encrypt directory start");
+ qCDebug(core, "encrypt directory start");
auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
auto err = CheckGpgError(gpgme_op_encrypt(ctx, recipients.data(),
@@ -119,15 +118,14 @@ void GpgFileOpera::EncryptDirectory(const KeyArgsList& keys,
data_in, data_out));
data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx))});
- GF_CORE_LOG_DEBUG("encrypt directory finished, err: {}", err);
+ qCDebug(core, "encrypt directory finished, err: %d", err);
return err;
},
cb, "gpgme_op_encrypt", "2.1.0");
ArchiveFileOperator::NewArchive2DataExchanger(
in_path, ex, [=](GFError err, const DataObjectPtr&) {
- GF_CORE_LOG_DEBUG("new archive 2 data exchanger operation, err: {}",
- err);
+ qCDebug(core, "new archive 2 data exchanger operation, err: %d", err);
if (decltype(ex) p_ex = w_ex.lock(); err < 0 && p_ex != nullptr) {
ex->CloseWrite();
}
@@ -176,8 +174,8 @@ void GpgFileOpera::DecryptArchive(const QString& in_path,
ArchiveFileOperator::ExtractArchiveFromDataExchanger(
ex, out_path, [](GFError err, const DataObjectPtr&) {
- GF_CORE_LOG_DEBUG(
- "extract archive from data exchanger operation, err: {}", err);
+ qCDebug(core, "extract archive from data exchanger operation, err: %d",
+ err);
});
RunGpgOperaAsync(
@@ -331,11 +329,10 @@ void GpgFileOpera::EncryptSignFile(const KeyArgsList& keys,
cb, "gpgme_op_encrypt_sign", "2.1.0");
}
-auto GpgFileOpera::EncryptSignFileSync(const KeyArgsList& keys,
- const KeyArgsList& signer_keys,
- const QString& in_path, bool ascii,
- const QString& out_path)
- -> std::tuple<GpgError, DataObjectPtr> {
+auto GpgFileOpera::EncryptSignFileSync(
+ const KeyArgsList& keys, const KeyArgsList& signer_keys,
+ const QString& in_path, bool ascii,
+ const QString& out_path) -> std::tuple<GpgError, DataObjectPtr> {
return RunGpgOperaSync(
[=](const DataObjectPtr& data_object) -> GpgError {
GpgError err;
@@ -399,7 +396,7 @@ void GpgFileOpera::EncryptSignDirectory(const KeyArgsList& keys,
ArchiveFileOperator::NewArchive2DataExchanger(
in_path, ex, [=](GFError err, const DataObjectPtr&) {
- GF_CORE_LOG_DEBUG("new archive 2 fd operation, err: {}", err);
+ qCDebug(core, "new archive 2 fd operation, err: %d", err);
if (decltype(ex) p_ex = w_ex.lock(); err < 0 && p_ex != nullptr) {
ex->CloseWrite();
}
@@ -459,7 +456,7 @@ void GpgFileOpera::DecryptVerifyArchive(const QString& in_path,
ArchiveFileOperator::ExtractArchiveFromDataExchanger(
ex, out_path, [](GFError err, const DataObjectPtr&) {
- GF_CORE_LOG_DEBUG("extract archive from ex operation, err: {}", err);
+ qCDebug(core, "extract archive from ex operation, err: %d", err);
});
RunGpgOperaAsync(
@@ -545,19 +542,18 @@ void GpgFileOpera::EncryptDerectorySymmetric(const QString& in_path, bool ascii,
ArchiveFileOperator::NewArchive2DataExchanger(
in_path, ex, [=](GFError err, const DataObjectPtr&) {
- GF_CORE_LOG_DEBUG("new archive 2 fd operation, err: {}", err);
+ qCDebug(core, "new archive 2 fd operation, err: %d", err);
});
}
-auto GpgFileOpera::EncryptDerectorySymmetricSync(const QString& in_path,
- bool ascii,
- const QString& out_path)
- -> std::tuple<GpgError, DataObjectPtr> {
+auto GpgFileOpera::EncryptDerectorySymmetricSync(
+ const QString& in_path, bool ascii,
+ const QString& out_path) -> std::tuple<GpgError, DataObjectPtr> {
auto ex = std::make_shared<GFDataExchanger>(kDataExchangerSize);
ArchiveFileOperator::NewArchive2DataExchanger(
in_path, ex, [=](GFError err, const DataObjectPtr&) {
- GF_CORE_LOG_DEBUG("new archive 2 fd operation, err: {}", err);
+ qCDebug(core, "new archive 2 fd operation, err: %d", err);
});
return RunGpgOperaSync(
diff --git a/src/core/function/gpg/GpgKeyGetter.cpp b/src/core/function/gpg/GpgKeyGetter.cpp
index 4a35d3cd..8b78b754 100644
--- a/src/core/function/gpg/GpgKeyGetter.cpp
+++ b/src/core/function/gpg/GpgKeyGetter.cpp
@@ -42,9 +42,7 @@ namespace GpgFrontend {
class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
public:
explicit Impl(int channel)
- : SingletonFunctionObject<GpgKeyGetter::Impl>(channel) {
- GF_CORE_LOG_DEBUG("called channel: {}", channel);
- }
+ : SingletonFunctionObject<GpgKeyGetter::Impl>(channel) {}
auto GetKey(const QString& fpr, bool use_cache) -> GpgKey {
// find in cache first
@@ -56,7 +54,8 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
gpgme_key_t p_key = nullptr;
gpgme_get_key(ctx_.DefaultContext(), fpr.toUtf8(), &p_key, 1);
if (p_key == nullptr) {
- GF_CORE_LOG_WARN("GpgKeyGetter GetKey Private _p_key Null fpr", fpr);
+ qCWarning(core) << "GpgKeyGetter GetKey Private _p_key Null, fpr: "
+ << fpr;
return GetPubkey(fpr, true);
}
return GpgKey(std::move(p_key));
@@ -72,7 +71,7 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
gpgme_key_t p_key = nullptr;
gpgme_get_key(ctx_.DefaultContext(), fpr.toUtf8(), &p_key, 0);
if (p_key == nullptr)
- GF_CORE_LOG_WARN("GpgKeyGetter GetKey _p_key Null", fpr);
+ qCWarning(core) << "GpgKeyGetter GetKey _p_key Null, fpr: " << fpr;
return GpgKey(std::move(p_key));
}
@@ -92,9 +91,23 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
return keys_list;
}
- auto FlushKeyCache() -> bool {
- GF_CORE_LOG_DEBUG("flush key channel called, channel: {}", GetChannel());
+ auto FetchGpgKeyList() -> GpgKeyList {
+ if (keys_search_cache_.empty()) {
+ FlushKeyCache();
+ }
+ auto keys_list = GpgKeyList{};
+ {
+ // get the lock
+ std::lock_guard<std::mutex> lock(keys_cache_mutex_);
+ for (const auto& key : keys_cache_) {
+ keys_list.push_back(key);
+ }
+ }
+ return keys_list;
+ }
+
+ auto FlushKeyCache() -> bool {
// clear the keys cache
keys_cache_.clear();
keys_search_cache_.clear();
@@ -129,17 +142,12 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
}
}
- GF_CORE_LOG_DEBUG("flush key channel cache address: {} object address: {}",
- static_cast<void*>(&keys_search_cache_),
- static_cast<void*>(this));
-
// for debug
assert(CheckGpgError2ErrCode(err, GPG_ERR_EOF) == GPG_ERR_EOF);
err = gpgme_op_keylist_end(ctx_.DefaultContext());
assert(CheckGpgError2ErrCode(err, GPG_ERR_EOF) == GPG_ERR_NO_ERROR);
- GF_CORE_LOG_DEBUG("flush key channel done, channel: {}", GetChannel());
return true;
}
@@ -165,6 +173,11 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
return keys_copy;
}
+ auto GetGpgKeyTableModel() -> QSharedPointer<GpgKeyTableModel> {
+ return SecureCreateQSharedObject<GpgKeyTableModel>(FetchGpgKeyList(),
+ nullptr);
+ }
+
private:
/**
* @brief Get the gpgme context object
@@ -218,9 +231,7 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
GpgKeyGetter::GpgKeyGetter(int channel)
: SingletonFunctionObject<GpgKeyGetter>(channel),
- p_(SecureCreateUniqueObject<Impl>(channel)) {
- GF_CORE_LOG_DEBUG("called channel: {}", channel);
-}
+ p_(SecureCreateUniqueObject<Impl>(channel)) {}
GpgKeyGetter::~GpgKeyGetter() = default;
@@ -248,4 +259,8 @@ auto GpgKeyGetter::GetKeysCopy(const KeyListPtr& keys) -> KeyListPtr {
auto GpgKeyGetter::FetchKey() -> KeyLinkListPtr { return p_->FetchKey(); }
+auto GpgKeyGetter::GetGpgKeyTableModel() -> QSharedPointer<GpgKeyTableModel> {
+ return p_->GetGpgKeyTableModel();
+}
+
} // namespace GpgFrontend
diff --git a/src/core/function/gpg/GpgKeyGetter.h b/src/core/function/gpg/GpgKeyGetter.h
index 91138623..2c4c0706 100644
--- a/src/core/function/gpg/GpgKeyGetter.h
+++ b/src/core/function/gpg/GpgKeyGetter.h
@@ -29,6 +29,7 @@
#pragma once
#include "core/function/basic/GpgFunctionObject.h"
+#include "core/model/GpgKeyTableModel.h"
#include "core/typedef/GpgTypedef.h"
namespace GpgFrontend {
@@ -106,6 +107,13 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyGetter
*/
auto GetKeysCopy(const KeyLinkListPtr& keys) -> KeyLinkListPtr;
+ /**
+ * @brief
+ *
+ * @return GpgKeyTableModel
+ */
+ auto GetGpgKeyTableModel() -> QSharedPointer<GpgKeyTableModel>;
+
private:
class Impl;
SecureUniquePtr<Impl> p_;
diff --git a/src/core/function/gpg/GpgKeyImportExporter.cpp b/src/core/function/gpg/GpgKeyImportExporter.cpp
index ef8cb112..b9875131 100644
--- a/src/core/function/gpg/GpgKeyImportExporter.cpp
+++ b/src/core/function/gpg/GpgKeyImportExporter.cpp
@@ -49,11 +49,11 @@ auto GpgKeyImportExporter::ImportKey(const GFBuffer& in_buffer)
if (in_buffer.Empty()) return {};
GpgData data_in(in_buffer);
- auto err = CheckGpgError(gpgme_op_import(ctx_.DefaultContext(), data_in));
+ auto err = CheckGpgError(gpgme_op_import(ctx_.BinaryContext(), data_in));
if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return {};
gpgme_import_result_t result;
- result = gpgme_op_import_result(ctx_.DefaultContext());
+ result = gpgme_op_import_result(ctx_.BinaryContext());
gpgme_import_status_t status = result->imports;
auto import_info = SecureCreateSharedObject<GpgImportInformation>(result);
while (status != nullptr) {
@@ -91,11 +91,8 @@ auto GpgKeyImportExporter::ExportKey(const GpgKey& key, bool secret, bool ascii,
GpgData data_out;
auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
auto err = gpgme_op_export_keys(ctx, keys_array.data(), mode, data_out);
- if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return {};
+ if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return {err, {}};
- GF_CORE_LOG_DEBUG(
- "operation of exporting a key finished, ascii: {}, read_bytes: {}", ascii,
- gpgme_data_seek(data_out, 0, SEEK_END));
return {err, data_out.Read2GFBuffer()};
}
@@ -125,11 +122,7 @@ void GpgKeyImportExporter::ExportKeys(const KeyArgsList& keys, bool secret,
GpgData data_out;
auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
auto err = gpgme_op_export_keys(ctx, keys_array.data(), mode, data_out);
- if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return {};
-
- GF_CORE_LOG_DEBUG(
- "operation of exporting keys finished, ascii: {}, read_bytes: {}",
- ascii, gpgme_data_seek(data_out, 0, SEEK_END));
+ if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return err;
data_object->Swap({data_out.Read2GFBuffer()});
return err;
@@ -159,11 +152,8 @@ void GpgKeyImportExporter::ExportAllKeys(const KeyArgsList& keys, bool secret,
GpgData data_out;
auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
auto err = gpgme_op_export_keys(ctx, keys_array.data(), mode, data_out);
- if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return {};
+ if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return err;
- GF_CORE_LOG_DEBUG(
- "operation of exporting keys finished, ascii: {}, read_bytes: {}",
- ascii, gpgme_data_seek(data_out, 0, SEEK_END));
auto buffer = data_out.Read2GFBuffer();
if (secret) {
@@ -173,12 +163,8 @@ void GpgKeyImportExporter::ExportAllKeys(const KeyArgsList& keys, bool secret,
GpgData data_out_secret;
auto err = gpgme_op_export_keys(ctx, keys_array.data(), mode,
data_out_secret);
- if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return {};
+ if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return err;
- GF_CORE_LOG_DEBUG(
- "operation of exporting secret keys finished, "
- "ascii: {}, read_bytes: {}",
- ascii, gpgme_data_seek(data_out_secret, 0, SEEK_END));
buffer.Append(data_out_secret.Read2GFBuffer());
}
diff --git a/src/core/function/gpg/GpgKeyManager.cpp b/src/core/function/gpg/GpgKeyManager.cpp
index b5efe141..93a864ca 100644
--- a/src/core/function/gpg/GpgKeyManager.cpp
+++ b/src/core/function/gpg/GpgKeyManager.cpp
@@ -73,10 +73,9 @@ auto GpgFrontend::GpgKeyManager::RevSign(
return true;
}
-auto GpgFrontend::GpgKeyManager::SetExpire(const GpgFrontend::GpgKey& key,
- std::unique_ptr<GpgSubKey>& subkey,
- std::unique_ptr<QDateTime>& expires)
- -> bool {
+auto GpgFrontend::GpgKeyManager::SetExpire(
+ const GpgFrontend::GpgKey& key, std::unique_ptr<GpgSubKey>& subkey,
+ std::unique_ptr<QDateTime>& expires) -> bool {
unsigned long expires_time = 0;
if (expires != nullptr) expires_time = expires->toSecsSinceEpoch();
@@ -95,81 +94,83 @@ auto GpgFrontend::GpgKeyManager::SetExpire(const GpgFrontend::GpgKey& key,
auto GpgFrontend::GpgKeyManager::SetOwnerTrustLevel(const GpgKey& key,
int trust_level) -> bool {
if (trust_level < 0 || trust_level > 5) {
- GF_CORE_LOG_ERROR("illegal owner trust level: {}", trust_level);
+ qCWarning(core, "illegal owner trust level: %d", trust_level);
}
- AutomatonNextStateHandler next_state_handler = [](AutomatonState state,
- QString status,
- QString args) {
- GF_CORE_LOG_DEBUG("next_state_handler state: {}, gpg_status: {}, args: {}",
- state, status, args);
- auto tokens = args.split(' ');
+ AutomatonNextStateHandler next_state_handler =
+ [](AutomatonState state, QString status, QString args) {
+ qCDebug(core) << "next_state_handler state: "
+ << static_cast<unsigned int>(state)
+ << ", gpg_status: " << status << ", args: " << args;
- switch (state) {
- case AS_START:
- if (status == "GET_LINE" && args == "keyedit.prompt") {
- return AS_COMMAND;
- }
- return AS_ERROR;
- case AS_COMMAND:
- if (status == "GET_LINE" && args == "edit_ownertrust.value") {
- return AS_VALUE;
- }
- return AS_ERROR;
- case AS_VALUE:
- if (status == "GET_LINE" && args == "keyedit.prompt") {
- return AS_QUIT;
- } else if (status == "GET_BOOL" &&
- args == "edit_ownertrust.set_ultimate.okay") {
- return AS_REALLY_ULTIMATE;
- }
- return AS_ERROR;
- case AS_REALLY_ULTIMATE:
- if (status == "GET_LINE" && args == "keyedit.prompt") {
- return AS_QUIT;
- }
- return AS_ERROR;
- case AS_QUIT:
- if (status == "GET_LINE" && args == "keyedit.save.okay") {
- return AS_SAVE;
- }
- return AS_ERROR;
- case AS_ERROR:
- if (status == "GET_LINE" && args == "keyedit.prompt") {
- return AS_QUIT;
- }
- return AS_ERROR;
- default:
- return AS_ERROR;
- };
- };
+ auto tokens = args.split(' ');
- AutomatonActionHandler action_handler =
- [trust_level](AutomatonHandelStruct& handler, AutomatonState state) {
- GF_CORE_LOG_DEBUG("action_handler state: {}", state);
switch (state) {
+ case AS_START:
+ if (status == "GET_LINE" && args == "keyedit.prompt") {
+ return AS_COMMAND;
+ }
+ return AS_ERROR;
case AS_COMMAND:
- return QString("trust");
+ if (status == "GET_LINE" && args == "edit_ownertrust.value") {
+ return AS_VALUE;
+ }
+ return AS_ERROR;
case AS_VALUE:
- handler.SetSuccess(true);
- return QString::number(trust_level);
+ if (status == "GET_LINE" && args == "keyedit.prompt") {
+ return AS_QUIT;
+ } else if (status == "GET_BOOL" &&
+ args == "edit_ownertrust.set_ultimate.okay") {
+ return AS_REALLY_ULTIMATE;
+ }
+ return AS_ERROR;
case AS_REALLY_ULTIMATE:
- handler.SetSuccess(true);
- return QString("Y");
+ if (status == "GET_LINE" && args == "keyedit.prompt") {
+ return AS_QUIT;
+ }
+ return AS_ERROR;
case AS_QUIT:
- return QString("quit");
- case AS_SAVE:
- handler.SetSuccess(true);
- return QString("Y");
- case AS_START:
+ if (status == "GET_LINE" && args == "keyedit.save.okay") {
+ return AS_SAVE;
+ }
+ return AS_ERROR;
case AS_ERROR:
- return QString("");
+ if (status == "GET_LINE" && args == "keyedit.prompt") {
+ return AS_QUIT;
+ }
+ return AS_ERROR;
default:
- return QString("");
- }
- return QString("");
+ return AS_ERROR;
+ };
};
+ AutomatonActionHandler action_handler = [trust_level](
+ AutomatonHandelStruct& handler,
+ AutomatonState state) {
+ qCDebug(core, "action_handler state: %d", static_cast<unsigned int>(state));
+ switch (state) {
+ case AS_COMMAND:
+ return QString("trust");
+ case AS_VALUE:
+ handler.SetSuccess(true);
+ return QString::number(trust_level);
+ case AS_REALLY_ULTIMATE:
+ handler.SetSuccess(true);
+ return QString("Y");
+ case AS_QUIT:
+ return QString("quit");
+ case AS_SAVE:
+ handler.SetSuccess(true);
+ return QString("Y");
+ case AS_START:
+ case AS_ERROR:
+ return QString("");
+ default:
+ return QString("");
+ }
+ return QString("");
+ };
+
auto key_fpr = key.GetFingerprint();
AutomatonHandelStruct handel_struct(key_fpr);
handel_struct.SetHandler(next_state_handler, action_handler);
@@ -185,21 +186,19 @@ auto GpgFrontend::GpgKeyManager::SetOwnerTrustLevel(const GpgKey& key,
auto GpgFrontend::GpgKeyManager::interactor_cb_fnc(void* handle,
const char* status,
- const char* args, int fd)
- -> gpgme_error_t {
+ const char* args,
+ int fd) -> gpgme_error_t {
auto* handle_struct = static_cast<AutomatonHandelStruct*>(handle);
QString status_s = status;
QString args_s = args;
- GF_CORE_LOG_DEBUG(
- "cb start status: {}, args: {}, fd: {}, handle struct state: {}",
- status_s, args_s, fd, handle_struct->CuurentStatus());
if (status_s == "KEY_CONSIDERED") {
auto tokens = QString(args).split(' ');
if (tokens.empty() || tokens[0] != handle_struct->KeyFpr()) {
- GF_CORE_LOG_ERROR("handle struct key fpr {} mismatch token: {}, exit...",
- handle_struct->KeyFpr(), tokens[0]);
+ qCWarning(core) << "handle struct key fpr " << handle_struct->KeyFpr()
+ << "mismatch token: " << tokens[0] << ", exit...";
+
return -1;
}
@@ -207,13 +206,13 @@ auto GpgFrontend::GpgKeyManager::interactor_cb_fnc(void* handle,
}
if (status_s == "GOT_IT" || status_s.isEmpty()) {
- GF_CORE_LOG_DEBUG("status GOT_IT, continue...");
+ qCDebug(core, "status GOT_IT, continue...");
return 0;
}
AutomatonState next_state = handle_struct->NextState(status_s, args_s);
if (next_state == AS_ERROR) {
- GF_CORE_LOG_DEBUG("handle struct next state caught error, skipping...");
+ qCDebug(core, "handle struct next state caught error, skipping...");
return GPG_ERR_FALSE;
}
@@ -224,8 +223,7 @@ auto GpgFrontend::GpgKeyManager::interactor_cb_fnc(void* handle,
// set state and preform action
handle_struct->SetStatus(next_state);
Command cmd = handle_struct->Action();
- GF_CORE_LOG_DEBUG("handle struct action done, next state: {}, action cmd: {}",
- next_state, cmd);
+
if (!cmd.isEmpty()) {
auto btye_array = cmd.toUtf8();
gpgme_io_write(fd, btye_array, btye_array.size());
diff --git a/src/core/function/gpg/GpgKeyManager.h b/src/core/function/gpg/GpgKeyManager.h
index 8b4d41b2..85dc6be5 100644
--- a/src/core/function/gpg/GpgKeyManager.h
+++ b/src/core/function/gpg/GpgKeyManager.h
@@ -105,7 +105,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKeyManager
AS_ERROR,
AS_QUIT,
};
-
+
struct AutomatonHandelStruct;
using AutomatonActionHandler =
diff --git a/src/core/function/gpg/GpgKeyOpera.cpp b/src/core/function/gpg/GpgKeyOpera.cpp
index 14d58a10..0205ea2f 100644
--- a/src/core/function/gpg/GpgKeyOpera.cpp
+++ b/src/core/function/gpg/GpgKeyOpera.cpp
@@ -61,7 +61,7 @@ void GpgKeyOpera::DeleteKeys(KeyIdArgsListPtr key_ids) {
GPGME_DELETE_ALLOW_SECRET | GPGME_DELETE_FORCE));
assert(gpg_err_code(err) == GPG_ERR_NO_ERROR);
} else {
- GF_CORE_LOG_WARN("GpgKeyOpera DeleteKeys get key failed", tmp);
+ qCWarning(core) << "GpgKeyOpera DeleteKeys get key failed: " << tmp;
}
}
}
@@ -113,14 +113,12 @@ void GpgKeyOpera::GenerateRevokeCert(const GpgKey& key,
output_path, "--gen-revoke", key.GetFingerprint()},
[=](int exit_code, const QString& p_out, const QString& p_err) {
if (exit_code != 0) {
- GF_CORE_LOG_ERROR(
- "gnupg gen revoke execute error, process stderr: {}, process "
- "stdout: {}",
- p_err, p_out);
+ qCWarning(core) << "gnupg gen revoke execute error, process stderr: "
+ << p_err << ", process stdout: " << p_out;
} else {
- GF_CORE_LOG_DEBUG(
- "gnupg gen revoke exit_code: {}, process stdout size: {}",
- exit_code, p_out.size());
+ qCDebug(core,
+ "gnupg gen revoke exit_code: %d, process stdout size: %lld",
+ exit_code, p_out.size());
}
},
nullptr,
@@ -128,7 +126,6 @@ void GpgKeyOpera::GenerateRevokeCert(const GpgKey& key,
// Code From Gpg4Win
while (proc->canReadLine()) {
const QString line = QString::fromUtf8(proc->readLine()).trimmed();
- GF_CORE_LOG_DEBUG("line: {}", line);
if (line == QLatin1String("[GNUPG:] GET_BOOL gen_revoke.okay")) {
proc->write("y\n");
} else if (line == QLatin1String("[GNUPG:] GET_LINE "
@@ -162,8 +159,8 @@ void GpgKeyOpera::GenerateKey(const std::shared_ptr<GenKeyInfo>& params,
auto userid = params->GetUserid();
auto algo = params->GetAlgo() + params->GetKeySizeStr();
- GF_CORE_LOG_DEBUG("params: {} {}", params->GetAlgo(),
- params->GetKeySizeStr());
+ qCDebug(core) << "params: " << params->GetAlgo()
+ << params->GetKeySizeStr();
unsigned long expires =
QDateTime::currentDateTime().secsTo(params->GetExpireTime());
@@ -178,8 +175,9 @@ void GpgKeyOpera::GenerateKey(const std::shared_ptr<GenKeyInfo>& params,
if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("key generation args: {} {} {} {}", userid, algo,
- expires, flags);
+ qCDebug(core) << "key generation args: " << userid << algo << expires
+ << flags;
+
err = gpgme_op_createkey(ctx.DefaultContext(), userid.toUtf8(),
algo.toUtf8(), 0, expires, nullptr, flags);
@@ -202,8 +200,8 @@ auto GpgKeyOpera::GenerateKeySync(const std::shared_ptr<GenKeyInfo>& params)
auto userid = params->GetUserid();
auto algo = params->GetAlgo() + params->GetKeySizeStr();
- GF_CORE_LOG_DEBUG("params: {} {}", params->GetAlgo(),
- params->GetKeySizeStr());
+ qCDebug(core) << "params: " << params->GetAlgo()
+ << params->GetKeySizeStr();
unsigned long expires =
QDateTime::currentDateTime().secsTo(params->GetExpireTime());
@@ -218,8 +216,9 @@ auto GpgKeyOpera::GenerateKeySync(const std::shared_ptr<GenKeyInfo>& params)
if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("key generation args: {} {} {} {}", userid, algo,
- expires, flags);
+ qCDebug(core) << "key generation args: " << userid << algo << expires
+ << flags;
+
err = gpgme_op_createkey(ctx.DefaultContext(), userid.toUtf8(),
algo.toUtf8(), 0, expires, nullptr, flags);
@@ -242,8 +241,8 @@ void GpgKeyOpera::GenerateSubkey(const GpgKey& key,
[key, &ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError {
if (!params->IsSubKey()) return GPG_ERR_CANCELED;
- GF_CORE_LOG_DEBUG("generate subkey algo {}, key size {}",
- params->GetAlgo(), params->GetKeySizeStr());
+ qCDebug(core) << "generate subkey algo: " << params->GetAlgo()
+ << "key size: " << params->GetKeySizeStr();
auto algo = params->GetAlgo() + params->GetKeySizeStr();
unsigned long expires =
@@ -257,8 +256,9 @@ void GpgKeyOpera::GenerateSubkey(const GpgKey& key,
if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("subkey generation args: {} {} {} {}", key.GetId(),
- algo, expires, flags);
+ qCDebug(core) << "subkey generation args: " << key.GetId() << algo
+ << expires << flags;
+
auto err = gpgme_op_createsubkey(ctx.DefaultContext(),
static_cast<gpgme_key_t>(key),
algo.toUtf8(), 0, expires, flags);
@@ -281,8 +281,8 @@ auto GpgKeyOpera::GenerateSubkeySync(const GpgKey& key,
[key, &ctx = ctx_, params](const DataObjectPtr& data_object) -> GpgError {
if (!params->IsSubKey()) return GPG_ERR_CANCELED;
- GF_CORE_LOG_DEBUG("generate subkey algo {} key size {}",
- params->GetAlgo(), params->GetKeySizeStr());
+ qCDebug(core) << "generate subkey algo: " << params->GetAlgo()
+ << " key size: " << params->GetKeySizeStr();
auto algo = params->GetAlgo() + params->GetKeySizeStr();
unsigned long expires =
@@ -296,8 +296,7 @@ auto GpgKeyOpera::GenerateSubkeySync(const GpgKey& key,
if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("args: {} {} {} {}", key.GetId(), algo, expires,
- flags);
+ qCDebug(core) << " args: " << key.GetId() << algo << expires << flags;
auto err = gpgme_op_createsubkey(ctx.DefaultContext(),
static_cast<gpgme_key_t>(key),
@@ -337,8 +336,9 @@ void GpgKeyOpera::GenerateKeyWithSubkey(
if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("key generation args: {}", userid, algo, expires,
- flags);
+ qCDebug(core) << "key generation args: " << userid << algo << expires
+ << flags;
+
err = gpgme_op_createkey(ctx.DefaultContext(), userid, algo, 0, expires,
nullptr, flags);
@@ -358,16 +358,11 @@ void GpgKeyOpera::GenerateKeyWithSubkey(
auto key =
GpgKeyGetter::GetInstance().GetKey(genkey_result.GetFingerprint());
if (!key.IsGood()) {
- GF_CORE_LOG_ERROR("cannot get key which has been generate, fpr: {}",
- genkey_result.GetFingerprint());
+ qCWarning(core) << "cannot get key which has been generate, fpr: "
+ << genkey_result.GetFingerprint();
return err;
}
- GF_CORE_LOG_DEBUG(
- "try to generate subkey of key: {}, algo {} key size {}",
- key.GetId(), subkey_params->GetAlgo(),
- subkey_params->GetKeySizeStr());
-
algo = (subkey_params->GetAlgo() + subkey_params->GetKeySizeStr())
.toUtf8();
expires =
@@ -380,8 +375,8 @@ void GpgKeyOpera::GenerateKeyWithSubkey(
if (subkey_params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (subkey_params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("subkey generation args: {} {} {} {}", key.GetId(),
- algo, expires, flags);
+ qCDebug(core) << "subkey generation args: " << key.GetId() << algo
+ << expires << flags;
err = gpgme_op_createsubkey(ctx.DefaultContext(),
static_cast<gpgme_key_t>(key), algo, 0,
@@ -422,8 +417,9 @@ auto GpgKeyOpera::GenerateKeyWithSubkeySync(
if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("key generation args: {}", userid, algo, expires,
- flags);
+ qCDebug(core) << "key generation args: " << userid << algo << expires
+ << flags;
+
err = gpgme_op_createkey(ctx.DefaultContext(), userid, algo, 0, expires,
nullptr, flags);
@@ -443,15 +439,14 @@ auto GpgKeyOpera::GenerateKeyWithSubkeySync(
auto key =
GpgKeyGetter::GetInstance().GetKey(genkey_result.GetFingerprint());
if (!key.IsGood()) {
- GF_CORE_LOG_ERROR("cannot get key which has been generate, fpr: {}",
- genkey_result.GetFingerprint());
+ qCWarning(core) << "cannot get key which has been generate, fpr: "
+ << genkey_result.GetFingerprint();
return err;
}
- GF_CORE_LOG_DEBUG(
- "try to generate subkey of key: {}, algo {} key size {}",
- key.GetId(), subkey_params->GetAlgo(),
- subkey_params->GetKeySizeStr());
+ qCDebug(core) << "try to generate subkey of key: " << key.GetId()
+ << ", algo :" << subkey_params->GetAlgo()
+ << ", key size: " << subkey_params->GetKeySizeStr();
algo = (subkey_params->GetAlgo() + subkey_params->GetKeySizeStr())
.toUtf8();
@@ -465,8 +460,8 @@ auto GpgKeyOpera::GenerateKeyWithSubkeySync(
if (subkey_params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
if (subkey_params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
- GF_CORE_LOG_DEBUG("subkey generation args: {} {} {} {}", key.GetId(),
- algo, expires, flags);
+ qCDebug(core) << "subkey generation args: " << key.GetId() << algo
+ << expires << flags;
err = gpgme_op_createsubkey(ctx.DefaultContext(),
static_cast<gpgme_key_t>(key), algo, 0,
@@ -495,15 +490,14 @@ void GpgKeyOpera::ModifyPassword(const GpgKey& key,
callback, "gpgme_op_passwd", "2.0.15");
}
-auto GpgKeyOpera::ModifyTOFUPolicy(const GpgKey& key,
- gpgme_tofu_policy_t tofu_policy)
- -> GpgError {
+auto GpgKeyOpera::ModifyTOFUPolicy(
+ const GpgKey& key, gpgme_tofu_policy_t tofu_policy) -> GpgError {
const auto gnupg_version = Module::RetrieveRTValueTypedOrDefault<>(
"core", "gpgme.ctx.gnupg_version", QString{"2.0.0"});
- GF_CORE_LOG_DEBUG("got gnupg version from rt: {}", gnupg_version);
+ qCDebug(core) << "got gnupg version from rt: " << gnupg_version;
if (GFCompareSoftwareVersion(gnupg_version, "2.1.10") < 0) {
- GF_CORE_LOG_ERROR("operator not support");
+ qCWarning(core, "operator not support");
return GPG_ERR_NOT_SUPPORTED;
}
diff --git a/src/core/function/gpg/GpgUIDOperator.cpp b/src/core/function/gpg/GpgUIDOperator.cpp
index 6c0373de..4477dd2f 100644
--- a/src/core/function/gpg/GpgUIDOperator.cpp
+++ b/src/core/function/gpg/GpgUIDOperator.cpp
@@ -48,17 +48,17 @@ auto GpgUIDOperator::RevUID(const GpgKey& key, const QString& uid) -> bool {
return CheckGpgError(err) == GPG_ERR_NO_ERROR;
}
-auto GpgUIDOperator::SetPrimaryUID(const GpgKey& key, const QString& uid)
- -> bool {
+auto GpgUIDOperator::SetPrimaryUID(const GpgKey& key,
+ const QString& uid) -> bool {
auto err = CheckGpgError(gpgme_op_set_uid_flag(
ctx_.DefaultContext(), static_cast<gpgme_key_t>(key), uid.toUtf8(),
"primary", nullptr));
return CheckGpgError(err) == GPG_ERR_NO_ERROR;
}
auto GpgUIDOperator::AddUID(const GpgKey& key, const QString& name,
- const QString& comment, const QString& email)
- -> bool {
- GF_CORE_LOG_DEBUG("new uuid: {} {} {}", name, comment, email);
+ const QString& comment,
+ const QString& email) -> bool {
+ qCDebug(core) << "new uuid:" << name << comment << email;
return AddUID(key, QString("%1(%2)<%3>").arg(name).arg(comment).arg(email));
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-28 07:17:36 +0000