Implement TCP server sockets.

whitequark · whitequark · commit ab61890b0996 · 2016-12-20T19:51:52.000Z
diff --git a/examples/smoltcpserver.rs b/examples/smoltcpserver.rs
@@ -7,6 +7,7 @@ use smoltcp::phy::{Tracer, TapInterface};
 use smoltcp::wire::{EthernetFrame, EthernetAddress, IpAddress, IpEndpoint};
 use smoltcp::iface::{SliceArpCache, EthernetInterface};
 use smoltcp::socket::{UdpSocket, AsSocket, UdpSocketBuffer, UdpPacketBuffer};
+use smoltcp::socket::{TcpListener};
 
 fn main() {
     let ifname = env::args().nth(1).unwrap();
@@ -15,14 +16,18 @@ fn main() {
     let device = Tracer::<_, EthernetFrame<&[u8]>>::new(device);
     let arp_cache = SliceArpCache::new(vec![Default::default(); 8]);
 
+    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 endpoint = IpEndpoint::new(IpAddress::default(), 6969);
     let udp_socket = UdpSocket::new(endpoint, udp_rx_buffer, udp_tx_buffer);
 
+    let tcp_backlog = vec![None];
+    let tcp_listener = TcpListener::new(endpoint, tcp_backlog);
+
     let hardware_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
     let protocol_addrs = [IpAddress::v4(192, 168, 69, 1)];
-    let sockets = [udp_socket];
+    let sockets = [udp_socket, tcp_listener];
     let mut iface = EthernetInterface::new(device, arp_cache,
         hardware_addr, protocol_addrs, sockets);
 
@@ -32,22 +37,31 @@ fn main() {
             Err(e) => println!("error {}", e)
         }
 
-        let udp_socket = iface.sockets()[0].as_socket();
-        let client = match udp_socket.recv() {
-            Ok((endpoint, data)) => {
-                println!("data {:?} from {}", data, endpoint);
-                Some(endpoint)
+        {
+            let udp_socket: &mut UdpSocket = iface.sockets()[0].as_socket();
+            let udp_client = match udp_socket.recv() {
+                Ok((endpoint, data)) => {
+                    println!("data {:?} from {}", data, endpoint);
+                    Some(endpoint)
+                }
+                Err(Error::Exhausted) => {
+                    None
+                }
+                Err(e) => {
+                    println!("error {}", e);
+                    None
+                }
+            };
+            if let Some(endpoint) = udp_client {
+                udp_socket.send_slice(endpoint, "hihihi".as_bytes()).unwrap()
             }
-            Err(Error::Exhausted) => {
-                None
-            }
-            Err(e) => {
-                println!("error {}", e);
-                None
+        }
+
+        {
+            let tcp_listener: &mut TcpListener = iface.sockets()[1].as_socket();
+            if let Some(stream) = tcp_listener.accept() {
+                println!("client from {}", stream.remote_end())
             }
-        };
-        if let Some(endpoint) = client {
-            udp_socket.send_slice(endpoint, "hihihi".as_bytes()).unwrap()
         }
     }
 }
diff --git a/src/managed.rs b/src/managed.rs
@@ -35,8 +35,8 @@ impl<'a, T: 'a + fmt::Debug + ?Sized> fmt::Debug for Managed<'a, T> {
     }
 }
 
-impl<'a, 'b: 'a, T: 'b + ?Sized> From<&'b mut T> for Managed<'b, T> {
-    fn from(value: &'b mut T) -> Self {
+impl<'a, T: 'a + ?Sized> From<&'a mut T> for Managed<'a, T> {
+    fn from(value: &'a mut T) -> Self {
         Managed::Borrowed(value)
     }
 }
diff --git a/src/socket/mod.rs b/src/socket/mod.rs
@@ -21,6 +21,8 @@ pub use self::udp::SocketBuffer as UdpSocketBuffer;
 pub use self::udp::UdpSocket as UdpSocket;
 
 pub use self::tcp::SocketBuffer as TcpSocketBuffer;
+pub use self::tcp::Incoming as TcpIncoming;
+pub use self::tcp::Listener as TcpListener;
 
 /// A packet representation.
 ///
@@ -49,6 +51,7 @@ pub trait PacketRepr {
 /// since the lower layers treat the packet as an opaque octet sequence.
 pub enum Socket<'a, 'b: 'a> {
     Udp(UdpSocket<'a, 'b>),
+    TcpServer(TcpListener<'a>),
     #[doc(hidden)]
     __Nonexhaustive
 }
@@ -67,6 +70,8 @@ impl<'a, 'b> Socket<'a, 'b> {
         match self {
             &mut Socket::Udp(ref mut socket) =>
                 socket.collect(src_addr, dst_addr, protocol, payload),
+            &mut Socket::TcpServer(ref mut socket) =>
+                socket.collect(src_addr, dst_addr, protocol, payload),
             &mut Socket::__Nonexhaustive => unreachable!()
         }
     }
@@ -84,6 +89,8 @@ impl<'a, 'b> Socket<'a, 'b> {
         match self {
             &mut Socket::Udp(ref mut socket) =>
                 socket.dispatch(f),
+            &mut Socket::TcpServer(_) =>
+                Err(Error::Exhausted),
             &mut Socket::__Nonexhaustive => unreachable!()
         }
     }
@@ -105,3 +112,12 @@ impl<'a, 'b> AsSocket<UdpSocket<'a, 'b>> for Socket<'a, 'b> {
         }
     }
 }
+
+impl<'a, 'b> AsSocket<TcpListener<'a>> for Socket<'a, 'b> {
+    fn as_socket(&mut self) -> &mut TcpListener<'a> {
+        match self {
+            &mut Socket::TcpServer(ref mut socket) => socket,
+            _ => panic!(".as_socket::<TcpListener> called on wrong socket type")
+        }
+    }
+}
diff --git a/src/socket/tcp.rs b/src/socket/tcp.rs
@@ -1,4 +1,8 @@
+use Error;
 use Managed;
