-rw-r--r-- | libopie2/opiecore/oprocess.h | 13 |
1 files changed, 11 insertions, 2 deletions
diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h index 1a2472d..eb56b03 100644 --- a/libopie2/opiecore/oprocess.h +++ b/libopie2/opiecore/oprocess.h @@ -1,94 +1,100 @@ /* This file is part of the Opie Project Copyright (C) 2003-2004 Holger Freyther <zecke@handhelds.org> Copyright (C) The Opie Team <opie-devel@handhelds.org> =. Based on KProcess (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at) .=l. .>+-= _;:, .> :=|. This program is free software; you can .> <`_, > . <= redistribute it and/or modify it under :`=1 )Y*s>-.-- : the terms of the GNU Library General Public .="- .-=="i, .._ License as published by the Free Software - . .-<_> .<> Foundation; either version 2 of the License, ._= =} : or (at your option) any later version. .%`+i> _;_. .i_,=:_. -<s. This program is distributed in the hope that + . -:. = it will be useful, but WITHOUT ANY WARRANTY; : .. .:, . . . without even the implied warranty of =_ + =;=|` MERCHANTABILITY or FITNESS FOR A _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU ..}^=.= = ; Library General Public License for more ++= -. .` .: details. : = ...= . :.=- -. .:....=;==+<; You should have received a copy of the GNU -_. . . )=. = Library General Public License along with -- :-=` this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef OPROCESS_H #define OPROCESS_H /* QT */ #include <qcstring.h> #include <qobject.h> #include <qvaluelist.h> /* STD */ #include <sys/types.h> // for pid_t #include <sys/wait.h> #include <signal.h> #include <unistd.h> class QSocketNotifier; + +namespace Opie { +namespace Core { +namespace Private { +class OProcessController; class OProcessPrivate; +} /** * Child process invocation, monitoring and control. * * @sect 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 KProcIO * *Basically, this class distinguishes three different ways of running *child processes: * *@li OProcess::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. * *@li OProcess::NotifyOnExit -- The child process is invoked and both the *child and the parent process run concurrently. * *When the child process exits, the OProcess instance *corresponding to it emits the Qt signal @ref processExited(). * *Since this signal is @em 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. * *@li OProcess::Block -- The child process starts and the parent process *is suspended until the child process exits. (@em Really not recommended *for programs with a GUI.) * *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: *<pre> *OProcess *proc = new OProcess; @@ -352,96 +358,97 @@ public: * @li Transmission of data to the child process by a previous call to * @ref 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 * @ref wroteStdin() will be emitted. * * Please note that you must not free "buffer" or call @ref writeStdin() * again until either a @ref wroteStdin() signal indicates that the * data has been sent or a @ref processHasExited() signal shows that * the child process is no longer alive... **/ bool writeStdin( const char *buffer, int buflen ); void flushStdin(); /** * This causes the stdin file descriptor of the child process to be * closed indicating an "EOF" to the child. * * @return @p false if no communication to the process's stdin * had been specified in the call to @ref start(). */ bool closeStdin(); /** * This causes the stdout file descriptor of the child process to be * closed. * * @return @p false if no communication to the process's stdout * had been specified in the call to @ref start(). */ bool closeStdout(); /** * This causes the stderr file descriptor of the child process to be * closed. * * @return @p false if no communication to the process's stderr * had been specified in the call to @ref start(). */ bool closeStderr(); /** * Lets you see what your arguments are for debugging. + * \todo make const */ const QValueList<QCString> &args() { return arguments; } /** * Controls whether the started process should drop any * setuid/segid privileges or whether it should keep them * * The default is @p false : drop privileges */ void setRunPrivileged( bool keepPrivileges ); /** * Returns whether the started process will drop any * setuid/segid privileges or whether it will keep them */ bool runPrivileged() const; /** * Modifies the environment of the process to be started. * This function must be called before starting the process. */ void setEnvironment( const QString &name, const QString &value ); /** * Changes the current working directory (CWD) of the process * to be started. * This function must be called before starting the process. */ void setWorkingDirectory( const QString &dir ); /** * Specify whether to start the command via a shell or directly. * The default is to start the command directly. * If @p useShell is true @p shell will be used as shell, or * if shell is empty, the standard shell is used. * @p 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 quote() */ void setUseShell( bool useShell, const char *shell = 0 ); /** @@ -671,82 +678,84 @@ protected: */ virtual void commClose(); /** * the socket descriptors for stdin/stdout/stderr. */ int out[ 2 ]; int in[ 2 ]; int err[ 2 ]; /** * The socket notifiers for the above socket descriptors. */ QSocketNotifier *innot; QSocketNotifier *outnot; QSocketNotifier *errnot; /** * Lists the communication links that are activated for the child * process. Should not be modified from derived classes. */ Communication communication; /** * Called by "slotChildOutput" this function copies data arriving from the * child process's stdout to the respective buffer and emits the signal * "@ref receivedStderr". */ 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 * "@ref receivedStderr" */ int childError( int fdno ); // information about the data that has to be sent to the child: const char *input_data; // the buffer holding the data int input_sent; // # of bytes already transmitted int input_total; // total length of input_data /** * @ref OProcessController is a friend of OProcess because it has to have * access to various data members. */ - friend class OProcessController; + friend class Private::OProcessController; private: /** * Searches for a valid shell. * Here is the algorithm used for finding an executable shell: * * @li Try the executable pointed to by the "SHELL" environment * variable with white spaces stripped off * * @li If your process runs with uid != euid or gid != egid, a shell * not listed in /etc/shells will not used. * * @li If no valid shell could be found, "/bin/sh" is used as a last resort. */ QCString searchShell(); /** * Used by @ref searchShell in order to find out whether the shell found * is actually executable at all. */ bool isExecutable( const QCString &filename ); // Disallow assignment and copy-construction OProcess( const OProcess& ); OProcess& operator= ( const OProcess& ); private: void init ( ); - OProcessPrivate *d; + Private::OProcessPrivate *d; }; +} +} #endif |