Conform AFL struct casing to codebase/rust (#3221)

* Conform AFL struct casing to codebase/rust

* Actually, Aflpp looks better

Author: domenukk

fuzzers/forkserver/fuzzbench_forkserver/src/main.rs

@@ -43,7 +43,7 @@ use libafl_bolts::{
     tuples::{tuple_list, Merge},
     AsSliceMut, StdTargetArgs,
 };
-use libafl_targets::cmps::AFLppCmpLogMap;
+use libafl_targets::cmps::AflppCmpLogMap;
 use nix::sys::signal::Signal;
 
 pub fn main() {
@@ -351,12 +351,12 @@ fn fuzz(
 
     if let Some(exec) = &cmplog_exec {
         // The cmplog map shared between observer and executor
-        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AFLppCmpLogMap>().unwrap();
+        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AflppCmpLogMap>().unwrap();
         // let the forkserver know the shmid
         unsafe {
             cmplog_shmem.write_to_env(SHM_CMPLOG_ENV_VAR).unwrap();
         }
-        let cmpmap = unsafe { OwnedRefMut::<AFLppCmpLogMap>::from_shmem(&mut cmplog_shmem) };
+        let cmpmap = unsafe { OwnedRefMut::<AflppCmpLogMap>::from_shmem(&mut cmplog_shmem) };
 
         let cmplog_observer = StdCmpObserver::new("cmplog", cmpmap, true);
 

fuzzers/forkserver/fuzzbench_forkserver_cmplog/src/main.rs

@@ -21,7 +21,7 @@ use libafl::{
     inputs::BytesInput,
     monitors::SimpleMonitor,
     mutators::{
-        havoc_mutations, token_mutations::AFLppRedQueen, tokens_mutations, StdMOptMutator, Tokens,
+        havoc_mutations, token_mutations::AflppRedQueen, tokens_mutations, StdMOptMutator, Tokens,
     },
     observers::{CanTrack, HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{
@@ -43,8 +43,8 @@ use libafl_bolts::{
     AsSliceMut, StdTargetArgs,
 };
 use libafl_targets::{
-    cmps::{observers::AFLppCmpLogObserver, stages::AFLppCmplogTracingStage},
-    AFLppCmpLogMap,
+    cmps::{observers::AflppCmpLogObserver, stages::AflppCmplogTracingStage},
+    AflppCmpLogMap,
 };
 use nix::sys::signal::Signal;
 
@@ -354,14 +354,14 @@ fn fuzz(
 
     if let Some(exec) = &cmplog_exec {
         // The cmplog map shared between observer and executor
-        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AFLppCmpLogMap>().unwrap();
+        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AflppCmpLogMap>().unwrap();
         // let the forkserver know the shmid
         unsafe {
             cmplog_shmem.write_to_env(SHM_CMPLOG_ENV_VAR).unwrap();
         }
         let cmpmap = unsafe { OwnedRefMut::from_shmem(&mut cmplog_shmem) };
 
-        let cmplog_observer = AFLppCmpLogObserver::new("cmplog", cmpmap, true);
+        let cmplog_observer = AflppCmpLogObserver::new("cmplog", cmpmap, true);
         let cmplog_ref = cmplog_observer.handle();
 
         let cmplog_executor = ForkserverExecutor::builder()
@@ -376,11 +376,11 @@ fn fuzz(
             .build(tuple_list!(cmplog_observer))
             .unwrap();
 
-        let tracing = AFLppCmplogTracingStage::new(cmplog_executor, cmplog_ref);
+        let tracing = AflppCmplogTracingStage::new(cmplog_executor, cmplog_ref);
 
         // Setup a randomic Input2State stage
         let rq: MultiMutationalStage<_, _, BytesInput, _, _, _> =
-            MultiMutationalStage::new(AFLppRedQueen::with_cmplog_options(true, true));
+            MultiMutationalStage::new(AflppRedQueen::with_cmplog_options(true, true));
 
         let cb = |_fuzzer: &mut _,
                   _executor: &mut _,

fuzzers/forkserver/fuzzbench_forkserver_sand/src/main.rs

@@ -44,7 +44,7 @@ use libafl_bolts::{
     tuples::{tuple_list, Handled, Merge},
     AsSliceMut, StdTargetArgs,
 };
-use libafl_targets::cmps::AFLppCmpLogMap;
+use libafl_targets::cmps::AflppCmpLogMap;
 use nix::sys::signal::Signal;
 
 pub fn main() {
@@ -399,12 +399,12 @@ fn fuzz(
 
     if let Some(exec) = &cmplog_exec {
         // The cmplog map shared between observer and executor
-        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AFLppCmpLogMap>().unwrap();
+        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AflppCmpLogMap>().unwrap();
         // let the forkserver know the shmid
         unsafe {
             cmplog_shmem.write_to_env(SHM_CMPLOG_ENV_VAR).unwrap();
         }
-        let cmpmap = unsafe { OwnedRefMut::<AFLppCmpLogMap>::from_shmem(&mut cmplog_shmem) };
+        let cmpmap = unsafe { OwnedRefMut::<AflppCmpLogMap>::from_shmem(&mut cmplog_shmem) };
 
         let cmplog_observer = StdCmpObserver::new("cmplog", cmpmap, true);
 

fuzzers/forkserver/libafl-fuzz/src/fuzzer.rs

@@ -26,7 +26,7 @@ use libafl::{
     },
     fuzzer::StdFuzzer,
     inputs::BytesInput,
-    mutators::{havoc_mutations, tokens_mutations, AFLppRedQueen, HavocScheduledMutator, Tokens},
+    mutators::{havoc_mutations, tokens_mutations, AflppRedQueen, HavocScheduledMutator, Tokens},
     observers::{CanTrack, HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{
         powersched::{BaseSchedule, PowerSchedule},
@@ -58,7 +58,7 @@ use libafl_bolts::{
 };
 #[cfg(feature = "nyx")]
 use libafl_nyx::{executor::NyxExecutor, helper::NyxHelper, settings::NyxSettings};
-use libafl_targets::{cmps::AFLppCmpLogMap, AFLppCmpLogObserver, AFLppCmplogTracingStage};
+use libafl_targets::{cmps::AflppCmpLogMap, AflppCmpLogObserver, AflppCmplogTracingStage};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -475,7 +475,7 @@ define_run_client!(state, mgr, fuzzer_dir, core_id, opt, is_main_node, {
 
     if run_cmplog {
         // The CmpLog map shared between the CmpLog observer and CmpLog executor
-        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AFLppCmpLogMap>().unwrap();
+        let mut cmplog_shmem = shmem_provider.uninit_on_shmem::<AflppCmpLogMap>().unwrap();
 
         // Let the Forkserver know the CmpLog shared memory map ID.
         unsafe {
@@ -484,7 +484,7 @@ define_run_client!(state, mgr, fuzzer_dir, core_id, opt, is_main_node, {
         let cmpmap = unsafe { OwnedRefMut::from_shmem(&mut cmplog_shmem) };
 
         // Create the CmpLog observer.
-        let cmplog_observer = AFLppCmpLogObserver::new("cmplog", cmpmap, true);
+        let cmplog_observer = AflppCmpLogObserver::new("cmplog", cmpmap, true);
         let cmplog_ref = cmplog_observer.handle();
 
         // Create the CmpLog executor.
@@ -496,11 +496,11 @@ define_run_client!(state, mgr, fuzzer_dir, core_id, opt, is_main_node, {
             .unwrap();
 
         // Create the CmpLog tracing stage.
-        let tracing = AFLppCmplogTracingStage::new(cmplog_executor, cmplog_ref);
+        let tracing = AflppCmplogTracingStage::new(cmplog_executor, cmplog_ref);
 
         // Create a randomic Input2State stage
         let rq = MultiMutationalStage::<_, _, BytesInput, _, _, _>::new(
-            AFLppRedQueen::with_cmplog_options(true, true),
+            AflppRedQueen::with_cmplog_options(true, true),
         );
 
         // Create an IfStage and wrap the CmpLog stages in it.

libafl/src/mutators/token_mutations.rs

@@ -30,7 +30,7 @@ use crate::{
     mutators::{
         MultiMutator, MutationResult, Mutator, Named, buffer_self_copy, mutations::buffer_copy,
     },
-    observers::cmp::{AFLppCmpValuesMetadata, CmpValues, CmpValuesMetadata},
+    observers::cmp::{AflppCmpValuesMetadata, CmpValues, CmpValuesMetadata},
     stages::TaintMetadata,
     state::{HasCorpus, HasMaxSize, HasRand},
 };
@@ -849,7 +849,7 @@ const CMP_ATTRIBUTE_IS_TRANSFORM: u8 = 64;
 
 /// AFL++ redqueen mutation
 #[derive(Debug, Default)]
-pub struct AFLppRedQueen {
+pub struct AflppRedQueen {
     enable_transform: bool,
     enable_arith: bool,
     text_type: TextType,
@@ -858,7 +858,7 @@ pub struct AFLppRedQueen {
     last_corpus_id: Option<CorpusId>,
 }
 
-impl AFLppRedQueen {
+impl AflppRedQueen {
     #[inline]
     fn swapa(x: u8) -> u8 {
         (x & 0xf8) + ((x & 7) ^ 0x07)
@@ -1321,7 +1321,7 @@ impl AFLppRedQueen {
     }
 }
 
-impl<I, S> MultiMutator<I, S> for AFLppRedQueen
+impl<I, S> MultiMutator<I, S> for AflppRedQueen
 where
     S: HasMetadata + HasRand + HasMaxSize + HasCorpus<I> + HasCurrentCorpusId,
     I: ResizableMutator<u8> + From<Vec<u8>> + HasMutatorBytes,
@@ -1342,7 +1342,7 @@ where
 
         let (cmp_len, cmp_meta, taint_meta) = {
             let (Some(cmp_meta), Some(taint_meta)) = (
-                state.metadata_map().get::<AFLppCmpValuesMetadata>(),
+                state.metadata_map().get::<AflppCmpValuesMetadata>(),
                 state.metadata_map().get::<TaintMetadata>(),
             ) else {
                 return Ok(vec![]);
@@ -1370,7 +1370,7 @@ where
         // println!("orig: {:#?} new: {:#?}", orig_cmpvals, new_cmpvals);
 
         // Compute when mutating it for the 1st time.
-        let current_corpus_id = state.current_corpus_id()?.ok_or_else(|| Error::key_not_found("No corpus-id is currently being fuzzed, but called AFLppRedQueen::multi_mutated()."))?;
+        let current_corpus_id = state.current_corpus_id()?.ok_or_else(|| Error::key_not_found("No corpus-id is currently being fuzzed, but called AflppRedQueen::multi_mutated()."))?;
         if self.last_corpus_id.is_none() || self.last_corpus_id.unwrap() != current_corpus_id {
             self.text_type = check_if_text(orig_bytes, orig_bytes.len());
             self.last_corpus_id = Some(current_corpus_id);
@@ -1920,15 +1920,15 @@ where
     }
 }
 
-impl Named for AFLppRedQueen {
+impl Named for AflppRedQueen {
     fn name(&self) -> &Cow<'static, str> {
-        static NAME: Cow<'static, str> = Cow::Borrowed("AFLppRedQueen");
+        static NAME: Cow<'static, str> = Cow::Borrowed("AflppRedQueen");
         &NAME
     }
 }
 
-impl AFLppRedQueen {
-    /// Create a new `AFLppRedQueen` Mutator
+impl AflppRedQueen {
+    /// Create a new `AflppRedQueen` Mutator
     #[must_use]
     pub fn new() -> Self {
         Self {
@@ -2111,7 +2111,7 @@ mod tests {
     use std::fs;
 
     #[cfg(feature = "std")]
-    use super::{AFLppRedQueen, Tokens};
+    use super::{AflppRedQueen, Tokens};
 
     #[cfg(feature = "std")]
     #[test]
@@ -2134,7 +2134,7 @@ token2="B"
     #[cfg(feature = "std")]
     #[test]
     fn test_token_mutations() {
-        let rq = AFLppRedQueen::with_cmplog_options(true, true);
+        let rq = AflppRedQueen::with_cmplog_options(true, true);
         let pattern = 0;
         let repl = 0;
         let another_pattern = 0;

libafl/src/observers/cmp.rs

@@ -120,7 +120,7 @@ impl CmpValuesMetadata {
 
     /// Add comparisons to a metadata from a `CmpObserver`. `cmp_map` is mutable in case
     /// it is needed for a custom map, but this is not utilized for `CmpObserver` or
-    /// `AFLppCmpLogObserver`.
+    /// `AflppCmpLogObserver`.
     pub fn add_from<CM>(&mut self, usable_count: usize, cmp_map: &mut CM)
     where
         CM: CmpMap,
@@ -360,22 +360,22 @@ struct cmp_map {
     any(not(feature = "serdeany_autoreg"), miri),
     expect(clippy::unsafe_derive_deserialize)
 )] // for SerdeAny
-pub struct AFLppCmpValuesMetadata {
-    /// The first map of `AFLppCmpLogVals` retrieved by running the un-mutated input
+pub struct AflppCmpValuesMetadata {
+    /// The first map of `AflppCmpLogVals` retrieved by running the un-mutated input
     #[serde(skip)]
     pub orig_cmpvals: HashMap<usize, Vec<CmpValues>>,
-    /// The second map of `AFLppCmpLogVals` retrieved by runnning the mutated input
+    /// The second map of `AflppCmpLogVals` retrieved by runnning the mutated input
     #[serde(skip)]
     pub new_cmpvals: HashMap<usize, Vec<CmpValues>>,
     /// The list of logged idx and headers retrieved by runnning the mutated input
     #[serde(skip)]
-    pub headers: Vec<(usize, AFLppCmpLogHeader)>,
+    pub headers: Vec<(usize, AflppCmpLogHeader)>,
 }
 
-libafl_bolts::impl_serdeany!(AFLppCmpValuesMetadata);
+libafl_bolts::impl_serdeany!(AflppCmpValuesMetadata);
 
-impl AFLppCmpValuesMetadata {
-    /// Constructor for `AFLppCmpValuesMetadata`
+impl AflppCmpValuesMetadata {
+    /// Constructor for `AflppCmpValuesMetadata`
     #[must_use]
     pub fn new() -> Self {
         Self {
@@ -399,7 +399,7 @@ impl AFLppCmpValuesMetadata {
 
     /// Getter for `headers`
     #[must_use]
-    pub fn headers(&self) -> &Vec<(usize, AFLppCmpLogHeader)> {
+    pub fn headers(&self) -> &Vec<(usize, AflppCmpLogHeader)> {
         &self.headers
     }
 }
@@ -418,7 +418,7 @@ impl AFLppCmpValuesMetadata {
 /// - reserved:  Reserved for future use
 #[bitfield(u16)]
 #[derive(Debug)]
-pub struct AFLppCmpLogHeader {
+pub struct AflppCmpLogHeader {
     /// The number of hits of a particular comparison
     ///
     /// 6 bits up to 63 entries, we have CMP_MAP_H = 32 (so using half of it)

libafl/src/stages/afl_stats.rs

@@ -117,7 +117,7 @@ pub struct AflStatsStage<C, E, EM, I, O, S, Z> {
 
 /// AFL++'s `fuzzer_stats`
 #[derive(Debug, Clone)]
-pub struct AFLFuzzerStats<'a> {
+pub struct AflFuzzerStats<'a> {
     /// unix time indicating the start time of afl-fuzz
     start_time: u64,
     /// unix time corresponding to the last interval
@@ -320,7 +320,7 @@ where
         } else {
             0
         };
-        let stats = AFLFuzzerStats {
+        let stats = AflFuzzerStats {
             start_time: self.start_time,
             last_update: self.last_report_time.as_secs(),
             run_time: self.last_report_time.as_secs() - self.start_time,
@@ -460,7 +460,7 @@ where
     }
 
     /// Writes a stats file, if a `stats_file_path` is set.
-    fn maybe_write_fuzzer_stats(&self, stats: &AFLFuzzerStats) -> Result<(), Error> {
+    fn maybe_write_fuzzer_stats(&self, stats: &AflFuzzerStats) -> Result<(), Error> {
         if let Some(stats_file_path) = &self.stats_file_path {
             let tmp_file = stats_file_path
                 .parent()
@@ -586,7 +586,7 @@ impl AFLPlotData<'_> {
         "# relative_time, cycles_done, cur_item, corpus_count, pending_total, pending_favs, total_edges, saved_crashes, saved_hangs, max_depth, execs_per_sec, execs_done, edges_found"
     }
 }
-impl Display for AFLFuzzerStats<'_> {
+impl Display for AflFuzzerStats<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         writeln!(f, "start_time        : {}", &self.start_time)?;
         writeln!(f, "start_time        : {}", &self.start_time)?;

libafl_sugar/src/forkserver.rs

@@ -39,7 +39,7 @@ use libafl_bolts::{
     shmem::{ShMem, ShMemProvider, UnixShMemProvider},
     tuples::{Merge, tuple_list},
 };
-use libafl_targets::AFLppCmpLogMap;
+use libafl_targets::AflppCmpLogMap;
 use typed_builder::TypedBuilder;
 
 use crate::{CORPUS_CACHE_SIZE, DEFAULT_TIMEOUT_SECS};
@@ -265,14 +265,14 @@ impl ForkserverBytesCoverageSugar<'_> {
             if let Some(exec) = &self.cmplog_binary {
                 // The cmplog map shared between observer and executor
                 let mut cmplog_shmem = shmem_provider_client
-                    .uninit_on_shmem::<AFLppCmpLogMap>()
+                    .uninit_on_shmem::<AflppCmpLogMap>()
                     .unwrap();
                 // let the forkserver know the shmid
                 unsafe {
                     cmplog_shmem.write_to_env(SHM_CMPLOG_ENV_VAR).unwrap();
                 }
                 let cmpmap =
-                    unsafe { OwnedRefMut::<AFLppCmpLogMap>::from_shmem(&mut cmplog_shmem) };
+                    unsafe { OwnedRefMut::<AflppCmpLogMap>::from_shmem(&mut cmplog_shmem) };
 
                 let cmplog_observer = StdCmpObserver::new("cmplog", cmpmap, true);