/** @file

    $Id$

    $Date$
    $Author$

    @copy © Marc Wäckerlin
    @license LGPL, see file <a href="license.html">COPYING</a>

    $Log$
    Revision 1.14  2005/11/29 12:39:42  marc
    make it compilable with gcc 4.0.2 and newer doxygen

    Revision 1.13  2005/04/20 18:32:14  marc
    *** empty log message ***

    Revision 1.12  2005/04/20 18:12:55  marc
    added kill() for PartialExec

    Revision 1.11  2005/04/19 18:48:00  marc
    new feature PartialExec

    Revision 1.10  2005/03/14 16:26:34  marc
    bugs have been fixed a long time ago, now no more in buglist

    Revision 1.9  2004/12/20 07:40:35  marc
    documentation improved, new grouping

    Revision 1.8  2004/12/18 21:00:09  marc
    everything is ok, when pipes are non blocking on parent's side and blocking on client's side, and select is not used (not necessary for non blocking IO)

    Revision 1.7  2004/12/17 17:38:57  marc
    it works perfectly with blocking pipes and buffer size of 1

    Revision 1.6  2004/12/17 16:28:51  marc
    stable implementation with select for both executes

    Revision 1.5  2004/12/14 20:30:09  marc
    added possibility to pass string to stdin of child process

    Revision 1.4  2004/08/28 16:21:25  marc
    mrw-c++-0.92 (mrw)
    - new file: version.cxx
    - new file header for all sources
    - work around warning in mrw::auto<T>
    - possibility to compile without log4cxx
    - work around bugs in demangle.h and libiberty.h
    - corrections in documentation
    - added simple tracing mechanism
    - more warnings
    - small corrections in Auto<>::Free and a new test for it
    - possibility to compile without stack trace

*/
#include <mrw/exec.hxx>
#include <mrw/unistd.hxx>
#include <mrw/exception.hxx>
#include <sys/wait.h> // waitpid
#include <unistd.h> // fork, exec
#include <string.h> // memcpy
#include <assert.h> // assert
#include <sys/types.h> // kill
#include <signal.h> // kill
#include <cstdlib> // exit

//=========================================================== ExecutionFailedExc

//------------------------------------------------------------------------------
mrw::ExecutionFailedExc::ExecutionFailedExc(const std::string& w,
                                            const std::string& c)
  :
  _what(std::string("mrw::Exec: command execution failed\n")+
        std::string("           failed command was: \""+c+"\"\n")+
        std::string("           error was: \"")+w+'"') {
  /**
      @c what looks like:
      @verbatim
      mrw::Exec: command execution failed
                 failed command was: "/bin/OOOOPS -v -q --crash"
                 error was: "execution failed"
      @endverbatim
  */
}

//========================================================================== Cmd

//------------------------------------------------------------------------------
mrw::Cmd::Cmd(const std::string& c) {
  _cmd.push_back(c);
}

//------------------------------------------------------------------------------
mrw::Cmd& mrw::Cmd::operator,(const std::string& arg)
  {
  _cmd.push_back(arg);
  return *this;
}

//------------------------------------------------------------------------------
mrw::Cmd& mrw::Cmd::operator<<(const std::string& arg)
  {
  _cmd.push_back(arg);
  return *this;
}

//------------------------------------------------------------------------------
mrw::Cmd::operator std::string() const {
  ArgList::const_iterator it(_cmd.begin());
  std::string c(*it);
  while (++it!=_cmd.end()) c+=' '+*it;
  return c;
}

//------------------------------------------------------------------------------
mrw::Cmd::operator mrw::Exec() const {
  return mrw::Exec(*this);
}

//------------------------------------------------------------------------------
mrw::Cmd::operator mrw::PartialExec() const {
  return mrw::PartialExec(*this);
}

//------------------------------------------------------------------------------
mrw::Exec mrw::Cmd::execute(bool exc) const {
  return mrw::Exec(*this).execute(exc);
}

//------------------------------------------------------------------------------
mrw::Exec mrw::Cmd::execute(const std::string& input, bool exc) const
  {
  return mrw::Exec(*this).execute(input, exc);
}

