qprocess.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2022 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
//#define QPROCESS_DEBUG
 
#include <qdebug.h>
#include <qdir.h>
#include <qscopedvaluerollback.h>
 
#include "qprocess.h"
#include "qprocess_p.h"
 
#include <qbytearray.h>
#include <qdeadlinetimer.h>
#include <qcoreapplication.h>
#include <qtimer.h>
 
#if __has_include(<paths.h>)
#include <paths.h>
#endif
 
QT_BEGIN_NAMESPACE
 
QStringList QProcessEnvironmentPrivate::toList() const
{
    QStringList result;
    result.reserve(vars.size());
    for (auto it = vars.cbegin(), end = vars.cend(); it != end; ++it)
        result << nameToString(it.key()) + u'=' + valueToString(it.value());
    return result;
}
 
QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list)
{
    QProcessEnvironment env;
    QStringList::ConstIterator it = list.constBegin(),
                              end = list.constEnd();
    for ( ; it != end; ++it) {
        const qsizetype pos = it->indexOf(u'=', 1);
        if (pos < 1)
            continue;
 
        QString value = it->mid(pos + 1);
        QString name = *it;
        name.truncate(pos);
        env.insert(name, value);
    }
    return env;
}
 
QStringList QProcessEnvironmentPrivate::keys() const
{
    QStringList result;
    result.reserve(vars.size());
    auto it = vars.constBegin();
    const auto end = vars.constEnd();
    for ( ; it != end; ++it)
        result << nameToString(it.key());
    return result;
}
 
void QProcessEnvironmentPrivate::insert(const QProcessEnvironmentPrivate &other)
{
    auto it = other.vars.constBegin();
    const auto end = other.vars.constEnd();
    for ( ; it != end; ++it)
        vars.insert(it.key(), it.value());
 
#ifdef Q_OS_UNIX
    const OrderedNameMapMutexLocker locker(this, &other);
    auto nit = other.nameMap.constBegin();
    const auto nend = other.nameMap.constEnd();
    for ( ; nit != nend; ++nit)
        nameMap.insert(nit.key(), nit.value());
#endif
}
 
QProcessEnvironment::QProcessEnvironment() : d(new QProcessEnvironmentPrivate) { }
 
QProcessEnvironment::QProcessEnvironment(QProcessEnvironment::Initialization) noexcept { }
 
QProcessEnvironment::~QProcessEnvironment()
{
}
 
QProcessEnvironment::QProcessEnvironment(const QProcessEnvironment &other)
    : d(other.d)
{
}
 
QProcessEnvironment &QProcessEnvironment::operator=(const QProcessEnvironment &other)
{
    d = other.d;
    return *this;
}
 
bool QProcessEnvironment::operator==(const QProcessEnvironment &other) const
{
    if (d == other.d)
        return true;
 
    return d && other.d && d->vars == other.d->vars;
}
 
bool QProcessEnvironment::isEmpty() const
{
    // Needs no locking, as no hash nodes are accessed
    return d ? d->vars.isEmpty() : true;
}
 
bool QProcessEnvironment::inheritsFromParent() const
{
    return !d;
}
 
void QProcessEnvironment::clear()
{
    if (d.constData())
        d->vars.clear();
    // Unix: Don't clear d->nameMap, as the environment is likely to be
    // re-populated with the same keys again.
}
 
bool QProcessEnvironment::contains(const QString &name) const
{
    if (!d)
        return false;
    return d->vars.contains(d->prepareName(name));
}
 
void QProcessEnvironment::insert(const QString &name, const QString &value)
{
    // our re-impl of detach() detaches from null
    d.detach(); // detach before prepareName()
    d->vars.insert(d->prepareName(name), d->prepareValue(value));
}
 
void QProcessEnvironment::remove(const QString &name)
{
    if (d.constData()) {
        QProcessEnvironmentPrivate *p = d.data();
        p->vars.remove(p->prepareName(name));
    }
}
 
QString QProcessEnvironment::value(const QString &name, const QString &defaultValue) const
{
    if (!d)
        return defaultValue;
 
    const auto it = d->vars.constFind(d->prepareName(name));
    if (it == d->vars.constEnd())
        return defaultValue;
 
    return d->valueToString(it.value());
}
 
QStringList QProcessEnvironment::toStringList() const
{
    if (!d)
        return QStringList();
    return d->toList();
}
 
