netstack3_ip/multicast_forwarding/
api.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! Declares the API for configuring multicast forwarding within the netstack.
6
7use alloc::collections::btree_map;
8use core::sync::atomic::Ordering;
9
10use log::warn;
11use net_types::SpecifiedAddr;
12use net_types::ip::{Ip, IpVersionMarker};
13use netstack3_base::{
14    AnyDevice, AtomicInstant, ContextPair, CoreTimerContext, CounterContext, DeviceIdContext,
15    Inspector, InspectorDeviceExt, InstantBindingsTypes, InstantContext, StrongDeviceIdentifier,
16    WeakDeviceIdentifier,
17};
18
19use crate::internal::base::IpLayerForwardingContext;
20use crate::internal::multicast_forwarding::counters::MulticastForwardingCounters;
21use crate::internal::multicast_forwarding::packet_queue::{PacketQueue, QueuedPacket};
22use crate::internal::multicast_forwarding::route::{
23    Action, MulticastRoute, MulticastRouteEntry, MulticastRouteKey, MulticastRouteStats,
24    MulticastRouteTarget,
25};
26use crate::internal::multicast_forwarding::state::{
27    MulticastForwardingEnabledState, MulticastForwardingPendingPacketsContext as _,
28    MulticastForwardingState, MulticastForwardingStateContext, MulticastRouteTableContext as _,
29};
30use crate::internal::multicast_forwarding::{
31    MulticastForwardingBindingsTypes, MulticastForwardingDeviceContext, MulticastForwardingEvent,
32    MulticastForwardingTimerId,
33};
34use crate::{IpLayerBindingsContext, IpLayerIpExt, IpPacketDestination};
35
36/// The API action can not be performed while multicast forwarding is disabled.
37#[derive(Debug, Eq, PartialEq)]
38pub struct MulticastForwardingDisabledError {}
39
40trait MulticastForwardingStateExt<
41    I: IpLayerIpExt,
42    D: StrongDeviceIdentifier,
43    BT: MulticastForwardingBindingsTypes,
44>
45{
46    fn try_enabled(
47        &self,
48    ) -> Result<&MulticastForwardingEnabledState<I, D, BT>, MulticastForwardingDisabledError>;
49}
50
51impl<I: IpLayerIpExt, D: StrongDeviceIdentifier, BT: MulticastForwardingBindingsTypes>
52    MulticastForwardingStateExt<I, D, BT> for MulticastForwardingState<I, D, BT>
53{
54    fn try_enabled(
55        &self,
56    ) -> Result<&MulticastForwardingEnabledState<I, D, BT>, MulticastForwardingDisabledError> {
57        self.enabled().ok_or(MulticastForwardingDisabledError {})
58    }
59}
60
61/// The multicast forwarding API.
62pub struct MulticastForwardingApi<I: Ip, C> {
63    ctx: C,
64    _ip_mark: IpVersionMarker<I>,
65}
66
67impl<I: Ip, C> MulticastForwardingApi<I, C> {
68    /// Constructs a new multicast forwarding API.
69    pub fn new(ctx: C) -> Self {
70        Self { ctx, _ip_mark: IpVersionMarker::new() }
71    }
72}
73
74impl<I: IpLayerIpExt, C> MulticastForwardingApi<I, C>
75where
76    C: ContextPair,
77    C::CoreContext: MulticastForwardingStateContext<I, C::BindingsContext>
78        + MulticastForwardingDeviceContext<I>
79        + IpLayerForwardingContext<I, C::BindingsContext>
80        + CounterContext<MulticastForwardingCounters<I>>
81        + CoreTimerContext<MulticastForwardingTimerId<I>, C::BindingsContext>,
82    C::BindingsContext:
83        IpLayerBindingsContext<I, <C::CoreContext as DeviceIdContext<AnyDevice>>::DeviceId>,
84{
85    pub(crate) fn core_ctx(&mut self) -> &mut C::CoreContext {
86        let Self { ctx, _ip_mark } = self;
87        ctx.core_ctx()
88    }
89
90    pub(crate) fn contexts(&mut self) -> (&mut C::CoreContext, &mut C::BindingsContext) {
91        let Self { ctx, _ip_mark } = self;
92        ctx.contexts()
93    }
94
95    /// Enables multicast forwarding.
96    ///
97    /// Returns whether multicast forwarding was newly enabled.
98    pub fn enable(&mut self) -> bool {
99        let (core_ctx, bindings_ctx) = self.contexts();
100        core_ctx.with_state_mut(|state, _ctx| match state {
101            MulticastForwardingState::Enabled(_) => false,
102            MulticastForwardingState::Disabled => {
103                *state = MulticastForwardingState::Enabled(MulticastForwardingEnabledState::new::<
104                    C::CoreContext,
105                >(bindings_ctx));
106                true
107            }
108        })
109    }
110
111    /// Disables multicast forwarding.
112    ///
113    /// Returns whether multicast forwarding was newly disabled.
114    ///
115    /// Upon being disabled, the multicast route table will be cleared,
116    /// and all pending packets will be dropped.
117    pub fn disable(&mut self) -> bool {
118        self.core_ctx().with_state_mut(|state, _ctx| match state {
119            MulticastForwardingState::Disabled => false,
120            MulticastForwardingState::Enabled(_) => {
121                *state = MulticastForwardingState::Disabled;
122                true
123            }
124        })
125    }
126
127    /// Add the route to the multicast route table.
128    ///
129    /// If a route already exists with the same key, it will be replaced, and
130    /// the original route will be returned.
131    pub fn add_multicast_route(
132        &mut self,
133        key: MulticastRouteKey<I>,
134        route: MulticastRoute<<C::CoreContext as DeviceIdContext<AnyDevice>>::DeviceId>,
135    ) -> Result<
136        Option<MulticastRoute<<C::CoreContext as DeviceIdContext<AnyDevice>>::DeviceId>>,
137        MulticastForwardingDisabledError,
138    > {
139        let (core_ctx, bindings_ctx) = self.contexts();
140        let (orig_route, packet_queue_and_new_route) = core_ctx.with_state_mut(|state, ctx| {
141            let state = state.try_enabled()?;
142            ctx.with_route_table_mut(state, |route_table, ctx| {
143                let stats = MulticastRouteStats { last_used: bindings_ctx.now_atomic() };
144                match route_table.entry(key.clone()) {
145                    btree_map::Entry::Occupied(mut entry) => {
146                        // NB: We consider the stats to be associated with the
147                        // `route` rather than the route's key. As such we
148                        // replace the stats instead of preserving them.
149                        let MulticastRouteEntry { route: orig_route, stats: _ } =
150                            entry.insert(MulticastRouteEntry { route, stats });
151                        // NB: Check the invariant that any key present in the
152                        // route table is not also present in the pending table.
153                        #[cfg(debug_assertions)]
154                        ctx.with_pending_table_mut(state, |pending_table| {
155                            debug_assert!(!pending_table.contains(&key));
156                        });
157                        Ok((Some(orig_route), None))
158                    }
159                    btree_map::Entry::Vacant(entry) => {
160                        let MulticastRouteEntry { route: new_route_ref, stats: _ } =
161                            entry.insert(MulticastRouteEntry { route, stats });
162                        let packet_queue_and_new_route = ctx
163                            .with_pending_table_mut(state, |pending_table| {
164                                pending_table.remove(&key, bindings_ctx)
165                            })
166                            .map(|packet_queue| (packet_queue, new_route_ref.clone()));
167                        Ok((None, packet_queue_and_new_route))
168                    }
169                }
170            })
171        })?;
172
173        if let Some((packet_queue, new_route)) = packet_queue_and_new_route {
174            // NB: we cloned the route out to a context that's no longer holding
175            // the routing table lock. This means the route could have been
176            // removed. In general, that's okay. We'll operate on the
177            // potentially stale route as if it still exists. This mirrors the
178            // lookup pattern used by the unicast/multicast route tables in
179            // other parts of the stack.
180            handle_pending_packets(core_ctx, bindings_ctx, packet_queue, key, new_route)
181        }
182
183        Ok(orig_route)
184    }
185
186    /// Remove the route from the multicast route table.
187    ///
188    /// Returns `None` if the route did not exist.
189    pub fn remove_multicast_route(
190        &mut self,
191        key: &MulticastRouteKey<I>,
192    ) -> Result<
193        Option<MulticastRoute<<C::CoreContext as DeviceIdContext<AnyDevice>>::DeviceId>>,
194        MulticastForwardingDisabledError,
195    > {
196        self.core_ctx().with_state_mut(|state, ctx| {
197            let state = state.try_enabled()?;
198            ctx.with_route_table_mut(state, |route_table, _ctx| {
199                Ok(route_table.remove(key).map(|MulticastRouteEntry { route, stats: _ }| route))
200            })
201        })
202    }
203
204    /// Remove all references to the device from the multicast forwarding state.
205    ///
206    /// Typically, this is called as part of device removal to purge all strong
207    /// device references.
208    ///
209    /// Any routes that reference the device as an `input_interface` will be
210    /// removed. Any routes that reference the device as a
211    /// [`MulticastRouteTarget`] will have that target removed (and will
212    /// themselves be removed if it's the only target).
213    pub fn remove_references_to_device(
214        &mut self,
215        dev: &<C::CoreContext as DeviceIdContext<AnyDevice>>::WeakDeviceId,
216    ) {
217        self.core_ctx().with_state_mut(|state, ctx| {
218            let Some(state) = state.enabled() else {
219                // There's no state to update if forwarding is disabled.
220                return;
221            };
222            ctx.with_route_table_mut(state, |route_table, _ctx| {
223                route_table.retain(
224                    |_route_key,
225                     MulticastRouteEntry {
226                         route: MulticastRoute { action, input_interface },
227                         stats: _,
228                     }| {
229                        if dev == &*input_interface {
230                            return false;
231                        }
232                        match action {
233                            Action::Forward(targets) => {
234                                // If all targets reference the device, we should
235                                // discard the route entirely.
236                                if targets.iter().all(|target| dev == &target.output_interface) {
237                                    return false;
238                                }
239                                // Otherwise, if any target references the device,
240                                // we should remove it from the set of targets.
241                                if targets.iter().any(|target| dev == &target.output_interface) {
242                                    *targets = targets
243                                        .iter()
244                                        .filter(|target| dev != &target.output_interface)
245                                        .cloned()
246                                        .collect();
247                                }
248                            }
249                        }
250                        true
251                    },
252                )
253            })
254        })
255    }
256
257    /// Returns the [`MulticastRouteStats`], if any, for the given key.
258    pub fn get_route_stats(
259        &mut self,
260        key: &MulticastRouteKey<I>,
261    ) -> Result<
262        Option<MulticastRouteStats<<C::BindingsContext as InstantBindingsTypes>::Instant>>,
263        MulticastForwardingDisabledError,
264    > {
265        self.core_ctx().with_state(|state, ctx| {
266            let state = state.try_enabled()?;
267            ctx.with_route_table(state, |route_table, _ctx| {
268                Ok(route_table.get(key).map(
269                    |MulticastRouteEntry { route: _, stats: MulticastRouteStats { last_used } }| {
270                        MulticastRouteStats { last_used: last_used.load(Ordering::Relaxed) }
271                    },
272                ))
273            })
274        })
275    }
276
277    /// Writes multicast routing table information to the provided `inspector`.
278    pub fn inspect<
279        N: Inspector + InspectorDeviceExt<<C::CoreContext as DeviceIdContext<AnyDevice>>::DeviceId>,
280    >(
281        &mut self,
282        inspector: &mut N,
283    ) {
284        self.core_ctx().with_state(|state, ctx| match state {
285            MulticastForwardingState::Disabled => {
286                inspector.record_bool("ForwardingEnabled", false);
287            }
288            MulticastForwardingState::Enabled(state) => {
289                inspector.record_bool("ForwardingEnabled", true);
290                inspector.record_child("Routes", |inspector| {
291                    ctx.with_route_table(state, |route_table, _ctx| {
292                        for (route_key, route_entry) in route_table.iter() {
293                            inspector.record_unnamed_child(|inspector| {
294                                inspector.delegate_inspectable(route_key);
295                                route_entry.inspect::<_, N>(inspector);
296                            })
297                        }
298                    })
299                });
300                // NB: All other operations on the pending table require mutable
301                // access; don't bother introducing an immutable accessor just
302                // for inspect.
303                ctx.with_pending_table_mut(state, |pending_table| {
304                    inspector.record_inspectable("PendingRoutes", pending_table);
305                });
306            }
307        })
308    }
309}
310
311/// Attempt to forward the packets from a pending [`PacketQueue`] according to a
312/// newly installed [`MulticastRoute`].
313fn handle_pending_packets<I: IpLayerIpExt, CC, BC>(
314    core_ctx: &mut CC,
315    bindings_ctx: &mut BC,
316    packet_queue: PacketQueue<I, CC::WeakDeviceId, BC>,
317    key: MulticastRouteKey<I>,
318    route: MulticastRoute<CC::DeviceId>,
319) where
320    CC: IpLayerForwardingContext<I, BC>
321        + MulticastForwardingDeviceContext<I>
322        + CounterContext<MulticastForwardingCounters<I>>,
323    BC: IpLayerBindingsContext<I, CC::DeviceId>,
324{
325    let MulticastRoute { input_interface, action } = route;
326
327    // NB: We checked that forwarding was enabled on the device before the
328    // packet was enqueued in the pending table. However, the packet may sit in
329    // the queue for an extended period of time, during which forwarding may
330    // have been disabled on the device. Check again here just in case.
331    if !core_ctx.is_device_multicast_forwarding_enabled(&input_interface) {
332        // The user just installed a multicast route, but also disabled
333        // forwarding on the device. Log a warning because that likely indicates
334        // incorrect API usage.
335        warn!(
336            "Dropping pending packets for newly installed multicast route: {key:?}. \
337            Multicast forwarding is disabled on input interface: {input_interface:?}"
338        );
339        CounterContext::<MulticastForwardingCounters<I>>::counters(core_ctx)
340            .pending_packet_drops_disabled_dev
341            .increment();
342        return;
343    }
344
345    let MulticastRouteKey { src_addr, dst_addr } = key.clone();
346    let dst_ip: SpecifiedAddr<I::Addr> = dst_addr.into();
347    let src_ip: I::RecvSrcAddr = src_addr.into();
348
349    for QueuedPacket { device, packet, frame_dst, max_fragment_len } in packet_queue.into_iter() {
350        let device = match device.upgrade() {
351            // Short circuit if the device was removed while the packet was
352            // pending.
353            None => continue,
354            Some(d) => d,
355        };
356        // Short circuit if the queued packet arrived on the wrong device.
357        if device != input_interface {
358            CounterContext::<MulticastForwardingCounters<I>>::counters(core_ctx)
359                .pending_packet_drops_wrong_dev
360                .increment();
361            bindings_ctx.on_event(
362                MulticastForwardingEvent::WrongInputInterface {
363                    key: key.clone(),
364                    actual_input_interface: device,
365                    expected_input_interface: input_interface.clone(),
366                }
367                .into(),
368            );
369            continue;
370        }
371
372        // NB: We could choose to update the `last_used` value on the route's
373        // statistics here, but that's probably overkill. We only end up in this
374        // function as part of route installation, which will have appropriately
375        // initialized `last_used`. It's not worth re-acquiring the route table
376        // lock to update it again here, as the change in time will be
377        // negligible.
378
379        match &action {
380            Action::Forward(targets) => {
381                CounterContext::<MulticastForwardingCounters<I>>::counters(core_ctx)
382                    .pending_packet_tx
383                    .increment();
384                let packet_iter = core::iter::repeat_n(packet, targets.len());
385                for (mut packet, MulticastRouteTarget { output_interface, min_ttl }) in
386                    packet_iter.zip(targets.iter())
387                {
388                    let packet_metadata = Default::default();
389                    crate::internal::base::determine_ip_packet_forwarding_action::<I, _, _>(
390                        core_ctx,
391                        packet.parse_ip_packet_mut(),
392                        packet_metadata,
393                        Some(*min_ttl),
394                        &input_interface,
395                        &output_interface,
396                        IpPacketDestination::from_addr(dst_ip),
397                        frame_dst,
398                        src_ip,
399                        dst_ip,
400                    )
401                    .perform_action_with_buffer(
402                        core_ctx,
403                        bindings_ctx,
404                        packet.into_inner(),
405                        max_fragment_len,
406                    );
407                }
408            }
409        }
410    }
411}
412
413#[cfg(test)]
414mod tests {
415    use super::*;
416
417    use alloc::vec;
418    use core::num::NonZeroU8;
419    use core::ops::Deref;
420    use core::time::Duration;
421
422    use assert_matches::assert_matches;
423    use ip_test_macro::ip_test;
424    use net_types::MulticastAddr;
425    use netstack3_base::testutil::MultipleDevicesId;
426    use netstack3_base::{LocalFrameDestination, StrongDeviceIdentifier};
427    use packet::ParseBuffer;
428    use test_case::test_case;
429
430    use crate::IpLayerEvent;
431    use crate::internal::multicast_forwarding;
432    use crate::internal::multicast_forwarding::packet_queue::QueuePacketOutcome;
433    use crate::internal::multicast_forwarding::testutil::{SentPacket, TestIpExt};
434    use crate::multicast_forwarding::{MulticastRoute, MulticastRouteKey, MulticastRouteTarget};
435
436    const MIN_TTL: NonZeroU8 = NonZeroU8::new(1).unwrap();
437
438    #[ip_test(I)]
439    fn enable_disable<I: IpLayerIpExt>() {
440        let mut api = multicast_forwarding::testutil::new_api::<I>();
441
442        assert_matches!(
443            api.core_ctx().state.multicast_forwarding.borrow().deref(),
444            &MulticastForwardingState::Disabled
445        );
446        assert!(api.enable());
447        assert!(!api.enable());
448        assert_matches!(
449            api.core_ctx().state.multicast_forwarding.borrow().deref(),
450            &MulticastForwardingState::Enabled(_)
451        );
452        assert!(api.disable());
453        assert!(!api.disable());
454        assert_matches!(
455            api.core_ctx().state.multicast_forwarding.borrow().deref(),
456            &MulticastForwardingState::Disabled
457        );
458    }
459
460    #[ip_test(I)]
461    fn add_remove_route<I: TestIpExt>() {
462        let key1 = MulticastRouteKey::new(I::SRC1, I::DST1).unwrap();
463        let key2 = MulticastRouteKey::new(I::SRC2, I::DST2).unwrap();
464        let forward_to_b = MulticastRoute::new_forward(
465            MultipleDevicesId::A,
466            [MulticastRouteTarget { output_interface: MultipleDevicesId::B, min_ttl: MIN_TTL }]
467                .into(),
468        )
469        .unwrap();
470        let forward_to_c = MulticastRoute::new_forward(
471            MultipleDevicesId::A,
472            [MulticastRouteTarget { output_interface: MultipleDevicesId::C, min_ttl: MIN_TTL }]
473                .into(),
474        )
475        .unwrap();
476
477        let mut api = multicast_forwarding::testutil::new_api::<I>();
478
479        // Adding/removing routes before multicast forwarding is enabled should
480        // fail.
481        assert_eq!(
482            api.add_multicast_route(key1.clone(), forward_to_b.clone()),
483            Err(MulticastForwardingDisabledError {})
484        );
485        assert_eq!(api.remove_multicast_route(&key1), Err(MulticastForwardingDisabledError {}));
486
487        // Enable the API and observe success.
488        assert!(api.enable());
489        assert_eq!(api.add_multicast_route(key1.clone(), forward_to_b.clone()), Ok(None));
490        assert_eq!(api.remove_multicast_route(&key1), Ok(Some(forward_to_b.clone())));
491
492        // Removing a route that doesn't exist should return `None`.
493        assert_eq!(api.remove_multicast_route(&key1), Ok(None));
494
495        // Adding a route with the same key as an existing route should
496        // overwrite the original.
497        assert_eq!(api.add_multicast_route(key1.clone(), forward_to_b.clone()), Ok(None));
498        assert_eq!(
499            api.add_multicast_route(key1.clone(), forward_to_c.clone()),
500            Ok(Some(forward_to_b.clone()))
501        );
502        assert_eq!(api.remove_multicast_route(&key1), Ok(Some(forward_to_c.clone())));
503
504        // Routes with different keys can co-exist.
505        assert_eq!(api.add_multicast_route(key1.clone(), forward_to_b.clone()), Ok(None));
506        assert_eq!(api.add_multicast_route(key2.clone(), forward_to_c.clone()), Ok(None));
507        assert_eq!(api.remove_multicast_route(&key1), Ok(Some(forward_to_b)));
508        assert_eq!(api.remove_multicast_route(&key2), Ok(Some(forward_to_c)));
509    }
510
511    #[ip_test(I)]
512    #[test_case(false, true; "forwarding_disabled")]
513    #[test_case(true, false; "forwarding_enabled_and_wrong_dev")]
514    #[test_case(true, true; "forwarding_enabled_and_right_dev")]
515    fn add_route_with_pending_packets<I: TestIpExt>(
516        forwarding_enabled_for_dev: bool,
517        right_dev: bool,
518    ) {
519        const FRAME_DST: Option<LocalFrameDestination> = None;
520        const MAX_FRAGMENT_LEN: Option<usize> = None;
521        const OUTPUT_DEV: MultipleDevicesId = MultipleDevicesId::C;
522        let right_key = MulticastRouteKey::new(I::SRC1, I::DST1).unwrap();
523        let wrong_key = MulticastRouteKey::new(I::SRC2, I::DST2).unwrap();
524        let expected_dev = MultipleDevicesId::A;
525        let actual_dev = if right_dev { expected_dev } else { MultipleDevicesId::B };
526
527        let route = MulticastRoute::new_forward(
528            expected_dev,
529            [MulticastRouteTarget { output_interface: OUTPUT_DEV, min_ttl: MIN_TTL }].into(),
530        )
531        .unwrap();
532
533        let mut api = multicast_forwarding::testutil::new_api::<I>();
534        assert!(api.enable());
535        api.core_ctx()
536            .state
537            .set_multicast_forwarding_enabled_for_dev(expected_dev, forwarding_enabled_for_dev);
538
539        // Setup a queued packet for `right_key`.
540        let (core_ctx, bindings_ctx) = api.contexts();
541        multicast_forwarding::testutil::with_pending_table(core_ctx, |pending_table| {
542            let buf = multicast_forwarding::testutil::new_ip_packet_buf::<I>(I::SRC1, I::DST1);
543            let mut buf_ref = buf.as_ref();
544            let packet = buf_ref.parse::<I::Packet<_>>().expect("parse should succeed");
545            assert_eq!(
546                pending_table.try_queue_packet(
547                    bindings_ctx,
548                    right_key.clone(),
549                    &packet,
550                    &actual_dev,
551                    FRAME_DST,
552                    MAX_FRAGMENT_LEN,
553                ),
554                QueuePacketOutcome::QueuedInNewQueue,
555            );
556        });
557
558        // Add a route with the wrong key and expect that the packet queue is
559        // unaffected.
560        assert_eq!(api.add_multicast_route(wrong_key, route.clone()), Ok(None));
561        assert!(multicast_forwarding::testutil::with_pending_table(
562            api.core_ctx(),
563            |pending_table| pending_table.contains(&right_key)
564        ));
565
566        // Add a route with the right key and expect that the packet queue is
567        // removed.
568        assert_eq!(api.add_multicast_route(right_key.clone(), route), Ok(None));
569        assert!(multicast_forwarding::testutil::with_pending_table(
570            api.core_ctx(),
571            |pending_table| !pending_table.contains(&right_key)
572        ));
573
574        let expect_sent_packet = forwarding_enabled_for_dev && right_dev;
575        let mut expected_sent_packets = vec![];
576        if expect_sent_packet {
577            expected_sent_packets.push(SentPacket {
578                dst: MulticastAddr::new(right_key.dst_addr()).unwrap(),
579                device: OUTPUT_DEV,
580            });
581        }
582        assert_eq!(api.core_ctx().state.take_sent_packets(), expected_sent_packets);
583
584        // Verify that multicast routing events are generated.
585        let mut expected_events = vec![];
586        if !right_dev {
587            expected_events.push(IpLayerEvent::MulticastForwarding(
588                MulticastForwardingEvent::WrongInputInterface {
589                    key: right_key,
590                    actual_input_interface: actual_dev,
591                    expected_input_interface: expected_dev,
592                },
593            ));
594        }
595
596        let (_core_ctx, bindings_ctx) = api.contexts();
597        assert_eq!(bindings_ctx.take_events(), expected_events);
598
599        // Verify that counters are updated.
600        let counters: &MulticastForwardingCounters<I> = api.core_ctx().counters();
601        assert_eq!(counters.pending_packet_tx.get(), if expect_sent_packet { 1 } else { 0 });
602        assert_eq!(
603            counters.pending_packet_drops_disabled_dev.get(),
604            if forwarding_enabled_for_dev { 0 } else { 1 }
605        );
606        assert_eq!(counters.pending_packet_drops_wrong_dev.get(), if right_dev { 0 } else { 1 });
607    }
608
609    #[ip_test(I)]
610    fn remove_references_to_device<I: TestIpExt>() {
611        // NB: 4 arbitrary keys, that are unique from each other.
612        let key1 = MulticastRouteKey::new(I::SRC1, I::DST1).unwrap();
613        let key2 = MulticastRouteKey::new(I::SRC2, I::DST1).unwrap();
614        let key3 = MulticastRouteKey::new(I::SRC1, I::DST2).unwrap();
615        let key4 = MulticastRouteKey::new(I::SRC2, I::DST2).unwrap();
616
617        // Create 4 routes, each exercising a different edge case.
618        const GOOD_DEV1: MultipleDevicesId = MultipleDevicesId::A;
619        const GOOD_DEV2: MultipleDevicesId = MultipleDevicesId::B;
620        const BAD_DEV: MultipleDevicesId = MultipleDevicesId::C;
621        const GOOD_TARGET1: MulticastRouteTarget<MultipleDevicesId> =
622            MulticastRouteTarget { output_interface: GOOD_DEV1, min_ttl: MIN_TTL };
623        const GOOD_TARGET2: MulticastRouteTarget<MultipleDevicesId> =
624            MulticastRouteTarget { output_interface: GOOD_DEV2, min_ttl: MIN_TTL };
625        const BAD_TARGET: MulticastRouteTarget<MultipleDevicesId> =
626            MulticastRouteTarget { output_interface: BAD_DEV, min_ttl: MIN_TTL };
627        let dev_is_input = MulticastRoute::new_forward(BAD_DEV, [GOOD_TARGET1].into()).unwrap();
628        let dev_is_only_output =
629            MulticastRoute::new_forward(GOOD_DEV1, [BAD_TARGET].into()).unwrap();
630        let dev_is_one_output =
631            MulticastRoute::new_forward(GOOD_DEV1, [GOOD_TARGET2, BAD_TARGET].into()).unwrap();
632        let no_ref_to_dev = MulticastRoute::new_forward(GOOD_DEV1, [GOOD_TARGET2].into()).unwrap();
633
634        // Verify that removing device references is a no-op when multicast
635        // forwarding is disabled.
636        let mut api = multicast_forwarding::testutil::new_api::<I>();
637        api.remove_references_to_device(&BAD_DEV.downgrade());
638        assert!(api.enable());
639
640        // Add the four routes, remove references to `Dev`, and verify that:
641        // * `dev_is_input` & `dev_is_only_output`, were both removed.
642        // * `dev_is_one_output` was updated to not list the dev in its
643        //    targets.
644        // * `no_ref_to_dev` was not updated.
645        assert_eq!(api.add_multicast_route(key1.clone(), dev_is_input), Ok(None));
646        assert_eq!(api.add_multicast_route(key2.clone(), dev_is_only_output), Ok(None));
647        assert_eq!(api.add_multicast_route(key3.clone(), dev_is_one_output), Ok(None));
648        assert_eq!(api.add_multicast_route(key4.clone(), no_ref_to_dev.clone()), Ok(None));
649        api.remove_references_to_device(&BAD_DEV.downgrade());
650        assert_eq!(api.remove_multicast_route(&key1), Ok(None));
651        assert_eq!(api.remove_multicast_route(&key2), Ok(None));
652        // NB: Equal to `dev_is_one_output`, but with `BAD_TARGET` removed.
653        assert_eq!(
654            api.remove_multicast_route(&key3),
655            Ok(Some(MulticastRoute::new_forward(GOOD_DEV1, [GOOD_TARGET2].into()).unwrap()))
656        );
657        assert_eq!(api.remove_multicast_route(&key4), Ok(Some(no_ref_to_dev)));
658    }
659
660    #[ip_test(I)]
661    fn get_route_stats<I: TestIpExt>() {
662        let key = MulticastRouteKey::new(I::SRC1, I::DST1).unwrap();
663
664        let mut api = multicast_forwarding::testutil::new_api::<I>();
665
666        // Verify that get_route_stats fails when forwarding is disabled.
667        assert_eq!(api.get_route_stats(&key), Err(MulticastForwardingDisabledError {}));
668
669        // Verify that get_route_stats returns `None` if the route doesn't exist.
670        assert!(api.enable());
671        assert_eq!(api.get_route_stats(&key), Ok(None));
672
673        // Install a route and verify that get_route_stats succeeds.
674        let route = MulticastRoute::new_forward(
675            MultipleDevicesId::A,
676            [MulticastRouteTarget { output_interface: MultipleDevicesId::B, min_ttl: MIN_TTL }]
677                .into(),
678        )
679        .unwrap();
680        assert_eq!(api.add_multicast_route(key.clone(), route.clone()), Ok(None));
681        let original_time = api.ctx.bindings_ctx().now();
682        let expected_stats = MulticastRouteStats { last_used: original_time };
683        assert_eq!(api.get_route_stats(&key), Ok(Some(expected_stats)));
684
685        // Advance the timer and overwrite the route to prove we initialize
686        // stats with an up-to-date instant.
687        api.ctx.bindings_ctx().timers.instant.sleep(Duration::from_secs(5));
688        let new_time = api.ctx.bindings_ctx().now();
689        assert!(new_time > original_time);
690        let expected_stats = MulticastRouteStats { last_used: new_time };
691        assert_eq!(api.add_multicast_route(key.clone(), route.clone()), Ok(Some(route)));
692        assert_eq!(api.get_route_stats(&key), Ok(Some(expected_stats)));
693    }
694}
netstack3_ip/multicast_forwarding/api.rs

netstack3_ip/multicast_forwarding/
api.rs
