cleanup and unify source layout

2 files changed, 109 insertions, 164 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,95 +1,74 @@
 /*
- 
-   $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,
+                            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;
     QString wd;
     QCString shell;
 };
@@ -140,55 +119,49 @@ void OProcess::init ( )
     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)
         d = new OProcessPrivate;
     d->env.insert(name, value);
 }
 
-void
-OProcess::setWorkingDirectory(const QString &dir)
+void OProcess::setWorkingDirectory( const QString &dir )
 {
     if (!d)
         d = new OProcessPrivate;
     d->wd = dir;
 }
 
-void
-OProcess::setupEnvironment()
+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)
+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")
@@ -221,15 +194,17 @@ void OProcess::detach()
     closeStdout();
     closeStderr();
 }
 
 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));
 
     return true;
@@ -313,12 +288,13 @@ bool OProcess::start(RunMode runmode, Communication comm)
 
     // 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))
     {
@@ -338,15 +314,17 @@ bool OProcess::start(RunMode runmode, Communication comm)
         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!" );
 
@@ -388,13 +366,14 @@ bool OProcess::start(RunMode runmode, Communication comm)
         // 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)
                 {
                     // Error
@@ -445,44 +424,34 @@ bool OProcess::kill(int 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)));
 }
 
-
-
 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
@@ -580,53 +549,36 @@ bool OProcess::closeStderr()
     }
     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;
@@ -638,14 +590,12 @@ void OProcess::processHasExited(int state)
         {
             emit processExited(this);
         }
     }
 }
 
-
-
 int OProcess::childOutput(int fdno)
 {
     if (communication & NoRead)
     {
         int len = -1;
         emit receivedStdout(fdno, len);
@@ -664,28 +614,24 @@ int OProcess::childOutput(int fdno)
             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;
 
@@ -699,14 +645,12 @@ int OProcess::setupCommunication(Communication comm)
     if (comm & Stderr)
         ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, err) >= 0;
 
     return ok;
 }
 
-
-
 int OProcess::commSetupDoneP()
 {
     int ok = 1;
 
     if (communication != NoCommunication)
     {
@@ -716,13 +660,14 @@ int OProcess::commSetupDoneP()
             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)
         {
             //        ok &= (-1 != fcntl(in[1], F_SETFL, O_NONBLOCK));
             innot =  new QSocketNotifier(in[1], QSocketNotifier::Write, this);
             CHECK_PTR(innot);
@@ -751,14 +696,12 @@ int OProcess::commSetupDoneP()
                              this, SLOT(slotChildError(int)));
         }
     }
     return ok;
 }
 
-
-
 int OProcess::commSetupDoneC()
 {
     int ok = 1;
     struct linger so;
     memset(&so, 0, sizeof(so));
 
@@ -799,14 +742,12 @@ int OProcess::commSetupDoneC()
         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);
@@ -862,26 +803,29 @@ void OProcess::commClose()
                     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 ( fds_ready <= 0 )
+                    break;
 
                 if (b_out && FD_ISSET(out[0], &rfds))
                 {
                     int ret = 1;
-                    while (ret > 0) ret = childOutput(out[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))
                 {
                     int ret = 1;
-                    while (ret > 0) ret = childError(err[0]);
+                    while ( ret > 0 )
+                        ret = childError( err[ 0 ] );
                     if ((ret == -1 && errno != EAGAIN) || ret == 0)
                         b_err = false;
                 }
             }
         }
 
@@ -935,17 +879,19 @@ QCString OProcess::searchShell()
 }
 
 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))  ||
@@ -957,14 +903,13 @@ bool OProcess::isExecutable(const QCString &filename)
             (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,45 +1,49 @@
-/* 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,
+/*
+                            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.
@@ -138,13 +142,13 @@ class OProcessPrivate;
  *@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
 
@@ -392,13 +396,16 @@ public:
     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
@@ -451,14 +458,12 @@ public:
      * 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.
@@ -519,13 +524,12 @@ signals:
      * 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"
      */
@@ -706,13 +710,12 @@ protected:
     /**
      * @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
@@ -734,14 +737,11 @@ private:
     // Disallow assignment and copy-construction
     OProcess( const OProcess& );
     OProcess& operator= ( const OProcess& );
 
 private:
     void init ( );
-
     OProcessPrivate *d;
 };
 
-
-
 #endif