//------------------------------------------------------------------------------
mrw::PartialExec mrw::Cmd::start(bool useInput) const {
  return mrw::PartialExec(*this).start(useInput);
}

//------------------------------------------------------------------------------
const char* mrw::Cmd::path() const {
  return _cmd.front().c_str();
}

//------------------------------------------------------------------------------
char** mrw::Cmd::args() const {
  if (_cmd.size()==0) return 0;
  char** array = new char*[_cmd.size()+1];
  int i(0);
  for (ArgList::const_iterator it(_cmd.begin()); it!=_cmd.end(); ++it)
    memcpy(array[i++]=new char[it->size()+1], it->c_str(), it->size()+1);
  array[i] = 0;
  return array;
}

//========================================================================= Exec

//------------------------------------------------------------------------------
mrw::Exec::Exec(const mrw::Cmd& c) :
  _cmd(new mrw::Cmd(c)), _success(false) {
}

//------------------------------------------------------------------------------
mrw::Exec::Exec(const mrw::Exec& e) :
  _cmd(new mrw::Cmd(*e._cmd)),
  _res(e._res), _err(e._err), _success(e._success) {
}

//------------------------------------------------------------------------------
mrw::Exec::~Exec() noexcept {
  delete _cmd;
}

//------------------------------------------------------------------------------
mrw::Exec& mrw::Exec::operator=(const mrw::Exec& e) {
  if (this==&e) return *this;
  *_cmd=*e._cmd; _res=e._res; _err=e._err; _success=e._success;
  return *this;
}

//------------------------------------------------------------------------------
mrw::Exec& mrw::Exec::execute(bool exc) {
  /** This method calls @c fork, sets up a pipe connection to pass @c
      stdout and @c stderr from the child process to the parent
      process using mrw::Pipe and calls @c execvp to execute the
      program. */
  _success = false;
  _res = _err = "";
  mrw::Pipe stdOut(mrw::Pipe::block_output), stdErr(mrw::Pipe::block_output);
  if (!stdOut || !stdErr)
    throw mrw::ExecutionFailedExc("cannot create pipe", *_cmd);
  pid_t pid(fork());
  if (pid<0)
    throw ExecutionFailedExc("cannot fork", *_cmd);
  if (pid) { // parent
    stdOut.close_out();
    stdErr.close_out();
    if (!stdOut || !stdErr)
      throw ExecutionFailedExc("cannot close pipe", *_cmd);
    ssize_t num1(1), num2(1);
    char buf[4096];
    int res(0), s(0);
    /* It sometimes did not get the whole input since I changed to non
       blocking pipes. Now I have found the solution to the problems:
       Non blocking IO does not work in conjunction with select! 
       Also the pipe must not be nonblocking on both ends, but only on
       one. */
    while (num1||num2||!res) try { // not end of files or child terminated
      if (!res && (res=waitpid(pid, &s, WNOHANG)))
        if (res!=pid || (WIFEXITED(s)!=0 && WEXITSTATUS(s)!=0))
          throw ExecutionFailedExc("execution failed", *_cmd);
      if (num1<=0&&num2<=0) usleep(10000); // nothing to read last time
      // check and handle stdout
      if (num1 && (num1=read(stdOut.istream(), buf, sizeof(buf)))>0) {
        _res += std::string(buf, num1);
      } else if (num1==-1) {
        if (errno!=EINTR&&errno!=EAGAIN) {
          throw ExecutionFailedExc("readin stdout", *_cmd);
        } else {
          num1 = 1;
        }
      }
      // check and handle stderr
      if (num2 && (num2=read(stdErr.istream(), buf, sizeof(buf)))>0) {
        _err += std::string(buf, num2);
      } else if (num2==-1) {
        if (errno!=EINTR&&errno!=EAGAIN) {
          throw ExecutionFailedExc("readin stderr", *_cmd);
        } else {
          num2 = 1;
        }
      }
    } catch (...) {
      _success = false;
      if (exc) throw;
      return *this;
    }
  } else { // child
    stdOut.close_in();
    stdErr.close_in();
    stdOut.connect_cout();
    stdErr.connect_cerr();
    execvp(_cmd->path(), _cmd->args());
    exit(1); // execute failed
  }
  _success = true;
  return *this;
}

