use failure::*;
use libc;
+use super::binary_search_tree::search_binary_tree_by;
use super::format_definition::*;
use super::sequential_decoder::SequentialDecoder;
use super::match_pattern::MatchPattern;
start: u64,
/// Points past the goodbye table tail
end: u64,
+ /// Filename of entry
pub filename: OsString,
+ /// Entry (mode, permissions)
pub entry: PxarEntry,
+ /// Extended attributes
+ pub xattr: PxarAttributes,
+ /// Payload size
+ pub size: u64,
+ /// Target path for symbolic links
+ pub target: Option<PathBuf>,
+ /// Start offset of the payload if present.
+ pub payload_offset: Option<u64>,
}
+/// Trait to create ReadSeek Decoder trait objects.
+trait ReadSeek: Read + Seek {}
+impl <R: Read + Seek> ReadSeek for R {}
+
// This one needs Read+Seek
-pub struct Decoder<R: Read + Seek, F: Fn(&Path) -> Result<(), Error>> {
- inner: SequentialDecoder<R, F>,
+pub struct Decoder {
+ inner: SequentialDecoder<Box<dyn ReadSeek + Send>>,
root_start: u64,
root_end: u64,
}
const HEADER_SIZE: u64 = std::mem::size_of::<PxarHeader>() as u64;
const GOODBYE_ITEM_SIZE: u64 = std::mem::size_of::<PxarGoodbyeItem>() as u64;
-impl<R: Read + Seek, F: Fn(&Path) -> Result<(), Error>> Decoder<R, F> {
- pub fn new(mut reader: R, callback: F) -> Result<Self, Error> {
+impl Decoder {
+ pub fn new<R: Read + Seek + Send + 'static>(mut reader: R) -> Result<Self, Error> {
let root_end = reader.seek(SeekFrom::End(0))?;
+ let boxed_reader: Box<dyn ReadSeek + 'static + Send> = Box::new(reader);
+ let inner = SequentialDecoder::new(boxed_reader, super::flags::DEFAULT);
+
+ Ok(Self { inner, root_start: 0, root_end })
+ }
- Ok(Self {
- inner: SequentialDecoder::new(reader, super::flags::DEFAULT, callback),
- root_start: 0,
- root_end,
- })
+ pub fn set_callback<F: Fn(&Path) -> Result<(), Error> + Send + 'static>(&mut self, callback: F ) {
+ self.inner.set_callback(callback);
}
pub fn root(&mut self) -> Result<DirectoryEntry, Error> {
let header: PxarHeader = self.inner.read_item()?;
check_ca_header::<PxarEntry>(&header, PXAR_ENTRY)?;
let entry: PxarEntry = self.inner.read_item()?;
+ let (header, xattr) = self.inner.read_attributes()?;
+ let (size, payload_offset) = match header.htype {
+ PXAR_PAYLOAD => (header.size - HEADER_SIZE, Some(self.seek(SeekFrom::Current(0))?)),
+ _ => (0, None),
+ };
+
Ok(DirectoryEntry {
start: self.root_start,
end: self.root_end,
filename: OsString::new(), // Empty
entry,
+ xattr,
+ size,
+ target: None,
+ payload_offset,
})
}
}
check_ca_header::<PxarEntry>(&head, PXAR_ENTRY)?;
let entry: PxarEntry = self.inner.read_item()?;
+ let (header, xattr) = self.inner.read_attributes()?;
+ let (size, payload_offset) = match header.htype {
+ PXAR_PAYLOAD => (header.size - HEADER_SIZE, Some(self.seek(SeekFrom::Current(0))?)),
+ _ => (0, None),
+ };
+ let target = match header.htype {
+ PXAR_SYMLINK => Some(self.inner.read_link(header.size)?),
+ _ => None,
+ };
Ok(DirectoryEntry {
start: entry_start,
end,
filename,
entry,
+ xattr,
+ size,
+ target,
+ payload_offset,
})
}
&mut self,
dir: &DirectoryEntry,
filename: &OsStr,
- ) -> Result<Option<(DirectoryEntry, PxarAttributes)>, Error> {
+ ) -> Result<Option<DirectoryEntry>, Error> {
let gbt = self.goodbye_table(Some(dir.start), dir.end)?;
let hash = compute_goodbye_hash(filename.as_bytes());
- let mut iterator = gbt.iter();
+ let mut start_idx = 0;
+ let mut skip_multiple = 0;
loop {
// Search for the next goodbye entry with matching hash.
- let (start, end) = match iterator.find(|(i, _, _)| i.hash == hash) {
- Some((_item, start, end)) => (start, end),
+ let idx = search_binary_tree_by(
+ start_idx,
+ gbt.len(),
+ skip_multiple,
+ |idx| hash.cmp(&gbt[idx].0.hash),
+ );
+ let (_item, start, end) = match idx {
+ Some(idx) => &gbt[idx],
None => return Ok(None),
};
- // At this point it is not clear if the item is a directory or not,
- // this has to be decided based on the entry mode.
- // `Decoder`s attributes function accepts both, offsets pointing to
- // the start of an item (PXAR_FILENAME) or the GOODBYE_TAIL_MARKER in
- // case of directories, so the use of start offset is fine for both
- // cases.
- let (entry_name, entry, attr, _payload_size) = self.attributes(*start)?;
+ let entry = self.read_directory_entry(*start, *end)?;
// Possible hash collision, need to check if the found entry is indeed
// the filename to lookup.
- if entry_name == filename {
- let dir_entry = DirectoryEntry {
- start: *start + HEADER_SIZE + entry_name.len() as u64 + 1,
- end: *end,
- filename: entry_name,
- entry,
- };
- return Ok(Some((dir_entry, attr)));
+ if entry.filename == filename {
+ return Ok(Some(entry));
}
+ // Hash collision, check the next entry in the goodbye table by starting
+ // from given index but skipping one more match (so hash at index itself).
+ start_idx = idx.unwrap();
+ skip_multiple = 1;
}
}
- /// Get attributes for the archive item located at `offset`.
- ///
- /// Returns the entry, attributes and the payload size for the item.
- /// For regular archive itmes a `PXAR_FILENAME` or a `PXAR_ENTRY` header is
- /// expected at `offset`.
- /// For directories, `offset` might also (but not necessarily) point at the
- /// directories `PXAR_GOODBYE_TAIL_MARKER`. This is not mandatory and it can
- /// also directly point to its `PXAR_FILENAME` or `PXAR_ENTRY`, thereby
- /// avoiding an additional seek.
- pub fn attributes(&mut self, offset: u64) -> Result<(OsString, PxarEntry, PxarAttributes, u64), Error> {
- self.seek(SeekFrom::Start(offset))?;
-
- let mut marker: u64 = self.inner.read_item()?;
- if marker == PXAR_GOODBYE_TAIL_MARKER {
- let dir_offset: u64 = self.inner.read_item()?;
- let gb_size: u64 = self.inner.read_item()?;
- let distance = i64::try_from(dir_offset + gb_size)?;
- self.seek(SeekFrom::Current(0 - distance))?;
- marker = self.inner.read_item()?;
- }
-
- let filename = if marker == PXAR_FILENAME {
- let size: u64 = self.inner.read_item()?;
- let filename = self.inner.read_filename(size)?;
- marker = self.inner.read_item()?;
- filename
- } else {
- OsString::new()
- };
-
- if marker == PXAR_FORMAT_HARDLINK {
- let size: u64 = self.inner.read_item()?;
- let (_, diff) = self.inner.read_hardlink(size)?;
- return self.attributes(offset - diff);
- }
-
- if marker != PXAR_ENTRY {
- bail!("Expected PXAR_ENTRY, found 0x{:x?}", marker);
- }
- let _size: u64 = self.inner.read_item()?;
- let entry: PxarEntry = self.inner.read_item()?;
- let (header, xattr) = self.inner.read_attributes()?;
- let file_size = match header.htype {
- PXAR_PAYLOAD => header.size - HEADER_SIZE,
- _ => 0,
- };
-
- Ok((filename, entry, xattr, file_size))
- }
-
- /// Opens the file by validating the given `offset` and returning its attrs,
- /// xattrs and size.
- pub fn open(&mut self, offset: u64) -> Result<(OsString, PxarEntry, PxarAttributes, u64), Error> {
- self.attributes(offset)
- }
-
- /// Read the payload of the file given by `offset`.
+ /// Read the payload of the file given by `entry`.
///
- /// This will read the file by first seeking to `offset` within the archive,
- /// check if there is indeed a valid item with payload and then read `size`
- /// bytes of content starting from `data_offset`.
- /// If EOF is reached before reading `size` bytes, the reduced buffer is
- /// returned.
- pub fn read(&mut self, offset: u64, size: usize, data_offset: u64) -> Result<Vec<u8>, Error> {
- self.seek(SeekFrom::Start(offset))?;
- let head: PxarHeader = self.inner.read_item()?;
- if head.htype != PXAR_FILENAME {
- bail!("Expected PXAR_FILENAME, encountered 0x{:x?}", head.htype);
- }
- let _filename = self.inner.read_filename(head.size)?;
-
- let head: PxarHeader = self.inner.read_item()?;
- check_ca_header::<PxarEntry>(&head, PXAR_ENTRY)?;
- let _: PxarEntry = self.inner.read_item()?;
-
- let (header, _) = self.inner.read_attributes()?;
- if header.htype != PXAR_PAYLOAD {
- bail!("Expected PXAR_PAYLOAD, found 0x{:x?}", header.htype);
- }
-
- let payload_size = header.size - HEADER_SIZE;
- if data_offset >= payload_size {
+ /// This will read a files payload as raw bytes starting from `offset` after
+ /// the payload marker, reading `size` bytes.
+ /// If the payload from `offset` to EOF is smaller than `size` bytes, the
+ /// buffer with reduced size is returned.
+ /// If `offset` is larger than the payload size of the `DirectoryEntry`, an
+ /// empty buffer is returned.
+ pub fn read(&mut self, entry: &DirectoryEntry, size: usize, offset: u64) -> Result<Vec<u8>, Error> {
+ let start_offset = entry.payload_offset
+ .ok_or_else(|| format_err!("entry has no payload offset"))?;
+ if offset >= entry.size {
return Ok(Vec::new());
}
-
- let len = if data_offset + u64::try_from(size)? > payload_size {
- usize::try_from(payload_size - data_offset)?
+ let len = if u64::try_from(size)? > entry.size {
+ usize::try_from(entry.size)?
} else {
size
};
- self.inner.skip_bytes(usize::try_from(data_offset)?)?;
+ self.seek(SeekFrom::Start(start_offset + offset))?;
let data = self.inner.get_reader_mut().read_exact_allocated(len)?;
Ok(data)
}
-
- /// Read the target of a hardlink in the archive.
- pub fn read_link(&mut self, offset: u64) -> Result<(PathBuf, PxarEntry), Error> {
- self.seek(SeekFrom::Start(offset))?;
- let mut header: PxarHeader = self.inner.read_item()?;
- if header.htype != PXAR_FILENAME {
- bail!("Expected PXAR_FILENAME, encountered 0x{:x?}", header.htype);
- }
- let _filename = self.inner.read_filename(header.size)?;
-
- header = self.inner.read_item()?;
- check_ca_header::<PxarEntry>(&header, PXAR_ENTRY)?;
- let entry: PxarEntry = self.inner.read_item()?;
-
- header = self.inner.read_item()?;
- if header.htype != PXAR_SYMLINK {
- bail!("Expected PXAR_SYMLINK, encountered 0x{:x?}", header.htype);
- }
- let target = self.inner.read_link(header.size)?;
-
- Ok((target, entry))
- }
}
projects / proxmox-backup.git / blobdiff