diff --git a/pbs-tools/src/async_lru_cache.rs b/pbs-tools/src/async_lru_cache.rs index be4ea891..a4781ac4 100644 --- a/pbs-tools/src/async_lru_cache.rs +++ b/pbs-tools/src/async_lru_cache.rs @@ -7,8 +7,8 @@ use std::collections::HashMap; use std::future::Future; use std::sync::{Arc, Mutex}; -use proxmox_async::broadcast_future::BroadcastFuture; use crate::lru_cache::LruCache; +use proxmox_async::broadcast_future::BroadcastFuture; /// Interface for asynchronously getting values on cache misses. pub trait AsyncCacher: Sync + Send { diff --git a/pbs-tools/src/cert.rs b/pbs-tools/src/cert.rs index c9fe8811..e4feb3bd 100644 --- a/pbs-tools/src/cert.rs +++ b/pbs-tools/src/cert.rs @@ -1,13 +1,13 @@ //! Deals with the server's current certificates (proxy.pem). -use std::path::PathBuf; use std::mem::MaybeUninit; +use std::path::PathBuf; use anyhow::{bail, format_err, Error}; use foreign_types::ForeignTypeRef; -use openssl::x509::{X509, GeneralName}; +use openssl::pkey::{PKey, Public}; use openssl::stack::Stack; -use openssl::pkey::{Public, PKey}; +use openssl::x509::{GeneralName, X509}; // C type: #[allow(non_camel_case_types)] @@ -34,7 +34,11 @@ pub struct CertInfo { fn x509name_to_string(name: &openssl::x509::X509NameRef) -> Result { let mut parts = Vec::new(); for entry in name.entries() { - parts.push(format!("{} = {}", entry.object().nid().short_name()?, entry.data().as_utf8()?)); + parts.push(format!( + "{} = {}", + entry.object().nid().short_name()?, + entry.data().as_utf8()? + )); } Ok(parts.join(", ")) } @@ -47,9 +51,7 @@ impl CertInfo { pub fn from_pem(cert_pem: &[u8]) -> Result { let x509 = openssl::x509::X509::from_pem(cert_pem)?; - Ok(Self{ - x509 - }) + Ok(Self { x509 }) } pub fn subject_alt_names(&self) -> Option> { @@ -70,7 +72,8 @@ impl CertInfo { .as_bytes() .chunks(2) .map(|v| std::str::from_utf8(v).unwrap()) - .collect::>().join(":")) + .collect::>() + .join(":")) } pub fn public_key(&self) -> Result, Error> { diff --git a/pbs-tools/src/crypt_config.rs b/pbs-tools/src/crypt_config.rs index 604abae9..cbf74190 100644 --- a/pbs-tools/src/crypt_config.rs +++ b/pbs-tools/src/crypt_config.rs @@ -7,7 +7,7 @@ //! encryption](https://en.wikipedia.org/wiki/Authenticated_encryption) //! for a short introduction. -use anyhow::{Error}; +use anyhow::Error; use openssl::hash::MessageDigest; use openssl::pkcs5::pbkdf2_hmac; use openssl::symm::{Cipher, Crypter, Mode}; @@ -15,10 +15,8 @@ use openssl::symm::{Cipher, Crypter, Mode}; // openssl::sha::sha256(b"Proxmox Backup Encryption Key Fingerprint") /// This constant is used to compute fingerprints. const FINGERPRINT_INPUT: [u8; 32] = [ - 110, 208, 239, 119, 71, 31, 255, 77, - 85, 199, 168, 254, 74, 157, 182, 33, - 97, 64, 127, 19, 76, 114, 93, 223, - 48, 153, 45, 37, 236, 69, 237, 38, + 110, 208, 239, 119, 71, 31, 255, 77, 85, 199, 168, 254, 74, 157, 182, 33, 97, 64, 127, 19, 76, + 114, 93, 223, 48, 153, 45, 37, 236, 69, 237, 38, ]; /// Encryption Configuration with secret key @@ -37,13 +35,11 @@ pub struct CryptConfig { } impl CryptConfig { - /// Create a new instance. /// /// We compute a derived 32 byte key using pbkdf2_hmac. This second /// key is used in compute_digest. pub fn new(enc_key: [u8; 32]) -> Result { - let mut id_key = [0u8; 32]; pbkdf2_hmac( @@ -51,11 +47,17 @@ impl CryptConfig { b"_id_key", 10, MessageDigest::sha256(), - &mut id_key)?; + &mut id_key, + )?; let id_pkey = openssl::pkey::PKey::hmac(&id_key).unwrap(); - Ok(Self { id_key, id_pkey, enc_key, cipher: Cipher::aes_256_gcm() }) + Ok(Self { + id_key, + id_pkey, + enc_key, + cipher: Cipher::aes_256_gcm(), + }) } /// Expose Cipher (AES_256_GCM) @@ -107,7 +109,7 @@ impl CryptConfig { } /// Returns an openssl Crypter using AES_256_GCM, - pub fn data_crypter(&self, iv: &[u8; 16], mode: Mode) -> Result { + pub fn data_crypter(&self, iv: &[u8; 16], mode: Mode) -> Result { let mut crypter = openssl::symm::Crypter::new(self.cipher, mode, &self.enc_key, Some(iv))?; crypter.aad_update(b"")?; //?? Ok(crypter) diff --git a/pbs-tools/src/format.rs b/pbs-tools/src/format.rs index df5fe544..aeaa3e03 100644 --- a/pbs-tools/src/format.rs +++ b/pbs-tools/src/format.rs @@ -1,20 +1,21 @@ use std::borrow::Borrow; -use anyhow::{Error}; +use anyhow::Error; use serde_json::Value; use pbs_api_types::HumanByte; pub fn strip_server_file_extension(name: &str) -> &str { if name.ends_with(".didx") || name.ends_with(".fidx") || name.ends_with(".blob") { - &name[..name.len()-5] + &name[..name.len() - 5] } else { name // should not happen } } pub fn render_backup_file_list>(files: &[S]) -> String { - let mut files: Vec<&str> = files.iter() + let mut files: Vec<&str> = files + .iter() .map(|v| strip_server_file_extension(v.borrow())) .collect(); @@ -24,7 +25,9 @@ pub fn render_backup_file_list>(files: &[S]) -> String { } pub fn render_epoch(value: &Value, _record: &Value) -> Result { - if value.is_null() { return Ok(String::new()); } + if value.is_null() { + return Ok(String::new()); + } let text = match value.as_i64() { Some(epoch) => { if let Ok(epoch_string) = proxmox_time::strftime_local("%c", epoch as i64) { @@ -32,10 +35,8 @@ pub fn render_epoch(value: &Value, _record: &Value) -> Result { } else { epoch.to_string() } - }, - None => { - value.to_string() } + None => value.to_string(), }; Ok(text) } @@ -54,14 +55,12 @@ pub fn render_bool_with_default_true(value: &Value, _record: &Value) -> Result Result { - if value.is_null() { return Ok(String::new()); } + if value.is_null() { + return Ok(String::new()); + } let text = match value.as_u64() { - Some(bytes) => { - HumanByte::from(bytes).to_string() - } - None => { - value.to_string() - } + Some(bytes) => HumanByte::from(bytes).to_string(), + None => value.to_string(), }; Ok(text) } diff --git a/pbs-tools/src/lib.rs b/pbs-tools/src/lib.rs index 939ba7e6..289efbc4 100644 --- a/pbs-tools/src/lib.rs +++ b/pbs-tools/src/lib.rs @@ -24,6 +24,6 @@ pub mod async_lru_cache; /// less erratic behavior in the overall's runtime RSS size. pub fn setup_libc_malloc_opts() { unsafe { - libc::mallopt(libc::M_MMAP_THRESHOLD, 4096*32); + libc::mallopt(libc::M_MMAP_THRESHOLD, 4096 * 32); } } diff --git a/pbs-tools/src/lru_cache.rs b/pbs-tools/src/lru_cache.rs index fbd7673a..1befb1a0 100644 --- a/pbs-tools/src/lru_cache.rs +++ b/pbs-tools/src/lru_cache.rs @@ -4,7 +4,7 @@ //! A HashMap is used for fast access by a given key and a doubly linked list //! is used to keep track of the cache access order. -use std::collections::{HashMap, hash_map::Entry}; +use std::collections::{hash_map::Entry, HashMap}; use std::marker::PhantomData; /// Interface for getting values on cache misses. @@ -101,7 +101,7 @@ pub struct LruCache { } impl Drop for LruCache { - fn drop (&mut self) { + fn drop(&mut self) { self.clear(); } } @@ -204,7 +204,11 @@ impl LruCache { /// value. /// If fetch returns a value, it is inserted as the most recently used entry /// in the cache. - pub fn access<'a>(&'a mut self, key: K, cacher: &mut dyn Cacher) -> Result, anyhow::Error> { + pub fn access<'a>( + &'a mut self, + key: K, + cacher: &mut dyn Cacher, + ) -> Result, anyhow::Error> { match self.map.entry(key) { Entry::Occupied(mut o) => { // Cache hit, birng node to front of list diff --git a/pbs-tools/src/nom.rs b/pbs-tools/src/nom.rs index 62d8c9ad..81e4dea2 100644 --- a/pbs-tools/src/nom.rs +++ b/pbs-tools/src/nom.rs @@ -1,10 +1,10 @@ use anyhow::{bail, Error}; use nom::{ - error::{ParseError, VerboseError}, bytes::complete::{take_while, take_while1}, - combinator::{map_res, all_consuming, recognize}, - character::complete::{digit1}, + character::complete::digit1, + combinator::{all_consuming, map_res, recognize}, + error::{ParseError, VerboseError}, }; pub type IResult> = Result<(I, O), nom::Err>; @@ -22,17 +22,17 @@ pub fn parse_failure<'a>(i: &'a str, context: &'static str) -> nom::Err IResult<&str, &str> { +pub fn multispace0(i: &str) -> IResult<&str, &str> { take_while(|c| c == ' ' || c == '\t')(i) } /// Recognizes one or more spaces and tabs (but not carage returns or line feeds) -pub fn multispace1(i: &str) -> IResult<&str, &str> { +pub fn multispace1(i: &str) -> IResult<&str, &str> { take_while1(|c| c == ' ' || c == '\t')(i) } /// Recognizes one or more non-whitespace-characters -pub fn notspace1(i: &str) -> IResult<&str, &str> { +pub fn notspace1(i: &str) -> IResult<&str, &str> { take_while1(|c| !(c == ' ' || c == '\t' || c == '\n'))(i) } @@ -43,32 +43,41 @@ pub fn parse_u64(i: &str) -> IResult<&str, u64> { /// Parse complete input, generate verbose error message with line numbers pub fn parse_complete<'a, F, O>(what: &str, i: &'a str, parser: F) -> Result - where F: Fn(&'a str) -> IResult<&'a str, O>, +where + F: Fn(&'a str) -> IResult<&'a str, O>, { match all_consuming(parser)(i) { - Err(nom::Err::Error(err)) | - Err(nom::Err::Failure(err)) => { - bail!("unable to parse {} - {}", what, nom::error::convert_error(i, err)); + Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => { + bail!( + "unable to parse {} - {}", + what, + nom::error::convert_error(i, err) + ); } Err(err) => { bail!("unable to parse {} - {}", what, err); } Ok((_, data)) => Ok(data), } - } /// Parse complete input, generate simple error message (use this for sinple line input). pub fn parse_complete_line<'a, F, O>(what: &str, i: &'a str, parser: F) -> Result - where F: Fn(&'a str) -> IResult<&'a str, O>, +where + F: Fn(&'a str) -> IResult<&'a str, O>, { match all_consuming(parser)(i) { - Err(nom::Err::Error(VerboseError { errors })) | - Err(nom::Err::Failure(VerboseError { errors })) => { + Err(nom::Err::Error(VerboseError { errors })) + | Err(nom::Err::Failure(VerboseError { errors })) => { if errors.is_empty() { bail!("unable to parse {}", what); } else { - bail!("unable to parse {} at '{}' - {:?}", what, errors[0].0, errors[0].1); + bail!( + "unable to parse {} at '{}' - {:?}", + what, + errors[0].0, + errors[0].1 + ); } } Err(err) => {