k3process.h

Go to the documentation of this file.

/* 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 K3PROCESS_H
#define K3PROCESS_H

#include <kde3support_export.h>

#include <QtCore/QObject>

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

class QSocketNotifier;
class K3ProcessPrivate;
class KPty;

class KDE3SUPPORT_EXPORT_DEPRECATED K3Process : public QObject
{
  Q_OBJECT

public:

  enum CommunicationFlag {
       NoCommunication = 0, 
       Stdin = 1, 
       Stdout = 2, 
       Stderr = 4, 
       AllOutput = 6, 
       All = 7, 
       NoRead = 8, 
       CTtyOnly = NoRead, 
       MergedStderr = 16  
  };

  Q_DECLARE_FLAGS(Communication, CommunicationFlag)

  
  enum RunMode {
       DontCare,
       NotifyOnExit,
       Block,
       OwnGroup
  };

  explicit K3Process( QObject* parent=0L );

  virtual ~K3Process();

  K3Process &operator<<(const QString& arg);
  K3Process &operator<<(const char * arg);
  K3Process &operator<<(const QByteArray & arg);

  K3Process &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 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 QList<QByteArray> &args() /* const */ { 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();

  void setUsePty(Communication comm, bool addUtmp);

  KPty *pty() const;

  enum { PrioLowest = 20, PrioLow = 10, PrioLower = 5, PrioNormal = 0,
    PrioHigher = -5, PrioHigh = -10, PrioHighest = -19 };

  bool setPriority(int prio);

Q_SIGNALS:
  void processExited(K3Process *proc);


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

  void receivedStdout(int fd, int &len); // KDE4: change, broken API


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

  void wroteStdin(K3Process *proc);


protected Q_SLOTS:

  void slotChildOutput(int fdno);

  void slotChildError(int fdno);

  void slotSendData(int dummy); // KDE 4: remove dummy

protected:

  void setupEnvironment();

  QList<QByteArray> 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];

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

  Communication communication;

  int childOutput(int fdno);

  int childError(int fdno);

  const char *input_data;
  int input_sent;
  int input_total;

  friend class K3ProcessController;

private:
  K3ProcessPrivate* const d;
};

Q_DECLARE_OPERATORS_FOR_FLAGS(K3Process::Communication)

class K3ShellProcessPrivate;

class KDE3SUPPORT_EXPORT_DEPRECATED K3ShellProcess : public K3Process
{
  Q_OBJECT

public:

  explicit K3ShellProcess(const char *shellname=0);

  ~K3ShellProcess();

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

  static QString quote(const QString &arg);

private:
  K3ShellProcessPrivate* const d;
};



#endif