支持客户端加密

update from upstream

.github/workflows/rust.yml

@@ -0,0 +1,154 @@
+name: Rust
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  CARGO_TERM_COLOR: always
+
+defaults:
+  run:
+    # necessary for windows
+    shell: bash
+
+jobs:
+  #  test:
+  #    runs-on: ubuntu-latest
+  #    steps:
+  #      - uses: actions/checkout@v2
+  #      - name: Init submodules
+  #        uses: snickerbockers/submodules-init@v4
+  #      - name: Cargo cache
+  #        uses: actions/cache@v2
+  #        with:
+  #          path: |
+  #            ~/.cargo/registry
+  #            ./target
+  #          key: test-cargo-registry
+  #      - name: List
+  #        run: find ./
+  #      - name: Run tests
+  #        run: cargo test --verbose
+
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        # a list of all the targets
+        include:
+          - TARGET: i686-unknown-linux-musl # test in an alpine container on a mac
+            OS: ubuntu-latest
+          - TARGET: x86_64-unknown-linux-gnu # tested in a debian container on a mac
+            OS: ubuntu-latest
+          - TARGET: x86_64-unknown-linux-musl # test in an alpine container on a mac
+            OS: ubuntu-latest
+          - TARGET: aarch64-unknown-linux-gnu # tested on aws t4g.nano
+            OS: ubuntu-latest
+          - TARGET: aarch64-unknown-linux-musl # tested on aws t4g.nano in alpine container
+            OS: ubuntu-latest
+          - TARGET: armv7-unknown-linux-gnueabihf # raspberry pi 2-3-4, not tested
+            OS: ubuntu-latest
+          - TARGET: armv7-unknown-linux-musleabihf # raspberry pi 2-3-4, not tested
+            OS: ubuntu-latest
+          - TARGET: arm-unknown-linux-gnueabihf # raspberry pi 0-1, not tested
+            OS: ubuntu-latest
+          - TARGET: arm-unknown-linux-musleabihf # raspberry pi 0-1, not tested
+            OS: ubuntu-latest
+          - TARGET: x86_64-apple-darwin # tested on a mac, is not properly signed so there are security warnings
+            OS: macos-latest
+          - TARGET: i686-pc-windows-msvc # tested on a windows machine
+            OS: windows-latest
+          - TARGET: x86_64-pc-windows-msvc # tested on a windows machine
+            OS: windows-latest
+    # needs: test
+    runs-on: ${{ matrix.OS }}
+    env:
+      NAME: switch-desktop # change with the name of your project
+      TARGET: ${{ matrix.TARGET }}
+      OS: ${{ matrix.OS }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Init submodules
+        uses: snickerbockers/submodules-init@v4
+      - name: Cargo cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cargo/registry
+            ./target
+          key: build-cargo-registry-${{matrix.TARGET}}
+      - name: List
+        run: find ./
+      - name: Install and configure dependencies
+        run: |
+          # dependencies are only needed on ubuntu as that's the only place where
+          # we make cross-compilation
+          if [[ $OS =~ ^ubuntu.*$ ]]; then
+            sudo apt-get update && sudo apt-get install -qq crossbuild-essential-arm64 crossbuild-essential-armhf
+          fi
+          # some additional configuration for cross-compilation on linux
+          cat >>~/.cargo/config <<EOF
+          [target.aarch64-unknown-linux-gnu]
+          linker = "aarch64-linux-gnu-gcc"
+          [target.aarch64-unknown-linux-musl]
+          linker = "aarch64-linux-gnu-gcc"
+          [target.armv7-unknown-linux-gnueabihf]
+          linker = "arm-linux-gnueabihf-gcc"
+          [target.armv7-unknown-linux-musleabihf]
+          linker = "arm-linux-gnueabihf-gcc"
+          [target.arm-unknown-linux-gnueabihf]
+          linker = "arm-linux-gnueabihf-gcc"
+          [target.arm-unknown-linux-musleabihf]
+          linker = "arm-linux-gnueabihf-gcc"
+          EOF
+      - name: Install rust target
+        run: rustup target add $TARGET
+      - name: Run build
+        run: cargo build --package switch-desktop --release --verbose --target $TARGET
+      - name: List target
+        run: find ./target
+      - name: Compress
+        run: |
+          mkdir -p ./artifacts
+          # windows is the only OS using a different convention for executable file name
+          if [[ $OS =~ ^windows.*$ ]]; then
+              EXEC=$NAME.exe
+          else
+              EXEC=$NAME
+          fi
+          if [[ $GITHUB_REF_TYPE =~ ^tag$ ]]; then
+            TAG=$GITHUB_REF_NAME
+          else
+            TAG=$GITHUB_SHA
+          fi
+          mv ./target/$TARGET/release/$EXEC ./$EXEC
+          tar -czf ./artifacts/$NAME-$TARGET-$TAG.tar.gz $EXEC
+      - name: Archive artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: switch-desktop
+          path: |
+            ./artifacts
+  # deploys to github releases on tag
+  deploy:
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: switch-desktop
+          path: ./artifacts
+      - name: List
+        run: find ./artifacts
+      - name: Release
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.YOURTOKEN }}
+          file: ./artifacts/*.tar.gz
+          tag: ${{ github.ref }}
+          overwrite: true
+          file_glob: true

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "switch/p2p_channel"]
-	path = switch/p2p_channel
-	url = [email protected]:lbl8603/p2p_channel.git

Cargo.toml

@@ -1,2 +1,14 @@
 [workspace]
-members = ["switch","switch-desktop","switch-jni"]
+members = ["switch","switch-desktop"]
+
+[profile.release]
+opt-level = 'z'
+debug = 0
+debug-assertions = false
+strip= "debuginfo"
+overflow-checks = true
+lto = true
+panic = 'abort'
+incremental = false
+codegen-units = 1
+rpath = false

README.md

@@ -4,14 +4,14 @@
 将不同网络下的多个设备虚拟到一个局域网下
 
 
-### 示例：
+### 快速使用：
 
 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  &
+      # 在另一台linux上使用nohup后台运行
+      [root@izj6cemne76ykdzkataftfz switch]# nohup ./switch-desktop start --token 123456 &
       # windows上
       D:\switch\bin_v1>switch-desktop.exe start --token 123456
     ```
@@ -42,12 +42,14 @@
    2. ssh
    
       <img width="506" alt="ssh" src="https://raw.githubusercontent.com/lbl8603/switch/dev/documents/img/ssh.jpg">
+5. 帮助，使用-h命令查看
 
 ### 更多玩法
 
 1. 和远程桌面(如mstsc)搭配，超低延迟的体验
 2. 安装samba服务，共享磁盘
 3. 搭配公网服务器nginx反向代理，在公网访问本地文件
+4. 点对网(结合启动参数'--in-ip'和'--out-ip')
 
 
 ### 使用须知
@@ -67,17 +69,30 @@
 - Mac
 - Linux
 - Windows
-  - 依赖 wintun.dll(https://www.wintun.net/)
+  - 使用tun网卡 依赖wintun.dll(https://www.wintun.net/ )(将dll放到同目录下，建议使用版本0.14.1)
+  - 使用tap网卡 依赖tap-windows(https://build.openvpn.net/downloads/releases/ )(建议使用版本9.24.7)
 
 ### 特性
 - IP层数据转发
   - tun虚拟网卡
+  - tap虚拟网卡
 - NAT穿透
   - 点对点穿透
   - 服务端中继转发
   - 客户端中继转发
+- IP代理
+- p2p组播/广播
+- 客户端数据加密
 
 ### Todo
 - 支持安卓
-- 数据加密
+- 服务端数据加密
 
+### 常见问题
+#### 问题1: 设置网络地址失败
+##### 可能原因:
+switch默认使用10.26.0.0/24网段，和本地网络适配器的ip冲突
+##### 解决方法:
+1. 方法一：找到冲突的IP，将其改成别的
+2. 方法二：自建服务器，指定其他不会冲突的网段
+3. 方法三：增加参数--device-id，设置不同的id会让switch-server分配不同的IP，从而绕开有冲突的IP

switch-desktop/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "switch-desktop"
-version = "0.1.0"
+version = "1.0.6"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -13,9 +13,10 @@ 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.28.1", features = ["full"] }
 chrono = "0.4.23"
 
+rust-i18n = "1.2.2"
 serde = "1.0"
 serde_yaml = "0.9"
 serde_json = "1.0.94"
@@ -28,9 +29,10 @@ fs2 = "0.4.3"
 os_info = "3.5.1"
 [target.'cfg(any(target_os = "linux",target_os = "macos"))'.dependencies]
 sudo = "0.6.0"
+libc = "0.2"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version = "0.3.9", features = ["handleapi", "processthreadsapi", "winnt", "securitybaseapi", "impl-default"] }
 #runas = "0.2.1"
-windows-service = "0.5.0"
+windows-service = "0.6.0"
 

switch-desktop/locales/en.yml

@@ -0,0 +1,50 @@
+switch_about: "A virtual network tool that will obtain an ip after startup. Devices under the same token will form a virtual local area network, and can use ip to communicate directly with each other."
+switch_usage: "switch-desktop.exe <COMMAND>"
+switch_start_about: "Start switch"
+switch_token_help: "Using the same token, you can build a local area network. It is recommended to use a more complex token to avoid connecting to other people's local area network"
+switch_name_help: "Give the device a name, the system version information will be used by default"
+switch_device_id_help: "The unique identifier of the device, the ip is assigned according to the id, and the MAC address is used by default"
+switch_server_help: "Registry and relay server address, public server is used by default"
+switch_nat_test_server_help: "NAT detection server addresses, separated by commas"
+switch_log_help: "Record the log, the output is in the '${home}/.switch_desktop' directory, it is not recommended to open it for long-term use"
+switch_tap_help: "Use tap mode, tun mode will be used by default"
+switch_in_ip_help: "Use when configuring point-to-network (IP proxy), --in-ip 192.168.10.0/24,10.26.0.3, which means it is allowed to receive data from the network segment 192.168.10.0/24 and forward it to 10.26.0.3"
+switch_out_ip_help: "Use when configuring point-to-network, --out-ip 192.168.10.0/24,192.168.1.10, which means that the data with the target of 192.168.10.0/24 is allowed to be forwarded from the network card 192.168.1.10"
+switch_password_help: "Client Data Encryption"
+switch_config_help: "Read configuration file"
+switch_stop_about: "Stop background service"
+switch_route_about: "View route"
+switch_list_about: "View device list"
+switch_list_all_help: "View full information"
+switch_status_about: "View current device information"
+switch_install_about: "Install windows service"
+switch_path_help: "Service installation path, it is recommended to use an empty directory"
+switch_auto_help: "Service starts automatically at boot"
+switch_uninstall_about: "Uninstall windows service"
+switch_config_about: "Change Windows Service Configuration"
+
+switch_use_admin_print: "Please run with administrator privileges"
+switch_use_root_print: "Please run with root privileges"
+switch_service_not_start_print: "service not started"
+switch_start_successfully_print: "Start successfully"
+switch_start_failed_print: "Startup failed"
+switch_service_not_stopped_print: "service not stopped"
+switch_stopped_print: "stopped"
+switch_server_already_installed_print: "service is installed"
+
+
+switch_repeated_start_print: "cannot be restarted repeatedly"
+
+switch_token_not_found_print: "missing token"
+switch_token_cannot_be_empty_print: "token cannot be empty"
+switch_token_cannot_exceed_64_print: "token cannot exceed 64 characters"
+switch_device_id_is_empty_print: "The device id cannot be empty and the length cannot be greater than 64 characters"
+switch_in_ips_example_print: "in_ips Parameter error Example:--in_ip 192.168.10.0/24,10.26.0.3"
+switch_out_ips_example_print: "out_ips Parameter error Example:--out_ip 192.168.10.0/24,192.168.0.5"
+switch_relay_server_address_error: "Wrong relay server address"
+switch_nat_test_server_address_error: "NAT detection service address error"
+switch_press_any_key_to_exit: "Press any key to exit"
+
+switch_virtual_ip: "virtual ip"
+switch_virtual_gateway: "virtual gateway"
+switch_please_enter_the_command: "Please enter the command (Usage: list,route,status,exit,help):"

switch-desktop/locales/zh-CN.yml

@@ -0,0 +1,50 @@
+switch_about: "一个虚拟网络工具,启动后会获取一个ip,相同token下的设备会组件虚拟局域网,之间可以用ip直接通信"
+switch_usage: "switch-desktop.exe <命令>"
+switch_start_about: "启动switch"
+switch_token_help: "使用相同的token，就能组建一个局域网络，建议使用一个复杂一点的token，避免连到其他人的局域网中"
+switch_name_help: "给设备一个名字，默认会使用系统版本信息"
+switch_device_id_help: "设备唯一标识符，凭id分配ip，默认使用MAC地址"
+switch_server_help: "注册和中继服务器地址，默认使用公共服务器"
+switch_nat_test_server_help: "NAT探测服务器地址，使用逗号分隔"
+switch_log_help: "记录日志，输出在 '${home}/.switch_desktop' 目录下，长时间使用时不建议开启"
+switch_tap_help: "使用tap模式，默认会使用tun模式"
+switch_in_ip_help: "配置点对网(IP代理)时使用，--in-ip 192.168.10.0/24,10.26.0.3，表示允许接收网段192.168.10.0/24的数据并转发到10.26.0.3"
+switch_out_ip_help: "配置点对网时使用，--out-ip 192.168.10.0/24,192.168.1.10，表示允许目标为192.168.10.0/24的数据从网卡192.168.1.10转发出去"
+switch_password_help: "使用该密码生成的密钥对客户端数据进行加密，并且服务端无法解密。使用相同密码的客户端才能通信"
+switch_config_help: "读取配置文件"
+switch_stop_about: "停止后台服务"
+switch_route_about: "查看路由"
+switch_list_about: "查看设备列表"
+switch_list_all_help: "查看完整信息"
+switch_status_about: "查看当前设备信息"
+switch_install_about: "安装Windows服务"
+switch_path_help: "服务安装路径，建议使用一个空目录"
+switch_auto_help: "服务开机自启动"
+switch_uninstall_about: "卸载Windows服务"
+switch_config_about: "改变Windows服务配置"
+
+switch_use_admin_print: "请使用管理员权限运行"
+switch_use_root_print: "请使用root权限运行"
+switch_service_not_start_print: "服务未启动"
+switch_start_successfully_print: "启动成功"
+switch_start_failed_print: "启动失败"
+switch_service_not_stopped_print: "服务未停止"
+switch_stopped_print: "已停止"
+switch_server_already_installed_print: "服务已经安装"
+
+
+switch_repeated_start_print: "不能重复启动"
+
+switch_token_not_found_print: "缺少token"
+switch_token_cannot_be_empty_print: "token不能为空"
+switch_token_cannot_exceed_64_print: "token不能超过64个字符"
+switch_device_id_is_empty_print: "设备id不能为空并且长度不能大于64字符"
+switch_in_ips_example_print: "in_ips 参数错误 示例：--in_ip 192.168.10.0/24,10.26.0.3"
+switch_out_ips_example_print: "out_ips 参数错误 示例：--out_ip 192.168.10.0/24,192.168.0.5"
+switch_relay_server_address_error: "中继服务器地址错误"
+switch_nat_test_server_address_error: "NAT检测服务地址错误"
+switch_press_any_key_to_exit: "按任意键退出"
+
+switch_virtual_ip: "当前虚拟ip(virtual ip)"
+switch_virtual_gateway: "虚拟网关(virtual gateway)"
+switch_please_enter_the_command: "输入命令 (例如: list,route,status,exit,help):"

switch-desktop/src/command/server.rs

@@ -182,7 +182,7 @@ fn command(cmd: &str, switch: &Switch) -> io::Result<String> {
             "stopping".to_string()
         }
         _ => {
-            format!("command '{}' not fount. \n Try to enter: 'help'\n", cmd)
+            format!("command '{}' not found. \n Try to enter: 'help'\n", cmd)
         }
     };
     Ok(out_str)

switch-desktop/src/command_args.rs

@@ -0,0 +1,133 @@
+use clap::{Arg, ArgAction, Command};
+use clap::builder::BoolishValueParser;
+use crate::i18n::*;
+
+fn common() -> Command {
+    Command::new("switch-desktop")
+        .about(switch_about())
+        // .version(switch_version())
+        .subcommand_required(true)
+        .arg_required_else_help(true)
+        // .author(switch_author())
+        .override_usage(switch_usage())
+        .subcommand(
+            Command::new("start")
+                .about(switch_start_about())
+                .arg(
+                    Arg::new("token")
+                        .long("token")
+                        .help(switch_token_help())
+                        .action(ArgAction::Set)
+                )
+                .arg(
+                    Arg::new("name")
+                        .long("name")
+                        .help(switch_name_help())
+                        .action(ArgAction::Set)
+                )
+                .arg(
+                    Arg::new("device_id")
+                        .long("device-id")
+                        .help(switch_device_id_help())
+                        .action(ArgAction::Set)
+                ).arg(
+                Arg::new("server")
+                    .long("server")
+                    .help(switch_server_help())
+                    .action(ArgAction::Set)
+            ).arg(
+                Arg::new("nat_test_server")
+                    .long("nat-test-server")
+                    .help(switch_nat_test_server_help())
+                    .action(ArgAction::Set)
+            ).arg(
+                Arg::new("log")
+                    .long("log")
+                    .help(switch_log_help())
+                    .action(ArgAction::SetTrue)
+                    .value_parser(BoolishValueParser::new()),
+            ).arg(
+                Arg::new("tap")
+                    .long("tap")
+                    .help(switch_tap_help())
+                    .action(ArgAction::SetTrue),
+            ).arg(
+                Arg::new("in_ip")
+                    .long("in-ip")
+                    .help(switch_in_ip_help())
+                    .action(ArgAction::Append)
+                    .num_args(1..),
+            ).arg(
+                Arg::new("out_ip")
+                    .long("out-ip")
+                    .help(switch_out_ip_help())
+                    .action(ArgAction::Append)
+            ).arg(
+                Arg::new("password")
+                    .long("password")
+                    .help(switch_password_help())
+                    .action(ArgAction::Set)
+            ).arg(
+                Arg::new("config")
+                    .long("config")
+                    .help(switch_config_help())
+                    .action(ArgAction::Set)
+            )
+            ,
+        ).subcommand(
+        Command::new("stop")
+            .about(switch_stop_about()))
+        .subcommand(
+            Command::new("route")
+                .about(switch_route_about()))
+        .subcommand(Command::new("list")
+            .about(switch_list_about()).arg(
+            Arg::new("all")
+                .long("all")
+                .short('a')
+                .help(switch_list_all_help())
+                .action(ArgAction::SetTrue)
+                .value_parser(BoolishValueParser::new()), ))
+        .subcommand(Command::new("status")
+            .about(switch_status_about()))
+}
+
+pub fn check() -> bool {
+    #[cfg(windows)]
+        let cmd = common().subcommand(Command::new("install")
+        .about(switch_install_about())
+        .arg(
+            Arg::new("path")
+                .long("path")
+                .help(switch_path_help())
+                .action(ArgAction::Set)
+                .num_args(1..))
+        .arg(
+            Arg::new("auto")
+                .long("auto")
+                .help(switch_auto_help())
+                .action(ArgAction::SetTrue)
+                .value_parser(BoolishValueParser::new()), ))
+        .subcommand(Command::new("uninstall")
+            .about(switch_uninstall_about()))
+        .subcommand(Command::new("config")
+            .about(switch_config_about())
+            .arg(
+                Arg::new("auto")
+                    .long("auto")
+                    .help(switch_auto_help())
+                    .action(ArgAction::SetTrue)
+                    .value_parser(BoolishValueParser::new()), ));
+    #[cfg(any(unix))]
+        let cmd = common();
+    match cmd.try_get_matches() {
+        Ok(_) => {
+            true
+        }
+        Err(e) => {
+            println!("{}", e);
+            false
+        }
+    }
+}
+

switch-desktop/src/config/log_config.rs

@@ -1,22 +1,17 @@
 use std::io;
-use crate::config::SWITCH_HOME_PATH;
+use std::path::PathBuf;
+use crate::config::get_home;
+
 #[cfg(target_os = "windows")]
 pub fn log_service_init() -> io::Result<()> {
-    log_init_("switch-service.log")
+    log_init_(crate::config::get_win_server_home().join("switch-service.log"))
 }
+
 pub fn log_init() -> io::Result<()> {
-    log_init_("switch.log")
+    log_init_(get_home().join("switch-desktop.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)?;
-    }
+
+fn log_init_(file_name: PathBuf) -> io::Result<()> {
     let stderr = log4rs::append::console::ConsoleAppender::builder()
         .target(log4rs::append::console::Target::Stderr)
         .build();
@@ -25,7 +20,7 @@ pub fn log_init_(file_name:&str) -> io::Result<()> {
         .encoder(Box::new(log4rs::encode::pattern::PatternEncoder::new(
             "{d(%+)(utc)} [{f}:{L}] {h({l})} {M}:{m}{n}\n",
         )))
-        .build(home.join(file_name))?;
+        .build(file_name)?;
     match log4rs::Config::builder()
         .appender(log4rs::config::Appender::builder().build("logfile", Box::new(logfile)))
         .appender(
@@ -47,4 +42,4 @@ pub fn log_init_(file_name:&str) -> io::Result<()> {
         Err(_) => {}
     }
     Ok(())
-}
+}

switch-desktop/src/config/mod.rs

@@ -1,43 +1,118 @@
 use std::fs::{File, OpenOptions};
 use std::io;
 use std::io::{Read, Write};
-use std::net::{SocketAddr, ToSocketAddrs};
+use std::net::{Ipv4Addr, SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
 
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use serde::{Deserialize, Serialize};
 
-use crate::StartArgs;
+use crate::{i18n, StartArgs};
 
 pub mod log_config;
+lazy_static! {
+    pub static ref SWITCH_HOME_PATH: Mutex<Option<PathBuf>> = Mutex::new(None);
+}
 
+#[cfg(windows)]
+pub fn get_win_server_home() -> PathBuf {
+    SWITCH_HOME_PATH.lock().as_ref().unwrap().clone()
+}
+
+#[cfg(windows)]
+pub fn set_win_server_home(home: PathBuf) {
+    let _ = SWITCH_HOME_PATH.lock().insert(home);
+}
+
+#[derive(Clone, Debug)]
 pub struct StartConfig {
+    pub tap: bool,
     pub name: String,
     pub token: String,
     pub server: SocketAddr,
     pub nat_test_server: Vec<SocketAddr>,
     pub device_id: String,
+    pub in_ips: Vec<(u32, u32, Ipv4Addr)>,
+    pub out_ips: Vec<(u32, u32, Ipv4Addr)>,
+    #[cfg(any(unix))]
+    pub off_command_server: bool,
+    pub log: bool,
+    pub password: Option<String>,
+}
+
+fn ips_parse(ips: &Vec<String>) -> Result<Vec<(u32, u32, Ipv4Addr)>, String> {
+    let mut in_ips_c = vec![];
+    for x in ips {
+        let mut split = x.split(",");
+        let net = if let Some(net) = split.next() {
+            net
+        } else {
+            return Err("参数错误".to_string());
+        };
+        let ip = if let Some(ip) = split.next() {
+            ip
+        } else {
+            return Err("参数错误".to_string());
+        };
+        let ip = if let Ok(ip) = ip.parse::<Ipv4Addr>() {
+            ip
+        } else {
+            return Err("参数错误".to_string());
+        };
+        let mut split = net.split("/");
+        let dest = if let Some(dest) = split.next() {
+            dest
+        } else {
+            return Err("参数错误".to_string());
+        };
+        let mask = if let Some(mask) = split.next() {
+            mask
+        } else {
+            return Err("参数错误".to_string());
+        };
+        let dest = if let Ok(dest) = dest.parse::<Ipv4Addr>() {
+            dest
+        } else {
+            return Err("参数错误".to_string());
+        };
+        let mask = if let Ok(m) = mask.parse::<u32>() {
+            let mut mask = 0 as u32;
+            for i in 0..m {
+                mask = mask | (1 << (31 - i));
+            }
+            mask
+        } else {
+            return Err("参数错误".to_string());
+        };
+        in_ips_c.push((u32::from_be_bytes(dest.octets()), mask, ip));
+    }
+    Ok(in_ips_c)
 }
 
 pub fn default_config(start_args: StartArgs) -> Result<StartConfig, String> {
-    let args_config = read_config();
-    if args_config.is_none() && start_args.token.is_none() {
-        return Err("找不到token(Token not found)".to_string());
+    println!("========参数配置========");
+    if start_args.log {
+        println!("print log");
     }
-    let token = start_args.token.unwrap_or_else(|| args_config.as_ref().unwrap().token.clone()).trim().to_string();
+    let tap = start_args.tap;
+    if tap {
+        println!("use tap");
+    } else {
+        println!("use tun");
+    }
+    if start_args.token.is_none() {
+        return Err(i18n::switch_token_not_found_print());
+    }
+    let token = start_args.token.unwrap();
     if token.is_empty() {
-        return Err("token不能为空(Token cannot be empty)".to_string());
+        return Err(i18n::switch_token_cannot_be_empty_print());
     }
     if token.len() > 64 {
-        return Err("token不能超过64字符(Token cannot exceed 64 characters)".to_string());
+        return Err(i18n::switch_token_cannot_exceed_64_print());
     }
+    println!("token:{:?}", token);
     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();
@@ -46,12 +121,8 @@ pub fn default_config(start_args: StartArgs) -> Result<StartConfig, String> {
     } else {
         name.to_string()
     };
+    println!("name:{:?}", name);
     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 {
@@ -59,82 +130,264 @@ pub fn default_config(start_args: StartArgs) -> Result<StartConfig, 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());
+        return Err(i18n::switch_device_id_is_empty_print());
     }
+    println!("device_id:{:?}", device_id);
+    let in_ips = start_args.in_ip.unwrap_or_else(|| {
+        vec![]
+    });
+    let out_ips = start_args.out_ip.unwrap_or_else(|| {
+        vec![]
+    });
+    println!("in_ips:{:?}", in_ips);
+    let in_ips_c = if let Ok(in_ips_c) = ips_parse(&in_ips) {
+        in_ips_c
+    } else {
+        return Err(i18n::switch_in_ips_example_print());
+    };
+    println!("out_ips:{:?}", out_ips);
+    let out_ips_c = if let Ok(out_ips_c) = ips_parse(&out_ips) {
+        out_ips_c
+    } else {
+        return Err(i18n::switch_out_ips_example_print());
+    };
+
+
     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());
+                return Err(i18n::switch_relay_server_address_error());
             }
         }
         Err(e) => {
-            return Err(format!("中继服务器地址错误( Relay server address error) :{:?}", e));
+            return Err(format!("{} :{:?}", i18n::switch_relay_server_address_error(), e));
         }
     };
+    println!("中继服务器:{:?}", server);
     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::<Vec<_>>();
     if nat_test_server.is_empty() {
-        return Err("NAT检测服务地址错误(NAT detection service address error)".to_string());
+        return Err(i18n::switch_nat_test_server_address_error());
     }
+    println!("NAT探测服务器:{:?}", nat_test_server);
     let base_config = StartConfig {
+        tap,
         name,
         token,
         server,
         nat_test_server,
         device_id,
+        in_ips: in_ips_c,
+        out_ips: out_ips_c,
+        #[cfg(any(unix))]
+        off_command_server: start_args.off_command_server,
+        log: start_args.log,
+        password: start_args.password,
     };
+    println!("========参数配置========");
     Ok(base_config)
 }
 
-lazy_static! {
-    static ref CONFIG: Mutex<Option<ArgsConfig>> = Mutex::new(None);
-    pub static ref SWITCH_HOME_PATH: Mutex<Option<PathBuf>> = Mutex::new(None);
+pub fn read_config_file(config_path: PathBuf) -> Result<StartConfig, String> {
+    println!("========读取配置文件========");
+    let args_config = if let Ok(config) = read_config(config_path) {
+        config
+    } else {
+        return Err("读取配置文件失败".to_string());
+    };
+    let log = args_config.log;
+    if log {
+        println!("print log");
+    }
+    let tap = args_config.tap;
+    if tap {
+        println!("use tap");
+    } else {
+        println!("use tun");
+    }
+    let token = args_config.token;
+    if token.is_empty() {
+        return Err(i18n::switch_token_cannot_be_empty_print());
+    }
+    if token.len() > 64 {
+        return Err(i18n::switch_token_cannot_exceed_64_print());
+    }
+    println!("token:{:?}", token);
+    let name = args_config.name;
+    let name = name.trim();
+    let name = if name.len() > 64 {
+        name[..64].to_string()
+    } else {
+        name.to_string()
+    };
+    println!("name:{:?}", name);
+    let device_id = if !args_config.device_id.is_empty() {
+        args_config.device_id
+    } else {
+        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(i18n::switch_device_id_is_empty_print());
+    }
+    println!("device_id:{:?}", device_id);
+    let in_ips = args_config.in_ips;
+    let out_ips = args_config.out_ips;
+    println!("in_ips:{:?}", in_ips);
+    let in_ips_c = if let Ok(in_ips_c) = ips_parse(&in_ips) {
+        in_ips_c
+    } else {
+        return Err(i18n::switch_in_ips_example_print());
+    };
+    println!("out_ips:{:?}", out_ips);
+    let out_ips_c = if let Ok(out_ips_c) = ips_parse(&out_ips) {
+        out_ips_c
+    } else {
+        return Err(i18n::switch_out_ips_example_print());
+    };
+    let server = match {
+        if !args_config.server.is_empty() {
+            args_config.server
+        } else {
+            "nat1.wherewego.top:29871".to_string()
+        }
+    }.to_socket_addrs()
+    {
+        Ok(mut server) => {
+            if let Some(addr) = server.next() {
+                addr
+            } else {
+                return Err(i18n::switch_relay_server_address_error());
+            }
+        }
+        Err(e) => {
+            return Err(format!("{}:{:?}", i18n::switch_relay_server_address_error(), e));
+        }
+    };
+    println!("中继服务器:{:?}", server);
+    let nat_test_server = if args_config.nat_test_server.is_empty() {
+        vec!["nat1.wherewego.top:35061".to_string(), "nat1.wherewego.top:35062".to_string(), "nat2.wherewego.top:35061".to_string(), "nat2.wherewego.top:35062".to_string()]
+    } else {
+        args_config.nat_test_server
+    }.iter().flat_map(|a| a.to_socket_addrs()).flatten()
+        .collect::<Vec<_>>();
+    if nat_test_server.is_empty() {
+        return Err(i18n::switch_nat_test_server_address_error());
+    }
+    println!("NAT探测服务器:{:?}", nat_test_server);
+    let base_config = StartConfig {
+        tap,
+        name,
+        token,
+        server,
+        nat_test_server,
+        device_id,
+        in_ips: in_ips_c,
+        out_ips: out_ips_c,
+        #[cfg(any(unix))]
+        off_command_server: args_config.off_command_server,
+        log,
+        password:args_config.password
+    };
+    println!("========参数配置========");
+    Ok(base_config)
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct RuntimeData {
+    #[serde(default = "default_pid")]
+    pub pid: u32,
+    pub command_port: Option<u16>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ArgsConfig {
+    #[serde(default = "default_false")]
+    pub tap: bool,
     #[serde(default = "default_version")]
     pub version: String,
     #[serde(default = "default_str")]
     pub token: String,
     #[serde(default = "default_str")]
     pub name: String,
-    pub command_port: Option<u16>,
     #[serde(default = "default_str")]
     pub server: String,
-    #[serde(default = "default_resource_vec")]
+    #[serde(default = "default_vec")]
     pub nat_test_server: Vec<String>,
     #[serde(default = "default_str")]
     pub device_id: String,
-    #[serde(default = "default_pid")]
-    pub pid: u32,
+    #[serde(default = "default_vec")]
+    pub in_ips: Vec<String>,
+    #[serde(default = "default_vec")]
+    pub out_ips: Vec<String>,
+    #[cfg(any(unix))]
+    #[serde(default = "default_false")]
+    pub off_command_server: bool,
+    #[serde(default = "default_false")]
+    pub log: bool,
+    pub password: Option<String>,
+}
+
+#[cfg(windows)]
+impl ArgsConfig {
+    pub fn new(start_config: StartConfig) -> ArgsConfig {
+        let in_ips = start_config.in_ips.iter().map(|(ip, mask, dest)| {
+            format!("{}/{},{}", Ipv4Addr::from(*ip), subnet_mask_to_integer(*mask), dest)
+        }).collect::<Vec<String>>();
+        let out_ips = start_config.out_ips.iter().map(|(ip, mask, dest)| {
+            format!("{}/{},{}", Ipv4Addr::from(*ip), subnet_mask_to_integer(*mask), dest)
+        }).collect::<Vec<String>>();
+        ArgsConfig {
+            tap: start_config.tap,
+            version: "1.0.6".to_string(),
+            token: start_config.token.to_string(),
+            name: start_config.name.to_string(),
+            server: start_config.server.to_string(),
+            nat_test_server: start_config.nat_test_server.iter().map(|v| v.to_string()).collect(),
+            device_id: start_config.device_id,
+            in_ips,
+            out_ips,
+            log: start_config.log,
+            #[cfg(any(unix))]
+            off_command_server: start_config.off_command_server,
+            password: start_config.password,
+        }
+    }
+}
+
+#[cfg(windows)]
+fn subnet_mask_to_integer(subnet_mask: u32) -> u8 {
+    let mut mask_bits = subnet_mask;
+    let mut num_bits = 0;
+    while mask_bits != 0 {
+        num_bits += 1;
+        mask_bits <<= 1;
+    }
+    num_bits as u8
+}
+
+fn default_false() -> bool {
+    false
 }
 
 fn default_version() -> String {
-    "1.0".to_string()
+    "1.0.6".to_string()
 }
 
 fn default_str() -> String {
     "".to_string()
 }
 
-fn default_resource_vec() -> Vec<String> {
+fn default_vec() -> Vec<String> {
     vec![]
 }
 
@@ -142,109 +395,90 @@ fn default_pid() -> u32 {
     0
 }
 
-impl ArgsConfig {
-    pub fn new(token: String, name: String, server: String, nat_test_server: Vec<String>, device_id: String) -> Self {
-        Self {
-            version: "1.0".to_string(),
-            token,
-            name,
-            command_port: None,
-            server,
-            nat_test_server,
-            device_id,
-            pid: 0,
-        }
-    }
-}
+// impl ArgsConfig {
+//     pub fn new(tap: bool, token: String, name: String, server: SocketAddr,
+//                nat_test_server: &Vec<SocketAddr>, device_id: String,
+//                in_ips: Vec<(u32, u32, Ipv4Addr)>, out_ips: Vec<(u32, u32, Ipv4Addr)>, ) -> Self {
+//
+//         Self {
+//             tap,
+//             version: "1.0".to_string(),
+//             token,
+//             name,
+//             command_port: None,
+//             server: server.to_string(),
+//             nat_test_server: nat_test_server.iter().map(|v| v.to_string()).collect::<Vec<String>>(),
+//             device_id,
+//             pid: 0,
+//         }
+//     }
+// }
+
 pub fn lock_file() -> io::Result<File> {
-    let path = SWITCH_HOME_PATH.lock().clone().unwrap().join(".lock");
-    Ok(File::create(path)?)
+    let path = get_home().join(".lock");
+    let file = File::create(path)?;
+    file.sync_all()?;
+    Ok(file)
 }
 
-pub fn save_config(config: ArgsConfig) -> io::Result<()> {
-    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();
+fn save_runtime_data(config: RuntimeData) -> io::Result<()> {
+    let config_path = get_runtime_data_path();
     let str = serde_yaml::to_string(&config).unwrap();
     let mut file = File::create(config_path)?;
-    file.write_all(str.as_bytes())
+    file.write_all(str.as_bytes())?;
+    file.sync_all()
 }
 
 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"))
+    let mut config = read_runtime_data()?;
+    config.pid = pid;
+    return save_runtime_data(config);
 }
 
 #[cfg(any(unix))]
 pub fn read_pid() -> io::Result<u32> {
-    let home = SWITCH_HOME_PATH.lock().clone().unwrap();
-    let config = read_config_(home)?;
+    let config = read_runtime_data()?;
     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() {
-        drop(home_lock);
-        let config_path = home.join("config");
-        if let Some(mut config) = read_config() {
-            config.command_port = Some(port);
-            return save_config_(config, config_path);
-        }
-    }
-    Err(io::Error::new(io::ErrorKind::Other, "not found"))
+    let mut config = read_runtime_data()?;
+    config.command_port = Some(port);
+    return save_runtime_data(config);
 }
 
 pub fn read_command_port() -> io::Result<u16> {
-    let home = SWITCH_HOME_PATH.lock().clone().unwrap();
-    let config = read_config_(home)?;
+    let config = read_runtime_data()?;
     if let Some(p) = config.command_port {
         Ok(p)
     } else {
-        Err(io::Error::new(io::ErrorKind::Other, "not fount config"))
+        Err(io::Error::new(io::ErrorKind::Other, "not found config"))
     }
 }
 
-pub fn read_config() -> Option<ArgsConfig> {
-    let mut lock = CONFIG.lock();
-    let c = lock.clone();
-    if c.is_some() {
-        return c;
-    }
-    if let Some(home) = SWITCH_HOME_PATH.lock().clone() {
-        match read_config_(home.to_path_buf()) {
-            Ok(config) => {
-                lock.replace(config.clone());
-                Some(config)
-            }
-            Err(e) => {
-                log::error!("{:?},path:{:?}", e,home);
-                None
-            }
+
+pub fn get_home() -> PathBuf {
+    #[cfg(windows)]
+    {
+        if let Some(path) = SWITCH_HOME_PATH.lock().as_ref() {
+            return path.clone();
         }
-    } else {
-        None
     }
+    let home = dirs::home_dir().unwrap().join(".switch_desktop");
+    if !home.exists() {
+        std::fs::create_dir(&home).unwrap();
+    }
+    home
 }
 
-pub fn set_home(home: PathBuf) {
-    SWITCH_HOME_PATH.lock().replace(home);
+pub fn get_runtime_data_path() -> PathBuf {
+    let home = get_home();
+    home.join(".data")
 }
 
-fn read_config_(home: PathBuf) -> io::Result<ArgsConfig> {
-    let config_path = home.join("config");
+fn read_runtime_data() -> io::Result<RuntimeData> {
+    let config_path = get_runtime_data_path();
     let mut file = if config_path.exists() {
         File::open(config_path)?
     } else {
@@ -252,6 +486,19 @@ fn read_config_(home: PathBuf) -> io::Result<ArgsConfig> {
     };
     let mut str = String::new();
     file.read_to_string(&mut str)?;
+    match serde_yaml::from_str::<RuntimeData>(&str) {
+        Ok(config) => Ok(config),
+        Err(e) => {
+            log::warn!("{:?}", e);
+            Err(io::Error::new(io::ErrorKind::Other, "config error"))
+        }
+    }
+}
+
+fn read_config(config_path: PathBuf) -> io::Result<ArgsConfig> {
+    let mut file = File::open(config_path)?;
+    let mut str = String::new();
+    file.read_to_string(&mut str)?;
     match serde_yaml::from_str::<ArgsConfig>(&str) {
         Ok(config) => Ok(config),
         Err(e) => {
@@ -259,4 +506,4 @@ fn read_config_(home: PathBuf) -> io::Result<ArgsConfig> {
             Err(io::Error::new(io::ErrorKind::Other, "config error"))
         }
     }
-}
+}

switch-desktop/src/i18n.rs

@@ -0,0 +1,214 @@
+#[cfg(target_os = "windows")]
+fn get_default_language() -> Option<String> {
+    use std::process::Command;
+    use std::str;
+
+    let output = Command::new("powershell")
+        .arg("-Command")
+        .arg("[System.Globalization.CultureInfo]::CurrentCulture.Name")
+        .output()
+        .ok()?;
+
+    let language_code = str::from_utf8(&output.stdout)
+        .ok()?
+        .trim()
+        .to_string();
+
+    Some(language_code)
+}
+
+pub fn init() {
+    #[cfg(target_os = "windows")]
+    {
+        if let Some(l) = get_default_language() {
+            rust_i18n::set_locale(&l);
+        }
+    }
+}
+
+pub fn switch_about() -> String {
+    rust_i18n::t!("switch_about")
+}
+
+pub fn switch_usage() -> String {
+    rust_i18n::t!("switch_usage")
+}
+
+pub fn switch_start_about() -> String {
+    rust_i18n::t!("switch_start_about")
+}
+
+pub fn switch_token_help() -> String {
+    rust_i18n::t!("switch_token_help")
+}
+
+pub fn switch_name_help() -> String {
+    rust_i18n::t!("switch_name_help")
+}
+
+pub fn switch_device_id_help() -> String {
+    rust_i18n::t!("switch_device_id_help")
+}
+
+pub fn switch_server_help() -> String {
+    rust_i18n::t!("switch_server_help")
+}
+
+pub fn switch_nat_test_server_help() -> String {
+    rust_i18n::t!("switch_nat_test_server_help")
+}
+
+pub fn switch_log_help() -> String {
+    rust_i18n::t!("switch_log_help")
+}
+
+pub fn switch_tap_help() -> String {
+    rust_i18n::t!("switch_tap_help")
+}
+
+pub fn switch_in_ip_help() -> String {
+    rust_i18n::t!("switch_in_ip_help")
+}
+
+pub fn switch_out_ip_help() -> String {
+    rust_i18n::t!("switch_out_ip_help")
+}
+pub fn switch_password_help() -> String {
+    rust_i18n::t!("switch_password_help")
+}
+
+pub fn switch_config_help() -> String {
+    rust_i18n::t!("switch_config_help")
+}
+
+pub fn switch_stop_about() -> String {
+    rust_i18n::t!("switch_stop_about")
+}
+
+pub fn switch_route_about() -> String {
+    rust_i18n::t!("switch_route_about")
+}
+
+pub fn switch_list_about() -> String {
+    rust_i18n::t!("switch_list_about")
+}
+
+pub fn switch_list_all_help() -> String {
+    rust_i18n::t!("switch_list_all_help")
+}
+
+pub fn switch_status_about() -> String {
+    rust_i18n::t!("switch_status_about")
+}
+
+#[cfg(windows)]
+pub fn switch_install_about() -> String {
+    rust_i18n::t!("switch_install_about")
+}
+
+#[cfg(windows)]
+pub fn switch_path_help() -> String {
+    rust_i18n::t!("switch_path_help")
+}
+
+#[cfg(windows)]
+pub fn switch_auto_help() -> String {
+    rust_i18n::t!("switch_auto_help")
+}
+
+#[cfg(windows)]
+pub fn switch_uninstall_about() -> String {
+    rust_i18n::t!("switch_uninstall_about")
+}
+
+#[cfg(windows)]
+pub fn switch_config_about() -> String {
+    rust_i18n::t!("switch_config_about")
+}
+
+#[cfg(windows)]
+pub fn switch_use_root_print() -> String {
+    rust_i18n::t!("switch_use_admin_print")
+}
+
+#[cfg(unix)]
+pub fn switch_use_root_print() -> String {
+    rust_i18n::t!("switch_use_root_print")
+}
+
+#[cfg(windows)]
+pub fn switch_service_not_start_print() -> String {
+    rust_i18n::t!("switch_service_not_start_print")
+}
+
+pub fn switch_start_successfully_print() -> String {
+    rust_i18n::t!("switch_start_successfully_print")
+}
+
+#[cfg(windows)]
+pub fn switch_start_failed_print() -> String {
+    rust_i18n::t!("switch_start_failed_print")
+}
+
+#[cfg(windows)]
+pub fn switch_service_not_stopped_print() -> String {
+    rust_i18n::t!("switch_service_not_stopped_print")
+}
+
+#[cfg(windows)]
+pub fn switch_server_already_installed_print() -> String {
+    rust_i18n::t!("switch_server_already_installed_print")
+}
+
+pub fn switch_repeated_start_print() -> String {
+    rust_i18n::t!("switch_repeated_start_print")
+}
+
+pub fn switch_stopped_print() -> String {
+    rust_i18n::t!("switch_stopped_print")
+}
+
+pub fn switch_token_not_found_print() -> String {
+    rust_i18n::t!("switch_token_not_found_print")
+}
+
+pub fn switch_token_cannot_be_empty_print() -> String {
+    rust_i18n::t!("switch_token_cannot_be_empty_print")
+}
+
+pub fn switch_token_cannot_exceed_64_print() -> String {
+    rust_i18n::t!("switch_token_cannot_exceed_64_print")
+}
+
+pub fn switch_device_id_is_empty_print() -> String {
+    rust_i18n::t!("switch_device_id_is_empty_print")
+}
+
+pub fn switch_in_ips_example_print() -> String {
+    rust_i18n::t!("switch_in_ips_example_print")
+}
+
+pub fn switch_out_ips_example_print() -> String {
+    rust_i18n::t!("switch_out_ips_example_print")
+}
+
+pub fn switch_relay_server_address_error() -> String {
+    rust_i18n::t!("switch_relay_server_address_error")
+}
+
+pub fn switch_nat_test_server_address_error() -> String {
+    rust_i18n::t!("switch_nat_test_server_address_error")
+}
+
+pub fn switch_press_any_key_to_exit() -> String {
+    rust_i18n::t!("switch_press_any_key_to_exit")
+}
+pub fn switch_virtual_ip() -> String {
+    rust_i18n::t!("switch_virtual_ip")
+}
+pub fn switch_virtual_gateway() -> String {
+    rust_i18n::t!("switch_virtual_gateway")
+}
+pub fn switch_please_enter_the_command() -> String {
+    rust_i18n::t!("switch_please_enter_the_command")
+}

switch-desktop/src/main.rs

@@ -1,3 +1,5 @@
+use std::thread;
+use std::time::Duration;
 use clap::{Parser, Subcommand};
 use console::style;
 
@@ -9,10 +11,11 @@ mod command;
 mod config;
 #[cfg(target_os = "windows")]
 mod windows;
-
 #[cfg(any(unix))]
 mod unix;
 mod console_out;
+mod command_args;
+mod i18n;
 
 #[derive(Parser, Debug)]
 #[command(
@@ -58,7 +61,7 @@ enum Commands {
     Status,
 }
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, Default)]
 pub struct StartArgs {
     /// 不超过64个字符
     /// 相同token的设备之间才能通信。
@@ -89,10 +92,28 @@ pub struct StartArgs {
     #[cfg(any(unix))]
     #[arg(long)]
     off_command_server: bool,
-    /// 记录日志，输出在 home/.switch 目录下，长时间使用时不建议开启
-    /// Output the log in the "home/.switch" directory
+    /// 记录日志，输出在 home/.switch_desktop 目录下，长时间使用时不建议开启
+    /// Output the log in the "home/.switch_desktop" directory
     #[arg(long)]
     log: bool,
+    /// 使用tap网卡
+    #[arg(long)]
+    tap: bool,
+    /// 配置点对网时使用，--in-ip 192.168.10.0/24,10.26.0.3，表示允许接收网段192.168.10.0/24的数据并转发到10.26.0.3
+    /// Use when configuring peer-to-peer networks
+    #[arg(long)]
+    in_ip: Option<Vec<String>>,
+    /// 配置点对网时使用，--out-ip 192.168.10.0/24,192.168.1.10，表示允许目标为192.168.10.0/24的数据从网卡192.168.1.10转发出去
+    /// Use when configuring peer-to-peer networks
+    #[arg(long)]
+    out_ip: Option<Vec<String>>,
+    /// 客户端数据加密
+    #[arg(long)]
+    password:Option<String>,
+    /// 读取配置文件 --config config_file_path
+    /// Read configuration file
+    #[arg(long)]
+    config: Option<String>,
 }
 
 #[cfg(target_os = "windows")]
@@ -117,18 +138,24 @@ pub struct ConfigArgs {
     auto: bool,
 }
 
+#[macro_use]
+extern crate rust_i18n;
+i18n!("locales", fallback = "en");
+
 
 #[cfg(windows)]
 fn main() {
+    i18n::init();
     let args: Vec<_> = std::env::args().collect();
     if args.len() == 3 && args[1] == windows::SERVICE_FLAG {
         //以服务的方式启动
-        config::set_home(std::path::PathBuf::from(&args[2]));
+        config::set_win_server_home(std::path::PathBuf::from(&args[2]));
         windows::service::start();
         return;
     } else {
-        let home = dirs::home_dir().unwrap().join(".switch");
-        config::set_home(home);
+        if !command_args::check() {
+            return;
+        }
         let args = BaseArgs::parse();
         if let Commands::Start(start_args) = &args.command {
             if start_args.log {
@@ -140,47 +167,51 @@ fn main() {
 }
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
-fn main() {
-    let home = dirs::home_dir().unwrap().join(".switch");
-    config::set_home(home);
+#[tokio::main]
+async fn main() {
+    if sudo::RunningAs::Root != sudo::check() {
+        println!(
+            "{}",
+            style("需要使用root权限执行(Need to execute with root permission)...").red()
+        );
+        sudo::escalate_if_needed().unwrap();
+    }
     let args = BaseArgs::parse();
     if let Commands::Start(start_args) = &args.command {
         if start_args.log {
             let _ = log_init();
         }
     }
-    unix::main0(args);
+    unix::main0(args).await;
 }
 
 pub fn console_listen(switch: &Switch) {
     use console::Term;
     let term = Term::stdout();
-    println!("{}", style("started").green());
+    println!("{}", style(i18n::switch_start_successfully_print()).green());
     let current_device = switch.current_device();
-    println!(
-        "当前虚拟ip(virtual ip): {:?}",
-        style(current_device.virtual_ip()).green()
-    );
-    println!(
-        "虚拟网关(virtual gateway): {:?}",
-        style(current_device.virtual_gateway()).green()
-    );
+    println!("{}: {:?}", i18n::switch_virtual_ip(), style(current_device.virtual_ip()).green());
+    println!("{}: {:?}", i18n::switch_virtual_gateway(), style(current_device.virtual_gateway()).green());
     loop {
         println!(
             "{}",
-            style("Please enter the command (Usage: list,status,exit,help):").color256(102)
+            style(i18n::switch_please_enter_the_command()).color256(102)
         );
         match term.read_line() {
             Ok(cmd) => {
+                #[cfg(unix)]
                 if cmd.is_empty() {
-                    log::warn!("非正常返回");
-                    return;
+                    use libc::{STDIN_FILENO, isatty};
+                    if !unsafe { isatty(STDIN_FILENO) != 0 } {
+                        return;
+                    }
                 }
                 if command(cmd.trim(), &switch).is_err() {
                     println!("{}", style("stopping").red());
                     if let Err(e) = switch.stop() {
                         println!("stop:{:?}", e);
                     }
+                    thread::sleep(Duration::from_secs(2));
                     break;
                 }
             }
@@ -190,7 +221,7 @@ pub fn console_listen(switch: &Switch) {
                 if let Err(e) = switch.stop() {
                     log::error!("stop:{:?}", e);
                 }
-                std::thread::sleep(std::time::Duration::from_secs(1));
+                thread::sleep(Duration::from_secs(1));
                 break;
             }
         }
@@ -226,7 +257,7 @@ fn command(cmd: &str, switch: &Switch) -> Result<(), ()> {
             return Err(());
         }
         _ => {
-            println!("command '{}' not fount. ", style(cmd).red());
+            println!("command '{}' not found. ", style(cmd).red());
             println!("Try to enter: '{}'", style("help").green());
         }
     }

switch-desktop/src/unix/mod.rs

@@ -9,100 +9,94 @@ use crate::{BaseArgs, Commands, config};
 use crate::command::{command, CommandEnum};
 
 
-pub fn main0(base_args: BaseArgs) {
+pub async 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 start_config = if let Some(config_path) = &args.config {
+                match config::read_config_file(config_path.into()) {
+                    Ok(start_config) => {
+                        start_config
                     }
-
-                    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::<Vec<String>>();
-                    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());
+                    Err(e) => {
+                        println!("{}", style(&e).red());
+                        log::error!("{:?}", e);
                         return;
                     }
-                    if let Err(e) = config::save_config(args_config) {
-                        log::error!("{:?}",e);
-                        lock.unlock().unwrap();
+                }
+            } else {
+                match config::default_config(args) {
+                    Ok(start_config) => {
+                        start_config
+                    }
+                    Err(e) => {
+                        println!("{}", style(&e).red());
+                        log::error!("{:?}", e);
                         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();
+                }
+            };
+            let off_command_server = start_config.off_command_server;
+            let config = Config::new(
+                start_config.tap,
+                start_config.token.clone(),
+                start_config.device_id.clone(),
+                start_config.name.clone(),
+                start_config.server,
+                start_config.nat_test_server.clone(),
+                start_config.in_ips.clone(),
+                start_config.out_ips.clone(),
+                start_config.password.clone(),
+            );
+            let lock = match config::lock_file() {
+                Ok(lock) => {
+                    lock
+                }
+                Err(e) => {
+                    log::error!("{:?}",e);
+                    println!("文件锁定失败:{:?}", e);
+                    return;
+                }
+            };
+            if lock.try_lock_exclusive().is_err() {
+                println!("{}", style("文件被重复打开").red());
+                return;
+            }
+            let switch = match Switch::start(config).await {
+                Ok(switch) => {
+                    switch
                 }
                 Err(e) => {
                     log::error!("{:?}", e);
+                    println!("启动switch失败:{:?}", 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::Builder::new().name("cmd-server".into()).spawn(move || {
+                    if let Err(e) = command_server.start(switch1) {
+                        log::error!("{:?}", e);
+                    }
+                }).unwrap();
+                crate::console_listen(&switch);
+                if let Err(e) = handle.join() {
+                    log::error!("后台任务异常{:?}",e);
+                } else {
+                    log::info!("后台任务结束");
                 }
             }
+            lock.unlock().unwrap();
         }
         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 {

switch-desktop/src/windows/mod.rs

@@ -14,7 +14,7 @@ use windows_service::service_manager::{ServiceManager, ServiceManagerAccess};
 
 use switch::core::{Config, Switch};
 
-use crate::{BaseArgs, Commands, config};
+use crate::{BaseArgs, Commands, config, i18n};
 use crate::command::{command, CommandEnum};
 
 pub mod service;
@@ -28,7 +28,7 @@ fn admin_check() -> bool {
     if !windows_admin_check::is_app_elevated() {
         println!(
             "{}",
-            style("请使用管理员权限运行(Please run with administrator privileges)").red()
+            style(i18n::switch_use_root_print()).red()
         );
         true
     } else {
@@ -42,7 +42,7 @@ fn not_started() -> bool {
             if state == ServiceState::Running {
                 return false;
             } else {
-                println!("服务未启动")
+                println!("{}", i18n::switch_service_not_start_print())
             }
         }
         Err(e) => {
@@ -62,87 +62,97 @@ pub fn main0(base_args: BaseArgs) {
                 // 允许应用通过防火墙
                 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::<Vec<String>>(),
-                                    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)");
+            let start_config = if let Some(config_path) = &args.config {
+                match config::read_config_file(config_path.into()) {
+                    Ok(start_config) => {
+                        start_config
+                    }
+                    Err(e) => {
+                        println!("{}", style(&e).red());
+                        log::error!("{:?}", e);
+                        return;
+                    }
+                }
+            } else {
+                match config::default_config(args) {
+                    Ok(start_config) => {
+                        start_config
+                    }
+                    Err(e) => {
+                        println!("{}", style(&e).red());
+                        log::error!("{:?}", e);
+                        return;
+                    }
+                }
+            };
+            match service_state() {
+                Ok(state) => {
+                    if state == ServiceState::Stopped {
+                        match start() {
+                            Ok(_) => {
+                                //需要检查启动状态
+                                thread::sleep(Duration::from_secs(2));
+                                println!("{}", style(i18n::switch_start_successfully_print()).green());
+                            }
+                            Err(e) => {
+                                log::error!("{:?}", e);
+                                println!("{}:{}", style(i18n::switch_start_failed_print()).red(), 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()
-                                            );
-                                            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);
-                        }
+                    } else {
+                        println!("{}", i18n::switch_service_not_stopped_print());
                     }
                 }
                 Err(e) => {
-                    println!("{}", style(e).red());
+                    match e {
+                        Error::Winapi(ref e) => {
+                            if let Some(code) = e.raw_os_error() {
+                                if code == 1060 {
+                                    //指定的服务未安装。
+                                    let config = Config::new(
+                                        start_config.tap,
+                                        start_config.token,
+                                        start_config.device_id,
+                                        start_config.name,
+                                        start_config.server,
+                                        start_config.nat_test_server,
+                                        start_config.in_ips,
+                                        start_config.out_ips,
+                                        start_config.password,
+                                    );
+                                    let lock = match config::lock_file() {
+                                        Ok(lock) => {
+                                            lock
+                                        }
+                                        Err(e) => {
+                                            log::error!("文件锁定失败:{:?}",e);
+                                            println!("文件锁定失败:{:?}", e);
+                                            return;
+                                        }
+                                    };
+                                    if lock.try_lock_exclusive().is_err() {
+                                        println!("{}", style(i18n::switch_repeated_start_print()).red());
+                                        return;
+                                    }
+                                    tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async move {
+                                        match Switch::start(config).await {
+                                            Ok(switch) => {
+                                                crate::console_listen(&switch);
+                                            }
+                                            Err(e) => {
+                                                log::error!("{:?}", e);
+                                                println!("启动switch失败:{:?}", e);
+                                            }
+                                        }
+                                    });
+                                    lock.unlock().unwrap();
+                                    return;
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                    println!("{:?}", e);
                 }
             };
             pause();
@@ -156,10 +166,11 @@ pub fn main0(base_args: BaseArgs) {
             }
             match stop() {
                 Ok(_) => {
-                    println!("{}", style("停止成功(Stopped successfully)").green())
+                    println!("{}", style(i18n::switch_stopped_print()).green())
                 }
                 Err(e) => {
                     log::error!("{:?}", e);
+                    println!("停止失败:{}", e);
                 }
             }
             pause();
@@ -168,6 +179,10 @@ pub fn main0(base_args: BaseArgs) {
             if admin_check() {
                 return;
             }
+            if service_state().is_ok() {
+                println!("{}", i18n::switch_server_already_installed_print());
+                return;
+            }
             let path: PathBuf = args.path.into();
             if !path.exists() {
                 std::fs::create_dir_all(&path).unwrap();
@@ -177,6 +192,7 @@ pub fn main0(base_args: BaseArgs) {
             } else {
                 if let Err(e) = install(path, args.auto) {
                     log::error!("{:?}", e);
+                    println!("安装失败:{}", e);
                 } else {
                     println!("{}", style("安装成功(Installation succeeded)").green())
                 }
@@ -187,16 +203,24 @@ pub fn main0(base_args: BaseArgs) {
             if admin_check() {
                 return;
             }
+            if service_state().is_err() {
+                println!("服务未安装");
+            }
             if let Err(e) = uninstall() {
                 log::error!("{:?}", e);
+                println!("卸载失败:{}", e);
             } else {
                 println!("{}", style("卸载成功(Uninstall succeeded)").green())
             }
             pause();
         }
         Commands::Config(args) => {
+            if service_state().is_err() {
+                println!("服务未安装");
+            }
             if let Err(e) = change(args.auto) {
                 log::error!("{:?}", e);
+                println!("配置失败:{}", e);
             } else {
                 println!("{}", style("配置成功(Config succeeded)").green())
             }
@@ -230,14 +254,17 @@ pub fn main0(base_args: BaseArgs) {
 fn pause() {
     println!(
         "{}",
-        style("按任意键退出(Press any key to exit)...").green()
+        style(i18n::switch_press_any_key_to_exit()).green()
     );
     use console::Term;
     let term = Term::stdout();
     let _ = term.read_char().unwrap();
 }
 
-fn install(path: PathBuf, auto: bool) -> Result<(), Error> {
+fn install(mut path: PathBuf, auto: bool) -> Result<(), Error> {
+    if !path.is_absolute() {
+        path = path.canonicalize().unwrap();
+    }
     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();
@@ -245,7 +272,7 @@ fn install(path: PathBuf, auto: bool) -> Result<(), Error> {
     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 {
-            println!("Not fount 'wintun.dll'. Please put 'wintun.dll' in the current directory");
+            println!("'wintun.dll' not found. Please put 'wintun.dll' in the current directory");
             std::process::exit(0);
         } else {
             panic!("{:?}", e)
@@ -254,7 +281,7 @@ fn install(path: PathBuf, auto: bool) -> Result<(), Error> {
     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(),
+        config::get_home().to_str().unwrap(),
     ));
     let start_type = if auto {
         ServiceStartType::AutoStart
@@ -290,18 +317,28 @@ fn change(auto: bool) -> Result<(), Error> {
     } 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 executable_path = config.executable_path.to_string_lossy().to_string();
+    let executable_path = if executable_path.starts_with('"') && executable_path.ends_with('"') {
+        &executable_path[1..executable_path.len() - 1]
+    } else {
+        &executable_path
+    };
+    let mut split = executable_path.split(SERVICE_FLAG);
+    let executable_path = split.next().unwrap().trim();
+    let executable_path = if executable_path.starts_with('"') && executable_path.ends_with('"') {
+        PathBuf::from(&executable_path[1..executable_path.len() - 1])
+    } else {
+        PathBuf::from(executable_path)
+    };
+    let home_path = split.next().unwrap().trim();
+    let launch_arguments = vec![OsString::from(SERVICE_FLAG), OsString::from(home_path)];
     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,
+        executable_path,
         launch_arguments,
         dependencies: config.dependencies,
         account_name: None, // run as System
@@ -328,15 +365,12 @@ fn uninstall() -> Result<(), Error> {
     Ok(())
 }
 
-fn start(out_log: bool) -> Result<(), Error> {
+fn start() -> 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)?;
-    if out_log {
-        service.start(&["log"])
-    } else {
-        service.start(&[""])
-    }
+    let args: Vec<_> = std::env::args().collect();
+    service.start(&args[1..])
 }
 
 fn service_state() -> Result<ServiceState, Error> {

switch-desktop/src/windows/service.rs

@@ -2,10 +2,12 @@
 // extern crate windows_service;
 
 use std::ffi::OsString;
-use std::net::ToSocketAddrs;
 use std::sync::Arc;
-use std::thread;
+use std::io;
+use std::io::Write;
+use std::path::PathBuf;
 use std::time::Duration;
+use clap::Parser;
 
 use windows_service::{define_windows_service, service_control_handler, service_dispatcher};
 use windows_service::service::{
@@ -15,28 +17,26 @@ use windows_service::service_control_handler::ServiceControlHandlerResult;
 
 use switch::core::{Config, Switch};
 
-use crate::config;
-use crate::windows::config::read_config;
+use crate::{BaseArgs, Commands, config};
 use crate::windows::SERVICE_NAME;
 
 define_windows_service!(ffi_service_main, switch_service_main);
 pub fn switch_service_main(arguments: Vec<OsString>) {
-    if !arguments.is_empty() {
-        if let Some(str) = arguments[0].to_str() {
-            if str == "log" {
-                let _ = config::log_config::log_service_init();
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(async {
+            match service_main(arguments).await {
+                Ok(_) => {}
+                Err(e) => {
+                    log::error!("启动服务失败：{:?}",e);
+                }
             }
-        }
-    }
-    thread::spawn(|| match service_main() {
-        Ok(_) => {}
-        Err(e) => {
-            log::error!("{:?}", e);
-        }
-    });
+        })
 }
 
-fn service_main() -> windows_service::Result<()> {
+async fn service_main(arguments: Vec<OsString>) -> windows_service::Result<()> {
     let parker = crossbeam::sync::Parker::new();
     let un_parker = parker.unparker().clone();
     let event_handler = move |control_event| -> ServiceControlHandlerResult {
@@ -70,15 +70,12 @@ fn service_main() -> windows_service::Result<()> {
         wait_hint: Duration::default(),
         process_id: None,
     })?;
-    match start_switch() {
-        Ok(switch) => {
+    match start_switch(arguments).await {
+        Ok(_) => {
             parker.park();
-            if let Err(e) = switch.stop() {
-                log::warn!("switch stop:{:?}",e)
-            }
         }
         Err(e) => {
-            log::error!("{:?}",e);
+            log::error!("服务启动失败 {:?}",e);
         }
     }
     status_handle.set_service_status(ServiceStatus {
@@ -92,51 +89,112 @@ fn service_main() -> windows_service::Result<()> {
     })
 }
 
-fn start_switch() -> switch::Result<Arc<Switch>> {
-    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()));
+fn auto_config_path() -> io::Result<PathBuf> {
+    Ok(config::get_win_server_home().join("auto_config.yaml"))
+}
+
+fn save_auto_config(start_config: config::StartConfig) -> io::Result<()> {
+    let mut file = std::fs::File::create(auto_config_path()?)?;
+    let config = config::ArgsConfig::new(start_config);
+    match serde_yaml::to_string(&config) {
+        Ok(yaml) => {
+            file.write_all(yaml.as_bytes())
         }
-        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::<Vec<_>>();
-        if nat_test_server.is_empty() {
-            return Err(switch::error::Error::Stop("nat test server address error".to_string()));
+        Err(e) => {
+            Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", e)))
         }
-        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()))
     }
 }
 
+async fn start_switch(arguments: Vec<OsString>) -> switch::Result<()> {
+    let start_config = match BaseArgs::try_parse_from(arguments) {
+        Ok(args) => {
+            match args.command {
+                Commands::Start(args) => {
+                    if args.log {
+                        let _ = config::log_config::log_service_init();
+                    }
+                    if let Some(config_path) = &args.config {
+                        match config::read_config_file(config_path.into()) {
+                            Ok(start_config) => {
+                                if let Err(e) = save_auto_config(start_config.clone()) {
+                                    log::warn!("配置文件保存失败:{:?}",e);
+                                }
+                                start_config
+                            }
+                            Err(e) => {
+                                log::error!("{:?}", e);
+                                return Err(switch::error::Error::Stop(e));
+                            }
+                        }
+                    } else {
+                        match config::default_config(args) {
+                            Ok(start_config) => {
+                                if let Err(e) = save_auto_config(start_config.clone()) {
+                                    log::warn!("配置文件保存失败:{:?}",e);
+                                }
+                                start_config
+                            }
+                            Err(e) => {
+                                log::error!("{:?}", e);
+                                return Err(switch::error::Error::Stop(e));
+                            }
+                        }
+                    }
+                }
+                _ => {
+                    return Err(switch::error::Error::Stop("配置文件错误".to_string()));
+                }
+            }
+        }
+        Err(_) => {
+            match config::read_config_file(auto_config_path()?) {
+                Ok(start_config) => {
+                    if start_config.log {
+                        let _ = config::log_config::log_service_init();
+                    }
+                    start_config
+                }
+                Err(e) => {
+                    return Err(switch::error::Error::Stop(e));
+                }
+            }
+        }
+    };
+    let config = Config::new(
+        start_config.tap,
+        start_config.token,
+        start_config.device_id,
+        start_config.name,
+        start_config.server,
+        start_config.nat_test_server,
+        start_config.in_ips,
+        start_config.out_ips,
+        start_config.password,
+    );
+    log::info!("switch-service服务启动");
+
+
+    tokio::spawn(async move {
+        match Switch::start(config).await {
+            Ok(switch) => {
+                let switch = Arc::new(switch);
+                let command_server = crate::command::server::CommandServer::new();
+                if let Err(e) = config::update_pid(std::process::id()) {
+                    log::error!("{:?}", e);
+                }
+                if let Err(e) = command_server.start(switch) {
+                    log::error!("{:?}", e);
+                }
+            }
+            Err(e) => {
+                log::error!("{:?}", e);
+            }
+        };
+    });
+    Ok(())
+}
+
 pub fn start() {
     log::info!("以服务的方式启动");
     service_dispatcher::start(SERVICE_NAME, ffi_service_main).unwrap();

switch-jni/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "switch-jni"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[lib]
-crate-type = ['cdylib']
-
-[dependencies]
-switch = {path="../switch"}
-jni = "0.20.0"
-anyhow = "1.0.65"

switch-jni/src/lib.rs

@@ -1,267 +0,0 @@
-use std::net::{IpAddr, Ipv4Addr, ToSocketAddrs};
-
-use jni::errors::Error;
-use jni::objects::{JClass, JObject, JString, JValue};
-use jni::sys::{jbyte, jint, jlong, jobject, jobjectArray, jsize};
-use jni::JNIEnv;
-
-use switch::handle::{CurrentDeviceInfo, PeerDeviceInfo, Route};
-use switch::{Config, Switch};
-
-fn to_string_not_null(env: &JNIEnv, config: JObject, name: &'static str) -> Result<String, Error> {
-    let value = env.get_field(config, name, "Ljava/lang/String;")?.l()?;
-    if value.is_null() {
-        env.throw_new("Ljava/lang/NullPointerException", name)
-            .expect("throw");
-        return Err(Error::NullPtr(name));
-    }
-    let value = env.get_string(JString::from(value))?;
-    match value.to_str() {
-        Ok(value) => Ok(value.to_string()),
-        Err(_) => {
-            env.throw_new("Ljava/lang/RuntimeException", "not utf-8")
-                .expect("throw");
-            return Err(Error::JavaException);
-        }
-    }
-}
-
-fn to_string(env: &JNIEnv, config: JObject, name: &str) -> Result<Option<String>, Error> {
-    let value = env.get_field(config, name, "Ljava/lang/String;")?.l()?;
-    if value.is_null() {
-        return Ok(None);
-    }
-    let value = env.get_string(JString::from(value))?;
-    match value.to_str() {
-        Ok(value) => Ok(Some(value.to_string())),
-        Err(_) => {
-            env.throw_new("Ljava/lang/RuntimeException", "not utf-8")
-                .expect("throw");
-            return Err(Error::JavaException);
-        }
-    }
-}
-
-fn start(env: &JNIEnv, config: JObject) -> Result<Option<Switch>, Error> {
-    let token = to_string_not_null(&env, config, "token")?;
-    let mac_address = to_string_not_null(&env, config, "macAddress")?;
-    let name = to_string(&env, config, "name")?;
-    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 config = match Config::new(
-        token,
-        mac_address,
-        name,
-        server_address,
-        nat_test_server,
-        || {},
-    ) {
-        Ok(config) => config,
-        Err(e) => {
-            env.throw_new(
-                "Ljava/lang/RuntimeException",
-                format!("switch start failed {:?}", e),
-            )
-            .expect("throw");
-            return Ok(None);
-        }
-    };
-    match Switch::start(config) {
-        Ok(switch) => {
-            return Ok(Some(switch));
-        }
-        Err(e) => {
-            env.throw_new(
-                "Ljava/lang/RuntimeException",
-                format!("switch start failed {:?}", e),
-            )
-            .expect("throw");
-        }
-    }
-    Ok(None)
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_org_switches_jni_Switch_start0(
-    env: JNIEnv,
-    _class: JClass,
-    config: JObject,
-) -> jlong {
-    match start(&env, config) {
-        Ok(switch) => {
-            if let Some(switch) = switch {
-                return Box::into_raw(Box::new(switch)) as jlong;
-            }
-        }
-        Err(_) => {}
-    }
-    return 0;
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_org_switches_jni_Switch_stop0(
-    _env: JNIEnv,
-    _class: JClass,
-    raw_switch: jlong,
-) {
-    let switch = Box::from_raw(raw_switch as *mut Switch);
-    switch.stop();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_org_switches_jni_Switch_currentDevice0(
-    env: JNIEnv,
-    _class: JClass,
-    raw_switch: jlong,
-) -> jobject {
-    let switch = raw_switch as *mut Switch;
-    let dev_info = (&*switch).current_device();
-    match current_device(&env, dev_info) {
-        Ok(obj) => obj,
-        Err(_) => std::ptr::null_mut(),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_org_switches_jni_Switch_deviceList0(
-    env: JNIEnv,
-    _class: JClass,
-    raw_switch: jlong,
-) -> jobjectArray {
-    let switch = raw_switch as *mut Switch;
-    match device_list(&env, (&*switch).device_list()) {
-        Ok(arr) => arr,
-        Err(_) => std::ptr::null_mut(),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_org_switches_jni_Switch_route0(
-    env: JNIEnv,
-    _class: JClass,
-    raw_switch: jlong,
-    ip: jint,
-) -> jobject {
-    let ip = Ipv4Addr::from(ip as u32);
-    let switch = raw_switch as *mut Switch;
-    match route(&env, (&*switch).route(&ip)) {
-        Ok(arr) => arr,
-        Err(_) => std::ptr::null_mut(),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_org_switches_jni_Switch_serverRt0(
-    _env: JNIEnv,
-    _class: JClass,
-    raw_switch: jlong,
-) -> jlong {
-    let switch = raw_switch as *mut Switch;
-    let rt = (&*switch).server_rt();
-    rt as jlong
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_org_switches_jni_Switch_connectionStatus0(
-    _env: JNIEnv,
-    _class: JClass,
-    raw_switch: jlong,
-) -> jbyte {
-    let switch = raw_switch as *mut Switch;
-    let connection_status: u8 = (&*switch).connection_status().into();
-    connection_status as jbyte
-}
-
-fn route(env: &JNIEnv, route: Route) -> Result<jobject, Error> {
-    let route_type: u8 = route.route_type.into();
-    let rt = route.rt;
-    let route = env.new_object(
-        "org/switches/jni/Route",
-        "(BJ)V",
-        &[JValue::Byte(route_type as jbyte), JValue::Long(rt as jlong)],
-    )?;
-    Ok(route.into_raw())
-}
-
-fn device_list(env: &JNIEnv, device_list: Vec<PeerDeviceInfo>) -> Result<jobjectArray, Error> {
-    if device_list.is_empty() {
-        return Ok(std::ptr::null_mut());
-    }
-    let arr = env.new_object_array(
-        device_list.len() as jsize,
-        "org/switches/jni/PeerDeviceInfo",
-        JObject::null(),
-    )?;
-    let mut index = 0;
-    for peer_info in device_list {
-        let virtual_ip: u32 = peer_info.virtual_ip.into();
-        let name = peer_info.name;
-        let status: u8 = peer_info.status.into();
-        let info = env.new_object(
-            "org/switches/jni/PeerDeviceInfo",
-            "(BLjava/lang/String;J)V",
-            &[
-                JValue::Int(virtual_ip as jint),
-                JValue::Object(env.new_string(name)?.into()),
-                JValue::Byte(status as jbyte),
-            ],
-        )?;
-        env.set_object_array_element(arr, index, info)?;
-        index += 1;
-    }
-    Ok(arr)
-}
-
-fn current_device(env: &JNIEnv, dev_info: &CurrentDeviceInfo) -> Result<jobject, Error> {
-    let virtual_ip: u32 = dev_info.virtual_ip.into();
-    let virtual_gateway: u32 = dev_info.virtual_gateway.into();
-    let virtual_netmask: u32 = dev_info.virtual_netmask.into();
-    let virtual_network: u32 = dev_info.virtual_network.into();
-    let broadcast_address: u32 = dev_info.broadcast_address.into();
-    let connect_server_host: u32 = match dev_info.connect_server.ip() {
-        IpAddr::V4(ip) => ip.into(),
-        IpAddr::V6(_) => {
-            panic!()
-        }
-    };
-    let connect_server_port = dev_info.connect_server.port() as u32;
-    let current_device = env.new_object(
-        "org/switches/jni/CurrentDevice",
-        "(IIIIIII)V",
-        &[
-            JValue::Int(virtual_ip as jint),
-            JValue::Int(virtual_gateway as jint),
-            JValue::Int(virtual_netmask as jint),
-            JValue::Int(virtual_network as jint),
-            JValue::Int(broadcast_address as jint),
-            JValue::Int(connect_server_host as jint),
-            JValue::Int(connect_server_port as jint),
-        ],
-    )?;
-    Ok(current_device.into_raw())
-}

switch/Cargo.toml

@@ -1,13 +1,12 @@
 [package]
 name = "switch"
-version = "0.1.0"
+version = "1.0.6"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 packet = { path = "./packet" }
-p2p_channel = { path = "./p2p_channel" }
 bytes = "1.3.0"
 log = "0.4.17"
 libc = "0.2.137"
@@ -20,21 +19,22 @@ parking_lot = "0.12.1"
 rsa = "0.7.2"
 rand = "0.8.5"
 sha2 = { version = "0.10.6", features = ["oid"] }
+aes-gcm = "0.10.2"
 
 thiserror = "1.0.37"
 chrono = "0.4.23"
 #lazy_static = "1.4.0"
-#moka = "0.9.6"
+moka = "0.9.6"
 protobuf = "3.2.0"
 #local-ip-address = "0.4.9"
-
-#mio = {version = "0.8.6",features = ["os-poll", "net"]}
-#tokio = { version = "1.24.1", features = ["full"] }
+socket2 ={ version = "0.5.2", features = ["all"] }
+tokio = { version = "1.28.1", features = ["full"] }
 [target.'cfg(any(unix))'.dependencies]
 tun = { path = "./rust-tun" }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-wintun = "0.2.1"
+
+win-tun-tap = {path = "./win-tun-tap"}
 libloading = "0.7.4"
 
 [build-dependencies]

switch/packet/Cargo.toml

@@ -7,4 +7,3 @@ edition = "2021"
 
 [dependencies]
 byteorder = "1.4.3"
-thiserror = "1.0.37"

switch/packet/src/arp/arp.rs

@@ -0,0 +1,122 @@
+use std::{fmt, io};
+
+/// 地址解析协议，由IP地址找到MAC地址
+/// https://www.ietf.org/rfc/rfc6747.txt
+/*
+   0      2       4         5          6      8      10  (字节)
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  | 硬件类型|协议类型|硬件地址长度|协议地址长度|操作类型|
+  |          源MAC地址                  |    源ip地址    |
+  |          目的MAC地址                 |   目的ip地址   |
+ */
+
+pub struct ArpPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> ArpPacket<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> io::Result<Self> {
+        if buffer.as_ref().len() != 28 {
+            Err(io::Error::from(io::ErrorKind::InvalidData))?;
+        }
+        let packet = Self::unchecked(buffer);
+        Ok(packet)
+    }
+}
+
+impl<B: AsRef<[u8]>> ArpPacket<B> {
+    /// 硬件类型 以太网类型为1
+    pub fn hardware_type(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[0..2].try_into().unwrap())
+    }
+    /// 上层协议类型,ipv4是0x0800
+    pub fn protocol_type(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
+    }
+    /// 如果是MAC地址 则长度为6
+    pub fn hardware_size(&self) -> u8 {
+        self.buffer.as_ref()[4]
+    }
+    /// 如果是IPv4 则长度为4
+    pub fn protocol_size(&self) -> u8 {
+        self.buffer.as_ref()[5]
+    }
+    /// 操作类型，请求和响应 1：ARP请求，2：ARP响应，3：RARP请求，4：RARP响应
+    pub fn op_code(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[6..8].try_into().unwrap())
+    }
+    /// 发送端硬件地址，仅支持以太网
+    pub fn sender_hardware_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[8..14]
+    }
+    /// 发送端协议地址，仅支持IPv4
+    pub fn sender_protocol_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[14..18]
+    }
+    /// 接收端硬件地址，仅支持以太网
+    pub fn target_hardware_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[18..24]
+    }
+    /// 接收端协议地址，仅支持IPv4
+    pub fn target_protocol_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[24..28]
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> ArpPacket<B> {
+    /// 硬件类型 以太网类型为1
+    pub fn set_hardware_type(&mut self, value: u16) {
+        self.buffer.as_mut()[0..2].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 上层协议类型,ipv4是0x0800
+    pub fn set_protocol_type(&mut self, value: u16) {
+        self.buffer.as_mut()[2..4].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 如果是MAC地址 则长度为6
+    pub fn set_hardware_size(&mut self, value: u8) {
+        self.buffer.as_mut()[4] = value
+    }
+    /// 如果是IPv4 则长度为4
+    pub fn set_protocol_size(&mut self, value: u8) {
+        self.buffer.as_mut()[5] = value
+    }
+    /// 操作类型，请求和响应 1：ARP请求，2：ARP响应，3：RARP请求，4：RARP响应
+    pub fn set_op_code(&mut self, value: u16) {
+        self.buffer.as_mut()[6..8].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 发送端硬件地址，仅支持以太网
+    pub fn set_sender_hardware_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[8..14].copy_from_slice(buf)
+    }
+    /// 发送端协议地址，仅支持IPv4
+    pub fn set_sender_protocol_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[14..18].copy_from_slice(buf)
+    }
+    /// 接收端硬件地址，仅支持以太网
+    pub fn set_target_hardware_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[18..24].copy_from_slice(buf)
+    }
+    /// 接收端协议地址，仅支持IPv4
+    pub fn set_target_protocol_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[24..28].copy_from_slice(buf)
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for ArpPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ArpPacket")
+            .field("hardware_type", &self.hardware_type())
+            .field("protocol_type", &self.protocol_type())
+            .field("hardware_size", &self.hardware_size())
+            .field("protocol_size", &self.protocol_size())
+            .field("op_code", &self.op_code())
+            .field("sender_hardware_addr", &self.sender_hardware_addr())
+            .field("sender_protocol_addr", &self.sender_protocol_addr())
+            .field("target_hardware_addr", &self.target_hardware_addr())
+            .field("target_protocol_addr", &self.target_protocol_addr())
+            .finish()
+    }
+}

switch/packet/src/arp/mod.rs

@@ -0,0 +1 @@
+pub mod arp;

switch/packet/src/error.rs

@@ -1,25 +0,0 @@
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error("the buffer is too small")]
-    SmallBuffer,
-
-    #[error("the packet is invalid")]
-    InvalidPacket,
-    #[error("Unimplemented")]
-    Unimplemented,
-    // #[error("the vaue is invalid for the field")]
-    // InvalidValue,
-    //
-    // #[error("the value has already been defined")]
-    // AlreadyDefined,
-    //
-    // #[error(transparent)]
-    // Io(#[from] io::Error),
-    //
-    // #[error(transparent)]
-    // Nul(#[from] ffi::NulError),
-}
-
-pub type Result<T> = ::std::result::Result<T, Error>;

switch/packet/src/ethernet/mod.rs

@@ -0,0 +1,2 @@
+pub mod packet;
+pub mod protocol;

switch/packet/src/ethernet/packet.rs

@@ -0,0 +1,77 @@
+use std::{fmt, io};
+use crate::ethernet::protocol::Protocol;
+
+/// 以太网帧协议
+/// https://www.ietf.org/rfc/rfc894.txt
+/*
+   0                      6                      12    14 (字节)
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |        目的地址         |         源地址         | 类型 |
+ */
+pub struct EthernetPacket<B> {
+    pub buffer: B,
+}
+
+impl<B: AsRef<[u8]>> EthernetPacket<B> {
+    pub fn unchecked(buffer: B) -> EthernetPacket<B> {
+        EthernetPacket { buffer }
+    }
+
+    pub fn new(buffer: B) -> io::Result<EthernetPacket<B>> {
+        let packet = EthernetPacket::unchecked(buffer);
+        //头部固定14位
+        if packet.buffer.as_ref().len() < 14 {
+            Err(io::Error::from(io::ErrorKind::InvalidData))?;
+        }
+
+        Ok(packet)
+    }
+}
+
+impl<B: AsRef<[u8]>> EthernetPacket<B> {
+    /// 目的MAC地址
+    pub fn destination(&self) -> &[u8] {
+        &self.buffer.as_ref()[0..6]
+    }
+    /// 源MAC地址
+    pub fn source(&self) -> &[u8] {
+        &self.buffer.as_ref()[6..12]
+    }
+    /// 3层协议
+    pub fn protocol(&self) -> Protocol {
+        u16::from_be_bytes(self.buffer.as_ref()[12..14].try_into().unwrap()).into()
+    }
+    /// 载荷
+    pub fn payload(&self) -> &[u8] {
+        &self.buffer.as_ref()[14..]
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> EthernetPacket<B> {
+    pub fn set_destination(&mut self, value: &[u8]) {
+        self.buffer.as_mut()[0..6].copy_from_slice(value);
+    }
+
+    pub fn set_source(&mut self, value: &[u8]) {
+        self.buffer.as_mut()[6..12].copy_from_slice(value);
+    }
+
+    pub fn set_protocol(&mut self, value: Protocol) {
+        let p: u16 = value.into();
+        self.buffer.as_mut()[12..14].copy_from_slice(&p.to_be_bytes())
+    }
+    pub fn payload_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer.as_mut()[14..]
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for EthernetPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EthernetPacket")
+            .field("destination", &self.destination())
+            .field("source", &self.source())
+            .field("protocol", &self.protocol())
+            .field("payload", &self.payload())
+            .finish()
+    }
+}

switch/packet/src/ethernet/protocol.rs

@@ -0,0 +1,141 @@
+/// 以太网帧协议
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum Protocol {
+    ///
+    Ipv4,
+
+    ///
+    Arp,
+
+    ///
+    WakeOnLan,
+
+    ///
+    Trill,
+
+    ///
+    DecNet,
+
+    ///
+    Rarp,
+
+    ///
+    AppleTalk,
+
+    ///
+    Aarp,
+
+    ///
+    Ipx,
+
+    ///
+    Qnx,
+
+    ///
+    Ipv6,
+
+    ///
+    FlowControl,
+
+    ///
+    CobraNet,
+
+    ///
+    Mpls,
+
+    ///
+    MplsMulticast,
+
+    ///
+    PppoeDiscovery,
+
+    ///
+    PppoeSession,
+
+    ///
+    Vlan,
+
+    ///
+    PBridge,
+
+    ///
+    Lldp,
+
+    ///
+    Ptp,
+
+    ///
+    Cfm,
+
+    ///
+    QinQ,
+
+    ///
+    Unknown(u16),
+}
+
+impl From<u16> for Protocol {
+    fn from(value: u16) -> Protocol {
+        use self::Protocol::*;
+
+        match value {
+            0x0800 => Ipv4,
+            0x0806 => Arp,
+            0x0842 => WakeOnLan,
+            0x22f3 => Trill,
+            0x6003 => DecNet,
+            0x8035 => Rarp,
+            0x809b => AppleTalk,
+            0x80f3 => Aarp,
+            0x8137 => Ipx,
+            0x8204 => Qnx,
+            0x86dd => Ipv6,
+            0x8808 => FlowControl,
+            0x8819 => CobraNet,
+            0x8847 => Mpls,
+            0x8848 => MplsMulticast,
+            0x8863 => PppoeDiscovery,
+            0x8864 => PppoeSession,
+            0x8100 => Vlan,
+            0x88a8 => PBridge,
+            0x88cc => Lldp,
+            0x88f7 => Ptp,
+            0x8902 => Cfm,
+            0x9100 => QinQ,
+            n      => Unknown(n),
+        }
+    }
+}
+
+impl Into<u16> for Protocol {
+    fn into(self) -> u16 {
+        use self::Protocol::*;
+
+        match self {
+            Ipv4           => 0x0800,
+            Arp            => 0x0806,
+            WakeOnLan      => 0x0842,
+            Trill          => 0x22f3,
+            DecNet         => 0x6003,
+            Rarp           => 0x8035,
+            AppleTalk      => 0x809b,
+            Aarp           => 0x80f3,
+            Ipx            => 0x8137,
+            Qnx            => 0x8204,
+            Ipv6           => 0x86dd,
+            FlowControl    => 0x8808,
+            CobraNet       => 0x8819,
+            Mpls           => 0x8847,
+            MplsMulticast  => 0x8848,
+            PppoeDiscovery => 0x8863,
+            PppoeSession   => 0x8864,
+            Vlan           => 0x8100,
+            PBridge        => 0x88a8,
+            Lldp           => 0x88cc,
+            Ptp            => 0x88f7,
+            Cfm            => 0x8902,
+            QinQ           => 0x9100,
+            Unknown(n)     => n,
+        }
+    }
+}

switch/packet/src/icmp/icmp.rs

@@ -1,9 +1,9 @@
-use std::fmt;
-
+use std::{fmt, io};
 use byteorder::{BigEndian, ReadBytesExt};
-
 use crate::cal_checksum;
-use crate::error::*;
+use crate::icmp::{Code, Kind};
+use crate::ip::ipv4::packet::IpV4Packet;
+
 /// icmp 协议
 /*  https://www.rfc-editor.org/rfc/rfc792
    0                   1                   2                   3
@@ -17,20 +17,18 @@ use crate::error::*;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 */
-use crate::icmp::{Code, Kind};
-use crate::ip::ipv4::packet::IpV4Packet;
 
 pub struct IcmpPacket<B> {
-    buffer: B,
+    pub buffer: B,
 }
 
 impl<B: AsRef<[u8]>> IcmpPacket<B> {
     pub fn unchecked(buffer: B) -> Self {
         Self { buffer }
     }
-    pub fn new(buffer: B) -> Result<Self> {
+    pub fn new(buffer: B) -> io::Result<Self> {
         if buffer.as_ref().len() < 8 {
-            Err(Error::SmallBuffer)?
+            Err(io::Error::from(io::ErrorKind::InvalidData))?;
         }
         let packet = Self::unchecked(buffer);
         Ok(packet)
@@ -56,9 +54,7 @@ impl<B: AsRef<[u8]>> IcmpPacket<B> {
         Code::from(self.kind(), self.buffer.as_ref()[1])
     }
     pub fn checksum(&self) -> u16 {
-        (&self.buffer.as_ref()[2..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
     }
     pub fn is_valid(&self) -> bool {
         self.checksum() == 0 || cal_checksum(self.buffer.as_ref()) == 0
@@ -71,12 +67,8 @@ impl<B: AsRef<[u8]>> IcmpPacket<B> {
             | Kind::TimestampReply
             | Kind::InformationRequest
             | Kind::InformationReply => {
-                let ide = (&self.buffer.as_ref()[4..])
-                    .read_u16::<BigEndian>()
-                    .unwrap();
-                let seq = (&self.buffer.as_ref()[6..])
-                    .read_u16::<BigEndian>()
-                    .unwrap();
+                let ide =u16::from_be_bytes(self.buffer.as_ref()[4..6].try_into().unwrap());
+                let seq = u16::from_be_bytes(self.buffer.as_ref()[6..8].try_into().unwrap());
                 HeaderOther::Identifier(ide, seq)
             }
             Kind::DestinationUnreachable | Kind::TimeExceeded | Kind::SourceQuench => {
@@ -110,6 +102,7 @@ impl<B: AsRef<[u8]>> IcmpPacket<B> {
             },
             Kind::TimestampRequest | Kind::TimestampReply => {
                 let mut buffer = Cursor::new(self.payload());
+
                 Description::Timestamp(
                     buffer.read_u32::<BigEndian>().unwrap(),
                     buffer.read_u32::<BigEndian>().unwrap(),
@@ -128,11 +121,11 @@ impl<B: AsRef<[u8]>> fmt::Debug for IcmpPacket<B> {
         } else {
             "icmp::Packet!"
         })
-        .field("kind", &self.kind())
-        .field("code", &self.code())
-        .field("checksum", &self.checksum())
-        .field("payload", &self.payload())
-        .finish()
+            .field("kind", &self.kind())
+            .field("code", &self.code())
+            .field("checksum", &self.checksum())
+            .field("payload", &self.payload())
+            .finish()
     }
 }
 

switch/packet/src/igmp/igmp_v1.rs

@@ -0,0 +1,117 @@
+use std::{fmt, io};
+use std::net::Ipv4Addr;
+use crate::cal_checksum;
+
+/// igmp v1
+/* https://datatracker.ietf.org/doc/html/rfc1112
+       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
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |Version| Type  |    Unused     |           Checksum            |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                         Group Address                         |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+/// v1版本的报文
+pub struct IgmpV1Packet<B> {
+    pub buffer: B,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum IgmpV1Type {
+    /// 0x11 所有组224.0.0.1或者特定组
+    Query,
+    /// 0x12
+    ReportV1,
+    Unknown(u8),
+}
+
+impl From<u8> for IgmpV1Type {
+    fn from(value: u8) -> IgmpV1Type {
+        use self::IgmpV1Type::*;
+
+        match value {
+            0x11 => Query,
+            0x12 => ReportV1,
+            v => Unknown(v),
+        }
+    }
+}
+
+impl Into<u8> for IgmpV1Type {
+    fn into(self) -> u8 {
+        match self {
+            IgmpV1Type::Query => 0x11,
+            IgmpV1Type::ReportV1 => 0x12,
+            IgmpV1Type::Unknown(v) => v
+        }
+    }
+}
+
+impl<B: AsRef<[u8]>> IgmpV1Packet<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> io::Result<Self> {
+        if buffer.as_ref().len() != 8 {
+            Err(io::Error::from(io::ErrorKind::InvalidData))
+        } else {
+            let packet = Self::unchecked(buffer);
+            Ok(packet)
+        }
+    }
+}
+
+impl<B: AsRef<[u8]>> IgmpV1Packet<B> {
+    pub fn version(&self) -> u8 {
+        self.buffer.as_ref()[0] >> 4
+    }
+    pub fn igmp_type(&self) -> IgmpV1Type {
+        IgmpV1Type::from(self.buffer.as_ref()[0] & 0x0F)
+    }
+    pub fn unused(&self) -> u8 {
+        self.buffer.as_ref()[1]
+    }
+    pub fn checksum(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
+    }
+    pub fn is_valid(&self) -> bool {
+        self.checksum() == 0 || cal_checksum(self.buffer.as_ref()) == 0
+    }
+    pub fn group_address(&self) -> Ipv4Addr {
+        let tmp: [u8; 4] = self.buffer.as_ref()[4..8].try_into().unwrap();
+        Ipv4Addr::from(tmp)
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> IgmpV1Packet<B> {
+    pub fn set_version(&mut self, version: u8) {
+        self.buffer.as_mut()[0] = (version << 4) | 0x0F & self.buffer.as_mut()[0]
+    }
+    pub fn set_type(&mut self, igmp_type: IgmpV1Type) {
+        let t: u8 = igmp_type.into();
+        self.buffer.as_mut()[0] = self.buffer.as_mut()[0] & 0xF0 | t
+    }
+    pub fn set_checksum(&mut self, checksum: u16) {
+        self.buffer.as_mut()[2..4].copy_from_slice(&checksum.to_be_bytes());
+    }
+    pub fn update_checksum(&mut self) {
+        self.set_checksum(0);
+        self.set_checksum(cal_checksum(self.buffer.as_ref()));
+    }
+    pub fn set_group_address(&mut self, group_address: Ipv4Addr) {
+        self.buffer.as_mut()[4..8].copy_from_slice(&group_address.octets());
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for IgmpV1Packet<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("igmp::V1")
+            .field("version", &self.version())
+            .field("type", &self.igmp_type())
+            .field("checksum", &self.checksum())
+            .field("is_valid", &self.is_valid())
+            .field("group_address", &self.group_address())
+            .finish()
+    }
+}

switch/packet/src/igmp/igmp_v2.rs

@@ -0,0 +1,118 @@
+use std::{fmt, io};
+use std::net::Ipv4Addr;
+use crate::cal_checksum;
+
+/// igmp v2
+/* https://www.rfc-editor.org/rfc/rfc2236.html
+
+    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
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |      Type     | Max Resp Time |           Checksum            |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                         Group Address                         |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+
+/// v2版本的报文
+pub struct IgmpV2Packet<B> {
+    pub buffer: B,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum IgmpV2Type {
+    /// 0x11 所有组224.0.0.1或者特定组
+    Query,
+    /// 0x16
+    ReportV2,
+    LeaveV2,
+    Unknown(u8),
+}
+
+impl From<u8> for IgmpV2Type {
+    fn from(value: u8) -> IgmpV2Type {
+        use self::IgmpV2Type::*;
+
+        match value {
+            0x11 => Query,
+            0x16 => ReportV2,
+            0x17 => LeaveV2,
+            v => Unknown(v),
+        }
+    }
+}
+
+impl Into<u8> for IgmpV2Type {
+    fn into(self) -> u8 {
+        match self {
+            IgmpV2Type::Query => 0x11,
+            IgmpV2Type::ReportV2 => 0x16,
+            IgmpV2Type::LeaveV2 => 0x17,
+            IgmpV2Type::Unknown(v) => v
+        }
+    }
+}
+
+impl<B: AsRef<[u8]>> IgmpV2Packet<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> io::Result<Self> {
+        if buffer.as_ref().len() != 8 {
+            Err(io::Error::from(io::ErrorKind::InvalidData))
+        } else {
+            let packet = Self::unchecked(buffer);
+            Ok(packet)
+        }
+    }
+}
+
+impl<B: AsRef<[u8]>> IgmpV2Packet<B> {
+    pub fn igmp_type(&self) -> IgmpV2Type {
+        IgmpV2Type::from(self.buffer.as_ref()[0])
+    }
+    pub fn max_resp_time(&self) -> u8 {
+        self.buffer.as_ref()[1]
+    }
+    pub fn checksum(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
+    }
+    pub fn is_valid(&self) -> bool {
+        self.checksum() == 0 || cal_checksum(self.buffer.as_ref()) == 0
+    }
+    pub fn group_address(&self) -> Ipv4Addr {
+        let tmp: [u8; 4] = self.buffer.as_ref()[4..8].try_into().unwrap();
+        Ipv4Addr::from(tmp)
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> IgmpV2Packet<B> {
+    pub fn set_type(&mut self, igmp_type: IgmpV2Type) {
+        self.buffer.as_mut()[0] = igmp_type.into()
+    }
+    pub fn set_max_resp_time(&mut self, resp: u8) {
+        self.buffer.as_mut()[1] = resp
+    }
+    pub fn set_checksum(&mut self, checksum: u16) {
+        self.buffer.as_mut()[2..4].copy_from_slice(&checksum.to_be_bytes());
+    }
+    pub fn update_checksum(&mut self) {
+        self.set_checksum(0);
+        self.set_checksum(cal_checksum(self.buffer.as_ref()));
+    }
+    pub fn set_group_address(&mut self, group_address: Ipv4Addr) {
+        self.buffer.as_mut()[4..8].copy_from_slice(&group_address.octets());
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for IgmpV2Packet<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("igmp::V2")
+            .field("type", &self.igmp_type())
+            .field("max_resp_time", &self.max_resp_time())
+            .field("checksum", &self.checksum())
+            .field("is_valid", &self.is_valid())
+            .field("group_address", &self.group_address())
+            .finish()
+    }
+}

switch/packet/src/igmp/igmp_v3.rs

@@ -0,0 +1,491 @@
+use std::{fmt, io};
+use std::net::Ipv4Addr;
+
+use crate::cal_checksum;
+
+/// igmp v3
+/* https://www.rfc-editor.org/rfc/rfc3376
+Query:
+       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
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |  Type = 0x11  | Max Resp Code |           Checksum            |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                         Group Address                         |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      | Resv  |S| QRV |     QQIC      |     Number of Sources (N)     |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                       Source Address [1]                      |
+      +-                                                             -+
+      |                       Source Address [2]                      |
+      +-                              .                              -+
+      .                               .                               .
+      .                               .                               .
+      +-                                                             -+
+      |                       Source Address [N]                      |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+-----------------------------------------------------------------------------
+
+Report:
+       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
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |  Type = 0x22  |    Reserved   |           Checksum            |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |           Reserved            |  Number of Group Records (M)  |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                                                               |
+      .                                                               .
+      .                        Group Record [1]                       .
+      .                                                               .
+      |                                                               |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                                                               |
+      .                                                               .
+      .                        Group Record [2]                       .
+      .                                                               .
+      |                                                               |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                               .                               |
+      .                               .                               .
+      |                               .                               |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                                                               |
+      .                                                               .
+      .                        Group Record [M]                       .
+      .                                                               .
+      |                                                               |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+Group Record:
+
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |  Record Type  |  Aux Data Len |     Number of Sources (N)     |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                       Multicast Address                       |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                       Source Address [1]                      |
+      +-                                                             -+
+      |                       Source Address [2]                      |
+      +-                                                             -+
+      .                               .                               .
+      .                               .                               .
+      .                               .                               .
+      +-                                                             -+
+      |                       Source Address [N]                      |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |                                                               |
+      .                                                               .
+      .                         Auxiliary Data                        .
+      .                                                               .
+      |                                                               |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+Record Type:
+    1    MODE_IS_INCLUDE 表示主机希望加入指定组播组并指定了一个或多个源地址
+    2    MODE_IS_EXCLUDE 表示主机希望加入指定组播组但排除了一个或多个源地址
+    3    CHANGE_TO_INCLUDE_MODE 表示主机正在将组播组的过滤模式从排除切换为包括，指定了一个或多个源地址
+    4    CHANGE_TO_EXCLUDE_MODE 表示主机正在将组播组的过滤模式从包括切换为排除，指定了一个或多个源地址
+    5    ALLOW_NEW_SOURCES 表示主机希望在已有的源地址列表中添加新的源地址，指定了一个或多个源地址
+    6    BLOCK_OLD_SOURCES 表示主机希望在已有的源地址列表中删除旧的源地址，指定了一个或多个源地址
+ */
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum IgmpV3Type {
+    /// 0x11 所有组224.0.0.1或者特定组
+    Query,
+    /// 0x22
+    ReportV3,
+    Unknown(u8),
+}
+
+impl From<u8> for IgmpV3Type {
+    fn from(value: u8) -> IgmpV3Type {
+        use self::IgmpV3Type::*;
+
+        match value {
+            0x11 => Query,
+            0x22 => ReportV3,
+            v => Unknown(v),
+        }
+    }
+}
+
+impl Into<u8> for IgmpV3Type {
+    fn into(self) -> u8 {
+        match self {
+            IgmpV3Type::Query => 0x11,
+            IgmpV3Type::ReportV3 => 0x22,
+            IgmpV3Type::Unknown(v) => v
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum IgmpV3RecordType {
+    //1    MODE_IS_INCLUDE 表示主机希望加入指定组播组并指定了一个或多个源地址
+    ModeIsInclude,
+    //2    MODE_IS_EXCLUDE 表示主机希望加入指定组播组但排除了一个或多个源地址
+    ModeIsExclude,
+    //3    CHANGE_TO_INCLUDE_MODE 表示主机正在将组播组的过滤模式从排除切换为包括，指定了一个或多个源地址
+    ChangeToIncludeMode,
+    //4    CHANGE_TO_EXCLUDE_MODE 表示主机正在将组播组的过滤模式从包括切换为排除，指定了一个或多个源地址
+    ChangeToExcludeMode,
+    //5    ALLOW_NEW_SOURCES 表示主机希望在已有的源地址列表中添加新的源地址，指定了一个或多个源地址
+    AllowNewSources,
+    //6    BLOCK_OLD_SOURCES 表示主机希望在已有的源地址列表中删除旧的源地址，指定了一个或多个源地址
+    BlockOldSources,
+    Unknown(u8),
+}
+
+impl From<u8> for IgmpV3RecordType {
+    fn from(value: u8) -> IgmpV3RecordType {
+        use self::IgmpV3RecordType::*;
+
+        match value {
+            1 => ModeIsInclude,
+            2 => ModeIsExclude,
+            3 => ChangeToIncludeMode,
+            4 => ChangeToExcludeMode,
+            5 => AllowNewSources,
+            6 => BlockOldSources,
+            v => Unknown(v),
+        }
+    }
+}
+
+impl Into<u8> for IgmpV3RecordType {
+    fn into(self) -> u8 {
+        use self::IgmpV3RecordType::*;
+
+        match self {
+            ModeIsInclude => 1,
+            ModeIsExclude => 2,
+            ChangeToIncludeMode => 3,
+            ChangeToExcludeMode => 4,
+            AllowNewSources => 5,
+            BlockOldSources => 6,
+            Unknown(v) => v,
+        }
+    }
+}
+
+/// v3版本的query报文
+pub struct IgmpV3QueryPacket<B> {
+    pub buffer: B,
+}
+
+impl<B: AsRef<[u8]>> IgmpV3QueryPacket<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> io::Result<Self> {
+        if buffer.as_ref().len() < 12 {
+            Err(io::Error::from(io::ErrorKind::InvalidData))
+        } else {
+            let packet = Self::unchecked(buffer);
+            Ok(packet)
+        }
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> IgmpV3QueryPacket<B> {
+    pub fn set_igmp_type(&mut self) {
+        self.buffer.as_mut()[0] = IgmpV3Type::Query.into();
+    }
+    pub fn set_max_resp_code(&mut self, code: u8) {
+        self.buffer.as_mut()[1] = code;
+    }
+    pub fn set_group_address(&mut self, addr: Ipv4Addr) {
+        self.buffer.as_mut()[4..8].copy_from_slice(&addr.octets())
+    }
+    pub fn set_checksum(&mut self, checksum: u16) {
+        self.buffer.as_mut()[2..4].copy_from_slice(&checksum.to_be_bytes())
+    }
+    pub fn set_qrv(&mut self, qrv: u8) {
+        self.buffer.as_mut()[8] = (self.buffer.as_ref()[8]&(!0x07)) | (qrv & 0x07)
+    }
+    pub fn set_qqic(&mut self, qqic: u8) {
+        self.buffer.as_mut()[9] = qqic
+    }
+
+    pub fn update_checksum(&mut self) {
+        self.set_checksum(0);
+        let checksum = cal_checksum(self.buffer.as_ref());
+        self.set_checksum(checksum);
+    }
+}
+
+impl<B: AsRef<[u8]>> IgmpV3QueryPacket<B> {
+    pub fn igmp_type(&self) -> IgmpV3Type {
+        IgmpV3Type::from(self.buffer.as_ref()[0])
+    }
+    pub fn max_resp_code(&self) -> u8 {
+        self.buffer.as_ref()[1]
+    }
+    pub fn checksum(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
+    }
+    pub fn is_valid(&self) -> bool {
+        self.checksum() == 0 || cal_checksum(self.buffer.as_ref()) == 0
+    }
+    pub fn group_address(&self) -> Ipv4Addr {
+        let tmp: [u8; 4] = self.buffer.as_ref()[4..8].try_into().unwrap();
+        Ipv4Addr::from(tmp)
+    }
+    /// 保留字段，设置为0
+    pub fn resv(&self) -> u8 {
+        self.buffer.as_ref()[8] >> 4
+    }
+    /// 标志位
+    /// 该比特位为1时，所有收到此查询报文的其他路由器不启动定时器刷新过程，但是此查询报文并不抑制查询者选举过程和路由器的主机侧处理过程；默认未置位。
+    pub fn s(&self) -> u8 {
+        (self.buffer.as_ref()[8] & 0x0F) >> 3
+    }
+    /// 查询者向网络通告的健壮系数
+    /// 此参数可使查询者使用自己的健壮系统同步其他组播路由器的健壮系数；
+    /// 其他路由器接收到查询报文时，如果发现该字段非0,则将自己的健壮系数调整为该字段的值;如果发现该字段为0，则不做处理。默认健壮系数值为2。
+    pub fn qrv(&self) -> u8 {
+        self.buffer.as_ref()[8] & 0x07
+    }
+    /// IGMP查询者的查询间隔
+    /// 非查询者收到查询报文时，如果发现该字段非0，则将自己的查询间隔参数调整为该字段的值:如果发现该字段为0，则不做处理。默认值为60。
+    pub fn qqic(&self) -> u8 {
+        self.buffer.as_ref()[9]
+    }
+    /// 报文中包含的组播源的数量
+    /// 对于普遍组查询报文和特定组查询报文，该字段为0；对于特定源组查询报文，该字段非0
+    pub fn source_number(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[10..12].try_into().unwrap())
+    }
+    pub fn source_addresses(&self) -> Option<Vec<Ipv4Addr>> {
+        let num = self.source_number();
+        if num == 0 {
+            None
+        } else {
+            let num = num as usize;
+            let mut list = Vec::with_capacity(num);
+            let buf = self.buffer.as_ref();
+            let len = buf.len();
+            for index in 0..num {
+                let start = (12 + index * 4) as usize;
+                let end = start + 4;
+                if end > len {
+                    return None;
+                }
+                let tmp: [u8; 4] = buf[start..end].try_into().unwrap();
+                list.push(Ipv4Addr::from(tmp));
+            }
+            Some(list)
+        }
+    }
+    pub fn source_address(&self, index: u16) -> Option<Ipv4Addr> {
+        if self.source_number() >= index {
+            None
+        } else {
+            let start = (12 + index * 4) as usize;
+            let end = start + 4;
+            let buf = self.buffer.as_ref();
+            let len = buf.len();
+            if end > len {
+                return None;
+            }
+            let tmp: [u8; 4] = buf[start..end].try_into().unwrap();
+            Some(Ipv4Addr::from(tmp))
+        }
+    }
+}
+
+/// v3版本的query报文
+pub struct IgmpV3ReportPacket<B> {
+    pub buffer: B,
+}
+
+impl<B: AsRef<[u8]>> IgmpV3ReportPacket<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> io::Result<Self> {
+        if buffer.as_ref().len() < 8 {
+            Err(io::Error::from(io::ErrorKind::InvalidData))
+        } else {
+            let packet = Self::unchecked(buffer);
+            Ok(packet)
+        }
+    }
+}
+
+impl<B: AsRef<[u8]>> IgmpV3ReportPacket<B> {
+    pub fn igmp_type(&self) -> IgmpV3Type {
+        IgmpV3Type::from(self.buffer.as_ref()[0])
+    }
+    pub fn reserved1(&self) -> u8 {
+        self.buffer.as_ref()[1]
+    }
+    pub fn checksum(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
+    }
+    pub fn is_valid(&self) -> bool {
+        self.checksum() == 0 || cal_checksum(self.buffer.as_ref()) == 0
+    }
+    pub fn reserved2(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[4..6].try_into().unwrap())
+    }
+    pub fn record_number(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[6..8].try_into().unwrap())
+    }
+    pub fn group_records(&self) -> Option<Vec<IgmpV3RecordPacket<&[u8]>>> {
+        let num = self.record_number();
+        if num == 0 {
+            None
+        } else {
+            let num = num as usize;
+            let mut list = Vec::with_capacity(num);
+            let mut start = 8 as usize;
+            let buf = self.buffer.as_ref();
+            let len = buf.len();
+            for _ in 0..num {
+                if start >= len {
+                    return None;
+                }
+                if let Ok(record) = IgmpV3RecordPacket::new(&buf[start..]) {
+                    let end = start + 8 + record.aux_data_len() as usize * 4 + record.source_number() as usize * 4;
+                    if end > len {
+                        return None;
+                    }
+                    list.push(IgmpV3RecordPacket::new(&buf[start..end]).unwrap());
+                    start = end;
+                } else {
+                    return None;
+                }
+            }
+            Some(list)
+        }
+    }
+}
+
+
+/// group record
+pub struct IgmpV3RecordPacket<B> {
+    pub buffer: B,
+}
+
+impl<B: AsRef<[u8]>> IgmpV3RecordPacket<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> io::Result<Self> {
+        if buffer.as_ref().len() < 8 {
+            Err(io::Error::from(io::ErrorKind::InvalidData))
+        } else {
+            let packet = Self::unchecked(buffer);
+            Ok(packet)
+        }
+    }
+}
+
+impl<B: AsRef<[u8]>> IgmpV3RecordPacket<B> {
+    pub fn record_type(&self) -> IgmpV3RecordType {
+        IgmpV3RecordType::from(self.buffer.as_ref()[0])
+    }
+    /// 辅助数据长度 以4字节为单位
+    pub fn aux_data_len(&self) -> u8 {
+        self.buffer.as_ref()[1]
+    }
+    /// 源地址数
+    pub fn source_number(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
+    }
+    ///多播地址
+    pub fn multicast_address(&self) -> Ipv4Addr {
+        let tmp: [u8; 4] = self.buffer.as_ref()[4..8].try_into().unwrap();
+        Ipv4Addr::from(tmp)
+    }
+    pub fn source_addresses(&self) -> Option<Vec<Ipv4Addr>> {
+        let num = self.source_number();
+        if num == 0 {
+            None
+        } else {
+            let num = num as usize;
+            let mut list = Vec::with_capacity(num);
+            let buf = self.buffer.as_ref();
+            let len = buf.len();
+            for index in 0..num {
+                let start = (8 + index * 4) as usize;
+                let end = start + 4;
+                if end > len {
+                    return None;
+                }
+                let tmp: [u8; 4] = buf[start..end].try_into().unwrap();
+                list.push(Ipv4Addr::from(tmp));
+            }
+            Some(list)
+        }
+    }
+    pub fn source_address(&self, index: u16) -> Option<Ipv4Addr> {
+        if self.source_number() >= index {
+            None
+        } else {
+            let start = (8 + index * 4) as usize;
+            let end = start + 4;
+            if end > self.buffer.as_ref().len() {
+                return None;
+            }
+            let tmp: [u8; 4] = self.buffer.as_ref()[start..end].try_into().unwrap();
+            Some(Ipv4Addr::from(tmp))
+        }
+    }
+    /// 在文档中没有定义辅助数据的作用，通常应该是空的
+    pub fn auxiliary_data(&self) -> &[u8] {
+        let start = 8 + self.source_number() as usize * 4;
+        let end = start + self.aux_data_len() as usize * 4;
+        if end > self.buffer.as_ref().len() {
+            return &[];
+        }
+        &self.buffer.as_ref()[start..end]
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for IgmpV3QueryPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("igmp::V3Query")
+            .field("type", &self.igmp_type())
+            .field("max_resp_code", &self.max_resp_code())
+            .field("checksum", &self.checksum())
+            .field("is_valid", &self.is_valid())
+            .field("group_address", &self.group_address())
+            .field("s", &self.s())
+            .field("qrv", &self.qrv())
+            .field("qqic", &self.qqic())
+            .field("number of sources", &self.source_number())
+            .field("source_addresses", &self.source_addresses())
+            .finish()
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for IgmpV3ReportPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("igmp::V3Report")
+            .field("type", &self.igmp_type())
+            .field("reserved1", &self.reserved1())
+            .field("checksum", &self.checksum())
+            .field("is_valid", &self.is_valid())
+            .field("reserved2", &self.reserved2())
+            .field("record_number", &self.record_number())
+            .field("group_records", &self.group_records())
+            .finish()
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for IgmpV3RecordPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("igmp::V3Record")
+            .field("record_type", &self.record_type())
+            .field("aux_data_len", &self.aux_data_len())
+            .field("source_number", &self.source_number())
+            .field("multicast_address", &self.multicast_address())
+            .field("source_addresses", &self.source_addresses())
+            .field("auxiliary_data", &self.auxiliary_data())
+            .finish()
+    }
+}

switch/packet/src/igmp/mod.rs

@@ -0,0 +1,46 @@
+pub mod igmp_v1;
+pub mod igmp_v2;
+pub mod igmp_v3;
+
+#[derive(Debug,Copy, Clone,Eq, PartialEq)]
+pub enum IgmpType {
+    /// 0x11 所有组224.0.0.1或者特定组
+    Query,
+    /// 0x12
+    ReportV1,
+    /// 0x16
+    ReportV2,
+    /// 0x22
+    ReportV3,
+    /// 0x17 目标组固定是 224.0.0.2
+    LeaveV2,
+    Unknown(u8),
+}
+
+impl From<u8> for IgmpType {
+    fn from(value: u8) -> IgmpType {
+        use self::IgmpType::*;
+
+        match value {
+            0x11 => Query,
+            0x12 => ReportV1,
+            0x16 => ReportV2,
+            0x22 => ReportV3,
+            0x17 => LeaveV2,
+            v => Unknown(v),
+        }
+    }
+}
+
+impl Into<u8> for IgmpType {
+    fn into(self) -> u8 {
+        match self {
+            IgmpType::Query => 0x11,
+            IgmpType::ReportV1 => 0x12,
+            IgmpType::ReportV2 => 0x16,
+            IgmpType::ReportV3 => 0x22,
+            IgmpType::LeaveV2 => 0x17,
+            IgmpType::Unknown(v) => v
+        }
+    }
+}

switch/packet/src/ip/ipv4/packet.rs

@@ -1,10 +1,8 @@
-use std::fmt;
+use std::{fmt, io};
 use std::net::Ipv4Addr;
 
-use byteorder::{BigEndian, ReadBytesExt};
 
 use crate::cal_checksum;
-use crate::error::*;
 use crate::ip::ipv4::protocol::Protocol;
 
 /// ip协议
@@ -39,16 +37,16 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
     pub fn unchecked(buffer: B) -> Self {
         Self { buffer }
     }
-    pub fn new(buffer: B) -> Result<Self> {
-        if buffer.as_ref()[0] >> 4 != 4 {
-            Err(Error::Unimplemented)?
-        }
+    pub fn new(buffer: B) -> io::Result<Self> {
         if buffer.as_ref().len() < 20 {
-            Err(Error::SmallBuffer)?
+            Err(io::Error::new(io::ErrorKind::InvalidData, "len < 20"))?;
+        }
+        if buffer.as_ref()[0] >> 4 != 4 {
+            Err(io::Error::new(io::ErrorKind::InvalidData, "not ipv4"))?;
         }
         let packet = Self::unchecked(buffer);
         if packet.buffer.as_ref().len() < packet.header_len() as usize * 4 {
-            Err(Error::SmallBuffer)?
+            Err(io::Error::new(io::ErrorKind::InvalidData, "head_len err"))?;
         }
         Ok(packet)
     }
@@ -60,17 +58,6 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
     }
     pub fn payload(&self) -> &[u8] {
         &self.buffer.as_ref()[(self.header_len() as usize * 4)..]
-        // match self.protocol() {
-        //     Protocol::Udp => {
-        //         let udp = UdpPacket::new(IpAddr::V4(self.source_ip()),
-        //                                  IpAddr::V4(self.destination_ip()),
-        //                                  &self.buffer.as_ref()[(self.header_len() as usize * 4)..])?;
-        //         Ok(crate::IpUpperLayer::UDP(udp))
-        //     }
-        //     _ => {
-        //         Ok(crate::IpUpperLayer::Unknown(self.buffer.as_ref()));
-        //     }
-        // }
     }
 }
 
@@ -83,13 +70,18 @@ impl<B: AsRef<[u8]> + AsMut<[u8]>> IpV4Packet<B> {
         let len = self.header_len() as usize * 4;
         &mut self.buffer.as_mut()[len..]
     }
-
+    pub fn set_protocol(&mut self, value: Protocol) {
+        self.header_mut()[9] = value.into();
+    }
     pub fn set_source_ip(&mut self, value: Ipv4Addr) {
         self.header_mut()[12..16].copy_from_slice(&value.octets());
     }
     pub fn set_destination_ip(&mut self, value: Ipv4Addr) {
         self.header_mut()[16..20].copy_from_slice(&value.octets());
     }
+    pub fn set_flags(&mut self, flags: u8) {
+        self.buffer.as_mut()[6] = (self.buffer.as_ref()[6] & 0b11100000) | (flags << 5)
+    }
     fn set_checksum(&mut self, value: u16) {
         self.header_mut()[10..12].copy_from_slice(&value.to_be_bytes())
     }
@@ -141,16 +133,12 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
 
     /// ip报总字节数
     pub fn length(&self) -> u16 {
-        (&self.buffer.as_ref()[2..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
     }
 
     /// 标识. ip报文在数据链路层可能会被拆分，同一报文的不同分组标识字段相同
     pub fn id(&self) -> u16 {
-        (&self.buffer.as_ref()[4..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[4..6].try_into().unwrap())
     }
 
     /// 标志 3位.
@@ -170,10 +158,7 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
     /// 以字节为单位,用于指明分段起始点相对于包头起始点的偏移量
     /// 由于分段到达时可能错序，所以分段的偏移字段可以使接收者按照正确的顺序重组数据包
     pub fn offset(&self) -> u16 {
-        (&self.buffer.as_ref()[6..])
-            .read_u16::<BigEndian>()
-            .unwrap()
-            & 0x1fff
+        u16::from_be_bytes(self.buffer.as_ref()[6..8].try_into().unwrap()) & 0x1fff
     }
 
     /// 生存时间.
@@ -189,9 +174,7 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
 
     /// 首部校验和
     pub fn checksum(&self) -> u16 {
-        (&self.buffer.as_ref()[10..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[10..12].try_into().unwrap())
     }
     /// 验证校验和
     ///

switch/packet/src/ip/ipv4/protocol.rs

@@ -1,4 +1,4 @@
-#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+#[derive(Eq, PartialEq,Ord, PartialOrd, Copy, Clone, Debug)]
 pub enum Protocol {
     ///
     Hopopt,

switch/packet/src/ip/mod.rs

@@ -1,7 +1,6 @@
+use std::io;
 use ipv4::packet::IpV4Packet;
 
-use crate::error::*;
-
 pub mod ipv4;
 
 pub enum IpPacket<B> {
@@ -9,10 +8,10 @@ pub enum IpPacket<B> {
 }
 
 impl<B: AsRef<[u8]>> IpPacket<B> {
-    pub fn new(buffer: B) -> Result<Self> {
+    pub fn new(buffer: B) -> io::Result<Self> {
         match buffer.as_ref()[0] >> 4 {
             4 => Ok(IpPacket::V4(IpV4Packet::new(buffer)?)),
-            _ => Err(Error::InvalidPacket),
+            _ => Err(io::Error::from(io::ErrorKind::InvalidData)),
         }
     }
 }

switch/packet/src/lib.rs

@@ -3,12 +3,13 @@ use std::net::Ipv4Addr;
 use byteorder::BigEndian;
 use byteorder::ReadBytesExt;
 
-pub mod error;
 pub mod icmp;
+pub mod igmp;
 pub mod ip;
 pub mod tcp;
 pub mod udp;
-
+pub mod ethernet;
+pub mod arp;
 // pub enum IpUpperLayer<B> {
 //     UDP(UdpPacket<B>),
 //     Unknown(B),

switch/packet/src/tcp/tcp.rs

@@ -1,9 +1,6 @@
-use std::fmt;
-use std::net::IpAddr;
+use std::{fmt, io};
+use std::net::Ipv4Addr;
 
-use byteorder::{BigEndian, ReadBytesExt};
-
-use crate::error::*;
 use crate::tcp::Flags;
 
 /// tcp
@@ -48,59 +45,69 @@ use crate::tcp::Flags;
   Options+Padding:32位整数倍，最多40个字节
 */
 pub struct TcpPacket<B> {
-    source_ip: IpAddr,
-    destination_ip: IpAddr,
+    source_ip: Ipv4Addr,
+    destination_ip: Ipv4Addr,
     buffer: B,
 }
 
 impl<B: AsRef<[u8]>> TcpPacket<B> {
-    pub fn unchecked(source_ip: IpAddr, destination_ip: IpAddr, buffer: B) -> TcpPacket<B> {
+    pub fn unchecked(source_ip: Ipv4Addr, destination_ip: Ipv4Addr, buffer: B) -> TcpPacket<B> {
         TcpPacket {
             source_ip,
             destination_ip,
             buffer,
         }
     }
-    pub fn new(source_ip: IpAddr, destination_ip: IpAddr, buffer: B) -> Result<TcpPacket<B>> {
+    pub fn new(source_ip: Ipv4Addr, destination_ip: Ipv4Addr, buffer: B) -> io::Result<TcpPacket<B>> {
         let packet = TcpPacket::unchecked(source_ip, destination_ip, buffer);
 
         if packet.buffer.as_ref().len() < 20 {
-            Err(Error::SmallBuffer)?
+            Err(io::Error::from(io::ErrorKind::InvalidData))?;
         }
 
         if packet.buffer.as_ref().len() < packet.data_offset() as usize * 4 {
-            Err(Error::SmallBuffer)?
+            Err(io::Error::from(io::ErrorKind::InvalidData))?;
         }
 
         Ok(packet)
     }
 }
 
+impl<B: AsRef<[u8]> + AsMut<[u8]>> TcpPacket<B> {
+    fn set_checksum(&mut self, value: u16) {
+        self.buffer.as_mut()[16..18].copy_from_slice(&value.to_be_bytes())
+    }
+    pub fn set_source_port(&mut self, value: u16) {
+        self.buffer.as_mut()[0..2].copy_from_slice(&value.to_be_bytes())
+    }
+    pub fn set_destination_port(&mut self, value: u16) {
+        self.buffer.as_mut()[2..4].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 更新校验和
+    pub fn update_checksum(&mut self) {
+        //先将校验和置0
+        self.set_checksum(0);
+        self.set_checksum(self.cal_checksum())
+    }
+}
+
 impl<B: AsRef<[u8]>> TcpPacket<B> {
     /// 源端口
     pub fn source_port(&self) -> u16 {
-        (&self.buffer.as_ref()[0..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[0..2].try_into().unwrap())
     }
 
     /// 目标端口
     pub fn destination_port(&self) -> u16 {
-        (&self.buffer.as_ref()[2..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
     }
     /// 序列号
     pub fn sequence(&self) -> u32 {
-        (&self.buffer.as_ref()[4..])
-            .read_u32::<BigEndian>()
-            .unwrap()
+        u32::from_be_bytes(self.buffer.as_ref()[4..8].try_into().unwrap())
     }
     /// 确认号
     pub fn acknowledgment(&self) -> u32 {
-        (&self.buffer.as_ref()[8..])
-            .read_u32::<BigEndian>()
-            .unwrap()
+        u32::from_be_bytes(self.buffer.as_ref()[8..12].try_into().unwrap())
     }
     /// 数据偏移 4字节为单位
     pub fn data_offset(&self) -> u8 {
@@ -110,14 +117,10 @@ impl<B: AsRef<[u8]>> TcpPacket<B> {
         Flags(self.buffer.as_ref()[13])
     }
     pub fn window(&self) -> u16 {
-        (&self.buffer.as_ref()[14..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[14..16].try_into().unwrap())
     }
     pub fn checksum(&self) -> u16 {
-        (&self.buffer.as_ref()[16..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[16..18].try_into().unwrap())
     }
     /// 验证校验和,ipv4中为0表示不使用校验和，ipv6校验和不能为0
     /// TCP/IP协议栈不会自己计算校验和，而是简单地将一个空的校验和字段(零或随机填充)交给网卡硬件。
@@ -126,26 +129,16 @@ impl<B: AsRef<[u8]>> TcpPacket<B> {
         self.checksum() == 0 || self.cal_checksum() == 0
     }
     fn cal_checksum(&self) -> u16 {
-        match self.source_ip {
-            IpAddr::V4(src) => {
-                if let IpAddr::V4(dest) = self.destination_ip {
-                    return crate::ipv4_cal_checksum(
-                        self.buffer.as_ref(),
-                        &src,
-                        &dest,
-                        6,
-                        self.buffer.as_ref().len() as u16,
-                    );
-                }
-            }
-            IpAddr::V6(_src) => {}
-        }
-        unimplemented!()
+        crate::ipv4_cal_checksum(
+            self.buffer.as_ref(),
+            &self.source_ip,
+            &self.destination_ip,
+            6,
+            self.buffer.as_ref().len() as u16,
+        )
     }
     pub fn urgent_pointer(&self) -> u16 {
-        (&self.buffer.as_ref()[18..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[18..20].try_into().unwrap())
     }
     pub fn options(&self) -> &[u8] {
         &self.buffer.as_ref()[20..(self.data_offset() as usize * 4)]

switch/packet/src/udp/udp.rs

@@ -1,11 +1,5 @@
-use std::fmt;
-use std::io::Cursor;
-use std::net::IpAddr;
-
-use byteorder::WriteBytesExt;
-use byteorder::{BigEndian, ReadBytesExt};
-
-use crate::error::*;
+use std::{fmt, io};
+use std::net::Ipv4Addr;
 
 /// udp协议
 ///
@@ -53,22 +47,22 @@ RFC 768   https://www.ietf.org/rfc/rfc768.txt
 */
 
 pub struct UdpPacket<B> {
-    source_ip: IpAddr,
-    destination_ip: IpAddr,
+    source_ip: Ipv4Addr,
+    destination_ip: Ipv4Addr,
     buffer: B,
 }
 
 impl<B: AsRef<[u8]>> UdpPacket<B> {
-    pub fn unchecked(source_ip: IpAddr, destination_ip: IpAddr, buffer: B) -> UdpPacket<B> {
+    pub fn unchecked(source_ip: Ipv4Addr, destination_ip: Ipv4Addr, buffer: B) -> UdpPacket<B> {
         UdpPacket {
             source_ip,
             destination_ip,
             buffer,
         }
     }
-    pub fn new(source_ip: IpAddr, destination_ip: IpAddr, buffer: B) -> Result<UdpPacket<B>> {
+    pub fn new(source_ip: Ipv4Addr, destination_ip: Ipv4Addr, buffer: B) -> io::Result<UdpPacket<B>> {
         if buffer.as_ref().len() < 8 {
-            Err(Error::SmallBuffer)?
+            Err(io::Error::from(io::ErrorKind::InvalidData))?;
         }
         let packet = Self::unchecked(source_ip, destination_ip, buffer);
         Ok(packet)
@@ -78,30 +72,22 @@ impl<B: AsRef<[u8]>> UdpPacket<B> {
 impl<B: AsRef<[u8]>> UdpPacket<B> {
     /// 源端口
     pub fn source_port(&self) -> u16 {
-        (&self.buffer.as_ref()[0..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[0..2].try_into().unwrap())
     }
 
     /// 目标端口
     pub fn destination_port(&self) -> u16 {
-        (&self.buffer.as_ref()[2..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
     }
 
     /// 总字节数
     pub fn length(&self) -> u16 {
-        (&self.buffer.as_ref()[4..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[4..6].try_into().unwrap())
     }
 
     /// Checksum of the packet.
     pub fn checksum(&self) -> u16 {
-        (&self.buffer.as_ref()[6..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[6..8].try_into().unwrap())
     }
     /// 验证校验和,ipv4中为0表示不使用校验和，ipv6校验和不能为0
     pub fn is_valid(&self) -> bool {
@@ -111,21 +97,13 @@ impl<B: AsRef<[u8]>> UdpPacket<B> {
         &self.buffer.as_ref()[8..]
     }
     fn cal_checksum(&self) -> u16 {
-        match self.source_ip {
-            IpAddr::V4(src) => {
-                if let IpAddr::V4(dest) = self.destination_ip {
-                    return crate::ipv4_cal_checksum(
-                        self.buffer.as_ref(),
-                        &src,
-                        &dest,
-                        17,
-                        self.length(),
-                    );
-                }
-            }
-            IpAddr::V6(_src) => {}
-        }
-        unimplemented!()
+        crate::ipv4_cal_checksum(
+            self.buffer.as_ref(),
+            &self.source_ip,
+            &self.destination_ip,
+            17,
+            self.length(),
+        )
     }
 }
 
@@ -137,29 +115,21 @@ impl<B: AsRef<[u8]> + AsMut<[u8]>> UdpPacket<B> {
 
 impl<B: AsRef<[u8]> + AsMut<[u8]>> UdpPacket<B> {
     /// 设置源端口
-    pub fn set_source_port(&mut self, value: u16) -> &mut Self {
-        Cursor::new(&mut self.header_mut()[0..])
-            .write_u16::<BigEndian>(value)
-            .unwrap();
-        self
+    pub fn set_source_port(&mut self, value: u16) {
+        self.buffer.as_mut()[0..2].copy_from_slice(&value.to_be_bytes())
     }
 
     /// 设置目的端口
-    pub fn set_destination_port(&mut self, value: u16) -> &mut Self {
-        Cursor::new(&mut self.header_mut()[2..])
-            .write_u16::<BigEndian>(value)
-            .unwrap();
-        self
+    pub fn set_destination_port(&mut self, value: u16) {
+        self.buffer.as_mut()[2..4].copy_from_slice(&value.to_be_bytes())
     }
-    fn set_checknum(&mut self, value: u16) {
-        Cursor::new(&mut self.header_mut()[6..])
-            .write_u16::<BigEndian>(value)
-            .unwrap();
+    fn set_checksum(&mut self, value: u16) {
+        self.buffer.as_mut()[6..8].copy_from_slice(&value.to_be_bytes())
     }
-    pub fn update_checknum(&mut self) {
+    pub fn update_checksum(&mut self) {
         //先写0
-        self.set_checknum(0);
-        self.set_checknum(self.cal_checksum());
+        self.set_checksum(0);
+        self.set_checksum(self.cal_checksum());
     }
 }
 

switch/proto/message.proto

@@ -4,6 +4,7 @@ message RegistrationRequest{
   string device_id = 2;
   string name = 3;
   bool is_fast = 4;
+  string version = 5;
 }
 
 message RegistrationResponse{

switch/rust-tun/src/lib.rs

@@ -11,7 +11,7 @@
 //   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 //
 //  0. You just DO WHAT THE FUCK YOU WANT TO.
-
+#![cfg(unix)]
 mod error;
 pub use crate::error::*;
 

switch/rust-tun/src/platform/posix/split.rs

@@ -112,6 +112,11 @@ 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 {

switch/src/channel/channel.rs

@@ -0,0 +1,398 @@
+use std::io;
+use std::net::{Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicI64, AtomicUsize, Ordering};
+use crossbeam_skiplist::SkipMap;
+use dashmap::DashMap;
+use tokio::net::UdpSocket;
+use tokio::sync::Notify;
+use tokio::sync::watch::{channel, Receiver, Sender};
+use crate::channel::{Route, RouteKey, Status};
+use crate::channel::punch::NatType;
+use crate::handle::recv_handler::ChannelDataHandler;
+
+#[derive(Clone)]
+pub struct Context {
+    pub(crate) count: Arc<AtomicUsize>,
+    pub(crate) main_channel: Arc<UdpSocket>,
+    pub(crate) route_table: Arc<DashMap<Ipv4Addr, Vec<Route>>>,
+    pub(crate) route_table_time: Arc<SkipMap<(RouteKey, Ipv4Addr), AtomicI64>>,
+    pub(crate) status_receiver: Receiver<Status>,
+    pub(crate) status_sender: Arc<Sender<Status>>,
+    pub(crate) udp_map: Arc<SkipMap<usize, Arc<UdpSocket>>>,
+    pub(crate) channel_num: usize,
+    pub(crate) notify: Arc<Notify>,
+}
+
+impl Context {
+    pub fn new(main_channel: Arc<UdpSocket>, _channel_num: usize) -> Self {
+        //当前版本只支持一个通道
+        let channel_num = 1;
+        let (status_sender, status_receiver) = channel(Status::Cone);
+        let status_sender = Arc::new(status_sender);
+        Self {
+            count: Arc::new(AtomicUsize::new(0)),
+            main_channel,
+            route_table: Arc::new(DashMap::with_capacity(16)),
+            route_table_time: Arc::new(SkipMap::new()),
+            status_receiver,
+            status_sender,
+            udp_map: Arc::new(SkipMap::new()),
+            channel_num,
+            notify: Arc::new(Notify::new()),
+        }
+    }
+}
+
+impl Context {
+    pub fn is_close(&self) -> bool {
+        *self.status_receiver.borrow() == Status::Close
+    }
+    pub fn is_cone(&self) -> bool {
+        *self.status_receiver.borrow() == Status::Cone
+    }
+    pub fn close(&self) {
+        let _ = self.status_sender.send(Status::Close);
+    }
+    pub fn switch(&self, nat_type: NatType) {
+        match nat_type {
+            NatType::Symmetric => {
+                self.switch_to_symmetric();
+            }
+            NatType::Cone => {
+                self.switch_to_cone();
+            }
+        }
+    }
+    pub fn switch_to_cone(&self) {
+        let _ = self.status_sender.send(Status::Cone);
+    }
+    pub fn switch_to_symmetric(&self) {
+        let _ = self.status_sender.send(Status::Symmetric);
+    }
+    pub fn main_local_port(&self) -> io::Result<u16> {
+        self.main_channel.local_addr().map(|k| k.port())
+    }
+    pub async fn send_main(&self, buf: &[u8], addr: SocketAddr) -> io::Result<usize> {
+        self.main_channel.send_to(buf, addr).await
+    }
+
+    pub(crate) async fn send_all(&self, buf: &[u8], addr: SocketAddr) -> io::Result<()> {
+        for udp in self.udp_map.iter() {
+            udp.value().send_to(buf, addr).await?;
+        }
+        Ok(())
+    }
+    pub fn try_send_main(&self, buf: &[u8], addr: SocketAddr) -> io::Result<usize> {
+        self.main_channel.try_send_to(buf, addr)
+    }
+    pub async fn send_by_id(&self, buf: &[u8], id: &Ipv4Addr) -> io::Result<usize> {
+        if let Some(v) = self.route_table.get(id) {
+            let route = match v.len() {
+                0 => {
+                    return Err(io::Error::new(io::ErrorKind::NotFound, "route not found"));
+                }
+                1 => &v[0],
+                len => &v[self.count.fetch_add(1, Ordering::Relaxed) % len]
+            };
+            if let Some(udp) = self.udp_map.get(&route.index) {
+                return udp.value().send_to(buf, route.addr).await;
+            }
+        }
+        Err(io::Error::new(io::ErrorKind::NotFound, "route not found"))
+    }
+    pub fn try_send_by_id(&self, buf: &[u8], id: &Ipv4Addr) -> io::Result<usize> {
+        if let Some(v) = self.route_table.get(id) {
+            if v.is_empty() {
+                return Err(io::Error::new(io::ErrorKind::NotFound, "route not found"));
+            }
+            let route = &v[self.count.fetch_add(1, Ordering::Relaxed) % v.len()];
+            if let Some(udp) = self.udp_map.get(&route.index) {
+                return udp.value().try_send_to(buf, route.addr);
+            }
+        }
+        Err(io::Error::new(io::ErrorKind::NotFound, "route not found"))
+    }
+    pub async fn send_by_key(&self, buf: &[u8], route_key: &RouteKey) -> io::Result<usize> {
+        if let Some(udp) = self.udp_map.get(&route_key.index) {
+            return udp.value().send_to(buf, route_key.addr).await;
+        }
+        Err(io::Error::new(io::ErrorKind::NotFound, "route not found"))
+    }
+    pub fn try_send_by_key(&self, buf: &[u8], route_key: &RouteKey) -> io::Result<usize> {
+        if let Some(udp) = self.udp_map.get(&route_key.index) {
+            return udp.value().try_send_to(buf, route_key.addr);
+        }
+        Err(io::Error::new(io::ErrorKind::NotFound, "route not found"))
+    }
+    pub fn add_route_if_absent(&self, id: Ipv4Addr, route: Route) {
+        self.add_route_(id, route, true)
+    }
+    pub fn add_route(&self, id: Ipv4Addr, route: Route) {
+        self.add_route_(id, route, false)
+    }
+    fn add_route_(&self, id: Ipv4Addr, route: Route, only_if_absent: bool) {
+        let key = route.route_key();
+        let mut ref_mut = self.route_table.entry(id.clone()).or_insert(Vec::with_capacity(4));
+        let mut exist = false;
+        for x in ref_mut.iter_mut() {
+            if x.metric < route.metric {
+                //不能比当前的路径更长
+                return;
+            }
+            if x.route_key() == key {
+                if only_if_absent {
+                    return;
+                }
+                x.metric = route.metric;
+                x.rt = route.rt;
+                exist = true;
+                break;
+            }
+        }
+        if !exist {
+            if route.metric == 1 {
+                //添加了直连的则排除非直连的
+                ref_mut.retain(|k| k.metric == 1);
+            }
+            ref_mut.push(route);
+            let max_len = self.channel_num;
+            if ref_mut.len() > max_len {
+                ref_mut.sort_by_key(|k| k.sort_key());
+                ref_mut.truncate(max_len);
+            }
+        }
+        self.route_table_time.insert((key, id), AtomicI64::new(chrono::Local::now().timestamp_millis()));
+        self.notify.notify_one();
+    }
+    pub fn route(&self, id: &Ipv4Addr) -> Option<Vec<Route>> {
+        if let Some(v) = self.route_table.get(id) {
+            Some(v.value().clone())
+        } else {
+            None
+        }
+    }
+    pub fn route_one(&self, id: &Ipv4Addr) -> Option<Route> {
+        if let Some(v) = self.route_table.get(id) {
+            v.value().iter().max_by_key(|k| k.sort_key()).map(|k| *k)
+        } else {
+            None
+        }
+    }
+    pub fn route_to_id(&self, route_key: &RouteKey) -> Option<Ipv4Addr> {
+        for x in self.route_table_time.iter() {
+            if &x.key().0 == route_key {
+                return Some(x.key().1);
+            }
+        }
+        None
+    }
+    pub fn need_punch(&self, id: &Ipv4Addr) -> bool {
+        if let Some(v) = self.route_table.get(id) {
+            if v.iter().filter(|k| k.is_p2p()).count() >= self.channel_num {
+                return false;
+            }
+        }
+        true
+    }
+    pub fn route_table(&self) -> Vec<(Ipv4Addr, Vec<Route>)> {
+        self.route_table.iter().map(|k| (k.key().clone(), k.value().clone())).collect()
+    }
+    pub fn route_table_one(&self) -> Vec<(Ipv4Addr, Route)> {
+        let mut v = Vec::with_capacity(8);
+        for x in self.route_table.iter() {
+            if let Some(route) = x.value().iter().max_by_key(|k| k.sort_key()) {
+                v.push((*x.key(), *route));
+            }
+        }
+        v
+    }
+    pub fn direct_route_table_one(&self) -> Vec<(Ipv4Addr, Route)> {
+        let mut v = Vec::with_capacity(8);
+        for x in self.route_table.iter() {
+            if let Some(route) = x.value().iter().max_by_key(|k| k.sort_key()) {
+                if route.metric == 1 {
+                    v.push((*x.key(), *route));
+                }
+            }
+        }
+        v
+    }
+    pub fn remove_route_all(&self, id: &Ipv4Addr) {
+        if let Some((_, v)) = self.route_table.remove(id) {
+            for x in v {
+                self.route_table_time.remove(&(x.route_key(), id.clone()));
+            }
+        }
+    }
+    pub fn remove_route(&self, id: &Ipv4Addr, route_key: RouteKey) {
+        if let Some(mut v) = self.route_table.get_mut(id) {
+            v.retain(|x| x.route_key() != route_key);
+            self.route_table_time.remove(&(route_key, id.clone()));
+        }
+    }
+    pub fn update_read_time(&self, id: &Ipv4Addr, route_key: &RouteKey) {
+        if let Some(time) = self.route_table_time.get(&(*route_key, *id)) {
+            time.value().store(chrono::Local::now().timestamp_millis(), Ordering::Relaxed);
+        }
+    }
+}
+
+pub struct Channel {
+    context: Context,
+    handler: ChannelDataHandler,
+}
+
+impl Channel {
+    pub fn new(context: Context,
+               handler: ChannelDataHandler, ) -> Self {
+        Self {
+            context,
+            handler,
+        }
+    }
+}
+
+impl Channel {
+    async fn handle(handler: &mut ChannelDataHandler,
+                    udp: &Arc<UdpSocket>,
+                    context: &Context,
+                    id: usize,
+                    result: io::Result<(usize, SocketAddr)>,
+                    buf: &mut [u8], start: usize) {
+        match result {
+            Ok((len, addr)) => {
+                handler.handle(buf, start, start + len, RouteKey::new(id, addr), &udp, context).await;
+            }
+            Err(e) => {
+                log::error!("{:?}",e)
+            }
+        }
+    }
+    pub async fn start(self,
+                       head_reserve: usize,//头部预留字节
+                       symmetric_channel_num: usize,//对称网络，则再加一组监听，提升打洞成功率
+    ) {
+        let mut context = self.context;
+        let main_channel = context.main_channel.clone();
+        let handler = self.handler.clone();
+        tokio::spawn(Self::start_(context.clone(), handler, main_channel, head_reserve, true));
+        let mut cur_status = Status::Cone;
+        loop {
+            match context.status_receiver.changed().await {
+                Ok(_) => {
+                    match *context.status_receiver.borrow() {
+                        Status::Cone => {
+                            cur_status = Status::Cone;
+                        }
+                        Status::Symmetric => {
+                            if cur_status == Status::Symmetric {
+                                continue;
+                            }
+                            cur_status = Status::Symmetric;
+                            for _ in 0..symmetric_channel_num {
+                                match UdpSocket::bind("0.0.0.0:0").await {
+                                    Ok(udp) => {
+                                        let udp = Arc::new(udp);
+                                        let context = context.clone();
+                                        let handler = self.handler.clone();
+                                        tokio::spawn(Self::start_(context, handler, udp, head_reserve, false));
+                                    }
+                                    Err(e) => {
+                                        log::error!("{}",e);
+                                    }
+                                }
+                            }
+                        }
+                        Status::Close => {
+                            break;
+                        }
+                    }
+                }
+                Err(_) => {
+                    break;
+                }
+            }
+        }
+    }
+    async fn start_(context: Context,
+                    mut handler: ChannelDataHandler,
+                    udp: Arc<UdpSocket>,
+                    head_reserve: usize,
+                    is_core: bool) {
+        let mut status_receiver = context.status_receiver.clone();
+        #[cfg(target_os = "windows")]
+        use std::os::windows::io::AsRawSocket;
+        #[cfg(target_os = "windows")]
+            let id = udp.as_raw_socket() as usize;
+        #[cfg(any(unix))]
+        use std::os::fd::AsRawFd;
+        #[cfg(any(unix))]
+            let id = udp.as_raw_fd() as usize;
+        context.udp_map.insert(id, udp.clone());
+        let mut buf = [0; 65536];
+        loop {
+            tokio::select! {
+                rs=udp.recv_from(&mut buf[head_reserve..])=>{
+                    Self::handle(&mut handler,&udp,&context,id,rs,&mut buf,head_reserve).await;
+                }
+                changed=status_receiver.changed()=>{
+                        match changed {
+                            Ok(_) => {
+                                match *status_receiver.borrow() {
+                                    Status::Cone => {
+                                        if !is_core{
+                                            break;
+                                        }
+                                    }
+                                    Status::Close=>{
+                                        break;
+                                    }
+                                    Status::Symmetric => {}
+                                }
+                            }
+                            Err(_) => {
+                                break;
+                            }
+                        }
+                }
+            }
+        }
+        context.udp_map.remove(&id);
+    }
+}
+
+
+// pub async fn start<H: ChannelDataHandler + Clone>(mut handler: H,
+//                                                   mut status_receiver: Receiver<Status>,
+//                                                   head_reserve: usize,
+//                                                   core_channel_num: usize,
+//                                                   symmetric_channel_num: usize) -> io::Result<()> {
+//     for _ in 0..core_channel_num {
+//         let d = channel(1);
+//     }
+//     let udp = UdpSocket::bind("0.0.0.0:0").await?;
+//     let d = status_receiver.changed().await;
+//     match d {
+//         Ok(_) => {
+//             match *status_receiver.borrow() {
+//                 Status::Cone => {}
+//                 Status::Symmetric => {}
+//                 Status::Close => {}
+//             }
+//         }
+//         Err(_) => {}
+//     }
+//     let mut buf = [0; 65546];
+//     let result = udp.recv_from(&mut buf[head_reserve..]).await;
+//     match result {
+//         Ok((len, addr)) => {}
+//         Err(e) => {}
+//     }
+//     Ok(())
+// }
+//
+// pub struct Channel<H: ChannelDataHandler + Clone> {
+//     handler: H,
+//
+// }

switch/src/channel/idle.rs

@@ -0,0 +1,62 @@
+use std::io;
+use std::io::{Error, ErrorKind};
+use std::net::Ipv4Addr;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+use crate::channel::channel::Context;
+use crate::channel::RouteKey;
+
+
+pub struct Idle {
+    read_idle: i64,
+    context: Context,
+}
+
+impl Idle {
+    pub fn new(read_idle: i64,
+               context: Context, ) -> Self {
+        Self {
+            read_idle,
+            context,
+        }
+    }
+}
+
+impl Idle {
+    /// 获取空闲路由
+    pub async fn next_idle(&self) -> io::Result<(Ipv4Addr, RouteKey)> {
+        loop {
+            let now = chrono::Local::now().timestamp_millis();
+            let last_read_idle = now - self.read_idle;
+            let mut min = i64::MAX;
+            for entry in self.context.route_table_time.iter() {
+                let mut is_read_idle = false;
+                if self.read_idle > 0 {
+                    let last_read = entry.value().load(Ordering::Relaxed);
+                    if last_read < last_read_idle {
+                        is_read_idle = true;
+                    } else {
+                        if min > last_read {
+                            min = last_read;
+                        }
+                    }
+                }
+                if is_read_idle {
+                    return Ok((entry.key().1.clone(), entry.key().0.clone()));
+                }
+            }
+            if self.context.route_table_time.is_empty() {
+                self.context.notify.notified().await;
+            } else {
+                let sleep_time = chrono::Local::now().timestamp_millis() - min;
+                if sleep_time > 0 {
+                    tokio::time::sleep(Duration::from_millis(sleep_time as u64)).await;
+                    // let _ =  tokio::time::timeout(Duration::from_millis(sleep_time as u64),  self.context.notify.notified()).await;
+                }
+            }
+            if self.context.is_close() {
+                return Err(Error::new(ErrorKind::Other, "closed"));
+            }
+        }
+    }
+}

switch/src/channel/mod.rs

@@ -0,0 +1,78 @@
+use std::net::SocketAddr;
+
+pub mod channel;
+pub mod punch;
+pub mod idle;
+pub mod sender;
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum Status {
+    Cone,
+    Symmetric,
+    Close,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct Route {
+    index: usize,
+    pub addr: SocketAddr,
+    pub metric: u8,
+    pub rt: i64,
+}
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]
+pub struct RouteSortKey {
+    pub metric: u8,
+    pub rt: i64,
+}
+
+impl Route {
+    pub fn new(index: usize,
+               addr: SocketAddr, metric: u8, rt: i64, ) -> Self {
+        Self {
+            index,
+            addr,
+            metric,
+            rt,
+        }
+    }
+    pub fn from(route_key: RouteKey, metric: u8, rt: i64) -> Self {
+        Self {
+            index: route_key.index,
+            addr: route_key.addr,
+            metric,
+            rt,
+        }
+    }
+    pub fn route_key(&self) -> RouteKey {
+        RouteKey {
+            index: self.index,
+            addr: self.addr,
+        }
+    }
+    pub fn sort_key(&self) -> RouteSortKey {
+        RouteSortKey {
+            metric: self.metric,
+            rt: self.rt,
+        }
+    }
+    pub fn is_p2p(&self) -> bool {
+        self.metric == 1
+    }
+}
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]
+pub struct RouteKey {
+    index: usize,
+    pub addr: SocketAddr,
+}
+
+impl RouteKey {
+    pub(crate) fn new(index: usize,
+                      addr: SocketAddr, ) -> Self {
+        Self {
+            index,
+            addr,
+        }
+    }
+}

switch/src/channel/punch.rs

@@ -0,0 +1,152 @@
+use std::collections::HashMap;
+use std::io;
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+use std::time::Duration;
+
+use rand::prelude::SliceRandom;
+
+use crate::channel::channel::Context;
+
+#[derive(Clone, Debug)]
+pub struct NatInfo {
+    pub public_ips: Vec<Ipv4Addr>,
+    pub public_port: u16,
+    pub public_port_range: u16,
+    pub local_ip: Ipv4Addr,
+    pub local_port: u16,
+    pub nat_type: NatType,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub enum NatType {
+    Symmetric,
+    Cone,
+}
+
+impl NatInfo {
+    pub fn new(public_ips: Vec<Ipv4Addr>,
+               public_port: u16,
+               public_port_range: u16,
+               local_ip: Ipv4Addr,
+               local_port: u16,
+               nat_type: NatType, ) -> Self {
+        Self {
+            public_ips,
+            public_port,
+            public_port_range,
+            local_ip,
+            local_port,
+            nat_type,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Punch {
+    context: Context,
+    port_vec: Vec<u16>,
+    port_index: HashMap<Ipv4Addr, usize>,
+}
+
+impl Punch {
+    pub fn new(context: Context) -> Self {
+        let mut port_vec: Vec<u16> = (1..65535).collect();
+        port_vec.push(65535);
+        let mut rng = rand::thread_rng();
+        port_vec.shuffle(&mut rng);
+        Punch {
+            context,
+            port_vec,
+            port_index: HashMap::new(),
+        }
+    }
+}
+
+impl Punch {
+    pub async fn punch(&mut self, buf: &[u8], id: Ipv4Addr, nat_info: NatInfo) -> io::Result<()> {
+        if !self.context.need_punch(&id) {
+            return Ok(());
+        }
+        if !nat_info.local_ip.is_unspecified() || nat_info.local_port != 0 {
+            let _ = self.context.send_main(buf, SocketAddr::V4(SocketAddrV4::new(nat_info.local_ip, nat_info.local_port))).await;
+        }
+        match nat_info.nat_type {
+            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%了
+                // 前提 自己是锥形网络，否则猜中了也通信不了
+
+                //预测范围内最多发送max_k1个包
+                let max_k1 = 60;
+                //全局最多发送max_k2个包
+                let max_k2 = 800;
+                if nat_info.public_port_range < max_k1 * 3 {
+                    //端口变化不大时，在预测的范围内随机发送
+                    let min_port = if nat_info.public_port > nat_info.public_port_range {
+                        nat_info.public_port - nat_info.public_port_range
+                    } else {
+                        1
+                    };
+                    let (max_port, overflow) = nat_info.public_port.overflowing_add(nat_info.public_port_range);
+                    let max_port = if overflow {
+                        65535
+                    } else {
+                        max_port
+                    };
+                    let k = if max_port - min_port + 1 > max_k1 {
+                        max_k1 as usize
+                    } else {
+                        (max_port - min_port + 1) as usize
+                    };
+                    let mut nums: Vec<u16> = (min_port..max_port).collect();
+                    nums.push(max_port);
+                    {
+                        let mut rng = rand::thread_rng();
+                        nums.shuffle(&mut rng);
+                    }
+                    self.punch_symmetric(&nums[..k], buf, &nat_info.public_ips, max_k1 as usize).await?;
+                }
+                let start = *self.port_index.entry(id.clone()).or_insert(0);
+                let mut end = start + max_k2;
+                let mut index = end;
+                if end >= self.port_vec.len() {
+                    end = self.port_vec.len();
+                    index = 0
+                }
+                self.punch_symmetric(&self.port_vec[start..end], buf, &nat_info.public_ips, max_k2).await?;
+                self.port_index.insert(id, index);
+            }
+            NatType::Cone => {
+                let is_cone = self.context.is_cone();
+                for ip in nat_info.public_ips {
+                    let addr = SocketAddr::V4(SocketAddrV4::new(ip, nat_info.public_port));
+                    if is_cone {
+                        self.context.send_main(buf, addr).await?;
+                    } else {
+                        //只有一方是对称，则对称方要使用全部端口发送数据，符合上述计算的概率
+                        self.context.send_all(buf, addr).await?;
+                    }
+                    tokio::time::sleep(Duration::from_millis(2)).await;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    async fn punch_symmetric(&self, ports: &[u16], buf: &[u8], ips: &Vec<Ipv4Addr>, max: usize) -> io::Result<()> {
+        let mut count = 0;
+        for port in ports {
+            for pub_ip in ips {
+                count += 1;
+                if count == max {
+                    return Ok(());
+                }
+                let addr = SocketAddr::V4(SocketAddrV4::new(*pub_ip, *port));
+                self.context.send_main(buf, addr).await?;
+                tokio::time::sleep(Duration::from_millis(2)).await;
+            }
+        }
+        Ok(())
+    }
+}

switch/src/channel/sender.rs

@@ -0,0 +1,23 @@
+use std::ops::Deref;
+use crate::channel::channel::Context;
+
+#[derive(Clone)]
+pub struct ChannelSender {
+    context: Context,
+}
+
+impl ChannelSender {
+    pub fn new(context: Context) -> Self {
+        Self {
+            context,
+        }
+    }
+}
+
+impl Deref for ChannelSender {
+    type Target = Context;
+
+    fn deref(&self) -> &Self::Target {
+        &self.context
+    }
+}

switch/src/core/mod.rs

@@ -1,22 +1,35 @@
-use std::io;
+use std::{io, thread};
 use std::net::{Ipv4Addr, SocketAddr};
 use std::sync::Arc;
+use aes_gcm::{Aes256Gcm, Key, KeyInit};
+
 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 tokio::net::UdpSocket;
+use tokio::sync::mpsc::channel;
+
+
+use crate::channel::channel::{Channel, Context};
+use crate::channel::idle::Idle;
+use crate::channel::punch::{NatInfo, Punch};
+use crate::channel::{Route, RouteKey};
+use crate::channel::sender::ChannelSender;
+
+use crate::external_route::ExternalRoute;
+use crate::handle::{ConnectStatus, CurrentDeviceInfo, heartbeat_handler, PeerDeviceInfo, punch_handler, registration_handler};
+use crate::handle::recv_handler::ChannelDataHandler;
+use crate::handle::tun_tap::{tap_handler, tun_handler};
+use crate::igmp_server::IgmpServer;
 use crate::nat::NatTest;
-use crate::tun_device;
-use crate::tun_device::TunReader;
+use crate::tun_tap_device;
+use crate::tun_tap_device::DeviceWriter;
 
 pub struct Switch {
     name: String,
     current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-    tun_reader: TunReader,
-    nat_channel: Channel<Ipv4Addr>,
+    context: Context,
+    device_writer: DeviceWriter,
     /// 0. 机器纪元，每一次上线或者下线都会增1，用于感知网络中机器变化
     /// 服务端和客户端的不一致，则服务端会推送新的设备列表
     /// 1. 网络中的虚拟ip列表
@@ -27,47 +40,97 @@ pub struct Switch {
 }
 
 impl Switch {
-    pub fn start(config: Config) -> crate::Result<Switch> {
-        let (mut channel, punch, idle) = Boot::new::<Ipv4Addr>(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()));
+    pub async fn start(config: Config) -> crate::Result<Switch> {
+        log::info!("config:{:?}",config);
+        let cipher = if let Some(key) = &config.key {
+            let key: &Key<Aes256Gcm> = key.into();
+            Some(Aes256Gcm::new(&key))
+        } else {
+            None
+        };
+        let main_channel = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
+        let response = registration_handler::registration(&main_channel, config.server_address, config.token.clone(), config.device_id.clone(), config.name.clone()).await?;
+        let (cone_sender, cone_receiver) = channel(3);
+        let (symmetric_sender, symmetric_receiver) = channel(2);
+        let context = Context::new(main_channel, 1);
+        let punch = Punch::new(context.clone());
+        let idle = Idle::new(16000, context.clone());
+        let channel_sender = ChannelSender::new(context.clone());
+
+        let register = Arc::new(registration_handler::Register::new(channel_sender.clone(), config.server_address, config.token.clone(), config.device_id.clone(), config.name.clone()));
         let device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>> = Arc::new(Mutex::new((0, Vec::new())));
         let peer_nat_info_map: Arc<SkipMap<Ipv4Addr, NatInfo>> = 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();
+        let local_port = context.main_local_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)?;
+        let in_ips = config.in_ips.iter().map(|(dest, mask, _)| { (Ipv4Addr::from(*dest & *mask), Ipv4Addr::from(*mask)) }).collect::<Vec<(Ipv4Addr, Ipv4Addr)>>();
 
-        // 定时心跳
-        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 out_ips = config.out_ips.iter().map(|(_, _, ip)| *ip).collect::<Vec<Ipv4Addr>>();
+        let out_external_route = ExternalRoute::new(config.out_ips);
+        let in_external_route = ExternalRoute::new(config.in_ips);
+        let current_device = Arc::new(AtomicCell::new(CurrentDeviceInfo::new(virtual_ip, virtual_gateway, virtual_netmask, config.server_address)));
+        let ip_proxy_map = crate::ip_proxy::init_proxy(channel_sender.clone(), out_ips, current_device.clone()).await?;
+        let (device_writer, igmp_server) = if config.tap {
+            #[cfg(windows)]
+            {
+                //删除switch的tun网卡避免ip冲突，因为非正常退出会保留网卡
+                tun_tap_device::delete_device(tun_tap_device::DeviceType::Tap);
+            }
+            let (tap_writer, tap_reader) = tun_tap_device::create_device(tun_tap_device::DeviceType::Tap, virtual_ip, virtual_netmask, virtual_gateway, in_ips)?;
+            let igmp_server = IgmpServer::new(tap_writer.clone());
+            //tap数据处理
+            tap_handler::start(channel_sender.clone(), tap_reader.clone(), tap_writer.clone(),
+                               igmp_server.clone(), current_device.clone(), in_external_route, ip_proxy_map.clone(), cipher.clone());
+            (tap_writer, igmp_server)
+        } else {
+            #[cfg(windows)]
+            {
+                //删除switch的tap网卡避免ip冲突，非正常退出会保留网卡
+                tun_tap_device::delete_device(tun_tap_device::DeviceType::Tap);
+            }
+            // tun通道
+            let (tun_writer, tun_reader) = tun_tap_device::create_device(tun_tap_device::DeviceType::Tun, virtual_ip, virtual_netmask, virtual_gateway, in_ips)?;
+            let igmp_server = IgmpServer::new(tun_writer.clone());
+            //tun数据接收处理
+            tun_handler::start(channel_sender.clone(), tun_reader.clone(), tun_writer.clone(),
+                               igmp_server.clone(), current_device.clone(), in_external_route, ip_proxy_map.clone(), cipher.clone());
+            (tun_writer, igmp_server)
+        };
         //外部数据接收处理
-        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()?);
-        }
+        let channel_recv_handler = ChannelDataHandler::new(current_device.clone(), device_list.clone(),
+                                                           register.clone(), nat_test.clone(), igmp_server,
+                                                           device_writer.clone(), connect_status.clone(),
+                                                           peer_nat_info_map.clone(), ip_proxy_map, out_external_route,
+                                                           cone_sender, symmetric_sender, cipher);
+        let channel = Channel::new(context.clone(), channel_recv_handler);
+        thread::spawn(move || {
+            tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build().unwrap()
+                .block_on(channel.start(14, 60));
+        });
+        context.switch(nat_test.nat_info().nat_type);
+        // 定时心跳
+        heartbeat_handler::start_heartbeat(channel_sender.clone(), device_list.clone(), current_device.clone()).await;
+        // 空闲检查
+        heartbeat_handler::start_idle(idle, channel_sender.clone()).await;
+        // 打洞处理
+        punch_handler::start(cone_receiver, punch.clone(), current_device.clone()).await;
+        punch_handler::start(symmetric_receiver, punch, current_device.clone()).await;
+        punch_handler::start_punch(nat_test.clone(), device_list.clone(), channel_sender.clone(), current_device.clone()).await;
+
+        log::info!("switch启动成功");
         Ok(Switch {
             name: config.name,
             current_device,
-            tun_reader,
-            nat_channel: channel,
+            context,
+            device_writer,
             nat_test,
             device_list,
             connect_status,
@@ -99,42 +162,61 @@ impl Switch {
         device_list
     }
     pub fn route(&self, ip: &Ipv4Addr) -> Option<Route> {
-        self.nat_channel.route(ip)
+        self.context.route_one(ip)
     }
     pub fn route_key(&self, route_key: &RouteKey) -> Option<Ipv4Addr> {
-        self.nat_channel.route_to_id(route_key)
+        self.context.route_to_id(route_key)
     }
     pub fn route_table(&self) -> Vec<(Ipv4Addr, Route)> {
-        self.nat_channel.route_table()
+        self.context.route_table_one()
     }
     pub fn stop(&self) -> io::Result<()> {
-        self.tun_reader.close();
-        self.nat_channel.close()?;
+        self.context.close();
+        self.device_writer.close()?;
         Ok(())
     }
 }
 
 #[derive(Clone, Debug)]
 pub struct Config {
+    pub tap: bool,
     pub token: String,
     pub device_id: String,
     pub name: String,
     pub server_address: SocketAddr,
     pub nat_test_server: Vec<SocketAddr>,
+    pub in_ips: Vec<(u32, u32, Ipv4Addr)>,
+    pub out_ips: Vec<(u32, u32, Ipv4Addr)>,
+    pub key: Option<[u8; 32]>,
 }
 
+use sha2::Digest;
+
 impl Config {
-    pub fn new(token: String,
+    pub fn new(tap: bool, token: String,
                device_id: String,
                name: String,
                server_address: SocketAddr,
-               nat_test_server: Vec<SocketAddr>, ) -> Self {
+               nat_test_server: Vec<SocketAddr>,
+               in_ips: Vec<(u32, u32, Ipv4Addr)>, out_ips: Vec<(u32, u32, Ipv4Addr)>, password: Option<String>, ) -> Self {
+        let key = if let Some(password) = password {
+            let mut hasher = sha2::Sha256::new();
+            hasher.update(password.as_bytes());
+            let key: [u8; 32] = hasher.finalize().into();
+            Some(key)
+        } else {
+            None
+        };
         Self {
+            tap,
             token,
             device_id,
             name,
             server_address,
             nat_test_server,
+            in_ips,
+            out_ips,
+            key,
         }
     }
 }

switch/src/error/mod.rs

@@ -5,8 +5,6 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum Error {
-    #[error("packet error")]
-    PacketError(#[from] packet::error::Error),
     #[error("Io error")]
     Io(#[from] io::Error),
     #[error("Channel error")]

switch/src/external_route/mod.rs

@@ -0,0 +1,25 @@
+use std::net::Ipv4Addr;
+
+// 目标ip，子网掩码，网关
+
+#[derive(Clone)]
+pub struct ExternalRoute {
+    route_table: Vec<(u32, u32, Ipv4Addr)>,
+}
+
+impl ExternalRoute {
+    pub fn new(route_table: Vec<(u32, u32, Ipv4Addr)>) -> Self {
+        Self {
+            route_table
+        }
+    }
+    pub fn route(&self, ip: &Ipv4Addr) -> Option<Ipv4Addr> {
+        let ip = u32::from_be_bytes(ip.octets());
+        for (dest, mask, gateway) in &self.route_table {
+            if *mask & ip == *mask & *dest {
+                return Some(*gateway);
+            }
+        }
+        None
+    }
+}

switch/src/handle/heartbeat_handler.rs

@@ -1,73 +1,105 @@
-use std::{io, thread};
 use std::net::Ipv4Addr;
 use std::sync::Arc;
 use std::time::Duration;
+use std::io;
 
 use chrono::Local;
 use crossbeam::atomic::AtomicCell;
 use parking_lot::Mutex;
 use rand::prelude::SliceRandom;
+use crate::channel::idle::Idle;
+use crate::channel::Route;
+use crate::channel::sender::ChannelSender;
 
-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};
 
-pub fn start_idle(idle: Idle<Ipv4Addr>, sender: Sender<Ipv4Addr>) {
-    thread::spawn(move || {
-        if let Err(e) = start_idle_(idle, sender) {
-            log::info!("空闲检测线程停止:{:?}",e);
+pub async fn start_idle(idle: Idle, sender: ChannelSender) {
+    tokio::spawn(async move {
+        match start_idle_(idle, sender).await {
+            Ok(_) => {}
+            Err(e) => {
+                log::warn!("空闲检测任务停止:{:?}", e);
+            }
         }
     });
 }
 
-fn start_idle_(idle: Idle<Ipv4Addr>, sender: Sender<Ipv4Addr>) -> io::Result<()> {
+async fn start_idle_(idle: Idle, sender: ChannelSender) -> io::Result<()> {
     loop {
-        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);
-        }
+        let (peer_ip, route) = idle.next_idle().await?;
+        log::info!(
+            "peer_ip:{:?},route:{:?}",
+            peer_ip,
+            route
+        );
+        sender.remove_route(&peer_ip, route);
     }
 }
 
-pub fn start_heartbeat(sender: Sender<Ipv4Addr>, device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) {
-    thread::spawn(move || {
-        if let Err(e) = start_heartbeat_(sender, device_list, current_device) {
-            log::info!("空闲检测线程停止:{:?}",e);
+pub async fn start_heartbeat(
+    sender: ChannelSender,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+) {
+    tokio::spawn(async move {
+        if let Err(e) = start_heartbeat_(sender, device_list, current_device).await {
+            log::warn!("心跳任务停止:{:?}", e);
         }
     });
 }
 
-fn start_heartbeat_(sender: Sender<Ipv4Addr>, device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) -> io::Result<()> {
+fn set_now_time(packet: &mut NetPacket<[u8; 16]>) -> io::Result<()> {
+    let current_time = Local::now().timestamp_millis() as u16;
+    let mut ping = PingPacket::new(packet.payload_mut())?;
+    ping.set_time(current_time);
+    Ok(())
+}
+
+async fn start_heartbeat_(
+    sender: ChannelSender,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+) -> 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);
+    //只寻找两跳以内能到的目标
+    net_packet.first_set_ttl(2);
     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);
         }
+        set_now_time(&mut net_packet)?;
+        net_packet.set_destination(current_device.virtual_gateway());
+        if let Err(e) = sender.send_main(net_packet.buffer(), current_device.connect_server).await
+        {
+            log::warn!(
+                    "connect_server:{:?},e:{:?}",
+                    current_device.connect_server,
+                    e
+                );
+        }
         if count < 7 || count % 7 == 0 {
-            let mut route_list: Option<Vec<(Ipv4Addr, Route)>> = None;
-            let peer_list = device_list.lock().1.clone();
+            let mut route_list: Option<Vec<(Ipv4Addr, Vec<Route>)>> = None;
+            let peer_list = {device_list.lock().1.clone()};
             for peer in peer_list {
-                net_packet.first_set_ttl(MAX_TTL);
+                set_now_time(&mut net_packet)?;
                 net_packet.set_destination(peer.virtual_ip);
-                if sender.send_to_id(net_packet.buffer(), &peer.virtual_ip).is_err() {
+                if sender
+                    .send_by_id(net_packet.buffer(), &peer.virtual_ip).await
+                    .is_err()
+                {
                     //没有路由则发送到网关
-                    let _ = sender.send_to_addr(net_packet.buffer(), current_device.connect_server);
+                    let _ = sender.try_send_main(net_packet.buffer(), current_device.connect_server);
                     //再随机发送到其他地址，看有没有客户端符合转发条件
                     let route_list = route_list.get_or_insert_with(|| {
                         let mut l = sender.route_table();
@@ -75,34 +107,37 @@ fn start_heartbeat_(sender: Sender<Ipv4Addr>, device_list: Arc<Mutex<(u16, Vec<P
                         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;
+                    'a: for (peer_ip, route_list) in route_list.iter() {
+                        for route in route_list {
+                            if peer_ip != &peer.virtual_ip && route.metric == 1 {
+                                set_now_time(&mut net_packet)?;
+                                let _ = sender.try_send_by_key(net_packet.buffer(), &route.route_key());
+                                num += 1;
+                                break;
+                            }
+                            if num >= 3 {
+                                break 'a;
+                            }
                         }
                     }
                 }
-                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);
+                tokio::time::sleep(Duration::from_millis(1)).await;
             }
+
         } else {
-            for (peer_ip, route) in sender.route_table().iter() {
+            for (peer_ip, route_list) in sender.route_table().iter() {
+                set_now_time(&mut net_packet)?;
                 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);
+                for route in route_list {
+                    if let Err(e) = sender.send_by_key(net_packet.buffer(), &route.route_key()).await {
+                        log::warn!("peer_ip:{:?},route:{:?},e:{:?}", peer_ip, route, e);
+                    }
+                    tokio::time::sleep(Duration::from_millis(2)).await;
                 }
-                thread::sleep(Duration::from_millis(1));
             }
         }
 
         count += 1;
-        thread::sleep(Duration::from_millis(5000));
+        tokio::time::sleep(Duration::from_millis(5000)).await;
     }
-}
+}

switch/src/handle/mod.rs

@@ -2,9 +2,9 @@ use std::net::{Ipv4Addr, SocketAddr};
 
 pub mod heartbeat_handler;
 pub mod punch_handler;
-pub mod registration_handler;
-pub mod tun_handler;
 pub mod recv_handler;
+pub mod registration_handler;
+pub mod tun_tap;
 
 /// 是否在一个网段
 fn check_dest(dest: Ipv4Addr, virtual_netmask: Ipv4Addr, virtual_network: Ipv4Addr) -> bool {
@@ -70,6 +70,7 @@ pub struct CurrentDeviceInfo {
     pub broadcast_address: Ipv4Addr,
     //链接的服务器地址
     pub connect_server: SocketAddr,
+
 }
 
 impl CurrentDeviceInfo {
@@ -103,7 +104,3 @@ impl CurrentDeviceInfo {
         self.virtual_gateway
     }
 }
-
-
-
-

switch/src/handle/punch_handler.rs

@@ -1,70 +1,72 @@
-use std::{io, thread};
-use std::net::{IpAddr, Ipv4Addr};
-use std::sync::Arc;
-use std::time::Duration;
+use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
+use crate::nat::NatTest;
+use crate::proto::message::{PunchInfo, PunchNatType};
+use crate::protocol::{control_packet, other_turn_packet, NetPacket, Protocol, Version, MAX_TTL};
 use crossbeam::atomic::AtomicCell;
 use parking_lot::Mutex;
 use protobuf::Message;
 use rand::prelude::SliceRandom;
-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 std::net::Ipv4Addr;
+use std::sync::Arc;
+use std::time::Duration;
+use std::io;
+use tokio::sync::mpsc::Receiver;
+use crate::channel::punch::{NatInfo, Punch};
+use crate::channel::sender::ChannelSender;
 
-pub fn start_cone(punch: Punch<Ipv4Addr>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) {
-    thread::spawn(move || {
-        if let Err(e) = start_(true, punch, current_device) {
-            log::warn!("锥形网络打洞处理线程停止 {:?}",e);
-        }
+pub async fn start(receiver: Receiver<(Ipv4Addr, NatInfo)>, punch: Punch, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) {
+    tokio::spawn(async move {
+        start0(receiver, punch, current_device).await;
     });
 }
 
-pub fn start_symmetric(punch: Punch<Ipv4Addr>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) {
-    thread::spawn(move || {
-        if let Err(e) = start_(false, punch, current_device) {
-            log::warn!("对称网络打洞处理线程停止 {:?}",e);
+pub async fn start0(mut receiver: Receiver<(Ipv4Addr, NatInfo)>, mut punch: Punch, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) {
+    while let Some((peer_ip, nat_info)) = receiver.recv().await {
+        if let Err(e) = start_(&mut punch, &current_device, peer_ip, nat_info).await {
+            log::warn!("网络打洞异常 {:?}", e);
         }
-    });
+    }
 }
 
-fn start_(is_cone: bool, mut punch: Punch<Ipv4Addr>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) -> io::Result<()> {
+async fn start_(
+    punch: &mut Punch,
+    current_device: &Arc<AtomicCell<CurrentDeviceInfo>>,
+    peer_ip: Ipv4Addr,
+    nat_info: NatInfo,
+) -> 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;
-            }
-        }
-        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);
-        }
-    }
+    packet.set_source(current_device.load().virtual_ip());
+    packet.set_destination(peer_ip);
+    log::info!("发起打洞，目标:{:?},{:?}", peer_ip, nat_info);
+
+    punch.punch(packet.buffer(), peer_ip, nat_info).await
 }
 
-pub fn start_punch(nat_test: NatTest, device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>, sender: Sender<Ipv4Addr>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) {
-    thread::spawn(move || {
-        if let Err(e) = start_punch_(nat_test, device_list, sender, current_device) {
-            log::warn!("对称网络打洞处理线程停止 {:?}",e);
+pub async fn start_punch(
+    nat_test: NatTest,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    sender: ChannelSender,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+) {
+    tokio::spawn(async move {
+        if let Err(e) = start_punch_(nat_test, device_list, sender, current_device).await {
+            log::warn!("打洞处理任务停止 {:?}", e);
         }
     });
 }
 
-fn start_punch_(nat_test: NatTest, device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>, sender: Sender<Ipv4Addr>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) -> crate::Result<()> {
+async fn start_punch_(
+    nat_test: NatTest,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    sender: ChannelSender,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+) -> crate::Result<()> {
+    let mut num = 0;
+    let sleep_time = [3, 5, 7, 11, 13, 17, 19, 23, 29];
     loop {
         if sender.is_close() {
             return Ok(());
@@ -79,62 +81,47 @@ fn start_punch_(nat_test: NatTest, device_list: Arc<Mutex<(u16, Vec<PeerDeviceIn
                 if info.virtual_ip <= current_device.virtual_ip {
                     continue;
                 }
-                if let Some(route) = sender.route(&info.virtual_ip) {
-                    if route.metric == 1 {
-                        //直连地址不需要打洞
-                        continue;
-                    }
+                if !sender.need_punch(&info.virtual_ip) {
+                    continue;
                 }
                 count += 1;
-                if count > 3 {
+                if count > 2 {
                     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 => {
-                thread::sleep(Duration::from_secs(20));
+                sender.send_main(&buf, current_device.connect_server).await?;
             }
         }
+        num += 1;
+        tokio::time::sleep(Duration::from_secs(sleep_time[num % sleep_time.len()])).await;
     }
 }
 
-pub fn punch_packet(virtual_ip: Ipv4Addr, nat_info: &NatInfo, dest: Ipv4Addr) -> crate::Result<Vec<u8>> {
+pub fn punch_packet(
+    virtual_ip: Ipv4Addr,
+    nat_info: &NatInfo,
+    dest: Ipv4Addr,
+) -> crate::Result<Vec<u8>> {
     let mut punch_reply = PunchInfo::new();
     punch_reply.reply = false;
-    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_ip_list = nat_info
+        .public_ips
+        .iter()
+        .map(|ip| u32::from_be_bytes(ip.octets()))
+        .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.local_ip = match nat_info.local_ip {
-        IpAddr::V4(ip) => u32::from_be_bytes(ip.octets()),
-        IpAddr::V6(_) => {
-            panic!()
-        }
-    };
+    punch_reply.local_ip = u32::from_be_bytes(nat_info.local_ip.octets());
     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; 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_transport_protocol(other_turn_packet::Protocol::Punch.into());
     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())
-}
+}

switch/src/handle/recv_handler.rs

@@ -1,115 +1,111 @@
-use std::{io, thread};
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::sync::Arc;
+use aes_gcm::{AeadInPlace, Aes256Gcm, Nonce, Tag};
+use aes_gcm::aead::consts::{U12, U16};
+use aes_gcm::aead::generic_array::GenericArray;
 
 use chrono::Local;
 use crossbeam::atomic::AtomicCell;
 use crossbeam_skiplist::SkipMap;
 use parking_lot::Mutex;
 use protobuf::Message;
+use tokio::net::UdpSocket;
+use tokio::sync::mpsc::Sender;
 
-use p2p_channel::channel::{Channel, Route, RouteKey};
-use p2p_channel::punch::NatInfo;
 use packet::icmp::{icmp, Kind};
+use packet::icmp::icmp::HeaderOther;
 use packet::ip::ipv4;
 use packet::ip::ipv4::packet::IpV4Packet;
+use crate::channel::channel::Context;
+use crate::channel::punch::{NatInfo, NatType};
+use crate::channel::{Route, RouteKey};
 
 use crate::error::Error;
+use crate::external_route::ExternalRoute;
 use crate::handle::{check_dest, ConnectStatus, CurrentDeviceInfo, PeerDeviceInfo};
 use crate::handle::registration_handler::Register;
+use crate::igmp_server::IgmpServer;
+use crate::ip_proxy::IpProxyMap;
 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, MAX_TTL, NetPacket, Protocol, service_packet, other_turn_packet, Version, ip_turn_packet};
 use crate::protocol::control_packet::ControlPacket;
 use crate::protocol::error_packet::InErrorPacket;
-use crate::tun_device::TunWriter;
+use crate::tun_tap_device::DeviceWriter;
 
-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<Ipv4Addr>,
+#[derive(Clone)]
+pub struct ChannelDataHandler {
     current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
     device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
     register: Arc<Register>,
     nat_test: NatTest,
-    tun_writer: TunWriter,
+    igmp_server: IgmpServer,
+    device_writer: DeviceWriter,
     connect_status: Arc<AtomicCell<ConnectStatus>>,
     peer_nat_info_map: Arc<SkipMap<Ipv4Addr, NatInfo>>,
+    ip_proxy_map: IpProxyMap,
+    out_external_route: ExternalRoute,
+    cone_sender: Sender<(Ipv4Addr, NatInfo)>,
+    symmetric_sender: Sender<(Ipv4Addr, NatInfo)>,
+    cipher: Option<Aes256Gcm>,
 }
 
-impl RecvHandler {
-    pub fn new(channel: Channel<Ipv4Addr>,
-               current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+impl ChannelDataHandler {
+    pub fn new(current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
                device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
                register: Arc<Register>,
                nat_test: NatTest,
-               tun_writer: TunWriter,
+               igmp_server: IgmpServer,
+               device_writer: DeviceWriter,
                connect_status: Arc<AtomicCell<ConnectStatus>>,
                peer_nat_info_map: Arc<SkipMap<Ipv4Addr, NatInfo>>,
-    ) -> Self {
+               ip_proxy_map: IpProxyMap,
+               out_external_route: ExternalRoute,
+               cone_sender: Sender<(Ipv4Addr, NatInfo)>,
+               symmetric_sender: Sender<(Ipv4Addr, NatInfo)>,
+               cipher: Option<Aes256Gcm>, ) -> Self {
         Self {
-            channel,
             current_device,
             device_list,
             register,
             nat_test,
-            tun_writer,
+            igmp_server,
+            device_writer,
             connect_status,
             peer_nat_info_map,
+            ip_proxy_map,
+            out_external_route,
+            cone_sender,
+            symmetric_sender,
+            cipher,
         }
     }
-    pub fn try_clone(&self) -> io::Result<Self> {
-        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)?;
+
+impl ChannelDataHandler {
+    pub async fn handle(&mut self, buf: &mut [u8], start: usize, end: usize, route_key: RouteKey, _udp: &Arc<UdpSocket>,
+                        context: &Context, ) {
+        assert_eq!(start, 14);
+        match self.handle0(&mut buf[..end], &route_key, context).await {
+            Ok(_) => {}
+            Err(e) => {
+                log::error!("{:?}",e);
+            }
+        }
+    }
+    async fn handle0(&self, buf: &mut [u8], route_key: &RouteKey, context: &Context) -> crate::Result<()> {
+        let mut net_packet = NetPacket::new(&mut buf[14..])?;
         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 current_device.virtual_ip() != destination
+            && !destination.is_broadcast() && !destination.is_multicast() && destination != current_device.broadcast_address
+            && 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(());
@@ -118,53 +114,189 @@ impl RecvHandler {
                 log::warn!("转发数据，目的地址错误:{:?},当前网络:{:?},route_key:{:?}",destination,current_device.virtual_network,route_key);
                 return Ok(());
             }
+            net_packet.set_ttl(net_packet.ttl() - 1);
             let ttl = net_packet.ttl();
-            if ttl > 1 {
+            if ttl > 0 {
                 // 转发
-                net_packet.set_ttl(ttl - 1);
-                if let Some(route) = self.channel.route(&destination) {
+                if let Some(route) = context.route_one(&destination) {
                     if route.metric <= net_packet.ttl() {
-                        self.channel.send_to_route(net_packet.buffer(), &route.route_key())?;
+                        context.send_by_key(net_packet.buffer(), &route.route_key()).await?;
                     }
-                } else if (ttl > 2 || destination == current_device.virtual_gateway())
+                } else if (ttl > 1 || destination == current_device.virtual_gateway())
                     && source != current_device.virtual_gateway() {
                     //网关默认要转发一次，生存时间不够的发到网关也会被丢弃
-                    self.channel.send_to_addr(net_packet.buffer(), current_device.connect_server)?;
+                    context.send_main(net_packet.buffer(), current_device.connect_server).await?;
                 }
             }
             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)?;
+            Protocol::IpTurn => {
+                match ip_turn_packet::Protocol::from(net_packet.transport_protocol()) {
+                    ip_turn_packet::Protocol::Icmp => {
+                        let ipv4 = IpV4Packet::new(net_packet.payload())?;
+                        if ipv4.protocol() == ipv4::protocol::Protocol::Icmp {
+                            self.device_writer.write_ipv4(&mut buf[12..])?;
+                            return Ok(());
+                        }
+                    }
+                    ip_turn_packet::Protocol::Igmp => {
+                        let ipv4 = IpV4Packet::new(net_packet.payload())?;
+                        if ipv4.protocol() == ipv4::protocol::Protocol::Igmp {
+                            self.igmp_server.handle(ipv4.payload(), source)?;
+                        }
                         return Ok(());
                     }
+                    ip_turn_packet::Protocol::Ipv4 => {
+                        let data = if let Some(cipher) = &self.cipher {
+                            if !net_packet.is_encrypt() {
+                                //未加密的数据之间丢弃
+                                return Ok(());
+                            }
+                            if net_packet.payload().len() < 16 {
+                                log::error!("数据异常,长度小于16");
+                                return Ok(());
+                            }
+                            //需要解密
+                            let mut nonce = [0; 12];
+                            nonce[0..4].copy_from_slice(&source.octets());
+                            nonce[4..8].copy_from_slice(&destination.octets());
+                            nonce[8] = Protocol::IpTurn.into();
+                            nonce[9] = ip_turn_packet::Protocol::Ipv4.into();
+                            let nonce: &GenericArray<u8, U12> = Nonce::from_slice(&nonce);
+                            let data_len = net_packet.payload().len() - 16;
+                            let tag: GenericArray<u8, U16> = Tag::clone_from_slice(&net_packet.payload()[data_len..]);
+                            match cipher.decrypt_in_place_detached(nonce, &[], &mut net_packet.payload_mut()[..data_len], &tag) {
+                                Ok(_) => {}
+                                Err(e) => {
+                                    log::error!("数据解密异常:{}",e);
+                                    return Ok(());
+                                }
+                            }
+                            &mut net_packet.payload_mut()[..data_len]
+                        } else {
+                            net_packet.payload_mut()
+                        };
+                        let mut ipv4 = IpV4Packet::new(data)?;
+                        match ipv4.protocol() {
+                            ipv4::protocol::Protocol::Igmp => {
+                                self.igmp_server.handle(ipv4.payload(), source)?;
+                                return Ok(());
+                            }
+                            ipv4::protocol::Protocol::Icmp => {
+                                if ipv4.destination_ip() == destination {
+                                    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);
+                                        if let Some(cipher) = &self.cipher {
+                                            //需要加密
+                                            let mut nonce = [0; 12];
+                                            nonce[0..4].copy_from_slice(&destination.octets());
+                                            nonce[4..8].copy_from_slice(&source.octets());
+                                            nonce[8] = Protocol::IpTurn.into();
+                                            nonce[9] = ip_turn_packet::Protocol::Ipv4.into();
+                                            let nonce: &GenericArray<u8, U12> = Nonce::from_slice(&nonce);
+                                            let data_len = net_packet.payload().len() - 16;
+                                            match cipher.encrypt_in_place_detached(nonce, &[], &mut net_packet.payload_mut()[..data_len]) {
+                                                Ok(tag) => {
+                                                    if tag.len() != 16 {
+                                                        log::error!("加密tag长度错误:{}",tag.len());
+                                                        return Ok(());
+                                                    }
+                                                    net_packet.set_encrypt_flag(true);
+                                                    net_packet.payload_mut()[data_len..data_len + 16].copy_from_slice(tag.as_slice());
+                                                }
+                                                Err(e) => {
+                                                    log::error!("加密失败:{}",e);
+                                                    return Ok(());
+                                                }
+                                            }
+                                        }
+                                        context.send_by_key(net_packet.buffer(), route_key).await?;
+                                        return Ok(());
+                                    }
+                                }
+                            }
+                            _ => {}
+                        }
+                        if ipv4.destination_ip() != destination {
+                            if let Some(gate_way) = self.out_external_route.route(&ipv4.destination_ip()) {
+                                match ipv4.protocol() {
+                                    ipv4::protocol::Protocol::Tcp => {
+                                        let dest_ip = ipv4.destination_ip();
+                                        //转发到代理目标地址
+                                        let mut tcp_packet = packet::tcp::tcp::TcpPacket::new(source, destination, ipv4.payload_mut())?;
+                                        let source_port = tcp_packet.source_port();
+                                        let dest_port = tcp_packet.destination_port();
+                                        tcp_packet.set_destination_port(self.ip_proxy_map.tcp_proxy_port);
+                                        tcp_packet.update_checksum();
+                                        ipv4.set_destination_ip(destination);
+                                        ipv4.update_checksum();
+                                        self.ip_proxy_map.tcp_proxy_map.insert(SocketAddrV4::new(source, source_port),
+                                                                               (SocketAddrV4::new(gate_way, 0), SocketAddrV4::new(dest_ip, dest_port)));
+                                    }
+                                    ipv4::protocol::Protocol::Udp => {
+                                        let dest_ip = ipv4.destination_ip();
+                                        //转发到代理目标地址
+                                        let mut udp_packet = packet::udp::udp::UdpPacket::new(source, destination, ipv4.payload_mut())?;
+                                        let source_port = udp_packet.source_port();
+                                        let dest_port = udp_packet.destination_port();
+                                        udp_packet.set_destination_port(self.ip_proxy_map.udp_proxy_port);
+                                        udp_packet.update_checksum();
+                                        ipv4.set_destination_ip(destination);
+                                        ipv4.update_checksum();
+                                        self.ip_proxy_map.udp_proxy_map.insert(SocketAddrV4::new(source, source_port),
+                                                                               (SocketAddrV4::new(gate_way, 0), SocketAddrV4::new(dest_ip, dest_port)));
+                                    }
+                                    ipv4::protocol::Protocol::Icmp => {
+                                        let dest_ip = ipv4.destination_ip();
+                                        //转发到代理目标地址
+                                        let icmp_packet = icmp::IcmpPacket::new(ipv4.payload())?;
+                                        match icmp_packet.header_other() {
+                                            HeaderOther::Identifier(id, seq) => {
+                                                self.ip_proxy_map.icmp_proxy_map.insert((dest_ip, id, seq), source);
+                                                self.ip_proxy_map.send_icmp(ipv4.payload(), &gate_way, &dest_ip)?;
+                                            }
+                                            _ => {
+                                                return Ok(());
+                                            }
+                                        }
+                                    }
+                                    _ => {
+                                        return Ok(());
+                                    }
+                                }
+                            }
+                        }
+
+                        //传输协议12字节
+                        self.device_writer.write_ipv4(&mut buf[12..])?;
+                        return Ok(());
+                    }
+                    ip_turn_packet::Protocol::Ipv4Broadcast => {
+                        //客户端不帮忙转发广播包，所以不会出现这种类型的数据
+                    }
+                    ip_turn_packet::Protocol::Unknown(_) => {}
                 }
-                self.tun_writer.write(net_packet.payload())?;
             }
             Protocol::Service => {
-                self.service(current_device, source, net_packet, route_key)?;
+                self.service(context, current_device, source, net_packet, route_key).await?;
             }
             Protocol::Error => {
-                self.error(current_device, source, net_packet, route_key)?;
+                self.error(context, current_device, source, net_packet, route_key).await?;
             }
             Protocol::Control => {
-                self.control(current_device, source, net_packet, route_key)?;
+                self.control(context, current_device, source, net_packet, route_key).await?;
             }
             Protocol::OtherTurn => {
-                self.other_turn(current_device, source, net_packet, route_key)?;
+                self.other_turn(context, current_device, source, net_packet, route_key).await?;
             }
             Protocol::UnKnow(e) => {
                 log::info!("不支持的协议:{}",e);
@@ -172,18 +304,20 @@ impl RecvHandler {
         }
         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() {
+    async fn service(&self, context: &Context, current_device: CurrentDeviceInfo, _source: Ipv4Addr, net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> {
+        //todo 校验来源
+        if route_key.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())?;
-                let local_port = self.channel.local_addr()?.port();
+                let local_port = context.main_local_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 nat_info = self.nat_test.re_test(Ipv4Addr::from(response.public_ip),
+                                                     response.public_port as u16, local_ip, local_port);
+                context.switch(nat_info.nat_type);
                 let new_ip = Ipv4Addr::from(response.virtual_ip);
                 let current_ip = current_device.virtual_ip();
                 if current_ip != new_ip {
@@ -194,7 +328,7 @@ impl RecvHandler {
                     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)?;
+                    self.device_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) {
@@ -223,14 +357,14 @@ impl RecvHandler {
                     dev.1 = ip_list;
                 }
             }
-            service_packet::Protocol::UnKnow(u) => {
+            service_packet::Protocol::Unknown(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() {
+    async fn error(&self, _context: &Context, current_device: CurrentDeviceInfo, _source: Ipv4Addr, net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> {
+        if route_key.addr != current_device.connect_server {
             return Ok(());
         }
         match InErrorPacket::new(net_packet.transport_protocol(), net_packet.payload())? {
@@ -238,8 +372,14 @@ impl RecvHandler {
                 return Err(Error::Stop("Token error".to_string()));
             }
             InErrorPacket::Disconnect => {
+                {
+                    //掉线epoch要归零
+                    let mut dev = self.device_list.lock();
+                    dev.0 = 0;
+                }
+
                 self.connect_status.store(ConnectStatus::Connecting);
-                self.register.fast_register()?;
+                self.register.fast_register().await?;
             }
             InErrorPacket::AddressExhausted => {
                 //地址用尽
@@ -251,33 +391,28 @@ impl RecvHandler {
         }
         Ok(())
     }
-    fn control(&self, current_device: CurrentDeviceInfo, source: Ipv4Addr, mut net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> {
+    async fn control(&self, context: &Context, current_device: CurrentDeviceInfo, source: Ipv4Addr, mut net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> {
+        let metric = net_packet.source_ttl() - net_packet.ttl() + 1;
         match ControlPacket::new(net_packet.transport_protocol(), net_packet.payload())? {
             ControlPacket::PingPacket(_) => {
+                context.update_read_time(&source, route_key);
                 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)?;
+                context.send_by_key(net_packet.buffer(), route_key).await?;
+                let route = Route::from(*route_key, metric, 99);
+                context.add_route_if_absent(source, route);
             }
             ControlPacket::PongPacket(pong_packet) => {
+                context.update_read_time(&source, route_key);
                 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 &current_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);
-                }
+                let route = Route::from(*route_key, metric, rt);
+                context.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 {
@@ -288,7 +423,7 @@ impl RecvHandler {
                         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)?;
+                        context.send_by_key(poll_device.buffer(), route_key).await?;
                     }
                 }
             }
@@ -299,28 +434,28 @@ impl RecvHandler {
                 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);
+                context.send_by_key(net_packet.buffer(), route_key).await?;
+                let route = Route::from(*route_key, metric, 99);
+                context.add_route_if_absent(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);
+                let route = Route::from(*route_key, metric, 99);
+                context.add_route_if_absent(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 => {
+    async fn other_turn(&self, context: &Context, current_device: CurrentDeviceInfo, source: Ipv4Addr, net_packet: NetPacket<&mut [u8]>, route_key: &RouteKey) -> crate::Result<()> {
+        match other_turn_packet::Protocol::from(net_packet.transport_protocol()) {
+            other_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();
+                    iter().map(|v| { Ipv4Addr::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()),
+                                                 Ipv4Addr::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());
@@ -328,27 +463,20 @@ impl RecvHandler {
                     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_ip_list = nat_info.public_ips.iter().map(|ip| u32::from_be_bytes(ip.octets())).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));
+                    punch_reply.local_ip = u32::from_be_bytes(nat_info.local_ip.octets());
+                    punch_reply.local_port = nat_info.local_port as u32;
                     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(),
+                        other_turn_packet::Protocol::Punch.into(),
                     );
                     net_packet.first_set_ttl(MAX_TTL);
                     net_packet.set_source(current_device.virtual_ip());
@@ -362,21 +490,29 @@ impl RecvHandler {
                         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));
+                        let _ = context.send_main(packet.buffer(), SocketAddr::V4(SocketAddrV4::new(peer_nat_info.local_ip, peer_nat_info.local_port))).await;
                     }
-                    if let Err(e) = self.channel.punch(source, peer_nat_info) {
-                        log::warn!("发送到打洞通道失败 {:?}",e);
-                        return Ok(());
+                    if self.punch(source, peer_nat_info).await {
+                        context.send_by_key(net_packet.buffer(), route_key).await?;
                     }
-                    self.channel.send_to_route(net_packet.buffer(), route_key)?;
                 } else {
-                    let _ = self.channel.punch(source, peer_nat_info);
+                    self.punch(source, peer_nat_info).await;
                 }
             }
-            turn_packet::Protocol::UnKnow(e) => {
+            other_turn_packet::Protocol::Unknown(e) => {
                 log::warn!("不支持的转发协议 {:?},source:{:?}",e,source);
             }
         }
         Ok(())
     }
+    async fn punch(&self, peer_ip: Ipv4Addr, peer_nat_info: NatInfo) -> bool {
+        match peer_nat_info.nat_type {
+            NatType::Symmetric => {
+                self.symmetric_sender.try_send((peer_ip, peer_nat_info)).is_ok()
+            }
+            NatType::Cone => {
+                self.cone_sender.try_send((peer_ip, peer_nat_info)).is_ok()
+            }
+        }
+    }
 }

switch/src/handle/registration_handler.rs

@@ -1,12 +1,12 @@
 use std::io;
-use std::net::{Ipv4Addr, SocketAddr};
+use std::net::SocketAddr;
 use std::sync::atomic::{AtomicI64, Ordering};
 use std::time::Duration;
 
 use chrono::Local;
 use protobuf::Message;
-use p2p_channel::channel::Channel;
-use p2p_channel::channel::sender::Sender;
+use tokio::net::UdpSocket;
+use crate::channel::sender::ChannelSender;
 
 use crate::error::*;
 use crate::proto::message::{RegistrationRequest, RegistrationResponse};
@@ -14,8 +14,8 @@ use crate::protocol::error_packet::InErrorPacket;
 use crate::protocol::{service_packet, NetPacket, Protocol, Version, MAX_TTL};
 
 ///向中继服务器注册，token标识一个虚拟网关，device_id防止多次注册时得到的ip不一致
-pub fn registration(
-    channel: &mut Channel<Ipv4Addr>,
+pub async fn registration(
+    main_channel: &UdpSocket,
     server_address: SocketAddr,
     token: String,
     device_id: String,
@@ -25,45 +25,72 @@ pub fn registration(
         registration_request_packet(token.clone(), device_id.clone(), name.clone(), false)?;
     let buf = request_packet.buffer();
     let mut recv_buf = [0u8; 10240];
-    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)))
+    let mut count = 0;
+    loop {
+        match main_channel.send_to(buf, server_address).await {
+            Ok(_) => {
+                match tokio::time::timeout(Duration::from_millis(300), main_channel.recv_from(&mut recv_buf)).await {
+                    Ok(rs) => {
+                        match rs {
+                            Ok((len, addr)) => {
+                                if server_address == addr {
+                                    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())?;
+                                                    return Ok(response);
+                                                }
+                                                _ => println!("响应数据错误"),
+                                            }
+                                        }
+                                        Protocol::Error => {
+                                            match InErrorPacket::new(net_packet.transport_protocol(), net_packet.payload()) {
+                                                Ok(e) => match e {
+                                                    InErrorPacket::TokenError => return Err(Error::Stop("token错误".to_string())),
+                                                    InErrorPacket::Disconnect => {
+                                                        println!("断开连接");
+                                                    }
+                                                    InErrorPacket::AddressExhausted => {
+                                                        println!("地址用尽");
+                                                        log::warn!("地址用尽");
+                                                    }
+                                                    InErrorPacket::OtherError(e) => match e.message() {
+                                                        Ok(str) => {
+                                                            println!("其他异常:{:?}", str);
+                                                            log::warn!("其他异常{:?}",str);
+                                                        }
+                                                        Err(e) => println!("其他异常:{:?}", e),
+                                                    },
+                                                },
+                                                Err(e) => println!("数据解析异常:{:?}", e),
+                                            }
+                                        }
+                                        _ => println!("响应数据错误"),
+                                    };
+                                }
+                            }
+                            Err(e) => {
+                                println!("接收服务器数据失败:{:?}", e);
+                                log::warn!("接收服务器数据失败:{:?}",e);
+                            }
+                        }
+                    }
+                    Err(_) => {
+                        println!("接收超时");
+                        log::warn!("接收超时");
+                    }
                 }
             }
-        }
-        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(e) => {
+                println!("发送数据到服务器失败:{:?}", e);
+                log::warn!("发送数据到服务器失败:{:?}",e);
             }
         }
-        _ => {
-            Err(Error::Warn(format!("数据错误：{:?}", net_packet)))
-        }
+        count += 1;
+        println!("重试中(retrying)...");
+        std::thread::sleep(Duration::from_secs(count % 10 + 1));
     };
 }
 
@@ -78,6 +105,7 @@ fn registration_request_packet(
     request.device_id = device_id;
     request.name = name;
     request.is_fast = is_fast;
+    request.version = "1.0.6".to_string();
     let bytes = request.write_to_bytes()?;
     let buf = vec![0u8; 12 + bytes.len()];
     let mut net_packet = NetPacket::new(buf)?;
@@ -90,7 +118,7 @@ fn registration_request_packet(
 }
 
 pub struct Register {
-    sender: Sender<Ipv4Addr>,
+    sender: ChannelSender,
     server_address: SocketAddr,
     token: String,
     device_id: String,
@@ -99,11 +127,13 @@ pub struct Register {
 }
 
 impl Register {
-    pub fn new(sender: Sender<Ipv4Addr>,
-               server_address: SocketAddr,
-               token: String,
-               device_id: String,
-               name: String, ) -> Self {
+    pub fn new(
+        sender: ChannelSender,
+        server_address: SocketAddr,
+        token: String,
+        device_id: String,
+        name: String,
+    ) -> Self {
         Self {
             sender,
             server_address,
@@ -113,11 +143,12 @@ impl Register {
             time: AtomicI64::new(0),
         }
     }
-    pub fn fast_register(&self) -> io::Result<()> {
+    pub async 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
+            || self
+            .time
             .compare_exchange(last, new, Ordering::Relaxed, Ordering::Relaxed)
             .is_err()
         {
@@ -125,12 +156,15 @@ impl Register {
             return Ok(());
         }
         log::info!("重新连接");
-        let request_packet =
-            registration_request_packet(self.token.clone(),
-                                        self.device_id.clone(),
-                                        self.name.clone(), false).unwrap();
+        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)?;
+        self.sender.send_main(buf, self.server_address).await?;
         Ok(())
     }
 }

switch/src/handle/tun_handler.rs

@@ -1,120 +0,0 @@
-use std::{io, thread};
-/// 接收tun数据，并且转发到udp上
-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::{check_dest, CurrentDeviceInfo};
-use crate::protocol::{MAX_TTL, NetPacket, Protocol, Version};
-use crate::tun_device::{TunReader, TunWriter};
-
-
-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 {
-            icmp.set_kind(Kind::EchoReply);
-            icmp.update_checksum();
-            let src = ipv4_packet.source_ip();
-            ipv4_packet.set_source_ip(ipv4_packet.destination_ip());
-            ipv4_packet.set_destination_ip(src);
-            ipv4_packet.update_checksum();
-            tun_writer.write(ipv4_packet.buffer)?;
-        }
-    }
-    Ok(())
-}
-
-#[inline]
-fn handle(sender: &Sender<Ipv4Addr>, data: &mut [u8], tun_writer: &TunWriter, current_device: CurrentDeviceInfo, net_packet: &mut NetPacket<Vec<u8>>) -> Result<()> {
-    let data_len = data.len();
-    let ipv4_packet = match IpV4Packet::new(data) {
-        Ok(ipv4_packet) => ipv4_packet,
-        Err(packet::error::Error::Unimplemented) => {
-            return Ok(());
-        }
-        Err(e) => Err(e)?,
-    };
-    let src_ip = ipv4_packet.source_ip();
-    let dest_ip = ipv4_packet.destination_ip();
-    // if dest_ip == cur_info.broadcast_address {
-    //     // 启动服务后会收到对137端口的广播
-    //     // 137端口是在局域网中提供计算机的名字或IP地址查询服务
-    //     return Ok(());
-    // }
-    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(&tun_writer, ipv4_packet);
-    }
-    net_packet.set_source(src_ip);
-    net_packet.set_destination(dest_ip);
-    net_packet.set_payload(ipv4_packet.buffer);
-    //优先发到直连到地址
-    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)?;
-    }
-    return Ok(());
-}
-
-pub fn start(sender: Sender<Ipv4Addr>,
-             tun_reader: TunReader,
-             tun_writer: TunWriter,
-             current_device: Arc<AtomicCell<CurrentDeviceInfo>>, ) {
-    thread::spawn(move || {
-        if let Err(e) = start_(sender, tun_reader, tun_writer, current_device) {
-            log::warn!("{:?}",e);
-        }
-    });
-}
-
-#[cfg(target_os = "windows")]
-fn start_(sender: Sender<Ipv4Addr>,
-          tun_reader: TunReader,
-          tun_writer: TunWriter,
-          current_device: Arc<AtomicCell<CurrentDeviceInfo>>, ) -> 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(MAX_TTL);
-    loop {
-        let mut data = tun_reader.next()?;
-        match handle(&sender, data.bytes_mut(), &tun_writer, current_device.load(), &mut net_packet) {
-            Ok(_) => {}
-            Err(e) => {
-                log::warn!("{:?}", e)
-            }
-        }
-    }
-}
-
-#[cfg(any(target_os = "linux",target_os = "macos"))]
-fn start_(sender: Sender<Ipv4Addr>,
-          tun_reader: TunReader,
-          tun_writer: TunWriter,
-          current_device: Arc<AtomicCell<CurrentDeviceInfo>>, ) -> 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(MAX_TTL);
-    let mut buf = [0; 4096];
-    loop {
-        let data = tun_reader.read(&mut buf)?;
-        match handle(&sender, data, &tun_writer, current_device.load(), &mut net_packet) {
-            Ok(_) => {}
-            Err(e) => {
-                log::warn!("{:?}", e)
-            }
-        }
-    }
-}

switch/src/handle/tun_tap/mod.rs

@@ -0,0 +1,215 @@
+use std::io;
+use std::net::{Ipv4Addr, SocketAddrV4};
+use aes_gcm::{AeadInPlace, Aes256Gcm, Nonce};
+use aes_gcm::aead::consts::U12;
+use aes_gcm::aead::generic_array::GenericArray;
+use packet::ip::ipv4::packet::IpV4Packet;
+use packet::ip::ipv4::protocol::Protocol;
+use packet::tcp::tcp::TcpPacket;
+use packet::udp::udp::UdpPacket;
+use crate::channel::sender::ChannelSender;
+use crate::external_route::ExternalRoute;
+use crate::handle::{check_dest, CurrentDeviceInfo};
+use crate::ip_proxy::IpProxyMap;
+use crate::protocol::{ip_turn_packet, NetPacket, Version};
+use crate::error::*;
+use crate::igmp_server::IgmpServer;
+use crate::protocol;
+use crate::protocol::ip_turn_packet::BroadcastPacketEnd;
+
+pub mod tun_handler;
+pub mod tap_handler;
+
+async fn broadcast(sender: &ChannelSender, net_packet: &mut NetPacket<&mut [u8]>, data_len: usize, current_device: &CurrentDeviceInfo) -> Result<()> {
+    let mut peer_ips = Vec::with_capacity(8);
+    let vec = sender.direct_route_table_one();
+    for (peer_ip, route) in vec {
+        if sender.send_by_key(&net_packet.buffer()[..data_len], &route.route_key()).await.is_ok() {
+            peer_ips.push(peer_ip);
+        }
+    }
+    if peer_ips.is_empty() {
+        sender.send_main(&net_packet.buffer()[..data_len], current_device.connect_server).await?;
+    } else {
+        let end_len = 1 + peer_ips.len() * 4;
+        //剩余的发送到服务端，需要告知哪些已发送过
+        //放在末尾可以减少复制次数
+        let mut broadcast = BroadcastPacketEnd::unchecked(&mut net_packet.buffer_mut()[data_len..data_len + end_len]);
+        broadcast.set_address(&peer_ips)?;
+        net_packet.set_transport_protocol(ip_turn_packet::Protocol::Ipv4Broadcast.into());
+        sender.send_main(&net_packet.buffer()[..(data_len + end_len)], current_device.connect_server).await?;
+    }
+    Ok(())
+}
+
+async fn multicast(igmp_server: &IgmpServer, multicast_addr: Ipv4Addr, sender: &ChannelSender, net_packet: &mut NetPacket<&mut [u8]>, data_len: usize, current_device: &CurrentDeviceInfo) -> Result<()> {
+    let mut peer_ips = Vec::with_capacity(8);
+    let vec = sender.direct_route_table_one();
+    if let Some(members) = igmp_server.load(&multicast_addr) {
+        for (peer_ip, route) in vec {
+            let is_send = {members.read().is_send(&peer_ip)};
+            if is_send {
+                if sender.send_by_key(&net_packet.buffer()[..data_len], &route.route_key()).await.is_ok() {
+                    peer_ips.push(peer_ip);
+                    if peer_ips.len() == u8::MAX as usize {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if peer_ips.is_empty() {
+        sender.send_main(&net_packet.buffer()[..data_len], current_device.connect_server).await?;
+    } else {
+        let end_len = 1 + peer_ips.len() * 4;
+        //剩余的发送到服务端，需要告知哪些已发送过
+        //放在末尾可以减少复制次数
+        let mut broadcast = BroadcastPacketEnd::unchecked(&mut net_packet.buffer_mut()[data_len..data_len + end_len]);
+        broadcast.set_address(&peer_ips)?;
+        net_packet.set_transport_protocol(ip_turn_packet::Protocol::Ipv4Broadcast.into());
+        sender.send_main(&net_packet.buffer()[..(data_len + end_len)], current_device.connect_server).await?;
+    }
+    Ok(())
+}
+
+/// 实现一个原地发送，必须保证是如下结构
+/// |12字节开头|ip报文|至少1024字节+12字节结尾|
+///
+#[inline]
+pub async fn base_handle(sender: &ChannelSender, buf: &mut [u8],
+                         mut data_len: usize,//数据总长度=ip长度+12
+                         igmp_server: &IgmpServer,
+                         current_device: CurrentDeviceInfo,
+                         ip_route: &ExternalRoute, proxy_map: &IpProxyMap, cipher: &Option<Aes256Gcm>) -> Result<()> {
+    let ipv4_packet = IpV4Packet::new(&buf[12..data_len])?;
+    let protocol = ipv4_packet.protocol();
+    let ip_head_len = ipv4_packet.header_len() as usize * 4;
+    let src_ip = ipv4_packet.source_ip();
+    let mut dest_ip = ipv4_packet.destination_ip();
+    let mut net_packet = NetPacket::new(buf)?;
+    net_packet.set_version(Version::V1);
+    net_packet.set_protocol(protocol::Protocol::IpTurn);
+    net_packet.set_transport_protocol(ip_turn_packet::Protocol::Ipv4.into());
+    net_packet.first_set_ttl(3);
+    net_packet.set_source(src_ip);
+    net_packet.set_destination(dest_ip);
+    if dest_ip == current_device.virtual_gateway {
+        if protocol == Protocol::Icmp {
+            net_packet.set_transport_protocol(ip_turn_packet::Protocol::Icmp.into());
+            //发送到服务端的不加密
+            sender.send_main(&net_packet.buffer()[..data_len], current_device.connect_server).await?;
+        }
+        return Ok(());
+    }
+    if dest_ip.is_multicast() {
+        if protocol == Protocol::Igmp {
+            net_packet.set_transport_protocol(ip_turn_packet::Protocol::Igmp.into());
+            //发送到服务端
+            sender.send_main(&net_packet.buffer()[..data_len], current_device.connect_server).await?;
+            return Ok(());
+        }
+    }
+    if dest_ip.is_broadcast() || current_device.broadcast_address == dest_ip {
+        // 广播 发送到直连目标
+        if Protocol::Udp == protocol {
+            if let Some(cipher) = cipher {
+                //需要加密
+                encrypt(cipher, &mut data_len, &mut net_packet)?;
+            }
+            broadcast(sender, &mut net_packet, data_len, &current_device).await?;
+        }
+        return Ok(());
+    } else if dest_ip.is_multicast() {
+        if protocol == Protocol::Udp {
+            if let Some(cipher) = cipher {
+                //需要加密
+                encrypt(cipher, &mut data_len, &mut net_packet)?;
+            }
+            multicast(igmp_server, dest_ip, sender, &mut net_packet, data_len, &current_device).await?;
+        }
+        return Ok(());
+    } else {
+        if !check_dest(dest_ip, current_device.virtual_netmask, current_device.virtual_network) {
+            if let Some(r_dest_ip) = ip_route.route(&dest_ip) {
+                //路由的目标不能是自己
+                if r_dest_ip == src_ip {
+                    return Ok(());
+                }
+                //需要修改目的地址
+                dest_ip = r_dest_ip;
+                net_packet.set_destination(r_dest_ip);
+            } else {
+                return Ok(());
+            }
+        } else {
+            match protocol {
+                Protocol::Tcp => {
+                    let dest_addr = {
+                        let tcp_packet = TcpPacket::new(src_ip, dest_ip, &mut net_packet.buffer_mut()[12 + ip_head_len..data_len])?;
+                        SocketAddrV4::new(dest_ip, tcp_packet.destination_port())
+                    };
+                    if let Some(entry) = proxy_map.tcp_proxy_map.get(&dest_addr) {
+                        let source_addr = entry.value().1;
+                        let source_ip = *source_addr.ip();
+                        let mut tcp_packet = TcpPacket::new(source_ip, dest_ip, &mut net_packet.buffer_mut()[12 + ip_head_len..data_len])?;
+                        tcp_packet.set_source_port(source_addr.port());
+                        tcp_packet.update_checksum();
+                        let mut ipv4_packet = IpV4Packet::new(&mut net_packet.buffer_mut()[12..data_len])?;
+                        ipv4_packet.set_source_ip(source_ip);
+                        ipv4_packet.update_checksum();
+                    }
+                }
+                Protocol::Udp => {
+                    let dest_addr = {
+                        let udp_packet = UdpPacket::new(src_ip, dest_ip, &mut net_packet.buffer_mut()[12 + ip_head_len..data_len])?;
+                        SocketAddrV4::new(dest_ip, udp_packet.destination_port())
+                    };
+                    if let Some(entry) = proxy_map.udp_proxy_map.get(&dest_addr) {
+                        let source_addr = entry.value().1;
+                        let source_ip = *source_addr.ip();
+                        let mut udp_packet = UdpPacket::new(source_ip, dest_ip, &mut net_packet.buffer_mut()[12 + ip_head_len..data_len])?;
+                        udp_packet.set_source_port(source_addr.port());
+                        udp_packet.update_checksum();
+                        let mut ipv4_packet = IpV4Packet::new(&mut net_packet.buffer_mut()[12..data_len])?;
+                        ipv4_packet.set_source_ip(source_ip);
+                        ipv4_packet.update_checksum();
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    if let Some(cipher) = cipher {
+        //需要加密
+        encrypt(cipher, &mut data_len, &mut net_packet)?;
+    }
+
+    //优先发到直连到地址
+    if sender.send_by_id(&net_packet.buffer()[..data_len], &dest_ip).await.is_err() {
+        sender.send_main(&net_packet.buffer()[..data_len], current_device.connect_server).await?;
+    }
+    return Ok(());
+}
+
+fn encrypt(cipher: &Aes256Gcm, data_len: &mut usize, net_packet: &mut NetPacket<&mut [u8]>) -> io::Result<()> {
+    let mut nonce = [0; 12];
+    nonce[0..4].copy_from_slice(&net_packet.source().octets());
+    nonce[4..8].copy_from_slice(&net_packet.destination().octets());
+    nonce[8] = protocol::Protocol::IpTurn.into();
+    nonce[9] = ip_turn_packet::Protocol::Ipv4.into();
+    let nonce: &GenericArray<u8, U12> = Nonce::from_slice(&nonce);
+    return match cipher.encrypt_in_place_detached(nonce, &[], &mut net_packet.payload_mut()[..*data_len - 12]) {
+        Ok(tag) => {
+            if tag.len() != 16 {
+                return Err(io::Error::new(io::ErrorKind::Other, format!("加密tag长度错误:{}", tag.len())));
+            }
+            net_packet.set_encrypt_flag(true);
+            net_packet.payload_mut()[*data_len - 12..*data_len - 12 + 16].copy_from_slice(tag.as_slice());
+            *data_len += 16;
+            Ok(())
+        }
+        Err(e) => {
+            Err(io::Error::new(io::ErrorKind::Other, format!("加密失败:{}", e)))
+        }
+    };
+}

switch/src/handle/tun_tap/tap_handler.rs

@@ -0,0 +1,119 @@
+use std::sync::Arc;
+use std::{io, thread};
+use aes_gcm::Aes256Gcm;
+use crossbeam::atomic::AtomicCell;
+use packet::arp::arp::ArpPacket;
+use packet::ethernet;
+use packet::ethernet::packet::EthernetPacket;
+use packet::icmp::icmp::IcmpPacket;
+use packet::icmp::Kind;
+use packet::ip::ipv4;
+use packet::ip::ipv4::packet::IpV4Packet;
+use crate::channel::sender::ChannelSender;
+use crate::external_route::ExternalRoute;
+use crate::handle::CurrentDeviceInfo;
+use crate::igmp_server::IgmpServer;
+use crate::ip_proxy::IpProxyMap;
+use crate::tun_tap_device::{DeviceReader, DeviceWriter};
+
+pub fn start(sender: ChannelSender,
+             device_reader: DeviceReader,
+             device_writer: DeviceWriter,
+             igmp_server: IgmpServer,
+             current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+             ip_route: ExternalRoute,
+             ip_proxy_map: IpProxyMap,
+             cipher: Option<Aes256Gcm>) {
+    thread::Builder::new().name("tap-handler".into()).spawn(move || {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all().build().unwrap()
+            .block_on(async move {
+                if let Err(e) = start_(sender, device_reader,
+                                       device_writer, igmp_server,
+                                       current_device, ip_route, ip_proxy_map, cipher).await {
+                    log::warn!("tap:{:?}",e);
+                }
+            });
+    }).unwrap();
+}
+
+async fn start_(sender: ChannelSender,
+                device_reader: DeviceReader,
+                device_writer: DeviceWriter,
+                igmp_server: IgmpServer,
+                current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+                ip_route: ExternalRoute,
+                ip_proxy_map: IpProxyMap,
+                cipher: Option<Aes256Gcm>) -> io::Result<()> {
+    let mut buf = [0; 2048];
+    loop {
+        //ip拆包了会直接丢弃？
+        let len = device_reader.read(&mut buf)?;
+        if let Err(e) = handle(&mut buf, len, &igmp_server, &current_device, &device_writer, &sender, &ip_route, &ip_proxy_map, &cipher).await {
+            log::error!("tap handle{:?}",e);
+        }
+    }
+}
+
+async fn handle(buf: &mut [u8], len: usize, igmp_server: &IgmpServer, current_device: &AtomicCell<CurrentDeviceInfo>,
+                device_writer: &DeviceWriter, sender: &ChannelSender, ip_route: &ExternalRoute, proxy_map: &IpProxyMap, cipher: &Option<Aes256Gcm>) -> crate::Result<()> {
+    let mut ethernet_packet = EthernetPacket::new(&mut buf[..len])?;
+    let current_device = current_device.load();
+    match ethernet_packet.protocol() {
+        ethernet::protocol::Protocol::Arp => {
+            let mut out_ethernet_packet = EthernetPacket::unchecked(ethernet_packet.buffer.to_vec());
+            let arp_packet = ArpPacket::unchecked(ethernet_packet.payload());
+            let mut out_arp_packet = ArpPacket::unchecked(out_ethernet_packet.payload_mut());
+            let sender_h = arp_packet.sender_hardware_addr();
+            let sender_p = arp_packet.sender_protocol_addr();
+            let target_p = arp_packet.target_protocol_addr();
+            if target_p == &[0, 0, 0, 0] || sender_p == &[0, 0, 0, 0] || target_p == sender_p {
+                return Ok(());
+            }
+            //回复一个虚假的MAC地址
+            out_arp_packet.set_sender_hardware_addr(&[target_p[0], target_p[1], target_p[2], target_p[3], !sender_h[5], 234]);
+            out_arp_packet.set_sender_protocol_addr(target_p);
+            out_arp_packet.set_target_hardware_addr(sender_h);
+            out_arp_packet.set_target_protocol_addr(sender_p);
+            out_arp_packet.set_op_code(2);
+            out_ethernet_packet.set_source(&[target_p[0], target_p[1], target_p[2], target_p[3], !sender_h[5], 234]);
+            out_ethernet_packet.set_destination(sender_h);
+            device_writer.write_ethernet_tap(&out_ethernet_packet.buffer)?;
+        }
+        ethernet::protocol::Protocol::Ipv4 => {
+            let mut ipv4_packet = IpV4Packet::unchecked(ethernet_packet.payload_mut());
+            let src_ip = ipv4_packet.source_ip();
+            if src_ip != current_device.virtual_ip() {
+                return Ok(());
+            }
+            let dest_ip = ipv4_packet.destination_ip();
+            let protocol = ipv4_packet.protocol();
+            if src_ip == dest_ip {
+                if protocol == ipv4::protocol::Protocol::Icmp {
+                    let mut icmp = IcmpPacket::new(ipv4_packet.payload_mut())?;
+                    if icmp.kind() == Kind::EchoRequest {
+                        icmp.set_kind(Kind::EchoReply);
+                        icmp.update_checksum();
+                        ipv4_packet.set_source_ip(dest_ip);
+                        ipv4_packet.set_destination_ip(src_ip);
+                        ipv4_packet.update_checksum();
+                        let source = ethernet_packet.source().to_vec();
+                        let dest = ethernet_packet.destination().to_vec();
+                        ethernet_packet.set_source(&dest);
+                        ethernet_packet.set_destination(&source);
+                        device_writer.write_ethernet_tap(&ethernet_packet.buffer)?;
+                    }
+                }
+                return Ok(());
+            }
+            // 以太网帧头部14字节，预留12字节
+            return crate::handle::tun_tap::base_handle(sender, &mut buf[2..], len - 2, igmp_server, current_device,
+                                                       ip_route, proxy_map, cipher).await;
+        }
+        _ => {
+            // log::warn!("不支持的二层协议：{:?}",p)
+        }
+    }
+    Ok(())
+}
+

switch/src/handle/tun_tap/tun_handler.rs

@@ -0,0 +1,93 @@
+use std::{io, thread};
+use std::sync::Arc;
+use aes_gcm::Aes256Gcm;
+
+use crossbeam::atomic::AtomicCell;
+
+use packet::icmp::Kind;
+use packet::icmp::icmp::IcmpPacket;
+use packet::ip::ipv4;
+use packet::ip::ipv4::packet::IpV4Packet;
+use crate::channel::sender::ChannelSender;
+
+use crate::error::*;
+use crate::external_route::ExternalRoute;
+use crate::handle::CurrentDeviceInfo;
+use crate::igmp_server::IgmpServer;
+use crate::ip_proxy::IpProxyMap;
+use crate::tun_tap_device::{DeviceReader, DeviceWriter};
+
+fn icmp(device_writer: &DeviceWriter, 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 {
+            icmp.set_kind(Kind::EchoReply);
+            icmp.update_checksum();
+            let src = ipv4_packet.source_ip();
+            ipv4_packet.set_source_ip(ipv4_packet.destination_ip());
+            ipv4_packet.set_destination_ip(src);
+            ipv4_packet.update_checksum();
+            device_writer.write_ipv4_tun(ipv4_packet.buffer)?;
+        }
+    }
+    Ok(())
+}
+
+/// 接收tun数据，并且转发到udp上
+#[inline]
+async fn handle(sender: &ChannelSender, data: &mut [u8], len: usize, device_writer: &DeviceWriter, igmp_server: &IgmpServer, current_device: CurrentDeviceInfo,
+                ip_route: &ExternalRoute, proxy_map: &IpProxyMap,cipher: &Option<Aes256Gcm>) -> Result<()> {
+    let ipv4_packet = if let Ok(ipv4_packet) = IpV4Packet::new(&mut data[12..len]) {
+        ipv4_packet
+    } else {
+        return Ok(());
+    };
+    let src_ip = ipv4_packet.source_ip();
+    let dest_ip = ipv4_packet.destination_ip();
+    if src_ip != current_device.virtual_ip() {
+        return Ok(());
+    }
+    if src_ip == dest_ip {
+        return icmp(&device_writer, ipv4_packet);
+    }
+    return crate::handle::tun_tap::base_handle(sender, data, len, igmp_server, current_device, ip_route, proxy_map,cipher).await;
+}
+
+pub fn start(sender: ChannelSender,
+             device_reader: DeviceReader,
+             device_writer: DeviceWriter,
+             igmp_server: IgmpServer,
+             current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+             ip_route: ExternalRoute,
+             ip_proxy_map: IpProxyMap,
+             cipher: Option<Aes256Gcm>) {
+    thread::Builder::new().name("tun-handler".into()).spawn(move || {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all().build().unwrap()
+            .block_on(async move {
+                if let Err(e) = start_(sender, device_reader, device_writer, igmp_server, current_device, ip_route, ip_proxy_map,cipher).await {
+                    log::warn!("tun:{:?}",e);
+                }
+            })
+    }).unwrap();
+}
+
+async fn start_(sender: ChannelSender,
+                device_reader: DeviceReader,
+                device_writer: DeviceWriter,
+                igmp_server: IgmpServer,
+                current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+                ip_route: ExternalRoute,
+                ip_proxy_map: IpProxyMap,
+                cipher: Option<Aes256Gcm>) -> io::Result<()> {
+    let mut buf = [0; 4096];
+    loop {
+        let len = device_reader.read(&mut buf[12..])? + 12;
+        match handle(&sender, &mut buf, len, &device_writer, &igmp_server, current_device.load(), &ip_route, &ip_proxy_map,&cipher).await {
+            Ok(_) => {}
+            Err(e) => {
+                log::warn!("{:?}", e)
+            }
+        }
+    }
+}

switch/src/igmp_server/mod.rs

@@ -0,0 +1,248 @@
+use std::collections::{HashMap, HashSet};
+use std::net::Ipv4Addr;
+use std::sync::Arc;
+use std::time::Duration;
+use moka::sync::Cache;
+use parking_lot::RwLock;
+use packet::igmp::igmp_v2::IgmpV2Packet;
+use packet::igmp::igmp_v3::{IgmpV3QueryPacket, IgmpV3RecordType, IgmpV3ReportPacket};
+use packet::igmp::IgmpType;
+use packet::ip::ipv4::protocol::Protocol;
+use crate::tun_tap_device::DeviceWriter;
+
+//1. 定时发送query，启动时20秒一次，连发3次，之后8分钟一次
+//2. 接收网关的igmp report 维护组播源信息
+#[derive(Clone, Debug)]
+pub struct Multicast {
+    //成员虚拟ip
+    members: HashSet<Ipv4Addr>,
+    //是否是过滤模式
+    //成员过滤或包含的源ip
+    map: HashMap<Ipv4Addr, (bool, HashSet<Ipv4Addr>)>,
+}
+
+impl Multicast {
+    pub fn new() -> Self {
+        Self {
+            members: Default::default(),
+            map: Default::default(),
+        }
+    }
+    pub fn is_send(&self, ip: &Ipv4Addr) -> bool {
+        if self.members.contains(ip) {
+            if let Some((is_include, set)) = self.map.get(ip) {
+                if *is_include {
+                    set.contains(ip)
+                } else {
+                    !set.contains(ip)
+                }
+            } else {
+                true
+            }
+        } else {
+            false
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct IgmpServer {
+    multicast: Cache<Ipv4Addr, Arc<RwLock<Multicast>>>,
+    members: Cache<(Ipv4Addr, Ipv4Addr), ()>,
+}
+
+impl IgmpServer {
+    pub fn new(device_writer: DeviceWriter) -> Self {
+        let multicast: Cache<Ipv4Addr, Arc<RwLock<Multicast>>> = Cache::builder()
+            .time_to_idle(Duration::from_secs(30 * 60)).build();
+        let m = multicast.clone();
+        let members: Cache<(Ipv4Addr, Ipv4Addr), ()> = Cache::builder()
+            .time_to_idle(Duration::from_secs(20 * 60)).eviction_listener(move |k: Arc<(Ipv4Addr, Ipv4Addr)>, _, cause| {
+            if cause == moka::notification::RemovalCause::Replaced {
+                return;
+            }
+            log::info!("MULTICAST_MEMBER eviction {:?}", k);
+            if let Some(v) = m.get(&k.0) {
+                let mut lock = v.write();
+                lock.members.remove(&k.1);
+                lock.map.remove(&k.1);
+            }
+        }).build();
+        std::thread::spawn(move || {
+            //定时发送query，启动时20秒一次，连发3次，之后125秒一次
+            let mut count = 0;
+            //预留以太网帧头和ip头
+            let mut buf = [0; 14 + 24 + 12];
+            let dest = Ipv4Addr::new(224, 0, 0, 1);
+            let src = Ipv4Addr::new(10, 26, 0, 1);
+            {
+                let buf = &mut buf[14..];
+                let len = buf.len();
+                // ipv4 头部20字节
+                buf[0] = 0b0100_0110;
+                //写入总长度
+                buf[2..4].copy_from_slice(&(len as u16).to_be_bytes());
+                //ttl
+                buf[8] = 1;
+                buf[20] = 0x94;
+                buf[21] = 0x04;
+                let mut ipv4 = packet::ip::ipv4::packet::IpV4Packet::unchecked(buf);
+                ipv4.set_flags(2);
+                ipv4.set_protocol(Protocol::Igmp);
+                ipv4.set_source_ip(src);
+                ipv4.set_destination_ip(dest);
+                ipv4.update_checksum();
+            }
+            {
+                let mut igmp_query = IgmpV3QueryPacket::unchecked(&mut buf[14 + 24..]);
+                igmp_query.set_igmp_type();
+                igmp_query.set_max_resp_code(100);
+                igmp_query.set_group_address(Ipv4Addr::UNSPECIFIED);
+                igmp_query.set_qrv(2);
+                igmp_query.set_qqic(125);
+                igmp_query.update_checksum();
+            }
+            loop {
+                let _ = device_writer.write_ipv4(&mut buf);
+                if count < 3 {
+                    count += 1;
+                    std::thread::sleep(Duration::from_secs(20))
+                } else {
+                    std::thread::sleep(Duration::from_secs(125))
+                }
+            }
+        });
+        Self {
+            multicast,
+            members,
+        }
+    }
+    pub fn load(&self, multicast_addr: &Ipv4Addr) -> Option<Arc<RwLock<Multicast>>> {
+        self.multicast.get(multicast_addr)
+    }
+    pub fn handle(&self, buf: &[u8], source: Ipv4Addr) -> crate::Result<()> {
+        match IgmpType::from(buf[0]) {
+            IgmpType::Query => {}
+            IgmpType::ReportV1 | IgmpType::ReportV2 => {
+                //加入组播，v1和v2差不多
+                let report = IgmpV2Packet::new(buf)?;
+                let multicast_addr = report.group_address();
+                if !multicast_addr.is_multicast() {
+                    return Ok(());
+                }
+                let multi = self.multicast.get_with(multicast_addr, || {
+                    Arc::new(RwLock::new(Multicast::new()))
+                });
+                let mut guard = multi.write();
+                guard.members.insert(source);
+                drop(guard);
+                self.members.insert((multicast_addr, source), ());
+            }
+            IgmpType::LeaveV2 => {
+                //退出组播
+                let leave = IgmpV2Packet::new(buf)?;
+                let multicast_addr = leave.group_address();
+                if !multicast_addr.is_multicast() {
+                    return Ok(());
+                }
+                self.members.invalidate(&(multicast_addr, source));
+            }
+            IgmpType::ReportV3 => {
+                let report = IgmpV3ReportPacket::new(buf)?;
+                if let Some(group_records) = report.group_records() {
+                    for group_record in group_records {
+                        let multicast_addr = group_record.multicast_address();
+                        if !multicast_addr.is_multicast() {
+                            return Ok(());
+                        }
+                        let multi = self.multicast.get_with(multicast_addr, || {
+                            Arc::new(RwLock::new(Multicast::new()))
+                        });
+                        let mut guard = multi.write();
+
+                        match group_record.record_type() {
+                            IgmpV3RecordType::ModeIsInclude | IgmpV3RecordType::ChangeToIncludeMode => {
+                                match group_record.source_addresses() {
+                                    None => {
+                                        //不接收所有
+                                        guard.members.remove(&source);
+                                        guard.map.remove(&source);
+                                    }
+                                    Some(src) => {
+                                        guard.members.insert(source);
+                                        guard.map.insert(source, (true, HashSet::from_iter(src)));
+                                        drop(guard);
+                                        self.members.insert((multicast_addr, source), ());
+                                    }
+                                }
+                            }
+
+                            IgmpV3RecordType::ModeIsExclude | IgmpV3RecordType::ChangeToExcludeMode => {
+                                match group_record.source_addresses() {
+                                    None => {
+                                        //接收所有
+                                        guard.members.insert(source);
+                                        guard.map.remove(&source);
+                                    }
+                                    Some(src) => {
+                                        guard.members.insert(source);
+                                        guard.map.insert(source, (false, HashSet::from_iter(src)));
+                                    }
+                                }
+                                drop(guard);
+                                self.members.insert((multicast_addr, source), ());
+                            }
+                            IgmpV3RecordType::AllowNewSources => {
+                                //在已有源的基础上，接收目标源，如果是排除模式，则删除；是包含模式则添加
+                                match group_record.source_addresses() {
+                                    None => {}
+                                    Some(src) => {
+                                        match guard.map.get_mut(&source) {
+                                            None => {}
+                                            Some((is_include, set)) => {
+                                                for ip in src {
+                                                    if *is_include {
+                                                        set.insert(ip);
+                                                    } else {
+                                                        set.remove(&ip);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                drop(guard);
+                                self.members.insert((multicast_addr, source), ());
+                            }
+                            IgmpV3RecordType::BlockOldSources => {
+                                //在已有源的基础上，不接收目标源
+                                match group_record.source_addresses() {
+                                    None => {}
+                                    Some(src) => {
+                                        match guard.map.get_mut(&source) {
+                                            None => {}
+                                            Some((is_include, set)) => {
+                                                for ip in src {
+                                                    if *is_include {
+                                                        set.remove(&ip);
+                                                    } else {
+                                                        set.insert(ip);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                drop(guard);
+                                self.members.insert((multicast_addr, source), ());
+                            }
+                            IgmpV3RecordType::Unknown(_) => {}
+                        }
+                    }
+                }
+            }
+            IgmpType::Unknown(_) => {}
+        }
+        Ok(())
+    }
+}

switch/src/ip_proxy/icmp_proxy.rs

@@ -0,0 +1,131 @@
+use std::io;
+use std::mem::MaybeUninit;
+use std::net::{IpAddr, Ipv4Addr, SocketAddrV4};
+use std::sync::Arc;
+use crossbeam::atomic::AtomicCell;
+
+use crossbeam_skiplist::SkipMap;
+use socket2::{Domain, SockAddr, Socket, Type};
+
+use packet::icmp::icmp;
+use packet::icmp::icmp::HeaderOther;
+use packet::ip::ipv4;
+use crate::channel::sender::ChannelSender;
+use crate::handle::CurrentDeviceInfo;
+use crate::protocol::{MAX_TTL, NetPacket, Protocol, Version};
+
+pub struct IcmpProxy {
+    icmp_socket: Arc<Socket>,
+    // 对端-> 真实来源
+    icmp_proxy_map: Arc<SkipMap<(Ipv4Addr, u16, u16), Ipv4Addr>>,
+    sender: ChannelSender,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+}
+
+impl IcmpProxy {
+    pub fn new(addr: SocketAddrV4, icmp_proxy_map: Arc<SkipMap<(Ipv4Addr, u16, u16), Ipv4Addr>>, sender: ChannelSender, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) -> io::Result<IcmpProxy> {
+        let icmp_socket = Arc::new(Socket::new(Domain::IPV4, Type::RAW, Some(socket2::Protocol::ICMPV4))?);
+        icmp_socket.bind(&SockAddr::from(addr))?;
+        // // 设置 SIO_RCVALL 参数
+        // #[cfg(windows)]
+        // {
+        //     use std::os::windows::io::AsRawSocket;
+        //     let raw_fd = icmp_socket.as_raw_socket();
+        //     let mut rcvall: winapi::shared::minwindef::DWORD = 1;
+        //     let mut bytes_returned: winapi::shared::minwindef::DWORD = 0;
+        //     let result = unsafe {
+        //         winapi::um::winsock2::WSAIoctl(
+        //             raw_fd as _,
+        //             winapi::shared::mstcpip::SIO_RCVALL,
+        //             &mut rcvall as *mut winapi::shared::minwindef::DWORD as *mut std::ffi::c_void,
+        //             std::mem::size_of::<winapi::shared::minwindef::DWORD>() as winapi::shared::minwindef::DWORD,
+        //             std::ptr::null_mut(),
+        //             0,
+        //             &mut bytes_returned as winapi::shared::minwindef::LPDWORD,
+        //             std::ptr::null_mut(),
+        //             None,
+        //         )
+        //     };
+        //     if result != 0 {
+        //         return Err(io::Error::from_raw_os_error(unsafe { winapi::um::winsock2::WSAGetLastError() }));
+        //     }
+        // }
+        Ok(IcmpProxy {
+            icmp_socket,
+            icmp_proxy_map,
+            sender,
+            current_device,
+        })
+    }
+    pub fn icmp_socket(&self) ->Arc<Socket>{
+        self.icmp_socket.clone()
+    }
+    pub fn start(self) {
+        let mut buf = [0 as u8; 1500];
+        let data: &mut [MaybeUninit<u8>] =
+            unsafe { std::mem::transmute(&mut buf[..]) };
+        let mut net_packet = NetPacket::new([0u8; 4 + 8 + 1500]).unwrap();
+        net_packet.set_version(Version::V1);
+        net_packet.set_protocol(Protocol::IpTurn);
+        net_packet.set_transport_protocol(ipv4::protocol::Protocol::Icmp.into());
+        net_packet.set_ttl(MAX_TTL);
+        loop {
+            match self.recv(data) {
+                Ok((len, peer_ip)) => {
+                    match peer_ip {
+                        IpAddr::V4(peer_ip) => {
+                            match ipv4::packet::IpV4Packet::new(&mut buf[..len]) {
+                                Ok(mut ipv4_packet) => {
+                                    match icmp::IcmpPacket::new(ipv4_packet.payload()) {
+                                        Ok(icmp_packet) => {
+                                            match icmp_packet.header_other() {
+                                                HeaderOther::Identifier(id, seq) => {
+                                                    if let Some(entry) = self.icmp_proxy_map.get(&(peer_ip, id, seq)) {
+                                                        //将数据发送到真实的来源
+                                                        let dest_ip = *entry.value();
+                                                        ipv4_packet.set_destination_ip(dest_ip);
+                                                        ipv4_packet.update_checksum();
+                                                        let virtual_ip = self.current_device.load().virtual_ip();
+                                                        net_packet.set_source(virtual_ip);
+                                                        net_packet.set_destination(dest_ip);
+                                                        let data_len = ipv4_packet.buffer.len();
+                                                        net_packet.set_payload(ipv4_packet.buffer);
+                                                        let _ = self.sender.try_send_by_id(&net_packet.buffer()[..(12 + data_len)], &dest_ip);
+                                                    }
+                                                }
+                                                _ => {
+                                                    continue;
+                                                }
+                                            }
+                                        }
+                                        Err(_) => {}
+                                    };
+                                }
+                                Err(_) => {}
+                            }
+                        }
+                        IpAddr::V6(_) => {}
+                    }
+                }
+                Err(e) => {
+                    log::warn!("icmp代理异常:{:?}",e);
+                }
+            }
+        }
+    }
+    fn recv(&self, buf: &mut [MaybeUninit<u8>]) -> io::Result<(usize, IpAddr)> {
+        let (size, addr) = self.icmp_socket.recv_from(buf)?;
+        let addr = match addr.as_socket() {
+            None => {
+                IpAddr::V4(Ipv4Addr::UNSPECIFIED)
+            }
+            Some(add) => {
+                add.ip()
+            }
+        };
+        Ok((size, addr))
+    }
+    // fn send_to(&self, buf: &[u8], addr: SocketAddrV4) -> io::Result<usize> {
+    //     self.icmp_socket.send_to(buf, &SockAddr::from(addr))
+    // }
+}

switch/src/ip_proxy/mod.rs

@@ -0,0 +1,90 @@
+use std::{io, thread};
+use std::collections::HashMap;
+use std::net::{Ipv4Addr, SocketAddrV4};
+use std::sync::Arc;
+use crossbeam::atomic::AtomicCell;
+use crossbeam_skiplist::SkipMap;
+use socket2::{SockAddr, Socket};
+use tokio::net::{TcpListener, UdpSocket};
+use crate::channel::sender::ChannelSender;
+use crate::handle::CurrentDeviceInfo;
+use crate::ip_proxy::icmp_proxy::IcmpProxy;
+use crate::ip_proxy::tcp_proxy::TcpProxy;
+use crate::ip_proxy::udp_proxy::UdpProxy;
+
+pub mod icmp_proxy;
+pub mod tcp_proxy;
+pub mod udp_proxy;
+
+#[derive(Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Debug)]
+pub enum Protocol {
+    Icmp,
+    Tcp,
+    Udp,
+}
+
+#[derive(Clone)]
+pub struct IpProxyMap {
+    pub(crate) tcp_proxy_port: u16,
+    pub(crate) udp_proxy_port: u16,
+    //真实源地址 -> (绑定地址,目的地址)
+    pub(crate) tcp_proxy_map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>>,
+    pub(crate) udp_proxy_map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>>,
+    // icmp用Identifier来区分，没有Identifier的一律不转发
+    pub(crate) icmp_proxy_map: Arc<SkipMap<(Ipv4Addr, u16, u16), Ipv4Addr>>,
+    icmp_sockets: HashMap<Ipv4Addr, Arc<Socket>>,
+}
+
+impl IpProxyMap {
+    pub fn send_icmp(&self, buf: &[u8], src: &Ipv4Addr, dest: &Ipv4Addr) -> io::Result<usize> {
+        if let Some(socket) = self.icmp_sockets.get(src) {
+            socket.send_to(buf, &SockAddr::from(SocketAddrV4::new(*dest, 0)))
+        } else {
+            Err(io::Error::new(io::ErrorKind::Other, format!("not found src:{},dest:{}", src, dest)))
+        }
+    }
+}
+
+pub async fn init_proxy(sender: ChannelSender, bind_ips: Vec<Ipv4Addr>, current_device: Arc<AtomicCell<CurrentDeviceInfo>>) -> io::Result<IpProxyMap> {
+    let mut icmp_sockets = HashMap::new();
+    let tcp_proxy_map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>> = Arc::new(SkipMap::new());
+    let udp_proxy_map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>> = Arc::new(SkipMap::new());
+    let icmp_proxy_map: Arc<SkipMap<(Ipv4Addr, u16, u16), Ipv4Addr>> = Arc::new(SkipMap::new());
+    let (tcp_proxy_port, udp_proxy_port) = if !bind_ips.is_empty() {
+        let tcp_listener = TcpListener::bind("0.0.0.0:0").await?;
+        let udp_socket = UdpSocket::bind("0.0.0.0:0").await?;
+        let tcp_proxy_port = tcp_listener.local_addr()?.port();
+        let udp_proxy_port = udp_socket.local_addr()?.port();
+        let tcp_proxy_map = tcp_proxy_map.clone();
+        tokio::spawn(async {
+            let tcp_proxy = TcpProxy::new(tcp_listener, tcp_proxy_map);
+            tcp_proxy.start().await
+        });
+        let udp_proxy_map = udp_proxy_map.clone();
+        tokio::spawn(async {
+            let udp_proxy = UdpProxy::new(udp_socket, udp_proxy_map);
+            udp_proxy.start().await
+        });
+        (tcp_proxy_port, udp_proxy_port)
+    } else {
+        (0, 0)
+    };
+    for ip in bind_ips {
+        let addr = SocketAddrV4::new(ip, 0);
+        let icmp_proxy_map = icmp_proxy_map.clone();
+        let icmp_proxy = IcmpProxy::new(addr, icmp_proxy_map, sender.clone(), current_device.clone())?;
+        icmp_sockets.insert(ip, icmp_proxy.icmp_socket());
+        thread::spawn(move || {
+            icmp_proxy.start();
+        });
+    }
+
+    Ok(IpProxyMap {
+        tcp_proxy_port,
+        udp_proxy_port,
+        tcp_proxy_map,
+        udp_proxy_map,
+        icmp_proxy_map,
+        icmp_sockets,
+    })
+}

switch/src/ip_proxy/tcp_proxy.rs

@@ -0,0 +1,70 @@
+use std::io;
+use std::net::{SocketAddr, SocketAddrV4};
+use std::sync::Arc;
+use crossbeam_skiplist::SkipMap;
+use tokio::net::{TcpListener, TcpStream};
+
+pub struct TcpProxy {
+    tcp_listener: TcpListener,
+    //  todo 怎么过期
+    map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>>,
+}
+
+impl TcpProxy {
+    pub fn new(tcp_listener: TcpListener, map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>>) -> Self {
+        Self {
+            tcp_listener,
+            map,
+        }
+    }
+    pub async fn start(self)  {
+        let tcp_listener = self.tcp_listener;
+        let map = self.map;
+        loop {
+            match tcp_listener.accept().await {
+                Ok((tcp_stream, sender_addr)) => {
+                    match sender_addr {
+                        SocketAddr::V4(sender_addr) => {
+                            if let Some(entry) = map.get(&sender_addr) {
+                                let (src_addr, dest_addr) = *entry.value();
+                                let peer_tcp_stream = match TcpStream::connect(dest_addr).await {
+                                    Ok(peer_tcp_stream) => {peer_tcp_stream}
+                                    Err(e) => {
+                                        log::warn!("tcp代理异常:{:?},来源:{},目标：{}",e,src_addr,dest_addr);
+                                        continue;
+                                    }
+                                };
+                                tokio::spawn(async move {
+                                    match proxy(tcp_stream, peer_tcp_stream).await {
+                                        Ok(_) => {}
+                                        Err(e) => {
+                                            log::warn!("tcp代理异常:{:?},来源:{},目标：{}",e,src_addr,dest_addr);
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                        SocketAddr::V6(_) => {}
+                    }
+
+                }
+                Err(e) => {
+                    log::warn!("tcp代理监听:{:?}",e);
+                }
+            }
+
+        }
+    }
+}
+
+async fn proxy(mut client: TcpStream, mut server: TcpStream) -> io::Result<()> {
+    let (mut client_reader, mut client_writer) = client.split();
+    let (mut server_reader, mut server_writer) = server.split();
+
+    let client_to_server = tokio::io::copy(&mut client_reader, &mut server_writer);
+    let server_to_client = tokio::io::copy(&mut server_reader, &mut client_writer);
+
+    tokio::try_join!(client_to_server, server_to_client)?;
+
+    Ok(())
+}

switch/src/ip_proxy/udp_proxy.rs

@@ -0,0 +1,96 @@
+use std::io;
+use std::net::{SocketAddr, SocketAddrV4};
+use std::sync::Arc;
+use std::time::Duration;
+use crossbeam_skiplist::SkipMap;
+use tokio::net::UdpSocket;
+
+/// 一个udp代理，作用是利用系统协议栈，将udp数据报解析出来再转发到目的地址
+pub struct UdpProxy {
+    udp_socket: Arc<UdpSocket>,
+    //  todo 过期处理
+    map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>>,
+}
+
+impl UdpProxy {
+    pub fn new(udp_socket: UdpSocket, map: Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>>) -> Self {
+        let udp_socket = Arc::new(udp_socket);
+        Self {
+            udp_socket,
+            map,
+        }
+    }
+    pub async fn start(self) {
+        let map = self.map;
+        let udp_socket = self.udp_socket;
+        let mut buf = [0u8; 65536];
+        let inner_map: Arc<SkipMap<SocketAddrV4, Arc<UdpSocket>>> = Arc::new(SkipMap::new());
+
+        loop {
+            match udp_socket.recv_from(&mut buf).await {
+                Ok((len, sender_addr)) => {
+                    match sender_addr {
+                        SocketAddr::V4(sender_addr) => {
+                            match start0(&buf[..len], sender_addr, &inner_map, &map, &udp_socket).await {
+                                Ok(_) => {}
+                                Err(e) => {
+                                    log::warn!("udp代理异常:{:?},来源:{}",e,sender_addr);
+                                }
+                            }
+                        }
+                        SocketAddr::V6(_) => {}
+                    }
+                }
+                Err(e) => {
+                    log::warn!("udp代理异常:{:?}",e);
+                }
+            };
+        }
+    }
+}
+
+async fn start0(buf: &[u8], sender_addr: SocketAddrV4, inner_map: &Arc<SkipMap<SocketAddrV4, Arc<UdpSocket>>>, map: &Arc<SkipMap<SocketAddrV4, (SocketAddrV4, SocketAddrV4)>>, udp_socket: &Arc<UdpSocket>) -> io::Result<()> {
+    if let Some(entry) = inner_map.get(&sender_addr) {
+        entry.value().send(buf).await?;
+    } else if let Some(entry) = map.get(&sender_addr) {
+        let (src_addr, dest_addr) = *entry.value();
+        let peer_udp_socket = UdpSocket::bind("0.0.0.0:0").await?;
+        peer_udp_socket.connect(dest_addr).await?;
+        peer_udp_socket.send(buf).await?;
+        let peer_udp_socket = Arc::new(peer_udp_socket);
+        let inner_map = inner_map.clone();
+        inner_map.insert(sender_addr, peer_udp_socket.clone());
+        let udp_socket = udp_socket.clone();
+        tokio::spawn(async move {
+            let mut buf = [0u8; 65536];
+            loop {
+                match tokio::time::timeout(Duration::from_secs(300), peer_udp_socket.recv(&mut buf)).await {
+                    Ok(rs) => {
+                        match rs {
+                            Ok(len) => {
+                                match udp_socket.send_to(&buf[..len], sender_addr).await {
+                                    Ok(_) => {}
+                                    Err(e) => {
+                                        log::warn!("udp代理异常:{:?},来源:{},目标：{}",e,src_addr,dest_addr);
+                                        break;
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                log::warn!("udp代理异常:{:?},来源:{},目标：{}",e,src_addr,dest_addr);
+                                break;
+                            }
+                        }
+                    }
+                    Err(_) => {
+                        //超时关闭
+                        log::warn!("udp代理超时关闭,来源:{},目标：{}",src_addr,dest_addr);
+                        break;
+                    }
+                }
+            }
+            inner_map.remove(&sender_addr);
+        });
+    }
+    Ok(())
+}

switch/src/lib.rs

@@ -1,8 +1,5 @@
 use crate::error::Error;
 
-
-pub use p2p_channel::channel::{Route, RouteKey};
-
 pub type Result<T> = std::result::Result<T, Error>;
 
 pub mod error;
@@ -10,5 +7,9 @@ pub mod handle;
 pub mod nat;
 pub mod proto;
 pub mod protocol;
-pub mod tun_device;
+pub mod ip_proxy;
+pub mod external_route;
+pub mod igmp_server;
+pub mod tun_tap_device;
 pub mod core;
+pub mod channel;

switch/src/nat/check.rs

@@ -2,8 +2,7 @@ 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::channel::punch::NatType;
 
 // #[derive(Debug, Copy, Clone, PartialEq)]
 // pub enum NatType {

switch/src/nat/mod.rs

@@ -1,19 +1,26 @@
+use crate::proto::message::PunchNatType;
+use parking_lot::Mutex;
 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;
+use crate::channel::punch::{NatInfo, NatType};
 
-pub fn local_ip() -> io::Result<IpAddr> {
+pub fn local_ip() -> io::Result<Ipv4Addr> {
     let socket = UdpSocket::bind("0.0.0.0:0")?;
     socket.connect("8.8.8.8:80")?;
     let addr = socket.local_addr()?;
-    Ok(addr.ip())
+    match addr.ip() {
+        IpAddr::V4(ip) => {
+            Ok(ip)
+        }
+        IpAddr::V6(_) => {
+            Ok(Ipv4Addr::UNSPECIFIED)
+        }
+    }
 }
 
 #[derive(Clone)]
@@ -26,7 +33,7 @@ impl From<NatType> for PunchNatType {
     fn from(value: NatType) -> Self {
         match value {
             NatType::Symmetric => PunchNatType::Symmetric,
-            NatType::Cone => PunchNatType::Cone
+            NatType::Cone => PunchNatType::Cone,
         }
     }
 }
@@ -35,14 +42,26 @@ impl Into<NatType> for PunchNatType {
     fn into(self) -> NatType {
         match self {
             PunchNatType::Symmetric => NatType::Symmetric,
-            PunchNatType::Cone => NatType::Cone
+            PunchNatType::Cone => NatType::Cone,
         }
     }
 }
 
 impl NatTest {
-    pub fn new(nat_test_server: Vec<SocketAddr>, 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);
+    pub fn new(
+        nat_test_server: Vec<SocketAddr>,
+        public_ip: Ipv4Addr,
+        public_port: u16,
+        local_ip: Ipv4Addr,
+        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)),
@@ -51,37 +70,59 @@ impl NatTest {
     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);
+    pub fn re_test(
+        &self,
+        public_ip: Ipv4Addr,
+        public_port: u16,
+        local_ip: Ipv4Addr,
+        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<SocketAddr>, public_ip: Ipv4Addr, public_port: u16, local_ip: IpAddr, local_port: u16) -> NatInfo {
+    fn re_test_(
+        nat_test_server: &Vec<SocketAddr>,
+        public_ip: Ipv4Addr,
+        public_port: u16,
+        local_ip: Ipv4Addr,
+        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));
+                public_ips.push(Ipv4Addr::from(public_ip));
                 for ip in ips {
                     if ip != public_ip {
-                        public_ips.push(IpAddr::from(ip));
+                        public_ips.push(ip);
                     }
                 }
-                NatInfo::new(public_ips,
-                             public_port,
-                             port_range,
-                             local_ip, local_port,
-                             nat_type, )
+                NatInfo::new(
+                    public_ips,
+                    public_port,
+                    port_range,
+                    local_ip,
+                    local_port,
+                    nat_type,
+                )
             }
             Err(e) => {
-                log::warn!("{:?}",e);
+                log::warn!("{:?}", e);
                 NatInfo::new(
-                    vec![IpAddr::from(public_ip)],
+                    vec![public_ip],
                     public_port,
                     0,
-                    local_ip, local_port,
+                    local_ip,
+                    local_port,
                     NatType::Cone,
                 )
             }
         };
     }
-}
+}

switch/src/proto/message.rs

@@ -37,6 +37,8 @@ pub struct RegistrationRequest {
     pub name: ::std::string::String,
     // @@protoc_insertion_point(field:RegistrationRequest.is_fast)
     pub is_fast: bool,
+    // @@protoc_insertion_point(field:RegistrationRequest.version)
+    pub version: ::std::string::String,
     // special fields
     // @@protoc_insertion_point(special_field:RegistrationRequest.special_fields)
     pub special_fields: ::protobuf::SpecialFields,
@@ -54,7 +56,7 @@ impl RegistrationRequest {
     }
 
     fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(4);
+        let mut fields = ::std::vec::Vec::with_capacity(5);
         let mut oneofs = ::std::vec::Vec::with_capacity(0);
         fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
             "token",
@@ -76,6 +78,11 @@ impl RegistrationRequest {
             |m: &RegistrationRequest| { &m.is_fast },
             |m: &mut RegistrationRequest| { &mut m.is_fast },
         ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "version",
+            |m: &RegistrationRequest| { &m.version },
+            |m: &mut RegistrationRequest| { &mut m.version },
+        ));
         ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationRequest>(
             "RegistrationRequest",
             fields,
@@ -106,6 +113,9 @@ impl ::protobuf::Message for RegistrationRequest {
                 32 => {
                     self.is_fast = is.read_bool()?;
                 },
+                42 => {
+                    self.version = is.read_string()?;
+                },
                 tag => {
                     ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                 },
@@ -130,6 +140,9 @@ impl ::protobuf::Message for RegistrationRequest {
         if self.is_fast != false {
             my_size += 1 + 1;
         }
+        if !self.version.is_empty() {
+            my_size += ::protobuf::rt::string_size(5, &self.version);
+        }
         my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
         self.special_fields.cached_size().set(my_size as u32);
         my_size
@@ -148,6 +161,9 @@ impl ::protobuf::Message for RegistrationRequest {
         if self.is_fast != false {
             os.write_bool(4, self.is_fast)?;
         }
+        if !self.version.is_empty() {
+            os.write_string(5, &self.version)?;
+        }
         os.write_unknown_fields(self.special_fields.unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -169,6 +185,7 @@ impl ::protobuf::Message for RegistrationRequest {
         self.device_id.clear();
         self.name.clear();
         self.is_fast = false;
+        self.version.clear();
         self.special_fields.clear();
     }
 
@@ -178,6 +195,7 @@ impl ::protobuf::Message for RegistrationRequest {
             device_id: ::std::string::String::new(),
             name: ::std::string::String::new(),
             is_fast: false,
+            version: ::std::string::String::new(),
             special_fields: ::protobuf::SpecialFields::new(),
         };
         &instance
@@ -1017,28 +1035,29 @@ impl PunchNatType {
 }
 
 static file_descriptor_proto_data: &'static [u8] = b"\
-    \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\
+    \n\rmessage.proto\"\x8f\x01\n\x13RegistrationRequest\x12\x14\n\x05token\
+    \x18\x01\x20\x01(\tR\x05token\x12\x1b\n\tdevice_id\x18\x02\x20\x01(\tR\
+    \x08deviceId\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\x17\n\x07\
+    is_fast\x18\x04\x20\x01(\x08R\x06isFast\x12\x18\n\x07version\x18\x05\x20\
+    \x01(\tR\x07version\"\x92\x02\n\x14RegistrationResponse\x12\x1d\n\nvirtu\
+    al_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12'\n\x0fvirtual_gateway\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\x05e\
+    poch\x125\n\x10device_info_list\x18\x05\x20\x03(\x0b2\x0b.DeviceInfoR\
+    \x0edeviceInfoList\x12\x1b\n\tpublic_ip\x18\x06\x20\x01(\x07R\x08publicI\
+    p\x12\x1f\n\x0bpublic_port\x18\x07\x20\x01(\rR\npublicPort\"d\n\nDeviceI\
+    nfo\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x1d\n\nvirtual_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.Device\
+    InfoR\x0edeviceInfoList\"\xf8\x01\n\tPunchInfo\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\r.PunchNatT\
+    ypeR\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_por\
+    t\x18\x08\x20\x01(\rR\tlocalPort*'\n\x0cPunchNatType\x12\r\n\tSymmetric\
+    \x10\0\x12\x08\n\x04Cone\x10\x01b\x06proto3\
 ";
 
 /// `FileDescriptorProto` object which was a source for this generated file

switch/src/protocol/control_packet.rs

@@ -1,6 +1,5 @@
 use std::{fmt, io};
 
-
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
 pub enum Protocol {
     /// ping请求
@@ -18,7 +17,7 @@ pub enum Protocol {
     PunchRequest,
     /// 打洞响应
     PunchResponse,
-    UnKnow(u8),
+    Unknown(u8),
 }
 
 impl From<u8> for Protocol {
@@ -28,7 +27,7 @@ impl From<u8> for Protocol {
             2 => Protocol::Pong,
             3 => Protocol::PunchRequest,
             4 => Protocol::PunchResponse,
-            val => Protocol::UnKnow(val),
+            val => Protocol::Unknown(val),
         }
     }
 }
@@ -40,7 +39,7 @@ impl Into<u8> for Protocol {
             Protocol::Pong => 2,
             Protocol::PunchRequest => 3,
             Protocol::PunchResponse => 4,
-            Protocol::UnKnow(val) => val,
+            Protocol::Unknown(val) => val,
         }
     }
 }
@@ -59,18 +58,17 @@ impl<B: AsRef<[u8]>> ControlPacket<B> {
             Protocol::Pong => Ok(ControlPacket::PongPacket(PongPacket::new(buffer)?)),
             Protocol::PunchRequest => Ok(ControlPacket::PunchRequest),
             Protocol::PunchResponse => Ok(ControlPacket::PunchResponse),
-            Protocol::UnKnow(_) => Err(io::Error::new(io::ErrorKind::InvalidData, "Unsupported")),
+            Protocol::Unknown(_) => Err(io::Error::new(io::ErrorKind::InvalidData, "Unsupported")),
         }
     }
 }
 
 /// 网络探针
-#[derive(Copy, Clone)]
 pub struct PingPacket<B> {
     buffer: B,
 }
 
-type PongPacket<B> = PingPacket<B>;
+pub type PongPacket<B> = PingPacket<B>;
 
 impl<B: AsRef<[u8]>> PingPacket<B> {
     pub fn new(buffer: B) -> io::Result<PingPacket<B>> {
@@ -107,4 +105,4 @@ impl<B: AsRef<[u8]>> fmt::Debug for PingPacket<B> {
             .field("epoch", &self.epoch())
             .finish()
     }
-}
+}

switch/src/protocol/ip_turn_packet.rs

@@ -0,0 +1,105 @@
+use std::io;
+use std::net::Ipv4Addr;
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum Protocol {
+    Icmp,
+    Igmp,
+    Ipv4,
+    Ipv4Broadcast,
+    Unknown(u8),
+}
+
+impl From<u8> for Protocol {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Protocol::Icmp,
+            2 => Protocol::Igmp,
+            4 => Protocol::Ipv4,
+            201 => Protocol::Ipv4Broadcast,
+            val => Protocol::Unknown(val),
+        }
+    }
+}
+
+impl Into<u8> for Protocol {
+    fn into(self) -> u8 {
+        match self {
+            Protocol::Icmp => 1,
+            Protocol::Igmp => 2,
+            Protocol::Ipv4 => 4,
+            Protocol::Ipv4Broadcast => 201,
+            Protocol::Unknown(val) => val,
+        }
+    }
+}
+
+pub struct BroadcastPacketEnd<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> BroadcastPacketEnd<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> io::Result<Self> {
+        let len = buffer.as_ref().len();
+        let packet = Self::unchecked(buffer);
+        if len < 1 || packet.len() != len {
+            Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "InvalidData",
+            ))
+        } else {
+            Ok(packet)
+        }
+    }
+}
+
+impl<B: AsRef<[u8]>> BroadcastPacketEnd<B> {
+    pub fn len(&self) -> usize {
+        1 + self.num() as usize * 4
+    }
+    pub fn num(&self) -> u8 {
+        let len = self.buffer.as_ref().len();
+        self.buffer.as_ref()[len - 1]
+    }
+    /// 已经发送给了这些地址
+    /// 从尾往头拿
+    pub fn addresses(&self) -> Vec<Ipv4Addr> {
+        let num = self.num() as usize;
+        let mut list = Vec::with_capacity(num);
+        let buf = self.buffer.as_ref();
+        let mut offset = buf.len() + 4 - 2;
+        for _ in 0..num {
+            offset -= 4;
+            list.push(Ipv4Addr::new(buf[offset - 3], buf[offset - 2], buf[offset - 1], buf[offset]));
+        }
+        list
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> BroadcastPacketEnd<B> {
+    /// 从头往尾放
+    pub fn set_address(&mut self, addr: &[Ipv4Addr]) -> io::Result<()> {
+        let buf = self.buffer.as_mut();
+        if buf.len() < 1 + addr.len() * 4 || addr.len() > u8::MAX as usize {
+            Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "InvalidData",
+            ))
+        } else {
+            let mut offset = 0;
+            for ip in addr {
+                buf[offset..offset + 4].copy_from_slice(&ip.octets());
+                offset += 4;
+            }
+            self.buffer.as_mut()[offset] = addr.len() as u8;
+            Ok(())
+        }
+    }
+}
+
+
+
+

switch/src/protocol/mod.rs

@@ -1,24 +1,25 @@
-use std::{fmt, io};
 use std::net::Ipv4Addr;
+use std::{fmt, io};
 
 /*
-    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)                                       |
-   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-   |                                           数据体                                              |
-   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
- */
+   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
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  | p|unused|  版本(4)   |      协议(8)          |      上层协议(8)        | 初始ttl(4) | 生存时间(4) |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                                          源ip地址(32)                                         |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                                          目的ip地址(32)                                       |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                                           数据体                                              |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+*/
 
 pub mod control_packet;
 pub mod error_packet;
 pub mod service_packet;
-pub mod turn_packet;
+pub mod ip_turn_packet;
+pub mod other_turn_packet;
 
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
 pub enum Version {
@@ -52,8 +53,8 @@ pub enum Protocol {
     Error,
     /// 控制协议
     Control,
-    /// 转发ipv4数据
-    Ipv4Turn,
+    /// 转发ip数据
+    IpTurn,
     /// 转发其他数据
     OtherTurn,
     UnKnow(u8),
@@ -65,7 +66,7 @@ impl From<u8> for Protocol {
             1 => Protocol::Service,
             2 => Protocol::Error,
             3 => Protocol::Control,
-            4 => Protocol::Ipv4Turn,
+            4 => Protocol::IpTurn,
             5 => Protocol::OtherTurn,
             val => Protocol::UnKnow(val),
         }
@@ -78,7 +79,7 @@ impl Into<u8> for Protocol {
             Protocol::Service => 1,
             Protocol::Error => 2,
             Protocol::Control => 3,
-            Protocol::Ipv4Turn => 4,
+            Protocol::IpTurn => 4,
             Protocol::OtherTurn => 5,
             Protocol::UnKnow(val) => val,
         }
@@ -98,7 +99,10 @@ impl<B: AsRef<[u8]>> NetPacket<B> {
         let len = buffer.as_ref().len();
         // 不能大于udp最大载荷长度
         if len < 12 || len > 65535 - 20 - 8 {
-            return Err(io::Error::new(io::ErrorKind::InvalidData, "length overflow"));
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "length overflow",
+            ));
         }
         Ok(NetPacket { buffer })
     }
@@ -111,8 +115,11 @@ impl<B: AsRef<[u8]>> NetPacket<B> {
 }
 
 impl<B: AsRef<[u8]>> NetPacket<B> {
+    pub fn is_encrypt(&self) -> bool {
+        self.buffer.as_ref()[0] & 0x80 == 0x80
+    }
     pub fn version(&self) -> Version {
-        Version::from(self.buffer.as_ref()[0])
+        Version::from(self.buffer.as_ref()[0] & 0x0F)
     }
     pub fn protocol(&self) -> Protocol {
         Protocol::from(self.buffer.as_ref()[1])
@@ -140,8 +147,19 @@ impl<B: AsRef<[u8]>> NetPacket<B> {
 }
 
 impl<B: AsRef<[u8]> + AsMut<[u8]>> NetPacket<B> {
+    pub fn buffer_mut(&mut self) -> &mut [u8] {
+        self.buffer.as_mut()
+    }
+    pub fn set_encrypt_flag(&mut self, is_encrypt: bool) {
+        if is_encrypt {
+            self.buffer.as_mut()[0] = self.buffer.as_ref()[0] | 0x80
+        } else {
+            self.buffer.as_mut()[0] = self.buffer.as_ref()[0] & 0x7F
+        };
+    }
     pub fn set_version(&mut self, version: Version) {
-        self.buffer.as_mut()[0] = version.into();
+        let v: u8 = version.into();
+        self.buffer.as_mut()[0] = (self.buffer.as_ref()[0] & 0xF0) | (0x0F & v);
     }
     pub fn set_protocol(&mut self, protocol: Protocol) {
         self.buffer.as_mut()[1] = protocol.into();

switch/src/protocol/other_turn_packet.rs

@@ -1,16 +1,14 @@
-
-
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum Protocol {
     Punch,
-    UnKnow(u8),
+    Unknown(u8),
 }
 
 impl From<u8> for Protocol {
     fn from(value: u8) -> Self {
         match value {
             1 => Protocol::Punch,
-            val => Protocol::UnKnow(val),
+            val => Protocol::Unknown(val),
         }
     }
 }
@@ -19,7 +17,7 @@ impl Into<u8> for Protocol {
     fn into(self) -> u8 {
         match self {
             Protocol::Punch => 1,
-            Protocol::UnKnow(val) => val,
+            Protocol::Unknown(val) => val,
         }
     }
 }

switch/src/protocol/service_packet.rs

@@ -8,7 +8,7 @@ pub enum Protocol {
     PollDeviceList,
     /// 推送设备列表
     PushDeviceList,
-    UnKnow(u8),
+    Unknown(u8),
 }
 
 impl From<u8> for Protocol {
@@ -18,7 +18,7 @@ impl From<u8> for Protocol {
             2 => Self::RegistrationResponse,
             3 => Self::PollDeviceList,
             4 => Self::PushDeviceList,
-            val => Self::UnKnow(val),
+            val => Self::Unknown(val),
         }
     }
 }
@@ -30,7 +30,7 @@ impl Into<u8> for Protocol {
             Self::RegistrationResponse => 2,
             Self::PollDeviceList => 3,
             Self::PushDeviceList => 4,
-            Self::UnKnow(val) => val,
+            Self::Unknown(val) => val,
         }
     }
 }

switch/src/tun_device/linux.rs

@@ -1,35 +0,0 @@
-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,
-    netmask: Ipv4Addr,
-    gateway: Ipv4Addr,
-) -> crate::error::Result<(TunWriter, TunReader)> {
-    let mut config = tun::Configuration::default();
-
-    config
-        .destination(gateway)
-        .address(address)
-        .netmask(netmask)
-        .mtu(1420)
-        // .queues(2) 用多个队列有兼容性问题
-        .up();
-    //
-    // config.platform(|config| {
-    //     config.packet_information(true);
-    // });
-
-    let dev = tun::create(&config).unwrap();
-    let packet_information = dev.has_packet_information();
-    let queue = dev.queue(0).unwrap();
-    let reader = queue.reader();
-    let writer = queue.writer();
-    Ok((
-        TunWriter(writer, packet_information, Arc::new(Mutex::new(dev))),
-        TunReader(reader, packet_information),
-    ))
-}

switch/src/tun_device/mac.rs

@@ -1,71 +0,0 @@
-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};
-
-pub fn create_tun(
-    address: Ipv4Addr,
-    netmask: Ipv4Addr,
-    gateway: Ipv4Addr,
-) -> crate::error::Result<(TunWriter, TunReader)> {
-    let mut config = tun::Configuration::default();
-
-    config
-        .destination(gateway)
-        .address(address)
-        .netmask(netmask)
-        .mtu(1420)
-        .up();
-
-    let dev = tun::create(&config).unwrap();
-    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();
-    //
-    // let cmd_str_out = Command::new("sh")
-    //     .arg("-c")
-    //     .arg(cmd_str)
-    //     .output()
-    //     .expect("sh exec error!");
-    // if !cmd_str_out.status.success(){
-    //     return Err(Error::Stop(format!("设置路由失败:{:?}", cmd_str_out)));
-    // }
-    // println!("{:?}", cmd_str_out);
-    let packet_information = dev.has_packet_information();
-    let queue = dev.queue(0).unwrap();
-    let reader = queue.reader();
-    let writer = queue.writer();
-    Ok((
-        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(())
-}

switch/src/tun_device/mod.rs

@@ -1,19 +0,0 @@
-#[cfg(any(target_os = "linux", target_os = "android"))]
-pub use linux::create_tun;
-#[cfg(target_os = "macos")]
-pub use mac::create_tun;
-#[cfg(any(unix))]
-pub use unix::{TunReader, TunWriter};
-#[cfg(target_os = "windows")]
-pub use windows::create_tun;
-#[cfg(target_os = "windows")]
-pub use windows::{TunReader, TunWriter};
-
-#[cfg(any(target_os = "linux", target_os = "android"))]
-pub mod linux;
-#[cfg(target_os = "macos")]
-pub mod mac;
-#[cfg(any(unix))]
-pub mod unix;
-#[cfg(target_os = "windows")]
-pub mod windows;

switch/src/tun_device/unix.rs

@@ -1,76 +0,0 @@
-use std::io;
-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 self, buf: &'a mut [u8]) -> io::Result<&mut [u8]> {
-        let len = self.0.read(buf)?;
-        if self.1 {
-            Ok(&mut buf[4..len])
-        } else {
-            Ok(&mut buf[..len])
-        }
-    }
-    pub fn close(&self) {
-        unsafe {
-            let raw = self.0.as_raw_fd();
-            if raw >= 0 {
-                libc::close(raw);
-            }
-        }
-    }
-}
-
-
-#[derive(Clone)]
-pub struct TunWriter(pub(crate) Writer, pub(crate) bool, pub(crate) Arc<Mutex<Device>>);
-
-impl TunWriter {
-    pub fn write(&self, packet: &[u8]) -> io::Result<()> {
-        if self.1 {
-            let mut buf = Vec::<u8>::with_capacity(4 + packet.len());
-            buf.put_u16(0);
-            #[cfg(any(target_os = "macos", target_os = "ios"))]
-            buf.put_u16(libc::PF_INET as u16);
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            buf.put_u16(libc::ETH_P_IP as u16);
-            buf.extend_from_slice(packet);
-            self.0.write_all(&buf)
-        } else {
-            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(());
-    }
-}

switch/src/tun_device/windows.rs

@@ -1,171 +0,0 @@
-use std::io;
-use std::net::Ipv4Addr;
-use std::sync::Arc;
-
-use libloading::Library;
-use parking_lot::Mutex;
-use wintun::{Adapter, Packet, Session};
-
-#[derive(Clone)]
-pub struct TunWriter(Arc<Session>, Arc<Mutex<u32>>);
-
-impl TunWriter {
-    pub fn write(&self, buf: &[u8]) -> io::Result<()> {
-        match self.0.allocate_send_packet(buf.len() as u16) {
-            Ok(mut packet) => {
-                packet.bytes_mut().copy_from_slice(buf);
-                self.0.send_packet(packet);
-                return Ok(());
-            }
-            Err(_) => {}
-        }
-        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<Session>);
-
-
-impl TunReader {
-    pub fn next(&self) -> io::Result<Packet> {
-        match self.0.receive_blocking() {
-            Ok(packet) => {
-                return Ok(packet);
-            }
-            Err(_) => {}
-        }
-        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,
-) -> 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(io::Error::new(io::ErrorKind::Other, format!("{:?}", e)));
-                }
-            },
-            Err(e) => {
-                log::error!("wintun.dll not found");
-                return Err(io::Error::new(io::ErrorKind::Other, format!("wintun.dll not found {:?}", e)));
-            }
-        }
-    };
-    let adapter = match Adapter::open(&win_tun, "Switch-V1") {
-        Ok(a) => a,
-        Err(_) => match Adapter::create(&win_tun, "Switch-V1", "Switch-V1", None) {
-            Ok(adapter) => adapter,
-
-            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
-    );
-    let set_metric = format!("netsh interface ip set interface {} metric=1", index);
-    let set_address = format!(
-        "netsh interface ip set address {} static {:?} {:?}  ", // gateway={:?}
-        index, address, netmask,
-    );
-    // 执行网卡初始化命令
-    let out = std::process::Command::new("cmd")
-        .arg("/C")
-        .arg(set_mtu)
-        .output()
-        .unwrap();
-    if !out.status.success() {
-        return Err(io::Error::new(io::ErrorKind::Other, format!("设置mtu失败: {:?}", out)));
-    }
-    let out = std::process::Command::new("cmd")
-        .arg("/C")
-        .arg(set_metric)
-        .output()
-        .unwrap();
-    if !out.status.success() {
-        return Err(io::Error::new(io::ErrorKind::Other, format!("设置接口跃点失败: {:?}", out)));
-    }
-    let out = std::process::Command::new("cmd")
-        .arg("/C")
-        .arg(set_address)
-        .output()
-        .unwrap();
-    if !out.status.success() {
-        return Err(io::Error::new(io::ErrorKind::Other, format!("设置网络地址失败: {:?}", out)));
-    }
-    let dest = {
-        let ip = address.octets();
-        let mask = netmask.octets();
-        Ipv4Addr::from([
-            ip[0] & mask[0],
-            ip[1] & mask[1],
-            ip[2] & mask[2],
-            ip[3] & mask[3],
-        ])
-    };
-    let set_route = format!(
-        "route add {:?} mask {:?} {:?} if {}",
-        dest, netmask, gateway, index
-    );
-    // 执行添加路由命令
-    let out = std::process::Command::new("cmd")
-        .arg("/C")
-        .arg(set_route)
-        .output()
-        .unwrap();
-    if !out.status.success() {
-        return Err(io::Error::new(io::ErrorKind::Other, format!("添加路由失败: {:?}", out)));
-    }
-    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(())
-}

switch/src/tun_tap_device/linux.rs

@@ -0,0 +1,121 @@
+use std::io;
+use std::net::Ipv4Addr;
+use crate::tun_tap_device::{DeviceReader, DeviceType, DeviceWriter};
+use tun::Device;
+use parking_lot::Mutex;
+use std::process::Command;
+use std::sync::Arc;
+use crate::tun_tap_device::unix::DeviceW;
+
+impl DeviceWriter {
+    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();
+        config
+            .destination(gateway)
+            .address(address)
+            .netmask(netmask)
+            .mtu(1420)
+            // .queues(2)
+            .up();
+        let mut dev = self.lock.lock();
+        if let Err(e) = dev.configure(&config) {
+            return Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", e)));
+        }
+        let name = dev.name();
+        for (address, netmask) in &self.in_ips {
+            add_route(name, *address, *netmask)?;
+        }
+        // 当前网段路由
+        // add_route(name, address, netmask)?;
+        // 广播和组播路由
+        add_route(name, Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST)?;
+        add_route(name, Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]))?;
+        return Ok(());
+    }
+}
+
+pub fn add_route(name: &str, address: Ipv4Addr, netmask: Ipv4Addr) -> io::Result<()> {
+    let route_add_str: String = format!(
+        "ip route add {:?}/{:?} dev {}",
+        address, netmask, name
+    );
+    let route_add_out = Command::new("sh")
+        .arg("-c")
+        .arg(&route_add_str)
+        .output()
+        .expect("sh exec error!");
+    if !route_add_out.status.success() {
+        return Err(io::Error::new(io::ErrorKind::Other, format!("添加路由失败: cmd:{},out:{:?}", route_add_str, route_add_out)));
+    }
+    Ok(())
+}
+
+pub fn create_device(device_type: DeviceType,
+                     address: Ipv4Addr,
+                     netmask: Ipv4Addr,
+                     gateway: Ipv4Addr,
+                     in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
+) -> io::Result<(DeviceWriter, DeviceReader)> {
+    println!("========网卡配置========");
+    let mut config = tun::Configuration::default();
+
+    config
+        .destination(gateway)
+        .address(address)
+        .netmask(netmask)
+        .mtu(1420)
+        // .queues(2) 用多个队列有兼容性问题
+        .up();
+    match device_type {
+        DeviceType::Tun => {}
+        DeviceType::Tap => {
+            config.layer(tun::Layer::L2);
+        }
+    }
+    let dev = tun::create(&config).unwrap();
+    let packet_information = dev.has_packet_information();
+    let queue = dev.queue(0).unwrap();
+    let reader = queue.reader();
+    let writer = queue.writer();
+    let name = dev.name();
+    println!("name:{:?}", name);
+    for (address, netmask) in &in_ips {
+        add_route(name, *address, *netmask)?;
+    }
+    // 当前网段路由
+    // add_route(name, address, netmask)?;
+    // 广播和组播路由
+    add_route(name, Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST)?;
+    add_route(name, Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]))?;
+    let device_w = match device_type {
+        DeviceType::Tun => {
+            DeviceW::Tun(writer)
+        }
+        DeviceType::Tap => {
+            let get_mac_cmd = format!("cat /sys/class/net/{}/address", name);
+            let mac_out = Command::new("sh")
+                .arg("-c")
+                .arg(get_mac_cmd)
+                .output()
+                .expect("sh exec error!");
+            if !mac_out.status.success() {
+                return Err(io::Error::new(io::ErrorKind::Other, format!("获取mac地址错误: {:?}", mac_out)));
+            }
+            let mac_str = String::from_utf8(mac_out.stdout).unwrap();
+            let mut mac = [0; 6];
+            let mut split = mac_str.split(":");
+            for i in 0..6 {
+                mac[i] = u8::from_str_radix(&split.next().unwrap()[..2], 16).unwrap();
+            }
+            DeviceW::Tap((writer, mac))
+        }
+    };
+    println!("========TUN网卡配置========");
+    Ok((
+        DeviceWriter::new(device_w, Arc::new(Mutex::new(dev)), in_ips, address, packet_information),
+        DeviceReader::new(reader),
+    ))
+}
+
+pub fn delete_device(_device_type: DeviceType) {}

switch/src/tun_tap_device/mac.rs

@@ -0,0 +1,114 @@
+use std::io;
+use std::net::Ipv4Addr;
+use crate::tun_tap_device::{DeviceReader, DeviceType, DeviceWriter};
+use tun::Device;
+use parking_lot::Mutex;
+use std::process::Command;
+use std::sync::Arc;
+use crate::tun_tap_device::unix::DeviceW;
+
+impl DeviceWriter {
+    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();
+        config
+            .destination(gateway)
+            .address(address)
+            .netmask(netmask)
+            .mtu(1420)
+            .up();
+        let mut dev = self.lock.lock();
+        if let Err(e) = dev.configure(&config) {
+            return Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", e)));
+        }
+        if let Err(e) = config_ip(dev.name(), address, netmask, gateway) {
+            log::error!("{}",e);
+        }
+        let name = dev.name();
+        for (address, netmask) in &self.in_ips {
+            add_route(name, *address, *netmask)?;
+        }
+        // 当前网段路由
+        add_route(name, address, netmask)?;
+        // 广播和组播路由
+        add_route(name, Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST)?;
+        add_route(name, Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]))?;
+        return Ok(());
+    }
+}
+
+pub fn create_device(device_type: DeviceType,
+                     address: Ipv4Addr,
+                     netmask: Ipv4Addr,
+                     gateway: Ipv4Addr,
+                     in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
+) -> io::Result<(DeviceWriter, DeviceReader)> {
+    match device_type {
+        DeviceType::Tun => {}
+        DeviceType::Tap => {
+            unimplemented!()
+        }
+    }
+    println!("========TUN网卡配置========");
+    let mut config = tun::Configuration::default();
+
+    config
+        .destination(gateway)
+        .address(address)
+        .netmask(netmask)
+        .mtu(1420)
+        .up();
+
+    let dev = tun::create(&config).unwrap();
+    let name = dev.name();
+    config_ip(name, address, netmask, gateway)?;
+    for (address, netmask) in &in_ips {
+        add_route(name, *address, *netmask)?;
+    }
+    // 当前网段路由
+    add_route(name, address, netmask)?;
+    // 广播和组播路由
+    add_route(name, Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST)?;
+    add_route(name, Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]))?;
+    let packet_information = dev.has_packet_information();
+    let queue = dev.queue(0).unwrap();
+    let reader = queue.reader();
+    let writer = queue.writer();
+    println!("name:{:?}", name);
+    println!("========TUN网卡配置========");
+    Ok((
+        DeviceWriter::new(DeviceW::Tun(writer), Arc::new(Mutex::new(dev)), in_ips, address, packet_information),
+        DeviceReader::new(reader),
+    ))
+}
+
+fn add_route(name: &str, address: Ipv4Addr, netmask: Ipv4Addr) -> io::Result<()> {
+    let route_add_str: String = format!(
+        "sudo route -n add -net {:?}/{:?} -interface {}",
+        address, netmask, name
+    );
+    let route_add_out = Command::new("sh")
+        .arg("-c")
+        .arg(&route_add_str)
+        .output()
+        .expect("sh exec error!");
+    if !route_add_out.status.success() {
+        return Err(io::Error::new(io::ErrorKind::Other, format!("添加路由失败: cmd:{},out:{:?}", route_add_str, route_add_out)));
+    }
+    Ok(())
+}
+
+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 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!("设置网络地址失败: cmd:{},out:{:?}", up_eth_str, up_eth_out)));
+    }
+    Ok(())
+}
+
+pub fn delete_device(_device_type: DeviceType) {}

switch/src/tun_tap_device/mod.rs

@@ -0,0 +1,32 @@
+#[cfg(target_os = "windows")]
+pub mod windows;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub mod linux;
+#[cfg(target_os = "macos")]
+pub mod mac;
+#[cfg(any(unix))]
+pub mod unix;
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub use linux::create_device;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub use linux::delete_device;
+#[cfg(any(unix))]
+pub use unix::{DeviceWriter, DeviceReader};
+
+#[cfg(target_os = "macos")]
+pub use mac::create_device;
+#[cfg(target_os = "macos")]
+pub use mac::delete_device;
+
+#[cfg(target_os = "windows")]
+pub use windows::create_device;
+#[cfg(target_os = "windows")]
+pub use windows::delete_device;
+#[cfg(target_os = "windows")]
+pub use windows::{DeviceWriter, DeviceReader};
+
+pub enum DeviceType {
+    Tun,
+    Tap,
+}

switch/src/tun_tap_device/unix.rs

@@ -0,0 +1,144 @@
+use std::io;
+use std::sync::Arc;
+
+use bytes::BufMut;
+use tun::platform::posix::{Reader, Writer};
+use std::net::Ipv4Addr;
+use std::os::unix::io::AsRawFd;
+use crossbeam::atomic::AtomicCell;
+#[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;
+use packet::ethernet;
+
+use packet::ethernet::packet::EthernetPacket;
+#[derive(Clone)]
+pub enum DeviceW {
+    Tun(Writer),
+    Tap((Writer, [u8; 6])),
+}
+
+impl DeviceW {
+    pub fn is_tun(&self) -> bool {
+        match self {
+            DeviceW::Tun(_) => {
+                true
+            }
+            DeviceW::Tap(_) => {
+                false
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct DeviceWriter {
+    writer: DeviceW,
+    pub lock: Arc<Mutex<Device>>,
+    pub in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
+    ip: Arc<AtomicCell<Ipv4Addr>>,
+    packet_information: bool,
+}
+
+impl DeviceWriter {
+    pub fn new(writer: DeviceW,lock: Arc<Mutex<Device>>, in_ips: Vec<(Ipv4Addr, Ipv4Addr)>, ip: Ipv4Addr, packet_information: bool) -> Self {
+        Self {
+            writer,
+            lock,
+            in_ips,
+            ip: Arc::new(AtomicCell::new(ip)),
+            packet_information,
+        }
+    }
+}
+
+impl DeviceWriter {
+    pub fn write(packet_information: bool, writer: &Writer, packet: &[u8]) -> io::Result<()> {
+        if packet_information {
+            let mut buf = Vec::<u8>::with_capacity(4 + packet.len());
+            buf.put_u16(0);
+            #[cfg(any(target_os = "macos", target_os = "ios"))]
+            buf.put_u16(libc::PF_INET as u16);
+            #[cfg(any(target_os = "linux", target_os = "android"))]
+            buf.put_u16(libc::ETH_P_IP as u16);
+            buf.extend_from_slice(packet);
+            writer.write_all(&buf)
+        } else {
+            writer.write_all(packet)
+        }
+    }
+    ///tun网卡写入ipv4数据
+    pub fn write_ipv4_tun(&self, buf: &[u8]) -> io::Result<()> {
+        match &self.writer {
+            DeviceW::Tun(writer) => {
+                Self::write(self.packet_information, writer, buf)
+            }
+            DeviceW::Tap(_) => {
+                Err(io::Error::from(io::ErrorKind::Unsupported))
+            }
+        }
+    }
+    /// tap网卡写入以太网帧
+    pub fn write_ethernet_tap(&self, buf: &[u8]) -> io::Result<()> {
+        match &self.writer {
+            DeviceW::Tun(_) => {
+                Err(io::Error::from(io::ErrorKind::Unsupported))
+            }
+            DeviceW::Tap((writer, _)) => {
+                Self::write(self.packet_information, writer, buf)
+            }
+        }
+    }
+    ///写入ipv4数据，头部必须留14字节，给tap写入以太网帧头
+    pub fn write_ipv4(&self, buf: &mut [u8]) -> io::Result<()> {
+        match &self.writer {
+            DeviceW::Tun(writer) => {
+                Self::write(self.packet_information, writer, &buf[14..])
+            }
+            DeviceW::Tap((writer, mac)) => {
+                let source_mac = [buf[14 + 12], buf[14 + 13], buf[14 + 14], buf[14 + 15], !mac[5], 234];
+                let mut ethernet_packet = EthernetPacket::unchecked(buf);
+                ethernet_packet.set_source(&source_mac);
+                ethernet_packet.set_destination(mac);
+                ethernet_packet.set_protocol(ethernet::protocol::Protocol::Ipv4);
+                Self::write(self.packet_information, writer, &ethernet_packet.buffer)
+            }
+        }
+    }
+    pub fn ip(&self) -> Ipv4Addr {
+        self.ip.load()
+    }
+    pub fn close(&self) -> io::Result<()> {
+        unsafe {
+            match &self.writer {
+                DeviceW::Tun(writer) => {
+                    libc::close(writer.as_raw_fd());
+                }
+                DeviceW::Tap((writer, _)) => {
+                    libc::close(writer.as_raw_fd());
+                }
+            }
+        }
+        Ok(())
+    }
+    pub fn is_tun(&self) -> bool {
+        self.writer.is_tun()
+    }
+}
+
+#[derive(Clone)]
+pub struct DeviceReader(Reader);
+
+impl DeviceReader {
+    pub fn new(device: Reader) -> Self {
+        DeviceReader(device)
+    }
+}
+
+impl DeviceReader {
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+}

switch/src/tun_tap_device/windows.rs

@@ -0,0 +1,365 @@
+use std::{io, thread};
+use std::net::Ipv4Addr;
+use std::sync::Arc;
+use std::time::Duration;
+use crossbeam::atomic::AtomicCell;
+use libloading::Library;
+use parking_lot::Mutex;
+use packet::ethernet;
+use packet::ethernet::packet::EthernetPacket;
+use win_tun_tap::{IFace, TapDevice, TunDevice};
+use crate::tun_tap_device::DeviceType;
+
+pub const TUN_INTERFACE_NAME: &str = "Switch-Tun-V1";
+pub const TUN_POOL_NAME: &str = "Switch-Tun-V1";
+pub const TAP_INTERFACE_NAME: &str = "Switch-Tap-V1";
+
+pub enum Device {
+    Tun(TunDevice),
+    Tap((TapDevice, [u8; 6])),
+}
+
+impl Device {
+    pub fn is_tun(&self) -> bool {
+        match self {
+            Device::Tun(_) => {
+                true
+            }
+            Device::Tap(_) => {
+                false
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct DeviceWriter {
+    device: Arc<Device>,
+    lock: Arc<Mutex<()>>,
+    in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
+    ip: Arc<AtomicCell<Ipv4Addr>>,
+}
+
+impl DeviceWriter {
+    pub fn new(device: Arc<Device>, in_ips: Vec<(Ipv4Addr, Ipv4Addr)>, ip: Ipv4Addr) -> Self {
+        Self {
+            device,
+            lock: Arc::new(Default::default()),
+            in_ips,
+            ip: Arc::new(AtomicCell::new(ip)),
+        }
+    }
+}
+
+impl DeviceWriter {
+    ///tun网卡写入ipv4数据
+    pub fn write_ipv4_tun(&self, buf: &[u8]) -> io::Result<()> {
+        match self.device.as_ref() {
+            Device::Tun(dev) => {
+                let mut packet = dev.allocate_send_packet(buf.len() as u16)?;
+                packet.bytes_mut().copy_from_slice(buf);
+                dev.send_packet(packet);
+                Ok(())
+            }
+            Device::Tap(_) => {
+                Err(io::Error::from(io::ErrorKind::Unsupported))
+            }
+        }
+    }
+    /// tap网卡写入以太网帧
+    pub fn write_ethernet_tap(&self, buf: &[u8]) -> io::Result<()> {
+        match self.device.as_ref() {
+            Device::Tun(_) => {
+                Err(io::Error::from(io::ErrorKind::Unsupported))
+            }
+            Device::Tap((dev, _)) => {
+                dev.write(buf)?;
+                Ok(())
+            }
+        }
+    }
+    ///写入ipv4数据，头部必须留14字节，给tap写入以太网帧头
+    pub fn write_ipv4(&self, buf: &mut [u8]) -> io::Result<()> {
+        match self.device.as_ref() {
+            Device::Tun(dev) => {
+                let mut packet = dev.allocate_send_packet((buf.len() - 14) as u16)?;
+                packet.bytes_mut().copy_from_slice(&buf[14..]);
+                dev.send_packet(packet);
+            }
+            Device::Tap((dev, mac)) => {
+                let source_mac = [buf[14 + 12], buf[14 + 13], buf[14 + 14], buf[14 + 15], !mac[5], 234];
+                let mut ethernet_packet = EthernetPacket::unchecked(buf);
+                ethernet_packet.set_source(&source_mac);
+                ethernet_packet.set_destination(mac);
+                ethernet_packet.set_protocol(ethernet::protocol::Protocol::Ipv4);
+                dev.write(&ethernet_packet.buffer)?;
+            }
+        }
+        Ok(())
+    }
+    pub fn change_ip(
+        &self,
+        address: Ipv4Addr,
+        netmask: Ipv4Addr,
+        gateway: Ipv4Addr,
+        old_netmask: Ipv4Addr,
+        old_gateway: Ipv4Addr,
+    ) -> io::Result<()> {
+        let _guard = self.lock.lock();
+        let dev: &dyn IFace = match self.device.as_ref() {
+            Device::Tun(dev) => {
+                dev as &dyn IFace
+            }
+            Device::Tap((dev, _)) => {
+                dev as &dyn IFace
+            }
+        };
+        if let Err(e) =
+            dev.delete_route(dest(old_gateway, old_gateway), old_netmask, old_gateway)
+        {
+            log::warn!("{:?}", e);
+        }
+        dev.set_ip(address, netmask)?;
+        self.ip.store(address);
+        for (address, netmask) in &self.in_ips {
+            dev.add_route(*address, *netmask, gateway, 1)?;
+        }
+        // 当前网段路由
+        dev.add_route(address, netmask, gateway, 1)?;
+        // 广播和组播路由
+        dev.add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, gateway, 1)?;
+        dev.add_route(Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]), gateway, 1)?;
+        delete_cache();
+        Ok(())
+    }
+    pub fn ip(&self) -> Ipv4Addr {
+        self.ip.load()
+    }
+    pub fn close(&self) -> io::Result<()> {
+        match self.device.as_ref() {
+            Device::Tun(dev) => {
+                dev.shutdown()
+            }
+            Device::Tap((dev, _)) => {
+                dev.shutdown()
+            }
+        }
+    }
+    pub fn is_tun(&self) -> bool {
+        self.device.is_tun()
+    }
+}
+
+fn dest(ip: Ipv4Addr, mask: Ipv4Addr) -> Ipv4Addr {
+    let ip = ip.octets();
+    let mask = mask.octets();
+    Ipv4Addr::from([
+        ip[0] & mask[0],
+        ip[1] & mask[1],
+        ip[2] & mask[2],
+        ip[3] & mask[3],
+    ])
+}
+
+#[derive(Clone)]
+pub struct DeviceReader {
+    device: Arc<Device>,
+}
+
+impl DeviceReader {
+    pub fn new(device: Arc<Device>) -> Self {
+        Self {
+            device,
+        }
+    }
+}
+
+impl DeviceReader {
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        match self.device.as_ref() {
+            Device::Tun(dev) => {
+                let packet = dev.receive_blocking()?;
+                let packet = packet.bytes();
+                let len = packet.len();
+                if len > buf.len() {
+                    return Err(io::Error::new(io::ErrorKind::InvalidData, "data too long"));
+                }
+                buf[..len].copy_from_slice(packet);
+                Ok(len)
+            }
+            Device::Tap((dev, _)) => {
+                dev.read(buf)
+            }
+        }
+    }
+}
+
+fn create_tun(
+    address: Ipv4Addr,
+    netmask: Ipv4Addr,
+    gateway: Ipv4Addr,
+    in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
+) -> io::Result<(DeviceWriter, DeviceReader)> {
+    unsafe {
+        println!("========TUN网卡配置========");
+        match Library::new("wintun.dll") {
+            Ok(lib) => match TunDevice::delete_for_name(lib, TUN_INTERFACE_NAME) {
+                Ok(_) => {
+                    thread::sleep(Duration::from_millis(5));
+                }
+                Err(_) => {}
+            },
+            Err(e) => {
+                log::error!("wintun.dll not found");
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("wintun.dll not found {:?}", e),
+                ));
+            }
+        }
+        let tun_device = match TunDevice::create(
+            Library::new("wintun.dll").unwrap(),
+            TUN_POOL_NAME,
+            TUN_INTERFACE_NAME,
+        ) {
+            Ok(tun_device) => tun_device,
+            Err(_) => {
+                thread::sleep(Duration::from_millis(200));
+                match TunDevice::create(
+                    Library::new("wintun.dll").unwrap(),
+                    TUN_POOL_NAME,
+                    TUN_INTERFACE_NAME,
+                ) {
+                    Ok(tun_device) => tun_device,
+                    Err(e) => {
+                        return Err(io::Error::new(
+                            io::ErrorKind::Other,
+                            format!("{:?}", e),
+                        ));
+                    }
+                }
+            }
+        };
+        println!("name:{:?}", tun_device.get_name()?);
+        println!("version:{:?}", tun_device.version()?);
+        tun_device.set_ip(address, netmask)?;
+        tun_device.set_metric(1)?;
+        tun_device.set_mtu(1420)?;
+        // ip代理路由
+        for (address, netmask) in &in_ips {
+            tun_device.add_route(*address, *netmask, gateway, 1)?;
+        }
+        // 当前网段路由
+        tun_device.add_route(address, netmask, gateway, 1)?;
+        // 广播和组播路由
+        tun_device.add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, gateway, 1)?;
+        tun_device.add_route(Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]), gateway, 1)?;
+        delete_cache();
+        let device = Arc::new(Device::Tun(tun_device));
+        println!("========TUN网卡配置========");
+        Ok((
+            DeviceWriter::new(device.clone(), in_ips, address),
+            DeviceReader::new(device),
+        ))
+    }
+}
+fn delete_cache(){
+    //清除路由缓存
+    let delete_cache = "netsh interface ip delete destinationcache";
+    let out = std::process::Command::new("cmd")
+        .arg("/C")
+        .arg(delete_cache)
+        .output()
+        .unwrap();
+    if !out.status.success(){
+        log::warn!("删除缓存失败:{:?}",out);
+    }
+}
+
+fn delete_tun() {
+    unsafe {
+        match Library::new("wintun.dll") {
+            Ok(lib) => match TunDevice::delete_for_name(lib, TUN_INTERFACE_NAME) {
+                Ok(_) => {}
+                Err(_) => {}
+            },
+            Err(_) => {}
+        }
+    }
+}
+
+fn create_tap(
+    address: Ipv4Addr,
+    netmask: Ipv4Addr,
+    gateway: Ipv4Addr,
+    in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
+) -> io::Result<(DeviceWriter, DeviceReader)> {
+    println!("========TAP网卡配置========");
+    let tap_device = match TapDevice::open(TAP_INTERFACE_NAME) {
+        Ok(tap_device) => tap_device,
+        Err(e) => {
+            log::warn!("{:?}", e);
+            let tap_device = TapDevice::create()?;
+            tap_device.set_name(TAP_INTERFACE_NAME)?;
+            tap_device
+        }
+    };
+    let mac = tap_device.get_mac()?;
+    println!("name:{:?}", tap_device.get_name()?);
+    println!("version:{:x?}", tap_device.get_version()?);
+    println!("mac:{:x?}", mac);
+    tap_device.set_ip(address, netmask)?;
+    tap_device.set_metric(1)?;
+    tap_device.set_mtu(1420)?;
+    tap_device.set_status(true)?;
+    tap_device.add_route(address, netmask, gateway, 1)?;
+    for (address, netmask) in &in_ips {
+        tap_device.add_route(*address, *netmask, gateway, 1)?;
+    }
+    // 广播和组播路由
+    tap_device.add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, gateway, 1)?;
+    tap_device.add_route(Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]), gateway, 1)?;
+    delete_cache();
+    let tap = Arc::new(Device::Tap((tap_device, mac)));
+    println!("========TAP网卡配置========");
+    Ok((
+        DeviceWriter::new(tap.clone(), in_ips, address),
+        DeviceReader::new(tap)
+    ))
+}
+
+fn delete_tap() {
+    let tap_device = match TapDevice::open(TAP_INTERFACE_NAME) {
+        Ok(tap_device) => tap_device,
+        Err(_) => {
+            return;
+        }
+    };
+    let _ = tap_device.delete();
+}
+
+pub fn create_device(device_type: DeviceType, address: Ipv4Addr,
+                     netmask: Ipv4Addr,
+                     gateway: Ipv4Addr,
+                     in_ips: Vec<(Ipv4Addr, Ipv4Addr)>, ) -> io::Result<(DeviceWriter, DeviceReader)> {
+    match device_type {
+        DeviceType::Tun => {
+            create_tun(address, netmask, gateway, in_ips)
+        }
+        DeviceType::Tap => {
+            create_tap(address, netmask, gateway, in_ips)
+        }
+    }
+}
+
+pub fn delete_device(device_type: DeviceType) {
+    match device_type {
+        DeviceType::Tun => {
+            delete_tun()
+        }
+        DeviceType::Tap => {
+            delete_tap()
+        }
+    }
+}
+

switch/win-tun-tap/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "win-tun-tap"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+log = "0.4.17"
+winreg = "0.7"
+scopeguard = "1.1"
+libloading = "0.7"
+widestring = "0.4"
+once_cell = "1.8"
+itertools = "0.10.1"
+rand = "0.8.5"
+[dependencies.winapi]
+version = "0.3"
+features = [
+    "errhandlingapi",
+    "combaseapi",
+    "ioapiset",
+    "winioctl",
+    "setupapi",
+    "synchapi",
+    "netioapi",
+    "fileapi",
+    "winbase",
+    "winerror",
+    "ipexport",
+    "iphlpapi",
+    "handleapi"
+]

switch/win-tun-tap/src/ffi.rs

@@ -0,0 +1,534 @@
+// Many things will be used in the future
+#![allow(unused)]
+
+//! Module holding safe wrappers over winapi functions
+
+use winapi::shared::basetsd::*;
+use winapi::shared::guiddef::GUID;
+use winapi::shared::ifdef::*;
+use winapi::shared::minwindef::*;
+use winapi::shared::netioapi::*;
+use winapi::shared::winerror::*;
+
+use winapi::um::combaseapi::*;
+use winapi::um::errhandlingapi::*;
+use winapi::um::fileapi::*;
+use winapi::um::handleapi::*;
+use winapi::um::ioapiset::*;
+use winapi::um::setupapi::*;
+use winapi::um::synchapi::*;
+use winapi::um::winioctl::*;
+use winapi::um::winnt::*;
+use winapi::um::winreg::*;
+
+use std::{io, mem, ptr};
+use std::error::Error;
+use winapi::um::minwinbase::OVERLAPPED_u;
+
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[repr(C)]
+#[derive(Clone, Copy)]
+/// Custom type to handle variable size SP_DRVINFO_DETAIL_DATA_W
+pub struct SP_DRVINFO_DETAIL_DATA_W2 {
+    pub cbSize: DWORD,
+    pub InfDate: FILETIME,
+    pub CompatIDsOffset: DWORD,
+    pub CompatIDsLength: DWORD,
+    pub Reserved: ULONG_PTR,
+    pub SectionName: [WCHAR; 256],
+    pub InfFileName: [WCHAR; 260],
+    pub DrvDescription: [WCHAR; 256],
+    pub HardwareID: [WCHAR; 512],
+}
+
+pub fn string_from_guid(guid: &GUID) -> io::Result<Vec<WCHAR>> {
+    // GUID_STRING_CHARACTERS + 1
+    let mut string = vec![0; 39];
+
+    match unsafe {
+        StringFromGUID2(guid, string.as_mut_ptr(), string.len() as _)
+    } {
+        0 => Err(io::Error::new(io::ErrorKind::Other, "Insufficent buffer")),
+        _ => Ok(string),
+    }
+}
+
+pub fn alias_to_luid(alias: &[WCHAR]) -> io::Result<NET_LUID> {
+    let mut luid = unsafe { mem::zeroed() };
+
+    match unsafe { ConvertInterfaceAliasToLuid(alias.as_ptr(), &mut luid) } {
+        0 => Ok(luid),
+        err => Err(io::Error::from_raw_os_error(err as _)),
+    }
+}
+
+pub fn luid_to_index(luid: &NET_LUID) -> io::Result<NET_IFINDEX> {
+    let mut index = 0;
+
+    match unsafe { ConvertInterfaceLuidToIndex(luid, &mut index) } {
+        0 => Ok(index),
+        err => Err(io::Error::from_raw_os_error(err as _)),
+    }
+}
+
+pub fn luid_to_guid(luid: &NET_LUID) -> io::Result<GUID> {
+    let mut guid = unsafe { mem::zeroed() };
+
+    match unsafe { ConvertInterfaceLuidToGuid(luid, &mut guid) } {
+        0 => Ok(guid),
+        err => Err(io::Error::from_raw_os_error(err as _)),
+    }
+}
+
+pub fn luid_to_alias(luid: &NET_LUID) -> io::Result<Vec<WCHAR>> {
+    // IF_MAX_STRING_SIZE + 1
+    let mut alias = vec![0; 257];
+
+    match unsafe {
+        ConvertInterfaceLuidToAlias(luid, alias.as_mut_ptr(), alias.len())
+    } {
+        0 => {
+            Ok(alias)
+        }
+        err => Err(io::Error::from_raw_os_error(err as _)),
+    }
+}
+
+pub fn close_handle(handle: HANDLE) -> io::Result<()> {
+    match unsafe { CloseHandle(handle) } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn create_file(
+    file_name: &[WCHAR],
+    desired_access: DWORD,
+    share_mode: DWORD,
+    creation_disposition: DWORD,
+    flags_and_attributes: DWORD,
+) -> io::Result<HANDLE> {
+    match unsafe {
+        CreateFileW(
+            file_name.as_ptr(),
+            desired_access,
+            share_mode,
+            ptr::null_mut(),
+            creation_disposition,
+            flags_and_attributes,
+            ptr::null_mut(),
+        )
+    } {
+        INVALID_HANDLE_VALUE => Err(io::Error::last_os_error()),
+        handle => Ok(handle),
+    }
+}
+
+pub fn read_file(handle: HANDLE, buffer: &mut [u8]) -> io::Result<DWORD> {
+    let mut ret = 0;
+    //https://www.cnblogs.com/linyilong3/archive/2012/05/03/2480451.html
+    unsafe {
+        let mut ip_overlapped = winapi::um::minwinbase::OVERLAPPED {
+            Internal: 0,
+            InternalHigh: 0,
+            u: Default::default(),
+            hEvent: ptr::null_mut(),
+        };
+        if 0 == ReadFile(
+            handle,
+            buffer.as_mut_ptr() as _,
+            buffer.len() as _,
+            &mut ret,
+            &mut ip_overlapped, ) {
+            let e = io::Error::last_os_error();
+            if e.raw_os_error().unwrap_or(0) == 997 {
+                if 0 == GetOverlappedResult(handle, &mut ip_overlapped, &mut ret, 1) {
+                    return Err(e);
+                }
+            } else {
+                return Err(e);
+            }
+        }
+        Ok(ret)
+    }
+}
+
+pub fn write_file(handle: HANDLE, buffer: &[u8]) -> io::Result<DWORD> {
+    let mut ret = 0;
+    let mut ip_overlapped = winapi::um::minwinbase::OVERLAPPED {
+        Internal: 0,
+        InternalHigh: 0,
+        u: Default::default(),
+        hEvent: ptr::null_mut(),
+    };
+    unsafe {
+        if 0 == WriteFile(
+            handle,
+            buffer.as_ptr() as _,
+            buffer.len() as _,
+            &mut ret,
+            &mut ip_overlapped,
+        ) {
+            let e = io::Error::last_os_error();
+            if e.raw_os_error().unwrap_or(0) == 997 {
+                if 0 == GetOverlappedResult(handle, &mut ip_overlapped, &mut ret, 1) {
+                    return Err(e);
+                }
+            } else {
+                return Err(e);
+            }
+        }
+        Ok(ret)
+    }
+}
+
+pub fn create_device_info_list(guid: &GUID) -> io::Result<HDEVINFO> {
+    match unsafe { SetupDiCreateDeviceInfoList(guid, ptr::null_mut()) } {
+        INVALID_HANDLE_VALUE => Err(io::Error::last_os_error()),
+        devinfo => Ok(devinfo),
+    }
+}
+
+pub fn get_class_devs(guid: &GUID, flags: DWORD) -> io::Result<HDEVINFO> {
+    match unsafe {
+        SetupDiGetClassDevsW(guid, ptr::null(), ptr::null_mut(), flags)
+    } {
+        INVALID_HANDLE_VALUE => Err(io::Error::last_os_error()),
+        devinfo => Ok(devinfo),
+    }
+}
+
+pub fn destroy_device_info_list(devinfo: HDEVINFO) -> io::Result<()> {
+    match unsafe { SetupDiDestroyDeviceInfoList(devinfo) } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn class_name_from_guid(guid: &GUID) -> io::Result<Vec<WCHAR>> {
+    let mut class_name = vec![0; 32];
+
+    match unsafe {
+        SetupDiClassNameFromGuidW(
+            guid,
+            class_name.as_mut_ptr(),
+            class_name.len() as _,
+            ptr::null_mut(),
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(class_name),
+    }
+}
+
+pub fn create_device_info(
+    devinfo: HDEVINFO,
+    device_name: &[WCHAR],
+    guid: &GUID,
+    device_description: &[WCHAR],
+    creation_flags: DWORD,
+) -> io::Result<SP_DEVINFO_DATA> {
+    let mut devinfo_data: SP_DEVINFO_DATA = unsafe { mem::zeroed() };
+    devinfo_data.cbSize = mem::size_of_val(&devinfo_data) as _;
+
+    match unsafe {
+        SetupDiCreateDeviceInfoW(
+            devinfo,
+            device_name.as_ptr(),
+            guid,
+            device_description.as_ptr(),
+            ptr::null_mut(),
+            creation_flags,
+            &mut devinfo_data,
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(devinfo_data),
+    }
+}
+
+pub fn set_selected_device(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+) -> io::Result<()> {
+    match unsafe {
+        SetupDiSetSelectedDevice(devinfo, devinfo_data as *const _ as _)
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn set_device_registry_property(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    property: DWORD,
+    value: &[WCHAR],
+) -> io::Result<()> {
+    match unsafe {
+        SetupDiSetDeviceRegistryPropertyW(
+            devinfo,
+            devinfo_data as *const _ as _,
+            property,
+            value.as_ptr() as _,
+            (value.len() * 2) as _,
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn get_device_registry_property(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    property: DWORD,
+) -> io::Result<Vec<WCHAR>> {
+    let mut value = vec![0; 32];
+
+    match unsafe {
+        SetupDiGetDeviceRegistryPropertyW(
+            devinfo,
+            devinfo_data as *const _ as _,
+            property,
+            ptr::null_mut(),
+            value.as_mut_ptr() as _,
+            (value.len() * 2) as _,
+            ptr::null_mut(),
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(value),
+    }
+}
+
+pub fn build_driver_info_list(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    driver_type: DWORD,
+) -> io::Result<()> {
+    match unsafe {
+        SetupDiBuildDriverInfoList(
+            devinfo,
+            devinfo_data as *const _ as _,
+            driver_type,
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn destroy_driver_info_list(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    driver_type: DWORD,
+) -> io::Result<()> {
+    match unsafe {
+        SetupDiDestroyDriverInfoList(
+            devinfo,
+            devinfo_data as *const _ as _,
+            driver_type,
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn get_driver_info_detail(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    drvinfo_data: &SP_DRVINFO_DATA_W,
+) -> io::Result<SP_DRVINFO_DETAIL_DATA_W2> {
+    let mut drvinfo_detail: SP_DRVINFO_DETAIL_DATA_W2 =
+        unsafe { mem::zeroed() };
+    drvinfo_detail.cbSize = mem::size_of::<SP_DRVINFO_DETAIL_DATA_W>() as _;
+
+    match unsafe {
+        SetupDiGetDriverInfoDetailW(
+            devinfo,
+            devinfo_data as *const _ as _,
+            drvinfo_data as *const _ as _,
+            &mut drvinfo_detail as *mut _ as _,
+            mem::size_of_val(&drvinfo_detail) as _,
+            ptr::null_mut(),
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(drvinfo_detail),
+    }
+}
+
+pub fn set_selected_driver(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    drvinfo_data: &SP_DRVINFO_DATA_W,
+) -> io::Result<()> {
+    match unsafe {
+        SetupDiSetSelectedDriverW(
+            devinfo,
+            devinfo_data as *const _ as _,
+            drvinfo_data as *const _ as _,
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn set_class_install_params(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    params: &impl Copy,
+) -> io::Result<()> {
+    match unsafe {
+        SetupDiSetClassInstallParamsW(
+            devinfo,
+            devinfo_data as *const _ as _,
+            params as *const _ as _,
+            mem::size_of_val(params) as _,
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn call_class_installer(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    install_function: DI_FUNCTION,
+) -> io::Result<()> {
+    match unsafe {
+        SetupDiCallClassInstaller(
+            install_function,
+            devinfo,
+            devinfo_data as *const _ as _,
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}
+
+pub fn open_dev_reg_key(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    scope: DWORD,
+    hw_profile: DWORD,
+    key_type: DWORD,
+    sam_desired: REGSAM,
+) -> io::Result<HKEY> {
+    const INVALID_KEY_VALUE: HKEY = INVALID_HANDLE_VALUE as _;
+
+    match unsafe {
+        SetupDiOpenDevRegKey(
+            devinfo,
+            devinfo_data as *const _ as _,
+            scope,
+            hw_profile,
+            key_type,
+            sam_desired,
+        )
+    } {
+        INVALID_KEY_VALUE => Err(io::Error::last_os_error()),
+        key => Ok(key),
+    }
+}
+
+pub fn notify_change_key_value(
+    key: HKEY,
+    watch_subtree: BOOL,
+    notify_filter: DWORD,
+    milliseconds: DWORD,
+) -> io::Result<()> {
+    let event = match unsafe {
+        CreateEventW(ptr::null_mut(), FALSE, FALSE, ptr::null())
+    } {
+        INVALID_HANDLE_VALUE => Err(io::Error::last_os_error()),
+        event => Ok(event),
+    }?;
+
+    match unsafe {
+        RegNotifyChangeKeyValue(key, watch_subtree, notify_filter, event, TRUE)
+    } {
+        0 => Ok(()),
+        err => Err(io::Error::from_raw_os_error(err)),
+    }?;
+
+    match unsafe { WaitForSingleObject(event, milliseconds) } {
+        0 => Ok(()),
+        0x102 => Err(io::Error::new(
+            io::ErrorKind::TimedOut,
+            "Registry timed out",
+        )),
+        _ => Err(io::Error::last_os_error()),
+    }
+}
+
+pub fn enum_driver_info(
+    devinfo: HDEVINFO,
+    devinfo_data: &SP_DEVINFO_DATA,
+    driver_type: DWORD,
+    member_index: DWORD,
+) -> Option<io::Result<SP_DRVINFO_DATA_W>> {
+    let mut drvinfo_data: SP_DRVINFO_DATA_W = unsafe { mem::zeroed() };
+    drvinfo_data.cbSize = mem::size_of_val(&drvinfo_data) as _;
+
+    match unsafe {
+        SetupDiEnumDriverInfoW(
+            devinfo,
+            devinfo_data as *const _ as _,
+            driver_type,
+            member_index,
+            &mut drvinfo_data,
+        )
+    } {
+        0 if unsafe { GetLastError() == ERROR_NO_MORE_ITEMS } => None,
+        0 => Some(Err(io::Error::last_os_error())),
+        _ => Some(Ok(drvinfo_data)),
+    }
+}
+
+pub fn enum_device_info(
+    devinfo: HDEVINFO,
+    member_index: DWORD,
+) -> Option<io::Result<SP_DEVINFO_DATA>> {
+    let mut devinfo_data: SP_DEVINFO_DATA = unsafe { mem::zeroed() };
+    devinfo_data.cbSize = mem::size_of_val(&devinfo_data) as _;
+
+    match unsafe {
+        SetupDiEnumDeviceInfo(devinfo, member_index, &mut devinfo_data)
+    } {
+        0 if unsafe { GetLastError() == ERROR_NO_MORE_ITEMS } => None,
+        0 => Some(Err(io::Error::last_os_error())),
+        _ => Some(Ok(devinfo_data)),
+    }
+}
+
+pub fn device_io_control(
+    handle: HANDLE,
+    io_control_code: DWORD,
+    in_buffer: &impl Copy,
+    out_buffer: &mut impl Copy,
+) -> io::Result<()> {
+    let mut junk = 0;
+
+    match unsafe {
+        DeviceIoControl(
+            handle,
+            io_control_code,
+            in_buffer as *const _ as _,
+            mem::size_of_val(in_buffer) as _,
+            out_buffer as *mut _ as _,
+            mem::size_of_val(out_buffer) as _,
+            &mut junk,
+            ptr::null_mut(),
+        )
+    } {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
+}

switch/win-tun-tap/src/lib.rs

@@ -0,0 +1,47 @@
+#![cfg(windows)]
+
+mod tap;
+mod tun;
+mod ffi;
+mod netsh;
+mod route;
+use std::{io, net};
+use std::net::Ipv4Addr;
+pub use tap::TapDevice;
+pub use tun::*;
+
+/// Encode a string as a utf16 buffer
+fn encode_utf16(string: &str) -> Vec<u16> {
+    use std::iter::once;
+    string.encode_utf16().chain(once(0)).collect()
+}
+
+/// Decode a string from a utf16 buffer
+fn decode_utf16(string: &[u16]) -> String {
+    let end = string.iter().position(|b| *b == 0).unwrap_or(string.len());
+    String::from_utf16_lossy(&string[..end])
+}
+
+pub trait IFace {
+    fn shutdown(&self) -> io::Result<()>;
+    /// 获取接口索引
+    fn get_index(&self) -> io::Result<u32>;
+    /// 获取名称
+    fn get_name(&self) -> io::Result<String>;
+    /// 设置名称
+    fn set_name(&self, new_name: &str) -> io::Result<()>;
+    /// 设置ip
+    fn set_ip(&self, address: Ipv4Addr, mask: Ipv4Addr) -> io::Result<()>;
+    /// 设置路由
+    fn add_route(&self, dest: Ipv4Addr,
+                     netmask: Ipv4Addr,
+                     gateway: Ipv4Addr, metric: u16) -> io::Result<()>;
+    /// 删除路由
+    fn delete_route(&self, dest: Ipv4Addr,
+                        netmask: Ipv4Addr,
+                        gateway: Ipv4Addr, ) -> io::Result<()>;
+    /// 设置最大传输单元
+    fn set_mtu(&self, mtu: u16) -> io::Result<()>;
+    /// 设置跃点
+    fn set_metric(&self, metric: u16) -> io::Result<()>;
+}

switch/win-tun-tap/src/netsh.rs

@@ -0,0 +1,60 @@
+use std::io;
+use std::net::Ipv4Addr;
+
+/// 设置网卡名称
+pub fn set_interface_name(old_name: &str, new_name: &str) -> io::Result<()> {
+    let cmd = format!(" netsh interface set interface name={:?} newname={:?}", old_name, new_name);
+    let out = std::process::Command::new("cmd")
+        .arg("/C")
+        .arg(&cmd)
+        .output()?;
+    if !out.status.success() {
+        log::warn!("修改网卡名称失败：cmd={:?},out={:?}",cmd,out);
+        return Err(io::Error::new(io::ErrorKind::Other, "修改网卡名称失败"));
+    }
+    Ok(())
+}
+/// 设置网卡ip
+pub fn set_interface_ip(index: u32, address: &Ipv4Addr, netmask: &Ipv4Addr) -> io::Result<()> {
+    let set_address = format!(
+        "netsh interface ip set address {} static {:?} {:?} ",
+        index, address, netmask,
+    );
+    let out = std::process::Command::new("cmd")
+        .arg("/C")
+        .arg(&set_address)
+        .output()?;
+    if !out.status.success() {
+        log::error!("cmd={:?},out={:?}",set_address,out);
+        return Err(io::Error::new(io::ErrorKind::Other, format!("设置网络地址失败: {:?}", out)));
+    }
+    Ok(())
+}
+
+pub fn set_interface_mtu(index: u32, mtu: u16) -> io::Result<()> {
+    let set_mtu = format!(
+        "netsh interface ipv4 set subinterface {}  mtu={} store=persistent",
+        index, mtu
+    );
+    let out = std::process::Command::new("cmd")
+        .arg("/C")
+        .arg(&set_mtu)
+        .output()?;
+    if !out.status.success() {
+        log::error!("cmd={:?},out={:?}",set_mtu,out);
+        return Err(io::Error::new(io::ErrorKind::Other, format!("设置mtu失败: {:?}", out)));
+    }
+    Ok(())
+}
+pub fn set_interface_metric(index: u32, metric: u16) -> io::Result<()> {
+    let set_metric = format!("netsh interface ip set interface {} metric={}", index,metric);
+    let out = std::process::Command::new("cmd")
+        .arg("/C")
+        .arg(&set_metric)
+        .output()?;
+    if !out.status.success() {
+        log::error!("cmd={:?},out={:?}",set_metric,out);
+        return Err(io::Error::new(io::ErrorKind::Other, format!("设置metric失败: {:?}", out)));
+    }
+    Ok(())
+}

switch/win-tun-tap/src/route.rs

@@ -0,0 +1,44 @@
+use std::io;
+use std::net::Ipv4Addr;
+
+/// 添加路由
+pub fn add_route(index: u32, dest: Ipv4Addr,
+                 netmask: Ipv4Addr,
+                 gateway: Ipv4Addr, metric: u16) -> io::Result<()> {
+    let set_route = format!(
+        "route add {:?} mask {:?} {:?} metric {} if {}",
+        dest, netmask, gateway, metric, index
+    );
+    // 执行添加路由命令
+    let out = std::process::Command::new("cmd")
+        .arg("/C")
+        .arg(&set_route)
+        .output()
+        .unwrap();
+    if !out.status.success() {
+        log::error!("cmd={:?},out={:?}",set_route,out);
+        return Err(io::Error::new(io::ErrorKind::Other, format!("添加路由失败: {:?}", out)));
+    }
+    Ok(())
+}
+
+/// 删除路由
+pub fn delete_route(index: u32, dest: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr) -> io::Result<()> {
+    if index == 0 {
+        return Err(io::Error::new(io::ErrorKind::Other, format!("网络接口索引错误: {:?}", index)));
+    }
+    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(())
+}

switch/win-tun-tap/src/tap/iface.rs

@@ -0,0 +1,328 @@
+use winapi::shared::ifdef::NET_LUID;
+use winapi::shared::minwindef::*;
+
+use winapi::um::fileapi::*;
+use winapi::um::setupapi::*;
+use winapi::um::winnt::*;
+
+use scopeguard::{guard, ScopeGuard};
+use winreg::RegKey;
+
+use std::io;
+use winapi::um::winbase::FILE_FLAG_OVERLAPPED;
+
+use crate::{decode_utf16, encode_utf16, ffi};
+
+/// tap-windows hardware ID
+const HARDWARE_ID: &str = "tap0901";
+
+winapi::DEFINE_GUID! {
+    GUID_NETWORK_ADAPTER,
+    0x4d36e972, 0xe325, 0x11ce,
+    0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18
+}
+
+/// Create a new interface and returns its NET_LUID
+pub fn create_interface() -> io::Result<NET_LUID> {
+    let devinfo = ffi::create_device_info_list(&GUID_NETWORK_ADAPTER)?;
+
+    let _guard = guard((), |_| {
+        let _ = ffi::destroy_device_info_list(devinfo);
+    });
+
+    let class_name = ffi::class_name_from_guid(&GUID_NETWORK_ADAPTER)?;
+
+    let devinfo_data = ffi::create_device_info(
+        devinfo,
+        &class_name,
+        &GUID_NETWORK_ADAPTER,
+        &encode_utf16(""),
+        DICD_GENERATE_ID,
+    )?;
+
+    ffi::set_selected_device(devinfo, &devinfo_data)?;
+    ffi::set_device_registry_property(
+        devinfo,
+        &devinfo_data,
+        SPDRP_HARDWAREID,
+        &encode_utf16(HARDWARE_ID),
+    )?;
+
+    ffi::build_driver_info_list(devinfo, &devinfo_data, SPDIT_COMPATDRIVER)?;
+
+    let _guard = guard((), |_| {
+        let _ = ffi::destroy_driver_info_list(
+            devinfo,
+            &devinfo_data,
+            SPDIT_COMPATDRIVER,
+        );
+    });
+
+    let mut driver_version = 0;
+    let mut member_index = 0;
+
+    while let Some(drvinfo_data) = ffi::enum_driver_info(
+        devinfo,
+        &devinfo_data,
+        SPDIT_COMPATDRIVER,
+        member_index,
+    ) {
+        member_index += 1;
+
+        let drvinfo_data = match drvinfo_data {
+            Ok(drvinfo_data) => drvinfo_data,
+            _ => continue,
+        };
+
+        if drvinfo_data.DriverVersion <= driver_version {
+            continue;
+        }
+
+        let drvinfo_detail = match ffi::get_driver_info_detail(
+            devinfo,
+            &devinfo_data,
+            &drvinfo_data,
+        ) {
+            Ok(drvinfo_detail) => drvinfo_detail,
+            _ => continue,
+        };
+
+        let is_compatible = drvinfo_detail
+            .HardwareID
+            .split(|b| *b == 0)
+            .map(|id| decode_utf16(id))
+            .any(|id| id.eq_ignore_ascii_case(HARDWARE_ID));
+
+        if !is_compatible {
+            continue;
+        }
+
+        match ffi::set_selected_driver(devinfo, &devinfo_data, &drvinfo_data) {
+            Ok(_) => (),
+            _ => continue,
+        }
+
+        driver_version = drvinfo_data.DriverVersion;
+    }
+
+    if driver_version == 0 {
+        return Err(io::Error::new(io::ErrorKind::NotFound, "No driver found"));
+    }
+
+    let uninstaller = guard((), |_| {
+        let _ = ffi::call_class_installer(devinfo, &devinfo_data, DIF_REMOVE);
+    });
+
+    ffi::call_class_installer(devinfo, &devinfo_data, DIF_REGISTERDEVICE)?;
+
+    let _ = ffi::call_class_installer(
+        devinfo,
+        &devinfo_data,
+        DIF_REGISTER_COINSTALLERS,
+    );
+    let _ = ffi::call_class_installer(
+        devinfo,
+        &devinfo_data,
+        DIF_INSTALLINTERFACES,
+    );
+
+    ffi::call_class_installer(devinfo, &devinfo_data, DIF_INSTALLDEVICE)?;
+
+    let key = ffi::open_dev_reg_key(
+        devinfo,
+        &devinfo_data,
+        DICS_FLAG_GLOBAL,
+        0,
+        DIREG_DRV,
+        KEY_QUERY_VALUE | KEY_NOTIFY,
+    )?;
+
+    let key = RegKey::predef(key);
+
+    while let Err(_) = key.get_value::<DWORD, &str>("*IfType") {
+        ffi::notify_change_key_value(
+            key.raw_handle(),
+            TRUE,
+            REG_NOTIFY_CHANGE_NAME,
+            2000,
+        )?;
+    }
+
+    while let Err(_) = key.get_value::<DWORD, &str>("NetLuidIndex") {
+        ffi::notify_change_key_value(
+            key.raw_handle(),
+            TRUE,
+            REG_NOTIFY_CHANGE_NAME,
+            2000,
+        )?;
+    }
+
+    let if_type: DWORD = key.get_value("*IfType")?;
+    let luid_index: DWORD = key.get_value("NetLuidIndex")?;
+
+    // Defuse the uninstaller
+    ScopeGuard::into_inner(uninstaller);
+
+    let mut luid = NET_LUID { Value: 0 };
+
+    luid.set_IfType(if_type as _);
+    luid.set_NetLuidIndex(luid_index as _);
+
+    Ok(luid)
+}
+
+/// Check if the given interface exists and is a valid tap-windows device
+pub fn check_interface(luid: &NET_LUID) -> io::Result<()> {
+    let devinfo = ffi::get_class_devs(&GUID_NETWORK_ADAPTER, DIGCF_PRESENT)?;
+
+    let _guard = guard((), |_| {
+        let _ = ffi::destroy_device_info_list(devinfo);
+    });
+
+    let mut member_index = 0;
+
+    while let Some(devinfo_data) = ffi::enum_device_info(devinfo, member_index)
+    {
+        member_index += 1;
+
+        let devinfo_data = match devinfo_data {
+            Ok(devinfo_data) => devinfo_data,
+            Err(_) => continue,
+        };
+
+        let hardware_id = match ffi::get_device_registry_property(
+            devinfo,
+            &devinfo_data,
+            SPDRP_HARDWAREID,
+        ) {
+            Ok(hardware_id) => hardware_id,
+            Err(_) => continue,
+        };
+
+        if !decode_utf16(&hardware_id).eq_ignore_ascii_case(HARDWARE_ID) {
+            continue;
+        }
+
+        let key = match ffi::open_dev_reg_key(
+            devinfo,
+            &devinfo_data,
+            DICS_FLAG_GLOBAL,
+            0,
+            DIREG_DRV,
+            KEY_QUERY_VALUE | KEY_NOTIFY,
+        ) {
+            Ok(key) => RegKey::predef(key),
+            Err(_) => continue,
+        };
+
+        let if_type: DWORD = match key.get_value("*IfType") {
+            Ok(if_type) => if_type,
+            Err(_) => continue,
+        };
+
+        let luid_index: DWORD = match key.get_value("NetLuidIndex") {
+            Ok(luid_index) => luid_index,
+            Err(_) => continue,
+        };
+
+        let mut luid2 = NET_LUID { Value: 0 };
+
+        luid2.set_IfType(if_type as _);
+        luid2.set_NetLuidIndex(luid_index as _);
+
+        if luid.Value != luid2.Value {
+            continue;
+        }
+
+        // Found it!
+        return Ok(());
+    }
+
+    Err(io::Error::new(io::ErrorKind::NotFound, "TAP Device not found"))
+}
+
+/// Deletes an existing interface
+pub fn delete_interface(luid: &NET_LUID) -> io::Result<()> {
+    let devinfo = ffi::get_class_devs(&GUID_NETWORK_ADAPTER, DIGCF_PRESENT)?;
+
+    let _guard = guard((), |_| {
+        let _ = ffi::destroy_device_info_list(devinfo);
+    });
+
+    let mut member_index = 0;
+
+    while let Some(devinfo_data) = ffi::enum_device_info(devinfo, member_index)
+    {
+        member_index += 1;
+
+        let devinfo_data = match devinfo_data {
+            Ok(devinfo_data) => devinfo_data,
+            Err(_) => continue,
+        };
+
+        let hardware_id = match ffi::get_device_registry_property(
+            devinfo,
+            &devinfo_data,
+            SPDRP_HARDWAREID,
+        ) {
+            Ok(hardware_id) => hardware_id,
+            Err(_) => continue,
+        };
+
+        if !decode_utf16(&hardware_id).eq_ignore_ascii_case(HARDWARE_ID) {
+            continue;
+        }
+
+        let key = match ffi::open_dev_reg_key(
+            devinfo,
+            &devinfo_data,
+            DICS_FLAG_GLOBAL,
+            0,
+            DIREG_DRV,
+            KEY_QUERY_VALUE | KEY_NOTIFY,
+        ) {
+            Ok(key) => RegKey::predef(key),
+            Err(_) => continue,
+        };
+
+        let if_type: DWORD = match key.get_value("*IfType") {
+            Ok(if_type) => if_type,
+            Err(_) => continue,
+        };
+
+        let luid_index: DWORD = match key.get_value("NetLuidIndex") {
+            Ok(luid_index) => luid_index,
+            Err(_) => continue,
+        };
+
+        let mut luid2 = NET_LUID { Value: 0 };
+
+        luid2.set_IfType(if_type as _);
+        luid2.set_NetLuidIndex(luid_index as _);
+
+        if luid.Value != luid2.Value {
+            continue;
+        }
+
+        // Found it!
+        return ffi::call_class_installer(devinfo, &devinfo_data, DIF_REMOVE);
+    }
+
+    Err(io::Error::new(io::ErrorKind::NotFound, "TAP Device not found"))
+}
+
+/// Open an handle to an interface
+pub fn open_interface(luid: &NET_LUID) -> io::Result<HANDLE> {
+    let guid = ffi::luid_to_guid(luid)
+        .and_then(|guid| ffi::string_from_guid(&guid))?;
+
+    let path = format!(r"\\.\Global\{}.tap", &decode_utf16(&guid));
+
+    ffi::create_file(
+        &encode_utf16(&path),
+        GENERIC_READ | GENERIC_WRITE,
+        FILE_SHARE_READ | FILE_SHARE_WRITE,
+        OPEN_EXISTING,
+        FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,//FILE_ATTRIBUTE_SYSTEM,
+    )
+}

switch/win-tun-tap/src/tap/mod.rs

@@ -0,0 +1,182 @@
+use std::{io, time};
+use std::net::Ipv4Addr;
+
+use winapi::shared::ifdef::NET_LUID;
+use winapi::um::winioctl::*;
+use winapi::um::winnt::HANDLE;
+
+use crate::{decode_utf16, encode_utf16, ffi, IFace, netsh, route};
+
+mod iface;
+
+pub struct TapDevice {
+    index: u32,
+    luid: NET_LUID,
+    handle: HANDLE,
+
+}
+
+unsafe impl Send for TapDevice {}
+
+unsafe impl Sync for TapDevice {}
+
+impl TapDevice {
+    /// Retieve the mac of the interface
+    pub fn get_mac(&self) -> io::Result<[u8; 6]> {
+        let mut mac = [0; 6];
+
+        ffi::device_io_control(
+            self.handle,
+            CTL_CODE(FILE_DEVICE_UNKNOWN, 1, METHOD_BUFFERED, FILE_ANY_ACCESS),
+            &(),
+            &mut mac,
+        )
+            .map(|_| mac)
+    }
+
+    /// Retrieve the version of the driver
+    pub fn get_version(&self) -> io::Result<[u32; 3]> {
+        let mut version = [0; 3];
+
+        ffi::device_io_control(
+            self.handle,
+            CTL_CODE(FILE_DEVICE_UNKNOWN, 2, METHOD_BUFFERED, FILE_ANY_ACCESS),
+            &(),
+            &mut version,
+        )
+            .map(|_| version)
+    }
+
+    /// Retieve the mtu of the interface
+    pub fn get_mtu(&self) -> io::Result<u32> {
+        let mut mtu = 0;
+
+        ffi::device_io_control(
+            self.handle,
+            CTL_CODE(FILE_DEVICE_UNKNOWN, 3, METHOD_BUFFERED, FILE_ANY_ACCESS),
+            &(),
+            &mut mtu,
+        )
+            .map(|_| mtu)
+    }
+
+
+    /// Set the status of the interface, true for connected,
+    /// false for disconnected.
+    pub fn set_status(&self, status: bool) -> io::Result<()> {
+        let status: u32 = if status { 1 } else { 0 };
+        ffi::device_io_control(
+            self.handle,
+            CTL_CODE(FILE_DEVICE_UNKNOWN, 6, METHOD_BUFFERED, FILE_ANY_ACCESS),
+            &status,
+            &mut (),
+        )
+    }
+}
+
+impl TapDevice {
+    pub fn create() -> io::Result<Self> {
+        let luid = iface::create_interface()?;
+        // Even after retrieving the luid, we might need to wait
+        let start = time::Instant::now();
+        let handle = loop {
+            // If we surpassed 2 seconds just return
+            let now = time::Instant::now();
+            if now - start > time::Duration::from_secs(3) {
+                return Err(io::Error::new(
+                    io::ErrorKind::TimedOut,
+                    "Interface timed out",
+                ));
+            }
+
+            match iface::open_interface(&luid) {
+                Err(_) => {
+                    std::thread::yield_now();
+                    continue;
+                }
+                Ok(handle) => break handle,
+            };
+        };
+        let index = ffi::luid_to_index(&luid).map(|index| index as u32)?;
+        Ok(Self { index, luid, handle })
+    }
+
+    pub fn open(name: &str) -> io::Result<Self> {
+        let name = encode_utf16(name);
+
+        let luid = ffi::alias_to_luid(&name)?;
+        iface::check_interface(&luid)?;
+
+        let handle = iface::open_interface(&luid)?;
+        let index = ffi::luid_to_index(&luid).map(|index| index as u32)?;
+        Ok(Self { index, luid, handle })
+    }
+
+    pub fn delete(self) -> io::Result<()> {
+        iface::delete_interface(&self.luid)
+    }
+}
+
+impl IFace for TapDevice {
+    fn shutdown(&self) -> io::Result<()> {
+        self.set_status(false)
+    }
+
+    fn get_index(&self) -> io::Result<u32> {
+        Ok(self.index)
+    }
+
+    fn get_name(&self) -> io::Result<String> {
+        ffi::luid_to_alias(&self.luid).map(|name| decode_utf16(&name))
+    }
+
+    fn set_name(&self, new_name: &str) -> io::Result<()> {
+        let name = self.get_name()?;
+        netsh::set_interface_name(&name, new_name)
+    }
+
+    fn set_ip(&self, address: Ipv4Addr, mask: Ipv4Addr) -> io::Result<()> {
+        let index = self.get_index()?;
+        netsh::set_interface_ip(index, &address, &mask)
+    }
+
+    fn add_route(&self, dest: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr, metric: u16) -> io::Result<()>  {
+        let index = self.get_index()?;
+        route::add_route(index, dest, netmask, gateway,metric)
+    }
+
+    fn delete_route(&self, dest: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr) -> io::Result<()>  {
+        let index = self.get_index()?;
+        route::delete_route(index, dest, netmask, gateway)
+    }
+
+    fn set_mtu(&self, mtu: u16) -> io::Result<()> {
+        let index = self.get_index()?;
+        netsh::set_interface_mtu(index, mtu)
+    }
+
+    fn set_metric(&self, metric: u16) -> io::Result<()> {
+        let index = self.get_index()?;
+        netsh::set_interface_metric(index, metric)
+    }
+}
+
+
+impl TapDevice {
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        ffi::read_file(self.handle, buf).map(|res| res as _)
+    }
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        ffi::write_file(self.handle, buf).map(|res| res as _)
+    }
+}
+
+impl Drop for TapDevice {
+    fn drop(&mut self) {
+        let _ = ffi::close_handle(self.handle);
+        let _ = iface::delete_interface(&self.luid);
+    }
+}
+
+
+

switch/win-tun-tap/src/tun/log.rs

@@ -0,0 +1,47 @@
+use log::*;
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use widestring::U16CStr;
+use crate::tun::wintun_raw;
+
+/// Sets the logger wintun will use when logging. Maps to the WintunSetLogger C function
+pub fn set_logger(win_tun: &wintun_raw::wintun, f: wintun_raw::WINTUN_LOGGER_CALLBACK) {
+    unsafe { win_tun.WintunSetLogger(f) };
+}
+
+pub fn reset_logger(win_tun: &wintun_raw::wintun) {
+    set_logger(win_tun, None);
+}
+
+static SET_LOGGER: AtomicBool = AtomicBool::new(false);
+
+/// The logger that is active by default. Logs messages to the log crate
+///
+/// # Safety
+/// `message` must be a valid pointer that points to an aligned null terminated UTF-16 string
+pub unsafe extern "C" fn default_logger(
+    level: wintun_raw::WINTUN_LOGGER_LEVEL,
+    _timestamp: wintun_raw::DWORD64,
+    message: *const wintun_raw::WCHAR,
+) {
+    //Cant wait for RFC 2585
+    #[allow(unused_unsafe)]
+    //Wintun will always give us a valid UTF16 null termineted string
+    let msg = unsafe { U16CStr::from_ptr_str(message) };
+    let utf8_msg = msg.to_string_lossy();
+    match level {
+        wintun_raw::WINTUN_LOGGER_LEVEL_WINTUN_LOG_INFO => info!("WinTun: {}", utf8_msg),
+        wintun_raw::WINTUN_LOGGER_LEVEL_WINTUN_LOG_WARN => warn!("WinTun: {}", utf8_msg),
+        wintun_raw::WINTUN_LOGGER_LEVEL_WINTUN_LOG_ERR => error!("WinTun: {}", utf8_msg),
+        _ => error!("WinTun: {} (with invalid log level {})", utf8_msg, level),
+    }
+}
+
+pub(crate) fn set_default_logger_if_unset(win_tun: &wintun_raw::wintun) {
+    if SET_LOGGER
+        .compare_exchange(false, true, Ordering::SeqCst, Ordering::Relaxed)
+        .is_ok()
+    {
+        set_logger(win_tun, Some(default_logger));
+    }
+}

switch/win-tun-tap/src/tun/mod.rs

@@ -0,0 +1,315 @@
+use std::io;
+use std::net::Ipv4Addr;
+
+use winapi::um::{handleapi, synchapi, winbase, winnt};
+
+use crate::{decode_utf16, encode_utf16, ffi, IFace, netsh, route};
+use rand::Rng;
+mod wintun_raw;
+mod log;
+pub mod packet;
+
+/// The maximum size of wintun's internal ring buffer (in bytes)
+pub const MAX_RING_CAPACITY: u32 = 0x400_0000;
+
+/// The minimum size of wintun's internal ring buffer (in bytes)
+pub const MIN_RING_CAPACITY: u32 = 0x2_0000;
+
+/// Maximum pool name length including zero terminator
+pub const MAX_POOL: usize = 256;
+
+
+pub struct TunDevice {
+    pub(crate) luid: u64,
+    pub(crate) index: u32,
+    /// The session handle given to us by WintunStartSession
+    pub(crate) session: wintun_raw::WINTUN_SESSION_HANDLE,
+
+    /// Shared dll for required wintun driver functions
+    pub(crate) win_tun: wintun_raw::wintun,
+
+    /// Windows event handle that is signaled by the wintun driver when data becomes available to
+    /// read
+    pub(crate) read_event: winnt::HANDLE,
+
+    /// Windows event handle that is signaled when [`TunSession::shutdown`] is called force blocking
+    /// readers to exit
+    pub(crate) shutdown_event: winnt::HANDLE,
+
+    /// The adapter that owns this session
+    pub(crate) adapter: wintun_raw::WINTUN_ADAPTER_HANDLE,
+
+}
+
+unsafe impl Send for TunDevice {}
+
+unsafe impl Sync for TunDevice {}
+
+impl TunDevice {
+    pub unsafe fn create<L>(library: L, pool: &str, name: &str) -> io::Result<Self>
+        where L: Into<libloading::Library>, {
+        let win_tun = match wintun_raw::wintun::from_library(library) {
+            Ok(win_tun) => { win_tun }
+            Err(e) => {
+                return Err(io::Error::new(io::ErrorKind::Other, format!("library error {:?} ", e)));
+            }
+        };
+        let pool_utf16 = encode_utf16(pool);
+        if pool_utf16.len() > MAX_POOL {
+            return Err(io::Error::new(io::ErrorKind::Other, format!("长度大于{}:{:?}", MAX_POOL, pool)));
+        }
+        let name_utf16 = encode_utf16(name);
+        if name_utf16.len() > MAX_POOL {
+            return Err(io::Error::new(io::ErrorKind::Other, format!("长度大于{}:{:?}", MAX_POOL, pool)));
+        }
+        let mut guid_bytes: [u8; 16] = [0u8; 16];
+        rand::thread_rng().fill(&mut guid_bytes);
+        let guid = u128::from_ne_bytes(guid_bytes);
+        //SAFETY: guid is a unique integer so transmuting either all zeroes or the user's preferred
+        //guid to the winapi guid type is safe and will allow the windows kernel to see our GUID
+
+        let guid_struct: wintun_raw::GUID = unsafe { std::mem::transmute(guid) };
+        let guid_ptr = &guid_struct as *const wintun_raw::GUID;
+
+        log::set_default_logger_if_unset(&win_tun);
+
+        //SAFETY: the function is loaded from the wintun dll properly, we are providing valid
+        //pointers, and all the strings are correct null terminated UTF-16. This safety rationale
+        //applies for all Wintun* functions below
+        let adapter = win_tun.WintunCreateAdapter(pool_utf16.as_ptr(), name_utf16.as_ptr(), guid_ptr);
+        if adapter.is_null() {
+            return Err(io::Error::new(io::ErrorKind::Other, "Failed to crate adapter"));
+        }
+        Self::init(win_tun, adapter)
+    }
+    pub unsafe fn init(win_tun: wintun_raw::wintun, adapter: wintun_raw::WINTUN_ADAPTER_HANDLE) -> io::Result<Self> {
+        // 开启session
+        let session = win_tun.WintunStartSession(adapter, 128 * 1024);
+        if session.is_null() {
+            return Err(io::Error::new(io::ErrorKind::Other, "WintunStartSession failed"));
+        }
+        //SAFETY: We follow the contract required by CreateEventA. See MSDN
+        //(the pointers are allowed to be null, and 0 is okay for the others)
+        let shutdown_event = synchapi::CreateEventA(std::ptr::null_mut(),
+                                                    0, 0, std::ptr::null_mut());
+        let read_event = win_tun.WintunGetReadWaitEvent(session) as winnt::HANDLE;
+        let mut luid: wintun_raw::NET_LUID = std::mem::zeroed();
+        win_tun.WintunGetAdapterLUID(adapter, &mut luid as *mut wintun_raw::NET_LUID);
+        let index = ffi::luid_to_index(&std::mem::transmute(luid)).map(|index| index as u32)?;
+        Ok(TunDevice {
+            luid: std::mem::transmute(luid),
+            index,
+            session,
+            win_tun,
+            read_event,
+            shutdown_event,
+            adapter,
+        })
+    }
+    pub unsafe fn delete_for_name<L>(library: L, name: &str) -> io::Result<()>
+        where L: Into<libloading::Library>, {
+        let win_tun = match wintun_raw::wintun::from_library(library) {
+            Ok(win_tun) => win_tun,
+            Err(e) => {
+                return Err(io::Error::new(io::ErrorKind::Other, format!("library error {:?} ", e)));
+            }
+        };
+        log::set_default_logger_if_unset(&win_tun);
+        let name_utf16 = encode_utf16(name);
+        let adapter = win_tun.WintunOpenAdapter(name_utf16.as_ptr());
+        if adapter.is_null() {
+            return Err(io::Error::new(io::ErrorKind::Other, "Failed to open adapter"));
+        }
+        win_tun.WintunCloseAdapter(adapter);
+        win_tun.WintunDeleteDriver();
+        Ok(())
+    }
+    pub fn delete(self) -> io::Result<()> {
+        drop(self);
+        Ok(())
+    }
+    pub fn version(&self) -> io::Result<Version> {
+        let version = unsafe { self.win_tun.WintunGetRunningDriverVersion() };
+        if version == 0 {
+            return Err(io::Error::new(io::ErrorKind::Other, "WintunGetRunningDriverVersion"));
+        } else {
+            Ok(Version {
+                major: ((version >> 16) & 0xFF) as u16,
+                minor: (version & 0xFF) as u16,
+            })
+        }
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct Version {
+    pub major: u16,
+    pub minor: u16,
+}
+
+// impl TunDevice {
+//     fn get_adapter_luid(&self) -> u64 {
+//         let mut luid: wintun_raw::NET_LUID = unsafe { std::mem::zeroed() };
+//         unsafe { self.win_tun.WintunGetAdapterLUID(self.adapter, &mut luid as *mut wintun_raw::NET_LUID) };
+//         unsafe { std::mem::transmute(luid) }
+//     }
+// }
+
+
+impl IFace for TunDevice {
+    fn shutdown(&self) -> io::Result<()> {
+        let _ = unsafe { synchapi::SetEvent(self.shutdown_event) };
+        let _ = unsafe { handleapi::CloseHandle(self.shutdown_event) };
+        Ok(())
+    }
+
+    fn get_index(&self) -> io::Result<u32> {
+        Ok(self.index)
+    }
+
+    fn get_name(&self) -> io::Result<String> {
+        let luid = self.luid;
+        ffi::luid_to_alias(&unsafe { std::mem::transmute(luid) }).map(|name| {
+            decode_utf16(&name)
+        })
+    }
+
+    fn set_name(&self, new_name: &str) -> io::Result<()> {
+        let name = self.get_name()?;
+        netsh::set_interface_name(&name, new_name)
+    }
+
+    fn set_ip(&self, address: Ipv4Addr, mask: Ipv4Addr) -> io::Result<()>{
+        netsh::set_interface_ip(self.get_index()?, &address, &mask)
+    }
+
+    fn add_route(&self, dest: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr, metric: u16) -> io::Result<()>  {
+        route::add_route(self.get_index()?, dest, netmask, gateway, metric)
+    }
+
+    fn delete_route(&self, dest: Ipv4Addr, netmask: Ipv4Addr, gateway: Ipv4Addr) -> io::Result<()>  {
+        route::delete_route(self.get_index()?, dest, netmask, gateway)
+    }
+
+    fn set_mtu(&self, mtu: u16) -> io::Result<()> {
+        netsh::set_interface_mtu(self.get_index()?, mtu)
+    }
+
+    fn set_metric(&self, metric: u16) -> io::Result<()> {
+        let index = self.get_index()?;
+        netsh::set_interface_metric(index, metric)
+    }
+}
+
+impl TunDevice {
+    pub fn try_receive(&self) -> io::Result<Option<packet::TunPacket>> {
+        let mut size = 0u32;
+
+        let bytes_ptr = unsafe {
+            self.win_tun
+                .WintunReceivePacket(self.session, &mut size as *mut u32)
+        };
+
+        debug_assert!(size <= u16::MAX as u32);
+        if bytes_ptr.is_null() {
+            //Wintun returns ERROR_NO_MORE_ITEMS instead of blocking if packets are not available
+            let last_error = unsafe { winapi::um::errhandlingapi::GetLastError() };
+            if last_error == winapi::shared::winerror::ERROR_NO_MORE_ITEMS {
+                Ok(None)
+            } else {
+                Err(io::Error::new(io::ErrorKind::Other, "try_receive failed"))
+            }
+        } else {
+            Ok(Some(packet::TunPacket {
+                kind: packet::Kind::ReceivePacket,
+                size: size as usize,
+                //SAFETY: ptr is non null, aligned for u8, and readable for up to size bytes (which
+                //must be less than isize::MAX because bytes is a u16
+                bytes_ptr,
+                tun_device: Some(&self),
+            }))
+        }
+    }
+    pub fn receive_blocking(&self) -> io::Result<packet::TunPacket> {
+        loop {
+            //Try 5 times to receive without blocking so we don't have to issue a syscall to wait
+            //for the event if packets are being received at a rapid rate
+            for _ in 0..5 {
+                match self.try_receive()? {
+                    None => {
+                        continue;
+                    }
+                    Some(packet) => {
+                        return Ok(packet);
+                    }
+                }
+            }
+            //Wait on both the read handle and the shutdown handle so that we stop when requested
+            let handles = [self.read_event, self.shutdown_event];
+            let result = unsafe {
+                //SAFETY: We abide by the requirements of WaitForMultipleObjects, handles is a
+                //pointer to valid, aligned, stack memory
+                synchapi::WaitForMultipleObjects(
+                    2,
+                    &handles as *const winnt::HANDLE,
+                    0,
+                    winbase::INFINITE,
+                )
+            };
+            match result {
+                winbase::WAIT_FAILED => return Err(io::Error::new(io::ErrorKind::Other, "WAIT_FAILED")),
+                _ => {
+                    if result == winbase::WAIT_OBJECT_0 {
+                        //We have data!
+                        continue;
+                    } else if result == winbase::WAIT_OBJECT_0 + 1 {
+                        //Shutdown event triggered
+                        return Err(io::Error::new(io::ErrorKind::Other, "Shutdown event triggered"));
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl TunDevice {
+    pub fn allocate_send_packet(&self, size: u16) -> io::Result<packet::TunPacket> {
+        let bytes_ptr = unsafe {
+            self.win_tun.WintunAllocateSendPacket(self.session, size as u32)
+        };
+        if bytes_ptr.is_null() {
+            Err(io::Error::new(io::ErrorKind::Other, "allocate_send_packet failed"))
+        } else {
+            Ok(packet::TunPacket {
+                kind: packet::Kind::SendPacketPending,
+                size: size as usize,
+                //SAFETY: ptr is non null, aligned for u8, and readable for up to size bytes (which
+                //must be less than isize::MAX because bytes is a u16
+                bytes_ptr,
+                tun_device: None,
+            })
+        }
+    }
+    pub fn send_packet(&self, mut packet: packet::TunPacket) {
+        assert!(matches!(packet.kind, packet::Kind::SendPacketPending));
+
+        unsafe {
+            self.win_tun
+                .WintunSendPacket(self.session, packet.bytes_ptr)
+        };
+        //Mark the packet at sent
+        packet.kind = packet::Kind::SendPacketSent;
+    }
+}
+
+
+impl Drop for TunDevice {
+    fn drop(&mut self) {
+        //Close adapter on drop
+        //This is why we need an Arc of wintun
+        unsafe {
+            self.win_tun.WintunCloseAdapter(self.adapter);
+            self.win_tun.WintunDeleteDriver()
+        };
+    }
+}

switch/win-tun-tap/src/tun/packet.rs

@@ -0,0 +1,64 @@
+
+use crate::TunDevice;
+
+pub(crate) enum Kind {
+    SendPacketPending,
+    //Send packet type, but not sent yet
+    SendPacketSent,
+    //Send packet type - sent
+    ReceivePacket,
+}
+
+/// Represents a wintun packet
+pub struct TunPacket<'a> {
+    pub(crate) kind: Kind,
+    pub(crate) size:usize,
+    pub(crate) bytes_ptr: *const u8,
+
+    //Share ownership of session to prevent the session from being dropped before packets that
+    //belong to it
+    pub(crate) tun_device: Option<&'a TunDevice>,
+}
+
+impl <'a>TunPacket<'a> {
+    /// Returns the bytes this packet holds as &mut.
+    /// The lifetime of the bytes is tied to the lifetime of this packet.
+    pub fn bytes_mut(&mut self) -> &mut [u8] {
+        unsafe { std::slice::from_raw_parts_mut(self.bytes_ptr as *mut u8, self.size) }
+    }
+
+    /// Returns an immutable reference to the bytes this packet holds.
+    /// The lifetime of the bytes is tied to the lifetime of this packet.
+    pub fn bytes(&self) -> &[u8] {
+        unsafe { std::slice::from_raw_parts(self.bytes_ptr,self.size) }
+    }
+}
+
+impl <'a>Drop for TunPacket<'a> {
+    fn drop(&mut self) {
+        match self.kind {
+            Kind::ReceivePacket => {
+                unsafe {
+                    //SAFETY:
+                    //
+                    //  1. We share ownership of the session therefore it hasn't been dropped yet
+                    //  2. Bytes is valid because each packet holds exclusive access to a region of the
+                    //     ring buffer that the wintun session owns. We return that region of
+                    //     memory back to wintun here
+                    let tun_device = self.tun_device.unwrap();
+                    tun_device.win_tun
+                        .WintunReleaseReceivePacket(tun_device.session, self.bytes_ptr)
+                };
+            }
+            Kind::SendPacketPending => {
+                //If someone allocates a packet with session.allocate_send_packet() and then it is
+                //dropped without being sent, this will hold up the send queue because wintun expects
+                //that every allocated packet is sent
+                panic!("Packet was never sent!");
+            }
+            Kind::SendPacketSent => {
+                //Nop
+            }
+        }
+    }
+}

switch/win-tun-tap/src/tun/wintun_raw.rs

@@ -0,0 +1,447 @@
+/* automatically generated by rust-bindgen 0.59.1 */
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+    where
+        Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+pub type wchar_t = ::std::os::raw::c_ushort;
+pub type DWORD = ::std::os::raw::c_ulong;
+pub type BOOL = ::std::os::raw::c_int;
+pub type BYTE = ::std::os::raw::c_uchar;
+pub type ULONG64 = ::std::os::raw::c_ulonglong;
+pub type DWORD64 = ::std::os::raw::c_ulonglong;
+pub type WCHAR = wchar_t;
+pub type LPCWSTR = *const WCHAR;
+pub type HANDLE = *mut ::std::os::raw::c_void;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _GUID {
+    pub Data1: ::std::os::raw::c_ulong,
+    pub Data2: ::std::os::raw::c_ushort,
+    pub Data3: ::std::os::raw::c_ushort,
+    pub Data4: [::std::os::raw::c_uchar; 8usize],
+}
+#[test]
+fn bindgen_test_layout__GUID() {
+    assert_eq!(
+        ::std::mem::size_of::<_GUID>(),
+        16usize,
+        concat!("Size of: ", stringify!(_GUID))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_GUID>(),
+        4usize,
+        concat!("Alignment of ", stringify!(_GUID))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<_GUID>())).Data1 as *const _ as usize },
+        0usize,
+        concat!(
+        "Offset of field: ",
+        stringify!(_GUID),
+        "::",
+        stringify!(Data1)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<_GUID>())).Data2 as *const _ as usize },
+        4usize,
+        concat!(
+        "Offset of field: ",
+        stringify!(_GUID),
+        "::",
+        stringify!(Data2)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<_GUID>())).Data3 as *const _ as usize },
+        6usize,
+        concat!(
+        "Offset of field: ",
+        stringify!(_GUID),
+        "::",
+        stringify!(Data3)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<_GUID>())).Data4 as *const _ as usize },
+        8usize,
+        concat!(
+        "Offset of field: ",
+        stringify!(_GUID),
+        "::",
+        stringify!(Data4)
+        )
+    );
+}
+pub type GUID = _GUID;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union _NET_LUID_LH {
+    pub Value: ULONG64,
+    pub Info: _NET_LUID_LH__bindgen_ty_1,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
+pub struct _NET_LUID_LH__bindgen_ty_1 {
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
+}
+#[test]
+fn bindgen_test_layout__NET_LUID_LH__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<_NET_LUID_LH__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(_NET_LUID_LH__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_NET_LUID_LH__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(_NET_LUID_LH__bindgen_ty_1))
+    );
+}
+impl _NET_LUID_LH__bindgen_ty_1 {
+    #[inline]
+    pub fn Reserved(&self) -> ULONG64 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u64) }
+    }
+    #[inline]
+    pub fn set_Reserved(&mut self, val: ULONG64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 24u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn NetLuidIndex(&self) -> ULONG64 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 24u8) as u64) }
+    }
+    #[inline]
+    pub fn set_NetLuidIndex(&mut self, val: ULONG64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 24u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn IfType(&self) -> ULONG64 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
+    }
+    #[inline]
+    pub fn set_IfType(&mut self, val: ULONG64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(48usize, 16u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        Reserved: ULONG64,
+        NetLuidIndex: ULONG64,
+        IfType: ULONG64,
+    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 24u8, {
+            let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
+            Reserved as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 24u8, {
+            let NetLuidIndex: u64 = unsafe { ::std::mem::transmute(NetLuidIndex) };
+            NetLuidIndex as u64
+        });
+        __bindgen_bitfield_unit.set(48usize, 16u8, {
+            let IfType: u64 = unsafe { ::std::mem::transmute(IfType) };
+            IfType as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[test]
+fn bindgen_test_layout__NET_LUID_LH() {
+    assert_eq!(
+        ::std::mem::size_of::<_NET_LUID_LH>(),
+        8usize,
+        concat!("Size of: ", stringify!(_NET_LUID_LH))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_NET_LUID_LH>(),
+        8usize,
+        concat!("Alignment of ", stringify!(_NET_LUID_LH))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<_NET_LUID_LH>())).Value as *const _ as usize },
+        0usize,
+        concat!(
+        "Offset of field: ",
+        stringify!(_NET_LUID_LH),
+        "::",
+        stringify!(Value)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<_NET_LUID_LH>())).Info as *const _ as usize },
+        0usize,
+        concat!(
+        "Offset of field: ",
+        stringify!(_NET_LUID_LH),
+        "::",
+        stringify!(Info)
+        )
+    );
+}
+pub type NET_LUID_LH = _NET_LUID_LH;
+pub type NET_LUID = NET_LUID_LH;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _WINTUN_ADAPTER {
+    _unused: [u8; 0],
+}
+#[doc = " A handle representing Wintun adapter"]
+pub type WINTUN_ADAPTER_HANDLE = *mut _WINTUN_ADAPTER;
+#[doc = "< Informational"]
+pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_INFO: WINTUN_LOGGER_LEVEL = 0;
+#[doc = "< Warning"]
+pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_WARN: WINTUN_LOGGER_LEVEL = 1;
+#[doc = "< Error"]
+pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_ERR: WINTUN_LOGGER_LEVEL = 2;
+#[doc = " Determines the level of logging, passed to WINTUN_LOGGER_CALLBACK."]
+pub type WINTUN_LOGGER_LEVEL = ::std::os::raw::c_int;
+#[doc = " Called by internal logger to report diagnostic messages"]
+#[doc = ""]
+#[doc = " @param Level         Message level."]
+#[doc = ""]
+#[doc = " @param Timestamp     Message timestamp in in 100ns intervals since 1601-01-01 UTC."]
+#[doc = ""]
+#[doc = " @param Message       Message text."]
+pub type WINTUN_LOGGER_CALLBACK = ::std::option::Option<
+    unsafe extern "C" fn(Level: WINTUN_LOGGER_LEVEL, Timestamp: DWORD64, Message: LPCWSTR),
+>;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _TUN_SESSION {
+    _unused: [u8; 0],
+}
+#[doc = " A handle representing Wintun session"]
+pub type WINTUN_SESSION_HANDLE = *mut _TUN_SESSION;
+extern crate libloading;
+pub struct wintun {
+    __library: ::libloading::Library,
+    pub WintunCreateAdapter: unsafe extern "C" fn(
+        arg1: LPCWSTR,
+        arg2: LPCWSTR,
+        arg3: *const GUID,
+    ) -> WINTUN_ADAPTER_HANDLE,
+    pub WintunCloseAdapter: unsafe extern "C" fn(arg1: WINTUN_ADAPTER_HANDLE),
+    pub WintunOpenAdapter: unsafe extern "C" fn(arg1: LPCWSTR) -> WINTUN_ADAPTER_HANDLE,
+    pub WintunGetAdapterLUID:
+    unsafe extern "C" fn(arg1: WINTUN_ADAPTER_HANDLE, arg2: *mut NET_LUID),
+    pub WintunGetRunningDriverVersion: unsafe extern "C" fn() -> DWORD,
+    pub WintunDeleteDriver: unsafe extern "C" fn() -> BOOL,
+    pub WintunSetLogger: unsafe extern "C" fn(arg1: WINTUN_LOGGER_CALLBACK),
+    pub WintunStartSession:
+    unsafe extern "C" fn(arg1: WINTUN_ADAPTER_HANDLE, arg2: DWORD) -> WINTUN_SESSION_HANDLE,
+    pub WintunEndSession: unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE),
+    pub WintunGetReadWaitEvent: unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE) -> HANDLE,
+    pub WintunReceivePacket:
+    unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *mut DWORD) -> *mut BYTE,
+    pub WintunReleaseReceivePacket:
+    unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE),
+    pub WintunAllocateSendPacket:
+    unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: DWORD) -> *mut BYTE,
+    pub WintunSendPacket: unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE),
+}
+impl wintun {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+        where
+            P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
+        where
+            L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let WintunCreateAdapter = __library.get(b"WintunCreateAdapter\0").map(|sym| *sym)?;
+        let WintunCloseAdapter = __library.get(b"WintunCloseAdapter\0").map(|sym| *sym)?;
+        let WintunOpenAdapter = __library.get(b"WintunOpenAdapter\0").map(|sym| *sym)?;
+        let WintunGetAdapterLUID = __library.get(b"WintunGetAdapterLUID\0").map(|sym| *sym)?;
+        let WintunGetRunningDriverVersion = __library
+            .get(b"WintunGetRunningDriverVersion\0")
+            .map(|sym| *sym)?;
+        let WintunDeleteDriver = __library.get(b"WintunDeleteDriver\0").map(|sym| *sym)?;
+        let WintunSetLogger = __library.get(b"WintunSetLogger\0").map(|sym| *sym)?;
+        let WintunStartSession = __library.get(b"WintunStartSession\0").map(|sym| *sym)?;
+        let WintunEndSession = __library.get(b"WintunEndSession\0").map(|sym| *sym)?;
+        let WintunGetReadWaitEvent = __library.get(b"WintunGetReadWaitEvent\0").map(|sym| *sym)?;
+        let WintunReceivePacket = __library.get(b"WintunReceivePacket\0").map(|sym| *sym)?;
+        let WintunReleaseReceivePacket = __library
+            .get(b"WintunReleaseReceivePacket\0")
+            .map(|sym| *sym)?;
+        let WintunAllocateSendPacket = __library
+            .get(b"WintunAllocateSendPacket\0")
+            .map(|sym| *sym)?;
+        let WintunSendPacket = __library.get(b"WintunSendPacket\0").map(|sym| *sym)?;
+        Ok(wintun {
+            __library,
+            WintunCreateAdapter,
+            WintunCloseAdapter,
+            WintunOpenAdapter,
+            WintunGetAdapterLUID,
+            WintunGetRunningDriverVersion,
+            WintunDeleteDriver,
+            WintunSetLogger,
+            WintunStartSession,
+            WintunEndSession,
+            WintunGetReadWaitEvent,
+            WintunReceivePacket,
+            WintunReleaseReceivePacket,
+            WintunAllocateSendPacket,
+            WintunSendPacket,
+        })
+    }
+    pub unsafe fn WintunCreateAdapter(
+        &self,
+        arg1: LPCWSTR,
+        arg2: LPCWSTR,
+        arg3: *const GUID,
+    ) -> WINTUN_ADAPTER_HANDLE {
+        (self.WintunCreateAdapter)(arg1, arg2, arg3)
+    }
+    pub unsafe fn WintunCloseAdapter(&self, arg1: WINTUN_ADAPTER_HANDLE) -> () {
+        (self.WintunCloseAdapter)(arg1)
+    }
+    pub unsafe fn WintunOpenAdapter(&self, arg1: LPCWSTR) -> WINTUN_ADAPTER_HANDLE {
+        (self.WintunOpenAdapter)(arg1)
+    }
+    pub unsafe fn WintunGetAdapterLUID(
+        &self,
+        arg1: WINTUN_ADAPTER_HANDLE,
+        arg2: *mut NET_LUID,
+    ) -> () {
+        (self.WintunGetAdapterLUID)(arg1, arg2)
+    }
+    pub unsafe fn WintunGetRunningDriverVersion(&self) -> DWORD {
+        (self.WintunGetRunningDriverVersion)()
+    }
+    pub unsafe fn WintunDeleteDriver(&self) -> BOOL {
+        (self.WintunDeleteDriver)()
+    }
+    pub unsafe fn WintunSetLogger(&self, arg1: WINTUN_LOGGER_CALLBACK) -> () {
+        (self.WintunSetLogger)(arg1)
+    }
+    pub unsafe fn WintunStartSession(
+        &self,
+        arg1: WINTUN_ADAPTER_HANDLE,
+        arg2: DWORD,
+    ) -> WINTUN_SESSION_HANDLE {
+        (self.WintunStartSession)(arg1, arg2)
+    }
+    pub unsafe fn WintunEndSession(&self, arg1: WINTUN_SESSION_HANDLE) -> () {
+        (self.WintunEndSession)(arg1)
+    }
+    pub unsafe fn WintunGetReadWaitEvent(&self, arg1: WINTUN_SESSION_HANDLE) -> HANDLE {
+        (self.WintunGetReadWaitEvent)(arg1)
+    }
+    pub unsafe fn WintunReceivePacket(
+        &self,
+        arg1: WINTUN_SESSION_HANDLE,
+        arg2: *mut DWORD,
+    ) -> *mut BYTE {
+        (self.WintunReceivePacket)(arg1, arg2)
+    }
+    pub unsafe fn WintunReleaseReceivePacket(
+        &self,
+        arg1: WINTUN_SESSION_HANDLE,
+        arg2: *const BYTE,
+    ) -> () {
+        (self.WintunReleaseReceivePacket)(arg1, arg2)
+    }
+    pub unsafe fn WintunAllocateSendPacket(
+        &self,
+        arg1: WINTUN_SESSION_HANDLE,
+        arg2: DWORD,
+    ) -> *mut BYTE {
+        (self.WintunAllocateSendPacket)(arg1, arg2)
+    }
+    pub unsafe fn WintunSendPacket(&self, arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE) -> () {
+        (self.WintunSendPacket)(arg1, arg2)
+    }
+}