rename catar into pxar

Seems impossible to stay compatible with the original catar specification,
so we change the name to avoid confusions.

src/bin/pxar.rs

@@ -0,0 +1,198 @@
+extern crate proxmox_backup;
+
+use failure::*;
+
+use proxmox_backup::tools;
+use proxmox_backup::cli::*;
+use proxmox_backup::api_schema::*;
+use proxmox_backup::api_schema::router::*;
+
+use serde_json::{Value};
+
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use proxmox_backup::catar::format_definition::*;
+use proxmox_backup::catar::encoder::*;
+use proxmox_backup::catar::decoder::*;
+
+use proxmox_backup::tools::*;
+
+fn print_goodby_entries(buffer: &[u8]) -> Result<(), Error> {
+    println!("GOODBY START: {}", buffer.len());
+
+    let entry_size = std::mem::size_of::<CaFormatGoodbyeItem>();
+    if (buffer.len() % entry_size) != 0 {
+        bail!("unexpected goodby item size ({})", entry_size);
+    }
+
+    let mut pos = 0;
+
+    while pos < buffer.len() {
+
+        let item = map_struct::<CaFormatGoodbyeItem>(&buffer[pos..pos+entry_size])?;
+
+        if item.hash == CA_FORMAT_GOODBYE_TAIL_MARKER {
+            println!("  Entry Offset: {}", item.offset);
+            if item.size != (buffer.len() + 16) as u64 {
+                bail!("gut unexpected goodby entry size (tail marker)");
+            }
+        } else {
+            println!("  Offset: {}", item.offset);
+            println!("  Size: {}", item.size);
+            println!("  Hash: {:016x}", item.hash);
+        }
+
+        pos += entry_size;
+    }
+
+    Ok(())
+}
+
+fn print_filenames(
+    _param: Value,
+    _info: &ApiMethod,
+    _rpcenv: &mut RpcEnvironment,
+) -> Result<Value, Error> {
+
+    /* FIXME
+
+    let archive = tools::required_string_param(&param, "archive")?;
+    let file = std::fs::File::open(archive)?;
+
+    let mut reader = std::io::BufReader::new(file);
+
+     let mut decoder = CaTarDecoder::new(&mut reader)?;
+
+    let root = decoder.root();
+
+    let stdout = std::io::stdout();
+    let mut out = stdout.lock();
+
+    decoder.print_filenames(&mut out, &mut PathBuf::from("."), &root)?;
+    */
+
+    panic!("not implemented");
+
+    Ok(Value::Null)
+}
+
+fn dump_archive(
+    param: Value,
+    _info: &ApiMethod,
+    _rpcenv: &mut RpcEnvironment,
+) -> Result<Value, Error> {
+
+    let archive = tools::required_string_param(&param, "archive")?;
+    let mut file = std::fs::File::open(archive)?;
+
+    println!("CATAR {}", archive);
+
+    let mut buffer = [0u8; 16];
+
+    let mut nesting = 0;
+
+    loop {
+        file.read_exact(&mut buffer)?;
+
+        let header = map_struct::<CaFormatHeader>(&mut buffer)?;
+
+        println!("Type: {:016x}", header.htype);
+        println!("Size: {}", header.size);
+
+        let mut rest = vec![0u8; (header.size as usize) - 16];
+        file.read_exact(&mut rest)?;
+
+        if header.htype == CA_FORMAT_FILENAME {
+            let name = read_os_string(&rest);
+            let hash = compute_goodbye_hash(&rest[..rest.len()-1]);
+            println!("Name: {:?} {:016x}",  name, hash);
+        }
+
+        if header.htype == CA_FORMAT_ENTRY {
+            let entry = map_struct::<CaFormatEntry>(&mut rest)?;
+            println!("Mode: {:08x} {:08x}", entry.mode, (entry.mode as u32) & libc::S_IFDIR);
+            if ((entry.mode as u32) & libc::S_IFMT) == libc::S_IFDIR {
+                nesting += 1;
+            }
+        }
+        if header.htype == CA_FORMAT_GOODBYE {
+            nesting -= 1;
+            print_goodby_entries(&rest)?;
+            if nesting == 0 { break; }
+        }
+    }
+
+    Ok(Value::Null)
+}
+
+fn create_archive(
+    param: Value,
+    _info: &ApiMethod,
+    _rpcenv: &mut RpcEnvironment,
+) -> Result<Value, Error> {
+
+    let archive = tools::required_string_param(&param, "archive")?;
+    let source = tools::required_string_param(&param, "source")?;
+    let verbose = param["verbose"].as_bool().unwrap_or(false);
+    let all_file_systems = param["all-file-systems"].as_bool().unwrap_or(false);
+
+    let source = std::path::PathBuf::from(source);
+
+    let mut dir = nix::dir::Dir::open(
+        &source, nix::fcntl::OFlag::O_NOFOLLOW, nix::sys::stat::Mode::empty())?;
+
+    let file = std::fs::OpenOptions::new()
+        .create_new(true)
+        .write(true)
+        .open(archive)?;
+
+    let mut writer = std::io::BufWriter::with_capacity(1024*1024, file);
+
+    CaTarEncoder::encode(source, &mut dir, &mut writer, all_file_systems, verbose)?;
+
+    writer.flush()?;
+
+    Ok(Value::Null)
+}
+
+fn main() {
+
+    let cmd_def = CliCommandMap::new()
+        .insert("create", CliCommand::new(
+            ApiMethod::new(
+                create_archive,
+                ObjectSchema::new("Create new catar archive.")
+                    .required("archive", StringSchema::new("Archive name"))
+                    .required("source", StringSchema::new("Source directory."))
+                    .optional("verbose", BooleanSchema::new("Verbose output.").default(false))
+                    .optional("all-file-systems", BooleanSchema::new("Include mounted sudirs.").default(false))
+           ))
+            .arg_param(vec!["archive", "source"])
+            .completion_cb("archive", tools::complete_file_name)
+            .completion_cb("source", tools::complete_file_name)
+           .into()
+        )
+        .insert("list", CliCommand::new(
+            ApiMethod::new(
+                print_filenames,
+                ObjectSchema::new("List the contents of an archive.")
+                    .required("archive", StringSchema::new("Archive name."))
+            ))
+            .arg_param(vec!["archive"])
+            .completion_cb("archive", tools::complete_file_name)
+            .into()
+        )
+        .insert("dump", CliCommand::new(
+            ApiMethod::new(
+                dump_archive,
+                ObjectSchema::new("Textual dump of archive contents (debug toolkit).")
+                    .required("archive", StringSchema::new("Archive name."))
+            ))
+            .arg_param(vec!["archive"])
+            .completion_cb("archive", tools::complete_file_name)
+            .into()
+        );
+
+    run_cli_command(cmd_def.into());
+}