interface: Hook up SLAAC to interface

Author: bergzand

README.md

@@ -103,8 +103,8 @@ The ICMPv6 protocol is supported, and ICMP sockets are available.
 #### NDISC
 
   * Neighbor Advertisement messages are generated in response to Neighbor Solicitations.
-  * Router Advertisement messages are **not** generated or read.
-  * Router Solicitation messages are **not** generated or read.
+  * Router Advertisement messages are read, but **not** generated.
+  * Router Solicitation messages are generated, but **not** read.
   * Redirected Header messages are **not** generated or read.
 
 ### UDP layer

src/iface/interface/ipv6.rs

@@ -1,5 +1,7 @@
 use super::*;
 
+use crate::iface::Route;
+
 /// Enum used for the process_hopbyhop function. In some cases, when discarding a packet, an ICMP
 /// parameter problem message needs to be transmitted to the source of the address. In other cases,
 /// the processing of the IP packet can continue.
@@ -502,6 +504,30 @@ impl InterfaceInner {
                     None
                 }
             }
+            NdiscRepr::RouterAdvert {
+                hop_limit: _,
+                flags: _,
+                router_lifetime,
+                reachable_time: _,
+                retrans_time: _,
+                lladdr: _,
+                mtu: _,
+                prefix_info,
+            } if self.slaac_enabled => {
+                if ip_repr.src_addr.is_link_local()
+                    && (ip_repr.dst_addr == IPV6_LINK_LOCAL_ALL_NODES
+                        || ip_repr.dst_addr.is_link_local())
+                    && ip_repr.hop_limit == 255
+                {
+                    self.slaac.process_advertisement(
+                        &ip_repr.src_addr,
+                        router_lifetime,
+                        prefix_info,
+                        self.now,
+                    )
+                }
+                None
+            }
             _ => None,
         }
     }
@@ -581,3 +607,132 @@ impl InterfaceInner {
         ))
     }
 }
+
+impl Interface {
+    /// Synchronize the slaac address and router state with the interface state.
+    #[cfg(all(
+        feature = "proto-ipv6",
+        any(feature = "medium-ethernet", feature = "medium-ieee802154")
+    ))]
+    pub(super) fn sync_slaac_state(&mut self, timestamp: Instant) {
+        let required_addresses: Vec<_, IFACE_MAX_PREFIX_COUNT> = self
+            .inner
+            .slaac
+            .prefix()
+            .iter()
+            .filter_map(|(prefix, prefixinfo)| {
+                if prefixinfo.is_valid(timestamp) {
+                    Ipv6Cidr::from_link_prefix(prefix, self.inner.hardware_addr())
+                } else {
+                    None
+                }
+            })
+            .collect();
+        let removed_addresses: Vec<_, IFACE_MAX_PREFIX_COUNT> = self
+            .inner
+            .slaac
+            .prefix()
+            .iter()
+            .filter_map(|(prefix, prefixinfo)| {
+                if !prefixinfo.is_valid(timestamp) {
+                    Ipv6Cidr::from_link_prefix(prefix, self.inner.hardware_addr())
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        self.update_ip_addrs(|addresses| {
+            for address in required_addresses {
+                if !addresses.contains(&IpCidr::Ipv6(address)) {
+                    let _ = addresses.push(IpCidr::Ipv6(address));
+                }
+            }
+            addresses.retain(|address| {
+                if let IpCidr::Ipv6(address) = address {
+                    !removed_addresses.contains(address)
+                } else {
+                    true
+                }
+            });
+        });
+
+        {
+            let required_routes = self
+                .inner
+                .slaac
+                .routes()
+                .into_iter()
+                .filter(|required| required.is_valid(timestamp));
+
+            let removed_routes = self
+                .inner
+                .slaac
+                .routes()
+                .into_iter()
+                .filter(|r| !r.is_valid(timestamp));
+
+            self.inner.routes.update(|routes| {
+                routes.retain(|r| match (&r.cidr, &r.via_router) {
+                    (IpCidr::Ipv6(cidr), IpAddress::Ipv6(via_router)) => !removed_routes
+                        .clone()
+                        .any(|f| f.same_route(cidr, via_router)),
+                    _ => true,
+                });
+
+                for route in required_routes {
+                    if routes.iter().all(|r| match (&r.cidr, &r.via_router) {
+                        (IpCidr::Ipv6(cidr), IpAddress::Ipv6(via_router)) => {
+                            !route.same_route(cidr, via_router)
+                        }
+                        _ => false,
+                    }) {
+                        let _ = routes.push(Route {
+                            cidr: route.cidr.into(),
+                            via_router: route.via_router.into(),
+                            preferred_until: None,
+                            expires_at: None,
+                        });
+                    }
+                }
+            });
+        }
+
+        self.inner.slaac.update_slaac_state(timestamp);
+    }
+
+    /// Emit a router solicitation when required by the interface's slaac state machine.
+    #[cfg(all(
+        feature = "proto-ipv6",
+        any(feature = "medium-ethernet", feature = "medium-ieee802154")
+    ))]
+    pub(super) fn ndisc_rs_egress(&mut self, device: &mut (impl Device + ?Sized)) {
+        if !self.inner.slaac.rs_required(self.inner.now) {
+            return;
+        }
+        let rs_repr = Icmpv6Repr::Ndisc(NdiscRepr::RouterSolicit {
+            lladdr: Some(self.hardware_addr().into()),
+        });
+        let ipv6_repr = Ipv6Repr {
+            src_addr: self.inner.link_local_ipv6_address().unwrap(),
+            dst_addr: IPV6_LINK_LOCAL_ALL_ROUTERS,
+            next_header: IpProtocol::Icmpv6,
+            payload_len: rs_repr.buffer_len(),
+            hop_limit: 255,
+        };
+        let packet = Packet::new_ipv6(ipv6_repr, IpPayload::Icmpv6(rs_repr));
+        let Some(tx_token) = device.transmit(self.inner.now) else {
+            return;
+        };
+        // NOTE(unwrap): packet destination is multicast, which is always routable and doesn't require neighbor discovery.
+        self.inner
+            .dispatch_ip(
+                tx_token,
+                PacketMeta::default(),
+                packet,
+                &mut self.fragmenter,
+            )
+            .unwrap();
+        self.inner.slaac.rs_sent(self.inner.now);
+    }
+}

