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

#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 KProcessPrivate;

/**
 * Child process invocation, monitoring and control.
 *
 * @sect General usage and features
 *
 *This class allows a KDE application to start child processes without having
 *to worry about UN*X signal handling issues and zombie process reaping.
 *
 *@see KProcIO
 *
 *Basically, this class distinguishes three different ways of running
 *child processes:
 *
 *@li  KProcess::DontCare -- The child process is invoked and both the child
 *process and the parent process continue concurrently.
 *
 *Starting a  DontCare child process means that the application is
 *not interested in any notification to determine whether the
 *child process has already exited or not.
 *
 *@li  KProcess::NotifyOnExit -- The child process is invoked both the
 *child and the parent process run concurrently.
 *
 *When the child process exits, the KProcess instance
 *corresponding to it emits the Qt signal @ref processExited().
 *
 *Since this signal is @em not emitted from within a UN*X
 *signal handler, arbitrary function calls can be made.
 *
 *Be aware: When the KProcess objects gets destructed, the child
 *process will be killed if it is still running!
 *This means in particular, that you cannot use a KProcess on the stack
 *with KProcess::NotifyOnExit.
 *
 *@li  KProcess::Block -- The child process starts and the parent process
 *is suspended until the child process exits. (@em Really not recommended
 *for programs with a GUI.)
 *
 *KProcess also provides several functions for determining the exit status
 *and the pid of the child process it represents.
 *
 *Furthermore it is possible to supply command-line arguments to the process
 *in a clean fashion (no null -- terminated stringlists and such...)
 *
 *A small usage example:
 *<pre>
 *KProcess *proc = new KProcess;
 *
 **proc << "my_executable";
 **proc << "These" << "are" << "the" << "command" << "line" << "args";
 *QApplication::connect(proc, SIGNAL(processExited(KProcess *)),
 *                      pointer_to_my_object, SLOT(my_objects_slot(KProcess *)));
 *proc->start();
 *</pre>
 *
 *This will start "my_executable" with the commandline arguments "These"...
 *
 *When the child process exits, the respective Qt signal will be emitted.
 *
 *@sect Communication with the child process
 *
 *KProcess supports communication with the child process through
 *stdin/stdout/stderr.
 *
 *The following functions are provided for getting data from the child
 *process or sending data to the child's stdin (For more information,
 *have a look at the documentation of each function):
 *
 *@li bool @ref writeStdin(char  *buffer, int  buflen);
 *@li  -- Transmit data to the child process's stdin.
 *
 *@li bool @ref closeStdin();
 *@li -- Closes the child process's stdin (which causes it to see an  feof(stdin)).
 *Returns false if you try to close stdin for a process that has been started
 *without a communication channel to stdin.
 *
 *@li bool @ref closeStdout();
 *@li -- Closes the child process's stdout.
 *Returns false if you try to close stdout for a process that has been started
 *without a communication channel to stdout.
 *
 *@li bool @ref closeStderr();
 *@li -- Closes the child process's stderr.
 *Returns false if you try to close stderr for a process that has been started
 *without a communication channel to stderr.
 *
 *
 *@sect QT signals:
 *
 *@li void @ref receivedStdout(KProcess  *proc, char  *buffer, int  buflen);
 *@li  void @ref receivedStderr(KProcess  *proc, char  *buffer, int  buflen);
 *@li  -- Indicates that new data has arrived from either the
 *child process's stdout or stderr.
 *
 *@li  void @ref wroteStdin(KProcess  *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
 *
 *
 **/
class KProcess : public QObject
{
  Q_OBJECT

public:

