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 <optional>

#include <zypp-core/Globals.h>
#include <zypp-core/base/ExternalDataSource.h>
#include <zypp-core/Pathname.h>

namespace zyppng {
  class AbstractSpawnEngine;
}

namespace zypp {

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

    public:

      using Arguments = std::vector<std::string>;

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

      using Environment = std::map<std::string, std::string>;

      ExternalProgram (const 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() override;

#ifdef __cpp_lib_optional // YAST/PK explicitly use c++11 until 15-SP3

      bool waitForExit ( std::optional<uint64_t> timeout = {} );
#endif

      int close() override;

      bool kill();

      bool kill( int sig );

      bool running();

      Pathname chroot() const;

      pid_t getpid();

      const std::string & command() const;

      const std::string & execError() const;

      static void renumber_fd (int origfd, int newfd);

    public:

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

    private:
      std::unique_ptr<zyppng::AbstractSpawnEngine> _backend;

    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, bool die_with_parent = false, bool usePty = 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 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