#include <qprocess_p.h>

Inheritance diagram for QProcessPrivate:

Classes
struct	Channel

Public Functions
bool	_q_canReadStandardError ()

bool	_q_canReadStandardOutput ()

bool	_q_canWrite ()

void	_q_notified ()

bool	_q_processDied ()

bool	_q_startupNotification ()

qint64	bytesAvailableFromStderr () const

qint64	bytesAvailableFromStdout () const

void	cleanup ()

void	closeWriteChannel ()

bool	createChannel (Channel &channel)

void	destroyPipe (Q_PIPE pipe[2])

void	execChild (const char workingDirectory, char path, char argv, char *envp)

void	findExitCode ()

void	flushPipeWriter ()

void	killProcess ()

qint64	pipeWriterBytesToWrite () const

bool	processStarted ()

	QProcessPrivate ()

qint64	readFromStderr (char *data, qint64 maxlen)

qint64	readFromStdout (char *data, qint64 maxlen)

void	startProcess ()

void	terminateProcess ()

bool	waitForBytesWritten (int msecs=30000)

bool	waitForDeadChild ()

bool	waitForFinished (int msecs=30000)

bool	waitForReadyRead (int msecs=30000)

bool	waitForStarted (int msecs=30000)

bool	waitForWrite (int msecs=30000)

qint64	writeToStdin (const char *data, qint64 maxlen)

virtual	~QProcessPrivate ()

Public Functions inherited from QIODevicePrivate
bool	isSequential () const

virtual qint64	peek (char *data, qint64 maxSize)

virtual QByteArray	peek (qint64 maxSize)

virtual bool	putCharHelper (char c)

	QIODevicePrivate ()

virtual	~QIODevicePrivate ()

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Static Public Functions
static void	initializeProcessManager ()

static bool	startDetached (const QString &program, const QStringList &arguments, const QString &workingDirectory=QString(), qint64 *pid=0)

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Public Variables
QStringList	arguments

Q_PIPE	childStartedPipe [2]

bool	crashed

QSocketNotifier *	deathNotifier

Q_PIPE	deathPipe [2]

bool	dying

bool	emittedBytesWritten

bool	emittedReadyRead

QProcessEnvironment	environment

QRingBuffer	errorReadBuffer

int	exitCode

QProcess::ExitStatus	exitStatus

QString	nativeArguments

QTimer *	notifier

QRingBuffer	outputReadBuffer

Q_PID	pid

QWindowsPipeWriter *	pipeWriter

QProcess::ProcessChannel	processChannel

QProcess::ProcessChannelMode	processChannelMode

QProcess::ProcessError	processError

QWinEventNotifier *	processFinishedNotifier

QProcess::ProcessState	processState

QString	program

int	sequenceNumber

int	serial

QSocketNotifier *	startupSocketNotifier

Channel	stderrChannel

Channel	stdinChannel

Channel	stdoutChannel

QString	workingDirectory

QRingBuffer	writeBuffer

Public Variables inherited from QIODevicePrivate
AccessMode	accessMode

bool	baseReadLineDataCalled

QIODevicePrivateLinearBuffer	buffer

qint64	devicePos

QString	errorString

bool	firstRead

QIODevice::OpenMode	openMode

qint64 *	pDevicePos

qint64	pos

qint64 *	pPos

qint64	seqDumpPos

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QIODevicePrivate
enum	AccessMode { Unset, Sequential, RandomAccess }

Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Detailed Description

Definition at line 240 of file qprocess_p.h.

Constructors and Destructors

◆ QProcessPrivate()

QProcessPrivate::QProcessPrivate ( )

Warning: This function is not part of the public interface.

Definition at line 820 of file qprocess.cpp.

 {
     processChannel = QProcess::StandardOutput;
     processChannelMode = QProcess::SeparateChannels;
     processError = QProcess::UnknownError;
     processState = QProcess::NotRunning;
     pid = 0;
     sequenceNumber = 0;
     exitCode = 0;
     exitStatus = QProcess::NormalExit;
     startupSocketNotifier = 0;
     deathNotifier = 0;
     notifier = 0;
     pipeWriter = 0;
     childStartedPipe[0] = INVALID_Q_PIPE;
     childStartedPipe[1] = INVALID_Q_PIPE;
     deathPipe[0] = INVALID_Q_PIPE;
     deathPipe[1] = INVALID_Q_PIPE;
     exitCode = 0;
     crashed = false;
     dying = false;
     emittedReadyRead = false;
     emittedBytesWritten = false;
 #ifdef Q_WS_WIN
     pipeWriter = 0;
     processFinishedNotifier = 0;
 #endif // Q_WS_WIN
 #ifdef Q_OS_UNIX
     serial = 0;
 #endif
 #ifdef Q_OS_SYMBIAN
     symbianProcess = NULL;
     processLaunched = false;
 #endif
 }

◆ ~QProcessPrivate()

QProcessPrivate::~QProcessPrivate ( )

virtual

Warning: This function is not part of the public interface.

Definition at line 858 of file qprocess.cpp.

 {
     if (stdinChannel.process)
         stdinChannel.process->stdoutChannel.clear();
     if (stdoutChannel.process)
         stdoutChannel.process->stdinChannel.clear();
 }

Functions

◆ _q_canReadStandardError()

bool QProcessPrivate::_q_canReadStandardError ( )

Warning: This function is not part of the public interface.

Definition at line 992 of file qprocess.cpp.

Referenced by pipeWriterBytesToWrite(), and qt_terminateApp().

 {
     Q_Q(QProcess);
     qint64 available = bytesAvailableFromStderr();
     if (available == 0) {
         if (stderrChannel.notifier)
             stderrChannel.notifier->setEnabled(false);
         destroyPipe(stderrChannel.pipe);
         return false;
     }
 
     char *ptr = errorReadBuffer.reserve(available);
     qint64 readBytes = readFromStderr(ptr, available);
     if (readBytes == -1) {
         processError = QProcess::ReadError;
         q->setErrorString(QProcess::tr("Error reading from process"));
         emit q->error(processError);
         return false;
     }
     if (stderrChannel.closed) {
         errorReadBuffer.chop(readBytes);
         return false;
     }
 
     errorReadBuffer.chop(available - readBytes);
 
     bool didRead = false;
     if (readBytes == 0) {
         if (stderrChannel.notifier)
             stderrChannel.notifier->setEnabled(false);
     } else if (processChannel == QProcess::StandardError) {
         didRead = true;
         if (!emittedReadyRead) {
             emittedReadyRead = true;
             emit q->readyRead();
             emittedReadyRead = false;
         }
     }
     emit q->readyReadStandardError();
     return didRead;
 }

◆ _q_canReadStandardOutput()

bool QProcessPrivate::_q_canReadStandardOutput ( )

Warning: This function is not part of the public interface.

Definition at line 937 of file qprocess.cpp.

