aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--src/bin/geniza-sleep.rs80
-rw-r--r--src/lib.rs49
-rw-r--r--src/sleep.rs3
3 files changed, 120 insertions, 12 deletions
diff --git a/src/bin/geniza-sleep.rs b/src/bin/geniza-sleep.rs
new file mode 100644
index 0000000..168f803
--- /dev/null
+++ b/src/bin/geniza-sleep.rs
@@ -0,0 +1,80 @@
+
+#[macro_use]
+extern crate clap;
+
+extern crate geniza;
+
+// TODO: more careful import
+use geniza::*;
+use std::path::Path;
+
+use clap::{App, SubCommand};
+
+fn run() -> Result<()> {
+
+ let matches = App::new("geniza-sleep")
+ .version(env!("CARGO_PKG_VERSION"))
+ .subcommand(SubCommand::with_name("info")
+ .about("Reads a SLEEP file and shows some basic metadata")
+ .arg_from_usage("<FILE> 'SLEEP file to read'"))
+ .subcommand(SubCommand::with_name("create")
+ .about("Creates an empty SLEEP file (with header)")
+ .arg_from_usage("<FILE> 'SLEEP file to write (can't exist)'")
+ .arg_from_usage("<magic> 'Magic word to use (eg, 0x5025700)'")
+ .arg_from_usage("<entry_size> 'Size of each entry (bytes)'")
+ .arg_from_usage("<algo_name> 'Name of algorithm (empty string for none)'"))
+ .get_matches();
+
+
+ match matches.subcommand() {
+ ("info", Some(subm)) => {
+ let path = Path::new(subm.value_of("FILE").unwrap());
+ let sf = SleepFile::open(path, false)?;
+ //debug!(println!("{:?}", sf));
+ println!("Magic: 0x{:X}", sf.get_magic());
+ println!("Algorithm: '{}'", sf.get_algorithm().or(Some("".to_string())).unwrap());
+ println!("Entry Size (bytes): {}", sf.get_entry_size());
+ println!("Entry count: {}", sf.length()?);
+ },
+ ("create", Some(subm)) => {
+ let path = Path::new(subm.value_of("FILE").unwrap());
+ let algo_name = subm.value_of("algo_name").unwrap();
+ let algo_name = if algo_name.len() == 0 {
+ None
+ } else {
+ Some(algo_name.to_string())
+ };
+ SleepFile::create(
+ path,
+ value_t_or_exit!(subm, "magic", u32),
+ value_t_or_exit!(subm, "entry_size", u16),
+ algo_name)?;
+ println!("Done!");
+ },
+ _ => {
+ println!("Missing or unimplemented command!");
+ println!("{}", matches.usage());
+ ::std::process::exit(-1);
+ },
+ }
+ Ok(())
+}
+
+// TODO: is there a shorter error_chain 'main()' to use here?
+fn main() {
+ if let Err(ref e) = run() {
+ println!("error: {}", e);
+
+ for e in e.iter().skip(1) {
+ println!("caused by: {}", e);
+ }
+
+ // The backtrace is not always generated. Try to run this example
+ // with `RUST_BACKTRACE=1`.
+ if let Some(backtrace) = e.backtrace() {
+ println!("backtrace: {:?}", backtrace);
+ }
+
+ ::std::process::exit(1);
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 63fd9bf..18dffbc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,6 +7,7 @@ use std::io::prelude::*;
use std::path::Path;
use std::fs::File;
use integer_encoding::FixedInt;
+use std::fs::OpenOptions;
mod errors {
// Create the Error, ErrorKind, ResultExt, and Result types
@@ -33,6 +34,7 @@ pub struct SleepFile {
file: File,
magic: u32,
entry_size: u16,
+ // Option isn't necessary here... idiomatic?
algorithm_name: Option<String>,
}
@@ -42,15 +44,18 @@ impl SleepFile {
pub fn open(path: &Path, writable: bool) -> Result<SleepFile> {
- // TODO: use writable here
- let mut f = File::open(path)?;
+ let mut f = OpenOptions::new()
+ .read(true)
+ .write(writable)
+ .create(false)
+ .open(path)?;
let mut header = [0; 32];
f.read_exact(&mut header)?;
let version: u8 = header[4];
if version != 0 {
return Err("Invalid SLEEP header: version must be 0".into());
}
- let algo_len: u8 = header[8];
+ let algo_len: u8 = header[7];
if algo_len > 24 {
return Err("Invalid SLEEP header: can't have algo_len > 24".into());
}
@@ -60,18 +65,44 @@ impl SleepFile {
// TODO: endian-ness of u16 entry_size
Ok(SleepFile {
file: f,
- magic: FixedInt::decode_fixed(&header[0..4]),
- entry_size: FixedInt::decode_fixed(&header[6..8]),
+ magic: u32::from_be(FixedInt::decode_fixed(&header[0..4])),
+ entry_size: u16::from_be(FixedInt::decode_fixed(&header[5..7])),
algorithm_name: algorithm_name,
})
}
-/*
- pub fn create(path: Path, magic: u32, entry_size: u16, algo: &str) -> Result<SleepFile> {
- let mut sf = SleepFile {
+ pub fn create(path: &Path, magic: u32, entry_size: u16, algo: Option<String>) -> Result<SleepFile> {
+ // This function will *not* allow overwriting an existing file.
+
+ let mut header = [0; 32];
+ u32::to_be(magic).encode_fixed(&mut header[0..4]);
+ header[4] = 0; // version
+ u16::to_be(entry_size).encode_fixed(&mut header[5..7]);
+ if let Some(name) = algo.clone() {
+ let name = name.as_bytes();
+ let algo_len = name.len();
+ if algo_len > 24 {
+ return Err("Algorithm name must be 24 bytes at most".into());
+ }
+ header[7] = algo_len as u8;
+ header[8..(8+algo_len)].clone_from_slice(name);
+ } else {
+ header[7] = 0;
};
+
+ let mut f = OpenOptions::new()
+ .read(true)
+ .write(true)
+ .create_new(true)
+ .open(path)?;
+ f.write(&header)?;
+ Ok(SleepFile {
+ file: f,
+ magic: magic,
+ entry_size: entry_size,
+ algorithm_name: algo,
+ })
}
-*/
}
impl SleepStorage for SleepFile {
diff --git a/src/sleep.rs b/src/sleep.rs
deleted file mode 100644
index b28b04f..0000000
--- a/src/sleep.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-
-
-