Struct PacketHeaders

Source

pub struct PacketHeaders<'a> {
    pub link: Option<LinkHeader>,
    pub link_exts: ArrayVec<LinkExtHeader, { PacketHeaders::LINK_EXTS_CAP }>,
    pub net: Option<NetHeaders>,
    pub transport: Option<TransportHeader>,
    pub payload: PayloadSlice<'a>,
}

Expand description

Decoded packet headers (data link layer and lower).

You can use

depending on your starting header to parse the headers in a slice and get this struct as a result.

Fields§

§link: Option<LinkHeader>

Ethernet II header if present.

§link_exts: ArrayVec<LinkExtHeader, { PacketHeaders::LINK_EXTS_CAP }>

Link extension headers (VLAN & MAC Sec headers).

§net: Option<NetHeaders>

IPv4 or IPv6 header and IP extension headers if present.

§transport: Option<TransportHeader>

TCP or UDP header if present.

§payload: PayloadSlice<'a>

Payload of the last parsed layer.

Implementations§

Source §

impl<'a> PacketHeaders<'a>

Source

pub const LINK_EXTS_CAP: usize = 3usize

Maximum supported number of link extensions headers.

Source

pub fn from_ethernet_slice( slice: &'a [u8], ) -> Result<PacketHeaders<'a>, SliceError>

Decodes a network packet into different headers from a slice that starts with an Ethernet II header.

The result is returned as a PacketHeaders struct.

§Example

Basic usage:

 use etherparse::{ether_type, PacketHeaders};

 match PacketHeaders::from_ether_type(ether_type::IPV4, packet) {
     Err(value) => println!("Err {:?}", value),
     Ok(value) => {
         println!("link: {:?}", value.link);
         println!("link_exts: {:?}", value.link_exts); // vlan & macsec
         println!("net: {:?}", value.net); // ip & arp
         println!("transport: {:?}", value.transport);
     }
 }

Source

pub fn from_ether_type( ether_type: EtherType, slice: &'a [u8], ) -> Result<PacketHeaders<'a>, SliceError>

Tries to decode a network packet into different headers using the given ether_type number to identify the first header.

The result is returned as a PacketHeaders struct. Currently supported ether type numbers are:

ether_type::ARP
ether_type::IPV4
ether_type::IPV6
ether_type::VLAN_TAGGED_FRAME
ether_type::PROVIDER_BRIDGING
ether_type::VLAN_DOUBLE_TAGGED_FRAME

If an unsupported ether type is given the given slice will be set as payload and all other fields will be set to None.

§Example

Basic usage:

 use etherparse::{ether_type, PacketHeaders};

 match PacketHeaders::from_ether_type(ether_type::IPV4, packet) {
     Err(value) => println!("Err {:?}", value),
     Ok(value) => {
         println!("link: {:?}", value.link);
         println!("link_exts: {:?}", value.link_exts); // vlan & macsec
         println!("net: {:?}", value.net); // ip & arp
         println!("transport: {:?}", value.transport);
     }
 }

Source

pub fn from_ip_slice(slice: &[u8]) -> Result<PacketHeaders<'_>, SliceError>

Tries to decode an ip packet and its transport headers.

Assumes the given slice starts with the first byte of the IP header.

§Example

Basic usage:

use etherparse::PacketHeaders;

match PacketHeaders::from_ip_slice(&packet) {
    Err(value) => println!("Err {:?}", value),
    Ok(value) => {
        println!("link: {:?}", value.link);
        println!("link_exts: {:?}", value.link_exts); // vlan & macsec
        println!("net: {:?}", value.net); // ip & arp
        println!("transport: {:?}", value.transport);
    }
}