1use crate::network::parser::ParsedPacket;
4use crate::network::protocol::TransportParams;
5use crate::network::types::{Protocol, ProtocolState};
6use std::net::{Ipv4Addr, SocketAddr};
7
8pub fn parse(
23 transport_data: &[u8],
24 params: TransportParams,
25 local_ips: &std::collections::HashSet<std::net::IpAddr>,
26) -> Option<ParsedPacket> {
27 if transport_data.is_empty() {
28 return None;
29 }
30
31 let igmp_type = transport_data[0];
32
33 let group_addr = if igmp_type != 0x22 && transport_data.len() >= 8 {
37 Some(Ipv4Addr::new(
38 transport_data[4],
39 transport_data[5],
40 transport_data[6],
41 transport_data[7],
42 ))
43 } else {
44 None
45 };
46
47 let is_outgoing = local_ips.contains(¶ms.src_ip);
48
49 let (local_addr, remote_addr) = if is_outgoing {
50 (
51 SocketAddr::new(params.src_ip, 0),
52 SocketAddr::new(params.dst_ip, 0),
53 )
54 } else {
55 (
56 SocketAddr::new(params.dst_ip, 0),
57 SocketAddr::new(params.src_ip, 0),
58 )
59 };
60
61 Some(ParsedPacket {
62 protocol: Protocol::Igmp,
63 local_addr,
64 remote_addr,
65 tcp_header: None,
66 protocol_state: ProtocolState::Igmp {
67 igmp_type,
68 group_addr,
69 },
70 is_outgoing,
71 packet_len: params.packet_len,
72 dpi_result: None,
73 process_name: params.process_name,
74 process_id: params.process_id,
75 })
76}
77
78#[cfg(test)]
79mod tests {
80 use super::*;
81 use std::collections::HashSet;
82 use std::net::{IpAddr, Ipv4Addr};
83
84 fn local_ips(ip: Ipv4Addr) -> HashSet<IpAddr> {
85 let mut set = HashSet::new();
86 set.insert(IpAddr::V4(ip));
87 set
88 }
89
90 fn params(src: Ipv4Addr, dst: Ipv4Addr) -> TransportParams {
91 TransportParams::new(IpAddr::V4(src), IpAddr::V4(dst), 64, None, None)
92 }
93
94 #[test]
97 fn test_igmpv1_membership_report() {
98 let group = Ipv4Addr::new(239, 1, 2, 3);
99 let data: &[u8] = &[0x12, 0x00, 0x00, 0x00, 239, 1, 2, 3];
100 let src = Ipv4Addr::new(192, 168, 1, 1);
101 let dst = Ipv4Addr::new(239, 1, 2, 3);
102
103 let packet = parse(data, params(src, dst), &local_ips(src)).unwrap();
104
105 assert_eq!(packet.protocol, Protocol::Igmp);
106 assert!(packet.is_outgoing);
107 match packet.protocol_state {
108 ProtocolState::Igmp {
109 igmp_type,
110 group_addr,
111 } => {
112 assert_eq!(igmp_type, 0x12);
113 assert_eq!(group_addr, Some(group));
114 }
115 _ => panic!("unexpected protocol state"),
116 }
117 }
118
119 #[test]
121 fn test_igmpv2_general_query() {
122 let data: &[u8] = &[0x11, 0x64, 0x00, 0x00, 0, 0, 0, 0];
123 let src = Ipv4Addr::new(192, 168, 1, 1);
124 let dst = Ipv4Addr::new(224, 0, 0, 1);
125
126 let packet = parse(data, params(src, dst), &local_ips(src)).unwrap();
127
128 assert_eq!(packet.protocol, Protocol::Igmp);
129 assert!(packet.is_outgoing);
130 match packet.protocol_state {
131 ProtocolState::Igmp {
132 igmp_type,
133 group_addr,
134 } => {
135 assert_eq!(igmp_type, 0x11);
136 assert_eq!(group_addr, Some(Ipv4Addr::new(0, 0, 0, 0)));
137 }
138 _ => panic!("unexpected protocol state"),
139 }
140 }
141
142 #[test]
144 fn test_igmpv2_group_specific_query() {
145 let group = Ipv4Addr::new(239, 255, 255, 250);
146 let data: &[u8] = &[0x11, 0x14, 0x00, 0x00, 239, 255, 255, 250];
147 let src = Ipv4Addr::new(10, 0, 0, 1);
148 let dst = Ipv4Addr::new(239, 255, 255, 250);
149
150 let packet = parse(data, params(src, dst), &local_ips(src)).unwrap();
151
152 match packet.protocol_state {
153 ProtocolState::Igmp {
154 igmp_type,
155 group_addr,
156 } => {
157 assert_eq!(igmp_type, 0x11);
158 assert_eq!(group_addr, Some(group));
159 }
160 _ => panic!("unexpected protocol state"),
161 }
162 }
163
164 #[test]
166 fn test_igmpv2_membership_report() {
167 let group = Ipv4Addr::new(239, 255, 255, 250);
168 let data: &[u8] = &[0x16, 0x00, 0x00, 0x00, 239, 255, 255, 250];
169 let src = Ipv4Addr::new(192, 168, 0, 5);
170 let dst = Ipv4Addr::new(239, 255, 255, 250);
171
172 let packet = parse(data, params(src, dst), &local_ips(src)).unwrap();
173
174 assert!(packet.is_outgoing);
175 match packet.protocol_state {
176 ProtocolState::Igmp {
177 igmp_type,
178 group_addr,
179 } => {
180 assert_eq!(igmp_type, 0x16);
181 assert_eq!(group_addr, Some(group));
182 }
183 _ => panic!("unexpected protocol state"),
184 }
185 }
186
187 #[test]
189 fn test_igmpv2_leave_group() {
190 let group = Ipv4Addr::new(239, 255, 255, 250);
191 let data: &[u8] = &[0x17, 0x00, 0x00, 0x00, 239, 255, 255, 250];
192 let src = Ipv4Addr::new(192, 168, 0, 5);
193 let dst = Ipv4Addr::new(224, 0, 0, 2);
194
195 let packet = parse(data, params(src, dst), &local_ips(src)).unwrap();
196
197 match packet.protocol_state {
198 ProtocolState::Igmp {
199 igmp_type,
200 group_addr,
201 } => {
202 assert_eq!(igmp_type, 0x17);
203 assert_eq!(group_addr, Some(group));
204 }
205 _ => panic!("unexpected protocol state"),
206 }
207 }
208
209 #[test]
212 fn test_igmpv3_membership_report_no_group_addr() {
213 let data: &[u8] = &[0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02];
215 let src = Ipv4Addr::new(192, 168, 1, 10);
216 let dst = Ipv4Addr::new(224, 0, 0, 22);
217
218 let packet = parse(data, params(src, dst), &local_ips(src)).unwrap();
219
220 assert!(packet.is_outgoing);
221 match packet.protocol_state {
222 ProtocolState::Igmp {
223 igmp_type,
224 group_addr,
225 } => {
226 assert_eq!(igmp_type, 0x22);
227 assert_eq!(group_addr, None);
228 }
229 _ => panic!("unexpected protocol state"),
230 }
231 }
232
233 #[test]
235 fn test_incoming_direction() {
236 let data: &[u8] = &[0x11, 0x64, 0x00, 0x00, 0, 0, 0, 0];
237 let src = Ipv4Addr::new(10, 0, 0, 1);
238 let dst = Ipv4Addr::new(192, 168, 1, 5);
239 let local = Ipv4Addr::new(192, 168, 1, 5);
240
241 let packet = parse(data, params(src, dst), &local_ips(local)).unwrap();
242
243 assert!(!packet.is_outgoing);
244 assert_eq!(packet.local_addr.ip(), IpAddr::V4(local));
245 assert_eq!(packet.remote_addr.ip(), IpAddr::V4(src));
246 }
247
248 #[test]
250 fn test_empty_data_returns_none() {
251 let src = Ipv4Addr::new(192, 168, 1, 1);
252 let dst = Ipv4Addr::new(224, 0, 0, 22);
253 assert!(parse(&[], params(src, dst), &local_ips(src)).is_none());
254 }
255
256 #[test]
258 fn test_truncated_packet_no_group_addr() {
259 let data: &[u8] = &[0x16, 0x00, 0x00, 0x00]; let src = Ipv4Addr::new(192, 168, 1, 1);
261 let dst = Ipv4Addr::new(239, 255, 255, 250);
262
263 let packet = parse(data, params(src, dst), &local_ips(src)).unwrap();
264
265 match packet.protocol_state {
266 ProtocolState::Igmp {
267 igmp_type,
268 group_addr,
269 } => {
270 assert_eq!(igmp_type, 0x16);
271 assert_eq!(group_addr, None);
272 }
273 _ => panic!("unexpected protocol state"),
274 }
275 }
276}