tdeprocess.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., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/
 
#ifndef __TDEPROCESS_H__
#define __TDEPROCESS_H__
 
#include <sys/types.h> // for pid_t
#include <sys/wait.h>
#include <signal.h>
#include <unistd.h>
#include <tqvaluelist.h>
#include <tqcstring.h>
#include <tqobject.h>
#include "tdelibs_export.h"
 
class TQSocketNotifier;
class TDEProcessPrivate;
 
#ifdef Q_OS_UNIX
#include <kpty.h>
#else
class KPty;
#endif
 
class TDECORE_EXPORT TDEProcess : public TQObject
{
  TQ_OBJECT
 
public:
 
  enum Communication {
       NoCommunication = 0,
       Stdin = 1, Stdout = 2, Stderr = 4,
       AllOutput = 6, All = 7,
       NoRead = 8,
       CTtyOnly = NoRead,
       MergedStderr = 16
  };
 
  enum RunMode {
       DontCare,
       NotifyOnExit,
       Block,
       OwnGroup
  };
 
  TDEProcess( TQObject* parent, const char *name = 0 );
 // KDE4 merge with the above
  TDEProcess();
 
  virtual ~TDEProcess();
 
  bool setExecutable(const TQString& proc) TDE_DEPRECATED;
 
 
  TDEProcess &operator<<(const TQString& arg);
  TDEProcess &operator<<(const char * arg);
  TDEProcess &operator<<(const TQCString & arg);
 
  TDEProcess &operator<<(const TQStringList& 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;
 
  TDE_DEPRECATED pid_t getPid() const { return pid(); }
 
  void suspend();
 
  void resume();
 
  bool wait(int timeout = -1);
 
  bool normalExit() const;
 
  bool signalled() const;
 
  bool coreDumped() const;
 
  int exitStatus() const;
 
  int exitSignal() const;
 
  bool writeStdin(const char *buffer, int buflen);
 
  bool closeStdin();
 
  bool closeStdout();
 
  bool closeStderr();
 
  bool closePty();
 
  void closeAll();
 
  const TQValueList<TQCString> &args() /* const */ { return arguments; }
 
  void setRunPrivileged(bool keepPrivileges);
 
  bool runPrivileged() const;
 
  void setEnvironment(const TQString &name, const TQString &value);
 
  void setWorkingDirectory(const TQString &dir);
 
  void setUseShell(bool useShell, const char *shell = 0);
 
  static TQString quote(const TQString &arg);
 
  void detach();
 
#ifdef Q_OS_UNIX
  void setUsePty(Communication comm, bool addUtmp);
 
  KPty *pty() const;
#endif
 
  enum { PrioLowest = 20, PrioLow = 10, PrioLower = 5, PrioNormal = 0,
    PrioHigher = -5, PrioHigh = -10, PrioHighest = -19 };
 
  bool setPriority(int prio);
 
signals:
  void processExited(TDEProcess *proc);
 
 
  void receivedStdout(TDEProcess *proc, char *buffer, int buflen);
 
  void receivedStdout(int fd, int &len); // KDE4: change, broken API
 
 
  void receivedStderr(TDEProcess *proc, char *buffer, int buflen);
 
  void wroteStdin(TDEProcess *proc);
 
 
protected slots:
 
  void slotChildOutput(int fdno);
 
  void slotChildError(int fdno);
 
  void slotSendData(int dummy); // KDE 4: remove dummy
 
protected:
 
  void setupEnvironment();
 
  TQValueList<TQCString> arguments;
  RunMode run_mode;
  bool runs;
 
  pid_t pid_;
 
  int status;
 
 
  bool keepPrivs;
 
  virtual int setupCommunication(Communication comm);
 
  virtual int commSetupDoneP();
 
  virtual int commSetupDoneC();
 
 
  virtual void processHasExited(int state);
 
  virtual void commClose();
 
  /* KDE 4 - commClose will be changed to perform cleanup only in all cases *
   * If @p notfd is -1, all data immediately available from the
   *  communication links should be processed.
   * If @p notfd is not -1, the communication links should be monitored
   *  for data until the file handle @p notfd becomes ready for reading.
   */
//  virtual void commDrain(int notfd);
 
  void setBinaryExecutable(const char *filename);
 
  int out[2];
  int in[2];
  int err[2];
 
  TQSocketNotifier *innot;
  TQSocketNotifier *outnot;
  TQSocketNotifier *errnot;
 
  Communication communication;
 
  int childOutput(int fdno);
 
  int childError(int fdno);
 
  const char *input_data;
  int input_sent;
  int input_total;
 
  friend class TDEProcessController;
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  TDEProcessPrivate *d;
};
 
class KShellProcessPrivate;
 
class TDECORE_EXPORT KShellProcess: public TDEProcess
{
  TQ_OBJECT
 
public:
 
  KShellProcess(const char *shellname=0);
 
  ~KShellProcess();
 
  virtual bool start(RunMode  runmode = NotifyOnExit,
          Communication comm = NoCommunication);
 
  static TQString quote(const TQString &arg);
 
private:
  TQCString shell;
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  KShellProcessPrivate *d;
};
 
#endif