smoltcp-rs · Mar 5, 2017 · Mar 5, 2017 · Mar 5, 2017
Showing with 49 additions and 15 deletions.

+7 −7 .travis.yml

+3 −1 examples/client.rs

+2 −1 examples/server.rs

+25 −1 src/phy/sys/tap_interface.rs

+10 −3 src/phy/tap_interface.rs

+2 −2 src/socket/tcp.rs
diff --git a/.travis.yml b/.travis.yml
@@ -2,21 +2,21 @@ language: rust
 matrix:
   include:
     - rust: stable
-      env: FEATURES='use_std'
+      env: FEATURES='use_std' MODE='test'
     - rust: beta
-      env: FEATURES='use_std'
+      env: FEATURES='use_std' MODE='test'
     - rust: nightly
-      env: FEATURES='use_std'
+      env: FEATURES='use_std' MODE='test'
     - rust: nightly
-      env: FEATURES='use_std use_log'
+      env: FEATURES='use_std use_log' MODE='test'
     - rust: nightly
-      env: FEATURES='use_alloc use_collections'
+      env: FEATURES='use_alloc use_collections' MODE='build'
     - rust: nightly
-      env: FEATURES=''
+      env: FEATURES='' MODE='build'
   allow_failures:
     - rust: stable # until 1.15 comes out
 script:
-   - cargo test --no-default-features --features "$FEATURES"
+   - cargo "$MODE" --no-default-features --features "$FEATURES"
 notifications:
   irc:
     channels:

diff --git a/examples/client.rs b/examples/client.rs
@@ -8,6 +8,7 @@ mod utils;
 
 use std::str::{self, FromStr};
 use std::time::Instant;
+use smoltcp::Error;
 use smoltcp::wire::{EthernetAddress, IpAddress};
 use smoltcp::iface::{ArpCache, SliceArpCache, EthernetInterface};
 use smoltcp::socket::{AsSocket, SocketSet};
@@ -49,6 +50,7 @@ fn main() {
                 debug!("connected");
             } else if !socket.is_active() && tcp_active {
                 debug!("disconnected");
+                break
             }
             tcp_active = socket.is_active();
 
@@ -79,7 +81,7 @@ fn main() {
         let timestamp_ms = (timestamp.as_secs() * 1000) +
                            (timestamp.subsec_nanos() / 1000000) as u64;
         match iface.poll(&mut sockets, timestamp_ms) {
-            Ok(()) => (),
+            Ok(()) | Err(Error::Exhausted) => (),
             Err(e) => debug!("poll error: {}", e)
         }
     }

diff --git a/examples/server.rs b/examples/server.rs
@@ -8,6 +8,7 @@ mod utils;
 
 use std::str;
 use std::time::Instant;
+use smoltcp::Error;
 use smoltcp::wire::{EthernetAddress, IpAddress};
 use smoltcp::iface::{ArpCache, SliceArpCache, EthernetInterface};
 use smoltcp::socket::{AsSocket, SocketSet};
@@ -128,7 +129,7 @@ fn main() {
         let timestamp_ms = (timestamp.as_secs() * 1000) +
                            (timestamp.subsec_nanos() / 1000000) as u64;
         match iface.poll(&mut sockets, timestamp_ms) {
-            Ok(()) => (),
+            Ok(()) | Err(Error::Exhausted) => (),
             Err(e) => debug!("poll error: {}", e)
         }
     }

diff --git a/src/phy/sys/tap_interface.rs b/src/phy/sys/tap_interface.rs
@@ -1,5 +1,6 @@
-use libc;
+use std::mem;
 use std::io;
+use libc;
 use super::*;
 
 #[cfg(target_os = "linux")]
@@ -29,7 +30,28 @@ impl TapInterfaceDesc {
         ifreq_ioctl(self.lower, &mut self.ifreq, imp::TUNSETIFF).map(|_| ())
     }
 
+    fn wait(&mut self, ms: u32) -> io::Result<bool> {
+        unsafe {
+            let mut readfds = mem::uninitialized::<libc::fd_set>();
+            libc::FD_ZERO(&mut readfds);
+            libc::FD_SET(self.lower, &mut readfds);
+            let mut writefds = mem::uninitialized::<libc::fd_set>();
+            libc::FD_ZERO(&mut writefds);
+            let mut exceptfds = mem::uninitialized::<libc::fd_set>();
+            libc::FD_ZERO(&mut exceptfds);
+            let mut timeout = libc::timeval { tv_sec: 0, tv_usec: (ms * 1_000) as i64 };
+            let res = libc::select(self.lower + 1, &mut readfds, &mut writefds, &mut exceptfds,
+                                   &mut timeout);
+            if res == -1 { return Err(io::Error::last_os_error()) }
+            Ok(res == 0)
+        }
+    }
+
     pub fn recv(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
+        // FIXME: here we don't wait forever, in case we need to send several packets in a row
+        // ideally this would be implemented by going full nonblocking
+        if self.wait(100)? { return Err(io::ErrorKind::TimedOut)? }
+
         unsafe {
             let len = libc::read(self.lower, buffer.as_mut_ptr() as *mut libc::c_void,
                                  buffer.len());
@@ -39,6 +61,8 @@ impl TapInterfaceDesc {
     }
 
     pub fn send(&mut self, buffer: &[u8]) -> io::Result<usize> {
+        self.wait(100)?;
+
         unsafe {
             let len = libc::write(self.lower, buffer.as_ptr() as *const libc::c_void,
                                   buffer.len());

diff --git a/src/phy/tap_interface.rs b/src/phy/tap_interface.rs
@@ -38,9 +38,16 @@ impl Device for TapInterface {
     fn receive(&mut self) -> Result<Self::RxBuffer, Error> {
         let mut lower = self.lower.borrow_mut();
         let mut buffer = vec![0; self.mtu];
-        let size = lower.recv(&mut buffer[..]).unwrap();
-        buffer.resize(size, 0);
-        Ok(buffer)
+        match lower.recv(&mut buffer[..]) {
+            Ok(size) => {
+                buffer.resize(size, 0);
+                Ok(buffer)
+            }
+            Err(ref err) if err.kind() == io::ErrorKind::TimedOut => {
+                Err(Error::Exhausted)
+            }
+            Err(err) => panic!(err)
+        }
     }
 
     fn transmit(&mut self, length: usize) -> Result<Self::TxBuffer, Error> {

diff --git a/src/socket/tcp.rs b/src/socket/tcp.rs
@@ -674,7 +674,7 @@ impl<'a> TcpSocket<'a> {
             (State::SynSent, TcpRepr {
                 control: TcpControl::Rst, ack_number: Some(ack_number), ..
             }) => {
-                if ack_number != self.local_seq_no {
+                if ack_number != self.local_seq_no + 1 {
                     net_trace!("[{}]{}:{}: unacceptable RST|ACK in response to initial SYN",
                                self.debug_id, self.local_endpoint, self.remote_endpoint);
                     return Err(Error::Malformed)
@@ -1501,7 +1501,7 @@ mod test {
         send!(s, TcpRepr {
             control: TcpControl::Rst,
             seq_number: REMOTE_SEQ,
-            ack_number: Some(LOCAL_SEQ),
+            ack_number: Some(LOCAL_SEQ + 1),
             ..SEND_TEMPL
         });
         assert_eq!(s.state, State::Closed);