Add: Add dependency filter functionality

This restructures the original feed-filter into separate files.
Additionally a dependency filter is added. It does not filter based on builtin functions
but based on given scipts and their dependencies.

Author: Kraemii

rust/src/feed_filter/builtins.rs

@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: 2026 Greenbone AG
+//
+// SPDX-License-Identifier: GPL-2.0-or-later WITH x11vnc-openssl-exception
+
+use scannerlib::nasl::nasl_std_functions;
+use scannerlib::nasl::syntax::grammar::Ast;
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::path::PathBuf;
+
+use crate::utils::iter_fn_calls;
+
+#[derive(Eq, Hash, PartialEq, Clone)]
+pub enum BuiltinStatus {
+    Used,
+    Unused,
+    Deprecated,
+}
+
+/// This struct holds information about implemented and unimplemented built-in functions
+/// based on the documentation files and rust implementation of NASL. It also tracks
+/// functions that are present in the rust implementation but not documented.
+pub struct BuiltinFunctions {
+    /// HashMap<function_name, (category, deprecated)>
+    implemented: HashMap<String, (String, bool)>,
+    /// HashMap<function_name, (category, deprecated)>
+    unimplemented: HashMap<String, (String, bool)>,
+    /// Set of undocumented functions
+    pub undocumented: HashSet<String>,
+}
+
+impl BuiltinFunctions {
+    pub fn new(doc_path: PathBuf) -> Self {
+        let mut implemented = HashMap::new();
+        let mut unimplemented = HashMap::new();
+
+        let exec = nasl_std_functions();
+        let mut implemented_funcs = exec.iter().map(|f| f.to_string()).collect::<HashSet<_>>();
+
+        for entry in fs::read_dir(doc_path).unwrap() {
+            let entry = entry.unwrap();
+            let category_path = entry.path();
+            let category = category_path
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+                .into_owned();
+
+            if category_path.is_dir() {
+                for func_entry in fs::read_dir(category_path).unwrap() {
+                    let func_path = func_entry.unwrap().path();
+                    let function = func_path
+                        .file_stem()
+                        .unwrap()
+                        .to_string_lossy()
+                        .into_owned();
+
+                    if function == "index" {
+                        continue;
+                    }
+
+                    let content = fs::read_to_string(func_path.clone())
+                        .unwrap()
+                        .to_ascii_lowercase();
+
+                    let deprecated = content.contains("## deprecated");
+
+                    if implemented_funcs.take(&function).is_some() {
+                        implemented.insert(function, (category.clone(), deprecated));
+                    } else {
+                        unimplemented.insert(function, (category.clone(), deprecated));
+                    }
+                }
+            }
+        }
+        Self {
+            implemented,
+            unimplemented,
+            undocumented: implemented_funcs,
+        }
+    }
+
+    pub fn implemented(&self) -> &HashMap<String, (String, bool)> {
+        &self.implemented
+    }
+
+    pub fn unimplemented(&self) -> &HashMap<String, (String, bool)> {
+        &self.unimplemented
+    }
+
+    pub fn script_is_runnable(&self, ast: &Ast) -> bool {
+        for call in iter_fn_calls(ast) {
+            let function = call.fn_name.to_string();
+            if let Some((_, deprecated)) = self.unimplemented().get(&function)
+                && !deprecated
+            {
+                return false;
+            }
+        }
+        true
+    }
+}

rust/src/feed_filter/dep_filter.rs

