ipsuite 0.0.1

[WIP] Collection of Types for the Internet Protocol Suite
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use core::{fmt, mem};

use zerocopy::{
    FromBytes, Immutable, IntoBytes, KnownLayout, SizeError, Unaligned, network_endian,
};

use super::ChecksumWords;

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum UdpPduError {
    InvalidChecksum,
    CastError,
}

impl From<zerocopy::SizeError<&[u8], UdpPdu>> for UdpPduError {
    #[inline]
    fn from(_err: zerocopy::SizeError<&[u8], UdpPdu>) -> Self {
        UdpPduError::CastError
    }
}

impl From<zerocopy::SizeError<&mut [u8], UdpPdu>> for UdpPduError {
    #[inline]
    fn from(_err: zerocopy::SizeError<&mut [u8], UdpPdu>) -> Self {
        UdpPduError::CastError
    }
}

impl From<zerocopy::SizeError<&[u8], UdpPduWords>> for UdpPduError {
    #[inline]
    fn from(_err: zerocopy::SizeError<&[u8], UdpPduWords>) -> Self {
        UdpPduError::CastError
    }
}

impl From<zerocopy::SizeError<&mut [u8], UdpPduWords>> for UdpPduError {
    #[inline]
    fn from(_err: zerocopy::SizeError<&mut [u8], UdpPduWords>) -> Self {
        UdpPduError::CastError
    }
}

#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
#[repr(C, packed)]
pub struct UdpPdu {
    pub header: UdpHeader,
    pub payload: [u8],
}

type UdpPduWords = ChecksumWords<{ UdpHeader::WORDS }, 3>;

impl UdpPdu {
    #[must_use]
    #[inline]
    pub const fn length(&self) -> usize {
        mem::size_of_val(&self.header).wrapping_add(self.payload.len())
    }

    #[inline]
    pub fn update_checksum(&mut self, partial: u32) -> Result<(), UdpPduError> {
        self.as_mut_words()?.update_checksum_nonzero(partial);
        Ok(())
    }

    #[inline]
    pub fn verify_checksum(&self, partial: u32) -> Result<(), UdpPduError> {
        self.as_words()?
            .verify_checksum(partial)
            .map_err(|()| UdpPduError::InvalidChecksum)
    }

    #[inline]
    fn as_words(&self) -> Result<&UdpPduWords, UdpPduError> {
        // TODO: half word at end
        UdpPduWords::ref_from_bytes(self.as_bytes())
            .map_err(SizeError::from)
            .map_err(Into::into)
    }

    #[inline]
    fn as_mut_words(&mut self) -> Result<&mut UdpPduWords, UdpPduError> {
        // TODO: half word at end
        UdpPduWords::mut_from_bytes(self.as_mut_bytes())
            .map_err(SizeError::from)
            .map_err(Into::into)
    }

    #[inline]
    pub fn from_bytes(buf: &[u8]) -> Result<&Self, UdpPduError> {
        UdpPdu::ref_from_bytes(buf)
            .map_err(SizeError::from)
            .map_err(Into::into)
    }

    #[inline]
    pub fn from_bytes_mut(buf: &mut [u8]) -> Result<&mut Self, UdpPduError> {
        UdpPdu::mut_from_bytes(buf)
            .map_err(SizeError::from)
            .map_err(Into::into)
    }

    #[inline]
    pub fn as_parts(&self) -> Result<(&UdpHeader, &[u8]), UdpPduError> {
        Ok((&self.header, &self.payload))
    }

    #[inline]
    pub fn as_mut_parts(&mut self) -> Result<(&mut UdpHeader, &mut [u8]), UdpPduError> {
        Ok((&mut self.header, &mut self.payload))
    }
}

impl fmt::Debug for UdpPdu {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("UdpPdu")
            .field("header", &self.header)
            // TODO: debug print options
            .field("payload", &self.payload.len())
            .finish()
    }
}

#[derive(Copy, Clone, Debug, Default, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
#[repr(C, packed)]
pub struct UdpHeader {
    pub src_port: network_endian::U16,
    pub dst_port: network_endian::U16,
    pub length: network_endian::U16,
    pub checksum: network_endian::U16,
}

impl UdpHeader {
    pub const SIZE: usize = mem::size_of::<Self>();
    pub const WORDS: usize = Self::SIZE >> 1;
}

impl fmt::Display for UdpHeader {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "src={} dst={} len={} cksum={:04x}",
            self.src_port, self.dst_port, self.length, self.checksum,
        )
    }
}