QStringList QProcessEnvironment::keys() const
{
    if (!d)
        return QStringList();
    return d->keys();
}
 
void QProcessEnvironment::insert(const QProcessEnvironment &e)
{
    if (!e.d)
        return;
 
    // our re-impl of detach() detaches from null
    d->insert(*e.d);
}
 
#if QT_CONFIG(process)
 
void QProcessPrivate::Channel::clear()
{
    switch (type) {
    case PipeSource:
        Q_ASSERT(process);
        process->stdinChannel.type = Normal;
        process->stdinChannel.process = nullptr;
        break;
    case PipeSink:
        Q_ASSERT(process);
        process->stdoutChannel.type = Normal;
        process->stdoutChannel.process = nullptr;
        break;
    default:
        break;
    }
 
    type = Normal;
    file.clear();
    process = nullptr;
}
 
QProcessPrivate::QProcessPrivate()
{
    readBufferChunkSize = QRINGBUFFER_CHUNKSIZE;
#ifndef Q_OS_WIN
    writeBufferChunkSize = QRINGBUFFER_CHUNKSIZE;
#endif
}
 
QProcessPrivate::~QProcessPrivate()
{
    if (stdinChannel.process)
        stdinChannel.process->stdoutChannel.clear();
    if (stdoutChannel.process)
        stdoutChannel.process->stdinChannel.clear();
}
 
void QProcessPrivate::setError(QProcess::ProcessError error, const QString &description)
{
    processError = error;
    if (description.isEmpty()) {
        switch (error) {
        case QProcess::FailedToStart:
            errorString = QProcess::tr("Process failed to start");
            break;
        case QProcess::Crashed:
            errorString = QProcess::tr("Process crashed");
            break;
        case QProcess::Timedout:
            errorString = QProcess::tr("Process operation timed out");
            break;
        case QProcess::ReadError:
            errorString = QProcess::tr("Error reading from process");
            break;
        case QProcess::WriteError:
            errorString = QProcess::tr("Error writing to process");
            break;
        case QProcess::UnknownError:
            errorString.clear();
            break;
        }
    } else {
        errorString = description;
    }
}
 
void QProcessPrivate::setErrorAndEmit(QProcess::ProcessError error, const QString &description)
{
    Q_Q(QProcess);
    Q_ASSERT(error != QProcess::UnknownError);
    setError(error, description);
    emit q->errorOccurred(QProcess::ProcessError(processError));
}
 
bool QProcessPrivate::openChannels()
{
    // stdin channel.
    if (inputChannelMode == QProcess::ForwardedInputChannel) {
        if (stdinChannel.type != Channel::Normal)
            qWarning("QProcess::openChannels: Inconsistent stdin channel configuration");
    } else if (!openChannel(stdinChannel)) {
        return false;
    }
 
    // stdout channel.
    if (processChannelMode == QProcess::ForwardedChannels
            || processChannelMode == QProcess::ForwardedOutputChannel) {
        if (stdoutChannel.type != Channel::Normal)
            qWarning("QProcess::openChannels: Inconsistent stdout channel configuration");
    } else if (!openChannel(stdoutChannel)) {
        return false;
    }
 
    // stderr channel.
    if (processChannelMode == QProcess::ForwardedChannels
            || processChannelMode == QProcess::ForwardedErrorChannel
            || processChannelMode == QProcess::MergedChannels) {
        if (stderrChannel.type != Channel::Normal)
            qWarning("QProcess::openChannels: Inconsistent stderr channel configuration");
    } else if (!openChannel(stderrChannel)) {
        return false;
    }
 
    return true;
}
 
void QProcessPrivate::closeChannels()
{
    closeChannel(&stdoutChannel);
    closeChannel(&stderrChannel);
    closeChannel(&stdinChannel);
}
 
