Revert "stone: Decode unknown variants"

This reverts commit 235a552.

Author: ermo

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.
 ///
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FileType {
     /// Binary package
     Binary = 1,
@@ -25,8 +25,6 @@ pub enum FileType {
 
     /// (Legacy) build manifest
     BuildManifest,
-
-    Unknown = 255,
 }
 
 /// Header for the v1 format version
@@ -51,7 +49,7 @@ impl Header {
             2 => FileType::Delta,
             3 => FileType::Repository,
             4 => FileType::BuildManifest,
-            _ => FileType::Unknown,
+            f => return Err(DecodeError::UnknownFileType(f)),
         };
 
         Ok(Self {
@@ -78,4 +76,6 @@ 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.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FileType {
     /// Regular file
     Regular = 1,
@@ -34,8 +34,6 @@ pub enum FileType {
 
     /// UNIX Socket
     Socket,
-
-    Unknown = 255,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -49,8 +47,6 @@ pub enum Entry {
     BlockDevice(AStr),
     Fifo(AStr),
     Socket(AStr),
-
-    Unknown(AStr, AStr),
 }
 
 impl Entry {
@@ -63,20 +59,18 @@ 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)
-            | Entry::Symlink(_, target)
-            | Entry::Directory(target)
-            | Entry::CharacterDevice(target)
-            | Entry::BlockDevice(target)
-            | Entry::Fifo(target)
-            | Entry::Socket(target)
-            | Entry::Unknown(_, target) => target,
+            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,
         }
     }
 
@@ -89,7 +83,6 @@ impl Entry {
             Entry::BlockDevice(_) => 5,
             Entry::Fifo(_) => 6,
             Entry::Socket(_) => 7,
-            Entry::Unknown(..) => 255,
         }
     }
 }
@@ -125,13 +118,14 @@ impl Record for Layout {
             5 => FileType::BlockDevice,
             6 => FileType::Fifo,
             7 => FileType::Socket,
-            _ => FileType::Unknown,
+            t => return Err(DecodeError::UnknownFileType(t)),
         };
 
         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());
@@ -142,16 +136,12 @@ 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()),
-            FileType::CharacterDevice => {
-                Entry::CharacterDevice(sanitize(&reader.read_string(target_length as u64)?).into())
+            _ => {
+                if source_length > 0 {
+                    let _ = reader.read_vec(source_length as usize);
+                }
+                unreachable!()
             }
-            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,10 +50,9 @@ 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),
@@ -67,7 +66,6 @@ pub enum Kind {
     String(String),
     Dependency(Dependency, String),
     Provider(Dependency, String),
-    Unknown(Vec<u8>),
 }
 
 impl Kind {
@@ -87,61 +85,58 @@ impl Kind {
             Kind::Dependency(_, s) => s.len() + 2,
             // Plus dep size & nul terminator
             Kind::Provider(_, s) => s.len() + 2,
-            Kind::Unknown(data) => data.len(),
         }
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u16)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Tag {
     // Name of the package
     Name = 1,
     // Architecture of the package
-    Architecture,
+    Architecture = 2,
     // Version of the package
-    Version,
+    Version = 3,
     // Summary of the package
-    Summary,
+    Summary = 4,
     // Description of the package
-    Description,
+    Description = 5,
     // Homepage for the package
-    Homepage,
+    Homepage = 6,
     // ID for the source package, used for grouping
-    SourceID,
+    SourceID = 7,
     // Runtime dependencies
-    Depends,
+    Depends = 8,
     // Provides some capability or name
-    Provides,
+    Provides = 9,
     // Conflicts with some capability or name
-    Conflicts,
+    Conflicts = 10,
     // Release number for the package
-    Release,
+    Release = 11,
     // SPDX license identifier
-    License,
+    License = 12,
     // Currently recorded build number
-    BuildRelease,
+    BuildRelease = 13,
     // Repository index specific (relative URI)
-    PackageURI,
+    PackageURI = 14,
     // Repository index specific (Package hash)
-    PackageHash,
+    PackageHash = 15,
     // Repository index specific (size on disk)
-    PackageSize,
+    PackageSize = 16,
     // A Build Dependency
-    BuildDepends,
+    BuildDepends = 17,
     // Upstream URI for the source
-    SourceURI,
+    SourceURI = 18,
     // Relative path for the source within the upstream URI
-    SourcePath,
+    SourcePath = 19,
     // Ref/commit of the upstream source
-    SourceRef,
-
-    Unknown = u16::MAX,
+    SourceRef = 20,
 }
 
 /// Helper to decode a dependency's encoded kind
-fn decode_dependency(i: u8) -> Dependency {
-    match i {
+fn decode_dependency(i: u8) -> Result<Dependency, DecodeError> {
+    let result = match i {
         0 => Dependency::PackageName,
         1 => Dependency::SharedLibrary,
         2 => Dependency::PkgConfig,
@@ -151,8 +146,9 @@ fn decode_dependency(i: u8) -> Dependency {
         6 => Dependency::Binary,
         7 => Dependency::SystemBinary,
         8 => Dependency::PkgConfig32,
-        _ => Dependency::Unknown,
-    }
+        _ => return Err(DecodeError::UnknownDependency(i)),
+    };
+    Ok(result)
 }
 
 impl Record for Meta {
@@ -180,7 +176,7 @@ impl Record for Meta {
             18 => Tag::SourceURI,
             19 => Tag::SourcePath,
             20 => Tag::SourceRef,
-            _ => Tag::Unknown,
+            t => return Err(DecodeError::UnknownMetaTag(t)),
         };
 
         let kind = reader.read_u8()?;
@@ -201,15 +197,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)?),
             ),
-            _ => Kind::Unknown(reader.read_vec(length as usize)?),
+            k => return Err(DecodeError::UnknownMetaKind(k)),
         };
 
         Ok(Self { tag, kind })
@@ -228,7 +224,6 @@ impl Record for Meta {
             Kind::String(_) => 9,
             Kind::Dependency(_, _) => 10,
             Kind::Provider(_, _) => 11,
-            Kind::Unknown(_) => 255,
         };
 
         writer.write_u32(self.kind.size() as u32)?;
@@ -255,9 +250,6 @@ 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,32 +17,30 @@ pub use self::layout::Layout;
 pub use self::meta::Meta;
 use crate::{ReadExt, WriteExt};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Kind {
     // The Metadata store
     Meta = 1,
     // File store, i.e. hash indexed
-    Content,
+    Content = 2,
     // Map Files to Disk with basic UNIX permissions + types
-    Layout,
+    Layout = 3,
     // For indexing the deduplicated store
-    Index,
+    Index = 4,
     // Attribute storage
-    Attributes,
-
-    Unknown = 255,
+    Attributes = 5,
+    // For Writer interim
+    Dumb = 6,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Compression {
     // Payload has no compression
     None = 1,
     // Payload uses ZSTD compression
-    Zstd,
-
-    Unknown = 255,
+    Zstd = 2,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -73,13 +71,14 @@ impl Header {
             3 => Kind::Layout,
             4 => Kind::Index,
             5 => Kind::Attributes,
-            _ => Kind::Unknown,
+            6 => Kind::Dumb,
+            k => return Err(DecodeError::UnknownKind(k)),
         };
 
         let compression = match reader.read_u8()? {
             1 => Compression::None,
             2 => Compression::Zstd,
-            _ => Compression::Unknown,
+            d => return Err(DecodeError::UnknownCompression(d)),
         };
 
         Ok(Self {
@@ -141,6 +140,18 @@ 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),
 }