2 The software in this package is distributed under the GNU General
3 Public License version 2 (with a special exception described below).
5 A copy of GNU General Public License (GPL) is included in this distribution,
6 in the file COPYING.GPL.
8 As a special exception, if other files instantiate templates or use macros
9 or inline functions from this file, or you compile this file and link it
10 with other works to produce a work based on this file, this file
11 does not by itself cause the resulting work to be covered
12 by the GNU General Public License.
14 However the source code for this file must still be made available
15 in accordance with section (3) of the GNU General Public License.
17 This exception does not invalidate any other reasons why a work based
18 on this file might be covered by the GNU General Public License.
20 /***************************************************************************
21 inpipestream.cpp - C++ streambuffer wrapper
23 begin : Thu Dec 27 2001
24 copyright : (C) 2001 by Intra2net AG
25 ***************************************************************************/
38 #include <boost/foreach.hpp>
39 #include <boost/shared_array.hpp>
41 #include "exception.hxx"
42 #include "stringfunc.hxx"
43 #include "pipestream.hxx"
45 /** @brief runs command and returns it's output as string
46 * @param command the full command with all parameters
47 * @param rescode struct containing the return code, if the program exited normally and so on
48 * @param out Whether to collect \c stdout.
49 * @param err Whether to collect \c stderr; combines with \c out.
50 * @param path Wether to look up the executable in \c $PATH.
51 * @returns the output (stdout) of the called program
53 template <typename CmdT>
54 std::string capture_exec(CmdT command, ExecResult &rescode,
55 const bool out, const bool err,
60 bool exit_set = false;
61 int exit_status_waitpid;
63 // set the results to false until we are sure we have proper values
64 rescode.normal_exit = false;
65 rescode.terminated_by_signal = false;
70 inpipestream ips(command, out, err, path);
72 ips.store_exit_status(&exit_set, &exit_status_waitpid);
77 ips.read(buffer, sizeof(buffer));
78 output.append(buffer, ips.gcount());
82 // exit_status_waitpid only valid after destruction of the inpipestream
86 rescode.normal_exit = WIFEXITED(exit_status_waitpid);
87 if (rescode.normal_exit)
88 rescode.return_code = WEXITSTATUS(exit_status_waitpid);
90 rescode.terminated_by_signal = WIFSIGNALED(exit_status_waitpid);
91 if (rescode.terminated_by_signal)
92 rescode.signal = WTERMSIG(exit_status_waitpid);
95 catch (pipestream_error &e)
97 rescode.error_message = e.what();
103 /** @brief Instantiation of \c capture_exec for STL string arguments.
104 * Caveat emptor: this will cause the backing stream to use \c
105 * popen(3). To avoid shelling out, please refer to one of the
106 * variants that allow passing an argument list.
108 * @param command String specifying the shell expression to be executed.
109 * @param res (Out parameter) Store information about the termination
110 * state in this struct.
112 * @returns Result of \c stdout. Note that due to the use of \c
113 * popen, the correct way to collect stderr output as
114 * well is to use shell redirection inside the expression
117 std::string capture_exec (const std::string &command, ExecResult &res)
118 { return capture_exec<const std::string &>(command, res, true, false, false); }
120 /** @brief Instantiation of \c capture_exec for argument lists. The
121 * pipestream used to run the command will not shell out.
122 * One of \c out or \c err must be set.
124 * @param command List of \c char* specifying the \c argv array of the
125 * command to run. Note that the binary to executed is
126 * assumed to be present at index 0 and that the input
127 * is properly \c NULL terminated.
128 * @param res (Out parameter) Store information about the termination
129 * state in this struct.
130 * @param out Whether to collect \c stdout.
131 * @param err Whether to collect \c stderr; combines with \c out.
132 * @param path Wether to look up the executable in \c $PATH.
134 * @returns Captured output, combined into one string.
136 std::string capture_exec (const char *const *command, ExecResult &res,
137 const bool out, const bool err, const bool path)
138 { return capture_exec<const char *const *>(command, res, out, err, path); }
140 /** @brief Instantiation of \c capture_exec for argument lists. The
141 * pipestream used to run the command will not shell out.
142 * One of \c out or \c err must be set.
144 * @param command String vector specifying the \c argv array of the
145 * command to run. Note that the binary to executed is
146 * assumed to be present at index 0.
147 * @param res (Out parameter) Store information about the termination
148 * state in this struct.
149 * @param out Whether to collect \c stdout.
150 * @param err Whether to collect \c stderr; combines with \c out.
151 * @param path Wether to look up the executable in \c $PATH.
153 * @returns Captured output, combined into one string.
155 std::string capture_exec (const std::vector<std::string> &command, ExecResult &res,
156 const bool out, const bool err, const bool path)
158 return capture_exec<const std::vector<std::string> &>
159 (command, res, out, err, path);
162 #define PIPE_CTOR_FAIL(where) \
164 throw EXCEPTION (pipestream_error, \
165 std::string (where) + ": error " \
166 + I2n::to_string (errno) \
167 + " (" + std::string (strerror (errno)) + ")"); \
170 /** @brief Convert a string vector to a refcounted \c char**
171 * that is \c NULL terminated for use with e. g. \c execve(2).
173 * @param command List of arguments including the binary at index 0.
175 * @returns A \c boost::shared_array of pointers to the
176 * arguments plus a trailing \c NULL. Note that
177 * while the array itself is refcounted, the
178 * pointees are assumed owned by the caller and
179 * *not copyied*. I. e. they lose validity if the
180 * original strings are freed.
182 static boost::shared_array <char *>
183 mk_argv (const std::vector<std::string> &command)
188 ret = new char *[command.size () * sizeof (ret[0]) + 1];
189 } catch (std::bad_alloc &) {
190 return boost::shared_array<char *> ();
194 BOOST_FOREACH(const std::string &arg, command) {
196 * Casting away constness is safe since the data is always
197 * kept alive until after exec().
199 ret [cur++] = const_cast<char *> (arg.c_str ());
204 return boost::shared_array<char *> (ret);
207 /** @brief Helper for redirecting a file descriptor to \c /dev/null.
208 * This will only acquire an fd the first time it is called
209 * or if it is called after unsuccessfully attempting to
212 * @param fd The open file descriptor to operate on.
214 * @returns \c true on success, \c false otherwise (the call to
215 * either \c open(2) or \c dup2(2) failed).
218 redirect_devnull (const int fd)
220 static int nullfd = -1;
223 if (nullfd == -1 && (nullfd = open ("/dev/null", O_RDWR)) == -1) {
228 if (dup2 (nullfd, fd) == -1) {
235 /** @brief Helper aggregating common code for the shell-free ctors.
237 * @param argv Argument list prepared for \c execve(2).
238 * @param out Whether to capture \c stdout.
239 * @param err Whether to capture \c stderr.
241 * @returns A \c FILE* handle for streaming if successful, \c NULL
244 std::pair <pid_t, FILE *>
245 inpipebuf::init_without_shell (const char *const *argv,
248 const bool path) const
250 FILE *pipeobj = NULL;
252 sigset_t oldmask, newmask;
256 PIPE_CTOR_FAIL("ctor");
260 if (::pipe (pipefd) == -1) {
261 PIPE_CTOR_FAIL("pipe");
264 sigfillset (&newmask);
265 sigprocmask (SIG_SETMASK, &newmask, &oldmask);
268 pid_t childpid = fork ();
271 sigprocmask (SIG_SETMASK, &oldmask, NULL);
272 PIPE_CTOR_FAIL("fork");
279 if (!redirect_devnull (STDOUT_FILENO)) {
280 fprintf(stderr, "redirect_devnull/stdout: %m\n");
281 /* XXX should we bail here? */
283 } else if (dup2 (pipefd[1], STDOUT_FILENO) == -1) {
284 fprintf(stderr, "dup2/stdout: %m\n");
289 if (!redirect_devnull (STDERR_FILENO)) {
290 fprintf(stderr, "redirect_devnull/stderr: %m\n");
291 /* XXX should we bail here? */
293 } else if (dup2 (pipefd[1], STDERR_FILENO) == -1) {
294 fprintf(stderr, "dup2/stderr: %m\n");
300 sigprocmask (SIG_SETMASK, &oldmask, NULL);
304 execvpe (argv [0], const_cast <char *const *>(argv), environ);
306 execve (argv [0], const_cast <char *const *>(argv), NULL);
314 sigprocmask (SIG_SETMASK, &oldmask, NULL);
317 if ((pipeobj = fdopen (pipefd [0], "r")) == NULL) {
318 PIPE_CTOR_FAIL("fdopen");
324 return std::make_pair (childpid, pipeobj);
327 inpipebuf::inpipebuf(const char *const *command,
331 : pipe (NULL) /* brr: shadowing global ident */
336 if (command == NULL || command [0] == NULL) {
337 PIPE_CTOR_FAIL("command");
340 std::pair <pid_t, FILE *> tmp =
341 this->init_without_shell (command, out, err, path);
342 this->pid = tmp.first; /* no std::tie :/ */
343 this->pipe = tmp.second;
345 setg (&buffer, &buffer, &buffer);
348 inpipebuf::inpipebuf(const std::vector<std::string> &command,
352 : pipe (NULL) /* brr: shadowing global ident */
357 if (command.empty ()) {
358 PIPE_CTOR_FAIL("command");
361 const boost::shared_array <char *> argv = mk_argv (command);
363 PIPE_CTOR_FAIL("malloc");
366 std::pair <pid_t, FILE *> tmp =
367 this->init_without_shell (argv.get (), out, err, path);
368 this->pid = tmp.first;
369 this->pipe = tmp.second;
371 setg (&buffer, &buffer, &buffer);
374 inpipebuf::inpipebuf(const std::string& command,
375 const bool _ignored_out,
376 const bool _ignored_err,
377 const bool _ignored_path)
382 pipe = popen (command.c_str(), "r");
384 throw EXCEPTION (pipestream_error, "can't open program or permission denied");
387 setg (&buffer, &buffer, &buffer);
390 inpipebuf::~inpipebuf()
398 status = pclose (pipe);
400 if (exit_status != NULL) {
401 *exit_status = status;
402 if (status_set != NULL) {
411 status = fclose (pipe);
413 if (exit_status != NULL) {
414 *exit_status = status; /* might be overwritten below */
415 if (status_set != NULL) {
422 while (waitpid (this->pid, &status, 0) == -1) {
423 if (errno != EINTR) {
428 if (status != 0 && exit_status != NULL) {
429 *exit_status = status; /* might overwrite pipe status above */
430 if (status_set != NULL) {
440 /** note: exit status only available after destruction */
441 void inpipebuf::store_exit_status(bool *_status_set, int *_exit_status)
443 status_set = _status_set;
444 exit_status = _exit_status;
447 inpipebuf::int_type inpipebuf::underflow()
449 if (gptr() < egptr())
450 return traits_type::to_int_type(*gptr());
452 buffer = fgetc (pipe);
459 setg (&buffer, &buffer, &buffer+sizeof(char));
461 return traits_type::to_int_type(*gptr());
464 outpipebuf::outpipebuf(const std::string& command)
469 pipe = popen (command.c_str(), "w");
471 throw EXCEPTION (pipestream_error, "can't open program or permission denied");
474 outpipebuf::~outpipebuf()
477 int pclose_exit = pclose (pipe);
479 if (exit_status && pclose_exit != -1)
483 *exit_status = pclose_exit;
490 /** note: exit status only available after destruction */
491 void outpipebuf::store_exit_status(bool *_status_set, int *_exit_status)
493 status_set = _status_set;
494 exit_status = _exit_status;
497 outpipebuf::int_type outpipebuf::overflow(int_type c)
501 if (fputc(c,pipe)==EOF)
507 std::streamsize outpipebuf::xsputn(const char* s, std::streamsize num)
509 return fwrite(s,num,1,pipe);