use SharedConfig instead of single variables where applicable

Author: manio

src/io_uring.rs

@@ -3,7 +3,6 @@ use humantime::format_duration;
 use simplelog::*;
 use std::cell::RefCell;
 use std::marker::PhantomData;
-use std::path::PathBuf;
 use std::process::Command;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -33,8 +32,7 @@ const USB_ACCESSORY_PATH: &str = "/dev/usb_accessory";
 pub const BUFFER_LEN: usize = 16 * 1024;
 const TCP_CLIENT_TIMEOUT: Duration = Duration::new(30, 0);
 
-use crate::config::HexdumpLevel;
-use crate::config::UsbId;
+use crate::config::SharedConfig;
 use crate::ev::{rest_server, RestContext};
 use crate::mitm::endpoint_reader;
 use crate::mitm::proxy;
@@ -197,31 +195,18 @@ pub async fn io_loop(
     need_restart: Arc<Notify>,
     tcp_start: Arc<Notify>,
     read_timeout: Duration,
-    mitm: bool,
-    dpi: u16,
-    developer_mode: bool,
-    disable_media_sink: bool,
-    disable_tts_sink: bool,
-    remove_tap_restriction: bool,
-    video_in_motion: bool,
-    hex_requested: HexdumpLevel,
-    wired: Option<UsbId>,
-    dhu: bool,
-    ev: bool,
-    ev_battery_logger: Option<PathBuf>,
-    ev_battery_capacity: u64,
-    ev_factor: f32,
+    config: SharedConfig,
 ) -> Result<()> {
     // prepare/bind needed TCP listeners
     let mut dhu_listener = None;
     let mut md_listener = None;
-    if !wired.is_some() {
+    if !config.read().await.wired.is_some() {
         info!("{} 🛰️ Starting TCP server for MD...", NAME);
         let bind_addr = format!("0.0.0.0:{}", TCP_SERVER_PORT).parse().unwrap();
         md_listener = Some(TcpListener::bind(bind_addr).unwrap());
         info!("{} 🛰️ MD TCP server bound to: <u>{}</u>", NAME, bind_addr);
     }
-    if dhu {
+    if config.read().await.dhu {
         info!("{} 🛰️ Starting TCP server for DHU...", NAME);
         let bind_addr = format!("0.0.0.0:{}", TCP_DHU_PORT).parse().unwrap();
         dhu_listener = Some(TcpListener::bind(bind_addr).unwrap());
@@ -233,12 +218,12 @@ pub async fn io_loop(
         let mut md_usb = None;
         let mut hu_tcp = None;
         let mut hu_usb = None;
-        if wired.is_some() {
+        if config.read().await.wired.is_some() {
             info!(
                 "{} 💤 trying to enable Android Auto mode on USB port...",
                 NAME
             );
-            match usb_stream::new(wired.clone()).await {
+            match usb_stream::new(config.read().await.wired.clone()).await {
                 Err(e) => {
                     error!("{} 🔴 Enabling Android Auto: {}", NAME, e);
                     // notify main loop to restart
@@ -266,7 +251,7 @@ pub async fn io_loop(
             }
         }
 
-        if dhu {
+        if config.read().await.dhu {
             info!(
                 "{} 🛰️ DHU TCP server: listening for `Desktop Head Unit` connection...",
                 NAME
@@ -355,11 +340,11 @@ pub async fn io_loop(
         // handling battery in JSON
         let mut rest_server_handle = None;
         let mut rest_ctx = None;
-        if mitm && ev {
+        if config.read().await.mitm && config.read().await.ev {
             let ctx = RestContext {
                 sensor_channel: None,
-                ev_battery_capacity,
-                ev_factor,
+                ev_battery_capacity: config.read().await.ev_battery_capacity,
+                ev_factor: config.read().await.ev_factor,
             };
             let ctx = Arc::new(Mutex::new(ctx));
 
@@ -379,17 +364,8 @@ pub async fn io_loop(
             tx_hu.clone(),
             rx_hu,
             rxr_md,
-            dpi,
-            developer_mode,
-            disable_media_sink,
-            disable_tts_sink,
-            remove_tap_restriction,
-            video_in_motion,
-            !mitm,
-            hex_requested,
-            ev,
+            config.clone(),
             rest_ctx.clone(),
-            ev_battery_logger.clone(),
         ));
         from_stream = tokio_uring::spawn(proxy(
             ProxyType::MobileDevice,
@@ -398,17 +374,8 @@ pub async fn io_loop(
             tx_md,
             rx_md,
             rxr_hu,
-            dpi,
-            developer_mode,
-            disable_media_sink,
-            disable_tts_sink,
-            remove_tap_restriction,
-            video_in_motion,
-            !mitm,
-            hex_requested,
-            ev,
+            config.clone(),
             rest_ctx.clone(),
-            ev_battery_logger.clone(),
         ));
 
         // Thread for monitoring transfer
@@ -446,7 +413,7 @@ pub async fn io_loop(
             handle.abort();
         }
         // stop EV battery logger if neded
-        if let Some(ref path) = ev_battery_logger {
+        if let Some(ref path) = config.read().await.ev_battery_logger {
             let _ = Command::new(path).arg("stop").spawn();
         }
 

src/main.rs

@@ -9,6 +9,7 @@ mod usb_stream;
 mod web;
 
 use crate::config::AppConfig;
+use crate::config::SharedConfig;
 use bluetooth::bluetooth_setup_connection;
 use bluetooth::bluetooth_stop;
 use clap::Parser;
@@ -157,18 +158,18 @@ fn logging_init(debug: bool, disable_console_debug: bool, log_path: &PathBuf) {
 }
 
 async fn tokio_main(
-    config: AppConfig,
+    config: SharedConfig,
     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();
 
-    if let Some(ref bindaddr) = config.webserver {
+    if let Some(ref bindaddr) = config.read().await.webserver {
         // preparing AppState and starting webserver
         let state = web::AppState {
-            config: Arc::new(RwLock::new(config.clone())),
+            config: config.clone(),
             config_file: config_file.into(),
         };
         let app = web::app(state.into());
@@ -193,19 +194,25 @@ async fn tokio_main(
     }
 
     let wifi_conf = {
-        if !config.wired.is_some() {
-            Some(init_wifi_config(&config.iface, config.hostapd_conf))
+        if !config.read().await.wired.is_some() {
+            Some(init_wifi_config(
+                &config.read().await.iface,
+                config.read().await.hostapd_conf.clone(),
+            ))
         } else {
             None
         }
     };
     let mut usb = None;
-    if !config.dhu {
-        if config.legacy {
+    if !config.read().await.dhu {
+        if config.read().await.legacy {
             // start uevent listener in own task
             std::thread::spawn(|| uevent_listener(accessory_started_cloned));
         }
-        usb = Some(UsbGadgetState::new(config.legacy, config.udc));
+        usb = Some(UsbGadgetState::new(
+            config.read().await.legacy,
+            config.read().await.udc.clone(),
+        ));
     }
     loop {
         if let Some(ref mut usb) = usb {
@@ -218,13 +225,13 @@ async fn tokio_main(
         if let Some(ref wifi_conf) = wifi_conf {
             loop {
                 match bluetooth_setup_connection(
-                    config.advertise,
-                    config.btalias.clone(),
-                    config.connect,
+                    config.read().await.advertise,
+                    config.read().await.btalias.clone(),
+                    config.read().await.connect,
                     wifi_conf.clone(),
                     tcp_start.clone(),
-                    config.keepalive,
-                    Duration::from_secs(config.bt_timeout_secs.into()),
+                    config.read().await.keepalive,
+                    Duration::from_secs(config.read().await.bt_timeout_secs.into()),
                 )
                 .await
                 {
@@ -331,47 +338,22 @@ fn main() {
     let need_restart_cloned = need_restart.clone();
     let tcp_start = Arc::new(Notify::new());
     let tcp_start_cloned = tcp_start.clone();
-    let mitm = config.mitm;
-    let dpi = config.dpi;
-    let developer_mode = config.developer_mode;
-    let disable_media_sink = config.disable_media_sink;
-    let disable_tts_sink = config.disable_tts_sink;
-    let remove_tap_restriction = config.remove_tap_restriction;
-    let video_in_motion = config.video_in_motion;
-    let hex_requested = config.hexdump_level;
-    let wired = config.wired.clone();
-    let dhu = config.dhu;
-    let ev = config.ev;
-    let ev_battery_logger = config.ev_battery_logger.clone();
-    let ev_battery_capacity = config.ev_battery_capacity.clone();
-    let ev_factor = config.ev_factor.clone();
+    let config = Arc::new(RwLock::new(config));
+    let config_cloned = config.clone();
 
     // 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, args.config.clone()).await },
-    );
+    runtime.spawn(async move {
+        tokio_main(config_cloned, need_restart, tcp_start, args.config.clone()).await
+    });
 
     // start tokio_uring runtime simultaneously
     let _ = tokio_uring::start(io_loop(
         stats_interval,
         need_restart_cloned,
         tcp_start_cloned,
         read_timeout,
-        mitm,
-        dpi,
-        developer_mode,
-        disable_media_sink,
-        disable_tts_sink,
-        remove_tap_restriction,
-        video_in_motion,
-        hex_requested,
-        wired,
-        dhu,
-        ev,
-        ev_battery_logger,
-        ev_battery_capacity,
-        ev_factor,
+        config,
     ));
 
     info!(

src/mitm.rs

@@ -28,6 +28,7 @@ use protobuf::{Enum, Message, MessageDyn};
 use protos::ControlMessageType::{self, *};
 
 use crate::config::HexdumpLevel;
+use crate::config::SharedConfig;
 use crate::ev::RestContext;
 use crate::io_uring::Endpoint;
 use crate::io_uring::IoDevice;
@@ -650,18 +651,21 @@ pub async fn proxy<A: Endpoint<A> + 'static>(
     tx: Sender<Packet>,
     mut rx: Receiver<Packet>,
     mut rxr: Receiver<Packet>,
-    dpi: u16,
-    developer_mode: bool,
-    disable_media_sink: bool,
-    disable_tts_sink: bool,
-    remove_tap_restriction: bool,
-    video_in_motion: bool,
-    passthrough: bool,
-    hex_requested: HexdumpLevel,
-    ev: bool,
+    config: SharedConfig,
     rest_ctx: Option<Arc<tokio::sync::Mutex<RestContext>>>,
-    ev_battery_logger: Option<PathBuf>,
 ) -> Result<()> {
+    // load needed config options to local variables
+    let passthrough = !config.read().await.mitm;
+    let hex_requested = config.read().await.hexdump_level;
+    let dpi = config.read().await.dpi;
+    let developer_mode = config.read().await.developer_mode;
+    let disable_media_sink = config.read().await.disable_media_sink;
+    let disable_tts_sink = config.read().await.disable_tts_sink;
+    let remove_tap_restriction = config.read().await.remove_tap_restriction;
+    let video_in_motion = config.read().await.video_in_motion;
+    let ev = config.read().await.ev;
+    let ev_battery_logger = &config.read().await.ev_battery_logger;
+
     // in full_frames/passthrough mode we only directly pass packets from one endpoint to the other
     if passthrough {
         loop {