src/execute.cc


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// -*- c++ -*-
// Distributed under the BSD 2-Clause License.
// See accompanying file LICENSE for details.
#include "execute.h"

#include "ctor.h"
#include "pointerlist.h"

#include <unistd.h>
#include <cstring>
#include <sys/types.h>
#include <sys/wait.h>
#include <spawn.h>
#include <iostream>

/*
https://blog.famzah.net/2009/11/20/a-much-faster-popen-and-system-implementation-for-linux/
https://github.com/famzah/popen-noshell/commit/1f9eaf4eeef348d1efe0f3c7fe8ab670653cfbb1
https://blog.famzah.net/2018/12/19/posix_spawn-performance-benchmarks-and-usage-examples/
https://stackoverflow.com/questions/4259629/what-is-the-difference-between-fork-and-vfork/5207945#5207945
 */


namespace
{

int parent_waitpid(pid_t pid)
{
	int status{};

	auto rc_pid = waitpid(pid, &status, 0);

	if(rc_pid > 0)
	{
		if(WIFEXITED(status))
		{
			// Child exited with normally
			return WEXITSTATUS(status);
		}
		if(WIFSIGNALED(status))
		{
			// Child exited via signal (segfault, abort, ...)
			std::cerr << strsignal(status) << '\n';
			return WTERMSIG(status);
		}
	}
	else
	{ // No PID returned, this is an error
		if(errno == ECHILD)
		{
			// No children exist.
			return 1;
		}
		else
		{
			// Unexpected error.
			abort();
		}
	}

	// Should never happen...
	return 1;
}
} // namespace ::

extern char **environ; // see 'man environ'

int execute(const ctor::settings& settings,
            const std::string& command,
            const std::vector<std::string>& args,
            const std::map<std::string, std::string>& env,
            [[maybe_unused]] bool terminate)
{
	std::vector<const char*> argv;
	argv.push_back(command.data());
	for(const auto& arg : args)
	{
		argv.push_back(arg.data());
	}
	argv.push_back(nullptr);

	std::string cmd;
	for(const auto& arg : argv)
	{
		if(arg == nullptr)
		{
			break;
		}
		if(!cmd.empty())
		{
			cmd += " ";
		}
		cmd += arg;
	}

	if(settings.verbose > 0)
	{
		std::cout << cmd << std::endl;
	}

#if 1
	auto pid = vfork();
	if(pid == 0)
	{
		EnvMap envmap((const char**)environ);
		for(const auto& [key, value] : env)
		{
			envmap.insert(key + "=" + value);
		}
		if(settings.dry_run)
		{
			_exit(0);
		}
		auto [_, envv] = envmap.get();
		execve(command.data(), const_cast<char* const *>(argv.data()),
		       const_cast<char* const *>(envv));
		std::cout << "Could not execute " << command << ": " <<
			strerror(errno) << "\n";
		_exit(1); // execve only returns if an error occurred
	}
	return parent_waitpid(pid);
#elif 0
	pid_t pid;
	std::vector<std::string> venv;
	for(const auto& [key, value] : env)
	{
		venv.push_back(key + "=" + value);
	}
	Env penv(venv);
	if(posix_spawn(&pid, command.data(), nullptr, nullptr,
	               (char**)argv.data(), penv.data()))
	{
		return 1;
	}
	return parent_waitpid(pid);
#else
	(void)parent_waitpid;
	return system(cmd.data());
#endif

	return 1;
}