zephyr: net: Add TCP implementation

Add TcpListener and TcpStream structs which work much like those in the
Rust std library.

Also add a basic test case to confirm that the TCP abstractions have the
basic functions working.

Signed-off-by: Matt Rodgers <[email protected]>

Author: mrodgers-witekio

tests/net/tcp/CMakeLists.txt

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(tcp_rust)
+
+rust_cargo_application()

tests/net/tcp/Cargo.toml

@@ -0,0 +1,16 @@
+# Copyright (c) 2025 Witekio
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+# This must be rustapp for now.
+name = "rustapp"
+version = "0.1.0"
+edition = "2021"
+description = "Tests of TCP sockets"
+license = "Apache-2.0 or MIT"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+zephyr = "0.1.0"

tests/net/tcp/prj.conf

@@ -0,0 +1,22 @@
+# Copyright (c) 2025 Witekio
+# SPDX-License-Identifier: Apache-2.0
+
+CONFIG_RUST=y
+CONFIG_RUST_ALLOC=y # For threads
+CONFIG_MAIN_STACK_SIZE=2048
+
+# Networking config
+CONFIG_NETWORKING=y
+CONFIG_NET_IPV4=y
+CONFIG_NET_IPV6=y
+CONFIG_NET_TCP=y
+CONFIG_NET_SOCKETS=y
+CONFIG_NET_PKT_RX_COUNT=16
+CONFIG_NET_PKT_TX_COUNT=16
+
+# Networking drivers
+CONFIG_NET_DRIVERS=y
+CONFIG_NET_TEST=y
+CONFIG_NET_LOOPBACK=y
+CONFIG_TEST_RANDOM_GENERATOR=y
+

tests/net/tcp/src/lib.rs

