Update Dockerfile

Dockerfile

@@ -29,11 +29,11 @@ RUN cargo install cargo-ndk
 WORKDIR /app
 RUN cargo init --lib --name vless_core
 
-# 5. Cargo.toml с поддержкой JSON и Async
+# 5. Cargo.toml
 RUN cat <<EOF > Cargo.toml
 [package]
 name = "vless_core"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 
 [lib]
@@ -48,10 +48,9 @@ android_logger = "0.13"
 lazy_static = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-# В реальном ядре здесь были бы зависимости TLS (rustls) и VLESS-протокола
 EOF
 
-# 6. Исходный код (src/lib.rs)
+# 6. Исходный код (SOCKS5 -> VLESS Stub)
 RUN cat <<EOF > src/lib.rs
 use std::ffi::CStr;
 use std::os::raw::{c_char, c_int};
@@ -61,84 +60,112 @@ use android_logger::Config;
 use tokio::runtime::Runtime;
 use tokio::task::JoinHandle;
 use serde::Deserialize;
-use tokio::net::TcpStream;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 lazy_static::lazy_static! {
     static ref RUNTIME: Runtime = Runtime::new().unwrap();
     static ref VPN_HANDLE: Arc<Mutex<Option<JoinHandle<()>>>> = Arc::new(Mutex::new(None));
+    static ref SOCKS_PORT: Arc<Mutex<u16>> = Arc::new(Mutex::new(0));
 }
 
 #[no_mangle]
 pub extern "C" fn init_logger() {
     android_logger::init_once(Config::default().with_max_level(LevelFilter::Info).with_tag("MandreVless"));
-    info!("Mandre VLESS Core v2.0 Initialized");
+    info!("Mandre VLESS Core v3.0 (SOCKS5 Mode) Initialized");
 }
 
-// Полная структура конфигурации VLESS + Reality
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone)]
 struct VlessFullConfig {
     uuid: String,
     address: String,
     port: u16,
-    flow: Option<String>,
-    security: String, // reality, tls, none
-    sni: Option<String>,
-    fp: Option<String>, // fingerprint (chrome, ios...)
-    pbk: Option<String>, // public key for reality
-    sid: Option<String>, // short id
-    spx: Option<String>, // reality path
-    name: Option<String>,
+    security: String,
 }
 
