feat: icmp extensions (#33)

Cargo.toml

@@ -74,6 +74,7 @@ windows-sys = { version = "0.48.0", features = [
 ] }
 
 [dev-dependencies]
+hex-literal = "0.4.1"
 rand = "0.8.5"
 test-case = "3.2.1"
 

src/tracing/constants.rs

@@ -14,3 +14,9 @@ pub const MAX_SEQUENCE_PER_ROUND: u16 = 1024;
 /// require two rounds to ensure that delayed probe responses from the immediate prior round can be
 /// detected and excluded.
 pub const MAX_SEQUENCE: u16 = u16::MAX - (MAX_SEQUENCE_PER_ROUND * 2);
+
+/// The maximum number of extensions allowed per probe response.
+pub const MAX_EXTENSIONS_PER_PROBE: usize = 8;
+
+/// The maximum number of members allowed per MPLS stack.
+pub const MAX_MPLS_MEMBERS_PER_STACK: usize = 8;

src/tracing/net.rs

@@ -8,6 +8,9 @@ mod ipv4;
 /// IPv6 implementation.
 mod ipv6;
 
+/// ICMP extensions.
+mod extension;
+
 /// Platform specific network code.
 mod platform;
 

src/tracing/net/channel.rs

@@ -91,7 +91,7 @@ impl Network for TracerChannel {
                 resp => Ok(resp),
             },
         }?;
-        if let Some(resp) = prob_response {
+        if let Some(resp) = &prob_response {
             tracing::debug!(?resp);
         }
         Ok(prob_response)

src/tracing/net/extension.rs

@@ -0,0 +1,61 @@
+use crate::tracing::constants::{MAX_EXTENSIONS_PER_PROBE, MAX_MPLS_MEMBERS_PER_STACK};
+use crate::tracing::error::TracerError;
+use crate::tracing::packet::icmp_extension::extension_object::ClassNum;
+use crate::tracing::packet::icmp_extension::extension_structure::ExtensionStructure;
+use crate::tracing::packet::icmp_extension::mpls_label_stack::MplsLabelStack;
+use crate::tracing::packet::icmp_extension::mpls_label_stack_member::MplsLabelStackMember;
+use crate::tracing::probe::{
+    MplsExtensionData, MplsExtensionMember, ProbeResponseExtension, ProbeResponseExtensions,
+};
+use crate::tracing::util::Required;
+
+impl TryFrom<&[u8]> for ProbeResponseExtensions {
+    type Error = TracerError;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        Self::try_from(ExtensionStructure::new_view(value).req()?)
+    }
+}
+
+impl TryFrom<ExtensionStructure<'_>> for ProbeResponseExtensions {
+    type Error = TracerError;
+
+    fn try_from(value: ExtensionStructure<'_>) -> Result<Self, Self::Error> {
+        let extensions = value
+            .objects()
+            .take(MAX_EXTENSIONS_PER_PROBE)
+            .map(|obj| match obj.get_class_num() {
+                ClassNum::MultiProtocolLabelSwitchingLabelStack => {
+                    MplsLabelStack::new_view(obj.payload())
+                        .req()
+                        .map(|mpls| ProbeResponseExtension::Mpls(MplsExtensionData::from(mpls)))
+                }
+                _ => Ok(ProbeResponseExtension::Unknown),
+            })
+            .collect::<Result<_, _>>()?;
+        Ok(Self { extensions })
+    }
+}
+
+impl From<MplsLabelStack<'_>> for MplsExtensionData {
+    fn from(value: MplsLabelStack<'_>) -> Self {
+        Self {
+            members: value
+                .members()
+                .take(MAX_MPLS_MEMBERS_PER_STACK)
+                .map(MplsExtensionMember::from)
+                .collect(),
+        }
+    }
+}
+
+impl From<MplsLabelStackMember<'_>> for MplsExtensionMember {
+    fn from(value: MplsLabelStackMember<'_>) -> Self {
+        Self {
+            label: value.get_label(),
+            exp: value.get_exp(),
+            bos: value.get_bos(),
+            ttl: value.get_ttl(),
+        }
+    }
+}

src/tracing/net/ipv4.rs

@@ -15,8 +15,8 @@ use crate::tracing::packet::tcp::TcpPacket;
 use crate::tracing::packet::udp::UdpPacket;
 use crate::tracing::packet::IpProtocol;
 use crate::tracing::probe::{
-    ProbeResponse, ProbeResponseData, ProbeResponseSeq, ProbeResponseSeqIcmp, ProbeResponseSeqTcp,
-    ProbeResponseSeqUdp,
+    ProbeResponse, ProbeResponseData, ProbeResponseExtensions, ProbeResponseSeq,
+    ProbeResponseSeqIcmp, ProbeResponseSeqTcp, ProbeResponseSeqUdp,
 };
 use crate::tracing::types::{PacketSize, PayloadPattern, Sequence, TraceId, TypeOfService};
 use crate::tracing::util::Required;
