Struct Permissions 

pub struct Permissions(/* private fields */);

Unix-style permission bits.

Stores permissions as a standard Unix mode bitmask (rwxrwxrwx format). The lower 12 bits represent: owner (rwx), group (rwx), other (rwx), plus setuid/setgid/sticky bits.

Permission Bits

Mode: 0o7777 (octal)
┌─────┬─────┬─────┬────────────────────┐
│ Special │ Owner │ Group │ Other        │
│ (sst)   │ (rwx) │ (rwx) │ (rwx)        │
└─────┴─────┴─────┴────────────────────┘

Bit	Meaning
r (4)	Read permission
w (2)	Write permission
x (1)	Execute/search permission

Common Permission Values

Mode	Meaning
0o644	Owner read/write, others read (typical file)
0o755	Owner all, others read/execute (typical directory)
0o600	Owner read/write only (private file)
0o444	Everyone read only

Example

use anyfs_backend::Permissions;

// Create from octal mode
let perm = Permissions::from_mode(0o755);
assert_eq!(perm.mode(), 0o755);
assert!(!perm.readonly());

// Read-only permissions
let readonly = Permissions::from_mode(0o444);
assert!(readonly.readonly());

// Default permissions
assert_eq!(Permissions::default_file().mode(), 0o644);  // rw-r--r--
assert_eq!(Permissions::default_dir().mode(), 0o755);   // rwxr-xr-x

Implementations

impl Permissions

pub const fn from_mode(mode: u32) -> Self

Create permissions from a Unix mode (e.g., 0o755).

pub const fn mode(&self) -> u32

Get the raw mode value.

pub const fn readonly(&self) -> bool

Returns true if these permissions deny writing.

pub const fn default_file() -> Self

Default permissions for a new file (0o644 = rw-r–r–).

Examples found in repository

examples/generic_functions.rs (line 340)

    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        let ft = self.get_file_type(path).ok_or_else(|| FsError::NotFound {
            path: path.to_path_buf(),
        })?;
        let size = if ft == FileType::File {
            self.files
                .read()
                .unwrap()
                .get(path)
                .map(|d| d.len() as u64)
                .unwrap_or(0)
        } else {
            0
        };
        Ok(Metadata {
            file_type: ft,
            size,
            permissions: Permissions::default_file(),
            created: SystemTime::UNIX_EPOCH,
            modified: SystemTime::UNIX_EPOCH,
            accessed: SystemTime::UNIX_EPOCH,
            inode: self.inodes.read().unwrap().get(path).copied().unwrap_or(0),
            nlink: 1,
        })
    }
    fn open_read(&self, path: &Path) -> Result<Box<dyn Read + Send>, FsError> {
        Ok(Box::new(std::io::Cursor::new(self.read(path)?)))
    }
}

impl FsWrite for DemoFs {
    fn write(&self, path: &Path, data: &[u8]) -> Result<(), FsError> {
        self.assign_inode(path);
        self.files
            .write()
            .unwrap()
            .insert(path.to_path_buf(), data.to_vec());
        Ok(())
    }
    fn append(&self, path: &Path, data: &[u8]) -> Result<(), FsError> {
        self.files
            .write()
            .unwrap()
            .entry(path.to_path_buf())
            .or_default()
            .extend_from_slice(data);
        self.assign_inode(path);
        Ok(())
    }
    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
        self.files
            .write()
            .unwrap()
            .remove(path)
            .map(|_| ())
            .ok_or_else(|| FsError::NotFound {
                path: path.to_path_buf(),
            })
    }
    fn rename(&self, from: &Path, to: &Path) -> Result<(), FsError> {
        let data = self
            .files
            .write()
            .unwrap()
            .remove(from)
            .ok_or_else(|| FsError::NotFound {
                path: from.to_path_buf(),
            })?;
        self.files.write().unwrap().insert(to.to_path_buf(), data);
        self.assign_inode(to);
        Ok(())
    }
    fn copy(&self, from: &Path, to: &Path) -> Result<(), FsError> {
        let data = self.read(from)?;
        self.write(to, &data)
    }
    fn truncate(&self, path: &Path, size: u64) -> Result<(), FsError> {
        self.files
            .write()
            .unwrap()
            .get_mut(path)
            .ok_or_else(|| FsError::NotFound {
                path: path.to_path_buf(),
            })?
            .resize(size as usize, 0);
        Ok(())
    }
    fn open_write(&self, _path: &Path) -> Result<Box<dyn Write + Send>, FsError> {
        Ok(Box::new(std::io::Cursor::new(Vec::new())))
    }
}

