wip

Author: jasonish

rust/Cargo.toml.in

@@ -7,7 +7,7 @@ edition = "2021"
 rust-version = "1.67.1"
 
 [workspace]
-members = [".", "./derive"]
+members = [".", "./derive", "./config"]
 
 [lib]
 crate-type = ["staticlib", "rlib"]
@@ -68,6 +68,7 @@ hex = "~0.4.3"
 time = "~0.3.36"
 
 suricata-derive = { path = "./derive", version = "@PACKAGE_VERSION@" }
+suricata-config = { path = "./config", version = "0.1.0" }
 
 suricata-lua-sys = { version = "0.1.0-alpha.3" }
 

rust/Makefile.am

@@ -2,6 +2,7 @@ EXTRA_DIST =	src derive \
 		.cargo/config.toml.in \
 		cbindgen.toml \
 		dist/rust-bindings.h \
+		dist/rust-config.h \
 		vendor \
 		Cargo.toml Cargo.lock \
 		derive/Cargo.toml
@@ -60,6 +61,7 @@ endif
 			$(RUST_SURICATA_LIBDIR)/${RUST_SURICATA_LIBNAME}; \
 	fi
 	$(MAKE) gen/rust-bindings.h
+	rm -f gen/rust-config.h && $(MAKE) gen/rust-config.h
 
 install-library:
 	$(MKDIR_P) "$(DESTDIR)$(libdir)"
@@ -88,6 +90,9 @@ gen/rust-bindings.h: $(RUST_SURICATA_LIB)
 	cd $(abs_top_srcdir)/rust && \
 		cbindgen --config $(abs_top_srcdir)/rust/cbindgen.toml \
 		--quiet --verify --output $(abs_top_builddir)/rust/gen/rust-bindings.h || true
+gen/rust-config.h: $(RUST_SURICATA_LIB)
+	cbindgen --config $(abs_top_srcdir)/rust/config/cbindgen.toml \
+		--quiet --verify --output $(abs_top_builddir)/rust/$@ config || true
 else
 gen/rust-bindings.h:
 endif

rust/config/.gitignore

@@ -0,0 +1 @@
+!/Cargo.toml

rust/config/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "suricata-config"
+version = "0.1.0"
+edition = "2021"
+
+# Saphyr requires 1.70.0
+rust-version = "1.70.0"
+
+[dependencies]
+# Need to keep hashlink's version in check with saphyr.
+hashlink = "0.8.4"
+lazy_static = "1.4.0"
+
+saphyr = { git = "https://github.com/saphyr-rs/saphyr" }
+saphyr-parser = { git = "https://github.com/saphyr-rs/saphyr" }

rust/config/cbindgen.toml

@@ -0,0 +1,58 @@
+language = "C"
+
+
+header = """/* Copyright (C) 2024 Open Information Security Foundation
+*
+* You can copy, redistribute or modify this Program under the terms of
+* the GNU General Public License version 2 as published by the Free
+* Software Foundation.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* version 2 along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+* 02110-1301, USA.
+*/"""
+
+include_guard = "SURICATA_RUST_CONFIG_H"
+
+autogen_warning = "/* DO NOT EDIT This file is autogenerated by cbindgen. Don't modify this manually. */"
+
+include_version = true
+
+includes = []
+
+# Cbindgen doesn't appear to create structs for types from other
+# crates, so add an opaque definition of the YAML type here.
+after_includes = """typedef struct Yaml Yaml;"""
+
+line_length = 80
+
+tab_width = 4
+
+documentation_style = "doxy"
+
+[export]
+include = []
+
+exclude = []
+
+item_types = ["enums","structs","opaque","functions","constants"]
+
+[export.rename]
+
+renaming_overrides_prefixing = "true"
+
+[enum]
+rename_variants = "ScreamingSnakeCase"
+prefix_with_name = true
+
+[parse]
+exclude = ["libc"]
+
+[parse.expand]
+features = ["cbindgen"]

rust/config/src/bin/loader.rs

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright (C) 2024 Open Information Security Foundation
+// SPDX-License-Identifier: MIT
+
+use saphyr::Yaml;
+
+fn main() {
+    let filename = std::env::args().nth(1).expect("No filename given");
+    let config = suricata_config::load_from_file(filename).unwrap();
+    dump_yaml(&config, ".");
+}
+
+fn dump_yaml(value: &Yaml, sep: &str) {
+    let mut stack: Vec<(Vec<String>, &Yaml)> = vec![(vec![], value)];
+    while let Some((prefix, node)) = stack.pop() {
+        match node {
+            Yaml::Real(value) => {
+                println!("{} = {}", prefix.join(sep), value);
+            }
+            Yaml::Integer(value) => {
+                println!("{} = {}", prefix.join(sep), value);
+            }
+            Yaml::String(value) => {
+                println!("{} = {}", prefix.join(sep), value);
+            }
+            Yaml::Boolean(value) => {
+                println!("{} = {}", prefix.join(sep), value);
+            }
+            Yaml::Array(array) => {
+                let mut tmp = vec![];
+                for (i, v) in array.iter().enumerate() {
+                    let mut prefix = prefix.clone();
+                    prefix.push(format!("{}", i));
+                    tmp.push((prefix, v));
+                }
+                tmp.reverse();
+                stack.extend(tmp);
+            }
+            Yaml::Hash(hash) => {
+                for (key, v) in hash.iter().rev() {
+                    let mut prefix = prefix.clone();
+                    prefix.push(key.as_str().unwrap().to_string());
+                    stack.push((prefix, v));
+                }
+            }
+            Yaml::Null => {
+                println!("{} = ~", prefix.join(sep));
+            }
+            Yaml::Alias(_) => todo!(),
+            Yaml::BadValue => todo!(),
+        }
+    }
+}