Referenced by pipeWriterBytesToWrite(), and qt_terminateApp().

 {
     Q_Q(QProcess);
     qint64 available = bytesAvailableFromStdout();
     if (available == 0) {
         if (stdoutChannel.notifier)
             stdoutChannel.notifier->setEnabled(false);
         destroyPipe(stdoutChannel.pipe);
 #if defined QPROCESS_DEBUG
         qDebug("QProcessPrivate::canReadStandardOutput(), 0 bytes available");
 #endif
         return false;
     }
 
     char *ptr = outputReadBuffer.reserve(available);
     qint64 readBytes = readFromStdout(ptr, available);
     if (readBytes == -1) {
         processError = QProcess::ReadError;
         q->setErrorString(QProcess::tr("Error reading from process"));
         emit q->error(processError);
 #if defined QPROCESS_DEBUG
         qDebug("QProcessPrivate::canReadStandardOutput(), failed to read from the process");
 #endif
         return false;
     }
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::canReadStandardOutput(), read %d bytes from the process' output",
             int(readBytes));
 #endif
 
     if (stdoutChannel.closed) {
         outputReadBuffer.chop(readBytes);
         return false;
     }
 
     outputReadBuffer.chop(available - readBytes);
 
     bool didRead = false;
     if (readBytes == 0) {
         if (stdoutChannel.notifier)
             stdoutChannel.notifier->setEnabled(false);
     } else if (processChannel == QProcess::StandardOutput) {
         didRead = true;
         if (!emittedReadyRead) {
             emittedReadyRead = true;
             emit q->readyRead();
             emittedReadyRead = false;
         }
     }
     emit q->readyReadStandardOutput();
     return didRead;
 }

◆ _q_canWrite()

bool QProcessPrivate::_q_canWrite ( )

Warning: This function is not part of the public interface.

Definition at line 1036 of file qprocess.cpp.

Referenced by pipeWriterBytesToWrite(), and qt_terminateApp().

 {
     Q_Q(QProcess);
     if (stdinChannel.notifier)
         stdinChannel.notifier->setEnabled(false);
 
     if (writeBuffer.isEmpty()) {
 #if defined QPROCESS_DEBUG
         qDebug("QProcessPrivate::canWrite(), not writing anything (empty write buffer).");
 #endif
         return false;
     }
 
     qint64 written = writeToStdin(writeBuffer.readPointer(),
                                       writeBuffer.nextDataBlockSize());
     if (written < 0) {
         destroyPipe(stdinChannel.pipe);
         processError = QProcess::WriteError;
         q->setErrorString(QProcess::tr("Error writing to process"));
         emit q->error(processError);
         return false;
     }
 
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::canWrite(), wrote %d bytes to the process input", int(written));
 #endif
 
     if (written != 0) {
         writeBuffer.free(written);
         if (!emittedBytesWritten) {
             emittedBytesWritten = true;
             emit q->bytesWritten(written);
             emittedBytesWritten = false;
         }
     }
     if (stdinChannel.notifier && !writeBuffer.isEmpty())
         stdinChannel.notifier->setEnabled(true);
     if (writeBuffer.isEmpty() && stdinChannel.closed)
         closeWriteChannel();
     return true;
 }

◆ _q_notified()

void QProcessPrivate::_q_notified ( )

Definition at line 1325 of file qprocess_unix.cpp.

Referenced by pipeWriterBytesToWrite(), and qt_create_commandline().

1326 {

1327 }

◆ _q_processDied()

bool QProcessPrivate::_q_processDied ( )

Warning: This function is not part of the public interface.

Definition at line 1080 of file qprocess.cpp.

Referenced by qt_create_commandline(), and qt_terminateApp().

 {
     Q_Q(QProcess);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::_q_processDied()");
 #endif
 #ifdef Q_OS_UNIX
     if (!waitForDeadChild())
         return false;
 #endif
 #ifdef Q_OS_WIN
     if (processFinishedNotifier)
         processFinishedNotifier->setEnabled(false);
 #endif
 
     // the process may have died before it got a chance to report that it was
     // either running or stopped, so we will call _q_startupNotification() and
     // give it a chance to emit started() or error(FailedToStart).
     if (processState == QProcess::Starting) {
         if (!_q_startupNotification())
             return true;
     }
 
     if (dying) {
         // at this point we know the process is dead. prevent
         // reentering this slot recursively by calling waitForFinished()
         // or opening a dialog inside slots connected to the readyRead
         // signals emitted below.
         return true;
     }
     dying = true;
 
     // in case there is data in the pipe line and this slot by chance
     // got called before the read notifications, call these two slots
     // so the data is made available before the process dies.
     _q_canReadStandardOutput();
     _q_canReadStandardError();
 
     findExitCode();
 
     if (crashed) {
         exitStatus = QProcess::CrashExit;
         processError = QProcess::Crashed;
         q->setErrorString(QProcess::tr("Process crashed"));
         emit q->error(processError);
     }
 
     bool wasRunning = (processState == QProcess::Running);
 
     cleanup();
 
     if (wasRunning) {
         // we received EOF now:
         emit q->readChannelFinished();
         // in the future:
         //emit q->standardOutputClosed();
         //emit q->standardErrorClosed();
 
         emit q->finished(exitCode);
         emit q->finished(exitCode, exitStatus);
     }
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::_q_processDied() process is dead");
 #endif
     return true;
 }

◆ _q_startupNotification()

bool QProcessPrivate::_q_startupNotification ( )

Warning: This function is not part of the public interface.

Definition at line 1149 of file qprocess.cpp.

Referenced by qt_create_commandline().

 {
     Q_Q(QProcess);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::startupNotification()");
 #endif
 
     if (startupSocketNotifier)
         startupSocketNotifier->setEnabled(false);
     if (processStarted()) {
         q->setProcessState(QProcess::Running);
         emit q->started();
         return true;
     }
 
     q->setProcessState(QProcess::NotRunning);
     processError = QProcess::FailedToStart;
     emit q->error(processError);
 #ifdef Q_OS_UNIX
     // make sure the process manager removes this entry
     waitForDeadChild();
     findExitCode();
 #endif
     cleanup();
     return false;
 }

◆ bytesAvailableFromStderr()

qint64 QProcessPrivate::bytesAvailableFromStderr ( ) const

Definition at line 963 of file qprocess_unix.cpp.

Referenced by pipeWriterBytesToWrite(), qt_create_commandline(), and qt_terminateApp().

 {
     int nbytes = 0;
     qint64 available = 0;
     if (::ioctl(stderrChannel.pipe[0], FIONREAD, (char *) &nbytes) >= 0)
         available = (qint64) nbytes;
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::bytesAvailableFromStderr() == %lld", available);
 #endif
     return available;
 }

◆ bytesAvailableFromStdout()

qint64 QProcessPrivate::bytesAvailableFromStdout ( ) const

Definition at line 951 of file qprocess_unix.cpp.

Referenced by pipeWriterBytesToWrite(), qt_create_commandline(), and qt_terminateApp().

 {
     int nbytes = 0;
     qint64 available = 0;
     if (::ioctl(stdoutChannel.pipe[0], FIONREAD, (char *) &nbytes) >= 0)
         available = (qint64) nbytes;
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::bytesAvailableFromStdout() == %lld", available);
 #endif
     return available;
 }

◆ cleanup()

void QProcessPrivate::cleanup ( )

