// False on every non-POSIX build, and on POSIX when the child could not be

// spawned. "Could not spawn" and "ran and failed" must not share an exit

// code, so the caller falls back rather than reporting a failure.

bool supported = false;

int exit_code = 0;

bool timed_out = false;

if (WIFEXITED(status)) return WEXITSTATUS(status);

if (WIFSIGNALED(status)) return 128 + WTERMSIG(status);

return status;

unsigned long argvCount,

const char* const* envEntries,

unsigned long envCount,

const char* cwd,

long long deadlineMs,

OutputSink sink,

void* ctx)

{

DeadlineRun out;

if (deadlineMs <= 0 || argvCount == 0 || !argvEntries) return out;

// The child's environment: ours, minus anything overridden, plus the

// overrides. Names are case-SENSITIVE here (unlike the Windows peer).

std::vector<std::string> envStore;

{

std::vector<std::string_view> overridden;

overridden.reserve(envCount);

for (unsigned long i = 0; i < envCount; ++i) {

std::string_view e(envEntries[i]);

overridden.push_back(e.substr(0, e.find('=')));

}

for (char** p = current_environ(); p && *p; ++p) {

std::string_view e(*p);

auto name = e.substr(0, e.find('='));

if (std::ranges::find(overridden, name) != overridden.end()) continue;

envStore.emplace_back(e);

}

for (unsigned long i = 0; i < envCount; ++i)

envStore.emplace_back(envEntries[i]);

}

std::vector<char*> envp;

envp.reserve(envStore.size() + 1);

for (auto& s : envStore) envp.push_back(s.data());

envp.push_back(nullptr);

std::vector<char*> cargv;

cargv.reserve(argvCount + 1);

for (unsigned long i = 0; i < argvCount; ++i)

cargv.push_back(const_cast<char*>(argvEntries[i]));

cargv.push_back(nullptr);

const bool capture = (sink != nullptr);

int fds[2] = {-1, -1};

if (capture && ::pipe(fds) != 0) return out;

posix_spawn_file_actions_t fa;

::posix_spawn_file_actions_init(&fa);

// Same cwd contract as the untimed launcher: a bounded child must land in

// the same directory an unbounded one would, or adding a timeout would

// silently move where a build program's relative writes go.

if (cwd && *cwd)

::posix_spawn_file_actions_addchdir_np(&fa, cwd);

if (capture) {

::posix_spawn_file_actions_adddup2(&fa, fds[1], 1);

::posix_spawn_file_actions_adddup2(&fa, fds[1], 2);

::posix_spawn_file_actions_addclose(&fa, fds[0]);

::posix_spawn_file_actions_addclose(&fa, fds[1]);

}

// else: no file actions for stdio at all — the child inherits ours, which

// keeps its output live AND keeps it a terminal.

pid_t pid = 0;

int sp = ::posix_spawnp(&pid, cargv[0], &fa, nullptr, cargv.data(), envp.data());

::posix_spawn_file_actions_destroy(&fa);

if (capture) ::close(fds[1]);

if (sp != 0) { if (capture) ::close(fds[0]); return out; }

// Non-blocking reads so the deadline is still checked while the child is

// quiet. A blocking read on a silent, hung child is exactly the hang this

// whole mechanism exists to stop.

if (capture)

::fcntl(fds[0], F_SETFL, ::fcntl(fds[0], F_GETFL, 0) | O_NONBLOCK);

const auto until = std::chrono::steady_clock::now()

+ std::chrono::milliseconds(deadlineMs);

std::array<char, 4096> buf{};

bool killed = false;

int status = 0;

auto drain = [&]() -> bool {

if (!capture) return false;

ssize_t n;

bool any = false;

while ((n = ::read(fds[0], buf.data(), buf.size())) > 0) {

sink(ctx, buf.data(), static_cast<unsigned long>(n));

any = true;

}

return any;

};

for (;;) {

if (drain()) continue;

pid_t r = ::waitpid(pid, &status, WNOHANG);

if (r == pid) {

while (drain()) { /* tail — the child is gone, so this ends */ }

break;

}

if (r < 0 && errno != EINTR && errno != ECHILD) break;

if (!killed && std::chrono::steady_clock::now() >= until) {

::kill(pid, SIGKILL);

killed = true;

continue;

}

struct timespec ts{0, 20'000'000}; // 20ms

::nanosleep(&ts, nullptr);

}

if (capture) ::close(fds[0]);

out.exit_code = normalize_status(status);

out.timed_out = killed;

out.supported = true;

return out;

const char* const*, unsigned long,

const char*, long long, OutputSink, void*) {

// Not POSIX: mcpp.platform.windows.bounded_process owns this.

return {};