Rename PacketId to PacketMeta, make id field public.

src/iface/interface/ethernet.rs

@@ -14,7 +14,7 @@ impl InterfaceInner {
     pub(super) fn process_ethernet<'frame, T: AsRef<[u8]>>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: crate::phy::PacketId,
+        meta: crate::phy::PacketMeta,
         frame: &'frame T,
         fragments: &'frame mut FragmentsBuffer,
     ) -> Option<EthernetPacket<'frame>> {
@@ -35,13 +35,13 @@ impl InterfaceInner {
             EthernetProtocol::Ipv4 => {
                 let ipv4_packet = check!(Ipv4Packet::new_checked(eth_frame.payload()));
 
-                self.process_ipv4(sockets, packet_id, &ipv4_packet, fragments)
+                self.process_ipv4(sockets, meta, &ipv4_packet, fragments)
                     .map(EthernetPacket::Ip)
             }
             #[cfg(feature = "proto-ipv6")]
             EthernetProtocol::Ipv6 => {
                 let ipv6_packet = check!(Ipv6Packet::new_checked(eth_frame.payload()));
-                self.process_ipv6(sockets, packet_id, &ipv6_packet)
+                self.process_ipv6(sockets, meta, &ipv6_packet)
                     .map(EthernetPacket::Ip)
             }
             // Drop all other traffic.

src/iface/interface/ieee802154.rs

@@ -7,7 +7,7 @@ impl InterfaceInner {
     pub(super) fn process_ieee802154<'output, 'payload: 'output, T: AsRef<[u8]> + ?Sized>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         sixlowpan_payload: &'payload T,
         _fragments: &'output mut FragmentsBuffer,
     ) -> Option<IpPacket<'output>> {
@@ -34,7 +34,7 @@ impl InterfaceInner {
 
         match ieee802154_frame.payload() {
             Some(payload) => {
-                self.process_sixlowpan(sockets, packet_id, &ieee802154_repr, payload, _fragments)
+                self.process_sixlowpan(sockets, meta, &ieee802154_repr, payload, _fragments)
             }
             None => None,
         }

src/iface/interface/ipv4.rs

@@ -14,7 +14,7 @@ impl InterfaceInner {
     pub(super) fn process_ipv4<'a, T: AsRef<[u8]> + ?Sized>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ipv4_packet: &Ipv4Packet<&'a T>,
         frag: &'a mut FragmentsBuffer,
     ) -> Option<IpPacket<'a>> {
@@ -139,7 +139,7 @@ impl InterfaceInner {
 
                 self.process_udp(
                     sockets,
-                    packet_id,
+                    meta,
                     ip_repr,
                     udp_repr,
                     handled_by_raw_socket,

src/iface/interface/ipv6.rs

@@ -8,7 +8,7 @@ use super::SocketSet;
 use crate::socket::icmp;
 use crate::socket::AnySocket;
 
-use crate::phy::PacketId;
+use crate::phy::PacketMeta;
 use crate::wire::*;
 
 impl InterfaceInner {
@@ -16,7 +16,7 @@ impl InterfaceInner {
     pub(super) fn process_ipv6<'frame, T: AsRef<[u8]> + ?Sized>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ipv6_packet: &Ipv6Packet<&'frame T>,
     ) -> Option<IpPacket<'frame>> {
         let ipv6_repr = check!(Ipv6Repr::parse(ipv6_packet));
@@ -36,7 +36,7 @@ impl InterfaceInner {
 
         self.process_nxt_hdr(
             sockets,
-            packet_id,
+            meta,
             ipv6_repr,
             ipv6_repr.next_header,
             handled_by_raw_socket,
@@ -50,7 +50,7 @@ impl InterfaceInner {
     pub(super) fn process_nxt_hdr<'frame>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ipv6_repr: Ipv6Repr,
         nxt_hdr: IpProtocol,
         handled_by_raw_socket: bool,
@@ -71,7 +71,7 @@ impl InterfaceInner {
 
                 self.process_udp(
                     sockets,
-                    packet_id,
+                    meta,
                     ipv6_repr.into(),
                     udp_repr,
                     handled_by_raw_socket,
@@ -83,13 +83,9 @@ impl InterfaceInner {
             #[cfg(feature = "socket-tcp")]
             IpProtocol::Tcp => self.process_tcp(sockets, ipv6_repr.into(), ip_payload),
 
-            IpProtocol::HopByHop => self.process_hopbyhop(
-                sockets,
-                packet_id,
-                ipv6_repr,
-                handled_by_raw_socket,
-                ip_payload,
-            ),
+            IpProtocol::HopByHop => {
+                self.process_hopbyhop(sockets, meta, ipv6_repr, handled_by_raw_socket, ip_payload)
+            }
 
             #[cfg(feature = "socket-raw")]
             _ if handled_by_raw_socket => None,
@@ -249,7 +245,7 @@ impl InterfaceInner {
     pub(super) fn process_hopbyhop<'frame>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ipv6_repr: Ipv6Repr,
         handled_by_raw_socket: bool,
         ip_payload: &'frame [u8],
@@ -282,7 +278,7 @@ impl InterfaceInner {
         }
         self.process_nxt_hdr(
             sockets,
-            packet_id,
+            meta,
             ipv6_repr,
             hbh_repr.next_header,
             handled_by_raw_socket,

src/iface/interface/mod.rs

@@ -37,7 +37,7 @@ use crate::config::{
     IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT,
 };
 use crate::iface::Routes;
-use crate::phy::PacketId;
+use crate::phy::PacketMeta;
 use crate::phy::{ChecksumCapabilities, Device, DeviceCapabilities, Medium, RxToken, TxToken};
 use crate::rand::Rand;
 #[cfg(feature = "socket-dns")]
@@ -321,7 +321,7 @@ pub(crate) enum IpPacket<'a> {
     #[cfg(feature = "socket-raw")]
     Raw((IpRepr, &'a [u8])),
     #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
-    Udp((IpRepr, UdpRepr, &'a [u8], PacketId)),
+    Udp((IpRepr, UdpRepr, &'a [u8], PacketMeta)),
     #[cfg(feature = "socket-tcp")]
     Tcp((IpRepr, TcpRepr<'a>)),
     #[cfg(feature = "socket-dhcpv4")]
@@ -348,11 +348,11 @@ impl<'a> IpPacket<'a> {
         }
     }
 
-    pub(crate) fn packet_id(&self) -> PacketId {
+    pub(crate) fn meta(&self) -> PacketMeta {
         match self {
             #[cfg(feature = "socket-udp")]
-            IpPacket::Udp((_, _, _, packet_id)) => *packet_id,
-            _ => PacketId::empty(),
+            IpPacket::Udp((_, _, _, meta)) => *meta,
+            _ => PacketMeta::default(),
         }
     }
 
@@ -814,14 +814,14 @@ impl Interface {
         let mut processed_any = false;
 
         while let Some((rx_token, tx_token)) = device.receive(self.inner.now) {
-            let rx_packet_id = rx_token.packet_id();
+            let rx_meta = rx_token.meta();
             rx_token.consume(|frame| {
                 match self.inner.caps.medium {
                     #[cfg(feature = "medium-ethernet")]
                     Medium::Ethernet => {
                         if let Some(packet) = self.inner.process_ethernet(
                             sockets,
-                            rx_packet_id,
+                            rx_meta,
                             &frame,
                             &mut self.fragments,
                         ) {
@@ -834,12 +834,10 @@ impl Interface {
                     }
                     #[cfg(feature = "medium-ip")]
                     Medium::Ip => {
-                        if let Some(packet) = self.inner.process_ip(
-                            sockets,
-                            rx_packet_id,
-                            &frame,
-                            &mut self.fragments,
-                        ) {
+                        if let Some(packet) =
+                            self.inner
+                                .process_ip(sockets, rx_meta, &frame, &mut self.fragments)
+                        {
                             if let Err(err) =
                                 self.inner
                                     .dispatch_ip(tx_token, packet, &mut self.fragmenter)
@@ -852,7 +850,7 @@ impl Interface {
                     Medium::Ieee802154 => {
                         if let Some(packet) = self.inner.process_ieee802154(
                             sockets,
-                            rx_packet_id,
+                            rx_meta,
                             &frame,
                             &mut self.fragments,
                         ) {
@@ -944,7 +942,10 @@ impl Interface {
                 #[cfg(feature = "socket-dns")]
                 Socket::Dns(socket) => {
                     socket.dispatch(&mut self.inner, |inner, (ip, udp, payload)| {
-                        respond(inner, IpPacket::Udp((ip, udp, payload, PacketId::empty())))
+                        respond(
+                            inner,
+                            IpPacket::Udp((ip, udp, payload, PacketMeta::default())),
+                        )
                     })
                 }
             };
@@ -1284,7 +1285,7 @@ impl InterfaceInner {
     fn process_ip<'frame, T: AsRef<[u8]>>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ip_payload: &'frame T,
         frag: &'frame mut FragmentsBuffer,
     ) -> Option<IpPacket<'frame>> {
@@ -1293,12 +1294,12 @@ impl InterfaceInner {
             Ok(IpVersion::Ipv4) => {
                 let ipv4_packet = check!(Ipv4Packet::new_checked(ip_payload));
 
-                self.process_ipv4(sockets, packet_id, &ipv4_packet, frag)
+                self.process_ipv4(sockets, meta, &ipv4_packet, frag)
             }
             #[cfg(feature = "proto-ipv6")]
             Ok(IpVersion::Ipv6) => {
                 let ipv6_packet = check!(Ipv6Packet::new_checked(ip_payload));
-                self.process_ipv6(sockets, packet_id, &ipv6_packet)
+                self.process_ipv6(sockets, meta, &ipv6_packet)
             }
             // Drop all other traffic.
             _ => None,
@@ -1367,7 +1368,7 @@ impl InterfaceInner {
     fn process_udp<'frame>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ip_repr: IpRepr,
         udp_repr: UdpRepr,
         handled_by_raw_socket: bool,
@@ -1380,7 +1381,7 @@ impl InterfaceInner {
             .filter_map(|i| udp::Socket::downcast_mut(&mut i.socket))
         {
             if udp_socket.accepts(self, &ip_repr, &udp_repr) {
-                udp_socket.process(self, packet_id, &ip_repr, &udp_repr, udp_payload);
+                udp_socket.process(self, meta, &ip_repr, &udp_repr, udp_payload);
                 return None;
             }
         }
@@ -1834,7 +1835,7 @@ impl InterfaceInner {
                         Ok(())
                     }
                 } else {
-                    tx_token.set_packet_id(packet.packet_id());
+                    tx_token.set_meta(packet.meta());
 
                     // No fragmentation is required.
                     tx_token.consume(total_len, |mut tx_buffer| {

src/iface/interface/sixlowpan.rs

@@ -11,7 +11,7 @@ impl InterfaceInner {
     pub(super) fn process_sixlowpan<'output, 'payload: 'output, T: AsRef<[u8]> + ?Sized>(
         &mut self,
         sockets: &mut SocketSet,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ieee802154_repr: &Ieee802154Repr,
         payload: &'payload T,
         f: &'output mut FragmentsBuffer,
@@ -48,11 +48,7 @@ impl InterfaceInner {
             }
         };
 
-        self.process_ipv6(
-            sockets,
-            packet_id,
-            &check!(Ipv6Packet::new_checked(payload)),
-        )
+        self.process_ipv6(sockets, meta, &check!(Ipv6Packet::new_checked(payload)))
     }
 
     #[cfg(feature = "proto-sixlowpan-fragmentation")]
@@ -434,7 +430,7 @@ impl InterfaceInner {
                 return;
             }
         } else {
-            tx_token.set_packet_id(packet.packet_id());
+            tx_token.set_meta(packet.meta());
 
             // We don't need fragmentation, so we emit everything to the TX token.
             tx_token.consume(total_size + ieee_len, |mut tx_buf| {

src/iface/interface/tests.rs

@@ -168,7 +168,7 @@ fn test_no_icmp_no_unicast_ipv4() {
     assert_eq!(
         iface.inner.process_ipv4(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &frame,
             &mut iface.fragments
         ),
@@ -204,7 +204,7 @@ fn test_no_icmp_no_unicast_ipv6() {
     assert_eq!(
         iface
             .inner
-            .process_ipv6(&mut sockets, PacketId::empty(), &frame),
+            .process_ipv6(&mut sockets, PacketMeta::default(), &frame),
         None
     );
 }
@@ -259,7 +259,7 @@ fn test_icmp_error_no_payload() {
     assert_eq!(
         iface.inner.process_ipv4(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &frame,
             &mut iface.fragments
         ),
@@ -398,7 +398,7 @@ fn test_icmp_error_port_unreachable() {
     assert_eq!(
         iface.inner.process_udp(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             ip_repr,
             udp_repr,
             false,
@@ -432,7 +432,7 @@ fn test_icmp_error_port_unreachable() {
     assert_eq!(
         iface.inner.process_udp(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             ip_repr,
             udp_repr,
             false,
@@ -508,7 +508,7 @@ fn test_handle_udp_broadcast() {
     assert_eq!(
         iface.inner.process_udp(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             ip_repr,
             udp_repr,
             false,
@@ -526,7 +526,7 @@ fn test_handle_udp_broadcast() {
         socket.recv(),
         Ok((
             &UDP_PAYLOAD[..],
-            UdpMetadata::new(IpEndpoint::new(src_ip.into(), 67), PacketId::empty(),)
+            UdpMetadata::new(IpEndpoint::new(src_ip.into(), 67), PacketMeta::default(),)
         ))
     );
 }
@@ -590,7 +590,7 @@ fn test_handle_ipv4_broadcast() {
     assert_eq!(
         iface.inner.process_ipv4(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &frame,
             &mut iface.fragments
         ),
@@ -705,7 +705,7 @@ fn test_icmp_reply_size() {
     assert_eq!(
         iface.inner.process_udp(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             ip_repr.into(),
             udp_repr,
             false,
@@ -718,7 +718,7 @@ fn test_icmp_reply_size() {
     assert_eq!(
         iface.inner.process_udp(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             ip_repr.into(),
             udp_repr,
             false,
@@ -760,7 +760,7 @@ fn test_handle_valid_arp_request() {
     assert_eq!(
         iface.inner.process_ethernet(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             frame.into_inner(),
             &mut iface.fragments
         ),
@@ -839,7 +839,7 @@ fn test_handle_valid_ndisc_request() {
     assert_eq!(
         iface.inner.process_ethernet(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             frame.into_inner(),
             &mut iface.fragments
         ),
@@ -890,7 +890,7 @@ fn test_handle_other_arp_request() {
     assert_eq!(
         iface.inner.process_ethernet(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             frame.into_inner(),
             &mut iface.fragments
         ),
@@ -946,7 +946,7 @@ fn test_arp_flush_after_update_ip() {
     assert_eq!(
         iface.inner.process_ethernet(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             frame.into_inner(),
             &mut iface.fragments
         ),
@@ -1144,7 +1144,7 @@ fn test_icmpv6_nxthdr_unknown() {
     assert_eq!(
         iface
             .inner
-            .process_ipv6(&mut sockets, PacketId::empty(), &frame),
+            .process_ipv6(&mut sockets, PacketMeta::default(), &frame),
         Some(IpPacket::Icmpv6((reply_ipv6_repr, reply_icmp_repr)))
     );
 }
@@ -1310,7 +1310,7 @@ fn test_raw_socket_no_reply() {
     assert_eq!(
         iface.inner.process_ipv4(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &frame,
             &mut iface.fragments
         ),
@@ -1402,7 +1402,7 @@ fn test_raw_socket_with_udp_socket() {
     assert_eq!(
         iface.inner.process_ipv4(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &frame,
             &mut iface.fragments
         ),
@@ -1416,7 +1416,7 @@ fn test_raw_socket_with_udp_socket() {
         socket.recv(),
         Ok((
             &UDP_PAYLOAD[..],
-            UdpMetadata::new(IpEndpoint::new(src_addr.into(), 67), PacketId::empty(),)
+            UdpMetadata::new(IpEndpoint::new(src_addr.into(), 67), PacketMeta::default(),)
         ))
     );
 }
@@ -1511,7 +1511,7 @@ fn test_echo_request_sixlowpan_128_bytes() {
     assert_eq!(
         iface.inner.process_sixlowpan(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &ieee802154_repr,
             &request_first_part_packet.into_inner(),
             &mut iface.fragments
@@ -1536,7 +1536,7 @@ fn test_echo_request_sixlowpan_128_bytes() {
 
     let result = iface.inner.process_sixlowpan(
         &mut sockets,
-        PacketId::empty(),
+        PacketMeta::default(),
         &ieee802154_repr,
         &request_second_part,
         &mut iface.fragments,
@@ -1667,7 +1667,7 @@ fn test_sixlowpan_udp_with_fragmentation() {
     assert_eq!(
         iface.inner.process_sixlowpan(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &ieee802154_repr,
             udp_first_part,
             &mut iface.fragments
@@ -1687,7 +1687,7 @@ fn test_sixlowpan_udp_with_fragmentation() {
     assert_eq!(
         iface.inner.process_sixlowpan(
             &mut sockets,
-            PacketId::empty(),
+            PacketMeta::default(),
             &ieee802154_repr,
             udp_second_part,
             &mut iface.fragments
@@ -1731,7 +1731,7 @@ fn test_sixlowpan_udp_with_fragmentation() {
                 dst_port: 1234,
             },
             udp_data,
-            PacketId::empty(),
+            PacketMeta::default(),
         )),
         &mut iface.fragmenter,
     );

src/phy/fault_injector.rs

@@ -1,7 +1,7 @@
 use crate::phy::{self, Device, DeviceCapabilities};
 use crate::time::{Duration, Instant};
 
-use super::PacketId;
+use super::PacketMeta;
 
 // We use our own RNG to stay compatible with #![no_std].
 // The use of the RNG below has a slight bias, but it doesn't matter.
@@ -213,7 +213,7 @@ impl<D: Device> Device for FaultInjector<D> {
 
     fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
         let (rx_token, tx_token) = self.inner.receive(timestamp)?;
-        let rx_packet_id = <D::RxToken<'_> as phy::RxToken>::packet_id(&rx_token);
+        let rx_meta = <D::RxToken<'_> as phy::RxToken>::meta(&rx_token);
 
         let len = super::RxToken::consume(rx_token, |buffer| {
             if (self.config.max_size > 0 && buffer.len() > self.config.max_size)
@@ -243,10 +243,7 @@ impl<D: Device> Device for FaultInjector<D> {
             self.state.corrupt(&mut buf[..]);
         }
 
-        let rx = RxToken {
-            buf,
-            packet_id: rx_packet_id,
-        };
+        let rx = RxToken { buf, meta: rx_meta };
         let tx = TxToken {
             state: &mut self.state,
             config: self.config,
@@ -271,7 +268,7 @@ impl<D: Device> Device for FaultInjector<D> {
 #[doc(hidden)]
 pub struct RxToken<'a> {
     buf: &'a mut [u8],
-    packet_id: PacketId,
+    meta: PacketMeta,
 }
 
 impl<'a> phy::RxToken for RxToken<'a> {
@@ -282,8 +279,8 @@ impl<'a> phy::RxToken for RxToken<'a> {
         f(self.buf)
     }
 
-    fn packet_id(&self) -> phy::PacketId {
-        self.packet_id
+    fn meta(&self) -> phy::PacketMeta {
+        self.meta
     }
 }
 
@@ -327,7 +324,7 @@ impl<'a, Tx: phy::TxToken> phy::TxToken for TxToken<'a, Tx> {
         })
     }
 
-    fn set_packet_id(&mut self, packet_id: PacketId) {
-        self.token.set_packet_id(packet_id);
+    fn set_meta(&mut self, meta: PacketMeta) {
+        self.token.set_meta(meta);
     }
 }

src/phy/fuzz_injector.rs

@@ -100,8 +100,8 @@ impl<'a, Rx: phy::RxToken, FRx: Fuzzer> phy::RxToken for RxToken<'a, Rx, FRx> {
         })
     }
 
-    fn packet_id(&self) -> phy::PacketId {
-        self.token.packet_id()
+    fn meta(&self) -> phy::PacketMeta {
+        self.token.meta()
     }
 }
 
@@ -123,7 +123,7 @@ impl<'a, Tx: phy::TxToken, FTx: Fuzzer> phy::TxToken for TxToken<'a, Tx, FTx> {
         })
     }
 
-    fn set_packet_id(&mut self, packet_id: phy::PacketId) {
-        self.token.set_packet_id(packet_id)
+    fn set_meta(&mut self, meta: phy::PacketMeta) {
+        self.token.set_meta(meta)
     }
 }

src/phy/mod.rs

@@ -133,38 +133,11 @@ pub use self::tuntap_interface::TunTapInterface;
 /// An ID that can be used to uniquely identify a packet to a [`Device`],
 /// sent or received by that same [`Device`]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
-pub struct PacketId {
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Default)]
+#[non_exhaustive]
+pub struct PacketMeta {
     #[cfg(feature = "packet-id")]
-    id: Option<u32>,
-}
-
-impl PacketId {
-    pub fn empty() -> Self {
-        #[cfg(feature = "packet-id")]
-        {
-            Self { id: None }
-        }
-        #[cfg(not(feature = "packet-id"))]
-        {
-            Self {}
-        }
-    }
-}
-
-#[cfg(feature = "packet-id")]
-impl PacketId {
-    pub fn id(&self) -> Option<u32> {
-        self.id
-    }
-
-    /// Create a new packet ID.
-    ///
-    /// A caller of this function should know the context in which
-    /// this ID is relevant.
-    pub fn new(id: u32) -> Self {
-        Self { id: Some(id) }
-    }
+    pub id: Option<u32>,
 }
 
 /// A description of checksum behavior for a particular protocol.
@@ -378,8 +351,8 @@ pub trait RxToken {
         F: FnOnce(&mut [u8]) -> R;
 
     /// The Packet ID associated with the frame received by this [`RxToken`]
-    fn packet_id(&self) -> PacketId {
-        PacketId::empty()
+    fn meta(&self) -> PacketMeta {
+        PacketMeta::default()
     }
 }
 
@@ -397,5 +370,5 @@ pub trait TxToken {
 
     /// The Packet ID to be associated with the frame to be transmitted by this [`TxToken`].
     #[allow(unused_variables)]
-    fn set_packet_id(&mut self, packet_id: PacketId) {}
+    fn set_meta(&mut self, meta: PacketMeta) {}
 }

src/phy/pcap_writer.rs

@@ -232,8 +232,8 @@ impl<'a, Rx: phy::RxToken, S: PcapSink> phy::RxToken for RxToken<'a, Rx, S> {
         })
     }
 
-    fn packet_id(&self) -> phy::PacketId {
-        self.token.packet_id()
+    fn meta(&self) -> phy::PacketMeta {
+        self.token.meta()
     }
 }
 
@@ -262,7 +262,7 @@ impl<'a, Tx: phy::TxToken, S: PcapSink> phy::TxToken for TxToken<'a, Tx, S> {
         })
     }
 
-    fn set_packet_id(&mut self, packet_id: phy::PacketId) {
-        self.token.set_packet_id(packet_id)
+    fn set_meta(&mut self, meta: phy::PacketMeta) {
+        self.token.set_meta(meta)
     }
 }

src/phy/tracer.rs

@@ -109,8 +109,8 @@ impl<Rx: phy::RxToken> phy::RxToken for RxToken<Rx> {
         })
     }
 
-    fn packet_id(&self) -> phy::PacketId {
-        self.token.packet_id()
+    fn meta(&self) -> phy::PacketMeta {
+        self.token.meta()
     }
 }
 
@@ -141,8 +141,8 @@ impl<Tx: phy::TxToken> phy::TxToken for TxToken<Tx> {
         })
     }
 
-    fn set_packet_id(&mut self, packet_id: phy::PacketId) {
-        self.token.set_packet_id(packet_id)
+    fn set_meta(&mut self, meta: phy::PacketMeta) {
+        self.token.set_meta(meta)
     }
 }
 

src/socket/udp.rs

@@ -3,7 +3,7 @@ use core::cmp::min;
 use core::task::Waker;
 
 use crate::iface::Context;
-use crate::phy::PacketId;
+use crate::phy::PacketMeta;
 use crate::socket::PollAt;
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
@@ -14,7 +14,7 @@ use crate::wire::{IpEndpoint, IpListenEndpoint, IpProtocol, IpRepr, UdpRepr};
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct UdpMetadata {
     endpoint: IpEndpoint,
-    packet_id: PacketId,
+    meta: PacketMeta,
 }
 
 impl UdpMetadata {
@@ -24,27 +24,24 @@ impl UdpMetadata {
     }
 
     /// The packet ID of this metadata
-    pub fn packet_id(self) -> PacketId {
-        self.packet_id
+    pub fn meta(self) -> PacketMeta {
+        self.meta
     }
 
     /// Create a new metadata instance.
     ///
-    /// If `packet_id` is `Some`, it can be used to track a datagram
+    /// If `meta` is `Some`, it can be used to track a datagram
     /// as it is handled by the networking stack, or other elements of `smoltcp`
     /// that interact with the specific datagram.
-    pub(crate) fn new(endpoint: IpEndpoint, packet_id: PacketId) -> Self {
-        Self {
-            endpoint,
-            packet_id,
-        }
+    pub(crate) fn new(endpoint: IpEndpoint, meta: PacketMeta) -> Self {
+        Self { endpoint, meta }
     }
 }
 
 impl core::fmt::Display for UdpMetadata {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         #[cfg(feature = "packet-id")]
-        return write!(f, "{}, PacketID: {:?}", self.endpoint, self.packet_id);
+        return write!(f, "{}, PacketID: {:?}", self.endpoint, self.meta);
 
         #[cfg(not(feature = "packet-id"))]
         write!(f, "{}", self.endpoint)
@@ -323,7 +320,10 @@ impl<'a> Socket<'a> {
 
         let payload_buf = self
             .tx_buffer
-            .enqueue(size, UdpMetadata::new(remote_endpoint, PacketId::empty()))
+            .enqueue(
+                size,
+                UdpMetadata::new(remote_endpoint, PacketMeta::default()),
+            )
             .map_err(|_| SendError::BufferFull)?;
 
         net_trace!(
@@ -354,12 +354,12 @@ impl<'a> Socket<'a> {
             return Err(SendError::Unaddressable);
         }
 
+        let mut meta = PacketMeta::default();
+        meta.id = Some(packet_id);
+
         let payload_buf = self
             .tx_buffer
-            .enqueue(
-                size,
-                UdpMetadata::new(remote_endpoint, PacketId::new(packet_id)),
-            )
+            .enqueue(size, UdpMetadata::new(remote_endpoint, meta))
             .map_err(|_| SendError::BufferFull)?;
 
         net_trace!(
@@ -401,7 +401,7 @@ impl<'a> Socket<'a> {
             .tx_buffer
             .enqueue_with_infallible(
                 max_size,
-                UdpMetadata::new(remote_endpoint, PacketId::empty()),
+                UdpMetadata::new(remote_endpoint, PacketMeta::default()),
                 f,
             )
             .map_err(|_| SendError::BufferFull)?;
@@ -507,7 +507,7 @@ impl<'a> Socket<'a> {
     pub(crate) fn process(
         &mut self,
         cx: &mut Context,
-        packet_id: PacketId,
+        meta: PacketMeta,
         ip_repr: &IpRepr,
         repr: &UdpRepr,
         payload: &[u8],
@@ -530,7 +530,7 @@ impl<'a> Socket<'a> {
 
         let metadata = UdpMetadata {
             endpoint: remote_endpoint,
-            packet_id,
+            meta,
         };
 
         match self.rx_buffer.enqueue(size, metadata) {
@@ -548,7 +548,7 @@ impl<'a> Socket<'a> {
 
     pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
     where
-        F: FnOnce(&mut Context, (IpRepr, UdpRepr, &[u8], PacketId)) -> Result<(), E>,
+        F: FnOnce(&mut Context, (IpRepr, UdpRepr, &[u8], PacketMeta)) -> Result<(), E>,
     {
         let endpoint = self.endpoint;
         let hop_limit = self.hop_limit.unwrap_or(64);
@@ -588,7 +588,7 @@ impl<'a> Socket<'a> {
                 hop_limit,
             );
 
-            emit(cx, (ip_repr, repr, payload_buf, packet_meta.packet_id))
+            emit(cx, (ip_repr, repr, payload_buf, packet_meta.meta))
         });
         match res {
             Err(Empty) => Ok(()),
@@ -778,7 +778,7 @@ mod test {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&mut cx, |_, (ip_repr, udp_repr, payload, _packet_id)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, udp_repr, payload, _meta)| {
                 assert_eq!(ip_repr, LOCAL_IP_REPR);
                 assert_eq!(udp_repr, LOCAL_UDP_REPR);
                 assert_eq!(payload, PAYLOAD);
@@ -789,7 +789,7 @@ mod test {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&mut cx, |_, (ip_repr, udp_repr, payload, _packet_id)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, udp_repr, payload, _meta)| {
                 assert_eq!(ip_repr, LOCAL_IP_REPR);
                 assert_eq!(udp_repr, LOCAL_UDP_REPR);
                 assert_eq!(payload, PAYLOAD);
@@ -813,7 +813,7 @@ mod test {
         assert!(socket.accepts(&mut cx, &REMOTE_IP_REPR, &REMOTE_UDP_REPR));
         socket.process(
             &mut cx,
-            PacketId::empty(),
+            PacketMeta::default(),
             &REMOTE_IP_REPR,
             &REMOTE_UDP_REPR,
             PAYLOAD,
@@ -823,7 +823,7 @@ mod test {
         assert!(socket.accepts(&mut cx, &REMOTE_IP_REPR, &REMOTE_UDP_REPR));
         socket.process(
             &mut cx,
-            PacketId::empty(),
+            PacketMeta::default(),
             &REMOTE_IP_REPR,
             &REMOTE_UDP_REPR,
             PAYLOAD,
@@ -833,7 +833,7 @@ mod test {
             socket.recv(),
             Ok((
                 &b"abcdef"[..],
-                UdpMetadata::new(REMOTE_END, PacketId::empty())
+                UdpMetadata::new(REMOTE_END, PacketMeta::default())
             ))
         );
         assert!(!socket.can_recv());
@@ -850,7 +850,7 @@ mod test {
 
         socket.process(
             &mut cx,
-            PacketId::empty(),
+            PacketMeta::default(),
             &REMOTE_IP_REPR,
             &REMOTE_UDP_REPR,
             PAYLOAD,
@@ -859,14 +859,14 @@ mod test {
             socket.peek(),
             Ok((
                 &b"abcdef"[..],
-                &UdpMetadata::new(REMOTE_END, PacketId::empty())
+                &UdpMetadata::new(REMOTE_END, PacketMeta::default())
             ))
         );
         assert_eq!(
             socket.recv(),
             Ok((
                 &b"abcdef"[..],
-                UdpMetadata::new(REMOTE_END, PacketId::empty())
+                UdpMetadata::new(REMOTE_END, PacketMeta::default())
             ))
         );
         assert_eq!(socket.peek(), Err(RecvError::Exhausted));
@@ -882,7 +882,7 @@ mod test {
         assert!(socket.accepts(&mut cx, &REMOTE_IP_REPR, &REMOTE_UDP_REPR));
         socket.process(
             &mut cx,
-            PacketId::empty(),
+            PacketMeta::default(),
             &REMOTE_IP_REPR,
             &REMOTE_UDP_REPR,
             PAYLOAD,
@@ -891,7 +891,7 @@ mod test {
         let mut slice = [0; 4];
         assert_eq!(
             socket.recv_slice(&mut slice[..]),
-            Ok((4, UdpMetadata::new(REMOTE_END, PacketId::empty())))
+            Ok((4, UdpMetadata::new(REMOTE_END, PacketMeta::default())))
         );
         assert_eq!(&slice, b"abcd");
     }
@@ -905,7 +905,7 @@ mod test {
 
         socket.process(
             &mut cx,
-            PacketId::empty(),
+            PacketMeta::default(),
             &REMOTE_IP_REPR,
             &REMOTE_UDP_REPR,
             PAYLOAD,
@@ -914,12 +914,12 @@ mod test {
         let mut slice = [0; 4];
         assert_eq!(
             socket.peek_slice(&mut slice[..]),
-            Ok((4, &UdpMetadata::new(REMOTE_END, PacketId::empty())))
+            Ok((4, &UdpMetadata::new(REMOTE_END, PacketMeta::default())))
         );
         assert_eq!(&slice, b"abcd");
         assert_eq!(
             socket.recv_slice(&mut slice[..]),
-            Ok((4, UdpMetadata::new(REMOTE_END, PacketId::empty())))
+            Ok((4, UdpMetadata::new(REMOTE_END, PacketMeta::default())))
         );
         assert_eq!(&slice, b"abcd");
         assert_eq!(socket.peek_slice(&mut slice[..]), Err(RecvError::Exhausted));
@@ -1005,10 +1005,10 @@ mod test {
             src_port: REMOTE_PORT,
             dst_port: LOCAL_PORT,
         };
-        socket.process(&mut cx, PacketId::empty(), &REMOTE_IP_REPR, &repr, &[]);
+        socket.process(&mut cx, PacketMeta::default(), &REMOTE_IP_REPR, &repr, &[]);
         assert_eq!(
             socket.recv(),
-            Ok((&[][..], UdpMetadata::new(REMOTE_END, PacketId::empty())))
+            Ok((&[][..], UdpMetadata::new(REMOTE_END, PacketMeta::default())))
         );
     }