impl FsDir for DemoFs {
    fn read_dir(&self, path: &Path) -> Result<ReadDirIter, FsError> {
        if !self.dirs.read().unwrap().contains(path) {
            return Err(FsError::NotFound {
                path: path.to_path_buf(),
            });
        }
        let mut entries = Vec::new();
        for (fp, data) in self.files.read().unwrap().iter() {
            if fp.parent() == Some(path) {
                if let Some(name) = fp.file_name() {
                    entries.push(Ok(DirEntry {
                        name: name.to_string_lossy().into(),
                        path: fp.clone(),
                        file_type: FileType::File,
                        size: data.len() as u64,
                        inode: 0,
                    }));
                }
            }
        }
        for dp in self.dirs.read().unwrap().iter() {
            if dp.parent() == Some(path) && dp != path {
                if let Some(name) = dp.file_name() {
                    entries.push(Ok(DirEntry {
                        name: name.to_string_lossy().into(),
                        path: dp.clone(),
                        file_type: FileType::Directory,
                        size: 0,
                        inode: 0,
                    }));
                }
            }
        }
        Ok(ReadDirIter::from_vec(entries))
    }
    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
        if self.dirs.read().unwrap().contains(path) {
            return Err(FsError::AlreadyExists {
                path: path.to_path_buf(),
                operation: "create_dir",
            });
        }
        self.dirs.write().unwrap().insert(path.to_path_buf());
        self.assign_inode(path);
        Ok(())
    }
    fn create_dir_all(&self, path: &Path) -> Result<(), FsError> {
        let mut current = PathBuf::new();
        for c in path.components() {
            current.push(c);
            self.dirs.write().unwrap().insert(current.clone());
            self.assign_inode(&current);
        }
        Ok(())
    }
    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
        if !self.dirs.write().unwrap().remove(path) {
            return Err(FsError::NotFound {
                path: path.to_path_buf(),
            });
        }
        Ok(())
    }
    fn remove_dir_all(&self, path: &Path) -> Result<(), FsError> {
        self.dirs.write().unwrap().remove(path);
        self.files
            .write()
            .unwrap()
            .retain(|p, _| !p.starts_with(path));
        Ok(())
    }
}

impl FsLink for DemoFs {
    fn symlink(&self, target: &Path, link: &Path) -> Result<(), FsError> {
        self.symlinks
            .write()
            .unwrap()
            .insert(link.to_path_buf(), target.to_path_buf());
        self.assign_inode(link);
        Ok(())
    }
    fn hard_link(&self, original: &Path, link: &Path) -> Result<(), FsError> {
        let data = self.read(original)?;
        self.write(link, &data)
    }
    fn read_link(&self, path: &Path) -> Result<PathBuf, FsError> {
        self.symlinks
            .read()
            .unwrap()
            .get(path)
            .cloned()
            .ok_or_else(|| FsError::InvalidData {
                path: path.to_path_buf(),
                details: "not a symlink".into(),
            })
    }
    fn symlink_metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        let ft = self.get_file_type(path).ok_or_else(|| FsError::NotFound {
            path: path.to_path_buf(),
        })?;
        Ok(Metadata {
            file_type: ft,
            size: 0,
            permissions: Permissions::default_file(),
            created: SystemTime::UNIX_EPOCH,
            modified: SystemTime::UNIX_EPOCH,
            accessed: SystemTime::UNIX_EPOCH,
            inode: 0,
            nlink: 1,
        })
    }

examples/inmemory_fs.rs (line 220)

    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        let file_type = self.get_file_type(path).ok_or_else(|| FsError::NotFound {
            path: path.to_path_buf(),
        })?;

        let size = if file_type == FileType::File {
            self.files
                .read()
                .unwrap()
                .get(path)
                .map(|d| d.len() as u64)
                .unwrap_or(0)
        } else {
            0
        };

        let inode = self.inodes.read().unwrap().get(path).copied().unwrap_or(0);

        Ok(Metadata {
            file_type,
            size,
            permissions: Permissions::default_file(),
            created: SystemTime::UNIX_EPOCH,
            modified: SystemTime::UNIX_EPOCH,
            accessed: SystemTime::UNIX_EPOCH,
            inode,
            nlink: 1,
        })
    }

    fn open_read(&self, path: &Path) -> Result<Box<dyn Read + Send>, FsError> {
        let data = self.read(path)?;
        Ok(Box::new(std::io::Cursor::new(data)))
    }
}

