src/bin/pxar.rs

   1 extern crate proxmox_backup;
   2
   3 use failure::*;
   4
   5 use proxmox_backup::tools;
   6 use proxmox_backup::cli::*;
   7 use proxmox_backup::api_schema::*;
   8 use proxmox_backup::api_schema::router::*;
   9
  10 use serde_json::{Value};
  11
  12 use std::io::Write;
  13 use std::path::{Path, PathBuf};
  14 use std::fs::OpenOptions;
  15 use std::sync::Arc;
  16 use std::os::unix::fs::OpenOptionsExt;
  17 use std::os::unix::io::AsRawFd;
  18 use std::collections::HashSet;
  19
  20 use proxmox_backup::pxar;
  21
  22 fn dump_archive_from_reader<R: std::io::Read>(
  23     reader: &mut R,
  24     feature_flags: u64,
  25     verbose: bool,
  26 ) -> Result<(), Error> {
  27     let mut decoder = pxar::SequentialDecoder::new(reader, feature_flags, |_| Ok(()));
  28
  29     let stdout = std::io::stdout();
  30     let mut out = stdout.lock();
  31
  32     let mut path = PathBuf::new();
  33     decoder.dump_entry(&mut path, verbose, &mut out)?;
  34
  35     Ok(())
  36 }
  37
  38 fn dump_archive(
  39     param: Value,
  40     _info: &ApiMethod,
  41     _rpcenv: &mut dyn RpcEnvironment,
  42 ) -> Result<Value, Error> {
  43
  44     let archive = tools::required_string_param(&param, "archive")?;
  45     let verbose = param["verbose"].as_bool().unwrap_or(false);
  46
  47     let feature_flags = pxar::flags::DEFAULT;
  48
  49     if archive == "-" {
  50         let stdin = std::io::stdin();
  51         let mut reader = stdin.lock();
  52         dump_archive_from_reader(&mut reader, feature_flags, verbose)?;
  53     } else {
  54         if verbose { println!("PXAR dump: {}", archive); }
  55         let file = std::fs::File::open(archive)?;
  56         let mut reader = std::io::BufReader::new(file);
  57         dump_archive_from_reader(&mut reader, feature_flags, verbose)?;
  58     }
  59
  60     Ok(Value::Null)
  61 }
  62
  63 fn extract_archive_from_reader<R: std::io::Read>(
  64     reader: &mut R,
  65     target: &str,
  66     feature_flags: u64,
  67     allow_existing_dirs: bool,
  68     verbose: bool,
  69     pattern: Option<Vec<pxar::MatchPattern>>
  70 ) -> Result<(), Error> {
  71     let mut decoder = pxar::SequentialDecoder::new(reader, feature_flags, |path| {
  72         if verbose {
  73             println!("{:?}", path);
  74         }
  75         Ok(())
  76     });
  77     decoder.set_allow_existing_dirs(allow_existing_dirs);
  78
  79     let pattern = pattern.unwrap_or(Vec::new());
  80     decoder.restore(Path::new(target), &pattern)?;
  81
  82     Ok(())
  83 }
  84
  85 fn extract_archive(
  86     param: Value,
  87     _info: &ApiMethod,
  88     _rpcenv: &mut dyn RpcEnvironment,
  89 ) -> Result<Value, Error> {
  90
  91     let archive = tools::required_string_param(&param, "archive")?;
  92     let target = param["target"].as_str().unwrap_or(".");
  93     let verbose = param["verbose"].as_bool().unwrap_or(false);
  94     let no_xattrs = param["no-xattrs"].as_bool().unwrap_or(false);
  95     let no_fcaps = param["no-fcaps"].as_bool().unwrap_or(false);
  96     let no_acls = param["no-acls"].as_bool().unwrap_or(false);
  97     let no_device_nodes = param["no-device-nodes"].as_bool().unwrap_or(false);
  98     let no_fifos = param["no-fifos"].as_bool().unwrap_or(false);
  99     let no_sockets = param["no-sockets"].as_bool().unwrap_or(false);
 100     let allow_existing_dirs = param["allow-existing-dirs"].as_bool().unwrap_or(false);
 101     let files_from = param["files-from"].as_str();
 102     let empty = Vec::new();
 103     let arg_pattern = param["pattern"].as_array().unwrap_or(&empty);
 104
 105     let mut feature_flags = pxar::flags::DEFAULT;
 106     if no_xattrs {
 107         feature_flags ^= pxar::flags::WITH_XATTRS;
 108     }
 109     if no_fcaps {
 110         feature_flags ^= pxar::flags::WITH_FCAPS;
 111     }
 112     if no_acls {
 113         feature_flags ^= pxar::flags::WITH_ACL;
 114     }
 115     if no_device_nodes {
 116         feature_flags ^= pxar::flags::WITH_DEVICE_NODES;
 117     }
 118     if no_fifos {
 119         feature_flags ^= pxar::flags::WITH_FIFOS;
 120     }
 121     if no_sockets {
 122         feature_flags ^= pxar::flags::WITH_SOCKETS;
 123     }
 124
 125     let mut pattern_list = Vec::new();
 126     if let Some(filename) = files_from {
 127         let dir = nix::dir::Dir::open("./", nix::fcntl::OFlag::O_RDONLY, nix::sys::stat::Mode::empty())?;
 128         if let Some((mut pattern, _, _)) = pxar::MatchPattern::from_file(dir.as_raw_fd(), filename)? {
 129             pattern_list.append(&mut pattern);
 130         }
 131     }
 132
 133     for s in arg_pattern {
 134         let l = s.as_str().ok_or_else(|| format_err!("Invalid pattern string slice"))?;
 135         let p = pxar::MatchPattern::from_line(l.as_bytes())?
 136             .ok_or_else(|| format_err!("Invalid match pattern in arguments"))?;
 137         pattern_list.push(p);
 138     }
 139
 140     let pattern = if pattern_list.len() > 0 {
 141         Some(pattern_list)
 142     } else {
 143         None
 144     };
 145
 146     if archive == "-" {
 147         let stdin = std::io::stdin();
 148         let mut reader = stdin.lock();
 149         extract_archive_from_reader(&mut reader, target, feature_flags, allow_existing_dirs, verbose, pattern)?;
 150     } else {
 151         if verbose { println!("PXAR extract: {}", archive); }
 152         let file = std::fs::File::open(archive)?;
 153         let mut reader = std::io::BufReader::new(file);
 154         extract_archive_from_reader(&mut reader, target, feature_flags, allow_existing_dirs, verbose, pattern)?;
 155     }
 156
 157     Ok(Value::Null)
 158 }
 159
 160 fn create_archive(
 161     param: Value,
 162     _info: &ApiMethod,
 163     _rpcenv: &mut dyn RpcEnvironment,
 164 ) -> Result<Value, Error> {
 165
 166     let archive = tools::required_string_param(&param, "archive")?;
 167     let source = tools::required_string_param(&param, "source")?;
 168     let verbose = param["verbose"].as_bool().unwrap_or(false);
 169     let all_file_systems = param["all-file-systems"].as_bool().unwrap_or(false);
 170     let no_xattrs = param["no-xattrs"].as_bool().unwrap_or(false);
 171     let no_fcaps = param["no-fcaps"].as_bool().unwrap_or(false);
 172     let no_acls = param["no-acls"].as_bool().unwrap_or(false);
 173     let no_device_nodes = param["no-device-nodes"].as_bool().unwrap_or(false);
 174     let no_fifos = param["no-fifos"].as_bool().unwrap_or(false);
 175     let no_sockets = param["no-sockets"].as_bool().unwrap_or(false);
 176
 177     let devices = if all_file_systems { None } else { Some(HashSet::new()) };
 178
 179     let source = PathBuf::from(source);
 180
 181     let mut dir = nix::dir::Dir::open(
 182         &source, nix::fcntl::OFlag::O_NOFOLLOW, nix::sys::stat::Mode::empty())?;
 183
 184     let file = OpenOptions::new()
 185         .create_new(true)
 186         .write(true)
 187         .mode(0o640)
 188         .open(archive)?;
 189
 190     let mut writer = std::io::BufWriter::with_capacity(1024*1024, file);
 191     let mut feature_flags = pxar::flags::DEFAULT;
 192     if no_xattrs {
 193         feature_flags ^= pxar::flags::WITH_XATTRS;
 194     }
 195     if no_fcaps {
 196         feature_flags ^= pxar::flags::WITH_FCAPS;
 197     }
 198     if no_acls {
 199         feature_flags ^= pxar::flags::WITH_ACL;
 200     }
 201     if no_device_nodes {
 202         feature_flags ^= pxar::flags::WITH_DEVICE_NODES;
 203     }
 204     if no_fifos {
 205         feature_flags ^= pxar::flags::WITH_FIFOS;
 206     }
 207     if no_sockets {
 208         feature_flags ^= pxar::flags::WITH_SOCKETS;
 209     }
 210
 211     let catalog = None::<&mut pxar::catalog::SimpleCatalog>;
 212     pxar::Encoder::encode(source, &mut dir, &mut writer, catalog, devices, verbose, false, feature_flags)?;
 213
 214     writer.flush()?;
 215
 216     Ok(Value::Null)
 217 }
 218
 219 fn main() {
 220
 221     let cmd_def = CliCommandMap::new()
 222         .insert("create", CliCommand::new(
 223             ApiMethod::new(
 224                 create_archive,
 225                 ObjectSchema::new("Create new .pxar archive.")
 226                     .required("archive", StringSchema::new("Archive name"))
 227                     .required("source", StringSchema::new("Source directory."))
 228                     .optional("verbose", BooleanSchema::new("Verbose output.").default(false))
 229                     .optional("no-xattrs", BooleanSchema::new("Ignore extended file attributes.").default(false))
 230                     .optional("no-fcaps", BooleanSchema::new("Ignore file capabilities.").default(false))
 231                     .optional("no-acls", BooleanSchema::new("Ignore access control list entries.").default(false))
 232                     .optional("all-file-systems", BooleanSchema::new("Include mounted sudirs.").default(false))
 233                     .optional("no-device-nodes", BooleanSchema::new("Ignore device nodes.").default(false))
 234                     .optional("no-fifos", BooleanSchema::new("Ignore fifos.").default(false))
 235                     .optional("no-sockets", BooleanSchema::new("Ignore sockets.").default(false))
 236             ))
 237             .arg_param(vec!["archive", "source"])
 238             .completion_cb("archive", tools::complete_file_name)
 239             .completion_cb("source", tools::complete_file_name)
 240             .into()
 241         )
 242         .insert("extract", CliCommand::new(
 243             ApiMethod::new(
 244                 extract_archive,
 245                 ObjectSchema::new("Extract an archive.")
 246                     .required("archive", StringSchema::new("Archive name."))
 247                     .optional("pattern", Arc::new(
 248                         ArraySchema::new(
 249                             "List of paths or pattern matching files to restore",
 250                             Arc::new(StringSchema::new("Path or pattern matching files to restore.").into())
 251                         ).into()
 252                     ))
 253                     .optional("target", StringSchema::new("Target directory."))
 254                     .optional("verbose", BooleanSchema::new("Verbose output.").default(false))
 255                     .optional("no-xattrs", BooleanSchema::new("Ignore extended file attributes.").default(false))
 256                     .optional("no-fcaps", BooleanSchema::new("Ignore file capabilities.").default(false))
 257                     .optional("no-acls", BooleanSchema::new("Ignore access control list entries.").default(false))
 258                     .optional("allow-existing-dirs", BooleanSchema::new("Allows directories to already exist on restore.").default(false))
 259                     .optional("files-from", StringSchema::new("Match pattern for files to restore."))
 260                     .optional("no-device-nodes", BooleanSchema::new("Ignore device nodes.").default(false))
 261                     .optional("no-fifos", BooleanSchema::new("Ignore fifos.").default(false))
 262                     .optional("no-sockets", BooleanSchema::new("Ignore sockets.").default(false))
 263             ))
 264             .arg_param(vec!["archive", "pattern"])
 265             .completion_cb("archive", tools::complete_file_name)
 266             .completion_cb("target", tools::complete_file_name)
 267             .completion_cb("files-from", tools::complete_file_name)
 268             .into()
 269         )
 270         .insert("list", CliCommand::new(
 271             ApiMethod::new(
 272                 dump_archive,
 273                 ObjectSchema::new("List the contents of an archive.")
 274                     .required("archive", StringSchema::new("Archive name."))
 275                     .optional("verbose", BooleanSchema::new("Verbose output.").default(false))
 276             ))
 277             .arg_param(vec!["archive"])
 278             .completion_cb("archive", tools::complete_file_name)
 279             .into()
 280         );
 281
 282     run_cli_command(cmd_def.into());
 283 }