diff --git a/src/commands/importcertificatefromfilecommand.cpp b/src/commands/importcertificatefromfilecommand.cpp index 3b44dc9a2..14f3539c5 100644 --- a/src/commands/importcertificatefromfilecommand.cpp +++ b/src/commands/importcertificatefromfilecommand.cpp @@ -1,169 +1,169 @@ /* -*- mode: c++; c-basic-offset:4 -*- importcertificatefromfilecommand.cpp This file is part of Kleopatra, the KDE keymanager SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB SPDX-License-Identifier: GPL-2.0-or-later */ #include #include "importcertificatefromfilecommand.h" #include "importcertificatescommand_p.h" #include "utils/filedialog.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace GpgME; using namespace Kleo; using namespace QGpgME; class ImportCertificateFromFileCommand::Private : public ImportCertificatesCommand::Private { friend class ::ImportCertificateFromFileCommand; ImportCertificateFromFileCommand *q_func() const { return static_cast(q); } public: explicit Private(ImportCertificateFromFileCommand *qq, KeyListController *c); ~Private() override; bool ensureHaveFile(); private: QStringList files; }; ImportCertificateFromFileCommand::Private *ImportCertificateFromFileCommand::d_func() { return static_cast(d.get()); } const ImportCertificateFromFileCommand::Private *ImportCertificateFromFileCommand::d_func() const { return static_cast(d.get()); } ImportCertificateFromFileCommand::Private::Private(ImportCertificateFromFileCommand *qq, KeyListController *c) : ImportCertificatesCommand::Private(qq, c), files() { } ImportCertificateFromFileCommand::Private::~Private() {} #define d d_func() #define q q_func() ImportCertificateFromFileCommand::ImportCertificateFromFileCommand() : ImportCertificatesCommand(new Private(this, nullptr)) { } ImportCertificateFromFileCommand::ImportCertificateFromFileCommand(KeyListController *p) : ImportCertificatesCommand(new Private(this, p)) { } ImportCertificateFromFileCommand::ImportCertificateFromFileCommand(QAbstractItemView *v, KeyListController *p) : ImportCertificatesCommand(v, new Private(this, p)) { } ImportCertificateFromFileCommand::ImportCertificateFromFileCommand(const QStringList &files, KeyListController *p) : ImportCertificatesCommand(new Private(this, p)) { d->files = files; } ImportCertificateFromFileCommand::ImportCertificateFromFileCommand(const QStringList &files, QAbstractItemView *v, KeyListController *p) : ImportCertificatesCommand(v, new Private(this, p)) { d->files = files; } ImportCertificateFromFileCommand::~ImportCertificateFromFileCommand() {} void ImportCertificateFromFileCommand::setFiles(const QStringList &files) { d->files = files; } void ImportCertificateFromFileCommand::doStart() { if (!d->ensureHaveFile()) { Q_EMIT canceled(); d->finished(); return; } //TODO: use KIO here d->setWaitForMoreJobs(true); for (const QString &fn : std::as_const(d->files)) { QFile in(fn); if (!in.open(QIODevice::ReadOnly)) { d->error(i18n("Could not open file %1 for reading: %2", in.fileName(), in.errorString()), i18n("Certificate Import Failed")); - d->importResult(ImportResult(), fn); + d->importResult({fn, ImportResult{}}); continue; } const auto data = in.readAll(); d->startImport(GpgME::OpenPGP, data, fn); d->startImport(GpgME::CMS, data, fn); } d->setWaitForMoreJobs(false); } static QStringList get_file_name(QWidget *parent) { const QString certificateFilter = i18n("Certificates") + QLatin1String(" (*.asc *.cer *.cert *.crt *.der *.pem *.gpg *.p7c *.p12 *.pfx *.pgp)"); const QString anyFilesFilter = i18n("Any files") + QLatin1String(" (*)"); QString previousDir; if (const KSharedConfig::Ptr config = KSharedConfig::openConfig()) { const KConfigGroup group(config, "Import Certificate"); previousDir = group.readPathEntry("last-open-file-directory", QDir::homePath()); } const QStringList files = Kleo::FileDialog::getOpenFileNames(parent, i18n("Select Certificate File"), previousDir, certificateFilter + QLatin1String(";;") + anyFilesFilter); if (!files.empty()) if (const KSharedConfig::Ptr config = KSharedConfig::openConfig()) { KConfigGroup group(config, "Import Certificate"); group.writePathEntry("last-open-file-directory", QFileInfo(files.front()).path()); } return files; } bool ImportCertificateFromFileCommand::Private::ensureHaveFile() { if (files.empty()) { files = get_file_name(parentWidgetOrView()); } return !files.empty(); } #undef d #undef q diff --git a/src/commands/importcertificatescommand.cpp b/src/commands/importcertificatescommand.cpp index b97d117b5..8fc2b32f0 100644 --- a/src/commands/importcertificatescommand.cpp +++ b/src/commands/importcertificatescommand.cpp @@ -1,670 +1,689 @@ /* -*- mode: c++; c-basic-offset:4 -*- commands/importcertificatescommand.cpp This file is part of Kleopatra, the KDE keymanager SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik SPDX-FileContributor: Intevation GmbH SPDX-License-Identifier: GPL-2.0-or-later */ #include #include "importcertificatescommand.h" #include "importcertificatescommand_p.h" #include "certifycertificatecommand.h" #include "kleopatra_debug.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // for Qt::escape #include #include #include #include using namespace GpgME; using namespace Kleo; using namespace QGpgME; +bool operator==(const ImportJobData &lhs, const ImportJobData &rhs) +{ + return lhs.job == rhs.job; +} + namespace { make_comparator_str(ByImportFingerprint, .fingerprint()); class ImportResultProxyModel : public AbstractKeyListSortFilterProxyModel { Q_OBJECT public: - ImportResultProxyModel(const std::vector &results, const QStringList &ids, QObject *parent = nullptr) + ImportResultProxyModel(const std::vector &results, QObject *parent = nullptr) : AbstractKeyListSortFilterProxyModel(parent) { - updateFindCache(results, ids); + updateFindCache(results); } ~ImportResultProxyModel() override {} ImportResultProxyModel *clone() const override { // compiler-generated copy ctor is fine! return new ImportResultProxyModel(*this); } - void setImportResults(const std::vector &results, const QStringList &ids) + void setImportResults(const std::vector &results) { - updateFindCache(results, ids); + updateFindCache(results); invalidateFilter(); } protected: QVariant data(const QModelIndex &index, int role) const override { if (!index.isValid() || role != Qt::ToolTipRole) { return AbstractKeyListSortFilterProxyModel::data(index, role); } const QString fpr = index.data(KeyList::FingerprintRole).toString(); // find information: const std::vector::const_iterator it = Kleo::binary_find(m_importsByFingerprint.begin(), m_importsByFingerprint.end(), fpr.toLatin1().constData(), ByImportFingerprint()); if (it == m_importsByFingerprint.end()) { return AbstractKeyListSortFilterProxyModel::data(index, role); } else { QStringList rv; const auto ids = m_idsByFingerprint[it->fingerprint()]; rv.reserve(ids.size()); std::copy(ids.cbegin(), ids.cend(), std::back_inserter(rv)); return Formatting::importMetaData(*it, rv); } } bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override { // // 0. Keep parents of matching children: // const QModelIndex index = sourceModel()->index(source_row, 0, source_parent); Q_ASSERT(index.isValid()); for (int i = 0, end = sourceModel()->rowCount(index); i != end; ++i) if (filterAcceptsRow(i, index)) { return true; } // // 1. Check that this is an imported key: // const QString fpr = index.data(KeyList::FingerprintRole).toString(); return std::binary_search(m_importsByFingerprint.begin(), m_importsByFingerprint.end(), fpr.toLatin1().constData(), ByImportFingerprint()); } private: - void updateFindCache(const std::vector &results, const QStringList &ids) + void updateFindCache(const std::vector &results) { - Q_ASSERT(results.size() == static_cast(ids.size())); m_importsByFingerprint.clear(); m_idsByFingerprint.clear(); m_results = results; - for (unsigned int i = 0, end = results.size(); i != end; ++i) { - const std::vector imports = results[i].imports(); + for (const auto &r : results) { + const std::vector imports = r.result.imports(); m_importsByFingerprint.insert(m_importsByFingerprint.end(), imports.begin(), imports.end()); - const QString &id = ids[i]; for (std::vector::const_iterator it = imports.begin(), end = imports.end(); it != end; ++it) { - m_idsByFingerprint[it->fingerprint()].insert(id); + m_idsByFingerprint[it->fingerprint()].insert(r.id); } } std::sort(m_importsByFingerprint.begin(), m_importsByFingerprint.end(), ByImportFingerprint()); } private: mutable std::vector m_importsByFingerprint; mutable std::map< const char *, std::set, ByImportFingerprint > m_idsByFingerprint; - std::vector m_results; + std::vector m_results; }; } ImportCertificatesCommand::Private::Private(ImportCertificatesCommand *qq, KeyListController *c) : Command::Private(qq, c) { } ImportCertificatesCommand::Private::~Private() = default; #define d d_func() #define q q_func() ImportCertificatesCommand::ImportCertificatesCommand(KeyListController *p) : Command(new Private(this, p)) { } ImportCertificatesCommand::ImportCertificatesCommand(QAbstractItemView *v, KeyListController *p) : Command(v, new Private(this, p)) { } ImportCertificatesCommand::~ImportCertificatesCommand() = default; -static QString format_ids(const QStringList &ids) +static QString format_ids(const std::vector &ids) { QStringList escapedIds; for (const QString &id : ids) { if (!id.isEmpty()) { escapedIds << id.toHtmlEscaped(); } } return escapedIds.join(QLatin1String("
")); } -static QString make_tooltip(const QStringList &ids) +static QString make_tooltip(const std::vector &results) { - if (ids.empty()) { - return QString(); + if (results.empty()) { + return {}; } + + std::vector ids; + ids.reserve(results.size()); + std::transform(std::begin(results), std::end(results), + std::back_inserter(ids), + [](const auto &r) { return r.id; }); + std::sort(std::begin(ids), std::end(ids)); + ids.erase(std::unique(std::begin(ids), std::end(ids)), std::end(ids)); + if (ids.size() == 1) if (ids.front().isEmpty()) { - return QString(); + return {}; } else return i18nc("@info:tooltip", "Imported Certificates from %1", ids.front().toHtmlEscaped()); else return i18nc("@info:tooltip", "Imported certificates from these sources:
%1", format_ids(ids)); } -void ImportCertificatesCommand::Private::setImportResultProxyModel(const std::vector &results, const QStringList &ids) +void ImportCertificatesCommand::Private::setImportResultProxyModel(const std::vector &results) { - if (std::none_of(results.cbegin(), results.cend(), std::mem_fn(&ImportResult::numConsidered))) { + if (std::none_of(std::begin(results), std::end(results), + [](const auto &r) { return r.result.numConsidered() > 0; })) { return; } q->addTemporaryView(i18nc("@title:tab", "Imported Certificates"), - new ImportResultProxyModel(results, ids), - make_tooltip(ids)); + new ImportResultProxyModel(results), + make_tooltip(results)); if (QTreeView *const tv = qobject_cast(parentWidgetOrView())) { tv->expandAll(); } } int sum(const std::vector &res, int (ImportResult::*fun)() const) { return kdtools::accumulate_transform(res.begin(), res.end(), std::mem_fn(fun), 0); } -static QString make_report(const std::vector &res, const QString &id = QString()) +static QString make_report(const std::vector &results, const QString &id = QString()) { - const KLocalizedString normalLine = ki18n("%1%2"); const KLocalizedString boldLine = ki18n("%1%2"); const KLocalizedString headerLine = ki18n("%1"); + std::vector res; + res.reserve(results.size()); + std::transform(std::begin(results), std::end(results), + std::back_inserter(res), + [](const auto &r) { return r.result; }); + #define SUM( x ) sum( res, &ImportResult::x ) QStringList lines; if (!id.isEmpty()) { lines.push_back(headerLine.subs(id).toString()); } lines.push_back(normalLine.subs(i18n("Total number processed:")) .subs(SUM(numConsidered)).toString()); lines.push_back(normalLine.subs(i18n("Imported:")) .subs(SUM(numImported)).toString()); if (const int n = SUM(newSignatures)) lines.push_back(normalLine.subs(i18n("New signatures:")) .subs(n).toString()); if (const int n = SUM(newUserIDs)) lines.push_back(normalLine.subs(i18n("New user IDs:")) .subs(n).toString()); if (const int n = SUM(numKeysWithoutUserID)) lines.push_back(normalLine.subs(i18n("Certificates without user IDs:")) .subs(n).toString()); if (const int n = SUM(newSubkeys)) lines.push_back(normalLine.subs(i18n("New subkeys:")) .subs(n).toString()); if (const int n = SUM(newRevocations)) lines.push_back(boldLine.subs(i18n("Newly revoked:")) .subs(n).toString()); if (const int n = SUM(notImported)) lines.push_back(boldLine.subs(i18n("Not imported:")) .subs(n).toString()); if (const int n = SUM(numUnchanged)) lines.push_back(normalLine.subs(i18n("Unchanged:")) .subs(n).toString()); if (const int n = SUM(numSecretKeysConsidered)) lines.push_back(normalLine.subs(i18n("Secret keys processed:")) .subs(n).toString()); if (const int n = SUM(numSecretKeysImported)) lines.push_back(normalLine.subs(i18n("Secret keys imported:")) .subs(n).toString()); if (const int n = SUM(numSecretKeysConsidered) - SUM(numSecretKeysImported) - SUM(numSecretKeysUnchanged)) if (n > 0) lines.push_back(boldLine.subs(i18n("Secret keys not imported:")) .subs(n).toString()); if (const int n = SUM(numSecretKeysUnchanged)) lines.push_back(normalLine.subs(i18n("Secret keys unchanged:")) .subs(n).toString()); if (const int n = SUM(numV3KeysSkipped)) lines.push_back(normalLine.subs(i18n("Deprecated PGP-2 keys skipped:")) .subs(n).toString()); #undef sum return lines.join(QString()); } -static QString make_message_report(const std::vector &res, const QStringList &ids) +static QString make_message_report(const std::vector &res) { - - Q_ASSERT(res.size() == static_cast(ids.size())); - if (res.empty()) { return i18n("No imports (should not happen, please report a bug)."); } if (res.size() == 1) - return ids.front().isEmpty() + return res.front().id.isEmpty() ? i18n("

