Clipped Fixxy (#1622)

* clippy fix

* fix

* fix

* it works

* imports

Author: andreafioraldi

libafl/src/events/mod.rs

@@ -77,6 +77,7 @@ pub type ShutdownFuncPtr =
 ///
 /// This will acceess `data` and write to the global `data.staterestorer_ptr` if it's not null.
 #[cfg(all(unix, feature = "std"))]
+#[allow(clippy::needless_pass_by_value)]
 pub unsafe fn shutdown_handler<SP>(
     signal: Signal,
     _info: &mut siginfo_t,

libafl/src/executors/inprocess.rs

@@ -2,6 +2,7 @@
 //! It should usually be paired with extra error-handling, such as a restarting event manager, to be effective.
 //!
 //! Needs the `fork` feature flag.
+#![allow(clippy::needless_pass_by_value)]
 
 use alloc::boxed::Box;
 #[cfg(all(unix, feature = "std"))]

libafl/src/mutators/token_mutations.rs

@@ -223,6 +223,11 @@ impl Tokens {
     pub fn tokens(&self) -> &[Vec<u8>] {
         &self.tokens_vec
     }
+
+    /// Returns an iterator over the tokens.
+    pub fn iter(&self) -> Iter<'_, Vec<u8>> {
+        <&Self as IntoIterator>::into_iter(self)
+    }
 }
 
 impl AddAssign for Tokens {

libafl/src/observers/concolic/serialization_format.rs

@@ -381,66 +381,6 @@ impl<W: Write + Seek> MessageFileWriter<W> {
     }
 }
 
-#[cfg(test)]
-mod serialization_tests {
-    use alloc::vec::Vec;
-    use std::io::Cursor;
-
-    use super::{MessageFileReader, MessageFileWriter, SymExpr};
-
-    /// This test intends to ensure that the serialization format can efficiently encode the required information.
-    /// This is mainly useful to fail if any changes should be made in the future that (inadvertently) reduce
-    /// serialization efficiency.
-    #[test]
-    fn efficient_serialization() {
-        let mut buf = Vec::new();
-        {
-            let mut cursor = Cursor::new(&mut buf);
-            let mut writer = MessageFileWriter::from_writer(&mut cursor).unwrap();
-            let a = writer.write_message(SymExpr::True).unwrap();
-            let b = writer.write_message(SymExpr::True).unwrap();
-            writer.write_message(SymExpr::And { a, b }).unwrap();
-            writer.update_trace_header().unwrap();
-        }
-        let expected_size = 8 + // the header takes 8 bytes to encode the length of the trace
-                            1 + // tag to create SymExpr::True (a)
-                            1 + // tag to create SymExpr::True (b)
-                            1 + // tag to create SymExpr::And
-                            1 + // reference to a
-                            1; // reference to b
-        assert_eq!(buf.len(), expected_size);
-    }
-
-    /// This test intends to verify that a trace written by [`MessageFileWriter`] can indeed be read back by
-    /// [`MessageFileReader`].
-    #[test]
-    fn serialization_roundtrip() {
-        let mut buf = Vec::new();
-        {
-            let mut cursor = Cursor::new(&mut buf);
-            let mut writer = MessageFileWriter::from_writer(&mut cursor).unwrap();
-            let a = writer.write_message(SymExpr::True).unwrap();
-            let b = writer.write_message(SymExpr::True).unwrap();
-            writer.write_message(SymExpr::And { a, b }).unwrap();
-            writer.update_trace_header().unwrap();
-        }
-        let mut reader = MessageFileReader::from_length_prefixed_buffer(&buf).unwrap();
-        let (first_bool_id, first_bool) = reader.next_message().unwrap().unwrap();
-        assert_eq!(first_bool, SymExpr::True);
-        let (second_bool_id, second_bool) = reader.next_message().unwrap().unwrap();
-        assert_eq!(second_bool, SymExpr::True);
-        let (_, and) = reader.next_message().unwrap().unwrap();
-        assert_eq!(
-            and,
-            SymExpr::And {
-                a: first_bool_id,
-                b: second_bool_id
-            }
-        );
-        assert!(reader.next_message().is_none());
-    }
-}
-
 use libafl_bolts::shmem::{ShMem, ShMemCursor, ShMemProvider, StdShMemProvider};
 
 /// The default environment variable name to use for the shared memory used by the concolic tracing
@@ -511,3 +451,63 @@ impl MessageFileWriter<ShMemCursor<<StdShMemProvider as ShMemProvider>::ShMem>>
 /// A writer that will write messages to a shared memory buffer.
 pub type StdShMemMessageFileWriter =
     MessageFileWriter<ShMemCursor<<StdShMemProvider as ShMemProvider>::ShMem>>;
+
+#[cfg(test)]
+mod serialization_tests {
+    use alloc::vec::Vec;
+    use std::io::Cursor;
+
+    use super::{MessageFileReader, MessageFileWriter, SymExpr};
+
+    /// This test intends to ensure that the serialization format can efficiently encode the required information.
+    /// This is mainly useful to fail if any changes should be made in the future that (inadvertently) reduce
+    /// serialization efficiency.
+    #[test]
+    fn efficient_serialization() {
+        let mut buf = Vec::new();
+        {
+            let mut cursor = Cursor::new(&mut buf);
+            let mut writer = MessageFileWriter::from_writer(&mut cursor).unwrap();
+            let a = writer.write_message(SymExpr::True).unwrap();
+            let b = writer.write_message(SymExpr::True).unwrap();
+            writer.write_message(SymExpr::And { a, b }).unwrap();
+            writer.update_trace_header().unwrap();
+        }
+        let expected_size = 8 + // the header takes 8 bytes to encode the length of the trace
+                            1 + // tag to create SymExpr::True (a)
+                            1 + // tag to create SymExpr::True (b)
+                            1 + // tag to create SymExpr::And
+                            1 + // reference to a
+                            1; // reference to b
+        assert_eq!(buf.len(), expected_size);
+    }
+
+    /// This test intends to verify that a trace written by [`MessageFileWriter`] can indeed be read back by
+    /// [`MessageFileReader`].
+    #[test]
+    fn serialization_roundtrip() {
+        let mut buf = Vec::new();
+        {
+            let mut cursor = Cursor::new(&mut buf);
+            let mut writer = MessageFileWriter::from_writer(&mut cursor).unwrap();
+            let a = writer.write_message(SymExpr::True).unwrap();
+            let b = writer.write_message(SymExpr::True).unwrap();
+            writer.write_message(SymExpr::And { a, b }).unwrap();
+            writer.update_trace_header().unwrap();
+        }
+        let mut reader = MessageFileReader::from_length_prefixed_buffer(&buf).unwrap();
+        let (first_bool_id, first_bool) = reader.next_message().unwrap().unwrap();
+        assert_eq!(first_bool, SymExpr::True);
+        let (second_bool_id, second_bool) = reader.next_message().unwrap().unwrap();
+        assert_eq!(second_bool, SymExpr::True);
+        let (_, and) = reader.next_message().unwrap().unwrap();
+        assert_eq!(
+            and,
+            SymExpr::And {
+                a: first_bool_id,
+                b: second_bool_id
+            }
+        );
+        assert!(reader.next_message().is_none());
+    }
+}

libafl/src/observers/map.rs

@@ -324,6 +324,28 @@ where
     }
 }
 
