Add: methology for simulating forking behaviour

rust/examples/get_kb_item.nasl

@@ -0,0 +1,6 @@
+set_kb_item(name: "test", value: 1);
+set_kb_item(name: "test", value: 2);
+set_kb_item(name: "test", value: 3);
+set_kb_item(name: "test", value: 4);
+set_kb_item(name: "test", value: 5);
+display(get_kb_item("test"));

rust/feed/src/update/mod.rs

@@ -9,8 +9,8 @@ pub use error::Error;
 use std::{fmt::Display, fs::File, io::Read, marker::PhantomData};
 
 use nasl_interpreter::{
-    logger::DefaultLogger, AsBufReader, Context, ContextType, Interpreter, Loader, NaslValue,
-    Register,
+    logger::DefaultLogger, AsBufReader, CodeInterpreter, Context, ContextType, Interpreter, Loader,
+    NaslValue, Register,
 };
 use storage::{item::NVTField, Dispatcher, NoOpRetriever};
 
@@ -46,23 +46,24 @@ pub fn feed_version<K: Default + AsRef<str> + 'static>(
 ) -> Result<String, ErrorKind> {
     let feed_info_key = "plugin_feed_info.inc";
     let code = loader.load(feed_info_key)?;
-    let mut register = Register::default();
+    let register = Register::default();
     let logger = DefaultLogger::default();
     let k: K = Default::default();
     let fr = NoOpRetriever::default();
     let target = String::default();
     // TODO add parameter to struct
     let functions = nasl_interpreter::nasl_std_functions();
     let context = Context::new(&k, &target, dispatcher, &fr, loader, &logger, &functions);
-    let mut interpreter = Interpreter::new(&mut register, &context);
+    let mut interpreter = Interpreter::new(register, &context);
     for stmt in nasl_syntax::parse(&code) {
         match stmt {
-            Ok(stmt) => interpreter.retry_resolve(&stmt, 3)?,
+            Ok(stmt) => interpreter.retry_resolve_next(&stmt, 3)?,
             Err(e) => return Err(e.into()),
         };
     }
 
-    let feed_version = register
+    let feed_version = interpreter
+        .register()
         .named("PLUGIN_SET")
         .map(|x| x.to_string())
         .unwrap_or_else(|| "0".to_owned());
@@ -142,7 +143,7 @@ where
     fn single(&self, key: &K) -> Result<i64, ErrorKind> {
         let code = self.loader.load(key.as_ref())?;
 
-        let mut register = Register::root_initial(&self.initial);
+        let register = Register::root_initial(&self.initial);
         let logger = DefaultLogger::default();
         let fr = NoOpRetriever::default();
         let target = String::default();
@@ -158,9 +159,9 @@ where
             &logger,
             &functions,
         );
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        for stmt in nasl_syntax::parse(&code) {
-            match interpreter.retry_resolve(&stmt?, self.max_retry) {
+        let interpreter = CodeInterpreter::new(&code, register, &context);
+        for stmt in interpreter {
+            match stmt {
                 Ok(NaslValue::Exit(i)) => {
                     self.dispatcher.on_exit()?;
                     return Ok(i);

rust/nasl-builtin-cryptographic/tests/aes_cbc.rs

@@ -18,12 +18,10 @@ mod tests {
         crypt = aes128_cbc_encrypt(key: key, data: data, iv: iv);
         aes128_cbc_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -50,12 +48,10 @@ mod tests {
         crypt = aes192_cbc_encrypt(key: key, data: data, iv: iv);
         aes192_cbc_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -82,12 +78,10 @@ mod tests {
         crypt = aes256_cbc_encrypt(key: key, data: data, iv: iv);
         aes256_cbc_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -115,12 +109,10 @@ mod tests {
         aes128_cbc_encrypt(key: key, data: data1, iv: iv);
         aes128_cbc_encrypt(key: key, data: data2, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();

rust/nasl-builtin-cryptographic/tests/aes_ccm.rs

@@ -18,12 +18,10 @@ mod tests {
         crypt = aes128_ccm_encrypt(key: key, data: data, iv: iv);
         aes128_ccm_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -51,12 +49,10 @@ mod tests {
         crypt = aes128_ccm_encrypt_auth(key: key, data: data, iv: iv, aad: aad);
         aes128_ccm_decrypt_auth(key: key, data: crypt, iv: iv, aad: aad);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -84,12 +80,10 @@ mod tests {
         crypt = aes192_ccm_encrypt(key: key, data: data, iv: iv);
         aes192_ccm_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -117,12 +111,10 @@ mod tests {
         crypt = aes192_ccm_encrypt_auth(key: key, data: data, iv: iv, aad: aad);
         aes192_ccm_decrypt_auth(key: key, data: crypt, iv: iv, aad: aad);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -150,12 +142,10 @@ mod tests {
         crypt = aes256_ccm_encrypt(key: key, data: data, iv: iv);
         aes256_ccm_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -183,12 +173,10 @@ mod tests {
         crypt = aes256_ccm_encrypt_auth(key: key, data: data, iv: iv, aad: aad);
         aes256_ccm_decrypt_auth(key: key, data: crypt, iv: iv, aad: aad);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();

rust/nasl-builtin-cryptographic/tests/aes_cmac.rs

@@ -15,12 +15,10 @@ mod tests {
         data = hexstr_to_data("d2e8a3e86ae0b9edc7cc3116d929a16f13ee3643");
         crypt = aes_mac_cbc(key: key, data: data);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         assert_eq!(

rust/nasl-builtin-cryptographic/tests/aes_ctr.rs

@@ -19,12 +19,10 @@ mod tests {
         crypt = aes128_ctr_encrypt(key: key, data: data, iv: iv);
         aes128_ctr_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -51,12 +49,10 @@ mod tests {
         crypt = aes192_ctr_encrypt(key: key, data: data, iv: iv);
         aes192_ctr_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();
@@ -83,12 +79,10 @@ mod tests {
         crypt = aes256_ctr_encrypt(key: key, data: data, iv: iv);
         aes256_ctr_decrypt(key: key, data: crypt, iv: iv);
         "#;
-        let mut register = Register::default();
+        let register = Register::default();
         let binding = ContextBuilder::default();
         let context = binding.build();
-        let mut interpreter = Interpreter::new(&mut register, &context);
-        let mut parser =
-            parse(code).map(|x| interpreter.resolve(&x.expect("no parse error expected")));
+        let mut parser = CodeInterpreter::new(code, register, &context);
         parser.next();
         parser.next();
         parser.next();