2 files changed, 56 insertions, 110 deletions

diff --git a/libopie/oprocess.cpp b/libopie/oprocess.cpp
index f3e52bd..5db2b6c 100644
--- a/libopie/oprocess.cpp
+++ b/libopie/oprocess.cpp
@@ -1,922 +1,926 @@
 /*
 
    $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.
 
 */
 
 
 //
 //  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>
 
 #include <qfile.h>
 #include <qsocketnotifier.h>
 #include <qregexp.h>
 
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/socket.h>
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <stdio.h>
 #include <string.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) { }
 
    bool useShell;
    QMap<QString,QString> env;
    QString wd;
    QCString shell;
 };
 
 
-OProcess::OProcess()
-  : QObject(),
-    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)
+OProcess::OProcess(QObject *parent, const char *name)
+  : QObject(parent, name)
 {
+  init ( );
+}
+
+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)
+{
+  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) {
         (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;
 }
 
 void
 OProcess::setEnvironment(const QString &name, const QString &value)
 {
    if (!d)
       d = new OProcessPrivate;
    d->env.insert(name, value);
 }
 
 void
 OProcess::setWorkingDirectory(const QString &dir)
 {
    if (!d)
       d = new OProcessPrivate;
    d->wd = dir;   
 } 
 
 void 
 OProcess::setupEnvironment()
 {
    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());
    }
 }
 
 void
 OProcess::setRunPrivileged(bool keepPrivileges)
 {
    keepPrivs = keepPrivileges;
 }
 
 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);
   // 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);
 
   // 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);
 
   runs = false;
   pid_ = 0;
 
   // Clean up open fd's and socket notifiers.
   closeStdin();
   closeStdout();
   closeStderr();
 }
 
 bool OProcess::setExecutable(const QString& proc)
 {
   if (runs) return false;
 
   if (proc.isEmpty())  return false;
 
   if (!arguments.isEmpty())
      arguments.remove(arguments.begin());
   arguments.prepend(QFile::encodeName(proc));
 
   return true;
 }
 
 OProcess &OProcess::operator<<(const QStringList& args)
 {
   QStringList::ConstIterator it = args.begin();
   for ( ; it != args.end() ; ++it )
       arguments.append(QFile::encodeName(*it));
   return *this;
 }
 
 OProcess &OProcess::operator<<(const QCString& arg)
 {
   return operator<< (arg.data());
 }
 
 OProcess &OProcess::operator<<(const char* arg)
 {
   arguments.append(arg);
   return *this;
 }
 
 OProcess &OProcess::operator<<(const QString& arg)
 {
   arguments.append(QFile::encodeName(arg));
   return *this;
 }
 
 void OProcess::clearArguments()
 {
   arguments.clear();
 }
 
 bool OProcess::start(RunMode runmode, Communication comm)
 {
   uint i;
   uint n = arguments.count();
   char **arglist;
 
   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->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++) {
           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;
   }
   else
   {
       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!");
     
   // 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);
 #endif
 
   int fd[2];
   if (0 > pipe(fd))
   {
      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 (fd[0])
            close(fd[0]);
         if (!runPrivileged())
         {
            setgid(gid);
 #if defined( HAVE_INITGROUPS)
            if(pw)
               initgroups(pw->pw_name, pw->pw_gid);
 #endif
            setuid(uid);
         }
         // The child process
         if(!commSetupDoneC())
           qWarning( "Could not finish comm setup in child!" );
           
         setupEnvironment();
 
         // Matthias
         if (run_mode == DontCare)
           setpgid(0,0);
         // restore default SIGPIPE handler (Harri)
         struct sigaction act;
         sigemptyset(&(act.sa_mask));
         sigaddset(&(act.sa_mask), SIGPIPE);
         act.sa_handler = SIG_DFL;
         act.sa_flags = 0;
         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);
         char resultByte = 1;
         if (fd[1])
           write(fd[1], &resultByte, 1);
         _exit(-1);
   } else if (-1 == pid_) {
         // forking failed
 
         runs = false;
         free(arglist);
         return false;
   } else {
         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(;;)
         {
            char resultByte;
            int n = ::read(fd[0], &resultByte, 1);
            if (n == 1)
            {
                // Error
                runs = false;
                close(fd[0]);
                free(arglist);
                pid_ = 0;
                return false;
            }
            if (n == -1)
            {
               if ((errno == ECHILD) || (errno == EINTR))
                  continue; // Ignore
            }
            break; // success
         }
         if (fd[0])
            close(fd[0]);
 
         if (!commSetupDoneP())  // finish communication socket setup for the parent
           qWarning( "Could not finish comm setup in parent!" );
 
         if (run_mode == Block) {
           commClose();
 
           // The SIGCHLD handler of the process controller will catch
           // the exit and set the status
           while(runs)
           {
              OProcessController::theOProcessController->
                   slotDoHousekeeping(0);
           }
           runs = FALSE;
           emit processExited(this);
         }
   }
   free(arglist);
   return true;
 }
 
 
 
 bool OProcess::kill(int signo)
 {
   bool rv=false;
 
   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)));
 }
 
 
 
 int OProcess::exitStatus() const
 {
   int _status = status;
   return WEXITSTATUS((_status));
 }
 
 
 
 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)
     return false;
 
   if (runs && (communication & Stdin)) {
     input_data = buffer;
     input_sent = 0;
     input_total = buflen;
     slotSendData(0);
     innot->setEnabled(true);
     rv = true;
   } else
     rv = false;
   return rv;
 }
 
