/*
 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

///////////////////////////////////////////////////////////////////////////////
/// \ingroup  tag_SystemManagerIf
/// \brief    This file provides support for the System Manager client interface.
///
///////////////////////////////////////////////////////////////////////////////

#include "system_service/ss_system_process.h"
#include <errno.h>
#include <sys/types.h>
#include <unistd.h>
#include <limits.h>
#include <pwd.h>
#include <grp.h>
#include <elfio/elfio_dump.hpp>

#include <string.h>
#include <signal.h>
#include <sys/wait.h>
#include <assert.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include "ss_system_if_interfaceunifiedlog.h"

const char* iProcess_DEFAULT_PROCESS_USER_NAME = "default_user";
uid_t iProcess_DEFAULT_PROCESS_USER = 4999;
gid_t iPrpocess_DEFAULT_PROCESS_GROUP = 4999;

/**
 * Process: Called when the class is instantiated.
 *
 * @return 
 */
Process::Process(int cpu_assign) :
  m_lValidationTag(lProcess_VALIDATION_VALUE),
  m_cpu_assign(cpu_assign),
  m_tProcessId(-1),
  m_eProcessLoadMode(NOWAIT),
  m_strFile(""),
  m_strProcessName(""),
  m_iErrorCode(0),
  m_fAutoKill(TRUE),
  m_iReturnCode(0) {
}


/**
 * ~Process: Called when the object is destroyed.
 *
 * @return 
 */
Process::~Process() {
  // ASSERT_VALID (this);

  //
  // Set the validation tag to NOT valid
  m_lValidationTag = 0;

  //
  // Cleanup after ourselves...
  //
  if ((m_fAutoKill) && (m_tProcessId != -1) && (m_tProcessId != getpid())) {
    KillProcess();        // Then remove the process from PosixBasedOS001
  }
}

/**
 * Process: Used to create an object and copy another
 * object to the new object.
 *
 * @param p_rhs_i Reference to the class being copied from. 
 * @return Process( const
 */
Process::Process(const Process& p_rhs_i) {
  // Copy data from the specified object to this object.
  Copy(p_rhs_i);
}


/**
 * operator=: Called when one object is assigned 
 * to another object.
 *
 * @param p_rhs_i Reference to the class being copied from. 
 * @return Process&
 */
Process& Process::operator= (const Process& p_rhs_i) {
  // Don't do anything if we're being copied on to ourselves.
  if (this == &p_rhs_i) return (*this);

  // Copy data from the specified object to this object.
  Copy(p_rhs_i);

  return (*this);
}


/**
 * Copy: Copies data members from the specified object to this object.
 * No attempt is made to free dynamically allocated objects within
 * this object (you must do that before calling this function).
 *
 * @param p_rhs_i 
 * @return void
 */
void Process::Copy(const Process& p_rhs_i) {
  // Copy data from the specified object to this object.
  m_lValidationTag = p_rhs_i.m_lValidationTag;

  m_tProcessId = p_rhs_i.m_tProcessId;
  m_eProcessLoadMode = p_rhs_i.m_eProcessLoadMode;
  m_strFile = p_rhs_i.m_strFile;
  m_strlstArgv = p_rhs_i.m_strlstArgv;
  m_strProcessName = p_rhs_i.m_strProcessName;
  m_iErrorCode = p_rhs_i.m_iErrorCode;
  m_fAutoKill = p_rhs_i.m_fAutoKill;
  m_iReturnCode = p_rhs_i.m_iReturnCode;
}

/**
 * GetProcessReturnCode: This function will return the processes
 * exit/return code. This is not the value of ERRNO as returned by 
 * GetLastPosixBasedOS001ErrorCode().
 *
 * @return code from the process
 */
int Process::GetProcessReturnCode() {
  int iProcessReturn = 0;
  if (waitpid(m_tProcessId, &iProcessReturn, WNOHANG) > 0) {
    m_iReturnCode = WEXITSTATUS(iProcessReturn);
  }

  return m_iReturnCode;
}

static int getIdsFromUserName(const char* user_name, uid_t *uid, gid_t *gid) {
  int ret = -1;

  try {
    if (NULL == user_name) {
      *uid = geteuid();
      *gid = getegid();
    } else {
      static __thread size_t  bufSize = 0;
      static __thread char   *buf = NULL;
      struct passwd  pwd;
      struct passwd *result;

      if (0 == bufSize) {
        struct stat statInfo;

        bufSize = -1;

        if (0 != stat("/etc/passwd", &statInfo) || 0 >= statInfo.st_size) {
          throw "/etc/passwd is not exist";
        }

        bufSize = statInfo.st_size * 2;

        // Since SystemManager is a resident service,
        // the area secured here is not explicity released by free()
        // in anticipation of release at the end of the process
        buf = reinterpret_cast<char *>(malloc(sizeof(char) * bufSize));
        if (NULL == buf) {
          throw "malloc()";
        }
      }

      if (NULL == buf) {
        throw "buf = NULL";
      }

      ret = getpwnam_r(user_name, &pwd, buf, bufSize, &result);
      if (ret == 0 && result != NULL) {
        *uid = pwd.pw_uid;
        *gid = pwd.pw_gid;
      } else {
        throw "getpwnam_r()";
      }
    }

    ret = 0;
  }

  catch (const char *e) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "ERROR:%s", e);
  }

  return ret;
}

