rebase onto main

Author: aaronddavies

benches/bench.rs

@@ -2,7 +2,7 @@
 
 mod wire {
     use smoltcp::phy::ChecksumCapabilities;
-    use smoltcp::wire::{IpAddress, IpProtocol};
+    use smoltcp::wire::{IPV4_HEADER_LEN, IPV4_MAX_OPTIONS_SIZE, IpAddress, IpProtocol};
     #[cfg(feature = "proto-ipv4")]
     use smoltcp::wire::{Ipv4Address, Ipv4Packet, Ipv4Repr};
     #[cfg(feature = "proto-ipv6")]
@@ -83,8 +83,16 @@ mod wire {
             src_addr: Ipv4Address::new(192, 168, 1, 1),
             dst_addr: Ipv4Address::new(192, 168, 1, 2),
             next_header: IpProtocol::Tcp,
+            header_len: IPV4_HEADER_LEN,
             payload_len: 100,
+            dscp: 0,
+            ecn: 0,
+            ident: 0,
+            dont_frag: true,
+            more_frags: false,
+            frag_offset: 0,
             hop_limit: 64,
+            options: [0u8; IPV4_MAX_OPTIONS_SIZE],
         };
         let mut bytes = vec![0xa5; repr.buffer_len()];
 

src/iface/fragmentation.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::wire::ipv4::MAX_OPTIONS_SIZE;
 
 impl Interface {
     /// Process fragments that still need to be sent for IPv4 packets.
@@ -107,6 +108,14 @@ impl InterfaceInner {
             return None;
         }
 
+        // If this is the first fragment, capture the options.
+        #[cfg(feature = "proto-ipv4-fragmentation")]
+        if ipv4_packet.frag_offset() == 0 && ipv4_packet.has_options() {
+            frag.options_buffer[..ipv4_repr.options_len()]
+                .copy_from_slice(&ipv4_repr.options[..ipv4_repr.options_len()]);
+            frag.options_len = ipv4_repr.options_len()
+        }
+
         #[cfg(feature = "proto-ipv4-fragmentation")]
         let ip_payload = {
             if ipv4_packet.more_frags() || ipv4_packet.frag_offset() != 0 {
@@ -133,7 +142,9 @@ impl InterfaceInner {
                     return None;
                 }
 
+                // Returns early if assembly is incomplete.
                 let payload = f.assemble()?;
+
                 // Update the payload length, so that the raw sockets get the correct value.
                 ipv4_repr.payload_len = payload.len();
                 payload
@@ -145,6 +156,16 @@ impl InterfaceInner {
         #[cfg(not(feature = "proto-ipv4-fragmentation"))]
         let ip_payload = ipv4_packet.payload();
 
+        #[cfg(feature = "proto-ipv4-fragmentation")]
+        // The first fragment will by definition have all options. The length of the options it
+        // contains will be greater than or equal to size of the options in the other fragments.
+        // Therefore, this is guaranteed to overwrite whatever was captured when the repr object
+        // parsed the current packet.
+        if let Err(e) = ipv4_repr.set_options(&frag.options_buffer[..frag.options_len]) {
+            net_debug!("fragmentation assembler options error: {:?}", e);
+            return None;
+        }
+
         let ip_repr = IpRepr::Ipv4(ipv4_repr);
 
         #[cfg(feature = "socket-raw")]
@@ -384,8 +405,16 @@ impl InterfaceInner {
                 src_addr: ipv4_repr.dst_addr,
                 dst_addr: ipv4_repr.src_addr,
                 next_header: IpProtocol::Icmp,
+                header_len: IPV4_HEADER_LEN,
                 payload_len: icmp_repr.buffer_len(),
+                dscp: 0,
+                ecn: 0,
+                ident: 0,
+                dont_frag: true,
+                more_frags: false,
+                frag_offset: 0,
                 hop_limit: 64,
+                options: [0u8; MAX_OPTIONS_SIZE],
             };
             Some(Packet::new_ipv4(
                 ipv4_reply_repr,
@@ -400,8 +429,16 @@ impl InterfaceInner {
                             src_addr,
                             dst_addr: ipv4_repr.src_addr,
                             next_header: IpProtocol::Icmp,
+                            header_len: IPV4_HEADER_LEN,
                             payload_len: icmp_repr.buffer_len(),
+                            dscp: 0,
+                            ecn: 0,
+                            ident: 0,
+                            dont_frag: true,
+                            more_frags: false,
+                            frag_offset: 0,
                             hop_limit: 64,
+                            options: [0u8; MAX_OPTIONS_SIZE],
                         };
                         Some(Packet::new_ipv4(
                             ipv4_reply_repr,

src/iface/interface/ipv4.rs

@@ -67,6 +67,8 @@ macro_rules! check {
         }
     };
 }
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::ipv4::MAX_OPTIONS_SIZE;
 use check;
 
 /// Result returned by [`Interface::poll`].
@@ -253,6 +255,12 @@ impl Interface {
                 assembler: PacketAssemblerSet::new(),
                 #[cfg(feature = "_proto-fragmentation")]
                 reassembly_timeout: Duration::from_secs(60),
+
+                #[cfg(feature = "proto-ipv4-fragmentation")]
+                options_buffer: [0u8; MAX_OPTIONS_SIZE],
+
+                #[cfg(feature = "proto-ipv4-fragmentation")]
+                options_len: 0,
             },
             fragmenter: Fragmenter::new(),
             inner: InterfaceInner {
@@ -1314,6 +1322,14 @@ impl InterfaceInner {
                         // Emit the IP header to the buffer.
                         emit_ip(&ip_repr, &mut frag.buffer);
 
+                        // Verify that we can filter the options for the subsequent packets.
+                        if frag.ipv4.filter_options().is_err() {
+                            net_debug!(
+                                "Could not fragment packet because options cannot be filtered. Dropping."
+                            );
+                            return Ok(());
+                        };
+
                         let mut ipv4_packet = Ipv4Packet::new_unchecked(&mut frag.buffer[..]);
                         frag.ipv4.ident = ipv4_id;
                         ipv4_packet.set_ident(ipv4_id);
@@ -1394,12 +1410,14 @@ impl InterfaceInner {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-enum DispatchError {
+pub enum DispatchError {
     /// No route to dispatch this packet. Retrying won't help unless
     /// configuration is changed.
     NoRoute,
     /// We do have a route to dispatch this packet, but we haven't discovered
     /// the neighbor for it yet. Discovery has been initiated, dispatch
     /// should be retried later.
     NeighborPending,
+    /// The packet must be fragmented but there was a parse error.
+    CannotFragment,
 }

src/iface/interface/mod.rs

@@ -6,6 +6,8 @@ use super::{Interface, InterfaceInner};
 use super::{IpPayload, Packet, check};
 use crate::config::{IFACE_MAX_ADDR_COUNT, IFACE_MAX_MULTICAST_GROUP_COUNT};
 use crate::phy::{Device, PacketMeta};
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::ipv4::MAX_OPTIONS_SIZE;
 use crate::wire::*;
 
 /// Error type for `join_multicast_group`, `leave_multicast_group`.
@@ -480,7 +482,15 @@ impl InterfaceInner {
                 dst_addr: group_addr,
                 next_header: IpProtocol::Igmp,
                 payload_len: igmp_repr.buffer_len(),
+                header_len: IPV4_HEADER_LEN,
+                dscp: 0,
+                ecn: 0,
+                ident: 0,
+                dont_frag: false,
+                more_frags: false,
+                frag_offset: 0,
                 hop_limit: 1,
+                options: [0u8; MAX_OPTIONS_SIZE],
                 // [#183](https://github.com/m-labs/smoltcp/issues/183).
             },
             IpPayload::Igmp(igmp_repr),
@@ -498,7 +508,15 @@ impl InterfaceInner {
                     dst_addr: IPV4_MULTICAST_ALL_ROUTERS,
                     next_header: IpProtocol::Igmp,
                     payload_len: igmp_repr.buffer_len(),
+                    header_len: IPV4_HEADER_LEN,
+                    dscp: 0,
+                    ecn: 0,
+                    ident: 0,
+                    dont_frag: false,
+                    more_frags: false,
+                    frag_offset: 0,
                     hop_limit: 1,
+                    options: [0u8; MAX_OPTIONS_SIZE],
                 },
                 IpPayload::Igmp(igmp_repr),
             )