#[cfg(unix)] use std::os::unix::prelude::*;
#[cfg(windows)] use std::os::windows::prelude::*;
use std::borrow::Cow;
use std::fmt;
use std::fs;
use std::io;
use std::iter::repeat;
use std::mem;
use std::path::{Path, PathBuf, Component};
use std::str;
use EntryType;
use other;
#[repr(C)]
#[allow(missing_docs)]
pub struct Header {
bytes: [u8; 512],
}
#[repr(C)]
#[allow(missing_docs)]
pub struct OldHeader {
pub name: [u8; 100],
pub mode: [u8; 8],
pub uid: [u8; 8],
pub gid: [u8; 8],
pub size: [u8; 12],
pub mtime: [u8; 12],
pub cksum: [u8; 8],
pub linkflag: [u8; 1],
pub linkname: [u8; 100],
pub pad: [u8; 255],
}
#[repr(C)]
#[allow(missing_docs)]
pub struct UstarHeader {
pub name: [u8; 100],
pub mode: [u8; 8],
pub uid: [u8; 8],
pub gid: [u8; 8],
pub size: [u8; 12],
pub mtime: [u8; 12],
pub cksum: [u8; 8],
pub typeflag: [u8; 1],
pub linkname: [u8; 100],
pub magic: [u8; 6],
pub version: [u8; 2],
pub uname: [u8; 32],
pub gname: [u8; 32],
pub dev_major: [u8; 8],
pub dev_minor: [u8; 8],
pub prefix: [u8; 155],
pub pad: [u8; 12],
}
#[repr(C)]
#[allow(missing_docs)]
pub struct GnuHeader {
pub name: [u8; 100],
pub mode: [u8; 8],
pub uid: [u8; 8],
pub gid: [u8; 8],
pub size: [u8; 12],
pub mtime: [u8; 12],
pub cksum: [u8; 8],
pub typeflag: [u8; 1],
pub linkname: [u8; 100],
pub magic: [u8; 6],
pub version: [u8; 2],
pub uname: [u8; 32],
pub gname: [u8; 32],
pub dev_major: [u8; 8],
pub dev_minor: [u8; 8],
pub atime: [u8; 12],
pub ctime: [u8; 12],
pub offset: [u8; 12],
pub longnames: [u8; 4],
pub unused: [u8; 1],
pub sparse: [GnuSparseHeader; 4],
pub isextended: [u8; 1],
pub realsize: [u8; 12],
pub pad: [u8; 17],
}
#[repr(C)]
#[allow(missing_docs)]
pub struct GnuSparseHeader {
pub offset: [u8; 12],
pub numbytes: [u8; 12],
}
#[repr(C)]
#[allow(missing_docs)]
pub struct GnuExtSparseHeader {
pub sparse: [GnuSparseHeader; 21],
pub isextended: [u8; 1],
pub padding: [u8; 7],
}
impl Header {
pub fn new_gnu() -> Header {
let mut header = Header { bytes: [0; 512] };
{
let gnu = header.cast_mut::<GnuHeader>();
gnu.magic = *b"ustar ";
gnu.version = *b" \0";
}
header
}
pub fn new_ustar() -> Header {
let mut header = Header { bytes: [0; 512] };
{
let gnu = header.cast_mut::<UstarHeader>();
gnu.magic = *b"ustar\0";
gnu.version = *b"00";
}
header
}
pub fn new_old() -> Header {
Header { bytes: [0; 512] }
}
fn cast<T>(&self) -> &T {
assert_eq!(mem::size_of_val(self), mem::size_of::<T>());
unsafe { &*(self as *const Header as *const T) }
}
fn cast_mut<T>(&mut self) -> &mut T {
assert_eq!(mem::size_of_val(self), mem::size_of::<T>());
unsafe { &mut *(self as *mut Header as *mut T) }
}
fn is_ustar(&self) -> bool {
let ustar = self.cast::<UstarHeader>();
ustar.magic[..] == b"ustar\0"[..] && ustar.version[..] == b"00"[..]
}
fn is_gnu(&self) -> bool {
let ustar = self.cast::<UstarHeader>();
ustar.magic[..] == b"ustar "[..] && ustar.version[..] == b" \0"[..]
}
pub fn as_old(&self) -> &OldHeader {
self.cast()
}
pub fn as_old_mut(&mut self) -> &mut OldHeader {
self.cast_mut()
}
pub fn as_ustar(&self) -> Option<&UstarHeader> {
if self.is_ustar() {Some(self.cast())} else {None}
}
pub fn as_ustar_mut(&mut self) -> Option<&mut UstarHeader> {
if self.is_ustar() {Some(self.cast_mut())} else {None}
}
pub fn as_gnu(&self) -> Option<&GnuHeader> {
if self.is_gnu() {Some(self.cast())} else {None}
}
pub fn as_gnu_mut(&mut self) -> Option<&mut GnuHeader> {
if self.is_gnu() {Some(self.cast_mut())} else {None}
}
pub fn as_bytes(&self) -> &[u8; 512] {
&self.bytes
}
pub fn as_mut_bytes(&mut self) -> &mut [u8; 512] {
&mut self.bytes
}
pub fn set_metadata(&mut self, meta: &fs::Metadata) {
self.fill_from(meta);
self.set_size(if meta.is_dir() { 0 } else { meta.len() });
if let Some(ustar) = self.as_ustar_mut() {
ustar.set_device_major(0);
ustar.set_device_minor(0);
}
if let Some(gnu) = self.as_gnu_mut() {
gnu.set_device_major(0);
gnu.set_device_minor(0);
}
}
pub fn entry_size(&self) -> io::Result<u64> {
octal_from(&self.as_old().size)
}
pub fn size(&self) -> io::Result<u64> {
if self.entry_type().is_gnu_sparse() {
self.as_gnu().ok_or_else(|| {
other("sparse header was not a gnu header")
}).and_then(|h| h.real_size())
} else {
self.entry_size()
}
}
pub fn set_size(&mut self, size: u64) {
octal_into(&mut self.as_old_mut().size, size)
}
pub fn path(&self) -> io::Result<Cow<Path>> {
bytes2path(self.path_bytes())
}
pub fn path_bytes(&self) -> Cow<[u8]> {
if let Some(ustar) = self.as_ustar() {
ustar.path_bytes()
} else {
let name = truncate(&self.as_old().name);
Cow::Borrowed(name)
}
}
pub fn set_path<P: AsRef<Path>>(&mut self, p: P) -> io::Result<()> {
self._set_path(p.as_ref())
}
fn _set_path(&mut self, path: &Path) -> io::Result<()> {
if let Some(ustar) = self.as_ustar_mut() {
return ustar.set_path(path)
}
copy_path_into(&mut self.as_old_mut().name, path, false)
}
pub fn link_name(&self) -> io::Result<Option<Cow<Path>>> {
match self.link_name_bytes() {
Some(bytes) => bytes2path(bytes).map(Some),
None => Ok(None),
}
}
pub fn link_name_bytes(&self) -> Option<Cow<[u8]>> {
let old = self.as_old();
if old.linkname[0] != 0 {
Some(Cow::Borrowed(truncate(&old.linkname)))
} else {
None
}
}
pub fn set_link_name<P: AsRef<Path>>(&mut self, p: P) -> io::Result<()> {
self._set_link_name(p.as_ref())
}
fn _set_link_name(&mut self, path: &Path) -> io::Result<()> {
copy_path_into(&mut self.as_old_mut().linkname, path, true)
}
pub fn mode(&self) -> io::Result<u32> {
octal_from(&self.as_old().mode).map(|u| u as u32)
}
pub fn set_mode(&mut self, mode: u32) {
octal_into(&mut self.as_old_mut().mode, mode);
}
pub fn uid(&self) -> io::Result<u32> {
octal_from(&self.as_old().uid).map(|u| u as u32)
}
pub fn set_uid(&mut self, uid: u32) {
octal_into(&mut self.as_old_mut().uid, uid);
}
pub fn gid(&self) -> io::Result<u32> {
octal_from(&self.as_old().gid).map(|u| u as u32)
}
pub fn set_gid(&mut self, gid: u32) {
octal_into(&mut self.as_old_mut().gid, gid);
}
pub fn mtime(&self) -> io::Result<u64> {
octal_from(&self.as_old().mtime)
}
pub fn set_mtime(&mut self, mtime: u64) {
octal_into(&mut self.as_old_mut().mtime, mtime);
}
pub fn username(&self) -> Result<Option<&str>, str::Utf8Error> {
match self.username_bytes() {
Some(bytes) => str::from_utf8(bytes).map(Some),
None => Ok(None),
}
}
pub fn username_bytes(&self) -> Option<&[u8]> {
if let Some(ustar) = self.as_ustar() {
Some(ustar.username_bytes())
} else if let Some(gnu) = self.as_gnu() {
Some(gnu.username_bytes())
} else {
None
}
}
pub fn set_username(&mut self, name: &str) -> io::Result<()> {
if let Some(ustar) = self.as_ustar_mut() {
return ustar.set_username(name)
}
if let Some(gnu) = self.as_gnu_mut() {
gnu.set_username(name)
} else {
Err(other("not a ustar or gnu archive, cannot set username"))
}
}
pub fn groupname(&self) -> Result<Option<&str>, str::Utf8Error> {
match self.groupname_bytes() {
Some(bytes) => str::from_utf8(bytes).map(Some),
None => Ok(None),
}
}
pub fn groupname_bytes(&self) -> Option<&[u8]> {
if let Some(ustar) = self.as_ustar() {
Some(ustar.groupname_bytes())
} else if let Some(gnu) = self.as_gnu() {
Some(gnu.groupname_bytes())
} else {
None
}
}
pub fn set_groupname(&mut self, name: &str) -> io::Result<()> {
if let Some(ustar) = self.as_ustar_mut() {
return ustar.set_groupname(name)
}
if let Some(gnu) = self.as_gnu_mut() {
gnu.set_groupname(name)
} else {
Err(other("not a ustar or gnu archive, cannot set groupname"))
}
}
pub fn device_major(&self) -> io::Result<Option<u32>> {
if let Some(ustar) = self.as_ustar() {
ustar.device_major().map(Some)
} else if let Some(gnu) = self.as_gnu() {
gnu.device_major().map(Some)
} else {
Ok(None)
}
}
pub fn set_device_major(&mut self, major: u32) -> io::Result<()> {
if let Some(ustar) = self.as_ustar_mut() {
return Ok(ustar.set_device_major(major))
}
if let Some(gnu) = self.as_gnu_mut() {
Ok(gnu.set_device_major(major))
} else {
Err(other("not a ustar or gnu archive, cannot set dev_major"))
}
}
pub fn device_minor(&self) -> io::Result<Option<u32>> {
if let Some(ustar) = self.as_ustar() {
ustar.device_minor().map(Some)
} else if let Some(gnu) = self.as_gnu() {
gnu.device_minor().map(Some)
} else {
Ok(None)
}
}
pub fn set_device_minor(&mut self, minor: u32) -> io::Result<()> {
if let Some(ustar) = self.as_ustar_mut() {
return Ok(ustar.set_device_minor(minor))
}
if let Some(gnu) = self.as_gnu_mut() {
Ok(gnu.set_device_minor(minor))
} else {
Err(other("not a ustar or gnu archive, cannot set dev_minor"))
}
}
pub fn entry_type(&self) -> EntryType {
EntryType::new(self.as_old().linkflag[0])
}
pub fn set_entry_type(&mut self, ty: EntryType) {
self.as_old_mut().linkflag = [ty.as_byte()];
}
pub fn cksum(&self) -> io::Result<u32> {
octal_from(&self.as_old().cksum).map(|u| u as u32)
}
pub fn set_cksum(&mut self) {
self.as_old_mut().cksum = *b" ";
let cksum = self.bytes.iter().fold(0, |a, b| a + (*b as u32));
octal_into(&mut self.as_old_mut().cksum, cksum);
}
#[cfg(unix)]
fn fill_from(&mut self, meta: &fs::Metadata) {
use libc;
self.set_mode(meta.mode() as u32);
self.set_mtime(meta.mtime() as u64);
self.set_uid(meta.uid() as u32);
self.set_gid(meta.gid() as u32);
self.set_entry_type(match meta.mode() as libc::mode_t & libc::S_IFMT {
libc::S_IFREG => EntryType::file(),
libc::S_IFLNK => EntryType::symlink(),
libc::S_IFCHR => EntryType::character_special(),
libc::S_IFBLK => EntryType::block_special(),
libc::S_IFDIR => EntryType::dir(),
libc::S_IFIFO => EntryType::fifo(),
_ => EntryType::new(b' '),
});
}
#[cfg(windows)]
fn fill_from(&mut self, meta: &fs::Metadata) {
const FILE_ATTRIBUTE_READONLY: u32 = 0x00000001;
let readonly = meta.file_attributes() & FILE_ATTRIBUTE_READONLY;
let mode = match (meta.is_dir(), readonly != 0) {
(true, false) => 0o755,
(true, true) => 0o555,
(false, false) => 0o644,
(false, true) => 0o444,
};
self.set_mode(mode);
self.set_uid(0);
self.set_gid(0);
let ft = meta.file_type();
self.set_entry_type(if ft.is_dir() {
EntryType::dir()
} else if ft.is_file() {
EntryType::file()
} else if ft.is_symlink() {
EntryType::symlink()
} else {
EntryType::new(b' ')
});
let mtime = (meta.last_write_time() / (1_000_000_000 / 100)) - 11644473600;
self.set_mtime(mtime);
}
}
impl Clone for Header {
fn clone(&self) -> Header {
Header { bytes: self.bytes }
}
}
impl UstarHeader {
pub fn path_bytes(&self) -> Cow<[u8]> {
if self.prefix[0] == 0 && !self.name.contains(&b'\\') {
Cow::Borrowed(truncate(&self.name))
} else {
let mut bytes = Vec::new();
let prefix = truncate(&self.prefix);
if prefix.len() > 0 {
bytes.extend_from_slice(prefix);
bytes.push(b'/');
}
bytes.extend_from_slice(truncate(&self.name));
Cow::Owned(bytes)
}
}
pub fn set_path<P: AsRef<Path>>(&mut self, p: P) -> io::Result<()> {
self._set_path(p.as_ref())
}
fn _set_path(&mut self, path: &Path) -> io::Result<()> {
let bytes = try!(path2bytes(path));
let (maxnamelen, maxprefixlen) = (self.name.len(), self.prefix.len());
if bytes.len() <= maxnamelen {
try!(copy_path_into(&mut self.name, path, false));
} else {
let mut prefix = path;
let mut prefixlen;
loop {
match prefix.parent() {
Some(parent) => prefix = parent,
None => return Err(other("path cannot be split to be \
inserted into archive")),
}
prefixlen = try!(path2bytes(prefix)).len();
if prefixlen <= maxprefixlen {
break
}
}
try!(copy_path_into(&mut self.prefix, prefix, false));
let path = try!(bytes2path(Cow::Borrowed(&bytes[prefixlen + 1..])));
try!(copy_path_into(&mut self.name, &path, false));
}
Ok(())
}
pub fn username_bytes(&self) -> &[u8] {
truncate(&self.uname)
}
pub fn set_username(&mut self, name: &str) -> io::Result<()> {
copy_into(&mut self.uname, name.as_bytes())
}
pub fn groupname_bytes(&self) -> &[u8] {
truncate(&self.gname)
}
pub fn set_groupname(&mut self, name: &str) -> io::Result<()> {
copy_into(&mut self.gname, name.as_bytes())
}
pub fn device_major(&self) -> io::Result<u32> {
octal_from(&self.dev_major).map(|u| u as u32)
}
pub fn set_device_major(&mut self, major: u32) {
octal_into(&mut self.dev_major, major);
}
pub fn device_minor(&self) -> io::Result<u32> {
octal_from(&self.dev_minor).map(|u| u as u32)
}
pub fn set_device_minor(&mut self, minor: u32) {
octal_into(&mut self.dev_minor, minor);
}
}
impl GnuHeader {
pub fn username_bytes(&self) -> &[u8] {
truncate(&self.uname)
}
pub fn set_username(&mut self, name: &str) -> io::Result<()> {
copy_into(&mut self.uname, name.as_bytes())
}
pub fn groupname_bytes(&self) -> &[u8] {
truncate(&self.gname)
}
pub fn set_groupname(&mut self, name: &str) -> io::Result<()> {
copy_into(&mut self.gname, name.as_bytes())
}
pub fn device_major(&self) -> io::Result<u32> {
octal_from(&self.dev_major).map(|u| u as u32)
}
pub fn set_device_major(&mut self, major: u32) {
octal_into(&mut self.dev_major, major);
}
pub fn device_minor(&self) -> io::Result<u32> {
octal_from(&self.dev_minor).map(|u| u as u32)
}
pub fn set_device_minor(&mut self, minor: u32) {
octal_into(&mut self.dev_minor, minor);
}
pub fn atime(&self) -> io::Result<u64> {
octal_from(&self.atime)
}
pub fn set_atime(&mut self, atime: u64) {
octal_into(&mut self.atime, atime);
}
pub fn ctime(&self) -> io::Result<u64> {
octal_from(&self.ctime)
}
pub fn set_ctime(&mut self, ctime: u64) {
octal_into(&mut self.ctime, ctime);
}
pub fn real_size(&self) -> io::Result<u64> {
octal_from(&self.realsize)
}
pub fn is_extended(&self) -> bool {
self.isextended[0] == 1
}
}
impl GnuSparseHeader {
pub fn is_empty(&self) -> bool {
self.offset[0] == 0 || self.numbytes[0] == 0
}
pub fn offset(&self) -> io::Result<u64> {
octal_from(&self.offset)
}
pub fn length(&self) -> io::Result<u64> {
octal_from(&self.numbytes)
}
}
impl GnuExtSparseHeader {
pub fn new() -> GnuExtSparseHeader {
unsafe { mem::zeroed() }
}
pub fn as_bytes(&self) -> &[u8; 512] {
debug_assert_eq!(mem::size_of_val(self), 512);
unsafe { mem::transmute(self) }
}
pub fn as_mut_bytes(&mut self) -> &mut [u8; 512] {
debug_assert_eq!(mem::size_of_val(self), 512);
unsafe { mem::transmute(self) }
}
pub fn sparse(&self) -> &[GnuSparseHeader; 21] {
&self.sparse
}
pub fn is_extended(&self) -> bool {
self.isextended[0] == 1
}
}
impl Default for GnuExtSparseHeader {
fn default() -> Self {
Self::new()
}
}
fn octal_from(slice: &[u8]) -> io::Result<u64> {
let num = match str::from_utf8(truncate(slice)) {
Ok(n) => n,
Err(_) => return Err(other("numeric field did not have utf-8 text")),
};
match u64::from_str_radix(num.trim(), 8) {
Ok(n) => Ok(n),
Err(_) => Err(other("numeric field was not a number"))
}
}
fn octal_into<T: fmt::Octal>(dst: &mut [u8], val: T) {
let o = format!("{:o}", val);
let value = o.bytes().rev().chain(repeat(b'0'));
for (slot, value) in dst.iter_mut().rev().skip(1).zip(value) {
*slot = value;
}
}
fn truncate(slice: &[u8]) -> &[u8] {
match slice.iter().position(|i| *i == 0) {
Some(i) => &slice[..i],
None => slice,
}
}
fn copy_into(slot: &mut [u8], bytes: &[u8]) -> io::Result<()> {
if bytes.len() > slot.len() {
Err(other("provided value is too long"))
} else if bytes.iter().any(|b| *b == 0) {
Err(other("provided value contains a nul byte"))
} else {
for (slot, val) in slot.iter_mut().zip(bytes.iter().chain(Some(&0))) {
*slot = *val;
}
Ok(())
}
}
fn copy_path_into(mut slot: &mut [u8],
path: &Path,
is_link_name: bool) -> io::Result<()> {
let mut emitted = false;
for component in path.components() {
let bytes = try!(path2bytes(Path::new(component.as_os_str())));
match (component, is_link_name) {
(Component::Prefix(..), false) |
(Component::RootDir, false) => {
return Err(other("paths in archives must be relative"))
}
(Component::ParentDir, false) => {
return Err(other("paths in archives must not have `..`"))
}
(Component::CurDir, false) => continue,
(Component::Normal(_), _) |
(_, true) => {}
};
if emitted {
try!(copy(&mut slot, &[b'/']));
}
if bytes.contains(&b'/') {
if let Component::Normal(..) = component {
return Err(other("path component in archive cannot contain `/`"))
}
}
try!(copy(&mut slot, bytes));
emitted = true;
}
if !emitted {
return Err(other("paths in archives must have at least one component"))
}
if ends_with_slash(path) {
try!(copy(&mut slot, &[b'/']));
}
return Ok(());
fn copy(slot: &mut &mut [u8], bytes: &[u8]) -> io::Result<()> {
try!(copy_into(*slot, bytes));
let tmp = mem::replace(slot, &mut []);
*slot = &mut tmp[bytes.len()..];
Ok(())
}
}
#[cfg(windows)]
fn ends_with_slash(p: &Path) -> bool {
p.as_os_str().encode_wide().last() == Some(b'/' as u16)
}
#[cfg(unix)]
fn ends_with_slash(p: &Path) -> bool {
p.as_os_str().as_bytes().ends_with(&[b'/'])
}
#[cfg(windows)]
pub fn path2bytes(p: &Path) -> io::Result<&[u8]> {
p.as_os_str().to_str().map(|s| s.as_bytes()).ok_or_else(|| {
other("path was not valid unicode")
})
}
#[cfg(unix)]
pub fn path2bytes(p: &Path) -> io::Result<&[u8]> {
Ok(p.as_os_str().as_bytes())
}
#[cfg(windows)]
pub fn bytes2path(bytes: Cow<[u8]>) -> io::Result<Cow<Path>> {
return match bytes {
Cow::Borrowed(bytes) => {
let s = try!(str::from_utf8(bytes).map_err(|_| {
not_unicode()
}));
Ok(Cow::Borrowed(Path::new(s)))
}
Cow::Owned(bytes) => {
let s = try!(String::from_utf8(bytes).map_err(|_| {
not_unicode()
}));
Ok(Cow::Owned(PathBuf::from(s)))
}
};
fn not_unicode() -> io::Error {
other("only unicode paths are supported on windows")
}
}
#[cfg(unix)]
pub fn bytes2path(bytes: Cow<[u8]>) -> io::Result<Cow<Path>> {
use std::ffi::{OsStr, OsString};
Ok(match bytes {
Cow::Borrowed(bytes) => Cow::Borrowed({
Path::new(OsStr::from_bytes(bytes))
}),
Cow::Owned(bytes) => Cow::Owned({
PathBuf::from(OsString::from_vec(bytes))
})
})
}