// =============================================================================
// Layer 1: FsWrite - Writing and modifying files
// =============================================================================

impl FsWrite for InMemoryFs {
    fn write(&self, path: &Path, data: &[u8]) -> Result<(), FsError> {
        self.assign_inode(path);
        self.files
            .write()
            .unwrap()
            .insert(path.to_path_buf(), data.to_vec());
        Ok(())
    }

    fn append(&self, path: &Path, data: &[u8]) -> Result<(), FsError> {
        let mut files = self.files.write().unwrap();
        files
            .entry(path.to_path_buf())
            .or_default()
            .extend_from_slice(data);
        drop(files);
        self.assign_inode(path);
        Ok(())
    }

    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
        self.files
            .write()
            .unwrap()
            .remove(path)
            .ok_or_else(|| FsError::NotFound {
                path: path.to_path_buf(),
            })?;

        // Clean up inode mapping
        if let Some(inode) = self.inodes.write().unwrap().remove(path) {
            self.inode_to_path.write().unwrap().remove(&inode);
        }

        // Clean up xattrs
        self.xattrs.write().unwrap().remove(path);

        Ok(())
    }

    fn rename(&self, from: &Path, to: &Path) -> Result<(), FsError> {
        let mut files = self.files.write().unwrap();
        let data = files.remove(from).ok_or_else(|| FsError::NotFound {
            path: from.to_path_buf(),
        })?;
        files.insert(to.to_path_buf(), data);
        drop(files);

        // Update inode mappings
        if let Some(inode) = self.inodes.write().unwrap().remove(from) {
            self.inodes.write().unwrap().insert(to.to_path_buf(), inode);
            self.inode_to_path
                .write()
                .unwrap()
                .insert(inode, to.to_path_buf());
        } else {
            self.assign_inode(to);
        }

        // Move xattrs
        if let Some(attrs) = self.xattrs.write().unwrap().remove(from) {
            self.xattrs.write().unwrap().insert(to.to_path_buf(), attrs);
        }

        Ok(())
    }

    fn copy(&self, from: &Path, to: &Path) -> Result<(), FsError> {
        let data = self.read(from)?;
        self.write(to, &data)
    }

    fn truncate(&self, path: &Path, size: u64) -> Result<(), FsError> {
        let mut files = self.files.write().unwrap();
        let data = files.get_mut(path).ok_or_else(|| FsError::NotFound {
            path: path.to_path_buf(),
        })?;
        data.resize(size as usize, 0);
        Ok(())
    }

    fn open_write(&self, path: &Path) -> Result<Box<dyn Write + Send>, FsError> {
        // Create file if it doesn't exist
        if !self.files.read().unwrap().contains_key(path) {
            self.write(path, &[])?;
        }

        // Return a cursor that writes to a buffer
        // Note: In a real implementation, this would write back on drop
        Ok(Box::new(std::io::Cursor::new(Vec::new())))
    }
}

// =============================================================================
// Layer 1: FsDir - Directory operations
// =============================================================================

