3pp-mirror/snapcast
1
0
Fork 0
mirror of https://github.com/badaix/snapcast.git synced 2025-04-29 18:27:12 +02:00
Code Issues Projects Releases Packages Wiki Activity

Replace process class with boost::process

Browse source
This commit is contained in:
badaix 2020-01-05 22:00:35 +01:00
parent d80c87351c
commit ad05e87f6d
3 changed files with 23 additions and 260 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

247
server/streamreader/process.hpp
View file

@ -1,247 +0,0 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#ifndef TINY_PROCESS_LIBRARY_HPP_
#define TINY_PROCESS_LIBRARY_HPP_
#include <cstdlib>
#include <mutex>
#include <signal.h>
#include <string>
#include <sys/wait.h>
#include <unistd.h>
// Forked from: https://github.com/eidheim/tiny-process-library
// Copyright (c) 2015-2016 Ole Christian Eidheim
// Thanks, Christian :-)
namespace streamreader
{
/// Create a new process given command and run path.
/// Thus, at the moment, if read_stdout==nullptr, read_stderr==nullptr and open_stdin==false,
/// the stdout, stderr and stdin are sent to the parent process instead.
/// Compile with -DMSYS_PROCESS_USE_SH to run command using "sh -c [command]" on Windows as well.
class Process
{
public:
typedef int fd_type;
Process(const std::string& command, const std::string& path = "") : closed(true)
{
open(command, path);
}
~Process()
{
close_fds();
}
/// Get the process id of the started process.
pid_t getPid()
{
return pid;
}
/// Write to stdin. Convenience function using write(const char *, size_t).
bool write(const std::string& data)
{
return write(data.c_str(), data.size());
}
/// Wait until process is finished, and return exit status.
int get_exit_status()
{
if (pid <= 0)
return -1;
int exit_status;
waitpid(pid, &exit_status, 0);
{
std::lock_guard<std::mutex> lock(close_mutex);
closed = true;
}
close_fds();
if (exit_status >= 256)
exit_status = exit_status >> 8;
return exit_status;
}
/// Write to stdin.
bool write(const char* bytes, size_t n)
{
std::lock_guard<std::mutex> lock(stdin_mutex);
if (::write(stdin_fd, bytes, n) >= 0)
return true;
else
return false;
}
/// Close stdin. If the process takes parameters from stdin, use this to notify that all parameters have been sent.
void close_stdin()
{
std::lock_guard<std::mutex> lock(stdin_mutex);
if (pid > 0)
close(stdin_fd);
}
/// Kill the process.
void kill(bool force = false)
{
std::lock_guard<std::mutex> lock(close_mutex);
if (pid > 0 && !closed)
{
if (force)
::kill(-pid, SIGTERM);
else
::kill(-pid, SIGINT);
}
}
/// Kill a given process id. Use kill(bool force) instead if possible.
static void kill(pid_t id, bool force = false)
{
if (id <= 0)
return;
if (force)
::kill(-id, SIGTERM);
else
::kill(-id, SIGINT);
}
fd_type getStdout()
{
return stdout_fd;
}
fd_type getStderr()
{
return stderr_fd;
}
fd_type getStdin()
{
return stdin_fd;
}
private:
pid_t pid;
bool closed;
std::mutex close_mutex;
std::mutex stdin_mutex;
fd_type stdout_fd, stderr_fd, stdin_fd;
void closePipe(int pipefd[2])
{
close(pipefd[0]);
close(pipefd[1]);
}
pid_t open(const std::string& command, const std::string& path)
{
int stdin_p[2], stdout_p[2], stderr_p[2];
if (pipe(stdin_p) != 0)
return -1;
if (pipe(stdout_p) != 0)
{
closePipe(stdin_p);
return -1;
}
if (pipe(stderr_p) != 0)
{
closePipe(stdin_p);
closePipe(stdout_p);
return -1;
}
pid = fork();
if (pid < 0)
{
closePipe(stdin_p);
closePipe(stdout_p);
closePipe(stderr_p);
return pid;
}
else if (pid == 0)
{
dup2(stdin_p[0], 0);
dup2(stdout_p[1], 1);
dup2(stderr_p[1], 2);
closePipe(stdin_p);
closePipe(stdout_p);
closePipe(stderr_p);
// Based on http://stackoverflow.com/a/899533/3808293
int fd_max = sysconf(_SC_OPEN_MAX);
for (int fd = 3; fd < fd_max; fd++)
close(fd);
setpgid(0, 0);
if (!path.empty())
{
auto path_escaped = path;
size_t pos = 0;
// Based on https://www.reddit.com/r/cpp/comments/3vpjqg/a_new_platform_independent_process_library_for_c11/cxsxyb7
while ((pos = path_escaped.find('\'', pos)) != std::string::npos)
{
path_escaped.replace(pos, 1, "'\\''");
pos += 4;
}
execl("/bin/sh", "sh", "-c", ("cd '" + path_escaped + "' && " + command).c_str(), NULL);
}
else
execl("/bin/sh", "sh", "-c", command.c_str(), NULL);
_exit(EXIT_FAILURE);
}
close(stdin_p[0]);
close(stdout_p[1]);
close(stderr_p[1]);
stdin_fd = stdin_p[1];
stdout_fd = stdout_p[0];
stderr_fd = stderr_p[0];
closed = false;
return pid;
}
void close_fds()
{
close_stdin();
if (pid > 0)
{
close(stdout_fd);
close(stderr_fd);
}
}
};
} // namespace streamreader
#endif // TINY_PROCESS_LIBRARY_HPP_

