修改tun占用内存的大小

修改依赖
排除生成的文件
2024-06-15 22:18:51 +08:00 · 2024-06-15 21:16:04 +08:00 · 2024-06-15 21:15:52 +08:00 · 2024-06-15 21:03:41 +08:00 · 2024-06-15 20:55:14 +08:00 · 2024-06-15 20:55:05 +08:00
127 changed files with 4659 additions and 3744 deletions
@@ -108,7 +108,7 @@ jobs:
          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
+            sudo apt-get update && sudo apt-get install clang llvm libc6-dev-i386 crossbuild-essential-arm64 crossbuild-essential-armhf musl-tools libboost-all-dev libc6-dev -y
            #  curl -s musl.cc | grep mipsel
            case $TARGET in 
              mipsel-unknown-linux-musl)
@@ -193,7 +193,9 @@ jobs:
          EOF
      - name: Install rust target
        run: rustup target add $TARGET
-      - name: Run build
+      - name: Run build vn-link-cli
+        run: cargo build --package vn-link-cli --release --verbose --target $TARGET --features $FEATURES
+      - name: Run build vnt-cli
        run: cargo build --package vnt-cli --release --verbose --target $TARGET --features $FEATURES
      - name: List target
        run: find ./target
@@ -202,17 +204,22 @@ jobs:
          mkdir -p ./artifacts
          # windows is the only OS using a different convention for executable file name
          if [[ $OS =~ ^windows.*$ ]]; then
-              EXEC=$NAME.exe
+              EXEC_VNT_CLI=vnt-cli.exe
+              EXEC_VN_LINK_CLI=vn-link-cli.exe
          else
-              EXEC=$NAME
+              EXEC_VNT_CLI=vnt-cli
+              EXEC_VN_LINK_CLI=vn-link-cli
          fi
          if [[ $GITHUB_REF_TYPE =~ ^tag$ ]]; then
            TAG=$GITHUB_REF_NAME
          else
            TAG=$GITHUB_SHA
          fi
-          mv ./target/$TARGET/release/$EXEC ./artifacts/$EXEC
-          tar -czf ./artifacts/$NAME-$TARGET-$TAG.tar.gz -C ./artifacts $EXEC
+          mv ./target/$TARGET/release/$EXEC_VNT_CLI ./artifacts/$EXEC_VNT_CLI
+          mv ./target/$TARGET/release/$EXEC_VN_LINK_CLI ./artifacts/$EXEC_VN_LINK_CLI
+          mv ./README ./artifacts/README
+          cd ./artifacts
+          tar -czf vnt-$TARGET-$TAG.tar.gz *
      - name: Archive artifact
        uses: actions/upload-artifact@v2
        with:
@@ -1,3 +1,3 @@
 target/*
 vnt/src/proto/*
-vnt-cli/src/generated_serial_number.rs
+common/src/generated_serial_number.rs
@@ -67,24 +67,6 @@ 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"
@@ -133,6 +115,29 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"

+[[package]]
+name = "bindgen"
+version = "0.69.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
+dependencies = [
+ "bitflags 2.5.0",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "lazy_static",
+ "lazycell",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.60",
+ "which",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -192,15 +197,23 @@ dependencies = [

 [[package]]
 name = "cc"
-version = "1.0.94"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17f6e324229dc011159fcc089755d1e2e216a90d43a7dea6853ca740b84f35e7"
+checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695"
+dependencies = [
+ "jobserver",
+ "libc",
+ "once_cell",
+]

 [[package]]
-name = "cesu8"
-version = "1.1.0"
+name = "cexpr"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]

 [[package]]
 name = "cfg-if"
@@ -208,6 +221,36 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "chacha20poly1305"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
+dependencies = [
+ "aead",
+ "chacha20",
+ "cipher",
+ "poly1305",
+ "zeroize",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.38"
@@ -230,21 +273,37 @@ checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
 dependencies = [
 "crypto-common",
 "inout",
+ "zeroize",
 ]

 [[package]]
-name = "combine"
-version = "4.6.7"
+name = "clang-sys"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
- "bytes",
- "memchr",
+ "glob",
+ "libc",
+ "libloading",
 ]

 [[package]]
 name = "common"
-version = "1.2.9"
+version = "1.2.10"
+dependencies = [
+ "anyhow",
+ "chrono",
+ "console",
+ "gethostname",
+ "getopts",
+ "log",
+ "log4rs",
+ "rand",
+ "serde",
+ "serde_yaml",
+ "uuid",
+ "vnt",
+]

 [[package]]
 name = "console"
@@ -280,6 +339,38 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "crossbeam"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-epoch",
+ "crossbeam-queue",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-epoch"
 version = "0.9.18"
@@ -388,28 +479,12 @@ 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"
@@ -448,6 +523,16 @@ dependencies = [
 "version_check",
 ]

+[[package]]
+name = "gethostname"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0176e0459c2e4a1fe232f984bca6890e681076abb9934f6cea7c326f3fc47818"
+dependencies = [
+ "libc",
+ "windows-targets 0.48.5",
+]
+
 [[package]]
 name = "getopts"
 version = "0.2.21"
@@ -486,6 +571,12 @@ version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"

+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -578,6 +669,15 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8bd11f3a29434026f5ff98c730b668ba74b1033637b8817940b54d040696133c"

+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
@@ -585,27 +685,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"

 [[package]]
-name = "jni"
-version = "0.21.1"
+name = "jobserver"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
 dependencies = [
- "cesu8",
- "cfg-if",
- "combine",
- "jni-sys",
- "log",
- "thiserror",
- "walkdir",
- "windows-sys 0.45.0",
+ "libc",
 ]

-[[package]]
-name = "jni-sys"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
-
 [[package]]
 name = "js-sys"
 version = "0.3.69"
@@ -624,6 +711,12 @@ dependencies = [
 "spin 0.5.2",
 ]

+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
 [[package]]
 name = "libc"
 version = "0.2.153"
@@ -720,12 +813,38 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "lwip-rs"
+version = "0.1.0"
+source = "git+https://github.com/lbl8603/lwip-rs#3133f0c3bde55333a27641182ae3550e7acc2a39"
+dependencies = [
+ "bindgen",
+ "cc",
+ "crossbeam",
+ "lazy_static",
+ "log",
+ "parking_lot",
+ "tokio",
+]
+
+[[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 = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.7.2"
@@ -747,6 +866,16 @@ dependencies = [
 "windows-sys 0.48.0",
 ]

+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "num-bigint"
 version = "0.4.4"
@@ -865,17 +994,6 @@ 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"
@@ -948,6 +1066,17 @@ version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"

+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
 [[package]]
 name = "polyval"
 version = "0.6.2"
@@ -966,6 +1095,16 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

+[[package]]
+name = "prettyplease"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.60",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.81"
@@ -1206,6 +1345,12 @@ version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"

+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
 [[package]]
 name = "rustix"
 version = "0.38.32"
@@ -1225,15 +1370,6 @@ 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"
@@ -1305,6 +1441,22 @@ dependencies = [
 "digest",
 ]

+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.2"
@@ -1584,24 +1736,52 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

+[[package]]
+name = "vn-link"
+version = "1.2.10"
+dependencies = [
+ "anyhow",
+ "crossbeam-utils",
+ "log",
+ "lwip-rs",
+ "parking_lot",
+ "tokio",
+ "vnt",
+]
+
+[[package]]
+name = "vn-link-cli"
+version = "1.2.10"
+dependencies = [
+ "common",
+ "log",
+ "tokio",
+ "vn-link",
+]
+
 [[package]]
 name = "vnt"
-version = "1.2.9"
+version = "1.2.10"
 dependencies = [
 "aes",
 "aes-gcm",
 "anyhow",
 "bytes",
 "cbc",
+ "cfg_aliases",
+ "chacha20",
+ "chacha20poly1305",
 "crossbeam-epoch",
 "crossbeam-queue",
 "crossbeam-utils",
 "dns-parser",
 "ecb",
+ "fnv",
 "libc",
 "libloading",
 "libsm",
 "log",
+ "lz4_flex",
 "mio",
 "openssl-sys",
 "packet",
@@ -1619,52 +1799,24 @@ dependencies = [
 "thiserror",
 "tokio",
 "tun",
+ "zstd",
 ]

 [[package]]
 name = "vnt-cli"
-version = "1.2.9"
+version = "1.2.10"
 dependencies = [
+ "anyhow",
 "chrono",
 "common",
- "console",
- "embed-manifest",
- "getopts",
 "log",
- "log4rs",
- "os_info",
 "rand",
- "serde",
- "serde_yaml",
+ "signal-hook",
 "sudo",
- "uuid",
 "vnt",
 "winapi",
 ]

-[[package]]
-name = "vnt-jni"
-version = "1.2.9"
-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"
@@ -1759,15 +1911,6 @@ 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"
@@ -1783,15 +1926,6 @@ 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"
@@ -1810,21 +1944,6 @@ 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"
@@ -1856,12 +1975,6 @@ dependencies = [
 "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"
@@ -1874,12 +1987,6 @@ 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"
@@ -1892,12 +1999,6 @@ 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"
@@ -1916,12 +2017,6 @@ 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"
@@ -1934,12 +2029,6 @@ 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"
@@ -1952,12 +2041,6 @@ 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"
@@ -1970,12 +2053,6 @@ 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"
@@ -2002,3 +2079,31 @@ 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",
+]
@@ -1,11 +1,11 @@
 [workspace]
-members = ["vnt","common","vnt-cli","vnt-jni"]
+members = ["vnt", "common", "vnt-cli", "vn-link", "vn-link-cli"]

 [profile.release]
 opt-level = 'z'
 debug = 0
 debug-assertions = false
-strip= "debuginfo"
+strip = "debuginfo"
 lto = true
 panic = 'abort'
 incremental = false
@@ -0,0 +1,14 @@
+一、程序说明
+    1. vnt-cli vnt的命令行程序
+    2. vn-link-cli  功能和vnt-cli基本一致，但是不依赖tun、不改变本地路由、不需要管理员/root权限
+
+二、使用说明
+    使用-k参数构建虚拟网络
+
+
+1. Program Description
+    a. vnt-cli: Command-line program for VNT.
+    b. vn-link-cli: Functions similarly to vnt-cli, but does not depend on TUN, does not change local routing, and does not require administrator/root permissions.
+
+2. Instructions for Use
+    Use the -k parameter to create a virtual network.
@@ -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命令查看

 ### 更多玩法
@@ -73,35 +73,48 @@ cargo build -p vnt-cli --no-default-features

 features说明

-| feature          | 说明                   | 是否默认 |
-|------------------|----------------------|------|
-| openssl          | 使用openssl中的aes_ecb算法 | 否    |
-| openssl-vendored | 从源码编译openssl         | 否    |
-| ring-cipher      | 使用ring中的aes_gcm算法    | 否    |
-| aes_cbc          | 支持aes_cbc加密          | 是    |
-| aes_ecb          | 支持aes_ecb加密          | 是    |
-| aes_gcm          | 支持aes_gcm加密          | 是    |
-| sm4_cbc          | 支持sm4_cbc加密          | 是    |
-| server_encrypt   | 支持服务端加密              | 是    |
-| ip_proxy         | 内置ip代理               | 是    |
+| feature           | 说明                             | 是否默认 |
+|-------------------|--------------------------------|------|
+| openssl           | 使用openssl中的加密算法                | 否    |
+| openssl-vendored  | 从源码编译openssl                   | 否    |
+| ring-cipher       | 使用ring中的加密算法                   | 否    |
+| aes_cbc           | 支持aes_cbc加密                    | 是    |
+| aes_ecb           | 支持aes_ecb加密                    | 是    |
+| aes_gcm           | 支持aes_gcm加密                    | 是    |
+| sm4_cbc           | 支持sm4_cbc加密                    | 是    |
+| chacha20_poly1305 | 支持chacha20和chacha20_poly1305加密 | 是    |
+| 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 +157,7 @@ sudo iptables-restore iptables.rules
 ```

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

 ### 支持平台

 - Mac
 - Linux
-    - Arch Linux `yay -Syu vnt`
 - Windows
    - 默认使用tun网卡 依赖wintun.dll([win-tun](https://www.wintun.net/))(将dll放到同目录下，建议使用版本0.14.1)
    - 使用tap网卡 依赖tap-windows([win-tap](https://build.openvpn.net/downloads/releases/))(建议使用版本9.24.7)
 - Android
-    - [VntApp](https://github.com/lbl8603/VntApp)
+
+### GUI
+
+支持安卓和Windows [下载](https://github.com/lbl8603/VntApp/releases/)

 ### 特性

@@ -255,21 +272,33 @@ 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>

 ### 交流群

+对VNT有任何问题均可以加群联系作者
+
 QQ: 1034868233
+### 赞助
+如果VNT对你有帮助，欢迎打赏作者
+
+ <img width="300" alt="" src="https://github.com/lbl8603/vnt/assets/49143209/0d3a7311-43fc-4ed7-9507-863b5d69b6b2">

 ### 其他

 可使用社区小伙伴搭建的中继服务器

 1. -s vnt.8443.eu.org:29871
+2. -s vnt.wherewego.top:29872

 ### 参与贡献

@@ -1,8 +1,43 @@
 [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

 [dependencies]
+vnt = { path = "../vnt", package = "vnt", default-features = false }
+anyhow = "1.0.82"
+console = "0.15.2"
+log = "0.4.17"
+log4rs = { version = "1.3.0", optional = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_yaml = "0.9.32"
+getopts = "0.2.21"
+gethostname = "0.4.3"
+uuid = { version = "1.8.0", features = ["v4"] }
+
+[features]
+default = []
+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"]
+chacha20_poly1305 = ["vnt/chacha20_poly1305"]
+server_encrypt = ["vnt/server_encrypt"]
+ip_proxy = ["vnt/ip_proxy"]
+port_mapping = ["vnt/port_mapping"]
+lz4 = ["vnt/lz4_compress"]
+zstd = ["vnt/zstd_compress"]
+
+command = []
+file_config = []
+log = ["log4rs"]
+integrated_tun = ["vnt/integrated_tun"]
+
+[build-dependencies]
+rand = "0.8.5"
+chrono = "0.4.23"
@@ -1,9 +1,7 @@
 use std::process;

 use console::style;
-
-use vnt::handle::callback::{ConnectInfo, ErrorType};
-use vnt::{DeviceInfo, ErrorInfo, HandshakeInfo, RegisterInfo, VntCallback};
+use vnt::{ConnectInfo, ErrorInfo, ErrorType, HandshakeInfo, RegisterInfo, VntCallback};

 #[derive(Clone)]
 pub struct VntHandler {}
@@ -12,7 +10,8 @@ impl VntCallback for VntHandler {
    fn success(&self) {
        println!(" {} ", style("====== Connect Successfully ======").green())
    }
-    fn create_tun(&self, info: DeviceInfo) {
+    #[cfg(feature = "vnt-model")]
+    fn create_tun(&self, info: vnt::DeviceInfo) {
        println!("create_tun {}", info)
    }

@@ -0,0 +1,463 @@
+use crate::args_parse::{ips_parse, out_ips_parse};
+#[cfg(feature = "command")]
+use crate::command;
+use crate::{config, generated_serial_number};
+use anyhow::anyhow;
+use console::style;
+use getopts::Options;
+use std::io;
+use std::net::Ipv4Addr;
+use std::path::PathBuf;
+use std::str::FromStr;
+use vnt::channel::punch::PunchModel;
+use vnt::channel::UseChannelType;
+use vnt::cipher::CipherModel;
+use vnt::compression::Compressor;
+use vnt::core::Config;
+
+pub fn app_home() -> io::Result<PathBuf> {
+    let root_path = match std::env::current_exe() {
+        Ok(path) => {
+            if let Some(v) = path.as_path().parent() {
+                v.to_path_buf()
+            } else {
+                log::warn!("current_exe parent none:{:?}", path);
+                PathBuf::new()
+            }
+        }
+        Err(e) => {
+            log::warn!("current_exe err:{:?}", e);
+            PathBuf::new()
+        }
+    };
+    let path = root_path.join("env");
+    if !path.exists() {
+        std::fs::create_dir_all(&path)?;
+    }
+    Ok(path)
+}
+
+pub fn parse_args_config() -> anyhow::Result<Option<(Config, Vec<String>, bool)>> {
+    #[cfg(feature = "log")]
+    let _ = log4rs::init_file("log4rs.yaml", Default::default());
+    let args: Vec<String> = std::env::args().collect();
+    let program = args[0].clone();
+    let mut opts = Options::new();
+    opts.optopt("k", "", "组网标识", "<token>");
+    opts.optopt("n", "", "设备名称", "<name>");
+    opts.optopt("d", "", "设备标识", "<id>");
+    opts.optflag("c", "", "关闭交互式命令");
+    opts.optopt("s", "", "注册和中继服务器地址", "<server>");
+    opts.optmulti("e", "", "stun服务器", "<stun-server>");
+    opts.optflag("a", "", "使用tap模式");
+    opts.optopt("", "nic", "虚拟网卡名称,windows下使用tap则必填", "<tun0>");
+    opts.optmulti("i", "", "配置点对网(IP代理)入站时使用", "<in-ip>");
+    opts.optmulti("o", "", "配置点对网出站时使用", "<out-ip>");
+    opts.optopt("w", "", "客户端加密", "<password>");
+    opts.optflag("W", "", "服务端加密");
+    opts.optopt("u", "", "自定义mtu(默认为1430)", "<mtu>");
+    opts.optflag("", "tcp", "tcp");
+    opts.optopt("", "ip", "指定虚拟ip", "<ip>");
+    opts.optflag("", "relay", "仅使用服务器转发");
+    opts.optopt("", "par", "任务并行度(必须为正整数)", "<parallel>");
+    opts.optopt("", "model", "加密模式", "<model>");
+    opts.optflag("", "finger", "指纹校验");
+    opts.optopt("", "punch", "取值ipv4/ipv6", "<punch>");
+    opts.optopt("", "ports", "监听的端口", "<port,port>");
+    opts.optflag("", "cmd", "开启窗口输入");
+    opts.optflag("", "no-proxy", "关闭内置代理");
+    opts.optflag("", "first-latency", "优先延迟");
+    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.optmulti("", "vnt-mapping", "vnt-mapping", "<mapping>");
+    opts.optopt("f", "", "配置文件", "<conf>");
+    opts.optopt("", "compressor", "压缩算法", "<lz4>");
+    //"后台运行时,查看其他设备列表"
+    opts.optflag("", "add", "后台运行时,添加地址");
+    opts.optflag("", "list", "后台运行时,查看其他设备列表");
+    opts.optflag("", "all", "后台运行时,查看其他设备完整信息");
+    opts.optflag("", "info", "后台运行时,查看当前设备信息");
+    opts.optflag("", "route", "后台运行时,查看数据转发路径");
+    opts.optflag("", "stop", "停止后台运行");
+    opts.optflag("h", "help", "帮助");
+    let matches = match opts.parse(&args[1..]) {
+        Ok(m) => m,
+        Err(f) => {
+            print_usage(&program, opts);
+            return Err(anyhow::anyhow!("{}", f.to_string()));
+        }
+    };
+    if matches.opt_present("h") || args.len() == 1 {
+        print_usage(&program, opts);
+        return Ok(None);
+    }
+
+    #[cfg(feature = "command")]
+    if matches.opt_present("list") {
+        command::command(command::CommandEnum::List);
+        return Ok(None);
+    } else if matches.opt_present("info") {
+        command::command(command::CommandEnum::Info);
+        return Ok(None);
+    } else if matches.opt_present("stop") {
+        command::command(command::CommandEnum::Stop);
+        return Ok(None);
+    } else if matches.opt_present("route") {
+        command::command(command::CommandEnum::Route);
+        return Ok(None);
+    } else if matches.opt_present("all") {
+        command::command(command::CommandEnum::All);
+        return Ok(None);
+    }
+    let conf = matches.opt_str("f");
+    let (config, vnt_link_config, cmd) = if conf.is_some() {
+        match config::read_config(&conf.unwrap()) {
+            Ok(c) => c,
+            Err(e) => {
+                return Err(anyhow::anyhow!("conf err {}", e));
+            }
+        }
+    } else {
+        if !matches.opt_present("k") {
+            print_usage(&program, opts);
+            return Err(anyhow::anyhow!("parameter -k not found ."));
+        }
+        #[cfg(target_os = "windows")]
+        #[cfg(feature = "integrated_tun")]
+        let tap = matches.opt_present("a");
+        #[cfg(feature = "integrated_tun")]
+        let device_name = matches.opt_str("nic");
+        let token: String = matches.opt_get("k").unwrap().unwrap();
+        let device_id = matches.opt_get_default("d", String::new()).unwrap();
+        let device_id = if device_id.is_empty() {
+            config::get_device_id()
+        } else {
+            device_id
+        };
+        if device_id.is_empty() {
+            print_usage(&program, opts);
+            return Err(anyhow::anyhow!("parameter -d not found ."));
+        }
+        let name = matches
+            .opt_get_default(
+                "n",
+                gethostname::gethostname()
+                    .to_str()
+                    .unwrap_or("UnknownName")
+                    .to_string(),
+            )
+            .unwrap();
+        let server_address_str = matches
+            .opt_get_default("s", "vnt.wherewego.top:29872".to_string())
+            .unwrap();
+
+        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.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,
+            Err(e) => {
+                print_usage(&program, opts);
+                println!();
+                println!("-i: {:?} {}", in_ip, e);
+                return Err(anyhow::anyhow!("example: -i 192.168.0.0/24,10.26.0.3"));
+            }
+        };
+        let out_ip = matches.opt_strs("o");
+        let out_ip = match out_ips_parse(&out_ip) {
+            Ok(out_ip) => out_ip,
+            Err(e) => {
+                print_usage(&program, opts);
+                println!();
+                println!("-o: {:?} {}", out_ip, e);
+                return Err(anyhow::anyhow!("example: -o 0.0.0.0/0"));
+            }
+        };
+        let password: Option<String> = matches.opt_get("w").unwrap();
+        let server_encrypt = matches.opt_present("W");
+        #[cfg(not(feature = "server_encrypt"))]
+        {
+            if server_encrypt {
+                println!("Server encryption not supported");
+                return Err(anyhow::anyhow!("Server encryption not supported"));
+            }
+        }
+        let mtu: Option<String> = matches.opt_get("u").unwrap();
+        let mtu = if let Some(mtu) = mtu {
+            match u32::from_str(&mtu) {
+                Ok(mtu) => Some(mtu),
+                Err(e) => {
+                    print_usage(&program, opts);
+                    println!();
+                    println!("'-u {}' {}", mtu, e);
+                    return Err(anyhow::anyhow!("'-u {}' {}", mtu, e));
+                }
+            }
+        } else {
+            None
+        };
+        let virtual_ip: Option<String> = matches.opt_get("ip").unwrap();
+        let virtual_ip =
+            virtual_ip.map(|v| Ipv4Addr::from_str(&v).expect(&format!("'--ip {}' error", v)));
+        if let Some(virtual_ip) = virtual_ip {
+            if virtual_ip.is_unspecified() || virtual_ip.is_broadcast() || virtual_ip.is_multicast()
+            {
+                return Err(anyhow::anyhow!("'--ip {}' invalid", virtual_ip));
+            }
+        }
+        let tcp_channel = matches.opt_present("tcp");
+        let relay = matches.opt_present("relay");
+
+        let cipher_model = match matches.opt_get::<CipherModel>("model") {
+            Ok(model) => {
+                #[cfg(not(any(feature = "aes_gcm", feature = "server_encrypt")))]
+                {
+                    if password.is_some() && model.is_none() {
+                        return Err(anyhow::anyhow!("'--model ' undefined"));
+                    }
+                    model.unwrap_or(CipherModel::None)
+                }
+                #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
+                model.unwrap_or(CipherModel::AesGcm)
+            }
+            Err(e) => {
+                return Err(anyhow::anyhow!("'--model ' invalid,{}", e));
+            }
+        };
+
+        let finger = matches.opt_present("finger");
+        let punch_model = matches
+            .opt_get::<PunchModel>("punch")
+            .unwrap()
+            .unwrap_or(PunchModel::All);
+        let use_channel_type = matches
+            .opt_get::<UseChannelType>("use-channel")
+            .unwrap()
+            .unwrap_or_else(|| {
+                if relay {
+                    UseChannelType::Relay
+                } else {
+                    UseChannelType::All
+                }
+            });
+
+        let ports = matches
+            .opt_get::<String>("ports")
+            .unwrap_or(None)
+            .map(|v| v.split(",").map(|x| x.parse().unwrap_or(0)).collect());
+
+        let cmd = matches.opt_present("cmd");
+        #[cfg(feature = "ip_proxy")]
+        #[cfg(feature = "integrated_tun")]
+        let no_proxy = matches.opt_present("no-proxy");
+        let first_latency = matches.opt_present("first-latency");
+        let packet_loss = matches
+            .opt_get::<f64>("packet-loss")
+            .expect("--packet-loss");
+        let packet_delay = matches
+            .opt_get::<u32>("packet-delay")
+            .expect("--packet-delay")
+            .unwrap_or(0);
+        #[cfg(feature = "port_mapping")]
+        let port_mapping_list = matches.opt_strs("mapping");
+        let vnt_mapping_list = matches.opt_strs("vnt-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(feature = "integrated_tun")]
+            #[cfg(target_os = "windows")]
+            tap,
+            token,
+            device_id,
+            name,
+            server_address_str,
+            dns,
+            stun_server,
+            in_ip,
+            out_ip,
+            password,
+            mtu,
+            tcp_channel,
+            virtual_ip,
+            #[cfg(feature = "integrated_tun")]
+            #[cfg(feature = "ip_proxy")]
+            no_proxy,
+            server_encrypt,
+            cipher_model,
+            finger,
+            punch_model,
+            ports,
+            first_latency,
+            #[cfg(feature = "integrated_tun")]
+            device_name,
+            use_channel_type,
+            packet_loss,
+            packet_delay,
+            #[cfg(feature = "port_mapping")]
+            port_mapping_list,
+            compressor,
+        ) {
+            Ok(config) => config,
+            Err(e) => {
+                println!("config.toml error: {}", e);
+                std::process::exit(1);
+            }
+        };
+        (config, vnt_mapping_list, cmd)
+    };
+    println!("version {}", vnt::VNT_VERSION);
+    println!("Serial:{}", generated_serial_number::SERIAL_NUMBER);
+    log::info!(
+        "version:{},Serial:{}",
+        vnt::VNT_VERSION,
+        generated_serial_number::SERIAL_NUMBER
+    );
+    Ok(Some((config, vnt_link_config, cmd)))
+}
+
+fn print_usage(program: &str, _opts: Options) {
+    println!("Usage: {} [options]", program);
+    println!("version:{}", vnt::VNT_VERSION);
+    println!("Serial:{}", generated_serial_number::SERIAL_NUMBER);
+    println!("Options:");
+    println!(
+        "  -k <token>          {}",
+        green("使用相同的token,就能组建一个局域网络".to_string())
+    );
+    println!("  -n <name>           给设备一个名字,便于区分不同设备,默认使用系统版本");
+    println!("  -d <id>             设备唯一标识符,不使用--ip参数时,服务端凭此参数分配虚拟ip,注意不能重复");
+    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")]
+    #[cfg(feature = "integrated_tun")]
+    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,可指定多个网段");
+    println!("  -o <out-ip>         配置点对网时使用,-o 192.168.0.0/24表示允许将数据转发到192.168.0.0/24,可指定多个网段");
+
+    println!("  -w <password>       使用该密码生成的密钥对客户端数据进行加密,并且服务端无法解密,使用相同密码的客户端才能通信");
+    #[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");
+    println!("  --ip <ip>           指定虚拟ip,指定的ip不能和其他设备重复,必须有效并且在服务端所属网段下,默认情况由服务端分配");
+    let mut enums = String::new();
+    #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
+    enums.push_str("/aes_gcm");
+    #[cfg(feature = "chacha20_poly1305")]
+    enums.push_str("/chacha20_poly1305/chacha20");
+    #[cfg(feature = "aes_cbc")]
+    enums.push_str("/aes_cbc");
+    #[cfg(feature = "aes_ecb")]
+    enums.push_str("/aes_ecb");
+    #[cfg(feature = "sm4_cbc")]
+    enums.push_str("/sm4_cbc");
+    enums.push_str("/xor");
+    println!(
+        "  --model <model>     加密模式(默认aes_gcm),可选值{}",
+        &enums[1..]
+    );
+    #[cfg(any(
+        feature = "aes_gcm",
+        feature = "chacha20_poly1305",
+        feature = "server_encrypt",
+        feature = "aes_cbc",
+        feature = "aes_ecb",
+        feature = "sm4_cbc"
+    ))]
+    println!("  --finger            增加数据指纹校验,可增加安全性,如果服务端开启指纹校验,则客户端也必须开启");
+    println!("  --punch <punch>     取值ipv4/ipv6/all,ipv4表示仅使用ipv4打洞");
+    println!("  --ports <port,port> 取值0~65535,指定本地监听的一组端口,默认监听两个随机端口,使用过多端口会增加网络负担");
+    #[cfg(feature = "command")]
+    println!("  --cmd               开启交互式命令,使用此参数开启控制台输入");
+    #[cfg(feature = "ip_proxy")]
+    #[cfg(feature = "integrated_tun")]
+    println!("  --no-proxy          关闭内置代理,如需点对网则需要配置网卡NAT转发");
+    println!("  --first-latency     优先低延迟的通道,默认情况优先使用p2p通道");
+    println!("  --use-channel <p2p> 使用通道 relay/p2p/all,默认两者都使用");
+    #[cfg(not(feature = "vn-link-model"))]
+    println!("  --nic <tun0>        指定虚拟网卡名称");
+    println!("  --packet-loss <0>   模拟丢包,取值0~1之间的小数,程序会按设定的概率主动丢包,可用于模拟弱网");
+    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-domain: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");
+
+    #[cfg(not(feature = "integrated_tun"))]
+    println!(
+        "  --vnt-mapping <x>   {}",
+        green(
+            "vnt地址映射,例如 --vnt-mapping tcp:80-10.26.0.10:80 映射目标是vnt网络或其子网中的设备"
+                .to_string()
+        )
+    );
+    println!();
+    #[cfg(feature = "command")]
+    {
+        // #[cfg(not(feature = "integrated_tun"))]
+        // println!(
+        //     "  --add               {}",
+        //     yellow("后台运行时,添加VNT地址映射 用法同'--vnt-mapping'".to_string())
+        // );
+        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          帮助");
+}
+
+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()
+}
@@ -7,7 +7,7 @@ use std::time::Duration;
 use crate::command::entity::{DeviceItem, Info, RouteItem};

 pub struct CommandClient {
-    buf: [u8; 10240],
+    buf: Vec<u8>,
    udp: UdpSocket,
 }

@@ -25,12 +25,12 @@ impl CommandClient {
        )))?;
        Ok(Self {
            udp,
-            buf: [0; 10240],
+            buf: vec![0; 65536 * 8],
        })
    }
 }
 fn read_command_port() -> io::Result<u16> {
-    let path_buf = crate::app_home()?.join("command-port");
+    let path_buf = crate::cli::app_home()?.join("command-port");
    let port = std::fs::read_to_string(path_buf)?;
    match u16::from_str(&port) {
        Ok(port) => Ok(port),
@@ -59,8 +59,16 @@ impl CommandClient {
        match serde_yaml::from_slice::<V>(&self.buf[..len]) {
            Ok(val) => Ok(val),
            Err(e) => {
-                log::error!("{:?},{:?}", &self.buf[..len], e);
-                Err(io::Error::new(io::ErrorKind::Other, "data error"))
+                log::error!(
+                    "send_cmd {:?} {:?},{:?}",
+                    std::str::from_utf8(cmd),
+                    std::str::from_utf8(&self.buf[..len]),
+                    e
+                );
+                Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("data error {:?} buf_len={}", e, len),
+                ))
            }
        }
    }
@@ -16,6 +16,37 @@ pub enum CommandEnum {
    Stop,
 }

+pub fn command_str(cmd: &str, vnt: &Vnt) -> bool {
+    if cmd.is_empty() {
+        return false;
+    }
+    match cmd.to_lowercase().trim() {
+        "list" => {
+            let list = command_list(&vnt);
+            console_out::console_device_list(list);
+        }
+        "info" => {
+            let info = command_info(&vnt);
+            console_out::console_info(info);
+        }
+        "route" => {
+            let route = command_route(&vnt);
+            console_out::console_route_table(route);
+        }
+        "all" => {
+            let list = command_list(&vnt);
+            console_out::console_device_list_all(list);
+        }
+        "stop" => {
+            let _ = vnt.stop();
+            return false;
+        }
+        _ => {}
+    }
+    println!();
+    return true;
+}
+
 pub fn command(cmd: CommandEnum) {
    if let Err(e) = command_(cmd) {
        println!("cmd: {:?}", e);
@@ -185,7 +216,10 @@ 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 {
@@ -1,7 +1,6 @@
 use std::io;
 use std::io::Write;
 use std::net::UdpSocket;
-
 use vnt::core::Vnt;

 pub struct CommandServer {}
@@ -48,7 +47,7 @@ impl CommandServer {
    }
 }
 fn save_port(port: u16) -> io::Result<()> {
-    let path_buf = crate::app_home()?.join("command-port");
+    let path_buf = crate::cli::app_home()?.join("command-port");
    let mut file = std::fs::File::create(path_buf)?;
    file.write_all(port.to_string().as_bytes())?;
    file.sync_all()
@@ -1,12 +1,14 @@
-use std::io;
+use anyhow::anyhow;
 use std::net::Ipv4Addr;
 use std::str::FromStr;

+use crate::args_parse;
+use crate::config::get_device_id;
 use serde::{Deserialize, Serialize};
-
 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)]
@@ -30,8 +32,7 @@ pub struct FileConfig {
    #[cfg(feature = "ip_proxy")]
    pub no_proxy: bool,
    pub server_encrypt: bool,
-    pub parallel: usize,
-    pub cipher_model: String,
+    pub cipher_model: Option<String>,
    pub finger: bool,
    pub punch_model: String,
    pub ports: Option<Vec<u16>>,
@@ -42,6 +43,8 @@ pub struct FileConfig {
    pub packet_delay: u32,
    #[cfg(feature = "port_mapping")]
    pub mapping: Vec<String>,
+    pub compressor: Option<String>,
+    pub vnt_mapping: Vec<String>,
 }

 impl Default for FileConfig {
@@ -51,7 +54,10 @@ impl Default for FileConfig {
            tap: false,
            token: "".to_string(),
            device_id: get_device_id(),
-            name: os_info::get().to_string(),
+            name: gethostname::gethostname()
+                .to_str()
+                .unwrap_or("UnknownName")
+                .to_string(),
            server_address: "nat1.wherewego.top:29872".to_string(),
            stun_server: vec![
                "stun1.l.google.com:19302".to_string(),
@@ -69,8 +75,7 @@ impl Default for FileConfig {
            #[cfg(feature = "ip_proxy")]
            no_proxy: false,
            server_encrypt: false,
-            parallel: 1,
-            cipher_model: "aes_gcm".to_string(),
+            cipher_model: None,
            finger: false,
            punch_model: "all".to_string(),
            ports: None,
@@ -81,60 +86,65 @@ impl Default for FileConfig {
            packet_delay: 0,
            #[cfg(feature = "port_mapping")]
            mapping: vec![],
+            compressor: None,
+            vnt_mapping: vec![],
        }
    }
 }

-pub fn read_config(file_path: &str) -> io::Result<(Config, bool)> {
+pub fn read_config(file_path: &str) -> anyhow::Result<(Config, Vec<String>, 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)));
+            return Err(anyhow!("{}", e));
        }
    };
    if file_conf.token.is_empty() {
-        return Err(io::Error::new(io::ErrorKind::Other, "token is_empty"));
+        return Err(anyhow!("token is_empty"));
    }

-    let in_ips = match common::args_parse::ips_parse(&file_conf.in_ips) {
+    let in_ips = match 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),
-            ));
+            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) {
+    let out_ips = match 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),
-            ));
+            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| {
-            io::Error::new(
-                io::ErrorKind::Other,
-                format!("ip {:?} error:{}", &file_conf.ip, e),
-            )
-        })?),
+        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"))?
+        } else if let Some(v) = file_conf.cipher_model {
+            CipherModel::from_str(&v).map_err(|e| anyhow!("{}", e))?
+        } else {
+            CipherModel::None
+        }
+        #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
+        CipherModel::AesGcm
    };

-    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 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")]
+        #[cfg(feature = "integrated_tun")]
        file_conf.tap,
        file_conf.token,
        file_conf.device_id,
@@ -148,43 +158,24 @@ pub fn read_config(file_path: &str) -> io::Result<(Config, bool)> {
        file_conf.mtu,
        file_conf.tcp,
        virtual_ip,
+        #[cfg(feature = "integrated_tun")]
        #[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,
+        #[cfg(feature = "integrated_tun")]
        file_conf.device_name,
        use_channel_type,
        file_conf.packet_loss,
        file_conf.packet_delay,
        #[cfg(feature = "port_mapping")]
        file_conf.mapping,
-    )
-    .unwrap();
-    Ok((config, file_conf.cmd))
-}
+        compressor,
+    )?;

-pub fn get_device_id() -> String {
-    if let Some(id) = common::identifier::get_unique_identifier() {
-        id
-    } else {
-        let path_buf = match crate::app_home() {
-            Ok(path_buf) => path_buf.join("device-id"),
-            Err(e) => {
-                log::warn!("{:?}", e);
-                return String::new();
-            }
-        };
-        if let Ok(id) = std::fs::read_to_string(path_buf.as_path()) {
-            id
-        } else {
-            let id = uuid::Uuid::new_v4().to_string();
-            let _ = std::fs::write(path_buf, &id);
-            id
-        }
-    }
+    Ok((config, file_conf.vnt_mapping, file_conf.cmd))
 }
@@ -0,0 +1,32 @@
+#[cfg(feature = "file_config")]
+mod file_config;
+
+use crate::identifier;
+#[cfg(feature = "file_config")]
+pub use file_config::read_config;
+
+#[cfg(not(feature = "file_config"))]
+pub fn read_config(_file_path: &str) -> anyhow::Result<(vnt::core::Config, Vec<String>, bool)> {
+    unimplemented!()
+}
+
+pub fn get_device_id() -> String {
+    if let Some(id) = identifier::get_unique_identifier() {
+        id
+    } else {
+        let path_buf = match crate::cli::app_home() {
+            Ok(path_buf) => path_buf.join("device-id"),
+            Err(e) => {
+                log::warn!("{:?}", e);
+                return String::new();
+            }
+        };
+        if let Ok(id) = std::fs::read_to_string(path_buf.as_path()) {
+            id
+        } else {
+            let id = uuid::Uuid::new_v4().to_string();
+            let _ = std::fs::write(path_buf, &id);
+            id
+        }
+    }
+}
@@ -1,2 +1,12 @@
 pub mod args_parse;
+#[cfg(feature = "command")]
+pub mod command;
+pub mod config;
+#[cfg(feature = "command")]
+mod console_out;
 pub mod identifier;
+
+pub mod cli;
+mod generated_serial_number;
+
+pub mod callback;
@@ -0,0 +1,30 @@
+[package]
+name = "vn-link-cli"
+version = "1.2.10"
+edition = "2021"
+
+[dependencies]
+vn-link = { path = "../vn-link", default-features = false }
+common = { path = "../common", default-features = false }
+tokio = { version = "1.37.0", features = ["full"] }
+log = "0.4.17"
+
+[features]
+default = ["default-feature"]
+openssl = ["vn-link/openssl","common/openssl"]
+openssl-vendored = ["vn-link/openssl-vendored","common/openssl-vendored"]
+ring-cipher = ["vn-link/ring-cipher","common/ring-cipher"]
+aes_cbc = ["vn-link/aes_cbc","common/aes_cbc"]
+aes_ecb = ["vn-link/aes_ecb","common/aes_ecb"]
+sm4_cbc = ["vn-link/sm4_cbc","common/sm4_cbc"]
+aes_gcm = ["vn-link/aes_gcm","common/aes_gcm"]
+chacha20_poly1305 = ["vn-link/chacha20_poly1305","common/chacha20_poly1305"]
+server_encrypt = ["vn-link/server_encrypt","common/server_encrypt"]
+port_mapping = ["vn-link/port_mapping","common/port_mapping"]
+lz4 = ["vn-link/lz4_compress","common/lz4"]
+zstd = ["vn-link/zstd_compress","common/zstd"]
+log = ["common/log"]
+command = ["common/command"]
+file_config = ["common/file_config"]
+
+default-feature = ["server_encrypt", "aes_gcm", "aes_cbc", "aes_ecb", "sm4_cbc", "chacha20_poly1305", "port_mapping", "log", "command", "file_config", "lz4"]
@@ -0,0 +1,61 @@
+# 端口映射模式
+
+## 一、特点
+
+1. 不需要tap/tun虚拟网卡
+2. 不需要管理员/root权限
+3. 不改变本地路由
+4. 使用端口映射来访问目标服务
+
+## 二、作用
+
+和vnt互补，能简单快速构建网络，外部依赖更少
+
+## 三、使用方式
+
+和vnt的使用方式一样，只是多了"--vnt-mapping"这个参数
+
+### vn-link作为被访问端，不需要额外配置vnt-mapping
+
+### vn-link访问vnt或者vn-link，需要加vnt-mapping
+
+例如：
+
+设备A 运行vnt(虚拟IP 10.26.0.A)，设备B 运行vn-link(虚拟IP 10.26.0.B)。
+
+如果要用B访问A上的tcp 80端口，则在设备B上需要加--vnt-mapping "tcp:port1-10.26.0.A:80"
+
+这个参数的作用是将B上的***本地端口port1***转发到设备A的地址10.26.0.A:
+80，此时在设备B上可以访问本地port1端口从而间接访问10.26.0.A:80
+
+## 四、vn-link的子网代理
+
+vn-link也支持点对网参数。 还是接着上面的例子
+
+假设 设备C在设备A的子网下，C的子网IP为192.168.1.C，A的子网IP为192.168.1.A，要在设备B上访问C
+
+则在B上加这些参数
+
+- --vnt-mapping "tcp:port2-192.168.1.C:80" (将本地port2端口映射到C的80端口)
+- -i 192.168.1.0/24,10.26.0.A (将目标192.168.1.0/24的数据发送到10.26.0.A，也就是A节点)
+
+在A上加参数
+
+- -o 0.0.0.0/0 (允许所有流量转发)
+
+***再次说明，vn-link作为被访问端时和vnt使用方式一致，vn-link作为访问端时需要加--vnt-mapping映射端口***
+
+***vn-link是基于端口映射的使用模式，不会改变本地路由***
+
+## 五、参数介绍
+
+--vnt-mapping支持udp/tcp，例如 --vnt-mapping "tcp:port1-remoteIp:remotePort"
+
+- 第一部分为协议，支持使用udp/tcp
+- 第二部分是本地端口，注意不要和本地服务的端口冲突
+- 第三部分是目标机器的地址，一般是目标虚拟IP地址，如果配置了点对网参数(-i和-o)则也可以是目标子网地址
+
+
+
+
+
@@ -0,0 +1,84 @@
+use common::callback;
+use vn_link::config::VnLinkConfig;
+use vn_link::vnt::core::Config;
+
+fn main() {
+    let (config, vnt_link_config, cmd) = match common::cli::parse_args_config() {
+        Ok(rs) => {
+            if let Some(rs) = rs {
+                rs
+            } else {
+                return;
+            }
+        }
+        Err(e) => {
+            println!("{}", e);
+            return;
+        }
+    };
+    let vnt_link_config = VnLinkConfig::new(vn_link::config::convert(vnt_link_config).unwrap());
+    main0(config, vnt_link_config, cmd)
+}
+
+#[tokio::main]
+async fn main0(config: Config, vn_link_config: VnLinkConfig, _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)
+        }
+    }
+    for x in &vn_link_config.mapping {
+        if x.protocol.is_tcp() {
+            println!("TCP vnt addr mapping 127.0.0.1:{}->{}", x.src_port, x.dest)
+        } else {
+            println!("UDP vnt addr mapping 127.0.0.1:{}->{}", x.src_port, x.dest)
+        }
+    }
+
+    let vnt_util = match vn_link::VnLink::new(config, vn_link_config, callback::VntHandler {}).await
+    {
+        Ok(vnt) => vnt,
+        Err(e) => {
+            println!("error: {:?}", e);
+            std::process::exit(1);
+        }
+    };
+
+    #[cfg(feature = "command")]
+    {
+        let vnt_c = vnt_util.as_vnt().clone();
+        std::thread::Builder::new()
+            .name("CommandServer".into())
+            .spawn(move || {
+                if let Err(e) = common::command::server::CommandServer::new().start(vnt_c) {
+                    log::warn!("cmd:{:?}", e);
+                }
+            })
+            .expect("CommandServer");
+        let vnt_c = vnt_util.as_vnt();
+        if _show_cmd {
+            use tokio::io::AsyncBufReadExt;
+            let mut cmd = String::new();
+            let mut reader = tokio::io::BufReader::new(tokio::io::stdin());
+            loop {
+                cmd.clear();
+                println!("======== input:list,info,route,all,stop ========");
+                match reader.read_line(&mut cmd).await {
+                    Ok(len) => {
+                        if !common::command::command_str(&cmd[..len], vnt_c) {
+                            break;
+                        }
+                    }
+                    Err(e) => {
+                        println!("input err:{}", e);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    vnt_util.wait().await
+}
@@ -0,0 +1,29 @@
+[package]
+name = "vn-link"
+version = "1.2.10"
+edition = "2021"
+
+[dependencies]
+lwip-rs = { git = "https://github.com/lbl8603/lwip-rs" }
+vnt = { path = "../vnt", package = "vnt", default-features = false }
+log = "0.4.17"
+anyhow = "1.0.82"
+parking_lot = "0.12.1"
+
+tokio = { version = "1.37.0", features = ["full"] }
+crossbeam-utils = "0.8"
+
+[features]
+default = ["server_encrypt", "aes_gcm", "aes_cbc", "aes_ecb", "sm4_cbc", "chacha20_poly1305", "port_mapping", "lz4_compress"]
+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"]
+chacha20_poly1305 = ["vnt/chacha20_poly1305"]
+server_encrypt = ["vnt/server_encrypt"]
+port_mapping = ["vnt/port_mapping"]
+lz4_compress = ["vnt/lz4_compress"]
+zstd_compress = ["vnt/zstd_compress"]
@@ -0,0 +1,85 @@
+use anyhow::Context;
+use std::net::SocketAddr;
+use std::str::FromStr;
+
+#[derive(Clone, Debug)]
+pub struct VnLinkConfig {
+    pub mapping: Vec<LinkItem>,
+}
+
+impl VnLinkConfig {
+    pub fn new(mapping: Vec<LinkItem>) -> Self {
+        Self { mapping }
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum LinkProtocol {
+    Tcp,
+    Udp,
+}
+
+impl LinkProtocol {
+    pub fn is_tcp(&self) -> bool {
+        self == &LinkProtocol::Tcp
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct LinkItem {
+    pub protocol: LinkProtocol,
+    pub src_port: u16,
+    pub dest: SocketAddr,
+}
+
+impl LinkItem {
+    pub fn new(protocol: LinkProtocol, src_port: u16, dest: SocketAddr) -> Self {
+        Self {
+            protocol,
+            src_port,
+            dest,
+        }
+    }
+}
+
+pub fn convert(vec: Vec<String>) -> anyhow::Result<Vec<LinkItem>> {
+    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_port = split
+                .next()
+                .with_context(|| format!("vnt-mapping error {:?},eg: udp:80-10.26.0.10:8080", x))?;
+            let bind_port = u16::from_str(bind_port)
+                .with_context(|| format!("udp_mapping error {}", bind_port))?;
+            let dest = split
+                .next()
+                .with_context(|| format!("vnt-mapping error {:?},eg: udp:80-10.26.0.10:8080", x))?;
+            let dest_addr = SocketAddr::from_str(dest)
+                .with_context(|| format!("udp_mapping error {}", dest))?;
+            rs.push(LinkItem::new(LinkProtocol::Udp, bind_port, dest_addr));
+            continue;
+        }
+        if let Some(tcp_mapping) = string.strip_prefix("tcp:") {
+            let mut split = tcp_mapping.split("-");
+            let bind_port = split
+                .next()
+                .with_context(|| format!("vnt-mapping error {:?},eg: tcp:80-10.26.0.10:8080", x))?;
+            let bind_port = u16::from_str(bind_port)
+                .with_context(|| format!("tcp_mapping error {}", bind_port))?;
+            let dest = split
+                .next()
+                .with_context(|| format!("vnt-mapping error {:?},eg: tcp:80-10.26.0.10:8080", x))?;
+            let dest_addr = SocketAddr::from_str(dest)
+                .with_context(|| format!("tcp_mapping error {}", dest))?;
+            rs.push(LinkItem::new(LinkProtocol::Tcp, bind_port, dest_addr));
+            continue;
+        }
+        Err(anyhow::anyhow!(
+            "vnt-mapping error {:?},eg: tcp:80-10.26.0.10:8080",
+            x
+        ))?;
+    }
+    Ok(rs)
+}
@@ -0,0 +1,2 @@
+pub mod tcp;
+pub mod udp;
@@ -0,0 +1,46 @@
+use crate::out_mapping::tcp::tcp_copy;
+use crossbeam_utils::atomic::AtomicCell;
+use lwip_rs::tcp_stream::TcpStream as LwIpTcpStream;
+use std::net::{IpAddr, SocketAddr};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::net::TcpListener;
+use vnt::handle::CurrentDeviceInfo;
+
+pub async fn tcp_mapping_listen(
+    tcp_listener: TcpListener,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    dest: SocketAddr,
+) {
+    loop {
+        let (stream, addr) = match tcp_listener.accept().await {
+            Ok((stream, addr)) => (stream, addr),
+            Err(e) => {
+                log::warn!("tcp_mapping_listen {:?} dest {}", e, dest);
+                continue;
+            }
+        };
+        let current_info = current_device.load();
+        if current_info.virtual_ip.is_unspecified() {
+            continue;
+        }
+        if let IpAddr::V4(ip) = dest.ip() {
+            if ip == current_info.virtual_ip {
+                //防止用错参数的
+                log::warn!("目的地址不能是本地虚拟ip tcp->{}", dest);
+                continue;
+            }
+        }
+        let src = SocketAddr::new(IpAddr::V4(current_info.virtual_ip), addr.port());
+        tokio::spawn(async move {
+            match LwIpTcpStream::connect(src, dest, Duration::from_secs(5)).await {
+                Ok(lw_tcp) => {
+                    tcp_copy(lw_tcp, stream);
+                }
+                Err(e) => {
+                    log::warn!("{}  {}->{} {}", addr, src, dest, e);
+                }
+            };
+        });
+    }
+}
@@ -0,0 +1,63 @@
+use std::collections::HashMap;
+use std::net::{IpAddr, SocketAddr};
+use std::sync::Arc;
+use std::time::Instant;
+
+use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;
+use tokio::net::UdpSocket;
+
+use lwip_rs::udp::UdpSocketWrite;
+use vnt::handle::CurrentDeviceInfo;
+
+pub async fn udp_mapping_start(
+    udp: UdpSocket,
+    lwip_udp_write: UdpSocketWrite,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    in_udp_map: &Arc<
+        Mutex<
+            HashMap<
+                (SocketAddr, SocketAddr),
+                (Arc<UdpSocket>, Option<SocketAddr>, Arc<AtomicCell<Instant>>),
+            >,
+        >,
+    >,
+
+    dest: SocketAddr,
+) {
+    let udp = Arc::new(udp);
+    let mut buf = [0u8; 65536];
+    loop {
+        let (len, addr) = match udp.recv_from(&mut buf).await {
+            Ok(rs) => rs,
+            Err(e) => {
+                log::warn!("recv_from {} {}", dest, e);
+                continue;
+            }
+        };
+        let current_info = current_device.load();
+        if current_info.virtual_ip.is_unspecified() {
+            continue;
+        }
+        if let IpAddr::V4(ip) = dest.ip() {
+            if ip == current_info.virtual_ip {
+                //防止用错参数的
+                log::warn!("目的地址不能是本地虚拟ip udp->{}", dest);
+                continue;
+            }
+        }
+        let src = SocketAddr::new(IpAddr::V4(current_info.virtual_ip), addr.port());
+        in_udp_map.lock().insert(
+            (dest, src),
+            (
+                udp.clone(),
+                Some(addr),
+                Arc::new(AtomicCell::new(Instant::now())),
+            ),
+        );
+
+        if let Err(e) = lwip_udp_write.send(&buf[..len], &src, &dest) {
+            log::warn!("lwip_udp_write {}->{} {}", src, dest, e);
+        }
+    }
+}
@@ -0,0 +1,8 @@
+pub mod config;
+mod in_mapping;
+mod out_mapping;
+mod vnt_link;
+
+pub use vnt;
+
+pub use vnt_link::*;
@@ -0,0 +1,2 @@
+pub mod tcp;
+pub mod udp;
@@ -0,0 +1,64 @@
+use std::net::{IpAddr, Ipv4Addr};
+use std::sync::Arc;
+
+use crossbeam_utils::atomic::AtomicCell;
+use tokio::net::TcpStream;
+
+use lwip_rs::tcp_listener::TcpListener;
+use lwip_rs::tcp_stream::TcpStream as LwIpTcpStream;
+use vnt::handle::CurrentDeviceInfo;
+
+pub async fn tcp_mapping_listen(
+    mut tcp_listener: TcpListener,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+) {
+    loop {
+        let stream = match tcp_listener.accept().await {
+            Ok(stream) => stream,
+            Err(e) => {
+                log::warn!("tcp_mapping_listen err  {:?}", e);
+                break;
+            }
+        };
+        let device_info = current_device.load();
+        tokio::spawn(async move {
+            let dest = stream.dest_addr();
+            let src = stream.src_addr();
+            if let Err(e) = tcp_mapping_handle(stream, device_info).await {
+                log::warn!("tcp_mapping_handle {}->{} {:?}", src, dest, e)
+            }
+        });
+    }
+}
+
+async fn tcp_mapping_handle(
+    tcp_stream: LwIpTcpStream,
+    device_info: CurrentDeviceInfo,
+) -> anyhow::Result<()> {
+    let mut dest = tcp_stream.dest_addr();
+    // let src = tcp_stream.src_addr();
+    if let IpAddr::V4(ip) = dest.ip() {
+        if ip.is_unspecified()
+            || ip.is_broadcast()
+            || ip.is_multicast()
+            || ip == device_info.virtual_ip
+            || ip == device_info.broadcast_ip
+        {
+            //是自己
+            dest.set_ip(IpAddr::V4(Ipv4Addr::LOCALHOST));
+        }
+    }
+    let peer_stream = TcpStream::connect(dest).await?;
+    if dest.port() == peer_stream.local_addr()?.port() {
+        return Err(anyhow::anyhow!("tcp port loop"));
+    }
+    tcp_copy(tcp_stream, peer_stream);
+    Ok(())
+}
+
+pub(crate) fn tcp_copy(lw_tcp: LwIpTcpStream, tokio_tcp: TcpStream) {
+    let (mut write, mut read) = lw_tcp.into_split();
+    let (mut peer_read, mut peer_write) = tokio_tcp.into_split();
+    tokio::spawn(async move { tokio::io::copy(&mut read, &mut peer_write).await });
+    tokio::spawn(async move { tokio::io::copy(&mut peer_read, &mut write).await });
+}
@@ -0,0 +1,137 @@
+use crossbeam_utils::atomic::AtomicCell;
+use lwip_rs::udp::{UdpSocketRead, UdpSocketWrite};
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::net::UdpSocket;
+use vnt::handle::CurrentDeviceInfo;
+
+pub async fn udp_mapping_start(
+    lwip_udp_write: UdpSocketWrite,
+    mut lwip_udp_read: UdpSocketRead,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    in_udp_map: Arc<
+        Mutex<
+            HashMap<
+                (SocketAddr, SocketAddr),
+                (Arc<UdpSocket>, Option<SocketAddr>, Arc<AtomicCell<Instant>>),
+            >,
+        >,
+    >,
+) {
+    loop {
+        let (buf, src, dest) = match lwip_udp_read.recv().await {
+            Ok(rs) => rs,
+            Err(e) => {
+                log::warn!("udp_mapping err  {:?}", e);
+                break;
+            }
+        };
+        if let Err(e) = handle(
+            &current_device,
+            &lwip_udp_write,
+            &in_udp_map,
+            buf,
+            src,
+            dest,
+        )
+        .await
+        {
+            log::warn!("udp_mapping err {}->{} {:?}", src, dest, e)
+        }
+    }
+}
+
+async fn handle(
+    current_device: &AtomicCell<CurrentDeviceInfo>,
+    lwip_udp_write: &UdpSocketWrite,
+    map: &Arc<
+        Mutex<
+            HashMap<
+                (SocketAddr, SocketAddr),
+                (Arc<UdpSocket>, Option<SocketAddr>, Arc<AtomicCell<Instant>>),
+            >,
+        >,
+    >,
+    buf: Vec<u8>,
+    src: SocketAddr,
+    dest: SocketAddr,
+) -> anyhow::Result<()> {
+    let option = map.lock().get(&(src, dest)).cloned();
+
+    if let Some((dest_udp, addr, time)) = option {
+        time.store(Instant::now());
+        if let Some(addr) = addr {
+            dest_udp.send_to(&buf, addr).await?;
+        } else {
+            dest_udp.send(&buf).await?;
+        }
+    } else {
+        let mut real_dest = dest;
+        let peer_udp_socket = match UdpSocket::bind(format!("0.0.0.0:{}", src.port())).await {
+            Ok(udp) => udp,
+            Err(_) => UdpSocket::bind("0.0.0.0:0").await?,
+        };
+        if let IpAddr::V4(ip) = dest.ip() {
+            let device_info = current_device.load();
+            if ip.is_unspecified()
+                || ip.is_broadcast()
+                || ip.is_multicast()
+                || ip == device_info.virtual_ip
+                || ip == device_info.broadcast_ip
+            {
+                //是自己
+                real_dest.set_ip(IpAddr::V4(Ipv4Addr::LOCALHOST));
+            }
+        }
+        peer_udp_socket.connect(real_dest).await?;
+        peer_udp_socket.send(&buf).await?;
+        let peer_udp_socket = Arc::new(peer_udp_socket);
+        let time = Arc::new(AtomicCell::new(Instant::now()));
+        let map = map.clone();
+        map.lock()
+            .insert((src, dest), (peer_udp_socket.clone(), None, time.clone()));
+        let lwip_udp_write = lwip_udp_write.clone();
+        tokio::spawn(async move {
+            peer_udp_handle(peer_udp_socket, lwip_udp_write, src, dest, time).await;
+            map.lock().remove(&(src, dest));
+        });
+    }
+    Ok(())
+}
+
+async fn peer_udp_handle(
+    peer_udp_socket: Arc<UdpSocket>,
+    lwip_udp_write: UdpSocketWrite,
+    src: SocketAddr,
+    dest: SocketAddr,
+    time: Arc<AtomicCell<Instant>>,
+) {
+    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 lwip_udp_write.send(&buf[..len], &dest, &src) {
+                    Ok(_) => {}
+                    Err(e) => {
+                        log::warn!("udp proxy {}->{} {:?}", dest, src, e);
+                        break;
+                    }
+                },
+                Err(e) => {
+                    log::warn!("udp proxy {}->{} {:?}", dest, src, e);
+                    break;
+                }
+            },
+            Err(_) => {
+                if time.load().elapsed() > Duration::from_secs(580) {
+                    //超时关闭
+                    log::warn!("udp proxy timeout {}->{}", dest, src,);
+                    break;
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,217 @@
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Instant;
+
+use anyhow::Context;
+use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;
+use tokio::net::{TcpListener, UdpSocket};
+use tokio::sync::watch::{channel, Sender};
+
+use lwip_rs::stack::{NetStack, NetStackWrite};
+use lwip_rs::tcp_listener::TcpListener as LwIPTcpListener;
+use lwip_rs::udp::{UdpSocket as LwIpUdpSocket, UdpSocketWrite};
+use vnt::channel::BUFFER_SIZE;
+use vnt::core::{Config, Vnt};
+use vnt::packet::ip::ipv4::packet::IpV4Packet;
+use vnt::protocol::HEAD_LEN;
+use vnt::vnt_device::DeviceWrite;
+use vnt::VntCallback;
+
+use crate::config::{LinkItem, LinkProtocol, VnLinkConfig};
+use crate::{in_mapping, out_mapping};
+
+pub struct VnLink {
+    vnt: Vnt,
+    in_udp_map: Arc<
+        Mutex<
+            HashMap<
+                (SocketAddr, SocketAddr),
+                (Arc<UdpSocket>, Option<SocketAddr>, Arc<AtomicCell<Instant>>),
+            >,
+        >,
+    >,
+    lwip_udp_write: UdpSocketWrite,
+    shutdown_tx: Sender<bool>,
+}
+
+impl VnLink {
+    pub async fn new<Call: VntCallback>(
+        vnt_config: Config,
+        vn_link_config: VnLinkConfig,
+        callback: Call,
+    ) -> anyhow::Result<Self> {
+        let stack = NetStack::new(HEAD_LEN, 1024, vnt_config.mtu.unwrap_or(1420) as u16).await;
+        let udp = LwIpUdpSocket::new()?;
+        let tcp_listener = LwIPTcpListener::new()?;
+        let (shutdown_tx, shutdown_rx) = channel(false);
+        let (net_stack_write, mut net_stack_read) = stack.into_split();
+        let vnt = Vnt::new_device(vnt_config, callback, VntDevice { net_stack_write })?;
+        let shutdown_tx_ = shutdown_tx.clone();
+        let w = vnt.add_stop_listener("vnt-link".into(), move || {
+            let _ = shutdown_tx_.send(true);
+        })?;
+        let ip_sender = vnt.ipv4_packet_sender().unwrap();
+        let mut shutdown_rx_ = shutdown_rx.clone();
+        tokio::spawn(async move {
+            let mut extend = [0; BUFFER_SIZE];
+            loop {
+                tokio::select! {
+                    _ = shutdown_rx_.changed() => {
+                        break;
+                    }
+                    rs = net_stack_read.recv_ip() => {
+                         match rs{
+                              Ok((mut buf, start_index, len)) => {
+                                let ipv4_packet = if let Ok(packet) =
+                                     IpV4Packet::new(&buf[start_index..len])
+                                {
+                                    packet
+                                } else {
+                                    continue;
+                                };
+                                let destination_ip = ipv4_packet.destination_ip();
+                                let source_ip = ipv4_packet.source_ip();
+
+                                if let Err(e) = ip_sender.send_ip(&mut buf, len, &mut extend, destination_ip) {
+                                    log::warn!("{}->{},{}", source_ip, destination_ip, e);
+                                }
+                            },
+                            Err(e) => {
+                                log::error!("net_stack_read {:?}", e);
+                                break;
+                            }
+                        };
+                    }
+                }
+            }
+            w.stop_all();
+        });
+
+        let (lwip_udp_write, lwip_udp_read) = udp.into_split();
+        let in_udp_map: Arc<
+            Mutex<
+                HashMap<
+                    (SocketAddr, SocketAddr),
+                    (Arc<UdpSocket>, Option<SocketAddr>, Arc<AtomicCell<Instant>>),
+                >,
+            >,
+        > = Arc::new(Mutex::new(HashMap::new()));
+
+        let current_device_info = vnt.current_device_info();
+        let in_udp_map_ = in_udp_map.clone();
+        let lwip_udp_write_ = lwip_udp_write.clone();
+        let vnt_ = vnt.clone();
+        let mut shutdown_rx_ = shutdown_rx.clone();
+        tokio::spawn(async move {
+            tokio::select! {
+                _ = shutdown_rx_.changed() => {}
+                _ = out_mapping::udp::udp_mapping_start(
+                    lwip_udp_write_,
+                    lwip_udp_read,
+                    current_device_info,
+                    in_udp_map_,
+                ) => {}
+            }
+
+            vnt_.stop();
+        });
+        let current_device_info = vnt.current_device_info();
+        let vnt_ = vnt.clone();
+        let mut shutdown_rx_ = shutdown_rx.clone();
+
+        tokio::spawn(async move {
+            tokio::select! {
+                _ = shutdown_rx_.changed() => {}
+                _ = out_mapping::tcp::tcp_mapping_listen(tcp_listener, current_device_info) => {}
+            }
+            vnt_.stop();
+        });
+        let link = Self {
+            vnt,
+            in_udp_map,
+            lwip_udp_write,
+            shutdown_tx,
+        };
+        link.add_mapping(vn_link_config.mapping).await?;
+        Ok(link)
+    }
+    pub async fn add_mapping(&self, mapping: Vec<LinkItem>) -> anyhow::Result<()> {
+        for item in mapping {
+            let current_device_info = self.vnt.current_device_info();
+            if item.dest.ip().is_unspecified() {
+                Err(anyhow::anyhow!("dest_address {:?} is_unspecified", item))?
+            }
+            let mut shutdown_rx_ = self.shutdown_tx.subscribe();
+            if *shutdown_rx_.borrow() {
+                Err(anyhow::anyhow!("mapping stop"))?
+            }
+            if item.protocol == LinkProtocol::Udp {
+                let lwip_udp_write = self.lwip_udp_write.clone();
+                let in_udp_map = self.in_udp_map.clone();
+                //只能本机访问，不然不同IP的相同来源端口会有问题
+                let udp = UdpSocket::bind(format!("127.0.0.1:{}", item.src_port))
+                    .await
+                    .with_context(|| format!("udp bind failed {}", item.src_port))?;
+                tokio::spawn(async move {
+                    tokio::select! {
+                        _ = shutdown_rx_.changed() => {}
+                        _ = in_mapping::udp::udp_mapping_start(
+                                udp,
+                                lwip_udp_write,
+                                current_device_info,
+                                &in_udp_map,
+                                item.dest,
+                        ) => {}
+                    }
+                });
+            } else {
+                let listener = TcpListener::bind(format!("127.0.0.1:{}", item.src_port))
+                    .await
+                    .with_context(|| format!("tcp bind failed {}", item.src_port))?;
+                tokio::spawn(async move {
+                    tokio::select! {
+                        _ = shutdown_rx_.changed() => {}
+                        _ = in_mapping::tcp::tcp_mapping_listen(
+                            listener,
+                            current_device_info,
+                            item.dest,
+                        ) => {}
+                    }
+                });
+            }
+        }
+        Ok(())
+    }
+    pub fn stop(&self) {
+        self.as_vnt().stop()
+    }
+    pub async fn wait(&self) {
+        loop {
+            let mut receiver = self.shutdown_tx.subscribe();
+            if *receiver.borrow() {
+                return;
+            }
+            if receiver.changed().await.is_err() {
+                return;
+            }
+        }
+    }
+
+    pub fn as_vnt(&self) -> &Vnt {
+        &self.vnt
+    }
+}
+
+#[derive(Clone)]
+pub struct VntDevice {
+    net_stack_write: NetStackWrite,
+}
+
+impl DeviceWrite for VntDevice {
+    fn write(&self, buf: &[u8]) -> std::io::Result<usize> {
+        self.net_stack_write.send_ip(buf)?;
+        Ok(buf.len())
+    }
+}
@@ -1,45 +1,46 @@
 [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 }
-common = { path = "../common" }
-getopts = "0.2.21"
-console = "0.15.2"
-os_info = "3.7.0"
-serde = "1.0"
-serde_yaml = "0.9.32"
+vnt = { path = "../vnt", package = "vnt", default-features = false, features = ["integrated_tun"] }
+common = { path = "../common", default-features = false, features = ["integrated_tun"] }
 log = "0.4.17"
-log4rs = "1.2.0"
-[dependencies.uuid]
-version = "1.4.1"
-features = [
-    "v4", # Lets you generate random UUIDs
-]
+anyhow = "1.0.82"
+

 [target.'cfg(any(target_os = "linux",target_os = "macos"))'.dependencies]
 sudo = "0.6.0"
+signal-hook = "0.3.17"

 [target.'cfg(target_os = "windows")'.dependencies]
 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", "port_mapping"]
-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"]
-port_mapping = ["vnt/port_mapping"]
+default = ["default-feature"]
+default-feature = ["server_encrypt", "aes_gcm", "aes_cbc", "aes_ecb", "sm4_cbc", "chacha20_poly1305", "ip_proxy", "port_mapping", "log", "command", "file_config", "lz4"]
+
+openssl = ["vnt/openssl", "common/openssl"]
+openssl-vendored = ["vnt/openssl-vendored", "common/openssl-vendored"]
+ring-cipher = ["vnt/ring-cipher", "common/ring-cipher"]
+aes_cbc = ["vnt/aes_cbc", "common/aes_cbc"]
+aes_ecb = ["vnt/aes_ecb", "common/aes_ecb"]
+sm4_cbc = ["vnt/sm4_cbc", "common/sm4_cbc"]
+aes_gcm = ["vnt/aes_gcm", "common/aes_gcm"]
+chacha20_poly1305 = ["vnt/chacha20_poly1305", "common/chacha20_poly1305"]
+server_encrypt = ["vnt/server_encrypt", "common/server_encrypt"]
+port_mapping = ["vnt/port_mapping", "common/port_mapping"]
+lz4 = ["vnt/lz4_compress", "common/lz4"]
+zstd = ["vnt/zstd_compress", "common/zstd"]
+ip_proxy = ["vnt/ip_proxy", "common/ip_proxy"]
+log = ["common/log"]
+command = ["common/command"]
+file_config = ["common/file_config"]
+
+
 [build-dependencies]
-embed-manifest = "1.4.0"
 rand = "0.8.5"
 chrono = "0.4.23"
@@ -1,33 +1,56 @@
 ## 模块介绍
+
 体积小，可以在服务器、路由器等环境使用
+
 ## 详细参数说明
+
 ### -k `<token>`
+
 一个虚拟局域网的标识，在同一服务器下，相同token的设备会组建一个局域网
+
 ### -n `<name>`
+
 设备名称，方便区分不同设备
+
 ### -d `<id>`
+
 设备id，每台设备的唯一标识，注意不要重复
+
 ### -c
+
 关闭控制台交互式命令，后台运行时可以加此参数
+
 ### -s `<server>`
+
 注册和中继服务器地址，注册和转发数据，以'TXT:'开头表示解析TXT记录，TXT记录内容必须是'host:port'形式的服务器地址
+
 ### -e `<stun-server>`
+
 使用stun服务探测客户端NAT类型，不同类型有不同的打洞策略
+
 ### -a
+
 加了此参数表示使用tap网卡，默认使用tun网卡，tun网卡效率更高

 注意：仅在windows上支持使用tap，用于兼容低版本windows系统（低版本windows不支持wintun）
+
+使用tap模式需要手动创建tap网卡，使用--nic参数指定已经创建好的tap网卡名称
+
 ### --nic `<tun0>`
+
 指定虚拟网卡名称，默认tun模式使用vnt-tun，tap模式使用vnt-tap
+
 ### -i `<in-ip>`、-o  `<out-ip>`

-配置点对网(IP代理)时使用，例如A(虚拟ip:10.26.0.2)通过B(虚拟ip:10.26.0.3,本地出口ip:192.168.0.10)访问C(目标网段192.168.0.0/24)，
+配置点对网(IP代理)时使用，例如A(虚拟ip:10.26.0.2)通过B(虚拟ip:10.26.0.3,本地出口ip:192.168.0.10)访问C(
+目标网段192.168.0.0/24)，

 则在A配置 **'-i 192.168.0.0/24,10.26.0.3'** ,表示将192.168.0.0/24网段的数据都转发到10.26.0.3节点

 在B配置 **'-o 192.168.0.0/24'**  ,表示允许将数据转发到 192.168.0.0/24 ,允许转发所有网段可以使用 **'-o 0.0.0.0/0'**

-i和-o参数均可使用多次，来指定不同网段，例如 **'-o 192.168.1.0/24 -o 192.168.2.0/24'** 表示允许转发目标为192.168.1.0/24或192.168.2.0/24这两个网段的数据
+-i和-o参数均可使用多次，来指定不同网段，例如 **'-o 192.168.1.0/24 -o 192.168.2.0/24'**
+表示允许转发目标为192.168.1.0/24或192.168.2.0/24这两个网段的数据

 ### -w `<password>`

@@ -39,9 +62,11 @@
 | 大于等于8 | AES256-GCM | 

 ### -W
+
 开启和服务端通信的数据加密，采用rsa+aes256gcm加密客户端和服务端之间通信的数据，可以避免token泄漏、中间人攻击

 注意：
+
 1. -w `<password>`是用于客户端-客户端之间的加密，password不会传递到服务端，只添加这个参数不会加密客户端-服务端通信的数据
 2. -W 用于开启客户端-服务端之间的加密

@@ -49,55 +74,93 @@

 设置虚拟网卡的mtu值，大多数情况下使用默认值效率会更高，也可根据实际情况微调这个值，不加密默认为1450，加密默认为1410

-###  --tcp
+### --tcp
+
 和服务端使用tcp通信。有些网络提供商对UDP限制比较大，这个时候可以选择使用TCP模式，提高稳定性。一般来说udp延迟和消耗更低
+
 ### --ip `<IP>`
+
 指定虚拟ip,指定的ip不能和其他设备重复,必须有效并且在服务端所属网段下,默认情况由服务端分配
+
 ### --par `<parallel>`
+
 任务并行度(必须为正整数),默认值为1,该值表示处理网卡读写的任务数,组网设备数较多、处理延迟较大时可适当调大此值
+
 ### --model `<model>`
-加密模式，可选值 aes_gcm/aes_cbc/aes_ecb/sm4_cbc，默认使用aes_gcm，通常情况aes_gcm安全性高、aes_ecb性能更好，但是在低性能设备上sm4_cbc也许速度会更快；

+加密模式，可选值
+aes_gcm/aes_cbc/aes_ecb/sm4_cbc/chacha20_poly1305/chacha20/xor，默认使用aes_gcm，通常情况aes_gcm和chacha20_poly1305安全性高。
+各种加密模式的安全性和速度都不相同，请按需选取

-| 密码位数  | model   | 加密算法       |  
-|-------|---------|------------|
-| 1~8位  | aes_gcm | AES128-GCM |
-| `>=`8 | aes_gcm | AES256-GCM |
-| 1~8位  | aes_cbc | AES128-CBC |
-| `>=`8 | aes_cbc | AES256-CBC |
-| 1~8位  | aes_ecb | AES128-ECB |
-| `>=`8 | aes_ecb | AES256-ECB |
-| `>0`  | sm4_cbc | SM4-CBC    |
-### --finger 
+特别说明：xor只是对数据进行简单异或，仅仅避免了明文传输，安全性很差，同时对性能影响也极小；
+
+| 密码位数   | model             | 加密算法              |  
+|--------|-------------------|-------------------|
+| `< 8`  | aes_gcm           | AES128-GCM        |
+| `>= 8` | aes_gcm           | AES256-GCM        |
+| `< 8`  | aes_cbc           | AES128-CBC        |
+| `>= 8` | aes_cbc           | AES256-CBC        |
+| `< 8`  | aes_ecb           | AES128-ECB        |
+| `>= 8` | aes_ecb           | AES256-ECB        |
+| `> 0`  | sm4_cbc           | SM4-CBC           |
+| `> 0`  | chacha20_poly1305 | ChaCha20-Poly1305 |
+| `> 0`  | chacha20          | ChaCha20          |
+| `> 0`  | xor               | 简单异或混淆            |
+
+### --finger

 开启数据指纹校验，可增加安全性，如果服务端开启指纹校验，则客户端也必须开启，开启会损耗一部分性能

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

 - 例1：‘--ports 12345,12346,12347’ 表示udp监听12345、12346、12347这三个端口，tcp监听12345端口
 - 例2：‘--ports 0,0’ 表示udp监听两个未使用的端口，tcp监听一个未使用的端口
+
 ### --cmd
+
 开启交互式命令，开启后可以直接在窗口下输入命令，如需后台运行请勿开启
+
 ### --first_latency
+
 优先使用低延迟通道，默认情况下优先使用p2p通道，某些情况下可能p2p比客户端中继延迟更高，可使用此参数进行优化传输
+
 ### --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'
+### --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 仅在windows上支持使用tap
@@ -105,7 +168,7 @@ token: xxx #组网token
 device_id: xxx #当前设备id
 name: windows 11 #当前设备名称
 server_address: ip:port #注册和中继服务器
-stun_server:  #stun服务器
+stun_server: #stun服务器
  - stun1.l.google.com:19302
  - stun2.l.google.com:19302
 in_ips: #代理ip入站
@@ -122,7 +185,7 @@ parallel: 1 #任务并行度
 cipher_model: aes_gcm #客户端加密算法
 finger: false #关闭数据指纹
 punch_model: ipv4 #打洞模式，表示只使用ipv4地址打洞，默认会同时使用v6和v4
-ports: 
+ports:
  - 0 #使用随机端口，tcp监听此端口
  - 0
 cmd: false #关闭控制台输入
@@ -135,31 +198,47 @@ 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数据
+  - 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是必须的
+
 ```yaml
 # 部分参数
 token: xxx #组网token
 ```
+
 ### --use-channel `<relay/p2p>`
+
 - relay:仅中继模式，会禁止打洞/p2p直连，只使用服务器转发
 - p2p:仅直连模式，会禁止网络数据从服务器/客户端转发，只会使用服务器转发控制包
+
 ### --packet-loss `<0>`
+
 模拟丢包，取值0~1之间的小数，程序会按设定的概率主动丢包。在模拟弱网环境时会有帮助。
+
 ### --packet-delay `<0>`
+
 模拟延迟,整数,单位毫秒(ms),程序会按设定的值延迟发包,可用于模拟弱网

 ### --list
+
 在后台运行时,查看其他设备列表
+
 ### --all
+
 在后台运行时,查看其他设备完整信息
+
 ### --info
+
 在后台运行时,查看当前设备信息
-### --route 
+
+### --route
+
 在后台运行时,查看数据转发路径
+
 ### --stop
+
 停止后台运行
@@ -1,348 +1,29 @@
-use std::net::Ipv4Addr;
-use std::path::PathBuf;
-use std::str::FromStr;
-use std::{io, thread};
-
-use console::style;
-use getopts::Options;
-
-use common::args_parse::{ips_parse, out_ips_parse};
-use vnt::channel::punch::PunchModel;
-use vnt::channel::UseChannelType;
-use vnt::cipher::CipherModel;
+use common::callback;
 use vnt::core::{Config, Vnt};
-
-mod command;
-mod config;
-mod console_out;
-mod generated_serial_number;
 mod root_check;
-
-pub fn app_home() -> io::Result<PathBuf> {
-    let root_path = match std::env::current_exe() {
-        Ok(path) => {
-            if let Some(v) = path.as_path().parent() {
-                v.to_path_buf()
+fn main() {
+    let (config, _vnt_link_config, cmd) = match common::cli::parse_args_config() {
+        Ok(rs) => {
+            if let Some(rs) = rs {
+                rs
            } else {
-                log::warn!("current_exe parent none:{:?}", path);
-                PathBuf::new()
+                return;
            }
        }
        Err(e) => {
-            log::warn!("current_exe err:{:?}", e);
-            PathBuf::new()
-        }
-    };
-    let path = root_path.join("env");
-    if !path.exists() {
-        std::fs::create_dir_all(&path)?;
-    }
-    Ok(path)
-}
-
-fn main() {
-    let _ = log4rs::init_file("log4rs.yaml", Default::default());
-    let args: Vec<String> = std::env::args().collect();
-    let program = args[0].clone();
-    let mut opts = Options::new();
-    opts.optopt("k", "", "组网标识", "<token>");
-    opts.optopt("n", "", "设备名称", "<name>");
-    opts.optopt("d", "", "设备标识", "<id>");
-    opts.optflag("c", "", "关闭交互式命令");
-    opts.optopt("s", "", "注册和中继服务器地址", "<server>");
-    opts.optmulti("e", "", "stun服务器", "<stun-server>");
-    opts.optflag("a", "", "使用tap模式");
-    opts.optopt("", "nic", "虚拟网卡名称,windows下使用tap则必填", "<tun0>");
-    opts.optmulti("i", "", "配置点对网(IP代理)入站时使用", "<in-ip>");
-    opts.optmulti("o", "", "配置点对网出站时使用", "<out-ip>");
-    opts.optopt("w", "", "客户端加密", "<password>");
-    opts.optflag("W", "", "服务端加密");
-    opts.optopt("u", "", "自定义mtu(默认为1430)", "<mtu>");
-    opts.optflag("", "tcp", "tcp");
-    opts.optopt("", "ip", "指定虚拟ip", "<ip>");
-    opts.optflag("", "relay", "仅使用服务器转发");
-    opts.optopt("", "par", "任务并行度(必须为正整数)", "<parallel>");
-    opts.optopt("", "model", "加密模式", "<model>");
-    opts.optflag("", "finger", "指纹校验");
-    opts.optopt("", "punch", "取值ipv4/ipv6", "<punch>");
-    opts.optopt("", "ports", "监听的端口", "<port,port>");
-    opts.optflag("", "cmd", "开启窗口输入");
-    opts.optflag("", "no-proxy", "关闭内置代理");
-    opts.optflag("", "first-latency", "优先延迟");
-    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.optflag("", "list", "后台运行时,查看其他设备列表");
-    opts.optflag("", "all", "后台运行时,查看其他设备完整信息");
-    opts.optflag("", "info", "后台运行时,查看当前设备信息");
-    opts.optflag("", "route", "后台运行时,查看数据转发路径");
-    opts.optflag("", "stop", "停止后台运行");
-    opts.optflag("h", "help", "帮助");
-    let matches = match opts.parse(&args[1..]) {
-        Ok(m) => m,
-        Err(f) => {
-            print_usage(&program, opts);
-            println!("{}", f.to_string());
+            println!("{}", e);
            return;
        }
    };
-    if matches.opt_present("h") || args.len() == 1 {
-        print_usage(&program, opts);
-        return;
-    }
+    main0(config, cmd)
+}
+fn main0(config: Config, _show_cmd: bool) {
    if !root_check::is_app_elevated() {
        println!("Please run it with administrator or root privileges");
        #[cfg(any(target_os = "linux", target_os = "macos"))]
        sudo::escalate_if_needed().unwrap();
        return;
    }
-    if matches.opt_present("list") {
-        command::command(command::CommandEnum::List);
-        return;
-    } else if matches.opt_present("info") {
-        command::command(command::CommandEnum::Info);
-        return;
-    } else if matches.opt_present("stop") {
-        command::command(command::CommandEnum::Stop);
-        return;
-    } else if matches.opt_present("route") {
-        command::command(command::CommandEnum::Route);
-        return;
-    } else if matches.opt_present("all") {
-        command::command(command::CommandEnum::All);
-        return;
-    }
-    let conf = matches.opt_str("f");
-    let (config, cmd) = if conf.is_some() {
-        match config::read_config(&conf.unwrap()) {
-            Ok(c) => c,
-            Err(e) => {
-                println!("conf err {}", e);
-                return;
-            }
-        }
-    } else {
-        if !matches.opt_present("k") {
-            print_usage(&program, opts);
-            println!("parameter -k not found .");
-            return;
-        }
-        #[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();
-        let device_id = matches.opt_get_default("d", String::new()).unwrap();
-        let device_id = if device_id.is_empty() {
-            config::get_device_id()
-        } else {
-            device_id
-        };
-        if device_id.is_empty() {
-            print_usage(&program, opts);
-            println!("parameter -d not found .");
-            return;
-        }
-        let name = matches
-            .opt_get_default("n", os_info::get().to_string())
-            .unwrap();
-        let server_address_str = matches
-            .opt_get_default("s", "nat1.wherewego.top:29872".to_string())
-            .unwrap();
-
-        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.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,
-            Err(e) => {
-                print_usage(&program, opts);
-                println!();
-                println!("-i: {:?} {}", in_ip, e);
-                println!("example: -i 192.168.0.0/24,10.26.0.3");
-                return;
-            }
-        };
-        let out_ip = matches.opt_strs("o");
-        let out_ip = match out_ips_parse(&out_ip) {
-            Ok(out_ip) => out_ip,
-            Err(e) => {
-                print_usage(&program, opts);
-                println!();
-                println!("-o: {:?} {}", out_ip, e);
-                println!("example: -o 0.0.0.0/0");
-                return;
-            }
-        };
-        let password: Option<String> = matches.opt_get("w").unwrap();
-        let server_encrypt = matches.opt_present("W");
-        #[cfg(not(feature = "server_encrypt"))]
-        {
-            if server_encrypt {
-                println!("Server encryption not supported");
-                return;
-            }
-        }
-        let mtu: Option<String> = matches.opt_get("u").unwrap();
-        let mtu = if let Some(mtu) = mtu {
-            match u32::from_str(&mtu) {
-                Ok(mtu) => Some(mtu),
-                Err(e) => {
-                    print_usage(&program, opts);
-                    println!();
-                    println!("'-u {}' {}", mtu, e);
-                    return;
-                }
-            }
-        } else {
-            None
-        };
-        let virtual_ip: Option<String> = matches.opt_get("ip").unwrap();
-        let virtual_ip =
-            virtual_ip.map(|v| Ipv4Addr::from_str(&v).expect(&format!("'--ip {}' error", v)));
-        if let Some(virtual_ip) = virtual_ip {
-            if virtual_ip.is_unspecified() || virtual_ip.is_broadcast() || virtual_ip.is_multicast()
-            {
-                println!("'--ip {}' invalid", virtual_ip);
-                return;
-            }
-        }
-        let tcp_channel = matches.opt_present("tcp");
-        let relay = matches.opt_present("relay");
-
-        let parallel = matches.opt_get::<usize>("par").unwrap().unwrap_or(1);
-        if parallel == 0 {
-            println!("'--par {}' invalid", parallel);
-            return;
-        }
-
-        let cipher_model = match matches.opt_get::<CipherModel>("model") {
-            Ok(model) => {
-                #[cfg(not(any(
-                    feature = "aes_gcm",
-                    feature = "server_encrypt",
-                    feature = "aes_cbc",
-                    feature = "aes_ecb",
-                    feature = "sm4_cbc"
-                )))]
-                {
-                    if password.is_some() && model.is_none() {
-                        println!("Encryption not supported");
-                        return;
-                    }
-                }
-                #[cfg(not(any(feature = "aes_gcm", feature = "server_encrypt")))]
-                {
-                    if password.is_some() && model.is_none() {
-                        println!("'--model ' undefined");
-                        return;
-                    }
-                    model.unwrap_or(CipherModel::None)
-                }
-                #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
-                model.unwrap_or(CipherModel::AesGcm)
-            }
-            Err(e) => {
-                println!("'--model ' invalid,{}", e);
-                return;
-            }
-        };
-
-        let finger = matches.opt_present("finger");
-        let punch_model = matches
-            .opt_get::<PunchModel>("punch")
-            .unwrap()
-            .unwrap_or(PunchModel::All);
-        let use_channel_type = matches
-            .opt_get::<UseChannelType>("use-channel")
-            .unwrap()
-            .unwrap_or_else(|| {
-                if relay {
-                    UseChannelType::Relay
-                } else {
-                    UseChannelType::All
-                }
-            });
-
-        let ports = matches
-            .opt_get::<String>("ports")
-            .unwrap_or(None)
-            .map(|v| v.split(",").map(|x| x.parse().unwrap_or(0)).collect());
-
-        let cmd = matches.opt_present("cmd");
-        #[cfg(feature = "ip_proxy")]
-        let no_proxy = matches.opt_present("no-proxy");
-        let first_latency = matches.opt_present("first-latency");
-        let packet_loss = matches
-            .opt_get::<f64>("packet-loss")
-            .expect("--packet-loss");
-        let packet_delay = matches
-            .opt_get::<u32>("packet-delay")
-            .expect("--packet-delay")
-            .unwrap_or(0);
-        #[cfg(feature = "port_mapping")]
-        let port_mapping_list = matches.opt_strs("mapping");
-        let config = match Config::new(
-            #[cfg(target_os = "windows")]
-            tap,
-            token,
-            device_id,
-            name,
-            server_address_str,
-            dns,
-            stun_server,
-            in_ip,
-            out_ip,
-            password,
-            mtu,
-            tcp_channel,
-            virtual_ip,
-            #[cfg(feature = "ip_proxy")]
-            no_proxy,
-            server_encrypt,
-            parallel,
-            cipher_model,
-            finger,
-            punch_model,
-            ports,
-            first_latency,
-            device_name,
-            use_channel_type,
-            packet_loss,
-            packet_delay,
-            #[cfg(feature = "port_mapping")]
-            port_mapping_list,
-        ) {
-            Ok(config) => config,
-            Err(e) => {
-                println!("config error: {}", e);
-                return;
-            }
-        };
-        (config, cmd)
-    };
-    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) {
    #[cfg(feature = "port_mapping")]
    for (is_tcp, addr, dest) in config.port_mapping_list.iter() {
        if *is_tcp {
@@ -351,175 +32,66 @@ fn main0(config: Config, show_cmd: bool) {
            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);
+    let vnt_util = match Vnt::new(config, callback::VntHandler {}) {
+        Ok(vnt) => vnt,
+        Err(e) => {
+            println!("error: {:?}", e);
+            std::process::exit(1);
+        }
+    };
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    {
+        let vnt_c = vnt_util.clone();
+        let mut signals = signal_hook::iterator::Signals::new(&[
+            signal_hook::consts::SIGINT,
+            signal_hook::consts::SIGTERM,
+        ])
+        .unwrap();
+        let handle = signals.handle();
+        std::thread::spawn(move || {
+            for sig in signals.forever() {
+                match sig {
+                    signal_hook::consts::SIGINT | signal_hook::consts::SIGTERM => {
+                        println!("Received SIGINT, {}", sig);
+                        vnt_c.stop();
+                        handle.close();
+                        break;
+                    }
+                    _ => {}
+                }
            }
-        })
-        .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) = common::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 std::io::stdin().read_line(&mut cmd) {
+                    Ok(len) => {
+                        if !common::command::command_str(&cmd[..len], &vnt_util) {
+                            break;
+                        }
+                    }
+                    Err(e) => {
+                        println!("input err:{}", e);
                        break;
                    }
                }
-                Err(e) => {
-                    println!("input err:{}", e);
-                    break;
-                }
            }
        }
    }
+
    vnt_util.wait()
 }
-
-fn command(cmd: &str, vnt: &Vnt) -> bool {
-    if cmd.is_empty() {
-        return false;
-    }
-    match cmd.to_lowercase().trim() {
-        "list" => {
-            let list = command::command_list(&vnt);
-            console_out::console_device_list(list);
-        }
-        "info" => {
-            let info = command::command_info(&vnt);
-            console_out::console_info(info);
-        }
-        "route" => {
-            let route = command::command_route(&vnt);
-            console_out::console_route_table(route);
-        }
-        "all" => {
-            let list = command::command_list(&vnt);
-            console_out::console_device_list_all(list);
-        }
-        "stop" => {
-            let _ = vnt.stop();
-            return false;
-        }
-        _ => {}
-    }
-    println!();
-    return true;
-}
-
-fn print_usage(program: &str, _opts: Options) {
-    println!("Usage: {} [options]", program);
-    println!("version:{}", vnt::VNT_VERSION);
-    println!("Serial:{}", generated_serial_number::SERIAL_NUMBER);
-    println!("Options:");
-    println!(
-        "  -k <token>          {}",
-        green("使用相同的token,就能组建一个局域网络".to_string())
-    );
-    println!("  -n <name>           给设备一个名字,便于区分不同设备,默认使用系统版本");
-    println!("  -d <id>             设备唯一标识符,不使用--ip参数时,服务端凭此参数分配虚拟ip,注意不能重复");
-    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模式");
-    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",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    )))]
-    let enums = String::new();
-    #[cfg(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    ))]
-    let mut enums = String::new();
-    #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
-    enums.push_str("/aes_gcm");
-    #[cfg(feature = "aes_cbc")]
-    enums.push_str("/aes_cbc");
-    #[cfg(feature = "aes_ecb")]
-    enums.push_str("/aes_ecb");
-    #[cfg(feature = "sm4_cbc")]
-    enums.push_str("/sm4_cbc");
-    if !enums.is_empty() {
-        println!("  -w <password>       使用该密码生成的密钥对客户端数据进行加密,并且服务端无法解密,使用相同密码的客户端才能通信");
-    }
-    #[cfg(feature = "server_encrypt")]
-    println!("  -W                  加密当前客户端和服务端通信的数据,请留意服务端指纹是否正确");
-    println!("  -u <mtu>            自定义mtu(不加密默认为1450，加密默认为1410)");
-    println!("  -f <conf_file>      读取配置文件中的配置");
-
-    println!("  --tcp               和服务端使用tcp通信,默认使用udp,遇到udp qos时可指定使用tcp");
-    println!("  --ip <ip>           指定虚拟ip,指定的ip不能和其他设备重复,必须有效并且在服务端所属网段下,默认情况由服务端分配");
-    println!("  --par <parallel>    任务并行度(必须为正整数),默认值为1");
-    if !enums.is_empty() {
-        println!(
-            "  --model <model>     加密模式(默认aes_gcm),可选值{}",
-            &enums[1..]
-        );
-    }
-    if !enums.is_empty() {
-        println!("  --finger            增加数据指纹校验,可增加安全性,如果服务端开启指纹校验,则客户端也必须开启");
-    }
-    println!("  --punch <punch>     取值ipv4/ipv6/all,ipv4表示仅使用ipv4打洞");
-    println!("  --ports <port,port> 取值0~65535,指定本地监听的一组端口,默认监听两个随机端口,使用过多端口会增加网络负担");
-    println!("  --cmd               开启交互式命令,使用此参数开启控制台输入");
-    #[cfg(feature = "ip_proxy")]
-    println!("  --no-proxy          关闭内置代理,如需点对网则需要配置网卡NAT转发");
-    println!("  --first-latency     优先低延迟的通道,默认情况优先使用p2p通道");
-    println!("  --use-channel <p2p> 使用通道 relay/p2p/all,默认两者都使用");
-    println!("  --nic <tun0>        指定虚拟网卡名称");
-    println!("  --packet-loss <0>   模拟丢包,取值0~1之间的小数,程序会按设定的概率主动丢包,可用于模拟弱网");
-    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");
-
-    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())
-    );
-    println!("  -h, --help          帮助");
-}
-
-fn green(str: String) -> impl std::fmt::Display {
-    style(str).green()
-}
-
-fn yellow(str: String) -> impl std::fmt::Display {
-    style(str).yellow()
-}
@@ -1,21 +0,0 @@
-[package]
-name = "vnt-jni"
-version = "1.2.9"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-common = { path = "../common" }
-vnt = {path="../vnt"}
-parking_lot = "0.12.1"
-
-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"]
@@ -1 +0,0 @@
-## 提供给安卓端使用
@@ -1,77 +0,0 @@
-package top.wherewego.vnt.jni;
-
-import top.wherewego.vnt.jni.param.*;
-
-/**
- * 回调
- *
- * @author https://github.com/lbl8603/vnt
- */
-public interface CallBack {
-    /**
-     * 连接成功的回调
-     */
-    void success();
-
-    /**
-     * 创建虚拟网卡成功的回调方法
-     * 仅在 windows/linux/macos上使用
-     *
-     * @param info 网卡信息
-     */
-    void createTun(DeviceInfo info);
-
-    /**
-     * 连接服务端
-     *
-     * @param info 将要连接的服务端信息
-     */
-    void connect(ConnectInfo info);
-
-    /**
-     * 和服务端握手
-     *
-     * @param info 握手信息
-     * @return 是否确认握手
-     */
-    boolean handshake(HandshakeInfo info);
-
-    /**
-     * 注册成功回调
-     *
-     * @param info 注册信息
-     * @return 是否确认注册信息
-     */
-    boolean register(RegisterInfo info);
-
-    /**
-     * 创建网卡回调
-     * 仅在android上使用
-     *
-     * @param info 创建配置
-     * @return 网卡fd
-     */
-
-    int generateTun(DeviceConfig info);
-
-    /**
-     * 对端用户列表
-     *
-     * @param infoArray
-     */
-    void peerClientList(PeerClientInfo[] infoArray);
-
-
-    /**
-     * 异常回调
-     *
-     * @param info 错误信息
-     */
-    void error(ErrorInfo info);
-
-    /**
-     * 服务停止
-     */
-    void stop();
-
-}
@@ -1,333 +0,0 @@
-package top.wherewego.vnt.jni;
-
-import java.io.Serializable;
-import java.util.Arrays;
-
-/**
- * 启动配置
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class Config implements Serializable {
-    /**
-     * 是否是tap模式，仅支持windows
-     */
-    private boolean tap;
-    /**
-     * 组网标识
-     */
-    private String token;
-    /**
-     * 设备名称
-     */
-    private String name;
-    /**
-     * 客户端间加密的密码
-     */
-    private String password;
-    /**
-     * 客户端间加密模式 aes_gcm/aes_cbc/aes_ecb/sm4_cbc
-     */
-    private String cipherModel;
-    /**
-     * 打洞模式 ipv4/ipv6/all
-     */
-    private String punchModel;
-    /**
-     * mtu 默认自动计算
-     */
-    private Integer mtu;
-    /**
-     * 是否开启服务端加密
-     */
-    private boolean serverEncrypt;
-    /**
-     * 设备id，请使用唯一值
-     */
-    private String deviceId;
-    /**
-     * 服务端地址
-     */
-    private String server;
-    /**
-     * dns地址
-     */
-    private String[] dns;
-    /**
-     * 端口映射
-     */
-    private String[] portMapping;
-    /**
-     * stun服务地址
-     */
-    private String[] stunServer;
-    /**
-     * 和服务端使用tcp通信，默认使用udp
-     */
-    private boolean tcp;
-    /**
-     * 指定组网IP
-     */
-    private String ip;
-    /**
-     * 开启加密指纹校验
-     */
-    private boolean finger;
-    /**
-     * 延迟优先，默认p2p优先
-     */
-    private boolean firstLatency;
-    /**
-     * 点对网入口 格式 192.168.0.0/26,10.26.0.2
-     */
-    private String[] inIps;
-    /**
-     * 点对网出口 格式 192.168.0.0/26
-     */
-    private String[] outIps;
-    /**
-     * 端口组，udp会监听一组端口，tcp监听ports[0]端口
-     */
-    private int[] ports;
-    /**
-     * 虚拟网卡名称 仅在linux、windows、macos上支持
-     */
-    private String deviceName;
-    /**
-     * enum: relay/p2p/all
-     */
-    private String useChannel;
-    /**
-     * 模拟丢包率，取0~1之间的数，为null表示不丢包，1表示全部丢包
-     */
-    private Double packetLossRate;
-    /**
-     * 模拟延迟 单位毫秒(ms)
-     */
-    private Integer packetDelay;
-
-    public Config() {
-    }
-
-    public boolean isTap() {
-        return tap;
-    }
-
-    public void setTap(boolean tap) {
-        this.tap = tap;
-    }
-
-    public String getToken() {
-        return token;
-    }
-
-    public void setToken(String token) {
-        this.token = token;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public String getPassword() {
-        return password;
-    }
-
-    public void setPassword(String password) {
-        this.password = password;
-    }
-
-    public String getCipherModel() {
-        return cipherModel;
-    }
-
-    public void setCipherModel(String cipherModel) {
-        this.cipherModel = cipherModel;
-    }
-
-    public String getPunchModel() {
-        return punchModel;
-    }
-
-    public void setPunchModel(String punchModel) {
-        this.punchModel = punchModel;
-    }
-
-    public Integer getMtu() {
-        return mtu;
-    }
-
-    public void setMtu(Integer mtu) {
-        this.mtu = mtu;
-    }
-
-    public boolean isServerEncrypt() {
-        return serverEncrypt;
-    }
-
-    public void setServerEncrypt(boolean serverEncrypt) {
-        this.serverEncrypt = serverEncrypt;
-    }
-
-
-    public String getDeviceId() {
-        return deviceId;
-    }
-
-    public void setDeviceId(String deviceId) {
-        this.deviceId = deviceId;
-    }
-
-    public String getServer() {
-        return server;
-    }
-
-    public void setServer(String server) {
-        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;
-    }
-
-    public void setStunServer(String[] stunServer) {
-        this.stunServer = stunServer;
-    }
-
-    public boolean isTcp() {
-        return tcp;
-    }
-
-    public void setTcp(boolean tcp) {
-        this.tcp = tcp;
-    }
-
-    public String getIp() {
-        return ip;
-    }
-
-    public void setIp(String ip) {
-        this.ip = ip;
-    }
-
-    public boolean isFinger() {
-        return finger;
-    }
-
-    public void setFinger(boolean finger) {
-        this.finger = finger;
-    }
-
-    public boolean isFirstLatency() {
-        return firstLatency;
-    }
-
-    public void setFirstLatency(boolean firstLatency) {
-        this.firstLatency = firstLatency;
-    }
-
-    public String[] getInIps() {
-        return inIps;
-    }
-
-    public void setInIps(String[] inIps) {
-        this.inIps = inIps;
-    }
-
-    public String[] getOutIps() {
-        return outIps;
-    }
-
-    public void setOutIps(String[] outIps) {
-        this.outIps = outIps;
-    }
-
-    public int[] getPorts() {
-        return ports;
-    }
-
-    public void setPorts(int[] ports) {
-        this.ports = ports;
-    }
-
-    public String getDeviceName() {
-        return deviceName;
-    }
-
-    public void setDeviceName(String deviceName) {
-        this.deviceName = deviceName;
-    }
-
-    public String getUseChannel() {
-        return useChannel;
-    }
-
-    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,43 +0,0 @@
-package top.wherewego.vnt.jni;
-
-/**
- * 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) + "." +
-                ((ipAddress & 0x00FF0000) >>> 16) + "." +
-                ((ipAddress & 0x0000FF00) >>> 8) + "." +
-                (ipAddress & 0x000000FF);
-    }
-
-    /**
-     * 返回掩码的长度
-     *
-     * @param subnetMask
-     * @return
-     */
-    public static int subnetMaskToPrefixLength(int subnetMask) {
-        int prefixLength = 0;
-        int bit = 1 << 31;
-
-        while (subnetMask != 0) {
-            if ((subnetMask & bit) != bit) {
-                break;
-            }
-            prefixLength++;
-            subnetMask <<= 1;
-        }
-
-        return prefixLength;
-    }
-}
@@ -1,46 +0,0 @@
-package top.wherewego.vnt.jni;
-
-/**
- * 对端设备信息
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class PeerRouteInfo {
-    private final int virtualIp;
-    private final String name;
-    private final String status;
-    private final Route route;
-
-    public PeerRouteInfo(int virtualIp, String name, String status, Route route) {
-        this.virtualIp = virtualIp;
-        this.name = name;
-        this.status = status;
-        this.route = route;
-    }
-
-    public int getVirtualIp() {
-        return virtualIp;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public String getStatus() {
-        return status;
-    }
-
-    public Route getRoute() {
-        return route;
-    }
-
-    @Override
-    public String toString() {
-        return "PeerDeviceInfo{" +
-                "virtualIp=" + IpUtils.intToIpAddress(virtualIp) +
-                ", name='" + name + '\'' +
-                ", status='" + status + '\'' +
-                ", route=" + route +
-                '}';
-    }
-}
@@ -1,50 +0,0 @@
-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(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;
-    }
-
-    public byte getMetric() {
-        return metric;
-    }
-
-    public int getRt() {
-        return rt;
-    }
-
-    @Override
-    public String toString() {
-        return "Route{" +
-                "tcp=" + tcp +
-                ", address='" + address + '\'' +
-                ", metric=" + metric +
-                ", rt=" + rt +
-                '}';
-    }
-}
@@ -1,53 +0,0 @@
-package top.wherewego.vnt.jni;
-
-import java.io.Closeable;
-import java.io.IOException;
-
-/**
- * vnt的Java映射
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class Vnt implements Closeable {
-    private final long raw;
-
-    public Vnt(Config config, CallBack callBack) throws Exception {
-        this.raw = new0(config, callBack);
-        if (this.raw == 0) {
-            throw new RuntimeException();
-        }
-    }
-
-    public void stop() {
-        stop0(raw);
-    }
-
-    public void await() {
-        wait0(raw);
-    }
-
-    public boolean awaitTimeout(long ms) {
-        return waitTimeout0(raw, ms);
-    }
-
-    public PeerRouteInfo[] list() {
-        return list0(raw);
-    }
-
-    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 PeerRouteInfo[] list0(long raw);
-
-    @Override
-    public void close() throws IOException {
-        drop0(raw);
-    }
-}
@@ -1,32 +0,0 @@
-package top.wherewego.vnt.jni.param;
-
-/**
- * 连接信息
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class ConnectInfo {
-    private final long count;
-    private final String address;
-
-    public ConnectInfo(long count, String address) {
-        this.count = count;
-        this.address = address;
-    }
-
-    public long getCount() {
-        return count;
-    }
-
-    public String getAddress() {
-        return address;
-    }
-
-    @Override
-    public String toString() {
-        return "ConnectInfo{" +
-                "count=" + count +
-                ", address='" + address + '\'' +
-                '}';
-    }
-}
@@ -1,72 +0,0 @@
-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,38 +0,0 @@
-package top.wherewego.vnt.jni.param;
-
-/**
- * 网卡信息 仅在 windows/linux/macos上使用
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class DeviceInfo {
-    /**
-     * 虚拟网卡名称
-     */
-    private final String name;
-    /**
-     * 虚拟网卡版本
-     */
-    private final String version;
-
-    public DeviceInfo(String name, String version) {
-        this.name = name;
-        this.version = version;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public String getVersion() {
-        return version;
-    }
-
-    @Override
-    public String toString() {
-        return "DeviceInfo{" +
-                "name='" + name + '\'' +
-                ", version='" + version + '\'' +
-                '}';
-    }
-}
@@ -1,65 +0,0 @@
-package top.wherewego.vnt.jni.param;
-
-/**
- * 异常回调信息
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class ErrorInfo {
-    /**
-     * 错误码
-     */
-    public final ErrorCodeEnum code;
-    /**
-     * 错误信息，可能为空
-     */
-    public final String msg;
-
-    public ErrorInfo(int code, String msg) {
-        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;
-    }
-
-    public ErrorCodeEnum getCode() {
-        return code;
-    }
-
-    public String getMsg() {
-        return msg;
-    }
-
-    public enum ErrorCodeEnum {
-        TokenError,
-        Disconnect,
-        AddressExhausted,
-        IpAlreadyExists,
-        InvalidIp,
-        Unknown,
-    }
-
-    @Override
-    public String toString() {
-        return "ErrorInfo{" +
-                "code=" + code +
-                ", msg='" + msg + '\'' +
-                '}';
-    }
-}
@@ -1,54 +0,0 @@
-package top.wherewego.vnt.jni.param;
-
-/**
- * 握手回调信息
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class HandshakeInfo {
-    /**
-     * 公钥 pem格式 CRLF分隔，不加密时为空
-     */
-    private final String publicKey;
-    /**
-     * 公钥签名，不加密时为空
-     */
-    private final String finger;
-    /**
-     * 服务端版本
-     */
-    private final String version;
-
-    public HandshakeInfo() {
-        this.publicKey = "publicKey";
-        this.finger = "finger";
-        this.version = "version";
-    }
-
-    public HandshakeInfo(String publicKey, String finger, String version) {
-        this.publicKey = publicKey;
-        this.finger = finger;
-        this.version = version;
-    }
-
-    public String getPublicKey() {
-        return publicKey;
-    }
-
-    public String getFinger() {
-        return finger;
-    }
-
-    public String getVersion() {
-        return version;
-    }
-
-    @Override
-    public String toString() {
-        return "HandshakeInfo{" +
-                "publicKey='" + publicKey + '\'' +
-                ", finger='" + finger + '\'' +
-                ", version='" + version + '\'' +
-                '}';
-    }
-}
@@ -1,60 +0,0 @@
-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,50 +0,0 @@
-package top.wherewego.vnt.jni.param;
-
-import top.wherewego.vnt.jni.IpUtils;
-
-/**
- * 注册回调信息
- *
- * @author https://github.com/lbl8603/vnt
- */
-public class RegisterInfo {
-    /**
-     * 虚拟IP
-     */
-    public final int virtualIp;
-    /**
-     * 掩码
-     */
-    public final int virtualNetmask;
-    /**
-     * 网关
-     */
-    public final int virtualGateway;
-
-    public RegisterInfo(int virtualIp, int virtualNetmask, int virtualGateway) {
-        this.virtualIp = virtualIp;
-        this.virtualNetmask = virtualNetmask;
-        this.virtualGateway = virtualGateway;
-    }
-
-    public int getVirtualIp() {
-        return virtualIp;
-    }
-
-    public int getVirtualNetmask() {
-        return virtualNetmask;
-    }
-
-    public int getVirtualGateway() {
-        return virtualGateway;
-    }
-
-    @Override
-    public String toString() {
-        return "RegisterInfo{" +
-                "virtualIp='" + IpUtils.intToIpAddress(virtualIp) + '\'' +
-                ", virtualNetmask='" + IpUtils.intToIpAddress(virtualNetmask) + '\'' +
-                ", virtualGateway='" + IpUtils.intToIpAddress(virtualGateway) + '\'' +
-                '}';
-    }
-}
@@ -1,322 +0,0 @@
-use std::sync::Arc;
-
-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;
-#[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) -> 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 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(
-            class,
-            "(Ljava/lang/String;Ljava/lang/String;)V",
-            &[
-                JValue::Object(&env.new_string(info.name)?.into()),
-                JValue::Object(&env.new_string(info.version)?.into()),
-            ],
-        )?;
-        env.call_method(
-            &self.this,
-            "createTun",
-            "(Ltop/wherewego/vnt/jni/param/DeviceInfo;)V",
-            &[JValue::Object(&param)],
-        )?;
-        Ok(())
-    }
-    fn connect0(&self, info: ConnectInfo) -> jni::errors::Result<()> {
-        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(
-            class,
-            "(JLjava/lang/String;)V",
-            &[
-                JValue::Long(info.count as _),
-                JValue::Object(&env.new_string(info.address.to_string())?.into()),
-            ],
-        )?;
-        env.call_method(
-            &self.this,
-            "connect",
-            "(Ltop/wherewego/vnt/jni/param/ConnectInfo;)V",
-            &[JValue::Object(&param)],
-        )?;
-        Ok(())
-    }
-    fn handshake0(&self, info: HandshakeInfo) -> jni::errors::Result<bool> {
-        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)?,
-                Err(e) => {
-                    log::warn!("{:?}", e);
-                    JString::default()
-                }
-            }
-        } else {
-            JString::default()
-        };
-        let finger = if let Some(finger) = info.finger {
-            env.new_string(finger)?
-        } else {
-            JString::default()
-        };
-        let class = unsafe { JClass::from_raw(self.handshake_info_class.as_raw()) };
-
-        let param = env.new_object(
-            class,
-            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
-            &[
-                JValue::Object(&public_key),
-                JValue::Object(&finger),
-                JValue::Object(&env.new_string(info.version)?.into()),
-            ],
-        )?;
-        let rs = env.call_method(
-            &self.this,
-            "handshake",
-            "(Ltop/wherewego/vnt/jni/param/HandshakeInfo;)Z",
-            &[JValue::Object(&param)],
-        )?;
-        rs.z()
-    }
-    fn register0(&self, info: RegisterInfo) -> jni::errors::Result<bool> {
-        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(
-            class,
-            "(III)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 _),
-            ],
-        )?;
-        let rs = env.call_method(
-            &self.this,
-            "register",
-            "(Ltop/wherewego/vnt/jni/param/RegisterInfo;)Z",
-            &[JValue::Object(&param)],
-        )?;
-        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 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(
-            class,
-            "(ILjava/lang/String;)V",
-            &[JValue::Int(code as _), JValue::Object(&msg.into())],
-        )?;
-        env.call_method(
-            &self.this,
-            "error",
-            "(Ltop/wherewego/vnt/jni/param/ErrorInfo;)V",
-            &[JValue::Object(&param)],
-        )?;
-        Ok(())
-    }
-    fn stop0(&self) -> jni::errors::Result<()> {
-        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);
-        }
-    }
-
-    fn connect(&self, info: ConnectInfo) {
-        if let Err(e) = self.connect0(info) {
-            log::warn!("connect {:?}", e);
-        }
-    }
-
-    fn handshake(&self, info: HandshakeInfo) -> bool {
-        self.handshake0(info).unwrap_or_else(|e| {
-            log::warn!("handshake {:?}", e);
-            false
-        })
-    }
-
-    fn register(&self, info: RegisterInfo) -> bool {
-        self.register0(info).unwrap_or_else(|e| {
-            log::warn!("register {:?}", e);
-            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) {
-            log::warn!("error {:?}", e);
-        }
-    }
-
-    fn stop(&self) {
-        if let Err(e) = self.stop0() {
-            log::warn!("stop {:?}", e);
-        }
-    }
-}
@@ -1,133 +0,0 @@
-use std::str::FromStr;
-
-use jni::errors::Error;
-use jni::objects::JObject;
-use jni::JNIEnv;
-
-use vnt::channel::punch::PunchModel;
-use vnt::channel::UseChannelType;
-use vnt::cipher::CipherModel;
-use vnt::core::Config;
-
-use crate::utils::*;
-
-pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
-    #[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")?;
-    let device_id = to_string_not_null(env, &config, "deviceId")?;
-    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);
-    let tcp = env.get_field(&config, "tcp", "Z")?.z()?;
-    let server_encrypt = env.get_field(&config, "serverEncrypt", "Z")?.z()?;
-    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 =
-        to_i32_array(env, &config, "ports")?.map(|v| v.into_iter().map(|v| v as u16).collect());
-    let ip = if let Some(ip) = to_string(env, &config, "ip")? {
-        match ip.parse() {
-            Ok(ip) => Some(ip),
-            Err(e) => {
-                env.throw_new(
-                    "java/lang/RuntimeException",
-                    format!("ip {} err: {}", ip, e),
-                )
-                .expect("throw");
-                return Err(Error::JavaException);
-            }
-        }
-    } else {
-        None
-    };
-    let in_ips = if let Some(in_ips) = in_ips {
-        match common::args_parse::ips_parse(&in_ips) {
-            Ok(in_ips) => in_ips,
-            Err(e) => {
-                env.throw_new("java/lang/RuntimeException", format!("in_ips {}", e))
-                    .expect("throw");
-                return Err(Error::JavaException);
-            }
-        }
-    } else {
-        vec![]
-    };
-    let out_ips = if let Some(out_ips) = out_ips {
-        match common::args_parse::out_ips_parse(&out_ips) {
-            Ok(out_ips) => out_ips,
-            Err(e) => {
-                env.throw_new("java/lang/RuntimeException", format!("out_ips {}", e))
-                    .expect("throw");
-                return Err(Error::JavaException);
-            }
-        }
-    } else {
-        vec![]
-    };
-
-    let cipher_model = match CipherModel::from_str(&cipher_model) {
-        Ok(cipher_model) => cipher_model,
-        Err(e) => {
-            env.throw_new("java/lang/RuntimeException", format!("cipher_model {}", e))
-                .expect("throw");
-            return Err(Error::JavaException);
-        }
-    };
-    #[cfg(not(target_os = "android"))]
-    let device_name = to_string(env, &config, "deviceName")?;
-    let config = match Config::new(
-        #[cfg(target_os = "windows")]
-        tap,
-        token,
-        device_id,
-        name,
-        server_address_str,
-        dns,
-        stun_server,
-        in_ips,
-        out_ips,
-        password,
-        mtu,
-        tcp,
-        ip,
-        false,
-        server_encrypt,
-        1,
-        cipher_model,
-        finger,
-        PunchModel::from_str(&punch_model.unwrap_or_default()).unwrap_or_default(),
-        ports,
-        first_latency,
-        #[cfg(not(target_os = "android"))]
-        device_name,
-        UseChannelType::from_str(&use_channel.unwrap_or_default()).unwrap_or_default(),
-        packet_loss_rate,
-        packet_delay,
-        port_mapping,
-    ) {
-        Ok(config) => config,
-        Err(e) => {
-            env.throw_new(
-                "java/lang/RuntimeException",
-                format!("vnt start error {:?}", e),
-            )
-            .expect("throw");
-            return Err(Error::JavaException);
-        }
-    };
-    Ok(config)
-}
@@ -1,5 +0,0 @@
-pub mod callback;
-pub mod config;
-pub mod utils;
-pub mod vnt;
-pub(crate) mod vnt_logger;
@@ -1,131 +0,0 @@
-use jni::errors::Error;
-use jni::objects::{JIntArray, JObject, JObjectArray, JString};
-use jni::JNIEnv;
-
-pub fn to_string_not_null(
-    env: &mut JNIEnv,
-    config: &JObject,
-    name: &'static str,
-) -> Result<String, Error> {
-    let value = env.get_field(config, name, "Ljava/lang/String;")?.l()?;
-    if value.is_null() {
-        env.throw_new("java/lang/NullPointerException", name)
-            .expect("throw");
-        return Err(Error::NullPtr(name));
-    }
-    let binding = JString::from(value);
-    let value = env.get_string(binding.as_ref())?;
-    match value.to_str() {
-        Ok(value) => Ok(value.to_string()),
-        Err(_) => {
-            env.throw_new("java/lang/RuntimeException", "not utf-8")
-                .expect("throw");
-            return Err(Error::JavaException);
-        }
-    }
-}
-
-pub fn to_string(env: &mut JNIEnv, config: &JObject, name: &str) -> Result<Option<String>, Error> {
-    let value = env.get_field(config, name, "Ljava/lang/String;")?.l()?;
-    if value.is_null() {
-        return Ok(None);
-    }
-    let tmp = JString::from(value);
-    let value = env.get_string(tmp.as_ref())?;
-    match value.to_str() {
-        Ok(value) => Ok(Some(value.to_string())),
-        Err(_) => {
-            env.throw_new("java/lang/RuntimeException", "not utf-8")
-                .expect("throw");
-            return Err(Error::JavaException);
-        }
-    }
-}
-
-pub fn to_string_array_not_null(
-    env: &mut JNIEnv,
-    config: &JObject,
-    name: &str,
-) -> Result<Vec<String>, Error> {
-    match to_string_array(env, config, name)? {
-        None => {
-            env.throw_new("java/lang/NullPointerException", name)
-                .expect("throw");
-            return Err(Error::JavaException);
-        }
-        Some(rs) => Ok(rs),
-    }
-}
-
-pub fn to_string_array(
-    env: &mut JNIEnv,
-    config: &JObject,
-    name: &str,
-) -> Result<Option<Vec<String>>, Error> {
-    let value = env.get_field(config, name, "[Ljava/lang/String;")?.l()?;
-    if value.is_null() {
-        return Ok(None);
-    }
-    let arr = JObjectArray::from(value);
-    let len = env.get_array_length(&arr)?;
-    let mut rs = Vec::with_capacity(len as usize);
-    for index in 0..len {
-        let object = env.get_object_array_element(&arr, index)?;
-        if object.is_null() {
-            env.throw_new(
-                "java/lang/NullPointerException",
-                format!("{},index={}", name, index),
-            )
-            .expect("throw");
-            return Err(Error::JavaException);
-        }
-        match env.get_string(JString::from(object).as_ref())?.to_str() {
-            Ok(value) => {
-                rs.push(value.to_string());
-            }
-            Err(_) => {
-                env.throw_new("java/lang/RuntimeException", "not utf-8")
-                    .expect("throw");
-                return Err(Error::JavaException);
-            }
-        }
-    }
-    Ok(Some(rs))
-}
-
-pub fn to_i32_array(
-    env: &mut JNIEnv,
-    config: &JObject,
-    name: &str,
-) -> Result<Option<Vec<i32>>, Error> {
-    let obj = env.get_field(&config, name, "[I")?.l()?;
-    if obj.is_null() {
-        Ok(None)
-    } else {
-        let j_arr = JIntArray::from(obj);
-        let len = env.get_array_length(&j_arr)?;
-        let mut arr = vec![0i32; len as usize];
-        env.get_int_array_region(j_arr, 0, &mut arr)?;
-        Ok(Some(arr))
-    }
-}
-pub fn to_integer(env: &mut JNIEnv, config: &JObject, name: &str) -> Result<Option<i32>, Error> {
-    let value = env.get_field(config, name, "Ljava/lang/Integer;")?.l()?;
-    if value.is_null() {
-        return Ok(None);
-    }
-    // 调用 intValue
-    return Ok(Some(
-        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,184 +0,0 @@
-use std::ptr;
-use std::time::Duration;
-
-use jni::errors::Error;
-use jni::objects::{JClass, JObject, JValue};
-use jni::sys::{jboolean, jint, jlong, jobject, jobjectArray, jsize};
-use jni::JNIEnv;
-
-use vnt::channel::Route;
-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>,
-    _class: JClass,
-    config: JObject,
-    call_back: JObject<'static>,
-) -> jlong {
-    crate::vnt_logger::init_log();
-    let jvm = if let Ok(jvm) = env.get_java_vm() {
-        jvm
-    } else {
-        return 0;
-    };
-    match crate::config::new_config(&mut env, config) {
-        Ok(config) => {
-            let call_back = if let Ok(call_back) = env.new_global_ref(call_back) {
-                call_back
-            } else {
-                return 0;
-            };
-            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(
-                        "java/lang/RuntimeException",
-                        format!("vnt start error {}", e),
-                    )
-                    .expect("throw");
-                    return 0;
-                }
-            };
-            let ptr = Box::into_raw(Box::new(vnt_util));
-            return ptr as jlong;
-        }
-        Err(_) => {}
-    }
-    return 0;
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_stop0(
-    _env: JNIEnv,
-    _class: JClass,
-    raw_vnt: jlong,
-) {
-    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,
-    _class: JClass,
-    raw_vnt: jlong,
-) {
-    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(
-    _env: JNIEnv,
-    _class: JClass,
-    raw_vnt: jlong,
-) {
-    let vnt = raw_vnt as *mut Vnt;
-    let _ = Box::from_raw(vnt).stop();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_top_wherewego_vnt_jni_Vnt_list0(
-    mut env: JNIEnv,
-    _class: JClass,
-    raw_vnt: jlong,
-) -> jobjectArray {
-    let vnt = raw_vnt as *mut Vnt;
-    let vnt = &mut *vnt;
-    let list = vnt.device_list();
-
-    let arr = match env.new_object_array(
-        list.len() as jsize,
-        "top/wherewego/vnt/jni/PeerRouteInfo",
-        JObject::null(),
-    ) {
-        Ok(arr) => arr,
-        Err(e) => {
-            env.throw_new("java/lang/RuntimeException", format!("error:{:?}", e))
-                .expect("throw");
-            return ptr::null_mut();
-        }
-    };
-    for (index, peer) in list.into_iter().enumerate() {
-        let route = if let Some(route) = vnt.route(&peer.virtual_ip) {
-            match route_parse(&mut env, route) {
-                Ok(route) => JObject::from_raw(route),
-                Err(_) => JObject::null(),
-            }
-        } else {
-            JObject::null()
-        };
-        match peer_device_info_parse(&mut env, peer, route) {
-            Ok(peer) => {
-                match env.set_object_array_element(&arr, index as jsize, JObject::from_raw(peer)) {
-                    Ok(_) => {}
-                    Err(e) => {
-                        env.throw_new("java/lang/RuntimeException", format!("error:{:?}", e))
-                            .expect("throw");
-                        return ptr::null_mut();
-                    }
-                }
-            }
-            Err(e) => {
-                env.throw_new("java/lang/RuntimeException", format!("error:{:?}", e))
-                    .expect("throw");
-                return ptr::null_mut();
-            }
-        }
-    }
-    arr.as_raw()
-}
-
-fn route_parse(env: &mut JNIEnv, route: Route) -> Result<jobject, Error> {
-    let rs = env.new_object(
-        "top/wherewego/vnt/jni/Route",
-        "(ZLjava/lang/String;BI)V",
-        &[
-            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())
-}
-
-fn peer_device_info_parse(
-    env: &mut JNIEnv,
-    peer: PeerDeviceInfo,
-    route: JObject,
-) -> Result<jobject, Error> {
-    let virtual_ip = u32::from(peer.virtual_ip);
-    let name = peer.name.to_string();
-    let status = format!("{:?}", peer.status);
-    let rs = env.new_object(
-        "top/wherewego/vnt/jni/PeerRouteInfo",
-        "(ILjava/lang/String;Ljava/lang/String;Ltop/wherewego/vnt/jni/Route;)V",
-        &[
-            JValue::Int(virtual_ip as jint),
-            JValue::Object(&env.new_string(name)?.into()),
-            JValue::Object(&env.new_string(status)?.into()),
-            JValue::Object(&route),
-        ],
-    )?;
-    Ok(rs.as_raw())
-}
@@ -1,12 +0,0 @@
-#[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" ,optional = true}
 packet = { path = "./packet" }
 bytes = "1.5.0"
 log = "0.4.17"
@@ -23,6 +23,8 @@ 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 }
+chacha20poly1305 = { version = "0.10.1", optional = true }
+chacha20 = { version = "0.9.1", optional = true }
 aes = "0.8.3"
 stun-format = { version = "1.0.1", features = ["fmt", "rfc3489"] }
 rsa = { version = "0.9.2", features = [], optional = true }
@@ -30,14 +32,17 @@ spki = { version = "0.7.2", features = ["fingerprint", "alloc", "base64"], optio
 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 }

+fnv = "1.0.7"
 [target.'cfg(target_os = "windows")'.dependencies]
 libloading = "0.8.0"

@@ -45,9 +50,10 @@ libloading = "0.8.0"
 [build-dependencies]
 protobuf-codegen = "3.2.0"
 protoc-bin-vendored = "3.0.0"
+cfg_aliases = "0.2.1"

 [features]
-default = ["server_encrypt", "aes_gcm", "aes_cbc", "aes_ecb", "sm4_cbc", "ip_proxy", "port_mapping"]
+default = ["server_encrypt", "aes_gcm", "aes_cbc", "aes_ecb", "sm4_cbc", "chacha20_poly1305", "ip_proxy", "port_mapping", "lz4_compress", "zstd_compress","integrated_tun"]
 openssl = ["openssl-sys"]
 # 从源码编译
 openssl-vendored = ["openssl-sys/vendored"]
@@ -56,6 +62,10 @@ aes_cbc = ["cbc"]
 aes_ecb = ["ecb"]
 sm4_cbc = ["libsm"]
 aes_gcm = ["aes-gcm"]
+chacha20_poly1305 = ["chacha20poly1305", "chacha20"]
 server_encrypt = ["aes-gcm", "rsa", "spki"]
 ip_proxy = ["tokio"]
 port_mapping = ["tokio"]
+lz4_compress = ["lz4_flex"]
+zstd_compress = ["zstd"]
+integrated_tun = ["tun"]
@@ -1,4 +1,17 @@
+use cfg_aliases::cfg_aliases;
+
 fn main() {
+    cfg_aliases! {
+        cipher: {
+            any(feature = "aes_gcm",
+            feature = "chacha20_poly1305",
+            feature = "server_encrypt",
+            feature = "aes_cbc",
+            feature = "aes_ecb",
+            feature = "sm4_cbc"
+        )},
+    }
+
    std::fs::create_dir_all("src/proto").unwrap();
    protobuf_codegen::Codegen::new()
        .pure()
@@ -1,7 +1,7 @@
-use std::collections::HashMap;
+use fnv::FnvHashMap;
 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};
@@ -11,7 +11,7 @@ use parking_lot::RwLock;
 use rand::Rng;

 use crate::channel::punch::NatType;
-use crate::channel::sender::{AcceptSocketSender, ChannelSender, PacketSender};
+use crate::channel::sender::{AcceptSocketSender, PacketSender};
 use crate::channel::{Route, RouteKey, UseChannelType, DEFAULT_RT};

 /// 传输通道上下文，持有udp socket、tcp socket和路由信息
@@ -44,11 +44,10 @@ impl ChannelContext {
            .unwrap_or(0);
        let inner = ContextInner {
            main_udp_socket,
-            sub_udp_socket: RwLock::new(Vec::with_capacity(64)),
-            tcp_map: RwLock::new(HashMap::with_capacity(64)),
+            sub_udp_socket: RwLock::new(Vec::new()),
+            tcp_map: RwLock::new(FnvHashMap::default()),
            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),
@@ -58,9 +57,6 @@ impl ChannelContext {
            inner: Arc::new(inner),
        }
    }
-    pub fn sender(&self) -> ChannelSender {
-        ChannelSender::new(self.clone())
-    }
 }

 impl Deref for ChannelContext {
@@ -81,13 +77,11 @@ pub struct ContextInner {
    // 对称网络增加的udp socket
    sub_udp_socket: RwLock<Vec<UdpSocket>>,
    // tcp数据发送器
-    pub(crate) tcp_map: RwLock<HashMap<SocketAddr, PacketSender>>,
+    pub(crate) tcp_map: RwLock<FnvHashMap<SocketAddr, PacketSender>>,
    // 路由信息
    pub route_table: RouteTable,
    // 是否使用tcp连接服务器
    is_tcp: bool,
-    //状态
-    state: AtomicBool,
    //控制丢包率，取值v=[0,100_0000] 丢包率r=v/100_0000
    packet_loss_rate: u32,
    //控制延迟
@@ -100,12 +94,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()
@@ -297,7 +285,7 @@ impl ContextInner {

 pub struct RouteTable {
    pub(crate) route_table:
-        RwLock<HashMap<Ipv4Addr, (AtomicUsize, Vec<(Route, AtomicCell<Instant>)>)>>,
+        RwLock<FnvHashMap<Ipv4Addr, (AtomicUsize, Vec<(Route, AtomicCell<Instant>)>)>>,
    first_latency: bool,
    channel_num: usize,
    use_channel_type: UseChannelType,
@@ -306,7 +294,7 @@ pub struct RouteTable {
 impl RouteTable {
    fn new(use_channel_type: UseChannelType, first_latency: bool, channel_num: usize) -> Self {
        Self {
-            route_table: RwLock::new(HashMap::with_capacity(64)),
+            route_table: RwLock::new(FnvHashMap::with_capacity_and_hasher(64, Default::default())),
            use_channel_type,
            first_latency,
            channel_num,
@@ -2,5 +2,11 @@ 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: &ChannelContext);
+    fn handle(
+        &mut self,
+        buf: &mut [u8],
+        extend: &mut [u8],
+        route_key: RouteKey,
+        context: &ChannelContext,
+    );
 }
@@ -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,
@@ -138,7 +138,7 @@ impl RouteKey {
    }
 }

-pub fn init_context(
+pub(crate) fn init_context(
    ports: Vec<u16>,
    use_channel_type: UseChannelType,
    first_latency: bool,
@@ -233,7 +233,7 @@ pub fn init_context(
    Ok((context, tcp_listener))
 }

-pub fn init_channel<H>(
+pub(crate) fn init_channel<H>(
    tcp_listener: mio::net::TcpListener,
    context: ChannelContext,
    stop_manager: StopManager,
@@ -1,31 +1,111 @@
 use std::io;
-use std::ops::Deref;
+use std::net::Ipv4Addr;
 use std::sync::mpsc::{SyncSender, TrySendError};
 use std::sync::Arc;

+use crossbeam_utils::atomic::AtomicCell;
 use mio::Token;

 use crate::channel::context::ChannelContext;
 use crate::channel::notify::{AcceptNotify, WritableNotify};
+use crate::cipher::Cipher;
+use crate::compression::Compressor;
+use crate::external_route::ExternalRoute;
+use crate::handle::CurrentDeviceInfo;
+use crate::protocol;
+use crate::protocol::{ip_turn_packet, NetPacket};

 #[derive(Clone)]
-pub struct ChannelSender {
+pub struct IpPacketSender {
    context: ChannelContext,
+    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    compressor: Compressor,
+    client_cipher: Cipher,
+    ip_route: ExternalRoute,
 }

-impl ChannelSender {
-    pub fn new(context: ChannelContext) -> Self {
-        Self { context }
+impl IpPacketSender {
+    pub fn new(
+        context: ChannelContext,
+        current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+        compressor: Compressor,
+        client_cipher: Cipher,
+        ip_route: ExternalRoute,
+    ) -> Self {
+        Self {
+            context,
+            current_device,
+            compressor,
+            client_cipher,
+            ip_route,
+        }
+    }
+    pub fn self_virtual_ip(&self) -> Ipv4Addr {
+        self.current_device.load().virtual_ip
+    }
+    pub fn send_ip(
+        &self,
+        buf: &mut [u8],
+        data_len: usize,
+        auxiliary_buf: &mut [u8],
+        mut dest_ip: Ipv4Addr,
+    ) -> anyhow::Result<()> {
+        let device_info = self.current_device.load();
+        let src_ip = device_info.virtual_ip;
+        if src_ip.is_unspecified() {
+            return Ok(());
+        }
+        if let Some(v) = self.ip_route.route(&dest_ip) {
+            dest_ip = v;
+        }
+        if dest_ip.is_multicast() || dest_ip.is_broadcast() || dest_ip == device_info.broadcast_ip {
+            //广播
+            dest_ip = Ipv4Addr::BROADCAST;
+        }
+
+        let mut net_packet = NetPacket::new0(data_len, buf)?;
+        let mut auxiliary = NetPacket::new(auxiliary_buf)?;
+        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);
+
+        let mut net_packet = if self.compressor.compress(&net_packet, &mut auxiliary)? {
+            auxiliary.set_default_version();
+            auxiliary.set_protocol(protocol::Protocol::IpTurn);
+            auxiliary.set_transport_protocol(ip_turn_packet::Protocol::Ipv4.into());
+            auxiliary.first_set_ttl(6);
+            auxiliary.set_source(src_ip);
+            auxiliary.set_destination(dest_ip);
+            auxiliary
+        } else {
+            net_packet
+        };
+        self.client_cipher.encrypt_ipv4(&mut net_packet)?;
+        if dest_ip.is_broadcast() {
+            //走服务端广播
+            self.context
+                .send_default(net_packet.buffer(), device_info.connect_server)?;
+            return Ok(());
+        }
+
+        // if u32::from_be_bytes(dest_ip.octets()) & u32::from_be_bytes(device_info.virtual_netmask.octets())
+        //     != u32::from_be_bytes(device_info.virtual_network.octets()) {
+        //     //不是一个网段的直接忽略
+        //     return Ok(());
+        // }
+        self.context.send_ipv4_by_id(
+            net_packet.buffer(),
+            &dest_ip,
+            device_info.connect_server,
+            device_info.status.online(),
+        )?;
+        Ok(())
    }
 }

-impl Deref for ChannelSender {
-    type Target = ChannelContext;
-
-    fn deref(&self) -> &Self::Target {
-        &self.context
-    }
-}
 pub struct AcceptSocketSender<T> {
    sender: SyncSender<T>,
    notify: AcceptNotify,
@@ -39,6 +119,7 @@ impl<T> Clone for AcceptSocketSender<T> {
        }
    }
 }
+
 impl<T> AcceptSocketSender<T> {
    pub fn new(notify: AcceptNotify, sender: SyncSender<T>) -> Self {
        Self { sender, notify }
@@ -31,7 +31,7 @@ pub fn tcp_listen<H>(
    stop_manager: StopManager,
    recv_handler: H,
    context: ChannelContext,
-) -> io::Result<AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>>
+) -> anyhow::Result<AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>>
 where
    H: RecvChannelHandler,
 {
@@ -75,7 +75,7 @@ fn tcp_listen0<H>(
    accept_tcp_receiver: Receiver<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
    mut recv_handler: H,
    context: ChannelContext,
-) -> io::Result<()>
+) -> anyhow::Result<()>
 where
    H: RecvChannelHandler,
 {
@@ -87,8 +87,12 @@ 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)?;
+        if let Err(e) = poll.poll(&mut events, None) {
+            crate::ignore_io_interrupted(e)?;
+            continue;
+        }
        for event in events.iter() {
            match event.token() {
                SERVER => loop {
@@ -108,7 +112,7 @@ where
                            if e.kind() == io::ErrorKind::WouldBlock {
                                break;
                            }
-                            return Err(e);
+                            return Err(e)?;
                        }
                    }
                },
@@ -132,9 +136,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) {
@@ -159,7 +167,7 @@ fn init_writable_handler(
    receiver: Receiver<(TcpStream, Token, SocketAddr, Option<Vec<u8>>)>,
    stop_manager: StopManager,
    context: ChannelContext,
-) -> io::Result<WritableNotify> {
+) -> anyhow::Result<WritableNotify> {
    let poll = Poll::new()?;
    let writable_notify = WritableNotify::new(Waker::new(poll.registry(), NOTIFY)?);
    let worker = {
@@ -203,7 +211,10 @@ fn tcp_writable_listen(
        ),
    > = HashMap::with_capacity(32);
    loop {
-        poll.poll(&mut events, None)?;
+        if let Err(e) = poll.poll(&mut events, None) {
+            crate::ignore_io_interrupted(e)?;
+            continue;
+        }
        for event in events.iter() {
            match event.token() {
                NOTIFY => {
@@ -339,6 +350,7 @@ fn readable_handle<H>(
    map: &mut HashMap<Token, (RouteKey, TcpStream, Box<[u8; BUFFER_SIZE]>, usize)>,
    recv_handler: &mut H,
    context: &ChannelContext,
+    extend: &mut [u8],
 ) -> io::Result<()>
 where
    H: RecvChannelHandler,
@@ -360,7 +372,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;
                    }
                }
@@ -17,7 +17,7 @@ pub fn udp_listen<H>(
    stop_manager: StopManager,
    recv_handler: H,
    context: ChannelContext,
-) -> io::Result<AcceptSocketSender<Option<Vec<UdpSocket>>>>
+) -> anyhow::Result<AcceptSocketSender<Option<Vec<UdpSocket>>>>
 where
    H: RecvChannelHandler,
 {
@@ -31,7 +31,7 @@ fn sub_udp_listen<H>(
    stop_manager: StopManager,
    recv_handler: H,
    context: ChannelContext,
-) -> io::Result<AcceptSocketSender<Option<Vec<UdpSocket>>>>
+) -> anyhow::Result<AcceptSocketSender<Option<Vec<UdpSocket>>>>
 where
    H: RecvChannelHandler,
 {
@@ -70,9 +70,13 @@ 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)?;
+        if let Err(e) = poll.poll(&mut events, None) {
+            crate::ignore_io_interrupted(e)?;
+            continue;
+        }
        for event in events.iter() {
            match event.token() {
                NOTIFY => {
@@ -115,6 +119,7 @@ where
                                Ok((len, addr)) => {
                                    recv_handler.handle(
                                        &mut buf[..len],
+                                        &mut extend,
                                        RouteKey::new(false, token.0, addr),
                                        &context,
                                    );
@@ -206,7 +211,7 @@ fn main_udp_listen<H>(
    stop_manager: StopManager,
    recv_handler: H,
    context: ChannelContext,
-) -> io::Result<()>
+) -> anyhow::Result<()>
 where
    H: RecvChannelHandler,
 {
@@ -252,8 +257,12 @@ where
    }

    let mut events = Events::with_capacity(udps.len());
+    let mut extend = [0; BUFFER_SIZE];
    loop {
-        poll.poll(&mut events, None)?;
+        if let Err(e) = poll.poll(&mut events, None) {
+            crate::ignore_io_interrupted(e)?;
+            continue;
+        }
        for x in events.iter() {
            let index = match x.token() {
                NOTIFY => return Ok(()),
@@ -270,6 +279,7 @@ where
                    Ok((len, addr)) => {
                        recv_handler.handle(
                            &mut buf[..len],
+                            &mut extend,
                            RouteKey::new(false, index, addr),
                            &context,
                        );
@@ -0,0 +1,2 @@
+mod rs_aes_cbc;
+pub use rs_aes_cbc::*;
@@ -1,6 +1,5 @@
-use std::io;
-
 use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use anyhow::anyhow;
 use rand::RngCore;

 use crate::cipher::Finger;
@@ -50,22 +49,17 @@ impl AesCbcCipher {
    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if !net_packet.is_encrypt() {
            //未加密的数据直接丢弃
-            return Err(io::Error::new(io::ErrorKind::Other, "not encrypt"));
+            return Err(anyhow!("not encrypt"));
        }
        if net_packet.payload().len() < 16 {
            log::error!("数据异常,长度{}小于{}", net_packet.payload().len(), 16);
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("aes_cbc data err"));
        }
        let mut iv = [0; 16];
-        iv[0..4].copy_from_slice(&net_packet.source().octets());
-        iv[4..8].copy_from_slice(&net_packet.destination().octets());
-        iv[8] = net_packet.protocol().into();
-        iv[9] = net_packet.transport_protocol();
-        iv[10] = net_packet.is_gateway() as u8;
-        iv[11] = net_packet.source_ttl();
+        iv[0..12].copy_from_slice(&net_packet.head_tag());
        if let Some(finger) = &self.finger {
            iv[12..16].copy_from_slice(&finger.hash[0..4]);
        }
@@ -75,7 +69,7 @@ impl AesCbcCipher {
        if let Some(finger) = &self.finger {
            let finger = finger.calculate_finger(&iv[..12], secret_body.en_body());
            if &finger != secret_body.finger() {
-                return Err(io::Error::new(io::ErrorKind::Other, "finger err"));
+                return Err(anyhow!("aes_cbc finger err"));
            }
        }
        let rs = match &self.cipher {
@@ -92,10 +86,7 @@ impl AesCbcCipher {
                net_packet.set_data_len(HEAD_LEN + len - 4)?;
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("解密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("aes_cbc 解密失败:{}", e)),
        }
    }
    /// net_packet 必须预留足够长度
@@ -103,15 +94,10 @@ impl AesCbcCipher {
    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        let data_len = net_packet.data_len();
        let mut iv = [0; 16];
-        iv[0..4].copy_from_slice(&net_packet.source().octets());
-        iv[4..8].copy_from_slice(&net_packet.destination().octets());
-        iv[8] = net_packet.protocol().into();
-        iv[9] = net_packet.transport_protocol();
-        iv[10] = net_packet.is_gateway() as u8;
-        iv[11] = net_packet.source_ttl();
+        iv[0..12].copy_from_slice(&net_packet.head_tag());
        if let Some(finger) = &self.finger {
            iv[12..16].copy_from_slice(&finger.hash[0..4]);
            net_packet.set_data_len(data_len + 16)?;
@@ -146,10 +132,22 @@ impl AesCbcCipher {
                net_packet.set_encrypt_flag(true);
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("加密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("aes_cbc 加密失败:{}", e)),
        };
    }
 }
+#[test]
+fn test_aes_cbc() {
+    let d = AesCbcCipher::new_128([0; 16], Some(Finger::new("123")));
+    let mut p = NetPacket::new_encrypt([0; 100]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+    let d = AesCbcCipher::new_128([0; 16], None);
+    let mut p = NetPacket::new_encrypt([0; 100]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+}
@@ -0,0 +1,9 @@
+#[cfg(not(any(feature = "openssl-vendored", feature = "openssl")))]
+mod rs_aes_ecb;
+#[cfg(not(any(feature = "openssl-vendored", feature = "openssl")))]
+pub use rs_aes_ecb::*;
+
+#[cfg(any(feature = "openssl-vendored", feature = "openssl"))]
+mod openssl_aes_ecb;
+#[cfg(any(feature = "openssl-vendored", feature = "openssl"))]
+pub use openssl_aes_ecb::*;
@@ -1,8 +1,11 @@
-use crate::cipher::Finger;
-use crate::protocol::{NetPacket, HEAD_LEN};
+use std::ptr;
+
+use anyhow::anyhow;
 use libc::c_int;
 use openssl_sys::EVP_CIPHER_CTX;
-use std::{io, ptr};
+
+use crate::cipher::Finger;
+use crate::protocol::{NetPacket, HEAD_LEN};

 pub struct AesEcbCipher {
    key: Vec<u8>,
@@ -100,34 +103,28 @@ impl AesEcbCipher {
    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if !net_packet.is_encrypt() {
            //未加密的数据直接丢弃
-            return Err(io::Error::new(io::ErrorKind::Other, "not encrypt"));
+            return Err(anyhow!("not encrypt"));
        }

        if let Some(finger) = &self.finger {
-            let mut nonce_raw = [0; 12];
-            nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-            nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-            nonce_raw[8] = net_packet.protocol().into();
-            nonce_raw[9] = net_packet.transport_protocol();
-            nonce_raw[10] = net_packet.is_gateway() as u8;
-            nonce_raw[11] = net_packet.source_ttl();
+            let nonce_raw = net_packet.head_tag();
            let len = net_packet.payload().len();
            if len < 12 {
-                return Err(io::Error::new(io::ErrorKind::Other, "data len err"));
+                return Err(anyhow!("data len err"));
            }
            let secret_body = &net_packet.payload()[..len - 12];
            let finger = finger.calculate_finger(&nonce_raw, secret_body);
            if &finger != &net_packet.payload()[len - 12..] {
-                return Err(io::Error::new(io::ErrorKind::Other, "finger err"));
+                return Err(anyhow!("finger err"));
            }
            net_packet.set_data_len(net_packet.data_len() - finger.len())?;
        }
        if net_packet.payload().len() < 16 {
            log::error!("数据异常,长度{}小于{}", net_packet.payload().len(), 16);
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("data err"));
        }
        let input = net_packet.payload();
        let mut out = [0u8; 1024 * 5];
@@ -147,22 +144,22 @@ impl AesEcbCipher {
            //校验头部
            let src_net_packet = NetPacket::new(text)?;
            if src_net_packet.source() != net_packet.source() {
-                return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                return Err(anyhow!("data err"));
            }
            if src_net_packet.destination() != net_packet.destination() {
-                return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                return Err(anyhow!("data err"));
            }
            if src_net_packet.protocol() != net_packet.protocol() {
-                return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                return Err(anyhow!("data err"));
            }
            if src_net_packet.transport_protocol() != net_packet.transport_protocol() {
-                return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                return Err(anyhow!("data err"));
            }
            if src_net_packet.is_gateway() != net_packet.is_gateway() {
-                return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                return Err(anyhow!("data err"));
            }
            if src_net_packet.source_ttl() != net_packet.source_ttl() {
-                return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                return Err(anyhow!("data err"));
            }
        }
        net_packet.set_encrypt_flag(false);
@@ -175,7 +172,7 @@ impl AesEcbCipher {
    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        let input = net_packet.buffer();
        let mut out = [0u8; 1024 * 5];
        let mut out_len = 0;
@@ -191,7 +188,7 @@ impl AesEcbCipher {
        }
        let out_len = out_len as usize;
        if out_len == 0 {
-            return Err(io::Error::new(io::ErrorKind::Other, "ciphertext len err"));
+            return Err(anyhow!("ciphertext len err"));
        }
        //密文
        let ciphertext = &out[..out_len];
@@ -199,13 +196,7 @@ impl AesEcbCipher {
        net_packet.payload_mut().copy_from_slice(ciphertext);
        net_packet.set_encrypt_flag(true);
        if let Some(finger) = &self.finger {
-            let mut nonce_raw = [0; 12];
-            nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-            nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-            nonce_raw[8] = net_packet.protocol().into();
-            nonce_raw[9] = net_packet.transport_protocol();
-            nonce_raw[10] = net_packet.is_gateway() as u8;
-            nonce_raw[11] = net_packet.source_ttl();
+            let nonce_raw = net_packet.head_tag();
            let finger = finger.calculate_finger(&nonce_raw, ciphertext);
            let src_data_len = net_packet.data_len();
            //设置实际长度
@@ -221,6 +212,8 @@ impl AesEcbCipher {
 fn test_openssl_aes_ecb() {
    let d = AesEcbCipher::new_128([0; 16], Some(Finger::new("123")));
    let mut p = NetPacket::new_encrypt([0; 100]).unwrap();
+    let src = p.buffer().to_vec();
    d.encrypt_ipv4(&mut p).unwrap();
    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
 }
@@ -1,7 +1,8 @@
+use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyInit};
+use anyhow::anyhow;
+
 use crate::cipher::Finger;
 use crate::protocol::{NetPacket, HEAD_LEN};
-use aes::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyInit};
-use std::io;

 type Aes128EcbEnc = ecb::Encryptor<aes::Aes128>;
 type Aes128EcbDec = ecb::Decryptor<aes::Aes128>;
@@ -46,34 +47,28 @@ impl AesEcbCipher {
    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if !net_packet.is_encrypt() {
            //未加密的数据直接丢弃
-            return Err(io::Error::new(io::ErrorKind::Other, "not encrypt"));
+            return Err(anyhow!("not encrypt"));
        }

        if let Some(finger) = &self.finger {
-            let mut nonce_raw = [0; 12];
-            nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-            nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-            nonce_raw[8] = net_packet.protocol().into();
-            nonce_raw[9] = net_packet.transport_protocol();
-            nonce_raw[10] = net_packet.is_gateway() as u8;
-            nonce_raw[11] = net_packet.source_ttl();
+            let nonce_raw = net_packet.head_tag();
            let len = net_packet.payload().len();
            if len < 12 {
-                return Err(io::Error::new(io::ErrorKind::Other, "payload len <12"));
+                return Err(anyhow!("payload len <12"));
            }
            let secret_body = &net_packet.payload()[..len - 12];
            let finger = finger.calculate_finger(&nonce_raw, secret_body);
            if &finger != &net_packet.payload()[len - 12..] {
-                return Err(io::Error::new(io::ErrorKind::Other, "finger err"));
+                return Err(anyhow!("finger err"));
            }
            net_packet.set_data_len(net_packet.data_len() - finger.len())?;
        }
        if net_packet.payload().len() < 16 {
            log::error!("数据异常,长度{}小于{}", net_packet.payload().len(), 16);
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("data err"));
        }
        let mut out = [0u8; 1024 * 5];
        let rs = match self.key {
@@ -87,32 +82,29 @@ impl AesEcbCipher {
                //校验头部
                let src_net_packet = NetPacket::new(buf)?;
                if src_net_packet.source() != net_packet.source() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.destination() != net_packet.destination() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.protocol() != net_packet.protocol() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.transport_protocol() != net_packet.transport_protocol() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.is_gateway() != net_packet.is_gateway() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.source_ttl() != net_packet.source_ttl() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                net_packet.set_data_len(buf.len())?;
                net_packet.set_payload(src_net_packet.payload())?;
                net_packet.set_encrypt_flag(false);
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("aes_ecb解密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("aes_ecb解密失败:{}", e)),
        }
    }
    /// net_packet 必须预留足够长度
@@ -120,7 +112,7 @@ impl AesEcbCipher {
    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        let mut out = [0u8; 1024 * 5];
        let rs = match self.key {
            AesEcbEnum::AES128ECB(key) => Aes128EcbEnc::new(&key.into())
@@ -136,13 +128,7 @@ impl AesEcbCipher {
                net_packet.set_encrypt_flag(true);

                if let Some(finger) = &self.finger {
-                    let mut nonce_raw = [0; 12];
-                    nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-                    nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-                    nonce_raw[8] = net_packet.protocol().into();
-                    nonce_raw[9] = net_packet.transport_protocol();
-                    nonce_raw[10] = net_packet.is_gateway() as u8;
-                    nonce_raw[11] = net_packet.source_ttl();
+                    let nonce_raw = net_packet.head_tag();
                    let finger = finger.calculate_finger(&nonce_raw, buf);
                    let src_data_len = net_packet.data_len();
                    //设置实际长度
@@ -152,10 +138,7 @@ impl AesEcbCipher {
                }
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("aes_ecb加密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("aes_ecb加密失败:{}", e)),
        };
    }
 }
@@ -1,8 +1,7 @@
-use std::io;
-
 use aes_gcm::aead::consts::{U12, U16};
 use aes_gcm::aead::generic_array::GenericArray;
 use aes_gcm::{AeadInPlace, Aes128Gcm, Aes256Gcm, Key, KeyInit, Nonce, Tag};
+use anyhow::anyhow;
 use rand::RngCore;

 use crate::cipher::finger::Finger;
@@ -39,22 +38,16 @@ impl AesGcmCipher {
    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if !net_packet.is_encrypt() {
            //未加密的数据直接丢弃
-            return Err(io::Error::new(io::ErrorKind::Other, "not encrypt"));
+            return Err(anyhow!("not encrypt"));
        }
        if net_packet.payload().len() < AES_GCM_ENCRYPTION_RESERVED {
            log::error!("数据异常,长度小于{}", AES_GCM_ENCRYPTION_RESERVED);
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("data err"));
        }
-        let mut nonce_raw = [0; 12];
-        nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-        nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-        nonce_raw[8] = net_packet.protocol().into();
-        nonce_raw[9] = net_packet.transport_protocol();
-        nonce_raw[10] = net_packet.is_gateway() as u8;
-        nonce_raw[11] = net_packet.source_ttl();
+        let nonce_raw = net_packet.head_tag();
        let nonce: &GenericArray<u8, U12> = Nonce::from_slice(&nonce_raw);

        let mut secret_body = SecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
@@ -62,7 +55,7 @@ impl AesGcmCipher {
        if let Some(finger) = &self.finger {
            let finger = finger.calculate_finger(&nonce_raw, secret_body.en_body());
            if &finger != secret_body.finger() {
-                return Err(io::Error::new(io::ErrorKind::Other, "finger err"));
+                return Err(anyhow!("finger err"));
            }
        }
        let tag: GenericArray<u8, U16> = Tag::clone_from_slice(tag);
@@ -75,10 +68,7 @@ impl AesGcmCipher {
            }
        };
        if let Err(e) = rs {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("解密失败:{}", e),
-            ));
+            return Err(anyhow!("解密失败:{}", e));
        }
        net_packet.set_encrypt_flag(false);
        net_packet.set_data_len(net_packet.data_len() - AES_GCM_ENCRYPTION_RESERVED)?;
@@ -89,17 +79,11 @@ impl AesGcmCipher {
    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if net_packet.reserve() < AES_GCM_ENCRYPTION_RESERVED {
-            return Err(io::Error::new(io::ErrorKind::Other, "too short"));
+            return Err(anyhow!("too short"));
        }
-        let mut nonce_raw = [0; 12];
-        nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-        nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-        nonce_raw[8] = net_packet.protocol().into();
-        nonce_raw[9] = net_packet.transport_protocol();
-        nonce_raw[10] = net_packet.is_gateway() as u8;
-        nonce_raw[11] = net_packet.source_ttl();
+        let nonce_raw = net_packet.head_tag();
        let nonce: &GenericArray<u8, U12> = Nonce::from_slice(&nonce_raw);
        let data_len = net_packet.data_len() + AES_GCM_ENCRYPTION_RESERVED;
        net_packet.set_data_len(data_len)?;
@@ -123,10 +107,26 @@ impl AesGcmCipher {
                net_packet.set_encrypt_flag(true);
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("加密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("加密失败:{}", e)),
        };
    }
 }
+
+#[test]
+fn test_aes_gcm() {
+    let d = AesGcmCipher::new_256([0; 32], Some(Finger::new("123")));
+    let mut p =
+        NetPacket::new_encrypt([1; 13 + crate::protocol::body::ENCRYPTION_RESERVED]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+
+    let d = AesGcmCipher::new_256([0; 32], None);
+    let mut p =
+        NetPacket::new_encrypt([0; 13 + crate::protocol::body::ENCRYPTION_RESERVED]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+}
@@ -0,0 +1,9 @@
+#[cfg(feature = "ring-cipher")]
+mod ring_aes_gcm_cipher;
+#[cfg(feature = "ring-cipher")]
+pub use ring_aes_gcm_cipher::*;
+
+#[cfg(not(feature = "ring-cipher"))]
+mod aes_gcm_cipher;
+#[cfg(not(feature = "ring-cipher"))]
+pub use aes_gcm_cipher::*;
@@ -1,9 +1,9 @@
-use crate::cipher::Finger;
+use anyhow::anyhow;
 use rand::RngCore;
 use ring::aead;
 use ring::aead::{LessSafeKey, UnboundKey};
-use std::io;

+use crate::cipher::Finger;
 use crate::protocol::body::{SecretBody, AES_GCM_ENCRYPTION_RESERVED};
 use crate::protocol::NetPacket;

@@ -53,28 +53,22 @@ impl AesGcmCipher {
    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if !net_packet.is_encrypt() {
            //未加密的数据直接丢弃
-            return Err(io::Error::new(io::ErrorKind::Other, "not encrypt"));
+            return Err(anyhow!("not encrypt"));
        }
        if net_packet.payload().len() < AES_GCM_ENCRYPTION_RESERVED {
            log::error!("数据异常,长度小于{}", AES_GCM_ENCRYPTION_RESERVED);
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("data err"));
        }
-        let mut nonce_raw = [0; 12];
-        nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-        nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-        nonce_raw[8] = net_packet.protocol().into();
-        nonce_raw[9] = net_packet.transport_protocol();
-        nonce_raw[10] = net_packet.is_gateway() as u8;
-        nonce_raw[11] = net_packet.source_ttl();
+        let nonce_raw = net_packet.head_tag();
        let nonce = aead::Nonce::assume_unique_for_key(nonce_raw);
        let mut secret_body = SecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
        if let Some(finger) = &self.finger {
            let finger = finger.calculate_finger(&nonce_raw, secret_body.en_body());
            if &finger != secret_body.finger() {
-                return Err(io::Error::new(io::ErrorKind::Other, "ring aes finger err"));
+                return Err(anyhow!("ring aes finger err"));
            }
        }

@@ -87,10 +81,7 @@ impl AesGcmCipher {
            }
        };
        if let Err(e) = rs {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("解密失败:{}", e),
-            ));
+            return Err(anyhow!("解密失败:{}", e));
        }
        net_packet.set_encrypt_flag(false);
        net_packet.set_data_len(net_packet.data_len() - AES_GCM_ENCRYPTION_RESERVED)?;
@@ -102,14 +93,8 @@ impl AesGcmCipher {
    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
-        let mut nonce_raw = [0; 12];
-        nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-        nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-        nonce_raw[8] = net_packet.protocol().into();
-        nonce_raw[9] = net_packet.transport_protocol();
-        nonce_raw[10] = net_packet.is_gateway() as u8;
-        nonce_raw[11] = net_packet.source_ttl();
+    ) -> anyhow::Result<()> {
+        let nonce_raw = net_packet.head_tag();
        let nonce = aead::Nonce::assume_unique_for_key(nonce_raw);
        let data_len = net_packet.data_len() + AES_GCM_ENCRYPTION_RESERVED;
        net_packet.set_data_len(data_len)?;
@@ -128,10 +113,7 @@ impl AesGcmCipher {
            Ok(tag) => {
                let tag = tag.as_ref();
                if tag.len() != 16 {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        format!("加密tag长度错误:{}", tag.len()),
-                    ));
+                    return Err(anyhow!("加密tag长度错误:{}", tag.len()));
                }
                secret_body.set_tag(tag)?;
                if let Some(finger) = &self.finger {
@@ -141,10 +123,26 @@ impl AesGcmCipher {
                net_packet.set_encrypt_flag(true);
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("加密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("加密失败:{}", e)),
        };
    }
 }
+
+#[test]
+fn test_aes_gcm() {
+    let d = AesGcmCipher::new_256([0; 32], Some(Finger::new("123")));
+    let mut p =
+        NetPacket::new_encrypt([0; 13 + crate::protocol::body::ENCRYPTION_RESERVED]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+
+    let d = AesGcmCipher::new_256([0; 32], None);
+    let mut p =
+        NetPacket::new_encrypt([0; 13 + crate::protocol::body::ENCRYPTION_RESERVED]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+}
@@ -0,0 +1,2 @@
+mod rs_chacha20;
+pub use rs_chacha20::*;
@@ -0,0 +1,107 @@
+use aes::cipher::Iv;
+use anyhow::anyhow;
+use chacha20::cipher::{Key, KeyIvInit, StreamCipher};
+use chacha20::ChaCha20;
+
+use crate::cipher::finger::{gen_nonce, gen_random_nonce};
+use crate::cipher::Finger;
+use crate::protocol::body::{
+    IVSecretBody, SecretTail, SecretTailMut, FINGER_RESERVED, RANDOM_RESERVED,
+};
+use crate::protocol::NetPacket;
+
+#[derive(Clone)]
+pub struct ChaCha20Cipher {
+    key: [u8; 32],
+    pub(crate) finger: Option<Finger>,
+}
+
+impl ChaCha20Cipher {
+    pub fn new_256(key: [u8; 32], finger: Option<Finger>) -> Self {
+        Self { key, finger }
+    }
+}
+
+impl ChaCha20Cipher {
+    pub fn key(&self) -> &[u8] {
+        &self.key
+    }
+}
+
+impl ChaCha20Cipher {
+    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        if !net_packet.is_encrypt() {
+            //未加密的数据直接丢弃
+            return Err(anyhow!("not encrypt"));
+        }
+        let mut head_tag = net_packet.head_tag();
+
+        let mut secret_body = IVSecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
+        if let Some(finger) = &self.finger {
+            let finger = finger.calculate_finger(&head_tag, secret_body.data());
+            if &finger != secret_body.finger() {
+                return Err(anyhow!("ChaCha20 finger err"));
+            }
+        }
+        gen_nonce(&mut head_tag, secret_body.random_buf());
+        ChaCha20::new(
+            Key::<ChaCha20>::from_slice(&self.key),
+            Iv::<ChaCha20>::from_slice(&head_tag),
+        )
+        .apply_keystream(secret_body.data_mut());
+        let len = secret_body.data().len();
+        net_packet.set_encrypt_flag(false);
+        net_packet.set_payload_len(len)?;
+        Ok(())
+    }
+    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        let data_len = net_packet.data_len();
+        let head_tag = net_packet.head_tag();
+        if let Some(_) = &self.finger {
+            net_packet.set_data_len(data_len + RANDOM_RESERVED + FINGER_RESERVED)?;
+        } else {
+            net_packet.set_data_len(data_len + RANDOM_RESERVED)?;
+        }
+        let mut secret_body = IVSecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
+        let mut nonce = head_tag;
+        secret_body.set_random(&gen_random_nonce(&mut nonce));
+
+        ChaCha20::new(
+            Key::<ChaCha20>::from_slice(&self.key),
+            Iv::<ChaCha20>::from_slice(&nonce),
+        )
+        .apply_keystream(secret_body.data_mut());
+        if let Some(finger) = &self.finger {
+            let finger = finger.calculate_finger(&head_tag, secret_body.data());
+            let mut secret_body = IVSecretBody::new(net_packet.payload_mut(), true)?;
+            secret_body.set_finger(&finger)?;
+        }
+        net_packet.set_encrypt_flag(true);
+        Ok(())
+    }
+}
+
+#[test]
+fn test_chacha20() {
+    let d = ChaCha20Cipher::new_256([0; 32], Some(Finger::new("123")));
+    let mut p =
+        NetPacket::new_encrypt([1; 13 + crate::protocol::body::ENCRYPTION_RESERVED]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+
+    let d = ChaCha20Cipher::new_256([0; 32], None);
+    let mut p =
+        NetPacket::new_encrypt([2; 13 + crate::protocol::body::ENCRYPTION_RESERVED]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+}
@@ -0,0 +1,9 @@
+#[cfg(feature = "ring-cipher")]
+mod ring_chacha20_poly1305;
+#[cfg(feature = "ring-cipher")]
+pub use ring_chacha20_poly1305::*;
+
+#[cfg(not(feature = "ring-cipher"))]
+mod rs_chacha20_poly1305;
+#[cfg(not(feature = "ring-cipher"))]
+pub use rs_chacha20_poly1305::*;
@@ -0,0 +1,127 @@
+use anyhow::anyhow;
+
+use ring::aead;
+use ring::aead::{LessSafeKey, UnboundKey};
+
+use crate::cipher::finger::{gen_nonce, gen_random_nonce};
+use crate::cipher::Finger;
+use crate::protocol::body::{
+    AEADSecretBody, SecretTail, SecretTailMut, FINGER_RESERVED, RANDOM_RESERVED, TAG_RESERVED,
+};
+use crate::protocol::NetPacket;
+
+#[derive(Clone)]
+pub struct ChaCha20Poly1305Cipher {
+    key: Vec<u8>,
+    pub(crate) cipher: LessSafeKey,
+    pub(crate) finger: Option<Finger>,
+}
+
+impl ChaCha20Poly1305Cipher {
+    pub fn new_256(key: [u8; 32], finger: Option<Finger>) -> Self {
+        let cipher = LessSafeKey::new(UnboundKey::new(&aead::CHACHA20_POLY1305, &key).unwrap());
+        Self {
+            key: key.to_vec(),
+            cipher,
+            finger,
+        }
+    }
+}
+
+impl ChaCha20Poly1305Cipher {
+    pub fn key(&self) -> &[u8] {
+        &self.key
+    }
+}
+
+impl ChaCha20Poly1305Cipher {
+    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        if !net_packet.is_encrypt() {
+            //未加密的数据直接丢弃
+            return Err(anyhow!("not encrypt"));
+        }
+        if net_packet.payload().len() < TAG_RESERVED {
+            log::error!("数据异常,长度小于{}", TAG_RESERVED);
+            return Err(anyhow!("data err"));
+        }
+        let mut head_tag = net_packet.head_tag();
+        let mut secret_body = AEADSecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
+        if let Some(finger) = &self.finger {
+            let finger = finger.calculate_finger(&head_tag, secret_body.data_tag_mut());
+            if &finger != secret_body.finger() {
+                return Err(anyhow!("ring CHACHA20_POLY1305 finger err"));
+            }
+        }
+        gen_nonce(&mut head_tag, secret_body.random_buf());
+        let nonce = aead::Nonce::assume_unique_for_key(head_tag);
+        let rs = self
+            .cipher
+            .open_in_place(nonce, aead::Aad::empty(), secret_body.data_tag_mut());
+        if let Err(e) = rs {
+            return Err(anyhow!("ring CHACHA20_POLY1305 解密失败:{}", e));
+        }
+        let len = secret_body.data().len();
+        net_packet.set_encrypt_flag(false);
+        net_packet.set_payload_len(len)?;
+        return Ok(());
+    }
+    /// net_packet 必须预留足够长度
+    /// data_len是有效载荷的长度
+    /// 返回加密后载荷的长度
+    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        let head_tag = net_packet.head_tag();
+        let data_len = net_packet.data_len();
+        if self.finger.is_some() {
+            net_packet.set_data_len(data_len + TAG_RESERVED + RANDOM_RESERVED + FINGER_RESERVED)?;
+        } else {
+            net_packet.set_data_len(data_len + TAG_RESERVED + RANDOM_RESERVED)?;
+        }
+        let mut secret_body = AEADSecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
+        let mut nonce = head_tag;
+        secret_body.set_random(&gen_random_nonce(&mut nonce));
+        let nonce = aead::Nonce::assume_unique_for_key(nonce);
+        let rs = self.cipher.seal_in_place_separate_tag(
+            nonce,
+            aead::Aad::empty(),
+            secret_body.data_mut(),
+        );
+        match rs {
+            Ok(tag) => {
+                let tag = tag.as_ref();
+                if tag.len() != 16 {
+                    return Err(anyhow!("加密tag长度错误:{}", tag.len()));
+                }
+                secret_body.set_tag(tag)?;
+                if let Some(finger) = &self.finger {
+                    let finger = finger.calculate_finger(&head_tag, secret_body.data_tag_mut());
+                    secret_body.set_finger(&finger)?;
+                }
+                net_packet.set_encrypt_flag(true);
+                Ok(())
+            }
+            Err(e) => Err(anyhow!("ring CHACHA20_POLY1305 加密失败:{}", e)),
+        }
+    }
+}
+
+#[test]
+fn test_ring_chacha20_poly1305() {
+    let d = ChaCha20Poly1305Cipher::new_256([0; 32], Some(Finger::new("123")));
+    let mut p = NetPacket::new_encrypt([0; 73]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+    let d = ChaCha20Poly1305Cipher::new_256([0; 32], None);
+    let mut p = NetPacket::new_encrypt([0; 73]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+}
@@ -0,0 +1,126 @@
+use crate::cipher::finger::{gen_nonce, gen_random_nonce};
+use crate::cipher::Finger;
+use crate::protocol::body::{
+    AEADSecretBody, SecretTail, SecretTailMut, FINGER_RESERVED, RANDOM_RESERVED, TAG_RESERVED,
+};
+use crate::protocol::NetPacket;
+use anyhow::anyhow;
+use chacha20poly1305::aead::{Nonce, Tag};
+use chacha20poly1305::{AeadInPlace, ChaCha20Poly1305, Key, KeyInit};
+
+#[derive(Clone)]
+pub struct ChaCha20Poly1305Cipher {
+    key: Vec<u8>,
+    pub(crate) cipher: ChaCha20Poly1305,
+    pub(crate) finger: Option<Finger>,
+}
+
+impl ChaCha20Poly1305Cipher {
+    pub fn new_256(key: [u8; 32], finger: Option<Finger>) -> Self {
+        let key: &Key = &key.into();
+        let cipher = ChaCha20Poly1305::new(key);
+        Self {
+            key: key.to_vec(),
+            cipher,
+            finger,
+        }
+    }
+}
+
+impl ChaCha20Poly1305Cipher {
+    pub fn key(&self) -> &[u8] {
+        &self.key
+    }
+}
+
+impl ChaCha20Poly1305Cipher {
+    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        if !net_packet.is_encrypt() {
+            //未加密的数据直接丢弃
+            return Err(anyhow!("not encrypt"));
+        }
+        if net_packet.payload().len() < TAG_RESERVED {
+            log::error!("数据异常,长度小于{}", TAG_RESERVED);
+            return Err(anyhow!("data err"));
+        }
+        let mut head_tag = net_packet.head_tag();
+        let mut secret_body = AEADSecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
+        if let Some(finger) = &self.finger {
+            let finger = finger.calculate_finger(&head_tag, secret_body.data_tag_mut());
+            if &finger != secret_body.finger() {
+                return Err(anyhow!("rs CHACHA20_POLY1305 finger err"));
+            }
+        }
+        gen_nonce(&mut head_tag, secret_body.random_buf());
+        let nonce: Nonce<ChaCha20Poly1305> = head_tag.into();
+        let tag: Tag<ChaCha20Poly1305> =
+            Tag::<ChaCha20Poly1305>::from_slice(secret_body.tag()).clone();
+        if let Err(e) =
+            self.cipher
+                .decrypt_in_place_detached(&nonce, &[], secret_body.data_mut(), &tag)
+        {
+            return Err(anyhow!("rs CHACHA20_POLY1305 decrypt_ipv4 {:?}", e));
+        }
+        let len = secret_body.data().len();
+        net_packet.set_encrypt_flag(false);
+        net_packet.set_payload_len(len)?;
+        Ok(())
+    }
+    /// net_packet 必须预留足够长度
+    /// data_len是有效载荷的长度
+    /// 返回加密后载荷的长度
+    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        let head_tag = net_packet.head_tag();
+        let data_len = net_packet.data_len();
+        if self.finger.is_some() {
+            net_packet.set_data_len(data_len + TAG_RESERVED + RANDOM_RESERVED + FINGER_RESERVED)?;
+        } else {
+            net_packet.set_data_len(data_len + TAG_RESERVED + RANDOM_RESERVED)?;
+        }
+        let mut secret_body = AEADSecretBody::new(net_packet.payload_mut(), self.finger.is_some())?;
+        let mut nonce = head_tag;
+        secret_body.set_random(&gen_random_nonce(&mut nonce));
+        let nonce = nonce.into();
+        let rs = self
+            .cipher
+            .encrypt_in_place_detached(&nonce, &[], secret_body.data_mut());
+        match rs {
+            Ok(tag) => {
+                let tag: &[u8] = tag.as_ref();
+                if tag.len() != 16 {
+                    return Err(anyhow!("加密tag长度错误:{}", tag.len(),));
+                }
+                secret_body.set_tag(tag)?;
+                if let Some(finger) = &self.finger {
+                    let finger = finger.calculate_finger(&head_tag, secret_body.data_tag_mut());
+                    secret_body.set_finger(&finger)?;
+                }
+                net_packet.set_encrypt_flag(true);
+                Ok(())
+            }
+            Err(e) => Err(anyhow!("rs CHACHA20_POLY1305 加密失败:{}", e)),
+        }
+    }
+}
+
+#[test]
+fn test_rs_chacha20_poly1305() {
+    let d = ChaCha20Poly1305Cipher::new_256([0; 32], Some(Finger::new("123")));
+    let mut p = NetPacket::new_encrypt([0; 73]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+    let d = ChaCha20Poly1305Cipher::new_256([0; 32], None);
+    let mut p = NetPacket::new_encrypt([0; 73]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src);
+}
@@ -1,110 +1,99 @@
-#[cfg(feature = "aes_ecb")]
-#[cfg(not(any(feature = "openssl-vendored", feature = "openssl")))]
-use crate::cipher::aes_ecb::AesEcbCipher;
 use std::fmt::Display;
+use std::str::FromStr;
+
+use anyhow::anyhow;
+#[cfg(cipher)]
+use sha2::Digest;

 #[cfg(feature = "aes_cbc")]
 use crate::cipher::aes_cbc::AesCbcCipher;
-#[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
-#[cfg(not(feature = "ring-cipher"))]
-use crate::cipher::aes_gcm_cipher::AesGcmCipher;
 #[cfg(feature = "aes_ecb")]
-#[cfg(any(feature = "openssl-vendored", feature = "openssl"))]
-use crate::cipher::openssl_aes_ecb::AesEcbCipher;
+use crate::cipher::aes_ecb::AesEcbCipher;
 #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
-#[cfg(feature = "ring-cipher")]
-use crate::cipher::ring_aes_gcm_cipher::AesGcmCipher;
+use crate::cipher::aes_gcm::AesGcmCipher;
+#[cfg(feature = "chacha20_poly1305")]
+use crate::cipher::chacha20::ChaCha20Cipher;
+#[cfg(feature = "chacha20_poly1305")]
+use crate::cipher::chacha20_poly1305::ChaCha20Poly1305Cipher;
 #[cfg(feature = "sm4_cbc")]
 use crate::cipher::sm4_cbc::Sm4CbcCipher;
-#[cfg(any(
-    feature = "aes_gcm",
-    feature = "server_encrypt",
-    feature = "aes_cbc",
-    feature = "aes_ecb",
-    feature = "sm4_cbc"
-))]
+use crate::cipher::xor::XORCipher;
+#[cfg(cipher)]
 use crate::cipher::Finger;
 use crate::protocol::NetPacket;
-#[cfg(any(
-    feature = "aes_gcm",
-    feature = "server_encrypt",
-    feature = "aes_cbc",
-    feature = "aes_ecb",
-    feature = "sm4_cbc"
-))]
-use sha2::Digest;
-use std::io;
-use std::str::FromStr;

 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum CipherModel {
    #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
    AesGcm,
+    #[cfg(feature = "chacha20_poly1305")]
+    Chacha20Poly1305,
+    #[cfg(feature = "chacha20_poly1305")]
+    Chacha20,
    #[cfg(feature = "aes_cbc")]
    AesCbc,
    #[cfg(feature = "aes_ecb")]
    AesEcb,
    #[cfg(feature = "sm4_cbc")]
    Sm4Cbc,
+    Xor,
    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 = "chacha20_poly1305")]
+            CipherModel::Chacha20Poly1305 => "chacha20_poly1305".to_string(),
+            #[cfg(feature = "chacha20_poly1305")]
+            CipherModel::Chacha20 => "chacha20".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::Xor => "xor".to_string(),
            CipherModel::None => "none".to_string(),
        };
        write!(f, "{}", str)
    }
 }
+
 impl FromStr for CipherModel {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        #[cfg(not(any(
-            feature = "aes_gcm",
-            feature = "server_encrypt",
-            feature = "aes_cbc",
-            feature = "aes_ecb",
-            feature = "sm4_cbc"
-        )))]
-        return Err(format!("not match '{}', no encrypt", s));
-        #[cfg(any(
-            feature = "aes_gcm",
-            feature = "server_encrypt",
-            feature = "aes_cbc",
-            feature = "aes_ecb",
-            feature = "sm4_cbc"
-        ))]
        match s.to_lowercase().trim() {
            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
            "aes_gcm" => Ok(CipherModel::AesGcm),
+            #[cfg(feature = "chacha20_poly1305")]
+            "chacha20_poly1305" => Ok(CipherModel::Chacha20Poly1305),
+            #[cfg(feature = "chacha20_poly1305")]
+            "chacha20" => Ok(CipherModel::Chacha20),
            #[cfg(feature = "aes_cbc")]
            "aes_cbc" => Ok(CipherModel::AesCbc),
            #[cfg(feature = "aes_ecb")]
            "aes_ecb" => Ok(CipherModel::AesEcb),
            #[cfg(feature = "sm4_cbc")]
            "sm4_cbc" => Ok(CipherModel::Sm4Cbc),
+            "xor" => Ok(CipherModel::Xor),
            _ => {
                let mut enums = String::new();
                #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
                enums.push_str("/aes_gcm");
+                #[cfg(feature = "chacha20_poly1305")]
+                enums.push_str("/chacha20_poly1305/chacha20");
                #[cfg(feature = "aes_cbc")]
                enums.push_str("/aes_cbc");
                #[cfg(feature = "aes_ecb")]
                enums.push_str("/aes_ecb");
                #[cfg(feature = "sm4_cbc")]
                enums.push_str("/sm4_cbc");
-                let str = if enums.is_empty() {
-                    "no encrypt"
-                } else {
-                    &enums[1..]
-                };
-                Err(format!("not match '{}', enum:{}", s, str))
+                enums.push_str("/xor");
+                Err(format!("not match '{}', enum:{}", s, &enums[1..]))
            }
        }
    }
@@ -114,199 +103,176 @@ impl FromStr for CipherModel {
 pub enum Cipher {
    #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
    AesGcm((AesGcmCipher, Vec<u8>)),
+    #[cfg(feature = "chacha20_poly1305")]
+    Chacha20Poly1305(ChaCha20Poly1305Cipher),
+    #[cfg(feature = "chacha20_poly1305")]
+    Chacha20(ChaCha20Cipher),
    #[cfg(feature = "aes_cbc")]
    AesCbc(AesCbcCipher),
    #[cfg(feature = "aes_ecb")]
    AesEcb(AesEcbCipher),
    #[cfg(feature = "sm4_cbc")]
    Sm4Cbc(Sm4CbcCipher),
+    Xor(XORCipher),
    None,
 }
+
 impl Cipher {
-    #[cfg(not(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    )))]
-    pub fn new_password(
-        _model: CipherModel,
-        _password: Option<String>,
-        _token: Option<String>,
-    ) -> Self {
-        Cipher::None
-    }
-    #[cfg(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    ))]
    pub fn new_password(
        model: CipherModel,
        password: Option<String>,
        token: Option<String>,
-    ) -> Self {
-        let finger = token.map(|token| Finger::new(&token));
+    ) -> anyhow::Result<Self> {
        if let Some(password) = password {
-            let mut hasher = sha2::Sha256::new();
-            hasher.update(password.as_bytes());
-            let key: [u8; 32] = hasher.finalize().into();
+            #[cfg(cipher)]
+            let key: [u8; 32] = {
+                let mut hasher = sha2::Sha256::new();
+                hasher.update(password.as_bytes());
+                hasher.finalize().into()
+            };
            match model {
                #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
                CipherModel::AesGcm => {
+                    let finger = token.map(|token| Finger::new(&token));
                    if password.len() < 8 {
                        let aes = AesGcmCipher::new_128(key[..16].try_into().unwrap(), finger);
-                        Cipher::AesGcm((aes, key[..16].to_vec()))
+                        Ok(Cipher::AesGcm((aes, key[..16].to_vec())))
                    } else {
                        let aes = AesGcmCipher::new_256(key, finger);
-                        Cipher::AesGcm((aes, key.to_vec()))
+                        Ok(Cipher::AesGcm((aes, key.to_vec())))
                    }
                }
+                #[cfg(feature = "chacha20_poly1305")]
+                CipherModel::Chacha20Poly1305 => {
+                    let finger = token.map(|token| Finger::new(&token));
+                    let chacha = ChaCha20Poly1305Cipher::new_256(key, finger);
+                    Ok(Cipher::Chacha20Poly1305(chacha))
+                }
+                #[cfg(feature = "chacha20_poly1305")]
+                CipherModel::Chacha20 => {
+                    let finger = token.map(|token| Finger::new(&token));
+                    let chacha = ChaCha20Cipher::new_256(key, finger);
+                    Ok(Cipher::Chacha20(chacha))
+                }
                #[cfg(feature = "aes_cbc")]
                CipherModel::AesCbc => {
+                    let finger = token.map(|token| Finger::new(&token));
                    if password.len() < 8 {
                        let aes = AesCbcCipher::new_128(key[..16].try_into().unwrap(), finger);
-                        Cipher::AesCbc(aes)
+                        Ok(Cipher::AesCbc(aes))
                    } else {
                        let aes = AesCbcCipher::new_256(key, finger);
-                        Cipher::AesCbc(aes)
+                        Ok(Cipher::AesCbc(aes))
                    }
                }
                #[cfg(feature = "aes_ecb")]
                CipherModel::AesEcb => {
+                    let finger = token.map(|token| Finger::new(&token));
                    if password.len() < 8 {
                        let aes = AesEcbCipher::new_128(key[..16].try_into().unwrap(), finger);
-                        Cipher::AesEcb(aes)
+                        Ok(Cipher::AesEcb(aes))
                    } else {
                        let aes = AesEcbCipher::new_256(key, finger);
-                        Cipher::AesEcb(aes)
+                        Ok(Cipher::AesEcb(aes))
                    }
                }
                #[cfg(feature = "sm4_cbc")]
                CipherModel::Sm4Cbc => {
+                    let finger = token.map(|token| Finger::new(&token));
                    let aes = Sm4CbcCipher::new_128(key[..16].try_into().unwrap(), finger);
-                    Cipher::Sm4Cbc(aes)
+                    Ok(Cipher::Sm4Cbc(aes))
                }
-                CipherModel::None => Cipher::None,
+                CipherModel::Xor => {
+                    if token.is_some() {
+                        Err(anyhow::anyhow!(
+                            "'finger' and 'xor' cannot be used simultaneously"
+                        ))?
+                    }
+                    Ok(Cipher::Xor(XORCipher::new_256(
+                        crate::cipher::xor::simple_hash(&password),
+                    )))
+                }
+                CipherModel::None => Ok(Cipher::None),
            }
        } else {
-            Cipher::None
+            Ok(Cipher::None)
        }
    }
-    #[cfg(not(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    )))]
-    pub fn new_key(_key: [u8; 32], _token: String) -> io::Result<Self> {
-        Err(io::Error::new(io::ErrorKind::Other, "key error"))
+    #[cfg(not(any(feature = "aes_gcm", feature = "server_encrypt")))]
+    pub fn new_key(_key: [u8; 32], _token: String) -> anyhow::Result<Self> {
+        Err(anyhow!("key error"))
    }
-    #[cfg(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    ))]
-    pub fn new_key(key: [u8; 32], token: String) -> io::Result<Self> {
+    #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
+    pub fn new_key(key: [u8; 32], token: String) -> anyhow::Result<Self> {
        let finger = Some(Finger::new(&token));
        match key.len() {
-            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
            16 => {
                let aes = AesGcmCipher::new_128(key[..16].try_into().unwrap(), finger);
                Ok(Cipher::AesGcm((aes, key[..16].to_vec())))
            }
-            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
            32 => {
                let aes = AesGcmCipher::new_256(key, finger);
                Ok(Cipher::AesGcm((aes, key.to_vec())))
            }
-            _ => Err(io::Error::new(io::ErrorKind::Other, "key error")),
+            _ => Err(anyhow!("key error")),
        }
    }
    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        match self {
            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
            Cipher::AesGcm((aes_gcm, _)) => aes_gcm.decrypt_ipv4(net_packet),
            #[cfg(feature = "aes_cbc")]
            Cipher::AesCbc(aes_cbc) => aes_cbc.decrypt_ipv4(net_packet),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20Poly1305(chacha20poly1305) => chacha20poly1305.decrypt_ipv4(net_packet),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20(chacha20) => chacha20.decrypt_ipv4(net_packet),
            #[cfg(feature = "aes_ecb")]
            Cipher::AesEcb(aes_ecb) => aes_ecb.decrypt_ipv4(net_packet),
            #[cfg(feature = "sm4_cbc")]
            Cipher::Sm4Cbc(sm4_cbc) => sm4_cbc.decrypt_ipv4(net_packet),
+            Cipher::Xor(xor) => xor.decrypt_ipv4(net_packet),
            Cipher::None => {
                if net_packet.is_encrypt() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "not key"));
+                    return Err(anyhow!("not key"));
                }
                Ok(())
            }
        }
    }
-    #[cfg(not(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    )))]
-    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
-        &self,
-        _net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
-        Ok(())
-    }
-    #[cfg(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    ))]
    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        match self {
            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
            Cipher::AesGcm((aes_gcm, _)) => aes_gcm.encrypt_ipv4(net_packet),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20Poly1305(chacha20poly1305) => chacha20poly1305.encrypt_ipv4(net_packet),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20(chacha20) => chacha20.encrypt_ipv4(net_packet),
            #[cfg(feature = "aes_cbc")]
            Cipher::AesCbc(aes_cbc) => aes_cbc.encrypt_ipv4(net_packet),
            #[cfg(feature = "aes_ecb")]
            Cipher::AesEcb(aes_ecb) => aes_ecb.encrypt_ipv4(net_packet),
            #[cfg(feature = "sm4_cbc")]
            Cipher::Sm4Cbc(sm4_cbc) => sm4_cbc.encrypt_ipv4(net_packet),
+            Cipher::Xor(xor) => xor.encrypt_ipv4(net_packet),
            Cipher::None => Ok(()),
        }
    }
-    #[cfg(not(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    )))]
+    #[cfg(not(cipher))]
    pub fn check_finger<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        _net_packet: &NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        Ok(())
    }
-    #[cfg(any(
-        feature = "aes_gcm",
-        feature = "server_encrypt",
-        feature = "aes_cbc",
-        feature = "aes_ecb",
-        feature = "sm4_cbc"
-    ))]
-    pub fn check_finger<B: AsRef<[u8]>>(&self, net_packet: &NetPacket<B>) -> io::Result<()> {
+    #[cfg(cipher)]
+    pub fn check_finger<B: AsRef<[u8]>>(&self, net_packet: &NetPacket<B>) -> anyhow::Result<()> {
        match self {
            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
            Cipher::AesGcm((aes_gcm, _)) => aes_gcm
@@ -314,6 +280,18 @@ impl Cipher {
                .as_ref()
                .map(|f| f.check_finger(net_packet))
                .unwrap_or(Ok(())),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20Poly1305(chacha20poly1305) => chacha20poly1305
+                .finger
+                .as_ref()
+                .map(|f| f.check_finger(net_packet))
+                .unwrap_or(Ok(())),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20(chacha20) => chacha20
+                .finger
+                .as_ref()
+                .map(|f| f.check_finger(net_packet))
+                .unwrap_or(Ok(())),
            #[cfg(feature = "aes_cbc")]
            Cipher::AesCbc(aes_cbc) => aes_cbc
                .finger
@@ -332,6 +310,7 @@ impl Cipher {
                .as_ref()
                .map(|f| f.check_finger(net_packet))
                .unwrap_or(Ok(())),
+            Cipher::Xor(_) => Ok(()),
            Cipher::None => Ok(()),
        }
    }
@@ -339,12 +318,17 @@ impl Cipher {
        match self {
            #[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
            Cipher::AesGcm((_, key)) => Some(key),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20Poly1305(chacha20poly1305) => Some(chacha20poly1305.key()),
+            #[cfg(feature = "chacha20_poly1305")]
+            Cipher::Chacha20(chacha20) => Some(chacha20.key()),
            #[cfg(feature = "aes_cbc")]
            Cipher::AesCbc(aes_cbc) => Some(aes_cbc.key()),
            #[cfg(feature = "aes_ecb")]
            Cipher::AesEcb(aes_ecb) => Some(aes_ecb.key()),
            #[cfg(feature = "sm4_cbc")]
            Cipher::Sm4Cbc(sm4_cbc) => Some(sm4_cbc.key()),
+            Cipher::Xor(xor) => Some(xor.key()),
            Cipher::None => None,
        }
    }
@@ -1,4 +1,5 @@
-use std::io;
+use anyhow::anyhow;
+use rand::RngCore;

 use sha2::Digest;

@@ -16,15 +17,15 @@ impl Finger {
        let hash: [u8; 32] = hasher.finalize().into();
        Finger { hash }
    }
-    pub fn check_finger<B: AsRef<[u8]>>(&self, net_packet: &NetPacket<B>) -> io::Result<()> {
+    pub fn check_finger<B: AsRef<[u8]>>(&self, net_packet: &NetPacket<B>) -> anyhow::Result<()> {
        if !net_packet.is_encrypt() {
            //未加密的数据直接丢弃
-            return Err(io::Error::new(io::ErrorKind::Other, "not encrypt"));
+            return Err(anyhow!("not encrypt"));
        }
        let payload_len = net_packet.payload().len();
        if payload_len < 12 {
            log::error!("数据异常,长度小于{}", 12);
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("data err"));
        }
        let mut nonce_raw = [0; 12];
        nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
@@ -36,7 +37,7 @@ impl Finger {
        let payload = net_packet.payload();
        let finger = self.calculate_finger(&nonce_raw, &payload[..payload_len - 12]);
        if &finger[..] != &payload[payload_len - 12..] {
-            return Err(io::Error::new(io::ErrorKind::Other, "finger err"));
+            return Err(anyhow!("finger err"));
        }
        Ok(())
    }
@@ -49,3 +50,27 @@ impl Finger {
        return key[20..].try_into().unwrap();
    }
 }
+impl<B: AsRef<[u8]>> NetPacket<B> {
+    pub fn head_tag(&self) -> [u8; 12] {
+        let mut tag = [0; 12];
+        tag[0..4].copy_from_slice(&self.buffer()[4..8]);
+        tag[4..8].copy_from_slice(&self.buffer()[8..12]);
+        tag[8] = self.protocol().into();
+        tag[9] = self.transport_protocol();
+        tag[10] = self.is_gateway() as u8;
+        tag[11] = self.source_ttl();
+        tag
+    }
+}
+pub fn gen_nonce(tag: &mut [u8], random: &[u8]) {
+    tag[8] = random[0] ^ tag[8];
+    tag[9] = random[1] ^ tag[9];
+    tag[10] = random[2] ^ tag[10];
+    tag[11] = random[3] ^ tag[11];
+}
+pub fn gen_random_nonce(tag: &mut [u8; 12]) -> [u8; 4] {
+    let mut random = [0; 4];
+    rand::thread_rng().fill_bytes(&mut random);
+    gen_nonce(tag, &random);
+    random
+}
@@ -1,40 +1,32 @@
-#[cfg(feature = "aes_cbc")]
-mod aes_cbc;
-#[cfg(feature = "aes_ecb")]
-#[cfg(not(any(feature = "openssl-vendored", feature = "openssl")))]
-mod aes_ecb;
-#[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
-#[cfg(not(feature = "ring-cipher"))]
-mod aes_gcm_cipher;
 mod cipher;
-#[cfg(any(
-    feature = "aes_gcm",
-    feature = "server_encrypt",
-    feature = "aes_cbc",
-    feature = "aes_ecb",
-    feature = "sm4_cbc"
-))]
+#[cfg(cipher)]
 mod finger;
-#[cfg(feature = "aes_ecb")]
-#[cfg(any(feature = "openssl-vendored", feature = "openssl"))]
-mod openssl_aes_ecb;
-#[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
-#[cfg(feature = "ring-cipher")]
-mod ring_aes_gcm_cipher;

-#[cfg(feature = "sm4_cbc")]
-mod sm4_cbc;
 pub use cipher::Cipher;
 pub use cipher::CipherModel;
-#[cfg(any(
-    feature = "aes_gcm",
-    feature = "server_encrypt",
-    feature = "aes_cbc",
-    feature = "aes_ecb",
-    feature = "sm4_cbc"
-))]
+#[cfg(cipher)]
 pub use finger::Finger;
 #[cfg(feature = "server_encrypt")]
 mod rsa_cipher;
 #[cfg(feature = "server_encrypt")]
 pub use rsa_cipher::RsaCipher;
+
+#[cfg(any(feature = "aes_gcm", feature = "server_encrypt"))]
+mod aes_gcm;
+
+#[cfg(feature = "chacha20_poly1305")]
+mod chacha20;
+#[cfg(feature = "chacha20_poly1305")]
+mod chacha20_poly1305;
+
+#[cfg(feature = "aes_ecb")]
+mod aes_ecb;
+
+#[cfg(feature = "aes_cbc")]
+mod aes_cbc;
+
+#[cfg(feature = "sm4_cbc")]
+mod sm4_cbc;
+
+mod xor;
+pub use xor::simple_hash;
@@ -0,0 +1,2 @@
+mod rs_sm4_cbc;
+pub use rs_sm4_cbc::*;
@@ -1,9 +1,9 @@
 use crate::cipher::Finger;
 use crate::protocol::{NetPacket, HEAD_LEN};
+use anyhow::anyhow;
 use libsm::sm4::cipher_mode::CipherMode;
 use libsm::sm4::Sm4CipherMode;
 use rand::RngCore;
-use std::io;

 pub struct Sm4CbcCipher {
    key: [u8; 16],
@@ -41,28 +41,22 @@ impl Sm4CbcCipher {
    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if !net_packet.is_encrypt() {
            //未加密的数据直接丢弃
-            return Err(io::Error::new(io::ErrorKind::Other, "not encrypt"));
+            return Err(anyhow!("not encrypt"));
        }

        if let Some(finger) = &self.finger {
-            let mut nonce_raw = [0; 12];
-            nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-            nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-            nonce_raw[8] = net_packet.protocol().into();
-            nonce_raw[9] = net_packet.transport_protocol();
-            nonce_raw[10] = net_packet.is_gateway() as u8;
-            nonce_raw[11] = net_packet.source_ttl();
+            let nonce_raw = net_packet.head_tag();
            let len = net_packet.payload().len();
            if len < 12 {
-                return Err(io::Error::new(io::ErrorKind::Other, "payload len <12"));
+                return Err(anyhow!("payload len <12"));
            }
            let secret_body = &net_packet.payload()[..len - 12];
            let finger = finger.calculate_finger(&nonce_raw, secret_body);
            if &finger != &net_packet.payload()[len - 12..] {
-                return Err(io::Error::new(io::ErrorKind::Other, "finger err"));
+                return Err(anyhow!("finger err"));
            }
            net_packet.set_data_len(net_packet.data_len() - finger.len())?;
        }
@@ -70,7 +64,7 @@ impl Sm4CbcCipher {
        let len = payload.len();
        if len < 16 || len > 1024 * 4 {
            log::error!("数据异常,长度{}小于16或大于4096", len);
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("data err"));
        }
        let mut out = [0u8; 1024 * 4];
        let data = &payload[..len - 16];
@@ -79,32 +73,29 @@ impl Sm4CbcCipher {
            Ok(len) => {
                let src_net_packet = NetPacket::new(&out[..len])?;
                if src_net_packet.source() != net_packet.source() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.destination() != net_packet.destination() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.protocol() != net_packet.protocol() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.transport_protocol() != net_packet.transport_protocol() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.is_gateway() != net_packet.is_gateway() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                if src_net_packet.source_ttl() != net_packet.source_ttl() {
-                    return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+                    return Err(anyhow!("data err"));
                }
                net_packet.set_data_len(len)?;
                net_packet.set_payload(src_net_packet.payload())?;
                net_packet.set_encrypt_flag(false);
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("sm4_cbc解密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("sm4_cbc解密失败:{}", e)),
        }
    }
    /// net_packet 必须预留足够长度
@@ -112,7 +103,7 @@ impl Sm4CbcCipher {
    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
        &self,
        net_packet: &mut NetPacket<B>,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        let mut out = [0u8; 1024 * 4];
        let mut iv = [0u8; 16];
        rand::thread_rng().fill_bytes(&mut iv);
@@ -121,7 +112,7 @@ impl Sm4CbcCipher {
                "数据异常,长度{}大于1024 * 4 - 32",
                net_packet.buffer().len()
            );
-            return Err(io::Error::new(io::ErrorKind::Other, "data err"));
+            return Err(anyhow!("data err"));
        }
        match self.cipher.encrypt(net_packet.buffer(), &iv, &mut out) {
            Ok(len) => {
@@ -129,13 +120,7 @@ impl Sm4CbcCipher {
                net_packet.payload_mut()[..len].copy_from_slice(&out[..len]);
                net_packet.payload_mut()[len..].copy_from_slice(&iv);
                if let Some(finger) = &self.finger {
-                    let mut nonce_raw = [0; 12];
-                    nonce_raw[0..4].copy_from_slice(&net_packet.source().octets());
-                    nonce_raw[4..8].copy_from_slice(&net_packet.destination().octets());
-                    nonce_raw[8] = net_packet.protocol().into();
-                    nonce_raw[9] = net_packet.transport_protocol();
-                    nonce_raw[10] = net_packet.is_gateway() as u8;
-                    nonce_raw[11] = net_packet.source_ttl();
+                    let nonce_raw = net_packet.head_tag();
                    let finger = finger.calculate_finger(&nonce_raw, net_packet.payload());
                    let src_data_len = net_packet.data_len();
                    //设置实际长度
@@ -146,10 +131,7 @@ impl Sm4CbcCipher {
                net_packet.set_encrypt_flag(true);
                Ok(())
            }
-            Err(e) => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("sm4_cbc加密失败:{}", e),
-            )),
+            Err(e) => Err(anyhow!("sm4_cbc加密失败:{}", e)),
        }
    }
 }
@@ -0,0 +1,2 @@
+mod xor;
+pub use xor::*;
@@ -0,0 +1,84 @@
+use anyhow::anyhow;
+
+use crate::protocol::NetPacket;
+
+pub fn simple_hash(input: &str) -> [u8; 32] {
+    let mut result = [0u8; 32];
+    let bytes = input.as_bytes();
+    for (index, v) in result.iter_mut().enumerate() {
+        *v = bytes[index % bytes.len()];
+    }
+
+    let mut state = 0u8;
+
+    for (i, &byte) in bytes.iter().enumerate() {
+        let combined = byte.wrapping_add(state).rotate_left((i % 8) as u32);
+        result[i % 32] ^= combined;
+        state = state.wrapping_add(byte).rotate_left(3);
+    }
+
+    for i in 0..32 {
+        result[i] = result[i]
+            .rotate_left((result[(i + 1) % 32] % 8) as u32)
+            .wrapping_add(state);
+        state = state.wrapping_add(result[i]).rotate_left(3);
+    }
+
+    result
+}
+
+#[derive(Clone)]
+pub struct XORCipher {
+    key: [u8; 32],
+}
+
+impl XORCipher {
+    pub fn new_256(key: [u8; 32]) -> Self {
+        Self { key }
+    }
+}
+
+impl XORCipher {
+    pub fn key(&self) -> &[u8] {
+        &self.key
+    }
+}
+
+impl XORCipher {
+    pub fn decrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        if !net_packet.is_encrypt() {
+            //未加密的数据直接丢弃
+            return Err(anyhow!("not encrypt"));
+        }
+        let key = &self.key;
+        for (i, byte) in net_packet.payload_mut().iter_mut().enumerate() {
+            *byte ^= key[i & 31];
+        }
+        net_packet.set_encrypt_flag(false);
+        Ok(())
+    }
+    pub fn encrypt_ipv4<B: AsRef<[u8]> + AsMut<[u8]>>(
+        &self,
+        net_packet: &mut NetPacket<B>,
+    ) -> anyhow::Result<()> {
+        net_packet.set_encrypt_flag(true);
+        let key = &self.key;
+        for (i, byte) in net_packet.payload_mut().iter_mut().enumerate() {
+            *byte ^= key[i & 31];
+        }
+        Ok(())
+    }
+}
+
+#[test]
+fn test_xor() {
+    let d = XORCipher::new_256(simple_hash("password"));
+    let mut p = NetPacket::new_encrypt([0; 1000]).unwrap();
+    let src = p.buffer().to_vec();
+    d.encrypt_ipv4(&mut p).unwrap();
+    d.decrypt_ipv4(&mut p).unwrap();
+    assert_eq!(p.buffer(), &src)
+}
@@ -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,220 @@
+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]
+#[cfg(feature = "zstd_compress")]
+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!()
+            }
+        },
+        _ => {
+            unimplemented!()
+        }
+    }
+    assert!(!out_packet.is_extension());
+    assert_eq!(in_packet.payload(), src_out_packet.payload())
+}
+#[test]
+#[cfg(feature = "zstd_compress")]
+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!()
+            }
+        },
+        _ => {
+            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(())
+    }
+}
@@ -6,17 +6,16 @@ use std::time::Duration;
 use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::{Mutex, RwLock};
 use rand::Rng;
