zephyr: net: add initial support for UDP sockets

Initial implementation of a Rust wrapper around the Zephyr networking
API for UDP sockets, loosely based on the UdpSocket in the Rust std
library. It's possible to create/bind a socket and sendto/recvfrom data,
but not much else.

There is also some supporting functionality for converting IP addresses
and socket addresses between the C representation and Rust's core::net
types.

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

Author: mrodgers-witekio

tests/net/udp/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(udp_rust)
+
+rust_cargo_application()

tests/net/udp/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 UDP sockets"
+license = "Apache-2.0 or MIT"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+zephyr = "0.1.0"

tests/net/udp/prj.conf

@@ -0,0 +1,22 @@
+# Copyright (c) 2025 Witekio
+# SPDX-License-Identifier: Apache-2.0
+
+CONFIG_RUST=y
+CONFIG_MAIN_STACK_SIZE=2048
+
+# Networking config
+CONFIG_NETWORKING=y
+CONFIG_NET_IPV4=y
+CONFIG_NET_IPV6=y
+CONFIG_NET_UDP=y
+CONFIG_NET_SOCKETS=y
+
+# Networking drivers
+CONFIG_NET_DRIVERS=y
+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

tests/net/udp/src/lib.rs

@@ -0,0 +1,38 @@
+// Copyright (c) 2025 Witekio
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_std]
+
+use zephyr::net::udp::UdpSocket;
+use zephyr::printkln;
+
+#[no_mangle]
+extern "C" fn rust_main() {
+    printkln!("Starting tests");
+
+    let rx_sa = "127.0.0.1:4242"
+        .parse()
+        .expect("Failed to parse RX SocketAddr");
+    let tx_sa = "127.0.0.1:12345"
+        .parse()
+        .expect("Failed to parse TX SocketAddr");
+
+    let rx_sock = UdpSocket::bind(&rx_sa).expect("Failed to create RX UDP socket");
+    let tx_sock = UdpSocket::bind(&tx_sa).expect("Failed to create TX UDP socket");
+
+    let tx_data: [u8; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
+    let sent = tx_sock
+        .send_to(&tx_data, &rx_sa)
+        .expect("Failed to send data");
+    assert_eq!(sent, tx_data.len());
+
+    let mut rx_data: [u8; 8] = [0; 8];
+    let (recvd, peer) = rx_sock
+        .recv_from(&mut rx_data)
+        .expect("Failed to receive data");
+    assert_eq!(recvd, tx_data.len());
+    assert_eq!(tx_data, rx_data);
+    assert_eq!(peer, tx_sa);
+
+    printkln!("All tests passed");
+}

tests/net/udp/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.udp:
+    harness: console
+    harness_config:
+      type: one_line
+      regex:
+        - "All tests passed"

zephyr/src/lib.rs

@@ -83,6 +83,7 @@ pub mod error;
 #[cfg(CONFIG_RUST_ALLOC)]
 pub mod kio;
 pub mod logging;
+pub mod net;
 pub mod object;
 #[cfg(CONFIG_RUST_ALLOC)]
 pub mod simpletls;

zephyr/src/net/ipaddr.rs

@@ -0,0 +1,156 @@
+//!
+//! docs todo...
+//!
+
+use crate::error::{Error, Result};
+use crate::raw::{in6_addr, in_addr, sockaddr, sockaddr_in, sockaddr_in6, socklen_t};
+use core::mem::MaybeUninit;
+use core::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
+
+/// docs todo...
+pub(crate) fn ipv4_addr_to_c(addr: &Ipv4Addr) -> in_addr {
+    let octets = addr.octets();
+
+    // It's not possible to easily construct this type due to the BindgenUnion field, and in any
+    // case constructing it would always require unsafe code. Since the layout of the C type is
+    // well defined and can be interpreted as a 4-byte array, we can just transmute the octets.
+    unsafe { core::mem::transmute(octets) }
+}
+
+/// docs todo...
+pub(crate) fn ipv4_addr_from_c(addr: &in_addr) -> Ipv4Addr {
+    let s4_addr = unsafe { addr.__bindgen_anon_1.s4_addr.as_ref() };
+
+    Ipv4Addr::new(s4_addr[0], s4_addr[1], s4_addr[2], s4_addr[3])
+}
+
+/// docs todo...
+pub(crate) fn ipv6_addr_to_c(addr: &Ipv6Addr) -> in6_addr {
+    let octets = addr.octets();
+
+    // It's not possible to easily construct this type due to the BindgenUnion field, and in any
+    // case constructing it would always require unsafe code. Since the layout of the C type is
+    // well defined and can be interpreted as a 16-byte array, we can just transmute the octets.
+    unsafe { core::mem::transmute(octets) }
+}
+
+/// docs todo...
+pub(crate) fn ipv6_addr_from_c(addr: &in6_addr) -> Ipv6Addr {
+    let s6_addr16 = unsafe { addr.__bindgen_anon_1.s6_addr16.as_ref() };
+
+    Ipv6Addr::new(
+        s6_addr16[0],
+        s6_addr16[1],
+        s6_addr16[2],
+        s6_addr16[3],
+        s6_addr16[4],
+        s6_addr16[5],
+        s6_addr16[6],
+        s6_addr16[7],
+    )
+}
+
+/// docs todo...
+pub(crate) fn sockaddr_v4_to_c(sa: &SocketAddrV4) -> sockaddr_in {
+    sockaddr_in {
+        sin_family: crate::raw::AF_INET as u16,
+        sin_port: sa.port().to_be(),
+        sin_addr: ipv4_addr_to_c(sa.ip()),
+    }
+}
+
+/// docs todo...
+pub(crate) fn try_sockaddr_v4_from_c(sa: &sockaddr_in) -> Result<SocketAddrV4> {
+    if sa.sin_family != crate::raw::AF_INET as u16 {
+        return Err(Error(crate::raw::EINVAL));
+    }
+
+    Ok(SocketAddrV4::new(
+        ipv4_addr_from_c(&sa.sin_addr),
+        u16::from_be(sa.sin_port),
+    ))
+}
+
+/// docs todo...
+pub(crate) fn sockaddr_v6_to_c(sa: &SocketAddrV6) -> sockaddr_in6 {
+    sockaddr_in6 {
+        sin6_family: crate::raw::AF_INET6 as u16,
+        sin6_port: sa.port().to_be(),
+        sin6_addr: ipv6_addr_to_c(sa.ip()),
+        // TODO: It seems to be possible that Rust scope_id is > 255. Is panic the correct behaviour?
+        sin6_scope_id: sa.scope_id() as u8,
+    }
+}
+
+/// docs todo...
+pub(crate) fn try_sockaddr_v6_from_c(sa: &sockaddr_in6) -> Result<SocketAddrV6> {
+    if sa.sin6_family != crate::raw::AF_INET6 as u16 {
+        return Err(Error(crate::raw::EINVAL));
+    }
+
+    Ok(SocketAddrV6::new(
+        ipv6_addr_from_c(&sa.sin6_addr),
+        u16::from_be(sa.sin6_port),
+        0,
+        sa.sin6_scope_id as u32,
+    ))
+}
+
+/// docs todo...
+pub(crate) fn sockaddr_to_c(sa: &SocketAddr) -> (sockaddr, socklen_t) {
+    // TODO: this way of getting a `struct sockaddr` is pretty horrible, see if there is a better approach
+    let mut sa_out = MaybeUninit::<sockaddr>::zeroed();
+    let dst_ptr = sa_out.as_mut_ptr() as *mut u8;
+
+    let socklen = match sa {
+        SocketAddr::V4(sa4) => {
+            let src = sockaddr_v4_to_c(sa4);
+            let src_ptr = (&src as *const sockaddr_in) as *const u8;
+            let len = core::mem::size_of::<sockaddr>();
+
+            unsafe {
+                core::ptr::copy_nonoverlapping(src_ptr, dst_ptr, len);
+            }
+
+            len
+        }
+        SocketAddr::V6(sa6) => {
+            let src = sockaddr_v6_to_c(sa6);
+            let src_ptr = (&src as *const sockaddr_in6) as *const u8;
+            let len = core::mem::size_of::<sockaddr_in6>();
+
+            unsafe {
+                core::ptr::copy_nonoverlapping(src_ptr, dst_ptr, len);
+            }
+
+            len
+        }
+    };
+
+    (unsafe { sa_out.assume_init() }, socklen)
+}
+
+/// docs todo...
+pub(crate) fn try_sockaddr_from_c(sa: &sockaddr, socklen: socklen_t) -> Result<SocketAddr> {
+    match sa.sa_family as u32 {
+        crate::raw::AF_INET => {
+            if socklen != core::mem::size_of::<sockaddr_in>() {
+                return Err(Error(crate::raw::EINVAL));
+            }
+
+            let sa4_ref: &sockaddr_in = unsafe { core::mem::transmute(sa) };
+            let res = try_sockaddr_v4_from_c(sa4_ref)?;
+            Ok(SocketAddr::V4(res))
+        }
+        crate::raw::AF_INET6 => {
+            if socklen != core::mem::size_of::<sockaddr_in6>() {
+                return Err(Error(crate::raw::EINVAL));
+            }
+
+            let sa6_ref: &sockaddr_in6 = unsafe { core::mem::transmute(sa) };
+            let res = try_sockaddr_v6_from_c(sa6_ref)?;
+            Ok(SocketAddr::V6(res))
+        }
+        _ => Err(Error(crate::raw::EINVAL)),
+    }
+}

zephyr/src/net/mod.rs

@@ -0,0 +1,7 @@
+//!
+//! docs todo...
+//!
+
+mod ipaddr;
+mod socket;
+pub mod udp;

zephyr/src/net/socket.rs

@@ -0,0 +1,111 @@
+//!
+//! docs todo...
+//!
+
+use crate::error::{to_result_errno, Result};
+use crate::net::ipaddr::{sockaddr_to_c, try_sockaddr_from_c};
+use crate::raw::{
+    sockaddr, socklen_t, zsock_bind, zsock_close, zsock_recvfrom, zsock_sendto, zsock_socket,
+};
+use core::ffi::{c_int, c_void};
+use core::mem::MaybeUninit;
+use core::net::SocketAddr;
+
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum Domain {
+    AfInet = crate::raw::AF_INET as isize,
+    AfInet6 = crate::raw::AF_INET6 as isize,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum SockType {
+    Dgram = crate::raw::net_sock_type_SOCK_DGRAM as isize,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum Protocol {
+    IpprotoUdp = crate::raw::net_ip_protocol_IPPROTO_UDP as isize,
+}
+
+/// Socket type implementing minimal safe wrappers around Zephyr's C socket API
+pub(crate) struct Socket {
+    fd: c_int,
+}
+
+impl Socket {
+    /// Create a 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 fd = to_result_errno(res)?;
+
+        Ok(Socket { fd })
+    }
+
+    /// Bind a socket
+    ///
+    /// This is a minimal wrapper around zsock_bind
+    pub(crate) fn bind(&mut self, addr: &SocketAddr) -> Result<()> {
+        let (sockaddr, socklen) = sockaddr_to_c(addr);
+
+        let res = unsafe { zsock_bind(self.fd, &sockaddr as *const sockaddr, socklen) };
+
+        let _ = to_result_errno(res)?;
+        Ok(())
+    }
+
+    /// Receive from the socket, returning the data length and peer address it was received from
+    ///
+    /// This is a minimal wrapper around zsock_recvfrom
+    pub(crate) fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)> {
+        let mut sa = MaybeUninit::<sockaddr>::uninit();
+        let mut socklen: socklen_t = core::mem::size_of::<sockaddr>();
+
+        let res = unsafe {
+            zsock_recvfrom(
+                self.fd,
+                buf.as_mut_ptr() as *mut c_void,
+                buf.len(),
+                0,
+                sa.as_mut_ptr(),
+                &mut socklen as *mut socklen_t,
+            )
+        };
+
+        let recvd = to_result_errno(res)?;
+        let sa = unsafe { sa.assume_init() };
+        let peer_sa = try_sockaddr_from_c(&sa, socklen)?;
+        Ok((recvd as usize, peer_sa))
+    }
+
+    /// 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) = sockaddr_to_c(addr);
+
+        let res = unsafe {
+            zsock_sendto(
+                self.fd,
+                buf.as_ptr() as *const c_void,
+                buf.len(),
+                0,
+                &sa as *const sockaddr,
+                socklen,
+            )
+        };
+
+        let sent = to_result_errno(res)?;
+        Ok(sent as usize)
+    }
+}
+
+impl Drop for Socket {
+    fn drop(&mut self) {
+        unsafe {
+            let _ = zsock_close(self.fd);
+        }
+    }
+}