  /**
   * Modes in which the communication channel can be opened.
   *
   * If communication for more than one channel is required,
   * the values have to be or'ed together, for example to get
   * communication with stdout as well as with stdin, you would
   * specify @p Stdin @p | @p Stdout
   *
   * If @p NoRead is specified in conjunction with @p Stdout,
   * no data is actually read from @p Stdout but only
   * the signal @ref childOutput(int fd) is emitted.
   */
  enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
					   AllOutput = 6, All = 7,
					   NoRead };

  /**
   * Run-modes for a child process.
   */
  enum RunMode {
      /**
       * The application does not receive notifications from the subprocess when
       * it is finished or aborted.
       */
       DontCare,
       /**
        * The application is notified when the subprocess dies.
        */
       NotifyOnExit,
       /**
        * The application is suspended until the started process is finished.
        */
       Block };

  /**
   * Constructor
   */
  KProcess();

  /**
   *Destructor:
   *
   *  If the process is running when the destructor for this class
   *  is called, the child process is killed with a SIGKILL, but
   *  only if the run mode is not of type @p DontCare.
   *  Processes started as @p DontCare keep running anyway.
  */
  virtual ~KProcess();

  /**
   @deprecated

         The use of this function is now deprecated. -- Please use the
	 "operator<<" instead of "setExecutable".

	 Sets the executable to be started with this KProcess object.
	 Returns false if the process is currently running (in that
	 case the executable remains unchanged.)

	 @see operator<<

  */
  bool setExecutable(const QString& proc);


  /**
   * Sets the executable and the command line argument list for this process.
   *
   * For example, doing an "ls -l /usr/local/bin" can be achieved by:
   *  <pre>
   *  KProcess p;
   *  ...
   *  p << "ls" << "-l" << "/usr/local/bin"
   *  </pre>
   *
   **/
  KProcess &operator<<(const QString& arg);
  /**
   * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
   */
  KProcess &operator<<(const char * arg);
  /**
   * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.
   */
  KProcess &operator<<(const QCString & arg);

  /**
   * Sets the executable and the command line argument list for this process,
   * in a single method call, or add a list of arguments.
   **/
  KProcess &operator<<(const QStringList& args);

  /**
   * Clear a command line argument list that has been set by using
   * the "operator<<".
  */
  void clearArguments();

  /**
   *  Starts the process.
   *  For a detailed description of the
   *  various run modes and communication semantics, have a look at the
   *  general description of the KProcess class.
   *
   *  The following problems could cause this function to
   *    return false:
   *
   *  @li The process is already running.
   *  @li The command line argument list is empty.
   *  @li The starting of the process failed (could not fork).
   *  @li The executable was not found.
   *
   *  @param comm  Specifies which communication links should be
   *  established to the child process (stdin/stdout/stderr). By default,
   *  no communication takes place and the respective communication
   *  signals will never get emitted.
   *
   *  @return true on success, false on error
   *  (see above for error conditions)
   **/
  virtual bool start(RunMode  runmode = NotifyOnExit,
  	Communication comm = NoCommunication);

  /**
   * Stop the process (by sending it a signal).
   *
   * @param signo	The signal to send. The default is SIGTERM.
   * @return @p true if the signal was delivered successfully.
  */
  virtual bool kill(int signo = SIGTERM);

  /**
     @return @p true if the process is (still) considered to be running
  */
  bool isRunning() const;

  /** Returns the process id of the process.
   *
   * If it is called after
   * the process has exited, it returns the process id of the last
   *  child process that was created by this instance of KProcess.
   *
   *  Calling it before any child process has been started by this
   *  KProcess instance causes pid() to return 0.
   **/
  pid_t pid() const;

  /**
   * Use pid().
   * @deprecated
   */
  pid_t getPid() const { return pid(); }

  /**
   * Suspend processing of data from stdout of the child process.
   */
  void suspend();

  /**
   * Resume processing of data from stdout of the child process.
   */
  void resume();

  /**
   * @return @p true if the process has already finished and has exited
   *  "voluntarily", ie: it has not been killed by a signal.
   *
   * Note that you should check @ref KProcess::exitStatus() to determine
   * whether the process completed its task successful or not.
   */
  bool normalExit() const;

  /**
   * Returns the exit status of the process.
   *
   * Please use
   * @ref KProcess::normalExit() to check whether the process has exited
   * cleanly (i.e., @ref KProcess::normalExit() returns @p true) before calling
   * this function because if the process did not exit normally,
   * it does not have a valid exit status.
  */
  int  exitStatus() const;


  /**
   *	 Transmit data to the child process's stdin.
   *
   * KProcess::writeStdin may return false in the following cases:
   *
   *     @li The process is not currently running.
   *
   *     @li Communication to stdin has not been requested in the @ref start() call.
   *
   *     @li Transmission of data to the child process by a previous call to
   * @ref writeStdin() is still in progress.
   *
   * Please note that the data is sent to the client asynchronously,
   * so when this function returns, the data might not have been
   * processed by the child process.
   *
   * If all the data has been sent to the client, the signal
   * @ref wroteStdin() will be emitted.
   *
   * Please note that you must not free "buffer" or call @ref writeStdin()
   * again until either a @ref wroteStdin() signal indicates that the
   * data has been sent or a @ref processHasExited() signal shows that
   * the child process is no longer alive...
   **/
  bool writeStdin(const char *buffer, int buflen);

  /**
   * This causes the stdin file descriptor of the child process to be
   * closed indicating an "EOF" to the child.
   *
   * @return @p false if no communication to the process's stdin
   *  had been specified in the call to @ref start().
  */
  bool closeStdin();

  /**
   * This causes the stdout file descriptor of the child process to be
   * closed.
   *
   * @return @p false if no communication to the process's stdout
   *  had been specified in the call to @ref start().
  */
  bool closeStdout();

  /**
   * This causes the stderr file descriptor of the child process to be
   * closed.
   *
   * @return @p false if no communication to the process's stderr
   *  had been specified in the call to @ref start().
  */
  bool closeStderr();

  /**
   * Lets you see what your arguments are for debugging.
   */

  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
   */
  void setRunPrivileged(bool keepPrivileges);

  /**
   * Returns whether the started process will drop any
   * setuid/segid privileges or whether it will keep them
   */
  bool runPrivileged() const;
  
  /**
   * Modifies the environment of the process to be started.
   * This function must be called before starting the process.
   */
  void setEnvironment(const QString &name, const QString &value);

  /**
   * Changes the current working directory (CWD) of the process 
   * to be started.
   * This function must be called before starting the process.
   */
  void setWorkingDirectory(const QString &dir);

  /**
   * Detaches KProcess from child process. All communication is closed.
   * No exit notification is emitted any more for the child process.
   * Deleting the KProcess 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.
   **/
  void processExited(KProcess *proc);


  /**
   * Emitted, when output from the child process has
   * been received on stdout.
   *
   *  To actually get
   * these signals, the respective communication link (stdout/stderr)
   * has to be turned on in @ref start().
   *
   * @param buffer The data received.
   * @param buflen The number of bytes that are available.
   *
   * You should copy the information contained in @p buffer to your private
   * data structures before returning from this slot.
   **/
  void receivedStdout(KProcess *proc, char *buffer, int buflen);

  /**
   * Emitted when output from the child process has
   * been received on stdout.
   *
   * To actually get these signals, the respective communications link 
   * (stdout/stderr) has to be turned on in @ref start() and the 
   * @p NoRead flag should have been passed.
   *
   * You will need to explicitly call resume() after your call to start()
   * to begin processing data from the child process's stdout.  This is
   * to ensure that this signal is not emitted when no one is connected
   * to it, otherwise this signal will not be emitted.
   * 
   * The data still has to be read from file descriptor @p fd.
   **/
  void receivedStdout(int fd, int &len);


  /**
   * Emitted, when output from the child process has
   * been received on stderr.
   * To actually get
   * these signals, the respective communication link (stdout/stderr)
   * has to be turned on in @ref start().
   *
   * @param buffer The data received.
   * @param buflen The number of bytes that are available.
   *
   * You should copy the information contained in @p buffer to your private
   * data structures before returning from this slot.
  */
  void receivedStderr(KProcess *proc, char *buffer, int buflen);

  /**
   * 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(KProcess *proc);


protected slots:

 /**
  * This slot gets activated when data from the child's stdout arrives.
  * It usually calls "childOutput"
  */
  void slotChildOutput(int fdno);

 /**
  * This slot gets activated when data from the child's stderr arrives.
  * It usually calls "childError"
  */
  void slotChildError(int fdno);
  /*
	Slot functions for capturing stdout and stderr of the child
  */

  /**
   * Called when another bulk of data can be sent to the child's
   * stdin. If there is no more data to be sent to stdin currently
   * available, this function must disable the QSocketNotifier "innot".
   */
  void slotSendData(int dummy);

