Refactor & clean code

.cargo/config.toml

@@ -0,0 +1,11 @@
+[registries.crates-io]
+protocol = "sparse"
+
+[build]
+# target = ["x86_64-unknown-linux-musl"]
+# target = ["x86_64-unknown-linux-gnu"]
+# target = ["aarch64-linux-android"]
+# target = ["aarch64-apple-ios"]
+# target = ["x86_64-pc-windows-msvc"]
+# target = ["x86_64-apple-darwin"]
+# target = ["x86_64-unknown-freebsd"]

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/rust.yml

@@ -1,29 +1,94 @@
 name: Push or PR
 
 on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
+  [push, pull_request]
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
   build_n_test:
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
 
     runs-on: ${{ matrix.os }}
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: rustfmt
+      if: ${{ !cancelled() }}
       run: cargo fmt --all -- --check
     - name: check
+      if: ${{ !cancelled() }}
       run: cargo check --verbose
     - name: clippy
+      if: ${{ !cancelled() }}
       run: cargo clippy --all-targets --all-features -- -D warnings
     - name: Build
-      run: cargo build --verbose --examples --tests --all-features --features="async tokio/rt-multi-thread"
+      if: ${{ !cancelled() }}
+      run: |
+        cargo build --verbose --examples --tests --all-features --features="async tokio/rt-multi-thread"
+        cargo clean
+        cargo build --verbose --examples --tests --no-default-features
+    - name: Abort on error
+      if: ${{ failure() }}
+      run: echo "Some of jobs failed" && false
+
+  build_n_test_android:
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install cargo ndk and rust compiler for android target
+      if: ${{ !cancelled() }}
+      run: |
+        cargo install --locked cargo-ndk
+        rustup target add x86_64-linux-android
+    - name: clippy
+      if: ${{ !cancelled() }}
+      run: cargo ndk -t x86_64 clippy --all-features --features="async tokio/rt-multi-thread" -- -D warnings
+    - name: Build
+      if: ${{ !cancelled() }}
+      run: |
+        cargo ndk -t x86_64 rustc --verbose --all-features --features="async tokio/rt-multi-thread" --lib --crate-type=cdylib
+    - name: Abort on error
+      if: ${{ failure() }}
+      run: echo "Android build job failed" && false
+
+  build_n_test_ios:
+    strategy:
+      fail-fast: false
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install cargo lipo and rust compiler for ios target
+      if: ${{ !cancelled() }}
+      run: |
+        cargo install --locked cargo-lipo
+        rustup target add x86_64-apple-ios aarch64-apple-ios
+    - name: clippy
+      if: ${{ !cancelled() }}
+      run: cargo clippy --target x86_64-apple-ios --all-features --features="async tokio/rt-multi-thread" -- -D warnings
+    - name: Build
+      if: ${{ !cancelled() }}
+      run: |
+        cargo lipo --verbose --all-features --features="async tokio/rt-multi-thread"
+    - name: Abort on error
+      if: ${{ failure() }}
+      run: echo "iOs build job failed" && false
+
+  semver:
+    name: Check semver
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: obi1kenobi/cargo-semver-checks-action@v2

.gitignore

@@ -1,5 +1,8 @@
 .vscode/
 .VSCodeCounter/
