process_spawn.cc

Go to the documentation of this file.

// Copyright (C) 2015-2021 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include <config.h>

#include <asiolink/io_service_signal.h>
#include <asiolink/process_spawn.h>
#include <exceptions/exceptions.h>
#include <cstring>
#include <functional>
#include <map>
#include <mutex>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>

using namespace std;
namespace ph = std::placeholders;

namespace isc {
namespace asiolink {

struct ProcessState {

    ProcessState() : running_(true), status_(0) {
    }

    bool running_;

    int status_;
};

typedef boost::shared_ptr<ProcessState> ProcessStatePtr;

typedef std::map<pid_t, ProcessStatePtr> ProcessStates;

class ProcessSpawnImpl;

typedef std::map<const ProcessSpawnImpl*, ProcessStates> ProcessCollection;

class ProcessSpawnImpl : boost::noncopyable {
public:

    ProcessSpawnImpl(IOServicePtr io_service,
                     const std::string& executable,
                     const ProcessArgs& args,
                     const ProcessEnvVars& vars);

    ~ProcessSpawnImpl();

    std::string getCommandLine() const;

    pid_t spawn(bool dismiss);

    bool isRunning(const pid_t pid) const;

    bool isAnyRunning() const;

    int getExitStatus(const pid_t pid) const;

    void clearState(const pid_t pid);

private:

    char* allocateInternal(const std::string& src);

    static bool waitForProcess(int signum);

    static ProcessCollection process_collection_;

    std::string executable_;

    boost::shared_ptr<char*[]> args_;

    boost::shared_ptr<char*[]> vars_;

    typedef boost::shared_ptr<char[]> CStringPtr;

    std::vector<CStringPtr> storage_;

    bool store_;

    static std::mutex mutex_;

