oprocess.h

Go to the documentation of this file.

/*
                            This file is part of the Opie Project
                            Copyright (C) 2003-2004 Holger Freyther <zecke@handhelds.org>
                            Copyright (C) The Opie Team <opie-devel@handhelds.org>
             =.             Based on KProcess (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at)
           .=l.
          .>+-=
_;:,     .>    :=|.         This program is free software; you can
.> <`_,   >  .   <=         redistribute it and/or  modify it under
:`=1 )Y*s>-.--   :          the terms of the GNU Library General Public
.="- .-=="i,     .._        License as published by the Free Software
- .   .-<_>     .<>         Foundation; either version 2 of the License,
    ._= =}       :          or (at your option) any later version.
   .%`+i>       _;_.
   .i_,=:_.      -<s.       This program is distributed in the hope that
    +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
   : ..    .:,     . . .    without even the implied warranty of
   =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
 _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
..}^=.=       =       ;     Library General Public License for more
++=   -.     .`     .:      details.
:     =  ...= . :.=-
-.   .:....=;==+<;          You should have received a copy of the GNU
 -_. . .   )=.  =           Library General Public License along with
   --        :-=`           this library; see the file COPYING.LIB.
                            If not, write to the Free Software Foundation,
                            Inc., 59 Temple Place - Suite 330,
                            Boston, MA 02111-1307, USA.
*/

#ifndef OPROCESS_H
#define OPROCESS_H

/* QT */
#include <qcstring.h>
#include <qobject.h>
#include <qvaluelist.h>

/* STD */
#include <sys/types.h> // for pid_t
#include <sys/wait.h>
#include <signal.h>
#include <unistd.h>

class QSocketNotifier;

namespace Opie {
namespace Core {
namespace Internal {
class OProcessController;
class OProcessPrivate;
}

class OProcess : public QObject
{
    Q_OBJECT

public:

    enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
                         AllOutput = 6, All = 7,
                         NoRead };

    enum RunMode {
        DontCare,
        NotifyOnExit,
        Block };

    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 );

    virtual ~OProcess();

    bool setExecutable( const QString& proc );


    OProcess &operator<<( const QString& arg );
    OProcess &operator<<( const char * arg );
    OProcess &operator<<( const QCString & arg );

    OProcess &operator<<( const QStringList& args );

    void clearArguments();

    virtual bool start( RunMode runmode = NotifyOnExit,
                        Communication comm = NoCommunication );

    virtual bool kill( int signo = SIGTERM );

    bool isRunning() const;

    pid_t pid() const;

    void suspend();

    void resume();

    bool normalExit() const;

    int exitStatus() const;


    bool writeStdin( const char *buffer, int buflen );

    void flushStdin();

    bool closeStdin();

    bool closeStdout();

    bool closeStderr();

    const QValueList<QCString> &args()
    {
        return arguments;
    }

    void setRunPrivileged( bool keepPrivileges );

    bool runPrivileged() const;

    void setEnvironment( const QString &name, const QString &value );

    void setWorkingDirectory( const QString &dir );

    void setUseShell( bool useShell, const char *shell = 0 );

    static QString quote( const QString &arg );

    void detach();

    static int processPID( const QString& process );

signals:

    void processExited( Opie::Core::OProcess *proc );


    void receivedStdout( Opie::Core::OProcess *proc, char *buffer, int buflen );

    void receivedStdout( int fd, int &len );


    void receivedStderr( Opie::Core::OProcess *proc, char *buffer, int buflen );

    void wroteStdin( Opie::Core::OProcess *proc );

protected slots:

    void slotChildOutput( int fdno );

    void slotChildError( int fdno );
    /*
    Slot functions for capturing stdout and stderr of the child
    */

    void slotSendData( int dummy );

protected:

    void setupEnvironment();

    QValueList<QCString> arguments;
    RunMode run_mode;
    bool runs;

    pid_t pid_;

    int status;


    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
    */

    virtual int setupCommunication( Communication comm );

    virtual int commSetupDoneP();

    virtual int commSetupDoneC();


    virtual void processHasExited( int state );

    virtual void commClose();


    int out[ 2 ];
    int in[ 2 ];
    int err[ 2 ];

    QSocketNotifier *innot;
    QSocketNotifier *outnot;
    QSocketNotifier *errnot;

    Communication communication;

    int childOutput( 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

    friend class Internal::OProcessController;

private:
    QCString searchShell();

    bool isExecutable( const QCString &filename );

    // Disallow assignment and copy-construction
    OProcess( const OProcess& );
    OProcess& operator= ( const OProcess& );

private:
    void init ( );
    Internal::OProcessPrivate *d;
};
}
}

#endif

---