socket: implement the receive path for ethernet sockets

Author: ususdei

src/iface/interface/ethernet.rs

@@ -18,6 +18,13 @@ impl InterfaceInner {
             return None;
         }
 
+        #[cfg(feature = "socket-eth")]
+        let _ = self.eth_socket_filter(
+            sockets,
+            &EthernetRepr::parse(&eth_frame).unwrap(),
+            eth_frame.payload(),
+        );
+
         match eth_frame.ethertype() {
             #[cfg(feature = "proto-ipv4")]
             EthernetProtocol::Arp => self.process_arp(self.now, &eth_frame),

src/iface/interface/mod.rs

@@ -901,6 +901,28 @@ impl InterfaceInner {
         handled_by_raw_socket
     }
 
+    #[cfg(feature = "socket-eth")]
+    fn eth_socket_filter(
+        &mut self,
+        sockets: &mut SocketSet,
+        eth_repr: &EthernetRepr,
+        eth_payload: &[u8],
+    ) -> bool {
+        let mut handled_by_eth_socket = false;
+
+        // Pass every IP packet to all raw sockets we have registered.
+        for eth_socket in sockets
+            .items_mut()
+            .filter_map(|i| eth::Socket::downcast_mut(&mut i.socket))
+        {
+            if eth_socket.accepts(eth_repr) {
+                eth_socket.process(self, eth_repr, eth_payload);
+                handled_by_eth_socket = true;
+            }
+        }
+        handled_by_eth_socket
+    }
+
     /// Checks if an address is broadcast, taking into account ipv4 subnet-local
     /// broadcast addresses.
     pub(crate) fn is_broadcast(&self, address: &IpAddress) -> bool {

src/socket/eth.rs

@@ -9,6 +9,9 @@ use crate::socket::WakerRegistration;
 
 use crate::storage::Empty;
 
+use crate::wire::EthernetFrame;
+use crate::wire::EthernetRepr;
+
 /// Error returned by [`Socket::send`]
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -294,6 +297,42 @@ impl<'a> Socket<'a> {
         self.rx_buffer.payload_bytes_count()
     }
 
+    pub(crate) fn accepts(&self, eth_repr: &EthernetRepr) -> bool {
+        match self.ethertype {
+            Some(e) if e == eth_repr.ethertype.into() => true,
+            Some(_) => false,
+            None => true,
+        }
+    }
+
+    pub(crate) fn process(&mut self, _cx: &mut Context, eth_repr: &EthernetRepr, payload: &[u8]) {
+        debug_assert!(self.accepts(eth_repr));
+
+        let header_len = eth_repr.buffer_len();
+        let total_len = header_len + payload.len();
+
+        net_trace!(
+            "eth:{}: receiving {} octets",
+            self.ethertype.unwrap_or(0),
+            total_len
+        );
+
+        match self.rx_buffer.enqueue(total_len, ()) {
+            Ok(buf) => {
+                let mut frame = EthernetFrame::new_checked(buf).expect("internal ethernet error");
+                eth_repr.emit(&mut frame);
+                frame.payload_mut().copy_from_slice(payload);
+            }
+            Err(_) => net_trace!(
+                "eth:{}: buffer full, dropped incoming packet",
+                self.ethertype.unwrap_or(0)
+            ),
+        }
+
+        #[cfg(feature = "async")]
+        self.rx_waker.wake();
+    }
+
     pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
         if self.tx_buffer.is_empty() {
             PollAt::Ingress