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

use std::sync::Arc;

use crate::header::Header;

use self::nic::NicBuffer;

pub mod ethernet;
pub mod nic;

pub struct IncomingPacketInfo {
    buffer: Arc<NicBuffer>,
    network_info: Option<(usize, usize)>,
    link_info: Option<(usize, usize)>,
    transport_info: Option<(usize, usize)>,
}

impl IncomingPacketInfo {
    pub fn new(buffer: Arc<NicBuffer>) -> Self {
        Self {
            buffer,
            network_info: None,
            link_info: None,
            transport_info: None,
        }
    }

    pub fn update_for_link(mut self, hdr_off: usize, len: usize) -> Option<Self> {
        let off = hdr_off;
        if off + len > self.buffer.packet_len() {
            return None;
        }
        self.link_info = Some((off, len));

        Some(self)
    }

    pub fn update_for_network(mut self, hdr_off: usize, len: usize) -> Option<Self> {
        let prev = self.link_info.unwrap().0;
        let off = hdr_off + prev;
        if off + len > self.buffer.packet_len() {
            return None;
        }
        self.network_info = Some((off, len));

        Some(self)
    }

    pub fn update_for_transport(mut self, hdr_off: usize, len: usize) -> Option<Self> {
        let prev = self.network_info.unwrap().0;
        let off = hdr_off + prev;
        if off + len > self.buffer.packet_len() {
            return None;
        }
        self.transport_info = Some((off, len));

        Some(self)
    }

#[allow(dead_code)]
    pub fn packet_len(&self) -> usize {
        self.buffer.packet_len()
    }

    pub unsafe fn get_network_hdr<T: Header>(&self) -> Option<T> {
        let info = self.network_info.unwrap();
        if info.0 + std::mem::size_of::<T>() > info.1 {
            return None;
        }
        Some(self.buffer.get_minimal_header(info.0))
    }

    #[allow(dead_code)]
    pub unsafe fn get_transport_hdr<T: Header>(&self) -> Option<T> {
        let info = self.transport_info.unwrap();
        if info.0 + std::mem::size_of::<T>() > info.1 {
            return None;
        }
        Some(self.buffer.get_minimal_header(info.0))
    }
}