• Skip to content
• Skip to link menu

KDE 4.4 API Reference

• KDE API Reference
• KDE Support

• Sitemap
• Contact Us

 

qca

gpgproc.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2003-2007  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 Street, Fifth Floor, Boston, MA  02110-1301, USA
 *
 */

#include "gpgproc.h"

#include "sprocess.h"

#ifdef Q_OS_MAC
#define QT_PIPE_HACK
#endif

#define QPROC_SIGNAL_RELAY

using namespace QCA;

namespace gpgQCAPlugin {

void releaseAndDeleteLater(QObject *owner, QObject *obj)
{
    obj->disconnect(owner);
    obj->setParent(0);
    obj->deleteLater();
}

//----------------------------------------------------------------------------
// SafeTimer
//----------------------------------------------------------------------------
SafeTimer::SafeTimer(QObject *parent) :
    QObject(parent)
{
    timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), SIGNAL(timeout()));
}

SafeTimer::~SafeTimer()
{
    releaseAndDeleteLater(this, timer);
}

int SafeTimer::interval() const
{
    return timer->interval();
}

bool SafeTimer::isActive() const
{
    return timer->isActive();
}

bool SafeTimer::isSingleShot() const
{
    return timer->isSingleShot();
}

void SafeTimer::setInterval(int msec)
{
    timer->setInterval(msec);
}

void SafeTimer::setSingleShot(bool singleShot)
{
    timer->setSingleShot(singleShot);
}

int SafeTimer::timerId() const
{
    return timer->timerId();
}

void SafeTimer::start(int msec)
{
    timer->start(msec);
}

void SafeTimer::start()
{
    timer->start();
}

void SafeTimer::stop()
{
    timer->stop();
}

//----------------------------------------------------------------------------
// QProcessSignalRelay
//----------------------------------------------------------------------------
class QProcessSignalRelay : public QObject
{
    Q_OBJECT
public:
    QProcessSignalRelay(QProcess *proc, QObject *parent = 0)
    :QObject(parent)
    {
        qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");
        connect(proc, SIGNAL(started()), SLOT(proc_started()), Qt::QueuedConnection);
        connect(proc, SIGNAL(readyReadStandardOutput()), SLOT(proc_readyReadStandardOutput()), Qt::QueuedConnection);
        connect(proc, SIGNAL(readyReadStandardError()), SLOT(proc_readyReadStandardError()), Qt::QueuedConnection);
        connect(proc, SIGNAL(bytesWritten(qint64)), SLOT(proc_bytesWritten(qint64)), Qt::QueuedConnection);
        connect(proc, SIGNAL(finished(int)), SLOT(proc_finished(int)), Qt::QueuedConnection);
        connect(proc, SIGNAL(error(QProcess::ProcessError)), SLOT(proc_error(QProcess::ProcessError)), Qt::QueuedConnection);
    }

signals:
    void started();
    void readyReadStandardOutput();
    void readyReadStandardError();
    void bytesWritten(qint64);
    void finished(int);
    void error(QProcess::ProcessError);

public slots:
    void proc_started()
    {
        emit started();
    }

    void proc_readyReadStandardOutput()
    {
        emit readyReadStandardOutput();
    }

    void proc_readyReadStandardError()
    {
        emit readyReadStandardError();
    }

    void proc_bytesWritten(qint64 x)
    {
        emit bytesWritten(x);
    }

    void proc_finished(int x)
    {
        emit finished(x);
    }

    void proc_error(QProcess::ProcessError x)
    {
        emit error(x);
    }
};

//----------------------------------------------------------------------------
// GPGProc
//----------------------------------------------------------------------------
enum ResetMode
{
    ResetSession        = 0,
    ResetSessionAndData = 1,
    ResetAll            = 2
};

class GPGProc::Private : public QObject
{
    Q_OBJECT
public:
    GPGProc *q;
    QString bin;
    QStringList args;
    GPGProc::Mode mode;
    SProcess *proc;
#ifdef QPROC_SIGNAL_RELAY
    QProcessSignalRelay *proc_relay;
#endif
    QPipe pipeAux, pipeCommand, pipeStatus;
    QByteArray statusBuf;
    QStringList statusLines;
    GPGProc::Error error;
    int exitCode;
    SafeTimer startTrigger, doneTrigger;

    QByteArray pre_stdin, pre_aux;
#ifdef QPIPE_SECURE
    SecureArray pre_command;
#else
    QByteArray pre_command;
#endif
    bool pre_stdin_close, pre_aux_close, pre_command_close;

