支持数据压缩

去除安卓上的icmp代理
停止时回收连接通道
2024-05-25 17:30:27 +08:00 · 2024-05-23 22:35:37 +08:00 · 2024-05-23 22:35:24 +08:00 · 2024-05-23 22:35:06 +08:00 · 2024-05-21 20:37:55 +08:00 · 2024-05-15 20:30:42 +08:00
110 changed files with 6683 additions and 4151 deletions
@@ -51,9 +51,15 @@ jobs:
          - TARGET: armv7-unknown-linux-musleabihf # raspberry pi 2-3-4, not tested
            OS: ubuntu-latest
            FEATURES: openssl-vendored
+          - TARGET: armv7-unknown-linux-musleabi # raspberry pi 2-3-4, not tested
+            OS: ubuntu-latest
+            FEATURES: openssl-vendored
          - TARGET: arm-unknown-linux-musleabihf # raspberry pi 0-1, not tested
            OS: ubuntu-latest
            FEATURES: ring-cipher,openssl-vendored
+          - TARGET: arm-unknown-linux-musleabi # raspberry pi 0-1, not tested
+            OS: ubuntu-latest
+            FEATURES: ring-cipher,openssl-vendored
          - TARGET: x86_64-apple-darwin # tested on a mac, is not properly signed so there are security warnings
            OS: macos-latest
            FEATURES: ring-cipher,openssl-vendored
@@ -99,6 +105,8 @@ jobs:
        run: |
          # dependencies are only needed on ubuntu as that's the only place where
          # we make cross-compilation
+          rustup set auto-self-update disable
+          
          if [[ $OS =~ ^ubuntu.*$ ]]; then
            sudo apt-get update && sudo apt-get install -qq crossbuild-essential-arm64 crossbuild-essential-armhf musl-tools
            #  curl -s musl.cc | grep mipsel
@@ -111,9 +119,15 @@ jobs:
                ;;
              armv7-unknown-linux-musleabihf)
                MUSL_URI=armv7l-linux-musleabihf-cross
+                ;;    
+              armv7-unknown-linux-musleabi)
+                MUSL_URI=armv7m-linux-musleabi-cross
                ;;   
              arm-unknown-linux-musleabihf)
                MUSL_URI=arm-linux-musleabihf-cross
+                ;;    
+              arm-unknown-linux-musleabi)
+                MUSL_URI=arm-linux-musleabi-cross
                ;;        
              mips-unknown-linux-musl)
                MUSL_URI=mips-linux-musl-cross
@@ -124,6 +138,9 @@ jobs:
              # mips平台使用1.71.1版本
              rustup install 1.71.1
              rustup default 1.71.1  
+            else
+              rustup install 1.77
+              rustup default 1.77
            fi
          
            if [  -n "$MUSL_URI" ]; then
@@ -132,8 +149,11 @@ jobs:
              tar zxf ./musl_gcc/$MUSL_URI.tgz -C ./musl_gcc/
              sudo ln -s $(pwd)/musl_gcc/$MUSL_URI/bin/*gcc /usr/bin/
            fi
+          else
+            rustup install 1.77
+            rustup default 1.77 
          fi
-          
+          rustup -V
          
          # some additional configuration for cross-compilation on linux
          cat >>~/.cargo/config <<EOF
@@ -145,8 +165,14 @@ jobs:
          [target.armv7-unknown-linux-musleabihf]
          linker = "armv7l-linux-musleabihf-gcc"
          rustflags = ["-C", "target-feature=+crt-static","-C", "strip=symbols"]
+          [target.armv7-unknown-linux-musleabi]
+          linker = "armv7m-linux-musleabi-gcc"
+          rustflags = ["-C", "target-feature=+crt-static","-C", "strip=symbols"]
          [target.arm-unknown-linux-musleabihf]
          linker = "arm-linux-musleabihf-gcc"
+          rustflags = ["-C", "target-feature=+crt-static","-C", "strip=symbols"]   
+          [target.arm-unknown-linux-musleabi]
+          linker = "arm-linux-musleabi-gcc"
          rustflags = ["-C", "target-feature=+crt-static","-C", "strip=symbols"]
          [target.mipsel-unknown-linux-musl]
          linker = "mipsel-linux-musl-gcc"
@@ -0,0 +1,3 @@
+target/*
+vnt/src/proto/*
+vnt-cli/src/generated_serial_number.rs
@@ -0,0 +1,2054 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "addr2line"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
+dependencies = [
+ "aead",
+ "aes",
+ "cipher",
+ "ctr",
+ "ghash",
+ "subtle",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_log-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ecc8056bf6ab9892dcd53216c83d1597487d7dacac16c8df6b877d127df9937"
+
+[[package]]
+name = "android_logger"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c494134f746c14dc653a35a4ea5aca24ac368529da5370ecf41fe0341c35772f"
+dependencies = [
+ "android_log-sys",
+ "env_logger",
+ "log",
+ "once_cell",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519"
+
+[[package]]
+name = "arc-swap"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
+
+[[package]]
+name = "autocfg"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
+
+[[package]]
+name = "backtrace"
+version = "0.3.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17f6e324229dc011159fcc089755d1e2e216a90d43a7dea6853ca740b84f35e7"
+dependencies = [
+ "jobserver",
+ "libc",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "common"
+version = "1.2.10"
+
+[[package]]
+name = "console"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+dependencies = [
+ "encode_unicode",
+ "lazy_static",
+ "libc",
+ "unicode-width",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "typenum",
+]
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "destructure_traitobject"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c877555693c14d2f84191cfd3ad8582790fc52b5e2274b40b59cf5f5cea25c7"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+]
+
+[[package]]
+name = "dns-parser"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4d33be9473d06f75f58220f71f7a9317aca647dc061dbd3c361b0bef505fbea"
+dependencies = [
+ "byteorder",
+ "quick-error",
+]
+
+[[package]]
+name = "ecb"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a8bfa975b1aec2145850fcaa1c6fe269a16578c44705a532ae3edc92b8881c7"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "either"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47c1c47d2f5964e29c61246e81db715514cd532db6b5116a25ea3c03d6780a2"
+
+[[package]]
+name = "embed-manifest"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41cd446c890d6bed1d8b53acef5f240069ebef91d6fae7c5f52efe61fe8b5eae"
+
+[[package]]
+name = "encode_unicode"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+
+[[package]]
+name = "env_logger"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "errno"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getopts"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ghash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
+dependencies = [
+ "opaque-debug",
+ "polyval",
+]
+
+[[package]]
+name = "gimli"
+version = "0.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+
+[[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.14.3",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
+[[package]]
+name = "ioctl-sys"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bd11f3a29434026f5ff98c730b668ba74b1033637b8817940b54d040696133c"
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
+[[package]]
+name = "jobserver"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+dependencies = [
+ "spin 0.5.2",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "libloading"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
+dependencies = [
+ "cfg-if",
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "libsm"
+version = "0.5.1"
+source = "git+https://github.com/lbl8603/libsm#f9e1b8cf20d0829efb4934a940d0ba4f3ee0ac14"
+dependencies = [
+ "byteorder",
+ "getrandom",
+ "lazy_static",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "rand",
+ "yasna",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+
+[[package]]
+name = "lock_api"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "log-mdc"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a94d21414c1f4a51209ad204c1776a3d0765002c76c6abcb602a6f09f1e881c7"
+
+[[package]]
+name = "log4rs"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0816135ae15bd0391cf284eab37e6e3ee0a6ee63d2ceeb659862bd8d0a984ca6"
+dependencies = [
+ "anyhow",
+ "arc-swap",
+ "chrono",
+ "derivative",
+ "fnv",
+ "humantime",
+ "libc",
+ "log",
+ "log-mdc",
+ "once_cell",
+ "parking_lot",
+ "rand",
+ "serde",
+ "serde-value",
+ "serde_json",
+ "serde_yaml",
+ "thiserror",
+ "thread-id",
+ "typemap-ors",
+ "winapi",
+]
+
+[[package]]
+name = "lz4_flex"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"
+
+[[package]]
+name = "memchr"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint-dig"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc84195820f291c7697304f3cbdadd1cb7199c0efc917ff5eafd71225c136151"
+dependencies = [
+ "byteorder",
+ "lazy_static",
+ "libm",
+ "num-integer",
+ "num-iter",
+ "num-traits",
+ "rand",
+ "smallvec",
+ "zeroize",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "object"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "openssl-src"
+version = "300.1.3+3.1.2"
+source = "git+https://github.com/lbl8603/openssl-src-rs#871c5d6cfe8a7cb1c5725638d7563c0d96ca4c04"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.93"
+source = "git+https://github.com/lbl8603/rust-openssl#e8b3d2c02d2d07a0e4a82ff4e4bef210f4bc71c8"
+dependencies = [
+ "cc",
+ "libc",
+ "openssl-src",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "ordered-float"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "os_info"
+version = "3.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae99c7fa6dd38c7cafe1ec085e804f8f555a2f8659b0dbe03f1f9963a9b51092"
+dependencies = [
+ "log",
+ "serde",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "packet"
+version = "0.1.0"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+
+[[package]]
+name = "pkcs1"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
+dependencies = [
+ "der",
+ "pkcs8",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "polyval"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "protobuf"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58678a64de2fced2bdec6bca052a6716a0efe692d6e3f53d1bda6a1def64cfc0"
+dependencies = [
+ "once_cell",
+ "protobuf-support",
+ "thiserror",
+]
+
+[[package]]
+name = "protobuf-codegen"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32777b0b3f6538d9d2e012b3fad85c7e4b9244b5958d04a6415f4333782b7a77"
+dependencies = [
+ "anyhow",
+ "once_cell",
+ "protobuf",
+ "protobuf-parse",
+ "regex",
+ "tempfile",
+ "thiserror",
+]
+
+[[package]]
+name = "protobuf-parse"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96cb37955261126624a25b5e6bda40ae34cf3989d52a783087ca6091b29b5642"
+dependencies = [
+ "anyhow",
+ "indexmap 1.9.3",
+ "log",
+ "protobuf",
+ "protobuf-support",
+ "tempfile",
+ "thiserror",
+ "which",
+]
+
+[[package]]
+name = "protobuf-support"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1ed294a835b0f30810e13616b1cd34943c6d1e84a8f3b0dcfe466d256c3e7e7"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "protoc-bin-vendored"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "005ca8623e5633e298ad1f917d8be0a44bcf406bf3cde3b80e63003e49a3f27d"
+dependencies = [
+ "protoc-bin-vendored-linux-aarch_64",
+ "protoc-bin-vendored-linux-ppcle_64",
+ "protoc-bin-vendored-linux-x86_32",
+ "protoc-bin-vendored-linux-x86_64",
+ "protoc-bin-vendored-macos-x86_64",
+ "protoc-bin-vendored-win32",
+]
+
+[[package]]
+name = "protoc-bin-vendored-linux-aarch_64"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fb9fc9cce84c8694b6ea01cc6296617b288b703719b725b8c9c65f7c5874435"
+
+[[package]]
+name = "protoc-bin-vendored-linux-ppcle_64"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02d2a07dcf7173a04d49974930ccbfb7fd4d74df30ecfc8762cf2f895a094516"
+
+[[package]]
+name = "protoc-bin-vendored-linux-x86_32"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54fef0b04fcacba64d1d80eed74a20356d96847da8497a59b0a0a436c9165b0"
+
+[[package]]
+name = "protoc-bin-vendored-linux-x86_64"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8782f2ce7d43a9a5c74ea4936f001e9e8442205c244f7a3d4286bd4c37bc924"
+
+[[package]]
+name = "protoc-bin-vendored-macos-x86_64"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5de656c7ee83f08e0ae5b81792ccfdc1d04e7876b1d9a38e6876a9e09e02537"
+
+[[package]]
+name = "protoc-bin-vendored-win32"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9653c3ed92974e34c5a6e0a510864dab979760481714c172e0a34e437cb98804"
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quote"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-ex"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42776a943a4f890410259860d4c308d32792ecbeaca4932a2b94b04f6d27bb9a"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
+
+[[package]]
+name = "ring"
+version = "0.17.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom",
+ "libc",
+ "spin 0.9.8",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rsa"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e5124fcb30e76a7e79bfee683a2746db83784b86289f6251b54b7950a0dfc"
+dependencies = [
+ "const-oid",
+ "digest",
+ "num-bigint-dig",
+ "num-integer",
+ "num-traits",
+ "pkcs1",
+ "pkcs8",
+ "rand_core",
+ "signature",
+ "spki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+
+[[package]]
+name = "rustix"
+version = "0.38.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
+dependencies = [
+ "bitflags 2.5.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.198"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9846a40c979031340571da2545a4e5b7c4163bdae79b301d5f86d03979451fcc"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-value"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
+dependencies = [
+ "ordered-float",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.198"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e88edab869b01783ba905e7d0153f9fc1a6505a96e4ad3018011eedb838566d9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.116"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap 2.2.6",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "socket2"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+ "sha2",
+]
+
+[[package]]
+name = "stun-bytes"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bebd666814c8af1e06e4d489f9c3d03a4aef20bae651550c52e6e95e09f3f12"
+dependencies = [
+ "r-ex",
+]
+
+[[package]]
+name = "stun-format"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6ad3c54fde6dfd6fe5048a71515b392d22c29730533663b5300e1b511d78df5"
+dependencies = [
+ "r-ex",
+ "stun-bytes",
+]
+
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
+[[package]]
+name = "sudo"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88bd84d4c082e18e37fef52c0088e4407dabcef19d23a607fb4b5ee03b7d5b83"
+dependencies = [
+ "libc",
+ "log",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "rustix",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "thread-id"
+version = "4.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0ec81c46e9eb50deaa257be2f148adf052d1fb7701cfd55ccfab2525280b70b"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "tokio"
+version = "1.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "libc",
+ "mio",
+ "num_cpus",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "tun"
+version = "0.1.0"
+dependencies = [
+ "ioctl-sys",
+ "libc",
+ "libloading",
+ "log",
+ "rand",
+ "widestring",
+ "winapi",
+]
+
+[[package]]
+name = "typemap-ors"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a68c24b707f02dd18f1e4ccceb9d49f2058c2fb86384ef9972592904d7a28867"
+dependencies = [
+ "unsafe-any-ors",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "unsafe-any-ors"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0a303d30665362d9680d7d91d78b23f5f899504d4f08b3c4cf08d055d87c0ad"
+dependencies = [
+ "destructure_traitobject",
+]
+
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "uuid"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "vnt"
+version = "1.2.10"
+dependencies = [
+ "aes",
+ "aes-gcm",
+ "anyhow",
+ "bytes",
+ "cbc",
+ "crossbeam-epoch",
+ "crossbeam-queue",
+ "crossbeam-utils",
+ "dns-parser",
+ "ecb",
+ "libc",
+ "libloading",
+ "libsm",
+ "log",
+ "lz4_flex",
+ "mio",
+ "openssl-sys",
+ "packet",
+ "parking_lot",
+ "protobuf",
+ "protobuf-codegen",
+ "protoc-bin-vendored",
+ "rand",
+ "ring",
+ "rsa",
+ "sha2",
+ "socket2",
+ "spki",
+ "stun-format",
+ "thiserror",
+ "tokio",
+ "tun",
+ "zstd",
+]
+
+[[package]]
+name = "vnt-cli"
+version = "1.2.10"
+dependencies = [
+ "anyhow",
+ "chrono",
+ "common",
+ "console",
+ "embed-manifest",
+ "getopts",
+ "log",
+ "log4rs",
+ "os_info",
+ "rand",
+ "serde",
+ "serde_yaml",
+ "sudo",
+ "uuid",
+ "vnt",
+ "winapi",
+]
+
+[[package]]
+name = "vnt-jni"
+version = "1.2.10"
+dependencies = [
+ "android_logger",
+ "common",
+ "jni",
+ "log",
+ "parking_lot",
+ "spki",
+ "vnt",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+
+[[package]]
+name = "which"
+version = "4.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
+dependencies = [
+ "either",
+ "home",
+ "once_cell",
+ "rustix",
+]
+
+[[package]]
+name = "widestring"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.5",
+ "windows_aarch64_msvc 0.52.5",
+ "windows_i686_gnu 0.52.5",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.5",
+ "windows_x86_64_gnu 0.52.5",
+ "windows_x86_64_gnullvm 0.52.5",
+ "windows_x86_64_msvc 0.52.5",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+
+[[package]]
+name = "yasna"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd"
+dependencies = [
+ "num-bigint",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
+
+[[package]]
+name = "zstd"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d789b1514203a1120ad2429eae43a7bd32b90976a7bb8a05f7ec02fa88cc23a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cd99b45c6bc03a018c8b8a86025678c87e55526064e38f9df301989dce7ec0a"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.10+zstd.1.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
@@ -39,7 +39,7 @@ A virtual network tool (VPN)
    ```
 4. 最后可以用虚拟ip实现设备间相互访问

-      <img width="506" alt="ssh" src="https://raw.githubusercontent.com/lbl8603/vnt/dev/documents/img/ssh.jpg">
+      <img width="506" alt="ssh" src="https://raw.githubusercontent.com/lbl8603/vnt/main/documents/img/ssh.jpg">
 5. 帮助，使用-h命令查看

 ### 更多玩法
@@ -84,24 +84,36 @@ features说明
 | sm4_cbc          | 支持sm4_cbc加密          | 是    |
 | server_encrypt   | 支持服务端加密              | 是    |
 | ip_proxy         | 内置ip代理               | 是    |
+| port_mapping     | 端口映射                 | 是    |
+| log              | 日志                   | 是    |
+| command          | list、route等命令        | 是    |
+| file_config      | yaml配置文件             | 是    |
+| lz4              | lz4压缩                | 是    |
+| zstd             | zstd压缩               | 否    |

 ### ip转发/代理
+
 如果编译时去除了内置的ip代理(或使用--no-proxy关闭了代理)，则可以使用网卡NAT转发来实现点对网，
 一般来说使用网卡NAT转发会比内置的ip代理性能更好
 <details> <summary>NAT配置可参考如下示例,点击展开</summary>

 ### 在出口一端做如下配置
+
 注意原有的-i(入口)和-o(出口)的参数不能少

 ### windows
+
 参考 https://learn.microsoft.com/zh-cn/virtualization/hyper-v-on-windows/user-guide/setup-nat-network
+
 ```shell
 #设置nat,名字可以自己取，网段是vnt的网段
 New-NetNat -Name vntnat -InternalIPInterfaceAddressPrefix 10.26.0.0/24
 #查看设置
 Get-NetNat
 ```
+
 ### linux
+
 ```shell
 # 开启ip转发
 sudo sysctl -w net.ipv4.ip_forward=1
@@ -144,6 +156,7 @@ sudo iptables-restore iptables.rules
 ```

 ### macos
+
 ```shell
 # 开启ip转发
 sudo sysctl -w net.ipv4.ip_forward=1
@@ -153,6 +166,7 @@ nat on en0 from 10.26.0.0/24 to any -> (en0)
 # 加载规则
 sudo pfctl -f /etc/pf.conf -e
 ```
+
 </details>

 ### 支持平台
@@ -255,10 +269,15 @@ vnt默认使用10.26.0.0/24网段，和本地网络适配器的ip冲突
 2. 如果p2p后效果很差，可以选择禁用p2p（vnt-cli增加--use-channel relay 参数）

 #### 问题4：重启后虚拟IP发生变化，或指定了IP不能启动
+
 ##### 可能原因：
+
 设备重启后程序自动获取的id值改变，导致注册时重新分配了新的IP，或是IP冲突
+
 ##### 解决方法：
+
 1. 命令行启动增加-d参数（使用配置文件启动则在配置文件中增加device_id参数），要保证每个设备的值都不一样，取值可以任意64位以内字符串
+
 </details>

 ### 交流群
@@ -1,6 +1,6 @@
 [package]
 name = "common"
-version = "1.2.9"
+version = "1.2.10"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -7,33 +7,33 @@ pub fn ips_parse(ips: &Vec<String>) -> Result<Vec<(u32, u32, Ipv4Addr)>, String>
        let net = if let Some(net) = split.next() {
            net
        } else {
-            return Err("ipv4/mask,ipv4".to_string());
+            return Err(format!("ipv4/mask,ipv4 {:?}", x));
        };
        let ip = if let Some(ip) = split.next() {
            ip
        } else {
-            return Err("ipv4/mask,ipv4".to_string());
+            return Err(format!("ipv4/mask,ipv4 {:?}", x));
        };
        let ip = if let Ok(ip) = ip.parse::<Ipv4Addr>() {
            ip
        } else {
-            return Err("not ipv4".to_string());
+            return Err(format!("not ipv4 {:?}", ip));
        };
        let mut split = net.split("/");
        let dest = if let Some(dest) = split.next() {
            dest
        } else {
-            return Err("no ipv4/mask".to_string());
+            return Err(format!("no ipv4/mask {:?}", net));
        };
        let mask = if let Some(mask) = split.next() {
            mask
        } else {
-            return Err("no netmask".to_string());
+            return Err(format!("no netmask {:?}", net));
        };
        let dest = if let Ok(dest) = dest.parse::<Ipv4Addr>() {
            dest
        } else {
-            return Err("not ipv4".to_string());
+            return Err(format!("not ipv4 {:?}", dest));
        };
        let mask = to_ip(mask)?;
        in_ips_c.push((u32::from_be_bytes(dest.octets()), mask, ip));
@@ -48,17 +48,17 @@ pub fn out_ips_parse(ips: &Vec<String>) -> Result<Vec<(u32, u32)>, String> {
        let dest = if let Some(dest) = split.next() {
            dest
        } else {
-            return Err("no ipv4/mask".to_string());
+            return Err(format!("no ipv4/mask {:?}", x));
        };
        let mask = if let Some(mask) = split.next() {
            mask
        } else {
-            return Err("no netmask".to_string());
+            return Err(format!("no netmask {:?}", x));
        };
        let dest = if let Ok(dest) = dest.parse::<Ipv4Addr>() {
            dest
        } else {
-            return Err("not ipv4".to_string());
+            return Err(format!("not ipv4 {:?}", dest));
        };
        let mask = to_ip(mask)?;
        in_ips_c.push((u32::from_be_bytes(dest.octets()), mask));
@@ -68,10 +68,10 @@ pub fn out_ips_parse(ips: &Vec<String>) -> Result<Vec<(u32, u32)>, String> {

 pub fn to_ip(mask: &str) -> Result<u32, String> {
    if let Ok(m) = mask.parse::<u32>() {
-        if m >= 32 {
+        if m > 32 {
            return Err("not netmask".to_string());
        }
-        let mut mask = 0 as u32;
+        let mut mask = 0u32;
        for i in 0..m {
            mask = mask | (1 << (31 - i));
        }
@@ -51,6 +51,16 @@ pub fn get_unique_identifier() -> Option<String> {
 #[cfg(target_os = "linux")]
 pub fn get_unique_identifier() -> Option<String> {
    use std::process::Command;
+
+    // 对 linux 或 wsl 来说，读取 /etc/machine-id 即可获取当前操作系统的
+    // 唯一标识，而且某些环境没有预装`dmidecode`命令
+    if let Ok(identifier) = std::fs::read_to_string("/etc/machine-id") {
+        let identifier = identifier.trim();
+        if !identifier.is_empty() {
+            return Some(identifier.to_string());
+        }
+    }
+
    let output = match Command::new("dmidecode")
        .arg("-s")
        .arg("system-uuid")
@@ -63,7 +73,7 @@ pub fn get_unique_identifier() -> Option<String> {
    };

    let result = String::from_utf8_lossy(&output.stdout);
-    let identifier = result.trim().to_string();
+    let identifier = result.trim();
    if identifier.is_empty() {
        None
    } else {
@@ -1,21 +1,21 @@
 [package]
 name = "vnt-cli"
-version = "1.2.9"
+version = "1.2.10"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-vnt = { path = "../vnt", package = "vnt",default-features = false }
+vnt = { path = "../vnt", package = "vnt", default-features = false }
 common = { path = "../common" }
 getopts = "0.2.21"
 console = "0.15.2"
 os_info = "3.7.0"
 serde = "1.0"
-#serde_json = "1.0.94"
 serde_yaml = "0.9.32"
 log = "0.4.17"
-log4rs = "1.2.0"
+log4rs = { version = "1.2.0", optional = true }
+anyhow = "1.0.82"
 [dependencies.uuid]
 version = "1.4.1"
 features = [
@@ -29,16 +29,23 @@ sudo = "0.6.0"
 winapi = { version = "0.3.9", features = ["handleapi", "processthreadsapi", "winnt", "securitybaseapi", "impl-default"] }

 [features]
-default = ["server_encrypt","aes_gcm","aes_cbc","aes_ecb","sm4_cbc","ip_proxy"]
+default = ["server_encrypt", "aes_gcm", "aes_cbc", "aes_ecb", "sm4_cbc", "ip_proxy", "port_mapping", "log", "command", "file_config", "lz4"]
 openssl = ["vnt/openssl"]
 openssl-vendored = ["vnt/openssl-vendored"]
 ring-cipher = ["vnt/ring-cipher"]
-aes_cbc=["vnt/aes_cbc"]
-aes_ecb=["vnt/aes_ecb"]
-sm4_cbc=["vnt/sm4_cbc"]
-aes_gcm=["vnt/aes_gcm"]
-server_encrypt=["vnt/server_encrypt"]
-ip_proxy=["vnt/ip_proxy"]
+aes_cbc = ["vnt/aes_cbc"]
+aes_ecb = ["vnt/aes_ecb"]
+sm4_cbc = ["vnt/sm4_cbc"]
+aes_gcm = ["vnt/aes_gcm"]
+server_encrypt = ["vnt/server_encrypt"]
+ip_proxy = ["vnt/ip_proxy"]
+port_mapping = ["vnt/port_mapping"]
+lz4 = ["vnt/lz4_compress"]
+zstd = ["vnt/zstd_compress"]
+log = ["log4rs"]
+command = []
+file_config = []
 [build-dependencies]
 embed-manifest = "1.4.0"
-rand = "0.9.0-alpha.0"
+rand = "0.8.5"
+chrono = "0.4.23"
@@ -10,11 +10,13 @@
 ### -c
 关闭控制台交互式命令，后台运行时可以加此参数
 ### -s `<server>`
-注册和中继服务器地址，注册和转发数据
+注册和中继服务器地址，注册和转发数据，以'TXT:'开头表示解析TXT记录，TXT记录内容必须是'host:port'形式的服务器地址
 ### -e `<stun-server>`
 使用stun服务探测客户端NAT类型，不同类型有不同的打洞策略
 ### -a
 加了此参数表示使用tap网卡，默认使用tun网卡，tun网卡效率更高
+
+注意：仅在windows上支持使用tap，用于兼容低版本windows系统（低版本windows不支持wintun）
 ### --nic `<tun0>`
 指定虚拟网卡名称，默认tun模式使用vnt-tun，tap模式使用vnt-tap
 ### -i `<in-ip>`、-o  `<out-ip>`
@@ -72,9 +74,9 @@

 注意：默认情况下服务端不会对中转的数据做校验，如果要对中转的数据做校验，则需要客户端、服务端都开启此参数
 ### --punch `<punch>`
-取值ipv4/ipv6，选择只使用ipv4打洞或者只使用ipv6打洞，默认两则都会使用
+取值ipv4/ipv6，选择只使用ipv4打洞或者只使用ipv6打洞，默认两者都会使用
 ### --ports `<port1,port2>`
-指定本地监听的端口组，多个端口使用逗号分隔，多个端口可以分摊流量，增加并发，tcp会监听端口组的第一个端口，用于tcp直连
+指定本地监听的端口组，多个端口使用逗号分隔，多个端口可以分摊流量，增加并发、减缓流量限制，tcp会监听端口组的第一个端口，用于tcp直连

 - 例1：‘--ports 12345,12346,12347’ 表示udp监听12345、12346、12347这三个端口，tcp监听12345端口
 - 例2：‘--ports 0,0’ 表示udp监听两个未使用的端口，tcp监听一个未使用的端口
@@ -85,12 +87,28 @@
 ### --no-proxy
 关闭内置的ip代理，内置的代理较为简单，而且一般来说直接使用网卡NAT转发性能会更高，
 有需要可以自行配置NAT转发，[可参考‘编译’小节中的NAT配置](https://github.com/lbl8603/vnt#%E7%BC%96%E8%AF%91)
+### --dns `<223.5.5.5>`
+设置域名解析服务器地址，可以设置多个。如果使用TXT记录的域名，则dns默认使用223.5.5.5和114.114.114.114，端口省略值为53
+
+当地址解析失败时，会依次尝试后面的dns，直到有A记录、AAAA记录(或TXT记录)的解析结果
+
+### --mapping `<udp:0.0.0.0:80->10.26.0.10:80>`
+端口映射,可以设置多个映射地址，例如 '--mapping udp:0.0.0.0:80->10.26.0.10:80 --mapping tcp:0.0.0.0:80->10.26.0.11:81'
+表示将本地udp 80端口的数据转发到10.26.0.10:80，将本地tcp 80端口的数据转发到10.26.0.11:81，转发的目的地址可以使用域名+端口
+
+### --compressor `<lz4>`
+启用压缩，默认仅支持lz4压缩，开启压缩后，如果数据包长度大于等于128，则会使用压缩，否则还是会按原数据发送
+
+也支持开启zstd压缩，但是需要自行编译，编译时加入参数--features zstd
+
+如果宽度速度比较慢，可以考虑使用高级别的压缩
+
 ### -f `<conf>`
 指定配置文件
 配置文件采用yaml格式，可参考：
 ```yaml
 # 全部参数
-tap: false #是否使用tap 
+tap: false #是否使用tap 仅在windows上支持使用tap
 token: xxx #组网token
 device_id: xxx #当前设备id
 name: windows 11 #当前设备名称
@@ -111,7 +129,7 @@ server_encrypt: true #服务端加密
 parallel: 1 #任务并行度
 cipher_model: aes_gcm #客户端加密算法
 finger: false #关闭数据指纹
-punch_model: ipv4 #打洞模式 
+punch_model: ipv4 #打洞模式，表示只使用ipv4地址打洞，默认会同时使用v6和v4
 ports: 
  - 0 #使用随机端口，tcp监听此端口
  - 0
@@ -121,6 +139,13 @@ first_latency: false #是否优先低延迟通道，默认为false，表示优
 device_name: vnt-tun #网卡名称
 packet_loss: 0 #指定丢包率 取值0~1之间的数 用于模拟弱网
 packet_delay: 0 #指定延迟 单位毫秒 用于模拟弱网
+dns:
+  - 223.5.5.5 # 首选dns
+  - 8.8.8.8 # 备选dns
+mapping:
+  - udp:0.0.0.0:80->10.26.0.10:80 # 映射udp数据
+  - tcp:0.0.0.0:80->10.26.0.10:81 # 映射tcp数据
+  - tcp:0.0.0.0:82->localhost:83 # 映射tcp数据
 ```

 或者需要哪个配置就加哪个，当然token是必须的
@@ -132,7 +157,9 @@ token: xxx #组网token
 - relay:仅中继模式，会禁止打洞/p2p直连，只使用服务器转发
 - p2p:仅直连模式，会禁止网络数据从服务器/客户端转发，只会使用服务器转发控制包
 ### --packet-loss `<0>`
-模拟丢包，取值0~1之间的小数，程序会按设定的概率主动丢包。在模拟弱网环境会有帮助。
+模拟丢包，取值0~1之间的小数，程序会按设定的概率主动丢包。在模拟弱网环境时会有帮助。
+### --packet-delay `<0>`
+模拟延迟,整数,单位毫秒(ms),程序会按设定的值延迟发包,可用于模拟弱网

 ### --list
 在后台运行时,查看其他设备列表
@@ -3,11 +3,10 @@ use std::fs::File;
 use std::io::Write;

 fn main() {
-    // 生成随机序列号
+    let now_time = chrono::Local::now();
    let serial_number = format!(
-        "{}-{}-{}",
-        rand::thread_rng().gen_range(100..1000),
-        rand::thread_rng().gen_range(100..1000),
+        "{}-{}",
+        &now_time.format("%y%m%d%H%M").to_string(),
        rand::thread_rng().gen_range(100..1000)
    );
    let generated_code = format!(r#"pub const SERIAL_NUMBER: &str = "{}";"#, serial_number);
@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use std::net::{Ipv4Addr, SocketAddr};
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Info {
    pub name: String,
@@ -13,6 +14,9 @@ pub struct Info {
    pub ipv6_addr: String,
    pub up: u64,
    pub down: u64,
+    pub port_mapping_list: Vec<(bool, SocketAddr, String)>,
+    pub in_ips: Vec<(u32, u32, Ipv4Addr)>,
+    pub out_ips: Vec<(u32, u32)>,
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -36,5 +40,7 @@ pub struct DeviceItem {
    pub rt: String,
    pub status: String,
    pub client_secret: bool,
+    pub client_secret_hash: Vec<u8>,
    pub current_client_secret: bool,
+    pub current_client_secret_hash: Vec<u8>,
 }
@@ -85,6 +85,7 @@ pub fn command_list(vnt: &Vnt) -> Vec<DeviceItem> {
    let device_list = vnt.device_list();
    let mut list = Vec::new();
    let current_client_secret = vnt.client_encrypt();
+    let client_encrypt_hash = vnt.client_encrypt_hash().unwrap_or(&[]);
    for peer in device_list {
        let name = peer.name;
        let virtual_ip = peer.virtual_ip.to_string();
@@ -153,7 +154,9 @@ pub fn command_list(vnt: &Vnt) -> Vec<DeviceItem> {
            rt,
            status,
            client_secret,
+            client_secret_hash: peer.client_secret_hash,
            current_client_secret,
+            current_client_secret_hash: client_encrypt_hash.to_vec(),
        };
        list.push(item);
    }
@@ -182,6 +185,12 @@ pub fn command_info(vnt: &Vnt) -> Info {
        .unwrap_or("None".to_string());
    let up = vnt.up_stream();
    let down = vnt.down_stream();
+    #[cfg(feature = "port_mapping")]
+    let port_mapping_list = vnt.config().port_mapping_list.clone();
+    #[cfg(not(feature = "port_mapping"))]
+    let port_mapping_list = vec![];
+    let in_ips = vnt.config().in_ips.clone();
+    let out_ips = vnt.config().out_ips.clone();
    Info {
        name,
        virtual_ip,
@@ -195,5 +204,8 @@ pub fn command_info(vnt: &Vnt) -> Info {
        ipv6_addr,
        up,
        down,
+        port_mapping_list,
+        in_ips,
+        out_ips,
    }
 }
@@ -0,0 +1,181 @@
+use anyhow::anyhow;
+use std::net::Ipv4Addr;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+use crate::config::get_device_id;
+use vnt::channel::punch::PunchModel;
+use vnt::channel::UseChannelType;
+use vnt::cipher::CipherModel;
+use vnt::compression::Compressor;
+use vnt::core::Config;
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(default)]
+pub struct FileConfig {
+    #[cfg(target_os = "windows")]
+    pub tap: bool,
+    pub token: String,
+    pub device_id: String,
+    pub name: String,
+    pub server_address: String,
+    pub stun_server: Vec<String>,
+    pub dns: Vec<String>,
+    pub in_ips: Vec<String>,
+    pub out_ips: Vec<String>,
+    pub password: Option<String>,
+    pub mtu: Option<u32>,
+    pub tcp: bool,
+    pub ip: Option<String>,
+    pub use_channel: String,
+    #[cfg(feature = "ip_proxy")]
+    pub no_proxy: bool,
+    pub server_encrypt: bool,
+    pub parallel: usize,
+    pub cipher_model: Option<String>,
+    pub finger: bool,
+    pub punch_model: String,
+    pub ports: Option<Vec<u16>>,
+    pub cmd: bool,
+    pub first_latency: bool,
+    pub device_name: Option<String>,
+    pub packet_loss: Option<f64>,
+    pub packet_delay: u32,
+    #[cfg(feature = "port_mapping")]
+    pub mapping: Vec<String>,
+    pub compressor: Option<String>,
+}
+
+impl Default for FileConfig {
+    fn default() -> Self {
+        Self {
+            #[cfg(target_os = "windows")]
+            tap: false,
+            token: "".to_string(),
+            device_id: get_device_id(),
+            name: os_info::get().to_string(),
+            server_address: "nat1.wherewego.top:29872".to_string(),
+            stun_server: vec![
+                "stun1.l.google.com:19302".to_string(),
+                "stun2.l.google.com:19302".to_string(),
+                "stun.miwifi.com:3478".to_string(),
+            ],
+            dns: vec![],
+            in_ips: vec![],
+            out_ips: vec![],
+            password: None,
+            mtu: None,
+            tcp: false,
+            ip: None,
+            use_channel: "all".to_string(),
+            #[cfg(feature = "ip_proxy")]
+            no_proxy: false,
+            server_encrypt: false,
+            parallel: 1,
+            cipher_model: None,
+            finger: false,
+            punch_model: "all".to_string(),
+            ports: None,
+            cmd: false,
+            first_latency: false,
+            device_name: None,
+            packet_loss: None,
+            packet_delay: 0,
+            #[cfg(feature = "port_mapping")]
+            mapping: vec![],
+            compressor: None,
+        }
+    }
+}
+
+pub fn read_config(file_path: &str) -> anyhow::Result<(Config, bool)> {
+    let conf = std::fs::read_to_string(file_path)?;
+    let file_conf = match serde_yaml::from_str::<FileConfig>(&conf) {
+        Ok(val) => val,
+        Err(e) => {
+            log::error!("{:?}", e);
+            return Err(anyhow!("{}", e));
+        }
+    };
+    if file_conf.token.is_empty() {
+        return Err(anyhow!("token is_empty"));
+    }
+
+    let in_ips = match common::args_parse::ips_parse(&file_conf.in_ips) {
+        Ok(in_ips) => in_ips,
+        Err(e) => {
+            return Err(anyhow!("in_ips {:?} error:{}", &file_conf.in_ips, e));
+        }
+    };
+    let out_ips = match common::args_parse::out_ips_parse(&file_conf.out_ips) {
+        Ok(out_ips) => out_ips,
+        Err(e) => {
+            return Err(anyhow!("out_ips {:?} error:{}", &file_conf.out_ips, e));
+        }
+    };
+    let virtual_ip = match file_conf.ip.clone().map(|v| Ipv4Addr::from_str(&v)) {
+        None => None,
+        Some(r) => Some(r.map_err(|e| anyhow!("ip {:?} error:{}", &file_conf.ip, e))?),
+    };
+    let cipher_model = {
+        #[cfg(not(any(feature = "aes_gcm", feature = "server_encrypt")))]
+        if file_conf.password.is_some() && file_conf.cipher_model.is_none() {
+            Err(anyhow!("cipher_model undefined"))?
+        }
+        #[cfg(not(any(
+            feature = "aes_gcm",
+            feature = "server_encrypt",
+            feature = "aes_cbc",
+            feature = "aes_ecb",
+            feature = "sm4_cbc"
+        )))]
+        {
+            CipherModel::None
+        }
+        #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
+        CipherModel::AesGcm
+    };
+
+    let punch_model = PunchModel::from_str(&file_conf.punch_model).map_err(|e| anyhow!("{}", e))?;
+    let use_channel_type =
+        UseChannelType::from_str(&file_conf.use_channel).map_err(|e| anyhow!("{}", e))?;
+    let compressor = if let Some(compressor) = file_conf.compressor.as_ref() {
+        Compressor::from_str(compressor).map_err(|e| anyhow!("{}", e))?
+    } else {
+        Compressor::None
+    };
+    let config = Config::new(
+        #[cfg(target_os = "windows")]
+        file_conf.tap,
+        file_conf.token,
+        file_conf.device_id,
+        file_conf.name,
+        file_conf.server_address,
+        file_conf.dns,
+        file_conf.stun_server,
+        in_ips,
+        out_ips,
+        file_conf.password,
+        file_conf.mtu,
+        file_conf.tcp,
+        virtual_ip,
+        #[cfg(feature = "ip_proxy")]
+        file_conf.no_proxy,
+        file_conf.server_encrypt,
+        file_conf.parallel,
+        cipher_model,
+        file_conf.finger,
+        punch_model,
+        file_conf.ports,
+        file_conf.first_latency,
+        file_conf.device_name,
+        use_channel_type,
+        file_conf.packet_loss,
+        file_conf.packet_delay,
+        #[cfg(feature = "port_mapping")]
+        file_conf.mapping,
+        compressor,
+    )?;
+    Ok((config, file_conf.cmd))
+}
@@ -1,180 +1,12 @@
-use std::io;
-use std::net::{Ipv4Addr, ToSocketAddrs};
-use std::str::FromStr;
+#[cfg(feature = "file_config")]
+mod file_config;

-use serde::{Deserialize, Serialize};
+#[cfg(feature = "file_config")]
+pub use file_config::read_config;

-use vnt::channel::punch::PunchModel;
-use vnt::channel::UseChannelType;
-use vnt::cipher::CipherModel;
-use vnt::core::Config;
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(default)]
-pub struct FileConfig {
-    #[cfg(any(target_os = "windows", target_os = "linux"))]
-    pub tap: bool,
-    pub token: String,
-    pub device_id: String,
-    pub name: String,
-    pub server_address: String,
-    pub stun_server: Vec<String>,
-    pub in_ips: Vec<String>,
-    pub out_ips: Vec<String>,
-    pub password: Option<String>,
-    pub mtu: Option<u32>,
-    pub tcp: bool,
-    pub ip: Option<String>,
-    pub use_channel: String,
-    #[cfg(feature = "ip_proxy")]
-    pub no_proxy: bool,
-    pub server_encrypt: bool,
-    pub parallel: usize,
-    pub cipher_model: String,
-    pub finger: bool,
-    pub punch_model: String,
-    pub ports: Option<Vec<u16>>,
-    pub cmd: bool,
-    pub first_latency: bool,
-    pub device_name: Option<String>,
-    pub packet_loss: Option<f64>,
-    pub packet_delay: u32,
-}
-
-impl Default for FileConfig {
-    fn default() -> Self {
-        Self {
-            #[cfg(any(target_os = "windows", target_os = "linux"))]
-            tap: false,
-            token: "".to_string(),
-            device_id: get_device_id(),
-            name: os_info::get().to_string(),
-            server_address: "nat1.wherewego.top:29872".to_string(),
-            stun_server: vec![
-                "stun1.l.google.com:19302".to_string(),
-                "stun2.l.google.com:19302".to_string(),
-                "stun.qq.com:3478".to_string(),
-            ],
-            in_ips: vec![],
-            out_ips: vec![],
-            password: None,
-            mtu: None,
-            tcp: false,
-            ip: None,
-            use_channel: "all".to_string(),
-            #[cfg(feature = "ip_proxy")]
-            no_proxy: false,
-            server_encrypt: false,
-            parallel: 1,
-            cipher_model: "aes_gcm".to_string(),
-            finger: false,
-            punch_model: "all".to_string(),
-            ports: None,
-            cmd: false,
-            first_latency: false,
-            device_name: None,
-            packet_loss: None,
-            packet_delay: 0,
-        }
-    }
-}
-
-pub fn read_config(file_path: &str) -> io::Result<(Config, bool)> {
-    let conf = std::fs::read_to_string(file_path)?;
-    let file_conf = match serde_yaml::from_str::<FileConfig>(&conf) {
-        Ok(val) => val,
-        Err(e) => {
-            log::error!("{:?}", e);
-            return Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)));
-        }
-    };
-    if file_conf.token.is_empty() {
-        return Err(io::Error::new(io::ErrorKind::Other, "token is_empty"));
-    }
-    let server_address = match file_conf.server_address.to_socket_addrs() {
-        Ok(mut addr) => {
-            if let Some(addr) = addr.next() {
-                addr
-            } else {
-                return Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("server_address {:?} error", &file_conf.server_address),
-                ));
-            }
-        }
-        Err(e) => {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("server_address {:?} error:{}", &file_conf.server_address, e),
-            ));
-        }
-    };
-    let in_ips = match common::args_parse::ips_parse(&file_conf.in_ips) {
-        Ok(in_ips) => in_ips,
-        Err(e) => {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("in_ips {:?} error:{}", &file_conf.in_ips, e),
-            ));
-        }
-    };
-    let out_ips = match common::args_parse::out_ips_parse(&file_conf.out_ips) {
-        Ok(out_ips) => out_ips,
-        Err(e) => {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("out_ips {:?} error:{}", &file_conf.out_ips, e),
-            ));
-        }
-    };
-    let virtual_ip = match file_conf.ip.clone().map(|v| Ipv4Addr::from_str(&v)) {
-        None => None,
-        Some(r) => Some(r.map_err(|e| {
-            io::Error::new(
-                io::ErrorKind::Other,
-                format!("ip {:?} error:{}", &file_conf.ip, e),
-            )
-        })?),
-    };
-
-    let cipher_model = CipherModel::from_str(&file_conf.cipher_model)
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-
-    let punch_model = PunchModel::from_str(&file_conf.punch_model)
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-    let use_channel_type = UseChannelType::from_str(&file_conf.use_channel)
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-    let config = Config::new(
-        #[cfg(any(target_os = "windows", target_os = "linux"))]
-        file_conf.tap,
-        file_conf.token,
-        file_conf.device_id,
-        file_conf.name,
-        server_address,
-        file_conf.server_address,
-        file_conf.stun_server,
-        in_ips,
-        out_ips,
-        file_conf.password,
-        file_conf.mtu,
-        file_conf.tcp,
-        virtual_ip,
-        #[cfg(feature = "ip_proxy")]
-        file_conf.no_proxy,
-        file_conf.server_encrypt,
-        file_conf.parallel,
-        cipher_model,
-        file_conf.finger,
-        punch_model,
-        file_conf.ports,
-        file_conf.first_latency,
-        file_conf.device_name,
-        use_channel_type,
-        file_conf.packet_loss,
-        file_conf.packet_delay,
-    )
-    .unwrap();
-    Ok((config, file_conf.cmd))
+#[cfg(not(feature = "file_config"))]
+pub fn read_config(_file_path: &str) -> anyhow::Result<(vnt::core::Config, bool)> {
+    unimplemented!()
 }

 pub fn get_device_id() -> String {
@@ -1,4 +1,5 @@
 use console::{style, Style};
+use std::net::Ipv4Addr;

 use crate::command::entity::{DeviceItem, Info, RouteItem};

@@ -9,10 +10,15 @@ pub fn console_info(status: Info) {
    println!("Virtual ip: {}", style(status.virtual_ip).green());
    println!("Virtual gateway: {}", style(status.virtual_gateway).green());
    println!("Virtual netmask: {}", style(status.virtual_netmask).green());
-    println!(
-        "Connection status: {}",
-        style(status.connect_status).green()
-    );
+    if status.connect_status.eq_ignore_ascii_case("Connected") {
+        println!(
+            "Connection status: {}",
+            style(status.connect_status).green()
+        );
+    } else {
+        println!("Connection status: {}", style(status.connect_status).red());
+    }
+
    println!("NAT type: {}", style(status.nat_type).green());
    println!("Relay server: {}", style(status.relay_server).green());
    println!("Public ips: {}", style(status.public_ips).green());
@@ -20,7 +26,40 @@ pub fn console_info(status: Info) {
    println!("IPv6: {}", style(status.ipv6_addr).green());
    println!("Up: {}", style(convert(status.up)).green());
    println!("Down: {}", style(convert(status.down)).green());
+
+    if !status.port_mapping_list.is_empty() {
+        println!("------------------------------------------");
+        println!("Port mapping {}", status.port_mapping_list.len());
+        for (is_tcp, addr, dest) in status.port_mapping_list {
+            if is_tcp {
+                println!("  TCP: {} -> {}", addr, dest)
+            } else {
+                println!("  UDP: {} -> {}", addr, dest)
+            }
+        }
+    }
+    if !status.in_ips.is_empty() || !status.out_ips.is_empty() {
+        println!("------------------------------------------");
+    }
+    if !status.in_ips.is_empty() {
+        println!("IP forwarding {}", status.in_ips.len());
+        for (dest, mask, ip) in status.in_ips {
+            println!(
+                "  -- {} --> {}/{}",
+                ip,
+                Ipv4Addr::from(dest),
+                mask.count_ones()
+            )
+        }
+    }
+    if !status.out_ips.is_empty() {
+        println!("Allows network {}", status.out_ips.len());
+        for (dest, mask) in status.out_ips {
+            println!("  {}/{}", Ipv4Addr::from(dest), mask.count_ones())
+        }
+    }
 }
+
 fn convert(num: u64) -> String {
    let gigabytes = num / (1024 * 1024 * 1024);
    let remaining_bytes = num % (1024 * 1024 * 1024);
@@ -90,13 +129,17 @@ pub fn console_device_list(mut list: Vec<DeviceItem>) {
    ]);
    for item in list {
        if &item.status == "Online" {
-            if item.client_secret != item.current_client_secret {
+            if item.client_secret != item.current_client_secret
+                || (!item.current_client_secret_hash.is_empty()
+                    && !item.client_secret_hash.is_empty()
+                    && item.current_client_secret_hash != item.client_secret_hash)
+            {
                //加密状态不一致，无法通信的
                out_list.push(vec![
                    (item.name, Style::new().red()),
                    (item.virtual_ip, Style::new().red()),
                    (item.status, Style::new().red()),
-                    ("".to_string(), Style::new().red()),
+                    ("Mismatch".to_string(), Style::new().red()),
                    ("".to_string(), Style::new().red()),
                ]);
            } else {
@@ -1,7 +1,8 @@
-use std::net::{Ipv4Addr, ToSocketAddrs};
+use anyhow::anyhow;
+use std::io;
+use std::net::Ipv4Addr;
 use std::path::PathBuf;
 use std::str::FromStr;
-use std::{io, thread};

 use console::style;
 use getopts::Options;
@@ -10,10 +11,13 @@ use common::args_parse::{ips_parse, out_ips_parse};
 use vnt::channel::punch::PunchModel;
 use vnt::channel::UseChannelType;
 use vnt::cipher::CipherModel;
+use vnt::compression::Compressor;
 use vnt::core::{Config, Vnt};

+#[cfg(feature = "command")]
 mod command;
 mod config;
+#[cfg(feature = "command")]
 mod console_out;
 mod generated_serial_number;
 mod root_check;
@@ -41,6 +45,7 @@ pub fn app_home() -> io::Result<PathBuf> {
 }

 fn main() {
+    #[cfg(feature = "log")]
    let _ = log4rs::init_file("log4rs.yaml", Default::default());
    let args: Vec<String> = std::env::args().collect();
    let program = args[0].clone();
@@ -72,7 +77,10 @@ fn main() {
    opts.optopt("", "use-channel", "使用通道 relay/p2p", "<use-channel>");
    opts.optopt("", "packet-loss", "丢包率", "<packet-loss>");
    opts.optopt("", "packet-delay", "延迟", "<packet-delay>");
+    opts.optmulti("", "dns", "dns", "<dns>");
+    opts.optmulti("", "mapping", "mapping", "<mapping>");
    opts.optopt("f", "", "配置文件", "<conf>");
+    opts.optopt("", "compressor", "压缩算法", "<lz4>");
    //"后台运行时,查看其他设备列表"
    opts.optflag("", "list", "后台运行时,查看其他设备列表");
    opts.optflag("", "all", "后台运行时,查看其他设备完整信息");
@@ -98,6 +106,7 @@ fn main() {
        sudo::escalate_if_needed().unwrap();
        return;
    }
+    #[cfg(feature = "command")]
    if matches.opt_present("list") {
        command::command(command::CommandEnum::List);
        return;
@@ -129,7 +138,7 @@ fn main() {
            println!("parameter -k not found .");
            return;
        }
-        #[cfg(any(target_os = "windows", target_os = "linux"))]
+        #[cfg(target_os = "windows")]
        let tap = matches.opt_present("a");
        let device_name = matches.opt_str("nic");
        let token: String = matches.opt_get("k").unwrap().unwrap();
@@ -150,27 +159,14 @@ fn main() {
        let server_address_str = matches
            .opt_get_default("s", "nat1.wherewego.top:29872".to_string())
            .unwrap();
-        let server_address = match server_address_str.to_socket_addrs() {
-            Ok(mut addr) => {
-                if let Some(addr) = addr.next() {
-                    addr
-                } else {
-                    println!("parameter '-s {}' error .", server_address_str);
-                    return;
-                }
-            }
-            Err(e) => {
-                println!("parameter '-s {}' error {}.", server_address_str, e);
-                return;
-            }
-        };
+
        let mut stun_server = matches.opt_strs("e");
        if stun_server.is_empty() {
            stun_server.push("stun1.l.google.com:19302".to_string());
            stun_server.push("stun2.l.google.com:19302".to_string());
-            stun_server.push("stun.qq.com:3478".to_string());
+            stun_server.push("stun.miwifi.com:3478".to_string());
        }
-
+        let dns = matches.opt_strs("dns");
        let in_ip = matches.opt_strs("i");
        let in_ip = match ips_parse(&in_ip) {
            Ok(in_ip) => in_ip,
@@ -299,14 +295,23 @@ fn main() {
            .opt_get::<u32>("packet-delay")
            .expect("--packet-delay")
            .unwrap_or(0);
+        #[cfg(feature = "port_mapping")]
+        let port_mapping_list = matches.opt_strs("mapping");
+        let compressor = if let Some(compressor) = matches.opt_str("compressor").as_ref() {
+            Compressor::from_str(compressor)
+                .map_err(|e| anyhow!("{}", e))
+                .unwrap()
+        } else {
+            Compressor::None
+        };
        let config = match Config::new(
-            #[cfg(any(target_os = "windows", target_os = "linux"))]
+            #[cfg(target_os = "windows")]
            tap,
            token,
            device_id,
            name,
-            server_address,
            server_address_str,
+            dns,
            stun_server,
            in_ip,
            out_ip,
@@ -327,10 +332,13 @@ fn main() {
            use_channel_type,
            packet_loss,
            packet_delay,
+            #[cfg(feature = "port_mapping")]
+            port_mapping_list,
+            compressor,
        ) {
            Ok(config) => config,
            Err(e) => {
-                println!("config error: {}", e);
+                println!("config.toml error: {}", e);
                return;
            }
        };
@@ -338,44 +346,61 @@ fn main() {
    };
    println!("version {}", vnt::VNT_VERSION);
    println!("Serial:{}", generated_serial_number::SERIAL_NUMBER);
+    log::info!(
+        "version:{},Serial:{}",
+        vnt::VNT_VERSION,
+        generated_serial_number::SERIAL_NUMBER
+    );
    main0(config, cmd);
    std::process::exit(0);
 }

 mod callback;

-fn main0(config: Config, show_cmd: bool) {
+fn main0(config: Config, _show_cmd: bool) {
+    #[cfg(feature = "port_mapping")]
+    for (is_tcp, addr, dest) in config.port_mapping_list.iter() {
+        if *is_tcp {
+            println!("TCP port mapping {}->{}", addr, dest)
+        } else {
+            println!("UDP port mapping {}->{}", addr, dest)
+        }
+    }
    let vnt_util = Vnt::new(config, callback::VntHandler {}).unwrap();
-    let vnt_c = vnt_util.clone();
-    thread::Builder::new()
-        .name("CommandServer".into())
-        .spawn(move || {
-            if let Err(e) = command::server::CommandServer::new().start(vnt_c) {
-                log::warn!("cmd:{:?}", e);
-            }
-        })
-        .expect("CommandServer");
-    if show_cmd {
-        let mut cmd = String::new();
-        loop {
-            cmd.clear();
-            println!("======== input:list,info,route,all,stop ========");
-            match io::stdin().read_line(&mut cmd) {
-                Ok(len) => {
-                    if !command(&cmd[..len], &vnt_util) {
+    #[cfg(feature = "command")]
+    {
+        let vnt_c = vnt_util.clone();
+        std::thread::Builder::new()
+            .name("CommandServer".into())
+            .spawn(move || {
+                if let Err(e) = command::server::CommandServer::new().start(vnt_c) {
+                    log::warn!("cmd:{:?}", e);
+                }
+            })
+            .expect("CommandServer");
+        if _show_cmd {
+            let mut cmd = String::new();
+            loop {
+                cmd.clear();
+                println!("======== input:list,info,route,all,stop ========");
+                match io::stdin().read_line(&mut cmd) {
+                    Ok(len) => {
+                        if !command(&cmd[..len], &vnt_util) {
+                            break;
+                        }
+                    }
+                    Err(e) => {
+                        println!("input err:{}", e);
                        break;
                    }
                }
-                Err(e) => {
-                    println!("input err:{}", e);
-                    break;
-                }
            }
        }
    }
+
    vnt_util.wait()
 }
-
+#[cfg(feature = "command")]
 fn command(cmd: &str, vnt: &Vnt) -> bool {
    if cmd.is_empty() {
        return false;
@@ -418,12 +443,14 @@ fn print_usage(program: &str, _opts: Options) {
    );
    println!("  -n <name>           给设备一个名字,便于区分不同设备,默认使用系统版本");
    println!("  -d <id>             设备唯一标识符,不使用--ip参数时,服务端凭此参数分配虚拟ip,注意不能重复");
-    println!("  -s <server>         注册和中继服务器地址");
-    println!("  -e <stun-server>    stun服务器,用于探测NAT类型,可多次指定,如-e addr1 -e addr2");
-    println!("  -a                  使用tap模式,默认使用tun模式");
+    println!("  -s <server>         注册和中继服务器地址,以'TXT:'开头表示解析TXT记录");
+    println!("  -e <stun-server>    stun服务器,用于探测NAT类型,可使用多个地址,如-e stun1.l.google.com -e stun2.l.google.com");
+    #[cfg(target_os = "windows")]
+    println!(
+        "  -a                  使用tap模式,默认使用tun模式,使用tap时需要配合'--nic'参数指定tap网卡"
+    );
    println!("  -i <in-ip>          配置点对网(IP代理)时使用,-i 192.168.0.0/24,10.26.0.3表示允许接收网段192.168.0.0/24的数据");
    println!("                      并转发到10.26.0.3,可指定多个网段");
-    #[cfg(feature = "ip_proxy")]
    println!("  -o <out-ip>         配置点对网时使用,-o 192.168.0.0/24表示允许将数据转发到192.168.0.0/24,可指定多个网段");
    #[cfg(not(any(
        feature = "aes_gcm",
@@ -455,6 +482,7 @@ fn print_usage(program: &str, _opts: Options) {
    #[cfg(feature = "server_encrypt")]
    println!("  -W                  加密当前客户端和服务端通信的数据,请留意服务端指纹是否正确");
    println!("  -u <mtu>            自定义mtu(不加密默认为1450，加密默认为1410)");
+    #[cfg(feature = "file_config")]
    println!("  -f <conf_file>      读取配置文件中的配置");

    println!("  --tcp               和服务端使用tcp通信,默认使用udp,遇到udp qos时可指定使用tcp");
@@ -471,6 +499,7 @@ fn print_usage(program: &str, _opts: Options) {
    }
    println!("  --punch <punch>     取值ipv4/ipv6/all,ipv4表示仅使用ipv4打洞");
    println!("  --ports <port,port> 取值0~65535,指定本地监听的一组端口,默认监听两个随机端口,使用过多端口会增加网络负担");
+    #[cfg(feature = "command")]
    println!("  --cmd               开启交互式命令,使用此参数开启控制台输入");
    #[cfg(feature = "ip_proxy")]
    println!("  --no-proxy          关闭内置代理,如需点对网则需要配置网卡NAT转发");
@@ -481,28 +510,41 @@ fn print_usage(program: &str, _opts: Options) {
    println!(
        "  --packet-delay <0>  模拟延迟,整数,单位毫秒(ms),程序会按设定的值延迟发包,可用于模拟弱网"
    );
-
+    println!("  --dns <host:port>   DNS服务器地址,可使用多个dns,不指定时使用系统解析");
+    #[cfg(feature = "port_mapping")]
+    println!("  --mapping <mapping> 端口映射,例如 --mapping udp:0.0.0.0:80->10.26.0.10:80 --mapping tcp:0.0.0.0:80->10.26.0.10:80");
+    #[cfg(all(feature = "lz4", feature = "zstd"))]
+    println!("  --compressor <lz4>  启用压缩,可选值lz4/zstd<,level>,level为压缩级别,例如 --compressor lz4 或--compressor zstd,10");
+    #[cfg(feature = "lz4")]
+    #[cfg(not(feature = "zstd"))]
+    println!("  --compressor <lz4>  启用压缩,可选值lz4,例如 --compressor lz4");
+    #[cfg(feature = "zstd")]
+    #[cfg(not(feature = "lz4"))]
+    println!("  --compressor <zstd>  启用压缩,可选值zstd<,level>,level为压缩级别,例如 --compressor zstd,10");
    println!();
-    println!(
-        "  --list              {}",
-        yellow("后台运行时,查看其他设备列表".to_string())
-    );
-    println!(
-        "  --all               {}",
-        yellow("后台运行时,查看其他设备完整信息".to_string())
-    );
-    println!(
-        "  --info              {}",
-        yellow("后台运行时,查看当前设备信息".to_string())
-    );
-    println!(
-        "  --route             {}",
-        yellow("后台运行时,查看数据转发路径".to_string())
-    );
-    println!(
-        "  --stop              {}",
-        yellow("停止后台运行".to_string())
-    );
+    #[cfg(feature = "command")]
+    {
+        println!(
+            "  --list              {}",
+            yellow("后台运行时,查看其他设备列表".to_string())
+        );
+        println!(
+            "  --all               {}",
+            yellow("后台运行时,查看其他设备完整信息".to_string())
+        );
+        println!(
+            "  --info              {}",
+            yellow("后台运行时,查看当前设备信息".to_string())
+        );
+        println!(
+            "  --route             {}",
+            yellow("后台运行时,查看数据转发路径".to_string())
+        );
+        println!(
+            "  --stop              {}",
+            yellow("停止后台运行".to_string())
+        );
+    }
    println!("  -h, --help          帮助");
 }

@@ -510,6 +552,7 @@ fn green(str: String) -> impl std::fmt::Display {
    style(str).green()
 }

+#[cfg(feature = "command")]
 fn yellow(str: String) -> impl std::fmt::Display {
    style(str).yellow()
 }
@@ -1,6 +1,6 @@
 [package]
 name = "vnt-jni"
-version = "1.2.9"
+version = "1.2.10"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -14,5 +14,8 @@ jni = { version = "0.21.1", default-features = false }
 log = "0.4.20"
 spki = { version = "0.7.2", features = ["fingerprint", "alloc","base64","pem"]}

+[target.'cfg(target_os = "android")'.dependencies]
+android_logger = "0.13"
+
 [lib]
 crate-type = ["staticlib", "cdylib"]
@@ -8,8 +8,14 @@ import top.wherewego.vnt.jni.param.*;
 * @author https://github.com/lbl8603/vnt
 */
 public interface CallBack {
+    /**
+     * 连接成功的回调
+     */
+    void success();
+
    /**
     * 创建虚拟网卡成功的回调方法
+     * 仅在 windows/linux/macos上使用
     *
     * @param info 网卡信息
     */
@@ -38,6 +44,24 @@ public interface CallBack {
     */
    boolean register(RegisterInfo info);

+    /**
+     * 创建网卡回调
+     * 仅在android上使用
+     *
+     * @param info 创建配置
+     * @return 网卡fd
+     */
+
+    int generateTun(DeviceConfig info);
+
+    /**
+     * 对端用户列表
+     *
+     * @param infoArray
+     */
+    void peerClientList(PeerClientInfo[] infoArray);
+
+
    /**
     * 异常回调
     *
@@ -1,13 +1,16 @@
 package top.wherewego.vnt.jni;

+import java.io.Serializable;
+import java.util.Arrays;
+
 /**
 * 启动配置
 *
 * @author https://github.com/lbl8603/vnt
 */
-public class Config {
+public class Config implements Serializable {
    /**
-     * 是否是tap模式，仅支持windows和linux
+     * 是否是tap模式，仅支持windows
     */
    private boolean tap;
    /**
@@ -38,10 +41,6 @@ public class Config {
     * 是否开启服务端加密
     */
    private boolean serverEncrypt;
-    /**
-     * 仅使用中继转发
-     */
-    private boolean relay;
    /**
     * 设备id，请使用唯一值
     */
@@ -50,6 +49,14 @@ public class Config {
     * 服务端地址
     */
    private String server;
+    /**
+     * dns地址
+     */
+    private String[] dns;
+    /**
+     * 端口映射
+     */
+    private String[] portMapping;
    /**
     * stun服务地址
     */
@@ -87,9 +94,17 @@ public class Config {
     */
    private String deviceName;
    /**
-     * 虚拟网卡fd 仅在android上支持
+     * enum: relay/p2p/all
     */
-    private int deviceFd;
+    private String useChannel;
+    /**
+     * 模拟丢包率，取0~1之间的数，为null表示不丢包，1表示全部丢包
+     */
+    private Double packetLossRate;
+    /**
+     * 模拟延迟 单位毫秒(ms)
+     */
+    private Integer packetDelay;

    public Config() {
    }
@@ -158,13 +173,6 @@ public class Config {
        this.serverEncrypt = serverEncrypt;
    }

-    public boolean isRelay() {
-        return relay;
-    }
-
-    public void setRelay(boolean relay) {
-        this.relay = relay;
-    }

    public String getDeviceId() {
        return deviceId;
@@ -182,6 +190,21 @@ public class Config {
        this.server = server;
    }

+    public String[] getDns() {
+        return dns;
+    }
+
+    public void setDns(String[] dns) {
+        this.dns = dns;
+    }
+    public String[] getPortMapping() {
+        return portMapping;
+    }
+
+    public void setPortMapping(String[] portMapping) {
+        this.portMapping = portMapping;
+    }
+
    public String[] getStunServer() {
        return stunServer;
    }
@@ -254,11 +277,57 @@ public class Config {
        this.deviceName = deviceName;
    }

-    public int getDeviceFd() {
-        return deviceFd;
+    public String getUseChannel() {
+        return useChannel;
    }

-    public void setDeviceFd(int deviceFd) {
-        this.deviceFd = deviceFd;
+    public void setUseChannel(String useChannel) {
+        this.useChannel = useChannel;
+    }
+
+    public Double getPacketLossRate() {
+        return packetLossRate;
+    }
+
+    public void setPacketLossRate(Double packetLossRate) {
+        this.packetLossRate = packetLossRate;
+    }
+
+    public Integer getPacketDelay() {
+        return packetDelay;
+    }
+
+    public void setPacketDelay(Integer packetDelay) {
+        this.packetDelay = packetDelay;
+    }
+
+    @Override
+    public String toString() {
+        return "Config{" +
+                "tap=" + tap +
+                ", token='" + token + '\'' +
+                ", name='" + name + '\'' +
+                ", password='" + password + '\'' +
+                ", cipherModel='" + cipherModel + '\'' +
+                ", punchModel='" + punchModel + '\'' +
+                ", mtu=" + mtu +
+                ", serverEncrypt=" + serverEncrypt +
+                ", deviceId='" + deviceId + '\'' +
+                ", server='" + server + '\'' +
+                ", dns=" + Arrays.toString(dns) +
+                ", portMapping=" + Arrays.toString(portMapping) +
+                ", stunServer=" + Arrays.toString(stunServer) +
+                ", tcp=" + tcp +
+                ", ip='" + ip + '\'' +
+                ", finger=" + finger +
+                ", firstLatency=" + firstLatency +
+                ", inIps=" + Arrays.toString(inIps) +
+                ", outIps=" + Arrays.toString(outIps) +
+                ", ports=" + Arrays.toString(ports) +
+                ", deviceName='" + deviceName + '\'' +
+                ", useChannel='" + useChannel + '\'' +
+                ", packetLossRate=" + packetLossRate +
+                ", packetDelay=" + packetDelay +
+                '}';
    }
 }
@@ -1,10 +1,17 @@
 package top.wherewego.vnt.jni;

 /**
- * @author lubeilin
- * @date: 2024/02/27 18:31
+ * ip转换
+ *
+ * @author https://github.com/lbl8603/vnt
 */
 public class IpUtils {
+    /**
+     * 将整数的ip地址转成字符串，例如 0 转成 "0.0.0.0"
+     *
+     * @param ipAddress
+     * @return
+     */
    public static String intToIpAddress(int ipAddress) {

        return ((ipAddress & 0xFF000000) >>> 24) + "." +
@@ -12,6 +19,13 @@ public class IpUtils {
                ((ipAddress & 0x0000FF00) >>> 8) + "." +
                (ipAddress & 0x000000FF);
    }
+
+    /**
+     * 返回掩码的长度
+     *
+     * @param subnetMask
+     * @return
+     */
    public static int subnetMaskToPrefixLength(int subnetMask) {
        int prefixLength = 0;
        int bit = 1 << 31;
@@ -5,13 +5,13 @@ package top.wherewego.vnt.jni;
 *
 * @author https://github.com/lbl8603/vnt
 */
-public class PeerDeviceInfo {
+public class PeerRouteInfo {
    private final int virtualIp;
    private final String name;
    private final String status;
    private final Route route;

-    public PeerDeviceInfo(int virtualIp, String name, String status, Route route) {
+    public PeerRouteInfo(int virtualIp, String name, String status, Route route) {
        this.virtualIp = virtualIp;
        this.name = name;
        this.status = status;
@@ -6,16 +6,26 @@ package top.wherewego.vnt.jni;
 * @author https://github.com/lbl8603/vnt
 */
 public class Route {
+    /**
+     * 是否使用tcp
+     */
+    private final boolean tcp;
    private final String address;
    private final byte metric;
    private final int rt;

-    public Route(String address, byte metric, int rt) {
+
+    public Route(boolean tcp, String address, byte metric, int rt) {
+        this.tcp = tcp;
        this.address = address;
        this.metric = metric;
        this.rt = rt;
    }

+    public boolean isTcp() {
+        return tcp;
+    }
+
    public String getAddress() {
        return address;
    }
@@ -31,7 +41,8 @@ public class Route {
    @Override
    public String toString() {
        return "Route{" +
-                "address='" + address + '\'' +
+                "tcp=" + tcp +
+                ", address='" + address + '\'' +
                ", metric=" + metric +
                ", rt=" + rt +
                '}';
@@ -11,9 +11,9 @@ import java.io.IOException;
 public class Vnt implements Closeable {
    private final long raw;

-    public Vnt(Config config, CallBack callBack) {
+    public Vnt(Config config, CallBack callBack) throws Exception {
        this.raw = new0(config, callBack);
-        if(this.raw == 0){
+        if (this.raw == 0) {
            throw new RuntimeException();
        }
    }
@@ -26,19 +26,25 @@ public class Vnt implements Closeable {
        wait0(raw);
    }

-    public PeerDeviceInfo[] list() {
+    public boolean awaitTimeout(long ms) {
+        return waitTimeout0(raw, ms);
+    }
+
+    public PeerRouteInfo[] list() {
        return list0(raw);
    }

-    private native long new0(Config config, CallBack callBack);
+    private native long new0(Config config, CallBack callBack) throws Exception;

    private native void stop0(long raw);

    private native void wait0(long raw);

+    private native boolean waitTimeout0(long raw, long ms);
+
    private native void drop0(long raw);

-    private native PeerDeviceInfo[] list0(long raw);
+    private native PeerRouteInfo[] list0(long raw);

    @Override
    public void close() throws IOException {
@@ -0,0 +1,72 @@
+package top.wherewego.vnt.jni.param;
+
+import top.wherewego.vnt.jni.IpUtils;
+
+import java.util.Arrays;
+
+/**
+ * 创建网卡所需信息，仅在android上使用
+ *
+ * @author https://github.com/lbl8603/vnt
+ */
+public class DeviceConfig {
+    /**
+     * 虚拟IP
+     */
+    public final int virtualIp;
+    /**
+     * 掩码
+     */
+    public final int virtualNetmask;
+    /**
+     * 网关
+     */
+    public final int virtualGateway;
+    /**
+     * 虚拟网段
+     */
+    public final int virtualNetwork;
+    /**
+     * 额外路由，来自点对网的路由配置
+     */
+    public final String[] externalRoute;
+
+    public DeviceConfig(int virtualIp, int virtualNetmask, int virtualGateway, int virtualNetwork, String[] externalRoute) {
+        this.virtualIp = virtualIp;
+        this.virtualNetmask = virtualNetmask;
+        this.virtualGateway = virtualGateway;
+        this.virtualNetwork = virtualNetwork;
+        this.externalRoute = externalRoute;
+    }
+
+    public int getVirtualIp() {
+        return virtualIp;
+    }
+
+    public int getVirtualNetmask() {
+        return virtualNetmask;
+    }
+
+    public int getVirtualGateway() {
+        return virtualGateway;
+    }
+
+    public int getVirtualNetwork() {
+        return virtualNetwork;
+    }
+
+    public String[] getExternalRoute() {
+        return externalRoute;
+    }
+
+    @Override
+    public String toString() {
+        return "DeviceConfig{" +
+                "virtualIp=" + IpUtils.intToIpAddress(virtualIp) +
+                ", virtualNetmask=" + IpUtils.intToIpAddress(virtualNetmask) +
+                ", virtualGateway=" + IpUtils.intToIpAddress(virtualGateway) +
+                ", virtualNetwork=" + IpUtils.intToIpAddress(virtualNetwork) +
+                ", externalRoute=" + Arrays.toString(externalRoute) +
+                '}';
+    }
+}
@@ -1,7 +1,7 @@
 package top.wherewego.vnt.jni.param;

 /**
- * 网卡信息
+ * 网卡信息 仅在 windows/linux/macos上使用
 *
 * @author https://github.com/lbl8603/vnt
 */
@@ -16,15 +16,25 @@ public class ErrorInfo {
    public final String msg;

    public ErrorInfo(int code, String msg) {
-        this.code = switch (code) {
-            case 1 -> ErrorCodeEnum.TokenError;
-            case 2 -> ErrorCodeEnum.Disconnect;
-            case 3 -> ErrorCodeEnum.AddressExhausted;
-            case 4 -> ErrorCodeEnum.IpAlreadyExists;
-            case 5 -> ErrorCodeEnum.InvalidIp;
-            case 6 -> ErrorCodeEnum.Unknown;
-            default -> null;
-        };
+        switch (code) {
+            case 1:
+                this.code = ErrorCodeEnum.TokenError;
+                break;
+            case 2:
+                this.code = ErrorCodeEnum.Disconnect;
+                break;
+            case 3:
+                this.code = ErrorCodeEnum.AddressExhausted;
+                break;
+            case 4:
+                this.code = ErrorCodeEnum.IpAlreadyExists;
+                break;
+            case 5:
+                this.code = ErrorCodeEnum.InvalidIp;
+                break;
+            default:
+                this.code = ErrorCodeEnum.Unknown;
+        }
        this.msg = msg;
    }

@@ -0,0 +1,60 @@
+package top.wherewego.vnt.jni.param;
+
+import top.wherewego.vnt.jni.IpUtils;
+
+/**
+ * 创建网卡所需信息，仅在android上使用
+ *
+ * @author https://github.com/lbl8603/vnt
+ */
+public class PeerClientInfo {
+    /**
+     * 虚拟IP
+     */
+    public final int virtualIp;
+    /**
+     * 名称
+     */
+    public final String name;
+    /**
+     * 是否在线
+     */
+    public final boolean online;
+    /**
+     * 是否开启客户端加密，不同加密状态的不能通信
+     */
+    public final boolean clientSecret;
+
+    public PeerClientInfo(int virtualIp, String name, boolean online, boolean clientSecret) {
+        this.virtualIp = virtualIp;
+        this.name = name;
+        this.online = online;
+        this.clientSecret = clientSecret;
+    }
+
+    public int getVirtualIp() {
+        return virtualIp;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean isOnline() {
+        return online;
+    }
+
+    public boolean isClientSecret() {
+        return clientSecret;
+    }
+
+    @Override
+    public String toString() {
+        return "PeerDeviceInfo{" +
+                "virtualIp=" + IpUtils.intToIpAddress(virtualIp) +
+                ", name='" + name + '\'' +
+                ", online=" + online +
+                ", clientSecret=" + clientSecret +
+                '}';
+    }
+}
@@ -1,5 +1,7 @@
 package top.wherewego.vnt.jni.param;

+import top.wherewego.vnt.jni.IpUtils;
+
 /**
 * 注册回调信息
 *
@@ -9,40 +11,40 @@ public class RegisterInfo {
    /**
     * 虚拟IP
     */
-    public final String virtualIp;
+    public final int virtualIp;
    /**
     * 掩码
     */
-    public final String virtualNetmask;
+    public final int virtualNetmask;
    /**
     * 网关
     */
-    public final String virtualGateway;
+    public final int virtualGateway;

-    public RegisterInfo(String virtualIp, String virtualNetmask, String virtualGateway) {
+    public RegisterInfo(int virtualIp, int virtualNetmask, int virtualGateway) {
        this.virtualIp = virtualIp;
        this.virtualNetmask = virtualNetmask;
        this.virtualGateway = virtualGateway;
    }

-    public String getVirtualIp() {
+    public int getVirtualIp() {
        return virtualIp;
    }

-    public String getVirtualNetmask() {
+    public int getVirtualNetmask() {
        return virtualNetmask;
    }

-    public String getVirtualGateway() {
+    public int getVirtualGateway() {
        return virtualGateway;
    }

    @Override
    public String toString() {
        return "RegisterInfo{" +
-                "virtualIp='" + virtualIp + '\'' +
-                ", virtualNetmask='" + virtualNetmask + '\'' +
-                ", virtualGateway='" + virtualGateway + '\'' +
+                "virtualIp='" + IpUtils.intToIpAddress(virtualIp) + '\'' +
+                ", virtualNetmask='" + IpUtils.intToIpAddress(virtualNetmask) + '\'' +
+                ", virtualGateway='" + IpUtils.intToIpAddress(virtualGateway) + '\'' +
                '}';
    }
 }
@@ -1,35 +1,87 @@
 use std::sync::Arc;

-use jni::objects::{GlobalRef, JString, JValue};
+use jni::objects::{GlobalRef, JClass, JObject, JString, JValue};
 use jni::{JNIEnv, JavaVM};
 use spki::der::pem::LineEnding;
 use spki::EncodePublicKey;

 use vnt::handle::callback::ConnectInfo;
-use vnt::{DeviceInfo, ErrorInfo, HandshakeInfo, RegisterInfo, VntCallback};
+#[cfg(target_os = "android")]
+use vnt::handle::callback::DeviceConfig;
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+use vnt::DeviceInfo;
+use vnt::{ErrorInfo, HandshakeInfo, PeerClientInfo, RegisterInfo, VntCallback};

 #[derive(Clone)]
 pub struct CallBack {
    jvm: Arc<JavaVM>,
    this: GlobalRef,
+    connect_info_class: GlobalRef,
+    handshake_info_class: GlobalRef,
+    error_info_class: GlobalRef,
+    register_info_class: GlobalRef,
+    #[cfg(target_os = "android")]
+    device_config_class: GlobalRef,
+    peer_client_info_class: GlobalRef,
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+    device_info_class: GlobalRef,
 }

 unsafe impl Send for CallBack {}

+fn find_class_global_ref(env: &mut JNIEnv, class: &str) -> jni::errors::Result<GlobalRef> {
+    let class = env.find_class(class)?;
+    env.new_global_ref(class)
+}
 impl CallBack {
-    pub fn new(jvm: JavaVM, this: GlobalRef) -> Self {
-        Self {
+    pub fn new(jvm: JavaVM, this: GlobalRef) -> jni::errors::Result<Self> {
+        let mut env = jvm.attach_current_thread_as_daemon()?;
+        let connect_info_class =
+            find_class_global_ref(&mut env, "top/wherewego/vnt/jni/param/ConnectInfo")?;
+        let handshake_info_class =
+            find_class_global_ref(&mut env, "top/wherewego/vnt/jni/param/HandshakeInfo")?;
+        let error_info_class =
+            find_class_global_ref(&mut env, "top/wherewego/vnt/jni/param/ErrorInfo")?;
+        let register_info_class =
+            find_class_global_ref(&mut env, "top/wherewego/vnt/jni/param/RegisterInfo")?;
+        #[cfg(target_os = "android")]
+        let device_config_class = crate::callback::find_class_global_ref(
+            &mut env,
+            "top/wherewego/vnt/jni/param/DeviceConfig",
+        )?;
+        let peer_client_info_class =
+            find_class_global_ref(&mut env, "top/wherewego/vnt/jni/param/PeerClientInfo")?;
+        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+        let device_info_class =
+            find_class_global_ref(&mut env, "top/wherewego/vnt/jni/param/DeviceInfo")?;
+        Ok(Self {
            jvm: Arc::new(jvm),
            this,
-        }
+            connect_info_class,
+            handshake_info_class,
+            error_info_class,
+            register_info_class,
+            #[cfg(target_os = "android")]
+            device_config_class,
+            peer_client_info_class,
+            #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+            device_info_class,
+        })
    }
 }

 impl CallBack {
+    fn success0(&self) -> jni::errors::Result<()> {
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        env.call_method(&self.this, "success", "()V", &[])?;
+        Ok(())
+    }
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
    fn create_tun0(&self, info: DeviceInfo) -> jni::errors::Result<()> {
-        let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        let class = unsafe { JClass::from_raw(self.device_info_class.as_raw()) };
        let param = env.new_object(
-            "top/wherewego/vnt/jni/param/DeviceInfo",
+            class,
            "(Ljava/lang/String;Ljava/lang/String;)V",
            &[
                JValue::Object(&env.new_string(info.name)?.into()),
@@ -45,9 +97,10 @@ impl CallBack {
        Ok(())
    }
    fn connect0(&self, info: ConnectInfo) -> jni::errors::Result<()> {
-        let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        let class = unsafe { JClass::from_raw(self.connect_info_class.as_raw()) };
        let param = env.new_object(
-            "top/wherewego/vnt/jni/param/ConnectInfo",
+            class,
            "(JLjava/lang/String;)V",
            &[
                JValue::Long(info.count as _),
@@ -63,7 +116,7 @@ impl CallBack {
        Ok(())
    }
    fn handshake0(&self, info: HandshakeInfo) -> jni::errors::Result<bool> {
-        let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
        let public_key = if let Some(public_key) = info.public_key {
            match public_key.to_public_key_pem(LineEnding::CRLF) {
                Ok(public_key) => env.new_string(public_key)?,
@@ -80,8 +133,10 @@ impl CallBack {
        } else {
            JString::default()
        };
+        let class = unsafe { JClass::from_raw(self.handshake_info_class.as_raw()) };
+
        let param = env.new_object(
-            "top/wherewego/vnt/jni/param/HandshakeInfo",
+            class,
            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
            &[
                JValue::Object(&public_key),
@@ -98,14 +153,15 @@ impl CallBack {
        rs.z()
    }
    fn register0(&self, info: RegisterInfo) -> jni::errors::Result<bool> {
-        let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        let class = unsafe { JClass::from_raw(self.register_info_class.as_raw()) };
        let param = env.new_object(
-            "top/wherewego/vnt/jni/param/RegisterInfo",
-            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            class,
+            "(III)V",
            &[
-                JValue::Object(&env.new_string(info.virtual_ip.to_string())?.into()),
-                JValue::Object(&env.new_string(info.virtual_netmask.to_string())?.into()),
-                JValue::Object(&env.new_string(info.virtual_gateway.to_string())?.into()),
+                JValue::Int(u32::from(info.virtual_ip) as _),
+                JValue::Int(u32::from(info.virtual_netmask) as _),
+                JValue::Int(u32::from(info.virtual_gateway) as _),
            ],
        )?;
        let rs = env.call_method(
@@ -116,16 +172,78 @@ impl CallBack {
        )?;
        rs.z()
    }
+    #[cfg(target_os = "android")]
+    fn generate_tun0(&self, info: DeviceConfig) -> jni::errors::Result<u32> {
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        let class = unsafe { JClass::from_raw(self.device_config_class.as_raw()) };
+
+        let object_array = env.new_object_array(
+            info.external_route.len() as _,
+            "java/lang/String",
+            JObject::null(),
+        )?;
+        for (index, (network, mask)) in info.external_route.into_iter().enumerate() {
+            let param =
+                env.new_string(format!("{}/{}", network, u32::from(mask).leading_ones()))?;
+            env.set_object_array_element(&object_array, index as _, &param)?;
+        }
+        let param = env.new_object(
+            class,
+            "(IIII[Ljava/lang/String;)V",
+            &[
+                JValue::Int(u32::from(info.virtual_ip) as _),
+                JValue::Int(u32::from(info.virtual_netmask) as _),
+                JValue::Int(u32::from(info.virtual_gateway) as _),
+                JValue::Int(u32::from(info.virtual_network) as _),
+                JValue::Object(&object_array),
+            ],
+        )?;
+        let rs = env.call_method(
+            &self.this,
+            "generateTun",
+            "(Ltop/wherewego/vnt/jni/param/DeviceConfig;)I",
+            &[JValue::Object(&param)],
+        )?;
+        rs.i().map(|v| v as _)
+    }
+    fn peer_client_list0(&self, info_vec: Vec<PeerClientInfo>) -> jni::errors::Result<()> {
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        let class = unsafe { JClass::from_raw(self.peer_client_info_class.as_raw()) };
+        let object_array = env.new_object_array(info_vec.len() as _, &class, JObject::null())?;
+        for (index, info) in info_vec.into_iter().enumerate() {
+            let param = env.new_object(
+                &class,
+                "(ILjava/lang/String;ZZ)V",
+                &[
+                    JValue::Int(u32::from(info.virtual_ip) as _),
+                    JValue::Object(&env.new_string(info.name)?.into()),
+                    JValue::Bool(info.status.is_online() as _),
+                    JValue::Bool(info.client_secret as _),
+                ],
+            )?;
+            env.set_object_array_element(&object_array, index as _, &param)?;
+        }
+
+        env.call_method(
+            &self.this,
+            "peerClientList",
+            "([Ltop/wherewego/vnt/jni/param/PeerClientInfo;)V",
+            &[JValue::Object(&object_array)],
+        )?;
+        Ok(())
+    }
+
    fn error0(&self, info: ErrorInfo) -> jni::errors::Result<()> {
        let code: u8 = info.code.into();
-        let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        let class = unsafe { JClass::from_raw(self.error_info_class.as_raw()) };
        let msg = if let Some(msg) = info.msg {
            env.new_string(msg)?
        } else {
            JString::default()
        };
        let param = env.new_object(
-            "top/wherewego/vnt/jni/param/ErrorInfo",
+            class,
            "(ILjava/lang/String;)V",
            &[JValue::Int(code as _), JValue::Object(&msg.into())],
        )?;
@@ -138,15 +256,19 @@ impl CallBack {
        Ok(())
    }
    fn stop0(&self) -> jni::errors::Result<()> {
-        let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
-        env.call_method(&self.this, "error", "()V", &[])?;
+        let mut env = self.jvm.attach_current_thread_as_daemon()?;
+        env.call_method(&self.this, "stop", "()V", &[])?;
        Ok(())
    }
 }

 impl VntCallback for CallBack {
    fn success(&self) {
+        if let Err(e) = self.success0() {
+            log::warn!("success {:?}", e);
+        }
    }
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
    fn create_tun(&self, info: DeviceInfo) {
        if let Err(e) = self.create_tun0(info) {
            log::warn!("create_tun {:?}", e);
@@ -172,6 +294,19 @@ impl VntCallback for CallBack {
            false
        })
    }
+    #[cfg(target_os = "android")]
+    fn generate_tun(&self, info: DeviceConfig) -> u32 {
+        self.generate_tun0(info).unwrap_or_else(|e| {
+            log::warn!("generate_tun {:?}", e);
+            0
+        })
+    }
+
+    fn peer_client_list(&self, info: Vec<PeerClientInfo>) {
+        if let Err(e) = self.peer_client_list0(info) {
+            log::warn!("peer_client_list {:?}", e);
+        }
+    }

    fn error(&self, info: ErrorInfo) {
        if let Err(e) = self.error0(info) {
@@ -1,4 +1,3 @@
-use std::net::ToSocketAddrs;
 use std::str::FromStr;

 use jni::errors::Error;
@@ -8,12 +7,13 @@ use jni::JNIEnv;
 use vnt::channel::punch::PunchModel;
 use vnt::channel::UseChannelType;
 use vnt::cipher::CipherModel;
+use vnt::compression::Compressor;
 use vnt::core::Config;

 use crate::utils::*;

 pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
-    #[cfg(any(target_os = "windows", target_os = "linux"))]
+    #[cfg(target_os = "windows")]
    let tap = env.get_field(&config, "tap", "Z")?.z()?;
    let token = to_string_not_null(env, &config, "token")?;
    let name = to_string_not_null(env, &config, "name")?;
@@ -21,6 +21,8 @@ pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
    let password = to_string(env, &config, "password")?;
    let server_address_str = to_string_not_null(env, &config, "server")?;
    let stun_server = to_string_array_not_null(env, &config, "stunServer")?;
+    let dns = to_string_array(env, &config, "dns")?.unwrap_or_else(|| vec![]);
+    let port_mapping = to_string_array(env, &config, "portMapping")?.unwrap_or_else(|| vec![]);
    let cipher_model = to_string_not_null(env, &config, "cipherModel")?;
    let punch_model = to_string(env, &config, "punchModel")?;
    let mtu = to_integer(env, &config, "mtu")?.map(|v| v as u32);
@@ -29,6 +31,11 @@ pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
    let use_channel = to_string(env, &config, "useChannel")?;
    let finger = env.get_field(&config, "finger", "Z")?.z()?;
    let first_latency = env.get_field(&config, "firstLatency", "Z")?.z()?;
+    let packet_delay = to_integer(env, &config, "packetDelay")?
+        .map(|v| v as u32)
+        .unwrap_or_default();
+    let packet_loss_rate = to_double(env, &config, "packetLossRate")?;
+
    let in_ips = to_string_array(env, &config, "inIps")?;
    let out_ips = to_string_array(env, &config, "outIps")?;
    let ports =
@@ -73,25 +80,6 @@ pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
        vec![]
    };

-    let server_address = match server_address_str.to_socket_addrs() {
-        Ok(mut rs) => {
-            if let Some(addr) = rs.next() {
-                addr
-            } else {
-                env.throw_new("java/lang/RuntimeException", "server address err")
-                    .expect("throw");
-                return Err(Error::JavaException);
-            }
-        }
-        Err(e) => {
-            env.throw_new(
-                "java/lang/RuntimeException",
-                format!("server address {}", e),
-            )
-            .expect("throw");
-            return Err(Error::JavaException);
-        }
-    };
    let cipher_model = match CipherModel::from_str(&cipher_model) {
        Ok(cipher_model) => cipher_model,
        Err(e) => {
@@ -102,16 +90,14 @@ pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
    };
    #[cfg(not(target_os = "android"))]
    let device_name = to_string(env, &config, "deviceName")?;
-    #[cfg(target_os = "android")]
-    let device_fd = env.get_field(&config, "deviceFd", "I")?.i()? as i32;
    let config = match Config::new(
-        #[cfg(any(target_os = "windows", target_os = "linux"))]
+        #[cfg(target_os = "windows")]
        tap,
        token,
        device_id,
        name,
-        server_address,
        server_address_str,
+        dns,
        stun_server,
        in_ips,
        out_ips,
@@ -129,17 +115,17 @@ pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
        first_latency,
        #[cfg(not(target_os = "android"))]
        device_name,
-        #[cfg(target_os = "android")]
-        device_fd,
        UseChannelType::from_str(&use_channel.unwrap_or_default()).unwrap_or_default(),
-        None,
-        0,
+        packet_loss_rate,
+        packet_delay,
+        port_mapping,
+        Compressor::None,
    ) {
        Ok(config) => config,
        Err(e) => {
            env.throw_new(
                "java/lang/RuntimeException",
-                format!("vnt start error {}", e),
+                format!("vnt start error {:?}", e),
            )
            .expect("throw");
            return Err(Error::JavaException);
@@ -2,3 +2,4 @@ pub mod callback;
 pub mod config;
 pub mod utils;
 pub mod vnt;
+pub(crate) mod vnt_logger;
@@ -119,3 +119,13 @@ pub fn to_integer(env: &mut JNIEnv, config: &JObject, name: &str) -> Result<Opti
        env.call_method(value, "intValue", "()I", &[])?.i()? as _
    ));
 }
+pub fn to_double(env: &mut JNIEnv, config: &JObject, name: &str) -> Result<Option<f64>, Error> {
+    let value = env.get_field(config, name, "Ljava/lang/Double;")?.l()?;
+    if value.is_null() {
+        return Ok(None);
+    }
+    // 调用 intValue
+    return Ok(Some(
+        env.call_method(value, "doubleValue", "()D", &[])?.d()? as _,
+    ));
+}
@@ -1,8 +1,9 @@
 use std::ptr;
+use std::time::Duration;

 use jni::errors::Error;
 use jni::objects::{JClass, JObject, JValue};
-use jni::sys::{jbyte, jint, jlong, jobject, jobjectArray, jsize};
+use jni::sys::{jboolean, jint, jlong, jobject, jobjectArray, jsize};
 use jni::JNIEnv;

 use vnt::channel::Route;
@@ -10,7 +11,6 @@ use vnt::core::Vnt;
 use vnt::handle::PeerDeviceInfo;

 use crate::callback::CallBack;
-
 #[no_mangle]
 pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_new0(
    mut env: JNIEnv<'static>,
@@ -18,6 +18,7 @@ pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_new0(
    config: JObject,
    call_back: JObject<'static>,
 ) -> jlong {
+    crate::vnt_logger::init_log();
    let jvm = if let Ok(jvm) = env.get_java_vm() {
        jvm
    } else {
@@ -30,7 +31,13 @@ pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_new0(
            } else {
                return 0;
            };
-            let vnt_util = match Vnt::new(config, CallBack::new(jvm, call_back)) {
+            let call_back = match CallBack::new(jvm, call_back) {
+                Ok(call_back) => call_back,
+                Err(_) => {
+                    return 0;
+                }
+            };
+            let vnt_util = match Vnt::new(config, call_back) {
                Ok(vnt_util) => vnt_util,
                Err(e) => {
                    env.throw_new(
@@ -58,6 +65,7 @@ pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_stop0(
    let vnt = raw_vnt as *mut Vnt;
    let _ = (&*vnt).stop();
 }
+
 #[no_mangle]
 pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_wait0(
    _env: JNIEnv,
@@ -67,6 +75,16 @@ pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_wait0(
    let vnt = raw_vnt as *mut Vnt;
    let _ = (&*vnt).wait();
 }
+#[no_mangle]
+pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_waitTimeout0(
+    _env: JNIEnv,
+    _class: JClass,
+    raw_vnt: jlong,
+    time: jlong,
+) -> jboolean {
+    let vnt = raw_vnt as *mut Vnt;
+    (&*vnt).wait_timeout(Duration::from_millis(time as _)) as _
+}

 #[no_mangle]
 pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_drop0(
@@ -90,7 +108,7 @@ pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_list0(

    let arr = match env.new_object_array(
        list.len() as jsize,
-        "top/wherewego/vnt/jni/PeerDeviceInfo",
+        "top/wherewego/vnt/jni/PeerRouteInfo",
        JObject::null(),
    ) {
        Ok(arr) => arr,
@@ -131,16 +149,14 @@ pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_list0(
 }

 fn route_parse(env: &mut JNIEnv, route: Route) -> Result<jobject, Error> {
-    let address = route.addr.to_string();
-    let metric = route.metric;
-    let rt = route.rt;
    let rs = env.new_object(
        "top/wherewego/vnt/jni/Route",
-        "(Ljava/lang/String;BI)V",
+        "(ZLjava/lang/String;BI)V",
        &[
-            JValue::Object(&env.new_string(address)?.into()),
-            JValue::Byte(metric as jbyte),
-            JValue::Int(rt as jint),
+            JValue::Bool(route.is_tcp as _),
+            JValue::Object(&env.new_string(route.addr.to_string())?.into()),
+            JValue::Byte(route.metric as _),
+            JValue::Int(route.rt as _),
        ],
    )?;
    Ok(rs.as_raw())
@@ -155,7 +171,7 @@ fn peer_device_info_parse(
    let name = peer.name.to_string();
    let status = format!("{:?}", peer.status);
    let rs = env.new_object(
-        "top/wherewego/vnt/jni/PeerDeviceInfo",
+        "top/wherewego/vnt/jni/PeerRouteInfo",
        "(ILjava/lang/String;Ljava/lang/String;Ltop/wherewego/vnt/jni/Route;)V",
        &[
            JValue::Int(virtual_ip as jint),
@@ -0,0 +1,12 @@
+#[cfg(target_os = "android")]
+pub fn init_log() {
+    use android_logger::Config;
+    use log::LevelFilter;
+    android_logger::init_once(
+        Config::default()
+            .with_max_level(LevelFilter::Info) // limit log level
+            .with_tag("vnt_jni"), // logs will show under mytag tag
+    );
+}
+#[cfg(not(target_os = "android"))]
+pub fn init_log() {}
@@ -1,12 +1,12 @@
 [package]
 name = "vnt"
-version = "1.2.9"
+version = "1.2.10"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-tun= {path = "tun"}
+tun = { path = "tun" }
 packet = { path = "./packet" }
 bytes = "1.5.0"
 log = "0.4.17"
@@ -19,19 +19,26 @@ sha2 = { version = "0.10.6", features = ["oid"] }
 thiserror = "1.0.37"
 protobuf = "3.2.0"
 socket2 = { version = "0.5.2", features = ["all"] }
-aes-gcm = { version = "0.10.2",optional = true }
+aes-gcm = { version = "0.10.2", optional = true }
 ring = { version = "0.17.0", optional = true }
-cbc = {version = "0.1.2",optional = true}
-ecb = {version = "0.1.2",optional = true}
+cbc = { version = "0.1.2", optional = true }
+ecb = { version = "0.1.2", optional = true }
 aes = "0.8.3"
 stun-format = { version = "1.0.1", features = ["fmt", "rfc3489"] }
-rsa = { version = "0.9.2", features = [] ,optional = true}
-spki = { version = "0.7.2", features = ["fingerprint", "alloc","base64"] ,optional = true}
-openssl-sys = { git = "https://github.com/lbl8603/rust-openssl" ,optional = true}
-libsm = {git="https://github.com/lbl8603/libsm" ,optional = true}
+rsa = { version = "0.9.2", features = [], optional = true }
+spki = { version = "0.7.2", features = ["fingerprint", "alloc", "base64"], optional = true }
+openssl-sys = { git = "https://github.com/lbl8603/rust-openssl", optional = true }
+libsm = { git = "https://github.com/lbl8603/libsm", optional = true }

-mio = {version = "0.8.10",features = ["os-poll","net"]}
+mio = { version = "0.8.10", features = ["os-poll", "net", "os-ext"] }
+crossbeam-queue = "0.3.11"
+anyhow = "1.0.82"
+dns-parser = "0.8.0"

+tokio = { version = "1.37.0", features = ["full"], optional = true }
+
+lz4_flex = { version = "0.11", default-features = false, optional = true }
+zstd = { version = "0.13.1", optional = true }
 [target.'cfg(target_os = "windows")'.dependencies]
 libloading = "0.8.0"

@@ -41,14 +48,17 @@ protobuf-codegen = "3.2.0"
 protoc-bin-vendored = "3.0.0"

 [features]
-default = ["server_encrypt","aes_gcm","aes_cbc","aes_ecb","sm4_cbc","ip_proxy"]
+default = ["server_encrypt", "aes_gcm", "aes_cbc", "aes_ecb", "sm4_cbc", "ip_proxy", "port_mapping", "lz4_compress","zstd_compress"]
 openssl = ["openssl-sys"]
 # 从源码编译
 openssl-vendored = ["openssl-sys/vendored"]
 ring-cipher = ["ring"]
-aes_cbc=["cbc"]
-aes_ecb=["ecb"]
-sm4_cbc=["libsm"]
-aes_gcm=["aes-gcm"]
-server_encrypt =["aes-gcm","rsa","spki"]
-ip_proxy=[]
+aes_cbc = ["cbc"]
+aes_ecb = ["ecb"]
+sm4_cbc = ["libsm"]
+aes_gcm = ["aes-gcm"]
+server_encrypt = ["aes-gcm", "rsa", "spki"]
+ip_proxy = ["tokio"]
+port_mapping = ["tokio"]
+lz4_compress = ["lz4_flex"]
+zstd_compress = ["zstd"]
@@ -81,6 +81,9 @@ impl<B: AsRef<[u8]> + AsMut<[u8]>> IpV4Packet<B> {
    pub fn set_flags(&mut self, flags: u8) {
        self.buffer.as_mut()[6] = (self.buffer.as_ref()[6] & 0b11100000) | (flags << 5)
    }
+    pub fn set_ttl(&mut self, ttl: u8) {
+        self.buffer.as_mut()[8] = ttl
+    }
    fn set_checksum(&mut self, value: u16) {
        self.header_mut()[10..12].copy_from_slice(&value.to_be_bytes())
    }
@@ -3,6 +3,7 @@ syntax = "proto3";
 message HandshakeRequest {
    string version = 1;
    bool secret = 2;
+    string key_finger = 3;
 }
 message HandshakeResponse {
    string version = 1;
@@ -23,6 +24,7 @@ message RegistrationRequest {
    fixed32 virtual_ip = 6;
    bool allow_ip_change = 7;
    bool client_secret = 8;
+    bytes client_secret_hash = 9;
 }

 message RegistrationResponse {
@@ -40,6 +42,7 @@ message DeviceInfo {
    fixed32 virtual_ip = 2;
    uint32 device_status = 3;
    bool client_secret = 4;
+    bytes client_secret_hash = 5;
 }

 message DeviceList {
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use std::net::{Ipv4Addr, SocketAddr, SocketAddrV6, UdpSocket};
 use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use std::{io, thread};
@@ -16,11 +16,11 @@ use crate::channel::{Route, RouteKey, UseChannelType, DEFAULT_RT};

 /// 传输通道上下文，持有udp socket、tcp socket和路由信息
 #[derive(Clone)]
-pub struct Context {
+pub struct ChannelContext {
    inner: Arc<ContextInner>,
 }

-impl Context {
+impl ChannelContext {
    pub fn new(
        main_udp_socket: Vec<UdpSocket>,
        use_channel_type: UseChannelType,
@@ -48,7 +48,6 @@ impl Context {
            tcp_map: RwLock::new(HashMap::with_capacity(64)),
            route_table: RouteTable::new(use_channel_type, first_latency, channel_num),
            is_tcp,
-            state: AtomicBool::new(true),
            packet_loss_rate,
            packet_delay,
            main_index: AtomicUsize::new(0),
@@ -63,7 +62,7 @@ impl Context {
    }
 }

-impl Deref for Context {
+impl Deref for ChannelContext {
    type Target = ContextInner;

    fn deref(&self) -> &Self::Target {
@@ -74,6 +73,7 @@ impl Deref for Context {
 /// 对称网络增加的udp socket数目，有助于增加打洞成功率
 pub const SYMMETRIC_CHANNEL_NUM: usize = 100;
 const PACKET_LOSS_RATE_DENOMINATOR: u32 = 100_0000;
+
 pub struct ContextInner {
    // 核心udp socket
    pub(crate) main_udp_socket: Vec<UdpSocket>,
@@ -85,8 +85,6 @@ pub struct ContextInner {
    pub route_table: RouteTable,
    // 是否使用tcp连接服务器
    is_tcp: bool,
-    //状态
-    state: AtomicBool,
    //控制丢包率，取值v=[0,100_0000] 丢包率r=v/100_0000
    packet_loss_rate: u32,
    //控制延迟
@@ -99,12 +97,6 @@ impl ContextInner {
    pub fn use_channel_type(&self) -> UseChannelType {
        self.route_table.use_channel_type
    }
-    pub fn is_stop(&self) -> bool {
-        !self.state.load(Ordering::Acquire)
-    }
-    pub fn stop(&self) {
-        self.state.store(false, Ordering::Release);
-    }
    /// 通过sub_udp_socket是否为空来判断是否为锥形网络
    pub fn is_cone(&self) -> bool {
        self.sub_udp_socket.read().is_empty()
@@ -198,6 +190,7 @@ impl ContextInner {
            self.send_main_udp(self.main_index.load(Ordering::Relaxed), buf, addr)
        }
    }
+
    pub fn change_main_index(&self) {
        let index = (self.main_index.load(Ordering::Relaxed) + 1) % self.main_udp_socket.len();
        self.main_index.store(index, Ordering::Relaxed);
@@ -289,15 +282,7 @@ impl ContextInner {
        }
    }
    pub fn remove_route(&self, ip: &Ipv4Addr, route_key: RouteKey) {
-        if self.route_table.remove_route(ip, route_key) {
-            if route_key.is_tcp {
-                if let Some(tcp) = self.tcp_map.write().remove(&route_key.addr) {
-                    if let Err(e) = tcp.shutdown() {
-                        log::warn!("{:?}", e);
-                    }
-                }
-            }
-        }
+        self.route_table.remove_route(ip, route_key)
    }
 }

@@ -330,7 +315,16 @@ impl RouteTable {
            } else {
                let len = v.len();
                if len != 0 {
-                    return Ok(v[index % len].0);
+                    let route = &v[index % len].0;
+                    // 跳过默认rt的路由(一般是刚加入的)，这有助于提升稳定性
+                    if route.rt != DEFAULT_RT {
+                        return Ok(*route);
+                    }
+                    for (route, _) in v {
+                        if route.rt != DEFAULT_RT {
+                            return Ok(*route);
+                        }
+                    }
                }
            }
        }
@@ -353,6 +347,15 @@ impl RouteTable {
            _ => {}
        }
        let key = route.route_key();
+        if only_if_absent {
+            if let Some((_, list)) = self.route_table.read().get(&id) {
+                for (x, _) in list {
+                    if x.route_key() == key {
+                        return;
+                    }
+                }
+            }
+        }
        let mut route_table = self.route_table.write();
        let (_, list) = route_table
            .entry(id)
@@ -461,14 +464,19 @@ impl RouteTable {
        }
        None
    }
-    pub fn need_punch(&self, id: &Ipv4Addr) -> bool {
+    pub fn no_need_punch(&self, id: &Ipv4Addr) -> bool {
        if let Some((_, v)) = self.route_table.read().get(id) {
-            //存在p2p的通道则不再打洞
-            if v.iter().filter(|(k, _)| k.is_p2p()).count() >= 1 {
-                return false;
-            }
+            //p2p的通道数符合要求
+            return v.iter().filter(|(k, _)| k.is_p2p()).count() >= self.channel_num;
+        }
+        false
+    }
+    pub fn p2p_num(&self, id: &Ipv4Addr) -> usize {
+        if let Some((_, v)) = self.route_table.read().get(id) {
+            v.iter().filter(|(k, _)| k.is_p2p()).count()
+        } else {
+            0
        }
-        true
    }
    /// 返回所有路由
    pub fn route_table(&self) -> Vec<(Ipv4Addr, Vec<Route>)> {
@@ -501,18 +509,13 @@ impl RouteTable {
        }
        list
    }
-    pub fn remove_route(&self, id: &Ipv4Addr, route_key: RouteKey) -> bool {
+    pub fn remove_route(&self, id: &Ipv4Addr, route_key: RouteKey) {
        let mut write_guard = self.route_table.write();
        if let Some((_, routes)) = write_guard.get_mut(id) {
            routes.retain(|(x, _)| x.route_key() != route_key);
            if routes.is_empty() {
                write_guard.remove(id);
-                true
-            } else {
-                false
            }
-        } else {
-            return true;
        }
    }
    /// 更新路由入栈包的时刻，长时间没有收到数据的路由将会被剔除
@@ -1,6 +1,12 @@
-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::RouteKey;

 pub trait RecvChannelHandler: Clone + Send + 'static {
-    fn handle(&mut self, buf: &mut [u8], route_key: RouteKey, context: &Context);
+    fn handle(
+        &mut self,
+        buf: &mut [u8],
+        extend: &mut [u8],
+        route_key: RouteKey,
+        context: &ChannelContext,
+    );
 }
@@ -1,16 +1,16 @@
 use std::net::Ipv4Addr;
 use std::time::Duration;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::Route;

 pub struct Idle {
    read_idle: Duration,
-    context: Context,
+    context: ChannelContext,
 }

 impl Idle {
-    pub fn new(read_idle: Duration, context: Context) -> Self {
+    pub fn new(read_idle: Duration, context: ChannelContext) -> Self {
        Self { read_idle, context }
    }
 }
@@ -1,13 +1,13 @@
-use std::io;
+use anyhow::Context;
 use std::net::{SocketAddr, UdpSocket};
 use std::str::FromStr;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::handler::RecvChannelHandler;
 use crate::channel::sender::AcceptSocketSender;
 use crate::channel::tcp_channel::tcp_listen;
 use crate::channel::udp_channel::udp_listen;
-use crate::util::{io_convert, StopManager};
+use crate::util::StopManager;

 pub mod context;
 pub mod handler;
@@ -18,7 +18,7 @@ pub mod sender;
 pub mod tcp_channel;
 pub mod udp_channel;

-const BUFFER_SIZE: usize = 1024 * 16;
+pub const BUFFER_SIZE: usize = 1024 * 16;
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum UseChannelType {
    Relay,
@@ -53,12 +53,6 @@ impl Default for UseChannelType {
        UseChannelType::All
    }
 }
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub enum Status {
-    Cone,
-    Symmetric,
-    Close,
-}

 #[derive(Copy, Clone, Debug)]
 pub struct Route {
@@ -74,7 +68,7 @@ pub struct RouteSortKey {
    pub metric: u8,
    pub rt: i64,
 }
-const DEFAULT_RT: i64 = 999;
+const DEFAULT_RT: i64 = 9999;
 impl Route {
    pub fn new(is_tcp: bool, index: usize, addr: SocketAddr, metric: u8, rt: i64) -> Self {
        Self {
@@ -151,7 +145,7 @@ pub fn init_context(
    is_tcp: bool,
    packet_loss_rate: Option<f64>,
    packet_delay: u32,
-) -> io::Result<(Context, mio::net::TcpListener)> {
+) -> anyhow::Result<(ChannelContext, mio::net::TcpListener)> {
    assert!(!ports.is_empty(), "not channel");
    let mut udps = Vec::with_capacity(ports.len());
    //检查系统是否支持ipv6
@@ -167,9 +161,9 @@ pub fn init_context(
        let (socket, address) = if use_ipv6 {
            let address: SocketAddr = format!("[::]:{}", port).parse().unwrap();
            let socket = socket2::Socket::new(socket2::Domain::IPV6, socket2::Type::DGRAM, None)?;
-            io_convert(socket.set_only_v6(false), |_| {
-                format!("set_only_v6 failed: {}", &address)
-            })?;
+            socket
+                .set_only_v6(false)
+                .with_context(|| format!("set_only_v6 failed: {}", &address))?;
            (socket, address)
        } else {
            let address: SocketAddr = format!("0.0.0.0:{}", port).parse().unwrap();
@@ -178,24 +172,19 @@ pub fn init_context(
                address,
            )
        };
-
-        io_convert(socket.set_reuse_address(true), |_| {
-            format!("set_reuse_address failed: {}", &address)
-        })?;
-        io_convert(socket.set_send_buffer_size(2 * 1024 * 1024), |_| {
-            format!("set_send_buffer_size failed: {}", &address)
-        })?;
-        io_convert(socket.set_recv_buffer_size(2 * 1024 * 1024), |_| {
-            format!("set_recv_buffer_size failed: {}", &address)
-        })?;
-        io_convert(socket.bind(&address.into()), |_| {
-            format!("bind failed: {}", &address)
-        })?;
+        if let Err(e) = socket.set_send_buffer_size(2 * 1024 * 1024) {
+            log::warn!("set_send_buffer_size {:?}", e);
+        }
+        if let Err(e) = socket.set_recv_buffer_size(2 * 1024 * 1024) {
+            log::warn!("set_send_buffer_size {:?}", e);
+        }
+        socket
+            .bind(&address.into())
+            .with_context(|| format!("bind failed: {}", &address))?;
        let main_channel: UdpSocket = socket.into();
-        main_channel.set_nonblocking(true)?;
        udps.push(main_channel);
    }
-    let context = Context::new(
+    let context = ChannelContext::new(
        udps,
        use_channel_type,
        first_latency,
@@ -210,9 +199,9 @@ pub fn init_context(
    let (socket, address) = if use_ipv6 {
        let address: SocketAddr = format!("[::]:{}", port).parse().unwrap();
        let socket = socket2::Socket::new(socket2::Domain::IPV6, socket2::Type::STREAM, None)?;
-        io_convert(socket.set_only_v6(false), |_| {
-            format!("set_only_v6 failed: {}", &address)
-        })?;
+        socket
+            .set_only_v6(false)
+            .with_context(|| format!("set_only_v6 failed: {}", &address))?;
        (socket, address)
    } else {
        let address: SocketAddr = format!("0.0.0.0:{}", port).parse().unwrap();
@@ -220,9 +209,6 @@ pub fn init_context(
        (socket, address)
    };

-    io_convert(socket.set_reuse_address(true), |_| {
-        format!("set_reuse_address failed: {}", &address)
-    })?;
    if let Err(e) = socket.bind(&address.into()) {
        if ports[0] == 0 {
            //端口可能冲突，则使用任意端口
@@ -232,12 +218,12 @@ pub fn init_context(
            } else {
                format!("0.0.0.0:{}", port).parse().unwrap()
            };
-            io_convert(socket.bind(&address.into()), |_| {
-                format!("bind failed: {}", &address)
-            })?;
+            socket
+                .bind(&address.into())
+                .with_context(|| format!("bind failed: {}", &address))?;
        } else {
            //手动指定的ip,直接报错
-            io_convert(Err(e), |_| format!("bind failed: {}", &address))?;
+            Err(anyhow::anyhow!("{:?},bind failed: {}", e, address))?;
        }
    }
    socket.listen(128)?;
@@ -249,10 +235,10 @@ pub fn init_context(

 pub fn init_channel<H>(
    tcp_listener: mio::net::TcpListener,
-    context: Context,
+    context: ChannelContext,
    stop_manager: StopManager,
    recv_handler: H,
-) -> io::Result<(
+) -> anyhow::Result<(
    AcceptSocketSender<Option<Vec<mio::net::UdpSocket>>>,
    AcceptSocketSender<(mio::net::TcpStream, SocketAddr, Option<Vec<u8>>)>,
 )>
@@ -8,8 +8,10 @@ use mio::net::TcpStream;
 use rand::prelude::SliceRandom;
 use rand::Rng;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::sender::AcceptSocketSender;
+use crate::external_route::ExternalRoute;
+use crate::nat::NatTest;

 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum PunchModel {
@@ -100,6 +102,9 @@ impl NatInfo {
    pub fn update_addr(&mut self, index: usize, ip: Ipv4Addr, port: u16) {
        if port != 0 {
            if let Some(public_port) = self.public_ports.get_mut(index) {
+                if *public_port != port {
+                    log::info!("端口变化={}:{} index={}", ip, port, index)
+                }
                *public_port = port;
            }
        }
@@ -111,6 +116,7 @@ impl NatInfo {
        {
            if !self.public_ips.contains(&ip) {
                self.public_ips.push(ip);
+                log::info!("ip变化={},{:?}", ip, self.public_ips)
            }
        }
    }
@@ -175,20 +181,24 @@ impl NatInfo {

 #[derive(Clone)]
 pub struct Punch {
-    context: Context,
+    context: ChannelContext,
    port_vec: Vec<u16>,
    port_index: HashMap<Ipv4Addr, usize>,
    punch_model: PunchModel,
    is_tcp: bool,
    tcp_socket_sender: AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
+    external_route: ExternalRoute,
+    nat_test: NatTest,
 }

 impl Punch {
    pub fn new(
-        context: Context,
+        context: ChannelContext,
        punch_model: PunchModel,
        is_tcp: bool,
        tcp_socket_sender: AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
+        external_route: ExternalRoute,
+        nat_test: NatTest,
    ) -> Self {
        let mut port_vec: Vec<u16> = (1..65535).collect();
        port_vec.push(65535);
@@ -201,14 +211,19 @@ impl Punch {
            punch_model,
            is_tcp,
            tcp_socket_sender,
+            external_route,
+            nat_test,
        }
    }
 }

 impl Punch {
    fn connect_tcp(&self, buf: &[u8], addr: SocketAddr) -> bool {
+        if self.nat_test.is_local_address(true, addr) {
+            return false;
+        }
        // mio是非阻塞的，不能立马判断是否能连接成功，所以用标准库的tcp
-        match std::net::TcpStream::connect_timeout(&addr, Duration::from_secs(3)) {
+        match std::net::TcpStream::connect_timeout(&addr, Duration::from_millis(100)) {
            Ok(tcp_stream) => {
                if tcp_stream.set_nonblocking(true).is_err() {
                    return false;
@@ -224,46 +239,69 @@ impl Punch {
        }
        false
    }
-    pub fn punch(&mut self, buf: &[u8], id: Ipv4Addr, nat_info: NatInfo) -> io::Result<()> {
-        if !self.context.route_table.need_punch(&id) {
+    pub fn punch(
+        &mut self,
+        buf: &[u8],
+        id: Ipv4Addr,
+        mut nat_info: NatInfo,
+        punch_tcp: bool,
+    ) -> io::Result<()> {
+        if self.context.route_table.no_need_punch(&id) {
            log::info!("已打洞成功,无需打洞:{:?}", id);
            return Ok(());
        }
-        if self.is_tcp && nat_info.tcp_port != 0 {
+        nat_info
+            .public_ips
+            .retain(|ip| self.external_route.route(&ip).is_none());
+        nat_info
+            .local_ipv4
+            .filter(|ip| self.external_route.route(&ip).is_none());
+        nat_info.ipv6.filter(|ip| {
+            if let Some(ip) = ip.to_ipv4_mapped() {
+                self.external_route.route(&ip).is_none()
+            } else {
+                true
+            }
+        });
+        if punch_tcp && self.is_tcp && nat_info.tcp_port != 0 {
            //向tcp发起连接
            if let Some(ipv6_addr) = nat_info.local_tcp_ipv6addr() {
                if self.connect_tcp(buf, ipv6_addr) {
-                    return Ok(());
+                    // return Ok(());
                }
            }
            //向tcp发起连接
            if let Some(ipv4_addr) = nat_info.local_tcp_ipv4addr() {
                if self.connect_tcp(buf, ipv4_addr) {
-                    return Ok(());
+                    // return Ok(());
                }
            }
            if nat_info.nat_type == NatType::Cone && nat_info.public_ips.len() == 1 {
                let addr =
                    SocketAddr::V4(SocketAddrV4::new(nat_info.public_ips[0], nat_info.tcp_port));
                if self.connect_tcp(buf, addr) {
-                    return Ok(());
+                    // return Ok(());
                }
            }
        }
        let channel_num = self.context.channel_num();
        for index in 0..channel_num {
            if let Some(ipv4_addr) = nat_info.local_udp_ipv4addr(index) {
-                let _ = self.context.send_main_udp(index, buf, ipv4_addr);
+                if !self.nat_test.is_local_address(false, ipv4_addr) {
+                    let _ = self.context.send_main_udp(index, buf, ipv4_addr);
+                }
            }
        }

        if self.punch_model != PunchModel::IPv4 {
            for index in 0..channel_num {
                if let Some(ipv6_addr) = nat_info.local_udp_ipv6addr(index) {
-                    let rs = self.context.send_main_udp(index, buf, ipv6_addr);
-                    log::info!("发送到ipv6地址:{:?},rs={:?}", ipv6_addr, rs);
-                    if rs.is_ok() && self.punch_model == PunchModel::IPv6 {
-                        return Ok(());
+                    if !self.nat_test.is_local_address(false, ipv6_addr) {
+                        let rs = self.context.send_main_udp(index, buf, ipv6_addr);
+                        log::info!("发送到ipv6地址:{:?},rs={:?}", ipv6_addr, rs);
+                        if rs.is_ok() && self.punch_model == PunchModel::IPv6 {
+                            return Ok(());
+                        }
                    }
                }
            }
@@ -5,22 +5,22 @@ use std::sync::Arc;

 use mio::Token;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::notify::{AcceptNotify, WritableNotify};

 #[derive(Clone)]
 pub struct ChannelSender {
-    context: Context,
+    context: ChannelContext,
 }

 impl ChannelSender {
-    pub fn new(context: Context) -> Self {
+    pub fn new(context: ChannelContext) -> Self {
        Self { context }
    }
 }

 impl Deref for ChannelSender {
-    type Target = Context;
+    type Target = ChannelContext;

    fn deref(&self) -> &Self::Target {
        &self.context
@@ -15,7 +15,7 @@ use std::{io, thread};
 use mio::net::{TcpListener, TcpStream};
 use mio::{Events, Interest, Poll, Registry, Token, Waker};

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::handler::RecvChannelHandler;
 use crate::channel::notify::{AcceptNotify, WritableNotify};
 use crate::channel::sender::{AcceptSocketSender, PacketSender};
@@ -30,7 +30,7 @@ pub fn tcp_listen<H>(
    tcp_server: TcpListener,
    stop_manager: StopManager,
    recv_handler: H,
-    context: Context,
+    context: ChannelContext,
 ) -> io::Result<AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>>
 where
    H: RecvChannelHandler,
@@ -74,7 +74,7 @@ fn tcp_listen0<H>(
    accept_notify: AcceptNotify,
    accept_tcp_receiver: Receiver<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
    mut recv_handler: H,
-    context: Context,
+    context: ChannelContext,
 ) -> io::Result<()>
 where
    H: RecvChannelHandler,
@@ -87,6 +87,7 @@ where

    let mut read_map: HashMap<Token, (RouteKey, TcpStream, Box<[u8; BUFFER_SIZE]>, usize)> =
        HashMap::with_capacity(32);
+    let mut extend = [0; BUFFER_SIZE];
    loop {
        poll.poll(&mut events, None)?;
        for event in events.iter() {
@@ -132,9 +133,13 @@ where
                }
                token => {
                    if event.is_readable() {
-                        if let Err(e) =
-                            readable_handle(&token, &mut read_map, &mut recv_handler, &context)
-                        {
+                        if let Err(e) = readable_handle(
+                            &token,
+                            &mut read_map,
+                            &mut recv_handler,
+                            &context,
+                            &mut extend,
+                        ) {
                            closed_handle_r(&token, &mut read_map);
                            log::warn!("{:?}", e);
                            if let Err(e) = write_waker.notify(token, false) {
@@ -158,7 +163,7 @@ where
 fn init_writable_handler(
    receiver: Receiver<(TcpStream, Token, SocketAddr, Option<Vec<u8>>)>,
    stop_manager: StopManager,
-    context: Context,
+    context: ChannelContext,
 ) -> io::Result<WritableNotify> {
    let poll = Poll::new()?;
    let writable_notify = WritableNotify::new(Waker::new(poll.registry(), NOTIFY)?);
@@ -190,7 +195,7 @@ fn tcp_writable_listen(
    receiver: Receiver<(TcpStream, Token, SocketAddr, Option<Vec<u8>>)>,
    mut poll: Poll,
    writable_notify: WritableNotify,
-    context: &Context,
+    context: &ChannelContext,
 ) -> io::Result<()> {
    let mut events = Events::with_capacity(1024);
    let mut write_map: HashMap<
@@ -338,7 +343,8 @@ fn readable_handle<H>(
    token: &Token,
    map: &mut HashMap<Token, (RouteKey, TcpStream, Box<[u8; BUFFER_SIZE]>, usize)>,
    recv_handler: &mut H,
-    context: &Context,
+    context: &ChannelContext,
+    extend: &mut [u8],
 ) -> io::Result<()>
 where
    H: RecvChannelHandler,
@@ -360,7 +366,7 @@ where
                    }
                    *begin += len;
                    if end > 4 && *begin == end {
-                        recv_handler.handle(&mut buf[4..end], *route_key, context);
+                        recv_handler.handle(&mut buf[4..end], extend, *route_key, context);
                        *begin = 0;
                    }
                }
@@ -447,7 +453,7 @@ fn closed_handle_w(
            Option<(Vec<u8>, usize)>,
        ),
    >,
-    context: &Context,
+    context: &ChannelContext,
 ) {
    if let Some((tcp, addr, _, _)) = map.remove(token) {
        context.tcp_map.write().remove(&addr);
@@ -1,13 +1,12 @@
 use std::collections::HashMap;
 use std::sync::mpsc::{sync_channel, Receiver};
-use std::sync::Arc;
 use std::{io, thread};

 use mio::event::Source;
 use mio::net::UdpSocket;
 use mio::{Events, Interest, Poll, Token, Waker};

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::handler::RecvChannelHandler;
 use crate::channel::notify::AcceptNotify;
 use crate::channel::sender::AcceptSocketSender;
@@ -17,7 +16,7 @@ use crate::util::StopManager;
 pub fn udp_listen<H>(
    stop_manager: StopManager,
    recv_handler: H,
-    context: Context,
+    context: ChannelContext,
 ) -> io::Result<AcceptSocketSender<Option<Vec<UdpSocket>>>>
 where
    H: RecvChannelHandler,
@@ -31,7 +30,7 @@ const NOTIFY: Token = Token(0);
 fn sub_udp_listen<H>(
    stop_manager: StopManager,
    recv_handler: H,
-    context: Context,
+    context: ChannelContext,
 ) -> io::Result<AcceptSocketSender<Option<Vec<UdpSocket>>>>
 where
    H: RecvChannelHandler,
@@ -62,7 +61,7 @@ where
 fn sub_udp_listen0<H>(
    mut poll: Poll,
    mut recv_handler: H,
-    context: Context,
+    context: ChannelContext,
    accept_notify: AcceptNotify,
    accept_receiver: Receiver<Option<Vec<UdpSocket>>>,
 ) -> io::Result<()>
@@ -71,6 +70,7 @@ where
 {
    let mut events = Events::with_capacity(1024);
    let mut buf = [0; BUFFER_SIZE];
+    let mut extend = [0; BUFFER_SIZE];
    let mut read_map: HashMap<Token, UdpSocket> = HashMap::with_capacity(32);
    loop {
        poll.poll(&mut events, None)?;
@@ -116,6 +116,7 @@ where
                                Ok((len, addr)) => {
                                    recv_handler.handle(
                                        &mut buf[..len],
+                                        &mut extend,
                                        RouteKey::new(false, token.0, addr),
                                        &context,
                                    );
@@ -135,15 +136,83 @@ where
    }
 }

-/// 阻塞监听
+// /// 阻塞
+// fn main_udp_listen<H>(
+//     stop_manager: StopManager,
+//     recv_handler: H,
+//     context: Context,
+// ) -> io::Result<()>
+// where
+//     H: RecvChannelHandler,
+// {
+//     for index in 0..context.main_udp_socket.len() {
+//         let stop_manager = stop_manager.clone();
+//         let context = context.clone();
+//         let recv_handler = recv_handler.clone();
+//         thread::Builder::new()
+//             .name(format!("mainUdp{}", index))
+//             .spawn(move || {
+//                 if let Err(e) = main_udp_listen0(stop_manager, index, recv_handler, context) {
+//                     log::error!("{:?}", e);
+//                 }
+//             })?;
+//     }
+//     Ok(())
+// }
+//
+// pub fn main_udp_listen0<H>(
+//     stop_manager: StopManager,
+//     index: usize,
+//     mut recv_handler: H,
+//     context: Context,
+// ) -> io::Result<()>
+// where
+//     H: RecvChannelHandler,
+// {
+//     use std::time::Duration;
+//     let udp_socket = &context.main_udp_socket[index];
+//     udp_socket.set_read_timeout(Some(Duration::from_secs(5)))?;
+//     udp_socket.set_write_timeout(Some(Duration::from_secs(1)))?;
+//     let local_addr = udp_socket.local_addr()?;
+//     let worker = stop_manager.add_listener(format!("main_udp_{}", index), move || {
+//         if let Ok(udp) = std::net::UdpSocket::bind("0.0.0.0:0") {
+//             let _ = udp.send_to(b"stop", format!("127.0.0.1:{}", local_addr.port()));
+//         }
+//     })?;
+//
+//     let mut buf = [0; BUFFER_SIZE];
+//     loop {
+//         match udp_socket.recv_from(&mut buf) {
+//             Ok((len, addr)) => {
+//                 if &buf[..len] == b"stop" {
+//                     if stop_manager.is_stop() {
+//                         break;
+//                     }
+//                 }
+//                 recv_handler.handle(&mut buf[..len], RouteKey::new(false, index, addr), &context);
+//             }
+//             Err(e) => {
+//                 if stop_manager.is_stop() {
+//                     break;
+//                 }
+//                 log::error!("index={},{:?},{}", index, udp_socket.local_addr(), e)
+//             }
+//         }
+//     }
+//     worker.stop_all();
+//     Ok(())
+// }
+
+/// 非阻塞
 fn main_udp_listen<H>(
    stop_manager: StopManager,
    recv_handler: H,
-    context: Context,
+    context: ChannelContext,
 ) -> io::Result<()>
 where
    H: RecvChannelHandler,
 {
+    use std::sync::Arc;
    let poll = Poll::new()?;
    let waker = Arc::new(Waker::new(poll.registry(), NOTIFY)?);
    let _waker = waker.clone();
@@ -164,7 +233,11 @@ where
    Ok(())
 }

-pub fn main_udp_listen0<H>(mut poll: Poll, mut recv_handler: H, context: Context) -> io::Result<()>
+pub fn main_udp_listen0<H>(
+    mut poll: Poll,
+    mut recv_handler: H,
+    context: ChannelContext,
+) -> io::Result<()>
 where
    H: RecvChannelHandler,
 {
@@ -181,6 +254,7 @@ where
    }

    let mut events = Events::with_capacity(udps.len());
+    let mut extend = [0; BUFFER_SIZE];
    loop {
        poll.poll(&mut events, None)?;
        for x in events.iter() {
@@ -199,6 +273,7 @@ where
                    Ok((len, addr)) => {
                        recv_handler.handle(
                            &mut buf[..len],
+                            &mut extend,
                            RouteKey::new(false, index, addr),
                            &context,
                        );
@@ -1,6 +1,7 @@
 #[cfg(feature = "aes_ecb")]
 #[cfg(not(any(feature = "openssl-vendored", feature = "openssl")))]
 use crate::cipher::aes_ecb::AesEcbCipher;
+use std::fmt::Display;

 #[cfg(feature = "aes_cbc")]
 use crate::cipher::aes_cbc::AesCbcCipher;
@@ -48,6 +49,22 @@ pub enum CipherModel {
    None,
 }

+impl Display for CipherModel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let str = match self {
+            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
+            CipherModel::AesGcm => "aes_gcm".to_string(),
+            #[cfg(feature = "aes_cbc")]
+            CipherModel::AesCbc => "aes_cbc".to_string(),
+            #[cfg(feature = "aes_ecb")]
+            CipherModel::AesEcb => "aes_ecb".to_string(),
+            #[cfg(feature = "sm4_cbc")]
+            CipherModel::Sm4Cbc => "sm4_cbc".to_string(),
+            CipherModel::None => "none".to_string(),
+        };
+        write!(f, "{}", str)
+    }
+}
 impl FromStr for CipherModel {
    type Err = String;

@@ -1,5 +1,5 @@
-use crate::protocol::NetPacket;
 use std::io;
+
 use {
    crate::protocol::body::{RsaSecretBody, RSA_ENCRYPTION_RESERVED},
    rand::Rng,
@@ -9,6 +9,8 @@ use {
    spki::{DecodePublicKey, EncodePublicKey},
 };

+use crate::protocol::NetPacket;
+
 #[derive(Clone)]
 pub struct RsaCipher {
    inner: Inner,
@@ -16,13 +18,15 @@ pub struct RsaCipher {
 #[derive(Clone)]
 struct Inner {
    public_key: RsaPublicKey,
+    finger: String,
 }

 impl RsaCipher {
    pub fn new(der: &[u8]) -> io::Result<Self> {
        match RsaPublicKey::from_public_key_der(der) {
            Ok(public_key) => {
-                let inner = Inner { public_key };
+                let finger = finger(&public_key)?;
+                let inner = Inner { public_key, finger };
                Ok(Self { inner })
            }
            Err(e) => Err(io::Error::new(
@@ -31,30 +35,32 @@ impl RsaCipher {
            )),
        }
    }
-
-    pub fn finger(&self) -> io::Result<String> {
-        match self.inner.public_key.to_public_key_der() {
-            Ok(der) => match rsa::pkcs8::SubjectPublicKeyInfoRef::from_der(der.as_bytes()) {
-                Ok(spki) => match spki.fingerprint_base64() {
-                    Ok(finger) => Ok(finger),
-                    Err(e) => Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        format!("fingerprint_base64 error {}", e),
-                    )),
-                },
+    pub fn finger(&self) -> &String {
+        &self.inner.finger
+    }
+    pub fn public_key(&self) -> io::Result<&RsaPublicKey> {
+        return Ok(&self.inner.public_key);
+    }
+}
+pub fn finger(public_key: &RsaPublicKey) -> io::Result<String> {
+    match public_key.to_public_key_der() {
+        Ok(der) => match rsa::pkcs8::SubjectPublicKeyInfoRef::from_der(der.as_bytes()) {
+            Ok(spki) => match spki.fingerprint_base64() {
+                Ok(finger) => Ok(finger),
                Err(e) => Err(io::Error::new(
                    io::ErrorKind::Other,
-                    format!("from_der error {}", e),
+                    format!("fingerprint_base64 error {}", e),
                )),
            },
            Err(e) => Err(io::Error::new(
                io::ErrorKind::Other,
-                format!("to_public_key_der error {}", e),
+                format!("from_der error {}", e),
            )),
-        }
-    }
-    pub fn public_key(&self) -> io::Result<&RsaPublicKey> {
-        return Ok(&self.inner.public_key);
+        },
+        Err(e) => Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!("to_public_key_der error {}", e),
+        )),
    }
 }

@@ -0,0 +1,33 @@
+use anyhow::anyhow;
+
+use crate::protocol::NetPacket;
+
+#[derive(Clone)]
+pub struct Lz4Compressor;
+
+impl Lz4Compressor {
+    pub fn compress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        in_net_packet: &NetPacket<I>,
+        out: &mut NetPacket<O>,
+    ) -> anyhow::Result<()> {
+        out.set_data_len_max();
+        let len = match lz4_flex::compress_into(in_net_packet.payload(), out.payload_mut()) {
+            Ok(len) => len,
+            Err(e) => Err(anyhow!("Lz4 compress {}", e))?,
+        };
+        out.set_payload_len(len)?;
+        Ok(())
+    }
+    pub fn decompress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        in_net_packet: &NetPacket<I>,
+        out: &mut NetPacket<O>,
+    ) -> anyhow::Result<()> {
+        out.set_data_len_max();
+        let len = match lz4_flex::decompress_into(in_net_packet.payload(), out.payload_mut()) {
+            Ok(len) => len,
+            Err(e) => Err(anyhow!("Lz4 decompress {}", e))?,
+        };
+        out.set_payload_len(len)?;
+        Ok(())
+    }
+}
@@ -0,0 +1,218 @@
+use std::str::FromStr;
+
+use anyhow::anyhow;
+
+#[cfg(feature = "lz4_compress")]
+use crate::compression::lz4_compress::Lz4Compressor;
+#[cfg(feature = "zstd_compress")]
+use crate::compression::zstd_compress::ZstdCompressor;
+use crate::protocol::extension::CompressionAlgorithm;
+#[cfg(feature = "zstd_compress")]
+use zstd::zstd_safe::CompressionLevel;
+
+use crate::protocol::NetPacket;
+
+#[cfg(feature = "lz4_compress")]
+mod lz4_compress;
+#[cfg(feature = "zstd_compress")]
+mod zstd_compress;
+
+#[derive(Clone, Copy, Debug)]
+pub enum Compressor {
+    #[cfg(feature = "lz4_compress")]
+    Lz4,
+    #[cfg(feature = "zstd_compress")]
+    Zstd(CompressionLevel),
+    None,
+}
+
+impl FromStr for Compressor {
+    type Err = String;
+    #[cfg(not(any(feature = "lz4_compress", feature = "zstd_compress")))]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Err(format!("not match '{}', Compression not supported", s))
+    }
+    #[cfg(any(feature = "lz4_compress", feature = "zstd_compress"))]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let str = s.trim().to_lowercase();
+        match str.as_str() {
+            #[cfg(feature = "lz4_compress")]
+            "lz4" => Ok(Compressor::Lz4),
+            #[cfg(feature = "zstd_compress")]
+            "zstd" => Ok(Compressor::Zstd(9)),
+            "none" => Ok(Compressor::None),
+            _ => {
+                #[cfg(feature = "zstd_compress")]
+                {
+                    let string_array: Vec<String> = str.split(',').map(|s| s.to_string()).collect();
+                    if string_array.len() != 2 || string_array[0] != "zstd" {
+                        return Err(format!("not match '{}', exp: zstd,10", s));
+                    }
+                    return match CompressionLevel::from_str(&string_array[1]) {
+                        Ok(level) => Ok(Compressor::Zstd(level)),
+                        Err(_) => Err(format!("not match '{}', exp: zstd,10", s)),
+                    };
+                }
+                #[cfg(not(feature = "zstd_compress"))]
+                #[cfg(feature = "lz4_compress")]
+                return Err(format!("not match '{}', exp: lz4", s));
+            }
+        }
+    }
+}
+
+#[cfg(not(any(feature = "lz4_compress", feature = "zstd_compress")))]
+impl Compressor {
+    pub fn compress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        _in_net_packet: &NetPacket<I>,
+        _out: &mut NetPacket<O>,
+    ) -> anyhow::Result<bool> {
+        Ok(false)
+    }
+    pub fn decompress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        _algorithm: CompressionAlgorithm,
+        _in_net_packet: &NetPacket<I>,
+        _out: &mut NetPacket<O>,
+    ) -> anyhow::Result<()> {
+        Err(anyhow!("Unsupported decompress"))
+    }
+}
+
+#[cfg(any(feature = "lz4_compress", feature = "zstd_compress"))]
+impl Compressor {
+    pub fn compress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        in_net_packet: &NetPacket<I>,
+        out: &mut NetPacket<O>,
+    ) -> anyhow::Result<bool> {
+        match self {
+            #[cfg(feature = "lz4_compress")]
+            Compressor::Lz4 => {
+                if in_net_packet.data_len() < 128 {
+                    return Ok(false);
+                }
+                Lz4Compressor::compress(in_net_packet, out)?;
+                let mut compression_extension_tail = out.append_compression_extension_tail()?;
+                compression_extension_tail.set_algorithm(CompressionAlgorithm::Lz4);
+                //压缩没效果，则放弃压缩
+                if out.data_len() >= in_net_packet.data_len() - 16 {
+                    return Ok(false);
+                }
+                return Ok(true);
+            }
+            #[cfg(feature = "zstd_compress")]
+            Compressor::Zstd(level) => {
+                if in_net_packet.data_len() < 128 {
+                    return Ok(false);
+                }
+                ZstdCompressor::compress(*level, in_net_packet, out)?;
+                let mut compression_extension_tail = out.append_compression_extension_tail()?;
+                compression_extension_tail.set_algorithm(CompressionAlgorithm::Zstd);
+                //压缩没效果，则放弃压缩
+                if out.data_len() >= in_net_packet.data_len() - 16 {
+                    return Ok(false);
+                }
+                return Ok(true);
+            }
+            Compressor::None => {}
+        }
+        Ok(false)
+    }
+    pub fn decompress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        algorithm: CompressionAlgorithm,
+        in_net_packet: &NetPacket<I>,
+        out: &mut NetPacket<O>,
+    ) -> anyhow::Result<()> {
+        match algorithm {
+            #[cfg(feature = "lz4_compress")]
+            CompressionAlgorithm::Lz4 => Lz4Compressor::decompress(in_net_packet, out),
+            #[cfg(feature = "zstd_compress")]
+            CompressionAlgorithm::Zstd => ZstdCompressor::decompress(in_net_packet, out),
+            _ => Err(anyhow!("Unknown decompress {:?}", algorithm)),
+        }
+    }
+}
+
+#[test]
+fn test_lz4() {
+    use crate::protocol::extension::{CompressionAlgorithm, ExtensionTailPacket};
+    let lz4 = Compressor::Lz4;
+    let in_packet = NetPacket::new([
+        65, 108, 105, 99, 101, 32, 119, 97, 116, 32, 98, 101, 103, 105, 110, 110, 105, 110, 103,
+        32, 116, 111, 32, 103, 101, 116, 32, 118, 101, 114, 121, 32, 116, 105, 114, 101, 100, 32,
+        111, 102, 32, 115, 105, 116, 116, 105, 110, 103, 32, 98, 121, 32, 104, 101, 114, 32, 115,
+        105, 115, 116, 101, 114, 32, 111, 110, 32, 116, 104, 101, 32, 98, 97, 110, 107, 44, 32, 97,
+        110, 100, 32, 111, 102, 32, 104, 97, 118, 105, 110, 103, 32, 110, 111, 116, 104, 105, 110,
+        103, 32, 116, 111, 32, 100, 111, 58, 32, 111, 110, 99, 101, 32, 111, 114, 32, 116, 119,
+        105, 99, 101, 32, 115, 104, 101, 32, 104, 97, 100, 32, 112, 101, 101, 112, 101, 100, 32,
+        105, 110, 116, 111, 32, 116, 104, 101, 32, 98, 111, 111, 107, 32, 104, 101, 114, 32, 115,
+        105, 115, 116, 101, 114, 32, 119, 97, 115, 32, 114, 101, 97, 100, 105, 110, 103, 44, 32,
+        98, 117, 116, 32, 105, 116, 32, 104, 97, 100, 32, 110, 111, 32, 112, 105, 99, 116, 117,
+        114, 101, 115, 32, 111, 114, 32, 99, 111, 110, 118, 101, 114, 115, 97, 116, 105,
+    ])
+    .unwrap();
+    let mut out_packet = NetPacket::new([0; 1000]).unwrap();
+    let mut src_out_packet = NetPacket::new([0; 1000]).unwrap();
+    lz4.compress(&in_packet, &mut out_packet).unwrap();
+    let tail = out_packet.split_tail_packet().unwrap();
+    match tail {
+        ExtensionTailPacket::Compression(c) => match c.algorithm() {
+            CompressionAlgorithm::Lz4 => {
+                Compressor::decompress(CompressionAlgorithm::Lz4, &out_packet, &mut src_out_packet)
+                    .unwrap();
+            }
+            _ => {
+                unimplemented!()
+            }
+        },
+        ExtensionTailPacket::Unknown => {
+            unimplemented!()
+        }
+    }
+    assert!(!out_packet.is_extension());
+    assert_eq!(in_packet.payload(), src_out_packet.payload())
+}
+#[test]
+fn test_zstd() {
+    use crate::protocol::extension::{CompressionAlgorithm, ExtensionTailPacket};
+    let zstd = Compressor::Zstd(22);
+    let in_packet = NetPacket::new([
+        65, 108, 105, 99, 101, 32, 119, 97, 115, 32, 98, 101, 103, 105, 110, 110, 105, 110, 103,
+        32, 116, 111, 32, 103, 101, 116, 32, 118, 101, 114, 121, 32, 116, 105, 114, 101, 100, 32,
+        111, 102, 32, 115, 105, 116, 116, 105, 110, 103, 32, 98, 121, 32, 104, 101, 114, 32, 115,
+        105, 115, 116, 101, 114, 32, 111, 110, 32, 116, 104, 101, 32, 98, 97, 110, 107, 44, 32, 97,
+        110, 100, 32, 111, 102, 32, 104, 97, 118, 105, 110, 103, 32, 110, 111, 116, 104, 105, 110,
+        103, 32, 116, 111, 32, 100, 111, 58, 32, 111, 110, 99, 101, 32, 111, 114, 32, 116, 119,
+        105, 99, 101, 32, 115, 104, 101, 32, 104, 97, 100, 32, 112, 101, 101, 112, 101, 100, 32,
+        105, 110, 116, 111, 32, 116, 104, 101, 32, 98, 111, 111, 107, 32, 104, 101, 114, 32, 115,
+        105, 115, 116, 101, 114, 32, 119, 97, 115, 32, 114, 101, 97, 100, 105, 110, 103, 44, 32,
+        98, 117, 116, 32, 105, 116, 32, 104, 97, 100, 32, 110, 111, 32, 112, 105, 99, 116, 117,
+        114, 101, 115, 32, 111, 114, 32, 99, 111, 110, 118, 101, 114, 115, 97, 116, 105,
+    ])
+    .unwrap();
+    let mut out_packet = NetPacket::new([0; 1000]).unwrap();
+    let mut src_out_packet = NetPacket::new([0; 1000]).unwrap();
+    zstd.compress(&in_packet, &mut out_packet).unwrap();
+    let tail = out_packet.split_tail_packet().unwrap();
+    match tail {
+        ExtensionTailPacket::Compression(c) => match c.algorithm() {
+            CompressionAlgorithm::Zstd => {
+                Compressor::decompress(
+                    CompressionAlgorithm::Zstd,
+                    &out_packet,
+                    &mut src_out_packet,
+                )
+                .unwrap();
+            }
+            _ => {
+                unimplemented!()
+            }
+        },
+        ExtensionTailPacket::Unknown => {
+            unimplemented!()
+        }
+    }
+    assert!(!out_packet.is_extension());
+    assert_eq!(in_packet.payload(), src_out_packet.payload())
+}
@@ -0,0 +1,38 @@
+use crate::protocol::NetPacket;
+use anyhow::anyhow;
+use zstd::zstd_safe::CompressionLevel;
+
+#[derive(Clone)]
+pub struct ZstdCompressor;
+
+impl ZstdCompressor {
+    pub fn compress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        compression_level: CompressionLevel,
+        in_net_packet: &NetPacket<I>,
+        out: &mut NetPacket<O>,
+    ) -> anyhow::Result<()> {
+        out.set_data_len_max();
+        let len = match zstd::zstd_safe::compress(
+            out.payload_mut(),
+            in_net_packet.payload(),
+            compression_level,
+        ) {
+            Ok(len) => len,
+            Err(e) => Err(anyhow!("zstd compress {}", e))?,
+        };
+        out.set_payload_len(len)?;
+        Ok(())
+    }
+    pub fn decompress<I: AsRef<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+        in_net_packet: &NetPacket<I>,
+        out: &mut NetPacket<O>,
+    ) -> anyhow::Result<()> {
+        out.set_data_len_max();
+        let len = match zstd::zstd_safe::decompress(out.payload_mut(), in_net_packet.payload()) {
+            Ok(len) => len,
+            Err(e) => Err(anyhow!("zstd decompress {}", e))?,
+        };
+        out.set_payload_len(len)?;
+        Ok(())
+    }
+}
@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::io;
 use std::net::Ipv4Addr;
 use std::sync::Arc;
 use std::time::Duration;
@@ -7,10 +6,10 @@ use std::time::Duration;
 use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::{Mutex, RwLock};
 use rand::Rng;
-
+#[cfg(not(target_os = "android"))]
 use tun::device::IFace;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::idle::Idle;
 use crate::channel::punch::{NatInfo, Punch};
 use crate::channel::{init_channel, init_context, Route, RouteKey};
@@ -22,14 +21,15 @@ use crate::external_route::{AllowExternalRoute, ExternalRoute};
 use crate::handle::handshaker::Handshake;
 use crate::handle::maintain::PunchReceiver;
 use crate::handle::recv_data::RecvDataHandler;
-use crate::handle::{
-    maintain, tun_tap, BaseConfigInfo, ConnectStatus, CurrentDeviceInfo, PeerDeviceInfo,
-};
+use crate::handle::{maintain, BaseConfigInfo, ConnectStatus, CurrentDeviceInfo, PeerDeviceInfo};
 use crate::nat::NatTest;
+use crate::tun_tap_device::tun_create_helper::{DeviceAdapter, TunDeviceHelper};
 use crate::util::{
    Scheduler, SingleU64Adder, StopManager, U64Adder, WatchSingleU64Adder, WatchU64Adder,
 };
-use crate::{nat, tun_tap_device, DeviceInfo, VntCallback};
+use crate::{nat, VntCallback};
+#[cfg(not(target_os = "android"))]
+use crate::{tun_tap_device, DeviceInfo};

 #[derive(Clone)]
 pub struct Vnt {
@@ -38,15 +38,16 @@ pub struct Vnt {
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    nat_test: NatTest,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
-    context: Context,
+    context: Arc<Mutex<Option<ChannelContext>>>,
    peer_nat_info_map: Arc<RwLock<HashMap<Ipv4Addr, NatInfo>>>,
    down_count_watcher: WatchU64Adder,
    up_count_watcher: WatchSingleU64Adder,
+    client_secret_hash: Option<[u8; 16]>,
 }

 impl Vnt {
-    pub fn new<Call: VntCallback>(config: Config, callback: Call) -> io::Result<Self> {
-        log::info!("config:{:?}", config);
+    pub fn new<Call: VntCallback>(config: Config, callback: Call) -> anyhow::Result<Self> {
+        log::info!("config.toml:{:?}", config);
        //服务端非对称加密
        #[cfg(feature = "server_encrypt")]
        let rsa_cipher: Arc<Mutex<Option<RsaCipher>>> = Arc::new(Mutex::new(None));
@@ -78,17 +79,33 @@ impl Vnt {
            config.name.clone(),
            config.token.clone(),
            config.ip,
-            config.password.is_some(),
+            config.password_hash(),
+            config.server_encrypt,
            config.device_id.clone(),
            config.server_address_str.clone(),
+            config.name_servers.clone(),
        );
-        let ports = config.ports.as_ref().map_or(vec![0, 0], |v| {
+        // 服务停止管理器
+        let stop_manager = {
+            let callback = callback.clone();
+            StopManager::new(move || callback.stop())
+        };
+        #[cfg(feature = "port_mapping")]
+        crate::port_mapping::start_port_mapping(
+            stop_manager.clone(),
+            config.port_mapping_list.clone(),
+        )?;
+        let mut ports = config.ports.as_ref().map_or(vec![0, 0], |v| {
            if v.is_empty() {
                vec![0, 0]
            } else {
                v.clone()
            }
        });
+        if config.use_channel_type.is_only_relay() {
+            //中继模式下只监听一个端口就够了
+            ports.truncate(1);
+        }
        //通道上下文
        let (context, tcp_listener) = init_context(
            ports,
@@ -112,14 +129,16 @@ impl Vnt {
            tcp_port,
        );

-        // 虚拟网卡
-        let device = tun_tap_device::create_device(&config)?;
-        let tun_info = DeviceInfo::new(device.name()?, device.version()?);
-        callback.create_tun(tun_info);
-        // 服务停止管理器
-        let stop_manager = {
-            let callback = callback.clone();
-            StopManager::new(move || callback.stop())
+        // pc上先创建虚拟网卡
+        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+        let device = {
+            log::info!("开始创建tun");
+            let device = tun_tap_device::create_device(&config)?;
+            log::info!("创建tun成功");
+            let tun_info = DeviceInfo::new(device.name()?, device.version()?);
+            log::info!("tun信息{:?}", tun_info);
+            callback.create_tun(tun_info);
+            device
        };
        // 定时器
        let scheduler = Scheduler::new(stop_manager.clone())?;
@@ -130,7 +149,6 @@ impl Vnt {
        let proxy_map = if !config.out_ips.is_empty() && !config.no_proxy {
            Some(crate::ip_proxy::init_proxy(
                context.clone(),
-                scheduler.clone(),
                stop_manager.clone(),
                current_device.clone(),
                client_cipher.clone(),
@@ -144,14 +162,38 @@ impl Vnt {
        let down_counter =
            U64Adder::with_capacity(config.ports.as_ref().map(|v| v.len()).unwrap_or_default() + 8);
        let down_count_watcher = down_counter.watch();
-        let handshake = Handshake::new();
+        let handshake = Handshake::new(
+            #[cfg(feature = "server_encrypt")]
+            rsa_cipher.clone(),
+        );
+        let up_counter = SingleU64Adder::new();
+        let up_count_watcher = up_counter.watch();
+        let tun_helper = TunDeviceHelper::new(
+            stop_manager.clone(),
+            context.clone(),
+            current_device.clone(),
+            external_route.clone(),
+            #[cfg(feature = "ip_proxy")]
+            proxy_map.clone(),
+            client_cipher.clone(),
+            server_cipher.clone(),
+            config.parallel,
+            up_counter,
+            device_list.clone(),
+            config.compressor,
+        );
+        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+        let device_adapter = DeviceAdapter::new(device.clone());
+        #[cfg(target_os = "android")]
+        let device_adapter = DeviceAdapter::new(tun_helper);
+
        let handler = RecvDataHandler::new(
            #[cfg(feature = "server_encrypt")]
            rsa_cipher,
            server_cipher.clone(),
            client_cipher.clone(),
            current_device.clone(),
-            device.clone(),
+            device_adapter,
            device_list.clone(),
            config_info.clone(),
            nat_test.clone(),
@@ -175,22 +217,13 @@ impl Vnt {
            config.punch_model,
            config.tcp,
            tcp_socket_sender.clone(),
+            external_route.clone(),
+            nat_test.clone(),
        );
-        let up_counter = SingleU64Adder::new();
-        let up_count_watcher = up_counter.watch();
-        tun_tap::tun_handler::start(
-            stop_manager.clone(),
-            context.clone(),
-            device.clone(),
-            current_device.clone(),
-            external_route,
-            #[cfg(feature = "ip_proxy")]
-            proxy_map,
-            client_cipher.clone(),
-            server_cipher.clone(),
-            config.parallel,
-            up_counter,
-        )?;
+
+        #[cfg(not(target_os = "android"))]
+        tun_helper.start(device)?;
+
        maintain::idle_gateway(
            &scheduler,
            context.clone(),
@@ -207,6 +240,7 @@ impl Vnt {
            let device_list = device_list.clone();
            let down_count_watcher = down_count_watcher.clone();
            let up_count_watcher = up_count_watcher.clone();
+            let config_info = config_info.clone();
            let current_device = current_device.clone();
            if !config.use_channel_type.is_only_relay() {
                // 定时nat探测
@@ -243,17 +277,18 @@ impl Vnt {
            current_device,
            nat_test,
            device_list,
-            context,
+            context: Arc::new(Mutex::new(Some(context))),
            peer_nat_info_map,
            down_count_watcher,
            up_count_watcher,
+            client_secret_hash: config_info.client_secret_hash,
        })
    }
 }

 pub fn start<Call: VntCallback>(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    nat_test: NatTest,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
@@ -295,15 +330,17 @@ pub fn start<Call: VntCallback>(
            client_cipher.clone(),
        );
    }
-    // 定时地址探测
-    maintain::addr_request(
-        &scheduler,
-        context.clone(),
-        current_device.clone(),
-        server_cipher.clone(),
-        config_info.clone(),
-    );
+
    if !context.use_channel_type().is_only_relay() {
+        // 定时地址探测
+        maintain::addr_request(
+            &scheduler,
+            context.clone(),
+            current_device.clone(),
+            server_cipher.clone(),
+            nat_test.clone(),
+            config_info.clone(),
+        );
        // 定时打洞
        maintain::punch(
            &scheduler,
@@ -335,6 +372,9 @@ impl Vnt {
    pub fn client_encrypt(&self) -> bool {
        self.config.password.is_some()
    }
+    pub fn client_encrypt_hash(&self) -> Option<&[u8]> {
+        self.client_secret_hash.as_ref().map(|v| v.as_ref())
+    }
    pub fn current_device(&self) -> CurrentDeviceInfo {
        self.current_device.load()
    }
@@ -354,16 +394,24 @@ impl Vnt {
        device_list
    }
    pub fn route(&self, ip: &Ipv4Addr) -> Option<Route> {
-        self.context.route_table.route_one(ip)
+        self.context.lock().as_ref()?.route_table.route_one(ip)
    }
    pub fn is_gateway(&self, ip: &Ipv4Addr) -> bool {
        self.current_device.load().is_gateway(ip)
    }
    pub fn route_key(&self, route_key: &RouteKey) -> Option<Ipv4Addr> {
-        self.context.route_table.route_to_id(route_key)
+        self.context
+            .lock()
+            .as_ref()?
+            .route_table
+            .route_to_id(route_key)
    }
    pub fn route_table(&self) -> Vec<(Ipv4Addr, Vec<Route>)> {
-        self.context.route_table.route_table()
+        if let Some(context) = self.context.lock().as_ref() {
+            context.route_table.route_table()
+        } else {
+            vec![]
+        }
    }
    pub fn up_stream(&self) -> u64 {
        self.up_count_watcher.get()
@@ -372,9 +420,17 @@ impl Vnt {
        self.down_count_watcher.get()
    }
    pub fn stop(&self) {
+        //退出协助回收资源
+        let _ = self.context.lock().take();
        self.stop_manager.stop()
    }
    pub fn wait(&self) {
        self.stop_manager.wait()
    }
+    pub fn wait_timeout(&self, dur: Duration) -> bool {
+        self.stop_manager.wait_timeout(dur)
+    }
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
 }
@@ -1,23 +1,27 @@
-use std::io;
-use std::net::{Ipv4Addr, SocketAddr};
+use anyhow::anyhow;
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::str::FromStr;

 pub use conn::Vnt;

 use crate::channel::punch::PunchModel;
 use crate::channel::UseChannelType;
 use crate::cipher::CipherModel;
+use crate::compression::Compressor;
+use crate::util::{address_choose, dns_query_all};

 mod conn;

 #[derive(Clone, Debug)]
 pub struct Config {
-    #[cfg(any(target_os = "windows", target_os = "linux"))]
+    #[cfg(target_os = "windows")]
    pub tap: bool,
    pub token: String,
    pub device_id: String,
    pub name: String,
    pub server_address: SocketAddr,
    pub server_address_str: String,
+    pub name_servers: Vec<String>,
    pub stun_server: Vec<String>,
    pub in_ips: Vec<(u32, u32, Ipv4Addr)>,
    pub out_ips: Vec<(u32, u32)>,
@@ -36,24 +40,26 @@ pub struct Config {
    pub first_latency: bool,
    #[cfg(not(target_os = "android"))]
    pub device_name: Option<String>,
-    #[cfg(target_os = "android")]
-    pub device_fd: i32,
    pub use_channel_type: UseChannelType,
    //控制丢包率
    pub packet_loss_rate: Option<f64>,
    pub packet_delay: u32,
+    // 端口映射
+    #[cfg(feature = "port_mapping")]
+    pub port_mapping_list: Vec<(bool, SocketAddr, String)>,
+    pub compressor: Compressor,
 }

 impl Config {
    pub fn new(
-        #[cfg(any(target_os = "windows", target_os = "linux"))] tap: bool,
+        #[cfg(target_os = "windows")] tap: bool,
        token: String,
        device_id: String,
        name: String,
-        server_address: SocketAddr,
        server_address_str: String,
+        mut name_servers: Vec<String>,
        mut stun_server: Vec<String>,
-        in_ips: Vec<(u32, u32, Ipv4Addr)>,
+        mut in_ips: Vec<(u32, u32, Ipv4Addr)>,
        out_ips: Vec<(u32, u32)>,
        password: Option<String>,
        mtu: Option<u32>,
@@ -68,33 +74,52 @@ impl Config {
        ports: Option<Vec<u16>>,
        first_latency: bool,
        #[cfg(not(target_os = "android"))] device_name: Option<String>,
-        #[cfg(target_os = "android")] device_fd: i32,
        use_channel_type: UseChannelType,
        packet_loss_rate: Option<f64>,
        packet_delay: u32,
-    ) -> io::Result<Self> {
+        // 例如 [udp:127.0.0.1:80->10.26.0.10:8080,tcp:127.0.0.1:80->10.26.0.10:8080]
+        #[cfg(feature = "port_mapping")] port_mapping_list: Vec<String>,
+        compressor: Compressor,
+    ) -> anyhow::Result<Self> {
        for x in stun_server.iter_mut() {
            if !x.contains(":") {
                x.push_str(":3478");
            }
        }
+        for x in name_servers.iter_mut() {
+            if Ipv6Addr::from_str(x).is_ok() {
+                x.push_str(":53");
+            } else if !x.contains(":") {
+                x.push_str(":53");
+            }
+        }
        if token.is_empty() || token.len() > 128 {
-            return Err(io::Error::new(io::ErrorKind::Other, "token too long"));
+            return Err(anyhow!("token too long"));
        }
        if device_id.is_empty() || device_id.len() > 128 {
-            return Err(io::Error::new(io::ErrorKind::Other, "device_id too long"));
+            return Err(anyhow!("device_id too long"));
        }
        if name.is_empty() || name.len() > 128 {
-            return Err(io::Error::new(io::ErrorKind::Other, "name too long"));
+            return Err(anyhow!("name too long"));
        }
+        let server_address =
+            address_choose(dns_query_all(&server_address_str, name_servers.clone())?)?;
+        #[cfg(feature = "port_mapping")]
+        let port_mapping_list = crate::port_mapping::convert(port_mapping_list)?;
+
+        for (dest, mask, _) in &mut in_ips {
+            *dest = *mask & *dest;
+        }
+        in_ips.sort_by(|(dest1, _, _), (dest2, _, _)| dest2.cmp(dest1));
        Ok(Self {
-            #[cfg(any(target_os = "windows", target_os = "linux"))]
+            #[cfg(target_os = "windows")]
            tap,
            token,
            device_id,
            name,
            server_address,
            server_address_str,
+            name_servers,
            stun_server,
            in_ips,
            out_ips,
@@ -113,11 +138,42 @@ impl Config {
            first_latency,
            #[cfg(not(target_os = "android"))]
            device_name,
-            #[cfg(target_os = "android")]
-            device_fd,
            use_channel_type,
            packet_loss_rate,
            packet_delay,
+            #[cfg(feature = "port_mapping")]
+            port_mapping_list,
+            compressor,
        })
    }
 }
+impl Config {
+    #[cfg(any(
+        feature = "aes_gcm",
+        feature = "server_encrypt",
+        feature = "aes_cbc",
+        feature = "aes_ecb",
+        feature = "sm4_cbc"
+    ))]
+    pub fn password_hash(&self) -> Option<[u8; 16]> {
+        self.password.as_ref().map(|v| {
+            use sha2::Digest;
+            let mut hasher = sha2::Sha256::new();
+            hasher.update(self.cipher_model.to_string().as_bytes());
+            hasher.update(v.as_bytes());
+            hasher.update(self.token.as_bytes());
+            let key: [u8; 32] = hasher.finalize().into();
+            key[16..].try_into().unwrap()
+        })
+    }
+    #[cfg(not(any(
+        feature = "aes_gcm",
+        feature = "server_encrypt",
+        feature = "aes_cbc",
+        feature = "aes_ecb",
+        feature = "sm4_cbc"
+    )))]
+    pub fn password_hash(&self) -> Option<[u8; 16]> {
+        None
+    }
+}
@@ -1,15 +1,18 @@
 use std::net::Ipv4Addr;
 use std::sync::Arc;

-// 目标ip，子网掩码，网关
-
+// 目标网段，子网掩码，网关
 #[derive(Clone)]
 pub struct ExternalRoute {
    route_table: Vec<(u32, u32, Ipv4Addr)>,
 }

 impl ExternalRoute {
-    pub fn new(route_table: Vec<(u32, u32, Ipv4Addr)>) -> Self {
+    pub fn new(mut route_table: Vec<(u32, u32, Ipv4Addr)>) -> Self {
+        for (dest, mask, _) in &mut route_table {
+            *dest = *mask & *dest;
+        }
+        route_table.sort_by(|(dest1, _, _), (dest2, _, _)| dest2.cmp(dest1));
        Self { route_table }
    }
    pub fn route(&self, ip: &Ipv4Addr) -> Option<Ipv4Addr> {
@@ -18,7 +21,7 @@ impl ExternalRoute {
        }
        let ip = u32::from_be_bytes(ip.octets());
        for (dest, mask, gateway) in self.route_table.iter() {
-            if *mask & ip == *mask & *dest {
+            if *mask & ip == *dest {
                return Some(*gateway);
            }
        }
@@ -27,18 +30,23 @@ impl ExternalRoute {
    pub fn to_route(&self) -> Vec<(Ipv4Addr, Ipv4Addr)> {
        self.route_table
            .iter()
-            .map(|(dest, mask, _)| (Ipv4Addr::from(*dest & *mask), Ipv4Addr::from(*mask)))
+            .map(|(dest, mask, _)| (Ipv4Addr::from(*dest), Ipv4Addr::from(*mask)))
            .collect::<Vec<(Ipv4Addr, Ipv4Addr)>>()
    }
 }

+// 目标网段，子网掩码
 #[derive(Clone)]
 pub struct AllowExternalRoute {
    route_table: Arc<Vec<(u32, u32)>>,
 }

 impl AllowExternalRoute {
-    pub fn new(route_table: Vec<(u32, u32)>) -> Self {
+    pub fn new(mut route_table: Vec<(u32, u32)>) -> Self {
+        for (dest, mask) in &mut route_table {
+            *dest = *mask & *dest;
+        }
+        route_table.sort_by(|(dest1, _), (dest2, _)| dest2.cmp(dest1));
        Self {
            route_table: Arc::new(route_table),
        }
@@ -1,21 +1,25 @@
+use crate::handle::PeerDeviceStatus;
 #[cfg(feature = "server_encrypt")]
 use rsa::RsaPublicKey;
 use std::fmt::{Display, Formatter};
 use std::io;
 use std::net::{Ipv4Addr, SocketAddr};

+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
 #[derive(Debug)]
 pub struct DeviceInfo {
    pub name: String,
    pub version: String,
 }

+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
 impl Display for DeviceInfo {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("name={} ,version={}", self.name, self.version))
    }
 }

+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
 impl DeviceInfo {
    pub fn new(name: String, version: String) -> Self {
        return Self { name, version };
@@ -68,6 +72,7 @@ impl Display for HandshakeInfo {
        f.write_str(&format!("server version={}", self.version))
    }
 }
+
 #[cfg(feature = "server_encrypt")]
 impl HandshakeInfo {
    pub fn new(public_key: RsaPublicKey, finger: String, version: String) -> Self {
@@ -85,6 +90,7 @@ impl HandshakeInfo {
        }
    }
 }
+
 #[cfg(not(feature = "server_encrypt"))]
 impl HandshakeInfo {
    pub fn new_no_secret(version: String) -> Self {
@@ -183,11 +189,89 @@ impl Into<u8> for ErrorType {
    }
 }

+#[cfg(target_os = "android")]
+#[derive(Debug)]
+pub struct DeviceConfig {
+    //本机虚拟IP
+    pub virtual_ip: Ipv4Addr,
+    //子网掩码
+    pub virtual_netmask: Ipv4Addr,
+    //虚拟网关
+    pub virtual_gateway: Ipv4Addr,
+    //虚拟网段
+    pub virtual_network: Ipv4Addr,
+    // 额外的路由
+    pub external_route: Vec<(Ipv4Addr, Ipv4Addr)>,
+}
+
+#[cfg(target_os = "android")]
+impl DeviceConfig {
+    pub fn new(
+        virtual_ip: Ipv4Addr,
+        virtual_netmask: Ipv4Addr,
+        virtual_gateway: Ipv4Addr,
+        virtual_network: Ipv4Addr,
+        external_route: Vec<(Ipv4Addr, Ipv4Addr)>,
+    ) -> Self {
+        Self {
+            virtual_ip,
+            virtual_netmask,
+            virtual_gateway,
+            virtual_network,
+            external_route,
+        }
+    }
+}
+
+#[cfg(target_os = "android")]
+impl Display for DeviceConfig {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!(
+            "ip={} ,netmask={} ,gateway={}, external_route={:?}",
+            self.virtual_ip, self.virtual_netmask, self.virtual_gateway, self.external_route
+        ))
+    }
+}
+
+#[derive(Debug)]
+pub struct PeerClientInfo {
+    pub virtual_ip: Ipv4Addr,
+    pub name: String,
+    pub status: PeerDeviceStatus,
+    pub client_secret: bool,
+}
+
+impl PeerClientInfo {
+    pub fn new(
+        virtual_ip: Ipv4Addr,
+        name: String,
+        status: PeerDeviceStatus,
+        client_secret: bool,
+    ) -> Self {
+        Self {
+            virtual_ip,
+            name,
+            status,
+            client_secret,
+        }
+    }
+}
+
+impl Display for PeerClientInfo {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!(
+            "ip={} ,name={} ,status={:?}, client_secret={}",
+            self.virtual_ip, self.name, self.status, self.client_secret
+        ))
+    }
+}
+
 pub trait VntCallback: Clone + Send + Sync + 'static {
    /// 启动成功
    fn success(&self) {}

    /// 创建网卡的信息
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
    fn create_tun(&self, _info: DeviceInfo) {}
    /// 连接
    fn connect(&self, _info: ConnectInfo) {}
@@ -199,6 +283,11 @@ pub trait VntCallback: Clone + Send + Sync + 'static {
    fn register(&self, _info: RegisterInfo) -> bool {
        true
    }
+    #[cfg(target_os = "android")]
+    fn generate_tun(&self, _info: DeviceConfig) -> u32 {
+        0
+    }
+    fn peer_client_list(&self, _info: Vec<PeerClientInfo>) {}
    /// 异常信息
    fn error(&self, _info: ErrorInfo) {}
    /// 服务停止
@@ -0,0 +1,24 @@
+use crate::compression::Compressor;
+use crate::protocol::extension::ExtensionTailPacket;
+use crate::protocol::NetPacket;
+use anyhow::anyhow;
+
+pub fn handle_extension_tail<I: AsRef<[u8]> + AsMut<[u8]>, O: AsRef<[u8]> + AsMut<[u8]>>(
+    in_net_packet: &mut NetPacket<I>,
+    out: &mut NetPacket<O>,
+) -> anyhow::Result<bool> {
+    if in_net_packet.is_extension() {
+        let tail_packet = in_net_packet.split_tail_packet()?;
+        match tail_packet {
+            ExtensionTailPacket::Compression(extension) => {
+                let compression_algorithm = extension.algorithm();
+                Compressor::decompress(compression_algorithm, &in_net_packet, out)?;
+                out.head_mut().copy_from_slice(in_net_packet.head());
+                Ok(true)
+            }
+            ExtensionTailPacket::Unknown => Err(anyhow!("Unknown decompress")),
+        }
+    } else {
+        Ok(false)
+    }
+}
@@ -4,9 +4,11 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};

 use crossbeam_utils::atomic::AtomicCell;
+#[cfg(feature = "server_encrypt")]
+use parking_lot::Mutex;
 use protobuf::Message;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 #[cfg(feature = "server_encrypt")]
 use crate::cipher::RsaCipher;
 use crate::handle::{GATEWAY_IP, SELF_IP};
@@ -15,7 +17,7 @@ use crate::proto::message::HandshakeRequest;
 use crate::proto::message::SecretHandshakeRequest;
 #[cfg(feature = "server_encrypt")]
 use crate::protocol::body::RSA_ENCRYPTION_RESERVED;
-use crate::protocol::{service_packet, NetPacket, Protocol, Version, MAX_TTL};
+use crate::protocol::{service_packet, NetPacket, Protocol, MAX_TTL};

 pub enum HandshakeEnum {
    NotSecret,
@@ -27,49 +29,58 @@ pub enum HandshakeEnum {
 #[derive(Clone)]
 pub struct Handshake {
    time: Arc<AtomicCell<Instant>>,
+    #[cfg(feature = "server_encrypt")]
+    rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
 }
 impl Handshake {
-    pub fn new() -> Self {
+    pub fn new(
+        #[cfg(feature = "server_encrypt")] rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
+    ) -> Self {
        Handshake {
            time: Arc::new(AtomicCell::new(Instant::now() - Duration::from_secs(60))),
+            #[cfg(feature = "server_encrypt")]
+            rsa_cipher,
        }
    }
-    pub fn send(&self, context: &Context, secret: bool, addr: SocketAddr) -> io::Result<()> {
+    pub fn send(&self, context: &ChannelContext, secret: bool, addr: SocketAddr) -> io::Result<()> {
        let last = self.time.load();
        //短时间不重复发送
        if last.elapsed() < Duration::from_secs(3) {
            return Ok(());
        }
-        let request_packet = handshake_request_packet(secret)?;
+        let request_packet = self.handshake_request_packet(secret)?;
        log::info!("发送握手请求,secret={},{:?}", secret, addr);
        context.send_default(request_packet.buffer(), addr)?;
        self.time.store(Instant::now());
        Ok(())
    }
-}
-
-/// 第一次握手数据
-pub fn handshake_request_packet(secret: bool) -> io::Result<NetPacket<Vec<u8>>> {
-    let mut request = HandshakeRequest::new();
-    request.secret = secret;
-    request.version = crate::VNT_VERSION.to_string();
-    let bytes = request.write_to_bytes().map_err(|e| {
-        io::Error::new(
-            io::ErrorKind::Other,
-            format!("handshake_request_packet {:?}", e),
-        )
-    })?;
-    let buf = vec![0u8; 12 + bytes.len()];
-    let mut net_packet = NetPacket::new(buf)?;
-    net_packet.set_version(Version::V1);
-    net_packet.set_gateway_flag(true);
-    net_packet.set_destination(GATEWAY_IP);
-    net_packet.set_source(SELF_IP);
-    net_packet.set_protocol(Protocol::Service);
-    net_packet.set_transport_protocol(service_packet::Protocol::HandshakeRequest.into());
-    net_packet.first_set_ttl(MAX_TTL);
-    net_packet.set_payload(&bytes)?;
-    Ok(net_packet)
+    /// 第一次握手数据
+    pub fn handshake_request_packet(&self, secret: bool) -> io::Result<NetPacket<Vec<u8>>> {
+        let mut request = HandshakeRequest::new();
+        request.secret = secret;
+        request.version = crate::VNT_VERSION.to_string();
+        #[cfg(feature = "server_encrypt")]
+        if let Some(finger) = self.rsa_cipher.lock().as_ref().map(|v| v.finger().clone()) {
+            request.key_finger = finger;
+        }
+        let bytes = request.write_to_bytes().map_err(|e| {
+            io::Error::new(
+                io::ErrorKind::Other,
+                format!("handshake_request_packet {:?}", e),
+            )
+        })?;
+        let buf = vec![0u8; 12 + bytes.len()];
+        let mut net_packet = NetPacket::new(buf)?;
+        net_packet.set_default_version();
+        net_packet.set_gateway_flag(true);
+        net_packet.set_destination(GATEWAY_IP);
+        net_packet.set_source(SELF_IP);
+        net_packet.set_protocol(Protocol::Service);
+        net_packet.set_transport_protocol(service_packet::Protocol::HandshakeRequest.into());
+        net_packet.first_set_ttl(MAX_TTL);
+        net_packet.set_payload(&bytes)?;
+        Ok(net_packet)
+    }
 }

 /// 第二次加密握手
@@ -92,7 +103,7 @@ pub fn secret_handshake_request_packet(
        12 + bytes.len(),
        vec![0u8; 12 + bytes.len() + RSA_ENCRYPTION_RESERVED],
    )?;
-    net_packet.set_version(Version::V1);
+    net_packet.set_default_version();
    net_packet.set_gateway_flag(true);
    net_packet.set_destination(GATEWAY_IP);
    net_packet.set_source(SELF_IP);
@@ -3,18 +3,21 @@ use std::time::Duration;

 use crossbeam_utils::atomic::AtomicCell;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
+use crate::channel::punch::NatType;
 use crate::cipher::Cipher;
 use crate::handle::{BaseConfigInfo, CurrentDeviceInfo};
+use crate::nat::NatTest;
 use crate::protocol::body::ENCRYPTION_RESERVED;
-use crate::protocol::{control_packet, NetPacket, Protocol, Version, MAX_TTL};
+use crate::protocol::{control_packet, NetPacket, Protocol, MAX_TTL};
 use crate::util::Scheduler;

 pub fn addr_request(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
    server_cipher: Cipher,
+    nat_test: NatTest,
    _config: BaseConfigInfo,
 ) {
    pub_address_request(
@@ -22,46 +25,83 @@ pub fn addr_request(
        context,
        current_device_info.clone(),
        server_cipher,
+        nat_test,
+        0,
    );
 }
-pub fn pub_address_request(
+
+fn pub_address_request(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
    server_cipher: Cipher,
+    nat_test: NatTest,
+    count: usize,
 ) {
-    addr_request0(&context, &current_device_info, &server_cipher);
-    // 17秒发送一次
-    let rs = scheduler.timeout(Duration::from_secs(17), |s| {
-        pub_address_request(s, context, current_device_info, server_cipher)
+    let channel_num = context.channel_num();
+    let index = count % channel_num;
+    let mut time = if index == channel_num - 1 { 19 } else { 1 };
+    if let Err(e) = addr_request0(
+        &context,
+        &current_device_info,
+        &server_cipher,
+        &nat_test,
+        index,
+    ) {
+        log::warn!("{:?}", e);
+    }
+    let nat_info = nat_test.nat_info();
+    if nat_info.nat_type == NatType::Symmetric {
+        //对称网络探测端口没啥作用，把频率放低，（锥形网络也只在打洞前需要探测端口，后续可以改改）
+        if !nat_info.public_ports.contains(&0) && !nat_info.public_ips.is_empty() {
+            time = 600;
+        }
+    }
+
+    let rs = scheduler.timeout(Duration::from_secs(time), move |s| {
+        pub_address_request(
+            s,
+            context,
+            current_device_info,
+            server_cipher,
+            nat_test,
+            index + 1,
+        )
    });
    if !rs {
        log::info!("定时任务停止");
    }
 }

-pub fn addr_request0(
-    context: &Context,
+fn addr_request0(
+    context: &ChannelContext,
    current_device: &AtomicCell<CurrentDeviceInfo>,
    server_cipher: &Cipher,
-) {
+    nat_test: &NatTest,
+    index: usize,
+) -> anyhow::Result<()> {
    let current_dev = current_device.load();
-    if current_dev.connect_server.is_ipv4() && current_dev.status.online() {
+    if current_dev.status.offline() {
+        return Ok(());
+    }
+
+    if current_dev.connect_server.is_ipv4() && !context.is_main_tcp() {
        // 如果连接的是ipv4服务，则探测公网端口
        let gateway_ip = current_dev.virtual_gateway;
        let src_ip = current_dev.virtual_ip;
        let mut packet = NetPacket::new_encrypt([0; 12 + ENCRYPTION_RESERVED]).unwrap();
-        packet.set_version(Version::V1);
+        packet.set_default_version();
        packet.set_gateway_flag(true);
        packet.set_protocol(Protocol::Control);
        packet.set_transport_protocol(control_packet::Protocol::AddrRequest.into());
        packet.first_set_ttl(MAX_TTL);
        packet.set_source(src_ip);
        packet.set_destination(gateway_ip);
-        if let Err(e) = server_cipher.encrypt_ipv4(&mut packet) {
-            log::warn!("AddrRequest err={:?}", e)
-        } else {
-            context.try_send_all_main(packet.buffer(), current_dev.connect_server);
-        }
+        server_cipher.encrypt_ipv4(&mut packet)?;
+        context.send_main_udp(index, packet.buffer(), current_dev.connect_server)?;
+    } else {
+        let (data, addr) = nat_test.send_data()?;
+        context.send_main_udp(index, &data, addr)?;
    }
+    Ok(())
 }
@@ -7,18 +7,18 @@ use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::Mutex;
 use rand::prelude::SliceRandom;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::cipher::Cipher;
 use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
 use crate::protocol::body::ENCRYPTION_RESERVED;
 use crate::protocol::control_packet::PingPacket;
-use crate::protocol::{control_packet, NetPacket, Protocol, Version};
+use crate::protocol::{control_packet, NetPacket, Protocol};
 use crate::util::Scheduler;

 /// 定时发送心跳包
 pub fn heartbeat(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    client_cipher: Cipher,
@@ -48,7 +48,7 @@ pub fn heartbeat(
 }

 fn heartbeat0(
-    context: &Context,
+    context: &ChannelContext,
    current_device: &CurrentDeviceInfo,
    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
    client_cipher: &Cipher,
@@ -125,7 +125,7 @@ fn heartbeat0(
 /// 客户端中继路径探测,延迟启动
 pub fn client_relay(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    client_cipher: Cipher,
@@ -141,7 +141,7 @@ pub fn client_relay(
 /// 客户端中继路径探测,每30秒探测一次
 fn client_relay_(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    client_cipher: Cipher,
@@ -163,7 +163,7 @@ fn client_relay_(
 }

 fn client_relay0(
-    context: &Context,
+    context: &ChannelContext,
    current_device: &CurrentDeviceInfo,
    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
    client_cipher: &Cipher,
@@ -213,7 +213,7 @@ fn heartbeat_packet(
    dest: Ipv4Addr,
 ) -> io::Result<NetPacket<[u8; 12 + 4 + ENCRYPTION_RESERVED]>> {
    let mut net_packet = NetPacket::new_encrypt([0u8; 12 + 4 + ENCRYPTION_RESERVED])?;
-    net_packet.set_version(Version::V1);
+    net_packet.set_default_version();
    net_packet.set_protocol(Protocol::Control);
    net_packet.set_transport_protocol(control_packet::Protocol::Ping.into());
    net_packet.first_set_ttl(5);
@@ -1,24 +1,24 @@
 use std::io;
-use std::net::{SocketAddr, ToSocketAddrs};
+use std::net::SocketAddr;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Duration;

 use crossbeam_utils::atomic::AtomicCell;
 use mio::net::TcpStream;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::idle::{Idle, IdleType};
 use crate::channel::sender::AcceptSocketSender;
 use crate::handle::callback::{ConnectInfo, ErrorType};
 use crate::handle::handshaker::Handshake;
-use crate::handle::{handshaker, BaseConfigInfo, ConnectStatus, CurrentDeviceInfo};
-use crate::util::Scheduler;
+use crate::handle::{BaseConfigInfo, ConnectStatus, CurrentDeviceInfo};
+use crate::util::{address_choose, dns_query_all, Scheduler};
 use crate::{ErrorInfo, VntCallback};

 pub fn idle_route<Call: VntCallback>(
    scheduler: &Scheduler,
    idle: Idle,
-    context: Context,
+    context: ChannelContext,
    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
    call: Call,
 ) {
@@ -30,39 +30,16 @@ pub fn idle_route<Call: VntCallback>(
        log::info!("定时任务停止");
    }
 }
+
 pub fn idle_gateway<Call: VntCallback>(
    scheduler: &Scheduler,
-    context: Context,
-    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
-    config: BaseConfigInfo,
-    tcp_socket_sender: AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
-    call: Call,
-    connect_count: usize,
-    handshake: Handshake,
-) {
-    let time = Instant::now();
-    idle_gateway_(
-        scheduler,
-        context,
-        current_device_info,
-        config,
-        tcp_socket_sender,
-        call,
-        connect_count,
-        handshake,
-        time,
-    );
-}
-pub fn idle_gateway_<Call: VntCallback>(
-    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
    config: BaseConfigInfo,
    tcp_socket_sender: AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
    call: Call,
    mut connect_count: usize,
    handshake: Handshake,
-    mut time: Instant,
 ) {
    idle_gateway0(
        &context,
@@ -72,10 +49,9 @@ pub fn idle_gateway_<Call: VntCallback>(
        &call,
        &mut connect_count,
        &handshake,
-        &mut time,
    );
    let rs = scheduler.timeout(Duration::from_secs(5), move |s| {
-        idle_gateway_(
+        idle_gateway(
            s,
            context,
            current_device_info,
@@ -84,22 +60,21 @@ pub fn idle_gateway_<Call: VntCallback>(
            call,
            connect_count,
            handshake,
-            time,
        )
    });
    if !rs {
        log::info!("定时任务停止");
    }
 }
+
 fn idle_gateway0<Call: VntCallback>(
-    context: &Context,
+    context: &ChannelContext,
    current_device: &AtomicCell<CurrentDeviceInfo>,
    config: &BaseConfigInfo,
    tcp_socket_sender: &AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
    call: &Call,
    connect_count: &mut usize,
    handshake: &Handshake,
-    time: &mut Instant,
 ) {
    if let Err(e) = check_gateway_channel(
        context,
@@ -109,7 +84,6 @@ fn idle_gateway0<Call: VntCallback>(
        call,
        connect_count,
        handshake,
-        time,
    ) {
        let cur = current_device.load();
        call.error(ErrorInfo::new_msg(
@@ -118,9 +92,10 @@ fn idle_gateway0<Call: VntCallback>(
        ));
    }
 }
+
 fn idle_route0<Call: VntCallback>(
    idle: &Idle,
-    context: &Context,
+    context: &ChannelContext,
    current_device: &AtomicCell<CurrentDeviceInfo>,
    call: &Call,
 ) -> Duration {
@@ -142,31 +117,27 @@ fn idle_route0<Call: VntCallback>(
 }

 fn check_gateway_channel<Call: VntCallback>(
-    context: &Context,
+    context: &ChannelContext,
    current_device_info: &AtomicCell<CurrentDeviceInfo>,
    config: &BaseConfigInfo,
    tcp_socket_sender: &AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
    call: &Call,
    count: &mut usize,
    handshake: &Handshake,
-    time: &mut Instant,
 ) -> io::Result<()> {
    let mut current_device = current_device_info.load();
    if current_device.status.offline() {
        *count += 1;
-        if time.elapsed() < Duration::from_secs(6 * 60) {
-            // 探测服务器地址
-            current_device = domain_request0(current_device_info, config);
-            *time = Instant::now()
-        }
+        // 探测服务器地址
+        current_device = domain_request0(current_device_info, config);
        //需要重连
        call.connect(ConnectInfo::new(*count, current_device.connect_server));
        log::info!("发送握手请求,{:?}", config);
-        if let Err(e) = handshake.send(context, config.client_secret, current_device.connect_server)
+        if let Err(e) = handshake.send(context, config.server_secret, current_device.connect_server)
        {
            log::warn!("{:?}", e);
            if context.is_main_tcp() {
-                let request_packet = handshaker::handshake_request_packet(config.client_secret)?;
+                let request_packet = handshake.handshake_request_packet(config.server_secret)?;
                //tcp需要重连
                let tcp_stream = std::net::TcpStream::connect_timeout(
                    &current_device.connect_server,
@@ -185,27 +156,48 @@ fn check_gateway_channel<Call: VntCallback>(
    }
    Ok(())
 }
+
 pub fn domain_request0(
    current_device: &AtomicCell<CurrentDeviceInfo>,
    config: &BaseConfigInfo,
 ) -> CurrentDeviceInfo {
    let mut current_dev = current_device.load();
+
    // 探测服务端地址变化
-    if let Ok(mut addr) = config.server_addr.to_socket_addrs() {
-        if let Some(addr) = addr.next() {
-            if addr != current_dev.connect_server {
-                let mut tmp = current_dev.clone();
-                tmp.connect_server = addr;
-                let rs = current_device.compare_exchange(current_dev, tmp);
-                current_dev.connect_server = addr;
-                log::info!(
-                    "服务端地址变化,旧地址:{}，新地址:{},替换结果:{}",
-                    current_dev.connect_server,
-                    addr,
-                    rs.is_ok()
-                );
+    match dns_query_all(&config.server_addr, config.name_servers.clone()) {
+        Ok(addrs) => {
+            log::info!(
+                "domain {} dns {:?} addr {:?}",
+                config.server_addr,
+                config.name_servers,
+                addrs
+            );
+
+            match address_choose(addrs) {
+                Ok(addr) => {
+                    if addr != current_dev.connect_server {
+                        let mut tmp = current_dev.clone();
+                        tmp.connect_server = addr;
+                        let rs = current_device.compare_exchange(current_dev, tmp);
+                        log::info!(
+                            "服务端地址变化,旧地址:{}，新地址:{},替换结果:{}",
+                            current_dev.connect_server,
+                            addr,
+                            rs.is_ok()
+                        );
+                        if rs.is_ok() {
+                            current_dev.connect_server = addr;
+                        }
+                    }
+                }
+                Err(e) => {
+                    log::error!("域名地址选择失败:{:?},domain={}", e, config.server_addr);
+                }
            }
        }
+        Err(e) => {
+            log::error!("域名解析失败:{:?},domain={}", e, config.server_addr);
+        }
    }
    current_dev
 }
@@ -6,7 +6,7 @@ mod re_nat_type;
 pub use re_nat_type::retrieve_nat_type;

 mod addr_request;
-pub use addr_request::addr_request;
+pub use addr_request::*;

 mod punch;
 pub use punch::*;
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::net::Ipv4Addr;
 use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::sync::Arc;
@@ -9,14 +10,14 @@ use parking_lot::Mutex;
 use protobuf::Message;
 use rand::prelude::SliceRandom;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::punch::{NatInfo, NatType, Punch};
 use crate::cipher::Cipher;
 use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
 use crate::nat::NatTest;
 use crate::proto::message::{PunchInfo, PunchNatType};
 use crate::protocol::body::ENCRYPTION_RESERVED;
-use crate::protocol::{control_packet, other_turn_packet, NetPacket, Protocol, Version, MAX_TTL};
+use crate::protocol::{control_packet, other_turn_packet, NetPacket, Protocol, MAX_TTL};
 use crate::util::Scheduler;

 #[derive(Clone)]
@@ -26,6 +27,7 @@ pub struct PunchSender {
    sender_cone_self: SyncSender<(Ipv4Addr, NatInfo)>,
    sender_cone_peer: SyncSender<(Ipv4Addr, NatInfo)>,
 }
+
 impl PunchSender {
    pub fn send(&self, src_peer: bool, ip: Ipv4Addr, info: NatInfo) -> bool {
        log::info!(
@@ -53,17 +55,19 @@ impl PunchSender {
        sender.try_send((ip, info)).is_ok()
    }
 }
+
 pub struct PunchReceiver {
    receiver_peer: Receiver<(Ipv4Addr, NatInfo)>,
    receiver_self: Receiver<(Ipv4Addr, NatInfo)>,
    receiver_cone_peer: Receiver<(Ipv4Addr, NatInfo)>,
    receiver_cone_self: Receiver<(Ipv4Addr, NatInfo)>,
 }
+
 pub fn punch_channel() -> (PunchSender, PunchReceiver) {
-    let (sender_self, receiver_self) = sync_channel(1);
-    let (sender_peer, receiver_peer) = sync_channel(1);
-    let (sender_cone_peer, receiver_cone_peer) = sync_channel(1);
-    let (sender_cone_self, receiver_cone_self) = sync_channel(1);
+    let (sender_self, receiver_self) = sync_channel(0);
+    let (sender_peer, receiver_peer) = sync_channel(0);
+    let (sender_cone_peer, receiver_cone_peer) = sync_channel(0);
+    let (sender_cone_self, receiver_cone_self) = sync_channel(0);
    (
        PunchSender {
            sender_self,
@@ -82,7 +86,7 @@ pub fn punch_channel() -> (PunchSender, PunchReceiver) {

 pub fn punch(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    nat_test: NatTest,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
@@ -90,6 +94,8 @@ pub fn punch(
    receiver: PunchReceiver,
    punch: Punch,
 ) {
+    let punch_record = Arc::new(Mutex::new(HashMap::new()));
+    let last_punch_record = HashMap::new();
    punch_request(
        scheduler,
        context,
@@ -98,15 +104,18 @@ pub fn punch(
        current_device.clone(),
        client_cipher.clone(),
        0,
+        punch_record.clone(),
+        last_punch_record,
    );
    let f = |receiver: Receiver<(Ipv4Addr, NatInfo)>| {
        let punch = punch.clone();
        let current_device = current_device.clone();
        let client_cipher = client_cipher.clone();
+        let punch_record = punch_record.clone();
        thread::Builder::new()
            .name("punch".into())
            .spawn(move || {
-                punch_start(receiver, punch, current_device, client_cipher);
+                punch_start(receiver, punch, current_device, client_cipher, punch_record);
            })
            .expect("punch");
    };
@@ -122,21 +131,33 @@ fn punch_start(
    mut punch: Punch,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    client_cipher: Cipher,
+    punch_record: Arc<Mutex<HashMap<Ipv4Addr, usize>>>,
 ) {
    while let Ok((peer_ip, nat_info)) = receiver.recv() {
        let mut packet = NetPacket::new_encrypt([0u8; 12 + ENCRYPTION_RESERVED]).unwrap();
-        packet.set_version(Version::V1);
+        packet.set_default_version();
        packet.first_set_ttl(1);
        packet.set_protocol(Protocol::Control);
        packet.set_transport_protocol(control_packet::Protocol::PunchRequest.into());
        packet.set_source(current_device.load().virtual_ip());
        packet.set_destination(peer_ip);
-        log::info!("发起打洞，目标:{:?},{:?}", peer_ip, nat_info);
+        let count = {
+            let mut guard = punch_record.lock();
+            if let Some(v) = guard.get_mut(&peer_ip) {
+                *v += 1;
+                *v
+            } else {
+                guard.insert(peer_ip, 1);
+                0
+            }
+        };
+        log::info!("第{}次发起打洞,目标:{:?},{:?} ", count, peer_ip, nat_info);
+
        if let Err(e) = client_cipher.encrypt_ipv4(&mut packet) {
            log::error!("{:?}", e);
            continue;
        }
-        if let Err(e) = punch.punch(packet.buffer(), peer_ip, nat_info) {
+        if let Err(e) = punch.punch(packet.buffer(), peer_ip, nat_info, count < 2) {
            log::warn!("{:?}", e)
        }
    }
@@ -145,22 +166,33 @@ fn punch_start(
 /// 定时发起打洞请求
 fn punch_request(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    nat_test: NatTest,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    client_cipher: Cipher,
    count: usize,
+    punch_record: Arc<Mutex<HashMap<Ipv4Addr, usize>>>,
+    mut last_punch_record: HashMap<Ipv4Addr, usize>,
 ) {
    let curr = current_device.load();
    let secs = if curr.status.online() {
-        if let Err(e) = punch0(&context, &nat_test, &device_list, curr, &client_cipher) {
+        if let Err(e) = punch0(
+            &context,
+            &nat_test,
+            &device_list,
+            curr,
+            &client_cipher,
+            &punch_record,
+            &mut last_punch_record,
+            count,
+        ) {
            log::warn!("{:?}", e)
        }
-        let sleep_time = [3, 5, 7, 11, 13, 17, 19, 23, 29];
+        let sleep_time = [5, 6, 7];
        Duration::from_secs(sleep_time[count % sleep_time.len()])
    } else {
-        Duration::from_secs(3)
+        Duration::from_secs(5)
    };
    let rs = scheduler.timeout(secs, move |s| {
        punch_request(
@@ -171,6 +203,8 @@ fn punch_request(
            current_device,
            client_cipher,
            count + 1,
+            punch_record,
+            last_punch_record,
        );
    });
    if !rs {
@@ -180,13 +214,26 @@ fn punch_request(

 /// 随机对需要打洞的客户端发起打洞请求
 fn punch0(
-    context: &Context,
+    context: &ChannelContext,
    nat_test: &NatTest,
    device_list: &Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    current_device: CurrentDeviceInfo,
    client_cipher: &Cipher,
+    punch_record: &Mutex<HashMap<Ipv4Addr, usize>>,
+    last_punch_record: &mut HashMap<Ipv4Addr, usize>,
+    total_count: usize,
 ) -> io::Result<()> {
    let nat_info = nat_test.nat_info();
+    if total_count < 10
+        && (nat_info.public_ips.is_empty()
+            || nat_info.public_ports.is_empty()
+            || nat_info.public_ports[0] == 0
+            || nat_info.public_ports.iter().filter(|&&v| v == 0).count()
+                > nat_info.public_ports.len() / 2)
+    {
+        log::info!("公网地址为空，暂时放弃打洞,第{}轮", total_count);
+        return Ok(());
+    }
    let current_ip = current_device.virtual_ip;
    let mut list: Vec<PeerDeviceInfo> = device_list
        .lock()
@@ -196,43 +243,51 @@ fn punch0(
        .cloned()
        .collect();
    list.shuffle(&mut rand::thread_rng());
-    let mut count = 0;
-    // // 优先没打洞的 need_punch会过滤掉已经打洞成功的
-    // list.sort_by(|v1, v2| {
-    //     if context.route_table.route_one_p2p(&v1.virtual_ip).is_none() {
-    //         Ordering::Less
-    //     } else if context.route_table.route_one_p2p(&v2.virtual_ip).is_none() {
-    //         Ordering::Greater
-    //     } else {
-    //         Ordering::Equal
-    //     }
-    // });
    for info in list {
-        if !info.status.is_online() {
-            continue;
+        let punch_count = punch_record
+            .lock()
+            .get(&info.virtual_ip)
+            .cloned()
+            .unwrap_or(0);
+        let p2p_num = context.route_table.p2p_num(&info.virtual_ip);
+        let mut max_punch_interval = 70;
+        if p2p_num > 0 {
+            if punch_count == 0 {
+                continue;
+            }
+            if p2p_num >= context.channel_num() {
+                //通道数满足要求，不再打洞
+                punch_record.lock().remove(&info.virtual_ip);
+                continue;
+            }
+            //有p2p通道，但是通道数量不够，则继续打洞
+            // 提高等待上限
+            max_punch_interval = 300;
        }
-        if info.virtual_ip <= current_device.virtual_ip {
-            continue;
-        }
-        if !context.route_table.need_punch(&info.virtual_ip) {
-            continue;
-        }
-        count += 1;
-        if count > 2 {
+        // 能发起打洞的前提是自己空闲，这里会间隔5秒以上发起一次打洞，所以假定上一轮打洞已结束
+        let last_punch = last_punch_record
+            .get(&info.virtual_ip)
+            .cloned()
+            .unwrap_or(0);
+        // 梯度增加打洞时间间隔
+        if total_count > last_punch + punch_count.min(max_punch_interval) {
+            last_punch_record.insert(info.virtual_ip, total_count);
+            let packet = punch_packet(
+                client_cipher,
+                current_device.virtual_ip(),
+                &nat_info,
+                info.virtual_ip,
+            )?;
+            log::info!(
+                "目标:{:?},当前nat:{:?} 第{}次发起打洞协商请求， 第:{}轮",
+                info.virtual_ip,
+                nat_info,
+                punch_count,
+                total_count,
+            );
+            context.send_default(packet.buffer(), current_device.connect_server)?;
            break;
        }
-        let packet = punch_packet(
-            client_cipher,
-            current_device.virtual_ip(),
-            &nat_info,
-            info.virtual_ip,
-        )?;
-        log::info!(
-            "发起打洞协商请求，目标:{:?},{:?}",
-            info.virtual_ip,
-            nat_info
-        );
-        context.send_default(packet.buffer(), current_device.connect_server)?;
    }
    Ok(())
 }
@@ -267,7 +322,7 @@ fn punch_packet(
        .write_to_bytes()
        .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("punch_packet {:?}", e)))?;
    let mut net_packet = NetPacket::new_encrypt(vec![0u8; 12 + bytes.len() + ENCRYPTION_RESERVED])?;
-    net_packet.set_version(Version::V1);
+    net_packet.set_default_version();
    net_packet.set_protocol(Protocol::OtherTurn);
    net_packet.set_transport_protocol(other_turn_packet::Protocol::Punch.into());
    net_packet.first_set_ttl(MAX_TTL);
@@ -1,7 +1,7 @@
 use std::thread;
 use std::time::Duration;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::sender::AcceptSocketSender;
 use crate::nat;
 use crate::nat::NatTest;
@@ -10,7 +10,7 @@ use crate::util::Scheduler;
 /// 10分钟探测一次nat
 pub fn retrieve_nat_type(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    nat_test: NatTest,
    udp_socket_sender: AcceptSocketSender<Option<Vec<mio::net::UdpSocket>>>,
 ) {
@@ -21,7 +21,7 @@ pub fn retrieve_nat_type(
 }

 fn retrieve_nat_type0(
-    context: Context,
+    context: ChannelContext,
    nat_test: NatTest,
    udp_socket_sender: AcceptSocketSender<Option<Vec<mio::net::UdpSocket>>>,
 ) {
@@ -1,8 +1,8 @@
-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::handle::CurrentDeviceInfo;
 use crate::proto::message::{ClientStatusInfo, PunchNatType, RouteItem};
 use crate::protocol::body::ENCRYPTION_RESERVED;
-use crate::protocol::{service_packet, NetPacket, Protocol, Version, HEAD_LEN, MAX_TTL};
+use crate::protocol::{service_packet, NetPacket, Protocol, HEAD_LEN, MAX_TTL};
 use crate::util::{Scheduler, WatchSingleU64Adder, WatchU64Adder};
 use crossbeam_utils::atomic::AtomicCell;
 use protobuf::Message;
@@ -13,7 +13,7 @@ use std::time::Duration;
 /// 上报状态给服务器
 pub fn up_status(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
    down_count_watcher: WatchU64Adder,
    up_count_watcher: WatchSingleU64Adder,
@@ -31,7 +31,7 @@ pub fn up_status(

 fn up_status0(
    scheduler: &Scheduler,
-    context: Context,
+    context: ChannelContext,
    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
    down_count_watcher: WatchU64Adder,
    up_count_watcher: WatchSingleU64Adder,
@@ -59,7 +59,7 @@ fn up_status0(
 }

 fn send_up_status_packet(
-    context: &Context,
+    context: &ChannelContext,
    current_device_info: &AtomicCell<CurrentDeviceInfo>,
    down_count_watcher: &WatchU64Adder,
    up_count_watcher: &WatchSingleU64Adder,
@@ -91,7 +91,7 @@ fn send_up_status_packet(
        .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("up_status_packet {:?}", e)))?;
    let mut net_packet =
        NetPacket::new_encrypt(vec![0; HEAD_LEN + buf.len() + ENCRYPTION_RESERVED])?;
-    net_packet.set_version(Version::V1);
+    net_packet.set_default_version();
    net_packet.set_gateway_flag(true);
    net_packet.set_protocol(Protocol::Service);
    net_packet.set_transport_protocol_into(service_packet::Protocol::ClientStatusInfo);
@@ -2,6 +2,7 @@ use crossbeam_utils::atomic::AtomicCell;
 use std::net::{Ipv4Addr, SocketAddr};

 pub mod callback;
+mod extension;
 pub mod handshaker;
 pub mod maintain;
 pub mod recv_data;
@@ -32,15 +33,23 @@ pub struct PeerDeviceInfo {
    pub name: String,
    pub status: PeerDeviceStatus,
    pub client_secret: bool,
+    pub client_secret_hash: Vec<u8>,
 }

 impl PeerDeviceInfo {
-    pub fn new(virtual_ip: Ipv4Addr, name: String, status: u8, client_secret: bool) -> Self {
+    pub fn new(
+        virtual_ip: Ipv4Addr,
+        name: String,
+        status: u8,
+        client_secret: bool,
+        client_secret_hash: Vec<u8>,
+    ) -> Self {
        Self {
            virtual_ip,
            name,
            status: PeerDeviceStatus::from(status),
            client_secret,
+            client_secret_hash,
        }
    }
 }
@@ -50,9 +59,11 @@ pub struct BaseConfigInfo {
    pub name: String,
    pub token: String,
    pub ip: Option<Ipv4Addr>,
-    pub client_secret: bool,
+    pub client_secret_hash: Option<[u8; 16]>,
+    pub server_secret: bool,
    pub device_id: String,
    pub server_addr: String,
+    pub name_servers: Vec<String>,
 }

 impl BaseConfigInfo {
@@ -60,17 +71,21 @@ impl BaseConfigInfo {
        name: String,
        token: String,
        ip: Option<Ipv4Addr>,
-        client_secret: bool,
+        client_secret_hash: Option<[u8; 16]>,
+        server_secret: bool,
        device_id: String,
        server_addr: String,
+        name_servers: Vec<String>,
    ) -> Self {
        Self {
            name,
            token,
            ip,
-            client_secret,
+            client_secret_hash,
+            server_secret,
            device_id,
            server_addr,
+            name_servers,
        }
    }
 }
@@ -1,22 +1,20 @@
+use parking_lot::RwLock;
+use protobuf::Message;
 use std::collections::HashMap;
 use std::io;
 use std::net::{Ipv4Addr, Ipv6Addr};
 use std::sync::Arc;

-use parking_lot::RwLock;
-use protobuf::Message;
-
 use packet::icmp::{icmp, Kind};
 use packet::ip::ipv4;
 use packet::ip::ipv4::packet::IpV4Packet;
-use tun::device::IFace;
-use tun::Device;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::punch::NatInfo;
 use crate::channel::{Route, RouteKey};
 use crate::cipher::Cipher;
 use crate::external_route::AllowExternalRoute;
+use crate::handle::extension::handle_extension_tail;
 use crate::handle::maintain::PunchSender;
 use crate::handle::recv_data::PacketHandler;
 use crate::handle::CurrentDeviceInfo;
@@ -27,13 +25,16 @@ use crate::proto::message::{PunchInfo, PunchNatType};
 use crate::protocol::body::ENCRYPTION_RESERVED;
 use crate::protocol::control_packet::ControlPacket;
 use crate::protocol::{
-    control_packet, ip_turn_packet, other_turn_packet, NetPacket, Protocol, Version, MAX_TTL,
+    control_packet, ip_turn_packet, other_turn_packet, NetPacket, Protocol, MAX_TTL,
 };
+use crate::tun_tap_device::tun_create_helper::DeviceAdapter;
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+use tun::device::IFace;

 /// 处理来源于客户端的包
 #[derive(Clone)]
 pub struct ClientPacketHandler {
-    device: Arc<Device>,
+    device: DeviceAdapter,
    client_cipher: Cipher,
    punch_sender: PunchSender,
    peer_nat_info_map: Arc<RwLock<HashMap<Ipv4Addr, NatInfo>>>,
@@ -45,7 +46,7 @@ pub struct ClientPacketHandler {

 impl ClientPacketHandler {
    pub fn new(
-        device: Arc<Device>,
+        device: DeviceAdapter,
        client_cipher: Cipher,
        punch_sender: PunchSender,
        peer_nat_info_map: Arc<RwLock<HashMap<Ipv4Addr, NatInfo>>>,
@@ -70,14 +71,26 @@ impl PacketHandler for ClientPacketHandler {
    fn handle(
        &self,
        mut net_packet: NetPacket<&mut [u8]>,
+        mut extend: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        self.client_cipher.decrypt_ipv4(&mut net_packet)?;
        context
            .route_table
            .update_read_time(&net_packet.source(), &route_key);
+        //处理扩展
+        let net_packet = if net_packet.is_extension() {
+            //这样重用数组，减少一次数据拷贝
+            if handle_extension_tail(&mut net_packet, &mut extend)? {
+                extend
+            } else {
+                net_packet
+            }
+        } else {
+            net_packet
+        };
        match net_packet.protocol() {
            Protocol::Service => {}
            Protocol::Error => {}
@@ -100,7 +113,7 @@ impl ClientPacketHandler {
    fn ip_turn(
        &self,
        mut net_packet: NetPacket<&mut [u8]>,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
        route_key: RouteKey,
    ) -> io::Result<()> {
@@ -143,6 +156,31 @@ impl ClientPacketHandler {
                        //拦截不符合的目标
                        return Ok(());
                    }
+                    match ipv4.protocol() {
+                        ipv4::protocol::Protocol::Tcp => {
+                            let payload = ipv4.payload();
+                            if payload.len() < 20 {
+                                return Ok(());
+                            }
+                            let destination_port =
+                                u16::from_be_bytes(payload[2..4].try_into().unwrap());
+                            if self.nat_test.is_local_tcp(real_dest, destination_port) {
+                                return Ok(());
+                            }
+                        }
+                        ipv4::protocol::Protocol::Udp => {
+                            let payload = ipv4.payload();
+                            if payload.len() < 8 {
+                                return Ok(());
+                            }
+                            let destination_port =
+                                u16::from_be_bytes(payload[2..4].try_into().unwrap());
+                            if self.nat_test.is_local_udp(real_dest, destination_port) {
+                                return Ok(());
+                            }
+                        }
+                        _ => {}
+                    }
                    #[cfg(feature = "ip_proxy")]
                    if let Some(ip_proxy_map) = &self.ip_proxy_map {
                        if ip_proxy_map.recv_handle(&mut ipv4, source, destination)? {
@@ -161,7 +199,7 @@ impl ClientPacketHandler {
    }
    fn control(
        &self,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
        mut net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
@@ -193,6 +231,14 @@ impl ClientPacketHandler {
                if context.use_channel_type().is_only_relay() {
                    return Ok(());
                }
+                //忽略掉来源于自己的包
+                if self
+                    .nat_test
+                    .is_local_address(route_key.is_tcp(), route_key.addr)
+                {
+                    return Ok(());
+                }
+
                //回应
                net_packet.set_transport_protocol(control_packet::Protocol::PunchResponse.into());
                net_packet.set_source(current_device.virtual_ip);
@@ -200,21 +246,28 @@ impl ClientPacketHandler {
                net_packet.first_set_ttl(1);
                self.client_cipher.encrypt_ipv4(&mut net_packet)?;
                context.send_by_key(net_packet.buffer(), route_key)?;
-                let route = Route::from_default_rt(route_key, 1);
-                context.route_table.add_route_if_absent(source, route);
+                // 收到PunchRequest就添加路由，会导致单向通信的问题，删掉试试
+                // let route = Route::from_default_rt(route_key, 1);
+                // context.route_table.add_route_if_absent(source, route);
            }
            ControlPacket::PunchResponse => {
                log::info!("PunchResponse={:?},source={}", route_key, source);
                if context.use_channel_type().is_only_relay() {
                    return Ok(());
                }
+                if self
+                    .nat_test
+                    .is_local_address(route_key.is_tcp(), route_key.addr)
+                {
+                    return Ok(());
+                }
                let route = Route::from_default_rt(route_key, 1);
                context.route_table.add_route_if_absent(source, route);
            }
            ControlPacket::AddrRequest => match route_key.addr.ip() {
                std::net::IpAddr::V4(ipv4) => {
                    let mut packet = NetPacket::new_encrypt([0; 12 + 6 + ENCRYPTION_RESERVED])?;
-                    packet.set_version(Version::V1);
+                    packet.set_default_version();
                    packet.set_protocol(Protocol::Control);
                    packet.set_transport_protocol(control_packet::Protocol::AddrResponse.into());
                    packet.first_set_ttl(MAX_TTL);
@@ -234,7 +287,7 @@ impl ClientPacketHandler {
    }
    fn other_turn(
        &self,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
        net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
@@ -313,7 +366,7 @@ impl ClientPacketHandler {
                    })?;
                    let mut punch_packet =
                        NetPacket::new_encrypt(vec![0u8; 12 + bytes.len() + ENCRYPTION_RESERVED])?;
-                    punch_packet.set_version(Version::V1);
+                    punch_packet.set_default_version();
                    punch_packet.set_protocol(Protocol::OtherTurn);
                    punch_packet.set_transport_protocol(other_turn_packet::Protocol::Punch.into());
                    punch_packet.first_set_ttl(MAX_TTL);
@@ -1,14 +1,12 @@
 use std::collections::HashMap;
 use std::net::Ipv4Addr;
 use std::sync::Arc;
-use std::{io, thread};
+use std::thread;

 use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::{Mutex, RwLock};

-use tun::Device;
-
-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::handler::RecvChannelHandler;
 use crate::channel::punch::NatInfo;
 use crate::channel::RouteKey;
@@ -27,6 +25,7 @@ use crate::handle::{BaseConfigInfo, CurrentDeviceInfo, PeerDeviceInfo, SELF_IP};
 use crate::ip_proxy::IpProxyMap;
 use crate::nat::NatTest;
 use crate::protocol::NetPacket;
+use crate::tun_tap_device::tun_create_helper::DeviceAdapter;
 use crate::util::U64Adder;

 mod client;
@@ -40,11 +39,29 @@ pub struct RecvDataHandler<Call> {
    client: ClientPacketHandler,
    server: ServerPacketHandler<Call>,
    counter: U64Adder,
+    nat_test: NatTest,
 }

 impl<Call: VntCallback> RecvChannelHandler for RecvDataHandler<Call> {
-    fn handle(&mut self, buf: &mut [u8], route_key: RouteKey, context: &Context) {
-        if let Err(e) = self.handle0(buf, route_key, context) {
+    fn handle(
+        &mut self,
+        buf: &mut [u8],
+        extend: &mut [u8],
+        route_key: RouteKey,
+        context: &ChannelContext,
+    ) {
+        //判断stun响应包
+        if !route_key.is_tcp() {
+            if let Ok(rs) = self
+                .nat_test
+                .recv_data(route_key.index(), route_key.addr, buf)
+            {
+                if rs {
+                    return;
+                }
+            }
+        }
+        if let Err(e) = self.handle0(buf, extend, route_key, context) {
            log::error!("[{}]-{:?}", thread::current().name().unwrap_or(""), e);
        }
    }
@@ -56,7 +73,7 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
        server_cipher: Cipher,
        client_cipher: Cipher,
        current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-        device: Arc<Device>,
+        device: DeviceAdapter,
        device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
        config_info: BaseConfigInfo,
        nat_test: NatTest,
@@ -79,7 +96,7 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
            config_info,
            nat_test.clone(),
            callback,
-            external_route,
+            external_route.clone(),
            handshake,
        );
        let client = ClientPacketHandler::new(
@@ -87,7 +104,7 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
            client_cipher,
            punch_sender,
            peer_nat_info_map,
-            nat_test,
+            nat_test.clone(),
            route,
            #[cfg(feature = "ip_proxy")]
            ip_proxy_map,
@@ -99,18 +116,22 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
            client,
            server,
            counter,
+            nat_test,
        }
    }
    fn handle0(
        &mut self,
        buf: &mut [u8],
+        extend: &mut [u8],
        route_key: RouteKey,
-        context: &Context,
-    ) -> io::Result<()> {
+        context: &ChannelContext,
+    ) -> anyhow::Result<()> {
        // 统计流量
        self.counter.add(buf.len() as _);
        let net_packet = NetPacket::new(buf)?;
+        let extend = NetPacket::unchecked(extend);
        if net_packet.ttl() == 0 || net_packet.source_ttl() < net_packet.ttl() {
+            log::warn!("丢弃过时包:{:?}", net_packet.head());
            return Ok(());
        }
        let current_device = self.current_device.load();
@@ -126,16 +147,16 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
            if net_packet.is_gateway() {
                //服务端-客户端包
                self.server
-                    .handle(net_packet, route_key, context, &current_device)
+                    .handle(net_packet, extend, route_key, context, &current_device)
            } else {
                //客户端-客户端包
                self.client
-                    .handle(net_packet, route_key, context, &current_device)
+                    .handle(net_packet, extend, route_key, context, &current_device)
            }
        } else {
            //转发包
            self.turn
-                .handle(net_packet, route_key, context, &current_device)
+                .handle(net_packet, extend, route_key, context, &current_device)
        }
    }
 }
@@ -144,8 +165,9 @@ pub trait PacketHandler {
    fn handle(
        &self,
        net_packet: NetPacket<&mut [u8]>,
+        extend: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
-    ) -> io::Result<()>;
+    ) -> anyhow::Result<()>;
 }
@@ -11,10 +11,8 @@ use protobuf::Message;
 use packet::icmp::{icmp, Kind};
 use packet::ip::ipv4;
 use packet::ip::ipv4::packet::IpV4Packet;
-use tun::device::IFace;
-use tun::Device;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::{Route, RouteKey};
 use crate::cipher::Cipher;
 #[cfg(feature = "server_encrypt")]
@@ -29,12 +27,15 @@ use crate::handle::{
    registrar, BaseConfigInfo, ConnectStatus, CurrentDeviceInfo, PeerDeviceInfo, GATEWAY_IP,
 };
 use crate::nat::NatTest;
-use crate::proto;
 use crate::proto::message::{DeviceList, HandshakeResponse, RegistrationResponse};
 use crate::protocol::body::ENCRYPTION_RESERVED;
 use crate::protocol::control_packet::ControlPacket;
 use crate::protocol::error_packet::InErrorPacket;
-use crate::protocol::{ip_turn_packet, service_packet, NetPacket, Protocol, Version, MAX_TTL};
+use crate::protocol::{ip_turn_packet, service_packet, NetPacket, Protocol, MAX_TTL};
+use crate::tun_tap_device::tun_create_helper::DeviceAdapter;
+use crate::{proto, PeerClientInfo};
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+use tun::device::IFace;

 /// 处理来源于服务端的包
 #[derive(Clone)]
@@ -43,13 +44,14 @@ pub struct ServerPacketHandler<Call> {
    rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
    server_cipher: Cipher,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-    device: Arc<Device>,
+    device: DeviceAdapter,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
    config_info: BaseConfigInfo,
    nat_test: NatTest,
    callback: Call,
    #[cfg(feature = "server_encrypt")]
    up_key_time: Arc<AtomicCell<Instant>>,
+    #[cfg(not(target_os = "android"))]
    route_record: Arc<Mutex<Vec<(Ipv4Addr, Ipv4Addr)>>>,
    external_route: ExternalRoute,
    handshake: Handshake,
@@ -60,7 +62,7 @@ impl<Call> ServerPacketHandler<Call> {
        #[cfg(feature = "server_encrypt")] rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
        server_cipher: Cipher,
        current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-        device: Arc<Device>,
+        device: DeviceAdapter,
        device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
        config_info: BaseConfigInfo,
        nat_test: NatTest,
@@ -80,6 +82,7 @@ impl<Call> ServerPacketHandler<Call> {
            callback,
            #[cfg(feature = "server_encrypt")]
            up_key_time: Arc::new(AtomicCell::new(Instant::now() - Duration::from_secs(60))),
+            #[cfg(not(target_os = "android"))]
            route_record: Arc::new(Mutex::default()),
            external_route,
            handshake,
@@ -91,10 +94,11 @@ impl<Call: VntCallback> PacketHandler for ServerPacketHandler<Call> {
    fn handle(
        &self,
        mut net_packet: NetPacket<&mut [u8]>,
+        _extend: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        context
            .route_table
            .update_read_time(&net_packet.source(), &route_key);
@@ -136,13 +140,45 @@ impl<Call: VntCallback> PacketHandler for ServerPacketHandler<Call> {
                HandshakeResponse::parse_from_bytes(net_packet.payload()).map_err(|e| {
                    io::Error::new(io::ErrorKind::Other, format!("HandshakeResponse {:?}", e))
                })?;
+            log::info!("握手响应:{:?},{}", route_key, response);
            //如果开启了加密，则发送加密握手请求
            #[cfg(feature = "server_encrypt")]
            if let Some(key) = self.server_cipher.key() {
+                {
+                    let guard = self.rsa_cipher.lock();
+                    if let Some(rsa_cipher) = guard.as_ref() {
+                        if rsa_cipher.finger() == &response.key_finger {
+                            let packet = handshaker::secret_handshake_request_packet(
+                                rsa_cipher,
+                                self.config_info.token.clone(),
+                                key,
+                            )?;
+                            drop(guard);
+                            context.send_by_key(packet.buffer(), route_key)?;
+                            return Ok(());
+                        }
+                        log::warn!(
+                            "拒绝服务端密钥对变化,原指纹:{:?}，新指纹:{:?}，addr:{:?}",
+                            rsa_cipher.finger(),
+                            response.key_finger,
+                            route_key
+                        );
+                        return Ok(());
+                    }
+                    drop(guard);
+                }
                let rsa_cipher = RsaCipher::new(&response.public_key)?;
+                if rsa_cipher.finger() != &response.key_finger {
+                    log::info!(
+                        "服务端密钥和指纹不匹 配拒绝握手,指纹1:{:?}，指纹2:{:?}",
+                        rsa_cipher.finger(),
+                        response.key_finger
+                    );
+                    return Ok(());
+                }
                let handshake_info = HandshakeInfo::new(
                    rsa_cipher.public_key()?.clone(),
-                    rsa_cipher.finger()?,
+                    response.key_finger,
                    response.version,
                );
                log::info!("加密握手请求:{:?}", handshake_info);
@@ -158,7 +194,10 @@ impl<Call: VntCallback> PacketHandler for ServerPacketHandler<Call> {
                }
                return Ok(());
            }
-
+            #[cfg(feature = "server_encrypt")]
+            if let Ok(rsa_cipher) = RsaCipher::new(&response.public_key) {
+                self.rsa_cipher.lock().replace(rsa_cipher);
+            }
            let handshake_info = HandshakeInfo::new_no_secret(response.version);
            if self.callback.handshake(handshake_info) {
                //没有加密，则发送注册请求
@@ -211,7 +250,7 @@ impl<Call: VntCallback> PacketHandler for ServerPacketHandler<Call> {
 impl<Call: VntCallback> ServerPacketHandler<Call> {
    fn service(
        &self,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
        net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
@@ -237,6 +276,10 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                    context
                        .route_table
                        .add_route_if_absent(virtual_gateway, route);
+                    let public_ip = response.public_ip.into();
+                    let public_port = response.public_port as u16;
+                    self.nat_test
+                        .update_addr(route_key.index(), public_ip, public_port);
                    let old = current_device;
                    let mut cur = *current_device;
                    loop {
@@ -245,7 +288,7 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                        new_current_device.virtual_ip = virtual_ip;
                        new_current_device.virtual_netmask = virtual_netmask;
                        new_current_device.virtual_gateway = virtual_gateway;
-                        new_current_device.status = crate::handle::ConnectStatus::Connected;
+                        new_current_device.status = ConnectStatus::Connected;
                        if let Err(c) = self
                            .current_device
                            .compare_exchange(cur, new_current_device)
@@ -256,10 +299,6 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                        }
                    }

-                    let public_ip = response.public_ip.into();
-                    let public_port = response.public_port as u16;
-                    self.nat_test
-                        .update_addr(route_key.index(), public_ip, public_port);
                    if old.virtual_ip != virtual_ip
                        || old.virtual_gateway != virtual_gateway
                        || old.virtual_netmask != virtual_netmask
@@ -267,57 +306,88 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                        if old.virtual_ip != Ipv4Addr::UNSPECIFIED {
                            log::info!("ip发生变化,old:{:?},response={:?}", old, response);
                        }
-                        if let Err(e) = self.device.set_ip(virtual_ip, virtual_netmask) {
-                            log::error!("LocalIpExists {:?}", e);
-                            self.callback.error(ErrorInfo::new_msg(
-                                ErrorType::LocalIpExists,
-                                format!("set_ip {:?}", e),
-                            ));
-                            return Ok(());
-                        }
-                        let mut guard = self.route_record.lock();
-                        for (dest, mask) in guard.drain(..) {
-                            if let Err(e) = self.device.delete_route(dest, mask) {
-                                log::warn!("删除路由失败 ={:?}", e);
+                        #[cfg(target_os = "android")]
+                        {
+                            let device_config = crate::handle::callback::DeviceConfig::new(
+                                virtual_ip,
+                                virtual_netmask,
+                                virtual_gateway,
+                                virtual_network,
+                                self.external_route.to_route(),
+                            );
+                            let device_fd = self.callback.generate_tun(device_config);
+                            if device_fd == 0 {
+                                self.callback.error(ErrorInfo::new_msg(
+                                    ErrorType::Unknown,
+                                    "device_fd == 0".into(),
+                                ));
+                            } else {
+                                if let Err(e) = self.device.start(device_fd as _) {
+                                    self.callback.error(ErrorInfo::new_msg(
+                                        ErrorType::Unknown,
+                                        format!("{:?}", e),
+                                    ));
+                                }
                            }
                        }
-                        if let Err(e) = self.device.add_route(virtual_network, virtual_netmask, 1) {
-                            log::warn!("添加默认路由失败 ={:?}", e);
-                        } else {
-                            guard.push((virtual_network, virtual_netmask));
-                        }
-                        if let Err(e) =
-                            self.device
-                                .add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, 1)
+                        #[cfg(not(target_os = "android"))]
                        {
-                            log::warn!("添加广播路由失败 ={:?}", e);
-                        } else {
-                            guard.push((Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST));
-                        }
+                            if let Err(e) = self.device.set_ip(virtual_ip, virtual_netmask) {
+                                log::error!("LocalIpExists {:?}", e);
+                                self.callback.error(ErrorInfo::new_msg(
+                                    ErrorType::LocalIpExists,
+                                    format!("set_ip {:?}", e),
+                                ));
+                                return Ok(());
+                            }
+                            let mut guard = self.route_record.lock();
+                            for (dest, mask) in guard.drain(..) {
+                                if let Err(e) = self.device.delete_route(dest, mask) {
+                                    log::warn!("删除路由失败 ={:?}", e);
+                                }
+                            }
+                            if let Err(e) =
+                                self.device.add_route(virtual_network, virtual_netmask, 1)
+                            {
+                                log::warn!("添加默认路由失败 ={:?}", e);
+                            } else {
+                                guard.push((virtual_network, virtual_netmask));
+                            }
+                            if let Err(e) =
+                                self.device
+                                    .add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, 1)
+                            {
+                                log::warn!("添加广播路由失败 ={:?}", e);
+                            } else {
+                                guard.push((Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST));
+                            }

-                        if let Err(e) = self.device.add_route(
-                            Ipv4Addr::from([224, 0, 0, 0]),
-                            Ipv4Addr::from([240, 0, 0, 0]),
-                            1,
-                        ) {
-                            log::warn!("添加组播路由失败 ={:?}", e);
-                        } else {
-                            guard.push((
+                            if let Err(e) = self.device.add_route(
                                Ipv4Addr::from([224, 0, 0, 0]),
                                Ipv4Addr::from([240, 0, 0, 0]),
-                            ));
-                        }
-
-                        for (dest, mask) in self.external_route.to_route() {
-                            if let Err(e) = self.device.add_route(dest, mask, 1) {
-                                log::warn!("添加路由失败 ={:?}", e);
+                                1,
+                            ) {
+                                log::warn!("添加组播路由失败 ={:?}", e);
                            } else {
-                                guard.push((dest, mask));
+                                guard.push((
+                                    Ipv4Addr::from([224, 0, 0, 0]),
+                                    Ipv4Addr::from([240, 0, 0, 0]),
+                                ));
+                            }
+
+                            for (dest, mask) in self.external_route.to_route() {
+                                if let Err(e) = self.device.add_route(dest, mask, 1) {
+                                    log::warn!("添加路由失败 ={:?}", e);
+                                } else {
+                                    guard.push((dest, mask));
+                                }
                            }
                        }
-                        self.callback.success();
                    }
                    self.set_device_info_list(response.device_info_list, response.epoch as _);
+                    if old.status.offline() {
+                        self.callback.success();
+                    }
                }
            }
            service_packet::Protocol::PushDeviceList => {
@@ -349,23 +419,40 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                    info.name,
                    info.device_status as u8,
                    info.client_secret,
+                    info.client_secret_hash,
                )
            })
            .collect();
-        let mut dev = self.device_list.lock();
-        //这里可能会收到旧的消息，但是随着时间推移总会收到新的
-        dev.0 = epoch;
-        dev.1 = ip_list;
+        {
+            let mut dev = self.device_list.lock();
+            //这里可能会收到旧的消息，但是随着时间推移总会收到新的
+            dev.0 = epoch;
+            dev.1 = ip_list.clone();
+        }
+        self.callback.peer_client_list(
+            ip_list
+                .into_iter()
+                .map(|v| PeerClientInfo::new(v.virtual_ip, v.name, v.status, v.client_secret))
+                .collect(),
+        );
    }
-    fn register(&self, current_device: &CurrentDeviceInfo, context: &Context) -> io::Result<()> {
+    fn register(
+        &self,
+        current_device: &CurrentDeviceInfo,
+        context: &ChannelContext,
+    ) -> io::Result<()> {
        if current_device.status.online() {
-            //已连接的不需要注册
+            log::info!("已连接的不需要注册，{:?}", self.config_info);
            return Ok(());
        }
        let token = self.config_info.token.clone();
        let device_id = self.config_info.device_id.clone();
        let name = self.config_info.name.clone();
-        let client_secret = self.config_info.client_secret;
+        let client_secret = self
+            .config_info
+            .client_secret_hash
+            .as_ref()
+            .map(|v| v.as_ref());
        let mut ip = self.config_info.ip;
        if ip.is_none() {
            ip = Some(current_device.virtual_ip)
@@ -386,7 +473,7 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
    }
    fn error(
        &self,
-        context: &Context,
+        context: &ChannelContext,
        _current_device: &CurrentDeviceInfo,
        net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
@@ -408,7 +495,7 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                    drop(dev);
                }
                self.handshake
-                    .send(context, self.config_info.client_secret, route_key.addr)?;
+                    .send(context, self.config_info.server_secret, route_key.addr)?;
                // self.register(current_device, context, route_key)?;
            }
            InErrorPacket::AddressExhausted => {
@@ -436,7 +523,7 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
    }
    fn control(
        &self,
-        context: &Context,
+        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
        net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
@@ -457,12 +544,12 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                    let mut poll_device = NetPacket::new_encrypt([0; 12 + ENCRYPTION_RESERVED])?;
                    poll_device.set_source(current_device.virtual_ip);
                    poll_device.set_destination(GATEWAY_IP);
-                    poll_device.set_version(Version::V1);
+                    poll_device.set_default_version();
                    poll_device.set_gateway_flag(true);
                    poll_device.first_set_ttl(MAX_TTL);
                    poll_device.set_protocol(Protocol::Service);
                    poll_device
-                        .set_transport_protocol(service_packet::Protocol::PollDeviceList.into());
+                        .set_transport_protocol(service_packet::Protocol::PullDeviceList.into());
                    self.server_cipher.encrypt_ipv4(&mut poll_device)?;
                    //发送到默认服务端即可
                    context.send_default(poll_device.buffer(), current_device.connect_server)?;
@@ -1,8 +1,9 @@
-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::channel::RouteKey;
 use crate::handle::recv_data::PacketHandler;
 use crate::handle::CurrentDeviceInfo;
 use crate::protocol::NetPacket;
+use anyhow::Context;

 /// 处理客户端中转包
 #[derive(Clone)]
@@ -18,10 +19,11 @@ impl PacketHandler for TurnPacketHandler {
    fn handle(
        &self,
        mut net_packet: NetPacket<&mut [u8]>,
+        _extend: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-        context: &Context,
+        context: &ChannelContext,
        _current_device: &CurrentDeviceInfo,
-    ) -> std::io::Result<()> {
+    ) -> anyhow::Result<()> {
        // ttl减一
        let ttl = net_packet.incr_ttl();
        if ttl > 0 {
@@ -33,12 +35,14 @@ impl PacketHandler for TurnPacketHandler {
                    return Ok(());
                }
                if route.metric <= ttl {
-                    context.send_by_key(net_packet.buffer(), route.route_key())?;
+                    return context
+                        .send_by_key(net_packet.buffer(), route.route_key())
+                        .context("转发失败");
                }
            }
            //其他没有路由的不转发
        }
-
+        log::info!("没有路由 {:?},{:?}", route_key, net_packet.head());
        Ok(())
    }
 }
@@ -7,7 +7,7 @@ use crate::cipher::Cipher;
 use crate::handle::{GATEWAY_IP, SELF_IP};
 use crate::proto::message::RegistrationRequest;
 use crate::protocol::body::ENCRYPTION_RESERVED;
-use crate::protocol::{service_packet, NetPacket, Protocol, Version, MAX_TTL};
+use crate::protocol::{service_packet, NetPacket, Protocol, MAX_TTL};

 /// 注册数据
 pub fn registration_request_packet(
@@ -18,7 +18,7 @@ pub fn registration_request_packet(
    ip: Option<Ipv4Addr>,
    is_fast: bool,
    allow_ip_change: bool,
-    client_secret: bool,
+    client_secret_hash: Option<&[u8]>,
 ) -> io::Result<NetPacket<Vec<u8>>> {
    let mut request = RegistrationRequest::new();
    request.token = token;
@@ -30,7 +30,12 @@ pub fn registration_request_packet(
    request.allow_ip_change = allow_ip_change;
    request.is_fast = is_fast;
    request.version = crate::VNT_VERSION.to_string();
-    request.client_secret = client_secret;
+    if let Some(client_secret_hash) = client_secret_hash {
+        request.client_secret = true;
+        request
+            .client_secret_hash
+            .extend_from_slice(client_secret_hash);
+    }
    let bytes = request.write_to_bytes().map_err(|e| {
        io::Error::new(io::ErrorKind::Other, format!("RegistrationRequest {:?}", e))
    })?;
@@ -38,7 +43,7 @@ pub fn registration_request_packet(
    let mut net_packet = NetPacket::new_encrypt(buf)?;
    net_packet.set_destination(GATEWAY_IP);
    net_packet.set_source(SELF_IP);
-    net_packet.set_version(Version::V1);
+    net_packet.set_default_version();
    net_packet.set_gateway_flag(true);
    net_packet.set_protocol(Protocol::Service);
    net_packet.set_transport_protocol(service_packet::Protocol::RegistrationRequest.into());
@@ -1,153 +1,11 @@
-use std::io;
-use std::net::Ipv4Addr;
-
-use crate::channel::context::Context;
-use packet::ip::ipv4::packet::IpV4Packet;
-use packet::ip::ipv4::protocol::Protocol;
-
-use crate::cipher::Cipher;
-use crate::external_route::ExternalRoute;
-use crate::handle::{check_dest, CurrentDeviceInfo};
-#[cfg(feature = "ip_proxy")]
-use crate::ip_proxy::{IpProxyMap, ProxyHandler};
-use crate::protocol;
-use crate::protocol::body::ENCRYPTION_RESERVED;
-use crate::protocol::ip_turn_packet::BroadcastPacket;
-use crate::protocol::{ip_turn_packet, NetPacket, Version, MAX_TTL};
-
 mod channel_group;
 pub mod tun_handler;

-fn broadcast(
-    server_cipher: &Cipher,
-    sender: &Context,
-    net_packet: &mut NetPacket<&mut [u8]>,
-    current_device: &CurrentDeviceInfo,
-) -> io::Result<()> {
-    let mut peer_ips = Vec::with_capacity(8);
-    let vec = sender.route_table.route_table_one();
-    let mut relay_count = 0;
-    const MAX_COUNT: usize = 8;
-    for (peer_ip, route) in vec {
-        if peer_ip == current_device.virtual_gateway {
-            continue;
-        }
-        if peer_ips.len() == MAX_COUNT {
-            relay_count += 1;
-            break;
-        }
-        if route.is_p2p()
-            && sender
-                .send_by_key(net_packet.buffer(), route.route_key())
-                .is_ok()
-        {
-            peer_ips.push(peer_ip);
-        } else {
-            relay_count += 1;
-        }
-    }
-    if (relay_count == 0 && !peer_ips.is_empty()) || current_device.status.offline() {
-        //不需要转发
-        return Ok(());
-    }
-    //转发到服务端的可选择广播，还要进行服务端加密
-    if peer_ips.is_empty() {
-        sender.send_default(net_packet.buffer(), current_device.connect_server)?;
-    } else {
-        let buf =
-            vec![0u8; 12 + 1 + peer_ips.len() * 4 + net_packet.data_len() + ENCRYPTION_RESERVED];
-        //剩余的发送到服务端，需要告知哪些已发送过
-        let mut server_packet = NetPacket::new_encrypt(buf)?;
-        server_packet.set_version(Version::V1);
-        server_packet.set_gateway_flag(true);
-        server_packet.first_set_ttl(MAX_TTL);
-        server_packet.set_source(net_packet.source());
-        //使用对应的目的地址
-        server_packet.set_destination(net_packet.destination());
-        server_packet.set_protocol(protocol::Protocol::IpTurn);
-        server_packet.set_transport_protocol(ip_turn_packet::Protocol::Ipv4Broadcast.into());
-
-        let mut broadcast = BroadcastPacket::unchecked(server_packet.payload_mut());
-        broadcast.set_address(&peer_ips)?;
-        broadcast.set_data(net_packet.buffer())?;
-        server_cipher.encrypt_ipv4(&mut server_packet)?;
-        sender.send_default(server_packet.buffer(), current_device.connect_server)?;
-    }
-    Ok(())
-}
-
-/// 实现一个原地发送，必须保证是如下结构
-/// |12字节开头|ip报文|至少1024字节结尾|
-///
-#[inline]
-pub fn base_handle(
-    context: &Context,
-    buf: &mut [u8],
-    data_len: usize, //数据总长度=12+ip包长度
-    current_device: CurrentDeviceInfo,
-    ip_route: &ExternalRoute,
-    #[cfg(feature = "ip_proxy")] proxy_map: &Option<IpProxyMap>,
-    client_cipher: &Cipher,
-    server_cipher: &Cipher,
-) -> io::Result<()> {
-    let ipv4_packet = IpV4Packet::new(&buf[12..data_len])?;
-    let protocol = ipv4_packet.protocol();
-    let src_ip = ipv4_packet.source_ip();
-    let mut dest_ip = ipv4_packet.destination_ip();
-    let mut net_packet = NetPacket::new0(data_len, 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(6);
-    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_gateway_flag(true);
-            server_cipher.encrypt_ipv4(&mut net_packet)?;
-            context.send_default(net_packet.buffer(), current_device.connect_server)?;
-        }
-        return Ok(());
-    }
-    if dest_ip.is_multicast() {
-        //当作广播处理
-        dest_ip = Ipv4Addr::BROADCAST;
-        net_packet.set_destination(Ipv4Addr::BROADCAST);
-    }
-    if dest_ip.is_broadcast() || current_device.broadcast_ip == dest_ip {
-        // 广播 发送到直连目标
-        client_cipher.encrypt_ipv4(&mut net_packet)?;
-        broadcast(server_cipher, context, &mut net_packet, &current_device)?;
-        return Ok(());
-    }
-    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(());
-        }
-    }
-    #[cfg(feature = "ip_proxy")]
-    if let Some(proxy_map) = proxy_map {
-        let mut ipv4_packet = IpV4Packet::new(net_packet.payload_mut())?;
-        proxy_map.send_handle(&mut ipv4_packet)?;
-    }
-    client_cipher.encrypt_ipv4(&mut net_packet)?;
-    context.send_ipv4_by_id(
-        net_packet.buffer(),
-        &dest_ip,
-        current_device.connect_server,
-        current_device.status.online(),
-    )
-}
+#[cfg(unix)]
+mod unix;
+#[cfg(unix)]
+pub(crate) use unix::*;
+#[cfg(target_os = "windows")]
+mod windows;
+#[cfg(target_os = "windows")]
+pub(crate) use windows::*;
@@ -1,26 +1,36 @@
+use std::net::Ipv4Addr;
 use std::sync::Arc;
 use std::{io, thread};

 use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;

+use crate::channel::BUFFER_SIZE;
 use packet::icmp::icmp::IcmpPacket;
 use packet::icmp::Kind;
-use packet::ip::ipv4;
 use packet::ip::ipv4::packet::IpV4Packet;
+use packet::ip::ipv4::protocol::Protocol;
 use tun::device::IFace;
 use tun::Device;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::cipher::Cipher;
+use crate::compression::Compressor;
 use crate::external_route::ExternalRoute;
-use crate::handle::tun_tap::channel_group::{channel_group, GroupSyncSender};
-use crate::handle::CurrentDeviceInfo;
+use crate::handle::tun_tap::channel_group::channel_group;
+use crate::handle::{check_dest, CurrentDeviceInfo, PeerDeviceInfo};
 #[cfg(feature = "ip_proxy")]
 use crate::ip_proxy::IpProxyMap;
+#[cfg(feature = "ip_proxy")]
+use crate::ip_proxy::ProxyHandler;
+use crate::protocol;
+use crate::protocol::body::ENCRYPTION_RESERVED;
+use crate::protocol::ip_turn_packet::BroadcastPacket;
+use crate::protocol::{ip_turn_packet, NetPacket, MAX_TTL};
 use crate::util::{SingleU64Adder, StopManager};

-fn icmp(device_writer: &Device, mut ipv4_packet: IpV4Packet<&mut [u8]>) -> io::Result<()> {
-    if ipv4_packet.protocol() == ipv4::protocol::Protocol::Icmp {
+fn icmp(device_writer: &Device, mut ipv4_packet: IpV4Packet<&mut [u8]>) -> anyhow::Result<()> {
+    if ipv4_packet.protocol() == Protocol::Icmp {
        let mut icmp = IcmpPacket::new(ipv4_packet.payload_mut())?;
        if icmp.kind() == Kind::EchoRequest {
            icmp.set_kind(Kind::EchoReply);
@@ -36,17 +46,20 @@ fn icmp(device_writer: &Device, mut ipv4_packet: IpV4Packet<&mut [u8]>) -> io::R
 }

 /// 接收tun数据，并且转发到udp上
-fn handle(
-    context: &Context,
+pub(crate) fn handle(
+    context: &ChannelContext,
    data: &mut [u8],
    len: usize,
+    extend: &mut [u8],
    device_writer: &Device,
    current_device: CurrentDeviceInfo,
    ip_route: &ExternalRoute,
    #[cfg(feature = "ip_proxy")] proxy_map: &Option<IpProxyMap>,
    client_cipher: &Cipher,
    server_cipher: &Cipher,
-) -> io::Result<()> {
+    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
+    compressor: &Compressor,
+) -> anyhow::Result<()> {
    //忽略掉结构不对的情况（ipv6数据、win tap会读到空数据），不然日志打印太多了
    let ipv4_packet = match IpV4Packet::new(&mut data[12..len]) {
        Ok(packet) => packet,
@@ -57,22 +70,25 @@ fn handle(
    if src_ip == dest_ip {
        return icmp(&device_writer, ipv4_packet);
    }
-    return crate::handle::tun_tap::base_handle(
+    return base_handle(
        context,
        data,
        len,
+        extend,
        current_device,
        ip_route,
        #[cfg(feature = "ip_proxy")]
        proxy_map,
        client_cipher,
        server_cipher,
+        device_list,
+        compressor,
    );
 }

 pub fn start(
    stop_manager: StopManager,
-    context: Context,
+    context: ChannelContext,
    device: Arc<Device>,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    ip_route: ExternalRoute,
@@ -81,24 +97,9 @@ pub fn start(
    server_cipher: Cipher,
    parallel: usize,
    mut up_counter: SingleU64Adder,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    compressor: Compressor,
 ) -> io::Result<()> {
-    let worker = {
-        #[cfg(target_os = "macos")]
-        let current_device = current_device.clone();
-        let device = device.clone();
-        stop_manager.add_listener("tun_device".into(), move || {
-            if let Err(e) = device.shutdown() {
-                log::warn!("{:?}", e);
-            }
-            #[cfg(target_os = "macos")]
-            {
-                let ip = current_device.load().virtual_ip;
-                if let Ok(udp) = std::net::UdpSocket::bind("0.0.0.0:0") {
-                    let _ = udp.send_to(b"stop", format!("{:?}:1234", ip));
-                }
-            }
-        })?
-    };
    if parallel > 1 {
        let (sender, receivers) = channel_group::<(Vec<u8>, usize)>(parallel, 16);
        for (index, receiver) in receivers.into_iter().enumerate() {
@@ -110,9 +111,11 @@ pub fn start(
            let ip_proxy_map = ip_proxy_map.clone();
            let client_cipher = client_cipher.clone();
            let server_cipher = server_cipher.clone();
+            let device_list = device_list.clone();
            thread::Builder::new()
                .name(format!("tunHandler-{}", index))
                .spawn(move || {
+                    let mut extend = [0; BUFFER_SIZE];
                    while let Ok((mut buf, len)) = receiver.recv() {
                        #[cfg(not(target_os = "macos"))]
                        let start = 0;
@@ -122,6 +125,7 @@ pub fn start(
                            &context,
                            &mut buf[start..],
                            len,
+                            &mut extend,
                            &device,
                            current_device.load(),
                            &ip_route,
@@ -129,6 +133,8 @@ pub fn start(
                            &ip_proxy_map,
                            &client_cipher,
                            &server_cipher,
+                            &device_list,
+                            &compressor,
                        ) {
                            Ok(_) => {}
                            Err(e) => {
@@ -141,16 +147,20 @@ pub fn start(
        thread::Builder::new()
            .name("tunHandlerM".into())
            .spawn(move || {
-                if let Err(e) = start_multi(stop_manager, device, sender, &mut up_counter) {
+                if let Err(e) = crate::handle::tun_tap::start_multi(
+                    stop_manager,
+                    device,
+                    sender,
+                    &mut up_counter,
+                ) {
                    log::warn!("stop:{}", e);
                }
-                worker.stop_all();
            })?;
    } else {
        thread::Builder::new()
            .name("tunHandlerS".into())
            .spawn(move || {
-                if let Err(e) = start_simple(
+                if let Err(e) = crate::handle::tun_tap::start_simple(
                    stop_manager,
                    &context,
                    device,
@@ -161,74 +171,193 @@ pub fn start(
                    client_cipher,
                    server_cipher,
                    &mut up_counter,
+                    device_list,
+                    compressor,
                ) {
                    log::warn!("stop:{}", e);
                }
-                worker.stop_all();
            })?;
    }
    Ok(())
 }

-fn start_simple(
-    stop_manager: StopManager,
-    context: &Context,
-    device: Arc<Device>,
-    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-    ip_route: ExternalRoute,
-    #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
-    client_cipher: Cipher,
-    server_cipher: Cipher,
-    up_counter: &mut SingleU64Adder,
+fn broadcast(
+    server_cipher: &Cipher,
+    sender: &ChannelContext,
+    net_packet: &mut NetPacket<&mut [u8]>,
+    current_device: &CurrentDeviceInfo,
+    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
 ) -> io::Result<()> {
-    let mut buf = [0; 1024 * 16];
-    loop {
-        if stop_manager.is_stop() {
-            return Ok(());
+    let list: Vec<Ipv4Addr> = device_list
+        .lock()
+        .1
+        .iter()
+        .filter(|info| info.status.is_online())
+        .map(|info| info.virtual_ip)
+        .collect();
+    const MAX_COUNT: usize = 8;
+    let mut p2p_ips = Vec::with_capacity(8);
+    let mut relay_ips = Vec::with_capacity(8);
+    let mut overflow = false;
+    for (index, peer_ip) in list.into_iter().enumerate() {
+        if index > MAX_COUNT {
+            overflow = true;
+            break;
        }
-        let len = device.read(&mut buf[12..])? + 12;
-        //单线程的
-        up_counter.add(len as u64);
-        #[cfg(any(target_os = "macos"))]
-        let mut buf = &mut buf[4..];
-        // buf是重复利用的，需要重置头部
-        buf[..12].fill(0);
-        match handle(
-            context,
-            &mut buf,
-            len,
-            &device,
-            current_device.load(),
-            &ip_route,
-            #[cfg(feature = "ip_proxy")]
-            &ip_proxy_map,
-            &client_cipher,
-            &server_cipher,
-        ) {
-            Ok(_) => {}
-            Err(e) => {
-                log::warn!("{:?}", e)
+        if let Some(route) = sender.route_table.route_one_p2p(&peer_ip) {
+            if sender
+                .send_by_key(net_packet.buffer(), route.route_key())
+                .is_ok()
+            {
+                p2p_ips.push(peer_ip);
+                continue;
            }
        }
+        relay_ips.push(peer_ip);
    }
+    if !overflow && relay_ips.is_empty() {
+        //全部p2p,不需要服务器中转
+        return Ok(());
+    }
+
+    if p2p_ips.is_empty() {
+        //都没有p2p则直接由服务器转发
+        if current_device.status.online() {
+            sender.send_default(net_packet.buffer(), current_device.connect_server)?;
+        }
+        return Ok(());
+    }
+    if !overflow && relay_ips.len() == 2 {
+        // 如果转发的ip数不多就直接发
+        for peer_ip in relay_ips {
+            //非直连的广播要改变目的地址，不然服务端收到了会再次广播
+            net_packet.set_destination(peer_ip);
+            sender.send_ipv4_by_id(
+                net_packet.buffer(),
+                &peer_ip,
+                current_device.connect_server,
+                current_device.status.online(),
+            )?;
+        }
+        return Ok(());
+    }
+    if current_device.status.offline() {
+        //离线的不再转发
+        return Ok(());
+    }
+    let buf = vec![0u8; 12 + 1 + p2p_ips.len() * 4 + net_packet.data_len() + ENCRYPTION_RESERVED];
+    //剩余的发送到服务端，需要告知哪些已发送过
+    let mut server_packet = NetPacket::new_encrypt(buf)?;
+    server_packet.set_default_version();
+    server_packet.set_gateway_flag(true);
+    server_packet.first_set_ttl(MAX_TTL);
+    server_packet.set_source(net_packet.source());
+    //使用对应的目的地址
+    server_packet.set_destination(net_packet.destination());
+    server_packet.set_protocol(protocol::Protocol::IpTurn);
+    server_packet.set_transport_protocol(ip_turn_packet::Protocol::Ipv4Broadcast.into());
+
+    let mut broadcast = BroadcastPacket::unchecked(server_packet.payload_mut());
+    broadcast.set_address(&p2p_ips)?;
+    broadcast.set_data(net_packet.buffer())?;
+    server_cipher.encrypt_ipv4(&mut server_packet)?;
+    sender.send_default(server_packet.buffer(), current_device.connect_server)
 }

-fn start_multi(
-    stop_manager: StopManager,
-    device: Arc<Device>,
-    mut group_sync_sender: GroupSyncSender<(Vec<u8>, usize)>,
-    up_counter: &mut SingleU64Adder,
-) -> io::Result<()> {
-    loop {
-        if stop_manager.is_stop() {
-            return Ok(());
+/// 实现一个原地发送，必须保证是如下结构
+/// |12字节开头|ip报文|至少1024字节结尾|
+///
+#[inline]
+fn base_handle(
+    context: &ChannelContext,
+    buf: &mut [u8],
+    data_len: usize, //数据总长度=12+ip包长度
+    extend: &mut [u8],
+    current_device: CurrentDeviceInfo,
+    ip_route: &ExternalRoute,
+    #[cfg(feature = "ip_proxy")] proxy_map: &Option<IpProxyMap>,
+    client_cipher: &Cipher,
+    server_cipher: &Cipher,
+    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
+    compressor: &Compressor,
+) -> anyhow::Result<()> {
+    let ipv4_packet = IpV4Packet::new(&buf[12..data_len])?;
+    let protocol = ipv4_packet.protocol();
+    let src_ip = ipv4_packet.source_ip();
+    let mut dest_ip = ipv4_packet.destination_ip();
+    let mut net_packet = NetPacket::new0(data_len, buf)?;
+    let mut out = NetPacket::unchecked(extend);
+    net_packet.set_default_version();
+    net_packet.set_protocol(protocol::Protocol::IpTurn);
+    net_packet.set_transport_protocol(ip_turn_packet::Protocol::Ipv4.into());
+    net_packet.first_set_ttl(6);
+    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_gateway_flag(true);
+            server_cipher.encrypt_ipv4(&mut net_packet)?;
+            context.send_default(net_packet.buffer(), current_device.connect_server)?;
        }
-        let mut buf = vec![0; 1024 * 16];
-        let len = device.read(&mut buf[12..])? + 12;
-        //单线程的
-        up_counter.add(len as u64);
-        if group_sync_sender.send((buf, len)).is_err() {
+        return Ok(());
+    }
+    let mut net_packet = if compressor.compress(&net_packet, &mut out)? {
+        out.set_default_version();
+        out.set_protocol(protocol::Protocol::IpTurn);
+        out.set_transport_protocol(ip_turn_packet::Protocol::Ipv4.into());
+        out.first_set_ttl(6);
+        out.set_source(src_ip);
+        out.set_destination(dest_ip);
+        out
+    } else {
+        net_packet
+    };
+    if dest_ip.is_multicast() {
+        //当作广播处理
+        dest_ip = Ipv4Addr::BROADCAST;
+        net_packet.set_destination(Ipv4Addr::BROADCAST);
+    }
+    if dest_ip.is_broadcast() || current_device.broadcast_ip == dest_ip {
+        // 广播 发送到直连目标
+        client_cipher.encrypt_ipv4(&mut net_packet)?;
+        broadcast(
+            server_cipher,
+            context,
+            &mut net_packet,
+            &current_device,
+            device_list,
+        )?;
+        return Ok(());
+    }
+    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(());
        }
    }
+    #[cfg(feature = "ip_proxy")]
+    if let Some(proxy_map) = proxy_map {
+        let mut ipv4_packet = IpV4Packet::new(net_packet.payload_mut())?;
+        proxy_map.send_handle(&mut ipv4_packet)?;
+    }
+    client_cipher.encrypt_ipv4(&mut net_packet)?;
+    context.send_ipv4_by_id(
+        net_packet.buffer(),
+        &dest_ip,
+        current_device.connect_server,
+        current_device.status.online(),
+    )?;
+    Ok(())
 }
@@ -0,0 +1,192 @@
+use crate::channel::context::ChannelContext;
+use crate::channel::BUFFER_SIZE;
+use crate::cipher::Cipher;
+use crate::compression::Compressor;
+use crate::external_route::ExternalRoute;
+use crate::handle::tun_tap::channel_group::GroupSyncSender;
+use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
+#[cfg(feature = "ip_proxy")]
+use crate::ip_proxy::IpProxyMap;
+use crate::util::{SingleU64Adder, StopManager};
+use crossbeam_utils::atomic::AtomicCell;
+use mio::event::Source;
+use mio::unix::SourceFd;
+use mio::{Events, Interest, Poll, Token, Waker};
+use parking_lot::Mutex;
+use std::io;
+use std::os::fd::AsRawFd;
+use std::sync::Arc;
+use tun::Device;
+
+const STOP: Token = Token(0);
+const FD: Token = Token(1);
+
+pub(crate) fn start_simple(
+    stop_manager: StopManager,
+    context: &ChannelContext,
+    device: Arc<Device>,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    ip_route: ExternalRoute,
+    #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
+    client_cipher: Cipher,
+    server_cipher: Cipher,
+    up_counter: &mut SingleU64Adder,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    compressor: Compressor,
+) -> io::Result<()> {
+    let poll = Poll::new()?;
+    let waker = Arc::new(Waker::new(poll.registry(), STOP)?);
+    let _waker = waker.clone();
+    let worker = stop_manager.add_listener("tun_device".into(), move || {
+        let _ = waker.wake();
+    })?;
+    if let Err(e) = start_simple0(
+        poll,
+        context,
+        device,
+        current_device,
+        ip_route,
+        #[cfg(feature = "ip_proxy")]
+        ip_proxy_map,
+        client_cipher,
+        server_cipher,
+        up_counter,
+        device_list,
+        compressor,
+    ) {
+        log::error!("{:?}", e);
+    };
+    worker.stop_all();
+    drop(_waker);
+    Ok(())
+}
+
+fn start_simple0(
+    mut poll: Poll,
+    context: &ChannelContext,
+    device: Arc<Device>,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    ip_route: ExternalRoute,
+    #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
+    client_cipher: Cipher,
+    server_cipher: Cipher,
+    up_counter: &mut SingleU64Adder,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    compressor: Compressor,
+) -> io::Result<()> {
+    let mut buf = [0; BUFFER_SIZE];
+    let mut extend = [0; BUFFER_SIZE];
+    let fd = device.as_tun_fd();
+    fd.set_nonblock()?;
+    SourceFd(&fd.as_raw_fd()).register(poll.registry(), FD, Interest::READABLE)?;
+    let mut evnets = Events::with_capacity(4);
+    #[cfg(not(target_os = "macos"))]
+    let start = 12;
+    #[cfg(target_os = "macos")]
+    let start = 12 - 4;
+    loop {
+        poll.poll(&mut evnets, None)?;
+        for event in evnets.iter() {
+            if event.token() == STOP {
+                return Ok(());
+            }
+            loop {
+                let len = match fd.read(&mut buf[start..]) {
+                    Ok(len) => len + start,
+                    Err(e) => {
+                        if e.kind() == io::ErrorKind::WouldBlock {
+                            break;
+                        }
+                        Err(e)?
+                    }
+                };
+                //单线程的
+                up_counter.add(len as u64);
+                // buf是重复利用的，需要重置头部
+                buf[..12].fill(0);
+                match crate::handle::tun_tap::tun_handler::handle(
+                    context,
+                    &mut buf,
+                    len,
+                    &mut extend,
+                    &device,
+                    current_device.load(),
+                    &ip_route,
+                    #[cfg(feature = "ip_proxy")]
+                    &ip_proxy_map,
+                    &client_cipher,
+                    &server_cipher,
+                    &device_list,
+                    &compressor,
+                ) {
+                    Ok(_) => {}
+                    Err(e) => {
+                        log::warn!("{:?}", e)
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn start_multi(
+    stop_manager: StopManager,
+    device: Arc<Device>,
+    group_sync_sender: GroupSyncSender<(Vec<u8>, usize)>,
+    up_counter: &mut SingleU64Adder,
+) -> io::Result<()> {
+    let poll = Poll::new()?;
+    let waker = Arc::new(Waker::new(poll.registry(), STOP)?);
+    let _waker = waker.clone();
+    let worker = stop_manager.add_listener("tun_device".into(), move || {
+        let _ = waker.wake();
+    })?;
+    if let Err(e) = start_multi0(poll, device, group_sync_sender, up_counter) {
+        log::error!("{:?}", e);
+    };
+    worker.stop_all();
+    drop(_waker);
+    Ok(())
+}
+
+fn start_multi0(
+    mut poll: Poll,
+    device: Arc<Device>,
+    mut group_sync_sender: GroupSyncSender<(Vec<u8>, usize)>,
+    up_counter: &mut SingleU64Adder,
+) -> io::Result<()> {
+    let fd = device.as_tun_fd();
+    fd.set_nonblock()?;
+    SourceFd(&fd.as_raw_fd()).register(poll.registry(), FD, Interest::READABLE)?;
+    let mut evnets = Events::with_capacity(4);
+    let mut buf = vec![0; 1024 * 16];
+    #[cfg(not(target_os = "macos"))]
+    let start = 12;
+    #[cfg(target_os = "macos")]
+    let start = 12 - 4;
+    loop {
+        poll.poll(&mut evnets, None)?;
+        for event in evnets.iter() {
+            if event.token() == STOP {
+                return Ok(());
+            }
+            loop {
+                let len = match fd.read(&mut buf[start..]) {
+                    Ok(len) => len + start,
+                    Err(e) => {
+                        if e.kind() == io::ErrorKind::WouldBlock {
+                            break;
+                        }
+                        Err(e)?
+                    }
+                };
+                //单线程的
+                up_counter.add(len as u64);
+                if group_sync_sender.send((buf, len)).is_err() {
+                    return Ok(());
+                }
+                buf = vec![0; 1024 * 16];
+            }
+        }
+    }
+}
@@ -0,0 +1,133 @@
+use crate::channel::context::ChannelContext;
+use crate::channel::BUFFER_SIZE;
+use crate::cipher::Cipher;
+use crate::compression::Compressor;
+use crate::external_route::ExternalRoute;
+use crate::handle::tun_tap::channel_group::GroupSyncSender;
+use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
+#[cfg(feature = "ip_proxy")]
+use crate::ip_proxy::IpProxyMap;
+use crate::util::{SingleU64Adder, StopManager};
+use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;
+use std::io;
+use std::sync::Arc;
+use tun::device::IFace;
+use tun::Device;
+
+pub(crate) fn start_simple(
+    stop_manager: StopManager,
+    context: &ChannelContext,
+    device: Arc<Device>,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    ip_route: ExternalRoute,
+    #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
+    client_cipher: Cipher,
+    server_cipher: Cipher,
+    up_counter: &mut SingleU64Adder,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    compressor: Compressor,
+) -> io::Result<()> {
+    let worker = {
+        let device = device.clone();
+        stop_manager.add_listener("tun_device".into(), move || {
+            if let Err(e) = device.shutdown() {
+                log::warn!("{:?}", e);
+            }
+        })?
+    };
+    if let Err(e) = start_simple0(
+        context,
+        device,
+        current_device,
+        ip_route,
+        #[cfg(feature = "ip_proxy")]
+        ip_proxy_map,
+        client_cipher,
+        server_cipher,
+        up_counter,
+        device_list,
+        compressor,
+    ) {
+        log::error!("{:?}", e);
+    }
+    worker.stop_all();
+    Ok(())
+}
+fn start_simple0(
+    context: &ChannelContext,
+    device: Arc<Device>,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    ip_route: ExternalRoute,
+    #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
+    client_cipher: Cipher,
+    server_cipher: Cipher,
+    up_counter: &mut SingleU64Adder,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    compressor: Compressor,
+) -> io::Result<()> {
+    let mut buf = [0; BUFFER_SIZE];
+    let mut extend = [0; BUFFER_SIZE];
+    loop {
+        let len = device.read(&mut buf[12..])? + 12;
+        //单线程的
+        up_counter.add(len as u64);
+        // buf是重复利用的，需要重置头部
+        buf[..12].fill(0);
+        match crate::handle::tun_tap::tun_handler::handle(
+            context,
+            &mut buf,
+            len,
+            &mut extend,
+            &device,
+            current_device.load(),
+            &ip_route,
+            #[cfg(feature = "ip_proxy")]
+            &ip_proxy_map,
+            &client_cipher,
+            &server_cipher,
+            &device_list,
+            &compressor,
+        ) {
+            Ok(_) => {}
+            Err(e) => {
+                log::warn!("tun/tap {:?}", e)
+            }
+        }
+    }
+}
+pub(crate) fn start_multi(
+    stop_manager: StopManager,
+    device: Arc<Device>,
+    group_sync_sender: GroupSyncSender<(Vec<u8>, usize)>,
+    up_counter: &mut SingleU64Adder,
+) -> io::Result<()> {
+    let worker = {
+        let device = device.clone();
+        stop_manager.add_listener("tun_device_multi".into(), move || {
+            if let Err(e) = device.shutdown() {
+                log::warn!("{:?}", e);
+            }
+        })?
+    };
+    if let Err(e) = start_multi0(device, group_sync_sender, up_counter) {
+        log::error!("{:?}", e);
+    };
+    worker.stop_all();
+    Ok(())
+}
+fn start_multi0(
+    device: Arc<Device>,
+    mut group_sync_sender: GroupSyncSender<(Vec<u8>, usize)>,
+    up_counter: &mut SingleU64Adder,
+) -> io::Result<()> {
+    loop {
+        let mut buf = vec![0; 1024 * 16];
+        let len = device.read(&mut buf[12..])? + 12;
+        //单线程的
+        up_counter.add(len as u64);
+        if group_sync_sender.send((buf, len)).is_err() {
+            return Ok(());
+        }
+    }
+}
@@ -1,24 +1,23 @@
+use anyhow::Context;
 use std::collections::HashMap;
+use std::io;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::sync::Arc;
-use std::{io, thread};

 use crossbeam_utils::atomic::AtomicCell;
-use mio::net::UdpSocket;
-use mio::{Events, Interest, Poll, Token, Waker};
 use parking_lot::Mutex;
+use tokio::net::UdpSocket;

 use packet::icmp::icmp;
 use packet::icmp::icmp::HeaderOther;
 use packet::ip::ipv4::packet::IpV4Packet;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::cipher::Cipher;
 use crate::handle::CurrentDeviceInfo;
 use crate::ip_proxy::ProxyHandler;
 use crate::protocol;
-use crate::protocol::{NetPacket, Version, MAX_TTL};
-use crate::util::StopManager;
+use crate::protocol::{NetPacket, MAX_TTL};
 #[derive(Clone)]
 pub struct IcmpProxy {
    icmp_socket: Arc<std::net::UdpSocket>,
@@ -27,41 +26,50 @@ pub struct IcmpProxy {
 }

 impl IcmpProxy {
-    pub fn new(
-        context: Context,
-        stop_manager: StopManager,
+    pub async fn new(
+        context: ChannelContext,
        current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
        client_cipher: Cipher,
-    ) -> io::Result<Self> {
+    ) -> anyhow::Result<Self> {
+        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
        let icmp_socket = socket2::Socket::new(
            socket2::Domain::IPV4,
            socket2::Type::RAW,
            Some(socket2::Protocol::ICMPV4),
-        )?;
+        )
+        .context("new Socket RAW ICMPV4 failed")?;
+        #[cfg(target_os = "android")]
+        let icmp_socket = socket2::Socket::new(
+            socket2::Domain::IPV4,
+            socket2::Type::DGRAM,
+            Some(socket2::Protocol::ICMPV4),
+        )
+        .context("new Socket DGRAM ICMPV4 failed")?;
        let addr: SocketAddrV4 = SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0);
-        icmp_socket.bind(&socket2::SockAddr::from(addr))?;
+        icmp_socket
+            .bind(&socket2::SockAddr::from(addr))
+            .context("bind Socket ICMPV4 failed")?;
        icmp_socket.set_nonblocking(true)?;
        let std_socket: std::net::UdpSocket = icmp_socket.into();
-        let mio_icmp_socket = UdpSocket::from_std(std_socket.try_clone()?);
+
+        let tokio_icmp_socket = UdpSocket::from_std(std_socket.try_clone()?)?;
        let nat_map: Arc<Mutex<HashMap<(Ipv4Addr, u16, u16), Ipv4Addr>>> =
            Arc::new(Mutex::new(HashMap::with_capacity(16)));
        {
            let nat_map = nat_map.clone();
-            thread::Builder::new()
-                .name("icmpProxy".into())
-                .spawn(move || {
-                    if let Err(e) = icmp_proxy(
-                        mio_icmp_socket,
-                        nat_map,
-                        context,
-                        stop_manager,
-                        current_device,
-                        client_cipher,
-                    ) {
-                        log::warn!("icmp_proxy:{:?}", e);
-                    }
-                })
-                .expect("icmpProxy");
+            tokio::spawn(async {
+                if let Err(e) = icmp_proxy(
+                    tokio_icmp_socket,
+                    nat_map,
+                    context,
+                    current_device,
+                    client_cipher,
+                )
+                .await
+                {
+                    log::warn!("icmp_proxy:{:?}", e);
+                }
+            });
        }
        Ok(Self {
            icmp_socket: Arc::new(std_socket),
@@ -70,78 +78,39 @@ impl IcmpProxy {
    }
 }

-const SERVER_VAL: usize = 0;
-const SERVER: Token = Token(SERVER_VAL);
-const NOTIFY_VAL: usize = 1;
-const NOTIFY: Token = Token(NOTIFY_VAL);
-
-fn icmp_proxy(
-    mut icmp_socket: UdpSocket,
+async fn icmp_proxy(
+    icmp_socket: UdpSocket,
    // 对端-> 真实来源
    nat_map: Arc<Mutex<HashMap<(Ipv4Addr, u16, u16), Ipv4Addr>>>,
-    context: Context,
-    stop_manager: StopManager,
+    context: ChannelContext,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    client_cipher: Cipher,
 ) -> io::Result<()> {
-    let mut poll = Poll::new()?;
-    poll.registry()
-        .register(&mut icmp_socket, SERVER, Interest::READABLE)?;
-    let mut events = Events::with_capacity(32);
-    let stop = Arc::new(Waker::new(poll.registry(), NOTIFY)?);
-    let _stop = stop.clone();
-    let _worker = stop_manager.add_listener("icmp_proxy".into(), move || {
-        if let Err(e) = stop.wake() {
-            log::warn!("stop icmp_proxy:{:?}", e);
-        }
-    })?;
    let mut buf = [0u8; 65535 - 20 - 8];
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+    let start = 12;
+    #[cfg(target_os = "android")]
+    let start = 12 + 20;
    loop {
-        poll.poll(&mut events, None)?;
-        if stop_manager.is_stop() {
-            return Ok(());
-        }
-        for event in events.iter() {
-            match event.token() {
-                SERVER => readable_handle(
-                    &icmp_socket,
-                    &mut buf,
-                    &nat_map,
-                    &context,
-                    &current_device,
-                    &client_cipher,
-                ),
-                NOTIFY => {
-                    return Ok(());
-                }
-                _ => {}
-            }
-        }
-    }
-}
-fn readable_handle(
-    icmp_socket: &UdpSocket,
-    buf: &mut [u8],
-    nat_map: &Mutex<HashMap<(Ipv4Addr, u16, u16), Ipv4Addr>>,
-    context: &Context,
-    current_device: &AtomicCell<CurrentDeviceInfo>,
-    client_cipher: &Cipher,
-) {
-    loop {
-        let (len, addr) = match icmp_socket.recv_from(&mut buf[12..]) {
-            Ok(rs) => rs,
-            Err(e) => {
-                if e.kind() == io::ErrorKind::WouldBlock {
-                    break;
-                }
-                log::warn!("icmp_socket {:?}", e);
-                return;
-            }
-        };
+        let (len, addr) = icmp_socket.recv_from(&mut buf[start..]).await?;
        if let IpAddr::V4(peer_ip) = addr.ip() {
+            #[cfg(target_os = "android")]
+            {
+                let buf = &mut buf[12..];
+                // ipv4 头部20字节
+                buf[0] = 0b0100_0110;
+                //写入总长度
+                buf[2..4].copy_from_slice(&((20 + len) as u16).to_be_bytes());
+
+                let mut ipv4 = IpV4Packet::unchecked(buf);
+                ipv4.set_flags(2);
+                ipv4.set_ttl(1);
+                ipv4.set_protocol(packet::ip::ipv4::protocol::Protocol::Icmp);
+                ipv4.set_source_ip(peer_ip);
+            }
            recv_handle(
-                buf,
-                12 + len,
+                &mut buf,
+                start + len,
                peer_ip,
                &nat_map,
                &context,
@@ -151,12 +120,13 @@ fn readable_handle(
        }
    }
 }
+
 fn recv_handle(
    buf: &mut [u8],
    data_len: usize,
    peer_ip: Ipv4Addr,
    nat_map: &Mutex<HashMap<(Ipv4Addr, u16, u16), Ipv4Addr>>,
-    context: &Context,
+    context: &ChannelContext,
    current_device: &AtomicCell<CurrentDeviceInfo>,
    client_cipher: &Cipher,
 ) {
@@ -172,7 +142,7 @@ fn recv_handle(
                        let virtual_ip = current_device.virtual_ip();

                        let mut net_packet = NetPacket::new0(data_len, buf).unwrap();
-                        net_packet.set_version(Version::V1);
+                        net_packet.set_default_version();
                        net_packet.set_protocol(protocol::Protocol::IpTurn);
                        net_packet.set_transport_protocol(
                            protocol::ip_turn_packet::Protocol::Ipv4.into(),
@@ -194,11 +164,17 @@ fn recv_handle(
                        }
                    }
                }
-                _ => {}
+                h => {
+                    log::debug!("不支持的icmp代理 {:?},{:?}", peer_ip, h)
+                }
            },
-            Err(_) => {}
+            Err(e) => {
+                log::warn!("icmp {:?}", e)
+            }
        },
-        Err(_) => {}
+        Err(e) => {
+            log::warn!("icmp {:?}", e)
+        }
    }
 }

@@ -225,12 +201,13 @@ impl ProxyHandler for IcmpProxy {
                    SocketAddr::from(SocketAddrV4::new(dest_ip, 0)),
                )?;
            }
-            _ => {
+            header_other => {
                log::warn!(
-                    "不支持的ip代理Icmp协议:{}->{}->{}",
+                    "不支持的ip代理Icmp协议:{}->{}->{},{:?}",
                    source,
                    destination,
-                    dest_ip
+                    dest_ip,
+                    header_other
                );
            }
        }
@@ -1,20 +1,22 @@
-use std::io;
 use std::net::Ipv4Addr;
 use std::sync::Arc;
+use std::{io, thread};

 use crossbeam_utils::atomic::AtomicCell;

 use packet::ip::ipv4;
 use packet::ip::ipv4::packet::IpV4Packet;

-use crate::channel::context::Context;
+use crate::channel::context::ChannelContext;
 use crate::cipher::Cipher;
 use crate::handle::CurrentDeviceInfo;
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
 use crate::ip_proxy::icmp_proxy::IcmpProxy;
 use crate::ip_proxy::tcp_proxy::TcpProxy;
 use crate::ip_proxy::udp_proxy::UdpProxy;
-use crate::util::{Scheduler, StopManager};
+use crate::util::StopManager;

+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
 pub mod icmp_proxy;
 pub mod tcp_proxy;
 pub mod udp_proxy;
@@ -31,23 +33,52 @@ pub trait ProxyHandler {

 #[derive(Clone)]
 pub struct IpProxyMap {
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
    icmp_proxy: IcmpProxy,
    tcp_proxy: TcpProxy,
    udp_proxy: UdpProxy,
 }

 pub fn init_proxy(
-    context: Context,
-    scheduler: Scheduler,
+    context: ChannelContext,
    stop_manager: StopManager,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    client_cipher: Cipher,
-) -> io::Result<IpProxyMap> {
-    let icmp_proxy = IcmpProxy::new(context, stop_manager.clone(), current_device, client_cipher)?;
-    let tcp_proxy = TcpProxy::new(stop_manager.clone())?;
-    let udp_proxy = UdpProxy::new(scheduler, stop_manager)?;
+) -> anyhow::Result<IpProxyMap> {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .thread_name("ipProxy")
+        .build()?;
+    let proxy_map = runtime.block_on(init_proxy0(context, current_device, client_cipher))?;
+    let (sender, receiver) = tokio::sync::oneshot::channel::<()>();
+    let worker = stop_manager.add_listener("ipProxy".into(), move || {
+        let _ = sender.send(());
+    })?;
+    thread::Builder::new()
+        .name("ipProxy".into())
+        .spawn(move || {
+            runtime.block_on(async {
+                let _ = receiver.await;
+            });
+            runtime.shutdown_background();
+            drop(worker);
+        })?;
+
+    return Ok(proxy_map);
+}
+
+async fn init_proxy0(
+    _context: ChannelContext,
+    _current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    _client_cipher: Cipher,
+) -> anyhow::Result<IpProxyMap> {
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+    let icmp_proxy = IcmpProxy::new(_context, _current_device, _client_cipher).await?;
+    let tcp_proxy = TcpProxy::new().await?;
+    let udp_proxy = UdpProxy::new().await?;

    Ok(IpProxyMap {
+        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
        icmp_proxy,
        tcp_proxy,
        udp_proxy,
@@ -64,6 +95,7 @@ impl ProxyHandler for IpProxyMap {
        match ipv4.protocol() {
            ipv4::protocol::Protocol::Tcp => self.tcp_proxy.recv_handle(ipv4, source, destination),
            ipv4::protocol::Protocol::Udp => self.udp_proxy.recv_handle(ipv4, source, destination),
+            #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
            ipv4::protocol::Protocol::Icmp => {
                self.icmp_proxy.recv_handle(ipv4, source, destination)
            }
@@ -84,6 +116,7 @@ impl ProxyHandler for IpProxyMap {
        match ipv4.protocol() {
            ipv4::protocol::Protocol::Tcp => self.tcp_proxy.send_handle(ipv4),
            ipv4::protocol::Protocol::Udp => self.udp_proxy.send_handle(ipv4),
+            #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
            ipv4::protocol::Protocol::Icmp => self.icmp_proxy.send_handle(ipv4),
            _ => Ok(()),
        }
@@ -1,28 +1,16 @@
-use std::io::{Read, Write};
-use std::net::{Ipv4Addr, Shutdown, SocketAddrV4};
-#[cfg(unix)]
-use std::os::fd::AsRawFd;
-#[cfg(windows)]
-use std::os::windows::io::AsRawSocket;
+use anyhow::Context;
+use std::net::{Ipv4Addr, SocketAddrV4};
 use std::sync::Arc;
 use std::time::Duration;
-use std::{collections::HashMap, io, net::SocketAddr, thread};
+use std::{collections::HashMap, io, net::SocketAddr};

-use bytes::{BufMut, BytesMut};
-use mio::net::TcpStream;
-use mio::{net::TcpListener, Events, Interest, Poll, Registry, Token, Waker};
 use parking_lot::Mutex;
+use tokio::net::{TcpListener, TcpSocket, TcpStream};

 use packet::ip::ipv4::packet::IpV4Packet;
 use packet::tcp::tcp::TcpPacket;

 use crate::ip_proxy::ProxyHandler;
-use crate::util::StopManager;
-
-const SERVER_VAL: usize = 0;
-const SERVER: Token = Token(SERVER_VAL);
-const NOTIFY_VAL: usize = 1;
-const NOTIFY: Token = Token(NOTIFY_VAL);

 #[derive(Clone)]
 pub struct TcpProxy {
@@ -31,21 +19,16 @@ pub struct TcpProxy {
 }

 impl TcpProxy {
-    pub fn new(stop_manager: StopManager) -> io::Result<Self> {
+    pub async fn new() -> anyhow::Result<Self> {
        let nat_map: Arc<Mutex<HashMap<SocketAddrV4, SocketAddrV4>>> =
            Arc::new(Mutex::new(HashMap::with_capacity(16)));
-        let tcp_listener = TcpListener::bind(format!("0.0.0.0:{}", 0).parse().unwrap())?;
+        let tcp_listener = TcpListener::bind(format!("0.0.0.0:{}", 0))
+            .await
+            .context("TcpProxy bind failed")?;
        let port = tcp_listener.local_addr()?.port();
        {
            let nat_map = nat_map.clone();
-            thread::Builder::new()
-                .name("tcpProxy".into())
-                .spawn(move || {
-                    if let Err(e) = tcp_proxy(tcp_listener, nat_map, stop_manager) {
-                        log::warn!("tcp_proxy:{:?}", e);
-                    }
-                })
-                .expect("tcpProxy");
+            tokio::spawn(tcp_proxy(tcp_listener, nat_map));
        }
        Ok(Self { port, nat_map })
    }
@@ -93,365 +76,74 @@ impl ProxyHandler for TcpProxy {
    }
 }

-fn tcp_proxy(
-    mut tcp_listener: TcpListener,
+async fn tcp_proxy(
+    tcp_listener: TcpListener,
    nat_map: Arc<Mutex<HashMap<SocketAddrV4, SocketAddrV4>>>,
-    stop_manager: StopManager,
-) -> io::Result<()> {
-    let mut poll = Poll::new()?;
-    poll.registry()
-        .register(&mut tcp_listener, SERVER, Interest::READABLE)?;
-    let mut events = Events::with_capacity(32);
-    let mut tcp_map: HashMap<usize, ProxyValue> = HashMap::with_capacity(16);
-    let mut mapping: HashMap<usize, usize> = HashMap::with_capacity(16);
-    let stop = Arc::new(Waker::new(poll.registry(), NOTIFY)?);
-    let _stop = stop.clone();
-    let _worker = stop_manager.add_listener("tcp_proxy".into(), move || {
-        if let Err(e) = stop.wake() {
-            log::warn!("stop tcp_proxy:{:?}", e);
-        }
-    })?;
-    loop {
-        poll.poll(&mut events, None)?;
-        if stop_manager.is_stop() {
-            return Ok(());
-        }
-        for event in events.iter() {
-            match event.token() {
-                SERVER => {
-                    accept_handle(
-                        poll.registry(),
-                        &tcp_listener,
-                        &nat_map,
-                        &mut tcp_map,
-                        &mut mapping,
-                    );
-                }
-                NOTIFY => {
-                    return Ok(());
-                }
-                Token(index) => {
-                    let (val, src_index) = if let Some(v) = tcp_map.get_mut(&index) {
-                        (v, index)
-                    } else {
-                        if let Some(dest_index) = mapping.get(&index) {
-                            if let Some(v) = tcp_map.get_mut(dest_index) {
-                                (v, *dest_index)
-                            } else {
-                                continue;
-                            }
-                        } else {
-                            continue;
-                        }
-                    };
-                    let (stream1, stream2, buf1, buf2, state1, state2) = val.as_mut(index);
-                    if event.is_readable() {
-                        if let Err(_) = readable_handle(stream1, stream2, buf1, state2) {
-                            *state1 |= READ_CLOSED;
-                        }
-                    }
-                    if event.is_writable() {
-                        let read = buf2.len() >= BUF_LEN;
-                        if let Err(_) = writable_handle(stream1, buf2) {
-                            *state1 |= WRITE_CLOSED;
-                        } else if read {
-                            if readable_handle(stream2, stream1, buf2, state1).is_err() {
-                                *state2 |= READ_CLOSED;
-                            }
-                        }
-                    }
-                    if event.is_read_closed() || event.is_error() {
-                        *state1 |= READ_CLOSED;
-                    }
-                    if event.is_write_closed() || event.is_error() {
-                        *state1 |= WRITE_CLOSED;
-                    }
-                    if is_write_closed(*state1) {
-                        let _ = stream1.shutdown(Shutdown::Write);
-                        let _ = stream2.shutdown(Shutdown::Read);
-                    }
-                    if is_read_closed(*state1) {
-                        let _ = stream1.shutdown(Shutdown::Read);
-                        if buf1.is_empty() {
-                            let _ = stream2.shutdown(Shutdown::Write);
-                        }
-                    }
-                    if (is_both_closed(*state1) && buf1.is_empty())
-                        || (is_both_closed(*state2) && buf2.is_empty())
-                        || (is_write_closed(*state1) && is_write_closed(*state2)
-                            || (is_read_closed(*state1)
-                                && is_read_closed(*state2)
-                                && buf1.is_empty()
-                                && buf2.is_empty()))
-                    {
-                        close(src_index, &mut tcp_map, &mut mapping);
-                    }
-                }
-            }
-        }
-    }
-}
-
-fn accept_handle(
-    registry: &Registry,
-    tcp_listener: &TcpListener,
-    nat_map: &Mutex<HashMap<SocketAddrV4, SocketAddrV4>>,
-    tcp_map: &mut HashMap<usize, ProxyValue>,
-    mapping: &mut HashMap<usize, usize>,
 ) {
    loop {
-        match tcp_listener.accept() {
-            Ok((mut src_stream, addr)) => {
-                #[cfg(windows)]
-                let src_fd = src_stream.as_raw_socket() as usize;
-                #[cfg(unix)]
-                let src_fd = src_stream.as_raw_fd() as usize;
-                if src_fd == SERVER_VAL || src_fd == NOTIFY_VAL {
-                    log::error!("fd错误:{:?}", src_fd);
-                    continue;
-                }
-                let addr = match addr {
-                    SocketAddr::V4(addr) => addr,
-                    SocketAddr::V6(_) => {
-                        // 忽略ipv6
-                        continue;
-                    }
-                };
-                let _ = src_stream.set_nodelay(false);
-                if let Some(dest_addr) = nat_map.lock().get(&addr).cloned() {
-                    match tcp_connect(addr.port(), dest_addr.into()) {
-                        Ok(mut dest_stream) => {
-                            #[cfg(windows)]
-                            let dest_fd = dest_stream.as_raw_socket() as usize;
-                            #[cfg(unix)]
-                            let dest_fd = dest_stream.as_raw_fd() as usize;
-                            if dest_fd == SERVER_VAL || dest_fd == NOTIFY_VAL {
-                                log::error!("fd错误:{:?}", dest_fd);
-                                continue;
-                            }
-                            if let Err(e) = registry.register(
-                                &mut src_stream,
-                                Token(src_fd),
-                                Interest::READABLE.add(Interest::WRITABLE),
-                            ) {
-                                log::error!("register src_stream:{:?}", e);
-                                continue;
-                            }
-                            if let Err(e) = registry.register(
-                                &mut dest_stream,
-                                Token(dest_fd),
-                                Interest::READABLE.add(Interest::WRITABLE),
-                            ) {
-                                log::error!("register dest_stream:{:?}", e);
-                                continue;
-                            }
-                            tcp_map.insert(
-                                src_fd,
-                                ProxyValue::new(src_stream, dest_stream, src_fd, dest_fd),
-                            );
-                            mapping.insert(dest_fd, src_fd);
-                        }
-                        Err(e) => {
-                            log::error!("connect:{:?} {}->{}", e, addr, dest_addr);
-                        }
+        match tcp_listener.accept().await {
+            Ok((tcp_stream, sender_addr)) => match sender_addr {
+                SocketAddr::V4(sender_addr) => {
+                    if let Some(dest_addr) = nat_map.lock().get(&sender_addr).cloned() {
+                        tokio::spawn(async move {
+                            let peer_tcp_stream =
+                                match tcp_connect(sender_addr.port(), dest_addr.into()).await {
+                                    Ok(peer_tcp_stream) => peer_tcp_stream,
+                                    Err(e) => {
+                                        log::warn!(
+                                            "tcp代理异常:{:?},来源:{},目标：{}",
+                                            e,
+                                            sender_addr,
+                                            dest_addr
+                                        );
+                                        return;
+                                    }
+                                };
+                            proxy(sender_addr, dest_addr, tcp_stream, peer_tcp_stream).await
+                        });
+                    } else {
+                        log::warn!("tcp代理异常: 来源:{},未找到目标", sender_addr);
                    }
                }
-            }
+                SocketAddr::V6(_) => {}
+            },
            Err(e) => {
-                if e.kind() == io::ErrorKind::WouldBlock {
-                    break;
-                }
-                log::error!("accept:{:?}", e);
+                log::warn!("tcp代理监听:{:?}", e);
            }
        }
    }
 }
-
-fn tcp_connect(src_port: u16, addr: SocketAddr) -> io::Result<TcpStream> {
-    let socket = socket2::Socket::new(
-        socket2::Domain::IPV4,
-        socket2::Type::STREAM,
-        Some(socket2::Protocol::TCP),
-    )?;
+/// 优先使用来源端口建立tcp连接
+async fn tcp_connect(src_port: u16, addr: SocketAddr) -> anyhow::Result<TcpStream> {
+    let socket = TcpSocket::new_v4()?;
    if socket
-        .bind(&SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, src_port).into())
+        .bind(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, src_port).into())
        .is_err()
    {
-        socket.bind(&SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0).into())?;
-    }
-    if let Err(e) = socket.set_tcp_keepalive(
-        &socket2::TcpKeepalive::new()
-            .with_time(Duration::from_secs(120))
-            .with_interval(Duration::from_secs(10)),
-    ) {
-        log::warn!("set_tcp_keepalive err {:?}", e);
+        socket.bind(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0).into())?;
    }
    let _ = socket.set_nodelay(false);
-    socket.connect_timeout(&addr.into(), Duration::from_secs(3))?;
-    socket.set_nonblocking(true)?;
-    Ok(TcpStream::from_std(socket.into()))
+    let tcp_stream = tokio::time::timeout(Duration::from_secs(5), socket.connect(addr))
+        .await
+        .with_context(|| format!("TCP connection timeout {}", addr))?
+        .with_context(|| format!("TCP connection target failed {}", addr))?;
+    Ok(tcp_stream)
 }

-#[derive(Debug)]
-struct ProxyValue {
-    src_stream: TcpStream,
-    dest_stream: TcpStream,
-    src_fd: usize,
-    dest_fd: usize,
-    src_buf: BytesMut,
-    dest_buf: BytesMut,
-    src_state: u8,
-    dest_state: u8,
-}
-
-const BUF_LEN: usize = 65536;
-
-impl ProxyValue {
-    fn new(src_stream: TcpStream, dest_stream: TcpStream, src_fd: usize, dest_fd: usize) -> Self {
-        Self {
-            src_stream,
-            dest_stream,
-            src_fd,
-            dest_fd,
-            src_buf: BytesMut::with_capacity(BUF_LEN),
-            dest_buf: BytesMut::with_capacity(BUF_LEN),
-            src_state: NORMAL,
-            dest_state: NORMAL,
-        }
-    }
-    fn as_mut(
-        &mut self,
-        index: usize,
-    ) -> (
-        &mut TcpStream,
-        &mut TcpStream,
-        &mut BytesMut,
-        &mut BytesMut,
-        &mut u8,
-        &mut u8,
-    ) {
-        if index == self.src_fd {
-            (
-                &mut self.src_stream,
-                &mut self.dest_stream,
-                &mut self.src_buf,
-                &mut self.dest_buf,
-                &mut self.src_state,
-                &mut self.dest_state,
-            )
-        } else {
-            (
-                &mut self.dest_stream,
-                &mut self.src_stream,
-                &mut self.dest_buf,
-                &mut self.src_buf,
-                &mut self.dest_state,
-                &mut self.src_state,
-            )
-        }
-    }
-}
-
-fn readable_handle(
-    stream1: &mut TcpStream,
-    stream2: &mut TcpStream,
-    mid_buf: &mut BytesMut,
-    state2: &mut u8,
-) -> io::Result<()> {
-    let mut buf = [0; BUF_LEN];
-
-    loop {
-        if mid_buf.len() >= BUF_LEN {
-            // 达到上限不再继续读取
-            return Ok(());
-        }
-        match stream1.read(&mut buf) {
-            Ok(len) => {
-                if len == 0 {
-                    return Err(io::Error::from(io::ErrorKind::UnexpectedEof));
-                }
-                let mut buf = &buf[..len];
-                if mid_buf.is_empty() {
-                    // 直接写入，避免在buf中过渡
-                    while !buf.is_empty() {
-                        match stream2.write(buf) {
-                            Ok(end) => {
-                                if end == 0 {
-                                    *state2 |= WRITE_CLOSED;
-                                    return Err(io::Error::from(io::ErrorKind::WriteZero));
-                                }
-                                buf = &buf[end..];
-                            }
-                            Err(e) => {
-                                if e.kind() != io::ErrorKind::WouldBlock {
-                                    *state2 |= WRITE_CLOSED;
-                                    return Err(e);
-                                }
-                                break;
-                            }
-                        }
-                    }
-                    if buf.is_empty() {
-                        continue;
-                    }
-                }
-                mid_buf.reserve(buf.len());
-                mid_buf.put_slice(buf);
-            }
-            Err(e) => {
-                if e.kind() == io::ErrorKind::WouldBlock {
-                    break;
-                }
-                return Err(e);
-            }
-        }
-    }
-    Ok(())
-}
-
-fn writable_handle(stream: &mut TcpStream, mid_buf: &mut BytesMut) -> io::Result<()> {
-    while !mid_buf.is_empty() {
-        match stream.write(&mid_buf) {
-            Ok(len) => {
-                let _ = mid_buf.split_to(len);
-            }
-            Err(e) => {
-                if e.kind() == io::ErrorKind::WouldBlock {
-                    break;
-                }
-                return Err(e);
-            }
-        }
-    }
-    Ok(())
-}
-
-fn close(
-    index: usize,
-    tcp_map: &mut HashMap<usize, ProxyValue>,
-    mapping: &mut HashMap<usize, usize>,
+async fn proxy(
+    sender_addr: SocketAddrV4,
+    dest_addr: SocketAddrV4,
+    client: TcpStream,
+    server: TcpStream,
 ) {
-    if let Some(val) = tcp_map.remove(&index) {
-        let _ = val.src_stream.shutdown(Shutdown::Both);
-        let _ = val.dest_stream.shutdown(Shutdown::Both);
-        mapping.remove(&val.src_fd);
-        mapping.remove(&val.dest_fd);
+    let (mut client_read, mut client_write) = client.into_split();
+    let (mut server_read, mut server_write) = server.into_split();
+    tokio::spawn(async move {
+        if let Err(e) = tokio::io::copy(&mut client_read, &mut server_write).await {
+            log::warn!("client tcp proxy {}->{},{:?}", sender_addr, dest_addr, e);
+        }
+    });
+    if let Err(e) = tokio::io::copy(&mut server_read, &mut client_write).await {
+        log::warn!("server tcp proxy {}->{},{:?}", sender_addr, dest_addr, e);
    }
 }
-
-const NORMAL: u8 = 0b00;
-const READ_CLOSED: u8 = 0b01;
-const WRITE_CLOSED: u8 = 0b10;
-const BOTH_CLOSED: u8 = 0b11;
-
-fn is_read_closed(state: u8) -> bool {
-    (state & READ_CLOSED == READ_CLOSED) || is_both_closed(state)
-}
-
-fn is_write_closed(state: u8) -> bool {
-    (state & WRITE_CLOSED == WRITE_CLOSED) || is_both_closed(state)
-}
-
-fn is_both_closed(state: u8) -> bool {
-    state & BOTH_CLOSED == BOTH_CLOSED
-}
@@ -1,30 +1,17 @@
+use anyhow::Context;
+use crossbeam_utils::atomic::AtomicCell;
 use std::net::{Ipv4Addr, SocketAddrV4};
-#[cfg(unix)]
-use std::os::fd::AsRawFd;
-#[cfg(windows)]
-use std::os::windows::io::AsRawSocket;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
-use std::{collections::HashMap, io, net::SocketAddr, rc::Rc, thread};
+use std::{collections::HashMap, io, net::SocketAddr};

-use mio::{net::UdpSocket, Events, Interest, Poll, Token};
-use mio::{Registry, Waker};
 use parking_lot::Mutex;
+use tokio::net::UdpSocket;

 use packet::ip::ipv4::packet::IpV4Packet;
 use packet::udp::udp::UdpPacket;

 use crate::ip_proxy::ProxyHandler;
-use crate::util::{Scheduler, StopManager};
-
-const SERVER_VAL: usize = 0;
-const SERVER: Token = Token(SERVER_VAL);
-const NOTIFY_VAL: usize = 1;
-const NOTIFY: Token = Token(NOTIFY_VAL);
-// 开了ip代理后使用mstsc，mstsc会误以为在真实局域网，从而不维护udp心跳，导致断连，所以这里尽量长一点过期时间
-const NAT_TIMEOUT: Duration = Duration::from_secs(20 * 60);
-const NAT_FAST_TIMEOUT: Duration = Duration::from_secs(5 * 60);
-const NAT_MAX: usize = 5_000;

 #[derive(Clone)]
 pub struct UdpProxy {
@@ -33,21 +20,20 @@ pub struct UdpProxy {
 }

 impl UdpProxy {
-    pub fn new(scheduler: Scheduler, stop_manager: StopManager) -> io::Result<Self> {
+    pub async fn new() -> anyhow::Result<Self> {
        let nat_map: Arc<Mutex<HashMap<SocketAddrV4, SocketAddrV4>>> =
            Arc::new(Mutex::new(HashMap::with_capacity(16)));
-        let udp = UdpSocket::bind(format!("0.0.0.0:{}", 0).parse().unwrap())?;
+        let udp = UdpSocket::bind(format!("0.0.0.0:{}", 0))
+            .await
+            .context("UdpProxy bind failed")?;
        let port = udp.local_addr()?.port();
        {
            let nat_map = nat_map.clone();
-            thread::Builder::new()
-                .name("udpProxy".into())
-                .spawn(move || {
-                    if let Err(e) = udp_proxy(udp, nat_map, scheduler, stop_manager) {
-                        log::warn!("udp_proxy:{:?}", e);
-                    }
-                })
-                .expect("udpProxy");
+            tokio::spawn(async {
+                if let Err(e) = udp_proxy(udp, nat_map).await {
+                    log::warn!("udp_proxy:{:?}", e);
+                }
+            });
        }
        Ok(Self { port, nat_map })
    }
@@ -95,218 +81,101 @@ impl ProxyHandler for UdpProxy {
    }
 }

-fn udp_proxy(
-    mut udp: UdpSocket,
+async fn udp_proxy(
+    udp: UdpSocket,
    nat_map: Arc<Mutex<HashMap<SocketAddrV4, SocketAddrV4>>>,
-    scheduler: Scheduler,
-    stop_manager: StopManager,
 ) -> io::Result<()> {
-    let mut poll = Poll::new()?;
+    let mut buf = [0u8; 65536];

-    poll.registry()
-        .register(&mut udp, SERVER, Interest::READABLE)?;
-    let mut events = Events::with_capacity(32);
-    let mut buf = [0; 65536];
-    let mut token_map: HashMap<Token, (Rc<UdpSocket>, SocketAddrV4, Instant)> =
-        HashMap::with_capacity(64);
-    let mut udp_map: HashMap<SocketAddrV4, (Rc<UdpSocket>, Instant)> = HashMap::with_capacity(64);
-    let mut timeout = false;
-    let waker = Arc::new(Waker::new(poll.registry(), NOTIFY)?);
-    let stop = waker.clone();
-    let _worker = stop_manager.add_listener("udp_proxy".into(), move || {
-        if let Err(e) = stop.wake() {
-            log::warn!("stop udp_proxy:{:?}", e);
-        }
-    })?;
+    let inner_map: Arc<Mutex<HashMap<SocketAddrV4, (Arc<UdpSocket>, Arc<AtomicCell<Instant>>)>>> =
+        Arc::new(Mutex::new(HashMap::with_capacity(64)));
+    let udp_socket = Arc::new(udp);
    loop {
-        let mut check = false;
-        if token_map.is_empty() {
-            poll.poll(&mut events, None)?;
-        } else {
-            //所有事件 50分钟超时
-            if let Err(e) = poll.poll(&mut events, Some(Duration::from_secs(50 * 60))) {
-                if e.kind() == io::ErrorKind::TimedOut || e.kind() == io::ErrorKind::WouldBlock {
-                    token_map.clear();
-                    udp_map.clear();
-                    continue;
+        match udp_socket.recv_from(&mut buf).await {
+            Ok((len, sender_addr)) => match sender_addr {
+                SocketAddr::V4(sender_addr) => {
+                    if let Err(e) =
+                        udp_proxy0(&buf[..len], sender_addr, &inner_map, &nat_map, &udp_socket)
+                            .await
+                    {
+                        log::warn!("udp proxy {} {:?}", sender_addr, e);
+                    }
                }
-                return Err(e);
+                SocketAddr::V6(_) => {}
+            },
+            Err(e) => {
+                log::warn!("udp代理异常:{:?}", e);
            }
-        }
-        if stop_manager.is_stop() {
-            return Ok(());
-        }
-        for event in events.iter() {
-            match event.token() {
-                SERVER => server_handle(
-                    poll.registry(),
-                    &udp,
-                    &nat_map,
-                    &mut token_map,
-                    &mut udp_map,
-                    &mut buf,
-                ),
-                NOTIFY => {
-                    check = true;
-                }
-                token => {
-                    if let Err(e) = readable_handle(&udp, &mut token_map, &token, &mut buf) {
-                        log::error!("发送目标失败:{:?}", e);
-                        if let Some((_, src_addr, _)) = token_map.remove(&token) {
-                            udp_map.remove(&src_addr);
+        };
+    }
+}
+
+async fn udp_proxy0(
+    buf: &[u8],
+    sender_addr: SocketAddrV4,
+    inner_map: &Arc<Mutex<HashMap<SocketAddrV4, (Arc<UdpSocket>, Arc<AtomicCell<Instant>>)>>>,
+    map: &Arc<Mutex<HashMap<SocketAddrV4, SocketAddrV4>>>,
+    udp_socket: &Arc<UdpSocket>,
+) -> io::Result<()> {
+    let option = inner_map.lock().get(&sender_addr).cloned();
+    if let Some((udp, time)) = option {
+        time.store(Instant::now());
+        udp.send(buf).await?;
+    } else {
+        let option = map.lock().get(&sender_addr).cloned();
+        if let Some(dest_addr) = option {
+            //先使用相同的端口，冲突了再随机端口
+            let peer_udp_socket =
+                match UdpSocket::bind(format!("0.0.0.0:{}", sender_addr.port())).await {
+                    Ok(udp) => udp,
+                    Err(_) => 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();
+            let time = Arc::new(AtomicCell::new(Instant::now()));
+            inner_map
+                .lock()
+                .insert(sender_addr, (peer_udp_socket.clone(), time.clone()));
+            let udp_socket = udp_socket.clone();
+            let map = map.clone();
+            tokio::spawn(async move {
+                let mut buf = [0u8; 65536];
+                loop {
+                    match tokio::time::timeout(
+                        Duration::from_secs(600),
+                        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 proxy {}->{} {:?}", sender_addr, dest_addr, e);
+                                    break;
+                                }
+                            },
+                            Err(e) => {
+                                log::warn!("udp proxy {}->{} {:?}", sender_addr, dest_addr, e);
+
+                                break;
+                            }
+                        },
+                        Err(_) => {
+                            if time.load().elapsed() > Duration::from_secs(580) {
+                                //超时关闭
+                                log::warn!("udp proxy timeout {}->{}", sender_addr, dest_addr);
+                                break;
+                            }
                        }
                    }
                }
-            }
-        }
-        if check {
-            //超时校验
-            if token_map.len() > NAT_MAX / 2 {
-                check_handle(&mut token_map, &mut udp_map, NAT_FAST_TIMEOUT)
-            } else {
-                check_handle(&mut token_map, &mut udp_map, NAT_TIMEOUT)
-            }
-            timeout = false;
-        }
-        if !token_map.is_empty() && !timeout {
-            //注册超时监听
-            timeout = true;
-            let waker = waker.clone();
-            scheduler.timeout(NAT_FAST_TIMEOUT, move |_| {
-                let _ = waker.wake();
+                inner_map.lock().remove(&sender_addr);
+                map.lock().remove(&sender_addr);
            });
        }
    }
-}
-
-fn check_handle(
-    token_map: &mut HashMap<Token, (Rc<UdpSocket>, SocketAddrV4, Instant)>,
-    udp_map: &mut HashMap<SocketAddrV4, (Rc<UdpSocket>, Instant)>,
-    timeout: Duration,
-) {
-    let mut remove_list = Vec::new();
-    for (token, (_, addr, time)) in token_map.iter() {
-        if time.elapsed() > timeout {
-            if let Some((_, time)) = udp_map.get(addr) {
-                if time.elapsed() > timeout {
-                    //映射超时，需要移除
-                    remove_list.push(*token);
-                }
-            }
-        }
-    }
-    for token in remove_list {
-        if let Some((_, src_addr, _)) = token_map.remove(&token) {
-            udp_map.remove(&src_addr);
-        }
-    }
-}
-
-fn server_handle(
-    registry: &Registry,
-    udp: &UdpSocket,
-    nat_map: &Mutex<HashMap<SocketAddrV4, SocketAddrV4>>,
-    token_map: &mut HashMap<Token, (Rc<UdpSocket>, SocketAddrV4, Instant)>,
-    udp_map: &mut HashMap<SocketAddrV4, (Rc<UdpSocket>, Instant)>,
-    buf: &mut [u8],
-) {
-    loop {
-        let (len, src_addr) = match udp.recv_from(buf) {
-            Ok((len, src_addr)) => match src_addr {
-                SocketAddr::V4(addr) => (len, addr),
-                SocketAddr::V6(_) => {
-                    continue;
-                }
-            },
-            Err(e) => {
-                if e.kind() == io::ErrorKind::WouldBlock {
-                    break;
-                }
-                log::error!("接收数据失败:{:?}", e);
-                break;
-            }
-        };
-        if let Some((dest_udp, time)) = udp_map.get_mut(&src_addr) {
-            //发送失败就当丢包了
-            let _ = dest_udp.send(&buf[..len]);
-            *time = Instant::now();
-        } else if let Some(dest_addr) = nat_map.lock().get(&src_addr).cloned() {
-            if token_map.len() >= NAT_MAX {
-                log::error!(
-                    "UDP NAT_MAX:src_addr={:?},dest_addr={:?}",
-                    src_addr,
-                    dest_addr
-                );
-                continue;
-            }
-            match udp_connect(src_addr.port(), dest_addr.into()) {
-                Ok((token_val, mut dest_udp)) => {
-                    let token = Token(token_val);
-                    if let Err(e) = registry.register(&mut dest_udp, token, Interest::READABLE) {
-                        log::error!("register失败:{:?},addr={:?}", e, dest_addr);
-                        continue;
-                    }
-                    if dest_udp.send(&buf[..len]).is_ok() {
-                        let dest_udp = Rc::new(dest_udp);
-                        token_map.insert(token, (dest_udp.clone(), src_addr, Instant::now()));
-                        udp_map.insert(src_addr, (dest_udp, Instant::now()));
-                    }
-                }
-                Err(e) => {
-                    log::error!("绑定目标地址失败:{:?}", e);
-                    continue;
-                }
-            };
-        }
-    }
-}
-
-/// 得到一个 fd不为SERVER_VAL或者NOTYFY_VAL的socket
-fn udp_connect(src_port: u16, addr: SocketAddr) -> io::Result<(usize, UdpSocket)> {
-    loop {
-        let udp = if let Ok(udp) =
-            UdpSocket::bind(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, src_port).into())
-        {
-            udp
-        } else {
-            UdpSocket::bind(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0).into())?
-        };
-        #[cfg(windows)]
-        let fd = udp.as_raw_socket() as usize;
-        #[cfg(unix)]
-        let fd = udp.as_raw_fd() as usize;
-        if fd == SERVER_VAL || fd == NOTIFY_VAL {
-            continue;
-        }
-        // 只接收目标的数据
-        udp.connect(addr)?;
-        return Ok((fd, udp));
-    }
-}
-
-fn readable_handle(
-    udp: &UdpSocket,
-    token_map: &mut HashMap<Token, (Rc<UdpSocket>, SocketAddrV4, Instant)>,
-    token: &Token,
-    buf: &mut [u8],
-) -> io::Result<()> {
-    if let Some((dest_udp, src_addr, time)) = token_map.get_mut(&token) {
-        loop {
-            let len = match dest_udp.recv(buf) {
-                Ok(rs) => rs,
-                Err(e) => {
-                    if e.kind() == io::ErrorKind::WouldBlock {
-                        break;
-                    }
-                    return Err(e);
-                }
-            };
-            if len == 0 {
-                return Err(io::Error::from(io::ErrorKind::UnexpectedEof));
-            }
-            let _ = udp.send_to(&buf[..len], (*src_addr).into());
-        }
-        *time = Instant::now();
-    }
    Ok(())
 }
@@ -8,9 +8,12 @@ pub mod handle;
 #[cfg(feature = "ip_proxy")]
 pub mod ip_proxy;
 pub mod nat;
+#[cfg(feature = "port_mapping")]
+pub mod port_mapping;
 pub mod proto;
 pub mod protocol;
 pub mod tun_tap_device;
 pub mod util;

-pub use handle::callback::{DeviceInfo, ErrorInfo, HandshakeInfo, RegisterInfo, VntCallback};
+pub use handle::callback::*;
+pub mod compression;
@@ -1,12 +1,14 @@
+use anyhow::Context;
 use std::io;
-use std::net::UdpSocket;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, ToSocketAddrs};
+use std::net::{SocketAddr, UdpSocket};
 use std::ops::Sub;
 use std::sync::Arc;
 use std::time::{Duration, Instant};

 use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::Mutex;
+use rand::Rng;

 use crate::channel::punch::{NatInfo, NatType};
 use crate::proto::message::PunchNatType;
@@ -22,6 +24,7 @@ pub fn local_ipv4_() -> io::Result<Ipv4Addr> {
        IpAddr::V6(_) => Ok(Ipv4Addr::UNSPECIFIED),
    }
 }
+
 pub fn local_ipv4() -> Option<Ipv4Addr> {
    match local_ipv4_() {
        Ok(ipv4) => Some(ipv4),
@@ -41,6 +44,7 @@ pub fn local_ipv6_() -> io::Result<Ipv6Addr> {
        IpAddr::V6(ip) => Ok(ip),
    }
 }
+
 pub fn local_ipv6() -> Option<Ipv6Addr> {
    match local_ipv6_() {
        Ok(ipv6) => Some(ipv6),
@@ -56,6 +60,8 @@ pub struct NatTest {
    stun_server: Vec<String>,
    info: Arc<Mutex<NatInfo>>,
    time: Arc<AtomicCell<Instant>>,
+    udp_ports: Vec<u16>,
+    tcp_port: u16,
 }

 impl From<NatType> for PunchNatType {
@@ -78,24 +84,24 @@ impl Into<NatType> for PunchNatType {

 impl NatTest {
    pub fn new(
-        channel_num: usize,
+        _channel_num: usize,
        mut stun_server: Vec<String>,
        local_ipv4: Option<Ipv4Addr>,
        ipv6: Option<Ipv6Addr>,
        udp_ports: Vec<u16>,
        tcp_port: u16,
    ) -> NatTest {
-        let server = stun_server[0].clone();
-        stun_server.resize(3, server);
-        let mut ports = udp_ports.clone();
-        ports.resize(channel_num, 0);
+        if stun_server.len() > 5 {
+            stun_server.truncate(5);
+        }
+        let ports = vec![0; udp_ports.len()];
        let nat_info = NatInfo::new(
            Vec::new(),
            ports,
            0,
            local_ipv4,
            ipv6,
-            udp_ports,
+            udp_ports.clone(),
            tcp_port,
            NatType::Cone,
        );
@@ -106,6 +112,8 @@ impl NatTest {
            time: Arc::new(AtomicCell::new(
                Instant::now().sub(Duration::from_secs(100)),
            )),
+            udp_ports,
+            tcp_port,
        }
    }
    pub fn can_update(&self) -> bool {
@@ -117,6 +125,66 @@ impl NatTest {
    pub fn nat_info(&self) -> NatInfo {
        self.info.lock().clone()
    }
+    pub fn is_local_udp(&self, ipv4: Ipv4Addr, port: u16) -> bool {
+        for x in &self.udp_ports {
+            if x == &port {
+                let guard = self.info.lock();
+                if let Some(ip) = guard.local_ipv4 {
+                    if ipv4 == ip {
+                        return true;
+                    }
+                }
+                break;
+            }
+        }
+        false
+    }
+    pub fn is_local_tcp(&self, ipv4: Ipv4Addr, port: u16) -> bool {
+        if self.tcp_port == port {
+            let guard = self.info.lock();
+            if let Some(ip) = guard.local_ipv4 {
+                if ipv4 == ip {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+    pub fn is_local_address(&self, is_tcp: bool, addr: SocketAddr) -> bool {
+        let port = addr.port();
+        let check_ip = || {
+            let guard = self.info.lock();
+            match addr.ip() {
+                IpAddr::V4(ipv4) => {
+                    if let Some(ip) = guard.local_ipv4 {
+                        if ipv4 == ip {
+                            return true;
+                        }
+                    }
+                }
+                IpAddr::V6(ipv6) => {
+                    if let Some(ip) = guard.ipv6 {
+                        if ipv6 == ip {
+                            return true;
+                        }
+                    }
+                }
+            }
+            false
+        };
+        if is_tcp {
+            if self.tcp_port == port {
+                return check_ip();
+            }
+        } else {
+            for x in &self.udp_ports {
+                if x == &port {
+                    return check_ip();
+                }
+            }
+        }
+        false
+    }
    pub fn update_addr(&self, index: usize, ip: Ipv4Addr, port: u16) {
        let mut guard = self.info.lock();
        guard.update_addr(index, ip, port)
@@ -136,4 +204,66 @@ impl NatTest {

        Ok(guard.clone())
    }
+    pub fn send_data(&self) -> anyhow::Result<(Vec<u8>, SocketAddr)> {
+        let len = self.stun_server.len();
+        let stun_server = if len == 1 {
+            &self.stun_server[0]
+        } else {
+            let index = rand::thread_rng().gen_range(0..self.stun_server.len());
+            &self.stun_server[index]
+        };
+        let addr = stun_server
+            .to_socket_addrs()?
+            .next()
+            .with_context(|| format!("stun error {:?}", stun_server))?;
+        Ok((stun::send_stun_request(), addr))
+    }
+    pub fn recv_data(
+        &self,
+        index: usize,
+        source_addr: SocketAddr,
+        buf: &[u8],
+    ) -> anyhow::Result<bool> {
+        if let Some(addr) = stun::recv_stun_response(buf) {
+            if let SocketAddr::V4(addr) = addr {
+                let mut check_fail = true;
+                let source_ip = match source_addr.ip() {
+                    IpAddr::V4(ip) => ip,
+                    IpAddr::V6(ip) => {
+                        if let Some(ip) = ip.to_ipv4_mapped() {
+                            ip
+                        } else {
+                            return Ok(false);
+                        }
+                    }
+                };
+                'a: for stun_server in &self.stun_server {
+                    for x in stun_server.to_socket_addrs()? {
+                        if source_addr.port() == x.port() {
+                            if let IpAddr::V4(ip) = x.ip() {
+                                if ip == source_ip {
+                                    check_fail = false;
+                                    break 'a;
+                                }
+                            };
+                        }
+                    }
+                }
+                if check_fail {
+                    return Ok(false);
+                }
+                let ip = addr.ip();
+                if !ip.is_multicast()
+                    && !ip.is_broadcast()
+                    && !ip.is_unspecified()
+                    && !ip.is_loopback()
+                    && !ip.is_private()
+                {
+                    self.update_addr(index, *addr.ip(), addr.port());
+                    return Ok(true);
+                }
+            }
+        }
+        return Ok(false);
+    }
 }
@@ -1,24 +1,26 @@
 use std::collections::HashSet;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
+use std::io;
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use std::time::Duration;
-use std::{io, thread};

 use crate::channel::punch::NatType;
+use rand::RngCore;
 use std::net::UdpSocket;
 use stun_format::Attr;

 pub fn stun_test_nat(stun_servers: Vec<String>) -> io::Result<(NatType, Vec<Ipv4Addr>, u16)> {
-    let mut h = Vec::new();
-    for x in stun_servers {
-        let handle = thread::spawn(move || test_nat(x));
-        h.push(handle);
+    let mut th = Vec::new();
+    for _ in 0..2 {
+        let stun_servers = stun_servers.clone();
+        let handle = std::thread::spawn(move || stun_test_nat0(stun_servers));
+        th.push(handle);
    }
    let mut nat_type = NatType::Cone;
    let mut port_range = 0;
    let mut hash_set = HashSet::new();
-    for x in h {
-        if let Ok(rs) = x.join() {
-            if let Ok((nat_type_t, ip_list_t, port_range_t)) = rs {
+    for x in th {
+        match x.join().unwrap() {
+            Ok((nat_type_t, ip_list_t, port_range_t)) => {
                if nat_type_t == NatType::Symmetric {
                    nat_type = NatType::Symmetric;
                }
@@ -29,66 +31,110 @@ pub fn stun_test_nat(stun_servers: Vec<String>) -> io::Result<(NatType, Vec<Ipv4
                    port_range = port_range_t;
                }
            }
+            Err(e) => {
+                log::warn!("{:?}", e);
+            }
        }
    }
    Ok((nat_type, hash_set.into_iter().collect(), port_range))
 }

-fn test_nat(stun_server: String) -> io::Result<(NatType, Vec<Ipv4Addr>, u16)> {
+pub fn stun_test_nat0(stun_servers: Vec<String>) -> io::Result<(NatType, Vec<Ipv4Addr>, u16)> {
    let udp = UdpSocket::bind("0.0.0.0:0")?;
-    udp.set_read_timeout(Some(Duration::from_millis(300)))?;
-    udp.connect(stun_server)?;
-    let mut port_range = 0;
-    let mut hash_set = HashSet::new();
+    udp.set_read_timeout(Some(Duration::from_millis(500)))?;
    let mut nat_type = NatType::Cone;
-    match test_nat_(&udp, true, true) {
-        Ok((mapped_addr1, changed_addr1)) => {
-            match mapped_addr1.ip() {
-                IpAddr::V4(ip) => {
-                    hash_set.insert(ip);
-                }
-                IpAddr::V6(_) => {}
+    let mut min_port = u16::MAX;
+    let mut max_port = 0;
+    let mut hash_set = HashSet::new();
+    let mut pub_addrs = HashSet::new();
+    for x in &stun_servers {
+        match test_nat(&udp, x) {
+            Ok(addr) => {
+                pub_addrs.extend(addr);
            }
-            if udp.connect(changed_addr1).is_ok() {
-                if let Ok((mapped_addr2, _)) = test_nat_(&udp, false, false) {
-                    match mapped_addr2.ip() {
-                        IpAddr::V4(ip) => {
-                            hash_set.insert(ip);
-                            if mapped_addr1 != mapped_addr2 {
-                                nat_type = NatType::Symmetric;
-                            }
-                        }
-                        IpAddr::V6(_) => {}
+            Err(e) => {
+                log::warn!("stun {} error {:?} ", x, e);
+            }
+        }
+    }
+    if pub_addrs.len() > 1 {
+        nat_type = NatType::Symmetric;
+    }
+    for addr in &pub_addrs {
+        if let SocketAddr::V4(addr) = addr {
+            hash_set.insert(*addr.ip());
+            if min_port > addr.port() {
+                min_port = addr.port()
+            }
+            if max_port < addr.port() {
+                max_port = addr.port()
+            }
+        }
+    }
+    if hash_set.is_empty() {
+        Ok((nat_type, vec![], 0))
+    } else {
+        Ok((
+            nat_type,
+            hash_set.into_iter().collect(),
+            max_port - min_port,
+        ))
+    }
+}
+
+fn test_nat(udp: &UdpSocket, stun_server: &String) -> io::Result<HashSet<SocketAddr>> {
+    udp.connect(stun_server)?;
+    let tid = rand::thread_rng().next_u64() as u128;
+    let mut addr = HashSet::new();
+    let (mapped_addr1, changed_addr1) = test_nat_(&udp, true, true, tid)?;
+    if mapped_addr1.is_ipv4() {
+        addr.insert(mapped_addr1);
+    }
+    if let Some(changed_addr1) = changed_addr1 {
+        if udp.connect(changed_addr1).is_ok() {
+            match test_nat_(&udp, false, false, tid + 1) {
+                Ok((mapped_addr2, _)) => {
+                    if mapped_addr2.is_ipv4() {
+                        addr.insert(mapped_addr1);
                    }
-                    port_range = mapped_addr2.port().abs_diff(mapped_addr1.port());
+                }
+                Err(e) => {
+                    log::warn!("stun {} error {:?} ", stun_server, e);
                }
            }
        }
-        Err(_) => {}
    }
-    Ok((nat_type, hash_set.into_iter().collect(), port_range))
+    log::info!(
+        "stun {} mapped_addr {:?}  changed_addr {:?}",
+        stun_server,
+        addr,
+        changed_addr1,
+    );
+
+    Ok(addr)
 }

 fn test_nat_(
    udp: &UdpSocket,
    change_ip: bool,
    change_port: bool,
-) -> io::Result<(SocketAddr, SocketAddr)> {
+    tid: u128,
+) -> io::Result<(SocketAddr, Option<SocketAddr>)> {
    for _ in 0..2 {
        let mut buf = [0u8; 28];
        let mut msg = stun_format::MsgBuilder::from(buf.as_mut_slice());
-        msg.typ(stun_format::MsgType::BindingRequest).unwrap();
-        msg.tid(1).unwrap();
+        msg.typ(stun_format::MsgType::BindingRequest);
+        msg.tid(tid);
        msg.add_attr(Attr::ChangeRequest {
            change_ip,
            change_port,
-        })
-        .unwrap();
+        });
        udp.send(msg.as_bytes())?;
        let mut buf = [0; 10240];
        let (len, _addr) = match udp.recv_from(&mut buf) {
            Ok(rs) => rs,
-            Err(_) => {
+            Err(e) => {
+                log::warn!("stun error {:?}", e);
                continue;
            }
        };
@@ -115,11 +161,11 @@ fn test_nat_(
                _ => {}
            }
            if changed_addr.is_some() && mapped_addr.is_some() {
-                return Ok((mapped_addr.unwrap(), changed_addr.unwrap()));
+                return Ok((mapped_addr.unwrap(), changed_addr));
            }
        }
        if let Some(addr) = mapped_addr {
-            return Ok((addr, changed_addr.unwrap_or(addr)));
+            return Ok((addr, changed_addr));
        }
    }
    Err(io::Error::new(io::ErrorKind::Other, "stun response err"))
@@ -135,3 +181,42 @@ fn stun_addr(addr: stun_format::SocketAddr) -> SocketAddr {
        }
    }
 }
+
+const TAG: u128 = 1827549368 << 64;
+
+pub fn send_stun_request() -> Vec<u8> {
+    let mut buf = [0u8; 28];
+    let mut msg = stun_format::MsgBuilder::from(buf.as_mut_slice());
+    msg.typ(stun_format::MsgType::BindingRequest);
+    let id = rand::thread_rng().next_u64() as u128;
+    msg.tid(id | TAG);
+    msg.add_attr(Attr::ChangeRequest {
+        change_ip: false,
+        change_port: false,
+    });
+    msg.as_bytes().to_vec()
+}
+
+pub fn recv_stun_response(buf: &[u8]) -> Option<SocketAddr> {
+    if buf[0] != 0x01 && buf[1] != 0x01 {
+        return None;
+    }
+    let msg = stun_format::Msg::from(buf);
+    if let Some(tid) = msg.tid() {
+        if tid & TAG != TAG {
+            return None;
+        }
+    }
+    for x in msg.attrs_iter() {
+        match x {
+            Attr::MappedAddress(addr) => {
+                return Some(stun_addr(addr));
+            }
+            Attr::XorMappedAddress(addr) => {
+                return Some(stun_addr(addr));
+            }
+            _ => {}
+        }
+    }
+    None
+}
@@ -0,0 +1,100 @@
+use std::net::SocketAddr;
+use std::str::FromStr;
+use std::thread;
+
+use anyhow::Context;
+
+use crate::util::StopManager;
+
+mod tcp_mapping;
+
+mod udp_mapping;
+
+pub fn convert(vec: Vec<String>) -> anyhow::Result<Vec<(bool, SocketAddr, String)>> {
+    let mut rs = Vec::with_capacity(vec.len());
+    for x in vec {
+        let string = x.trim().to_lowercase();
+        if let Some(udp_mapping) = string.strip_prefix("udp:") {
+            let mut split = udp_mapping.split("->");
+            let bind_addr = split.next().with_context(|| {
+                format!(
+                    "udp_mapping error {:?},eg: udp:127.0.0.1:80->10.26.0.10:8080",
+                    x
+                )
+            })?;
+            let bind_addr = SocketAddr::from_str(bind_addr)
+                .with_context(|| format!("udp_mapping error {}", bind_addr))?;
+            let dest = split.next().with_context(|| {
+                format!(
+                    "udp_mapping error {:?},eg: udp:127.0.0.1:80->10.26.0.10:8080",
+                    x
+                )
+            })?;
+            rs.push((false, bind_addr, dest.to_string()));
+            continue;
+        }
+        if let Some(tcp_mapping) = string.strip_prefix("tcp:") {
+            let mut split = tcp_mapping.split("->");
+            let bind_addr = split.next().with_context(|| {
+                format!(
+                    "tcp_mapping error {:?},eg: tcp:127.0.0.1:80->10.26.0.10:8080",
+                    x
+                )
+            })?;
+            let bind_addr = SocketAddr::from_str(bind_addr)
+                .with_context(|| format!("udp_mapping error {}", bind_addr))?;
+            let dest = split.next().with_context(|| {
+                format!(
+                    "tcp_mapping error {:?},eg: tcp:127.0.0.1:80->10.26.0.10:8080",
+                    x
+                )
+            })?;
+            rs.push((true, bind_addr, dest.to_string()));
+            continue;
+        }
+        Err(anyhow::anyhow!(
+            "port_mapping error {:?},eg: tcp:127.0.0.1:80->10.26.0.10:8080",
+            x
+        ))?;
+    }
+    Ok(rs)
+}
+pub fn start_port_mapping(
+    stop_manager: StopManager,
+    vec: Vec<(bool, SocketAddr, String)>,
+) -> anyhow::Result<()> {
+    if vec.is_empty() {
+        return Ok(());
+    }
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .thread_name("portMapping")
+        .build()?;
+    runtime.block_on(start_port_mapping0(vec))?;
+    let (sender, receiver) = tokio::sync::oneshot::channel::<()>();
+    let worker = stop_manager.add_listener("portMapping".into(), move || {
+        let _ = sender.send(());
+    })?;
+    thread::Builder::new()
+        .name("portMapping".into())
+        .spawn(move || {
+            runtime.block_on(async {
+                let _ = receiver.await;
+            });
+            runtime.shutdown_background();
+            drop(worker);
+        })?;
+
+    Ok(())
+}
+
+async fn start_port_mapping0(vec: Vec<(bool, SocketAddr, String)>) -> anyhow::Result<()> {
+    for (is_tcp, bind_addr, destination) in vec {
+        if is_tcp {
+            tcp_mapping::tcp_mapping(bind_addr, destination).await?;
+        } else {
+            udp_mapping::udp_mapping(bind_addr, destination).await?;
+        }
+    }
+    Ok(())
+}
@@ -0,0 +1,49 @@
+use anyhow::Context;
+use std::net::SocketAddr;
+use tokio::net::{TcpListener, TcpStream};
+
+pub async fn tcp_mapping(bind_addr: SocketAddr, destination: String) -> anyhow::Result<()> {
+    let tcp_listener = TcpListener::bind(bind_addr)
+        .await
+        .with_context(|| format!("TCP binding {:?} failed", bind_addr))?;
+    tokio::spawn(tcp_mapping_(bind_addr, tcp_listener, destination));
+    Ok(())
+}
+
+async fn tcp_mapping_(
+    bind_addr: SocketAddr,
+    tcp_listener: TcpListener,
+    destination: String,
+) -> anyhow::Result<()> {
+    loop {
+        let (tcp_stream, _) = tcp_listener.accept().await?;
+
+        let destination = destination.clone();
+        tokio::spawn(async move {
+            if let Err(e) = copy(tcp_stream, &destination).await {
+                log::warn!("tcp port mapping {}->{} {:?}", bind_addr, destination, e);
+            }
+        });
+    }
+}
+
+async fn copy(source_tcp: TcpStream, destination: &String) -> anyhow::Result<()> {
+    let dest_tcp = TcpStream::connect(destination)
+        .await
+        .with_context(|| format!("TCP connection target failed {:?}", destination))?;
+    let _ = source_tcp.set_nodelay(true);
+    let _ = dest_tcp.set_nodelay(true);
+
+    let destination = dest_tcp.peer_addr()?;
+    let (mut client_read, mut client_write) = source_tcp.into_split();
+    let (mut server_read, mut server_write) = dest_tcp.into_split();
+    tokio::spawn(async move {
+        if let Err(e) = tokio::io::copy(&mut client_read, &mut server_write).await {
+            log::warn!("client tcp proxy ->{:},{:?}", destination, e);
+        }
+    });
+    if let Err(e) = tokio::io::copy(&mut server_read, &mut client_write).await {
+        log::warn!("server tcp proxy ->{:?},{:?}", destination, e);
+    }
+    Ok(())
+}
@@ -0,0 +1,107 @@
+use anyhow::Context;
+use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::net::UdpSocket;
+
+pub async fn udp_mapping(bind_addr: SocketAddr, destination: String) -> anyhow::Result<()> {
+    let udp = UdpSocket::bind(bind_addr)
+        .await
+        .with_context(|| format!("port proxy UDP binding {:?} failed", bind_addr))?;
+    let udp = Arc::new(udp);
+
+    let inner_map: Arc<Mutex<HashMap<SocketAddr, (Arc<UdpSocket>, Arc<AtomicCell<Instant>>)>>> =
+        Arc::new(Mutex::new(HashMap::with_capacity(64)));
+
+    tokio::spawn(async move {
+        let mut buf = [0; 65536];
+        loop {
+            match udp.recv_from(&mut buf).await {
+                Ok((len, src_addr)) => {
+                    if let Err(e) =
+                        udp_mapping0(&buf[..len], src_addr, &inner_map, &udp, &destination).await
+                    {
+                        log::warn!("udp port mapping {}->{} {:?}", src_addr, destination, e);
+                    }
+                }
+                Err(e) => {
+                    log::warn!("port proxy UDP  {:?}", e);
+                }
+            }
+        }
+    });
+    Ok(())
+}
+
+async fn udp_mapping0(
+    buf: &[u8],
+    src_addr: SocketAddr,
+    inner_map: &Arc<Mutex<HashMap<SocketAddr, (Arc<UdpSocket>, Arc<AtomicCell<Instant>>)>>>,
+    udp_socket: &Arc<UdpSocket>,
+    destination: &String,
+) -> anyhow::Result<()> {
+    let option = inner_map.lock().get(&src_addr).cloned();
+    if let Some((udp, time)) = option {
+        time.store(Instant::now());
+        udp.send(buf).await?;
+    } else {
+        let dest_udp = UdpSocket::bind("0.0.0.0:0").await?;
+        dest_udp.connect(destination).await?;
+        dest_udp.send(buf).await?;
+        let destination_addr = dest_udp.peer_addr()?;
+        let udp_socket = udp_socket.clone();
+        let inner_map = inner_map.clone();
+        let dest_udp = Arc::new(dest_udp);
+        let time = Arc::new(AtomicCell::new(Instant::now()));
+        inner_map
+            .lock()
+            .insert(src_addr, (dest_udp.clone(), time.clone()));
+        tokio::spawn(async move {
+            let mut buf = [0u8; 65536];
+            loop {
+                match tokio::time::timeout(Duration::from_secs(600), dest_udp.recv(&mut buf)).await
+                {
+                    Ok(rs) => match rs {
+                        Ok(len) => match udp_socket.send_to(&buf[..len], src_addr).await {
+                            Ok(_) => {}
+                            Err(e) => {
+                                log::warn!(
+                                    "udp port mapping {}->{} {:?}",
+                                    src_addr,
+                                    destination_addr,
+                                    e
+                                );
+                                break;
+                            }
+                        },
+                        Err(e) => {
+                            log::warn!(
+                                "udp port mapping {}->{} {:?}",
+                                src_addr,
+                                destination_addr,
+                                e
+                            );
+                            break;
+                        }
+                    },
+                    Err(_) => {
+                        if time.load().elapsed() > Duration::from_secs(580) {
+                            //超时关闭
+                            log::warn!(
+                                "udp port mapping timeout {}->{}  ",
+                                src_addr,
+                                destination_addr
+                            );
+                            break;
+                        }
+                    }
+                }
+            }
+            inner_map.lock().remove(&src_addr);
+        });
+    }
+    Ok(())
+}
@@ -1,2080 +0,0 @@
-// This file is generated by rust-protobuf 3.2.0. Do not edit
-// .proto file is parsed by pure
-// @generated
-
-// https://github.com/rust-lang/rust-clippy/issues/702
-#![allow(unknown_lints)]
-#![allow(clippy::all)]
-
-#![allow(unused_attributes)]
-#![cfg_attr(rustfmt, rustfmt::skip)]
-
-#![allow(box_pointers)]
-#![allow(dead_code)]
-#![allow(missing_docs)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-#![allow(non_upper_case_globals)]
-#![allow(trivial_casts)]
-#![allow(unused_results)]
-#![allow(unused_mut)]
-
-//! Generated file from `message.proto`
-
-/// Generated files are compatible only with the same version
-/// of protobuf runtime.
-const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:HandshakeRequest)
-pub struct HandshakeRequest {
-    // message fields
-    // @@protoc_insertion_point(field:HandshakeRequest.version)
-    pub version: ::std::string::String,
-    // @@protoc_insertion_point(field:HandshakeRequest.secret)
-    pub secret: bool,
-    // special fields
-    // @@protoc_insertion_point(special_field:HandshakeRequest.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a HandshakeRequest {
-    fn default() -> &'a HandshakeRequest {
-        <HandshakeRequest as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl HandshakeRequest {
-    pub fn new() -> HandshakeRequest {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(2);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "version",
-            |m: &HandshakeRequest| { &m.version },
-            |m: &mut HandshakeRequest| { &mut m.version },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "secret",
-            |m: &HandshakeRequest| { &m.secret },
-            |m: &mut HandshakeRequest| { &mut m.secret },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<HandshakeRequest>(
-            "HandshakeRequest",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for HandshakeRequest {
-    const NAME: &'static str = "HandshakeRequest";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                10 => {
-                    self.version = is.read_string()?;
-                },
-                16 => {
-                    self.secret = is.read_bool()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if !self.version.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.version);
-        }
-        if self.secret != false {
-            my_size += 1 + 1;
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if !self.version.is_empty() {
-            os.write_string(1, &self.version)?;
-        }
-        if self.secret != false {
-            os.write_bool(2, self.secret)?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> HandshakeRequest {
-        HandshakeRequest::new()
-    }
-
-    fn clear(&mut self) {
-        self.version.clear();
-        self.secret = false;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static HandshakeRequest {
-        static instance: HandshakeRequest = HandshakeRequest {
-            version: ::std::string::String::new(),
-            secret: false,
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for HandshakeRequest {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("HandshakeRequest").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for HandshakeRequest {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for HandshakeRequest {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:HandshakeResponse)
-pub struct HandshakeResponse {
-    // message fields
-    // @@protoc_insertion_point(field:HandshakeResponse.version)
-    pub version: ::std::string::String,
-    // @@protoc_insertion_point(field:HandshakeResponse.secret)
-    pub secret: bool,
-    // @@protoc_insertion_point(field:HandshakeResponse.public_key)
-    pub public_key: ::std::vec::Vec<u8>,
-    // @@protoc_insertion_point(field:HandshakeResponse.key_finger)
-    pub key_finger: ::std::string::String,
-    // special fields
-    // @@protoc_insertion_point(special_field:HandshakeResponse.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a HandshakeResponse {
-    fn default() -> &'a HandshakeResponse {
-        <HandshakeResponse as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl HandshakeResponse {
-    pub fn new() -> HandshakeResponse {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(4);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "version",
-            |m: &HandshakeResponse| { &m.version },
-            |m: &mut HandshakeResponse| { &mut m.version },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "secret",
-            |m: &HandshakeResponse| { &m.secret },
-            |m: &mut HandshakeResponse| { &mut m.secret },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_key",
-            |m: &HandshakeResponse| { &m.public_key },
-            |m: &mut HandshakeResponse| { &mut m.public_key },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "key_finger",
-            |m: &HandshakeResponse| { &m.key_finger },
-            |m: &mut HandshakeResponse| { &mut m.key_finger },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<HandshakeResponse>(
-            "HandshakeResponse",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for HandshakeResponse {
-    const NAME: &'static str = "HandshakeResponse";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                10 => {
-                    self.version = is.read_string()?;
-                },
-                16 => {
-                    self.secret = is.read_bool()?;
-                },
-                26 => {
-                    self.public_key = is.read_bytes()?;
-                },
-                34 => {
-                    self.key_finger = is.read_string()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if !self.version.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.version);
-        }
-        if self.secret != false {
-            my_size += 1 + 1;
-        }
-        if !self.public_key.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(3, &self.public_key);
-        }
-        if !self.key_finger.is_empty() {
-            my_size += ::protobuf::rt::string_size(4, &self.key_finger);
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if !self.version.is_empty() {
-            os.write_string(1, &self.version)?;
-        }
-        if self.secret != false {
-            os.write_bool(2, self.secret)?;
-        }
-        if !self.public_key.is_empty() {
-            os.write_bytes(3, &self.public_key)?;
-        }
-        if !self.key_finger.is_empty() {
-            os.write_string(4, &self.key_finger)?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> HandshakeResponse {
-        HandshakeResponse::new()
-    }
-
-    fn clear(&mut self) {
-        self.version.clear();
-        self.secret = false;
-        self.public_key.clear();
-        self.key_finger.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static HandshakeResponse {
-        static instance: HandshakeResponse = HandshakeResponse {
-            version: ::std::string::String::new(),
-            secret: false,
-            public_key: ::std::vec::Vec::new(),
-            key_finger: ::std::string::String::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for HandshakeResponse {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("HandshakeResponse").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for HandshakeResponse {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for HandshakeResponse {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:SecretHandshakeRequest)
-pub struct SecretHandshakeRequest {
-    // message fields
-    // @@protoc_insertion_point(field:SecretHandshakeRequest.token)
-    pub token: ::std::string::String,
-    // @@protoc_insertion_point(field:SecretHandshakeRequest.key)
-    pub key: ::std::vec::Vec<u8>,
-    // special fields
-    // @@protoc_insertion_point(special_field:SecretHandshakeRequest.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a SecretHandshakeRequest {
-    fn default() -> &'a SecretHandshakeRequest {
-        <SecretHandshakeRequest as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl SecretHandshakeRequest {
-    pub fn new() -> SecretHandshakeRequest {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(2);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "token",
-            |m: &SecretHandshakeRequest| { &m.token },
-            |m: &mut SecretHandshakeRequest| { &mut m.token },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "key",
-            |m: &SecretHandshakeRequest| { &m.key },
-            |m: &mut SecretHandshakeRequest| { &mut m.key },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SecretHandshakeRequest>(
-            "SecretHandshakeRequest",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for SecretHandshakeRequest {
-    const NAME: &'static str = "SecretHandshakeRequest";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                10 => {
-                    self.token = is.read_string()?;
-                },
-                18 => {
-                    self.key = is.read_bytes()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if !self.token.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.token);
-        }
-        if !self.key.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(2, &self.key);
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if !self.token.is_empty() {
-            os.write_string(1, &self.token)?;
-        }
-        if !self.key.is_empty() {
-            os.write_bytes(2, &self.key)?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> SecretHandshakeRequest {
-        SecretHandshakeRequest::new()
-    }
-
-    fn clear(&mut self) {
-        self.token.clear();
-        self.key.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static SecretHandshakeRequest {
-        static instance: SecretHandshakeRequest = SecretHandshakeRequest {
-            token: ::std::string::String::new(),
-            key: ::std::vec::Vec::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for SecretHandshakeRequest {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("SecretHandshakeRequest").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for SecretHandshakeRequest {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for SecretHandshakeRequest {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:RegistrationRequest)
-pub struct RegistrationRequest {
-    // message fields
-    // @@protoc_insertion_point(field:RegistrationRequest.token)
-    pub token: ::std::string::String,
-    // @@protoc_insertion_point(field:RegistrationRequest.device_id)
-    pub device_id: ::std::string::String,
-    // @@protoc_insertion_point(field:RegistrationRequest.name)
-    pub name: ::std::string::String,
-    // @@protoc_insertion_point(field:RegistrationRequest.is_fast)
-    pub is_fast: bool,
-    // @@protoc_insertion_point(field:RegistrationRequest.version)
-    pub version: ::std::string::String,
-    // @@protoc_insertion_point(field:RegistrationRequest.virtual_ip)
-    pub virtual_ip: u32,
-    // @@protoc_insertion_point(field:RegistrationRequest.allow_ip_change)
-    pub allow_ip_change: bool,
-    // @@protoc_insertion_point(field:RegistrationRequest.client_secret)
-    pub client_secret: bool,
-    // special fields
-    // @@protoc_insertion_point(special_field:RegistrationRequest.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a RegistrationRequest {
-    fn default() -> &'a RegistrationRequest {
-        <RegistrationRequest as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl RegistrationRequest {
-    pub fn new() -> RegistrationRequest {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(8);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "token",
-            |m: &RegistrationRequest| { &m.token },
-            |m: &mut RegistrationRequest| { &mut m.token },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "device_id",
-            |m: &RegistrationRequest| { &m.device_id },
-            |m: &mut RegistrationRequest| { &mut m.device_id },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "name",
-            |m: &RegistrationRequest| { &m.name },
-            |m: &mut RegistrationRequest| { &mut m.name },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "is_fast",
-            |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 },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "virtual_ip",
-            |m: &RegistrationRequest| { &m.virtual_ip },
-            |m: &mut RegistrationRequest| { &mut m.virtual_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "allow_ip_change",
-            |m: &RegistrationRequest| { &m.allow_ip_change },
-            |m: &mut RegistrationRequest| { &mut m.allow_ip_change },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "client_secret",
-            |m: &RegistrationRequest| { &m.client_secret },
-            |m: &mut RegistrationRequest| { &mut m.client_secret },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationRequest>(
-            "RegistrationRequest",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for RegistrationRequest {
-    const NAME: &'static str = "RegistrationRequest";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                10 => {
-                    self.token = is.read_string()?;
-                },
-                18 => {
-                    self.device_id = is.read_string()?;
-                },
-                26 => {
-                    self.name = is.read_string()?;
-                },
-                32 => {
-                    self.is_fast = is.read_bool()?;
-                },
-                42 => {
-                    self.version = is.read_string()?;
-                },
-                53 => {
-                    self.virtual_ip = is.read_fixed32()?;
-                },
-                56 => {
-                    self.allow_ip_change = is.read_bool()?;
-                },
-                64 => {
-                    self.client_secret = is.read_bool()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if !self.token.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.token);
-        }
-        if !self.device_id.is_empty() {
-            my_size += ::protobuf::rt::string_size(2, &self.device_id);
-        }
-        if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(3, &self.name);
-        }
-        if self.is_fast != false {
-            my_size += 1 + 1;
-        }
-        if !self.version.is_empty() {
-            my_size += ::protobuf::rt::string_size(5, &self.version);
-        }
-        if self.virtual_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.allow_ip_change != false {
-            my_size += 1 + 1;
-        }
-        if self.client_secret != false {
-            my_size += 1 + 1;
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if !self.token.is_empty() {
-            os.write_string(1, &self.token)?;
-        }
-        if !self.device_id.is_empty() {
-            os.write_string(2, &self.device_id)?;
-        }
-        if !self.name.is_empty() {
-            os.write_string(3, &self.name)?;
-        }
-        if self.is_fast != false {
-            os.write_bool(4, self.is_fast)?;
-        }
-        if !self.version.is_empty() {
-            os.write_string(5, &self.version)?;
-        }
-        if self.virtual_ip != 0 {
-            os.write_fixed32(6, self.virtual_ip)?;
-        }
-        if self.allow_ip_change != false {
-            os.write_bool(7, self.allow_ip_change)?;
-        }
-        if self.client_secret != false {
-            os.write_bool(8, self.client_secret)?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> RegistrationRequest {
-        RegistrationRequest::new()
-    }
-
-    fn clear(&mut self) {
-        self.token.clear();
-        self.device_id.clear();
-        self.name.clear();
-        self.is_fast = false;
-        self.version.clear();
-        self.virtual_ip = 0;
-        self.allow_ip_change = false;
-        self.client_secret = false;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static RegistrationRequest {
-        static instance: RegistrationRequest = RegistrationRequest {
-            token: ::std::string::String::new(),
-            device_id: ::std::string::String::new(),
-            name: ::std::string::String::new(),
-            is_fast: false,
-            version: ::std::string::String::new(),
-            virtual_ip: 0,
-            allow_ip_change: false,
-            client_secret: false,
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for RegistrationRequest {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("RegistrationRequest").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for RegistrationRequest {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for RegistrationRequest {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:RegistrationResponse)
-pub struct RegistrationResponse {
-    // message fields
-    // @@protoc_insertion_point(field:RegistrationResponse.virtual_ip)
-    pub virtual_ip: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.virtual_gateway)
-    pub virtual_gateway: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.virtual_netmask)
-    pub virtual_netmask: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.epoch)
-    pub epoch: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.device_info_list)
-    pub device_info_list: ::std::vec::Vec<DeviceInfo>,
-    // @@protoc_insertion_point(field:RegistrationResponse.public_ip)
-    pub public_ip: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.public_port)
-    pub public_port: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.public_ipv6)
-    pub public_ipv6: ::std::vec::Vec<u8>,
-    // special fields
-    // @@protoc_insertion_point(special_field:RegistrationResponse.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a RegistrationResponse {
-    fn default() -> &'a RegistrationResponse {
-        <RegistrationResponse as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl RegistrationResponse {
-    pub fn new() -> RegistrationResponse {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(8);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "virtual_ip",
-            |m: &RegistrationResponse| { &m.virtual_ip },
-            |m: &mut RegistrationResponse| { &mut m.virtual_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "virtual_gateway",
-            |m: &RegistrationResponse| { &m.virtual_gateway },
-            |m: &mut RegistrationResponse| { &mut m.virtual_gateway },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "virtual_netmask",
-            |m: &RegistrationResponse| { &m.virtual_netmask },
-            |m: &mut RegistrationResponse| { &mut m.virtual_netmask },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "epoch",
-            |m: &RegistrationResponse| { &m.epoch },
-            |m: &mut RegistrationResponse| { &mut m.epoch },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "device_info_list",
-            |m: &RegistrationResponse| { &m.device_info_list },
-            |m: &mut RegistrationResponse| { &mut m.device_info_list },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_ip",
-            |m: &RegistrationResponse| { &m.public_ip },
-            |m: &mut RegistrationResponse| { &mut m.public_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_port",
-            |m: &RegistrationResponse| { &m.public_port },
-            |m: &mut RegistrationResponse| { &mut m.public_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_ipv6",
-            |m: &RegistrationResponse| { &m.public_ipv6 },
-            |m: &mut RegistrationResponse| { &mut m.public_ipv6 },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationResponse>(
-            "RegistrationResponse",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for RegistrationResponse {
-    const NAME: &'static str = "RegistrationResponse";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                13 => {
-                    self.virtual_ip = is.read_fixed32()?;
-                },
-                21 => {
-                    self.virtual_gateway = is.read_fixed32()?;
-                },
-                29 => {
-                    self.virtual_netmask = is.read_fixed32()?;
-                },
-                32 => {
-                    self.epoch = is.read_uint32()?;
-                },
-                42 => {
-                    self.device_info_list.push(is.read_message()?);
-                },
-                53 => {
-                    self.public_ip = is.read_fixed32()?;
-                },
-                56 => {
-                    self.public_port = is.read_uint32()?;
-                },
-                66 => {
-                    self.public_ipv6 = is.read_bytes()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if self.virtual_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.virtual_gateway != 0 {
-            my_size += 1 + 4;
-        }
-        if self.virtual_netmask != 0 {
-            my_size += 1 + 4;
-        }
-        if self.epoch != 0 {
-            my_size += ::protobuf::rt::uint32_size(4, self.epoch);
-        }
-        for value in &self.device_info_list {
-            let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
-        };
-        if self.public_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.public_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(7, self.public_port);
-        }
-        if !self.public_ipv6.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(8, &self.public_ipv6);
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if self.virtual_ip != 0 {
-            os.write_fixed32(1, self.virtual_ip)?;
-        }
-        if self.virtual_gateway != 0 {
-            os.write_fixed32(2, self.virtual_gateway)?;
-        }
-        if self.virtual_netmask != 0 {
-            os.write_fixed32(3, self.virtual_netmask)?;
-        }
-        if self.epoch != 0 {
-            os.write_uint32(4, self.epoch)?;
-        }
-        for v in &self.device_info_list {
-            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
-        };
-        if self.public_ip != 0 {
-            os.write_fixed32(6, self.public_ip)?;
-        }
-        if self.public_port != 0 {
-            os.write_uint32(7, self.public_port)?;
-        }
-        if !self.public_ipv6.is_empty() {
-            os.write_bytes(8, &self.public_ipv6)?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> RegistrationResponse {
-        RegistrationResponse::new()
-    }
-
-    fn clear(&mut self) {
-        self.virtual_ip = 0;
-        self.virtual_gateway = 0;
-        self.virtual_netmask = 0;
-        self.epoch = 0;
-        self.device_info_list.clear();
-        self.public_ip = 0;
-        self.public_port = 0;
-        self.public_ipv6.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static RegistrationResponse {
-        static instance: RegistrationResponse = RegistrationResponse {
-            virtual_ip: 0,
-            virtual_gateway: 0,
-            virtual_netmask: 0,
-            epoch: 0,
-            device_info_list: ::std::vec::Vec::new(),
-            public_ip: 0,
-            public_port: 0,
-            public_ipv6: ::std::vec::Vec::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for RegistrationResponse {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("RegistrationResponse").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for RegistrationResponse {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for RegistrationResponse {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:DeviceInfo)
-pub struct DeviceInfo {
-    // message fields
-    // @@protoc_insertion_point(field:DeviceInfo.name)
-    pub name: ::std::string::String,
-    // @@protoc_insertion_point(field:DeviceInfo.virtual_ip)
-    pub virtual_ip: u32,
-    // @@protoc_insertion_point(field:DeviceInfo.device_status)
-    pub device_status: u32,
-    // @@protoc_insertion_point(field:DeviceInfo.client_secret)
-    pub client_secret: bool,
-    // special fields
-    // @@protoc_insertion_point(special_field:DeviceInfo.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a DeviceInfo {
-    fn default() -> &'a DeviceInfo {
-        <DeviceInfo as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl DeviceInfo {
-    pub fn new() -> DeviceInfo {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(4);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "name",
-            |m: &DeviceInfo| { &m.name },
-            |m: &mut DeviceInfo| { &mut m.name },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "virtual_ip",
-            |m: &DeviceInfo| { &m.virtual_ip },
-            |m: &mut DeviceInfo| { &mut m.virtual_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "device_status",
-            |m: &DeviceInfo| { &m.device_status },
-            |m: &mut DeviceInfo| { &mut m.device_status },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "client_secret",
-            |m: &DeviceInfo| { &m.client_secret },
-            |m: &mut DeviceInfo| { &mut m.client_secret },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceInfo>(
-            "DeviceInfo",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for DeviceInfo {
-    const NAME: &'static str = "DeviceInfo";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                10 => {
-                    self.name = is.read_string()?;
-                },
-                21 => {
-                    self.virtual_ip = is.read_fixed32()?;
-                },
-                24 => {
-                    self.device_status = is.read_uint32()?;
-                },
-                32 => {
-                    self.client_secret = is.read_bool()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
-        }
-        if self.virtual_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.device_status != 0 {
-            my_size += ::protobuf::rt::uint32_size(3, self.device_status);
-        }
-        if self.client_secret != false {
-            my_size += 1 + 1;
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if !self.name.is_empty() {
-            os.write_string(1, &self.name)?;
-        }
-        if self.virtual_ip != 0 {
-            os.write_fixed32(2, self.virtual_ip)?;
-        }
-        if self.device_status != 0 {
-            os.write_uint32(3, self.device_status)?;
-        }
-        if self.client_secret != false {
-            os.write_bool(4, self.client_secret)?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> DeviceInfo {
-        DeviceInfo::new()
-    }
-
-    fn clear(&mut self) {
-        self.name.clear();
-        self.virtual_ip = 0;
-        self.device_status = 0;
-        self.client_secret = false;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static DeviceInfo {
-        static instance: DeviceInfo = DeviceInfo {
-            name: ::std::string::String::new(),
-            virtual_ip: 0,
-            device_status: 0,
-            client_secret: false,
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for DeviceInfo {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeviceInfo").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for DeviceInfo {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for DeviceInfo {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:DeviceList)
-pub struct DeviceList {
-    // message fields
-    // @@protoc_insertion_point(field:DeviceList.epoch)
-    pub epoch: u32,
-    // @@protoc_insertion_point(field:DeviceList.device_info_list)
-    pub device_info_list: ::std::vec::Vec<DeviceInfo>,
-    // special fields
-    // @@protoc_insertion_point(special_field:DeviceList.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a DeviceList {
-    fn default() -> &'a DeviceList {
-        <DeviceList as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl DeviceList {
-    pub fn new() -> DeviceList {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(2);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "epoch",
-            |m: &DeviceList| { &m.epoch },
-            |m: &mut DeviceList| { &mut m.epoch },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "device_info_list",
-            |m: &DeviceList| { &m.device_info_list },
-            |m: &mut DeviceList| { &mut m.device_info_list },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceList>(
-            "DeviceList",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for DeviceList {
-    const NAME: &'static str = "DeviceList";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                8 => {
-                    self.epoch = is.read_uint32()?;
-                },
-                18 => {
-                    self.device_info_list.push(is.read_message()?);
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if self.epoch != 0 {
-            my_size += ::protobuf::rt::uint32_size(1, self.epoch);
-        }
-        for value in &self.device_info_list {
-            let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
-        };
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if self.epoch != 0 {
-            os.write_uint32(1, self.epoch)?;
-        }
-        for v in &self.device_info_list {
-            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
-        };
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> DeviceList {
-        DeviceList::new()
-    }
-
-    fn clear(&mut self) {
-        self.epoch = 0;
-        self.device_info_list.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static DeviceList {
-        static instance: DeviceList = DeviceList {
-            epoch: 0,
-            device_info_list: ::std::vec::Vec::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for DeviceList {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeviceList").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for DeviceList {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for DeviceList {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:PunchInfo)
-pub struct PunchInfo {
-    // message fields
-    // @@protoc_insertion_point(field:PunchInfo.public_ip_list)
-    pub public_ip_list: ::std::vec::Vec<u32>,
-    // @@protoc_insertion_point(field:PunchInfo.public_port)
-    pub public_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.public_port_range)
-    pub public_port_range: u32,
-    // @@protoc_insertion_point(field:PunchInfo.nat_type)
-    pub nat_type: ::protobuf::EnumOrUnknown<PunchNatType>,
-    // @@protoc_insertion_point(field:PunchInfo.reply)
-    pub reply: bool,
-    // @@protoc_insertion_point(field:PunchInfo.local_ip)
-    pub local_ip: u32,
-    // @@protoc_insertion_point(field:PunchInfo.local_port)
-    pub local_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.ipv6)
-    pub ipv6: ::std::vec::Vec<u8>,
-    // @@protoc_insertion_point(field:PunchInfo.ipv6_port)
-    pub ipv6_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.tcp_port)
-    pub tcp_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.udp_ports)
-    pub udp_ports: ::std::vec::Vec<u32>,
-    // @@protoc_insertion_point(field:PunchInfo.public_ports)
-    pub public_ports: ::std::vec::Vec<u32>,
-    // special fields
-    // @@protoc_insertion_point(special_field:PunchInfo.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a PunchInfo {
-    fn default() -> &'a PunchInfo {
-        <PunchInfo as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl PunchInfo {
-    pub fn new() -> PunchInfo {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(12);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "public_ip_list",
-            |m: &PunchInfo| { &m.public_ip_list },
-            |m: &mut PunchInfo| { &mut m.public_ip_list },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_port",
-            |m: &PunchInfo| { &m.public_port },
-            |m: &mut PunchInfo| { &mut m.public_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_port_range",
-            |m: &PunchInfo| { &m.public_port_range },
-            |m: &mut PunchInfo| { &mut m.public_port_range },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "nat_type",
-            |m: &PunchInfo| { &m.nat_type },
-            |m: &mut PunchInfo| { &mut m.nat_type },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "reply",
-            |m: &PunchInfo| { &m.reply },
-            |m: &mut PunchInfo| { &mut m.reply },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "local_ip",
-            |m: &PunchInfo| { &m.local_ip },
-            |m: &mut PunchInfo| { &mut m.local_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "local_port",
-            |m: &PunchInfo| { &m.local_port },
-            |m: &mut PunchInfo| { &mut m.local_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "ipv6",
-            |m: &PunchInfo| { &m.ipv6 },
-            |m: &mut PunchInfo| { &mut m.ipv6 },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "ipv6_port",
-            |m: &PunchInfo| { &m.ipv6_port },
-            |m: &mut PunchInfo| { &mut m.ipv6_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "tcp_port",
-            |m: &PunchInfo| { &m.tcp_port },
-            |m: &mut PunchInfo| { &mut m.tcp_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "udp_ports",
-            |m: &PunchInfo| { &m.udp_ports },
-            |m: &mut PunchInfo| { &mut m.udp_ports },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "public_ports",
-            |m: &PunchInfo| { &m.public_ports },
-            |m: &mut PunchInfo| { &mut m.public_ports },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PunchInfo>(
-            "PunchInfo",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for PunchInfo {
-    const NAME: &'static str = "PunchInfo";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                18 => {
-                    is.read_repeated_packed_fixed32_into(&mut self.public_ip_list)?;
-                },
-                21 => {
-                    self.public_ip_list.push(is.read_fixed32()?);
-                },
-                24 => {
-                    self.public_port = is.read_uint32()?;
-                },
-                32 => {
-                    self.public_port_range = is.read_uint32()?;
-                },
-                40 => {
-                    self.nat_type = is.read_enum_or_unknown()?;
-                },
-                48 => {
-                    self.reply = is.read_bool()?;
-                },
-                61 => {
-                    self.local_ip = is.read_fixed32()?;
-                },
-                64 => {
-                    self.local_port = is.read_uint32()?;
-                },
-                74 => {
-                    self.ipv6 = is.read_bytes()?;
-                },
-                80 => {
-                    self.ipv6_port = is.read_uint32()?;
-                },
-                88 => {
-                    self.tcp_port = is.read_uint32()?;
-                },
-                98 => {
-                    is.read_repeated_packed_uint32_into(&mut self.udp_ports)?;
-                },
-                96 => {
-                    self.udp_ports.push(is.read_uint32()?);
-                },
-                106 => {
-                    is.read_repeated_packed_uint32_into(&mut self.public_ports)?;
-                },
-                104 => {
-                    self.public_ports.push(is.read_uint32()?);
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        my_size += 5 * self.public_ip_list.len() as u64;
-        if self.public_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(3, self.public_port);
-        }
-        if self.public_port_range != 0 {
-            my_size += ::protobuf::rt::uint32_size(4, self.public_port_range);
-        }
-        if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) {
-            my_size += ::protobuf::rt::int32_size(5, self.nat_type.value());
-        }
-        if self.reply != false {
-            my_size += 1 + 1;
-        }
-        if self.local_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.local_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(8, self.local_port);
-        }
-        if !self.ipv6.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(9, &self.ipv6);
-        }
-        if self.ipv6_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(10, self.ipv6_port);
-        }
-        if self.tcp_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(11, self.tcp_port);
-        }
-        for value in &self.udp_ports {
-            my_size += ::protobuf::rt::uint32_size(12, *value);
-        };
-        for value in &self.public_ports {
-            my_size += ::protobuf::rt::uint32_size(13, *value);
-        };
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        for v in &self.public_ip_list {
-            os.write_fixed32(2, *v)?;
-        };
-        if self.public_port != 0 {
-            os.write_uint32(3, self.public_port)?;
-        }
-        if self.public_port_range != 0 {
-            os.write_uint32(4, self.public_port_range)?;
-        }
-        if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) {
-            os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.nat_type))?;
-        }
-        if self.reply != false {
-            os.write_bool(6, self.reply)?;
-        }
-        if self.local_ip != 0 {
-            os.write_fixed32(7, self.local_ip)?;
-        }
-        if self.local_port != 0 {
-            os.write_uint32(8, self.local_port)?;
-        }
-        if !self.ipv6.is_empty() {
-            os.write_bytes(9, &self.ipv6)?;
-        }
-        if self.ipv6_port != 0 {
-            os.write_uint32(10, self.ipv6_port)?;
-        }
-        if self.tcp_port != 0 {
-            os.write_uint32(11, self.tcp_port)?;
-        }
-        for v in &self.udp_ports {
-            os.write_uint32(12, *v)?;
-        };
-        for v in &self.public_ports {
-            os.write_uint32(13, *v)?;
-        };
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> PunchInfo {
-        PunchInfo::new()
-    }
-
-    fn clear(&mut self) {
-        self.public_ip_list.clear();
-        self.public_port = 0;
-        self.public_port_range = 0;
-        self.nat_type = ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric);
-        self.reply = false;
-        self.local_ip = 0;
-        self.local_port = 0;
-        self.ipv6.clear();
-        self.ipv6_port = 0;
-        self.tcp_port = 0;
-        self.udp_ports.clear();
-        self.public_ports.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static PunchInfo {
-        static instance: PunchInfo = PunchInfo {
-            public_ip_list: ::std::vec::Vec::new(),
-            public_port: 0,
-            public_port_range: 0,
-            nat_type: ::protobuf::EnumOrUnknown::from_i32(0),
-            reply: false,
-            local_ip: 0,
-            local_port: 0,
-            ipv6: ::std::vec::Vec::new(),
-            ipv6_port: 0,
-            tcp_port: 0,
-            udp_ports: ::std::vec::Vec::new(),
-            public_ports: ::std::vec::Vec::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for PunchInfo {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("PunchInfo").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for PunchInfo {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for PunchInfo {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:ClientStatusInfo)
-pub struct ClientStatusInfo {
-    // message fields
-    // @@protoc_insertion_point(field:ClientStatusInfo.source)
-    pub source: u32,
-    // @@protoc_insertion_point(field:ClientStatusInfo.p2p_list)
-    pub p2p_list: ::std::vec::Vec<RouteItem>,
-    // @@protoc_insertion_point(field:ClientStatusInfo.up_stream)
-    pub up_stream: u64,
-    // @@protoc_insertion_point(field:ClientStatusInfo.down_stream)
-    pub down_stream: u64,
-    // @@protoc_insertion_point(field:ClientStatusInfo.nat_type)
-    pub nat_type: ::protobuf::EnumOrUnknown<PunchNatType>,
-    // special fields
-    // @@protoc_insertion_point(special_field:ClientStatusInfo.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a ClientStatusInfo {
-    fn default() -> &'a ClientStatusInfo {
-        <ClientStatusInfo as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl ClientStatusInfo {
-    pub fn new() -> ClientStatusInfo {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        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::<_, _>(
-            "source",
-            |m: &ClientStatusInfo| { &m.source },
-            |m: &mut ClientStatusInfo| { &mut m.source },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "p2p_list",
-            |m: &ClientStatusInfo| { &m.p2p_list },
-            |m: &mut ClientStatusInfo| { &mut m.p2p_list },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "up_stream",
-            |m: &ClientStatusInfo| { &m.up_stream },
-            |m: &mut ClientStatusInfo| { &mut m.up_stream },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "down_stream",
-            |m: &ClientStatusInfo| { &m.down_stream },
-            |m: &mut ClientStatusInfo| { &mut m.down_stream },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "nat_type",
-            |m: &ClientStatusInfo| { &m.nat_type },
-            |m: &mut ClientStatusInfo| { &mut m.nat_type },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ClientStatusInfo>(
-            "ClientStatusInfo",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for ClientStatusInfo {
-    const NAME: &'static str = "ClientStatusInfo";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                13 => {
-                    self.source = is.read_fixed32()?;
-                },
-                18 => {
-                    self.p2p_list.push(is.read_message()?);
-                },
-                24 => {
-                    self.up_stream = is.read_uint64()?;
-                },
-                32 => {
-                    self.down_stream = is.read_uint64()?;
-                },
-                40 => {
-                    self.nat_type = is.read_enum_or_unknown()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if self.source != 0 {
-            my_size += 1 + 4;
-        }
-        for value in &self.p2p_list {
-            let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
-        };
-        if self.up_stream != 0 {
-            my_size += ::protobuf::rt::uint64_size(3, self.up_stream);
-        }
-        if self.down_stream != 0 {
-            my_size += ::protobuf::rt::uint64_size(4, self.down_stream);
-        }
-        if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) {
-            my_size += ::protobuf::rt::int32_size(5, self.nat_type.value());
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if self.source != 0 {
-            os.write_fixed32(1, self.source)?;
-        }
-        for v in &self.p2p_list {
-            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
-        };
-        if self.up_stream != 0 {
-            os.write_uint64(3, self.up_stream)?;
-        }
-        if self.down_stream != 0 {
-            os.write_uint64(4, self.down_stream)?;
-        }
-        if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) {
-            os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.nat_type))?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> ClientStatusInfo {
-        ClientStatusInfo::new()
-    }
-
-    fn clear(&mut self) {
-        self.source = 0;
-        self.p2p_list.clear();
-        self.up_stream = 0;
-        self.down_stream = 0;
-        self.nat_type = ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric);
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static ClientStatusInfo {
-        static instance: ClientStatusInfo = ClientStatusInfo {
-            source: 0,
-            p2p_list: ::std::vec::Vec::new(),
-            up_stream: 0,
-            down_stream: 0,
-            nat_type: ::protobuf::EnumOrUnknown::from_i32(0),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for ClientStatusInfo {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("ClientStatusInfo").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for ClientStatusInfo {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for ClientStatusInfo {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:RouteItem)
-pub struct RouteItem {
-    // message fields
-    // @@protoc_insertion_point(field:RouteItem.next_ip)
-    pub next_ip: u32,
-    // special fields
-    // @@protoc_insertion_point(special_field:RouteItem.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a RouteItem {
-    fn default() -> &'a RouteItem {
-        <RouteItem as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl RouteItem {
-    pub fn new() -> RouteItem {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(1);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "next_ip",
-            |m: &RouteItem| { &m.next_ip },
-            |m: &mut RouteItem| { &mut m.next_ip },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RouteItem>(
-            "RouteItem",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for RouteItem {
-    const NAME: &'static str = "RouteItem";
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
-        while let Some(tag) = is.read_raw_tag_or_eof()? {
-            match tag {
-                13 => {
-                    self.next_ip = is.read_fixed32()?;
-                },
-                tag => {
-                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u64 {
-        let mut my_size = 0;
-        if self.next_ip != 0 {
-            my_size += 1 + 4;
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
-        self.special_fields.cached_size().set(my_size as u32);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
-        if self.next_ip != 0 {
-            os.write_fixed32(1, self.next_ip)?;
-        }
-        os.write_unknown_fields(self.special_fields.unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn special_fields(&self) -> &::protobuf::SpecialFields {
-        &self.special_fields
-    }
-
-    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
-        &mut self.special_fields
-    }
-
-    fn new() -> RouteItem {
-        RouteItem::new()
-    }
-
-    fn clear(&mut self) {
-        self.next_ip = 0;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static RouteItem {
-        static instance: RouteItem = RouteItem {
-            next_ip: 0,
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for RouteItem {
-    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().message_by_package_relative_name("RouteItem").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for RouteItem {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for RouteItem {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
-// @@protoc_insertion_point(enum:PunchNatType)
-pub enum PunchNatType {
-    // @@protoc_insertion_point(enum_value:PunchNatType.Symmetric)
-    Symmetric = 0,
-    // @@protoc_insertion_point(enum_value:PunchNatType.Cone)
-    Cone = 1,
-}
-
-impl ::protobuf::Enum for PunchNatType {
-    const NAME: &'static str = "PunchNatType";
-
-    fn value(&self) -> i32 {
-        *self as i32
-    }
-
-    fn from_i32(value: i32) -> ::std::option::Option<PunchNatType> {
-        match value {
-            0 => ::std::option::Option::Some(PunchNatType::Symmetric),
-            1 => ::std::option::Option::Some(PunchNatType::Cone),
-            _ => ::std::option::Option::None
-        }
-    }
-
-    const VALUES: &'static [PunchNatType] = &[
-        PunchNatType::Symmetric,
-        PunchNatType::Cone,
-    ];
-}
-
-impl ::protobuf::EnumFull for PunchNatType {
-    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
-        descriptor.get(|| file_descriptor().enum_by_package_relative_name("PunchNatType").unwrap()).clone()
-    }
-
-    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
-        let index = *self as usize;
-        Self::enum_descriptor().value_by_index(index)
-    }
-}
-
-impl ::std::default::Default for PunchNatType {
-    fn default() -> Self {
-        PunchNatType::Symmetric
-    }
-}
-
-impl PunchNatType {
-    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
-        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<PunchNatType>("PunchNatType")
-    }
-}
-
-static file_descriptor_proto_data: &'static [u8] = b"\
-    \n\rmessage.proto\"D\n\x10HandshakeRequest\x12\x18\n\x07version\x18\x01\
-    \x20\x01(\tR\x07version\x12\x16\n\x06secret\x18\x02\x20\x01(\x08R\x06sec\
-    ret\"\x83\x01\n\x11HandshakeResponse\x12\x18\n\x07version\x18\x01\x20\
-    \x01(\tR\x07version\x12\x16\n\x06secret\x18\x02\x20\x01(\x08R\x06secret\
-    \x12\x1d\n\npublic_key\x18\x03\x20\x01(\x0cR\tpublicKey\x12\x1d\n\nkey_f\
-    inger\x18\x04\x20\x01(\tR\tkeyFinger\"@\n\x16SecretHandshakeRequest\x12\
-    \x14\n\x05token\x18\x01\x20\x01(\tR\x05token\x12\x10\n\x03key\x18\x02\
-    \x20\x01(\x0cR\x03key\"\xfb\x01\n\x13RegistrationRequest\x12\x14\n\x05to\
-    ken\x18\x01\x20\x01(\tR\x05token\x12\x1b\n\tdevice_id\x18\x02\x20\x01(\t\
-    R\x08deviceId\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\x17\n\
-    \x07is_fast\x18\x04\x20\x01(\x08R\x06isFast\x12\x18\n\x07version\x18\x05\
-    \x20\x01(\tR\x07version\x12\x1d\n\nvirtual_ip\x18\x06\x20\x01(\x07R\tvir\
-    tualIp\x12&\n\x0fallow_ip_change\x18\x07\x20\x01(\x08R\rallowIpChange\
-    \x12#\n\rclient_secret\x18\x08\x20\x01(\x08R\x0cclientSecret\"\xb3\x02\n\
-    \x14RegistrationResponse\x12\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvi\
-    rtualIp\x12'\n\x0fvirtual_gateway\x18\x02\x20\x01(\x07R\x0evirtualGatewa\
-    y\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.DeviceInfoR\x0edeviceInfoList\x12\x1b\n\tpubl\
-    ic_ip\x18\x06\x20\x01(\x07R\x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\
-    \x20\x01(\rR\npublicPort\x12\x1f\n\x0bpublic_ipv6\x18\x08\x20\x01(\x0cR\
-    \npublicIpv6\"\x89\x01\n\nDeviceInfo\x12\x12\n\x04name\x18\x01\x20\x01(\
-    \tR\x04name\x12\x1d\n\nvirtual_ip\x18\x02\x20\x01(\x07R\tvirtualIp\x12#\
-    \n\rdevice_status\x18\x03\x20\x01(\rR\x0cdeviceStatus\x12#\n\rclient_sec\
-    ret\x18\x04\x20\x01(\x08R\x0cclientSecret\"Y\n\nDeviceList\x12\x14\n\x05\
-    epoch\x18\x01\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x02\
-    \x20\x03(\x0b2\x0b.DeviceInfoR\x0edeviceInfoList\"\x84\x03\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.PunchNatTypeR\x07natType\x12\x14\n\x05reply\x18\x06\x20\
-    \x01(\x08R\x05reply\x12\x19\n\x08local_ip\x18\x07\x20\x01(\x07R\x07local\
-    Ip\x12\x1d\n\nlocal_port\x18\x08\x20\x01(\rR\tlocalPort\x12\x12\n\x04ipv\
-    6\x18\t\x20\x01(\x0cR\x04ipv6\x12\x1b\n\tipv6_port\x18\n\x20\x01(\rR\x08\
-    ipv6Port\x12\x19\n\x08tcp_port\x18\x0b\x20\x01(\rR\x07tcpPort\x12\x1b\n\
-    \tudp_ports\x18\x0c\x20\x03(\rR\x08udpPorts\x12!\n\x0cpublic_ports\x18\r\
-    \x20\x03(\rR\x0bpublicPorts\"\xb9\x01\n\x10ClientStatusInfo\x12\x16\n\
-    \x06source\x18\x01\x20\x01(\x07R\x06source\x12%\n\x08p2p_list\x18\x02\
-    \x20\x03(\x0b2\n.RouteItemR\x07p2pList\x12\x1b\n\tup_stream\x18\x03\x20\
-    \x01(\x04R\x08upStream\x12\x1f\n\x0bdown_stream\x18\x04\x20\x01(\x04R\nd\
-    ownStream\x12(\n\x08nat_type\x18\x05\x20\x01(\x0e2\r.PunchNatTypeR\x07na\
-    tType\"$\n\tRouteItem\x12\x17\n\x07next_ip\x18\x01\x20\x01(\x07R\x06next\
-    Ip*'\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
-fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
-    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
-    file_descriptor_proto_lazy.get(|| {
-        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
-    })
-}
-
-/// `FileDescriptor` object which allows dynamic access to files
-pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
-    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
-    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
-    file_descriptor.get(|| {
-        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
-            let mut deps = ::std::vec::Vec::with_capacity(0);
-            let mut messages = ::std::vec::Vec::with_capacity(10);
-            messages.push(HandshakeRequest::generated_message_descriptor_data());
-            messages.push(HandshakeResponse::generated_message_descriptor_data());
-            messages.push(SecretHandshakeRequest::generated_message_descriptor_data());
-            messages.push(RegistrationRequest::generated_message_descriptor_data());
-            messages.push(RegistrationResponse::generated_message_descriptor_data());
-            messages.push(DeviceInfo::generated_message_descriptor_data());
-            messages.push(DeviceList::generated_message_descriptor_data());
-            messages.push(PunchInfo::generated_message_descriptor_data());
-            messages.push(ClientStatusInfo::generated_message_descriptor_data());
-            messages.push(RouteItem::generated_message_descriptor_data());
-            let mut enums = ::std::vec::Vec::with_capacity(1);
-            enums.push(PunchNatType::generated_enum_descriptor_data());
-            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
-                file_descriptor_proto(),
-                deps,
-                messages,
-                enums,
-            )
-        });
-        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
-    })
-}
@@ -1,3 +0,0 @@
-// @generated
-
-pub mod message;
@@ -5,14 +5,20 @@ use std::{fmt, io};
 pub enum Protocol {
    /// ping请求
    /*
-     0                   1                   2                   3
-     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-    |              time             |             echo              |
-    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         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
+        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+        |              time                          |                    echo                        |
+        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    */
    Ping,
-    /// 维持连接，内容同ping
+    /*
+         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
+        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+        |              time                          |                    echo                        |
+        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    */
    Pong,
    /// 打洞请求
    PunchRequest,
@@ -85,8 +91,8 @@ pub type PongPacket<B> = PingPacket<B>;
 impl<B: AsRef<[u8]>> PingPacket<B> {
    pub fn new(buffer: B) -> io::Result<PingPacket<B>> {
        let len = buffer.as_ref().len();
-        if len != 4 {
-            return Err(io::Error::new(io::ErrorKind::InvalidData, "len != 4"));
+        if len < 4 {
+            return Err(io::Error::new(io::ErrorKind::InvalidData, "len < 4"));
        }
        Ok(PingPacket { buffer })
    }
@@ -126,8 +132,8 @@ pub struct AddrPacket<B> {
 impl<B: AsRef<[u8]>> AddrPacket<B> {
    pub fn new(buffer: B) -> io::Result<AddrPacket<B>> {
        let len = buffer.as_ref().len();
-        if len != 6 {
-            return Err(io::Error::new(io::ErrorKind::InvalidData, "len != 6"));
+        if len < 6 {
+            return Err(io::Error::new(io::ErrorKind::InvalidData, "len < 6"));
        }
        Ok(AddrPacket { buffer })
    }
@@ -0,0 +1,141 @@
+/* 扩展协议
+  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
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                          扩展数据(n)                                          |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                         扩展数据(n)                                 |          type(8)        |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ 注：扩展数据的长度由type决定
+*/
+
+use anyhow::anyhow;
+use std::io;
+
+use crate::protocol::NetPacket;
+
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum ExtensionTailType {
+    Compression,
+    Unknown(u8),
+}
+
+impl From<u8> for ExtensionTailType {
+    fn from(value: u8) -> Self {
+        if value == 0 {
+            ExtensionTailType::Compression
+        } else {
+            ExtensionTailType::Unknown(value)
+        }
+    }
+}
+
+pub enum ExtensionTailPacket<B> {
+    Compression(CompressionExtensionTail<B>),
+    Unknown,
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> NetPacket<B> {
+    /// 分离尾部数据
+    pub fn split_tail_packet(&mut self) -> anyhow::Result<ExtensionTailPacket<&[u8]>> {
+        if self.is_extension() {
+            let payload = self.payload();
+            if let Some(v) = payload.last() {
+                return match ExtensionTailType::from(*v) {
+                    ExtensionTailType::Compression => {
+                        let data_len = self.data_len - 4;
+                        self.set_data_len(data_len)?;
+                        self.set_extension_flag(false);
+                        Ok(ExtensionTailPacket::Compression(
+                            CompressionExtensionTail::new(
+                                &self.raw_buffer()[data_len..data_len + 4],
+                            ),
+                        ))
+                    }
+                    ExtensionTailType::Unknown(e) => Err(anyhow!("unknown extension {}", e)),
+                };
+            }
+        }
+        Err(anyhow!("not extension"))
+    }
+    /// 追加压缩扩展
+    pub fn append_compression_extension_tail(
+        &mut self,
+    ) -> io::Result<CompressionExtensionTail<&mut [u8]>> {
+        let len = self.data_len;
+        //增加数据长度
+        self.set_data_len(self.data_len + 4)?;
+        self.set_extension_flag(true);
+        let mut tail = CompressionExtensionTail::new(&mut self.buffer_mut()[len..]);
+        tail.init();
+        return Ok(tail);
+    }
+}
+
+/* 扩展协议
+  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
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |     algorithm(8)     |                                            |          type(8)        |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ 注：扩展数据的长度由type决定
+*/
+/// 压缩扩展
+pub struct CompressionExtensionTail<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> CompressionExtensionTail<B> {
+    pub fn new(buffer: B) -> CompressionExtensionTail<B> {
+        assert_eq!(buffer.as_ref().len(), 4);
+        CompressionExtensionTail { buffer }
+    }
+}
+
+impl<B: AsRef<[u8]>> CompressionExtensionTail<B> {
+    pub fn algorithm(&self) -> CompressionAlgorithm {
+        self.buffer.as_ref()[0].into()
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> CompressionExtensionTail<B> {
+    pub fn init(&mut self) {
+        self.buffer.as_mut().fill(0);
+    }
+    pub fn set_algorithm(&mut self, algorithm: CompressionAlgorithm) {
+        self.buffer.as_mut()[0] = algorithm.into()
+    }
+}
+
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum CompressionAlgorithm {
+    #[cfg(feature = "lz4_compress")]
+    Lz4,
+    #[cfg(feature = "zstd_compress")]
+    Zstd,
+    Unknown(u8),
+}
+
+impl From<u8> for CompressionAlgorithm {
+    fn from(value: u8) -> Self {
+        match value {
+            #[cfg(feature = "lz4_compress")]
+            1 => CompressionAlgorithm::Lz4,
+            #[cfg(feature = "zstd_compress")]
+            2 => CompressionAlgorithm::Zstd,
+            v => CompressionAlgorithm::Unknown(v),
+        }
+    }
+}
+
+impl From<CompressionAlgorithm> for u8 {
+    fn from(value: CompressionAlgorithm) -> Self {
+        match value {
+            #[cfg(feature = "lz4_compress")]
+            CompressionAlgorithm::Lz4 => 1,
+            #[cfg(feature = "zstd_compress")]
+            CompressionAlgorithm::Zstd => 2,
+            CompressionAlgorithm::Unknown(val) => val,
+        }
+    }
+}
@@ -21,20 +21,22 @@ pub const HEAD_LEN: usize = 12;
 pub mod body;
 pub mod control_packet;
 pub mod error_packet;
+pub mod extension;
 pub mod ip_turn_packet;
 pub mod other_turn_packet;
 pub mod service_packet;

 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
 pub enum Version {
-    V1,
+    V2,
    Unknown(u8),
 }

 impl From<u8> for Version {
    fn from(value: u8) -> Self {
        match value {
-            1 => Version::V1,
+            // 版本从2开始，用于和stun协议的binging响应区分开
+            2 => Version::V2,
            val => Version::Unknown(val),
        }
    }
@@ -43,7 +45,7 @@ impl From<u8> for Version {
 impl Into<u8> for Version {
    fn into(self) -> u8 {
        match self {
-            Version::V1 => 1,
+            Version::V2 => 2,
            Version::Unknown(val) => val,
        }
    }
@@ -100,6 +102,10 @@ pub struct NetPacket<B> {
 }

 impl<B: AsRef<[u8]>> NetPacket<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        let data_len = buffer.as_ref().len();
+        Self { data_len, buffer }
+    }
    pub fn new(buffer: B) -> io::Result<NetPacket<B>> {
        let data_len = buffer.as_ref().len();
        Self::new0(data_len, buffer)
@@ -157,6 +163,10 @@ impl<B: AsRef<[u8]>> NetPacket<B> {
    pub fn is_gateway(&self) -> bool {
        self.buffer.as_ref()[0] & 0x40 == 0x40
    }
+    /// 扩展协议
+    pub fn is_extension(&self) -> bool {
+        self.buffer.as_ref()[0] & 0x20 == 0x20
+    }
    pub fn version(&self) -> Version {
        Version::from(self.buffer.as_ref()[0] & 0x0F)
    }
@@ -189,6 +199,9 @@ impl<B: AsRef<[u8]>> NetPacket<B> {
 }

 impl<B: AsRef<[u8]> + AsMut<[u8]>> NetPacket<B> {
+    pub fn head_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer.as_mut()[..12]
+    }
    pub fn buffer_mut(&mut self) -> &mut [u8] {
        &mut self.buffer.as_mut()[..self.data_len]
    }
@@ -207,8 +220,15 @@ impl<B: AsRef<[u8]> + AsMut<[u8]>> NetPacket<B> {
            self.buffer.as_mut()[0] = self.buffer.as_ref()[0] & 0xBF
        };
    }
-    pub fn set_version(&mut self, version: Version) {
-        let v: u8 = version.into();
+    pub fn set_extension_flag(&mut self, is_extension: bool) {
+        if is_extension {
+            self.buffer.as_mut()[0] = self.buffer.as_ref()[0] | 0x20
+        } else {
+            self.buffer.as_mut()[0] = self.buffer.as_ref()[0] & 0xDF
+        };
+    }
+    pub fn set_default_version(&mut self) {
+        let v: u8 = Version::V2.into();
        self.buffer.as_mut()[0] = (self.buffer.as_ref()[0] & 0xF0) | (0x0F & v);
    }
    pub fn set_protocol(&mut self, protocol: Protocol) {
@@ -263,6 +283,10 @@ impl<B: AsRef<[u8]> + AsMut<[u8]>> NetPacket<B> {
        self.data_len = data_len;
        Ok(())
    }
+    pub fn set_payload_len(&mut self, payload_len: usize) -> io::Result<()> {
+        let data_len = HEAD_LEN + payload_len;
+        self.set_data_len(data_len)
+    }
    pub fn set_data_len_max(&mut self) {
        self.data_len = self.buffer.as_ref().len();
    }
@@ -5,7 +5,7 @@ pub enum Protocol {
    /// 注册响应
    RegistrationResponse,
    /// 拉取设备列表
-    PollDeviceList,
+    PullDeviceList,
    /// 推送设备列表
    PushDeviceList,
    /// 和服务端握手
@@ -23,7 +23,7 @@ impl From<u8> for Protocol {
        match value {
            1 => Self::RegistrationRequest,
            2 => Self::RegistrationResponse,
-            3 => Self::PollDeviceList,
+            3 => Self::PullDeviceList,
            4 => Self::PushDeviceList,
            5 => Self::HandshakeRequest,
            6 => Self::HandshakeResponse,
@@ -40,7 +40,7 @@ impl Into<u8> for Protocol {
        match self {
            Self::RegistrationRequest => 1,
            Self::RegistrationResponse => 2,
-            Self::PollDeviceList => 3,
+            Self::PullDeviceList => 3,
            Self::PushDeviceList => 4,
            Self::HandshakeRequest => 5,
            Self::HandshakeResponse => 6,
@@ -0,0 +1,64 @@
+use std::io;
+use std::sync::Arc;
+use tun::device::IFace;
+use tun::Device;
+
+#[cfg(any(target_os = "windows", target_os = "linux"))]
+const DEFAULT_TUN_NAME: &str = "vnt-tun";
+#[cfg(target_os = "windows")]
+const DEFAULT_TAP_NAME: &str = "vnt-tap";
+
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+pub fn create_device(config: &crate::core::Config) -> io::Result<Arc<Device>> {
+    #[cfg(target_os = "windows")]
+    let default_name: &str = if config.tap {
+        DEFAULT_TAP_NAME
+    } else {
+        DEFAULT_TUN_NAME
+    };
+    #[cfg(target_os = "linux")]
+    let device = {
+        let device_name = config
+            .device_name
+            .clone()
+            .unwrap_or(DEFAULT_TUN_NAME.to_string());
+        if &device_name == DEFAULT_TUN_NAME {
+            delete_device(DEFAULT_TUN_NAME);
+        }
+        Arc::new(Device::new(Some(device_name))?)
+    };
+    #[cfg(target_os = "macos")]
+    let device = Arc::new(Device::new(config.device_name.clone())?);
+    #[cfg(target_os = "windows")]
+    let device = Arc::new(Device::new(
+        config
+            .device_name
+            .clone()
+            .unwrap_or(default_name.to_string()),
+        config.tap,
+    )?);
+    let mtu = config.mtu.unwrap_or_else(|| {
+        if config.password.is_none() {
+            1450
+        } else {
+            1410
+        }
+    });
+    device.set_mtu(mtu)?;
+    Ok(device)
+}
+
+#[cfg(target_os = "linux")]
+fn delete_device(name: &str) {
+    // 删除默认网卡，此操作有风险，后续可能去除
+    use std::process::Command;
+    let cmd = format!("ip link delete {}", name);
+    let delete_tun = Command::new("sh")
+        .arg("-c")
+        .arg(&cmd)
+        .output()
+        .expect("sh exec error!");
+    if !delete_tun.status.success() {
+        log::warn!("删除网卡失败:{:?}", delete_tun);
+    }
+}
@@ -1,70 +1,6 @@
-use std::io;
-use std::sync::Arc;
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+pub use create_device::create_device;

-use tun::device::IFace;
-use tun::Device;
-
-use crate::core::Config;
-#[cfg(any(target_os = "windows", target_os = "linux"))]
-const DEFAULT_TUN_NAME: &str = "vnt-tun";
-#[cfg(any(target_os = "windows", target_os = "linux"))]
-const DEFAULT_TAP_NAME: &str = "vnt-tap";
-
-pub fn create_device(config: &Config) -> io::Result<Arc<Device>> {
-    #[cfg(any(target_os = "windows", target_os = "linux"))]
-    let default_name: &str = if config.tap {
-        DEFAULT_TAP_NAME
-    } else {
-        DEFAULT_TUN_NAME
-    };
-    #[cfg(target_os = "linux")]
-    let device = {
-        let device_name = config
-            .device_name
-            .clone()
-            .unwrap_or(default_name.to_string());
-        if &device_name == default_name {
-            delete_device(default_name);
-        }
-        Arc::new(Device::new(Some(device_name), config.tap)?)
-    };
-    #[cfg(target_os = "macos")]
-    let device = Arc::new(Device::new(config.device_name.clone())?);
-    #[cfg(target_os = "windows")]
-    let device = Arc::new(Device::new(
-        config
-            .device_name
-            .clone()
-            .unwrap_or(default_name.to_string()),
-        config.tap,
-    )?);
-    #[cfg(target_os = "android")]
-    let device = Arc::new(Device::new(config.device_fd as _)?);
-    #[cfg(not(target_os = "android"))]
-    {
-        let mtu = config.mtu.unwrap_or_else(|| {
-            if config.password.is_none() {
-                1450
-            } else {
-                1410
-            }
-        });
-        device.set_mtu(mtu)?;
-    }
-    Ok(device)
-}
-
-#[cfg(target_os = "linux")]
-fn delete_device(name: &str) {
-    // 删除默认网卡，此操作有风险，后续可能去除
-    use std::process::Command;
-    let cmd = format!("ip link delete {}", name);
-    let delete_tun = Command::new("sh")
-        .arg("-c")
-        .arg(&cmd)
-        .output()
-        .expect("sh exec error!");
-    if !delete_tun.status.success() {
-        log::warn!("删除网卡失败:{:?}", delete_tun);
-    }
-}
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+mod create_device;
+pub mod tun_create_helper;
@@ -0,0 +1,138 @@
+use std::io;
+use std::sync::Arc;
+
+use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;
+
+use tun::Device;
+
+use crate::channel::context::ChannelContext;
+use crate::cipher::Cipher;
+use crate::compression::Compressor;
+use crate::external_route::ExternalRoute;
+use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
+#[cfg(feature = "ip_proxy")]
+use crate::ip_proxy::IpProxyMap;
+use crate::util::{SingleU64Adder, StopManager};
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+#[repr(transparent)]
+#[derive(Clone)]
+pub struct DeviceAdapter {
+    tun: Arc<Device>,
+}
+impl DeviceAdapter {
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+    pub fn new(tun: Arc<Device>) -> Self {
+        Self { tun }
+    }
+    #[cfg(target_os = "android")]
+    pub fn new(tun_device_helper: TunDeviceHelper) -> Self {
+        Self {
+            tun: Arc::new(AtomicCell::new(-1 as _)),
+            tun_device_helper,
+        }
+    }
+}
+#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+impl std::ops::Deref for DeviceAdapter {
+    type Target = Arc<Device>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.tun
+    }
+}
+
+#[cfg(target_os = "android")]
+#[derive(Clone)]
+pub struct DeviceAdapter {
+    tun: Arc<AtomicCell<std::os::fd::RawFd>>,
+    tun_device_helper: TunDeviceHelper,
+}
+#[cfg(target_os = "android")]
+impl DeviceAdapter {
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        let fd = self.tun.load();
+        tun::Fd(fd).write(buf)
+    }
+    pub fn start(&self, fd: std::os::fd::RawFd) -> io::Result<()> {
+        //安卓端fd是由外部释放的，所以这里这么搞免得加锁
+        self.tun_device_helper.start(Arc::new(Device::new(fd)?))?;
+        self.tun.store(fd);
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct TunDeviceHelper {
+    inner: Arc<AtomicCell<Option<TunDeviceHelperInner>>>,
+}
+
+struct TunDeviceHelperInner {
+    stop_manager: StopManager,
+    context: ChannelContext,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    ip_route: ExternalRoute,
+    #[cfg(feature = "ip_proxy")]
+    ip_proxy_map: Option<IpProxyMap>,
+    client_cipher: Cipher,
+    server_cipher: Cipher,
+    parallel: usize,
+    up_counter: SingleU64Adder,
+    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    compressor: Compressor,
+}
+
+impl TunDeviceHelper {
+    pub fn new(
+        stop_manager: StopManager,
+        context: ChannelContext,
+        current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+        ip_route: ExternalRoute,
+        #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
+        client_cipher: Cipher,
+        server_cipher: Cipher,
+        parallel: usize,
+        up_counter: SingleU64Adder,
+        device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+        compressor: Compressor,
+    ) -> Self {
+        Self {
+            inner: Arc::new(AtomicCell::new(Some(TunDeviceHelperInner {
+                stop_manager,
+                context,
+                current_device,
+                ip_route,
+                #[cfg(feature = "ip_proxy")]
+                ip_proxy_map,
+                client_cipher,
+                server_cipher,
+                parallel,
+                up_counter,
+                device_list,
+                compressor,
+            }))),
+        }
+    }
+    pub fn start(&self, device: Arc<Device>) -> io::Result<()> {
+        if let Some(inner) = self.inner.take() {
+            crate::handle::tun_tap::tun_handler::start(
+                inner.stop_manager,
+                inner.context,
+                device,
+                inner.current_device,
+                inner.ip_route,
+                #[cfg(feature = "ip_proxy")]
+                inner.ip_proxy_map,
+                inner.client_cipher,
+                inner.server_cipher,
+                inner.parallel,
+                inner.up_counter,
+                inner.device_list,
+                inner.compressor,
+            )?;
+            Ok(())
+        } else {
+            Err(io::Error::new(io::ErrorKind::Other, "Repeated start"))
+        }
+    }
+}
@@ -0,0 +1,288 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs, UdpSocket};
+use std::str::FromStr;
+use std::time::Duration;
+use std::{io, thread};
+
+use anyhow::Context;
+use dns_parser::{Builder, Packet, QueryClass, QueryType, RData, ResponseCode};
+
+thread_local! {
+    static HISTORY: RefCell<HashMap<SocketAddr,usize>> = RefCell::new(HashMap::new());
+}
+
+/// 保留一个地址使用记录，使用过的地址后续不再选中，直到地址全使用过
+pub fn address_choose(addrs: Vec<SocketAddr>) -> anyhow::Result<SocketAddr> {
+    HISTORY.with(|history| {
+        let mut available = Vec::new();
+        for x in &addrs {
+            let num = history.borrow().get(x).map_or(0, |v| *v);
+            if num < 3 {
+                available.push(*x);
+            }
+        }
+        if available.is_empty() {
+            available = addrs;
+            history.borrow_mut().clear();
+        }
+        let addr = address_choose0(available)?;
+        history
+            .borrow_mut()
+            .entry(addr)
+            .and_modify(|v| {
+                *v += 1;
+            })
+            .or_insert(1);
+        Ok(addr)
+    })
+}
+
+/// 后续实现选择延迟最低的可用地址，需要服务端配合
+/// 现在是选择第一个地址，优先ipv6
+fn address_choose0(addrs: Vec<SocketAddr>) -> anyhow::Result<SocketAddr> {
+    let v4: Vec<SocketAddr> = addrs.iter().filter(|v| v.is_ipv4()).copied().collect();
+    let v6: Vec<SocketAddr> = addrs.iter().filter(|v| v.is_ipv6()).copied().collect();
+    let check_addr = |addrs: &Vec<SocketAddr>| -> anyhow::Result<SocketAddr> {
+        let mut err = Vec::new();
+        if !addrs.is_empty() {
+            let udp = if addrs[0].is_ipv6() {
+                UdpSocket::bind("[::]:0")?
+            } else {
+                UdpSocket::bind("0.0.0.0:0")?
+            };
+            for addr in addrs {
+                if let Err(e) = udp.connect(addr) {
+                    err.push((*addr, e));
+                } else {
+                    return Ok(*addr);
+                }
+            }
+        }
+        Err(anyhow::anyhow!("Unable to connect to address {:?}", err))
+    };
+    if v6.is_empty() {
+        return check_addr(&v4);
+    }
+    if v4.is_empty() {
+        return check_addr(&v6);
+    }
+    match check_addr(&v6) {
+        Ok(addr) => Ok(addr),
+        Err(e1) => match check_addr(&v4) {
+            Ok(addr) => Ok(addr),
+            Err(e2) => Err(anyhow::anyhow!("{} , {}", e1, e2)),
+        },
+    }
+}
+
+pub fn dns_query_all(
+    domain: &str,
+    mut name_servers: Vec<String>,
+) -> anyhow::Result<Vec<SocketAddr>> {
+    match SocketAddr::from_str(domain) {
+        Ok(addr) => Ok(vec![addr]),
+        Err(_) => {
+            let txt_domain = domain
+                .to_lowercase()
+                .strip_prefix("txt:")
+                .map(|v| v.to_string());
+            if name_servers.is_empty() {
+                if txt_domain.is_some() {
+                    name_servers.push("223.5.5.5:53".into());
+                    name_servers.push("114.114.114.114:53".into());
+                } else {
+                    return Ok(domain
+                        .to_socket_addrs()
+                        .with_context(|| format!("DNS query failed {:?}", domain))?
+                        .collect());
+                }
+            }
+
+            let mut err: Option<anyhow::Error> = None;
+            for name_server in name_servers {
+                if let Some(domain) = txt_domain.as_ref() {
+                    match txt_dns(domain, name_server) {
+                        Ok(addr) => {
+                            if !addr.is_empty() {
+                                return Ok(addr);
+                            }
+                        }
+                        Err(e) => {
+                            if let Some(err) = &mut err {
+                                *err = anyhow::anyhow!("{} {}", err, e);
+                            } else {
+                                err.replace(anyhow::anyhow!("{}", e));
+                            }
+                        }
+                    }
+                    continue;
+                }
+                let end_index = domain
+                    .rfind(':')
+                    .with_context(|| format!("{:?} not port", domain))?;
+                let host = &domain[..end_index];
+                let port = u16::from_str(&domain[end_index + 1..])
+                    .with_context(|| format!("{:?} not port", domain))?;
+                let th1 = {
+                    let host = host.to_string();
+                    let name_server = name_server.clone();
+                    thread::spawn(move || a_dns(host, name_server))
+                };
+                let th2 = {
+                    let host = host.to_string();
+                    let name_server = name_server.clone();
+                    thread::spawn(move || aaaa_dns(host, name_server))
+                };
+                let mut addr = Vec::new();
+                match th1.join().unwrap() {
+                    Ok(rs) => {
+                        for ip in rs {
+                            addr.push(SocketAddr::new(ip.into(), port));
+                        }
+                    }
+                    Err(e) => {
+                        err.replace(anyhow::anyhow!("{}", e));
+                    }
+                }
+                match th2.join().unwrap() {
+                    Ok(rs) => {
+                        for ip in rs {
+                            addr.push(SocketAddr::new(ip.into(), port));
+                        }
+                    }
+                    Err(e) => {
+                        if addr.is_empty() {
+                            if let Some(err) = &mut err {
+                                *err = anyhow::anyhow!("{},{}", err, e);
+                            } else {
+                                err.replace(anyhow::anyhow!("{}", e));
+                            }
+                            continue;
+                        }
+                    }
+                }
+                if addr.is_empty() {
+                    continue;
+                }
+                return Ok(addr);
+            }
+            if let Some(e) = err {
+                Err(e)
+            } else {
+                Err(anyhow::anyhow!("DNS query failed {:?}", domain))
+            }
+        }
+    }
+}
+
+fn query<'a>(
+    udp: &UdpSocket,
+    domain: &str,
+    name_server: SocketAddr,
+    record_type: QueryType,
+    buf: &'a mut [u8],
+) -> anyhow::Result<Packet<'a>> {
+    let mut builder = Builder::new_query(1, true);
+    builder.add_question(domain, false, record_type, QueryClass::IN);
+    let packet = builder.build().unwrap();
+
+    udp.connect(name_server)
+        .with_context(|| format!("DNS {:?} error ", name_server))?;
+    let mut count = 0;
+    let len = loop {
+        udp.send(&packet)?;
+
+        match udp.recv(buf) {
+            Ok(len) => {
+                break len;
+            }
+            Err(e) => {
+                if e.kind() == io::ErrorKind::TimedOut || e.kind() == io::ErrorKind::WouldBlock {
+                    count += 1;
+                    if count < 3 {
+                        continue;
+                    }
+                }
+                Err(e).with_context(|| format!("DNS {:?} recv error ", name_server))?
+            }
+        };
+    };
+
+    let pkt = Packet::parse(&buf[..len])
+        .with_context(|| format!("domain {:?} DNS {:?} data error ", domain, name_server))?;
+    if pkt.header.response_code != ResponseCode::NoError {
+        return Err(anyhow::anyhow!(
+            "response_code {} DNS {:?} domain {:?}",
+            pkt.header.response_code,
+            name_server,
+            domain
+        ));
+    }
+    if pkt.answers.is_empty() {
+        return Err(anyhow::anyhow!(
+            "No records received DNS {:?} domain {:?}",
+            name_server,
+            domain
+        ));
+    }
+
+    Ok(pkt)
+}
+
+pub fn txt_dns(domain: &str, name_server: String) -> anyhow::Result<Vec<SocketAddr>> {
+    let name_server: SocketAddr = name_server.parse()?;
+    let udp = bind_udp(name_server)?;
+    let mut buf = [0; 65536];
+    let message = query(&udp, domain, name_server, QueryType::TXT, &mut buf)?;
+    let mut rs = Vec::new();
+    for record in message.answers {
+        if let RData::TXT(txt) = record.data {
+            for x in txt.iter() {
+                let txt = std::str::from_utf8(x).context("record type txt is not string")?;
+                let addr =
+                    SocketAddr::from_str(txt).context("record type txt is not SocketAddr")?;
+                rs.push(addr);
+            }
+        }
+    }
+    Ok(rs)
+}
+
+fn bind_udp(name_server: SocketAddr) -> anyhow::Result<UdpSocket> {
+    let udp = if name_server.is_ipv4() {
+        UdpSocket::bind("0.0.0.0:0")?
+    } else {
+        UdpSocket::bind("[::]:0")?
+    };
+    udp.set_read_timeout(Some(Duration::from_millis(800)))?;
+    Ok(udp)
+}
+
+pub fn a_dns(domain: String, name_server: String) -> anyhow::Result<Vec<Ipv4Addr>> {
+    let name_server: SocketAddr = name_server.parse()?;
+    let udp = bind_udp(name_server)?;
+    let mut buf = [0; 65536];
+    let message = query(&udp, &domain, name_server, QueryType::A, &mut buf)?;
+    let mut rs = Vec::new();
+    for record in message.answers {
+        if let RData::A(a) = record.data {
+            rs.push(a.0);
+        }
+    }
+    Ok(rs)
+}
+
+pub fn aaaa_dns(domain: String, name_server: String) -> anyhow::Result<Vec<Ipv6Addr>> {
+    let name_server: SocketAddr = name_server.parse()?;
+    let udp = bind_udp(name_server)?;
+    let mut buf = [0; 65536];
+    let message = query(&udp, &domain, name_server, QueryType::AAAA, &mut buf)?;
+    let mut rs = Vec::new();
+    for record in message.answers {
+        if let RData::AAAA(a) = record.data {
+            rs.push(a.0);
+        }
+    }
+    Ok(rs)
+}
@@ -1,9 +1,10 @@
 mod notify;
-mod result_convert;
-pub use result_convert::io_convert;
 mod scheduler;
 pub use notify::StopManager;
 pub use scheduler::Scheduler;

 mod counter;
 pub use counter::*;
+
+mod dns_query;
+pub use dns_query::*;
@@ -1,6 +1,7 @@
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::thread::Thread;
+use std::time::Duration;
 use std::{io, thread};

 use parking_lot::Mutex;
@@ -31,6 +32,9 @@ impl StopManager {
    pub fn wait(&self) {
        self.inner.wait();
    }
+    pub fn wait_timeout(&self, dur: Duration) -> bool {
+        self.inner.wait_timeout(dur)
+    }
    pub fn is_stop(&self) -> bool {
        self.inner.state.load(Ordering::Acquire)
    }
@@ -103,6 +107,18 @@ impl StopManagerInner {
            thread::park()
        }
    }
+    fn wait_timeout(&self, dur: Duration) -> bool {
+        {
+            let mut guard = self.park_threads.lock();
+            guard.push(thread::current());
+            drop(guard);
+        }
+        if self.worker_num.load(Ordering::Acquire) == 0 {
+            return true;
+        }
+        thread::park_timeout(dur);
+        self.worker_num.load(Ordering::Acquire) == 0
+    }
    fn stop_call(&self) {
        if let Some(call) = self.stop_call.lock().take() {
            call();
@@ -1,10 +0,0 @@
-use std::fmt::Display;
-use std::io;
-
-#[inline]
-pub fn io_convert<T, R: Display, F: FnOnce(&io::Error) -> R>(
-    rs: io::Result<T>,
-    f: F,
-) -> io::Result<T> {
-    rs.map_err(|e| io::Error::new(e.kind(), format!("{},internal error:{:?}", f(&e), e)))
-}
@@ -13,6 +13,11 @@ impl Device {
        Ok(Self { fd: Fd::new(fd)? })
    }
 }
+impl Device {
+    pub fn as_tun_fd(&self) -> &Fd {
+        &self.fd
+    }
+}
 impl IFace for Device {
    fn version(&self) -> io::Result<String> {
        Ok(String::new())
@@ -26,7 +31,7 @@ impl IFace for Device {
        Err(io::Error::from(io::ErrorKind::Unsupported))
    }

-    fn set_ip(&self, address: Ipv4Addr, mask: Ipv4Addr) -> io::Result<()> {
+    fn set_ip(&self, _address: Ipv4Addr, _mask: Ipv4Addr) -> io::Result<()> {
        Err(io::Error::from(io::ErrorKind::Unsupported))
    }

@@ -34,15 +39,15 @@ impl IFace for Device {
        Err(io::Error::from(io::ErrorKind::Unsupported))
    }

-    fn set_mtu(&self, value: u32) -> io::Result<()> {
+    fn set_mtu(&self, _value: u32) -> io::Result<()> {
        Err(io::Error::from(io::ErrorKind::Unsupported))
    }

-    fn add_route(&self, dest: Ipv4Addr, netmask: Ipv4Addr, metric: u16) -> io::Result<()> {
+    fn add_route(&self, _dest: Ipv4Addr, _netmask: Ipv4Addr, _metric: u16) -> io::Result<()> {
        Err(io::Error::from(io::ErrorKind::Unsupported))
    }

-    fn delete_route(&self, dest: Ipv4Addr, netmask: Ipv4Addr) -> io::Result<()> {
+    fn delete_route(&self, _dest: Ipv4Addr, _netmask: Ipv4Addr) -> io::Result<()> {
        Err(io::Error::from(io::ErrorKind::Unsupported))
    }

@@ -3,7 +3,6 @@
 /// https://github.com/Tazdevil971/tap-windows
 /// https://github.com/nulldotblack/wintun
 pub mod device;
-mod packet;

 #[cfg(target_os = "linux")]
 mod linux;
@@ -29,3 +28,6 @@ mod windows;

 #[cfg(windows)]
 pub use windows::Device;
+
+#[cfg(windows)]
+mod packet;
@@ -1,29 +1,27 @@
+#![allow(dead_code)]
 use std::ffi::{CStr, CString};
 use std::net::Ipv4Addr;
 use std::os::fd::AsRawFd;
-use std::process::Command;
 use std::{io, mem, ptr};

 use libc::{
-    c_char, c_short, ifreq, AF_INET, IFF_MULTI_QUEUE, IFF_NO_PI, IFF_RUNNING, IFF_TAP, IFF_TUN,
+    c_char, c_short, ifreq, AF_INET, IFF_MULTI_QUEUE, IFF_NO_PI, IFF_RUNNING, IFF_TUN,
    IFF_UP, IFNAMSIZ, O_RDWR, SOCK_DGRAM,
 };

 use crate::device::IFace;
 use crate::linux::route;
 use crate::linux::sys::*;
-use crate::packet;
 use crate::unix::{exe_cmd, Fd, SockAddr};

 pub struct Device {
    name: String,
    ctl: Fd,
    tun: Fd,
-    mac: Option<[u8; 6]>,
 }

 impl Device {
-    pub fn new(name: Option<String>, tap: bool) -> io::Result<Self> {
+    pub fn new(name: Option<String>) -> io::Result<Self> {
        let device = unsafe {
            let dev = match name {
                Some(name) => {
@@ -50,7 +48,7 @@ impl Device {
                );
            }

-            let device_type: c_short = if tap { IFF_TAP } else { IFF_TUN } as c_short;
+            let device_type: c_short = IFF_TUN as c_short; //if tap { IFF_TAP } else { IFF_TUN } as c_short;

            let queues_num = 1;

@@ -73,29 +71,11 @@ impl Device {
            let name = CStr::from_ptr(req.ifr_name.as_ptr())
                .to_string_lossy()
                .to_string();
-            let mac = if tap {
-                let get_mac_cmd = format!("cat /sys/class/net/{}/address", name);
-                let mac_out = exe_cmd(&get_mac_cmd)?;
-                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();
-                }
-                Some(mac)
-            } else {
-                None
-            };
-            let set_txqueuelen  = format!("ifconfig {} txqueuelen 1000", name);
-            if let Err(e) = exe_cmd(&set_txqueuelen){
-                log::warn!("{:?}",e);
-            }
-            Device {
-                name,
-                tun,
-                ctl,
-                mac,
+            let set_txqueuelen = format!("ifconfig {} txqueuelen 1000", name);
+            if let Err(e) = exe_cmd(&set_txqueuelen) {
+                log::warn!("{:?}", e);
            }
+            Device { name, tun, ctl }
        };
        device.enabled(true)?;
        Ok(device)
@@ -234,6 +214,12 @@ impl Device {
    }
 }

+impl Device {
+    pub fn as_tun_fd(&self) -> &Fd {
+        &self.tun
+    }
+}
+
 impl IFace for Device {
    fn version(&self) -> io::Result<String> {
        Ok(String::new())
@@ -286,22 +272,10 @@ impl IFace for Device {
    }

    fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        if self.mac.is_some() {
-            packet::read_tap(
-                buf,
-                |eth_buf| self.tun.read(eth_buf),
-                |eth_buf| self.tun.write(eth_buf),
-            )
-        } else {
-            self.tun.read(buf)
-        }
+        self.tun.read(buf)
    }

    fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        if let Some(mac) = &self.mac {
-            packet::write_tap(buf, |eth_buf| self.tun.write(eth_buf), mac)
-        } else {
-            self.tun.write(buf)
-        }
+        self.tun.write(buf)
    }
 }
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use std::ffi::{c_void, CStr};
 use std::net::Ipv4Addr;
 use std::os::fd::AsRawFd;
@@ -224,6 +225,11 @@ impl Device {
        }
    }
 }
+impl Device {
+    pub fn as_tun_fd(&self) -> &Fd {
+        &self.tun
+    }
+}

 impl IFace for Device {
    fn version(&self) -> io::Result<String> {
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use std::{fmt, io};

 /// 地址解析协议，由IP地址找到MAC地址
@@ -21,7 +21,10 @@ impl<B: AsRef<[u8]>> EthernetPacket<B> {
        let packet = EthernetPacket::unchecked(buffer);
        //头部固定14位
        if packet.buffer.as_ref().len() < 14 {
-            Err(io::Error::new(io::ErrorKind::InvalidData,format!("len={}", packet.buffer.as_ref().len())))?;
+            Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!("len={}", packet.buffer.as_ref().len()),
+            ))?;
        }

        Ok(packet)
@@ -13,7 +13,7 @@ where
    let mut eth_buf = [0; 65536];
    loop {
        let len = read_fn(&mut eth_buf)?;
-        if len == 0{
+        if len == 0 {
            return Ok(len);
        }
        //处理arp包
@@ -1,3 +1,4 @@
+use libc::{fcntl, F_GETFL, F_SETFL, O_NONBLOCK};
 use std::io;
 use std::os::fd::{AsRawFd, IntoRawFd, RawFd};

@@ -10,6 +11,12 @@ impl Fd {
        }
        Ok(Fd(value))
    }
+    pub fn set_nonblock(&self) -> io::Result<()> {
+        match unsafe { fcntl(self.0, F_SETFL, fcntl(self.0, F_GETFL) | O_NONBLOCK) } {
+            0 => Ok(()),
+            _ => Err(io::Error::last_os_error()),
+        }
+    }
 }

 impl Fd {
@@ -51,6 +58,7 @@ impl IntoRawFd for Fd {
    }
 }

+#[cfg(not(target_os = "android"))]
 impl Drop for Fd {
    fn drop(&mut self) {
        unsafe {
@@ -1,6 +1,7 @@
 mod fd;

 pub use fd::Fd;
+#[cfg(any(target_os = "macos", target_os = "linux"))]
 use std::process::Output;
 #[cfg(any(target_os = "macos", target_os = "linux"))]
 mod sockaddr;
@@ -1,6 +1,7 @@
+#![allow(dead_code)]
 use crate::windows::exe_cmd;
+use std::io;
 use std::net::Ipv4Addr;
-use std::{io, process};

 /// 设置网卡名称
 pub fn set_interface_name(old_name: &str, new_name: &str) -> io::Result<()> {
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use std::io;
 use std::net::Ipv4Addr;
 use winapi::shared::ifdef::NET_LUID;
@@ -11,8 +12,6 @@ use winapi::um::winnt::{

 use crate::device::IFace;
 use crate::packet;
-use crate::packet::ethernet::protocol::Protocol;
-use crate::packet::{arp, ethernet};
 use crate::windows::{ctl_code, decode_utf16, encode_utf16, ffi, netsh, route};

 /* Present in 8.1 */
@@ -97,7 +96,7 @@ impl Device {
        let index = ffi::luid_to_index(&luid).map(|index| index as u32)?;
        // 设置网卡跃点
        if let Err(e) = netsh::set_interface_metric(index, 0) {
-            log::warn!("{:?}",e);
+            log::warn!("{:?}", e);
        }
        let device = Self {
            handle,
@@ -122,8 +121,6 @@ impl Device {
    }
 }

-const MAC: [u8; 6] = [0xf, 0xf, 0xf, 0xf, 0xe, 0x9];
-
 impl IFace for Device {
    fn version(&self) -> io::Result<String> {
        let mut version = [0u32; 3];
@@ -1,4 +1,5 @@
-use libloading::{Error, Library};
+#![allow(dead_code)]
+use libloading::Library;
 use std::io;
 use std::net::Ipv4Addr;

@@ -84,7 +85,7 @@ impl Device {
            //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_struct: wintun_raw::GUID = std::mem::transmute(guid);
            let guid_ptr = &guid_struct as *const wintun_raw::GUID;

            //SAFETY: the function is loaded from the wintun dll properly, we are providing valid
@@ -118,7 +119,7 @@ impl Device {
            let index = ffi::luid_to_index(&std::mem::transmute(luid)).map(|index| index as u32)?;
            // 设置网卡跃点
            if let Err(e) = netsh::set_interface_metric(index, 0) {
-                log::warn!("{:?}",e);
+                log::warn!("{:?}", e);
            }
            Ok(Self {
                luid: std::mem::transmute(luid),
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use log::*;

 use crate::windows::tun::wintun_raw;
@@ -1,3 +1,5 @@
+#![allow(non_snake_case)]
+#![allow(non_camel_case_types)]
 /* automatically generated by rust-bindgen 0.59.1 */
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
Author	SHA1	Message	Date
lbl8603	215337fd8a	支持数据压缩	2024-05-25 17:30:27 +08:00
lbl8603	e54341567a	去除安卓上的icmp代理	2024-05-23 22:35:37 +08:00
lbl8603	1ce3e9ff2e	停止时回收连接通道	2024-05-23 22:35:24 +08:00
lbl8603	ffdb5ceb6b	去除无用状态	2024-05-23 22:35:06 +08:00
lbl8603	faa78445b1	返回具体错误信息	2024-05-21 20:37:55 +08:00
lbl8603	440a832ace	调整条件编译	2024-05-15 20:30:42 +08:00
lubeilin	01cf8806e2	处理unix去掉所有模块的编译问题	2024-05-14 09:25:16 +08:00
lbl8603	a85e0c6d06	修改图片地址	2024-05-13 22:53:22 +08:00
lbl8603	fee3b24df4	减少无用日志	2024-05-13 22:07:05 +08:00
lubeilin	d8a9ec5732	支持--no-default-features编译	2024-05-11 13:30:16 +08:00
lbl8603	0e4294415e	增加日志输出内容	2024-05-10 23:19:52 +08:00
lbl8603	9df324f402	增加输出端口映射和ip代理内容	2024-05-10 23:18:45 +08:00
lbl8603	3b1236cfd0	通过stun探测端口，解决使用ipv6或tcp服务时端口错误的问题	2024-05-10 23:18:24 +08:00
lbl8603	699262d79e	rustup set auto-self-update disable	2024-05-10 23:16:37 +08:00
lbl8603	f6cfa1b84c	调整安卓端tun逻辑	2024-05-09 22:51:27 +08:00
lbl8603	1338bcbbc5	消除代码警告	2024-05-09 21:25:55 +08:00
lbl8603	4215488cb6	调整中继模式的逻辑	2024-05-09 20:16:02 +08:00
lbl8603	ccd6e44c2b	使用异步tun	2024-05-09 20:14:01 +08:00
lbl8603	b12b0b95a0	去除linux上的tap	2024-05-09 20:13:44 +08:00
lbl8603	948f3d5d24	遍历txt记录值	2024-05-09 20:12:26 +08:00
lbl8603	cf4fc54dfd	端口映射列表为空时不启动	2024-05-09 20:11:43 +08:00
lbl8603	5a9e31bded	支持异步tun	2024-05-09 20:11:08 +08:00
lbl8603	b61c140c24	去除linux上tap的支持	2024-05-09 20:10:17 +08:00
lbl8603	035ae46ee5	过滤/etc/machine-id为空的情况	2024-05-09 20:07:46 +08:00
lbl8603	b57a38e81e	增加超时方法	2024-05-08 23:58:38 +08:00
lbl8603	be767ae300	增加提示	2024-05-08 23:58:03 +08:00
lbl8603	607c8c2e9f	增加端口映射功能	2024-05-08 21:31:21 +08:00
lbl8603	d3dce7a3cc	调整stun处理	2024-05-08 20:20:09 +08:00
lbl8603	ff2bbdd837	改回用tokio处理代理，简化代码	2024-05-08 20:19:33 +08:00
lbl8603	b771b6c074	增加set_ttl方法	2024-05-08 20:16:36 +08:00
lubeilin	ff389647c0	修改帮助描述	2024-05-06 21:00:12 +08:00
lubeilin	49bec2d6aa	使用anyhow替换部分处理	2024-05-06 20:02:40 +08:00
lbl8603	ee359dc0d8	调整子网路由逻辑	2024-05-01 15:30:31 +08:00
lbl8603	d4fc28dca3	收到PunchRequest时不添加路由	2024-05-01 15:21:25 +08:00
lbl8603	1130f69a82	修改默认rt	2024-05-01 14:50:00 +08:00
lbl8603	e73ed238cd	去除无用代码	2024-04-30 23:34:17 +08:00
lbl8603	c6c1d297af	去除多余代码	2024-04-30 23:28:45 +08:00
lbl8603	f78f8de15e	修改结构体名称	2024-04-30 23:25:40 +08:00
lbl8603	fcbc52dc2e	增加icmp代理日志	2024-04-30 23:24:12 +08:00
lbl8603	bbfa255dd3	优化环路检测逻辑	2024-04-29 23:23:28 +08:00
lbl8603	18fcee52db	兼容安卓icmp	2024-04-28 23:17:45 +08:00
lbl8603	d36d0b9491	增加编译目标	2024-04-28 23:17:33 +08:00
lbl8603	fb8d7ec5b8	调整解析地址选择	2024-04-25 23:34:44 +08:00
lbl8603	24341808ef	Merge remote-tracking branch 'origin/2024-04-19' into 2024-04-19	2024-04-25 23:17:55 +08:00
lbl8603	353809f91c	优化路由添加逻辑	2024-04-25 20:04:32 +08:00
lbl8603	d2b2dfbf1e	去除多余校验	2024-04-25 19:44:20 +08:00
lbl8603	e027cf9d98	提交Cargo.lock锁定依赖版本	2024-04-24 23:18:05 +08:00
lbl8603	484b1657e8	修改dns参数描述	2024-04-24 23:09:20 +08:00
lbl8603	7dc4161f2f	避免打洞环路	2024-04-24 23:04:01 +08:00
lbl8603	18eb4af016	修改默认版本设置	2024-04-24 23:03:50 +08:00
lbl8603	635ec315f7	增加udp代理日志	2024-04-24 23:02:34 +08:00
lbl8603	37eb9ec045	优化dns查询	2024-04-24 23:02:01 +08:00
lbl8603	7c799589df	调整stun逻辑	2024-04-24 23:01:40 +08:00
lubeilin	4f52d58d6e	调整错误输出	2024-04-23 14:04:32 +08:00
lubeilin	441e374563	jni设置dns	2024-04-23 13:56:25 +08:00
lubeilin	3272f3cdca	设置dns	2024-04-23 12:40:33 +08:00
lbl8603	5b40a9f147	支持指定dns	2024-04-23 08:21:01 +08:00
lubeilin	12d4fc8e98	dns解析	2024-04-22 19:00:05 +08:00
lbl8603	ca74827aaf	拒绝服务端密钥对变化	2024-04-21 22:14:56 +08:00
lbl8603	0b570130e8	处理tcp加密注册失败的问题	2024-04-21 18:48:18 +08:00
lbl8603	5bdc514606	增加转发日志	2024-04-21 18:30:33 +08:00
lbl8603	137efe20b8	增加密钥hash，方便客户端判断加密是否一致	2024-04-20 21:27:35 +08:00
lbl8603	0cbc3e0f63	双重探测NAT类型，用于检测某些对称网络	2024-04-20 16:15:45 +08:00
lbl8603	7fbcf0a832	Merge remote-tracking branch 'origin/2024-04-19' into 2024-04-19	2024-04-20 14:49:57 +08:00
lbl8603	7283863fe8	增加路由回调	2024-04-20 14:48:58 +08:00
lbl8603	198f82fb2c	修改ip转u32方式	2024-04-19 20:05:19 +08:00
lubeilin	c219af4f4b	增加额外路由	2024-04-19 18:44:22 +08:00
lubeilin	0352982c14	回调增加网络路由	2024-04-19 18:35:37 +08:00
lubeilin	cc6cd6dc37	去除多余代码	2024-04-19 18:07:41 +08:00
lubeilin	9155471c26	去除多余代码	2024-04-19 16:28:49 +08:00
lubeilin	d916fd7573	去除多余字段	2024-04-19 16:17:39 +08:00
lubeilin	5528557964	去除多余字段	2024-04-19 16:16:49 +08:00
lbl8603	8dfc3b8c43	修改安卓端逻辑	2024-04-19 10:49:47 +08:00
lubeilin	84824731a7	优化nat探测	2024-04-16 23:20:24 +08:00
lubeilin	7131937d06	fmt	2024-04-13 17:45:46 +08:00
lubeilin	a657eae599	优化加密状态下的重连	2024-04-13 11:13:37 +08:00
lubeilin	e9ec6e8903	增加丢包日志	2024-04-13 10:24:29 +08:00
lubeilin	c4a9e79dc2	修复域名转换ip的问题	2024-04-09 22:48:14 +08:00
lubeilin	aeebf45390	去除proto生成代码	2024-04-08 23:34:36 +08:00
lubeilin	b818851b38	修改rand版本	2024-04-07 22:47:50 +08:00
lubeilin	f47db0ab1b	处理通道空置的问题	2024-04-07 21:40:31 +08:00
lubeilin	256a2adc3e	安卓不设置路由	2024-04-07 21:38:09 +08:00
lubeilin	28522f2f07	完善jni调用	2024-04-07 20:57:10 +08:00
lubeilin	a33ffd96fd	通道设置为0	2024-04-06 17:30:32 +08:00
lubeilin	61f7352312	测试阻塞udp的性能	2024-04-06 17:30:12 +08:00
lubeilin	def33382e3	日志输出版本信息	2024-04-06 11:23:09 +08:00
lubeilin	1d0d64bd30	Merge remote-tracking branch 'origin/main'	2024-04-05 23:21:21 +08:00
lubeilin	e7e8f6b771	调整tcp模式打洞	2024-04-05 23:14:45 +08:00
lubeilin	4317b06428	公网端口默认设置为0	2024-04-05 23:14:12 +08:00
lubeilin	e9c695f4ac	注册成功后先更新地址	2024-04-05 23:13:36 +08:00
lubeilin	da714e97e8	修改公网地址探测频率	2024-04-05 23:10:07 +08:00
lubeilin	ee2186aba5	解决tcp掉线问题	2024-04-05 23:01:34 +08:00
lubeilin	ca91f97c27	调整序列号	2024-04-05 23:00:34 +08:00
lubeilin	284cf38f0b	优化广播	2024-03-30 00:24:19 +08:00
lbl8603	dc3e4c8253	Merge pull request #32 from ziyouwa/main 优化从linux或wsl系统获取id	2024-03-25 15:46:01 +08:00
ziyouwa	c7b9f61bd2	1、优化从linux或wsl系统获取id 2、增加.gitignore文件	2024-03-25 15:36:18 +08:00