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