@@ -0,0 +1,61 @@
+// Copyright (c) 2025 Witekio
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_std]
+
+use zephyr::net::{TcpListener, TcpStream};
+use zephyr::printkln;
+
+#[no_mangle]
+extern "C" fn rust_main() {
+    let tx_data: [u8; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
+    let mut server_recv_buf: [u8; 64] = [0; 64];
+    let mut client_recv_buf: [u8; 64] = [0; 64];
+
+    // The test creates client and server TcpStreams, and echo's some data between them to verify
+    // that the TCP connection is functioning
+    printkln!("Starting tests");
+
+    let server_sockaddr = "0.0.0.0:4242"
+        .parse()
+        .expect("Failed to parse server sockaddr");
+
+    let connect_sockaddr = "127.0.0.1:4242"
+        .parse()
+        .expect("Failed to parse connect sockaddr");
+
+    let mut listener = TcpListener::bind(&server_sockaddr).expect("Failed to create TcpListener");
+
+    let mut client_stream =
+        TcpStream::connect(&connect_sockaddr).expect("Failed to create client TcpStream");
+
+    let sent = client_stream
+        .send(&tx_data)
+        .expect("Client failed to send data");
+
+    assert_eq!(sent, tx_data.len());
+
+    let (mut server_stream, _) = listener.accept().expect("Failed to accept connection");
+
+    let recvd = server_stream
+        .recv(&mut server_recv_buf)
+        .expect("Server failed to receive data");
+
+    assert_eq!(recvd, tx_data.len());
+    assert_eq!(server_recv_buf[0..recvd], tx_data);
+
+    let sent = server_stream
+        .send(&server_recv_buf[0..recvd])
+        .expect("Failed to send data");
+
+    assert_eq!(sent, recvd);
+
+    let recvd = client_stream
+        .recv(&mut client_recv_buf)
+        .expect("Client failed to receive data");
+
+    assert_eq!(recvd, sent);
+    assert_eq!(client_recv_buf[0..recvd], tx_data);
+
+    printkln!("All tests passed");
+}

tests/net/tcp/testcase.yaml

@@ -0,0 +1,15 @@
+common:
+  filter: CONFIG_RUST_SUPPORTED
+  platform_allow:
+    - qemu_cortex_m0
+    - qemu_cortex_m3
+    - qemu_riscv32
+    - qemu_riscv64
+    - nrf52840dk/nrf52840
+tests:
+  test.rust.tcp:
+    harness: console
+    harness_config:
+      type: one_line
+      regex:
+        - "All tests passed"

tests/net/udp/prj.conf

@@ -17,6 +17,3 @@ CONFIG_NET_TEST=y
 CONFIG_NET_LOOPBACK=y
 CONFIG_TEST_RANDOM_GENERATOR=y
 
-# Avoid tests blocking forever if something goes wrong
-CONFIG_NET_CONTEXT_SNDTIMEO=y
-CONFIG_NET_CONTEXT_RCVTIMEO=y

zephyr/src/net/mod.rs

@@ -10,6 +10,7 @@ mod socket;
 
 use crate::error::Result;
 use crate::net::socket::{Domain, Protocol, SockType, Socket};
+use core::ffi::c_int;
 use core::net::SocketAddr;
 
 /// UDP socket.
@@ -26,18 +27,16 @@ pub struct UdpSocket {
 impl UdpSocket {
     /// Create a UDP socket bound to the provided socket address.
     pub fn bind(addr: &SocketAddr) -> Result<Self> {
-        let domain = match addr {
-            SocketAddr::V4(_) => Domain::AfInet,
-            SocketAddr::V6(_) => Domain::AfInet6,
-        };
+        let domain = Domain::from_socket_addr(addr);
 
-        let mut sock = Socket::new(domain, SockType::Dgram, Protocol::IpprotoUdp)?;
+        let mut sock = Socket::new(domain, SockType::Dgram, Protocol::IpProtoUdp)?;
         sock.bind(addr)?;
 
         Ok(Self { sock })
     }
 
-    /// Send data to the specified socket address.
+    /// Send data to the specified socket address, returning the number of bytes that were actually
+    /// sent.
     pub fn send_to(&self, buf: &[u8], addr: &SocketAddr) -> Result<usize> {
         self.sock.send_to(buf, addr)
     }
@@ -47,3 +46,73 @@ impl UdpSocket {
         self.sock.recv_from(buf)
     }
 }
+
+/// TCP Listener
+///
+/// A TCP listener can be created by binding to a local socket address. It represents a server
+/// socket which is ready to accept incoming connections.
+///
+/// Connections can be accepted by calling [`accept`] on the TcpListener.
+///
+/// [`accept`]: TcpListener::accept
+pub struct TcpListener {
+    sock: Socket,
+}
+
+impl TcpListener {
+    /// Create a TCP listener bound to and listening on the provided socket address.
+    pub fn bind(addr: &SocketAddr) -> Result<Self> {
+        let domain = Domain::from_socket_addr(addr);
+
+        let mut sock = Socket::new(domain, SockType::Stream, Protocol::IpProtoTcp)?;
+        sock.bind(addr)?;
+        sock.listen()?;
+
+        Ok(Self { sock })
+    }
+
+    /// Accept a single connection from the TCP listener.
+    pub fn accept(&mut self) -> Result<(TcpStream, SocketAddr)> {
+        let (sock, peer) = self.sock.accept()?;
+        Ok((TcpStream { sock }, peer))
+    }
+}
+
+/// TCP Stream
+///
+/// This represents a connected TCP socket, which may be either a client or server socket. Data can
+/// be sent and received over the stream using the [`send`] and [`recv`] methods.
+///
+/// There are two ways to get a `TcpStream`:
+/// - Call [`accept`] on a [`TcpListener`] to get a connected stream as a server.
+/// - Use [`connect`] to get a connected stream as a client
+///
+/// [`accept`]: TcpListener::accept
+/// [`connect`]: TcpStream::connect
+/// [`send`]: TcpStream::send
+/// [`recv`]: TcpStream::recv
+pub struct TcpStream {
+    sock: Socket,
+}
+
+impl TcpStream {
+    /// Create a TCP stream by connecting to the provided socket address.
+    pub fn connect(addr: &SocketAddr) -> Result<Self> {
+        let domain = Domain::from_socket_addr(addr);
+
+        let mut sock = Socket::new(domain, SockType::Stream, Protocol::IpProtoTcp)?;
+        sock.connect(addr)?;
+
+        Ok(Self { sock })
+    }
+
+    /// Send data over the TCP stream, returning the number of bytes that were actually sent.
+    pub fn send(&mut self, buf: &[u8]) -> Result<usize> {
+        self.sock.send(buf)
+    }
+
+    /// Receive data from the TCP stream, returning the number of bytes received.
+    pub fn recv(&mut self, buf: &mut [u8]) -> Result<usize> {
+        self.sock.recv(buf)
+    }
+}

zephyr/src/net/socket.rs

@@ -5,9 +5,7 @@
 
 use crate::error::{to_result_errno, Result};
 use crate::net::ipaddr::{try_sockaddr_from_c, try_sockaddr_to_c};
-use crate::raw::{
-    sockaddr, socklen_t, zsock_bind, zsock_close, zsock_recvfrom, zsock_sendto, zsock_socket,
-};
+use crate::raw::{self, sockaddr, socklen_t};
 use core::ffi::{c_int, c_void};
 use core::mem::MaybeUninit;
 use core::net::SocketAddr;
@@ -18,16 +16,31 @@ pub(crate) enum Domain {
     AfInet6 = crate::raw::AF_INET6 as isize,
 }
 
+impl Domain {
+    /// Get the Domain associated with a SocketAddr
+    pub(crate) fn from_socket_addr(addr: &SocketAddr) -> Self {
+        match addr {
+            SocketAddr::V4(_) => Self::AfInet,
+            SocketAddr::V6(_) => Self::AfInet6,
+        }
+    }
+}
+
 #[derive(Debug, Copy, Clone)]
 pub(crate) enum SockType {
     Dgram = crate::raw::net_sock_type_SOCK_DGRAM as isize,
+    Stream = crate::raw::net_sock_type_SOCK_STREAM as isize,
 }
 
 #[derive(Debug, Copy, Clone)]
 pub(crate) enum Protocol {
-    IpprotoUdp = crate::raw::net_ip_protocol_IPPROTO_UDP as isize,
+    IpProtoUdp = crate::raw::net_ip_protocol_IPPROTO_UDP as isize,
+    IpProtoTcp = crate::raw::net_ip_protocol_IPPROTO_TCP as isize,
 }
 
+// We could make the backlog configurable, but for now just pick a sensible default value
+const LISTEN_BACKLOG: c_int = 10;
+
 /// Socket type implementing minimal safe wrappers around Zephyr's C socket API
 pub(crate) struct Socket {
     fd: c_int,
@@ -38,7 +51,8 @@ impl Socket {
     ///
     /// This is a minimal wrapper around zsock_socket
     pub(crate) fn new(domain: Domain, sock_type: SockType, protocol: Protocol) -> Result<Socket> {
-        let res = unsafe { zsock_socket(domain as c_int, sock_type as c_int, protocol as c_int) };
+        let res =
+            unsafe { raw::zsock_socket(domain as c_int, sock_type as c_int, protocol as c_int) };
 
         let fd = to_result_errno(res)?;
 
@@ -51,12 +65,52 @@ impl Socket {
     pub(crate) fn bind(&mut self, addr: &SocketAddr) -> Result<()> {
         let (sockaddr, socklen) = try_sockaddr_to_c(addr)?;
 
-        let res = unsafe { zsock_bind(self.fd, &sockaddr as *const sockaddr, socklen) };
+        let res = unsafe { raw::zsock_bind(self.fd, &sockaddr as *const sockaddr, socklen) };
 
         let _ = to_result_errno(res)?;
         Ok(())
     }
 
+    /// Connect a socket to a peer socket address
+    ///
+    /// This is a minimal wrapper around zsock_connect
+    pub(crate) fn connect(&mut self, peer: &SocketAddr) -> Result<()> {
+        let (sa, socklen) = try_sockaddr_to_c(peer)?;
+
+        let res = unsafe { raw::zsock_connect(self.fd, &sa as *const sockaddr, socklen) };
+        let _ = to_result_errno(res)?;
+        Ok(())
+    }
+
+    /// Listen for incoming connections on a socket
+    ///
+    /// This is a minimal wrapper around zsock_listen
+    pub(crate) fn listen(&mut self) -> Result<()> {
+        let res = unsafe { raw::zsock_listen(self.fd, LISTEN_BACKLOG) };
+        let _ = to_result_errno(res)?;
+        Ok(())
+    }
+
+    /// Accept a connection on a listening socket
+    ///
+    /// This is a minimal wrapper around zsock_accept
+    pub(crate) fn accept(&mut self) -> Result<(Socket, SocketAddr)> {
+        let mut sa = MaybeUninit::<sockaddr>::uninit();
+        let mut socklen: socklen_t = core::mem::size_of::<sockaddr>();
+
+        let res =
+            unsafe { raw::zsock_accept(self.fd, sa.as_mut_ptr(), &mut socklen as *mut socklen_t) };
+
+        let new_fd = to_result_errno(res)?;
+        let new_sock = Socket { fd: new_fd };
+
+        // SAFETY: `zsock_accept` returned a success code, so it has populated the sockaddr.
+        let sa = unsafe { sa.assume_init() };
+
+        let peer_sa = try_sockaddr_from_c(&sa, socklen)?;
+        Ok((new_sock, peer_sa))
+    }
+
     /// Receive from the socket, returning the data length and peer address it was received from
     ///
     /// This is a minimal wrapper around zsock_recvfrom
@@ -65,7 +119,7 @@ impl Socket {
         let mut socklen: socklen_t = core::mem::size_of::<sockaddr>();
 
         let res = unsafe {
-            zsock_recvfrom(
+            raw::zsock_recvfrom(
                 self.fd,
                 buf.as_mut_ptr() as *mut c_void,
                 buf.len(),
@@ -87,11 +141,11 @@ impl Socket {
     /// Send data to the specified socket address.
     ///
     /// This is a minimal wrapper around zsock_sendto
-    pub fn send_to(&self, buf: &[u8], addr: &SocketAddr) -> Result<usize> {
-        let (sa, socklen) = try_sockaddr_to_c(addr)?;
+    pub fn send_to(&self, buf: &[u8], peer: &SocketAddr) -> Result<usize> {
+        let (sa, socklen) = try_sockaddr_to_c(peer)?;
 
         let res = unsafe {
-            zsock_sendto(
+            raw::zsock_sendto(
                 self.fd,
                 buf.as_ptr() as *const c_void,
                 buf.len(),
@@ -104,12 +158,27 @@ impl Socket {
         let sent = to_result_errno(res)?;
         Ok(sent as usize)
     }
+
+    /// Send data on a socket
+    pub fn send(&mut self, buf: &[u8]) -> Result<usize> {
+        let res = unsafe { raw::zsock_send(self.fd, buf.as_ptr() as *const c_void, buf.len(), 0) };
+        let sent = to_result_errno(res)?;
+        Ok(sent as usize)
+    }
+
+    /// Receive data from a socket
+    pub fn recv(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let res =
+            unsafe { raw::zsock_recv(self.fd, buf.as_mut_ptr() as *mut c_void, buf.len(), 0) };
+        let recvd = to_result_errno(res)?;
+        Ok(recvd as usize)
+    }
 }
 
 impl Drop for Socket {
     fn drop(&mut self) {
         unsafe {
-            let _ = zsock_close(self.fd);
+            let _ = raw::zsock_close(self.fd);
         }
     }
 }