+void OProcess::flushStdin ( )
+{
+        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);
 }
 
 void OProcess::resume()
 {
   if ((communication & Stdout) && outnot)
      outnot->setEnabled(true);
 }
 
 bool OProcess::closeStdin()
 {
   bool rv;
 
   if (communication & Stdin) {
     communication = (Communication) (communication & ~Stdin);
     delete innot;
     innot = 0;
     close(in[1]);
     rv = true;
   } else
     rv = false;
   return rv;
 }
 
 bool OProcess::closeStdout()
 {
   bool rv;
 
   if (communication & Stdout) {
     communication = (Communication) (communication & ~Stdout);
     delete outnot;
     outnot = 0;
     close(out[0]);
     rv = true;
   } else
     rv = false;
   return rv;
 }
 
 bool OProcess::closeStderr()
 {
   bool rv;
 
   if (communication & Stderr) {
     communication = static_cast<Communication>(communication & ~Stderr);
     delete errnot;
     errnot = 0;
     close(err[0]);
     rv = true;
   } else
     rv = false;
   return rv;
 }
 
 
 /////////////////////////////
 // protected slots         //
 /////////////////////////////
 
 
 
 void OProcess::slotChildOutput(int fdno)
 {
   if (!childOutput(fdno))
      closeStdout();
 }
 
 
 void OProcess::slotChildError(int fdno)
 {
   if (!childError(fdno))
      closeStderr();
 }
 
 
 void OProcess::slotSendData(int)
 {
   if (input_sent == input_total) {
     innot->setEnabled(false);
     input_data = 0;
     emit wroteStdin(this);
   } else
     input_sent += ::write(in[1], input_data+input_sent, input_total-input_sent);
 }
 
 
 
 //////////////////////////////
 // private member functions //
 //////////////////////////////
 
 
 
 void OProcess::processHasExited(int state)
 {
   if (runs)
   {
     runs = false;
     status = state;
 
     commClose(); // cleanup communication sockets
 
     // also emit a signal if the process was run Blocking
     if (DontCare != run_mode)
     {
       emit processExited(this);
     }
   }
 }
 
 
 
 int OProcess::childOutput(int fdno)
 {
   if (communication & NoRead) {
      int len = -1;
      emit receivedStdout(fdno, len);
      errno = 0; // Make sure errno doesn't read "EAGAIN"
      return len;
   }
   else
   {
      char buffer[1024];
      int len;
 
      len = ::read(fdno, buffer, 1024);
 
      if ( 0 < len) {
         emit receivedStdout(this, buffer, len);
      }
      return len;
   }
 }
 
 
 
 int OProcess::childError(int fdno)
 {
   char buffer[1024];
   int len;
 
   len = ::read(fdno, buffer, 1024);
 
   if ( 0 < len)
         emit receivedStderr(this, buffer, len);
   return len;
 }
 
 
 
 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 & Stdout)
         ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, out) >= 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 & 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 (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)));
         }
 
         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)
               suspend();
         }
 
         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)));
         }
   }
   return ok;
 }
 
 
 
 int OProcess::commSetupDoneC()
 {
   int ok = 1;
   struct linger 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)
     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) {
     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) {
     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) {
         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 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) {
             fcntl(out[0], F_SETFL, O_NONBLOCK);
             if (out[0] > max_fd)
               max_fd = out[0];
             delete outnot;
             outnot = 0;
           }
           if (b_err) {
             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) {
             // * 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);
 
             if (b_err)
               FD_SET(err[0], &rfds);
 
             fds_ready = select(max_fd+1, &rfds, 0, 0, p_timeout);
             if (fds_ready <= 0) break;
 
             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)
                  b_out = false;
             }
 
             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)
                  b_err = false;
             }
           }
         }
 
         if (b_in) {
             communication = (Communication) (communication & ~Stdin);
             close(in[1]);
         }
         if (b_out) {
             communication = (Communication) (communication & ~Stdout);
             close(out[0]);
         }
         if (b_err) {
             communication = (Communication) (communication & ~Stderr);
             close(err[0]);
         }
   }
 }
 
 void OProcess::setUseShell(bool useShell, const char *shell)
 {
   if (!d)
     d = new OProcessPrivate;
   d->useShell = useShell;
   d->shell = shell;
   if (d->shell.isEmpty())
      d->shell = searchShell();
 }
 
 QString OProcess::quote(const QString &arg)
 {
     QString res = arg;
     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))
   {
      tmpShell = "/bin/sh";
   }
 
   return tmpShell;
 }
 
 bool OProcess::isExecutable(const QCString &filename)
 {
   struct stat fileinfo;
 
   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;
   // 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))  ||
 #ifdef S_ISSOCK
        // CC: SYSVR4 systems don't have that macro
        (S_ISSOCK(fileinfo.st_mode)) ||
 #endif
        (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;
 
   // CC: we've passed all the tests...
   return true;
 }
 
-void OProcess::virtual_hook( int, void* )
-{ /*BASE::virtual_hook( id, data );*/ }
-
-
-///////////////////////////
-// CC: Class KShellProcess
-///////////////////////////
-
-KShellProcess::KShellProcess(const char *shellname):
-  OProcess()
-{
-  setUseShell(true, shellname);
-}
-
-
-KShellProcess::~KShellProcess() {
-}
-
-QString KShellProcess::quote(const QString &arg)
-{
-    return OProcess::quote(arg);
-}
-
-bool KShellProcess::start(RunMode runmode, Communication comm)
-{
-  return OProcess::start(runmode, comm);
-}
 
-void KShellProcess::virtual_hook( int id, void* data )
-{ OProcess::virtual_hook( id, data ); }
 
-//#include "kprocess.moc"
diff --git a/libopie/oprocess.h b/libopie/oprocess.h
index fd726b4..bf5fe0e 100644
--- a/libopie/oprocess.h
+++ b/libopie/oprocess.h
@@ -1,805 +1,747 @@
 /* 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.
 */
 //
 //  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__
 
 #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 application to start child processes without having
  *to worry about UN*X signal handling issues and zombie process reaping.
  *
  *@see KProcIO
  *
  *Basically, this class distinguishes three different ways of running
  *child processes:
  *
  *@li  OProcess::DontCare -- The child process is invoked and both the child
  *process and the parent process continue concurrently.
  *
  *Starting a  DontCare child process means that the application is
  *not interested in any notification to determine whether the
  *child process has already exited or not.
  *
  *@li  OProcess::NotifyOnExit -- The child process is invoked and both the
  *child and the parent process run concurrently.
  *
  *When the child process exits, the OProcess instance
  *corresponding to it emits the Qt signal @ref processExited().
  *
  *Since this signal is @em not emitted from within a UN*X
  *signal handler, arbitrary function calls can be made.
  *
  *Be aware: When the OProcess objects gets destructed, the child
  *process will be killed if it is still running!
  *This means in particular, that you cannot use a OProcess on the stack
  *with OProcess::NotifyOnExit.
  *
  *@li  OProcess::Block -- The child process starts and the parent process
  *is suspended until the child process exits. (@em Really not recommended
  *for programs with a GUI.)
  *
  *OProcess also provides several functions for determining the exit status
  *and the pid of the child process it represents.
  *
  *Furthermore it is possible to supply command-line arguments to the process
  *in a clean fashion (no null -- terminated stringlists and such...)
  *
  *A small usage example:
  *<pre>
  *OProcess *proc = new OProcess;
  *
  **proc << "my_executable";
  **proc << "These" << "are" << "the" << "command" << "line" << "args";
  *QApplication::connect(proc, SIGNAL(processExited(OProcess *)),
  *                      pointer_to_my_object, SLOT(my_objects_slot(OProcess *)));
  *proc->start();
  *</pre>
  *
  *This will start "my_executable" with the commandline arguments "These"...
  *
  *When the child process exits, the respective Qt signal will be emitted.
  *
  *@sect Communication with the child process
  *
  *OProcess supports communication with the child process through
  *stdin/stdout/stderr.
  *
  *The following functions are provided for getting data from the child
  *process or sending data to the child's stdin (For more information,
  *have a look at the documentation of each function):
  *
  *@li bool @ref writeStdin(char  *buffer, int  buflen);
  *@li  -- Transmit data to the child process's stdin.
  *
  *@li bool @ref closeStdin();
  *@li -- Closes the child process's stdin (which causes it to see an  feof(stdin)).
  *Returns false if you try to close stdin for a process that has been started
  *without a communication channel to stdin.
  *
  *@li bool @ref closeStdout();
  *@li -- Closes the child process's stdout.
  *Returns false if you try to close stdout for a process that has been started
  *without a communication channel to stdout.
  *
  *@li bool @ref closeStderr();
  *@li -- Closes the child process's stderr.
  *Returns false if you try to close stderr for a process that has been started
  *without a communication channel to stderr.
  *
  *
  *@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
  *
  *
  **/
 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
    *
    * If @p NoRead is specified in conjunction with @p Stdout,
    * no data is actually read from @p Stdout but only
    * the signal @ref childOutput(int fd) is emitted.
    */
   enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
                                            AllOutput = 6, All = 7,
                                            NoRead };
 
   /**
    * Run-modes for a child process.
    */
   enum RunMode {
       /**
        * 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();
+  OProcess(QObject *parent = 0, const char *name = 0);
+  OProcess(const QString &arg0, 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);
 
 
   /**
    * 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);
   /**
    * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
    */
   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);
 
   /**
    * 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);
 
   /**
    * 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);
 
   /**
    * Stop the process (by sending it a signal).
    *
            * @param signoThe signal to send. The default is SIGTERM.
    * @return @p true if the signal was delivered successfully.
   */
   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;
 
   /**
    * Use pid().
    * @deprecated
    */
   pid_t getPid() const { return pid(); }
 
   /**
    * Suspend processing of data from stdout of the child process.
    */
   void suspend();
 
   /**
    * Resume processing of data from stdout of the child process.
    */
   void resume();
 
   /**
    * @return @p true if the process has already finished and has exited
    *  "voluntarily", ie: it has not been killed by a signal.
    *
    * Note that you should check @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;
 
 
   /**
            * 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);
 
+  void flushStdin();
+
   /**
    * This causes the stdin file descriptor of the child process to be
    * closed indicating an "EOF" to the child.
    *
    * @return @p false if no communication to the process's stdin
    *  had been specified in the call to @ref start().
   */
   bool closeStdin();
 
   /**
    * This causes the stdout file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stdout
    *  had been specified in the call to @ref start().
   */
   bool closeStdout();
 
   /**
    * This causes the stderr file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stderr
    *  had been specified in the call to @ref start().
   */
   bool closeStderr();
 
   /**
    * Lets you see what your arguments are for debugging.
    */
 
   const QValueList<QCString> &args() { return arguments; }
 
   /**
    * Controls whether the started process should drop any
    * setuid/segid privileges or whether it should keep them
    *
    * The default is @p false : drop privileges
    */
   void setRunPrivileged(bool keepPrivileges);
 
   /**
    * Returns whether the started process will drop any
    * setuid/segid privileges or whether it will keep them
    */
   bool runPrivileged() const;
   
   /**
    * Modifies the environment of the process to be started.
    * This function must be called before starting the process.
    */
   void setEnvironment(const QString &name, const QString &value);
 
   /**
    * Changes the current working directory (CWD) of the process 
    * to be started.
    * This function must be called before starting the process.
    */
   void setWorkingDirectory(const QString &dir);
 
   /**
    * Specify whether to start the command via a shell or directly.
    * The default is to start the command directly.
    * If @p useShell is true @p shell will be used as shell, or
    * if shell is empty, the standard shell is used.
    * @p quote A flag indicating whether to quote the arguments.
    *
    * When using a shell, the caller should make sure that all filenames etc.
    * are properly quoted when passed as argument.
    * @see quote()
    */
   void setUseShell(bool useShell, const char *shell = 0);
 
   /**
    * 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);
 
   /**
    * 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);
 
 
   /**
    * 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);
 
   /**
    * 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);
 
 
   /**
    * 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);
 
   /**
    * 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);
 
 
 protected slots:
 
  /**
   * This slot gets activated when data from the child's stdout arrives.
   * It usually calls "childOutput"
   */
   void slotChildOutput(int fdno);
 
  /**
   * This slot gets activated when data from the child's stderr arrives.
   * It usually calls "childError"
   */
   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);
 
 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
    *  not modify this data member directly from derived classes.
    */
   RunMode run_mode;
   /**
    * true if the process is currently running. You should not
    * modify this data member directly from derived classes. For
    * reading the value of this data member, please use "isRunning()"
    * since "runs" will probably be made private in later versions
    * of OProcess.
    */
   bool runs;
 
   /**
    * The PID of the currently running process (see "getPid()").
    * You should not modify this data member in derived classes.
    * Please use "getPid()" instead of directly accessing this
    * member function since it will probably be made private in
    * later versions of OProcess.
    */
   pid_t pid_;
 
   /**
    * The process' exit status as returned by "waitpid". You should not
    * modify the value of this data member from derived classes. You should
    * rather use @ref exitStatus than accessing this data member directly
    * since it will probably be made private in further versions of
    * OProcess.
    */
   int status;
 
 
   /**
    * See setRunPrivileged()
    */
   bool keepPrivs;
 
   /*
         Functions for setting up the sockets for communication.
         setupCommunication
         -- is called from "start" before "fork"ing.
         commSetupDoneP
         -- completes communication socket setup in the parent
         commSetupDoneC
         -- completes communication setup in the child process
         commClose
         -- frees all allocated communication resources in the parent
         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);
 
   /**
    * 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);
 
   /**
    * 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];
 
   /**
    * The socket notifiers for the above socket descriptors.
    */
   QSocketNotifier *innot;
   QSocketNotifier *outnot;
   QSocketNotifier *errnot;
 
   /**
    * Lists the communication links that are activated for the child
    * process.  Should not be modified from derived classes.
    */
   Communication communication;
 
   /**
    * Called by "slotChildOutput" this function copies data arriving from the
    * child process's stdout to the respective buffer and emits the signal
    * "@ref receivedStderr".
    */
   int childOutput(int fdno);
 
   /**
    * Called by "slotChildOutput" this function copies data arriving from the
    * child process's stdout to the respective buffer and emits the signal
    * "@ref receivedStderr"
    */
   int childError(int fdno);
 
   // information about the data that has to be sent to the child:
 
   const char *input_data;  // the buffer holding the data
   int input_sent;    // # of bytes already transmitted
   int input_total;   // total length of input_data
 
   /**
    * @ref OProcessController is a friend of OProcess because it has to have
    * access to various data members.
    */
   friend class OProcessController;
 
 
 private:
   /**
    * Searches for a valid shell. 
    * Here is the algorithm used for finding an executable shell:
    *
    *    @li Try the executable pointed to by the "SHELL" environment
    *    variable with white spaces stripped off
    *
    *    @li If your process runs with uid != euid or gid != egid, a shell
    *    not listed in /etc/shells will not used.
    *
    *    @li If no valid shell could be found, "/bin/sh" is used as a last resort.
    */
   QCString searchShell();
 
   /**
    * Used by @ref searchShell in order to find out whether the shell found
    * is actually executable at all.
    */
   bool isExecutable(const QCString &filename);
 
   // Disallow assignment and copy-construction
   OProcess( const OProcess& );
   OProcess& operator= ( const OProcess& );
 
