ip_addrs field of an interface is now a heapless::Vec (one test still failing)

examples/benchmark.rs

@@ -93,7 +93,8 @@ fn main() {
     let tcp2_socket = tcp::Socket::new(tcp2_rx_buffer, tcp2_tx_buffer);
 
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
-    let ip_addrs = [IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)).unwrap();
     let medium = device.capabilities().medium;
     let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs);
     if medium == Medium::Ethernet {

examples/client.rs

@@ -42,7 +42,8 @@ fn main() {
     let tcp_socket = tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer);
 
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
-    let ip_addrs = [IpCidr::new(IpAddress::v4(192, 168, 69, 2), 24)];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(IpAddress::v4(192, 168, 69, 2), 24)).unwrap();
     let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
     let mut routes_storage = [None; 1];
     let mut routes = Routes::new(&mut routes_storage[..]);

examples/dhcp_client.rs

@@ -30,7 +30,8 @@ fn main() {
 
     let neighbor_cache = NeighborCache::new(BTreeMap::new());
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
-    let ip_addrs = [IpCidr::new(Ipv4Address::UNSPECIFIED.into(), 0)];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(Ipv4Address::UNSPECIFIED.into(), 0)).unwrap();
     let mut routes_storage = [None; 1];
     let routes = Routes::new(&mut routes_storage[..]);
 

examples/dns.rs

@@ -43,11 +43,10 @@ fn main() {
 
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
     let src_ipv6 = IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1);
-    let ip_addrs = [
-        IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24),
-        IpCidr::new(src_ipv6, 64),
-        IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64),
-    ];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)).unwrap();
+    ip_addrs.push(IpCidr::new(src_ipv6, 64)).unwrap();
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
     let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
     let default_v6_gw = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100);
     let mut routes_storage = [None; 2];

examples/httpclient.rs

@@ -36,11 +36,10 @@ fn main() {
     let tcp_socket = tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer);
 
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
-    let ip_addrs = [
-        IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24),
-        IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64),
-        IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64),
-    ];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)).unwrap();
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
     let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
     let default_v6_gw = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100);
     let mut routes_storage = [None; 2];

examples/loopback.rs

@@ -85,7 +85,8 @@ fn main() {
     let mut neighbor_cache_entries = [None; 8];
     let mut neighbor_cache = NeighborCache::new(&mut neighbor_cache_entries[..]);
 
-    let mut ip_addrs = [IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)).unwrap();
     let mut iface = InterfaceBuilder::new()
         .hardware_addr(EthernetAddress::default().into())
         .neighbor_cache(neighbor_cache)

examples/multicast.rs

@@ -34,11 +34,13 @@ fn main() {
 
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
     let ip_addr = IpCidr::new(IpAddress::from(local_addr), 24);
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(ip_addr).unwrap();
     let mut ipv4_multicast_storage = [None; 1];
     let mut iface = InterfaceBuilder::new()
         .hardware_addr(ethernet_addr.into())
         .neighbor_cache(neighbor_cache)
-        .ip_addrs([ip_addr])
+        .ip_addrs(ip_addrs)
         .ipv4_multicast_groups(&mut ipv4_multicast_storage[..])
         .finalize(&mut device);
 

examples/ping.rs

@@ -116,11 +116,10 @@ fn main() {
 
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
     let src_ipv6 = IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1);
-    let ip_addrs = [
-        IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24),
-        IpCidr::new(src_ipv6, 64),
-        IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64),
-    ];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)).unwrap();
+    ip_addrs.push(IpCidr::new(src_ipv6, 64)).unwrap();
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
     let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
     let default_v6_gw = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100);
     let mut routes_storage = [None; 2];

examples/server.rs

@@ -58,11 +58,10 @@ fn main() {
     let tcp4_socket = tcp::Socket::new(tcp4_rx_buffer, tcp4_tx_buffer);
 
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
-    let ip_addrs = [
-        IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24),
-        IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64),
-        IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64),
-    ];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)).unwrap();
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
 
     let medium = device.capabilities().medium;
     let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs);

examples/sixlowpan.rs

@@ -81,10 +81,11 @@ fn main() {
     let ieee802154_addr = smoltcp::wire::Ieee802154Address::Extended([
         0x1a, 0x0b, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
     ]);
-    let ip_addrs = [IpCidr::new(
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(
         IpAddress::v6(0xfe80, 0, 0, 0, 0x180b, 0x4242, 0x4242, 0x4242),
         64,
-    )];
+    )).unwrap();
 
     let mut builder = InterfaceBuilder::new()
         .ip_addrs(ip_addrs)