bool QProcessPrivate::openChannelsForDetached()
{
    // stdin channel.
    bool needToOpen = (stdinChannel.type == Channel::Redirect
                       || stdinChannel.type == Channel::PipeSink);
    if (stdinChannel.type != Channel::Normal
            && (!needToOpen
                || inputChannelMode == QProcess::ForwardedInputChannel)) {
        qWarning("QProcess::openChannelsForDetached: Inconsistent stdin channel configuration");
    }
    if (needToOpen && !openChannel(stdinChannel))
        return false;
 
    // stdout channel.
    needToOpen = (stdoutChannel.type == Channel::Redirect
                  || stdoutChannel.type == Channel::PipeSource);
    if (stdoutChannel.type != Channel::Normal
            && (!needToOpen
                || processChannelMode == QProcess::ForwardedChannels
                || processChannelMode == QProcess::ForwardedOutputChannel)) {
        qWarning("QProcess::openChannelsForDetached: Inconsistent stdout channel configuration");
    }
    if (needToOpen && !openChannel(stdoutChannel))
        return false;
 
    // stderr channel.
    needToOpen = (stderrChannel.type == Channel::Redirect);
    if (stderrChannel.type != Channel::Normal
            && (!needToOpen
                || processChannelMode == QProcess::ForwardedChannels
                || processChannelMode == QProcess::ForwardedErrorChannel
                || processChannelMode == QProcess::MergedChannels)) {
        qWarning("QProcess::openChannelsForDetached: Inconsistent stderr channel configuration");
    }
    if (needToOpen && !openChannel(stderrChannel))
        return false;
 
    return true;
}
 
bool QProcessPrivate::tryReadFromChannel(Channel *channel)
{
    Q_Q(QProcess);
    if (channel->pipe[0] == INVALID_Q_PIPE)
        return false;
 
    qint64 available = bytesAvailableInChannel(channel);
    if (available == 0)
        available = 1;      // always try to read at least one byte
 
    QProcess::ProcessChannel channelIdx = (channel == &stdoutChannel
                                           ? QProcess::StandardOutput
                                           : QProcess::StandardError);
    Q_ASSERT(readBuffers.size() > int(channelIdx));
    QRingBuffer &readBuffer = readBuffers[int(channelIdx)];
    char *ptr = readBuffer.reserve(available);
    qint64 readBytes = readFromChannel(channel, ptr, available);
    if (readBytes <= 0)
        readBuffer.chop(available);
    if (readBytes == -2) {
        // EWOULDBLOCK
        return false;
    }
    if (readBytes == -1) {
        setErrorAndEmit(QProcess::ReadError);
#if defined QPROCESS_DEBUG
        qDebug("QProcessPrivate::tryReadFromChannel(%d), failed to read from the process",
               int(channel - &stdinChannel));
#endif
        return false;
    }
    if (readBytes == 0) {
        // EOF
        closeChannel(channel);
#if defined QPROCESS_DEBUG
        qDebug("QProcessPrivate::tryReadFromChannel(%d), 0 bytes available",
               int(channel - &stdinChannel));
#endif
        return false;
    }
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::tryReadFromChannel(%d), read %lld bytes from the process' output",
           int(channel - &stdinChannel), readBytes);
#endif
 
    if (channel->closed) {
        readBuffer.chop(readBytes);
        return false;
    }
 
    readBuffer.chop(available - readBytes);
 
    bool didRead = false;
    if (currentReadChannel == channelIdx) {
        didRead = true;
        if (!emittedReadyRead) {
            QScopedValueRollback<bool> guard(emittedReadyRead, true);
            emit q->readyRead();
        }
    }
    emit q->channelReadyRead(int(channelIdx));
    if (channelIdx == QProcess::StandardOutput)
        emit q->readyReadStandardOutput(QProcess::QPrivateSignal());
    else
        emit q->readyReadStandardError(QProcess::QPrivateSignal());
    return didRead;
}
 
bool QProcessPrivate::_q_canReadStandardOutput()
{
    return tryReadFromChannel(&stdoutChannel);
}
 
bool QProcessPrivate::_q_canReadStandardError()
{
    return tryReadFromChannel(&stderrChannel);
}
 
void QProcessPrivate::_q_processDied()
{
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::_q_processDied()");
#endif
 
    // in case there is data in the pipeline and this slot by chance
    // got called before the read notifications, call these functions
    // so the data is made available before we announce death.
#ifdef Q_OS_WIN
    drainOutputPipes();
#else
    _q_canReadStandardOutput();
    _q_canReadStandardError();
#endif
 
    // Slots connected to signals emitted by the functions called above
    // might call waitFor*(), which would synchronously reap the process.
    // So check the state to avoid trying to reap a second time.
    if (processState != QProcess::NotRunning)
        processFinished();
}
 
