qprocess_p.h - mozsearch

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2016 The Qt Company Ltd.

// Copyright (C) 2016 Intel Corporation.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:critical reason:execute-external-code

#ifndef QPROCESS_P_H

#define QPROCESS_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "QtCore/qprocess.h"

#include "QtCore/qstringlist.h"

#include "QtCore/qhash.h"

#include "QtCore/qmap.h"

#include "QtCore/qshareddata.h"

#include "QtCore/qdeadlinetimer.h"

#include "private/qiodevice_p.h"

QT_REQUIRE_CONFIG(processenvironment);

#ifdef Q_OS_UNIX

#include <QtCore/private/qorderedmutexlocker_p.h>

#endif

#ifdef Q_OS_WIN

#include "QtCore/qt_windows.h"

typedef HANDLE Q_PIPE;

#define INVALID_Q_PIPE INVALID_HANDLE_VALUE

#else

typedef int Q_PIPE;

#define INVALID_Q_PIPE -1

#endif

QT_BEGIN_NAMESPACE

class QSocketNotifier;

class QWindowsPipeReader;

class QWindowsPipeWriter;

class QWinEventNotifier;

#ifdef Q_OS_WIN

class QProcEnvKey : public QString

public:

    QProcEnvKey() {}

    explicit QProcEnvKey(const QString &other) : QString(other) {}

    QProcEnvKey(const QProcEnvKey &other) : QString(other) {}

    bool operator==(const QProcEnvKey &other) const { return !compare(other, Qt::CaseInsensitive); }

};

inline bool operator<(const QProcEnvKey &a, const QProcEnvKey &b)

    // On windows use case-insensitive ordering because that is how Windows needs the environment

    // block sorted (https://msdn.microsoft.com/en-us/library/windows/desktop/ms682009(v=vs.85).aspx)

    return a.compare(b, Qt::CaseInsensitive) < 0;

Q_DECLARE_TYPEINFO(QProcEnvKey, Q_RELOCATABLE_TYPE);

typedef QString QProcEnvValue;

#else

using QProcEnvKey = QByteArray;

class QProcEnvValue

public:

    QProcEnvValue() = default;

    explicit QProcEnvValue(const QString &value) : stringValue(value) {}

    explicit QProcEnvValue(const QByteArray &value) : byteValue(value) {}

    bool operator==(const QProcEnvValue &other) const

        return byteValue.isEmpty() && other.byteValue.isEmpty()

                ? stringValue == other.stringValue

                : bytes() == other.bytes();

    QByteArray bytes() const

        if (byteValue.isEmpty() && !stringValue.isEmpty())

            byteValue = stringValue.toLocal8Bit();

        return byteValue;

    QString string() const

        if (stringValue.isEmpty() && !byteValue.isEmpty())

            stringValue = QString::fromLocal8Bit(byteValue);

        return stringValue;

    mutable QByteArray byteValue;

    mutable QString stringValue;

};

Q_DECLARE_TYPEINFO(QProcEnvValue, Q_RELOCATABLE_TYPE);

#endif

class QProcessEnvironmentPrivate: public QSharedData

public:

    typedef QProcEnvKey Key;

    typedef QProcEnvValue Value;

#ifdef Q_OS_WIN

    inline Key prepareName(const QString &name) const { return Key(name); }

    inline QString nameToString(const Key &name) const { return name; }

    inline Value prepareValue(const QString &value) const { return value; }

    inline QString valueToString(const Value &value) const { return value; }

    struct MutexLocker {

        MutexLocker(const QProcessEnvironmentPrivate *) {}

};

    struct OrderedMutexLocker {

        OrderedMutexLocker(const QProcessEnvironmentPrivate *,

                           const QProcessEnvironmentPrivate *) {}

};

#else

    inline Key prepareName(const QString &name) const

        Key &ent = nameMap[name];

        if (ent.isEmpty())

            ent = name.toLocal8Bit();

        return ent;

    inline QString nameToString(const Key &name) const

        const QString sname = QString::fromLocal8Bit(name);

        nameMap[sname] = name;

        return sname;

    inline Value prepareValue(const QString &value) const { return Value(value); }

    inline QString valueToString(const Value &value) const { return value.string(); }

    struct MutexLocker : public QMutexLocker<QMutex>

        MutexLocker(const QProcessEnvironmentPrivate *d) : QMutexLocker(&d->mutex) {}

};

    struct OrderedMutexLocker : public QOrderedMutexLocker

        OrderedMutexLocker(const QProcessEnvironmentPrivate *d1,

                           const QProcessEnvironmentPrivate *d2) :

            QOrderedMutexLocker(&d1->mutex, &d2->mutex)

{}

};

    QProcessEnvironmentPrivate() : QSharedData() {}

    QProcessEnvironmentPrivate(const QProcessEnvironmentPrivate &other) :

        QSharedData()

        // This being locked ensures that the functions that only assign

        // d pointers don't need explicit locking.

        // We don't need to lock our own mutex, as this object is new and

        // consequently not shared. For the same reason, non-const methods

        // do not need a lock, as they detach objects (however, we need to

        // ensure that they really detach before using prepareName()).

        MutexLocker locker(&other);

        vars = other.vars;

        nameMap = other.nameMap;

        // We need to detach our members, so that our mutex can protect them.

        // As we are being detached, they likely would be detached a moment later anyway.

        vars.detach();

        nameMap.detach();

#endif

    using Map = QMap<Key, Value>;

    Map vars;

