cargo_deb/deb/
tar.rs

1use crate::assets::{Asset, AssetSource};
2use crate::error::{CDResult, CargoDebError};
3use crate::listener::Listener;
4use crate::PackageConfig;
5use crate::util::pathbytes::AsUnixPathBytes;
6use std::collections::HashSet;
7use std::io::{Read, Write};
8use std::path::Path;
9use std::{fs, io};
10use tar::{EntryType, Header as TarHeader};
11
12/// Tarball for control and data files
13pub(crate) struct Tarball<W: Write> {
14    added_directories: HashSet<Box<Path>>,
15    time: u64,
16    tar: tar::Builder<W>,
17}
18
19impl<W: Write> Tarball<W> {
20    pub fn new(dest: W, time: u64) -> Self {
21        Self {
22            added_directories: HashSet::new(),
23            time,
24            tar: tar::Builder::new(dest),
25        }
26    }
27
28    /// Copies all the files to be packaged into the tar archive.
29    pub fn archive_files(mut self, package_deb: &PackageConfig, rsyncable: bool, listener: &dyn Listener) -> CDResult<W> {
30        let mut archive_data_added = 0;
31        let mut prev_is_built = false;
32        let log_display_base_dir = std::env::current_dir().unwrap_or_default();
33
34        debug_assert!(package_deb.assets.unresolved.is_empty());
35        for asset in &package_deb.assets.resolved {
36            log_asset(asset, &log_display_base_dir, listener);
37
38            if let AssetSource::Symlink(source_path) = &asset.source {
39                let link_name = fs::read_link(source_path)
40                    .map_err(|e| CargoDebError::IoFile("Symlink asset", e, source_path.clone()))?;
41                self.symlink(&asset.c.target_path, &link_name)?;
42            } else {
43                let out_data = asset.source.data()?;
44                if rsyncable {
45                    if archive_data_added > 1_000_000 || prev_is_built != asset.c.is_built() {
46                        self.flush().map_err(|e| CargoDebError::Io(e).context("error while writing tar archive"))?;
47                        archive_data_added = 0;
48                    }
49                    // puts synchronization point between non-code and code assets
50                    prev_is_built = asset.c.is_built();
51                    archive_data_added += out_data.len();
52                }
53                self.file(&asset.c.target_path, &out_data, asset.c.chmod)?;
54            }
55        }
56
57        self.tar.into_inner().map_err(|e| CargoDebError::Io(e).context("error while finalizing tar archive"))
58    }
59
60    fn directory(&mut self, path: &Path) -> io::Result<()> {
61        let mut header = self.header_for_path(path, true)?;
62        header.set_mtime(self.time);
63        header.set_size(0);
64        header.set_mode(0o755);
65        header.set_entry_type(EntryType::Directory);
66        header.set_cksum();
67        self.tar.append(&header, &mut io::empty())
68    }
69
70    fn add_parent_directories(&mut self, path: &Path) -> CDResult<()> {
71        debug_assert!(path.is_relative());
72
73        let dirs = path.ancestors().skip(1)
74            .take_while(|&d| !self.added_directories.contains(d))
75            .filter(|&d| !d.as_os_str().is_empty())
76            .map(Box::from)
77            .collect::<Vec<_>>();
78
79        for directory in dirs.into_iter().rev() {
80            if let Err(e) = self.directory(&directory) {
81                return Err(CargoDebError::IoFile("Can't add directory to tarball", e, directory.into()));
82            }
83            self.added_directories.insert(directory);
84        }
85        Ok(())
86    }
87
88    pub(crate) fn file<P: AsRef<Path>>(&mut self, path: P, out_data: &[u8], chmod: u32) -> CDResult<()> {
89        self.file_(path.as_ref(), out_data, chmod)
90    }
91
92    fn file_(&mut self, path: &Path, out_data: &[u8], chmod: u32) -> CDResult<()> {
93        debug_assert!(path.is_relative());
94        self.add_parent_directories(path)?;
95
96        let mut header = self.header_for_path(path, false)
97            .map_err(|e| CargoDebError::IoFile("Can't set header path", e, path.into()))?;
98        header.set_mtime(self.time);
99        header.set_mode(chmod);
100        header.set_size(out_data.len() as u64);
101        header.set_cksum();
102        self.tar.append(&header, out_data)
103            .map_err(|e| CargoDebError::IoFile("Can't add file to tarball", e, path.into()))?;
104        Ok(())
105    }
106
107    pub(crate) fn symlink(&mut self, path: &Path, link_name: &Path) -> CDResult<()> {
108        debug_assert!(path.is_relative());
109        self.add_parent_directories(path.as_ref())?;
110
111        let mut header = self.header_for_path(path, false)
112            .map_err(|e| CargoDebError::IoFile("Can't set header path", e, path.into()))?;
113        header.set_mtime(self.time);
114        header.set_entry_type(EntryType::Symlink);
115        header.set_size(0);
116        header.set_mode(0o777);
117        header.set_link_name(link_name)
118            .map_err(|e| CargoDebError::IoFile("Can't set header link name", e, path.into()))?;
119        header.set_cksum();
120        self.tar.append(&header, &mut io::empty())
121            .map_err(|e| CargoDebError::IoFile("Can't add symlink to tarball", e, path.into()))?;
122        Ok(())
123    }
124
125    #[inline]
126    fn header_for_path(&mut self, path: &Path, is_dir: bool) -> io::Result<TarHeader> {
127        debug_assert!(path.is_relative());
128        let path_bytes = path.to_bytes();
129
130        let mut header = if path_bytes.len() < 98 {
131            TarHeader::new_old()
132        } else {
133            TarHeader::new_gnu()
134        };
135        self.set_header_path(&mut header, path_bytes, is_dir)?;
136        Ok(header)
137    }
138
139    #[inline(never)]
140    fn set_header_path(&mut self, header: &mut TarHeader, path_bytes: &[u8], is_dir: bool) -> io::Result<()> {
141        debug_assert!(is_dir || path_bytes.last() != Some(&b'/'));
142        let needs_slash = is_dir && path_bytes.last() != Some(&b'/');
143
144        const PREFIX: &[u8] = b"./";
145        let (prefix, path_slot) = header.as_old_mut().name.split_at_mut(PREFIX.len());
146        prefix.copy_from_slice(PREFIX);
147        let (path_slot, zero) = path_slot.split_at_mut(path_bytes.len().min(path_slot.len()));
148        path_slot.copy_from_slice(&path_bytes[..path_slot.len()]);
149        if cfg!(target_os = "windows") {
150            for b in path_slot {
151                if *b == b'\\' { *b = b'/' }
152            }
153        }
154
155        if let Some((t, rest)) = zero.split_first_mut() {
156            if !needs_slash {
157                *t = 0;
158                return Ok(());
159            }
160            if let Some(t2) = rest.first_mut() {
161                // Lintian insists on dir paths ending with /, which Rust doesn't
162                *t = b'/';
163                *t2 = 0;
164                return Ok(());
165            }
166        }
167
168        // GNU long name extension, copied from
169        // https://github.com/alexcrichton/tar-rs/blob/a1c3036af48fa02437909112239f0632e4cfcfae/src/builder.rs#L731-L744
170        let mut header = TarHeader::new_gnu();
171        const LONG_LINK: &[u8] = b"././@LongLink\0";
172        header.as_gnu_mut().ok_or(io::ErrorKind::Other)?
173            .name[..LONG_LINK.len()].copy_from_slice(LONG_LINK);
174        header.set_mode(0o644);
175        header.set_uid(0);
176        header.set_gid(0);
177        header.set_mtime(0);
178        // include \0 in len to be compliant with GNU tar
179        let suffix = b"/\0";
180        let suffix = if needs_slash { &suffix[..] } else { &suffix[1..] };
181        header.set_size((PREFIX.len() + path_bytes.len() + suffix.len()) as u64);
182        header.set_entry_type(EntryType::new(b'L'));
183        header.set_cksum();
184        self.tar.append(&header, PREFIX.chain(path_bytes).chain(suffix))
185    }
186
187    fn flush(&mut self) -> io::Result<()> {
188        self.tar.get_mut().flush()
189    }
190
191    pub fn into_inner(self) -> io::Result<W> {
192        self.tar.into_inner()
193    }
194}
195
196fn log_asset(asset: &Asset, log_display_base_dir: &Path, listener: &dyn Listener) {
197    let operation = if let AssetSource::Symlink(_) = &asset.source {
198        "Linking"
199    } else {
200        "Adding"
201    };
202    let mut log_line = format!("'{}' {}-> {}",
203        asset.processed_from.as_ref().and_then(|p| p.original_path.as_deref()).or(asset.source.path())
204            .map(|p| p.strip_prefix(log_display_base_dir).unwrap_or(p))
205            .unwrap_or_else(|| Path::new("-")).display(),
206        asset.processed_from.as_ref().map(|p| p.action).unwrap_or_default(),
207        asset.c.target_path.display()
208    );
209    if let Some(len) = asset.source.file_size() {
210        let (size, unit) = human_size(len);
211        use std::fmt::Write;
212        let _ = write!(&mut log_line, " ({size}{unit})");
213    }
214    listener.progress(operation, log_line);
215}
216
217fn human_size(len: u64) -> (u64, &'static str) {
218    if len < 1000 {
219        return (len, "B");
220    }
221    if len < 1_000_000 {
222        return (len.div_ceil(1000), "KB");
223    }
224    (len.div_ceil(1_000_000), "MB")
225}
226
227#[cfg(test)]
228mod tests {
229    use super::Tarball;
230    use std::{io::{Cursor, Read}, path::Path};
231    use tar::{Archive, EntryType};
232
233    struct ExpectedEntry<'a> {
234        path: &'a str,
235        entry_type: EntryType,
236        mode: u32,
237        check: Option<Box<dyn Fn(&mut tar::Entry<Cursor<Vec<u8>>>) + 'a>>,
238    }
239
240    impl<'a> ExpectedEntry<'a> {
241        fn with_check<F>(mut self, check: F) -> Self
242            where F: Fn(&mut tar::Entry<Cursor<Vec<u8>>>) + 'a
243        {
244            self.check = Some(Box::new(check));
245            self
246        }
247    }
248
249    fn expected_entry(path: &str, entry_type: EntryType, mode: u32) -> ExpectedEntry<'_> {
250        ExpectedEntry { path, entry_type, mode, check: None }
251    }
252
253    fn check_tarball_content(tarball: Vec<u8>, expected_entries: &[ExpectedEntry]) {
254        let cursor = Cursor::new(tarball);
255        let mut archive = Archive::new(cursor);
256        let mut entries = archive.entries().unwrap();
257        let mut expected_entries = expected_entries.iter();
258        loop {
259            let (entry_result, expected_entry) = match (entries.next(), expected_entries.next()) {
260                (Some(entry_result), Some(expected_entry)) => (entry_result, expected_entry),
261                (None, None) => break,
262                _ => panic!("mismatched number of entries"),
263            };
264            let mut entry = entry_result.unwrap();
265            let path = entry.path().unwrap().to_string_lossy().to_string();
266            let entry_type = entry.header().entry_type();
267            let mode = entry.header().mode().unwrap();
268            let mtime = entry.header().mtime().unwrap();
269            assert_eq!(path.strip_prefix("./").unwrap(), expected_entry.path);
270            assert_eq!(entry_type, expected_entry.entry_type);
271            assert_eq!(mode, expected_entry.mode);
272            assert_eq!(mtime, 1234567890);
273            if let Some(check) = &expected_entry.check {
274                check(&mut entry);
275            }
276        }
277    }
278
279    #[test]
280    fn basic() {
281        let buffer = Vec::new();
282        let mut tarball = Tarball::new(buffer, 1234567890);
283        let file_content = b"Hello, world!";
284        tarball.file("test/file.txt", file_content, 0o644).unwrap();
285        let script_content = b"#!/bin/bash\necho 'test'";
286        tarball.file("usr/bin/script", script_content, 0o755).unwrap();
287        tarball.symlink(Path::new("usr/bin/link"), Path::new("script")).unwrap();
288
289        let buffer = tarball.into_inner().unwrap();
290        check_tarball_content(buffer, &[
291            expected_entry("test/", EntryType::Directory, 0o755),
292            expected_entry("test/file.txt", EntryType::Regular, 0o644).with_check(|entry| {
293                let mut content = Vec::new();
294                entry.read_to_end(&mut content).unwrap();
295                assert_eq!(content, file_content);
296            }),
297            expected_entry("usr/", EntryType::Directory, 0o755),
298            expected_entry("usr/bin/", EntryType::Directory, 0o755),
299            expected_entry("usr/bin/script", EntryType::Regular, 0o755).with_check(|entry| {
300                let mut content = Vec::new();
301                entry.read_to_end(&mut content).unwrap();
302                assert_eq!(content, script_content);
303            }),
304            expected_entry("usr/bin/link", EntryType::Symlink, 0o777).with_check(|entry| {
305                let link_name = entry.header().link_name().unwrap().unwrap();
306                assert_eq!(link_name.to_string_lossy(), "script");
307            }),
308        ]);
309    }
310
311    #[test]
312    fn long_path() {
313        let buffer = Vec::new();
314        let mut tarball = Tarball::new(buffer, 1234567890);
315
316        tarball.file("a.txt", b"start", 0o644).unwrap();
317        let level = "long/";
318        let deep_path = level.repeat(25) + "file.txt";
319        tarball.file(&deep_path, b"long path", 0o644).unwrap();
320        let long_filename = "very_".repeat(25) + "long_filename.txt";
321        tarball.file(&long_filename, b"long filename", 0o644).unwrap();
322        tarball.file("b.txt", b"end", 0o644).unwrap();
323        let buffer = tarball.into_inner().unwrap();
324
325        let mut expected_entries = vec![expected_entry("a.txt", EntryType::Regular, 0o644)];
326        expected_entries.extend((1..=25).map(|i| expected_entry(&deep_path[..i * level.len()], EntryType::Directory, 0o755)));
327        expected_entries.extend([
328            expected_entry(&deep_path, EntryType::Regular, 0o644),
329            expected_entry(&long_filename, EntryType::Regular, 0o644),
330            expected_entry("b.txt", EntryType::Regular, 0o644),
331        ]);
332        check_tarball_content(buffer, &expected_entries);
333    }
334}
cargo_deb/deb/tar.rs

cargo_deb/deb/
tar.rs