/**
 * CreateProcess: This method will create a PosixBasedOS001 process with the executable provided and mode as a calling parameter. 
 * The caller can also provide a list of arguments that will be provided to the executable at startup. 
 * The calling p_strProcessName parameter is a textual name that will be
 * associated with the newly created process by the OS. The process state information 
 * will be maintained by this object.
 *
 * Upon successful creation of the process, the scheduling policy and priority
 * of the process will be set to the provided values. The user can change these
 * values through the SetSchedulingPolicy() and SetPriority() method calls.
 *
 * @param p_strFile_i Path and Filename of executable to create process for
 * @param p_strlstArgv_i List of ARGV values for new process
 * @param p_eMode_i Mode to create and load new process
 *          WAIT     -  The invoked program is loaded into available memory, is executed,
 *                      and then the original program resumes execution.
 *          NOWAIT   -  Causes the current program to execute concurrently with the new child process.
 * @param p_strProcessName_i This is the name that will be registered to the OS for this process
 * @param p_eSchedulingPolicy_i Scheduling Policy for this process
 *          FIFO          - A fixed priority scheduler in which the highest ready process runs until it
 *                          blocks or is preempted by a higher priority process.
 *          ROUND_ROBIN   - The same as FIFO, except processes at the same priority level time-slice.
 *          OTHER         - A general time sharing scheduler in which a process decays in priority if it
 *                          consumes too much processor before blocking. It reverts to its default priority
 *                          when it blocks. Should it fail to run over a 2 second period and it has decayed
 *                          then it's boosted one priority level up to a maximum of its default priority.
 * @param p_iPriority_i Priority for this process
 * @param p_lSpawnFlags_i Spawning flags. These are PosixBasedOS001 specific....
 * @return void
 */
