Process.cpp

Go to the documentation of this file.

#include <signal.h>
#include <stdexcept>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <sstream>
#include <iostream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <Poco/Thread.h>
#include <Poco/PipeStream.h>

#include "Process.hpp"

void signalHandler(int signum)
{
  pid_t pid = 0;
  int status = 0;
  /* Keep asking for a status until we get a definitive result.  */
  do
  {
    pid = waitpid (WAIT_ANY, &status, WNOHANG | WUNTRACED);
  }
  while (pid <= 0 && errno == EINTR);
}

namespace HCE
{
//-----------------------------------------------------------------------------
ProcessHandle Process::launch(const std::string& cmd, const Poco::Process::Args& args, const std::string& initialDirectory,
    std::istream& in, std::ostream& os, std::ostream& es, const Poco::Process::Env& env, CallbackFunction fn)
{
  std::stringstream outMsg, errMsg;
  std::string inputStream = toString(in);

  pid_t nPid;
  int pipeOut[2];    /* pipe to get the exec'ed program out */
  int pipeErr[2];    /* pipe to get the exec'ed program err */

  if (pipe(pipeOut) != 0)
    throw std::runtime_error(strerror(errno));

  if (pipe(pipeErr) != 0)
    throw std::runtime_error(strerror(errno));

  struct sigaction sa;
  __sigset_t mask;
  sa.sa_mask = mask;
  sa.sa_handler = signalHandler;
  sa.sa_flags = SA_NOCLDWAIT;
  sigaction (SIGCHLD, &sa, NULL);

  nPid = fork();
  if (nPid < 0)
  {
    throw std::runtime_error(strerror(errno));
  }
  else if (nPid == 0)
  {
    //Change File Mask
    umask(0);

    //Create a new Signature Id for our child
    pid_t sid = setsid();
    if (sid < 0)
      exit(EXIT_FAILURE);

    /* dup pipe write to stdout/stderr */
    dup2(pipeOut[1], STDOUT_FILENO);
    dup2(pipeErr[1], STDERR_FILENO);

    /* close unnecessary pipe descriptors for a clean environment */
    close(pipeOut[0]);
    close(pipeErr[0]);

    Poco::Pipe inPipe;
    Poco::ProcessHandle ph = Poco::Process::launch(cmd, args, initialDirectory, &inPipe, 0, 0, env);

    Poco::PipeOutputStream istr(inPipe);
    istr << inputStream;
    istr.close();
    inPipe.close();

    HCE::ProcessHandle handle(ph.id());
    handle.wait();

    close(pipeOut[1]);
    close(pipeErr[1]);

    Poco::Thread::sleep(500);
    exit(SUCCESS);
  }
  else
  {
    close(pipeOut[1]);
    close(pipeErr[1]);

    if (fn)
      fn(nPid);
    /* read output of stdout/stderr */
    readFromPipe(pipeOut[0], outMsg);
    readFromPipe(pipeErr[0], errMsg);

    HCE::ProcessHandle handle(nPid);
    handle.wait();

    close(pipeOut[0]);
    close(pipeErr[0]);
  }
  os << outMsg.str();
  es << errMsg.str();

  return ProcessHandle(nPid);
}
//-----------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
void Process::writeToPipe(int fd, const std::string& inputData)
{
  FILE* stream = nullptr;

  if((stream = fdopen( fd, "w" ))==nullptr)
    exit(ERROR_FDOPEN_WRITE);

  if (!inputData.empty())
    fwrite(inputData.c_str(), sizeof(char), inputData.length(), stream);

  fflush(stream);
  fclose(stream);
}
//-----------------------------------------------------------------------------
void Process::readFromPipe(int fd, std::stringstream& os)
{
  FILE* stream = nullptr;

  if((stream = fdopen( fd, "r" ))==nullptr)
    exit(ERROR_FDOPEN_READ);

  int ch = 0;
  while((ch = getc(stream)) != std::char_traits<char>::eof())
    os << (char)ch;

  os.flush();
  fclose(stream);
}
//-----------------------------------------------------------------------------
std::string Process::toString(std::istream& in)
{
  std::string str;
  in.seekg(0, std::ios::end);
  str.resize(in.tellg());
  in.seekg(0, std::ios::beg);
  in.read(const_cast<char*>(str.c_str()), str.size());
  return str;
}
//-----------------------------------------------------------------------------
void Process::requestKill(ProcessHandle& handle, unsigned int signum)
{
  requestKill(handle.id(), signum);
}
//-----------------------------------------------------------------------------
void Process::requestKill(pid_t pid, unsigned int signum)
{
  if(kill(pid, signum) != 0)
    throw std::runtime_error(strerror(errno));
  int status = 0;
  wait(&status);
}
//-----------------------------------------------------------------------------
void Process::requestKill(ProcessHandle& handle)
{
  requestKill(handle.id());
}
//-----------------------------------------------------------------------------
void Process::requestKill(pid_t pid)
{
  Process::requestKill(pid, SIGKILL);
}
//-----------------------------------------------------------------------------
void Process::requestTermination(ProcessHandle& handle)
{
  requestTermination(handle.id());
}
//-----------------------------------------------------------------------------
void Process::requestTermination(pid_t pid)
{
  Process::requestKill(pid, SIGINT);
}
//-----------------------------------------------------------------------------
std::string Process::processStatus(ProcessHandle& handle)
{
  return processStatus(handle.id());
}
//-----------------------------------------------------------------------------
std::string Process::processStatus(pid_t pid)
{
  std::string result;
  char procPath[PATH_MAX]={0};

  sprintf(procPath, "/proc/%d/status", pid);

  FILE* proc = fopen(procPath, "r");
  if (proc)
  {
    const unsigned int SZ = 256;
    char buff[SZ]={0};
    char state[SZ]={0};

    fgets(buff, SZ, proc);
    fgets(buff, SZ, proc);
    sscanf(buff, "State:\t%20s", state);
    result = state;
    fclose(proc);
  }
  return result;
}
//-----------------------------------------------------------------------------
ProcessHandle Process::processParent(ProcessHandle& handle)
{
  return processParent(handle.id());
}
//-----------------------------------------------------------------------------
ProcessHandle Process::processParent(pid_t pid)
{
  char procPath[PATH_MAX]={0};
  pid_t ppid = 0;

  sprintf(procPath, "/proc/%d/status", pid);

  FILE* proc = fopen(procPath, "r");
  if (proc)
  {
    const unsigned int SZ = 256;
    char buff[SZ]={0};
    const char name[] = "PPid";

    while (!feof(proc))
    {
      fgets(buff, SZ, proc);
      if (strncmp(buff, name, strlen(name))==0)
      {
        sscanf(buff, "PPid:\t%10d", &ppid);
        break;
      }
    }
    fclose(proc);
  }
  return ProcessHandle(ppid);
}
//-----------------------------------------------------------------------------
bool Process::isExistProcess(ProcessHandle& handle)
{
  return isExistProcess(handle.id());
}
//-----------------------------------------------------------------------------
bool Process::isExistProcess(pid_t pid)
{
  bool result = false;
  char procPath[PATH_MAX]={0};

  sprintf(procPath, "/proc/%d/status", pid);

  FILE* proc = fopen(procPath, "r");
  if (proc)
  {
    result = true;
    fclose(proc);
  }
  return result;
}
//-----------------------------------------------------------------------------
pid_t Process::id(void)
{
  return getpid();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ProcessHandle Process::launch(const std::string& command, const Poco::Process::Args& args, const std::string& initialDirectory,
  std::istream& in, std::ostream& out, std::ostream& err, const Poco::Process::Env& env)
{
  return Process::launch(command, args, initialDirectory, in, out, err, env, nullptr);
}
//-----------------------------------------------------------------------------
ProcessHandle Process::launch(const std::string& command, const Poco::Process::Args& args,
    std::istream& in, std::ostream& out, std::ostream& err, const Poco::Process::Env& env)
{
  std::string initialDirectory;
  return Process::launch(command, args, initialDirectory, in, out, err, env);
}
//-----------------------------------------------------------------------------
ProcessHandle Process::launch(const std::string& command, const Poco::Process::Args& args, const std::string& initialDirectory,
    std::istream& in, std::ostream& out, std::ostream& err)
{
  Poco::Process::Env env;
  return Process::launch(command, args, initialDirectory, in, out, err, env);
}
//-----------------------------------------------------------------------------
ProcessHandle Process::launch(const std::string& command, const Poco::Process::Args& args,
  std::istream& in, std::ostream& out, std::ostream& err)
{
  std::string initialDirectory;
  return Process::launch(command, args, initialDirectory, in, out, err);
}
//-----------------------------------------------------------------------------
ProcessHandle Process::launch(const std::string& command, const Poco::Process::Args& args, const std::string& initialDirectory)
{
  std::stringstream inMsg, outMsg, errMsg;
  return Process::launch(command, args, initialDirectory, inMsg, outMsg, errMsg);
}
//-----------------------------------------------------------------------------
ProcessHandle Process::launch(const std::string& command, const Poco::Process::Args& args)
{
  std::string initialDirectory;
  return Process::launch(command, args, initialDirectory);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace HCE