TCP Timestamp option support

src/iface/interface/tests/mod.rs

@@ -169,6 +169,7 @@ pub fn tcp_not_accepted() {
         max_seg_size: None,
         sack_permitted: false,
         sack_ranges: [None, None, None],
+        timestamp: None,
         payload: &[],
     };
 
@@ -212,6 +213,7 @@ pub fn tcp_not_accepted() {
                 max_seg_size: None,
                 sack_permitted: false,
                 sack_ranges: [None, None, None],
+                timestamp: None,
                 payload: &[],
             })
         ))

src/socket/tcp.rs

@@ -1,6 +1,6 @@
 // Heads up! Before working on this file you should read, at least, RFC 793 and
-// the parts of RFC 1122 that discuss TCP. Consult RFC 7414 when implementing
-// a new feature.
+// the parts of RFC 1122 that discuss TCP, as well as RFC 7323 for some of the TCP options.
+// Consult RFC 7414 when implementing a new feature.
 
 use core::fmt::Display;
 #[cfg(feature = "async")]
@@ -14,7 +14,7 @@ use crate::storage::{Assembler, RingBuffer};
 use crate::time::{Duration, Instant};
 use crate::wire::{
     IpAddress, IpEndpoint, IpListenEndpoint, IpProtocol, IpRepr, TcpControl, TcpRepr, TcpSeqNumber,
-    TCP_HEADER_LEN,
+    TcpTimestampGenerator, TcpTimestampRepr, TCP_HEADER_LEN,
 };
 
 mod congestion;
@@ -482,6 +482,12 @@ pub struct Socket<'a> {
     /// The congestion control algorithm.
     congestion_controller: congestion::AnyController,
 
+    /// tsval generator - if some, tcp timestamp is enabled
+    tsval_generator: Option<TcpTimestampGenerator>,
+
+    /// 0 if not seen or timestamp not enabled
+    last_remote_tsval: u32,
+
     #[cfg(feature = "async")]
     rx_waker: WakerRegistration,
     #[cfg(feature = "async")]
@@ -540,6 +546,8 @@ impl<'a> Socket<'a> {
             ack_delay_timer: AckDelayTimer::Idle,
             challenge_ack_timer: Instant::from_secs(0),
             nagle: true,
+            tsval_generator: None,
+            last_remote_tsval: 0,
             congestion_controller: congestion::AnyController::new(),
 
             #[cfg(feature = "async")]
@@ -549,6 +557,16 @@ impl<'a> Socket<'a> {
         }
     }
 
+    /// Enable or disable TCP Timestamp.
+    pub fn set_tsval_generator(&mut self, generator: Option<TcpTimestampGenerator>) {
+        self.tsval_generator = generator;
+    }
+
+    /// Return whether TCP Timestamp is enabled.
+    pub fn timestamp_enabled(&self) -> bool {
+        self.tsval_generator.is_some()
+    }
+
     /// Set an algorithm for congestion control.
     ///
     /// `CongestionControl::None` indicates that no congestion control is applied.
