summaryrefslogtreecommitdiffhomepage
path: root/src/process
diff options
context:
space:
mode:
Diffstat (limited to 'src/process')
-rw-r--r--src/process/mod.rs31
-rw-r--r--src/process/monitor.rs267
-rw-r--r--src/process/openvpn.rs310
3 files changed, 0 insertions, 608 deletions
diff --git a/src/process/mod.rs b/src/process/mod.rs
deleted file mode 100644
index 3259f90524..0000000000
--- a/src/process/mod.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use std::io;
-
-use std::process::{ChildStderr, ChildStdout};
-
-/// A module for monitoring child processes and get notified of events on them.
-pub mod monitor;
-use self::monitor::MonitoredChild;
-
-/// A module for all OpenVPN related process management.
-pub mod openvpn;
-
-use clonablechild::ClonableChild;
-
-
-impl MonitoredChild for ClonableChild {
- fn wait(&self) -> io::Result<bool> {
- ClonableChild::wait(self).map(|exit_status| exit_status.success())
- }
-
- fn kill(&self) -> io::Result<()> {
- ClonableChild::kill(self)
- }
-
- fn stdout(&mut self) -> Option<ChildStdout> {
- self.stdout()
- }
-
- fn stderr(&mut self) -> Option<ChildStderr> {
- self.stderr()
- }
-}
diff --git a/src/process/monitor.rs b/src/process/monitor.rs
deleted file mode 100644
index 3a6f9fb65f..0000000000
--- a/src/process/monitor.rs
+++ /dev/null
@@ -1,267 +0,0 @@
-use std::io;
-use std::process::{ChildStdout, ChildStderr};
-use std::sync::{Arc, Mutex};
-use std::thread;
-
-
-error_chain! {
- errors {
- /// The transition could not be made because the state machine was not in a state that
- /// could transition to the desired state.
- InvalidState {
- description("Invalid state for desired transition")
- }
- /// Error representing a failure in spawning the child process
- Spawn {
- description("Unable to spawn child process")
- }
- /// Error representing a failure in sending a kill signal to the child process
- Kill {
- description("Unable to send kill signal to process")
- }
- }
-}
-
-/// Trait for objects that represent child processes that `ChildMonitor` can monitor
-pub trait MonitoredChild: Clone + Send + 'static {
- /// Waits for the child to exit completely, returning if the child exited cleanly or not.
- fn wait(&self) -> io::Result<bool>;
-
- /// Forces the child to exit.
- fn kill(&self) -> io::Result<()>;
-
- /// Retreives the stdout stream for the child.
- fn stdout(&mut self) -> Option<ChildStdout>;
-
- /// Retreives the stderr stream for the child.
- fn stderr(&mut self) -> Option<ChildStderr>;
-}
-
-/// Trait for objects that can spawn any type of child process object implementing `MonitoredChild`.
-pub trait ChildSpawner: Send + 'static {
- /// The type of child being spawned.
- type Child: MonitoredChild;
-
- /// Spawns the child process, returning a handle to it on success.
- fn spawn(&mut self) -> io::Result<Self::Child>;
-}
-
-
-enum State<C: MonitoredChild> {
- Stopped,
- Running(RunningState<C>),
-}
-
-struct RunningState<C: MonitoredChild> {
- child: C,
- thread_handle: Option<thread::JoinHandle<()>>,
-}
-
-/// A child process monitor. Takes care of starting and monitoring a child process and runs the
-/// listener on child exit.
-pub struct ChildMonitor<S: ChildSpawner> {
- spawner: S,
- state: Arc<Mutex<State<S::Child>>>,
-}
-
-impl<S: ChildSpawner> ChildMonitor<S> {
- /// Creates a new `ChildMonitor` that spawns processes with the given `spawner`. The new
- /// `ChildMonitor` will be in the stopped state and not start any process until you call
- /// `start()`.
- pub fn new(spawner: S) -> Self {
- ChildMonitor {
- spawner: spawner,
- state: Arc::new(Mutex::new(State::Stopped)),
- }
- }
-
- /// Starts the child process and begins to monitor it. `listener` will be called as soon as the
- /// child process exits.
- pub fn start<L>(&mut self, listener: L) -> Result<(Option<ChildStdout>, Option<ChildStderr>)>
- where L: FnMut(bool) + Send + 'static
- {
- let mut state_lock = self.state.lock().unwrap();
- if let State::Stopped = *state_lock {
- let mut child = self.spawner.spawn().chain_err(|| ErrorKind::Spawn)?;
- let io = (child.stdout(), child.stderr());
- let thread_handle = self.spawn_monitor(child.clone(), listener);
- *state_lock = State::Running(RunningState {
- child: child,
- thread_handle: Some(thread_handle),
- });
- Ok(io)
- } else {
- bail!(ErrorKind::InvalidState);
- }
- }
-
- fn spawn_monitor<L>(&self, child: S::Child, mut listener: L) -> thread::JoinHandle<()>
- where L: FnMut(bool) + Send + 'static
- {
- let state_mutex = self.state.clone();
- thread::spawn(move || {
- let success = child.wait().unwrap_or(false);
- {
- let mut state_lock = state_mutex.lock().unwrap();
- *state_lock = State::Stopped;
- }
- listener(success);
- })
- }
-
- /// Sends a kill signal to the child process.
- pub fn stop(&self) -> Result<()> {
- let state_lock = self.state.lock().unwrap();
- if let State::Running(ref running_state) = *state_lock {
- running_state.child.kill().chain_err(|| ErrorKind::Kill)?;
- Ok(())
- } else {
- bail!(ErrorKind::InvalidState);
- }
- }
-}
-
-impl<S: ChildSpawner> Drop for ChildMonitor<S> {
- fn drop(&mut self) {
- let thread_handle = {
- let mut state_lock = self.state.lock().unwrap();
- if let State::Running(ref mut state) = *state_lock {
- let _ = state.child.kill();
- state.thread_handle.take()
- } else {
- None
- }
- };
- if let Some(thread_handle) = thread_handle {
- let _ = thread_handle.join();
- }
- }
-}
-
-
-#[cfg(test)]
-mod child_monitor_tests {
- use super::*;
- use std::io;
- use std::process::{ChildStdout, ChildStderr};
- use std::sync::{Arc, Mutex};
- use std::sync::mpsc;
- use std::thread;
- use std::time::Duration;
-
- #[derive(Clone)]
- struct MockChild {
- died: Arc<Mutex<bool>>,
- }
-
- impl MockChild {
- pub fn instant_exit() -> Self {
- Self::new(true)
- }
-
- pub fn alive_until_kill() -> Self {
- Self::new(false)
- }
-
- fn new(died: bool) -> Self {
- MockChild { died: Arc::new(Mutex::new(died)) }
- }
- }
-
- impl MonitoredChild for MockChild {
- fn wait(&self) -> io::Result<bool> {
- loop {
- if *self.died.lock().unwrap() {
- break;
- }
- thread::sleep(Duration::new(0, 1_000_000));
- }
- Ok(true)
- }
-
- fn kill(&self) -> io::Result<()> {
- *self.died.lock().unwrap() = true;
- Ok(())
- }
-
- fn stdout(&mut self) -> Option<ChildStdout> {
- None
- }
-
- fn stderr(&mut self) -> Option<ChildStderr> {
- None
- }
- }
-
- struct MockChildSpawner {
- spawn_result: Option<MockChild>,
- }
-
- impl MockChildSpawner {
- pub fn new(spawn_result: Option<MockChild>) -> Self {
- MockChildSpawner { spawn_result: spawn_result }
- }
- }
-
- impl ChildSpawner for MockChildSpawner {
- type Child = MockChild;
-
- fn spawn(&mut self) -> io::Result<MockChild> {
- self.spawn_result
- .clone()
- .ok_or(io::Error::new(io::ErrorKind::Other, "Mocking a failed process spawn"))
- }
- }
-
- /// Tries to recv a message from the given `$rx` for one second and tries to match it with the
- /// given expected value, `$expected`
- macro_rules! assert_event {
- ($rx:ident, $expected:pat) => {{
- let result = $rx.recv_timeout(Duration::new(1, 0));
- assert_matches!(result, $expected);
- }}
- }
-
- #[test]
- fn normal_start() {
- let spawner = MockChildSpawner::new(Some(MockChild::instant_exit()));
- let mut testee = ChildMonitor::new(spawner);
-
- let (tx, rx) = mpsc::channel();
- assert!(testee.start(move |success| tx.send(success).unwrap()).is_ok());
- assert_event!(rx, Ok(true));
- }
-
- #[test]
- fn start_failed() {
- let spawner = MockChildSpawner::new(None);
- let mut testee = ChildMonitor::new(spawner);
-
- let (tx, rx) = mpsc::channel();
- assert!(testee.start(move |success| tx.send(success).unwrap()).is_err());
- // Make sure that the listener is not kept anywhere. Failing to start should drop the
- // listener
- assert_event!(rx, Err(mpsc::RecvTimeoutError::Disconnected));
- }
-
- #[test]
- fn normal_stop() {
- let spawner = MockChildSpawner::new(Some(MockChild::alive_until_kill()));
- let mut testee = ChildMonitor::new(spawner);
-
- let (tx, rx) = mpsc::channel();
- assert!(testee.start(move |success| tx.send(success).unwrap()).is_ok());
- assert_event!(rx, Err(mpsc::RecvTimeoutError::Timeout));
-
- assert!(testee.stop().is_ok());
- assert_event!(rx, Ok(true));
- }
-
- #[test]
- fn stop_without_start() {
- let spawner = MockChildSpawner::new(Some(MockChild::alive_until_kill()));
- let testee = ChildMonitor::new(spawner);
-
- assert_matches!(testee.stop(), Err(Error(ErrorKind::InvalidState, _)));
- }
-}
diff --git a/src/process/openvpn.rs b/src/process/openvpn.rs
deleted file mode 100644
index e002d2b9c3..0000000000
--- a/src/process/openvpn.rs
+++ /dev/null
@@ -1,310 +0,0 @@
-extern crate openvpn_ffi;
-
-use super::monitor::{ChildSpawner, ChildMonitor};
-
-use clonablechild::{ClonableChild, ChildExt};
-
-use net::{RemoteAddr, ToRemoteAddrs};
-
-use std::collections::HashMap;
-use std::ffi::{OsString, OsStr};
-use std::fmt;
-use std::io;
-use std::ops::DerefMut;
-use std::path::{Path, PathBuf};
-use std::process::{Command, Child, Stdio, ChildStdout, ChildStderr};
-use std::sync::{Arc, Mutex};
-
-use talpid_ipc;
-
-error_chain!{
- errors {
- /// Error while communicating with the OpenVPN plugin
- PluginCommunicationError
- }
- links {
- ChildMonitorError(::process::monitor::Error, ::process::monitor::ErrorKind)
- #[doc="Something went wrong in the underlying ChildMonitor"];
- }
-}
-
-/// An OpenVPN process builder, providing control over the different arguments that the OpenVPN
-/// binary accepts.
-#[derive(Clone)]
-pub struct OpenVpnCommand {
- openvpn_bin: OsString,
- config: Option<PathBuf>,
- remotes: Vec<RemoteAddr>,
- plugin: Option<(PathBuf, Vec<String>)>,
- pipe_output: bool,
-}
-
-impl OpenVpnCommand {
- /// Constructs a new `OpenVpnCommand` for launching OpenVPN processes from the binary at
- /// `openvpn_bin`.
- pub fn new<P: AsRef<OsStr>>(openvpn_bin: P) -> Self {
- OpenVpnCommand {
- openvpn_bin: OsString::from(openvpn_bin.as_ref()),
- config: None,
- remotes: vec![],
- plugin: None,
- pipe_output: true,
- }
- }
-
- /// Sets what configuration file will be given to OpenVPN
- pub fn config<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
- self.config = Some(path.as_ref().to_path_buf());
- self
- }
-
- /// Sets the addresses that OpenVPN will connect to. See OpenVPN documentation for how multiple
- /// remotes are handled.
- pub fn remotes<A: ToRemoteAddrs>(&mut self, remotes: A) -> io::Result<&mut Self> {
- self.remotes = remotes.to_remote_addrs()?.collect();
- Ok(self)
- }
-
- /// Sets a plugin and its arguments that OpenVPN will be started with.
- pub fn plugin<P: AsRef<Path>>(&mut self, path: P, args: Vec<String>) -> &mut Self {
- self.plugin = Some((path.as_ref().to_path_buf(), args));
- self
- }
-
- /// If piping the standard streams, stdout and stderr will be available to the parent process.
- /// This is the default behavior. If you want the equivalence of attaching the child streams to
- /// /dev/null, invoke this method with false.
- pub fn pipe_output(&mut self, pipe_output: bool) -> &mut Self {
- self.pipe_output = pipe_output;
- self
- }
-
- /// Executes the OpenVPN process as a child process, returning a handle to it.
- pub fn spawn(&self) -> io::Result<Child> {
- let mut command = self.create_command();
- let args = self.get_arguments();
- command.args(&args);
- debug!("Spawning: {}", &self);
- command.spawn()
- }
-
- fn create_command(&self) -> Command {
- let mut command = Command::new(&self.openvpn_bin);
- command.stdin(Stdio::null())
- .stdout(self.get_output_pipe_policy())
- .stderr(self.get_output_pipe_policy());
- command
- }
-
- fn get_output_pipe_policy(&self) -> Stdio {
- if self.pipe_output {
- Stdio::piped()
- } else {
- Stdio::null()
- }
- }
-
- /// Returns all arguments that the subprocess would be spawned with.
- pub fn get_arguments(&self) -> Vec<OsString> {
- let mut args = vec![];
- if let Some(ref config) = self.config {
- args.push(OsString::from("--config"));
- args.push(OsString::from(config.as_os_str()));
- }
- for remote in &self.remotes {
- args.push(OsString::from("--remote"));
- args.push(OsString::from(remote.address()));
- args.push(OsString::from(remote.port().to_string()));
- }
- if let Some((ref path, ref plugin_args)) = self.plugin {
- args.push(OsString::from("--plugin"));
- args.push(OsString::from(path));
- args.extend(plugin_args.iter().map(OsString::from));
- }
- args
- }
-}
-
-impl fmt::Display for OpenVpnCommand {
- /// Format the program and arguments of an `OpenVpnCommand` for display. Any non-utf8 data is
- /// lossily converted using the utf8 replacement character.
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.write_str(&self.openvpn_bin.to_string_lossy())?;
- for arg in self.get_arguments().iter().map(|arg| arg.to_string_lossy()) {
- write_argument(fmt, &arg)?;
- }
- Ok(())
- }
-}
-
-fn write_argument(fmt: &mut fmt::Formatter, arg: &str) -> fmt::Result {
- fmt.write_str(" ")?;
- let quote = arg.contains(char::is_whitespace);
- if quote {
- fmt.write_str("\"")?;
- }
- fmt.write_str(arg)?;
- if quote {
- fmt.write_str("\"")?;
- }
- Ok(())
-}
-
-
-impl ChildSpawner for OpenVpnCommand {
- type Child = ClonableChild;
-
- fn spawn(&mut self) -> io::Result<ClonableChild> {
- OpenVpnCommand::spawn(self).map(|child| child.into_clonable())
- }
-}
-
-
-/// Possible events from OpenVPN
-pub enum OpenVpnEvent {
- /// An event from the plugin loaded into OpenVPN.
- PluginEvent(Result<(openvpn_ffi::OpenVpnPluginEvent, HashMap<String, String>)>),
- /// The OpenVPN process exited. The bool indicates if the process exited cleanly.
- Shutdown(bool),
-}
-
-/// A struct able to start and monitor OpenVPN processes.
-pub struct OpenVpnMonitor {
- command: OpenVpnCommand,
- plugin_path: PathBuf,
- monitor: ChildMonitor<OpenVpnCommand>,
-}
-
-impl OpenVpnMonitor {
- /// Creates a new `OpenVpnMonitor` based on the given command
- pub fn new<P: AsRef<Path>>(command: OpenVpnCommand, plugin_path: P) -> Self {
- OpenVpnMonitor {
- command: command.clone(),
- plugin_path: plugin_path.as_ref().to_path_buf(),
- monitor: ChildMonitor::new(command),
- }
- }
-
- /// Starts OpenVPN and begins to monitor it.
- pub fn start<L>(&mut self, listener: L) -> Result<(Option<ChildStdout>, Option<ChildStderr>)>
- where L: FnMut(OpenVpnEvent) + Send + 'static
- {
- let shared_listener = Arc::new(Mutex::new(listener));
- self.start_plugin_listener(shared_listener.clone())?;
- self.start_child_monitor(shared_listener)
- }
-
- fn start_plugin_listener<L>(&mut self, shared_listener: Arc<Mutex<L>>) -> Result<()>
- where L: FnMut(OpenVpnEvent) + Send + 'static
- {
- let server_id = talpid_ipc::start_new_server(move |msg| {
- let chained_msg = msg.chain_err(|| ErrorKind::PluginCommunicationError);
- let mut listener = shared_listener.lock().unwrap();
- (listener.deref_mut())(OpenVpnEvent::PluginEvent(chained_msg));
- }).chain_err(|| ErrorKind::PluginCommunicationError)?;
- self.command.plugin(&self.plugin_path, vec![server_id]);
- Ok(())
- }
-
- fn start_child_monitor<L>(&mut self,
- shared_listener: Arc<Mutex<L>>)
- -> Result<(Option<ChildStdout>, Option<ChildStderr>)>
- where L: FnMut(OpenVpnEvent) + Send + 'static
- {
- let callback = move |clean_exit| {
- let mut listener = shared_listener.lock().unwrap();
- (listener.deref_mut())(OpenVpnEvent::Shutdown(clean_exit));
- };
-
- self.monitor = ChildMonitor::new(self.command.clone());
- Ok(self.monitor.start(callback)?)
- }
-
- /// Forwards a stop call to the underlying `ChildMonitor`.
- pub fn stop(&self) -> Result<()> {
- Ok(self.monitor.stop()?)
- }
-}
-
-
-#[cfg(test)]
-mod openvpn_command_tests {
- use super::OpenVpnCommand;
- use net::RemoteAddr;
- use std::ffi::OsString;
-
- #[test]
- fn no_arguments() {
- let testee_args = OpenVpnCommand::new("").get_arguments();
- assert_eq!(0, testee_args.len());
- }
-
- #[test]
- fn passes_one_remote() {
- let remote = RemoteAddr::new("example.com", 3333);
-
- let testee_args = OpenVpnCommand::new("").remotes(remote).unwrap().get_arguments();
-
- assert!(testee_args.contains(&OsString::from("example.com")));
- assert!(testee_args.contains(&OsString::from("3333")));
- }
-
- #[test]
- fn passes_two_remotes() {
- let remotes = vec![RemoteAddr::new("127.0.0.1", 998), RemoteAddr::new("fe80::1", 1337)];
-
- let testee_args = OpenVpnCommand::new("").remotes(&remotes[..]).unwrap().get_arguments();
-
- assert!(testee_args.contains(&OsString::from("127.0.0.1")));
- assert!(testee_args.contains(&OsString::from("998")));
- assert!(testee_args.contains(&OsString::from("fe80::1")));
- assert!(testee_args.contains(&OsString::from("1337")));
- }
-
- #[test]
- fn accepts_str() {
- assert!(OpenVpnCommand::new("").remotes("10.0.0.1:1377").is_ok());
- }
-
- #[test]
- fn accepts_slice_of_str() {
- let remotes = ["10.0.0.1:1337", "127.0.0.1:99"];
-
- let testee_args = OpenVpnCommand::new("").remotes(&remotes[..]).unwrap().get_arguments();
-
- assert!(testee_args.contains(&OsString::from("10.0.0.1")));
- assert!(testee_args.contains(&OsString::from("1337")));
- assert!(testee_args.contains(&OsString::from("127.0.0.1")));
- assert!(testee_args.contains(&OsString::from("99")));
- }
-
- #[test]
- fn passes_plugin_path() {
- let path = "./a/path";
- let testee_args = OpenVpnCommand::new("").plugin(path, vec![]).get_arguments();
- assert!(testee_args.contains(&OsString::from("./a/path")));
- }
-
- #[test]
- fn passes_plugin_args() {
- let args = vec![String::from("123"), String::from("cde")];
- let testee_args = OpenVpnCommand::new("").plugin("", args).get_arguments();
- assert!(testee_args.contains(&OsString::from("123")));
- assert!(testee_args.contains(&OsString::from("cde")));
- }
-}
-
-
-#[cfg(test)]
-mod openvpn_monitor_tests {
- use super::*;
-
- #[test]
- fn stop_without_start() {
- let command = OpenVpnCommand::new("");
- let testee = OpenVpnMonitor::new(command, "");
-
- use super::super::monitor::ErrorKind::InvalidState as MInvalidState;
- assert_matches!(testee.stop(), Err(Error(ErrorKind::ChildMonitorError(MInvalidState), _)));
- }
-}
Copyright © 2025 - 2026 Wayne Cole. WTFPL. Attribution appreciated. No warranty. Not liable for bodily damages.