//------------------------------------------------------------------------------
mrw::Exec& mrw::Exec::execute(const std::string& input, bool exc)
  {
#ifdef SSIZE_MAX
  /// @c input length must be smaller than @c SSIZE_MAX.
  /// I'll only add support for longer strings upon request.
  assert(input.size()<=SSIZE_MAX &&
         "sdin input exeeds C library limit in mrw::Exec "
         "please contact the author of the library");
#endif
  /** This method calls @c fork, sets up a pipe connection to pass @c
      stdin, @c stdout and @c stderr between the child process and the
      parent process using mrw::Pipe and calls @c execvp to execute
      the program. */
  _success = false;
  _res = _err = "";
  mrw::Pipe stdIn(mrw::Pipe::block_input),
    stdOut(mrw::Pipe::block_output), stdErr(mrw::Pipe::block_output);
  if (!stdIn || !stdOut || !stdErr)
    throw mrw::ExecutionFailedExc("cannot create pipe", *_cmd);
  pid_t pid(fork());
  if (pid<0) throw ExecutionFailedExc("cannot fork", *_cmd);
  if (pid) { // parent
    stdIn.close_in();
    stdOut.close_out();
    stdErr.close_out();
    if (!stdIn || !stdOut || !stdErr)
      throw ExecutionFailedExc("cannot close pipes", *_cmd);
    ssize_t num0(1), num1(1), num2(1);
    std::string in(input);
    char buf[4096];
    int res(0), s(0);
    /* It sometimes did not get the whole input since I changed to non
       blocking pipes. Now I have found the solution to the problems:
       Non blocking IO does not work in conjunction with select! Also
       the pipe must not be nonblocking on both ends, but only on
       one. */
    while (num0||num1||num2||!res) try { // not end of files or child terminated
      if (!res && (res=waitpid(pid, &s, WNOHANG)))
        if (res!=pid || (WIFEXITED(s)!=0 && WEXITSTATUS(s)!=0))
          throw ExecutionFailedExc("execution failed", *_cmd);
      if (num0<=0&&num1<=0&&num2<=0) usleep(10000); // no activity last time
      // check and handle stdin
      if (num0 && (num0=write(stdIn.ostream(), in.c_str(), in.size()))>0) {
        if ((unsigned int)num0<in.size())
          in = in.substr(num0);
        else if ((unsigned int)num0==in.size())
          num0=0, stdIn.close_out();
      } else if (num0==-1) {
        if (errno!=EINTR&&errno!=EAGAIN)
          throw ExecutionFailedExc("writing stdin", *_cmd);
        else
          num0 = 1;
      }
      // check and handle stdout
      if (num1 && (num1=read(stdOut.istream(), buf, sizeof(buf)))>0) {
        _res += std::string(buf, num1);
      } else if (num1==-1) {
        if (errno!=EINTR&&errno!=EAGAIN) {
          throw ExecutionFailedExc("readin stdout", *_cmd);
        } else {
          num1 = 1;
        }
      }
      // check and handle stderr
      if (num2 && (num2=read(stdErr.istream(), buf, sizeof(buf)))>0) {
        _err += std::string(buf, num2);
      } else if (num2==-1) {
        if (errno!=EINTR&&errno!=EAGAIN) {
          throw ExecutionFailedExc("readin stderr", *_cmd);
        } else {
          num2 = 1;
        }
      }
    } catch (...) {
      _success = false;
      if (exc) throw;
      return *this;
    }
  } else { // child
    stdIn.close_out();
    stdOut.close_in();
    stdErr.close_in();
    stdIn.connect_cin();
    stdOut.connect_cout();
    stdErr.connect_cerr();
    execvp(_cmd->path(), _cmd->args());
    exit(1); // execute failed
  }
  _success = true;
  return *this;
}

//------------------------------------------------------------------------------
mrw::Exec& mrw::Exec::operator>>(std::string& res) {
  execute();
  res += _res;
  return *this;
}