@@ -1300,6 +1318,7 @@ impl<'a> Socket<'a> {
             max_seg_size: None,
             sack_permitted: false,
             sack_ranges: [None, None, None],
+            timestamp: None,
             payload: &[],
         };
         let ip_reply_repr = IpRepr::new(
@@ -1330,6 +1349,9 @@ impl<'a> Socket<'a> {
 
     fn ack_reply(&mut self, ip_repr: &IpRepr, repr: &TcpRepr) -> (IpRepr, TcpRepr<'static>) {
         let (mut ip_reply_repr, mut reply_repr) = Self::reply(ip_repr, repr);
+        reply_repr.timestamp = repr
+            .timestamp
+            .and_then(|tcp_ts| tcp_ts.generate_reply(self.tsval_generator));
 
         // From RFC 793:
         // [...] an empty acknowledgment segment containing the current send-sequence number
@@ -1725,6 +1747,10 @@ impl<'a> Socket<'a> {
                 if self.remote_win_scale.is_none() {
                     self.remote_win_shift = 0;
                 }
+                // Remote doesn't support timestamping, don't do it.
+                if repr.timestamp.is_none() {
+                    self.tsval_generator = None;
+                }
                 self.set_state(State::SynReceived);
                 self.timer.set_for_idle(cx.now(), self.keep_alive);
             }
@@ -1767,6 +1793,10 @@ impl<'a> Socket<'a> {
                 if self.remote_win_scale.is_none() {
                     self.remote_win_shift = 0;
                 }
+                // Remote doesn't support timestamping, don't do it.
+                if repr.timestamp.is_none() {
+                    self.tsval_generator = None;
+                }
 
                 self.set_state(State::Established);
                 self.timer.set_for_idle(cx.now(), self.keep_alive);
@@ -1954,6 +1984,11 @@ impl<'a> Socket<'a> {
             }
         }
 
+        // update last remote tsval
+        if let Some(timestamp) = repr.timestamp {
+            self.last_remote_tsval = timestamp.tsval;
+        }
+
         let payload_len = payload.len();
         if payload_len == 0 {
             return None;
@@ -2246,6 +2281,10 @@ impl<'a> Socket<'a> {
             max_seg_size: None,
             sack_permitted: false,
             sack_ranges: [None, None, None],
+            timestamp: TcpTimestampRepr::generate_reply_with_tsval(
+                self.tsval_generator,
+                self.last_remote_tsval,
+            ),
             payload: &[],
         };
 
@@ -2574,6 +2613,7 @@ mod test {
         max_seg_size: None,
         sack_permitted: false,
         sack_ranges: [None, None, None],
+        timestamp: None,
         payload: &[],
     };
     const _RECV_IP_TEMPL: IpRepr = IpReprIpvX(IpvXRepr {
@@ -2594,6 +2634,7 @@ mod test {
         max_seg_size: None,
         sack_permitted: false,
         sack_ranges: [None, None, None],
+        timestamp: None,
         payload: &[],
     };
 
@@ -7429,4 +7470,239 @@ mod test {
         s.set_congestion_control(CongestionControl::None);
         assert_eq!(s.congestion_control(), CongestionControl::None);
     }
+
+    // =========================================================================================//
+    // Timestamp tests
+    // =========================================================================================//
+
+    #[test]
+    fn test_tsval_established_connection() {
+        let mut s = socket_established();
+        s.set_tsval_generator(Some(|| 1));
+
+        assert!(s.timestamp_enabled());
+
+        // First roundtrip after establishing.
+        s.send_slice(b"abcdef").unwrap();
+        recv!(
+            s,
+            [TcpRepr {
+                seq_number: LOCAL_SEQ + 1,
+                ack_number: Some(REMOTE_SEQ + 1),
+                payload: &b"abcdef"[..],
+                timestamp: Some(TcpTimestampRepr::new(1, 0)),
+                ..RECV_TEMPL
+            }]
+        );
+        assert_eq!(s.tx_buffer.len(), 6);
+        send!(
+            s,
+            TcpRepr {
+                seq_number: REMOTE_SEQ + 1,
+                ack_number: Some(LOCAL_SEQ + 1 + 6),
+                timestamp: Some(TcpTimestampRepr::new(500, 1)),
+                ..SEND_TEMPL
+            }
+        );
+        assert_eq!(s.tx_buffer.len(), 0);
+        // Second roundtrip.
+        s.send_slice(b"foobar").unwrap();
+        recv!(
+            s,
+            [TcpRepr {
+                seq_number: LOCAL_SEQ + 1 + 6,
+                ack_number: Some(REMOTE_SEQ + 1),
+                payload: &b"foobar"[..],
+                timestamp: Some(TcpTimestampRepr::new(1, 500)),
+                ..RECV_TEMPL
+            }]
+        );
+        send!(
+            s,
+            TcpRepr {
+                seq_number: REMOTE_SEQ + 1,
+                ack_number: Some(LOCAL_SEQ + 1 + 6 + 6),
+                ..SEND_TEMPL
+            }
+        );
+        assert_eq!(s.tx_buffer.len(), 0);
+    }
+
+    #[test]
+    fn test_tsval_disabled_in_remote_client() {
+        let mut s = socket_listen();
+        s.set_tsval_generator(Some(|| 1));
+        assert!(s.timestamp_enabled());
+        send!(
+            s,
+            TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: REMOTE_SEQ,
+                ack_number: None,
+                ..SEND_TEMPL
+            }
+        );
+        assert_eq!(s.state(), State::SynReceived);
+        assert_eq!(s.tuple, Some(TUPLE));
+        assert!(!s.timestamp_enabled());
+        recv!(
+            s,
+            [TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: LOCAL_SEQ,
+                ack_number: Some(REMOTE_SEQ + 1),
+                max_seg_size: Some(BASE_MSS),
+                ..RECV_TEMPL
+            }]
+        );
+        send!(
+            s,
+            TcpRepr {
+                seq_number: REMOTE_SEQ + 1,
+                ack_number: Some(LOCAL_SEQ + 1),
+                ..SEND_TEMPL
+            }
+        );
+        assert_eq!(s.state(), State::Established);
+        assert_eq!(s.local_seq_no, LOCAL_SEQ + 1);
+        assert_eq!(s.remote_seq_no, REMOTE_SEQ + 1);
+    }
+
+    #[test]
+    fn test_tsval_disabled_in_local_server() {
+        let mut s = socket_listen();
+        // s.set_timestamp(false); // commented to alert if the default state changes
+        assert!(!s.timestamp_enabled());
+        send!(
+            s,
+            TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: REMOTE_SEQ,
+                ack_number: None,
+                timestamp: Some(TcpTimestampRepr::new(500, 0)),
+                ..SEND_TEMPL
+            }
+        );
+        assert_eq!(s.state(), State::SynReceived);
+        assert_eq!(s.tuple, Some(TUPLE));
+        assert!(!s.timestamp_enabled());
+        recv!(
+            s,
+            [TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: LOCAL_SEQ,
+                ack_number: Some(REMOTE_SEQ + 1),
+                max_seg_size: Some(BASE_MSS),
+                ..RECV_TEMPL
+            }]
+        );
+        send!(
+            s,
+            TcpRepr {
+                seq_number: REMOTE_SEQ + 1,
+                ack_number: Some(LOCAL_SEQ + 1),
+                ..SEND_TEMPL
+            }
+        );
+        assert_eq!(s.state(), State::Established);
+        assert_eq!(s.local_seq_no, LOCAL_SEQ + 1);
+        assert_eq!(s.remote_seq_no, REMOTE_SEQ + 1);
+    }
+
+    #[test]
+    fn test_tsval_disabled_in_remote_server() {
+        let mut s = socket();
+        s.set_tsval_generator(Some(|| 1));
+        assert!(s.timestamp_enabled());
+        s.local_seq_no = LOCAL_SEQ;
+        s.socket
+            .connect(&mut s.cx, REMOTE_END, LOCAL_END.port)
+            .unwrap();
+        assert_eq!(s.tuple, Some(TUPLE));
+        recv!(
+            s,
+            [TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: LOCAL_SEQ,
+                ack_number: None,
+                max_seg_size: Some(BASE_MSS),
+                window_scale: Some(0),
+                sack_permitted: true,
+                timestamp: Some(TcpTimestampRepr::new(1, 0)),
+                ..RECV_TEMPL
+            }]
+        );
+        send!(
+            s,
+            TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: REMOTE_SEQ,
+                ack_number: Some(LOCAL_SEQ + 1),
+                max_seg_size: Some(BASE_MSS - 80),
+                window_scale: Some(0),
+                timestamp: None,
+                ..SEND_TEMPL
+            }
+        );
+        assert!(!s.timestamp_enabled());
+        s.send_slice(b"abcdef").unwrap();
+        recv!(
+            s,
+            [TcpRepr {
+                seq_number: LOCAL_SEQ + 1,
+                ack_number: Some(REMOTE_SEQ + 1),
+                payload: &b"abcdef"[..],
+                timestamp: None,
+                ..RECV_TEMPL
+            }]
+        );
+    }
+
+    #[test]
+    fn test_tsval_disabled_in_local_client() {
+        let mut s = socket();
+        // s.set_timestamp(false); // commented to alert if the default state changes
+        assert!(!s.timestamp_enabled());
+        s.local_seq_no = LOCAL_SEQ;
+        s.socket
+            .connect(&mut s.cx, REMOTE_END, LOCAL_END.port)
+            .unwrap();
+        assert_eq!(s.tuple, Some(TUPLE));
+        recv!(
+            s,
+            [TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: LOCAL_SEQ,
+                ack_number: None,
+                max_seg_size: Some(BASE_MSS),
+                window_scale: Some(0),
+                sack_permitted: true,
+                ..RECV_TEMPL
+            }]
+        );
+        send!(
+            s,
+            TcpRepr {
+                control: TcpControl::Syn,
+                seq_number: REMOTE_SEQ,
+                ack_number: Some(LOCAL_SEQ + 1),
+                max_seg_size: Some(BASE_MSS - 80),
+                window_scale: Some(0),
+                timestamp: Some(TcpTimestampRepr::new(500, 0)),
+                ..SEND_TEMPL
+            }
+        );
+        assert!(!s.timestamp_enabled());
+        s.send_slice(b"abcdef").unwrap();
+        recv!(
+            s,
+            [TcpRepr {
+                seq_number: LOCAL_SEQ + 1,
+                ack_number: Some(REMOTE_SEQ + 1),
+                payload: &b"abcdef"[..],
+                timestamp: None,
+                ..RECV_TEMPL
+            }]
+        );
+    }
 }