examples/sixlowpan_benchmark.rs

@@ -161,10 +161,11 @@ fn main() {
     let ieee802154_addr = smoltcp::wire::Ieee802154Address::Extended([
         0x1a, 0x0b, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
     ]);
-    let ip_addrs = [IpCidr::new(
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    ip_addrs.push(IpCidr::new(
         IpAddress::v6(0xfe80, 0, 0, 0, 0x180b, 0x4242, 0x4242, 0x4242),
         64,
-    )];
+    )).unwrap();
 
     let cache = ReassemblyBuffer::new(vec![], BTreeMap::new());
 

src/iface/interface/mod.rs

@@ -16,6 +16,7 @@ mod ipv4;
 mod ipv6;
 
 use core::cmp;
+use heapless::Vec;
 use managed::{ManagedMap, ManagedSlice};
 
 #[cfg(any(feature = "proto-ipv4", feature = "proto-sixlowpan"))]
@@ -33,6 +34,8 @@ use crate::time::{Duration, Instant};
 use crate::wire::*;
 use crate::{Error, Result};
 
+const MAX_IP_ADDRS_NUM: usize = 4;
+
 pub(crate) struct FragmentsBuffer<'a> {
     #[cfg(feature = "proto-ipv4-fragmentation")]
     pub(crate) ipv4_fragments: PacketAssemblerSet<'a, Ipv4FragKey>,
@@ -269,7 +272,7 @@ pub struct InterfaceInner<'a> {
     sixlowpan_address_context: &'a [SixlowpanAddressContext<'a>],
     #[cfg(feature = "proto-sixlowpan-fragmentation")]
     tag: u16,
-    ip_addrs: ManagedSlice<'a, IpCidr>,
+    ip_addrs: Vec<IpCidr, MAX_IP_ADDRS_NUM>,
     #[cfg(feature = "proto-ipv4")]
     any_ip: bool,
     routes: Routes<'a>,
@@ -288,7 +291,7 @@ pub struct InterfaceBuilder<'a> {
     neighbor_cache: Option<NeighborCache<'a>>,
     #[cfg(feature = "medium-ieee802154")]
     pan_id: Option<Ieee802154Pan>,
-    ip_addrs: ManagedSlice<'a, IpCidr>,
+    ip_addrs: Vec<IpCidr, MAX_IP_ADDRS_NUM>,
     #[cfg(feature = "proto-ipv4")]
     any_ip: bool,
     routes: Routes<'a>,
@@ -365,7 +368,7 @@ let iface = builder.finalize(&mut device);
             #[cfg(feature = "medium-ieee802154")]
             pan_id: None,
 
-            ip_addrs: ManagedSlice::Borrowed(&mut []),
+            ip_addrs: Vec::new(),
             #[cfg(feature = "proto-ipv4")]
             any_ip: false,
             routes: Routes::new(ManagedMap::Borrowed(&mut [])),
@@ -433,7 +436,7 @@ let iface = builder.finalize(&mut device);
     /// [ip_addrs]: struct.Interface.html#method.ip_addrs
     pub fn ip_addrs<T>(mut self, ip_addrs: T) -> Self
     where