Warning: This function is not part of the public interface.

Definition at line 868 of file qprocess.cpp.

Referenced by qt_create_commandline(), and qt_create_pipe().

 {
     q_func()->setProcessState(QProcess::NotRunning);
 #ifdef Q_OS_WIN
     if (pid) {
         CloseHandle(pid->hThread);
         CloseHandle(pid->hProcess);
         delete pid;
         pid = 0;
     }
     if (processFinishedNotifier) {
         processFinishedNotifier->setEnabled(false);
         qDeleteInEventHandler(processFinishedNotifier);
         processFinishedNotifier = 0;
     }
 
 #endif
     pid = 0;
     sequenceNumber = 0;
     dying = false;
 
     if (stdoutChannel.notifier) {
         stdoutChannel.notifier->setEnabled(false);
         qDeleteInEventHandler(stdoutChannel.notifier);
         stdoutChannel.notifier = 0;
     }
     if (stderrChannel.notifier) {
         stderrChannel.notifier->setEnabled(false);
         qDeleteInEventHandler(stderrChannel.notifier);
         stderrChannel.notifier = 0;
     }
     if (stdinChannel.notifier) {
         stdinChannel.notifier->setEnabled(false);
         qDeleteInEventHandler(stdinChannel.notifier);
         stdinChannel.notifier = 0;
     }
     if (startupSocketNotifier) {
         startupSocketNotifier->setEnabled(false);
         qDeleteInEventHandler(startupSocketNotifier);
         startupSocketNotifier = 0;
     }
     if (deathNotifier) {
         deathNotifier->setEnabled(false);
         qDeleteInEventHandler(deathNotifier);
         deathNotifier = 0;
     }
     if (notifier) {
         qDeleteInEventHandler(notifier);
         notifier = 0;
     }
     destroyPipe(stdoutChannel.pipe);
     destroyPipe(stderrChannel.pipe);
     destroyPipe(stdinChannel.pipe);
     destroyPipe(childStartedPipe);
     destroyPipe(deathPipe);
 #ifdef Q_OS_UNIX
     serial = 0;
 #endif
 #ifdef Q_OS_SYMBIAN
     if (symbianProcess) {
         symbianProcess->Close();
         delete symbianProcess;
         symbianProcess = NULL;
     }
 #endif
 }

◆ closeWriteChannel()

void QProcessPrivate::closeWriteChannel ( )

Warning: This function is not part of the public interface.

Definition at line 1178 of file qprocess.cpp.

 {
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::closeWriteChannel()");
 #endif
     if (stdinChannel.notifier) {
         extern void qDeleteInEventHandler(QObject *o);
         stdinChannel.notifier->setEnabled(false);
         if (stdinChannel.notifier) {
             qDeleteInEventHandler(stdinChannel.notifier);
             stdinChannel.notifier = 0;
         }
     }
 #ifdef Q_OS_WIN
     // ### Find a better fix, feeding the process little by little
     // instead.
     flushPipeWriter();
 #endif
     destroyPipe(stdinChannel.pipe);
 }

◆ createChannel()

bool QProcessPrivate::createChannel ( Channel & channel )

Definition at line 383 of file qprocess_unix.cpp.

Referenced by qt_create_commandline(), and qt_create_pipe().

 {
     Q_Q(QProcess);
 
     if (&channel == &stderrChannel && processChannelMode == QProcess::MergedChannels) {
         channel.pipe[0] = -1;
         channel.pipe[1] = -1;
         return true;
     }
 
     if (channel.type == Channel::Normal) {
         // we're piping this channel to our own process
         if (qt_create_pipe(channel.pipe) != 0)
             return false;
 
         // create the socket notifiers
         if (threadData->eventDispatcher) {
             if (&channel == &stdinChannel) {
                 channel.notifier = new QSocketNotifier(channel.pipe[1],
                                                        QSocketNotifier::Write, q);
                 channel.notifier->setEnabled(false);
                 QObject::connect(channel.notifier, SIGNAL(activated(int)),
                                  q, SLOT(_q_canWrite()));
             } else {
                 channel.notifier = new QSocketNotifier(channel.pipe[0],
                                                        QSocketNotifier::Read, q);
                 const char *receiver;
                 if (&channel == &stdoutChannel)
                     receiver = SLOT(_q_canReadStandardOutput());
                 else
                     receiver = SLOT(_q_canReadStandardError());
                 QObject::connect(channel.notifier, SIGNAL(activated(int)),
                                  q, receiver);
             }
         }
 
         return true;
     } else if (channel.type == Channel::Redirect) {
         // we're redirecting the channel to/from a file
         QByteArray fname = QFile::encodeName(channel.file);
 
         if (&channel == &stdinChannel) {
             // try to open in read-only mode
             channel.pipe[1] = -1;
             if ( (channel.pipe[0] = qt_safe_open(fname, O_RDONLY)) != -1)
                 return true;    // success
 
             q->setErrorString(QProcess::tr("Could not open input redirection for reading"));
         } else {
             int mode = O_WRONLY | O_CREAT;
             if (channel.append)
                 mode |= O_APPEND;
             else
                 mode |= O_TRUNC;
 
             channel.pipe[0] = -1;
             if ( (channel.pipe[1] = qt_safe_open(fname, mode, 0666)) != -1)
                 return true; // success
 
             q->setErrorString(QProcess::tr("Could not open output redirection for writing"));
         }
 
         // could not open file
         processError = QProcess::FailedToStart;
         emit q->error(processError);
         cleanup();
         return false;
     } else {
         Q_ASSERT_X(channel.process, "QProcess::start", "Internal error");
 
         Channel *source;
         Channel *sink;
 
         if (channel.type == Channel::PipeSource) {
             // we are the source
             source = &channel;
             sink = &channel.process->stdinChannel;
 
             Q_ASSERT(source == &stdoutChannel);
             Q_ASSERT(sink->process == this && sink->type == Channel::PipeSink);
         } else {
             // we are the sink;
             source = &channel.process->stdoutChannel;
             sink = &channel;
 
             Q_ASSERT(sink == &stdinChannel);
             Q_ASSERT(source->process == this && source->type == Channel::PipeSource);
         }
 
         if (source->pipe[1] != INVALID_Q_PIPE || sink->pipe[0] != INVALID_Q_PIPE) {
             // already created, do nothing
             return true;
         } else {
             Q_ASSERT(source->pipe[0] == INVALID_Q_PIPE && source->pipe[1] == INVALID_Q_PIPE);
             Q_ASSERT(sink->pipe[0] == INVALID_Q_PIPE && sink->pipe[1] == INVALID_Q_PIPE);
 
             Q_PIPE pipe[2] = { -1, -1 };
             if (qt_create_pipe(pipe) != 0)
                 return false;
             sink->pipe[0] = pipe[0];
             source->pipe[1] = pipe[1];
 
             return true;
         }
     }
 }

◆ destroyPipe()

void QProcessPrivate::destroyPipe ( Q_PIPE pipe[2] )

Definition at line 366 of file qprocess_unix.cpp.

