qprocess_win.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2017 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
 
//#define QPROCESS_DEBUG
#include <qdebug.h>
#include <private/qdebug_p.h>
 
#include "qprocess.h"
#include "qprocess_p.h"
#include "qwindowspipereader_p.h"
#include "qwindowspipewriter_p.h"
 
#include <qdatetime.h>
#include <qdir.h>
#include <qfileinfo.h>
#include <qrandom.h>
#include <qwineventnotifier.h>
#include <qscopedvaluerollback.h>
#include <private/qsystemlibrary_p.h>
#include <private/qthread_p.h>
 
#include "private/qfsfileengine_p.h" // for longFileName
 
#ifndef PIPE_REJECT_REMOTE_CLIENTS
#define PIPE_REJECT_REMOTE_CLIENTS 0x08
#endif
 
QT_BEGIN_NAMESPACE
 
constexpr UINT KillProcessExitCode = 0xf291;
 
using namespace Qt::StringLiterals;
 
QProcessEnvironment QProcessEnvironment::systemEnvironment()
{
    QProcessEnvironment env;
    // Calls to setenv() affect the low-level environment as well.
    // This is not the case the other way round.
    if (wchar_t *envStrings = GetEnvironmentStringsW()) {
        for (const wchar_t *entry = envStrings; *entry; ) {
            const int entryLen = int(wcslen(entry));
            // + 1 to permit magic cmd variable names starting with =
            if (const wchar_t *equal = wcschr(entry + 1, L'=')) {
                int nameLen = equal - entry;
                QString name = QString::fromWCharArray(entry, nameLen);
                QString value = QString::fromWCharArray(equal + 1, entryLen - nameLen - 1);
                env.d->vars.insert(QProcessEnvironmentPrivate::Key(name), value);
            }
            entry += entryLen + 1;
        }
        FreeEnvironmentStringsW(envStrings);
    }
    return env;
}
 
#if QT_CONFIG(process)
 
namespace {
struct QProcessPoller
{
    QProcessPoller(const QProcessPrivate &proc);
 
    int poll(const QDeadlineTimer &deadline);
 
    enum { maxHandles = 4 };
    HANDLE handles[maxHandles];
    DWORD handleCount = 0;
};
 
QProcessPoller::QProcessPoller(const QProcessPrivate &proc)
{
    if (proc.stdinChannel.writer)
        handles[handleCount++] = proc.stdinChannel.writer->syncEvent();
    if (proc.stdoutChannel.reader)
        handles[handleCount++] = proc.stdoutChannel.reader->syncEvent();
    if (proc.stderrChannel.reader)
        handles[handleCount++] = proc.stderrChannel.reader->syncEvent();
 
    handles[handleCount++] = proc.pid->hProcess;
}
 
int QProcessPoller::poll(const QDeadlineTimer &deadline)
{
    DWORD waitRet;
 
    do {
        waitRet = WaitForMultipleObjectsEx(handleCount, handles, FALSE,
                                           deadline.remainingTime(), TRUE);
    } while (waitRet == WAIT_IO_COMPLETION);
 
    if (waitRet - WAIT_OBJECT_0 < handleCount)
        return 1;
 
    return (waitRet == WAIT_TIMEOUT) ? 0 : -1;
}
} // anonymous namespace
 
