summaryrefslogtreecommitdiff
authormickeyl <mickeyl>2004-01-13 19:20:49 (UTC)
committer mickeyl <mickeyl>2004-01-13 19:20:49 (UTC)
commit81b48fa5be4806e3afa64a0d1fa254fbdf9b7315 (patch) (side-by-side diff)
treea28289a6d048ec80e359233a6b72bd946a9b8eb8
parent399cf645e63e53043975fa2b26768d8db6d83ee4 (diff)
downloadopie-81b48fa5be4806e3afa64a0d1fa254fbdf9b7315.zip
opie-81b48fa5be4806e3afa64a0d1fa254fbdf9b7315.tar.gz
opie-81b48fa5be4806e3afa64a0d1fa254fbdf9b7315.tar.bz2
cleanup and unify source layout
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--libopie2/opiecore/oprocess.cpp689
-rw-r--r--libopie2/opiecore/oprocess.h152
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,51 +1,55 @@
-/* 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.
*
@@ -132,25 +136,25 @@ class OProcessPrivate;
*
*@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,
@@ -178,86 +182,86 @@ public:
/**
* 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.
@@ -269,34 +273,34 @@ public:
* @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.
*
@@ -324,25 +328,25 @@ public:
*/
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
@@ -351,25 +355,25 @@ public:
* 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();
@@ -386,175 +390,175 @@ public:
* 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.
@@ -615,25 +619,25 @@ protected:
* 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.
*/
@@ -645,103 +649,99 @@ protected:
* "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