    IOSignalSetPtr io_signal_set_;
};

ProcessCollection ProcessSpawnImpl::process_collection_;
std::mutex ProcessSpawnImpl::mutex_;

ProcessSpawnImpl::ProcessSpawnImpl(IOServicePtr io_service,
                                   const std::string& executable,
                                   const ProcessArgs& args,
                                   const ProcessEnvVars& vars)
    : executable_(executable), args_(new char*[args.size() + 2]),
      vars_(new char*[vars.size() + 1]), store_(false),
      io_signal_set_(new IOSignalSet(io_service,
                                     std::bind(&ProcessSpawnImpl::waitForProcess,
                                               ph::_1))) {
    struct stat st;

    if (stat(executable_.c_str(), &st)) {
        isc_throw(ProcessSpawnError, "File not found: " << executable_);
    }

    if (!(st.st_mode & S_IEXEC)) {
        isc_throw(ProcessSpawnError, "File not executable: " << executable_);
    }

    io_signal_set_->add(SIGCHLD);

    // Conversion of the arguments to the C-style array we start by setting
    // all pointers within an array to NULL to indicate that they haven't
    // been allocated yet.
    memset(args_.get(), 0, (args.size() + 2) * sizeof(char*));
    memset(vars_.get(), 0, (vars.size() + 1) * sizeof(char*));
    // By convention, the first argument points to an executable name.
    args_[0] = allocateInternal(executable_);
    // Copy arguments to the array.
    for (int i = 1; i <= args.size(); ++i) {
        args_[i] = allocateInternal(args[i - 1]);
    }
    // Copy environment variables to the array.
    for (int i = 0; i < vars.size(); ++i) {
        vars_[i] = allocateInternal(vars[i]);
    }
}

ProcessSpawnImpl::~ProcessSpawnImpl() {
    io_signal_set_->remove(SIGCHLD);
    if (store_) {
        lock_guard<std::mutex> lk(mutex_);
        process_collection_.erase(this);
    }
}

std::string
ProcessSpawnImpl::getCommandLine() const {
    std::ostringstream s;
    s << executable_;
    // Start with index 1, because the first argument duplicates the
    // path to the executable. Note, that even if there are no parameters
    // the minimum size of the table is 2.
    int i = 1;
    while (args_[i] != NULL) {
        s << " " << args_[i];
        ++i;
    }
    return (s.str());
}

pid_t
ProcessSpawnImpl::spawn(bool dismiss) {
    lock_guard<std::mutex> lk(mutex_);
    // Create the child
    pid_t pid = fork();
    if (pid < 0) {
        isc_throw(ProcessSpawnError, "unable to fork current process");

    } else if (pid == 0) {
        // Run the executable.
        execve(executable_.c_str(), args_.get(), vars_.get());
        // We may end up here if the execve failed, e.g. as a result
        // of issue with permissions or invalid executable name.
        _exit(EXIT_FAILURE);
    }

    // We're in the parent process.
    if (!dismiss) {
        store_ = true;
        process_collection_[this].insert(std::pair<pid_t, ProcessStatePtr>(pid, ProcessStatePtr(new ProcessState())));
    }
    return (pid);
}

bool
ProcessSpawnImpl::isRunning(const pid_t pid) const {
    lock_guard<std::mutex> lk(mutex_);
    ProcessStates::const_iterator proc;
    if (process_collection_.find(this) == process_collection_.end() ||
        (proc = process_collection_[this].find(pid)) == process_collection_[this].end()) {
        isc_throw(BadValue, "the process with the pid '" << pid
                  << "' hasn't been spawned and it status cannot be"
                  " returned");
    }
    return (proc->second->running_);
}

bool
ProcessSpawnImpl::isAnyRunning() const {
    lock_guard<std::mutex> lk(mutex_);
    if (process_collection_.find(this) != process_collection_.end()) {
        for (auto const& proc : process_collection_[this]) {
            if (proc.second->running_) {
                return (true);
            }
        }
    }
    return (false);
}

int
ProcessSpawnImpl::getExitStatus(const pid_t pid) const {
    lock_guard<std::mutex> lk(mutex_);
    ProcessStates::const_iterator proc;
    if (process_collection_.find(this) == process_collection_.end() ||
        (proc = process_collection_[this].find(pid)) == process_collection_[this].end()) {
        isc_throw(InvalidOperation, "the process with the pid '" << pid
                  << "' hasn't been spawned and it status cannot be"
                  " returned");
    }
    return (WEXITSTATUS(proc->second->status_));
}

char*
ProcessSpawnImpl::allocateInternal(const std::string& src) {
    const size_t src_len = src.length();
    storage_.push_back(CStringPtr(new char[src_len + 1]));
    // Allocate the C-string with one byte more for the null termination.
    char* dest = storage_[storage_.size() - 1].get();
    // copy doesn't append the null at the end.
    src.copy(dest, src_len);
    // Append null on our own.
    dest[src_len] = '\0';
    return (dest);
}

bool
ProcessSpawnImpl::waitForProcess(int) {
    lock_guard<std::mutex> lk(mutex_);
    for (;;) {
        int status = 0;
        pid_t pid = waitpid(-1, &status, WNOHANG);
        if (pid <= 0) {
            break;
        }
        for (auto const& instance : process_collection_) {
            auto const& proc = instance.second.find(pid);
            if (proc != instance.second.end()) {
                // In this order please
                proc->second->status_ = status;
                proc->second->running_ = false;
            }
        }
    }
    return (true);
}

void
ProcessSpawnImpl::clearState(const pid_t pid) {
    if (isRunning(pid)) {
        isc_throw(InvalidOperation, "unable to remove the status for the"
                  "process (pid: " << pid << ") which is still running");
    }
    lock_guard<std::mutex> lk(mutex_);
    if (process_collection_.find(this) != process_collection_.end()) {
        process_collection_[this].erase(pid);
    }
}

ProcessSpawn::ProcessSpawn(IOServicePtr io_service,
                           const std::string& executable,
                           const ProcessArgs& args,
                           const ProcessEnvVars& vars)
    : impl_(new ProcessSpawnImpl(io_service, executable, args, vars)) {
}

std::string
ProcessSpawn::getCommandLine() const {
    return (impl_->getCommandLine());
}

pid_t
ProcessSpawn::spawn(bool dismiss) {
    return (impl_->spawn(dismiss));
}

bool
ProcessSpawn::isRunning(const pid_t pid) const {
    return (impl_->isRunning(pid));
}

bool
ProcessSpawn::isAnyRunning() const {
    return (impl_->isAnyRunning());
}

int
ProcessSpawn::getExitStatus(const pid_t pid) const {
    return (impl_->getExitStatus(pid));
}

void
ProcessSpawn::clearState(const pid_t pid) {
    return (impl_->clearState(pid));
}

} // namespace asiolink
} // namespace isc