Skip to main content

rustnet_core/network/protocol/
igmp.rs

1//! IGMP (Internet Group Management Protocol) parsing
2
3use crate::network::parser::ParsedPacket;
4use crate::network::protocol::TransportParams;
5use crate::network::types::{Protocol, ProtocolState};
6use std::net::{Ipv4Addr, SocketAddr};
7
8/// Parse an IGMP packet
9///
10/// IGMPv1/v2 header layout:
11/// - Byte 0: Type
12/// - Byte 1: Max Response Time
13/// - Bytes 2–3: Checksum
14/// - Bytes 4–7: Group Address
15///
16/// IGMPv3 Membership Report (type 0x22) layout:
17/// - Byte 0: Type
18/// - Byte 1: Max Response Time
19/// - Bytes 2–3: Checksum
20/// - Bytes 4–5: Reserved
21/// - Bytes 6–7: Number of Group Records
22pub 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    // IGMPv3 Membership Reports (0x22) have no single group address —
34    // bytes 4–5 are reserved and bytes 6–7 are the number of group records.
35    // Only IGMPv1/v2 messages carry a group address in bytes 4–7.
36    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(&params.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    // IGMPv1 Membership Report (type 0x12)
95    // Header: [type, unused, checksum(2), group_addr(4)]
96    #[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    // IGMPv2 General Membership Query (type 0x11, group addr = 0.0.0.0)
120    #[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    // IGMPv2 Group-Specific Query (type 0x11, group addr set)
143    #[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    // IGMPv2 Membership Report (type 0x16)
165    #[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    // IGMPv2 Leave Group (type 0x17)
188    #[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    // IGMPv3 Membership Report (type 0x22): bytes 4-5 reserved, 6-7 = num records
210    // group_addr must be None
211    #[test]
212    fn test_igmpv3_membership_report_no_group_addr() {
213        // 2 group records
214        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    // Incoming packet: src is not a local IP, so is_outgoing must be false
234    #[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    // Empty data must return None
249    #[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    // Truncated packet (< 8 bytes) yields no group_addr
257    #[test]
258    fn test_truncated_packet_no_group_addr() {
259        let data: &[u8] = &[0x16, 0x00, 0x00, 0x00]; // only 4 bytes
260        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}