Clean up routes module slightly

examples/client.rs

@@ -42,7 +42,7 @@ fn main() {
     let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
     let mut routes_storage = [None; 1];
     let mut routes = Routes::new(&mut routes_storage[..]);
-    routes.add_default_ipv4_route(default_v4_gw).unwrap();
+    routes.set_default_ipv4_route(default_v4_gw).unwrap();
     let mut iface = EthernetInterfaceBuilder::new(device)
             .ethernet_addr(ethernet_addr)
             .neighbor_cache(neighbor_cache)

examples/httpclient.rs

@@ -49,7 +49,7 @@ fn main() {
     let default_v6_gw = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100);
     let mut routes_storage = [None; 2];
     let mut routes = Routes::new(&mut routes_storage[..]);
-    routes.add_default_ipv4_route(default_v4_gw).unwrap();
+    routes.set_default_ipv4_route(default_v4_gw).unwrap();
     routes.add_default_ipv6_route(default_v6_gw).unwrap();
     let mut iface = EthernetInterfaceBuilder::new(device)
             .ethernet_addr(ethernet_addr)

examples/ping.rs

@@ -101,7 +101,7 @@ fn main() {
     let default_v6_gw = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100);
     let mut routes_storage = [None; 2];
     let mut routes = Routes::new(&mut routes_storage[..]);
-    routes.add_default_ipv4_route(default_v4_gw).unwrap();
+    routes.set_default_ipv4_route(default_v4_gw).unwrap();
     routes.add_default_ipv6_route(default_v6_gw).unwrap();
     let mut iface = EthernetInterfaceBuilder::new(device)
             .ethernet_addr(ethernet_addr)

src/iface/ethernet.rs

@@ -267,13 +267,16 @@ impl<'b, 'c, 'e, DeviceT> Interface<'b, 'c, 'e, DeviceT>
         self.inner.ip_addrs.as_ref()
     }
 
-    /// Update the IP addresses of the interface.
+    /// Replace the set of IP addresses.
     ///
     /// # Panics
     /// This function panics if any of the addresses are not unicast.
-    pub fn update_ip_addrs<F: FnOnce(&mut ManagedSlice<'c, IpCidr>)>(&mut self, f: F) {
-        f(&mut self.inner.ip_addrs);
-        InterfaceInner::check_ip_addrs(&self.inner.ip_addrs)
+    pub fn set_ip_addrs<S>(&mut self, ips: S)
+        where S: Into<ManagedSlice<'c, IpCidr>>
+    {
+        let ips = ips.into();
+        InterfaceInner::check_ip_addrs(&ips);
+        self.inner.ip_addrs = ips;
     }
 
     /// Check whether the interface has the given IP address assigned.
@@ -1898,10 +1901,9 @@ mod test {
         let (mut iface, _) = create_loopback();
         let mut new_addrs = vec![IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 1, 2, 0, 2), 64),
                                  IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 3, 4, 0, 0xffff), 64)];
-        iface.update_ip_addrs(|addrs| {
-            new_addrs.extend(addrs.to_vec());
-            *addrs = From::from(new_addrs);
-        });
+        new_addrs.extend(iface.ip_addrs());
+        iface.set_ip_addrs(new_addrs);
+
         assert!(iface.inner.has_solicited_node(Ipv6Address::new(0xff02, 0, 0, 0, 0, 1, 0xff00, 0x0002)));
         assert!(iface.inner.has_solicited_node(Ipv6Address::new(0xff02, 0, 0, 0, 0, 1, 0xff00, 0xffff)));
         assert!(!iface.inner.has_solicited_node(Ipv6Address::new(0xff02, 0, 0, 0, 0, 1, 0xff00, 0x0003)));

src/iface/route.rs

@@ -74,16 +74,36 @@ impl<'a> Routes<'a> {
         Routes { storage }
     }
 