#ifdef Q_OS_UNIX

    typedef QHash<QString, Key> NameHash;

    mutable NameHash nameMap;

    mutable QMutex mutex;

#endif

    static QProcessEnvironment fromList(const QStringList &list);

    QStringList toList() const;

    QStringList keys() const;

    void insert(const QProcessEnvironmentPrivate &other);

};

template<> Q_INLINE_TEMPLATE void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()

    if (d && d->ref.loadRelaxed() == 1)

        return;

    QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)

                                     : new QProcessEnvironmentPrivate);

    x->ref.ref();

    if (d && !d->ref.deref())

        delete d.get();

    d.reset(x);

#if QT_CONFIG(process)

class QProcessPrivate : public QIODevicePrivate

public:

    Q_DECLARE_PUBLIC(QProcess)

    struct Channel {

        enum ProcessChannelType : char {

            Normal = 0,

            PipeSource = 1,

            PipeSink = 2,

            Redirect = 3

};

        void clear();

        Channel &operator=(const QString &fileName)

            clear();

            file = fileName;

            type = fileName.isEmpty() ? Normal : Redirect;

            return *this;

        void pipeTo(QProcessPrivate *other)

            clear();

            process = other;

            type = PipeSource;

        void pipeFrom(QProcessPrivate *other)

            clear();

            process = other;

            type = PipeSink;

        QString file;

        QProcessPrivate *process = nullptr;

#ifdef Q_OS_UNIX

        QSocketNotifier *notifier = nullptr;

#else

        union {

            QWindowsPipeReader *reader = nullptr;

            QWindowsPipeWriter *writer;

};

#endif

        Q_PIPE pipe[2] = {INVALID_Q_PIPE, INVALID_Q_PIPE};

        ProcessChannelType type = Normal;

        bool closed = false;

        bool append = false;

};

    QProcessPrivate();

    virtual ~QProcessPrivate();

    // private slots

    bool _q_canReadStandardOutput();

    bool _q_canReadStandardError();

#ifdef Q_OS_WIN

    qint64 pipeWriterBytesToWrite() const;

    void _q_bytesWritten(qint64 bytes);

    void _q_writeFailed();

#else

    bool _q_canWrite();

    bool writeToStdin();

#endif

    bool _q_startupNotification();

    void _q_processDied();

    Channel stdinChannel;

    Channel stdoutChannel;

    Channel stderrChannel;

    bool openChannels();

    bool openChannelsForDetached();

    bool openChannel(Channel &channel);

    void closeChannel(Channel *channel);

    void closeWriteChannel();

    void closeChannels();

    bool tryReadFromChannel(Channel *channel); // obviously, only stdout and stderr

    QString program;

    QStringList arguments;

    QString workingDirectory;

    QProcessEnvironment environment = QProcessEnvironment::InheritFromParent;

#if defined(Q_OS_WIN)

    QString nativeArguments;

    QProcess::CreateProcessArgumentModifier modifyCreateProcessArgs;

    QWinEventNotifier *processFinishedNotifier = nullptr;

    Q_PROCESS_INFORMATION *pid = nullptr;

#else

    struct UnixExtras {

        std::function<void(void)> childProcessModifier;

        QProcess::UnixProcessParameters processParameters;

};

    std::unique_ptr<UnixExtras> unixExtras;

    QSocketNotifier *stateNotifier = nullptr;

    Q_PIPE childStartedPipe[2] = {INVALID_Q_PIPE, INVALID_Q_PIPE};

    pid_t pid = 0;

    int forkfd = -1;

#endif

    int exitCode = 0;

    quint8 processState = QProcess::NotRunning;

    quint8 exitStatus = QProcess::NormalExit;

    quint8 processError = QProcess::UnknownError;

    quint8 processChannelMode = QProcess::SeparateChannels;

    quint8 inputChannelMode = QProcess::ManagedInputChannel;

    bool emittedReadyRead = false;

    bool emittedBytesWritten = false;

    void start(QIODevice::OpenMode mode);

    void startProcess();

#if defined(Q_OS_UNIX)

    void commitChannels() const;

#endif

    bool processStarted(QString *errorMessage = nullptr);

    void processFinished();

    void terminateProcess();

    void killProcess();

#ifdef Q_OS_UNIX

    void waitForDeadChild();

#else

    void findExitCode();

#endif

#ifdef Q_OS_WIN

    STARTUPINFOW createStartupInfo();

    bool callCreateProcess(QProcess::CreateProcessArguments *cpargs);

    bool drainOutputPipes();

#endif

    bool startDetached(qint64 *pPid);

    bool waitForStarted(const QDeadlineTimer &deadline);

    bool waitForReadyRead(const QDeadlineTimer &deadline);

    bool waitForBytesWritten(const QDeadlineTimer &deadline);

    bool waitForFinished(const QDeadlineTimer &deadline);

    qint64 bytesAvailableInChannel(const Channel *channel) const;

    qint64 readFromChannel(const Channel *channel, char *data, qint64 maxlen);

    void destroyPipe(Q_PIPE pipe[2]);

    void cleanup();

    void setError(QProcess::ProcessError error, const QString &description = QString());

    void setErrorAndEmit(QProcess::ProcessError error, const QString &description = QString());

    const QProcessEnvironmentPrivate *environmentPrivate() const

    { return environment.d.constData(); }

};

#endif // QT_CONFIG(process)

QT_END_NAMESPACE

#endif // QPROCESS_P_H