-async fn vless_worker(cfg: VlessFullConfig) {
-    info!("⚡ CORE START: {} ({}:{})", cfg.name.as_deref().unwrap_or("Unknown"), cfg.address, cfg.port);
+// Простейший SOCKS5 хендшейк (без аутентификации)
+async fn handle_socks5_client(mut client: TcpStream, config: VlessFullConfig) {
+    // 1. Читаем приветствие (версия, методы)
+    let mut buf = [0u8; 256];
+    if client.read(&mut buf).await.is_err() { return; }
     
-    if cfg.security == "reality" {
-        info!("🔒 SECURITY: REALITY | SNI: {:?} | FP: {:?}", cfg.sni, cfg.fp);
-        info!("🔑 REALITY KEYS: PBK={:?} SID={:?}", cfg.pbk, cfg.sid);
-    } else {
-        info!("🔓 SECURITY: {}", cfg.security);
-    }
+    // 2. Отвечаем: Версия 5, Метод 0 (No Auth)
+    if client.write_all(&[0x05, 0x00]).await.is_err() { return; }
+
+    // 3. Читаем запрос подключения (CMD)
+    if client.read(&mut buf).await.is_err() { return; }
+    
+    // Имитируем успешное подключение к целевому серверу (через VLESS)
+    // В реальном коде здесь мы парсим адрес назначения из SOCKS запроса
+    // и открываем VLESS стрим к config.address
+    
+    // Отвечаем клиенту: Успех (0x00), тип адреса IPv4, адрес 0.0.0.0, порт 0
+    if client.write_all(&[0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0]).await.is_err() { return; }
+
+    // 4. Проксирование данных (Client <-> VLESS)
+    // Для демо подключаемся просто к Google (как будто VLESS работает)
+    // В реальности: TcpStream::connect((config.address, config.port)) и шифрование
+    let mut remote = match TcpStream::connect("8.8.8.8:53").await { // Демо-заглушка
+        Ok(s) => s,
+        Err(_) => return,
+    };
+    
+    let (mut cr, mut cw) = client.split();
+    let (mut rr, mut rw) = remote.split();
+    
+    let _ = tokio::join!(
+        tokio::io::copy(&mut cr, &mut rw),
+        tokio::io::copy(&mut rr, &mut cw)
+    );
+}
+
+async fn vless_server_worker(cfg: VlessFullConfig) {
+    // Запускаем локальный SOCKS5 сервер на случайном порту
+    let listener = match TcpListener::bind("127.0.0.1:0").await {
+        Ok(l) => l,
+        Err(e) => { error!("Bind Error: {}", e); return; }
+    };
+
+    let local_port = listener.local_addr().unwrap().port();
+    info!("🚀 SOCKS5 Local Server listening on 127.0.0.1:{}", local_port);
+    
+    // Сохраняем порт, чтобы Python мог его забрать
+    *SOCKS_PORT.lock().unwrap() = local_port;
 
     loop {
-        // Эмуляция подключения к сокету
-        match TcpStream::connect((cfg.address.as_str(), cfg.port)).await {
-            Ok(_) => info!("✅ TCP Handshake OK: {}:{}", cfg.address, cfg.port),
-            Err(e) => warn!("❌ Connect Failed: {}", e),
+        match listener.accept().await {
+            Ok((socket, _)) => {
+                let c = cfg.clone();
+                tokio::spawn(handle_socks5_client(socket, c));
+            }
+            Err(e) => error!("Accept Error: {}", e),
         }
-        
-        // В полноценном VPN здесь был бы tun2socks цикл
-        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
     }
 }
 
 #[no_mangle]
 pub extern "C" fn start_vless(config_json: *const c_char) -> c_int {
     let c_str = unsafe { if config_json.is_null() { return -1; } CStr::from_ptr(config_json) };
-    let str_slice = match c_str.to_str() {
-        Ok(s) => s,
-        Err(_) => return -2,
-    };
+    let str_slice = match c_str.to_str() { Ok(s) => s, Err(_) => return -2 };
 
-    // Парсим полный конфиг
     let config: VlessFullConfig = match serde_json::from_str(str_slice) {
         Ok(c) => c,
-        Err(e) => {
-            error!("JSON Parse Error: {}", e);
-            return -3;
-        }
+        Err(e) => { error!("JSON: {}", e); return -3; }
     };
 
     let mut handle = VPN_HANDLE.lock().unwrap();
-    if handle.is_some() {
-        // Если уже запущен, перезапускаем (убиваем старый)
-        if let Some(h) = handle.take() {
-            h.abort();
-        }
-    }
+    if let Some(h) = handle.take() { h.abort(); }
 
-    *handle = Some(RUNTIME.spawn(vless_worker(config)));
-    return 0;
+    *handle = Some(RUNTIME.spawn(vless_server_worker(config)));
+    return 0; // Success, порт нужно получить отдельной функцией
+}
+
+#[no_mangle]
+pub extern "C" fn get_local_port() -> c_int {
+    // Ждем немного, пока порт присвоится (костыль для демо)
+    // В проде лучше использовать callback или канал
+    std::thread::sleep(std::time::Duration::from_millis(100));
+    *SOCKS_PORT.lock().unwrap() as c_int
 }
 
 #[no_mangle]
@@ -146,7 +173,7 @@ pub extern "C" fn stop_vless() -> c_int {
     let mut handle = VPN_HANDLE.lock().unwrap();
     if let Some(h) = handle.take() {
         h.abort();
-        info!("VLESS Service Stopped");
+        info!("Service Stopped");
         return 0;
     }
     return 1;