taro 0.1.0

In-place tar file extractor for memory-limited systems
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Utilities and datatypes relating to tar header blocks.

pub mod file_type;
use self::file_type::FileType;

/// Number of bytes in a tar header; all tar data blocks are aligned in null-byte padded blocks of
/// this size.
pub const TAR_BLOCKSIZE: u64 = 512;

/// Represents the data within a tar header.
pub struct TarHeader {
    pub name: String,
    pub mode: usize,
    pub uid: usize,
    pub gid: usize,
    pub size: usize,
    pub mtime: usize,
    pub chksum: usize,
    pub typeflag: FileType,
    pub linkname: String,
    pub uname: String,
    pub gname: String,
    pub devmajor: String,
    pub devminor: String,
    pub prefix: String,
    pub atime: Option<usize>,
    pub ctime: Option<usize>,
}

/// Creates a TarHeader directly from a string read out of a tar archive.
impl std::convert::From<&[u8; TAR_BLOCKSIZE as usize]> for TarHeader {
    fn from(b: &[u8; TAR_BLOCKSIZE as usize]) -> Self {
        let magic = std::str::from_utf8(&b[257..263]).unwrap();
        if magic != "ustar " {
            panic!("This does not look like a tar archive");
        }
        let _version = std::str::from_utf8(&b[263..265]).unwrap();

        let parse_octal = |start: usize, length: usize| {
            usize::from_str_radix(std::str::from_utf8(&b[start..start+length]).unwrap(), 8).unwrap()
        };

        let parse_string = |start: usize, length: usize| {
            std::str::from_utf8(&b[start..start+length]).unwrap().trim_end_matches('\0').to_owned()
        };

        let parse_time = |start: usize, length: usize| {
            let s = std::str::from_utf8(&b[start..start+length]).unwrap();
            if s.trim_end_matches('\0') == "" {
                None
            } else {
                Some(usize::from_str_radix(s, 8).unwrap())
            }
        };

        TarHeader {
            name: parse_string(0, 100),
            mode: parse_octal(100, 7),
            uid: parse_octal(108, 7),
            gid: parse_octal(116, 7),
            size: parse_octal(124, 11),
            mtime: parse_time(136, 11).unwrap(),
            chksum: parse_octal(148, 6),
            typeflag: (b[156] as char).into(),
            linkname: parse_string(157, 100),
            uname: parse_string(265, 32),
            gname: parse_string(297, 32),
            devmajor: parse_string(329, 8),
            devminor: parse_string(337, 8),
            prefix: parse_string(345, 131),
            atime: parse_time(476, 11),
            ctime: parse_time(488, 11),
        }
    }
}

impl std::fmt::Display for TarHeader {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        let atime = match self.atime {
            Some(atime) => atime,
            None => 0,
        };
        let ctime = match self.ctime {
            Some(ctime) => ctime,
            None => 0,
        };
        match self.typeflag {
            FileType::SoftLink => {
                write!(f, "{}{:o} {}({}):{}({}) {} {} -> {}, {}, {}, ({})??, {}, {}",
                    self.typeflag,
                    self.mode,
                    self.gname,
                    self.gid,
                    self.uname,
                    self.uid,
                    self.size,
                    self.name,
                    self.linkname,
                    self.mtime,
                    self.chksum,
                    self.prefix,
                    atime,
                    ctime)
            }
            FileType::HardLink => {
                write!(f, "{}{:o} {}({}):{}({}) {} {} link to {}, {}, {}, ({})??, {}, {}",
                    self.typeflag,
                    self.mode,
                    self.gname,
                    self.gid,
                    self.uname,
                    self.uid,
                    self.size,
                    self.name,
                    self.linkname,
                    self.mtime,
                    self.chksum,
                    self.prefix,
                    atime,
                    ctime)
            }
            FileType::CharacterSpecial => {
                write!(f, "{}{:o} {}({}):{}({}) {} {} = {}/{}, {}, {}, ({})??, {}, {}",
                    self.typeflag,
                    self.mode,
                    self.gname,
                    self.gid,
                    self.uname,
                    self.uid,
                    self.size,
                    self.name,
                    self.devmajor,
                    self.devminor,
                    self.mtime,
                    self.chksum,
                    self.prefix,
                    atime,
                    ctime)
            }
            _ => {
                write!(f, "{}{:o} {}({}):{}({}) {} {}, {}, {}, ({})??, {}, {}",
                    self.typeflag,
                    self.mode,
                    self.gname,
                    self.gid,
                    self.uname,
                    self.uid,
                    self.size,
                    self.name,
                    self.mtime,
                    self.chksum,
                    self.prefix,
                    atime,
                    ctime)
            }
        }
    }
}