socket: move meta from XxxSocket to Socket.

Author: Dirbaio

src/iface/interface.rs

@@ -473,10 +473,7 @@ where
     ///
     /// # Panics
     /// This function panics if the storage is fixed-size (not a `Vec`) and is full.
-    pub fn add_socket<T>(&mut self, socket: T) -> SocketHandle
-    where
-        T: Into<Socket<'a>>,
-    {
+    pub fn add_socket<T: AnySocket<'a>>(&mut self, socket: T) -> SocketHandle {
         self.sockets.add(socket)
     }
 
@@ -861,16 +858,16 @@ where
                 }};
             }
 
-            let socket_result = match *socket {
+            let socket_result = match &mut socket.socket {
                 #[cfg(feature = "socket-raw")]
-                Socket::Raw(ref mut socket) => {
+                SocketEnum::Raw(socket) => {
                     socket.dispatch(cx, |response| respond!(IpPacket::Raw(response)))
                 }
                 #[cfg(all(
                     feature = "socket-icmp",
                     any(feature = "proto-ipv4", feature = "proto-ipv6")
                 ))]
-                Socket::Icmp(ref mut socket) => socket.dispatch(cx, |response| match response {
+                SocketEnum::Icmp(socket) => socket.dispatch(cx, |response| match response {
                     #[cfg(feature = "proto-ipv4")]
                     (IpRepr::Ipv4(ipv4_repr), IcmpRepr::Ipv4(icmpv4_repr)) => {
                         respond!(IpPacket::Icmpv4((ipv4_repr, icmpv4_repr)))
@@ -882,15 +879,15 @@ where
                     _ => Err(Error::Unaddressable),
                 }),
                 #[cfg(feature = "socket-udp")]
-                Socket::Udp(ref mut socket) => {
+                SocketEnum::Udp(socket) => {
                     socket.dispatch(cx, |response| respond!(IpPacket::Udp(response)))
                 }
                 #[cfg(feature = "socket-tcp")]
-                Socket::Tcp(ref mut socket) => {
+                SocketEnum::Tcp(socket) => {
                     socket.dispatch(cx, |response| respond!(IpPacket::Tcp(response)))
                 }
                 #[cfg(feature = "socket-dhcpv4")]
-                Socket::Dhcpv4(ref mut socket) => {
+                SocketEnum::Dhcpv4(socket) => {
                     socket.dispatch(cx, |response| respond!(IpPacket::Dhcpv4(response)))
                 }
             };

src/socket/dhcpv4.rs

@@ -1,5 +1,4 @@
-use crate::socket::SocketHandle;
-use crate::socket::{Context, SocketMeta};
+use crate::socket::Context;
 use crate::time::{Duration, Instant};
 use crate::wire::dhcpv4::field as dhcpv4_field;
 use crate::wire::HardwareAddress;
@@ -9,7 +8,7 @@ use crate::wire::{
 };
 use crate::{Error, Result};
 
-use super::{PollAt, Socket};
+use super::PollAt;
 
 const DISCOVER_TIMEOUT: Duration = Duration::from_secs(10);
 
@@ -112,7 +111,6 @@ pub enum Event {
 
 #[derive(Debug)]
 pub struct Dhcpv4Socket {
-    pub(crate) meta: SocketMeta,
     /// State of the DHCP client.
     state: ClientState,
     /// Set to true on config/state change, cleared back to false by the `config` function.
@@ -138,7 +136,6 @@ impl Dhcpv4Socket {
     #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         Dhcpv4Socket {
-            meta: SocketMeta::default(),
             state: ClientState::Discovering(DiscoverState {
                 retry_at: Instant::from_millis(0),
             }),
@@ -520,12 +517,6 @@ impl Dhcpv4Socket {
         }
     }
 
-    /// Return the socket handle.
-    #[inline]
-    pub fn handle(&self) -> SocketHandle {
-        self.meta.handle
-    }
-
     /// Reset state and restart discovery phase.
     ///
     /// Use this to speed up acquisition of an address in a new
@@ -557,12 +548,6 @@ impl Dhcpv4Socket {
     }
 }
 
-impl<'a> From<Dhcpv4Socket> for Socket<'a> {
-    fn from(val: Dhcpv4Socket) -> Self {
-        Socket::Dhcpv4(val)
-    }
-}
-
 #[cfg(test)]
 mod test {
 

src/socket/icmp.rs

@@ -5,7 +5,7 @@ use core::task::Waker;
 use crate::phy::ChecksumCapabilities;
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
-use crate::socket::{Context, PollAt, Socket, SocketHandle, SocketMeta};
+use crate::socket::{Context, PollAt};
 use crate::storage::{PacketBuffer, PacketMetadata};
 use crate::{Error, Result};
 
@@ -62,7 +62,6 @@ pub type IcmpSocketBuffer<'a> = PacketBuffer<'a, IpAddress>;
 /// [bind]: #method.bind
 #[derive(Debug)]
 pub struct IcmpSocket<'a> {
-    pub(crate) meta: SocketMeta,
     rx_buffer: IcmpSocketBuffer<'a>,
     tx_buffer: IcmpSocketBuffer<'a>,
     /// The endpoint this socket is communicating with
@@ -79,7 +78,6 @@ impl<'a> IcmpSocket<'a> {
     /// Create an ICMP socket with the given buffers.
     pub fn new(rx_buffer: IcmpSocketBuffer<'a>, tx_buffer: IcmpSocketBuffer<'a>) -> IcmpSocket<'a> {
         IcmpSocket {
-            meta: SocketMeta::default(),
             rx_buffer: rx_buffer,
             tx_buffer: tx_buffer,
             endpoint: Endpoint::default(),
@@ -126,12 +124,6 @@ impl<'a> IcmpSocket<'a> {
         self.tx_waker.register(waker)
     }
 
-    /// Return the socket handle.
-    #[inline]
-    pub fn handle(&self) -> SocketHandle {
-        self.meta.handle
-    }
-
     /// Return the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
     ///
     /// See also the [set_hop_limit](#method.set_hop_limit) method
@@ -290,12 +282,7 @@ impl<'a> IcmpSocket<'a> {
 
         let packet_buf = self.tx_buffer.enqueue(size, endpoint)?;
 
-        net_trace!(
-            "{}:{}: buffer to send {} octets",
-            self.meta.handle,
-            endpoint,
-            size
-        );
+        net_trace!("icmp:{}: buffer to send {} octets", endpoint, size);
         Ok(packet_buf)
     }
 
@@ -316,8 +303,7 @@ impl<'a> IcmpSocket<'a> {
         let (endpoint, packet_buf) = self.rx_buffer.dequeue()?;
 
         net_trace!(
-            "{}:{}: receive {} buffered octets",
-            self.meta.handle,
+            "icmp:{}: receive {} buffered octets",
             endpoint,
             packet_buf.len()
         );
@@ -417,8 +403,7 @@ impl<'a> IcmpSocket<'a> {
                 );
 
                 net_trace!(
-                    "{}:{}: receiving {} octets",
-                    self.meta.handle,
+                    "icmp:{}: receiving {} octets",
                     icmp_repr.buffer_len(),
                     packet_buf.len()
                 );
@@ -436,8 +421,7 @@ impl<'a> IcmpSocket<'a> {
                 );
 
                 net_trace!(
-                    "{}:{}: receiving {} octets",
-                    self.meta.handle,
+                    "icmp:{}: receiving {} octets",
                     icmp_repr.buffer_len(),
                     packet_buf.len()
                 );
@@ -454,12 +438,10 @@ impl<'a> IcmpSocket<'a> {
     where
         F: FnOnce((IpRepr, IcmpRepr)) -> Result<()>,
     {
-        let handle = self.meta.handle;
         let hop_limit = self.hop_limit.unwrap_or(64);
         self.tx_buffer.dequeue_with(|remote_endpoint, packet_buf| {
             net_trace!(
-                "{}:{}: sending {} octets",
-                handle,
+                "icmp:{}: sending {} octets",
                 remote_endpoint,
                 packet_buf.len()
             );
@@ -515,12 +497,6 @@ impl<'a> IcmpSocket<'a> {
     }
 }
 
-impl<'a> From<IcmpSocket<'a>> for Socket<'a> {
-    fn from(val: IcmpSocket<'a>) -> Self {
-        Socket::Icmp(val)
-    }
-}
-
 #[cfg(test)]
 mod tests_common {
     pub use super::*;

src/socket/meta.rs

@@ -31,7 +31,7 @@ impl Default for NeighborState {
 /// is interested in, but which are more conveniently stored inside the socket itself.
 #[derive(Debug, Default)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct Meta {
+pub(crate) struct Meta {
     /// Handle of this socket within its enclosing `SocketSet`.
     /// Mainly useful for debug output.
     pub(crate) handle: SocketHandle,

src/socket/mod.rs

@@ -81,7 +81,13 @@ pub(crate) enum PollAt {
 /// [AnySocket]: trait.AnySocket.html
 /// [SocketSet::get]: struct.SocketSet.html#method.get
 #[derive(Debug)]
-pub enum Socket<'a> {
+pub struct Socket<'a> {
+    meta: SocketMeta,
+    pub(crate) socket: SocketEnum<'a>,
+}
+
+#[derive(Debug)]
+pub(crate) enum SocketEnum<'a> {
     #[cfg(feature = "socket-raw")]
     Raw(RawSocket<'a>),
     #[cfg(all(
@@ -97,29 +103,6 @@ pub enum Socket<'a> {
     Dhcpv4(Dhcpv4Socket),
 }
 
-macro_rules! dispatch_socket {
-    ($self_:expr, |$socket:ident| $code:expr) => {
-        dispatch_socket!(@inner $self_, |$socket| $code)
-    };
-    (mut $self_:expr, |$socket:ident| $code:expr) => {
-        dispatch_socket!(@inner mut $self_, |$socket| $code)
-    };
-    (@inner $( $mut_:ident )* $self_:expr, |$socket:ident| $code:expr) => {
-        match $self_ {
-            #[cfg(feature = "socket-raw")]
-            &$( $mut_ )* Socket::Raw(ref $( $mut_ )* $socket) => $code,
-            #[cfg(all(feature = "socket-icmp", any(feature = "proto-ipv4", feature = "proto-ipv6")))]
-            &$( $mut_ )* Socket::Icmp(ref $( $mut_ )* $socket) => $code,
-            #[cfg(feature = "socket-udp")]
-            &$( $mut_ )* Socket::Udp(ref $( $mut_ )* $socket) => $code,
-            #[cfg(feature = "socket-tcp")]
-            &$( $mut_ )* Socket::Tcp(ref $( $mut_ )* $socket) => $code,
-            #[cfg(feature = "socket-dhcpv4")]
-            &$( $mut_ )* Socket::Dhcpv4(ref $( $mut_ )* $socket) => $code,
-        }
-    };
-}
-
 impl<'a> Socket<'a> {
     /// Return the socket handle.
     #[inline]
@@ -128,30 +111,52 @@ impl<'a> Socket<'a> {
     }
 
     pub(crate) fn meta(&self) -> &SocketMeta {
-        dispatch_socket!(self, |socket| &socket.meta)
+        &self.meta
     }
 
     pub(crate) fn meta_mut(&mut self) -> &mut SocketMeta {
-        dispatch_socket!(mut self, |socket| &mut socket.meta)
+        &mut self.meta
     }
 
     pub(crate) fn poll_at(&self, cx: &Context) -> PollAt {
-        dispatch_socket!(self, |socket| socket.poll_at(cx))
+        match &self.socket {
+            #[cfg(feature = "socket-raw")]
+            SocketEnum::Raw(s) => s.poll_at(cx),
+            #[cfg(all(
+                feature = "socket-icmp",
+                any(feature = "proto-ipv4", feature = "proto-ipv6")
+            ))]
+            SocketEnum::Icmp(s) => s.poll_at(cx),
+            #[cfg(feature = "socket-udp")]
+            SocketEnum::Udp(s) => s.poll_at(cx),
+            #[cfg(feature = "socket-tcp")]
+            SocketEnum::Tcp(s) => s.poll_at(cx),
+            #[cfg(feature = "socket-dhcpv4")]
+            SocketEnum::Dhcpv4(s) => s.poll_at(cx),
+        }
     }
 }
 
 /// A conversion trait for network sockets.
 pub trait AnySocket<'a>: Sized {
+    fn upcast(self) -> Socket<'a>;
     fn downcast<'c>(socket: &'c mut Socket<'a>) -> Option<&'c mut Self>;
 }
 
 macro_rules! from_socket {
     ($socket:ty, $variant:ident) => {
         impl<'a> AnySocket<'a> for $socket {
+            fn upcast(self) -> Socket<'a> {
+                Socket {
+                    meta: SocketMeta::default(),
+                    socket: SocketEnum::$variant(self),
+                }
+            }
+
             fn downcast<'c>(socket: &'c mut Socket<'a>) -> Option<&'c mut Self> {
                 #[allow(unreachable_patterns)]
-                match socket {
-                    Socket::$variant(socket) => Some(socket),
+                match &mut socket.socket {
+                    SocketEnum::$variant(socket) => Some(socket),
                     _ => None,
                 }
             }