src/pxar/sequential_decoder.rs

   1 //! *pxar* format decoder.
   2 //!
   3 //! This module contain the code to decode *pxar* archive files.
   4
   5 use failure::*;
   6 use endian_trait::Endian;
   7
   8 use super::format_definition::*;
   9
  10 use std::io::{Read, Write};
  11 use std::path::{Path, PathBuf};
  12
  13 use std::os::unix::io::AsRawFd;
  14 use std::os::unix::io::RawFd;
  15 use std::os::unix::io::FromRawFd;
  16 use std::os::unix::ffi::{OsStringExt};
  17 use std::ffi::{OsStr, OsString};
  18
  19 use nix::fcntl::OFlag;
  20 use nix::sys::stat::Mode;
  21 use nix::errno::Errno;
  22 use nix::NixPath;
  23
  24 use crate::tools::io::ops::*;
  25 use crate::tools::vec;
  26 use crate::tools::fs;
  27 use crate::tools::acl;
  28 use crate::tools::xattr;
  29
  30 // This one need Read, but works without Seek
  31 pub struct SequentialDecoder<'a, R: Read> {
  32     reader: &'a mut R,
  33     feature_flags: u64,
  34     skip_buffer: Vec<u8>,
  35 }
  36
  37 const HEADER_SIZE: u64 = std::mem::size_of::<CaFormatHeader>() as u64;
  38
  39 impl <'a, R: Read> SequentialDecoder<'a, R> {
  40
  41     pub fn new(reader: &'a mut R, feature_flags: u64) -> Self {
  42         let skip_buffer = vec::undefined(64*1024);
  43
  44         Self {
  45             reader,
  46             feature_flags,
  47             skip_buffer
  48         }
  49     }
  50
  51     pub (crate) fn get_reader_mut(&mut self) -> & mut R {
  52         self.reader
  53     }
  54
  55     pub (crate) fn read_item<T: Endian>(&mut self) -> Result<T, Error> {
  56
  57         let mut result: T = unsafe { std::mem::uninitialized() };
  58
  59         let buffer = unsafe { std::slice::from_raw_parts_mut(
  60             &mut result as *mut T as *mut u8,
  61             std::mem::size_of::<T>()
  62         )};
  63
  64         self.reader.read_exact(buffer)?;
  65
  66         Ok(result.from_le())
  67     }
  68
  69     fn read_link(&mut self, size: u64) -> Result<PathBuf, Error> {
  70         if size < (HEADER_SIZE + 2) {
  71              bail!("dectected short link target.");
  72         }
  73         let target_len = size - HEADER_SIZE;
  74
  75         if target_len > (libc::PATH_MAX as u64) {
  76             bail!("link target too long ({}).", target_len);
  77         }
  78
  79         let mut buffer = self.reader.read_exact_allocated(target_len as usize)?;
  80
  81         let last_byte = buffer.pop().unwrap();
  82         if last_byte != 0u8 {
  83             bail!("link target not nul terminated.");
  84         }
  85
  86         Ok(PathBuf::from(std::ffi::OsString::from_vec(buffer)))
  87     }
  88
  89     fn read_hardlink(&mut self, size: u64) -> Result<(PathBuf, u64), Error> {
  90         if size < (HEADER_SIZE + 8 + 2) {
  91             bail!("dectected short hardlink header.");
  92         }
  93         let offset: u64 = self.read_item()?;
  94         let target = self.read_link(size - 8)?;
  95
  96         for c in target.components() {
  97             match c {
  98                 std::path::Component::Normal(_) => { /* OK */  },
  99                 _ => {
 100                     bail!("hardlink target contains invalid component {:?}", c);
 101                 }
 102             }
 103         }
 104
 105         Ok((target, offset))
 106     }
 107
 108     pub (crate) fn read_filename(&mut self, size: u64) -> Result<OsString, Error> {
 109         if size < (HEADER_SIZE + 2) {
 110             bail!("dectected short filename");
 111         }
 112         let name_len = size - HEADER_SIZE;
 113
 114         if name_len > ((libc::FILENAME_MAX as u64) + 1) {
 115             bail!("filename too long ({}).", name_len);
 116         }
 117
 118         let mut buffer = self.reader.read_exact_allocated(name_len as usize)?;
 119
 120         let last_byte = buffer.pop().unwrap();
 121         if last_byte != 0u8 {
 122             bail!("filename entry not nul terminated.");
 123         }
 124
 125         if (buffer.len() == 1 && buffer[0] == b'.') || (buffer.len() == 2 && buffer[0] == b'.' && buffer[1] == b'.') {
 126             bail!("found invalid filename with slashes.");
 127         }
 128
 129         if buffer.iter().find(|b| (**b == b'/')).is_some() {
 130             bail!("found invalid filename with slashes.");
 131         }
 132
 133         let name = std::ffi::OsString::from_vec(buffer);
 134         if name.is_empty() {
 135             bail!("found empty filename.");
 136         }
 137
 138         Ok(name)
 139     }
 140
 141     fn has_features(&self, feature_flags: u64) -> bool {
 142         (self.feature_flags & feature_flags) == feature_flags
 143     }
 144
 145     fn read_xattr(&mut self, size: usize) -> Result<CaFormatXAttr, Error> {
 146         let buffer = self.reader.read_exact_allocated(size)?;
 147
 148         let separator = buffer.iter().position(|c| *c == b'\0')
 149             .ok_or_else(|| format_err!("no value found in xattr"))?;
 150
 151         let (name, value) = buffer.split_at(separator);
 152         if !xattr::is_valid_xattr_name(name) ||
 153             xattr::is_security_capability(name)
 154         {
 155             bail!("incorrect xattr name - {}.", String::from_utf8_lossy(name));
 156         }
 157
 158         Ok(CaFormatXAttr {
 159             name: name.to_vec(),
 160             value: value[1..].to_vec(),
 161         })
 162     }
 163
 164     fn read_fcaps(&mut self, size: usize) -> Result<CaFormatFCaps, Error> {
 165         let buffer = self.reader.read_exact_allocated(size)?;
 166
 167         Ok(CaFormatFCaps { data: buffer })
 168     }
 169
 170     fn restore_attributes(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<CaFormatHeader, Error> {
 171         let mut xattrs = Vec::new();
 172         let mut fcaps = None;
 173         let mut quota_projid = None;
 174
 175         let mut acl_user = Vec::new();
 176         let mut acl_group = Vec::new();
 177         let mut acl_group_obj = None;
 178
 179         let mut acl_default = None;
 180         let mut acl_default_user = Vec::new();
 181         let mut acl_default_group = Vec::new();
 182
 183         let mut head: CaFormatHeader = self.read_item()?;
 184         let mut size = (head.size - HEADER_SIZE) as usize;
 185         loop {
 186             match head.htype {
 187                 CA_FORMAT_XATTR => {
 188                     if self.has_features(CA_FORMAT_WITH_XATTRS) {
 189                         xattrs.push(self.read_xattr(size)?);
 190                     } else {
 191                         self.skip_bytes(size)?;
 192                     }
 193                 },
 194                 CA_FORMAT_FCAPS => {
 195                     if self.has_features(CA_FORMAT_WITH_FCAPS) {
 196                         fcaps = Some(self.read_fcaps(size)?);
 197                     } else {
 198                         self.skip_bytes(size)?;
 199                     }
 200                 },
 201                 CA_FORMAT_ACL_USER => {
 202                     if self.has_features(CA_FORMAT_WITH_ACL) {
 203                         acl_user.push(self.read_item::<CaFormatACLUser>()?);
 204                     } else {
 205                         self.skip_bytes(size)?;
 206                     }
 207                 },
 208                 CA_FORMAT_ACL_GROUP => {
 209                     if self.has_features(CA_FORMAT_WITH_ACL) {
 210                         acl_group.push(self.read_item::<CaFormatACLGroup>()?);
 211                     } else {
 212                         self.skip_bytes(size)?;
 213                     }
 214                 },
 215                 CA_FORMAT_ACL_GROUP_OBJ => {
 216                     if self.has_features(CA_FORMAT_WITH_ACL) {
 217                         acl_group_obj = Some(self.read_item::<CaFormatACLGroupObj>()?);
 218                     } else {
 219                         self.skip_bytes(size)?;
 220                     }
 221                 },
 222                 CA_FORMAT_ACL_DEFAULT => {
 223                     if self.has_features(CA_FORMAT_WITH_ACL) {
 224                         acl_default = Some(self.read_item::<CaFormatACLDefault>()?);
 225                     } else {
 226                         self.skip_bytes(size)?;
 227                     }
 228                 },
 229                 CA_FORMAT_ACL_DEFAULT_USER => {
 230                     if self.has_features(CA_FORMAT_WITH_ACL) {
 231                         acl_default_user.push(self.read_item::<CaFormatACLUser>()?);
 232                     } else {
 233                         self.skip_bytes(size)?;
 234                     }
 235                 },
 236                 CA_FORMAT_ACL_DEFAULT_GROUP => {
 237                     if self.has_features(CA_FORMAT_WITH_ACL) {
 238                         acl_default_group.push(self.read_item::<CaFormatACLGroup>()?);
 239                     } else {
 240                         self.skip_bytes(size)?;
 241                     }
 242                 },
 243                 CA_FORMAT_QUOTA_PROJID => {
 244                     if self.has_features(CA_FORMAT_WITH_QUOTA_PROJID) {
 245                         quota_projid = Some(self.read_item::<CaFormatQuotaProjID>()?);
 246                     } else {
 247                         self.skip_bytes(size)?;
 248                     }
 249                 },
 250                 _ => break,
 251             }
 252             head = self.read_item()?;
 253             size = (head.size - HEADER_SIZE) as usize;
 254         }
 255         self.restore_xattrs_fcaps_fd(fd, xattrs, fcaps)?;
 256
 257         let mut acl = acl::ACL::init(5)?;
 258         acl.add_entry_full(acl::ACL_USER_OBJ, None, mode_user_to_acl_permissions(entry.mode))?;
 259         acl.add_entry_full(acl::ACL_OTHER, None, mode_other_to_acl_permissions(entry.mode))?;
 260         match acl_group_obj {
 261             Some(group_obj) => {
 262                 acl.add_entry_full(acl::ACL_MASK, None, mode_group_to_acl_permissions(entry.mode))?;
 263                 acl.add_entry_full(acl::ACL_GROUP_OBJ, None, group_obj.permissions)?;
 264             },
 265             None => {
 266                 acl.add_entry_full(acl::ACL_GROUP_OBJ, None, mode_group_to_acl_permissions(entry.mode))?;
 267             },
 268         }
 269         for user in acl_user {
 270             acl.add_entry_full(acl::ACL_USER, Some(user.uid), user.permissions)?;
 271         }
 272         for group in acl_group {
 273             acl.add_entry_full(acl::ACL_GROUP, Some(group.gid), group.permissions)?;
 274         }
 275         let proc_path = Path::new("/proc/self/fd/").join(fd.to_string());
 276         if !acl.is_valid() {
 277             bail!("Error while restoring ACL - ACL invalid");
 278         }
 279         acl.set_file(&proc_path, acl::ACL_TYPE_ACCESS)?;
 280
 281         if let Some(default) = acl_default {
 282             let mut acl = acl::ACL::init(5)?;
 283             acl.add_entry_full(acl::ACL_USER_OBJ, None, default.user_obj_permissions)?;
 284             acl.add_entry_full(acl::ACL_GROUP_OBJ, None, default.group_obj_permissions)?;
 285             acl.add_entry_full(acl::ACL_OTHER, None, default.other_permissions)?;
 286             if default.mask_permissions != std::u64::MAX {
 287                 acl.add_entry_full(acl::ACL_MASK, None, default.mask_permissions)?;
 288             }
 289             for user in acl_default_user {
 290                 acl.add_entry_full(acl::ACL_USER, Some(user.uid), user.permissions)?;
 291             }
 292             for group in acl_default_group {
 293                 acl.add_entry_full(acl::ACL_GROUP, Some(group.gid), group.permissions)?;
 294             }
 295             if !acl.is_valid() {
 296                 bail!("Error while restoring ACL - ACL invalid");
 297             }
 298             acl.set_file(&proc_path, acl::ACL_TYPE_DEFAULT)?;
 299         }
 300         self.restore_quota_projid(fd, quota_projid)?;
 301
 302         Ok(head)
 303     }
 304
 305     fn restore_xattrs_fcaps_fd(&mut self, fd: RawFd, xattrs: Vec<CaFormatXAttr>, fcaps: Option<CaFormatFCaps>) -> Result<(), Error> {
 306         for xattr in xattrs {
 307             if let Err(err) = xattr::fsetxattr(fd, xattr) {
 308                 bail!("fsetxattr failed with error: {}", err);
 309             }
 310         }
 311         if let Some(fcaps) = fcaps {
 312             if let Err(err) = xattr::fsetxattr_fcaps(fd, fcaps) {
 313                 bail!("fsetxattr_fcaps failed with error: {}", err);
 314             }
 315         }
 316
 317         Ok(())
 318     }
 319
 320     fn restore_quota_projid(&mut self, fd: RawFd, projid: Option<CaFormatQuotaProjID>) -> Result<(), Error> {
 321         if let Some(projid) = projid {
 322             let mut fsxattr = fs::FSXAttr::default();
 323             unsafe {
 324                 fs::fs_ioc_fsgetxattr(fd, &mut fsxattr)
 325                     .map_err(|err| format_err!("error while getting fsxattr to restore quota project id - {}", err))?;
 326             }
 327             fsxattr.fsx_projid = projid.projid as u32;
 328             unsafe {
 329                 fs::fs_ioc_fssetxattr(fd, &fsxattr)
 330                     .map_err(|err| format_err!("error while setting fsxattr to restore quota project id - {}", err))?;
 331             }
 332         }
 333
 334         Ok(())
 335     }
 336
 337     fn restore_mode(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 338
 339         let mode = Mode::from_bits_truncate((entry.mode as u32) & 0o7777);
 340
 341         nix::sys::stat::fchmod(fd, mode)?;
 342
 343         Ok(())
 344     }
 345
 346     fn restore_mode_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 347
 348         let mode = Mode::from_bits_truncate((entry.mode as u32) & 0o7777);
 349
 350         // NOTE: we want :FchmodatFlags::NoFollowSymlink, but fchmodat does not support that
 351         // on linux (see man fchmodat). Fortunately, we can simply avoid calling this on symlinks.
 352         nix::sys::stat::fchmodat(Some(dirfd), filename, mode, nix::sys::stat::FchmodatFlags::FollowSymlink)?;
 353
 354         Ok(())
 355     }
 356
 357     fn restore_ugid(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 358
 359         let uid = entry.uid as u32;
 360         let gid = entry.gid as u32;
 361
 362         let res = unsafe { libc::fchown(fd, uid, gid) };
 363         Errno::result(res)?;
 364
 365         Ok(())
 366     }
 367
 368     fn restore_ugid_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd,  filename: &OsStr) -> Result<(), Error> {
 369
 370         let uid = entry.uid as u32;
 371         let gid = entry.gid as u32;
 372
 373         let res = filename.with_nix_path(|cstr| unsafe {
 374             libc::fchownat(dirfd, cstr.as_ptr(), uid, gid, libc::AT_SYMLINK_NOFOLLOW)
 375         })?;
 376         Errno::result(res)?;
 377
 378         Ok(())
 379     }
 380
 381     fn restore_mtime(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 382
 383         let times = nsec_to_update_timespec(entry.mtime);
 384
 385         let res = unsafe { libc::futimens(fd, &times[0]) };
 386         Errno::result(res)?;
 387
 388         Ok(())
 389     }
 390
 391     fn restore_mtime_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 392
 393         let times = nsec_to_update_timespec(entry.mtime);
 394
 395         let res =  filename.with_nix_path(|cstr| unsafe {
 396             libc::utimensat(dirfd, cstr.as_ptr(), &times[0],  libc::AT_SYMLINK_NOFOLLOW)
 397         })?;
 398         Errno::result(res)?;
 399
 400         Ok(())
 401     }
 402
 403     fn restore_device_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr, device: &CaFormatDevice) -> Result<(), Error> {
 404
 405         let rdev = nix::sys::stat::makedev(device.major, device.minor);
 406         let mode = ((entry.mode as u32) & libc::S_IFMT) | 0o0600;
 407         let res =  filename.with_nix_path(|cstr| unsafe {
 408             libc::mknodat(dirfd, cstr.as_ptr(), mode, rdev)
 409         })?;
 410         Errno::result(res)?;
 411
 412         Ok(())
 413     }
 414
 415     fn restore_socket_at(&mut self, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 416
 417         let mode = libc::S_IFSOCK | 0o0600;
 418         let res =  filename.with_nix_path(|cstr| unsafe {
 419             libc::mknodat(dirfd, cstr.as_ptr(), mode, 0)
 420         })?;
 421         Errno::result(res)?;
 422
 423         Ok(())
 424     }
 425
 426     fn restore_fifo_at(&mut self, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 427
 428         let mode = libc::S_IFIFO | 0o0600;
 429         let res =  filename.with_nix_path(|cstr| unsafe {
 430             libc::mkfifoat(dirfd, cstr.as_ptr(), mode)
 431         })?;
 432         Errno::result(res)?;
 433
 434         Ok(())
 435     }
 436
 437     fn skip_bytes(&mut self, count: usize) -> Result<(), Error> {
 438         let mut done = 0;
 439         while done < count  {
 440             let todo = count - done;
 441             let n = if todo > self.skip_buffer.len() { self.skip_buffer.len() } else { todo };
 442             let data = &mut self.skip_buffer[..n];
 443             self.reader.read_exact(data)?;
 444             done += n;
 445         }
 446         Ok(())
 447     }
 448
 449     /// Restore an archive into the specified directory.
 450     ///
 451     /// The directory is created if it does not exist.
 452     pub fn restore<F>(
 453         &mut self,
 454         path: &Path,
 455         callback: &F,
 456     ) -> Result<(), Error>
 457         where F: Fn(&Path) -> Result<(), Error>
 458     {
 459
 460         let _ = std::fs::create_dir(path);
 461
 462         let dir = match nix::dir::Dir::open(path, nix::fcntl::OFlag::O_DIRECTORY,  nix::sys::stat::Mode::empty()) {
 463             Ok(dir) => dir,
 464             Err(err) => bail!("unable to open target directory {:?} - {}", path, err),
 465         };
 466
 467         let mut relative_path = PathBuf::new();
 468         self.restore_sequential(path, &mut relative_path, &OsString::new(), &dir, callback)
 469     }
 470
 471     fn restore_sequential<F>(
 472         &mut self,
 473         base_path: &Path,
 474         relative_path: &mut PathBuf,
 475         filename: &OsStr,  // repeats path last relative_path component
 476         parent: &nix::dir::Dir,
 477         callback: &F,
 478     ) -> Result<(), Error>
 479         where F: Fn(&Path) -> Result<(), Error>
 480     {
 481
 482         let parent_fd = parent.as_raw_fd();
 483
 484         let full_path = base_path.join(&relative_path);
 485
 486         (callback)(&full_path)?;
 487
 488         let head: CaFormatHeader = self.read_item()?;
 489
 490         if head.htype == PXAR_FORMAT_HARDLINK {
 491             let (target, _offset) = self.read_hardlink(head.size)?;
 492             let target_path = base_path.join(&target);
 493             //println!("HARDLINK: {} {:?} -> {:?}", offset, full_path, target_path);
 494             hardlink(&target_path, &full_path)?;
 495             return Ok(());
 496         }
 497
 498         check_ca_header::<CaFormatEntry>(&head, CA_FORMAT_ENTRY)?;
 499         let entry: CaFormatEntry = self.read_item()?;
 500
 501
 502         let mode = entry.mode as u32; //fixme: upper 32bits?
 503
 504         let ifmt = mode & libc::S_IFMT;
 505
 506         if ifmt == libc::S_IFDIR {
 507             let dir;
 508             if filename.is_empty() {
 509                 dir = nix::dir::Dir::openat(parent_fd, ".", OFlag::O_DIRECTORY,  Mode::empty())?;
 510              } else {
 511                 dir = match dir_mkdirat(parent_fd, filename, true) {
 512                     Ok(dir) => dir,
 513                     Err(err) => bail!("unable to open directory {:?} - {}", full_path, err),
 514                 };
 515             }
 516
 517             self.restore_ugid(&entry, dir.as_raw_fd())?;
 518             // fcaps have to be restored after restore_ugid as chown clears security.capability xattr, see CVE-2015-1350
 519             let mut head = match self.restore_attributes(&entry, dir.as_raw_fd()) {
 520                 Ok(head) => head,
 521                 Err(err) => bail!("Restoring of directory attributes failed - {}", err),
 522             };
 523
 524             while head.htype == CA_FORMAT_FILENAME {
 525                 let name = self.read_filename(head.size)?;
 526                 relative_path.push(&name);
 527                 self.restore_sequential(base_path, relative_path, &name, &dir, callback)?;
 528                 relative_path.pop();
 529
 530                 head = self.read_item()?;
 531             }
 532
 533             if head.htype != CA_FORMAT_GOODBYE {
 534                 bail!("got unknown header type inside directory entry {:016x}", head.htype);
 535             }
 536
 537             //println!("Skip Goodbye");
 538             if head.size < HEADER_SIZE { bail!("detected short goodbye table"); }
 539
 540             self.skip_bytes((head.size - HEADER_SIZE) as usize)?;
 541
 542             self.restore_mode(&entry, dir.as_raw_fd())?;
 543             self.restore_mtime(&entry, dir.as_raw_fd())?;
 544
 545             return Ok(());
 546         }
 547
 548         if filename.is_empty() {
 549             bail!("got empty file name at {:?}", full_path)
 550         }
 551
 552         if ifmt == libc::S_IFLNK {
 553             // fixme: create symlink
 554             //fixme: restore permission, acls, xattr, ...
 555
 556             let head: CaFormatHeader = self.read_item()?;
 557             match head.htype {
 558                 CA_FORMAT_SYMLINK => {
 559                     let target = self.read_link(head.size)?;
 560                     //println!("TARGET: {:?}", target);
 561                     if let Err(err) = symlinkat(&target, parent_fd, filename) {
 562                         bail!("create symlink {:?} failed - {}", full_path, err);
 563                     }
 564                 }
 565                  _ => {
 566                      bail!("got unknown header type inside symlink entry {:016x}", head.htype);
 567                  }
 568             }
 569
 570             // self.restore_mode_at(&entry, parent_fd, filename)?; //not supported on symlinks
 571             self.restore_ugid_at(&entry, parent_fd, filename)?;
 572             self.restore_mtime_at(&entry, parent_fd, filename)?;
 573
 574             return Ok(());
 575         }
 576
 577         if ifmt == libc::S_IFSOCK  {
 578
 579             self.restore_socket_at(parent_fd, filename)?;
 580
 581             self.restore_mode_at(&entry, parent_fd, filename)?;
 582             self.restore_ugid_at(&entry, parent_fd, filename)?;
 583             self.restore_mtime_at(&entry, parent_fd, filename)?;
 584
 585             return Ok(());
 586         }
 587
 588         if ifmt == libc::S_IFIFO  {
 589
 590             self.restore_fifo_at(parent_fd, filename)?;
 591
 592             self.restore_mode_at(&entry, parent_fd, filename)?;
 593             self.restore_ugid_at(&entry, parent_fd, filename)?;
 594             self.restore_mtime_at(&entry, parent_fd, filename)?;
 595
 596             return Ok(());
 597         }
 598
 599         if (ifmt == libc::S_IFBLK) || (ifmt == libc::S_IFCHR)  {
 600
 601             let head: CaFormatHeader = self.read_item()?;
 602             match head.htype {
 603                 CA_FORMAT_DEVICE => {
 604                     let device: CaFormatDevice = self.read_item()?;
 605                     self.restore_device_at(&entry, parent_fd, filename, &device)?;
 606                 }
 607                 _ => {
 608                     bail!("got unknown header type inside device entry {:016x}", head.htype);
 609                 }
 610             }
 611
 612             self.restore_mode_at(&entry, parent_fd, filename)?;
 613             self.restore_ugid_at(&entry, parent_fd, filename)?;
 614             self.restore_mtime_at(&entry, parent_fd, filename)?;
 615
 616             return Ok(());
 617         }
 618
 619         if ifmt == libc::S_IFREG {
 620
 621             let mut read_buffer: [u8; 64*1024] = unsafe { std::mem::uninitialized() };
 622
 623             let flags = OFlag::O_CREAT|OFlag::O_WRONLY|OFlag::O_EXCL;
 624             let open_mode =  Mode::from_bits_truncate(0o0600 | mode);
 625
 626             let mut file = match file_openat(parent_fd, filename, flags, open_mode) {
 627                 Ok(file) => file,
 628                 Err(err) => bail!("open file {:?} failed - {}", full_path, err),
 629             };
 630
 631             self.restore_ugid(&entry, file.as_raw_fd())?;
 632             // fcaps have to be restored after restore_ugid as chown clears security.capability xattr, see CVE-2015-1350
 633             let head = match self.restore_attributes(&entry, file.as_raw_fd()) {
 634                 Ok(head) => head,
 635                 Err(err) => bail!("Restoring of file attributes failed - {}", err),
 636             };
 637
 638             if head.htype != CA_FORMAT_PAYLOAD {
 639                   bail!("got unknown header type for file entry {:016x}", head.htype);
 640             }
 641
 642             if head.size < HEADER_SIZE {
 643                 bail!("detected short payload");
 644             }
 645             let need = (head.size - HEADER_SIZE) as usize;
 646             //self.reader.seek(SeekFrom::Current(need as i64))?;
 647
 648             let mut done = 0;
 649             while done < need  {
 650                 let todo = need - done;
 651                 let n = if todo > read_buffer.len() { read_buffer.len() } else { todo };
 652                 let data = &mut read_buffer[..n];
 653                 self.reader.read_exact(data)?;
 654                 file.write_all(data)?;
 655                 done += n;
 656             }
 657
 658             self.restore_mode(&entry, file.as_raw_fd())?;
 659             self.restore_mtime(&entry, file.as_raw_fd())?;
 660
 661             return Ok(());
 662         }
 663
 664         Ok(())
 665     }
 666
 667     /// List/Dump archive content.
 668     ///
 669     /// Simply print the list of contained files. This dumps archive
 670     /// format details when the verbose flag is set (useful for debug).
 671     pub fn dump_entry<W: std::io::Write>(
 672         &mut self,
 673         path: &mut PathBuf,
 674         verbose: bool,
 675         output: &mut W,
 676     ) -> Result<(), Error> {
 677
 678         let print_head = |head: &CaFormatHeader| {
 679             println!("Type: {:016x}", head.htype);
 680             println!("Size: {}", head.size);
 681         };
 682
 683         let head: CaFormatHeader = self.read_item()?;
 684         if verbose {
 685             println!("Path: {:?}", path);
 686             print_head(&head);
 687         } else {
 688             println!("{:?}", path);
 689         }
 690
 691         if head.htype == PXAR_FORMAT_HARDLINK {
 692             let (target, offset) = self.read_hardlink(head.size)?;
 693             if verbose {
 694                 println!("Hardlink: {} {:?}", offset, target);
 695             }
 696             return Ok(());
 697         }
 698
 699         check_ca_header::<CaFormatEntry>(&head, CA_FORMAT_ENTRY)?;
 700         let entry: CaFormatEntry = self.read_item()?;
 701
 702         if verbose {
 703             println!("Mode: {:08x} {:08x}", entry.mode, (entry.mode as u32) & libc::S_IFDIR);
 704         }
 705
 706         let ifmt = (entry.mode as u32) & libc::S_IFMT;
 707
 708         if ifmt == libc::S_IFDIR {
 709
 710             let mut entry_count = 0;
 711
 712             loop {
 713                 let head: CaFormatHeader = self.read_item()?;
 714                 if verbose {
 715                     print_head(&head);
 716                 }
 717
 718                 // This call covers all the cases of the match statement
 719                 // regarding extended attributes. These calls will never
 720                 // break on the loop and can therefore be handled separately.
 721                 // If the header was matched, true is returned and we can continue
 722                 if self.dump_if_attribute(&head, verbose)? {
 723                     continue;
 724                 }
 725
 726                 match head.htype {
 727                     CA_FORMAT_FILENAME =>  {
 728                         let name = self.read_filename(head.size)?;
 729                         if verbose { println!("Name: {:?}", name); }
 730                         entry_count += 1;
 731                         path.push(&name);
 732                         self.dump_entry(path, verbose, output)?;
 733                         path.pop();
 734                     },
 735                     CA_FORMAT_GOODBYE => {
 736                         let table_size = (head.size - HEADER_SIZE) as usize;
 737                         if verbose {
 738                             println!("Goodbye: {:?}", path);
 739                             self.dump_goodby_entries(entry_count, table_size)?;
 740                         } else {
 741                             self.skip_bytes(table_size)?;
 742                         }
 743                         break;
 744                     },
 745                     _ => panic!("got unexpected header type inside directory"),
 746                 }
 747             }
 748         } else if (ifmt == libc::S_IFBLK) || (ifmt == libc::S_IFCHR) ||
 749             (ifmt == libc::S_IFLNK) || (ifmt == libc::S_IFREG)
 750         {
 751             loop {
 752                 let head: CaFormatHeader = self.read_item()?;
 753                 if verbose {
 754                     print_head(&head);
 755                 }
 756
 757                 // This call covers all the cases of the match statement
 758                 // regarding extended attributes. These calls will never
 759                 // break on the loop and can therefore be handled separately.
 760                 // If the header was matched, true is returned and we can continue
 761                 if self.dump_if_attribute(&head, verbose)? {
 762                     continue;
 763                 }
 764
 765                 match head.htype {
 766                     CA_FORMAT_SYMLINK => {
 767                         let target = self.read_link(head.size)?;
 768                         if verbose {
 769                             println!("Symlink: {:?}", target);
 770                         }
 771                         break;
 772                     },
 773                     CA_FORMAT_DEVICE => {
 774                         let device: CaFormatDevice = self.read_item()?;
 775                         if verbose {
 776                             println!("Device: {}, {}", device.major, device.minor);
 777                         }
 778                         break;
 779                     },
 780                     CA_FORMAT_PAYLOAD => {
 781                         let payload_size = (head.size - HEADER_SIZE) as usize;
 782                         if verbose {
 783                             println!("Payload: {}", payload_size);
 784                         }
 785                         self.skip_bytes(payload_size)?;
 786                         break;
 787                     }
 788                     _ => {
 789                         panic!("got unexpected header type inside non-directory");
 790                     }
 791                 }
 792             }
 793         } else if ifmt == libc::S_IFIFO {
 794             if verbose {
 795                 println!("Fifo:");
 796             }
 797         } else if ifmt == libc::S_IFSOCK {
 798             if verbose {
 799                 println!("Socket:");
 800             }
 801         } else {
 802             panic!("unknown st_mode");
 803         }
 804         Ok(())
 805     }
 806
 807     fn dump_if_attribute(&mut self, header: &CaFormatHeader, verbose: bool) -> Result<bool, Error> {
 808         match header.htype {
 809             CA_FORMAT_XATTR => {
 810                 let xattr = self.read_xattr((header.size - HEADER_SIZE) as usize)?;
 811                 if verbose && self.has_features(CA_FORMAT_WITH_XATTRS) {
 812                     println!("XAttr: {:?}", xattr);
 813                 }
 814             },
 815             CA_FORMAT_FCAPS => {
 816                 let fcaps = self.read_fcaps((header.size - HEADER_SIZE) as usize)?;
 817                 if verbose && self.has_features(CA_FORMAT_WITH_FCAPS) {
 818                     println!("FCaps: {:?}", fcaps);
 819                 }
 820             },
 821             CA_FORMAT_ACL_USER => {
 822                 let user = self.read_item::<CaFormatACLUser>()?;
 823                 if verbose && self.has_features(CA_FORMAT_WITH_ACL) {
 824                     println!("ACLUser: {:?}", user);
 825                 }
 826             },
 827             CA_FORMAT_ACL_GROUP => {
 828                 let group = self.read_item::<CaFormatACLGroup>()?;
 829                 if verbose && self.has_features(CA_FORMAT_WITH_ACL) {
 830                     println!("ACLGroup: {:?}", group);
 831                 }
 832             },
 833             CA_FORMAT_ACL_GROUP_OBJ => {
 834                 let group_obj = self.read_item::<CaFormatACLGroupObj>()?;
 835                 if verbose && self.has_features(CA_FORMAT_WITH_ACL) {
 836                     println!("ACLGroupObj: {:?}", group_obj);
 837                 }
 838             },
 839             CA_FORMAT_ACL_DEFAULT => {
 840                 let default = self.read_item::<CaFormatACLDefault>()?;
 841                 if verbose && self.has_features(CA_FORMAT_WITH_ACL) {
 842                     println!("ACLDefault: {:?}", default);
 843                 }
 844             },
 845             CA_FORMAT_ACL_DEFAULT_USER => {
 846                 let default_user = self.read_item::<CaFormatACLUser>()?;
 847                 if verbose && self.has_features(CA_FORMAT_WITH_ACL) {
 848                     println!("ACLDefaultUser: {:?}", default_user);
 849                 }
 850             },
 851             CA_FORMAT_ACL_DEFAULT_GROUP => {
 852                 let default_group = self.read_item::<CaFormatACLGroup>()?;
 853                 if verbose && self.has_features(CA_FORMAT_WITH_ACL) {
 854                     println!("ACLDefaultGroup: {:?}", default_group);
 855                 }
 856             },
 857             CA_FORMAT_QUOTA_PROJID => {
 858                 let quota_projid = self.read_item::<CaFormatQuotaProjID>()?;
 859                 if verbose && self.has_features(CA_FORMAT_WITH_QUOTA_PROJID) {
 860                     println!("Quota project id: {:?}", quota_projid);
 861                 }
 862             },
 863             _ => return Ok(false),
 864         }
 865
 866         Ok(true)
 867     }
 868
 869     fn dump_goodby_entries(
 870         &mut self,
 871         entry_count: usize,
 872         table_size: usize,
 873     ) -> Result<(), Error> {
 874
 875         const GOODBYE_ITEM_SIZE: usize = std::mem::size_of::<CaFormatGoodbyeItem>();
 876
 877         if table_size < GOODBYE_ITEM_SIZE {
 878             bail!("Goodbye table to small ({} < {})", table_size, GOODBYE_ITEM_SIZE);
 879         }
 880         if (table_size % GOODBYE_ITEM_SIZE) != 0 {
 881             bail!("Goodbye table with strange size ({})", table_size);
 882         }
 883
 884         let entries = table_size / GOODBYE_ITEM_SIZE;
 885
 886         if entry_count != (entries - 1) {
 887             bail!("Goodbye table with wrong entry count ({} != {})", entry_count, entries - 1);
 888         }
 889
 890         let mut count = 0;
 891
 892         loop {
 893             let item: CaFormatGoodbyeItem = self.read_item()?;
 894             count += 1;
 895             if item.hash == CA_FORMAT_GOODBYE_TAIL_MARKER {
 896                 if count != entries {
 897                     bail!("unexpected goodbye tail marker");
 898                 }
 899                 println!("Goodby tail mark.");
 900                 break;
 901             }
 902             println!("Goodby item: offset {}, size {}, hash {:016x}", item.offset, item.size, item.hash);
 903             if count >= entries {
 904                 bail!("too many goodbye items (no tail marker)");
 905             }
 906         }
 907
 908         Ok(())
 909     }
 910 }
 911
 912 fn file_openat(parent: RawFd, filename: &OsStr, flags: OFlag, mode: Mode) -> Result<std::fs::File, Error> {
 913
 914     let fd = filename.with_nix_path(|cstr| {
 915         nix::fcntl::openat(parent, cstr.as_ref(), flags, mode)
 916     })??;
 917
 918     let file = unsafe { std::fs::File::from_raw_fd(fd) };
 919
 920     Ok(file)
 921 }
 922
 923 fn dir_mkdirat(parent: RawFd, filename: &OsStr, create_new: bool) -> Result<nix::dir::Dir, nix::Error> {
 924
 925     // call mkdirat first
 926     let res = filename.with_nix_path(|cstr| unsafe {
 927         libc::mkdirat(parent, cstr.as_ptr(), libc::S_IRWXU)
 928     })?;
 929
 930     match Errno::result(res) {
 931         Ok(_) => {},
 932         Err(err) => {
 933             if err == nix::Error::Sys(nix::errno::Errno::EEXIST) {
 934                 if create_new { return Err(err); }
 935             } else {
 936                 return Err(err);
 937             }
 938         }
 939     }
 940
 941     let dir = nix::dir::Dir::openat(parent, filename, OFlag::O_DIRECTORY,  Mode::empty())?;
 942
 943     Ok(dir)
 944 }
 945
 946 fn hardlink(oldpath: &Path, newpath: &Path) -> Result<(), Error> {
 947     oldpath.with_nix_path(|oldpath| {
 948         newpath.with_nix_path(|newpath| {
 949             let res = unsafe { libc::link(oldpath.as_ptr(), newpath.as_ptr()) };
 950             Errno::result(res)?;
 951             Ok(())
 952         })?
 953     })?
 954 }
 955
 956 fn symlinkat(target: &Path, parent: RawFd, linkname: &OsStr) -> Result<(), Error> {
 957
 958     target.with_nix_path(|target| {
 959         linkname.with_nix_path(|linkname| {
 960             let res = unsafe { libc::symlinkat(target.as_ptr(), parent, linkname.as_ptr()) };
 961             Errno::result(res)?;
 962             Ok(())
 963         })?
 964     })?
 965 }
 966
 967 fn nsec_to_update_timespec(mtime_nsec: u64) -> [libc::timespec; 2] {
 968
 969     // restore mtime
 970     const UTIME_OMIT: i64 = ((1 << 30) - 2);
 971     const NANOS_PER_SEC: i64 = 1_000_000_000;
 972
 973     let sec = (mtime_nsec as i64) / NANOS_PER_SEC;
 974     let nsec = (mtime_nsec as i64) % NANOS_PER_SEC;
 975
 976     let times: [libc::timespec; 2] = [
 977         libc::timespec { tv_sec: 0, tv_nsec: UTIME_OMIT },
 978         libc::timespec { tv_sec: sec, tv_nsec: nsec },
 979     ];
 980
 981     times
 982 }
 983
 984 fn mode_user_to_acl_permissions(mode: u64) -> u64 {
 985     return (mode >> 6) & 7;
 986 }
 987
 988 fn mode_group_to_acl_permissions(mode: u64) -> u64 {
 989     return (mode >> 3) & 7;
 990 }
 991
 992 fn mode_other_to_acl_permissions(mode: u64) -> u64 {
 993     return mode & 7;
 994 }