Add embedded webserver for config management

Author: manio

src/config.rs

@@ -1,11 +1,16 @@
 use bluer::Address;
 use serde::de::{self, Deserializer, Error as DeError, Visitor};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
+use simplelog::*;
 use std::fmt::{self, Display};
+use std::fs;
 use std::path::PathBuf;
 use std::str::FromStr;
+use toml_edit::{value, DocumentMut};
 
-#[derive(clap::ValueEnum, Default, Debug, PartialEq, PartialOrd, Clone, Copy, Deserialize)]
+#[derive(
+    clap::ValueEnum, Default, Debug, PartialEq, PartialOrd, Clone, Copy, Deserialize, Serialize,
+)]
 pub enum HexdumpLevel {
     #[default]
     Disabled,
@@ -16,7 +21,7 @@ pub enum HexdumpLevel {
     All,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct UsbId {
     pub vid: u16,
     pub pid: u16,
@@ -36,6 +41,12 @@ impl std::str::FromStr for UsbId {
     }
 }
 
+impl fmt::Display for UsbId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:x}:{:x}", self.vid, self.pid)
+    }
+}
+
 impl<'de> Deserialize<'de> for UsbId {
     fn deserialize<D>(deserializer: D) -> Result<UsbId, D::Error>
     where
@@ -76,7 +87,7 @@ where
     }
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(default)]
 pub struct AppConfig {
     pub advertise: bool,
@@ -149,12 +160,68 @@ impl Default for AppConfig {
     }
 }
 
-pub fn load_config(config_file: PathBuf) -> Result<AppConfig, Box<dyn std::error::Error>> {
-    let file_config: AppConfig = config::Config::builder()
-        .add_source(config::File::from(config_file).required(false))
-        .build()?
-        .try_deserialize()
-        .unwrap_or_default();
+impl AppConfig {
+    pub fn load(config_file: PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
+        use ::config::File;
+        let file_config: AppConfig = ::config::Config::builder()
+            .add_source(File::from(config_file).required(false))
+            .build()?
+            .try_deserialize()
+            .unwrap_or_default();
+
+        Ok(file_config)
+    }
+
+    pub fn save(&self, config_file: PathBuf) {
+        debug!("Saving config: {:?}", self);
+        let raw = fs::read_to_string(&config_file).unwrap_or_default();
+        let mut doc = raw.parse::<DocumentMut>().unwrap_or_else(|_| {
+            // if the file doesn't exists or there is parse error, create a new one
+            DocumentMut::new()
+        });
 
-    Ok(file_config)
+        doc["advertise"] = value(self.advertise);
+        doc["debug"] = value(self.debug);
+        doc["hexdump_level"] = value(format!("{:?}", self.hexdump_level));
+        doc["disable_console_debug"] = value(self.disable_console_debug);
+        doc["legacy"] = value(self.legacy);
+        doc["connect"] = match &self.connect {
+            Some(c) => value(c.to_string()),
+            None => value(""),
+        };
+        doc["logfile"] = value(self.logfile.display().to_string());
+        doc["stats_interval"] = value(self.stats_interval as i64);
+        if let Some(udc) = &self.udc {
+            doc["udc"] = value(udc);
+        }
+        doc["iface"] = value(&self.iface);
+        doc["hostapd_conf"] = value(self.hostapd_conf.display().to_string());
+        if let Some(alias) = &self.btalias {
+            doc["btalias"] = value(alias);
+        }
+        doc["keepalive"] = value(self.keepalive);
+        doc["timeout_secs"] = value(self.timeout_secs as i64);
+        doc["bt_timeout_secs"] = value(self.bt_timeout_secs as i64);
+        doc["mitm"] = value(self.mitm);
+        doc["dpi"] = value(self.dpi as i64);
+        doc["remove_tap_restriction"] = value(self.remove_tap_restriction);
+        doc["video_in_motion"] = value(self.video_in_motion);
+        doc["disable_media_sink"] = value(self.disable_media_sink);
+        doc["disable_tts_sink"] = value(self.disable_tts_sink);
+        doc["developer_mode"] = value(self.developer_mode);
+        doc["wired"] = value(
+            self.wired
+                .as_ref()
+                .map_or("".to_string(), |w| w.to_string()),
+        );
+        doc["dhu"] = value(self.dhu);
+        doc["ev"] = value(self.ev);
+        if let Some(path) = &self.ev_battery_logger {
+            doc["ev_battery_logger"] = value(path.display().to_string());
+        }
+        doc["ev_battery_capacity"] = value(self.ev_battery_capacity as i64);
+        doc["ev_factor"] = value(self.ev_factor as f64);
+
+        let _ = fs::write(config_file, doc.to_string());
+    }
 }

src/main.rs

@@ -6,6 +6,7 @@ mod io_uring;
 mod mitm;
 mod usb_gadget;
 mod usb_stream;
+mod web;
 
 use crate::config::AppConfig;
 use bluetooth::bluetooth_setup_connection;
@@ -26,6 +27,9 @@ use tokio::runtime::Builder;
 use tokio::sync::Notify;
 use tokio::time::Instant;
 
+use std::net::SocketAddr;
+use std::sync::Mutex;
+
 // module name for logging engine
 const NAME: &str = "<i><bright-black> main: </>";
 
@@ -152,10 +156,29 @@ fn logging_init(debug: bool, disable_console_debug: bool, log_path: &PathBuf) {
     }
 }
 
