libopie API Documentation
Overview Class Hierarchy Classes Classes (annotated) Members Source Files Todo

OProcess Class Reference

Child process invocation, monitoring and control. More...

#include <oprocess.h>

Inheritance diagram for OProcess:

Inheritance graph
[legend]
Collaboration diagram for OProcess:

Collaboration graph
[legend]
List of all members.

Public Types

enum  Communication {
  NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
  AllOutput = 6, All = 7, NoRead
}
 Modes in which the communication channel can be opened. More...

enum  RunMode { DontCare, NotifyOnExit, Block }
 Run-modes for a child process. More...


Signals

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

void receivedStdout (OProcess *proc, char *buffer, int buflen)
 Emitted, when output from the child process has been received on stdout.

void receivedStdout (int fd, int &len)
 Emitted when output from the child process has been received on stdout.

void receivedStderr (OProcess *proc, char *buffer, int buflen)
 Emitted, when output from the child process has been received on stderr.

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


Public Member Functions

 OProcess (QObject *parent=0, const char *name=0)
 Constructor.

 OProcess (const QString &arg0, QObject *parent=0, const char *name=0)
 Constructor.

 OProcess (const QStringList &args, QObject *parent=0, const char *name=0)
 Constructor.

virtual ~OProcess ()
 Destructor:.

bool setExecutable (const QString &proc)
 This class or method is obsolete, it is provided for compatibility only.

OProcess & operator<< (const QString &arg)
 Sets the executable and the command line argument list for this process.

OProcess & operator<< (const char *arg)
 Similar to previous method, takes a char *, supposed to be in locale 8 bit already.

OProcess & operator<< (const QCString &arg)
 Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.

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

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

virtual bool start (RunMode runmode=NotifyOnExit, Communication comm=NoCommunication)
 Starts the process.

virtual bool kill (int signo=SIGTERM)
 Stop the process (by sending it a signal).

bool isRunning () const
pid_t pid () const
 Returns the process id of the process.

void suspend ()
 Suspend processing of data from stdout of the child process.

void resume ()
 Resume processing of data from stdout of the child process.

bool normalExit () const
int exitStatus () const
 Returns the exit status of the process.

bool writeStdin (const char *buffer, int buflen)
 Transmit data to the child process's stdin.

void flushStdin ()
bool closeStdin ()
 This causes the stdin file descriptor of the child process to be closed indicating an "EOF" to the child.

bool closeStdout ()
 This causes the stdout file descriptor of the child process to be closed.

bool closeStderr ()
 This causes the stderr file descriptor of the child process to be closed.

const QValueList< QCString > & args ()
 Lets you see what your arguments are for debugging.

void setRunPrivileged (bool keepPrivileges)
 Controls whether the started process should drop any setuid/segid privileges or whether it should keep them.

bool runPrivileged () const
 Returns whether the started process will drop any setuid/segid privileges or whether it will keep them.

void setEnvironment (const QString &name, const QString &value)
 Modifies the environment of the process to be started.

void setWorkingDirectory (const QString &dir)
 Changes the current working directory (CWD) of the process to be started.

void setUseShell (bool useShell, const char *shell=0)
 Specify whether to start the command via a shell or directly.

void detach ()
 Detaches OProcess from child process.


Static Public Member Functions

QString quote (const QString &arg)
 This function can be used to quote an argument string such that the shell processes it properly.


Protected Slots

void slotChildOutput (int fdno)
 This slot gets activated when data from the child's stdout arrives.

void slotChildError (int fdno)
 This slot gets activated when data from the child's stderr arrives.

void slotSendData (int dummy)
 Called when another bulk of data can be sent to the child's stdin.


Protected Member Functions

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

virtual int setupCommunication (Communication comm)
 This function is called from "OProcess::start" right before a "fork" takes place.

virtual int commSetupDoneP ()
 Called right after a (successful) fork on the parent side.

virtual int commSetupDoneC ()
 Called right after a (successful) fork, but before an "exec" on the child process' side.

virtual void processHasExited (int state)
 Immediately called after a process has exited.

virtual void commClose ()
 Should clean up the communication links to the child after it has exited.

int childOutput (int fdno)
 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)
 Called by "slotChildOutput" this function copies data arriving from the child process's stdout to the respective buffer and emits the signal " receivedStderr".


Protected Attributes

QValueList< QCString > arguments
 The list of the process' command line arguments.