@@ -229,11 +229,10 @@ pub fn recv_tcp_socket(
                 }
                 if platform::is_host_unreachable_error(code) {
                     let error_addr = tcp_socket.icmp_error_info()?;
-                    return Ok(Some(ProbeResponse::TimeExceeded(ProbeResponseData::new(
-                        SystemTime::now(),
-                        error_addr,
-                        resp_seq,
-                    ))));
+                    return Ok(Some(ProbeResponse::TimeExceeded(
+                        ProbeResponseData::new(SystemTime::now(), error_addr, resp_seq),
+                        None,
+                    )));
                 }
             }
         }
@@ -332,16 +331,28 @@ fn extract_probe_resp(
     Ok(match icmp_v4.get_icmp_type() {
         IcmpType::TimeExceeded => {
             let packet = TimeExceededPacket::new_view(icmp_v4.packet()).req()?;
-            let resp_seq = extract_probe_resp_seq(packet.payload(), protocol)?;
-            Some(ProbeResponse::TimeExceeded(ProbeResponseData::new(
-                recv, src, resp_seq,
-            )))
+            let payload = packet.payload();
+            let extension = packet
+                .extension()
+                .map(ProbeResponseExtensions::try_from)
+                .transpose()?;
+            let resp_seq = extract_probe_resp_seq(payload, protocol)?;
+            Some(ProbeResponse::TimeExceeded(
+                ProbeResponseData::new(recv, src, resp_seq),
+                extension,
+            ))
         }
         IcmpType::DestinationUnreachable => {
             let packet = DestinationUnreachablePacket::new_view(icmp_v4.packet()).req()?;
-            let resp_seq = extract_probe_resp_seq(packet.payload(), protocol)?;
+            let payload = packet.payload();
+            let extension = packet
+                .extension()
+                .map(ProbeResponseExtensions::try_from)
+                .transpose()?;
+            let resp_seq = extract_probe_resp_seq(payload, protocol)?;
             Some(ProbeResponse::DestinationUnreachable(
                 ProbeResponseData::new(recv, src, resp_seq),
+                extension,
             ))
         }
         IcmpType::EchoReply => match protocol {

src/tracing/net/ipv6.rs

@@ -185,11 +185,10 @@ pub fn recv_tcp_socket(
                 }
                 if platform::is_host_unreachable_error(code) {
                     let error_addr = tcp_socket.icmp_error_info()?;
-                    return Ok(Some(ProbeResponse::TimeExceeded(ProbeResponseData::new(
-                        SystemTime::now(),
-                        error_addr,
-                        resp_seq,
-                    ))));
+                    return Ok(Some(ProbeResponse::TimeExceeded(
+                        ProbeResponseData::new(SystemTime::now(), error_addr, resp_seq),
+                        None,
+                    )));
                 }
             }
         }
@@ -263,15 +262,17 @@ fn extract_probe_resp(
         IcmpType::TimeExceeded => {
             let packet = TimeExceededPacket::new_view(icmp_v6.packet()).req()?;
             let resp_seq = extract_probe_resp_seq(packet.payload(), protocol)?;
-            Some(ProbeResponse::TimeExceeded(ProbeResponseData::new(
-                recv, ip, resp_seq,
-            )))
+            Some(ProbeResponse::TimeExceeded(
+                ProbeResponseData::new(recv, ip, resp_seq),
+                None,
+            ))
         }
         IcmpType::DestinationUnreachable => {
             let packet = DestinationUnreachablePacket::new_view(icmp_v6.packet()).req()?;
             let resp_seq = extract_probe_resp_seq(packet.payload(), protocol)?;
             Some(ProbeResponse::DestinationUnreachable(
                 ProbeResponseData::new(recv, ip, resp_seq),
+                None,
             ))
         }
         IcmpType::EchoReply => match protocol {

src/tracing/packet.rs

@@ -9,6 +9,9 @@ pub mod icmpv4;
 /// `ICMPv6` packets.
 pub mod icmpv6;
 
+/// ICMP extensions
+pub mod icmp_extension;
+
 /// `IPv4` packets.
 pub mod ipv4;
 
@@ -21,7 +24,8 @@ pub mod udp;
 /// `TCP` packets.
 pub mod tcp;
 
-fn fmt_payload(bytes: &[u8]) -> String {
+#[must_use]
+pub fn fmt_payload(bytes: &[u8]) -> String {
     use itertools::Itertools as _;
     format!("{:02x}", bytes.iter().format(" "))
 }