+impl<'a, T, const DIFFERENTIAL: bool> StdMapObserver<'a, T, DIFFERENTIAL>
+where
+    T: Bounded
+        + PartialEq
+        + Default
+        + Copy
+        + 'static
+        + Serialize
+        + serde::de::DeserializeOwned
+        + Debug,
+{
+    /// Returns an iterator over the map.
+    pub fn iter(&self) -> Iter<'_, T> {
+        <&Self as IntoIterator>::into_iter(self)
+    }
+
+    /// Returns a mutable iterator over the map.
+    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+        <&mut Self as IntoIterator>::into_iter(self)
+    }
+}
+
 impl<'a, T, const DIFFERENTIAL: bool> MapObserver for StdMapObserver<'a, T, DIFFERENTIAL>
 where
     T: Bounded
@@ -781,6 +803,28 @@ where
     }
 }
 
+impl<'a, T, const N: usize> ConstMapObserver<'a, T, N>
+where
+    T: Bounded
+        + PartialEq
+        + Default
+        + Copy
+        + 'static
+        + Serialize
+        + serde::de::DeserializeOwned
+        + Debug,
+{
+    /// Returns an iterator over the map.
+    pub fn iter(&self) -> Iter<'_, T> {
+        <&Self as IntoIterator>::into_iter(self)
+    }
+
+    /// Returns a mutable iterator over the map.
+    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+        <&mut Self as IntoIterator>::into_iter(self)
+    }
+}
+
 impl<'a, T, const N: usize> MapObserver for ConstMapObserver<'a, T, N>
 where
     T: Bounded
