Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   Related Pages  

KProcess Class Reference

#include <kprocess.h>

Inheritance diagram for KProcess:

KShellProcess List of all members.

Public Types

enum  Communication
enum  RunMode { DontCare, NotifyOnExit, Block }

Signals

void processExited (KProcess *proc)
void receivedStdout (KProcess *proc, char *buffer, int buflen)
void receivedStdout (int fd, int &len)
void receivedStderr (KProcess *proc, char *buffer, int buflen)
void wroteStdin (KProcess *proc)

Public Methods

 KProcess ()
virtual ~KProcess ()
bool setExecutable (const QString &proc)
KProcess & operator<< (const QString &arg)
KProcess & operator<< (const char *arg)
KProcess & operator<< (const QCString &arg)
KProcess & operator<< (const QStringList &args)
void clearArguments ()
virtual bool start (RunMode runmode=NotifyOnExit, Communication comm=NoCommunication)
virtual bool kill (int signo=SIGTERM)
bool isRunning () const
pid_t pid () const
pid_t getPid () const
void suspend ()
void resume ()
bool normalExit () const
int exitStatus () const
bool writeStdin (const char *buffer, int buflen)
bool closeStdin ()
bool closeStdout ()
bool closeStderr ()
const QValueList< QCString > & args ()
void setRunPrivileged (bool keepPrivileges)
bool runPrivileged () const
void setEnvironment (const QString &name, const QString &value)
void setWorkingDirectory (const QString &dir)
void detach ()

Protected Slots

void slotChildOutput (int fdno)
void slotChildError (int fdno)
void slotSendData (int dummy)

Protected Methods

void setupEnvironment ()
virtual int setupCommunication (Communication comm)
virtual int commSetupDoneP ()
virtual int commSetupDoneC ()
virtual void processHasExited (int state)
virtual void commClose ()
int childOutput (int fdno)
int childError (int fdno)

Protected Attributes

QValueList< QCString > arguments
RunMode run_mode
bool runs
pid_t pid_
int status
bool keepPrivs
int out [2]
QSocketNotifier * innot
Communication communication

Friends

class KProcessController

Detailed Description

Child process invocation, monitoring and control.

@sect 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.

See also:
KProcIO
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.

Be aware: When the KProcess objects gets destructed, the child process will be killed if it is still running! This means in particular, that you cannot use a KProcess on the stack with KProcess::NotifyOnExit.

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 = new KProcess;

 **proc << "my_executable";
 **proc << "These" << "are" << "the" << "command" << "line" << "args";
 *QApplication::connect(proc, SIGNAL(processExited(KProcess *)),
                      pointer_to_my_object, SLOT(my_objects_slot(KProcess *)));
 *proc->start();
 *

This will start "my_executable" with the commandline arguments "These"...

When the child process exits, the respective Qt signal will be emitted.

@sect 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):

@sect QT signals:

Author:
Christian Czezakte e9025461@student.tuwien.ac.at


Member Enumeration Documentation

enum KProcess::Communication
 

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 KProcess::RunMode
 

Run-modes for a child process.

Enumeration values:
DontCare  The application does not receive notifications from the subprocess when it is finished or aborted.
NotifyOnExit  The application is notified when the subprocess dies.
Block  The application is suspended until the started process is finished.


Constructor & Destructor Documentation

KProcess::KProcess  
 

Constructor

