iface: make socket_egress infallible.

src/iface/interface.rs

@@ -773,7 +773,7 @@ where
         let mut readiness_may_have_changed = false;
         loop {
             let processed_any = self.socket_ingress();
-            let emitted_any = self.socket_egress()?;
+            let emitted_any = self.socket_egress();
 
             #[cfg(feature = "proto-igmp")]
             self.igmp_egress()?;
@@ -880,7 +880,7 @@ where
         processed_any
     }
 
-    fn socket_egress(&mut self) -> Result<bool> {
+    fn socket_egress(&mut self) -> bool {
         let Self {
             device,
             inner,
@@ -899,58 +899,53 @@ where
             }
 
             let mut neighbor_addr = None;
-            let mut device_result = Ok(());
-
-            macro_rules! respond {
-                ($inner:expr, $response:expr) => {{
-                    let response = $response;
-                    neighbor_addr = Some(response.ip_repr().dst_addr());
-                    let tx_token = device.transmit().ok_or(Error::Exhausted)?;
-                    device_result = $inner.dispatch_ip(tx_token, response);
-                    device_result
-                }};
-            }
+            let mut respond = |inner: &mut InterfaceInner, response: IpPacket| {
+                neighbor_addr = Some(response.ip_repr().dst_addr());
+                let tx_token = device.transmit().ok_or(Error::Exhausted)?;
+                inner.dispatch_ip(tx_token, response)?;
+                emitted_any = true;
+                Ok(())
+            };
 
-            let socket_result = match &mut item.socket {
+            let result = match &mut item.socket {
                 #[cfg(feature = "socket-raw")]
                 Socket::Raw(socket) => socket.dispatch(inner, |inner, response| {
-                    respond!(inner, IpPacket::Raw(response))
+                    respond(inner, IpPacket::Raw(response))
                 }),
                 #[cfg(feature = "socket-icmp")]
                 Socket::Icmp(socket) => socket.dispatch(inner, |inner, response| match response {
                     #[cfg(feature = "proto-ipv4")]
                     (IpRepr::Ipv4(ipv4_repr), IcmpRepr::Ipv4(icmpv4_repr)) => {
-                        respond!(inner, IpPacket::Icmpv4((ipv4_repr, icmpv4_repr)))
+                        respond(inner, IpPacket::Icmpv4((ipv4_repr, icmpv4_repr)))
                     }
                     #[cfg(feature = "proto-ipv6")]
                     (IpRepr::Ipv6(ipv6_repr), IcmpRepr::Ipv6(icmpv6_repr)) => {
-                        respond!(inner, IpPacket::Icmpv6((ipv6_repr, icmpv6_repr)))
+                        respond(inner, IpPacket::Icmpv6((ipv6_repr, icmpv6_repr)))
                     }
                     #[allow(unreachable_patterns)]
                     _ => unreachable!(),
                 }),
                 #[cfg(feature = "socket-udp")]
                 Socket::Udp(socket) => socket.dispatch(inner, |inner, response| {
-                    respond!(inner, IpPacket::Udp(response))
+                    respond(inner, IpPacket::Udp(response))
                 }),
                 #[cfg(feature = "socket-tcp")]
                 Socket::Tcp(socket) => socket.dispatch(inner, |inner, response| {
-                    respond!(inner, IpPacket::Tcp(response))
+                    respond(inner, IpPacket::Tcp(response))
                 }),
                 #[cfg(feature = "socket-dhcpv4")]
                 Socket::Dhcpv4(socket) => socket.dispatch(inner, |inner, response| {
-                    respond!(inner, IpPacket::Dhcpv4(response))
+                    respond(inner, IpPacket::Dhcpv4(response))
                 }),
                 #[cfg(feature = "socket-dns")]
                 Socket::Dns(ref mut socket) => socket.dispatch(inner, |inner, response| {
-                    respond!(inner, IpPacket::Udp(response))
+                    respond(inner, IpPacket::Udp(response))
                 }),
             };
 
-            match (device_result, socket_result) {
-                (Err(Error::Exhausted), _) => break,   // nowhere to transmit
-                (Ok(()), Err(Error::Exhausted)) => (), // nothing to transmit
-                (Err(Error::Unaddressable), _) => {
+            match result {
+                Err(Error::Exhausted) => break, // Device buffer full.
+                Err(Error::Unaddressable) => {
                     // `NeighborCache` already takes care of rate limiting the neighbor discovery
                     // requests from the socket. However, without an additional rate limiting
                     // mechanism, we would spin on every socket that has yet to discover its
@@ -961,18 +956,17 @@ where
                     );
                     break;
                 }
-                (Err(err), _) | (_, Err(err)) => {
+                Err(err) => {
                     net_debug!(
                         "{}: cannot dispatch egress packet: {}",
                         item.meta.handle,
                         err
                     );
-                    return Err(err);
                 }
-                (Ok(()), Ok(())) => emitted_any = true,
+                Ok(()) => {}
             }
         }
-        Ok(emitted_any)
+        emitted_any
     }
 
     /// Depending on `igmp_report_state` and the therein contained