fix traffic-masking

Author: kogeler

traffic-masking/.version

@@ -1 +1 @@
-1.0.3
+1.0.4

traffic-masking/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to the Traffic Masking System will be documented in this fil
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.4] - 2025-02-12
+
+### Fixed
+- Client no longer falsely reports "Reconnected successfully" when server is unreachable
+- Connection status now reflects actual data flow, not just successful UDP send
+- Exponential backoff now works correctly (was resetting every cycle due to false success)
+
+### Changed
+- Reconnection logic now waits for actual server response before confirming connection
+- Keepalive is only sent when connected; on timeout the client enters reconnect loop first
+- All Russian comments in source code translated to English
+
+### Improved
+- Reconnection test now validates no false reconnection reports during server downtime
+- Reconnection test verifies client shows `disconnected` status while server is down
+- Reconnection test requires `Reconnected successfully` message only after real server recovery
+
 ## [1.0.3] - 2025-02-12
 
 ### Fixed

traffic-masking/test_traffic_masking.py

@@ -604,15 +604,40 @@ def start_server():
         with open(client_log_path, "r") as f:
             loss_log = f.read()
 
-        if (
-            "disconnected" in loss_log
-            or "Connection lost" in loss_log
-            or "Reconnecting" in loss_log
-        ):
+        if "Connection lost" in loss_log:
             print("✓ Phase 2: Client detected connection loss")
         else:
             print("⚠ Phase 2: Client may not have detected loss (checking Phase 3)")
 
+        # Verify client does NOT falsely report successful reconnection while server is down
+        # Split log into lines after "Connection lost" to check behavior during downtime
+        loss_idx = loss_log.find("Connection lost")
+        if loss_idx >= 0:
+            downtime_log = loss_log[loss_idx:]
+            false_reconnects = downtime_log.count("Reconnected successfully")
+            if false_reconnects > 0:
+                print(
+                    f"✗ Phase 2: Client falsely reported 'Reconnected successfully' {false_reconnects} time(s) while server was down"
+                )
+                test_results["transmission"]["reconnect"] = False
+                return False
+            else:
+                print("✓ Phase 2: No false reconnection reports during server downtime")
+
+            # Verify client shows disconnected status (not connected) during downtime
+            downtime_stats = [l for l in downtime_log.splitlines() if "[STATS]" in l]
+            false_connected = [l for l in downtime_stats if "Status: connected" in l]
+            if false_connected:
+                print(
+                    f"✗ Phase 2: Client reported 'connected' status {len(false_connected)} time(s) while server was down"
+                )
+                test_results["transmission"]["reconnect"] = False
+                return False
+            else:
+                print(
+                    "✓ Phase 2: Client correctly reported disconnected status during downtime"
+                )
+
         # Phase 3: Restart server, verify client reconnects and resumes traffic
         print("[RECONN] Phase 3: Restarting server...")
         server_proc = start_server()
@@ -644,33 +669,36 @@ def start_server():
             test_results["transmission"]["reconnect"] = False
             return False
 
-        # Check if the last few stats lines show data reception
+        # Verify "Reconnected successfully" appears after server restart
+        # (should only appear now, not during Phase 2 downtime)
+        has_reconnected_msg = "Reconnected successfully" in full_log
+        if has_reconnected_msg:
+            print("✓ Phase 3: Client reported successful reconnection")
+        else:
+            print("✗ Phase 3: Client never reported 'Reconnected successfully'")
+            test_results["transmission"]["reconnect"] = False
+            return False
+
+        # Check the last few stats lines show connected status and data flow
         last_stats = stats_lines[-3:]
+        has_connected_status = any("Status: connected" in l for l in last_stats)
         recovered = False
         for line in last_stats:
             rx_match = re.search(r"Rx:\s*([0-9.]+)\s*Mbps", line)
             if rx_match and float(rx_match.group(1)) > 0.1:
                 recovered = True
                 break
 
