ExternalProgram.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_EXTERNALPROGRAM_H
#define ZYPP_EXTERNALPROGRAM_H

#include <unistd.h>

#include <map>
#include <string>
#include <vector>

#include "zypp/APIConfig.h"
#include "zypp/base/ExternalDataSource.h"
#include "zypp/Pathname.h"

namespace zypp {

    class ExternalProgram : public zypp::externalprogram::ExternalDataSource
    {

    public:

      typedef std::vector<std::string> Arguments;

      enum Stderr_Disposition {
        Normal_Stderr,
        Discard_Stderr,
        Stderr_To_Stdout,
        Stderr_To_FileDesc
      };


      typedef std::map<std::string,std::string> Environment;

      ExternalProgram (std::string commandline,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");

      ExternalProgram();

      ExternalProgram (const Arguments &argv,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");

      ExternalProgram (const Arguments &argv, const Environment & environment,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");

      ExternalProgram (const char *const *argv,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");

      ExternalProgram (const char *const *argv, const Environment & environment,
                     Stderr_Disposition stderr_disp = Normal_Stderr,
                     bool use_pty = false, int stderr_fd = -1, bool default_locale = false,
                     const Pathname& root = "");

      ExternalProgram (const char *binpath, const char *const *argv_1,
                     bool use_pty = false);


      ExternalProgram (const char *binpath, const char *const *argv_1, const Environment & environment,
                     bool use_pty = false);


      ~ExternalProgram();

      int close();

      bool kill();

      bool running();

      pid_t getpid() { return pid; }

      const std::string & command() const
      { return _command; }

      const std::string & execError() const
      { return _execError; }

      static void renumber_fd (int origfd, int newfd);

    public:

      std::ostream & operator>>( std::ostream & out_r );

    protected:
      int checkStatus( int );

    private:

      bool use_pty;

      pid_t pid;
      int _exitStatus;
      std::string _command;
      std::string _execError;

    protected:

      void start_program (const char *const *argv, const Environment & environment,
                        Stderr_Disposition stderr_disp = Normal_Stderr,
                        int stderr_fd = -1, bool default_locale = false,
                        const char* root = NULL, bool switch_pgid = false);

    };


  namespace externalprogram
  {
    struct EarlyPipe
    {
      enum { R=0, W=1 };
      EarlyPipe();
      ~EarlyPipe();
      void closeW()             { if ( _fds[W] != -1 ) { ::close( _fds[W] ); _fds[W] = -1; } }
      FILE * fStdErr()          { return _stderr; }
      protected:
        FILE * _stderr;
        int _fds[2];
    };
  } // namespace externalprogram

  class ExternalProgramWithStderr : private externalprogram::EarlyPipe, public ExternalProgram
  {
    public:
      ExternalProgramWithStderr( const Arguments & argv_r, bool defaultLocale_r = false, const Pathname & root_r = "" )
      : ExternalProgram( argv_r, Stderr_To_FileDesc, /*use_pty*/false, _fds[W], defaultLocale_r, root_r )
      { _initStdErr(); }
      ExternalProgramWithStderr( const Arguments & argv_r, const Pathname & root_r )
      : ExternalProgramWithStderr( argv_r, false, root_r )
      {}

      ExternalProgramWithStderr( const Arguments & argv_r, const Environment & environment_r, bool defaultLocale_r = false, const Pathname & root_r = "" )
      : ExternalProgram( argv_r, environment_r, Stderr_To_FileDesc, /*use_pty*/false, _fds[W], defaultLocale_r, root_r )
      { _initStdErr(); }
      ExternalProgramWithStderr( const Arguments & argv_r, const Environment & environment_r, const Pathname & root_r )
      : ExternalProgramWithStderr( argv_r, environment_r, false, root_r )
      {}
  public:
      using externalprogram::EarlyPipe::fStdErr;

      bool stderrGetUpTo( std::string & retval_r, const char delim_r, bool returnDelim_r = false );

      bool stderrGetline( std::string & retval_r, bool returnDelim_r = false  )
      { return stderrGetUpTo( retval_r, '\n', returnDelim_r ); }

    private:
      void _initStdErr()
      { closeW(); }

    private:
      std::string _buffer;
  };

  class ZYPP_LOCAL ExternalProgramWithSeperatePgid : public ExternalProgram
  {
    public:
      ExternalProgramWithSeperatePgid (const char *const *argv,
                   Stderr_Disposition stderr_disp = Normal_Stderr,
                   int stderr_fd = -1, bool default_locale = false,
                   const Pathname& root = "") : ExternalProgram()
      {
        start_program( argv, Environment(), stderr_disp, stderr_fd, default_locale, root.c_str(), true );
      }

  };

} // namespace zypp

#endif // ZYPP_EXTERNALPROGRAM_H