src/connectivity/network/netstack3/core/src/lib.rs - fuchsia - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 //! A networking stack.

 #![cfg_attr(not(fuzz), no_std)]
 // In case we roll the toolchain and something we're using as a feature has been
 // stabilized.
 #![allow(stable_features)]
 // Tracking: https://github.com/rust-lang/rust/issues/31844.
 #![feature(min_specialization)]
 #![deny(missing_docs, unreachable_patterns)]
 // Turn off checks for dead code, but only when building for fuzzing or
 // benchmarking. This allows fuzzers and benchmarks to be written as part of
 // the crate, with access to test utilities, without a bunch of build errors
 // due to unused code. These checks are turned back on in the 'fuzz' and
 // 'benchmark' modules.
 #![cfg_attr(any(fuzz, benchmark), allow(dead_code, unused_imports, unused_macros))]

 // TODO(https://github.com/rust-lang-nursery/portability-wg/issues/11): remove
 // this module.
 extern crate fakealloc as alloc;

 // TODO(https://github.com/dtolnay/thiserror/pull/64): remove this module.
 #[cfg(not(fuzz))]
 extern crate fakestd as std;

 #[macro_use]
 mod macros;

 mod algorithm;
 #[cfg(test)]
 pub mod benchmarks;
 pub mod context;
 mod data_structures;
 mod device;
 pub mod error;
 #[cfg(fuzz)]
 mod fuzz;
 mod ip;
 mod socket;
 #[cfg(test)]
 mod testutil;
 mod transport;

 use log::trace;

 pub use crate::{
     data_structures::{Entry, IdMap, IdMapCollection, IdMapCollectionKey},
     device::{
         add_ethernet_device, add_loopback_device, get_ipv4_configuration, get_ipv6_configuration,
         receive_frame, remove_device, update_ipv4_configuration, update_ipv6_configuration,
         DeviceId, DeviceLayerEventDispatcher,
     },
     error::{LocalAddressError, NetstackError, RemoteAddressError, SocketError},
     ip::{
         device::{
             dad::DadEvent,
             route_discovery::Ipv6RouteDiscoveryEvent,
             slaac::SlaacConfiguration,
             state::{IpDeviceConfiguration, Ipv4DeviceConfiguration, Ipv6DeviceConfiguration},
             IpAddressState, IpDeviceEvent,
         },
         forwarding::AddRouteError,
         icmp,
         socket::{IpSockCreationError, IpSockRouteError, IpSockSendError, IpSockUnroutableError},
         AddableEntry, AddableEntryEither, EntryEither, IpDeviceIdContext, IpExt, IpLayerEvent,
         Ipv4StateBuilder, Ipv6StateBuilder, TransportIpContext,
     },
     transport::{
         udp::{
             connect_udp, create_udp_unbound, get_udp_bound_device, get_udp_conn_info,
             get_udp_listener_info, get_udp_posix_reuse_port, listen_udp, remove_udp_conn,
             remove_udp_listener, remove_udp_unbound, send_udp, send_udp_conn, send_udp_listener,
             set_bound_udp_device, set_udp_multicast_membership, set_udp_posix_reuse_port,
             set_unbound_udp_device, BufferUdpContext, BufferUdpStateContext,
             BufferUdpStateNonSyncContext, UdpBoundId, UdpConnId, UdpConnInfo, UdpContext,
             UdpListenerId, UdpListenerInfo, UdpSendError, UdpSendListenerError,
             UdpSockCreationError, UdpSocketId, UdpStateContext, UdpStateNonSyncContext,
             UdpUnboundId,
         },
         TransportStateBuilder,
     },
 };

 use alloc::vec::Vec;
 use core::{fmt::Debug, marker::PhantomData, time};

 use net_types::{
     ip::{AddrSubnetEither, IpAddr, Ipv4, Ipv4Addr, Ipv6, Ipv6Addr, SubnetEither},
     SpecifiedAddr,
 };
 use packet::{Buf, BufferMut, EmptyBuf};

 use crate::{
     context::{CounterContext, EventContext, RngContext, TimerContext},
     device::{DeviceLayerState, DeviceLayerTimerId},
     ip::{
         device::{Ipv4DeviceTimerId, Ipv6DeviceTimerId},
         icmp::{BufferIcmpContext, IcmpContext},
         IpLayerTimerId, Ipv4State, Ipv6State,
     },
     transport::{TransportLayerState, TransportLayerTimerId},
 };

 /// Map an expression over either version of one or more addresses.
 ///
 /// `map_addr_version!` when given a value of a type which is an enum with two
 /// variants - `V4` and `V6` - matches on the variants, and for both variants,
 /// invokes an expression on the inner contents. `$addr` is both the name of the
 /// variable to match on, and the name that the address will be bound to for the
 /// scope of the expression.
 ///
 /// `map_addr_version!` when given a list of values and their types (all enums
 /// with variants `V4` and `V6`), matches on the tuple of values and invokes the
 /// `$match` expression when all values are of the same variant. Otherwise the
 /// `$mismatch` expression is invoked.
 ///
 /// To make it concrete, the expression `map_addr_version!(bar: Foo; blah(bar))`
 /// desugars to:
 ///
 /// ```rust,ignore
 /// match bar {
 ///     Foo::V4(bar) => blah(bar),
 ///     Foo::V6(bar) => blah(bar),
 /// }
 /// ```
 ///
 /// Also,
 /// `map_addr_version!((foo: Foo, bar: Bar); blah(foo, bar), unreachable!())`
 /// desugars to:
 ///
 /// ```rust,ignore
 /// match (foo, bar) {
 ///     (Foo::V4(foo), Bar::V4(bar)) => blah(foo, bar),
 ///     (Foo::V6(foo), Bar::V6(bar)) => blah(foo, bar),
 ///     _ => unreachable!(),
 /// }
 /// ```
 #[macro_export]
 macro_rules! map_addr_version {
     ($addr:ident: $ty:tt; $expr:expr) => {
         match $addr {
             $ty::V4($addr) => $expr,
             $ty::V6($addr) => $expr,
         }
     };
     ($addr:ident: $ty:tt; $expr_v4:expr, $expr_v6:expr) => {
         match $addr {
             $ty::V4($addr) => $expr_v4,
             $ty::V6($addr) => $expr_v6,
         }
     };
     (( $( $addr:ident : $ty:tt ),+ ); $match:expr, $mismatch:expr) => {
         match ( $( $addr ),+ ) {
             ( $( $ty::V4( $addr ) ),+ ) => $match,
             ( $( $ty::V6( $addr ) ),+ ) => $match,
             _ => $mismatch,
         }
     };
     (( $( $addr:ident : $ty:tt ),+ ); $match_v4:expr, $match_v6:expr, $mismatch:expr) => {
         match ( $( $addr ),+ ) {
             ( $( $ty::V4( $addr ) ),+ ) => $match_v4,
             ( $( $ty::V6( $addr ) ),+ ) => $match_v6,
             _ => $mismatch,
         }
     };
     (( $( $addr:ident : $ty:tt ),+ ); $match:expr, $mismatch:expr,) => {
         map_addr_version!(($( $addr: $ty ),+); $match, $mismatch)
     };
 }

 /// A builder for [`StackState`].
 #[derive(Default, Clone)]
 pub struct StackStateBuilder {
     transport: TransportStateBuilder,
     ipv4: Ipv4StateBuilder,
     ipv6: Ipv6StateBuilder,
 }

 impl StackStateBuilder {
     /// Get the builder for the transport layer state.
     pub fn transport_builder(&mut self) -> &mut TransportStateBuilder {
         &mut self.transport
     }

     /// Get the builder for the IPv4 state.
     pub fn ipv4_builder(&mut self) -> &mut Ipv4StateBuilder {
         &mut self.ipv4
     }

     /// Get the builder for the IPv6 state.
     pub fn ipv6_builder(&mut self) -> &mut Ipv6StateBuilder {
         &mut self.ipv6
     }

     /// Consume this builder and produce a `StackState`.
     pub fn build<I: Instant>(self) -> StackState<I> {
         StackState {
             transport: self.transport.build(),
             ipv4: self.ipv4.build(),
             ipv6: self.ipv6.build(),
             device: Default::default(),
         }
     }
 }

 /// The state associated with the network stack.
 pub struct StackState<I: Instant> {
     transport: TransportLayerState,
     ipv4: Ipv4State<I, DeviceId>,
     ipv6: Ipv6State<I, DeviceId>,
     device: DeviceLayerState<I>,
 }

 impl<I: Instant> Default for StackState<I> {
     fn default() -> StackState<I> {
         StackStateBuilder::default().build()
     }
 }

 /// The non synchronized context for the stack with a buffer.
 pub trait BufferNonSyncContextInner<B: BufferMut>:
     DeviceLayerEventDispatcher<B>
     + BufferUdpContext<Ipv4, B>
     + BufferUdpContext<Ipv6, B>
     + BufferIcmpContext<Ipv4, B>
     + BufferIcmpContext<Ipv6, B>
 {
 }
 impl<
         B: BufferMut,
         C: DeviceLayerEventDispatcher<B>
             + BufferUdpContext<Ipv4, B>
             + BufferUdpContext<Ipv6, B>
             + BufferIcmpContext<Ipv4, B>
             + BufferIcmpContext<Ipv6, B>,
     > BufferNonSyncContextInner<B> for C
 {
 }

 /// The non synchronized context for the stack with a buffer.
 pub trait BufferNonSyncContext<B: BufferMut>:
     NonSyncContext + BufferNonSyncContextInner<B>
 {
 }
 impl<B: BufferMut, C: NonSyncContext + BufferNonSyncContextInner<B>> BufferNonSyncContext<B> for C {}

 /// The non-synchronized context for the stack.
 pub trait NonSyncContext:
     CounterContext
     + BufferNonSyncContextInner<Buf<Vec<u8>>>
     + BufferNonSyncContextInner<EmptyBuf>
     + RngContext
     + TimerContext<TimerId>
     + EventContext<IpDeviceEvent<DeviceId, Ipv4>>
     + EventContext<IpDeviceEvent<DeviceId, Ipv6>>
     + EventContext<IpLayerEvent<DeviceId, Ipv4>>
     + EventContext<IpLayerEvent<DeviceId, Ipv6>>
     + EventContext<DadEvent<DeviceId>>
     + EventContext<Ipv6RouteDiscoveryEvent<DeviceId>>
     + UdpContext<Ipv4>
     + UdpContext<Ipv6>
     + IcmpContext<Ipv4>
     + IcmpContext<Ipv6>
 {
 }
 impl<
         C: CounterContext
             + BufferNonSyncContextInner<Buf<Vec<u8>>>
             + BufferNonSyncContextInner<EmptyBuf>
             + RngContext
             + TimerContext<TimerId>
             + EventContext<IpDeviceEvent<DeviceId, Ipv4>>
             + EventContext<IpDeviceEvent<DeviceId, Ipv6>>
             + EventContext<IpLayerEvent<DeviceId, Ipv4>>
             + EventContext<IpLayerEvent<DeviceId, Ipv6>>
             + EventContext<DadEvent<DeviceId>>
             + EventContext<Ipv6RouteDiscoveryEvent<DeviceId>>
             + UdpContext<Ipv4>
             + UdpContext<Ipv6>
             + IcmpContext<Ipv4>
             + IcmpContext<Ipv6>,
     > NonSyncContext for C
 {
 }

 /// The synchronized context.
 pub struct SyncCtx<NonSyncCtx: NonSyncContext> {
     /// Contains the state of the stack.
     pub state: StackState<NonSyncCtx::Instant>,
     /// A marker for the non-synchronized context type.
     pub non_sync_ctx_marker: PhantomData<NonSyncCtx>,
 }

 /// Context available during the execution of the netstack.
 ///
 /// `Ctx` provides access to the state of the netstack and to an event
 /// dispatcher which can be used to emit events and schedule timers. A mutable
 /// reference to a `Ctx` is passed to every function in the netstack.
 pub struct Ctx<NonSyncCtx: NonSyncContext> {
     /// The synchronized context.
     pub sync_ctx: SyncCtx<NonSyncCtx>,
     /// The non-synchronized context.
     pub non_sync_ctx: NonSyncCtx,
 }

 impl<NonSyncCtx: NonSyncContext + Default> Default for Ctx<NonSyncCtx>
 where
     StackState<NonSyncCtx::Instant>: Default,
 {
     fn default() -> Ctx<NonSyncCtx> {
         Ctx {
             sync_ctx: SyncCtx { state: StackState::default(), non_sync_ctx_marker: PhantomData },
             non_sync_ctx: Default::default(),
         }
     }
 }

 impl<NonSyncCtx: NonSyncContext + Default> Ctx<NonSyncCtx> {
     /// Constructs a new `Ctx`.
     pub fn new(state: StackState<NonSyncCtx::Instant>) -> Ctx<NonSyncCtx> {
         Ctx {
             sync_ctx: SyncCtx { state, non_sync_ctx_marker: PhantomData },
             non_sync_ctx: Default::default(),
         }
     }
 }

 /// The identifier for any timer event.
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
 pub struct TimerId(TimerIdInner);

 #[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
 enum TimerIdInner {
     /// A timer event in the device layer.
     DeviceLayer(DeviceLayerTimerId),
     /// A timer event in the transport layer.
     _TransportLayer(TransportLayerTimerId),
     /// A timer event in the IP layer.
     IpLayer(IpLayerTimerId),
     /// A timer event for an IPv4 device.
     Ipv4Device(Ipv4DeviceTimerId<DeviceId>),
     /// A timer event for an IPv6 device.
     Ipv6Device(Ipv6DeviceTimerId<DeviceId>),
     /// A no-op timer event (used for tests)
     #[cfg(test)]
     Nop(usize),
 }

 impl From<DeviceLayerTimerId> for TimerId {
     fn from(id: DeviceLayerTimerId) -> TimerId {
         TimerId(TimerIdInner::DeviceLayer(id))
     }
 }

 impl From<Ipv4DeviceTimerId<DeviceId>> for TimerId {
     fn from(id: Ipv4DeviceTimerId<DeviceId>) -> TimerId {
         TimerId(TimerIdInner::Ipv4Device(id))
     }
 }

 impl From<Ipv6DeviceTimerId<DeviceId>> for TimerId {
     fn from(id: Ipv6DeviceTimerId<DeviceId>) -> TimerId {
         TimerId(TimerIdInner::Ipv6Device(id))
     }
 }

 impl From<IpLayerTimerId> for TimerId {
     fn from(id: IpLayerTimerId) -> TimerId {
         TimerId(TimerIdInner::IpLayer(id))
     }
 }

 impl_timer_context!(TimerId, DeviceLayerTimerId, TimerId(TimerIdInner::DeviceLayer(id)), id);
 impl_timer_context!(TimerId, IpLayerTimerId, TimerId(TimerIdInner::IpLayer(id)), id);
 impl_timer_context!(
     TimerId,
     Ipv4DeviceTimerId<DeviceId>,
     TimerId(TimerIdInner::Ipv4Device(id)),
     id
 );
 impl_timer_context!(
     TimerId,
     Ipv6DeviceTimerId<DeviceId>,
     TimerId(TimerIdInner::Ipv6Device(id)),
     id
 );

 /// Handles a generic timer event.
 pub fn handle_timer<NonSyncCtx: NonSyncContext>(
     sync_ctx: &mut SyncCtx<NonSyncCtx>,
     ctx: &mut NonSyncCtx,
     id: TimerId,
 ) {
     trace!("handle_timer: dispatching timerid: {:?}", id);

     match id {
         TimerId(TimerIdInner::DeviceLayer(x)) => {
             device::handle_timer(sync_ctx, ctx, x);
         }
         TimerId(TimerIdInner::_TransportLayer(x)) => {
             transport::handle_timer(sync_ctx, x);
         }
         TimerId(TimerIdInner::IpLayer(x)) => {
             ip::handle_timer(sync_ctx, ctx, x);
         }
         TimerId(TimerIdInner::Ipv4Device(x)) => {
             ip::device::handle_ipv4_timer(sync_ctx, ctx, x);
         }
         TimerId(TimerIdInner::Ipv6Device(x)) => {
             ip::device::handle_ipv6_timer(sync_ctx, ctx, x);
         }
         #[cfg(test)]
         TimerId(TimerIdInner::Nop(_)) => {
             ctx.increment_counter("timer::nop");
         }
     }
 }

 /// A type representing an instant in time.
 ///
 /// `Instant` can be implemented by any type which represents an instant in
 /// time. This can include any sort of real-world clock time (e.g.,
 /// [`std::time::Instant`]) or fake time such as in testing.
 pub trait Instant: Sized + Ord + Copy + Clone + Debug + Send + Sync {
     /// Returns the amount of time elapsed from another instant to this one.
     ///
     /// # Panics
     ///
     /// This function will panic if `earlier` is later than `self`.
     fn duration_since(&self, earlier: Self) -> time::Duration;

     /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be
     /// represented as `Instant` (which means it's inside the bounds of the
     /// underlying data structure), `None` otherwise.
     fn checked_add(&self, duration: time::Duration) -> Option<Self>;

     /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be
     /// represented as `Instant` (which means it's inside the bounds of the
     /// underlying data structure), `None` otherwise.
     fn checked_sub(&self, duration: time::Duration) -> Option<Self>;
 }

 /// Get all IPv4 and IPv6 address/subnet pairs configured on a device
 pub fn get_all_ip_addr_subnets<'a, NonSyncCtx: NonSyncContext>(
     ctx: &'a SyncCtx<NonSyncCtx>,
     device: DeviceId,
 ) -> impl 'a + Iterator<Item = AddrSubnetEither> {
     let addr_v4 = crate::ip::device::get_assigned_ipv4_addr_subnets(ctx, device)
         .map(|a| AddrSubnetEither::V4(a));
     let addr_v6 = crate::ip::device::get_assigned_ipv6_addr_subnets(ctx, device)
         .map(|a| AddrSubnetEither::V6(a));

     addr_v4.chain(addr_v6)
 }

 /// Set the IP address and subnet for a device.
 pub fn add_ip_addr_subnet<NonSyncCtx: NonSyncContext>(
     sync_ctx: &mut SyncCtx<NonSyncCtx>,
     ctx: &mut NonSyncCtx,
     device: DeviceId,
     addr_sub: AddrSubnetEither,
 ) -> error::Result<()> {
     map_addr_version!(
         addr_sub: AddrSubnetEither;
         crate::device::add_ip_addr_subnet(sync_ctx, ctx, device, addr_sub)
     )
     .map_err(From::from)
 }

 /// Delete an IP address on a device.
 pub fn del_ip_addr<NonSyncCtx: NonSyncContext>(
     sync_ctx: &mut SyncCtx<NonSyncCtx>,
     ctx: &mut NonSyncCtx,
     device: DeviceId,
     addr: IpAddr<SpecifiedAddr<Ipv4Addr>, SpecifiedAddr<Ipv6Addr>>,
 ) -> error::Result<()> {
     map_addr_version!(
         addr: IpAddr;
         crate::device::del_ip_addr(sync_ctx, ctx, device, &addr)
     )
     .map_err(From::from)
 }

 /// Adds a route to the forwarding table.
 pub fn add_route<NonSyncCtx: NonSyncContext>(
     sync_ctx: &mut SyncCtx<NonSyncCtx>,
     ctx: &mut NonSyncCtx,
     entry: AddableEntryEither<DeviceId>,
 ) -> Result<(), AddRouteError> {
     let (subnet, device, gateway) = entry.into_subnet_device_gateway();
     match (device, gateway) {
         (Some(device), None) => map_addr_version!(
             subnet: SubnetEither;
             crate::ip::add_device_route::<Ipv4, _, _>(sync_ctx, ctx, subnet, device),
             crate::ip::add_device_route::<Ipv6, _, _>(sync_ctx, ctx, subnet, device)
         )
         .map_err(From::from),
         (None, Some(next_hop)) => {
             let next_hop = next_hop.into();
             map_addr_version!(
                 (subnet: SubnetEither, next_hop: IpAddr);
                 crate::ip::add_route::<Ipv4, _, _>(sync_ctx, ctx, subnet, next_hop),
                 crate::ip::add_route::<Ipv6, _, _>(sync_ctx, ctx, subnet, next_hop),
                 unreachable!()
             )
         }
         x => todo!("TODO(https://fxbug.dev/96680): support setting gateway route with device; (device, gateway) = {:?}", x),
     }
 }

 /// Delete a route from the forwarding table, returning `Err` if no
 /// route was found to be deleted.
 pub fn del_route<NonSyncCtx: NonSyncContext>(
     sync_ctx: &mut SyncCtx<NonSyncCtx>,
     ctx: &mut NonSyncCtx,
     subnet: SubnetEither,
 ) -> error::Result<()> {
     map_addr_version!(
         subnet: SubnetEither;
         crate::ip::del_route::<Ipv4, _, _>(sync_ctx, ctx, subnet),
         crate::ip::del_route::<Ipv6, _, _>(sync_ctx, ctx, subnet)
     )
     .map_err(From::from)
 }

 /// Get all the routes.
 pub fn get_all_routes<'a, NonSyncCtx: NonSyncContext>(
     ctx: &'a SyncCtx<NonSyncCtx>,
 ) -> impl 'a + Iterator<Item = EntryEither<DeviceId>> {
     let v4_routes = ip::iter_all_routes::<_, Ipv4Addr>(ctx);
     let v6_routes = ip::iter_all_routes::<_, Ipv6Addr>(ctx);
     v4_routes.cloned().map(From::from).chain(v6_routes.cloned().map(From::from))
 }

 #[cfg(test)]
 mod tests {
     use net_types::{
         ip::{Ip, Ipv4, Ipv6},
         Witness,
     };

     use super::*;
     use crate::testutil::{DummyEventDispatcherBuilder, TestIpExt};

     fn test_add_remove_ip_addresses<I: Ip + TestIpExt>() {
         let config = I::DUMMY_CONFIG;
         let Ctx { mut sync_ctx, mut non_sync_ctx } = DummyEventDispatcherBuilder::default().build();
         let device = crate::add_ethernet_device(
             &mut sync_ctx,
             &mut non_sync_ctx,
             config.local_mac,
             Ipv6::MINIMUM_LINK_MTU.into(),
         );
         crate::device::testutil::enable_device(&mut sync_ctx, &mut non_sync_ctx, device);

         let ip: IpAddr = I::get_other_ip_address(1).get().into();
         let prefix = config.subnet.prefix();
         let addr_subnet = AddrSubnetEither::new(ip, prefix).unwrap();

         // IP doesn't exist initially.
         assert_eq!(get_all_ip_addr_subnets(&sync_ctx, device).find(|&a| a == addr_subnet), None);

         // Add IP (OK).
         let () = add_ip_addr_subnet(&mut sync_ctx, &mut non_sync_ctx, device, addr_subnet).unwrap();
         assert_eq!(
             get_all_ip_addr_subnets(&sync_ctx, device).find(|&a| a == addr_subnet),
             Some(addr_subnet)
         );

         // Add IP again (already exists).
         assert_eq!(
             add_ip_addr_subnet(&mut sync_ctx, &mut non_sync_ctx, device, addr_subnet).unwrap_err(),
             NetstackError::Exists
         );
         assert_eq!(
             get_all_ip_addr_subnets(&sync_ctx, device).find(|&a| a == addr_subnet),
             Some(addr_subnet)
         );

         // Add IP with different subnet (already exists).
         let wrong_addr_subnet = AddrSubnetEither::new(ip, prefix - 1).unwrap();
         assert_eq!(
             add_ip_addr_subnet(&mut sync_ctx, &mut non_sync_ctx, device, wrong_addr_subnet)
                 .unwrap_err(),
             NetstackError::Exists
         );
         assert_eq!(
             get_all_ip_addr_subnets(&sync_ctx, device).find(|&a| a == addr_subnet),
             Some(addr_subnet)
         );

         let ip = SpecifiedAddr::new(ip).unwrap();
         // Del IP (ok).
         let () = del_ip_addr(&mut sync_ctx, &mut non_sync_ctx, device, ip.into()).unwrap();
         assert_eq!(get_all_ip_addr_subnets(&sync_ctx, device).find(|&a| a == addr_subnet), None);

         // Del IP again (not found).
         assert_eq!(
             del_ip_addr(&mut sync_ctx, &mut non_sync_ctx, device, ip.into()).unwrap_err(),
             NetstackError::NotFound
         );
         assert_eq!(get_all_ip_addr_subnets(&sync_ctx, device).find(|&a| a == addr_subnet), None);
     }

     #[test]
     fn test_add_remove_ipv4_addresses() {
         test_add_remove_ip_addresses::<Ipv4>();
     }

     #[test]
     fn test_add_remove_ipv6_addresses() {
         test_add_remove_ip_addresses::<Ipv6>();
     }
 }
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	//! A networking stack.

	#![cfg_attr(not(fuzz), no_std)]
	// In case we roll the toolchain and something we're using as a feature has been
	// stabilized.
	#![allow(stable_features)]
	// Tracking: https://github.com/rust-lang/rust/issues/31844.
	#![feature(min_specialization)]
	#![deny(missing_docs, unreachable_patterns)]
	// Turn off checks for dead code, but only when building for fuzzing or
	// benchmarking. This allows fuzzers and benchmarks to be written as part of
	// the crate, with access to test utilities, without a bunch of build errors
	// due to unused code. These checks are turned back on in the 'fuzz' and
	// 'benchmark' modules.
	#![cfg_attr(any(fuzz, benchmark), allow(dead_code, unused_imports, unused_macros))]

	// TODO(https://github.com/rust-lang-nursery/portability-wg/issues/11): remove
	// this module.
	extern crate fakealloc as alloc;

	// TODO(https://github.com/dtolnay/thiserror/pull/64): remove this module.
	#[cfg(not(fuzz))]
	extern crate fakestd as std;

	#[macro_use]
	mod macros;

	mod algorithm;
	#[cfg(test)]
	pub mod benchmarks;
	pub mod context;
	mod data_structures;
	mod device;
	pub mod error;
	#[cfg(fuzz)]
	mod fuzz;
	mod ip;
	mod socket;
	#[cfg(test)]
	mod testutil;
	mod transport;

	use log::trace;

	pub use crate::{
	data_structures::{Entry, IdMap, IdMapCollection, IdMapCollectionKey},
	device::{
	add_ethernet_device, add_loopback_device, get_ipv4_configuration, get_ipv6_configuration,
	receive_frame, remove_device, update_ipv4_configuration, update_ipv6_configuration,
	DeviceId, DeviceLayerEventDispatcher,
	},
	error::{LocalAddressError, NetstackError, RemoteAddressError, SocketError},
	ip::{
	device::{
	dad::DadEvent,
	route_discovery::Ipv6RouteDiscoveryEvent,
	slaac::SlaacConfiguration,
	state::{IpDeviceConfiguration, Ipv4DeviceConfiguration, Ipv6DeviceConfiguration},
	IpAddressState, IpDeviceEvent,
	},
	forwarding::AddRouteError,
	icmp,
	socket::{IpSockCreationError, IpSockRouteError, IpSockSendError, IpSockUnroutableError},
	AddableEntry, AddableEntryEither, EntryEither, IpDeviceIdContext, IpExt, IpLayerEvent,
	Ipv4StateBuilder, Ipv6StateBuilder, TransportIpContext,
	},
	transport::{
	udp::{
	connect_udp, create_udp_unbound, get_udp_bound_device, get_udp_conn_info,
	get_udp_listener_info, get_udp_posix_reuse_port, listen_udp, remove_udp_conn,
	remove_udp_listener, remove_udp_unbound, send_udp, send_udp_conn, send_udp_listener,
	set_bound_udp_device, set_udp_multicast_membership, set_udp_posix_reuse_port,
	set_unbound_udp_device, BufferUdpContext, BufferUdpStateContext,
	BufferUdpStateNonSyncContext, UdpBoundId, UdpConnId, UdpConnInfo, UdpContext,
	UdpListenerId, UdpListenerInfo, UdpSendError, UdpSendListenerError,
	UdpSockCreationError, UdpSocketId, UdpStateContext, UdpStateNonSyncContext,
	UdpUnboundId,
	},
	TransportStateBuilder,
	},
	};

	use alloc::vec::Vec;
	use core::{fmt::Debug, marker::PhantomData, time};

	use net_types::{
	ip::{AddrSubnetEither, IpAddr, Ipv4, Ipv4Addr, Ipv6, Ipv6Addr, SubnetEither},
	SpecifiedAddr,
	};
	use packet::{Buf, BufferMut, EmptyBuf};

	use crate::{
	context::{CounterContext, EventContext, RngContext, TimerContext},
	device::{DeviceLayerState, DeviceLayerTimerId},
	ip::{
	device::{Ipv4DeviceTimerId, Ipv6DeviceTimerId},
	icmp::{BufferIcmpContext, IcmpContext},
	IpLayerTimerId, Ipv4State, Ipv6State,
	},
	transport::{TransportLayerState, TransportLayerTimerId},
	};

	/// Map an expression over either version of one or more addresses.
	///
	/// `map_addr_version!` when given a value of a type which is an enum with two
	/// variants - `V4` and `V6` - matches on the variants, and for both variants,
	/// invokes an expression on the inner contents. `$addr` is both the name of the
	/// variable to match on, and the name that the address will be bound to for the
	/// scope of the expression.
	///
	/// `map_addr_version!` when given a list of values and their types (all enums
	/// with variants `V4` and `V6`), matches on the tuple of values and invokes the
	/// `$match` expression when all values are of the same variant. Otherwise the
	/// `$mismatch` expression is invoked.
	///
	/// To make it concrete, the expression `map_addr_version!(bar: Foo; blah(bar))`
	/// desugars to:
	///
	/// ```rust,ignore
	/// match bar {
	/// Foo::V4(bar) => blah(bar),
	/// Foo::V6(bar) => blah(bar),
	/// }
	/// ```
	///
	/// Also,
	/// `map_addr_version!((foo: Foo, bar: Bar); blah(foo, bar), unreachable!())`
	/// desugars to:
	///
	/// ```rust,ignore
	/// match (foo, bar) {
	/// (Foo::V4(foo), Bar::V4(bar)) => blah(foo, bar),
	/// (Foo::V6(foo), Bar::V6(bar)) => blah(foo, bar),
	/// _ => unreachable!(),
	/// }
	/// ```
	#[macro_export]
	macro_rules! map_addr_version {
	($addr:ident: $ty:tt; $expr:expr) => {
	match $addr {
	$ty::V4($addr) => $expr,
	$ty::V6($addr) => $expr,
	}
	};
	($addr:ident: $ty:tt; $expr_v4:expr, $expr_v6:expr) => {
	match $addr {
	$ty::V4($addr) => $expr_v4,
	$ty::V6($addr) => $expr_v6,
	}
	};
	(( $( $addr:ident : $ty:tt ),+ ); $match:expr, $mismatch:expr) => {
	match ( $( $addr ),+ ) {
	( $( $ty::V4( $addr ) ),+ ) => $match,
	( $( $ty::V6( $addr ) ),+ ) => $match,
	_ => $mismatch,
	}
	};
	(( $( $addr:ident : $ty:tt ),+ ); $match_v4:expr, $match_v6:expr, $mismatch:expr) => {
	match ( $( $addr ),+ ) {
	( $( $ty::V4( $addr ) ),+ ) => $match_v4,
	( $( $ty::V6( $addr ) ),+ ) => $match_v6,
	_ => $mismatch,
	}
	};
	(( $( $addr:ident : $ty:tt ),+ ); $match:expr, $mismatch:expr,) => {
	map_addr_version!(($( $addr: $ty ),+); $match, $mismatch)
	};
	}

	/// A builder for [`StackState`].
	#[derive(Default, Clone)]
	pub struct StackStateBuilder {
	transport: TransportStateBuilder,
	ipv4: Ipv4StateBuilder,
	ipv6: Ipv6StateBuilder,
	}

	impl StackStateBuilder {
	/// Get the builder for the transport layer state.
	pub fn transport_builder(&mut self) -> &mut TransportStateBuilder {
	&mut self.transport
	}

	/// Get the builder for the IPv4 state.
	pub fn ipv4_builder(&mut self) -> &mut Ipv4StateBuilder {
	&mut self.ipv4
	}

	/// Get the builder for the IPv6 state.
	pub fn ipv6_builder(&mut self) -> &mut Ipv6StateBuilder {
	&mut self.ipv6
	}

	/// Consume this builder and produce a `StackState`.
	pub fn build<I: Instant>(self) -> StackState<I> {
	StackState {
	transport: self.transport.build(),
	ipv4: self.ipv4.build(),
	ipv6: self.ipv6.build(),
	device: Default::default(),
	}
	}
	}

	/// The state associated with the network stack.
	pub struct StackState<I: Instant> {
	transport: TransportLayerState,
	ipv4: Ipv4State<I, DeviceId>,
	ipv6: Ipv6State<I, DeviceId>,
	device: DeviceLayerState<I>,
	}

	impl<I: Instant> Default for StackState<I> {
	fn default() -> StackState<I> {
	StackStateBuilder::default().build()
	}
	}

	/// The non synchronized context for the stack with a buffer.
	pub trait BufferNonSyncContextInner<B: BufferMut>:
	DeviceLayerEventDispatcher<B>
	+ BufferUdpContext<Ipv4, B>
	+ BufferUdpContext<Ipv6, B>
	+ BufferIcmpContext<Ipv4, B>
	+ BufferIcmpContext<Ipv6, B>
	{
	}
	impl<
	B: BufferMut,
	C: DeviceLayerEventDispatcher<B>
	+ BufferUdpContext<Ipv4, B>
	+ BufferUdpContext<Ipv6, B>
	+ BufferIcmpContext<Ipv4, B>
	+ BufferIcmpContext<Ipv6, B>,
	> BufferNonSyncContextInner<B> for C
	{
	}

	/// The non synchronized context for the stack with a buffer.
	pub trait BufferNonSyncContext<B: BufferMut>:
	NonSyncContext + BufferNonSyncContextInner<B>
	{
	}
	impl<B: BufferMut, C: NonSyncContext + BufferNonSyncContextInner<B>> BufferNonSyncContext<B> for C {}

	/// The non-synchronized context for the stack.
	pub trait NonSyncContext:
	CounterContext
	+ BufferNonSyncContextInner<Buf<Vec<u8>>>
	+ BufferNonSyncContextInner<EmptyBuf>
	+ RngContext
	+ TimerContext<TimerId>
	+ EventContext<IpDeviceEvent<DeviceId, Ipv4>>
	+ EventContext<IpDeviceEvent<DeviceId, Ipv6>>
	+ EventContext<IpLayerEvent<DeviceId, Ipv4>>
	+ EventContext<IpLayerEvent<DeviceId, Ipv6>>
	+ EventContext<DadEvent<DeviceId>>
	+ EventContext<Ipv6RouteDiscoveryEvent<DeviceId>>
	+ UdpContext<Ipv4>
	+ UdpContext<Ipv6>
	+ IcmpContext<Ipv4>
	+ IcmpContext<Ipv6>
	{
	}
	impl<
	C: CounterContext
	+ BufferNonSyncContextInner<Buf<Vec<u8>>>
	+ BufferNonSyncContextInner<EmptyBuf>
	+ RngContext
	+ TimerContext<TimerId>
	+ EventContext<IpDeviceEvent<DeviceId, Ipv4>>
	+ EventContext<IpDeviceEvent<DeviceId, Ipv6>>
	+ EventContext<IpLayerEvent<DeviceId, Ipv4>>
	+ EventContext<IpLayerEvent<DeviceId, Ipv6>>
	+ EventContext<DadEvent<DeviceId>>
	+ EventContext<Ipv6RouteDiscoveryEvent<DeviceId>>
	+ UdpContext<Ipv4>
	+ UdpContext<Ipv6>
	+ IcmpContext<Ipv4>
	+ IcmpContext<Ipv6>,
	> NonSyncContext for C
	{
	}

	/// The synchronized context.
	pub struct SyncCtx<NonSyncCtx: NonSyncContext> {
	/// Contains the state of the stack.
	pub state: StackState<NonSyncCtx::Instant>,
	/// A marker for the non-synchronized context type.
	pub non_sync_ctx_marker: PhantomData<NonSyncCtx>,
	}

	/// Context available during the execution of the netstack.
	///
	/// `Ctx` provides access to the state of the netstack and to an event
	/// dispatcher which can be used to emit events and schedule timers. A mutable
	/// reference to a `Ctx` is passed to every function in the netstack.
	pub struct Ctx<NonSyncCtx: NonSyncContext> {
	/// The synchronized context.
	pub sync_ctx: SyncCtx<NonSyncCtx>,
	/// The non-synchronized context.
	pub non_sync_ctx: NonSyncCtx,
	}

	impl<NonSyncCtx: NonSyncContext + Default> Default for Ctx<NonSyncCtx>
	where
	StackState<NonSyncCtx::Instant>: Default,
	{
	fn default() -> Ctx<NonSyncCtx> {
	Ctx {
	sync_ctx: SyncCtx { state: StackState::default(), non_sync_ctx_marker: PhantomData },
	non_sync_ctx: Default::default(),
	}
	}
	}

	impl<NonSyncCtx: NonSyncContext + Default> Ctx<NonSyncCtx> {
	/// Constructs a new `Ctx`.
	pub fn new(state: StackState<NonSyncCtx::Instant>) -> Ctx<NonSyncCtx> {
	Ctx {
	sync_ctx: SyncCtx { state, non_sync_ctx_marker: PhantomData },
	non_sync_ctx: Default::default(),
	}
	}
	}

	/// The identifier for any timer event.
	#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
	pub struct TimerId(TimerIdInner);

	#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
	enum TimerIdInner {
	/// A timer event in the device layer.
	DeviceLayer(DeviceLayerTimerId),
	/// A timer event in the transport layer.
	_TransportLayer(TransportLayerTimerId),
	/// A timer event in the IP layer.
	IpLayer(IpLayerTimerId),
	/// A timer event for an IPv4 device.
	Ipv4Device(Ipv4DeviceTimerId<DeviceId>),
	/// A timer event for an IPv6 device.
	Ipv6Device(Ipv6DeviceTimerId<DeviceId>),
	/// A no-op timer event (used for tests)
	#[cfg(test)]
	Nop(usize),
	}

	impl From<DeviceLayerTimerId> for TimerId {
	fn from(id: DeviceLayerTimerId) -> TimerId {
	TimerId(TimerIdInner::DeviceLayer(id))
	}
	}

	impl From<Ipv4DeviceTimerId<DeviceId>> for TimerId {
	fn from(id: Ipv4DeviceTimerId<DeviceId>) -> TimerId {
	TimerId(TimerIdInner::Ipv4Device(id))
	}
	}

	impl From<Ipv6DeviceTimerId<DeviceId>> for TimerId {
	fn from(id: Ipv6DeviceTimerId<DeviceId>) -> TimerId {
	TimerId(TimerIdInner::Ipv6Device(id))
	}
	}

	impl From<IpLayerTimerId> for TimerId {
	fn from(id: IpLayerTimerId) -> TimerId {
	TimerId(TimerIdInner::IpLayer(id))
	}
	}

	impl_timer_context!(TimerId, DeviceLayerTimerId, TimerId(TimerIdInner::DeviceLayer(id)), id);
	impl_timer_context!(TimerId, IpLayerTimerId, TimerId(TimerIdInner::IpLayer(id)), id);
	impl_timer_context!(
	TimerId,
	Ipv4DeviceTimerId<DeviceId>,
	TimerId(TimerIdInner::Ipv4Device(id)),
	id
	);
	impl_timer_context!(
	TimerId,
	Ipv6DeviceTimerId<DeviceId>,
	TimerId(TimerIdInner::Ipv6Device(id)),
	id
	);

	/// Handles a generic timer event.
	pub fn handle_timer<NonSyncCtx: NonSyncContext>(
	sync_ctx: &mut SyncCtx<NonSyncCtx>,
	ctx: &mut NonSyncCtx,
	id: TimerId,
	) {
	trace!("handle_timer: dispatching timerid: {:?}", id);

	match id {
	TimerId(TimerIdInner::DeviceLayer(x)) => {
	device::handle_timer(sync_ctx, ctx, x);
	}
	TimerId(TimerIdInner::_TransportLayer(x)) => {
	transport::handle_timer(sync_ctx, x);
	}
	TimerId(TimerIdInner::IpLayer(x)) => {
	ip::handle_timer(sync_ctx, ctx, x);
	}
	TimerId(TimerIdInner::Ipv4Device(x)) => {
	ip::device::handle_ipv4_timer(sync_ctx, ctx, x);
	}
	TimerId(TimerIdInner::Ipv6Device(x)) => {
	ip::device::handle_ipv6_timer(sync_ctx, ctx, x);
	}
	#[cfg(test)]
	TimerId(TimerIdInner::Nop(_)) => {
	ctx.increment_counter("timer::nop");
	}
	}
	}

	/// A type representing an instant in time.
	///
	/// `Instant` can be implemented by any type which represents an instant in
	/// time. This can include any sort of real-world clock time (e.g.,
	/// [`std::time::Instant`]) or fake time such as in testing.
	pub trait Instant: Sized + Ord + Copy + Clone + Debug + Send + Sync {
	/// Returns the amount of time elapsed from another instant to this one.
	///
	/// # Panics
	///
	/// This function will panic if `earlier` is later than `self`.
	fn duration_since(&self, earlier: Self) -> time::Duration;

	/// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be
	/// represented as `Instant` (which means it's inside the bounds of the
	/// underlying data structure), `None` otherwise.
	fn checked_add(&self, duration: time::Duration) -> Option<Self>;

	/// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be
	/// represented as `Instant` (which means it's inside the bounds of the
	/// underlying data structure), `None` otherwise.
	fn checked_sub(&self, duration: time::Duration) -> Option<Self>;
	}

	/// Get all IPv4 and IPv6 address/subnet pairs configured on a device
	pub fn get_all_ip_addr_subnets<'a, NonSyncCtx: NonSyncContext>(
	ctx: &'a SyncCtx<NonSyncCtx>,
	device: DeviceId,
	) -> impl 'a + Iterator<Item = AddrSubnetEither> {
	let addr_v4 = crate::ip::device::get_assigned_ipv4_addr_subnets(ctx, device)
	.map(\|a\| AddrSubnetEither::V4(a));
	let addr_v6 = crate::ip::device::get_assigned_ipv6_addr_subnets(ctx, device)
	.map(\|a\| AddrSubnetEither::V6(a));

	addr_v4.chain(addr_v6)
	}

	/// Set the IP address and subnet for a device.
	pub fn add_ip_addr_subnet<NonSyncCtx: NonSyncContext>(
	sync_ctx: &mut SyncCtx<NonSyncCtx>,
	ctx: &mut NonSyncCtx,
	device: DeviceId,
	addr_sub: AddrSubnetEither,
	) -> error::Result<()> {
	map_addr_version!(
	addr_sub: AddrSubnetEither;
	crate::device::add_ip_addr_subnet(sync_ctx, ctx, device, addr_sub)
	)
	.map_err(From::from)
	}

	/// Delete an IP address on a device.
	pub fn del_ip_addr<NonSyncCtx: NonSyncContext>(
	sync_ctx: &mut SyncCtx<NonSyncCtx>,
	ctx: &mut NonSyncCtx,
	device: DeviceId,
	addr: IpAddr<SpecifiedAddr<Ipv4Addr>, SpecifiedAddr<Ipv6Addr>>,
	) -> error::Result<()> {
	map_addr_version!(
	addr: IpAddr;
	crate::device::del_ip_addr(sync_ctx, ctx, device, &addr)
	)
	.map_err(From::from)
	}

	/// Adds a route to the forwarding table.
	pub fn add_route<NonSyncCtx: NonSyncContext>(
	sync_ctx: &mut SyncCtx<NonSyncCtx>,
	ctx: &mut NonSyncCtx,
	entry: AddableEntryEither<DeviceId>,
	) -> Result<(), AddRouteError> {
	let (subnet, device, gateway) = entry.into_subnet_device_gateway();
	match (device, gateway) {
	(Some(device), None) => map_addr_version!(
	subnet: SubnetEither;
	crate::ip::add_device_route::<Ipv4, _, _>(sync_ctx, ctx, subnet, device),
	crate::ip::add_device_route::<Ipv6, _, _>(sync_ctx, ctx, subnet, device)
	)
	.map_err(From::from),
	(None, Some(next_hop)) => {
	let next_hop = next_hop.into();
	map_addr_version!(
	(subnet: SubnetEither, next_hop: IpAddr);
	crate::ip::add_route::<Ipv4, _, _>(sync_ctx, ctx, subnet, next_hop),
	crate::ip::add_route::<Ipv6, _, _>(sync_ctx, ctx, subnet, next_hop),
	unreachable!()
	)
	}
	x => todo!("TODO(https://fxbug.dev/96680): support setting gateway route with device; (device, gateway) = {:?}", x),
	}
	}

	/// Delete a route from the forwarding table, returning `Err` if no
	/// route was found to be deleted.
	pub fn del_route<NonSyncCtx: NonSyncContext>(
	sync_ctx: &mut SyncCtx<NonSyncCtx>,
	ctx: &mut NonSyncCtx,
	subnet: SubnetEither,
	) -> error::Result<()> {
	map_addr_version!(
	subnet: SubnetEither;
	crate::ip::del_route::<Ipv4, _, _>(sync_ctx, ctx, subnet),
	crate::ip::del_route::<Ipv6, _, _>(sync_ctx, ctx, subnet)
	)
	.map_err(From::from)
	}

	/// Get all the routes.
	pub fn get_all_routes<'a, NonSyncCtx: NonSyncContext>(
	ctx: &'a SyncCtx<NonSyncCtx>,
	) -> impl 'a + Iterator<Item = EntryEither<DeviceId>> {
	let v4_routes = ip::iter_all_routes::<_, Ipv4Addr>(ctx);
	let v6_routes = ip::iter_all_routes::<_, Ipv6Addr>(ctx);
	v4_routes.cloned().map(From::from).chain(v6_routes.cloned().map(From::from))
	}

	#[cfg(test)]
	mod tests {
	use net_types::{
	ip::{Ip, Ipv4, Ipv6},
	Witness,
	};

	use super::*;
	use crate::testutil::{DummyEventDispatcherBuilder, TestIpExt};

	fn test_add_remove_ip_addresses<I: Ip + TestIpExt>() {
	let config = I::DUMMY_CONFIG;
	let Ctx { mut sync_ctx, mut non_sync_ctx } = DummyEventDispatcherBuilder::default().build();
	let device = crate::add_ethernet_device(
	&mut sync_ctx,
	&mut non_sync_ctx,
	config.local_mac,
	Ipv6::MINIMUM_LINK_MTU.into(),
	);
	crate::device::testutil::enable_device(&mut sync_ctx, &mut non_sync_ctx, device);

	let ip: IpAddr = I::get_other_ip_address(1).get().into();
	let prefix = config.subnet.prefix();
	let addr_subnet = AddrSubnetEither::new(ip, prefix).unwrap();

	// IP doesn't exist initially.
	assert_eq!(get_all_ip_addr_subnets(&sync_ctx, device).find(\|&a\| a == addr_subnet), None);

	// Add IP (OK).
	let () = add_ip_addr_subnet(&mut sync_ctx, &mut non_sync_ctx, device, addr_subnet).unwrap();
	assert_eq!(
	get_all_ip_addr_subnets(&sync_ctx, device).find(\|&a\| a == addr_subnet),
	Some(addr_subnet)
	);

	// Add IP again (already exists).
	assert_eq!(
	add_ip_addr_subnet(&mut sync_ctx, &mut non_sync_ctx, device, addr_subnet).unwrap_err(),
	NetstackError::Exists
	);
	assert_eq!(
	get_all_ip_addr_subnets(&sync_ctx, device).find(\|&a\| a == addr_subnet),
	Some(addr_subnet)
	);

	// Add IP with different subnet (already exists).
	let wrong_addr_subnet = AddrSubnetEither::new(ip, prefix - 1).unwrap();
	assert_eq!(
	add_ip_addr_subnet(&mut sync_ctx, &mut non_sync_ctx, device, wrong_addr_subnet)
	.unwrap_err(),
	NetstackError::Exists
	);
	assert_eq!(
	get_all_ip_addr_subnets(&sync_ctx, device).find(\|&a\| a == addr_subnet),
	Some(addr_subnet)
	);

	let ip = SpecifiedAddr::new(ip).unwrap();
	// Del IP (ok).
	let () = del_ip_addr(&mut sync_ctx, &mut non_sync_ctx, device, ip.into()).unwrap();
	assert_eq!(get_all_ip_addr_subnets(&sync_ctx, device).find(\|&a\| a == addr_subnet), None);

	// Del IP again (not found).
	assert_eq!(
	del_ip_addr(&mut sync_ctx, &mut non_sync_ctx, device, ip.into()).unwrap_err(),
	NetstackError::NotFound
	);
	assert_eq!(get_all_ip_addr_subnets(&sync_ctx, device).find(\|&a\| a == addr_subnet), None);
	}

	#[test]
	fn test_add_remove_ipv4_addresses() {
	test_add_remove_ip_addresses::<Ipv4>();
	}

	#[test]
	fn test_add_remove_ipv6_addresses() {
	test_add_remove_ip_addresses::<Ipv6>();
	}
	}