| -rw-r--r-- | libopie2/opiecore/oprocess.cpp | 689 | ||||
| -rw-r--r-- | libopie2/opiecore/oprocess.h | 152 |
2 files changed, 393 insertions, 448 deletions
diff --git a/libopie2/opiecore/oprocess.cpp b/libopie2/opiecore/oprocess.cpp index fb51bf9..f1a5f3b 100644 --- a/libopie2/opiecore/oprocess.cpp +++ b/libopie2/opiecore/oprocess.cpp @@ -1,970 +1,915 @@ /* - - $Id$ - - This file is part of the KDE libraries - Copyright (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at) - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library 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. - + This file is part of the Opie Project + Copyright (C) 2002-2004 Holger Freyther <zecke@handhelds.org> + and 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. */ - -// -// KPROCESS -- A class for handling child processes in KDE without -// having to take care of Un*x specific implementation details -// -// version 0.3.1, Jan 8th 1998 -// -// (C) Christian Czezatke -// e9025461@student.tuwien.ac.at -// -// Changes: -// -// March 2nd, 1998: Changed parameter list for KShellProcess: -// Arguments are now placed in a single string so that -// <shell> -c <commandstring> is passed to the shell -// to make the use of "operator<<" consistent with KProcess -// -// -// Ported by Holger Freyther -// <zekce> Harlekin: oprocess and say it was ported to Qt by the Opie developers an Qt 2 - - - -#include "oprocess.h" -#define _MAY_INCLUDE_KPROCESSCONTROLLER_ #include "oprocctrl.h" -//#include <config.h> +/* OPIE */ +#include <opie2/oprocess.h> + +/* QT */ +#include <qapplication.h> #include <qfile.h> -#include <qsocketnotifier.h> +#include <qmap.h> #include <qregexp.h> +#include <qsocketnotifier.h> -#include <sys/time.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <sys/socket.h> - +/* STD */ #include <errno.h> #include <fcntl.h> +#include <pwd.h> #include <stdlib.h> #include <signal.h> #include <stdio.h> #include <string.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/socket.h> #include <unistd.h> #ifdef HAVE_SYS_SELECT_H #include <sys/select.h> #endif #ifdef HAVE_INITGROUPS #include <grp.h> #endif -#include <pwd.h> - -#include <qapplication.h> -#include <qmap.h> -//#include <kdebug.h> - -///////////////////////////// -// public member functions // -///////////////////////////// class OProcessPrivate { public: - OProcessPrivate() : useShell(false) { } + OProcessPrivate() : useShell( false ) + { } bool useShell; - QMap<QString,QString> env; + QMap<QString, QString> env; QString wd; QCString shell; }; -OProcess::OProcess(QObject *parent, const char *name) - : QObject(parent, name) +OProcess::OProcess( QObject *parent, const char *name ) + : QObject( parent, name ) { init ( ); } -OProcess::OProcess(const QString &arg0, QObject *parent, const char *name) - : QObject(parent, name) +OProcess::OProcess( const QString &arg0, QObject *parent, const char *name ) + : QObject( parent, name ) { init ( ); *this << arg0; } -OProcess::OProcess(const QStringList &args, QObject *parent, const char *name) - : QObject(parent, name) +OProcess::OProcess( const QStringList &args, QObject *parent, const char *name ) + : QObject( parent, name ) { init ( ); *this << args; } void OProcess::init ( ) { run_mode = NotifyOnExit; runs = false; pid_ = 0; status = 0; keepPrivs = false; innot = 0; outnot = 0; errnot = 0; communication = NoCommunication; input_data = 0; input_sent = 0; input_total = 0; d = 0; - if (0 == OProcessController::theOProcessController) + if ( 0 == OProcessController::theOProcessController ) { - (void) new OProcessController(); - CHECK_PTR(OProcessController::theOProcessController); + ( void ) new OProcessController(); + CHECK_PTR( OProcessController::theOProcessController ); } - OProcessController::theOProcessController->addOProcess(this); - out[0] = out[1] = -1; - in[0] = in[1] = -1; - err[0] = err[1] = -1; + OProcessController::theOProcessController->addOProcess( this ); + out[ 0 ] = out[ 1 ] = -1; + in[ 0 ] = in[ 1 ] = -1; + err[ 0 ] = err[ 1 ] = -1; } -void -OProcess::setEnvironment(const QString &name, const QString &value) +void OProcess::setEnvironment( const QString &name, const QString &value ) { - if (!d) + if ( !d ) d = new OProcessPrivate; - d->env.insert(name, value); + d->env.insert( name, value ); } -void -OProcess::setWorkingDirectory(const QString &dir) +void OProcess::setWorkingDirectory( const QString &dir ) { - if (!d) + if ( !d ) d = new OProcessPrivate; d->wd = dir; } -void -OProcess::setupEnvironment() +void OProcess::setupEnvironment() { - if (d) + if ( d ) { - QMap<QString,QString>::Iterator it; - for(it = d->env.begin(); it != d->env.end(); ++it) - setenv(QFile::encodeName(it.key()).data(), - QFile::encodeName(it.data()).data(), 1); - if (!d->wd.isEmpty()) - chdir(QFile::encodeName(d->wd).data()); + QMap<QString, QString>::Iterator it; + for ( it = d->env.begin(); it != d->env.end(); ++it ) + setenv( QFile::encodeName( it.key() ).data(), + QFile::encodeName( it.data() ).data(), 1 ); + if ( !d->wd.isEmpty() ) + chdir( QFile::encodeName( d->wd ).data() ); } } -void -OProcess::setRunPrivileged(bool keepPrivileges) +void OProcess::setRunPrivileged( bool keepPrivileges ) { keepPrivs = keepPrivileges; } -bool -OProcess::runPrivileged() const +bool OProcess::runPrivileged() const { return keepPrivs; } - OProcess::~OProcess() { // destroying the OProcess instance sends a SIGKILL to the // child process (if it is running) after removing it from the // list of valid processes (if the process is not started as // "DontCare") - OProcessController::theOProcessController->removeOProcess(this); + OProcessController::theOProcessController->removeOProcess( this ); // this must happen before we kill the child // TODO: block the signal while removing the current process from the process list - if (runs && (run_mode != DontCare)) - kill(SIGKILL); + if ( runs && ( run_mode != DontCare ) ) + kill( SIGKILL ); // Clean up open fd's and socket notifiers. closeStdin(); closeStdout(); closeStderr(); // TODO: restore SIGCHLD and SIGPIPE handler if this is the last OProcess delete d; } void OProcess::detach() { - OProcessController::theOProcessController->removeOProcess(this); + OProcessController::theOProcessController->removeOProcess( this ); runs = false; pid_ = 0; // Clean up open fd's and socket notifiers. closeStdin(); closeStdout(); closeStderr(); } -bool OProcess::setExecutable(const QString& proc) +bool OProcess::setExecutable( const QString& proc ) { - if (runs) return false; + if ( runs ) + return false; - if (proc.isEmpty()) return false; + if ( proc.isEmpty() ) + return false; - if (!arguments.isEmpty()) - arguments.remove(arguments.begin()); - arguments.prepend(QFile::encodeName(proc)); + if ( !arguments.isEmpty() ) + arguments.remove( arguments.begin() ); + arguments.prepend( QFile::encodeName( proc ) ); return true; } -OProcess &OProcess::operator<<(const QStringList& args) +OProcess &OProcess::operator<<( const QStringList& args ) { QStringList::ConstIterator it = args.begin(); for ( ; it != args.end() ; ++it ) - arguments.append(QFile::encodeName(*it)); + arguments.append( QFile::encodeName( *it ) ); return *this; } -OProcess &OProcess::operator<<(const QCString& arg) +OProcess &OProcess::operator<<( const QCString& arg ) { - return operator<< (arg.data()); + return operator<< ( arg.data() ); } -OProcess &OProcess::operator<<(const char* arg) +OProcess &OProcess::operator<<( const char* arg ) { - arguments.append(arg); + arguments.append( arg ); return *this; } -OProcess &OProcess::operator<<(const QString& arg) +OProcess &OProcess::operator<<( const QString& arg ) { - arguments.append(QFile::encodeName(arg)); + arguments.append( QFile::encodeName( arg ) ); return *this; } void OProcess::clearArguments() { arguments.clear(); } -bool OProcess::start(RunMode runmode, Communication comm) +bool OProcess::start( RunMode runmode, Communication comm ) { uint i; uint n = arguments.count(); char **arglist; - if (runs || (0 == n)) + if ( runs || ( 0 == n ) ) { return false; // cannot start a process that is already running // or if no executable has been assigned } run_mode = runmode; status = 0; QCString shellCmd; - if (d && d->useShell) + if ( d && d->useShell ) { - if (d->shell.isEmpty()) + if ( d->shell.isEmpty() ) { qWarning( "Could not find a valid shell" ); return false; } - arglist = static_cast<char **>(malloc( (4)*sizeof(char *))); - for (i=0; i < n; i++) + arglist = static_cast<char **>( malloc( ( 4 ) * sizeof( char * ) ) ); + for ( i = 0; i < n; i++ ) { - shellCmd += arguments[i]; + shellCmd += arguments[ i ]; shellCmd += " "; // CC: to separate the arguments } - arglist[0] = d->shell.data(); - arglist[1] = (char *) "-c"; - arglist[2] = shellCmd.data(); - arglist[3] = 0; + arglist[ 0 ] = d->shell.data(); + arglist[ 1 ] = ( char * ) "-c"; + arglist[ 2 ] = shellCmd.data(); + arglist[ 3 ] = 0; } else { - arglist = static_cast<char **>(malloc( (n+1)*sizeof(char *))); - for (i=0; i < n; i++) - arglist[i] = arguments[i].data(); - arglist[n]= 0; + arglist = static_cast<char **>( malloc( ( n + 1 ) * sizeof( char * ) ) ); + for ( i = 0; i < n; i++ ) + arglist[ i ] = arguments[ i ].data(); + arglist[ n ] = 0; } - if (!setupCommunication(comm)) - qWarning( "Could not setup Communication!"); + if ( !setupCommunication( comm ) ) + qWarning( "Could not setup Communication!" ); // We do this in the parent because if we do it in the child process // gdb gets confused when the application runs from gdb. uid_t uid = getuid(); gid_t gid = getgid(); #ifdef HAVE_INITGROUPS - struct passwd *pw = getpwuid(uid); + + struct passwd *pw = getpwuid( uid ); #endif - int fd[2]; - if (0 > pipe(fd)) + int fd[ 2 ]; + if ( 0 > pipe( fd ) ) { - fd[0] = fd[1] = 0; // Pipe failed.. continue + fd[ 0 ] = fd[ 1 ] = 0; // Pipe failed.. continue } runs = true; QApplication::flushX(); // WABA: Note that we use fork() and not vfork() because // vfork() has unclear semantics and is not standardized. pid_ = fork(); - if (0 == pid_) + if ( 0 == pid_ ) { - if (fd[0]) - close(fd[0]); - if (!runPrivileged()) + if ( fd[ 0 ] ) + close( fd[ 0 ] ); + if ( !runPrivileged() ) { - setgid(gid); + setgid( gid ); #if defined( HAVE_INITGROUPS) - if(pw) - initgroups(pw->pw_name, pw->pw_gid); + + if ( pw ) + initgroups( pw->pw_name, pw->pw_gid ); #endif - setuid(uid); + + setuid( uid ); } // The child process - if(!commSetupDoneC()) + if ( !commSetupDoneC() ) qWarning( "Could not finish comm setup in child!" ); setupEnvironment(); // Matthias - if (run_mode == DontCare) - setpgid(0,0); + if ( run_mode == DontCare ) + setpgid( 0, 0 ); // restore default SIGPIPE handler (Harri) struct sigaction act; - sigemptyset(&(act.sa_mask)); - sigaddset(&(act.sa_mask), SIGPIPE); + sigemptyset( &( act.sa_mask ) ); + sigaddset( &( act.sa_mask ), SIGPIPE ); act.sa_handler = SIG_DFL; act.sa_flags = 0; - sigaction(SIGPIPE, &act, 0L); + sigaction( SIGPIPE, &act, 0L ); // We set the close on exec flag. // Closing of fd[1] indicates that the execvp succeeded! - if (fd[1]) - fcntl(fd[1], F_SETFD, FD_CLOEXEC); - execvp(arglist[0], arglist); + if ( fd[ 1 ] ) + fcntl( fd[ 1 ], F_SETFD, FD_CLOEXEC ); + execvp( arglist[ 0 ], arglist ); char resultByte = 1; - if (fd[1]) - write(fd[1], &resultByte, 1); - _exit(-1); + if ( fd[ 1 ] ) + write( fd[ 1 ], &resultByte, 1 ); + _exit( -1 ); } - else if (-1 == pid_) + else if ( -1 == pid_ ) { // forking failed runs = false; - free(arglist); + free( arglist ); return false; } else { - if (fd[1]) - close(fd[1]); + if ( fd[ 1 ] ) + close( fd[ 1 ] ); // the parent continues here // Discard any data for stdin that might still be there input_data = 0; // Check whether client could be started. - if (fd[0]) for(;;) + if ( fd[ 0 ] ) + for ( ;; ) { char resultByte; - int n = ::read(fd[0], &resultByte, 1); - if (n == 1) + int n = ::read( fd[ 0 ], &resultByte, 1 ); + if ( n == 1 ) { // Error runs = false; - close(fd[0]); - free(arglist); + close( fd[ 0 ] ); + free( arglist ); pid_ = 0; return false; } - if (n == -1) + if ( n == -1 ) { - if ((errno == ECHILD) || (errno == EINTR)) + if ( ( errno == ECHILD ) || ( errno == EINTR ) ) continue; // Ignore } break; // success } - if (fd[0]) - close(fd[0]); + if ( fd[ 0 ] ) + close( fd[ 0 ] ); - if (!commSetupDoneP()) // finish communication socket setup for the parent + if ( !commSetupDoneP() ) // finish communication socket setup for the parent qWarning( "Could not finish comm setup in parent!" ); - if (run_mode == Block) + if ( run_mode == Block ) { commClose(); // The SIGCHLD handler of the process controller will catch // the exit and set the status - while(runs) + while ( runs ) { OProcessController::theOProcessController-> - slotDoHousekeeping(0); + slotDoHousekeeping( 0 ); } runs = FALSE; - emit processExited(this); + emit processExited( this ); } } - free(arglist); + free( arglist ); return true; } -bool OProcess::kill(int signo) +bool OProcess::kill( int signo ) { - bool rv=false; + bool rv = false; - if (0 != pid_) - rv= (-1 != ::kill(pid_, signo)); + if ( 0 != pid_ ) + rv = ( -1 != ::kill( pid_, signo ) ); // probably store errno somewhere... return rv; } - - bool OProcess::isRunning() const { return runs; } - - pid_t OProcess::pid() const { return pid_; } - - bool OProcess::normalExit() const { int _status = status; - return (pid_ != 0) && (!runs) && (WIFEXITED((_status))); + return ( pid_ != 0 ) && ( !runs ) && ( WIFEXITED( ( _status ) ) ); } - - int OProcess::exitStatus() const { int _status = status; - return WEXITSTATUS((_status)); + return WEXITSTATUS( ( _status ) ); } - - -bool OProcess::writeStdin(const char *buffer, int buflen) +bool OProcess::writeStdin( const char *buffer, int buflen ) { bool rv; // if there is still data pending, writing new data // to stdout is not allowed (since it could also confuse // kprocess... - if (0 != input_data) + if ( 0 != input_data ) return false; - if (runs && (communication & Stdin)) + if ( runs && ( communication & Stdin ) ) { input_data = buffer; input_sent = 0; input_total = buflen; - slotSendData(0); - innot->setEnabled(true); + slotSendData( 0 ); + innot->setEnabled( true ); rv = true; } else rv = false; return rv; } void OProcess::flushStdin ( ) { - if ( !input_data || ( input_sent == input_total )) - return; + if ( !input_data || ( input_sent == input_total ) ) + return ; int d1, d2; do { d1 = input_total - input_sent; slotSendData ( 0 ); d2 = input_total - input_sent; } while ( d2 <= d1 ); } void OProcess::suspend() { - if ((communication & Stdout) && outnot) - outnot->setEnabled(false); + if ( ( communication & Stdout ) && outnot ) + outnot->setEnabled( false ); } void OProcess::resume() { - if ((communication & Stdout) && outnot) - outnot->setEnabled(true); + if ( ( communication & Stdout ) && outnot ) + outnot->setEnabled( true ); } bool OProcess::closeStdin() { bool rv; - if (communication & Stdin) + if ( communication & Stdin ) { - communication = (Communication) (communication & ~Stdin); + communication = ( Communication ) ( communication & ~Stdin ); delete innot; innot = 0; - close(in[1]); + close( in[ 1 ] ); rv = true; } else rv = false; return rv; } bool OProcess::closeStdout() { bool rv; - if (communication & Stdout) + if ( communication & Stdout ) { - communication = (Communication) (communication & ~Stdout); + communication = ( Communication ) ( communication & ~Stdout ); delete outnot; outnot = 0; - close(out[0]); + close( out[ 0 ] ); rv = true; } else rv = false; return rv; } bool OProcess::closeStderr() { bool rv; - if (communication & Stderr) + if ( communication & Stderr ) { - communication = static_cast<Communication>(communication & ~Stderr); + communication = static_cast<Communication>( communication & ~Stderr ); delete errnot; errnot = 0; - close(err[0]); + close( err[ 0 ] ); rv = true; } else rv = false; return rv; } - -///////////////////////////// -// protected slots // -///////////////////////////// - - - -void OProcess::slotChildOutput(int fdno) +void OProcess::slotChildOutput( int fdno ) { - if (!childOutput(fdno)) + if ( !childOutput( fdno ) ) closeStdout(); } - -void OProcess::slotChildError(int fdno) +void OProcess::slotChildError( int fdno ) { - if (!childError(fdno)) + if ( !childError( fdno ) ) closeStderr(); } - -void OProcess::slotSendData(int) +void OProcess::slotSendData( int ) { - if (input_sent == input_total) + if ( input_sent == input_total ) { - innot->setEnabled(false); + innot->setEnabled( false ); input_data = 0; - emit wroteStdin(this); + emit wroteStdin( this ); } else - input_sent += ::write(in[1], input_data+input_sent, input_total-input_sent); + input_sent += ::write( in[ 1 ], input_data + input_sent, input_total - input_sent ); } - - -////////////////////////////// -// private member functions // -////////////////////////////// - - - -void OProcess::processHasExited(int state) +void OProcess::processHasExited( int state ) { - if (runs) + if ( runs ) { runs = false; status = state; commClose(); // cleanup communication sockets // also emit a signal if the process was run Blocking - if (DontCare != run_mode) + if ( DontCare != run_mode ) { - emit processExited(this); + emit processExited( this ); } } } - - -int OProcess::childOutput(int fdno) +int OProcess::childOutput( int fdno ) { - if (communication & NoRead) + if ( communication & NoRead ) { int len = -1; - emit receivedStdout(fdno, len); + emit receivedStdout( fdno, len ); errno = 0; // Make sure errno doesn't read "EAGAIN" return len; } else { - char buffer[1024]; + char buffer[ 1024 ]; int len; - len = ::read(fdno, buffer, 1024); + len = ::read( fdno, buffer, 1024 ); - if ( 0 < len) + if ( 0 < len ) { - emit receivedStdout(this, buffer, len); + emit receivedStdout( this, buffer, len ); } return len; } } - - -int OProcess::childError(int fdno) +int OProcess::childError( int fdno ) { - char buffer[1024]; + char buffer[ 1024 ]; int len; - len = ::read(fdno, buffer, 1024); + len = ::read( fdno, buffer, 1024 ); - if ( 0 < len) - emit receivedStderr(this, buffer, len); + if ( 0 < len ) + emit receivedStderr( this, buffer, len ); return len; } - - -int OProcess::setupCommunication(Communication comm) +int OProcess::setupCommunication( Communication comm ) { int ok; communication = comm; ok = 1; - if (comm & Stdin) - ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, in) >= 0; + if ( comm & Stdin ) + ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, in ) >= 0; - if (comm & Stdout) - ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, out) >= 0; + if ( comm & Stdout ) + ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, out ) >= 0; - if (comm & Stderr) - ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, err) >= 0; + if ( comm & Stderr ) + ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, err ) >= 0; return ok; } - - int OProcess::commSetupDoneP() { int ok = 1; - if (communication != NoCommunication) + if ( communication != NoCommunication ) { - if (communication & Stdin) - close(in[0]); - if (communication & Stdout) - close(out[1]); - if (communication & Stderr) - close(err[1]); + if ( communication & Stdin ) + close( in[ 0 ] ); + if ( communication & Stdout ) + close( out[ 1 ] ); + if ( communication & Stderr ) + close( err[ 1 ] ); // Don't create socket notifiers and set the sockets non-blocking if // blocking is requested. - if (run_mode == Block) return ok; + if ( run_mode == Block ) + return ok; - if (communication & Stdin) + if ( communication & Stdin ) { // ok &= (-1 != fcntl(in[1], F_SETFL, O_NONBLOCK)); - innot = new QSocketNotifier(in[1], QSocketNotifier::Write, this); - CHECK_PTR(innot); - innot->setEnabled(false); // will be enabled when data has to be sent - QObject::connect(innot, SIGNAL(activated(int)), - this, SLOT(slotSendData(int))); + innot = new QSocketNotifier( in[ 1 ], QSocketNotifier::Write, this ); + CHECK_PTR( innot ); + innot->setEnabled( false ); // will be enabled when data has to be sent + QObject::connect( innot, SIGNAL( activated( int ) ), + this, SLOT( slotSendData( int ) ) ); } - if (communication & Stdout) + if ( communication & Stdout ) { // ok &= (-1 != fcntl(out[0], F_SETFL, O_NONBLOCK)); - outnot = new QSocketNotifier(out[0], QSocketNotifier::Read, this); - CHECK_PTR(outnot); - QObject::connect(outnot, SIGNAL(activated(int)), - this, SLOT(slotChildOutput(int))); - if (communication & NoRead) + outnot = new QSocketNotifier( out[ 0 ], QSocketNotifier::Read, this ); + CHECK_PTR( outnot ); + QObject::connect( outnot, SIGNAL( activated( int ) ), + this, SLOT( slotChildOutput( int ) ) ); + if ( communication & NoRead ) suspend(); } - if (communication & Stderr) + if ( communication & Stderr ) { // ok &= (-1 != fcntl(err[0], F_SETFL, O_NONBLOCK)); - errnot = new QSocketNotifier(err[0], QSocketNotifier::Read, this ); - CHECK_PTR(errnot); - QObject::connect(errnot, SIGNAL(activated(int)), - this, SLOT(slotChildError(int))); + errnot = new QSocketNotifier( err[ 0 ], QSocketNotifier::Read, this ); + CHECK_PTR( errnot ); + QObject::connect( errnot, SIGNAL( activated( int ) ), + this, SLOT( slotChildError( int ) ) ); } } return ok; } - - int OProcess::commSetupDoneC() { int ok = 1; struct linger so; - memset(&so, 0, sizeof(so)); + memset( &so, 0, sizeof( so ) ); - if (communication & Stdin) - close(in[1]); - if (communication & Stdout) - close(out[0]); - if (communication & Stderr) - close(err[0]); + if ( communication & Stdin ) + close( in[ 1 ] ); + if ( communication & Stdout ) + close( out[ 0 ] ); + if ( communication & Stderr ) + close( err[ 0 ] ); - if (communication & Stdin) - ok &= dup2(in[0], STDIN_FILENO) != -1; + if ( communication & Stdin ) + ok &= dup2( in[ 0 ], STDIN_FILENO ) != -1; else { int null_fd = open( "/dev/null", O_RDONLY ); ok &= dup2( null_fd, STDIN_FILENO ) != -1; close( null_fd ); } - if (communication & Stdout) + if ( communication & Stdout ) { - ok &= dup2(out[1], STDOUT_FILENO) != -1; - ok &= !setsockopt(out[1], SOL_SOCKET, SO_LINGER, (char*)&so, sizeof(so)); + ok &= dup2( out[ 1 ], STDOUT_FILENO ) != -1; + ok &= !setsockopt( out[ 1 ], SOL_SOCKET, SO_LINGER, ( char* ) & so, sizeof( so ) ); } else { int null_fd = open( "/dev/null", O_WRONLY ); ok &= dup2( null_fd, STDOUT_FILENO ) != -1; close( null_fd ); } - if (communication & Stderr) + if ( communication & Stderr ) { - ok &= dup2(err[1], STDERR_FILENO) != -1; - ok &= !setsockopt(err[1], SOL_SOCKET, SO_LINGER, reinterpret_cast<char *>(&so), sizeof(so)); + ok &= dup2( err[ 1 ], STDERR_FILENO ) != -1; + ok &= !setsockopt( err[ 1 ], SOL_SOCKET, SO_LINGER, reinterpret_cast<char *>( &so ), sizeof( so ) ); } else { int null_fd = open( "/dev/null", O_WRONLY ); ok &= dup2( null_fd, STDERR_FILENO ) != -1; close( null_fd ); } return ok; } - - void OProcess::commClose() { - if (NoCommunication != communication) + if ( NoCommunication != communication ) { - bool b_in = (communication & Stdin); - bool b_out = (communication & Stdout); - bool b_err = (communication & Stderr); - if (b_in) + bool b_in = ( communication & Stdin ); + bool b_out = ( communication & Stdout ); + bool b_err = ( communication & Stderr ); + if ( b_in ) delete innot; - if (b_out || b_err) + if ( b_out || b_err ) { // If both channels are being read we need to make sure that one socket buffer // doesn't fill up whilst we are waiting for data on the other (causing a deadlock). // Hence we need to use select. // Once one or other of the channels has reached EOF (or given an error) go back // to the usual mechanism. int fds_ready = 1; fd_set rfds; int max_fd = 0; - if (b_out) + if ( b_out ) { - fcntl(out[0], F_SETFL, O_NONBLOCK); - if (out[0] > max_fd) - max_fd = out[0]; + fcntl( out[ 0 ], F_SETFL, O_NONBLOCK ); + if ( out[ 0 ] > max_fd ) + max_fd = out[ 0 ]; delete outnot; outnot = 0; } - if (b_err) + if ( b_err ) { - fcntl(err[0], F_SETFL, O_NONBLOCK); - if (err[0] > max_fd) - max_fd = err[0]; + fcntl( err[ 0 ], F_SETFL, O_NONBLOCK ); + if ( err[ 0 ] > max_fd ) + max_fd = err[ 0 ]; delete errnot; errnot = 0; } - while (b_out || b_err) + while ( b_out || b_err ) { // * If the process is still running we block until we // receive data. (p_timeout = 0, no timeout) // * If the process has already exited, we only check // the available data, we don't wait for more. // (p_timeout = &timeout, timeout immediately) struct timeval timeout; timeout.tv_sec = 0; timeout.tv_usec = 0; struct timeval *p_timeout = runs ? 0 : &timeout; - FD_ZERO(&rfds); - if (b_out) - FD_SET(out[0], &rfds); + FD_ZERO( &rfds ); + if ( b_out ) + FD_SET( out[ 0 ], &rfds ); - if (b_err) - FD_SET(err[0], &rfds); + if ( b_err ) + FD_SET( err[ 0 ], &rfds ); - fds_ready = select(max_fd+1, &rfds, 0, 0, p_timeout); - if (fds_ready <= 0) break; + fds_ready = select( max_fd + 1, &rfds, 0, 0, p_timeout ); + if ( fds_ready <= 0 ) + break; - if (b_out && FD_ISSET(out[0], &rfds)) + if ( b_out && FD_ISSET( out[ 0 ], &rfds ) ) { int ret = 1; - while (ret > 0) ret = childOutput(out[0]); - if ((ret == -1 && errno != EAGAIN) || ret == 0) + while ( ret > 0 ) + ret = childOutput( out[ 0 ] ); + if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 ) b_out = false; } - if (b_err && FD_ISSET(err[0], &rfds)) + if ( b_err && FD_ISSET( err[ 0 ], &rfds ) ) { int ret = 1; - while (ret > 0) ret = childError(err[0]); - if ((ret == -1 && errno != EAGAIN) || ret == 0) + while ( ret > 0 ) + ret = childError( err[ 0 ] ); + if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 ) b_err = false; } } } - if (b_in) + if ( b_in ) { - communication = (Communication) (communication & ~Stdin); - close(in[1]); + communication = ( Communication ) ( communication & ~Stdin ); + close( in[ 1 ] ); } - if (b_out) + if ( b_out ) { - communication = (Communication) (communication & ~Stdout); - close(out[0]); + communication = ( Communication ) ( communication & ~Stdout ); + close( out[ 0 ] ); } - if (b_err) + if ( b_err ) { - communication = (Communication) (communication & ~Stderr); - close(err[0]); + communication = ( Communication ) ( communication & ~Stderr ); + close( err[ 0 ] ); } } } -void OProcess::setUseShell(bool useShell, const char *shell) +void OProcess::setUseShell( bool useShell, const char *shell ) { - if (!d) + if ( !d ) d = new OProcessPrivate; d->useShell = useShell; d->shell = shell; - if (d->shell.isEmpty()) + if ( d->shell.isEmpty() ) d->shell = searchShell(); } -QString OProcess::quote(const QString &arg) +QString OProcess::quote( const QString &arg ) { QString res = arg; - res.replace(QRegExp(QString::fromLatin1("\'")), - QString::fromLatin1("'\"'\"'")); - res.prepend('\''); - res.append('\''); + res.replace( QRegExp( QString::fromLatin1( "\'" ) ), + QString::fromLatin1( "'\"'\"'" ) ); + res.prepend( '\'' ); + res.append( '\'' ); return res; } QCString OProcess::searchShell() { - QCString tmpShell = QCString(getenv("SHELL")).stripWhiteSpace(); - if (!isExecutable(tmpShell)) + QCString tmpShell = QCString( getenv( "SHELL" ) ).stripWhiteSpace(); + if ( !isExecutable( tmpShell ) ) { tmpShell = "/bin/sh"; } return tmpShell; } -bool OProcess::isExecutable(const QCString &filename) +bool OProcess::isExecutable( const QCString &filename ) { struct stat fileinfo; - if (filename.isEmpty()) return false; + if ( filename.isEmpty() ) + return false; // CC: we've got a valid filename, now let's see whether we can execute that file - if (-1 == stat(filename.data(), &fileinfo)) return false; + if ( -1 == stat( filename.data(), &fileinfo ) ) + return false; // CC: return false if the file does not exist // CC: anyway, we cannot execute directories, block/character devices, fifos or sockets - if ( (S_ISDIR(fileinfo.st_mode)) || - (S_ISCHR(fileinfo.st_mode)) || - (S_ISBLK(fileinfo.st_mode)) || + if ( ( S_ISDIR( fileinfo.st_mode ) ) || + ( S_ISCHR( fileinfo.st_mode ) ) || + ( S_ISBLK( fileinfo.st_mode ) ) || #ifdef S_ISSOCK // CC: SYSVR4 systems don't have that macro - (S_ISSOCK(fileinfo.st_mode)) || + ( S_ISSOCK( fileinfo.st_mode ) ) || #endif - (S_ISFIFO(fileinfo.st_mode)) || - (S_ISDIR(fileinfo.st_mode)) ) + ( S_ISFIFO( fileinfo.st_mode ) ) || + ( S_ISDIR( fileinfo.st_mode ) ) ) { return false; } // CC: now check for permission to execute the file - if (access(filename.data(), X_OK) != 0) return false; + if ( access( filename.data(), X_OK ) != 0 ) + return false; // CC: we've passed all the tests... return true; } - - diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h index 8dd19b5..352485b 100644 --- a/libopie2/opiecore/oprocess.h +++ b/libopie2/opiecore/oprocess.h @@ -1,55 +1,59 @@ -/* This file is part of the KDE libraries - Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at) - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library 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. +/* + 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. */ -// -// KPROCESS -- A class for handling child processes in KDE without -// having to take care of Un*x specific implementation details -// -// version 0.3.1, Jan 8th 1998 -// -// (C) Christian Czezatke -// e9025461@student.tuwien.ac.at -// Ported by Holger Freyther to the Open Palmtop Integrated Environment -// - -#ifndef __kprocess_h__ -#define __kprocess_h__ +#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> -#include <qvaluelist.h> -#include <qcstring.h> -#include <qobject.h> class QSocketNotifier; 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: @@ -128,33 +132,33 @@ class OProcessPrivate; *without a communication channel to stderr. * * *@sect QT signals: * *@li void @ref receivedStdout(OProcess *proc, char *buffer, int buflen); *@li void @ref receivedStderr(OProcess *proc, char *buffer, int buflen); *@li -- Indicates that new data has arrived from either the *child process's stdout or stderr. * *@li void @ref wroteStdin(OProcess *proc); *@li -- Indicates that all data that has been sent to the child process *by a prior call to @ref writeStdin() has actually been transmitted to the *client . * *@author Christian Czezakte e9025461@student.tuwien.ac.at - * + *@author Holger Freyther (Opie Port) * **/ class OProcess : public QObject { Q_OBJECT public: /** * 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 @p Stdin @p | @p Stdout * @@ -174,133 +178,133 @@ public: * The application does not receive notifications from the subprocess when * it is finished or aborted. */ DontCare, /** * The application is notified when the subprocess dies. */ NotifyOnExit, /** * The application is suspended until the started process is finished. */ Block }; /** * Constructor */ - OProcess(QObject *parent = 0, const char *name = 0); + OProcess( QObject *parent = 0, const char *name = 0 ); /** * Constructor */ - OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0); + OProcess( const QString &arg0, QObject *parent = 0, const char *name = 0 ); /** * Constructor */ - OProcess(const QStringList &args, QObject *parent = 0, const char *name = 0); + OProcess( const QStringList &args, QObject *parent = 0, const char *name = 0 ); /** *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 @p DontCare. * Processes started as @p DontCare keep running anyway. */ virtual ~OProcess(); /** @deprecated 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 operator<< */ - bool setExecutable(const QString& proc); + bool setExecutable( const QString& proc ); /** * 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: * <pre> * OProcess p; * ... * p << "ls" << "-l" << "/usr/local/bin" * </pre> * **/ - OProcess &operator<<(const QString& arg); + OProcess &operator<<( const QString& arg ); /** * Similar to previous method, takes a char *, supposed to be in locale 8 bit already. */ - OProcess &operator<<(const char * arg); + OProcess &operator<<( const char * arg ); /** * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already. */ - OProcess &operator<<(const QCString & arg); + OProcess &operator<<( const QCString & arg ); /** * Sets the executable and the command line argument list for this process, * in a single method call, or add a list of arguments. **/ - OProcess &operator<<(const QStringList& args); + OProcess &operator<<( const QStringList& args ); /** * Clear a command line argument list that has been set by using * the "operator<<". */ void clearArguments(); /** * 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: * * @li The process is already running. * @li The command line argument list is empty. * @li The starting of the process failed (could not fork). * @li The executable was not found. * * @param 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. * * @return true on success, false on error * (see above for error conditions) **/ - virtual bool start(RunMode runmode = NotifyOnExit, - Communication comm = NoCommunication); + virtual bool start( RunMode runmode = NotifyOnExit, + Communication comm = NoCommunication ); /** * Stop the process (by sending it a signal). * * @param signo The signal to send. The default is SIGTERM. * @return @p true if the signal was delivered successfully. */ - virtual bool kill(int signo = SIGTERM); + virtual bool kill( int signo = SIGTERM ); /** @return @p true if the process is (still) considered to be running */ bool isRunning() 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. **/ pid_t pid() const; @@ -320,60 +324,60 @@ public: * "voluntarily", ie: it has not been killed by a signal. * * Note that you should check @ref OProcess::exitStatus() to determine * whether the process completed its task successful or not. */ bool normalExit() const; /** * Returns the exit status of the process. * * Please use * @ref OProcess::normalExit() to check whether the process has exited * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling * this function because if the process did not exit normally, * it does not have a valid exit status. */ - int exitStatus() const; + int exitStatus() const; /** * Transmit data to the child process's stdin. * * OProcess::writeStdin may return false in the following cases: * * @li The process is not currently running. * * @li Communication to stdin has not been requested in the @ref start() call. * * @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); + 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. * @@ -382,183 +386,183 @@ public: */ 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. */ - const QValueList<QCString> &args() { return arguments; } + 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); + 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); + 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); + 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); + void setUseShell( bool useShell, const char *shell = 0 ); /** * 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. */ - static QString quote(const QString &arg); + static QString quote( const QString &arg ); /** * 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. */ void detach(); - - signals: /** * Emitted after the process has terminated when * the process was run in the @p NotifyOnExit (==default option to * @ref start()) or the @ref Block mode. **/ - void processExited(OProcess *proc); + void processExited( OProcess *proc ); /** * 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 @ref start(). * * @param buffer The data received. * @param buflen The number of bytes that are available. * * You should copy the information contained in @p buffer to your private * data structures before returning from this slot. **/ - void receivedStdout(OProcess *proc, char *buffer, int buflen); + void receivedStdout( OProcess *proc, char *buffer, int buflen ); /** * 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 @ref start() and the * @p 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 @p fd. **/ - void receivedStdout(int fd, int &len); + void receivedStdout( int fd, int &len ); /** * 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 @ref start(). * * @param buffer The data received. * @param buflen The number of bytes that are available. * * You should copy the information contained in @p buffer to your private * data structures before returning from this slot. */ - void receivedStderr(OProcess *proc, char *buffer, int buflen); + void receivedStderr( OProcess *proc, char *buffer, int buflen ); /** * Emitted after all the data that has been * specified by a prior call to @ref writeStdin() has actually been * written to the child process. **/ - void wroteStdin(OProcess *proc); - + void wroteStdin( OProcess *proc ); protected slots: /** * This slot gets activated when data from the child's stdout arrives. * It usually calls "childOutput" */ - void slotChildOutput(int fdno); + void slotChildOutput( int fdno ); /** * This slot gets activated when data from the child's stderr arrives. * It usually calls "childError" */ - void slotChildError(int fdno); + void slotChildError( int fdno ); /* Slot functions for capturing stdout and stderr of the child */ /** * 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". */ - void slotSendData(int dummy); + void slotSendData( int dummy ); protected: /** * Sets up the environment according to the data passed via * setEnvironment(...) */ void setupEnvironment(); /** * The list of the process' command line arguments. The first entry * in this list is the executable itself. */ QValueList<QCString> arguments; /** * How to run the process (Block, NotifyOnExit, DontCare). You should @@ -611,137 +615,133 @@ protected: after the process has exited */ /** * 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. */ - virtual int setupCommunication(Communication comm); + virtual int setupCommunication( Communication comm ); /** * 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. */ virtual int commSetupDoneP(); /** * 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 commSetupDoneC(); /** * 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). */ - virtual void processHasExited(int state); + virtual void processHasExited( int state ); /** * Should clean up the communication links to the child after it has * exited. Should be called from "processHasExited". */ virtual void commClose(); /** * the socket descriptors for stdin/stdout/stderr. */ - int out[2]; - int in[2]; - int err[2]; + 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); + 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); + 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; - 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); + bool isExecutable( const QCString &filename ); // Disallow assignment and copy-construction OProcess( const OProcess& ); OProcess& operator= ( const OProcess& ); private: void init ( ); - OProcessPrivate *d; }; - - #endif |