netstack3_base/tcp/
segment.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! The definition of a TCP segment.
6
7use crate::alloc::borrow::ToOwned;
8use core::borrow::Borrow;
9use core::convert::TryFrom as _;
10use core::fmt::Debug;
11use core::mem::MaybeUninit;
12use core::num::{NonZeroU16, TryFromIntError};
13use core::ops::Range;
14
15use arrayvec::ArrayVec;
16use log::info;
17use net_types::ip::IpAddress;
18use packet::records::options::OptionSequenceBuilder;
19use packet::InnerSerializer;
20use packet_formats::tcp::options::{TcpOption, TcpSackBlock};
21use packet_formats::tcp::{TcpSegment, TcpSegmentBuilder, TcpSegmentBuilderWithOptions};
22use thiserror::Error;
23
24use super::base::{Control, Mss};
25use super::seqnum::{SeqNum, UnscaledWindowSize, WindowScale, WindowSize};
26
27/// A TCP segment.
28#[derive(Debug, PartialEq, Eq, Clone)]
29pub struct Segment<P> {
30    /// The non-payload information of the segment.
31    pub header: SegmentHeader,
32    /// The data carried by the segment.
33    ///
34    /// It is guaranteed that data.len() plus the length of the control flag
35    /// (SYN or FIN) is <= MAX_PAYLOAD_AND_CONTROL_LEN
36    pub data: P,
37}
38
39/// All non-data portions of a TCP segment.
40#[derive(Debug, PartialEq, Eq, Clone)]
41pub struct SegmentHeader {
42    /// The sequence number of the segment.
43    pub seq: SeqNum,
44    /// The acknowledge number of the segment. [`None`] if not present.
45    pub ack: Option<SeqNum>,
46    /// The advertised window size.
47    pub wnd: UnscaledWindowSize,
48    /// The control flag of the segment.
49    pub control: Option<Control>,
50    /// Options carried by this segment.
51    pub options: Options,
52}
53
54/// Contains all supported TCP options.
55#[derive(Debug, PartialEq, Eq, Clone)]
56pub enum Options {
57    /// Options present in a handshake segment.
58    Handshake(HandshakeOptions),
59    /// Options present in a regular segment.
60    Segment(SegmentOptions),
61}
62
63impl Default for Options {
64    fn default() -> Self {
65        // Default to a non handshake options value, since those are more
66        // common.
67        Self::Segment(SegmentOptions::default())
68    }
69}
70
71impl From<HandshakeOptions> for Options {
72    fn from(value: HandshakeOptions) -> Self {
73        Self::Handshake(value)
74    }
75}
76
77impl From<SegmentOptions> for Options {
78    fn from(value: SegmentOptions) -> Self {
79        Self::Segment(value)
80    }
81}
82
83impl Options {
84    /// Returns an iterator over the contained options.
85    pub fn iter(&self) -> impl Iterator<Item = TcpOption<'_>> + Debug + Clone {
86        match self {
87            Options::Handshake(o) => either::Either::Left(o.iter()),
88            Options::Segment(o) => either::Either::Right(o.iter()),
89        }
90    }
91
92    fn as_handshake(&self) -> Option<&HandshakeOptions> {
93        match self {
94            Self::Handshake(h) => Some(h),
95            Self::Segment(_) => None,
96        }
97    }
98
99    fn as_handshake_mut(&mut self) -> Option<&mut HandshakeOptions> {
100        match self {
101            Self::Handshake(h) => Some(h),
102            Self::Segment(_) => None,
103        }
104    }
105
106    fn as_segment(&self) -> Option<&SegmentOptions> {
107        match self {
108            Self::Handshake(_) => None,
109            Self::Segment(s) => Some(s),
110        }
111    }
112
113    fn as_segment_mut(&mut self) -> Option<&mut SegmentOptions> {
114        match self {
115            Self::Handshake(_) => None,
116            Self::Segment(s) => Some(s),
117        }
118    }
119
120    /// Returns a new empty [`Options`] with the variant dictated by
121    /// `handshake`.
122    pub fn new_with_handshake(handshake: bool) -> Self {
123        if handshake {
124            Self::Handshake(Default::default())
125        } else {
126            Self::Segment(Default::default())
127        }
128    }
129
130    /// Creates a new [`Options`] from an iterator of TcpOption.
131    ///
132    /// If `handshake` is `true`, only the handshake options will be parsed.
133    /// Otherwise only the non-handshake options are parsed.
134    pub fn from_iter<'a>(handshake: bool, iter: impl IntoIterator<Item = TcpOption<'a>>) -> Self {
135        let mut options = Self::new_with_handshake(handshake);
136        for option in iter {
137            match option {
138                TcpOption::Mss(mss) => {
139                    if let Some(h) = options.as_handshake_mut() {
140                        h.mss = NonZeroU16::new(mss).map(Mss);
141                    }
142                }
143                TcpOption::WindowScale(ws) => {
144                    if let Some(h) = options.as_handshake_mut() {
145                        // Per RFC 7323 Section 2.3:
146                        //   If a Window Scale option is received with a shift.cnt
147                        //   value larger than 14, the TCP SHOULD log the error but
148                        //   MUST use 14 instead of the specified value.
149                        if ws > WindowScale::MAX.get() {
150                            info!(
151                                "received an out-of-range window scale: {}, want < {}",
152                                ws,
153                                WindowScale::MAX.get()
154                            );
155                        }
156                        h.window_scale = Some(WindowScale::new(ws).unwrap_or(WindowScale::MAX));
157                    }
158                }
159                TcpOption::SackPermitted => {
160                    if let Some(h) = options.as_handshake_mut() {
161                        h.sack_permitted = true;
162                    }
163                }
164                TcpOption::Sack(sack) => {
165                    if let Some(seg) = options.as_segment_mut() {
166                        seg.sack_blocks = SackBlocks::from_option(sack);
167                    }
168                }
169                // TODO(https://fxbug.dev/42072902): We don't support these yet.
170                TcpOption::Timestamp { ts_val: _, ts_echo_reply: _ } => {}
171            }
172        }
173        options
174    }
175
176    /// Reads the window scale if this is an [`Options::Handshake`].
177    pub fn window_scale(&self) -> Option<WindowScale> {
178        self.as_handshake().and_then(|h| h.window_scale)
179    }
180
181    /// Reads the mss option if this is an [`Options::Handshake`].
182    pub fn mss(&self) -> Option<Mss> {
183        self.as_handshake().and_then(|h| h.mss)
184    }
185
186    /// Returns true IFF this is an [`Options::Handshake`] and its
187    /// [`HandShakeOptions::sack_permitted`] is set.
188    pub fn sack_permitted(&self) -> bool {
189        self.as_handshake().is_some_and(|o| o.sack_permitted)
190    }
191
192    /// Returns the segment's selective ack blocks.
193    ///
194    /// Returns a reference to empty blocks if this is not [`Options::Segment`].
195    pub fn sack_blocks(&self) -> &SackBlocks {
196        const EMPTY_REF: &'static SackBlocks = &SackBlocks::EMPTY;
197        self.as_segment().map(|s| &s.sack_blocks).unwrap_or(EMPTY_REF)
198    }
199}
200
201/// Segment options only set on handshake.
202#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
203pub struct HandshakeOptions {
204    /// The MSS option.
205    pub mss: Option<Mss>,
206
207    /// The WS option.
208    pub window_scale: Option<WindowScale>,
209
210    /// The SACK permitted option.
211    pub sack_permitted: bool,
212}
213
214impl HandshakeOptions {
215    /// Returns an iterator over the contained options.
216    pub fn iter(&self) -> impl Iterator<Item = TcpOption<'_>> + Debug + Clone {
217        let Self { mss, window_scale, sack_permitted } = self;
218        mss.map(|mss| TcpOption::Mss(mss.get().get()))
219            .into_iter()
220            .chain(window_scale.map(|ws| TcpOption::WindowScale(ws.get())))
221            .chain((*sack_permitted).then_some(TcpOption::SackPermitted))
222    }
223}
224
225/// Segment options set on non-handshake segments.
226#[derive(Debug, Default, PartialEq, Eq, Clone)]
227pub struct SegmentOptions {
228    /// The SACK option.
229    pub sack_blocks: SackBlocks,
230}
231
232impl SegmentOptions {
233    /// Returns an iterator over the contained options.
234    pub fn iter(&self) -> impl Iterator<Item = TcpOption<'_>> + Debug + Clone {
235        let Self { sack_blocks } = self;
236        sack_blocks.as_option().into_iter()
237    }
238}
239
240const MAX_SACK_BLOCKS: usize = 4;
241/// Blocks of selective ACKs.
242#[derive(Debug, Default, PartialEq, Eq, Clone)]
243pub struct SackBlocks(ArrayVec<TcpSackBlock, MAX_SACK_BLOCKS>);
244
245impl SackBlocks {
246    /// A constant empty instance of SACK blocks.
247    pub const EMPTY: Self = SackBlocks(ArrayVec::new_const());
248
249    /// The maximum number of selective ack blocks that can be in a TCP segment.
250    ///
251    /// See [RFC 2018 section 3].
252    ///
253    /// [RFC 2018 section 3] https://www.rfc-editor.org/rfc/rfc2018#section-3
254    pub const MAX_BLOCKS: usize = MAX_SACK_BLOCKS;
255
256    /// Returns the contained selective ACKs as a TCP option.
257    ///
258    /// Returns `None` if this [`SackBlocks`] is empty.
259    pub fn as_option(&self) -> Option<TcpOption<'_>> {
260        let Self(inner) = self;
261        if inner.is_empty() {
262            return None;
263        }
264
265        Some(TcpOption::Sack(inner.as_slice()))
266    }
267
268    /// Returns an iterator over the *valid* [`SackBlock`]s contained in this
269    /// option.
270    pub fn iter_skip_invalid(&self) -> impl Iterator<Item = SackBlock> + '_ {
271        self.try_iter().filter_map(|r| match r {
272            Ok(s) => Some(s),
273            Err(InvalidSackBlockError(_, _)) => None,
274        })
275    }
276
277    /// Returns an iterator yielding the results of converting the blocks in
278    /// this option to valid [`SackBlock`]s.
279    pub fn try_iter(&self) -> impl Iterator<Item = Result<SackBlock, InvalidSackBlockError>> + '_ {
280        let Self(inner) = self;
281        inner.iter().map(|block| SackBlock::try_from(*block))
282    }
283
284    /// Creates a new [`SackBlocks`] option from a slice of blocks seen in a TCP
285    /// segment.
286    ///
287    /// Ignores any blocks past [`SackBlocks::MAX_BLOCKS`].
288    pub fn from_option(blocks: &[TcpSackBlock]) -> Self {
289        Self(blocks.iter().take(Self::MAX_BLOCKS).copied().collect())
290    }
291
292    /// Returns `true` if there are no blocks present.
293    pub fn is_empty(&self) -> bool {
294        let Self(inner) = self;
295        inner.is_empty()
296    }
297
298    /// Drops all blocks.
299    pub fn clear(&mut self) {
300        let Self(inner) = self;
301        inner.clear()
302    }
303}
304
305/// Creates a new [`SackBlocks`] option from an iterator of [`SackBlock`].
306///
307/// Ignores any blocks past [`SackBlocks::MAX_BLOCKS`].
308impl FromIterator<SackBlock> for SackBlocks {
309    fn from_iter<T: IntoIterator<Item = SackBlock>>(iter: T) -> Self {
310        Self(iter.into_iter().take(Self::MAX_BLOCKS).map(|b| b.into()).collect())
311    }
312}
313
314mod sack_block {
315    use super::*;
316
317    /// A selective ACK block.
318    ///
319    /// Contains the left and right markers for a received data segment. It is a
320    /// witness for a valid non empty open range of `SeqNum`.
321    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
322    pub struct SackBlock {
323        // NB: We don't use core::ops::Range here because it doesn't implement Copy.
324        left: SeqNum,
325        right: SeqNum,
326    }
327
328    impl SackBlock {
329        /// Attempts to create a new [`SackBlock`] with the range `[left, right)`.
330        ///
331        /// Returns an error if `right` is at or before `left`.
332        pub fn try_new(left: SeqNum, right: SeqNum) -> Result<Self, InvalidSackBlockError> {
333            if right.after(left) {
334                Ok(Self { left, right })
335            } else {
336                Err(InvalidSackBlockError(left, right))
337            }
338        }
339
340        /// Creates a new [`SackBlock`] without checking that `right` is
341        /// strictly after `left`.
342        ///
343        /// # Safety
344        ///
345        /// Caller must guarantee that `right.after(left)`.
346        pub unsafe fn new_unchecked(left: SeqNum, right: SeqNum) -> Self {
347            Self { left, right }
348        }
349
350        /// Consumes this [`SackBlock`] returning a [`Range`] representation.
351        pub fn into_range(self) -> Range<SeqNum> {
352            let Self { left, right } = self;
353            Range { start: left, end: right }
354        }
355
356        /// Consumes this [`SackBlock`] returning a [`Range`] representation
357        /// unwrapping the [`SeqNum`] representation into `u32`.
358        pub fn into_range_u32(self) -> Range<u32> {
359            let Self { left, right } = self;
360            Range { start: left.into(), end: right.into() }
361        }
362
363        /// Returns the left (inclusive) edge of the block.
364        pub fn left(&self) -> SeqNum {
365            self.left
366        }
367
368        /// Returns the right (exclusive) edge of the block.
369        pub fn right(&self) -> SeqNum {
370            self.right
371        }
372
373        /// Returns a tuple of the left (inclusive) and right (exclusive) edges
374        /// of the block.
375        pub fn into_parts(self) -> (SeqNum, SeqNum) {
376            let Self { left, right } = self;
377            (left, right)
378        }
379    }
380
381    /// Error returned when attempting to create a [`SackBlock`] with an invalid
382    /// range (i.e. right edge <= left edge).
383    #[derive(Debug, Eq, PartialEq, Clone, Copy)]
384    pub struct InvalidSackBlockError(pub SeqNum, pub SeqNum);
385
386    impl From<SackBlock> for TcpSackBlock {
387        fn from(value: SackBlock) -> Self {
388            let SackBlock { left, right } = value;
389            TcpSackBlock::new(left.into(), right.into())
390        }
391    }
392
393    impl TryFrom<TcpSackBlock> for SackBlock {
394        type Error = InvalidSackBlockError;
395
396        fn try_from(value: TcpSackBlock) -> Result<Self, Self::Error> {
397            Self::try_new(value.left_edge().into(), value.right_edge().into())
398        }
399    }
400
401    impl From<SackBlock> for Range<SeqNum> {
402        fn from(value: SackBlock) -> Self {
403            value.into_range()
404        }
405    }
406
407    impl TryFrom<Range<SeqNum>> for SackBlock {
408        type Error = InvalidSackBlockError;
409
410        fn try_from(value: Range<SeqNum>) -> Result<Self, Self::Error> {
411            let Range { start, end } = value;
412            Self::try_new(start, end)
413        }
414    }
415}
416pub use sack_block::{InvalidSackBlockError, SackBlock};
417
418/// The maximum length that the sequence number doesn't wrap around.
419pub const MAX_PAYLOAD_AND_CONTROL_LEN: usize = 1 << 31;
420// The following `as` is sound because it is representable by `u32`.
421const MAX_PAYLOAD_AND_CONTROL_LEN_U32: u32 = MAX_PAYLOAD_AND_CONTROL_LEN as u32;
422
423impl<P: Payload> Segment<P> {
424    /// Creates a new segment with data and options.
425    ///
426    /// Returns the segment along with how many bytes were removed to make sure
427    /// sequence numbers don't wrap around, i.e., `seq.before(seq + seg.len())`.
428    pub fn with_data_options(
429        seq: SeqNum,
430        ack: Option<SeqNum>,
431        control: Option<Control>,
432        wnd: UnscaledWindowSize,
433        data: P,
434        options: Options,
435    ) -> (Self, usize) {
436        let has_control_len = control.map(Control::has_sequence_no).unwrap_or(false);
437
438        let discarded_len =
439            data.len().saturating_sub(MAX_PAYLOAD_AND_CONTROL_LEN - usize::from(has_control_len));
440
441        let (control, data) = if discarded_len > 0 {
442            // If we have to truncate the segment, the FIN flag must be removed
443            // because it is logically the last octet of the segment.
444            let (control, control_len) = if control == Some(Control::FIN) {
445                (None, 0)
446            } else {
447                (control, has_control_len.into())
448            };
449            // The following slice will not panic because `discarded_len > 0`,
450            // thus `data.len() > MAX_PAYLOAD_AND_CONTROL_LEN - control_len`.
451            (control, data.slice(0..MAX_PAYLOAD_AND_CONTROL_LEN_U32 - control_len))
452        } else {
453            (control, data)
454        };
455
456        (
457            Segment { header: SegmentHeader { seq, ack, wnd, control, options }, data: data },
458            discarded_len,
459        )
460    }
461
462    /// Creates a new segment with data.
463    ///
464    /// Returns the segment along with how many bytes were removed to make sure
465    /// sequence numbers don't wrap around, i.e., `seq.before(seq + seg.len())`.
466    pub fn with_data(
467        seq: SeqNum,
468        ack: Option<SeqNum>,
469        control: Option<Control>,
470        wnd: UnscaledWindowSize,
471        data: P,
472    ) -> (Self, usize) {
473        Self::with_data_options(seq, ack, control, wnd, data, Options::default())
474    }
475
476    /// Maps the payload in the segment with `f`.
477    pub fn map_payload<R, F: FnOnce(P) -> R>(self, f: F) -> Segment<R> {
478        let Segment { header, data } = self;
479        Segment { header, data: f(data) }
480    }
481
482    /// Returns the length of the segment in sequence number space.
483    ///
484    /// Per RFC 793 (https://tools.ietf.org/html/rfc793#page-25):
485    ///   SEG.LEN = the number of octets occupied by the data in the segment
486    ///   (counting SYN and FIN)
487    pub fn len(&self) -> u32 {
488        self.header.len(self.data.len())
489    }
490
491    /// Returns the part of the incoming segment within the receive window.
492    pub fn overlap(self, rnxt: SeqNum, rwnd: WindowSize) -> Option<Segment<P>> {
493        let len = self.len();
494        let Segment { header: SegmentHeader { seq, ack, wnd, control, options }, data } = self;
495
496        // RFC 793 (https://tools.ietf.org/html/rfc793#page-69):
497        //   There are four cases for the acceptability test for an incoming
498        //   segment:
499        //       Segment Receive  Test
500        //       Length  Window
501        //       ------- -------  -------------------------------------------
502        //          0       0     SEG.SEQ = RCV.NXT
503        //          0      >0     RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
504        //         >0       0     not acceptable
505        //         >0      >0     RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
506        //                     or RCV.NXT =< SEG.SEQ+SEG.LEN-1 < RCV.NXT+RCV.WND
507        let overlap = match (len, rwnd) {
508            (0, WindowSize::ZERO) => seq == rnxt,
509            (0, rwnd) => !rnxt.after(seq) && seq.before(rnxt + rwnd),
510            (_len, WindowSize::ZERO) => false,
511            (len, rwnd) => {
512                (!rnxt.after(seq) && seq.before(rnxt + rwnd))
513                    // Note: here we use RCV.NXT <= SEG.SEQ+SEG.LEN instead of
514                    // the condition as quoted above because of the following
515                    // text immediately after the above table:
516                    //   One could tailor actual segments to fit this assumption by
517                    //   trimming off any portions that lie outside the window
518                    //   (including SYN and FIN), and only processing further if
519                    //   the segment then begins at RCV.NXT.
520                    // This is essential for TCP simultaneous open to work,
521                    // otherwise, the state machine would reject the SYN-ACK
522                    // sent by the peer.
523                    || (!(seq + len).before(rnxt) && !(seq + len).after(rnxt + rwnd))
524            }
525        };
526        overlap.then(move || {
527            // We deliberately don't define `PartialOrd` for `SeqNum`, so we use
528            // `cmp` below to utilize `cmp::{max,min}_by`.
529            let cmp = |lhs: &SeqNum, rhs: &SeqNum| (*lhs - *rhs).cmp(&0);
530            let new_seq = core::cmp::max_by(seq, rnxt, cmp);
531            let new_len = core::cmp::min_by(seq + len, rnxt + rwnd, cmp) - new_seq;
532            // The following unwrap won't panic because:
533            // 1. if `seq` is after `rnxt`, then `start` would be 0.
534            // 2. the interesting case is when `rnxt` is after `seq`, in that
535            // case, we have `rnxt - seq > 0`, thus `new_seq - seq > 0`.
536            let start = u32::try_from(new_seq - seq).unwrap();
537            // The following unwrap won't panic because:
538            // 1. The witness on `Segment` and `WindowSize` guarantees that
539            // `len <= 2^31` and `rwnd <= 2^30-1` thus
540            // `seq <= seq + len` and `rnxt <= rnxt + rwnd`.
541            // 2. We are in the closure because `overlap` is true which means
542            // `seq <= rnxt + rwnd` and `rnxt <= seq + len`.
543            // With these two conditions combined, `new_len` can't be negative
544            // so the unwrap can't panic.
545            let new_len = u32::try_from(new_len).unwrap();
546            let (new_control, new_data) = {
547                match control {
548                    Some(Control::SYN) => {
549                        if start == 0 {
550                            (Some(Control::SYN), data.slice(start..start + new_len - 1))
551                        } else {
552                            (None, data.slice(start - 1..start + new_len - 1))
553                        }
554                    }
555                    Some(Control::FIN) => {
556                        if len == start + new_len {
557                            if new_len > 0 {
558                                (Some(Control::FIN), data.slice(start..start + new_len - 1))
559                            } else {
560                                (None, data.slice(start - 1..start - 1))
561                            }
562                        } else {
563                            (None, data.slice(start..start + new_len))
564                        }
565                    }
566                    Some(Control::RST) | None => (control, data.slice(start..start + new_len)),
567                }
568            };
569            Segment {
570                header: SegmentHeader { seq: new_seq, ack, wnd, control: new_control, options },
571                data: new_data,
572            }
573        })
574    }
575
576    /// Creates a segment with no data.
577    pub fn new(
578        seq: SeqNum,
579        ack: Option<SeqNum>,
580        control: Option<Control>,
581        wnd: UnscaledWindowSize,
582    ) -> Self {
583        Self::with_options(seq, ack, control, wnd, Options::default())
584    }
585
586    /// Creates a new segment with options but no data.
587    pub fn with_options(
588        seq: SeqNum,
589        ack: Option<SeqNum>,
590        control: Option<Control>,
591        wnd: UnscaledWindowSize,
592        options: Options,
593    ) -> Self {
594        // All of the checks on lengths are optimized out:
595        // https://godbolt.org/z/KPd537G6Y
596        let (seg, truncated) =
597            Segment::with_data_options(seq, ack, control, wnd, P::new_empty(), options);
598        debug_assert_eq!(truncated, 0);
599        seg
600    }
601
602    /// Creates an ACK segment.
603    pub fn ack(seq: SeqNum, ack: SeqNum, wnd: UnscaledWindowSize) -> Self {
604        Self::ack_with_options(seq, ack, wnd, Options::default())
605    }
606
607    /// Creates an ACK segment with options.
608    pub fn ack_with_options(
609        seq: SeqNum,
610        ack: SeqNum,
611        wnd: UnscaledWindowSize,
612        options: Options,
613    ) -> Self {
614        Segment::with_options(seq, Some(ack), None, wnd, options)
615    }
616
617    /// Creates a SYN segment.
618    pub fn syn(seq: SeqNum, wnd: UnscaledWindowSize, options: Options) -> Self {
619        Segment::with_options(seq, None, Some(Control::SYN), wnd, options)
620    }
621
622    /// Creates a SYN-ACK segment.
623    pub fn syn_ack(seq: SeqNum, ack: SeqNum, wnd: UnscaledWindowSize, options: Options) -> Self {
624        Segment::with_options(seq, Some(ack), Some(Control::SYN), wnd, options)
625    }
626
627    /// Creates a RST segment.
628    pub fn rst(seq: SeqNum) -> Self {
629        Segment::new(seq, None, Some(Control::RST), UnscaledWindowSize::from(0))
630    }
631
632    /// Creates a RST-ACK segment.
633    pub fn rst_ack(seq: SeqNum, ack: SeqNum) -> Self {
634        Segment::new(seq, Some(ack), Some(Control::RST), UnscaledWindowSize::from(0))
635    }
636}
637
638impl Segment<()> {
639    /// Converts this segment with `()` data into any `P` payload's `new_empty`
640    /// form.
641    pub fn into_empty<P: Payload>(self) -> Segment<P> {
642        self.map_payload(|()| P::new_empty())
643    }
644}
645
646impl SegmentHeader {
647    /// Returns the length of the segment in sequence number space.
648    ///
649    /// Per RFC 793 (https://tools.ietf.org/html/rfc793#page-25):
650    ///   SEG.LEN = the number of octets occupied by the data in the segment
651    ///   (counting SYN and FIN)
652    pub fn len(&self, payload_len: usize) -> u32 {
653        // The following unwrap and addition are fine because:
654        // - `u32::from(has_control_len)` is 0 or 1.
655        // - `self.data.len() <= 2^31`.
656        let has_control_len = self.control.map(Control::has_sequence_no).unwrap_or(false);
657        u32::try_from(payload_len).unwrap() + u32::from(has_control_len)
658    }
659
660    /// Create a `SegmentHeader` from the provided builder and data length.  The
661    /// options will be set to their default values.
662    pub fn from_builder<A: IpAddress>(
663        builder: &TcpSegmentBuilder<A>,
664    ) -> Result<Self, MalformedFlags> {
665        Self::from_builder_options(builder, Options::new_with_handshake(builder.syn_set()))
666    }
667
668    /// Create a `SegmentHeader` from the provided builder, options, and data length.
669    pub fn from_builder_options<A: IpAddress>(
670        builder: &TcpSegmentBuilder<A>,
671        options: Options,
672    ) -> Result<Self, MalformedFlags> {
673        Ok(SegmentHeader {
674            seq: SeqNum::new(builder.seq_num()),
675            ack: builder.ack_num().map(SeqNum::new),
676            control: Flags {
677                syn: builder.syn_set(),
678                fin: builder.fin_set(),
679                rst: builder.rst_set(),
680            }
681            .control()?,
682            wnd: UnscaledWindowSize::from(builder.window_size()),
683            options: options,
684        })
685    }
686}
687
688/// A TCP payload that only allows for getting the length of the payload.
689pub trait PayloadLen {
690    /// Returns the length of the payload.
691    fn len(&self) -> usize;
692}
693
694/// A TCP payload that operates around `u32` instead of `usize`.
695pub trait Payload: PayloadLen + Sized {
696    /// Creates a slice of the payload, reducing it to only the bytes within
697    /// `range`.
698    ///
699    /// # Panics
700    ///
701    /// Panics if the provided `range` is not within the bounds of this
702    /// `Payload`, or if the range is nonsensical (the end precedes
703    /// the start).
704    fn slice(self, range: Range<u32>) -> Self;
705
706    /// Copies part of the payload beginning at `offset` into `dst`.
707    ///
708    /// # Panics
709    ///
710    /// Panics if offset is too large or we couldn't fill the `dst` slice.
711    fn partial_copy(&self, offset: usize, dst: &mut [u8]);
712
713    /// Copies part of the payload beginning at `offset` into `dst`.
714    ///
715    /// # Panics
716    ///
717    /// Panics if offset is too large or we couldn't fill the `dst` slice.
718    fn partial_copy_uninit(&self, offset: usize, dst: &mut [MaybeUninit<u8>]);
719
720    /// Creates a new empty payload.
721    ///
722    /// An empty payload must report 0 as its length.
723    fn new_empty() -> Self;
724}
725
726impl PayloadLen for &[u8] {
727    fn len(&self) -> usize {
728        <[u8]>::len(self)
729    }
730}
731
732impl Payload for &[u8] {
733    fn slice(self, Range { start, end }: Range<u32>) -> Self {
734        // The following `unwrap`s are ok because:
735        // `usize::try_from(x)` fails when `x > usize::MAX`; given that
736        // `self.len() <= usize::MAX`, panic would be expected because `range`
737        // exceeds the bound of `self`.
738        let start = usize::try_from(start).unwrap_or_else(|TryFromIntError { .. }| {
739            panic!("range start index {} out of range for slice of length {}", start, self.len())
740        });
741        let end = usize::try_from(end).unwrap_or_else(|TryFromIntError { .. }| {
742            panic!("range end index {} out of range for slice of length {}", end, self.len())
743        });
744        &self[start..end]
745    }
746
747    fn partial_copy(&self, offset: usize, dst: &mut [u8]) {
748        dst.copy_from_slice(&self[offset..offset + dst.len()])
749    }
750
751    fn partial_copy_uninit(&self, offset: usize, dst: &mut [MaybeUninit<u8>]) {
752        // TODO(https://github.com/rust-lang/rust/issues/79995): Replace unsafe
753        // with copy_from_slice when stabiliized.
754        let src = &self[offset..offset + dst.len()];
755        // SAFETY: &[T] and &[MaybeUninit<T>] have the same layout.
756        let uninit_src: &[MaybeUninit<u8>] = unsafe { core::mem::transmute(src) };
757        dst.copy_from_slice(&uninit_src);
758    }
759
760    fn new_empty() -> Self {
761        &[]
762    }
763}
764
765impl PayloadLen for () {
766    fn len(&self) -> usize {
767        0
768    }
769}
770
771impl Payload for () {
772    fn slice(self, Range { start, end }: Range<u32>) -> Self {
773        if start != 0 {
774            panic!("range start index {} out of range for slice of length 0", start);
775        }
776        if end != 0 {
777            panic!("range end index {} out of range for slice of length 0", end);
778        }
779        ()
780    }
781
782    fn partial_copy(&self, offset: usize, dst: &mut [u8]) {
783        if dst.len() != 0 || offset != 0 {
784            panic!(
785                "source slice length (0) does not match destination slice length ({})",
786                dst.len()
787            );
788        }
789    }
790
791    fn partial_copy_uninit(&self, offset: usize, dst: &mut [MaybeUninit<u8>]) {
792        if dst.len() != 0 || offset != 0 {
793            panic!(
794                "source slice length (0) does not match destination slice length ({})",
795                dst.len()
796            );
797        }
798    }
799
800    fn new_empty() -> Self {
801        ()
802    }
803}
804
805impl<I: PayloadLen, B> PayloadLen for InnerSerializer<I, B> {
806    fn len(&self) -> usize {
807        PayloadLen::len(self.inner())
808    }
809}
810
811#[derive(Error, Debug, PartialEq, Eq)]
812#[error("multiple mutually exclusive flags are set: syn: {syn}, fin: {fin}, rst: {rst}")]
813pub struct MalformedFlags {
814    syn: bool,
815    fin: bool,
816    rst: bool,
817}
818
819struct Flags {
820    syn: bool,
821    fin: bool,
822    rst: bool,
823}
824
825impl Flags {
826    fn control(&self) -> Result<Option<Control>, MalformedFlags> {
827        if usize::from(self.syn) + usize::from(self.fin) + usize::from(self.rst) > 1 {
828            return Err(MalformedFlags { syn: self.syn, fin: self.fin, rst: self.rst });
829        }
830
831        let syn = self.syn.then_some(Control::SYN);
832        let fin = self.fin.then_some(Control::FIN);
833        let rst = self.rst.then_some(Control::RST);
834
835        Ok(syn.or(fin).or(rst))
836    }
837}
838
839impl<'a> TryFrom<TcpSegment<&'a [u8]>> for Segment<&'a [u8]> {
840    type Error = MalformedFlags;
841
842    fn try_from(from: TcpSegment<&'a [u8]>) -> Result<Self, Self::Error> {
843        let syn = from.syn();
844        let options = Options::from_iter(syn, from.iter_options());
845        let (to, discarded) = Segment::with_data_options(
846            from.seq_num().into(),
847            from.ack_num().map(Into::into),
848            Flags { syn, fin: from.fin(), rst: from.rst() }.control()?,
849            UnscaledWindowSize::from(from.window_size()),
850            from.into_body(),
851            options,
852        );
853        debug_assert_eq!(discarded, 0);
854        Ok(to)
855    }
856}
857
858impl<A> TryFrom<&TcpSegmentBuilder<A>> for SegmentHeader
859where
860    A: IpAddress,
861{
862    type Error = MalformedFlags;
863
864    fn try_from(from: &TcpSegmentBuilder<A>) -> Result<Self, Self::Error> {
865        SegmentHeader::from_builder(from)
866    }
867}
868
869impl<'a, A, I> TryFrom<&TcpSegmentBuilderWithOptions<A, OptionSequenceBuilder<TcpOption<'a>, I>>>
870    for SegmentHeader
871where
872    A: IpAddress,
873    I: Iterator + Clone,
874    I::Item: Borrow<TcpOption<'a>>,
875{
876    type Error = MalformedFlags;
877
878    fn try_from(
879        from: &TcpSegmentBuilderWithOptions<A, OptionSequenceBuilder<TcpOption<'a>, I>>,
880    ) -> Result<Self, Self::Error> {
881        let prefix_builder = from.prefix_builder();
882        let handshake = prefix_builder.syn_set();
883        Self::from_builder_options(
884            prefix_builder,
885            Options::from_iter(
886                handshake,
887                from.iter_options().map(|option| option.borrow().to_owned()),
888            ),
889        )
890    }
891}
892
893#[cfg(feature = "testutils")]
894mod testutils {
895    use super::*;
896
897    impl<'a> Segment<&'a [u8]> {
898        /// Create a new segment with the given seq, ack, and data.
899        pub fn with_fake_data(seq: SeqNum, ack: SeqNum, data: &'a [u8]) -> Self {
900            let (segment, discarded) =
901                Self::with_data(seq, Some(ack), None, UnscaledWindowSize::from(u16::MAX), data);
902            assert_eq!(discarded, 0);
903            segment
904        }
905    }
906
907    impl<P: Payload> Segment<P> {
908        /// Creates a new segment with the provided data.
909        pub fn data(seq: SeqNum, ack: SeqNum, wnd: UnscaledWindowSize, data: P) -> Segment<P> {
910            let (seg, truncated) = Segment::with_data(seq, Some(ack), None, wnd, data);
911            assert_eq!(truncated, 0);
912            seg
913        }
914
915        /// Creates a new FIN segment with the provided data.
916        pub fn piggybacked_fin(
917            seq: SeqNum,
918            ack: SeqNum,
919            wnd: UnscaledWindowSize,
920            data: P,
921        ) -> Segment<P> {
922            let (seg, truncated) =
923                Segment::with_data(seq, Some(ack), Some(Control::FIN), wnd, data);
924            assert_eq!(truncated, 0);
925            seg
926        }
927
928        /// Creates a new FIN segment.
929        pub fn fin(seq: SeqNum, ack: SeqNum, wnd: UnscaledWindowSize) -> Self {
930            Segment::new(seq, Some(ack), Some(Control::FIN), wnd)
931        }
932    }
933}
934
935#[cfg(test)]
936mod test {
937    use assert_matches::assert_matches;
938    use ip_test_macro::ip_test;
939    use net_declare::{net_ip_v4, net_ip_v6};
940    use net_types::ip::{Ipv4, Ipv6};
941    use packet_formats::ip::IpExt;
942    use test_case::test_case;
943
944    use super::*;
945
946    #[test_case(None, &[][..] => (0, &[][..]); "empty")]
947    #[test_case(None, &[1][..] => (1, &[1][..]); "no control")]
948    #[test_case(Some(Control::SYN), &[][..] => (1, &[][..]); "empty slice with syn")]
949    #[test_case(Some(Control::SYN), &[1][..] => (2, &[1][..]); "non-empty slice with syn")]
950    #[test_case(Some(Control::FIN), &[][..] => (1, &[][..]); "empty slice with fin")]
951    #[test_case(Some(Control::FIN), &[1][..] => (2, &[1][..]); "non-empty slice with fin")]
952    #[test_case(Some(Control::RST), &[][..] => (0, &[][..]); "empty slice with rst")]
953    #[test_case(Some(Control::RST), &[1][..] => (1, &[1][..]); "non-empty slice with rst")]
954    fn segment_len(control: Option<Control>, data: &[u8]) -> (u32, &[u8]) {
955        let (seg, truncated) = Segment::with_data(
956            SeqNum::new(1),
957            Some(SeqNum::new(1)),
958            control,
959            UnscaledWindowSize::from(0),
960            data,
961        );
962        assert_eq!(truncated, 0);
963        (seg.len(), seg.data)
964    }
965
966    #[test_case(&[1, 2, 3, 4, 5][..], 0..4 => [1, 2, 3, 4])]
967    #[test_case((), 0..0 => [0, 0, 0, 0])]
968    fn payload_slice_copy(data: impl Payload, range: Range<u32>) -> [u8; 4] {
969        let sliced = data.slice(range);
970        let mut buffer = [0; 4];
971        sliced.partial_copy(0, &mut buffer[..sliced.len()]);
972        buffer
973    }
974
975    #[derive(Debug, PartialEq, Eq)]
976    struct TestPayload(Range<u32>);
977
978    impl TestPayload {
979        fn new(len: usize) -> Self {
980            Self(0..u32::try_from(len).unwrap())
981        }
982    }
983
984    impl PayloadLen for TestPayload {
985        fn len(&self) -> usize {
986            self.0.len()
987        }
988    }
989
990    impl Payload for TestPayload {
991        fn slice(self, range: Range<u32>) -> Self {
992            let Self(this) = self;
993            assert!(range.start >= this.start && range.end <= this.end);
994            TestPayload(range)
995        }
996
997        fn partial_copy(&self, _offset: usize, _dst: &mut [u8]) {
998            unimplemented!("TestPayload doesn't carry any data");
999        }
1000
1001        fn partial_copy_uninit(&self, _offset: usize, _dst: &mut [MaybeUninit<u8>]) {
1002            unimplemented!("TestPayload doesn't carry any data");
1003        }
1004
1005        fn new_empty() -> Self {
1006            Self(0..0)
1007        }
1008    }
1009
1010    #[test_case(100, Some(Control::SYN) => (100, Some(Control::SYN), 0))]
1011    #[test_case(100, Some(Control::FIN) => (100, Some(Control::FIN), 0))]
1012    #[test_case(100, Some(Control::RST) => (100, Some(Control::RST), 0))]
1013    #[test_case(100, None => (100, None, 0))]
1014    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::SYN)
1015    => (MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::SYN), 0))]
1016    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::FIN)
1017    => (MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::FIN), 0))]
1018    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::RST)
1019    => (MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::RST), 0))]
1020    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN - 1, None
1021    => (MAX_PAYLOAD_AND_CONTROL_LEN - 1, None, 0))]
1022    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN, Some(Control::SYN)
1023    => (MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::SYN), 1))]
1024    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN, Some(Control::FIN)
1025    => (MAX_PAYLOAD_AND_CONTROL_LEN, None, 1))]
1026    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN, Some(Control::RST)
1027    => (MAX_PAYLOAD_AND_CONTROL_LEN, Some(Control::RST), 0))]
1028    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN, None
1029    => (MAX_PAYLOAD_AND_CONTROL_LEN, None, 0))]
1030    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN + 1, Some(Control::SYN)
1031    => (MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::SYN), 2))]
1032    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN + 1, Some(Control::FIN)
1033    => (MAX_PAYLOAD_AND_CONTROL_LEN, None, 2))]
1034    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN + 1, Some(Control::RST)
1035    => (MAX_PAYLOAD_AND_CONTROL_LEN, Some(Control::RST), 1))]
1036    #[test_case(MAX_PAYLOAD_AND_CONTROL_LEN + 1, None
1037    => (MAX_PAYLOAD_AND_CONTROL_LEN, None, 1))]
1038    #[test_case(u32::MAX as usize, Some(Control::SYN)
1039    => (MAX_PAYLOAD_AND_CONTROL_LEN - 1, Some(Control::SYN), 1 << 31))]
1040    fn segment_truncate(len: usize, control: Option<Control>) -> (usize, Option<Control>, usize) {
1041        let (seg, truncated) = Segment::with_data(
1042            SeqNum::new(0),
1043            None,
1044            control,
1045            UnscaledWindowSize::from(0),
1046            TestPayload::new(len),
1047        );
1048        (seg.data.len(), seg.header.control, truncated)
1049    }
1050
1051    struct OverlapTestArgs {
1052        seg_seq: u32,
1053        control: Option<Control>,
1054        data_len: u32,
1055        rcv_nxt: u32,
1056        rcv_wnd: usize,
1057    }
1058    #[test_case(OverlapTestArgs{
1059        seg_seq: 1,
1060        control: None,
1061        data_len: 0,
1062        rcv_nxt: 0,
1063        rcv_wnd: 0,
1064    } => None)]
1065    #[test_case(OverlapTestArgs{
1066        seg_seq: 1,
1067        control: None,
1068        data_len: 0,
1069        rcv_nxt: 1,
1070        rcv_wnd: 0,
1071    } => Some((SeqNum::new(1), None, 0..0)))]
1072    #[test_case(OverlapTestArgs{
1073        seg_seq: 1,
1074        control: None,
1075        data_len: 0,
1076        rcv_nxt: 2,
1077        rcv_wnd: 0,
1078    } => None)]
1079    #[test_case(OverlapTestArgs{
1080        seg_seq: 1,
1081        control: Some(Control::SYN),
1082        data_len: 0,
1083        rcv_nxt: 2,
1084        rcv_wnd: 0,
1085    } => None)]
1086    #[test_case(OverlapTestArgs{
1087        seg_seq: 1,
1088        control: Some(Control::SYN),
1089        data_len: 0,
1090        rcv_nxt: 1,
1091        rcv_wnd: 0,
1092    } => None)]
1093    #[test_case(OverlapTestArgs{
1094        seg_seq: 1,
1095        control: Some(Control::SYN),
1096        data_len: 0,
1097        rcv_nxt: 0,
1098        rcv_wnd: 0,
1099    } => None)]
1100    #[test_case(OverlapTestArgs{
1101        seg_seq: 1,
1102        control: Some(Control::FIN),
1103        data_len: 0,
1104        rcv_nxt: 2,
1105        rcv_wnd: 0,
1106    } => None)]
1107    #[test_case(OverlapTestArgs{
1108        seg_seq: 1,
1109        control: Some(Control::FIN),
1110        data_len: 0,
1111        rcv_nxt: 1,
1112        rcv_wnd: 0,
1113    } => None)]
1114    #[test_case(OverlapTestArgs{
1115        seg_seq: 1,
1116        control: Some(Control::FIN),
1117        data_len: 0,
1118        rcv_nxt: 0,
1119        rcv_wnd: 0,
1120    } => None)]
1121    #[test_case(OverlapTestArgs{
1122        seg_seq: 0,
1123        control: None,
1124        data_len: 0,
1125        rcv_nxt: 1,
1126        rcv_wnd: 1,
1127    } => None)]
1128    #[test_case(OverlapTestArgs{
1129        seg_seq: 1,
1130        control: None,
1131        data_len: 0,
1132        rcv_nxt: 1,
1133        rcv_wnd: 1,
1134    } => Some((SeqNum::new(1), None, 0..0)))]
1135    #[test_case(OverlapTestArgs{
1136        seg_seq: 2,
1137        control: None,
1138        data_len: 0,
1139        rcv_nxt: 1,
1140        rcv_wnd: 1,
1141    } => None)]
1142    #[test_case(OverlapTestArgs{
1143        seg_seq: 0,
1144        control: None,
1145        data_len: 1,
1146        rcv_nxt: 1,
1147        rcv_wnd: 1,
1148    } => Some((SeqNum::new(1), None, 1..1)))]
1149    #[test_case(OverlapTestArgs{
1150        seg_seq: 0,
1151        control: Some(Control::SYN),
1152        data_len: 0,
1153        rcv_nxt: 1,
1154        rcv_wnd: 1,
1155    } => Some((SeqNum::new(1), None, 0..0)))]
1156    #[test_case(OverlapTestArgs{
1157        seg_seq: 2,
1158        control: None,
1159        data_len: 1,
1160        rcv_nxt: 1,
1161        rcv_wnd: 1,
1162    } => None)]
1163    #[test_case(OverlapTestArgs{
1164        seg_seq: 0,
1165        control: None,
1166        data_len: 2,
1167        rcv_nxt: 1,
1168        rcv_wnd: 1,
1169    } => Some((SeqNum::new(1), None, 1..2)))]
1170    #[test_case(OverlapTestArgs{
1171        seg_seq: 1,
1172        control: None,
1173        data_len: 2,
1174        rcv_nxt: 1,
1175        rcv_wnd: 1,
1176    } => Some((SeqNum::new(1), None, 0..1)))]
1177    #[test_case(OverlapTestArgs{
1178        seg_seq: 0,
1179        control: Some(Control::SYN),
1180        data_len: 1,
1181        rcv_nxt: 1,
1182        rcv_wnd: 1,
1183    } => Some((SeqNum::new(1), None, 0..1)))]
1184    #[test_case(OverlapTestArgs{
1185        seg_seq: 1,
1186        control: Some(Control::SYN),
1187        data_len: 1,
1188        rcv_nxt: 1,
1189        rcv_wnd: 1,
1190    } => Some((SeqNum::new(1), Some(Control::SYN), 0..0)))]
1191    #[test_case(OverlapTestArgs{
1192        seg_seq: 0,
1193        control: Some(Control::FIN),
1194        data_len: 1,
1195        rcv_nxt: 1,
1196        rcv_wnd: 1,
1197    } => Some((SeqNum::new(1), Some(Control::FIN), 1..1)))]
1198    #[test_case(OverlapTestArgs{
1199        seg_seq: 1,
1200        control: Some(Control::FIN),
1201        data_len: 1,
1202        rcv_nxt: 1,
1203        rcv_wnd: 1,
1204    } => Some((SeqNum::new(1), None, 0..1)))]
1205    #[test_case(OverlapTestArgs{
1206        seg_seq: 1,
1207        control: None,
1208        data_len: MAX_PAYLOAD_AND_CONTROL_LEN_U32,
1209        rcv_nxt: 1,
1210        rcv_wnd: 10,
1211    } => Some((SeqNum::new(1), None, 0..10)))]
1212    #[test_case(OverlapTestArgs{
1213        seg_seq: 10,
1214        control: None,
1215        data_len: MAX_PAYLOAD_AND_CONTROL_LEN_U32,
1216        rcv_nxt: 1,
1217        rcv_wnd: 10,
1218    } => Some((SeqNum::new(10), None, 0..1)))]
1219    #[test_case(OverlapTestArgs{
1220        seg_seq: 1,
1221        control: None,
1222        data_len: 10,
1223        rcv_nxt: 1,
1224        rcv_wnd: 1 << 30 - 1,
1225    } => Some((SeqNum::new(1), None, 0..10)))]
1226    #[test_case(OverlapTestArgs{
1227        seg_seq: 10,
1228        control: None,
1229        data_len: 10,
1230        rcv_nxt: 1,
1231        rcv_wnd: 1 << 30 - 1,
1232    } => Some((SeqNum::new(10), None, 0..10)))]
1233    #[test_case(OverlapTestArgs{
1234        seg_seq: 1,
1235        control: Some(Control::FIN),
1236        data_len: 1,
1237        rcv_nxt: 3,
1238        rcv_wnd: 10,
1239    } => Some((SeqNum::new(3), None, 1..1)); "regression test for https://fxbug.dev/42061750")]
1240    fn segment_overlap(
1241        OverlapTestArgs { seg_seq, control, data_len, rcv_nxt, rcv_wnd }: OverlapTestArgs,
1242    ) -> Option<(SeqNum, Option<Control>, Range<u32>)> {
1243        let (seg, discarded) = Segment::with_data(
1244            SeqNum::new(seg_seq),
1245            None,
1246            control,
1247            UnscaledWindowSize::from(0),
1248            TestPayload(0..data_len),
1249        );
1250        assert_eq!(discarded, 0);
1251        seg.overlap(SeqNum::new(rcv_nxt), WindowSize::new(rcv_wnd).unwrap()).map(
1252            |Segment { header: SegmentHeader { seq, control, .. }, data: TestPayload(range) }| {
1253                (seq, control, range)
1254            },
1255        )
1256    }
1257
1258    pub trait TestIpExt: IpExt {
1259        const SRC_IP: Self::Addr;
1260        const DST_IP: Self::Addr;
1261    }
1262
1263    impl TestIpExt for Ipv4 {
1264        const SRC_IP: Self::Addr = net_ip_v4!("192.0.2.1");
1265        const DST_IP: Self::Addr = net_ip_v4!("192.0.2.2");
1266    }
1267
1268    impl TestIpExt for Ipv6 {
1269        const SRC_IP: Self::Addr = net_ip_v6!("2001:db8::1");
1270        const DST_IP: Self::Addr = net_ip_v6!("2001:db8::2");
1271    }
1272
1273    const SRC_PORT: NonZeroU16 = NonZeroU16::new(1234).unwrap();
1274    const DST_PORT: NonZeroU16 = NonZeroU16::new(9876).unwrap();
1275
1276    #[ip_test(I)]
1277    fn from_segment_builder<I: TestIpExt>() {
1278        let mut builder =
1279            TcpSegmentBuilder::new(I::SRC_IP, I::DST_IP, SRC_PORT, DST_PORT, 1, Some(2), 3);
1280        builder.syn(true);
1281
1282        let converted_header =
1283            SegmentHeader::try_from(&builder).expect("failed to convert serializer");
1284
1285        let expected_header = SegmentHeader {
1286            seq: SeqNum::new(1),
1287            ack: Some(SeqNum::new(2)),
1288            wnd: UnscaledWindowSize::from(3u16),
1289            control: Some(Control::SYN),
1290            options: HandshakeOptions::default().into(),
1291        };
1292
1293        assert_eq!(converted_header, expected_header);
1294    }
1295
1296    #[ip_test(I)]
1297    fn from_segment_builder_failure<I: TestIpExt>() {
1298        let mut builder =
1299            TcpSegmentBuilder::new(I::SRC_IP, I::DST_IP, SRC_PORT, DST_PORT, 1, Some(2), 3);
1300        builder.syn(true);
1301        builder.fin(true);
1302
1303        assert_matches!(
1304            SegmentHeader::try_from(&builder),
1305            Err(MalformedFlags { syn: true, fin: true, rst: false })
1306        );
1307    }
1308
1309    #[ip_test(I)]
1310    fn from_segment_builder_with_options_handshake<I: TestIpExt>() {
1311        let mut builder =
1312            TcpSegmentBuilder::new(I::SRC_IP, I::DST_IP, SRC_PORT, DST_PORT, 1, Some(2), 3);
1313        builder.syn(true);
1314
1315        let builder = TcpSegmentBuilderWithOptions::new(
1316            builder,
1317            [TcpOption::Mss(1024), TcpOption::WindowScale(10), TcpOption::SackPermitted],
1318        )
1319        .expect("failed to create tcp segment builder");
1320
1321        let converted_header =
1322            SegmentHeader::try_from(&builder).expect("failed to convert serializer");
1323
1324        let expected_header = SegmentHeader {
1325            seq: SeqNum::new(1),
1326            ack: Some(SeqNum::new(2)),
1327            wnd: UnscaledWindowSize::from(3u16),
1328            control: Some(Control::SYN),
1329            options: HandshakeOptions {
1330                mss: Some(Mss(NonZeroU16::new(1024).unwrap())),
1331                window_scale: Some(WindowScale::new(10).unwrap()),
1332                sack_permitted: true,
1333            }
1334            .into(),
1335        };
1336
1337        assert_eq!(converted_header, expected_header);
1338    }
1339
1340    #[ip_test(I)]
1341    fn from_segment_builder_with_options_segment<I: TestIpExt>() {
1342        let builder =
1343            TcpSegmentBuilder::new(I::SRC_IP, I::DST_IP, SRC_PORT, DST_PORT, 1, Some(2), 3);
1344
1345        let sack_blocks = [TcpSackBlock::new(1, 2), TcpSackBlock::new(4, 6)];
1346        let builder =
1347            TcpSegmentBuilderWithOptions::new(builder, [TcpOption::Sack(&sack_blocks[..])])
1348                .expect("failed to create tcp segment builder");
1349
1350        let converted_header =
1351            SegmentHeader::try_from(&builder).expect("failed to convert serializer");
1352
1353        let expected_header = SegmentHeader {
1354            seq: SeqNum::new(1),
1355            ack: Some(SeqNum::new(2)),
1356            wnd: UnscaledWindowSize::from(3u16),
1357            control: None,
1358            options: SegmentOptions {
1359                sack_blocks: SackBlocks::from_iter([
1360                    SackBlock::try_new(SeqNum::new(1), SeqNum::new(2)).unwrap(),
1361                    SackBlock::try_new(SeqNum::new(4), SeqNum::new(6)).unwrap(),
1362                ]),
1363            }
1364            .into(),
1365        };
1366
1367        assert_eq!(converted_header, expected_header);
1368    }
1369
1370    #[ip_test(I)]
1371    fn from_segment_builder_with_options_failure<I: TestIpExt>() {
1372        let mut builder =
1373            TcpSegmentBuilder::new(I::SRC_IP, I::DST_IP, SRC_PORT, DST_PORT, 1, Some(2), 3);
1374        builder.syn(true);
1375        builder.fin(true);
1376
1377        let builder = TcpSegmentBuilderWithOptions::new(
1378            builder,
1379            [TcpOption::Mss(1024), TcpOption::WindowScale(10)],
1380        )
1381        .expect("failed to create tcp segment builder");
1382
1383        assert_matches!(
1384            SegmentHeader::try_from(&builder),
1385            Err(MalformedFlags { syn: true, fin: true, rst: false })
1386        );
1387    }
1388
1389    #[test_case(Flags {
1390            syn: false,
1391            fin: false,
1392            rst: false,
1393        } => Ok(None))]
1394    #[test_case(Flags {
1395            syn: true,
1396            fin: false,
1397            rst: false,
1398        } => Ok(Some(Control::SYN)))]
1399    #[test_case(Flags {
1400            syn: false,
1401            fin: true,
1402            rst: false,
1403        } => Ok(Some(Control::FIN)))]
1404    #[test_case(Flags {
1405            syn: false,
1406            fin: false,
1407            rst: true,
1408        } => Ok(Some(Control::RST)))]
1409    #[test_case(Flags {
1410            syn: true,
1411            fin: true,
1412            rst: false,
1413        } => Err(MalformedFlags {
1414            syn: true,
1415            fin: true,
1416            rst: false,
1417        }))]
1418    #[test_case(Flags {
1419            syn: true,
1420            fin: false,
1421            rst: true,
1422        } => Err(MalformedFlags {
1423            syn: true,
1424            fin: false,
1425            rst: true,
1426        }))]
1427    #[test_case(Flags {
1428            syn: false,
1429            fin: true,
1430            rst: true,
1431        } => Err(MalformedFlags {
1432            syn: false,
1433            fin: true,
1434            rst: true,
1435        }))]
1436    #[test_case(Flags {
1437            syn: true,
1438            fin: true,
1439            rst: true,
1440        } => Err(MalformedFlags {
1441            syn: true,
1442            fin: true,
1443            rst: true,
1444        }))]
1445    fn flags_to_control(input: Flags) -> Result<Option<Control>, MalformedFlags> {
1446        input.control()
1447    }
1448
1449    #[test]
1450    fn sack_block_try_new() {
1451        assert_matches!(SackBlock::try_new(SeqNum::new(1), SeqNum::new(2)), Ok(_));
1452        assert_matches!(
1453            SackBlock::try_new(SeqNum::new(0u32.wrapping_sub(1)), SeqNum::new(2)),
1454            Ok(_)
1455        );
1456        assert_eq!(
1457            SackBlock::try_new(SeqNum::new(1), SeqNum::new(1)),
1458            Err(InvalidSackBlockError(SeqNum::new(1), SeqNum::new(1)))
1459        );
1460        assert_eq!(
1461            SackBlock::try_new(SeqNum::new(2), SeqNum::new(1)),
1462            Err(InvalidSackBlockError(SeqNum::new(2), SeqNum::new(1)))
1463        );
1464        assert_eq!(
1465            SackBlock::try_new(SeqNum::new(0), SeqNum::new(0u32.wrapping_sub(1))),
1466            Err(InvalidSackBlockError(SeqNum::new(0), SeqNum::new(0u32.wrapping_sub(1))))
1467        );
1468    }
1469}
netstack3_base/tcp/segment.rs

netstack3_base/tcp/
segment.rs
