added auto-tune and auto-bail to config

src/config/container.rs

@@ -1,8 +1,9 @@
 use super::utils::{
     depth, report_and_exit, save_state, serialized_type, status_codes, threads, timeout,
-    user_agent, wordlist, OutputLevel,
+    user_agent, wordlist, OutputLevel, RequesterPolicy,
 };
 use crate::config::determine_output_level;
+use crate::config::utils::determine_requester_policy;
 use crate::{
     client, parser, scan_manager::resume_scan, traits::FeroxSerialize, utils::fmt_err,
     DEFAULT_CONFIG_NAME,
@@ -124,6 +125,18 @@ pub struct Configuration {
     #[serde(skip)]
     pub output_level: OutputLevel,
 
+    /// automatically bail at certain error thresholds
+    #[serde(default)]
+    pub auto_bail: bool,
+
+    /// automatically try to lower request rate in order to reduce errors
+    #[serde(default)]
+    pub auto_tune: bool,
+
+    /// more easily differentiate between the three requester policies
+    #[serde(skip)]
+    pub requester_policy: RequesterPolicy,
+
     /// Store log output as NDJSON
     #[serde(default)]
     pub json: bool,
@@ -245,6 +258,7 @@ impl Default for Configuration {
         let replay_codes = status_codes.clone();
         let kind = serialized_type();
         let output_level = OutputLevel::Default;
+        let requester_policy = RequesterPolicy::Default;
 
         Configuration {
             kind,
@@ -254,7 +268,10 @@ impl Default for Configuration {
             replay_codes,
             status_codes,
             replay_client,
+            requester_policy,
             dont_filter: false,
+            auto_bail: false,
+            auto_tune: false,
             silent: false,
             quiet: false,
             output_level,
@@ -313,6 +330,8 @@ impl Configuration {
     /// - **debug_log**: `None`
     /// - **quiet**: `false`
     /// - **silent**: `false`
+    /// - **auto_tune**: `false`
+    /// - **auto_bail**: `false`
     /// - **save_state**: `true`
     /// - **user_agent**: `feroxbuster/VERSION`
     /// - **insecure**: `false` (don't be insecure, i.e. don't allow invalid certs)
@@ -561,6 +580,16 @@ impl Configuration {
             config.output_level = OutputLevel::Quiet;
         }
 
+        if args.is_present("auto_tune") {
+            config.auto_tune = true;
+            config.requester_policy = RequesterPolicy::AutoTune;
+        }
+
+        if args.is_present("auto_bail") {
+            config.auto_bail = true;
+            config.requester_policy = RequesterPolicy::AutoBail;
+        }
+
         if args.is_present("dont_filter") {
             config.dont_filter = true;
         }
@@ -721,8 +750,9 @@ impl Configuration {
         update_if_not_default!(&mut conf.verbosity, new.verbosity, 0);
         update_if_not_default!(&mut conf.silent, new.silent, false);
         update_if_not_default!(&mut conf.quiet, new.quiet, false);
-        // use updated quiet/silent values to determin output level
+        // use updated quiet/silent values to determine output level; same for requester policy
         conf.output_level = determine_output_level(conf.quiet, conf.silent);
+        conf.requester_policy = determine_requester_policy(conf.auto_tune, conf.auto_bail);
         update_if_not_default!(&mut conf.output, new.output, "");
         update_if_not_default!(&mut conf.redirects, new.redirects, false);
         update_if_not_default!(&mut conf.insecure, new.insecure, false);

src/config/mod.rs

@@ -6,4 +6,4 @@ mod utils;
 mod tests;
 
 pub use self::container::Configuration;
-pub use self::utils::{determine_output_level, OutputLevel};
+pub use self::utils::{determine_output_level, OutputLevel, RequesterPolicy};

src/config/tests.rs

@@ -16,6 +16,8 @@ fn setup_config_test() -> Configuration {
             replay_proxy = "http://127.0.0.1:8081"
             quiet = true
             silent = true
+            auto_tune = true
+            auto_bail = true
             verbosity = 1
             scan_limit = 6
             rate_limit = 250
@@ -71,7 +73,11 @@ fn default_configuration() {
     assert_eq!(config.scan_limit, 0);
     assert_eq!(config.silent, false);
     assert_eq!(config.quiet, false);
+    assert_eq!(config.output_level, OutputLevel::Default);
     assert_eq!(config.dont_filter, false);
+    assert_eq!(config.auto_tune, false);
+    assert_eq!(config.auto_bail, false);
+    assert_eq!(config.requester_policy, RequesterPolicy::Default);
     assert_eq!(config.no_recursion, false);
     assert_eq!(config.json, false);
     assert_eq!(config.save_state, true);
@@ -189,6 +195,20 @@ fn config_reads_json() {
     assert_eq!(config.json, true);
 }
 
+#[test]
+/// parse the test config and see that the value parsed is correct
+fn config_reads_auto_bail() {
+    let config = setup_config_test();
+    assert_eq!(config.auto_bail, true);
+}
+
+#[test]
+/// parse the test config and see that the value parsed is correct
+fn config_reads_auto_tune() {
+    let config = setup_config_test();
+    assert_eq!(config.auto_tune, true);
+}
+
 #[test]
 /// parse the test config and see that the value parsed is correct
 fn config_reads_verbosity() {

src/config/utils.rs

@@ -102,6 +102,41 @@ pub fn determine_output_level(quiet: bool, silent: bool) -> OutputLevel {
     }
 }
 
+/// represents actions the Requester should take in certain situations
+#[derive(Debug, PartialEq, Copy, Clone)]
+pub enum RequesterPolicy {
+    /// automatically try to lower request rate in order to reduce errors
+    AutoTune,
+
+    /// automatically bail at certain error thresholds
+    AutoBail,
+
+    /// just let that junk run super natural
+    Default,
+}
+
+/// default implementation for RequesterPolicy
+impl Default for RequesterPolicy {
+    /// Default as default
+    fn default() -> Self {
+        Self::Default
+    }
+}
+
+/// given the current settings for quiet and silent, determine output_level (DRY helper)
+pub fn determine_requester_policy(auto_tune: bool, auto_bail: bool) -> RequesterPolicy {
+    if auto_tune && auto_bail {
+        // user COULD have both as true in config file, take the more aggressive of the two
+        RequesterPolicy::AutoBail
+    } else if auto_tune {
+        RequesterPolicy::AutoTune
+    } else if auto_bail {
+        RequesterPolicy::AutoBail
+    } else {
+        RequesterPolicy::Default
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -122,6 +157,22 @@ mod tests {
         assert_eq!(level, OutputLevel::Quiet);
     }
 
+    #[test]
+    /// test determine_requester_policy returns higher of the two levels if both given values are true
+    fn determine_requester_policy_returns_correct_results() {
+        let mut level = determine_requester_policy(true, true);
+        assert_eq!(level, RequesterPolicy::AutoBail);
+
+        level = determine_requester_policy(false, true);
+        assert_eq!(level, RequesterPolicy::AutoBail);
+
+        level = determine_requester_policy(false, false);
+        assert_eq!(level, RequesterPolicy::Default);
+
+        level = determine_requester_policy(true, false);
+        assert_eq!(level, RequesterPolicy::AutoTune);
+    }
+
     #[test]
     #[should_panic]
     /// report_and_exit should panic/exit when called

src/scanner/mod.rs

@@ -6,4 +6,3 @@ mod tests;
 
 pub use self::container::{FeroxScanner, RESPONSES};
 pub use self::init::initialize;
-pub use self::utils::RequesterPolicy;

src/scanner/utils.rs

@@ -1,5 +1,6 @@
 use super::FeroxScanner;
 use crate::{
+    config::RequesterPolicy,
     event_handlers::{
         Command::{self, AddError},
         Handles,
@@ -15,19 +16,6 @@ use leaky_bucket::LeakyBucket;
 use std::{cmp::max, sync::Arc};
 use tokio::{sync::oneshot, time::Duration};
 
-/// represents actions the Requester should take in certain situations
-#[derive(Debug, PartialEq, Copy, Clone)]
-pub enum RequesterPolicy {
-    /// automatically try to lower request rate in order to reduce errors
-    AutoTune,
-
-    /// automatically bail at certain error thresholds
-    AutoBail,
-
-    /// just let that junk run super natural
-    Default,
-}
-
 /// Makes multiple requests based on the presence of extensions
 pub(super) struct Requester {
     /// handles to handlers and config