use std::io;
use std::os::unix::net::{SocketAddr, UnixDatagram};
#[cfg(feature = "tokio")]
pub(crate) fn drain(socket: &tokio::net::UnixDatagram) -> io::Result<()> {
use std::os::fd::AsRawFd;
let mut scratch = [0u8; 64];
loop {
let read = unsafe {
libc::recv(
socket.as_raw_fd(),
scratch.as_mut_ptr().cast(),
scratch.len(),
libc::MSG_DONTWAIT,
)
};
if read >= 0 {
continue;
}
let error = io::Error::last_os_error();
match error.kind() {
io::ErrorKind::Interrupted => continue,
io::ErrorKind::WouldBlock => {
match socket.try_recv(&mut scratch) {
Ok(_) => continue,
Err(error) if error.kind() == io::ErrorKind::WouldBlock => {
return Ok(());
}
Err(error)
if error.kind() == io::ErrorKind::Interrupted => {}
Err(error) => return Err(error),
}
}
_ => return Err(error),
}
}
}
#[derive(Clone, Copy)]
pub(crate) enum Doorbell {
Lane(usize),
Watcher(usize),
}
impl Doorbell {
fn suffix(self) -> String {
match self {
Self::Lane(lane) => lane.to_string(),
Self::Watcher(slot) => format!("w{slot}"),
}
}
}
pub(crate) struct Bell {
prefix: String,
sender: UnixDatagram,
group: Option<orbit_core::shm::GroupAccess>,
}
impl Bell {
#[cfg(test)]
pub(crate) fn new(segment: &str) -> io::Result<Self> {
Self::with_group(segment, None)
}
pub(crate) fn with_group(
segment: &str,
group: Option<orbit_core::shm::GroupAccess>,
) -> io::Result<Self> {
let sender = UnixDatagram::unbound()?;
sender.set_nonblocking(true)?;
let prefix = if group.is_some() {
segment.to_owned()
} else {
Self::prefix(segment)
};
Ok(Self { prefix, sender, group })
}
pub(crate) fn validate_group_address(
access: &orbit_core::shm::GroupAccess,
segment: &str,
last_slot: usize,
) -> io::Result<()> {
SocketAddr::from_pathname(
access.bell_path(segment, &Doorbell::Watcher(last_slot).suffix()),
)
.map(|_| ())
}
fn group_path(
&self,
door: Doorbell,
) -> Option<std::path::PathBuf> {
self.group
.as_ref()
.map(|access| access.bell_path(&self.prefix, &door.suffix()))
}
fn prefix(segment: &str) -> String {
let uid = unsafe { libc::getuid() };
let segment = segment.trim_start_matches('/');
format!("orbit-link-{uid}/{segment}")
}
pub(crate) fn validate_address(
segment: &str,
last_slot: usize,
) -> io::Result<()> {
Self::address_for(&Self::prefix(segment), Doorbell::Watcher(last_slot))
.map(|_| ())
}
#[cfg(target_os = "linux")]
fn address(
&self,
door: Doorbell,
) -> io::Result<SocketAddr> {
if let Some(path) = self.group_path(door) {
return SocketAddr::from_pathname(path);
}
Self::address_for(&self.prefix, door)
}
#[cfg(target_os = "linux")]
fn address_for(
prefix: &str,
door: Doorbell,
) -> io::Result<SocketAddr> {
use std::os::linux::net::SocketAddrExt;
SocketAddr::from_abstract_name(format!("{}.{}", prefix, door.suffix()))
}
#[cfg(not(target_os = "linux"))]
fn path(
&self,
door: Doorbell,
) -> std::path::PathBuf {
Self::path_for(&self.prefix, door)
}
#[cfg(not(target_os = "linux"))]
fn path_for(
prefix: &str,
door: Doorbell,
) -> std::path::PathBuf {
std::path::PathBuf::from(format!("/tmp/{}.{}", prefix, door.suffix()))
}
#[cfg(not(target_os = "linux"))]
fn address(
&self,
door: Doorbell,
) -> io::Result<SocketAddr> {
if let Some(path) = self.group_path(door) {
return SocketAddr::from_pathname(path);
}
Self::address_for(&self.prefix, door)
}
#[cfg(not(target_os = "linux"))]
fn address_for(
prefix: &str,
door: Doorbell,
) -> io::Result<SocketAddr> {
SocketAddr::from_pathname(Self::path_for(prefix, door))
}
pub(crate) fn ring(
&self,
door: Doorbell,
) -> io::Result<()> {
let address = self.address(door)?;
self.sender.send_to_addr(&[1], &address).map(|_| ())
}
#[cfg(feature = "tokio")]
pub(crate) fn bind(
&self,
door: Doorbell,
) -> io::Result<UnixDatagram> {
if let Some(access) = &self.group {
return access.bind_bell(&self.group_path(door).unwrap());
}
#[cfg(not(target_os = "linux"))]
{
use std::os::unix::fs::DirBuilderExt;
let path = self.path(door);
if let Some(directory) = path.parent() {
match std::fs::DirBuilder::new().mode(0o700).create(directory) {
Err(error)
if error.kind() != io::ErrorKind::AlreadyExists =>
{
return Err(error);
}
_ => {}
}
}
match std::fs::remove_file(&path) {
Ok(()) => {}
Err(error) if error.kind() == io::ErrorKind::NotFound => {}
Err(error) => return Err(error),
}
}
let socket = UnixDatagram::bind_addr(&self.address(door)?)?;
socket.set_nonblocking(true)?;
Ok(socket)
}
#[cfg(feature = "tokio")]
pub(crate) fn unbind(
&self,
door: Doorbell,
) {
if let Some(path) = self.group_path(door) {
let _ = std::fs::remove_file(path);
return;
}
#[cfg(not(target_os = "linux"))]
let _ = std::fs::remove_file(self.path(door));
#[cfg(target_os = "linux")]
let _ = door;
}
}