smoltcp-rs · Jun 25, 2017 · Jun 25, 2017 · Jun 25, 2017
Showing with 59 additions and 7 deletions.

+1 −0 src/iface/ethernet.rs

+49 −5 src/socket/tcp.rs

+9 −2 src/wire/tcp.rs
diff --git a/src/iface/ethernet.rs b/src/iface/ethernet.rs
@@ -257,6 +257,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
                                     src_port:     tcp_packet.dst_port(),
                                     dst_port:     tcp_packet.src_port(),
                                     control:      TcpControl::Rst,
+                                    push:         false,
                                     seq_number:   tcp_packet.ack_number(),
                                     ack_number:   Some(tcp_packet.seq_number() +
                                                        tcp_packet.segment_len()),

diff --git a/src/socket/tcp.rs b/src/socket/tcp.rs
@@ -334,7 +334,6 @@ impl<'a> TcpSocket<'a> {
         self.remote_last_seq = TcpSeqNumber(0);
         self.remote_last_ack = TcpSeqNumber(0);
         self.remote_win_len  = 0;
-        self.remote_win_len  = 0;
         self.remote_mss      = DEFAULT_MSS;
         self.retransmit.reset();
         self.tx_buffer.clear();
@@ -940,6 +939,7 @@ impl<'a> TcpSocket<'a> {
             src_port:     self.local_endpoint.port,
             dst_port:     self.remote_endpoint.port,
             control:      TcpControl::None,
+            push:         false,
             seq_number:   self.local_seq_no,
             ack_number:   None,
             window_len:   self.rx_buffer.window() as u16,
@@ -986,7 +986,7 @@ impl<'a> TcpSocket<'a> {
                 _ => self.remote_last_seq = self.local_seq_no
             }
         } else if self.retransmit.may_send_new(timestamp) {
-            // The retransmit timer has reset, and we can send something new.
+            // The retransmit timer has been reset, and we can send something new.
         } else {
             // We don't have anything to send at this time.
             return Err(Error::Exhausted)
@@ -1034,6 +1034,10 @@ impl<'a> TcpSocket<'a> {
                                data.len(), offset);
                     repr.seq_number += offset;
                     repr.payload = data;
+                    // If that was the last data we had buffered, set the PSH flag.
+                    if offset + data.len() == self.tx_buffer.len() {
+                        repr.push = true;
+                    }
                     // Speculatively shrink the remote window. This will get updated
                     // the next time we receive a packet.
                     self.remote_win_len  -= data.len();
@@ -1091,7 +1095,7 @@ impl<'a> TcpSocket<'a> {
 
             if repr.control == TcpControl::Syn {
                 // First enable the option, without assigning any value, to get a correct
-                // result for (ip_repr:Unspecified).payload_len below.
+                // result for the payload_len field of ip_repr below.
                 repr.max_seg_size = Some(0);
             }
 
@@ -1200,14 +1204,14 @@ mod test {
 
     const SEND_TEMPL: TcpRepr<'static> = TcpRepr {
         src_port: REMOTE_PORT, dst_port: LOCAL_PORT,
-        control: TcpControl::None,
+        control: TcpControl::None, push: false,
         seq_number: TcpSeqNumber(0), ack_number: Some(TcpSeqNumber(0)),
         window_len: 256, max_seg_size: None,
         payload: &[]
     };
     const RECV_TEMPL:  TcpRepr<'static> = TcpRepr {
         src_port: LOCAL_PORT, dst_port: REMOTE_PORT,
-        control: TcpControl::None,
+        control: TcpControl::None, push: false,
         seq_number: TcpSeqNumber(0), ack_number: Some(TcpSeqNumber(0)),
         window_len: 64, max_seg_size: None,
         payload: &[]
@@ -1270,6 +1274,12 @@ mod test {
         ($socket:ident, $result:expr) =>
             (recv!($socket, time 0, $result));
         ($socket:ident, time $time:expr, $result:expr) =>
+            (recv(&mut $socket, $time, |repr| {
+                // Most of the time we don't care about the PSH flag.
+                let repr = repr.map(|r| TcpRepr { push: false, ..r });
+                assert_eq!(repr, $result)
+            }));
+        ($socket:ident, time $time:expr, $result:expr, exact) =>
             (recv(&mut $socket, $time, |repr| assert_eq!(repr, $result)));
     }
 
@@ -2580,4 +2590,38 @@ mod test {
             Ok(())
         }).unwrap();
     }
+
+    // =========================================================================================//
+    // Tests for flow control.
+    // =========================================================================================//
+
+    #[test]
+    fn test_psh() {
+        let mut s = socket_established();
+        s.remote_win_len = 6;
+        s.send_slice(b"abcdef").unwrap();
+        s.send_slice(b"123456").unwrap();
+        s.close();
+        recv!(s, time 0, Ok(TcpRepr {
+            seq_number: LOCAL_SEQ + 1,
+            ack_number: Some(REMOTE_SEQ + 1),
+            push:       false,
+            payload:    &b"abcdef"[..],
+            ..RECV_TEMPL
+        }), exact);
+        send!(s, time 0, TcpRepr {
+            seq_number: REMOTE_SEQ + 1,
+            ack_number: Some(LOCAL_SEQ + 1 + 6),
+            window_len: 6,
+            ..SEND_TEMPL
+        });
+        recv!(s, time 0, Ok(TcpRepr {
+            control:    TcpControl::Fin,
+            seq_number: LOCAL_SEQ + 1 + 6,
+            ack_number: Some(REMOTE_SEQ + 1),
+            push:       true,
+            payload:    &b"123456"[..],
+            ..RECV_TEMPL
+        }), exact);
+    }
 }
