Struct etherparse::SlicedPacket

pub struct SlicedPacket<'a> {
    pub link: Option<LinkSlice<'a>>,
    pub vlan: Option<VlanSlice<'a>>,
    pub net: Option<NetSlice<'a>>,
    pub transport: Option<TransportSlice<'a>>,
}

Packet slice split into multiple slices containing the different headers & payload.

Everything that could not be parsed is stored in a slice in the field “payload”.

You can use

• SlicedPacket::from_ethernet
• SlicedPacket::from_ether_type
• SlicedPacket::from_ip

depending on your starting header to slice a packet.

Examples

Basic usage:

 match SlicedPacket::from_ethernet(&packet) {
     Err(value) => println!("Err {:?}", value),
     Ok(value) => {
         println!("link: {:?}", value.link);
         println!("vlan: {:?}", value.vlan);
         println!("net: {:?}", value.net);
         println!("transport: {:?}", value.transport);
     }
 }

Fields

link: Option<LinkSlice<'a>>

Ethernet II header if present.

vlan: Option<VlanSlice<'a>>

Single or double vlan headers if present.

net: Option<NetSlice<'a>>

IPv4 or IPv6 header, IP extension headers & payload if present.

transport: Option<TransportSlice<'a>>

TCP or UDP header & payload if present.

Implementations

impl<'a> SlicedPacket<'a>

pub fn from_ethernet(data: &'a [u8]) -> Result<SlicedPacket<'_>, SliceError>

Separates a network packet slice into different slices containing the headers from the ethernet header downwards.

The result is returned as a SlicedPacket struct. This function assumes the given data starts with an ethernet II header.

Examples

Basic usage:

 match SlicedPacket::from_ethernet(&packet) {
     Err(value) => println!("Err {:?}", value),
     Ok(value) => {
         println!("link: {:?}", value.link);
         println!("vlan: {:?}", value.vlan);
         println!("net: {:?}", value.net);
         println!("transport: {:?}", value.transport);
     }
 }

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

Separates a network packet slice into different slices containing the headers using the given ether_type number to identify the first header.

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

• 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, SlicedPacket};

 match SlicedPacket::from_ether_type(ether_type::IPV4, packet) {
     Err(value) => println!("Err {:?}", value),
     Ok(value) => {
         println!("link: {:?}", value.link);
         println!("vlan: {:?}", value.vlan);
         println!("net: {:?}", value.net);
         println!("transport: {:?}", value.transport);
     }
 }

pub fn from_ip(data: &'a [u8]) -> Result<SlicedPacket<'_>, SliceError>

Separates a network packet slice into different slices containing the headers from the ip header downwards.

The result is returned as a SlicedPacket struct. This function assumes the given data starts with an IPv4 or IPv6 header.

Examples

Basic usage:

 match SlicedPacket::from_ip(&packet) {
     Err(value) => println!("Err {:?}", value),
     Ok(value) => {
         //link & vlan fields are empty when parsing from ip downwards
         assert_eq!(None, value.link);
         assert_eq!(None, value.vlan);

         //ip & transport (udp or tcp)
         println!("net: {:?}", value.net);
         println!("transport: {:?}", value.transport);
     }
 }

pub fn payload_ether_type(&self) -> Option<EtherType>

If the slice in the payload field contains an ethernet payload this method returns the ether type number describing the payload type.

The ether type number can come from an ethernet II header or a VLAN header depending on which headers are present.

In case that ip and/or transport fields are the filled None is returned, as the payload contents then are defined by a lower layer protocol described in these fields.

Trait Implementations

impl<'a> Clone for SlicedPacket<'a>

fn clone(&self) -> SlicedPacket<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for SlicedPacket<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for SlicedPacket<'a>

fn eq(&self, other: &SlicedPacket<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for SlicedPacket<'a>

impl<'a> StructuralPartialEq for SlicedPacket<'a>