async_tun

Struct TunBuilder

Source 
pub struct TunBuilder<'a> { /* private fields */ }
Expand description

Represents a factory to build new instances of Tun.

Implementations§

Source§

impl<'a> TunBuilder<'a>

Source

pub fn new() -> Self

Creates a new instance of TunBuilder.

Examples found in repository?
examples/read.rs (line 9)
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 11)
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 name(self, name: &'a str) -> Self

Sets the name of device (max length: 16 characters), if it is empty, then device name is set by kernel. Default value is empty.

Examples found in repository?
examples/read.rs (line 10)
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 12)
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 tap(self, is_tap: bool) -> Self

If is_tap is true, a TAP device is allocated, otherwise, a TUN device is created. Default value is false.

Examples found in repository?
examples/read.rs (line 11)
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 13)
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 packet_info(self, packet_info: bool) -> Self

If packet_info is false, then IFF_NO_PI flag is set. Default value is true.

Examples found in repository?
examples/read.rs (line 12)
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 14)
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, mtu: i32) -> Self

Sets the MTU of device.

Examples found in repository?
examples/read.rs (line 13)
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 15)
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 owner(self, owner: i32) -> Self

Sets the owner of device.

Source

pub fn group(self, group: i32) -> Self

Sets the group of device.

Source

pub fn address(self, address: Ipv4Addr) -> Self

Sets IPv4 address of device.

Examples found in repository?
examples/read.rs (line 15)
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 17)
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, dst: Ipv4Addr) -> Self

Sets IPv4 destination address of device.

Examples found in repository?
examples/read.rs (line 16)
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 18)
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, broadcast: Ipv4Addr) -> Self

Sets IPv4 broadcast address of device.

Examples found in repository?
examples/read.rs (line 17)
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 19)
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, netmask: Ipv4Addr) -> Self

Sets IPv4 netmask address of device.

Examples found in repository?
examples/read.rs (line 18)
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 20)
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, mac: MacAddress) -> Self

Sets Ethernet MAC address of device (for tap mode).

Source

pub fn persist(self) -> Self

Makes the device persistent.

Source

pub fn up(self) -> Self

Sets up the device.

Examples found in repository?
examples/read.rs (line 14)
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 16)
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 async fn try_build(self) -> Result<Tun>

Builds a new instance of Tun.

Examples found in repository?
examples/read.rs (line 19)
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 async fn try_build_mq(self, queues: usize) -> Result<Vec<Tun>>

Builds multiple instances of Tun with IFF_MULTI_QUEUE flag.

Examples found in repository?
examples/read-mq.rs (line 21)
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}

Trait Implementations§

Source§

impl<'a> Default for TunBuilder<'a>

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl<'a> Freeze for TunBuilder<'a>

§

impl<'a> RefUnwindSafe for TunBuilder<'a>

§

impl<'a> Send for TunBuilder<'a>

§

impl<'a> Sync for TunBuilder<'a>

§

impl<'a> Unpin for TunBuilder<'a>

§

impl<'a> UnwindSafe for TunBuilder<'a>

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