void Process::CreateProcess(
            const SS_String& p_strFile_i,      // Path and Filename of executable to create process for
            const StringList& p_strlstArgv_i,    // List of ARGV values for new process
            const eProcessLoadMode p_eMode_i,    // Mode to create and load new process
            const SS_String& p_strProcessName_i,  // This is the name that will be registered to the OS for this process
            const eProcessSchedulingPolicy p_eSchedulingPolicy_i,  // Scheduling Policy for this process
            const int p_iPriority_i,        // Priority for this process
                      const char* unix_user_name,
            const long p_lSpawnFlags_i        // Posix Spawning flags. These are PosixBasedOS001 specific....  // NOLINT (runtime/int)
) {
  //========================================================================================
  // Perform some idiot checking of the parameters that are passed in.
  // Check the priority level that is being set to make sure it is in bounds.
  // Then save off the calling parameters into the objects member variables.
  // Also check the number of valid calling (argv[]) parameters passed in
  //========================================================================================
  m_iErrorCode = 0;   // Initialize to NO ERROR
  m_iReturnCode = 0;  // Initialize value (0 usually means good in unix/PosixBasedOS001)

  //
  // Process filename os provided
  //
  if (p_strFile_i.empty()) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }

  //
  // Save off process calling arguments
  //
  m_eProcessLoadMode = p_eMode_i;

  m_strFile = p_strFile_i;

  if (!p_strProcessName_i.empty())
    m_strProcessName = p_strProcessName_i;

  //
  // Copy Argument List...
  //
  SetCallingArgumentList(p_strlstArgv_i);

  //
  // Valid number of calling arguments
  //
  int iNumberElements = m_strlstArgv.size();
  if (iNumberElements > (iProcess_MAXIMUM_NUMBER_OF_PROCESS_ARGUMENTS - 3)) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }


  //========================================================================================
  // Initialize to the beginning of the provided argument list.
  // Allocate an array of buffer pointers that will be used for the ARGV calling parameters
  // for the specified process.
  // Set the ARGV[0] equal to the process name being created
  // Set the ARGV[1] equal to the process name to be registered with the OS.
  // If p_strProcessName_is NULL, do not set the cArgv[1] parameter
  // Populate the array that will hold the argument list for the new process we are creating.
  //========================================================================================
  //

  int iLoop = 1;
  char * cArgv[iProcess_MAXIMUM_NUMBER_OF_PROCESS_ARGUMENTS];

  cArgv[0] = basename(const_cast<char *>(p_strFile_i.c_str()));    // Set the executable filename

  // Go through the list of provided argv calling parameters to the CreateProcess
  // function, and copy the arguments to the ARGV[] calling argument which will be passed
  // into the process being created.
  StringListIter at = m_strlstArgv.begin();
  for (; at !=  m_strlstArgv.end(); at++, iLoop++) {
    cArgv[iLoop] = const_cast<char *>(at->c_str());
  }

  cArgv[iLoop] = NULL;

  try {
    CL_ProcessAttr_t        clAttr;
    CL_ProcessSchedPolicy_t clPolicy = CL_PROCESS_SCHED_POLICY_OTHER;
    int                     clPriority = 0;

    if (0 != CL_ProcessCreateAttrInit(&clAttr)) {
      throw "CL_ProcessCreateAttrInit()";
    }


    // In order to collect even the child processes of the service, all are group leaders.
    if (0 != CL_ProcessCreateAttrSetGroup(&clAttr, 1)) {
      throw "CL_ProcessCreateAttrInit()";
    }

    if (0 != CL_ProcessCreateAttrSetCpuAssign(&clAttr, m_cpu_assign)) {
      throw "CL_ProcessCreateAttrSetCpuAssign()";
    }

    switch (p_eSchedulingPolicy_i) {
      case FIFO:
        clPolicy =  CL_PROCESS_SCHED_POLICY_FIFO;
        break;
      case ROUND_ROBIN:
        clPolicy =  CL_PROCESS_SCHED_POLICY_RR;
        break;
      case OTHER:
        clPolicy =  CL_PROCESS_SCHED_POLICY_OTHER;
        break;
      default:
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "p_eSchedulingPolicy_i = %d", p_eSchedulingPolicy_i);
        break;
    }

    switch (p_eSchedulingPolicy_i) {
      case FIFO:
      case ROUND_ROBIN:
        if ((1 > p_iPriority_i) || (p_iPriority_i > 99)) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "p_eSchedulingPolicy_i = %d", p_eSchedulingPolicy_i);
        } else {
          clPriority = p_iPriority_i;
        }
        break;
      case OTHER:
      default:
        if ((-20 > p_iPriority_i) || (p_iPriority_i > 19)) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "p_eSchedulingPolicy_i = %d", p_eSchedulingPolicy_i);
        } else {
          clPriority = p_iPriority_i;
        }
        break;
    }

    if (0 != CL_ProcessCreateAttrSetSchedule(&clAttr, clPolicy, clPriority)) {
      throw "CL_ProcessCreateAttrSetSchedule()";
    }

    uid_t uid = 0;
    gid_t gid = 0;

    if (0 != getIdsFromUserName(unix_user_name, &uid, &gid)) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "unexpected unix_user_name [%s]", unix_user_name);
      uid = geteuid();
      gid = getegid();
    }
    if (uid == 0) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "!! uid=root %s", m_strFile.c_str());
      uid = UINT_MAX;
    }
    if (0 != CL_ProcessCreateAttrSetUid(&clAttr, uid)) {
      throw "CL_ProcessCreateAttrSetUid()";
    }

    if (0 != CL_ProcessCreateAttrSetGid(&clAttr, gid)) {
      throw "CL_ProcessCreateAttrSetGid()";
    }

    if (0 != CL_ProcessCreateAttrSetDisableCloseFds(&clAttr)) {
      throw "CL_ProcessCreateAttrSetDisableCloseFds()";
    }
    char environment_string[2048] = {0};  // Size is provisional
    fprintf(stderr, "[%s](%d)Process Create Target : %s \n", __func__, __LINE__, m_strFile.c_str());

    CheckLdPreLoad(&m_strFile, environment_string);

    CreateProcess(&m_strFile, const_cast<char* const*>(cArgv), environment_string, &clAttr);
  }

  catch(const char *e) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "%s", e);
  }
}

/**
 * CreateProcess: This method will create a process with the executable provided and mode as a calling parameter.
 * The caller can also provide a list of arguments that will be provided to the executable at startup.
 * The calling p_strProcessName parameter is a textual name that will be
 * associated with the newly created process by the OS. The process state information
 * will be maintained by this object.
 *
 * @param p_str_file Path and Filename of executable to create process for
 * @param c_argv use process arguments
 * @param environment_string Set LD_PRELOAD string
 * @param cl_attr CL_ProcessAttr_t
 * @return void
 */
