|
|
1) General usage and features
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:
+) "KProcess::DontCare" -- The child process is invoked and both the child process and the parent process continue concurrently.
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.
+) "KProcess::NotifyOnExit" -- The child process is invoked both the child and the parent process run concurrently.
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::Block" -- The child process starts and the parent process is suspended until the child process exits. (_Really_ not recommended for programs with a GUI)
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.
2) Communication with the child process
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):
bool writeStdin(char *buffer, int buflen); -- Transmit data to the child process's stdin.
bool closeStdin(); -- Closes the child process's stdin (which causes it to see a "feof(stdin)") Returns FALSE if you try to close stdin for a process that has been started without a communication channel to stdin.
QT signals:
void receivedStdout(KProcess *proc, char *buffer, int buflen); void receivedStderr(KProcess *proc, char *buffer, int buflen); -- Indicates that new data has arrived from either the child process's stdout or stderr.
void wroteStdin(KProcess *proc); -- Indicates that all data that has been sent to the child process by a prior call to "writeStdin" has actually been transmitted to the client
enum |
enums for communication channels to open. 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"
enum |
various run--modes for a child process. For more information about the semantics of the run modes have a look at the general description of the KProcess class.
|
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 depreciated. -- 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, doning a "ls -l /usr/local/bin" can be achieved by:
KProcess p; ... p << "ls" << "-l" << "/usr/local/bin"
void |
Clears a command line argument list that has been set by using the "operator<<".
bool |
[virtual]
Starts up 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.
This function returns TRUE if the process was started successfully. The following problems could cause KProcess:start" to return FALSE:
+) the process is already running
+) the command line argument list is empty
+) the starting of the process failed (could not fork)
The second argument 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.
bool |
[virtual]
Stops the process (by sending a SIGTERM to it). -- You may send other signals too of course... ;-) )
Returns TRUE if the signal could be delivered successfully
bool |
Returns TRUE if the process is (still) considered to be running
pid_t |
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 getPid to return 0
bool |
Returns TRUE if the process has already finished and has exited "voluntarily", ie: it has not been killed by a signal.
int |
Returns the exit status of the process. Please use "KProcess::normalExit" to check whether the process has exited cleanly (KProcess::normalExit returning 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:
+) The process is not currently running
+) Communication to stdin has not been requested in the "start" call
+) transmission of data to the child process by a previous call to "writeStdin" is still in progress.
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. This function will return FALSE if:
+) No communication to the process's stdin has been specified in the "start" call.
void |
[signal]
This signal gets emitted after the process has terminated when the process was run in the "NotfiyOnExit" (=default option to "start") or the "Block" mode.
void |
[signal]
These signals get 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".
"buffer" contains the data, and "buflen" bytes are available from the client.
You should copy the information contained in "buffer" to your private data structures before returning from this slot.
void |
[signal]
These signals get 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".
"buffer" contains the data, and "buflen" bytes are available from the client.
You should copy the information contained in "buffer" to your private data structures before returning from this slot.
void |
[signal]
This signal gets emitted after all the data that has been specified by a prior call to "writeStdin" has actually been written to the child process.
void |
[protected slot]
This slot gets activated when data from the child's stdout arrives. It usually calls "childOutput"
void |
[protected slot]
This slot gets activated when data from the child's stderr arrives. It usually calls "childError"
void |
[protected slot]
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".
QStrList |
[protected]
The list of the process' command line arguments. The first entry in this list is the executable itself.
RunMode |
[protected]
How to run the process (Block, NotifyOnExit, DontCare). You should not modify this data member directly from derived classes.
bool |
[protected]
TRUE if the process is currently running. You should not modify this data member directly from derived classes. For reading the value of this data member, please use "isRunning()" since "runs" will probably be made private in later versions of KProcess.
pid_t |
[protected]
The PID of the currently running process (see "getPid()"). You should not modify this data member in derived classes. Please use "getPid()" instead of directly accessing this member function since it will probably be made private in later versions of KProcess.
int |
[protected]
The process' exit status as returned by "waitpid". You should not modify the value of this data member from derived classes. You should rather use "getStatus()" than accessing this data member directly since it will probably be made private in further versions of KProcess.
int |
[protected virtual]
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 |
[protected virtual]
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 |
[protected virtual]
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 |
[protected virtual]
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 |
[protected virtual]
Should clean up the communication links to the child after it has exited. Should be called from "processHasExited".
Communication |
[protected]
Lists the communication links that are activated for the child process. Should not be modified from derived classes.
int |
[protected]
Called by "slotChildOutput" this function copies data arriving from the child process's stdout to the respective buffer and emits the signal "receivedStderr"
int |
[protected]
Called by "slotChildOutput" this function copies data arriving from the child process's stdout to the respective buffer and emits the signal "receivedStderr"
friend class |
[protected]
KProcessController is a friend fo KProcess because it has to have access to various data members.