    bool need_status, fin_process, fin_process_success, fin_status;
    QByteArray leftover_stdout;
    QByteArray leftover_stderr;

    Private(GPGProc *_q) : QObject(_q), q(_q), pipeAux(this), pipeCommand(this), pipeStatus(this), startTrigger(this), doneTrigger(this)
    {
        qRegisterMetaType<gpgQCAPlugin::GPGProc::Error>("gpgQCAPlugin::GPGProc::Error");

        proc = 0;
#ifdef QPROC_SIGNAL_RELAY
        proc_relay = 0;
#endif
        startTrigger.setSingleShot(true);
        doneTrigger.setSingleShot(true);

        connect(&pipeAux.writeEnd(), SIGNAL(bytesWritten(int)), SLOT(aux_written(int)));
        connect(&pipeAux.writeEnd(), SIGNAL(error(QCA::QPipeEnd::Error)), SLOT(aux_error(QCA::QPipeEnd::Error)));
        connect(&pipeCommand.writeEnd(), SIGNAL(bytesWritten(int)), SLOT(command_written(int)));
        connect(&pipeCommand.writeEnd(), SIGNAL(error(QCA::QPipeEnd::Error)), SLOT(command_error(QCA::QPipeEnd::Error)));
        connect(&pipeStatus.readEnd(), SIGNAL(readyRead()), SLOT(status_read()));
        connect(&pipeStatus.readEnd(), SIGNAL(error(QCA::QPipeEnd::Error)), SLOT(status_error(QCA::QPipeEnd::Error)));
        connect(&startTrigger, SIGNAL(timeout()), SLOT(doStart()));
        connect(&doneTrigger, SIGNAL(timeout()), SLOT(doTryDone()));

        reset(ResetSessionAndData);
    }

    ~Private()
    {
        reset(ResetSession);
    }

    void closePipes()
    {
#ifdef QT_PIPE_HACK
        pipeAux.readEnd().reset();
        pipeCommand.readEnd().reset();
        pipeStatus.writeEnd().reset();
#endif

        pipeAux.reset();
        pipeCommand.reset();
        pipeStatus.reset();
    }

    void reset(ResetMode mode)
    {
#ifndef QT_PIPE_HACK
        closePipes();
#endif

        if(proc)
        {
            proc->disconnect(this);
            if(proc->state() != QProcess::NotRunning)
                proc->terminate();
            proc->setParent(0);
#ifdef QPROC_SIGNAL_RELAY
            releaseAndDeleteLater(this, proc_relay);
            proc_relay = 0;
            delete proc; // should be safe to do thanks to relay
#else
            proc->deleteLater();
#endif
            proc = 0;
        }

#ifdef QT_PIPE_HACK
        closePipes();
#endif

        startTrigger.stop();
        doneTrigger.stop();

        pre_stdin.clear();
        pre_aux.clear();
        pre_command.clear();
        pre_stdin_close = false;
        pre_aux_close = false;
        pre_command_close = false;

        need_status = false;
        fin_process = false;
        fin_status = false;

        if(mode >= ResetSessionAndData)
        {
            statusBuf.clear();
            statusLines.clear();
            leftover_stdout.clear();
            leftover_stderr.clear();
            error = GPGProc::FailedToStart;
            exitCode = -1;
        }
    }

    bool setupPipes(bool makeAux)
    {
        if(makeAux && !pipeAux.create())
        {
            closePipes();
            emit q->debug("Error creating pipeAux");
            return false;
        }

#ifdef QPIPE_SECURE
        if(!pipeCommand.create(true)) // secure
#else
        if(!pipeCommand.create())
#endif
        {
            closePipes();
            emit q->debug("Error creating pipeCommand");
            return false;
        }

        if(!pipeStatus.create())
        {
            closePipes();
            emit q->debug("Error creating pipeStatus");
            return false;
        }

        return true;
    }

