added a step to make sure state infomration is saved before exit, and

updated the parse_scope command to work better.

src/appstate.rs

@@ -281,6 +281,7 @@ impl AppState {
         self.help.push(
             "Shortcuts:\nCTRL+P = new_project\nCTRL+s = save\nCTRL_+h = select_host\n".to_string(),
         );
+        self.help.push("exclude\nexcludes an IP or a cidr network from the scope and all future tool calls.\nexport 192.168.1.1 192.168.2.0/24\n".to_string());
         self.help.push("exit\nquit the tool\n".to_string());
         self.initialize_modules();
         return Ok(());
@@ -864,23 +865,52 @@ impl AppState {
             }
             "parse_scope" => {
                 let mut general_path = self.projects[self.selected_project].notes.clone();
+                let mut scope_path = self.projects[self.selected_project].notes.clone();
+                scope_path.push("scope.md");
                 general_path.push("general.md");
                 let general_string = read_to_string(general_path)?;
-                if let Some((_, scope_section)) = general_string.split_once("# Scope") {
-                    if let Some((scope_section, _)) = scope_section.split_once("#") {
-                        scope_section.lines().into_iter().for_each(|line| {
-                            if line.contains("|") {
-                                if !line.contains("Subnet") {
-                                    if !line.contains("--") {
-                                        let host =
-                                            line.split("|").collect::<Vec<&str>>()[1].to_string();
-                                        self.projects[self.selected_project].add_scope(host);
+                let mut scope_file = OpenOptions::new()
+                    .create(true)
+                    .truncate(true)
+                    .write(true)
+                    .open(scope_path)?;
+                general_string
+                    .split_whitespace()
+                    .into_iter()
+                    .for_each(|word| {
+                        if let Ok(_) = word.trim().parse::<IpNet>() {
+                            if let Err(e) = write!(scope_file, "{}\n", word) {
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    format!("Error writing scope file! {e}"),
+                                )));
                             }
+                        } else if let Ok(_) = word.trim().parse::<IpAddr>() {
+                            if let Err(e) = write!(scope_file, "{}\n", word) {
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    format!("Error writing scope file! {e}"),
+                                )));
+                            }
+                        } else if word.contains(".com")
+                            || word.contains(".org")
+                            || word.contains(".gov")
+                            || word.contains(".site")
+                            || word.contains(".local")
+                            || word.contains(".ad")
+                        {
+                            if let Err(e) = write!(scope_file, "{}\n", word) {
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    format!("Error writing scope file! {e}"),
+                                )));
                             }
                         }
                     });
-                    }
-                }
+                let _ = self.main_tx.send(ToolMessage::Output((
+                    rid,
+                    "[success] scope parsed and scope.md written!".to_string(),
+                )));
             }
             "show_config" | "sc" => {
                 let _ = self
@@ -1151,6 +1181,7 @@ impl AppState {
                             }
                             2 => {
                                 args_vec[0].split(",").into_iter().for_each(|ip| {
+                                    if !project.exclusions.contains(&ip.to_string()) {
                                         if let Ok(ip) = ip.parse::<IpAddr>() {
                                             let mut new_host = Host::new();
                                             new_host.ip = ip.to_string();
@@ -1162,6 +1193,7 @@ impl AppState {
                                                 hosts.push(new_host);
                                             }
                                         }
+                                    }
                                 });
                                 args_vec[1].split(",").into_iter().for_each(|p| {
                                     if p.contains("-") {
@@ -1660,6 +1692,30 @@ impl AppState {
                 }
             }
 
+            "exclude" => {
+                if let Some(args) = command_args {
+                    let project = self.projects[self.selected_project].clone();
+                    if args.contains(" ") {
+                        args.split(" ")
+                            .into_iter()
+                            .filter(|ex| !project.exclusions.contains(&ex.to_string()))
+                            .for_each(|ex| {
+                                if let Ok(_) = ex.parse::<IpAddr>() {
+                                    self.projects[self.selected_project]
+                                        .exclusions
+                                        .push(ex.to_string());
+                                } else if let Ok(net) = ex.parse::<IpNet>() {
+                                    net.hosts().into_iter().for_each(|ip| {
+                                        self.projects[self.selected_project]
+                                            .exclusions
+                                            .push(ip.to_string());
+                                    });
+                                }
+                            });
+                    }
+                }
+            }
+
             "exit" => {
                 self.save_all()?;
                 let _ = self.main_tx.send(ToolMessage::AppStateExit);
@@ -1945,6 +2001,7 @@ impl AppState {
             current: false,
             db: db,
             scope: Vec::new(),
+            exclusions: Vec::new(),
         };
         match new_project.save_config() {
             Ok(_) => {}

src/funcs.rs

@@ -1086,6 +1086,9 @@ pub fn run_tui(
             server_lock.action_que.push("disconnect".to_string());
         }
     });
+    println!("saving state information");
+    let _ = state.save_all();
+    println!("SAVED!");
     for handle in handles {
         handle.join().unwrap();
     }

src/project.rs

@@ -10,6 +10,7 @@ use std::net::IpAddr;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use std::sync::mpsc::Sender;
+use walkdir::WalkDir;
 
 #[derive(Clone, Debug)]
 pub struct Project {
@@ -22,6 +23,7 @@ pub struct Project {
     pub current: bool,
     pub db: Option<DistroBox>,
     pub scope: Vec<String>,
+    pub exclusions: Vec<String>,
 }
 
 impl Project {
@@ -36,6 +38,7 @@ impl Project {
             current: false,
             db: None,
             scope: Vec::new(),
+            exclusions: Vec::new(),
         }
     }
 
@@ -56,6 +59,7 @@ impl Project {
     }
 
     pub fn add_host(&mut self, mut host: Host) {
+        if !self.exclusions.contains(&host.ip) {
             let mut new_id = 0;
             self.hosts.iter().for_each(|h| {
                 if h.id > new_id {
@@ -68,6 +72,7 @@ impl Project {
                 self.hosts.push(host);
             }
         }
+    }
 
     pub fn config_folder(&mut self, path: PathBuf) {
         self.config_folder = path;
@@ -106,6 +111,12 @@ impl Project {
                             self.add_scope(ip.trim().to_string());
                         });
                     }
+                    "exclusions" => {
+                        let ips: Vec<&str> = parts[1].split(",").collect();
+                        ips.iter().for_each(|ip| {
+                            self.exclusions.push(ip.to_string());
+                        });
+                    }
                     _ => {}
                 }
             }
@@ -225,12 +236,13 @@ impl Project {
         }
         let mut file = File::create(&self.config_folder)?;
         let mut out_string = format!(
-            "org_name: {}\nname: {}\nnotes: {}\nfiles: {}\nscope: {}\n",
+            "org_name: {}\nname: {}\nnotes: {}\nfiles: {}\nscope: {}\nexclusions: {}\n",
             self.org_name,
             self.name,
             self.notes.display(),
             self.files.display(),
             self.scope.join(","),
+            self.exclusions.join(","),
         );
         if self.current {
             out_string.push_str("stage: current");