mirror of
https://github.com/arun11299/cpp-subprocess.git
synced 2025-08-05 04:46:21 -04:00
Merge pull request #7 from mirror3000/master
Make library usable from multiple object files
This commit is contained in:
Arun Muralidharan
GitHub
commit
09ee99a282
280
subprocess.hpp
280
subprocess.hpp
@ -141,9 +141,9 @@ namespace util
|
||||
* Function: split
|
||||
* Parameters:
|
||||
* [in] str : Input string which needs to be split based upon the
|
||||
* delimiters provided.
|
||||
* delimiters provided.
|
||||
* [in] deleims : Delimiter characters based upon which the string needs
|
||||
* to be split. Default constructed to ' '(space) and '\t'(tab)
|
||||
* to be split. Default constructed to ' '(space) and '\t'(tab)
|
||||
* [out] vector<string> : Vector of strings split at deleimiter.
|
||||
*/
|
||||
static inline std::vector<std::string>
|
||||
@ -155,8 +155,8 @@ namespace util
|
||||
while (true) {
|
||||
auto pos = str.find_first_of(delims, init);
|
||||
if (pos == std::string::npos) {
|
||||
res.emplace_back(str.substr(init, str.length()));
|
||||
break;
|
||||
res.emplace_back(str.substr(init, str.length()));
|
||||
break;
|
||||
}
|
||||
res.emplace_back(str.substr(init, pos - init));
|
||||
pos++;
|
||||
@ -171,15 +171,14 @@ namespace util
|
||||
* Function: join
|
||||
* Parameters:
|
||||
* [in] vec : Vector of strings which needs to be joined to form
|
||||
* a single string with words seperated by
|
||||
* a seperator char.
|
||||
* a single string with words seperated by a seperator char.
|
||||
* [in] sep : String used to seperate 2 words in the joined string.
|
||||
* Default constructed to ' ' (space).
|
||||
* Default constructed to ' ' (space).
|
||||
* [out] string: Joined string.
|
||||
*/
|
||||
static
|
||||
static inline
|
||||
std::string join(const std::vector<std::string>& vec,
|
||||
const std::string& sep = " ")
|
||||
const std::string& sep = " ")
|
||||
{
|
||||
std::string res;
|
||||
for (auto& elem : vec) res.append(elem + sep);
|
||||
@ -195,9 +194,9 @@ namespace util
|
||||
* Parameters:
|
||||
* [in] fd : The descriptor on which FD_CLOEXEC needs to be set/reset.
|
||||
* [in] set : If 'true', set FD_CLOEXEC.
|
||||
* If 'false' unset FD_CLOEXEC.
|
||||
* If 'false' unset FD_CLOEXEC.
|
||||
*/
|
||||
static
|
||||
static inline
|
||||
void set_clo_on_exec(int fd, bool set = true)
|
||||
{
|
||||
int flags = fcntl(fd, F_GETFD, 0);
|
||||
@ -214,10 +213,10 @@ namespace util
|
||||
* read and write descriptors of the pipe.
|
||||
* Parameters:
|
||||
* [out] : A pair of file descriptors.
|
||||
* First element of pair is the read descriptor of pipe.
|
||||
* Second element is the write descriptor of pipe.
|
||||
* First element of pair is the read descriptor of pipe.
|
||||
* Second element is the write descriptor of pipe.
|
||||
*/
|
||||
static
|
||||
static inline
|
||||
std::pair<int, int> pipe_cloexec() throw (OSError)
|
||||
{
|
||||
int pipe_fds[2];
|
||||
@ -241,10 +240,10 @@ namespace util
|
||||
* [in] fd : The file descriptotr to write to.
|
||||
* [in] buf: Buffer from which data needs to be written to fd.
|
||||
* [in] length: The number of bytes that needs to be written from
|
||||
* `buf` to `fd`.
|
||||
* `buf` to `fd`.
|
||||
* [out] int : Number of bytes written or -1 in case of failure.
|
||||
*/
|
||||
static
|
||||
static inline
|
||||
int write_n(int fd, const char* buf, size_t length)
|
||||
{
|
||||
int nwritten = 0;
|
||||
@ -266,12 +265,12 @@ namespace util
|
||||
* [in] buf : The buffer into which it needs to write the data.
|
||||
* [in] read_upto: Max number of bytes which must be read from `fd`.
|
||||
* [out] int : Number of bytes written to `buf` or read from `fd`
|
||||
* OR -1 in case of error.
|
||||
* OR -1 in case of error.
|
||||
* NOTE: In case of EINTR while reading from socket, this API
|
||||
* will retry to read from `fd`, but only till the EINTR counter
|
||||
* reaches 50 after which it will return with whatever data it read.
|
||||
*/
|
||||
static
|
||||
static inline
|
||||
int read_atmost_n(int fd, char* buf, size_t read_upto)
|
||||
{
|
||||
int rbytes = 0;
|
||||
@ -280,12 +279,12 @@ namespace util
|
||||
while (1) {
|
||||
int read_bytes = read(fd, buf, read_upto);
|
||||
if (read_bytes == -1) {
|
||||
if (errno == EINTR) {
|
||||
if (eintr_cnter >= 50) return -1;
|
||||
eintr_cnter++;
|
||||
continue;
|
||||
}
|
||||
return -1;
|
||||
if (errno == EINTR) {
|
||||
if (eintr_cnter >= 50) return -1;
|
||||
eintr_cnter++;
|
||||
continue;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
if (read_bytes == 0) return rbytes;
|
||||
|
||||
@ -302,14 +301,14 @@ namespace util
|
||||
* Parameters:
|
||||
* [in] fd : The file descriptor from which to read from.
|
||||
* [in] buf : The buffer of type `class Buffer` into which
|
||||
* the read data is written to.
|
||||
* the read data is written to.
|
||||
* [out] int: Number of bytes read OR -1 in case of failure.
|
||||
*
|
||||
* NOTE: `class Buffer` is a exposed public class. See below.
|
||||
*/
|
||||
template <typename Buffer>
|
||||
// Requires Buffer to be of type class Buffer
|
||||
static int read_all(int fd, Buffer& buf)
|
||||
static inline int read_all(int fd, Buffer& buf)
|
||||
{
|
||||
size_t orig_size = buf.size();
|
||||
size_t increment = orig_size;
|
||||
@ -319,18 +318,18 @@ namespace util
|
||||
while (1) {
|
||||
int rd_bytes = read_atmost_n(fd, buffer, buf.size());
|
||||
if (rd_bytes == increment) {
|
||||
// Resize the buffer to accomodate more
|
||||
orig_size = orig_size * 1.5;
|
||||
increment = orig_size - buf.size();
|
||||
buf.resize(orig_size);
|
||||
buffer += rd_bytes;
|
||||
total_bytes_read += rd_bytes;
|
||||
} else if (rd_bytes != -1){
|
||||
total_bytes_read += rd_bytes;
|
||||
break;
|
||||
// Resize the buffer to accomodate more
|
||||
orig_size = orig_size * 1.5;
|
||||
increment = orig_size - buf.size();
|
||||
buf.resize(orig_size);
|
||||
buffer += rd_bytes;
|
||||
total_bytes_read += rd_bytes;
|
||||
} else if (rd_bytes != -1) {
|
||||
total_bytes_read += rd_bytes;
|
||||
break;
|
||||
} else {
|
||||
if (total_bytes_read == 0) return -1;
|
||||
break;
|
||||
if (total_bytes_read == 0) return -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return total_bytes_read;
|
||||
@ -344,13 +343,13 @@ namespace util
|
||||
* Parameters:
|
||||
* [in] pid : The pid of the process.
|
||||
* [out] pair<int, int>:
|
||||
* pair.first : Return code of the waitpid call.
|
||||
* pair.second : Exit status of the process.
|
||||
* pair.first : Return code of the waitpid call.
|
||||
* pair.second : Exit status of the process.
|
||||
*
|
||||
* NOTE: This is a blocking call as in, it will loop
|
||||
* NOTE: This is a blocking call as in, it will loop
|
||||
* till the child is exited.
|
||||
*/
|
||||
static
|
||||
static inline
|
||||
std::pair<int, int> wait_for_child_exit(int pid)
|
||||
{
|
||||
int status = 0;
|
||||
@ -919,13 +918,13 @@ private:
|
||||
* 7. kill(sig_num) - Kill the child. SIGTERM used by default.
|
||||
* 8. send(...) - Send input to the input channel of the child.
|
||||
* 9. communicate(...) - Get the output/error from the child and close the channels
|
||||
* from the parent side.
|
||||
* from the parent side.
|
||||
*10. input() - Get the input channel/File pointer. Can be used for
|
||||
* cutomizing the way of sending input to child.
|
||||
* cutomizing the way of sending input to child.
|
||||
*11. output() - Get the output channel/File pointer. Usually used
|
||||
in case of redirection. See piping examples.
|
||||
in case of redirection. See piping examples.
|
||||
*12. error() - Get the error channel/File poiner. Usually used
|
||||
in case of redirection.
|
||||
in case of redirection.
|
||||
*13. start_process() - Start the child process. Only to be used when
|
||||
* `defer_spawn` option was provided in Popen constructor.
|
||||
*/
|
||||
@ -1041,19 +1040,19 @@ private:
|
||||
int retcode_ = -1;
|
||||
};
|
||||
|
||||
void Popen::init_args() {
|
||||
inline void Popen::init_args() {
|
||||
populate_c_argv();
|
||||
}
|
||||
|
||||
template <typename F, typename... Args>
|
||||
void Popen::init_args(F&& farg, Args&&... args)
|
||||
inline void Popen::init_args(F&& farg, Args&&... args)
|
||||
{
|
||||
detail::ArgumentDeducer argd(this);
|
||||
argd.set_option(std::forward<F>(farg));
|
||||
init_args(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
void Popen::populate_c_argv()
|
||||
inline void Popen::populate_c_argv()
|
||||
{
|
||||
cargv_.clear();
|
||||
cargv_.reserve(vargs_.size() + 1);
|
||||
@ -1061,7 +1060,7 @@ void Popen::populate_c_argv()
|
||||
cargv_.push_back(nullptr);
|
||||
}
|
||||
|
||||
void Popen::start_process() throw (CalledProcessError, OSError)
|
||||
inline void Popen::start_process() throw (CalledProcessError, OSError)
|
||||
{
|
||||
// The process was started/tried to be started
|
||||
// in the constructor itself.
|
||||
@ -1075,7 +1074,7 @@ void Popen::start_process() throw (CalledProcessError, OSError)
|
||||
execute_process();
|
||||
}
|
||||
|
||||
int Popen::wait() throw (OSError)
|
||||
inline int Popen::wait() throw (OSError)
|
||||
{
|
||||
int ret, status;
|
||||
std::tie(ret, status) = util::wait_for_child_exit(pid());
|
||||
@ -1090,7 +1089,7 @@ int Popen::wait() throw (OSError)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int Popen::poll() throw (OSError)
|
||||
inline int Popen::poll() throw (OSError)
|
||||
{
|
||||
int status;
|
||||
if (!child_created_) return -1; // TODO: ??
|
||||
@ -1125,14 +1124,14 @@ int Popen::poll() throw (OSError)
|
||||
return retcode_;
|
||||
}
|
||||
|
||||
void Popen::kill(int sig_num)
|
||||
inline void Popen::kill(int sig_num)
|
||||
{
|
||||
if (session_leader_) killpg(child_pid_, sig_num);
|
||||
else ::kill(child_pid_, sig_num);
|
||||
}
|
||||
|
||||
|
||||
void Popen::execute_process() throw (CalledProcessError, OSError)
|
||||
inline void Popen::execute_process() throw (CalledProcessError, OSError)
|
||||
{
|
||||
int err_rd_pipe, err_wr_pipe;
|
||||
std::tie(err_rd_pipe, err_wr_pipe) = util::pipe_cloexec();
|
||||
@ -1187,19 +1186,19 @@ void Popen::execute_process() throw (CalledProcessError, OSError)
|
||||
char err_buf[SP_MAX_ERR_BUF_SIZ] = {0,};
|
||||
|
||||
int read_bytes = util::read_atmost_n(
|
||||
err_rd_pipe,
|
||||
err_buf,
|
||||
SP_MAX_ERR_BUF_SIZ);
|
||||
err_rd_pipe,
|
||||
err_buf,
|
||||
SP_MAX_ERR_BUF_SIZ);
|
||||
close(err_rd_pipe);
|
||||
|
||||
if (read_bytes || strlen(err_buf)) {
|
||||
// Call waitpid to reap the child process
|
||||
// waitpid suspends the calling process until the
|
||||
// child terminates.
|
||||
wait();
|
||||
// Call waitpid to reap the child process
|
||||
// waitpid suspends the calling process until the
|
||||
// child terminates.
|
||||
wait();
|
||||
|
||||
// Throw whatever information we have about child failure
|
||||
throw CalledProcessError(err_buf);
|
||||
// Throw whatever information we have about child failure
|
||||
throw CalledProcessError(err_buf);
|
||||
}
|
||||
} catch (std::exception& exp) {
|
||||
stream_.cleanup_fds();
|
||||
@ -1211,45 +1210,45 @@ void Popen::execute_process() throw (CalledProcessError, OSError)
|
||||
|
||||
namespace detail {
|
||||
|
||||
void ArgumentDeducer::set_option(executable&& exe) {
|
||||
inline void ArgumentDeducer::set_option(executable&& exe) {
|
||||
popen_->exe_name_ = std::move(exe.arg_value);
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(cwd&& cwdir) {
|
||||
inline void ArgumentDeducer::set_option(cwd&& cwdir) {
|
||||
popen_->cwd_ = std::move(cwdir.arg_value);
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(bufsize&& bsiz) {
|
||||
inline void ArgumentDeducer::set_option(bufsize&& bsiz) {
|
||||
popen_->stream_.bufsiz_ = bsiz.bufsiz;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(environment&& env) {
|
||||
inline void ArgumentDeducer::set_option(environment&& env) {
|
||||
popen_->env_ = std::move(env.env_);
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(defer_spawn&& defer) {
|
||||
inline void ArgumentDeducer::set_option(defer_spawn&& defer) {
|
||||
popen_->defer_process_start_ = defer.defer;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(shell&& sh) {
|
||||
inline void ArgumentDeducer::set_option(shell&& sh) {
|
||||
popen_->shell_ = sh.shell_;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(session_leader&& sleader) {
|
||||
inline void ArgumentDeducer::set_option(session_leader&& sleader) {
|
||||
popen_->session_leader_ = sleader.leader_;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(input&& inp) {
|
||||
inline void ArgumentDeducer::set_option(input&& inp) {
|
||||
if (inp.rd_ch_ != -1) popen_->stream_.read_from_parent_ = inp.rd_ch_;
|
||||
if (inp.wr_ch_ != -1) popen_->stream_.write_to_child_ = inp.wr_ch_;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(output&& out) {
|
||||
inline void ArgumentDeducer::set_option(output&& out) {
|
||||
if (out.wr_ch_ != -1) popen_->stream_.write_to_parent_ = out.wr_ch_;
|
||||
if (out.rd_ch_ != -1) popen_->stream_.read_from_child_ = out.rd_ch_;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(error&& err) {
|
||||
inline void ArgumentDeducer::set_option(error&& err) {
|
||||
if (err.deferred_) {
|
||||
if (popen_->stream_.write_to_parent_) {
|
||||
popen_->stream_.err_write_ = popen_->stream_.write_to_parent_;
|
||||
@ -1261,26 +1260,26 @@ namespace detail {
|
||||
if (err.rd_ch_ != -1) popen_->stream_.err_read_ = err.rd_ch_;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(close_fds&& cfds) {
|
||||
inline void ArgumentDeducer::set_option(close_fds&& cfds) {
|
||||
popen_->close_fds_ = cfds.close_all;
|
||||
}
|
||||
|
||||
void ArgumentDeducer::set_option(preexec_func&& prefunc) {
|
||||
inline void ArgumentDeducer::set_option(preexec_func&& prefunc) {
|
||||
popen_->preexec_fn_ = std::move(prefunc);
|
||||
popen_->has_preexec_fn_ = true;
|
||||
}
|
||||
|
||||
|
||||
void Child::execute_child() {
|
||||
inline void Child::execute_child() {
|
||||
int sys_ret = -1;
|
||||
auto& stream = parent_->stream_;
|
||||
|
||||
try {
|
||||
if (stream.write_to_parent_ == 0)
|
||||
stream.write_to_parent_ = dup(stream.write_to_parent_);
|
||||
stream.write_to_parent_ = dup(stream.write_to_parent_);
|
||||
|
||||
if (stream.err_write_ == 0 || stream.err_write_ == 1)
|
||||
stream.err_write_ = dup(stream.err_write_);
|
||||
stream.err_write_ = dup(stream.err_write_);
|
||||
|
||||
// Make the child owned descriptors as the
|
||||
// stdin, stdout and stderr for the child process
|
||||
@ -1307,13 +1306,13 @@ namespace detail {
|
||||
|
||||
// Close the duped descriptors
|
||||
if (stream.read_from_parent_ != -1 && stream.read_from_parent_ > 2)
|
||||
close(stream.read_from_parent_);
|
||||
close(stream.read_from_parent_);
|
||||
|
||||
if (stream.write_to_parent_ != -1 && stream.write_to_parent_ > 2)
|
||||
close(stream.write_to_parent_);
|
||||
close(stream.write_to_parent_);
|
||||
|
||||
if (stream.err_write_ != -1 && stream.err_write_ > 2)
|
||||
close(stream.err_write_);
|
||||
close(stream.err_write_);
|
||||
|
||||
// Close all the inherited fd's except the error write pipe
|
||||
if (parent_->close_fds_) {
|
||||
@ -1333,19 +1332,19 @@ namespace detail {
|
||||
}
|
||||
|
||||
if (parent_->has_preexec_fn_) {
|
||||
parent_->preexec_fn_();
|
||||
parent_->preexec_fn_();
|
||||
}
|
||||
|
||||
if (parent_->session_leader_) {
|
||||
sys_ret = setsid();
|
||||
if (sys_ret == -1) throw OSError("setsid failed", errno);
|
||||
sys_ret = setsid();
|
||||
if (sys_ret == -1) throw OSError("setsid failed", errno);
|
||||
}
|
||||
|
||||
// Replace the current image with the executable
|
||||
if (parent_->env_.size()) {
|
||||
for (auto& kv : parent_->env_) {
|
||||
setenv(kv.first.c_str(), kv.second.c_str(), 1);
|
||||
}
|
||||
}
|
||||
sys_ret = execvp(parent_->exe_name_.c_str(), parent_->cargv_.data());
|
||||
} else {
|
||||
sys_ret = execvp(parent_->exe_name_.c_str(), parent_->cargv_.data());
|
||||
@ -1368,7 +1367,7 @@ namespace detail {
|
||||
}
|
||||
|
||||
|
||||
void Streams::setup_comm_channels()
|
||||
inline void Streams::setup_comm_channels()
|
||||
{
|
||||
if (write_to_child_ != -1) input(fdopen(write_to_child_, "wb"));
|
||||
if (read_from_child_ != -1) output(fdopen(read_from_child_, "rb"));
|
||||
@ -1380,29 +1379,29 @@ namespace detail {
|
||||
if (h == nullptr) continue;
|
||||
switch (bufsiz_) {
|
||||
case 0:
|
||||
setvbuf(h, nullptr, _IONBF, BUFSIZ);
|
||||
break;
|
||||
setvbuf(h, nullptr, _IONBF, BUFSIZ);
|
||||
break;
|
||||
case 1:
|
||||
setvbuf(h, nullptr, _IONBF, BUFSIZ);
|
||||
break;
|
||||
setvbuf(h, nullptr, _IONBF, BUFSIZ);
|
||||
break;
|
||||
default:
|
||||
setvbuf(h, nullptr, _IOFBF, bufsiz_);
|
||||
setvbuf(h, nullptr, _IOFBF, bufsiz_);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
int Communication::send(const char* msg, size_t length)
|
||||
inline int Communication::send(const char* msg, size_t length)
|
||||
{
|
||||
if (stream_->input() == nullptr) return -1;
|
||||
return std::fwrite(msg, sizeof(char), length, stream_->input());
|
||||
}
|
||||
|
||||
int Communication::send(const std::vector<char>& msg)
|
||||
inline int Communication::send(const std::vector<char>& msg)
|
||||
{
|
||||
return send(msg.data(), msg.size());
|
||||
}
|
||||
|
||||
std::pair<OutBuffer, ErrBuffer>
|
||||
inline std::pair<OutBuffer, ErrBuffer>
|
||||
Communication::communicate(const char* msg, size_t length)
|
||||
{
|
||||
// Optimization from subprocess.py
|
||||
@ -1415,50 +1414,50 @@ namespace detail {
|
||||
OutBuffer obuf;
|
||||
ErrBuffer ebuf;
|
||||
if (stream_->input()) {
|
||||
if (msg) {
|
||||
int wbytes = std::fwrite(msg, sizeof(char), length, stream_->input());
|
||||
if (wbytes < length) {
|
||||
if (errno != EPIPE && errno != EINVAL) {
|
||||
throw OSError("fwrite error", errno);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Close the input stream
|
||||
stream_->input_.reset();
|
||||
if (msg) {
|
||||
int wbytes = std::fwrite(msg, sizeof(char), length, stream_->input());
|
||||
if (wbytes < length) {
|
||||
if (errno != EPIPE && errno != EINVAL) {
|
||||
throw OSError("fwrite error", errno);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Close the input stream
|
||||
stream_->input_.reset();
|
||||
} else if (stream_->output()) {
|
||||
// Read till EOF
|
||||
// ATTN: This could be blocking, if the process
|
||||
// at the other end screws up, we get screwed up as well
|
||||
obuf.add_cap(out_buf_cap_);
|
||||
// Read till EOF
|
||||
// ATTN: This could be blocking, if the process
|
||||
// at the other end screws up, we get screwed up as well
|
||||
obuf.add_cap(out_buf_cap_);
|
||||
|
||||
int rbytes = util::read_all(
|
||||
fileno(stream_->output()),
|
||||
obuf.buf);
|
||||
int rbytes = util::read_all(
|
||||
fileno(stream_->output()),
|
||||
obuf.buf);
|
||||
|
||||
if (rbytes == -1) {
|
||||
throw OSError("read to obuf failed", errno);
|
||||
}
|
||||
if (rbytes == -1) {
|
||||
throw OSError("read to obuf failed", errno);
|
||||
}
|
||||
|
||||
obuf.length = rbytes;
|
||||
// Close the output stream
|
||||
stream_->output_.reset();
|
||||
obuf.length = rbytes;
|
||||
// Close the output stream
|
||||
stream_->output_.reset();
|
||||
|
||||
} else if (stream_->error()) {
|
||||
// Same screwness applies here as well
|
||||
ebuf.add_cap(err_buf_cap_);
|
||||
// Same screwness applies here as well
|
||||
ebuf.add_cap(err_buf_cap_);
|
||||
|
||||
int rbytes = util::read_atmost_n(
|
||||
fileno(stream_->error()),
|
||||
ebuf.buf.data(),
|
||||
ebuf.buf.size());
|
||||
int rbytes = util::read_atmost_n(
|
||||
fileno(stream_->error()),
|
||||
ebuf.buf.data(),
|
||||
ebuf.buf.size());
|
||||
|
||||
if (rbytes == -1) {
|
||||
throw OSError("read to ebuf failed", errno);
|
||||
}
|
||||
if (rbytes == -1) {
|
||||
throw OSError("read to ebuf failed", errno);
|
||||
}
|
||||
|
||||
ebuf.length = rbytes;
|
||||
// Close the error stream
|
||||
stream_->error_.reset();
|
||||
ebuf.length = rbytes;
|
||||
// Close the error stream
|
||||
stream_->error_.reset();
|
||||
}
|
||||
return std::make_pair(std::move(obuf), std::move(ebuf));
|
||||
}
|
||||
@ -1467,7 +1466,7 @@ namespace detail {
|
||||
}
|
||||
|
||||
|
||||
std::pair<OutBuffer, ErrBuffer>
|
||||
inline std::pair<OutBuffer, ErrBuffer>
|
||||
Communication::communicate_threaded(const char* msg, size_t length)
|
||||
{
|
||||
OutBuffer obuf;
|
||||
@ -1492,12 +1491,12 @@ namespace detail {
|
||||
}
|
||||
if (stream_->input()) {
|
||||
if (msg) {
|
||||
int wbytes = std::fwrite(msg, sizeof(char), length, stream_->input());
|
||||
if (wbytes < length) {
|
||||
if (errno != EPIPE && errno != EINVAL) {
|
||||
throw OSError("fwrite error", errno);
|
||||
}
|
||||
}
|
||||
int wbytes = std::fwrite(msg, sizeof(char), length, stream_->input());
|
||||
if (wbytes < length) {
|
||||
if (errno != EPIPE && errno != EINVAL) {
|
||||
throw OSError("fwrite error", errno);
|
||||
}
|
||||
}
|
||||
}
|
||||
stream_->input_.reset();
|
||||
}
|
||||
@ -1544,12 +1543,15 @@ namespace detail
|
||||
return Popen(std::forward<F>(farg), std::forward<Args>(args)...).wait();
|
||||
}
|
||||
|
||||
void pipeline_impl(std::vector<Popen>& cmds) { /* EMPTY IMPL */ }
|
||||
static inline void pipeline_impl(std::vector<Popen>& cmds)
|
||||
{
|
||||
/* EMPTY IMPL */
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
void pipeline_impl(std::vector<Popen>& cmds,
|
||||
const std::string& cmd,
|
||||
Args&&... args)
|
||||
static inline void pipeline_impl(std::vector<Popen>& cmds,
|
||||
const std::string& cmd,
|
||||
Args&&... args)
|
||||
{
|
||||
if (cmds.size() == 0) {
|
||||
cmds.emplace_back(cmd, output{PIPE}, defer_spawn{true});
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user