Fix after rebasing

src/socket/icmp.rs

@@ -315,20 +315,26 @@ impl<'a> Socket<'a> {
     /// 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]>
+    pub fn send_with<F>(
+        &mut self,
+        max_size: usize,
+        endpoint: IpAddress,
+        f: F,
+    ) -> Result<&mut [u8], SendError>
     where
         F: FnOnce(&mut [u8]) -> usize,
     {
         if endpoint.is_unspecified() {
-            return Err(Error::Unaddressable);
+            return Err(SendError::Unaddressable);
         }
 
-        let (size, packet_buf) =
-            self.tx_buffer
-                .enqueue_with_infallible(max_size, endpoint, |data| {
-                    let size = f(data);
-                    (size, &mut data[..size])
-                })?;
+        let (size, packet_buf) = self
+            .tx_buffer
+            .enqueue_with_infallible(max_size, endpoint, |data| {
+                let size = f(data);
+                (size, &mut data[..size])
+            })
+            .map_err(|_| SendError::BufferFull)?;
 
         net_trace!("icmp:{}: buffer to send {} octets", endpoint, size);
         Ok(packet_buf)

src/socket/raw.rs

@@ -192,7 +192,7 @@ 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]>
+    pub fn send_with<F>(&mut self, max_size: usize, f: F) -> Result<&mut [u8], SendError>
     where
         F: FnOnce(&mut [u8]) -> usize,
     {
@@ -201,7 +201,8 @@ impl<'a> Socket<'a> {
             .enqueue_with_infallible(max_size, (), |data| {
                 let size = f(data);
                 (size, &mut data[..size])
-            })?;
+            })
+            .map_err(|_| SendError::BufferFull)?;
 
         net_trace!(
             "raw:{}:{}: buffer to send {} octets",

src/socket/udp.rs

@@ -268,26 +268,27 @@ impl<'a> Socket<'a> {
         max_size: usize,
         remote_endpoint: IpEndpoint,
         f: F,
-    ) -> Result<&mut [u8]>
+    ) -> Result<&mut [u8], SendError>
     where
         F: FnOnce(&mut [u8]) -> usize,
     {
         if self.endpoint.port == 0 {
-            return Err(Error::Unaddressable);
+            return Err(SendError::Unaddressable);
         }
         if remote_endpoint.addr.is_unspecified() {
-            return Err(Error::Unaddressable);
+            return Err(SendError::Unaddressable);
         }
         if remote_endpoint.port == 0 {
-            return Err(Error::Unaddressable);
+            return Err(SendError::Unaddressable);
         }
 
-        let (size, payload_buf) =
-            self.tx_buffer
-                .enqueue_with_infallible(max_size, remote_endpoint, |data| {
-                    let size = f(data);
-                    (size, &mut data[..size])
-                })?;
+        let (size, payload_buf) = self
+            .tx_buffer
+            .enqueue_with_infallible(max_size, remote_endpoint, |data| {
+                let size = f(data);
+                (size, &mut data[..size])
+            })
+            .map_err(|_| SendError::BufferFull)?;
 
         net_trace!(
             "udp:{}:{}: buffer to send {} octets",

src/storage/packet_buffer.rs

@@ -118,30 +118,26 @@ impl<'a, H> PacketBuffer<'a, H> {
         max_size: usize,
         header: H,
         f: F,
-    ) -> Result<(usize, R)>
+    ) -> Result<(usize, R), Full>
     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);
+        if self.payload_ring.capacity() < max_size || self.metadata_ring.is_full() {
+            return Err(Full);
         }
 
         let window = self.payload_ring.window();
         let contig_window = self.payload_ring.contiguous_window();
 
         if window < max_size {
-            return Err(Error::Exhausted);
+            return Err(Full);
         } 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);
+                return Err(Full);
             } else {
                 // Add padding to the end of the ring buffer so that the
                 // contiguous window is at the beginning of the ring buffer.