void Process::CreateProcess(const SS_String *p_str_file, char* const*c_argv, char* environment_string,
                            const CL_ProcessAttr_t *cl_attr) {
  try {
    if ((p_str_file == NULL) || (c_argv == NULL) || (cl_attr == NULL)) {
      throw "CreateProcess() Invaild Param";
    }

    int process_id = -1;
    if (environment_string[0] == '\0') {
      // If there is no LD_PRELOAD setting, set envp to NULL
      process_id = CL_ProcessCreate(p_str_file->c_str(), c_argv, NULL, cl_attr);
    } else {
      // vector holding preferences
      std::vector<SS_String> *vec_environ = GetEnvironVector();

      // Set LD_PRELOAD string as the last element
      SS_String ld_preload_string = SS_String(environment_string);
      vec_environ->push_back(environment_string);

      // Number of acquired environment variables + 1(For terminal) memory allocation
      size_t env_num = sizeof(char*) * (vec_environ->size() + 1);
      char **p_environment = static_cast<char **>(malloc(env_num));
      memset(p_environment, 0x00, env_num);

      // Create environment variable list
      int i = 0;
      char **p_environment_tmp = p_environment;
      for (std::vector<SS_String>::iterator itr = vec_environ->begin(); itr != vec_environ->end(); itr++, i++) {
        p_environment_tmp[i] = static_cast<char *>(malloc(sizeof(char) * (itr->length() + 1)));

        snprintf(p_environment_tmp[i], itr->length() + 1, "%s", itr->c_str());
      }

      // Set envp for environment variable
      process_id = CL_ProcessCreate(p_str_file->c_str(), c_argv, p_environment, cl_attr);

      // Free memory
      i = 0;
      p_environment_tmp = p_environment;
      for (std::vector<SS_String>::iterator itr = vec_environ->begin(); itr != vec_environ->end(); itr++, i++) {
        free(p_environment_tmp[i]);
      }

      free(p_environment);
      delete(vec_environ);
    }

    if (process_id == -1) {
      throw "CL_ProcessCreate()";
    }

    m_tProcessId = process_id;
  }
  catch (const char *e) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "%s", e);
  }
}
/**
 * CreateProcess: This method will create a PosixBasedOS001 process with the executable provided and mode as a calling parameter. 
 * The caller can also provide a list of arguments that will be provided to the executable at startup. 
 * The calling p_strProcessName parameter is a textual name that will be
 * associated with the newly created process by the OS. The process state information 
 * will be maintained by this object.
 *
 * @param p_strFile_i Path and Filename of executable to create process for
 * @param p_strProcessName This is the name that will be registered to the OS for this process 
 * @return void
 */