protected:

  /**
   * Sets up the environment according to the data passed via 
   * setEnvironment(...)
   */
  void setupEnvironment();

  /**
   * The list of the process' command line arguments. The first entry
   * in this list is the executable itself.
   */
  QValueList<QCString> arguments;
  /**
   * How to run the process (Block, NotifyOnExit, DontCare). You should
   *  not modify this data member directly from derived classes.
   */
  RunMode run_mode;
  /**
   * true if the process is currently running. You should not
   * modify this data member directly from derived classes. For
   * reading the value of this data member, please use "isRunning()"
   * since "runs" will probably be made private in later versions
   * of KProcess.
   */
  bool runs;

  /**
   * The PID of the currently running process (see "getPid()").
   * You should not modify this data member in derived classes.
   * Please use "getPid()" instead of directly accessing this
   * member function since it will probably be made private in
   * later versions of KProcess.
   */
  pid_t pid_;

  /**
   * The process' exit status as returned by "waitpid". You should not
   * modify the value of this data member from derived classes. You should
   * rather use @ref exitStatus than accessing this data member directly
   * since it will probably be made private in further versions of
   * KProcess.
   */
  int status;


  /**
   * See setRunPrivileged()
   */
  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
  */

  /**
   * This function is called from "KProcess::start" right before a "fork" takes
   * place. According to
   * the "comm" parameter this function has to initialize the "in", "out" and
   * "err" data member of KProcess.
   *
   * This function should return 0 if setting the needed communication channels
   * was successful.
   *
   * The default implementation is to create UNIX STREAM sockets for the communication,
   * but you could overload this function and establish a TCP/IP communication for
   * network communication, for example.
   */
  virtual int setupCommunication(Communication comm);

  /**
   * Called right after a (successful) fork on the parent side. This function
   * will usually do some communications cleanup, like closing the reading end
   * of the "stdin" communication channel.
   *
   * Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and
   * "errnot" and connect their Qt slots to the respective KProcess member functions.
   *
   * For a more detailed explanation, it is best to have a look at the default
   * implementation of "setupCommunication" in kprocess.cpp.
   */
  virtual int commSetupDoneP();

  /**
   * Called right after a (successful) fork, but before an "exec" on the child
   * process' side. It usually just closes the unused communication ends of
   * "in", "out" and "err" (like the writing end of the "in" communication
   * channel.
   */
  virtual int commSetupDoneC();


  /**
   * Immediately called after a process has exited. This function normally
   * calls commClose to close all open communication channels to this
   * process and emits the "processExited" signal (if the process was
   * not running in the "DontCare" mode).
   */
  virtual void processHasExited(int state);

  /**
   * Should clean up the communication links to the child after it has
   * exited. Should be called from "processHasExited".
   */
  virtual void commClose();


  /**
   * the socket descriptors for stdin/stdout/stderr.
   */
  int out[2];
  int in[2];
  int err[2];

  /**
   * The socket notifiers for the above socket descriptors.
   */
  QSocketNotifier *innot;
  QSocketNotifier *outnot;
  QSocketNotifier *errnot;

  /**
   * Lists the communication links that are activated for the child
   * process.  Should not be modified from derived classes.
   */
  Communication communication;

  /**
   * Called by "slotChildOutput" this function copies data arriving from the
   * child process's stdout to the respective buffer and emits the signal
   * "@ref receivedStderr".
   */
  int childOutput(int fdno);

  /**
   * Called by "slotChildOutput" this function copies data arriving from the
   * child process's stdout to the respective buffer and emits the signal
   * "@ref receivedStderr"
   */
  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

  /**
   * @ref KProcessController is a friend of KProcess because it has to have
   * access to various data members.
   */
  friend class KProcessController;