static bool qt_create_pipe(Q_PIPE *pipe, bool isInputPipe, BOOL defInheritFlag)
{
    // Anomymous pipes do not support asynchronous I/O. Thus we
    // create named pipes for redirecting stdout, stderr and stdin.
 
    // The write handle must be non-inheritable for input pipes.
    // The read handle must be non-inheritable for output pipes.
    // When one process pipes to another (setStandardOutputProcess() was called),
    // both handles must be inheritable (defInheritFlag == TRUE).
    SECURITY_ATTRIBUTES secAtt = { sizeof(SECURITY_ATTRIBUTES), 0, defInheritFlag };
 
    HANDLE hServer;
    wchar_t pipeName[256];
    unsigned int attempts = 1000;
    forever {
        _snwprintf(pipeName, sizeof(pipeName) / sizeof(pipeName[0]),
                L"\\\\.\\pipe\\qt-%lX-%X", long(QCoreApplication::applicationPid()),
                QRandomGenerator::global()->generate());
 
        DWORD dwOpenMode = FILE_FLAG_OVERLAPPED;
        DWORD dwOutputBufferSize = 0;
        DWORD dwInputBufferSize = 0;
        const DWORD dwPipeBufferSize = 1024 * 1024;
        if (isInputPipe) {
            dwOpenMode |= PIPE_ACCESS_OUTBOUND;
            dwOutputBufferSize = dwPipeBufferSize;
        } else {
            dwOpenMode |= PIPE_ACCESS_INBOUND;
            dwInputBufferSize = dwPipeBufferSize;
        }
        DWORD dwPipeFlags = PIPE_TYPE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS;
        hServer = CreateNamedPipe(pipeName,
                                  dwOpenMode,
                                  dwPipeFlags,
                                  1,                      // only one pipe instance
                                  dwOutputBufferSize,
                                  dwInputBufferSize,
                                  0,
                                  &secAtt);
        if (hServer != INVALID_HANDLE_VALUE)
            break;
        DWORD dwError = GetLastError();
        if (dwError != ERROR_PIPE_BUSY || !--attempts) {
            qErrnoWarning(dwError, "QProcess: CreateNamedPipe failed.");
            SetLastError(dwError);
            return false;
        }
    }
 
    secAtt.bInheritHandle = TRUE;
    const HANDLE hClient = CreateFile(pipeName,
                                      (isInputPipe ? (GENERIC_READ | FILE_WRITE_ATTRIBUTES)
                                                   : GENERIC_WRITE),
                                      0,
                                      &secAtt,
                                      OPEN_EXISTING,
                                      FILE_FLAG_OVERLAPPED,
                                      NULL);
    if (hClient == INVALID_HANDLE_VALUE) {
        DWORD dwError = GetLastError();
        qErrnoWarning("QProcess: CreateFile failed.");
        CloseHandle(hServer);
        SetLastError(dwError);
        return false;
    }
 
    // Wait until connection is in place.
    OVERLAPPED overlapped;
    ZeroMemory(&overlapped, sizeof(overlapped));
    overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (ConnectNamedPipe(hServer, &overlapped) == 0) {
        DWORD dwError = GetLastError();
        switch (dwError) {
        case ERROR_PIPE_CONNECTED:
            break;
        case ERROR_IO_PENDING:
            WaitForSingleObject(overlapped.hEvent, INFINITE);
            break;
        default:
            dwError = GetLastError();
            qErrnoWarning(dwError, "QProcess: ConnectNamedPipe failed.");
            CloseHandle(overlapped.hEvent);
            CloseHandle(hClient);
            CloseHandle(hServer);
            SetLastError(dwError);
            return false;
        }
    }
    CloseHandle(overlapped.hEvent);
 
    if (isInputPipe) {
        pipe[0] = hClient;
        pipe[1] = hServer;
    } else {
        pipe[0] = hServer;
        pipe[1] = hClient;
    }
    return true;
}
 