Referenced by qt_create_pipe().

 {
     if (pipe[1] != -1) {
         qt_safe_close(pipe[1]);
         pipe[1] = -1;
     }
     if (pipe[0] != -1) {
         qt_safe_close(pipe[0]);
         pipe[0] = -1;
     }
 }

◆ execChild()

void QProcessPrivate::execChild	(	const char *	workingDirectory,
		char **	path,
		char **	argv,
		char **	envp
	)

Definition at line 770 of file qprocess_unix.cpp.

 {
     ::signal(SIGPIPE, SIG_DFL);         // reset the signal that we ignored
 
     Q_Q(QProcess);
 
     // copy the stdin socket (without closing on exec)
     qt_safe_dup2(stdinChannel.pipe[0], STDIN_FILENO, 0);
 
     // copy the stdout and stderr if asked to
     if (processChannelMode != QProcess::ForwardedChannels) {
         qt_safe_dup2(stdoutChannel.pipe[1], STDOUT_FILENO, 0);
 
         // merge stdout and stderr if asked to
         if (processChannelMode == QProcess::MergedChannels) {
             qt_safe_dup2(STDOUT_FILENO, STDERR_FILENO, 0);
         } else {
             qt_safe_dup2(stderrChannel.pipe[1], STDERR_FILENO, 0);
         }
     }
 
     // make sure this fd is closed if execvp() succeeds
     qt_safe_close(childStartedPipe[0]);
 
     // enter the working directory
     if (workingDir)
         QT_CHDIR(workingDir);
 
     // this is a virtual call, and it base behavior is to do nothing.
     q->setupChildProcess();
 
     // execute the process
     if (!envp) {
         qt_safe_execvp(argv[0], argv);
     } else {
         if (path) {
             char **arg = path;
             while (*arg) {
                 argv[0] = *arg;
 #if defined (QPROCESS_DEBUG)
                 fprintf(stderr, "QProcessPrivate::execChild() searching / starting %s\n", argv[0]);
 #endif
                 qt_safe_execve(argv[0], argv, envp);
                 ++arg;
             }
         } else {
 #if defined (QPROCESS_DEBUG)
             fprintf(stderr, "QProcessPrivate::execChild() starting %s\n", argv[0]);
 #endif
             qt_safe_execve(argv[0], argv, envp);
         }
     }
 
     // notify failure
     QString error = qt_error_string(errno);
 #if defined (QPROCESS_DEBUG)
     fprintf(stderr, "QProcessPrivate::execChild() failed (%s), notifying parent process\n", qPrintable(error));
 #endif
     qt_safe_write(childStartedPipe[1], error.data(), error.length() * sizeof(QChar));
     qt_safe_close(childStartedPipe[1]);
     childStartedPipe[1] = -1;
 }

◆ findExitCode()

void QProcessPrivate::findExitCode ( )

Definition at line 1293 of file qprocess_unix.cpp.

Referenced by qt_terminateApp().

 {
     Q_Q(QProcess);
     processManager()->remove(q);
 }

◆ flushPipeWriter()

void QProcessPrivate::flushPipeWriter ( )

Definition at line 774 of file qprocess_win.cpp.

 {
     if (pipeWriter && pipeWriter->bytesToWrite() > 0) {
         pipeWriter->waitForWrite(ULONG_MAX);
     }
 }

◆ initializeProcessManager()

void QProcessPrivate::initializeProcessManager ( )

static

Definition at line 1485 of file qprocess_unix.cpp.

Referenced by QCoreApplication::init().

 {
     (void) processManager();
 }

◆ killProcess()

void QProcessPrivate::killProcess ( )

Definition at line 1021 of file qprocess_unix.cpp.

Referenced by qt_terminateApp().

 {
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::killProcess()");
 #endif
     if (pid)
         ::kill(pid_t(pid), SIGKILL);
 }

◆ pipeWriterBytesToWrite()

qint64 QProcessPrivate::pipeWriterBytesToWrite ( ) const

Definition at line 781 of file qprocess_win.cpp.

 {
     return pipeWriter ? pipeWriter->bytesToWrite() : qint64(0);
 }

◆ processStarted()

bool QProcessPrivate::processStarted ( )

Definition at line 835 of file qprocess_unix.cpp.

Referenced by qt_create_commandline(), and qt_terminateApp().

 {
     ushort buf[errorBufferMax];
     int i = qt_safe_read(childStartedPipe[0], &buf, sizeof buf);
     if (startupSocketNotifier) {
         startupSocketNotifier->setEnabled(false);
         startupSocketNotifier->deleteLater();
         startupSocketNotifier = 0;
     }
     qt_safe_close(childStartedPipe[0]);
     childStartedPipe[0] = -1;
 
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::processStarted() == %s", i <= 0 ? "true" : "false");
 #endif
 
     // did we read an error message?
     if (i > 0)
         q_func()->setErrorString(QString((const QChar *)buf, i / sizeof(QChar)));
 
     return i <= 0;
 }

◆ readFromStderr()

qint64 QProcessPrivate::readFromStderr	(	char *	data,
		qint64	maxlen
	)

Definition at line 985 of file qprocess_unix.cpp.

Referenced by qt_create_commandline().

 {
     qint64 bytesRead = qt_safe_read(stderrChannel.pipe[0], data, maxlen);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::readFromStderr(%p \"%s\", %lld) == %lld",
            data, qt_prettyDebug(data, bytesRead, 16).constData(), maxlen, bytesRead);
 #endif
     return bytesRead;
 }

◆ readFromStdout()

qint64 QProcessPrivate::readFromStdout	(	char *	data,
		qint64	maxlen
	)

Definition at line 975 of file qprocess_unix.cpp.

Referenced by qt_create_commandline().

 {
     qint64 bytesRead = qt_safe_read(stdoutChannel.pipe[0], data, maxlen);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::readFromStdout(%p \"%s\", %lld) == %lld",
            data, qt_prettyDebug(data, bytesRead, 16).constData(), maxlen, bytesRead);
 #endif
     return bytesRead;
 }

◆ startDetached()

bool QProcessPrivate::startDetached	(	const QString &	program,
		const QStringList &	arguments,
		const QString &	workingDirectory = `QString()`,
		qint64 *	pid = `0`
	)

static

Warning: This function is not part of the public interface.

Definition at line 1365 of file qprocess_unix.cpp.

