Simplify send_with functions

src/socket/icmp.rs

@@ -320,7 +320,7 @@ impl<'a> Socket<'a> {
         max_size: usize,
         endpoint: IpAddress,
         f: F,
-    ) -> Result<&mut [u8], SendError>
+    ) -> Result<usize, SendError>
     where
         F: FnOnce(&mut [u8]) -> usize,
     {
@@ -328,16 +328,13 @@ impl<'a> Socket<'a> {
             return Err(SendError::Unaddressable);
         }
 
-        let (size, packet_buf) = self
+        let size = self
             .tx_buffer
-            .enqueue_with_infallible(max_size, endpoint, |data| {
-                let size = f(data);
-                (size, &mut data[..size])
-            })
+            .enqueue_with_infallible(max_size, endpoint, f)
             .map_err(|_| SendError::BufferFull)?;
 
         net_trace!("icmp:{}: buffer to send {} octets", endpoint, size);
-        Ok(packet_buf)
+        Ok(size)
     }
 
     /// Enqueue a packet to be sent to a given remote address, and fill it from a slice.

src/socket/raw.rs

@@ -192,16 +192,13 @@ impl<'a> Socket<'a> {
     /// 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], SendError>
+    pub fn send_with<F>(&mut self, max_size: usize, f: F) -> Result<usize, SendError>
     where
         F: FnOnce(&mut [u8]) -> usize,
     {
-        let (size, packet_buf) = self
+        let size = self
             .tx_buffer
-            .enqueue_with_infallible(max_size, (), |data| {
-                let size = f(data);
-                (size, &mut data[..size])
-            })
+            .enqueue_with_infallible(max_size, (), f)
             .map_err(|_| SendError::BufferFull)?;
 
         net_trace!(
@@ -211,7 +208,7 @@ impl<'a> Socket<'a> {
             size
         );
 
-        Ok(packet_buf)
+        Ok(size)
     }
 
     /// Enqueue a packet to send, and fill it from a slice.

src/socket/udp.rs

@@ -268,7 +268,7 @@ impl<'a> Socket<'a> {
         max_size: usize,
         remote_endpoint: IpEndpoint,
         f: F,
-    ) -> Result<&mut [u8], SendError>
+    ) -> Result<usize, SendError>
     where
         F: FnOnce(&mut [u8]) -> usize,
     {
@@ -282,12 +282,9 @@ impl<'a> Socket<'a> {
             return Err(SendError::Unaddressable);
         }
 
-        let (size, payload_buf) = self
+        let size = self
             .tx_buffer
-            .enqueue_with_infallible(max_size, remote_endpoint, |data| {
-                let size = f(data);
-                (size, &mut data[..size])
-            })
+            .enqueue_with_infallible(max_size, remote_endpoint, f)
             .map_err(|_| SendError::BufferFull)?;
 
         net_trace!(
@@ -296,7 +293,7 @@ impl<'a> Socket<'a> {
             remote_endpoint,
             size
         );
-        Ok(payload_buf)
+        Ok(size)
     }
 
     /// Enqueue a packet to be sent to a given remote endpoint, and fill it from a slice.

src/storage/packet_buffer.rs

@@ -113,14 +113,14 @@ impl<'a, H> PacketBuffer<'a, H> {
 
     /// 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>(
+    pub fn enqueue_with_infallible<'b, F>(
         &'b mut self,
         max_size: usize,
         header: H,
         f: F,
-    ) -> Result<(usize, R), Full>
+    ) -> Result<usize, Full>
     where
-        F: FnOnce(&'b mut [u8]) -> (usize, R),
+        F: FnOnce(&'b mut [u8]) -> usize,
     {
         if self.payload_ring.capacity() < max_size || self.metadata_ring.is_full() {
             return Err(Full);
@@ -148,13 +148,13 @@ impl<'a, H> PacketBuffer<'a, H> {
             }
         }
 
-        let (size, r) = self
+        let (size, _) = self
             .payload_ring
-            .enqueue_many_with(|data| f(&mut data[..max_size]));
+            .enqueue_many_with(|data| (f(&mut data[..max_size]), ()));
 
         *self.metadata_ring.enqueue_one()? = PacketMetadata::packet(size, header);
 
-        Ok((size, r))
+        Ok(size)
     }
 
     fn dequeue_padding(&mut self) {