fuchsia_archive/
write.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::name::validate_name;
6use crate::{
7    DirectoryEntry, Error, Index, IndexEntry, CONTENT_ALIGNMENT, DIRECTORY_ENTRY_LEN,
8    DIR_CHUNK_TYPE, DIR_NAMES_CHUNK_TYPE, INDEX_ENTRY_LEN, INDEX_LEN, MAGIC_INDEX_VALUE,
9};
10use std::collections::BTreeMap;
11use std::convert::TryInto as _;
12use std::io::{copy, Read, Write};
13use zerocopy::IntoBytes as _;
14
15fn write_zeros(mut target: impl Write, count: usize) -> Result<(), Error> {
16    let b = vec![0u8; count];
17    target.write_all(&b).map_err(Error::Write)?;
18    Ok(())
19}
20
21/// Write a FAR-formatted archive to the target.
22///
23/// # Arguments
24///
25/// * `target` - receives the serialized bytes of the archive
26/// * `path_content_map` - map from archive relative path to (size, contents)
27pub fn write(
28    mut target: impl Write,
29    path_content_map: BTreeMap<impl AsRef<[u8]>, (u64, Box<dyn Read + '_>)>,
30) -> Result<(), Error> {
31    // `write` could be written to take the content chunks as one of:
32    // 1. Box<dyn Read>: requires an allocation per chunk
33    // 2. &mut dyn Read: requires that the caller retain ownership of the chunks, which could result
34    //                   in the caller building a mirror data structure just to own the chunks
35    // 3. impl Read: requires that all the chunks have the same type
36    let mut path_data: Vec<u8> = vec![];
37    let mut directory_entries = vec![];
38    for (destination_name, (size, _)) in &path_content_map {
39        let destination_name = destination_name.as_ref();
40        validate_name(destination_name)?;
41        directory_entries.push(DirectoryEntry {
42            name_offset: u32::try_from(path_data.len()).map_err(|_| Error::TooMuchPathData)?.into(),
43            name_length: destination_name
44                .len()
45                .try_into()
46                .map_err(|_| Error::NameTooLong(destination_name.len()))?,
47            reserved: 0.into(),
48            data_offset: 0.into(),
49            data_length: (*size).into(),
50            reserved2: 0.into(),
51        });
52        path_data.extend_from_slice(destination_name.as_bytes());
53    }
54
55    let index = Index { magic: MAGIC_INDEX_VALUE, length: (2 * INDEX_ENTRY_LEN).into() };
56
57    let dir_index = IndexEntry {
58        chunk_type: DIR_CHUNK_TYPE,
59        offset: (INDEX_LEN + INDEX_ENTRY_LEN * 2).into(),
60        length: (directory_entries.len() as u64 * DIRECTORY_ENTRY_LEN).into(),
61    };
62
63    let name_index = IndexEntry {
64        chunk_type: DIR_NAMES_CHUNK_TYPE,
65        offset: (dir_index.offset.get() + dir_index.length.get()).into(),
66        // path_data.len() is at most u32::MAX + u16::MAX, so the aligning will not overflow a u64.
67        length: (path_data.len() as u64).next_multiple_of(8).into(),
68    };
69
70    target.write_all(index.as_bytes()).map_err(Error::SerializeIndex)?;
71
72    target.write_all(dir_index.as_bytes()).map_err(Error::SerializeDirectoryChunkIndexEntry)?;
73
74    target
75        .write_all(name_index.as_bytes())
76        .map_err(Error::SerializeDirectoryNamesChunkIndexEntry)?;
77
78    let mut content_offset = name_index
79        .offset
80        .get()
81        .checked_add(name_index.length.get())
82        .ok_or(Error::ContentChunkOffsetOverflow)?
83        .checked_next_multiple_of(CONTENT_ALIGNMENT)
84        .ok_or(Error::ContentChunkOffsetOverflow)?;
85
86    for entry in &mut directory_entries {
87        entry.data_offset = content_offset.into();
88        content_offset = content_offset
89            .checked_add(entry.data_length.get())
90            .ok_or(Error::ContentChunkOffsetOverflow)?
91            .checked_next_multiple_of(CONTENT_ALIGNMENT)
92            .ok_or(Error::ContentChunkOffsetOverflow)?;
93        target.write_all(entry.as_bytes()).map_err(Error::SerializeDirectoryEntry)?;
94    }
95
96    target.write_all(&path_data).map_err(Error::Write)?;
97
98    write_zeros(&mut target, name_index.length.get() as usize - path_data.len())?;
99
100    let pos = name_index.offset.get() + name_index.length.get();
101    // This alignment won't overflow, it was checked for the first content_offset.
102    let padding_count = pos.next_multiple_of(CONTENT_ALIGNMENT) - pos;
103    write_zeros(&mut target, padding_count as usize)?;
104
105    for (entry_index, (archive_path, (_, mut contents))) in path_content_map.into_iter().enumerate()
106    {
107        let bytes_read = copy(&mut contents, &mut target).map_err(Error::Copy)?;
108        if bytes_read != directory_entries[entry_index].data_length.get() {
109            return Err(Error::ContentChunkSizeMismatch {
110                expected: directory_entries[entry_index].data_length.get(),
111                actual: bytes_read,
112                path: archive_path.as_ref().into(),
113            });
114        }
115        let pos = directory_entries[entry_index].data_offset.get()
116            + directory_entries[entry_index].data_length.get();
117        let padding_count = pos
118            .checked_next_multiple_of(CONTENT_ALIGNMENT)
119            .ok_or(Error::ContentChunkOffsetOverflow)?
120            - pos;
121        write_zeros(&mut target, padding_count as usize)?;
122    }
123
124    Ok(())
125}
126
127#[cfg(test)]
128mod tests {
129    use super::*;
130    use crate::tests::example_archive;
131    use assert_matches::assert_matches;
132    use itertools::assert_equal;
133    use std::io::Cursor;
134
135    #[test]
136    fn creates_example_archive() {
137        let a_contents = "a\n".as_bytes();
138        let b_contents = "b\n".as_bytes();
139        let dirc_contents = "dir/c\n".as_bytes();
140        let mut path_content_map: BTreeMap<&str, (u64, Box<dyn Read>)> = BTreeMap::new();
141        path_content_map.insert("a", (a_contents.len() as u64, Box::new(a_contents)));
142        path_content_map.insert("b", (b_contents.len() as u64, Box::new(b_contents)));
143        path_content_map.insert("dir/c", (dirc_contents.len() as u64, Box::new(dirc_contents)));
144        let mut target = Cursor::new(Vec::new());
145        write(&mut target, path_content_map).unwrap();
146        assert!(target.get_ref()[0..8] == MAGIC_INDEX_VALUE);
147        let example_archive = example_archive();
148        let target_ref = target.get_ref();
149        assert_equal(target_ref, &example_archive);
150        assert_eq!(*target_ref, example_archive);
151    }
152
153    #[test]
154    fn validates_name() {
155        let path_content_map =
156            BTreeMap::from_iter([(".", (0, Box::new("".as_bytes()) as Box<dyn Read>))]);
157        let mut target = Cursor::new(Vec::new());
158        assert_matches!(
159            write(&mut target, path_content_map),
160            Err(Error::NameContainsDotSegment(_))
161        );
162    }
163
164    #[test]
165    fn validates_name_length() {
166        let name = String::from_utf8(vec![b'a'; 2usize.pow(16)]).unwrap();
167        let mut path_content_map: BTreeMap<&str, (u64, Box<dyn Read>)> = BTreeMap::new();
168        path_content_map.insert(&name, (0, Box::new("".as_bytes())));
169        let mut target = Cursor::new(Vec::new());
170        assert_matches!(
171            write(&mut target, path_content_map),
172            Err(Error::NameTooLong(len)) if len == 2usize.pow(16)
173        );
174    }
175}
fuchsia_archive/write.rs

fuchsia_archive/
write.rs