diff --git a/src/wire/tcp.rs b/src/wire/tcp.rs
@@ -615,6 +615,7 @@ pub struct Repr<'a> {
     pub src_port:     u16,
     pub dst_port:     u16,
     pub control:      Control,
+    pub push:         bool,
     pub seq_number:   SeqNumber,
     pub ack_number:   Option<SeqNumber>,
     pub window_len:   u16,
@@ -670,6 +671,7 @@ impl<'a> Repr<'a> {
             src_port:     packet.src_port(),
             dst_port:     packet.dst_port(),
             control:      control,
+            push:         packet.psh(),
             seq_number:   packet.seq_number(),
             ack_number:   ack_number,
             window_len:   packet.window_len(),
@@ -710,6 +712,7 @@ impl<'a> Repr<'a> {
             Control::Fin  => packet.set_fin(true),
             Control::Rst  => packet.set_rst(true)
         }
+        packet.set_psh(self.push);
         packet.set_ack(self.ack_number.is_some());
         {
             let mut options = packet.options_mut();
@@ -780,6 +783,9 @@ impl<'a> fmt::Display for Repr<'a> {
             Control::Rst => write!(f, " rst")?,
             Control::None => ()
         }
+        if self.push {
+            write!(f, " psh")?;
+        }
         write!(f, " seq={}", self.seq_number)?;
         if let Some(ack_number) = self.ack_number {
             write!(f, " ack={}", ack_number)?;
@@ -892,8 +898,8 @@ mod test {
         [0xbf, 0x00, 0x00, 0x50,
          0x01, 0x23, 0x45, 0x67,
          0x00, 0x00, 0x00, 0x00,
-         0x50, 0x02, 0x01, 0x23,
-         0x7a, 0x8d, 0x00, 0x00,
+         0x50, 0x0a, 0x01, 0x23,
+         0x7a, 0x85, 0x00, 0x00,
          0xaa, 0x00, 0x00, 0xff];
 
     fn packet_repr() -> Repr<'static> {
@@ -904,6 +910,7 @@ mod test {
             ack_number:   None,
             window_len:   0x0123,
             control:      Control::Syn,
+            push:         true,
             max_seg_size: None,
             payload:      &PAYLOAD_BYTES
         }