// Copyright 2022 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.

//! An IP device.

pub(crate) mod dad;
mod integration;
pub(crate) mod route_discovery;
pub(crate) mod router_solicitation;
pub(crate) mod slaac;
pub(crate) mod state;

use alloc::{boxed::Box, vec::Vec};
use core::num::NonZeroU8;

#[cfg(test)]
use net_types::ip::IpVersion;
use net_types::{
    ip::{AddrSubnet, Ip, IpAddress as _, Ipv4, Ipv4Addr, Ipv6, Ipv6Addr},
    MulticastAddr, SpecifiedAddr, UnicastAddr,
};
use packet::{BufferMut, EmptyBuf, Serializer};
use packet_formats::utils::NonZeroDuration;

use crate::{
    context::{EventContext, InstantContext, RngContext, TimerContext, TimerHandler},
    error::{ExistsError, NotFoundError},
    ip::{
        device::{
            dad::{DadHandler, DadTimerId},
            route_discovery::{Ipv6DiscoveredRouteTimerId, RouteDiscoveryHandler},
            router_solicitation::{RsHandler, RsTimerId},
            slaac::{SlaacHandler, SlaacTimerId},
            state::{
                AddrConfig, AddressState, DelIpv6AddrReason, IpDeviceConfiguration, IpDeviceState,
                IpDeviceStateIpExt, Ipv4DeviceConfiguration, Ipv4DeviceState, Ipv6AddressEntry,
                Ipv6DeviceConfiguration, Ipv6DeviceState,
            },
        },
        gmp::{
            igmp::IgmpTimerId, mld::MldDelayedReportTimerId, GmpHandler, GroupJoinResult,
            GroupLeaveResult,
        },
        IpDeviceIdContext,
    },
    Instant,
};
#[cfg(test)]
use crate::{error::NotSupportedError, ip::IpDeviceId as _};

/// A timer ID for IPv4 devices.
#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
pub(crate) struct Ipv4DeviceTimerId<DeviceId>(IgmpTimerId<DeviceId>);

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

// If we are provided with an impl of `TimerContext<Ipv4DeviceTimerId<_>>`, then
// we can in turn provide an impl of `TimerContext` for IGMP.
impl_timer_context!(
    DeviceId,
    Ipv4DeviceTimerId<DeviceId>,
    IgmpTimerId<DeviceId>,
    Ipv4DeviceTimerId(id),
    id
);

/// Handle an IPv4 device timer firing.
pub(crate) fn handle_ipv4_timer<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: BufferIpDeviceContext<Ipv4, C, EmptyBuf>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    Ipv4DeviceTimerId(id): Ipv4DeviceTimerId<SC::DeviceId>,
) {
    TimerHandler::handle_timer(sync_ctx, ctx, id)
}

/// A timer ID for IPv6 devices.
#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
pub(crate) enum Ipv6DeviceTimerId<DeviceId> {
    Mld(MldDelayedReportTimerId<DeviceId>),
    Dad(DadTimerId<DeviceId>),
    Rs(RsTimerId<DeviceId>),
    RouteDiscovery(Ipv6DiscoveredRouteTimerId<DeviceId>),
    Slaac(SlaacTimerId<DeviceId>),
}

impl<DeviceId> From<MldDelayedReportTimerId<DeviceId>> for Ipv6DeviceTimerId<DeviceId> {
    fn from(id: MldDelayedReportTimerId<DeviceId>) -> Ipv6DeviceTimerId<DeviceId> {
        Ipv6DeviceTimerId::Mld(id)
    }
}

impl<DeviceId> From<DadTimerId<DeviceId>> for Ipv6DeviceTimerId<DeviceId> {
    fn from(id: DadTimerId<DeviceId>) -> Ipv6DeviceTimerId<DeviceId> {
        Ipv6DeviceTimerId::Dad(id)
    }
}

impl<DeviceId> From<RsTimerId<DeviceId>> for Ipv6DeviceTimerId<DeviceId> {
    fn from(id: RsTimerId<DeviceId>) -> Ipv6DeviceTimerId<DeviceId> {
        Ipv6DeviceTimerId::Rs(id)
    }
}

impl<DeviceId> From<Ipv6DiscoveredRouteTimerId<DeviceId>> for Ipv6DeviceTimerId<DeviceId> {
    fn from(id: Ipv6DiscoveredRouteTimerId<DeviceId>) -> Ipv6DeviceTimerId<DeviceId> {
        Ipv6DeviceTimerId::RouteDiscovery(id)
    }
}

impl<DeviceId> From<SlaacTimerId<DeviceId>> for Ipv6DeviceTimerId<DeviceId> {
    fn from(id: SlaacTimerId<DeviceId>) -> Ipv6DeviceTimerId<DeviceId> {
        Ipv6DeviceTimerId::Slaac(id)
    }
}

// If we are provided with an impl of `TimerContext<Ipv6DeviceTimerId<_>>`, then
// we can in turn provide an impl of `TimerContext` for MLD and DAD.
impl_timer_context!(
    DeviceId,
    Ipv6DeviceTimerId<DeviceId>,
    MldDelayedReportTimerId<DeviceId>,
    Ipv6DeviceTimerId::Mld(id),
    id
);
impl_timer_context!(
    DeviceId,
    Ipv6DeviceTimerId<DeviceId>,
    DadTimerId<DeviceId>,
    Ipv6DeviceTimerId::Dad(id),
    id
);
impl_timer_context!(
    DeviceId,
    Ipv6DeviceTimerId<DeviceId>,
    RsTimerId<DeviceId>,
    Ipv6DeviceTimerId::Rs(id),
    id
);
impl_timer_context!(
    DeviceId,
    Ipv6DeviceTimerId<DeviceId>,
    Ipv6DiscoveredRouteTimerId<DeviceId>,
    Ipv6DeviceTimerId::RouteDiscovery(id),
    id
);
impl_timer_context!(
    DeviceId,
    Ipv6DeviceTimerId<DeviceId>,
    SlaacTimerId<DeviceId>,
    Ipv6DeviceTimerId::Slaac(id),
    id
);