Detailed results of certificate import:

" "%1
", make_report(res)) : i18n("

Detailed results of importing %1:

" - "%2
", ids.front(), make_report(res)); + "%2
", res.front().id, make_report(res)); return i18n("

Detailed results of certificate import:

" "%1
", make_report(res, i18n("Totals"))); } // Returns false on error, true if please certify was shown. bool ImportCertificatesCommand::Private::showPleaseCertify(const GpgME::Import &imp) { const char *fpr = imp.fingerprint(); if (!fpr) { // WTF qCWarning(KLEOPATRA_LOG) << "Import without fingerprint"; return false; } // Exactly one public key imported. Let's see if it is openpgp. We are async here so // we can just fetch it. auto ctx = GpgME::Context::createForProtocol(GpgME::OpenPGP); if (!ctx) { // WTF qCWarning(KLEOPATRA_LOG) << "Failed to create OpenPGP proto"; return false; } GpgME::Error err; auto key = ctx->key(fpr, err, false); delete ctx; if (key.isNull() || err) { // No such key most likely not OpenPGP return false; } for (const auto &uid: key.userIDs()) { if (uid.validity() >= GpgME::UserID::Marginal) { // Already marginal so don't bug the user return false; } } const QStringList suggestions = QStringList() << i18n("A phone call to the person.") << i18n("Using a business card.") << i18n("Confirming it on a trusted website."); auto sel = KMessageBox::questionYesNo(parentWidgetOrView(), i18n("In order to mark the certificate as valid (green) it needs to be certified.") + QStringLiteral("
") + i18n("Certifying means that you check the Fingerprint.") + QStringLiteral("
") + i18n("Some suggestions to do this are:") + QStringLiteral("
    • %1").arg(suggestions.join(QStringLiteral("
      "))) + QStringLiteral("
    • ") + i18n("Do you wish to start this process now?"), i18nc("@title", "You have imported a new certificate (public key)"), KStandardGuiItem::yes(), KStandardGuiItem::no(), QStringLiteral("CertifyQuestion")); if (sel == KMessageBox::Yes) { QEventLoop loop; auto cmd = new Commands::CertifyCertificateCommand(key); cmd->setParentWidget(parentWidgetOrView()); loop.connect(cmd, SIGNAL(finished()), SLOT(quit())); QMetaObject::invokeMethod(cmd, &Commands::CertifyCertificateCommand::start, Qt::QueuedConnection); loop.exec(); } return true; } -void ImportCertificatesCommand::Private::showDetails(QWidget *parent, const std::vector &res, const QStringList &ids) +void ImportCertificatesCommand::Private::showDetails(QWidget *parent, const std::vector &res) { - if (res.size() == 1 && res[0].numImported() == 1 && res[0].imports().size() == 1) { - if (showPleaseCertify(res[0].imports()[0])) { + if (res.size() == 1 && res[0].result.numImported() == 1 && res[0].result.imports().size() == 1) { + if (showPleaseCertify(res[0].result.imports()[0])) { return; } } - setImportResultProxyModel(res, ids); - KMessageBox::information(parent, make_message_report(res, ids), i18n("Certificate Import Result")); + setImportResultProxyModel(res); + KMessageBox::information(parent, make_message_report(res), i18n("Certificate Import Result")); } -void ImportCertificatesCommand::Private::showDetails(const std::vector &res, const QStringList &ids) +void ImportCertificatesCommand::Private::showDetails(const std::vector &res) { - showDetails(parentWidgetOrView(), res, ids); + showDetails(parentWidgetOrView(), res); } static QString make_error_message(const Error &err, const QString &id) { Q_ASSERT(err); Q_ASSERT(!err.isCanceled()); return id.isEmpty() ? i18n("

    An error occurred while trying " "to import the certificate:

    " "

    %1

    ", QString::fromLocal8Bit(err.asString())) : i18n("

    An error occurred while trying " "to import the certificate %1:

    " "

    %2

    ", id, QString::fromLocal8Bit(err.asString())); } void ImportCertificatesCommand::Private::showError(QWidget *parent, const Error &err, const QString &id) { if (parent) { KMessageBox::error(parent, make_error_message(err, id), i18n("Certificate Import Failed")); } else { showError(err, id); } } void ImportCertificatesCommand::Private::showError(const Error &err, const QString &id) { error(make_error_message(err, id), i18n("Certificate Import Failed")); } void ImportCertificatesCommand::Private::setWaitForMoreJobs(bool wait) { if (wait == waitForMoreJobs) { return; } waitForMoreJobs = wait; tryToFinish(); } void ImportCertificatesCommand::Private::importResult(const ImportResult &result) { - const auto job = q->sender(); - jobs.erase(std::remove(jobs.begin(), jobs.end(), job), jobs.end()); + const auto finishedJob = q->sender(); + auto it = std::find_if(std::cbegin(jobs), std::cend(jobs), + [finishedJob](const auto &job) { return job.job == finishedJob; }); + Q_ASSERT(it != std::cend(jobs)); + if (it == std::cend(jobs)) { + qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Finished job not found"; + } + const auto job = *it; + jobs.erase(std::remove(std::begin(jobs), std::end(jobs), job), std::end(jobs)); - const auto nodeHandler = idsByJob.extract(job); - const auto id = nodeHandler.mapped(); - importResult(result, id); + importResult({job.id, result}); } -void ImportCertificatesCommand::Private::importResult(const ImportResult &result, const QString &id) +void ImportCertificatesCommand::Private::importResult(const ImportResultData &result) { - + qCDebug(KLEOPATRA_LOG) << __func__ << result.id; results.push_back(result); - ids.push_back(id); tryToFinish(); } -static void handleOwnerTrust(const std::vector &results) +static void handleOwnerTrust(const std::vector &results) { //iterate over all imported certificates - for (const ImportResult &result : results) { + for (const auto &r: results) { //when a new certificate got a secret key - if (result.numSecretKeysImported() >= 1) { - const char *fingerPr = result.imports()[0].fingerprint(); + if (r.result.numSecretKeysImported() >= 1) { + const char *fingerPr = r.result.imports()[0].fingerprint(); GpgME::Error err; QScopedPointer ctx(Context::createForProtocol(GpgME::Protocol::OpenPGP)); if (!ctx){ qCWarning(KLEOPATRA_LOG) << "Failed to get context"; continue; } const Key toTrustOwner = ctx->key(fingerPr, err , false); if (toTrustOwner.isNull()) { return; } QStringList uids; const auto toTrustOwnerUserIDs{toTrustOwner.userIDs()}; uids.reserve(toTrustOwnerUserIDs.size()); for (const UserID &uid : toTrustOwnerUserIDs) { uids << Formatting::prettyNameAndEMail(uid); } const QString str = xi18nc("@info", "You have imported a Secret Key." "The key has the fingerprint:" "%1" "" "And claims the User IDs:" "%2" "" "Is this your own key? (Set trust level to ultimate)", QString::fromUtf8(fingerPr), uids.join(QLatin1String(""))); int k = KMessageBox::questionYesNo(nullptr, str, i18nc("@title:window", "Secret key imported")); if (k == KMessageBox::Yes) { //To use the ChangeOwnerTrustJob over //the CryptoBackendFactory const QGpgME::Protocol *const backend = QGpgME::openpgp(); if (!backend){ qCWarning(KLEOPATRA_LOG) << "Failed to get CryptoBackend"; return; } ChangeOwnerTrustJob *const j = backend->changeOwnerTrustJob(); j->start(toTrustOwner, Key::Ultimate); } } } } void ImportCertificatesCommand::Private::processResults() { QStringList fingerprints; // For external CMS Imports we have to manually do a keylist // with validation to get the intermediate and root ca imported // automatically if trusted-certs and extra-certs are used. - for (const ImportResult &result : std::as_const(results)) { - const auto imports = result.imports(); + for (const auto &r : results) { + const auto imports = r.result.imports(); for (const Import &import : imports) { if (!import.fingerprint()) { continue; } fingerprints << QString::fromLatin1(import.fingerprint()); } } auto job = QGpgME::smime()->keyListJob(false, true, true); // Old connect here because of Windows. connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector,QString,GpgME::Error)), q, SLOT(keyListDone(GpgME::KeyListResult,std::vector,QString,GpgME::Error))); job->start(fingerprints, false); } void ImportCertificatesCommand::Private::keyListDone(const GpgME::KeyListResult &, const std::vector &keys, const QString &, const GpgME::Error&) { KeyCache::mutableInstance()->refresh(keys); handleOwnerTrust(results); - showDetails(results, ids); + showDetails(results); auto tv = dynamic_cast (view()); if (!tv) { qCDebug(KLEOPATRA_LOG) << "Failed to find treeview"; } else { tv->expandAll(); } finished(); } namespace { -bool importFailed(const GpgME::ImportResult &result) +bool importFailed(const ImportResultData &r) { // ignore GPG_ERR_EOF error to handle the "failed" import of files // without X.509 certificates by gpgsm gracefully - return result.error().code() != GPG_ERR_NO_ERROR - && result.error().code() != GPG_ERR_EOF; + return r.result.error().code() != GPG_ERR_NO_ERROR + && r.result.error().code() != GPG_ERR_EOF; } } void ImportCertificatesCommand::Private::tryToFinish() { if (waitForMoreJobs || !jobs.empty()) { return; } - if (std::any_of(results.cbegin(), results.cend(), &importFailed)) { - setImportResultProxyModel(results, ids); - if (std::all_of(results.cbegin(), results.cend(), - [](const GpgME::ImportResult &result) { - return result.error().isCanceled(); + if (std::any_of(std::cbegin(results), std::cend(results), &importFailed)) { + setImportResultProxyModel(results); + if (std::all_of(std::cbegin(results), std::cend(results), + [](const auto &r) { + return r.result.error().isCanceled(); })) { Q_EMIT q->canceled(); } else { - for (unsigned int i = 0, end = results.size(); i != end; ++i) { - if (importFailed(results[i])) { - showError(results[i].error(), ids[i]); + for (const auto &r : results) { + if (importFailed(r)) { + showError(r.result.error(), r.id); } } } finished(); return; } processResults(); } static std::unique_ptr get_import_job(GpgME::Protocol protocol) { Q_ASSERT(protocol != UnknownProtocol); if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) { return std::unique_ptr(backend->importJob()); } else { return std::unique_ptr(); } } void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const QByteArray &data, const QString &id) { Q_ASSERT(protocol != UnknownProtocol); if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) { return; } std::unique_ptr job = get_import_job(protocol); if (!job.get()) { nonWorkingProtocols.push_back(protocol); error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.", Formatting::displayName(protocol)), i18n("Certificate Import Failed")); - importResult(ImportResult(), id); + importResult({id, ImportResult{}}); return; } connect(job.get(), SIGNAL(result(GpgME::ImportResult)), q, SLOT(importResult(GpgME::ImportResult))); connect(job.get(), &Job::progress, q, &Command::progress); const GpgME::Error err = job->start(data); if (err.code()) { - importResult(ImportResult(err), id); + importResult({id, ImportResult{err}}); } else { - jobs.push_back(job.release()); - idsByJob[jobs.back()] = id; + jobs.push_back({id, job.release()}); } } static std::unique_ptr get_import_from_keyserver_job(GpgME::Protocol protocol) { Q_ASSERT(protocol != UnknownProtocol); if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) { return std::unique_ptr(backend->importFromKeyserverJob()); } else { return std::unique_ptr(); } } void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const std::vector &keys, const QString &id) { Q_ASSERT(protocol != UnknownProtocol); if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) { return; } std::unique_ptr job = get_import_from_keyserver_job(protocol); if (!job.get()) { nonWorkingProtocols.push_back(protocol); error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.", Formatting::displayName(protocol)), i18n("Certificate Import Failed")); - importResult(ImportResult(), id); + importResult({id, ImportResult{}}); return; } connect(job.get(), SIGNAL(result(GpgME::ImportResult)), q, SLOT(importResult(GpgME::ImportResult))); connect(job.get(), &Job::progress, q, &Command::progress); const GpgME::Error err = job->start(keys); if (err.code()) { - importResult(ImportResult(err), id); + importResult({id, ImportResult{err}}); } else { - jobs.push_back(job.release()); - idsByJob[jobs.back()] = id; + jobs.push_back({id, job.release()}); } } void ImportCertificatesCommand::doCancel() { - std::for_each(d->jobs.begin(), d->jobs.end(), [](Job *job) { job->slotCancel(); }); + std::for_each(std::cbegin(d->jobs), std::cend(d->jobs), + [](const auto &job) { job.job->slotCancel(); }); + d->jobs.clear(); } #undef d #undef q #include "moc_importcertificatescommand.cpp" #include "importcertificatescommand.moc" diff --git a/src/commands/importcertificatescommand_p.h b/src/commands/importcertificatescommand_p.h index 6b37473b2..b811fea65 100644 --- a/src/commands/importcertificatescommand_p.h +++ b/src/commands/importcertificatescommand_p.h @@ -1,91 +1,103 @@ /* -*- mode: c++; c-basic-offset:4 -*- commands/importcertificatescommand_p.h This file is part of Kleopatra, the KDE keymanager SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB SPDX-License-Identifier: GPL-2.0-or-later */ #pragma once #include "command_p.h" #include "importcertificatescommand.h" #include +#include #include #include namespace GpgME { -class ImportResult; class Import; class KeyListResult; class Error; } namespace QGpgME { class AbstractImportJob; } class QByteArray; +struct ImportJobData +{ + QString id; + QGpgME::AbstractImportJob *job; +}; + +bool operator==(const ImportJobData &lhs, const ImportJobData &rhs); + +struct ImportResultData +{ + QString id; + GpgME::ImportResult result; +}; + class Kleo::ImportCertificatesCommand::Private : public Command::Private { friend class ::Kleo::ImportCertificatesCommand; Kleo::ImportCertificatesCommand *q_func() const { return static_cast(q); } public: explicit Private(ImportCertificatesCommand *qq, KeyListController *c); ~Private() override; void setWaitForMoreJobs(bool waiting); void startImport(GpgME::Protocol proto, const QByteArray &data, const QString &id = QString()); void startImport(GpgME::Protocol proto, const std::vector &keys, const QString &id = QString()); void importResult(const GpgME::ImportResult &); - void importResult(const GpgME::ImportResult &, const QString &); + void importResult(const ImportResultData &result); void showError(QWidget *parent, const GpgME::Error &error, const QString &id = QString()); void showError(const GpgME::Error &error, const QString &id = QString()); - void showDetails(QWidget *parent, const std::vector &results, const QStringList &ids); - void showDetails(const std::vector &results, const QStringList &ids); + void showDetails(QWidget *parent, const std::vector &results); + void showDetails(const std::vector &results); - void setImportResultProxyModel(const std::vector &results, const QStringList &ids); + void setImportResultProxyModel(const std::vector &results); bool showPleaseCertify(const GpgME::Import &imp); void keyListDone(const GpgME::KeyListResult &result, const std::vector &keys, const QString &, const GpgME::Error&); private: void processResults(); void tryToFinish(); private: bool waitForMoreJobs = false; std::vector nonWorkingProtocols; - std::map idsByJob; - std::vector jobs; - std::vector results; - QStringList ids; + std::vector jobs; + std::vector results; }; inline Kleo::ImportCertificatesCommand::Private *Kleo::ImportCertificatesCommand::d_func() { return static_cast(d.get()); } inline const Kleo::ImportCertificatesCommand::Private *Kleo::ImportCertificatesCommand::d_func() const { return static_cast(d.get()); } inline Kleo::ImportCertificatesCommand::ImportCertificatesCommand(Private *pp) : Command(pp) {} inline Kleo::ImportCertificatesCommand::ImportCertificatesCommand(QAbstractItemView *v, Private *pp) : Command(v, pp) {}