]> git.localhorst.tv Git - blank.git/blob - app/proc.cpp
new gcc version
[blank.git] / app / proc.cpp
1 #include "Process.hpp"
2
3 #include "error.hpp"
4
5 #ifdef _WIN32
6 #  include <tchar.h>
7 #  include <windows.h>
8 #else
9 #  include <fcntl.h>
10 #  include <signal.h>
11 #  include <unistd.h>
12 #  include <sys/wait.h>
13 #endif
14
15 #include <cstdio>
16 #include <stdexcept>
17
18 using namespace std;
19
20
21 namespace blank {
22
23 struct Process::Impl {
24
25         Impl(
26                 const string &path,
27                 const Arguments &args,
28                 char *const env[]);
29         ~Impl();
30
31         static Impl *EnvHelper(
32                 const string &path,
33                 const Arguments &args,
34                 const Environment &env);
35
36         size_t WriteIn(const void *buffer, size_t max_len);
37         void CloseIn();
38
39         size_t ReadOut(void *buffer, size_t max_len);
40         void CloseOut();
41
42         size_t ReadErr(void *buffer, size_t max_len);
43         void CloseErr();
44
45         void Terminate();
46         bool Terminated();
47         int Join();
48
49         bool joined;
50         int status;
51
52         bool in_closed;
53         bool out_closed;
54         bool err_closed;
55
56 #ifdef _WIN32
57         PROCESS_INFORMATION pi;
58         HANDLE fd_in[2];
59         HANDLE fd_out[2];
60         HANDLE fd_err[2];
61 #else
62         int pid;
63         int fd_in[2];
64         int fd_out[2];
65         int fd_err[2];
66 #endif
67
68 };
69
70
71 Process::Process(
72         const string &path,
73         const Arguments &args)
74 : impl(new Impl(path, args, nullptr)) {
75
76 }
77
78 Process::Process(
79         const string &path,
80         const Arguments &args,
81         const Environment &env)
82 : impl(Impl::EnvHelper(path, args, env)) {
83
84 }
85
86 Process::~Process() {
87         Join();
88 }
89
90
91 size_t Process::WriteIn(const void *buffer, size_t max_len) {
92         return impl->WriteIn(buffer, max_len);
93 }
94
95 void Process::CloseIn() {
96         impl->CloseIn();
97 }
98
99 size_t Process::ReadOut(void *buffer, size_t max_len) {
100         return impl->ReadOut(buffer, max_len);
101 }
102
103 void Process::CloseOut() {
104         impl->CloseOut();
105 }
106
107 size_t Process::ReadErr(void *buffer, size_t max_len) {
108         return impl->ReadErr(buffer, max_len);
109 }
110
111 void Process::CloseErr() {
112         impl->CloseErr();
113 }
114
115 void Process::Terminate() {
116         impl->Terminate();
117 }
118
119 bool Process::Terminated() {
120         return impl->Terminated();
121 }
122
123 int Process::Join() {
124         return impl->Join();
125 }
126
127 Process::Impl *Process::Impl::EnvHelper(
128         const string &path,
129         const Arguments &args,
130         const Environment &env
131 ) {
132         char *envp[env.size() + 1];
133         for (size_t i = 0; i < env.size(); ++i) {
134                 envp[i] = const_cast<char *>(env[i].c_str());
135         }
136         envp[env.size()] = nullptr;
137         return new Impl(path, args, envp);
138 }
139
140 Process::Impl::Impl(
141         const string &path_in,
142         const Arguments &args,
143         char *const envp[])
144 : joined(false)
145 , status(0)
146 , in_closed(false)
147 , out_closed(false)
148 , err_closed(false) {
149         const char *path = path_in.c_str();
150 #ifdef _WIN32
151         string cmdline;
152         for (const auto &arg : args) {
153                 cmdline += '"';
154                 cmdline += arg;
155                 cmdline += '"';
156         }
157
158         SECURITY_ATTRIBUTES sa;
159         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
160         sa.bInheritHandle = true;
161         sa.lpSecurityDescriptor = nullptr;
162         if (!CreatePipe(&fd_in[0], &fd_in[1], &sa, 0)) {
163                 throw runtime_error("failed to open pipe for child process' stdin");
164         }
165         if (!SetHandleInformation(fd_in[1], HANDLE_FLAG_INHERIT, 0)) {
166                 throw runtime_error("failed to stop child process from inheriting stdin write handle");
167         }
168         if (!CreatePipe(&fd_out[0], &fd_out[1], &sa, 0)) {
169                 throw runtime_error("failed to open pipe for child process' stdout");
170         }
171         if (!SetHandleInformation(fd_out[0], HANDLE_FLAG_INHERIT, 0)) {
172                 throw runtime_error("failed to stop child process from inheriting stdout read handle");
173         }
174         if (!CreatePipe(&fd_err[0], &fd_err[1], &sa, 0)) {
175                 throw runtime_error("failed to open pipe for child process' stderr");
176         }
177         if (!SetHandleInformation(fd_err[0], HANDLE_FLAG_INHERIT, 0)) {
178                 throw runtime_error("failed to stop child process from inheriting stderr read handle");
179         }
180
181         STARTUPINFO si;
182         ZeroMemory(&si, sizeof(STARTUPINFO));
183         si.cb = sizeof(STARTUPINFO);
184         si.hStdError = fd_err[1];
185         si.hStdOutput = fd_out[1];
186         si.hStdInput = fd_in[0];
187         si.dwFlags |= STARTF_USESTDHANDLES;
188         ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
189
190         if (!CreateProcess(
191                 path,
192                 cmdline.c_str(),
193                 nullptr,
194                 nullptr,
195                 true,
196                 0,
197                 envp,
198                 nullptr,
199                 &si,
200                 &pi
201         )) {
202                 throw runtime_error("CreateProcess");
203         }
204 #else
205         char *argv[args.size() + 1];
206         for (size_t i = 0; i < args.size(); ++i) {
207                 // I was promised exec won't modify my characters
208                 argv[i] = const_cast<char *>(args[i].c_str());
209         }
210         argv[args.size()] = nullptr;
211
212         if (pipe(fd_in) != 0) {
213                 throw SysError("failed to open pipe for child process' stdin");
214         }
215         if (pipe(fd_out) != 0) {
216                 throw SysError("failed to open pipe for child process' stdout");
217         }
218         if (pipe(fd_err) != 0) {
219                 throw SysError("failed to open pipe for child process' stderr");
220         }
221
222         pid = fork();
223         if (pid == -1) {
224                 throw SysError("fork");
225         } else if (pid == 0) {
226
227                 if (dup2(fd_in[0], STDIN_FILENO) == -1) {
228                         exit(EXIT_FAILURE);
229                 }
230                 if (dup2(fd_out[1], STDOUT_FILENO) == -1) {
231                         exit(EXIT_FAILURE);
232                 }
233                 if (dup2(fd_err[1], STDERR_FILENO) == -1) {
234                         exit(EXIT_FAILURE);
235                 }
236
237                 close(fd_in[0]);
238                 close(fd_in[1]);
239                 close(fd_out[0]);
240                 close(fd_out[1]);
241                 close(fd_err[0]);
242                 close(fd_err[1]);
243
244                 if (envp) {
245                         execve(path, argv, envp);
246                 } else {
247                         execv(path, argv);
248                 }
249                 // if execve returns, something bad happened
250                 exit(EXIT_FAILURE);
251
252         } else {
253
254                 close(fd_in[0]);
255                 close(fd_out[1]);
256                 close(fd_err[1]);
257
258         }
259 }
260 #endif
261
262 Process::Impl::~Impl() {
263         CloseIn();
264         CloseOut();
265         CloseErr();
266 }
267
268 size_t Process::Impl::WriteIn(const void *buffer, size_t max_len) {
269 #ifdef _WIN32
270         DWORD written;
271         if (!WriteFile(fd_in[1], buffer, max_len, &written, nullptr)) {
272                 throw runtime_error("failed to write to child process' input stream");
273         }
274         return written;
275 #else
276         int written = write(fd_in[1], buffer, max_len);
277         if (written < 0) {
278                 if (errno == EAGAIN) {
279                         return 0;
280                 } else {
281                         throw SysError("failed to write to child process' input stream");
282                 }
283         }
284         return written;
285 #endif
286 }
287
288 void Process::Impl::CloseIn() {
289         if (in_closed) {
290                 return;
291         }
292 #ifdef _WIN32
293         CloseHandle(fd_in[1]);
294 #else
295         close(fd_in[1]);
296 #endif
297         in_closed = true;
298 }
299
300 size_t Process::Impl::ReadOut(void *buffer, size_t max_len) {
301 #ifdef _WIN32
302         DWORD ret;
303         if (!ReadFile(fd_out[0], buffer, max_len, &ret, nullptr)) {
304                 throw runtime_error("failed to read from child process' output stream");
305         }
306         return ret;
307 #else
308         int ret = read(fd_out[0], buffer, max_len);
309         if (ret < 0) {
310                 if (errno == EAGAIN) {
311                         return 0;
312                 } else {
313                         throw SysError("failed to read from child process' output stream");
314                 }
315         }
316         return ret;
317 #endif
318 }
319
320 void Process::Impl::CloseOut() {
321         if (out_closed) {
322                 return;
323         }
324 #ifdef _WIN32
325         CloseHandle(fd_out[0]);
326 #else
327         close(fd_out[0]);
328 #endif
329         out_closed = true;
330 }
331
332 size_t Process::Impl::ReadErr(void *buffer, size_t max_len) {
333 #ifdef _WIN32
334         DWORD ret;
335         if (!ReadFile(fd_err[0], buffer, max_len, &ret, nullptr)) {
336                 throw runtime_error("failed to read from child process' error stream");
337         }
338         return ret;
339 #else
340         int ret = read(fd_err[0], buffer, max_len);
341         if (ret < 0) {
342                 if (errno == EAGAIN) {
343                         return 0;
344                 } else {
345                         throw SysError("failed to read from child process' error stream");
346                 }
347         }
348         return ret;
349 #endif
350 }
351
352 void Process::Impl::CloseErr() {
353         if (err_closed) {
354                 return;
355         }
356 #ifdef _WIN32
357         CloseHandle(fd_err[0]);
358 #else
359         close(fd_err[0]);
360 #endif
361         err_closed = true;
362 }
363
364 void Process::Impl::Terminate() {
365         if (joined) {
366                 // can only terminate once
367                 return;
368         }
369 #ifdef _WIN32
370         if (!TerminateProcess(pi.hProcess, -1)) {
371 #else
372         if (kill(pid, SIGTERM) == -1) {
373 #endif
374                 throw SysError("failed to terminate child process");
375         }
376 }
377
378 bool Process::Impl::Terminated() {
379         if (joined) {
380                 return true;
381         }
382 #ifdef _WIN32
383         DWORD exit_code;
384         GetExitCodeProcess(pi.hProcess, &exit_code);
385         if (exit_code == STILL_ACTIVE) {
386                 return false;
387         } else {
388                 CloseHandle(pi.hProcess);
389                 CloseHandle(pi.hThread);
390                 status = exit_code;
391                 joined = true;
392                 return true;
393         }
394 #else
395         int stat;
396         int result = waitpid(pid, &stat, WNOHANG);
397         if (result == -1) {
398                 throw SysError("error polling child process");
399         } else if (result == 0) {
400                 return false;
401         } else if (result == pid) {
402                 // child just exited, reap
403                 if (WIFEXITED(stat)) {
404                         // autonomous termination
405                         status = WEXITSTATUS(stat);
406                 } else if (WIFSIGNALED(stat)) {
407                         // signalled termination
408                         status = WTERMSIG(stat);
409                 }
410                 joined = true;
411                 return true;
412         } else {
413                 throw runtime_error("bogus return value of waitpid");
414         }
415 #endif
416 }
417
418 int Process::Impl::Join() {
419         if (joined) {
420                 // can only join once
421                 return status;
422         }
423 #ifdef _WIN32
424         DWORD exit_code;
425         WaitForSingleObject(pi.hProcess, INFINITE);
426         GetExitCodeProcess(pi.hProcess, &exit_code);
427         CloseHandle(pi.hProcess);
428         CloseHandle(pi.hThread);
429         status = exit_code;
430         joined = true;
431         return status;
432 #else
433         while (true) {
434                 int stat;
435                 int result = waitpid(pid, &stat, 0);
436                 if (result == -1) {
437                         throw SysError("error waiting on child process");
438                 }
439                 if (result != pid) {
440                         // should in theory only happen with WNOHANG set
441                         continue;
442                 }
443                 if (WIFEXITED(stat)) {
444                         // autonomous termination
445                         status = WEXITSTATUS(stat);
446                         joined = true;
447                         return status;
448                 }
449                 if (WIFSIGNALED(stat)) {
450                         // signalled termination
451                         status = WTERMSIG(stat);
452                         joined = true;
453                         return status;
454                 }
455                 // otherwise, child probably signalled stop/continue, which we
456                 // don't care about (please don't tell youth welfare), so try again
457         }
458 #endif
459 }
460
461 }