26
server/streamreader/process_stream.cpp
View file

@ -35,8 +35,7 @@ namespace streamreader
static constexpr auto LOG_TAG = "ProcessStream";
ProcessStream::ProcessStream(PcmListener* pcmListener, boost::asio::io_context& ioc, const StreamUri& uri)
: PosixStream(pcmListener, ioc, uri), path_(""), process_(nullptr)
ProcessStream::ProcessStream(PcmListener* pcmListener, boost::asio::io_context& ioc, const StreamUri& uri) : PosixStream(pcmListener, ioc, uri)
{
params_ = uri_.getQuery("params");
wd_timeout_sec_ = cpt::stoul(uri_.getQuery("wd_timeout", "0"));
@ -103,11 +102,16 @@ void ProcessStream::do_connect()
return;
initExeAndPath(uri_.path);
LOG(DEBUG, LOG_TAG) << "Launching: '" << path_ + exe_ << "', with params: '" << params_ << "', in path: '" << path_ << "'\n";
process_.reset(new Process(path_ + exe_ + " " + params_, path_));
int flags = fcntl(process_->getStdout(), F_GETFL, 0);
fcntl(process_->getStdout(), F_SETFL, flags | O_NONBLOCK);
stream_ = make_unique<stream_descriptor>(ioc_, process_->getStdout());
stream_stderr_ = make_unique<stream_descriptor>(ioc_, process_->getStderr());
pipe_stdout_ = bp::pipe();
pipe_stderr_ = bp::pipe();
// stdout pipe should not block
int flags = fcntl(pipe_stdout_.native_source(), F_GETFL, 0);
fcntl(pipe_stdout_.native_source(), F_SETFL, flags | O_NONBLOCK);
process_ = bp::child(path_ + exe_ + " " + params_, bp::std_out > pipe_stdout_, bp::std_err > pipe_stderr_, bp::start_dir = path_);
stream_ = make_unique<stream_descriptor>(ioc_, pipe_stdout_.native_source());
stream_stderr_ = make_unique<stream_descriptor>(ioc_, pipe_stderr_.native_source());
on_connect();
if (wd_timeout_sec_ > 0)
{
@ -124,8 +128,8 @@ void ProcessStream::do_connect()
void ProcessStream::do_disconnect()
{
if (process_)
process_->kill();
if (process_.running())
::kill(-process_.native_handle(), SIGINT);
}
@ -146,7 +150,7 @@ void ProcessStream::stderrReadLine()
*stream_stderr_, streambuf_stderr_, delimiter, [this, self, delimiter](const std::error_code& ec, std::size_t bytes_transferred) {
if (ec)
{
LOG(ERROR, LOG_TAG) << "Error while reading from control socket: " << ec.message() << "\n";
LOG(ERROR, LOG_TAG) << "Error while reading from stderr: " << ec.message() << "\n";
return;
}
@ -171,7 +175,7 @@ void ProcessStream::onTimeout(const Watchdog& /*watchdog*/, std::chrono::millise
{
LOG(ERROR, LOG_TAG) << "Watchdog timeout: " << ms.count() / 1000 << "s\n";
if (process_)
process_->kill();
::kill(-process_.native_handle(), SIGINT);
}
} // namespace streamreader

10
server/streamreader/process_stream.hpp
View file

@ -19,13 +19,17 @@
#ifndef PROCESS_STREAM_HPP
#define PROCESS_STREAM_HPP
#include <boost/process.hpp>
#include <memory>
#include <string>
#include "posix_stream.hpp"
#include "process.hpp"
#include "watchdog.hpp"
namespace bp = boost::process;
namespace streamreader
{
@ -49,7 +53,9 @@ protected:
std::string exe_;
std::string path_;
std::string params_;
std::unique_ptr<Process> process_;
bp::pipe pipe_stdout_;
bp::pipe pipe_stderr_;
bp::child process_;
bool logStderr_;
boost::asio::streambuf streambuf_stderr_;