RunMode run_mode
 How to run the process (Block, NotifyOnExit, DontCare).

bool runs
 true if the process is currently running.

pid_t pid_
 The PID of the currently running process (see "getPid()").

int status
 The process' exit status as returned by "waitpid".

bool keepPrivs
 See setRunPrivileged().

int out [2]
 the socket descriptors for stdin/stdout/stderr.

int in [2]
int err [2]
QSocketNotifier * innot
 The socket notifiers for the above socket descriptors.

QSocketNotifier * outnot
QSocketNotifier * errnot
Communication communication
 Lists the communication links that are activated for the child process.

const char * input_data
int input_sent
int input_total

Friends

class OProcessController
 OProcessController is a friend of OProcess because it has to have access to various data members.

Detailed Description

Child process invocation, monitoring and control.

General usage and features

This class allows a KDE and OPIE 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 OProcess 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 OProcess objects gets destructed, the child process will be killed if it is still running! This means in particular, that you cannot use a OProcess on the stack with OProcess::NotifyOnExit.

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


 *OProcess *proc = new OProcess;

 **proc << "my_executable";
 **proc << "These" << "are" << "the" << "command" << "line" << "args";
 *QApplication::connect(proc, SIGNAL(processExited(OProcess *)),
                      pointer_to_my_object, SLOT(my_objects_slot(OProcess *)));
 *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

OProcess 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):

QT signals:

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

Definition at line 147 of file oprocess.h.

Member Enumeration Documentation

enum OProcess::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.

Definition at line 165 of file oprocess.h.

Referenced by closeStdin(), closeStdout(), and commClose().

enum OProcess::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.

Definition at line 172 of file oprocess.h.

Constructor & Destructor Documentation

OProcess::OProcess (  QObject *  parent = 0,
const char *  name = 0
) 
 

Constructor.

Definition at line 97 of file oprocess.cpp.

OProcess::OProcess (  const QString &  arg0,
QObject *  parent = 0,
const char *  name = 0
) 
 

Constructor.

Definition at line 103 of file oprocess.cpp.

OProcess::OProcess (  const QStringList &  args,
QObject *  parent = 0,
const char *  name = 0
) 
 

Constructor.

Definition at line 110 of file oprocess.cpp.

OProcess::~OProcess (   )  [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.

Definition at line 187 of file oprocess.cpp.

References closeStderr(), closeStdin(), closeStdout(), DontCare, kill(), OProcessController::removeOProcess(), run_mode, and runs.

Member Function Documentation

bool OProcess::setExecutable (  const QString &  proc  ) 
 

This class or method is obsolete, it is provided for compatibility only.

The use of this function is now deprecated. -- Please use the "operator<<" instead of "setExecutable".

Sets the executable to be started with this OProcess object. Returns false if the process is currently running (in that case the executable remains unchanged.)

See also:
operator<<

Definition at line 223 of file oprocess.cpp.

References arguments, QValueList< QCString >::begin(), QValueList< QCString >::isEmpty(), QString::isEmpty(), QValueList< QCString >::prepend(), QValueList< QCString >::remove(), and runs.

OProcess & OProcess::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: 


  OProcess p;
  ...
  p << "ls" << "-l" << "/usr/local/bin"

Definition at line 255 of file oprocess.cpp.

References QValueList< QCString >::append(), and arguments.

Referenced by operator<<().

OProcess & OProcess::operator<< (  const char *  arg  ) 
 

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

Definition at line 249 of file oprocess.cpp.

References QValueList< QCString >::append(), and arguments.

OProcess & OProcess::operator<< (  const QCString &  arg  ) 
 

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

Definition at line 244 of file oprocess.cpp.

References QByteArray::data(), and operator<<().

OProcess & OProcess::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.

Definition at line 236 of file oprocess.cpp.

References QValueList< QCString >::append(), arguments, QValueList::begin(), and QValueList::end().

void OProcess::clearArguments (   ) 
 

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

Definition at line 261 of file oprocess.cpp.

References arguments, and QValueList< QCString >::clear().

bool OProcess::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 OProcess 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)

Definition at line 266 of file oprocess.cpp.

References arguments, Block, commClose(), commSetupDoneC(), commSetupDoneP(), QValueList< QCString >::count(), QByteArray::data(), DontCare, QApplication::flushX(), pid_, processExited(), run_mode, runPrivileged(), runs, setupCommunication(), setupEnvironment(), and status.

