async_tun

Struct Tun

Source 
pub struct Tun { /* private fields */ }
Expand description

Represents a Tun/Tap device. Use TunBuilder to create a new instance of Tun.

Implementations§

Source§

impl Tun

Source

pub fn name(&self) -> &str

Returns the name of Tun/Tap device.

Examples found in repository?
examples/read.rs (line 28)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
More examples
Hide additional examples
examples/read-mq.rs (line 30)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn mtu(&self) -> Result<i32>

Returns the value of MTU.

Examples found in repository?
examples/read.rs (line 30)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
More examples
Hide additional examples
examples/read-mq.rs (line 32)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn address(&self) -> Result<Ipv4Addr>

Returns the IPv4 address of MTU.

Examples found in repository?
examples/read.rs (line 32)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
More examples
Hide additional examples
examples/read-mq.rs (line 34)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn destination(&self) -> Result<Ipv4Addr>

Returns the IPv4 destination address of MTU.

Examples found in repository?
examples/read.rs (line 33)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
More examples
Hide additional examples
examples/read-mq.rs (line 35)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn broadcast(&self) -> Result<Ipv4Addr>

Returns the IPv4 broadcast address of MTU.

Examples found in repository?
examples/read.rs (line 34)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
More examples
Hide additional examples
examples/read-mq.rs (line 36)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn netmask(&self) -> Result<Ipv4Addr>

Returns the IPv4 netmask address of MTU.

Examples found in repository?
examples/read.rs (line 35)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
More examples
Hide additional examples
examples/read-mq.rs (line 37)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn mac(&self) -> Result<Option<MacAddress>>

Returns to Ethernet MAC address.

Source

pub fn flags(&self) -> Result<i16>

Returns the flags of MTU.

Examples found in repository?
examples/read.rs (line 31)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
More examples
Hide additional examples
examples/read-mq.rs (line 33)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn split(&self) -> (BufReader<&File>, BufWriter<&File>)

Splits self to reader and writer pairs.

Examples found in repository?
examples/read.rs (line 42)
8async fn async_main() -> Result<()> {
9    let tun = TunBuilder::new()
10        .name("")
11        .tap(false)
12        .packet_info(false)
13        .mtu(1350)
14        .up()
15        .address(Ipv4Addr::new(10, 0, 0, 1))
16        .destination(Ipv4Addr::new(10, 1, 0, 1))
17        .broadcast(Ipv4Addr::BROADCAST)
18        .netmask(Ipv4Addr::new(255, 255, 255, 0))
19        .try_build()
20        .await?;
21
22    println!("-----------");
23    println!("tun created");
24    println!("-----------");
25
26    println!(
27        "┌ name: {}\n├ fd: {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
28        tun.name(),
29        tun.as_raw_fd(),
30        tun.mtu().unwrap(),
31        tun.flags().unwrap(),
32        tun.address().unwrap(),
33        tun.destination().unwrap(),
34        tun.broadcast().unwrap(),
35        tun.netmask().unwrap(),
36    );
37
38    println!("---------------------");
39    println!("ping 10.1.0.2 to test");
40    println!("---------------------");
41
42    let (mut reader, mut _writer) = tun.split();
43
44    let mut buf = [0u8; 1024];
45    loop {
46        let n = reader.read(&mut buf).await?;
47        println!("reading {} bytes: {:?}", n, &buf[..n]);
48    }
49}
Source

pub fn reader(&self) -> BufReader<&File>

Returns a reader to read from tun.

Examples found in repository?
examples/read-mq.rs (line 50)
8async fn async_main() -> Result<()> {
9    let queues = 3;
10
11    let tuns = TunBuilder::new()
12        .name("")
13        .tap(false)
14        .packet_info(false)
15        .mtu(1350)
16        .up()
17        .address(Ipv4Addr::new(10, 0, 0, 1))
18        .destination(Ipv4Addr::new(10, 1, 0, 1))
19        .broadcast(Ipv4Addr::BROADCAST)
20        .netmask(Ipv4Addr::new(255, 255, 255, 0))
21        .try_build_mq(queues)
22        .await?;
23
24    println!("--------------");
25    println!("{} tuns created", queues);
26    println!("--------------");
27
28    println!(
29        "┌ name: {}\n├ fd: {}, {}, {}\n├ mtu: {}\n├ flags: {}\n├ address: {}\n├ destination: {}\n├ broadcast: {}\n└ netmask: {}",
30        tuns[0].name(),
31        tuns[0].as_raw_fd(), tuns[1].as_raw_fd(), tuns[2].as_raw_fd(),
32        tuns[0].mtu().unwrap(),
33        tuns[0].flags().unwrap(),
34        tuns[0].address().unwrap(),
35        tuns[0].destination().unwrap(),
36        tuns[0].broadcast().unwrap(),
37        tuns[0].netmask().unwrap(),
38    );
39
40    println!("---------------------");
41    println!("ping 10.1.0.2 to test");
42    println!("---------------------");
43
44    let mut tuns = tuns.into_iter();
45    let tun0 = tuns.next().unwrap();
46    let tun1 = tuns.next().unwrap();
47    let tun2 = tuns.next().unwrap();
48
49    task::spawn(async move {
50        let mut reader = tun0.reader();
51        let mut buf = [0u8; 1024];
52        loop {
53            let n = reader.read(&mut buf).await.unwrap();
54            println!("reading {} bytes from tuns[0]: {:?}", n, &buf[..n]);
55        }
56    });
57
58    task::spawn(async move {
59        let mut reader = tun1.reader();
60        let mut buf = [0u8; 1024];
61        loop {
62            let n = reader.read(&mut buf).await.unwrap();
63            println!("reading {} bytes from tuns[1]: {:?}", n, &buf[..n]);
64        }
65    });
66
67    let mut reader = tun2.reader();
68    let mut buf = [0u8; 1024];
69    loop {
70        let n = reader.read(&mut buf).await.unwrap();
71        println!("reading {} bytes from tuns[2]: {:?}", n, &buf[..n]);
72    }
73}
Source

pub fn writer(&self) -> BufWriter<&File>

Returns a writer to write to tun.

Trait Implementations§

Source§

impl AsRawFd for Tun

Source§

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor. Read more

Auto Trait Implementations§

§

impl Freeze for Tun

§

impl !RefUnwindSafe for Tun

§

impl Send for Tun

§

impl Sync for Tun

§

impl Unpin for Tun

§

impl !UnwindSafe for Tun

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more