+use wire::{IpProtocol, IpAddress, IpEndpoint};
+use wire::{TcpPacket, TcpRepr, TcpControl};
+use socket::{Socket};
 
 /// A TCP stream ring buffer.
 #[derive(Debug)]
@@ -56,6 +60,92 @@ impl<'a> SocketBuffer<'a> {
     }
 }
 
+/// A description of incoming TCP connection.
+#[derive(Debug)]
+pub struct Incoming {
+    local_end:  IpEndpoint,
+    remote_end: IpEndpoint,
+    seq_number: u32
+}
+
+impl Incoming {
+    /// Return the local endpoint.
+    pub fn local_end(&self) -> IpEndpoint {
+        self.local_end
+    }
+
+    /// Return the remote endpoint.
+    pub fn remote_end(&self) -> IpEndpoint {
+        self.remote_end
+    }
+}
+
+/// A Transmission Control Protocol server socket.
+#[derive(Debug)]
+pub struct Listener<'a> {
+    endpoint:   IpEndpoint,
+    backlog:    Managed<'a, [Option<Incoming>]>,
+    accept_at:  usize,
+    length:     usize
+}
+
+impl<'a> Listener<'a> {
+    /// Create a server socket with the given backlog.
+    pub fn new<T>(endpoint: IpEndpoint, backlog: T) -> Socket<'a, 'static>
+            where T: Into<Managed<'a, [Option<Incoming>]>> {
+        Socket::TcpServer(Listener {
+            endpoint:  endpoint,
+            backlog:   backlog.into(),
+            accept_at: 0,
+            length:    0
+        })
+    }
+
+    /// Accept a connection from this server socket,
+    pub fn accept(&mut self) -> Option<Incoming> {
+        if self.length == 0 { return None }
+
+        let accept_at = self.accept_at;
+        self.accept_at = (self.accept_at + 1) % self.backlog.len();
+        self.length -= 1;
+
+        self.backlog[accept_at].take()
+    }
+
+    /// See [Socket::collect](enum.Socket.html#method.collect).
+    pub fn collect(&mut self, src_addr: &IpAddress, dst_addr: &IpAddress,
+                   protocol: IpProtocol, payload: &[u8])
+            -> Result<(), Error> {
+        if protocol != IpProtocol::Tcp { return Err(Error::Rejected) }
+
+        let packet = try!(TcpPacket::new(payload));
+        let repr = try!(TcpRepr::parse(&packet, src_addr, dst_addr));
+
+        if repr.dst_port != self.endpoint.port { return Err(Error::Rejected) }
+        if !self.endpoint.addr.is_unspecified() {
+            if self.endpoint.addr != *dst_addr { return Err(Error::Rejected) }
+        }
+
+        match (repr.control, repr.ack_number) {
+            (TcpControl::Syn, None) => {
+                if self.length == self.backlog.len() { return Err(Error::Exhausted) }
+
+                let inject_at = (self.accept_at + self.length) % self.backlog.len();
+                self.length += 1;
+
+                assert!(self.backlog[inject_at].is_none());
+                self.backlog[inject_at] = Some(Incoming {
+                    local_end:  IpEndpoint::new(*dst_addr, repr.dst_port),
+                    remote_end: IpEndpoint::new(*src_addr, repr.src_port),
+                    seq_number: repr.seq_number
+                });
+                Ok(())
+            }
+            _ => Err(Error::Rejected)
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/src/socket/udp.rs b/src/socket/udp.rs
@@ -17,7 +17,7 @@ impl<'a> PacketBuffer<'a> {
     pub fn new<T>(payload: T) -> PacketBuffer<'a>
             where T: Into<Managed<'a, [u8]>> {
         PacketBuffer {
-            endpoint: IpEndpoint::INVALID,
+            endpoint: IpEndpoint::UNSPECIFIED,
             size:     0,
             payload:  payload.into()
         }
diff --git a/src/wire/ip.rs b/src/wire/ip.rs
@@ -25,9 +25,9 @@ impl fmt::Display for Protocol {
 /// An internetworking address.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 pub enum Address {
-    /// An invalid address.
+    /// An unspecified address.
     /// May be used as a placeholder for storage where the address is not assigned yet.
-    Invalid,
+    Unspecified,
     /// An IPv4 address.
     Ipv4(Ipv4Address)
 }
@@ -41,23 +41,23 @@ impl Address {
     /// Query whether the address is a valid unicast address.
     pub fn is_unicast(&self) -> bool {
         match self {
-            &Address::Invalid    => false,
-            &Address::Ipv4(addr) => addr.is_unicast()
+            &Address::Unspecified => false,
+            &Address::Ipv4(addr)  => addr.is_unicast()
         }
     }
 
     /// Query whether the address falls into the "unspecified" range.
     pub fn is_unspecified(&self) -> bool {
         match self {
-            &Address::Invalid    => false,
-            &Address::Ipv4(addr) => addr.is_unspecified()
+            &Address::Unspecified => true,
+            &Address::Ipv4(addr)  => addr.is_unspecified()
         }
     }
 }
 
 impl Default for Address {
     fn default() -> Address {
-        Address::Invalid
+        Address::Unspecified
     }
 }
 
@@ -70,8 +70,8 @@ impl From<Ipv4Address> for Address {
 impl fmt::Display for Address {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &Address::Invalid    => write!(f, "(invalid)"),
-            &Address::Ipv4(addr) => write!(f, "{}", addr)
+            &Address::Unspecified => write!(f, "*"),
+            &Address::Ipv4(addr)  => write!(f, "{}", addr)
         }
     }
 }
@@ -84,7 +84,7 @@ pub struct Endpoint {
 }
 
 impl Endpoint {
-    pub const INVALID: Endpoint = Endpoint { addr: Address::Invalid, port: 0 };
+    pub const UNSPECIFIED: Endpoint = Endpoint { addr: Address::Unspecified, port: 0 };
 
     /// Create an endpoint address from given address and port.
     pub fn new(addr: Address, port: u16) -> Endpoint {

Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,8 @@ impl<'a, T: 'a + fmt::Debug + ?Sized> fmt::Debug for Managed<'a, T> {`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`38`		`-impl<'a, 'b: 'a, T: 'b + ?Sized> From<&'b mut T> for Managed<'b, T> {`
`39`		`- fn from(value: &'b mut T) -> Self {`
	`38`	`+impl<'a, T: 'a + ?Sized> From<&'a mut T> for Managed<'a, T> {`
	`39`	`+ fn from(value: &'a mut T) -> Self {`
`40`	`40`	`Managed::Borrowed(value)`
`41`	`41`	`}`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,8 @@ pub use self::udp::SocketBuffer as UdpSocketBuffer;`
`21`	`21`	`pub use self::udp::UdpSocket as UdpSocket;`
`22`	`22`
`23`	`23`	`pub use self::tcp::SocketBuffer as TcpSocketBuffer;`
	`24`	`+pub use self::tcp::Incoming as TcpIncoming;`
	`25`	`+pub use self::tcp::Listener as TcpListener;`
`24`	`26`
`25`	`27`	`/// A packet representation.`
`26`	`28`	`///`
`@@ -49,6 +51,7 @@ pub trait PacketRepr {`
`49`	`51`	`/// since the lower layers treat the packet as an opaque octet sequence.`
`50`	`52`	`pub enum Socket<'a, 'b: 'a> {`
`51`	`53`	`Udp(UdpSocket<'a, 'b>),`
	`54`	`+ TcpServer(TcpListener<'a>),`
`52`	`55`	`#[doc(hidden)]`
`53`	`56`	`__Nonexhaustive`
`54`	`57`	`}`
`@@ -67,6 +70,8 @@ impl<'a, 'b> Socket<'a, 'b> {`
`67`	`70`	`match self {`
`68`	`71`	`&mut Socket::Udp(ref mut socket) =>`
`69`	`72`	`socket.collect(src_addr, dst_addr, protocol, payload),`
	`73`	`+ &mut Socket::TcpServer(ref mut socket) =>`
	`74`	`+ socket.collect(src_addr, dst_addr, protocol, payload),`
`70`	`75`	`&mut Socket::__Nonexhaustive => unreachable!()`
`71`	`76`	`}`
`72`	`77`	`}`
`@@ -84,6 +89,8 @@ impl<'a, 'b> Socket<'a, 'b> {`
`84`	`89`	`match self {`
`85`	`90`	`&mut Socket::Udp(ref mut socket) =>`
`86`	`91`	`socket.dispatch(f),`
	`92`	`+ &mut Socket::TcpServer(_) =>`
	`93`	`+ Err(Error::Exhausted),`
`87`	`94`	`&mut Socket::__Nonexhaustive => unreachable!()`
`88`	`95`	`}`
`89`	`96`	`}`
`@@ -105,3 +112,12 @@ impl<'a, 'b> AsSocket<UdpSocket<'a, 'b>> for Socket<'a, 'b> {`
`105`	`112`	`}`
`106`	`113`	`}`
`107`	`114`	`}`
	`115`	`+`
	`116`	`+impl<'a, 'b> AsSocket<TcpListener<'a>> for Socket<'a, 'b> {`
	`117`	`+ fn as_socket(&mut self) -> &mut TcpListener<'a> {`
	`118`	`+ match self {`
	`119`	`+ &mut Socket::TcpServer(ref mut socket) => socket,`
	`120`	`+ _ => panic!(".as_socket::<TcpListener> called on wrong socket type")`
	`121`	`+ }`
	`122`	`+ }`
	`123`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ impl<'a> PacketBuffer<'a> {`
`17`	`17`	`pub fn new<T>(payload: T) -> PacketBuffer<'a>`
`18`	`18`	`where T: Into<Managed<'a, [u8]>> {`
`19`	`19`	`PacketBuffer {`
`20`		`- endpoint: IpEndpoint::INVALID,`
	`20`	`+ endpoint: IpEndpoint::UNSPECIFIED,`
`21`	`21`	`size: 0,`
`22`	`22`	`payload: payload.into()`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,9 +25,9 @@ impl fmt::Display for Protocol {`
`25`	`25`	`/// An internetworking address.`
`26`	`26`	`#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]`
`27`	`27`	`pub enum Address {`
`28`		`- /// An invalid address.`
	`28`	`+ /// An unspecified address.`
`29`	`29`	`/// May be used as a placeholder for storage where the address is not assigned yet.`
`30`		`- Invalid,`
	`30`	`+ Unspecified,`
`31`	`31`	`/// An IPv4 address.`
`32`	`32`	`Ipv4(Ipv4Address)`
`33`	`33`	`}`
`@@ -41,23 +41,23 @@ impl Address {`
`41`	`41`	`/// Query whether the address is a valid unicast address.`
`42`	`42`	`pub fn is_unicast(&self) -> bool {`
`43`	`43`	`match self {`
`44`		`- &Address::Invalid => false,`
`45`		`- &Address::Ipv4(addr) => addr.is_unicast()`
	`44`	`+ &Address::Unspecified => false,`
	`45`	`+ &Address::Ipv4(addr) => addr.is_unicast()`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`/// Query whether the address falls into the "unspecified" range.`
`50`	`50`	`pub fn is_unspecified(&self) -> bool {`
`51`	`51`	`match self {`
`52`		`- &Address::Invalid => false,`
`53`		`- &Address::Ipv4(addr) => addr.is_unspecified()`
	`52`	`+ &Address::Unspecified => true,`
	`53`	`+ &Address::Ipv4(addr) => addr.is_unspecified()`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`impl Default for Address {`
`59`	`59`	`fn default() -> Address {`
`60`		`- Address::Invalid`
	`60`	`+ Address::Unspecified`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`@@ -70,8 +70,8 @@ impl From<Ipv4Address> for Address {`
`70`	`70`	`impl fmt::Display for Address {`
`71`	`71`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`72`	`72`	`match self {`
`73`		`- &Address::Invalid => write!(f, "(invalid)"),`
`74`		`- &Address::Ipv4(addr) => write!(f, "{}", addr)`
	`73`	`+ &Address::Unspecified => write!(f, "*"),`
	`74`	`+ &Address::Ipv4(addr) => write!(f, "{}", addr)`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`}`
`@@ -84,7 +84,7 @@ pub struct Endpoint {`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`impl Endpoint {`
`87`		`- pub const INVALID: Endpoint = Endpoint { addr: Address::Invalid, port: 0 };`
	`87`	`+ pub const UNSPECIFIED: Endpoint = Endpoint { addr: Address::Unspecified, port: 0 };`
`88`	`88`
`89`	`89`	`/// Create an endpoint address from given address and port.`
`90`	`90`	`pub fn new(addr: Address, port: u16) -> Endpoint {`