libopie API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Todo

oprocess.h

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

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



signals:

  void processExited(OProcess *proc);


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

  void receivedStdout(int fd, int &len);


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

  void wroteStdin(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 OProcessController;


private:
  QCString searchShell();

  bool isExecutable(const QCString &filename);

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

private:
  void init ( );

  OProcessPrivate *d;
};



#endif

This file is part of the documentation for OPIE Version 1.1.

Documentation copyright © 1997-2003 the KDE developers. 2003 OPIE developers
Generated on Tue Feb 10 20:24:44 2004 by doxygen 1.3.5 written by Dimitri van Heesch, © 1997-2001