read.rs

use std::net::Ipv4Addr;
use std::os::unix::io::AsRawFd;
use std::sync::Arc;
use tokio_tun::Tun;

#[tokio::main]
async fn main() {
    let tun = Arc::new(
        Tun::builder()
            .name("")
            .tap()
            .packet_info()
            .mtu(1350)
            .up()
            .address(Ipv4Addr::new(10, 0, 0, 1))
            .destination(Ipv4Addr::new(10, 1, 0, 1))
            .broadcast(Ipv4Addr::BROADCAST)
            .netmask(Ipv4Addr::new(255, 255, 255, 0))
            .build()
            .unwrap()
            .pop()
            .unwrap(),
    );

    println!("-----------");
    println!("tap created");
    println!("-----------");

    println!(
        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
        tun.name(),
        tun.as_raw_fd(),
        tun.mtu().unwrap(),
        tun.flags().unwrap(),
        tun.address().unwrap(),
        tun.destination().unwrap(),
        tun.broadcast().unwrap(),
        tun.netmask().unwrap(),
    );

    println!("---------------------");
    println!("ping 10.1.0.2 to test");
    println!("---------------------");

    // Reader
    let mut buf = [0u8; 1024];
    loop {
        let n = tun.recv(&mut buf).await.unwrap();
        println!("reading {} bytes: {:?}", n, &buf[..n]);
    }

    // Writer: simply clone Arced Tun.
    /*
        let tun_c = tun.clone();
        tokio::spawn(async move{
            let buf = b"data to be written";
            tun_c.send_all(buf).await.unwrap();
        });
    */
}