src/wire/mod.rs

@@ -265,7 +265,7 @@ pub use self::udp::{Packet as UdpPacket, Repr as UdpRepr, HEADER_LEN as UDP_HEAD
 
 pub use self::tcp::{
     Control as TcpControl, Packet as TcpPacket, Repr as TcpRepr, SeqNumber as TcpSeqNumber,
-    TcpOption, HEADER_LEN as TCP_HEADER_LEN,
+    TcpOption, TcpTimestampGenerator, TcpTimestampRepr, HEADER_LEN as TCP_HEADER_LEN,
 };
 
 #[cfg(feature = "proto-dhcpv4")]

src/wire/tcp.rs

@@ -131,6 +131,7 @@ mod field {
     pub const OPT_WS: u8 = 0x03;
     pub const OPT_SACKPERM: u8 = 0x04;
     pub const OPT_SACKRNG: u8 = 0x05;
+    pub const OPT_TSTAMP: u8 = 0x08;
 }
 
 pub const HEADER_LEN: usize = field::URGENT.end;
@@ -624,6 +625,7 @@ pub enum TcpOption<'a> {
     WindowScale(u8),
     SackPermitted,
     SackRange([Option<(u32, u32)>; 3]),
+    TimeStamp { tsval: u32, tsecr: u32 },
     Unknown { kind: u8, data: &'a [u8] },
 }
 
@@ -687,6 +689,11 @@ impl<'a> TcpOption<'a> {
                         });
                         option = TcpOption::SackRange(sack_ranges);
                     }
