use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use tar::EntryType;
use crate::acl::{Acl, AclEntry, AclQualifier, EXEC, READ, WRITE};
use crate::ondisk::{Timestamp, Xattr};
use crate::source::{EntryKind, FileContent, FileRange, Metadata, Source, SourceEntry};
mod blocks;
mod sink;
use blocks::{Member, MemberBody, PaxRecord};
pub use sink::ArchiveSink;
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum ArchiveError {
#[error("reading archive: {0}")]
Io(#[from] std::io::Error),
#[error("archive entry {}: {reason}", String::from_utf8_lossy(path))]
#[non_exhaustive]
Bad {
path: Vec<u8>,
reason: &'static str,
},
#[error(
"archive entry {} has an unsupported type",
String::from_utf8_lossy(path)
)]
#[non_exhaustive]
Unsupported {
path: Vec<u8>,
},
#[error("malformed archive: {reason}")]
#[non_exhaustive]
Malformed {
reason: &'static str,
},
#[error(
"the archive is {format}-compressed, and this reads uncompressed tar: decompress it first"
)]
#[non_exhaustive]
Compressed {
format: &'static str,
},
#[error(
"archive entry {} has an invalid ACL: {source}",
String::from_utf8_lossy(path)
)]
#[non_exhaustive]
Acl {
path: Vec<u8>,
source: crate::acl::AclError,
},
#[error(transparent)]
Read(#[from] crate::read::ReadError),
#[error(
"{} is a socket, which a tar archive has no entry type for: writing it out would \
drop it silently",
String::from_utf8_lossy(path)
)]
#[non_exhaustive]
Unrepresentable {
path: Vec<u8>,
},
#[error(
"{}: extended-attribute name {} cannot be written to a PAX record: it holds an '=' \
or a newline, or is not valid UTF-8",
String::from_utf8_lossy(path),
String::from_utf8_lossy(name)
)]
#[non_exhaustive]
XattrNameUnrepresentable {
path: Vec<u8>,
name: Vec<u8>,
},
}
impl ArchiveError {
fn from_body_io(e: std::io::Error, path: &[u8]) -> Self {
ArchiveError::Io(std::io::Error::new(
e.kind(),
format!("{}: {e}", String::from_utf8_lossy(path)),
))
}
}
pub struct ArchiveSource {
entries: Vec<SourceEntry>,
}
impl ArchiveSource {
pub fn from_reader<R: Read>(reader: R) -> Result<Self, ArchiveError> {
let entries = blocks::read_members(reader)?
.into_iter()
.map(|m| parse_entry(m, None))
.collect::<Result<Vec<_>, _>>()?;
Ok(Self { entries })
}
pub fn from_path(path: impl AsRef<Path>) -> Result<Self, ArchiveError> {
let path = path.as_ref();
let file = File::open(path)?;
let members = blocks::read_members_seeking(&file)?;
let backing = (Arc::new(file), path.to_path_buf());
let entries = members
.into_iter()
.map(|m| parse_entry(m, Some(&backing)))
.collect::<Result<Vec<_>, _>>()?;
Ok(Self { entries })
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
}
impl Source for ArchiveSource {
fn into_entries(self) -> Vec<SourceEntry> {
self.entries
}
}
#[derive(Default)]
struct Pax {
uid: Option<u64>,
gid: Option<u64>,
atime: Option<Timestamp>,
ctime: Option<Timestamp>,
mtime: Option<Timestamp>,
xattrs: Vec<Xattr>,
acl_access: Option<Acl>,
acl_default: Option<Acl>,
}
fn parse_entry(
member: Member,
backing: Option<&(Arc<File>, PathBuf)>,
) -> Result<SourceEntry, ArchiveError> {
let Member {
header,
path: raw_path,
link,
records,
body,
} = member;
let path = normalize(&raw_path).unwrap_or_else(|| b"/".to_vec());
let pax = collect_pax(&records, &path)?;
let mode = (header.mode()? & 0o7777) as u16;
let uid = match pax.uid {
Some(id) => id,
None => header.uid()?,
};
let uid = u32::try_from(uid).map_err(|_| ArchiveError::Bad {
path: path.clone(),
reason: "uid exceeds the 32-bit range ext4 stores",
})?;
let gid = match pax.gid {
Some(id) => id,
None => header.gid()?,
};
let gid = u32::try_from(gid).map_err(|_| ArchiveError::Bad {
path: path.clone(),
reason: "gid exceeds the 32-bit range ext4 stores",
})?;
let mtime = match pax.mtime {
Some(t) => t,
None => {
let secs = header.mtime().map_err(|_| ArchiveError::Bad {
path: path.clone(),
reason: "malformed modification time",
})?;
let secs = i64::try_from(secs).map_err(|_| ArchiveError::Bad {
path: path.clone(),
reason: "modification time exceeds the range ext4 stores",
})?;
Timestamp::from_secs(secs)
}
};
let meta = Metadata::new(mode, mtime).owned_by(uid, gid).with_times(
pax.atime.unwrap_or(mtime),
pax.ctime.unwrap_or(mtime),
mtime,
);
let kind = match header.entry_type() {
EntryType::Regular | EntryType::Continuous => EntryKind::File(match body {
MemberBody::Bytes(bytes) => FileContent::Owned(bytes),
MemberBody::Range { offset, len } => {
let (file, archive) = backing.expect("a located body comes from a backed parse");
FileContent::Range(FileRange::new(
Arc::clone(file),
archive.clone(),
offset,
len,
))
}
}),
EntryType::Directory => EntryKind::Directory,
EntryType::Symlink => EntryKind::Symlink(link_target(link, &path)?),
EntryType::Link => {
let target = link_target(link, &path)?;
let target = normalize(&target).ok_or(ArchiveError::Bad {
path: path.clone(),
reason: "hard link targets the archive root",
})?;
EntryKind::HardLink { target }
}
EntryType::Char => {
let (major, minor) = device(&header, &path)?;
EntryKind::CharDevice { major, minor }
}
EntryType::Block => {
let (major, minor) = device(&header, &path)?;
EntryKind::BlockDevice { major, minor }
}
EntryType::Fifo => EntryKind::Fifo,
_ => return Err(ArchiveError::Unsupported { path }),
};
let mut xattrs = pax.xattrs;
if let Some(acl) = &pax.acl_access {
xattrs.push(Xattr {
name: Acl::ACCESS_NAME.to_vec(),
value: acl.encode(),
});
}
if let Some(acl) = &pax.acl_default {
if !matches!(kind, EntryKind::Directory) {
return Err(ArchiveError::Bad {
path,
reason: "a default ACL on a non-directory",
});
}
xattrs.push(Xattr {
name: Acl::DEFAULT_NAME.to_vec(),
value: acl.encode(),
});
}
Ok(SourceEntry {
path,
kind,
meta,
xattrs,
})
}
fn link_target(link: Option<Vec<u8>>, path: &[u8]) -> Result<Vec<u8>, ArchiveError> {
link.ok_or(ArchiveError::Bad {
path: path.to_vec(),
reason: "link has no target",
})
}
fn device(header: &tar::Header, path: &[u8]) -> Result<(u32, u32), ArchiveError> {
let major = header.device_major()?.ok_or(ArchiveError::Bad {
path: path.to_vec(),
reason: "device has no major number",
})?;
let minor = header.device_minor()?.ok_or(ArchiveError::Bad {
path: path.to_vec(),
reason: "device has no minor number",
})?;
Ok((major, minor))
}
fn collect_pax(records: &[PaxRecord], path: &[u8]) -> Result<Pax, ArchiveError> {
let mut pax = Pax::default();
let mut libarchive_names: Vec<Vec<u8>> = Vec::new();
for record in records {
let key = record.key.as_slice();
let value = record.value.as_slice();
if key.starts_with(b"GNU.sparse.") {
return Err(ArchiveError::Bad {
path: path.to_vec(),
reason: "PAX-format sparse files are not supported",
});
} else if let Some(name) = key.strip_prefix(b"LIBARCHIVE.xattr.") {
libarchive_names.push(percent_decode(name));
} else if let Some(name) = key.strip_prefix(b"SCHILY.xattr.") {
if name == Acl::ACCESS_NAME {
pax.acl_access = Some(decode_acl_xattr(value, path)?);
} else if name == Acl::DEFAULT_NAME {
pax.acl_default = Some(decode_acl_xattr(value, path)?);
} else {
let name = name.to_vec();
pax.xattrs.retain(|x| x.name != name);
pax.xattrs.push(Xattr {
name,
value: value.to_vec(),
});
}
} else if key == b"SCHILY.acl.access" {
pax.acl_access = Some(parse_acl_text(value, path)?);
} else if key == b"SCHILY.acl.default" {
pax.acl_default = Some(parse_acl_text(value, path)?);
} else if key == b"uid" {
pax.uid = Some(parse_pax_id(value, "invalid PAX uid", path)?);
} else if key == b"gid" {
pax.gid = Some(parse_pax_id(value, "invalid PAX gid", path)?);
} else if key == b"atime" {
pax.atime = parse_pax_time(value, path)?;
} else if key == b"ctime" {
pax.ctime = parse_pax_time(value, path)?;
} else if key == b"mtime" {
pax.mtime = parse_pax_time(value, path)?;
}
}
for name in libarchive_names {
let carried = pax.xattrs.iter().any(|x| x.name == name)
|| (name == Acl::ACCESS_NAME && pax.acl_access.is_some())
|| (name == Acl::DEFAULT_NAME && pax.acl_default.is_some());
if !carried {
return Err(ArchiveError::Bad {
path: path.to_vec(),
reason: "a LIBARCHIVE.xattr record has no SCHILY counterpart to read it from",
});
}
}
Ok(pax)
}
fn percent_decode(name: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(name.len());
let mut i = 0;
while i < name.len() {
if name[i] == b'%'
&& i + 2 < name.len()
&& let (Some(hi), Some(lo)) = (hex_digit(name[i + 1]), hex_digit(name[i + 2]))
{
out.push((hi << 4) | lo);
i += 3;
continue;
}
out.push(name[i]);
i += 1;
}
out
}
fn hex_digit(b: u8) -> Option<u8> {
match b {
b'0'..=b'9' => Some(b - b'0'),
b'a'..=b'f' => Some(b - b'a' + 10),
b'A'..=b'F' => Some(b - b'A' + 10),
_ => None,
}
}
fn parse_pax_id(value: &[u8], reason: &'static str, path: &[u8]) -> Result<u64, ArchiveError> {
std::str::from_utf8(value)
.ok()
.and_then(|s| s.parse::<u64>().ok())
.ok_or_else(|| ArchiveError::Bad {
path: path.to_vec(),
reason,
})
}
fn parse_pax_time(value: &[u8], path: &[u8]) -> Result<Option<Timestamp>, ArchiveError> {
let text = std::str::from_utf8(value).map_err(|_| ArchiveError::Bad {
path: path.to_vec(),
reason: "non-UTF-8 PAX time",
})?;
let (secs_str, frac_str) = match text.split_once('.') {
Some((s, f)) => (s, f),
None => (text, ""),
};
let mut secs: i64 = secs_str.parse().map_err(|_| ArchiveError::Bad {
path: path.to_vec(),
reason: "invalid PAX time seconds",
})?;
let mut nanos: u32 = 0;
if !frac_str.is_empty() {
let digits: String = frac_str.chars().take(9).collect();
let scale = 9 - digits.len() as u32;
let parsed: u32 = digits.parse().map_err(|_| ArchiveError::Bad {
path: path.to_vec(),
reason: "invalid PAX time fraction",
})?;
nanos = parsed * 10u32.pow(scale);
}
if nanos != 0 && (secs < 0 || secs_str.starts_with('-')) {
secs = secs.checked_sub(1).ok_or(ArchiveError::Bad {
path: path.to_vec(),
reason: "invalid PAX time seconds",
})?;
nanos = 1_000_000_000 - nanos;
}
Ok(Some(Timestamp { secs, nanos }))
}
fn decode_acl_xattr(value: &[u8], path: &[u8]) -> Result<Acl, ArchiveError> {
Acl::decode_xattr_v2(value).map_err(|source| ArchiveError::Acl {
path: path.to_vec(),
source,
})
}
fn parse_acl_text(value: &[u8], path: &[u8]) -> Result<Acl, ArchiveError> {
let bad = |reason: &'static str| ArchiveError::Bad {
path: path.to_vec(),
reason,
};
let text = std::str::from_utf8(value).map_err(|_| bad("non-UTF-8 ACL text"))?;
let mut entries = Vec::new();
for token in text.split([',', '\n']) {
let token = token.trim();
if token.is_empty() {
continue;
}
let token = token.split('#').next().unwrap_or(token).trim();
let fields: Vec<&str> = token.split(':').map(str::trim).collect();
if fields.len() < 3 {
return Err(bad("ACL entry missing its permissions field"));
}
let tag = fields[0];
let qualifier = fields[1];
let perm = parse_acl_perm(fields[2]).ok_or(bad("invalid ACL permissions"))?;
let extra_id = fields.get(3).copied();
let who = match tag {
"user" | "u" => named_qualifier(
qualifier,
extra_id,
AclQualifier::UserObj,
AclQualifier::User,
|| bad("invalid or unresolved ACL user"),
)?,
"group" | "g" => named_qualifier(
qualifier,
extra_id,
AclQualifier::GroupObj,
AclQualifier::Group,
|| bad("invalid or unresolved ACL group"),
)?,
"mask" | "m" => AclQualifier::Mask,
"other" | "o" => AclQualifier::Other,
_ => return Err(bad("unknown ACL tag")),
};
entries.push(AclEntry { who, perm });
}
Acl::new(entries).map_err(|source| ArchiveError::Acl {
path: path.to_vec(),
source,
})
}
fn named_qualifier(
qualifier: &str,
extra_id: Option<&str>,
object: AclQualifier,
named: fn(u32) -> AclQualifier,
err: impl Fn() -> ArchiveError,
) -> Result<AclQualifier, ArchiveError> {
if let Some(id) = extra_id {
return Ok(named(id.parse().map_err(|_| err())?));
}
if qualifier.is_empty() {
return Ok(object);
}
match qualifier.parse() {
Ok(id) => Ok(named(id)),
Err(_) => Err(err()),
}
}
fn parse_acl_perm(text: &str) -> Option<u16> {
let mut perm = 0u16;
for c in text.chars() {
match c {
'r' => perm |= READ,
'w' => perm |= WRITE,
'x' => perm |= EXEC,
'-' => {}
_ => return None,
}
}
Some(perm)
}
fn normalize(raw: &[u8]) -> Option<Vec<u8>> {
let mut p = raw;
while let Some(rest) = p.strip_prefix(b"./") {
p = rest;
}
while let Some(rest) = p.strip_prefix(b"/") {
p = rest;
}
while p.last() == Some(&b'/') {
p = &p[..p.len() - 1];
}
if p.is_empty() || p == b"." {
return None;
}
let mut out = Vec::with_capacity(p.len() + 1);
out.push(b'/');
out.extend_from_slice(p);
Some(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn normalize_strips_and_anchors() {
assert_eq!(normalize(b"./etc/hostname").unwrap(), b"/etc/hostname");
assert_eq!(normalize(b"bin/sh").unwrap(), b"/bin/sh");
assert_eq!(normalize(b"var/log/").unwrap(), b"/var/log");
assert_eq!(normalize(b"."), None);
assert_eq!(normalize(b"./"), None);
assert_eq!(normalize(b"/"), None);
}
#[test]
fn pax_time_parses_seconds_and_fraction() {
let t = parse_pax_time(b"1700000000.5", b"/x").unwrap().unwrap();
assert_eq!(t.secs, 1_700_000_000);
assert_eq!(t.nanos, 500_000_000);
let t = parse_pax_time(b"42", b"/x").unwrap().unwrap();
assert_eq!(t, Timestamp::from_secs(42));
}
#[test]
fn acl_text_parses_abbreviated_and_full() {
let acl = parse_acl_text(b"u::rwx,u:1000:rw-,g::r-x,m::rwx,o::r--", b"/x").unwrap();
let entries = acl.entries();
assert_eq!(entries[0].who, AclQualifier::UserObj);
assert_eq!(entries[0].perm, READ | WRITE | EXEC);
assert!(entries.iter().any(|e| e.who == AclQualifier::User(1000)));
let full = parse_acl_text(b"user::rwx,group::r-x,other::r--", b"/x").unwrap();
assert_eq!(full.entries().len(), 3);
}
#[test]
fn acl_perm_rejects_junk() {
assert_eq!(parse_acl_perm("rwx"), Some(READ | WRITE | EXEC));
assert_eq!(parse_acl_perm("r--"), Some(READ));
assert_eq!(parse_acl_perm("rwq"), None);
}
#[test]
fn pax_time_handles_negative_fractions() {
let t = parse_pax_time(b"-5.25", b"/x").unwrap().unwrap();
assert_eq!((t.secs, t.nanos), (-6, 750_000_000));
let t = parse_pax_time(b"-0.5", b"/x").unwrap().unwrap();
assert_eq!((t.secs, t.nanos), (-1, 500_000_000));
let t = parse_pax_time(b"-1", b"/x").unwrap().unwrap();
assert_eq!((t.secs, t.nanos), (-1, 0));
}
#[test]
fn pax_time_refuses_the_unfloorable_minimum() {
let err = parse_pax_time(b"-9223372036854775808.5", b"/x").unwrap_err();
assert!(matches!(err, ArchiveError::Bad { reason, .. } if reason.contains("seconds")));
let t = parse_pax_time(b"-9223372036854775808", b"/x")
.unwrap()
.unwrap();
assert_eq!((t.secs, t.nanos), (i64::MIN, 0));
}
#[test]
fn acl_text_resolves_named_and_four_field_qualifiers() {
let acl = parse_acl_text(b"u::rwx,u:lisa:rw-:502,g::r-x,m::rwx,o::r--", b"/x").unwrap();
assert!(
acl.entries()
.iter()
.any(|e| e.who == AclQualifier::User(502))
);
let acl = parse_acl_text(b"u::rwx,u::rw-:502,g::r-x,m::rwx,o::r--", b"/x").unwrap();
assert!(
acl.entries()
.iter()
.any(|e| e.who == AclQualifier::User(502))
);
}
#[test]
fn acl_text_rejects_a_missing_permissions_field_and_unresolved_name() {
assert!(parse_acl_text(b"u::rwx,u:1000,g::r-x,m::rwx,o::r--", b"/x").is_err());
assert!(parse_acl_text(b"u::rwx,mask,g::r-x,o::r--", b"/x").is_err());
assert!(parse_acl_text(b"u::rwx,u:lisa:rw-,g::r-x,m::rwx,o::r--", b"/x").is_err());
}
}