trying to fix udp telegram

client/src/net/connection.rs

@@ -9,7 +9,7 @@ use smoltcp::{
 use std::time::Duration;
 use tokio::sync::{mpsc, oneshot};
 // Добавили trace для частых логов (попакетно) и debug для состояний
-use netrunner_logger::{debug, info, trace, warn};
+use netrunner_logger::{debug, error, info, trace, warn};
 
 // ============================================================================
 // 1. БАЗОВАЯ СТРУКТУРА (ConnectionCore)
@@ -302,10 +302,16 @@ impl UdpConnection {
                     match self.core.rx.try_recv() {
                         Ok(data) => match socket.send_slice(&data, client_endpoint) {
                             Ok(_) => {
+                                info!(
+                                    %self.core.handle,
+                                    bytes = data.len(),
+                                    target = %client_endpoint,
+                                    "🟢 SUCCESS: Received UDP from tunnel, pushed to smoltcp!"
+                                );
                                 self.last_activity = smoltcp::time::Instant::now();
                             }
                             Err(e) => {
-                                debug!(%self.core.handle, "Failed to send UDP datagram: {:?}", e);
+                                error!(%self.core.handle, "Failed to send UDP datagram: {:?}", e);
                                 break;
                             }
                         },

client/src/net/connection_manager.rs

@@ -161,7 +161,7 @@ impl SocketFactory {
 
     fn create_udp<'a>(port: u16) -> udp::Socket<'a> {
         let config = NetworkConfig::global();
-        let max_buf = config.udp_buffer_size;
+        let max_buf = config.smoltcp_socket_buf;
         let payload_size = config.safe_payload_size.max(1); // Защита от деления на 0
 
         // Вычисляем размер буфера и количество пакетов
@@ -170,9 +170,7 @@ impl SocketFactory {
             53 => (64 * 1024, (64 * 1024) / payload_size), // DNS
             _ => (max_buf, max_buf / payload_size),
         };
-
+        let packet_count = packet_count.max(32);
-        // Гарантируем, что метаданных хватит хотя бы на 10 пакетов
-        let packet_count = packet_count.max(10);
 
         udp::Socket::new(
             udp::PacketBuffer::new(
@@ -226,13 +224,25 @@ impl ConnectionManager {
             match tx.try_send(frame.payload.clone()) {
                 Ok(_) => Ok(()),
                 Err(tokio::sync::mpsc::error::TrySendError::Full(_)) => {
-                    Err(frame) // Возвращаем кадр, чтобы Engine затормозил чтение туннеля
+                    error!(
+                        "🟡 WARNING: Inbound channel FULL for stream {}",
+                        frame.socket_id
+                    );
+                    Err(frame)
                 }
                 Err(tokio::sync::mpsc::error::TrySendError::Closed(_)) => {
-                    Ok(()) // Сокет уже закрыт браузером, дропаем пакет
+                    error!(
+                        "🔴 WARNING: Inbound channel CLOSED for stream {}",
+                        frame.socket_id
+                    );
+                    Ok(())
                 }
             }
         } else {
+            error!(
+                "👻 ORPHAN PACKET: No local socket for stream {}",
+                frame.socket_id
+            );
             Ok(())
         }
     }

core/src/net/network.rs

@@ -97,29 +97,36 @@ pub struct NetworkConfig {
 
 impl NetworkConfig {
     pub fn new(system_mtu: usize) -> Self {
-        let transport_overhead = 28;
+        // 1. Оверхед и MTU (Борьба с фрагментацией)
+        let transport_overhead = 28; // IPv4 (20) + UDP (8)
         let max_wire_frame = system_mtu.saturating_sub(transport_overhead);
-        let safe_payload = max_wire_frame.saturating_sub(10).saturating_sub(255);
 
-        let muxer_capacity = 64;
+        // ВАЖНО: Убираем вычитание 255! Оставляем 64 байта под заголовки твоего протокола и крипто-теги.
-        let tcp_stream_capacity = 4; // Жесткий лимит для загрузок
+        // Это даст safe_payload около ~1408 байт, что идеально ложится в стандартный интернет-пакет.
-        let udp_stream_capacity = 8;
+        let safe_payload = max_wire_frame.saturating_sub(64);
+
+        // 2. Каналы Muxer (Баланс между скоростью и задержкой)
+        let muxer_capacity = 512; // Глобальная очередь (выдержит много вкладок)
+        let tcp_stream_capacity = 16; // Хватит для скорости, но не даст пингу взлететь
+        let udp_stream_capacity = 64; // Простор для голосового трафика и игр
 
         Self {
             mtu: system_mtu,
             max_wire_frame_size: max_wire_frame,
             safe_payload_size: safe_payload,
 
-            // Заменяем громоздкие вычисления на стандартные 64KB чанки для системных сокетов
+            // 3. Системные буферы ОС (Широкие "входные ворота")
-            tcp_buffer_size: 16 * 1024,
+            tcp_buffer_size: 256 * 1024, // 256 KB
-            udp_buffer_size: 16 * 1024,
+            udp_buffer_size: 512 * 1024, // 512 KB
 
             muxer_capacity,
             tcp_stream_capacity,
             udp_stream_capacity,
-            smoltcp_socket_buf: 64 * 1024,
+
-            tcp_max_pending: 16 * 1024,
+            // 4. Настройки виртуального стека smoltcp (Движок)
-            tcp_chunk_size: 8 * 1024,
+            smoltcp_socket_buf: 256 * 1024, // 256 KB - КРИТИЧНО для скорости загрузки!
+            tcp_max_pending: 32 * 1024,     // 32 KB - Очередь на запись
+            tcp_chunk_size: 16 * 1024,      // 16 KB - Куски, которыми мы читаем данные
         }
     }
 

server/src/main.rs

@@ -14,7 +14,7 @@ struct Args {
 
 fn main() {
     Logger::init();
-    Logger::global().set_level("trace"); //set error in prod
+    Logger::global().set_level("info"); //set error in prod
     let args = Args::parse();
     let net = Network::new(args.host, args.port, ConnectionRole::Server, None);