-        T: Into<ManagedSlice<'a, IpCidr>>,
+        T: Into<Vec<IpCidr, MAX_IP_ADDRS_NUM>>,
     {
         let ip_addrs = ip_addrs.into();
         InterfaceInner::check_ip_addrs(&ip_addrs);
@@ -1003,7 +1006,7 @@ impl<'a> Interface<'a> {
     ///
     /// # Panics
     /// This function panics if any of the addresses are not unicast.
-    pub fn update_ip_addrs<F: FnOnce(&mut ManagedSlice<'a, IpCidr>)>(&mut self, f: F) {
+    pub fn update_ip_addrs<F: FnOnce(&mut Vec<IpCidr, MAX_IP_ADDRS_NUM>)>(&mut self, f: F) {
         f(&mut self.inner.ip_addrs);
         InterfaceInner::flush_cache(&mut self.inner);
         InterfaceInner::check_ip_addrs(&self.inner.ip_addrs)
@@ -1556,7 +1559,7 @@ impl<'a> InterfaceInner<'a> {
             },
             now: Instant::from_millis_const(0),
 
-            ip_addrs: ManagedSlice::Owned(vec![
+            ip_addrs: Vec::from_slice(&vec![
                 #[cfg(feature = "proto-ipv4")]
                 IpCidr::Ipv4(Ipv4Cidr::new(Ipv4Address::new(192, 168, 1, 1), 24)),
                 #[cfg(feature = "proto-ipv6")]
@@ -1564,7 +1567,7 @@ impl<'a> InterfaceInner<'a> {
                     Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]),
                     64,
                 )),
-            ]),
+            ]).unwrap(),
             rand: Rand::new(1234),
             routes: Routes::new(&mut [][..]),
 

src/iface/interface/tests.rs

@@ -42,14 +42,13 @@ fn create<'a>(medium: Medium) -> (Interface<'a>, SocketSet<'a>, Loopback) {
 fn create_ip<'a>() -> (Interface<'a>, SocketSet<'a>, Loopback) {
     // Create a basic device
     let mut device = Loopback::new(Medium::Ip);
-    let ip_addrs = [
-        #[cfg(feature = "proto-ipv4")]
-        IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8),
-        #[cfg(feature = "proto-ipv6")]
-        IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 128),
-        #[cfg(feature = "proto-ipv6")]
-        IpCidr::new(IpAddress::v6(0xfdbe, 0, 0, 0, 0, 0, 0, 1), 64),
-    ];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    #[cfg(feature = "proto-ipv4")]
+    ip_addrs.push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)).unwrap();
+    #[cfg(feature = "proto-ipv6")]
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 128)).unwrap();
+    #[cfg(feature = "proto-ipv6")]
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfdbe, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
 
     let iface_builder = InterfaceBuilder::new().ip_addrs(ip_addrs);
 
@@ -69,14 +68,13 @@ fn create_ip<'a>() -> (Interface<'a>, SocketSet<'a>, Loopback) {
 fn create_ethernet<'a>() -> (Interface<'a>, SocketSet<'a>, Loopback) {
     // Create a basic device
     let mut device = Loopback::new(Medium::Ethernet);
-    let ip_addrs = [
-        #[cfg(feature = "proto-ipv4")]
-        IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8),
-        #[cfg(feature = "proto-ipv6")]
-        IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 128),
-        #[cfg(feature = "proto-ipv6")]
-        IpCidr::new(IpAddress::v6(0xfdbe, 0, 0, 0, 0, 0, 0, 1), 64),
-    ];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    #[cfg(feature = "proto-ipv4")]
+    ip_addrs.push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)).unwrap();
+    #[cfg(feature = "proto-ipv6")]
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 128)).unwrap();
+    #[cfg(feature = "proto-ipv6")]
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfdbe, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
 
     let iface_builder = InterfaceBuilder::new()
         .hardware_addr(EthernetAddress::default().into())
@@ -104,12 +102,11 @@ fn create_ethernet<'a>() -> (Interface<'a>, SocketSet<'a>, Loopback) {
 fn create_ieee802154<'a>() -> (Interface<'a>, SocketSet<'a>, Loopback) {
     // Create a basic device
     let mut device = Loopback::new(Medium::Ieee802154);
-    let ip_addrs = [
-        #[cfg(feature = "proto-ipv6")]
-        IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 128),
-        #[cfg(feature = "proto-ipv6")]
-        IpCidr::new(IpAddress::v6(0xfdbe, 0, 0, 0, 0, 0, 0, 1), 64),
-    ];
+    let mut ip_addrs = heapless::Vec::<IpCidr, 4>::new();
+    #[cfg(feature = "proto-ipv6")]
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 128)).unwrap();
+    #[cfg(feature = "proto-ipv6")]
+    ip_addrs.push(IpCidr::new(IpAddress::v6(0xfdbe, 0, 0, 0, 0, 0, 0, 1), 64)).unwrap();
 
     let iface_builder = InterfaceBuilder::new()
         .hardware_addr(Ieee802154Address::default().into())
@@ -1050,13 +1047,12 @@ fn test_icmpv4_socket() {
 #[cfg(feature = "proto-ipv6")]
 fn test_solicited_node_addrs() {
     let (mut iface, _, _device) = create(MEDIUM);
-    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),
-    ];
+    let mut new_addrs = heapless::Vec::<IpCidr, 4>::new();
+    new_addrs.push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 1, 2, 0, 2), 64)).unwrap();
+    new_addrs.push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 3, 4, 0, 0xffff), 64)).unwrap();
     iface.update_ip_addrs(|addrs| {
         new_addrs.extend(addrs.to_vec());
-        *addrs = From::from(new_addrs);
+        *addrs = new_addrs;
     });
     assert!(iface
         .inner