Rust网络隧道库wintun的使用，高性能Windows虚拟网卡驱动开发插件包

wintun是Wintun C库的安全Rust惯用绑定。该库的所有功能都使用纯Rust类型和函数进行包装，使使用感觉符合人体工程学。

使用说明

在代码中加载wintun.dll签名驱动文件，使用load、load_from_path或load_from_library方法。

然后调用Adapter::create或Adapter::open获取wintun适配器。使用Adapter::start_session开始会话。

示例代码

use std::sync::Arc;

//必须以管理员身份运行，因为我们要创建网络适配器
//加载wintun dll文件以便调用底层C函数
//不安全，因为我们加载的是任意dll文件
let wintun = unsafe { wintun::load_from_path("path/to/wintun.dll") }
    .expect("Failed to load wintun dll");

//尝试打开名为"Demo"的适配器
let adapter = match wintun::Adapter::open(&wintun, "Demo") {
    Ok(a) => a,
    Err(_) => {
        //如果加载失败(很可能不存在)，则创建新的
        wintun::Adapter::create(&wintun, "Demo", "Example", None)
            .expect("Failed to create wintun adapter!")
    }
};
//指定wintun驱动程序应使用的环形缓冲区大小
let session = Arc::new(adapter.start_session(wintun::MAX_RING_CAPACITY).unwrap());

//从环形缓冲区获取20字节的包
let mut packet = session.allocate_send_packet(20).unwrap();
let bytes: &mut [u8] = packet.bytes_mut();
//写入IPV4版本和头部长度
bytes[0] = 0x40;

//完成IP头部写入
bytes[9] = 0x69;
bytes[10] = 0x04;
bytes[11] = 0x20;
//...

//将包发送到wintun虚拟适配器进行系统处理
session.send_packet(packet);

//停止任何在其他线程上阻塞等待数据的读取器
//仅在阻塞读取器阻止关闭时需要，即它持有对会话的Arc引用，阻止其被丢弃
session.shutdown();

//会话在drop时停止
//drop(session);

//drop(adapter)
//适配器在丢弃时关闭其资源

完整示例

下面是一个更完整的示例，展示了如何创建虚拟网卡并处理网络数据包：

use std::{sync::Arc, time::Duration};
use wintun::Adapter;

fn main() {
    // 加载wintun驱动
    let wintun = unsafe { wintun::load_from_path("wintun/bin/wintun.dll") }
        .expect("Failed to load wintun dll");

    // 创建或打开适配器
    let adapter = match Adapter::open(&wintun, "WintunRustDemo") {
        Ok(adapter) => adapter,
        Err(_) => {
            Adapter::create(&wintun, "WintunRustDemo", "Wintun Rust Demo", None)
                .expect("Failed to create adapter")
        }
    };

    // 设置MTU并启动会话
    adapter.set_adapter_mtu(1500).expect("Failed to set MTU");
    let session = Arc::new(
        adapter
            .start_session(wintun::MAX_RING_CAPACITY)
            .expect("Failed to start session"),
    );

    // 接收线程
    let recv_session = session.clone();
    std::thread::spawn(move || {
        loop {
            match recv_session.receive_blocking() {
                Ok(packet) => {
                    let bytes = packet.bytes();
                    println!("Received packet with {} bytes", bytes.len());
                    // 处理包数据...
                }
                Err(e) => {
                    println!("Receive error: {}", e);
                    break;
                }
            }
        }
    });

    // 发送线程
    let send_session = session.clone();
    std::thread::spawn(move || {
        let mut counter = 0;
        loop {
            std::thread::sleep(Duration::from_secs(1));
            
            // 分配发送包
            let mut packet = match send_session.allocate_send_packet(20) {
                Ok(p) => p,
                Err(e) => {
                    println!("Allocate packet error: {}", e);
                    continue;
                }
            };
            
            // 填充测试数据
            let bytes = packet.bytes_mut();
            bytes[0] = 0x45; // IP版本和头部长度
            bytes[9] = 0x01; // 协议类型
            bytes[10] = (counter >> 8) as u8;
            bytes[11] = counter as u8;
            counter += 1;
            
            // 发送包
            if let Err(e) = send_session.send_packet(packet) {
                println!("Send packet error: {}", e);
            }
        }
    });

    // 等待用户输入退出
    println!("Press Enter to exit...");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).unwrap();
    
    // 关闭会话
    session.shutdown();
}

特性

• panic_on_unsent_packets: 如果发送包被丢弃而没有发送，则panic。对于调试包问题很有用，因为未发送而被丢弃的包会占用wintun的内部环形缓冲区。

待办事项

• 添加异步支持 需要挂钩到Windows特定的反应器并在wintun的读取句柄上注册读取兴趣。通过tokio::spawn_blocking异步化其他慢操作。

许可证: MIT