@@ -1054,6 +1098,28 @@ where
     }
 }
 
+impl<'a, T> VariableMapObserver<'a, T>
+where
+    T: Bounded
+        + PartialEq
+        + Default
+        + Copy
+        + 'static
+        + Serialize
+        + serde::de::DeserializeOwned
+        + Debug,
+{
+    /// Returns an iterator over the map.
+    pub fn iter(&self) -> Iter<'_, T> {
+        <&Self as IntoIterator>::into_iter(self)
+    }
+
+    /// Returns a mutable iterator over the map.
+    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+        <&mut Self as IntoIterator>::into_iter(self)
+    }
+}
+
 impl<'a, T> MapObserver for VariableMapObserver<'a, T>
 where
     T: Bounded
@@ -1412,7 +1478,7 @@ where
 
 impl<'it, M> IntoIterator for &'it HitcountsMapObserver<M>
 where
-    M: Named + Serialize + serde::de::DeserializeOwned,
+    M: Serialize + serde::de::DeserializeOwned,
     &'it M: IntoIterator<Item = &'it u8>,
 {
     type Item = &'it u8;
@@ -1425,7 +1491,7 @@ where
 
 impl<'it, M> IntoIterator for &'it mut HitcountsMapObserver<M>
 where
-    M: Named + Serialize + serde::de::DeserializeOwned,
+    M: Serialize + serde::de::DeserializeOwned,
     &'it mut M: IntoIterator<Item = &'it mut u8>,
 {
     type Item = &'it mut u8;
@@ -1436,6 +1502,28 @@ where
     }
 }
 
+impl<M> HitcountsMapObserver<M>
+where
+    M: Serialize + serde::de::DeserializeOwned,
+    for<'it> &'it M: IntoIterator<Item = &'it u8>,
+{
+    /// Returns an iterator over the map.
+    pub fn iter(&self) -> <&M as IntoIterator>::IntoIter {
+        <&Self as IntoIterator>::into_iter(self)
+    }
+}
+
+impl<M> HitcountsMapObserver<M>
+where
+    M: Serialize + serde::de::DeserializeOwned,
+    for<'it> &'it mut M: IntoIterator<Item = &'it mut u8>,
+{
+    /// Returns a mutable iterator over the map.
+    pub fn iter_mut(&mut self) -> <&mut M as IntoIterator>::IntoIter {
+        <&mut Self as IntoIterator>::into_iter(self)
+    }
+}
+
 impl<M, OTA, OTB, S> DifferentialObserver<OTA, OTB, S> for HitcountsMapObserver<M>
 where
     M: DifferentialObserver<OTA, OTB, S>
