Revert "Revert "stone: Decode unknown variants""

This reverts commit 56e6ebc.

Author: tarkah

crates/stone/src/header/v1.rs

@@ -11,8 +11,8 @@ const INTEGRITY_CHECK: [u8; 21] = [0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0, 5,
 ///
 /// Some types are now legacy as we're going to use Ion to define them.
 ///
-#[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
 pub enum FileType {
     /// Binary package
     Binary = 1,
@@ -25,6 +25,8 @@ pub enum FileType {
 
     /// (Legacy) build manifest
     BuildManifest,
+
+    Unknown = 255,
 }
 
 /// Header for the v1 format version
@@ -49,7 +51,7 @@ impl Header {
             2 => FileType::Delta,
             3 => FileType::Repository,
             4 => FileType::BuildManifest,
-            f => return Err(DecodeError::UnknownFileType(f)),
+            _ => FileType::Unknown,
         };
 
         Ok(Self {
@@ -76,6 +78,4 @@ impl Header {
 pub enum DecodeError {
     #[error("Corrupt header, failed integrity check")]
     Corrupt,
-    #[error("Unknown file type: {0}")]
-    UnknownFileType(u8),
 }

crates/stone/src/payload/layout.rs

@@ -11,8 +11,8 @@ use crate::{ReadExt, WriteExt};
 
 /// Layout entries record their target file type so they can be rebuilt on
 /// the target installation.
-#[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
 pub enum FileType {
     /// Regular file
     Regular = 1,
@@ -34,6 +34,8 @@ pub enum FileType {
 
     /// UNIX Socket
     Socket,
+
+    Unknown = 255,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -47,6 +49,8 @@ pub enum Entry {
     BlockDevice(AStr),
     Fifo(AStr),
     Socket(AStr),
+
+    Unknown(AStr, AStr),
 }
 
 impl Entry {
@@ -59,18 +63,20 @@ impl Entry {
             Entry::BlockDevice(_) => vec![],
             Entry::Fifo(_) => vec![],
             Entry::Socket(_) => vec![],
+            Entry::Unknown(source, _) => source.as_bytes().to_vec(),
         }
     }
 
     pub fn target(&self) -> &str {
         match self {
-            Entry::Regular(_, target) => target,
-            Entry::Symlink(_, target) => target,
-            Entry::Directory(target) => target,
-            Entry::CharacterDevice(target) => target,
-            Entry::BlockDevice(target) => target,
-            Entry::Fifo(target) => target,
-            Entry::Socket(target) => target,
+            Entry::Regular(_, target)
+            | Entry::Symlink(_, target)
+            | Entry::Directory(target)
+            | Entry::CharacterDevice(target)
+            | Entry::BlockDevice(target)
+            | Entry::Fifo(target)
+            | Entry::Socket(target)
+            | Entry::Unknown(_, target) => target,
         }
     }
 
@@ -83,6 +89,7 @@ impl Entry {
             Entry::BlockDevice(_) => 5,
             Entry::Fifo(_) => 6,
             Entry::Socket(_) => 7,
+            Entry::Unknown(..) => 255,
         }
     }
 }
@@ -118,14 +125,13 @@ impl Record for Layout {
             5 => FileType::BlockDevice,
             6 => FileType::Fifo,
             7 => FileType::Socket,
-            t => return Err(DecodeError::UnknownFileType(t)),
+            _ => FileType::Unknown,
         };
 
         let _padding = reader.read_array::<11>()?;
 
         // Make the layout entry *usable*
         let entry = match file_type {
-            // BUG: boulder stores xxh128 as le bytes not be
             FileType::Regular => {
                 let source = reader.read_vec(source_length as usize)?;
                 let hash = u128::from_be_bytes(source.try_into().unwrap());
@@ -136,12 +142,16 @@ impl Record for Layout {
                 sanitize(&reader.read_string(target_length as u64)?).into(),
             ),
             FileType::Directory => Entry::Directory(sanitize(&reader.read_string(target_length as u64)?).into()),
-            _ => {
-                if source_length > 0 {
-                    let _ = reader.read_vec(source_length as usize);
-                }
-                unreachable!()
+            FileType::CharacterDevice => {
+                Entry::CharacterDevice(sanitize(&reader.read_string(target_length as u64)?).into())
             }
+            FileType::BlockDevice => Entry::BlockDevice(sanitize(&reader.read_string(target_length as u64)?).into()),
+            FileType::Fifo => Entry::Fifo(sanitize(&reader.read_string(target_length as u64)?).into()),
+            FileType::Socket => Entry::Socket(sanitize(&reader.read_string(target_length as u64)?).into()),
+            FileType::Unknown => Entry::Unknown(
+                sanitize(&reader.read_string(source_length as u64)?).into(),
+                sanitize(&reader.read_string(target_length as u64)?).into(),
+            ),
         };
 
         Ok(Self {

crates/stone/src/payload/meta.rs

@@ -17,9 +17,9 @@ pub struct Meta {
     pub kind: Kind,
 }
 
-#[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, strum::Display)]
 #[strum(serialize_all = "lowercase")]
+#[repr(u8)]
 pub enum Dependency {
     /// Just the plain name of a package
     #[strum(serialize = "name")]
@@ -50,9 +50,10 @@ pub enum Dependency {
 
     /// An emul32-compatible pkgconfig .pc dependency (lib32/*.pc)
     PkgConfig32,
+
+    Unknown = 255,
 }
 
-#[repr(u8)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Kind {
     Int8(i8),
@@ -66,6 +67,7 @@ pub enum Kind {
     String(String),
     Dependency(Dependency, String),
     Provider(Dependency, String),
+    Unknown(Vec<u8>),
 }
 
 impl Kind {
@@ -85,58 +87,61 @@ impl Kind {
             Kind::Dependency(_, s) => s.len() + 2,
             // Plus dep size & nul terminator
             Kind::Provider(_, s) => s.len() + 2,
+            Kind::Unknown(data) => data.len(),
         }
     }
 }
 
-#[repr(u16)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u16)]
 pub enum Tag {
     // Name of the package
     Name = 1,
     // Architecture of the package
-    Architecture = 2,
+    Architecture,
     // Version of the package
-    Version = 3,
+    Version,
     // Summary of the package
-    Summary = 4,
+    Summary,
     // Description of the package
-    Description = 5,
+    Description,
     // Homepage for the package
-    Homepage = 6,
+    Homepage,
     // ID for the source package, used for grouping
-    SourceID = 7,
+    SourceID,
     // Runtime dependencies
-    Depends = 8,
+    Depends,
     // Provides some capability or name
-    Provides = 9,
+    Provides,
     // Conflicts with some capability or name
-    Conflicts = 10,
+    Conflicts,
     // Release number for the package
-    Release = 11,
+    Release,
     // SPDX license identifier
-    License = 12,
+    License,
     // Currently recorded build number
-    BuildRelease = 13,
+    BuildRelease,
     // Repository index specific (relative URI)
-    PackageURI = 14,
+    PackageURI,
     // Repository index specific (Package hash)
-    PackageHash = 15,
+    PackageHash,
     // Repository index specific (size on disk)
-    PackageSize = 16,
+    PackageSize,
     // A Build Dependency
-    BuildDepends = 17,
+    BuildDepends,
     // Upstream URI for the source
-    SourceURI = 18,
+    SourceURI,
     // Relative path for the source within the upstream URI
-    SourcePath = 19,
+    SourcePath,
     // Ref/commit of the upstream source
-    SourceRef = 20,
+    SourceRef,
+
+    Unknown = u16::MAX,
 }
 
 /// Helper to decode a dependency's encoded kind
-fn decode_dependency(i: u8) -> Result<Dependency, DecodeError> {
-    let result = match i {
+fn decode_dependency(i: u8) -> Dependency {
+    match i {
         0 => Dependency::PackageName,
         1 => Dependency::SharedLibrary,
         2 => Dependency::PkgConfig,
@@ -146,9 +151,8 @@ fn decode_dependency(i: u8) -> Result<Dependency, DecodeError> {
         6 => Dependency::Binary,
         7 => Dependency::SystemBinary,
         8 => Dependency::PkgConfig32,
-        _ => return Err(DecodeError::UnknownDependency(i)),
-    };
-    Ok(result)
+        _ => Dependency::Unknown,
+    }
 }
 
 impl Record for Meta {
@@ -176,7 +180,7 @@ impl Record for Meta {
             18 => Tag::SourceURI,
             19 => Tag::SourcePath,
             20 => Tag::SourceRef,
-            t => return Err(DecodeError::UnknownMetaTag(t)),
+            _ => Tag::Unknown,
         };
 
         let kind = reader.read_u8()?;
@@ -197,15 +201,15 @@ impl Record for Meta {
             9 => Kind::String(sanitize(reader.read_string(length as u64)?)),
             10 => Kind::Dependency(
                 // DependencyKind u8 subtracted from length
-                decode_dependency(reader.read_u8()?)?,
+                decode_dependency(reader.read_u8()?),
                 sanitize(reader.read_string(length as u64 - 1)?),
             ),
             11 => Kind::Provider(
                 // DependencyKind u8 subtracted from length
-                decode_dependency(reader.read_u8()?)?,
+                decode_dependency(reader.read_u8()?),
                 sanitize(reader.read_string(length as u64 - 1)?),
             ),
-            k => return Err(DecodeError::UnknownMetaKind(k)),
+            _ => Kind::Unknown(reader.read_vec(length as usize)?),
         };
 
         Ok(Self { tag, kind })
@@ -224,6 +228,7 @@ impl Record for Meta {
             Kind::String(_) => 9,
             Kind::Dependency(_, _) => 10,
             Kind::Provider(_, _) => 11,
+            Kind::Unknown(_) => 255,
         };
 
         writer.write_u32(self.kind.size() as u32)?;
@@ -250,6 +255,9 @@ impl Record for Meta {
                 writer.write_all(s.as_bytes())?;
                 writer.write_u8(b'\0')?;
             }
+            Kind::Unknown(data) => {
+                writer.write_all(data)?;
+            }
         }
 
         Ok(())

crates/stone/src/payload/mod.rs

@@ -17,30 +17,32 @@ pub use self::layout::Layout;
 pub use self::meta::Meta;
 use crate::{ReadExt, WriteExt};
 
-#[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
 pub enum Kind {
     // The Metadata store
     Meta = 1,
     // File store, i.e. hash indexed
-    Content = 2,
+    Content,
     // Map Files to Disk with basic UNIX permissions + types
-    Layout = 3,
+    Layout,
     // For indexing the deduplicated store
-    Index = 4,
+    Index,
     // Attribute storage
-    Attributes = 5,
-    // For Writer interim
-    Dumb = 6,
+    Attributes,
+
+    Unknown = 255,
 }
 
-#[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
 pub enum Compression {
     // Payload has no compression
     None = 1,
     // Payload uses ZSTD compression
-    Zstd = 2,
+    Zstd,
+
+    Unknown = 255,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -71,14 +73,13 @@ impl Header {
             3 => Kind::Layout,
             4 => Kind::Index,
             5 => Kind::Attributes,
-            6 => Kind::Dumb,
-            k => return Err(DecodeError::UnknownKind(k)),
+            _ => Kind::Unknown,
         };
 
         let compression = match reader.read_u8()? {
             1 => Compression::None,
             2 => Compression::Zstd,
-            d => return Err(DecodeError::UnknownCompression(d)),
+            _ => Compression::Unknown,
         };
 
         Ok(Self {
@@ -140,18 +141,6 @@ pub struct Payload<T> {
 
 #[derive(Debug, Error)]
 pub enum DecodeError {
-    #[error("Unknown header type: {0}")]
-    UnknownKind(u8),
-    #[error("Unknown header compression: {0}")]
-    UnknownCompression(u8),
-    #[error("Unknown metadata type: {0}")]
-    UnknownMetaKind(u8),
-    #[error("Unknown metadata tag: {0}")]
-    UnknownMetaTag(u16),
-    #[error("Unknown file type: {0}")]
-    UnknownFileType(u8),
-    #[error("Unknown dependency type: {0}")]
-    UnknownDependency(u8),
     #[error("io")]
     Io(#[from] io::Error),
 }