private:
  // Disallow assignment and copy-construction
  KProcess( const KProcess& );
  KProcess& operator= ( const KProcess& );

protected:
  virtual void virtual_hook( int id, void* data );
private:
  KProcessPrivate *d;
};

class KShellProcessPrivate;

/**
* This class is similar to @ref KProcess. The only difference is that
* KShellProcess runs the specified executable through a UN*X shell so
* that standard shell mechanisms like wild card matching, use of pipes
* and environment variable expansion will work.
*
* For example, you could run commands like the following through
* KShellProcess:
*
* <pre>
*   ls ~/HOME/ *.lyx | sort | uniq |wc -l
* </pre>
*
* KShellProcess tries really hard to find a valid executable shell. Here
* is the algorithm used for finding an executable shell:
*
*    @li Try the executable pointed to by the "SHELL" environment
*    variable with white spaces stripped off
*
*    @li If your process runs with uid != euid or gid != egid, a shell
*    not listed in /etc/shells will not used.
*
*    @li If no valid shell could be found, "/bin/sh" is used as a last resort.
*
*   @short A class derived from @ref KProcess to start child
*   	processes through a shell.
*   @author Christian Czezakte <e9025461@student.tuwien.ac.at>
*   @version $Id: kprocess.h,v 1.54 2002/03/05 23:13:26 rich Exp $
*/
class KShellProcess: public KProcess
{
  Q_OBJECT

public:

  /**
   * Constructor
   *
   * By specifying the name of a shell (like "/bin/bash") you can override
   * the mechanism for finding a valid shell as described in the detailed
   * description of this class.
   */
  KShellProcess(const char *shellname=0);

  /**
   * Destructor.
   */
  ~KShellProcess();

  /**
   * Starts up the process. -- For a detailed description
   * have a look at the "start" member function and the detailed
   * description of @ref KProcess .
   */
  virtual bool start(RunMode  runmode = NotifyOnExit,
		  Communication comm = NoCommunication);

  /**
   * This function can be used to quote an argument string such that
   * the shell processes it properly. This is e. g. necessary for
   * user-provided file names which may contain spaces or quotes.
   * It also prevents expansion of wild cards and environment variables.
   */
  static QString quote(const QString &arg);

private:

  /**
   * Searches for a valid shell. See the general description of this
   * class for information on how the search is actually performed.
   */
  QCString searchShell();

  /**
   * Used by @ref searchShell in order to find out whether the shell found
   * is actually executable at all.
   */
  bool isExecutable(const QCString &filename);

  QCString shell;

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

protected:
  virtual void virtual_hook( int id, void* data );
private:
  KShellProcessPrivate *d;
};



#endif