-use rsa::signature::digest::Digest;
-#[cfg(not(target_os = "android"))]
-use tun::device::IFace;

 use crate::channel::context::ChannelContext;
 use crate::channel::idle::Idle;
 use crate::channel::punch::{NatInfo, Punch};
+use crate::channel::sender::IpPacketSender;
 use crate::channel::{init_channel, init_context, Route, RouteKey};
 use crate::cipher::Cipher;
 #[cfg(feature = "server_encrypt")]
 use crate::cipher::RsaCipher;
+use crate::compression::Compressor;
 use crate::core::Config;
 use crate::external_route::{AllowExternalRoute, ExternalRoute};
 use crate::handle::handshaker::Handshake;
@@ -24,13 +23,13 @@ use crate::handle::maintain::PunchReceiver;
 use crate::handle::recv_data::RecvDataHandler;
 use crate::handle::{maintain, BaseConfigInfo, ConnectStatus, CurrentDeviceInfo, PeerDeviceInfo};
 use crate::nat::NatTest;
+#[cfg(feature = "integrated_tun")]
 use crate::tun_tap_device::tun_create_helper::{DeviceAdapter, TunDeviceHelper};
+use crate::tun_tap_device::vnt_device::DeviceWrite;
 use crate::util::{
    Scheduler, SingleU64Adder, StopManager, U64Adder, WatchSingleU64Adder, WatchU64Adder,
 };
 use crate::{nat, VntCallback};
