Merge pull request #16 from yellowcake-org/develop

Inspect & extract files from .dat

Author: 0xceed

.gitignore

@@ -8,3 +8,5 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+.DS_Store
+.idea

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+edition = "2018"
+name = "libycresources"
+version = "0.1.0"
+
+[[example]]
+name = "undat"
+
+[dev-dependencies]
+clap = "3.0.0-beta.2"

examples/undat/extract.rs

@@ -0,0 +1,69 @@
+use libycresources::dat;
+
+use std::io::{Read, Seek};
+use std::path::PathBuf;
+
+#[derive(Debug)]
+pub(crate) enum Error {
+    Path,
+    Buffer,
+    Decompress,
+    Read(std::io::Error),
+    Write(std::io::Error),
+}
+
+pub(crate) fn tree<R>(reader: &mut R, tree: &dat::Directory, output: &String) -> Result<(), Error>
+where
+    R: Read + Seek,
+{
+    let mut path = PathBuf::new();
+
+    for (depth, _, directory) in tree.iter() {
+        if depth > path.components().count() {
+            path.push(String::from(&directory.name));
+        } else {
+            for _ in 0..path.components().count() - depth {
+                path.pop();
+            }
+
+            if !path.ends_with(String::from(&directory.name)) {
+                path.push(String::from(&directory.name));
+            }
+        }
+
+        for file in &directory.files {
+            let root = std::path::Path::new(&output);
+            let full = root.join(&path).join(&file.name);
+            let path = full.as_path();
+
+            println!("{:}", path.display());
+
+            let directory = match path.parent() {
+                None => return Err(Error::Path),
+                Some(directory) => directory,
+            };
+
+            if let Err(error) = std::fs::create_dir_all(&directory) {
+                return Err(Error::Write(error));
+            }
+
+            let mut created = match std::fs::File::create(&path) {
+                Err(error) => return Err(Error::Write(error)),
+                Ok(created) => created,
+            };
+
+            let mut writer = std::io::BufWriter::with_capacity(1 * 1024 * 1024, &mut created);
+
+            if let Err(error) = dat::extract::file(reader, &file, &mut writer) {
+                return match error {
+                    dat::extract::Error::Source => Err(Error::Buffer),
+                    dat::extract::Error::Decompress => Err(Error::Decompress),
+                    dat::extract::Error::Read(error) => Err(Error::Read(error)),
+                    dat::extract::Error::Write(error) => Err(Error::Write(error)),
+                };
+            }
+        }
+    }
+
+    Ok(())
+}

examples/undat/main.rs

@@ -0,0 +1,67 @@
+pub(crate) mod extract;
+pub(crate) mod tree;
+
+use libycresources::dat;
+
+use clap::Clap;
+use std::fs::File;
+
+#[derive(Clap)]
+#[clap(name = "undat", version)]
+struct Options {
+    /// Path to the input arhive file
+    #[clap(short, long)]
+    input: String,
+    #[clap(subcommand)]
+    action: Action,
+}
+
+#[derive(Clap)]
+enum Action {
+    /// Prints arhive contents
+    Tree,
+    /// Extracts all archive contents to specified directory
+    Extract(Extract),
+}
+
+#[derive(Clap)]
+struct Extract {
+    output: String,
+}
+
+fn main() {
+    let options = Options::parse();
+
+    let file = match File::open(&options.input) {
+        Err(error) => {
+            eprintln!("Couldn't open input file: {:?}", error);
+            return;
+        }
+        Ok(value) => value,
+    };
+
+    let mut reader = std::io::BufReader::with_capacity(1 * 1024 * 1024, file);
+
+    if let Some(tree) = match dat::parse::tree(&mut reader) {
+        Err(error) => {
+            eprintln!("Error occured: {:?}", error);
+            return;
+        }
+        Ok(value) => value,
+    } {
+        match options.action {
+            Action::Tree => {
+                tree::print(&tree);
+            }
+            Action::Extract(arguments) => {
+                let result = extract::tree(&mut reader, &tree, &arguments.output);
+
+                if let Err(error) = result {
+                    eprintln!("Error occured: {:?}", error);
+                }
+            }
+        }
+    } else {
+        println!("Input file has zero directories.");
+    }
+}

examples/undat/tree.rs

@@ -0,0 +1,68 @@
+use libycresources::dat;
+
+pub(crate) fn print(tree: &dat::Directory) {
+    let mut flag_path = Vec::new();
+
+    for (depth, is_last, directory) in tree.iter() {
+        if depth > flag_path.iter().count() {
+            flag_path.push((is_last, &directory.name));
+        } else {
+            for _ in 0..flag_path.iter().count() - depth {
+                flag_path.pop();
+            }
+
+            if flag_path.last() != Some(&(is_last, &directory.name)) {
+                flag_path.push((is_last, &directory.name));
+            }
+        }
+
+        for (index, tuple) in flag_path.iter().enumerate() {
+            if index > 0 {
+                if tuple.0 {
+                    if index == depth {
+                        print!("└");
+                    } else {
+                        print!(" ");
+                    }
+                } else {
+                    if index == depth {
+                        print!("├");
+                    } else {
+                        print!("│");
+                    }
+                }
+                if index == depth {
+                    print!("───");
+                } else {
+                    print!("   ");
+                }
+            }
+        }
+
+        println!("{:}", directory.name);
+
+        for (index, file) in directory.files.iter().enumerate() {
+            let is_last_file = index == directory.files.iter().count() - 1
+                && directory.children.iter().count() == 0;
+
+            for (index, tuple) in flag_path.iter().enumerate() {
+                if index > 0 {
+                    if tuple.0 {
+                        print!(" ");
+                    } else {
+                        print!("│");
+                    }
+                    print!("   ");
+                }
+            }
+
+            if is_last_file {
+                print!("└");
+            } else {
+                print!("├");
+            }
+            print!("───");
+            println!("{:}", file.name);
+        }
+    }
+}

src/dat.rs

@@ -0,0 +1,14 @@
+pub mod extract;
+pub mod parse;
+
+pub struct File {
+    pub name: String,
+    pub size: usize,
+    pub(crate) range: std::ops::Range<usize>,
+}
+
+pub struct Directory {
+    pub name: String,
+    pub files: Vec<File>,
+    pub children: Vec<Directory>,
+}