@@ -1639,7 +1727,7 @@ where
 
 impl<'it, M> IntoIterator for &'it HitcountsIterableMapObserver<M>
 where
-    M: Named + Serialize + serde::de::DeserializeOwned,
+    M: Serialize + serde::de::DeserializeOwned,
     &'it M: IntoIterator<Item = &'it u8>,
 {
     type Item = &'it u8;
@@ -1652,7 +1740,7 @@ where
 
 impl<'it, M> IntoIterator for &'it mut HitcountsIterableMapObserver<M>
 where
-    M: Named + Serialize + serde::de::DeserializeOwned,
+    M: Serialize + serde::de::DeserializeOwned,
     &'it mut M: IntoIterator<Item = &'it mut u8>,
 {
     type Item = &'it mut u8;
@@ -1663,6 +1751,28 @@ where
     }
 }
 
+impl<M> HitcountsIterableMapObserver<M>
+where
+    M: Serialize + serde::de::DeserializeOwned,
+    for<'it> &'it M: IntoIterator<Item = &'it u8>,
+{
+    /// Returns an iterator over the map.
+    pub fn iter(&self) -> <&M as IntoIterator>::IntoIter {
+        <&Self as IntoIterator>::into_iter(self)
+    }
+}
+
+impl<M> HitcountsIterableMapObserver<M>
+where
+    M: Serialize + serde::de::DeserializeOwned,
+    for<'it> &'it mut M: IntoIterator<Item = &'it mut u8>,
+{
+    /// Returns a mutable iterator over the map.
+    pub fn iter_mut(&mut self) -> <&mut M as IntoIterator>::IntoIter {
+        <&mut Self as IntoIterator>::into_iter(self)
+    }
+}
+
 impl<M, OTA, OTB, S> DifferentialObserver<OTA, OTB, S> for HitcountsIterableMapObserver<M>
 where
     M: MapObserver<Entry = u8> + Observer<S> + DifferentialObserver<OTA, OTB, S>,
@@ -1967,6 +2077,21 @@ where
     }
 }
 
+impl<'a, T, const DIFFERENTIAL: bool> MultiMapObserver<'a, T, DIFFERENTIAL>
+where
+    T: Default + Copy + 'static + Serialize + serde::de::DeserializeOwned + Debug,
+{
+    /// Returns an iterator over the map.
+    pub fn iter(&self) -> <&Self as IntoIterator>::IntoIter {
+        <&Self as IntoIterator>::into_iter(self)
+    }
+
+    /// Returns a mutable iterator over the map.
+    pub fn iter_mut(&mut self) -> <&mut Self as IntoIterator>::IntoIter {
+        <&mut Self as IntoIterator>::into_iter(self)
+    }
+}
+
 impl<'a, T, OTA, OTB, S> DifferentialObserver<OTA, OTB, S> for MultiMapObserver<'a, T, true>
 where
     T: Default + Copy + 'static + Serialize + serde::de::DeserializeOwned + Debug,
@@ -2071,6 +2196,21 @@ where
     }
 }
 
+impl<T> OwnedMapObserver<T>
+where
+    T: Default + Copy + 'static + Serialize + serde::de::DeserializeOwned + Debug,
+{
+    /// Returns an iterator over the map.
+    pub fn iter(&self) -> Iter<'_, T> {
+        <&Self as IntoIterator>::into_iter(self)
+    }
+
+    /// Returns a mutable iterator over the map.
+    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+        <&mut Self as IntoIterator>::into_iter(self)
+    }
+}
+
 impl<T> MapObserver for OwnedMapObserver<T>
 where
     T: Bounded

libafl/src/observers/stacktrace.rs

@@ -19,6 +19,7 @@ use std::{
 
 use backtrace::Backtrace;
 use libafl_bolts::{ownedref::OwnedRefMut, Named};
+#[allow(unused_imports)]
 #[cfg(feature = "casr")]
 use libcasr::{
     asan::AsanStacktrace,