/// Handle an IPv6 device timer firing.
pub(crate) fn handle_ipv6_timer<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: BufferIpDeviceContext<Ipv6, C, EmptyBuf>
        + DadHandler<C>
        + RsHandler<C>
        + TimerHandler<C, Ipv6DiscoveredRouteTimerId<SC::DeviceId>>
        + TimerHandler<C, MldDelayedReportTimerId<SC::DeviceId>>
        + TimerHandler<C, SlaacTimerId<SC::DeviceId>>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    id: Ipv6DeviceTimerId<SC::DeviceId>,
) {
    match id {
        Ipv6DeviceTimerId::Mld(id) => TimerHandler::handle_timer(sync_ctx, ctx, id),
        Ipv6DeviceTimerId::Dad(id) => DadHandler::handle_timer(sync_ctx, ctx, id),
        Ipv6DeviceTimerId::Rs(id) => RsHandler::handle_timer(sync_ctx, ctx, id),
        Ipv6DeviceTimerId::RouteDiscovery(id) => TimerHandler::handle_timer(sync_ctx, ctx, id),
        Ipv6DeviceTimerId::Slaac(id) => TimerHandler::handle_timer(sync_ctx, ctx, id),
    }
}

/// An extension trait adding IP device properties.
pub(crate) trait IpDeviceIpExt<Instant, DeviceId>: IpDeviceStateIpExt<Instant> {
    type State: AsRef<IpDeviceState<Instant, Self>> + AsRef<IpDeviceConfiguration>;
    type Timer;
}

impl<I: Instant, DeviceId> IpDeviceIpExt<I, DeviceId> for Ipv4 {
    type State = Ipv4DeviceState<I>;
    type Timer = Ipv4DeviceTimerId<DeviceId>;
}

impl<I: Instant, DeviceId> IpDeviceIpExt<I, DeviceId> for Ipv6 {
    type State = Ipv6DeviceState<I>;
    type Timer = Ipv6DeviceTimerId<DeviceId>;
}

/// IP address assignment states.
#[derive(Eq, PartialEq, Debug, Copy, Clone)]
pub enum IpAddressState {
    /// The address is assigned to an interface and can be considered bound to
    /// it (all packets destined to the address will be accepted).
    Assigned,
    /// The address is considered unassigned to an interface for normal
    /// operations, but has the intention of being assigned in the future (e.g.
    /// once Duplicate Address Detection is completed).
    Tentative,
}

impl From<AddressState> for IpAddressState {
    fn from(state: AddressState) -> IpAddressState {
        match state {
            AddressState::Assigned => IpAddressState::Assigned,
            AddressState::Tentative { .. } => IpAddressState::Tentative,
        }
    }
}

#[derive(Debug)]
/// Events emitted from IP devices.
pub enum IpDeviceEvent<DeviceId, I: Ip> {
    /// Address was assigned.
    AddressAdded {
        /// The device.
        device: DeviceId,
        /// The new address.
        addr: AddrSubnet<I::Addr>,
        /// Initial address state.
        state: IpAddressState,
    },
    /// Address was unassigned.
    AddressRemoved {
        /// The device.
        device: DeviceId,
        /// The removed address.
        addr: I::Addr,
    },
    /// Address state changed.
    AddressStateChanged {
        /// The device.
        device: DeviceId,
        /// The address whose state was changed.
        addr: I::Addr,
        /// The new address state.
        state: IpAddressState,
    },
}

/// The non-synchronized execution context for IP devices.
pub(crate) trait IpDeviceNonSyncContext<
    I: IpDeviceIpExt<<Self as InstantContext>::Instant, DeviceId>,
    DeviceId,
>: RngContext + TimerContext<I::Timer> + EventContext<IpDeviceEvent<DeviceId, I>>
{
}
impl<
        DeviceId,
        I: IpDeviceIpExt<<C as InstantContext>::Instant, DeviceId>,
        C: RngContext + TimerContext<I::Timer> + EventContext<IpDeviceEvent<DeviceId, I>>,
    > IpDeviceNonSyncContext<I, DeviceId> for C
{
}

/// The execution context for IP devices.
pub(crate) trait IpDeviceContext<
    I: IpDeviceIpExt<C::Instant, Self::DeviceId>,
    C: IpDeviceNonSyncContext<I, Self::DeviceId>,
>: IpDeviceIdContext<I>
{
    /// Gets immutable access to an IP device's state.
    fn get_ip_device_state(&self, device_id: Self::DeviceId) -> &I::State;

    /// Gets mutable access to an IP device's state.
    fn get_ip_device_state_mut(&mut self, device_id: Self::DeviceId) -> &mut I::State;

    /// Returns an [`Iterator`] of IDs for all initialized devices.
    fn iter_devices(&self) -> Box<dyn Iterator<Item = Self::DeviceId> + '_>;

    /// Gets the MTU for a device.
    ///
    /// The MTU is the maximum size of an IP packet.
    fn get_mtu(&self, device_id: Self::DeviceId) -> u32;

    /// Joins the link-layer multicast group associated with the given IP
    /// multicast group.
    fn join_link_multicast_group(
        &mut self,
        ctx: &mut C,
        device_id: Self::DeviceId,
        multicast_addr: MulticastAddr<I::Addr>,
    );

    /// Leaves the link-layer multicast group associated with the given IP
    /// multicast group.
    fn leave_link_multicast_group(
        &mut self,
        ctx: &mut C,
        device_id: Self::DeviceId,
        multicast_addr: MulticastAddr<I::Addr>,
    );
}

/// The execution context for an IPv6 device.
pub(crate) trait Ipv6DeviceContext<C: IpDeviceNonSyncContext<Ipv6, Self::DeviceId>>:
    IpDeviceContext<Ipv6, C>
{
    /// Gets the device's link-layer address bytes, if the device supports
    /// link-layer addressing.
    fn get_link_layer_addr_bytes(&self, device_id: Self::DeviceId) -> Option<&[u8]>;

    /// Gets the device's EUI-64 based interface identifier.
    ///
    /// A `None` value indicates the device does not have an EUI-64 based
    /// interface identifier.
    fn get_eui64_iid(&self, device_id: Self::DeviceId) -> Option<[u8; 8]>;
}

