update ffmpeg.git files for newer versions
[goodguy/cinelerra.git] / cinelerra-5.1 / tools / makeappimagetool / process.cpp
1 // system headers
2 #include <algorithm>
3 #include <iostream>
4 #include <memory>
5 #include <sstream>
6 #include <stdexcept>
7 #include <utility>
8 #include <unistd.h>
9 #include <memory.h>
10 #include <wait.h>
11
12 // local headers
13 #include "includes/process.h"
14 #include "includes/subprocess.h"
15 #include "includes/assert.h"
16
17 // shorter than using namespace ...
18 using namespace linuxdeploy::subprocess;
19
20 int process::pid() const {
21     return child_pid_;
22 }
23
24 int process::stdout_fd() const {
25     return stdout_fd_;
26 }
27
28 int process::stderr_fd() const {
29     return stderr_fd_;
30 }
31
32 process::process(std::initializer_list<std::string> args, const subprocess_env_map_t& env)
33     : process(std::vector<std::string>(args), env) {}
34
35 process::process(const std::vector<std::string>& args, const subprocess_env_map_t& env) {
36     // preconditions
37     util::assert::assert_not_empty(args);
38
39     // pipes for both stdout and stderr
40     // the order is, as seen from the child: [read, write]
41     int stdout_pipe_fds[2];
42     int stderr_pipe_fds[2];
43
44     // FIXME: for debugging of #150
45     auto create_pipe = [](int fds[]) {
46         const auto rv = pipe(fds);
47
48         if (rv != 0) {
49             const auto error = errno;
50             throw std::logic_error("failed to create pipe: " + std::string(strerror(error)));
51         }
52     };
53
54     // create actual pipes
55     create_pipe(stdout_pipe_fds);
56     create_pipe(stderr_pipe_fds);
57
58     // create child process
59     child_pid_ = fork();
60
61     if (child_pid_ < 0) {
62         throw std::runtime_error{"fork() failed"};
63     }
64
65     if (child_pid_ == 0) {
66         // we're in the child process
67
68         // first step: close the read end of both pipes
69         close_pipe_fd_(stdout_pipe_fds[READ_END_]);
70         close_pipe_fd_(stderr_pipe_fds[READ_END_]);
71
72         auto connect_fd = [](int fd, int fileno) {
73             for (;;) {
74                 if (dup2(fd, fileno) == -1) {
75                     const auto error = errno;
76                     if (error != EINTR) {
77                         throw std::logic_error{"failed to connect pipes: " + std::string(strerror(error))};
78                     }
79                     continue;
80                 }
81
82                 break;
83             }
84         };
85
86         connect_fd(stdout_pipe_fds[WRITE_END_], STDOUT_FILENO);
87         connect_fd(stderr_pipe_fds[WRITE_END_], STDERR_FILENO);
88
89         // now, we also have to close the write end of both pipes
90         close_pipe_fd_(stdout_pipe_fds[WRITE_END_]);
91         close_pipe_fd_(stderr_pipe_fds[WRITE_END_]);
92
93         // prepare arguments for exec*
94         auto exec_args = make_args_vector_(args);
95         auto exec_env = make_env_vector_(env);
96
97         // call subprocess
98         execvpe(args.front().c_str(), exec_args.data(), exec_env.data());
99
100         // only reached if exec* fails
101
102         // clean up memory if exec should ever return
103         // prevents memleaks if the exception below would be handled by a caller
104         auto deleter = [](char* ptr) {
105             free(ptr);
106             ptr = nullptr;
107         };
108
109         std::for_each(exec_args.begin(), exec_args.end(), deleter);
110         std::for_each(exec_env.begin(), exec_env.end(), deleter);
111
112         throw std::runtime_error{"exec() failed: " + std::string(strerror(errno))};
113     }
114
115     // parent code
116
117     // we do not intend to write to the processes
118     close_pipe_fd_(stdout_pipe_fds[WRITE_END_]);
119     close_pipe_fd_(stderr_pipe_fds[WRITE_END_]);
120
121     // store file descriptors
122     stdout_fd_ = stdout_pipe_fds[READ_END_];
123     stderr_fd_ = stderr_pipe_fds[READ_END_];
124 }
125
126 int process::close() {
127     if (!exited_) {
128         close_pipe_fd_(stdout_fd_);
129         stdout_fd_ = -1;
130
131         close_pipe_fd_(stderr_fd_);
132         stderr_fd_ = -1;
133
134         {
135             int status;
136
137             if (waitpid(child_pid_, &status, 0) == -1) {
138                 throw std::logic_error{"waitpid() failed"};
139             }
140
141             exited_ = true;
142             exit_code_ = check_waitpid_status_(status);
143         }
144     }
145
146     return exit_code_;
147 }
148
149 process::~process() {
150     (void) close();
151 }
152
153 std::vector<char*> process::make_args_vector_(const std::vector<std::string>& args) {
154     std::vector<char*> rv{};
155     rv.reserve(args.size());
156
157     for (const auto& arg : args) {
158         rv.emplace_back(strdup(arg.c_str()));
159     }
160
161     // execv* want a nullptr-terminated array
162     rv.emplace_back(nullptr);
163
164     return rv;
165 }
166
167 std::vector<char*> process::make_env_vector_(const subprocess_env_map_t& env) {
168     std::vector<char*> rv;
169
170     // first, copy existing environment
171     // we cannot reserve space in the vector unfortunately, as we don't know the size of environ before the iteration
172     if (environ != nullptr) {
173         for (auto** current_env_var = environ; *current_env_var != nullptr; ++current_env_var) {
174             rv.emplace_back(strdup(*current_env_var));
175         }
176     }
177
178     // add own environment variables, overwriting existing ones if necessary
179     for (const auto& env_var : env) {
180         const auto& key = env_var.first;
181         const auto& value = env_var.second;
182
183         auto predicate = [&key](char* existing_env_var) {
184             char* equal_sign = strstr(existing_env_var, "=");
185
186             if (equal_sign == nullptr) {
187                 throw std::runtime_error{"no equal sign in environment variable"};
188             }
189
190             return strncmp(existing_env_var, key.c_str(), std::distance(equal_sign, existing_env_var)) == 0;
191         };
192
193         // delete existing env var, if any
194         rv.erase(std::remove_if(rv.begin(), rv.end(), predicate), rv.end());
195
196         // insert new value
197         std::ostringstream oss;
198         oss << key;
199         oss << "=";
200         oss << value;
201
202         rv.emplace_back(strdup(oss.str().c_str()));
203     }
204
205     // exec*e want a nullptr-terminated array
206     rv.emplace_back(nullptr);
207
208     return rv;
209 }
210
211 void process::kill(int signal) const {
212     if (::kill(child_pid_, signal) != 0) {
213         throw std::logic_error{"failed to kill child process"};
214     }
215
216     if (waitpid(child_pid_, nullptr, 0)) {
217         throw std::logic_error{"failed to wait for killed child"};
218     }
219 }
220
221 bool process::is_running() {
222     if (exited_) {
223         return false;
224     }
225
226     int status;
227     auto result = waitpid(child_pid_, &status, WNOHANG);
228
229     if (result == 0) {
230         return true;
231     }
232
233     if (result == child_pid_) {
234         // TODO: extract the following lines from both this method and close() to eliminate duplicate code
235         close_pipe_fd_(stdout_fd_);
236         stdout_fd_ = -1;
237
238         close_pipe_fd_(stderr_fd_);
239         stderr_fd_ = -1;
240
241         exited_ = true;
242         exit_code_ = check_waitpid_status_(status);
243
244         return false;
245     }
246
247     if (result < 0) {
248         // TODO: check errno == ECHILD
249         throw std::logic_error{"waitpid() failed: " + std::string(strerror(errno))};
250     }
251
252     // can only happen if waitpid() returns an unknown process ID
253     throw std::logic_error{"unknown error occured"};
254 }
255
256 int process::check_waitpid_status_(int status) {
257     if (WIFSIGNALED(status) != 0) {
258         // TODO: consider treating child exit caused by signals separately
259         return WTERMSIG(status);
260     } else if (WIFEXITED(status) != 0) {
261         return WEXITSTATUS(status);
262     }
263
264     throw std::logic_error{"unknown child process state"};
265 }
266
267 void process::close_pipe_fd_(int fd) {
268     const auto rv = ::close(fd);
269
270     if (rv != 0) {
271         const auto error = errno;
272         throw std::logic_error("failed to close pipe fd: " + std::string(strerror(error)));
273     }
274 }