Struct ForwardedPacket

pub struct ForwardedPacket<I: IpExt, B> { /* private fields */ }

An incoming IP packet that is being forwarded.

Implementations

impl<I: IpExt, B: BufferMut> ForwardedPacket<I, B>

pub fn new( src_addr: I::Addr, dst_addr: I::Addr, protocol: I::Proto, meta: ParseMetadata, buffer: B, ) -> Self

Create a new ForwardedPacket from its IP header fields and payload.

meta is used to revert buffer back to the IP header for further serialization, and to mark where the transport header starts in buffer. It must have originated from a previously parsed IP packet on buffer.

pub fn into_buffer(self) -> B

Discard the metadata carried by the ForwardedPacket and return the inner buffer.

The returned buffer is guaranteed to contain a valid IP frame, the start of the buffer points at the start of the IP header.

pub fn buffer(&self) -> &B

Returns a reference to the forwarded buffer.

The returned reference is guaranteed to contain a valid IP frame, the start of the buffer points at the start of the IP header.

Trait Implementations

impl<I: Debug + IpExt, B: Debug> Debug for ForwardedPacket<I, B>

where I::Addr: Debug, I::Proto: Debug,

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

Formats the value using the given formatter.

impl<I: IpExt, B, IpType> GenericOverIp<IpType> for ForwardedPacket<I, B>

where IpType: IpExt + Ip,

type Type = ForwardedPacket<IpType, B>

The type of Self when its IP-generic parameter is replaced with the type NewIp.

impl<I: IpExt, B: BufferMut> IpPacket<I> for ForwardedPacket<I, B>

type TransportPacket<'a> = &'a ForwardedPacket<I, B> where Self: 'a

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

type TransportPacketMut<'a> = Option<ParsedTransportHeaderMut<'a, I>> where Self: 'a

The type that provides access to transport-layer header modification, 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 set_src_addr(&mut self, addr: I::Addr)

Sets the source IP address of the packet.

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

The destination IP address of the packet.

fn set_dst_addr(&mut self, addr: I::Addr)

Sets the destination IP address of the packet.

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

The IP protocol of the packet.

fn maybe_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.

fn transport_packet_mut(&mut self) -> Self::TransportPacketMut<'_>

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

impl<I: IpExt, B: BufferMut> MaybeTransportPacket for ForwardedPacket<I, B>

fn transport_packet_data(&self) -> Option<TransportPacketData>

Optionally returns a type that provides access to this transport-layer packet.

impl<I: PartialEq + IpExt, B: PartialEq> PartialEq for ForwardedPacket<I, B>

where I::Addr: PartialEq, I::Proto: PartialEq,

fn eq(&self, other: &ForwardedPacket<I, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<I: IpExt, B: BufferMut> Serializer for ForwardedPacket<I, B>

type Buffer = <B 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_new_buf<BB: ReusableBuffer, A: BufferAlloc<BB>>( &self, outer: PacketConstraints, alloc: A, ) -> Result<BB, SerializeError<A::Error>>

Serializes the data into a new buffer without consuming self.

fn serialize_vec( self, outer: PacketConstraints, ) -> Result<Either<Self::Buffer, Buf<Vec<u8>>>, (SerializeError<Infallible>, Self)>

where Self::Buffer: ReusableBuffer,

Serializes this Serializer, allocating a Buf<Vec<u8>> if the contained buffer isn’t large enough.

fn serialize_no_alloc( self, outer: PacketConstraints, ) -> Result<Self::Buffer, (SerializeError<BufferTooShortError>, Self)>

where Self::Buffer: ReusableBuffer,

Serializes this Serializer, failing if the existing buffer is not large enough.

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 serialize_vec_outer( self, ) -> Result<Either<Self::Buffer, Buf<Vec<u8>>>, (SerializeError<Infallible>, Self)>

where Self::Buffer: ReusableBuffer,

Serializes this Serializer as the outermost packet, allocating a Buf<Vec<u8>> if the contained buffer isn’t large enough.

fn serialize_no_alloc_outer( self, ) -> Result<Self::Buffer, (SerializeError<BufferTooShortError>, Self)>

where Self::Buffer: ReusableBuffer,

Serializes this Serializer as the outermost packet, failing if the existing buffer is not large enough.

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.

impl<I: IpExt, B> StructuralPartialEq for ForwardedPacket<I, B>