-#[cfg(not(target_os = "android"))]
-use crate::{tun_tap_device, DeviceInfo};

 #[derive(Clone)]
 pub struct Vnt {
@@ -39,16 +38,35 @@ pub struct Vnt {
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    nat_test: NatTest,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
-    context: ChannelContext,
+    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]>,
+    compressor: Compressor,
+    client_cipher: Cipher,
+    external_route: ExternalRoute,
 }

 impl Vnt {
+    #[cfg(feature = "integrated_tun")]
    pub fn new<Call: VntCallback>(config: Config, callback: Call) -> anyhow::Result<Self> {
-        log::info!("config:{:?}", config);
+        Vnt::new_device0(config, callback, DeviceAdapter::default())
+    }
+    #[cfg(not(feature = "integrated_tun"))]
+    pub fn new_device<Call: VntCallback, Device: DeviceWrite>(
+        config: Config,
+        callback: Call,
+        device: Device,
+    ) -> anyhow::Result<Self> {
+        Vnt::new_device0(config, callback, device)
+    }
+    fn new_device0<Call: VntCallback, Device: DeviceWrite>(
+        config: Config,
+        callback: Call,
+        device: Device,
+    ) -> anyhow::Result<Self> {
+        log::info!("config.toml:{:?}", config);
        //服务端非对称加密
        #[cfg(feature = "server_encrypt")]
        let rsa_cipher: Arc<Mutex<Option<RsaCipher>>> = Arc::new(Mutex::new(None));
@@ -67,7 +85,7 @@ impl Vnt {
        };
        //客户端对称加密
        let client_cipher =
-            Cipher::new_password(config.cipher_model, config.password.clone(), finger);
+            Cipher::new_password(config.cipher_model, config.password.clone(), finger)?;
        //当前设备信息
        let current_device = Arc::new(AtomicCell::new(CurrentDeviceInfo::new0(
            config.server_address,
@@ -80,18 +98,18 @@ impl Vnt {
            config.name.clone(),
            config.token.clone(),
            config.ip,
-            config.password.as_ref().map(|v| {
-                let mut hasher = sha2::Sha256::new();
-                hasher.update(config.cipher_model.to_string().as_bytes());
-                hasher.update(v.as_bytes());
-                hasher.update(config.token.as_bytes());
-                let key: [u8; 32] = hasher.finalize().into();
-                key[16..].try_into().unwrap()
-            }),
+            config.password_hash(),
            config.server_encrypt,
            config.device_id.clone(),
            config.server_address_str.clone(),
            config.name_servers.clone(),
+            config.mtu.unwrap_or(1420),
+            #[cfg(feature = "integrated_tun")]
+            #[cfg(target_os = "windows")]
+            config.tap,
+            #[cfg(feature = "integrated_tun")]
+            #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+            config.device_name.clone(),
        );
        // 服务停止管理器
        let stop_manager = {
@@ -136,21 +154,13 @@ impl Vnt {
            udp_ports,
            tcp_port,
        );
-
-        // pc上先创建虚拟网卡
-        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
-        let device = {
-            let device = tun_tap_device::create_device(&config)?;
-            let tun_info = DeviceInfo::new(device.name()?, device.version()?);
-            callback.create_tun(tun_info);
-            device
-        };
        // 定时器
        let scheduler = Scheduler::new(stop_manager.clone())?;
        let external_route = ExternalRoute::new(config.in_ips.clone());
        let out_external_route = AllowExternalRoute::new(config.out_ips.clone());

        #[cfg(feature = "ip_proxy")]
+        #[cfg(feature = "integrated_tun")]
        let proxy_map = if !config.out_ips.is_empty() && !config.no_proxy {
            Some(crate::ip_proxy::init_proxy(
                context.clone(),
@@ -167,26 +177,29 @@ 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(rsa_cipher.clone());
+        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(),
-        );
-        #[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);
+        #[cfg(feature = "integrated_tun")]
+        let tun_device_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(),
+                up_counter,
+                device_list.clone(),
+                config.compressor,
+                device.clone().into_device_adapter(),
+            )
+        };

        let handler = RecvDataHandler::new(
            #[cfg(feature = "server_encrypt")]
@@ -194,7 +207,7 @@ impl Vnt {
            server_cipher.clone(),
            client_cipher.clone(),
            current_device.clone(),
-            device_adapter,
+            device,
            device_list.clone(),
            config_info.clone(),
            nat_test.clone(),
@@ -204,9 +217,12 @@ impl Vnt {
            external_route.clone(),
            out_external_route,
            #[cfg(feature = "ip_proxy")]
+            #[cfg(feature = "integrated_tun")]
            proxy_map.clone(),
            down_counter,
            handshake.clone(),
+            #[cfg(feature = "integrated_tun")]
+            tun_device_helper,
        );

        //初始化网络数据通道
@@ -222,8 +238,8 @@ impl Vnt {
            nat_test.clone(),
        );

-        #[cfg(not(target_os = "android"))]
-        tun_helper.start(device)?;
+        // #[cfg(not(target_os = "android"))]
+        // tun_helper.start(device)?;

        maintain::idle_gateway(
            &scheduler,
@@ -252,6 +268,7 @@ impl Vnt {
                    udp_socket_sender,
                );
            }
+            let client_cipher = client_cipher.clone();
            //延迟启动
            scheduler.timeout(Duration::from_secs(3), move |scheduler| {
                start(
@@ -271,18 +288,21 @@ impl Vnt {
                );
            });
        }
-
+        let compressor = config.compressor;
        Ok(Self {
            stop_manager,
            config,
            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,
+            compressor,
+            client_cipher,
+            external_route,
        })
    }
 }
@@ -379,6 +399,9 @@ impl Vnt {
    pub fn current_device(&self) -> CurrentDeviceInfo {
        self.current_device.load()
    }
+    pub fn current_device_info(&self) -> Arc<AtomicCell<CurrentDeviceInfo>> {
+        self.current_device.clone()
+    }
    pub fn peer_nat_info(&self, ip: &Ipv4Addr) -> Option<NatInfo> {
        self.peer_nat_info_map.read().get(ip).cloned()
    }
@@ -395,16 +418,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()
@@ -413,8 +444,16 @@ impl Vnt {
        self.down_count_watcher.get()
    }
    pub fn stop(&self) {
+        //退出协助回收资源
+        let _ = self.context.lock().take();
        self.stop_manager.stop()
    }
+    pub fn add_stop_listener<F>(&self, name: String, f: F) -> anyhow::Result<crate::util::Worker>
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        self.stop_manager.add_listener(name, f)
+    }
    pub fn wait(&self) {
        self.stop_manager.wait()
    }
@@ -424,4 +463,17 @@ impl Vnt {
    pub fn config(&self) -> &Config {
        &self.config
    }
+    pub fn ipv4_packet_sender(&self) -> Option<IpPacketSender> {
+        if let Some(c) = self.context.lock().as_ref() {
+            Some(IpPacketSender::new(
+                c.clone(),
+                self.current_device.clone(),
+                self.compressor.clone(),
+                self.client_cipher.clone(),
+                self.external_route.clone(),
+            ))
+        } else {
+            None
+        }
+    }
 }
@@ -7,12 +7,14 @@ 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(feature = "integrated_tun")]
    #[cfg(target_os = "windows")]
    pub tap: bool,
    pub token: String,
@@ -29,15 +31,16 @@ pub struct Config {
    pub tcp: bool,
    pub ip: Option<Ipv4Addr>,
    #[cfg(feature = "ip_proxy")]
+    #[cfg(feature = "integrated_tun")]
    pub no_proxy: bool,
    pub server_encrypt: bool,
-    pub parallel: usize,
    pub cipher_model: CipherModel,
    pub finger: bool,
    pub punch_model: PunchModel,
    pub ports: Option<Vec<u16>>,
    pub first_latency: bool,
-    #[cfg(not(target_os = "android"))]
+    #[cfg(feature = "integrated_tun")]
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
    pub device_name: Option<String>,
    pub use_channel_type: UseChannelType,
    //控制丢包率
@@ -46,11 +49,14 @@ pub struct Config {
    // 端口映射
    #[cfg(feature = "port_mapping")]
    pub port_mapping_list: Vec<(bool, SocketAddr, String)>,
+    pub compressor: Compressor,
 }

 impl Config {
    pub fn new(
-        #[cfg(target_os = "windows")] tap: bool,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(target_os = "windows")]
+        tap: bool,
        token: String,
        device_id: String,
        name: String,
@@ -63,20 +69,24 @@ impl Config {
        mtu: Option<u32>,
        tcp: bool,
        ip: Option<Ipv4Addr>,
-        #[cfg(feature = "ip_proxy")] no_proxy: bool,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(feature = "ip_proxy")]
+        no_proxy: bool,
        server_encrypt: bool,
-        parallel: usize,
        cipher_model: CipherModel,
        finger: bool,
        punch_model: PunchModel,
        ports: Option<Vec<u16>>,
        first_latency: bool,
-        #[cfg(not(target_os = "android"))] device_name: Option<String>,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(not(target_os = "android"))]
+        device_name: Option<String>,
        use_channel_type: UseChannelType,
        packet_loss_rate: Option<f64>,
        packet_delay: u32,
        // 例如 [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(":") {
@@ -109,6 +119,7 @@ impl Config {
        }
        in_ips.sort_by(|(dest1, _, _), (dest2, _, _)| dest2.cmp(dest1));
        Ok(Self {
+            #[cfg(feature = "integrated_tun")]
            #[cfg(target_os = "windows")]
            tap,
            token,
@@ -125,14 +136,15 @@ impl Config {
            tcp,
            ip,
            #[cfg(feature = "ip_proxy")]
+            #[cfg(feature = "integrated_tun")]
            no_proxy,
            server_encrypt,
-            parallel,
            cipher_model,
            finger,
            punch_model,
            ports,
            first_latency,
+            #[cfg(feature = "integrated_tun")]
            #[cfg(not(target_os = "android"))]
            device_name,
            use_channel_type,
@@ -140,6 +152,33 @@ impl Config {
            packet_delay,
            #[cfg(feature = "port_mapping")]
            port_mapping_list,
+            compressor,
        })
    }
 }
+
+impl Config {
+    pub fn password_hash(&self) -> Option<[u8; 16]> {
+        if let Some(p) = self.password.as_ref() {
+            match self.cipher_model {
+                CipherModel::Xor => {
+                    let key = crate::cipher::simple_hash(&format!("Xor{}{}", p, self.token));
+                    Some(key[16..].try_into().unwrap())
+                }
+                CipherModel::None => None,
+                #[cfg(cipher)]
+                _ => {
+                    use sha2::Digest;
+                    let mut hasher = sha2::Sha256::new();
+                    hasher.update(self.cipher_model.to_string().as_bytes());
+                    hasher.update(p.as_bytes());
+                    hasher.update(self.token.as_bytes());
+                    let key: [u8; 32] = hasher.finalize().into();
+                    Some(key[16..].try_into().unwrap())
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
@@ -189,9 +189,16 @@ impl Into<u8> for ErrorType {
    }
 }

-#[cfg(target_os = "android")]
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct DeviceConfig {
+    #[cfg(feature = "integrated_tun")]
+    #[cfg(target_os = "windows")]
+    pub tap: bool,
+    #[cfg(feature = "integrated_tun")]
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+    pub device_name: Option<String>,
+    //虚拟网卡mtu值
+    pub mtu: u32,
    //本机虚拟IP
    pub virtual_ip: Ipv4Addr,
    //子网掩码
@@ -204,9 +211,15 @@ pub struct DeviceConfig {
    pub external_route: Vec<(Ipv4Addr, Ipv4Addr)>,
 }

-#[cfg(target_os = "android")]
 impl DeviceConfig {
    pub fn new(
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(target_os = "windows")]
+        tap: bool,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+        device_name: Option<String>,
+        mtu: u32,
        virtual_ip: Ipv4Addr,
        virtual_netmask: Ipv4Addr,
        virtual_gateway: Ipv4Addr,
@@ -214,6 +227,13 @@ impl DeviceConfig {
        external_route: Vec<(Ipv4Addr, Ipv4Addr)>,
    ) -> Self {
        Self {
+            #[cfg(feature = "integrated_tun")]
+            #[cfg(target_os = "windows")]
+            tap,
+            #[cfg(feature = "integrated_tun")]
+            #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+            device_name,
+            mtu,
            virtual_ip,
            virtual_netmask,
            virtual_gateway,
@@ -223,7 +243,6 @@ impl DeviceConfig {
    }
 }

-#[cfg(target_os = "android")]
 impl Display for DeviceConfig {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!(
@@ -272,6 +291,7 @@ pub trait VntCallback: Clone + Send + Sync + 'static {

    /// 创建网卡的信息
    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+    #[cfg(feature = "integrated_tun")]
    fn create_tun(&self, _info: DeviceInfo) {}
    /// 连接
    fn connect(&self, _info: ConnectInfo) {}
@@ -283,8 +303,11 @@ pub trait VntCallback: Clone + Send + Sync + 'static {
    fn register(&self, _info: RegisterInfo) -> bool {
        true
    }
+    #[cfg(not(feature = "integrated_tun"))]
+    fn create_device(&self, _info: DeviceConfig) {}
    #[cfg(target_os = "android")]
-    fn generate_tun(&self, _info: DeviceConfig) -> u32 {
+    #[cfg(feature = "integrated_tun")]
+    fn generate_tun(&self, _info: DeviceConfig) -> usize {
        0
    }
    fn peer_client_list(&self, _info: Vec<PeerClientInfo>) {}
@@ -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,6 +4,7 @@ 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;

@@ -18,22 +19,19 @@ use crate::proto::message::SecretHandshakeRequest;
 use crate::protocol::body::RSA_ENCRYPTION_RESERVED;
 use crate::protocol::{service_packet, NetPacket, Protocol, MAX_TTL};

-pub enum HandshakeEnum {
-    NotSecret,
-    KeyError,
-    Timeout,
-    ServerError(String),
-    Other(String),
-}
 #[derive(Clone)]
 pub struct Handshake {
    time: Arc<AtomicCell<Instant>>,
+    #[cfg(feature = "server_encrypt")]
    rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
 }
 impl Handshake {
-    pub fn new(rsa_cipher: Arc<Mutex<Option<RsaCipher>>>) -> 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,
        }
    }
@@ -54,6 +52,7 @@ impl Handshake {
        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;
        }
@@ -1,4 +1,3 @@
-use std::io;
 use std::net::Ipv4Addr;
 use std::sync::Arc;
 use std::time::Duration;
@@ -167,7 +166,7 @@ fn client_relay0(
    current_device: &CurrentDeviceInfo,
    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
    client_cipher: &Cipher,
-) -> io::Result<()> {
+) -> anyhow::Result<()> {
    // 离线了不再探测
    if current_device.status.offline() {
        return Ok(());
@@ -211,7 +210,7 @@ fn client_relay0(
 fn heartbeat_packet(
    src: Ipv4Addr,
    dest: Ipv4Addr,
-) -> io::Result<NetPacket<[u8; 12 + 4 + ENCRYPTION_RESERVED]>> {
+) -> anyhow::Result<NetPacket<[u8; 12 + 4 + ENCRYPTION_RESERVED]>> {
    let mut net_packet = NetPacket::new_encrypt([0u8; 12 + 4 + ENCRYPTION_RESERVED])?;
    net_packet.set_default_version();
    net_packet.set_protocol(Protocol::Control);
@@ -228,7 +227,7 @@ fn heartbeat_packet_client(
    client_cipher: &Cipher,
    src: Ipv4Addr,
    dest: Ipv4Addr,
-) -> io::Result<NetPacket<[u8; 12 + 4 + ENCRYPTION_RESERVED]>> {
+) -> anyhow::Result<NetPacket<[u8; 12 + 4 + ENCRYPTION_RESERVED]>> {
    let mut net_packet = heartbeat_packet(src, dest)?;
    client_cipher.encrypt_ipv4(&mut net_packet)?;
    Ok(net_packet)
@@ -239,7 +238,7 @@ fn heartbeat_packet_server(
    server_cipher: &Cipher,
    src: Ipv4Addr,
    dest: Ipv4Addr,
-) -> io::Result<NetPacket<[u8; 12 + 4 + ENCRYPTION_RESERVED]>> {
+) -> anyhow::Result<NetPacket<[u8; 12 + 4 + ENCRYPTION_RESERVED]>> {
    let mut net_packet = heartbeat_packet(src, dest)?;
    let mut ping = PingPacket::new(net_packet.payload_mut())?;
    ping.set_epoch(device_list.lock().0);
@@ -2,9 +2,10 @@ use std::collections::HashMap;
 use std::net::Ipv4Addr;
 use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::sync::Arc;
+use std::thread;
 use std::time::Duration;
-use std::{io, thread};

+use anyhow::anyhow;
 use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::Mutex;
 use protobuf::Message;
@@ -222,7 +223,7 @@ fn punch0(
    punch_record: &Mutex<HashMap<Ipv4Addr, usize>>,
    last_punch_record: &mut HashMap<Ipv4Addr, usize>,
    total_count: usize,
-) -> io::Result<()> {
+) -> anyhow::Result<()> {
    let nat_info = nat_test.nat_info();
    if total_count < 10
        && (nat_info.public_ips.is_empty()
@@ -297,7 +298,7 @@ fn punch_packet(
    virtual_ip: Ipv4Addr,
    nat_info: &NatInfo,
    dest: Ipv4Addr,
-) -> io::Result<NetPacket<Vec<u8>>> {
+) -> anyhow::Result<NetPacket<Vec<u8>>> {
    let mut punch_reply = PunchInfo::new();
    punch_reply.reply = false;
    punch_reply.public_ip_list = nat_info
@@ -320,7 +321,7 @@ fn punch_packet(
    log::info!("请求打洞={:?}", punch_reply);
    let bytes = punch_reply
        .write_to_bytes()
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("punch_packet {:?}", e)))?;
+        .map_err(|e| anyhow!("punch_packet {:?}", e))?;
    let mut net_packet = NetPacket::new_encrypt(vec![0u8; 12 + bytes.len() + ENCRYPTION_RESERVED])?;
    net_packet.set_default_version();
    net_packet.set_protocol(Protocol::OtherTurn);
@@ -2,10 +2,12 @@ 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;
 pub mod registrar;
+#[cfg(feature = "integrated_tun")]
 pub mod tun_tap;

 const SELF_IP: Ipv4Addr = Ipv4Addr::new(0, 0, 0, 2);
@@ -20,12 +22,6 @@ pub fn now_time() -> u64 {
    }
 }

-/// 是否在一个网段
-fn check_dest(dest: Ipv4Addr, virtual_netmask: Ipv4Addr, virtual_network: Ipv4Addr) -> bool {
-    u32::from_be_bytes(dest.octets()) & u32::from_be_bytes(virtual_netmask.octets())
-        == u32::from_be_bytes(virtual_network.octets())
-}
-
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PeerDeviceInfo {
    pub virtual_ip: Ipv4Addr,
@@ -63,6 +59,13 @@ pub struct BaseConfigInfo {
    pub device_id: String,
    pub server_addr: String,
    pub name_servers: Vec<String>,
+    pub mtu: u32,
+    #[cfg(feature = "integrated_tun")]
+    #[cfg(target_os = "windows")]
+    pub tap: bool,
+    #[cfg(feature = "integrated_tun")]
+    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+    pub device_name: Option<String>,
 }

 impl BaseConfigInfo {
@@ -75,6 +78,13 @@ impl BaseConfigInfo {
        device_id: String,
        server_addr: String,
        name_servers: Vec<String>,
+        mtu: u32,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(target_os = "windows")]
+        tap: bool,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+        device_name: Option<String>,
    ) -> Self {
        Self {
            name,
@@ -85,6 +95,13 @@ impl BaseConfigInfo {
            device_id,
            server_addr,
            name_servers,
+            mtu,
+            #[cfg(feature = "integrated_tun")]
+            #[cfg(target_os = "windows")]
+            tap,
+            #[cfg(feature = "integrated_tun")]
+            #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+            device_name,
        }
    }
 }
@@ -1,10 +1,11 @@
-use parking_lot::RwLock;
-use protobuf::Message;
+use anyhow::anyhow;
 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;
@@ -14,6 +15,7 @@ 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;
@@ -26,32 +28,33 @@ use crate::protocol::control_packet::ControlPacket;
 use crate::protocol::{
    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;
+use crate::tun_tap_device::vnt_device::DeviceWrite;

 /// 处理来源于客户端的包
 #[derive(Clone)]
-pub struct ClientPacketHandler {
-    device: DeviceAdapter,
+pub struct ClientPacketHandler<Device> {
+    device: Device,
    client_cipher: Cipher,
    punch_sender: PunchSender,
    peer_nat_info_map: Arc<RwLock<HashMap<Ipv4Addr, NatInfo>>>,
    nat_test: NatTest,
    route: AllowExternalRoute,
    #[cfg(feature = "ip_proxy")]
+    #[cfg(feature = "integrated_tun")]
    ip_proxy_map: Option<IpProxyMap>,
 }

-impl ClientPacketHandler {
+impl<Device: DeviceWrite> ClientPacketHandler<Device> {
    pub fn new(
-        device: DeviceAdapter,
+        device: Device,
        client_cipher: Cipher,
        punch_sender: PunchSender,
        peer_nat_info_map: Arc<RwLock<HashMap<Ipv4Addr, NatInfo>>>,
        nat_test: NatTest,
        route: AllowExternalRoute,
-        #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(feature = "ip_proxy")]
+        ip_proxy_map: Option<IpProxyMap>,
    ) -> Self {
        Self {
            device,
@@ -60,24 +63,37 @@ impl ClientPacketHandler {
            peer_nat_info_map,
            nat_test,
            route,
+            #[cfg(feature = "integrated_tun")]
            #[cfg(feature = "ip_proxy")]
            ip_proxy_map,
        }
    }
 }

-impl PacketHandler for ClientPacketHandler {
+impl<Device: DeviceWrite> PacketHandler for ClientPacketHandler<Device> {
    fn handle(
        &self,
        mut net_packet: NetPacket<&mut [u8]>,
+        mut extend: NetPacket<&mut [u8]>,
        route_key: RouteKey,
        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 => {}
@@ -96,14 +112,14 @@ impl PacketHandler for ClientPacketHandler {
    }
 }

-impl ClientPacketHandler {
+impl<Device: DeviceWrite> ClientPacketHandler<Device> {
    fn ip_turn(
        &self,
        mut net_packet: NetPacket<&mut [u8]>,
        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
        route_key: RouteKey,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        let destination = net_packet.destination();
        let source = net_packet.source();
        match ip_turn_packet::Protocol::from(net_packet.transport_protocol()) {
@@ -169,6 +185,7 @@ impl ClientPacketHandler {
                        _ => {}
                    }
                    #[cfg(feature = "ip_proxy")]
+                    #[cfg(feature = "integrated_tun")]
                    if let Some(ip_proxy_map) = &self.ip_proxy_map {
                        if ip_proxy_map.recv_handle(&mut ipv4, source, destination)? {
                            return Ok(());
@@ -190,7 +207,7 @@ impl ClientPacketHandler {
        current_device: &CurrentDeviceInfo,
        mut net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        let metric = net_packet.source_ttl() - net_packet.ttl() + 1;
        let source = net_packet.source();
        match ControlPacket::new(net_packet.transport_protocol(), net_packet.payload())? {
@@ -278,17 +295,15 @@ impl ClientPacketHandler {
        current_device: &CurrentDeviceInfo,
        net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if context.use_channel_type().is_only_relay() {
            return Ok(());
        }
        let source = net_packet.source();
        match other_turn_packet::Protocol::from(net_packet.transport_protocol()) {
            other_turn_packet::Protocol::Punch => {
-                let mut punch_info =
-                    PunchInfo::parse_from_bytes(net_packet.payload()).map_err(|e| {
-                        io::Error::new(io::ErrorKind::Other, format!("PunchInfo {:?}", e))
-                    })?;
+                let mut punch_info = PunchInfo::parse_from_bytes(net_packet.payload())
+                    .map_err(|e| anyhow!("PunchInfo {:?}", e))?;
                let public_ips = punch_info
                    .public_ip_list
                    .iter()
@@ -348,9 +363,9 @@ impl ClientPacketHandler {
                        punch_reply.ipv6 = ipv6.octets().to_vec();
                        punch_reply.ipv6_port = nat_info.udp_ports[0] as u32;
                    }
-                    let bytes = punch_reply.write_to_bytes().map_err(|e| {
-                        io::Error::new(io::ErrorKind::Other, format!("punch_reply {:?}", e))
-                    })?;
+                    let bytes = punch_reply
+                        .write_to_bytes()
+                        .map_err(|e| anyhow!("punch_reply {:?}", e))?;
                    let mut punch_packet =
                        NetPacket::new_encrypt(vec![0u8; 12 + bytes.len() + ENCRYPTION_RESERVED])?;
                    punch_packet.set_default_version();
@@ -1,7 +1,7 @@
 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};
@@ -24,8 +24,8 @@ use crate::handle::{BaseConfigInfo, CurrentDeviceInfo, PeerDeviceInfo, SELF_IP};
 #[cfg(feature = "ip_proxy")]
 use crate::ip_proxy::IpProxyMap;
 use crate::nat::NatTest;
-use crate::protocol::NetPacket;
-use crate::tun_tap_device::tun_create_helper::DeviceAdapter;
+use crate::protocol::{NetPacket, HEAD_LEN};
+use crate::tun_tap_device::vnt_device::DeviceWrite;
 use crate::util::U64Adder;

 mod client;
@@ -33,17 +33,26 @@ mod server;
 mod turn;

 #[derive(Clone)]
-pub struct RecvDataHandler<Call> {
+pub struct RecvDataHandler<Call, Device> {
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
    turn: TurnPacketHandler,
-    client: ClientPacketHandler,
-    server: ServerPacketHandler<Call>,
+    client: ClientPacketHandler<Device>,
+    server: ServerPacketHandler<Call, Device>,
    counter: U64Adder,
    nat_test: NatTest,
 }

-impl<Call: VntCallback> RecvChannelHandler for RecvDataHandler<Call> {
-    fn handle(&mut self, buf: &mut [u8], route_key: RouteKey, context: &ChannelContext) {
+impl<Call: VntCallback, Device: DeviceWrite> RecvChannelHandler for RecvDataHandler<Call, Device> {
+    fn handle(
+        &mut self,
+        buf: &mut [u8],
+        extend: &mut [u8],
+        route_key: RouteKey,
+        context: &ChannelContext,
+    ) {
+        if buf.len() < HEAD_LEN {
+            return;
+        }
        //判断stun响应包
        if !route_key.is_tcp() {
            if let Ok(rs) = self
@@ -55,19 +64,24 @@ impl<Call: VntCallback> RecvChannelHandler for RecvDataHandler<Call> {
                }
            }
        }
-        if let Err(e) = self.handle0(buf, route_key, context) {
-            log::error!("[{}]-{:?}", thread::current().name().unwrap_or(""), e);
+        if let Err(e) = self.handle0(buf, extend, route_key, context) {
+            log::error!(
+                "[{}]-{:?}-{:?}",
+                thread::current().name().unwrap_or(""),
+                route_key.addr,
+                e
+            );
        }
    }
 }

-impl<Call: VntCallback> RecvDataHandler<Call> {
+impl<Call: VntCallback, Device: DeviceWrite> RecvDataHandler<Call, Device> {
    pub fn new(
        #[cfg(feature = "server_encrypt")] rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
        server_cipher: Cipher,
        client_cipher: Cipher,
        current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-        device: DeviceAdapter,
+        device: Device,
        device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
        config_info: BaseConfigInfo,
        nat_test: NatTest,
@@ -76,9 +90,13 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
        peer_nat_info_map: Arc<RwLock<HashMap<Ipv4Addr, NatInfo>>>,
        external_route: ExternalRoute,
        route: AllowExternalRoute,
-        #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
+        #[cfg(feature = "integrated_tun")]
+        #[cfg(feature = "ip_proxy")]
+        ip_proxy_map: Option<IpProxyMap>,
        counter: U64Adder,
        handshake: Handshake,
+        #[cfg(feature = "integrated_tun")]
+        tun_device_helper: crate::tun_tap_device::tun_create_helper::TunDeviceHelper,
    ) -> Self {
        let server = ServerPacketHandler::new(
            #[cfg(feature = "server_encrypt")]
@@ -92,6 +110,8 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
            callback,
            external_route.clone(),
            handshake,
+            #[cfg(feature = "integrated_tun")]
+            tun_device_helper,
        );
        let client = ClientPacketHandler::new(
            device.clone(),
@@ -100,6 +120,7 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
            peer_nat_info_map,
            nat_test.clone(),
            route,
+            #[cfg(feature = "integrated_tun")]
            #[cfg(feature = "ip_proxy")]
            ip_proxy_map,
        );
@@ -116,14 +137,16 @@ impl<Call: VntCallback> RecvDataHandler<Call> {
    fn handle0(
        &mut self,
        buf: &mut [u8],
+        extend: &mut [u8],
        route_key: RouteKey,
        context: &ChannelContext,
-    ) -> io::Result<()> {
+    ) -> 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());
+            log::warn!("丢弃过时包:{:?} {}", net_packet.head(), route_key.addr);
            return Ok(());
        }
        let current_device = self.current_device.load();
@@ -139,16 +162,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)
        }
    }
 }
@@ -157,8 +180,9 @@ pub trait PacketHandler {
    fn handle(
        &self,
        net_packet: NetPacket<&mut [u8]>,
+        extend: NetPacket<&mut [u8]>,
        route_key: RouteKey,
        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
-    ) -> io::Result<()>;
+    ) -> anyhow::Result<()>;
 }
@@ -1,3 +1,4 @@
+use anyhow::anyhow;
 use std::io;
 use std::net::Ipv4Addr;
 use std::sync::Arc;
@@ -32,43 +33,43 @@ 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, MAX_TTL};
-use crate::tun_tap_device::tun_create_helper::DeviceAdapter;
+use crate::tun_tap_device::vnt_device::DeviceWrite;
 use crate::{proto, PeerClientInfo};
-#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
-use tun::device::IFace;

 /// 处理来源于服务端的包
 #[derive(Clone)]
-pub struct ServerPacketHandler<Call> {
+pub struct ServerPacketHandler<Call, Device> {
    #[cfg(feature = "server_encrypt")]
    rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
    server_cipher: Cipher,
    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-    device: DeviceAdapter,
+    device: Device,
    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,
+    #[cfg(feature = "integrated_tun")]
+    tun_device_helper: crate::tun_tap_device::tun_create_helper::TunDeviceHelper,
 }

-impl<Call> ServerPacketHandler<Call> {
+impl<Call, Device> ServerPacketHandler<Call, Device> {
    pub fn new(
        #[cfg(feature = "server_encrypt")] rsa_cipher: Arc<Mutex<Option<RsaCipher>>>,
        server_cipher: Cipher,
        current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-        device: DeviceAdapter,
+        device: Device,
        device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
        config_info: BaseConfigInfo,
        nat_test: NatTest,
        callback: Call,
        external_route: ExternalRoute,
        handshake: Handshake,
+        #[cfg(feature = "integrated_tun")]
+        tun_device_helper: crate::tun_tap_device::tun_create_helper::TunDeviceHelper,
    ) -> Self {
        Self {
            #[cfg(feature = "server_encrypt")]
@@ -82,22 +83,23 @@ 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,
+            #[cfg(feature = "integrated_tun")]
+            tun_device_helper,
        }
    }
 }

-impl<Call: VntCallback> PacketHandler for ServerPacketHandler<Call> {
+impl<Call: VntCallback, Device: DeviceWrite> PacketHandler for ServerPacketHandler<Call, Device> {
    fn handle(
        &self,
        mut net_packet: NetPacket<&mut [u8]>,
+        _extend: NetPacket<&mut [u8]>,
        route_key: RouteKey,
        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        context
            .route_table
            .update_read_time(&net_packet.source(), &route_key);
@@ -135,10 +137,8 @@ impl<Call: VntCallback> PacketHandler for ServerPacketHandler<Call> {
        } else if net_packet.protocol() == Protocol::Service
            && net_packet.transport_protocol() == service_packet::Protocol::HandshakeResponse.into()
        {
-            let response =
-                HandshakeResponse::parse_from_bytes(net_packet.payload()).map_err(|e| {
-                    io::Error::new(io::ErrorKind::Other, format!("HandshakeResponse {:?}", e))
-                })?;
+            let response = HandshakeResponse::parse_from_bytes(net_packet.payload())
+                .map_err(|e| anyhow!("HandshakeResponse {:?}", e))?;
            log::info!("握手响应:{:?},{}", route_key, response);
            //如果开启了加密，则发送加密握手请求
            #[cfg(feature = "server_encrypt")]
@@ -193,6 +193,7 @@ 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);
            }
@@ -245,14 +246,14 @@ impl<Call: VntCallback> PacketHandler for ServerPacketHandler<Call> {
    }
 }

-impl<Call: VntCallback> ServerPacketHandler<Call> {
+impl<Call: VntCallback, Device: DeviceWrite> ServerPacketHandler<Call, Device> {
    fn service(
        &self,
        context: &ChannelContext,
        current_device: &CurrentDeviceInfo,
        net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        match service_packet::Protocol::from(net_packet.transport_protocol()) {
            service_packet::Protocol::RegistrationResponse => {
                let response = RegistrationResponse::parse_from_bytes(net_packet.payload())
@@ -304,80 +305,85 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                        if old.virtual_ip != Ipv4Addr::UNSPECIFIED {
                            log::info!("ip发生变化,old:{:?},response={:?}", old, response);
                        }
-                        #[cfg(target_os = "android")]
+                        let device_config = crate::handle::callback::DeviceConfig::new(
+                            #[cfg(feature = "integrated_tun")]
+                            #[cfg(target_os = "windows")]
+                            self.config_info.tap,
+                            #[cfg(feature = "integrated_tun")]
+                            #[cfg(any(
+                                target_os = "windows",
+                                target_os = "linux",
+                                target_os = "macos"
+                            ))]
+                            self.config_info.device_name.clone(),
+                            self.config_info.mtu,
+                            virtual_ip,
+                            virtual_netmask,
+                            virtual_gateway,
+                            virtual_network,
+                            self.external_route.to_route(),
+                        );
+                        #[cfg(not(feature = "integrated_tun"))]
+                        self.callback.create_device(device_config);
+                        #[cfg(feature = "integrated_tun")]
                        {
-                            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.tun_device_helper.stop();
+                            #[cfg(any(
+                                target_os = "windows",
+                                target_os = "linux",
+                                target_os = "macos"
+                            ))]
+                            match crate::tun_tap_device::create_device(device_config) {
+                                Ok(device) => {
+                                    use tun::device::IFace;
+                                    let tun_info = crate::handle::callback::DeviceInfo::new(
+                                        device.name().unwrap_or("unknown".into()),
+                                        device.version().unwrap_or("unknown".into()),
+                                    );
+                                    log::info!("tun信息{:?}", tun_info);
+                                    self.callback.create_tun(tun_info);
+                                    self.tun_device_helper.start(device)?;
+                                }
+                                Err(e) => {
+                                    log::error!("{:?}", e);
+                                    self.callback.error(e);
+                                }
+                            }
+                            #[cfg(target_os = "android")]
+                            {
+                                let device_config = crate::handle::callback::DeviceConfig::new(
+                                    self.config_info.mtu,
+                                    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,
-                                        format!("{:?}", e),
+                                        "device_fd == 0".into(),
                                    ));
-                                }
-                            }
-                        }
-                        #[cfg(not(target_os = "android"))]
-                        {
-                            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((
-                                    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));
+                                    match tun::Device::new(device_fd as _) {
+                                        Ok(device) => {
+                                            if let Err(e) =
+                                                self.tun_device_helper.start(Arc::new(device))
+                                            {
+                                                self.callback.error(ErrorInfo::new_msg(
+                                                    ErrorType::Unknown,
+                                                    format!("{:?}", e),
+                                                ));
+                                            }
+                                        }
+                                        Err(e) => {
+                                            self.callback.error(ErrorInfo::new_msg(
+                                                ErrorType::Unknown,
+                                                format!("{:?}", e),
+                                            ));
+                                        }
+                                    }
                                }
                            }
                        }
@@ -438,7 +444,7 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
        &self,
        current_device: &CurrentDeviceInfo,
        context: &ChannelContext,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        if current_device.status.online() {
            log::info!("已连接的不需要注册，{:?}", self.config_info);
            return Ok(());
@@ -467,7 +473,8 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
        )?;
        log::info!("发送注册请求，{:?}", self.config_info);
        //注册请求只发送到默认通道
-        context.send_default(response.buffer(), current_device.connect_server)
+        context.send_default(response.buffer(), current_device.connect_server)?;
+        Ok(())
    }
    fn error(
        &self,
@@ -525,7 +532,7 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
        current_device: &CurrentDeviceInfo,
        net_packet: NetPacket<&mut [u8]>,
        route_key: RouteKey,
-    ) -> io::Result<()> {
+    ) -> anyhow::Result<()> {
        match ControlPacket::new(net_packet.transport_protocol(), net_packet.payload())? {
            ControlPacket::PongPacket(pong_packet) => {
                let current_time = crate::handle::now_time() as u16;
@@ -3,6 +3,7 @@ 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: &ChannelContext,
        _current_device: &CurrentDeviceInfo,
-    ) -> std::io::Result<()> {
+    ) -> anyhow::Result<()> {
        // ttl减一
        let ttl = net_packet.incr_ttl();
        if ttl > 0 {
@@ -33,7 +35,9 @@ impl PacketHandler for TurnPacketHandler {
                    return Ok(());
                }
                if route.metric <= ttl {
-                    return context.send_by_key(net_packet.buffer(), route.route_key());
+                    return context
+                        .send_by_key(net_packet.buffer(), route.route_key())
+                        .context("转发失败");
                }
            }
            //其他没有路由的不转发
@@ -1,4 +1,4 @@
-use std::io;
+use anyhow::anyhow;
 use std::net::Ipv4Addr;

 use protobuf::Message;
@@ -19,7 +19,7 @@ pub fn registration_request_packet(
    is_fast: bool,
    allow_ip_change: bool,
    client_secret_hash: Option<&[u8]>,
-) -> io::Result<NetPacket<Vec<u8>>> {
+) -> anyhow::Result<NetPacket<Vec<u8>>> {
    let mut request = RegistrationRequest::new();
    request.token = token;
    request.device_id = device_id;
@@ -36,9 +36,9 @@ pub fn registration_request_packet(
            .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))
-    })?;
+    let bytes = request
+        .write_to_bytes()
+        .map_err(|e| anyhow!("RegistrationRequest {:?}", e))?;
    let buf = vec![0u8; 12 + bytes.len() + ENCRYPTION_RESERVED];
    let mut net_packet = NetPacket::new_encrypt(buf)?;
    net_packet.set_destination(GATEWAY_IP);
@@ -1,30 +0,0 @@
-use std::sync::mpsc::{sync_channel, Receiver, SendError, SyncSender};
-
-pub fn channel_group<T>(size: usize, bound: usize) -> (GroupSyncSender<T>, Vec<Receiver<T>>) {
-    let mut senders = Vec::with_capacity(size);
-    let mut receivers = Vec::with_capacity(size);
-    for _ in 0..size {
-        let (s, r) = sync_channel(bound);
-        senders.push(s);
-        receivers.push(r);
-    }
-    (
-        GroupSyncSender {
-            count: 0,
-            base: senders,
-        },
-        receivers,
-    )
-}
-
-pub struct GroupSyncSender<T> {
-    count: usize,
-    base: Vec<SyncSender<T>>,
-}
-
-impl<T> GroupSyncSender<T> {
-    pub fn send(&mut self, t: T) -> Result<(), SendError<T>> {
-        self.count += 1;
-        self.base[self.count % self.base.len()].send(t)
-    }
-}
@@ -1,11 +1,45 @@
-mod channel_group;
 pub mod tun_handler;

 #[cfg(unix)]
 mod unix;
+
+use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;
+use std::sync::Arc;
 #[cfg(unix)]
 pub(crate) use unix::*;
+
 #[cfg(target_os = "windows")]
 mod windows;
+
 #[cfg(target_os = "windows")]
 pub(crate) use windows::*;
+
+/// 仅仅是停止tun，不停止vnt
+#[derive(Clone, Default)]
+pub struct DeviceStop {
+    f: Arc<Mutex<Option<Box<dyn FnOnce() -> bool + Send>>>>,
+    stopped: Arc<AtomicCell<bool>>,
+}
+
+impl DeviceStop {
+    pub fn set_stop_fn<F>(&self, f: F)
+    where
+        F: FnOnce() -> bool + Send + 'static,
+    {
+        self.f.lock().replace(Box::new(f));
+    }
+    pub fn stop(&self) -> bool {
+        if let Some(f) = self.f.lock().take() {
+            f()
+        } else {
+            false
+        }
+    }
+    pub fn stopped(&self) {
+        self.stopped.store(true);
+    }
+    pub fn is_stop(&self) -> bool {
+        self.stopped.load()
+    }
+}
@@ -14,19 +14,26 @@ use tun::Device;

 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;
-use crate::handle::{check_dest, CurrentDeviceInfo, PeerDeviceInfo};
+use crate::handle::tun_tap::DeviceStop;
+use crate::handle::{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<()> {
+/// 是否在一个网段
+#[inline]
+fn check_dest(dest: Ipv4Addr, virtual_netmask: Ipv4Addr, virtual_network: Ipv4Addr) -> bool {
+    u32::from_be_bytes(dest.octets()) & u32::from_be_bytes(virtual_netmask.octets())
+        == u32::from_be_bytes(virtual_network.octets())
+}
+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 {
@@ -42,43 +49,6 @@ fn icmp(device_writer: &Device, mut ipv4_packet: IpV4Packet<&mut [u8]>) -> io::R
    Ok(())
 }

-/// 接收tun数据，并且转发到udp上
-pub(crate) fn handle(
-    context: &ChannelContext,
-    data: &mut [u8],
-    len: usize,
-    device_writer: &Device,
-    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>)>,
-) -> io::Result<()> {
-    //忽略掉结构不对的情况（ipv6数据、win tap会读到空数据），不然日志打印太多了
-    let ipv4_packet = match IpV4Packet::new(&mut data[12..len]) {
-        Ok(packet) => packet,
-        Err(_) => return Ok(()),
-    };
-    let src_ip = ipv4_packet.source_ip();
-    let dest_ip = ipv4_packet.destination_ip();
-    if src_ip == dest_ip {
-        return icmp(&device_writer, ipv4_packet);
-    }
-    return base_handle(
-        context,
-        data,
-        len,
-        current_device,
-        ip_route,
-        #[cfg(feature = "ip_proxy")]
-        proxy_map,
-        client_cipher,
-        server_cipher,
-        device_list,
-    );
-}
-
 pub fn start(
    stop_manager: StopManager,
    context: ChannelContext,
@@ -88,84 +58,33 @@ pub fn start(
    #[cfg(feature = "ip_proxy")] ip_proxy_map: Option<IpProxyMap>,
    client_cipher: Cipher,
    server_cipher: Cipher,
-    parallel: usize,
    mut up_counter: SingleU64Adder,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
+    compressor: Compressor,
+    device_stop: DeviceStop,
 ) -> io::Result<()> {
-    if parallel > 1 {
-        let (sender, receivers) = channel_group::<(Vec<u8>, usize)>(parallel, 16);
-        for (index, receiver) in receivers.into_iter().enumerate() {
-            let context = context.clone();
-            let device = device.clone();
-            let current_device = current_device.clone();
-            let ip_route = ip_route.clone();
-            #[cfg(feature = "ip_proxy")]
-            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 || {
-                    while let Ok((mut buf, len)) = receiver.recv() {
-                        #[cfg(not(target_os = "macos"))]
-                        let start = 0;
-                        #[cfg(target_os = "macos")]
-                        let start = 4;
-                        match handle(
-                            &context,
-                            &mut buf[start..],
-                            len,
-                            &device,
-                            current_device.load(),
-                            &ip_route,
-                            #[cfg(feature = "ip_proxy")]
-                            &ip_proxy_map,
-                            &client_cipher,
-                            &server_cipher,
-                            &device_list,
-                        ) {
-                            Ok(_) => {}
-                            Err(e) => {
-                                log::warn!("{:?}", e)
-                            }
-                        }
-                    }
-                })?;
-        }
-        thread::Builder::new()
-            .name("tunHandlerM".into())
-            .spawn(move || {
-                if let Err(e) = crate::handle::tun_tap::start_multi(
-                    stop_manager,
-                    device,
-                    sender,
-                    &mut up_counter,
-                ) {
-                    log::warn!("stop:{}", e);
-                }
-            })?;
-    } else {
-        thread::Builder::new()
-            .name("tunHandlerS".into())
-            .spawn(move || {
-                if let Err(e) = crate::handle::tun_tap::start_simple(
-                    stop_manager,
-                    &context,
-                    device,
-                    current_device,
-                    ip_route,
-                    #[cfg(feature = "ip_proxy")]
-                    ip_proxy_map,
-                    client_cipher,
-                    server_cipher,
-                    &mut up_counter,
-                    device_list,
-                ) {
-                    log::warn!("stop:{}", e);
-                }
-            })?;
-    }
+    thread::Builder::new()
+        .name("tunHandlerS".into())
+        .spawn(move || {
+            if let Err(e) = crate::handle::tun_tap::start_simple(
+                stop_manager,
+                &context,
+                device,
+                current_device,
+                ip_route,
+                #[cfg(feature = "ip_proxy")]
+                ip_proxy_map,
+                client_cipher,
+                server_cipher,
+                &mut up_counter,
+                device_list,
+                compressor,
+                device_stop,
+            ) {
+                log::warn!("stop:{}", e);
+            }
+        })?;
+
    Ok(())
 }

@@ -175,7 +94,7 @@ fn broadcast(
    net_packet: &mut NetPacket<&mut [u8]>,
    current_device: &CurrentDeviceInfo,
    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
-) -> io::Result<()> {
+) -> anyhow::Result<()> {
    let list: Vec<Ipv4Addr> = device_list
        .lock()
        .1
@@ -249,29 +168,43 @@ fn broadcast(
    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)
+    sender.send_default(server_packet.buffer(), current_device.connect_server)?;
+    Ok(())
 }

+/// 接收tun数据，并且转发到udp上
 /// 实现一个原地发送，必须保证是如下结构
 /// |12字节开头|ip报文|至少1024字节结尾|
 ///
-#[inline]
-fn base_handle(
+pub(crate) fn handle(
    context: &ChannelContext,
    buf: &mut [u8],
    data_len: usize, //数据总长度=12+ip包长度
+    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,
    device_list: &Mutex<(u16, Vec<PeerDeviceInfo>)>,
-) -> io::Result<()> {
-    let ipv4_packet = IpV4Packet::new(&buf[12..data_len])?;
+    compressor: &Compressor,
+) -> anyhow::Result<()> {
+    //忽略掉结构不对的情况（ipv6数据、win tap会读到空数据），不然日志打印太多了
+    let ipv4_packet = match IpV4Packet::new(&mut buf[12..data_len]) {
+        Ok(packet) => packet,
+        Err(_) => return Ok(()),
+    };
+    let src_ip = ipv4_packet.source_ip();
+    let dest_ip = ipv4_packet.destination_ip();
+    if src_ip == dest_ip {
+        return icmp(&device_writer, ipv4_packet);
+    }
    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());
@@ -287,11 +220,49 @@ fn base_handle(
        }
        return Ok(());
    }
+    if !dest_ip.is_multicast() && !dest_ip.is_broadcast() && current_device.broadcast_ip != dest_ip
+    {
+        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)?;
+        }
+    }
+
    if dest_ip.is_multicast() {
        //当作广播处理
        dest_ip = Ipv4Addr::BROADCAST;
        net_packet.set_destination(Ipv4Addr::BROADCAST);
    }
+
+    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_broadcast() || current_device.broadcast_ip == dest_ip {
        // 广播 发送到直连目标
        client_cipher.encrypt_ipv4(&mut net_packet)?;
@@ -304,33 +275,13 @@ fn base_handle(
        )?;
        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(())
 }
@@ -1,8 +1,11 @@
 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::tun_tap::DeviceStop;
 use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
+#[cfg(feature = "ip_proxy")]
 use crate::ip_proxy::IpProxyMap;
 use crate::util::{SingleU64Adder, StopManager};
 use crossbeam_utils::atomic::AtomicCell;
@@ -29,13 +32,39 @@ pub(crate) fn start_simple(
    server_cipher: Cipher,
    up_counter: &mut SingleU64Adder,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
-) -> io::Result<()> {
+    compressor: Compressor,
+    device_stop: DeviceStop,
+) -> anyhow::Result<()> {
+    let stop_all = Arc::new(AtomicCell::new(true));
    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();
-    })?;
+    let device_cell = Arc::new(AtomicCell::new(Some(waker)));
+    let worker = {
+        let device_cell = device_cell.clone();
+        stop_manager.add_listener("tun_device".into(), move || {
+            if let Some(waker) = device_cell.take() {
+                if let Err(e) = waker.wake() {
+                    log::warn!("{:?}", e);
+                }
+            }
+        })?
+    };
+    {
+        let stop_all = stop_all.clone();
+        device_stop.set_stop_fn(move || {
+            if let Some(waker) = device_cell.take() {
+                stop_all.store(false);
+                if let Err(e) = waker.wake() {
+                    log::warn!("{:?}", e);
+                    return false;
+                }
+                true
+            } else {
+                false
+            }
+        });
+    }
    if let Err(e) = start_simple0(
        poll,
        context,
@@ -48,10 +77,14 @@ pub(crate) fn start_simple(
        server_cipher,
        up_counter,
        device_list,
+        compressor,
    ) {
        log::error!("{:?}", e);
    };
-    worker.stop_all();
+    device_stop.stopped();
+    if stop_all.load() {
+        worker.stop_all();
+    }
    drop(_waker);
    Ok(())
 }
@@ -67,19 +100,24 @@ fn start_simple0(
    server_cipher: Cipher,
    up_counter: &mut SingleU64Adder,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
-) -> io::Result<()> {
-    let mut buf = [0; 1024 * 16];
+    compressor: Compressor,
+) -> anyhow::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);
+    let mut events = 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 let Err(e) = poll.poll(&mut events, None) {
+            crate::ignore_io_interrupted(e)?;
+            continue;
+        }
+        for event in events.iter() {
            if event.token() == STOP {
                return Ok(());
            }
@@ -101,6 +139,7 @@ fn start_simple0(
                    context,
                    &mut buf,
                    len,
+                    &mut extend,
                    &device,
                    current_device.load(),
                    &ip_route,
@@ -109,6 +148,7 @@ fn start_simple0(
                    &client_cipher,
                    &server_cipher,
                    &device_list,
+                    &compressor,
                ) {
                    Ok(_) => {}
                    Err(e) => {
@@ -119,65 +159,3 @@ fn start_simple0(
        }
    }
 }
-
-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];
-            }
-        }
-    }
-}
@@ -1,13 +1,15 @@
 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::tun_tap::DeviceStop;
 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;
@@ -23,15 +25,36 @@ pub(crate) fn start_simple(
    server_cipher: Cipher,
    up_counter: &mut SingleU64Adder,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
-) -> io::Result<()> {
+    compressor: Compressor,
+    device_stop: DeviceStop,
+) -> anyhow::Result<()> {
+    let device_cell = Arc::new(AtomicCell::new(Some(device.clone())));
+    let stop_all = Arc::new(AtomicCell::new(true));
    let worker = {
-        let device = device.clone();
+        let device_cell = device_cell.clone();
        stop_manager.add_listener("tun_device".into(), move || {
-            if let Err(e) = device.shutdown() {
-                log::warn!("{:?}", e);
+            if let Some(device) = device_cell.take() {
+                if let Err(e) = device.shutdown() {
+                    log::warn!("{:?}", e);
+                }
            }
        })?
    };
+    {
+        let stop_all = stop_all.clone();
+        device_stop.set_stop_fn(move || {
+            if let Some(device) = device_cell.take() {
+                stop_all.store(false);
+                if let Err(e) = device.shutdown() {
+                    log::warn!("{:?}", e);
+                    return false;
+                }
+                true
+            } else {
+                false
+            }
+        });
+    }
    if let Err(e) = start_simple0(
        context,
        device,
@@ -43,12 +66,17 @@ pub(crate) fn start_simple(
        server_cipher,
        up_counter,
        device_list,
+        compressor,
    ) {
        log::error!("{:?}", e);
    }
-    worker.stop_all();
+    device_stop.stopped();
+    if stop_all.load() {
+        worker.stop_all();
+    }
    Ok(())
 }
+
 fn start_simple0(
    context: &ChannelContext,
    device: Arc<Device>,
@@ -59,8 +87,10 @@ fn start_simple0(
    server_cipher: Cipher,
    up_counter: &mut SingleU64Adder,
    device_list: Arc<Mutex<(u16, Vec<PeerDeviceInfo>)>>,
-) -> io::Result<()> {
-    let mut buf = [0; 1024 * 16];
+    compressor: Compressor,
+) -> anyhow::Result<()> {
+    let mut buf = [0; BUFFER_SIZE];
+    let mut extend = [0; BUFFER_SIZE];
    loop {
        let len = device.read(&mut buf[12..])? + 12;
        //单线程的
@@ -71,6 +101,7 @@ fn start_simple0(
            context,
            &mut buf,
            len,
+            &mut extend,
            &device,
            current_device.load(),
            &ip_route,
@@ -79,6 +110,7 @@ fn start_simple0(
            &client_cipher,
            &server_cipher,
            &device_list,
+            &compressor,
        ) {
            Ok(_) => {}
            Err(e) => {
@@ -87,38 +119,3 @@ fn start_simple0(
        }
    }
 }
-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(());
-        }
-    }
-}
@@ -87,38 +87,36 @@ async fn icmp_proxy(
    client_cipher: Cipher,
 ) -> io::Result<()> {
    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 {
-        #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
-        let start = 12;
-        #[cfg(target_os = "android")]
-        let start = 12 + 20;
-        loop {
-            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 (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(
-                    &mut buf,
-                    start + len,
-                    peer_ip,
-                    &nat_map,
-                    &context,
-                    &current_device,
-                    &client_cipher,
-                );
+                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(
+                &mut buf,
+                start + len,
+                peer_ip,
+                &nat_map,
+                &context,
+                &current_device,
+                &client_cipher,
+            );
        }
    }
 }
@@ -167,7 +165,7 @@ fn recv_handle(
                    }
                }
                h => {
-                    log::warn!("不支持的icmp代理 {:?},{:?}", peer_ip, h)
+                    log::debug!("不支持的icmp代理 {:?},{:?}", peer_ip, h)
                }
            },
            Err(e) => {
@@ -10,11 +10,13 @@ use packet::ip::ipv4::packet::IpV4Packet;
 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::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,6 +33,7 @@ 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,
@@ -65,15 +68,17 @@ pub fn init_proxy(
 }

 async fn init_proxy0(
-    context: ChannelContext,
-    current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
-    client_cipher: Cipher,
+    _context: ChannelContext,
+    _current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
+    _client_cipher: Cipher,
 ) -> anyhow::Result<IpProxyMap> {
-    let icmp_proxy = IcmpProxy::new(context, current_device, client_cipher).await?;
+    #[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,
@@ -90,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)
            }
@@ -110,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(()),
        }
@@ -3,16 +3,29 @@ pub const VNT_VERSION: &'static str = env!("CARGO_PKG_VERSION");
 pub mod channel;
 pub mod cipher;
 pub mod core;
-pub mod external_route;
+mod external_route;
 pub mod handle;
 #[cfg(feature = "ip_proxy")]
-pub mod ip_proxy;
+mod ip_proxy;
 pub mod nat;
 #[cfg(feature = "port_mapping")]
-pub mod port_mapping;
-pub mod proto;
+mod port_mapping;
+mod proto;
 pub mod protocol;
-pub mod tun_tap_device;
+mod tun_tap_device;
+pub use tun_tap_device::*;
 pub mod util;

 pub use handle::callback::*;
+
+pub mod compression;
+pub use packet;
+
+pub(crate) fn ignore_io_interrupted(e: std::io::Error) -> std::io::Result<()> {
+    if e.kind() == std::io::ErrorKind::Interrupted {
+        log::warn!("ignore_io_interrupted");
+        Ok(())
+    } else {
+        Err(e)
+    }
+}
@@ -224,34 +224,48 @@ impl NatTest {
        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 buf[0] == 0x01 && buf[1] == 0x01 {
+            if let Some(addr) = stun::recv_stun_response(buf) {
+                if let Err(e) = self.recv_data_(index, source_addr, addr) {
+                    log::warn!("{:?}", e);
+                }
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+    fn recv_data_(
+        &self,
+        index: usize,
+        source_addr: SocketAddr,
+        addr: SocketAddr,
+    ) -> anyhow::Result<()> {
+        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(());
                    }
                }
-                if check_fail {
-                    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 {
                let ip = addr.ip();
                if !ip.is_multicast()
                    && !ip.is_broadcast()
@@ -260,10 +274,9 @@ impl NatTest {
                    && !ip.is_private()
                {
                    self.update_addr(index, *addr.ip(), addr.port());
-                    return Ok(true);
                }
            }
        }
-        return Ok(false);
+        Ok(())
    }
 }
@@ -71,11 +71,15 @@ pub fn stun_test_nat0(stun_servers: Vec<String>) -> io::Result<(NatType, Vec<Ipv
            }
        }
    }
-    Ok((
-        nat_type,
-        hash_set.into_iter().collect(),
-        max_port - min_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>> {
@@ -194,9 +198,6 @@ pub fn send_stun_request() -> Vec<u8> {
 }

 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 {
@@ -15,10 +15,10 @@ pub fn convert(vec: Vec<String>) -> anyhow::Result<Vec<(bool, SocketAddr, String
    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 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",
+                    "udp_mapping error {:?},eg: udp:127.0.0.1:80-10.26.0.10:8080",
                    x
                )
            })?;
@@ -26,7 +26,7 @@ pub fn convert(vec: Vec<String>) -> anyhow::Result<Vec<(bool, SocketAddr, String
                .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",
+                    "udp_mapping error {:?},eg: udp:127.0.0.1:80-10.26.0.10:8080",
                    x
                )
            })?;
@@ -34,10 +34,10 @@ pub fn convert(vec: Vec<String>) -> anyhow::Result<Vec<(bool, SocketAddr, String
            continue;
        }
        if let Some(tcp_mapping) = string.strip_prefix("tcp:") {
-            let mut split = tcp_mapping.split("->");
+            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",
+                    "tcp_mapping error {:?},eg: tcp:127.0.0.1:80-10.26.0.10:8080",
                    x
                )
            })?;
@@ -45,7 +45,7 @@ pub fn convert(vec: Vec<String>) -> anyhow::Result<Vec<(bool, SocketAddr, String
                .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",
+                    "tcp_mapping error {:?},eg: tcp:127.0.0.1:80-10.26.0.10:8080",
                    x
                )
            })?;
@@ -53,7 +53,7 @@ pub fn convert(vec: Vec<String>) -> anyhow::Result<Vec<(bool, SocketAddr, String
            continue;
        }
        Err(anyhow::anyhow!(
-            "port_mapping error {:?},eg: tcp:127.0.0.1:80->10.26.0.10:8080",
+            "port_mapping error {:?},eg: tcp:127.0.0.1:80-10.26.0.10:8080",
            x
        ))?;
    }
@@ -6,7 +6,11 @@ pub async fn tcp_mapping(bind_addr: SocketAddr, destination: String) -> anyhow::
    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));
+    tokio::spawn(async move {
+        if let Err(e) = tcp_mapping_(bind_addr, tcp_listener, destination).await {
+            log::warn!("tcp_mapping {:?}", e);
+        }
+    });
    Ok(())
 }

@@ -4,6 +4,261 @@ pub const ENCRYPTION_RESERVED: usize = 16 + 32 + 12;
 pub const AES_GCM_ENCRYPTION_RESERVED: usize = 32;
 pub const RSA_ENCRYPTION_RESERVED: usize = 32;

+pub const RANDOM_RESERVED: usize = 4;
+pub const FINGER_RESERVED: usize = 12;
+pub const TAG_RESERVED: usize = 16;
+
+/*
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                         random(32)                                          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                         finger(32)                                          |
+|                                         finger(32)                                          |
+|                                         finger(32)                                          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+*/
+pub trait SecretTail {
+    fn buffer(&self) -> &[u8];
+    fn exist_finger(&self) -> bool;
+    fn random_buf(&self) -> &[u8] {
+        let buf = self.buffer();
+        let mut end = buf.len();
+        if self.exist_finger() {
+            end -= FINGER_RESERVED;
+        }
+        &buf[end - RANDOM_RESERVED..end]
+    }
+    fn finger(&self) -> &[u8] {
+        if self.exist_finger() {
+            let buf = self.buffer();
+            let end = buf.len();
+            &buf[end - FINGER_RESERVED..end]
+        } else {
+            &[]
+        }
+    }
+}
+
+pub trait SecretTailMut: SecretTail {
+    fn buffer_mut(&mut self) -> &mut [u8];
+    fn set_random(&mut self, random: &[u8]) {
+        let f = self.exist_finger();
+        let buf = self.buffer_mut();
+        let mut end = buf.len();
+        if f {
+            end -= FINGER_RESERVED;
+        }
+        buf[end - RANDOM_RESERVED..end].copy_from_slice(random);
+    }
+    fn set_finger(&mut self, finger: &[u8]) -> io::Result<()> {
+        if self.exist_finger() {
+            if finger.len() != FINGER_RESERVED {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "finger.len != 12",
+                ));
+            }
+            let buf = self.buffer_mut();
+            let end = buf.len();
+            buf[end - FINGER_RESERVED..end].copy_from_slice(finger);
+            Ok(())
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "not exist finger",
+            ))
+        }
+    }
+}
+
+/* aead加密数据体
+  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
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                          数据体                                              |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                          tag(32)                                            |
+ |                                          tag(32)                                            |
+ |                                          tag(32)                                            |
+ |                                          tag(32)                                            |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                         random(32)                                          |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                         finger(32)                                          |
+ |                                         finger(32)                                          |
+ |                                         finger(32)                                          |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ 注：finger用于快速校验数据是否被修改，上层可使用token、协议头参与计算finger，
+    确保服务端和客户端都能感知修改(服务端不能解密也能校验指纹)
+*/
+pub struct AEADSecretBody<B> {
+    buffer: B,
+    exist_finger: bool,
+}
+
+impl<B: AsRef<[u8]>> AEADSecretBody<B> {
+    pub fn new(buffer: B, exist_finger: bool) -> io::Result<AEADSecretBody<B>> {
+        let len = buffer.as_ref().len();
+        let min_len = if exist_finger {
+            TAG_RESERVED + RANDOM_RESERVED + FINGER_RESERVED
+        } else {
+            TAG_RESERVED + RANDOM_RESERVED
+        };
+        // 不能大于udp最大载荷长度
+        if len < min_len || len > 65535 - 20 - 8 - 12 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!("AEADSecretBody length overflow {}", len),
+            ));
+        }
+        Ok(AEADSecretBody {
+            buffer,
+            exist_finger,
+        })
+    }
+    pub fn data(&self) -> &[u8] {
+        let mut end = self.buffer.as_ref().len() - TAG_RESERVED - RANDOM_RESERVED;
+        if self.exist_finger {
+            end -= FINGER_RESERVED;
+        }
+        &self.buffer.as_ref()[..end]
+    }
+    pub fn tag(&self) -> &[u8] {
+        let mut end = self.buffer.as_ref().len() - RANDOM_RESERVED;
+        if self.exist_finger {
+            end -= FINGER_RESERVED;
+        }
+        &self.buffer.as_ref()[end - TAG_RESERVED..end]
+    }
+}
+
+impl<B: AsRef<[u8]>> SecretTail for AEADSecretBody<B> {
+    #[inline]
+    fn buffer(&self) -> &[u8] {
+        self.buffer.as_ref()
+    }
+    #[inline]
+    fn exist_finger(&self) -> bool {
+        self.exist_finger
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> SecretTailMut for AEADSecretBody<B> {
+    #[inline]
+    fn buffer_mut(&mut self) -> &mut [u8] {
+        self.buffer.as_mut()
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> AEADSecretBody<B> {
+    /// 数据部分
+    pub fn data_mut(&mut self) -> &mut [u8] {
+        let mut end = self.buffer.as_ref().len() - RANDOM_RESERVED - TAG_RESERVED;
+        if self.exist_finger {
+            end -= FINGER_RESERVED;
+        }
+        &mut self.buffer.as_mut()[..end]
+    }
+    /// 数据和tag部分
+    pub fn data_tag_mut(&mut self) -> &mut [u8] {
+        let mut end = self.buffer.as_ref().len() - RANDOM_RESERVED;
+        if self.exist_finger {
+            end -= FINGER_RESERVED;
+        }
+        &mut self.buffer.as_mut()[..end]
+    }
+    pub fn set_tag(&mut self, tag: &[u8]) -> io::Result<()> {
+        if tag.len() != 16 {
+            return Err(io::Error::new(io::ErrorKind::InvalidData, "tag.len != 16"));
+        }
+        let mut end = self.buffer.as_ref().len() - RANDOM_RESERVED;
+        if self.exist_finger {
+            end -= FINGER_RESERVED;
+        }
+        self.buffer.as_mut()[end - TAG_RESERVED..end].copy_from_slice(tag);
+        Ok(())
+    }
+}
+
+/* 带随机数的加密数据体
+  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
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                          数据体                                              |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                         random(32)                                          |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |                                         finger(32)                                          |
+ |                                         finger(32)                                          |
+ |                                         finger(32)                                          |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ 注：finger用于快速校验数据是否被修改，上层可使用token、协议头参与计算finger，
+    确保服务端和客户端都能感知修改(服务端不能解密也能校验指纹)
+*/
+pub struct IVSecretBody<B> {
+    buffer: B,
+    exist_finger: bool,
+}
+
+impl<B: AsRef<[u8]>> IVSecretBody<B> {
+    pub fn new(buffer: B, exist_finger: bool) -> io::Result<IVSecretBody<B>> {
+        let len = buffer.as_ref().len();
+        let min_len = if exist_finger {
+            FINGER_RESERVED + RANDOM_RESERVED
+        } else {
+            RANDOM_RESERVED
+        };
+        // 不能大于udp最大载荷长度
+        if len < min_len || len > 65535 - 20 - 8 - 12 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!("IVSecretBody length overflow {}", len),
+            ));
+        }
+        Ok(IVSecretBody {
+            buffer,
+            exist_finger,
+        })
+    }
+    pub fn data(&self) -> &[u8] {
+        let mut end = self.buffer.as_ref().len() - RANDOM_RESERVED;
+        if self.exist_finger {
+            end -= FINGER_RESERVED;
+        }
+        &self.buffer.as_ref()[..end]
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> IVSecretBody<B> {
+    pub fn data_mut(&mut self) -> &mut [u8] {
+        let mut end = self.buffer.as_ref().len() - RANDOM_RESERVED;
+        if self.exist_finger {
+            end -= FINGER_RESERVED;
+        }
+        &mut self.buffer.as_mut()[..end]
+    }
+}
+
+impl<B: AsRef<[u8]>> SecretTail for IVSecretBody<B> {
+    #[inline]
+    fn buffer(&self) -> &[u8] {
+        self.buffer.as_ref()
+    }
+    #[inline]
+    fn exist_finger(&self) -> bool {
+        self.exist_finger
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> SecretTailMut for IVSecretBody<B> {
+    #[inline]
+    fn buffer_mut(&mut self) -> &mut [u8] {
+        self.buffer.as_mut()
+    }
+}
+
 /* aes_gcm加密数据体
  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
@@ -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,
+        }
+    }
+}
@@ -6,7 +6,7 @@ use std::{fmt, io};
   0                                            15                                              31
   0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9  0  1
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-  |e |s |u |u|   版本(4) |      协议(8)          |      上层协议(8)        | 初始ttl(4) | 生存时间(4) |
+  |e |s |x |u|   版本(4) |      协议(8)          |      上层协议(8)        | 初始ttl(4) | 生存时间(4) |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |                                          源ip地址(32)                                         |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -14,13 +14,14 @@ use std::{fmt, io};
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |                                           数据体                                              |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-  注：e为是否加密标志，s为服务端通信包标志，u未使用
+  注：e为是否加密标志，s为服务端通信包标志，x扩展标志，u未使用
 */
 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;
@@ -101,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)
@@ -132,6 +137,7 @@ impl<B: AsRef<[u8]>> NetPacket<B> {
        }
        Ok(NetPacket { data_len, buffer })
    }
+    #[inline]
    pub fn buffer(&self) -> &[u8] {
        &self.buffer.as_ref()[..self.data_len]
    }
@@ -158,6 +164,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)
    }
@@ -190,6 +200,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]
    }
@@ -208,6 +221,13 @@ impl<B: AsRef<[u8]> + AsMut<[u8]>> NetPacket<B> {
            self.buffer.as_mut()[0] = self.buffer.as_ref()[0] & 0xBF
        };
    }
+    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);
@@ -264,6 +284,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();
    }
@@ -1,4 +1,6 @@
+use crate::{DeviceConfig, ErrorInfo, ErrorType};
 use std::io;
+use std::net::Ipv4Addr;
 use std::sync::Arc;
 use tun::device::IFace;
 use tun::Device;
@@ -8,8 +10,47 @@ 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>> {
+pub fn create_device(config: DeviceConfig) -> Result<Arc<Device>, ErrorInfo> {
+    let device = match create_device0(&config) {
+        Ok(device) => device,
+        Err(e) => {
+            return Err(ErrorInfo::new_msg(
+                ErrorType::Unknown,
+                format!("create device {:?}", e),
+            ));
+        }
+    };
+    if let Err(e) = device.set_ip(config.virtual_ip, config.virtual_netmask) {
+        log::error!("LocalIpExists {:?}", e);
+        return Err(ErrorInfo::new_msg(
+            ErrorType::LocalIpExists,
+            format!("set_ip {:?}", e),
+        ));
+    }
+    if let Err(e) = device.add_route(config.virtual_network, config.virtual_netmask, 1) {
+        log::warn!("添加默认路由失败 ={:?}", e);
+    }
+    if let Err(e) = device.add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, 1) {
+        log::warn!("添加广播路由失败 ={:?}", e);
+    }
+
+    if let Err(e) = device.add_route(
+        Ipv4Addr::from([224, 0, 0, 0]),
+        Ipv4Addr::from([240, 0, 0, 0]),
+        1,
+    ) {
+        log::warn!("添加组播路由失败 ={:?}", e);
+    }
+
+    for (dest, mask) in config.external_route {
+        if let Err(e) = device.add_route(dest, mask, 1) {
+            log::warn!("添加路由失败 ={:?}", e);
+        }
+    }
+    Ok(device)
+}
+
+fn create_device0(config: &DeviceConfig) -> io::Result<Arc<Device>> {
    #[cfg(target_os = "windows")]
    let default_name: &str = if config.tap {
        DEFAULT_TAP_NAME
@@ -37,14 +78,7 @@ pub fn create_device(config: &crate::core::Config) -> io::Result<Arc<Device>> {
            .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)?;
+    device.set_mtu(config.mtu)?;
    Ok(device)
 }

@@ -1,6 +1,11 @@
 #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+#[cfg(feature = "integrated_tun")]
 pub use create_device::create_device;

 #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+#[cfg(feature = "integrated_tun")]
 mod create_device;
+#[cfg(feature = "integrated_tun")]
 pub mod tun_create_helper;
+
+pub mod vnt_device;
@@ -4,67 +4,60 @@ use std::sync::Arc;
 use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::Mutex;

+use tun::device::IFace;
 use tun::Device;

 use crate::channel::context::ChannelContext;
 use crate::cipher::Cipher;
+use crate::compression::Compressor;
 use crate::external_route::ExternalRoute;
+use crate::handle::tun_tap::DeviceStop;
 use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
+#[cfg(feature = "ip_proxy")]
 use crate::ip_proxy::IpProxyMap;
+use crate::tun_tap_device::vnt_device::DeviceWrite;
 use crate::util::{SingleU64Adder, StopManager};
-#[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
+
 #[repr(transparent)]
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct DeviceAdapter {
-    tun: Arc<Device>,
+    tun: Arc<Mutex<Option<Arc<Device>>>>,
 }
+
 impl DeviceAdapter {
-    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "macos"))]
-    pub fn new(tun: Arc<Device>) -> Self {
-        Self { tun }
+    pub fn insert(&self, device: Arc<Device>) {
+        let r = self.tun.lock().replace(device);
+        assert!(r.is_none());
    }
-    #[cfg(target_os = "android")]
-    pub fn new(tun_device_helper: TunDeviceHelper) -> Self {
-        Self {
-            tun: Arc::new(AtomicCell::new(-1 as _)),
-            tun_device_helper,
+    /// 要保证先remove 再insert
+    pub fn remove(&self) {
+        drop(self.tun.lock().take());
+    }
+}
+
+impl DeviceWrite for DeviceAdapter {
+    #[inline]
+    fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        if let Some(tun) = self.tun.lock().as_ref() {
+            tun.write(buf)
+        } else {
+            Err(io::Error::new(io::ErrorKind::NotFound, "not tun device"))
        }
    }
-}
-#[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(())
+    fn into_device_adapter(self) -> DeviceAdapter {
+        self
    }
 }

 #[derive(Clone)]
 pub struct TunDeviceHelper {
-    inner: Arc<AtomicCell<Option<TunDeviceHelperInner>>>,
+    inner: Arc<Mutex<TunDeviceHelperInner>>,
+    device_adapter: DeviceAdapter,
+    device_stop: Arc<Mutex<Option<DeviceStop>>>,
 }

+#[derive(Clone)]
 struct TunDeviceHelperInner {
    stop_manager: StopManager,
    context: ChannelContext,
@@ -74,9 +67,9 @@ struct TunDeviceHelperInner {
    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 {
@@ -88,44 +81,65 @@ impl TunDeviceHelper {
        #[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,
+        device_adapter: DeviceAdapter,
    ) -> Self {
+        let inner = TunDeviceHelperInner {
+            stop_manager,
+            context,
+            current_device,
+            ip_route,
+            #[cfg(feature = "ip_proxy")]
+            ip_proxy_map,
+            client_cipher,
+            server_cipher,
+            up_counter,
+            device_list,
+            compressor,
+        };
        Self {
-            inner: Arc::new(AtomicCell::new(Some(TunDeviceHelperInner {
-                stop_manager,
-                context,
-                current_device,
-                ip_route,
-                ip_proxy_map,
-                client_cipher,
-                server_cipher,
-                parallel,
-                up_counter,
-                device_list,
-            }))),
+            inner: Arc::new(Mutex::new(inner)),
+            device_adapter,
+            device_stop: Default::default(),
        }
    }
-    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,
-            )?;
-            Ok(())
-        } else {
-            Err(io::Error::new(io::ErrorKind::Other, "Repeated start"))
+    pub fn stop(&self) {
+        //先停止旧的，再启动新的，改变旧网卡的IP太麻烦
+        if let Some(device_stop) = self.device_stop.lock().take() {
+            self.device_adapter.remove();
+            loop {
+                device_stop.stop();
+                std::thread::sleep(std::time::Duration::from_millis(300));
+                //确保停止了
+                if device_stop.is_stop() {
+                    break;
+                }
+            }
        }
    }
+    /// 要保证先stop 再start
+    pub fn start(&self, device: Arc<Device>) -> io::Result<()> {
+        self.device_adapter.insert(device.clone());
+        let device_stop = DeviceStop::default();
+        let s = self.device_stop.lock().replace(device_stop.clone());
+        assert!(s.is_none());
+        let inner = self.inner.lock().clone();
+        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.up_counter,
+            inner.device_list,
+            inner.compressor,
+            device_stop,
+        )
+    }
 }
@@ -0,0 +1,7 @@
+use std::io;
+
+pub trait DeviceWrite: Clone + Send + Sync + 'static {
+    fn write(&self, buf: &[u8]) -> io::Result<usize>;
+    #[cfg(feature = "integrated_tun")]
+    fn into_device_adapter(self) -> crate::tun_tap_device::tun_create_helper::DeviceAdapter;
+}
@@ -8,6 +8,7 @@ pub struct U64Adder {
    inner: Arc<U64AdderInner>,
    index: usize,
 }
+#[derive(Clone)]
 pub struct SingleU64Adder {
    inner: Arc<SingleU64AdderInner>,
 }
@@ -41,9 +41,10 @@ pub fn address_choose(addrs: Vec<SocketAddr>) -> anyhow::Result<SocketAddr> {
 /// 后续实现选择延迟最低的可用地址，需要服务端配合
 /// 现在是选择第一个地址，优先ipv6
 fn address_choose0(addrs: Vec<SocketAddr>) -> anyhow::Result<SocketAddr> {
-    let v4: Vec<SocketAddr> = addrs.iter().filter(|v| v.is_ipv4()).map(|v| *v).collect();
-    let v6: Vec<SocketAddr> = addrs.iter().filter(|v| v.is_ipv6()).map(|v| *v).collect();
+    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")?
@@ -51,12 +52,14 @@ fn address_choose0(addrs: Vec<SocketAddr>) -> anyhow::Result<SocketAddr> {
                UdpSocket::bind("0.0.0.0:0")?
            };
            for addr in addrs {
-                if udp.connect(addr).is_ok() {
+                if let Err(e) = udp.connect(addr) {
+                    err.push((*addr, e));
+                } else {
                    return Ok(*addr);
                }
            }
        }
-        Err(anyhow::anyhow!("Unable to connect to address {:?}", addrs))
+        Err(anyhow::anyhow!("Unable to connect to address {:?}", err))
    };
    if v6.is_empty() {
        return check_addr(&v4);
@@ -78,9 +81,7 @@ pub fn dns_query_all(
    mut name_servers: Vec<String>,
 ) -> anyhow::Result<Vec<SocketAddr>> {
    match SocketAddr::from_str(domain) {
-        Ok(addr) => {
-            return Ok(vec![addr]);
-        }
+        Ok(addr) => Ok(vec![addr]),
        Err(_) => {
            let txt_domain = domain
                .to_lowercase()
@@ -94,7 +95,6 @@ pub fn dns_query_all(
                    return Ok(domain
                        .to_socket_addrs()
                        .with_context(|| format!("DNS query failed {:?}", domain))?
-                        .into_iter()
                        .collect());
                }
            }
@@ -119,7 +119,7 @@ pub fn dns_query_all(
                    continue;
                }
                let end_index = domain
-                    .rfind(":")
+                    .rfind(':')
                    .with_context(|| format!("{:?} not port", domain))?;
                let host = &domain[..end_index];
                let port = u16::from_str(&domain[end_index + 1..])
@@ -219,7 +219,7 @@ fn query<'a>(
            domain
        ));
    }
-    if pkt.answers.len() == 0 {
+    if pkt.answers.is_empty() {
        return Err(anyhow::anyhow!(
            "No records received DNS {:?} domain {:?}",
            name_server,
@@ -240,8 +240,8 @@ pub fn txt_dns(domain: &str, name_server: String) -> anyhow::Result<Vec<SocketAd
        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.to_string())
-                    .context("record type txt is not SocketAddr")?;
+                let addr =
+                    SocketAddr::from_str(txt).context("record type txt is not SocketAddr")?;
                rs.push(addr);
            }
        }
@@ -1,6 +1,6 @@
 mod notify;
 mod scheduler;
-pub use notify::StopManager;
+pub use notify::{StopManager, Worker};
 pub use scheduler::Scheduler;

 mod counter;
@@ -1,9 +1,10 @@
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::thread;
 use std::thread::Thread;
 use std::time::Duration;
-use std::{io, thread};

+use anyhow::anyhow;
 use parking_lot::Mutex;

 #[derive(Clone)]
@@ -20,7 +21,7 @@ impl StopManager {
            inner: Arc::new(StopManagerInner::new(f)),
        }
    }
-    pub fn add_listener<F>(&self, name: String, f: F) -> io::Result<Worker>
+    pub fn add_listener<F>(&self, name: String, f: F) -> anyhow::Result<Worker>
    where
        F: FnOnce() + Send + 'static,
    {
@@ -61,23 +62,20 @@ impl StopManagerInner {
            stop_call: Mutex::new(Some(Box::new(f))),
        }
    }
-    fn add_listener<F>(self: &Arc<Self>, name: String, f: F) -> io::Result<Worker>
+    fn add_listener<F>(self: &Arc<Self>, name: String, f: F) -> anyhow::Result<Worker>
    where
        F: FnOnce() + Send + 'static,
    {
        if name.is_empty() {
-            return Err(io::Error::new(io::ErrorKind::Other, "name cannot be empty"));
+            return Err(anyhow!("name cannot be empty"));
        }
        let mut guard = self.listeners.lock();
        if guard.0 {
-            return Err(io::Error::new(io::ErrorKind::Other, "stopped"));
+            return Err(anyhow!("stopped"));
        }
        for (n, _) in &guard.1 {
            if &name == n {
-                return Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("stop add_listener {:?} name already exists", name),
-                ));
+                return Err(anyhow!("stop add_listener {:?} name already exists", name));
            }
        }
        guard.1.push((name.clone(), Box::new(f)));
@@ -2,7 +2,6 @@ use crate::util::StopManager;
 use std::collections::BinaryHeap;
 use std::{
    cmp::Ordering,
-    io,
    sync::mpsc::{sync_channel, Receiver, SyncSender},
    time::{Duration, Instant},
 };
@@ -36,7 +35,7 @@ pub struct Scheduler {
    sender: SyncSender<Op>,
 }
 impl Scheduler {
-    pub fn new(stop_manager: StopManager) -> io::Result<Self> {
+    pub fn new(stop_manager: StopManager) -> anyhow::Result<Self> {
        let (sender, receiver) = sync_channel::<Op>(32);
        let s = Self { sender };
        let s_inner = s.clone();
@@ -5,8 +5,8 @@ use std::os::fd::AsRawFd;
 use std::{io, mem, ptr};

 use libc::{
-    c_char, c_short, ifreq, AF_INET, IFF_MULTI_QUEUE, IFF_NO_PI, IFF_RUNNING, IFF_TUN,
-    IFF_UP, IFNAMSIZ, O_RDWR, SOCK_DGRAM,
+    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;
@@ -62,9 +62,7 @@ impl IntoRawFd for Fd {
 impl Drop for Fd {
    fn drop(&mut self) {
        unsafe {
-            if self.0 >= 0 {
-                libc::close(self.0);
-            }
+            libc::close(self.0);
        }
    }
 }
@@ -101,7 +101,7 @@ impl Device {
                ));
            }
            // 开启session
-            let session = win_tun.WintunStartSession(adapter, MAX_RING_CAPACITY);
+            let session = win_tun.WintunStartSession(adapter, 128 * 1024);
            if session.is_null() {
                log::error!("session.is_null {:?}", io::Error::last_os_error());
                return Err(io::Error::new(
Author	SHA1	Message	Date
lbl8603	073fa6ac6b	修改tun占用内存的大小	2024-06-15 22:18:51 +08:00
lbl8603	51315efb52	修改依赖	2024-06-15 21:16:04 +08:00
lbl8603	30cbf39e7f	排除生成的文件	2024-06-15 21:15:52 +08:00
lbl8603	2973d88df3	修改描述	2024-06-15 21:03:41 +08:00
lbl8603	8b2d7293fe	增加程序说明	2024-06-15 20:55:14 +08:00
lbl8603	215d9aa362	编译vn-link-cli	2024-06-15 20:55:05 +08:00
lbl8603	c3f27e8727	调整依赖	2024-06-15 20:54:49 +08:00
lbl8603	755339189d	去除重复代码	2024-06-15 20:54:35 +08:00
lbl8603	71cf0aa66d	初始化无tun的命令行程序	2024-06-15 20:54:18 +08:00
lbl8603	d695efd787	抽离公共逻辑	2024-06-15 20:53:32 +08:00
lbl8603	66129c2a24	支持无tun模式	2024-06-15 20:52:35 +08:00
lbl8603	0bc7115102	支持外置网卡	2024-06-15 20:51:00 +08:00
lbl8603	dca33a3ec1	fmt	2024-06-15 20:50:35 +08:00
lbl8603	9acbae2554	调整模块	2024-06-15 20:49:53 +08:00
lbl8603	ccfff7b1f6	调整参数格式	2024-06-15 20:49:34 +08:00
lbl8603	39ae4c5dd6	inline	2024-06-15 20:48:20 +08:00
lbl8603	350357076d	抽离发送IP包的逻辑	2024-06-15 20:47:37 +08:00
lbl8603	1e5e15f1f5	不再需要jni	2024-06-15 20:44:20 +08:00
lbl8603	1a385a777e	修改feature名称	2024-06-09 00:16:48 +08:00
lbl8603	16278dae62	优化代码结构	2024-06-09 00:11:33 +08:00
lbl8603	8294e46003	去除多余参数	2024-06-09 00:03:47 +08:00
lbl8603	dedc66875b	支持排除tun	2024-06-09 00:03:28 +08:00
lbl8603	3045e239ff	Merge branch 'refs/heads/1.2.x' into 2024-05-31	2024-06-07 22:42:29 +08:00
lbl8603	5363558118	忽略io interrupted	2024-06-06 21:42:14 +08:00
lbl8603	13ba7cf0b8	优化提示	2024-06-06 21:41:56 +08:00
lbl8603	a5a43e762d	修改命令处理	2024-06-06 21:39:46 +08:00
lbl8603	cb6101a835	修改tap模式说明	2024-06-05 23:11:56 +08:00
lbl8603	255f84c969	提示创建tun失败的信息	2024-06-05 22:58:56 +08:00
lbl8603	7617d6c409	修改加密描述	2024-06-05 22:39:02 +08:00
lbl8603	f75691b483	过滤非vnt包	2024-06-05 22:38:51 +08:00
lbl8603	c5dbb79ed2	完善代码说明	2024-06-04 23:41:56 +08:00
lbl8603	60ba3c64b2	调整加密逻辑	2024-06-04 23:12:51 +08:00
lbl8603	080e58eeb7	调整代码	2024-06-04 23:00:27 +08:00
lbl8603	5d228b9c27	使用fnv	2024-06-04 22:58:35 +08:00
lbl8603	ba87a2780d	Update README.md	2024-06-01 16:59:54 +08:00
lbl8603	fccc3478c8	增加GUI程序	2024-06-01 16:38:17 +08:00
lbl8603	a76280c53b	调整代码结构	2024-05-29 22:47:48 +08:00
lbl8603	90ff03e27c	计算密码hash	2024-05-28 23:21:43 +08:00
lbl8603	5eed05989f	增加ChaCah20和signal-hook	2024-05-28 22:49:06 +08:00
lbl8603	ac939746bd	增加ChaCah20	2024-05-28 22:48:46 +08:00
lbl8603	b7532e89c2	简化条件编译	2024-05-28 22:48:09 +08:00
lbl8603	74f44d6961	增加ChaCah20	2024-05-28 22:47:50 +08:00
lbl8603	86fc27c233	使用anyhow调整错误处理	2024-05-28 22:45:15 +08:00
lbl8603	4b6bb0e5f7	调整加密	2024-05-28 22:42:58 +08:00
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