    void setupArguments()
    {
        QStringList fullargs;
        fullargs += "--no-tty";

        if(mode == ExtendedMode)
        {
            fullargs += "--enable-special-filenames";

            fullargs += "--status-fd";
            fullargs += QString::number(pipeStatus.writeEnd().idAsInt());

            fullargs += "--command-fd";
            fullargs += QString::number(pipeCommand.readEnd().idAsInt());
        }

        for(int n = 0; n < args.count(); ++n)
        {
            QString a = args[n];
            if(mode == ExtendedMode && a == "-&?")
                fullargs += QString("-&") + QString::number(pipeAux.readEnd().idAsInt());
            else
                fullargs += a;
        }

        QString fullcmd = fullargs.join(" ");
        emit q->debug(QString("Running: [") + bin + ' ' + fullcmd + ']');

        args = fullargs;
    }

public slots:
    void doStart()
    {
#ifdef Q_OS_WIN
        // Note: for unix, inheritability is set in SProcess
        if(pipeAux.readEnd().isValid())
            pipeAux.readEnd().setInheritable(true);
        if(pipeCommand.readEnd().isValid())
            pipeCommand.readEnd().setInheritable(true);
        if(pipeStatus.writeEnd().isValid())
            pipeStatus.writeEnd().setInheritable(true);
#endif

        setupArguments();

        proc->start(bin, args);

        // FIXME: From reading the source to Qt on both windows
        //   and unix platforms, we know that fork/CreateProcess
        //   are called in start.  However this is not guaranteed
        //   from an API perspective.  We should probably call
        //   QProcess::waitForStarted() to synchronously ensure
        //   fork/CreateProcess are called before closing these
        //   pipes.
        pipeAux.readEnd().close();
        pipeCommand.readEnd().close();
        pipeStatus.writeEnd().close();
    }

    void aux_written(int x)
    {
        emit q->bytesWrittenAux(x);
    }

    void aux_error(QCA::QPipeEnd::Error)
    {
        emit q->debug("Aux: Pipe error");
        reset(ResetSession);
        emit q->error(GPGProc::ErrorWrite);
    }

    void command_written(int x)
    {
        emit q->bytesWrittenCommand(x);
    }

    void command_error(QCA::QPipeEnd::Error)
    {
        emit q->debug("Command: Pipe error");
        reset(ResetSession);
        emit q->error(GPGProc::ErrorWrite);
    }

    void status_read()
    {
        if(readAndProcessStatusData())
            emit q->readyReadStatusLines();
    }

    void status_error(QCA::QPipeEnd::Error e)
    {
        if(e == QPipeEnd::ErrorEOF)
            emit q->debug("Status: Closed (EOF)");
        else
            emit q->debug("Status: Closed (gone)");

        fin_status = true;
        doTryDone();
    }

    void proc_started()
    {
        emit q->debug("Process started");

        // Note: we don't close these here anymore.  instead we
        //   do it just after calling proc->start().
        // close these, we don't need them
        /*pipeAux.readEnd().close();
        pipeCommand.readEnd().close();
        pipeStatus.writeEnd().close();*/

        // do the pre* stuff
        if(!pre_stdin.isEmpty())
        {
            proc->write(pre_stdin);
            pre_stdin.clear();
        }
        if(!pre_aux.isEmpty())
        {
            pipeAux.writeEnd().write(pre_aux);
            pre_aux.clear();
        }
        if(!pre_command.isEmpty())
        {
#ifdef QPIPE_SECURE
            pipeCommand.writeEnd().writeSecure(pre_command);
#else
            pipeCommand.writeEnd().write(pre_command);
#endif
            pre_command.clear();
        }

        if(pre_stdin_close)
            proc->closeWriteChannel();
        if(pre_aux_close)
            pipeAux.writeEnd().close();
        if(pre_command_close)
            pipeCommand.writeEnd().close();
    }

    void proc_readyReadStandardOutput()
    {
        emit q->readyReadStdout();
    }

    void proc_readyReadStandardError()
    {
        emit q->readyReadStderr();
    }

    void proc_bytesWritten(qint64 lx)
    {
        int x = (int)lx;
        emit q->bytesWrittenStdin(x);
    }

    void proc_finished(int x)
    {
        emit q->debug(QString("Process finished: %1").arg(x));
        exitCode = x;

        fin_process = true;
        fin_process_success = true;

        if(need_status && !fin_status)
        {
            pipeStatus.readEnd().finalize();
            fin_status = true;
            if(readAndProcessStatusData())
            {
                doneTrigger.start();
                emit q->readyReadStatusLines();
                return;
            }
        }

        doTryDone();
    }

