use std::collections::HashMap;
use std::io::{Read, Write};
use tar::{Builder, EntryType, Header};
use crate::archive::ArchiveError;
use crate::fidelity::{Direction, FidelityReport, Property, Synthesis};
use crate::time::Timestamp;
use crate::tree::{
Attributes, BODY_WINDOW, FsTree, NodeKind, TreeEntry, TreeError, flags_not_carried,
made_by_the_format,
};
pub struct ArchiveSink<W: Write> {
builder: Builder<W>,
synthesis: Synthesis,
}
impl<W: Write> ArchiveSink<W> {
#[must_use]
pub fn new(out: W) -> Self {
Self {
builder: Builder::new(out),
synthesis: Synthesis::new(),
}
}
#[must_use]
pub fn synthesis(mut self, synthesis: Synthesis) -> Self {
self.synthesis = synthesis;
self
}
pub fn write_tree<T: FsTree>(mut self, tree: &mut T) -> Result<FidelityReport, ArchiveError> {
let mut named: HashMap<u64, Vec<u8>> = HashMap::new();
let mut fidelity = FidelityReport::new();
let synthesis = self.synthesis;
tree.walk_tree(|tree, entry| {
if made_by_the_format(&entry.path, tree.family()) {
return Ok(());
}
let member = Member::of(tree, entry, &mut named, &synthesis, &mut fidelity)?;
self.append(tree, &member)
})?;
self.builder.finish().map_err(ArchiveError::Io)?;
Ok(fidelity)
}
fn append<T: FsTree>(&mut self, tree: &mut T, m: &Member<T::Node>) -> Result<(), ArchiveError> {
let name = member_name(&m.path, matches!(m.kind, NodeKind::Directory));
let entry_type = if m.hardlink.is_some() {
EntryType::Link
} else {
match m.kind {
NodeKind::Directory => EntryType::Directory,
NodeKind::File { .. } => EntryType::Regular,
NodeKind::Symlink => EntryType::Symlink,
NodeKind::CharDevice { .. } => EntryType::Char,
NodeKind::BlockDevice { .. } => EntryType::Block,
NodeKind::Fifo => EntryType::Fifo,
NodeKind::Socket => {
return Err(ArchiveError::Unrepresentable {
path: m.path.clone(),
});
}
}
};
let target = m.hardlink.as_ref().or(m.symlink.as_ref());
let meta = &m.attrs.meta;
let mut records: Vec<(String, Vec<u8>)> = vec![
("path".to_string(), name.clone()),
("atime".to_string(), pax_time(meta.atime).into()),
("ctime".to_string(), pax_time(meta.ctime).into()),
("mtime".to_string(), pax_time(meta.mtime).into()),
("uid".to_string(), meta.uid.to_string().into()),
("gid".to_string(), meta.gid.to_string().into()),
];
if let Some(target) = target {
records.push(("linkpath".to_string(), target.clone()));
}
for xattr in &m.attrs.xattrs {
records.push((pax_xattr_key(&m.path, &xattr.name)?, xattr.value.clone()));
}
let borrowed: Vec<(&str, &[u8])> = records
.iter()
.map(|(k, v)| (k.as_str(), v.as_slice()))
.collect();
self.builder
.append_pax_extensions(borrowed)
.map_err(ArchiveError::Io)?;
let mut header = Header::new_ustar();
header.set_entry_type(entry_type);
header.set_mode(u32::from(meta.mode & 0o7777));
header.set_uid(u64::from(meta.uid));
header.set_gid(u64::from(meta.gid));
header.set_mtime(u64::try_from(meta.mtime.secs).unwrap_or(0));
if let NodeKind::CharDevice { major, minor } | NodeKind::BlockDevice { major, minor } =
m.kind
&& let Some(ustar) = header.as_ustar_mut()
{
device_field(&mut ustar.dev_major, major);
device_field(&mut ustar.dev_minor, minor);
}
if let Ok(text) = std::str::from_utf8(&name) {
let _ = header.set_path(text);
}
if let Some(target) = target
&& let Ok(text) = std::str::from_utf8(target)
{
let _ = header.set_link_name(text);
}
let size = match m.kind {
NodeKind::File { size } if m.hardlink.is_none() => size,
_ => 0,
};
tree.check_file_size(&m.path, size)?;
header.set_size(size);
header.set_cksum();
if size == 0 {
return self
.builder
.append(&header, std::io::empty())
.map_err(ArchiveError::Io);
}
let window = usize::try_from(size).unwrap_or(usize::MAX).min(BODY_WINDOW);
let mut body =
std::io::BufReader::with_capacity(window, NodeData::new(tree, &m.node, size));
match self.builder.append(&header, &mut body) {
Ok(()) => Ok(()),
Err(e) => {
let body = body.into_inner();
Err(match (body.failed, body.short) {
(Some(source), _) => ArchiveError::Read(source),
(None, true) => ArchiveError::ShortRead {
path: m.path.clone(),
size,
got: body.offset,
},
(None, false) => ArchiveError::from_body_io(e, &m.path),
})
}
}
}
}
struct NodeData<'a, T: FsTree> {
tree: &'a mut T,
node: &'a T::Node,
offset: u64,
size: u64,
failed: Option<TreeError>,
short: bool,
}
impl<'a, T: FsTree> NodeData<'a, T> {
fn new(tree: &'a mut T, node: &'a T::Node, size: u64) -> Self {
Self {
tree,
node,
offset: 0,
size,
failed: None,
short: false,
}
}
}
impl<T: FsTree> Read for NodeData<'_, T> {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
let left = self.size.saturating_sub(self.offset);
if left == 0 || buf.is_empty() {
return Ok(0);
}
let want = usize::try_from(left).unwrap_or(usize::MAX).min(buf.len());
let filled = match self
.tree
.read_bytes(self.node, self.offset, &mut buf[..want])
{
Ok(filled) => filled,
Err(e) => {
let carried = match &e {
TreeError::Io { kind, message } => std::io::Error::new(*kind, message.clone()),
other => std::io::Error::other(other.to_string()),
};
self.failed = Some(e);
return Err(carried);
}
};
if filled == 0 {
self.short = true;
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"the filesystem yielded fewer bytes than the file's length",
));
}
self.offset += filled as u64;
Ok(filled)
}
}
struct Member<N> {
path: Vec<u8>,
kind: NodeKind,
attrs: Attributes,
hardlink: Option<Vec<u8>>,
symlink: Option<Vec<u8>>,
node: N,
}
impl<N> Member<N> {
fn of<T: FsTree<Node = N>>(
tree: &mut T,
entry: TreeEntry<N>,
named: &mut HashMap<u64, Vec<u8>>,
synthesis: &Synthesis,
fidelity: &mut FidelityReport,
) -> Result<Self, ArchiveError> {
let TreeEntry {
path,
kind,
shared,
node,
..
} = entry;
if matches!(kind, NodeKind::Socket) {
return Err(ArchiveError::Unrepresentable { path });
}
if let NodeKind::CharDevice { major, minor } | NodeKind::BlockDevice { major, minor } = kind
&& (major > DEVICE_MAX || minor > DEVICE_MAX)
{
return Err(ArchiveError::DeviceUnrepresentable { path, major, minor });
}
let hardlink = match shared {
Some(id) => match named.get(&id) {
Some(first) => Some(member_name(first, false)),
None => {
named.insert(id, path.clone());
None
}
},
None => None,
};
let mut attrs = tree.stat(&node, synthesis)?;
for property in &attrs.synthesized {
fidelity.record(Direction::Synthesized, &path, *property);
}
if hardlink.is_none() && flags_not_carried(tree, &node)? != 0 {
fidelity.record(Direction::Dropped, &path, Property::BsdFlags);
}
if hardlink.is_some() {
attrs.xattrs.clear();
}
let symlink = if matches!(kind, NodeKind::Symlink) && hardlink.is_none() {
Some(tree.link_target(&node)?)
} else {
None
};
Ok(Self {
path,
kind,
attrs,
hardlink,
symlink,
node,
})
}
}
const DEVICE_MAX: u32 = 0o7777_7777;
fn device_field(field: &mut [u8; 8], value: u32) -> bool {
let digits = if value <= 0o777_7777 {
format!("{value:07o}\0")
} else if value <= DEVICE_MAX {
format!("{value:08o}")
} else {
return false;
};
field.copy_from_slice(digits.as_bytes());
true
}
fn member_name(path: &[u8], directory: bool) -> Vec<u8> {
let mut name = Vec::with_capacity(path.len() + 2);
name.push(b'.');
name.extend_from_slice(path);
if directory {
name.push(b'/');
}
name
}
#[must_use]
fn pax_time(t: Timestamp) -> String {
let t = Timestamp {
secs: t
.secs
.saturating_add(i64::from(t.nanos / Timestamp::NANOS_PER_SEC)),
nanos: t.nanos % Timestamp::NANOS_PER_SEC,
};
if t.nanos == 0 {
return t.secs.to_string();
}
if t.secs < 0 {
let whole = t.secs + 1;
let frac = Timestamp::NANOS_PER_SEC - t.nanos;
if whole == 0 {
return format!("-0.{frac:09}");
}
return format!("{whole}.{frac:09}");
}
format!("{}.{:09}", t.secs, t.nanos)
}
fn pax_xattr_key(path: &[u8], name: &[u8]) -> Result<String, ArchiveError> {
match std::str::from_utf8(name) {
Ok(text) if !text.is_empty() && !text.contains(['=', '\n', '\0']) => {
Ok(format!("SCHILY.xattr.{text}"))
}
_ => Err(ArchiveError::XattrNameUnrepresentable {
path: path.to_vec(),
name: name.to_vec(),
}),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_member_is_named_relative_to_the_archive_root() {
assert_eq!(member_name(b"/etc/hostname", false), b"./etc/hostname");
assert_eq!(member_name(b"/etc", true), b"./etc/");
assert_eq!(member_name(b"", true), b"./");
}
#[test]
fn a_device_number_fills_the_header_field_as_far_as_it_reads_back() {
for value in [0u32, 3, 0o777_7777, 0o1000_0000, 16_777_215] {
let mut header = Header::new_ustar();
let ustar = header.as_ustar_mut().expect("a ustar header");
assert!(device_field(&mut ustar.dev_minor, value), "{value}");
assert_eq!(header.device_minor().expect("a number"), Some(value));
}
let mut ours = Header::new_ustar();
device_field(&mut ours.as_ustar_mut().expect("ustar").dev_minor, 3);
let mut theirs = Header::new_ustar();
theirs.set_device_minor(3).expect("a ustar header");
assert_eq!(ours.as_bytes(), theirs.as_bytes());
let mut header = Header::new_ustar();
let ustar = header.as_ustar_mut().expect("a ustar header");
assert!(!device_field(&mut ustar.dev_minor, DEVICE_MAX + 1));
}
#[test]
fn a_pax_xattr_key_is_built_for_a_plain_name_and_refused_otherwise() {
assert_eq!(
pax_xattr_key(b"/f", b"user.comment").unwrap(),
"SCHILY.xattr.user.comment"
);
for bad in [
&b"user.a=b"[..],
b"user.a\nb",
b"user.a\0b",
b"",
b"user.\xff",
] {
assert!(
matches!(
pax_xattr_key(b"/f", bad),
Err(ArchiveError::XattrNameUnrepresentable { .. })
),
"name {bad:?} must be refused"
);
}
}
#[test]
fn a_pax_time_is_the_instant_it_names() {
assert_eq!(pax_time(Timestamp::from_secs(1_700_000_000)), "1700000000");
assert_eq!(
pax_time(Timestamp {
secs: 1_700_000_000,
nanos: 123_456_789
}),
"1700000000.123456789"
);
assert_eq!(
pax_time(Timestamp {
secs: -6,
nanos: 750_000_000
}),
"-5.250000000"
);
assert_eq!(
pax_time(Timestamp {
secs: -1,
nanos: 500_000_000
}),
"-0.500000000"
);
assert_eq!(pax_time(Timestamp::from_secs(-1)), "-1");
}
#[test]
fn a_pax_time_carries_an_over_long_fraction_into_the_seconds() {
assert_eq!(
pax_time(Timestamp {
secs: 100,
nanos: 1_073_741_823 }),
"101.073741823"
);
assert_eq!(
pax_time(Timestamp {
secs: -6,
nanos: 1_073_741_823
}),
"-4.926258177"
);
assert_eq!(
pax_time(Timestamp {
secs: 10,
nanos: 2_000_000_000
}),
"12"
);
}
}