+                    (field::OPT_TSTAMP, 10) => {
+                        let tsval = NetworkEndian::read_u32(&data[0..4]);
+                        let tsecr = NetworkEndian::read_u32(&data[4..8]);
+                        option = TcpOption::TimeStamp { tsval, tsecr };
+                    }
                     (_, _) => option = TcpOption::Unknown { kind, data },
                 }
             }
@@ -702,6 +709,7 @@ impl<'a> TcpOption<'a> {
             TcpOption::WindowScale(_) => 3,
             TcpOption::SackPermitted => 2,
             TcpOption::SackRange(s) => s.iter().filter(|s| s.is_some()).count() * 8 + 2,
+            TcpOption::TimeStamp { tsval: _, tsecr: _ } => 10,
             TcpOption::Unknown { data, .. } => 2 + data.len(),
         }
     }
@@ -749,6 +757,11 @@ impl<'a> TcpOption<'a> {
                                 NetworkEndian::write_u32(&mut buffer[pos + 4..], second);
                             });
                     }
+                    &TcpOption::TimeStamp { tsval, tsecr } => {
+                        buffer[0] = field::OPT_TSTAMP;
+                        NetworkEndian::write_u32(&mut buffer[2..], tsval);
+                        NetworkEndian::write_u32(&mut buffer[6..], tsecr);
+                    }
                     &TcpOption::Unknown {
                         kind,
                         data: provided,
@@ -806,9 +819,35 @@ pub struct Repr<'a> {
     pub max_seg_size: Option<u16>,
     pub sack_permitted: bool,
     pub sack_ranges: [Option<(u32, u32)>; 3],
+    pub timestamp: Option<TcpTimestampRepr>,
     pub payload: &'a [u8],
 }
 
