kpea 0.4.0

CPIO archive reader/writer library. Supports New ASCII and Old character formats. Fuzz-tested against GNU cpio.
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

use std::io::Error;
use std::io::ErrorKind;

use crate::constants::*;

/// File types supported by CPIO.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(u8)]
pub enum FileType {
    /// Unix-domain socket.
    Socket = 0o14,
    /// Symbolic link.
    Symlink = 0o12,
    /// Regular file.
    Regular = 0o10,
    /// Block device.
    BlockDevice = 0o6,
    /// Directory.
    Directory = 0o4,
    /// Character device.
    CharDevice = 0o2,
    /// Named pipe.
    Fifo = 0o1,
}

impl FileType {
    /// Get file type from file mode.
    pub fn new(mode: u32) -> Result<Self, Error> {
        use FileType::*;
        const SOCKET: u8 = FileType::Socket as u8;
        const SYMLINK: u8 = FileType::Symlink as u8;
        const REGULAR: u8 = FileType::Regular as u8;
        const BLOCK: u8 = FileType::BlockDevice as u8;
        const DIRECTORY: u8 = FileType::Directory as u8;
        const CHAR: u8 = FileType::CharDevice as u8;
        const FIFO: u8 = FileType::Fifo as u8;
        match mode_to_file_type(mode) {
            SOCKET => Ok(Socket),
            SYMLINK => Ok(Symlink),
            REGULAR => Ok(Regular),
            BLOCK => Ok(BlockDevice),
            DIRECTORY => Ok(Directory),
            CHAR => Ok(CharDevice),
            FIFO => Ok(Fifo),
            _ => Err(ErrorKind::InvalidData.into()),
        }
    }

    #[allow(unused)]
    pub(crate) fn to_mode(self) -> u32 {
        u32::from(self as u8) << 12
    }
}

impl TryFrom<u32> for FileType {
    type Error = Error;
    fn try_from(mode: u32) -> Result<Self, Error> {
        Self::new(mode)
    }
}

pub(crate) fn mode_to_file_type(mode: u32) -> u8 {
    ((mode & FILE_TYPE_MASK) >> 12) as u8
}

#[cfg(unix)]
impl TryFrom<&std::fs::Metadata> for FileType {
    type Error = Error;

    fn try_from(other: &std::fs::Metadata) -> Result<Self, Self::Error> {
        use std::os::unix::fs::MetadataExt;
        FileType::new(other.mode())
    }
}

#[cfg(not(unix))]
impl TryFrom<&std::fs::Metadata> for FileType {
    type Error = Error;

    fn try_from(other: &std::fs::Metadata) -> Result<Self, Self::Error> {
        if other.is_dir() {
            return Ok(FileType::Directory);
        }
        if other.is_symlink() {
            return Ok(FileType::Symlink);
        }
        if other.is_file() {
            return Ok(FileType::Regular);
        }
        Err(ErrorKind::InvalidData.into())
    }
}