bool OProcess::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.

Definition at line 431 of file oprocess.cpp.

References pid_.

Referenced by ~OProcess().

bool OProcess::isRunning (   )  const
 

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

Definition at line 443 of file oprocess.cpp.

References runs.

pid_t OProcess::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 OProcess.

Calling it before any child process has been started by this OProcess instance causes pid() to return 0.

Definition at line 450 of file oprocess.cpp.

References pid_.

void OProcess::suspend (   ) 
 

Suspend processing of data from stdout of the child process.

Definition at line 509 of file oprocess.cpp.

References communication, and QSocketNotifier::setEnabled().

Referenced by commSetupDoneP().

void OProcess::resume (   ) 
 

Resume processing of data from stdout of the child process.

Definition at line 515 of file oprocess.cpp.

References communication, and QSocketNotifier::setEnabled().

bool OProcess::normalExit (   )  const
 

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 OProcess::exitStatus() to determine whether the process completed its task successful or not.

Definition at line 457 of file oprocess.cpp.

References pid_, runs, and status.

int OProcess::exitStatus (   )  const
 

Returns the exit status of the process.

Please use OProcess::normalExit() to check whether the process has exited cleanly (i.e., OProcess::normalExit() returns true) before calling this function because if the process did not exit normally, it does not have a valid exit status.

Definition at line 465 of file oprocess.cpp.

References status.

bool OProcess::writeStdin (  const char *  buffer,
int  buflen
) 
 

Transmit data to the child process's stdin.

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

Definition at line 473 of file oprocess.cpp.

References communication, innot, runs, QSocketNotifier::setEnabled(), and slotSendData().

bool OProcess::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().

Definition at line 521 of file oprocess.cpp.

References Communication, communication, and innot.

Referenced by detach(), and ~OProcess().

bool OProcess::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().

Definition at line 536 of file oprocess.cpp.

References Communication, communication, and out.

Referenced by detach(), slotChildOutput(), and ~OProcess().

bool OProcess::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().

Definition at line 551 of file oprocess.cpp.

References communication.

Referenced by detach(), slotChildError(), and ~OProcess().

const QValueList<QCString>& OProcess::args (   )  [inline]
 

Lets you see what your arguments are for debugging.

Definition at line 398 of file oprocess.h.

References arguments.

void OProcess::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

Definition at line 175 of file oprocess.cpp.

References keepPrivs.

bool OProcess::runPrivileged (   )  const
 

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

Definition at line 181 of file oprocess.cpp.

References keepPrivs.

Referenced by start().

void OProcess::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.

Definition at line 145 of file oprocess.cpp.

void OProcess::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.

Definition at line 153 of file oprocess.cpp.

void OProcess::setUseShell (  bool  useShell,
const char *  shell = 0
) 
 

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.

See also:
quote()

Definition at line 863 of file oprocess.cpp.

