feat: new code

Author: Crauzer

crates/io-ext/src/writer.rs

@@ -21,6 +21,17 @@ pub trait WriterExt: Write {
         Ok(())
     }
 
+    /// Writes a string with a length prefix (writes sizeof(str.len()) + str.len() bytes)
+    fn write_len_prefixed_string_better<T: ByteOrder>(
+        &mut self,
+        str: impl AsRef<str>,
+    ) -> io::Result<()> {
+        let str = str.as_ref();
+        self.write_u16::<T>(str.len() as _)?;
+        self.write_all(str.as_bytes())?;
+        Ok(())
+    }
+
     /// Writes a string with a null terminator (writes sizeof(str) + 1 bytes)
     fn write_terminated_string<S: AsRef<str>>(&mut self, str: S) -> io::Result<()> {
         self.write_all(str.as_ref().as_bytes())?;

crates/league-modpkg/Cargo.toml

@@ -9,3 +9,4 @@ byteorder = "1.5.0"
 io-ext = { path = "../io-ext" }
 serde = { version = "1.0", features = ["derive"] }
 rmp-serde = "1.3.0"
+twox-hash = { version = "2.0.1", features = ["xxhash64"] }

crates/league-modpkg/src/chunk.rs

@@ -1,4 +1,4 @@
-use crate::error::ModpkgError;
+use crate::{error::ModpkgError, ModpkgCompression};
 use byteorder::{ReadBytesExt as _, LE};
 use std::io::{BufReader, Read};
 
@@ -7,6 +7,7 @@ pub struct ModpkgChunk {
     path_hash: u64,
 
     data_offset: usize,
+    compression: ModpkgCompression,
     compressed_size: usize,
     uncompressed_size: usize,
 
@@ -15,14 +16,15 @@ pub struct ModpkgChunk {
 
     path_index: u32,
     wad_paths_index: u32,
-    layers_index: u32,
+    layer_index: u32,
 }
 
 impl ModpkgChunk {
     pub fn read(reader: &mut BufReader<impl Read>) -> Result<Self, ModpkgError> {
         let path_hash = reader.read_u64::<LE>()?;
 
         let data_offset = reader.read_u64::<LE>()?;
+        let compression = ModpkgCompression::try_from(reader.read_u8()?)?;
         let compressed_size = reader.read_u64::<LE>()?;
         let uncompressed_size = reader.read_u64::<LE>()?;
 
@@ -31,19 +33,19 @@ impl ModpkgChunk {
 
         let path_index = reader.read_u32::<LE>()?;
         let wad_paths_index = reader.read_u32::<LE>()?;
-        let layers_index = reader.read_u32::<LE>()?;
-        let _ = reader.read_u32::<LE>()?; // reserved
+        let layer_index = reader.read_u32::<LE>()?;
 
         Ok(Self {
             path_hash,
             data_offset: data_offset as usize,
+            compression,
             compressed_size: compressed_size as usize,
             uncompressed_size: uncompressed_size as usize,
             compressed_checksum,
             uncompressed_checksum,
             path_index,
             wad_paths_index,
-            layers_index,
+            layer_index,
         })
     }
 
@@ -54,6 +56,9 @@ impl ModpkgChunk {
     pub fn data_offset(&self) -> usize {
         self.data_offset
     }
+    pub fn compression(&self) -> ModpkgCompression {
+        self.compression
+    }
     pub fn compressed_size(&self) -> usize {
         self.compressed_size
     }
@@ -74,7 +79,7 @@ impl ModpkgChunk {
     pub fn wad_paths_index(&self) -> u32 {
         self.wad_paths_index
     }
-    pub fn layers_index(&self) -> u32 {
-        self.layers_index
+    pub fn layer_index(&self) -> u32 {
+        self.layer_index
     }
 }

crates/league-modpkg/src/error.rs

@@ -1,5 +1,7 @@
 use thiserror::Error;
 
+use crate::ModpkgCompression;
+
 #[derive(Error, Debug)]
 pub enum ModpkgError {
     #[error("IO error: {0}")]
@@ -11,10 +13,20 @@ pub enum ModpkgError {
     InvalidHeaderSize { header_size: u32, actual_size: u64 },
     #[error("Chunks are not in ascending order: previous: {previous}, current: {current}")]
     UnsortedChunks { previous: u64, current: u64 },
+    #[error("Missing metadata chunk")]
+    MissingMetadata,
     #[error("Missing base layer")]
     MissingBaseLayer,
     #[error("Invalid modpkg compression type: {0}")]
     InvalidCompressionType(u8),
+    #[error(
+        "Unexpected compression type: chunk: {chunk:x}, expected: {expected}, actual: {actual}"
+    )]
+    UnexpectedCompressionType {
+        chunk: u64,
+        expected: ModpkgCompression,
+        actual: ModpkgCompression,
+    },
     #[error("Invalid modpkg license type: {0}")]
     InvalidLicenseType(u8),
     #[error("Invalid modpkg magic: {0}")]
@@ -23,6 +35,8 @@ pub enum ModpkgError {
     InvalidVersion(u32),
     #[error("Duplicate chunk: {0}")]
     DuplicateChunk(u64),
+    #[error("Chunk not found: {0:x}")]
+    MissingChunk(u64),
 
     #[error("Msgpack decode error: {0}")]
     MsgpackDecode(#[from] rmp_serde::decode::Error),

crates/league-modpkg/src/lib.rs

@@ -1,20 +1,35 @@
 use chunk::ModpkgChunk;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
+use error::ModpkgError;
+use metadata::ModpkgMetadata;
+use std::{collections::HashMap, fmt::Display, io};
 mod chunk;
 mod error;
+mod license;
+mod metadata;
 mod read;
+mod utils;
+
+pub const METADATA_CHUNK_NAME: &str = "__metadata__";
+pub const LAYERS_CHUNK_NAME: &str = "__layers__";
+pub const WADS_CHUNK_NAME: &str = "__wads__";
+pub const CHUNK_PATHS_CHUNK_NAME: &str = "__chunk_paths__";
+
+pub const METADATA_CHUNK_HASH: u64 = 0xc3b02c1cbcdff91f;
+pub const LAYERS_CHUNK_HASH: u64 = 0xe8f354f18f398ee1;
+pub const WADS_CHUNK_HASH: u64 = 0x67c34d7d3d2900df;
+pub const CHUNK_PATHS_CHUNK_HASH: u64 = 0xbe4dc608d6e153c0;
 
 #[derive(Debug, PartialEq)]
-pub struct Modpkg {
+pub struct Modpkg<TSource: io::Read + io::Seek> {
     metadata: ModpkgMetadata,
     chunk_paths: Vec<String>,
     wad_paths: Vec<String>,
     chunks: HashMap<u64, ModpkgChunk>,
+
+    source: TSource,
 }
 
-impl Modpkg {
+impl<TSource: io::Read + io::Seek> Modpkg<TSource> {
     pub fn metadata(&self) -> &ModpkgMetadata {
         &self.metadata
     }
@@ -23,68 +38,33 @@ impl Modpkg {
     }
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub struct ModpkgMetadata {
-    name: String,
-    display_name: String,
-    description: Option<String>,
-    version: String,
-    distributor: Option<String>,
-    authors: Vec<ModpkgAuthor>,
-    license: ModpkgLicense,
-}
-
-impl ModpkgMetadata {
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-    pub fn display_name(&self) -> &str {
-        &self.display_name
-    }
-    pub fn description(&self) -> Option<&str> {
-        self.description.as_deref()
-    }
-    pub fn version(&self) -> &str {
-        &self.version
-    }
-    pub fn distributor(&self) -> Option<&str> {
-        self.distributor.as_deref()
-    }
-    pub fn authors(&self) -> &[ModpkgAuthor] {
-        &self.authors
-    }
-    pub fn license(&self) -> &ModpkgLicense {
-        &self.license
-    }
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub enum ModpkgLicense {
-    None,
-    Spdx { spdx_id: String },
-    Custom { name: String, url: String },
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub struct ModpkgAuthor {
-    name: String,
-    role: Option<String>,
-}
-
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 pub enum ModpkgCompression {
     None = 0,
     Zstd = 1,
 }
 
+impl Display for ModpkgCompression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{:?}",
+            match self {
+                ModpkgCompression::None => "none",
+                ModpkgCompression::Zstd => "zstd",
+            }
+        )
+    }
+}
+
 impl TryFrom<u8> for ModpkgCompression {
-    type Error = &'static str;
+    type Error = ModpkgError;
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         Ok(match value {
             0 => ModpkgCompression::None,
             1 => ModpkgCompression::Zstd,
-            _ => return Err("Invalid modpkg compression value"),
+            _ => return Err(ModpkgError::InvalidCompressionType(value)),
         })
     }
 }

crates/league-modpkg/src/license.rs

@@ -0,0 +1,67 @@
+use std::io::{BufReader, Read, Write};
+
+use byteorder::{ReadBytesExt as _, WriteBytesExt as _, LE};
+use io_ext::{ReaderExt as _, WriterExt as _};
+
+use crate::error::ModpkgError;
+
+#[derive(Debug, PartialEq, Default)]
+pub enum ModpkgLicense {
+    #[default]
+    None,
+    Spdx {
+        spdx_id: String,
+    },
+    Custom {
+        name: String,
+        url: String,
+    },
+}
+
+impl ModpkgLicense {
+    pub fn read(reader: &mut BufReader<impl Read>) -> Result<Self, ModpkgError> {
+        let license_type = reader.read_u8()?;
+        match license_type {
+            0 => Ok(Self::None),
+            1 => Ok(Self::Spdx {
+                spdx_id: reader.read_len_prefixed_string::<LE>()?,
+            }),
+            2 => Ok(Self::Custom {
+                name: reader.read_len_prefixed_string::<LE>()?,
+                url: reader.read_len_prefixed_string::<LE>()?,
+            }),
+            _ => Err(ModpkgError::InvalidLicenseType(license_type)),
+        }
+    }
+
+    pub fn write(&self, writer: &mut impl Write) -> Result<(), ModpkgError> {
+        writer.write_u8(match self {
+            Self::None => 0,
+            Self::Spdx { .. } => 1,
+            Self::Custom { .. } => 2,
+        })?;
+
+        match self {
+            Self::Spdx { spdx_id } => {
+                writer.write_len_prefixed_string_better::<LE>(spdx_id)?;
+
+                Ok(())
+            }
+            Self::Custom { name, url } => {
+                writer.write_len_prefixed_string_better::<LE>(name)?;
+                writer.write_len_prefixed_string_better::<LE>(url)?;
+
+                Ok(())
+            }
+            Self::None => Ok(()),
+        }
+    }
+
+    pub fn size(&self) -> usize {
+        match self {
+            Self::None => 1,
+            Self::Spdx { spdx_id } => 1 + 4 + spdx_id.len(),
+            Self::Custom { name, url } => 1 + 4 + 4 + name.len() + url.len(),
+        }
+    }
+}