impl FsDir for InMemoryFs {
    fn read_dir(&self, path: &Path) -> Result<ReadDirIter, FsError> {
        if !self.dirs.read().unwrap().contains(path) {
            return Err(FsError::NotFound {
                path: path.to_path_buf(),
            });
        }

        let mut entries = Vec::new();

        // Collect files in this directory
        for (file_path, data) in self.files.read().unwrap().iter() {
            if let Some(parent) = file_path.parent() {
                if parent == path {
                    if let Some(name) = file_path.file_name() {
                        entries.push(Ok(DirEntry {
                            name: name.to_string_lossy().into_owned(),
                            path: file_path.clone(),
                            file_type: FileType::File,
                            size: data.len() as u64,
                            inode: self
                                .inodes
                                .read()
                                .unwrap()
                                .get(file_path)
                                .copied()
                                .unwrap_or(0),
                        }));
                    }
                }
            }
        }

        // Collect subdirectories
        for dir_path in self.dirs.read().unwrap().iter() {
            if let Some(parent) = dir_path.parent() {
                if parent == path && dir_path != path {
                    if let Some(name) = dir_path.file_name() {
                        entries.push(Ok(DirEntry {
                            name: name.to_string_lossy().into_owned(),
                            path: dir_path.clone(),
                            file_type: FileType::Directory,
                            size: 0,
                            inode: self
                                .inodes
                                .read()
                                .unwrap()
                                .get(dir_path)
                                .copied()
                                .unwrap_or(0),
                        }));
                    }
                }
            }
        }

        // Collect symlinks
        for link_path in self.symlinks.read().unwrap().keys() {
            if let Some(parent) = link_path.parent() {
                if parent == path {
                    if let Some(name) = link_path.file_name() {
                        entries.push(Ok(DirEntry {
                            name: name.to_string_lossy().into_owned(),
                            path: link_path.clone(),
                            file_type: FileType::Symlink,
                            size: 0,
                            inode: self
                                .inodes
                                .read()
                                .unwrap()
                                .get(link_path)
                                .copied()
                                .unwrap_or(0),
                        }));
                    }
                }
            }
        }

        Ok(ReadDirIter::from_vec(entries))
    }

    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
        let mut dirs = self.dirs.write().unwrap();

        if dirs.contains(path) {
            return Err(FsError::AlreadyExists {
                path: path.to_path_buf(),
                operation: "create_dir",
            });
        }

        // Check parent exists
        if let Some(parent) = path.parent() {
            if parent != Path::new("") && parent != Path::new("/") && !dirs.contains(parent) {
                return Err(FsError::NotFound {
                    path: parent.to_path_buf(),
                });
            }
        }

        dirs.insert(path.to_path_buf());
        drop(dirs);
        self.assign_inode(path);

        Ok(())
    }

    fn create_dir_all(&self, path: &Path) -> Result<(), FsError> {
        let mut current = PathBuf::new();

        for component in path.components() {
            current.push(component);

            let mut dirs = self.dirs.write().unwrap();
            if !dirs.contains(&current) {
                dirs.insert(current.clone());
                drop(dirs);
                self.assign_inode(&current);
            }
        }

        Ok(())
    }

    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
        // Check if directory is empty
        let has_files = self
            .files
            .read()
            .unwrap()
            .keys()
            .any(|p| p.parent() == Some(path));

        let has_subdirs = self
            .dirs
            .read()
            .unwrap()
            .iter()
            .any(|p| p.parent() == Some(path) && p != path);

        if has_files || has_subdirs {
            return Err(FsError::DirectoryNotEmpty {
                path: path.to_path_buf(),
            });
        }

        if !self.dirs.write().unwrap().remove(path) {
            return Err(FsError::NotFound {
                path: path.to_path_buf(),
            });
        }

        // Clean up inode
        if let Some(inode) = self.inodes.write().unwrap().remove(path) {
            self.inode_to_path.write().unwrap().remove(&inode);
        }

        Ok(())
    }

    fn remove_dir_all(&self, path: &Path) -> Result<(), FsError> {
        // Remove all files under this path
        self.files
            .write()
            .unwrap()
            .retain(|p, _| !p.starts_with(path));

        // Remove all subdirectories under this path
        self.dirs.write().unwrap().retain(|p| !p.starts_with(path));

        // Remove all symlinks under this path
        self.symlinks
            .write()
            .unwrap()
            .retain(|p, _| !p.starts_with(path));

        // Clean up inodes
        let paths_to_remove: Vec<_> = self
            .inodes
            .read()
            .unwrap()
            .keys()
            .filter(|p| p.starts_with(path))
            .cloned()
            .collect();

        for p in paths_to_remove {
            if let Some(inode) = self.inodes.write().unwrap().remove(&p) {
                self.inode_to_path.write().unwrap().remove(&inode);
            }
        }

        Ok(())
    }
}

// =============================================================================
// Layer 2: FsLink - Symbolic and hard links
// =============================================================================

