chore(ipv6): all logic into ipv6.rs

Signed-off-by: Thibaut Vandervelden <thvdveld@vub.be>

src/iface/interface/ipv6.rs

@@ -1,12 +1,5 @@
 use super::*;
 
-#[cfg(feature = "socket-icmp")]
-use crate::socket::icmp;
-use crate::socket::AnySocket;
-
-use crate::phy::PacketMeta;
-use crate::wire::*;
-
 /// Enum used for the process_hopbyhop function. In some cases, when discarding a packet, an ICMMP
 /// parameter problem message needs to be transmitted to the source of the address. In other cases,
 /// the processing of the IP packet can continue.
@@ -26,6 +19,133 @@ impl Default for HopByHopResponse<'_> {
 }
 
 impl InterfaceInner {
+    /// Return the IPv6 address that is a candidate source address for the given destination
+    /// address, based on RFC 6724.
+    #[allow(unused)]
+    pub(crate) fn get_source_address_ipv6(&self, dst_addr: &Ipv6Address) -> Option<Ipv6Address> {
+        // See RFC 6724 Section 4: Candidate source address
+        fn is_candidate_source_address(dst_addr: &Ipv6Address, src_addr: &Ipv6Address) -> bool {
+            // For all multicast and link-local destination addresses, the candidate address MUST
+            // only be an address from the same link.
+            if dst_addr.is_link_local() && !src_addr.is_link_local() {
+                return false;
+            }
+
+            if dst_addr.is_multicast()
+                && matches!(dst_addr.scope(), Ipv6AddressScope::LinkLocal)
+                && src_addr.is_multicast()
+                && !matches!(src_addr.scope(), Ipv6AddressScope::LinkLocal)
+            {
+                return false;
+            }
+
+            // Loopback addresses and multicast address can not be in the candidate source address
+            // list. Except when the destination multicast address has a link-local scope, then the
+            // source address can also be link-local multicast.
+            if src_addr.is_loopback() || src_addr.is_multicast() {
+                return false;
+            }
+
+            true
+        }
+
+        // See RFC 6724 Section 2.2: Common Prefix Length
+        fn common_prefix_length(dst_addr: &Ipv6Cidr, src_addr: &Ipv6Address) -> usize {
+            let addr = dst_addr.address();
+            let mut bits = 0;
+            for (l, r) in addr.as_bytes().iter().zip(src_addr.as_bytes().iter()) {
+                if l == r {
+                    bits += 8;
+                } else {
+                    bits += (l ^ r).leading_zeros();
+                    break;
+                }
+            }
+
+            bits = bits.min(dst_addr.prefix_len() as u32);
+
+            bits as usize
+        }
+
+        // Get the first address that is a candidate address.
+        let mut candidate = self
+            .ip_addrs
+            .iter()
+            .filter_map(|a| match a {
+                #[cfg(feature = "proto-ipv4")]
+                IpCidr::Ipv4(_) => None,
+                #[cfg(feature = "proto-ipv6")]
+                IpCidr::Ipv6(a) => Some(a),
+            })
+            .find(|a| is_candidate_source_address(dst_addr, &a.address()))
+            .unwrap();
+
+        for addr in self.ip_addrs.iter().filter_map(|a| match a {
+            #[cfg(feature = "proto-ipv4")]
+            IpCidr::Ipv4(_) => None,
+            #[cfg(feature = "proto-ipv6")]
+            IpCidr::Ipv6(a) => Some(a),
+        }) {
+            if !is_candidate_source_address(dst_addr, &addr.address()) {
+                continue;
+            }
+
+            // Rule 1: prefer the address that is the same as the output destination address.
+            if candidate.address() != *dst_addr && addr.address() == *dst_addr {
+                candidate = addr;
+            }
+
+            // Rule 2: prefer appropriate scope.
+            if (candidate.address().scope() as u8) < (addr.address().scope() as u8) {
+                if (candidate.address().scope() as u8) < (dst_addr.scope() as u8) {
+                    candidate = addr;
+                }
+            } else if (addr.address().scope() as u8) > (dst_addr.scope() as u8) {
+                candidate = addr;
+            }
+
+            // Rule 3: avoid deprecated addresses (TODO)
+            // Rule 4: prefer home addresses (TODO)
+            // Rule 5: prefer outgoing interfaces (TODO)
+            // Rule 5.5: prefer addresses in a prefix advertises by the next-hop (TODO).
+            // Rule 6: prefer matching label (TODO)
+            // Rule 7: prefer temporary addresses (TODO)
+            // Rule 8: use longest matching prefix
+            if common_prefix_length(candidate, dst_addr) < common_prefix_length(addr, dst_addr) {
+                candidate = addr;
+            }
+        }
+
+        Some(candidate.address())
+    }
+
+    /// Determine if the given `Ipv6Address` is the solicited node
+    /// multicast address for a IPv6 addresses assigned to the interface.
+    /// See [RFC 4291 § 2.7.1] for more details.
+    ///
+    /// [RFC 4291 § 2.7.1]: https://tools.ietf.org/html/rfc4291#section-2.7.1
+    pub fn has_solicited_node(&self, addr: Ipv6Address) -> bool {
+        self.ip_addrs.iter().any(|cidr| {
+            match *cidr {
+                IpCidr::Ipv6(cidr) if cidr.address() != Ipv6Address::LOOPBACK => {
+                    // Take the lower order 24 bits of the IPv6 address and
+                    // append those bits to FF02:0:0:0:0:1:FF00::/104.
+                    addr.as_bytes()[14..] == cidr.address().as_bytes()[14..]
+                }
+                _ => false,
+            }
+        })
+    }
+
+    /// Get the first IPv6 address if present.
+    pub fn ipv6_addr(&self) -> Option<Ipv6Address> {
+        self.ip_addrs.iter().find_map(|addr| match *addr {
+            IpCidr::Ipv6(cidr) => Some(cidr.address()),
+            #[allow(unreachable_patterns)]
+            _ => None,
+        })
+    }
+
     pub(super) fn process_ipv6<'frame>(
         &mut self,
         sockets: &mut SocketSet,
@@ -191,13 +311,16 @@ impl InterfaceInner {
         let mut handled_by_icmp_socket = false;
 
         #[cfg(feature = "socket-icmp")]
-        for icmp_socket in _sockets
-            .items_mut()
-            .filter_map(|i| icmp::Socket::downcast_mut(&mut i.socket))
         {
-            if icmp_socket.accepts(self, &ip_repr, &icmp_repr.into()) {
-                icmp_socket.process(self, &ip_repr, &icmp_repr.into());
-                handled_by_icmp_socket = true;
+            use crate::socket::icmp::Socket as IcmpSocket;
+            for icmp_socket in _sockets
+                .items_mut()
+                .filter_map(|i| IcmpSocket::downcast_mut(&mut i.socket))
+            {
+                if icmp_socket.accepts(self, &ip_repr, &icmp_repr.into()) {
+                    icmp_socket.process(self, &ip_repr, &icmp_repr.into());
+                    handled_by_icmp_socket = true;
+                }
             }
         }
 

src/iface/interface/mod.rs

@@ -732,108 +732,6 @@ impl InterfaceInner {
         }
     }
 
-    #[cfg(feature = "proto-ipv6")]
-    #[allow(unused)]
-    pub(crate) fn get_source_address_ipv6(&self, dst_addr: &Ipv6Address) -> Option<Ipv6Address> {
-        // RFC 6724 describes how to select the correct source address depending on the destination
-        // address.
-
-        // See RFC 6724 Section 4: Candidate source address
-        fn is_candidate_source_address(dst_addr: &Ipv6Address, src_addr: &Ipv6Address) -> bool {
-            // For all multicast and link-local destination addresses, the candidate address MUST
-            // only be an address from the same link.
-            if dst_addr.is_link_local() && !src_addr.is_link_local() {
-                return false;
-            }
-
-            if dst_addr.is_multicast()
-                && matches!(dst_addr.scope(), Ipv6AddressScope::LinkLocal)
-                && src_addr.is_multicast()
-                && !matches!(src_addr.scope(), Ipv6AddressScope::LinkLocal)
-            {
-                return false;
-            }
-
-            // Loopback addresses and multicast address can not be in the candidate source address
-            // list. Except when the destination multicast address has a link-local scope, then the
-            // source address can also be link-local multicast.
-            if src_addr.is_loopback() || src_addr.is_multicast() {
-                return false;
-            }
-
-            true
-        }
-
-        // See RFC 6724 Section 2.2: Common Prefix Length
-        fn common_prefix_length(dst_addr: &Ipv6Cidr, src_addr: &Ipv6Address) -> usize {
-            let addr = dst_addr.address();
-            let mut bits = 0;
-            for (l, r) in addr.as_bytes().iter().zip(src_addr.as_bytes().iter()) {
-                if l == r {
-                    bits += 8;
-                } else {
-                    bits += (l ^ r).leading_zeros();
-                    break;
-                }
-            }
-
-            bits = bits.min(dst_addr.prefix_len() as u32);
-
-            bits as usize
-        }
-
-        // Get the first address that is a candidate address.
-        let mut candidate = self
-            .ip_addrs
-            .iter()
-            .filter_map(|a| match a {
-                #[cfg(feature = "proto-ipv4")]
-                IpCidr::Ipv4(_) => None,
-                #[cfg(feature = "proto-ipv6")]
-                IpCidr::Ipv6(a) => Some(a),
-            })
-            .find(|a| is_candidate_source_address(dst_addr, &a.address()))
-            .unwrap();
-
-        for addr in self.ip_addrs.iter().filter_map(|a| match a {
-            #[cfg(feature = "proto-ipv4")]
-            IpCidr::Ipv4(_) => None,
-            #[cfg(feature = "proto-ipv6")]
-            IpCidr::Ipv6(a) => Some(a),
-        }) {
-            if !is_candidate_source_address(dst_addr, &addr.address()) {
-                continue;
-            }
-
-            // Rule 1: prefer the address that is the same as the output destination address.
-            if candidate.address() != *dst_addr && addr.address() == *dst_addr {
-                candidate = addr;
-            }
-
-            // Rule 2: prefer appropriate scope.
-            if (candidate.address().scope() as u8) < (addr.address().scope() as u8) {
-                if (candidate.address().scope() as u8) < (dst_addr.scope() as u8) {
-                    candidate = addr;
-                }
-            } else if (addr.address().scope() as u8) > (dst_addr.scope() as u8) {
-                candidate = addr;
-            }
-
-            // Rule 3: avoid deprecated addresses (TODO)
-            // Rule 4: prefer home addresses (TODO)
-            // Rule 5: prefer outgoing interfaces (TODO)
-            // Rule 5.5: prefer addresses in a prefix advertises by the next-hop (TODO).
-            // Rule 6: prefer matching label (TODO)
-            // Rule 7: prefer temporary addresses (TODO)
-            // Rule 8: use longest matching prefix
-            if common_prefix_length(candidate, dst_addr) < common_prefix_length(addr, dst_addr) {
-                candidate = addr;
-            }
-        }
-
-        Some(candidate.address())
-    }
-
     #[cfg(test)]
     #[allow(unused)] // unused depending on which sockets are enabled
     pub(crate) fn set_now(&mut self, now: Instant) {
@@ -855,41 +753,12 @@ impl InterfaceInner {
         }
     }
 
-    /// Determine if the given `Ipv6Address` is the solicited node
-    /// multicast address for a IPv6 addresses assigned to the interface.
-    /// See [RFC 4291 § 2.7.1] for more details.
-    ///
-    /// [RFC 4291 § 2.7.1]: https://tools.ietf.org/html/rfc4291#section-2.7.1
-    #[cfg(feature = "proto-ipv6")]
-    pub fn has_solicited_node(&self, addr: Ipv6Address) -> bool {
-        self.ip_addrs.iter().any(|cidr| {
-            match *cidr {
-                IpCidr::Ipv6(cidr) if cidr.address() != Ipv6Address::LOOPBACK => {
-                    // Take the lower order 24 bits of the IPv6 address and
-                    // append those bits to FF02:0:0:0:0:1:FF00::/104.
-                    addr.as_bytes()[14..] == cidr.address().as_bytes()[14..]
-                }
-                _ => false,
-            }
-        })
-    }
-
     /// Check whether the interface has the given IP address assigned.
     fn has_ip_addr<T: Into<IpAddress>>(&self, addr: T) -> bool {
         let addr = addr.into();
         self.ip_addrs.iter().any(|probe| probe.address() == addr)
     }
 
-    /// Get the first IPv6 address if present.
-    #[cfg(feature = "proto-ipv6")]
-    pub fn ipv6_addr(&self) -> Option<Ipv6Address> {
-        self.ip_addrs.iter().find_map(|addr| match *addr {
-            IpCidr::Ipv6(cidr) => Some(cidr.address()),
-            #[allow(unreachable_patterns)]
-            _ => None,
-        })
-    }
-
     /// Check whether the interface listens to given destination multicast IP address.
     ///
     /// If built without feature `proto-igmp` this function will