lx 0.4.0

A no_std crate to use Linux system calls
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

use core::fmt::{
    self,
    Display,
    Formatter,
};

use super::{
    SockAddr,
    AF_INET,
    AF_INET6,
};

#[repr(C)]
#[derive(Clone, Copy)]
pub struct SockAddrIn {
    family: u16,
    pub port: u16,
    pub addr: u32,
    zero: [u8; 8],
}

impl SockAddrIn {
    pub fn new(addr: [u8; 4], port: u16) -> Self {
        Self {
            family: AF_INET.into(),
            port: port.to_be(),
            addr: u32::from_ne_bytes(addr),
            zero: [0u8; 8],
        }
    }
}

unsafe impl SockAddr for SockAddrIn {
    fn family() -> u8 {
        AF_INET
    }
}

impl Display for SockAddrIn {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        let parts = self.addr.to_ne_bytes();
        write!(
            f,
            "{}.{}.{}.{}:{}",
            parts[0],
            parts[1],
            parts[2],
            parts[3],
            u16::from_be(self.port)
        )
    }
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct SockAddrIn6 {
    family: u16,
    pub port: u16,
    pub flowinfo: u32,
    pub addr: [u16; 8],
    pub scope_id: u32,
}

impl SockAddrIn6 {
    pub fn new(addr: [u16; 8], port: u16) -> Self {
        Self {
            family: AF_INET6.into(),
            flowinfo: 0,
            port: port.to_be(),
            addr,
            scope_id: 0,
        }
    }
}

unsafe impl SockAddr for SockAddrIn6 {
    fn family() -> u8 {
        AF_INET6
    }
}

impl Display for SockAddrIn6 {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "[{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}]:{}",
            self.addr[0],
            self.addr[1],
            self.addr[2],
            self.addr[3],
            self.addr[4],
            self.addr[5],
            self.addr[6],
            self.addr[7],
            u16::from_be(self.port)
        )
    }
}