-protected:
-  virtual void virtual_hook( int id, void* data );
-private:
-  OProcessPrivate *d;
-};
-
-class KShellProcessPrivate;
-
-/**
-* @obsolete
-*
-* This class is obsolete. Use OProcess and OProcess::setUseShell(true)
-* instead.
-*
-*   @short A class derived from @ref OProcess to start child
-        *   processes through a shell.
-*   @author Christian Czezakte <e9025461@student.tuwien.ac.at>
-*   @version $Id$
-*/
-class KShellProcess: public OProcess
-{
-  Q_OBJECT
-
-public:
-
-  /**
-   * Constructor
-   *
-   * By specifying the name of a shell (like "/bin/bash") you can override
-   * the mechanism for finding a valid shell as described in OProcess::searchShell()
-   */
-  KShellProcess(const char *shellname=0);
-
-  /**
-   * Destructor.
-   */
-  ~KShellProcess();
-
-  /**
-   * Starts up the process. -- For a detailed description
-   * have a look at the "start" member function and the detailed
-   * description of @ref OProcess .
-   */
-  virtual bool start(RunMode  runmode = NotifyOnExit,
-                  Communication comm = NoCommunication);
-
-  /**
-   * 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);
-
 private:
+  void init ( );
 
-  QCString shell;
-
-  // Disallow assignment and copy-construction
-  KShellProcess( const KShellProcess& );
-  KShellProcess& operator= ( const KShellProcess& );
-
-protected:
-  virtual void virtual_hook( int id, void* data );
-private:
-  KShellProcessPrivate *d;
+  OProcessPrivate *d;
 };
 
 
 
 #endif