iface: use reassembly timeout setting for both ipv4 and 6lowpan.

Author: Dirbaio

src/iface/interface/ethernet.rs

@@ -34,13 +34,8 @@ impl InterfaceInner {
             EthernetProtocol::Ipv4 => {
                 let ipv4_packet = check!(Ipv4Packet::new_checked(eth_frame.payload()));
 
-                self.process_ipv4(
-                    sockets,
-                    &ipv4_packet,
-                    #[cfg(feature = "proto-ipv4-fragmentation")]
-                    &mut fragments.assembler,
-                )
-                .map(EthernetPacket::Ip)
+                self.process_ipv4(sockets, &ipv4_packet, fragments)
+                    .map(EthernetPacket::Ip)
             }
             #[cfg(feature = "proto-ipv6")]
             EthernetProtocol::Ipv6 => {

src/iface/interface/ipv4.rs

@@ -7,15 +7,15 @@ use crate::socket::icmp;
 use crate::socket::AnySocket;
 
 use crate::phy::{Medium, TxToken};
-use crate::time::{Duration, Instant};
+use crate::time::Instant;
 use crate::wire::*;
 
 impl InterfaceInner {
     pub(super) fn process_ipv4<'a, T: AsRef<[u8]> + ?Sized>(
         &mut self,
         sockets: &mut SocketSet,
         ipv4_packet: &Ipv4Packet<&'a T>,
-        #[cfg(feature = "proto-ipv4-fragmentation")] assembler: &'a mut PacketAssemblerSet<FragKey>,
+        frag: &'a mut FragmentsBuffer,
     ) -> Option<IpPacket<'a>> {
         let ipv4_repr = check!(Ipv4Repr::parse(ipv4_packet, &self.caps.checksum));
         if !self.is_unicast_v4(ipv4_repr.src_addr) {
@@ -26,12 +26,10 @@ impl InterfaceInner {
 
         #[cfg(feature = "proto-ipv4-fragmentation")]
         let ip_payload = {
-            const REASSEMBLY_TIMEOUT: Duration = Duration::from_secs(90);
-
             if ipv4_packet.more_frags() || ipv4_packet.frag_offset() != 0 {
                 let key = FragKey::Ipv4(ipv4_packet.get_key());
 
-                let f = match assembler.get(&key, self.now + REASSEMBLY_TIMEOUT) {
+                let f = match frag.assembler.get(&key, self.now + frag.reassembly_timeout) {
                     Ok(f) => f,
                     Err(_) => {
                         net_debug!("No available packet assembler for fragmented packet");

src/iface/interface/mod.rs

@@ -60,8 +60,8 @@ pub(crate) struct FragmentsBuffer {
     #[cfg(feature = "_proto-fragmentation")]
     pub(crate) assembler: PacketAssemblerSet<FragKey>,
 
-    #[cfg(feature = "proto-sixlowpan-fragmentation")]
-    sixlowpan_reassembly_timeout: Duration,
+    #[cfg(feature = "_proto-fragmentation")]
+    reassembly_timeout: Duration,
 }
 
 #[cfg(not(feature = "_proto-fragmentation"))]
@@ -538,8 +538,8 @@ impl Interface {
 
                 #[cfg(feature = "_proto-fragmentation")]
                 assembler: PacketAssemblerSet::new(),
-                #[cfg(feature = "proto-sixlowpan-fragmentation")]
-                sixlowpan_reassembly_timeout: Duration::from_secs(60),
+                #[cfg(feature = "_proto-fragmentation")]
+                reassembly_timeout: Duration::from_secs(60),
             },
             fragmenter: Fragmenter::new(),
             inner: InterfaceInner {
@@ -703,22 +703,18 @@ impl Interface {
     }
 
     /// Get the packet reassembly timeout.
-    ///
-    /// Currently used only for 6LoWPAN, will be used for IPv4 in the future as well.
-    #[cfg(feature = "proto-sixlowpan-fragmentation")]
+    #[cfg(feature = "_proto-fragmentation")]
     pub fn reassembly_timeout(&self) -> Duration {
-        self.fragments.sixlowpan_reassembly_timeout
+        self.fragments.reassembly_timeout
     }
 
     /// Set the packet reassembly timeout.
-    ///
-    /// Currently used only for 6LoWPAN, will be used for IPv4 in the future as well.
-    #[cfg(feature = "proto-sixlowpan-fragmentation")]
+    #[cfg(feature = "_proto-fragmentation")]
     pub fn set_reassembly_timeout(&mut self, timeout: Duration) {
         if timeout > Duration::from_secs(60) {
             net_debug!("RFC 4944 specifies that the reassembly timeout MUST be set to a maximum of 60 seconds");
         }
-        self.fragments.sixlowpan_reassembly_timeout = timeout;
+        self.fragments.reassembly_timeout = timeout;
     }
 
     /// Transmit packets queued in the given sockets, and receive packets queued
@@ -1288,19 +1284,14 @@ impl InterfaceInner {
         &mut self,
         sockets: &mut SocketSet,
         ip_payload: &'frame T,
-        fragments: &'frame mut FragmentsBuffer,
+        frag: &'frame mut FragmentsBuffer,
     ) -> Option<IpPacket<'frame>> {
         match IpVersion::of_packet(ip_payload.as_ref()) {
             #[cfg(feature = "proto-ipv4")]
             Ok(IpVersion::Ipv4) => {
                 let ipv4_packet = check!(Ipv4Packet::new_checked(ip_payload));
 
-                self.process_ipv4(
-                    sockets,
-                    &ipv4_packet,
-                    #[cfg(feature = "proto-ipv4-fragmentation")]
-                    &mut fragments.assembler,
-                )
+                self.process_ipv4(sockets, &ipv4_packet, frag)
             }
             #[cfg(feature = "proto-ipv6")]
             Ok(IpVersion::Ipv6) => {

src/iface/interface/sixlowpan.rs

@@ -107,10 +107,7 @@ impl InterfaceInner {
         // This information is the total size of the packet when it is fully assmbled.
         // We also pass the header size, since this is needed when other fragments
         // (other than the first one) are added.
-        let frag_slot = match f
-            .assembler
-            .get(&key, self.now + f.sixlowpan_reassembly_timeout)
-        {
+        let frag_slot = match f.assembler.get(&key, self.now + f.reassembly_timeout) {
             Ok(frag) => frag,
             Err(AssemblerFullError) => {
                 net_debug!("No available packet assembler for fragmented packet");

src/iface/interface/tests.rs

@@ -168,12 +168,9 @@ fn test_no_icmp_no_unicast_ipv4() {
     // broadcast address
 
     assert_eq!(
-        iface.inner.process_ipv4(
-            &mut sockets,
-            &frame,
-            #[cfg(feature = "proto-ipv4-fragmentation")]
-            &mut iface.fragments.assembler
-        ),
+        iface
+            .inner
+            .process_ipv4(&mut sockets, &frame, &mut iface.fragments),
         None
     );
 }
@@ -254,12 +251,9 @@ fn test_icmp_error_no_payload() {
     // And we correctly handle no payload.
 
     assert_eq!(
-        iface.inner.process_ipv4(
-            &mut sockets,
-            &frame,
-            #[cfg(feature = "proto-ipv4-fragmentation")]
-            &mut iface.fragments.assembler
-        ),
+        iface
+            .inner
+            .process_ipv4(&mut sockets, &frame, &mut iface.fragments),
         Some(expected_repr)
     );
 }
@@ -564,12 +558,9 @@ fn test_handle_ipv4_broadcast() {
     let expected_packet = IpPacket::Icmpv4((expected_ipv4_repr, expected_icmpv4_repr));
 
     assert_eq!(
-        iface.inner.process_ipv4(
-            &mut sockets,
-            &frame,
-            #[cfg(feature = "proto-ipv4-fragmentation")]
-            &mut iface.fragments.assembler
-        ),
+        iface
+            .inner
+            .process_ipv4(&mut sockets, &frame, &mut iface.fragments),
         Some(expected_packet)
     );
 }
@@ -1268,12 +1259,9 @@ fn test_raw_socket_no_reply() {
     };
 
     assert_eq!(
-        iface.inner.process_ipv4(
-            &mut sockets,
-            &frame,
-            #[cfg(feature = "proto-ipv4-fragmentation")]
-            &mut iface.fragments.assembler
-        ),
+        iface
+            .inner
+            .process_ipv4(&mut sockets, &frame, &mut iface.fragments),
         None
     );
 }
@@ -1357,12 +1345,9 @@ fn test_raw_socket_with_udp_socket() {
     };
 
     assert_eq!(
-        iface.inner.process_ipv4(
-            &mut sockets,
-            &frame,
-            #[cfg(feature = "proto-ipv4-fragmentation")]
-            &mut iface.fragments.assembler
-        ),
+        iface
+            .inner
+            .process_ipv4(&mut sockets, &frame, &mut iface.fragments),
         None
     );