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

use super::{Header, PacketData, Protocol, ParseError};
use crate::AsBeBytes;

#[derive(AddGetter, AddSetter)]
pub struct EthernetHeader {
    #[get]
    dst_mac: [u8; 6],

    #[get]
    src_mac: [u8; 6],

    #[get]
    #[set]
    eth_type: u16,

}

impl EthernetHeader {
    pub fn new(src_mac: [u8; 6], dst_mac: [u8; 6], eth_type: u16) -> Self {
        EthernetHeader {
            dst_mac: dst_mac,
            src_mac: src_mac,
            eth_type: eth_type,
        }
    }
}

impl Header for EthernetHeader {
    #[allow(unused_variables)]
    fn make(self) -> PacketData {
        let tyb = self.eth_type.split_to_bytes();
        let dst_mac: [u8; 6] = self.dst_mac.into();
        let src_mac: [u8; 6] = self.src_mac.into();
        vec![
            dst_mac[0],
            dst_mac[1],
            dst_mac[2],
            dst_mac[3],
            dst_mac[4],
            dst_mac[5],
            src_mac[0],
            src_mac[1],
            src_mac[2],
            src_mac[3],
            src_mac[4],
            src_mac[5],
            tyb[0],
            tyb[1],
        ]
    }

    fn parse(raw_data: &[u8]) -> Result<Box<Self>, ParseError> {
        if raw_data.len() < Self::get_min_length().into() {
            return Err(ParseError::InvalidLength);
        }
        Ok(Box::new(Self {
            dst_mac: [raw_data[0], raw_data[1], raw_data[2], raw_data[3], raw_data[4], raw_data[5]],
            src_mac: [raw_data[6], raw_data[7], raw_data[8], raw_data[9], raw_data[10], raw_data[11]],
            eth_type: ((raw_data[12] as u16) << 8) + raw_data[13] as u16,
        }))
    }

    fn get_proto(&self) -> Protocol {
        Protocol::ETH
    }

    fn get_length(&self) -> u8 {
        14
    }

    fn get_min_length() -> u8 {
        14
    }
}