+pub type TcpTimestampGenerator = fn() -> u32;
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct TcpTimestampRepr {
+    pub tsval: u32,
+    pub tsecr: u32,
+}
+
+impl TcpTimestampRepr {
+    pub fn new(tsval: u32, tsecr: u32) -> Self {
+        Self { tsval, tsecr }
+    }
+
+    pub fn generate_reply(&self, generator: Option<TcpTimestampGenerator>) -> Option<Self> {
+        Self::generate_reply_with_tsval(generator, self.tsval)
+    }
+
+    pub fn generate_reply_with_tsval(
+        generator: Option<TcpTimestampGenerator>,
+        tsval: u32,
+    ) -> Option<Self> {
+        Some(Self::new(generator?(), tsval))
+    }
+}
+
 impl<'a> Repr<'a> {
     /// Parse a Transmission Control Protocol packet and return a high-level representation.
     pub fn parse<T>(
@@ -856,6 +895,7 @@ impl<'a> Repr<'a> {
         let mut options = packet.options();
         let mut sack_permitted = false;
         let mut sack_ranges = [None, None, None];
+        let mut timestamp = None;
         while !options.is_empty() {
             let (next_options, option) = TcpOption::parse(options)?;
             match option {
@@ -882,6 +922,9 @@ impl<'a> Repr<'a> {
                 }
                 TcpOption::SackPermitted => sack_permitted = true,
                 TcpOption::SackRange(slice) => sack_ranges = slice,
+                TcpOption::TimeStamp { tsval, tsecr } => {
+                    timestamp = Some(TcpTimestampRepr::new(tsval, tsecr));
+                }
                 _ => (),
             }
             options = next_options;
@@ -898,6 +941,7 @@ impl<'a> Repr<'a> {
             max_seg_size: max_seg_size,
             sack_permitted: sack_permitted,
             sack_ranges: sack_ranges,
+            timestamp: timestamp,
             payload: packet.payload(),
         })
     }
@@ -917,6 +961,9 @@ impl<'a> Repr<'a> {
         if self.sack_permitted {
             length += 2;
         }
+        if self.timestamp.is_some() {
+            length += 10;
+        }
         let sack_range_len: usize = self
             .sack_ranges
             .iter()
@@ -978,6 +1025,14 @@ impl<'a> Repr<'a> {
                 let tmp = options;
                 options = TcpOption::SackRange(self.sack_ranges).emit(tmp);
             }
+            if let Some(timestamp) = self.timestamp {
+                let tmp = options;
+                options = TcpOption::TimeStamp {
+                    tsval: timestamp.tsval,
+                    tsecr: timestamp.tsecr,
+                }
+                .emit(tmp);
+            }
 
             if !options.is_empty() {
                 TcpOption::EndOfList.emit(options);
@@ -1058,6 +1113,9 @@ impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
                 TcpOption::WindowScale(value) => write!(f, " ws={value}")?,
                 TcpOption::SackPermitted => write!(f, " sACK")?,
                 TcpOption::SackRange(slice) => write!(f, " sACKr{slice:?}")?, // debug print conveniently includes the []s
+                TcpOption::TimeStamp { tsval, tsecr } => {
+                    write!(f, " tsval {tsval:08x} tsecr {tsecr:08x}")?
+                }
                 TcpOption::Unknown { kind, .. } => write!(f, " opt({kind})")?,
             }
             options = next_options;
@@ -1233,6 +1291,7 @@ mod test {
             max_seg_size: None,
             sack_permitted: false,
             sack_ranges: [None, None, None],
+            timestamp: None,
             payload: &PAYLOAD_BYTES,
         }
     }
@@ -1312,6 +1371,18 @@ mod test {
                 0x00, 0x26, 0x25, 0xa0, 0x34, 0x3e, 0xfc, 0xea, 0x34, 0x40, 0xae, 0xf0
             ]
         );
+        assert_option_parses!(
+            TcpOption::TimeStamp {
+                tsval: 5000000,
+                tsecr: 7000000
+            },
+            &[
+                0x08, // data length
+                0x0a, // type
+                0x00, 0x4c, 0x4b, 0x40, //tsval
+                0x00, 0x6a, 0xcf, 0xc0 //tsecr
+            ]
+        );
         assert_option_parses!(
             TcpOption::Unknown {
                 kind: 12,