Referenced by _q_notified(), pipeWriterBytesToWrite(), and QProcess::startDetached().

 {
     processManager()->start();
 
     QByteArray encodedWorkingDirectory = QFile::encodeName(workingDirectory);
 
     // To catch the startup of the child
     int startedPipe[2];
     if (qt_safe_pipe(startedPipe) != 0)
         return false;
     // To communicate the pid of the child
     int pidPipe[2];
     if (qt_safe_pipe(pidPipe) != 0) {
         qt_safe_close(startedPipe[0]);
         qt_safe_close(startedPipe[1]);
         return false;
     }
 
     pid_t childPid = fork();
     if (childPid == 0) {
         struct sigaction noaction;
         memset(&noaction, 0, sizeof(noaction));
         noaction.sa_handler = SIG_IGN;
         ::sigaction(SIGPIPE, &noaction, 0);
 
         ::setsid();
 
         qt_safe_close(startedPipe[0]);
         qt_safe_close(pidPipe[0]);
 
         pid_t doubleForkPid = fork();
         if (doubleForkPid == 0) {
             qt_safe_close(pidPipe[1]);
 
             if (!encodedWorkingDirectory.isEmpty())
                 QT_CHDIR(encodedWorkingDirectory.constData());
 
             char **argv = new char *[arguments.size() + 2];
             for (int i = 0; i < arguments.size(); ++i) {
 #ifdef Q_OS_MAC
                 argv[i + 1] = ::strdup(arguments.at(i).toUtf8().constData());
 #else
                 argv[i + 1] = ::strdup(arguments.at(i).toLocal8Bit().constData());
 #endif
             }
             argv[arguments.size() + 1] = 0;
 
             if (!program.contains(QLatin1Char('/'))) {
                 const QString path = QString::fromLocal8Bit(::getenv("PATH"));
                 if (!path.isEmpty()) {
                     QStringList pathEntries = path.split(QLatin1Char(':'));
                     for (int k = 0; k < pathEntries.size(); ++k) {
                         QByteArray tmp = QFile::encodeName(pathEntries.at(k));
                         if (!tmp.endsWith('/')) tmp += '/';
                         tmp += QFile::encodeName(program);
                         argv[0] = tmp.data();
                         qt_safe_execv(argv[0], argv);
                     }
                 }
             } else {
                 QByteArray tmp = QFile::encodeName(program);
                 argv[0] = tmp.data();
                 qt_safe_execv(argv[0], argv);
             }
 
             struct sigaction noaction;
             memset(&noaction, 0, sizeof(noaction));
             noaction.sa_handler = SIG_IGN;
             ::sigaction(SIGPIPE, &noaction, 0);
 
             // '\1' means execv failed
             char c = '\1';
             qt_safe_write(startedPipe[1], &c, 1);
             qt_safe_close(startedPipe[1]);
             ::_exit(1);
         } else if (doubleForkPid == -1) {
             struct sigaction noaction;
             memset(&noaction, 0, sizeof(noaction));
             noaction.sa_handler = SIG_IGN;
             ::sigaction(SIGPIPE, &noaction, 0);
 
             // '\2' means internal error
             char c = '\2';
             qt_safe_write(startedPipe[1], &c, 1);
         }
 
         qt_safe_close(startedPipe[1]);
         qt_safe_write(pidPipe[1], (const char *)&doubleForkPid, sizeof(pid_t));
         QT_CHDIR("/");
         ::_exit(1);
     }
 
     qt_safe_close(startedPipe[1]);
     qt_safe_close(pidPipe[1]);
 
     if (childPid == -1) {
         qt_safe_close(startedPipe[0]);
         qt_safe_close(pidPipe[0]);
         return false;
     }
 
     char reply = '\0';
     int startResult = qt_safe_read(startedPipe[0], &reply, 1);
     int result;
     qt_safe_close(startedPipe[0]);
     qt_safe_waitpid(childPid, &result, 0);
     bool success = (startResult != -1 && reply == '\0');
     if (success && pid) {
         pid_t actualPid = 0;
         if (qt_safe_read(pidPipe[0], (char *)&actualPid, sizeof(pid_t)) == sizeof(pid_t)) {
             *pid = actualPid;
         } else {
             *pid = 0;
         }
     }
     qt_safe_close(pidPipe[0]);
     return success;
 }

◆ startProcess()

void QProcessPrivate::startProcess ( )

Definition at line 562 of file qprocess_unix.cpp.