/// An implementation of an IP device.
pub(crate) trait IpDeviceHandler<I: Ip, C>: IpDeviceIdContext<I> {
    fn is_router_device(&self, device_id: Self::DeviceId) -> bool;
}

impl<
        I: IpDeviceIpExt<C::Instant, SC::DeviceId>,
        C: IpDeviceNonSyncContext<I, SC::DeviceId>,
        SC: IpDeviceContext<I, C>,
    > IpDeviceHandler<I, C> for SC
{
    fn is_router_device(&self, device_id: Self::DeviceId) -> bool {
        AsRef::<IpDeviceState<_, _>>::as_ref(self.get_ip_device_state(device_id)).routing_enabled
    }
}

/// An implementation of an IPv6 device.
pub(crate) trait Ipv6DeviceHandler<C>: IpDeviceHandler<Ipv6, C> {
    /// Gets the device's link-layer address bytes, if the device supports
    /// link-layer addressing.
    fn get_link_layer_addr_bytes(&self, device_id: Self::DeviceId) -> Option<&[u8]>;

    /// Sets the discovered retransmit timer for the device.
    fn set_discovered_retrans_timer(
        &mut self,
        ctx: &mut C,
        device_id: Self::DeviceId,
        retrans_timer: NonZeroDuration,
    );

    /// Removes a tentative address as a result of duplicate address detection.
    ///
    /// Returns whether or not the address was removed. That is, this method
    /// returns `Ok(true)` when the address was tentatively assigned and
    /// `Ok(false)` if the address is fully assigned.
    fn remove_duplicate_tentative_address(
        &mut self,
        ctx: &mut C,
        device_id: Self::DeviceId,
        addr: UnicastAddr<Ipv6Addr>,
    ) -> Result<bool, NotFoundError>;
}

impl<
        C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
        SC: Ipv6DeviceContext<C> + GmpHandler<Ipv6, C> + DadHandler<C> + SlaacHandler<C>,
    > Ipv6DeviceHandler<C> for SC
{
    fn get_link_layer_addr_bytes(&self, device_id: Self::DeviceId) -> Option<&[u8]> {
        Ipv6DeviceContext::get_link_layer_addr_bytes(self, device_id)
    }

    fn set_discovered_retrans_timer(
        &mut self,
        _ctx: &mut C,
        device_id: Self::DeviceId,
        retrans_timer: NonZeroDuration,
    ) {
        self.get_ip_device_state_mut(device_id).retrans_timer = retrans_timer;
    }

    fn remove_duplicate_tentative_address(
        &mut self,
        ctx: &mut C,
        device_id: Self::DeviceId,
        addr: UnicastAddr<Ipv6Addr>,
    ) -> Result<bool, NotFoundError> {
        let address_state = self
            .get_ip_device_state(device_id)
            .ip_state
            .iter_addrs()
            .find_map(
                |Ipv6AddressEntry { addr_sub, state: address_state, config: _, deprecated: _ }| {
                    (addr_sub.addr() == addr).then(|| (*address_state).into())
                },
            )
            .ok_or(NotFoundError)?;

        Ok(match address_state {
            IpAddressState::Tentative => {
                del_ipv6_addr_with_reason(
                    self,
                    ctx,
                    device_id,
                    &addr.into_specified(),
                    DelIpv6AddrReason::DadFailed,
                )
                .unwrap();
                true
            }
            IpAddressState::Assigned => false,
        })
    }
}

/// The execution context for an IP device with a buffer.
pub(crate) trait BufferIpDeviceContext<
    I: IpDeviceIpExt<C::Instant, Self::DeviceId>,
    C: IpDeviceNonSyncContext<I, Self::DeviceId>,
    B: BufferMut,
>: IpDeviceContext<I, C>
{
    /// Sends an IP packet through the device.
    fn send_ip_frame<S: Serializer<Buffer = B>>(
        &mut self,
        ctx: &mut C,
        device_id: Self::DeviceId,
        local_addr: SpecifiedAddr<I::Addr>,
        body: S,
    ) -> Result<(), S>;
}

fn enable_ipv6_device<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: Ipv6DeviceContext<C> + GmpHandler<Ipv6, C> + RsHandler<C> + DadHandler<C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
) {
    let Ipv6DeviceState {
        ip_state: _,
        config:
            Ipv6DeviceConfiguration {
                dad_transmits,
                max_router_solicitations: _,
                slaac_config: _,
                ip_config: IpDeviceConfiguration { ip_enabled: _, gmp_enabled: _ },
            },
        retrans_timer: _,
        router_soliciations_remaining: _,
        route_discovery: _,
    } = sync_ctx.get_ip_device_state_mut(device_id);
    let dad_transmits = *dad_transmits;

    // All nodes should join the all-nodes multicast group.
    join_ip_multicast(sync_ctx, ctx, device_id, Ipv6::ALL_NODES_LINK_LOCAL_MULTICAST_ADDRESS);
    GmpHandler::gmp_handle_maybe_enabled(sync_ctx, ctx, device_id);

    // Perform DAD for all addresses when enabling a device.
    //
    // We have to do this for all addresses (including ones that had DAD
    // performed) as while the device was disabled, another node could have
    // assigned the address and we wouldn't have responded to its DAD
    // solicitations.
    sync_ctx
        .get_ip_device_state_mut(device_id)
        .ip_state
        .iter_addrs_mut()
        .map(|Ipv6AddressEntry { addr_sub, state, config: _, deprecated: _ }| {
            *state = AddressState::Tentative { dad_transmits_remaining: dad_transmits };
            addr_sub.ipv6_unicast_addr()
        })
        .collect::<Vec<_>>()
        .into_iter()
        .for_each(|addr| {
            ctx.on_event(IpDeviceEvent::AddressStateChanged {
                device: device_id,
                addr: *addr,
                state: IpAddressState::Tentative,
            });
            DadHandler::do_duplicate_address_detection(sync_ctx, ctx, device_id, addr);
        });

    // TODO(https://fxbug.dev/95946): Generate link-local address with opaque
    // IIDs.
    if let Some(iid) = sync_ctx.get_eui64_iid(device_id) {
        let link_local_addr_sub = {
            let mut addr = [0; 16];
            addr[0..2].copy_from_slice(&[0xfe, 0x80]);
            addr[(Ipv6::UNICAST_INTERFACE_IDENTIFIER_BITS / 8) as usize..].copy_from_slice(&iid);

            AddrSubnet::new(
                Ipv6Addr::from(addr),
                Ipv6Addr::BYTES * 8 - Ipv6::UNICAST_INTERFACE_IDENTIFIER_BITS,
            )
            .expect("valid link-local address")
        };

        match add_ipv6_addr_subnet(
            sync_ctx,
            ctx,
            device_id,
            link_local_addr_sub,
            AddrConfig::SLAAC_LINK_LOCAL,
        ) {
            Ok(()) => {}
            Err(ExistsError) => {
                // The address may have been added by admin action so it is safe
                // to swallow the exists error.
            }
        }
    }

    // As per RFC 4861 section 6.3.7,
    //
    //    A host sends Router Solicitations to the all-routers multicast
    //    address.
    //
    // If we are operating as a router, we do not solicit routers.
    if !is_ipv6_routing_enabled(sync_ctx, device_id) {
        RsHandler::start_router_solicitation(sync_ctx, ctx, device_id);
    }
}

