v0.4.6 : clippy pedantic

Author: BarbossHack

Cargo.toml

@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 name = "shmap"
 readme = "README.md"
 repository = "https://github.com/BarbossHack/shmap"
-version = "0.4.5"
+version = "0.4.6"
 
 [dependencies]
 aes-gcm = { version = "0.10", features = ["std"] }
@@ -19,11 +19,18 @@ fdlimit = "0.3"
 libc = "0.2"
 log = "0.4"
 memmap2 = "0.9"
-named-lock = "0.3"
+named-lock = "0.4"
 rand = "0.8"
 serde = { version = "1.0", features = ["serde_derive"] }
 sha2 = "0.10"
 thiserror = "1.0"
 
 [dev-dependencies]
-env_logger = "0.10"
+env_logger = "0.11"
+
+[lints.clippy]
+missing_errors_doc = "allow"
+nursery = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+undocumented_unsafe_blocks = "warn"
+unwrap_used = "warn"

clippy.toml

@@ -0,0 +1 @@
+allow-unwrap-in-tests = true

src/map.rs

@@ -1,7 +1,7 @@
 use crate::{
     errors::ShmapError,
     metadata::Metadata,
-    shm::{shm_open_read, shm_open_write, shm_unlink, SHM_DIR},
+    shm::{self, SHM_DIR},
 };
 use aes_gcm::{
     aead::{generic_array::GenericArray, Aead},
@@ -38,13 +38,15 @@ impl Default for Shmap {
 
 impl Shmap {
     /// Initialize Shmap with no TTL or encryption.
+    #[must_use]
     pub fn new() -> Self {
-        Shmap::_new(None)
+        Self::_new(None)
     }
 
     /// Initialize Shmap with AES256 encryption key (random bytes).
+    #[must_use]
     pub fn new_with_encryption(encryption_key: &[u8; 32]) -> Self {
-        Shmap::_new(Some(encryption_key))
+        Self::_new(Some(encryption_key))
     }
 
     fn _new(encryption_key: Option<&[u8; 32]>) -> Self {
@@ -58,9 +60,9 @@ impl Shmap {
             Aes256Gcm::new(key)
         });
 
-        let shmap = Shmap { cipher };
+        let shmap = Self { cipher };
         if let Err(e) = shmap.clean() {
-            warn!("Error while cleaning shmap keys: {}", e)
+            warn!("Error while cleaning shmap keys: {}", e);
         }
         shmap
     }
@@ -74,17 +76,14 @@ impl Shmap {
 
         // Remove item if expired
         let not_found = match self.get_metadata(key)? {
-            Some(metadata) => match metadata.expiration {
-                Some(expiration) => {
-                    let expired = Utc::now().gt(&expiration);
-                    if expired {
-                        warn!("Key <{}> expired, removing", &key);
-                        let _ = self.remove(key);
-                    }
-                    expired
+            Some(metadata) => metadata.expiration.map_or(false, |expiration| {
+                let expired = Utc::now().gt(&expiration);
+                if expired {
+                    warn!("Key <{}> expired, removing", &key);
+                    let _ = self.remove(key);
                 }
-                None => false,
-            },
+                expired
+            }),
             None => true,
         };
         if not_found {
@@ -123,7 +122,7 @@ impl Shmap {
         let lock = NamedLock::with_path(
             PathBuf::from(SHM_DIR).join(
                 sanitized_key
-                    .trim_end_matches(&format!(".{}", METADATA_SUFFIX))
+                    .trim_end_matches(&format!(".{METADATA_SUFFIX}"))
                     .to_string()
                     + "."
                     + LOCK_SUFFIX,
@@ -132,7 +131,7 @@ impl Shmap {
         let guard = lock.lock()?;
 
         // Read the item from shm
-        let fd = match shm_open_read(sanitized_key) {
+        let fd = match shm::open_read(sanitized_key) {
             Ok(fd) => fd,
             Err(e) => match e {
                 ShmapError::ShmFileNotFound => {
@@ -143,6 +142,7 @@ impl Shmap {
                 e => return Err(e),
             },
         };
+        // SAFETY: Mmap call is unsafe
         let mmap = unsafe { Mmap::map(fd) }?;
         if mmap.len() == 0 {
             // If the value is empty, remove it and return None
@@ -162,10 +162,9 @@ impl Shmap {
                     sanitized_key
                 );
                 return Ok(None);
-            } else {
-                let nonce = Nonce::from_slice(&mmap[..12]);
-                cipher.decrypt(nonce, &mmap[12..])?
             }
+            let nonce = Nonce::from_slice(&mmap[..12]);
+            cipher.decrypt(nonce, &mmap[12..])?
         } else {
             mmap.to_vec()
         };
@@ -238,7 +237,7 @@ impl Shmap {
         let lock = NamedLock::with_path(
             PathBuf::from(SHM_DIR).join(
                 sanitized_key
-                    .trim_end_matches(&format!(".{}", METADATA_SUFFIX))
+                    .trim_end_matches(&format!(".{METADATA_SUFFIX}"))
                     .to_string()
                     + "."
                     + LOCK_SUFFIX,
@@ -247,13 +246,16 @@ impl Shmap {
         let guard = lock.lock()?;
 
         // Insert the item to shm
-        match || -> Result<(), ShmapError> {
-            let fd = shm_open_write(sanitized_key, bytes.len())?;
+        let write_result = || -> Result<(), ShmapError> {
+            let fd = shm::open_write(sanitized_key, bytes.len())?;
+            // SAFETY: libc call is unsafe
             let mut mmap = unsafe { MmapMut::map_mut(fd) }?;
             mmap.copy_from_slice(bytes.as_slice());
             Ok(())
-        }() {
-            Ok(_) => Ok(()),
+        }();
+
+        match write_result {
+            Ok(()) => Ok(()),
             Err(e) => {
                 drop(guard);
                 let _ = self._remove(sanitized_key);
@@ -274,12 +276,13 @@ impl Shmap {
         self._remove(&sanitize_metadata_key)
     }
 
+    #[allow(clippy::unused_self)]
     fn _remove(&self, sanitized_key: &str) -> Result<(), ShmapError> {
         if !sanitized_key.ends_with(LOCK_SUFFIX) {
             let lock = NamedLock::with_path(
                 PathBuf::from(SHM_DIR).join(
                     sanitized_key
-                        .trim_end_matches(&format!(".{}", METADATA_SUFFIX))
+                        .trim_end_matches(&format!(".{METADATA_SUFFIX}"))
                         .to_string()
                         + "."
                         + LOCK_SUFFIX,
@@ -288,7 +291,7 @@ impl Shmap {
             let _guard = lock.lock()?;
         }
 
-        shm_unlink(sanitized_key)?;
+        shm::unlink(sanitized_key)?;
 
         Ok(())
     }
@@ -317,7 +320,7 @@ impl Shmap {
                 && !filename.ends_with(METADATA_SUFFIX)
                 && !filename.ends_with(LOCK_SUFFIX)
             {
-                let metadata_filename = format!("{}.{}", filename, METADATA_SUFFIX);
+                let metadata_filename = format!("{filename}.{METADATA_SUFFIX}");
                 match self.get_deserialize::<Metadata>(&metadata_filename) {
                     Ok(Some(metadata)) => match metadata.expiration {
                         Some(expiration) => {
@@ -353,8 +356,7 @@ impl Shmap {
                 }
             } else if filename.starts_with(SHMAP_PREFIX) && filename.ends_with(METADATA_SUFFIX) {
                 let filename_path = dir_entry.path().to_string_lossy().to_string();
-                let item_filename =
-                    filename_path.trim_end_matches(&format!(".{}", METADATA_SUFFIX));
+                let item_filename = filename_path.trim_end_matches(&format!(".{METADATA_SUFFIX}"));
                 if !PathBuf::from(item_filename).exists()
                     && duration_since_modified_time > Duration::from_secs(5)
                 {
@@ -366,9 +368,9 @@ impl Shmap {
                 }
             } else if filename.starts_with(SHMAP_PREFIX) && filename.ends_with(LOCK_SUFFIX) {
                 let filename_path = dir_entry.path().to_string_lossy().to_string();
-                let item_filename = filename_path.trim_end_matches(&format!(".{}", LOCK_SUFFIX));
+                let item_filename = filename_path.trim_end_matches(&format!(".{LOCK_SUFFIX}"));
                 if !PathBuf::from(item_filename).exists()
-                    && !PathBuf::from(format!("{}.{}", item_filename, METADATA_SUFFIX)).exists()
+                    && !PathBuf::from(format!("{item_filename}.{METADATA_SUFFIX}")).exists()
                     && duration_since_modified_time > Duration::from_secs(5)
                 {
                     warn!(
@@ -383,7 +385,7 @@ impl Shmap {
     }
 }
 
-pub(crate) fn sanitize_key(key: &str) -> String {
+pub fn sanitize_key(key: &str) -> String {
     let mut hasher = Sha224::new();
     hasher.update(key);
     format!("{}.{:x}", SHMAP_PREFIX, hasher.finalize())

src/metadata.rs

@@ -25,7 +25,7 @@ impl Metadata {
             None => None,
         };
 
-        Ok(Metadata {
+        Ok(Self {
             key: key.to_owned(),
             expiration,
             encrypted,

src/shm.rs

@@ -13,7 +13,7 @@ pub struct Fd(RawFd);
 
 impl From<RawFd> for Fd {
     fn from(value: RawFd) -> Self {
-        Fd(value)
+        Self(value)
     }
 }
 
@@ -25,14 +25,15 @@ impl MmapAsRawDesc for Fd {
 
 impl Drop for Fd {
     fn drop(&mut self) {
+        // SAFETY: libc call is unsafe
         unsafe {
             libc::close(self.0);
         }
     }
 }
 
 /// Open shm in readonly.
-pub fn shm_open_read(name: &str) -> Result<Fd, ShmapError> {
+pub fn open_read(name: &str) -> Result<Fd, ShmapError> {
     let fd = shm_open(name, libc::O_RDONLY)?;
     // On success, returns a file descriptor (a nonnegative integer)
     if fd < 0 {
@@ -49,14 +50,16 @@ pub fn shm_open_read(name: &str) -> Result<Fd, ShmapError> {
 }
 
 /// Open shm with read/write rights, and initialze it to `length`size.
-pub fn shm_open_write(name: &str, length: usize) -> Result<Fd, ShmapError> {
+pub fn open_write(name: &str, length: usize) -> Result<Fd, ShmapError> {
     let fd = shm_open(name, libc::O_RDWR | libc::O_CREAT | libc::O_TRUNC)?;
     // On success, returns a file descriptor (a nonnegative integer)
     if fd < 0 {
         let err = std::io::Error::last_os_error();
         return Err(ShmapError::IOError(err));
     }
 
+    // SAFETY: libc call is unsafe
+    #[allow(clippy::cast_possible_wrap)]
     let ret = unsafe { libc::ftruncate(fd, length as libc::off_t) };
     if ret != 0 {
         let err = std::io::Error::last_os_error();
@@ -68,14 +71,16 @@ pub fn shm_open_write(name: &str, length: usize) -> Result<Fd, ShmapError> {
 
 fn shm_open(name: &str, flags: i32) -> Result<RawFd, ShmapError> {
     let name = std::ffi::CString::new(name)?;
+    // SAFETY: libc call is unsafe
     let fd = unsafe { libc::shm_open(name.as_ptr(), flags, 0o600) };
     Ok(fd)
 }
 
 /// Unlink (remove) shm by its name.
-pub fn shm_unlink(name: &str) -> Result<(), ShmapError> {
-    let name = std::ffi::CString::new(name)?;
-    let ret = unsafe { libc::shm_unlink(name.as_ptr()) };
+pub fn unlink(name: &str) -> Result<(), ShmapError> {
+    let c_name = std::ffi::CString::new(name)?;
+    // SAFETY: libc call is unsafe
+    let ret = unsafe { libc::shm_unlink(c_name.as_ptr()) };
     // returns 0 on success, or -1 on error
     if ret != 0 {
         let err = std::io::Error::last_os_error();