src/iface/interface/mod.rs

@@ -38,8 +38,15 @@ use super::fragmentation::{Fragmenter, FragmentsBuffer};
 #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
 use super::neighbor::{Answer as NeighborAnswer, Cache as NeighborCache};
 use super::socket_set::SocketSet;
-use crate::config::{IFACE_MAX_ADDR_COUNT, IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT};
+use crate::config::{
+    IFACE_MAX_ADDR_COUNT, IFACE_MAX_PREFIX_COUNT, IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT,
+};
 use crate::iface::Routes;
+#[cfg(all(
+    feature = "proto-ipv6",
+    any(feature = "medium-ethernet", feature = "medium-ieee802154")
+))]
+use crate::iface::Slaac;
 use crate::phy::PacketMeta;
 use crate::phy::{ChecksumCapabilities, Device, DeviceCapabilities, Medium, RxToken, TxToken};
 use crate::rand::Rand;
@@ -142,6 +149,16 @@ pub struct InterfaceInner {
     tag: u16,
     ip_addrs: Vec<IpCidr, IFACE_MAX_ADDR_COUNT>,
     any_ip: bool,
+    #[cfg(all(
+        feature = "proto-ipv6",
+        any(feature = "medium-ethernet", feature = "medium-ieee802154")
+    ))]
+    slaac_enabled: bool,
+    #[cfg(all(
+        feature = "proto-ipv6",
+        any(feature = "medium-ethernet", feature = "medium-ieee802154")
+    ))]
+    slaac: Slaac,
     routes: Routes,
     #[cfg(feature = "multicast")]
     multicast: multicast::State,
@@ -169,6 +186,10 @@ pub struct Config {
     /// **NOTE**: we use the same PAN ID for destination and source.
     #[cfg(feature = "medium-ieee802154")]
     pub pan_id: Option<Ieee802154Pan>,
+
+    /// Enable stateless address autoconfiguration on the interface.
+    #[cfg(feature = "proto-ipv6")]
+    pub slaac: bool,
 }
 
 impl Config {
@@ -178,6 +199,8 @@ impl Config {
             hardware_addr,
             #[cfg(feature = "medium-ieee802154")]
             pan_id: None,
+            #[cfg(feature = "proto-ipv6")]
+            slaac: false,
         }
     }
 }
@@ -262,6 +285,16 @@ impl Interface {
                 ipv4_id,
                 #[cfg(feature = "proto-sixlowpan")]
                 sixlowpan_address_context: Vec::new(),
+                #[cfg(all(
+                    feature = "proto-ipv6",
+                    any(feature = "medium-ethernet", feature = "medium-ieee802154")
+                ))]
+                slaac_enabled: config.slaac,
+                #[cfg(all(
+                    feature = "proto-ipv6",
+                    any(feature = "medium-ethernet", feature = "medium-ieee802154")
+                ))]
+                slaac: Slaac::new(),
                 rand,
             },
         }
@@ -491,6 +524,14 @@ impl Interface {
             }
         }
 
+        #[cfg(all(
+            feature = "proto-ipv6",
+            any(feature = "medium-ethernet", feature = "medium-ieee802154")
+        ))]
+        if self.inner.slaac_enabled {
+            self.ndisc_rs_egress(device);
+        }
+
         #[cfg(feature = "multicast")]
         self.multicast_egress(device);
 
@@ -526,6 +567,14 @@ impl Interface {
 
         #[cfg(feature = "_proto-fragmentation")]
         self.fragments.assembler.remove_expired(timestamp);
+
+        #[cfg(all(
+            feature = "proto-ipv6",
+            any(feature = "medium-ethernet", feature = "medium-ieee802154")
+        ))]
+        if self.inner.slaac.sync_required(timestamp) {
+            self.sync_slaac_state(timestamp)
+        }
     }
 
     /// Return a _soft deadline_ for calling [poll] the next time.
@@ -546,6 +595,15 @@ impl Interface {
 
         let inner = &mut self.inner;
 
+        let other_polls = [
+            #[cfg(all(
+                feature = "proto-ipv6",
+                any(feature = "medium-ethernet", feature = "medium-ieee802154")
+            ))]
+            inner.slaac.poll_at(timestamp),
+            None,
+        ];
+
         sockets
             .items()
             .filter_map(move |item| {
@@ -559,6 +617,7 @@ impl Interface {
                     PollAt::Now => Some(Instant::from_millis(0)),
                 }
             })
+            .chain(other_polls.into_iter().flatten())
             .min()
     }