File indexing completed on 2024-05-05 04:45:04

 /*
  * Copyright (C) 2003-2005  Justin Karneges <justin@affinix.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  *
  */
 
 #include "gpgop.h"
 #include "gpgaction.h"
 #include "gpgop_p.h"
 
 namespace gpgQCAPlugin {
 
 //----------------------------------------------------------------------------
 // GpgOp
 //----------------------------------------------------------------------------
 GpgOp::Private::Private(GpgOp *_q)
     : QObject(_q)
     , sync(_q)
     , q(_q)
     , act(nullptr)
     , waiting(false)
 {
     reset(ResetAll);
 }
 
 GpgOp::Private::~Private()
 {
     reset(ResetAll);
 }
 
 void GpgOp::Private::reset(ResetMode mode)
 {
     if (act) {
         act->disconnect(this);
         act->setParent(nullptr);
         act->deleteLater();
 
         act = nullptr;
     }
 
     if (mode >= ResetSessionAndData) {
         output = GpgAction::Output();
         result.clear();
         diagnosticText = QString();
         eventList.clear();
     }
 
     if (mode >= ResetAll) {
         opt_ascii       = false;
         opt_noagent     = false;
         opt_alwaystrust = false;
         opt_pubfile     = QString();
         opt_secfile     = QString();
     }
 }
 
 void GpgOp::Private::make_act(GpgOp::Type _op)
 {
     reset(ResetSessionAndData);
 
     op = _op;
 
     act = new GpgAction(this);
 
     connect(act, &GpgAction::readyRead, this, &GpgOp::Private::act_readyRead);
     connect(act, &GpgAction::bytesWritten, this, &GpgOp::Private::act_bytesWritten);
     connect(act, &GpgAction::needPassphrase, this, &GpgOp::Private::act_needPassphrase);
     connect(act, &GpgAction::needCard, this, &GpgOp::Private::act_needCard);
     connect(act, &GpgAction::finished, this, &GpgOp::Private::act_finished);
     connect(act, &GpgAction::readyReadDiagnosticText, this, &GpgOp::Private::act_readyReadDiagnosticText);
 
     act->input.bin             = bin;
     act->input.op              = op;
     act->input.opt_ascii       = opt_ascii;
     act->input.opt_noagent     = opt_noagent;
     act->input.opt_alwaystrust = opt_alwaystrust;
     act->input.opt_pubfile     = opt_pubfile;
     act->input.opt_secfile     = opt_secfile;
 }
 
 void GpgOp::Private::eventReady(const GpgOp::Event &e)
 {
     eventList += e;
     sync.conditionMet();
 }
 
 void GpgOp::Private::eventReady(GpgOp::Event::Type type)
 {
     GpgOp::Event e;
     e.type = type;
     eventReady(e);
 }
 
 void GpgOp::Private::eventReady(GpgOp::Event::Type type, int written)
 {
     GpgOp::Event e;
     e.type    = type;
     e.written = written;
     eventReady(e);
 }
 
 void GpgOp::Private::eventReady(GpgOp::Event::Type type, const QString &keyId)
 {
     GpgOp::Event e;
     e.type  = type;
     e.keyId = keyId;
     eventReady(e);
 }
 
 void GpgOp::Private::act_readyRead()
 {
     if (waiting)
         eventReady(GpgOp::Event::ReadyRead);
     else
         emit q->readyRead();
 }
 
 void GpgOp::Private::act_bytesWritten(int bytes)
 {
     if (waiting)
         eventReady(GpgOp::Event::BytesWritten, bytes);
     else
         emit q->bytesWritten(bytes);
 }
 
 void GpgOp::Private::act_needPassphrase(const QString &keyId)
 {
     if (waiting)
         eventReady(GpgOp::Event::NeedPassphrase, keyId);
     else
         emit q->needPassphrase(keyId);
 }
 
 void GpgOp::Private::act_needCard()
 {
     if (waiting)
         eventReady(GpgOp::Event::NeedCard);
     else
         emit q->needCard();
 }
 
 void GpgOp::Private::act_readyReadDiagnosticText()
 {
     const QString s = act->readDiagnosticText();
     // printf("dtext ready: [%s]\n", qPrintable(s));
     diagnosticText += s;
 
     if (waiting)
         eventReady(GpgOp::Event::ReadyReadDiagnosticText);
     else
         emit q->readyReadDiagnosticText();
 }
 
 void GpgOp::Private::act_finished()
 {
 #ifdef GPG_PROFILE
     if (op == GpgOp::Encrypt)
         printf("<< doEncrypt: %d >>\n", timer.elapsed());
 #endif
 
     result = act->read();
     diagnosticText += act->readDiagnosticText();
     output = act->output;
 
     QMap<int, QString> errmap;
     errmap[GpgOp::ErrorProcess]          = QStringLiteral("ErrorProcess");
     errmap[GpgOp::ErrorPassphrase]       = QStringLiteral("ErrorPassphrase");
     errmap[GpgOp::ErrorFormat]           = QStringLiteral("ErrorFormat");
     errmap[GpgOp::ErrorSignerExpired]    = QStringLiteral("ErrorSignerExpired");
     errmap[GpgOp::ErrorEncryptExpired]   = QStringLiteral("ErrorEncryptExpired");
     errmap[GpgOp::ErrorEncryptUntrusted] = QStringLiteral("ErrorEncryptUntrusted");
     errmap[GpgOp::ErrorEncryptInvalid]   = QStringLiteral("ErrorEncryptInvalid");
     errmap[GpgOp::ErrorDecryptNoKey]     = QStringLiteral("ErrorDecryptNoKey");
     errmap[GpgOp::ErrorUnknown]          = QStringLiteral("ErrorUnknown");
     if (output.success)
         diagnosticText += QStringLiteral("GpgAction success\n");
     else
         diagnosticText += QStringLiteral("GpgAction error: %1\n").arg(errmap[output.errorCode]);
 
     if (output.wasSigned) {
         QString s;
         if (output.verifyResult == GpgOp::VerifyGood)
             s = QStringLiteral("VerifyGood");
         else if (output.verifyResult == GpgOp::VerifyBad)
             s = QStringLiteral("VerifyBad");
         else
             s = QStringLiteral("VerifyNoKey");
         diagnosticText += QStringLiteral("wasSigned: verifyResult: %1\n").arg(s);
     }
 
     // printf("diagnosticText:\n%s", qPrintable(diagnosticText));
 
     reset(ResetSession);
 
     if (waiting)
         eventReady(GpgOp::Event::Finished);
     else
         emit q->finished();
 }
 
 GpgOp::GpgOp(const QString &bin, QObject *parent)
     : QObject(parent)
 {
     d      = new Private(this);
     d->bin = bin;
 }
 
 GpgOp::~GpgOp()
 {
     delete d;
 }
 
 void GpgOp::reset()
 {
     d->reset(ResetAll);
 }
 
 bool GpgOp::isActive() const
 {
     return (d->act ? true : false);
 }
 
 GpgOp::Type GpgOp::op() const
 {
     return d->op;
 }
 
 void GpgOp::setAsciiFormat(bool b)
 {
     d->opt_ascii = b;
 }
 
 void GpgOp::setDisableAgent(bool b)
 {
     d->opt_noagent = b;
 }
 
 void GpgOp::setAlwaysTrust(bool b)
 {
     d->opt_alwaystrust = b;
 }
 
 void GpgOp::setKeyrings(const QString &pubfile, const QString &secfile)
 {
     d->opt_pubfile = pubfile;
     d->opt_secfile = secfile;
 }
 
 void GpgOp::doCheck()
 {
     d->make_act(Check);
     d->act->start();
 }
 
 void GpgOp::doSecretKeyringFile()
 {
     d->make_act(SecretKeyringFile);
     d->act->start();
 }
 
 void GpgOp::doPublicKeyringFile()
 {
     d->make_act(PublicKeyringFile);
     d->act->start();
 }
 
 void GpgOp::doSecretKeys()
 {
     d->make_act(SecretKeys);
     d->act->start();
 }
 
 void GpgOp::doPublicKeys()
 {
     d->make_act(PublicKeys);
     d->act->start();
 }
 
 void GpgOp::doEncrypt(const QStringList &recip_ids)
 {
 #ifdef GPG_PROFILE
     d->timer.start();
     printf("<< doEncrypt >>\n");
 #endif
 
     d->make_act(Encrypt);
     d->act->input.recip_ids = recip_ids;
     d->act->start();
 }
 
 void GpgOp::doDecrypt()
 {
     d->make_act(Decrypt);
     d->act->start();
 }
 
 void GpgOp::doSign(const QString &signer_id)
 {
     d->make_act(Sign);
     d->act->input.signer_id = signer_id;
     d->act->start();
 }
 
 void GpgOp::doSignAndEncrypt(const QString &signer_id, const QStringList &recip_ids)
 {
     d->make_act(SignAndEncrypt);
     d->act->input.signer_id = signer_id;
     d->act->input.recip_ids = recip_ids;
     d->act->start();
 }
 
 void GpgOp::doSignClearsign(const QString &signer_id)
 {
     d->make_act(SignClearsign);
     d->act->input.signer_id = signer_id;
     d->act->start();
 }
 
 void GpgOp::doSignDetached(const QString &signer_id)
 {
     d->make_act(SignDetached);
     d->act->input.signer_id = signer_id;
     d->act->start();
 }
 
 void GpgOp::doVerify()
 {
     d->make_act(Verify);
     d->act->start();
 }
 
 void GpgOp::doVerifyDetached(const QByteArray &sig)
 {
     d->make_act(VerifyDetached);
     d->act->input.sig = sig;
     d->act->start();
 }
 
 void GpgOp::doImport(const QByteArray &in)
 {
     d->make_act(Import);
     d->act->input.inkey = in;
     d->act->start();
 }
 
 void GpgOp::doExport(const QString &key_id)
 {
     d->make_act(Export);
     d->act->input.export_key_id = key_id;
     d->act->start();
 }
 
 void GpgOp::doDeleteKey(const QString &key_fingerprint)
 {
     d->make_act(DeleteKey);
     d->act->input.delete_key_fingerprint = key_fingerprint;
     d->act->start();
 }
 
 #ifdef QPIPE_SECURE
 void GpgOp::submitPassphrase(const QCA::SecureArray &a)
 #else
 void GpgOp::submitPassphrase(const QByteArray &a)
 #endif
 {
     d->act->submitPassphrase(a);
 }
 
 void GpgOp::cardOkay()
 {
     d->act->cardOkay();
 }
 
 QByteArray GpgOp::read()
 {
     if (d->act) {
         return d->act->read();
     } else {
         const QByteArray a = d->result;
         d->result.clear();
         return a;
     }
 }
 
 void GpgOp::write(const QByteArray &in)
 {
     d->act->write(in);
 }
 
 void GpgOp::endWrite()
 {
     d->act->endWrite();
 }
 
 QString GpgOp::readDiagnosticText()
 {
     QString s         = d->diagnosticText;
     d->diagnosticText = QString();
     return s;
 }
 
 GpgOp::Event GpgOp::waitForEvent(int msecs)
 {
     if (!d->eventList.isEmpty())
         return d->eventList.takeFirst();
 
     if (!d->act)
         return GpgOp::Event();
 
     d->waiting = true;
     d->sync.waitForCondition(msecs);
     d->waiting = false;
     if (!d->eventList.isEmpty())
         return d->eventList.takeFirst();
     else
         return GpgOp::Event();
 }
 
 bool GpgOp::success() const
 {
     return d->output.success;
 }
 
 GpgOp::Error GpgOp::errorCode() const
 {
     return d->output.errorCode;
 }
 
 GpgOp::KeyList GpgOp::keys() const
 {
     return d->output.keys;
 }
 
 QString GpgOp::keyringFile() const
 {
     return d->output.keyringFile;
 }
 
 QString GpgOp::homeDir() const
 {
     return d->output.homeDir;
 }
 
 QString GpgOp::encryptedToId() const
 {
     return d->output.encryptedToId;
 }
 
 bool GpgOp::wasSigned() const
 {
     return d->output.wasSigned;
 }
 
 QString GpgOp::signerId() const
 {
     return d->output.signerId;
 }
 
 QDateTime GpgOp::timestamp() const
 {
     return d->output.timestamp;
 }
 
 GpgOp::VerifyResult GpgOp::verifyResult() const
 {
     return d->output.verifyResult;
 }
 
 }