Struct IcmpTracerouteMsgPart

Source

#[repr(C, packed(1))]pub struct IcmpTracerouteMsgPart {
    pub hops_out: [u8; 2],
    pub hops_in: [u8; 2],
    pub bandwidth_out: [u8; 4],
    pub mtu_out: [u8; 4],
}

Expand description

Represents the variable length portion of a Traceroute message (RFC 1393) that follows the ICMP header.

Contains hop counts, bandwidth, and MTU information about the traced route. All fields are stored in network byte order.

§Example

use core::mem;
use aya_ebpf::programs::TcContext;
use network_types::eth::EthHdr;
use network_types::icmp::{IcmpHdr, IcmpTracerouteMsgPart};
use network_types::ip::Ipv4Hdr;

fn handle_icmp_traceroute(ctx: &TcContext) -> Result<u32, ()> {
    // Parse the ICMP header from start of payload
    let icmp_start = ctx.data() + EthHdr::LEN + Ipv4Hdr::LEN;
    let icmp: *const IcmpHdr = icmp_start as *const IcmpHdr;
     
    // Check if it's a Traceroute message (type 30)
    // Ensure 'icmp' is within bounds before dereferencing.
    // if (icmp as *const u8).add(IcmpHdr::LEN) > ctx.data_end() { return Err(()); }
    if unsafe { (*icmp).type_ } == 30 {
        // Access the traceroute part that follows the header
        let traceroute_ptr: *const IcmpTracerouteMsgPart = unsafe {
            (icmp_start as *const u8)
                .add(IcmpHdr::LEN) as *const IcmpTracerouteMsgPart
        };

        // Before dereferencing traceroute_ptr, ensure it's within packet bounds.
        // For example:
        // if (traceroute_ptr as *const u8).add(IcmpTracerouteMsgPart::LEN) > ctx.data_end() {
        //     aya_log_ebpf::error!(ctx, "Traceroute part out of bounds");
        //     return Err(());
        // }

        // Safely get a reference to IcmpTracerouteMsgPart
        if let Some(traceroute_ref) = unsafe { traceroute_ptr.as_ref() } {
            // Now you can read the traceroute fields in network byte order
            let hops_out = traceroute_ref.hops_out();
            let bandwidth = traceroute_ref.bandwidth_out();
            let mtu = traceroute_ref.mtu_out();

            // You can now use hops_out, bandwidth, mtu
            // For example, in a real eBPF program, you might log them or store them in a map.
            // aya_log_ebpf::info!(ctx, "Hops: {}, BW: {}, MTU: {}", hops_out, bandwidth, mtu);
        } else {
            // Handle the case where traceroute_ptr is null or misaligned.
            // This indicates an issue, possibly a malformed packet.
            // aya_log_ebpf::error!(ctx, "Failed to get reference to IcmpTracerouteMsgPart: pointer invalid");
            return Err(()); // Or other appropriate error handling
        }
    }
    Ok(0)
}

Fields§

§hops_out: [u8; 2]§hops_in: [u8; 2]§bandwidth_out: [u8; 4]§mtu_out: [u8; 4]

Implementations§

Source §

impl IcmpTracerouteMsgPart

Source

pub const LEN: usize = 12usize

Source

pub fn hops_out(&self) -> u16

Returns the outbound hop count in host byte order. This indicates the maximum number of hops that can be traversed to the target.

Source

pub fn set_hops_out(&mut self, hops: u16)

Sets the outbound hop count field. The value will be stored in network byte order. This should be set to the maximum number of hops that can be traversed to the target.

Source

pub fn hops_in(&self) -> u16

Returns the inbound hop count in host byte order. This indicates the maximum number of hops that can be traversed in the return path.

Source

pub fn set_hops_in(&mut self, hops: u16)

Sets the inbound hop count field. The value will be stored in network byte order. This should be set to the maximum number of hops that can be traversed in the return path.

Source

pub fn bandwidth_out(&self) -> u32

Returns the outbound bandwidth estimate in host byte order. This represents the minimum bandwidth along the forward path in bytes per second.

Source

pub fn set_bandwidth_out(&mut self, bandwidth: u32)

Sets the outbound bandwidth field. The value will be stored in network byte order. This should be set to the minimum bandwidth along the forward path in bytes per second.

Source