core engine rewrite and client side changes

client/src/connections/udp_connection.rs

@@ -3,128 +3,71 @@ use smoltcp::socket::udp;
 use smoltcp::wire::IpEndpoint;
 use std::time::{Duration, Instant};
 use tokio::sync::mpsc;
-use tokio_util::sync::CancellationToken;
-
-use bytes::Bytes;
-use netrunner_core::{
-    protocol::codec::{frame::FrameType, socks::TargetAddress},
-    proxy::connection::muxer::{MuxMessage, Muxer},
-};
 
 use crate::connections::CHANNEL_CAPACITY;
+use bytes::Bytes;
 
 pub struct UdpConnection {
     pub handle: SocketHandle,
-    stream_id: u32,
-    tx_to_net: mpsc::Sender<MuxMessage>,
-    rx_from_net: mpsc::UnboundedReceiver<Bytes>, // <-- ТУТ
+    // UPLOAD: Ограниченный канал для передачи данных наружу
+    tx: mpsc::Sender<Bytes>,
+    // DOWNLOAD: Канал для приема данных из сети
+    rx: mpsc::Receiver<Bytes>,
     client_endpoint: Option<IpEndpoint>,
     last_activity: Instant,
-    token: CancellationToken,
 }
 
 const UDP_TIMEOUT: Duration = Duration::from_secs(60);
 
 impl UdpConnection {
-    pub fn new(handle: SocketHandle, target_addr: TargetAddress, muxer: Muxer) -> Self {
-        let stream_id = muxer.next_id();
-        let token = CancellationToken::new();
-        let task_token = token.clone();
+    /// Возвращает:
+    /// 1. Экземпляр UdpConnection
+    /// 2. Receiver (для чтения данных, отправляемых ИЗ smoltcp В сеть)
+    /// 3. Sender (для записи данных ИЗ сети В smoltcp)
+    pub fn new(handle: SocketHandle) -> (Self, mpsc::Receiver<Bytes>, mpsc::Sender<Bytes>) {
+        let (tx_to_net, rx_from_smol) = mpsc::channel::<Bytes>(CHANNEL_CAPACITY);
+        let (tx_to_smol, rx_from_net) = mpsc::channel::<Bytes>(CHANNEL_CAPACITY);
 
-        let (tx_to_net, mut rx_from_smol) = mpsc::channel::<MuxMessage>(CHANNEL_CAPACITY);
-
-        // ИСПРАВЛЕНИЕ: Внутренний безлимитный канал
-        let (internal_tx, internal_rx) = mpsc::unbounded_channel::<Bytes>();
-
-        let m_clone = muxer.clone();
-
-        tokio::spawn(async move {
-            // Даем Муксеру ограниченный канал (тип Sender), чтобы компилятор пропустил
-            let (v_tx, mut v_rx) = mpsc::channel::<Bytes>(1024);
-            m_clone.register_stream(stream_id, v_tx);
-
-            let _ = m_clone
-                .send_to_netwrok(MuxMessage {
-                    stream_id,
-                    frame_type: FrameType::UdpConnect,
-                    data: Bytes::from(target_addr.to_string()),
-                })
-                .await;
-
-            let to_proxy = async {
-                while let Some(msg) = rx_from_smol.recv().await {
-                    if m_clone.send_to_netwrok(msg).await.is_err() {
-                        break;
-                    }
-                }
-            };
-
-            // Мгновенно выкачиваем данные из Муксера в безлимитный внутренний канал
-            let from_proxy = async {
-                while let Some(data) = v_rx.recv().await {
-                    if internal_tx.send(data).is_err() {
-                        break;
-                    }
-                }
-            };
-
-            tokio::select! {
-                _ = to_proxy => {}
-                _ = from_proxy => {} // Не забудь добавить этот блок в select!
-                _ = task_token.cancelled() => {}
-            }
-
-            let _ = m_clone
-                .send_to_netwrok(MuxMessage {
-                    stream_id,
-                    frame_type: FrameType::Close,
-                    data: Bytes::new(),
-                })
-                .await;
-            m_clone.remove_stream(stream_id);
-        });
-
-        Self {
+        let conn = Self {
             handle,
-            stream_id,
-            tx_to_net,
-            rx_from_net: internal_rx, // Сохраняем безлимитный ресивер
+            tx: tx_to_net,
+            rx: rx_from_net,
             client_endpoint: None,
             last_activity: Instant::now(),
-            token,
-        }
+        };
+
+        (conn, rx_from_smol, tx_to_smol)
     }
 
     pub fn tick(&mut self, socket: &mut udp::Socket) -> bool {
+        // Проверка таймаута бездействия
         if self.last_activity.elapsed() > UDP_TIMEOUT {
             netrunner_logger::debug!(%self.handle, "UDP Session closed due to timeout");
-            self.token.cancel();
             socket.close();
             return false;
         }
 
+        // 1. UPLOAD: Читаем из smoltcp и отправляем в виртуальный канал
         if socket.can_recv() {
             while let Ok((data, metadata)) = socket.recv() {
                 self.client_endpoint = Some(metadata.endpoint);
 
-                let msg = MuxMessage {
-                    stream_id: self.stream_id,
-                    frame_type: FrameType::UdpData,
-                    data: Bytes::copy_from_slice(data),
-                };
-
-                if self.tx_to_net.try_send(msg).is_ok() {
+                // Копируем данные в Bytes и пытаемся протолкнуть.
+                // Если канал забит (Full), пакет дропается — это штатное поведение UDP.
+                if self.tx.try_send(Bytes::copy_from_slice(data)).is_ok() {
                     self.last_activity = Instant::now();
                 }
             }
         }
 
+        // 2. DOWNLOAD: Читаем из виртуального канала и пишем в smoltcp
         if socket.can_send() {
             if let Some(endpoint) = self.client_endpoint {
-                while let Ok(data) = self.rx_from_net.try_recv() {
+                while let Ok(data) = self.rx.try_recv() {
+                    // Сигнал закрытия стрима
                     if data.is_empty() {
-                        self.token.cancel();
-                        break;
+                        socket.close();
+                        return false;
                     }
 
                     match socket.send_slice(&data, endpoint) {
@@ -132,6 +75,8 @@ impl UdpConnection {
                             self.last_activity = Instant::now();
                         }
                         Err(_) => {
+                            // Если сокет smoltcp переполнен, прерываем цикл.
+                            // Пакет теряется, что опять же является нормой для UDP.
                             break;
                         }
                     }