File indexing completed on 2024-06-16 04:55:58

 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signemailcontroller.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 <config-kleopatra.h>
 
 #include "signemailcontroller.h"
 
 #include "certificateresolver.h"
 #include "kleopatra_debug.h"
 #include "signemailtask.h"
 #include "taskcollection.h"
 
 #include <crypto/gui/signemailwizard.h>
 
 #include <utils/input.h>
 #include <utils/kleo_assert.h>
 #include <utils/output.h>
 
 #include <Libkleo/Stl_Util>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace GpgME;
 using namespace KMime::Types;
 
 class SignEMailController::Private
 {
     friend class ::Kleo::Crypto::SignEMailController;
     SignEMailController *const q;
 
 public:
     explicit Private(Mode m, SignEMailController *qq);
     ~Private();
 
 private:
     void slotWizardSignersResolved();
     void slotWizardCanceled(); // ### extract to base
 
 private:
     void ensureWizardCreated(); // ### extract to base
     void ensureWizardVisible(); // ### extract to base
     void cancelAllJobs(); // ### extract to base
 
     void schedule(); // ### extract to base
     std::shared_ptr<SignEMailTask> takeRunnable(GpgME::Protocol proto); // ### extract to base
 
 private:
     const Mode mode;
     std::vector<std::shared_ptr<SignEMailTask>> runnable, completed; // ### extract to base
     std::shared_ptr<SignEMailTask> cms, openpgp; // ### extract to base
     QPointer<SignEMailWizard> wizard; // ### extract to base
     Protocol protocol; // ### extract to base
     bool detached : 1;
 };
 
 SignEMailController::Private::Private(Mode m, SignEMailController *qq)
     : q(qq)
     , mode(m)
     , runnable()
     , cms()
     , openpgp()
     , wizard()
     , protocol(UnknownProtocol)
     , detached(false)
 {
 }
 
 SignEMailController::Private::~Private()
 {
 }
 
 SignEMailController::SignEMailController(Mode mode, QObject *p)
     : Controller(p)
     , d(new Private(mode, this))
 {
 }
 
 SignEMailController::SignEMailController(const std::shared_ptr<ExecutionContext> &xc, Mode mode, QObject *p)
     : Controller(xc, p)
     , d(new Private(mode, this))
 {
 }
 
 SignEMailController::~SignEMailController()
 {
     /// ### extract to base
     if (d->wizard && !d->wizard->isVisible()) {
         delete d->wizard;
     }
 }
 
 SignEMailController::Mode SignEMailController::mode() const
 {
     return d->mode;
 }
 
 // ### extract to base
 void SignEMailController::setProtocol(Protocol proto)
 {
     kleo_assert(d->protocol == UnknownProtocol || d->protocol == proto);
     d->protocol = proto;
     d->ensureWizardCreated();
     d->wizard->setPresetProtocol(proto);
 }
 
 Protocol SignEMailController::protocol() const
 {
     return d->protocol;
 }
 
 void SignEMailController::startResolveSigners()
 {
     d->ensureWizardCreated();
 
     d->wizard->setSignersAndCandidates({}, {});
 
     d->ensureWizardVisible();
 }
 
 void SignEMailController::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->openpgp);
     kleo_assert(!d->cms);
     kleo_assert(d->completed.empty());
     kleo_assert(d->runnable.empty());
 
     d->detached = detached;
 }
 
 void SignEMailController::Private::slotWizardSignersResolved()
 {
     Q_EMIT q->signersResolved();
 }
 
 // ### extract to base
 void SignEMailController::Private::slotWizardCanceled()
 {
     q->setLastError(gpg_error(GPG_ERR_CANCELED), i18n("User cancel"));
     q->emitDoneOrError();
 }
 
 void SignEMailController::setInputAndOutput(const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output)
 {
     setInputsAndOutputs(std::vector<std::shared_ptr<Input>>(1, input), std::vector<std::shared_ptr<Output>>(1, output));
 }
 
 // ### extract to base
 void SignEMailController::setInputsAndOutputs(const std::vector<std::shared_ptr<Input>> &inputs, const std::vector<std::shared_ptr<Output>> &outputs)
 {
     kleo_assert(!inputs.empty());
     kleo_assert(!outputs.empty());
 
     std::vector<std::shared_ptr<SignEMailTask>> tasks;
     tasks.reserve(inputs.size());
 
     d->ensureWizardCreated();
 
     const std::vector<Key> keys = d->wizard->resolvedSigners();
     kleo_assert(!keys.empty());
 
     for (unsigned int i = 0, end = inputs.size(); i < end; ++i) {
         const std::shared_ptr<SignEMailTask> task(new SignEMailTask);
         task->setInput(inputs[i]);
         task->setOutput(outputs[i]);
         task->setSigners(keys);
         task->setDetachedSignature(d->detached);
         if (d->mode == ClipboardMode) {
             if (d->protocol == OpenPGP) {
                 task->setClearsign(true);
             } else {
                 task->setAsciiArmor(true);
             }
         }
 
         tasks.push_back(task);
     }
 
     d->runnable.swap(tasks);
 }
 
 // ### extract to base
 void SignEMailController::start()
 {
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     std::vector<std::shared_ptr<Task>> tmp;
     std::copy(d->runnable.begin(), d->runnable.end(), std::back_inserter(tmp));
     coll->setTasks(tmp);
     d->ensureWizardCreated();
     d->wizard->setTaskCollection(coll);
     for (const std::shared_ptr<Task> &t : std::as_const(tmp)) {
         connectTask(t);
     }
 
     d->schedule();
 }
 
 // ### extract to base
 void SignEMailController::Private::schedule()
 {
     if (!cms)
         if (const std::shared_ptr<SignEMailTask> t = takeRunnable(CMS)) {
             t->start();
             cms = t;
         }
 
     if (!openpgp)
         if (const std::shared_ptr<SignEMailTask> t = takeRunnable(OpenPGP)) {
             t->start();
             openpgp = t;
         }
 
     if (!cms && !openpgp) {
         kleo_assert(runnable.empty());
         QPointer<QObject> Q = q;
         for (const std::shared_ptr<SignEMailTask> &t : completed) {
             Q_EMIT q->reportMicAlg(t->micAlg());
             if (!Q) {
                 return;
             }
         }
         q->emitDoneOrError();
     }
 }
 
 // ### extract to base
 std::shared_ptr<SignEMailTask> SignEMailController::Private::takeRunnable(GpgME::Protocol proto)
 {
     const auto it = std::find_if(runnable.begin(), runnable.end(), [proto](const std::shared_ptr<Task> &task) {
         return task->protocol() == proto;
     });
     if (it == runnable.end()) {
         return std::shared_ptr<SignEMailTask>();
     }
 
     const std::shared_ptr<SignEMailTask> result = *it;
     runnable.erase(it);
     return result;
 }
 
 // ### extract to base
 void SignEMailController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
 {
     Q_UNUSED(result)
     Q_ASSERT(task);
 
     // We could just delete the tasks here, but we can't use
     // Qt::QueuedConnection here (we need sender()) and other slots
     // might not yet have executed. Therefore, we push completed tasks
     // into a burial container
 
     if (task == d->cms.get()) {
         d->completed.push_back(d->cms);
         d->cms.reset();
     } else if (task == d->openpgp.get()) {
         d->completed.push_back(d->openpgp);
         d->openpgp.reset();
     }
 
     QTimer::singleShot(0, this, SLOT(schedule()));
 }
 
 // ### extract to base
 void SignEMailController::cancel()
 {
     try {
         if (d->wizard) {
             d->wizard->close();
         }
         d->cancelAllJobs();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 // ### extract to base
 void SignEMailController::Private::cancelAllJobs()
 {
     // we just kill all runnable tasks - this will not result in
     // signal emissions.
     runnable.clear();
 
     // a cancel() will result in a call to
     if (cms) {
         cms->cancel();
     }
     if (openpgp) {
         openpgp->cancel();
     }
 }
 
 // ### extract to base
 void SignEMailController::Private::ensureWizardCreated()
 {
     if (wizard) {
         return;
     }
 
     std::unique_ptr<SignEMailWizard> w(new SignEMailWizard);
     w->setAttribute(Qt::WA_DeleteOnClose);
     connect(w.get(), SIGNAL(signersResolved()), q, SLOT(slotWizardSignersResolved()), Qt::QueuedConnection);
     connect(w.get(), SIGNAL(canceled()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection);
     w->setPresetProtocol(protocol);
     wizard = w.release();
 }
 
 // ### extract to base
 void SignEMailController::Private::ensureWizardVisible()
 {
     ensureWizardCreated();
     q->bringToForeground(wizard);
 }
 
 #include "moc_signemailcontroller.cpp"