fuchsia_pkg/
meta_contents.rs

1// Copyright 2019 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::errors::MetaContentsError;
6use fuchsia_merkle::Hash;
7use fuchsia_url::validate_resource_path;
8use std::collections::HashMap;
9use std::io;
10use std::str::FromStr;
11
12/// A `MetaContents` represents the "meta/contents" file of a Fuchsia archive
13/// file of a Fuchsia package.
14/// It validates that all resource paths are valid and that none of them start
15/// with "meta/".
16#[derive(Debug, PartialEq, Eq, Clone)]
17pub struct MetaContents {
18    contents: HashMap<String, Hash>,
19}
20
21impl MetaContents {
22    pub const PATH: &'static str = "meta/contents";
23
24    /// Creates a `MetaContents` from a `map` from resource paths to Merkle roots.
25    /// Validates that:
26    ///   1. all resource paths are valid Fuchsia package resource paths,
27    ///   2. none of the resource paths start with "meta/",
28    ///   3. none of the resource paths are "meta",
29    ///   4. none of the resource paths have directories that collide with other full resource
30    ///      paths, e.g. path combination ["foo", "foo/bar"] would be rejected because it has
31    ///      both a file and a directory at path "foo".
32    ///
33    /// # Examples
34    /// ```
35    /// # use fuchsia_merkle::Hash;
36    /// # use fuchsia_pkg::MetaContents;
37    /// # use maplit::hashmap;
38    /// # use std::str::FromStr;
39    /// let map = hashmap! {
40    ///     "bin/my_prog".to_string() =>
41    ///         Hash::from_str(
42    ///             "0000000000000000000000000000000000000000000000000000000000000000")
43    ///         .unwrap(),
44    ///     "lib/mylib.so".to_string() =>
45    ///         Hash::from_str(
46    ///             "1111111111111111111111111111111111111111111111111111111111111111")
47    ///         .unwrap(),
48    /// };
49    /// let meta_contents = MetaContents::from_map(map).unwrap();
50    pub fn from_map(map: HashMap<String, Hash>) -> Result<Self, MetaContentsError> {
51        for resource_path in map.keys() {
52            validate_resource_path(resource_path).map_err(|e| {
53                MetaContentsError::InvalidResourcePath { cause: e, path: resource_path.to_string() }
54            })?;
55            if resource_path.starts_with("meta/") || resource_path == "meta" {
56                return Err(MetaContentsError::ExternalContentInMetaDirectory {
57                    path: resource_path.to_string(),
58                });
59            }
60            for (i, _) in resource_path.match_indices('/') {
61                if map.contains_key(&resource_path[..i]) {
62                    return Err(MetaContentsError::FileDirectoryCollision {
63                        path: resource_path[..i].to_string(),
64                    });
65                }
66            }
67        }
68        Ok(MetaContents { contents: map })
69    }
70
71    /// Serializes a "meta/contents" file to `writer`.
72    ///
73    /// # Examples
74    /// ```
75    /// # use fuchsia_merkle::Hash;
76    /// # use fuchsia_pkg::MetaContents;
77    /// # use maplit::hashmap;
78    /// # use std::str::FromStr;
79    /// let map = hashmap! {
80    ///     "bin/my_prog".to_string() =>
81    ///         Hash::from_str(
82    ///             "0000000000000000000000000000000000000000000000000000000000000000")
83    ///         .unwrap(),
84    ///     "lib/mylib.so".to_string() =>
85    ///         Hash::from_str(
86    ///             "1111111111111111111111111111111111111111111111111111111111111111")
87    ///         .unwrap(),
88    /// };
89    /// let meta_contents = MetaContents::from_map(map).unwrap();
90    /// let mut bytes = Vec::new();
91    /// meta_contents.serialize(&mut bytes).unwrap();
92    /// let expected = "bin/my_prog=0000000000000000000000000000000000000000000000000000000000000000\n\
93    ///                 lib/mylib.so=1111111111111111111111111111111111111111111111111111111111111111\n";
94    /// assert_eq!(bytes.as_slice(), expected.as_bytes());
95    /// ```
96    pub fn serialize(&self, writer: &mut impl io::Write) -> io::Result<()> {
97        let mut entries = self.contents.iter().collect::<Vec<_>>();
98        entries.sort();
99        for (path, hash) in entries {
100            writeln!(writer, "{path}={hash}")?;
101        }
102        Ok(())
103    }
104
105    /// Deserializes a "meta/contents" file from a `reader`.
106    ///
107    /// # Examples
108    /// ```
109    /// # use fuchsia_merkle::Hash;
110    /// # use fuchsia_pkg::MetaContents;
111    /// # use maplit::hashmap;
112    /// # use std::str::FromStr;
113    /// let bytes = "bin/my_prog=0000000000000000000000000000000000000000000000000000000000000000\n\
114    ///              lib/mylib.so=1111111111111111111111111111111111111111111111111111111111111111\n".as_bytes();
115    /// let meta_contents = MetaContents::deserialize(bytes).unwrap();
116    /// let expected_contents = hashmap! {
117    ///     "bin/my_prog".to_string() =>
118    ///         Hash::from_str(
119    ///             "0000000000000000000000000000000000000000000000000000000000000000")
120    ///         .unwrap(),
121    ///     "lib/mylib.so".to_string() =>
122    ///         Hash::from_str(
123    ///             "1111111111111111111111111111111111111111111111111111111111111111")
124    ///         .unwrap(),
125    /// };
126    /// assert_eq!(meta_contents.contents(), &expected_contents);
127    /// ```
128    pub fn deserialize(mut reader: impl io::BufRead) -> Result<Self, MetaContentsError> {
129        let mut contents = HashMap::new();
130        let mut buf = String::new();
131        while reader.read_line(&mut buf)? > 0 {
132            let line = buf.trim_end();
133            let i = line.rfind('=').ok_or_else(|| MetaContentsError::EntryHasNoEqualsSign {
134                entry: line.to_string(),
135            })?;
136
137            let hash = Hash::from_str(&line[i + 1..])?;
138            let path = line[..i].to_string();
139
140            use std::collections::hash_map::Entry;
141            match contents.entry(path) {
142                Entry::Vacant(entry) => {
143                    entry.insert(hash);
144                }
145                Entry::Occupied(entry) => {
146                    return Err(MetaContentsError::DuplicateResourcePath {
147                        path: entry.key().clone(),
148                    });
149                }
150            }
151
152            buf.clear();
153        }
154        contents.shrink_to_fit();
155        Self::from_map(contents)
156    }
157
158    /// Get the map from blob resource paths to Merkle Tree root hashes.
159    pub fn contents(&self) -> &HashMap<String, Hash> {
160        &self.contents
161    }
162
163    /// Take the map from blob resource paths to Merkle Tree root hashes.
164    pub fn into_contents(self) -> HashMap<String, Hash> {
165        self.contents
166    }
167
168    /// Take the Merkle Tree root hashes in a iterator. The returned iterator may include
169    /// duplicates.
170    pub fn into_hashes_undeduplicated(self) -> impl Iterator<Item = Hash> {
171        self.contents.into_values()
172    }
173}
174
175#[cfg(test)]
176mod tests {
177    use super::*;
178    use crate::test::*;
179    use assert_matches::assert_matches;
180    use fuchsia_url::errors::ResourcePathError;
181    use fuchsia_url::test::*;
182    use maplit::hashmap;
183    use proptest::prelude::*;
184
185    fn zeros_hash() -> Hash {
186        Hash::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap()
187    }
188
189    fn ones_hash() -> Hash {
190        Hash::from_str("1111111111111111111111111111111111111111111111111111111111111111").unwrap()
191    }
192
193    #[test]
194    fn deserialize_empty_file() {
195        let empty = Vec::new();
196        let meta_contents = MetaContents::deserialize(empty.as_slice()).unwrap();
197        assert_eq!(meta_contents.contents(), &HashMap::new());
198        assert_eq!(meta_contents.into_contents(), HashMap::new());
199    }
200
201    #[test]
202    fn deserialize_known_file() {
203        let bytes =
204            "a-host/path=0000000000000000000000000000000000000000000000000000000000000000\n\
205             other/host/path=1111111111111111111111111111111111111111111111111111111111111111\n"
206                .as_bytes();
207        let meta_contents = MetaContents::deserialize(bytes).unwrap();
208        let expected_contents = hashmap! {
209            "a-host/path".to_string() => zeros_hash(),
210            "other/host/path".to_string() => ones_hash(),
211        };
212        assert_eq!(meta_contents.contents(), &expected_contents);
213        assert_eq!(meta_contents.into_contents(), expected_contents);
214    }
215
216    #[test]
217    fn from_map_rejects_meta_file() {
218        let map = hashmap! {
219            "meta".to_string() => zeros_hash(),
220        };
221        assert_matches!(
222            MetaContents::from_map(map),
223            Err(MetaContentsError::ExternalContentInMetaDirectory { path }) if path == "meta"
224        );
225    }
226
227    #[test]
228    fn from_map_rejects_file_dir_collisions() {
229        for (map, expected_path) in [
230            (
231                hashmap! {
232                    "foo".to_string() => zeros_hash(),
233                    "foo/bar".to_string() => zeros_hash(),
234                },
235                "foo",
236            ),
237            (
238                hashmap! {
239                    "foo/bar".to_string() => zeros_hash(),
240                    "foo/bar/baz".to_string() => zeros_hash(),
241                },
242                "foo/bar",
243            ),
244            (
245                hashmap! {
246                    "foo".to_string() => zeros_hash(),
247                    "foo/bar/baz".to_string() => zeros_hash(),
248                },
249                "foo",
250            ),
251        ] {
252            assert_matches!(
253                MetaContents::from_map(map),
254                Err(MetaContentsError::FileDirectoryCollision { path }) if path == expected_path
255            );
256        }
257    }
258
259    proptest! {
260        #![proptest_config(ProptestConfig{
261            failure_persistence: None,
262            ..Default::default()
263        })]
264
265        #[test]
266        fn from_map_rejects_invalid_resource_path(
267            ref path in random_resource_path(1, 3),
268            ref hex in random_merkle_hex())
269        {
270            prop_assume!(!path.starts_with("meta/"));
271            let invalid_path = format!("{path}/");
272            let map = hashmap! {
273                invalid_path.clone() =>
274                    Hash::from_str(hex.as_str()).unwrap(),
275            };
276            assert_matches!(
277                MetaContents::from_map(map),
278                Err(MetaContentsError::InvalidResourcePath {
279                    cause: ResourcePathError::PathEndsWithSlash,
280                    path }) if path == invalid_path
281            );
282        }
283
284        #[test]
285        fn from_map_rejects_file_in_meta(
286            ref path in random_resource_path(1, 3),
287            ref hex in random_merkle_hex())
288        {
289            let invalid_path = format!("meta/{path}");
290            let map = hashmap! {
291                invalid_path.clone() =>
292                    Hash::from_str(hex.as_str()).unwrap(),
293            };
294            assert_matches!(
295                MetaContents::from_map(map),
296                Err(MetaContentsError::ExternalContentInMetaDirectory { path }) if path == invalid_path
297            );
298        }
299
300        #[test]
301        fn serialize(
302            ref path0 in random_external_resource_path(),
303            ref hex0 in random_merkle_hex(),
304            ref path1 in random_external_resource_path(),
305            ref hex1 in random_merkle_hex())
306        {
307            prop_assume!(path0 != path1);
308            let map = hashmap! {
309                path0.clone() =>
310                    Hash::from_str(hex0.as_str()).unwrap(),
311                path1.clone() =>
312                    Hash::from_str(hex1.as_str()).unwrap(),
313            };
314            let meta_contents = MetaContents::from_map(map);
315            prop_assume!(meta_contents.is_ok());
316            let meta_contents = meta_contents.unwrap();
317            let mut bytes = Vec::new();
318
319            meta_contents.serialize(&mut bytes).unwrap();
320
321            let ((first_path, first_hex), (second_path, second_hex)) = if path0 <= path1 {
322                ((path0, hex0), (path1, hex1))
323            } else {
324                ((path1, hex1), (path0, hex0))
325            };
326            let expected = format!(
327                "{}={}\n{}={}\n",
328                first_path,
329                first_hex.to_ascii_lowercase(),
330                second_path,
331                second_hex.to_ascii_lowercase());
332            prop_assert_eq!(bytes.as_slice(), expected.as_bytes());
333        }
334
335        #[test]
336        fn serialize_deserialize_is_id(
337            contents in prop::collection::hash_map(
338                random_external_resource_path(), random_hash(), 0..4)
339        ) {
340            let meta_contents = MetaContents::from_map(contents);
341            prop_assume!(meta_contents.is_ok());
342            let meta_contents = meta_contents.unwrap();
343            let mut serialized = Vec::new();
344            meta_contents.serialize(&mut serialized).unwrap();
345            let deserialized = MetaContents::deserialize(serialized.as_slice()).unwrap();
346            prop_assert_eq!(meta_contents, deserialized);
347        }
348    }
349}
fuchsia_pkg/meta_contents.rs

fuchsia_pkg/
meta_contents.rs
