X-Git-Url: https://git.r.bdr.sh/rbdr/olden-mail/blobdiff_plain/573aaf2a8ccdb6c8c917b2d88a39c9c8103f64ef..6aebf7f92c7a0bdce8e7c8e8049739d70065ec3b:/src/proxy.rs?ds=inline

diff --git a/src/proxy.rs b/src/proxy.rs
index 2798df3..176d5f9 100644
--- a/src/proxy.rs
+++ b/src/proxy.rs
@@ -42,7 +42,7 @@ use std::thread::{sleep, spawn, JoinHandle};
 use std::time::Duration;
 
 use crate::configuration::Proxy;
-use crate::middleware::MIDDLEWARE;
+use crate::middleware::get as get_middleware;
 
 /// A proxy server that listens for plaintext connections and forwards them
 /// via TLS.
@@ -117,8 +117,8 @@ fn run_proxy(configuration: &Arc<Proxy>, running: &Arc<AtomicBool>) {
 
     while running.load(Ordering::SeqCst) {
         match listener.accept() {
-            Ok((stream, addr)) => {
-                info!("New {} connection from {}", configuration.protocol, addr);
+            Ok((stream, address)) => {
+                info!("New {} connection from {}", configuration.protocol, address);
 
                 let configuration_clone = Arc::clone(configuration);
                 let handle = spawn(move || {
@@ -159,6 +159,9 @@ fn handle_client(client_stream: TcpStream, configuration: &Arc<Proxy>) {
         return;
     }
 
+    let available_middleware = get_middleware();
+    let available_middleware_clone = Arc::clone(&available_middleware);
+
     let connector = match TlsConnector::new() {
         Ok(c) => c,
         Err(e) => {
@@ -167,14 +170,14 @@ fn handle_client(client_stream: TcpStream, configuration: &Arc<Proxy>) {
         }
     };
 
-    let remote_addr = format!(
+    let remote_address = format!(
         "{}:{}",
         configuration.remote_host, configuration.remote_port
     );
-    let tcp_stream = match TcpStream::connect(&remote_addr) {
+    let tcp_stream = match TcpStream::connect(&remote_address) {
         Ok(stream) => stream,
         Err(e) => {
-            error!("Failed to connect to {}: {}", remote_addr, e);
+            error!("Failed to connect to {}: {}", remote_address, e);
             return;
         }
     };
@@ -229,20 +232,31 @@ fn handle_client(client_stream: TcpStream, configuration: &Arc<Proxy>) {
 
             let mut command = buffer[..bytes_read].to_vec();
 
-            for middleware in MIDDLEWARE {
-                command = middleware(&command);
+            if let Ok(mut guard) = available_middleware.lock() {
+                for middleware in guard.iter_mut() {
+                    command = middleware.client_message(&command);
+                }
             }
 
-            let debug_str = String::from_utf8_lossy(&command)
+            let debug_original = String::from_utf8_lossy(&buffer[..bytes_read])
                 .replace('\n', "\\n")
                 .replace('\r', "\\r")
                 .replace('\t', "\\t");
-            debug!(">>> {}", debug_str);
+
+            let debug_final = String::from_utf8_lossy(&command)
+                .replace('\n', "\\n")
+                .replace('\r', "\\r")
+                .replace('\t', "\\t");
+
+            debug!(">>> {debug_original}");
+            if debug_original != debug_final {
+                debug!("### {debug_final}");
+            }
 
             // Lock the TLS stream and write the data to server
             match tls_stream_clone.lock() {
                 Ok(mut tls_guard) => {
-                    if let Err(error) = tls_guard.write_all(&buffer[..bytes_read]) {
+                    if let Err(error) = tls_guard.write_all(&command) {
                         debug!(">>> Error writing to server: {error}");
                         break;
                     }
@@ -286,14 +300,28 @@ fn handle_client(client_stream: TcpStream, configuration: &Arc<Proxy>) {
                 }
             };
 
-            let debug_str = String::from_utf8_lossy(&buffer[..bytes_read])
+            let mut command = buffer[..bytes_read].to_vec();
+
+            if let Ok(mut guard) = available_middleware_clone.lock() {
+                for middleware in guard.iter_mut() {
+                    command = middleware.server_message(&command);
+                }
+            }
+
+            let debug_original = String::from_utf8_lossy(&buffer[..bytes_read])
+                .replace('\n', "\\n")
+                .replace('\r', "\\r")
+                .replace('\t', "\\t");
+
+            let debug_final = String::from_utf8_lossy(&command)
                 .replace('\n', "\\n")
                 .replace('\r', "\\r")
                 .replace('\t', "\\t");
-            debug!("<<< {}", debug_str);
+            debug!("<<< {debug_original}");
+            debug!("### {debug_final}");
 
             // Write decrypted data to client
-            if client_writer.write_all(&buffer[..bytes_read]).is_err() {
+            if client_writer.write_all(&command).is_err() {
                 debug!("<<< ERR");
                 break;
             }