lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

fs.rs (8810B)


      1 //! Owner-only files for the separate native execution namespace.
      2 
      3 use super::WorkspaceError;
      4 use fs2::FileExt;
      5 use rustix::fs::{Mode, OFlags, open, openat};
      6 use std::{
      7     fs::{File, Metadata},
      8     os::unix::fs::{DirBuilderExt, MetadataExt, PermissionsExt},
      9     path::{Component, Path, PathBuf},
     10 };
     11 
     12 #[derive(Clone, Copy, Eq, PartialEq)]
     13 pub(super) enum Kind {
     14     Outbox,
     15     SellerStock,
     16 }
     17 impl Kind {
     18     fn database(self) -> &'static str {
     19         match self {
     20             Self::Outbox => "execution_v1.sqlite",
     21             Self::SellerStock => "stock_execution_v1.sqlite",
     22         }
     23     }
     24     fn lock(self) -> &'static str {
     25         match self {
     26             Self::Outbox => ".execution_v1.lock",
     27             Self::SellerStock => ".stock_execution_v1.lock",
     28         }
     29     }
     30 }
     31 
     32 /// Retained identities and writer authority. The persistent lock inode is never
     33 /// unlinked on close, so another opener cannot lock a replacement inode.
     34 pub(super) struct Namespace {
     35     root: PathBuf,
     36     kind: Kind,
     37     directory: File,
     38     lock: File,
     39     database: File,
     40 }
     41 impl Namespace {
     42     #[cfg(test)]
     43     pub(super) fn acquire(root: &Path, create: bool) -> Result<Self, WorkspaceError> {
     44         Self::acquire_kind(root, create, Kind::Outbox)
     45     }
     46     pub(super) fn acquire_kind(
     47         root: &Path,
     48         create: bool,
     49         kind: Kind,
     50     ) -> Result<Self, WorkspaceError> {
     51         validate_absolute(root)?;
     52         if create {
     53             std::fs::DirBuilder::new()
     54                 .mode(0o700)
     55                 .create(root)
     56                 .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
     57         }
     58         validate_ancestors(root)?;
     59         let directory: File = open(
     60             root,
     61             OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC,
     62             Mode::empty(),
     63         )
     64         .map_err(|_| WorkspaceError::NamespaceUnavailable)?
     65         .into();
     66         let metadata = directory
     67             .metadata()
     68             .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
     69         validate_directory(&metadata)?;
     70         let flags = OFlags::RDWR
     71             | OFlags::NOFOLLOW
     72             | OFlags::CLOEXEC
     73             | if create {
     74                 OFlags::CREATE | OFlags::EXCL
     75             } else {
     76                 OFlags::empty()
     77             };
     78         let lock: File = openat(&directory, kind.lock(), flags, Mode::RUSR | Mode::WUSR)
     79             .map_err(|_| WorkspaceError::NamespaceUnavailable)?
     80             .into();
     81         validate_file(&lock)?;
     82         if lock
     83             .metadata()
     84             .map_err(|_| WorkspaceError::NamespaceUnavailable)?
     85             .len()
     86             != 0
     87         {
     88             return Err(WorkspaceError::RecoveryRequired);
     89         }
     90         FileExt::try_lock_exclusive(&lock).map_err(|error| {
     91             if error.kind() == std::io::ErrorKind::WouldBlock {
     92                 WorkspaceError::WriterActive
     93             } else {
     94                 WorkspaceError::NamespaceUnavailable
     95             }
     96         })?;
     97         let database: File = openat(&directory, kind.database(), flags, Mode::RUSR | Mode::WUSR)
     98             .map_err(|_| WorkspaceError::NamespaceUnavailable)?
     99             .into();
    100         validate_file(&database)?;
    101         if !create
    102             && database
    103                 .metadata()
    104                 .map_err(|_| WorkspaceError::NamespaceUnavailable)?
    105                 .len()
    106                 == 0
    107         {
    108             return Err(WorkspaceError::RecoveryRequired);
    109         }
    110         if create {
    111             database
    112                 .sync_all()
    113                 .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    114             lock.sync_all()
    115                 .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    116             directory
    117                 .sync_all()
    118                 .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    119         }
    120         let namespace = Self {
    121             root: root.to_path_buf(),
    122             kind,
    123             directory,
    124             lock,
    125             database,
    126         };
    127         namespace.validate()?;
    128         Ok(namespace)
    129     }
    130     pub(super) fn kind(&self) -> Kind {
    131         self.kind
    132     }
    133     pub(super) fn database_path(&self) -> PathBuf {
    134         self.root.join(self.kind.database())
    135     }
    136     pub(super) fn validate(&self) -> Result<(), WorkspaceError> {
    137         validate_ancestors(&self.root)?;
    138         let entries =
    139             std::fs::read_dir(&self.root).map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    140         for (index, entry) in entries.enumerate() {
    141             let entry = entry.map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    142             if index >= 5
    143                 || ![
    144                     self.kind.database().to_owned(),
    145                     self.kind.lock().to_owned(),
    146                     format!("{}-wal", self.kind.database()),
    147                     format!("{}-shm", self.kind.database()),
    148                     format!("{}-journal", self.kind.database()),
    149                 ]
    150                 .iter()
    151                 .any(|name| entry.file_name() == name.as_str())
    152             {
    153                 return Err(WorkspaceError::RecoveryRequired);
    154             }
    155         }
    156         let root = std::fs::symlink_metadata(&self.root)
    157             .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    158         let retained = self
    159             .directory
    160             .metadata()
    161             .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    162         validate_directory(&root)?;
    163         if !root.is_dir() || root.file_type().is_symlink() || !same(&root, &retained) {
    164             return Err(WorkspaceError::NamespaceUnavailable);
    165         }
    166         for (name, file) in [
    167             (self.kind.database(), &self.database),
    168             (self.kind.lock(), &self.lock),
    169         ] {
    170             validate_file(file)?;
    171             let current = std::fs::symlink_metadata(self.root.join(name))
    172                 .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    173             let retained = file
    174                 .metadata()
    175                 .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    176             if current.file_type().is_symlink() || !same(&current, &retained) {
    177                 return Err(WorkspaceError::NamespaceUnavailable);
    178             }
    179         }
    180         for suffix in ["-wal", "-shm", "-journal"] {
    181             match std::fs::symlink_metadata(
    182                 self.root.join(format!("{}{suffix}", self.kind.database())),
    183             ) {
    184                 Ok(metadata) => validate_metadata(&metadata)?,
    185                 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
    186                 Err(_) => return Err(WorkspaceError::NamespaceUnavailable),
    187             }
    188         }
    189         Ok(())
    190     }
    191 }
    192 fn validate_absolute(root: &Path) -> Result<(), WorkspaceError> {
    193     if !root.is_absolute()
    194         || root
    195             .components()
    196             .any(|part| matches!(part, Component::CurDir | Component::ParentDir))
    197     {
    198         return Err(WorkspaceError::NamespaceUnavailable);
    199     }
    200     Ok(())
    201 }
    202 fn validate_ancestors(root: &Path) -> Result<(), WorkspaceError> {
    203     let mut current = PathBuf::new();
    204     for part in root.components() {
    205         current.push(part.as_os_str());
    206         let metadata = std::fs::symlink_metadata(&current)
    207             .map_err(|_| WorkspaceError::NamespaceUnavailable)?;
    208         if !metadata.is_dir() || metadata.file_type().is_symlink() {
    209             return Err(WorkspaceError::NamespaceUnavailable);
    210         }
    211         // A root-owned sticky ancestor is an ordinary system temporary root;
    212         // all other mutable ancestors could allow another user to replace it.
    213         let mode = metadata.permissions().mode();
    214         let sticky_system = metadata.uid() == 0 && mode & 0o1000 != 0;
    215         if mode & 0o022 != 0 && !sticky_system {
    216             return Err(WorkspaceError::NamespaceUnavailable);
    217         }
    218     }
    219     Ok(())
    220 }
    221 fn same(a: &Metadata, b: &Metadata) -> bool {
    222     a.dev() == b.dev() && a.ino() == b.ino() && a.uid() == b.uid()
    223 }
    224 fn validate_file(file: &File) -> Result<(), WorkspaceError> {
    225     validate_metadata(
    226         &file
    227             .metadata()
    228             .map_err(|_| WorkspaceError::NamespaceUnavailable)?,
    229     )
    230 }
    231 fn validate_directory(metadata: &Metadata) -> Result<(), WorkspaceError> {
    232     if !metadata.is_dir()
    233         || metadata.uid() != rustix::process::geteuid().as_raw()
    234         || metadata.permissions().mode() & 0o077 != 0
    235     {
    236         return Err(WorkspaceError::NamespaceUnavailable);
    237     }
    238     Ok(())
    239 }
    240 fn validate_metadata(metadata: &Metadata) -> Result<(), WorkspaceError> {
    241     if !metadata.is_file()
    242         || metadata.file_type().is_symlink()
    243         || metadata.nlink() != 1
    244         || metadata.uid() != rustix::process::geteuid().as_raw()
    245         || metadata.permissions().mode() & 0o7777 != 0o600
    246     {
    247         return Err(WorkspaceError::NamespaceUnavailable);
    248     }
    249     Ok(())
    250 }