1use crate::headers::*;
2use crate::types::*;
3use crate::PacketSlice;
4
5pub fn parse<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
6 let length: u16 = ((arr[12] as u16) << 8) | arr[13] as u16;
7 if length < 1500 {
8 parse_dot3(arr)
9 } else {
10 parse_ethernet(arr)
11 }
12}
13pub fn parse_dot3<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
14 let dot3 = Dot3Slice::from(&arr[0..Dot3::size()]);
15 let mut pkt = parse_llc(&arr[Dot3::size()..]);
16 pkt.insert(dot3);
17 pkt
18}
19pub fn parse_llc<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
20 let llc = LLCSlice::from(&arr[0..LLC::size()]);
21 let mut pkt = if arr[0] == 0xAA && arr[1] == 0xAA && arr[2] == 0x03 {
22 parse_snap(&arr[LLC::size()..])
23 } else {
24 accept(&arr[LLC::size()..])
25 };
26 pkt.insert(llc);
27 pkt
28}
29pub fn parse_snap<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
30 let snap = SNAPSlice::from(&arr[0..SNAP::size()]);
31 let mut pkt = accept(&arr[SNAP::size()..]);
32 pkt.insert(snap);
33 pkt
34}
35pub fn parse_ethernet<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
36 let eth = EtherSlice::from(&arr[0..Ether::size()]);
37 let etype = EtherType::try_from(eth.etype() as u16);
38 let mut pkt = match etype {
39 Ok(EtherType::DOT1Q) => parse_vlan(&arr[Ether::size()..]),
40 Ok(EtherType::ARP) => parse_arp(&arr[Ether::size()..]),
41 Ok(EtherType::IPV4) => parse_ipv4(&arr[Ether::size()..]),
42 Ok(EtherType::IPV6) => parse_ipv6(&arr[Ether::size()..]),
43 Ok(EtherType::MPLS) => parse_mpls(&arr[Ether::size()..]),
44 _ => accept(&arr[Ether::size()..]),
45 };
46 pkt.insert(eth);
47 pkt
48}
49pub fn parse_vlan<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
50 let vlan = VlanSlice::from(&arr[0..Vlan::size()]);
51 let etype = EtherType::try_from(vlan.etype() as u16);
52 let mut pkt = match etype {
53 Ok(EtherType::DOT1Q) => parse_vlan(&arr[Vlan::size()..]),
54 Ok(EtherType::ARP) => parse_arp(&arr[Vlan::size()..]),
55 Ok(EtherType::IPV4) => parse_ipv4(&arr[Vlan::size()..]),
56 Ok(EtherType::IPV6) => parse_ipv6(&arr[Vlan::size()..]),
57 Ok(EtherType::MPLS) => parse_mpls(&arr[Vlan::size()..]),
58 _ => accept(&arr[Vlan::size()..]),
59 };
60 pkt.insert(vlan);
61 pkt
62}
63pub fn parse_mpls<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
64 let mpls = MPLSSlice::from(&arr[0..MPLS::size()]);
65 let bos = mpls.bos();
66 let mut pkt = if bos == 1 {
67 parse_mpls_bos(&arr[MPLS::size()..])
68 } else {
69 parse_mpls(&arr[MPLS::size()..])
70 };
71 pkt.insert(mpls);
72 pkt
73}
74pub fn parse_mpls_bos<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
75 let mpls = MPLSSlice::from(&arr[0..MPLS::size()]);
76 let mut pkt = match IpType::try_from(arr[MPLS::size()] >> 4 & 0xf) {
77 Ok(IpType::V4) => parse_ipv4(&arr[MPLS::size()..]),
78 Ok(IpType::V6) => parse_ipv6(&arr[MPLS::size()..]),
79 _ => parse_ethernet(&arr[MPLS::size()..]),
80 };
81 pkt.insert(mpls);
82 pkt
83}
84pub fn parse_ipv4<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
85 let ipv4 = IPv4Slice::from(&arr[0..IPv4::size()]);
86 let proto = IpProtocol::try_from(ipv4.protocol() as u8);
87 let mut pkt = match proto {
88 Ok(IpProtocol::ICMP) => parse_icmp(&arr[IPv4::size()..]),
89 Ok(IpProtocol::IPIP) => parse_ipv4(&arr[IPv4::size()..]),
90 Ok(IpProtocol::TCP) => parse_tcp(&arr[IPv4::size()..]),
91 Ok(IpProtocol::UDP) => parse_udp(&arr[IPv4::size()..]),
92 Ok(IpProtocol::IPV6) => parse_ipv6(&arr[IPv4::size()..]),
93 Ok(IpProtocol::GRE) => parse_gre(&arr[IPv4::size()..]),
94 _ => accept(&arr[IPv4::size()..]),
95 };
96 pkt.insert(ipv4);
97 pkt
98}
99pub fn parse_ipv6<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
100 let ipv6 = IPv6Slice::from(&arr[0..IPv6::size()]);
101 let next_hdr = IpProtocol::try_from(ipv6.next_hdr() as u8);
102 let mut pkt = match next_hdr {
103 Ok(IpProtocol::ICMPV6) => parse_icmp(&arr[IPv6::size()..]),
104 Ok(IpProtocol::IPIP) => parse_ipv4(&arr[IPv6::size()..]),
105 Ok(IpProtocol::TCP) => parse_tcp(&arr[IPv6::size()..]),
106 Ok(IpProtocol::UDP) => parse_udp(&arr[IPv6::size()..]),
107 Ok(IpProtocol::IPV6) => parse_ipv6(&arr[IPv6::size()..]),
108 Ok(IpProtocol::GRE) => parse_gre(&arr[IPv6::size()..]),
109 _ => accept(&arr[IPv6::size()..]),
110 };
111 pkt.insert(ipv6);
112 pkt
113}
114pub fn parse_gre<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
115 let gre = GRESlice::from(&arr[0..GRE::size()]);
116 let proto = EtherType::try_from(gre.proto() as u16);
117 let chksum_present = gre.chksum_present();
118 let seqnum_present = gre.seqnum_present();
119 let key_present = gre.key_present();
120 let mut offset = 0;
121 offset += GRE::size();
122 let gco = if chksum_present == 1 {
123 let p = Some(GREChksumOffsetSlice::from(
124 &arr[offset..offset + GREChksumOffset::size()],
125 ));
126 offset += GREChksumOffset::size();
127 p
128 } else {
129 None
130 };
131 let gk = if key_present == 1 {
132 let p = Some(GREKeySlice::from(&arr[offset..offset + GREKey::size()]));
133 offset += GREKey::size();
134 p
135 } else {
136 None
137 };
138 let gsn = if seqnum_present == 1 {
139 let p = Some(GRESequenceNumSlice::from(
140 &arr[offset..offset + GRESequenceNum::size()],
141 ));
142 offset += GRESequenceNum::size();
143 p
144 } else {
145 None
146 };
147 let mut pkt = match proto {
148 Ok(EtherType::IPV4) => parse_ipv4(&arr[offset..]),
149 Ok(EtherType::IPV6) => parse_ipv6(&arr[offset..]),
150 Ok(EtherType::ERSPANII) => parse_erspan2(&arr[offset..]),
151 Ok(EtherType::ERSPANIII) => parse_erspan3(&arr[offset..]),
152 _ => accept(&arr[offset..]),
153 };
154 if let Some(p) = gco {
155 pkt.insert(p);
156 }
157 if let Some(p) = gk {
158 pkt.insert(p);
159 }
160 if let Some(p) = gsn {
161 pkt.insert(p);
162 }
163 pkt.insert(gre);
164 pkt
165}
166pub fn parse_erspan2<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
167 let erspan2 = ERSPAN2Slice::from(&arr[0..ERSPAN2::size()]);
168 let mut pkt = parse_ethernet(&arr[ERSPAN2::size()..]);
169 pkt.insert(erspan2);
170 pkt
171}
172pub fn parse_erspan3<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
173 let erspan3 = ERSPAN3Slice::from(&arr[0..ERSPAN3::size()]);
174 let o = erspan3.o();
175 let mut offset = 0;
176 offset += ERSPAN3::size();
177 let platform = if o == 1 {
178 let p = Some(ERSPANPLATFORMSlice::from(
179 &arr[offset..offset + ERSPANPLATFORM::size()],
180 ));
181 offset += ERSPANPLATFORM::size();
182 p
183 } else {
184 None
185 };
186 let mut pkt = parse_ethernet(&arr[offset..]);
187 if let Some(p) = platform {
188 pkt.insert(p);
189 }
190 pkt.insert(erspan3);
191 pkt
192}
193pub fn parse_arp<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
194 let mut pkt = accept(&arr[ARP::size()..]);
195 pkt.insert(ARPSlice::from(&arr[0..ARP::size()]));
196 pkt
197}
198pub fn parse_icmp<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
199 let mut pkt = accept(&arr[ICMP::size()..]);
200 pkt.insert(ICMPSlice::from(&arr[0..ICMP::size()]));
201 pkt
202}
203pub fn parse_tcp<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
204 let mut pkt = accept(&arr[TCP::size()..]);
205 pkt.insert(TCPSlice::from(&arr[0..TCP::size()]));
206 pkt
207}
208pub fn parse_udp<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
209 let udp = UDPSlice::from(&arr[0..UDP::size()]);
210 let dst = udp.dst() as u16;
211 let mut pkt = match dst {
212 UDP_PORT_VXLAN => parse_vxlan(&arr[UDP::size()..]),
213 _ => accept(&arr[UDP::size()..]),
214 };
215 pkt.insert(udp);
216 pkt
217}
218pub fn parse_vxlan<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
219 let mut pkt = parse_ethernet(&arr[Vxlan::size()..]);
220 pkt.insert(VxlanSlice::from(&arr[0..Vxlan::size()]));
221 pkt
222}
223fn accept<'a>(arr: &'a [u8]) -> PacketSlice<'a> {
224 let mut pkt = PacketSlice::new();
225 pkt.set_payload(arr);
226 pkt
227}