#include "ChildProcess.h"

#include <system_error>

#include "Logging.h"

#include "make_unique.h"

#include "watchman_scopeguard.h"

namespace watchman {

ChildProcess::Environment::Environment() {

// Construct the map from the current process environment

uint32_t nenv, i;

const char* eq;

const char* ent;

for (i = 0, nenv = 0; environ[i]; i++) {

nenv++;

}

map_.reserve(nenv);

for (i = 0; environ[i]; i++) {

ent = environ[i];

eq = strchr(ent, '=');

if (!eq) {

continue;

}

// slice name=value into a key and a value string

w_string str(ent, W_STRING_BYTE);

auto key = str.slice(0, (uint32_t)(eq - ent));

auto val = str.slice(

1 + (uint32_t)(eq - ent), (uint32_t)(str.size() - (key.size() + 1)));

// Replace rather than set, just in case we somehow have duplicate

// keys in our environment array.

map_[key] = val;

}

}

ChildProcess::Environment::Environment(

const std::unordered_map<w_string, w_string>& map)

: map_(map) {}

std::unique_ptr<char*, ChildProcess::Deleter>

ChildProcess::Environment::asEnviron(size_t* env_size) const {

size_t len = (1 + map_.size()) * sizeof(char*);

// Make a pass through to compute the required memory size

for (const auto& it : map_) {

const auto& key = it.first;

const auto& val = it.second;

// key=value\0

len += key.size() + 1 + val.size() + 1;

}

auto envp = (char**)malloc(len);

if (!envp) {

throw std::bad_alloc();

}

auto result = std::unique_ptr<char*, Deleter>(envp, Deleter());

// Now populate

auto buf = (char*)(envp + map_.size() + 1);

size_t i = 0;

for (const auto& it : map_) {

const auto& key = it.first;

const auto& val = it.second;

envp[i++] = buf;

// key=value\0

memcpy(buf, key.data(), key.size());

buf += key.size();

memcpy(buf, "=", 1);

buf++;

memcpy(buf, val.data(), val.size());

buf += val.size();

*buf = 0;

buf++;

}

envp[map_.size()] = nullptr;

if (env_size) {

*env_size = len;

}

return result;

}

void ChildProcess::Environment::set(const w_string& key, const w_string& val) {

map_[key] = val;

}

void ChildProcess::Environment::set(const w_string& key, bool bval) {

if (bval) {

map_[key] = "true";

} else {

map_.erase(key);

}

}

void ChildProcess::Environment::set(

std::initializer_list<std::pair<w_string_piece, w_string_piece>> pairs) {

for (auto& pair : pairs) {

set(pair.first.asWString(), pair.second.asWString());

}

}

void ChildProcess::Environment::unset(const w_string& key) {

map_.erase(key);

}

ChildProcess::Options::Options() : inner_(make_unique<Inner>()) {

#ifdef POSIX_SPAWN_CLOEXEC_DEFAULT

setFlags(POSIX_SPAWN_CLOEXEC_DEFAULT);

#endif

}

ChildProcess::Options::Inner::Inner() {

posix_spawnattr_init(&attr);

posix_spawn_file_actions_init(&actions);

}

ChildProcess::Options::Inner::~Inner() {

posix_spawn_file_actions_destroy(&actions);

posix_spawnattr_destroy(&attr);

}

void ChildProcess::Options::setFlags(short flags) {

short currentFlags;

auto err = posix_spawnattr_getflags(&inner_->attr, &currentFlags);

if (err) {

throw std::system_error(

err, std::generic_category(), "posix_spawnattr_getflags");

}

err = posix_spawnattr_setflags(&inner_->attr, currentFlags | flags);

if (err) {

throw std::system_error(

err, std::generic_category(), "posix_spawnattr_setflags");

}

}

#ifdef POSIX_SPAWN_SETSIGMASK

void ChildProcess::Options::setSigMask(const sigset_t& mask) {

posix_spawnattr_setsigmask(&inner_->attr, &mask);

setFlags(POSIX_SPAWN_SETSIGMASK);

}

#endif

ChildProcess::Environment& ChildProcess::Options::environment() {

return env_;

}

void ChildProcess::Options::dup2(int fd, int targetFd) {

auto err = posix_spawn_file_actions_adddup2(&inner_->actions, fd, targetFd);

if (err) {

throw std::system_error(

err, std::generic_category(), "posix_spawn_file_actions_adddup2");

}

}

#ifdef _WIN32

void ChildProcess::Options::dup2(intptr_t handle, int targetFd) {

auto err = posix_spawn_file_actions_adddup2_handle_np(

&inner_->actions, handle, targetFd);

if (err) {

throw std::system_error(

err,

std::generic_category(),

"posix_spawn_file_actions_adddup2_handle_np");

}

}

#endif

void ChildProcess::Options::open(

int targetFd,

const char* path,

int flags,

int mode) {

auto err = posix_spawn_file_actions_addopen(

&inner_->actions, targetFd, path, flags, mode);

if (err) {

throw std::system_error(

err, std::generic_category(), "posix_spawn_file_actions_addopen");

}

}

void ChildProcess::Options::pipe(int targetFd, bool childRead) {

if (pipes_.find(targetFd) != pipes_.end()) {

throw std::runtime_error("targetFd is already present in pipes map");

}

auto result = pipes_.emplace(std::make_pair(targetFd, make_unique<Pipe>()));

auto pipe = result.first->second.get();

dup2(childRead ? pipe->read.fd() : pipe->write.fd(), targetFd);

}

void ChildProcess::Options::pipeStdin() {

pipe(STDIN_FILENO, true);

}

void ChildProcess::Options::pipeStdout() {

pipe(STDOUT_FILENO, false);

}

void ChildProcess::Options::pipeStderr() {

pipe(STDERR_FILENO, false);

}

void ChildProcess::Options::chdir(w_string_piece path) {

cwd_ = std::string(path.data(), path.size());

#ifdef _WIN32

posix_spawnattr_setcwd_np(&inner_->attr, cwd_.c_str());

#endif

}

static std::vector<w_string_piece> json_args_to_string_vec(

}

ChildProcess::ChildProcess(const json_ref& args, Options&& options)

: ChildProcess(json_args_to_string_vec(args), std::move(options)) {}

ChildProcess::ChildProcess(std::vector<w_string_piece> args, Options&& options)

}

static std::mutex& getCwdMutex() {

// Meyers singleton

static std::mutex m;

return m;

}

std::unique_lock<std::mutex> ChildProcess::lockCwdMutex() {

return std::unique_lock<std::mutex>(getCwdMutex());

}

ChildProcess::~ChildProcess() {

if (!waited_) {

watchman::log(

watchman::FATAL,

"you must call ChildProcess.wait() before destroying a ChildProcess\n");

}

}

void ChildProcess::disown() {

waited_ = true;

}

bool ChildProcess::terminated() {

}

int ChildProcess::wait() {

}

void ChildProcess::kill(

#ifndef _WIN32

int signo

#endif

) {

#ifndef _WIN32

if (!waited_) {

::kill(pid_, signo);

}

#endif

}

Pipe& ChildProcess::pipe(int fd) {

return *pipes_.at(fd);

}

}