fn disable_ipv6_device<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: Ipv6DeviceContext<C>
        + GmpHandler<Ipv6, C>
        + RsHandler<C>
        + DadHandler<C>
        + RouteDiscoveryHandler<C>
        + SlaacHandler<C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
) {
    SlaacHandler::remove_all_slaac_addresses(sync_ctx, ctx, device_id);

    RouteDiscoveryHandler::invalidate_routes(sync_ctx, ctx, device_id);

    RsHandler::stop_router_solicitation(sync_ctx, ctx, device_id);

    // Delete the link-local address generated when enabling the device and stop
    // DAD on the other addresses.
    sync_ctx
        .get_ip_device_state(device_id)
        .ip_state
        .iter_addrs()
        .map(|Ipv6AddressEntry { addr_sub, state: _, config, deprecated: _ }| {
            (addr_sub.ipv6_unicast_addr(), *config)
        })
        .collect::<Vec<_>>()
        .into_iter()
        .for_each(|(addr, config)| {
            if config == AddrConfig::SLAAC_LINK_LOCAL {
                del_ipv6_addr_with_reason(
                    sync_ctx,
                    ctx,
                    device_id,
                    &addr.into_specified(),
                    DelIpv6AddrReason::ManualAction,
                )
                .expect("delete listed address")
            } else {
                DadHandler::stop_duplicate_address_detection(sync_ctx, ctx, device_id, addr)
            }
        });

    GmpHandler::gmp_handle_disabled(sync_ctx, ctx, device_id);
    leave_ip_multicast(sync_ctx, ctx, device_id, Ipv6::ALL_NODES_LINK_LOCAL_MULTICAST_ADDRESS);
}

fn enable_ipv4_device<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C> + GmpHandler<Ipv4, C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
) {
    // All systems should join the all-systems multicast group.
    join_ip_multicast(sync_ctx, ctx, device_id, Ipv4::ALL_SYSTEMS_MULTICAST_ADDRESS);
    GmpHandler::gmp_handle_maybe_enabled(sync_ctx, ctx, device_id);
}

fn disable_ipv4_device<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C> + GmpHandler<Ipv4, C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
) {
    GmpHandler::gmp_handle_disabled(sync_ctx, ctx, device_id);
    leave_ip_multicast(sync_ctx, ctx, device_id, Ipv4::ALL_SYSTEMS_MULTICAST_ADDRESS);
}

/// Gets the IPv4 address and subnet pairs associated with this device.
///
/// Returns an [`Iterator`] of `AddrSubnet`.
pub(crate) fn get_assigned_ipv4_addr_subnets<
    'a,
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C>,
>(
    sync_ctx: &'a SC,
    device_id: SC::DeviceId,
) -> impl Iterator<Item = AddrSubnet<Ipv4Addr>> + 'a {
    sync_ctx.get_ip_device_state(device_id).ip_state.iter_addrs().cloned()
}

/// Gets the IPv6 address and subnet pairs associated with this device which are
/// in the assigned state.
///
/// Tentative IP addresses (addresses which are not yet fully bound to a device)
/// and deprecated IP addresses (addresses which have been assigned but should
/// no longer be used for new connections) will not be returned by
/// `get_assigned_ipv6_addr_subnets`.
///
/// Returns an [`Iterator`] of `AddrSubnet`.
///
/// See [`Tentative`] and [`AddrSubnet`] for more information.
pub(crate) fn get_assigned_ipv6_addr_subnets<
    'a,
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: IpDeviceContext<Ipv6, C>,
>(
    sync_ctx: &'a SC,
    device_id: SC::DeviceId,
) -> impl Iterator<Item = AddrSubnet<Ipv6Addr>> + 'a {
    sync_ctx.get_ip_device_state(device_id).ip_state.iter_addrs().filter_map(|a| {
        if a.state.is_assigned() {
            Some((*a.addr_sub()).to_witness())
        } else {
            None
        }
    })
}

/// Gets a single IPv4 address and subnet for a device.
pub(super) fn get_ipv4_addr_subnet<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C>,
>(
    sync_ctx: &SC,
    device_id: SC::DeviceId,
) -> Option<AddrSubnet<Ipv4Addr>> {
    get_assigned_ipv4_addr_subnets(sync_ctx, device_id).nth(0)
}

/// Gets the state associated with an IPv4 device.
pub(crate) fn get_ipv4_device_state<
    'a,
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C>,
>(
    sync_ctx: &'a SC,
    device_id: SC::DeviceId,
) -> &'a IpDeviceState<C::Instant, Ipv4> {
    &sync_ctx.get_ip_device_state(device_id).ip_state
}