void QProcessPrivate::processFinished()
{
    Q_Q(QProcess);
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::processFinished()");
#endif
 
#ifdef Q_OS_UNIX
    waitForDeadChild();
#else
    findExitCode();
#endif
 
    cleanup();
 
    if (exitStatus == QProcess::CrashExit)
        setErrorAndEmit(QProcess::Crashed);
 
    // we received EOF now:
    emit q->readChannelFinished();
    // in the future:
    //emit q->standardOutputClosed();
    //emit q->standardErrorClosed();
 
    emit q->finished(exitCode, QProcess::ExitStatus(exitStatus));
 
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::processFinished(): process is dead");
#endif
}
 
bool QProcessPrivate::_q_startupNotification()
{
    Q_Q(QProcess);
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::startupNotification()");
#endif
 
    QString errorMessage;
    if (processStarted(&errorMessage)) {
        q->setProcessState(QProcess::Running);
        emit q->started(QProcess::QPrivateSignal());
        return true;
    }
 
    q->setProcessState(QProcess::NotRunning);
    setErrorAndEmit(QProcess::FailedToStart, errorMessage);
#ifdef Q_OS_UNIX
    waitForDeadChild();
#endif
    cleanup();
    return false;
}
 
void QProcessPrivate::closeWriteChannel()
{
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::closeWriteChannel()");
#endif
 
    closeChannel(&stdinChannel);
}
 
QProcess::QProcess(QObject *parent)
    : QIODevice(*new QProcessPrivate, parent)
{
#if defined QPROCESS_DEBUG
    qDebug("QProcess::QProcess(%p)", parent);
#endif
}
 
QProcess::~QProcess()
{
    Q_D(QProcess);
    if (d->processState != NotRunning) {
        qWarning().nospace()
            << "QProcess: Destroyed while process (" << QDir::toNativeSeparators(program()) << ") is still running.";
        kill();
        waitForFinished();
    }
    d->cleanup();
}
 
QProcess::ProcessChannelMode QProcess::processChannelMode() const
{
    Q_D(const QProcess);
    return ProcessChannelMode(d->processChannelMode);
}
 
void QProcess::setProcessChannelMode(ProcessChannelMode mode)
{
    Q_D(QProcess);
    d->processChannelMode = mode;
}
 
QProcess::InputChannelMode QProcess::inputChannelMode() const
{
    Q_D(const QProcess);
    return InputChannelMode(d->inputChannelMode);
}
 
void QProcess::setInputChannelMode(InputChannelMode mode)
{
    Q_D(QProcess);
    d->inputChannelMode = mode;
}
 
QProcess::ProcessChannel QProcess::readChannel() const
{
    Q_D(const QProcess);
    return ProcessChannel(d->currentReadChannel);
}
 
void QProcess::setReadChannel(ProcessChannel channel)
{
    QIODevice::setCurrentReadChannel(int(channel));
}
 
void QProcess::closeReadChannel(ProcessChannel channel)
{
    Q_D(QProcess);
 
    if (channel == StandardOutput)
        d->stdoutChannel.closed = true;
    else
        d->stderrChannel.closed = true;
}
 
void QProcess::closeWriteChannel()
{
    Q_D(QProcess);
    d->stdinChannel.closed = true; // closing
    if (bytesToWrite() == 0)
        d->closeWriteChannel();
}
 
void QProcess::setStandardInputFile(const QString &fileName)
{
    Q_D(QProcess);
    d->stdinChannel = fileName;
}
 
void QProcess::setStandardOutputFile(const QString &fileName, OpenMode mode)
{
    Q_ASSERT(mode == Append || mode == Truncate);
    Q_D(QProcess);
 
    d->stdoutChannel = fileName;
    d->stdoutChannel.append = mode == Append;
}
 
void QProcess::setStandardErrorFile(const QString &fileName, OpenMode mode)
{
    Q_ASSERT(mode == Append || mode == Truncate);
    Q_D(QProcess);
 
    d->stderrChannel = fileName;
    d->stderrChannel.append = mode == Append;
}
 
void QProcess::setStandardOutputProcess(QProcess *destination)
{
    QProcessPrivate *dfrom = d_func();
    QProcessPrivate *dto = destination->d_func();
    dfrom->stdoutChannel.pipeTo(dto);
    dto->stdinChannel.pipeFrom(dfrom);
}
 
#if defined(Q_OS_WIN) || defined(Q_QDOC)
 
QString QProcess::nativeArguments() const
{
    Q_D(const QProcess);
    return d->nativeArguments;
}
 
void QProcess::setNativeArguments(const QString &arguments)
{
    Q_D(QProcess);
    d->nativeArguments = arguments;
}
 
