close to final of fake ip resolving

client/src/tun/connection_manager.rs

@@ -33,19 +33,29 @@ impl ConnectionManager {
             fake_ip_store: FakeIpStore::new(),
         }
     }
-
     pub fn start_listening(&mut self, socket_set: &mut SocketSet) {
         for (_, socket) in socket_set.iter_mut() {
+            // Обработка TCP (как было)
             if let Some(tcp) = tcp::Socket::downcast_mut(socket) {
                 if !tcp.is_open() {
                     let endpoint = IpListenEndpoint {
                         addr: None,
                         port: 443,
                     };
-
-                    match tcp.listen(endpoint) {
-                        Ok(_) => debug!("Socket is now listening"),
-                        Err(e) => warn!(error=?e, "Failed to listen on socket"),
+                    let _ = tcp.listen(endpoint);
+                }
+            }
+            // Добавляем обработку UDP
+            else if let Some(udp) = udp::Socket::downcast_mut(socket) {
+                if !udp.is_open() {
+                    // Биндим на 53 порт, чтобы ловить DNS-запросы
+                    let endpoint = IpListenEndpoint {
+                        addr: None,
+                        port: 53,
+                    };
+                    match udp.bind(endpoint) {
+                        Ok(_) => debug!("UDP socket bound to port 53"),
+                        Err(e) => warn!(error=?e, "Failed to bind UDP socket"),
                     }
                 }
             }
@@ -54,7 +64,7 @@ impl ConnectionManager {
 
     fn resolve_target(&self, socket: &tcp::Socket) -> TargetAddress {
         // Безопасно получаем эндпоинт
-        let remote_endpoint = match socket.remote_endpoint() {
+        let local_endpoint = match socket.local_endpoint() {
             Some(ep) => ep,
             None => {
                 warn!(handle=?socket, "Attempted to resolve target for an unconnected socket");
@@ -62,18 +72,21 @@ impl ConnectionManager {
                 return TargetAddress::Domain("disconnected".to_string(), 0);
             }
         };
+        debug!(remote_addr = %local_endpoint.addr, remote_port = %local_endpoint.port, "SMOLTCP RAW REMOTE ENDPOINT");
 
-        let port = remote_endpoint.port;
-        let ip = remote_endpoint.addr;
+        let port = local_endpoint.port;
+        let ip = local_endpoint.addr;
 
         match ip {
             smoltcp::wire::IpAddress::Ipv4(ipv4_addr) => {
                 let std_ip = std::net::Ipv4Addr::from(ipv4_addr);
 
-                // Ищем домен в нашем FakeIpStore
+                debug!(ip=%std_ip, "Trying to resolve IP in FakeIpStore");
                 if let Some(domain) = self.fake_ip_store.lookup_by_ip(&std_ip) {
                     debug!(target=%domain, port=%port, "Resolved fake IP to domain");
                     return TargetAddress::Domain(domain, port);
+                } else {
+                    warn!(ip=%std_ip, "IP not found in FakeIpStore! SOCKS request will fail.");
                 }
 
                 debug!(ip=%std_ip, port=%port, "Using raw IP target");

client/src/tun/engine.rs

@@ -4,7 +4,6 @@ use smoltcp::{
     iface::{Config, Interface, SocketSet},
     phy::DeviceCapabilities,
 };
-use std::net::Ipv4Addr;
 use std::{
     mem,
     sync::{Arc, LazyLock, atomic::AtomicBool},
@@ -38,8 +37,8 @@ impl Engine {
         let (mut device, bridge_rx, bridge_tx, avail) = VirtTunDevice::new(caps);
         let interface = Interface::new(config, &mut device, now);
 
-        let mut socket_set = ConnectionManager::setup_sockets(16, 4, 1);
-        let mut manager = ConnectionManager::new(ip);
+        let socket_set = ConnectionManager::setup_sockets(16, 4, 1);
+        let manager = ConnectionManager::new(ip);
         Self {
             interface,
             socket_set,
@@ -104,13 +103,6 @@ impl Engine {
                     break;
                 }
 
-                if n >= 20 {
-                    let dst_ip = std::net::Ipv4Addr::new(buf[16], buf[17], buf[18], buf[19]);
-                    let dst_port = u16::from_be_bytes([buf[22], buf[23]]); // Порт для TCP
-
-                    debug!("Сырой пакет: назначение {}:{}", dst_ip, dst_port);
-                }
-
                 let mut token = TokenBuffer::with_capacity(n);
                 token.extend_from_slice(&buf[..n]);
 

client/src/tun/tun.rs

@@ -46,16 +46,55 @@ impl Tun {
     pub fn setup_routing(&self) -> io::Result<()> {
         use std::process::Command;
 
-        // Теперь, когда мы знаем, что tun0 имеет IP 10.0.0.1,
-        // мы можем смело ставить его шлюзом.
+        // 1. Удаляем существующий default-маршрут (чтобы не было конфликтов)
+        // Игнорируем ошибку, если его вдруг нет
+        let _ = Command::new("sudo")
+            .args(&["ip", "route", "del", "default"])
+            .status();
 
-        // 1. Устанавливаем маршрут через созданный интерфейс tun0
+        // 2. Добавляем tun0 как ГЛАВНЫЙ маршрут (метрика 1 — самый высокий приоритет)
         let _ = Command::new("sudo")
             .args(&[
                 "ip", "route", "add", "default", "via", "10.0.0.2", "dev", "tun0", "metric", "1",
             ])
             .status();
 
+        // 3. Добавляем eth0 как РЕЗЕРВНЫЙ маршрут (метрика 100 — низкий приоритет)
+        // ВАЖНО: Тебе нужно знать IP шлюза твоего eth0.
+        // Если ты не знаешь его заранее, можешь попробовать вытащить его из `ip route`
+        // или просто оставить как есть, если eth0 — единственный физический интерфейс.
+        let _ = Command::new("sudo")
+            .args(&[
+                "ip",
+                "route",
+                "add",
+                "default",
+                "via",
+                "172.18.144.1",
+                "dev",
+                "eth0",
+                "metric",
+                "100",
+            ])
+            .status();
+
+        info!(
+            "Маршрутизация настроена: tun0 (metric 1) -> основной, eth0 (metric 100) -> резервный"
+        );
+        Ok(())
+    }
+
+    pub fn setup_dns_redirection(&self) -> io::Result<()> {
+        // 1. Создаем временный файл resolv.conf
+        // Мы говорим системе: "Твой DNS-сервер теперь 10.0.0.1" (твой TUN-IP)
+        let _ = std::fs::write("/tmp/resolv.conf.netrunner", "nameserver 10.0.0.2\n");
+
+        // 2. Применяем его (для Linux/systemd)
+        let _ = std::process::Command::new("sudo")
+            .args(&["cp", "/tmp/resolv.conf.netrunner", "/etc/resolv.conf"])
+            .status();
+
+        info!("DNS перенаправлен на 10.0.0.1");
         Ok(())
     }
 }