qint64 QProcessPrivate::readFromStdout(char *data, qint64 maxlen)
{
DWORD read = qMin(maxlen, bytesAvailableFromStdout());
DWORD bytesRead = 0;
if (read > 0 && !ReadFile(stdoutChannel.pipe[0], data, read, &bytesRead, 0))
return -1;
return bytesRead;
}
bool QProcessPrivate::waitForReadyRead(int msecs)
{
Q_Q(QProcess);
#if defined(Q_OS_WINCE)
processError = QProcess::ReadError;
q->setErrorString(QProcess::tr("Error reading from process"));
emit q->error(processError);
return false;
#endif
QIncrementalSleepTimer timer(msecs);
forever {
if (!writeBuffer.isEmpty() && !_q_canWrite())
return false;
if (pipeWriter && pipeWriter->waitForWrite(0))
timer.resetIncrements();
bool readyReadEmitted = false;
if (bytesAvailableFromStdout() != 0) {
readyReadEmitted = _q_canReadStandardOutput() ? true : readyReadEmitted;
timer.resetIncrements();
}
if (bytesAvailableFromStderr() != 0) {
readyReadEmitted = _q_canReadStandardError() ? true : readyReadEmitted;
timer.resetIncrements();
}
if (readyReadEmitted)
return true;
if (!pid)
return false;
if (WaitForSingleObject(pid->hProcess, 0) == WAIT_OBJECT_0) {
// find the return value if there is noew data to read
_q_processDied();
return false;
}
Sleep(timer.nextSleepTime());
if (timer.hasTimedOut())
break;
}
processError = QProcess::Timedout;
q->setErrorString(QProcess::tr("Process operation timed out"));
return false;
}
void QProcessPrivate::_q_notified()
{
notifier->stop();
if (!writeBuffer.isEmpty() && (!pipeWriter || pipeWriter->waitForWrite(0)))
_q_canWrite();
if (bytesAvailableFromStdout())
_q_canReadStandardOutput();
if (bytesAvailableFromStderr())
_q_canReadStandardError();
if (processState != QProcess::NotRunning)
notifier->start(NOTIFYTIMEOUT);
}
/*! \internal
*/
bool QProcessPrivate::canReadStandardOutput()
{
Q_Q(QProcess);
qint64 available = bytesAvailableFromStdout();
if (available == 0) {
if (standardReadSocketNotifier)
standardReadSocketNotifier->setEnabled(false);
destroyPipe(standardReadPipe);
return false;
}
char *ptr = outputReadBuffer.reserve(available);
qint64 readBytes = readFromStdout(ptr, available);
if (readBytes == -1) {
processError = QProcess::ReadError;
q->setErrorString(QT_TRANSLATE_NOOP(QProcess, QLatin1String("Error reading from process")));
emit q->error(processError);
return false;
}
if (standardOutputClosed) {
outputReadBuffer.truncate(readBytes);
return false;
}
outputReadBuffer.truncate(available - readBytes);
bool didRead = false;
if (readBytes == 0) {
if (standardReadSocketNotifier)
standardReadSocketNotifier->setEnabled(false);
} else if (processChannel == QProcess::StandardOutput) {
didRead = true;
if (!emittedReadyRead) {
emittedReadyRead = true;
emit q->readyRead();
emittedReadyRead = false;
}
}
emit q->readyReadStandardOutput();
return didRead;
}
bool QProcessPrivate::waitForFinished(int msecs)
{
Q_Q(QProcess);
#if defined QPROCESS_DEBUG
qDebug("QProcessPrivate::waitForFinished(%d)", msecs);
#endif
QIncrementalSleepTimer timer(msecs);
forever {
if (!writeBuffer.isEmpty() && !_q_canWrite())
return false;
if (pipeWriter && pipeWriter->waitForWrite(0))
timer.resetIncrements();
if (bytesAvailableFromStdout() != 0) {
_q_canReadStandardOutput();
timer.resetIncrements();
}
if (bytesAvailableFromStderr() != 0) {
_q_canReadStandardError();
timer.resetIncrements();
}
if (!pid)
return true;
if (WaitForSingleObject(pid->hProcess, timer.nextSleepTime()) == WAIT_OBJECT_0) {
_q_processDied();
return true;
}
if (timer.hasTimedOut())
break;
}
processError = QProcess::Timedout;
q->setErrorString(QProcess::tr("Process operation timed out"));
return false;
}
bool QProcessPrivate::waitForBytesWritten(int msecs)
{
Q_Q(QProcess);
QIncrementalSleepTimer timer(msecs);
forever {
// Check if we have any data pending: the pipe writer has
// bytes waiting to written, or it has written data since the
// last time we called pipeWriter->waitForWrite().
bool pendingDataInPipe = pipeWriter && (pipeWriter->bytesToWrite() || pipeWriter->hadWritten());
// If we don't have pending data, and our write buffer is
// empty, we fail.
if (!pendingDataInPipe && writeBuffer.isEmpty())
return false;
// If we don't have pending data and we do have data in our
// write buffer, try to flush that data over to the pipe
// writer. Fail on error.
if (!pendingDataInPipe) {
if (!_q_canWrite())
return false;
}
// Wait for the pipe writer to acknowledge that it has
// written. This will succeed if either the pipe writer has
// already written the data, or if it manages to write data
// within the given timeout. If the write buffer was non-empty
// and the pipeWriter is now dead, that means _q_canWrite()
// destroyed the writer after it successfully wrote the last
// batch.
if (!pipeWriter || pipeWriter->waitForWrite(0))
return true;
// If we wouldn't write anything, check if we can read stdout.
if (bytesAvailableFromStdout() != 0) {
_q_canReadStandardOutput();
timer.resetIncrements();
}
// Check if we can read stderr.
if (bytesAvailableFromStderr() != 0) {
_q_canReadStandardError();
timer.resetIncrements();
}
// Check if the process died while reading.
if (!pid)
return false;
// Wait for the process to signal any change in its state,
// such as incoming data, or if the process died.
if (WaitForSingleObject(pid->hProcess, 0) == WAIT_OBJECT_0) {
_q_processDied();
return false;
}
// Only wait for as long as we've been asked.
if (timer.hasTimedOut())
break;
}
processError = QProcess::Timedout;
q->setErrorString(QProcess::tr("Process operation timed out"));
return false;
}