Make every Builder ::builder(), so BobTheBuilder::new() becomes BobTh…

…e::builder() (AFLplusplus#2242)

* Make every builder ::builder()

* Fix no_std

* More

* Fix clippy, stuff

* More fun

* Make NopShMem do something

* Alloc

* more fmt

* Remove UB in tinyinst executor builder

* Make builder order not matter for tinyinst

* More better

* fix

* docs

* fmt

* more fmt

* clippy

* fix fixes

* tiny thing

* more betterg

* more more

* more builder

* more builder

* more nyx

* undo breaking clippy

* clip

fuzzers/nautilus_sync/src/lib.rs

@@ -9,7 +9,7 @@ use std::{env, net::SocketAddr, path::PathBuf, time::Duration};
 use clap::Parser;
 use libafl::{
     corpus::{InMemoryCorpus, OnDiskCorpus},
-    events::{launcher::Launcher, EventConfig, LlmpEventConverterBuilder},
+    events::{launcher::Launcher, llmp::LlmpEventConverter, EventConfig},
     executors::{inprocess::InProcessExecutor, ExitKind},
     feedback_or,
     feedbacks::{CrashFeedback, MaxMapFeedback, NautilusChunksMetadata, NautilusFeedback},
@@ -120,7 +120,7 @@ pub extern "C" fn libafl_main() {
     let context = NautilusContext::from_file(15, "grammar.json");
 
     let mut event_converter = opt.bytes_broker_port.map(|port| {
-        LlmpEventConverterBuilder::new()
+        LlmpEventConverter::builder()
             .build_on_port(
                 shmem_provider.clone(),
                 port,

fuzzers/nyx_libxml2_parallel/src/main.rs

@@ -19,7 +19,7 @@ use libafl_bolts::{
     shmem::{ShMemProvider, StdShMemProvider},
     tuples::tuple_list,
 };
-use libafl_nyx::{executor::NyxExecutorBuilder, helper::NyxHelper, settings::NyxSettings};
+use libafl_nyx::{executor::NyxExecutor, helper::NyxHelper, settings::NyxSettings};
 
 fn main() {
     let shmem_provider = StdShMemProvider::new().expect("Failed to init shared memory");
@@ -54,7 +54,7 @@ fn main() {
         let mut feedback = MaxMapFeedback::new(&observer);
         let mut objective = CrashFeedback::new();
         let scheduler = RandScheduler::new();
-        let mut executor = NyxExecutorBuilder::new().build(helper, tuple_list!(observer));
+        let mut executor = NyxExecutor::builder().build(helper, tuple_list!(observer));
 
         // If not restarting, create a State from scratch
         let mut state = state.unwrap_or_else(|| {

fuzzers/nyx_libxml2_standalone/src/main.rs

@@ -14,7 +14,7 @@ use libafl::{
     Fuzzer, StdFuzzer,
 };
 use libafl_bolts::{rands::StdRand, tuples::tuple_list};
-use libafl_nyx::{executor::NyxExecutorBuilder, helper::NyxHelper, settings::NyxSettings};
+use libafl_nyx::{executor::NyxExecutor, helper::NyxHelper, settings::NyxSettings};
 
 fn main() {
     // nyx stuff
@@ -44,7 +44,7 @@ fn main() {
     let monitor = TuiMonitor::new(ui);
 
     let mut mgr = SimpleEventManager::new(monitor);
-    let mut executor = NyxExecutorBuilder::new().build(helper, tuple_list!(observer));
+    let mut executor = NyxExecutor::builder().build(helper, tuple_list!(observer));
     let mutator = StdScheduledMutator::new(havoc_mutations());
     let mut stages = tuple_list!(StdMutationalStage::new(mutator));
 

fuzzers/tinyinst_simple/src/main.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{path::PathBuf, ptr::addr_of_mut, time::Duration};
 
 use libafl::{
     corpus::{CachedOnDiskCorpus, Corpus, OnDiskCorpus, Testcase},
@@ -20,7 +20,7 @@ use libafl_bolts::shmem::Win32ShMemProvider;
 use libafl_bolts::{
     ownedref::OwnedMutPtr, rands::StdRand, shmem::ShMemProvider, tuples::tuple_list,
 };
-use libafl_tinyinst::executor::TinyInstExecutorBuilder;
+use libafl_tinyinst::executor::TinyInstExecutor;
 static mut COVERAGE: Vec<u64> = vec![];
 
 #[cfg(not(any(target_vendor = "apple", windows, target_os = "linux")))]
@@ -37,7 +37,7 @@ fn main() {
     // use file to pass testcases
     // let args = vec!["test.exe".to_string(), "-f".to_string(), "@@".to_string()];
 
-    let coverage = unsafe { OwnedMutPtr::Ptr(core::ptr::addr_of_mut!(COVERAGE)) };
+    let coverage = unsafe { OwnedMutPtr::Ptr(addr_of_mut!(COVERAGE)) };
     let observer = ListObserver::new("cov", coverage);
     let mut feedback = ListFeedback::new(&observer);
     #[cfg(windows)]
@@ -59,18 +59,19 @@ fn main() {
     let scheduler = RandScheduler::new();
     let mut fuzzer = StdFuzzer::new(scheduler, feedback, objective);
 
-    let monitor = SimpleMonitor::new(|x| println!("{}", x));
+    let monitor = SimpleMonitor::new(|x| println!("{x}"));
 
     let mut mgr = SimpleEventManager::new(monitor);
     let mut executor = unsafe {
-        TinyInstExecutorBuilder::new()
+        TinyInstExecutor::builder()
             .tinyinst_args(tinyinst_args)
             .program_args(args)
             .use_shmem()
             .persistent("test.exe".to_string(), "fuzz".to_string(), 1, 10000)
-            .timeout(std::time::Duration::new(5, 0))
+            .timeout(Duration::new(5, 0))
             .shmem_provider(&mut shmem_provider)
-            .build(&mut COVERAGE, tuple_list!(observer))
+            .coverage_ptr(addr_of_mut!(COVERAGE))
+            .build(tuple_list!(observer))
             .unwrap()
     };
     let mutator = StdScheduledMutator::new(havoc_mutations());

libafl/src/events/centralized.rs

@@ -19,11 +19,12 @@ use libafl_bolts::{
 };
 use libafl_bolts::{
     llmp::{self, LlmpBroker, LlmpClient, LlmpClientDescription, Tag},
-    shmem::ShMemProvider,
+    shmem::{NopShMemProvider, ShMemProvider},
     ClientId,
 };
 use serde::{Deserialize, Serialize};
 
+use super::NopEventManager;
 #[cfg(feature = "llmp_compression")]
 use crate::events::llmp::COMPRESS_THRESHOLD;
 #[cfg(feature = "adaptive_serialization")]
@@ -38,9 +39,9 @@ use crate::{
     },
     executors::{Executor, HasObservers},
     fuzzer::{EvaluatorObservers, ExecutionProcessor},
-    inputs::{Input, UsesInput},
+    inputs::{Input, NopInput, UsesInput},
     observers::ObserversTuple,
-    state::{HasExecutions, HasLastReportTime, UsesState},
+    state::{HasExecutions, HasLastReportTime, NopState, UsesState},
     Error, HasMetadata,
 };
 
@@ -230,6 +231,14 @@ where
     is_main: bool,
 }
 
+impl CentralizedEventManager<NopEventManager<NopState<NopInput>>, NopShMemProvider> {
+    /// Creates a builder for [`CentralizedEventManager`]
+    #[must_use]
+    pub fn builder() -> CentralizedEventManagerBuilder {
+        CentralizedEventManagerBuilder::new()
+    }
+}
+
 /// The builder or `CentralizedEventManager`
 #[derive(Debug)]
 pub struct CentralizedEventManagerBuilder {

libafl/src/events/launcher.rs

@@ -48,10 +48,8 @@ use libafl_bolts::{
 use typed_builder::TypedBuilder;
 
 use super::hooks::EventManagerHooksTuple;
-#[cfg(all(unix, feature = "std"))]
-use crate::events::centralized::CentralizedEventManagerBuilder;
 #[cfg(all(unix, feature = "std", feature = "fork"))]
-use crate::events::{CentralizedEventManager, CentralizedLlmpEventBroker};
+use crate::events::centralized::{CentralizedEventManager, CentralizedLlmpEventBroker};
 #[cfg(feature = "adaptive_serialization")]
 use crate::observers::TimeObserver;
 #[cfg(feature = "std")]
@@ -698,7 +696,7 @@ where
                         let builder = builder.time_ref(self.time_obs.handle());
                         let (state, mgr) = builder.build().launch()?;
 
-                        let mut centralized_builder = CentralizedEventManagerBuilder::new();
+                        let mut centralized_builder = CentralizedEventManager::builder();
 
                         if index == 1 {
                             centralized_builder = centralized_builder.is_main(true);

libafl/src/events/llmp/mgr.rs

@@ -18,7 +18,7 @@ use libafl_bolts::{
 use libafl_bolts::{
     current_time,
     llmp::{LlmpClient, LlmpClientDescription},
-    shmem::ShMemProvider,
+    shmem::{NopShMemProvider, ShMemProvider},
     ClientId,
 };
 #[cfg(feature = "std")]
@@ -44,9 +44,9 @@ use crate::{
     },
     executors::{Executor, HasObservers},
     fuzzer::{EvaluatorObservers, ExecutionProcessor},
-    inputs::UsesInput,
+    inputs::{NopInput, UsesInput},
     observers::ObserversTuple,
-    state::{HasExecutions, HasLastReportTime, State, UsesState},
+    state::{HasExecutions, HasLastReportTime, NopState, State, UsesState},
     Error, HasMetadata,
 };
 
@@ -85,6 +85,14 @@ where
     phantom: PhantomData<S>,
 }
 
+impl LlmpEventManager<(), NopState<NopInput>, NopShMemProvider> {
+    /// Creates a builder for [`LlmpEventManager`]
+    #[must_use]
+    pub fn builder() -> LlmpEventManagerBuilder<()> {
+        LlmpEventManagerBuilder::new()
+    }
+}
+
 /// Builder for `LlmpEventManager`
 #[derive(Debug, Copy, Clone)]
 pub struct LlmpEventManagerBuilder<EMH> {

libafl/src/events/llmp/mod.rs

@@ -10,7 +10,7 @@ use libafl_bolts::{
 };
 use libafl_bolts::{
     llmp::{LlmpClient, LlmpClientDescription, Tag},
-    shmem::ShMemProvider,
+    shmem::{NopShMemProvider, ShMemProvider},
     ClientId,
 };
 use serde::Deserialize;
@@ -19,8 +19,8 @@ use crate::{
     events::{CustomBufEventResult, CustomBufHandlerFn, Event, EventFirer},
     executors::{Executor, HasObservers},
     fuzzer::{EvaluatorObservers, ExecutionProcessor},
-    inputs::{Input, InputConverter, UsesInput},
-    state::{HasExecutions, State, UsesState},
+    inputs::{Input, InputConverter, NopInput, NopInputConverter, UsesInput},
+    state::{HasExecutions, NopState, State, UsesState},
     Error, HasMetadata,
 };
 
@@ -108,6 +108,22 @@ where
     phantom: PhantomData<S>,
 }
 
+impl
+    LlmpEventConverter<
+        NopInput,
+        NopInputConverter<NopInput>,
+        NopInputConverter<NopInput>,
+        NopState<NopInput>,
+        NopShMemProvider,
+    >
+{
+    /// Create a builder for [`LlmpEventConverter`]
+    #[must_use]
+    pub fn builder() -> LlmpEventConverterBuilder {
+        LlmpEventConverterBuilder::new()
+    }
+}
+
 /// Build `LlmpEventConverter`
 #[derive(Debug, Clone, Default)]
 pub struct LlmpEventConverterBuilder {

libafl/src/events/llmp/restarting.rs

@@ -1,4 +1,7 @@
-//! Llmp restarting manager
+//! The `LLMP` restarting manager will
+//! forward messages over lockless shared maps.
+//! When the target crashes, a watch process (the parent) will
+//! restart/refork it.
 
 use alloc::vec::Vec;
 #[cfg(all(unix, not(miri), feature = "std"))]
@@ -42,7 +45,7 @@ use crate::{
     events::{
         hooks::EventManagerHooksTuple, Event, EventConfig, EventFirer, EventManager,
         EventManagerId, EventProcessor, EventRestarter, HasEventManagerId, LlmpEventBroker,
-        LlmpEventManager, LlmpEventManagerBuilder, LlmpShouldSaveState, ProgressReporter,
+        LlmpEventManager, LlmpShouldSaveState, ProgressReporter,
     },
     executors::{Executor, HasObservers},
     fuzzer::{EvaluatorObservers, ExecutionProcessor},
@@ -483,11 +486,11 @@ where
                         }
                         LlmpConnection::IsClient { client } => {
                             #[cfg(not(feature = "adaptive_serialization"))]
-                            let mgr: LlmpEventManager<EMH, S, SP> = LlmpEventManagerBuilder::new()
+                            let mgr: LlmpEventManager<EMH, S, SP> = LlmpEventManager::builder()
                                 .hooks(self.hooks)
                                 .build_from_client(client, self.configuration)?;
                             #[cfg(feature = "adaptive_serialization")]
-                            let mgr: LlmpEventManager<EMH, S, SP> = LlmpEventManagerBuilder::new()
+                            let mgr: LlmpEventManager<EMH, S, SP> = LlmpEventManager::builder()
                                 .hooks(self.hooks)
                                 .build_from_client(
                                     client,
@@ -511,15 +514,15 @@ where
                 ManagerKind::Client { cpu_core } => {
                     // We are a client
                     #[cfg(not(feature = "adaptive_serialization"))]
-                    let mgr = LlmpEventManagerBuilder::new()
+                    let mgr = LlmpEventManager::builder()
                         .hooks(self.hooks)
                         .build_on_port(
                             self.shmem_provider.clone(),
                             self.broker_port,
                             self.configuration,
                         )?;
                     #[cfg(feature = "adaptive_serialization")]
-                    let mgr = LlmpEventManagerBuilder::new()
+                    let mgr = LlmpEventManager::builder()
                         .hooks(self.hooks)
                         .build_on_port(
                             self.shmem_provider.clone(),
@@ -648,15 +651,15 @@ where
         let (state, mut mgr) =
             if let Some((state_opt, mgr_description)) = staterestorer.restore()? {
                 #[cfg(not(feature = "adaptive_serialization"))]
-                let llmp_mgr = LlmpEventManagerBuilder::new()
+                let llmp_mgr = LlmpEventManager::builder()
                     .hooks(self.hooks)
                     .build_existing_client_from_description(
                         new_shmem_provider,
                         &mgr_description,
                         self.configuration,
                     )?;
                 #[cfg(feature = "adaptive_serialization")]
-                let llmp_mgr = LlmpEventManagerBuilder::new()
+                let llmp_mgr = LlmpEventManager::builder()
                     .hooks(self.hooks)
                     .build_existing_client_from_description(
                         new_shmem_provider,
@@ -676,15 +679,15 @@ where
                 log::info!("First run. Let's set it all up");
                 // Mgr to send and receive msgs from/to all other fuzzer instances
                 #[cfg(not(feature = "adaptive_serialization"))]
-                let mgr = LlmpEventManagerBuilder::new()
+                let mgr = LlmpEventManager::builder()
                     .hooks(self.hooks)
                     .build_existing_client_from_env(
                         new_shmem_provider,
                         _ENV_FUZZER_BROKER_CLIENT_INITIAL,
                         self.configuration,
                     )?;
                 #[cfg(feature = "adaptive_serialization")]
-                let mgr = LlmpEventManagerBuilder::new()
+                let mgr = LlmpEventManager::builder()
                     .hooks(self.hooks)
                     .build_existing_client_from_env(
                         new_shmem_provider,
@@ -738,7 +741,7 @@ mod tests {
 
     use crate::{
         corpus::{Corpus, InMemoryCorpus, Testcase},
-        events::llmp::{restarting::_ENV_FUZZER_SENDER, LlmpEventManagerBuilder},
+        events::llmp::{restarting::_ENV_FUZZER_SENDER, LlmpEventManager},
         executors::{ExitKind, InProcessExecutor},
         feedbacks::ConstFeedback,
         fuzzer::Fuzzer,
@@ -788,11 +791,11 @@ mod tests {
         }
 
         #[cfg(not(feature = "adaptive_serialization"))]
-        let mut llmp_mgr = LlmpEventManagerBuilder::new()
+        let mut llmp_mgr = LlmpEventManager::builder()
             .build_from_client(llmp_client, "fuzzer".into())
             .unwrap();
         #[cfg(feature = "adaptive_serialization")]
-        let mut llmp_mgr = LlmpEventManagerBuilder::new()
+        let mut llmp_mgr = LlmpEventManager::builder()
             .build_from_client(llmp_client, "fuzzer".into(), time_ref.clone())
             .unwrap();
 
@@ -837,15 +840,15 @@ mod tests {
 
         let (mut state_clone, mgr_description) = staterestorer.restore().unwrap().unwrap();
         #[cfg(not(feature = "adaptive_serialization"))]
-        let mut llmp_clone = LlmpEventManagerBuilder::new()
+        let mut llmp_clone = LlmpEventManager::builder()
             .build_existing_client_from_description(
                 shmem_provider,
                 &mgr_description,
                 "fuzzer".into(),
             )
             .unwrap();
         #[cfg(feature = "adaptive_serialization")]
-        let mut llmp_clone = LlmpEventManagerBuilder::new()
+        let mut llmp_clone = LlmpEventManager::builder()
             .build_existing_client_from_description(
                 shmem_provider,
                 &mgr_description,

libafl/src/events/tcp.rs

@@ -440,6 +440,17 @@ where
     phantom: PhantomData<S>,
 }
 
+impl<S> TcpEventManager<(), S>
+where
+    S: State,
+{
+    /// Create a builder for [`TcpEventManager`]
+    #[must_use]
+    pub fn builder() -> TcpEventManagerBuilder<(), S> {
+        TcpEventManagerBuilder::new()
+    }
+}
+
 /// Builder for `TcpEventManager`
 #[derive(Debug, Copy, Clone)]
 pub struct TcpEventManagerBuilder<EMH, S> {

libafl/src/executors/command.rs

@@ -182,8 +182,7 @@ impl CommandExecutor<(), (), ()> {
     /// By default, input is read from stdin, unless you specify a different location using
     /// * `arg_input_arg` for input delivered _as_ an command line argument
     /// * `arg_input_file` for input via a file of a specific name
-    /// * `arg_input_file_std` for a file with default name
-    /// (at the right location in the arguments)
+    /// * `arg_input_file_std` for a file with default name (at the right location in the arguments)
     #[must_use]
     pub fn builder() -> CommandExecutorBuilder {
         CommandExecutorBuilder::new()