//------------------------------------------------------------------------------
mrw::Exec::operator std::string&() {
  if (!_success) execute();
  return _res;
}

//------------------------------------------------------------------------------
mrw::Exec::operator bool() {
  return _success;
}

//------------------------------------------------------------------------------
std::string& mrw::Exec::result() {
  if (!_success) execute();
  return _res;
}

//------------------------------------------------------------------------------
std::string& mrw::Exec::error() {
  if (!_success) execute();
  return _err;
}

//------------------------------------------------------------------------------
bool mrw::Exec::success() {
  return _success;
}

//================================================================== PartialExec

//------------------------------------------------------------------------------
mrw::PartialExec::PartialExec(const mrw::Cmd& c) :
    Exec(c), _finished(true), _finish(false) {
}

//------------------------------------------------------------------------------
mrw::PartialExec::PartialExec(mrw::PartialExec& e)
    :
    Exec(e), _finished(e._finished), _finish(e._finish),
    _stdIn(e._stdIn), _stdOut(e._stdOut), _stdErr(e._stdErr), _input(e._input),
    _num0(e._num0), _num1(e._num1), _num2(e._num2),
    _lastPid(e._lastPid), _pid(e._pid) {
      e._finished = true;
}

//------------------------------------------------------------------------------
mrw::PartialExec::PartialExec(const mrw::PartialExec& e)
    :
    Exec(e), _finished(e._finished), _finish(e._finish),
    _input(e._input),
    _num0(e._num0), _num1(e._num1), _num2(e._num2),
    _lastPid(e._lastPid), _pid(e._pid) {
      /** @warning @c const is casted away */
      mrw::PartialExec& nonConstE(const_cast<mrw::PartialExec&>(e));
      _stdIn = nonConstE._stdIn;
      _stdOut = nonConstE._stdOut;
      _stdErr = nonConstE._stdErr;
      nonConstE._finished = true;
      nonConstE._finish = false;
}

//------------------------------------------------------------------------------
mrw::PartialExec& mrw::PartialExec::operator=(mrw::PartialExec& e)
    {
  if (this==&e) return *this;
  *_cmd=*e._cmd; _res=e._res; _err=e._err; _success=e._success;
  _finished = e._finished;
  _finish = e._finish;
  _stdIn = e._stdIn; _stdOut = e._stdOut; _stdErr = e._stdErr;
  _input = e._input; _num0 = e._num0; _num1 = e._num1; _num2 = e._num2;
  _lastPid = e._lastPid;
  _pid = e._pid;
  e._finished = true;
  e._finish = false;
  return *this;
}

//------------------------------------------------------------------------------
mrw::PartialExec& mrw::PartialExec::finish() noexcept {
  _finish = true;
  return *this;
}

//------------------------------------------------------------------------------
bool mrw::PartialExec::finished() noexcept {
  return _finished;
}

//------------------------------------------------------------------------------
mrw::PartialExec& mrw::PartialExec::start(bool useInput)
  {
  if (!_finished) throw mrw::runtime_error("running process not yet finished");
  /** This method calls @c fork, sets up a pipe connection to pass @c
      stdin, @c stdout and @c stderr between the child  process and the
      parent process using mrw::Pipe and calls @c execvp to execute
      the program. */
  _success = false;
  _finish = !useInput;
  _input = "";
  _res = _err = "";
  _stdIn = std::shared_ptr<mrw::Pipe>(new mrw::Pipe(mrw::Pipe::block_input));
  _stdOut = std::shared_ptr<mrw::Pipe>(new mrw::Pipe(mrw::Pipe::block_output));
  _stdErr = std::shared_ptr<mrw::Pipe>(new mrw::Pipe(mrw::Pipe::block_output));
  if (!*_stdIn || !*_stdOut || !*_stdErr)
    throw mrw::ExecutionFailedExc("cannot create pipe", *_cmd);
  _lastPid = 0;
  _pid = fork();
  if (_pid<0) throw ExecutionFailedExc("cannot fork", *_cmd);
  if (_pid) { // parent
    _stdIn->close_in();
    _stdOut->close_out();
    _stdErr->close_out();
    if (!*_stdIn || !*_stdOut || !*_stdErr)
      throw ExecutionFailedExc("cannot close pipes", *_cmd);
    _num0 = _num1 = _num2 = 1;
    _finished = false;
  } else { // child
    _stdIn->close_out();
    _stdOut->close_in();
    _stdErr->close_in();
    _stdIn->connect_cin();
    _stdOut->connect_cout();
    _stdErr->connect_cerr();
    execvp(_cmd->path(), _cmd->args());
    exit(1); // execute failed
  }
  _success = true;
  return *this;
}

