class KProcess

# class KProcess | Child process invocation, monitoring and control. More...
Definition | `#include <kprocess.h>`
Inherits | QObject (qt) [public ]
Inherited by | KProcIO, KShellProcess
List of all Methods
Annotated List
Files
Globals
Hierarchy
Index

#### Public Types

- enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4, AllOutput = 6, All = 7, NoRead }
- enum RunMode { DontCare, /** }

#### 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 setUseShell (bool useShell, const char *shell = 0)
- void detach ()

#### 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 Static Methods

- static QString quote (const QString &arg)

#### 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)
- virtual void virtual_hook ( int id, void* data )

#### Protected Slots

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

#### Protected Members

- QValueList arguments
- RunMode run_mode
- bool runs
- pid_t pid_
- int status
- bool keepPrivs
- int out[2]
- int in[2]
- int err[2]
- QSocketNotifier *innot
- QSocketNotifier *outnot
- QSocketNotifier *errnot
- Communication communication
- const char *input_data
- int input_sent
- int input_total
- friend class KProcessController

## Detailed Description

Child process invocation, monitoring and control.

### 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 and 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.

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::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 = 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.

### 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 an feof(stdin)). Returns false if you try to close stdin for a process that has been started without a communication channel to stdin.

- bool closeStdout();
- -- Closes the child process's stdout. Returns false if you try to close stdout for a process that has been started without a communication channel to stdout.

- bool closeStderr();
- -- Closes the child process's stderr. Returns false if you try to close stderr for a process that has been started without a communication channel to stderr.

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

See also: KProcIO

enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4, AllOutput = 6, All = 7, NoRead } | ### 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 RunMode { DontCare, /** } | ### RunMode

The application does not receive notifications from the subprocess when it is finished or aborted.

KProcess () | ### KProcess

Constructor

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

bool setExecutable (const QString& proc) | ### setExecutable

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

KProcess & operator<< (const QString& arg) | ### operator<<

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"

Parameters:

arg | the argument to add

Returns: a reference to this KProcess

KProcess & operator<< (const char * arg) | ### operator<<

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

KProcess & operator<< (const QCString & arg) | ### operator<<

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

Parameters:

arg | the argument to add

Returns: a reference to this KProcess

KProcess & operator<< (const QStringList& args) | ### operator<<

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

Parameters:

arg | the arguments to add

Returns: a reference to this KProcess

void clearArguments () | ### clearArguments

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

bool start (RunMode runmode = NotifyOnExit, Communication comm = NoCommunication) | ### start

[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:

runmode | The Run-mode for the process.
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 kill (int signo = SIGTERM) | ### kill

[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 isRunning () | ### isRunning

[const]

Checks whether the process is running.

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

pid_t pid () | ### pid

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

Returns: the pid of the process or 0 if no process has been started yet.

pid_t getPid () | ### getPid

[const]

Use pid().

void suspend () | ### suspend

Suspend processing of data from stdout of the child process.

void resume () | ### resume

Resume processing of data from stdout of the child process.

bool normalExit () | ### normalExit

[const]

Note that you should check KProcess::exitStatus() to determine whether the process completed its task successful or not.

Returns: true if the process has already finished and has exited "voluntarily", ie: it has not been killed by a signal.

int exitStatus () | ### exitStatus

[const]

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.

Returns: the exit status of the process

bool writeStdin (const char *buffer, int buflen) | ### writeStdin

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

Parameters:

buffer | the buffer to write. Do not free or modify it until you got a wroteStdin() or processHasExited() signal

Returns: false if an error has occurred

bool closeStdin () | ### 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 closeStdout () | ### 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().

bool closeStderr () | ### 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().

const QValueList<QCString> & args () | ### args

Lets you see what your arguments are for debugging.

Returns: the list of arguments

void setRunPrivileged (bool keepPrivileges) | ### setRunPrivileged

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

The default is false : drop privileges

Parameters:

true | to keep the privileges

bool runPrivileged () | ### runPrivileged

[const]

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

Returns: true if the process runs privileged

void setEnvironment (const QString &name, const QString &value) | ### setEnvironment

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

Parameters:

name | the name of the environment variable
value | the new value for the environment variable

void setWorkingDirectory (const QString &dir) | ### setWorkingDirectory

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

Parameters:

dir | the new directory

void setUseShell (bool useShell, const char *shell = 0) | ### setUseShell

Specify whether to start the command via a shell or directly. The default is to start the command directly. If `useShell` is true `shell` will be used as shell, or if shell is empty, the standard shell is used. `quote` A flag indicating whether to quote the arguments.

When using a shell, the caller should make sure that all filenames etc. are properly quoted when passed as argument.

Parameters:

useShell | true if the command should be started via a shell
shell | the path to the shell that will execute the process, or 0 to use the standard shell

See also: quote()

QString quote (const QString &arg) | ### quote

[static]

This function can be used to quote an argument string such that the shell processes it properly. This is e. g. necessary for user-provided file names which may contain spaces or quotes. It also prevents expansion of wild cards and environment variables.

Parameters:

arg | the argument to quite

Returns: the quoted argument

void detach () | ### 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.

void processExited (KProcess *proc) | ### processExited

[signal]

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

Parameters:

proc | a pointer to the process that has exited

void receivedStdout (KProcess *proc, char *buffer, int buflen) | ### receivedStdout

[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. Example: QString myBuf = QString::fromLatin1(buffer, buflen);

Parameters:

proc | a pointer to the process that has received the output
buffer | The data received.
buflen | The number of bytes that are available.

void receivedStdout (int fd, int &len) | ### receivedStdout

[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`.

Parameters:

fd | the file descriptor that provides the data
len | the number of bytes that have been read from fd must be written here

void receivedStderr (KProcess *proc, char *buffer, int buflen) | ### receivedStderr

[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:

proc | a pointer to the process that has received the data
buffer | The data received.
buflen | The number of bytes that are available.

void wroteStdin (KProcess *proc) | ### wroteStdin

[signal]

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

Parameters:

proc | a pointer to the process

void slotChildOutput (int fdno) | ### slotChildOutput

[protected slots slot]

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

Parameters:

the | file descriptor for the output

void slotChildError (int fdno) | ### slotChildError

[protected slots slot]

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

Parameters:

the | file descriptor for the output

void slotSendData (int dummy) | ### slotSendData

[protected slots 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".

Parameters:

dummy | ignore this argument

void setupEnvironment () | ### setupEnvironment

[protected]

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

QValueList<QCString> arguments | ### arguments

[protected]

RunMode run_mode | ### run_mode

[protected]

bool runs | ### runs

[protected]

pid_t pid_ | ### pid_

[protected]

int status | ### status

[protected]

bool keepPrivs | ### keepPrivs

[protected]

int setupCommunication (Communication comm) | ### setupCommunication

[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 commSetupDoneP () | ### 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.

int commSetupDoneC () | ### 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.

void processHasExited (int state) | ### processHasExited

[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 commClose () | ### commClose

[protected virtual]

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

int out[2] | ### out[2]

[protected]

int in[2] | ### in[2]

[protected]

int err[2] | ### err[2]

[protected]

QSocketNotifier * innot | ### innot

[protected]

QSocketNotifier * outnot | ### outnot

[protected]

QSocketNotifier * errnot | ### errnot

[protected]

Communication communication | ### communication

[protected]

int childOutput (int fdno) | ### childOutput

[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 childError (int fdno) | ### childError

[protected]

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

const char * input_data | ### input_data

[protected]

int input_sent | ### input_sent

[protected]

int input_total | ### input_total

[protected]

friend class KProcessController | ### KProcessController

[protected]

void virtual_hook ( int id, void* data ) | ### virtual_hook

[protected virtual]

- Author: Christian Czezakte e9025461@student.tuwien.ac.at
- Generated: root on macppc.ports.openbsd.org on Sat Sep 6 10:36:15 2003, using kdoc 2.0a54.