/// Gets the state associated with an IPv6 device.
pub(crate) fn get_ipv6_device_state<
    'a,
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: IpDeviceContext<Ipv6, C>,
>(
    sync_ctx: &'a SC,
    device_id: SC::DeviceId,
) -> &'a IpDeviceState<C::Instant, Ipv6> {
    &sync_ctx.get_ip_device_state(device_id).ip_state
}

/// Gets the hop limit for new IPv6 packets that will be sent out from `device`.
pub(crate) fn get_ipv6_hop_limit<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: IpDeviceContext<Ipv6, C>,
>(
    sync_ctx: &SC,
    device: SC::DeviceId,
) -> NonZeroU8 {
    get_ipv6_device_state(sync_ctx, device).default_hop_limit
}

/// Iterates over all of the IPv4 devices in the stack.
pub(super) fn iter_ipv4_devices<
    'a,
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C>,
>(
    sync_ctx: &'a SC,
) -> impl Iterator<Item = (SC::DeviceId, &'a IpDeviceState<C::Instant, Ipv4>)> + 'a {
    sync_ctx.iter_devices().map(move |device| (device, get_ipv4_device_state(sync_ctx, device)))
}

/// Iterates over all of the IPv6 devices in the stack.
pub(super) fn iter_ipv6_devices<
    'a,
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: IpDeviceContext<Ipv6, C>,
>(
    sync_ctx: &'a SC,
) -> impl Iterator<Item = (SC::DeviceId, &'a IpDeviceState<C::Instant, Ipv6>)> + 'a {
    sync_ctx.iter_devices().map(move |device| (device, get_ipv6_device_state(sync_ctx, device)))
}

/// Is IPv4 packet routing enabled on `device`?
pub(crate) fn is_ipv4_routing_enabled<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C>,
>(
    sync_ctx: &SC,
    device_id: SC::DeviceId,
) -> bool {
    get_ipv4_device_state(sync_ctx, device_id).routing_enabled
}

/// Is IPv6 packet routing enabled on `device`?
pub(crate) fn is_ipv6_routing_enabled<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: IpDeviceContext<Ipv6, C>,
>(
    sync_ctx: &SC,
    device_id: SC::DeviceId,
) -> bool {
    get_ipv6_device_state(sync_ctx, device_id).routing_enabled
}

/// Enables or disables IP packet routing on `device`.
#[cfg(test)]
pub(crate) fn set_routing_enabled<
    C: IpDeviceNonSyncContext<Ipv4, <SC as IpDeviceIdContext<Ipv4>>::DeviceId>
        + IpDeviceNonSyncContext<Ipv6, <SC as IpDeviceIdContext<Ipv6>>::DeviceId>,
    SC: IpDeviceContext<Ipv4, C> + Ipv6DeviceContext<C> + GmpHandler<Ipv6, C> + RsHandler<C>,
    I: Ip,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device: <SC as IpDeviceIdContext<Ipv6>>::DeviceId,
    enabled: bool,
) -> Result<(), NotSupportedError>
where
    SC: IpDeviceIdContext<Ipv6, DeviceId = <SC as IpDeviceIdContext<Ipv4>>::DeviceId>,
{
    match I::VERSION {
        IpVersion::V4 => set_ipv4_routing_enabled(sync_ctx, ctx, device, enabled),
        IpVersion::V6 => set_ipv6_routing_enabled(sync_ctx, ctx, device, enabled),
    }
}

/// Enables or disables IPv4 packet routing on `device_id`.
#[cfg(test)]
fn set_ipv4_routing_enabled<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C>,
>(
    sync_ctx: &mut SC,
    _ctx: &mut C,
    device_id: SC::DeviceId,
    enabled: bool,
) -> Result<(), NotSupportedError> {
    if device_id.is_loopback() {
        return Err(NotSupportedError);
    }

    sync_ctx.get_ip_device_state_mut(device_id).ip_state.routing_enabled = enabled;
    Ok(())
}

/// Enables or disables IPv4 packet routing on `device_id`.
///
/// When routing is enabled/disabled, the interface will leave/join the all
/// routers link-local multicast group and stop/start soliciting routers.
///
/// Does nothing if the routing status does not change as a consequence of this
/// call.
#[cfg(test)]
pub(crate) fn set_ipv6_routing_enabled<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: Ipv6DeviceContext<C> + GmpHandler<Ipv6, C> + RsHandler<C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    enabled: bool,
) -> Result<(), NotSupportedError> {
    if device_id.is_loopback() {
        return Err(NotSupportedError);
    }

    if is_ipv6_routing_enabled(sync_ctx, device_id) == enabled {
        return Ok(());
    }

    if enabled {
        RsHandler::stop_router_solicitation(sync_ctx, ctx, device_id);
        sync_ctx.get_ip_device_state_mut(device_id).ip_state.routing_enabled = true;
        join_ip_multicast(sync_ctx, ctx, device_id, Ipv6::ALL_ROUTERS_LINK_LOCAL_MULTICAST_ADDRESS);
    } else {
        leave_ip_multicast(
            sync_ctx,
            ctx,
            device_id,
            Ipv6::ALL_ROUTERS_LINK_LOCAL_MULTICAST_ADDRESS,
        );
        sync_ctx.get_ip_device_state_mut(device_id).ip_state.routing_enabled = false;
        RsHandler::start_router_solicitation(sync_ctx, ctx, device_id);
    }

    Ok(())
}

