address clippy issues in agent

src/agent/debugger/src/dbghelp.rs

@@ -602,7 +602,7 @@ impl DebugHelpGuard {
     ) -> Result<SymLineInfo> {
         let mut line_info: IMAGEHLP_LINEW64 = unsafe { MaybeUninit::zeroed().assume_init() };
         line_info.SizeOfStruct = size_of::<IMAGEHLP_LINEW64>() as DWORD;
-        let mut displacement = 0 as DWORD;
+        let mut displacement: DWORD = 0;
         check_winapi(|| unsafe {
             SymGetLineFromInlineContextW(
                 process_handle,

src/agent/debugger/src/target.rs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+#![allow(clippy::single_match)]
+
 use std::{
     collections::hash_map,
     fs,
@@ -405,14 +407,16 @@ impl Target {
                 bp.set_original_byte(Some(original_byte));
                 bp.set_id(id);
             })
-            .or_insert(Breakpoint::new(
-                address,
-                kind,
-                /*enabled*/ true,
-                /*original_byte*/ Some(original_byte),
-                /*hit_count*/ 0,
-                id,
-            ));
+            .or_insert_with(|| {
+                Breakpoint::new(
+                    address,
+                    kind,
+                    /*enabled*/ true,
+                    /*original_byte*/ Some(original_byte),
+                    /*hit_count*/ 0,
+                    id,
+                )
+            });
 
         write_instruction_byte(self.process_handle, address, 0xcc)?;
 

src/agent/input-tester/src/test_result/mod.rs

@@ -343,17 +343,11 @@ impl ExitStatus {
     }
 
     pub fn is_normal_exit(&self) -> bool {
-        match self {
-            ExitStatus::Code(_) => true,
-            _ => false,
-        }
+        matches!(self, ExitStatus::Code(_))
     }
 
     pub fn is_timeout(&self) -> bool {
-        match self {
-            ExitStatus::Timeout(_) => true,
-            _ => false,
-        }
+        matches!(self, ExitStatus::Timeout(_))
     }
 }
 

src/agent/input-tester/src/tester.rs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+#![allow(clippy::match_like_matches_macro)]
 #![allow(clippy::unknown_clippy_lints)]
 #![allow(clippy::single_component_path_imports)]
 #![allow(clippy::option_map_or_none)]

src/agent/onefuzz-agent/src/local/common.rs

@@ -26,17 +26,17 @@ pub const CHECK_FUZZER_HELP: &str = "check_fuzzer_help";
 pub const TARGET_EXE: &str = "target_exe";
 pub const TARGET_ENV: &str = "target_env";
 pub const TARGET_OPTIONS: &str = "target_options";
-pub const SUPERVISOR_EXE: &str = "supervisor_exe";
-pub const SUPERVISOR_ENV: &str = "supervisor_env";
-pub const SUPERVISOR_OPTIONS: &str = "supervisor_options";
+// pub const SUPERVISOR_EXE: &str = "supervisor_exe";
+// pub const SUPERVISOR_ENV: &str = "supervisor_env";
+// pub const SUPERVISOR_OPTIONS: &str = "supervisor_options";
 pub const GENERATOR_EXE: &str = "generator_exe";
 pub const GENERATOR_ENV: &str = "generator_env";
 pub const GENERATOR_OPTIONS: &str = "generator_options";
 
 pub enum CmdType {
     Target,
     Generator,
-    Supervisor,
+    // Supervisor,
 }
 
 pub fn add_cmd_options(
@@ -48,7 +48,7 @@ pub fn add_cmd_options(
 ) -> App<'static, 'static> {
     let (exe_name, env_name, arg_name) = match cmd_type {
         CmdType::Target => (TARGET_EXE, TARGET_ENV, TARGET_OPTIONS),
-        CmdType::Supervisor => (SUPERVISOR_EXE, SUPERVISOR_ENV, SUPERVISOR_OPTIONS),
+        // CmdType::Supervisor => (SUPERVISOR_EXE, SUPERVISOR_ENV, SUPERVISOR_OPTIONS),
         CmdType::Generator => (GENERATOR_EXE, GENERATOR_ENV, GENERATOR_OPTIONS),
     };
 
@@ -78,7 +78,7 @@ pub fn add_cmd_options(
 pub fn get_cmd_exe(cmd_type: CmdType, args: &clap::ArgMatches<'_>) -> Result<String> {
     let name = match cmd_type {
         CmdType::Target => TARGET_EXE,
-        CmdType::Supervisor => SUPERVISOR_EXE,
+        // CmdType::Supervisor => SUPERVISOR_EXE,
         CmdType::Generator => GENERATOR_EXE,
     };
 
@@ -89,7 +89,7 @@ pub fn get_cmd_exe(cmd_type: CmdType, args: &clap::ArgMatches<'_>) -> Result<Str
 pub fn get_cmd_arg(cmd_type: CmdType, args: &clap::ArgMatches<'_>) -> Vec<String> {
     let name = match cmd_type {
         CmdType::Target => TARGET_OPTIONS,
-        CmdType::Supervisor => SUPERVISOR_OPTIONS,
+        // CmdType::Supervisor => SUPERVISOR_OPTIONS,
         CmdType::Generator => GENERATOR_OPTIONS,
     };
 
@@ -102,7 +102,7 @@ pub fn get_cmd_env(
 ) -> Result<HashMap<String, String>> {
     let env_name = match cmd_type {
         CmdType::Target => TARGET_ENV,
-        CmdType::Supervisor => SUPERVISOR_ENV,
+        // CmdType::Supervisor => SUPERVISOR_ENV,
         CmdType::Generator => GENERATOR_ENV,
     };
 
@@ -156,15 +156,13 @@ pub fn build_common_config(args: &ArgMatches<'_>) -> Result<CommonConfig> {
 
     let setup_dir = if args.is_present(SETUP_DIR) {
         value_t!(args, SETUP_DIR, PathBuf)?
+    } else if args.is_present(TARGET_EXE) {
+        value_t!(args, TARGET_EXE, PathBuf)?
+            .parent()
+            .map(|x| x.to_path_buf())
+            .unwrap_or_default()
     } else {
-        if args.is_present(TARGET_EXE) {
-            value_t!(args, TARGET_EXE, PathBuf)?
-                .parent()
-                .map(|x| x.to_path_buf())
-                .unwrap_or_default()
-        } else {
-            PathBuf::default()
-        }
+        PathBuf::default()
     };
 
     let config = CommonConfig {

src/agent/onefuzz-agent/src/tasks/fuzz/generator.rs

@@ -91,18 +91,21 @@ impl GeneratorTask {
     }
 
     async fn fuzzing_loop(&self, heartbeat_client: Option<TaskHeartbeatClient>) -> Result<()> {
-        let tester = Tester::new(
+        let mut tester = Tester::new(
             &self.config.common.setup_dir,
             &self.config.target_exe,
             &self.config.target_options,
             &self.config.target_env,
-            &self.config.target_timeout,
-            self.config.check_asan_log,
-            false,
-            self.config.check_debugger,
-            self.config.check_retry_count,
         );
 
+        tester
+            .check_asan_log(self.config.check_asan_log)
+            .check_debugger(self.config.check_debugger)
+            .check_retry_count(self.config.check_retry_count);
+        if let Some(timeout) = self.config.target_timeout {
+            tester.timeout(timeout);
+        }
+
         loop {
             for corpus_dir in &self.config.readonly_inputs {
                 heartbeat_client.alive();

src/agent/onefuzz-agent/src/tasks/report/generic.rs

@@ -118,18 +118,18 @@ pub struct GenericReportProcessor<'a> {
 
 impl<'a> GenericReportProcessor<'a> {
     pub fn new(config: &'a Config, heartbeat_client: Option<TaskHeartbeatClient>) -> Self {
-        let tester = Tester::new(
+        let mut tester = Tester::new(
             &config.common.setup_dir,
             &config.target_exe,
             &config.target_options,
             &config.target_env,
-            &config.target_timeout,
-            config.check_asan_log,
-            false,
-            config.check_debugger,
-            config.check_retry_count,
         );
 
+        tester
+            .check_asan_log(config.check_asan_log)
+            .check_debugger(config.check_debugger)
+            .check_retry_count(config.check_retry_count);
+
         Self {
             config,
             tester,

src/agent/onefuzz/src/input_tester.rs

@@ -12,7 +12,7 @@ use anyhow::{Error, Result};
 use std::{collections::HashMap, path::Path, time::Duration};
 use tempfile::tempdir;
 
-const DEFAULT_TIMEOUT_SECS: u64 = 5;
+const DEFAULT_TIMEOUT: Duration = Duration::from_secs(5);
 const CRASH_SITE_UNAVAILABLE: &str = "<crash site unavailable>";
 
 pub struct Tester<'a> {
@@ -47,26 +47,45 @@ impl<'a> Tester<'a> {
         exe_path: &'a Path,
         arguments: &'a [String],
         environ: &'a HashMap<String, String>,
-        timeout: &'a Option<u64>,
-        check_asan_log: bool,
-        check_asan_stderr: bool,
-        check_debugger: bool,
-        check_retry_count: u64,
     ) -> Self {
-        let timeout = Duration::from_secs(timeout.unwrap_or(DEFAULT_TIMEOUT_SECS));
         Self {
             setup_dir,
             exe_path,
             arguments,
             environ,
-            timeout,
-            check_asan_log,
-            check_asan_stderr,
-            check_debugger,
-            check_retry_count,
+            timeout: DEFAULT_TIMEOUT,
+            check_asan_log: false,
+            check_asan_stderr: false,
+            check_debugger: true,
+            check_retry_count: 0,
         }
     }
 
+    pub fn timeout(&mut self, value: u64) -> &mut Self {
+        self.timeout = Duration::from_secs(value);
+        self
+    }
+
+    pub fn check_asan_log(&mut self, value: bool) -> &mut Self {
+        self.check_asan_log = value;
+        self
+    }
+
+    pub fn check_asan_stderr(&mut self, value: bool) -> &mut Self {
+        self.check_asan_stderr = value;
+        self
+    }
+
+    pub fn check_debugger(&mut self, value: bool) -> &mut Self {
+        self.check_debugger = value;
+        self
+    }
+
+    pub fn check_retry_count(&mut self, value: u64) -> &mut Self {
+        self.check_retry_count = value;
+        self
+    }
+
     #[cfg(target_os = "windows")]
     async fn test_input_debugger(
         &self,

src/agent/onefuzz/src/libfuzzer.rs

@@ -162,17 +162,11 @@ impl<'a> LibFuzzer<'a> {
         let mut options = self.options.to_owned();
         options.push("{input}".to_string());
 
-        let tester = Tester::new(
-            &self.setup_dir,
-            &self.exe,
-            &options,
-            &self.env,
-            &timeout,
-            false,
-            true,
-            false,
-            retry,
-        );
+        let mut tester = Tester::new(&self.setup_dir, &self.exe, &options, &self.env);
+        tester.check_asan_stderr(true).check_retry_count(retry);
+        if let Some(timeout) = timeout {
+            tester.timeout(timeout);
+        }
         tester.test_input(test_input.as_ref()).await
     }
 

src/agent/onefuzz/src/machine_id.rs

@@ -2,8 +2,11 @@
 // Licensed under the MIT License.
 
 use crate::fs::{onefuzz_etc, write_file};
-use anyhow::{Context, Result};
+#[cfg(target_os = "linux")]
+use anyhow::Context;
+use anyhow::Result;
 use reqwest_retry::SendRetry;
+#[cfg(target_os = "linux")]
 use std::path::Path;
 use std::time::Duration;
 use tokio::fs;

src/ci/agent.sh

@@ -29,12 +29,12 @@ mkdir -p artifacts/agent
 
 cd src/agent
 cargo fmt -- --check
-# RUSTSEC-2019-0031: a dependency spin (pulled in from ring) is not actively maintained
 # RUSTSEC-2020-0016: a dependency net2 (pulled in from tokio) is deprecated
 # RUSTSEC-2020-0036: a dependency failure (pulled from proc-maps) is deprecated
-cargo audit --deny warnings --deny unmaintained --deny unsound --deny yanked --ignore RUSTSEC-2019-0031 --ignore RUSTSEC-2020-0016 --ignore RUSTSEC-2020-0036
+cargo audit --deny warnings --deny unmaintained --deny unsound --deny yanked --ignore RUSTSEC-2020-0016 --ignore RUSTSEC-2020-0036
 cargo-license -j > data/licenses.json
 cargo build --release --locked
+cargo clippy --release -- -D warnings
 # export RUST_LOG=trace
 export RUST_BACKTRACE=full
 cargo test --release --manifest-path ./onefuzz-supervisor/Cargo.toml