kprocess.h

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

/* This file is part of the KDE libraries
    Copyright (C) 1997 Christian Czezakte ([e-mail])

    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
//  [e-mail]
//

#ifndef __kprocess_h__
#define __kprocess_h__

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


/**
  @short KProcess -- A class for invoking Child processes from within KDE applications
  @author Christian Czezakte [e-mail]

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

  Basically, this class distinguishes three different ways of running
  child processes: 

  +) "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.
  
  +) "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 "processExited".
  
  Since this signal is _not_ emitted from within a UN*X
  signal handler, arbitrary function calls can be made.
  
  +) "KProcess::Block" -- The child process starts and the parent
  process is suspended 
  until the child process exits. (_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;

  proc &lt;&lt; "my_executable";
  proc &lt;&lt; "These" &lt;&lt; "are" &lt;&lt; "the" &lt;&lt; "command" &lt;&lt; "line" &lt;&lt; "args";
  QApplication::connect(&proc, SIGNAL(processExited(KProcess *)), 
                        pointer_to_my_object, SLOT(my_objects_slot));
  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.
  
  2) 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):
  
  
  bool writeStdin(char *buffer, int buflen);
  -- Transmit data to the child process's stdin.
  
  bool closeStdin();
  -- Closes the child process's stdin (which causes it to see a "feof(stdin)")
  Returns FALSE if you try to close stdin for a process that has been started
  without a communication channel to stdin.
  
  QT signals:
  
  void receivedStdout(KProcess *proc, char *buffer, int buflen);
  void receivedStderr(KProcess *proc, char *buffer, int buflen);
  -- Indicates that new data has arrived from either the
  child process's stdout or stderr.
  
  void wroteStdin(KProcess *proc);
  -- Indicates that all data that has been sent to the child process
  by a prior call to "writeStdin" has actually been transmitted to the
  client 
*/
class KProcess : public QObject
{
  Q_OBJECT

public:

  /** enums for communication channels to open. 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 "Stdin | Stdout" 
  */
  enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
					   AllOutput = 6, All = 7 };

  /** various run--modes for a child process. For more information about the
      semantics of the run modes have a look at the general description of
      the @ref KProcess class.
  */
  enum RunMode { DontCare, NotifyOnExit, 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 "DontCare". --
	  Processes started as "DontCare" keep running anyway...
  */
  virtual ~KProcess();
 
  /**
         The use of this function is now depreciated. -- Please use the
	 "operator&lt;&lt;" 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.) 

  */
  bool setExecutable(const char *proc);


  /** Sets the executable and the command line argument list for this process 
      
      For example, doning a "ls -l /usr/local/bin" can be achieved by:
      <pre>
      KProcess p;
      ...
      p &lt;&lt; "ls" &lt;&lt; "-l" &lt;&lt; "/usr/local/bin"
      </pre>

   */
  KProcess &operator<<(const char *arg);

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

  /** Starts up 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.

      This function returns TRUE if the process was started successfully.
      The following problems could cause KProcess:start" to return FALSE:

	  +) the process is already running

	  +) the command line argument list is empty 

	  +) the starting of the process failed (could not fork)

      The second argument 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.
  */
  virtual bool start(RunMode  runmode = NotifyOnExit, Communication comm = NoCommunication);

  /**
     Stops the process (by sending a SIGTERM to it). -- You may send other
     signals too of course... ;-) ) 

     Returns TRUE if the signal could be delivered successfully
  */
  virtual bool kill(int signo = SIGTERM);

  /**
     Returns TRUE if the process is (still) considered to be running
  */
  bool isRunning();

  /** 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 getPid to return 0
  */    
  pid_t getPid();


  /** Returns TRUE if the process has already finished and has exited
      "voluntarily", ie: it has not been killed by a signal.
  */
  bool normalExit();

  /** Returns the exit status of the process. Please use "KProcess::normalExit" to 
      check whether the process has exited cleanly (KProcess::normalExit returning
      TRUE) before calling this function because if the process did not exit
      normally, it does not have a valid exit status.
  */
  int  exitStatus(); 

   
  /**
	 Transmit data to the child process's stdin. KProcess::writeStdin
         may return FALSE in the following cases:

         +) The process is not currently running

	 +) Communication to stdin has not been requested in the "start" call

         +) transmission of data to the child process by a previous call to "writeStdin"
            is still in progress. 

	 Please note that the data is sent to the client asynchronousely,
	 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
	 "wroteStdin" will be emitted. 

	 Please note that you must not free "buffer" or call "writeStdin"
	 again until either a "wroteStdin" signal indicates that the data has been sent or a
	 "processHasExited" signal shows that the child process is no
	 longer alive... 
  */
  bool writeStdin(char *buffer, int buflen);

  /**
     This causes the stdin file descriptor of the child process to be
	 closed indicating an "EOF" to the child. This function will
	 return FALSE if:

	 +) No communication to the process's stdin has been specified in the "start" call.
  */
  bool closeStdin();

  signals: 

  /**
     This signal gets emitted after the process has terminated when
	 the process was run in the "NotfiyOnExit"  (=default option to
	 "start") or the "Block" mode. 
  */     
  void processExited(KProcess *proc);