Add loop logging macros

Author: ComputerCraftr

src/logging.rs

@@ -77,3 +77,29 @@ macro_rules! log_debug_dir {
         }
     };
 }
+
+#[macro_export]
+macro_rules! option_or_log_continue {
+    ($opt:expr, $log_macro:ident, $($args:tt)*) => {
+        match $opt {
+            Some(v) => v,
+            None => {
+                $log_macro!($($args)*);
+                continue;
+            }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! result_or_log_continue {
+    ($res:expr, $log_macro:ident, $($args:tt)*) => {
+        match $res {
+            Ok(v) => v,
+            Err(e) => {
+                $log_macro!($($args)*, e);
+                continue;
+            }
+        }
+    };
+}

src/net/payload.rs

@@ -30,7 +30,7 @@ const fn be16_16(b0: u8, b1: u8) -> u16 {
 }
 
 #[inline]
-fn validate_payload<'a>(
+pub(crate) fn validate_payload<'a>(
     c2u: bool,
     cfg: &Config,
     stats: &Stats,
@@ -156,29 +156,6 @@ pub(crate) fn send_payload(
     }
 }
 
-pub(crate) fn validate_payload_or_log<'a>(
-    c2u: bool,
-    worker_id: usize,
-    cfg: &Config,
-    stats: &Stats,
-    buf: &'a [u8],
-    recv_port_id: u16,
-) -> Option<ValidatedPayload<'a>> {
-    match validate_payload(c2u, cfg, stats, buf, recv_port_id) {
-        Ok(v) => Some(v),
-        Err(e) => {
-            log_debug_dir!(
-                cfg.debug_log_drops,
-                worker_id,
-                c2u,
-                "validate_payload error: {}",
-                e
-            );
-            None
-        }
-    }
-}
-
 pub(crate) fn handle_payload_result(
     c2u: bool,
     worker_id: usize,

src/worker.rs

@@ -1,6 +1,6 @@
 use crate::cli::{Config, TimeoutAction};
 use crate::net::params::MAX_WIRE_PAYLOAD;
-use crate::net::payload::{handle_payload_result, send_payload, validate_payload_or_log};
+use crate::net::payload::{handle_payload_result, send_payload, validate_payload};
 use crate::net::sock_mgr::{SocketHandles, SocketManager};
 use crate::stats::Stats;
 use socket2::{SockAddr, Type};
@@ -236,16 +236,14 @@ pub fn run_upstream_to_client_thread(
                 cache.refresh_handles_and_cache(sock_mgr, &mut handles);
 
                 if locked.load(AtomOrdering::Relaxed) {
-                    let Some(validated) = validate_payload_or_log(
-                        C2U,
+                    let validated = result_or_log_continue!(
+                        validate_payload(C2U, cfg, stats, &buf.data[..len], cache.recv_port_id),
+                        log_debug_dir,
+                        cfg.debug_log_drops,
                         worker_id,
-                        cfg,
-                        stats,
-                        &buf.data[..len],
-                        cache.recv_port_id,
-                    ) else {
-                        continue;
-                    };
+                        C2U,
+                        "validate_payload error: {}"
+                    );
                     let send_res = send_payload(
                         C2U,
                         &validated,
@@ -314,16 +312,14 @@ pub fn run_client_to_upstream_thread(
                     let t_recv = Instant::now();
 
                     if locked.load(AtomOrdering::Relaxed) {
-                        let Some(validated) = validate_payload_or_log(
-                            C2U,
+                        let validated = result_or_log_continue!(
+                            validate_payload(C2U, cfg, stats, &buf.data[..len], cache.recv_port_id),
+                            log_debug_dir,
+                            cfg.debug_log_drops,
                             worker_id,
-                            cfg,
-                            stats,
-                            &buf.data[..len],
-                            cache.recv_port_id,
-                        ) else {
-                            continue;
-                        };
+                            C2U,
+                            "validate_payload error: {}"
+                        );
                         let send_res = send_payload(
                             C2U,
                             &validated,
@@ -365,26 +361,23 @@ pub fn run_client_to_upstream_thread(
 
                     // First lock: publish client and connect the socket for fast path
                     if !locked.load(AtomOrdering::Relaxed) {
-                        let Some(src) = src_sa.as_socket() else {
-                            log_warn_dir!(
-                                worker_id,
-                                C2U,
-                                "recv_from client non-IP address family (ignored): {:?}",
-                                src_sa
-                            );
-                            continue;
-                        };
-
-                        let Some(validated) = validate_payload_or_log(
+                        let src = option_or_log_continue!(
+                            src_sa.as_socket(),
+                            log_warn_dir,
+                            worker_id,
                             C2U,
+                            "recv_from client non-IP address family (ignored): {:?}",
+                            src_sa
+                        );
+
+                        let validated = result_or_log_continue!(
+                            validate_payload(C2U, cfg, stats, &buf.data[..len], cache.recv_port_id),
+                            log_debug_dir,
+                            cfg.debug_log_drops,
                             worker_id,
-                            cfg,
-                            stats,
-                            &buf.data[..len],
-                            cache.recv_port_id,
-                        ) else {
-                            continue;
-                        };
+                            C2U,
+                            "validate_payload error: {}"
+                        );
 
                         // Signal to other threads that a client is currently being locked
                         locked.store(true, AtomOrdering::Relaxed);
@@ -468,16 +461,14 @@ pub fn run_client_to_upstream_thread(
                         );
                     } else if Some(src_sa) == cache.client_sa {
                         // Only forward packets from the locked client (recv_from may still deliver before connect succeeds)
-                        let Some(validated) = validate_payload_or_log(
-                            C2U,
+                        let validated = result_or_log_continue!(
+                            validate_payload(C2U, cfg, stats, &buf.data[..len], cache.recv_port_id),
+                            log_debug_dir,
+                            cfg.debug_log_drops,
                             worker_id,
-                            cfg,
-                            stats,
-                            &buf.data[..len],
-                            cache.recv_port_id,
-                        ) else {
-                            continue;
-                        };
+                            C2U,
+                            "validate_payload error: {}"
+                        );
                         let send_res = send_payload(
                             C2U,
                             &validated,