QProcess::CreateProcessArgumentModifier QProcess::createProcessArgumentsModifier() const
{
    Q_D(const QProcess);
    return d->modifyCreateProcessArgs;
}
 
void QProcess::setCreateProcessArgumentsModifier(CreateProcessArgumentModifier modifier)
{
    Q_D(QProcess);
    d->modifyCreateProcessArgs = modifier;
}
 
#endif
 
#if defined(Q_OS_UNIX) || defined(Q_QDOC)
std::function<void(void)> QProcess::childProcessModifier() const
{
    Q_D(const QProcess);
    return d->unixExtras ? d->unixExtras->childProcessModifier : std::function<void(void)>();
}
 
void QProcess::setChildProcessModifier(const std::function<void(void)> &modifier)
{
    Q_D(QProcess);
    if (!d->unixExtras)
        d->unixExtras.reset(new QProcessPrivate::UnixExtras);
    d->unixExtras->childProcessModifier = modifier;
}
 
auto QProcess::unixProcessParameters() const noexcept -> UnixProcessParameters
{
    Q_D(const QProcess);
    return d->unixExtras ? d->unixExtras->processParameters : UnixProcessParameters{};
}
 
void QProcess::setUnixProcessParameters(const UnixProcessParameters &params)
{
    Q_D(QProcess);
    if (!d->unixExtras)
        d->unixExtras.reset(new QProcessPrivate::UnixExtras);
    d->unixExtras->processParameters = params;
}
 
void QProcess::setUnixProcessParameters(UnixProcessFlags flagsOnly)
{
    Q_D(QProcess);
    if (!d->unixExtras)
        d->unixExtras.reset(new QProcessPrivate::UnixExtras);
    d->unixExtras->processParameters = { flagsOnly };
}
#endif
 
QString QProcess::workingDirectory() const
{
    Q_D(const QProcess);
    return d->workingDirectory;
}
 
void QProcess::setWorkingDirectory(const QString &dir)
{
    Q_D(QProcess);
    d->workingDirectory = dir;
}
 
qint64 QProcess::processId() const
{
    Q_D(const QProcess);
#ifdef Q_OS_WIN
    return d->pid ? d->pid->dwProcessId : 0;
#else
    return d->pid;
#endif
}
 
void QProcess::close()
{
    Q_D(QProcess);
    emit aboutToClose();
    while (waitForBytesWritten(-1))
        ;
    kill();
    waitForFinished(-1);
    d->setWriteChannelCount(0);
    QIODevice::close();
}
 
bool QProcess::isSequential() const
{
    return true;
}
 
qint64 QProcess::bytesToWrite() const
{
#ifdef Q_OS_WIN
    return d_func()->pipeWriterBytesToWrite();
#else
    return QIODevice::bytesToWrite();
#endif
}
 
QProcess::ProcessError QProcess::error() const
{
    Q_D(const QProcess);
    return ProcessError(d->processError);
}
 
QProcess::ProcessState QProcess::state() const
{
    Q_D(const QProcess);
    return ProcessState(d->processState);
}
 
void QProcess::setEnvironment(const QStringList &environment)
{
    setProcessEnvironment(QProcessEnvironmentPrivate::fromList(environment));
}
 
QStringList QProcess::environment() const
{
    Q_D(const QProcess);
    return d->environment.toStringList();
}
 
void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)
{
    Q_D(QProcess);
    d->environment = environment;
}
 
QProcessEnvironment QProcess::processEnvironment() const
{
    Q_D(const QProcess);
    return d->environment;
}
 
bool QProcess::waitForStarted(int msecs)
{
    Q_D(QProcess);
    if (d->processState == QProcess::Starting)
        return d->waitForStarted(QDeadlineTimer(msecs));
 
    return d->processState == QProcess::Running;
}
 
bool QProcess::waitForReadyRead(int msecs)
{
    Q_D(QProcess);
 
    if (d->processState == QProcess::NotRunning)
        return false;
    if (d->currentReadChannel == QProcess::StandardOutput && d->stdoutChannel.closed)
        return false;
    if (d->currentReadChannel == QProcess::StandardError && d->stderrChannel.closed)
        return false;
 
    QDeadlineTimer deadline(msecs);
    if (d->processState == QProcess::Starting) {
        bool started = d->waitForStarted(deadline);
        if (!started)
            return false;
    }
 
    return d->waitForReadyRead(deadline);
}
 
