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 // This one need Read, but works without Seek
  25 pub struct SequentialDecoder<'a, R: Read> {
  26     reader: &'a mut R,
  27     skip_buffer: Vec<u8>,
  28 }
  29
  30 const HEADER_SIZE: u64 = std::mem::size_of::<CaFormatHeader>() as u64;
  31
  32 impl <'a, R: Read> SequentialDecoder<'a, R> {
  33
  34     pub fn new(reader: &'a mut R) -> Self {
  35         let skip_buffer = vec![0u8; 64*1024];
  36         Self { reader, skip_buffer }
  37     }
  38
  39     pub (crate) fn get_reader_mut(&mut self) -> & mut R {
  40         self.reader
  41     }
  42
  43     pub (crate) fn read_item<T: Endian>(&mut self) -> Result<T, Error> {
  44
  45         let mut result: T = unsafe { std::mem::uninitialized() };
  46
  47         let buffer = unsafe { std::slice::from_raw_parts_mut(
  48             &mut result as *mut T as *mut u8,
  49             std::mem::size_of::<T>()
  50         )};
  51
  52         self.reader.read_exact(buffer)?;
  53
  54         Ok(result.from_le())
  55     }
  56
  57     fn read_symlink(&mut self, size: u64) -> Result<PathBuf, Error> {
  58         if size < (HEADER_SIZE + 2) {
  59              bail!("dectected short symlink target.");
  60         }
  61         let target_len = size - HEADER_SIZE;
  62
  63         if target_len > (libc::PATH_MAX as u64) {
  64             bail!("symlink target too long ({}).", target_len);
  65         }
  66
  67         let mut buffer = vec![0u8; target_len as usize];
  68         self.reader.read_exact(&mut buffer)?;
  69
  70         let last_byte = buffer.pop().unwrap();
  71         if last_byte != 0u8 {
  72             bail!("symlink target not nul terminated.");
  73         }
  74
  75         Ok(PathBuf::from(std::ffi::OsString::from_vec(buffer)))
  76     }
  77
  78     pub (crate) fn read_filename(&mut self, size: u64) -> Result<OsString, Error> {
  79         if size < (HEADER_SIZE + 2) {
  80             bail!("dectected short filename");
  81         }
  82         let name_len = size - HEADER_SIZE;
  83
  84         if name_len > ((libc::FILENAME_MAX as u64) + 1) {
  85             bail!("filename too long ({}).", name_len);
  86         }
  87
  88         let mut buffer = vec![0u8; name_len as usize];
  89         self.reader.read_exact(&mut buffer)?;
  90
  91         let last_byte = buffer.pop().unwrap();
  92         if last_byte != 0u8 {
  93             bail!("filename entry not nul terminated.");
  94         }
  95
  96         if (buffer.len() == 1 && buffer[0] == b'.') || (buffer.len() == 2 && buffer[0] == b'.' && buffer[1] == b'.') {
  97             bail!("found invalid filename with slashes.");
  98         }
  99
 100         if buffer.iter().find(|b| (**b == b'/')).is_some() {
 101             bail!("found invalid filename with slashes.");
 102         }
 103
 104         let name = std::ffi::OsString::from_vec(buffer);
 105         if name.is_empty() {
 106             bail!("found empty filename.");
 107         }
 108
 109         Ok(name)
 110     }
 111
 112     fn restore_attributes(&mut self, _entry: &CaFormatEntry) -> Result<CaFormatHeader, Error> {
 113
 114         loop {
 115             let head: CaFormatHeader = self.read_item()?;
 116             match head.htype {
 117                 // fimxe: impl ...
 118                 _ => return Ok(head),
 119             }
 120         }
 121     }
 122
 123     fn restore_mode(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 124
 125         let mode = Mode::from_bits_truncate((entry.mode as u32) & 0o7777);
 126
 127         nix::sys::stat::fchmod(fd, mode)?;
 128
 129         Ok(())
 130     }
 131
 132     fn restore_mode_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 133
 134         let mode = Mode::from_bits_truncate((entry.mode as u32) & 0o7777);
 135
 136         // NOTE: we want :FchmodatFlags::NoFollowSymlink, but fchmodat does not support that
 137         // on linux (see man fchmodat). Fortunately, we can simply avoid calling this on symlinks.
 138         nix::sys::stat::fchmodat(Some(dirfd), filename, mode, nix::sys::stat::FchmodatFlags::FollowSymlink)?;
 139
 140         Ok(())
 141     }
 142
 143     fn restore_ugid(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 144
 145         let uid = entry.uid as u32;
 146         let gid = entry.gid as u32;
 147
 148         let res = unsafe { libc::fchown(fd, uid, gid) };
 149         Errno::result(res)?;
 150
 151         Ok(())
 152     }
 153
 154     fn restore_ugid_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd,  filename: &OsStr) -> Result<(), Error> {
 155
 156         let uid = entry.uid as u32;
 157         let gid = entry.gid as u32;
 158
 159         let res = filename.with_nix_path(|cstr| unsafe {
 160             libc::fchownat(dirfd, cstr.as_ptr(), uid, gid, libc::AT_SYMLINK_NOFOLLOW)
 161         })?;
 162         Errno::result(res)?;
 163
 164         Ok(())
 165     }
 166
 167     fn restore_mtime(&mut self, entry: &CaFormatEntry, fd: RawFd) -> Result<(), Error> {
 168
 169         let times = nsec_to_update_timespec(entry.mtime);
 170
 171         let res = unsafe { libc::futimens(fd, &times[0]) };
 172         Errno::result(res)?;
 173
 174         Ok(())
 175     }
 176
 177     fn restore_mtime_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 178
 179         let times = nsec_to_update_timespec(entry.mtime);
 180
 181         let res =  filename.with_nix_path(|cstr| unsafe {
 182             libc::utimensat(dirfd, cstr.as_ptr(), &times[0],  libc::AT_SYMLINK_NOFOLLOW)
 183         })?;
 184         Errno::result(res)?;
 185
 186         Ok(())
 187     }
 188
 189     fn restore_device_at(&mut self, entry: &CaFormatEntry, dirfd: RawFd, filename: &OsStr, device: &CaFormatDevice) -> Result<(), Error> {
 190
 191         let rdev = nix::sys::stat::makedev(device.major, device.minor);
 192         let mode = ((entry.mode as u32) & libc::S_IFMT) | 0o0600;
 193         let res =  filename.with_nix_path(|cstr| unsafe {
 194             libc::mknodat(dirfd, cstr.as_ptr(), mode, rdev)
 195         })?;
 196         Errno::result(res)?;
 197
 198         Ok(())
 199     }
 200
 201     fn restore_socket_at(&mut self, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 202
 203         let mode = libc::S_IFSOCK | 0o0600;
 204         let res =  filename.with_nix_path(|cstr| unsafe {
 205             libc::mknodat(dirfd, cstr.as_ptr(), mode, 0)
 206         })?;
 207         Errno::result(res)?;
 208
 209         Ok(())
 210     }
 211
 212     fn restore_fifo_at(&mut self, dirfd: RawFd, filename: &OsStr) -> Result<(), Error> {
 213
 214         let mode = libc::S_IFIFO | 0o0600;
 215         let res =  filename.with_nix_path(|cstr| unsafe {
 216             libc::mkfifoat(dirfd, cstr.as_ptr(), mode)
 217         })?;
 218         Errno::result(res)?;
 219
 220         Ok(())
 221     }
 222
 223     fn skip_bytes(&mut self, count: usize) -> Result<(), Error> {
 224         let mut done = 0;
 225         while done < count  {
 226             let todo = count - done;
 227             let n = if todo > self.skip_buffer.len() { self.skip_buffer.len() } else { todo };
 228             let data = &mut self.skip_buffer[..n];
 229             self.reader.read_exact(data)?;
 230             done += n;
 231         }
 232         Ok(())
 233     }
 234
 235     /// Restore an archive into the specified directory.
 236     ///
 237     /// The directory is created if it does not exist.
 238     pub fn restore<F>(
 239         &mut self,
 240         path: &Path,
 241         callback: &F,
 242     ) -> Result<(), Error>
 243         where F: Fn(&Path) -> Result<(), Error>
 244     {
 245
 246         let _ = std::fs::create_dir(path);
 247
 248         let dir = match nix::dir::Dir::open(path, nix::fcntl::OFlag::O_DIRECTORY,  nix::sys::stat::Mode::empty()) {
 249             Ok(dir) => dir,
 250             Err(err) => bail!("unable to open target directory {:?} - {}", path, err),
 251         };
 252
 253         self.restore_sequential(&mut path.to_owned(), &OsString::new(), &dir, callback)
 254     }
 255
 256     fn restore_sequential<F>(
 257         &mut self,
 258         path: &mut PathBuf, // used for error reporting
 259         filename: &OsStr,  // repeats path last component
 260         parent: &nix::dir::Dir,
 261         callback: &F,
 262     ) -> Result<(), Error>
 263         where F: Fn(&Path) -> Result<(), Error>
 264     {
 265
 266         let parent_fd = parent.as_raw_fd();
 267
 268         // read ENTRY first
 269         let head: CaFormatHeader = self.read_item()?;
 270         check_ca_header::<CaFormatEntry>(&head, CA_FORMAT_ENTRY)?;
 271         let entry: CaFormatEntry = self.read_item()?;
 272
 273         (callback)(path)?;
 274
 275         let mode = entry.mode as u32; //fixme: upper 32bits?
 276
 277         let ifmt = mode & libc::S_IFMT;
 278
 279         if ifmt == libc::S_IFDIR {
 280             let dir;
 281             if filename.is_empty() {
 282                 dir = nix::dir::Dir::openat(parent_fd, ".", OFlag::O_DIRECTORY,  Mode::empty())?;
 283              } else {
 284                 dir = match dir_mkdirat(parent_fd, filename, true) {
 285                     Ok(dir) => dir,
 286                     Err(err) => bail!("unable to open directory {:?} - {}", path, err),
 287                 };
 288             }
 289
 290             let mut head = self.restore_attributes(&entry)?;
 291
 292             while head.htype == CA_FORMAT_FILENAME {
 293                 let name = self.read_filename(head.size)?;
 294                 path.push(&name);
 295                 //println!("NAME: {:?}", path);
 296                 self.restore_sequential(path, &name, &dir, callback)?;
 297                 path.pop();
 298
 299                 head = self.read_item()?;
 300             }
 301
 302             if head.htype != CA_FORMAT_GOODBYE {
 303                 bail!("got unknown header type inside directory entry {:016x}", head.htype);
 304             }
 305
 306             //println!("Skip Goodbye");
 307             if head.size < HEADER_SIZE { bail!("detected short goodbye table"); }
 308
 309             self.skip_bytes((head.size - HEADER_SIZE) as usize)?;
 310
 311             self.restore_mode(&entry, dir.as_raw_fd())?;
 312             self.restore_mtime(&entry, dir.as_raw_fd())?;
 313             self.restore_ugid(&entry, dir.as_raw_fd())?;
 314
 315             return Ok(());
 316         }
 317
 318         if filename.is_empty() {
 319             bail!("got empty file name at {:?}", path)
 320         }
 321
 322         if ifmt == libc::S_IFLNK {
 323             // fixme: create symlink
 324             //fixme: restore permission, acls, xattr, ...
 325
 326             let head: CaFormatHeader = self.read_item()?;
 327             match head.htype {
 328                 CA_FORMAT_SYMLINK => {
 329                     let target = self.read_symlink(head.size)?;
 330                     //println!("TARGET: {:?}", target);
 331                     if let Err(err) = symlinkat(&target, parent_fd, filename) {
 332                         bail!("create symlink {:?} failed - {}", path, err);
 333                     }
 334                 }
 335                  _ => {
 336                      bail!("got unknown header type inside symlink entry {:016x}", head.htype);
 337                  }
 338             }
 339
 340             // self.restore_mode_at(&entry, parent_fd, filename)?; //not supported on symlinks
 341             self.restore_ugid_at(&entry, parent_fd, filename)?;
 342             self.restore_mtime_at(&entry, parent_fd, filename)?;
 343
 344             return Ok(());
 345         }
 346
 347         if ifmt == libc::S_IFSOCK  {
 348
 349             self.restore_socket_at(parent_fd, filename)?;
 350
 351             self.restore_mode_at(&entry, parent_fd, filename)?;
 352             self.restore_ugid_at(&entry, parent_fd, filename)?;
 353             self.restore_mtime_at(&entry, parent_fd, filename)?;
 354
 355             return Ok(());
 356         }
 357
 358         if ifmt == libc::S_IFIFO  {
 359
 360             self.restore_fifo_at(parent_fd, filename)?;
 361
 362             self.restore_mode_at(&entry, parent_fd, filename)?;
 363             self.restore_ugid_at(&entry, parent_fd, filename)?;
 364             self.restore_mtime_at(&entry, parent_fd, filename)?;
 365
 366             return Ok(());
 367         }
 368
 369         if (ifmt == libc::S_IFBLK) || (ifmt == libc::S_IFCHR)  {
 370
 371             let head: CaFormatHeader = self.read_item()?;
 372             match head.htype {
 373                 CA_FORMAT_DEVICE => {
 374                     let device: CaFormatDevice = self.read_item()?;
 375                     self.restore_device_at(&entry, parent_fd, filename, &device)?;
 376                 }
 377                 _ => {
 378                     bail!("got unknown header type inside device entry {:016x}", head.htype);
 379                 }
 380             }
 381
 382             self.restore_mode_at(&entry, parent_fd, filename)?;
 383             self.restore_ugid_at(&entry, parent_fd, filename)?;
 384             self.restore_mtime_at(&entry, parent_fd, filename)?;
 385
 386             return Ok(());
 387         }
 388
 389         if ifmt == libc::S_IFREG {
 390
 391             let mut read_buffer: [u8; 64*1024] = unsafe { std::mem::uninitialized() };
 392
 393             let flags = OFlag::O_CREAT|OFlag::O_WRONLY|OFlag::O_EXCL;
 394             let open_mode =  Mode::from_bits_truncate(0o0600 | mode);
 395
 396             let mut file = match file_openat(parent_fd, filename, flags, open_mode) {
 397                 Ok(file) => file,
 398                 Err(err) => bail!("open file {:?} failed - {}", path, err),
 399             };
 400
 401             let head = self.restore_attributes(&entry)?;
 402
 403             if head.htype != CA_FORMAT_PAYLOAD {
 404                   bail!("got unknown header type for file entry {:016x}", head.htype);
 405             }
 406
 407             if head.size < HEADER_SIZE {
 408                 bail!("detected short payload");
 409             }
 410             let need = (head.size - HEADER_SIZE) as usize;
 411             //self.reader.seek(SeekFrom::Current(need as i64))?;
 412
 413             let mut done = 0;
 414             while done < need  {
 415                 let todo = need - done;
 416                 let n = if todo > read_buffer.len() { read_buffer.len() } else { todo };
 417                 let data = &mut read_buffer[..n];
 418                 self.reader.read_exact(data)?;
 419                 file.write_all(data)?;
 420                 done += n;
 421             }
 422
 423             self.restore_mode(&entry, file.as_raw_fd())?;
 424             self.restore_mtime(&entry, file.as_raw_fd())?;
 425             self.restore_ugid(&entry, file.as_raw_fd())?;
 426
 427             return Ok(());
 428         }
 429
 430         Ok(())
 431     }
 432
 433     /// List/Dump archive content.
 434     ///
 435     /// Simply print the list of contained files. This dumps archive
 436     /// format details when the verbose flag is set (useful for debug).
 437     pub fn dump_entry<W: std::io::Write>(
 438         &mut self,
 439         path: &mut PathBuf,
 440         verbose: bool,
 441         output: &mut W,
 442     ) -> Result<(), Error> {
 443
 444         let print_head = |head: &CaFormatHeader| {
 445             println!("Type: {:016x}", head.htype);
 446             println!("Size: {}", head.size);
 447         };
 448
 449         let head: CaFormatHeader = self.read_item()?;
 450         if verbose {
 451             println!("Path: {:?}", path);
 452             print_head(&head);
 453         } else {
 454             println!("{:?}", path);
 455         }
 456
 457         check_ca_header::<CaFormatEntry>(&head, CA_FORMAT_ENTRY)?;
 458         let entry: CaFormatEntry = self.read_item()?;
 459
 460         if verbose {
 461             println!("Mode: {:08x} {:08x}", entry.mode, (entry.mode as u32) & libc::S_IFDIR);
 462         }
 463         // fixme: dump attributes (ACLs, ...)
 464
 465         let ifmt = (entry.mode as u32) & libc::S_IFMT;
 466
 467         if ifmt == libc::S_IFDIR {
 468
 469             let mut entry_count = 0;
 470
 471             loop {
 472                 let head: CaFormatHeader = self.read_item()?;
 473                 if verbose {
 474                     print_head(&head);
 475                 }
 476                 match head.htype {
 477
 478                     CA_FORMAT_FILENAME =>  {
 479                         let name = self.read_filename(head.size)?;
 480                         if verbose { println!("Name: {:?}", name); }
 481                         entry_count += 1;
 482                         path.push(&name);
 483                         self.dump_entry(path, verbose, output)?;
 484                         path.pop();
 485                     }
 486                     CA_FORMAT_GOODBYE => {
 487                         let table_size = (head.size - HEADER_SIZE) as usize;
 488                         if verbose {
 489                             println!("Goodbye: {:?}", path);
 490                             self.dump_goodby_entries(entry_count, table_size)?;
 491                         } else {
 492                             self.skip_bytes(table_size)?;
 493                         }
 494                         break;
 495                     }
 496                     _ => {
 497                         panic!("got unexpected header type inside directory");
 498                     }
 499                 }
 500             }
 501         } else {
 502
 503             let head: CaFormatHeader = self.read_item()?;
 504             if verbose {
 505                 print_head(&head);
 506             }
 507
 508             match head.htype {
 509
 510                 CA_FORMAT_SYMLINK => {
 511                     let target = self.read_symlink(head.size)?;
 512                     if verbose {
 513                         println!("Symlink: {:?}", target);
 514                     }
 515                 }
 516                 CA_FORMAT_DEVICE => {
 517                     let device: CaFormatDevice = self.read_item()?;
 518                     if verbose {
 519                         println!("Device: {}, {}", device.major, device.minor);
 520                     }
 521                 }
 522                 CA_FORMAT_PAYLOAD => {
 523                     let payload_size = (head.size - HEADER_SIZE) as usize;
 524                     if verbose {
 525                         println!("Payload: {}", payload_size);
 526                     }
 527                     self.skip_bytes(payload_size)?;
 528                 }
 529                 _ => {
 530                     panic!("got unexpected header type inside non-directory");
 531                 }
 532             }
 533         }
 534
 535         Ok(())
 536     }
 537
 538     fn dump_goodby_entries(
 539         &mut self,
 540         entry_count: usize,
 541         table_size: usize,
 542     ) -> Result<(), Error> {
 543
 544         let item_size = std::mem::size_of::<CaFormatGoodbyeItem>();
 545         if table_size < item_size {
 546             bail!("Goodbye table to small ({} < {})", table_size, item_size);
 547         }
 548         if (table_size % item_size) != 0 {
 549             bail!("Goodbye table with strange size ({})", table_size);
 550         }
 551
 552         let entries = table_size / item_size;
 553
 554         if entry_count != (entries - 1) {
 555             bail!("Goodbye table with wrong entry count ({} != {})", entry_count, entries - 1);
 556         }
 557
 558         let mut count = 0;
 559
 560         loop {
 561             let item: CaFormatGoodbyeItem = self.read_item()?;
 562             count += 1;
 563             if item.hash == CA_FORMAT_GOODBYE_TAIL_MARKER {
 564                 if count != entries {
 565                     bail!("unexpected goodbye tail marker");
 566                 }
 567                 println!("Goodby tail mark.");
 568                 break;
 569             }
 570             println!("Goodby item: offset {}, size {}, hash {:016x}", item.offset, item.size, item.hash);
 571             if count >= (table_size / item_size) {
 572                 bail!("too many goodbye items (no tail marker)");
 573             }
 574         }
 575
 576         Ok(())
 577     }
 578 }
 579
 580 fn file_openat(parent: RawFd, filename: &OsStr, flags: OFlag, mode: Mode) -> Result<std::fs::File, Error> {
 581
 582     let fd = filename.with_nix_path(|cstr| {
 583         nix::fcntl::openat(parent, cstr.as_ref(), flags, mode)
 584     })??;
 585
 586     let file = unsafe { std::fs::File::from_raw_fd(fd) };
 587
 588     Ok(file)
 589 }
 590
 591 fn dir_mkdirat(parent: RawFd, filename: &OsStr, create_new: bool) -> Result<nix::dir::Dir, nix::Error> {
 592
 593     // call mkdirat first
 594     let res = filename.with_nix_path(|cstr| unsafe {
 595         libc::mkdirat(parent, cstr.as_ptr(), libc::S_IRWXU)
 596     })?;
 597
 598     match Errno::result(res) {
 599         Ok(_) => {},
 600         Err(err) => {
 601             if err == nix::Error::Sys(nix::errno::Errno::EEXIST) {
 602                 if create_new { return Err(err); }
 603             } else {
 604                 return Err(err);
 605             }
 606         }
 607     }
 608
 609     let dir = nix::dir::Dir::openat(parent, filename, OFlag::O_DIRECTORY,  Mode::empty())?;
 610
 611     Ok(dir)
 612 }
 613
 614 fn symlinkat(target: &Path, parent: RawFd, linkname: &OsStr) -> Result<(), Error> {
 615
 616     target.with_nix_path(|target| {
 617         linkname.with_nix_path(|linkname| {
 618             let res = unsafe { libc::symlinkat(target.as_ptr(), parent, linkname.as_ptr()) };
 619             Errno::result(res)?;
 620             Ok(())
 621         })?
 622     })?
 623 }
 624
 625 fn nsec_to_update_timespec(mtime_nsec: u64) -> [libc::timespec; 2] {
 626
 627     // restore mtime
 628     const UTIME_OMIT: i64 = ((1 << 30) - 2);
 629     const NANOS_PER_SEC: i64 = 1_000_000_000;
 630
 631     let sec = (mtime_nsec as i64) / NANOS_PER_SEC;
 632     let nsec = (mtime_nsec as i64) % NANOS_PER_SEC;
 633
 634     let times: [libc::timespec; 2] = [
 635         libc::timespec { tv_sec: 0, tv_nsec: UTIME_OMIT },
 636         libc::timespec { tv_sec: sec, tv_nsec: nsec },
 637     ];
 638
 639     times
 640 }