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::xattr;
  27
  28 // This one need Read, but works without Seek
  29 pub struct SequentialDecoder<'a, R: Read> {
  30     reader: &'a mut R,
  31     feature_flags: u64,
  32     skip_buffer: Vec<u8>,
  33 }
  34
  35 const HEADER_SIZE: u64 = std::mem::size_of::<CaFormatHeader>() as u64;
  36
  37 impl <'a, R: Read> SequentialDecoder<'a, R> {
  38
  39     pub fn new(reader: &'a mut R, feature_flags: u64) -> Self {
  40         let skip_buffer = vec::undefined(64*1024);
  41
  42         Self {
  43             reader,
  44             feature_flags,
  45             skip_buffer
  46         }
  47     }
  48
  49     pub (crate) fn get_reader_mut(&mut self) -> & mut R {
  50         self.reader
  51     }
  52
  53     pub (crate) fn read_item<T: Endian>(&mut self) -> Result<T, Error> {
  54
  55         let mut result: T = unsafe { std::mem::uninitialized() };
  56
  57         let buffer = unsafe { std::slice::from_raw_parts_mut(
  58             &mut result as *mut T as *mut u8,
  59             std::mem::size_of::<T>()
  60         )};
  61
  62         self.reader.read_exact(buffer)?;
  63
  64         Ok(result.from_le())
  65     }
  66
  67     fn read_link(&mut self, size: u64) -> Result<PathBuf, Error> {
  68         if size < (HEADER_SIZE + 2) {
  69              bail!("dectected short link target.");
  70         }
  71         let target_len = size - HEADER_SIZE;
  72
  73         if target_len > (libc::PATH_MAX as u64) {
  74             bail!("link target too long ({}).", target_len);
  75         }
  76
  77         let mut buffer = self.reader.read_exact_allocated(target_len as usize)?;
  78
  79         let last_byte = buffer.pop().unwrap();
  80         if last_byte != 0u8 {
  81             bail!("link target not nul terminated.");
  82         }
  83
  84         Ok(PathBuf::from(std::ffi::OsString::from_vec(buffer)))
  85     }
  86
  87     fn read_hardlink(&mut self, size: u64) -> Result<(PathBuf, u64), Error> {
  88         if size < (HEADER_SIZE + 8 + 2) {
  89             bail!("dectected short hardlink header.");
  90         }
  91         let offset: u64 = self.read_item()?;
  92         let target = self.read_link(size - 8)?;
  93
  94         for c in target.components() {
  95             match c {
  96                 std::path::Component::Normal(_) => { /* OK */  },
  97                 _ => {
  98                     bail!("hardlink target contains invalid component {:?}", c);
  99                 }
 100             }
 101         }
 102
 103         Ok((target, offset))
 104     }
 105
 106     pub (crate) fn read_filename(&mut self, size: u64) -> Result<OsString, Error> {
 107         if size < (HEADER_SIZE + 2) {
 108             bail!("dectected short filename");
 109         }
 110         let name_len = size - HEADER_SIZE;
 111
 112         if name_len > ((libc::FILENAME_MAX as u64) + 1) {
 113             bail!("filename too long ({}).", name_len);
 114         }
 115
 116         let mut buffer = self.reader.read_exact_allocated(name_len as usize)?;
 117
 118         let last_byte = buffer.pop().unwrap();
 119         if last_byte != 0u8 {
 120             bail!("filename entry not nul terminated.");
 121         }
 122
 123         if (buffer.len() == 1 && buffer[0] == b'.') || (buffer.len() == 2 && buffer[0] == b'.' && buffer[1] == b'.') {
 124             bail!("found invalid filename with slashes.");
 125         }
 126
 127         if buffer.iter().find(|b| (**b == b'/')).is_some() {
 128             bail!("found invalid filename with slashes.");
 129         }
 130
 131         let name = std::ffi::OsString::from_vec(buffer);
 132         if name.is_empty() {
 133             bail!("found empty filename.");
 134         }
 135
 136         Ok(name)
 137     }
 138
 139     fn has_features(&self, feature_flags: u64) -> bool {
 140         (self.feature_flags & feature_flags) == feature_flags
 141     }
 142
 143     fn read_xattr(&mut self, size: usize) -> Result<CaFormatXAttr, Error> {
 144         let buffer = self.reader.read_exact_allocated(size)?;
 145
 146         let separator = buffer.iter().position(|c| *c == b'\0')
 147             .ok_or_else(|| format_err!("no value found in xattr"))?;
 148
 149         let (name, value) = buffer.split_at(separator);
 150         if !xattr::is_valid_xattr_name(name) ||
 151             xattr::is_security_capability(name)
 152         {
 153             bail!("incorrect xattr name - {}.", String::from_utf8_lossy(name));
 154         }
 155
 156         Ok(CaFormatXAttr {
 157             name: name.to_vec(),
 158             value: value[1..].to_vec(),
 159         })
 160     }
 161
 162     fn read_fcaps(&mut self, size: usize) -> Result<CaFormatFCaps, Error> {
 163         let buffer = self.reader.read_exact_allocated(size)?;
 164
 165         Ok(CaFormatFCaps { data: buffer })
 166     }
 167
 168     fn restore_attributes(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<CaFormatHeader, Error> {
 169         let mut xattrs: Vec<CaFormatXAttr> = Vec::new();
 170         let mut fcaps: Option<CaFormatFCaps> = None;
 171
 172         let mut head: CaFormatHeader = self.read_item()?;
 173         let mut size = (head.size - HEADER_SIZE) as usize;
 174         loop {
 175             match head.htype {
 176                 CA_FORMAT_XATTR => {
 177                     if self.has_features(CA_FORMAT_WITH_XATTRS) {
 178                         xattrs.push(self.read_xattr(size)?);
 179                     } else {
 180                         self.skip_bytes(size)?;
 181                     }
 182                 },
 183                 CA_FORMAT_FCAPS => {
 184                     if self.has_features(CA_FORMAT_WITH_FCAPS) {
 185                         fcaps = Some(self.read_fcaps(size)?);
 186                     } else {
 187                         self.skip_bytes(size)?;
 188                     }
 189                 },
 190                 _ => break,
 191             }
 192             head = self.read_item()?;
 193             size = (head.size - HEADER_SIZE) as usize;
 194         }
 195         self.restore_xattrs_fcaps_fd(fd, xattrs, fcaps)?;
 196
 197         Ok(head)
 198     }
 199
 200     fn restore_xattrs_fcaps_fd(&mut self, fd: RawFd, xattrs: Vec<CaFormatXAttr>, fcaps: Option<CaFormatFCaps>) -> Result<(), Error> {
 201         for xattr in xattrs {
 202             if let Err(err) = xattr::fsetxattr(fd, xattr) {
 203                 bail!("fsetxattr failed with error: {}", err);
 204             }
 205         }
 206         if let Some(fcaps) = fcaps {
 207             if let Err(err) = xattr::fsetxattr_fcaps(fd, fcaps) {
 208                 bail!("fsetxattr_fcaps failed with error: {}", err);
 209             }
 210         }
 211
 212         Ok(())
 213     }
 214
 215     fn restore_mode(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 216
 217         let mode = Mode::from_bits_truncate((entry.mode as u32) & 0o7777);
 218
 219         nix::sys::stat::fchmod(fd, mode)?;
 220
 221         Ok(())
 222     }
 223
 224     fn restore_mode_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 225
 226         let mode = Mode::from_bits_truncate((entry.mode as u32) & 0o7777);
 227
 228         // NOTE: we want :FchmodatFlags::NoFollowSymlink, but fchmodat does not support that
 229         // on linux (see man fchmodat). Fortunately, we can simply avoid calling this on symlinks.
 230         nix::sys::stat::fchmodat(Some(dirfd), filename, mode, nix::sys::stat::FchmodatFlags::FollowSymlink)?;
 231
 232         Ok(())
 233     }
 234
 235     fn restore_ugid(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 236
 237         let uid = entry.uid as u32;
 238         let gid = entry.gid as u32;
 239
 240         let res = unsafe { libc::fchown(fd, uid, gid) };
 241         Errno::result(res)?;
 242
 243         Ok(())
 244     }
 245
 246     fn restore_ugid_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd,  filename: &OsStr) -> Result<(), Error> {
 247
 248         let uid = entry.uid as u32;
 249         let gid = entry.gid as u32;
 250
 251         let res = filename.with_nix_path(|cstr| unsafe {
 252             libc::fchownat(dirfd, cstr.as_ptr(), uid, gid, libc::AT_SYMLINK_NOFOLLOW)
 253         })?;
 254         Errno::result(res)?;
 255
 256         Ok(())
 257     }
 258
 259     fn restore_mtime(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 260
 261         let times = nsec_to_update_timespec(entry.mtime);
 262
 263         let res = unsafe { libc::futimens(fd, &times[0]) };
 264         Errno::result(res)?;
 265
 266         Ok(())
 267     }
 268
 269     fn restore_mtime_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 270
 271         let times = nsec_to_update_timespec(entry.mtime);
 272
 273         let res =  filename.with_nix_path(|cstr| unsafe {
 274             libc::utimensat(dirfd, cstr.as_ptr(), &times[0],  libc::AT_SYMLINK_NOFOLLOW)
 275         })?;
 276         Errno::result(res)?;
 277
 278         Ok(())
 279     }
 280
 281     fn restore_device_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr, device: &CaFormatDevice) -> Result<(), Error> {
 282
 283         let rdev = nix::sys::stat::makedev(device.major, device.minor);
 284         let mode = ((entry.mode as u32) & libc::S_IFMT) | 0o0600;
 285         let res =  filename.with_nix_path(|cstr| unsafe {
 286             libc::mknodat(dirfd, cstr.as_ptr(), mode, rdev)
 287         })?;
 288         Errno::result(res)?;
 289
 290         Ok(())
 291     }
 292
 293     fn restore_socket_at(&mut self, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 294
 295         let mode = libc::S_IFSOCK | 0o0600;
 296         let res =  filename.with_nix_path(|cstr| unsafe {
 297             libc::mknodat(dirfd, cstr.as_ptr(), mode, 0)
 298         })?;
 299         Errno::result(res)?;
 300
 301         Ok(())
 302     }
 303
 304     fn restore_fifo_at(&mut self, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 305
 306         let mode = libc::S_IFIFO | 0o0600;
 307         let res =  filename.with_nix_path(|cstr| unsafe {
 308             libc::mkfifoat(dirfd, cstr.as_ptr(), mode)
 309         })?;
 310         Errno::result(res)?;
 311
 312         Ok(())
 313     }
 314
 315     fn skip_bytes(&mut self, count: usize) -> Result<(), Error> {
 316         let mut done = 0;
 317         while done < count  {
 318             let todo = count - done;
 319             let n = if todo > self.skip_buffer.len() { self.skip_buffer.len() } else { todo };
 320             let data = &mut self.skip_buffer[..n];
 321             self.reader.read_exact(data)?;
 322             done += n;
 323         }
 324         Ok(())
 325     }
 326
 327     /// Restore an archive into the specified directory.
 328     ///
 329     /// The directory is created if it does not exist.
 330     pub fn restore<F>(
 331         &mut self,
 332         path: &Path,
 333         callback: &F,
 334     ) -> Result<(), Error>
 335         where F: Fn(&Path) -> Result<(), Error>
 336     {
 337
 338         let _ = std::fs::create_dir(path);
 339
 340         let dir = match nix::dir::Dir::open(path, nix::fcntl::OFlag::O_DIRECTORY,  nix::sys::stat::Mode::empty()) {
 341             Ok(dir) => dir,
 342             Err(err) => bail!("unable to open target directory {:?} - {}", path, err),
 343         };
 344
 345         let mut relative_path = PathBuf::new();
 346         self.restore_sequential(path, &mut relative_path, &OsString::new(), &dir, callback)
 347     }
 348
 349     fn restore_sequential<F>(
 350         &mut self,
 351         base_path: &Path,
 352         relative_path: &mut PathBuf,
 353         filename: &OsStr,  // repeats path last relative_path component
 354         parent: &nix::dir::Dir,
 355         callback: &F,
 356     ) -> Result<(), Error>
 357         where F: Fn(&Path) -> Result<(), Error>
 358     {
 359
 360         let parent_fd = parent.as_raw_fd();
 361
 362         let full_path = base_path.join(&relative_path);
 363
 364         (callback)(&full_path)?;
 365
 366         let head: CaFormatHeader = self.read_item()?;
 367
 368         if head.htype == PXAR_FORMAT_HARDLINK {
 369             let (target, _offset) = self.read_hardlink(head.size)?;
 370             let target_path = base_path.join(&target);
 371             //println!("HARDLINK: {} {:?} -> {:?}", offset, full_path, target_path);
 372             hardlink(&target_path, &full_path)?;
 373             return Ok(());
 374         }
 375
 376         check_ca_header::<CaFormatEntry>(&head, CA_FORMAT_ENTRY)?;
 377         let entry: CaFormatEntry = self.read_item()?;
 378
 379
 380         let mode = entry.mode as u32; //fixme: upper 32bits?
 381
 382         let ifmt = mode & libc::S_IFMT;
 383
 384         if ifmt == libc::S_IFDIR {
 385             let dir;
 386             if filename.is_empty() {
 387                 dir = nix::dir::Dir::openat(parent_fd, ".", OFlag::O_DIRECTORY,  Mode::empty())?;
 388              } else {
 389                 dir = match dir_mkdirat(parent_fd, filename, true) {
 390                     Ok(dir) => dir,
 391                     Err(err) => bail!("unable to open directory {:?} - {}", full_path, err),
 392                 };
 393             }
 394
 395             self.restore_ugid(&entry, dir.as_raw_fd())?;
 396             // fcaps have to be restored after restore_ugid as chown clears security.capability xattr, see CVE-2015-1350
 397             let mut head = match self.restore_attributes(&entry, dir.as_raw_fd()) {
 398                 Ok(head) => head,
 399                 Err(err) => bail!("Restoring of directory attributes failed - {}", err),
 400             };
 401
 402             while head.htype == CA_FORMAT_FILENAME {
 403                 let name = self.read_filename(head.size)?;
 404                 relative_path.push(&name);
 405                 self.restore_sequential(base_path, relative_path, &name, &dir, callback)?;
 406                 relative_path.pop();
 407
 408                 head = self.read_item()?;
 409             }
 410
 411             if head.htype != CA_FORMAT_GOODBYE {
 412                 bail!("got unknown header type inside directory entry {:016x}", head.htype);
 413             }
 414
 415             //println!("Skip Goodbye");
 416             if head.size < HEADER_SIZE { bail!("detected short goodbye table"); }
 417
 418             self.skip_bytes((head.size - HEADER_SIZE) as usize)?;
 419
 420             self.restore_mode(&entry, dir.as_raw_fd())?;
 421             self.restore_mtime(&entry, dir.as_raw_fd())?;
 422
 423             return Ok(());
 424         }
 425
 426         if filename.is_empty() {
 427             bail!("got empty file name at {:?}", full_path)
 428         }
 429
 430         if ifmt == libc::S_IFLNK {
 431             // fixme: create symlink
 432             //fixme: restore permission, acls, xattr, ...
 433
 434             let head: CaFormatHeader = self.read_item()?;
 435             match head.htype {
 436                 CA_FORMAT_SYMLINK => {
 437                     let target = self.read_link(head.size)?;
 438                     //println!("TARGET: {:?}", target);
 439                     if let Err(err) = symlinkat(&target, parent_fd, filename) {
 440                         bail!("create symlink {:?} failed - {}", full_path, err);
 441                     }
 442                 }
 443                  _ => {
 444                      bail!("got unknown header type inside symlink entry {:016x}", head.htype);
 445                  }
 446             }
 447
 448             // self.restore_mode_at(&entry, parent_fd, filename)?; //not supported on symlinks
 449             self.restore_ugid_at(&entry, parent_fd, filename)?;
 450             self.restore_mtime_at(&entry, parent_fd, filename)?;
 451
 452             return Ok(());
 453         }
 454
 455         if ifmt == libc::S_IFSOCK  {
 456
 457             self.restore_socket_at(parent_fd, filename)?;
 458
 459             self.restore_mode_at(&entry, parent_fd, filename)?;
 460             self.restore_ugid_at(&entry, parent_fd, filename)?;
 461             self.restore_mtime_at(&entry, parent_fd, filename)?;
 462
 463             return Ok(());
 464         }
 465
 466         if ifmt == libc::S_IFIFO  {
 467
 468             self.restore_fifo_at(parent_fd, filename)?;
 469
 470             self.restore_mode_at(&entry, parent_fd, filename)?;
 471             self.restore_ugid_at(&entry, parent_fd, filename)?;
 472             self.restore_mtime_at(&entry, parent_fd, filename)?;
 473
 474             return Ok(());
 475         }
 476
 477         if (ifmt == libc::S_IFBLK) || (ifmt == libc::S_IFCHR)  {
 478
 479             let head: CaFormatHeader = self.read_item()?;
 480             match head.htype {
 481                 CA_FORMAT_DEVICE => {
 482                     let device: CaFormatDevice = self.read_item()?;
 483                     self.restore_device_at(&entry, parent_fd, filename, &device)?;
 484                 }
 485                 _ => {
 486                     bail!("got unknown header type inside device entry {:016x}", head.htype);
 487                 }
 488             }
 489
 490             self.restore_mode_at(&entry, parent_fd, filename)?;
 491             self.restore_ugid_at(&entry, parent_fd, filename)?;
 492             self.restore_mtime_at(&entry, parent_fd, filename)?;
 493
 494             return Ok(());
 495         }
 496
 497         if ifmt == libc::S_IFREG {
 498
 499             let mut read_buffer: [u8; 64*1024] = unsafe { std::mem::uninitialized() };
 500
 501             let flags = OFlag::O_CREAT|OFlag::O_WRONLY|OFlag::O_EXCL;
 502             let open_mode =  Mode::from_bits_truncate(0o0600 | mode);
 503
 504             let mut file = match file_openat(parent_fd, filename, flags, open_mode) {
 505                 Ok(file) => file,
 506                 Err(err) => bail!("open file {:?} failed - {}", full_path, err),
 507             };
 508
 509             self.restore_ugid(&entry, file.as_raw_fd())?;
 510             // fcaps have to be restored after restore_ugid as chown clears security.capability xattr, see CVE-2015-1350
 511             let head = match self.restore_attributes(&entry, file.as_raw_fd()) {
 512                 Ok(head) => head,
 513                 Err(err) => bail!("Restoring of file attributes failed - {}", err),
 514             };
 515
 516             if head.htype != CA_FORMAT_PAYLOAD {
 517                   bail!("got unknown header type for file entry {:016x}", head.htype);
 518             }
 519
 520             if head.size < HEADER_SIZE {
 521                 bail!("detected short payload");
 522             }
 523             let need = (head.size - HEADER_SIZE) as usize;
 524             //self.reader.seek(SeekFrom::Current(need as i64))?;
 525
 526             let mut done = 0;
 527             while done < need  {
 528                 let todo = need - done;
 529                 let n = if todo > read_buffer.len() { read_buffer.len() } else { todo };
 530                 let data = &mut read_buffer[..n];
 531                 self.reader.read_exact(data)?;
 532                 file.write_all(data)?;
 533                 done += n;
 534             }
 535
 536             self.restore_mode(&entry, file.as_raw_fd())?;
 537             self.restore_mtime(&entry, file.as_raw_fd())?;
 538
 539             return Ok(());
 540         }
 541
 542         Ok(())
 543     }
 544
 545     /// List/Dump archive content.
 546     ///
 547     /// Simply print the list of contained files. This dumps archive
 548     /// format details when the verbose flag is set (useful for debug).
 549     pub fn dump_entry<W: std::io::Write>(
 550         &mut self,
 551         path: &mut PathBuf,
 552         verbose: bool,
 553         output: &mut W,
 554     ) -> Result<(), Error> {
 555
 556         let print_head = |head: &CaFormatHeader| {
 557             println!("Type: {:016x}", head.htype);
 558             println!("Size: {}", head.size);
 559         };
 560
 561         let head: CaFormatHeader = self.read_item()?;
 562         if verbose {
 563             println!("Path: {:?}", path);
 564             print_head(&head);
 565         } else {
 566             println!("{:?}", path);
 567         }
 568
 569         if head.htype == PXAR_FORMAT_HARDLINK {
 570             let (target, offset) = self.read_hardlink(head.size)?;
 571             if verbose {
 572                 println!("Hardlink: {} {:?}", offset, target);
 573             }
 574             return Ok(());
 575         }
 576
 577         check_ca_header::<CaFormatEntry>(&head, CA_FORMAT_ENTRY)?;
 578         let entry: CaFormatEntry = self.read_item()?;
 579
 580         if verbose {
 581             println!("Mode: {:08x} {:08x}", entry.mode, (entry.mode as u32) & libc::S_IFDIR);
 582         }
 583         // fixme: dump attributes (ACLs, ...)
 584
 585         let ifmt = (entry.mode as u32) & libc::S_IFMT;
 586
 587         if ifmt == libc::S_IFDIR {
 588
 589             let mut entry_count = 0;
 590
 591             loop {
 592                 let head: CaFormatHeader = self.read_item()?;
 593                 if verbose {
 594                     print_head(&head);
 595                 }
 596                 match head.htype {
 597                     //TODO verify the correct order of occurrence
 598                     CA_FORMAT_XATTR => {
 599                         let size = (head.size - HEADER_SIZE) as usize;
 600                         let xattr: CaFormatXAttr = self.read_xattr(size)?;
 601                         if verbose {
 602                             println!("XAttr: {:?}: {:?}", String::from_utf8_lossy(&xattr.name), String::from_utf8_lossy(&xattr.value));
 603                         }
 604                     }
 605                     CA_FORMAT_FCAPS => {
 606                         let size = (head.size - HEADER_SIZE) as usize;
 607                         let fcaps: CaFormatFCaps = self.read_fcaps(size)?;
 608                         if verbose {
 609                             println!("FCaps: {:?}", fcaps);
 610                         }
 611                     }
 612                     CA_FORMAT_FILENAME =>  {
 613                         let name = self.read_filename(head.size)?;
 614                         if verbose { println!("Name: {:?}", name); }
 615                         entry_count += 1;
 616                         path.push(&name);
 617                         self.dump_entry(path, verbose, output)?;
 618                         path.pop();
 619                     }
 620                     CA_FORMAT_GOODBYE => {
 621                         let table_size = (head.size - HEADER_SIZE) as usize;
 622                         if verbose {
 623                             println!("Goodbye: {:?}", path);
 624                             self.dump_goodby_entries(entry_count, table_size)?;
 625                         } else {
 626                             self.skip_bytes(table_size)?;
 627                         }
 628                         break;
 629                     }
 630                     _ => {
 631                         panic!("got unexpected header type inside directory");
 632                     }
 633                 }
 634             }
 635         } else if (ifmt == libc::S_IFBLK) || (ifmt == libc::S_IFCHR) ||
 636             (ifmt == libc::S_IFLNK) || (ifmt == libc::S_IFREG)
 637         {
 638             loop {
 639                 let head: CaFormatHeader = self.read_item()?;
 640                 if verbose {
 641                     print_head(&head);
 642                 }
 643
 644                 match head.htype {
 645
 646                     CA_FORMAT_SYMLINK => {
 647                         let target = self.read_link(head.size)?;
 648                         if verbose {
 649                             println!("Symlink: {:?}", target);
 650                         }
 651                         break;
 652                     }
 653                     CA_FORMAT_DEVICE => {
 654                         let device: CaFormatDevice = self.read_item()?;
 655                         if verbose {
 656                             println!("Device: {}, {}", device.major, device.minor);
 657                         }
 658                         break;
 659                     }
 660                     CA_FORMAT_XATTR => {
 661                         let size = (head.size - HEADER_SIZE) as usize;
 662                         let xattr: CaFormatXAttr = self.read_xattr(size)?;
 663                         if verbose {
 664                             println!("XAttr: {:?}: {:?}", String::from_utf8_lossy(&xattr.name), String::from_utf8_lossy(&xattr.value));
 665                         }
 666                     }
 667                     CA_FORMAT_FCAPS => {
 668                         let size = (head.size - HEADER_SIZE) as usize;
 669                         let fcaps: CaFormatFCaps = self.read_fcaps(size)?;
 670                         if verbose {
 671                             println!("FCaps: {:?}", fcaps);
 672                         }
 673                     }
 674                     CA_FORMAT_PAYLOAD => {
 675                         let payload_size = (head.size - HEADER_SIZE) as usize;
 676                         if verbose {
 677                             println!("Payload: {}", payload_size);
 678                         }
 679                         self.skip_bytes(payload_size)?;
 680                         break;
 681                     }
 682                     _ => {
 683                         panic!("got unexpected header type inside non-directory");
 684                     }
 685                 }
 686             }
 687         } else if ifmt == libc::S_IFIFO {
 688             if verbose {
 689                 println!("Fifo:");
 690             }
 691         } else if ifmt == libc::S_IFSOCK {
 692             if verbose {
 693                 println!("Socket:");
 694             }
 695         } else {
 696             panic!("unknown st_mode");
 697         }
 698         Ok(())
 699     }
 700
 701     fn dump_goodby_entries(
 702         &mut self,
 703         entry_count: usize,
 704         table_size: usize,
 705     ) -> Result<(), Error> {
 706
 707         const GOODBYE_ITEM_SIZE: usize = std::mem::size_of::<CaFormatGoodbyeItem>();
 708
 709         if table_size < GOODBYE_ITEM_SIZE {
 710             bail!("Goodbye table to small ({} < {})", table_size, GOODBYE_ITEM_SIZE);
 711         }
 712         if (table_size % GOODBYE_ITEM_SIZE) != 0 {
 713             bail!("Goodbye table with strange size ({})", table_size);
 714         }
 715
 716         let entries = table_size / GOODBYE_ITEM_SIZE;
 717
 718         if entry_count != (entries - 1) {
 719             bail!("Goodbye table with wrong entry count ({} != {})", entry_count, entries - 1);
 720         }
 721
 722         let mut count = 0;
 723
 724         loop {
 725             let item: CaFormatGoodbyeItem = self.read_item()?;
 726             count += 1;
 727             if item.hash == CA_FORMAT_GOODBYE_TAIL_MARKER {
 728                 if count != entries {
 729                     bail!("unexpected goodbye tail marker");
 730                 }
 731                 println!("Goodby tail mark.");
 732                 break;
 733             }
 734             println!("Goodby item: offset {}, size {}, hash {:016x}", item.offset, item.size, item.hash);
 735             if count >= entries {
 736                 bail!("too many goodbye items (no tail marker)");
 737             }
 738         }
 739
 740         Ok(())
 741     }
 742 }
 743
 744 fn file_openat(parent: RawFd, filename: &OsStr, flags: OFlag, mode: Mode) -> Result<std::fs::File, Error> {
 745
 746     let fd = filename.with_nix_path(|cstr| {
 747         nix::fcntl::openat(parent, cstr.as_ref(), flags, mode)
 748     })??;
 749
 750     let file = unsafe { std::fs::File::from_raw_fd(fd) };
 751
 752     Ok(file)
 753 }
 754
 755 fn dir_mkdirat(parent: RawFd, filename: &OsStr, create_new: bool) -> Result<nix::dir::Dir, nix::Error> {
 756
 757     // call mkdirat first
 758     let res = filename.with_nix_path(|cstr| unsafe {
 759         libc::mkdirat(parent, cstr.as_ptr(), libc::S_IRWXU)
 760     })?;
 761
 762     match Errno::result(res) {
 763         Ok(_) => {},
 764         Err(err) => {
 765             if err == nix::Error::Sys(nix::errno::Errno::EEXIST) {
 766                 if create_new { return Err(err); }
 767             } else {
 768                 return Err(err);
 769             }
 770         }
 771     }
 772
 773     let dir = nix::dir::Dir::openat(parent, filename, OFlag::O_DIRECTORY,  Mode::empty())?;
 774
 775     Ok(dir)
 776 }
 777
 778 fn hardlink(oldpath: &Path, newpath: &Path) -> Result<(), Error> {
 779     oldpath.with_nix_path(|oldpath| {
 780         newpath.with_nix_path(|newpath| {
 781             let res = unsafe { libc::link(oldpath.as_ptr(), newpath.as_ptr()) };
 782             Errno::result(res)?;
 783             Ok(())
 784         })?
 785     })?
 786 }
 787
 788 fn symlinkat(target: &Path, parent: RawFd, linkname: &OsStr) -> Result<(), Error> {
 789
 790     target.with_nix_path(|target| {
 791         linkname.with_nix_path(|linkname| {
 792             let res = unsafe { libc::symlinkat(target.as_ptr(), parent, linkname.as_ptr()) };
 793             Errno::result(res)?;
 794             Ok(())
 795         })?
 796     })?
 797 }
 798
 799 fn nsec_to_update_timespec(mtime_nsec: u64) -> [libc::timespec; 2] {
 800
 801     // restore mtime
 802     const UTIME_OMIT: i64 = ((1 << 30) - 2);
 803     const NANOS_PER_SEC: i64 = 1_000_000_000;
 804
 805     let sec = (mtime_nsec as i64) / NANOS_PER_SEC;
 806     let nsec = (mtime_nsec as i64) % NANOS_PER_SEC;
 807
 808     let times: [libc::timespec; 2] = [
 809         libc::timespec { tv_sec: 0, tv_nsec: UTIME_OMIT },
 810         libc::timespec { tv_sec: sec, tv_nsec: nsec },
 811     ];
 812
 813     times
 814 }