/// Adds `device_id` to a multicast group `multicast_addr`.
///
/// Calling `join_ip_multicast` multiple times is completely safe. A counter
/// will be kept for the number of times `join_ip_multicast` has been called
/// with the same `device_id` and `multicast_addr` pair. To completely leave a
/// multicast group, [`leave_ip_multicast`] must be called the same number of
/// times `join_ip_multicast` has been called for the same `device_id` and
/// `multicast_addr` pair. The first time `join_ip_multicast` is called for a
/// new `device` and `multicast_addr` pair, the device will actually join the
/// multicast group.
pub(crate) fn join_ip_multicast<
    I: IpDeviceIpExt<C::Instant, SC::DeviceId>,
    C: IpDeviceNonSyncContext<I, SC::DeviceId>,
    SC: IpDeviceContext<I, C> + GmpHandler<I, C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    multicast_addr: MulticastAddr<I::Addr>,
) {
    match sync_ctx.gmp_join_group(ctx, device_id, multicast_addr) {
        GroupJoinResult::Joined(()) => {
            sync_ctx.join_link_multicast_group(ctx, device_id, multicast_addr)
        }
        GroupJoinResult::AlreadyMember => {}
    }
}

/// Removes `device_id` from a multicast group `multicast_addr`.
///
/// `leave_ip_multicast` will attempt to remove `device_id` from a multicast
/// group `multicast_addr`. `device_id` may have "joined" the same multicast
/// address multiple times, so `device_id` will only leave the multicast group
/// once `leave_ip_multicast` has been called for each corresponding
/// [`join_ip_multicast`]. That is, if `join_ip_multicast` gets called 3
/// times and `leave_ip_multicast` gets called two times (after all 3
/// `join_ip_multicast` calls), `device_id` will still be in the multicast
/// group until the next (final) call to `leave_ip_multicast`.
///
/// # Panics
///
/// If `device_id` is not currently in the multicast group `multicast_addr`.
pub(crate) fn leave_ip_multicast<
    I: IpDeviceIpExt<C::Instant, SC::DeviceId>,
    C: IpDeviceNonSyncContext<I, SC::DeviceId>,
    SC: IpDeviceContext<I, C> + GmpHandler<I, C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    multicast_addr: MulticastAddr<I::Addr>,
) {
    match sync_ctx.gmp_leave_group(ctx, device_id, multicast_addr) {
        GroupLeaveResult::Left(()) => {
            sync_ctx.leave_link_multicast_group(ctx, device_id, multicast_addr)
        }
        GroupLeaveResult::StillMember => {}
        GroupLeaveResult::NotMember => panic!(
            "attempted to leave IP multicast group we were not a member of: {}",
            multicast_addr,
        ),
    }
}

/// Adds an IPv4 address and associated subnet to this device.
pub(crate) fn add_ipv4_addr_subnet<
    SC: BufferIpDeviceContext<Ipv4, C, EmptyBuf>,
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    addr_sub: AddrSubnet<Ipv4Addr>,
) -> Result<(), ExistsError> {
    sync_ctx.get_ip_device_state_mut(device_id).ip_state.add_addr(addr_sub).map(|()| {
        ctx.on_event(IpDeviceEvent::AddressAdded {
            device: device_id,
            addr: addr_sub,
            state: IpAddressState::Assigned,
        })
    })
}

/// Adds an IPv6 address (with duplicate address detection) and associated
/// subnet to this device and joins the address's solicited-node multicast
/// group.
///
/// `config` is the way this address is being configured. See [`AddrConfig`]
/// for more details.
pub(crate) fn add_ipv6_addr_subnet<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: Ipv6DeviceContext<C> + GmpHandler<Ipv6, C> + DadHandler<C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    addr_sub: AddrSubnet<Ipv6Addr>,
    config: AddrConfig<C::Instant>,
) -> Result<(), ExistsError> {
    let Ipv6DeviceState {
        ref mut ip_state,
        config:
            Ipv6DeviceConfiguration {
                dad_transmits,
                max_router_solicitations: _,
                slaac_config: _,
                ip_config: IpDeviceConfiguration { ip_enabled, gmp_enabled: _ },
            },
        retrans_timer: _,
        router_soliciations_remaining: _,
        route_discovery: _,
    } = sync_ctx.get_ip_device_state_mut(device_id);
    let ip_enabled = *ip_enabled;

    let addr_sub = addr_sub.to_unicast();
    ip_state
        .add_addr(Ipv6AddressEntry::new(
            addr_sub,
            AddressState::Tentative { dad_transmits_remaining: *dad_transmits },
            config,
        ))
        .map(|()| {
            // As per RFC 4861 section 5.6.2,
            //
            //   Before sending a Neighbor Solicitation, an interface MUST join
            //   the all-nodes multicast address and the solicited-node
            //   multicast address of the tentative address.
            //
            // Note that we join the all-nodes multicast address on interface
            // enable.
            join_ip_multicast(
                sync_ctx,
                ctx,
                device_id,
                addr_sub.addr().to_solicited_node_address(),
            );

            ctx.on_event(IpDeviceEvent::AddressAdded {
                device: device_id,
                addr: addr_sub.to_witness(),
                state: IpAddressState::Tentative,
            });

            // NB: We don't start DAD if the device is disabled. DAD will be
            // performed when the device is enabled for all addressed.
            if ip_enabled {
                DadHandler::do_duplicate_address_detection(
                    sync_ctx,
                    ctx,
                    device_id,
                    addr_sub.addr(),
                );
            }
        })
}

/// Removes an IPv4 address and associated subnet from this device.
pub(crate) fn del_ipv4_addr<
    SC: BufferIpDeviceContext<Ipv4, C, EmptyBuf>,
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    addr: &SpecifiedAddr<Ipv4Addr>,
) -> Result<(), NotFoundError> {
    sync_ctx.get_ip_device_state_mut(device_id).ip_state.remove_addr(&addr).map(|addr| {
        ctx.on_event(IpDeviceEvent::AddressRemoved { device: device_id, addr: *addr.addr() })
    })
}