Referenced by qt_create_commandline().

 {
     Q_Q(QProcess);
 
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::startProcess()");
 #endif
 
     processManager()->start();
 
     // Initialize pipes
     if (!createChannel(stdinChannel) ||
         !createChannel(stdoutChannel) ||
         !createChannel(stderrChannel) ||
         qt_create_pipe(childStartedPipe) != 0 ||
         qt_create_pipe(deathPipe) != 0) {
         processError = QProcess::FailedToStart;
         q->setErrorString(qt_error_string(errno));
         emit q->error(processError);
         cleanup();
         return;
     }
 
     if (threadData->eventDispatcher) {
         startupSocketNotifier = new QSocketNotifier(childStartedPipe[0],
                                                     QSocketNotifier::Read, q);
         QObject::connect(startupSocketNotifier, SIGNAL(activated(int)),
                          q, SLOT(_q_startupNotification()));
         deathNotifier = new QSocketNotifier(deathPipe[0],
                                             QSocketNotifier::Read, q);
         QObject::connect(deathNotifier, SIGNAL(activated(int)),
                          q, SLOT(_q_processDied()));
     }
 
     // Start the process (platform dependent)
     q->setProcessState(QProcess::Starting);
 
     // Create argument list with right number of elements, and set the final
     // one to 0.
     char **argv = new char *[arguments.count() + 2];
     argv[arguments.count() + 1] = 0;
 
     // Encode the program name.
     QByteArray encodedProgramName = QFile::encodeName(program);
 #ifdef Q_OS_MAC
     // allow invoking of .app bundles on the Mac.
     QFileInfo fileInfo(QString::fromUtf8(encodedProgramName.constData()));
     if (encodedProgramName.endsWith(".app") && fileInfo.isDir()) {
         QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0,
                                                           QCFString(fileInfo.absoluteFilePath()),
                                                           kCFURLPOSIXPathStyle, true);
         {
             // CFBundle is not reentrant, since CFBundleCreate might return a reference
             // to a cached bundle object. Protect the bundle calls with a mutex lock.
             QMutexLocker lock(cfbundleMutex());
             QCFType<CFBundleRef> bundle = CFBundleCreate(0, url);
             url = CFBundleCopyExecutableURL(bundle);
         }
         if (url) {
             QCFString str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
             encodedProgramName += "/Contents/MacOS/" + static_cast<QString>(str).toUtf8();
         }
     }
 #endif
 
     // Add the program name to the argument list.
     char *dupProgramName = ::strdup(encodedProgramName.constData());
     argv[0] = dupProgramName;
 
     // Add every argument to the list
     for (int i = 0; i < arguments.count(); ++i) {
         QString arg = arguments.at(i);
 #ifdef Q_OS_MAC
         // Mac OS X uses UTF8 for exec, regardless of the system locale.
         argv[i + 1] = ::strdup(arg.toUtf8().constData());
 #else
         argv[i + 1] = ::strdup(arg.toLocal8Bit().constData());
 #endif
     }
 
     // Duplicate the environment.
     int envc = 0;
     char **envp = 0;
     if (environment.d.constData()) {
         QProcessEnvironmentPrivate::MutexLocker locker(environment.d);
         envp = _q_dupEnvironment(environment.d.constData()->hash, &envc);
     }
 
     // Encode the working directory if it's non-empty, otherwise just pass 0.
     const char *workingDirPtr = 0;
     QByteArray encodedWorkingDirectory;
     if (!workingDirectory.isEmpty()) {
         encodedWorkingDirectory = QFile::encodeName(workingDirectory);
         workingDirPtr = encodedWorkingDirectory.constData();
     }
 
     // If the program does not specify a path, generate a list of possible
     // locations for the binary using the PATH environment variable.
     char **path = 0;
     int pathc = 0;
     if (!program.contains(QLatin1Char('/'))) {
         const QString pathEnv = QString::fromLocal8Bit(::getenv("PATH"));
         if (!pathEnv.isEmpty()) {
             QStringList pathEntries = pathEnv.split(QLatin1Char(':'), QString::SkipEmptyParts);
             if (!pathEntries.isEmpty()) {
                 pathc = pathEntries.size();
                 path = new char *[pathc + 1];
                 path[pathc] = 0;
 
                 for (int k = 0; k < pathEntries.size(); ++k) {
                     QByteArray tmp = QFile::encodeName(pathEntries.at(k));
                     if (!tmp.endsWith('/')) tmp += '/';
                     tmp += encodedProgramName;
                     path[k] = ::strdup(tmp.constData());
                 }
             }
         }
     }
 
     // Start the process manager, and fork off the child process.
     processManager()->lock();
 #if defined(Q_OS_QNX)
     pid_t childPid = spawnChild(workingDirPtr, argv, envp);
 #else
     pid_t childPid = fork();
     int lastForkErrno = errno;
 #endif
     if (childPid != 0) {
         // Clean up duplicated memory.
         free(dupProgramName);
         for (int i = 1; i <= arguments.count(); ++i)
             free(argv[i]);
         for (int i = 0; i < envc; ++i)
             free(envp[i]);
         for (int i = 0; i < pathc; ++i)
             free(path[i]);
         delete [] argv;
         delete [] envp;
         delete [] path;
     }
 
     // This is not a valid check under QNX, because the semantics are
     // different. While under other platforms where fork() may succeed and exec() can still fail,
     // causing the childPid to hold a valid value (and thus evaluating the
     // following if to false), and then signaling the error via
     // childStartedPipe, under QNX on the other hand, spawn() return value will be assigned
     // to childPid (which will be -1 in case of failure). This will force
     // QProcess to cleanup, instead of signaling the error via
     // childStartedPipe. Since it will invalidade the pipes, functions like
     // QProcess::waitForStarted() will fail, for childStartedPipe will be
     // '-1' and mess with the select() calls.
 #if !defined(Q_OS_QNX)
     if (childPid < 0) {
         // Cleanup, report error and return
 #if defined (QPROCESS_DEBUG)
         qDebug("fork() failed: %s", qPrintable(qt_error_string(lastForkErrno)));
 #endif
         processManager()->unlock();
         q->setProcessState(QProcess::NotRunning);
         processError = QProcess::FailedToStart;
         q->setErrorString(QProcess::tr("Resource error (fork failure): %1").arg(qt_error_string(lastForkErrno)));
         emit q->error(processError);
         cleanup();
         return;
     }
 
     // Start the child.
     if (childPid == 0) {
         execChild(workingDirPtr, path, argv, envp);
         ::_exit(-1);
     }
 #endif
 
     // Register the child. In the mean time, we can get a SIGCHLD, so we need
     // to keep the lock held to avoid a race to catch the child.
     processManager()->add(childPid, q);
     pid = Q_PID(childPid);
     processManager()->unlock();
 
     // parent
     // close the ends we don't use and make all pipes non-blocking
     ::fcntl(deathPipe[0], F_SETFL, ::fcntl(deathPipe[0], F_GETFL) | O_NONBLOCK);
     qt_safe_close(childStartedPipe[1]);
     childStartedPipe[1] = -1;
 
     if (stdinChannel.pipe[0] != -1) {
         qt_safe_close(stdinChannel.pipe[0]);
         stdinChannel.pipe[0] = -1;
     }
     if (stdinChannel.pipe[1] != -1)
         ::fcntl(stdinChannel.pipe[1], F_SETFL, ::fcntl(stdinChannel.pipe[1], F_GETFL) | O_NONBLOCK);
 
     if (stdoutChannel.pipe[1] != -1) {
         qt_safe_close(stdoutChannel.pipe[1]);
         stdoutChannel.pipe[1] = -1;
     }
     if (stdoutChannel.pipe[0] != -1)
         ::fcntl(stdoutChannel.pipe[0], F_SETFL, ::fcntl(stdoutChannel.pipe[0], F_GETFL) | O_NONBLOCK);
 
     if (stderrChannel.pipe[1] != -1) {
         qt_safe_close(stderrChannel.pipe[1]);
         stderrChannel.pipe[1] = -1;
     }
     if (stderrChannel.pipe[0] != -1)
         ::fcntl(stderrChannel.pipe[0], F_SETFL, ::fcntl(stderrChannel.pipe[0], F_GETFL) | O_NONBLOCK);
 }

◆ terminateProcess()

void QProcessPrivate::terminateProcess ( )

Definition at line 1012 of file qprocess_unix.cpp.

Referenced by qt_terminateApp().

 {
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::killProcess()");
 #endif
     if (pid)
         ::kill(pid_t(pid), SIGTERM);
 }

◆ waitForBytesWritten()

bool QProcessPrivate::waitForBytesWritten ( int msecs = 30000 )

Definition at line 1154 of file qprocess_unix.cpp.

Referenced by qt_terminateApp().

 {
     Q_Q(QProcess);
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::waitForBytesWritten(%d)", msecs);
 #endif
 
     QElapsedTimer stopWatch;
     stopWatch.start();
 
     while (!writeBuffer.isEmpty()) {
         fd_set fdread;
         fd_set fdwrite;
 
         FD_ZERO(&fdread);
         FD_ZERO(&fdwrite);
 
         int nfds = deathPipe[0];
         FD_SET(deathPipe[0], &fdread);
 
         if (processState == QProcess::Starting)
             add_fd(nfds, childStartedPipe[0], &fdread);
 
         if (stdoutChannel.pipe[0] != -1)
             add_fd(nfds, stdoutChannel.pipe[0], &fdread);
         if (stderrChannel.pipe[0] != -1)
             add_fd(nfds, stderrChannel.pipe[0], &fdread);
 
 
         if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
             add_fd(nfds, stdinChannel.pipe[1], &fdwrite);
 
     int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
     int ret = select_msecs(nfds + 1, &fdread, &fdwrite, timeout);
         if (ret < 0) {
             break;
         }
 
         if (ret == 0) {
         processError = QProcess::Timedout;
         q->setErrorString(QProcess::tr("Process operation timed out"));
         return false;
     }
 
     if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
         if (!_q_startupNotification())
         return false;
     }
 
     if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
         return _q_canWrite();
 
     if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
         _q_canReadStandardOutput();
 
     if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
         _q_canReadStandardError();
 
     if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
             if (_q_processDied())
                 return false;
         }
     }
 
     return false;
 }

◆ waitForDeadChild()

bool QProcessPrivate::waitForDeadChild ( )

