Add incoming timeout option (not documented yet)

Author: ClusterM

config.c

@@ -25,6 +25,7 @@ static const mini_argp_opt options[] = {
     { "static-bindings", 'b', 1 },
     { "max-clients" , 'm', 1 },
     { "idle-timeout", 'l', 1 },
+    { "in-timeout", 'n', 1 },
     { "max-dummy", 'd', 1 },
     { "fwmark", 'f', 1 },
     { "verbose", 'v', 1 },
@@ -64,6 +65,7 @@ static void show_usage(void)
         "Additional options:\n"
         "  -m, --max-clients=<number> Maximum number of clients (default: 1024)\n"
         "  -l, --idle-timeout=<sec>   Idle timeout in seconds (default: 300)\n"
+        "  -n, --in-timeout=<sec>     Incoming timeout in seconds (default: 0 - disabled)\n"
         "  -d, --max-dummy=<bytes>    Maximum length of dummy bytes for data packets\n" 
         "                             (default: 4)\n");
 }
@@ -83,6 +85,7 @@ static void reset_config(obfuscator_config_t *config)
     memset(config, 0, sizeof(*config));
     config->max_clients = MAX_CLIENTS_DEFAULT;
     config->idle_timeout = IDLE_TIMEOUT_DEFAULT;
+    config->in_timeout = IN_TIMEOUT_DEFAULT;
     config->max_dummy_length_data = MAX_DUMMY_LENGTH_DATA_DEFAULT;
     verbose = LL_DEFAULT;
 }
@@ -277,6 +280,18 @@ static int parse_opt(const char *lname, char sname, const char *val, void *ctx)
             }
             config->idle_timeout *= 1000; // Convert to milliseconds
             break;
+        case 'n':
+            if (!is_integer(val)) {
+                log(LL_ERROR, "Invalid incoming timeout: %s (must be an integer)", val);
+                exit(EXIT_FAILURE);
+            }
+            config->in_timeout = atol(val);
+            if (config->in_timeout <= 0) {
+                log(LL_ERROR, "Invalid incoming timeout: %s (must be greater than 0)", val);
+                exit(EXIT_FAILURE);
+            }
+            config->in_timeout *= 1000; // Convert to milliseconds
+            break;
         case 'd':
             if (!is_integer(val)) {
                 log(LL_ERROR, "Invalid maximum dummy length for data packets: %s (must be an integer)", val);

wg-obfuscator.c

@@ -625,6 +625,7 @@ int main(int argc, char *argv[]) {
                             continue;
                         }
                         client_entry->last_activity_time = now;
+                        client_entry->last_incoming_time = 0;
                         client_entry->masking_handler = masking_handler;
                     }
                     if (!obfuscated) {
@@ -863,6 +864,7 @@ int main(int argc, char *argv[]) {
                     continue;
                 }
                 client_entry->last_activity_time = now;
+                client_entry->last_incoming_time = now;
             } // if (event->data.fd != listen_sock)
         } // for (int e = 0; e < events_n; e++)
 
@@ -871,15 +873,18 @@ int main(int argc, char *argv[]) {
             // Iterate over all client entries
             HASH_ITER(hh, conn_table, current_entry, tmp) {
                 // Check if the entry is idle for too long
-                if (
-                    (
-                        (now - current_entry->last_activity_time >= config.idle_timeout)
-                        || (!current_entry->handshaked && (now - current_entry->last_activity_time >= HANDSHAKE_TIMEOUT))
-                    ) && !current_entry->is_static // Do not remove static entries
-                ) {
+                uint8_t idle = now - current_entry->last_activity_time >= config.idle_timeout;
+                uint8_t incoming_timeout = config.in_timeout > 0 && now - current_entry->last_incoming_time >= config.in_timeout;
+                uint8_t handshake_timeout = !current_entry->handshaked && now - current_entry->last_activity_time >= HANDSHAKE_TIMEOUT;
+                if ((idle || incoming_timeout || handshake_timeout) && !current_entry->is_static) { // Do not remove static entries
                     // Remove old entry
-                    log(current_entry->handshaked ? LL_INFO : LL_DEBUG, "Removing idle client %s:%d (handshaked=%s)", inet_ntoa(current_entry->client_addr.sin_addr), ntohs(current_entry->client_addr.sin_port), 
-                        current_entry->handshaked ? "yes" : "no");
+                    if (idle) {
+                        log(LL_INFO, "Removing idle client %s:%d", inet_ntoa(current_entry->client_addr.sin_addr), ntohs(current_entry->client_addr.sin_port));
+                    } else if (incoming_timeout) {
+                        log(LL_INFO, "Removing client %s:%d due to incoming timeout", inet_ntoa(current_entry->client_addr.sin_addr), ntohs(current_entry->client_addr.sin_port));
+                    } else if (handshake_timeout) {
+                        log(LL_INFO, "Removing client %s:%d due to handshake timeout", inet_ntoa(current_entry->client_addr.sin_addr), ntohs(current_entry->client_addr.sin_port));
+                    }
 #ifdef USE_EPOLL
                     epoll_ctl(epfd, EPOLL_CTL_DEL, current_entry->server_sock, NULL);
 #endif

wg-obfuscator.h

@@ -34,6 +34,7 @@
 
 #define MAX_CLIENTS_DEFAULT             1024    // maximum number of clients
 #define IDLE_TIMEOUT_DEFAULT            300000  // in milliseconds
+#define IN_TIMEOUT_DEFAULT              0       // in milliseconds
 #define MAX_DUMMY_LENGTH_DATA_DEFAULT   4       // maximum length of dummy data for data packets
 
 // Default instance name
@@ -79,6 +80,7 @@ typedef struct {
     char static_bindings[10 * 1024];            // Static bindings as a string
     int max_clients;                            // Maximum number of clients
     long idle_timeout;                          // Idle timeout in milliseconds
+    long in_timeout;                            // Incoming timeout in milliseconds
     int max_dummy_length_data;                  // Maximum length of dummy data for data packets
     uint32_t fwmark;                            // Firewall mark
     masking_handler_t *masking_handler;         // Masking handler to use
@@ -96,6 +98,7 @@ typedef struct {
     struct sockaddr_in client_addr;             // client address and port (key for the hash table)
     struct sockaddr_in our_addr;                // our address and port on the server connection
     long last_activity_time;                    // last time we received data from/to this client
+    long last_incoming_time;                    // last time we received data from the remote server
     long last_handshake_request_time;           // last time we received a handshake request from/to this client
     long last_handshake_time;                   // last time we received a handshake response from/to this client
     long last_masking_timer_time;               // last time we called the masking timer handler for this client