stree 0.1.0

A directory hierarchy mapping format, similar to mtree
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::mem::MaybeUninit;
use std::path::Path;
use crate::{Result, Error, error, FileType};
use crate::time::FileTime;
use pathstr::PathStr;
use errno::errno;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) struct Stat
{
    pub uid: libc::uid_t,
    pub gid: libc::gid_t,
    pub mode: libc::mode_t,
    pub time: FileTime,
    pub filetype: FileType,
    pub blocksize: libc::blksize_t,
    pub blockcount: libc::blkcnt_t,
    pub device: libc::dev_t,
    pub rdevice: libc::dev_t,
    pub size: usize,
    pub nlink: u64,
    pub ino: u64
}

impl Default for Stat
{
    fn default() -> Self
    {
        Self
        {
            uid: 0,
            gid: 0,
            mode: 0,
            time: FileTime::default(),
            filetype: FileType::Regular,
            blocksize: 0,
            blockcount: 0,
            device: 0,
            rdevice: 0,
            size: 0,
            nlink: 0,
            ino: 0
        }
    }
}

impl TryFrom<libc::stat> for Stat
{
    type Error = Error;
    fn try_from(st: libc::stat) -> Result<Self>
    {
        let mut r = Self::default();
        r.uid = st.st_uid;
        r.gid = st.st_gid;
        r.blockcount = st.st_blocks;
        r.blocksize = st.st_blksize;
        r.size = st.st_size as usize;
        r.device = st.st_dev;
        r.rdevice = st.st_rdev;
        r.mode = st.st_mode;
        r.filetype = FileType::try_from(st.st_mode)?;
        r.time = FileTime::from(st);
        r.nlink = st.st_nlink;
        r.ino = st.st_ino;
        Ok(r)
    }
}

impl Stat
{
    pub fn new<P>(path: P) -> Result<Self>
    where P: AsRef<Path>
    {
        let cpath = PathStr::new(path.as_ref()).cstring()?;
        let mut buffer = MaybeUninit::<libc::stat>::uninit();
        unsafe
        {
            if libc::lstat(cpath.as_ptr(), buffer.as_mut_ptr()) == -1
            {
                error!("Stat::new: {}", errno())
            }
        }
        let buffer = unsafe { buffer.assume_init() };
        let stat = Self::try_from(buffer)?;
        Ok(stat)
    }

    #[allow(unused)]
    pub fn new_follow<P>(path: P) -> Result<Self>
    where P: AsRef<Path>
    {
        let cpath = PathStr::new(path.as_ref()).cstring()?;
        let mut buffer = MaybeUninit::<libc::stat>::uninit();
        unsafe
        {
            if libc::stat(cpath.as_ptr(), buffer.as_mut_ptr()) == -1
            {
                error!("Stat::new: {}", errno())
            }
        }
        let buffer = unsafe { buffer.assume_init() };
        let stat = Self::try_from(buffer)?;
        Ok(stat)
    }

    #[allow(unused)]
    pub fn owners(&self) -> Result<(String, String)>
    {
        Ok((
            crate::util::username_from_id(self.uid)?,
            crate::util::groupname_from_id(self.gid)?
        ))
    }
}