src/pxar/encoder.rs

   1 //! *pxar* format encoder.
   2 //!
   3 //! This module contain the code to generate *pxar* archive files.
   4
   5 use failure::*;
   6 use endian_trait::Endian;
   7 use std::collections::HashMap;
   8
   9 use super::format_definition::*;
  10 use super::binary_search_tree::*;
  11 use crate::tools::xattr;
  12
  13 use std::io::Write;
  14 use std::os::unix::io::AsRawFd;
  15 use std::os::unix::ffi::OsStrExt;
  16 use std::os::unix::io::RawFd;
  17 use std::path::{Path, PathBuf};
  18
  19 use std::ffi::CStr;
  20
  21 use nix::NixPath;
  22 use nix::fcntl::OFlag;
  23 use nix::sys::stat::Mode;
  24 use nix::errno::Errno;
  25 use nix::sys::stat::FileStat;
  26
  27 /// The format requires to build sorted directory lookup tables in
  28 /// memory, so we restrict the number of allowed entries to limit
  29 /// maximum memory usage.
  30 pub const MAX_DIRECTORY_ENTRIES: usize = 256*1024;
  31
  32 #[derive(Eq, PartialEq, Hash)]
  33 struct HardLinkInfo {
  34     st_dev: u64,
  35     st_ino: u64,
  36 }
  37
  38 pub struct Encoder<'a, W: Write> {
  39     base_path: PathBuf,
  40     relative_path: PathBuf,
  41     writer: &'a mut W,
  42     writer_pos: usize,
  43     _size: usize,
  44     file_copy_buffer: Vec<u8>,
  45     all_file_systems: bool,
  46     root_st_dev: u64,
  47     verbose: bool,
  48     hardlinks: HashMap<HardLinkInfo, (PathBuf, u64)>,
  49 }
  50
  51 impl <'a, W: Write> Encoder<'a, W> {
  52
  53     // used for error reporting
  54     fn full_path(&self) ->  PathBuf {
  55         self.base_path.join(&self.relative_path)
  56     }
  57
  58     pub fn encode(
  59         path: PathBuf,
  60         dir: &mut nix::dir::Dir,
  61         writer: &'a mut W,
  62         all_file_systems: bool,
  63         verbose: bool,
  64     ) -> Result<(), Error> {
  65
  66         const FILE_COPY_BUFFER_SIZE: usize = 1024*1024;
  67
  68         let mut file_copy_buffer = Vec::with_capacity(FILE_COPY_BUFFER_SIZE);
  69         unsafe { file_copy_buffer.set_len(FILE_COPY_BUFFER_SIZE); }
  70
  71
  72         // todo: use scandirat??
  73
  74         let dir_fd = dir.as_raw_fd();
  75         let stat = match nix::sys::stat::fstat(dir_fd) {
  76             Ok(stat) => stat,
  77             Err(err) => bail!("fstat {:?} failed - {}", path, err),
  78         };
  79
  80         if (stat.st_mode & libc::S_IFMT) != libc::S_IFDIR {
  81             bail!("got unexpected file type {:?} (not a directory)", path);
  82         }
  83
  84         let magic = detect_fs_type(dir_fd)?;
  85
  86         if is_virtual_file_system(magic) {
  87             bail!("backup virtual file systems is disabled!");
  88         }
  89
  90         let mut me = Self {
  91             base_path: path,
  92             relative_path: PathBuf::new(),
  93             writer: writer,
  94             writer_pos: 0,
  95             _size: 0,
  96             file_copy_buffer,
  97             all_file_systems,
  98             root_st_dev: stat.st_dev,
  99             verbose,
 100             hardlinks: HashMap::new(),
 101         };
 102
 103         if verbose { println!("{:?}", me.full_path()); }
 104
 105         me.encode_dir(dir, &stat, magic)?;
 106
 107         Ok(())
 108     }
 109
 110     fn write(&mut self,  buf: &[u8]) -> Result<(), Error> {
 111         self.writer.write_all(buf)?;
 112         self.writer_pos += buf.len();
 113         Ok(())
 114     }
 115
 116     fn write_item<T: Endian>(&mut self, item: T) ->  Result<(), Error> {
 117
 118         let data = item.to_le();
 119
 120         let buffer = unsafe { std::slice::from_raw_parts(
 121             &data as *const T as *const u8,
 122             std::mem::size_of::<T>()
 123         )};
 124
 125         self.write(buffer)?;
 126
 127         Ok(())
 128     }
 129
 130     fn flush_copy_buffer(&mut self, size: usize) -> Result<(), Error> {
 131         self.writer.write_all(&self.file_copy_buffer[..size])?;
 132         self.writer_pos += size;
 133         Ok(())
 134     }
 135
 136     fn write_header(&mut self, htype: u64, size: u64) -> Result<(), Error> {
 137
 138         let size = size + (std::mem::size_of::<CaFormatHeader>() as u64);
 139         self.write_item(CaFormatHeader { size, htype })?;
 140
 141         Ok(())
 142     }
 143
 144     fn write_filename(&mut self, name: &CStr) -> Result<(), Error> {
 145
 146         let buffer = name.to_bytes_with_nul();
 147         self.write_header(CA_FORMAT_FILENAME, buffer.len() as u64)?;
 148         self.write(buffer)?;
 149
 150         Ok(())
 151     }
 152
 153     fn create_entry(&self, stat: &FileStat) -> Result<CaFormatEntry, Error> {
 154
 155         let mode = if (stat.st_mode & libc::S_IFMT) == libc::S_IFLNK {
 156             (libc::S_IFLNK | 0o777) as u64
 157         } else {
 158             (stat.st_mode & (libc::S_IFMT | 0o7777)) as u64
 159         };
 160
 161         let mtime = stat.st_mtime * 1_000_000_000 + stat.st_mtime_nsec;
 162         if mtime < 0 {
 163             bail!("got strange mtime ({}) from fstat for {:?}.", mtime, self.full_path());
 164         }
 165
 166
 167         let entry = CaFormatEntry {
 168             feature_flags: CA_FORMAT_DEFAULT, // fixme: ??
 169             mode: mode,
 170             flags: 0,
 171             uid: stat.st_uid as u64,
 172             gid: stat.st_gid as u64,
 173             mtime: mtime as u64,
 174         };
 175
 176         Ok(entry)
 177     }
 178
 179     fn read_chattr(&self, fd: RawFd, entry: &mut CaFormatEntry) -> Result<(), Error> {
 180
 181         let mut attr: usize = 0;
 182
 183         let res = unsafe { read_attr_fd(fd, &mut attr)};
 184         if let Err(err) = res {
 185             if let nix::Error::Sys(errno) = err {
 186                 if errno_is_unsupported(errno) { return Ok(()) };
 187             }
 188             bail!("read_attr_fd failed for {:?} - {}", self.full_path(), err);
 189         }
 190
 191         let flags = ca_feature_flags_from_chattr(attr as u32);
 192         entry.flags = entry.flags | flags;
 193
 194         Ok(())
 195     }
 196
 197     fn read_fat_attr(&self, fd: RawFd, magic: i64, entry: &mut CaFormatEntry) -> Result<(), Error> {
 198
 199         if magic != MSDOS_SUPER_MAGIC && magic != FUSE_SUPER_MAGIC { return Ok(()); }
 200
 201         let mut attr: u32 = 0;
 202
 203         let res = unsafe { read_fat_attr_fd(fd, &mut attr)};
 204         if let Err(err) = res {
 205             if let nix::Error::Sys(errno) = err {
 206                 if errno_is_unsupported(errno) { return Ok(()) };
 207             }
 208             bail!("read_fat_attr_fd failed for {:?} - {}", self.full_path(), err);
 209         }
 210
 211         let flags = ca_feature_flags_from_fat_attr(attr);
 212         entry.flags = entry.flags | flags;
 213
 214         Ok(())
 215     }
 216
 217     fn read_xattrs(&self, fd: RawFd, stat: &FileStat, entry: &CaFormatEntry) -> Result<(Vec<CaFormatXAttr>, Option<CaFormatFCaps>), Error> {
 218         let mut xattrs = Vec::new();
 219         let mut fcaps = None;
 220
 221         let flags = CA_FORMAT_WITH_XATTRS | CA_FORMAT_WITH_FCAPS;
 222         if (entry.feature_flags & flags) == 0 { return Ok((xattrs, fcaps)); }
 223         // Should never be called on symlinks, just in case check anyway
 224         if (stat.st_mode & libc::S_IFMT) == libc::S_IFLNK { return Ok((xattrs, fcaps)); }
 225
 226         let xattr_names = match xattr::flistxattr(fd) {
 227             Ok(names) => names,
 228             Err(Errno::EOPNOTSUPP) => return Ok((xattrs, fcaps)),
 229             Err(Errno::EBADF) => return Ok((xattrs, fcaps)),
 230             Err(err) => bail!("read_xattrs failed for {:?} - {}", self.full_path(), err),
 231         };
 232
 233         for name in xattr_names.split(|c| *c == '\0' as u8) {
 234             // Only extract the relevant extended attributes
 235             if !xattr::name_store(&name) { continue; }
 236
 237             let value = match xattr::fgetxattr(fd, name) {
 238                 Ok(value) => value,
 239                 // Vanished between flistattr and getxattr, this is ok, silently ignore
 240                 Err(Errno::ENODATA) => continue,
 241                 Err(err) => bail!("read_xattrs failed for {:?} - {}", self.full_path(), err),
 242             };
 243
 244             if xattr::security_capability(&name) {
 245                 // fcaps are stored in own format within the archive
 246                 fcaps = Some(CaFormatFCaps {
 247                     data: value,
 248                 });
 249             } else {
 250                 xattrs.push(CaFormatXAttr {
 251                     name: name.to_vec(),
 252                     value: value,
 253                 });
 254             }
 255         }
 256         xattrs.sort();
 257
 258         Ok((xattrs, fcaps))
 259     }
 260
 261     fn write_entry(&mut self, entry: CaFormatEntry) -> Result<(), Error> {
 262
 263         self.write_header(CA_FORMAT_ENTRY, std::mem::size_of::<CaFormatEntry>() as u64)?;
 264         self.write_item(entry)?;
 265
 266         Ok(())
 267     }
 268
 269     fn write_xattr(&mut self, xattr: CaFormatXAttr) -> Result<(), Error> {
 270         let size = xattr.name.len() + xattr.value.len() + 1; // +1 for '\0' separating name and value
 271         self.write_header(CA_FORMAT_XATTR, size as u64)?;
 272         self.write(xattr.name.as_slice())?;
 273         self.write(&[0])?;
 274         self.write(xattr.value.as_slice())?;
 275
 276         Ok(())
 277     }
 278
 279     fn write_fcaps(&mut self, fcaps: Option<CaFormatFCaps>) -> Result<(), Error> {
 280         if let Some(fcaps) = fcaps {
 281             let size = fcaps.data.len();
 282             self.write_header(CA_FORMAT_FCAPS, size as u64)?;
 283             self.write(fcaps.data.as_slice())?;
 284         }
 285
 286         Ok(())
 287     }
 288
 289     fn write_goodbye_table(&mut self, goodbye_offset: usize, goodbye_items: &mut [CaFormatGoodbyeItem]) -> Result<(), Error> {
 290
 291         goodbye_items.sort_unstable_by(|a, b| a.hash.cmp(&b.hash));
 292
 293         let item_count = goodbye_items.len();
 294
 295         let goodbye_table_size = (item_count + 1)*std::mem::size_of::<CaFormatGoodbyeItem>();
 296
 297         self.write_header(CA_FORMAT_GOODBYE, goodbye_table_size as u64)?;
 298
 299         if self.file_copy_buffer.len() < goodbye_table_size {
 300             let need = goodbye_table_size - self.file_copy_buffer.len();
 301             self.file_copy_buffer.reserve(need);
 302             unsafe { self.file_copy_buffer.set_len(self.file_copy_buffer.capacity()); }
 303         }
 304
 305         let buffer = &mut self.file_copy_buffer;
 306
 307         copy_binary_search_tree(item_count, |s, d| {
 308             let item = &goodbye_items[s];
 309             let offset = d*std::mem::size_of::<CaFormatGoodbyeItem>();
 310             let dest = crate::tools::map_struct_mut::<CaFormatGoodbyeItem>(&mut buffer[offset..]).unwrap();
 311             dest.offset = u64::to_le(item.offset);
 312             dest.size = u64::to_le(item.size);
 313             dest.hash = u64::to_le(item.hash);
 314         });
 315
 316         // append CaFormatGoodbyeTail as last item
 317         let offset = item_count*std::mem::size_of::<CaFormatGoodbyeItem>();
 318         let dest = crate::tools::map_struct_mut::<CaFormatGoodbyeItem>(&mut buffer[offset..]).unwrap();
 319         dest.offset = u64::to_le(goodbye_offset as u64);
 320         dest.size = u64::to_le((goodbye_table_size + std::mem::size_of::<CaFormatHeader>()) as u64);
 321         dest.hash = u64::to_le(CA_FORMAT_GOODBYE_TAIL_MARKER);
 322
 323         self.flush_copy_buffer(goodbye_table_size)?;
 324
 325         Ok(())
 326     }
 327
 328     fn encode_dir(&mut self, dir: &mut nix::dir::Dir, dir_stat: &FileStat, magic: i64)  -> Result<(), Error> {
 329
 330         //println!("encode_dir: {:?} start {}", self.full_path(), self.writer_pos);
 331
 332         let mut name_list = vec![];
 333
 334         let rawfd = dir.as_raw_fd();
 335
 336         let dir_start_pos = self.writer_pos;
 337
 338         let mut dir_entry = self.create_entry(&dir_stat)?;
 339
 340         self.read_chattr(rawfd, &mut dir_entry)?;
 341         self.read_fat_attr(rawfd, magic, &mut dir_entry)?;
 342         let (xattrs, fcaps) = self.read_xattrs(rawfd, &dir_stat, &dir_entry)?;
 343
 344         self.write_entry(dir_entry)?;
 345         for xattr in xattrs { self.write_xattr(xattr)?; }
 346         self.write_fcaps(fcaps)?;
 347
 348         let mut dir_count = 0;
 349
 350         let include_children;
 351         if is_virtual_file_system(magic) {
 352             include_children = false;
 353         } else {
 354             include_children = (self.root_st_dev == dir_stat.st_dev) || self.all_file_systems;
 355         }
 356
 357         if include_children {
 358             for entry in dir.iter() {
 359                 dir_count += 1;
 360                 if dir_count > MAX_DIRECTORY_ENTRIES {
 361                     bail!("too many directory items in {:?} (> {})",
 362                           self.full_path(), MAX_DIRECTORY_ENTRIES);
 363                 }
 364
 365                 let entry = match entry {
 366                     Ok(entry) => entry,
 367                     Err(err) => bail!("readir {:?} failed - {}", self.full_path(), err),
 368                 };
 369                 let filename = entry.file_name().to_owned();
 370
 371                 let name = filename.to_bytes_with_nul();
 372                 let name_len = name.len();
 373                 if name_len == 2 && name[0] == b'.' && name[1] == 0u8 { continue; }
 374                 if name_len == 3 && name[0] == b'.' && name[1] == b'.' && name[2] == 0u8 { continue; }
 375
 376                 name_list.push(filename);
 377             }
 378         } else {
 379             eprintln!("skip mount point: {:?}", self.full_path());
 380         }
 381
 382         name_list.sort_unstable_by(|a, b| a.cmp(&b));
 383
 384         let mut goodbye_items = vec![];
 385
 386         for filename in &name_list {
 387             self.relative_path.push(std::ffi::OsStr::from_bytes(filename.as_bytes()));
 388
 389             if self.verbose { println!("{:?}", self.full_path()); }
 390
 391             let stat = match nix::sys::stat::fstatat(rawfd, filename.as_ref(), nix::fcntl::AtFlags::AT_SYMLINK_NOFOLLOW) {
 392                 Ok(stat) => stat,
 393                 Err(nix::Error::Sys(Errno::ENOENT)) => {
 394                     self.report_vanished_file(&self.full_path())?;
 395                     continue;
 396                 }
 397                 Err(err) => bail!("fstat {:?} failed - {}", self.full_path(), err),
 398             };
 399
 400             let start_pos = self.writer_pos;
 401
 402             let ifmt = stat.st_mode & libc::S_IFMT;
 403
 404             if ifmt == libc::S_IFDIR {
 405
 406                 let mut dir = match nix::dir::Dir::openat(rawfd, filename.as_ref(), OFlag::O_DIRECTORY|OFlag::O_NOFOLLOW, Mode::empty()) {
 407                     Ok(dir) => dir,
 408                     Err(nix::Error::Sys(Errno::ENOENT)) => {
 409                         self.report_vanished_file(&self.full_path())?;
 410                         continue; // fixme!!
 411                     },
 412                     Err(err) => bail!("open dir {:?} failed - {}", self.full_path(), err),
 413                 };
 414
 415                 let child_magic = if dir_stat.st_dev != stat.st_dev {
 416                     detect_fs_type(dir.as_raw_fd())?
 417                 } else {
 418                     magic
 419                 };
 420
 421                 self.write_filename(&filename)?;
 422                 self.encode_dir(&mut dir, &stat, child_magic)?;
 423
 424             } else if ifmt == libc::S_IFREG {
 425
 426                 let mut hardlink_target = None;
 427
 428                 if stat.st_nlink > 1 {
 429                     let link_info = HardLinkInfo { st_dev: stat.st_dev, st_ino: stat.st_ino };
 430                     hardlink_target = self.hardlinks.get(&link_info).map(|(v, offset)| {
 431                         let mut target = v.clone().into_os_string();
 432                         target.push("\0"); // add Nul byte
 433                         (target, (start_pos as u64) - offset)
 434                     });
 435                     if hardlink_target == None {
 436                         self.hardlinks.insert(link_info, (self.relative_path.clone(), start_pos as u64));
 437                     }
 438                 }
 439
 440                 if let Some((target, offset)) = hardlink_target {
 441
 442                     self.write_filename(&filename)?;
 443                     self.encode_hardlink(target.as_bytes(), offset)?;
 444
 445                 } else {
 446
 447                     let filefd = match nix::fcntl::openat(rawfd, filename.as_ref(), OFlag::O_NOFOLLOW, Mode::empty()) {
 448                         Ok(filefd) => filefd,
 449                         Err(nix::Error::Sys(Errno::ENOENT)) => {
 450                             self.report_vanished_file(&self.full_path())?;
 451                             continue;
 452                         },
 453                         Err(err) => bail!("open file {:?} failed - {}", self.full_path(), err),
 454                     };
 455
 456                     let child_magic = if dir_stat.st_dev != stat.st_dev {
 457                         detect_fs_type(filefd)?
 458                     } else {
 459                         magic
 460                     };
 461
 462                     self.write_filename(&filename)?;
 463                     let res = self.encode_file(filefd, &stat, child_magic);
 464                     let _ = nix::unistd::close(filefd); // ignore close errors
 465                     res?;
 466                 }
 467
 468             } else if ifmt == libc::S_IFLNK {
 469                 let mut buffer = [0u8; libc::PATH_MAX as usize];
 470
 471                 let res = filename.with_nix_path(|cstr| {
 472                     unsafe { libc::readlinkat(rawfd, cstr.as_ptr(), buffer.as_mut_ptr() as *mut libc::c_char, buffer.len()-1) }
 473                 })?;
 474
 475                 match Errno::result(res) {
 476                     Ok(len) => {
 477                         buffer[len as usize] = 0u8; // add Nul byte
 478                         self.write_filename(&filename)?;
 479                         self.encode_symlink(&buffer[..((len+1) as usize)], &stat)?
 480                     }
 481                     Err(nix::Error::Sys(Errno::ENOENT)) => {
 482                         self.report_vanished_file(&self.full_path())?;
 483                         continue;
 484                     }
 485                     Err(err) => bail!("readlink {:?} failed - {}", self.full_path(), err),
 486                 }
 487             } else if (ifmt == libc::S_IFBLK) || (ifmt == libc::S_IFCHR) {
 488                 self.write_filename(&filename)?;
 489                 self.encode_device(&stat)?;
 490             } else if (ifmt == libc::S_IFIFO) || (ifmt == libc::S_IFSOCK) {
 491                 self.write_filename(&filename)?;
 492                 self.encode_special(&stat)?;
 493             } else {
 494                 bail!("unsupported file type (mode {:o} {:?})", stat.st_mode, self.full_path());
 495             }
 496
 497             let end_pos = self.writer_pos;
 498
 499             goodbye_items.push(CaFormatGoodbyeItem {
 500                 offset: start_pos as u64,
 501                 size: (end_pos - start_pos) as u64,
 502                 hash: compute_goodbye_hash(filename.to_bytes()),
 503             });
 504
 505             self.relative_path.pop();
 506         }
 507
 508         //println!("encode_dir: {:?} end {}", self.full_path(), self.writer_pos);
 509
 510         // fixup goodby item offsets
 511         let goodbye_start = self.writer_pos as u64;
 512         for item in &mut goodbye_items {
 513             item.offset = goodbye_start - item.offset;
 514         }
 515
 516         let goodbye_offset = self.writer_pos - dir_start_pos;
 517
 518         self.write_goodbye_table(goodbye_offset, &mut goodbye_items)?;
 519
 520         //println!("encode_dir: {:?} end1 {}", self.full_path(), self.writer_pos);
 521         Ok(())
 522     }
 523
 524     fn encode_file(&mut self, filefd: RawFd, stat: &FileStat, magic: i64)  -> Result<(), Error> {
 525
 526         //println!("encode_file: {:?}", self.full_path());
 527
 528         let mut entry = self.create_entry(&stat)?;
 529
 530         self.read_chattr(filefd, &mut entry)?;
 531         self.read_fat_attr(filefd, magic, &mut entry)?;
 532         let (xattrs, fcaps) = self.read_xattrs(filefd, &stat, &entry)?;
 533
 534         self.write_entry(entry)?;
 535         for xattr in xattrs { self.write_xattr(xattr)?; }
 536         self.write_fcaps(fcaps)?;
 537
 538         let include_payload;
 539         if is_virtual_file_system(magic) {
 540             include_payload = false;
 541         } else {
 542             include_payload = (stat.st_dev == self.root_st_dev) || self.all_file_systems;
 543         }
 544
 545         if !include_payload {
 546             eprintln!("skip content: {:?}", self.full_path());
 547             self.write_header(CA_FORMAT_PAYLOAD, 0)?;
 548             return Ok(());
 549         }
 550
 551         let size = stat.st_size as u64;
 552
 553         self.write_header(CA_FORMAT_PAYLOAD, size)?;
 554
 555         let mut pos: u64 = 0;
 556         loop {
 557             let n = match nix::unistd::read(filefd, &mut self.file_copy_buffer) {
 558                 Ok(n) => n,
 559                 Err(nix::Error::Sys(Errno::EINTR)) => continue /* try again */,
 560                 Err(err) =>  bail!("read {:?} failed - {}", self.full_path(), err),
 561             };
 562             if n == 0 { // EOF
 563                 if pos != size {
 564                     // Note:: casync format cannot handle that
 565                     bail!("detected shrinked file {:?} ({} < {})", self.full_path(), pos, size);
 566                 }
 567                 break;
 568             }
 569
 570             let mut next = pos + (n as u64);
 571
 572             if next > size { next = size; }
 573
 574             let count = (next - pos) as usize;
 575
 576             self.flush_copy_buffer(count)?;
 577
 578             pos = next;
 579
 580             if pos >= size { break; }
 581         }
 582
 583         Ok(())
 584     }
 585
 586     fn encode_device(&mut self, stat: &FileStat)  -> Result<(), Error> {
 587
 588         let entry = self.create_entry(&stat)?;
 589
 590         self.write_entry(entry)?;
 591
 592         let major = unsafe { libc::major(stat.st_rdev) } as u64;
 593         let minor = unsafe { libc::minor(stat.st_rdev) } as u64;
 594
 595         //println!("encode_device: {:?} {} {} {}", self.full_path(), stat.st_rdev, major, minor);
 596
 597         self.write_header(CA_FORMAT_DEVICE, std::mem::size_of::<CaFormatDevice>() as u64)?;
 598         self.write_item(CaFormatDevice { major, minor })?;
 599
 600         Ok(())
 601     }
 602
 603     // FIFO or Socket
 604     fn encode_special(&mut self, stat: &FileStat)  -> Result<(), Error> {
 605
 606         let entry = self.create_entry(&stat)?;
 607
 608         self.write_entry(entry)?;
 609
 610         Ok(())
 611     }
 612
 613     fn encode_symlink(&mut self, target: &[u8], stat: &FileStat)  -> Result<(), Error> {
 614
 615         //println!("encode_symlink: {:?} -> {:?}", self.full_path(), target);
 616
 617         let entry = self.create_entry(&stat)?;
 618         self.write_entry(entry)?;
 619
 620         self.write_header(CA_FORMAT_SYMLINK, target.len() as u64)?;
 621         self.write(target)?;
 622
 623         Ok(())
 624     }
 625
 626     fn encode_hardlink(&mut self, target: &[u8], offset: u64)  -> Result<(), Error> {
 627
 628         //println!("encode_hardlink: {:?} -> {:?}", self.full_path(), target);
 629
 630         // Note: HARDLINK replaces an ENTRY.
 631         self.write_header(PXAR_FORMAT_HARDLINK, (target.len() as u64) + 8)?;
 632         self.write_item(offset)?;
 633         self.write(target)?;
 634
 635         Ok(())
 636     }
 637
 638     // the report_XXX method may raise and error - depending on encoder configuration
 639
 640     fn report_vanished_file(&self, path: &Path) -> Result<(), Error> {
 641
 642         eprintln!("WARNING: detected vanished file {:?}", path);
 643
 644         Ok(())
 645     }
 646 }
 647
 648 fn errno_is_unsupported(errno: Errno) -> bool {
 649
 650     match errno {
 651         Errno::ENOTTY | Errno::ENOSYS | Errno::EBADF | Errno::EOPNOTSUPP | Errno::EINVAL => {
 652             true
 653         }
 654         _ => false,
 655     }
 656 }
 657
 658 fn detect_fs_type(fd: RawFd) -> Result<i64, Error> {
 659     let mut fs_stat: libc::statfs = unsafe { std::mem::uninitialized() };
 660     let res = unsafe { libc::fstatfs(fd, &mut fs_stat) };
 661     Errno::result(res)?;
 662
 663     Ok(fs_stat.f_type)
 664 }
 665
 666 use nix::{convert_ioctl_res, request_code_read, ioc};
 667
 668 // /usr/include/linux/fs.h: #define FS_IOC_GETFLAGS _IOR('f', 1, long)
 669 /// read Linux file system attributes (see man chattr)
 670 nix::ioctl_read!(read_attr_fd, b'f', 1, usize);
 671
 672 // /usr/include/linux/msdos_fs.h: #define FAT_IOCTL_GET_ATTRIBUTES _IOR('r', 0x10, __u32)
 673 // read FAT file system attributes
 674 nix::ioctl_read!(read_fat_attr_fd, b'r', 0x10, u32);
 675
 676
 677 // from /usr/include/linux/magic.h
 678 // and from casync util.h
 679 pub const BINFMTFS_MAGIC: i64 =        0x42494e4d;
 680 pub const CGROUP2_SUPER_MAGIC: i64 =   0x63677270;
 681 pub const CGROUP_SUPER_MAGIC: i64 =    0x0027e0eb;
 682 pub const CONFIGFS_MAGIC: i64 =        0x62656570;
 683 pub const DEBUGFS_MAGIC: i64 =         0x64626720;
 684 pub const DEVPTS_SUPER_MAGIC: i64 =    0x00001cd1;
 685 pub const EFIVARFS_MAGIC: i64 =        0xde5e81e4;
 686 pub const FUSE_CTL_SUPER_MAGIC: i64 =  0x65735543;
 687 pub const HUGETLBFS_MAGIC: i64 =       0x958458f6;
 688 pub const MQUEUE_MAGIC: i64 =          0x19800202;
 689 pub const NFSD_MAGIC: i64 =            0x6e667364;
 690 pub const PROC_SUPER_MAGIC: i64 =      0x00009fa0;
 691 pub const PSTOREFS_MAGIC: i64 =        0x6165676C;
 692 pub const RPCAUTH_GSSMAGIC: i64 =      0x67596969;
 693 pub const SECURITYFS_MAGIC: i64 =      0x73636673;
 694 pub const SELINUX_MAGIC: i64 =         0xf97cff8c;
 695 pub const SMACK_MAGIC: i64 =           0x43415d53;
 696 pub const RAMFS_MAGIC: i64 =           0x858458f6;
 697 pub const TMPFS_MAGIC: i64 =           0x01021994;
 698 pub const SYSFS_MAGIC: i64 =           0x62656572;
 699 pub const MSDOS_SUPER_MAGIC: i64 =     0x00004d44;
 700 pub const FUSE_SUPER_MAGIC: i64 =      0x65735546;
 701
 702
 703 #[inline(always)]
 704 pub fn is_temporary_file_system(magic: i64) -> bool {
 705     magic == RAMFS_MAGIC || magic == TMPFS_MAGIC
 706 }
 707
 708 pub fn is_virtual_file_system(magic: i64) -> bool {
 709
 710     match magic {
 711         BINFMTFS_MAGIC |
 712         CGROUP2_SUPER_MAGIC |
 713         CGROUP_SUPER_MAGIC |
 714         CONFIGFS_MAGIC |
 715         DEBUGFS_MAGIC |
 716         DEVPTS_SUPER_MAGIC |
 717         EFIVARFS_MAGIC |
 718         FUSE_CTL_SUPER_MAGIC |
 719         HUGETLBFS_MAGIC |
 720         MQUEUE_MAGIC |
 721         NFSD_MAGIC |
 722         PROC_SUPER_MAGIC |
 723         PSTOREFS_MAGIC |
 724         RPCAUTH_GSSMAGIC |
 725         SECURITYFS_MAGIC |
 726         SELINUX_MAGIC |
 727         SMACK_MAGIC |
 728         SYSFS_MAGIC => true,
 729         _ => false
 730     }
 731 }