use super::Seat;
use interprocess::ConnectWaitMode;
use interprocess::local_socket::prelude::*;
use interprocess::local_socket::{ConnectOptions, Listener, ListenerOptions, Name, Stream};
use std::io;
use std::time::Duration;
pub const SOCKET_ENV: &str = "SEFY_AGENT_SOCKET";
pub(super) const PATIENCE: Duration = Duration::from_secs(30);
#[derive(Debug, Clone)]
pub(super) struct Address(String);
impl Address {
pub(super) fn of(seat: Seat) -> Option<Self> {
let base = std::env::var(SOCKET_ENV)
.ok()
.filter(|base| !base.is_empty());
match base {
Some(base) => Some(Self(format!("{base}-{}", seat.name()))),
None => standard(seat).map(Self),
}
}
}
#[cfg(windows)]
fn standard(seat: Seat) -> Option<String> {
Some(match std::env::var("USERNAME") {
Ok(user) if !user.is_empty() => format!("sefy-{}-{user}", seat.name()),
_ => format!("sefy-{}", seat.name()),
})
}
#[cfg(unix)]
fn standard(seat: Seat) -> Option<String> {
let runtime = std::env::var_os("XDG_RUNTIME_DIR")
.map(std::path::PathBuf::from)
.filter(|path| path.is_absolute())
.map(|path| path.join("sefy-agent"));
let directory = runtime
.or_else(|| crate::plugin::data_directory().map(|path| path.join("sefy").join("agent")))?;
directory
.join(format!("{}.sock", seat.name()))
.to_str()
.map(str::to_owned)
}
#[cfg(windows)]
fn name(address: &Address) -> io::Result<Name<'_>> {
use interprocess::local_socket::GenericNamespaced;
address.0.as_str().to_ns_name::<GenericNamespaced>()
}
#[cfg(unix)]
fn name(address: &Address) -> io::Result<Name<'_>> {
use interprocess::local_socket::GenericFilePath;
address.0.as_str().to_fs_name::<GenericFilePath>()
}
pub(super) fn connect(address: &Address) -> io::Result<Stream> {
ConnectOptions::new()
.name(name(address)?)
.wait_mode(ConnectWaitMode::Timeout(PATIENCE))
.connect_sync()
}
#[cfg(windows)]
pub(super) fn listen(address: &Address) -> io::Result<Listener> {
use interprocess::os::windows::local_socket::ListenerOptionsExt;
use interprocess::os::windows::security_descriptor::SecurityDescriptor;
let only_the_owner = widestring::U16CString::from_str("D:P(A;;GA;;;OW)")
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
ListenerOptions::new()
.name(name(address)?)
.security_descriptor(SecurityDescriptor::deserialize(&only_the_owner)?)
.create_sync()
}
#[cfg(unix)]
pub(super) fn listen(address: &Address) -> io::Result<Listener> {
use std::path::Path;
let path = Path::new(&address.0);
if let Some(directory) = path.parent() {
private_directory(directory)?;
}
match ListenerOptions::new().name(name(address)?).create_sync() {
Err(error) if error.kind() == io::ErrorKind::AddrInUse && connect(address).is_err() => {
std::fs::remove_file(path)?;
ListenerOptions::new().name(name(address)?).create_sync()
}
other => other,
}
}
#[cfg(unix)]
fn private_directory(directory: &std::path::Path) -> io::Result<()> {
use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
std::fs::DirBuilder::new()
.recursive(true)
.mode(0o700)
.create(directory)?;
let found = std::fs::symlink_metadata(directory)?;
if !found.is_dir() || found.permissions().mode() & 0o077 != 0 {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
format!(
"{} can be entered by other users; an agent will not listen there",
directory.display()
),
));
}
Ok(())
}
pub(super) fn leave(address: &Address) {
#[cfg(unix)]
{
let path = std::path::Path::new(&address.0);
let _ = std::fs::remove_file(path);
if let Some(directory) = path.parent() {
let _ = std::fs::remove_dir(directory);
}
}
#[cfg(windows)]
let _ = address;
}