0c7d76f1de89f3399b7eefd9d8a4616baa4d5d4f
[chaz/yoink] / src / stlplus / portability / subprocesses.cpp
1 ////////////////////////////////////////////////////////////////////////////////
2
3 // Author: Andy Rushton
4 // Copyright: (c) Southampton University 1999-2004
5 // (c) Andy Rushton 2004-2009
6 // License: BSD License, see ../docs/license.html
7
8 ////////////////////////////////////////////////////////////////////////////////
9
10 // Bug fix by Alistair Low: kill on Windows now kills grandchild processes as
11 // well as the child process. This is done using jobs - which has to be
12 // enabled by stating that the version of Windows is at least 5.0
13 #if defined(_WIN32) || defined(_WIN32_WCE)
14 #define _WIN32_WINNT 0x0500
15 #endif
16
17 #include "subprocesses.hpp"
18 #include "file_system.hpp"
19 #include "dprintf.hpp"
20 #include <ctype.h>
21 #include <string.h>
22 #include <stdlib.h>
23
24 #ifdef MSWINDOWS
25 #else
26 #include <signal.h>
27 #include <errno.h>
28 #include <sys/wait.h>
29 #include <unistd.h>
30 #include <fcntl.h>
31 #endif
32
33 ////////////////////////////////////////////////////////////////////////////////
34
35 namespace stlplus
36 {
37
38 ////////////////////////////////////////////////////////////////////////////////
39 // argument-vector related stuff
40
41 static void skip_white (const std::string& command, unsigned& i)
42 {
43 while(i < command.size() && isspace(command[i]))
44 i++;
45 }
46
47 // get_argument is the main function for breaking a string down into separate command arguments
48 // it mimics the way shells break down a command into an argv[] and unescapes the escaped characters on the way
49
50 static std::string get_argument (const std::string& command, unsigned& i)
51 {
52 std::string result;
53 #ifdef MSWINDOWS
54
55 // as far as I know, there is only double-quoting and no escape character in DOS
56 // so, how do you include a double-quote in an argument???
57
58 bool dquote = false;
59 for ( ; i < command.size(); i++)
60 {
61 char ch = command[i];
62 if (!dquote && isspace(ch)) break;
63 if (dquote)
64 {
65 if (ch == '\"')
66 dquote = false;
67 else
68 result += ch;
69 }
70 else if (ch == '\"')
71 dquote = true;
72 else
73 result += ch;
74 }
75 #else
76 bool squote = false;
77 bool dquote = false;
78 bool escaped = false;
79 for ( ; i < command.size(); i++)
80 {
81 char ch = command[i];
82 if (!squote && !dquote && !escaped && isspace(ch)) break;
83 if (escaped)
84 {
85 result += ch;
86 escaped = false;
87 }
88 else if (squote)
89 {
90 if (ch == '\'')
91 squote = false;
92 else
93 result += ch;
94 }
95 else if (ch == '\\')
96 escaped = true;
97 else if (dquote)
98 {
99 if (ch == '\"')
100 dquote = false;
101 else
102 result += ch;
103 }
104 else if (ch == '\'')
105 squote = true;
106 else if (ch == '\"')
107 dquote = true;
108 else
109 result += ch;
110 }
111 #endif
112
113 return result;
114 }
115
116
117 // this function performs the reverse of the above on a single argument
118 // it escapes special characters and quotes the argument if necessary ready for shell interpretation
119
120 static std::string make_argument (const std::string& arg)
121 {
122 std::string result;
123 bool needs_quotes = false;
124
125 for (unsigned i = 0; i < arg.size(); i++)
126 {
127 switch (arg[i])
128 {
129 // set of characters requiring escapes
130 #ifdef MSWINDOWS
131 #else
132 case '\\': case '\'': case '\"': case '`': case '(': case ')':
133 case '&': case '|': case '<': case '>': case '*': case '?': case '!':
134 result += '\\';
135 result += arg[i];
136 break;
137 #endif
138 // set of whitespace characters that force quoting
139 case ' ':
140 result += arg[i];
141 needs_quotes = true;
142 break;
143 default:
144 result += arg[i];
145 break;
146 }
147 }
148
149 if (needs_quotes)
150 {
151 result.insert(result.begin(), '"');
152 result += '"';
153 }
154 return result;
155 }
156
157 static char* copy_string (const char* str)
158 {
159 char* result = new char[strlen(str)+1];
160 strcpy(result,str);
161 return result;
162 }
163
164 ////////////////////////////////////////////////////////////////////////////////
165
166 arg_vector::arg_vector (void)
167 {
168 m_argv = 0;
169 }
170
171 arg_vector::arg_vector (const arg_vector& a)
172 {
173 m_argv = 0;
174 *this = a;
175 }
176
177 arg_vector::arg_vector (char** a)
178 {
179 m_argv = 0;
180 *this = a;
181 }
182
183 arg_vector::arg_vector (const std::string& command)
184 {
185 m_argv = 0;
186 *this = command;
187 }
188
189 arg_vector::arg_vector (const char* command)
190 {
191 m_argv = 0;
192 *this = command;
193 }
194
195 arg_vector::~arg_vector (void)
196 {
197 clear();
198 }
199
200 arg_vector& arg_vector::operator = (const arg_vector& a)
201 {
202 return *this = a.m_argv;
203 }
204
205 arg_vector& arg_vector::operator = (char** argv)
206 {
207 clear();
208 for (unsigned i = 0; argv[i]; i++)
209 operator += (argv[i]);
210 return *this;
211 }
212
213 arg_vector& arg_vector::operator = (const std::string& command)
214 {
215 clear();
216 for (unsigned i = 0; i < command.size(); )
217 {
218 std::string argument = get_argument(command, i);
219 operator += (argument);
220 skip_white(command, i);
221 }
222 return *this;
223 }
224
225 arg_vector& arg_vector::operator = (const char* command)
226 {
227 return operator = (std::string(command));
228 }
229
230 arg_vector& arg_vector::operator += (const std::string& str)
231 {
232 insert(size(), str);
233 return *this;
234 }
235
236 arg_vector& arg_vector::operator -= (const std::string& str)
237 {
238 insert(0, str);
239 return *this;
240 }
241
242 void arg_vector::insert (unsigned index, const std::string& str) throw(std::out_of_range)
243 {
244 if (index > size()) throw std::out_of_range("arg_vector::insert");
245 // copy up to but not including index, then add the new argument, then copy the rest
246 char** new_argv = new char*[size()+2];
247 unsigned i = 0;
248 for ( ; i < index; i++)
249 new_argv[i] = copy_string(m_argv[i]);
250 new_argv[index] = copy_string(str.c_str());
251 for ( ; i < size(); i++)
252 new_argv[i+1] = copy_string(m_argv[i]);
253 new_argv[i+1] = 0;
254 clear();
255 m_argv = new_argv;
256 }
257
258 void arg_vector::clear (unsigned index) throw(std::out_of_range)
259 {
260 if (index >= size()) throw std::out_of_range("arg_vector::clear");
261 // copy up to index, skip it, then copy the rest
262 char** new_argv = new char*[size()];
263 unsigned i = 0;
264 for ( ; i < index; i++)
265 new_argv[i] = copy_string(m_argv[i]);
266 i++;
267 for ( ; i < size(); i++)
268 new_argv[i-1] = copy_string(m_argv[i]);
269 new_argv[i-1] = 0;
270 clear();
271 m_argv = new_argv;
272 }
273
274 void arg_vector::clear(void)
275 {
276 if (m_argv)
277 {
278 for (unsigned i = 0; m_argv[i]; i++)
279 delete[] m_argv[i];
280 delete[] m_argv;
281 m_argv = 0;
282 }
283 }
284
285 unsigned arg_vector::size (void) const
286 {
287 unsigned i = 0;
288 if (m_argv)
289 while (m_argv[i])
290 i++;
291 return i;
292 }
293
294 arg_vector::operator char** (void) const
295 {
296 return m_argv;
297 }
298
299 char** arg_vector::argv (void) const
300 {
301 return m_argv;
302 }
303
304 char* arg_vector::operator [] (unsigned index) const throw(std::out_of_range)
305 {
306 if (index >= size()) throw std::out_of_range("arg_vector::operator[]");
307 return m_argv[index];
308 }
309
310 char* arg_vector::argv0 (void) const throw(std::out_of_range)
311 {
312 return operator [] (0);
313 }
314
315 std::string arg_vector::image (void) const
316 {
317 std::string result;
318 for (unsigned i = 0; i < size(); i++)
319 {
320 if (i) result += ' ';
321 result += make_argument(m_argv[i]);
322 }
323 return result;
324 }
325
326 ////////////////////////////////////////////////////////////////////////////////
327 // environment-vector
328
329 // Windoze environment is a single string containing null-terminated
330 // name=value strings and the whole terminated by a null
331
332 // Unix environment is a null-terminated vector of pointers to null-terminated strings
333
334 ////////////////////////////////////////////////////////////////////////////////
335 // platform specifics
336
337 #ifdef MSWINDOWS
338 // Windows utilities
339
340 // Windows environment variables are case-insensitive and I do comparisons by converting to lowercase
341 static std::string lowercase(const std::string& val)
342 {
343 std::string text = val;
344 for (unsigned i = 0; i < text.size(); i++)
345 text[i] = tolower(text[i]);
346 return text;
347 }
348
349 static unsigned envp_size(const char* envp)
350 {
351 unsigned size = 0;
352 while (envp[size] || (size > 0 && envp[size-1])) size++;
353 size++;
354 return size;
355 }
356
357 static void envp_extract(std::string& name, std::string& value, const char* envp, unsigned& envi)
358 {
359 name.erase();
360 value.erase();
361 if (!envp[envi]) return;
362 // some special variables start with '=' so ensure at least one character in the name
363 name += envp[envi++];
364 while(envp[envi] != '=')
365 name += envp[envi++];
366 envi++;
367 while(envp[envi])
368 value += envp[envi++];
369 envi++;
370 }
371
372 static void envp_append(const std::string& name, const std::string& value, char* envp, unsigned& envi)
373 {
374 for (unsigned i = 0; i < name.size(); i++)
375 envp[envi++] = name[i];
376 envp[envi++] = '=';
377 for (unsigned j = 0; j < value.size(); j++)
378 envp[envi++] = value[j];
379 envp[envi++] = '\0';
380 envp[envi] = '\0';
381 }
382
383 static char* envp_copy(const char* envp)
384 {
385 unsigned size = envp_size(envp);
386 char* result = new char[size];
387 result[0] = '\0';
388 unsigned i = 0;
389 unsigned j = 0;
390 while(envp[i])
391 {
392 std::string name;
393 std::string value;
394 envp_extract(name, value, envp, i);
395 envp_append(name, value, result, j);
396 }
397 return result;
398 }
399
400 static void envp_clear(char*& envp)
401 {
402 if (envp)
403 {
404 delete[] envp;
405 envp = 0;
406 }
407 }
408
409 static bool envp_equal(const std::string& left, const std::string& right)
410 {
411 return lowercase(left) == lowercase(right);
412 }
413
414 static bool envp_less(const std::string& left, const std::string& right)
415 {
416 return lowercase(left) < lowercase(right);
417 }
418
419 #else
420 // Unix utilities
421
422 extern char** environ;
423
424 static unsigned envp_size(char* const* envp)
425 {
426 unsigned size = 0;
427 while(envp[size]) size++;
428 size++;
429 return size;
430 }
431
432 static void envp_extract(std::string& name, std::string& value, char* const* envp, unsigned& envi)
433 {
434 name = "";
435 value = "";
436 if (!envp[envi]) return;
437 unsigned i = 0;
438 while(envp[envi][i] != '=')
439 name += envp[envi][i++];
440 i++;
441 while(envp[envi][i])
442 value += envp[envi][i++];
443 envi++;
444 }
445
446 static void envp_append(const std::string& name, const std::string& value, char** envp, unsigned& envi)
447 {
448 std::string entry = name + "=" + value;
449 envp[envi] = copy_string(entry.c_str());
450 envi++;
451 envp[envi] = 0;
452 }
453
454 static char** envp_copy(char* const* envp)
455 {
456 unsigned size = envp_size(envp);
457 char** result = new char*[size];
458 unsigned i = 0;
459 unsigned j = 0;
460 while(envp[i])
461 {
462 std::string name;
463 std::string value;
464 envp_extract(name, value, envp, i);
465 envp_append(name, value, result, j);
466 }
467 return result;
468 }
469
470 static void envp_clear(char**& envp)
471 {
472 if (envp)
473 {
474 for (unsigned i = 0; envp[i]; i++)
475 delete[] envp[i];
476 delete[] envp;
477 envp = 0;
478 }
479 }
480
481 static bool envp_equal(const std::string& left, const std::string& right)
482 {
483 return left == right;
484 }
485
486 static bool envp_less(const std::string& left, const std::string& right)
487 {
488 return left < right;
489 }
490
491 #endif
492 ////////////////////////////////////////////////////////////////////////////////
493
494 env_vector::env_vector(void)
495 {
496 #ifdef MSWINDOWS
497 char* env = (char*)GetEnvironmentStringsA();
498 m_env = envp_copy(env);
499 FreeEnvironmentStringsA(env);
500 #else
501 m_env = envp_copy(::environ);
502 #endif
503 }
504
505 env_vector::env_vector (const env_vector& a)
506 {
507 m_env = 0;
508 *this = a;
509 }
510
511 env_vector::~env_vector (void)
512 {
513 clear();
514 }
515
516 env_vector& env_vector::operator = (const env_vector& a)
517 {
518 clear();
519 m_env = envp_copy(a.m_env);
520 return *this;
521 }
522
523 void env_vector::clear(void)
524 {
525 envp_clear(m_env);
526 }
527
528 void env_vector::add(const std::string& name, const std::string& value)
529 {
530 // the trick is to add the value in alphabetic order
531 // this is done by copying the existing environment string to a new
532 // string, inserting the new value when a name greater than it is found
533 unsigned size = envp_size(m_env);
534 #ifdef MSWINDOWS
535 unsigned new_size = size + name.size() + value.size() + 2;
536 char* new_v = new char[new_size];
537 new_v[0] = '\0';
538 #else
539 unsigned new_size = size + 1;
540 char** new_v = new char*[new_size];
541 new_v[0] = 0;
542 #endif
543 // now extract each name=value pair and check the ordering
544 bool added = false;
545 unsigned i = 0;
546 unsigned j = 0;
547 while(m_env[i])
548 {
549 std::string current_name;
550 std::string current_value;
551 envp_extract(current_name, current_value, m_env, i);
552 if (envp_equal(name,current_name))
553 {
554 // replace an existing value
555 envp_append(name, value, new_v, j);
556 }
557 else if (!added && envp_less(name,current_name))
558 {
559 // add the new value first, then the existing one
560 envp_append(name, value, new_v, j);
561 envp_append(current_name, current_value, new_v, j);
562 added = true;
563 }
564 else
565 {
566 // just add the existing value
567 envp_append(current_name, current_value, new_v, j);
568 }
569 }
570 if (!added)
571 envp_append(name, value, new_v, j);
572 envp_clear(m_env);
573 m_env = new_v;
574 }
575
576
577 bool env_vector::remove (const std::string& name)
578 {
579 bool result = false;
580 // this is done by copying the existing environment string to a new string, but excluding the specified name
581 unsigned size = envp_size(m_env);
582 #ifdef MSWINDOWS
583 char* new_v = new char[size];
584 new_v[0] = '\0';
585 #else
586 char** new_v = new char*[size];
587 new_v[0] = 0;
588 #endif
589 unsigned i = 0;
590 unsigned j = 0;
591 while(m_env[i])
592 {
593 std::string current_name;
594 std::string current_value;
595 envp_extract(current_name, current_value, m_env, i);
596 if (envp_equal(name,current_name))
597 result = true;
598 else
599 envp_append(current_name, current_value, new_v, j);
600 }
601 envp_clear(m_env);
602 m_env = new_v;
603 return result;
604 }
605
606 std::string env_vector::operator [] (const std::string& name) const
607 {
608 return get(name);
609 }
610
611 std::string env_vector::get (const std::string& name) const
612 {
613 unsigned i = 0;
614 while(m_env[i])
615 {
616 std::string current_name;
617 std::string current_value;
618 envp_extract(current_name, current_value, m_env, i);
619 if (envp_equal(name,current_name))
620 return current_value;
621 }
622 return std::string();
623 }
624
625 unsigned env_vector::size (void) const
626 {
627 unsigned i = 0;
628 #ifdef MSWINDOWS
629 unsigned offset = 0;
630 while(m_env[offset])
631 {
632 std::string current_name;
633 std::string current_value;
634 envp_extract(current_name, current_value, m_env, offset);
635 i++;
636 }
637 #else
638 while(m_env[i])
639 i++;
640 #endif
641
642 return i;
643 }
644
645 std::pair<std::string,std::string> env_vector::operator [] (unsigned index) const throw(std::out_of_range)
646 {
647 return get(index);
648 }
649
650 std::pair<std::string,std::string> env_vector::get (unsigned index) const throw(std::out_of_range)
651 {
652 if (index >= size()) throw std::out_of_range("arg_vector::get");
653 unsigned j = 0;
654 for (unsigned i = 0; i < index; i++)
655 {
656 std::string current_name;
657 std::string current_value;
658 envp_extract(current_name, current_value, m_env, j);
659 }
660 std::string name;
661 std::string value;
662 envp_extract(name, value, m_env, j);
663 return std::make_pair(name,value);
664 }
665
666 ENVIRON_TYPE env_vector::envp (void) const
667 {
668 return m_env;
669 }
670
671 ////////////////////////////////////////////////////////////////////////////////
672 // Synchronous subprocess
673 // Win32 implementation mostly cribbed from MSDN examples and then made (much) more readable
674 // Unix implementation mostly from man pages and bitter experience
675 ////////////////////////////////////////////////////////////////////////////////
676
677 #ifdef MSWINDOWS
678
679 subprocess::subprocess(void)
680 {
681 m_pid.hProcess = 0;
682 m_job = 0;
683 m_child_in = 0;
684 m_child_out = 0;
685 m_child_err = 0;
686 m_err = 0;
687 m_status = 0;
688 }
689
690 #else
691
692 subprocess::subprocess(void)
693 {
694 m_pid = -1;
695 m_child_in = -1;
696 m_child_out = -1;
697 m_child_err = -1;
698 m_err = 0;
699 m_status = 0;
700 }
701
702 #endif
703
704 #ifdef MSWINDOWS
705
706 subprocess::~subprocess(void)
707 {
708 if (m_pid.hProcess != 0)
709 {
710 close_stdin();
711 close_stdout();
712 close_stderr();
713 kill();
714 WaitForSingleObject(m_pid.hProcess, INFINITE);
715 CloseHandle(m_pid.hThread);
716 CloseHandle(m_pid.hProcess);
717 CloseHandle(m_job);
718 }
719 }
720
721 #else
722
723 subprocess::~subprocess(void)
724 {
725 if (m_pid != -1)
726 {
727 close_stdin();
728 close_stdout();
729 close_stderr();
730 kill();
731 for (;;)
732 {
733 int wait_status = 0;
734 int wait_ret_val = waitpid(m_pid, &wait_status, 0);
735 if (wait_ret_val != -1 || errno != EINTR) break;
736 }
737 }
738 }
739
740 #endif
741
742 void subprocess::add_variable(const std::string& name, const std::string& value)
743 {
744 m_env.add(name, value);
745 }
746
747 bool subprocess::remove_variable(const std::string& name)
748 {
749 return m_env.remove(name);
750 }
751
752 #ifdef MSWINDOWS
753
754 bool subprocess::spawn(const std::string& path, const arg_vector& argv,
755 bool connect_stdin, bool connect_stdout, bool connect_stderr)
756 {
757 bool result = true;
758 // first create the pipes to be used to connect to the child stdin/out/err
759 // If no pipes requested, then connect to the parent stdin/out/err
760 // for some reason you have to create a pipe handle, then duplicate it
761 // This is not well explained in MSDN but seems to work
762 PIPE_TYPE parent_stdin = 0;
763 if (!connect_stdin)
764 parent_stdin = GetStdHandle(STD_INPUT_HANDLE);
765 else
766 {
767 PIPE_TYPE tmp = 0;
768 SECURITY_ATTRIBUTES inherit_handles = {sizeof(SECURITY_ATTRIBUTES), 0, TRUE};
769 CreatePipe(&parent_stdin, &tmp, &inherit_handles, 0);
770 DuplicateHandle(GetCurrentProcess(), tmp, GetCurrentProcess(), &m_child_in, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
771 }
772
773 PIPE_TYPE parent_stdout = 0;
774 if (!connect_stdout)
775 parent_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
776 else
777 {
778 PIPE_TYPE tmp = 0;
779 SECURITY_ATTRIBUTES inherit_handles = {sizeof(SECURITY_ATTRIBUTES), 0, TRUE};
780 CreatePipe(&tmp, &parent_stdout, &inherit_handles, 0);
781 DuplicateHandle(GetCurrentProcess(), tmp, GetCurrentProcess(), &m_child_out, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
782 }
783
784 PIPE_TYPE parent_stderr = 0;
785 if (!connect_stderr)
786 parent_stderr = GetStdHandle(STD_ERROR_HANDLE);
787 else
788 {
789 PIPE_TYPE tmp = 0;
790 SECURITY_ATTRIBUTES inherit_handles = {sizeof(SECURITY_ATTRIBUTES), 0, TRUE};
791 CreatePipe(&tmp, &parent_stderr, &inherit_handles, 0);
792 DuplicateHandle(GetCurrentProcess(), tmp, GetCurrentProcess(), &m_child_err, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
793 }
794
795 // Now create the subprocess
796 // The horrible trick of creating a console window and hiding it seems to be required for the pipes to work
797 // Note that the child will inherit a copy of the pipe handles
798 STARTUPINFOA startup = {sizeof(STARTUPINFO),0,0,0,0,0,0,0,0,0,0,
799 STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW,SW_HIDE,0,0,
800 parent_stdin,parent_stdout,parent_stderr};
801 bool created = CreateProcessA(path.c_str(),(char*)argv.image().c_str(),0,0,TRUE,CREATE_SUSPENDED,m_env.envp(),0,&startup,&m_pid) != 0;
802 // close the parent copy of the pipe handles so that the pipes will be closed when the child releases them
803 if (connect_stdin) CloseHandle(parent_stdin);
804 if (connect_stdout) CloseHandle(parent_stdout);
805 if (connect_stderr) CloseHandle(parent_stderr);
806 if (!created)
807 {
808 m_err = GetLastError();
809 close_stdin();
810 close_stdout();
811 close_stderr();
812 result = false;
813 }
814 else
815 {
816 m_job = CreateJobObject(NULL, NULL);
817 AssignProcessToJobObject(m_job, m_pid.hProcess);
818 ResumeThread(m_pid.hThread);
819
820 // The child process is now running so call the user's callback
821 // The convention is that the callback can return false, in which case this will kill the child (if its still running)
822 if (!callback())
823 {
824 result = false;
825 kill();
826 }
827 close_stdin();
828 close_stdout();
829 close_stderr();
830 // wait for the child to finish
831 // TODO - kill the child if a timeout happens
832 WaitForSingleObject(m_pid.hProcess, INFINITE);
833 DWORD exit_status = 0;
834 if (!GetExitCodeProcess(m_pid.hProcess, &exit_status))
835 {
836 m_err = GetLastError();
837 result = false;
838 }
839 else if (exit_status != 0)
840 result = false;
841 m_status = (int)exit_status;
842 CloseHandle(m_pid.hThread);
843 CloseHandle(m_pid.hProcess);
844 CloseHandle(m_job);
845 }
846 m_pid.hProcess = 0;
847 return result;
848 }
849
850 #else
851
852 bool subprocess::spawn(const std::string& path, const arg_vector& argv,
853 bool connect_stdin, bool connect_stdout, bool connect_stderr)
854 {
855 bool result = true;
856 // first create the pipes to be used to connect to the child stdin/out/err
857
858 int stdin_pipe [2] = {-1, -1};
859 if (connect_stdin)
860 pipe(stdin_pipe);
861
862 int stdout_pipe [2] = {-1, -1};
863 if (connect_stdout)
864 pipe(stdout_pipe);
865
866 int stderr_pipe [2] = {-1, -1};
867 if (connect_stderr)
868 pipe(stderr_pipe);
869
870 // now create the subprocess
871 // In Unix, this is done by forking (creating two copies of the parent), then overwriting the child copy using exec
872 m_pid = ::fork();
873 switch(m_pid)
874 {
875 case -1: // failed to fork
876 m_err = errno;
877 if (connect_stdin)
878 {
879 ::close(stdin_pipe[0]);
880 ::close(stdin_pipe[1]);
881 }
882 if (connect_stdout)
883 {
884 ::close(stdout_pipe[0]);
885 ::close(stdout_pipe[1]);
886 }
887 if (connect_stderr)
888 {
889 ::close(stderr_pipe[0]);
890 ::close(stderr_pipe[1]);
891 }
892 result = false;
893 break;
894 case 0: // in child;
895 {
896 // for each pipe, close the end of the duplicated pipe that is being used by the parent
897 // and connect the child's end of the pipe to the appropriate standard I/O device
898 if (connect_stdin)
899 {
900 ::close(stdin_pipe[1]);
901 dup2(stdin_pipe[0],STDIN_FILENO);
902 }
903 if (connect_stdout)
904 {
905 ::close(stdout_pipe[0]);
906 dup2(stdout_pipe[1],STDOUT_FILENO);
907 }
908 if (connect_stderr)
909 {
910 ::close(stderr_pipe[0]);
911 dup2(stderr_pipe[1],STDERR_FILENO);
912 }
913 execve(path.c_str(), argv.argv(), m_env.envp());
914 // will only ever get here if the exec() failed completely - *must* now exit the child process
915 // by using errno, the parent has some chance of diagnosing the cause of the problem
916 exit(errno);
917 }
918 break;
919 default: // in parent
920 {
921 // for each pipe, close the end of the duplicated pipe that is being used by the child
922 // and connect the parent's end of the pipe to the class members so that they are visible to the parent() callback
923 if (connect_stdin)
924 {
925 ::close(stdin_pipe[0]);
926 m_child_in = stdin_pipe[1];
927 }
928 if (connect_stdout)
929 {
930 ::close(stdout_pipe[1]);
931 m_child_out = stdout_pipe[0];
932 }
933 if (connect_stderr)
934 {
935 ::close(stderr_pipe[1]);
936 m_child_err = stderr_pipe[0];
937 }
938 // call the user's callback
939 if (!callback())
940 {
941 result = false;
942 kill();
943 }
944 // close the pipes and wait for the child to finish
945 // wait exits on a signal which may be the child signalling its exit or may be an interrupt
946 close_stdin();
947 close_stdout();
948 close_stderr();
949 int wait_status = 0;
950 for (;;)
951 {
952 int wait_ret_val = waitpid(m_pid, &wait_status, 0);
953 if (wait_ret_val != -1 || errno != EINTR) break;
954 }
955 // establish whether an error occurred
956 if (WIFSIGNALED(wait_status))
957 {
958 // set_error(errno);
959 m_status = WTERMSIG(wait_status);
960 result = false;
961 }
962 else if (WIFEXITED(wait_status))
963 {
964 m_status = WEXITSTATUS(wait_status);
965 if (m_status != 0)
966 result = false;
967 }
968 m_pid = -1;
969 }
970 break;
971 }
972 return result;
973 }
974
975 #endif
976
977 bool subprocess::spawn(const std::string& command_line,
978 bool connect_stdin, bool connect_stdout, bool connect_stderr)
979 {
980 arg_vector arguments = command_line;
981 if (arguments.size() == 0) return false;
982 std::string path = path_lookup(arguments.argv0());
983 if (path.empty()) return false;
984 return spawn(path, arguments, connect_stdin, connect_stdout, connect_stderr);
985 }
986
987 bool subprocess::callback(void)
988 {
989 return true;
990 }
991
992 #ifdef MSWINDOWS
993
994 bool subprocess::kill (void)
995 {
996 if (!m_pid.hProcess) return false;
997 close_stdin();
998 close_stdout();
999 close_stderr();
1000 if (!TerminateJobObject(m_job, (UINT)-1))
1001 {
1002 m_err = GetLastError();
1003 return false;
1004 }
1005 return true;
1006 }
1007
1008 #else
1009
1010 bool subprocess::kill (void)
1011 {
1012 if (m_pid == -1) return false;
1013 close_stdin();
1014 close_stdout();
1015 close_stderr();
1016 if (::kill(m_pid, SIGINT) == -1)
1017 {
1018 m_err = errno;
1019 return false;
1020 }
1021 return true;
1022 }
1023
1024 #endif
1025
1026 #ifdef MSWINDOWS
1027
1028 int subprocess::write_stdin (std::string& buffer)
1029 {
1030 if (m_child_in == 0) return -1;
1031 // do a blocking write of the whole buffer
1032 DWORD bytes = 0;
1033 if (!WriteFile(m_child_in, buffer.c_str(), (DWORD)buffer.size(), &bytes, 0))
1034 {
1035 m_err = GetLastError();
1036 close_stdin();
1037 return -1;
1038 }
1039 // now discard that part of the buffer that was written
1040 if (bytes > 0)
1041 buffer.erase(0, bytes);
1042 return bytes;
1043 }
1044
1045 #else
1046
1047 int subprocess::write_stdin (std::string& buffer)
1048 {
1049 if (m_child_in == -1) return -1;
1050 // do a blocking write of the whole buffer
1051 int bytes = write(m_child_in, buffer.c_str(), buffer.size());
1052 if (bytes == -1)
1053 {
1054 m_err = errno;
1055 close_stdin();
1056 return -1;
1057 }
1058 // now discard that part of the buffer that was written
1059 if (bytes > 0)
1060 buffer.erase(0, bytes);
1061 return bytes;
1062 }
1063
1064 #endif
1065
1066 #ifdef MSWINDOWS
1067
1068 int subprocess::read_stdout (std::string& buffer)
1069 {
1070 if (m_child_out == 0) return -1;
1071 DWORD bytes = 0;
1072 DWORD buffer_size = 256;
1073 char* tmp = new char[buffer_size];
1074 if (!ReadFile(m_child_out, tmp, buffer_size, &bytes, 0))
1075 {
1076 if (GetLastError() != ERROR_BROKEN_PIPE)
1077 m_err = GetLastError();
1078 close_stdout();
1079 delete[] tmp;
1080 return -1;
1081 }
1082 if (bytes == 0)
1083 {
1084 // EOF
1085 close_stdout();
1086 delete[] tmp;
1087 return -1;
1088 }
1089 buffer.append(tmp, bytes);
1090 delete[] tmp;
1091 return (int)bytes;
1092 }
1093
1094 #else
1095
1096 int subprocess::read_stdout (std::string& buffer)
1097 {
1098 if (m_child_out == -1) return -1;
1099 int buffer_size = 256;
1100 char* tmp = new char[buffer_size];
1101 int bytes = read(m_child_out, tmp, buffer_size);
1102 if (bytes == -1)
1103 {
1104 m_err = errno;
1105 close_stdout();
1106 delete[] tmp;
1107 return -1;
1108 }
1109 if (bytes == 0)
1110 {
1111 // EOF
1112 close_stdout();
1113 delete[] tmp;
1114 return -1;
1115 }
1116 buffer.append(tmp, bytes);
1117 delete[] tmp;
1118 return bytes;
1119 }
1120
1121 #endif
1122
1123 #ifdef MSWINDOWS
1124
1125 int subprocess::read_stderr(std::string& buffer)
1126 {
1127 if (m_child_err == 0) return -1;
1128 DWORD bytes = 0;
1129 DWORD buffer_size = 256;
1130 char* tmp = new char[buffer_size];
1131 if (!ReadFile(m_child_err, tmp, buffer_size, &bytes, 0))
1132 {
1133 if (GetLastError() != ERROR_BROKEN_PIPE)
1134 m_err = GetLastError();
1135 close_stderr();
1136 delete[] tmp;
1137 return -1;
1138 }
1139 if (bytes == 0)
1140 {
1141 // EOF
1142 close_stderr();
1143 delete[] tmp;
1144 return -1;
1145 }
1146 buffer.append(tmp, bytes);
1147 delete[] tmp;
1148 return (int)bytes;
1149 }
1150
1151 #else
1152
1153 int subprocess::read_stderr (std::string& buffer)
1154 {
1155 if (m_child_err == -1) return -1;
1156 int buffer_size = 256;
1157 char* tmp = new char[buffer_size];
1158 int bytes = read(m_child_err, tmp, buffer_size);
1159 if (bytes == -1)
1160 {
1161 m_err = errno;
1162 close_stderr();
1163 delete[] tmp;
1164 return -1;
1165 }
1166 if (bytes == 0)
1167 {
1168 // EOF
1169 close_stderr();
1170 delete[] tmp;
1171 return -1;
1172 }
1173 buffer.append(tmp, bytes);
1174 delete[] tmp;
1175 return bytes;
1176 }
1177
1178 #endif
1179
1180 #ifdef MSWINDOWS
1181
1182 void subprocess::close_stdin (void)
1183 {
1184 if (m_child_in)
1185 {
1186 CloseHandle(m_child_in);
1187 m_child_in = 0;
1188 }
1189 }
1190
1191 #else
1192
1193 void subprocess::close_stdin (void)
1194 {
1195 if (m_child_in != -1)
1196 {
1197 ::close(m_child_in);
1198 m_child_in = -1;
1199 }
1200 }
1201
1202 #endif
1203
1204 #ifdef MSWINDOWS
1205
1206 void subprocess::close_stdout (void)
1207 {
1208 if (m_child_out)
1209 {
1210 CloseHandle(m_child_out);
1211 m_child_out = 0;
1212 }
1213 }
1214
1215 #else
1216
1217 void subprocess::close_stdout (void)
1218 {
1219 if (m_child_out != -1)
1220 {
1221 ::close(m_child_out);
1222 m_child_out = -1;
1223 }
1224 }
1225
1226 #endif
1227
1228 #ifdef MSWINDOWS
1229
1230 void subprocess::close_stderr (void)
1231 {
1232 if (m_child_err)
1233 {
1234 CloseHandle(m_child_err);
1235 m_child_err = 0;
1236 }
1237 }
1238
1239 #else
1240
1241 void subprocess::close_stderr (void)
1242 {
1243 if (m_child_err != -1)
1244 {
1245 ::close(m_child_err);
1246 m_child_err = -1;
1247 }
1248 }
1249
1250 #endif
1251
1252 bool subprocess::error(void) const
1253 {
1254 return m_err != 0;
1255 }
1256
1257 int subprocess::error_number(void) const
1258 {
1259 return m_err;
1260 }
1261
1262 #ifdef MSWINDOWS
1263
1264 std::string subprocess::error_text(void) const
1265 {
1266 if (m_err == 0) return std::string();
1267 char* message;
1268 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1269 0,
1270 m_err,
1271 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1272 (LPTSTR)&message,
1273 0,0);
1274 std::string result = message;
1275 LocalFree(message);
1276 // the error message is for some perverse reason newline terminated - remove this
1277 if (result[result.size()-1] == '\n')
1278 result.erase(result.end()-1);
1279 if (result[result.size()-1] == '\r')
1280 result.erase(result.end()-1);
1281 return result;
1282 }
1283
1284 #else
1285
1286 std::string subprocess::error_text(void) const
1287 {
1288 if (m_err == 0) return std::string();
1289 char* text = strerror(m_err);
1290 if (text) return std::string(text);
1291 return "error number " + dformat("%d",m_err);
1292 }
1293
1294 #endif
1295
1296 int subprocess::exit_status(void) const
1297 {
1298 return m_status;
1299 }
1300
1301 ////////////////////////////////////////////////////////////////////////////////
1302 // backtick subprocess and operations
1303
1304 backtick_subprocess::backtick_subprocess(void) : subprocess()
1305 {
1306 }
1307
1308 bool backtick_subprocess::callback(void)
1309 {
1310 for (;;)
1311 {
1312 std::string buffer;
1313 int read_size = read_stdout(buffer);
1314 if (read_size < 0) break;
1315 m_text += buffer;
1316 }
1317 return !error();
1318 }
1319
1320 bool backtick_subprocess::spawn(const std::string& path, const arg_vector& argv)
1321 {
1322 return subprocess::spawn(path, argv, false, true, false);
1323 }
1324
1325 bool backtick_subprocess::spawn(const std::string& command_line)
1326 {
1327 return subprocess::spawn(command_line, false, true, false);
1328 }
1329
1330 std::vector<std::string> backtick_subprocess::text(void) const
1331 {
1332 std::vector<std::string> result;
1333 // convert the raw text into a vector of strings, each corresponding to a line
1334 // in the process, strip out platform-specific line-endings
1335 for (unsigned i = 0; i < m_text.size(); i++)
1336 {
1337 // handle any kind of line-ending - Dos, Unix or MacOS
1338 switch(m_text[i])
1339 {
1340 case '\xd': // carriage-return - optionally followed by linefeed
1341 {
1342 // discard optional following linefeed
1343 if ((i+1 < m_text.size()) && (m_text[i+1] == '\xa'))
1344 i++;
1345 // add a new line to the end of the vector
1346 result.push_back(std::string());
1347 break;
1348 }
1349 case '\xa': // linefeed
1350 {
1351 // add a new line to the end of the vector
1352 result.push_back(std::string());
1353 break;
1354 }
1355 default:
1356 {
1357 result.back() += m_text[i];
1358 break;
1359 }
1360 }
1361 }
1362 // tidy up - if the last line ended with a newline, the vector will end with an empty string - discard this
1363 if ((result.size()) > 0 && result.back().empty())
1364 result.erase(result.end()-1);
1365 return result;
1366 }
1367
1368 std::vector<std::string> backtick(const std::string& path, const arg_vector& argv)
1369 {
1370 backtick_subprocess sub;
1371 sub.spawn(path, argv);
1372 return sub.text();
1373 }
1374
1375 std::vector<std::string> backtick(const std::string& command_line)
1376 {
1377 backtick_subprocess sub;
1378 sub.spawn(command_line);
1379 return sub.text();
1380 }
1381
1382 ////////////////////////////////////////////////////////////////////////////////
1383 // Asynchronous subprocess
1384
1385 #ifdef MSWINDOWS
1386
1387 async_subprocess::async_subprocess(void)
1388 {
1389 m_pid.hProcess = 0;
1390 m_job = 0;
1391 m_child_in = 0;
1392 m_child_out = 0;
1393 m_child_err = 0;
1394 m_err = 0;
1395 m_status = 0;
1396 }
1397
1398 #else
1399
1400 async_subprocess::async_subprocess(void)
1401 {
1402 m_pid = -1;
1403 m_child_in = -1;
1404 m_child_out = -1;
1405 m_child_err = -1;
1406 m_err = 0;
1407 m_status = 0;
1408 }
1409
1410 #endif
1411
1412 #ifdef MSWINDOWS
1413
1414 async_subprocess::~async_subprocess(void)
1415 {
1416 if (m_pid.hProcess != 0)
1417 {
1418 close_stdin();
1419 close_stdout();
1420 close_stderr();
1421 kill();
1422 WaitForSingleObject(m_pid.hProcess, INFINITE);
1423 CloseHandle(m_pid.hThread);
1424 CloseHandle(m_pid.hProcess);
1425 CloseHandle(m_job);
1426 }
1427 }
1428
1429 #else
1430
1431 async_subprocess::~async_subprocess(void)
1432 {
1433 if (m_pid != -1)
1434 {
1435 close_stdin();
1436 close_stdout();
1437 close_stderr();
1438 kill();
1439 for (;;)
1440 {
1441 int wait_status = 0;
1442 int wait_ret_val = waitpid(m_pid, &wait_status, 0);
1443 if (wait_ret_val != -1 || errno != EINTR) break;
1444 }
1445 }
1446 }
1447
1448 #endif
1449
1450 void async_subprocess::set_error(int e)
1451 {
1452 m_err = e;
1453 }
1454
1455 void async_subprocess::add_variable(const std::string& name, const std::string& value)
1456 {
1457 m_env.add(name, value);
1458 }
1459
1460 bool async_subprocess::remove_variable(const std::string& name)
1461 {
1462 return m_env.remove(name);
1463 }
1464
1465 #ifdef MSWINDOWS
1466
1467 bool async_subprocess::spawn(const std::string& path, const arg_vector& argv,
1468 bool connect_stdin, bool connect_stdout, bool connect_stderr)
1469 {
1470 bool result = true;
1471 // first create the pipes to be used to connect to the child stdin/out/err
1472 // If no pipes requested, then connect to the parent stdin/out/err
1473 // for some reason you have to create a pipe handle, then duplicate it
1474 // This is not well explained in MSDN but seems to work
1475 PIPE_TYPE parent_stdin = 0;
1476 if (!connect_stdin)
1477 parent_stdin = GetStdHandle(STD_INPUT_HANDLE);
1478 else
1479 {
1480 PIPE_TYPE tmp = 0;
1481 SECURITY_ATTRIBUTES inherit_handles = {sizeof(SECURITY_ATTRIBUTES), 0, TRUE};
1482 CreatePipe(&parent_stdin, &tmp, &inherit_handles, 0);
1483 DuplicateHandle(GetCurrentProcess(), tmp, GetCurrentProcess(), &m_child_in, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
1484 }
1485
1486 PIPE_TYPE parent_stdout = 0;
1487 if (!connect_stdout)
1488 parent_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
1489 else
1490 {
1491 PIPE_TYPE tmp = 0;
1492 SECURITY_ATTRIBUTES inherit_handles = {sizeof(SECURITY_ATTRIBUTES), 0, TRUE};
1493 CreatePipe(&tmp, &parent_stdout, &inherit_handles, 0);
1494 DuplicateHandle(GetCurrentProcess(), tmp, GetCurrentProcess(), &m_child_out, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
1495 }
1496
1497 PIPE_TYPE parent_stderr = 0;
1498 if (!connect_stderr)
1499 parent_stderr = GetStdHandle(STD_ERROR_HANDLE);
1500 else
1501 {
1502 PIPE_TYPE tmp = 0;
1503 SECURITY_ATTRIBUTES inherit_handles = {sizeof(SECURITY_ATTRIBUTES), 0, TRUE};
1504 CreatePipe(&tmp, &parent_stderr, &inherit_handles, 0);
1505 DuplicateHandle(GetCurrentProcess(), tmp, GetCurrentProcess(), &m_child_err, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
1506 }
1507
1508 // Now create the subprocess
1509 // The horrible trick of creating a console window and hiding it seems to be required for the pipes to work
1510 // Note that the child will inherit a copy of the pipe handles
1511 STARTUPINFOA startup = {sizeof(STARTUPINFO),0,0,0,0,0,0,0,0,0,0,
1512 STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW,SW_HIDE,0,0,
1513 parent_stdin,parent_stdout,parent_stderr};
1514 bool created = CreateProcessA(path.c_str(),(char*)argv.image().c_str(),0,0,TRUE,CREATE_SUSPENDED,m_env.envp(),0,&startup,&m_pid) != 0;
1515 // close the parent copy of the pipe handles so that the pipes will be closed when the child releases them
1516 if (connect_stdin) CloseHandle(parent_stdin);
1517 if (connect_stdout) CloseHandle(parent_stdout);
1518 if (connect_stderr) CloseHandle(parent_stderr);
1519 if (!created)
1520 {
1521 set_error(GetLastError());
1522 close_stdin();
1523 close_stdout();
1524 close_stderr();
1525 result = false;
1526 }
1527 else
1528 {
1529 m_job = CreateJobObject(NULL, NULL);
1530 AssignProcessToJobObject(m_job, m_pid.hProcess);
1531 ResumeThread(m_pid.hThread);
1532 }
1533 return result;
1534 }
1535
1536 #else
1537
1538 bool async_subprocess::spawn(const std::string& path, const arg_vector& argv,
1539 bool connect_stdin, bool connect_stdout, bool connect_stderr)
1540 {
1541 bool result = true;
1542 // first create the pipes to be used to connect to the child stdin/out/err
1543
1544 int stdin_pipe [2] = {-1, -1};
1545 if (connect_stdin)
1546 pipe(stdin_pipe);
1547
1548 int stdout_pipe [2] = {-1, -1};
1549 if (connect_stdout)
1550 pipe(stdout_pipe);
1551
1552 int stderr_pipe [2] = {-1, -1};
1553 if (connect_stderr)
1554 pipe(stderr_pipe);
1555
1556 // now create the subprocess
1557 // In Unix, this is done by forking (creating two copies of the parent), then overwriting the child copy using exec
1558 m_pid = ::fork();
1559 switch(m_pid)
1560 {
1561 case -1: // failed to fork
1562 set_error(errno);
1563 if (connect_stdin)
1564 {
1565 ::close(stdin_pipe[0]);
1566 ::close(stdin_pipe[1]);
1567 }
1568 if (connect_stdout)
1569 {
1570 ::close(stdout_pipe[0]);
1571 ::close(stdout_pipe[1]);
1572 }
1573 if (connect_stderr)
1574 {
1575 ::close(stderr_pipe[0]);
1576 ::close(stderr_pipe[1]);
1577 }
1578 result = false;
1579 break;
1580 case 0: // in child;
1581 {
1582 // for each pipe, close the end of the duplicated pipe that is being used by the parent
1583 // and connect the child's end of the pipe to the appropriate standard I/O device
1584 if (connect_stdin)
1585 {
1586 ::close(stdin_pipe[1]);
1587 dup2(stdin_pipe[0],STDIN_FILENO);
1588 }
1589 if (connect_stdout)
1590 {
1591 ::close(stdout_pipe[0]);
1592 dup2(stdout_pipe[1],STDOUT_FILENO);
1593 }
1594 if (connect_stderr)
1595 {
1596 ::close(stderr_pipe[0]);
1597 dup2(stderr_pipe[1],STDERR_FILENO);
1598 }
1599 execve(path.c_str(), argv.argv(), m_env.envp());
1600 // will only ever get here if the exec() failed completely - *must* now exit the child process
1601 // by using errno, the parent has some chance of diagnosing the cause of the problem
1602 exit(errno);
1603 }
1604 break;
1605 default: // in parent
1606 {
1607 // for each pipe, close the end of the duplicated pipe that is being used by the child
1608 // and connect the parent's end of the pipe to the class members so that they are visible to the parent() callback
1609 if (connect_stdin)
1610 {
1611 ::close(stdin_pipe[0]);
1612 m_child_in = stdin_pipe[1];
1613 if (fcntl(m_child_in, F_SETFL, O_NONBLOCK) == -1)
1614 {
1615 set_error(errno);
1616 result = false;
1617 }
1618 }
1619 if (connect_stdout)
1620 {
1621 ::close(stdout_pipe[1]);
1622 m_child_out = stdout_pipe[0];
1623 if (fcntl(m_child_out, F_SETFL, O_NONBLOCK) == -1)
1624 {
1625 set_error(errno);
1626 result = false;
1627 }
1628 }
1629 if (connect_stderr)
1630 {
1631 ::close(stderr_pipe[1]);
1632 m_child_err = stderr_pipe[0];
1633 if (fcntl(m_child_err, F_SETFL, O_NONBLOCK) == -1)
1634 {
1635 set_error(errno);
1636 result = false;
1637 }
1638 }
1639 }
1640 break;
1641 }
1642 return result;
1643 }
1644
1645 #endif
1646
1647 bool async_subprocess::spawn(const std::string& command_line,
1648 bool connect_stdin, bool connect_stdout, bool connect_stderr)
1649 {
1650 arg_vector arguments = command_line;
1651 if (arguments.size() == 0) return false;
1652 std::string path = path_lookup(arguments.argv0());
1653 if (path.empty()) return false;
1654 return spawn(path, arguments, connect_stdin, connect_stdout, connect_stderr);
1655 }
1656
1657 bool async_subprocess::callback(void)
1658 {
1659 return true;
1660 }
1661
1662 #ifdef MSWINDOWS
1663
1664 bool async_subprocess::tick(void)
1665 {
1666 bool result = true;
1667 if (!callback())
1668 kill();
1669 DWORD exit_status = 0;
1670 if (!GetExitCodeProcess(m_pid.hProcess, &exit_status))
1671 {
1672 set_error(GetLastError());
1673 result = false;
1674 }
1675 else if (exit_status != STILL_ACTIVE)
1676 {
1677 CloseHandle(m_pid.hThread);
1678 CloseHandle(m_pid.hProcess);
1679 CloseHandle(m_job);
1680 m_pid.hProcess = 0;
1681 result = false;
1682 }
1683 m_status = (int)exit_status;
1684 return result;
1685 }
1686
1687 #else
1688
1689 bool async_subprocess::tick(void)
1690 {
1691 bool result = true;
1692 if (!callback())
1693 kill();
1694 int wait_status = 0;
1695 int wait_ret_val = waitpid(m_pid, &wait_status, WNOHANG);
1696 if (wait_ret_val == -1 && errno != EINTR)
1697 {
1698 set_error(errno);
1699 result = false;
1700 }
1701 else if (wait_ret_val != 0)
1702 {
1703 // the only states that indicate a terminated child are WIFSIGNALLED and WIFEXITED
1704 if (WIFSIGNALED(wait_status))
1705 {
1706 // set_error(errno);
1707 m_status = WTERMSIG(wait_status);
1708 result = false;
1709 }
1710 else if (WIFEXITED(wait_status))
1711 {
1712 // child has exited
1713 m_status = WEXITSTATUS(wait_status);
1714 result = false;
1715 }
1716 }
1717 if (!result)
1718 m_pid = -1;
1719 return result;
1720 }
1721
1722 #endif
1723
1724 #ifdef MSWINDOWS
1725
1726 bool async_subprocess::kill(void)
1727 {
1728 if (!m_pid.hProcess) return false;
1729 close_stdin();
1730 close_stdout();
1731 close_stderr();
1732 if (!TerminateJobObject(m_job, (UINT)-1))
1733 {
1734 set_error(GetLastError());
1735 return false;
1736 }
1737 return true;
1738 }
1739
1740 #else
1741
1742 bool async_subprocess::kill(void)
1743 {
1744 if (m_pid == -1) return false;
1745 close_stdin();
1746 close_stdout();
1747 close_stderr();
1748 if (::kill(m_pid, SIGINT) == -1)
1749 {
1750 set_error(errno);
1751 return false;
1752 }
1753 return true;
1754 }
1755
1756 #endif
1757
1758 #ifdef MSWINDOWS
1759
1760 int async_subprocess::write_stdin (std::string& buffer)
1761 {
1762 if (m_child_in == 0) return -1;
1763 // there doesn't seem to be a way of doing non-blocking writes under Windoze
1764 DWORD bytes = 0;
1765 if (!WriteFile(m_child_in, buffer.c_str(), (DWORD)buffer.size(), &bytes, 0))
1766 {
1767 set_error(GetLastError());
1768 close_stdin();
1769 return -1;
1770 }
1771 // now discard that part of the buffer that was written
1772 if (bytes > 0)
1773 buffer.erase(0, bytes);
1774 return (int)bytes;
1775 }
1776
1777 #else
1778
1779 int async_subprocess::write_stdin (std::string& buffer)
1780 {
1781 if (m_child_in == -1) return -1;
1782 // relies on the pipe being non-blocking
1783 // This does block under Windoze
1784 int bytes = write(m_child_in, buffer.c_str(), buffer.size());
1785 if (bytes == -1 && errno == EAGAIN)
1786 {
1787 // not ready
1788 return 0;
1789 }
1790 if (bytes == -1)
1791 {
1792 // error on write - close the pipe and give up
1793 set_error(errno);
1794 close_stdin();
1795 return -1;
1796 }
1797 // successful write
1798 // now discard that part of the buffer that was written
1799 if (bytes > 0)
1800 buffer.erase(0, bytes);
1801 return bytes;
1802 }
1803
1804 #endif
1805
1806 #ifdef MSWINDOWS
1807
1808 int async_subprocess::read_stdout (std::string& buffer)
1809 {
1810 if (m_child_out == 0) return -1;
1811 // peek at the buffer to see how much data there is in the first place
1812 DWORD buffer_size = 0;
1813 if (!PeekNamedPipe(m_child_out, 0, 0, 0, &buffer_size, 0))
1814 {
1815 if (GetLastError() != ERROR_BROKEN_PIPE)
1816 set_error(GetLastError());
1817 close_stdout();
1818 return -1;
1819 }
1820 if (buffer_size == 0) return 0;
1821 DWORD bytes = 0;
1822 char* tmp = new char[buffer_size];
1823 if (!ReadFile(m_child_out, tmp, buffer_size, &bytes, 0))
1824 {
1825 set_error(GetLastError());
1826 close_stdout();
1827 delete[] tmp;
1828 return -1;
1829 }
1830 if (bytes == 0)
1831 {
1832 // EOF
1833 close_stdout();
1834 delete[] tmp;
1835 return -1;
1836 }
1837 buffer.append(tmp, bytes);
1838 delete[] tmp;
1839 return (int)bytes;
1840 }
1841
1842 #else
1843
1844 int async_subprocess::read_stdout (std::string& buffer)
1845 {
1846 if (m_child_out == -1) return -1;
1847 // rely on the pipe being non-blocking
1848 int buffer_size = 256;
1849 char* tmp = new char[buffer_size];
1850 int bytes = read(m_child_out, tmp, buffer_size);
1851 if (bytes == -1 && errno == EAGAIN)
1852 {
1853 // not ready
1854 delete[] tmp;
1855 return 0;
1856 }
1857 if (bytes == -1)
1858 {
1859 // error
1860 set_error(errno);
1861 close_stdout();
1862 delete[] tmp;
1863 return -1;
1864 }
1865 if (bytes == 0)
1866 {
1867 // EOF
1868 close_stdout();
1869 delete[] tmp;
1870 return -1;
1871 }
1872 // successful read
1873 buffer.append(tmp, bytes);
1874 delete[] tmp;
1875 return bytes;
1876 }
1877
1878 #endif
1879
1880 #ifdef MSWINDOWS
1881
1882 int async_subprocess::read_stderr (std::string& buffer)
1883 {
1884 if (m_child_err == 0) return -1;
1885 // peek at the buffer to see how much data there is in the first place
1886 DWORD buffer_size = 0;
1887 if (!PeekNamedPipe(m_child_err, 0, 0, 0, &buffer_size, 0))
1888 {
1889 if (GetLastError() != ERROR_BROKEN_PIPE)
1890 set_error(GetLastError());
1891 close_stderr();
1892 return -1;
1893 }
1894 if (buffer_size == 0) return 0;
1895 DWORD bytes = 0;
1896 char* tmp = new char[buffer_size];
1897 if (!ReadFile(m_child_err, tmp, buffer_size, &bytes, 0))
1898 {
1899 set_error(GetLastError());
1900 close_stderr();
1901 delete[] tmp;
1902 return -1;
1903 }
1904 if (bytes == 0)
1905 {
1906 // EOF
1907 close_stderr();
1908 delete[] tmp;
1909 return -1;
1910 }
1911 buffer.append(tmp, bytes);
1912 delete[] tmp;
1913 return (int)bytes;
1914 }
1915
1916 #else
1917
1918 int async_subprocess::read_stderr (std::string& buffer)
1919 {
1920 if (m_child_err == -1) return -1;
1921 // rely on the pipe being non-blocking
1922 int buffer_size = 256;
1923 char* tmp = new char[buffer_size];
1924 int bytes = read(m_child_err, tmp, buffer_size);
1925 if (bytes == -1 && errno == EAGAIN)
1926 {
1927 // not ready
1928 delete[] tmp;
1929 return 0;
1930 }
1931 if (bytes == -1)
1932 {
1933 // error
1934 set_error(errno);
1935 close_stderr();
1936 delete[] tmp;
1937 return -1;
1938 }
1939 if (bytes == 0)
1940 {
1941 // EOF
1942 close_stderr();
1943 delete[] tmp;
1944 return -1;
1945 }
1946 // successful read
1947 buffer.append(tmp, bytes);
1948 delete[] tmp;
1949 return bytes;
1950 }
1951
1952 #endif
1953
1954 #ifdef MSWINDOWS
1955
1956 void async_subprocess::close_stdin (void)
1957 {
1958 if (m_child_in)
1959 {
1960 CloseHandle(m_child_in);
1961 m_child_in = 0;
1962 }
1963 }
1964
1965 #else
1966
1967 void async_subprocess::close_stdin (void)
1968 {
1969 if (m_child_in != -1)
1970 {
1971 ::close(m_child_in);
1972 m_child_in = -1;
1973 }
1974 }
1975
1976 #endif
1977
1978 #ifdef MSWINDOWS
1979
1980 void async_subprocess::close_stdout (void)
1981 {
1982 if (m_child_out)
1983 {
1984 CloseHandle(m_child_out);
1985 m_child_out = 0;
1986 }
1987 }
1988
1989 #else
1990
1991 void async_subprocess::close_stdout (void)
1992 {
1993 if (m_child_out != -1)
1994 {
1995 ::close(m_child_out);
1996 m_child_out = -1;
1997 }
1998 }
1999
2000 #endif
2001
2002 #ifdef MSWINDOWS
2003
2004 void async_subprocess::close_stderr (void)
2005 {
2006 if (m_child_err)
2007 {
2008 CloseHandle(m_child_err);
2009 m_child_err = 0;
2010 }
2011 }
2012
2013 #else
2014
2015 void async_subprocess::close_stderr (void)
2016 {
2017 if (m_child_err != -1)
2018 {
2019 ::close(m_child_err);
2020 m_child_err = -1;
2021 }
2022 }
2023
2024 #endif
2025
2026 bool async_subprocess::error(void) const
2027 {
2028 return m_err != 0;
2029 }
2030
2031 int async_subprocess::error_number(void) const
2032 {
2033 return m_err;
2034 }
2035
2036 #ifdef MSWINDOWS
2037
2038 std::string async_subprocess::error_text(void) const
2039 {
2040 if (m_err == 0) return std::string();
2041 char* message;
2042 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
2043 0,
2044 m_err,
2045 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
2046 (LPTSTR)&message,
2047 0,0);
2048 std::string result = message;
2049 LocalFree(message);
2050 // the error message is for some perverse reason newline terminated - remove this
2051 if (result[result.size()-1] == '\n')
2052 result.erase(result.end()-1);
2053 if (result[result.size()-1] == '\r')
2054 result.erase(result.end()-1);
2055 return result;
2056 }
2057
2058 #else
2059
2060 std::string async_subprocess::error_text(void) const
2061 {
2062 if (m_err == 0) return std::string();
2063 char* text = strerror(m_err);
2064 if (text) return std::string(text);
2065 return "error number " + dformat("%d",m_err);
2066 }
2067
2068 #endif
2069
2070 int async_subprocess::exit_status(void) const
2071 {
2072 return m_status;
2073 }
2074
2075 ////////////////////////////////////////////////////////////////////////////////
2076
2077 } // end namespace stlplus
This page took 0.121836 seconds and 3 git commands to generate.