调整jni模块、优化cmd模块展示

switch-cmd/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "switch-cmd"
+version = "1.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+switch = {path="../switch"}
+common = {path="../common"}
+tokio = { version = "1.28.1", features = ["full"] }
+getopts = "0.2.21"
+console = "0.15.2"
+os_info = "3.7.0"
+dirs = "4.0.0"
+serde = "1.0"
+serde_json = "1.0.94"
+log = "0.4.17"
+[features]
+default = []
+mini = []

switch-cmd/README.md

@@ -0,0 +1,35 @@
+## 模块介绍
+体积小，可以在服务器、路由器等环境使用
+## 详细参数说明
+### -k
+一个虚拟局域网的标识，在同一服务器下，相同token的设备会组建一个局域网
+### -n
+设备名称，方便区分不同设备
+### -d
+设备id，每台设备的唯一标识，注意不要重复
+### -c
+关闭命令，后台运行时可以加此参数
+### -s
+中继服务器地址，注册和转发数据
+### -e
+探测客户端NAT类型，不同类型有不同的打洞策略
+### -a
+加了此参数表示使用tap网卡，默认使用tun网卡，tun网卡效率更高
+### -i、-o
+配置点对网时使用，例如A(10.26.0.2)通过B(10.26.0.3,192.168.0.10)访问C(192.168.0.11)，
+
+则在A配置 --in-ip 192.168.10.0/24,10.26.0.3 ,表示将192.168.10.0/24网段的数据都转发到10.26.0.3节点
+
+在B配置 --out-ip 192.168.10.0/24,192.168.1.10  ,表示允许将192.168.10.0/24的数据从网卡192.168.1.10转发出去
+
+### -w
+提升通信安全性，使用该密码生成的密钥对客户端数据进行加密，并且服务端无法解密。使用相同密码的客户端才能通信
+
+### -m
+模拟组播，高频使用组播通信时，可以尝试开启此参数，默认情况下会把组播当作广播发给所有节点
+
+### -u
+
+设置虚拟网卡的mtu值，大多数情况下使用默认值效率会更高，也可根据实际情况微调这个值
+
+

switch-cmd/src/command/client.rs

@@ -0,0 +1,84 @@
+use std::io;
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket};
+use std::str::FromStr;
+use std::time::Duration;
+
+use crate::command::entity::{DeviceItem, RouteItem, Info};
+
+pub struct CommandClient {
+    udp: UdpSocket,
+}
+
+impl CommandClient {
+    pub fn new() -> io::Result<Self> {
+        let path_buf = dirs::home_dir().unwrap().join(".switch_desktop").join("command-port");
+        if !path_buf.exists() {
+            return Err(io::Error::new(io::ErrorKind::Other, "not started"));
+        }
+        let port = std::fs::read_to_string(path_buf)?;
+        let port = match u16::from_str(&port) {
+            Ok(port) => { port }
+            Err(_) => {
+                return Err(io::Error::new(io::ErrorKind::Other, "'command-port' file error"));
+            }
+        };
+        let udp = UdpSocket::bind("127.0.0.1:0")?;
+        udp.set_read_timeout(Some(Duration::from_secs(2)))?;
+        udp.connect(SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::new(127, 0, 0, 1),
+            port,
+        )))?;
+        Ok(Self { udp })
+    }
+}
+
+impl CommandClient {
+    pub fn list(&self) -> io::Result<Vec<DeviceItem>> {
+        self.udp.send(b"list")?;
+        let mut buf = [0; 10240];
+        let len = self.udp.recv(&mut buf)?;
+        match serde_json::from_slice::<Vec<DeviceItem>>(&buf[..len]) {
+            Ok(val) => {
+                Ok(val)
+            }
+            Err(e) => {
+                log::error!("{:?}",e);
+                Err(io::Error::new(io::ErrorKind::Other, "data error"))
+            }
+        }
+    }
+    pub fn route(&self) -> io::Result<Vec<RouteItem>> {
+        self.udp.send(b"route")?;
+        let mut buf = [0; 10240];
+        let len = self.udp.recv(&mut buf)?;
+        match serde_json::from_slice::<Vec<RouteItem>>(&buf[..len]) {
+            Ok(val) => {
+                Ok(val)
+            }
+            Err(e) => {
+                log::error!("{:?}",e);
+                Err(io::Error::new(io::ErrorKind::Other, "data error"))
+            }
+        }
+    }
+    pub fn info(&self) -> io::Result<Info> {
+        self.udp.send(b"info")?;
+        let mut buf = [0; 10240];
+        let len = self.udp.recv(&mut buf)?;
+        match serde_json::from_slice::<Info>(&buf[..len]) {
+            Ok(val) => {
+                Ok(val)
+            }
+            Err(e) => {
+                log::error!("{:?},{:?}",&buf[..len],e);
+                Err(io::Error::new(io::ErrorKind::Other, "data error"))
+            }
+        }
+    }
+    pub fn stop(&self) -> io::Result<String> {
+        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())
+    }
+}

