proxmox-backup/src/pxar/decoder.rs
Christian Ebner fa7e957ca3 pxar: Adapt SequentialDecoder::restore() calls to pass empty match pattern for full restore
Signed-off-by: Christian Ebner <c.ebner@proxmox.com>
2019-07-17 12:19:31 +02:00

221 lines
6.3 KiB
Rust

//! *pxar* format decoder for seekable files
//!
//! This module contain the code to decode *pxar* archive files.
use failure::*;
use super::format_definition::*;
use super::sequential_decoder::*;
use std::io::{Read, Seek, SeekFrom};
use std::path::{Path, PathBuf};
use std::ffi::OsString;
pub struct CaDirectoryEntry {
start: u64,
end: u64,
pub filename: OsString,
pub entry: CaFormatEntry,
}
// This one needs Read+Seek
pub struct Decoder<'a, R: Read + Seek, F: Fn(&Path) -> Result<(), Error>> {
inner: SequentialDecoder<'a, R, F>,
root_start: u64,
root_end: u64,
}
const HEADER_SIZE: u64 = std::mem::size_of::<CaFormatHeader>() as u64;
impl <'a, R: Read + Seek, F: Fn(&Path) -> Result<(), Error>> Decoder<'a, R, F> {
pub fn new(reader: &'a mut R, callback: F) -> Result<Self, Error> {
let root_end = reader.seek(SeekFrom::End(0))?;
Ok(Self {
inner: SequentialDecoder::new(reader, CA_FORMAT_DEFAULT, callback),
root_start: 0,
root_end: root_end,
})
}
pub fn root(&self) -> CaDirectoryEntry {
CaDirectoryEntry {
start: self.root_start,
end: self.root_end,
filename: OsString::new(), // Empty
entry: CaFormatEntry {
mode: 0,
flags: 0,
uid: 0,
gid: 0,
mtime: 0,
}
}
}
fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error> {
let pos = self.inner.get_reader_mut().seek(pos)?;
Ok(pos)
}
pub fn restore(
&mut self,
dir: &CaDirectoryEntry,
path: &Path,
) -> Result<(), Error> {
let start = dir.start;
self.seek(SeekFrom::Start(start))?;
self.inner.restore(path, &Vec::new())?;
Ok(())
}
fn read_directory_entry(&mut self, start: u64, end: u64) -> Result<CaDirectoryEntry, Error> {
self.seek(SeekFrom::Start(start))?;
let head: CaFormatHeader = self.inner.read_item()?;
if head.htype != CA_FORMAT_FILENAME {
bail!("wrong filename header type for object [{}..{}]", start, end);
}
let entry_start = start + head.size;
let filename = self.inner.read_filename(head.size)?;
let head: CaFormatHeader = self.inner.read_item()?;
check_ca_header::<CaFormatEntry>(&head, CA_FORMAT_ENTRY)?;
let entry: CaFormatEntry = self.inner.read_item()?;
Ok(CaDirectoryEntry {
start: entry_start,
end: end,
filename: filename,
entry,
})
}
pub fn list_dir(&mut self, dir: &CaDirectoryEntry) -> Result<Vec<CaDirectoryEntry>, Error> {
const GOODBYE_ITEM_SIZE: u64 = std::mem::size_of::<CaFormatGoodbyeItem>() as u64;
let start = dir.start;
let end = dir.end;
//println!("list_dir1: {} {}", start, end);
if (end - start) < (HEADER_SIZE + GOODBYE_ITEM_SIZE) {
bail!("detected short object [{}..{}]", start, end);
}
self.seek(SeekFrom::Start(end - GOODBYE_ITEM_SIZE))?;
let item: CaFormatGoodbyeItem = self.inner.read_item()?;
if item.hash != CA_FORMAT_GOODBYE_TAIL_MARKER {
bail!("missing goodbye tail marker for object [{}..{}]", start, end);
}
let goodbye_table_size = item.size;
if goodbye_table_size < (HEADER_SIZE + GOODBYE_ITEM_SIZE) {
bail!("short goodbye table size for object [{}..{}]", start, end);
}
let goodbye_inner_size = goodbye_table_size - HEADER_SIZE - GOODBYE_ITEM_SIZE;
if (goodbye_inner_size % GOODBYE_ITEM_SIZE) != 0 {
bail!("wrong goodbye inner table size for entry [{}..{}]", start, end);
}
let goodbye_start = end - goodbye_table_size;
if item.offset != (goodbye_start - start) {
println!("DEBUG: {} {}", u64::from_le(item.offset), goodbye_start - start);
bail!("wrong offset in goodbye tail marker for entry [{}..{}]", start, end);
}
self.seek(SeekFrom::Start(goodbye_start))?;
let head: CaFormatHeader = self.inner.read_item()?;
if head.htype != CA_FORMAT_GOODBYE {
bail!("wrong goodbye table header type for entry [{}..{}]", start, end);
}
if head.size != goodbye_table_size {
bail!("wrong goodbye table size for entry [{}..{}]", start, end);
}
let mut range_list = Vec::new();
for i in 0..goodbye_inner_size/GOODBYE_ITEM_SIZE {
let item: CaFormatGoodbyeItem = self.inner.read_item()?;
if item.offset > (goodbye_start - start) {
bail!("goodbye entry {} offset out of range [{}..{}] {} {} {}",
i, start, end, item.offset, goodbye_start, start);
}
let item_start = goodbye_start - item.offset;
let item_end = item_start + item.size;
if item_end > goodbye_start {
bail!("goodbye entry {} end out of range [{}..{}]",
i, start, end);
}
range_list.push((item_start, item_end));
}
let mut result = vec![];
for (item_start, item_end) in range_list {
let entry = self.read_directory_entry(item_start, item_end)?;
//println!("ENTRY: {} {} {:?}", item_start, item_end, entry.filename);
result.push(entry);
}
Ok(result)
}
pub fn print_filenames<W: std::io::Write>(
&mut self,
output: &mut W,
prefix: &mut PathBuf,
dir: &CaDirectoryEntry,
) -> Result<(), Error> {
let mut list = self.list_dir(dir)?;
list.sort_unstable_by(|a, b| a.filename.cmp(&b.filename));
for item in &list {
prefix.push(item.filename.clone());
let mode = item.entry.mode as u32;
let ifmt = mode & libc::S_IFMT;
writeln!(output, "{:?}", prefix)?;
if ifmt == libc::S_IFDIR {
self.print_filenames(output, prefix, item)?;
} else if ifmt == libc::S_IFREG {
} else if ifmt == libc::S_IFLNK {
} else if ifmt == libc::S_IFBLK {
} else if ifmt == libc::S_IFCHR {
} else {
bail!("unknown item mode/type for {:?}", prefix);
}
prefix.pop();
}
Ok(())
}
}