-    /// Update the routes of this node.
-    pub fn update<F: FnOnce(&mut ManagedMap<'a, IpCidr, Route>)>(&mut self, f: F) {
-        f(&mut self.storage);
+    /// Add a new route.
+    ///
+    /// On success, return the previous route, if any.
+    pub fn add_route(&mut self, cidr: IpCidr, route: Route) -> Result<Option<Route>> {
+        // TODO: Validate
+        match self.storage.insert(cidr, route) {
+            Ok(route) => Ok(route),
+            Err((_cidr, _route)) => Err(Error::Exhausted)
+        }
+    }
+    /// Returns a route registered on cidr
+    pub fn get_route(&mut self, cidr: &IpCidr) -> Option<&Route> {
+        self.storage.get(cidr)
+    }
+    /// Returns a mutable reference to the route registered by cidr
+    pub fn get_route_mut(&mut self, cidr: &IpCidr) -> Option<&mut Route> {
+        self.storage.get_mut(cidr)
+    }
+    /// Delete a route.
+    ///
+    /// On success, returns the value it deleted, if any.
+    pub fn del_route(&mut self, cidr: &IpCidr) -> Option<Route> {
+        self.storage.remove(&cidr)
     }
 
-    /// Add a default ipv4 gateway (ie. "ip route add 0.0.0.0/0 via `gateway`").
+    /// Set the default ipv4 gateway (ie. "ip route add 0.0.0.0/0 via `gateway`").
     ///
     /// On success, returns the previous default route, if any.
     #[cfg(feature = "proto-ipv4")]
-    pub fn add_default_ipv4_route(&mut self, gateway: Ipv4Address) -> Result<Option<Route>> {
+    pub fn set_default_ipv4_route(&mut self, gateway: Ipv4Address) -> Result<Option<Route>> {
         let cidr = IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0);
         let route = Route::new_ipv4_gateway(gateway);
         match self.storage.insert(cidr, route) {
@@ -92,6 +112,22 @@ impl<'a> Routes<'a> {
         }
     }
 
+    /// Get the current default ipv4 gateway, if any
+    #[cfg(feature = "proto-ipv4")]
+    pub fn get_default_ipv4_route(&mut self) -> Option<&Route> {
+        let cidr = IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0);
+        self.storage.get(&cidr)
+    }
+
+    /// Remove default ipv4 gateway.
+    ///
+    /// Returns the removed route, if any.
+    #[cfg(feature = "proto-ipv4")]
+    pub fn remove_default_ipv4_route(&mut self) -> Option<Route> {
+        let cidr = IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0);
+        self.storage.remove(&cidr)
+    }
+
     /// Add a default ipv6 gateway (ie. "ip -6 route add ::/0 via `gateway`").
     ///
     /// On success, returns the previous default route, if any.
@@ -105,6 +141,23 @@ impl<'a> Routes<'a> {
         }
     }
 
+    /// Get the current default ipv6 gateways, if any
+    #[cfg(feature = "proto-ipv6")]
+    pub fn get_default_ipv6_routes(&mut self) -> impl Iterator<Item = &Route> {
+        let cidr = IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 0), 0);
+        // TODO: Support multiple default ipv6 gateways
+        self.storage.get(&cidr).into_iter()
+    }
+
+    /// Clear default ipv6 gateways.
+    ///
+    /// On success, returns the cleared routes, if any.
+    #[cfg(feature = "proto-ipv6")]
+    pub fn clear_default_ipv6_routes(&mut self) -> Option<Route> {
+        let cidr = IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 0), 0);
+        self.storage.remove(&cidr)
+    }
+
     pub(crate) fn lookup(&self, addr: &IpAddress, timestamp: Instant) ->
             Option<IpAddress> {
         assert!(addr.is_unicast());
@@ -195,9 +248,7 @@ mod test {
             via_router: ADDR_1A.into(),
             preferred_until: None, expires_at: None,
         };
-        routes.update(|storage| {
-            storage.insert(cidr_1().into(), route).unwrap();
-        });
+        routes.add_route(cidr_1().into(), route).unwrap();
 
         assert_eq!(routes.lookup(&ADDR_1A.into(), Instant::from_millis(0)), Some(ADDR_1A.into()));
         assert_eq!(routes.lookup(&ADDR_1B.into(), Instant::from_millis(0)), Some(ADDR_1A.into()));
@@ -210,9 +261,7 @@ mod test {
             preferred_until: Some(Instant::from_millis(10)),
             expires_at: Some(Instant::from_millis(10)),
         };
-        routes.update(|storage| {
-            storage.insert(cidr_2().into(), route2).unwrap();
-        });
+        routes.add_route(cidr_2().into(), route2).unwrap();
 
         assert_eq!(routes.lookup(&ADDR_1A.into(), Instant::from_millis(0)), Some(ADDR_1A.into()));
         assert_eq!(routes.lookup(&ADDR_1B.into(), Instant::from_millis(0)), Some(ADDR_1A.into()));