ethox 0.0.2

A standalone network stack for user-space networking and unikernels
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

// Copyright (C) 2016 whitequark@whitequark.org
// Copyright (C) 2019 Andreas Molzer <andreas.molzer@tum.de>
//
// in large parts from `smoltcp` originally distributed under 0-clause BSD
use super::{ifreq, Errno, LibcResult, IoctlResult};
use libc;

pub(crate) const ETH_P_ALL:    libc::c_short = 0x0003;

/// Adds a method to open a tap.
///
/// This is an extension trait implemented for `ifreq` in Linux.
pub(crate) trait TunSetIf {
    /// Attach to an existing interface or create a new one.
    fn tun_set_if(&mut self, fd: libc::c_int, kind: libc::c_int) -> Result<(), Errno>;

    /// Convenience method over`set_if` when `kind` is a tap.
    fn tun_set_tap(&mut self, fd: libc::c_int) -> Result<(), Errno>;
}

/// Adds a method to interact with the mtu.
pub(crate) trait NetdeviceMtu {
    fn get_mtu(&mut self, fd: libc::c_int) -> Result<libc::c_int, Errno>;
}

pub(crate) trait IfIndex {
    fn get_if_index(&mut self, fd: libc::c_int) -> Result<libc::c_int, Errno>;
}

impl ifreq {
    pub(crate) const SIOCGIFMTU:   libc::c_ulong = 0x8921;
    pub(crate) const SIOCGIFINDEX: libc::c_ulong = 0x8933;

    pub(crate) const TUNSETIFF:    libc::c_ulong = 0x400454CA;
    pub(crate) const IFF_TAP:      libc::c_int   = 0x0002;
    pub(crate) const IFF_NO_PI:    libc::c_int   = 0x1000;
}

impl TunSetIf for ifreq {
    fn tun_set_if(&mut self, fd: libc::c_int, kind: libc::c_int) -> Result<(), Errno> {
        #[repr(C)]
        #[derive(Debug)]
        struct Request {
            interface: ifreq,
            kind: libc::c_int,
        }

        let mut request = Request {
            interface: *self,
            kind,
        };

        let res = unsafe {
            libc::ioctl(fd, Self::TUNSETIFF, &mut request as *mut _)
        };

        IoctlResult(res).errno()?;

        Ok(())
    }

    fn tun_set_tap(&mut self, fd: libc::c_int) -> Result<(), Errno> {
        self.tun_set_if(fd, Self::IFF_TAP | Self::IFF_NO_PI)
    }
}

impl NetdeviceMtu for ifreq {
    fn get_mtu(&mut self, fd: libc::c_int) -> Result<libc::c_int, Errno> {
        #[repr(C)]
        struct Request {
            interface: ifreq,
            ifr_mtu: libc::c_int,
        }

        let mut request = Request {
            interface: *self,
            ifr_mtu: 0,
        };

        let res = unsafe {
            libc::ioctl(fd, Self::SIOCGIFMTU, &mut request as *mut _)
        };

        IoctlResult(res).errno()?;

        Ok(request.ifr_mtu)
    }
}

impl IfIndex for ifreq {
    fn get_if_index(&mut self, fd: libc::c_int) -> Result<libc::c_int, Errno> {
        #[repr(C)]
        struct Request {
            interface: ifreq,
            ifr_ifindex: libc::c_int,
        }

        let mut request = Request {
            interface: *self,
            ifr_ifindex: 0,
        };

        let res = unsafe {
            libc::ioctl(fd, Self::SIOCGIFINDEX, &mut request as *mut _)
        };

        IoctlResult(res).errno()?;

        Ok(request.ifr_ifindex)
    }
}