use std::fs::File;
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
pub const SUFFIX: &str = ".mnemo-shared";
pub const INTENT: &str = "intent.lock";
pub const LOCK_INFO: &str = "lock-info";
pub(crate) fn sidecar_path(brain: &Path) -> PathBuf {
let mut p = brain.as_os_str().to_os_string();
p.push(SUFFIX);
PathBuf::from(p)
}
pub(crate) enum SidecarState {
Ready(Sidecar),
Unavailable(String),
}
pub(crate) struct Sidecar {
path: PathBuf,
#[cfg(unix)]
dir: rustix::fd::OwnedFd,
}
impl std::fmt::Debug for Sidecar {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Sidecar").field("path", &self.path).finish()
}
}
impl Sidecar {
pub(crate) fn path(&self) -> &Path {
&self.path
}
pub(crate) fn read_lock_info(&self) -> Option<String> {
let mut f = self.open_existing(LOCK_INFO, false).ok()?;
let mut buf = vec![0u8; 512];
let n = f.read(&mut buf).ok()?;
buf.truncate(n);
let text = String::from_utf8_lossy(&buf).into_owned();
Some(text.lines().next().unwrap_or("").to_string())
}
pub(crate) fn write_lock_info(&self, line: &str) -> std::io::Result<()> {
use std::sync::atomic::{AtomicU64, Ordering};
static NEXT: AtomicU64 = AtomicU64::new(0);
let tmp = format!(
"{LOCK_INFO}.{}-{}.tmp",
std::process::id(),
NEXT.fetch_add(1, Ordering::Relaxed)
);
let result = (|| {
let mut f = self.create_new(&tmp)?;
f.write_all(line.as_bytes())?;
f.write_all(b"\n")?;
drop(f);
self.rename(&tmp, LOCK_INFO)
})();
if result.is_err() {
let _ = self.remove(&tmp);
}
result
}
pub(crate) fn remove_lock_info(&self) {
let _ = self.remove(LOCK_INFO);
}
}
#[cfg(unix)]
mod imp {
use super::*;
use rustix::fs::{self as rfs, AtFlags, FileType, Mode, OFlags};
use rustix::io::Errno;
pub(crate) fn open(brain: &Path) -> SidecarState {
let path = sidecar_path(brain);
match rfs::mkdir(&path, Mode::RWXU) {
Ok(()) | Err(Errno::EXIST) => {}
Err(Errno::ACCESS | Errno::PERM | Errno::ROFS) => {
return SidecarState::Unavailable(format!(
"can't create {} (the directory isn't writable)",
path.display()
))
}
Err(e) => {
return SidecarState::Unavailable(format!("can't create {}: {e}", path.display()))
}
}
let dir = match rfs::open(
&path,
OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC,
Mode::empty(),
) {
Ok(fd) => fd,
Err(e) => {
return SidecarState::Unavailable(format!(
"{} isn't a real directory ({e})",
path.display()
))
}
};
let st = match rfs::fstat(&dir) {
Ok(st) => st,
Err(e) => return SidecarState::Unavailable(format!("{}: {e}", path.display())),
};
if FileType::from_raw_mode(st.st_mode) != FileType::Directory {
return SidecarState::Unavailable(format!("{} isn't a directory", path.display()));
}
if st.st_uid != rustix::process::geteuid().as_raw() {
return SidecarState::Unavailable(format!(
"{} belongs to another user",
path.display()
));
}
if st.st_mode & 0o077 != 0 {
return SidecarState::Unavailable(format!(
"{} is open to other users (mode {:o}; it must be 0700)",
path.display(),
st.st_mode & 0o777
));
}
if st.st_mode & 0o700 != 0o700 {
if let Err(e) = rfs::fchmod(&dir, Mode::RWXU) {
return SidecarState::Unavailable(format!(
"{} has mode {:o} and can't be given 0700: {e}",
path.display(),
st.st_mode & 0o777
));
}
}
SidecarState::Ready(Sidecar { path, dir })
}
fn check_regular(f: &File) -> std::io::Result<()> {
let st = rfs::fstat(f)?;
if FileType::from_raw_mode(st.st_mode) != FileType::RegularFile
|| st.st_uid != rustix::process::geteuid().as_raw()
{
return Err(std::io::Error::other("not a regular file of this user's"));
}
Ok(())
}
impl Sidecar {
pub(crate) fn lock_file(&self, name: &str) -> std::io::Result<File> {
let base = OFlags::RDWR | OFlags::NOFOLLOW | OFlags::CLOEXEC | OFlags::NONBLOCK;
match rfs::openat(
&self.dir,
name,
base | OFlags::CREATE | OFlags::EXCL,
Mode::RUSR | Mode::WUSR,
) {
Ok(fd) => Ok(File::from(fd)),
Err(Errno::EXIST) => self.open_existing(name, true),
Err(e) => Err(e.into()),
}
}
pub(super) fn open_existing(&self, name: &str, write: bool) -> std::io::Result<File> {
let mode = if write { OFlags::RDWR } else { OFlags::RDONLY };
let fd = rfs::openat(
&self.dir,
name,
mode | OFlags::NOFOLLOW | OFlags::CLOEXEC | OFlags::NONBLOCK,
Mode::empty(),
)?;
let f = File::from(fd);
check_regular(&f)?;
Ok(f)
}
pub(super) fn create_new(&self, name: &str) -> std::io::Result<File> {
let fd = rfs::openat(
&self.dir,
name,
OFlags::WRONLY | OFlags::CREATE | OFlags::EXCL | OFlags::NOFOLLOW | OFlags::CLOEXEC,
Mode::RUSR | Mode::WUSR,
)?;
Ok(File::from(fd))
}
pub(super) fn rename(&self, from: &str, to: &str) -> std::io::Result<()> {
Ok(rfs::renameat(&self.dir, from, &self.dir, to)?)
}
pub(super) fn remove(&self, name: &str) -> std::io::Result<()> {
Ok(rfs::unlinkat(&self.dir, name, AtFlags::empty())?)
}
}
pub(crate) fn pid_alive(pid: u32) -> bool {
let Some(pid) = i32::try_from(pid)
.ok()
.and_then(rustix::process::Pid::from_raw)
else {
return false;
};
!matches!(rustix::process::test_kill_process(pid), Err(Errno::SRCH))
}
}
#[cfg(not(unix))]
mod imp {
use super::*;
use std::fs::OpenOptions;
#[cfg(windows)]
const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
fn no_follow(o: &mut OpenOptions) -> &mut OpenOptions {
#[cfg(windows)]
{
use std::os::windows::fs::OpenOptionsExt;
o.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT);
}
o
}
pub(crate) fn open(brain: &Path) -> SidecarState {
let path = sidecar_path(brain);
match std::fs::create_dir(&path) {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}
Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
return SidecarState::Unavailable(format!(
"can't create {} (the directory isn't writable)",
path.display()
))
}
Err(e) => {
return SidecarState::Unavailable(format!("can't create {}: {e}", path.display()))
}
}
match std::fs::symlink_metadata(&path) {
Ok(m) if m.is_dir() && !m.file_type().is_symlink() => {
SidecarState::Ready(Sidecar { path })
}
_ => SidecarState::Unavailable(format!("{} isn't a real directory", path.display())),
}
}
fn check_regular(f: &File) -> std::io::Result<()> {
let m = f.metadata()?;
if !m.is_file() || m.file_type().is_symlink() {
return Err(std::io::Error::other("not a regular file"));
}
Ok(())
}
impl Sidecar {
pub(crate) fn lock_file(&self, name: &str) -> std::io::Result<File> {
let p = self.path.join(name);
match no_follow(OpenOptions::new().read(true).write(true).create_new(true)).open(&p) {
Ok(f) => Ok(f),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
self.open_existing(name, true)
}
Err(e) => Err(e),
}
}
pub(super) fn open_existing(&self, name: &str, write: bool) -> std::io::Result<File> {
let f =
no_follow(OpenOptions::new().read(true).write(write)).open(self.path.join(name))?;
check_regular(&f)?;
Ok(f)
}
pub(super) fn create_new(&self, name: &str) -> std::io::Result<File> {
no_follow(OpenOptions::new().write(true).create_new(true)).open(self.path.join(name))
}
pub(super) fn rename(&self, from: &str, to: &str) -> std::io::Result<()> {
std::fs::rename(self.path.join(from), self.path.join(to))
}
pub(super) fn remove(&self, name: &str) -> std::io::Result<()> {
std::fs::remove_file(self.path.join(name))
}
}
pub(crate) fn pid_alive(_pid: u32) -> bool {
true
}
}
pub(crate) use imp::{open, pid_alive};