Struct TcpSegmentRaw

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

A partially-parsed and not yet validated TCP segment.

A TcpSegmentRaw 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 TcpSegmentRaw from raw data will succeed as long as at least 4 bytes are available, which will be extracted as a TcpFlowHeader that contains the TCP source and destination ports. A TcpSegmentRaw is, then, guaranteed to always have at least that minimal information available.

TcpSegment provides a [FromRaw] implementation that can be used to validate a TcpSegmentRaw.

Implementations

impl<B: SplitByteSlice> TcpSegmentRaw<B>

pub fn flow_header(&self) -> TcpFlowHeader

Gets the flow header from this packet.

pub fn builder<A: IpAddress>( &self, src_ip: A, dst_ip: A, ) -> Option<TcpSegmentBuilderWithOptions<A, ArrayVec<u8, MAX_OPTIONS_LEN>>>

Constructs a builder with the same contents as this packet.

Returns None if an entire TCP header was not successfully parsed.

Note that, since TcpSegmentRaw does not validate its header fields, it’s possible for builder to produce a TcpSegmentBuilder which describes an invalid TCP segment, or one which this module is not capable of building from scratch. In particular:

• The source or destination ports may be zero, which is illegal (these ports are reserved in IANA’s Service Name and Transport Protocol Port Number Registry).
• The ACK number may be nonzero even though the ACK flag is not set. This is not illegal according to RFC 793, but it’s possible that some implementations expect it not to happen.
• Some of the reserved zero bits between the Data Offset and Flags fields may be set. This may be due to a noncompliant implementation or a future change to TCP which makes use of these bits.

pub fn into_builder_options<A: IpAddress>( self, src_ip: A, dst_ip: A, ) -> Option<(TcpSegmentBuilder<A>, Records<B, TcpOptionsImpl>, B)>

Transform this TcpSegmentRaw into the equivalent builder, parsed options, and body.

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 segment and constructs a [Serializer] with the same contents.

Returns None if an entire TCP header was not successfully 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 TcpSegmentRaw 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 TcpSegmentRaw was parsed rather than by the lifetime on &self, which may be more restricted.

Trait Implementations

impl<B: SplitByteSlice, A: IpAddress> FromRaw<TcpSegmentRaw<B>, TcpParseArgs<A>> for TcpSegment<B>

type Error = ParseError

The type of error that may happen during validation.

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

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

impl<B> ParsablePacket<B, ()> for TcpSegmentRaw<B>

where B: SplitByteSlice,

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: ()) -> 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.