//------------------------------------------------------------------------------
std::pair<std::string, std::string>
  mrw::PartialExec::read(const std::string& input, bool exc)
    {
  std::pair<std::string, std::string> output;
#ifdef SSIZE_MAX
  /** @note @c input length must be smaller than @c SSIZE_MAX.
            I'll only add support for longer strings upon request. */
  assert(input.size()<=SSIZE_MAX &&
         "sdin input exeeds C library limit in mrw::Exec "
         "please contact the author of the library");
#endif
  /** @warning After calling finish(), it is forbidden to pass
               any @c input string, it must then always be empty,
               because the pipe is already closed! */
  assert(!(_finish && input.size()) &&
         "after calling PartialExec::finish(), it is forbidden "
         "to pass new input text, because the pipe is already "
         "closed! this is a programming but that must be solved!");
  _input += input;
  /* It sometimes did not get the whole input since I changed to non
     blocking pipes. Now I have found the solution to the problems:
     Non blocking IO does not work in conjunction with select! Also
     the pipe must not be nonblocking on both ends, but only on
     one. */
  if (!_finished) try { // not finished
    char buf[4096];
    int s(0);
    if (!_lastPid && (_lastPid=waitpid(_pid, &s, WNOHANG))) {
      if (_lastPid!=_pid || (WIFEXITED(s)!=0 && WEXITSTATUS(s)!=0))
        throw ExecutionFailedExc("execution failed", *_cmd);
    }
    // check and handle stdin
    if (_input.size() && _num0!=-1 &&
        (_num0=write(_stdIn->ostream(), _input.c_str(), _input.size()))>0) {
      if ((unsigned int)_num0<_input.size())
        _input = _input.substr(_num0);
      else if ((unsigned int)_num0==_input.size())
        _input.clear();
    } else if (_num0==-1) {
      if (errno!=EINTR&&errno!=EAGAIN)
        throw ExecutionFailedExc("writing stdin", *_cmd);
      else
        _num0 = 1;
    }
    // check and handle stdout
    if (_num1 && (_num1=::read(_stdOut->istream(), buf, sizeof(buf)))>0) {
      _res += output.first=std::string(buf, _num1);
    } else if (_num1==-1) {
      if (errno!=EINTR&&errno!=EAGAIN)
        throw ExecutionFailedExc("readin stdout", *_cmd);
      else
        _num1 = 1;
    }
    // check and handle stderr
    if (_num2 && (_num2=::read(_stdErr->istream(), buf, sizeof(buf)))>0) {
      _err += output.second=std::string(buf, _num2);
    } else if (_num2==-1) {
      if (errno!=EINTR&&errno!=EAGAIN)
        throw ExecutionFailedExc("readin stderr", *_cmd);
      else
        _num2 = 1;
    }
    if (_finish && !_input.size()) {
      _stdIn->close_out();
      _num0 = 0;
    }
    _finished = _finish && !_input.size() && !_num1 && !_num2 && _lastPid;
  } catch (mrw::exception& x) {
    _finished = true;
    _success = false;
    if (exc) throw;
    return output;
  }
  if (_finished) _success = true;
  return output;
}

//------------------------------------------------------------------------------
mrw::PartialExec& mrw::PartialExec::terminate() noexcept {
  ::kill(_pid, SIGTERM);
  return *this;
}

//------------------------------------------------------------------------------
mrw::PartialExec& mrw::PartialExec::kill() noexcept {
  ::kill(_pid, SIGKILL);
  return *this;
}