use alloc::borrow::Cow;
use alloc::vec::Vec;
use core::mem;
use crate::error::{Error, Result};
use crate::format::{
ArchiveFormat, Detection, Entry, EntryDataSink, EntryReader, EntrySink, EntrySource,
EntryWriter, SliceData, SourceEvent,
};
use crate::io::Sink;
use crate::meta::{EntryKind, EntryMeta, Timestamp};
const BLOCK: usize = 512;
const F_NAME: (usize, usize) = (0, 100);
const F_MODE: (usize, usize) = (100, 108);
const F_UID: (usize, usize) = (108, 116);
const F_GID: (usize, usize) = (116, 124);
const F_SIZE: (usize, usize) = (124, 136);
const F_MTIME: (usize, usize) = (136, 148);
const F_CHKSUM: (usize, usize) = (148, 156);
const O_TYPEFLAG: usize = 156;
const F_LINKNAME: (usize, usize) = (157, 257);
const F_MAGIC: (usize, usize) = (257, 263);
const F_PREFIX: (usize, usize) = (345, 500);
#[derive(Debug, Clone, Copy, Default)]
pub struct Tar;
impl ArchiveFormat for Tar {
const NAME: &'static str = "tar";
fn sniff(prefix: &[u8]) -> Detection {
if prefix.len() < F_MAGIC.1 {
return Detection::NeedMore;
}
if prefix[F_MAGIC.0..F_MAGIC.0 + 5] == *b"ustar" {
Detection::Match
} else {
Detection::NoMatch
}
}
}
#[derive(Debug, Default, Clone)]
struct Overrides<'a> {
path: Option<Cow<'a, [u8]>>,
linkpath: Option<Cow<'a, [u8]>>,
size: Option<u64>,
mtime: Option<Timestamp>,
uid: Option<u64>,
gid: Option<u64>,
}
type OwnedOverrides = Overrides<'static>;
#[derive(Debug)]
pub struct TarReader<'a> {
data: &'a [u8],
pos: usize,
payload: SliceData<'a>,
pending: Overrides<'a>,
global: Overrides<'a>,
ended: bool,
}
impl<'a> TarReader<'a> {
#[must_use]
pub fn new(data: &'a [u8]) -> Self {
Self {
data,
pos: 0,
payload: SliceData::default(),
pending: Overrides::default(),
global: Overrides::default(),
ended: false,
}
}
fn slice(data: &'a [u8], start: usize, len: usize) -> Result<&'a [u8]> {
let end = start
.checked_add(len)
.ok_or(Error::Malformed("offset overflow"))?;
data.get(start..end)
.ok_or(Error::Malformed("truncated data"))
}
fn build_meta(&mut self, hdr: &'a [u8], typeflag: u8) -> Result<EntryMeta<'a>> {
let kind = kind_from_typeflag(typeflag)?;
let name = cstr(field(hdr, F_NAME));
let prefix = cstr(field(hdr, F_PREFIX));
let is_ustar = field(hdr, F_MAGIC).starts_with(b"ustar");
let path =
take_first(&mut self.pending.path, self.global.path.as_ref()).unwrap_or_else(|| {
if is_ustar && !prefix.is_empty() {
join_prefix_name(prefix, name)
} else {
Cow::Borrowed(name)
}
});
let link_target = match kind {
EntryKind::Symlink | EntryKind::Hardlink => Some(
take_first(&mut self.pending.linkpath, self.global.linkpath.as_ref())
.unwrap_or_else(|| Cow::Borrowed(cstr(field(hdr, F_LINKNAME)))),
),
_ => None,
};
let size = self
.pending
.size
.or(self.global.size)
.map_or_else(|| parse_numeric(field(hdr, F_SIZE)), Ok)?;
let mtime = self.pending.mtime.or(self.global.mtime).or_else(|| {
parse_numeric(field(hdr, F_MTIME))
.ok()
.map(|secs| Timestamp {
secs: i64::try_from(secs).unwrap_or(i64::MAX),
nanos: 0,
})
});
let uid = self
.pending
.uid
.or(self.global.uid)
.map_or_else(|| parse_numeric(field(hdr, F_UID)), Ok)?;
let gid = self
.pending
.gid
.or(self.global.gid)
.map_or_else(|| parse_numeric(field(hdr, F_GID)), Ok)?;
let mode = u32::try_from(parse_numeric(field(hdr, F_MODE))? & 0o7777).unwrap_or(0);
Ok(EntryMeta {
kind,
path,
mode,
uid,
gid,
mtime,
size,
link_target,
pax: crate::meta::PaxMap::new(),
})
}
}
impl<'a> EntryReader for TarReader<'a> {
type Data = SliceData<'a>;
fn next_entry(&mut self) -> Result<Option<Entry<'_, SliceData<'a>>>> {
if self.ended {
return Ok(None);
}
let data = self.data;
loop {
if self.pos + BLOCK > data.len() {
self.ended = true;
return Ok(None);
}
let hdr = &data[self.pos..self.pos + BLOCK];
if hdr.iter().all(|&b| b == 0) {
self.ended = true;
return Ok(None);
}
verify_checksum(hdr)?;
let typeflag = hdr[O_TYPEFLAG];
let raw_size = parse_numeric(field(hdr, F_SIZE))?;
let data_start = self.pos + BLOCK;
let next_pos = data_start
.checked_add(round_up(raw_size)?)
.ok_or(Error::Malformed("size overflow"))?;
match typeflag {
b'x' | b'X' | b'g' => {
let records = Self::slice(data, data_start, usize_of(raw_size)?)?;
let target = if typeflag == b'g' {
&mut self.global
} else {
&mut self.pending
};
parse_pax(records, target)?;
self.pos = next_pos;
},
b'L' => {
let raw = Self::slice(data, data_start, usize_of(raw_size)?)?;
self.pending.path = Some(Cow::Borrowed(cstr(raw)));
self.pos = next_pos;
},
b'K' => {
let raw = Self::slice(data, data_start, usize_of(raw_size)?)?;
self.pending.linkpath = Some(Cow::Borrowed(cstr(raw)));
self.pos = next_pos;
},
_ => {
let meta = self.build_meta(hdr, typeflag)?;
let len = usize_of(meta.size)?;
let _ = Self::slice(data, data_start, len)?;
self.payload = SliceData::new(data, data_start, len);
self.pos = data_start
.checked_add(round_up(meta.size)?)
.ok_or(Error::Malformed("size overflow"))?;
self.pending = Overrides::default();
return Ok(Some(Entry::new(meta, &mut self.payload)));
},
}
}
}
}
#[derive(Debug, Clone, Copy)]
enum MetaKind {
PaxNext,
PaxGlobal,
LongName,
LongLink,
}
#[derive(Debug, Clone, Copy)]
enum State {
Header,
Payload { remaining: u64, pad: usize },
Meta {
kind: MetaKind,
data: usize,
pad: usize,
},
Done,
}
enum Poll {
Continue,
NeedInput,
Done,
EndEntry,
Entry,
Data,
}
#[derive(Debug)]
pub struct TarSource {
buf: Vec<u8>,
cursor: usize,
state: State,
finished: bool,
pending: OwnedOverrides,
global: OwnedOverrides,
record: Vec<u8>,
stage_pending: OwnedOverrides,
stage_size: u64,
stage_len: usize,
}
impl Default for TarSource {
fn default() -> Self {
Self::new()
}
}
impl TarSource {
#[must_use]
pub fn new() -> Self {
Self {
buf: Vec::new(),
cursor: 0,
state: State::Header,
finished: false,
pending: Overrides::default(),
global: Overrides::default(),
record: Vec::new(),
stage_pending: Overrides::default(),
stage_size: 0,
stage_len: 0,
}
}
fn available(&self) -> usize {
self.buf.len() - self.cursor
}
#[must_use]
pub fn buffered_len(&self) -> usize {
self.buf.len()
}
fn compact(&mut self) {
if self.cursor > 0 {
self.buf.drain(..self.cursor);
self.cursor = 0;
}
}
fn apply_record(&mut self, kind: MetaKind) -> Result<()> {
match kind {
MetaKind::LongName => {
self.pending.path = Some(Cow::Owned(cstr(&self.record).to_vec()));
},
MetaKind::LongLink => {
self.pending.linkpath = Some(Cow::Owned(cstr(&self.record).to_vec()));
},
MetaKind::PaxNext => {
let mut parsed = Overrides::default();
parse_pax(&self.record, &mut parsed)?;
merge_owned(&mut self.pending, parsed);
},
MetaKind::PaxGlobal => {
let mut parsed = Overrides::default();
parse_pax(&self.record, &mut parsed)?;
merge_owned(&mut self.global, parsed);
},
}
Ok(())
}
fn starved(&self, what: &'static str) -> Result<Poll> {
if self.finished {
Err(Error::Malformed(what))
} else {
Ok(Poll::NeedInput)
}
}
fn poll_header(&mut self) -> Result<Poll> {
if self.available() < BLOCK {
if self.finished {
self.state = State::Done;
return Ok(Poll::Done);
}
return Ok(Poll::NeedInput);
}
let hdr = &self.buf[self.cursor..self.cursor + BLOCK];
if hdr.iter().all(|&b| b == 0) {
self.state = State::Done;
return Ok(Poll::Done);
}
verify_checksum(hdr)?;
let typeflag = hdr[O_TYPEFLAG];
let raw_size = parse_numeric(field(hdr, F_SIZE))?;
match typeflag {
b'x' | b'X' | b'g' | b'L' | b'K' => {
let data = usize_of(raw_size)?;
let pad = round_up(raw_size)? - data;
let kind = match typeflag {
b'g' => MetaKind::PaxGlobal,
b'L' => MetaKind::LongName,
b'K' => MetaKind::LongLink,
_ => MetaKind::PaxNext,
};
self.cursor += BLOCK;
self.record.clear();
self.state = State::Meta { kind, data, pad };
Ok(Poll::Continue)
},
_ => {
let pending = mem::take(&mut self.pending);
let hdr_start = self.cursor;
let size = {
let hdr = &self.buf[hdr_start..hdr_start + BLOCK];
pending
.size
.or(self.global.size)
.map_or_else(|| parse_numeric(field(hdr, F_SIZE)), Ok)?
};
let pad = round_up(size)? - usize_of(size)?;
self.cursor = hdr_start + BLOCK;
self.state = State::Payload {
remaining: size,
pad,
};
self.stage_pending = pending;
self.stage_size = size;
Ok(Poll::Entry)
},
}
}
fn poll_meta(&mut self, kind: MetaKind, data: usize, pad: usize) -> Result<Poll> {
if data > 0 {
let avail = self.available();
if avail == 0 {
return self.starved("tar: truncated extended header");
}
let n = data.min(avail);
let from = self.cursor;
self.record.extend_from_slice(&self.buf[from..from + n]);
self.cursor += n;
self.state = State::Meta {
kind,
data: data - n,
pad,
};
return Ok(Poll::Continue);
}
if pad > 0 {
let avail = self.available();
if avail == 0 {
return self.starved("tar: truncated extended header");
}
let n = pad.min(avail);
self.cursor += n;
self.state = State::Meta {
kind,
data,
pad: pad - n,
};
return Ok(Poll::Continue);
}
self.apply_record(kind)?;
self.record = Vec::new();
self.state = State::Header;
Ok(Poll::Continue)
}
fn poll_payload(&mut self, remaining: u64, pad: usize) -> Result<Poll> {
if remaining > 0 {
let avail = self.available();
if avail == 0 {
return self.starved("tar: truncated payload");
}
let want = usize_of(remaining)?.min(avail);
self.cursor += want;
self.state = State::Payload {
remaining: remaining - want as u64,
pad,
};
self.stage_len = want;
return Ok(Poll::Data);
}
if pad > 0 {
let avail = self.available();
if avail == 0 {
return self.starved("tar: truncated payload padding");
}
let n = pad.min(avail);
self.cursor += n;
self.state = State::Payload {
remaining,
pad: pad - n,
};
return Ok(Poll::Continue);
}
self.state = State::Header;
Ok(Poll::EndEntry)
}
}
impl EntrySource for TarSource {
fn feed(&mut self, input: &[u8]) -> Result<usize> {
self.buf.extend_from_slice(input);
Ok(input.len())
}
fn finish_input(&mut self) {
self.finished = true;
}
fn pull(&mut self) -> Result<SourceEvent<'_>> {
self.compact();
loop {
let poll = match self.state {
State::Done => return Ok(SourceEvent::Done),
State::Header => self.poll_header()?,
State::Meta { kind, data, pad } => self.poll_meta(kind, data, pad)?,
State::Payload { remaining, pad } => self.poll_payload(remaining, pad)?,
};
match poll {
Poll::Continue => {},
Poll::NeedInput => return Ok(SourceEvent::NeedInput),
Poll::Done => return Ok(SourceEvent::Done),
Poll::EndEntry => return Ok(SourceEvent::EndEntry),
Poll::Entry => {
let start = self.cursor - BLOCK;
let hdr = &self.buf[start..start + BLOCK];
let meta =
build_source_meta(hdr, &self.stage_pending, &self.global, self.stage_size)?;
return Ok(SourceEvent::Entry(meta));
},
Poll::Data => {
let from = self.cursor - self.stage_len;
return Ok(SourceEvent::Data(&self.buf[from..self.cursor]));
},
}
}
}
}
fn build_source_meta<'s>(
hdr: &'s [u8],
pending: &OwnedOverrides,
global: &OwnedOverrides,
size: u64,
) -> Result<EntryMeta<'s>> {
let kind = kind_from_typeflag(hdr[O_TYPEFLAG])?;
let name = cstr(field(hdr, F_NAME));
let prefix = cstr(field(hdr, F_PREFIX));
let is_ustar = field(hdr, F_MAGIC).starts_with(b"ustar");
let path = match pending.path.as_ref().or(global.path.as_ref()) {
Some(p) => Cow::Owned(p.clone().into_owned()),
None => {
if is_ustar && !prefix.is_empty() {
join_prefix_name(prefix, name)
} else {
Cow::Borrowed(name)
}
},
};
let link_target = match kind {
EntryKind::Symlink | EntryKind::Hardlink => Some(
match pending.linkpath.as_ref().or(global.linkpath.as_ref()) {
Some(l) => Cow::Owned(l.clone().into_owned()),
None => Cow::Borrowed(cstr(field(hdr, F_LINKNAME))),
},
),
_ => None,
};
let mtime = pending.mtime.or(global.mtime).or_else(|| {
parse_numeric(field(hdr, F_MTIME))
.ok()
.map(|secs| Timestamp {
secs: i64::try_from(secs).unwrap_or(i64::MAX),
nanos: 0,
})
});
let uid = pending
.uid
.or(global.uid)
.map_or_else(|| parse_numeric(field(hdr, F_UID)), Ok)?;
let gid = pending
.gid
.or(global.gid)
.map_or_else(|| parse_numeric(field(hdr, F_GID)), Ok)?;
let mode = u32::try_from(parse_numeric(field(hdr, F_MODE))? & 0o7777).unwrap_or(0);
Ok(EntryMeta {
kind,
path,
mode,
uid,
gid,
mtime,
size,
link_target,
pax: crate::meta::PaxMap::new(),
})
}
fn merge_owned(dst: &mut OwnedOverrides, src: Overrides<'_>) {
if let Some(v) = src.path {
dst.path = Some(Cow::Owned(v.into_owned()));
}
if let Some(v) = src.linkpath {
dst.linkpath = Some(Cow::Owned(v.into_owned()));
}
if let Some(v) = src.size {
dst.size = Some(v);
}
if let Some(v) = src.mtime {
dst.mtime = Some(v);
}
if let Some(v) = src.uid {
dst.uid = Some(v);
}
if let Some(v) = src.gid {
dst.gid = Some(v);
}
}
#[derive(Debug)]
pub struct TarWriter<W: Sink> {
sink: W,
remaining: u64,
pad: usize,
open: bool,
}
impl<W: Sink> TarWriter<W> {
pub fn new(sink: W) -> Self {
Self {
sink,
remaining: 0,
pad: 0,
open: false,
}
}
pub fn into_inner(self) -> W {
self.sink
}
}
impl<W: Sink> EntryWriter for TarWriter<W> {
type Sink = Self;
fn start_entry(&mut self, meta: &EntryMeta<'_>) -> Result<EntrySink<'_, Self>> {
if self.open {
return Err(Error::InvalidState("tar: previous entry not closed"));
}
write_header(&mut self.sink, meta)?;
self.remaining = meta.size;
self.pad = round_up(meta.size)? - usize_of(meta.size)?;
self.open = true;
Ok(EntrySink::new(self))
}
fn finish(&mut self) -> Result<()> {
if self.open {
return Err(Error::InvalidState("tar: entry open at finish"));
}
write_zeros(&mut self.sink, 2 * BLOCK)
}
}
impl<W: Sink> EntryDataSink for TarWriter<W> {
fn write_chunk(&mut self, data: &[u8]) -> Result<()> {
if data.len() as u64 > self.remaining {
return Err(Error::InvalidState("tar: payload exceeds declared size"));
}
self.sink.write_all(data)?;
self.remaining -= data.len() as u64;
Ok(())
}
fn close(&mut self) -> Result<()> {
if self.remaining != 0 {
return Err(Error::InvalidState(
"tar: payload shorter than declared size",
));
}
write_zeros(&mut self.sink, self.pad)?;
self.pad = 0;
self.open = false;
Ok(())
}
}
fn field(hdr: &[u8], (start, end): (usize, usize)) -> &[u8] {
&hdr[start..end]
}
fn cstr(field: &[u8]) -> &[u8] {
let end = field.iter().position(|&b| b == 0).unwrap_or(field.len());
&field[..end]
}
fn join_prefix_name<'a>(prefix: &'a [u8], name: &'a [u8]) -> Cow<'a, [u8]> {
let mut joined = Vec::with_capacity(prefix.len() + 1 + name.len());
joined.extend_from_slice(prefix);
joined.push(b'/');
joined.extend_from_slice(name);
Cow::Owned(joined)
}
fn take_first<'a>(
pending: &mut Option<Cow<'a, [u8]>>,
global: Option<&Cow<'a, [u8]>>,
) -> Option<Cow<'a, [u8]>> {
pending.take().or_else(|| global.cloned())
}
fn kind_from_typeflag(tf: u8) -> Result<EntryKind> {
Ok(match tf {
b'5' => EntryKind::Dir,
b'1' => EntryKind::Hardlink,
b'2' => EntryKind::Symlink,
b'3' => EntryKind::Char,
b'4' => EntryKind::Block,
b'6' => EntryKind::Fifo,
b'S' => return Err(Error::Unsupported("GNU sparse tar entry")),
_ => EntryKind::File,
})
}
fn parse_numeric(field: &[u8]) -> Result<u64> {
match field.first() {
None => Ok(0),
Some(&first) if first & 0x80 != 0 => {
let mut val: u64 = u64::from(first & 0x7f);
for &b in &field[1..] {
val = val
.checked_mul(256)
.and_then(|v| v.checked_add(u64::from(b)))
.ok_or(Error::Malformed("base-256 numeric overflow"))?;
}
Ok(val)
},
_ => {
let mut val: u64 = 0;
let mut seen = false;
for &b in field {
match b {
b' ' | 0 => {
if seen {
break;
}
},
b'0'..=b'7' => {
val = val
.checked_mul(8)
.and_then(|v| v.checked_add(u64::from(b - b'0')))
.ok_or(Error::Malformed("octal numeric overflow"))?;
seen = true;
},
_ => return Err(Error::Malformed("invalid octal digit")),
}
}
Ok(val)
},
}
}
fn verify_checksum(hdr: &[u8]) -> Result<()> {
let stored = parse_numeric(field(hdr, F_CHKSUM))?;
let mut unsigned: u64 = 0;
let mut signed: i64 = 0;
for (i, &b) in hdr.iter().enumerate() {
let byte = if (F_CHKSUM.0..F_CHKSUM.1).contains(&i) {
b' '
} else {
b
};
unsigned += u64::from(byte);
signed += i64::from(i8::from_ne_bytes([byte]));
}
if stored == unsigned || u64::try_from(signed).is_ok_and(|s| s == stored) {
Ok(())
} else {
Err(Error::Malformed("header checksum mismatch"))
}
}
fn usize_of(v: u64) -> Result<usize> {
usize::try_from(v).map_err(|_| Error::LimitExceeded("size exceeds usize"))
}
fn round_up(size: u64) -> Result<usize> {
let size = usize_of(size)?;
let blocks = size
.checked_add(BLOCK - 1)
.ok_or(Error::Malformed("size overflow"))?
/ BLOCK;
blocks
.checked_mul(BLOCK)
.ok_or(Error::Malformed("size overflow"))
}
fn parse_pax<'a>(mut records: &'a [u8], into: &mut Overrides<'a>) -> Result<()> {
while !records.is_empty() {
let sp = records
.iter()
.position(|&b| b == b' ')
.ok_or(Error::Malformed("pax: missing length separator"))?;
let len = ascii_decimal(&records[..sp])?;
if len < sp + 2 || len > records.len() {
return Err(Error::Malformed("pax: bad record length"));
}
let record = &records[..len];
let body = &record[sp + 1..record.len() - 1];
let eq = body
.iter()
.position(|&b| b == b'=')
.ok_or(Error::Malformed("pax: missing '='"))?;
let key = &body[..eq];
let value = &body[eq + 1..];
apply_pax(key, value, into)?;
records = &records[len..];
}
Ok(())
}
fn apply_pax<'a>(key: &[u8], value: &'a [u8], into: &mut Overrides<'a>) -> Result<()> {
match key {
b"path" => into.path = Some(Cow::Borrowed(value)),
b"linkpath" => into.linkpath = Some(Cow::Borrowed(value)),
b"size" => into.size = Some(ascii_decimal(value)? as u64),
b"uid" => into.uid = Some(ascii_decimal(value)? as u64),
b"gid" => into.gid = Some(ascii_decimal(value)? as u64),
b"mtime" => into.mtime = Some(parse_pax_time(value)?),
_ => {}, }
Ok(())
}
fn ascii_decimal(bytes: &[u8]) -> Result<usize> {
if bytes.is_empty() {
return Err(Error::Malformed("empty decimal"));
}
let mut val: usize = 0;
for &b in bytes {
if !b.is_ascii_digit() {
return Err(Error::Malformed("invalid decimal digit"));
}
val = val
.checked_mul(10)
.and_then(|v| v.checked_add(usize::from(b - b'0')))
.ok_or(Error::LimitExceeded("decimal overflow"))?;
}
Ok(val)
}
fn parse_pax_time(value: &[u8]) -> Result<Timestamp> {
let (secs_part, frac_part) = match value.iter().position(|&b| b == b'.') {
Some(dot) => (&value[..dot], &value[dot + 1..]),
None => (value, &b""[..]),
};
let secs = i64::try_from(ascii_decimal(secs_part)?).unwrap_or(i64::MAX);
let mut nanos: u32 = 0;
for i in 0..9 {
nanos *= 10;
if let Some(&b) = frac_part.get(i) {
if !b.is_ascii_digit() {
return Err(Error::Malformed("invalid fractional second"));
}
nanos += u32::from(b - b'0');
}
}
Ok(Timestamp { secs, nanos })
}
fn write_header<W: Sink>(sink: &mut W, meta: &EntryMeta<'_>) -> Result<()> {
let typeflag = typeflag_for(meta.kind)?;
if meta.path.len() > 100 {
write_gnu_ext(sink, b'L', &meta.path)?;
}
if let Some(link) = &meta.link_target {
if link.len() > 100 {
write_gnu_ext(sink, b'K', link)?;
}
}
let mut h = [0u8; BLOCK];
let name = &meta.path[..meta.path.len().min(100)];
h[..name.len()].copy_from_slice(name);
put_octal(&mut h[F_MODE.0..F_MODE.1], u64::from(meta.mode & 0o7777))?;
put_octal(&mut h[F_UID.0..F_UID.1], meta.uid)?;
put_octal(&mut h[F_GID.0..F_GID.1], meta.gid)?;
put_octal(&mut h[F_SIZE.0..F_SIZE.1], meta.size)?;
let mtime = meta
.mtime
.map_or(0, |t| u64::try_from(t.secs.max(0)).unwrap_or(0));
put_octal(&mut h[F_MTIME.0..F_MTIME.1], mtime)?;
h[O_TYPEFLAG] = typeflag;
if let Some(link) = &meta.link_target {
let l = &link[..link.len().min(100)];
h[F_LINKNAME.0..F_LINKNAME.0 + l.len()].copy_from_slice(l);
}
h[F_MAGIC.0..F_MAGIC.0 + 5].copy_from_slice(b"ustar");
h[263] = b'0';
h[264] = b'0';
write_checksum(&mut h)?;
sink.write_all(&h)
}
fn write_gnu_ext<W: Sink>(sink: &mut W, flag: u8, data: &[u8]) -> Result<()> {
let mut h = [0u8; BLOCK];
let magic_name = b"././@LongLink";
h[..magic_name.len()].copy_from_slice(magic_name);
put_octal(&mut h[F_MODE.0..F_MODE.1], 0)?;
put_octal(&mut h[F_UID.0..F_UID.1], 0)?;
put_octal(&mut h[F_GID.0..F_GID.1], 0)?;
let size = data.len() as u64 + 1; put_octal(&mut h[F_SIZE.0..F_SIZE.1], size)?;
put_octal(&mut h[F_MTIME.0..F_MTIME.1], 0)?;
h[O_TYPEFLAG] = flag;
h[F_MAGIC.0..F_MAGIC.0 + 5].copy_from_slice(b"ustar");
h[263] = b'0';
h[264] = b'0';
write_checksum(&mut h)?;
sink.write_all(&h)?;
sink.write_all(data)?;
sink.write_all(&[0u8])?; let total = data.len() + 1;
write_zeros(sink, round_up(size)? - total)
}
fn write_checksum(h: &mut [u8; BLOCK]) -> Result<()> {
for b in &mut h[F_CHKSUM.0..F_CHKSUM.1] {
*b = b' ';
}
let sum: u64 = h.iter().map(|&b| u64::from(b)).sum();
put_octal(&mut h[F_CHKSUM.0..F_CHKSUM.1 - 1], sum)?;
h[F_CHKSUM.1 - 1] = b' ';
Ok(())
}
fn put_octal(field: &mut [u8], val: u64) -> Result<()> {
let n = field.len();
if fits_octal(val, n - 1) {
field[n - 1] = 0;
let mut v = val;
for slot in field[..n - 1].iter_mut().rev() {
*slot = b'0' + u8::try_from(v & 7).unwrap_or(0);
v >>= 3;
}
Ok(())
} else {
put_base256(field, val)
}
}
fn fits_octal(val: u64, digits: usize) -> bool {
digits >= 22 || val < 1u64 << (3 * digits)
}
fn put_base256(field: &mut [u8], val: u64) -> Result<()> {
let n = field.len();
let capacity = n - 1; let bytes = val.to_be_bytes();
if capacity < 8 && bytes[..8 - capacity].iter().any(|&b| b != 0) {
return Err(Error::Unsupported("tar: value too large for numeric field"));
}
field.fill(0);
field[0] = 0x80;
let take = capacity.min(8);
field[n - take..].copy_from_slice(&bytes[8 - take..]);
Ok(())
}
fn typeflag_for(kind: EntryKind) -> Result<u8> {
Ok(match kind {
EntryKind::File => b'0',
EntryKind::Dir => b'5',
EntryKind::Symlink => b'2',
EntryKind::Hardlink => b'1',
EntryKind::Char => b'3',
EntryKind::Block => b'4',
EntryKind::Fifo => b'6',
_ => return Err(Error::Unsupported("tar: unsupported entry kind for write")),
})
}
fn write_zeros<W: Sink>(sink: &mut W, count: usize) -> Result<()> {
const ZEROS: [u8; BLOCK] = [0; BLOCK];
let mut left = count;
while left > 0 {
let n = left.min(BLOCK);
sink.write_all(&ZEROS[..n])?;
left -= n;
}
Ok(())
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod tests {
use super::*;
#[test]
fn octal_and_base256() {
assert_eq!(parse_numeric(b"0000644\0").unwrap(), 0o644);
assert_eq!(parse_numeric(b" ").unwrap(), 0);
assert_eq!(parse_numeric(b"00000000144\0").unwrap(), 0o144);
assert_eq!(parse_numeric(&[0x80, 0, 0, 1, 0]).unwrap(), 256);
}
#[test]
fn round_up_blocks() {
assert_eq!(round_up(0).unwrap(), 0);
assert_eq!(round_up(1).unwrap(), 512);
assert_eq!(round_up(512).unwrap(), 512);
assert_eq!(round_up(513).unwrap(), 1024);
}
#[test]
fn pax_time_fractional() {
let t = parse_pax_time(b"1700000000.5").unwrap();
assert_eq!(t.secs, 1_700_000_000);
assert_eq!(t.nanos, 500_000_000);
}
#[test]
fn base256_overflow_is_rejected() {
let field = [0x80, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
assert!(parse_numeric(&field).is_err());
}
#[test]
fn put_octal_falls_back_to_base256() {
let mut size = [0u8; 12];
put_octal(&mut size, 10_737_418_240).unwrap();
assert_eq!(size[0] & 0x80, 0x80, "base-256 marker set");
assert_eq!(parse_numeric(&size).unwrap(), 10_737_418_240);
let mut mode = [0u8; 8];
put_octal(&mut mode, 0o644).unwrap();
assert_eq!(mode[0], b'0');
assert_eq!(parse_numeric(&mode).unwrap(), 0o644);
let mut uid = [0u8; 8];
put_octal(&mut uid, 3_000_000).unwrap();
assert_eq!(parse_numeric(&uid).unwrap(), 3_000_000);
}
#[test]
fn pax_malformed_record_does_not_panic() {
let mut o = Overrides::default();
assert!(parse_pax(b"2 ", &mut o).is_err());
assert!(parse_pax(b"1 ", &mut o).is_err());
assert!(parse_pax(b"11 path=ab\n", &mut o).is_ok());
assert_eq!(o.path.as_deref(), Some(&b"ab"[..]));
}
}