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.

impl<B: SplitByteSliceMut> UdpPacketRaw<B>

pub fn set_src_port(&mut self, new: u16)

Set the source port of the UDP packet.

pub fn set_dst_port(&mut self, new: NonZeroU16)

Set the destination port of the UDP packet.

pub fn update_checksum_pseudo_header_address<A: IpAddress>( &mut self, old: A, new: A, )

Update the checksum to reflect an updated address in the pseudo header.

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.