diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..c8535d9 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "switch/p2p_channel"] + path = switch/p2p_channel + url = git@github.com:lbl8603/p2p_channel.git diff --git a/README.md b/README.md index 3bb61de..e3a7589 100644 --- a/README.md +++ b/README.md @@ -6,31 +6,59 @@ ### 示例： -- 在一台mac设备上运行，获取到ip 10.13.0.2： +1. 指定一个token，在多台设备上运行该程序，例如： + ```shell + # linux上 + root@DESKTOP-0BCHNIO:/opt# ./switch-desktop start --token 123456 + # 在另一台linux上使用nohup后台运行，不在命令行指定配置时，将在home/.switch/config文件中读取配置 + [root@izj6cemne76ykdzkataftfz switch]# nohup ./switch-desktop start & + # windows上 + D:\switch\bin_v1>switch-desktop.exe start --token 123456 + ``` +2. 可以执行status命令查看当前设备的虚拟ip + ```shell + root@DESKTOP-0BCHNIO:/opt# ./switch-desktop status + Name: Ubuntu 18.04 (bionic) [64-bit] + Virtual ip: 10.26.0.2 + Virtual gateway: 10.26.0.1 + Virtual netmask: 255.255.255.0 + Connection status: Connected + NAT type: Cone + Relay server: 43.139.56.10:29871 + Public ips: 120.228.76.75 + Local ip: 172.25.165.58 + ``` +3. 也可以执行list命令查看其他设备的虚拟ip + ```shell + root@DESKTOP-0BCHNIO:/opt# ./switch-desktop list + Name Virtual Ip P2P/Relay Rt Status + Windows 10.0.22621 (Windows 11 Professional) [64-bit] 10.26.0.3 p2p 2 Online + CentOS 7.9.2009 (Core) [64-bit] 10.26.0.4 p2p 35 Online + ``` +4. 最后可以用虚拟ip实现设备间相互访问 + 1. ping - 图片 + ping + 2. ssh + + ssh -- 在另一台windows上运行，获取到ip 10.13.0.3： +### 更多玩法 - ![图片](https://user-images.githubusercontent.com/49143209/210380063-d02c5b46-8fef-4e21-aa9b-6c2defcb1412.png) +1. 和远程桌面(如mstsc)搭配，超低延迟的体验 +2. 安装samba服务，共享磁盘 +3. 搭配公网服务器nginx反向代理，在公网访问本地文件 -- 此时这两个不同局域网的设备之间就能用ip相互访问了 - - 图片 - -- 输入"list"查看其他已连接的设备(p2p表示NAT打洞成功，relay表示使用服务器中继转发),"status"查看当前设备状态 - - 图片 - -- token的作用是标识一个虚拟局域网，当使用公共服务器时，建议使用一个唯一值当token(比如uuid)，否则有可能连接到其他人创建的虚拟局域网中 -- 公共服务器目前的配置是2核4G 4Mbps，有需要再扩展~ ### 使用须知 +- token的作用是标识一个虚拟局域网，当使用公共服务器时，建议使用一个唯一值当token(比如uuid)，否则有可能连接到其他人创建的虚拟局域网中 +- 建议指定deviceId，默认使用MAC地址，在某些环境下可能发生变化 +- 公共服务器目前的配置是2核4G 4Mbps，有需要再扩展~ - 需要root/管理员权限 - 使用命令行运行 - Mac和Linux下需要加可执行权限(例如:chmod +x ./switch-macos) -- 暂时固定使用的10.13.0.1/24网段，需要避免和已有的路由冲突 -## 编译 +- 自己搭注册和中继服务器(https://github.com/lbl8603/switch-server) +### 编译 前提条件:安装rust编译环境(https://www.rust-lang.org/zh-CN/tools/install) 到项目根目录下执行 cargo build -p switch-desktop @@ -47,9 +75,9 @@ - NAT穿透 - 点对点穿透 - 服务端中继转发 -- Windows后台服务 + - 客户端中继转发 ### Todo - 支持安卓 - 数据加密 -- 客户端中继转发 + diff --git a/documents/img/cmd_list.jpg b/documents/img/cmd_list.jpg new file mode 100644 index 0000000..dcdc038 Binary files /dev/null and b/documents/img/cmd_list.jpg differ diff --git a/documents/img/cmd_status.jpg b/documents/img/cmd_status.jpg new file mode 100644 index 0000000..81f8351 Binary files /dev/null and b/documents/img/cmd_status.jpg differ diff --git a/documents/img/ping.jpg b/documents/img/ping.jpg new file mode 100644 index 0000000..a4c1caa Binary files /dev/null and b/documents/img/ping.jpg differ diff --git a/documents/img/ssh.jpg b/documents/img/ssh.jpg new file mode 100644 index 0000000..ea3dde1 Binary files /dev/null and b/documents/img/ssh.jpg differ diff --git a/switch-desktop/Cargo.toml b/switch-desktop/Cargo.toml index 5ceebd1..bf154e5 100644 --- a/switch-desktop/Cargo.toml +++ b/switch-desktop/Cargo.toml @@ -13,17 +13,19 @@ console = "0.15.2" dirs = "4.0.0" log = "0.4.17" log4rs = "1.2.0" -tokio = { version = "1.24.1", features = ["full"] } +#tokio = { version = "1.24.1", features = ["full"] } chrono = "0.4.23" serde = "1.0" serde_yaml = "0.9" +serde_json = "1.0.94" crossbeam = "0.8.2" lazy_static = "1.4.0" parking_lot = "0.12.1" -#parity-tokio-ipc = "0.9.0" -futures = "0.3" +fs2 = "0.4.3" + +os_info = "3.5.1" [target.'cfg(any(target_os = "linux",target_os = "macos"))'.dependencies] sudo = "0.6.0" diff --git a/switch-desktop/src/command/client.rs b/switch-desktop/src/command/client.rs index b570b7a..765588c 100644 --- a/switch-desktop/src/command/client.rs +++ b/switch-desktop/src/command/client.rs @@ -2,15 +2,17 @@ use std::io; use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket}; use std::time::Duration; +use crate::command::entity::{DeviceItem, RouteItem, Status}; + pub struct CommandClient { udp: UdpSocket, } impl CommandClient { pub fn new() -> io::Result { - let port = crate::config::read_command_port().unwrap(); + let port = crate::config::read_command_port()?; let udp = UdpSocket::bind("127.0.0.1:0")?; - udp.set_read_timeout(Some(Duration::from_secs(5)))?; + udp.set_read_timeout(Some(Duration::from_secs(2)))?; udp.connect(SocketAddr::V4(SocketAddrV4::new( Ipv4Addr::new(127, 0, 0, 1), port, @@ -20,16 +22,53 @@ impl CommandClient { } impl CommandClient { - pub fn list(&self) -> io::Result { + pub fn list(&self) -> io::Result> { self.udp.send(b"list")?; let mut buf = [0; 10240]; let len = self.udp.recv(&mut buf)?; - Ok(String::from_utf8(buf[..len].to_vec()).unwrap()) + match serde_json::from_slice::>(&buf[..len]) { + Ok(val) => { + Ok(val) + } + Err(e) => { + log::error!("{:?}",e); + Err(io::Error::new(io::ErrorKind::Other, "data error")) + } + } } - pub fn status(&self) -> io::Result { + pub fn route(&self) -> io::Result> { + self.udp.send(b"route")?; + let mut buf = [0; 10240]; + let len = self.udp.recv(&mut buf)?; + match serde_json::from_slice::>(&buf[..len]) { + Ok(val) => { + Ok(val) + } + Err(e) => { + log::error!("{:?}",e); + Err(io::Error::new(io::ErrorKind::Other, "data error")) + } + } + } + pub fn status(&self) -> io::Result { self.udp.send(b"status")?; let mut buf = [0; 10240]; let len = self.udp.recv(&mut buf)?; + match serde_json::from_slice::(&buf[..len]) { + Ok(val) => { + Ok(val) + } + Err(e) => { + log::error!("{:?},{:?}",&buf[..len],e); + Err(io::Error::new(io::ErrorKind::Other, "data error")) + } + } + } + #[cfg(any(unix))] + pub fn stop(&self) -> io::Result { + self.udp.send(b"stop")?; + let mut buf = [0; 10240]; + let len = self.udp.recv(&mut buf)?; Ok(String::from_utf8(buf[..len].to_vec()).unwrap()) } } diff --git a/switch-desktop/src/command/entity.rs b/switch-desktop/src/command/entity.rs new file mode 100644 index 0000000..2f7c373 --- /dev/null +++ b/switch-desktop/src/command/entity.rs @@ -0,0 +1,34 @@ +use serde::{Deserialize, Serialize}; +#[derive(Serialize, Deserialize, Debug)] +pub struct Status { + pub name: String, + pub virtual_ip: String, + pub virtual_gateway: String, + pub virtual_netmask: String, + pub connect_status: String, + pub relay_server: String, + pub nat_type: String, + pub public_ips: String, + pub local_ip: String, +} + +#[derive(Serialize, Deserialize, Debug)] +pub struct RouteItem { + pub destination: String, + pub next_hop: String, + pub metric: String, + pub rt: String, + pub interface: String, +} + +#[derive(Serialize, Deserialize, Debug)] +pub struct DeviceItem { + pub name: String, + pub virtual_ip: String, + pub nat_type: String, + pub public_ips: String, + pub local_ip: String, + pub nat_traversal_type: String, + pub rt: String, + pub status: String, +} \ No newline at end of file diff --git a/switch-desktop/src/command/mod.rs b/switch-desktop/src/command/mod.rs index c07f47e..ab99755 100644 --- a/switch-desktop/src/command/mod.rs +++ b/switch-desktop/src/command/mod.rs @@ -1,2 +1,59 @@ +use std::io; +use console::style; +use crate::console_out; + pub mod client; pub mod server; +pub mod entity; + +pub enum CommandEnum { + Route, + List, + ListAll, + Status, + #[cfg(any(unix))] + Stop, +} + +pub fn command(cmd: CommandEnum) { + if let Err(e) = command_(cmd) { + println!("{}:{:?}", style("连接后台服务错误(Connection background service error)").red(), e); + } +} + +fn command_(cmd: CommandEnum) -> io::Result<()> { + match client::CommandClient::new() { + Ok(command_client) => { + match cmd { + CommandEnum::Route => { + let list = command_client.route()?; + console_out::console_route_table(list); + } + CommandEnum::List => { + let list = command_client.list()?; + console_out::console_device_list(list); + } + CommandEnum::ListAll => { + let list = command_client.list()?; + console_out::console_device_list_all(list); + } + CommandEnum::Status => { + let status = command_client.status()?; + console_out::console_status(status); + } + #[cfg(any(unix))] + CommandEnum::Stop => { + command_client.stop()?; + } + } + } + Err(e) => { + log::error!("{:?}",e); + println!( + "{}:{:?}", + style("连接后台服务错误(Connection background service error)").red(), e + ); + } + }; + Ok(()) +} diff --git a/switch-desktop/src/command/server.rs b/switch-desktop/src/command/server.rs index 0be90a0..3791585 100644 --- a/switch-desktop/src/command/server.rs +++ b/switch-desktop/src/command/server.rs @@ -2,10 +2,9 @@ use std::io; use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket}; use std::sync::Arc; -use console::style; +use switch::core::Switch; +use crate::command::entity::{DeviceItem, RouteItem, Status}; -use switch::handle::{PeerDeviceStatus, RouteType}; -use switch::Switch; pub struct CommandServer {} @@ -54,111 +53,137 @@ impl CommandServer { } } +pub fn command_route(switch: &Switch) -> Vec { + let route_table = switch.route_table(); + let mut route_list = Vec::with_capacity(route_table.len()); + for (destination, route) in route_table { + let next_hop = switch.route_key(&route.route_key()).map_or(String::new(), |v| v.to_string()); + let metric = route.metric.to_string(); + let rt = if route.rt < 0 { + "".to_string() + } else { + route.rt.to_string() + }; + let interface = route.addr.to_string(); + let item = RouteItem { + destination: destination.to_string(), + next_hop, + metric, + rt, + interface, + }; + route_list.push(item); + } + route_list +} + +pub fn command_list(switch: &Switch) -> Vec { + let device_list = switch.device_list(); + let mut list = Vec::new(); + for peer in device_list { + let name = peer.name; + let virtual_ip = peer.virtual_ip.to_string(); + let (nat_type, public_ips, local_ip) = if let Some(nat_info) = switch.peer_nat_info(&peer.virtual_ip) { + let nat_type = format!("{:?}", nat_info.nat_type); + let public_ips: Vec = nat_info.public_ips.iter().map(|v| v.to_string()).collect(); + let public_ips = public_ips.join(","); + let local_ip = nat_info.local_ip.to_string(); + (nat_type, public_ips, local_ip) + } else { + ("".to_string(), "".to_string(), "".to_string()) + }; + let (nat_traversal_type, rt) = if let Some(route) = switch.route(&peer.virtual_ip) { + let nat_traversal_type = if route.metric == 1 { "p2p" } else { "relay" }.to_string(); + let rt = if route.rt < 0 { + "".to_string() + } else { + route.rt.to_string() + }; + (nat_traversal_type, rt) + } else { + ("relay".to_string(), "".to_string()) + }; + let status = format!("{:?}", peer.status); + let item = DeviceItem { + name, + virtual_ip, + nat_type, + public_ips, + local_ip, + nat_traversal_type, + rt, + status, + }; + list.push(item); + } + list +} + +pub fn command_status(switch: &Switch) -> Status { + let current_device = switch.current_device(); + let nat_info = switch.nat_info(); + let name = switch.name().to_string(); + let virtual_ip = current_device.virtual_ip().to_string(); + let virtual_gateway = current_device.virtual_gateway().to_string(); + let virtual_netmask = current_device.virtual_netmask.to_string(); + let connect_status = format!("{:?}", switch.connection_status()); + let relay_server = current_device.connect_server.to_string(); + let nat_type = format!("{:?}", nat_info.nat_type); + let public_ips: Vec = nat_info.public_ips.iter().map(|v| v.to_string()).collect(); + let public_ips = public_ips.join(","); + let local_ip = nat_info.local_ip.to_string(); + Status { + name, + virtual_ip, + virtual_gateway, + virtual_netmask, + connect_status, + relay_server, + nat_type, + public_ips, + local_ip, + } +} + fn command(cmd: &str, switch: &Switch) -> io::Result { - let mut out_str = String::new(); - match cmd { - "list" => { - let server_rt = switch.server_rt(); - let device_list = switch.device_list(); - if device_list.is_empty() { - return Ok("No other devices found\n".to_string()); + let out_str = match cmd { + "route" => { + match serde_json::to_string(&command_route(switch)) { + Ok(str) => { + str + } + Err(e) => { + format!("{:?}", e) + } } - for peer_device_info in device_list { - let route = switch.route(&peer_device_info.virtual_ip); - let str = if peer_device_info.status == PeerDeviceStatus::Online { - if route.route_type == RouteType::P2P { - let str = if route.rt >= 0 { - format!( - "[{}] {}(p2p delay:{}ms)\n", - peer_device_info.name, peer_device_info.virtual_ip, route.rt - ) - } else { - format!( - "[{}] {}(p2p)", - peer_device_info.name, peer_device_info.virtual_ip - ) - }; - style(str).green().to_string() - } else { - let str = if server_rt >= 0 { - format!( - "[{}] {}(relay delay:{}ms)\n", - peer_device_info.name, - peer_device_info.virtual_ip, - server_rt * 2 - ) - } else { - format!( - "[{}] {}(relay)\n", - peer_device_info.name, peer_device_info.virtual_ip - ) - }; - style(str).blue().to_string() - } - } else { - let str = format!( - "[{}] {}(Offline)\n", - peer_device_info.name, peer_device_info.virtual_ip - ); - style(str).red().to_string() - }; - out_str.push_str(&str); + } + "list" => { + match serde_json::to_string(&command_list(switch)) { + Ok(str) => { + str + } + Err(e) => { + format!("{:?}", e) + } } } "status" => { - let server_rt = switch.server_rt(); - let current_device = switch.current_device(); - let str = format!("Virtual ip:{}\n", style(current_device.virtual_ip).green()); - out_str.push_str(&str); - let str = format!( - "Virtual gateway:{}\n", - style(current_device.virtual_gateway).green() - ); - out_str.push_str(&str); - let str = format!( - "Connection status :{}\n", - style(format!("{:?}", switch.connection_status())).green() - ); - out_str.push_str(&str); - let str = format!( - "Relay server :{}\n", - style(current_device.connect_server).green() - ); - out_str.push_str(&str); - if server_rt >= 0 { - let str = format!("Delay of relay server :{}ms\n", style(server_rt).green()); - out_str.push_str(&str); - } - if let Some(nat_info) = switch.nat_info() { - let str = format!( - "NAT type :{}", - style(format!("{:?}", nat_info.nat_type)).green() - ); - out_str.push_str(&str); + match serde_json::to_string(&command_status(switch)) { + Ok(str) => { + str + } + Err(e) => { + format!("{:?}", e) + } } } - "help" | "h" => { - let str = format!("Options: \n"); - out_str.push_str(&str); - let str = format!( - "{} , Query the virtual IP of other devices\n", - style("list").green() - ); - out_str.push_str(&str); - let str = format!("{} , View current device status\n", style("status").green()); - out_str.push_str(&str); - let str = format!("{} , Exit the program\n", style("exit").green()); - out_str.push_str(&str); - } - "exit" => { - switch.stop_async(); + "stop" => { + switch.stop()?; + "stopping".to_string() } _ => { - let str = format!("command '{}' not fount. \n", style(cmd).red()); - out_str.push_str(&str); - let str = format!("Try to enter: '{}'\n", style("help").green()); - out_str.push_str(&str); + format!("command '{}' not fount. \n Try to enter: 'help'\n", cmd) } - } + }; Ok(out_str) } diff --git a/switch-desktop/src/config/log_config.rs b/switch-desktop/src/config/log_config.rs new file mode 100644 index 0000000..579e966 --- /dev/null +++ b/switch-desktop/src/config/log_config.rs @@ -0,0 +1,50 @@ +use std::io; +use crate::config::SWITCH_HOME_PATH; +#[cfg(target_os = "windows")] +pub fn log_service_init() -> io::Result<()> { + log_init_("switch-service.log") +} +pub fn log_init() -> io::Result<()> { + log_init_("switch.log") +} +pub fn log_init_(file_name:&str) -> io::Result<()> { + let home = SWITCH_HOME_PATH.lock().clone(); + let home = if let Some(home) = home { + home + } else { + return Err(io::Error::new(io::ErrorKind::Other, "not found")); + }; + if !home.exists() { + std::fs::create_dir(&home)?; + } + let stderr = log4rs::append::console::ConsoleAppender::builder() + .target(log4rs::append::console::Target::Stderr) + .build(); + let logfile = log4rs::append::file::FileAppender::builder() + // Pattern: https://docs.rs/log4rs/*/log4rs/encode/pattern/index.html + .encoder(Box::new(log4rs::encode::pattern::PatternEncoder::new( + "{d(%+)(utc)} [{f}:{L}] {h({l})} {M}:{m}{n}\n", + ))) + .build(home.join(file_name))?; + match log4rs::Config::builder() + .appender(log4rs::config::Appender::builder().build("logfile", Box::new(logfile))) + .appender( + log4rs::config::Appender::builder() + .filter(Box::new(log4rs::filter::threshold::ThresholdFilter::new( + log::LevelFilter::Error, + ))) + .build("stderr", Box::new(stderr)), + ) + .build( + log4rs::config::Root::builder() + .appender("logfile") + .appender("stderr") + .build(log::LevelFilter::Info), + ) { + Ok(config) => { + let _ = log4rs::init_config(config); + } + Err(_) => {} + } + Ok(()) +} \ No newline at end of file diff --git a/switch-desktop/src/config/mod.rs b/switch-desktop/src/config/mod.rs index 9c2e758..17c6271 100644 --- a/switch-desktop/src/config/mod.rs +++ b/switch-desktop/src/config/mod.rs @@ -1,45 +1,199 @@ -use std::fs::File; +use std::fs::{File, OpenOptions}; use std::io; use std::io::{Read, Write}; +use std::net::{SocketAddr, ToSocketAddrs}; use std::path::PathBuf; use lazy_static::lazy_static; use parking_lot::Mutex; use serde::{Deserialize, Serialize}; +use crate::StartArgs; + +pub mod log_config; + +pub struct StartConfig { + pub name: String, + pub token: String, + pub server: SocketAddr, + pub nat_test_server: Vec, + pub device_id: String, +} + +pub fn default_config(start_args: StartArgs) -> Result { + let args_config = read_config(); + if args_config.is_none() && start_args.token.is_none() { + return Err("找不到token(Token not found)".to_string()); + } + let token = start_args.token.unwrap_or_else(|| args_config.as_ref().unwrap().token.clone()).trim().to_string(); + if token.is_empty() { + return Err("token不能为空(Token cannot be empty)".to_string()); + } + if token.len() > 64 { + return Err("token不能超过64字符(Token cannot exceed 64 characters)".to_string()); + } + let name = start_args.name.unwrap_or_else(|| { + if let Some(c) = &args_config { + if !c.name.is_empty() { + return c.name.clone(); + } + } + os_info::get().to_string() + }); + let name = name.trim(); + let name = if name.len() > 64 { + name[..64].to_string() + } else { + name.to_string() + }; + let device_id = start_args.device_id.unwrap_or_else(|| { + if let Some(c) = &args_config { + if !c.device_id.is_empty() { + return c.device_id.clone(); + } + } + if let Ok(Some(mac_address)) = mac_address::get_mac_address() { + mac_address.to_string() + } else { + "".to_string() + } + }); + if device_id.is_empty() || device_id.len() > 64 { + return Err("设备id不能为空并且长度不能大于64字符(The device id cannot be empty and the length cannot be greater than 64 characters)".to_string()); + } + let server = match start_args.server.unwrap_or_else(|| { + if let Some(c) = &args_config { + if !c.server.is_empty() { + return c.server.clone(); + } + } + "nat1.wherewego.top:29871".to_string() + }).to_socket_addrs() { + Ok(mut server) => { + if let Some(addr) = server.next() { + addr + } else { + return Err("中继服务器地址错误( Relay server address error)".to_string()); + } + } + Err(e) => { + return Err(format!("中继服务器地址错误( Relay server address error) :{:?}", e)); + } + }; + let nat_test_server = start_args.nat_test_server.unwrap_or_else(|| { + if let Some(c) = &args_config { + if !c.nat_test_server.is_empty() { + return c.nat_test_server.join(","); + } + } + "nat1.wherewego.top:35061,nat1.wherewego.top:35062,nat2.wherewego.top:35061,nat2.wherewego.top:35062".to_string() + }).split(",").flat_map(|a| a.to_socket_addrs()).flatten() + .collect::>(); + if nat_test_server.is_empty() { + return Err("NAT检测服务地址错误(NAT detection service address error)".to_string()); + } + let base_config = StartConfig { + name, + token, + server, + nat_test_server, + device_id, + }; + Ok(base_config) +} + lazy_static! { static ref CONFIG: Mutex> = Mutex::new(None); - static ref SWITCH_HOME_PATH: Mutex> = Mutex::new(None); + pub static ref SWITCH_HOME_PATH: Mutex> = Mutex::new(None); } #[derive(Clone, Debug, Serialize, Deserialize)] pub struct ArgsConfig { + #[serde(default = "default_version")] + pub version: String, + #[serde(default = "default_str")] pub token: String, - pub name: Option, + #[serde(default = "default_str")] + pub name: String, pub command_port: Option, + #[serde(default = "default_str")] + pub server: String, + #[serde(default = "default_resource_vec")] + pub nat_test_server: Vec, + #[serde(default = "default_str")] + pub device_id: String, + #[serde(default = "default_pid")] + pub pid: u32, +} + +fn default_version() -> String { + "1.0".to_string() +} + +fn default_str() -> String { + "".to_string() +} + +fn default_resource_vec() -> Vec { + vec![] +} + +fn default_pid() -> u32 { + 0 } impl ArgsConfig { - pub fn new(token: String, name: Option) -> Self { + pub fn new(token: String, name: String, server: String, nat_test_server: Vec, device_id: String) -> Self { Self { + version: "1.0".to_string(), token, name, command_port: None, + server, + nat_test_server, + device_id, + pid: 0, } } } +pub fn lock_file() -> io::Result { + let path = SWITCH_HOME_PATH.lock().clone().unwrap().join(".lock"); + Ok(File::create(path)?) +} pub fn save_config(config: ArgsConfig) -> io::Result<()> { - let config_path = dirs::home_dir().unwrap().join(".switch").join("config"); + let config_path = SWITCH_HOME_PATH.lock().clone().unwrap().join("config"); save_config_(config, config_path) } fn save_config_(config: ArgsConfig, config_path: PathBuf) -> io::Result<()> { + let mut config_lock = CONFIG.lock(); + config_lock.take(); let str = serde_yaml::to_string(&config).unwrap(); let mut file = File::create(config_path)?; file.write_all(str.as_bytes()) } +pub fn update_pid(pid: u32) -> io::Result<()> { + let home_lock = SWITCH_HOME_PATH.lock(); + if let Some(home) = home_lock.clone() { + drop(home_lock); + let config_path = home.join("config"); + if let Some(mut config) = read_config() { + config.pid = pid; + return save_config_(config, config_path); + } + } + Err(io::Error::new(io::ErrorKind::Other, "not found")) +} + +#[cfg(any(unix))] +pub fn read_pid() -> io::Result { + let home = SWITCH_HOME_PATH.lock().clone().unwrap(); + let config = read_config_(home)?; + Ok(config.pid) +} + pub fn update_command_port(port: u16) -> io::Result<()> { let home_lock = SWITCH_HOME_PATH.lock(); if let Some(home) = home_lock.clone() { @@ -54,9 +208,13 @@ pub fn update_command_port(port: u16) -> io::Result<()> { } pub fn read_command_port() -> io::Result { - let home = dirs::home_dir().unwrap().join(".switch"); + let home = SWITCH_HOME_PATH.lock().clone().unwrap(); let config = read_config_(home)?; - Ok(config.command_port.unwrap()) + if let Some(p) = config.command_port { + Ok(p) + } else { + Err(io::Error::new(io::ErrorKind::Other, "not fount config")) + } } pub fn read_config() -> Option { @@ -66,13 +224,13 @@ pub fn read_config() -> Option { return c; } if let Some(home) = SWITCH_HOME_PATH.lock().clone() { - match read_config_(home) { + match read_config_(home.to_path_buf()) { Ok(config) => { lock.replace(config.clone()); Some(config) } Err(e) => { - log::error!("{:?}", e); + log::error!("{:?},path:{:?}", e,home); None } } @@ -87,7 +245,11 @@ pub fn set_home(home: PathBuf) { fn read_config_(home: PathBuf) -> io::Result { let config_path = home.join("config"); - let mut file = File::open(config_path)?; + let mut file = if config_path.exists() { + File::open(config_path)? + } else { + OpenOptions::new().read(true).write(true).truncate(false).create(true).open(config_path)? + }; let mut str = String::new(); file.read_to_string(&mut str)?; match serde_yaml::from_str::(&str) { diff --git a/switch-desktop/src/console_out/mod.rs b/switch-desktop/src/console_out/mod.rs new file mode 100644 index 0000000..83f55d6 --- /dev/null +++ b/switch-desktop/src/console_out/mod.rs @@ -0,0 +1,133 @@ +use console::{style, Style}; + +use crate::command::entity::{DeviceItem, RouteItem, Status}; + +pub mod table; + +pub fn console_status(status: Status) { + println!("Name: {}", style(status.name).green()); + println!("Virtual ip: {}", style(status.virtual_ip).green()); + println!("Virtual gateway: {}", style(status.virtual_gateway).green()); + println!("Virtual netmask: {}", style(status.virtual_netmask).green()); + println!("Connection status: {}", style(status.connect_status).green()); + println!("NAT type: {}", style(status.nat_type).green()); + println!("Relay server: {}", style(status.relay_server).green()); + println!("Public ips: {}", style(status.public_ips).green()); + println!("Local ip: {}", style(status.local_ip).green()); +} + +pub fn console_route_table(mut list: Vec) { + if list.is_empty() { + println!("No route found"); + return; + } + list.sort_by(|t1, t2| t1.destination.cmp(&t2.destination)); + let mut out_list = Vec::with_capacity(list.len()); + + out_list.push(vec![("Destination".to_string(), Style::new()), + ("Next Hop".to_string(), Style::new()), + ("Metric".to_string(), Style::new()), + ("Rt".to_string(), Style::new()), + ("Interface".to_string(), Style::new()), ]); + for item in list { + out_list.push(vec![(item.destination, Style::new().green()), + (item.next_hop, Style::new().green()), + (item.metric, Style::new().green()), + (item.rt, Style::new().green()), + (item.interface, Style::new().green())]); + } + + table::println_table(out_list) +} + +pub fn console_device_list(mut list: Vec) { + if list.is_empty() { + println!("No other devices found"); + return; + } + list.sort_by(|t1, t2| t1.virtual_ip.cmp(&t2.virtual_ip)); + list.sort_by(|t1, t2| t1.status.cmp(&t2.status)); + let mut out_list = Vec::with_capacity(list.len()); + //表头 + out_list.push(vec![("Name".to_string(), Style::new()), + ("Virtual Ip".to_string(), Style::new()), + ("Status".to_string(), Style::new()), + ("P2P/Relay".to_string(), Style::new()), + ("Rt".to_string(), Style::new())]); + for item in list { + if &item.status == "Online" { + if &item.nat_traversal_type == "p2p" { + out_list.push(vec![(item.name, Style::new().green()), + (item.virtual_ip, Style::new().green()), + (item.status, Style::new().green()), + (item.nat_traversal_type, Style::new().green()), + (item.rt, Style::new().green())]); + } else { + out_list.push(vec![(item.name, Style::new().yellow()), + (item.virtual_ip, Style::new().yellow()), + (item.status, Style::new().yellow()), + (item.nat_traversal_type, Style::new().yellow()), + (item.rt, Style::new().yellow())]); + } + } else { + out_list.push(vec![(item.name, Style::new().color256(102)), + (item.virtual_ip, Style::new().color256(102)), + (item.status, Style::new().color256(102)), + ("".to_string(), Style::new().color256(102)), + ("".to_string(), Style::new().color256(102))]); + } + } + table::println_table(out_list) +} + +pub fn console_device_list_all(mut list: Vec) { + if list.is_empty() { + println!("No other devices found"); + return; + } + list.sort_by(|t1, t2| t1.virtual_ip.cmp(&t2.virtual_ip)); + list.sort_by(|t1, t2| t1.status.cmp(&t2.status)); + let mut out_list = Vec::with_capacity(list.len()); + //表头 + out_list.push(vec![("Name".to_string(), Style::new()), + ("Virtual Ip".to_string(), Style::new()), + ("Status".to_string(), Style::new()), + ("NAT Type".to_string(), Style::new()), + ("Public Ips".to_string(), Style::new()), + ("Local Ip".to_string(), Style::new()), + ("P2P/Relay".to_string(), Style::new()), + ("Rt".to_string(), Style::new())]); + for item in list { + if &item.status == "Online" { + if &item.nat_traversal_type == "p2p" { + out_list.push(vec![(item.name, Style::new().green()), + (item.virtual_ip, Style::new().green()), + (item.status, Style::new().green()), + (item.nat_traversal_type, Style::new().green()), + (item.rt, Style::new().green()), + (item.nat_type, Style::new().green()), + (item.public_ips, Style::new().green()), + (item.local_ip, Style::new().green())]); + } else { + out_list.push(vec![(item.name, Style::new().yellow()), + (item.virtual_ip, Style::new().yellow()), + (item.status, Style::new().yellow()), + (item.nat_traversal_type, Style::new().yellow()), + (item.rt, Style::new().yellow()), + (item.nat_type, Style::new().yellow()), + (item.public_ips, Style::new().yellow()), + (item.local_ip, Style::new().yellow()), ]); + } + } else { + out_list.push(vec![(item.name, Style::new().color256(102)), + (item.virtual_ip, Style::new().color256(102)), + (item.status, Style::new().color256(102)), + ("".to_string(), Style::new().color256(102)), + ("".to_string(), Style::new().color256(102)), + ("".to_string(), Style::new().color256(102)), + ("".to_string(), Style::new().color256(102)), + ("".to_string(), Style::new().color256(102)), ]); + } + } + table::println_table(out_list) +} \ No newline at end of file diff --git a/switch-desktop/src/console_out/table.rs b/switch-desktop/src/console_out/table.rs new file mode 100644 index 0000000..c117b95 --- /dev/null +++ b/switch-desktop/src/console_out/table.rs @@ -0,0 +1,23 @@ +use console::Style; + +pub fn println_table(table: Vec>) { + if table.is_empty() { + return; + } + let mut width_list = vec![0; table[0].len()]; + for in_list in table.iter() { + for (index, (item, _)) in in_list.iter().enumerate() { + let width = console::measure_text_width(item) + 6; + if width_list[index] < width { + width_list[index] = width; + } + } + } + for in_list in table { + for (col, (item, style)) in in_list.iter().enumerate() { + let str = format!("{:1$}", item, width_list[col]); + print!("{}", style.apply_to(str)); + } + println!() + } +} \ No newline at end of file diff --git a/switch-desktop/src/main.rs b/switch-desktop/src/main.rs index b4b6d82..3b66ab5 100644 --- a/switch-desktop/src/main.rs +++ b/switch-desktop/src/main.rs @@ -1,197 +1,169 @@ -use std::io; -use std::net::ToSocketAddrs; -use std::path::PathBuf; - -use clap::Parser; +use clap::{Parser, Subcommand}; use console::style; -use switch::handle::{PeerDeviceStatus, RouteType}; -use switch::*; +use switch::core::Switch; + +use crate::config::log_config::log_init; -#[cfg(windows)] mod command; -#[cfg(windows)] mod config; -#[cfg(windows)] +#[cfg(target_os = "windows")] mod windows; +#[cfg(any(unix))] +mod unix; +mod console_out; + #[derive(Parser, Debug)] #[command( - author = "Lu Beilin", - version, - about = "一个虚拟网络工具,启动后会获取一个ip,相同token下的设备之间可以用ip直接通信" +author = "Lu Beilin", +version, +about = "一个虚拟网络工具,启动后会获取一个ip,相同token下的设备之间可以用ip直接通信" )] -struct Args { - /// 32位字符 +pub struct BaseArgs { + #[clap(subcommand)] + command: Commands, + +} + +#[derive(Subcommand, Debug)] +enum Commands { + /// 启动 + Start(StartArgs), + /// 停止后台服务 + Stop, + /// 安装服务 + /// Install service + #[cfg(target_os = "windows")] + Install(InstallArgs), + /// 卸载服务 + /// Uninstall service + #[cfg(target_os = "windows")] + Uninstall, + /// 配置 + #[cfg(target_os = "windows")] + Config(ConfigArgs), + /// 查看路由 + /// View route + Route, + /// 查看设备列表 + /// View device list + List { + /// 查看所有 + #[arg(short, long)] + all: bool + }, + /// 查看设备当前状态 + /// View the current status of the device + Status, +} + +#[derive(Parser, Debug)] +pub struct StartArgs { + /// 不超过64个字符 /// 相同token的设备之间才能通信。 /// 建议使用uuid保证唯一性。 - /// 32-bit characters. + /// No more than 64 characters /// Only devices with the same token can communicate with each other. /// It is recommended to use uuid to ensure uniqueness #[arg(long)] - token: String, + token: Option, /// 给设备一个名称，为空时默认用系统版本信息 /// Give the device a name. If it is blank, the system version information will be used by default - #[arg(long)] + #[arg(long, action)] name: Option, + /// 设备唯一标识，为空时默认使用MAC地址，不超过64个字符 + /// Unique identification of the device. If it is blank, the MAC address is used by default. No more than 64 characters + #[arg(long)] + device_id: Option, + /// 注册和中继服务器地址 + /// Register and relay server address + #[arg(long)] + server: Option, + /// NAT检测服务地址，使用逗号分隔 + /// NAT detection service address. Use comma to separate + #[arg(long)] + nat_test_server: Option, + /// 关闭命令服务，关闭后不能在其他进程直接使用route、list等命令查看信息 + /// Turn off the command service. After turning off, you cannot directly use the route, list and other commands to view information in other processes + #[cfg(any(unix))] + #[arg(long)] + off_command_server: bool, + /// 记录日志，输出在 home/.switch 目录下，长时间使用时不建议开启 + /// Output the log in the "home/.switch" directory + #[arg(long)] + log: bool, } -#[cfg(windows)] -fn log_init_service(home: PathBuf) -> io::Result<()> { - if !home.exists() { - std::fs::create_dir(&home)?; - } - let logfile = log4rs::append::file::FileAppender::builder() - // Pattern: https://docs.rs/log4rs/*/log4rs/encode/pattern/index.html - .encoder(Box::new(log4rs::encode::pattern::PatternEncoder::new( - "{d(%+)(utc)} [{f}:{L}] {h({l})} {M}:{m}{n}\n", - ))) - .build(home.join("switch-service.log"))?; - match log4rs::Config::builder() - .appender(log4rs::config::Appender::builder().build("logfile", Box::new(logfile))) - .build( - log4rs::config::Root::builder() - .appender("logfile") - .build(log::LevelFilter::Info), - ) { - Ok(config) => { - let _ = log4rs::init_config(config); - } - Err(_) => {} - } - Ok(()) +#[cfg(target_os = "windows")] +#[derive(Parser, Debug)] +pub struct InstallArgs { + /// 安装路径 + /// Service installation path + #[arg(long)] + path: String, + /// 服务开机自启动 + /// Autostart on system startup + #[arg(long)] + auto: bool, } -fn log_init() -> io::Result<()> { - let home = dirs::home_dir().unwrap().join(".switch"); - if !home.exists() { - std::fs::create_dir(&home)?; - } - let stderr = log4rs::append::console::ConsoleAppender::builder() - .target(log4rs::append::console::Target::Stderr) - .build(); - let logfile = log4rs::append::file::FileAppender::builder() - // Pattern: https://docs.rs/log4rs/*/log4rs/encode/pattern/index.html - .encoder(Box::new(log4rs::encode::pattern::PatternEncoder::new( - "{d(%+)(utc)} [{f}:{L}] {h({l})} {M}:{m}{n}\n", - ))) - .build(home.join("switch.log"))?; - match log4rs::Config::builder() - .appender(log4rs::config::Appender::builder().build("logfile", Box::new(logfile))) - .appender( - log4rs::config::Appender::builder() - .filter(Box::new(log4rs::filter::threshold::ThresholdFilter::new( - log::LevelFilter::Error, - ))) - .build("stderr", Box::new(stderr)), - ) - .build( - log4rs::config::Root::builder() - .appender("logfile") - .appender("stderr") - .build(log::LevelFilter::Info), - ) { - Ok(config) => { - let _ = log4rs::init_config(config); - } - Err(_) => {} - } - Ok(()) +#[cfg(target_os = "windows")] +#[derive(Parser, Debug)] +pub struct ConfigArgs { + /// 服务开机自启动 + /// Autostart on system startup + #[arg(long)] + auto: bool, } + #[cfg(windows)] fn main() { let args: Vec<_> = std::env::args().collect(); if args.len() == 3 && args[1] == windows::SERVICE_FLAG { //以服务的方式启动 - let _ = log_init_service(PathBuf::from(&args[2])); - config::set_home(PathBuf::from(&args[2])); - log::info!("config {:?}", PathBuf::from(&args[2])); - log::info!("config {:?}", config::read_config()); + config::set_home(std::path::PathBuf::from(&args[2])); windows::service::start(); return; } else { - let _ = log_init(); - windows::main0(); + let home = dirs::home_dir().unwrap().join(".switch"); + config::set_home(home); + let args = BaseArgs::parse(); + if let Commands::Start(start_args) = &args.command { + if start_args.log { + let _ = log_init(); + } + } + windows::main0(args); } - // println!("{}", style("starting...").green()); } #[cfg(any(target_os = "linux", target_os = "macos"))] fn main() { - let _ = log_init(); - let args = Args::parse(); - if sudo::RunningAs::Root != sudo::check() { - println!( - "{}", - style("需要使用root权限执行(Need to execute with root permission)...").red() - ); - sudo::escalate_if_needed().unwrap(); + let home = dirs::home_dir().unwrap().join(".switch"); + config::set_home(home); + let args = BaseArgs::parse(); + if let Commands::Start(start_args) = &args.command { + if start_args.log { + let _ = log_init(); + } } - println!("{}", style("starting...").green()); - start(args.token, args.name); + unix::main0(args); } -pub fn start(token: String, name: Option) { - let mac_address = mac_address::get_mac_address().unwrap().unwrap().to_string(); - let server_address = "nat1.wherewego.top:29875" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(); - let nat_test_server = vec![ - "nat1.wherewego.top:35061" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - "nat1.wherewego.top:35062" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - "nat2.wherewego.top:35061" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - "nat2.wherewego.top:35062" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - ]; - let switch = match Config::new( - token, - mac_address, - name, - server_address, - nat_test_server, - || {}, - ) { - Ok(config) => match Switch::start(config) { - Ok(switch) => switch, - Err(e) => { - log::error!("{:?}", e); - return; - } - }, - Err(e) => { - log::error!("{:?}", e); - return; - } - }; +pub fn console_listen(switch: &Switch) { use console::Term; let term = Term::stdout(); println!("{}", style("started").green()); let current_device = switch.current_device(); println!( "当前虚拟ip(virtual ip): {:?}", - style(current_device.virtual_ip).green() + style(current_device.virtual_ip()).green() ); println!( "虚拟网关(virtual gateway): {:?}", - style(current_device.virtual_gateway).green() + style(current_device.virtual_gateway()).green() ); loop { println!( @@ -200,99 +172,46 @@ pub fn start(token: String, name: Option) { ); match term.read_line() { Ok(cmd) => { + if cmd.is_empty() { + log::warn!("非正常返回"); + return; + } if command(cmd.trim(), &switch).is_err() { println!("{}", style("stopping").red()); - switch.stop(); + if let Err(e) = switch.stop() { + println!("stop:{:?}", e); + } break; } } Err(e) => { - println!("read_line:{:?}", e); + log::error!("read_line:{:?}", e); println!("{}", style("stopping...").red()); - switch.stop(); + if let Err(e) = switch.stop() { + log::error!("stop:{:?}", e); + } + std::thread::sleep(std::time::Duration::from_secs(1)); break; } } } println!("{}", style("stopped").red()); - std::process::exit(1); } + fn command(cmd: &str, switch: &Switch) -> Result<(), ()> { match cmd { + "route" => { + let list = command::server::command_route(switch); + console_out::console_route_table(list); + } "list" => { - let server_rt = switch.server_rt(); - let device_list = switch.device_list(); - if device_list.is_empty() { - println!("No other devices found"); - return Ok(()); - } - for peer_device_info in device_list { - let route = switch.route(&peer_device_info.virtual_ip); - if peer_device_info.status == PeerDeviceStatus::Online { - if route.route_type == RouteType::P2P { - let str = if route.rt >= 0 { - format!( - "[{}] {}(p2p delay:{}ms)", - peer_device_info.name, peer_device_info.virtual_ip, route.rt - ) - } else { - format!( - "[{}] {}(p2p)", - peer_device_info.name, peer_device_info.virtual_ip - ) - }; - println!("{}", style(str).green()); - } else { - let str = if server_rt >= 0 { - format!( - "[{}] {}(relay delay:{}ms)", - peer_device_info.name, - peer_device_info.virtual_ip, - server_rt * 2 - ) - } else { - format!( - "[{}] {}(relay)", - peer_device_info.name, peer_device_info.virtual_ip - ) - }; - println!("{}", style(str).blue()); - } - } else { - let str = format!( - "[{}] {}(Offline)", - peer_device_info.name, peer_device_info.virtual_ip - ); - println!("{}", style(str).red()); - } - } + let list = command::server::command_list(switch); + console_out::console_device_list(list); } "status" => { - let server_rt = switch.server_rt(); - let current_device = switch.current_device(); - println!("Virtual ip:{}", style(current_device.virtual_ip).green()); - println!( - "Virtual gateway:{}", - style(current_device.virtual_gateway).green() - ); - println!( - "Connection status :{}", - style(format!("{:?}", switch.connection_status())).green() - ); - println!( - "Relay server :{}", - style(current_device.connect_server).green() - ); - if server_rt >= 0 { - println!("Delay of relay server :{}ms", style(server_rt).green()); - } - if let Some(nat_info) = switch.nat_info() { - println!( - "NAT type :{}", - style(format!("{:?}", nat_info.nat_type)).green() - ); - } + let status = command::server::command_status(switch); + console_out::console_status(status); } "help" | "h" => { println!("Options: "); diff --git a/switch-desktop/src/unix/mod.rs b/switch-desktop/src/unix/mod.rs new file mode 100644 index 0000000..f94a764 --- /dev/null +++ b/switch-desktop/src/unix/mod.rs @@ -0,0 +1,137 @@ +use std::sync::Arc; + +use console::style; +use fs2::FileExt; + +use switch::core::{Config, Switch}; + +use crate::{BaseArgs, Commands, config}; +use crate::command::{command, CommandEnum}; + + +pub fn main0(base_args: BaseArgs) { + match base_args.command { + Commands::Start(args) => { + let off_command_server = args.off_command_server; + match config::default_config(args) { + Ok(start_config) => { + if sudo::RunningAs::Root != sudo::check() { + println!( + "{}", + style("需要使用root权限执行(Need to execute with root permission)...").red() + ); + sudo::escalate_if_needed().unwrap(); + } + + let config = Config::new( + start_config.token.clone(), + start_config.device_id.clone(), + start_config.name.clone(), + start_config.server, + start_config.nat_test_server.clone(), + ); + let nat_test_server = start_config.nat_test_server.iter().map(|v| v.to_string()).collect::>(); + let args_config = config::ArgsConfig::new( + start_config.token.clone(), + start_config.name.clone(), + start_config.server.to_string(), + nat_test_server, + start_config.device_id.clone(), + ); + let lock = match config::lock_file() { + Ok(lock) => { + lock + } + Err(e) => { + log::error!("{:?}",e); + return; + } + }; + if lock.try_lock_exclusive().is_err() { + println!("{}", style("文件被重复打开").red()); + return; + } + if let Err(e) = config::save_config(args_config) { + log::error!("{:?}",e); + lock.unlock().unwrap(); + return; + } + let switch = match Switch::start(config) { + Ok(switch) => { + switch + } + Err(e) => { + log::error!("{:?}", e); + lock.unlock().unwrap(); + return; + } + }; + let switch = Arc::new(switch); + let command_server = crate::command::server::CommandServer::new(); + if off_command_server { + crate::console_listen(&switch); + log::info!("前台任务结束"); + } else { + if let Err(e) = config::update_pid(std::process::id()) { + log::error!("{:?}", e); + } + let switch1 = switch.clone(); + let handle = std::thread::spawn(move || { + if let Err(e) = command_server.start(switch1) { + log::error!("{:?}", e); + } + }); + crate::console_listen(&switch); + if let Err(e) = handle.join() { + log::error!("后台任务异常{:?}",e); + } else { + log::info!("后台任务结束"); + } + } + lock.unlock().unwrap(); + } + Err(e) => { + log::error!("{:?}", e); + } + } + } + Commands::Stop => { + if sudo::RunningAs::Root != sudo::check() { + println!( + "{}", + style("需要使用root权限执行(Need to execute with root permission)...").red() + ); + sudo::escalate_if_needed().unwrap(); + } + command(CommandEnum::Stop); + if let Ok(pid) = config::read_pid() { + if pid != 0 { + let kill_cmd = format!("kill {}", pid); + let kill_out = std::process::Command::new("sh") + .arg("-c") + .arg(&kill_cmd) + .output() + .expect("sh exec error!"); + if !kill_out.status.success() { + println!("cmd:{:?},err:{:?}", kill_cmd, kill_out); + return; + } + } + } + println!("stopped") + } + Commands::Route => { + command(CommandEnum::Route); + } + Commands::List { all } => { + if all { + command(CommandEnum::ListAll); + } else { + command(CommandEnum::List); + } + } + Commands::Status => { + command(CommandEnum::Status); + } + } +} \ No newline at end of file diff --git a/switch-desktop/src/windows/mod.rs b/switch-desktop/src/windows/mod.rs index 910de42..4683816 100644 --- a/switch-desktop/src/windows/mod.rs +++ b/switch-desktop/src/windows/mod.rs @@ -1,184 +1,230 @@ +use std::{io, thread}; use std::ffi::OsString; +use std::net::UdpSocket; use std::path::PathBuf; use std::time::Duration; -use std::{io, thread}; -use clap::Parser; use console::style; - +use fs2::FileExt; +use windows_service::Error; use windows_service::service::{ ServiceAccess, ServiceErrorControl, ServiceInfo, ServiceStartType, ServiceState, ServiceType, }; use windows_service::service_manager::{ServiceManager, ServiceManagerAccess}; -use windows_service::Error; -use crate::config; +use switch::core::{Config, Switch}; + +use crate::{BaseArgs, Commands, config}; +use crate::command::{command, CommandEnum}; pub mod service; mod windows_admin_check; -#[derive(Parser, Debug)] -#[command( - author = "Lu Beilin", - version, - about = "一个虚拟网络工具,启动后会获取一个ip,相同token下的设备之间可以用ip直接通信" -)] -struct Args { - /// 32位字符 - /// 相同token的设备之间才能通信。 - /// 建议使用uuid保证唯一性。 - /// 32-bit characters. - /// Only devices with the same token can communicate with each other. - /// It is recommended to use uuid to ensure uniqueness - #[arg(long)] - token: Option, - /// 给设备一个名称，为空时默认用系统版本信息 - /// Give the device a name. If it is blank, the system version information will be used by default - #[arg(long)] - name: Option, - /// 安装服务，安装后可以后台运行，需要指定安装路径 - /// The installation service can run in the background after installation, and the installation path needs to be specified - #[arg(long)] - install: Option, - /// 卸载服务 - /// Uninstall service - #[arg(long)] - uninstall: bool, - /// 启动，启动时可以附加参数 --token，如果没有token，则会读取配置文件中上一次使用的token - /// 安装服务后，会以服务的方式在后台启动，此时可以关闭命令行窗口 - /// When starting, you can attach the parameter -- token. If there is no token, the last token used in the configuration file will be read. After installing the service, it will be started in the background as a service. At this time, you can close the command line window - #[arg(long)] - start: bool, - #[arg(long)] - /// 停止，安装服务后，使用 --stop停止服务 - /// Stop. After installing the service, use -- stop to stop the service - stop: bool, - /// 启动服务后，使用 --list 查看设备列表 - /// After starting the service, use -- list to view the device list - #[arg(long)] - list: bool, - /// 启动服务后，使用 --status 查看设备状态 - /// After starting the service, use -- status to view the device status - #[arg(long)] - status: bool, -} - -pub const SERVICE_FLAG: &'static str = "start_switch_service_"; -pub const SERVICE_NAME: &'static str = "switch-service"; +pub const SERVICE_FLAG: &'static str = "start_switch_service_v1_"; +pub const SERVICE_NAME: &'static str = "switch-service-v1"; pub const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS; -pub fn main0() { - let args = Args::parse(); - if args.list || args.status { - match service_state() { - Ok(state) => { - if state == ServiceState::Running { - let command_client = crate::command::client::CommandClient::new().unwrap(); - let out = if args.list { - command_client.list().unwrap() - } else if args.status { - command_client.status().unwrap() - } else { - "".to_string() - }; - println!("{}", out); - } else { - println!("服务未启动") - } - } - Err(e) => { - println!("{:?}", e); - } - } - return; - } +fn admin_check() -> bool { if !windows_admin_check::is_app_elevated() { println!( "{}", style("请使用管理员权限运行(Please run with administrator privileges)").red() ); - return; + true + } else { + false } - if let Some(path) = args.install { - let path: PathBuf = path.into(); - if !path.exists() { - std::fs::create_dir_all(&path).unwrap(); - } - if !path.is_dir() { - println!("参数必须为文件目录(Parameter must be a file directory)"); - } else { - if let Err(e) = install(path) { - log::error!("{:?}", e); +} + +fn not_started() -> bool { + match service_state() { + Ok(state) => { + if state == ServiceState::Running { + return false; } else { - println!("{}", style("安装成功(Installation succeeded)").green()) + println!("服务未启动") } } - } else if args.uninstall { - if let Err(e) = uninstall() { - log::error!("{:?}", e); - } else { - println!("{}", style("卸载成功(Uninstall succeeded)").green()) + Err(e) => { + println!("{:?}", e); } - } else if args.start { - if args.token.is_none() { - println!("{}", style("需要参数(require parameters) --token").red()); - } else { - let token = args.token.clone().unwrap(); - match service_state() { - Ok(state) => { - if state == ServiceState::Stopped { - config::save_config(config::ArgsConfig::new( - token.clone(), - args.name.clone(), - )) - .unwrap(); - match start() { - Ok(_) => { - //需要检查启动状态 - println!("{}", style("启动成功(Start successfully)").green()) - } - Err(e) => { - log::error!("{:?}", e); + } + return true; +} + +pub fn main0(base_args: BaseArgs) { + match base_args.command { + Commands::Start(args) => { + if admin_check() { + return; + } + { + // 允许应用通过防火墙 + let _udp = UdpSocket::bind("0.0.0.0:0").unwrap(); + } + let out_log = args.log; + match config::default_config(args) { + Ok(start_config) => { + match service_state() { + Ok(state) => { + if state == ServiceState::Stopped { + if let Err(e) = config::save_config(config::ArgsConfig::new( + start_config.token.clone(), + start_config.name.clone(), + start_config.server.to_string(), + start_config.nat_test_server.iter().map(|v| v.to_string()).collect::>(), + start_config.device_id.clone(), + )) { + log::error!("{:?}",e); + return; + } + match start(out_log) { + Ok(_) => { + //需要检查启动状态 + thread::sleep(Duration::from_secs(2)); + println!("{}", style("启动成功(Start successfully)").green()) + } + Err(e) => { + log::error!("{:?}", e); + } + } + } else { + println!("服务未停止(Service not stopped)"); } } - } else { - println!("服务未停止(Service not stopped)"); + Err(e) => { + match e { + Error::Winapi(ref e) => { + if let Some(code) = e.raw_os_error() { + if code == 1060 { + //指定的服务未安装。 + println!( + "{}", + style("服务未安装，在当前进程启动(The service is not installed and started in the current process)").red() + ); + let config = Config::new( + start_config.token, + start_config.device_id, + start_config.name, + start_config.server, + start_config.nat_test_server, + ); + let lock = match config::lock_file() { + Ok(lock) => { + lock + } + Err(e) => { + log::error!("{:?}",e); + return; + } + }; + if lock.try_lock_exclusive().is_err() { + println!("{}", style("文件被重复打开").red()); + return; + } + match Switch::start(config) { + Ok(switch) => { + crate::console_listen(&switch); + } + Err(e) => { + log::error!("{:?}", e); + } + } + lock.unlock().unwrap(); + return; + } + } + } + _ => {} + } + println!("{:?}", e); + } } } Err(e) => { - match e { - Error::Winapi(ref e) => { - if let Some(code) = e.raw_os_error() { - if code == 1060 { - //指定的服务未安装。 - println!( - "{}", - style("服务未安装，在当前进程启动(The service is not installed and started in the current process)").red() - ); - crate::start(token, args.name); - return; - } - } - } - _ => {} - } - println!("{:?}", e); + println!("{}", style(e).red()); + } + }; + pause(); + } + Commands::Stop => { + if not_started() { + return; + } + if admin_check() { + return; + } + match stop() { + Ok(_) => { + println!("{}", style("停止成功(Stopped successfully)").green()) + } + Err(e) => { + log::error!("{:?}", e); } } + pause(); } - } else if args.stop { - match stop() { - Ok(_) => { - println!("{}", style("停止成功(Stopped successfully)").green()) + Commands::Install(args) => { + if admin_check() { + return; } - Err(e) => { + let path: PathBuf = args.path.into(); + if !path.exists() { + std::fs::create_dir_all(&path).unwrap(); + } + if !path.is_dir() { + println!("参数必须为文件目录(Parameter must be a file directory)"); + } else { + if let Err(e) = install(path, args.auto) { + log::error!("{:?}", e); + } else { + println!("{}", style("安装成功(Installation succeeded)").green()) + } + } + pause(); + } + Commands::Uninstall => { + if admin_check() { + return; + } + if let Err(e) = uninstall() { log::error!("{:?}", e); + } else { + println!("{}", style("卸载成功(Uninstall succeeded)").green()) + } + pause(); + } + Commands::Config(args) => { + if let Err(e) = change(args.auto) { + log::error!("{:?}", e); + } else { + println!("{}", style("配置成功(Config succeeded)").green()) + } + pause(); + } + Commands::Route => { + if not_started() { + return; + } + command(CommandEnum::Route); + } + Commands::List { all } => { + if not_started() { + return; + } + if all { + command(CommandEnum::ListAll); + } else { + command(CommandEnum::List); } } - } else { - println!("使用参数 -h 查看帮助(Use the parameter - h to view help)") + Commands::Status => { + if not_started() { + return; + } + command(CommandEnum::Status); + } } - pause(); } fn pause() { @@ -191,11 +237,11 @@ fn pause() { let _ = term.read_char().unwrap(); } -fn install(path: PathBuf) -> Result<(), Error> { +fn install(path: PathBuf, auto: bool) -> Result<(), Error> { let manager_access = ServiceManagerAccess::CONNECT | ServiceManagerAccess::CREATE_SERVICE; let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?; let current_exe_path = std::env::current_exe().unwrap(); - let service_path = path.join("switch-service.exe"); + let service_path = path.join("switch-service-v1.exe"); std::fs::copy(current_exe_path, service_path.as_path()).unwrap(); if let Err(e) = std::fs::copy("wintun.dll", path.join("wintun.dll").as_path()) { if e.kind() == io::ErrorKind::NotFound { @@ -210,11 +256,16 @@ fn install(path: PathBuf) -> Result<(), Error> { launch_arguments.push(OsString::from( dirs::home_dir().unwrap().join(".switch").to_str().unwrap(), )); + let start_type = if auto { + ServiceStartType::AutoStart + } else { + ServiceStartType::OnDemand + }; let service_info = ServiceInfo { name: OsString::from(SERVICE_NAME), - display_name: OsString::from("switch service"), - service_type: ServiceType::OWN_PROCESS, - start_type: ServiceStartType::OnDemand, + display_name: OsString::from("switch service v1"), + service_type: SERVICE_TYPE, + start_type, error_control: ServiceErrorControl::Normal, executable_path: service_path.into(), launch_arguments, @@ -227,6 +278,39 @@ fn install(path: PathBuf) -> Result<(), Error> { Ok(()) } +fn change(auto: bool) -> Result<(), Error> { + let manager_access = ServiceManagerAccess::CONNECT; + let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?; + + let service_access = ServiceAccess::QUERY_CONFIG | ServiceAccess::CHANGE_CONFIG; + let service = service_manager.open_service(SERVICE_NAME, service_access)?; + let config = service.query_config()?; + let start_type = if auto { + ServiceStartType::AutoStart + } else { + ServiceStartType::OnDemand + }; + let mut launch_arguments = Vec::new(); + launch_arguments.push(OsString::from(SERVICE_FLAG)); + launch_arguments.push(OsString::from( + dirs::home_dir().unwrap().join(".switch").to_str().unwrap(), + )); + let service_info = ServiceInfo { + name: OsString::from(SERVICE_NAME), + display_name: config.display_name, + service_type: SERVICE_TYPE, + start_type, + error_control: config.error_control, + executable_path: config.executable_path, + launch_arguments, + dependencies: config.dependencies, + account_name: None, // run as System + account_password: None, + }; + service.change_config(&service_info)?; + Ok(()) +} + fn uninstall() -> Result<(), Error> { let manager_access = ServiceManagerAccess::CONNECT; let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?; @@ -240,16 +324,19 @@ fn uninstall() -> Result<(), Error> { // Wait for service to stop thread::sleep(Duration::from_secs(1)); } - service.delete()?; Ok(()) } -fn start() -> Result<(), Error> { +fn start(out_log: bool) -> Result<(), Error> { let manager_access = ServiceManagerAccess::CONNECT; let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?; let service = service_manager.open_service(SERVICE_NAME, ServiceAccess::START)?; - service.start(&[""]) + if out_log { + service.start(&["log"]) + } else { + service.start(&[""]) + } } fn service_state() -> Result { diff --git a/switch-desktop/src/windows/service.rs b/switch-desktop/src/windows/service.rs index fa6d54c..40dc4fc 100644 --- a/switch-desktop/src/windows/service.rs +++ b/switch-desktop/src/windows/service.rs @@ -2,25 +2,36 @@ // extern crate windows_service; use std::ffi::OsString; +use std::net::ToSocketAddrs; use std::sync::Arc; use std::thread; use std::time::Duration; -use std::net::ToSocketAddrs; -use switch::{Config, Switch}; + +use windows_service::{define_windows_service, service_control_handler, service_dispatcher}; use windows_service::service::{ ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus, }; use windows_service::service_control_handler::ServiceControlHandlerResult; -use windows_service::{define_windows_service, service_control_handler, service_dispatcher}; +use switch::core::{Config, Switch}; + +use crate::config; use crate::windows::config::read_config; +use crate::windows::SERVICE_NAME; define_windows_service!(ffi_service_main, switch_service_main); -pub fn switch_service_main(_arguments: Vec) { +pub fn switch_service_main(arguments: Vec) { + if !arguments.is_empty() { + if let Some(str) = arguments[0].to_str() { + if str == "log" { + let _ = config::log_config::log_service_init(); + } + } + } thread::spawn(|| match service_main() { Ok(_) => {} Err(e) => { - log::warn!("{:?}", e); + log::error!("{:?}", e); } }); } @@ -36,8 +47,8 @@ fn service_main() -> windows_service::Result<()> { // Handle stop ServiceControl::Stop => { - log::info!("handler 服务停止"); un_parker.unpark(); + log::info!("handler 服务停止"); ServiceControlHandlerResult::NoError } _ => ServiceControlHandlerResult::NotImplemented, @@ -47,7 +58,7 @@ fn service_main() -> windows_service::Result<()> { // Register system service event handler. // The returned status handle should be used to report service status changes to the system. let status_handle = - service_control_handler::register(crate::windows::SERVICE_NAME, event_handler)?; + service_control_handler::register(SERVICE_NAME, event_handler)?; // Tell the system that service is running status_handle.set_service_status(ServiceStatus { @@ -59,72 +70,16 @@ fn service_main() -> windows_service::Result<()> { wait_hint: Duration::default(), process_id: None, })?; - if let Some(config) = read_config() { - let mac_address = mac_address::get_mac_address().unwrap().unwrap().to_string(); - let un_parker = parker.unparker().clone(); - let server_address = "nat1.wherewego.top:29875" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(); - let nat_test_server = vec![ - "nat1.wherewego.top:35061" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - "nat1.wherewego.top:35062" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - "nat2.wherewego.top:35061" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - "nat2.wherewego.top:35062" - .to_socket_addrs() - .unwrap() - .next() - .unwrap(), - ]; - match Config::new( - config.token, - mac_address, - config.name, - server_address, - nat_test_server, - move || { - un_parker.unpark(); - }, - ) { - Ok(config) => match Switch::start(config) { - Ok(switch) => { - log::info!("switch-service服务启动"); - let switch = Arc::new(switch); - let command_server = crate::command::server::CommandServer::new(); - let switch1 = switch.clone(); - thread::spawn(move || { - if let Err(e) = command_server.start(switch1) { - log::warn!("{:?}", e); - } - }); - parker.park(); - switch.stop_async(); - thread::sleep(Duration::from_secs(1)); - log::info!("switch-service服务停止"); - } - Err(e) => { - log::error!("{:?}", e); - } - }, - Err(e) => { - log::error!("{:?}", e); + match start_switch() { + Ok(switch) => { + parker.park(); + if let Err(e) = switch.stop() { + log::warn!("switch stop:{:?}",e) } - }; - } else { - log::info!("配置文件为空"); + } + Err(e) => { + log::error!("{:?}",e); + } } status_handle.set_service_status(ServiceStatus { service_type: crate::windows::SERVICE_TYPE, @@ -137,7 +92,52 @@ fn service_main() -> windows_service::Result<()> { }) } +fn start_switch() -> switch::Result> { + if let Some(config) = read_config() { + let device_id = config.device_id; + if device_id.trim().is_empty() { + return Err(switch::error::Error::Stop("Device id error".to_string())); + } + let server_address = if let Some(server_address) = config.server + .to_socket_addrs()? + .next() { + server_address + } else { + return Err(switch::error::Error::Stop("server address error".to_string())); + }; + let nat_test_server = config.nat_test_server.iter() + .flat_map(|a| a.to_socket_addrs()) + .flatten() + .collect::>(); + if nat_test_server.is_empty() { + return Err(switch::error::Error::Stop("nat test server address error".to_string())); + } + let config = Config::new( + config.token, + device_id, + config.name, + server_address, + nat_test_server); + let switch = Switch::start(config)?; + log::info!("switch-service服务启动"); + let switch = Arc::new(switch); + let command_server = crate::command::server::CommandServer::new(); + let switch1 = switch.clone(); + thread::spawn(move || { + if let Err(e) = config::update_pid(std::process::id()) { + log::error!("{:?}", e); + } + if let Err(e) = command_server.start(switch1) { + log::error!("{:?}", e); + } + }); + Ok(switch) + } else { + Err(switch::error::Error::Stop("配置文件为空".to_string())) + } +} + pub fn start() { log::info!("以服务的方式启动"); - service_dispatcher::start("switch-service", ffi_service_main).unwrap(); + service_dispatcher::start(SERVICE_NAME, ffi_service_main).unwrap(); } diff --git a/switch/Cargo.toml b/switch/Cargo.toml index d399f73..9d70479 100644 --- a/switch/Cargo.toml +++ b/switch/Cargo.toml @@ -7,12 +7,14 @@ edition = "2021" [dependencies] packet = { path = "./packet" } +p2p_channel = { path = "./p2p_channel" } bytes = "1.3.0" log = "0.4.17" libc = "0.2.137" dashmap = "5.4.0" crossbeam = "0.8.2" +crossbeam-skiplist = "0.1" parking_lot = "0.12.1" rsa = "0.7.2" @@ -21,11 +23,13 @@ sha2 = { version = "0.10.6", features = ["oid"] } thiserror = "1.0.37" chrono = "0.4.23" -lazy_static = "1.4.0" -moka = "0.9.6" +#lazy_static = "1.4.0" +#moka = "0.9.6" protobuf = "3.2.0" -os_info = "3.5.1" -tokio = { version = "1.24.1", features = ["full"] } +#local-ip-address = "0.4.9" + +#mio = {version = "0.8.6",features = ["os-poll", "net"]} +#tokio = { version = "1.24.1", features = ["full"] } [target.'cfg(any(unix))'.dependencies] tun = { path = "./rust-tun" } diff --git a/switch/p2p_channel b/switch/p2p_channel new file mode 160000 index 0000000..a9c49f7 --- /dev/null +++ b/switch/p2p_channel @@ -0,0 +1 @@ +Subproject commit a9c49f79c66ecbe6a4286b9b6862c3488f730b13 diff --git a/switch/proto/message.proto b/switch/proto/message.proto index f0e63f5..6a490b4 100644 --- a/switch/proto/message.proto +++ b/switch/proto/message.proto @@ -1,7 +1,7 @@ syntax = "proto3"; message RegistrationRequest{ string token = 1; - string mac_address = 2; + string device_id = 2; string name = 3; bool is_fast = 4; } @@ -26,15 +26,16 @@ message DeviceList{ repeated DeviceInfo device_info_list = 2; } -message Punch{ - fixed32 virtual_ip = 1; +message PunchInfo{ repeated fixed32 public_ip_list = 2; uint32 public_port = 3; uint32 public_port_range = 4; - NatType nat_type = 5; + PunchNatType nat_type = 5; bool reply = 6; + fixed32 local_ip = 7; + uint32 local_port = 8; } -enum NatType{ +enum PunchNatType{ Symmetric = 0; Cone = 1; } \ No newline at end of file diff --git a/switch/rust-tun/Cargo.toml b/switch/rust-tun/Cargo.toml index f08cd94..7568382 100644 --- a/switch/rust-tun/Cargo.toml +++ b/switch/rust-tun/Cargo.toml @@ -15,31 +15,11 @@ libc = "0.2" thiserror = "1" [target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "ios", target_os = "android"))'.dependencies] -tokio = { version = "1", features = ["net", "macros"], optional = true } -tokio-util = { version = "0.6", features = ["codec"], optional = true } bytes = { version = "1", optional = true } byteorder = { version = "1", optional = true } -# This is only for the `ready` macro. -futures-core = { version = "0.3", optional = true } + [target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies] ioctl = { version = "0.6", package = "ioctl-sys" } -[dev-dependencies] -packet = "0.1" -futures = "0.3" -[features] -async = ["tokio", "tokio-util", "bytes", "byteorder", "futures-core"] - -[[example]] -name = "read-async" -required-features = [ "async", "tokio/rt-multi-thread" ] - -[[example]] -name = "read-async-codec" -required-features = [ "async", "tokio/rt-multi-thread" ] - -[[example]] -name = "ping-tun" -required-features = [ "async", "tokio/rt-multi-thread" ] diff --git a/switch/rust-tun/README.md b/switch/rust-tun/README.md deleted file mode 100644 index ae24a9e..0000000 --- a/switch/rust-tun/README.md +++ /dev/null @@ -1,106 +0,0 @@ -TUN interfaces [![Crates.io](https://img.shields.io/crates/v/tun.svg)](https://crates.io/crates/tun) ![tun](https://docs.rs/tun/badge.svg) ![WTFPL](http://img.shields.io/badge/license-WTFPL-blue.svg) -============== -This crate allows the creation and usage of TUN interfaces, the aim is to make this cross-platform. - -Usage ------ -First, add the following to your `Cargo.toml`: - -```toml -[dependencies] -tun = "0.5" -``` - -Next, add this to your crate root: - -```rust -extern crate tun; -``` - -If you want to use the TUN interface with mio/tokio, you need to enable the `async` feature: - -```toml -[dependencies] -tun = { version = "0.5", features = ["async"] } -``` - -Example -------- -The following example creates and configures a TUN interface and starts reading -packets from it. - -```rust -use std::io::Read; - -extern crate tun; - -fn main() { - let mut config = tun::Configuration::default(); - config.address((10, 0, 0, 1)) - .netmask((255, 255, 255, 0)) - .up(); - - #[cfg(target_os = "linux")] - config.platform(|config| { - config.packet_information(true); - }); - - let mut dev = tun::create(&config).unwrap(); - let mut buf = [0; 4096]; - - loop { - let amount = dev.read(&mut buf).unwrap(); - println!("{:?}", &buf[0 .. amount]); - } -} -``` - -Platforms -========= -Not every platform is supported. - -Linux ------ -You will need the `tun` module to be loaded and root is required to create -interfaces. - -macOS ------ -It just werks, but you have to set up routing manually. - -iOS ----- -You can pass the file descriptor of the TUN device to `rust-tun` to create the interface. - -Here is an example to create the TUN device on iOS and pass the `fd` to `rust-tun`: -```swift -// Swift -class PacketTunnelProvider: NEPacketTunnelProvider { - override func startTunnel(options: [String : NSObject]?, completionHandler: @escaping (Error?) -> Void) { - let tunnelNetworkSettings = createTunnelSettings() // Configure TUN address, DNS, mtu, routing... - setTunnelNetworkSettings(tunnelNetworkSettings) { [weak self] error in - let tunFd = self?.packetFlow.value(forKeyPath: "socket.fileDescriptor") as! Int32 - DispatchQueue.global(qos: .default).async { - start_tun(tunFd) - } - completionHandler(nil) - } - } -} -``` - -```rust -#[no_mangle] -pub extern "C" fn start_tun(fd: std::os::raw::c_int) { - let mut rt = tokio::runtime::Runtime::new().unwrap(); - rt.block_on(async { - let mut cfg = tun::Configuration::default(); - cfg.raw_fd(fd); - let mut tun = tun::create_as_async(&cfg).unwrap(); - let mut framed = tun.into_framed(); - while let Some(packet) = framed.next().await { - ... - } - }); -} -``` diff --git a/switch/rust-tun/examples/ping-tun.rs b/switch/rust-tun/examples/ping-tun.rs deleted file mode 100644 index a7a7c41..0000000 --- a/switch/rust-tun/examples/ping-tun.rs +++ /dev/null @@ -1,78 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -use futures::{SinkExt, StreamExt}; -use packet::{builder::Builder, icmp, ip, Packet}; -use tun::{self, Configuration, TunPacket}; - -#[tokio::main] -async fn main() { - let mut config = Configuration::default(); - - config - .address((10, 0, 0, 1)) - .netmask((255, 255, 255, 0)) - .up(); - - #[cfg(target_os = "linux")] - config.platform(|config| { - config.packet_information(true); - }); - - let dev = tun::create_as_async(&config).unwrap(); - - let mut framed = dev.into_framed(); - - while let Some(packet) = framed.next().await { - match packet { - Ok(pkt) => match ip::Packet::new(pkt.get_bytes()) { - Ok(ip::Packet::V4(pkt)) => match icmp::Packet::new(pkt.payload()) { - Ok(icmp) => match icmp.echo() { - Ok(icmp) => { - let reply = ip::v4::Builder::default() - .id(0x42) - .unwrap() - .ttl(64) - .unwrap() - .source(pkt.destination()) - .unwrap() - .destination(pkt.source()) - .unwrap() - .icmp() - .unwrap() - .echo() - .unwrap() - .reply() - .unwrap() - .identifier(icmp.identifier()) - .unwrap() - .sequence(icmp.sequence()) - .unwrap() - .payload(icmp.payload()) - .unwrap() - .build() - .unwrap(); - framed.send(TunPacket::new(reply)).await.unwrap(); - } - _ => {} - }, - _ => {} - }, - Err(err) => println!("Received an invalid packet: {:?}", err), - _ => {} - }, - Err(err) => panic!("Error: {:?}", err), - } - } -} diff --git a/switch/rust-tun/examples/read-async-codec.rs b/switch/rust-tun/examples/read-async-codec.rs deleted file mode 100644 index 211ab50..0000000 --- a/switch/rust-tun/examples/read-async-codec.rs +++ /dev/null @@ -1,61 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -use bytes::BytesMut; -use futures::StreamExt; -use packet::{ip::Packet, Error}; -use tokio_util::codec::{Decoder, FramedRead}; - -pub struct IPPacketCodec; - -impl Decoder for IPPacketCodec { - type Item = Packet; - type Error = Error; - - fn decode(&mut self, buf: &mut BytesMut) -> Result, Self::Error> { - if buf.is_empty() { - return Ok(None); - } - - let buf = buf.split_to(buf.len()); - Ok(match Packet::no_payload(buf) { - Ok(pkt) => Some(pkt), - Err(err) => { - println!("error {:?}", err); - None - } - }) - } -} - -#[tokio::main] -async fn main() { - let mut config = tun::Configuration::default(); - - config - .address((10, 0, 0, 1)) - .netmask((255, 255, 255, 0)) - .up(); - - let dev = tun::create_as_async(&config).unwrap(); - - let mut stream = FramedRead::new(dev, IPPacketCodec); - - while let Some(packet) = stream.next().await { - match packet { - Ok(pkt) => println!("pkt: {:#?}", pkt), - Err(err) => panic!("Error: {:?}", err), - } - } -} diff --git a/switch/rust-tun/examples/read-async.rs b/switch/rust-tun/examples/read-async.rs deleted file mode 100644 index 9fe9def..0000000 --- a/switch/rust-tun/examples/read-async.rs +++ /dev/null @@ -1,42 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -use futures::StreamExt; -use packet::ip::Packet; - -#[tokio::main] -async fn main() { - let mut config = tun::Configuration::default(); - - config - .address((10, 0, 0, 1)) - .netmask((255, 255, 255, 0)) - .up(); - - #[cfg(target_os = "linux")] - config.platform(|config| { - config.packet_information(true); - }); - - let dev = tun::create_as_async(&config).unwrap(); - - let mut stream = dev.into_framed(); - - while let Some(packet) = stream.next().await { - match packet { - Ok(pkt) => println!("pkt: {:#?}", Packet::unchecked(pkt.get_bytes())), - Err(err) => panic!("Error: {:?}", err), - } - } -} diff --git a/switch/rust-tun/examples/read.rs b/switch/rust-tun/examples/read.rs deleted file mode 100644 index 63ffd53..0000000 --- a/switch/rust-tun/examples/read.rs +++ /dev/null @@ -1,37 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -use std::io::Read; - -fn main() { - let mut config = tun::Configuration::default(); - - config - .address((10, 0, 0, 1)) - .netmask((255, 255, 255, 0)) - .up(); - - #[cfg(target_os = "linux")] - config.platform(|config| { - config.packet_information(true); - }); - - let mut dev = tun::create(&config).unwrap(); - let mut buf = [0; 4096]; - - loop { - let amount = dev.read(&mut buf).unwrap(); - println!("{:?}", &buf[0..amount]); - } -} diff --git a/switch/rust-tun/src/async/codec.rs b/switch/rust-tun/src/async/codec.rs deleted file mode 100644 index 04ead89..0000000 --- a/switch/rust-tun/src/async/codec.rs +++ /dev/null @@ -1,149 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -use std::io; - -use byteorder::{NativeEndian, NetworkEndian, WriteBytesExt}; -use bytes::{BufMut, Bytes, BytesMut}; -use tokio_util::codec::{Decoder, Encoder}; - -/// A packet protocol IP version -#[derive(Debug)] -enum PacketProtocol { - IPv4, - IPv6, - Other(u8), -} - -// Note: the protocol in the packet information header is platform dependent. -impl PacketProtocol { - #[cfg(any(target_os = "linux", target_os = "android"))] - fn into_pi_field(&self) -> Result { - match self { - PacketProtocol::IPv4 => Ok(libc::ETH_P_IP as u16), - PacketProtocol::IPv6 => Ok(libc::ETH_P_IPV6 as u16), - PacketProtocol::Other(_) => Err(io::Error::new( - io::ErrorKind::Other, - "neither an IPv4 or IPv6 packet", - )), - } - } - - #[cfg(any(target_os = "macos", target_os = "ios"))] - fn into_pi_field(&self) -> Result { - match self { - PacketProtocol::IPv4 => Ok(libc::PF_INET as u16), - PacketProtocol::IPv6 => Ok(libc::PF_INET6 as u16), - PacketProtocol::Other(_) => Err(io::Error::new( - io::ErrorKind::Other, - "neither an IPv4 or IPv6 packet", - )), - } - } -} - -/// A Tun Packet to be sent or received on the TUN interface. -#[derive(Debug)] -pub struct TunPacket(PacketProtocol, Bytes); - -/// Infer the protocol based on the first nibble in the packet buffer. -fn infer_proto(buf: &[u8]) -> PacketProtocol { - match buf[0] >> 4 { - 4 => PacketProtocol::IPv4, - 6 => PacketProtocol::IPv6, - p => PacketProtocol::Other(p), - } -} - -impl TunPacket { - /// Create a new `TunPacket` based on a byte slice. - pub fn new(bytes: Vec) -> TunPacket { - let proto = infer_proto(&bytes); - TunPacket(proto, Bytes::from(bytes)) - } - - /// Return this packet's bytes. - pub fn get_bytes(&self) -> &[u8] { - &self.1 - } - - pub fn into_bytes(self) -> Bytes { - self.1 - } -} - -/// A TunPacket Encoder/Decoder. -pub struct TunPacketCodec(bool, i32); - -impl TunPacketCodec { - /// Create a new `TunPacketCodec` specifying whether the underlying - /// tunnel Device has enabled the packet information header. - pub fn new(pi: bool, mtu: i32) -> TunPacketCodec { - TunPacketCodec(pi, mtu) - } -} - -impl Decoder for TunPacketCodec { - type Item = TunPacket; - type Error = io::Error; - - fn decode(&mut self, buf: &mut BytesMut) -> Result, Self::Error> { - if buf.is_empty() { - return Ok(None); - } - - let mut pkt = buf.split_to(buf.len()); - - // reserve enough space for the next packet - if self.0 { - buf.reserve(self.1 as usize + 4); - } else { - buf.reserve(self.1 as usize); - } - - // if the packet information is enabled we have to ignore the first 4 bytes - if self.0 { - let _ = pkt.split_to(4); - } - - let proto = infer_proto(pkt.as_ref()); - Ok(Some(TunPacket(proto, pkt.freeze()))) - } -} - -impl Encoder for TunPacketCodec { - type Error = io::Error; - - fn encode(&mut self, item: TunPacket, dst: &mut BytesMut) -> Result<(), Self::Error> { - dst.reserve(item.get_bytes().len() + 4); - match item { - TunPacket(proto, bytes) if self.0 => { - // build the packet information header comprising of 2 u16 - // fields: flags and protocol. - let mut buf = Vec::::with_capacity(4); - - // flags is always 0 - buf.write_u16::(0).unwrap(); - // write the protocol as network byte order - buf.write_u16::(proto.into_pi_field()?) - .unwrap(); - - dst.put_slice(&buf); - dst.put(bytes); - } - TunPacket(_, bytes) => dst.put(bytes), - } - Ok(()) - } -} diff --git a/switch/rust-tun/src/async/device.rs b/switch/rust-tun/src/async/device.rs deleted file mode 100644 index 5ac89fd..0000000 --- a/switch/rust-tun/src/async/device.rs +++ /dev/null @@ -1,201 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -use std::io; -use std::io::{IoSlice, Read, Write}; - -use core::pin::Pin; -use core::task::{Context, Poll}; -use futures_core::ready; -use tokio::io::unix::AsyncFd; -use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; -use tokio_util::codec::Framed; - -use crate::device::Device as D; -use crate::platform::{Device, Queue}; -use crate::r#async::codec::*; - -/// An async TUN device wrapper around a TUN device. -pub struct AsyncDevice { - inner: AsyncFd, -} - -impl AsyncDevice { - /// Create a new `AsyncDevice` wrapping around a `Device`. - pub fn new(device: Device) -> io::Result { - device.set_nonblock()?; - Ok(AsyncDevice { - inner: AsyncFd::new(device)?, - }) - } - /// Returns a shared reference to the underlying Device object - pub fn get_ref(&self) -> &Device { - self.inner.get_ref() - } - - /// Returns a mutable reference to the underlying Device object - pub fn get_mut(&mut self) -> &mut Device { - self.inner.get_mut() - } - - /// Consumes this AsyncDevice and return a Framed object (unified Stream and Sink interface) - pub fn into_framed(mut self) -> Framed { - let pi = self.get_mut().has_packet_information(); - let codec = TunPacketCodec::new(pi, self.inner.get_ref().mtu().unwrap_or(1504)); - Framed::new(self, codec) - } -} - -impl AsyncRead for AsyncDevice { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf, - ) -> Poll> { - loop { - let mut guard = ready!(self.inner.poll_read_ready_mut(cx))?; - let rbuf = buf.initialize_unfilled(); - match guard.try_io(|inner| inner.get_mut().read(rbuf)) { - Ok(res) => return Poll::Ready(res.map(|n| buf.advance(n))), - Err(_wb) => continue, - } - } - } -} - -impl AsyncWrite for AsyncDevice { - fn poll_write( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll> { - loop { - let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?; - match guard.try_io(|inner| inner.get_mut().write(buf)) { - Ok(res) => return Poll::Ready(res), - Err(_wb) => continue, - } - } - } - - fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { - loop { - let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?; - match guard.try_io(|inner| inner.get_mut().flush()) { - Ok(res) => return Poll::Ready(res), - Err(_wb) => continue, - } - } - } - - fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn poll_write_vectored( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - bufs: &[IoSlice<'_>], - ) -> Poll> { - loop { - let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?; - match guard.try_io(|inner| inner.get_mut().write_vectored(bufs)) { - Ok(res) => return Poll::Ready(res), - Err(_wb) => continue, - } - } - } - - fn is_write_vectored(&self) -> bool { - true - } -} - -/// An async TUN device queue wrapper around a TUN device queue. -pub struct AsyncQueue { - inner: AsyncFd, -} - -impl AsyncQueue { - /// Create a new `AsyncQueue` wrapping around a `Queue`. - pub fn new(queue: Queue) -> io::Result { - queue.set_nonblock()?; - Ok(AsyncQueue { - inner: AsyncFd::new(queue)?, - }) - } - /// Returns a shared reference to the underlying Queue object - pub fn get_ref(&self) -> &Queue { - self.inner.get_ref() - } - - /// Returns a mutable reference to the underlying Queue object - pub fn get_mut(&mut self) -> &mut Queue { - self.inner.get_mut() - } - - /// Consumes this AsyncQueue and return a Framed object (unified Stream and Sink interface) - pub fn into_framed(mut self) -> Framed { - let pi = self.get_mut().has_packet_information(); - let codec = TunPacketCodec::new(pi, 1504); - Framed::new(self, codec) - } -} - -impl AsyncRead for AsyncQueue { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf, - ) -> Poll> { - loop { - let mut guard = ready!(self.inner.poll_read_ready_mut(cx))?; - let rbuf = buf.initialize_unfilled(); - match guard.try_io(|inner| inner.get_mut().read(rbuf)) { - Ok(res) => return Poll::Ready(res.map(|n| buf.advance(n))), - Err(_wb) => continue, - } - } - } -} - -impl AsyncWrite for AsyncQueue { - fn poll_write( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll> { - loop { - let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?; - match guard.try_io(|inner| inner.get_mut().write(buf)) { - Ok(res) => return Poll::Ready(res), - Err(_wb) => continue, - } - } - } - - fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { - loop { - let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?; - match guard.try_io(|inner| inner.get_mut().flush()) { - Ok(res) => return Poll::Ready(res), - Err(_wb) => continue, - } - } - } - - fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } -} diff --git a/switch/rust-tun/src/async/mod.rs b/switch/rust-tun/src/async/mod.rs deleted file mode 100644 index b9be373..0000000 --- a/switch/rust-tun/src/async/mod.rs +++ /dev/null @@ -1,32 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -//! Async specific modules. - -use crate::error; - -use crate::configuration::Configuration; -use crate::platform::create; - -mod device; -pub use self::device::{AsyncDevice, AsyncQueue}; - -mod codec; -pub use self::codec::{TunPacket, TunPacketCodec}; - -/// Create a TUN device with the given name. -pub fn create_as_async(configuration: &Configuration) -> Result { - let device = create(&configuration)?; - AsyncDevice::new(device).map_err(|err| err.into()) -} diff --git a/switch/rust-tun/src/device.rs b/switch/rust-tun/src/device.rs index cab8432..5faaf56 100644 --- a/switch/rust-tun/src/device.rs +++ b/switch/rust-tun/src/device.rs @@ -12,15 +12,14 @@ // // 0. You just DO WHAT THE FUCK YOU WANT TO. -use std::io::{Read, Write}; use std::net::Ipv4Addr; use crate::configuration::Configuration; use crate::error::*; /// A TUN device. -pub trait Device: Read + Write { - type Queue: Read + Write; +pub trait Device { + type Queue ; /// Reconfigure the device. fn configure(&mut self, config: &Configuration) -> Result<()> { @@ -91,5 +90,5 @@ pub trait Device: Read + Write { fn set_mtu(&mut self, value: i32) -> Result<()>; /// Get a device queue. - fn queue(&mut self, index: usize) -> Option<&mut Self::Queue>; + fn queue(&self, index: usize) -> Option<&Self::Queue>; } diff --git a/switch/rust-tun/src/lib.rs b/switch/rust-tun/src/lib.rs index 3cb65c2..5989013 100644 --- a/switch/rust-tun/src/lib.rs +++ b/switch/rust-tun/src/lib.rs @@ -27,27 +27,6 @@ pub use crate::configuration::{Configuration, Layer}; pub mod platform; pub use crate::platform::create; -#[cfg(all( - feature = "async", - any( - target_os = "linux", - target_os = "macos", - target_os = "ios", - target_os = "android" - ) -))] -pub mod r#async; -#[cfg(all( - feature = "async", - any( - target_os = "linux", - target_os = "macos", - target_os = "ios", - target_os = "android" - ) -))] -pub use r#async::*; - pub fn configure() -> Configuration { Configuration::default() } diff --git a/switch/rust-tun/src/platform/android/device.rs b/switch/rust-tun/src/platform/android/device.rs deleted file mode 100644 index 5dd2c80..0000000 --- a/switch/rust-tun/src/platform/android/device.rs +++ /dev/null @@ -1,214 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. -#![allow(unused_variables)] - -use std::io::{self, Read, Write}; -use std::net::Ipv4Addr; -use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; -use std::sync::Arc; - -use crate::configuration::Configuration; -use crate::device::Device as D; -use crate::error::*; -use crate::platform::posix::{self, Fd}; - -/// A TUN device for Android. -pub struct Device { - queue: Queue, -} - -impl Device { - /// Create a new `Device` for the given `Configuration`. - pub fn new(config: &Configuration) -> Result { - let fd = match config.raw_fd { - Some(raw_fd) => raw_fd, - _ => return Err(Error::InvalidConfig), - }; - let device = { - let tun = Fd::new(fd).map_err(|_| io::Error::last_os_error())?; - - Device { - queue: Queue { tun: tun }, - } - }; - Ok(device) - } - - /// Split the interface into a `Reader` and `Writer`. - pub fn split(self) -> (posix::Reader, posix::Writer) { - let fd = Arc::new(self.queue.tun); - (posix::Reader(fd.clone()), posix::Writer(fd.clone())) - } - - /// Return whether the device has packet information - pub fn has_packet_information(&self) -> bool { - self.queue.has_packet_information() - } - - /// Set non-blocking mode - pub fn set_nonblock(&self) -> io::Result<()> { - self.queue.set_nonblock() - } -} - -impl Read for Device { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.queue.tun.read(buf) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.queue.tun.read_vectored(bufs) - } -} - -impl Write for Device { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.queue.tun.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.queue.tun.flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.queue.tun.write_vectored(bufs) - } -} - -impl D for Device { - type Queue = Queue; - - fn name(&self) -> &str { - return ""; - } - - fn set_name(&mut self, value: &str) -> Result<()> { - Err(Error::NotImplemented) - } - - fn enabled(&mut self, value: bool) -> Result<()> { - Ok(()) - } - - fn address(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_address(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn destination(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_destination(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn broadcast(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_broadcast(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn netmask(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_netmask(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn mtu(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_mtu(&mut self, value: i32) -> Result<()> { - Ok(()) - } - - fn queue(&mut self, index: usize) -> Option<&mut Self::Queue> { - if index > 0 { - return None; - } - - Some(&mut self.queue) - } -} - -impl AsRawFd for Device { - fn as_raw_fd(&self) -> RawFd { - self.queue.as_raw_fd() - } -} - -impl IntoRawFd for Device { - fn into_raw_fd(self) -> RawFd { - self.queue.into_raw_fd() - } -} - -pub struct Queue { - tun: Fd, -} - -impl Queue { - pub fn has_packet_information(&self) -> bool { - // on Android this is always the case - false - } - - pub fn set_nonblock(&self) -> io::Result<()> { - self.tun.set_nonblock() - } -} - -impl AsRawFd for Queue { - fn as_raw_fd(&self) -> RawFd { - self.tun.as_raw_fd() - } -} - -impl IntoRawFd for Queue { - fn into_raw_fd(self) -> RawFd { - self.tun.into_raw_fd() - } -} - -impl Read for Queue { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.tun.read(buf) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.tun.read_vectored(bufs) - } -} - -impl Write for Queue { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.tun.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.tun.flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.tun.write_vectored(bufs) - } -} diff --git a/switch/rust-tun/src/platform/android/mod.rs b/switch/rust-tun/src/platform/android/mod.rs deleted file mode 100644 index 923e14f..0000000 --- a/switch/rust-tun/src/platform/android/mod.rs +++ /dev/null @@ -1,30 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -//! Android specific functionality. - -mod device; -pub use self::device::{Device, Queue}; - -use crate::configuration::Configuration as C; -use crate::error::*; - -/// Android-only interface configuration. -#[derive(Copy, Clone, Default, Debug)] -pub struct Configuration {} - -/// Create a TUN device with the given name. -pub fn create(configuration: &C) -> Result { - Device::new(&configuration) -} diff --git a/switch/rust-tun/src/platform/ios/device.rs b/switch/rust-tun/src/platform/ios/device.rs deleted file mode 100644 index b079d42..0000000 --- a/switch/rust-tun/src/platform/ios/device.rs +++ /dev/null @@ -1,214 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. -#![allow(unused_variables)] - -use std::io::{self, Read, Write}; -use std::net::Ipv4Addr; -use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; -use std::sync::Arc; - -use crate::configuration::Configuration; -use crate::device::Device as D; -use crate::error::*; -use crate::platform::posix::{self, Fd}; - -/// A TUN device for iOS. -pub struct Device { - queue: Queue, -} - -impl Device { - /// Create a new `Device` for the given `Configuration`. - pub fn new(config: &Configuration) -> Result { - let fd = match config.raw_fd { - Some(raw_fd) => raw_fd, - _ => return Err(Error::InvalidConfig), - }; - let mut device = unsafe { - let tun = Fd::new(fd).map_err(|_| io::Error::last_os_error())?; - - Device { - queue: Queue { tun: tun }, - } - }; - Ok(device) - } - - /// Split the interface into a `Reader` and `Writer`. - pub fn split(self) -> (posix::Reader, posix::Writer) { - let fd = Arc::new(self.queue.tun); - (posix::Reader(fd.clone()), posix::Writer(fd.clone())) - } - - /// Return whether the device has packet information - pub fn has_packet_information(&self) -> bool { - self.queue.has_packet_information() - } - - /// Set non-blocking mode - pub fn set_nonblock(&self) -> io::Result<()> { - self.queue.set_nonblock() - } -} - -impl Read for Device { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.queue.tun.read(buf) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.queue.tun.read_vectored(bufs) - } -} - -impl Write for Device { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.queue.tun.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.queue.tun.flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.queue.tun.write_vectored(bufs) - } -} - -impl D for Device { - type Queue = Queue; - - fn name(&self) -> &str { - return ""; - } - - fn set_name(&mut self, value: &str) -> Result<()> { - Err(Error::NotImplemented) - } - - fn enabled(&mut self, value: bool) -> Result<()> { - Ok(()) - } - - fn address(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_address(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn destination(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_destination(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn broadcast(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_broadcast(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn netmask(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_netmask(&mut self, value: Ipv4Addr) -> Result<()> { - Ok(()) - } - - fn mtu(&self) -> Result { - Err(Error::NotImplemented) - } - - fn set_mtu(&mut self, value: i32) -> Result<()> { - Ok(()) - } - - fn queue(&mut self, index: usize) -> Option<&mut Self::Queue> { - if index > 0 { - return None; - } - - Some(&mut self.queue) - } -} - -impl AsRawFd for Device { - fn as_raw_fd(&self) -> RawFd { - self.queue.as_raw_fd() - } -} - -impl IntoRawFd for Device { - fn into_raw_fd(self) -> RawFd { - self.queue.into_raw_fd() - } -} - -pub struct Queue { - tun: Fd, -} - -impl Queue { - pub fn has_packet_information(&self) -> bool { - // on ios this is always the case - true - } - - pub fn set_nonblock(&self) -> io::Result<()> { - self.tun.set_nonblock() - } -} - -impl AsRawFd for Queue { - fn as_raw_fd(&self) -> RawFd { - self.tun.as_raw_fd() - } -} - -impl IntoRawFd for Queue { - fn into_raw_fd(self) -> RawFd { - self.tun.into_raw_fd() - } -} - -impl Read for Queue { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.tun.read(buf) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.tun.read_vectored(bufs) - } -} - -impl Write for Queue { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.tun.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.tun.flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.tun.write_vectored(bufs) - } -} diff --git a/switch/rust-tun/src/platform/ios/mod.rs b/switch/rust-tun/src/platform/ios/mod.rs deleted file mode 100644 index ea46855..0000000 --- a/switch/rust-tun/src/platform/ios/mod.rs +++ /dev/null @@ -1,30 +0,0 @@ -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// Version 2, December 2004 -// -// Copyleft (ↄ) meh. | http://meh.schizofreni.co -// -// Everyone is permitted to copy and distribute verbatim or modified -// copies of this license document, and changing it is allowed as long -// as the name is changed. -// -// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE -// TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -// -// 0. You just DO WHAT THE FUCK YOU WANT TO. - -//! iOS specific functionality. - -mod device; -pub use self::device::{Device, Queue}; - -use crate::configuration::Configuration as C; -use crate::error::*; - -/// iOS-only interface configuration. -#[derive(Copy, Clone, Default, Debug)] -pub struct Configuration {} - -/// Create a TUN device with the given name. -pub fn create(configuration: &C) -> Result { - Device::new(&configuration) -} diff --git a/switch/rust-tun/src/platform/linux/device.rs b/switch/rust-tun/src/platform/linux/device.rs index 1b078ae..8d0085d 100644 --- a/switch/rust-tun/src/platform/linux/device.rs +++ b/switch/rust-tun/src/platform/linux/device.rs @@ -13,10 +13,10 @@ // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ffi::{CStr, CString}; -use std::io::{self, Read, Write}; +use std::io; use std::mem; use std::net::Ipv4Addr; -use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::AsRawFd; use std::ptr; use std::sync::Arc; use std::vec::Vec; @@ -77,10 +77,10 @@ impl Device { req.ifru.flags = device_type | if config.platform.packet_information { - 0 - } else { - IFF_NO_PI - } + 0 + } else { + IFF_NO_PI + } | if queues_num > 1 { IFF_MULTI_QUEUE } else { 0 }; for _ in 0..queues_num { @@ -92,7 +92,7 @@ impl Device { } queues.push(Queue { - tun, + tun: Arc::new(tun), pi_enabled: config.platform.packet_information, }); } @@ -126,45 +126,40 @@ impl Device { req } - /// Make the device persistent. - pub fn persist(&mut self) -> Result<()> { - unsafe { - if tunsetpersist(self.as_raw_fd(), &1) < 0 { - Err(io::Error::last_os_error().into()) - } else { - Ok(()) - } - } - } + // /// Make the device persistent. + // pub fn persist(&mut self) -> Result<()> { + // unsafe { + // if tunsetpersist(self.as_raw_fd(), &1) < 0 { + // Err(io::Error::last_os_error().into()) + // } else { + // Ok(()) + // } + // } + // } - /// Set the owner of the device. - pub fn user(&mut self, value: i32) -> Result<()> { - unsafe { - if tunsetowner(self.as_raw_fd(), &value) < 0 { - Err(io::Error::last_os_error().into()) - } else { - Ok(()) - } - } - } - - /// Set the group of the device. - pub fn group(&mut self, value: i32) -> Result<()> { - unsafe { - if tunsetgroup(self.as_raw_fd(), &value) < 0 { - Err(io::Error::last_os_error().into()) - } else { - Ok(()) - } - } - } - pub fn split(mut self) -> (posix::Reader, posix::Writer) { - let queue = self.queues.swap_remove(0); - let fd = Arc::new(queue.tun); - (posix::Reader(fd.clone()), posix::Writer(fd.clone())) - } + // /// Set the owner of the device. + // pub fn user(&mut self, value: i32) -> Result<()> { + // unsafe { + // if tunsetowner(self.as_raw_fd(), &value) < 0 { + // Err(io::Error::last_os_error().into()) + // } else { + // Ok(()) + // } + // } + // } + // + // /// Set the group of the device. + // pub fn group(&mut self, value: i32) -> Result<()> { + // unsafe { + // if tunsetgroup(self.as_raw_fd(), &value) < 0 { + // Err(io::Error::last_os_error().into()) + // } else { + // Ok(()) + // } + // } + // } /// Return whether the device has packet information - pub fn has_packet_information(&mut self) -> bool { + pub fn has_packet_information(&self) -> bool { self.queues[0].has_packet_information() } @@ -174,30 +169,6 @@ impl Device { } } -impl Read for Device { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.queues[0].read(buf) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.queues[0].read_vectored(bufs) - } -} - -impl Write for Device { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.queues[0].write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.queues[0].flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.queues[0].write_vectored(bufs) - } -} - impl D for Device { type Queue = Queue; @@ -377,73 +348,29 @@ impl D for Device { } } - fn queue(&mut self, index: usize) -> Option<&mut Self::Queue> { - self.queues.get_mut(index) - } -} - -impl AsRawFd for Device { - fn as_raw_fd(&self) -> RawFd { - self.queues[0].as_raw_fd() - } -} - -impl IntoRawFd for Device { - fn into_raw_fd(mut self) -> RawFd { - // It is Ok to swap the first queue with the last one, because the self will be dropped afterwards - let queue = self.queues.swap_remove(0); - queue.into_raw_fd() + fn queue(&self, index: usize) -> Option<&Self::Queue> { + self.queues.get(index) } } pub struct Queue { - tun: Fd, + tun: Arc, pi_enabled: bool, } impl Queue { - pub fn has_packet_information(&mut self) -> bool { + pub fn has_packet_information(&self) -> bool { self.pi_enabled } pub fn set_nonblock(&self) -> io::Result<()> { self.tun.set_nonblock() } -} - -impl Read for Queue { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.tun.read(buf) + pub fn reader(&self) -> posix::Reader { + posix::Reader(self.tun.clone()) } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.tun.read_vectored(bufs) - } -} - -impl Write for Queue { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.tun.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.tun.flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.tun.write_vectored(bufs) - } -} - -impl AsRawFd for Queue { - fn as_raw_fd(&self) -> RawFd { - self.tun.as_raw_fd() - } -} - -impl IntoRawFd for Queue { - fn into_raw_fd(self) -> RawFd { - self.tun.into_raw_fd() + pub fn writer(&self) -> posix::Writer { + posix::Writer(self.tun.clone()) } } diff --git a/switch/rust-tun/src/platform/macos/device.rs b/switch/rust-tun/src/platform/macos/device.rs index 879e1ad..9b3bf62 100644 --- a/switch/rust-tun/src/platform/macos/device.rs +++ b/switch/rust-tun/src/platform/macos/device.rs @@ -14,15 +14,15 @@ #![allow(unused_variables)] use std::ffi::CStr; -use std::io::{self, Read, Write}; +use std::io; use std::mem; use std::net::Ipv4Addr; -use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::AsRawFd; use std::ptr; use std::sync::Arc; use libc; -use libc::{c_char, c_uint, c_void, sockaddr, socklen_t, AF_INET, SOCK_DGRAM}; +use libc::{AF_INET, c_char, c_uint, c_void, SOCK_DGRAM, sockaddr, socklen_t}; use crate::configuration::{Configuration, Layer}; use crate::device::Device as D; @@ -121,7 +121,7 @@ impl Device { name: CStr::from_ptr(name.as_ptr() as *const c_char) .to_string_lossy() .into(), - queue: Queue { tun: tun }, + queue: Queue { tun: Arc::new(tun) }, ctl: ctl, } }; @@ -165,11 +165,11 @@ impl Device { } } - /// Split the interface into a `Reader` and `Writer`. - pub fn split(self) -> (posix::Reader, posix::Writer) { - let fd = Arc::new(self.queue.tun); - (posix::Reader(fd.clone()), posix::Writer(fd.clone())) - } + // /// Split the interface into a `Reader` and `Writer`. + // pub fn split(self) -> (posix::Reader, posix::Writer) { + // let fd = Arc::new(self.queue.tun); + // (posix::Reader(fd.clone()), posix::Writer(fd.clone())) + // } /// Return whether the device has packet information pub fn has_packet_information(&self) -> bool { @@ -182,29 +182,29 @@ impl Device { } } -impl Read for Device { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.queue.tun.read(buf) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.queue.tun.read_vectored(bufs) - } -} - -impl Write for Device { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.queue.tun.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.queue.tun.flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.queue.tun.write_vectored(bufs) - } -} +// impl Read for Device { +// fn read(&mut self, buf: &mut [u8]) -> io::Result { +// self.queue.tun.read(buf) +// } +// +// fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { +// self.queue.tun.read_vectored(bufs) +// } +// } +// +// impl Write for Device { +// fn write(&mut self, buf: &[u8]) -> io::Result { +// self.queue.tun.write(buf) +// } +// +// fn flush(&mut self) -> io::Result<()> { +// self.queue.tun.flush() +// } +// +// fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { +// self.queue.tun.write_vectored(bufs) +// } +// } impl D for Device { type Queue = Queue; @@ -365,29 +365,29 @@ impl D for Device { } } - fn queue(&mut self, index: usize) -> Option<&mut Self::Queue> { + fn queue(&self, index: usize) -> Option<&Self::Queue> { if index > 0 { return None; } - Some(&mut self.queue) + Some(&self.queue) } } -impl AsRawFd for Device { - fn as_raw_fd(&self) -> RawFd { - self.queue.as_raw_fd() - } -} - -impl IntoRawFd for Device { - fn into_raw_fd(self) -> RawFd { - self.queue.into_raw_fd() - } -} +// impl AsRawFd for Device { +// fn as_raw_fd(&self) -> RawFd { +// self.queue.as_raw_fd() +// } +// } +// +// impl IntoRawFd for Device { +// fn into_raw_fd(self) -> RawFd { +// self.queue.into_raw_fd() +// } +// } pub struct Queue { - tun: Fd, + tun: Arc, } impl Queue { @@ -399,40 +399,47 @@ impl Queue { pub fn set_nonblock(&self) -> io::Result<()> { self.tun.set_nonblock() } -} -impl AsRawFd for Queue { - fn as_raw_fd(&self) -> RawFd { - self.tun.as_raw_fd() + pub fn reader(&self) -> posix::Reader { + posix::Reader(self.tun.clone()) + } + pub fn writer(&self) -> posix::Writer { + posix::Writer(self.tun.clone()) } } -impl IntoRawFd for Queue { - fn into_raw_fd(self) -> RawFd { - self.tun.into_raw_fd() - } -} +// impl AsRawFd for Queue { +// fn as_raw_fd(&self) -> RawFd { +// self.tun.as_raw_fd() +// } +// } +// +// impl IntoRawFd for Queue { +// fn into_raw_fd(self) -> RawFd { +// self.tun.into_raw_fd() +// } +// } -impl Read for Queue { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.tun.read(buf) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { - self.tun.read_vectored(bufs) - } -} - -impl Write for Queue { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.tun.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - self.tun.flush() - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { - self.tun.write_vectored(bufs) - } -} +// impl Read for Queue { +// fn read(&mut self, buf: &mut [u8]) -> io::Result { +// self.tun.read(buf) +// } +// +// fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { +// self.tun.read_vectored(bufs) +// } +// } +// +// impl Write for Queue { +// fn write(&mut self, buf: &[u8]) -> io::Result { +// self.tun.write(buf) +// } +// +// fn flush(&mut self) -> io::Result<()> { +// self.tun.flush() +// } +// +// fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { +// self.tun.write_vectored(bufs) +// } +// } diff --git a/switch/rust-tun/src/platform/posix/split.rs b/switch/rust-tun/src/platform/posix/split.rs index 7364102..d09ed68 100644 --- a/switch/rust-tun/src/platform/posix/split.rs +++ b/switch/rust-tun/src/platform/posix/split.rs @@ -12,22 +12,24 @@ // // 0. You just DO WHAT THE FUCK YOU WANT TO. -use std::io::{self, Read, Write}; +use std::io; use std::mem; -use std::os::unix::io::{AsRawFd, RawFd}; +use std::os::unix::io::{AsRawFd,RawFd}; use std::sync::Arc; use crate::platform::posix::Fd; use libc; /// Read-only end for a file descriptor. +#[derive(Clone)] pub struct Reader(pub(crate) Arc); /// Write-only end for a file descriptor. +#[derive(Clone)] pub struct Writer(pub(crate) Arc); -impl Read for Reader { - fn read(&mut self, buf: &mut [u8]) -> io::Result { +impl Reader { + pub fn read(&self, buf: &mut [u8]) -> io::Result { unsafe { let amount = libc::read(self.0.as_raw_fd(), buf.as_mut_ptr() as *mut _, buf.len()); @@ -39,7 +41,7 @@ impl Read for Reader { } } - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { + pub fn read_vectored(&self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result { unsafe { let mut msg: libc::msghdr = mem::zeroed(); // msg.msg_name: NULL @@ -57,8 +59,8 @@ impl Read for Reader { } } -impl Write for Writer { - fn write(&mut self, buf: &[u8]) -> io::Result { +impl Writer { + pub fn write(&self, buf: &[u8]) -> io::Result { unsafe { let amount = libc::write(self.0.as_raw_fd(), buf.as_ptr() as *const _, buf.len()); @@ -70,11 +72,8 @@ impl Write for Writer { } } - fn flush(&mut self) -> io::Result<()> { - Ok(()) - } - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result { + pub fn write_vectored(&self, bufs: &[io::IoSlice<'_>]) -> io::Result { unsafe { let mut msg: libc::msghdr = mem::zeroed(); // msg.msg_name = NULL @@ -90,6 +89,22 @@ impl Write for Writer { Ok(n as usize) } } + pub fn write_all(&self, mut buf: &[u8]) -> io::Result<()> { + while !buf.is_empty() { + match self.write(buf) { + Ok(0) => { + return Err(io::Error::new( + io::ErrorKind::WriteZero, + "failed to write whole buffer", + )); + } + Ok(n) => buf = &buf[n..], + Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} + Err(e) => return Err(e), + } + } + Ok(()) + } } impl AsRawFd for Reader { @@ -97,9 +112,9 @@ impl AsRawFd for Reader { self.0.as_raw_fd() } } - -impl AsRawFd for Writer { - fn as_raw_fd(&self) -> RawFd { - self.0.as_raw_fd() - } -} +// +// impl AsRawFd for Writer { +// fn as_raw_fd(&self) -> RawFd { +// self.0.as_raw_fd() +// } +// } diff --git a/switch/src/core/mod.rs b/switch/src/core/mod.rs new file mode 100644 index 0000000..bafaa3f --- /dev/null +++ b/switch/src/core/mod.rs @@ -0,0 +1,140 @@ +use std::io; +use std::net::{Ipv4Addr, SocketAddr}; +use std::sync::Arc; +use crossbeam::atomic::AtomicCell; +use crossbeam_skiplist::SkipMap; +use parking_lot::Mutex; +use p2p_channel::boot::Boot; +use p2p_channel::channel::{Channel, Route, RouteKey}; +use p2p_channel::punch::NatInfo; +use crate::handle::{ConnectStatus, CurrentDeviceInfo, heartbeat_handler, PeerDeviceInfo, punch_handler, recv_handler, registration_handler, tun_handler}; +use crate::nat::NatTest; +use crate::tun_device; +use crate::tun_device::TunReader; + +pub struct Switch { + name: String, + current_device: Arc>, + tun_reader: TunReader, + nat_channel: Channel, + /// 0. 机器纪元，每一次上线或者下线都会增1，用于感知网络中机器变化 + /// 服务端和客户端的不一致，则服务端会推送新的设备列表 + /// 1. 网络中的虚拟ip列表 + device_list: Arc)>>, + nat_test: NatTest, + connect_status: Arc>, + peer_nat_info_map: Arc>, +} + +impl Switch { + pub fn start(config: Config) -> crate::Result { + let (mut channel, punch, idle) = Boot::new::(80, 15000, 0)?; + let response = registration_handler::registration(&mut channel, config.server_address, config.token.clone(), config.device_id.clone(), config.name.clone())?; + let register = Arc::new(registration_handler::Register::new(channel.sender()?, config.server_address, config.token.clone(), config.device_id.clone(), config.name.clone())); + let device_list: Arc)>> = Arc::new(Mutex::new((0, Vec::new()))); + let peer_nat_info_map: Arc> = Arc::new(SkipMap::new()); + let connect_status = Arc::new(AtomicCell::new(ConnectStatus::Connected)); + let virtual_ip = Ipv4Addr::from(response.virtual_ip); + let virtual_gateway = Ipv4Addr::from(response.virtual_gateway); + let virtual_netmask = Ipv4Addr::from(response.virtual_netmask); + let current_device = Arc::new(AtomicCell::new(CurrentDeviceInfo::new(virtual_ip, virtual_gateway, virtual_netmask, config.server_address))); + let local_ip = crate::nat::local_ip()?; + let local_port = channel.local_addr()?.port(); + // NAT检测 + let nat_test = NatTest::new(config.nat_test_server.clone(), Ipv4Addr::from(response.public_ip), response.public_port as u16, local_ip, local_port); + // tun通道 + let (tun_writer, tun_reader) = tun_device::create_tun(virtual_ip, virtual_netmask, virtual_gateway)?; + + // 定时心跳 + heartbeat_handler::start_heartbeat(channel.sender()?, device_list.clone(), current_device.clone()); + // 空闲检查 + heartbeat_handler::start_idle(idle, channel.sender()?); + // 打洞处理 + punch_handler::start_cone(punch.try_clone()?, current_device.clone()); + punch_handler::start_symmetric(punch, current_device.clone()); + punch_handler::start_punch(nat_test.clone(), device_list.clone(), channel.sender()?, current_device.clone()); + //tun数据接收处理 + for _ in 0..2 { + tun_handler::start(channel.sender()?, tun_reader.clone(), tun_writer.clone(), current_device.clone()); + } + //外部数据接收处理 + let channel_recv_handler = recv_handler::RecvHandler::new(channel.try_clone()?, current_device.clone(), device_list.clone(), register.clone(), + nat_test.clone(), tun_writer.clone(), connect_status.clone(), peer_nat_info_map.clone()); + for _ in 0..2 { + recv_handler::start(channel_recv_handler.try_clone()?); + } + Ok(Switch { + name: config.name, + current_device, + tun_reader, + nat_channel: channel, + nat_test, + device_list, + connect_status, + peer_nat_info_map, + }) + } +} + +impl Switch { + pub fn name(&self) -> &str { + &self.name + } + pub fn current_device(&self) -> CurrentDeviceInfo { + self.current_device.load() + } + pub fn peer_nat_info(&self, ip: &Ipv4Addr) -> Option { + self.peer_nat_info_map.get(ip).map(|e| e.value().clone()) + } + pub fn connection_status(&self) -> ConnectStatus { + self.connect_status.load() + } + pub fn nat_info(&self) -> NatInfo { + self.nat_test.nat_info() + } + pub fn device_list(&self) -> Vec { + let device_list_lock = self.device_list.lock(); + let (_epoch, device_list) = device_list_lock.clone(); + drop(device_list_lock); + device_list + } + pub fn route(&self, ip: &Ipv4Addr) -> Option { + self.nat_channel.route(ip) + } + pub fn route_key(&self, route_key: &RouteKey) -> Option { + self.nat_channel.route_to_id(route_key) + } + pub fn route_table(&self) -> Vec<(Ipv4Addr, Route)> { + self.nat_channel.route_table() + } + pub fn stop(&self) -> io::Result<()> { + self.tun_reader.close(); + self.nat_channel.close()?; + Ok(()) + } +} + +#[derive(Clone, Debug)] +pub struct Config { + pub token: String, + pub device_id: String, + pub name: String, + pub server_address: SocketAddr, + pub nat_test_server: Vec, +} + +impl Config { + pub fn new(token: String, + device_id: String, + name: String, + server_address: SocketAddr, + nat_test_server: Vec, ) -> Self { + Self { + token, + device_id, + name, + server_address, + nat_test_server, + } + } +} \ No newline at end of file diff --git a/switch/src/error/mod.rs b/switch/src/error/mod.rs index 576bf03..24e6e3b 100644 --- a/switch/src/error/mod.rs +++ b/switch/src/error/mod.rs @@ -7,8 +7,6 @@ use thiserror::Error; pub enum Error { #[error("packet error")] PacketError(#[from] packet::error::Error), - #[error("TokioWatchRecvError")] - TokioWatchRecvError(#[from] tokio::sync::watch::error::RecvError), #[error("Io error")] Io(#[from] io::Error), #[error("Channel error")] @@ -21,6 +19,8 @@ pub enum Error { NotSupport, #[error("Stop")] Stop(String), + #[error("Warn")] + Warn(String), } pub type Result = std::result::Result; diff --git a/switch/src/handle/heartbeat_handler.rs b/switch/src/handle/heartbeat_handler.rs index 14e135f..5a4df8a 100644 --- a/switch/src/handle/heartbeat_handler.rs +++ b/switch/src/handle/heartbeat_handler.rs @@ -1,80 +1,108 @@ -use std::net::{SocketAddr, UdpSocket}; +use std::{io, thread}; +use std::net::Ipv4Addr; +use std::sync::Arc; use std::time::Duration; use chrono::Local; -use tokio::sync::watch::Receiver; -use tokio::time::sleep; +use crossbeam::atomic::AtomicCell; +use parking_lot::Mutex; +use rand::prelude::SliceRandom; -use crate::error::*; -use crate::handle::{ApplicationStatus, DIRECT_ROUTE_TABLE}; +use p2p_channel::channel::Route; +use p2p_channel::channel::sender::Sender; +use p2p_channel::idle::Idle; + +use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo}; +use crate::protocol::{control_packet, MAX_TTL, NetPacket, Protocol, Version}; use crate::protocol::control_packet::PingPacket; -use crate::protocol::{control_packet, NetPacket, Protocol, Version}; -use crate::{CurrentDeviceInfo, DEVICE_LIST}; -pub async fn start( - status_watch: Receiver, - udp: UdpSocket, - cur_info: CurrentDeviceInfo, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - tokio::spawn(async move { - match handle_loop(status_watch, udp, cur_info.connect_server).await { - Ok(_) => {} - Err(e) => { - log::warn!("{:?}", e) - } +pub fn start_idle(idle: Idle, sender: Sender) { + thread::spawn(move || { + if let Err(e) = start_idle_(idle, sender) { + log::info!("空闲检测线程停止:{:?}",e); } - stop_fn(); }); } -async fn handle_loop( - mut status_watch: Receiver, - udp: UdpSocket, - server_addr: SocketAddr, -) -> Result<()> { - const INTERVAL: u64 = 3000; - const MAX_INTERVAL: i64 = 3000 * 3; - let mut buf = [0u8; (4 + 8 + 4)]; - let mut net_packet = NetPacket::new(&mut buf)?; - net_packet.set_version(Version::V1); - net_packet.set_protocol(Protocol::Control); - net_packet.set_transport_protocol(control_packet::Protocol::Ping.into()); - net_packet.set_ttl(255); +fn start_idle_(idle: Idle, sender: Sender) -> io::Result<()> { loop { - let current_time = Local::now().timestamp_millis(); - { - let mut ping = PingPacket::new(net_packet.payload_mut())?; - ping.set_time(current_time); - let epoch = { DEVICE_LIST.lock().0 }; - ping.set_epoch(epoch); - } - let _ = udp.send_to(net_packet.buffer(), server_addr); - // 不clone会死锁？ - for x in DIRECT_ROUTE_TABLE.clone().iter() { - let virtual_ip = x.key().clone(); - let route = x.value().clone(); - drop(x); - if current_time - route.recv_time <= MAX_INTERVAL { - let _ = udp.send_to(net_packet.buffer(), route.address); - } else { - DIRECT_ROUTE_TABLE.remove_if(&virtual_ip, |_, route| { - current_time - route.recv_time > MAX_INTERVAL - }); - } - } - tokio::select! { - _ = sleep(Duration::from_millis(INTERVAL))=>{ - - } - status = status_watch.changed() =>{ - status?; - if *status_watch.borrow() != ApplicationStatus::Starting{ - return Ok(()) - } - } + let (idle_status, peer_ips, route) = idle.next_idle()?; + log::warn!("peer_ip:{:?},route:{:?},idle_status:{:?}",peer_ips,route,idle_status); + for peer_ip in peer_ips { + sender.remove_route(&peer_ip); } } } + +pub fn start_heartbeat(sender: Sender, device_list: Arc)>>, current_device: Arc>) { + thread::spawn(move || { + if let Err(e) = start_heartbeat_(sender, device_list, current_device) { + log::info!("空闲检测线程停止:{:?}",e); + } + }); +} + +fn start_heartbeat_(sender: Sender, device_list: Arc)>>, current_device: Arc>) -> io::Result<()> { + let mut net_packet = NetPacket::new([0u8; 16])?; + net_packet.set_version(Version::V1); + net_packet.set_protocol(Protocol::Control); + net_packet.set_transport_protocol(control_packet::Protocol::Ping.into()); + net_packet.first_set_ttl(MAX_TTL); + let mut count = 0; + loop { + let current_device = current_device.load(); + net_packet.set_source(current_device.virtual_ip()); + { + let current_time = Local::now().timestamp_millis() as u16; + let mut ping = PingPacket::new(net_packet.payload_mut())?; + ping.set_time(current_time); + let epoch = { device_list.lock().0 }; + ping.set_epoch(epoch); + } + if count < 7 || count % 7 == 0 { + let mut route_list: Option> = None; + let peer_list = device_list.lock().1.clone(); + for peer in peer_list { + net_packet.first_set_ttl(MAX_TTL); + net_packet.set_destination(peer.virtual_ip); + if sender.send_to_id(net_packet.buffer(), &peer.virtual_ip).is_err() { + //没有路由则发送到网关 + let _ = sender.send_to_addr(net_packet.buffer(), current_device.connect_server); + //再随机发送到其他地址，看有没有客户端符合转发条件 + let route_list = route_list.get_or_insert_with(|| { + let mut l = sender.route_table(); + l.shuffle(&mut rand::thread_rng()); + l + }); + let mut num = 0; + net_packet.first_set_ttl(2); + for (peer_ip, route) in route_list.iter() { + if peer_ip != &peer.virtual_ip && route.metric == 1 { + let _ = sender.send_to_route(net_packet.buffer(), &route.route_key()); + num += 1; + } + if num >= 3 { + break; + } + } + } + thread::sleep(Duration::from_millis(1)); + } + net_packet.set_destination(current_device.virtual_gateway()); + if let Err(e) = sender.send_to_addr(net_packet.buffer(), current_device.connect_server) { + log::warn!("connect_server:{:?},e:{:?}",current_device.connect_server,e); + } + } else { + for (peer_ip, route) in sender.route_table().iter() { + net_packet.set_destination(*peer_ip); + if let Err(e) = sender.send_to_route(net_packet.buffer(), &route.route_key()) { + log::warn!("peer_ip:{:?},route:{:?},e:{:?}",peer_ip,route,e); + } + thread::sleep(Duration::from_millis(1)); + } + } + + count += 1; + thread::sleep(Duration::from_millis(5000)); + } +} \ No newline at end of file diff --git a/switch/src/handle/mod.rs b/switch/src/handle/mod.rs index 5fef740..9e551f7 100644 --- a/switch/src/handle/mod.rs +++ b/switch/src/handle/mod.rs @@ -1,38 +1,17 @@ use std::net::{Ipv4Addr, SocketAddr}; -use std::sync::atomic::AtomicI64; -use std::time::Duration; - -use chrono::Local; -use dashmap::DashMap; -use lazy_static::lazy_static; -use moka::sync::Cache; -use parking_lot::{const_mutex, Mutex}; - -use crate::proto::message::NatType; pub mod heartbeat_handler; pub mod punch_handler; pub mod registration_handler; pub mod tun_handler; -pub mod udp_recv_handler; -lazy_static! { - /// 0. 机器纪元，每一次上线或者下线都会增1，由服务端维护，用于感知网络中机器变化 - /// 服务端和客户端的不一致，则服务端会推送新的设备列表 - /// 1. 网络中的虚拟ip列表 - pub static ref DEVICE_LIST:Mutex<(u32,Vec)> = const_mutex((0,Vec::new())); - /// 服务器延迟 - pub static ref SERVER_RT:AtomicI64 = AtomicI64::new(-1); - /// id - pub static ref ID:AtomicI64 = AtomicI64::new(0); - /// 直连路由表 - pub static ref DIRECT_ROUTE_TABLE:DashMap = DashMap::new(); - /// 地址映射 - pub static ref ADDR_TABLE:Cache = Cache::builder() - .time_to_idle(Duration::from_secs(60*5)).build(); - /// 当前设备的nat信息 - pub static ref NAT_INFO:Mutex> = const_mutex(None); - static ref NAT_TEST_ADDRESS:Mutex> = const_mutex(Vec::new()); +pub mod recv_handler; + +/// 是否在一个网段 +fn check_dest(dest: Ipv4Addr, virtual_netmask: Ipv4Addr, virtual_network: Ipv4Addr) -> bool { + u32::from_be_bytes(dest.octets()) & u32::from_be_bytes(virtual_netmask.octets()) + == u32::from_be_bytes(virtual_network.octets()) } + #[derive(Clone, Debug, Eq, PartialEq)] pub struct PeerDeviceInfo { pub virtual_ip: Ipv4Addr, @@ -74,82 +53,15 @@ impl From for PeerDeviceStatus { } } -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -pub enum ApplicationStatus { - Starting, - Stopping, -} - #[derive(Copy, Clone, Debug, Eq, PartialEq)] pub enum ConnectStatus { Connecting, Connected, } -impl Into for ConnectStatus { - fn into(self) -> u8 { - match self { - ConnectStatus::Connecting => 0, - ConnectStatus::Connected => 1, - } - } -} - -#[derive(Clone, Debug)] -pub struct NatInfo { - pub public_ips: Vec, - pub public_port: u16, - pub public_port_range: u16, - pub nat_type: NatType, -} - -impl NatInfo { - pub fn new( - public_ips: Vec, - public_port: u16, - public_port_range: u16, - nat_type: NatType, - ) -> Self { - Self { - public_ips, - public_port, - public_port_range, - nat_type, - } - } -} - -pub fn init_nat_test_addr(addrs: Vec) { - NAT_TEST_ADDRESS.lock().extend_from_slice(&addrs); -} - -/// 初始化nat信息 -pub fn init_nat_info(public_ip: u32, public_port: u16) { - let addrs = NAT_TEST_ADDRESS.lock().clone(); - match crate::nat::check::public_ip_list(&addrs) { - Ok((nat_type, ips, port_range)) => { - let mut public_ips = Vec::new(); - public_ips.push(public_ip); - for ip in ips { - let ip = u32::from_be_bytes(ip.octets()); - if ip != public_ip { - public_ips.push(ip); - } - } - let nat_info = NatInfo::new(public_ips, public_port, port_range, nat_type); - // println!("nat信息:{:?}",nat_info); - let mut nat_info_lock = NAT_INFO.lock(); - nat_info_lock.replace(nat_info); - } - Err(e) => { - println!("获取nat数据失败，将无法进行udp打洞:{:?}", e); - } - } -} - -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Debug, Eq, PartialEq)] pub struct CurrentDeviceInfo { - pub virtual_ip: Ipv4Addr, + virtual_ip: Ipv4Addr, pub virtual_gateway: Ipv4Addr, pub virtual_netmask: Ipv4Addr, //网络地址 @@ -182,40 +94,16 @@ impl CurrentDeviceInfo { connect_server, } } -} - -#[derive(Clone, Debug)] -pub struct Route { - pub route_type: RouteType, - pub address: SocketAddr, - //用心跳探测延迟，收包时更新 - pub rt: i64, - //收包时更新，如果太久没有收到消息则剔除 - pub recv_time: i64, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -pub enum RouteType { - ServerRelay, - P2P, -} - -impl Into for RouteType { - fn into(self) -> u8 { - match self { - RouteType::ServerRelay => 0, - RouteType::P2P => 1, - } + #[inline] + pub fn virtual_ip(&self) -> Ipv4Addr { + self.virtual_ip + } + #[inline] + pub fn virtual_gateway(&self) -> Ipv4Addr { + self.virtual_gateway } } -impl Route { - pub fn new(address: SocketAddr) -> Self { - Self { - route_type: RouteType::P2P, - address, - rt: -1, - recv_time: Local::now().timestamp_millis(), - } - } -} + + + diff --git a/switch/src/handle/punch_handler.rs b/switch/src/handle/punch_handler.rs index 9dd6902..f060249 100644 --- a/switch/src/handle/punch_handler.rs +++ b/switch/src/handle/punch_handler.rs @@ -1,401 +1,140 @@ -use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket}; -use std::time::Duration; use std::{io, thread}; - +use std::net::{IpAddr, Ipv4Addr}; +use std::sync::Arc; +use std::time::Duration; +use crossbeam::atomic::AtomicCell; +use parking_lot::Mutex; use protobuf::Message; use rand::prelude::SliceRandom; -use tokio::sync::mpsc::error::TrySendError; -use tokio::sync::mpsc::{Receiver, Sender}; -use tokio::sync::watch; +use p2p_channel::channel::sender::Sender; +use p2p_channel::punch::{NatInfo, NatType, Punch}; +use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo}; +use crate::nat::NatTest; +use crate::proto::message::{PunchInfo, PunchNatType}; +use crate::protocol::{control_packet, MAX_TTL, NetPacket, Protocol, turn_packet, Version}; -use crate::error::*; -use crate::handle::{ApplicationStatus, DIRECT_ROUTE_TABLE}; -use crate::proto::message::{NatType, Punch}; -use crate::protocol::control_packet::PunchRequestPacket; -use crate::protocol::turn_packet::TurnPacket; -use crate::protocol::{control_packet, turn_packet, NetPacket, Protocol, Version}; -use crate::{handle::NatInfo, handle::NAT_INFO, CurrentDeviceInfo, DEVICE_LIST}; - -/// 每一种类型一个通道，减少相互干扰 -pub fn bounded() -> ( - PunchSender, - ConeReceiver, - ReqSymmetricReceiver, - ResSymmetricReceiver, -) { - let (cone_sender, cone_receiver) = tokio::sync::mpsc::channel(3); - let (req_symmetric_sender, req_symmetric_receiver) = tokio::sync::mpsc::channel(1); - let (res_symmetric_sender, res_symmetric_receiver) = tokio::sync::mpsc::channel(1); - ( - PunchSender::new(cone_sender, req_symmetric_sender, res_symmetric_sender), - ConeReceiver(cone_receiver), - ReqSymmetricReceiver(req_symmetric_receiver), - ResSymmetricReceiver(res_symmetric_receiver), - ) -} - -pub struct ConeReceiver(Receiver); - -pub struct ReqSymmetricReceiver(Receiver); - -pub struct ResSymmetricReceiver(Receiver); - -#[derive(Clone)] -pub struct PunchSender { - cone_sender: Sender, - req_symmetric_sender: Sender, - res_symmetric_sender: Sender, -} - -impl PunchSender { - pub fn new( - cone_sender: Sender, - req_symmetric_sender: Sender, - res_symmetric_sender: Sender, - ) -> Self { - Self { - cone_sender, - req_symmetric_sender, - res_symmetric_sender, +pub fn start_cone(punch: Punch, current_device: Arc>) { + thread::spawn(move || { + if let Err(e) = start_(true, punch, current_device) { + log::warn!("锥形网络打洞处理线程停止 {:?}",e); } - } - // pub fn send(&self, punch: Punch) -> std::result::Result<(), SendError> { - // match punch.nat_type.enum_value_or_default() { - // NatType::Symmetric => { - // if punch.reply { - // // 为true表示回应，也就是主动发起的打洞操作 - // self.res_symmetric_sender.blocking_send(punch) - // } else { - // self.req_symmetric_sender.blocking_send(punch) - // } - // } - // NatType::Cone => { - // self.cone_sender.blocking_send(punch) - // } - // } - // } - pub fn try_send(&self, punch: Punch) -> std::result::Result<(), TrySendError> { - match punch.nat_type.enum_value_or_default() { - NatType::Symmetric => { - if punch.reply { - // 为true表示回应，也就是主动发起的打洞操作 - self.res_symmetric_sender.try_send(punch) - } else { - self.req_symmetric_sender.try_send(punch) - } + }); +} + +pub fn start_symmetric(punch: Punch, current_device: Arc>) { + thread::spawn(move || { + if let Err(e) = start_(false, punch, current_device) { + log::warn!("对称网络打洞处理线程停止 {:?}",e); + } + }); +} + +fn start_(is_cone: bool, mut punch: Punch, current_device: Arc>) -> io::Result<()> { + let mut packet = NetPacket::new([0u8; 12])?; + packet.set_version(Version::V1); + packet.first_set_ttl(1); + packet.set_protocol(Protocol::Control); + packet.set_transport_protocol(control_packet::Protocol::PunchRequest.into()); + loop { + let (peer_ip, nat_info) = if is_cone { + punch.next_cone(None)? + } else { + punch.next_symmetric(None)? + }; + if let Some(route) = punch.sender().route(&peer_ip) { + if route.metric == 1 { + //直连地址不需要打洞 + continue; } - NatType::Cone => self.cone_sender.try_send(punch), + } + packet.set_source(current_device.load().virtual_ip()); + packet.set_destination(peer_ip); + log::info!("发起打洞，目标:{:?},{:?}",peer_ip,nat_info); + if let Err(e) = punch.punch(packet.buffer(), peer_ip, nat_info) { + log::warn!("peer_ip:{:?},e:{:?}",peer_ip,e); } } } -fn handle( - _status_watch: &watch::Receiver, - udp: &UdpSocket, - punch_list: Vec, - buf: &[u8], -) -> Result<()> { - let mut counter = 0u64; - for punch in punch_list { - let dest = Ipv4Addr::from(punch.virtual_ip); - if DIRECT_ROUTE_TABLE.contains_key(&dest) { - continue; +pub fn start_punch(nat_test: NatTest, device_list: Arc)>>, sender: Sender, current_device: Arc>) { + thread::spawn(move || { + if let Err(e) = start_punch_(nat_test, device_list, sender, current_device) { + log::warn!("对称网络打洞处理线程停止 {:?}",e); } - // println!("punch {:?}", punch); - match punch.nat_type.enum_value_or_default() { - NatType::Symmetric => { - // 假设绑定n个端口，通过NAT对外映射出n个 公网ip:公网端口，随机尝试k次的情况下 - // 猜中的概率 p = 1-((65535-n)/65535)*((65535-n-1)/(65535-1))*...*((65535-n-k+1)/(65535-k+1)) - // n取76，k取600，猜中的概率就超过50%了 - let mut send_f = |min_port: u16, max_port: u16, k: usize| -> io::Result<()> { - let mut nums: Vec = (min_port..max_port).collect(); - nums.push(max_port); - let mut rng = rand::thread_rng(); - nums.shuffle(&mut rng); - for pub_ip in &punch.public_ip_list { - let pub_ip = Ipv4Addr::from(*pub_ip); - for port in &nums[..k] { - udp.send_to(buf, SocketAddr::V4(SocketAddrV4::new(pub_ip, *port)))?; - select_sleep(&mut counter); - } - } - Ok(()) - }; - if punch.public_port_range < 600 { - //端口变化不大时，在预测的范围内随机发送 - let min_port = if punch.public_port > punch.public_port_range { - punch.public_port - punch.public_port_range - } else { - 1 - }; - let max_port = if punch.public_port + punch.public_port_range > 65535 { - 65535 - } else { - punch.public_port + punch.public_port_range - }; - let k = if max_port - min_port + 1 > 60 { - 60 - } else { - max_port - min_port + 1 - }; - send_f(min_port as u16, max_port as u16, k as usize)?; + }); +} + +fn start_punch_(nat_test: NatTest, device_list: Arc)>>, sender: Sender, current_device: Arc>) -> crate::Result<()> { + loop { + if sender.is_close() { + return Ok(()); + } + let current_device = current_device.load(); + let nat_info = nat_test.nat_info(); + { + let mut list = device_list.lock().clone().1; + list.shuffle(&mut rand::thread_rng()); + let mut count = 0; + for info in list { + if info.virtual_ip <= current_device.virtual_ip { + continue; } - // 全端口范围，随机取600个端口发送 - send_f(1, 65535, 600)?; + if let Some(route) = sender.route(&info.virtual_ip) { + if route.metric == 1 { + //直连地址不需要打洞 + continue; + } + } + count += 1; + if count > 3 { + break; + } + let buf = punch_packet(current_device.virtual_ip(), &nat_info, info.virtual_ip)?; + sender.send_to_addr(&buf, current_device.connect_server)?; + } + } + match nat_info.nat_type { + NatType::Symmetric => { + thread::sleep(Duration::from_secs(28)); } NatType::Cone => { - for pub_ip in punch.public_ip_list { - udp.send_to( - buf, - SocketAddr::V4(SocketAddrV4::new( - Ipv4Addr::from(pub_ip), - punch.public_port as u16, - )), - )?; - select_sleep(&mut counter); - } - } - } - } - Ok(()) -} - -/// 给对称nat发送打洞数据包 -pub async fn req_symmetric_handler_start( - status_watch: watch::Receiver, - receiver: ReqSymmetricReceiver, - udp: UdpSocket, - cur_info: CurrentDeviceInfo, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - let receiver = receiver.0; - tokio::spawn(async move { - match handle_loop(status_watch, receiver, udp, cur_info).await { - Ok(_) => {} - Err(e) => { - log::warn!("{:?}", e) - } - } - stop_fn() - }); -} - -// pub fn req_symmetric_handle_loop( -// receiver: ReqSymmetricReceiver, -// udp: UdpSocket, -// cur_info: CurrentDeviceInfo, -// ) -> Result<()> { -// let receiver = receiver.0; -// handle_loop(receiver, udp, cur_info) -// } - -/// 给对称nat发送打洞数据包，处理主动发起的打洞操作 -pub async fn res_symmetric_handler_start( - status_watch: watch::Receiver, - receiver: ResSymmetricReceiver, - udp: UdpSocket, - cur_info: CurrentDeviceInfo, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - let receiver = receiver.0; - tokio::spawn(async move { - match res_symmetric_handle_loop(status_watch, receiver, udp, cur_info).await { - Ok(_) => {} - Err(e) => { - log::warn!("{:?}", e) - } - } - stop_fn() - }); -} - -async fn res_symmetric_handle_loop( - mut status_watch: watch::Receiver, - mut receiver: Receiver, - udp: UdpSocket, - cur_info: CurrentDeviceInfo, -) -> Result<()> { - let mut buf = [0u8; 12]; - let mut packet = NetPacket::new(&mut buf)?; - packet.set_version(Version::V1); - packet.set_ttl(255); - packet.set_protocol(Protocol::Control); - packet.set_transport_protocol(control_packet::Protocol::PunchRequest.into()); - { - let mut punch_packet = PunchRequestPacket::new(packet.payload_mut())?; - punch_packet.set_source(cur_info.virtual_ip); - } - loop { - tokio::select! { - rs = tokio::time::timeout(Duration::from_secs(20), receiver.recv()) =>{ - match rs { - Ok(punch) => { - if let Some(punch) = punch{ - let mut list = Vec::new(); - list.push(punch); - loop { - match receiver.try_recv() { - Ok(punch) => { - list.push(punch); - } - Err(_) => { - break; - } - } - } - if let Err(e) = handle(&status_watch,&udp, list, packet.buffer()) { - log::warn!("{:?}",e) - } - }else { - return Err(Error::Stop("打洞线程通道关闭".to_string())); - } - } - Err(_) => { - punch_request_handle(&udp, &cur_info)?; - } - } - } - status = status_watch.changed() =>{ - status?; - if *status_watch.borrow() != ApplicationStatus::Starting{ - return Ok(()) - } + thread::sleep(Duration::from_secs(20)); } } } } -/// 给锥形nat发送打洞数据包 -pub async fn cone_handler_start( - status_watch: watch::Receiver, - receiver: ConeReceiver, - udp: UdpSocket, - cur_info: CurrentDeviceInfo, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - let receiver = receiver.0; - tokio::spawn(async move { - match handle_loop(status_watch, receiver, udp, cur_info).await { - Ok(_) => {} - Err(e) => { - log::warn!("{:?}", e) - } - } - stop_fn(); - }); -} - -async fn handle_loop( - mut status_watch: watch::Receiver, - mut receiver: Receiver, - udp: UdpSocket, - cur_info: CurrentDeviceInfo, -) -> Result<()> { - let mut buf = [0u8; 12]; - let mut packet = NetPacket::new(&mut buf)?; - packet.set_version(Version::V1); - packet.set_ttl(255); - packet.set_protocol(Protocol::Control); - packet.set_transport_protocol(control_packet::Protocol::PunchRequest.into()); - { - let mut punch_packet = PunchRequestPacket::new(packet.payload_mut())?; - punch_packet.set_source(cur_info.virtual_ip); - } - loop { - tokio::select! { - punch = receiver.recv() =>{ - if let Some(punch) = punch{ - let mut list = Vec::new(); - list.push(punch); - loop { - match receiver.try_recv() { - Ok(punch) => { - list.push(punch); - } - Err(_) => { - break; - } - } - } - if let Err(e) = handle(&status_watch,&udp, list, packet.buffer()) { - log::warn!("{:?}",e) - } - }else { - return Err(Error::Stop("打洞线程通道关闭".to_string())); - } - } - status = status_watch.changed() =>{ - status?; - if *status_watch.borrow() != ApplicationStatus::Starting{ - return Ok(()) - } - } - } - } -} - -fn select_sleep(counter: &mut u64) { - *counter += 1; - if *counter & 10 == 10 { - thread::sleep(Duration::from_millis(2)); - } else { - thread::sleep(Duration::from_millis(1)); - } -} - -fn punch_request_handle(udp: &UdpSocket, cur_info: &CurrentDeviceInfo) -> Result<()> { - let nat_info_lock = NAT_INFO.lock(); - let nat_info = nat_info_lock.clone(); - drop(nat_info_lock); - if let Some(nat_info) = nat_info { - if let Err(e) = send_punch(&udp, &cur_info, nat_info) { - log::warn!("发送打洞数据失败 {:?}", e) - } - Ok(()) - } else { - Err(Error::Stop("未初始化nat信息".to_string())) - } -} - -fn send_punch(udp: &UdpSocket, cur_info: &CurrentDeviceInfo, nat_info: NatInfo) -> Result<()> { - let lock = DEVICE_LIST.lock(); - let list = lock.1.clone(); - drop(lock); - for peer_info in list { - let ip = peer_info.virtual_ip; - //只向ip比自己大的发起打洞，避免双方同时发起打洞浪费流量 - if ip > cur_info.virtual_ip && !DIRECT_ROUTE_TABLE.contains_key(&ip) { - log::info!("发起打洞 {:?}, peer_info:{:?}", nat_info, peer_info); - let bytes = punch_packet(cur_info.virtual_ip, nat_info.clone(), ip)?; - udp.send_to(&bytes, cur_info.connect_server)?; - } - } - Ok(()) -} - -fn punch_packet(virtual_ip: Ipv4Addr, nat_info: NatInfo, dest: Ipv4Addr) -> Result> { - let mut punch_reply = Punch::new(); +pub fn punch_packet(virtual_ip: Ipv4Addr, nat_info: &NatInfo, dest: Ipv4Addr) -> crate::Result> { + let mut punch_reply = PunchInfo::new(); punch_reply.reply = false; - punch_reply.virtual_ip = u32::from_be_bytes(virtual_ip.octets()); - punch_reply.public_ip_list = nat_info.public_ips; + punch_reply.public_ip_list = nat_info.public_ips.iter().map(|i| { + match i { + IpAddr::V4(ip) => { + u32::from_be_bytes(ip.octets()) + } + IpAddr::V6(_) => { + panic!() + } + } + }).collect(); punch_reply.public_port = nat_info.public_port as u32; punch_reply.public_port_range = nat_info.public_port_range as u32; - punch_reply.nat_type = protobuf::EnumOrUnknown::new(nat_info.nat_type); + punch_reply.local_ip = match nat_info.local_ip { + IpAddr::V4(ip) => u32::from_be_bytes(ip.octets()), + IpAddr::V6(_) => { + panic!() + } + }; + punch_reply.local_port = nat_info.local_port as u32; + punch_reply.nat_type = protobuf::EnumOrUnknown::new(PunchNatType::from(nat_info.nat_type)); let bytes = punch_reply.write_to_bytes()?; - let mut net_packet = NetPacket::new(vec![0u8; 4 + 8 + bytes.len()])?; + let mut net_packet = NetPacket::new(vec![0u8; 12 + bytes.len()])?; net_packet.set_version(Version::V1); net_packet.set_protocol(Protocol::OtherTurn); net_packet.set_transport_protocol(turn_packet::Protocol::Punch.into()); - net_packet.set_ttl(255); - let mut turn_packet = TurnPacket::new(net_packet.payload_mut())?; - turn_packet.set_source(virtual_ip); - turn_packet.set_destination(dest); - turn_packet.set_payload(&bytes); + net_packet.first_set_ttl(MAX_TTL); + net_packet.set_source(virtual_ip); + net_packet.set_destination(dest); + net_packet.set_payload(&bytes); Ok(net_packet.into_buffer()) -} +} \ No newline at end of file diff --git a/switch/src/handle/recv_handler.rs b/switch/src/handle/recv_handler.rs new file mode 100644 index 0000000..9388ce8 --- /dev/null +++ b/switch/src/handle/recv_handler.rs @@ -0,0 +1,382 @@ +use std::{io, thread}; +use std::net::{IpAddr, Ipv4Addr, SocketAddr}; +use std::sync::Arc; + +use chrono::Local; +use crossbeam::atomic::AtomicCell; +use crossbeam_skiplist::SkipMap; +use parking_lot::Mutex; +use protobuf::Message; + +use p2p_channel::channel::{Channel, Route, RouteKey}; +use p2p_channel::punch::NatInfo; +use packet::icmp::{icmp, Kind}; +use packet::ip::ipv4; +use packet::ip::ipv4::packet::IpV4Packet; + +use crate::error::Error; +use crate::handle::{check_dest, ConnectStatus, CurrentDeviceInfo, PeerDeviceInfo}; +use crate::handle::registration_handler::Register; +use crate::nat; +use crate::nat::NatTest; +use crate::proto::message::{DeviceList, PunchInfo, PunchNatType, RegistrationResponse}; +use crate::protocol::{control_packet, MAX_TTL, NetPacket, Protocol, service_packet, turn_packet, Version}; +use crate::protocol::control_packet::ControlPacket; +use crate::protocol::error_packet::InErrorPacket; +use crate::tun_device::TunWriter; + +pub fn start(mut handler: RecvHandler) { + thread::spawn(move || { + let mut buf = [0; 4096]; + loop { + match handler.channel.recv_from(&mut buf, None) { + Ok((len, route)) => { + if let Err(e) = handler.handle(&mut buf[..len], &route) { + log::warn!("数据处理失败:{:?},e:{:?}",route,e); + if let Error::Stop(_) = e { + let _ = handler.channel.close(); + break; + } + } + } + Err(e) => { + log::warn!("{:?}",e); + // 检查关闭状态 + if handler.channel.is_close() { + break; + } + } + } + } + }); +} + +pub struct RecvHandler { + channel: Channel, + current_device: Arc>, + device_list: Arc)>>, + register: Arc, + nat_test: NatTest, + tun_writer: TunWriter, + connect_status: Arc>, + peer_nat_info_map: Arc>, +} + +impl RecvHandler { + pub fn new(channel: Channel, + current_device: Arc>, + device_list: Arc)>>, + register: Arc, + nat_test: NatTest, + tun_writer: TunWriter, + connect_status: Arc>, + peer_nat_info_map: Arc>, + ) -> Self { + Self { + channel, + current_device, + device_list, + register, + nat_test, + tun_writer, + connect_status, + peer_nat_info_map, + } + } + pub fn try_clone(&self) -> io::Result { + Ok(Self { + channel: self.channel.try_clone()?, + current_device: self.current_device.clone(), + device_list: self.device_list.clone(), + register: self.register.clone(), + nat_test: self.nat_test.clone(), + tun_writer: self.tun_writer.clone(), + connect_status: self.connect_status.clone(), + peer_nat_info_map: self.peer_nat_info_map.clone(), + }) + } +} + +impl RecvHandler { + fn handle(&self, buf: &mut [u8], route_key: &RouteKey) -> crate::Result<()> { + let mut net_packet = NetPacket::new(buf)?; + if net_packet.ttl() == 0 { + return Ok(()); + } + let source = net_packet.source(); + let current_device = self.current_device.load(); + if source == current_device.virtual_ip() { + return Ok(()); + } + let destination = net_packet.destination(); + if current_device.virtual_ip() != destination && self.connect_status.load() == ConnectStatus::Connected { + if !check_dest(source, current_device.virtual_netmask, current_device.virtual_network) { + log::warn!("转发数据，源地址错误:{:?},当前网络:{:?},route_key:{:?}",source,current_device.virtual_network,route_key); + return Ok(()); + } + if !check_dest(destination, current_device.virtual_netmask, current_device.virtual_network) { + log::warn!("转发数据，目的地址错误:{:?},当前网络:{:?},route_key:{:?}",destination,current_device.virtual_network,route_key); + return Ok(()); + } + let ttl = net_packet.ttl(); + if ttl > 1 { + // 转发 + net_packet.set_ttl(ttl - 1); + if let Some(route) = self.channel.route(&destination) { + if route.metric <= net_packet.ttl() { + self.channel.send_to_route(net_packet.buffer(), &route.route_key())?; + } + } else if (ttl > 2 || destination == current_device.virtual_gateway()) + && source != current_device.virtual_gateway() { + //网关默认要转发一次，生存时间不够的发到网关也会被丢弃 + self.channel.send_to_addr(net_packet.buffer(), current_device.connect_server)?; + } + } + return Ok(()); + } + match net_packet.protocol() { + Protocol::Ipv4Turn => { + let mut ipv4 = IpV4Packet::new(net_packet.payload_mut())?; + if ipv4.protocol() == ipv4::protocol::Protocol::Icmp { + let mut icmp_packet = icmp::IcmpPacket::new(ipv4.payload_mut())?; + if icmp_packet.kind() == Kind::EchoRequest { + //开启ping + icmp_packet.set_kind(Kind::EchoReply); + icmp_packet.update_checksum(); + ipv4.set_source_ip(destination); + ipv4.set_destination_ip(source); + ipv4.update_checksum(); + net_packet.set_source(destination); + net_packet.set_destination(source); + self.channel.send_to_route(net_packet.buffer(), route_key)?; + return Ok(()); + } + } + self.tun_writer.write(net_packet.payload())?; + } + Protocol::Service => { + self.service(current_device, source, net_packet, route_key)?; + } + Protocol::Error => { + self.error(current_device, source, net_packet, route_key)?; + } + Protocol::Control => { + self.control(current_device, source, net_packet, route_key)?; + } + Protocol::OtherTurn => { + self.other_turn(current_device, source, net_packet, route_key)?; + } + Protocol::UnKnow(e) => { + log::info!("不支持的协议:{}",e); + } + } + Ok(()) + } + fn service(&self, current_device: CurrentDeviceInfo, source: Ipv4Addr, net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> { + if route_key.addr != current_device.connect_server || source != current_device.virtual_gateway() { + return Ok(()); + } + match service_packet::Protocol::from(net_packet.transport_protocol()) { + service_packet::Protocol::RegistrationRequest => {} + service_packet::Protocol::RegistrationResponse => { + let response = RegistrationResponse::parse_from_bytes(net_packet.payload())?; + let local_port = self.channel.local_addr()?.port(); + let local_ip = nat::local_ip()?; + let nat_info = self.nat_test.re_test(Ipv4Addr::from(response.public_ip), response.public_port as u16, local_ip, local_port); + self.channel.set_nat_type(nat_info.nat_type)?; + let new_ip = Ipv4Addr::from(response.virtual_ip); + let current_ip = current_device.virtual_ip(); + if current_ip != new_ip { + // ip发生变化 + log::info!("ip发生变化,old_ip:{:?},new_ip:{:?}",current_ip,new_ip); + let old_netmask = current_device.virtual_netmask; + let old_gateway = current_device.virtual_gateway(); + let virtual_ip = Ipv4Addr::from(response.virtual_ip); + let virtual_gateway = Ipv4Addr::from(response.virtual_gateway); + let virtual_netmask = Ipv4Addr::from(response.virtual_netmask); + self.tun_writer.change_ip(virtual_ip, virtual_netmask, virtual_gateway, old_netmask, old_gateway)?; + let new_current_device = CurrentDeviceInfo::new(virtual_ip, virtual_gateway, + virtual_netmask, current_device.connect_server); + if let Err(e) = self.current_device.compare_exchange(current_device, new_current_device) { + log::warn!("替换失败:{:?}",e); + } + } + self.connect_status.store(ConnectStatus::Connected); + } + service_packet::Protocol::PollDeviceList => {} + service_packet::Protocol::PushDeviceList => { + let device_list_t = DeviceList::parse_from_bytes(net_packet.payload())?; + let ip_list = device_list_t + .device_info_list + .into_iter() + .map(|info| { + PeerDeviceInfo::new( + Ipv4Addr::from(info.virtual_ip), + info.name, + info.device_status as u8, + ) + }) + .collect(); + let mut dev = self.device_list.lock(); + if dev.0 != device_list_t.epoch as u16 { + dev.0 = device_list_t.epoch as u16; + dev.1 = ip_list; + } + } + service_packet::Protocol::UnKnow(u) => { + log::warn!("未知服务协议:{}",u); + } + } + Ok(()) + } + fn error(&self, current_device: CurrentDeviceInfo, source: Ipv4Addr, net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> { + if route_key.addr != current_device.connect_server || source != current_device.virtual_gateway() { + return Ok(()); + } + match InErrorPacket::new(net_packet.transport_protocol(), net_packet.payload())? { + InErrorPacket::TokenError => { + return Err(Error::Stop("Token error".to_string())); + } + InErrorPacket::Disconnect => { + self.connect_status.store(ConnectStatus::Connecting); + self.register.fast_register()?; + } + InErrorPacket::AddressExhausted => { + //地址用尽 + return Err(Error::Stop("IP address has been exhausted".to_string())); + } + InErrorPacket::OtherError(e) => { + log::error!("OtherError {:?}", e.message()); + } + } + Ok(()) + } + fn control(&self, current_device: CurrentDeviceInfo, source: Ipv4Addr, mut net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> { + match ControlPacket::new(net_packet.transport_protocol(), net_packet.payload())? { + ControlPacket::PingPacket(_) => { + net_packet.set_transport_protocol(control_packet::Protocol::Pong.into()); + net_packet.set_source(current_device.virtual_ip()); + net_packet.set_destination(source); + net_packet.first_set_ttl(MAX_TTL); + self.channel.send_to_route(net_packet.buffer(), route_key)?; + } + ControlPacket::PongPacket(pong_packet) => { + let current_time = Local::now().timestamp_millis() as u16; + if current_time < pong_packet.time() { + return Ok(()); + } + let rt = (current_time - pong_packet.time()) as i64; + let metric = net_packet.source_ttl() - net_packet.ttl() + 1; + if let Some(current_route) = self.channel.route(&source) { + if ¤t_route.route_key() == route_key { + self.channel.update_route(&source, metric, rt); + } else if current_route.metric >= metric && current_route.rt > rt { + let route = Route::from(*route_key, metric, rt); + self.channel.add_route(source, route); + } + } else { + let route = Route::from(*route_key, metric, rt); + self.channel.add_route(source, route); + } + if route_key.addr == current_device.connect_server && source == current_device.virtual_gateway() { + let epoch = self.device_list.lock().0; + if pong_packet.epoch() != epoch { + let mut poll_device = NetPacket::new([0; 12])?; + poll_device.set_source(current_device.virtual_ip()); + poll_device.set_destination(source); + poll_device.set_version(Version::V1); + poll_device.first_set_ttl(MAX_TTL); + poll_device.set_protocol(Protocol::Service); + poll_device.set_transport_protocol(service_packet::Protocol::PollDeviceList.into()); + self.channel.send_to_route(poll_device.buffer(), route_key)?; + } + } + } + ControlPacket::PunchRequest => { + // log::info!("PunchRequest route_key:{:?}",route_key); + //回应 + net_packet.set_transport_protocol(control_packet::Protocol::PunchResponse.into()); + net_packet.set_source(current_device.virtual_ip()); + net_packet.set_destination(source); + net_packet.first_set_ttl(1); + self.channel.send_to_route(net_packet.buffer(), route_key)?; + let route = Route::from(*route_key, 1, -1); + self.channel.add_route(source, route); + } + ControlPacket::PunchResponse => { + // log::info!("PunchResponse route_key:{:?}",route_key); + let route = Route::from(*route_key, 1, -1); + self.channel.add_route(net_packet.source(), route); + } + } + Ok(()) + } + fn other_turn(&self, current_device: CurrentDeviceInfo, source: Ipv4Addr, net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> { + match turn_packet::Protocol::from(net_packet.transport_protocol()) { + turn_packet::Protocol::Punch => { + let punch_info = PunchInfo::parse_from_bytes(net_packet.payload())?; + let public_ips = punch_info.public_ip_list. + iter().map(|v| { IpAddr::from(v.to_be_bytes()) }).collect(); + let peer_nat_info = NatInfo::new(public_ips, + punch_info.public_port as u16, + punch_info.public_port_range as u16, + IpAddr::from(punch_info.local_ip.to_be_bytes()), + punch_info.local_port as u16, + punch_info.nat_type.enum_value_or_default().into()); + self.peer_nat_info_map.insert(source, peer_nat_info.clone()); + if !punch_info.reply { + let mut punch_reply = PunchInfo::new(); + punch_reply.reply = true; + let nat_info = self.nat_test.nat_info(); + punch_reply.public_ip_list = nat_info.public_ips.iter().map(|i| { + match i { + IpAddr::V4(ip) => { + u32::from_be_bytes(ip.octets()) + } + IpAddr::V6(_) => { + panic!() + } + } + }).collect(); + punch_reply.public_port = nat_info.public_port as u32; + punch_reply.public_port_range = nat_info.public_port_range as u32; + punch_reply.nat_type = + protobuf::EnumOrUnknown::new(PunchNatType::from(nat_info.nat_type)); + let bytes = punch_reply.write_to_bytes()?; + let mut net_packet = + NetPacket::new(vec![0u8; 12 + bytes.len()])?; + net_packet.set_version(Version::V1); + net_packet.set_protocol(Protocol::OtherTurn); + net_packet.set_transport_protocol( + turn_packet::Protocol::Punch.into(), + ); + net_packet.first_set_ttl(MAX_TTL); + net_packet.set_source(current_device.virtual_ip()); + net_packet.set_destination(source); + net_packet.set_payload(&bytes); + if !peer_nat_info.local_ip.is_unspecified() && peer_nat_info.local_port != 0 { + let mut packet = NetPacket::new([0u8; 12])?; + packet.set_version(Version::V1); + packet.first_set_ttl(1); + packet.set_protocol(Protocol::Control); + packet.set_transport_protocol(control_packet::Protocol::PunchRequest.into()); + packet.set_source(current_device.virtual_ip()); + packet.set_destination(source); + let _ = self.channel.send_to_addr(packet.buffer(), SocketAddr::new(peer_nat_info.local_ip, peer_nat_info.local_port)); + } + if let Err(e) = self.channel.punch(source, peer_nat_info) { + log::warn!("发送到打洞通道失败 {:?}",e); + return Ok(()); + } + self.channel.send_to_route(net_packet.buffer(), route_key)?; + } else { + let _ = self.channel.punch(source, peer_nat_info); + } + } + turn_packet::Protocol::UnKnow(e) => { + log::warn!("不支持的转发协议 {:?},source:{:?}",e,source); + } + } + Ok(()) + } +} \ No newline at end of file diff --git a/switch/src/handle/registration_handler.rs b/switch/src/handle/registration_handler.rs index b98ccfb..e6ed5d2 100644 --- a/switch/src/handle/registration_handler.rs +++ b/switch/src/handle/registration_handler.rs @@ -1,139 +1,136 @@ use std::io; -use std::net::{SocketAddr, UdpSocket}; +use std::net::{Ipv4Addr, SocketAddr}; use std::sync::atomic::{AtomicI64, Ordering}; use std::time::Duration; use chrono::Local; -use crossbeam::atomic::AtomicCell; -use parking_lot::RwLock; use protobuf::Message; +use p2p_channel::channel::Channel; +use p2p_channel::channel::sender::Sender; use crate::error::*; -use crate::handle::ConnectStatus; use crate::proto::message::{RegistrationRequest, RegistrationResponse}; use crate::protocol::error_packet::InErrorPacket; -use crate::protocol::{service_packet, NetPacket, Protocol, Version}; +use crate::protocol::{service_packet, NetPacket, Protocol, Version, MAX_TTL}; -lazy_static::lazy_static! { - static ref REQUEST:RwLock> = parking_lot::const_rwlock(None); - static ref REGISTRATION_TIME:AtomicI64=AtomicI64::new(0); - pub(crate) static ref CONNECTION_STATUS:AtomicCell = AtomicCell::new(ConnectStatus::Connecting); -} - -///向中继服务器注册，token标识一个虚拟网关，mac_address防止多次注册时得到的ip不一致 +///向中继服务器注册，token标识一个虚拟网关，device_id防止多次注册时得到的ip不一致 pub fn registration( - udp: &UdpSocket, + channel: &mut Channel, server_address: SocketAddr, token: String, - mac_address: String, + device_id: String, name: String, ) -> Result { - // todo 和服务器通信加密 let request_packet = - registration_request_packet(token.clone(), mac_address.clone(), name.clone(), false)?; + registration_request_packet(token.clone(), device_id.clone(), name.clone(), false)?; let buf = request_packet.buffer(); - let mut counter = 0; let mut recv_buf = [0u8; 10240]; - udp.set_read_timeout(Some(Duration::from_millis(500)))?; - loop { - counter += 1; - if counter & 10 == 10 { - return Err(Error::Stop("注册请求超时".to_string())); - } - udp.send_to(buf, server_address)?; - let (len, addr) = match udp.recv_from(&mut recv_buf) { - Ok(ok) => ok, - Err(e) => { - if e.kind() == io::ErrorKind::WouldBlock || e.kind() == io::ErrorKind::TimedOut { - continue; - } - return Err(Error::Io(e)); - } - }; - if server_address != addr { - continue; - } - let net_packet = NetPacket::new(&recv_buf[..len])?; - match net_packet.protocol() { - Protocol::Service => { - match service_packet::Protocol::from(net_packet.transport_protocol()) { - service_packet::Protocol::RegistrationResponse => { - let response = - RegistrationResponse::parse_from_bytes(net_packet.payload())?; - let _ = REQUEST.write().replace((token, mac_address, name)); - udp.set_read_timeout(None)?; - CONNECTION_STATUS.store(ConnectStatus::Connected); - return Ok(response); - } - _ => {} - } - } - Protocol::Error => { - return match InErrorPacket::new( - net_packet.transport_protocol(), - net_packet.payload(), - ) { - Ok(e) => match e { - InErrorPacket::TokenError => Err(Error::Stop("token错误".to_string())), - InErrorPacket::Disconnect => Err(Error::Stop("断开连接".to_string())), - InErrorPacket::AddressExhausted => Err(Error::Stop("地址用尽".to_string())), - InErrorPacket::OtherError(e) => match e.message() { - Ok(str) => Err(Error::Stop(str)), - Err(e) => Err(Error::Stop(format!("{:?}", e))), - }, - }, - Err(e) => Err(Error::Stop(format!("{:?}", e))), - }; - } - _ => { - return Err(Error::Stop(format!("数据错误：{:?}", net_packet))); - } - } + channel.send_to_addr(buf, server_address)?; + let (len, route) = channel.recv_from(&mut recv_buf, Some(Duration::from_millis(300)))?; + if server_address != route.addr { + return Err(Error::Warn(format!("数据来源错误：{:?}", route.addr))); } + let net_packet = NetPacket::new(&recv_buf[..len])?; + return match net_packet.protocol() { + Protocol::Service => { + match service_packet::Protocol::from(net_packet.transport_protocol()) { + service_packet::Protocol::RegistrationResponse => { + let response = + RegistrationResponse::parse_from_bytes(net_packet.payload())?; + Ok(response) + } + _ => { + Err(Error::Warn(format!("数据错误：{:?}", net_packet))) + } + } + } + Protocol::Error => { + match InErrorPacket::new( + net_packet.transport_protocol(), + net_packet.payload(), + ) { + Ok(e) => match e { + InErrorPacket::TokenError => Err(Error::Stop("token错误".to_string())), + InErrorPacket::Disconnect => Err(Error::Warn("断开连接".to_string())), + InErrorPacket::AddressExhausted => Err(Error::Stop("地址用尽".to_string())), + InErrorPacket::OtherError(e) => match e.message() { + Ok(str) => Err(Error::Warn(str)), + Err(e) => Err(Error::Warn(format!("{:?}", e))), + }, + }, + Err(e) => Err(Error::Warn(format!("{:?}", e))), + } + } + _ => { + Err(Error::Warn(format!("数据错误：{:?}", net_packet))) + } + }; } fn registration_request_packet( token: String, - mac_address: String, + device_id: String, name: String, is_fast: bool, -) -> Result>> { +) -> crate::Result>> { let mut request = RegistrationRequest::new(); request.token = token; - request.mac_address = mac_address; + request.device_id = device_id; request.name = name; request.is_fast = is_fast; let bytes = request.write_to_bytes()?; - let buf = vec![0u8; 4 + bytes.len()]; + let buf = vec![0u8; 12 + bytes.len()]; let mut net_packet = NetPacket::new(buf)?; net_packet.set_version(Version::V1); net_packet.set_protocol(Protocol::Service); net_packet.set_transport_protocol(service_packet::Protocol::RegistrationRequest.into()); - net_packet.set_ttl(255); + net_packet.first_set_ttl(MAX_TTL); net_packet.set_payload(&bytes); Ok(net_packet) } -pub fn fast_registration(udp: &UdpSocket, server_address: SocketAddr) -> Result<()> { - let last = REGISTRATION_TIME.load(Ordering::Relaxed); - let new = Local::now().timestamp_millis(); - if new - last < 2000 - || REGISTRATION_TIME +pub struct Register { + sender: Sender, + server_address: SocketAddr, + token: String, + device_id: String, + name: String, + time: AtomicI64, +} + +impl Register { + pub fn new(sender: Sender, + server_address: SocketAddr, + token: String, + device_id: String, + name: String, ) -> Self { + Self { + sender, + server_address, + token, + device_id, + name, + time: AtomicI64::new(0), + } + } + pub fn fast_register(&self) -> io::Result<()> { + let last = self.time.load(Ordering::Relaxed); + let new = Local::now().timestamp_millis(); + if new - last < 1000 + || self.time .compare_exchange(last, new, Ordering::Relaxed, Ordering::Relaxed) .is_err() - { - //短时间不重复注册 - return Ok(()); + { + //短时间不重复注册 + return Ok(()); + } + log::info!("重新连接"); + let request_packet = + registration_request_packet(self.token.clone(), + self.device_id.clone(), + self.name.clone(), false).unwrap(); + let buf = request_packet.buffer(); + self.sender.send_to_addr(buf, self.server_address)?; + Ok(()) } - CONNECTION_STATUS.store(ConnectStatus::Connecting); - let lock = REQUEST.read(); - let option = lock.clone(); - drop(lock); - if let Some((token, mac_address, name)) = option { - let request_packet = registration_request_packet(token, mac_address, name, true)?; - udp.send_to(request_packet.buffer(), server_address)?; - REGISTRATION_TIME.store(Local::now().timestamp_millis(), Ordering::Relaxed); - return Ok(()); - } - return Err(Error::Stop("注册信息不存在".to_string())); } diff --git a/switch/src/handle/tun_handler.rs b/switch/src/handle/tun_handler.rs index d3b20a4..ca2ae07 100644 --- a/switch/src/handle/tun_handler.rs +++ b/switch/src/handle/tun_handler.rs @@ -1,29 +1,22 @@ +use std::{io, thread}; /// 接收tun数据，并且转发到udp上 -use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; -use std::thread; - -use chrono::Local; -use tokio::sync::watch; +use std::net::Ipv4Addr; +use std::sync::Arc; +use crossbeam::atomic::AtomicCell; +use p2p_channel::channel::sender::Sender; use packet::icmp::icmp::IcmpPacket; use packet::icmp::Kind; use packet::ip::ipv4; use packet::ip::ipv4::packet::IpV4Packet; use crate::error::*; -use crate::handle::{CurrentDeviceInfo, DIRECT_ROUTE_TABLE}; -use crate::protocol::turn_packet::TurnPacket; -use crate::protocol::{NetPacket, Protocol, Version}; -use crate::tun_device::TunReader; -use crate::ApplicationStatus; +use crate::handle::{check_dest, CurrentDeviceInfo}; +use crate::protocol::{MAX_TTL, NetPacket, Protocol, Version}; +use crate::tun_device::{TunReader, TunWriter}; -/// 是否在一个网段 -fn check_dest(dest: Ipv4Addr, cur_info: &CurrentDeviceInfo) -> bool { - u32::from_be_bytes(dest.octets()) & u32::from_be_bytes(cur_info.virtual_netmask.octets()) - == u32::from_be_bytes(cur_info.virtual_network.octets()) -} -fn icmp(udp: &UdpSocket, mut ipv4_packet: IpV4Packet<&mut [u8]>) -> Result<()> { +fn icmp(tun_writer: &TunWriter, mut ipv4_packet: IpV4Packet<&mut [u8]>) -> Result<()> { if ipv4_packet.protocol() == ipv4::protocol::Protocol::Icmp { let mut icmp = IcmpPacket::new(ipv4_packet.payload_mut())?; if icmp.kind() == Kind::EchoRequest { @@ -33,21 +26,14 @@ fn icmp(udp: &UdpSocket, mut ipv4_packet: IpV4Packet<&mut [u8]>) -> Result<()> { ipv4_packet.set_source_ip(ipv4_packet.destination_ip()); ipv4_packet.set_destination_ip(src); ipv4_packet.update_checksum(); - let mut addr = udp.local_addr()?; - addr.set_ip(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))); - udp.send_to(ipv4_packet.buffer, addr)?; + tun_writer.write(ipv4_packet.buffer)?; } } Ok(()) } #[inline] -fn handle( - udp: &UdpSocket, - data: &mut [u8], - cur_info: &CurrentDeviceInfo, - net_packet: &mut NetPacket>, -) -> Result<()> { +fn handle(sender: &Sender, data: &mut [u8], tun_writer: &TunWriter, current_device: CurrentDeviceInfo, net_packet: &mut NetPacket>) -> Result<()> { let data_len = data.len(); let ipv4_packet = match IpV4Packet::new(data) { Ok(ipv4_packet) => ipv4_packet, @@ -63,73 +49,46 @@ fn handle( // // 137端口是在局域网中提供计算机的名字或IP地址查询服务 // return Ok(()); // } - if src_ip != cur_info.virtual_ip || !check_dest(dest_ip, &cur_info) { + if src_ip != current_device.virtual_ip() || !check_dest(dest_ip, current_device.virtual_netmask, current_device.virtual_network) { return Ok(()); } if src_ip == dest_ip { - return icmp(&udp, ipv4_packet); + return icmp(&tun_writer, ipv4_packet); } - let mut ipv4_turn_packet = TurnPacket::new(net_packet.payload_mut())?; - ipv4_turn_packet.set_source(src_ip); - ipv4_turn_packet.set_destination(dest_ip); - ipv4_turn_packet.set_payload(ipv4_packet.buffer); + net_packet.set_source(src_ip); + net_packet.set_destination(dest_ip); + net_packet.set_payload(ipv4_packet.buffer); //优先发到直连到地址 - if let Some(route) = DIRECT_ROUTE_TABLE.get(&dest_ip) { - let current_time = Local::now().timestamp_millis(); - if current_time - route.recv_time < 3_000 { - if udp - .send_to(&net_packet.buffer()[..(4 + 8 + data_len)], route.address) - .is_ok() - { - return Ok(()); - } - } + if sender.send_to_id(&net_packet.buffer()[..(12 + data_len)], &dest_ip).is_err() { + sender.send_to_addr(&net_packet.buffer()[..(12 + data_len)], current_device.connect_server)?; } - udp.send_to( - &net_packet.buffer()[..(4 + 8 + data_len)], - cur_info.connect_server, - )?; return Ok(()); } -#[cfg(target_os = "windows")] -pub async fn handler_start( - mut status_watch: watch::Receiver, - udp: UdpSocket, - tun_reader: TunReader, - cur_info: CurrentDeviceInfo, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - let session = tun_reader.0.clone(); - tokio::spawn(async move { - let _ = status_watch.changed().await; - session.shutdown(); - let udp = UdpSocket::bind("0.0.0.0:0").unwrap(); - let _ = udp.send_to( - &[0], - SocketAddr::new(IpAddr::V4(cur_info.virtual_gateway), 10), - ); - }); +pub fn start(sender: Sender, + tun_reader: TunReader, + tun_writer: TunWriter, + current_device: Arc>, ) { thread::spawn(move || { - if let Err(e) = handle_loop(udp, tun_reader, cur_info) { - log::warn!("tun数据处理线程停止 {:?}", e); + if let Err(e) = start_(sender, tun_reader, tun_writer, current_device) { + log::warn!("{:?}",e); } - stop_fn(); }); } #[cfg(target_os = "windows")] -fn handle_loop(udp: UdpSocket, tun_reader: TunReader, cur_info: CurrentDeviceInfo) -> Result<()> { +fn start_(sender: Sender, + tun_reader: TunReader, + tun_writer: TunWriter, + current_device: Arc>, ) -> io::Result<()> { let mut net_packet = NetPacket::new(vec![0u8; 4 + 8 + 1500])?; net_packet.set_version(Version::V1); net_packet.set_protocol(Protocol::Ipv4Turn); net_packet.set_transport_protocol(ipv4::protocol::Protocol::Ipv4.into()); - net_packet.set_ttl(255); + net_packet.set_ttl(MAX_TTL); loop { let mut data = tun_reader.next()?; - match handle(&udp, data.bytes_mut(), &cur_info, &mut net_packet) { + match handle(&sender, data.bytes_mut(), &tun_writer, current_device.load(), &mut net_packet) { Ok(_) => {} Err(e) => { log::warn!("{:?}", e) @@ -138,60 +97,24 @@ fn handle_loop(udp: UdpSocket, tun_reader: TunReader, cur_info: CurrentDeviceInf } } -#[cfg(any(target_os = "macos", target_os = "linux", target_os = "android"))] -pub async fn handler_start( - mut status_watch: watch::Receiver, - udp: UdpSocket, - tun_reader: TunReader, - cur_info: CurrentDeviceInfo, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - #[cfg(target_os = "macos")] - use std::os::fd::AsRawFd; - #[cfg(target_os = "linux")] - use std::os::unix::io::AsRawFd; - let raw_fd = tun_reader.0.as_raw_fd(); - tokio::spawn(async move { - let _ = status_watch.changed().await; - // 让tun接收线程关闭，问题：如果改变tun配置，可能导致tun接收线程无法关闭 - unsafe { - libc::close(raw_fd); - } - let udp = UdpSocket::bind("0.0.0.0:0").unwrap(); - let _ = udp.send_to( - &[0], - SocketAddr::new(IpAddr::V4(cur_info.virtual_gateway), 10), - ); - }); - thread::spawn(move || { - if let Err(e) = handle_loop(udp, tun_reader, cur_info) { - log::warn!(" tun数据处理线程停止 {:?}", e); - } - stop_fn(); - }); -} - -#[cfg(any(target_os = "macos", target_os = "linux", target_os = "android"))] -pub fn handle_loop( - udp: UdpSocket, - mut tun_reader: TunReader, - cur_info: CurrentDeviceInfo, -) -> Result<()> { +#[cfg(any(target_os = "linux",target_os = "macos"))] +fn start_(sender: Sender, + tun_reader: TunReader, + tun_writer: TunWriter, + current_device: Arc>, ) -> io::Result<()> { let mut net_packet = NetPacket::new(vec![0u8; 4 + 8 + 1500])?; net_packet.set_version(Version::V1); net_packet.set_protocol(Protocol::Ipv4Turn); - net_packet.set_transport_protocol(0); - net_packet.set_ttl(255); - let mut buf = [0u8; 1500]; + net_packet.set_transport_protocol(ipv4::protocol::Protocol::Ipv4.into()); + net_packet.set_ttl(MAX_TTL); + let mut buf = [0; 4096]; loop { let data = tun_reader.read(&mut buf)?; - match handle(&udp, data, &cur_info, &mut net_packet) { + match handle(&sender, data, &tun_writer, current_device.load(), &mut net_packet) { Ok(_) => {} Err(e) => { log::warn!("{:?}", e) } } } -} +} \ No newline at end of file diff --git a/switch/src/handle/udp_recv_handler.rs b/switch/src/handle/udp_recv_handler.rs deleted file mode 100644 index ef06650..0000000 --- a/switch/src/handle/udp_recv_handler.rs +++ /dev/null @@ -1,389 +0,0 @@ -use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; -use std::sync::atomic::Ordering; -use std::thread; - -use chrono::Local; -use packet::icmp::{icmp, Kind}; -use packet::ip::ipv4; -use packet::ip::ipv4::packet::IpV4Packet; -use protobuf::Message; -use tokio::sync::mpsc::error::TrySendError; -use tokio::sync::mpsc::{Receiver, Sender}; -use tokio::sync::watch; - -use crate::error::*; -use crate::handle::punch_handler::PunchSender; -use crate::handle::registration_handler::{fast_registration, CONNECTION_STATUS}; -use crate::handle::{ - ConnectStatus, Route, ADDR_TABLE, DEVICE_LIST, DIRECT_ROUTE_TABLE, NAT_INFO, SERVER_RT, -}; -use crate::proto::message::{DeviceList, Punch, RegistrationResponse}; -use crate::protocol::control_packet::{ControlPacket, PunchResponsePacket}; -use crate::protocol::error_packet::InErrorPacket; -use crate::protocol::turn_packet::TurnPacket; -use crate::protocol::{control_packet, service_packet, turn_packet, NetPacket, Protocol, Version}; -use crate::tun_device::TunWriter; -use crate::{ApplicationStatus, CurrentDeviceInfo, PeerDeviceInfo}; - -const UDP_STOP_BUF: [u8; 1] = [0u8]; - -pub async fn udp_recv_start( - mut status_watch: watch::Receiver, - udp: UdpSocket, - server_addr: SocketAddr, - other_sender: Sender<(SocketAddr, Vec)>, - tun_writer: TunWriter, - current_device: CurrentDeviceInfo, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - { - let udp = udp.try_clone().unwrap(); - tokio::spawn(async move { - let _ = status_watch.changed().await; - let mut addr = udp.local_addr().unwrap(); - addr.set_ip(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))); - udp.send_to(&UDP_STOP_BUF, addr).unwrap(); - }); - } - - thread::spawn(move || { - if let Err(e) = recv_loop(udp, server_addr, other_sender, tun_writer, current_device) { - log::warn!("udp数据处理线程停止 {:?}", e); - } - stop_fn(); - }); -} - -fn recv_loop( - udp: UdpSocket, - server_addr: SocketAddr, - other_sender: Sender<(SocketAddr, Vec)>, - mut tun_writer: TunWriter, - current_device: CurrentDeviceInfo, -) -> Result<()> { - let mut buf = [0u8; 65536]; - let mut local_addr = udp.local_addr()?; - local_addr.set_ip(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))); - loop { - match udp.recv_from(&mut buf) { - Ok((len, addr)) => { - if addr == local_addr { - if len == 1 && &buf[..len] == &UDP_STOP_BUF { - return Ok(()); - } - //本地的包直接再发到网卡，这个主要用于处理当前虚拟ip的icmp ping - if let Ok(ip) = IpV4Packet::new(&buf[..len]) { - if ip.destination_ip() == current_device.virtual_ip { - let _ = tun_writer.write(&buf[..len]); - } - } - continue; - } - match recv_handle( - &udp, - addr, - &mut buf[..len], - &server_addr, - &other_sender, - &mut tun_writer, - ¤t_device, - ) { - Ok(_) => {} - Err(Error::Stop(str)) => { - return Err(Error::Stop(str)); - } - Err(e) => { - log::warn!("{:?}", e); - } - } - } - Err(e) => { - log::warn!("{:?}", e); - } - }; - } -} - -fn recv_handle( - udp: &UdpSocket, - recv_addr: SocketAddr, - buf: &mut [u8], - _server_addr: &SocketAddr, - other_sender: &Sender<(SocketAddr, Vec)>, - tun_writer: &mut TunWriter, - current_device: &CurrentDeviceInfo, -) -> Result<()> { - let mut net_packet = NetPacket::new(buf)?; - match net_packet.protocol() { - Protocol::Ipv4Turn => { - let mut ipv4_turn_packet = TurnPacket::new(net_packet.payload_mut())?; - let source = ipv4_turn_packet.source(); - let destination = ipv4_turn_packet.destination(); - let mut ipv4 = IpV4Packet::new(ipv4_turn_packet.payload_mut())?; - if ipv4.source_ip() == source - && ipv4.destination_ip() == destination - && current_device.virtual_ip == ipv4.destination_ip() - { - if ipv4.protocol() == ipv4::protocol::Protocol::Icmp { - let mut icmp_packet = icmp::IcmpPacket::new(ipv4.payload_mut())?; - if icmp_packet.kind() == Kind::EchoRequest { - //开启ping - icmp_packet.set_kind(Kind::EchoReply); - icmp_packet.update_checksum(); - ipv4.set_source_ip(destination); - ipv4.set_destination_ip(source); - ipv4.update_checksum(); - ipv4_turn_packet.set_source(destination); - ipv4_turn_packet.set_destination(source); - udp.send_to(net_packet.buffer(), recv_addr)?; - } else { - tun_writer.write(ipv4_turn_packet.payload())?; - } - } else { - tun_writer.write(ipv4_turn_packet.payload())?; - } - } - } - Protocol::UnKnow(_) => {} - _ => { - //发送到子线程处理 - let v = net_packet.buffer().to_vec(); - match other_sender.try_send((recv_addr, v)) { - Ok(_) => {} - Err(TrySendError::Closed(_)) => { - return Err(Error::Stop("子处理线程停止".to_string())); - } - Err(e) => { - log::warn!("子线程处理 {:?}", e); - } - } - } - } - Ok(()) -} - -pub async fn udp_other_recv_start( - status_watch: watch::Receiver, - udp: UdpSocket, - receiver: Receiver<(SocketAddr, Vec)>, - current_device: CurrentDeviceInfo, - sender: PunchSender, - stop_fn: F, -) where - F: FnOnce() + Send + 'static, -{ - tokio::spawn(async move { - match other_loop(status_watch, udp, receiver, current_device, sender).await { - Ok(_) => { - log::info!("udp子处理线程停止"); - } - Err(e) => { - log::warn!("{:?}", e); - } - } - stop_fn(); - }); -} - -async fn other_loop( - mut status_watch: watch::Receiver, - udp: UdpSocket, - mut receiver: Receiver<(SocketAddr, Vec)>, - current_device: CurrentDeviceInfo, - sender: PunchSender, -) -> Result<()> { - loop { - tokio::select! { - rs = receiver.recv()=>{ - if let Some((peer_addr, buf)) = rs { - match other_handle(&udp, buf, peer_addr, ¤t_device, &sender) { - Ok(_) => {} - Err(Error::Stop(str)) => { - return Err(Error::Stop(str)); - } - Err(e) => { - log::warn!("other_loop {:?}",e); - } - } - } - } - status = status_watch.changed() =>{ - status?; - if *status_watch.borrow() != ApplicationStatus::Starting{ - return Ok(()) - } - } - } - } -} - -fn other_handle( - udp: &UdpSocket, - buf: Vec, - peer_addr: SocketAddr, - current_device: &CurrentDeviceInfo, - sender: &PunchSender, -) -> Result<()> { - let server_addr = current_device.connect_server; - let mut net_packet = NetPacket::new(buf)?; - match net_packet.protocol() { - Protocol::Service => { - if peer_addr != current_device.connect_server { - return Ok(()); - } - match service_packet::Protocol::from(net_packet.transport_protocol()) { - service_packet::Protocol::RegistrationRequest => {} - service_packet::Protocol::RegistrationResponse => { - let response = RegistrationResponse::parse_from_bytes(net_packet.payload())?; - crate::handle::init_nat_info(response.public_ip, response.public_port as u16); - CONNECTION_STATUS.store(ConnectStatus::Connected); - //需要保证重连ip不变 - } - service_packet::Protocol::UpdateDeviceList => { - let device_list = DeviceList::parse_from_bytes(net_packet.payload())?; - let ip_list = device_list - .device_info_list - .into_iter() - .map(|info| { - PeerDeviceInfo::new( - Ipv4Addr::from(info.virtual_ip), - info.name, - info.device_status as u8, - ) - }) - .collect(); - let mut dev = DEVICE_LIST.lock(); - if dev.0 < device_list.epoch || device_list.epoch - dev.0 > u32::MAX >> 2 { - dev.0 = device_list.epoch; - dev.1 = ip_list; - } - } - service_packet::Protocol::UnKnow(_) => {} - } - } - Protocol::Error => { - match InErrorPacket::new(net_packet.transport_protocol(), net_packet.payload())? { - InErrorPacket::TokenError => { - if server_addr == peer_addr { - //停止整个应用 - return Err(Error::Stop("token无效".to_string())); - } - } - InErrorPacket::Disconnect => { - if server_addr == peer_addr { - fast_registration(&udp, server_addr)?; - } - } - InErrorPacket::AddressExhausted => { - return Err(Error::Stop("IP address has been exhausted".to_string())); - } - InErrorPacket::OtherError(e) => { - log::error!("OtherError {:?}", e.message()); - } - } - } - Protocol::Control => { - match ControlPacket::new(net_packet.transport_protocol(), net_packet.payload())? { - ControlPacket::PingPacket(_ping) => { - net_packet.set_transport_protocol(control_packet::Protocol::Pong.into()); - udp.send_to(&net_packet.buffer()[..12], peer_addr)?; - } - ControlPacket::PongPacket(pong_packet) => { - let current_time = Local::now().timestamp_millis(); - let rt = current_time - pong_packet.time(); - if rt >= 0 { - if peer_addr == server_addr { - SERVER_RT.store(rt, Ordering::Relaxed) - } else { - //其他设备 - if let Some(virtual_ip) = ADDR_TABLE.get(&peer_addr) { - if let Some(mut info) = DIRECT_ROUTE_TABLE.get_mut(&virtual_ip) { - info.rt = rt; - info.recv_time = current_time; - } - } - } - } - } - ControlPacket::PunchRequest(punch_request) => { - // println!("打洞请求:{:?}", punch_request); - let src = punch_request.source(); - drop(punch_request); - //回应 - let mut punch_response = PunchResponsePacket::new(net_packet.payload_mut())?; - punch_response.set_source(current_device.virtual_ip); - net_packet - .set_transport_protocol(control_packet::Protocol::PunchResponse.into()); - udp.send_to(net_packet.buffer(), peer_addr)?; - let route = Route::new(peer_addr); - DIRECT_ROUTE_TABLE.insert(src, route); - ADDR_TABLE.insert(peer_addr, src); - } - ControlPacket::PunchResponse(punch_response) => { - // println!("打洞响应:{:?}", punch_response); - let route = Route::new(peer_addr); - DIRECT_ROUTE_TABLE.insert(punch_response.source(), route); - ADDR_TABLE.insert(peer_addr, punch_response.source()); - } - } - } - Protocol::Ipv4Turn => {} - Protocol::OtherTurn => { - let turn_packet = TurnPacket::new(net_packet.payload())?; - // println!("{:?}",turn_packet); - let src = turn_packet.source(); - let dest = turn_packet.destination(); - if dest == current_device.virtual_ip { - match turn_packet::Protocol::from(net_packet.transport_protocol()) { - turn_packet::Protocol::Punch => { - let punch = Punch::parse_from_bytes(turn_packet.payload())?; - if punch.virtual_ip.to_be_bytes() == src.octets() { - if !punch.reply { - let mut punch_reply = Punch::new(); - punch_reply.reply = true; - punch_reply.virtual_ip = - u32::from_be_bytes(current_device.virtual_ip.octets()); - if let Err(_) = sender.try_send(punch) { - return Ok(()); - } - let nat_info = NAT_INFO.lock(); - if let Some(info) = nat_info.as_ref() { - punch_reply.public_ip_list = info.public_ips.clone(); - punch_reply.public_port = info.public_port as u32; - punch_reply.public_port_range = info.public_port_range as u32; - punch_reply.nat_type = - protobuf::EnumOrUnknown::new(info.nat_type); - drop(nat_info); - let bytes = punch_reply.write_to_bytes()?; - let mut net_packet = - NetPacket::new(vec![0u8; 4 + 8 + bytes.len()])?; - net_packet.set_version(Version::V1); - net_packet.set_protocol(Protocol::OtherTurn); - net_packet.set_transport_protocol( - turn_packet::Protocol::Punch.into(), - ); - net_packet.set_ttl(255); - let mut turn_packet = - TurnPacket::new(net_packet.payload_mut())?; - turn_packet.set_source(current_device.virtual_ip); - turn_packet.set_destination(src); - turn_packet.set_payload(&bytes); - udp.send_to(net_packet.buffer(), peer_addr)?; - } - } else { - let _ = sender.try_send(punch); - } - } - } - turn_packet::Protocol::UnKnow(_) => {} - } - } - } - Protocol::UnKnow(p) => { - log::warn!("未知协议 {}", p); - } - } - Ok(()) -} diff --git a/switch/src/lib.rs b/switch/src/lib.rs index 69e28b1..faa979c 100644 --- a/switch/src/lib.rs +++ b/switch/src/lib.rs @@ -1,21 +1,9 @@ -use std::io; -use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket}; -use std::sync::atomic::Ordering; -use std::sync::Arc; -use std::time::Duration; +use crate::error::Error; -use crossbeam::atomic::AtomicCell; -use crossbeam::sync::WaitGroup; -use parking_lot::Mutex; -use tokio::sync::watch; -use error::*; +pub use p2p_channel::channel::{Route, RouteKey}; -use crate::handle::registration_handler::CONNECTION_STATUS; -use crate::handle::{ - ApplicationStatus, ConnectStatus, CurrentDeviceInfo, NatInfo, PeerDeviceInfo, Route, RouteType, - DEVICE_LIST, DIRECT_ROUTE_TABLE, NAT_INFO, SERVER_RT, -}; +pub type Result = std::result::Result; pub mod error; pub mod handle; @@ -23,353 +11,4 @@ pub mod nat; pub mod proto; pub mod protocol; pub mod tun_device; - -#[derive(Clone, Debug)] -pub struct Config { - pub token: String, - pub mac_address: String, - pub name: String, - pub server_address: SocketAddr, - pub nat_test_server: Vec, - pub abnormal_call: F, -} - -impl Config { - pub fn new( - token: String, - mac_address: String, - name: Option, - server_address: SocketAddr, - nat_test_server: Vec, - abnormal_call: F, - ) -> Result - where - F: FnOnce() + Send + 'static, - { - if token.is_empty() || token.len() > 64 { - return Err(Error::Stop("token invalid".to_string())); - } - if mac_address.len() != 12 + 5 { - return Err(Error::Stop("mac_address invalid".to_string())); - } - if let Some(name) = name { - if name.is_empty() || name.len() > 64 { - return Err(Error::Stop("name invalid".to_string())); - } - Ok(Self { - token, - mac_address, - name, - server_address, - nat_test_server, - abnormal_call, - }) - } else { - let info = os_info::get(); - let name = if info.version() != &os_info::Version::Unknown { - format!("{} {}", info.os_type(), info.version()) - } else { - format!("{}", info.os_type()) - }; - Ok(Self { - token, - mac_address, - name, - server_address, - nat_test_server, - abnormal_call, - }) - } - } -} - -pub struct Switch { - current_device: CurrentDeviceInfo, - status_sender: Arc>>, - wait_group: WaitGroup, - runtime: Option, -} - -impl Switch { - pub fn start(config: Config) -> Result - where - F: FnOnce() + Send + 'static, - { - let runtime = tokio::runtime::Builder::new_multi_thread() - .enable_all() - .build() - .unwrap(); - return match runtime.block_on(Switch::start_(config)) { - Ok(mut switch) => { - switch.runtime = Some(runtime); - Ok(switch) - } - Err(e) => Err(e), - }; - } - pub fn stop(self) { - Self::call_stop(self.status_sender); - self.wait_group.wait(); - } - pub fn stop_async(&self) { - Self::call_stop(self.status_sender.clone()); - } - pub fn current_device(&self) -> &CurrentDeviceInfo { - &self.current_device - } - pub fn nat_info(&self) -> Option { - NAT_INFO.lock().clone() - } - pub fn server_rt(&self) -> i64 { - SERVER_RT.load(Ordering::Relaxed) - } - pub fn connection_status(&self) -> ConnectStatus { - CONNECTION_STATUS.load() - } - pub fn device_list(&self) -> Vec { - let device_list_lock = DEVICE_LIST.lock(); - let (_epoch, device_list) = device_list_lock.clone(); - drop(device_list_lock); - device_list - } - pub fn route(&self, ip: &Ipv4Addr) -> Route { - if let Some(route_ref) = DIRECT_ROUTE_TABLE.get(ip) { - route_ref.value().clone() - } else { - let mut route = Route::new(self.current_device.connect_server); - route.route_type = RouteType::ServerRelay; - route.rt = self.server_rt() * 2; - route.recv_time = -1; - route - } - } -} - -impl Switch { - fn call_stop(status_sender: Arc>>) -> bool { - let lock = status_sender.lock(); - let status = lock.send_replace(ApplicationStatus::Stopping); - return status == ApplicationStatus::Starting; - } - pub async fn start_(config: Config) -> Result - where - F: FnOnce() + Send + 'static, - { - // let server_address = "nat1.wherewego.top:29876" - // let server_address = "nat1.wherewego.top:29875".to_socket_addrs().unwrap().next().unwrap(); - let server_address = config.server_address; - let mut port = 101 as u16; - let udp = loop { - match UdpSocket::bind(SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from(0), port))) { - Ok(udp) => { - break udp; - } - Err(e) => { - if e.kind() == io::ErrorKind::AddrInUse { - port += 1; - } else { - log::error!("创建udp失败 {:?}", e); - return Err(Error::Stop("udp bind error".to_string())); - } - } - } - }; - udp.set_write_timeout(Some(Duration::from_millis(2000)))?; - //注册 - let response = handle::registration_handler::registration( - &udp, - server_address, - config.token, - config.mac_address, - config.name, - )?; - { - let ip_list = response - .device_info_list - .into_iter() - .map(|info| { - PeerDeviceInfo::new( - Ipv4Addr::from(info.virtual_ip), - info.name, - info.device_status as u8, - ) - }) - .collect(); - let mut dev = DEVICE_LIST.lock(); - dev.0 = response.epoch; - dev.1 = ip_list; - } - let virtual_ip = Ipv4Addr::from(response.virtual_ip); - let virtual_gateway = Ipv4Addr::from(response.virtual_gateway); - let virtual_netmask = Ipv4Addr::from(response.virtual_netmask); - let (status_sender, status_receiver) = watch::channel(ApplicationStatus::Starting); - let current_device = - CurrentDeviceInfo::new(virtual_ip, virtual_gateway, virtual_netmask, server_address); - let wait_group = WaitGroup::new(); - let status_sender = Arc::new(parking_lot::const_mutex(status_sender)); - let call = Arc::new(AtomicCell::new(Some(config.abnormal_call))); - //心跳线程 - { - let udp = udp.try_clone()?; - let wait_group1 = wait_group.clone(); - let status_sender1 = status_sender.clone(); - let call1 = call.clone(); - handle::heartbeat_handler::start( - status_receiver.clone(), - udp, - current_device, - move || { - if Self::call_stop(status_sender1) { - if let Some(call) = call1.take() { - call(); - } - } - drop(wait_group1); - }, - ) - .await; - } - //初始化nat数据 - handle::init_nat_test_addr(config.nat_test_server); - handle::init_nat_info(response.public_ip, response.public_port as u16); - // tun服务 - let (tun_writer, tun_reader) = - tun_device::create_tun(virtual_ip, virtual_netmask, virtual_gateway)?; - // 打洞数据通道 - let (punch_sender, cone_receiver, req_symmetric_receiver, res_symmetric_receiver) = - handle::punch_handler::bounded(); - //udp数据处理 - { - // 低优先级的udp数据通道 - let (sender, receiver) = tokio::sync::mpsc::channel(50); - let udp1 = udp.try_clone()?; - let wait_group1 = wait_group.clone(); - let status_sender1 = status_sender.clone(); - let call1 = call.clone(); - handle::udp_recv_handler::udp_recv_start( - status_receiver.clone(), - udp1, - server_address, - sender, - tun_writer, - current_device, - move || { - if Self::call_stop(status_sender1) { - if let Some(call) = call1.take() { - call(); - } - } - drop(wait_group1); - }, - ) - .await; - let udp1 = udp.try_clone()?; - let wait_group1 = wait_group.clone(); - let status_sender1 = status_sender.clone(); - let call1 = call.clone(); - handle::udp_recv_handler::udp_other_recv_start( - status_receiver.clone(), - udp1, - receiver, - current_device, - punch_sender, - move || { - if Self::call_stop(status_sender1) { - if let Some(call) = call1.take() { - call(); - } - } - drop(wait_group1); - }, - ) - .await; - } - //打洞处理 - { - let udp1 = udp.try_clone()?; - let wait_group1 = wait_group.clone(); - let status_sender1 = status_sender.clone(); - let call1 = call.clone(); - handle::punch_handler::cone_handler_start( - status_receiver.clone(), - cone_receiver, - udp1, - current_device, - move || { - if Self::call_stop(status_sender1) { - if let Some(call) = call1.take() { - call(); - } - } - drop(wait_group1); - }, - ) - .await; - let udp1 = udp.try_clone()?; - let wait_group1 = wait_group.clone(); - let status_sender1 = status_sender.clone(); - let call1 = call.clone(); - handle::punch_handler::req_symmetric_handler_start( - status_receiver.clone(), - req_symmetric_receiver, - udp1, - current_device, - move || { - if Self::call_stop(status_sender1) { - if let Some(call) = call1.take() { - call(); - } - } - drop(wait_group1); - }, - ) - .await; - let udp1 = udp.try_clone()?; - let wait_group1 = wait_group.clone(); - let status_sender1 = status_sender.clone(); - let call1 = call.clone(); - handle::punch_handler::res_symmetric_handler_start( - status_receiver.clone(), - res_symmetric_receiver, - udp1, - current_device, - move || { - if Self::call_stop(status_sender1) { - if let Some(call) = call1.take() { - call(); - } - } - drop(wait_group1); - }, - ) - .await; - } - //tun数据处理 - { - let wait_group1 = wait_group.clone(); - let status_sender1 = status_sender.clone(); - let call1 = call.clone(); - handle::tun_handler::handler_start( - status_receiver.clone(), - udp, - tun_reader, - current_device, - move || { - if Self::call_stop(status_sender1) { - if let Some(call) = call1.take() { - call(); - } - } - drop(wait_group1); - }, - ) - .await; - } - Ok(Switch { - current_device, - status_sender, - wait_group, - runtime: None, - }) - } -} +pub mod core; diff --git a/switch/src/nat/check.rs b/switch/src/nat/check.rs index 9fa98be..d53f2e9 100644 --- a/switch/src/nat/check.rs +++ b/switch/src/nat/check.rs @@ -2,8 +2,8 @@ use std::collections::HashSet; use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; use std::time::Duration; use std::{io, thread}; +use p2p_channel::punch::NatType; -use crate::proto::message::NatType; // #[derive(Debug, Copy, Clone, PartialEq)] // pub enum NatType { @@ -79,9 +79,6 @@ pub fn public_ip_list_( for addr in addrs { let _ = udp.send_to(b"NatTest", addr)?; } - // let _ = udp.send_to(b"NatTest", "nat1.wherewego.top:35062")?; - // let _ = udp.send_to(b"NatTest", "nat2.wherewego.top:35061")?; - // let _ = udp.send_to(b"NatTest", "nat2.wherewego.top:35062")?; let mut hash_set = HashSet::new(); let mut count = 0; let mut min_port = 65535; @@ -99,7 +96,6 @@ pub fn public_ip_list_( max_port = port; } let ip = Ipv4Addr::new(buf[10], buf[11], buf[12], buf[13]); - // println!("pub {:?}:{}", ip, port); hash_set.insert(ip); count += 1; } diff --git a/switch/src/nat/mod.rs b/switch/src/nat/mod.rs index 3e8ff0f..81c3dfb 100644 --- a/switch/src/nat/mod.rs +++ b/switch/src/nat/mod.rs @@ -1 +1,87 @@ +use std::io; +use std::net::{IpAddr, Ipv4Addr, SocketAddr}; +use std::sync::Arc; +use parking_lot::Mutex; +use p2p_channel::punch::{NatInfo, NatType}; +use crate::proto::message::PunchNatType; + pub mod check; + +use std::net::UdpSocket; + +pub fn local_ip() -> io::Result { + let socket = UdpSocket::bind("0.0.0.0:0")?; + socket.connect("8.8.8.8:80")?; + let addr = socket.local_addr()?; + Ok(addr.ip()) +} + +#[derive(Clone)] +pub struct NatTest { + nat_test_server: Arc>, + info: Arc>, +} + +impl From for PunchNatType { + fn from(value: NatType) -> Self { + match value { + NatType::Symmetric => PunchNatType::Symmetric, + NatType::Cone => PunchNatType::Cone + } + } +} + +impl Into for PunchNatType { + fn into(self) -> NatType { + match self { + PunchNatType::Symmetric => NatType::Symmetric, + PunchNatType::Cone => NatType::Cone + } + } +} + +impl NatTest { + pub fn new(nat_test_server: Vec, public_ip: Ipv4Addr, public_port: u16, local_ip: IpAddr, local_port: u16) -> NatTest { + let info = NatTest::re_test_(&nat_test_server, public_ip, public_port, local_ip, local_port); + NatTest { + nat_test_server: Arc::new(nat_test_server), + info: Arc::new(Mutex::new(info)), + } + } + pub fn nat_info(&self) -> NatInfo { + self.info.lock().clone() + } + pub fn re_test(&self, public_ip: Ipv4Addr, public_port: u16, local_ip: IpAddr, local_port: u16) -> NatInfo { + let info = NatTest::re_test_(&self.nat_test_server, public_ip, public_port, local_ip, local_port); + *self.info.lock() = info.clone(); + info + } + fn re_test_(nat_test_server: &Vec, public_ip: Ipv4Addr, public_port: u16, local_ip: IpAddr, local_port: u16) -> NatInfo { + return match check::public_ip_list(nat_test_server) { + Ok((nat_type, ips, port_range)) => { + let mut public_ips = Vec::new(); + public_ips.push(IpAddr::from(public_ip)); + for ip in ips { + if ip != public_ip { + public_ips.push(IpAddr::from(ip)); + } + } + NatInfo::new(public_ips, + public_port, + port_range, + local_ip, local_port, + nat_type, ) + } + Err(e) => { + log::warn!("{:?}",e); + NatInfo::new( + vec![IpAddr::from(public_ip)], + public_port, + 0, + local_ip, local_port, + NatType::Cone, + ) + } + }; + } +} \ No newline at end of file diff --git a/switch/src/proto/message.rs b/switch/src/proto/message.rs index b335bb3..7164962 100644 --- a/switch/src/proto/message.rs +++ b/switch/src/proto/message.rs @@ -31,8 +31,8 @@ pub struct RegistrationRequest { // message fields // @@protoc_insertion_point(field:RegistrationRequest.token) pub token: ::std::string::String, - // @@protoc_insertion_point(field:RegistrationRequest.mac_address) - pub mac_address: ::std::string::String, + // @@protoc_insertion_point(field:RegistrationRequest.device_id) + pub device_id: ::std::string::String, // @@protoc_insertion_point(field:RegistrationRequest.name) pub name: ::std::string::String, // @@protoc_insertion_point(field:RegistrationRequest.is_fast) @@ -62,9 +62,9 @@ impl RegistrationRequest { |m: &mut RegistrationRequest| { &mut m.token }, )); fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( - "mac_address", - |m: &RegistrationRequest| { &m.mac_address }, - |m: &mut RegistrationRequest| { &mut m.mac_address }, + "device_id", + |m: &RegistrationRequest| { &m.device_id }, + |m: &mut RegistrationRequest| { &mut m.device_id }, )); fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( "name", @@ -98,7 +98,7 @@ impl ::protobuf::Message for RegistrationRequest { self.token = is.read_string()?; }, 18 => { - self.mac_address = is.read_string()?; + self.device_id = is.read_string()?; }, 26 => { self.name = is.read_string()?; @@ -121,8 +121,8 @@ impl ::protobuf::Message for RegistrationRequest { if !self.token.is_empty() { my_size += ::protobuf::rt::string_size(1, &self.token); } - if !self.mac_address.is_empty() { - my_size += ::protobuf::rt::string_size(2, &self.mac_address); + if !self.device_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.device_id); } if !self.name.is_empty() { my_size += ::protobuf::rt::string_size(3, &self.name); @@ -139,8 +139,8 @@ impl ::protobuf::Message for RegistrationRequest { if !self.token.is_empty() { os.write_string(1, &self.token)?; } - if !self.mac_address.is_empty() { - os.write_string(2, &self.mac_address)?; + if !self.device_id.is_empty() { + os.write_string(2, &self.device_id)?; } if !self.name.is_empty() { os.write_string(3, &self.name)?; @@ -166,7 +166,7 @@ impl ::protobuf::Message for RegistrationRequest { fn clear(&mut self) { self.token.clear(); - self.mac_address.clear(); + self.device_id.clear(); self.name.clear(); self.is_fast = false; self.special_fields.clear(); @@ -175,7 +175,7 @@ impl ::protobuf::Message for RegistrationRequest { fn default_instance() -> &'static RegistrationRequest { static instance: RegistrationRequest = RegistrationRequest { token: ::std::string::String::new(), - mac_address: ::std::string::String::new(), + device_id: ::std::string::String::new(), name: ::std::string::String::new(), is_fast: false, special_fields: ::protobuf::SpecialFields::new(), @@ -732,80 +732,87 @@ impl ::protobuf::reflect::ProtobufValue for DeviceList { } #[derive(PartialEq,Clone,Default,Debug)] -// @@protoc_insertion_point(message:Punch) -pub struct Punch { +// @@protoc_insertion_point(message:PunchInfo) +pub struct PunchInfo { // message fields - // @@protoc_insertion_point(field:Punch.virtual_ip) - pub virtual_ip: u32, - // @@protoc_insertion_point(field:Punch.public_ip_list) + // @@protoc_insertion_point(field:PunchInfo.public_ip_list) pub public_ip_list: ::std::vec::Vec, - // @@protoc_insertion_point(field:Punch.public_port) + // @@protoc_insertion_point(field:PunchInfo.public_port) pub public_port: u32, - // @@protoc_insertion_point(field:Punch.public_port_range) + // @@protoc_insertion_point(field:PunchInfo.public_port_range) pub public_port_range: u32, - // @@protoc_insertion_point(field:Punch.nat_type) - pub nat_type: ::protobuf::EnumOrUnknown, - // @@protoc_insertion_point(field:Punch.reply) + // @@protoc_insertion_point(field:PunchInfo.nat_type) + pub nat_type: ::protobuf::EnumOrUnknown, + // @@protoc_insertion_point(field:PunchInfo.reply) pub reply: bool, + // @@protoc_insertion_point(field:PunchInfo.local_ip) + pub local_ip: u32, + // @@protoc_insertion_point(field:PunchInfo.local_port) + pub local_port: u32, // special fields - // @@protoc_insertion_point(special_field:Punch.special_fields) + // @@protoc_insertion_point(special_field:PunchInfo.special_fields) pub special_fields: ::protobuf::SpecialFields, } -impl<'a> ::std::default::Default for &'a Punch { - fn default() -> &'a Punch { - ::default_instance() +impl<'a> ::std::default::Default for &'a PunchInfo { + fn default() -> &'a PunchInfo { + ::default_instance() } } -impl Punch { - pub fn new() -> Punch { +impl PunchInfo { + pub fn new() -> PunchInfo { ::std::default::Default::default() } fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { - let mut fields = ::std::vec::Vec::with_capacity(6); + let mut fields = ::std::vec::Vec::with_capacity(7); let mut oneofs = ::std::vec::Vec::with_capacity(0); - fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( - "virtual_ip", - |m: &Punch| { &m.virtual_ip }, - |m: &mut Punch| { &mut m.virtual_ip }, - )); fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "public_ip_list", - |m: &Punch| { &m.public_ip_list }, - |m: &mut Punch| { &mut m.public_ip_list }, + |m: &PunchInfo| { &m.public_ip_list }, + |m: &mut PunchInfo| { &mut m.public_ip_list }, )); fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( "public_port", - |m: &Punch| { &m.public_port }, - |m: &mut Punch| { &mut m.public_port }, + |m: &PunchInfo| { &m.public_port }, + |m: &mut PunchInfo| { &mut m.public_port }, )); fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( "public_port_range", - |m: &Punch| { &m.public_port_range }, - |m: &mut Punch| { &mut m.public_port_range }, + |m: &PunchInfo| { &m.public_port_range }, + |m: &mut PunchInfo| { &mut m.public_port_range }, )); fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( "nat_type", - |m: &Punch| { &m.nat_type }, - |m: &mut Punch| { &mut m.nat_type }, + |m: &PunchInfo| { &m.nat_type }, + |m: &mut PunchInfo| { &mut m.nat_type }, )); fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( "reply", - |m: &Punch| { &m.reply }, - |m: &mut Punch| { &mut m.reply }, + |m: &PunchInfo| { &m.reply }, + |m: &mut PunchInfo| { &mut m.reply }, )); - ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( - "Punch", + fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( + "local_ip", + |m: &PunchInfo| { &m.local_ip }, + |m: &mut PunchInfo| { &mut m.local_ip }, + )); + fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( + "local_port", + |m: &PunchInfo| { &m.local_port }, + |m: &mut PunchInfo| { &mut m.local_port }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "PunchInfo", fields, oneofs, ) } } -impl ::protobuf::Message for Punch { - const NAME: &'static str = "Punch"; +impl ::protobuf::Message for PunchInfo { + const NAME: &'static str = "PunchInfo"; fn is_initialized(&self) -> bool { true @@ -814,9 +821,6 @@ impl ::protobuf::Message for Punch { fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { - 13 => { - self.virtual_ip = is.read_fixed32()?; - }, 18 => { is.read_repeated_packed_fixed32_into(&mut self.public_ip_list)?; }, @@ -835,6 +839,12 @@ impl ::protobuf::Message for Punch { 48 => { self.reply = is.read_bool()?; }, + 61 => { + self.local_ip = is.read_fixed32()?; + }, + 64 => { + self.local_port = is.read_uint32()?; + }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, @@ -847,9 +857,6 @@ impl ::protobuf::Message for Punch { #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; - if self.virtual_ip != 0 { - my_size += 1 + 4; - } my_size += 5 * self.public_ip_list.len() as u64; if self.public_port != 0 { my_size += ::protobuf::rt::uint32_size(3, self.public_port); @@ -857,21 +864,24 @@ impl ::protobuf::Message for Punch { if self.public_port_range != 0 { my_size += ::protobuf::rt::uint32_size(4, self.public_port_range); } - if self.nat_type != ::protobuf::EnumOrUnknown::new(NatType::Symmetric) { + if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) { my_size += ::protobuf::rt::int32_size(5, self.nat_type.value()); } if self.reply != false { my_size += 1 + 1; } + if self.local_ip != 0 { + my_size += 1 + 4; + } + if self.local_port != 0 { + my_size += ::protobuf::rt::uint32_size(8, self.local_port); + } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { - if self.virtual_ip != 0 { - os.write_fixed32(1, self.virtual_ip)?; - } for v in &self.public_ip_list { os.write_fixed32(2, *v)?; }; @@ -881,12 +891,18 @@ impl ::protobuf::Message for Punch { if self.public_port_range != 0 { os.write_uint32(4, self.public_port_range)?; } - if self.nat_type != ::protobuf::EnumOrUnknown::new(NatType::Symmetric) { + if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) { os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.nat_type))?; } if self.reply != false { os.write_bool(6, self.reply)?; } + if self.local_ip != 0 { + os.write_fixed32(7, self.local_ip)?; + } + if self.local_port != 0 { + os.write_uint32(8, self.local_port)?; + } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } @@ -899,85 +915,87 @@ impl ::protobuf::Message for Punch { &mut self.special_fields } - fn new() -> Punch { - Punch::new() + fn new() -> PunchInfo { + PunchInfo::new() } fn clear(&mut self) { - self.virtual_ip = 0; self.public_ip_list.clear(); self.public_port = 0; self.public_port_range = 0; - self.nat_type = ::protobuf::EnumOrUnknown::new(NatType::Symmetric); + self.nat_type = ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric); self.reply = false; + self.local_ip = 0; + self.local_port = 0; self.special_fields.clear(); } - fn default_instance() -> &'static Punch { - static instance: Punch = Punch { - virtual_ip: 0, + fn default_instance() -> &'static PunchInfo { + static instance: PunchInfo = PunchInfo { public_ip_list: ::std::vec::Vec::new(), public_port: 0, public_port_range: 0, nat_type: ::protobuf::EnumOrUnknown::from_i32(0), reply: false, + local_ip: 0, + local_port: 0, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } -impl ::protobuf::MessageFull for Punch { +impl ::protobuf::MessageFull for PunchInfo { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); - descriptor.get(|| file_descriptor().message_by_package_relative_name("Punch").unwrap()).clone() + descriptor.get(|| file_descriptor().message_by_package_relative_name("PunchInfo").unwrap()).clone() } } -impl ::std::fmt::Display for Punch { +impl ::std::fmt::Display for PunchInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } -impl ::protobuf::reflect::ProtobufValue for Punch { +impl ::protobuf::reflect::ProtobufValue for PunchInfo { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] -// @@protoc_insertion_point(enum:NatType) -pub enum NatType { - // @@protoc_insertion_point(enum_value:NatType.Symmetric) +// @@protoc_insertion_point(enum:PunchNatType) +pub enum PunchNatType { + // @@protoc_insertion_point(enum_value:PunchNatType.Symmetric) Symmetric = 0, - // @@protoc_insertion_point(enum_value:NatType.Cone) + // @@protoc_insertion_point(enum_value:PunchNatType.Cone) Cone = 1, } -impl ::protobuf::Enum for NatType { - const NAME: &'static str = "NatType"; +impl ::protobuf::Enum for PunchNatType { + const NAME: &'static str = "PunchNatType"; fn value(&self) -> i32 { *self as i32 } - fn from_i32(value: i32) -> ::std::option::Option { + fn from_i32(value: i32) -> ::std::option::Option { match value { - 0 => ::std::option::Option::Some(NatType::Symmetric), - 1 => ::std::option::Option::Some(NatType::Cone), + 0 => ::std::option::Option::Some(PunchNatType::Symmetric), + 1 => ::std::option::Option::Some(PunchNatType::Cone), _ => ::std::option::Option::None } } - const VALUES: &'static [NatType] = &[ - NatType::Symmetric, - NatType::Cone, + const VALUES: &'static [PunchNatType] = &[ + PunchNatType::Symmetric, + PunchNatType::Cone, ]; } -impl ::protobuf::EnumFull for NatType { +impl ::protobuf::EnumFull for PunchNatType { fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); - descriptor.get(|| file_descriptor().enum_by_package_relative_name("NatType").unwrap()).clone() + descriptor.get(|| file_descriptor().enum_by_package_relative_name("PunchNatType").unwrap()).clone() } fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { @@ -986,41 +1004,41 @@ impl ::protobuf::EnumFull for NatType { } } -impl ::std::default::Default for NatType { +impl ::std::default::Default for PunchNatType { fn default() -> Self { - NatType::Symmetric + PunchNatType::Symmetric } } -impl NatType { +impl PunchNatType { fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { - ::protobuf::reflect::GeneratedEnumDescriptorData::new::("NatType") + ::protobuf::reflect::GeneratedEnumDescriptorData::new::("PunchNatType") } } static file_descriptor_proto_data: &'static [u8] = b"\ - \n\rmessage.proto\"y\n\x13RegistrationRequest\x12\x14\n\x05token\x18\x01\ - \x20\x01(\tR\x05token\x12\x1f\n\x0bmac_address\x18\x02\x20\x01(\tR\nmacA\ - ddress\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\x17\n\x07is_fas\ - t\x18\x04\x20\x01(\x08R\x06isFast\"\x92\x02\n\x14RegistrationResponse\ - \x12\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12'\n\x0fvirtua\ - l_gateway\x18\x02\x20\x01(\x07R\x0evirtualGateway\x12'\n\x0fvirtual_netm\ - ask\x18\x03\x20\x01(\x07R\x0evirtualNetmask\x12\x14\n\x05epoch\x18\x04\ - \x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x05\x20\x03(\x0b2\ - \x0b.DeviceInfoR\x0edeviceInfoList\x12\x1b\n\tpublic_ip\x18\x06\x20\x01(\ - \x07R\x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\x20\x01(\rR\npublicPo\ - rt\"d\n\nDeviceInfo\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\ - \x1d\n\nvirtual_ip\x18\x02\x20\x01(\x07R\tvirtualIp\x12#\n\rdevice_statu\ - s\x18\x03\x20\x01(\rR\x0cdeviceStatus\"Y\n\nDeviceList\x12\x14\n\x05epoc\ - h\x18\x01\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x02\x20\ - \x03(\x0b2\x0b.DeviceInfoR\x0edeviceInfoList\"\xd4\x01\n\x05Punch\x12\ - \x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12$\n\x0epublic_ip_\ - list\x18\x02\x20\x03(\x07R\x0cpublicIpList\x12\x1f\n\x0bpublic_port\x18\ - \x03\x20\x01(\rR\npublicPort\x12*\n\x11public_port_range\x18\x04\x20\x01\ - (\rR\x0fpublicPortRange\x12#\n\x08nat_type\x18\x05\x20\x01(\x0e2\x08.Nat\ - TypeR\x07natType\x12\x14\n\x05reply\x18\x06\x20\x01(\x08R\x05reply*\"\n\ - \x07NatType\x12\r\n\tSymmetric\x10\0\x12\x08\n\x04Cone\x10\x01b\x06proto\ - 3\ + \n\rmessage.proto\"u\n\x13RegistrationRequest\x12\x14\n\x05token\x18\x01\ + \x20\x01(\tR\x05token\x12\x1b\n\tdevice_id\x18\x02\x20\x01(\tR\x08device\ + Id\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\x17\n\x07is_fast\ + \x18\x04\x20\x01(\x08R\x06isFast\"\x92\x02\n\x14RegistrationResponse\x12\ + \x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12'\n\x0fvirtual_ga\ + teway\x18\x02\x20\x01(\x07R\x0evirtualGateway\x12'\n\x0fvirtual_netmask\ + \x18\x03\x20\x01(\x07R\x0evirtualNetmask\x12\x14\n\x05epoch\x18\x04\x20\ + \x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x05\x20\x03(\x0b2\x0b.D\ + eviceInfoR\x0edeviceInfoList\x12\x1b\n\tpublic_ip\x18\x06\x20\x01(\x07R\ + \x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\x20\x01(\rR\npublicPort\"d\ + \n\nDeviceInfo\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x1d\n\n\ + virtual_ip\x18\x02\x20\x01(\x07R\tvirtualIp\x12#\n\rdevice_status\x18\ + \x03\x20\x01(\rR\x0cdeviceStatus\"Y\n\nDeviceList\x12\x14\n\x05epoch\x18\ + \x01\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x02\x20\x03(\ + \x0b2\x0b.DeviceInfoR\x0edeviceInfoList\"\xf8\x01\n\tPunchInfo\x12$\n\ + \x0epublic_ip_list\x18\x02\x20\x03(\x07R\x0cpublicIpList\x12\x1f\n\x0bpu\ + blic_port\x18\x03\x20\x01(\rR\npublicPort\x12*\n\x11public_port_range\ + \x18\x04\x20\x01(\rR\x0fpublicPortRange\x12(\n\x08nat_type\x18\x05\x20\ + \x01(\x0e2\r.PunchNatTypeR\x07natType\x12\x14\n\x05reply\x18\x06\x20\x01\ + (\x08R\x05reply\x12\x19\n\x08local_ip\x18\x07\x20\x01(\x07R\x07localIp\ + \x12\x1d\n\nlocal_port\x18\x08\x20\x01(\rR\tlocalPort*'\n\x0cPunchNatTyp\ + e\x12\r\n\tSymmetric\x10\0\x12\x08\n\x04Cone\x10\x01b\x06proto3\ "; /// `FileDescriptorProto` object which was a source for this generated file @@ -1043,9 +1061,9 @@ pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor { messages.push(RegistrationResponse::generated_message_descriptor_data()); messages.push(DeviceInfo::generated_message_descriptor_data()); messages.push(DeviceList::generated_message_descriptor_data()); - messages.push(Punch::generated_message_descriptor_data()); + messages.push(PunchInfo::generated_message_descriptor_data()); let mut enums = ::std::vec::Vec::with_capacity(1); - enums.push(NatType::generated_enum_descriptor_data()); + enums.push(PunchNatType::generated_enum_descriptor_data()); ::protobuf::reflect::GeneratedFileDescriptor::new_generated( file_descriptor_proto(), deps, diff --git a/switch/src/protocol/control_packet.rs b/switch/src/protocol/control_packet.rs index 93e0ab1..c887bae 100644 --- a/switch/src/protocol/control_packet.rs +++ b/switch/src/protocol/control_packet.rs @@ -1,13 +1,22 @@ -use std::fmt; -use std::net::Ipv4Addr; +use std::{fmt, io}; -use crate::error::*; #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub enum Protocol { + /// ping请求 + /* + 0 1 2 3 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | time | echo | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ Ping, + /// 维持连接，内容同ping Pong, + /// 打洞请求 PunchRequest, + /// 打洞响应 PunchResponse, UnKnow(u8), } @@ -39,22 +48,18 @@ impl Into for Protocol { pub enum ControlPacket { PingPacket(PingPacket), PongPacket(PongPacket), - PunchRequest(PunchRequestPacket), - PunchResponse(PunchResponsePacket), + PunchRequest, + PunchResponse, } impl> ControlPacket { - pub fn new(protocol: u8, buffer: B) -> Result> { + pub fn new(protocol: u8, buffer: B) -> io::Result> { match Protocol::from(protocol) { Protocol::Ping => Ok(ControlPacket::PingPacket(PingPacket::new(buffer)?)), Protocol::Pong => Ok(ControlPacket::PongPacket(PongPacket::new(buffer)?)), - Protocol::PunchRequest => Ok(ControlPacket::PunchRequest(PunchRequestPacket::new( - buffer, - )?)), - Protocol::PunchResponse => Ok(ControlPacket::PunchResponse(PunchResponsePacket::new( - buffer, - )?)), - Protocol::UnKnow(_) => Err(Error::NotSupport), + Protocol::PunchRequest => Ok(ControlPacket::PunchRequest), + Protocol::PunchResponse => Ok(ControlPacket::PunchResponse), + Protocol::UnKnow(_) => Err(io::Error::new(io::ErrorKind::InvalidData, "Unsupported")), } } } @@ -65,36 +70,33 @@ pub struct PingPacket { buffer: B, } -#[derive(Copy, Clone)] -pub struct PongPacket { - buffer: B, -} +type PongPacket = PingPacket; impl> PingPacket { - pub fn new(buffer: B) -> Result> { + pub fn new(buffer: B) -> io::Result> { let len = buffer.as_ref().len(); - if len != 8 + 4 { - return Err(Error::InvalidPacket); + if len != 4 { + return Err(io::Error::new(io::ErrorKind::InvalidData, "len != 4")); } Ok(PingPacket { buffer }) } } impl> PingPacket { - pub fn time(&self) -> i64 { - i64::from_be_bytes(self.buffer.as_ref()[..8].try_into().unwrap()) + pub fn time(&self) -> u16 { + u16::from_be_bytes(self.buffer.as_ref()[..2].try_into().unwrap()) } - pub fn epoch(&self) -> u32 { - u32::from_be_bytes(self.buffer.as_ref()[8..12].try_into().unwrap()) + pub fn epoch(&self) -> u16 { + u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap()) } } impl + AsMut<[u8]>> PingPacket { - pub fn set_time(&mut self, time: i64) { - self.buffer.as_mut()[..8].copy_from_slice(&time.to_be_bytes()) + pub fn set_time(&mut self, time: u16) { + self.buffer.as_mut()[..2].copy_from_slice(&time.to_be_bytes()) } - pub fn set_epoch(&mut self, epoch: u32) { - self.buffer.as_mut()[8..12].copy_from_slice(&epoch.to_be_bytes()) + pub fn set_epoch(&mut self, epoch: u16) { + self.buffer.as_mut()[2..4].copy_from_slice(&epoch.to_be_bytes()) } } @@ -105,118 +107,4 @@ impl> fmt::Debug for PingPacket { .field("epoch", &self.epoch()) .finish() } -} - -impl> PongPacket { - pub fn new(buffer: B) -> Result> { - let len = buffer.as_ref().len(); - if len != 8 { - return Err(Error::InvalidPacket); - } - Ok(PongPacket { buffer }) - } -} - -impl> PongPacket { - pub fn time(&self) -> i64 { - i64::from_be_bytes(self.buffer.as_ref()[..8].try_into().unwrap()) - } -} - -impl + AsMut<[u8]>> PongPacket { - pub fn set_time(&mut self, time: i64) { - self.buffer.as_mut()[..8].copy_from_slice(&time.to_be_bytes()) - } -} - -impl> fmt::Debug for PongPacket { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("PongPacket") - .field("time", &self.time()) - .finish() - } -} - -pub type TurnPongPacket = TurnPingPacket; - -/// 探测目标延迟 -#[derive(Copy, Clone)] -pub struct TurnPingPacket { - buffer: B, -} - -impl> TurnPingPacket { - pub fn new(buffer: B) -> Result> { - let len = buffer.as_ref().len(); - if len != 16 { - return Err(Error::InvalidPacket); - } - Ok(TurnPingPacket { buffer }) - } -} - -impl> TurnPingPacket { - // pub fn source(&self) -> Ipv4Addr { - // let tmp:[u8;4] = self.buffer.as_ref()[..4].try_into().unwrap(); - // Ipv4Addr::from(tmp) - // } - // pub fn destination(&self) -> Ipv4Addr { - // let tmp:[u8;4] = self.buffer.as_ref()[4..8].try_into().unwrap(); - // Ipv4Addr::from(tmp) - // } - pub fn time(&self) -> i64 { - i64::from_be_bytes(self.buffer.as_ref()[8..].try_into().unwrap()) - } -} - -impl + AsMut<[u8]>> TurnPingPacket { - pub fn set_source(&mut self, source: Ipv4Addr) { - self.buffer.as_mut()[..4].copy_from_slice(&source.octets()); - } - pub fn set_destination(&mut self, destination: Ipv4Addr) { - self.buffer.as_mut()[4..8].copy_from_slice(&destination.octets()); - } - pub fn set_time(&mut self, time: i64) { - self.buffer.as_mut()[8..].copy_from_slice(&time.to_be_bytes()) - } -} - -pub type PunchResponsePacket = PunchPacket; -pub type PunchRequestPacket = PunchPacket; - -/// nat穿透 -#[derive(Clone)] -pub struct PunchPacket { - buffer: B, -} - -impl> PunchPacket { - pub fn new(buffer: B) -> Result> { - let len = buffer.as_ref().len(); - if len != 8 { - return Err(Error::InvalidPacket); - } - Ok(Self { buffer }) - } -} - -impl> PunchPacket { - pub fn source(&self) -> Ipv4Addr { - let tmp: [u8; 4] = self.buffer.as_ref()[..4].try_into().unwrap(); - Ipv4Addr::from(tmp) - } -} - -impl + AsMut<[u8]>> PunchPacket { - pub fn set_source(&mut self, source: Ipv4Addr) { - self.buffer.as_mut()[..4].copy_from_slice(&source.octets()); - } -} - -impl> fmt::Debug for PunchPacket { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("PunchPacket") - .field("source", &self.source()) - .finish() - } -} +} \ No newline at end of file diff --git a/switch/src/protocol/mod.rs b/switch/src/protocol/mod.rs index 3f6bd86..30d9b51 100644 --- a/switch/src/protocol/mod.rs +++ b/switch/src/protocol/mod.rs @@ -1,6 +1,19 @@ -use std::fmt; +use std::{fmt, io}; +use std::net::Ipv4Addr; -use crate::error::*; +/* + 0 15 31 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | 版本(8) | 协议(8) | 上层协议(8) | 初始ttl(4) | 生存时间(4) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | 源ip地址(32) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | 目的ip地址(32) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | 数据体 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ pub mod control_packet; pub mod error_packet; @@ -41,6 +54,7 @@ pub enum Protocol { Control, /// 转发ipv4数据 Ipv4Turn, + /// 转发其他数据 OtherTurn, UnKnow(u8), } @@ -71,17 +85,20 @@ impl Into for Protocol { } } +pub const MAX_TTL: u8 = 0b1111; +pub const MAX_SOURCE: u8 = 0b11110000; + #[derive(Copy, Clone)] pub struct NetPacket { buffer: B, } impl> NetPacket { - pub fn new(buffer: B) -> Result> { + pub fn new(buffer: B) -> io::Result> { let len = buffer.as_ref().len(); // 不能大于udp最大载荷长度 - if len < 4 || len > 65535 - 20 - 8 { - return Err(Error::InvalidPacket); + if len < 12 || len > 65535 - 20 - 8 { + return Err(io::Error::new(io::ErrorKind::InvalidData, "length overflow")); } Ok(NetPacket { buffer }) } @@ -104,10 +121,21 @@ impl> NetPacket { self.buffer.as_ref()[2] } pub fn ttl(&self) -> u8 { - self.buffer.as_ref()[3] + self.buffer.as_ref()[3] & MAX_TTL + } + pub fn source_ttl(&self) -> u8 { + self.buffer.as_ref()[3] >> 4 + } + pub fn source(&self) -> Ipv4Addr { + let tmp: [u8; 4] = self.buffer.as_ref()[4..8].try_into().unwrap(); + Ipv4Addr::from(tmp) + } + pub fn destination(&self) -> Ipv4Addr { + let tmp: [u8; 4] = self.buffer.as_ref()[8..12].try_into().unwrap(); + Ipv4Addr::from(tmp) } pub fn payload(&self) -> &[u8] { - &self.buffer.as_ref()[4..] + &self.buffer.as_ref()[12..] } } @@ -121,14 +149,26 @@ impl + AsMut<[u8]>> NetPacket { pub fn set_transport_protocol(&mut self, transport_protocol: u8) { self.buffer.as_mut()[2] = transport_protocol; } + pub fn first_set_ttl(&mut self, ttl: u8) { + self.buffer.as_mut()[3] = ttl << 4 | ttl; + } pub fn set_ttl(&mut self, ttl: u8) { - self.buffer.as_mut()[3] = ttl; + self.buffer.as_mut()[3] = (self.buffer.as_mut()[3] & MAX_SOURCE) | (MAX_TTL & ttl); + } + pub fn set_source_ttl(&mut self, source_ttl: u8) { + self.buffer.as_mut()[3] = (source_ttl << 4) | (MAX_TTL & self.buffer.as_ref()[3]); + } + pub fn set_source(&mut self, source: Ipv4Addr) { + self.buffer.as_mut()[4..8].copy_from_slice(&source.octets()); + } + pub fn set_destination(&mut self, destination: Ipv4Addr) { + self.buffer.as_mut()[8..12].copy_from_slice(&destination.octets()); } pub fn set_payload(&mut self, payload: &[u8]) { - self.buffer.as_mut()[4..payload.len() + 4].copy_from_slice(payload); + self.buffer.as_mut()[12..payload.len() + 12].copy_from_slice(payload); } pub fn payload_mut(&mut self) -> &mut [u8] { - &mut self.buffer.as_mut()[4..] + &mut self.buffer.as_mut()[12..] } } @@ -139,6 +179,9 @@ impl> fmt::Debug for NetPacket { .field("protocol", &self.protocol()) .field("transport_protocol", &self.transport_protocol()) .field("ttl", &self.ttl()) + .field("source_ttl", &self.source_ttl()) + .field("source", &self.source()) + .field("destination", &self.destination()) .field("payload", &self.payload()) .finish() } diff --git a/switch/src/protocol/service_packet.rs b/switch/src/protocol/service_packet.rs index c933ac6..bc3ea1e 100644 --- a/switch/src/protocol/service_packet.rs +++ b/switch/src/protocol/service_packet.rs @@ -4,8 +4,10 @@ pub enum Protocol { RegistrationRequest, /// 注册响应 RegistrationResponse, - /// 更新设备列表 - UpdateDeviceList, + /// 拉取设备列表 + PollDeviceList, + /// 推送设备列表 + PushDeviceList, UnKnow(u8), } @@ -14,7 +16,8 @@ impl From for Protocol { match value { 1 => Self::RegistrationRequest, 2 => Self::RegistrationResponse, - 3 => Self::UpdateDeviceList, + 3 => Self::PollDeviceList, + 4 => Self::PushDeviceList, val => Self::UnKnow(val), } } @@ -25,7 +28,8 @@ impl Into for Protocol { match self { Self::RegistrationRequest => 1, Self::RegistrationResponse => 2, - Self::UpdateDeviceList => 3, + Self::PollDeviceList => 3, + Self::PushDeviceList => 4, Self::UnKnow(val) => val, } } diff --git a/switch/src/protocol/turn_packet.rs b/switch/src/protocol/turn_packet.rs index 4016825..5ab3b54 100644 --- a/switch/src/protocol/turn_packet.rs +++ b/switch/src/protocol/turn_packet.rs @@ -1,7 +1,4 @@ -use std::fmt; -use std::net::Ipv4Addr; -use crate::error::*; #[derive(Copy, Clone, Eq, PartialEq, Debug)] pub enum Protocol { @@ -26,56 +23,3 @@ impl Into for Protocol { } } } - -pub struct TurnPacket { - buffer: B, -} - -impl> TurnPacket { - pub fn new(buffer: B) -> Result> { - let len = buffer.as_ref().len(); - if len <= 8 { - return Err(Error::InvalidPacket); - } - Ok(Self { buffer }) - } -} - -impl> TurnPacket { - pub fn source(&self) -> Ipv4Addr { - let tmp: [u8; 4] = self.buffer.as_ref()[..4].try_into().unwrap(); - Ipv4Addr::from(tmp) - } - pub fn destination(&self) -> Ipv4Addr { - let tmp: [u8; 4] = self.buffer.as_ref()[4..8].try_into().unwrap(); - Ipv4Addr::from(tmp) - } - pub fn payload(&self) -> &[u8] { - &self.buffer.as_ref()[8..] - } -} - -impl + AsMut<[u8]>> TurnPacket { - pub fn payload_mut(&mut self) -> &mut [u8] { - &mut self.buffer.as_mut()[8..] - } - pub fn set_source(&mut self, source: Ipv4Addr) { - self.buffer.as_mut()[..4].copy_from_slice(&source.octets()); - } - pub fn set_destination(&mut self, destination: Ipv4Addr) { - self.buffer.as_mut()[4..8].copy_from_slice(&destination.octets()); - } - pub fn set_payload(&mut self, payload: &[u8]) { - self.buffer.as_mut()[8..payload.len() + 8].copy_from_slice(payload) - } -} - -impl> fmt::Debug for TurnPacket { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("TurnPacket") - .field("source", &self.source()) - .field("destination", &self.destination()) - .field("payload", &self.payload()) - .finish() - } -} diff --git a/switch/src/tun_device/linux.rs b/switch/src/tun_device/linux.rs index d86f553..cfe270c 100644 --- a/switch/src/tun_device/linux.rs +++ b/switch/src/tun_device/linux.rs @@ -1,5 +1,8 @@ use crate::tun_device::{TunReader, TunWriter}; use std::net::Ipv4Addr; +use std::sync::Arc; +use tun::Device; +use parking_lot::Mutex; pub fn create_tun( address: Ipv4Addr, @@ -13,17 +16,20 @@ pub fn create_tun( .address(address) .netmask(netmask) .mtu(1420) + // .queues(2) 用多个队列有兼容性问题 .up(); + // + // config.platform(|config| { + // config.packet_information(true); + // }); - config.platform(|config| { - config.packet_information(true); - }); - - let mut dev = tun::create(&config).unwrap(); + let dev = tun::create(&config).unwrap(); let packet_information = dev.has_packet_information(); - let (reader, writer) = dev.split(); + let queue = dev.queue(0).unwrap(); + let reader = queue.reader(); + let writer = queue.writer(); Ok(( - TunWriter(writer, packet_information), + TunWriter(writer, packet_information, Arc::new(Mutex::new(dev))), TunReader(reader, packet_information), )) } diff --git a/switch/src/tun_device/mac.rs b/switch/src/tun_device/mac.rs index 4c5b9a1..4be2718 100644 --- a/switch/src/tun_device/mac.rs +++ b/switch/src/tun_device/mac.rs @@ -1,7 +1,9 @@ use std::net::Ipv4Addr; use std::process::Command; - +use std::io; use tun::Device; +use parking_lot::Mutex; +use std::sync::Arc; use crate::tun_device::{TunReader, TunWriter}; @@ -20,33 +22,7 @@ pub fn create_tun( .up(); let dev = tun::create(&config).unwrap(); - let up_eth_str: String = format!("ifconfig {} {:?} {:?} up ", dev.name(), address, gateway); - let route_add_str: String = format!( - "sudo route -n add -net {:?} -netmask {:?} {:?}", - address, netmask, gateway - ); - let up_eth_out = Command::new("sh") - .arg("-c") - .arg(up_eth_str) - .output() - .expect("sh exec error!"); - if !up_eth_out.status.success() { - return Err(crate::error::Error::Stop(format!( - "设置地址失败:{:?}", - up_eth_out - ))); - } - let if_config_out = Command::new("sh") - .arg("-c") - .arg(route_add_str) - .output() - .expect("sh exec error!"); - if !if_config_out.status.success() { - return Err(crate::error::Error::Stop(format!( - "设置路由失败:{:?}", - if_config_out - ))); - } + config_ip(dev.name(), address, netmask, gateway)?; // println!("{:?}", if_config_out); // let cmd_str: String = " ifconfig|grep flags=8051|awk -F ':' '{print $1}'|tail -1".to_string(); // @@ -60,9 +36,36 @@ pub fn create_tun( // } // println!("{:?}", cmd_str_out); let packet_information = dev.has_packet_information(); - let (reader, writer) = dev.split(); + let queue = dev.queue(0).unwrap(); + let reader = queue.reader(); + let writer = queue.writer(); Ok(( - TunWriter(writer, packet_information), + TunWriter(writer, packet_information, Arc::new(Mutex::new(dev))), TunReader(reader, packet_information), )) } + +pub(crate) fn config_ip(name: &str, address: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr) -> io::Result<()> { + let up_eth_str: String = format!("ifconfig {} {:?} {:?} up ", name, address, gateway); + let route_add_str: String = format!( + "sudo route -n add -net {:?} -netmask {:?} {:?}", + address, netmask, gateway + ); + let up_eth_out = Command::new("sh") + .arg("-c") + .arg(up_eth_str) + .output() + .expect("sh exec error!"); + if !up_eth_out.status.success() { + return Err(io::Error::new(io::ErrorKind::Other, format!("设置网络地址失败: {:?}", up_eth_out))); + } + let if_config_out = Command::new("sh") + .arg("-c") + .arg(route_add_str) + .output() + .expect("sh exec error!"); + if !if_config_out.status.success() { + return Err(io::Error::new(io::ErrorKind::Other, format!("添加路由失败: {:?}", if_config_out))); + } + Ok(()) +} diff --git a/switch/src/tun_device/unix.rs b/switch/src/tun_device/unix.rs index 04f4145..28e5e79 100644 --- a/switch/src/tun_device/unix.rs +++ b/switch/src/tun_device/unix.rs @@ -1,13 +1,21 @@ use std::io; -use std::io::{Read, Write}; +use std::sync::Arc; use bytes::BufMut; use tun::platform::posix::{Reader, Writer}; +use std::net::Ipv4Addr; +use std::os::unix::io::AsRawFd; +#[cfg(any(target_os = "linux", target_os = "android"))] +use tun::platform::linux::Device; +#[cfg(any(target_os = "macos", target_os = "ios"))] +use tun::platform::macos::Device; +use parking_lot::Mutex; +#[derive(Clone)] pub struct TunReader(pub(crate) Reader, pub(crate) bool); impl TunReader { - pub fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> io::Result<&mut [u8]> { + pub fn read<'a>(&'a self, buf: &'a mut [u8]) -> io::Result<&mut [u8]> { let len = self.0.read(buf)?; if self.1 { Ok(&mut buf[4..len]) @@ -15,12 +23,22 @@ impl TunReader { Ok(&mut buf[..len]) } } + pub fn close(&self) { + unsafe { + let raw = self.0.as_raw_fd(); + if raw >= 0 { + libc::close(raw); + } + } + } } -pub struct TunWriter(pub(crate) Writer, pub(crate) bool); + +#[derive(Clone)] +pub struct TunWriter(pub(crate) Writer, pub(crate) bool, pub(crate) Arc>); impl TunWriter { - pub fn write(&mut self, packet: &[u8]) -> io::Result<()> { + pub fn write(&self, packet: &[u8]) -> io::Result<()> { if self.1 { let mut buf = Vec::::with_capacity(4 + packet.len()); buf.put_u16(0); @@ -34,4 +52,25 @@ impl TunWriter { self.0.write_all(packet) } } + pub fn change_ip(&self, address: Ipv4Addr, netmask: Ipv4Addr, + gateway: Ipv4Addr, _old_netmask: Ipv4Addr, _old_gateway: Ipv4Addr) -> io::Result<()> { + let mut config = tun::Configuration::default(); + use tun::Device; + config + .destination(gateway) + .address(address) + .netmask(netmask) + .mtu(1420) + // .queues(2) + .up(); + let mut dev = self.2.lock(); + if let Err(e) = dev.configure(&config) { + return Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", e))); + } + #[cfg(target_os = "macos")] + if let Err(e) = crate::tun_device::mac::config_ip(dev.name(), address, netmask, gateway){ + log::error!("{}",e); + } + return Ok(()); + } } diff --git a/switch/src/tun_device/windows.rs b/switch/src/tun_device/windows.rs index 39e87b5..38674e3 100644 --- a/switch/src/tun_device/windows.rs +++ b/switch/src/tun_device/windows.rs @@ -3,11 +3,11 @@ use std::net::Ipv4Addr; use std::sync::Arc; use libloading::Library; +use parking_lot::Mutex; use wintun::{Adapter, Packet, Session}; -use crate::error::*; - -pub struct TunWriter(Arc); +#[derive(Clone)] +pub struct TunWriter(Arc, Arc>); impl TunWriter { pub fn write(&self, buf: &[u8]) -> io::Result<()> { @@ -21,10 +21,20 @@ impl TunWriter { } return Err(io::Error::new(io::ErrorKind::Other, "send err")); } + pub fn change_ip(&self, address: Ipv4Addr, netmask: Ipv4Addr, + gateway: Ipv4Addr, old_netmask: Ipv4Addr, old_gateway: Ipv4Addr) -> io::Result<()> { + let index = self.1.lock(); + if let Err(e) = delete_route(*index, old_netmask, old_gateway) { + log::warn!("{:?}",e); + } + config_ip(*index, address, netmask, gateway) + } } +#[derive(Clone)] pub struct TunReader(pub(crate) Arc); + impl TunReader { pub fn next(&self) -> io::Result { match self.0.receive_blocking() { @@ -35,36 +45,46 @@ impl TunReader { } return Err(io::Error::new(io::ErrorKind::Other, "read err")); } + pub fn close(&self) { + self.0.shutdown() + } } pub fn create_tun( address: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr, -) -> Result<(TunWriter, TunReader)> { +) -> io::Result<(TunWriter, TunReader)> { let win_tun = unsafe { match Library::new("wintun.dll") { Ok(library) => match wintun::load_from_library(library) { Ok(win_tun) => win_tun, Err(e) => { - return Err(Error::Stop(format!("{:?}", e))); + return Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", e))); } }, Err(e) => { log::error!("wintun.dll not found"); - return Err(Error::Stop(format!("wintun.dll not found {:?}", e))); + return Err(io::Error::new(io::ErrorKind::Other, format!("wintun.dll not found {:?}", e))); } } }; - let adapter = match Adapter::open(&win_tun, "Switch") { + let adapter = match Adapter::open(&win_tun, "Switch-V1") { Ok(a) => a, - Err(_) => match Adapter::create(&win_tun, "Switch", "Switch", None) { + Err(_) => match Adapter::create(&win_tun, "Switch-V1", "Switch-V1", None) { Ok(adapter) => adapter, - Err(e) => return Err(Error::Stop(format!("{:?}", e))), + Err(e) => return Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", e))), }, }; let index = adapter.get_adapter_index().unwrap(); + config_ip(index, address, netmask, gateway)?; + let session = Arc::new(adapter.start_session(wintun::MAX_RING_CAPACITY).unwrap()); + let reader_session = session.clone(); + Ok((TunWriter(session.clone(), Arc::new(Mutex::new(index))), TunReader(reader_session))) +} + +fn config_ip(index: u32, address: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr) -> io::Result<()> { let set_mtu = format!( "netsh interface ipv4 set subinterface {} mtu=1420 store=persistent", index @@ -74,9 +94,6 @@ pub fn create_tun( "netsh interface ip set address {} static {:?} {:?} ", // gateway={:?} index, address, netmask, ); - // println!("{}", set_mtu); - // println!("{}", set_metric); - // println!("{}", set_address); // 执行网卡初始化命令 let out = std::process::Command::new("cmd") .arg("/C") @@ -84,7 +101,7 @@ pub fn create_tun( .output() .unwrap(); if !out.status.success() { - return Err(Error::Stop(format!("设置mtu失败:{:?}", out))); + return Err(io::Error::new(io::ErrorKind::Other, format!("设置mtu失败: {:?}", out))); } let out = std::process::Command::new("cmd") .arg("/C") @@ -92,7 +109,7 @@ pub fn create_tun( .output() .unwrap(); if !out.status.success() { - return Err(Error::Stop(format!("设置接口跃点失败:{:?}", out))); + return Err(io::Error::new(io::ErrorKind::Other, format!("设置接口跃点失败: {:?}", out))); } let out = std::process::Command::new("cmd") .arg("/C") @@ -100,7 +117,7 @@ pub fn create_tun( .output() .unwrap(); if !out.status.success() { - return Err(Error::Stop(format!("设置网络地址失败:{:?}", out))); + return Err(io::Error::new(io::ErrorKind::Other, format!("设置网络地址失败: {:?}", out))); } let dest = { let ip = address.octets(); @@ -116,7 +133,6 @@ pub fn create_tun( "route add {:?} mask {:?} {:?} if {}", dest, netmask, gateway, index ); - // println!("{}", set_route); // 执行添加路由命令 let out = std::process::Command::new("cmd") .arg("/C") @@ -124,9 +140,32 @@ pub fn create_tun( .output() .unwrap(); if !out.status.success() { - return Err(Error::Stop(format!("添加路由失败:{:?}", out))); + return Err(io::Error::new(io::ErrorKind::Other, format!("添加路由失败: {:?}", out))); } - let session = Arc::new(adapter.start_session(wintun::MAX_RING_CAPACITY).unwrap()); - let reader_session = session.clone(); - Ok((TunWriter(session), TunReader(reader_session))) + Ok(()) +} + +fn delete_route(index: u32, netmask: Ipv4Addr, gateway: Ipv4Addr) -> io::Result<()> { + let mask = netmask.octets(); + let ip = gateway.octets(); + let dest = Ipv4Addr::from([ + ip[0] & mask[0], + ip[1] & mask[1], + ip[2] & mask[2], + ip[3] & mask[3], + ]); + let delete_route = format!( + "route delete {:?} mask {:?} {:?} if {}", + dest, netmask, gateway, index + ); + // 删除路由 + let out = std::process::Command::new("cmd") + .arg("/C") + .arg(delete_route) + .output() + .unwrap(); + if !out.status.success() { + return Err(io::Error::new(io::ErrorKind::Other, format!("删除路由失败: {:?}", out))); + } + Ok(()) }