src/bin/proxmox-backup-api.rs

   1 extern crate proxmox_backup;
   2
   3 use std::sync::Arc;
   4
   5 use proxmox_backup::tools;
   6 use proxmox_backup::api::schema::*;
   7 use proxmox_backup::api::router::*;
   8 use proxmox_backup::api::config::*;
   9 use proxmox_backup::server::rest::*;
  10 use proxmox_backup::getopts;
  11
  12 use failure::*;
  13 use lazy_static::lazy_static;
  14 use openssl::rsa::{Rsa};
  15 use std::path::PathBuf;
  16
  17 use futures::future::Future;
  18
  19 use hyper;
  20
  21 pub fn generate_csrf_key() -> Result<(), Error> {
  22
  23     let path = PathBuf::from("/etc/proxmox-backup/csrf.key");
  24
  25     if path.exists() { return Ok(()); }
  26
  27     let rsa = Rsa::generate(2048).unwrap();
  28
  29     let pem = rsa.private_key_to_pem()?;
  30
  31     use nix::sys::stat::Mode;
  32
  33     tools::file_set_contents(
  34         &path, &pem, Some(Mode::from_bits_truncate(0o0640)))?;
  35
  36     nix::unistd::chown(&path, Some(nix::unistd::ROOT), Some(nix::unistd::Gid::from_raw(33)))?;
  37
  38     Ok(())
  39 }
  40
  41 pub fn generate_auth_key() -> Result<(), Error> {
  42
  43     let priv_path = PathBuf::from("/etc/proxmox-backup/authkey.key");
  44
  45     let mut public_path = priv_path.clone();
  46     public_path.set_extension("pub");
  47
  48     if priv_path.exists() && public_path.exists() { return Ok(()); }
  49
  50     let rsa = Rsa::generate(4096).unwrap();
  51
  52     let priv_pem = rsa.private_key_to_pem()?;
  53
  54     use nix::sys::stat::Mode;
  55
  56     tools::file_set_contents(
  57         &priv_path, &priv_pem, Some(Mode::from_bits_truncate(0o0600)))?;
  58
  59
  60     let public_pem = rsa.public_key_to_pem()?;
  61
  62     tools::file_set_contents(&public_path, &public_pem, None)?;
  63
  64     Ok(())
  65 }
  66
  67 fn main() {
  68
  69     if let Err(err) = syslog::init(
  70         syslog::Facility::LOG_DAEMON,
  71         log::LevelFilter::Info,
  72         Some("proxmox-backup-api")) {
  73         eprintln!("unable to inititialize syslog: {}", err);
  74         std::process::exit(-1);
  75     }
  76
  77     if let Err(err) = generate_auth_key() {
  78         eprintln!("unable to generate auth key: {}", err);
  79         std::process::exit(-1);
  80     }
  81
  82     if let Err(err) = generate_csrf_key() {
  83         eprintln!("unable to generate csrf key: {}", err);
  84         std::process::exit(-1);
  85     }
  86
  87     let command : Arc<Schema> = StringSchema::new("Command.")
  88         .format(Arc::new(ApiStringFormat::Enum(vec![
  89             "start".into(),
  90             "status".into(),
  91             "stop".into()
  92         ])))
  93         .into();
  94
  95     let schema = ObjectSchema::new("Parameters.")
  96         .required("command", command);
  97
  98     let args: Vec<String> = std::env::args().skip(1).collect();
  99
 100     let options = match getopts::parse_arguments(&args, &vec!["command"], &schema) {
 101         Ok((options, rest)) => {
 102             if !rest.is_empty() {
 103                 eprintln!("Error: got additional arguments: {:?}", rest);
 104                 std::process::exit(-1);
 105             }
 106             options
 107         }
 108         Err(err) => {
 109             eprintln!("Error: unable to parse arguments:\n{}", err);
 110             std::process::exit(-1);
 111         }
 112     };
 113
 114     let command = options["command"].as_str().unwrap();
 115
 116     match command {
 117         "start" => {
 118             println!("Starting server.");
 119         },
 120         "stop" => {
 121             println!("Stopping server.");
 122             std::process::exit(0);
 123         },
 124         "status" => {
 125             println!("Server status.");
 126              std::process::exit(0);
 127        },
 128         _ => {
 129             eprintln!("got unexpected command {}", command);
 130             std::process::exit(-1);
 131         },
 132     }
 133
 134     let addr = ([127,0,0,1], 82).into();
 135
 136     lazy_static!{
 137        static ref ROUTER: Router = proxmox_backup::api2::router();
 138     }
 139
 140     let config = ApiConfig::new(
 141         "/usr/share/javascript/proxmox-backup", &ROUTER, RpcEnvironmentType::PRIVILEDGED);
 142
 143     let rest_server = RestServer::new(config);
 144
 145     let server = hyper::Server::bind(&addr)
 146         .serve(rest_server)
 147         .map_err(|e| eprintln!("server error: {}", e));
 148
 149
 150     // Run this server for... forever!
 151     hyper::rt::run(server);
 152 }