-async fn tokio_main(config: AppConfig, need_restart: Arc<Notify>, tcp_start: Arc<Notify>) {
+async fn tokio_main(
+    config: AppConfig,
+    need_restart: Arc<Notify>,
+    tcp_start: Arc<Notify>,
+    config_file: PathBuf,
+) {
     let accessory_started = Arc::new(Notify::new());
     let accessory_started_cloned = accessory_started.clone();
 
+    // preparing AppState and starting webserver
+    let state = web::AppState {
+        config: Arc::new(Mutex::new(config.clone())),
+        config_file: config_file.into(),
+    };
+    let app = web::app(state.into());
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], 80));
+    info!("Server running at http://{addr}/");
+    hyper::Server::bind(&addr)
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
+
     let wifi_conf = {
         if !config.wired.is_some() {
             Some(init_wifi_config(&config.iface, config.hostapd_conf))
@@ -235,7 +258,7 @@ fn main() {
     let args = Args::parse();
 
     // parse config
-    let config = config::load_config(args.config.clone()).unwrap();
+    let config = AppConfig::load(args.config.clone()).unwrap();
 
     logging_init(config.debug, config.disable_console_debug, &config.logfile);
     info!(
@@ -312,7 +335,9 @@ fn main() {
 
     // build and spawn main tokio runtime
     let runtime = Builder::new_multi_thread().enable_all().build().unwrap();
-    runtime.spawn(async move { tokio_main(config, need_restart, tcp_start).await });
+    runtime.spawn(
+        async move { tokio_main(config, need_restart, tcp_start, args.config.clone()).await },
+    );
 
     // start tokio_uring runtime simultaneously
     let _ = tokio_uring::start(io_loop(

src/web.rs

@@ -0,0 +1,43 @@
+use crate::config::AppConfig;
+use axum::{
+    extract::State,
+    response::{Html, IntoResponse},
+    routing::get,
+    Json, Router,
+};
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone)]
+pub struct AppState {
+    pub config: Arc<Mutex<AppConfig>>,
+    pub config_file: Arc<PathBuf>,
+}
+
+pub fn app(state: Arc<AppState>) -> Router {
+    Router::new()
+        .route("/", get(index))
+        .route("/config", get(get_config).post(set_config))
+        .with_state(state)
+}
+
+async fn index() -> impl IntoResponse {
+    Html(include_str!("../static/index.html"))
+}
+
+async fn get_config(State(state): State<Arc<AppState>>) -> impl IntoResponse {
+    let cfg = state.config.lock().unwrap().clone();
+    Json(cfg)
+}
+
+async fn set_config(
+    State(state): State<Arc<AppState>>,
+    Json(new_cfg): Json<AppConfig>,
+) -> impl IntoResponse {
+    {
+        let mut cfg = state.config.lock().unwrap();
+        *cfg = new_cfg.clone();
+        cfg.save((&state.config_file).to_path_buf());
+    }
+    Json(new_cfg)
+}