Definition at line 1299 of file qprocess_unix.cpp.

 {
     Q_Q(QProcess);
 
     // read a byte from the death pipe
     char c;
     qt_safe_read(deathPipe[0], &c, 1);
 
     // check if our process is dead
     int exitStatus;
     if (qt_safe_waitpid(pid_t(pid), &exitStatus, WNOHANG) > 0) {
         processManager()->remove(q);
         crashed = !WIFEXITED(exitStatus);
         exitCode = WEXITSTATUS(exitStatus);
 #if defined QPROCESS_DEBUG
         qDebug() << "QProcessPrivate::waitForDeadChild() dead with exitCode"
                  << exitCode << ", crashed?" << crashed;
 #endif
         return true;
     }
 #if defined QPROCESS_DEBUG
     qDebug() << "QProcessPrivate::waitForDeadChild() not dead!";
 #endif
     return false;
 }

◆ waitForFinished()

bool QProcessPrivate::waitForFinished ( int msecs = 30000 )

Definition at line 1221 of file qprocess_unix.cpp.

Referenced by qt_terminateApp().

 {
     Q_Q(QProcess);
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::waitForFinished(%d)", msecs);
 #endif
 
     QElapsedTimer stopWatch;
     stopWatch.start();
 
     forever {
         fd_set fdread;
         fd_set fdwrite;
         int nfds = -1;
 
         FD_ZERO(&fdread);
         FD_ZERO(&fdwrite);
 
         if (processState == QProcess::Starting)
             add_fd(nfds, childStartedPipe[0], &fdread);
 
         if (stdoutChannel.pipe[0] != -1)
             add_fd(nfds, stdoutChannel.pipe[0], &fdread);
         if (stderrChannel.pipe[0] != -1)
             add_fd(nfds, stderrChannel.pipe[0], &fdread);
 
         if (processState == QProcess::Running)
             add_fd(nfds, deathPipe[0], &fdread);
 
         if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
             add_fd(nfds, stdinChannel.pipe[1], &fdwrite);
 
     int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
     int ret = select_msecs(nfds + 1, &fdread, &fdwrite, timeout);
         if (ret < 0) {
             break;
         }
     if (ret == 0) {
         processError = QProcess::Timedout;
         q->setErrorString(QProcess::tr("Process operation timed out"));
         return false;
     }
 
     if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
         if (!_q_startupNotification())
         return false;
     }
     if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
         _q_canWrite();
 
     if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
         _q_canReadStandardOutput();
 
     if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
         _q_canReadStandardError();
 
     if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
             if (_q_processDied())
                 return true;
     }
     }
     return false;
 }

◆ waitForReadyRead()

bool QProcessPrivate::waitForReadyRead ( int msecs = 30000 )

Definition at line 1082 of file qprocess_unix.cpp.

Referenced by qt_terminateApp().

 {
     Q_Q(QProcess);
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::waitForReadyRead(%d)", msecs);
 #endif
 
     QElapsedTimer stopWatch;
     stopWatch.start();
 
     forever {
         fd_set fdread;
         fd_set fdwrite;
 
         FD_ZERO(&fdread);
         FD_ZERO(&fdwrite);
 
         int nfds = deathPipe[0];
         FD_SET(deathPipe[0], &fdread);
 
         if (processState == QProcess::Starting)
             add_fd(nfds, childStartedPipe[0], &fdread);
 
         if (stdoutChannel.pipe[0] != -1)
             add_fd(nfds, stdoutChannel.pipe[0], &fdread);
         if (stderrChannel.pipe[0] != -1)
             add_fd(nfds, stderrChannel.pipe[0], &fdread);
 
         if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
             add_fd(nfds, stdinChannel.pipe[1], &fdwrite);
 
         int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
         int ret = select_msecs(nfds + 1, &fdread, &fdwrite, timeout);
         if (ret < 0) {
             break;
         }
         if (ret == 0) {
             processError = QProcess::Timedout;
             q->setErrorString(QProcess::tr("Process operation timed out"));
         return false;
     }
 
     if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
             if (!_q_startupNotification())
                 return false;
     }
 
         bool readyReadEmitted = false;
     if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread)) {
         bool canRead = _q_canReadStandardOutput();
             if (processChannel == QProcess::StandardOutput && canRead)
                 readyReadEmitted = true;
     }
     if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread)) {
         bool canRead = _q_canReadStandardError();
             if (processChannel == QProcess::StandardError && canRead)
                 readyReadEmitted = true;
     }
         if (readyReadEmitted)
             return true;
 
     if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
         _q_canWrite();
 
     if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
             if (_q_processDied())
                 return false;
         }
     }
     return false;
 }

◆ waitForStarted()

bool QProcessPrivate::waitForStarted ( int msecs = 30000 )

Definition at line 1054 of file qprocess_unix.cpp.

Referenced by qt_terminateApp().

 {
     Q_Q(QProcess);
 
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::waitForStarted(%d) waiting for child to start (fd = %d)", msecs,
        childStartedPipe[0]);
 #endif
 
     fd_set fds;
     FD_ZERO(&fds);
     FD_SET(childStartedPipe[0], &fds);
     if (select_msecs(childStartedPipe[0] + 1, &fds, 0, msecs) == 0) {
         processError = QProcess::Timedout;
         q->setErrorString(QProcess::tr("Process operation timed out"));
 #if defined (QPROCESS_DEBUG)
         qDebug("QProcessPrivate::waitForStarted(%d) == false (timed out)", msecs);
 #endif
         return false;
     }
 
     bool startedEmitted = _q_startupNotification();
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::waitForStarted() == %s", startedEmitted ? "true" : "false");
 #endif
     return startedEmitted;
 }

◆ waitForWrite()

bool QProcessPrivate::waitForWrite ( int msecs = 30000 )

Definition at line 1285 of file qprocess_unix.cpp.

Referenced by pipeWriterBytesToWrite().

 {
     fd_set fdwrite;
     FD_ZERO(&fdwrite);
     FD_SET(stdinChannel.pipe[1], &fdwrite);
     return select_msecs(stdinChannel.pipe[1] + 1, 0, &fdwrite, msecs < 0 ? 0 : msecs) == 1;
 }

◆ writeToStdin()

qint64 QProcessPrivate::writeToStdin	(	const char *	data,
		qint64	maxlen
	)

Definition at line 995 of file qprocess_unix.cpp.

Referenced by pipeWriterBytesToWrite().

 {
     qint64 written = qt_safe_write_nosignal(stdinChannel.pipe[1], data, maxlen);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::writeToStdin(%p \"%s\", %lld) == %lld",
            data, qt_prettyDebug(data, maxlen, 16).constData(), maxlen, written);
     if (written == -1)
         qDebug("QProcessPrivate::writeToStdin(), failed to write (%s)", qPrintable(qt_error_string(errno)));
 #endif
     // If the O_NONBLOCK flag is set and If some data can be written without blocking
     // the process, write() will transfer what it can and return the number of bytes written.
     // Otherwise, it will return -1 and set errno to EAGAIN
     if (written == -1 && errno == EAGAIN)
         written = 0;
     return written;
 }

Properties

◆ arguments

QStringList QProcessPrivate::arguments

Definition at line 324 of file qprocess_p.h.

Referenced by pipeWriterBytesToWrite(), and qt_create_commandline().