-        # Also check for connected status in recent lines
-        has_connected_status = any(
-            "connected" in l and "disconnected" not in l
-            for l in full_log.splitlines()[-10:]
-            if "[STATS]" in l
-        )
-
-        # Check for reconnection log messages
-        has_reconnect_msg = "Reconnect" in full_log or "Registration sent" in full_log
-
-        if recovered or has_connected_status:
-            print("✓ Phase 3: Client reconnected and resumed receiving data")
+        if has_connected_status and recovered:
+            print("✓ Phase 3: Client connected and receiving data after recovery")
             test_results["transmission"]["reconnect"] = True
             success = True
-        elif has_reconnect_msg:
-            print(
-                "✓ Phase 3: Client attempted reconnection (traffic may still be ramping up)"
-            )
+        elif has_connected_status:
+            print("✓ Phase 3: Client connected (traffic still ramping up)")
+            test_results["transmission"]["reconnect"] = True
+            success = True
+        elif recovered:
+            print("✓ Phase 3: Client receiving data after recovery")
             test_results["transmission"]["reconnect"] = True
             success = True
         else:

traffic-masking/traffic_masking_client.py

@@ -88,40 +88,50 @@ def _create_socket(self):
         self.socket = init_udp_socket(socket.socket(socket.AF_INET, socket.SOCK_DGRAM))
         self.socket.settimeout(2.0)
 
-    def _register(self):
-        """Send registration packet to the server"""
+    def _send_registration(self):
+        """Send registration packet to the server (UDP: no delivery guarantee)"""
         try:
             self.socket.sendto(b"INIT_CLIENT", self.server_addr)
-            self.connected = True
-            self.last_received = time.time()
             print(
                 f"[*] Registration sent to {self.server_host}:{self.server_port}",
                 flush=True,
             )
+            return True
         except Exception as e:
             print(f"[!] Registration failed: {e}", flush=True)
-            self.connected = False
+            return False
+
+    def _wait_for_server(self, timeout=5.0):
+        """Wait for actual data from the server to confirm connection"""
+        deadline = time.time() + timeout
+        while time.time() < deadline and self.running:
+            if self.connected:
+                return True
+            time.sleep(0.2)
+        return self.connected
 
     def _reconnect(self):
         """Reconnect to the server with exponential backoff"""
         delay = self.RECONNECT_DELAY_MIN
         while self.running:
             print(
-                f"[*] Reconnecting in {delay:.1f}s...",
+                f"[*] Attempting reconnect in {delay:.1f}s...",
                 flush=True,
             )
             time.sleep(delay)
             if not self.running:
                 break
             try:
                 self._create_socket()
-                self._register()
-                if self.connected:
+                self._send_registration()
+                # Wait for actual server response to confirm connection
+                if self._wait_for_server(timeout=delay + 2.0):
                     print("[*] Reconnected successfully", flush=True)
-                    # Reset rate tracking for fresh start
                     self.received_rate = 0
                     self.rate_window.clear()
                     return
+                else:
+                    print("[!] No response from server", flush=True)
             except Exception as e:
                 print(f"[!] Reconnect failed: {e}", flush=True)
             delay = min(delay * 2, self.RECONNECT_DELAY_MAX)
@@ -144,7 +154,8 @@ def connect(self):
             )
 
         # Send initial registration packet
-        self._register()
+        self._send_registration()
+        self.last_received = time.time()  # Grace period for initial connection
 
         # Start threads
         threading.Thread(target=self.receive_loop, daemon=True).start()
@@ -247,12 +258,6 @@ def keepalive_loop(self):
             if not self.running:
                 break
 
-            # Send keepalive to stay registered on the server
-            try:
-                self.socket.sendto(b"KEEPALIVE", self.server_addr)
-            except Exception:
-                pass
-
             # Check if we've lost the connection
             if (
                 self.last_received > 0
@@ -265,6 +270,14 @@ def keepalive_loop(self):
                 self.connected = False
                 self.received_rate = 0
                 self._reconnect()
+                # After _reconnect returns (success), resume keepalive loop
+                continue
+
+            # Send keepalive to stay registered on the server
+            try:
+                self.socket.sendto(b"KEEPALIVE", self.server_addr)
+            except Exception:
+                pass
 
     def send_loop(self):
         """Generate uplink traffic"""