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(¤t, &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(¤t) 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 }