impl FsLink for InMemoryFs {
    fn symlink(&self, target: &Path, link: &Path) -> Result<(), FsError> {
        if self.get_file_type(link).is_some() {
            return Err(FsError::AlreadyExists {
                path: link.to_path_buf(),
                operation: "symlink",
            });
        }

        self.symlinks
            .write()
            .unwrap()
            .insert(link.to_path_buf(), target.to_path_buf());
        self.assign_inode(link);

        Ok(())
    }

    fn hard_link(&self, original: &Path, link: &Path) -> Result<(), FsError> {
        // For in-memory fs, we just copy the data (true hard links would share data)
        let data = self.read(original)?;
        self.write(link, &data)?;

        // In a real implementation, you'd update nlink count
        Ok(())
    }

    fn read_link(&self, path: &Path) -> Result<PathBuf, FsError> {
        self.symlinks
            .read()
            .unwrap()
            .get(path)
            .cloned()
            .ok_or_else(|| FsError::InvalidData {
                path: path.to_path_buf(),
                details: "not a symbolic link".into(),
            })
    }

    fn symlink_metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        let file_type = self.get_file_type(path).ok_or_else(|| FsError::NotFound {
            path: path.to_path_buf(),
        })?;

        Ok(Metadata {
            file_type,
            size: 0,
            permissions: Permissions::default_file(),
            created: SystemTime::UNIX_EPOCH,
            modified: SystemTime::UNIX_EPOCH,
            accessed: SystemTime::UNIX_EPOCH,
            inode: self.inodes.read().unwrap().get(path).copied().unwrap_or(0),
            nlink: 1,
        })
    }

examples/basic_usage.rs (line 92)

    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        if self.dirs.read().unwrap().contains(path) {
            Ok(Metadata {
                file_type: FileType::Directory,
                size: 0,
                permissions: Permissions::default_dir(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else if let Some(data) = self.files.read().unwrap().get(path) {
            Ok(Metadata {
                file_type: FileType::File,
                size: data.len() as u64,
                permissions: Permissions::default_file(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else {
            Err(FsError::NotFound {
                path: path.to_path_buf(),
            })
        }
    }

examples/layer_middleware.rs (line 495)

    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        if self.dirs.read().unwrap().contains(path) {
            Ok(Metadata {
                file_type: FileType::Directory,
                size: 0,
                permissions: Permissions::default_dir(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else if let Some(data) = self.files.read().unwrap().get(path) {
            Ok(Metadata {
                file_type: FileType::File,
                size: data.len() as u64,
                permissions: Permissions::default_file(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else {
            Err(FsError::NotFound {
                path: path.to_path_buf(),
            })
        }
    }

pub const fn default_dir() -> Self

Default permissions for a new directory (0o755 = rwxr-xr-x).

Examples found in repository

examples/basic_usage.rs (line 81)

    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        if self.dirs.read().unwrap().contains(path) {
            Ok(Metadata {
                file_type: FileType::Directory,
                size: 0,
                permissions: Permissions::default_dir(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else if let Some(data) = self.files.read().unwrap().get(path) {
            Ok(Metadata {
                file_type: FileType::File,
                size: data.len() as u64,
                permissions: Permissions::default_file(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else {
            Err(FsError::NotFound {
                path: path.to_path_buf(),
            })
        }
    }

examples/layer_middleware.rs (line 484)

    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
        if self.dirs.read().unwrap().contains(path) {
            Ok(Metadata {
                file_type: FileType::Directory,
                size: 0,
                permissions: Permissions::default_dir(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else if let Some(data) = self.files.read().unwrap().get(path) {
            Ok(Metadata {
                file_type: FileType::File,
                size: data.len() as u64,
                permissions: Permissions::default_file(),
                created: SystemTime::UNIX_EPOCH,
                modified: SystemTime::UNIX_EPOCH,
                accessed: SystemTime::UNIX_EPOCH,
                inode: 0,
                nlink: 1,
            })
        } else {
            Err(FsError::NotFound {
                path: path.to_path_buf(),
            })
        }
    }

Trait Implementations

impl Clone for Permissions

fn clone(&self) -> Permissions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Permissions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Permissions

fn default() -> Self

Returns the “default value” for a type.

impl Hash for Permissions

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Permissions

fn eq(&self, other: &Permissions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Permissions

impl Eq for Permissions

impl StructuralPartialEq for Permissions