switch-cmd/src/command/entity.rs

@@ -0,0 +1,34 @@
+use serde::{Deserialize, Serialize};
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Info {
+    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,
+}

switch-cmd/src/command/mod.rs

@@ -0,0 +1,141 @@
+use std::io;
+use switch::core::Switch;
+use crate::command::entity::{DeviceItem, RouteItem, Info};
+use crate::console_out;
+
+pub mod client;
+pub mod server;
+pub mod entity;
+
+pub enum CommandEnum {
+    Route,
+    List,
+    All,
+    Info,
+    Stop,
+}
+
+pub fn command(cmd: CommandEnum) {
+    if let Err(e) = command_(cmd) {
+        println!("cmd: {}", e);
+    }
+}
+
+fn command_(cmd: CommandEnum) -> io::Result<()> {
+    let command_client = client::CommandClient::new()?;
+    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::All => {
+            let list = command_client.list()?;
+            console_out::console_device_list_all(list);
+        }
+        CommandEnum::Info => {
+            let info = command_client.info()?;
+            console_out::console_info(info);
+        }
+        CommandEnum::Stop => {
+            command_client.stop()?;
+        }
+    }
+    Ok(())
+}
+
+pub fn command_route(switch: &Switch) -> Vec<RouteItem> {
+    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<DeviceItem> {
+    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<String> = 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_info(switch: &Switch) -> Info {
+    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<String> = 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();
+    Info {
+        name,
+        virtual_ip,
+        virtual_gateway,
+        virtual_netmask,
+        connect_status,
+        relay_server,
+        nat_type,
+        public_ips,
+        local_ip,
+    }
+}
+

switch-cmd/src/command/server.rs

@@ -0,0 +1,105 @@
+use std::io;
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+use tokio::net::UdpSocket;
+
+use switch::core::Switch;
+
+
+pub struct CommandServer {}
+
+impl CommandServer {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl CommandServer {
+    pub async fn start(self, switch: Switch) -> io::Result<()> {
+        let mut port = 21637 as u16;
+        let udp = loop {
+            match UdpSocket::bind(SocketAddr::V4(SocketAddrV4::new(
+                Ipv4Addr::new(127, 0, 0, 1),
+                port,
+            ))).await {
+                Ok(udp) => {
+                    break udp;
+                }
+                Err(e) => {
+                    if e.kind() == io::ErrorKind::AddrInUse {
+                        port += 1;
+                    } else {
+                        log::error!("创建udp失败 {:?}", e);
+                        return Err(e);
+                    }
+                }
+            }
+        };
+        let path_buf = dirs::home_dir().unwrap().join(".switch_desktop").join("command-port");
+        if !path_buf.parent().unwrap().exists() {
+            std::fs::create_dir_all(path_buf.parent().unwrap())?;
+        }
+        std::fs::write(path_buf,udp.local_addr()?.port().to_string())?;
+        let mut buf = [0u8; 64];
+        loop {
+            let (len, addr) = udp.recv_from(&mut buf).await?;
+            match std::str::from_utf8(&buf[..len]) {
+                Ok(cmd) => {
+                    if let Ok(out) = command(cmd, &switch) {
+                        let _ = udp.send_to(out.as_bytes(), addr).await;
+                        if "stopped" == &out {
+                             break;
+                        }
+                    }
+                }
+                Err(e) => {
+                    log::warn!("{:?}", e);
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+
+fn command(cmd: &str, switch: &Switch) -> io::Result<String> {
+    let out_str = match cmd {
+        "route" => {
+            match serde_json::to_string(&crate::command::command_route(switch)) {
+                Ok(str) => {
+                    str
+                }
+                Err(e) => {
+                    format!("{:?}", e)
+                }
+            }
+        }
+        "list" => {
+            match serde_json::to_string(&crate::command::command_list(switch)) {
+                Ok(str) => {
+                    str
+                }
+                Err(e) => {
+                    format!("{:?}", e)
+                }
+            }
+        }
+        "info" => {
+            match serde_json::to_string(&crate::command::command_info(switch)) {
+                Ok(str) => {
+                    str
+                }
+                Err(e) => {
+                    format!("{:?}", e)
+                }
+            }
+        }
+        "stop" => {
+            switch.stop()?;
+            "stopped".to_string()
+        }
+        _ => {
+            format!("command '{}' not found. \n Try to enter: 'help'\n", cmd)
+        }
+    };
+    Ok(out_str)
+}

switch-cmd/src/console_out/mod.rs

@@ -0,0 +1,133 @@
+use console::{style, Style};
+
+use crate::command::entity::{DeviceItem, RouteItem, Info};
+
+pub mod table;
+
+pub fn console_info(status: Info) {
+    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<RouteItem>) {
+    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<DeviceItem>) {
+    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<DeviceItem>) {
+    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)
+}

switch-cmd/src/console_out/table.rs

@@ -0,0 +1,23 @@
+use console::Style;
+
+pub fn println_table(table: Vec<Vec<(String, Style)>>) {
+    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!()
+    }
+}

switch-cmd/src/main.rs

@@ -0,0 +1,269 @@
+use std::net::ToSocketAddrs;
+use std::str::FromStr;
+#[cfg(not(feature = "mini"))]
+use console::style;
+use getopts::Options;
+use tokio::io::{AsyncBufReadExt, BufReader};
+use common::args_parse::ips_parse;
+use switch::core::{Config, SwitchUtil};
+use switch::handle::registration_handler::ReqEnum;
+
+mod command;
+mod console_out;
+
+#[tokio::main]
+async fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let program = args[0].clone();
+    let mut opts = Options::new();
+    opts.long_only(false);
+    opts.optopt("k", "", &format!("{}", green("使用相同的token,就能组建一个局域网络".to_string())), "<token>");
+    opts.optopt("n", "", "给设备一个名字", "<name>");
+    opts.optopt("d", "", "设备唯一标识符,凭id分配ip", "<id>");
+    #[cfg(not(feature = "mini"))]
+    opts.optflag("c", "", "关闭交互式命令");
+    opts.optopt("s", "", "注册和中继服务器地址", "<server>");
+    opts.optopt("e", "", "NAT探测服务器地址,使用逗号分隔", "<addr1,addr2>");
+    opts.optflag("a", "", "使用tap模式,默认使用tun模式");
+    opts.optmulti("i", "", "配置点对网(IP代理)时使用,--in-ip 192.168.10.0/24,10.26.0.3，表示允许接收网段192.168.10.0/24的数据并转发到10.26.0.3", "<in-ip>");
+    opts.optmulti("o", "", "配置点对网时使用,--out-ip 192.168.10.0/24,192.168.1.10，表示允许目标为192.168.10.0/24的数据从网卡192.168.1.10转发出去", "<out-ip>");
+    opts.optopt("w", "", "使用该密码生成的密钥对客户端数据进行加密,并且服务端无法解密,使用相同密码的客户端才能通信", "<password>");
+    opts.optflag("m", "", "模拟组播,默认情况下组播数据会被当作广播发送,开启后会模拟真实组播的数据发送");
+    opts.optopt("u", "", "虚拟网卡mtu值", "<mtu>");
+    //"后台运行时,查看其他设备列表"
+    opts.optflag("", "list", &format!("{}", yellow("后台运行时,查看其他设备列表".to_string())));
+    opts.optflag("", "all", &format!("{}", yellow("后台运行时,查看其他设备完整信息".to_string())));
+    opts.optflag("", "info", &format!("{}", yellow("后台运行时,查看当前设备信息".to_string())));
+    opts.optflag("", "route", &format!("{}", yellow("后台运行时,查看数据转发路径".to_string())));
+    opts.optflag("", "stop", &format!("{}", yellow("停止后台运行".to_string())));
+    opts.optflag("h", "help", "帮助");
+    let matches = match opts.parse(&args[1..]) {
+        Ok(m) => { m }
+        Err(f) => {
+            print_usage(&program, opts);
+            println!("{}", f.to_string());
+            return;
+        }
+    };
+    if matches.opt_present("l") {
+        command::command(command::CommandEnum::List);
+        return;
+    } else if matches.opt_present("f") {
+        command::command(command::CommandEnum::Info);
+        return;
+    } else if matches.opt_present("q") {
+        command::command(command::CommandEnum::Stop);
+        return;
+    } else if matches.opt_present("r") {
+        command::command(command::CommandEnum::Route);
+        return;
+    } else if matches.opt_present("z") {
+        command::command(command::CommandEnum::All);
+        return;
+    }
+    if matches.opt_present("h") {
+        print_usage(&program, opts);
+        return;
+    }
+    if !matches.opt_present("k") {
+        print_usage(&program, opts);
+        println!("parameter -k not found .");
+        return;
+    }
+    let tap = matches.opt_present("a");
+    let token: String = matches.opt_get("k").unwrap().unwrap();
+    let device_id = matches.opt_get_default("d", String::new()).unwrap();
+    #[cfg(not(feature = "mini"))]
+        let device_id = if device_id.is_empty() {
+        common::identifier::get_unique_identifier().unwrap_or(String::new())
+    } else {
+        device_id
+    };
+    if device_id.is_empty() {
+        print_usage(&program, opts);
+        println!("parameter -d not found .");
+        return;
+    }
+    let name = matches.opt_get_default("n", os_info::get().to_string()).unwrap();
+    let server_address_str = matches.opt_get_default("s", "nat1.wherewego.top:29871".to_string()).unwrap();
+    let server_address = server_address_str.to_socket_addrs().unwrap().next().unwrap();
+    let nat_test_server = matches.opt_get_default("e",
+                                                  "nat1.wherewego.top:35061,nat1.wherewego.top:35062,nat2.wherewego.top:35061,nat2.wherewego.top:35062".to_string()).unwrap();
+
+    let nat_test_server = nat_test_server.split(",").flat_map(|a| a.to_socket_addrs()).flatten()
+        .collect::<Vec<_>>();
+
+    let in_ip = matches.opt_strs("i");
+    let in_ip = match ips_parse(&in_ip) {
+        Ok(in_ip) => { in_ip }
+        Err(e) => {
+            print_usage(&program, opts);
+            println!();
+            println!("-i {}", e);
+            return;
+        }
+    };
+    let out_ip = matches.opt_strs("o");
+    let out_ip = match ips_parse(&out_ip) {
+        Ok(out_ip) => { out_ip }
+        Err(e) => {
+            print_usage(&program, opts);
+            println!();
+            println!("-o {}", e);
+            return;
+        }
+    };
+    let password: Option<String> = matches.opt_get("w").unwrap();
+    let simulate_multicast = matches.opt_present("m");
+    #[cfg(feature = "mini")]
+        let unused_cmd = true;
+    #[cfg(not(feature = "mini"))]
+        let unused_cmd = matches.opt_present("c");
+    let mtu: Option<String> = matches.opt_get("u").unwrap();
+    let mtu = if let Some(mtu) = mtu {
+        match u16::from_str(&mtu) {
+            Ok(mtu) => {
+                Some(mtu)
+            }
+            Err(e) => {
+                print_usage(&program, opts);
+                println!();
+                println!("-u {}", e);
+                return;
+            }
+        }
+    } else {
+        None
+    };
+    let config = Config::new(tap,
+                             token, device_id, name,
+                             server_address, server_address_str,
+                             nat_test_server, in_ip,
+                             out_ip, password, simulate_multicast, mtu);
+    let mut switch_util = SwitchUtil::new(config).await.unwrap();
+    let response = loop {
+        match switch_util.connect().await {
+            Ok(response) => {
+                break response;
+            }
+            Err(e) => {
+                match e {
+                    ReqEnum::TokenError => {
+                        println!("token error");
+                    }
+                    ReqEnum::AddressExhausted => {
+                        println!("address exhausted");
+                    }
+                    ReqEnum::Timeout => {
+                        println!("timeout...");
+                        continue;
+                    }
+                    ReqEnum::ServerError(str) => {
+                        println!("error:{}", str);
+                    }
+                    ReqEnum::Other(str) => {
+                        println!("error:{}", str);
+                    }
+                }
+                return;
+            }
+        }
+    };
+    println!(" ====== Connect Successfully ====== ");
+    println!("virtual_gateway:{}", response.virtual_gateway);
+    println!("virtual_ip:{}", green(response.virtual_ip.to_string()));
+    let driver_info = switch_util.create_iface().unwrap();
+    println!(" ====== Create Network Interface Successfully ====== ");
+    println!("name:{}", driver_info.name);
+    println!("version:{}", driver_info.version);
+    let mut switch = match switch_util.build().await {
+        Ok(switch) => {
+            switch
+        }
+        Err(e) => {
+            println!("error:{}", e);
+            return;
+        }
+    };
+    println!(" ====== Start Successfully ====== ");
+    let switch_s = switch.clone();
+    tokio::spawn(async {
+        if let Err(e) = command::server::CommandServer::new().start(switch_s).await {
+            println!("command error :{}", e);
+        }
+    });
+    if unused_cmd {
+        switch.wait_stop().await;
+    } else {
+        #[cfg(not(feature = "mini"))]
+        {
+            let stdin = tokio::io::stdin();
+            let mut cmd = String::new();
+            let mut reader = BufReader::new(stdin);
+            loop {
+                cmd.clear();
+                println!("input:list,info,route,all,stop");
+                tokio::select! {
+                _ = switch.wait_stop()=>{
+                    break;
+                }
+                rs = reader.read_line(&mut cmd)=>{
+                     match rs {
+                        Ok(len) => {
+                            if len ==0 {
+                                break;
+                            }
+                            match cmd[..len].to_lowercase().trim() {
+                                "list" => {
+                                    let list = command::command_list(&switch);
+                                    console_out::console_device_list(list);
+                                }
+                                "info"=>{
+                                    let info = command::command_info(&switch);
+                                    console_out::console_info(info);
+                                }
+                                "route" =>{
+                                    let route = command::command_route(&switch);
+                                    console_out::console_route_table(route);
+                                }
+                                "all" =>{
+                                    let list = command::command_list(&switch);
+                                    console_out::console_device_list_all(list);
+                                }
+                                "stop" =>{
+                                    let _ = switch.stop();
+                                    break;
+                                }
+                                _ => {
+                                }
+                            }
+                            println!();
+                        }
+                        Err(e) => {
+                            println!("input err:{}",e);
+                            break;
+                        }
+                    }
+                }
+            }
+            }
+            switch.wait_stop().await;
+        }
+    }
+    std::process::exit(0);
+}
+
+fn print_usage(program: &str, opts: Options) {
+    let brief = format!("Usage: {} [options]", program);
+    println!("version:1.1.0");
+    println!("{}", opts.usage(&brief));
+}
+
+fn green(str: String) -> impl std::fmt::Display {
+    style(str).green()
+}
+
+fn yellow(str: String) -> impl std::fmt::Display {
+    style(str).yellow()
+}
+