Merge remote-tracking branch 'origin'

3 files changed, 47 insertions, 11 deletions

diff --git a/embassy-net/Cargo.toml b/embassy-net/Cargo.toml
index 0c07e3651..612a3d689 100644
--- a/embassy-net/Cargo.toml
+++ b/embassy-net/Cargo.toml
@@ -25,18 +25,34 @@ features = ["defmt", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6", "medium-ethern
 default = []
 std = []
 
+## Enable defmt
 defmt = ["dep:defmt", "smoltcp/defmt", "embassy-net-driver/defmt", "heapless/defmt-03"]
 
+#! Many of the following feature flags are re-exports of smoltcp feature flags. See 
+#! the [smoltcp feature flag documentation](https://github.com/smoltcp-rs/smoltcp#feature-flags)
+#! for more details
+
+## Enable UDP support
 udp = ["smoltcp/socket-udp"]
+## Enable TCP support
 tcp = ["smoltcp/socket-tcp"]
+## Enable DNS support
 dns = ["smoltcp/socket-dns", "smoltcp/proto-dns"]
+## Enable DHCPv4 support
 dhcpv4 = ["proto-ipv4", "medium-ethernet", "smoltcp/socket-dhcpv4"]
+## Enable DHCPv4 support with hostname
 dhcpv4-hostname = ["dhcpv4"]
+## Enable IPv4 support
 proto-ipv4 = ["smoltcp/proto-ipv4"]
+## Enable IPv6 support
 proto-ipv6 = ["smoltcp/proto-ipv6"]
+## Enable the Ethernet medium
 medium-ethernet = ["smoltcp/medium-ethernet"]
+## Enable the IP medium
 medium-ip = ["smoltcp/medium-ip"]
+## Enable the IEEE 802.15.4 medium
 medium-ieee802154 = ["smoltcp/medium-ieee802154"]
+## Enable IGMP support
 igmp = ["smoltcp/proto-igmp"]
 
 [dependencies]
@@ -44,7 +60,7 @@ igmp = ["smoltcp/proto-igmp"]
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
 
-smoltcp = { git = "https://github.com/smoltcp-rs/smoltcp.git", rev = "b57e2f9e70e82a13f31d5ea17e55232c11cc2b2d", default-features = false, features = [
+smoltcp = { version = "0.11.0", default-features = false, features = [
   "socket",
   "async",
 ] }
@@ -62,3 +78,4 @@ stable_deref_trait = { version = "1.2.0", default-features = false }
 futures = { version = "0.3.17", default-features = false, features = [ "async-await" ] }
 atomic-pool = "1.0"
 embedded-nal-async = { version = "0.7.1" }
+document-features = "0.2.7"
diff --git a/embassy-net/src/lib.rs b/embassy-net/src/lib.rs
index bf1468642..2cef2232c 100644
--- a/embassy-net/src/lib.rs
+++ b/embassy-net/src/lib.rs
@@ -5,6 +5,9 @@
 #![warn(missing_docs)]
 #![doc = include_str!("../README.md")]
 
+//! ## Feature flags
+#![doc = document_features::document_features!(feature_label = r#"<span class="stab portability"><code>{feature}</code></span>"#)]
+
 #[cfg(not(any(feature = "proto-ipv4", feature = "proto-ipv6")))]
 compile_error!("You must enable at least one of the following features: proto-ipv4, proto-ipv6");
 
@@ -411,10 +414,12 @@ impl<D: Driver> Stack<D> {
     /// ```ignore
     /// let config = embassy_net::Config::dhcpv4(Default::default());
     ///// Init network stack
-    /// let stack = &*make_static!(embassy_net::Stack::new(
+    /// static RESOURCES: StaticCell<embassy_net::StackResources<2> = StaticCell::new();
+    /// static STACK: StaticCell<embassy_net::Stack> = StaticCell::new();
+    /// let stack = &*STACK.init(embassy_net::Stack::new(
     ///    device,
     ///    config,
-    ///    make_static!(embassy_net::StackResources::<2>::new()),
+    ///    RESOURCES.init(embassy_net::StackResources::new()),
     ///    seed
     /// ));
     /// // Launch network task that runs `stack.run().await`
diff --git a/embassy-net/src/udp.rs b/embassy-net/src/udp.rs
index 61058c1ba..a22cd8827 100644
--- a/embassy-net/src/udp.rs
+++ b/embassy-net/src/udp.rs
@@ -26,13 +26,21 @@ pub enum BindError {
 /// Error returned by [`UdpSocket::recv_from`] and [`UdpSocket::send_to`].
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub enum Error {
+pub enum SendError {
     /// No route to host.
     NoRoute,
     /// Socket not bound to an outgoing port.
     SocketNotBound,
 }
 
+/// Error returned by [`UdpSocket::recv_from`] and [`UdpSocket::send_to`].
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RecvError {
+    /// Provided buffer was smaller than the received packet.
+    Truncated,
+}
+
 /// An UDP socket.
 pub struct UdpSocket<'a> {
     stack: &'a RefCell<SocketStack>,
@@ -103,7 +111,7 @@ impl<'a> UdpSocket<'a> {
     /// This method will wait until a datagram is received.
     ///
     /// Returns the number of bytes received and the remote endpoint.
-    pub async fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, IpEndpoint), Error> {
+    pub async fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, IpEndpoint), RecvError> {
         poll_fn(move |cx| self.poll_recv_from(buf, cx)).await
     }
 
@@ -114,10 +122,11 @@ impl<'a> UdpSocket<'a> {
     ///
     /// When a datagram is received, this method will return `Poll::Ready` with the
     /// number of bytes received and the remote endpoint.
-    pub fn poll_recv_from(&self, buf: &mut [u8], cx: &mut Context<'_>) -> Poll<Result<(usize, IpEndpoint), Error>> {
+    pub fn poll_recv_from(&self, buf: &mut [u8], cx: &mut Context<'_>) -> Poll<Result<(usize, IpEndpoint), RecvError>> {
         self.with_mut(|s, _| match s.recv_slice(buf) {
             Ok((n, meta)) => Poll::Ready(Ok((n, meta.endpoint))),
             // No data ready
+            Err(udp::RecvError::Truncated) => Poll::Ready(Err(RecvError::Truncated)),
             Err(udp::RecvError::Exhausted) => {
                 s.register_recv_waker(cx.waker());
                 Poll::Pending
@@ -129,8 +138,8 @@ impl<'a> UdpSocket<'a> {
     ///
     /// This method will wait until the datagram has been sent.
     ///
-    /// When the remote endpoint is not reachable, this method will return `Err(Error::NoRoute)`
-    pub async fn send_to<T>(&self, buf: &[u8], remote_endpoint: T) -> Result<(), Error>
+    /// When the remote endpoint is not reachable, this method will return `Err(SendError::NoRoute)`
+    pub async fn send_to<T>(&self, buf: &[u8], remote_endpoint: T) -> Result<(), SendError>
     where
         T: Into<IpEndpoint>,
     {
@@ -146,7 +155,7 @@ impl<'a> UdpSocket<'a> {
     /// and register the current task to be notified when the buffer has space available.
     ///
     /// When the remote endpoint is not reachable, this method will return `Poll::Ready(Err(Error::NoRoute))`.
-    pub fn poll_send_to<T>(&self, buf: &[u8], remote_endpoint: T, cx: &mut Context<'_>) -> Poll<Result<(), Error>>
+    pub fn poll_send_to<T>(&self, buf: &[u8], remote_endpoint: T, cx: &mut Context<'_>) -> Poll<Result<(), SendError>>
     where
         T: Into<IpEndpoint>,
     {
@@ -160,9 +169,9 @@ impl<'a> UdpSocket<'a> {
             Err(udp::SendError::Unaddressable) => {
                 // If no sender/outgoing port is specified, there is not really "no route"
                 if s.endpoint().port == 0 {
-                    Poll::Ready(Err(Error::SocketNotBound))
+                    Poll::Ready(Err(SendError::SocketNotBound))
                 } else {
-                    Poll::Ready(Err(Error::NoRoute))
+                    Poll::Ready(Err(SendError::NoRoute))
                 }
             }
         })
@@ -213,6 +222,11 @@ impl<'a> UdpSocket<'a> {
     pub fn payload_send_capacity(&self) -> usize {
         self.with(|s, _| s.payload_send_capacity())
     }
+
+    /// Set the hop limit field in the IP header of sent packets.
+    pub fn set_hop_limit(&mut self, hop_limit: Option<u8>) {
+        self.with_mut(|s, _| s.set_hop_limit(hop_limit))
+    }
 }
 
 impl Drop for UdpSocket<'_> {