    void proc_error(QProcess::ProcessError x)
    {
        QMap<int, QString> errmap;
        errmap[QProcess::FailedToStart] = "FailedToStart";
        errmap[QProcess::Crashed]       = "Crashed";
        errmap[QProcess::Timedout]      = "Timedout";
        errmap[QProcess::WriteError]    = "WriteError";
        errmap[QProcess::ReadError]     = "ReadError";
        errmap[QProcess::UnknownError]  = "UnknownError";

        emit q->debug(QString("Process error: %1").arg(errmap[x]));

        if(x == QProcess::FailedToStart)
            error = GPGProc::FailedToStart;
        else if(x == QProcess::WriteError)
            error = GPGProc::ErrorWrite;
        else
            error = GPGProc::UnexpectedExit;

        fin_process = true;
        fin_process_success = false;

#ifdef QT_PIPE_HACK
        // If the process fails to start, then the ends of the pipes
        // intended for the child process are still open.  Some Mac
        // users experience a lockup if we close our ends of the pipes
        // when the child's ends are still open.  If we ensure the
        // child's ends are closed, we prevent this lockup.  I have no
        // idea why the problem even happens or why this fix should
        // work.
        pipeAux.readEnd().reset();
        pipeCommand.readEnd().reset();
        pipeStatus.writeEnd().reset();
#endif

        if(need_status && !fin_status)
        {
            pipeStatus.readEnd().finalize();
            fin_status = true;
            if(readAndProcessStatusData())
            {
                doneTrigger.start();
                emit q->readyReadStatusLines();
                return;
            }
        }

        doTryDone();
    }

    void doTryDone()
    {
        if(!fin_process)
            return;

        if(need_status && !fin_status)
            return;

        emit q->debug("Done");

        // get leftover data
        proc->setReadChannel(QProcess::StandardOutput);
        leftover_stdout = proc->readAll();

        proc->setReadChannel(QProcess::StandardError);
        leftover_stderr = proc->readAll();

        reset(ResetSession);
        if(fin_process_success)
            emit q->finished(exitCode);
        else
            emit q->error(error);
    }

private:
    bool readAndProcessStatusData()
    {
        QByteArray buf = pipeStatus.readEnd().read();
        if(buf.isEmpty())
            return false;

        return processStatusData(buf);
    }

    // return true if there are newly parsed lines available
    bool processStatusData(const QByteArray &buf)
    {
        statusBuf.append(buf);

        // extract all lines
        QStringList list;
        while(1)
        {
            int n = statusBuf.indexOf('\n');
            if(n == -1)
                break;

            // extract the string from statusbuf
            ++n;
            char *p = (char *)statusBuf.data();
            QByteArray cs(p, n);
            int newsize = statusBuf.size() - n;
            memmove(p, p + n, newsize);
            statusBuf.resize(newsize);

            // convert to string without newline
            QString str = QString::fromUtf8(cs);
            str.truncate(str.length() - 1);

            // ensure it has a proper header
            if(str.left(9) != "[GNUPG:] ")
                continue;

            // take it off
            str = str.mid(9);

            // add to the list
            list += str;
        }

        if(list.isEmpty())
            return false;

        statusLines += list;
        return true;
    }
};

GPGProc::GPGProc(QObject *parent)
:QObject(parent)
{
    d = new Private(this);
}

GPGProc::~GPGProc()
{
    delete d;
}

void GPGProc::reset()
{
    d->reset(ResetAll);
}

bool GPGProc::isActive() const
{
    return (d->proc ? true : false);
}

void GPGProc::start(const QString &bin, const QStringList &args, Mode mode)
{
    if(isActive())
        d->reset(ResetSessionAndData);

    if(mode == ExtendedMode)
    {
        if(!d->setupPipes(args.contains("-&?")))
        {
            d->error = FailedToStart;

            // emit later
            QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection, Q_ARG(gpgQCAPlugin::GPGProc::Error, d->error));
            return;
        }

        d->need_status = true;

        emit debug("Pipe setup complete");
    }

    d->proc = new SProcess(d);

#ifdef Q_OS_UNIX
    QList<int> plist;
    if(d->pipeAux.readEnd().isValid())
        plist += d->pipeAux.readEnd().id();
    if(d->pipeCommand.readEnd().isValid())
        plist += d->pipeCommand.readEnd().id();
    if(d->pipeStatus.writeEnd().isValid())
        plist += d->pipeStatus.writeEnd().id();
    d->proc->setInheritPipeList(plist);
#endif

    // enable the pipes we want
    if(d->pipeAux.writeEnd().isValid())
        d->pipeAux.writeEnd().enable();
    if(d->pipeCommand.writeEnd().isValid())
        d->pipeCommand.writeEnd().enable();
    if(d->pipeStatus.readEnd().isValid())
        d->pipeStatus.readEnd().enable();

