Shrink the buffers in examples for ease of testing.

README.md

@@ -109,6 +109,8 @@ It responds to:
   * UDP packets on port 6969 (`socat stdio udp4-connect:192.168.69.1:6969 <<<"abcdefg"`),
   * TCP packets on port 6969 (`socat stdio tcp4-connect:192.168.69.1:6969 <<<"abcdefg"`),
 
+The buffers are only 64 bytes long, for convenience of testing resource exhaustion conditions.
+
 License
 -------
 

examples/smoltcpserver.rs

@@ -4,6 +4,7 @@ extern crate log;
 extern crate env_logger;
 extern crate smoltcp;
 
+use std::str;
 use std::env;
 use std::time::Instant;
 use log::{LogLevelFilter, LogRecord};
@@ -49,12 +50,12 @@ fn main() {
 
     let endpoint = IpEndpoint::new(IpAddress::default(), 6969);
 
-    let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 2048])]);
-    let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 2048])]);
+    let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 64])]);
+    let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 64])]);
     let udp_socket = UdpSocket::new(endpoint, udp_rx_buffer, udp_tx_buffer);
 
-    let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; 8192]);
-    let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; 8192]);
+    let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; 64]);
+    let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; 64]);
     let mut tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
     (tcp_socket.as_socket() : &mut TcpSocket).listen(endpoint);
 
@@ -74,7 +75,8 @@ fn main() {
             let socket: &mut UdpSocket = iface.sockets()[0].as_socket();
             let client = match socket.recv() {
                 Ok((endpoint, data)) => {
-                    debug!("udp recv data: {:?} from {}", data, endpoint);
+                    debug!("udp recv data: {} from {}",
+                           str::from_utf8(data.as_ref()).unwrap(), endpoint);
                     Some(endpoint)
                 }
                 Err(Error::Exhausted) => {
@@ -87,7 +89,8 @@ fn main() {
             };
             if let Some(endpoint) = client {
                 let data = b"yo dawg";
-                debug!("udp send data: {:?}", data);
+                debug!("udp send data: {}",
+                       str::from_utf8(data.as_ref()).unwrap());
                 socket.send_slice(endpoint, data).unwrap()
             }
         }
@@ -97,7 +100,8 @@ fn main() {
             let data = {
                 let mut data = socket.recv(128).to_owned();
                 if data.len() > 0 {
-                    debug!("tcp recv data: {:?}", &data[..]);
+                    debug!("tcp recv data: {}",
+                           str::from_utf8(data.as_ref()).unwrap());
                     data = data.split(|&b| b == b'\n').next().unwrap().to_owned();
                     data.reverse();
                     data.extend(b"\n");
@@ -105,7 +109,8 @@ fn main() {
                 data
             };
             if data.len() > 0 {
-                debug!("tcp send data: {:?}", &data[..]);
+                debug!("tcp send data: {}",
+                       str::from_utf8(data.as_ref()).unwrap());
                 socket.send_slice(&data[..]);
             }
         }

src/socket/tcp.rs

@@ -266,6 +266,7 @@ impl<'a> TcpSocket<'a> {
     /// See also [send](#method.send).
     pub fn send_slice(&mut self, data: &[u8]) -> usize {
         let buffer = self.send(data.len());
+        let data = &data[..buffer.len()];
         buffer.copy_from_slice(data);
         buffer.len()
     }
@@ -279,7 +280,7 @@ impl<'a> TcpSocket<'a> {
         let buffer = self.rx_buffer.dequeue(size);
         self.remote_seq_no += buffer.len() as i32;
         if buffer.len() > 0 {
-            net_trace!("tcp:{}:{}: receive {} buffered octets",
+            net_trace!("tcp:{}:{}: rx buffer: dequeueing {} octets",
                        self.local_endpoint, self.remote_endpoint, buffer.len());
         }
         buffer
@@ -293,7 +294,8 @@ impl<'a> TcpSocket<'a> {
     /// See also [recv](#method.recv).
     pub fn recv_slice(&mut self, data: &mut [u8]) -> usize {
         let buffer = self.recv(data.len());
-        data[..buffer.len()].copy_from_slice(buffer);
+        let data = &mut data[..buffer.len()];
+        data.copy_from_slice(buffer);
         buffer.len()
     }
 
@@ -447,12 +449,8 @@ impl<'a> TcpSocket<'a> {
         if let Some(ack_number) = repr.ack_number {
             let control_len =
                 if old_state == State::SynReceived { 1 } else { 0 };
-            if control_len > 0 {
-                net_trace!("tcp:{}:{}: ACK for a control flag",
-                           self.local_endpoint, self.remote_endpoint);
-            }
             if ack_number - self.local_seq_no - control_len > 0 {
-                net_trace!("tcp:{}:{}: ACK for {} octets",
+                net_trace!("tcp:{}:{}: tx buffer: dequeueing {} octets",
                            self.local_endpoint, self.remote_endpoint,
                            ack_number - self.local_seq_no - control_len);
             }
@@ -462,7 +460,7 @@ impl<'a> TcpSocket<'a> {
 
         // Enqueue payload octets, which is guaranteed to be in order, unless we already did.
         if repr.payload.len() > 0 {
-            net_trace!("tcp:{}:{}: receiving {} octets",
+            net_trace!("tcp:{}:{}: rx buffer: enqueueing {} octets",
                        self.local_endpoint, self.remote_endpoint, repr.payload.len());
             self.rx_buffer.enqueue_slice(repr.payload)
         }
@@ -604,7 +602,7 @@ mod test {
         src_port: LOCAL_PORT, dst_port: REMOTE_PORT,
         control: TcpControl::None,
         seq_number: 0, ack_number: Some(0),
-        window_len: 128, payload: &[]
+        window_len: 64, payload: &[]
     };
 
     fn send(socket: &mut TcpSocket, repr: &TcpRepr) -> Result<(), Error> {
@@ -684,8 +682,8 @@ mod test {
     fn socket() -> TcpSocket<'static> {
         init_logger();
 
-        let rx_buffer = SocketBuffer::new(vec![0; 128]);
-        let tx_buffer = SocketBuffer::new(vec![0; 128]);
+        let rx_buffer = SocketBuffer::new(vec![0; 64]);
+        let tx_buffer = SocketBuffer::new(vec![0; 64]);
         match TcpSocket::new(rx_buffer, tx_buffer) {
             Socket::Tcp(socket) => socket,
             _ => unreachable!()
@@ -840,7 +838,7 @@ mod test {
         recv!(s, [TcpRepr {
             seq_number: LOCAL_SEQ + 1,
             ack_number: Some(REMOTE_SEQ + 1 + 6),
-            window_len: 122,
+            window_len: 58,
             ..RECV_TEMPL
         }]);
         assert_eq!(s.rx_buffer.dequeue(6), &b"abcdef"[..]);