LINE1 10 20 30 40 50 60 70 80 901use std::{2 collections::HashMap,3 future,4 io::{self, SeekFrom},5 path::{Component, Path, PathBuf},6 pin::Pin,7 sync::{Arc, Mutex},8 time::SystemTime,9};1011use bytes::{Buf, Bytes};12use cap_std::{ambient_authority, fs::Dir};13use dav_server::{14 davpath::DavPath,15 fs::{16 DavDirEntry, DavFile, DavFileSystem, DavMetaData, DavProp, FsError, FsFuture, FsResult,17 FsStream, OpenOptions, ReadDirMeta,18 },19};20use futures_util::stream;21use http::StatusCode;22use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};2324#[derive(Clone)]25pub struct RootFs {26 root: Arc<Dir>,27 dead_properties: Arc<Mutex<HashMap<PathBuf, HashMap<String, DavProp>>>>,28}2930impl RootFs {31 pub fn open(path: &Path) -> io::Result<Self> {32 Ok(Self {33 root: Arc::new(Dir::open_ambient_dir(path, ambient_authority())?),34 dead_properties: Arc::new(Mutex::new(HashMap::new())),35 })36 }3738 pub fn is_accessible(&self) -> bool {39 self.root40 .dir_metadata()41 .map(|metadata| metadata.is_dir())42 .unwrap_or(false)43 }4445 fn relative_path(path: &DavPath) -> FsResult<PathBuf> {46 let relative = path.as_rel_ospath();47 if relative.as_os_str().is_empty() {48 return Ok(PathBuf::from("."));49 }50 if relative.to_string_lossy().contains('\0')51 || relative.components().any(|component| {52 matches!(53 component,54 Component::ParentDir | Component::RootDir | Component::Prefix(_)55 )56 })57 {58 return Err(FsError::Forbidden);59 }60 Ok(relative.to_path_buf())61 }6263 fn reject_root(path: &Path) -> FsResult<()> {64 if path == Path::new(".") || path.as_os_str().is_empty() {65 Err(FsError::Forbidden)66 } else {67 Ok(())68 }69 }7071 fn property_key(property: &DavProp) -> String {72 format!(73 "{}\0{}",74 property.namespace.as_deref().unwrap_or_default(),75 property.name76 )77 }78}7980fn blocking<T, F>(operation: F) -> FsFuture<'static, T>81where82 T: Send + 'static,83 F: FnOnce() -> io::Result<T> + Send + 'static,84{85 Box::pin(async move {86 tokio::task::spawn_blocking(operation)87 .await88 .map_err(|_| FsError::GeneralFailure)?89 .map_err(FsError::from)90 })91}9293fn failed<T: Send + 'static>(error: FsError) -> FsFuture<'static, T> {94 Box::pin(future::ready(Err(error)))95}9697impl DavFileSystem for RootFs {98 fn metadata<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, Box<dyn DavMetaData>> {99 let relative = match Self::relative_path(path) {100 Ok(relative) => relative,101 Err(error) => return failed(error),102 };103 let root = Arc::clone(&self.root);104 Box::pin(async move {105 let metadata = blocking(move || root.metadata(relative)).await?;106 Ok(Box::new(RootMetadata::from_cap(metadata)) as Box<dyn DavMetaData>)107 })108 }109110 fn symlink_metadata<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, Box<dyn DavMetaData>> {111 let relative = match Self::relative_path(path) {112 Ok(relative) => relative,113 Err(error) => return failed(error),114 };115 let root = Arc::clone(&self.root);116 Box::pin(async move {117 let metadata = blocking(move || root.symlink_metadata(relative)).await?;118 Ok(Box::new(RootMetadata::from_cap(metadata)) as Box<dyn DavMetaData>)119 })120 }121122 fn read_dir<'a>(123 &'a self,124 path: &'a DavPath,125 meta: ReadDirMeta,126 ) -> FsFuture<'a, FsStream<Box<dyn DavDirEntry>>> {127 let relative = match Self::relative_path(path) {128 Ok(relative) => relative,129 Err(error) => return failed(error),130 };131 let root = Arc::clone(&self.root);132 Box::pin(async move {133 let entries = blocking(move || {134 let mut entries = Vec::new();135 for entry in root.read_dir(&relative)? {136 let entry = entry?;137 let name = entry.file_name();138 entries.push(Box::new(RootDirEntry {139 root: Arc::clone(&root),140 path: relative.join(&name),141 name: name.as_encoded_bytes().to_vec(),142 meta,143 }) as Box<dyn DavDirEntry>);144 }145 Ok(entries)146 })147 .await?;148 let stream = stream::iter(entries.into_iter().map(Ok::<_, FsError>));149 Ok(Box::pin(stream) as FsStream<Box<dyn DavDirEntry>>)150 })151 }152153 fn open<'a>(154 &'a self,155 path: &'a DavPath,156 options: OpenOptions,157 ) -> FsFuture<'a, Box<dyn DavFile>> {158 let relative = match Self::relative_path(path) {159 Ok(relative) => relative,160 Err(error) => return failed(error),161 };162 let root = Arc::clone(&self.root);163 Box::pin(async move {164 let file = blocking(move || {165 let mut open_options = cap_std::fs::OpenOptions::new();166 open_options167 .read(options.read)168 .write(options.write)169 .append(options.append)170 .truncate(options.truncate)171 .create(options.create)172 .create_new(options.create_new);173 let file = root.open_with(relative, &open_options)?;174 if let Some(size) = options.size {175 file.set_len(size)?;176 }177 Ok(file.into_std())178 })179 .await?;180 Ok(Box::new(RootDavFile {181 file: tokio::fs::File::from_std(file),182 }) as Box<dyn DavFile>)183 })184 }185186 fn create_dir<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, ()> {187 let relative = match Self::relative_path(path).and_then(|path| {188 Self::reject_root(&path)?;189 Ok(path)190 }) {191 Ok(relative) => relative,192 Err(error) => return failed(error),193 };194 let root = Arc::clone(&self.root);195 blocking(move || root.create_dir(relative))196 }197198 fn remove_dir<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, ()> {199 let relative = match Self::relative_path(path).and_then(|path| {200 Self::reject_root(&path)?;201 Ok(path)202 }) {203 Ok(relative) => relative,204 Err(error) => return failed(error),205 };206 let root = Arc::clone(&self.root);207 let dead_properties = Arc::clone(&self.dead_properties);208 Box::pin(async move {209 let path_for_io = relative.clone();210 blocking(move || root.remove_dir(path_for_io)).await?;211 dead_properties212 .lock()213 .map_err(|_| FsError::GeneralFailure)?214 .remove(&relative);215 Ok(())216 })217 }218219 fn remove_file<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, ()> {220 let relative = match Self::relative_path(path).and_then(|path| {221 Self::reject_root(&path)?;222 Ok(path)223 }) {224 Ok(relative) => relative,225 Err(error) => return failed(error),226 };227 let root = Arc::clone(&self.root);228 let dead_properties = Arc::clone(&self.dead_properties);229 Box::pin(async move {230 let path_for_io = relative.clone();231 blocking(move || root.remove_file(path_for_io)).await?;232 dead_properties233 .lock()234 .map_err(|_| FsError::GeneralFailure)?235 .remove(&relative);236 Ok(())237 })238 }239240 fn rename<'a>(&'a self, from: &'a DavPath, to: &'a DavPath) -> FsFuture<'a, ()> {241 let from = match Self::relative_path(from).and_then(|path| {242 Self::reject_root(&path)?;243 Ok(path)244 }) {245 Ok(path) => path,246 Err(error) => return failed(error),247 };248 let to = match Self::relative_path(to).and_then(|path| {249 Self::reject_root(&path)?;250 Ok(path)251 }) {252 Ok(path) => path,253 Err(error) => return failed(error),254 };255 let root = Arc::clone(&self.root);256 let dead_properties = Arc::clone(&self.dead_properties);257 Box::pin(async move {258 let from_for_io = from.clone();259 let to_for_io = to.clone();260 blocking(move || root.rename(from_for_io, &root, to_for_io)).await?;261 let mut properties = dead_properties262 .lock()263 .map_err(|_| FsError::GeneralFailure)?;264 if let Some(properties_for_file) = properties.remove(&from) {265 properties.insert(to, properties_for_file);266 }267 Ok(())268 })269 }270271 fn copy<'a>(&'a self, from: &'a DavPath, to: &'a DavPath) -> FsFuture<'a, ()> {272 let from = match Self::relative_path(from).and_then(|path| {273 Self::reject_root(&path)?;274 Ok(path)275 }) {276 Ok(path) => path,277 Err(error) => return failed(error),278 };279 let to = match Self::relative_path(to).and_then(|path| {280 Self::reject_root(&path)?;281 Ok(path)282 }) {283 Ok(path) => path,284 Err(error) => return failed(error),285 };286 let root = Arc::clone(&self.root);287 let dead_properties = Arc::clone(&self.dead_properties);288 Box::pin(async move {289 let from_for_io = from.clone();290 let to_for_io = to.clone();291 blocking(move || root.copy(&from_for_io, &root, &to_for_io).map(|_| ())).await?;292 let mut properties = dead_properties293 .lock()294 .map_err(|_| FsError::GeneralFailure)?;295 if let Some(properties_for_file) = properties.get(&from).cloned() {296 properties.insert(to, properties_for_file);297 }298 Ok(())299 })300 }301302 fn have_props<'a>(303 &'a self,304 _path: &'a DavPath,305 ) -> Pin<Box<dyn std::future::Future<Output = bool> + Send + 'a>> {306 Box::pin(future::ready(true))307 }308309 fn patch_props<'a>(310 &'a self,311 path: &'a DavPath,312 patch: Vec<(bool, DavProp)>,313 ) -> FsFuture<'a, Vec<(StatusCode, DavProp)>> {314 let relative = match Self::relative_path(path) {315 Ok(relative) => relative,316 Err(error) => return failed(error),317 };318 Box::pin(async move {319 let mut all_properties = self320 .dead_properties321 .lock()322 .map_err(|_| FsError::GeneralFailure)?;323 let properties = all_properties.entry(relative).or_default();324 let mut result = Vec::with_capacity(patch.len());325 for (set, property) in patch {326 let key = Self::property_key(&property);327 let status = if set {328 properties.insert(key, property.clone());329 StatusCode::OK330 } else if properties.remove(&key).is_some() {331 StatusCode::OK332 } else {333 StatusCode::NOT_FOUND334 };335 result.push((status, property));336 }337 Ok(result)338 })339 }340341 fn get_props<'a>(&'a self, path: &'a DavPath, do_content: bool) -> FsFuture<'a, Vec<DavProp>> {342 let relative = match Self::relative_path(path) {343 Ok(relative) => relative,344 Err(error) => return failed(error),345 };346 Box::pin(async move {347 let all_properties = self348 .dead_properties349 .lock()350 .map_err(|_| FsError::GeneralFailure)?;351 let mut properties = all_properties352 .get(&relative)353 .map(|properties| properties.values().cloned().collect::<Vec<_>>())354 .unwrap_or_default();355 if !do_content {356 for property in &mut properties {357 property.xml = None;358 }359 }360 Ok(properties)361 })362 }363364 fn get_prop<'a>(&'a self, path: &'a DavPath, property: DavProp) -> FsFuture<'a, Vec<u8>> {365 let relative = match Self::relative_path(path) {366 Ok(relative) => relative,367 Err(error) => return failed(error),368 };369 Box::pin(async move {370 let all_properties = self371 .dead_properties372 .lock()373 .map_err(|_| FsError::GeneralFailure)?;374 all_properties375 .get(&relative)376 .and_then(|properties| properties.get(&Self::property_key(&property)))377 .and_then(|property| property.xml.clone())378 .ok_or(FsError::NotFound)379 })380 }381}382383#[derive(Debug)]384struct RootDirEntry {385 root: Arc<Dir>,386 path: PathBuf,387 name: Vec<u8>,388 meta: ReadDirMeta,389}390391impl DavDirEntry for RootDirEntry {392 fn name(&self) -> Vec<u8> {393 self.name.clone()394 }395396 fn metadata(&self) -> FsFuture<'_, Box<dyn DavMetaData>> {397 let root = Arc::clone(&self.root);398 let path = self.path.clone();399 let use_symlink_metadata = self.meta != ReadDirMeta::Data;400 Box::pin(async move {401 let metadata = blocking(move || {402 if use_symlink_metadata {403 root.symlink_metadata(path)404 } else {405 root.metadata(path)406 }407 })408 .await?;409 Ok(Box::new(RootMetadata::from_cap(metadata)) as Box<dyn DavMetaData>)410 })411 }412}413414#[derive(Clone, Debug)]415struct RootMetadata {416 len: u64,417 modified: FsResult<SystemTime>,418 is_dir: bool,419 is_symlink: bool,420}421422impl RootMetadata {423 fn from_cap(metadata: cap_std::fs::Metadata) -> Self {424 Self {425 len: metadata.len(),426 modified: metadata427 .modified()428 .map(cap_std::time::SystemTime::into_std)429 .map_err(FsError::from),430 is_dir: metadata.is_dir(),431 is_symlink: metadata.is_symlink(),432 }433 }434435 fn from_std(metadata: std::fs::Metadata) -> Self {436 Self {437 len: metadata.len(),438 modified: metadata.modified().map_err(FsError::from),439 is_dir: metadata.is_dir(),440 is_symlink: metadata.file_type().is_symlink(),441 }442 }443}444445impl DavMetaData for RootMetadata {446 fn len(&self) -> u64 {447 self.len448 }449450 fn modified(&self) -> FsResult<SystemTime> {451 self.modified452 }453454 fn is_dir(&self) -> bool {455 self.is_dir456 }457458 fn is_symlink(&self) -> bool {459 self.is_symlink460 }461}462463#[derive(Debug)]464struct RootDavFile {465 file: tokio::fs::File,466}467468impl DavFile for RootDavFile {469 fn metadata(&mut self) -> FsFuture<'_, Box<dyn DavMetaData>> {470 Box::pin(async move {471 let metadata = self.file.metadata().await.map_err(FsError::from)?;472 Ok(Box::new(RootMetadata::from_std(metadata)) as Box<dyn DavMetaData>)473 })474 }475476 fn write_buf(&mut self, mut buf: Box<dyn Buf + Send>) -> FsFuture<'_, ()> {477 Box::pin(async move {478 while buf.has_remaining() {479 let chunk = buf.chunk();480 self.file.write_all(chunk).await.map_err(FsError::from)?;481 let written = chunk.len();482 buf.advance(written);483 }484 Ok(())485 })486 }487488 fn write_bytes(&mut self, buf: Bytes) -> FsFuture<'_, ()> {489 Box::pin(async move { self.file.write_all(&buf).await.map_err(FsError::from) })490 }491492 fn read_bytes(&mut self, count: usize) -> FsFuture<'_, Bytes> {493 Box::pin(async move {494 let mut buf = vec![0; count];495 let read = self.file.read(&mut buf).await.map_err(FsError::from)?;496 buf.truncate(read);497 Ok(Bytes::from(buf))498 })499 }500501 fn seek(&mut self, pos: SeekFrom) -> FsFuture<'_, u64> {502 Box::pin(async move { self.file.seek(pos).await.map_err(FsError::from) })503 }504505 fn flush(&mut self) -> FsFuture<'_, ()> {506 Box::pin(async move { self.file.flush().await.map_err(FsError::from) })507 }508}509510#[cfg(test)]511mod tests {512 use super::*;513514 #[test]515 fn rejects_parent_components() {516 assert!(DavPath::new("/../outside").is_err());517 assert!(DavPath::new("/%2e%2e/outside").is_err());518 }519520 #[test]521 fn maps_virtual_root_to_dot_and_protects_it_from_mutation() {522 let path = DavPath::new("/").expect("valid root DAV path");523 let relative = RootFs::relative_path(&path).expect("root path");524 assert_eq!(relative, PathBuf::from("."));525 assert_eq!(RootFs::reject_root(&relative), Err(FsError::Forbidden));526 }527}