/// Removes an IPv6 address and associated subnet from this device.
pub(crate) fn del_ipv6_addr_with_reason<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: Ipv6DeviceContext<C> + GmpHandler<Ipv6, C> + DadHandler<C> + SlaacHandler<C>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    addr: &SpecifiedAddr<Ipv6Addr>,
    reason: DelIpv6AddrReason,
) -> Result<(), NotFoundError> {
    let Ipv6AddressEntry { addr_sub, state: _, config, deprecated: _ } =
        sync_ctx.get_ip_device_state_mut(device_id).ip_state.remove_addr(&addr)?;
    let addr = addr_sub.addr();
    DadHandler::stop_duplicate_address_detection(sync_ctx, ctx, device_id, addr);
    leave_ip_multicast(sync_ctx, ctx, device_id, addr.to_solicited_node_address());

    match config {
        AddrConfig::Slaac(s) => {
            SlaacHandler::on_address_removed(sync_ctx, ctx, device_id, addr_sub, s, reason)
        }
        AddrConfig::Manual => {}
    }

    ctx.on_event(IpDeviceEvent::AddressRemoved { device: device_id, addr: *addr_sub.addr() });

    Ok(())
}

/// Sends an IP packet through the device.
pub(crate) fn send_ip_frame<
    I: IpDeviceIpExt<C::Instant, SC::DeviceId>,
    C: IpDeviceNonSyncContext<I, SC::DeviceId>,
    SC: BufferIpDeviceContext<I, C, B>,
    B: BufferMut,
    S: Serializer<Buffer = B>,
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    local_addr: SpecifiedAddr<I::Addr>,
    body: S,
) -> Result<(), S> {
    is_ip_device_enabled(sync_ctx, device_id)
        .then(|| sync_ctx.send_ip_frame(ctx, device_id, local_addr, body))
        .unwrap_or(Ok(()))
}

pub(crate) fn get_ipv4_configuration<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C>,
>(
    sync_ctx: &SC,
    device_id: SC::DeviceId,
) -> Ipv4DeviceConfiguration {
    sync_ctx.get_ip_device_state(device_id).config.clone()
}

pub(crate) fn get_ipv6_configuration<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: IpDeviceContext<Ipv6, C>,
>(
    sync_ctx: &SC,
    device_id: SC::DeviceId,
) -> Ipv6DeviceConfiguration {
    sync_ctx.get_ip_device_state(device_id).config.clone()
}

/// Updates the IPv4 Configuration for the device.
pub(crate) fn update_ipv4_configuration<
    C: IpDeviceNonSyncContext<Ipv4, SC::DeviceId>,
    SC: IpDeviceContext<Ipv4, C> + GmpHandler<Ipv4, C>,
    F: FnOnce(&mut Ipv4DeviceConfiguration),
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    update_cb: F,
) {
    let config = &mut sync_ctx.get_ip_device_state_mut(device_id).config;
    let Ipv4DeviceConfiguration {
        ip_config:
            IpDeviceConfiguration { ip_enabled: prev_ip_enabled, gmp_enabled: prev_gmp_enabled },
    } = *config;

    update_cb(config);

    let Ipv4DeviceConfiguration {
        ip_config:
            IpDeviceConfiguration { ip_enabled: next_ip_enabled, gmp_enabled: next_gmp_enabled },
    } = *config;

    if !prev_ip_enabled && next_ip_enabled {
        enable_ipv4_device(sync_ctx, ctx, device_id);
    } else if prev_ip_enabled && !next_ip_enabled {
        disable_ipv4_device(sync_ctx, ctx, device_id);
    }

    if !prev_gmp_enabled && next_gmp_enabled {
        GmpHandler::gmp_handle_maybe_enabled(sync_ctx, ctx, device_id);
    } else if prev_gmp_enabled && !next_gmp_enabled {
        GmpHandler::gmp_handle_disabled(sync_ctx, ctx, device_id);
    }
}

pub(super) fn is_ip_device_enabled<
    I: IpDeviceIpExt<C::Instant, SC::DeviceId>,
    C: IpDeviceNonSyncContext<I, SC::DeviceId>,
    SC: IpDeviceContext<I, C>,
>(
    sync_ctx: &SC,
    device_id: SC::DeviceId,
) -> bool {
    AsRef::<IpDeviceConfiguration>::as_ref(sync_ctx.get_ip_device_state(device_id)).ip_enabled
}

/// Updates the IPv6 Configuration for the device.
pub(crate) fn update_ipv6_configuration<
    C: IpDeviceNonSyncContext<Ipv6, SC::DeviceId>,
    SC: Ipv6DeviceContext<C>
        + GmpHandler<Ipv6, C>
        + RsHandler<C>
        + DadHandler<C>
        + RouteDiscoveryHandler<C>
        + SlaacHandler<C>,
    F: FnOnce(&mut Ipv6DeviceConfiguration),