◆ childStartedPipe

Q_PIPE QProcessPrivate::childStartedPipe[2]

Definition at line 334 of file qprocess_p.h.

◆ crashed

bool QProcessPrivate::crashed

Definition at line 369 of file qprocess_p.h.

Referenced by qt_terminateApp().

◆ deathNotifier

QSocketNotifier* QProcessPrivate::deathNotifier

Definition at line 339 of file qprocess_p.h.

◆ deathPipe

Q_PIPE QProcessPrivate::deathPipe[2]

Definition at line 335 of file qprocess_p.h.

◆ dying

bool QProcessPrivate::dying

Definition at line 313 of file qprocess_p.h.

◆ emittedBytesWritten

bool QProcessPrivate::emittedBytesWritten

Definition at line 315 of file qprocess_p.h.

◆ emittedReadyRead

bool QProcessPrivate::emittedReadyRead

Definition at line 314 of file qprocess_p.h.

◆ environment

QProcessEnvironment QProcessPrivate::environment

Definition at line 328 of file qprocess_p.h.

Referenced by qt_create_commandline().

◆ errorReadBuffer

QRingBuffer QProcessPrivate::errorReadBuffer

Definition at line 331 of file qprocess_p.h.

◆ exitCode

int QProcessPrivate::exitCode

Definition at line 367 of file qprocess_p.h.

Referenced by qt_terminateApp().

◆ exitStatus

QProcess::ExitStatus QProcessPrivate::exitStatus

Definition at line 368 of file qprocess_p.h.

◆ nativeArguments

QString QProcessPrivate::nativeArguments

Definition at line 326 of file qprocess_p.h.

Referenced by qt_create_commandline().

◆ notifier

QTimer* QProcessPrivate::notifier

Definition at line 342 of file qprocess_p.h.

Referenced by pipeWriterBytesToWrite(), and qt_create_commandline().

◆ outputReadBuffer

QRingBuffer QProcessPrivate::outputReadBuffer

Definition at line 330 of file qprocess_p.h.

◆ pid

Q_PID QProcessPrivate::pid

Definition at line 310 of file qprocess_p.h.

Referenced by pipeWriterBytesToWrite(), qt_create_commandline(), and qt_terminateApp().

◆ pipeWriter

QWindowsPipeWriter* QProcessPrivate::pipeWriter

Definition at line 343 of file qprocess_p.h.

Referenced by flushPipeWriter(), pipeWriterBytesToWrite(), qt_create_pipe(), and qt_terminateApp().

◆ processChannel

QProcess::ProcessChannel QProcessPrivate::processChannel

Definition at line 305 of file qprocess_p.h.

◆ processChannelMode

QProcess::ProcessChannelMode QProcessPrivate::processChannelMode

Definition at line 306 of file qprocess_p.h.

Referenced by qt_create_commandline(), and qt_create_pipe().

◆ processError

QProcess::ProcessError QProcessPrivate::processError

Definition at line 307 of file qprocess_p.h.

Referenced by pipeWriterBytesToWrite(), qt_create_commandline(), qt_create_pipe(), and qt_terminateApp().

◆ processFinishedNotifier

QWinEventNotifier* QProcessPrivate::processFinishedNotifier

Definition at line 344 of file qprocess_p.h.

Referenced by qt_create_commandline().

◆ processState

QProcess::ProcessState QProcessPrivate::processState

Definition at line 308 of file qprocess_p.h.

Referenced by pipeWriterBytesToWrite(), and qt_create_commandline().

◆ program

QString QProcessPrivate::program

Definition at line 323 of file qprocess_p.h.

Referenced by pipeWriterBytesToWrite(), and qt_create_commandline().

◆ sequenceNumber

int QProcessPrivate::sequenceNumber

Definition at line 311 of file qprocess_p.h.

◆ serial

int QProcessPrivate::serial

Definition at line 371 of file qprocess_p.h.

◆ startupSocketNotifier

QSocketNotifier* QProcessPrivate::startupSocketNotifier

Definition at line 338 of file qprocess_p.h.

◆ stderrChannel

Channel QProcessPrivate::stderrChannel

Definition at line 319 of file qprocess_p.h.

Referenced by qt_create_commandline(), and qt_create_pipe().

◆ stdinChannel

Channel QProcessPrivate::stdinChannel

Definition at line 317 of file qprocess_p.h.

Referenced by createChannel(), pipeWriterBytesToWrite(), qt_create_commandline(), qt_create_pipe(), and QProcess::setStandardOutputProcess().

◆ stdoutChannel

Channel QProcessPrivate::stdoutChannel

Definition at line 318 of file qprocess_p.h.

Referenced by createChannel(), qt_create_commandline(), qt_create_pipe(), and QProcess::setStandardOutputProcess().

◆ workingDirectory

QString QProcessPrivate::workingDirectory

Definition at line 309 of file qprocess_p.h.

Referenced by qt_create_commandline().

◆ writeBuffer

QRingBuffer QProcessPrivate::writeBuffer

Definition at line 332 of file qprocess_p.h.

Referenced by pipeWriterBytesToWrite(), and qt_terminateApp().

The documentation for this class was generated from the following files:

/src/corelib/io/qprocess_p.h
/src/corelib/io/qprocess.cpp
/src/corelib/io/qprocess_unix.cpp
/src/corelib/io/qprocess_win.cpp

Classes

Public Functions

Static Public Functions

Public Variables

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QProcessPrivate()

◆ ~QProcessPrivate()

Functions

◆ _q_canReadStandardError()

◆ _q_canReadStandardOutput()

◆ _q_canWrite()

◆ _q_notified()

◆ _q_processDied()

◆ _q_startupNotification()

◆ bytesAvailableFromStderr()

◆ bytesAvailableFromStdout()

◆ cleanup()

◆ closeWriteChannel()

◆ createChannel()

◆ destroyPipe()

◆ execChild()

◆ findExitCode()

◆ flushPipeWriter()

◆ initializeProcessManager()

◆ killProcess()

◆ pipeWriterBytesToWrite()

◆ processStarted()

◆ readFromStderr()

◆ readFromStdout()

◆ startDetached()

◆ startProcess()

◆ terminateProcess()

◆ waitForBytesWritten()

◆ waitForDeadChild()

◆ waitForFinished()

◆ waitForReadyRead()

◆ waitForStarted()

◆ waitForWrite()

◆ writeToStdin()

Properties

◆ arguments

◆ childStartedPipe

◆ crashed

◆ deathNotifier

◆ deathPipe

◆ dying

◆ emittedBytesWritten

◆ emittedReadyRead

◆ environment

◆ errorReadBuffer

◆ exitCode

◆ exitStatus

◆ nativeArguments

◆ notifier

◆ outputReadBuffer

◆ pid

◆ pipeWriter

◆ processChannel

◆ processChannelMode

◆ processError

◆ processFinishedNotifier

◆ processState

◆ program

◆ sequenceNumber

◆ serial

◆ startupSocketNotifier

◆ stderrChannel

◆ stdinChannel

◆ stdoutChannel

◆ workingDirectory

◆ writeBuffer