feat(M7.2): own the local server socket

Add a same-user 0600 Unix listener with stale-socket recovery, one-instance detection, bounded client timeouts, correlated responses, and a Pulse-backed server loop.

Tests: cargo test -p fader_master --all-targets --all-features --locked

Tests: cargo clippy -p fader_master --all-targets --all-features --locked -- -D warnings
This commit is contained in:
Dandaedre 2026-10-15 00:13:30 +02:00
parent a01e451643
commit 3b318256bf
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
4 changed files with 351 additions and 0 deletions

View File

@ -13,8 +13,12 @@ clap.workspace = true
fader-config.workspace = true
fader-core.workspace = true
midi.workspace = true
rustix.workspace = true
serde.workspace = true
thiserror.workspace = true
toml.workspace = true
tui.workspace = true
volume_lib.workspace = true
[dev-dependencies]
tempfile.workspace = true

View File

@ -5,6 +5,7 @@
pub mod cli;
pub mod ipc;
pub mod live;
pub mod local;
use std::{collections::BTreeMap, error::Error, fmt};

266
fader_master/src/local.rs Normal file
View File

@ -0,0 +1,266 @@
use std::{
fs, io,
os::unix::{
fs::{FileTypeExt, MetadataExt, PermissionsExt},
net::{UnixListener, UnixStream},
},
path::{Path, PathBuf},
sync::mpsc::RecvTimeoutError,
time::Duration,
};
use fader_config::{XdgEnvironment, XdgPaths};
use fader_core::{BackendEpoch, Gain};
use thiserror::Error;
use volume_lib::PulseWorker;
use crate::{
ipc::{
ClientRequest, PROTOCOL_VERSION, ResponseResult, ServerResponse, read_frame, write_frame,
},
live::LiveMixerState,
};
const CLIENT_TIMEOUT: Duration = Duration::from_millis(500);
const SERVER_TICK: Duration = Duration::from_millis(10);
#[derive(Debug, Error)]
pub enum LocalError {
#[error("XDG_RUNTIME_DIR is required for the local server socket")]
MissingRuntimeDirectory,
#[error("another fader_master server is already listening at {0}")]
AlreadyRunning(PathBuf),
#[error("refusing unsafe server socket {path}: {reason}")]
UnsafeSocket { path: PathBuf, reason: String },
#[error("local socket operation failed for {path}: {source}")]
Socket {
path: PathBuf,
#[source]
source: io::Error,
},
#[error(transparent)]
Frame(#[from] crate::ipc::FrameError),
#[error("server response request ID {actual} does not match {expected}")]
RequestId { actual: u64, expected: u64 },
#[error("server protocol version {actual} does not match {expected}")]
Protocol { actual: u16, expected: u16 },
#[error("audio worker command lane is unavailable or full")]
WorkerCommand,
#[error("audio worker event lane disconnected")]
WorkerDisconnected,
#[error(transparent)]
Mixer(#[from] crate::live::LiveMixerError),
#[error(transparent)]
Config(#[from] fader_config::ConfigError),
}
pub fn default_socket_path() -> Result<PathBuf, LocalError> {
let environment = XdgEnvironment::from_process()?;
let paths = XdgPaths::resolve(&environment)?;
let directory = paths
.runtime_dir()
.ok_or(LocalError::MissingRuntimeDirectory)?;
Ok(directory.join("control.sock"))
}
/// One-instance listener that removes only its own socket on orderly drop.
#[derive(Debug)]
pub struct OwnedListener {
listener: UnixListener,
path: PathBuf,
}
impl OwnedListener {
pub fn bind(path: impl Into<PathBuf>) -> Result<Self, LocalError> {
let path = path.into();
if path.exists() {
match UnixStream::connect(&path) {
Ok(_) => return Err(LocalError::AlreadyRunning(path)),
Err(_) => remove_stale_socket(&path)?,
}
}
let listener = UnixListener::bind(&path).map_err(|source| LocalError::Socket {
path: path.clone(),
source,
})?;
fs::set_permissions(&path, fs::Permissions::from_mode(0o600)).map_err(|source| {
LocalError::Socket {
path: path.clone(),
source,
}
})?;
listener
.set_nonblocking(true)
.map_err(|source| LocalError::Socket {
path: path.clone(),
source,
})?;
Ok(Self { listener, path })
}
pub fn accept(&self) -> Result<Option<UnixStream>, LocalError> {
match self.listener.accept() {
Ok((stream, _)) => Ok(Some(stream)),
Err(error) if error.kind() == io::ErrorKind::WouldBlock => Ok(None),
Err(source) => Err(LocalError::Socket {
path: self.path.clone(),
source,
}),
}
}
#[must_use]
pub fn path(&self) -> &Path {
&self.path
}
}
impl Drop for OwnedListener {
fn drop(&mut self) {
let _ = fs::remove_file(&self.path);
}
}
/// Sends one bounded request and waits for its corresponding response.
pub fn client_request(
socket: &Path,
request: &ClientRequest,
) -> Result<ServerResponse, LocalError> {
validate_socket(socket)?;
let mut stream = UnixStream::connect(socket).map_err(|source| LocalError::Socket {
path: socket.to_owned(),
source,
})?;
stream
.set_read_timeout(Some(CLIENT_TIMEOUT))
.and_then(|()| stream.set_write_timeout(Some(CLIENT_TIMEOUT)))
.map_err(|source| LocalError::Socket {
path: socket.to_owned(),
source,
})?;
write_frame(&mut stream, request)?;
let response: ServerResponse = read_frame(&mut stream)?;
if response.version != PROTOCOL_VERSION {
return Err(LocalError::Protocol {
actual: response.version,
expected: PROTOCOL_VERSION,
});
}
if response.request_id != request.request_id {
return Err(LocalError::RequestId {
actual: response.request_id,
expected: request.request_id,
});
}
Ok(response)
}
/// Persistent local server joining the Pulse owner thread on drop.
#[derive(Debug)]
pub struct LocalServer {
listener: OwnedListener,
worker: PulseWorker,
mixer: LiveMixerState,
}
impl LocalServer {
pub fn pulse(socket: impl Into<PathBuf>, write_ceiling: Gain) -> Result<Self, LocalError> {
Ok(Self {
listener: OwnedListener::bind(socket)?,
worker: PulseWorker::spawn(BackendEpoch::new(1), 256),
mixer: LiveMixerState::new(write_ceiling, "pulse"),
})
}
/// Runs until process termination or a fatal worker/socket error.
pub fn run(&mut self) -> Result<(), LocalError> {
loop {
self.tick()?;
}
}
pub fn tick(&mut self) -> Result<(), LocalError> {
match self.worker.receive_timeout(SERVER_TICK) {
Ok(event) => {
let commands = self.mixer.worker_event(event)?;
self.submit(commands)?;
}
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => return Err(LocalError::WorkerDisconnected),
}
while let Some(mut client) = self.listener.accept()? {
let _ = client.set_read_timeout(Some(CLIENT_TIMEOUT));
let _ = client.set_write_timeout(Some(CLIENT_TIMEOUT));
if let Err(error) = self.serve_client(&mut client)
&& matches!(error, LocalError::WorkerCommand)
{
return Err(error);
}
}
Ok(())
}
fn serve_client(&mut self, stream: &mut UnixStream) -> Result<(), LocalError> {
let request: ClientRequest = read_frame(stream)?;
let request_id = request.request_id;
let response = match self.mixer.request(request) {
Ok((response, commands)) => {
self.submit(commands)?;
response
}
Err(error) => ServerResponse {
version: PROTOCOL_VERSION,
request_id,
result: ResponseResult::Error {
message: error.to_string(),
resync: true,
},
},
};
write_frame(stream, &response)?;
Ok(())
}
fn submit(&self, commands: Vec<fader_core::AdapterCommand>) -> Result<(), LocalError> {
for command in commands {
self.worker
.try_submit(command)
.map_err(|_| LocalError::WorkerCommand)?;
}
Ok(())
}
}
fn validate_socket(path: &Path) -> Result<(), LocalError> {
let metadata = fs::symlink_metadata(path).map_err(|source| LocalError::Socket {
path: path.to_owned(),
source,
})?;
if !metadata.file_type().is_socket() {
return Err(LocalError::UnsafeSocket {
path: path.to_owned(),
reason: "path is not a Unix socket".to_owned(),
});
}
if metadata.uid() != rustix::process::getuid().as_raw() {
return Err(LocalError::UnsafeSocket {
path: path.to_owned(),
reason: "socket is owned by another user".to_owned(),
});
}
if metadata.mode() & 0o777 != 0o600 {
return Err(LocalError::UnsafeSocket {
path: path.to_owned(),
reason: "socket permissions must be 0600".to_owned(),
});
}
Ok(())
}
fn remove_stale_socket(path: &Path) -> Result<(), LocalError> {
validate_socket(path)?;
fs::remove_file(path).map_err(|source| LocalError::Socket {
path: path.to_owned(),
source,
})
}

View File

@ -0,0 +1,80 @@
use std::{
fs,
os::unix::fs::{FileTypeExt, PermissionsExt},
thread,
};
use fader_master::{
ipc::{ClientRequest, PROTOCOL_VERSION, RequestCommand, ResponseResult, ServerResponse},
local::{LocalError, OwnedListener, client_request},
};
#[test]
fn listener_is_private_and_prevents_a_second_server() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("control.sock");
let listener = OwnedListener::bind(&path).unwrap();
let metadata = fs::metadata(&path).unwrap();
assert!(metadata.file_type().is_socket());
assert_eq!(metadata.permissions().mode() & 0o777, 0o600);
assert!(matches!(
OwnedListener::bind(&path),
Err(LocalError::AlreadyRunning(_))
));
drop(listener);
assert!(!path.exists());
}
#[test]
fn client_rejects_a_socket_with_wrong_permissions() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("control.sock");
let listener = OwnedListener::bind(&path).unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o666)).unwrap();
let request = ClientRequest {
version: PROTOCOL_VERSION,
request_id: 1,
command: RequestCommand::Snapshot,
};
assert!(matches!(
client_request(&path, &request),
Err(LocalError::UnsafeSocket { .. })
));
drop(listener);
}
#[test]
fn client_validates_correlated_versioned_response() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("control.sock");
let listener = OwnedListener::bind(&path).unwrap();
let request = ClientRequest {
version: PROTOCOL_VERSION,
request_id: 77,
command: RequestCommand::Snapshot,
};
let server = thread::spawn(move || {
loop {
if let Some(mut stream) = listener.accept().unwrap() {
let received: ClientRequest = fader_master::ipc::read_frame(&mut stream).unwrap();
fader_master::ipc::write_frame(
&mut stream,
&ServerResponse {
version: PROTOCOL_VERSION,
request_id: received.request_id,
result: ResponseResult::Error {
message: "fixture".into(),
resync: false,
},
},
)
.unwrap();
break;
}
thread::yield_now();
}
});
let response = client_request(&path, &request).unwrap();
assert_eq!(response.request_id, 77);
server.join().unwrap();
}