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
  *
  */
 
 // #define GPGOP_DEBUG
 
 #include "gpgaction.h"
 
 #ifdef GPGOP_DEBUG
 #include "stdio.h"
 #endif
 
 namespace gpgQCAPlugin {
 
 static QDateTime getTimestamp(const QString &s)
 {
     if (s.isEmpty())
         return QDateTime();
 
     if (s.contains(QLatin1Char('T'))) {
         return QDateTime::fromString(s, Qt::ISODate);
     } else {
         return QDateTime::fromSecsSinceEpoch(s.toInt());
     }
 }
 
 static QByteArray getCString(const QByteArray &a)
 {
     QByteArray out;
 
     // convert the "backslash" C-string syntax
     for (int n = 0; n < a.size(); ++n) {
         if (a[n] == '\\' && n + 1 < a.size()) {
             ++n;
             unsigned char c = (unsigned char)a[n];
             if (c == '\\') {
                 out += '\\';
             } else if (c == 'x' && n + 2 < a.size()) {
                 ++n;
                 const QByteArray hex = a.mid(n, 2);
                 ++n; // only skip one, loop will skip the next
 
                 bool ok;
                 uint val = hex.toInt(&ok, 16);
                 if (ok) {
                     out += (unsigned char)val;
                 } else {
                     out += "\\x";
                     out += hex;
                 }
             }
         } else {
             out += a[n];
         }
     }
 
     return out;
 }
 
 static bool stringToKeyList(const QString &outstr, GpgOp::KeyList *_keylist, QString *_keyring)
 {
     GpgOp::KeyList    keyList;
     const QStringList lines = outstr.split(QLatin1Char('\n'));
 
     if (lines.count() < 1)
         return false;
 
     QStringList::ConstIterator it = lines.constBegin();
 
     // first line is keyring file
     QString keyring = *(it++);
 
     // if the second line isn't a divider, we are dealing
     // with a new version of gnupg that doesn't give us
     // the keyring file on gpg --list-keys --with-colons
     if (it == lines.constEnd() || (*it).isEmpty() || (*it).at(0) != QLatin1Char('-')) {
         // first line wasn't the keyring name...
         keyring.clear();
         // ...so read the first line again
         it--;
     } else {
         // this was the divider line - skip it
         it++;
     }
 
     for (; it != lines.constEnd(); ++it) {
         const QStringList f = (*it).split(QLatin1Char(':'));
         if (f.count() < 1)
             continue;
         const QString &type = f[0];
 
         bool key     = false; // key or not
         bool primary = false; // primary key or sub key
         // bool sec = false; // private key or not
 
         if (type == QLatin1String("pub")) {
             key     = true;
             primary = true;
         } else if (type == QLatin1String("sec")) {
             key     = true;
             primary = true;
             // sec = true;
         } else if (type == QLatin1String("sub")) {
             key = true;
         } else if (type == QLatin1String("ssb")) {
             key = true;
             // sec = true;
         }
 
         if (key) {
             if (primary) {
                 keyList += GpgOp::Key();
 
                 const QString &trust = f[1];
                 if (trust == QLatin1String("f") || trust == QLatin1String("u"))
                     keyList.last().isTrusted = true;
             }
 
             const int      key_type = f[3].toInt();
             const QString &caps     = f[11];
 
             GpgOp::KeyItem item;
             item.bits = f[2].toInt();
             if (key_type == 1)
                 item.type = GpgOp::KeyItem::RSA;
             else if (key_type == 16)
                 item.type = GpgOp::KeyItem::ElGamal;
             else if (key_type == 17)
                 item.type = GpgOp::KeyItem::DSA;
             else
                 item.type = GpgOp::KeyItem::Unknown;
             item.id             = f[4];
             item.creationDate   = getTimestamp(f[5]);
             item.expirationDate = getTimestamp(f[6]);
             if (caps.contains(QLatin1Char('e')))
                 item.caps |= GpgOp::KeyItem::Encrypt;
             if (caps.contains(QLatin1Char('s')))
                 item.caps |= GpgOp::KeyItem::Sign;
             if (caps.contains(QLatin1Char('c')))
                 item.caps |= GpgOp::KeyItem::Certify;
             if (caps.contains(QLatin1Char('a')))
                 item.caps |= GpgOp::KeyItem::Auth;
 
             keyList.last().keyItems += item;
         } else if (type == QLatin1String("uid")) {
             const QByteArray uid = getCString(f[9].toUtf8());
             keyList.last().userIds.append(QString::fromUtf8(uid));
         } else if (type == QLatin1String("fpr")) {
             const QString &s                           = f[9];
             keyList.last().keyItems.last().fingerprint = s;
         }
     }
 
     if (_keylist)
         *_keylist = keyList;
     if (_keyring)
         *_keyring = keyring;
 
     return true;
 }
 
 static bool findKeyringFilename(const QString &outstr, QString *_keyring)
 {
     const QStringList lines = outstr.split(QLatin1Char('\n'));
     if (lines.count() < 1)
         return false;
 
     *_keyring = lines[0];
     return true;
 }
 
 GpgAction::GpgAction(QObject *parent)
     : QObject(parent)
     , proc(this)
     , dtextTimer(this)
     , utf8Output(false)
 {
     dtextTimer.setSingleShot(true);
 
     connect(&proc, &GPGProc::error, this, &GpgAction::proc_error);
     connect(&proc, &GPGProc::finished, this, &GpgAction::proc_finished);
     connect(&proc, &GPGProc::readyReadStdout, this, &GpgAction::proc_readyReadStdout);
     connect(&proc, &GPGProc::readyReadStderr, this, &GpgAction::proc_readyReadStderr);
     connect(&proc, &GPGProc::readyReadStatusLines, this, &GpgAction::proc_readyReadStatusLines);
     connect(&proc, &GPGProc::bytesWrittenStdin, this, &GpgAction::proc_bytesWrittenStdin);
     connect(&proc, &GPGProc::bytesWrittenAux, this, &GpgAction::proc_bytesWrittenAux);
     connect(&proc, &GPGProc::bytesWrittenCommand, this, &GpgAction::proc_bytesWrittenCommand);
     connect(&proc, &GPGProc::debug, this, &GpgAction::proc_debug);
     connect(&dtextTimer, &QCA::SafeTimer::timeout, this, &GpgAction::t_dtext);
 
     reset();
 }
 
 GpgAction::~GpgAction()
 {
     reset();
 }
 
 void GpgAction::reset()
 {
     collectOutput = true;
     allowInput    = false;
     readConv.setup(LineConverter::Read);
     writeConv.setup(LineConverter::Write);
     readText              = false;
     writeText             = false;
     useAux                = false;
     passphraseKeyId       = QString();
     signing               = false;
     decryptGood           = false;
     signGood              = false;
     curError              = GpgOp::ErrorUnknown;
     badPassphrase         = false;
     need_submitPassphrase = false;
     need_cardOkay         = false;
     diagnosticText        = QString();
     dtextTimer.stop();
 
     output = Output();
 
     proc.reset();
 }
 
 void GpgAction::start()
 {
     reset();
 
     QStringList args;
     bool        extra = false;
 
     if (input.opt_ascii)
         args += QStringLiteral("--armor");
 
     if (input.opt_noagent)
         args += QStringLiteral("--no-use-agent");
 
     if (input.opt_alwaystrust)
         args += QStringLiteral("--always-trust");
 
     if (!input.opt_pubfile.isEmpty() && !input.opt_secfile.isEmpty()) {
         args += QStringLiteral("--no-default-keyring");
         args += QStringLiteral("--keyring");
         args += input.opt_pubfile;
         args += QStringLiteral("--secret-keyring");
         args += input.opt_secfile;
     }
 
     switch (input.op) {
     case GpgOp::Check:
     {
         args += QStringLiteral("--version");
         readText = true;
         break;
     }
     case GpgOp::SecretKeyringFile:
     {
 #ifndef Q_OS_WIN
         args += QStringLiteral("--display-charset=utf-8");
 #endif
         args += QStringLiteral("--list-secret-keys");
         readText = true;
         break;
     }
     case GpgOp::PublicKeyringFile:
     {
 #ifndef Q_OS_WIN
         args += QStringLiteral("--display-charset=utf-8");
 #endif
         args += QStringLiteral("--list-public-keys");
         readText = true;
         break;
     }
     case GpgOp::SecretKeys:
     {
         args += QStringLiteral("--fixed-list-mode");
         args += QStringLiteral("--with-colons");
         args += QStringLiteral("--with-fingerprint");
         args += QStringLiteral("--with-fingerprint");
         args += QStringLiteral("--list-secret-keys");
         utf8Output = true;
         readText   = true;
         break;
     }
     case GpgOp::PublicKeys:
     {
         args += QStringLiteral("--fixed-list-mode");
         args += QStringLiteral("--with-colons");
         args += QStringLiteral("--with-fingerprint");
         args += QStringLiteral("--with-fingerprint");
         args += QStringLiteral("--list-public-keys");
         utf8Output = true;
         readText   = true;
         break;
     }
     case GpgOp::Encrypt:
     {
         args += QStringLiteral("--encrypt");
 
         // recipients
         for (QStringList::ConstIterator it = input.recip_ids.constBegin(); it != input.recip_ids.constEnd(); ++it) {
             args += QStringLiteral("--recipient");
             args += QStringLiteral("0x") + *it;
         }
         extra         = true;
         collectOutput = false;
         allowInput    = true;
         if (input.opt_ascii)
             readText = true;
         break;
     }
     case GpgOp::Decrypt:
     {
         args += QStringLiteral("--decrypt");
         extra         = true;
         collectOutput = false;
         allowInput    = true;
         if (input.opt_ascii)
             writeText = true;
         break;
     }
     case GpgOp::Sign:
     {
         args += QStringLiteral("--default-key");
         args += QStringLiteral("0x") + input.signer_id;
         args += QStringLiteral("--sign");
         extra         = true;
         collectOutput = false;
         allowInput    = true;
         if (input.opt_ascii)
             readText = true;
         signing = true;
         break;
     }
     case GpgOp::SignAndEncrypt:
     {
         args += QStringLiteral("--default-key");
         args += QStringLiteral("0x") + input.signer_id;
         args += QStringLiteral("--sign");
         args += QStringLiteral("--encrypt");
 
         // recipients
         for (QStringList::ConstIterator it = input.recip_ids.constBegin(); it != input.recip_ids.constEnd(); ++it) {
             args += QStringLiteral("--recipient");
             args += QStringLiteral("0x") + *it;
         }
         extra         = true;
         collectOutput = false;
         allowInput    = true;
         if (input.opt_ascii)
             readText = true;
         signing = true;
         break;
     }
     case GpgOp::SignClearsign:
     {
         args += QStringLiteral("--default-key");
         args += QStringLiteral("0x") + input.signer_id;
         args += QStringLiteral("--clearsign");
         extra         = true;
         collectOutput = false;
         allowInput    = true;
         if (input.opt_ascii)
             readText = true;
         signing = true;
         break;
     }
     case GpgOp::SignDetached:
     {
         args += QStringLiteral("--default-key");
         args += QStringLiteral("0x") + input.signer_id;
         args += QStringLiteral("--detach-sign");
         extra         = true;
         collectOutput = false;
         allowInput    = true;
         if (input.opt_ascii)
             readText = true;
         signing = true;
         break;
     }
     case GpgOp::Verify:
     {
         args += QStringLiteral("--verify");
         args += QStringLiteral("-"); // krazy:exclude=doublequote_chars
         extra      = true;
         allowInput = true;
         if (input.opt_ascii)
             writeText = true;
         break;
     }
     case GpgOp::VerifyDetached:
     {
         args += QStringLiteral("--verify");
         args += QStringLiteral("-"); // krazy:exclude=doublequote_chars
         args += QStringLiteral("-&?");
         extra      = true;
         allowInput = true;
         useAux     = true;
         break;
     }
     case GpgOp::Import:
     {
         args += QStringLiteral("--import");
         readText = true;
         if (input.opt_ascii)
             writeText = true;
         break;
     }
     case GpgOp::Export:
     {
         args += QStringLiteral("--export");
         args += QStringLiteral("0x") + input.export_key_id;
         collectOutput = false;
         if (input.opt_ascii)
             readText = true;
         break;
     }
     case GpgOp::DeleteKey:
     {
         args += QStringLiteral("--batch");
         args += QStringLiteral("--delete-key");
         args += QStringLiteral("0x") + input.delete_key_fingerprint;
         break;
     }
     }
 
 #ifdef GPG_PROFILE
     timer.start();
     printf("<< launch >>\n");
 #endif
     proc.start(input.bin, args, extra ? GPGProc::ExtendedMode : GPGProc::NormalMode);
 
     // detached sig
     if (input.op == GpgOp::VerifyDetached) {
         QByteArray a = input.sig;
         if (input.opt_ascii) {
             LineConverter conv;
             conv.setup(LineConverter::Write);
             a = conv.process(a);
         }
         proc.writeStdin(a);
         proc.closeStdin();
     }
 
     // import
     if (input.op == GpgOp::Import) {
         QByteArray a = input.inkey;
         if (writeText) {
             LineConverter conv;
             conv.setup(LineConverter::Write);
             a = conv.process(a);
         }
         proc.writeStdin(a);
         proc.closeStdin();
     }
 }
 
 #ifdef QPIPE_SECURE
 void GpgAction::submitPassphrase(const QCA::SecureArray &a)
 #else
 void GpgAction::submitPassphrase(const QByteArray &a)
 #endif
 {
     if (!need_submitPassphrase)
         return;
 
     need_submitPassphrase = false;
 
 #ifdef QPIPE_SECURE
     QCA::SecureArray b;
 #else
     QByteArray b;
 #endif
     // filter out newlines, since that's the delimiter used
     // to indicate a submitted passphrase
     b.resize(a.size());
     int at = 0;
     for (int n = 0; n < a.size(); ++n) {
         if (a[n] != '\n')
             b[at++] = a[n];
     }
     b.resize(at);
 
     // append newline
     b.resize(b.size() + 1);
     b[b.size() - 1] = '\n';
     proc.writeCommand(b);
 }
 
 QByteArray GpgAction::read()
 {
     if (collectOutput)
         return QByteArray();
 
     QByteArray a = proc.readStdout();
     if (readText)
         a = readConv.update(a);
     if (!proc.isActive())
         a += readConv.final();
     return a;
 }
 
 void GpgAction::write(const QByteArray &in)
 {
     if (!allowInput)
         return;
 
     QByteArray a = in;
     if (writeText)
         a = writeConv.update(in);
 
     if (useAux)
         proc.writeAux(a);
     else
         proc.writeStdin(a);
 }
 
 void GpgAction::endWrite()
 {
     if (!allowInput)
         return;
 
     if (useAux)
         proc.closeAux();
     else
         proc.closeStdin();
 }
 
 void GpgAction::cardOkay()
 {
     if (need_cardOkay) {
         need_cardOkay = false;
         submitCommand("\n");
     }
 }
 
 QString GpgAction::readDiagnosticText()
 {
     QString s      = diagnosticText;
     diagnosticText = QString();
     return s;
 }
 
 void GpgAction::submitCommand(const QByteArray &a)
 {
     proc.writeCommand(a);
 }
 
 // since str is taken as a value, it is ok to use the same variable for 'rest'
 QString GpgAction::nextArg(QString str, QString *rest)
 {
     int n = str.indexOf(QLatin1Char(' '));
     if (n == -1) {
         if (rest)
             *rest = QString();
         return str;
     } else {
         if (rest)
             *rest = str.mid(n + 1);
         return str.mid(0, n);
     }
 }
 
 void GpgAction::processStatusLine(const QString &line)
 {
     appendDiagnosticText(QStringLiteral("{") + line + QStringLiteral("}"));
     ensureDTextEmit();
 
     if (!proc.isActive())
         return;
 
     QString s, rest;
     s = nextArg(line, &rest);
 
     if (s == QLatin1String("NODATA")) {
         // only set this if it'll make it better
         if (curError == GpgOp::ErrorUnknown)
             curError = GpgOp::ErrorFormat;
     } else if (s == QLatin1String("UNEXPECTED")) {
         if (curError == GpgOp::ErrorUnknown)
             curError = GpgOp::ErrorFormat;
     } else if (s == QLatin1String("EXPKEYSIG")) {
         curError = GpgOp::ErrorSignerExpired;
     } else if (s == QLatin1String("REVKEYSIG")) {
         curError = GpgOp::ErrorSignerRevoked;
     } else if (s == QLatin1String("EXPSIG")) {
         curError = GpgOp::ErrorSignatureExpired;
     } else if (s == QLatin1String("INV_RECP")) {
         const int r = nextArg(rest).toInt();
 
         if (curError == GpgOp::ErrorUnknown) {
             if (r == 10)
                 curError = GpgOp::ErrorEncryptUntrusted;
             else if (r == 4)
                 curError = GpgOp::ErrorEncryptRevoked;
             else if (r == 5)
                 curError = GpgOp::ErrorEncryptExpired;
             else
                 // due to GnuPG bug #1650
                 // <https://bugs.g10code.com/gnupg/issue1650>
                 // encrypting to expired and revoked keys will
                 // not specify any reason for failing,
                 // defaulting to this
                 curError = GpgOp::ErrorEncryptInvalid;
         }
     } else if (s == QLatin1String("NO_SECKEY")) {
         output.encryptedToId = nextArg(rest);
 
         if (curError == GpgOp::ErrorUnknown)
             curError = GpgOp::ErrorDecryptNoKey;
     } else if (s == QLatin1String("DECRYPTION_OKAY")) {
         decryptGood = true;
 
         // message could be encrypted with several keys
         if (curError == GpgOp::ErrorDecryptNoKey)
             curError = GpgOp::ErrorUnknown;
     } else if (s == QLatin1String("SIG_CREATED")) {
         signGood = true;
     } else if (s == QLatin1String("USERID_HINT")) {
         passphraseKeyId = nextArg(rest);
     } else if (s == QLatin1String("GET_HIDDEN")) {
         QString arg = nextArg(rest);
         if (arg == QLatin1String("passphrase.enter") || arg == QLatin1String("passphrase.pin.ask")) {
             need_submitPassphrase = true;
 
             // for signal-safety, emit later
             QMetaObject::invokeMethod(this, "needPassphrase", Qt::QueuedConnection, Q_ARG(QString, passphraseKeyId));
         }
     } else if (s == QLatin1String("GET_LINE")) {
         QString arg = nextArg(rest);
         if (arg == QLatin1String("cardctrl.insert_card.okay")) {
             need_cardOkay = true;
 
             QMetaObject::invokeMethod(this, "needCard", Qt::QueuedConnection);
         }
     } else if (s == QLatin1String("GET_BOOL")) {
         QString arg = nextArg(rest);
         if (arg == QLatin1String("untrusted_key.override"))
             submitCommand("no\n");
     } else if (s == QLatin1String("GOOD_PASSPHRASE")) {
         badPassphrase = false;
     } else if (s == QLatin1String("BAD_PASSPHRASE")) {
         badPassphrase = true;
     } else if (s == QLatin1String("GOODSIG")) {
         output.wasSigned    = true;
         output.signerId     = nextArg(rest);
         output.verifyResult = GpgOp::VerifyGood;
     } else if (s == QLatin1String("BADSIG")) {
         output.wasSigned    = true;
         output.signerId     = nextArg(rest);
         output.verifyResult = GpgOp::VerifyBad;
     } else if (s == QLatin1String("ERRSIG")) {
         output.wasSigned       = true;
         const QStringList list = rest.split(QLatin1Char(' '), Qt::SkipEmptyParts);
         output.signerId        = list[0];
         output.timestamp       = getTimestamp(list[4]);
         output.verifyResult    = GpgOp::VerifyNoKey;
     } else if (s == QLatin1String("VALIDSIG")) {
         const QStringList list = rest.split(QLatin1Char(' '), Qt::SkipEmptyParts);
         output.timestamp       = getTimestamp(list[2]);
     }
 }
 
 void GpgAction::processResult(int code)
 {
 #ifdef GPG_PROFILE
     printf("<< launch: %d >>\n", timer.elapsed());
 #endif
 
     // put stdout and stderr into QStrings
 
     QString outstr;
     QString errstr;
 
 #ifdef Q_OS_WIN
     if (!utf8Output) {
         outstr = QString::fromLocal8Bit(buf_stdout);
         errstr = QString::fromLocal8Bit(buf_stderr);
     } else {
 #endif
         outstr = QString::fromUtf8(buf_stdout);
         errstr = QString::fromUtf8(buf_stderr);
 #ifdef Q_OS_WIN
     }
 #endif
 
     if (collectOutput)
         appendDiagnosticText(QStringLiteral("stdout: [%1]").arg(outstr));
     appendDiagnosticText(QStringLiteral("stderr: [%1]").arg(errstr));
     ensureDTextEmit();
 
     if (badPassphrase) {
         output.errorCode = GpgOp::ErrorPassphrase;
     } else if (curError != GpgOp::ErrorUnknown) {
         output.errorCode = curError;
     } else if (code == 0) {
         if (input.op == GpgOp::Check) {
             const QStringList strList = outstr.split(QStringLiteral("\n"));
             foreach (const QString &str, strList) {
                 if (!str.startsWith(QLatin1String("Home: ")))
                     continue;
 
                 output.homeDir = str.section(QLatin1Char(' '), 1);
                 break;
             }
             output.success = true;
         } else if (input.op == GpgOp::SecretKeyringFile || input.op == GpgOp::PublicKeyringFile) {
             if (findKeyringFilename(outstr, &output.keyringFile))
                 output.success = true;
         } else if (input.op == GpgOp::SecretKeys || input.op == GpgOp::PublicKeys) {
             if (stringToKeyList(outstr, &output.keys, &output.keyringFile))
                 output.success = true;
         } else
             output.success = true;
     } else {
         // decrypt and sign success based on status only.
         // this is mainly because gpg uses fatal return
         // values if there is trouble with gpg-agent, even
         // though the operation otherwise works.
 
         if (input.op == GpgOp::Decrypt && decryptGood)
             output.success = true;
         if (signing && signGood)
             output.success = true;
 
         // gpg will indicate failure for bad sigs, but we don't
         // consider this to be operation failure.
 
         bool signedMakesItGood = false;
         if (input.op == GpgOp::Verify || input.op == GpgOp::VerifyDetached)
             signedMakesItGood = true;
 
         if (signedMakesItGood && output.wasSigned)
             output.success = true;
     }
 
     emit finished();
 }
 
 void GpgAction::ensureDTextEmit()
 {
     if (!dtextTimer.isActive())
         dtextTimer.start();
 }
 
 void GpgAction::t_dtext()
 {
     emit readyReadDiagnosticText();
 }
 
 void GpgAction::proc_error(gpgQCAPlugin::GPGProc::Error e)
 {
     QString str;
     if (e == GPGProc::FailedToStart)
         str = QStringLiteral("FailedToStart");
     else if (e == GPGProc::UnexpectedExit)
         str = QStringLiteral("UnexpectedExit");
     else if (e == GPGProc::ErrorWrite)
         str = QStringLiteral("ErrorWrite");
 
     appendDiagnosticText(QStringLiteral("GPG Process Error: %1").arg(str));
     ensureDTextEmit();
 
     output.errorCode = GpgOp::ErrorProcess;
     emit finished();
 }
 
 void GpgAction::proc_finished(int exitCode)
 {
     appendDiagnosticText(QStringLiteral("GPG Process Finished: exitStatus=%1").arg(exitCode));
     ensureDTextEmit();
 
     processResult(exitCode);
 }
 
 void GpgAction::proc_readyReadStdout()
 {
     if (collectOutput) {
         QByteArray a = proc.readStdout();
         if (readText)
             a = readConv.update(a);
         buf_stdout.append(a);
     } else
         emit readyRead();
 }
 
 void GpgAction::proc_readyReadStderr()
 {
     buf_stderr.append(proc.readStderr());
 }
 
 void GpgAction::proc_readyReadStatusLines()
 {
     const QStringList lines = proc.readStatusLines();
     for (int n = 0; n < lines.count(); ++n)
         processStatusLine(lines[n]);
 }
 
 void GpgAction::proc_bytesWrittenStdin(int bytes)
 {
     if (!useAux) {
         int  actual = writeConv.writtenToActual(bytes);
         emit bytesWritten(actual);
     }
 }
 
 void GpgAction::proc_bytesWrittenAux(int bytes)
 {
     if (useAux) {
         int  actual = writeConv.writtenToActual(bytes);
         emit bytesWritten(actual);
     }
 }
 
 void GpgAction::proc_bytesWrittenCommand(int)
 {
     // don't care about this
 }
 
 void GpgAction::proc_debug(const QString &str)
 {
     appendDiagnosticText(QStringLiteral("GPGProc: ") + str);
     ensureDTextEmit();
 }
 
 void GpgAction::appendDiagnosticText(const QString &line)
 {
 #ifdef GPGOP_DEBUG
     printf("%s\n", qPrintable(line));
 #endif
     diagnosticText += line;
 }
 
 } // end namespace gpgQCAPlugin