rust/config/src/ffi.rs

@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: Copyright (C) 2024 Open Information Security Foundation
+// SPDX-License-Identifier: MIT
+
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    ffi::{CStr, CString},
+    os::raw::c_char,
+    sync::{Mutex, RwLock},
+};
+
+use lazy_static::lazy_static;
+use saphyr::{Hash, Yaml};
+
+thread_local! {
+    static LAST_ERR: RefCell<Option<CString>> = const { RefCell::new(None) };
+}
+
+lazy_static! {
+    #[no_mangle]
+    static ref GLOBAL: RwLock<Yaml> = RwLock::new(Yaml::Hash(Hash::new()));
+    static ref CSTRINGS: Mutex<HashMap<String, CString>> = Mutex::new(HashMap::new());
+}
+
+//pub struct SuriConfigYamlHashIter(linked_hash_map::Iter<'static, Yaml, Yaml>);
+
+// Converts a Rust &str to CString, store it in CSTRINGS and return a *mut c_char.
+fn get_cstring(s: &str) -> Result<*const c_char, Box<dyn std::error::Error>> {
+    let cstring = CString::new(s)?;
+    let mut cstrings = CSTRINGS.lock().unwrap();
+    cstrings.insert(s.to_string(), cstring);
+    let s = cstrings.get(s).unwrap();
+    Ok(s.as_ptr())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn SuriConfigSetGlobal(yaml: *mut Yaml) {
+    let yaml = Box::from_raw(yaml);
+    let mut global = GLOBAL.write().unwrap();
+    *global = *yaml;
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn SuriConfigLoadFromFile(filename: *const c_char) -> *mut Yaml {
+    unsafe fn load_from_file(filename: *const c_char) -> Result<Yaml, Box<dyn std::error::Error>> {
+        let filename = CStr::from_ptr(filename).to_str()?;
+        crate::load_from_file(filename)
+    }
+
+    match load_from_file(filename) {
+        Ok(yaml) => Box::into_raw(Box::new(yaml)),
+        Err(err) => {
+            let err = CString::new(format!("{:?}", err)).unwrap();
+            LAST_ERR.with(|last_err|{
+                *last_err.borrow_mut() = Some(err);
+            });
+            std::ptr::null_mut()
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn SuriConfigLastErr() -> *const c_char {
+    LAST_ERR.with(|last_err| {
+        let last_err = last_err.borrow_mut();
+        if let Some(err) = last_err.as_ref() {
+            err.as_ptr()
+        } else {
+            std::ptr::null()
+        }
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn SuriConfigFree(yaml: *mut Yaml) {
+    std::mem::drop(Box::from_raw(yaml));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn SuriConfGet(name: *const c_char, vptr: *mut *const c_char) -> bool {
+    pub unsafe fn conf_get(
+        name: *const c_char, vptr: *mut *const c_char,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let name = CStr::from_ptr(name).to_str()?;
+        let global = GLOBAL.read().unwrap();
+        if let Some(node) = crate::get(&global, name) {
+            if let Some(display) = crate::display(node) {
+                *vptr = get_cstring(&display)?;
+            }
+        }
+        Ok(())
+    }
+
+    conf_get(name, vptr).is_ok()
+}

rust/config/src/file.rs

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright (C) 2024 Open Information Security Foundation
+// SPDX-License-Identifier: MIT
+
+use std::io::Read;
+
+/// A character iterator of a file to satisfy the YAML parser that only takes a char
+/// iterator. We could read the whole file into a string, but that could cause issues with
+/// very large files that may be passed by accident.
+pub struct FileCharIterator {
+    file: std::fs::File,
+}
+
+impl FileCharIterator {
+    pub fn new(file: std::fs::File) -> Self {
+        Self { file }
+    }
+
+    fn next_char(&mut self) -> Option<char> {
+        let mut buf: Vec<u8> = Vec::new();
+        loop {
+            let mut byte = [0; 1];
+            match self.file.read(&mut byte) {
+                Ok(n) => {
+                    if n == 0 {
+                        return None;
+                    }
+                }
+                Err(_) => {
+                    return None;
+                }
+            }
+            buf.push(byte[0]);
+            match String::from_utf8(buf) {
+                Ok(s) => {
+                    assert_eq!(s.len(), 1);
+                    return s.chars().next();
+                }
+                Err(err) => {
+                    buf = err.as_bytes().to_vec();
+                    continue;
+                }
+            }
+        }
+    }
+}
+
+impl Iterator for FileCharIterator {
+    type Item = char;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next_char()
+    }
+}