/*! \internal
*/
void QProcessPrivate::cleanup()
{
processState = QProcess::NotRunning;
#ifdef Q_OS_WIN
if (pid) {
CloseHandle(pid->hThread);
CloseHandle(pid->hProcess);
delete pid;
pid = 0;
}
if (processFinishedNotifier) {
processFinishedNotifier->setEnabled(false);
delete processFinishedNotifier;
processFinishedNotifier = 0;
}
#endif
pid = 0;
sequenceNumber = 0;
if (standardReadSocketNotifier) {
standardReadSocketNotifier->setEnabled(false);
delete standardReadSocketNotifier;
standardReadSocketNotifier = 0;
}
if (errorReadSocketNotifier) {
errorReadSocketNotifier->setEnabled(false);
delete errorReadSocketNotifier;
errorReadSocketNotifier = 0;
}
if (writeSocketNotifier) {
writeSocketNotifier->setEnabled(false);
delete writeSocketNotifier;
writeSocketNotifier = 0;
}
if (startupSocketNotifier) {
startupSocketNotifier->setEnabled(false);
delete startupSocketNotifier;
startupSocketNotifier = 0;
}
if (deathNotifier) {
deathNotifier->setEnabled(false);
delete deathNotifier;
deathNotifier = 0;
}
if (notifier) {
delete notifier;
notifier = 0;
}
destroyPipe(standardReadPipe);
destroyPipe(errorReadPipe);
destroyPipe(writePipe);
destroyPipe(childStartedPipe);
destroyPipe(deathPipe);
#ifdef Q_OS_UNIX
serial = 0;
#endif
}
/*! \internal
*/
bool QProcessPrivate::canWrite()
{
Q_Q(QProcess);
#if defined QPROCESS_DEBUG
qDebug("QProcessPrivate::canWrite()");
#endif
if (writeSocketNotifier)
writeSocketNotifier->setEnabled(false);
if (writeBuffer.isEmpty())
return false;
qint64 written = writeToStdin(writeBuffer.readPointer(),
writeBuffer.nextDataBlockSize());
if (written < 0) {
destroyPipe(writePipe);
processError = QProcess::WriteError;
q->setErrorString(QT_TRANSLATE_NOOP(QProcess, QLatin1String("Error writing to process")));
emit q->error(processError);
return false;
}
writeBuffer.free(written);
if (!emittedBytesWritten) {
emittedBytesWritten = true;
emit q->bytesWritten(written);
emittedBytesWritten = false;
}
if (writeSocketNotifier && !writeBuffer.isEmpty())
writeSocketNotifier->setEnabled(true);
if (writeBuffer.isEmpty() && writeChannelClosing)
closeWriteChannel();
return true;
}
void QProcessPrivate::closeChannel(Channel *channel)
{
if (channel == &stdinChannel) {
delete stdinChannel.writer;
stdinChannel.writer = 0;
} else if (channel->reader) {
channel->reader->stop();
channel->reader->deleteLater();
channel->reader = 0;
}
destroyPipe(channel->pipe);
}
/*! \internal
*/
void QProcessPrivate::closeWriteChannel()
{
#if defined QPROCESS_DEBUG
qDebug("QProcessPrivate::closeWriteChannel()");
#endif
if (writeSocketNotifier) {
writeSocketNotifier->setEnabled(false);
delete writeSocketNotifier;
writeSocketNotifier = 0;
}
destroyPipe(writePipe);
}
void QProcessPrivate::destroyChannel(Channel *channel)
{
if (channel == &stdinChannel) {
if (pipeWriter) {
delete pipeWriter;
pipeWriter = 0;
}
} else if (channel == &stdoutChannel) {
if (stdoutReader) {
stdoutReader->deleteLater();
stdoutReader = 0;
}
} else if (channel == &stderrChannel) {
if (stderrReader) {
stderrReader->deleteLater();
stderrReader = 0;
}
}
destroyPipe(channel->pipe);
}
/*! \internal
*/
bool QProcessPrivate::canReadStandardError()
{
Q_Q(QProcess);
qint64 available = bytesAvailableFromStderr();
if (available == 0) {
if (errorReadSocketNotifier)
errorReadSocketNotifier->setEnabled(false);
destroyPipe(errorReadPipe);
return false;
}
char *ptr = errorReadBuffer.reserve(available);
qint64 readBytes = readFromStderr(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 (standardErrorClosed) {
errorReadBuffer.truncate(readBytes);
return false;
}
errorReadBuffer.truncate(available - readBytes);
bool didRead = false;
if (readBytes == 0) {
if (errorReadSocketNotifier)
errorReadSocketNotifier->setEnabled(false);
} else if (processChannel == QProcess::StandardError) {
didRead = true;
if (!emittedReadyRead) {
emittedReadyRead = true;
emit q->readyRead();
emittedReadyRead = false;
}
}
emit q->readyReadStandardError();
return didRead;
}
void QProcessPrivate::closeChannel(Channel *channel)
{
destroyPipe(channel->pipe);
}
