|
|
Child process invocation, monitoring and control.
This class allows a KDE application to start child processes without having to worry about UN*X signal handling issues and zombie process reaping.
Basically, this class distinguishes three different ways of running child processes:
Starting a DontCare child process means that the application is not interested in any notification to determine whether the child process has already exited or not.
When the child process exits, the KProcess instance corresponding to it emits the Qt signal processExited().
Since this signal is not emitted from within a UN*X signal handler, arbitrary function calls can be made.
KProcess also provides several functions for determining the exit status and the pid of the child process it represents.
Furthermore it is possible to supply command-line arguments to the process in a clean fashion (no null -- terminated stringlists and such...)
A small usage example:
KProcess proc; proc << "my_executable"; proc << "These" << "are" << "the" << "command" << "line" << "args"; QApplication::connect(&proc, SIGNAL(processExited(KProcess *)), pointer_to_my_object, SLOT(my_objects_slot)); proc.start(); |
This will start "my_executable" with the commandline arguments "These"...
When the child process exits, the respective Qt signal will be emitted.
KProcess supports communication with the child process through stdin/stdout/stderr.
The following functions are provided for getting data from the child process or sending data to the child's stdin (For more information, have a look at the documentation of each function):
enum |
Modes in which the communication channel can be opened.
If communication for more than one channel is required,
the values have to be or'ed together, for example to get
communication with stdout as well as with stdin, you would
specify Stdin
|
Stdout
If NoRead
is specified in conjunction with Stdout,
no data is actually read from Stdout
but only
the signal childOutput(int fd) is emitted.
enum |
Run-modes for a child process.
|
Constructor
~ |
[virtual]
Destructor:
If the process is running when the destructor for this class
is called, the child process is killed with a SIGKILL, but
only if the run mode is not of type DontCare.
Processes started as DontCare
keep running anyway.
bool |
The use of this function is now deprecated. -- Please use the "operator<<" instead of "setExecutable".
Sets the executable to be started with this KProcess object. Returns false if the process is currently running (in that case the executable remains unchanged.)
KProcess & |
Sets the executable and the command line argument list for this process.
For example, doing an "ls -l /usr/local/bin" can be achieved by:
KProcess p; ... p << "ls" << "-l" << "/usr/local/bin" |
void |
Clear a command line argument list that has been set by using the "operator<<".
bool |
[virtual]
Start the process. For a detailed description of the various run modes and communication semantics, have a look at the general description of the KProcess class.
The following problems could cause KProcess:start() to
return false:
Parameters:
comm | Specifies which communication links should be established to the child process (stdin/stdout/stderr). By default, no communication takes place and the respective communication signals will never get emitted. |
Returns: true
on success, false
on error
(see above for error conditions)
bool |
[virtual]
Stop the process (by sending it a signal).
Parameters:
signo | The signal to send. The default is SIGTERM. |
Returns: true
if the signal was delivered successfully.
bool |
[const]
Returns: true
if the process is (still) considered to be running
pid_t |
[const]
Returns the process id of the process.
If it is called after the process has exited, it returns the process id of the last child process that was created by this instance of KProcess.
Calling it before any child process has been started by this KProcess instance causes pid() to return 0.
pid_t |
[const]
Use pid().
void |
Suspend processing of data from stdout of the child process.
void |
Resume processing of data from stdout of the child process.
bool |
[const]
Note that you should check KProcess::exitStatus() to determine whether the process completed its task successfull or not.
Returns: true
if the process has already finished and has exited
"voluntarily", ie: it has not been killed by a signal.
int |
[const]
Retrieve the exit status of the process.
Please use
KProcess::normalExit() to check whether the process has exited
cleanly (i.e., KProcess::normalExit() returns true)
before calling
this function because if the process did not exit normally,
it does not have a valid exit status.
bool |
Transmit data to the child process's stdin.
KProcess::writeStdin may return false in the following cases:
Please note that the data is sent to the client asynchronousely, so when this function returns, the data might not have been processed by the child process.
If all the data has been sent to the client, the signal wroteStdin() will be emitted.
Please note that you must not free "buffer" or call writeStdin() again until either a wroteStdin() signal indicates that the data has been sent or a processHasExited() signal shows that the child process is no longer alive...
bool |
This causes the stdin file descriptor of the child process to be closed indicating an "EOF" to the child.
Returns: false
if no communication to the process's stdin
had been specified in the call to start().
bool |
This causes the stdout file descriptor of the child process to be closed.
Returns: false
if no communication to the process's stdout
had been specified in the call to start().
bool |
This causes the stderr file descriptor of the child process to be closed.
Returns: false
if no communication to the process's stderr
had been specified in the call to start().
QStrList * |
Lets you see what your arguments are for debugging.
void |
Controls whether the started process should drop any setuid/segid privileges or whether it should keep them
The default is false
: drop privileges
bool |
[const]
Returns whether the started process will drop any setuid/segid privileges or whether it will keep them
void |
[signal]
Emitted after the process has terminated when
the process was run in the NotifyOnExit
(==default option to
start()) or the Block mode.
void |
[signal]
Emitted, when output from the child process has been received on stdout.
To actually get these signals, the respective communication link (stdout/stderr) has to be turned on in start().
You should copy the information contained in buffer
to your private
data structures before returning from this slot.
Parameters:
buffer | The data received. |
buflen | The number of bytes that are available. |
void |
[signal]
Emitted when output from the child process has been received on stdout.
To actually get
these signals, the respective communications link (stdout/stderr)
has to be turned on in start() and the NoRead
flag should
have been passed.
The data still has to be read from file descriptor fd.
void |
[signal]
Emitted, when output from the child process has been received on stderr. To actually get these signals, the respective communication link (stdout/stderr) has to be turned on in start().
You should copy the information contained in buffer
to your private
data structures before returning from this slot.
Parameters:
buffer | The data received. |
buflen | The number of bytes that are available. |
void |
[signal]
Emitted after all the data that has been specified by a prior call to writeStdin() has actually been written to the child process.
protected slots: /** This slot gets activated when data from the child's stdout arrives. It usually calls "childOutput" */ void |
[signal]
void |
[signal]
This slot gets activated when data from the child's stderr arrives. It usually calls "childError"
void |
[signal]
Called when another bulk of data can be sent to the child's stdin. If there is no more data to be sent to stdin currently available, this function must disable the QSocketNotifier "innot".
int |
[virtual signal]
This function is called from "KProcess::start" right before a "fork" takes place. According to the "comm" parameter this function has to initialize the "in", "out" and "err" data member of KProcess.
This function should return 0 if setting the needed communication channels was successful.
The default implementation is to create UNIX STREAM sockets for the communication, but you could overload this function and establish a TCP/IP communication for network communication, for example.
int |
[virtual signal]
Called right after a (successful) fork on the parent side. This function will usually do some communications cleanup, like closing the reading end of the "stdin" communication channel.
Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and "errnot" and connect their Qt slots to the respective KProcess member functions.
For a more detailed explanation, it is best to have a look at the default implementation of "setupCommunication" in kprocess.cpp.
int |
[virtual signal]
Called right after a (successful) fork, but before an "exec" on the child process' side. It usually just closes the unused communication ends of "in", "out" and "err" (like the writing end of the "in" communication channel.
void |
[virtual signal]
Immediately called after a process has exited. This function normally calls commClose to close all open communication channels to this process and emits the "processExited" signal (if the process was not running in the "DontCare" mode).
void |
[virtual signal]
Should clean up the communication links to the child after it has exited. Should be called from "processHasExited".
int |
[signal]
Called by "slotChildOutput" this function copies data arriving from the child process's stdout to the respective buffer and emits the signal "receivedStderr".
int |
[signal]
Called by "slotChildOutput" this function copies data arriving from the child process's stdout to the respective buffer and emits the signal "receivedStderr"
private: |
[signal]
KProcessController is a friend of KProcess because it has to have access to various data members.
KProcess& |
[signal]