/*
    Create the pipes to a QProcessPrivate::Channel.
*/
bool QProcessPrivate::openChannel(Channel &channel)
{
    Q_Q(QProcess);
 
    switch (channel.type) {
    case Channel::Normal: {
        // we're piping this channel to our own process
        if (&channel == &stdinChannel) {
            if (!qt_create_pipe(channel.pipe, true, FALSE)) {
                setErrorAndEmit(QProcess::FailedToStart, "pipe: "_L1 + qt_error_string(errno));
                return false;
            }
            return true;
        }
 
        // stdout or stderr
        if (!channel.reader) {
            auto receiver = &channel == &stdoutChannel ? &QProcessPrivate::_q_canReadStandardOutput
                                                       : &QProcessPrivate::_q_canReadStandardError;
            channel.reader = new QWindowsPipeReader(q);
            QObjectPrivate::connect(channel.reader, &QWindowsPipeReader::readyRead,
                                    this, receiver);
        }
        if (!qt_create_pipe(channel.pipe, false, FALSE)) {
            setErrorAndEmit(QProcess::FailedToStart, "pipe: "_L1 + qt_error_string(errno));
            return false;
        }
 
        channel.reader->setHandle(channel.pipe[0]);
        channel.reader->startAsyncRead();
        return true;
    }
    case Channel::Redirect: {
        // we're redirecting the channel to/from a file
        SECURITY_ATTRIBUTES secAtt = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
 
        if (&channel == &stdinChannel) {
            // try to open in read-only mode
            channel.pipe[1] = INVALID_Q_PIPE;
            channel.pipe[0] =
                CreateFile((const wchar_t*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
                           GENERIC_READ,
                           FILE_SHARE_READ | FILE_SHARE_WRITE,
                           &secAtt,
                           OPEN_EXISTING,
                           FILE_ATTRIBUTE_NORMAL,
                           NULL);
 
            if (channel.pipe[0] != INVALID_Q_PIPE)
                return true;
 
            setErrorAndEmit(QProcess::FailedToStart,
                            QProcess::tr("Could not open input redirection for reading"));
        } else {
            // open in write mode
            channel.pipe[0] = INVALID_Q_PIPE;
            channel.pipe[1] =
                CreateFile((const wchar_t *)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
                           GENERIC_WRITE,
                           FILE_SHARE_READ | FILE_SHARE_WRITE,
                           &secAtt,
                           channel.append ? OPEN_ALWAYS : CREATE_ALWAYS,
                           FILE_ATTRIBUTE_NORMAL,
                           NULL);
 
            if (channel.pipe[1] != INVALID_Q_PIPE) {
                if (channel.append) {
                    SetFilePointer(channel.pipe[1], 0, NULL, FILE_END);
                }
                return true;
            }
 
            setErrorAndEmit(QProcess::FailedToStart,
                            QProcess::tr("Could not open output redirection for writing"));
        }
        return false;
    }
    case Channel::PipeSource: {
        Q_ASSERT_X(channel.process, "QProcess::start", "Internal error");
        // we are the source
        Channel *source = &channel;
        Channel *sink = &channel.process->stdinChannel;
 
        if (source->pipe[1] != INVALID_Q_PIPE) {
            // already constructed by the sink
            return true;
        }
 
        Q_ASSERT(source == &stdoutChannel);
        Q_ASSERT(sink->process == this && sink->type == Channel::PipeSink);
 
        if (!qt_create_pipe(source->pipe, /* in = */ false, TRUE)) { // source is stdout
            setErrorAndEmit(QProcess::FailedToStart, "pipe: "_L1 + qt_error_string(errno));
            return false;
        }
 
        sink->pipe[0] = source->pipe[0];
        source->pipe[0] = INVALID_Q_PIPE;
 
        return true;
    }
    case Channel::PipeSink: { // we are the sink;
        Q_ASSERT_X(channel.process, "QProcess::start", "Internal error");
        Channel *source = &channel.process->stdoutChannel;
        Channel *sink = &channel;
 
        if (sink->pipe[0] != INVALID_Q_PIPE) {
            // already constructed by the source
            return true;
        }
        Q_ASSERT(sink == &stdinChannel);
        Q_ASSERT(source->process == this && source->type == Channel::PipeSource);
 
        if (!qt_create_pipe(sink->pipe, /* in = */ true, TRUE)) { // sink is stdin
            setErrorAndEmit(QProcess::FailedToStart, "pipe: "_L1 + qt_error_string(errno));
            return false;
        }
 
        source->pipe[1] = sink->pipe[1];
        sink->pipe[1] = INVALID_Q_PIPE;
 
        return true;
    }
    } // switch (channel.type)
    return false;
}
 
void QProcessPrivate::destroyPipe(Q_PIPE pipe[2])
{
    if (pipe[0] != INVALID_Q_PIPE) {
        CloseHandle(pipe[0]);
        pipe[0] = INVALID_Q_PIPE;
    }
    if (pipe[1] != INVALID_Q_PIPE) {
        CloseHandle(pipe[1]);
        pipe[1] = INVALID_Q_PIPE;
    }
}
 
void QProcessPrivate::closeChannel(Channel *channel)
{
    if (channel == &stdinChannel) {
        delete channel->writer;
        channel->writer = nullptr;
    } else {
        delete channel->reader;
        channel->reader = nullptr;
    }
    destroyPipe(channel->pipe);
}
 
void QProcessPrivate::cleanup()
{
    q_func()->setProcessState(QProcess::NotRunning);
 
    closeChannels();
    delete processFinishedNotifier;
    processFinishedNotifier = nullptr;
    if (pid) {
        CloseHandle(pid->hThread);
        CloseHandle(pid->hProcess);
        delete pid;
        pid = nullptr;
    }
}
 
static QString qt_create_commandline(const QString &program, const QStringList &arguments,
                                     const QString &nativeArguments)
{
    QString args;
    if (!program.isEmpty()) {
        QString programName = program;
        if (!programName.startsWith(u'\"') && !programName.endsWith(u'\"') && programName.contains(u' '))
            programName = u'\"' + programName + u'\"';
        programName.replace(u'/', u'\\');
 
        // add the program as the first arg ... it works better
        args = programName + u' ';
    }
 
    for (qsizetype i = 0; i < arguments.size(); ++i) {
        QString tmp = arguments.at(i);
        // Quotes are escaped and their preceding backslashes are doubled.
        qsizetype index = tmp.indexOf(u'"');
        while (index >= 0) {
            // Escape quote
            tmp.insert(index++, u'\\');
            // Double preceding backslashes (ignoring the one we just inserted)
            for (qsizetype i = index - 2 ; i >= 0 && tmp.at(i) == u'\\' ; --i) {
                tmp.insert(i, u'\\');
                index++;
            }
            index = tmp.indexOf(u'"', index + 1);
        }
        if (tmp.isEmpty() || tmp.contains(u' ') || tmp.contains(u'\t')) {
            // The argument must not end with a \ since this would be interpreted
            // as escaping the quote -- rather put the \ behind the quote: e.g.
            // rather use "foo"\ than "foo\"
            qsizetype i = tmp.length();
            while (i > 0 && tmp.at(i - 1) == u'\\')
                --i;
            tmp.insert(i, u'"');
            tmp.prepend(u'"');
        }
        args += u' ' + tmp;
    }
 
    if (!nativeArguments.isEmpty()) {
        if (!args.isEmpty())
             args += u' ';
        args += nativeArguments;
    }
 
    return args;
}
 
static QByteArray qt_create_environment(const QProcessEnvironmentPrivate::Map &environment)
{
    QByteArray envlist;
    QProcessEnvironmentPrivate::Map copy = environment;
 
    // add PATH if necessary (for DLL loading)
    QProcessEnvironmentPrivate::Key pathKey("PATH"_L1);
    if (!copy.contains(pathKey)) {
        QByteArray path = qgetenv("PATH");
        if (!path.isEmpty())
            copy.insert(pathKey, QString::fromLocal8Bit(path));
    }
 
    // add systemroot if needed
    QProcessEnvironmentPrivate::Key rootKey("SystemRoot"_L1);
    if (!copy.contains(rootKey)) {
        QByteArray systemRoot = qgetenv("SystemRoot");
        if (!systemRoot.isEmpty())
            copy.insert(rootKey, QString::fromLocal8Bit(systemRoot));
    }
 
    qsizetype pos = 0;
    auto it = copy.constBegin();
    const auto end = copy.constEnd();
 
    static const wchar_t equal = L'=';
    static const wchar_t nul = L'\0';
 
    for (; it != end; ++it) {
        qsizetype tmpSize = sizeof(wchar_t) * (it.key().length() + it.value().length() + 2);
        // ignore empty strings
        if (tmpSize == sizeof(wchar_t) * 2)
            continue;
        envlist.resize(envlist.size() + tmpSize);
 
        tmpSize = it.key().length() * sizeof(wchar_t);
        memcpy(envlist.data() + pos, it.key().data(), tmpSize);
        pos += tmpSize;
 
        memcpy(envlist.data() + pos, &equal, sizeof(wchar_t));
        pos += sizeof(wchar_t);
 
        tmpSize = it.value().length() * sizeof(wchar_t);
        memcpy(envlist.data() + pos, it.value().data(), tmpSize);
        pos += tmpSize;
 
        memcpy(envlist.data() + pos, &nul, sizeof(wchar_t));
        pos += sizeof(wchar_t);
    }
    // add the 2 terminating 0 (actually 4, just to be on the safe side)
    envlist.resize(envlist.size() + 4);
    envlist[pos++] = 0;
    envlist[pos++] = 0;
    envlist[pos++] = 0;
    envlist[pos++] = 0;
 
    return envlist;
}
 
static Q_PIPE pipeOrStdHandle(Q_PIPE pipe, DWORD handleNumber)
{
    return pipe != INVALID_Q_PIPE ? pipe : GetStdHandle(handleNumber);
}
 
STARTUPINFOW QProcessPrivate::createStartupInfo()
{
    Q_PIPE stdinPipe = pipeOrStdHandle(stdinChannel.pipe[0], STD_INPUT_HANDLE);
    Q_PIPE stdoutPipe = pipeOrStdHandle(stdoutChannel.pipe[1], STD_OUTPUT_HANDLE);
    Q_PIPE stderrPipe = stderrChannel.pipe[1];
    if (stderrPipe == INVALID_Q_PIPE) {
        stderrPipe = (processChannelMode == QProcess::MergedChannels)
                     ? stdoutPipe
                     : GetStdHandle(STD_ERROR_HANDLE);
    }
 
    return STARTUPINFOW{
        sizeof(STARTUPINFOW), 0, 0, 0,
        (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
        (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
        0, 0, 0,
        STARTF_USESTDHANDLES,
        0, 0, 0,
        stdinPipe, stdoutPipe, stderrPipe
    };
}
 
bool QProcessPrivate::callCreateProcess(QProcess::CreateProcessArguments *cpargs)
{
    if (modifyCreateProcessArgs)
        modifyCreateProcessArgs(cpargs);
    bool success = CreateProcess(cpargs->applicationName, cpargs->arguments,
                                 cpargs->processAttributes, cpargs->threadAttributes,
                                 cpargs->inheritHandles, cpargs->flags, cpargs->environment,
                                 cpargs->currentDirectory, cpargs->startupInfo,
                                 cpargs->processInformation);
    if (!success) {
        // don't CloseHandle here (we'll do that in cleanup()) so GetLastError()
        // remains unmodified
        return false;
    }
 
    if (stdinChannel.pipe[0] != INVALID_Q_PIPE) {
        CloseHandle(stdinChannel.pipe[0]);
        stdinChannel.pipe[0] = INVALID_Q_PIPE;
    }
    if (stdoutChannel.pipe[1] != INVALID_Q_PIPE) {
        CloseHandle(stdoutChannel.pipe[1]);
        stdoutChannel.pipe[1] = INVALID_Q_PIPE;
    }
    if (stderrChannel.pipe[1] != INVALID_Q_PIPE) {
        CloseHandle(stderrChannel.pipe[1]);
        stderrChannel.pipe[1] = INVALID_Q_PIPE;
    }
    return success;
}
 
void QProcessPrivate::startProcess()
{
    Q_Q(QProcess);
 
    pid = new PROCESS_INFORMATION;
    memset(pid, 0, sizeof(PROCESS_INFORMATION));
 
    q->setProcessState(QProcess::Starting);
 
    if (!openChannels()) {
        // openChannel sets the error string
        Q_ASSERT(!errorString.isEmpty());
        cleanup();
        return;
    }
 
    QString args = qt_create_commandline(program, arguments, nativeArguments);
    QByteArray envlist;
    if (!environment.inheritsFromParent())
        envlist = qt_create_environment(environment.d.constData()->vars);
 
#if defined QPROCESS_DEBUG
    qDebug("Creating process");
    qDebug("   program : [%s]", program.toLatin1().constData());
    qDebug("   args : %s", args.toLatin1().constData());
    qDebug("   pass environment : %s", environment.isEmpty() ? "no" : "yes");
#endif
 
    // We cannot unconditionally set the CREATE_NO_WINDOW flag, because this
    // will render the stdout/stderr handles connected to a console useless
    // (this typically affects ForwardedChannels mode).
    // However, we also do not want console tools launched from a GUI app to
    // create new console windows (behavior consistent with UNIX).
    DWORD dwCreationFlags = (GetConsoleWindow() ? 0 : CREATE_NO_WINDOW);
    dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
    STARTUPINFOW startupInfo = createStartupInfo();
    const QString nativeWorkingDirectory = QDir::toNativeSeparators(workingDirectory);
    QProcess::CreateProcessArguments cpargs = {
        nullptr, reinterpret_cast<wchar_t *>(args.data_ptr().data()),
        nullptr, nullptr, true, dwCreationFlags,
        environment.inheritsFromParent() ? nullptr : envlist.data(),
        nativeWorkingDirectory.isEmpty()
            ? nullptr : reinterpret_cast<const wchar_t *>(nativeWorkingDirectory.utf16()),
        &startupInfo, pid
    };
 
    if (!callCreateProcess(&cpargs)) {
        // Capture the error string before we do CloseHandle below
        QString errorString = qt_error_string();
        cleanup();
        setErrorAndEmit(QProcess::FailedToStart,
                        QProcess::tr("Process failed to start: %1").arg(errorString));
        return;
    }
 
    // The pipe writer may have already been created before we had
    // the pipe handle, specifically if the user wrote data from the
    // stateChanged() slot.
    if (stdinChannel.writer)
        stdinChannel.writer->setHandle(stdinChannel.pipe[1]);
 
    q->setProcessState(QProcess::Running);
    // User can call kill()/terminate() from the stateChanged() slot
    // so check before proceeding
    if (!pid)
        return;
 
    if (threadData.loadRelaxed()->hasEventDispatcher()) {
        processFinishedNotifier = new QWinEventNotifier(pid->hProcess, q);
        QObjectPrivate::connect(processFinishedNotifier, &QWinEventNotifier::activated, this,
                                &QProcessPrivate::_q_processDied);
 
        processFinishedNotifier->setEnabled(true);
    }
 
    _q_startupNotification();
}
 
bool QProcessPrivate::processStarted(QString * /*errorMessage*/)
{
    return processState == QProcess::Running;
}
 
qint64 QProcessPrivate::bytesAvailableInChannel(const Channel *channel) const
{
    Q_ASSERT(channel->pipe[0] != INVALID_Q_PIPE);
    Q_ASSERT(channel->reader);
 
    DWORD bytesAvail = channel->reader->bytesAvailable();
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::bytesAvailableInChannel(%d) == %lld",
           int(channel - &stdinChannel), qint64(bytesAvail));
#endif
    return bytesAvail;
}
 
qint64 QProcessPrivate::readFromChannel(const Channel *channel, char *data, qint64 maxlen)
{
    Q_ASSERT(channel->pipe[0] != INVALID_Q_PIPE);
    Q_ASSERT(channel->reader);
    return channel->reader->read(data, maxlen);
}
 
static BOOL QT_WIN_CALLBACK qt_terminateApp(HWND hwnd, LPARAM procId)
{
    DWORD currentProcId = 0;
    GetWindowThreadProcessId(hwnd, &currentProcId);
    if (currentProcId == (DWORD)procId)
        PostMessage(hwnd, WM_CLOSE, 0, 0);
 
    return TRUE;
}
 
void QProcessPrivate::terminateProcess()
{
    if (pid) {
        EnumWindows(qt_terminateApp, (LPARAM)pid->dwProcessId);
        PostThreadMessage(pid->dwThreadId, WM_CLOSE, 0, 0);
    }
}
 
void QProcessPrivate::killProcess()
{
    if (pid)
        TerminateProcess(pid->hProcess, KillProcessExitCode);
}
 
bool QProcessPrivate::waitForStarted(const QDeadlineTimer &)
{
    if (processStarted())
        return true;
 
    if (processError == QProcess::FailedToStart)
        return false;
 
    setError(QProcess::Timedout);
    return false;
}
 
bool QProcessPrivate::drainOutputPipes()
{
    bool readyReadEmitted = false;
 
    if (stdoutChannel.reader) {
        stdoutChannel.reader->drainAndStop();
        readyReadEmitted = _q_canReadStandardOutput();
    }
    if (stderrChannel.reader) {
        stderrChannel.reader->drainAndStop();
        readyReadEmitted |= _q_canReadStandardError();
    }
 
    return readyReadEmitted;
}
 
bool QProcessPrivate::waitForReadyRead(const QDeadlineTimer &deadline)
{
    forever {
        QProcessPoller poller(*this);
        int ret = poller.poll(deadline);
        if (ret < 0)
            return false;
        if (ret == 0)
            break;
 
        if (stdinChannel.writer)
            stdinChannel.writer->checkForWrite();
 
        if ((stdoutChannel.reader && stdoutChannel.reader->checkForReadyRead())
            || (stderrChannel.reader && stderrChannel.reader->checkForReadyRead()))
            return true;
 
        if (!pid)
            return false;
 
        if (WaitForSingleObject(pid->hProcess, 0) == WAIT_OBJECT_0) {
            bool readyReadEmitted = drainOutputPipes();
            if (pid)
                processFinished();
            return readyReadEmitted;
        }
    }
 
    setError(QProcess::Timedout);
    return false;
}
 
bool QProcessPrivate::waitForBytesWritten(const QDeadlineTimer &deadline)
{
    forever {
        // At entry into the loop the pipe writer's buffer can be empty to
        // start with, in which case we fail immediately. Also, if the input
        // pipe goes down somewhere in the code below, we avoid waiting for
        // a full timeout.
        if (!stdinChannel.writer || !stdinChannel.writer->isWriteOperationActive())
            return false;
 
        QProcessPoller poller(*this);
        int ret = poller.poll(deadline);
        if (ret < 0)
            return false;
        if (ret == 0)
            break;
 
        if (stdinChannel.writer->checkForWrite())
            return true;
 
        // If we wouldn't write anything, check if we can read stdout.
        if (stdoutChannel.reader)
            stdoutChannel.reader->checkForReadyRead();
 
        // Check if we can read stderr.
        if (stderrChannel.reader)
            stderrChannel.reader->checkForReadyRead();
 
        // Check if the process died while reading.
        if (!pid)
            return false;
 
        // Check if the process is signaling completion.
        if (WaitForSingleObject(pid->hProcess, 0) == WAIT_OBJECT_0) {
            drainOutputPipes();
            if (pid)
                processFinished();
            return false;
        }
    }
 
    setError(QProcess::Timedout);
    return false;
}
 
bool QProcessPrivate::waitForFinished(const QDeadlineTimer &deadline)
{
#if defined QPROCESS_DEBUG
    qDebug("QProcessPrivate::waitForFinished(%lld)", deadline.remainingTime());
#endif
 
    forever {
        QProcessPoller poller(*this);
        int ret = poller.poll(deadline);
        if (ret < 0)
            return false;
        if (ret == 0)
            break;
 
        if (stdinChannel.writer)
            stdinChannel.writer->checkForWrite();
        if (stdoutChannel.reader)
            stdoutChannel.reader->checkForReadyRead();
        if (stderrChannel.reader)
            stderrChannel.reader->checkForReadyRead();
 
        if (!pid)
            return true;
 
        if (WaitForSingleObject(pid->hProcess, 0) == WAIT_OBJECT_0) {
            drainOutputPipes();
            if (pid)
                processFinished();
            return true;
        }
    }
 
    setError(QProcess::Timedout);
    return false;
}
 
void QProcessPrivate::findExitCode()
{
    DWORD theExitCode;
    Q_ASSERT(pid);
    if (GetExitCodeProcess(pid->hProcess, &theExitCode)) {
        exitCode = theExitCode;
        if (exitCode == KillProcessExitCode
                || (theExitCode >= 0x80000000 && theExitCode < 0xD0000000))
            exitStatus = QProcess::CrashExit;
        else
            exitStatus = QProcess::NormalExit;
    }
}
 
/*! \reimp
    \internal
*/
qint64 QProcess::writeData(const char *data, qint64 len)
{
    Q_D(QProcess);
 
    if (d->stdinChannel.closed) {
#if defined QPROCESS_DEBUG
        qDebug("QProcess::writeData(%p \"%s\", %lld) == 0 (write channel closing)",
               data, QtDebugUtils::toPrintable(data, len, 16).constData(), len);
#endif
        return 0;
    }
 
    if (!d->stdinChannel.writer) {
        d->stdinChannel.writer = new QWindowsPipeWriter(d->stdinChannel.pipe[1], this);
        QObjectPrivate::connect(d->stdinChannel.writer, &QWindowsPipeWriter::bytesWritten,
                                d, &QProcessPrivate::_q_bytesWritten);
        QObjectPrivate::connect(d->stdinChannel.writer, &QWindowsPipeWriter::writeFailed,
                                d, &QProcessPrivate::_q_writeFailed);
    }
 
    if (d->isWriteChunkCached(data, len))
        d->stdinChannel.writer->write(*(d->currentWriteChunk));
    else
        d->stdinChannel.writer->write(data, len);
 
#if defined QPROCESS_DEBUG
    qDebug("QProcess::writeData(%p \"%s\", %lld) == %lld (written to buffer)",
           data, QtDebugUtils::toPrintable(data, len, 16).constData(), len, len);
#endif
    return len;
}
 
qint64 QProcessPrivate::pipeWriterBytesToWrite() const
{
    return stdinChannel.writer ? stdinChannel.writer->bytesToWrite() : qint64(0);
}
 
void QProcessPrivate::_q_bytesWritten(qint64 bytes)
{
    Q_Q(QProcess);
 
    if (!emittedBytesWritten) {
        QScopedValueRollback<bool> guard(emittedBytesWritten, true);
        emit q->bytesWritten(bytes);
    }
    if (stdinChannel.closed && pipeWriterBytesToWrite() == 0)
        closeWriteChannel();
}
 
void QProcessPrivate::_q_writeFailed()
{
    closeWriteChannel();
    setErrorAndEmit(QProcess::WriteError);
}
 
// Use ShellExecuteEx() to trigger an UAC prompt when CreateProcess()fails
// with ERROR_ELEVATION_REQUIRED.
static bool startDetachedUacPrompt(const QString &programIn, const QStringList &arguments,
                                   const QString &nativeArguments,
                                   const QString &workingDir, qint64 *pid)
{
    const QString args = qt_create_commandline(QString(),                   // needs arguments only
                                               arguments, nativeArguments);
    SHELLEXECUTEINFOW shellExecuteExInfo;
    memset(&shellExecuteExInfo, 0, sizeof(SHELLEXECUTEINFOW));
    shellExecuteExInfo.cbSize = sizeof(SHELLEXECUTEINFOW);
    shellExecuteExInfo.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_UNICODE | SEE_MASK_FLAG_NO_UI | SEE_MASK_CLASSNAME;
    shellExecuteExInfo.lpClass = L"exefile";
    shellExecuteExInfo.lpVerb = L"runas";
    const QString program = QDir::toNativeSeparators(programIn);
    shellExecuteExInfo.lpFile = reinterpret_cast<LPCWSTR>(program.utf16());
    if (!args.isEmpty())
        shellExecuteExInfo.lpParameters = reinterpret_cast<LPCWSTR>(args.utf16());
    if (!workingDir.isEmpty())
        shellExecuteExInfo.lpDirectory = reinterpret_cast<LPCWSTR>(workingDir.utf16());
    shellExecuteExInfo.nShow = SW_SHOWNORMAL;
 
    if (!ShellExecuteExW(&shellExecuteExInfo))
        return false;
    if (pid)
        *pid = qint64(GetProcessId(shellExecuteExInfo.hProcess));
    CloseHandle(shellExecuteExInfo.hProcess);
    return true;
}
 
bool QProcessPrivate::startDetached(qint64 *pid)
{
    static const DWORD errorElevationRequired = 740;
 
    if (!openChannelsForDetached()) {
        // openChannel sets the error string
        closeChannels();
        return false;
    }
 
    QString args = qt_create_commandline(program, arguments, nativeArguments);
    bool success = false;
    PROCESS_INFORMATION pinfo;
 
    void *envPtr = nullptr;
    QByteArray envlist;
    if (!environment.inheritsFromParent()) {
        envlist = qt_create_environment(environment.d.constData()->vars);
        envPtr = envlist.data();
    }
 
    DWORD dwCreationFlags = (GetConsoleWindow() ? 0 : CREATE_NO_WINDOW);
    dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
    STARTUPINFOW startupInfo = createStartupInfo();
    QProcess::CreateProcessArguments cpargs = {
        nullptr, reinterpret_cast<wchar_t *>(args.data_ptr().data()),
        nullptr, nullptr, true, dwCreationFlags, envPtr,
        workingDirectory.isEmpty()
            ? nullptr : reinterpret_cast<const wchar_t *>(workingDirectory.utf16()),
        &startupInfo, &pinfo
    };
    success = callCreateProcess(&cpargs);
 
    if (success) {
        CloseHandle(pinfo.hThread);
        CloseHandle(pinfo.hProcess);
        if (pid)
            *pid = pinfo.dwProcessId;
    } else if (GetLastError() == errorElevationRequired) {
        if (envPtr)
            qWarning("QProcess: custom environment will be ignored for detached elevated process.");
        if (!stdinChannel.file.isEmpty() || !stdoutChannel.file.isEmpty()
                || !stderrChannel.file.isEmpty()) {
            qWarning("QProcess: file redirection is unsupported for detached elevated processes.");
        }
        success = startDetachedUacPrompt(program, arguments, nativeArguments,
                                         workingDirectory, pid);
    }
    if (!success) {
        if (pid)
            *pid = -1;
        QString errorString = qt_error_string();
        setErrorAndEmit(QProcess::FailedToStart,
                        QProcess::tr("Process failed to start: %1").arg(errorString));
    }
 
    closeChannels();
    return success;
}
 
#endif // QT_CONFIG(process)
 
QT_END_NAMESPACE