Add an option to dynamically initialize the server handler

Author: saulvaldelvira

Cargo.toml

@@ -5,7 +5,7 @@ members = [
     "crates/mime",
     "crates/http",
     "crates/client",
-    "crates/server"
+    "crates/server",
 ]
 default-members = ["crates/server"]
 

crates/http/src/request/mod.rs

@@ -4,7 +4,7 @@ use std::{
     collections::HashMap,
     env,
     ffi::OsStr,
-    io::{BufRead, BufReader, Read, Write},
+    io::{BufRead, BufReader, BufWriter, Read, Write},
     path::Path,
 };
 
@@ -316,6 +316,20 @@ impl HttpRequest {
     pub fn respond_str(&mut self, text: &str) -> Result<()> {
         self.respond_buf(text.as_bytes())
     }
+    /// Responds using the given function.
+    ///
+    /// It sends the header for this request, and then calls
+    /// the provided function with a [writer](Write).
+    pub fn respond_with<F>(&mut self, f: F) -> Result<()>
+    where
+        F: FnOnce(&mut dyn Write) -> Result<()>,
+    {
+        self.respond()?;
+        let mut out = BufWriter::new(self.stream.get_mut());
+        f(&mut out)?;
+        out.flush()?;
+        Ok(())
+    }
     /// Respond to the request with the data read from reader as a body
     ///
     /// # Errors

crates/server/Cargo.toml

@@ -16,6 +16,7 @@ pool = { package = "job-pool", version = ">=0.6.0", git = "https://github.com/sa
 jsonrs = { package = "jsonrs", version = ">=0.1.4", git = "https://github.com/saulvaldelvira/json.rs" }
 base64 = { package = "rb64", version = ">=0.1.0", git = "https://github.com/saulvaldelvira/rb64" }
 url = { package = "url-utils", version = ">=0.1.0", path = "../url" }
+libloading = "0.8.8"
 
 [dependencies.rustls]
 version = ">=0.23.28"

crates/server/src/config.rs

@@ -26,6 +26,7 @@ pub struct ServerConfig {
     pub keep_alive_timeout: Duration,
     pub keep_alive_requests: u16,
     pub log_file: Option<String>,
+    pub setup_lib: Option<String>,
 
     #[cfg(feature = "tls")]
     pub tls_config: Option<Arc<rustls::ServerConfig>>,
@@ -38,6 +39,7 @@ impl fmt::Debug for ServerConfig {
             .field("pool_conf", &self.pool_conf)
             .field("keep_alive_timeout", &self.keep_alive_timeout)
             .field("keep_alive_requests", &self.keep_alive_requests)
+            .field("setup_lib", &self.setup_lib)
             .field("log_file", &self.log_file);
 
         #[cfg(feature = "tls")]
@@ -187,6 +189,9 @@ impl ServerConfig {
                     let n: u8 = parse_next!();
                     log::set_level(n.try_into()?);
                 }
+
+                "--setup-lib" => conf.setup_lib = Some(parse_next!()),
+
                 #[cfg(feature = "tls")]
                 "--tls" => tls = true,
 
@@ -378,7 +383,7 @@ impl ServerConfig {
 
 fn help() -> ! {
     /* FIXME: Don't output tls options if the tls feature is disabled */
-    println!(concat!(
+    println!(
         "\
 http-srv: Copyright (C) 2025 Saúl Valdelvira
 
@@ -397,6 +402,7 @@ PARAMETERS:
     -l, --log <file>   Set log file
     -h, --help      Display this help message
     --log-level <n> Set log level
+    --setup-lib <file> Load the given file to setup the server
     --conf <file>   Use the given config file instead of the default one
     --license       Output the license of this program
 
@@ -407,7 +413,7 @@ EXAMPLES:
   http-srv -p 8080 -d /var/html
   http-srv -d ~/desktop -n 1024 --keep-alive 120
   http-srv --log /var/log/http-srv.log"
-    ));
+    );
     process::exit(0);
 }
 
@@ -444,7 +450,7 @@ impl Default for ServerConfig {
             keep_alive_timeout: Duration::from_secs(0),
             keep_alive_requests: 10000,
             log_file: None,
-
+            setup_lib: None,
             #[cfg(feature = "tls")]
             tls_config: None,
         }

crates/server/src/handler/indexing.rs

@@ -73,14 +73,14 @@ pub fn index_of(filename: &str, show_hidden: bool) -> Result<String> {
     files.sort_by_key(DirEntry::path);
 
     html.push_str("<table><tr><th>Name</th><th>Size</th></tr>");
-    if let Some(parent) = Path::new(filename).parent() {
-        if parent.starts_with(cwd) {
-            let url = parent.strip_prefix(cwd)?;
-            let url = encode_path(url, show_hidden)?;
-            html.write_fmt(format_args!(
-                "<tr><td>&larr;</td><td><a href=\"{url}\">..</a></td></tr>"
-            ))?;
-        }
+    if let Some(parent) = Path::new(filename).parent()
+        && parent.starts_with(cwd)
+    {
+        let url = parent.strip_prefix(cwd)?;
+        let url = encode_path(url, show_hidden)?;
+        html.write_fmt(format_args!(
+            "<tr><td>&larr;</td><td><a href=\"{url}\">..</a></td></tr>"
+        ))?;
     }
     for file in files {
         let path = file.path();

crates/server/src/main.rs

@@ -2,15 +2,32 @@ use std::{env, process, thread, time::Duration};
 
 use encoding::StreamReader;
 use http_srv::prelude::*;
+use libloading::{Library, Symbol};
 
-pub fn main() {
-    let args: Vec<_> = env::args().skip(1).collect();
-    let config = ServerConfig::parse(&args).unwrap_or_else(|err| {
-        eprintln!("{err}");
-        process::exit(1);
-    });
+type Result<T> = ::core::result::Result<T, libloading::Error>;
+
+fn load_lib(handler: &mut Handler, name: &str) -> Result<Library> {
+    unsafe {
+        let lib = libloading::Library::new(name)?;
+
+        let init_handler: Symbol<fn(*mut Handler)> = lib.get(b"init_handler")?;
 
+        init_handler(handler);
+
+        Ok(lib)
+    }
+}
+
+fn get_handler(config: &ServerConfig) -> Result<(Option<Library>, Handler)> {
     let mut handler = Handler::default();
+    let mut _lib = None;
+
+    if let Some(path) = &config.setup_lib {
+        let mut handler = Handler::new();
+        _lib = Some(load_lib(&mut handler, path)?);
+        return Ok((_lib, handler));
+    }
+
     handler.get("/sleep", |req: &mut HttpRequest| {
         thread::sleep(Duration::from_secs(5));
         req.ok()
@@ -83,10 +100,26 @@ pub fn main() {
         auth.apply(|req: &mut HttpRequest| req.respond_str("Secret message")),
     );
 
+    Ok((_lib, handler))
+}
+
+pub fn main() {
+    let args: Vec<_> = env::args().skip(1).collect();
+    let config = ServerConfig::parse(&args).unwrap_or_else(|err| {
+        eprintln!("{err}");
+        process::exit(1);
+    });
+
+    let (_lib, handler) = get_handler(&config).unwrap_or_else(|err| {
+        eprintln!("ERROR: {err}");
+        process::exit(1);
+    });
+
     let mut server = HttpServer::new(config).unwrap_or_else(|err| {
         eprintln!("ERROR: {err}");
         std::process::exit(1)
     });
+
     server.set_handler(handler);
     server.run();
 }

crates/url/src/ffi.rs

@@ -16,26 +16,26 @@ pub struct Buffer {
 #[inline(always)]
 unsafe fn __bind_fn(ptr: *const c_char, f: fn(&str) -> crate::Result<Cow<str>>) -> Buffer {
     let cstr = unsafe { CStr::from_ptr(ptr) };
-    if let Ok(s) = cstr.to_str() {
-        if let Ok(d) = f(s) {
-            match d {
-                Cow::Owned(mut own) => {
-                    own.push('\0');
-                    let own = own.into_boxed_str();
-                    let len = own.len();
-                    return Buffer {
-                        ptr: Box::into_raw(own) as *const u8,
-                        len,
-                        __is_owned: true,
-                    };
-                }
-                Cow::Borrowed(bor) => {
-                    return Buffer {
-                        ptr: bor.as_ptr(),
-                        len: bor.len(),
-                        __is_owned: false,
-                    };
-                }
+    if let Ok(s) = cstr.to_str()
+        && let Ok(d) = f(s)
+    {
+        match d {
+            Cow::Owned(mut own) => {
+                own.push('\0');
+                let own = own.into_boxed_str();
+                let len = own.len();
+                return Buffer {
+                    ptr: Box::into_raw(own) as *const u8,
+                    len,
+                    __is_owned: true,
+                };
+            }
+            Cow::Borrowed(bor) => {
+                return Buffer {
+                    ptr: bor.as_ptr(),
+                    len: bor.len(),
+                    __is_owned: false,
+                };
             }
         }
     }

example-plugin/.gitignore

@@ -0,0 +1,2 @@
+Cargo.lock
+target

example-plugin/Cargo.toml

@@ -0,0 +1,13 @@
+[workspace]
+
+[package]
+name = "example-plugin"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+name = "init_handler"
+crate-type = [ "cdylib" ]
+
+[dependencies]
+server = { package = "http-srv", path = "../crates/server" }

example-plugin/src/lib.rs

@@ -0,0 +1,42 @@
+extern crate server;
+
+use http::HttpRequest;
+use server::{handler::Handler, http};
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn init_handler(handler: Option<&mut Handler>) {
+    let handler = handler.unwrap();
+
+    handler.get("/count", |req: &mut HttpRequest| {
+        macro_rules! get_numeric_arg {
+            ($n:literal) => {
+                match req.param($n) {
+                    Some(num) => match num.parse::<u32>() {
+                        Ok(num) => num,
+                        Err(err) => {
+                            return req
+                                .set_status(400)
+                                .respond_str(&format!("Error parsing '{}': {err}", $n));
+                        }
+                    },
+                    None => {
+                        return req
+                            .set_status(400)
+                            .respond_str(concat!("Missing numeric argument ", $n));
+                    }
+                }
+            };
+        }
+        let start = get_numeric_arg!("start");
+        let end = get_numeric_arg!("end");
+
+        req.respond_with(|out| {
+            for i in start..=end {
+                write!(out, "{i}, ")?;
+            }
+            Ok(())
+        })
+    });
+
+    println!("example-plugin: Done");
+}