@@ -0,0 +1,133 @@
+// SPDX-FileCopyrightText: 2026 Greenbone AG
+//
+// SPDX-License-Identifier: GPL-2.0-or-later WITH x11vnc-openssl-exception
+
+use std::collections::{HashMap, VecDeque};
+use std::path::{Path, PathBuf};
+
+use scannerlib::nasl::Code;
+use scannerlib::nasl::syntax::Loader;
+
+use crate::script::ScriptPath;
+use crate::utils::oid_from_ast;
+
+/// Dependencies of a script.
+pub struct ScriptDepsInfo {
+    /// include deps
+    pub includes: Vec<ScriptPath>,
+    /// script_dependencies deps
+    pub script_dependencies: Vec<ScriptPath>,
+    /// The OID of this script, if present.
+    pub oid: Option<String>,
+}
+
+impl ScriptDepsInfo {
+    pub fn all_deps(&self) -> impl Iterator<Item = &ScriptPath> {
+        self.includes.iter().chain(self.script_dependencies.iter())
+    }
+}
+
+/// Map from every script in the feed to its dependency info.
+pub type DepMap = HashMap<ScriptPath, ScriptDepsInfo>;
+
+/// Reads the feed and builds the full dependency map.
+pub struct DepReader {
+    feed_path: PathBuf,
+    loader: Loader,
+}
+
+impl DepReader {
+    pub fn new(feed_path: PathBuf) -> Self {
+        let loader = Loader::from_feed_path(&feed_path);
+        Self { feed_path, loader }
+    }
+
+    /// Read the given root scripts and all their dependencies recursively.
+    ///
+    /// Only the files that are actually reachable from `roots` are read from
+    /// disk; the rest of the feed is never touched.
+    pub fn read_from_roots(&mut self, roots: &[ScriptPath]) -> DepMap {
+        let mut map: DepMap = HashMap::default();
+        let mut queue: VecDeque<ScriptPath> = roots.iter().cloned().collect();
+
+        while let Some(path) = queue.pop_front() {
+            if map.contains_key(&path) {
+                continue;
+            }
+            let full_path = self.feed_path.join(&path.0);
+            match self.read_one(&full_path) {
+                Some(info) => {
+                    for dep in info.all_deps() {
+                        if !map.contains_key(dep) {
+                            queue.push_back(dep.clone());
+                        }
+                    }
+                    map.insert(path, info);
+                }
+                None => {
+                    eprintln!("Warning: could not read {}", path.0);
+                }
+            }
+        }
+
+        map
+    }
+
+    fn read_one(&mut self, path: &Path) -> Option<ScriptDepsInfo> {
+        let code = Code::load(&self.loader, path).ok()?;
+        let ast = code.parse().emit_errors().ok()?;
+        Some(extract_deps(&ast, &self.feed_path))
+    }
+}
+
+fn extract_deps(ast: &scannerlib::nasl::syntax::grammar::Ast, feed_path: &Path) -> ScriptDepsInfo {
+    let sp = search_path::SearchPath::from(feed_path.to_path_buf());
+
+    let includes = ast
+        .iter_includes()
+        .filter_map(|inc| {
+            sp.find_file(&PathBuf::from(&inc.path))
+                .map(|p| ScriptPath::new(feed_path, &p))
+        })
+        .collect();
+
+    let script_dependencies = ast
+        .iter_fn_calls()
+        .filter(|call| call.fn_name.to_string() == "script_dependencies")
+        .flat_map(|call| {
+            call.args.items.iter().filter_map(|arg| {
+                let s = arg.to_string();
+                // Args are double-quoted string literals: `"filename.nasl"`
+                let name = if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 {
+                    s[1..s.len() - 1].to_string()
+                } else {
+                    return None;
+                };
+                sp.find_file(&PathBuf::from(&name))
+                    .map(|p| ScriptPath::new(feed_path, &p))
+            })
+        })
+        .collect();
+
+    let oid = oid_from_ast(ast);
+
+    ScriptDepsInfo {
+        includes,
+        script_dependencies,
+        oid,
+    }
+}
+
+pub fn resolve_script(feed_path: &Path, script: &Path) -> Option<ScriptPath> {
+    if script.is_absolute() {
+        pathdiff::diff_paths(script, feed_path)
+            .map(|rel| ScriptPath(rel.to_string_lossy().into_owned()))
+    } else {
+        let full = feed_path.join(script);
+        if full.exists() {
+            Some(ScriptPath(script.to_string_lossy().into_owned()))
+        } else {
+            None
+        }
+    }
+}

rust/src/feed_filter/error.rs

@@ -7,12 +7,14 @@ use std::fmt;
 #[derive(Debug)]
 pub(crate) enum CliError {
     Io(std::io::Error),
+    Message(String),
 }
 
 impl fmt::Display for CliError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             CliError::Io(error) => write!(f, "{error}"),
+            CliError::Message(msg) => write!(f, "{msg}"),
         }
     }
 }
@@ -23,4 +25,10 @@ impl From<std::io::Error> for CliError {
     }
 }
 
+impl From<&str> for CliError {
+    fn from(value: &str) -> Self {
+        Self::Message(value.to_string())
+    }
+}
+
 impl std::error::Error for CliError {}