read serialized file tables

1 files changed, 248 insertions, 0 deletions

diff --git a/src/serialized_file.rs b/src/serialized_file.rs
new file mode 100644
index 0000000..becf1d7
--- /dev/null
+++ b/src/serialized_file.rs
@@ -0,0 +1,248 @@
+use crate::{
+    common_strings::COMMON_STRINGS,
+    helper::{AlignExt, Endianness, ReadExt},
+};
+use anyhow::Result;
+use log::{debug, trace};
+use std::io::{Cursor, Read, Seek};
+
+#[derive(Debug)]
+pub struct TypeTreeNode {
+    pub version: u16,
+    pub level: u8,
+    pub type_flags: u8,
+    pub type_string: String,
+    pub name_string: String,
+    pub byte_size: i32,
+    pub index: i32,
+    pub flags: i32,
+    pub ref_type_hash: u64,
+}
+
+#[derive(Debug)]
+pub struct SeralizedType {
+    pub class_id: i32,
+    pub stripped_type: bool,
+    pub script_type_index: i16,
+    pub script_id: u128,
+
+    pub type_tree: Vec<TypeTreeNode>,
+    pub type_deps: Vec<u32>,
+}
+
+#[derive(Debug)]
+pub struct ObjectInfo {
+    path_id: i64,
+    data_offset: u64,
+    data_size: u32,
+    type_id: i32,
+}
+
+#[derive(Debug)]
+pub struct Script {
+    file_index: u32,
+    identifier: i64,
+}
+
+#[derive(Debug)]
+pub struct External {
+    something: String,
+    guid: u128,
+    r#type: i32,
+    path_name: String,
+}
+
+#[derive(Debug)]
+pub struct SerializedFile {
+    pub types: Vec<SeralizedType>,
+    pub externals: Vec<External>,
+    pub scripts: Vec<Script>,
+    pub objects: Vec<ObjectInfo>,
+    pub user_string: String,
+}
+
+pub fn read_serialized_file(mut file: impl Read + Seek) -> Result<SerializedFile> {
+    let mut metadata_size = file.read_u32_be()?;
+    let mut file_size = file.read_u32_be()? as u64;
+    let format = file.read_u32_be()?;
+    let mut data_offset = file.read_u32_be()? as u64;
+
+    debug!("format={format}");
+
+    assert!(format >= 9);
+    let e = match file.read_u32_be()? {
+        0 => Endianness::Little,
+        _ => Endianness::Big,
+    };
+    debug!("endianess={e:?}");
+
+    if format >= 22 {
+        metadata_size = file.read_u32(e)?;
+        file_size = file.read_u64(e)?;
+        data_offset = file.read_u64(e)?;
+        file.read_u64(e)?;
+    }
+    debug!("metadata_size={metadata_size}");
+    debug!("file_size={file_size}");
+    debug!("data_offset={data_offset}");
+
+    let generator_version = file.read_cstr()?;
+    let target_platform = file.read_u32_le()?;
+    debug!("generator_version={generator_version:?}");
+    debug!("target_platform={target_platform}");
+
+    let has_type_trees = file.read_u8()? != 0;
+    let num_types = file.read_u32(e)?;
+    debug!("has_type_trees={has_type_trees:?}");
+    debug!("num_types={num_types}");
+
+    let mut types = Vec::new();
+
+    for _ in 0..num_types {
+        let class_id = file.read_i32(e)?;
+        let stripped_type = file.read_u8()? != 0;
+        let script_type_index = file.read_i16(e)?;
+        let mut script_id = 0;
+        // TODO reftype
+        if class_id == 114 {
+            script_id = file.read_u128_be()?;
+        }
+        let _old_hash = file.read_u128_be()?;
+
+        trace!("class_id={class_id}");
+        trace!("stripped_type={stripped_type}");
+        trace!("script_type_index={script_type_index}");
+        trace!("script_id={script_id}");
+
+        let mut type_deps = Vec::new();
+        let mut type_tree = Vec::new();
+        if has_type_trees {
+            let num_nodes = file.read_u32(e)?;
+            let size = file.read_u32(e)?;
+            trace!("tree:num_nodes={num_nodes}");
+            trace!("tree:size={size}");
+
+            let mut node_data = vec![0u8; num_nodes as usize * 32];
+            file.read_exact(&mut node_data)?;
+            let mut node_data = Cursor::new(node_data);
+            let mut string_data = vec![0u8; size as usize];
+            file.read_exact(&mut string_data)?;
+
+            let get_string = |off: u32| {
+                let data = if off & 0x80000000 != 0 {
+                    let off = off & 0x7fffffff;
+                    &COMMON_STRINGS[off as usize..]
+                } else {
+                    &string_data[off as usize..]
+                };
+                String::from_utf8(
+                    data.iter()
+                        .copied()
+                        .take_while(|e| *e != 0)
+                        .collect::<Vec<u8>>(),
+                )
+            };
+
+            for _ in 0..num_nodes {
+                type_tree.push(TypeTreeNode {
+                    version: node_data.read_u16(e)?,
+                    level: node_data.read_u8()?,
+                    type_flags: node_data.read_u8()?,
+                    type_string: get_string(node_data.read_u32(e)?)?,
+                    name_string: get_string(node_data.read_u32(e)?)?,
+                    byte_size: node_data.read_i32(e)?,
+                    index: node_data.read_i32(e)?,
+                    flags: node_data.read_i32(e)?,
+                    ref_type_hash: node_data.read_u64(e)?,
+                });
+            }
+
+            if format >= 21 {
+                let num_deps = file.read_u32(e)?;
+                trace!("num_deps={num_deps}");
+                for _ in 0..num_deps {
+                    type_deps.push(file.read_u32(e)?);
+                }
+            }
+        }
+
+        types.push(SeralizedType {
+            class_id,
+            script_id,
+            script_type_index,
+            stripped_type,
+            type_deps,
+            type_tree,
+        })
+    }
+
+    let num_objects = file.read_u32(e)?;
+    debug!("num_objects={num_objects}");
+    let mut objects = Vec::new();
+    for _ in 0..num_objects {
+        file.align(4)?;
+        let path_id = file.read_i64(e)?;
+        let data_offset = if format >= 22 {
+            file.align(4)?;
+            file.read_u64(e)?
+        } else {
+            file.read_u32(e)? as u64
+        } + data_offset;
+        let data_size = file.read_u32(e)?;
+        let type_id = file.read_i32(e)?;
+        objects.push(ObjectInfo {
+            data_offset,
+            data_size,
+            path_id,
+            type_id,
+        })
+    }
+
+    let num_scripts = file.read_u32(e)?;
+    debug!("num_scripts={num_scripts}");
+    let mut scripts = Vec::new();
+    for _ in 0..num_scripts {
+        let file_index = file.read_u32(e)?;
+        file.align(4)?;
+        let identifier = file.read_i64(e)?;
+        scripts.push(Script {
+            file_index,
+            identifier,
+        })
+    }
+
+    let num_externals = file.read_u32(e)?;
+    debug!("num_externals={num_externals}");
+    let mut externals = Vec::new();
+    for _ in 0..num_externals {
+        let something = file.read_cstr()?;
+        let guid = file.read_u128_be()?;
+        let r#type = file.read_i32(e)?;
+        let path_name = file.read_cstr()?;
+        externals.push(External {
+            guid,
+            path_name,
+            something,
+            r#type,
+        })
+    }
+
+    if format >= 20 {
+        let num_ref_types = file.read_i32(e)?;
+        debug!("num_ref_types={num_ref_types}");
+        // let mut ref_types = Vec::new();
+        for _ in 0..num_ref_types {
+            todo!()
+        }
+    }
+
+    let user_string = file.read_cstr()?;
+
+    Ok(SerializedFile {
+        types,
+        externals,
+        objects,
+        scripts,
+        user_string,
+    })
+}