mod listener;
mod process;
#[cfg(test)]
mod scan_benchmark;
#[cfg(test)]
mod tests;
mod transport;
pub use process::{ChainCanceller, HelperMonitor};
use std::hash::{BuildHasher, RandomState};
use std::io;
use std::path::Path;
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
use interprocess::local_socket::prelude::*;
use plughost_core::PluginRef;
use plughost_core::ipc::shared::{Activity, Caller, transfer};
use plughost_core::ipc::{PROTOCOL_VERSION, Request, Response};
use plughost_core::{FailureKind, HostIdentity};
use crate::errors::Error;
use transport::{Incoming, Stopped, Transport, Unqueued};
const START_TIMEOUT: Duration = Duration::from_secs(30);
const EXIT_TIMEOUT: Duration = Duration::from_secs(2);
const POLL: Duration = Duration::from_millis(5);
#[derive(Clone, Copy)]
pub(crate) enum Mode {
Scan,
Host,
Remote,
}
pub(crate) struct Helper {
child: process::Process,
transport: Transport,
shared: Option<Shared>,
processing: bool,
end_reported: bool,
remote: bool,
}
struct Shared {
activity: Activity,
sender: transfer::Sender,
slots: usize,
}
fn random() -> u64 {
RandomState::new().hash_one((std::process::id(), Instant::now()))
}
impl Helper {
pub fn spawn(path: &Path, mode: Mode) -> Result<Helper, Error> {
Self::spawn_controlled(path, mode, &|| false).map(Option::unwrap)
}
pub fn spawn_controlled(
path: &Path,
mode: Mode,
cancelled: &dyn Fn() -> bool,
) -> Result<Option<Helper>, Error> {
if cancelled() {
return Ok(None);
}
let (shared, stdin) = match mode {
Mode::Host | Mode::Remote => {
let (sender, stdin) = transfer::Sender::new().map_err(Error::HelperStart)?;
let activity = Activity::new().map_err(Error::HelperStart)?;
(
Some(Shared {
activity,
sender,
slots: 0,
}),
stdin,
)
}
Mode::Scan => (None, Stdio::null()),
};
let name = format!("plughost-{:016x}{:016x}.sock", random(), random());
let token = random();
let mut listener = listener::Listener::new(&name).map_err(Error::HelperStart)?;
let mut command = Command::new(path);
if cancelled() {
return Ok(None);
}
command
.arg(match mode {
Mode::Scan => "scan",
Mode::Host => "host",
Mode::Remote => "remote",
})
.arg(&name)
.arg(format!("{token:x}"))
.arg(std::process::id().to_string())
.stdin(stdin)
.stdout(Stdio::null())
.stderr(Stdio::inherit());
let child = process::Process::spawn(&mut command).map_err(Error::HelperStart)?;
let deadline = Instant::now() + START_TIMEOUT;
let stream = loop {
if cancelled() {
let _ = child.kill(FailureKind::Cancelled);
return Ok(None);
}
let remaining = deadline.saturating_duration_since(Instant::now());
match listener.wait(remaining.min(POLL)) {
Ok(true) => {
break listener.accept().map_err(|error| {
let _ = child.kill(FailureKind::Host);
Error::HelperStart(error)
})?;
}
Ok(false) => {
if let Ok(Some(status)) = child.try_wait() {
return Err(Error::Crashed {
slot: None,
status: Some(status),
});
}
if Instant::now() > deadline {
let _ = child.kill(FailureKind::TimedOut);
return Err(Error::TimedOut { slot: None });
}
}
Err(error) => {
let _ = child.kill(FailureKind::Host);
return Err(Error::HelperStart(error));
}
}
};
let transport = match stream
.set_nonblocking(false)
.and_then(|()| Transport::new(stream))
{
Ok(transport) => transport,
Err(error) => {
let _ = child.kill(FailureKind::Host);
return Err(Error::HelperStart(error));
}
};
let mut helper = Helper {
child,
transport,
shared,
processing: false,
end_reported: false,
remote: matches!(mode, Mode::Remote),
};
let error = match helper.message_controlled(START_TIMEOUT, cancelled)? {
Some(Incoming::Hello(hello)) if hello.token == token => {
if hello.protocol == PROTOCOL_VERSION {
return Ok(Some(helper));
}
Error::ProtocolVersion {
application: PROTOCOL_VERSION,
helper: hello.protocol,
}
}
None => return Ok(None),
_ => Error::Handshake,
};
helper.kill(FailureKind::Protocol);
Err(error)
}
pub fn request(&mut self, request: Request<'_>, timeout: Duration) -> Result<Response, Error> {
let slot = request.slot();
if !self.valid_slot(slot) {
return Err(Error::Input {
slot,
error: plughost_core::InputError::Slot,
});
}
let progresses =
self.remote || matches!(request, Request::Load { .. } | Request::PrepareAudio { .. });
self.send(request, timeout)?;
let response = loop {
match self.receive(timeout)? {
Response::Progress if progresses => {}
Response::Progress => {
self.kill(FailureKind::Protocol);
return Err(Error::Protocol);
}
response => break response,
}
};
match response {
Response::Failed { slot, failure } => {
self.check_slot(slot)?;
if failure.kind == FailureKind::Protocol {
self.kill(FailureKind::Protocol);
return Err(Error::Protocol);
}
Err(Error::Operation { slot, failure })
}
Response::Rejected { slot, error } => {
self.check_slot(slot)?;
Err(Error::Input { slot, error })
}
response => Ok(response),
}
}
fn valid_slot(&self, slot: Option<usize>) -> bool {
slot.is_none_or(|slot| {
self.shared
.as_ref()
.is_none_or(|shared| slot < shared.slots)
})
}
fn check_slot(&mut self, slot: Option<usize>) -> Result<(), Error> {
if !self.valid_slot(slot) {
self.kill(FailureKind::Protocol);
return Err(Error::Protocol);
}
Ok(())
}
pub fn load(
&mut self,
host: &HostIdentity,
plugins: &[PluginRef],
timeout: Duration,
) -> Result<Response, Error> {
self.shared.as_mut().ok_or(Error::Protocol)?.slots = plugins.len();
let activity =
self.transfer(|sender, activity, child| sender.send_activity(activity, child))?;
self.request(
Request::Load {
host: host.clone(),
plugins: plugins.to_vec(),
activity,
},
timeout,
)
}
pub fn prepare_shared(
&mut self,
memory: &plughost_core::ipc::shared::SharedAudio,
request: impl FnOnce(u64) -> Request<'static>,
timeout: Duration,
) -> Result<Response, Error> {
let handle = self.transfer(|sender, _, child| sender.send(memory, child))?;
self.request(request(handle), timeout)
}
pub fn install_ring(
&mut self,
ring: &plughost_core::ipc::shared::realtime::Ring,
request: impl FnOnce(Vec<u64>) -> Request<'static>,
timeout: Duration,
) -> Result<Response, Error> {
let tokens = self.transfer(|sender, _, child| sender.send_ring(ring, child))?;
self.request(request(tokens), timeout)
}
fn transfer<T>(
&mut self,
send: impl FnOnce(&transfer::Sender, &Activity, &std::process::Child) -> io::Result<T>,
) -> Result<T, Error> {
let shared = self.shared.as_ref().ok_or(Error::Protocol)?;
match self
.child
.with_child(|child| send(&shared.sender, &shared.activity, child))
{
Ok(handle) => Ok(handle),
Err(_) => Err(self.ended()),
}
}
#[cfg(target_os = "macos")]
pub fn send_channel(&mut self, channel: &std::os::fd::OwnedFd) -> Result<u64, Error> {
self.transfer(|sender, _, child| sender.send_channel(channel, child))
}
pub fn monitor(&self) -> HelperMonitor {
self.child.monitor()
}
pub fn canceller(&self) -> ChainCanceller {
self.child.canceller()
}
pub fn send(&mut self, request: Request<'_>, timeout: Duration) -> Result<(), Error> {
self.send_controlled(request, timeout, &|| false)
.map(Option::unwrap)
}
pub fn send_controlled(
&mut self,
request: Request<'_>,
timeout: Duration,
cancelled: &dyn Fn() -> bool,
) -> Result<Option<()>, Error> {
if cancelled() {
self.kill(FailureKind::Cancelled);
return Ok(None);
}
match self.queue(&request) {
Ok(()) => {}
Err(Unqueued::Unencodable) => {
self.kill(FailureKind::Protocol);
return Err(Error::Protocol);
}
Err(Unqueued::Closed) => return self.ended_controlled(cancelled).map_or(Ok(None), Err),
}
let started = Instant::now();
loop {
if cancelled() {
self.kill(FailureKind::Cancelled);
return Ok(None);
}
let remaining = timeout.saturating_sub(started.elapsed());
match self.transport.flush(remaining.min(POLL)) {
Ok(()) => return Ok(Some(())),
Err(Stopped::TimedOut) if started.elapsed() < timeout => continue,
Err(Stopped::TimedOut) => return Err(self.timed_out()),
Err(Stopped::Closed) => {
return self.ended_controlled(cancelled).map_or(Ok(None), Err);
}
}
}
}
fn queue(&mut self, request: &Request<'_>) -> Result<(), Unqueued> {
self.processing = matches!(request, Request::Process { .. });
#[cfg(target_os = "windows")]
if matches!(
&request,
Request::OpenEditor { .. }
| Request::Scan {
interactive: true,
..
}
) {
unsafe {
windows_sys::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow(
self.child.id(),
)
};
}
self.transport.queue(request)
}
pub fn receive(&mut self, timeout: Duration) -> Result<Response, Error> {
match self.message(timeout)? {
Incoming::Response(response) => Ok(response),
Incoming::Hello(_) => {
self.kill(FailureKind::Protocol);
Err(Error::Protocol)
}
}
}
pub fn receive_controlled(
&mut self,
timeout: Duration,
cancelled: &dyn Fn() -> bool,
) -> Result<Option<Response>, Error> {
match self.message_controlled(timeout, cancelled)? {
Some(Incoming::Response(response)) => Ok(Some(response)),
Some(Incoming::Hello(_)) => {
self.kill(FailureKind::Protocol);
Err(Error::Protocol)
}
None => Ok(None),
}
}
fn culprit(&mut self) -> Result<Option<usize>, Error> {
let Some(shared) = &self.shared else {
return Ok(None);
};
let activity = &shared.activity;
let (first, second) = if self.processing {
(Caller::Processing, Caller::Main)
} else {
(Caller::Main, Caller::Processing)
};
let (first, second) = (activity.slot(first), activity.slot(second));
if !self.valid_slot(first) || !self.valid_slot(second) {
self.kill(FailureKind::Protocol);
self.shared = None;
return Err(Error::Protocol);
}
Ok(first.or(second))
}
fn message_controlled(
&mut self,
timeout: Duration,
cancelled: &dyn Fn() -> bool,
) -> Result<Option<Incoming>, Error> {
let started = Instant::now();
loop {
if cancelled() {
self.kill(FailureKind::Cancelled);
return Ok(None);
}
let remaining = timeout.saturating_sub(started.elapsed());
match self.transport.receive(remaining.min(POLL)) {
Ok(Ok(message)) => return Ok(Some(message)),
Err(Stopped::TimedOut) if started.elapsed() < timeout => continue,
Err(Stopped::TimedOut) => return Err(self.timed_out()),
Ok(Err(error)) if error.kind() == io::ErrorKind::InvalidData => {
self.kill(FailureKind::Protocol);
return Err(Error::Protocol);
}
_ => return self.ended_controlled(cancelled).map_or(Ok(None), Err),
}
}
}
fn message(&mut self, timeout: Duration) -> Result<Incoming, Error> {
match self.transport.receive(timeout) {
Ok(Ok(message)) => Ok(message),
Err(Stopped::TimedOut) => Err(self.timed_out()),
Ok(Err(error)) if error.kind() == io::ErrorKind::InvalidData => {
self.kill(FailureKind::Protocol);
Err(Error::Protocol)
}
_ => Err(self.ended()),
}
}
fn timed_out(&mut self) -> Error {
let cancelled = !self.end_reported;
self.kill(FailureKind::TimedOut);
let by_canceller =
cancelled && self.child.monitor().end_reason() == Some(FailureKind::Cancelled);
match self.culprit() {
Ok(slot) if by_canceller => Error::Cancelled { slot },
Ok(slot) => Error::TimedOut { slot },
Err(error) => error,
}
}
fn ended(&mut self) -> Error {
self.ended_controlled(&|| false).unwrap()
}
fn ended_controlled(&mut self, cancelled: &dyn Fn() -> bool) -> Option<Error> {
let deadline = Instant::now() + EXIT_TIMEOUT;
let monitor = self.child.monitor();
let status = loop {
if cancelled() {
self.kill(FailureKind::Cancelled);
return None;
}
let remaining = deadline.saturating_duration_since(Instant::now());
if let Some(status) = monitor.wait_for_exit(remaining.min(POLL)) {
break Some(status);
}
if remaining.is_zero() {
self.kill(FailureKind::Crashed);
break None;
}
};
let by_canceller =
!self.end_reported && monitor.end_reason() == Some(FailureKind::Cancelled);
self.end_reported = true;
self.transport.close();
Some(match self.culprit() {
Ok(slot) if by_canceller => Error::Cancelled { slot },
Ok(slot) => Error::Crashed { slot, status },
Err(error) => error,
})
}
pub fn kill(&mut self, reason: FailureKind) {
let _ = self.child.kill(reason);
self.end_reported = true;
self.transport.close();
}
}
impl Drop for Helper {
fn drop(&mut self) {
self.child.expect_exit(FailureKind::Closed);
if self.transport.queue(&Request::Shutdown).is_ok()
&& self.transport.flush(EXIT_TIMEOUT).is_ok()
{
self.child.monitor().wait_for_exit(EXIT_TIMEOUT);
}
self.kill(FailureKind::Closed);
}
}