virtual KProcess::~KProcess   [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.


Member Function Documentation

const QValueList<QCString>& KProcess::args   [inline]
 

Lets you see what your arguments are for debugging.

int KProcess::childError int    fdno [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 KProcess::childOutput int    fdno [protected]
 

Called by "slotChildOutput" this function copies data arriving from the child process's stdout to the respective buffer and emits the signal "receivedStderr".

void KProcess::clearArguments  
 

Clear a command line argument list that has been set by using the "operator<<".

bool KProcess::closeStderr  
 

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().

bool KProcess::closeStdin  
 

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 KProcess::closeStdout  
 

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().

virtual void KProcess::commClose   [protected, virtual]
 

Should clean up the communication links to the child after it has exited. Should be called from "processHasExited".

virtual int KProcess::commSetupDoneC   [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.

virtual int KProcess::commSetupDoneP   [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.

void KProcess::detach  
 

Detaches KProcess from child process. All communication is closed. No exit notification is emitted any more for the child process. Deleting the KProcess will no longer kill the child process. Note that the current process remains the parent process of the child process.

int KProcess::exitStatus  
 

Returns 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.

pid_t KProcess::getPid   const [inline]
 

Use pid().

Deprecated:

bool KProcess::isRunning  
 

Returns:
true if the process is (still) considered to be running

virtual bool KProcess::kill int    signo = SIGTERM [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 KProcess::normalExit  
 

Returns:
true if the process has already finished and has exited "voluntarily", ie: it has not been killed by a signal.
Note that you should check KProcess::exitStatus() to determine whether the process completed its task successful or not.

KProcess& KProcess::operator<< const QStringList &    args
 

Sets the executable and the command line argument list for this process, in a single method call, or add a list of arguments.

KProcess& KProcess::operator<< const QCString &    arg
 

Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.

KProcess& KProcess::operator<< const char *    arg
 

Similar to previous method, takes a char *, supposed to be in locale 8 bit already.

KProcess& KProcess::operator<< const QString &    arg
 

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"
  

pid_t KProcess::pid  
 

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.

void KProcess::processExited KProcess *    proc [signal]
 

Emitted after the process has terminated when the process was run in the NotifyOnExit (==default option to start()) or the Block mode.

virtual void KProcess::processHasExited int    state [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 KProcess::receivedStderr KProcess *    proc,
char *    buffer,
int    buflen
[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().

Parameters:
buffer  The data received.
buflen  The number of bytes that are available.
You should copy the information contained in buffer to your private data structures before returning from this slot.

void KProcess::receivedStdout int    fd,
int &    len
[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.

You will need to explicitly call resume() after your call to start() to begin processing data from the child process's stdout. This is to ensure that this signal is not emitted when no one is connected to it, otherwise this signal will not be emitted.

The data still has to be read from file descriptor fd.

void KProcess::receivedStdout KProcess *    proc,
char *    buffer,
int    buflen
[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().

Parameters:
buffer  The data received.
buflen  The number of bytes that are available.
You should copy the information contained in buffer to your private data structures before returning from this slot.

void KProcess::resume  
 

Resume processing of data from stdout of the child process.

bool KProcess::runPrivileged  
 

Returns whether the started process will drop any setuid/segid privileges or whether it will keep them

void KProcess::setEnvironment const QString &    name,
const QString &    value
 

Modifies the environment of the process to be started. This function must be called before starting the process.

bool KProcess::setExecutable const QString &    proc
 

Deprecated:

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.)

See also:
operator<<

void KProcess::setRunPrivileged bool    keepPrivileges
 

Controls whether the started process should drop any setuid/segid privileges or whether it should keep them

The default is false : drop privileges

virtual int KProcess::setupCommunication Communication    comm [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.

void KProcess::setupEnvironment   [protected]
 

Sets up the environment according to the data passed via setEnvironment(...)

void KProcess::setWorkingDirectory const QString &    dir
 

Changes the current working directory (CWD) of the process to be started. This function must be called before starting the process.

void KProcess::slotChildError int    fdno [protected, slot]
 

This slot gets activated when data from the child's stderr arrives. It usually calls "childError"

void KProcess::slotChildOutput int    fdno [protected, slot]
 

This slot gets activated when data from the child's stdout arrives. It usually calls "childOutput"

void KProcess::slotSendData int    dummy [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".

virtual bool KProcess::start RunMode    runmode = NotifyOnExit,
Communication    comm = NoCommunication
[virtual]
 

Starts 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 this function 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 executable was not found.
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)

Reimplemented in KShellProcess.

void KProcess::suspend  
 

Suspend processing of data from stdout of the child process.

bool KProcess::writeStdin const char *    buffer,
int    buflen
 

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 asynchronously, 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...

void KProcess::wroteStdin KProcess *    proc [signal]
 

Emitted after all the data that has been specified by a prior call to writeStdin() has actually been written to the child process.


Friends And Related Function Documentation

friend class KProcessController [friend]
 

KProcessController is a friend of KProcess because it has to have access to various data members.


Member Data Documentation

QValueList<QCString> KProcess::arguments [protected]
 

The list of the process' command line arguments. The first entry in this list is the executable itself.

Communication KProcess::communication [protected]
 

Lists the communication links that are activated for the child process. Should not be modified from derived classes.

QSocketNotifier* KProcess::innot [protected]
 

The socket notifiers for the above socket descriptors.

bool KProcess::keepPrivs [protected]
 

See setRunPrivileged()

int KProcess::out[2] [protected]
 

the socket descriptors for stdin/stdout/stderr.

pid_t KProcess::pid_ [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.

RunMode KProcess::run_mode [protected]
 

How to run the process (Block, NotifyOnExit, DontCare). You should not modify this data member directly from derived classes.

bool KProcess::runs [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.

int KProcess::status [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 exitStatus than accessing this data member directly since it will probably be made private in further versions of KProcess.


The documentation for this class was generated from the following file:
Generated on Sat Jul 26 04:23:41 2003 by doxygen1.2.18