Struct RawIpBody

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

An unsanitized IP packet body.

Allows packets from raw IP sockets (with a user provided IP body), to be tracked from the filtering module.

Implementations

impl<I: IpExt, B: ParseBuffer> RawIpBody<I, B>

pub fn new( protocol: I::Proto, src_addr: I::Addr, dst_addr: I::Addr, body: B, ) -> RawIpBody<I, B>

Construct a new RawIpBody from it’s parts.

Trait Implementations

impl<I: IpExt, B: ParseBuffer, IpType> GenericOverIp<IpType> for RawIpBody<I, B>

where IpType: IpExt + Ip,

type Type = RawIpBody<IpType, B>

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

impl<I: IpExt, B: ParseBuffer> MaybeTransportPacket for RawIpBody<I, B>

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

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

impl<I: IpExt, B: BufferMut> MaybeTransportPacketMut<I> for RawIpBody<I, B>

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

The type that provides access to transport-layer header modification, if this is indeed a valid transport packet.

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

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

impl<I: IpExt, B: BufferMut> Serializer for RawIpBody<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.