+build/
+tmp/
 target/
 **/*.rs.bk
 Cargo.lock
+wintun.dll

Cargo.toml

@@ -1,46 +1,86 @@
 [package]
-name = "tun"
-version = "0.6.1"
+name = "tun2"
+version = "2.0.9"
 edition = "2021"
-
-authors = ["meh. <[email protected]>"]
+authors = ["meh. <[email protected]>", "@ssrlive"]
 license = "WTFPL"
-
 description = "TUN device creation and handling."
-repository = "https://github.com/meh/rust-tun"
+repository = "https://github.com/ssrlive/rust-tun"
 keywords = ["tun", "network", "tunnel", "bindings"]
+#rust-version = "1.79"
+
+[lib]
+crate-type = ["staticlib", "cdylib", "lib"]
 
 [dependencies]
-byteorder = { version = "1", optional = true }
-bytes = { version = "1", optional = true }
+bytes = { version = "1" }
+cfg-if = "1"
 futures-core = { version = "0.3", optional = true }
-libc = "0.2"
+libc = { version = "0.2", features = ["extra_traits"] }
 log = "0.4"
 thiserror = "1"
-tokio = { version = "1", features = ["net", "macros"], optional = true }
+tokio = { version = "1", features = [
+    "net",
+    "macros",
+    "io-util",
+], optional = true }
 tokio-util = { version = "0.7", features = ["codec"], optional = true }
 
-[target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
-ioctl = { version = "0.8", package = "ioctl-sys" }
+[target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "android", target_os="freebsd"))'.dependencies]
+nix = { version = "0.29", features = ["ioctl"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-wintun = { version = "0.3", features = ["panic_on_unsent_packets"] }
+futures = { version = "0.3", optional = true }
+windows-sys = { version = "0.59", features = [
+    "Win32_Foundation",
+    "Win32_Security",
+    "Win32_Security_WinTrust",
+    "Win32_Security_Cryptography",
+    "Win32_System_Threading",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_System_LibraryLoader",
+] }
+wintun-bindings = { version = "0.7", features = [
+    "panic_on_unsent_packets",
+    "verify_binary_signature",
+    "async",
+] }
+libloading = "0.8"
+
+[target.'cfg(any(target_os = "macos", target_os = "freebsd"))'.dependencies]
+ipnet = "2"
 
 [dev-dependencies]
+ctrlc2 = { version = "3", features = ["tokio", "termination"] }
+env_logger = "0.11"
 futures = "0.3"
 packet = "0.1"
+serde_json = "1"
+tokio = { version = "1", features = ["rt-multi-thread"] }
 
 [features]
-async = ["tokio", "tokio-util", "bytes", "byteorder", "futures-core"]
+default = ["wintun-dns"]
+# default = ["wintun-dns", "async"]
+async = [
+    "tokio",
+    "futures-core",
+    "futures",
+    "tokio-util",
+    "wintun-bindings/async",
+]
+wintun-dns = []
+
+[package.metadata.docs.rs]
+features = ["async"]
 
 [[example]]
 name = "read-async"
-required-features = ["async", "tokio/rt-multi-thread"]
+required-features = ["async"]
 
 [[example]]
 name = "read-async-codec"
-required-features = ["async", "tokio/rt-multi-thread"]
+required-features = ["async"]
 
 [[example]]
 name = "ping-tun"
-required-features = ["async", "tokio/rt-multi-thread"]
+required-features = ["async"]

README.md

@@ -1,27 +1,38 @@
-TUN interfaces [![Crates.io](https://img.shields.io/crates/v/tun.svg)](https://crates.io/crates/tun) ![tun](https://docs.rs/tun/badge.svg) ![WTFPL](http://img.shields.io/badge/license-WTFPL-blue.svg)
+TUN interfaces 
 ==============
+[![Crates.io](https://img.shields.io/crates/v/tun2.svg)](https://crates.io/crates/tun2)
+![tun2](https://docs.rs/tun2/badge.svg)
+![WTFPL](http://img.shields.io/badge/license-WTFPL-blue.svg)
+
 This crate allows the creation and usage of TUN interfaces, the aim is to make this cross-platform.
 
+> Since the original maintainer @meh is no longer interested in continuing to maintain
+> [tun](https://crates.io/crates/tun) at [repo](https://github.com/meh/rust-tun),
+> We (@ssrlive, @xmh0511) created the [tun2](https://github.com/ssrlive/rust-tun) branch repo and
+> continued to actively update. Welcome to any interested contributor.
+> If you want to be a co-contributor and publisher of [tun2](https://crates.io/crates/tun2),
+> please contact me in [issues](https://github.com/ssrlive/rust-tun/issues).
+>
+> For me, a submitted PR has not been reviewed for a long time,
+> cannot be merged to the main branch, and cannot be published.
+> It is like a patient who has not been sutured on the operating table for a long time.
+> This is a bad experience.
+> I believe that many people feel the same.
+
 Usage
 -----
 First, add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-tun = "0.6.1"
-```
-
-Next, add this to your crate root:
-
-```rust
-extern crate tun;
+tun2 = "2"
 ```
 
 If you want to use the TUN interface with mio/tokio, you need to enable the `async` feature:
 
 ```toml
 [dependencies]
-tun = { version = "0.6.1", features = ["async"] }
+tun2 = { version = "2", features = ["async"] }
 ```
 
 Example
@@ -32,55 +43,65 @@ packets from it.
 ```rust
 use std::io::Read;
 
-extern crate tun;
-
-fn main() {
-	let mut config = tun::Configuration::default();
-	config.address((10, 0, 0, 1))
-	       .netmask((255, 255, 255, 0))
-	       .up();
-
-	#[cfg(target_os = "linux")]
-	config.platform(|config| {
-		config.packet_information(true);
-	});
+fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let mut config = tun2::Configuration::default();
+    config
+        .address((10, 0, 0, 9))
+        .netmask((255, 255, 255, 0))
+        .destination((10, 0, 0, 1))
+        .up();
+
+    #[cfg(target_os = "linux")]
+    config.platform_config(|config| {
+        // requiring root privilege to acquire complete functions
+        config.ensure_root_privileges(true);
+    });
 
-	let mut dev = tun::create(&config).unwrap();
-	let mut buf = [0; 4096];
+    let mut dev = tun2::create(&config)?;
+    let mut buf = [0; 4096];
 
-	loop {
-		let amount = dev.read(&mut buf).unwrap();
-		println!("{:?}", &buf[0 .. amount]);
-	}
+    loop {
+        let amount = dev.read(&mut buf)?;
+        println!("{:?}", &buf[0..amount]);
+    }
 }
 ```
 
 Platforms
 =========
-Not every platform is supported.
+## Supported Platforms
+
+- [x] Windows
+- [x] Linux
+- [x] macOS
+- [x] FreeBSD
+- [x] Android
+- [x] iOS
+
 
 Linux
 -----
-You will need the `tun` module to be loaded and root is required to create
+You will need the `tun2` module to be loaded and root is required to create
 interfaces.
 
-macOS
+macOS & FreeBSD
 -----
-It just works, but you have to set up routing manually. For example:
+`tun2` will automatically set up a route according to the provided configuration, which does a similar thing like this:
 > sudo route -n add -net 10.0.0.0/24 10.0.0.1
 
 
 iOS
 ----
-You can pass the file descriptor of the TUN device to `rust-tun` to create the interface.
+You can pass the file descriptor of the TUN device to `tun2` to create the interface.
 
-Here is an example to create the TUN device on iOS and pass the `fd` to `rust-tun`:
+Here is an example to create the TUN device on iOS and pass the `fd` to `tun2`:
 ```swift
 // Swift
 class PacketTunnelProvider: NEPacketTunnelProvider {
     override func startTunnel(options: [String : NSObject]?, completionHandler: @escaping (Error?) -> Void) {
         let tunnelNetworkSettings = createTunnelSettings() // Configure TUN address, DNS, mtu, routing...
         setTunnelNetworkSettings(tunnelNetworkSettings) { [weak self] error in
+            // The tunnel of this tunFd is contains `Packet Information` prifix.
             let tunFd = self?.packetFlow.value(forKeyPath: "socket.fileDescriptor") as! Int32
             DispatchQueue.global(qos: .default).async {
                 start_tun(tunFd)
@@ -96,9 +117,13 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
 pub extern "C" fn start_tun(fd: std::os::raw::c_int) {
     let mut rt = tokio::runtime::Runtime::new().unwrap();
     rt.block_on(async {
-        let mut cfg = tun::Configuration::default();
+        let mut cfg = tun2::Configuration::default();
         cfg.raw_fd(fd);
-        let mut tun = tun::create_as_async(&cfg).unwrap();
+        #[cfg(target_os = "ios")]
+        cfg.platform_config(|p_cfg| {
+            p_cfg.packet_information(true);
+        });
+        let mut tun = tun2::create_as_async(&cfg).unwrap();
         let mut framed = tun.into_framed();
         while let Some(packet) = framed.next().await {
             ...
@@ -110,4 +135,4 @@ pub extern "C" fn start_tun(fd: std::os::raw::c_int) {
 Windows
 -----
 You need to copy the [wintun.dll](https://wintun.net/) file which matches your architecture to 
-the same directory as your executable and run you program as administrator.
+the same directory as your executable and run your program as administrator.