>(
    sync_ctx: &mut SC,
    ctx: &mut C,
    device_id: SC::DeviceId,
    update_cb: F,
) {
    let config = &mut sync_ctx.get_ip_device_state_mut(device_id).config;
    let Ipv6DeviceConfiguration {
        dad_transmits: _,
        max_router_solicitations: _,
        slaac_config: _,
        ip_config:
            IpDeviceConfiguration { ip_enabled: prev_ip_enabled, gmp_enabled: prev_gmp_enabled },
    } = *config;

    update_cb(config);

    let Ipv6DeviceConfiguration {
        dad_transmits: _,
        max_router_solicitations: _,
        slaac_config: _,
        ip_config:
            IpDeviceConfiguration { ip_enabled: next_ip_enabled, gmp_enabled: next_gmp_enabled },
    } = *config;

    if !prev_ip_enabled && next_ip_enabled {
        enable_ipv6_device(sync_ctx, ctx, device_id);
    } else if prev_ip_enabled && !next_ip_enabled {
        disable_ipv6_device(sync_ctx, ctx, device_id);
    }

    if !prev_gmp_enabled && next_gmp_enabled {
        GmpHandler::gmp_handle_maybe_enabled(sync_ctx, ctx, device_id);
    } else if prev_gmp_enabled && !next_gmp_enabled {
        GmpHandler::gmp_handle_disabled(sync_ctx, ctx, device_id);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use alloc::vec;
    use fakealloc::collections::HashSet;

    use net_types::ip::Ipv6;

    use crate::{
        ip::gmp::GmpDelayedReportTimerId,
        testutil::{assert_empty, DummyCtx, DummyNonSyncCtx, DummySyncCtx, TestIpExt as _},
        Ctx, StackStateBuilder, TimerId, TimerIdInner,
    };

    #[test]
    fn enable_disable_ipv6() {
        let DummyCtx { mut sync_ctx, mut non_sync_ctx } =
            Ctx::new(StackStateBuilder::default().build());
        non_sync_ctx.timer_ctx().assert_no_timers_installed();
        let local_mac = Ipv6::DUMMY_CONFIG.local_mac;
        let device_id =
            sync_ctx.state.device.add_ethernet_device(local_mac, Ipv6::MINIMUM_LINK_MTU.into());
        update_ipv6_configuration(&mut sync_ctx, &mut non_sync_ctx, device_id, |config| {
            config.ip_config.gmp_enabled = true;

            // Doesn't matter as long as we perform DAD and router
            // solicitation.
            config.dad_transmits = NonZeroU8::new(1);
            config.max_router_solicitations = NonZeroU8::new(1);
        });
        non_sync_ctx.timer_ctx().assert_no_timers_installed();

        let ll_addr = local_mac.to_ipv6_link_local();

        // Enable the device and observe an auto-generated link-local address,
        // router solicitation and DAD for the auto-generated address.
        let test_enable_device =
            |sync_ctx: &mut DummySyncCtx,
             non_sync_ctx: &mut DummyNonSyncCtx,
             extra_group: Option<MulticastAddr<Ipv6Addr>>| {
                update_ipv6_configuration(sync_ctx, non_sync_ctx, device_id, |config| {
                    config.ip_config.ip_enabled = true;
                });
                assert_eq!(
                    IpDeviceContext::<Ipv6, _>::get_ip_device_state(sync_ctx, device_id)
                        .ip_state
                        .iter_addrs()
                        .map(|Ipv6AddressEntry { addr_sub, state: _, config: _, deprecated: _ }| {
                            addr_sub.ipv6_unicast_addr()
                        })
                        .collect::<HashSet<_>>(),
                    HashSet::from([ll_addr.ipv6_unicast_addr()]),
                    "enabled device expected to generate link-local address"
                );
                let mut timers = vec![
                    (
                        TimerId(TimerIdInner::Ipv6Device(Ipv6DeviceTimerId::Rs(RsTimerId {
                            device_id,
                        }))),
                        ..,
                    ),
                    (
                        TimerId(TimerIdInner::Ipv6Device(Ipv6DeviceTimerId::Dad(DadTimerId {
                            device_id,
                            addr: ll_addr.ipv6_unicast_addr(),
                        }))),
                        ..,
                    ),
                    (
                        TimerId(TimerIdInner::Ipv6Device(Ipv6DeviceTimerId::Mld(
                            MldDelayedReportTimerId(GmpDelayedReportTimerId {
                                device: device_id,
                                group_addr: local_mac
                                    .to_ipv6_link_local()
                                    .addr()
                                    .to_solicited_node_address(),
                            })
                            .into(),
                        ))),
                        ..,
                    ),
                ];
                if let Some(group_addr) = extra_group {
                    timers.push((
                        TimerId(TimerIdInner::Ipv6Device(Ipv6DeviceTimerId::Mld(
                            MldDelayedReportTimerId(GmpDelayedReportTimerId {
                                device: device_id,
                                group_addr,
                            })
                            .into(),
                        ))),
                        ..,
                    ))
                }
                non_sync_ctx.timer_ctx().assert_timers_installed(timers);
            };
        test_enable_device(&mut sync_ctx, &mut non_sync_ctx, None);

        let test_disable_device =
            |sync_ctx: &mut DummySyncCtx, non_sync_ctx: &mut DummyNonSyncCtx| {
                update_ipv6_configuration(sync_ctx, non_sync_ctx, device_id, |config| {
                    config.ip_config.ip_enabled = false;
                });
                non_sync_ctx.timer_ctx().assert_no_timers_installed();
            };
        test_disable_device(&mut sync_ctx, &mut non_sync_ctx);
        assert_empty(
            IpDeviceContext::<Ipv6, _>::get_ip_device_state(&sync_ctx, device_id)
                .ip_state
                .iter_addrs(),
        );

        let multicast_addr = Ipv6::ALL_ROUTERS_LINK_LOCAL_MULTICAST_ADDRESS;
        join_ip_multicast::<Ipv6, _, _>(
            &mut sync_ctx,
            &mut non_sync_ctx,
            device_id,
            multicast_addr,
        );
        add_ipv6_addr_subnet(
            &mut sync_ctx,
            &mut non_sync_ctx,
            device_id,
            ll_addr.to_witness(),
            AddrConfig::Manual,
        )
        .expect("add MAC based IPv6 link-local address");
        assert_eq!(
            IpDeviceContext::<Ipv6, _>::get_ip_device_state(&sync_ctx, device_id)
                .ip_state
                .iter_addrs()
                .map(|Ipv6AddressEntry { addr_sub, state: _, config: _, deprecated: _ }| {
                    addr_sub.ipv6_unicast_addr()
                })
                .collect::<HashSet<_>>(),
            HashSet::from([ll_addr.ipv6_unicast_addr()])
        );

        test_enable_device(&mut sync_ctx, &mut non_sync_ctx, Some(multicast_addr));
        test_disable_device(&mut sync_ctx, &mut non_sync_ctx);
        assert_eq!(
            IpDeviceContext::<Ipv6, _>::get_ip_device_state(&sync_ctx, device_id)
                .ip_state
                .iter_addrs()
                .map(|Ipv6AddressEntry { addr_sub, state: _, config: _, deprecated: _ }| {
                    addr_sub.ipv6_unicast_addr()
                })
                .collect::<HashSet<_>>(),
            HashSet::from([ll_addr.ipv6_unicast_addr()]),
            "manual addresses should not be removed on device disable"
        );

        leave_ip_multicast::<Ipv6, _, _>(
            &mut sync_ctx,
            &mut non_sync_ctx,
            device_id,
            multicast_addr,
        );
        test_enable_device(&mut sync_ctx, &mut non_sync_ctx, None);
    }
}