Mtu

.cargo/config.toml

@@ -0,0 +1,9 @@
+[registries.crates-io]
+protocol = "sparse"
+
+[build]
+# 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"]

.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,10 +1,7 @@
 name: Push or PR
 
 on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
+  [push, pull_request]
 
 env:
   CARGO_TERM_COLOR: always
@@ -18,7 +15,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: rustfmt
       run: cargo fmt --all -- --check
     - name: check

.gitignore

@@ -3,3 +3,4 @@
 target/
 **/*.rs.bk
 Cargo.lock
+wintun.dll

Cargo.toml

@@ -1,46 +1,51 @@
 [package]
-name = "tun"
-version = "0.6.1"
+name = "tun2"
+version = "0.7.22"
 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"]
 
+[lib]
+crate-type = ["staticlib", "cdylib", "lib"]
+
 [dependencies]
-byteorder = { version = "1", optional = true }
-bytes = { version = "1", optional = true }
+byteorder = { version = "1" }
+bytes = { version = "1" }
 futures-core = { version = "0.3", optional = true }
 libc = "0.2"
 log = "0.4"
 thiserror = "1"
 tokio = { version = "1", features = ["net", "macros"], optional = true }
-tokio-util = { version = "0.7", features = ["codec"], optional = true }
+tokio-util = { version = "0.7", features = ["codec"] }
 
-[target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
+[target.'cfg(unix)'.dependencies]
 ioctl = { version = "0.8", package = "ioctl-sys" }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-wintun = { version = "0.3", features = ["panic_on_unsent_packets"] }
+wintun = { version = "0.4", features = ["panic_on_unsent_packets"] }
 
 [dev-dependencies]
 futures = "0.3"
 packet = "0.1"
+tokio = { version = "1", features = ["rt-multi-thread", "io-util"] }
 
 [features]
-async = ["tokio", "tokio-util", "bytes", "byteorder", "futures-core"]
+default = []
+async = ["tokio", "futures-core"]
 
 [[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),
+> I (@ssrlive) 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 = "0.7"
 ```
 
 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 = "0.7", features = ["async"] }
 ```
 
 Example
@@ -32,36 +43,36 @@ 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);
-	});
-
-	let mut dev = tun::create(&config).unwrap();
-	let mut buf = [0; 4096];
-
-	loop {
-		let amount = dev.read(&mut buf).unwrap();
-		println!("{:?}", &buf[0 .. amount]);
-	}
+    let mut config = tun2::Configuration::default();
+    config
+        .address((10, 0, 0, 1))
+        .netmask((255, 255, 255, 0))
+        .up();
+
+    #[cfg(target_os = "linux")]
+    config.platform_config(|config| {
+        config.packet_information(true);
+        config.apply_settings(true);
+    });
+
+    let mut dev = tun2::create(&config).unwrap();
+    let mut buf = [0; 4096];
+
+    loop {
+        let amount = dev.read(&mut buf).unwrap();
+        println!("{:?}", &buf[0..amount]);
+    }
 }
 ```
 
 Platforms
 =========
-Not every platform is supported.
+Recently, `tun2` supports Linux, Android, macOS, iOS and Windows.
 
 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
@@ -72,9 +83,9 @@ It just works, but you have to set up routing manually. For example:
 
 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 {
@@ -96,9 +107,9 @@ 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();
+        let mut tun = tun2::create_as_async(&cfg).unwrap();
         let mut framed = tun.into_framed();
         while let Some(packet) = framed.next().await {
             ...

examples/ping-tun.rs

@@ -14,7 +14,7 @@
 
 use futures::{SinkExt, StreamExt};
 use packet::{builder::Builder, icmp, ip, Packet};
-use tun::{self, Configuration, TunPacket};
+use tun2::{self, AbstractDevice, Configuration, TunPacket};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -27,16 +27,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .up();
 
     #[cfg(target_os = "linux")]
-    config.platform(|config| {
+    config.platform_config(|config| {
         config.packet_information(true);
+        config.apply_settings(true);
     });
 
     #[cfg(target_os = "windows")]
-    config.platform(|config| {
-        config.initialize();
+    config.platform_config(|config| {
+        config.device_guid(Some(9099482345783245345345_u128));
     });
 
-    let dev = tun::create_as_async(&config)?;
+    let dev = tun2::create_as_async(&config)?;
+    let packet_information = dev.as_ref().packet_information();
 
     let mut framed = dev.into_framed();
 
@@ -59,7 +61,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                             .sequence(icmp.sequence())?
                             .payload(icmp.payload())?
                             .build()?;
-                        framed.send(TunPacket::new(reply)).await?;
+                        let pkt = TunPacket::new(packet_information, reply);
+                        framed.send(pkt).await?;
                     }
                 }
             }

examples/read-async-codec.rs

@@ -41,14 +41,14 @@ impl Decoder for IPPacketCodec {
 
 #[tokio::main]
 async fn main() {
-    let mut config = tun::Configuration::default();
+    let mut config = tun2::Configuration::default();
 
     config
         .address((10, 0, 0, 1))
         .netmask((255, 255, 255, 0))
         .up();
 
-    let dev = tun::create_as_async(&config).unwrap();
+    let dev = tun2::create_as_async(&config).unwrap();
 
     let mut stream = FramedRead::new(dev, IPPacketCodec);
 

examples/read-async.rs

@@ -12,31 +12,33 @@
 //
 //  0. You just DO WHAT THE FUCK YOU WANT TO.
 
-use futures::StreamExt;
-use packet::ip::Packet;
+use tokio::io::AsyncReadExt;
+use tun2::AbstractDevice;
 
 #[tokio::main]
-async fn main() {
-    let mut config = tun::Configuration::default();
+async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let mut config = tun2::Configuration::default();
 
     config
         .address((10, 0, 0, 1))
         .netmask((255, 255, 255, 0))
+        .mtu(tun2::DEFAULT_MTU)
         .up();
 
     #[cfg(target_os = "linux")]
-    config.platform(|config| {
+    config.platform_config(|config| {
         config.packet_information(true);
+        config.apply_settings(true);
     });
 
-    let dev = tun::create_as_async(&config).unwrap();
-
-    let mut stream = dev.into_framed();
-
-    while let Some(packet) = stream.next().await {
-        match packet {
-            Ok(pkt) => println!("pkt: {:#?}", Packet::unchecked(pkt.get_bytes())),
-            Err(err) => panic!("Error: {:?}", err),
+    let mut dev = tun2::create_as_async(&config)?;
+    let size = dev.as_ref().mtu()? + tun2::PACKET_INFORMATION_LENGTH;
+    let mut buf = vec![0; size];
+    loop {
+        if let Ok(len) = dev.read(&mut buf).await {
+            println!("pkt: {:?}", &buf[..len]);
         }
     }
+    #[allow(unreachable_code)]
+    Ok(())
 }

examples/read.rs

@@ -15,7 +15,7 @@
 use std::io::Read;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut config = tun::Configuration::default();
+    let mut config = tun2::Configuration::default();
 
     config
         .address((10, 0, 0, 9))
@@ -24,11 +24,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .up();
 
     #[cfg(target_os = "linux")]
-    config.platform(|config| {
+    config.platform_config(|config| {
         config.packet_information(true);
+        config.apply_settings(true);
     });
 
-    let mut dev = tun::create(&config)?;
+    let mut dev = tun2::create(&config)?;
     let mut buf = [0; 4096];
 
     loop {