125 lines
3.7 KiB
Rust
125 lines
3.7 KiB
Rust
uniffi::setup_scaffolding!();
|
|
pub mod connections;
|
|
pub mod tun;
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use netrunner_core::proxy::{connection::connection::ConnectionRole, network::Network};
|
|
use smoltcp::{iface::Config, phy::DeviceCapabilities};
|
|
use std::net::Ipv4Addr;
|
|
use std::sync::OnceLock;
|
|
use tokio::runtime::Runtime;
|
|
use tokio::sync::oneshot;
|
|
use tracing::info;
|
|
|
|
use crate::tun::{engine::Engine, tun::Tun};
|
|
|
|
static RUNTIME: OnceLock<Runtime> = OnceLock::new();
|
|
|
|
fn get_runtime() -> &'static Runtime {
|
|
RUNTIME.get_or_init(|| {
|
|
tokio::runtime::Builder::new_multi_thread()
|
|
.enable_all()
|
|
.build()
|
|
.expect("Failed to create tokio runtime")
|
|
})
|
|
}
|
|
// --- Обертка для Session ---
|
|
#[derive(uniffi::Object)]
|
|
pub struct Session {
|
|
shutdown_tx: Mutex<Option<oneshot::Sender<()>>>,
|
|
}
|
|
|
|
#[uniffi::export]
|
|
impl Session {
|
|
pub fn stop(&self) {
|
|
let mut guard = self.shutdown_tx.lock().unwrap();
|
|
if let Some(tx) = guard.take() {
|
|
let _ = tx.send(());
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Фабрика (SessionManager) ---
|
|
#[derive(uniffi::Object)]
|
|
pub struct SessionManager;
|
|
|
|
#[uniffi::constructor]
|
|
impl SessionManager {
|
|
pub fn new() -> Self {
|
|
Self
|
|
}
|
|
}
|
|
|
|
#[uniffi::export]
|
|
impl SessionManager {
|
|
pub fn start(&self, remote_address: String, tun_fd: Option<i32>) -> Arc<Session> {
|
|
let (tx, rx) = oneshot::channel();
|
|
let runtime = get_runtime();
|
|
runtime.spawn(async move {
|
|
info!("Starting VPN session...");
|
|
|
|
let tun_device = if let Some(fd) = tun_fd {
|
|
info!("Using provided FD for TUN: {}", fd);
|
|
Tun::from_android_fd(fd).expect("Failed to init TUN from FD")
|
|
} else {
|
|
info!("Creating TUN device manually");
|
|
Tun::create(|config| {
|
|
config
|
|
.tun_name("tun0")
|
|
.address((10, 0, 0, 1))
|
|
// ... настройки ...
|
|
.up();
|
|
})
|
|
.expect("Failed to init TUN")
|
|
};
|
|
|
|
tun_device.setup_routing();
|
|
tun_device.setup_dns_redirection();
|
|
|
|
// 2. Инициализация сети
|
|
let config = Config::new(smoltcp::wire::HardwareAddress::Ip);
|
|
let mut caps = DeviceCapabilities::default();
|
|
caps.max_transmission_unit = 1500;
|
|
caps.medium = smoltcp::phy::Medium::Ip;
|
|
|
|
let network = Network::new(
|
|
"0.0.0.0".into(),
|
|
8080,
|
|
ConnectionRole::Client,
|
|
Some(remote_address),
|
|
);
|
|
|
|
let proxy_ip = network.get_self_local_address();
|
|
|
|
// Запускаем сетевой поток
|
|
let net_handle = tokio::spawn(async move {
|
|
network.run().await;
|
|
});
|
|
|
|
// 3. Инициализация Engine
|
|
let mut engine = Engine::new(config, caps, proxy_ip);
|
|
engine.set_any_ip(true);
|
|
engine.set_transparent_mode();
|
|
engine.set_default_gateway(Ipv4Addr::new(10, 0, 0, 2));
|
|
engine.activate();
|
|
|
|
// 4. Главный цикл с поддержкой остановки
|
|
tokio::select! {
|
|
_ = engine.run(tun_device) => {
|
|
info!("Engine loop finished naturally.");
|
|
}
|
|
_ = rx => {
|
|
info!("Shutdown signal received. Cleaning up...");
|
|
}
|
|
}
|
|
|
|
net_handle.abort();
|
|
info!("VPN session stopped.");
|
|
});
|
|
|
|
Arc::new(Session {
|
|
shutdown_tx: Mutex::new(Some(tx)),
|
|
})
|
|
}
|
|
}
|