Add send_with to udp, raw, and icmp sockets

src/iface/socket_meta.rs

@@ -1,19 +1,21 @@
 use super::SocketHandle;
-use crate::socket::PollAt;
-use crate::time::{Duration, Instant};
-use crate::wire::IpAddress;
+use crate::{
+    socket::PollAt,
+    time::{Duration, Instant},
+    wire::IpAddress,
+};
 
 /// Neighbor dependency.
 ///
-/// This enum tracks whether the socket should be polled based on the neighbor it is
-/// going to send packets to.
+/// This enum tracks whether the socket should be polled based on the neighbor
+/// it is going to send packets to.
 #[derive(Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 enum NeighborState {
     /// Socket can be polled immediately.
     Active,
-    /// Socket should not be polled until either `silent_until` passes or `neighbor` appears
-    /// in the neighbor cache.
+    /// Socket should not be polled until either `silent_until` passes or
+    /// `neighbor` appears in the neighbor cache.
     Waiting {
         neighbor: IpAddress,
         silent_until: Instant,
@@ -29,7 +31,8 @@ impl Default for NeighborState {
 /// Network socket metadata.
 ///
 /// This includes things that only external (to the socket, that is) code
-/// is interested in, but which are more conveniently stored inside the socket itself.
+/// is interested in, but which are more conveniently stored inside the socket
+/// itself.
 #[derive(Debug, Default)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub(crate) struct Meta {
@@ -41,8 +44,8 @@ pub(crate) struct Meta {
 }
 
 impl Meta {
-    /// Minimum delay between neighbor discovery requests for this particular socket,
-    /// in milliseconds.
+    /// Minimum delay between neighbor discovery requests for this particular
+    /// socket, in milliseconds.
     ///
     /// See also `iface::NeighborCache::SILENT_TIME`.
     pub(crate) const DISCOVERY_SILENT_TIME: Duration = Duration::from_millis(1_000);

src/socket/icmp.rs

@@ -310,6 +310,30 @@ impl<'a> Socket<'a> {
         Ok(packet_buf)
     }
 
+    /// Enqueue a packet to be send to a given remote address and pass the buffer
+    /// to the provided closure. The closure then returns the size of the data written
+    /// into the buffer.
+    ///
+    /// Also see [send](#method.send).
+    pub fn send_with<F>(&mut self, max_size: usize, endpoint: IpAddress, f: F) -> Result<&mut [u8]>
+    where
+        F: FnOnce(&mut [u8]) -> usize,
+    {
+        if endpoint.is_unspecified() {
+            return Err(Error::Unaddressable);
+        }
+
+        let (size, packet_buf) =
+            self.tx_buffer
+                .enqueue_with_infallible(max_size, endpoint, |data| {
+                    let size = f(data);
+                    (size, &mut data[..size])
+                })?;
+
+        net_trace!("icmp:{}: buffer to send {} octets", endpoint, size);
+        Ok(packet_buf)
+    }
+
     /// Enqueue a packet to be sent to a given remote address, and fill it from a slice.
     ///
     /// See also [send](#method.send).

src/socket/raw.rs

@@ -188,6 +188,31 @@ impl<'a> Socket<'a> {
         Ok(packet_buf)
     }
 
+    /// Enqueue a packet to be send and pass the buffer to the provided closure.
+    /// The closure then returns the size of the data written into the buffer.
+    ///
+    /// Also see [send](#method.send).
+    pub fn send_with<F>(&mut self, max_size: usize, f: F) -> Result<&mut [u8]>
+    where
+        F: FnOnce(&mut [u8]) -> usize,
+    {
+        let (size, packet_buf) = self
+            .tx_buffer
+            .enqueue_with_infallible(max_size, (), |data| {
+                let size = f(data);
+                (size, &mut data[..size])
+            })?;
+
+        net_trace!(
+            "raw:{}:{}: buffer to send {} octets",
+            self.ip_version,
+            self.ip_protocol,
+            size
+        );
+
+        Ok(packet_buf)
+    }
+
     /// Enqueue a packet to send, and fill it from a slice.
     ///
     /// See also [send](#method.send).

src/socket/udp.rs

@@ -258,6 +258,46 @@ impl<'a> Socket<'a> {
         Ok(payload_buf)
     }
 
+    /// Enqueue a packet to be send to a given remote endpoint and pass the buffer
+    /// to the provided closure. The closure then returns the size of the data written
+    /// into the buffer.
+    ///
+    /// Also see [send](#method.send).
+    pub fn send_with<F>(
+        &mut self,
+        max_size: usize,
+        remote_endpoint: IpEndpoint,
+        f: F,
+    ) -> Result<&mut [u8]>
+    where
+        F: FnOnce(&mut [u8]) -> usize,
+    {
+        if self.endpoint.port == 0 {
+            return Err(Error::Unaddressable);
+        }
+        if remote_endpoint.addr.is_unspecified() {
+            return Err(Error::Unaddressable);
+        }
+        if remote_endpoint.port == 0 {
+            return Err(Error::Unaddressable);
+        }
+
+        let (size, payload_buf) =
+            self.tx_buffer
+                .enqueue_with_infallible(max_size, remote_endpoint, |data| {
+                    let size = f(data);
+                    (size, &mut data[..size])
+                })?;
+
+        net_trace!(
+            "udp:{}:{}: buffer to send {} octets",
+            self.endpoint,
+            remote_endpoint,
+            size
+        );
+        Ok(payload_buf)
+    }
+
     /// Enqueue a packet to be sent to a given remote endpoint, and fill it from a slice.
     ///
     /// See also [send](#method.send).

src/storage/packet_buffer.rs

@@ -111,6 +111,56 @@ impl<'a, H> PacketBuffer<'a, H> {
         Ok(payload_buf)
     }
 
+    /// Call `f` with a packet from the buffer large enough to fit `max_size` bytes. The packet
+    /// is shrunk to the size returned from `f` and enqueued into the buffer.
+    pub fn enqueue_with_infallible<'b, R, F>(
+        &'b mut self,
+        max_size: usize,
+        header: H,
+        f: F,
+    ) -> Result<(usize, R)>
+    where
+        F: FnOnce(&'b mut [u8]) -> (usize, R),
+    {
+        if self.payload_ring.capacity() < max_size {
+            return Err(Error::Truncated);
+        }
+
+        if self.metadata_ring.is_full() {
+            return Err(Error::Exhausted);
+        }
+
+        let window = self.payload_ring.window();
+        let contig_window = self.payload_ring.contiguous_window();
+
+        if window < max_size {
+            return Err(Error::Exhausted);
+        } else if contig_window < max_size {
+            if window - contig_window < max_size {
+                // The buffer length is larger than the current contiguous window
+                // and is larger than the contiguous window will be after adding
+                // the padding necessary to circle around to the beginning of the
+                // ring buffer.
+                return Err(Error::Exhausted);
+            } else {
+                // Add padding to the end of the ring buffer so that the
+                // contiguous window is at the beginning of the ring buffer.
+                *self.metadata_ring.enqueue_one()? = PacketMetadata::padding(contig_window);
+                // note(discard): function does not write to the result
+                // enqueued padding buffer location
+                let _buf_enqueued = self.payload_ring.enqueue_many(contig_window);
+            }
+        }
+
+        let (size, r) = self
+            .payload_ring
+            .enqueue_many_with(|data| f(&mut data[..max_size]));
+
+        *self.metadata_ring.enqueue_one()? = PacketMetadata::packet(size, header);
+
+        Ok((size, r))
+    }
+
     fn dequeue_padding(&mut self) {
         let Self {
             ref mut metadata_ring,