void Process::CreateProcess(const SS_String& p_strFile_i, const SS_String& p_strProcessName,
                            const char* unix_user_name, const long p_lSpawnFlags_i) {  // NOLINT (runtime/int)
  StringList strlstArgv;

  try {
    CreateProcess(p_strFile_i,
            strlstArgv,
            NOWAIT,
            p_strProcessName,
            FIFO,
            iProcess_DEFAULT_PROCESS_PRIORITY,
                        unix_user_name,
            p_lSpawnFlags_i);
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}


/**
 * CreateProcess: This method will create a process with the executable provided and mode as a calling parameter.
 * The caller can also provide a list of arguments that will be provided to the executable at startup. 
 * The calling p_strProcessName parameter is a textual name that will be
 * associated with the newly created process by the OS. The process state information 
 * will be maintained by this object.
 *
 *
 * @param p_strFile_i Path and Filename of executable to create process for
 * @param p_strProcessName This is the name that will be registered to the OS for this process
 * @param p_iPriority_i  Priority of process
 * @return void
 */
void Process::CreateProcess(const SS_String& p_strFile_i, const SS_String& p_strProcessName, const int p_iPriority_i,
                            const char* unix_user_name, const long p_lSpawnFlags_i) {  // NOLINT (runtime/int)
  StringList strlstArgv;

  try {
    eProcessSchedulingPolicy policy;

    if (0 < p_iPriority_i) {
       policy = FIFO;
    } else {
       policy = OTHER;
    }

    CreateProcess(p_strFile_i,
            strlstArgv,
            NOWAIT,
            p_strProcessName,
            policy,
            p_iPriority_i,
                        unix_user_name,
            p_lSpawnFlags_i);
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}

/**
 * CreateProcess: This method will create a process with the executable provided and mode as a calling parameter.
 * The caller can also provide a list of arguments that will be provided to the executable at startup. 
 * The calling p_strProcessName parameter is a textual name that will be
 * associated with the newly created process by the OS. The process state information 
 * will be maintained by this object.
 *
 * @param p_strFile_i Path and Filename of executable to create process for
 * @param p_lSpawnFlags_i Spawning flags. These are PosixBasedOS001 specific.
 * @return void
 */
void  Process::CreateProcess(const SS_String& p_strFile_i, const char* unix_user_name, const long p_lSpawnFlags_i) {  // NOLINT (runtime/int)
  StringList strlstArgv;

  try {
    CreateProcess(p_strFile_i,
            strlstArgv,
            NOWAIT,
            basename(const_cast<char *>(p_strFile_i.c_str())),
            FIFO,
            iProcess_DEFAULT_PROCESS_PRIORITY,
                        unix_user_name,
            p_lSpawnFlags_i);
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}



/**
 * CreateProcess: This method will create a  process with the executable provided and mode as a calling parameter.
 * The caller can also provide a list of arguments that will be provided to the executable at startup. 
 * The calling p_strProcessName parameter is a textual name that will be
 * associated with the newly created process by the OS. The process state information 
 * will be maintained by this object.
 *
 * @param p_strFile_i Path and Filename of executable to create process for
 * @param p_strProcessName This is the name that will be registered to the OS for this process
 * @param p_strlstArgv_i  List of ARGV values for new process
 * @param p_lSpawnFlags_i Spawning flags. These are PosixBasedOS001 specific.
 * @return void
 */
void Process::CreateProcess(const SS_String& p_strFile_i, const SS_String& p_strProcessName_i,
                            const StringList& p_strlstArgv_i, const char* unix_user_name, const long p_lSpawnFlags_i) {  // NOLINT (runtime/int)
  try {
    CreateProcess(p_strFile_i,
            p_strlstArgv_i,
            NOWAIT,
            p_strProcessName_i,
            FIFO,
            iProcess_DEFAULT_PROCESS_PRIORITY,
                        unix_user_name,
            p_lSpawnFlags_i);
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}


void Process::CreateProcess(const SS_String& p_strFile_i, const SS_String& p_strProcessName_i, const int p_iPriority_i,
                            const StringList& p_strlstArgv_i, const char* unix_user_name, const long p_lSpawnFlags_i) {  // NOLINT (runtime/int)
  try {
    eProcessSchedulingPolicy policy;

    if (0 < p_iPriority_i) {
       policy = FIFO;
    } else {
       policy = OTHER;
    }

    CreateProcess(p_strFile_i,
            p_strlstArgv_i,
            NOWAIT,
            p_strProcessName_i,
            policy,
            p_iPriority_i,
                        unix_user_name,
            p_lSpawnFlags_i);
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}


/**
 * CreateProcessWait: This method will create a process with the executable provided.
 * The process state information will be maintained by this object.
 *
 * @param p_strFile_i Path and Filename of executable to create process for 
 * @return void
 */
void Process::CreateProcessWait(const SS_String& p_strFile_i) {
  StringList strlstArgv;

  try {
    CreateProcess(p_strFile_i,
            strlstArgv,
            WAIT,
            basename(const_cast<char *>(p_strFile_i.c_str())),
            FIFO,
            iProcess_DEFAULT_PROCESS_PRIORITY,
            iProcess_DEFAULT_PROCESS_USER_NAME,
            iProcess_DEFAULT_PROCESS_FLAGS);
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}

/**
 * CreateProcessWait: This method will create a PosixBasedOS001 process with the executable provided.
 * The process state information will be maintained by this object.
 *
 *
 * @param p_strFile_i Path and Filename of executable to create process for 
 * @param p_strlstArguments_i List of process calling arguments
 * @return void
 */
void Process::CreateProcessWait(const SS_String& p_strFile_i, const StringList& p_strlstArguments_i) {
  try {
    CreateProcess(p_strFile_i,
            p_strlstArguments_i,
            WAIT,
            basename(const_cast<char *>(p_strFile_i.c_str())),
            FIFO,
            iProcess_DEFAULT_PROCESS_PRIORITY,
            iProcess_DEFAULT_PROCESS_USER_NAME,
            iProcess_DEFAULT_PROCESS_FLAGS);
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}



/**
 * KillProcess: This method will delete the process represented by this object. All variables associated
 * with this object will be initialized to a know value.
 *
 * @param  
 * @return void
 */
void Process::KillProcess(int signal) {
  //=====================================================================================
  // Intialize the objects m_iErrorCode member variable to 0 (no error).
  // Then try to delete the process that this object represents.
  m_iErrorCode = 0;

  if (DoesProcessExist()) {
    if (-1 == killpg(m_tProcessId, signal)) {
      return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
    }
  }

  //
  // If no errors, clear out any process specific member variables for this object
  //
  m_tProcessId = -1;
  m_strProcessName = "";
}

/**
 * SetSchedulingPolicy: This method will change the scheduling policy for the process this
 * object represents. 
 *
 * @param p_eSchedulingPolicy_i Scheduling policy 
 * @return void
 */
void Process::SetSchedulingPolicy(
          const eProcessSchedulingPolicy p_eSchedulingPolicy_i  // Scheduling policy
) {
  //=======================================================================================
  // Attempt to change the scheduling policy for the process that this object
  // represents. If the change fails, restore the previous settings.
  //
  m_iErrorCode = 0;
  struct sched_param cur_sch_params;
  sched_getparam(m_tProcessId, &cur_sch_params);
  if (0 != sched_setscheduler(m_tProcessId, ConvertToPosixBasedOS001SchedularPolicy(p_eSchedulingPolicy_i),
                              &cur_sch_params)) {
    m_iErrorCode = errno;
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}

/**
 * SetPriority: This method will change the priority for the process this
 * object represents. 
 *
 * @param p_iPriority_i Scheduling Policy for this process
 * @return void
 */
void Process::SetPriority(const int p_iPriority_i) {
  //=======================================================================================
  // Attempt to change the priority for the process that this object
  // represents. If the change fails, restore the previous settings.
  //
  m_iErrorCode = 0;
  struct sched_param cur_sch_params;
  sched_getparam(m_tProcessId, &cur_sch_params);
  cur_sch_params.sched_priority = p_iPriority_i;

  if (-1 == sched_setparam(m_tProcessId, &cur_sch_params)) {
    m_iErrorCode = errno;
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}


/**
 * IncreasePriorityByOne: This method will increase the priority for the process this
 * object represents by one.
 *
 * @param  
 * @return void
 */
void Process::IncreasePriorityByOne(void) {
  //================================================================================
  // Retrieve the current priority of the process. Check to see if already at max.
  // If so just return. Otherwise increase by one and set the priority...
  //
  try {
    int iCurrentPriority = GetPriority();
    if (iCurrentPriority < iProcess_MAXIMUM_PROCESS_PRIORITY) {
      SetPriority(iCurrentPriority + 1);
    }
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}


/**
 * DecreasePriorityByOne: This method will decrease the priority for the process this
 * object represents by one.
 *
 *
 * @return void
 */
void Process::DecreasePriorityByOne(void) {
  //================================================================================
  // Retrieve the current priority of the process. Check to see if already at minimum.
  // If so just return. Otherwise decrease by one and set the priority...
  //
  try {
    int iCurrentPriority = GetPriority();
    if (iCurrentPriority > 1) {
      SetPriority(iCurrentPriority - 1);
    }
  }
  catch (...) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }
}





////////////////////////////////////////////////////////////////////////////////////////////////////
// ConvertToPosixBasedOS001SchedularPolicy
//
// This method will return to the caller the equivalent PosixBasedOS001 schedular policy for the process
// that this object represents
//
//
// Calling Arguments:
//      NONE
//
// Return Argument:
//  FIFO,      // A fixed priority scheduler in which the highest ready process runs until it
//          // blocks or is preempted by a higher priority process.
//  ROUND_ROBIN,  // The same as FIFO, except processes at the same priority level time-slice.
//  OTHER      // A general time sharing scheduler in which a process decays in priority if it
//          // consumes too much processor before blocking. It reverts to its default priority
//          // when it blocks. Should it fail to run over a 2 second period and it has decayed
//          // then it's boosted one priority level up to a maximum of its default priority.
//
int const Process::ConvertToPosixBasedOS001SchedularPolicy(const eProcessSchedulingPolicy p_eSchedulingPolicy_i) {
  int iReturnValue = SCHED_RR;  // Default is RR
  switch (p_eSchedulingPolicy_i) {
    case FIFO:
    {
      iReturnValue = SCHED_FIFO;
      break;
    }

    case ROUND_ROBIN:
    {
      iReturnValue = SCHED_RR;
      break;
    }

    case OTHER:
    {
      iReturnValue = SCHED_OTHER;
      break;
    }
  }

  return iReturnValue;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// ConvertFromPosixBasedOS001SchedularPolicy
//
// This method will return to the caller the eProcessSchedulingPolicy based on the PosixBasedOS001 schedular
// policy for the process that this object represents
//
//
// Calling Arguments:
//      PosixBasedOS001 Scheduling Policy
//
// Return Argument:
//  FIFO,      // A fixed priority scheduler in which the highest ready process runs until it
//          // blocks or is preempted by a higher priority process.
//  ROUND_ROBIN,  // The same as FIFO, except processes at the same priority level time-slice.
//  OTHER      // A general time sharing scheduler in which a process decays in priority if it
//          // consumes too much processor before blocking. It reverts to its default priority
//          // when it blocks. Should it fail to run over a 2 second period and it has decayed
//          // then it's boosted one priority level up to a maximum of its default priority.
//
Process::eProcessSchedulingPolicy const Process::ConvertFromPosixBasedOS001SchedularPolicy
                                                 (const int p_iPosixBasedOS001chedulingPolicy_i) {
  eProcessSchedulingPolicy ePolicy = ROUND_ROBIN;  // Default is RR
  switch (p_iPosixBasedOS001chedulingPolicy_i) {
    case SCHED_FIFO:
    {
      ePolicy = FIFO;
      break;
    }

    case SCHED_RR:
    {
      ePolicy = ROUND_ROBIN;
      break;
    }
    case SCHED_OTHER:
    {
      ePolicy = OTHER;
      break;
    }
  }  // Switch

  return ePolicy;
}


/**
 * DoesProcessExist: This method will return a BOOLean indicating whether this 
 * process exists.
 *
 * @return BOOL TRUE  - Process Exists, FALSE - Process does not exist
 */
BOOL Process::DoesProcessExist(void) {
  struct sched_param cur_sch_params;
  if (-1 >=  sched_getparam(m_tProcessId, &cur_sch_params)) {  // or the segment data
    return FALSE;
  }

  return TRUE;
}



/**
 * SetProcessName: This method will set this objects process name member variable to the 
 * provided string value.
 *
 * @param p_strProcessName_i Process Name to set the m_strProcessName member variable to
 * @return void
 */
void Process::SetProcessName(const SS_String& p_strProcessName_i) {
  //
  // Idiot checking
  //
  assert(!p_strProcessName_i.empty());

  m_strProcessName = p_strProcessName_i;
}

/**
 * GetSchedulingPolicy: This method will return to the caller the 
 * currently configured process scheduling policy.
 *
 * @return Process::eProcessSchedulingPolicy const
 */
Process::eProcessSchedulingPolicy const Process::GetSchedulingPolicy(void) {
  int policy = 0;
  if (-1 == (policy = sched_getscheduler(m_tProcessId))) {
    m_iErrorCode = errno;
    return ROUND_ROBIN;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }

  return (ConvertFromPosixBasedOS001SchedularPolicy (policy));
}



/**
 * GetPriority: This method will return to the caller the currently configured
 * process priority.
 *
 * @return int const
 */
int const Process::GetPriority(void) {
  struct sched_param cur_sch_params;
  if (-1 >=  sched_getparam(m_tProcessId, &cur_sch_params)) {
    m_iErrorCode = errno;
    return -1;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }

  return (cur_sch_params.sched_priority);
}



/**
 * SetCallingArgumentList: This method will set the calling argument list 
 * that this object represents.
 *
 * @param p_pcArgv_i Pointer to NULL terminated argument list.
 * @param p_iArgc_i Number of parameters
 * @return void
 */
void Process::SetCallingArgumentList(const char *p_pcArgv_i[], const int p_iArgc_i) {
  ////////////////////////////////////////////////////////////////////////
  // Set the executable filename first. This is always the 1st argument
  // in the argument list. Then set the argument list for the process
  // which is held in m_strlstArgv.
  //
  if (p_iArgc_i > (iProcess_MAXIMUM_NUMBER_OF_PROCESS_ARGUMENTS - 3)) {
    return;  // PAD THIS IS BAD!!! TODO: Change this to something meaningful
  }

  //
  // First make sure that the argument list is empty.
  //
  if (!m_strlstArgv.empty()) {
    m_strlstArgv.clear();      // Remove all elements from the current list
  }  // Process Argument list is NOT empty

  //
  // Once empty, put the new arguments into the list
  //
  StringListIter at = m_strlstArgv.begin();
  int iLoop;
  for (iLoop = 0; iLoop < p_iArgc_i; iLoop ++) {
    at = m_strlstArgv.insert(at, p_pcArgv_i[iLoop]);
  }
}


/**
 * SetCallingArgumentList: This method will set the calling argument 
 * list that this object represents.
 *
 * @param p_strlstParameters_i List of parameters 
 * @return void
 */
void Process::SetCallingArgumentList(const StringList& p_strlstParameters_i) {
  if (p_strlstParameters_i.size()) {
    m_strlstArgv.clear();  // Empty the current list.
    m_strlstArgv = p_strlstParameters_i;
  }
}

/**
 * Search if libTestFwCommon.so is dynamically linked.
 *
 * @param process_path Search target binary path
 * @return bool
 */
static bool CheckLinkedTestfwLibrary(SS_String *process_path) {
  if (NULL == process_path) {
    fprintf(stderr, "[%s](%d)Invaild Param.\n", __func__, __LINE__);
    return false;
  }

  ELFIO::elfio reader;
  if (!reader.load(process_path->c_str())) {
    fprintf(stderr, "[%s](%d)%s is not ELF!\n", __func__, __LINE__, process_path->c_str());
    return false;
  }

  ELFIO::Elf_Half n = reader.sections.size();
  for ( ELFIO::Elf_Half i = 0; i < n; ++i ) {
    ELFIO::section* sec = reader.sections[i];
    if ( SHT_DYNAMIC == sec->get_type() ) {
      ELFIO::dynamic_section_accessor dynamic(reader, sec);

      ELFIO::Elf_Xword dynamic_num = dynamic.get_entries_num();
      if ( dynamic_num > 0 ) {
        for ( ELFIO::Elf_Xword i = 0; i < dynamic_num; ++i ) {
          ELFIO::Elf_Xword   dynamic_tag   = 0;
          ELFIO::Elf_Xword   dynamic_value = 0;
          SS_String dynamic_str;
          dynamic.get_entry(i, dynamic_tag, dynamic_value, dynamic_str);

          // Search if the acquired dynamic section string contains libTestFwCommon.so
          if (SS_String::npos != dynamic_str.find("libTestFwCommon.so")) {
            fprintf(stderr, "[%s](%d)libTestFwCommon is linked.\n", __func__, __LINE__);
            return true;
          }

          // Check for continuation of dynamic section element
          if ( DT_NULL == dynamic_tag ) {
            break;
          }
        }
      } else {
        // If dynamic section is not found
        fprintf(stderr, "[%s](%d)dynamic symbol is not find.\n", __func__, __LINE__);
      }
    }
  }

  fprintf(stderr, "[%s](%d)libTestFwCommon is not find. \n", __func__, __LINE__);
  return false;
}

/**
 * This method is a private method to be called from CreateProcess func.
 * Check environment variable MOCK_LIBRARY where Mock Library Name to set in LD_PRELOAD is set
 * and output character string to set in LD_PRELOAD if there is setting.
 *
 * @param process_path,environment_string
 * @return void
 */
void Process::CheckLdPreLoad(SS_String *process_path, char *environment_string) {
  if ((process_path == NULL || environment_string == NULL)) {
    fprintf(stderr, "[%s](%d)Invaild Param.\n", __func__, __LINE__);
    return;
  }

  // Check if environment variable MOCK_LIBRARY for LD_PRELOAD setting is set
  char *value_mock_library = getenv("MOCK_LIBRARY");

  if (value_mock_library != NULL) {
    // When MOCK_LIBRARY is set
    fprintf(stderr, "[%s](%d)MOCK_LIBRARY = %s \n", __func__, __LINE__, value_mock_library);

    // Check whether the process to be started is a core unit or TestFW, and execute LD_PRELOAD if libTestFwCommon.so is linked
    if (CheckLinkedTestfwLibrary(process_path)) {
      SS_String key_value;
      SS_String key_ld_preload = "LD_PRELOAD=";

      // Create LD_PRELOAD setting string
      // LD_PRELOAD is enabled when the string is an envp argument in the form "LD_PRELOAD=hoge_mock.so hoge_mock.so ..."
      key_value = key_ld_preload + value_mock_library;
      strncpy(environment_string, key_value.c_str(), key_value.length());
      fprintf(stderr, "[%s](%d)Set envp: %s \n", __func__, __LINE__, environment_string);
      return;
    } else {
      // If the unit does not require LD_PRELOAD setting, set envairoment_string to NULL.
      fprintf(stderr, "[%s](%d)Core Unit is not setting LD_PRELOAD\n", __func__, __LINE__);
      return;
    }
  } else {
    // If it is not set to MOCK_LIBRARY, it is not necessary to set LD_PRELOAD, so set envairoment_string to NULL.
    fprintf(stderr, "[%s](%d)The MOCK_LIBRARY variable was unestablished.\n", __func__, __LINE__);
    return;
  }
}

/**
 * Acquire the character string of the environment variable and set it in String Vector
 * and return in a pointer of Vector.
 *
 * @param process_path,environment_string
 * @return vector<SS_String> pointer
 */
extern char ** environ;
std::vector<SS_String> *Process::GetEnvironVector(void) {
  // If LD_PRELOAD is set, copy existing environment settings and set to environment_pointer

  std::vector<SS_String>* vector_environ = new std::vector<SS_String>;

  char **environ_tmp = environ;

  // Insert environ_string into the vector table
  int i = 0;
  while (environ_tmp[i] != NULL) {
    SS_String str_env(environ_tmp[i]);
    vector_environ->push_back(str_env);
    i++;
  }

  return vector_environ;
}
// ----------------------------------------