tunic 0.1.0

An interface for TUN/TAP devices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

mod if_tun;
mod ifreq;
mod permission;

use if_tun::{tun_set_group, tun_set_iff, tun_set_owner, tun_set_persist};
use ifreq::Ifreq;
use nix::{
    errno::Errno,
    fcntl::{open, OFlag},
    libc::{IFF_NO_PI, IFF_TAP, IFF_TUN, IFNAMSIZ},
    sys::stat::Mode,
};
use permission::Permission;
use std::{
    error::Error,
    ffi::{CStr, CString, IntoStringError},
    fmt::Display,
    mem::transmute,
    os::fd::RawFd,
};

// TODO: Support multiqueue TUN/TAP

#[derive(Debug, Clone)]
pub struct Tunic {
    fd: RawFd,
}

impl Tunic {
    pub fn unset_persist(&self) -> Result<(), TunicError> {
        unsafe { tun_set_persist(self.fd, false as u64) }?;
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub struct TunicBuilder {
    ifr: Ifreq,
    persist: bool,
    owner: Option<Permission>,
    group: Option<Permission>,
}

impl TunicBuilder {
    pub fn new() -> Self {
        Default::default()
    }

    pub fn name(mut self, name: &CStr) -> Result<Self, TunicError> {
        let name = name.to_bytes();
        let name = unsafe { transmute::<_, &[i8]>(name) };
        if name.len() > IFNAMSIZ {
            Err(TunicError)
        } else {
            self.ifr.name[..name.len()].clone_from_slice(name);
            Ok(self)
        }
    }

    pub fn tap(mut self) -> Self {
        self.ifr.flags &= !IFF_TUN as i16;
        self.ifr.flags |= IFF_TAP as i16;
        self
    }

    pub fn no_packet_info(mut self) -> Self {
        self.ifr.flags |= IFF_NO_PI as i16;
        self
    }

    pub fn persist(mut self) -> Self {
        self.persist = true;
        self
    }

    pub fn owner(mut self, permission: Permission) -> Self {
        self.owner = Some(permission);
        self
    }

    pub fn group(mut self, permission: Permission) -> Self {
        self.group = Some(permission);
        self
    }

    pub fn build(mut self) -> Result<(Tunic, String), TunicError> {
        let fd = open("/dev/net/tun", OFlag::O_RDWR, Mode::empty())?;
        unsafe { tun_set_iff(fd, &self.ifr) }?;

        if self.persist {
            unsafe { tun_set_persist(fd, true as u64) }?;
        }

        if let Some(owner) = self.owner {
            unsafe { tun_set_owner(fd, owner.into_inner() as u64) }?;
        }

        if let Some(group) = self.group {
            unsafe { tun_set_group(fd, group.into_inner() as u64) }?;
        }

        let name = self.ifr.name.as_mut_ptr();
        let name = unsafe { CString::from_raw(name) }.into_string()?;
        Ok((Tunic { fd }, name))
    }
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct TunicError;

impl Error for TunicError {}

impl Display for TunicError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Failed to open TUN interface")
    }
}

impl From<Errno> for TunicError {
    fn from(_: Errno) -> Self {
        Self
    }
}

impl From<IntoStringError> for TunicError {
    fn from(_: IntoStringError) -> Self {
        Self
    }
}