#ifdef QPROC_SIGNAL_RELAY
    d->proc_relay = new QProcessSignalRelay(d->proc, d);
    connect(d->proc_relay, SIGNAL(started()), d, SLOT(proc_started()));
    connect(d->proc_relay, SIGNAL(readyReadStandardOutput()), d, SLOT(proc_readyReadStandardOutput()));
    connect(d->proc_relay, SIGNAL(readyReadStandardError()), d, SLOT(proc_readyReadStandardError()));
    connect(d->proc_relay, SIGNAL(bytesWritten(qint64)), d, SLOT(proc_bytesWritten(qint64)));
    connect(d->proc_relay, SIGNAL(finished(int)), d, SLOT(proc_finished(int)));
    connect(d->proc_relay, SIGNAL(error(QProcess::ProcessError)), d, SLOT(proc_error(QProcess::ProcessError)));
#else
    connect(d->proc, SIGNAL(started()), d, SLOT(proc_started()));
    connect(d->proc, SIGNAL(readyReadStandardOutput()), d, SLOT(proc_readyReadStandardOutput()));
    connect(d->proc, SIGNAL(readyReadStandardError()), d, SLOT(proc_readyReadStandardError()));
    connect(d->proc, SIGNAL(bytesWritten(qint64)), d, SLOT(proc_bytesWritten(qint64)));
    connect(d->proc, SIGNAL(finished(int)), d, SLOT(proc_finished(int)));
    connect(d->proc, SIGNAL(error(QProcess::ProcessError)), d, SLOT(proc_error(QProcess::ProcessError)));
#endif

    d->bin = bin;
    d->args = args;
    d->mode = mode;
    d->startTrigger.start();
}

QByteArray GPGProc::readStdout()
{
    if(d->proc)
    {
        d->proc->setReadChannel(QProcess::StandardOutput);
        return d->proc->readAll();
    }
    else
    {
        QByteArray a = d->leftover_stdout;
        d->leftover_stdout.clear();
        return a;
    }
}

QByteArray GPGProc::readStderr()
{
    if(d->proc)
    {
        d->proc->setReadChannel(QProcess::StandardError);
        return d->proc->readAll();
    }
    else
    {
        QByteArray a = d->leftover_stderr;
        d->leftover_stderr.clear();
        return a;
    }
}

QStringList GPGProc::readStatusLines()
{
    QStringList out = d->statusLines;
    d->statusLines.clear();
    return out;
}

void GPGProc::writeStdin(const QByteArray &a)
{
    if(!d->proc || a.isEmpty())
        return;

    if(d->proc->state() == QProcess::Running)
        d->proc->write(a);
    else
        d->pre_stdin += a;
}

void GPGProc::writeAux(const QByteArray &a)
{
    if(!d->proc || a.isEmpty())
        return;

    if(d->proc->state() == QProcess::Running)
        d->pipeAux.writeEnd().write(a);
    else
        d->pre_aux += a;
}

#ifdef QPIPE_SECURE
void GPGProc::writeCommand(const SecureArray &a)
#else
void GPGProc::writeCommand(const QByteArray &a)
#endif
{
    if(!d->proc || a.isEmpty())
        return;

    if(d->proc->state() == QProcess::Running)
#ifdef QPIPE_SECURE
        d->pipeCommand.writeEnd().writeSecure(a);
#else
        d->pipeCommand.writeEnd().write(a);
#endif
    else
        d->pre_command += a;
}

void GPGProc::closeStdin()
{
    if(!d->proc)
        return;

    if(d->proc->state() == QProcess::Running)
        d->proc->closeWriteChannel();
    else
        d->pre_stdin_close = true;
}

void GPGProc::closeAux()
{
    if(!d->proc)
        return;

    if(d->proc->state() == QProcess::Running)
        d->pipeAux.writeEnd().close();
    else
        d->pre_aux_close = true;
}

void GPGProc::closeCommand()
{
    if(!d->proc)
        return;

    if(d->proc->state() == QProcess::Running)
        d->pipeCommand.writeEnd().close();
    else
        d->pre_command_close = true;
}

}

#include "gpgproc.moc"

qca

Skip menu "qca"

• Main Page
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

KDE Support

Skip menu "KDE Support"

• akonadi
• Decibel
• grantlee
• kdewin
• phonon
•     Backend
• polkit-qt
• qca
• qimageblitz
• soprano
• strigi
•     searchclient
•     streamanalyzer
•     streams

Generated for KDE Support by doxygen 1.5.9-20090814
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal