Struct UdpPacketRaw

pub struct UdpPacketRaw<B: SplitByteSlice> { /* private fields */ }

A partially-parsed and not yet validated UDP packet.

A UdpPacketRaw shares its underlying memory with the byte slice it was parsed from or serialized to, meaning that no copying or extra allocation is necessary.

Parsing a UdpPacketRaw from raw data will succeed as long as at least 4 bytes are available, which will be extracted as a [UdpFlowHeader] that contains the UDP source and destination ports. A UdpPacketRaw is, then, guaranteed to always have at least that minimal information available.

UdpPacket provides a [FromRaw] implementation that can be used to validate a UdpPacketRaw.

Implementations

impl<B: SplitByteSlice> UdpPacketRaw<B>

pub fn src_port(&self) -> Option<NonZeroU16>

The source UDP port, if any.

The source port is optional, and may have been omitted by the sender.

pub fn dst_port(&self) -> Option<NonZeroU16>

The destination UDP port.

UDP packets must not have a destination port of 0; thus, if this function returns None, then the packet is malformed.

pub fn builder<A: IpAddress>(&self, src_ip: A, dst_ip: A) -> UdpPacketBuilder<A>

Constructs a builder with the same contents as this packet.

Note that, since UdpPacketRaw does not validate its header fields, it’s possible for builder to produce a UdpPacketBuilder which describes an invalid UDP packet. In particular, it’s possible that its destination port will be zero, which is illegal.

pub fn into_serializer<'a, A: IpAddress>( self, src_ip: A, dst_ip: A, ) -> Option<impl Serializer<Buffer = EmptyBuf> + 'a>

where B: 'a,

Consumes this packet and constructs a [Serializer] with the same contents.

Returns None if the body was not fully parsed.

This method has the same validity caveats as builder.

The returned Serializer has the Buffer type [EmptyBuf], which means it is not able to reuse the buffer backing this UdpPacket when serializing, and will always need to allocate a new buffer.

By consuming self instead of taking it by-reference, into_serializer is able to return a Serializer whose lifetime is restricted by the lifetime of the buffer from which this UdpPacket was parsed rather than by the lifetime on &self, which may be more restricted.

Trait Implementations

impl<B: SplitByteSlice, A: IpAddress> FromRaw<UdpPacketRaw<B>, UdpParseArgs<A>> for UdpPacket<B>

type Error = ParseError

The type of error that may happen during validation.

fn try_from_raw_with( raw: UdpPacketRaw<B>, args: UdpParseArgs<A>, ) -> Result<Self, Self::Error>

Attempts to create Self from the raw form in raw with args.

impl<B, I> ParsablePacket<B, IpVersionMarker<I>> for UdpPacketRaw<B>

where B: SplitByteSlice, I: Ip,

type Error = ParseError

The type of errors returned from parse and parse_mut.

fn parse_metadata(&self) -> ParseMetadata

Gets metadata about this packet required by [GrowBuffer::undo_parse].

fn parse<BV: BufferView<B>>( buffer: BV, _args: IpVersionMarker<I>, ) -> ParseResult<Self>

Parses a packet from a buffer.

fn parse_mut<BV>(buffer: BV, args: ParseArgs) -> Result<Self, Self::Error>

where BV: BufferViewMut<B>, B: SplitByteSliceMut,

Parses a packet from a mutable buffer.