bool QProcess::waitForBytesWritten(int msecs)
{
    Q_D(QProcess);
    if (d->processState == QProcess::NotRunning)
        return false;
 
    QDeadlineTimer deadline(msecs);
    if (d->processState == QProcess::Starting) {
        bool started = d->waitForStarted(deadline);
        if (!started)
            return false;
    }
 
    return d->waitForBytesWritten(deadline);
}
 
bool QProcess::waitForFinished(int msecs)
{
    Q_D(QProcess);
    if (d->processState == QProcess::NotRunning)
        return false;
 
    QDeadlineTimer deadline(msecs);
    if (d->processState == QProcess::Starting) {
        bool started = d->waitForStarted(deadline);
        if (!started)
            return false;
    }
 
    return d->waitForFinished(deadline);
}
 
void QProcess::setProcessState(ProcessState state)
{
    Q_D(QProcess);
    if (d->processState == state)
        return;
    d->processState = state;
    emit stateChanged(state, QPrivateSignal());
}
 
#if QT_VERSION < QT_VERSION_CHECK(7,0,0)
auto QProcess::setupChildProcess() -> Use_setChildProcessModifier_Instead
{
    Q_UNREACHABLE_RETURN({});
}
#endif
 
qint64 QProcess::readData(char *data, qint64 maxlen)
{
    Q_D(QProcess);
    Q_UNUSED(data);
    if (!maxlen)
        return 0;
    if (d->processState == QProcess::NotRunning)
        return -1;              // EOF
    return 0;
}
 
QByteArray QProcess::readAllStandardOutput()
{
    ProcessChannel tmp = readChannel();
    setReadChannel(StandardOutput);
    QByteArray data = readAll();
    setReadChannel(tmp);
    return data;
}
 
QByteArray QProcess::readAllStandardError()
{
    Q_D(QProcess);
    QByteArray data;
    if (d->processChannelMode == MergedChannels) {
        qWarning("QProcess::readAllStandardError: Called with MergedChannels");
    } else {
        ProcessChannel tmp = readChannel();
        setReadChannel(StandardError);
        data = readAll();
        setReadChannel(tmp);
    }
    return data;
}
 
void QProcess::start(const QString &program, const QStringList &arguments, OpenMode mode)
{
    Q_D(QProcess);
    if (d->processState != NotRunning) {
        qWarning("QProcess::start: Process is already running");
        return;
    }
    if (program.isEmpty()) {
        d->setErrorAndEmit(QProcess::FailedToStart, tr("No program defined"));
        return;
    }
 
    d->program = program;
    d->arguments = arguments;
 
    d->start(mode);
}
 
void QProcess::start(OpenMode mode)
{
    Q_D(QProcess);
    if (d->processState != NotRunning) {
        qWarning("QProcess::start: Process is already running");
        return;
    }
    if (d->program.isEmpty()) {
        d->setErrorAndEmit(QProcess::FailedToStart, tr("No program defined"));
        return;
    }
 
    d->start(mode);
}
 
void QProcess::startCommand(const QString &command, OpenMode mode)
{
    QStringList args = splitCommand(command);
    const QString program = args.takeFirst();
    start(program, args, mode);
}
 
bool QProcess::startDetached(qint64 *pid)
{
    Q_D(QProcess);
    if (d->processState != NotRunning) {
        qWarning("QProcess::startDetached: Process is already running");
        return false;
    }
    if (d->program.isEmpty()) {
        d->setErrorAndEmit(QProcess::FailedToStart, tr("No program defined"));
        return false;
    }
    return d->startDetached(pid);
}
 
bool QProcess::open(OpenMode mode)
{
    Q_D(QProcess);
    if (d->processState != NotRunning) {
        qWarning("QProcess::start: Process is already running");
        return false;
    }
    if (d->program.isEmpty()) {
        qWarning("QProcess::start: program not set");
        return false;
    }
 
    d->start(mode);
    return true;
}
 
