92 lines
2.6 KiB
Rust
92 lines
2.6 KiB
Rust
/*
|
|
*
|
|
* Copyright (c) 2020-2022 Project CHIP Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
use std::{
|
|
convert::TryInto,
|
|
fs::{DirBuilder, File},
|
|
io::{Read, Write},
|
|
sync::{Arc, Mutex, Once},
|
|
};
|
|
|
|
use crate::error::Error;
|
|
|
|
pub const SPAKE2_ITERATION_COUNT: u32 = 2000;
|
|
|
|
// The Packet Pool that is allocated from. POSIX systems can use
|
|
// higher values unlike embedded systems
|
|
pub const MAX_PACKET_POOL_SIZE: usize = 25;
|
|
|
|
pub struct Psm {}
|
|
|
|
static mut G_PSM: Option<Arc<Mutex<Psm>>> = None;
|
|
static INIT: Once = Once::new();
|
|
|
|
const PSM_DIR: &str = "/tmp/plonk_psm";
|
|
|
|
macro_rules! psm_path {
|
|
($key:ident) => {
|
|
format!("{}/{}", PSM_DIR, $key)
|
|
};
|
|
}
|
|
|
|
impl Psm {
|
|
fn new() -> Result<Self, Error> {
|
|
let result = DirBuilder::new().create(PSM_DIR);
|
|
if let Err(e) = result {
|
|
if e.kind() != std::io::ErrorKind::AlreadyExists {
|
|
return Err(e.into());
|
|
}
|
|
}
|
|
|
|
Ok(Self {})
|
|
}
|
|
|
|
pub fn get() -> Result<Arc<Mutex<Self>>, Error> {
|
|
unsafe {
|
|
INIT.call_once(|| {
|
|
G_PSM = Some(Arc::new(Mutex::new(Psm::new().unwrap())));
|
|
});
|
|
Ok(G_PSM.as_ref().ok_or(Error::Invalid)?.clone())
|
|
}
|
|
}
|
|
|
|
pub fn set_kv_slice(&self, key: &str, val: &[u8]) -> Result<(), Error> {
|
|
let mut f = File::create(psm_path!(key))?;
|
|
f.write_all(val)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_kv_slice(&self, key: &str, val: &mut Vec<u8>) -> Result<usize, Error> {
|
|
let mut f = File::open(psm_path!(key))?;
|
|
let len = f.read_to_end(val)?;
|
|
Ok(len)
|
|
}
|
|
|
|
pub fn set_kv_u64(&self, key: &str, val: u64) -> Result<(), Error> {
|
|
let mut f = File::create(psm_path!(key))?;
|
|
f.write_all(&val.to_be_bytes())?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_kv_u64(&self, key: &str, val: &mut u64) -> Result<(), Error> {
|
|
let mut f = File::open(psm_path!(key))?;
|
|
let mut vec = Vec::new();
|
|
let _ = f.read_to_end(&mut vec)?;
|
|
*val = u64::from_be_bytes(vec.as_slice().try_into()?);
|
|
Ok(())
|
|
}
|
|
}
|