use std::collections::HashMap;
use std::io::{Read, Seek, Write};
use tar::{Builder, EntryType, Header};
use crate::acl::Acl;
use crate::archive::ArchiveError;
use crate::ondisk::{Inode, Timestamp, Xattr};
use crate::read::{ReadError, Reader, WalkEntry};
const LOST_FOUND: &[u8] = b"/lost+found";
const ROOT_INO: u32 = 2;
const IFMT: u16 = 0o170000;
const IFDIR: u16 = 0o040000;
const IFREG: u16 = 0o100000;
const IFLNK: u16 = 0o120000;
const IFCHR: u16 = 0o020000;
const IFBLK: u16 = 0o060000;
const IFIFO: u16 = 0o010000;
const IFSOCK: u16 = 0o140000;
pub struct ArchiveSink<W: Write> {
builder: Builder<W>,
}
impl<W: Write> ArchiveSink<W> {
#[must_use]
pub fn new(out: W) -> Self {
Self {
builder: Builder::new(out),
}
}
pub fn write_tree<R: Read + Seek>(
mut self,
reader: &mut Reader<R>,
) -> Result<(), ArchiveError> {
let root = reader.inode(ROOT_INO)?;
let xattrs = reader.xattrs(&root)?;
self.append(reader, &Member::root(root, xattrs))?;
let mut named: HashMap<u32, Vec<u8>> = HashMap::new();
reader.walk_with(|reader, entry| {
if is_lost_found(&entry.path) {
return Ok(());
}
let member = Member::of(reader, entry, &mut named)?;
self.append(reader, &member)
})?;
self.builder.finish().map_err(ArchiveError::Io)
}
fn append<R: Read + Seek>(
&mut self,
reader: &mut Reader<R>,
m: &Member,
) -> Result<(), ArchiveError> {
let kind = m.inode.mode & IFMT;
let name = member_name(&m.path, kind == IFDIR);
let entry_type = if m.hardlink.is_some() {
EntryType::Link
} else {
match kind {
IFDIR => EntryType::Directory,
IFREG => EntryType::Regular,
IFLNK => EntryType::Symlink,
IFCHR => EntryType::Char,
IFBLK => EntryType::Block,
IFIFO => EntryType::Fifo,
_ => {
return Err(ArchiveError::Unrepresentable {
path: m.path.clone(),
});
}
}
};
let target = m.hardlink.as_ref().or(m.symlink.as_ref());
let mut records: Vec<(String, Vec<u8>)> = vec![
("path".to_string(), name.clone()),
("atime".to_string(), pax_time(m.inode.atime).into()),
("ctime".to_string(), pax_time(m.inode.ctime).into()),
("mtime".to_string(), pax_time(m.inode.mtime).into()),
("uid".to_string(), m.inode.uid.to_string().into()),
("gid".to_string(), m.inode.gid.to_string().into()),
];
if let Some(target) = target {
records.push(("linkpath".to_string(), target.clone()));
}
for xattr in &m.xattrs {
records.push((
pax_xattr_key(&m.path, &xattr.name)?,
xattr_value(&m.path, xattr)?,
));
}
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(m.inode.mode & 0o7777));
header.set_uid(u64::from(m.inode.uid));
header.set_gid(u64::from(m.inode.gid));
header.set_mtime(u64::try_from(m.inode.mtime.secs).unwrap_or(0));
if let Some((major, minor)) = m.device {
header.set_device_major(major).map_err(ArchiveError::Io)?;
header.set_device_minor(minor).map_err(ArchiveError::Io)?;
}
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 = if m.streams_data {
reader.file_len(&m.inode)
} else {
0
};
header.set_size(size);
header.set_cksum();
if size == 0 {
return self
.builder
.append(&header, std::io::empty())
.map_err(ArchiveError::Io);
}
let body = InodeData::new(reader, m.inode.clone());
self.builder
.append(&header, body)
.map_err(|e| ArchiveError::from_body_io(e, &m.path))
}
}
struct InodeData<'a, R> {
reader: &'a mut Reader<R>,
inode: Inode,
offset: u64,
}
impl<'a, R: Read + Seek> InodeData<'a, R> {
fn new(reader: &'a mut Reader<R>, inode: Inode) -> Self {
Self {
reader,
inode,
offset: 0,
}
}
}
impl<R: Read + Seek> Read for InodeData<'_, R> {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
let filled = self
.reader
.read_into(&self.inode, self.offset, buf)
.map_err(|e| match e {
ReadError::Io { kind, message } => std::io::Error::new(kind, message),
other => std::io::Error::other(other.to_string()),
})?;
self.offset += filled as u64;
Ok(filled)
}
}
struct Member {
path: Vec<u8>,
inode: Inode,
xattrs: Vec<Xattr>,
hardlink: Option<Vec<u8>>,
symlink: Option<Vec<u8>>,
device: Option<(u32, u32)>,
streams_data: bool,
}
impl Member {
fn root(inode: Inode, xattrs: Vec<Xattr>) -> Self {
Self {
path: Vec::new(),
inode,
xattrs,
hardlink: None,
symlink: None,
device: None,
streams_data: false,
}
}
fn of<R: Read + Seek>(
reader: &mut Reader<R>,
entry: WalkEntry,
named: &mut HashMap<u32, Vec<u8>>,
) -> Result<Self, ArchiveError> {
let WalkEntry {
path,
number,
inode,
..
} = entry;
let kind = inode.mode & IFMT;
if kind == IFSOCK {
return Err(ArchiveError::Unrepresentable { path });
}
let hardlink = if kind == IFDIR {
None
} else {
match named.get(&number) {
Some(first) => Some(member_name(first, false)),
None => {
named.insert(number, path.clone());
None
}
}
};
if hardlink.is_some() {
return Ok(Self {
path,
inode,
xattrs: Vec::new(),
hardlink,
symlink: None,
device: None,
streams_data: false,
});
}
let symlink = if kind == IFLNK {
Some(reader.read_symlink(&inode)?)
} else {
None
};
let device = if kind == IFCHR || kind == IFBLK {
Some(reader.device(&inode))
} else {
None
};
let xattrs = reader.xattrs(&inode)?;
Ok(Self {
path,
inode,
xattrs,
hardlink: None,
symlink,
device,
streams_data: kind == IFREG,
})
}
}
fn is_lost_found(path: &[u8]) -> bool {
path == LOST_FOUND || path.starts_with(b"/lost+found/")
}
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.contains('=') && !text.contains('\n') => {
Ok(format!("SCHILY.xattr.{text}"))
}
_ => Err(ArchiveError::XattrNameUnrepresentable {
path: path.to_vec(),
name: name.to_vec(),
}),
}
}
fn xattr_value(path: &[u8], xattr: &Xattr) -> Result<Vec<u8>, ArchiveError> {
if xattr.name == Acl::ACCESS_NAME || xattr.name == Acl::DEFAULT_NAME {
let acl = Acl::decode(&xattr.value).map_err(|source| ArchiveError::Acl {
path: path.to_vec(),
source,
})?;
return Ok(acl.encode_xattr_v2());
}
Ok(xattr.value.clone())
}
#[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 lost_and_found_is_recognized_with_its_contents() {
assert!(is_lost_found(b"/lost+found"));
assert!(is_lost_found(b"/lost+found/17"));
assert!(!is_lost_found(b"/lost+found-old"));
assert!(!is_lost_found(b"/etc/lost+found"));
}
#[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.\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"
);
}
}