Struct TcpSegment 

pub struct TcpSegment<B> { /* private fields */ }

A TCP segment.

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

A TcpSegment - whether parsed using parse or created using TcpSegmentBuilder - maintains the invariant that the checksum is always valid.

Implementations

impl<B: SplitByteSlice> TcpSegment<B>

pub fn options(&self) -> &TcpOptionsRef<B>

Returns the segment’s options.

pub fn body(&self) -> &[u8]

The segment body.

pub fn into_body(self) -> B

Consumes this packet and returns the body.

Note that the returned B has the same lifetime as the buffer from which this segment was parsed. By contrast, the body method returns a slice with the same lifetime as the receiver.

pub fn src_port(&self) -> NonZeroU16

The source port.

pub fn dst_port(&self) -> NonZeroU16

The destination port.

pub fn seq_num(&self) -> u32

The sequence number.

pub fn ack_num(&self) -> Option<u32>

The acknowledgement number.

If the ACK flag is not set, ack_num returns None.

pub fn psh(&self) -> bool

The PSH flag.

pub fn rst(&self) -> bool

The RST flag.

pub fn syn(&self) -> bool

The SYN flag.

pub fn fin(&self) -> bool

The FIN flag.

pub fn urg(&self) -> bool

The URG flag.

pub fn ece(&self) -> bool

The ECE flag.

pub fn cwr(&self) -> bool

The CWR flag.

pub fn flags(&self) -> u8

The segment’s flag bits: the six control flags and the two ECN flags.

pub fn reserved_bits(&self) -> u8

The segment’s reserved bits, held in the low nibble of the returned byte.

pub fn window_size(&self) -> u16

The sender’s window size.

pub fn checksum(&self) -> [u8; 2]

The TCP checksum.

pub fn header_len(&self) -> usize

The length of the header prefix and options.

pub fn total_segment_len(&self) -> usize

The length of the segment as calculated from the header prefix, options, and body.

pub fn recover_payload_partial_sum<I: Ip>( &self, src_ip: I::Addr, dst_ip: I::Addr, ) -> Result<[u8; 2], TryFromIntError>

Recovers the 1’s complement partial sum of the TCP segment body (payload) without hashing the payload bytes.

The sender computes tcp_checksum = ~(sum(pseudo_hdr) + sum(tcp_hdr_csum_zero) + sum(payload)). In 1’s complement arithmetic (RFC 1624), subtracting a sum S is equivalent to adding ~S.

Removing the pseudo header and the wire header prefix and options subtracts sum(pseudo_hdr) + sum(tcp_hdr_csum_zero) + sum(tcp_checksum). Adding tcp_checksum back cancels out the checksum field subtraction and leaves exactly ~sum(payload). Inverting that produces the partial sum sum(payload).

Returns an error if the TCP segment exceeds the maximum length representable by the IP pseudo-header.

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

Constructs a builder with the same contents as this packet.

pub fn as_bytes(&self) -> [&[u8]; 3]

Returns packet headers and the body as a list of slices.

pub fn into_builder<A: IpAddress>( self, src_ip: A, dst_ip: A, ) -> TcpSegmentBuilderWithOptions<A, TcpOptionsRef<B>>

Consumes this segment and constructs a builder with the same contents.

Unlike TcpSegment::builder, the returned builder’s options borrow from B rather than from self, so the builder can outlive this TcpSegment.

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

where B: 'a,

Consumes this segment and constructs a Serializer with the same contents.

The returned Serializer has the Buffer type EmptyBuf, which means it is not able to reuse the buffer backing this TcpSegment 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 TcpSegment was parsed rather than by the lifetime on &self, which may be more restricted.

impl<B: SplitByteSliceMut> TcpSegment<B>

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

Set the source port of the TCP packet.

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

Set the destination port of the TCP 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.

pub fn set_flags(&mut self, flags: u8)

Sets the flag bits in the segment header, updating the checksum.

Trait Implementations

impl<B: SplitByteSlice + CloneableByteSlice, A: IpAddress, C: TcpParseContext> FromRaw<TcpSegmentRaw<B>, TcpParseArgs<A, C>> for TcpSegment<B>

type Error = ParseError

The type of error that may happen during validation.

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

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

impl<B: SplitByteSlice + CloneableByteSlice, A: IpAddress, C: TcpParseContext> ParsablePacket<B, TcpParseArgs<A, C>> for TcpSegment<B>

When parsing, this type imposes a B: CloneableByteSlice bound. This is so that the type can

1. retain the original B to return the option bytes exactly as they were, and
2. have individual fields reference subsections of the B to avoid needless copies. This prevents parsing a TcpSegment from a MutableByteSlice, but we deem that acceptable because it’s not a known requirement.

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: TcpParseArgs<A, C>, ) -> 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.