QString OProcess::quote (  const QString &  arg  )  [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.

Definition at line 873 of file oprocess.cpp.

References QString::append(), QString::prepend(), and QString::replace().

void OProcess::detach (   ) 
 

Detaches OProcess from child process.

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

Definition at line 210 of file oprocess.cpp.

References closeStderr(), closeStdin(), closeStdout(), pid_, OProcessController::removeOProcess(), and runs.

void OProcess::processExited (  OProcess *  proc  )  [signal]
 

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

Referenced by processHasExited(), and start().

void OProcess::receivedStdout (  OProcess *  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.

Referenced by childOutput().

void OProcess::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 OProcess::receivedStderr (  OProcess *  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.

Referenced by childError().

void OProcess::wroteStdin (  OProcess *  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.

Referenced by slotSendData().

void OProcess::slotChildOutput (  int  fdno  )  [protected, slot]
 

This slot gets activated when data from the child's stdout arrives.

It usually calls "childOutput"

Definition at line 573 of file oprocess.cpp.

References childOutput(), and closeStdout().

Referenced by commSetupDoneP().

void OProcess::slotChildError (  int  fdno  )  [protected, slot]
 

This slot gets activated when data from the child's stderr arrives.

It usually calls "childError"

Definition at line 580 of file oprocess.cpp.

References childError(), and closeStderr().

Referenced by commSetupDoneP().

void OProcess::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".

Definition at line 587 of file oprocess.cpp.

References innot, QSocketNotifier::setEnabled(), and wroteStdin().

Referenced by commSetupDoneP(), and writeStdin().

void OProcess::setupEnvironment (   )  [protected]
 

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

Definition at line 161 of file oprocess.cpp.

References QFile::encodeName().

Referenced by start().

int OProcess::setupCommunication (  Communication  comm  )  [protected, virtual]
 

This function is called from "OProcess::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 OProcess.

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.

Definition at line 662 of file oprocess.cpp.

References communication, and out.

Referenced by start().

int OProcess::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 OProcess member functions.

For a more detailed explanation, it is best to have a look at the default implementation of "setupCommunication" in kprocess.cpp.

Definition at line 683 of file oprocess.cpp.

References Block, communication, QObject::connect(), innot, out, run_mode, QSocketNotifier::setEnabled(), slotChildError(), slotChildOutput(), slotSendData(), and suspend().

Referenced by start().

int OProcess::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.

Definition at line 731 of file oprocess.cpp.

References communication, and out.

Referenced by start().

void OProcess::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).

Definition at line 605 of file oprocess.cpp.

References commClose(), DontCare, processExited(), run_mode, runs, and status.

void OProcess::commClose (   )  [protected, virtual]
 

Should clean up the communication links to the child after it has exited.

Should be called from "processHasExited".

Definition at line 774 of file oprocess.cpp.

References childError(), childOutput(), Communication, communication, innot, out, and runs.

Referenced by processHasExited(), and start().

int OProcess::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".

Definition at line 624 of file oprocess.cpp.

References communication, and receivedStdout().

Referenced by commClose(), and slotChildOutput().

int OProcess::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".

Definition at line 648 of file oprocess.cpp.

References receivedStderr().

Referenced by commClose(), and slotChildError().

Friends And Related Function Documentation

friend class OProcessController [friend]
 

OProcessController is a friend of OProcess because it has to have access to various data members.

Definition at line 710 of file oprocess.h.

Member Data Documentation

QValueList<QCString> OProcess::arguments [protected]
 

The list of the process' command line arguments.

The first entry in this list is the executable itself.

Definition at line 562 of file oprocess.h.

Referenced by args(), clearArguments(), operator<<(), setExecutable(), and start().

RunMode OProcess::run_mode [protected]
 

How to run the process (Block, NotifyOnExit, DontCare).

You should not modify this data member directly from derived classes.

Definition at line 567 of file oprocess.h.

Referenced by commSetupDoneP(), processHasExited(), start(), and ~OProcess().

bool OProcess::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 OProcess.

Definition at line 575 of file oprocess.h.

Referenced by commClose(), detach(), isRunning(), normalExit(), processHasExited(), setExecutable(), start(), writeStdin(), and ~OProcess().

pid_t OProcess::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 OProcess.

Definition at line 584 of file oprocess.h.

Referenced by detach(), kill(), normalExit(), pid(), and start().

int OProcess::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 OProcess.

Definition at line 593 of file oprocess.h.

Referenced by exitStatus(), normalExit(), processHasExited(), and start().

bool OProcess::keepPrivs [protected]
 

See setRunPrivileged().

Definition at line 599 of file oprocess.h.

Referenced by runPrivileged(), and setRunPrivileged().

int OProcess::out[2] [protected]
 

the socket descriptors for stdin/stdout/stderr.

Definition at line 669 of file oprocess.h.

Referenced by closeStdout(), commClose(), commSetupDoneC(), commSetupDoneP(), and setupCommunication().

QSocketNotifier* OProcess::innot [protected]
 

The socket notifiers for the above socket descriptors.

Definition at line 676 of file oprocess.h.

Referenced by closeStdin(), commClose(), commSetupDoneP(), slotSendData(), and writeStdin().

Communication OProcess::communication [protected]
 

Lists the communication links that are activated for the child process.

Should not be modified from derived classes.

Definition at line 684 of file oprocess.h.

Referenced by childOutput(), closeStderr(), closeStdin(), closeStdout(), commClose(), commSetupDoneC(), commSetupDoneP(), resume(), setupCommunication(), suspend(), and writeStdin().

The documentation for this class was generated from the following files:
KDE Logo
This file is part of the documentation for OPIE Version 1.1.
Documentation copyright © 1997-2003 the KDE developers. 2003 OPIE developers
Generated on Tue Feb 10 20:24:58 2004 by doxygen 1.3.5 written by Dimitri van Heesch, © 1997-2001