Struct netstack3_filter::NestedWithInnerIpPacket

pub struct NestedWithInnerIpPacket<Inner, Outer>(/* private fields */);

A nested serializer whose inner serializer implements IpPacket.

[packet::Nested] is often used to represent an outer IP packet serializer and an inner payload contained by the IP packet. However, in some cases, a type that implements IpPacket may itself be wrapped in an outer serializer, such as (for example) a [packet::LimitedSizePacketBuilder] for enforcing an MTU. In that scenario, the Nested serializer can be wrapped in this type to indicate that the IpPacket implementation should be delegated to the inner serializer.

Implementations

impl<Inner, Outer> NestedWithInnerIpPacket<Inner, Outer>

pub fn new(nested: Nested<Inner, Outer>) -> Self

Creates a new NestedWithInnerIpPacket wrapping the provided nested serializer.

pub fn into_inner(self) -> Inner

Calls [Nested::into_inner] on the contained nested serializer.

Trait Implementations

impl<I: IpExt, Inner: IpPacket<I>, Outer> IpPacket<I> for NestedWithInnerIpPacket<Inner, Outer>

type TransportPacket<'a> = <Inner as IpPacket<I>>::TransportPacket<'a> where Inner: 'a, Outer: 'a

The type that provides access to transport-layer header inspection, if a transport header is contained in the body of the IP packet.

fn src_addr(&self) -> I::Addr

The source IP address of the packet.

fn dst_addr(&self) -> I::Addr

The destination IP address of the packet.

fn protocol(&self) -> I::Proto

The IP protocol of the packet.

fn transport_packet(&self) -> Self::TransportPacket<'_>

Returns a type that provides access to the transport-layer packet contained in the body of the IP packet, if one exists.

impl<Inner, Outer> Serializer for NestedWithInnerIpPacket<Inner, Outer>

where Nested<Inner, Outer>: Serializer,

type Buffer = <Nested<Inner, Outer> as Serializer>::Buffer

The type of buffers returned from serialization methods on this trait.

fn serialize<G: GrowBufferMut, P: BufferProvider<Self::Buffer, G>>( self, outer: PacketConstraints, provider: P ) -> Result<G, (SerializeError<P::Error>, Self)>

Serializes this Serializer, producing a buffer.

fn serialize_outer<B, P>( self, provider: P ) -> Result<B, (SerializeError<<P as BufferProvider<Self::Buffer, B>>::Error>, Self)>

where B: GrowBufferMut, P: BufferProvider<Self::Buffer, B>,

Serializes this Serializer as the outermost packet.

fn encapsulate<B>(self, outer: B) -> Nested<Self, B>

Encapsulates this Serializer in another packet, producing a new Serializer.

fn with_size_limit(self, limit: usize) -> Nested<Self, LimitedSizePacketBuilder>

Creates a new Serializer which will enforce a size limit.