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

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

#include "ctor.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
{
class Env
	: public std::vector<char*>
{
public:
	Env(const std::vector<std::string>& args)
	{
		for(const auto& arg : args)
		{
			push_back(strdup(arg.data()));
		}
		push_back(nullptr);
	}

	~Env()
	{
		for(auto ptr : *this)
		{
			free(ptr);
		}
	}
};

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

	if(waitpid(pid, &status, 0) != pid)
	{
		return 1;
	}

	return WEXITSTATUS(status);
}
} // 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)
	{
		std::cout << cmd << std::endl;
	}

#if 1
	auto pid = vfork();
	if(pid == 0)
	{
		std::vector<std::string> venv;
		for(const auto& [key, value] : env)
		{
			venv.push_back(key + "=" + value);
		}

		for(auto current = environ; *current; ++current)
		{
			venv.emplace_back(*current);
		}

		Env penv(venv);
		execve(command.data(), (char**)argv.data(), penv.data());
		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;
}