void QProcessPrivate::start(QIODevice::OpenMode mode)
{
    Q_Q(QProcess);
#if defined QPROCESS_DEBUG
    qDebug() << "QProcess::start(" << program << ',' << arguments << ',' << mode << ')';
#endif
 
    if (stdinChannel.type != QProcessPrivate::Channel::Normal)
        mode &= ~QIODevice::WriteOnly;     // not open for writing
    if (stdoutChannel.type != QProcessPrivate::Channel::Normal &&
        (stderrChannel.type != QProcessPrivate::Channel::Normal ||
         processChannelMode == QProcess::MergedChannels))
        mode &= ~QIODevice::ReadOnly;      // not open for reading
    if (mode == 0)
        mode = QIODevice::Unbuffered;
    if ((mode & QIODevice::ReadOnly) == 0) {
        if (stdoutChannel.type == QProcessPrivate::Channel::Normal)
            q->setStandardOutputFile(q->nullDevice());
        if (stderrChannel.type == QProcessPrivate::Channel::Normal
            && processChannelMode != QProcess::MergedChannels)
            q->setStandardErrorFile(q->nullDevice());
    }
 
    q->QIODevice::open(mode);
 
    if (q->isReadable() && processChannelMode != QProcess::MergedChannels)
        setReadChannelCount(2);
 
    stdinChannel.closed = false;
    stdoutChannel.closed = false;
    stderrChannel.closed = false;
 
    exitCode = 0;
    exitStatus = QProcess::NormalExit;
    processError = QProcess::UnknownError;
    errorString.clear();
    startProcess();
}
 
QStringList QProcess::splitCommand(QStringView command)
{
    QStringList args;
    QString tmp;
    int quoteCount = 0;
    bool inQuote = false;
 
    // handle quoting. tokens can be surrounded by double quotes
    // "hello world". three consecutive double quotes represent
    // the quote character itself.
    for (int i = 0; i < command.size(); ++i) {
        if (command.at(i) == u'"') {
            ++quoteCount;
            if (quoteCount == 3) {
                // third consecutive quote
                quoteCount = 0;
                tmp += command.at(i);
            }
            continue;
        }
        if (quoteCount) {
            if (quoteCount == 1)
                inQuote = !inQuote;
            quoteCount = 0;
        }
        if (!inQuote && command.at(i).isSpace()) {
            if (!tmp.isEmpty()) {
                args += tmp;
                tmp.clear();
            }
        } else {
            tmp += command.at(i);
        }
    }
    if (!tmp.isEmpty())
        args += tmp;
 
    return args;
}
 
QString QProcess::program() const
{
    Q_D(const QProcess);
    return d->program;
}
 
void QProcess::setProgram(const QString &program)
{
    Q_D(QProcess);
    if (d->processState != NotRunning) {
        qWarning("QProcess::setProgram: Process is already running");
        return;
    }
    d->program = program;
}
 
QStringList QProcess::arguments() const
{
    Q_D(const QProcess);
    return d->arguments;
}
 
void QProcess::setArguments(const QStringList &arguments)
{
    Q_D(QProcess);
    if (d->processState != NotRunning) {
        qWarning("QProcess::setProgram: Process is already running");
        return;
    }
    d->arguments = arguments;
}
 
void QProcess::terminate()
{
    Q_D(QProcess);
    d->terminateProcess();
}
 
void QProcess::kill()
{
    Q_D(QProcess);
    d->killProcess();
}
 
int QProcess::exitCode() const
{
    Q_D(const QProcess);
    return d->exitCode;
}
 
QProcess::ExitStatus QProcess::exitStatus() const
{
    Q_D(const QProcess);
    return ExitStatus(d->exitStatus);
}
 
int QProcess::execute(const QString &program, const QStringList &arguments)
{
    QProcess process;
    process.setProcessChannelMode(ForwardedChannels);
    process.start(program, arguments);
    if (!process.waitForFinished(-1) || process.error() == FailedToStart)
        return -2;
    return process.exitStatus() == QProcess::NormalExit ? process.exitCode() : -1;
}
 
bool QProcess::startDetached(const QString &program,
                             const QStringList &arguments,
                             const QString &workingDirectory,
                             qint64 *pid)
{
    QProcess process;
    process.setProgram(program);
    process.setArguments(arguments);
    process.setWorkingDirectory(workingDirectory);
    return process.startDetached(pid);
}
 
QStringList QProcess::systemEnvironment()
{
    return QProcessEnvironment::systemEnvironment().toStringList();
}
 
QString QProcess::nullDevice()
{
#ifdef Q_OS_WIN
    return QStringLiteral("\\\\.\\NUL");
#elif defined(_PATH_DEVNULL)
    return QStringLiteral(_PATH_DEVNULL);
#else
    return QStringLiteral("/dev/null");
#endif
}
 
#endif // QT_CONFIG(process)
 
QT_END_NAMESPACE
 
#include "moc_qprocess.cpp"