| // Copyright 2019 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. |
| |
| use std::collections::{HashMap, HashSet}; |
| use std::convert::TryFrom as _; |
| use std::num::NonZeroU16; |
| use std::ops::{Deref as _, DerefMut as _}; |
| use std::sync::{Arc, Once}; |
| |
| use anyhow::{format_err, Context as _, Error}; |
| use assert_matches::assert_matches; |
| use fidl_fuchsia_net as fidl_net; |
| use fidl_fuchsia_net_stack as fidl_net_stack; |
| use fidl_fuchsia_net_stack_ext::FidlReturn as _; |
| use fidl_fuchsia_netemul_network as net; |
| use fuchsia_async as fasync; |
| use futures::lock::Mutex; |
| use net_types::{ |
| ip::{AddrSubnetEither, IpAddr, Ipv4Addr, Ipv6Addr, SubnetEither}, |
| SpecifiedAddr, |
| }; |
| use netstack3_core::{ |
| context::{CounterContext, EventContext, InstantContext, RngContext, TimerContext}, |
| get_all_ip_addr_subnets, get_ipv4_configuration, get_ipv6_configuration, |
| icmp::{BufferIcmpContext, IcmpConnId, IcmpContext, IcmpIpExt}, |
| update_ipv4_configuration, update_ipv6_configuration, AddableEntryEither, BufferUdpContext, |
| Ctx, DeviceId, DeviceLayerEventDispatcher, IpExt, NonSyncContext, TimerId, UdpBoundId, |
| UdpContext, |
| }; |
| use packet::{Buf, BufferMut, Serializer}; |
| use packet_formats::icmp::{IcmpEchoReply, IcmpMessage, IcmpUnusedCode}; |
| use rand::rngs::OsRng; |
| |
| use crate::bindings::{ |
| context::Lockable, |
| devices::{ |
| CommonInfo, DeviceInfo, DeviceSpecificInfo, Devices, EthernetInfo, LoopbackInfo, |
| NetdeviceInfo, |
| }, |
| socket::datagram::{IcmpEcho, SocketCollectionIpExt, Udp}, |
| util::{ConversionContext as _, IntoFidl as _, TryFromFidlWithContext as _, TryIntoFidl as _}, |
| BindingsNonSyncCtxImpl, DeviceStatusNotifier, LockableContext, RequestStreamExt as _, |
| StackTime, DEFAULT_LOOPBACK_MTU, |
| }; |
| |
| /// log::Log implementation that uses stdout. |
| /// |
| /// Useful when debugging tests. |
| struct Logger; |
| |
| impl log::Log for Logger { |
| fn enabled(&self, _metadata: &log::Metadata<'_>) -> bool { |
| true |
| } |
| |
| fn log(&self, record: &log::Record<'_>) { |
| println!("[{}] ({}) {}", record.level(), record.module_path().unwrap_or(""), record.args()) |
| } |
| |
| fn flush(&self) {} |
| } |
| |
| static LOGGER: Logger = Logger; |
| |
| static LOGGER_ONCE: Once = Once::new(); |
| |
| /// Install a logger for tests. |
| pub(crate) fn set_logger_for_test() { |
| // log::set_logger will panic if called multiple times; using a Once makes |
| // set_logger_for_test idempotent |
| LOGGER_ONCE.call_once(|| { |
| log::set_logger(&LOGGER).unwrap(); |
| log::set_max_level(log::LevelFilter::Trace); |
| }) |
| } |
| |
| /// A dispatcher that can be used for tests with the ability to optionally |
| /// intercept events to use as signals during testing. |
| /// |
| /// `TestDispatcher` implements [`StackDispatcher`] and keeps an internal |
| /// [`BindingsDispatcherState`]. All the traits that are needed to have a |
| /// correct [`EventDispatcher`] are re-implemented by it so any events can be |
| /// short circuited into internal event watchers as opposed to routing into the |
| /// internal [`BindingsDispatcherState]`. |
| pub(crate) struct TestNonSyncCtx { |
| ctx: BindingsNonSyncCtxImpl, |
| /// A oneshot signal that is hit whenever changes to interface status occur |
| /// and it is set. |
| status_changed_signal: Option<futures::channel::oneshot::Sender<()>>, |
| } |
| |
| impl Default for TestNonSyncCtx { |
| fn default() -> TestNonSyncCtx { |
| TestNonSyncCtx { ctx: Default::default(), status_changed_signal: None } |
| } |
| } |
| |
| impl TestNonSyncCtx { |
| /// Shorthand method to get a [`DeviceInfo`] from the device's bindings |
| /// identifier. |
| fn get_device_info(&self, id: u64) -> Option<&DeviceInfo> { |
| AsRef::<Devices>::as_ref(self).get_device(id) |
| } |
| } |
| |
| impl DeviceStatusNotifier for TestNonSyncCtx { |
| fn device_status_changed(&mut self, id: u64) { |
| if let Some(s) = self.status_changed_signal.take() { |
| s.send(()).unwrap(); |
| } |
| // we can always send that forward to the real dispatcher, no need to |
| // short-circuit it. |
| self.ctx.device_status_changed(id); |
| } |
| } |
| |
| impl<T> AsRef<T> for TestNonSyncCtx |
| where |
| BindingsNonSyncCtxImpl: AsRef<T>, |
| { |
| fn as_ref(&self) -> &T { |
| self.ctx.as_ref() |
| } |
| } |
| |
| impl<T> AsMut<T> for TestNonSyncCtx |
| where |
| BindingsNonSyncCtxImpl: AsMut<T>, |
| { |
| fn as_mut(&mut self) -> &mut T { |
| self.ctx.as_mut() |
| } |
| } |
| |
| impl CounterContext for TestNonSyncCtx { |
| fn increment_counter(&mut self, key: &'static str) { |
| self.ctx.increment_counter(key) |
| } |
| } |
| |
| impl RngContext for TestNonSyncCtx { |
| type Rng = OsRng; |
| |
| fn rng(&self) -> &OsRng { |
| &self.ctx.rng |
| } |
| |
| fn rng_mut(&mut self) -> &mut OsRng { |
| &mut self.ctx.rng |
| } |
| } |
| |
| impl InstantContext for TestNonSyncCtx { |
| type Instant = StackTime; |
| |
| fn now(&self) -> StackTime { |
| self.ctx.now() |
| } |
| } |
| |
| impl TimerContext<TimerId> for TestNonSyncCtx { |
| fn schedule_timer_instant(&mut self, time: StackTime, id: TimerId) -> Option<StackTime> { |
| self.ctx.schedule_timer_instant(time, id) |
| } |
| |
| fn cancel_timer(&mut self, id: TimerId) -> Option<StackTime> { |
| self.ctx.cancel_timer(id) |
| } |
| |
| fn cancel_timers_with<F: FnMut(&TimerId) -> bool>(&mut self, f: F) { |
| self.ctx.cancel_timers_with(f); |
| } |
| |
| fn scheduled_instant(&self, id: TimerId) -> Option<StackTime> { |
| self.ctx.scheduled_instant(id) |
| } |
| } |
| |
| impl<B: BufferMut> DeviceLayerEventDispatcher<B> for TestNonSyncCtx { |
| fn send_frame<S: Serializer<Buffer = B>>( |
| &mut self, |
| device: DeviceId, |
| frame: S, |
| ) -> Result<(), S> { |
| self.ctx.send_frame(device, frame) |
| } |
| } |
| |
| impl<T: 'static + Send> EventContext<T> for TestNonSyncCtx { |
| fn on_event(&mut self, _event: T) {} |
| } |
| |
| impl<I: SocketCollectionIpExt<Udp> + IcmpIpExt> UdpContext<I> for TestNonSyncCtx { |
| fn receive_icmp_error(&mut self, id: UdpBoundId<I>, err: I::ErrorCode) { |
| UdpContext::receive_icmp_error(&mut self.ctx, id, err) |
| } |
| } |
| |
| impl<I: SocketCollectionIpExt<Udp> + IpExt, B: BufferMut> BufferUdpContext<I, B> |
| for TestNonSyncCtx |
| { |
| fn receive_udp_from_conn( |
| &mut self, |
| conn: netstack3_core::UdpConnId<I>, |
| src_ip: I::Addr, |
| src_port: NonZeroU16, |
| body: &B, |
| ) { |
| self.ctx.receive_udp_from_conn(conn, src_ip, src_port, body) |
| } |
| |
| /// Receive a UDP packet for a listener. |
| fn receive_udp_from_listen( |
| &mut self, |
| listener: netstack3_core::UdpListenerId<I>, |
| src_ip: I::Addr, |
| dst_ip: I::Addr, |
| src_port: Option<NonZeroU16>, |
| body: &B, |
| ) { |
| self.ctx.receive_udp_from_listen(listener, src_ip, dst_ip, src_port, body) |
| } |
| } |
| |
| impl<I: SocketCollectionIpExt<IcmpEcho> + IcmpIpExt> IcmpContext<I> for TestNonSyncCtx { |
| fn receive_icmp_error(&mut self, conn: IcmpConnId<I>, seq_num: u16, err: I::ErrorCode) { |
| IcmpContext::<I>::receive_icmp_error(&mut self.ctx, conn, seq_num, err) |
| } |
| } |
| |
| impl<I, B> BufferIcmpContext<I, B> for TestNonSyncCtx |
| where |
| I: SocketCollectionIpExt<IcmpEcho> + IcmpIpExt, |
| B: BufferMut, |
| IcmpEchoReply: for<'a> IcmpMessage<I, &'a [u8], Code = IcmpUnusedCode>, |
| { |
| fn receive_icmp_echo_reply( |
| &mut self, |
| conn: IcmpConnId<I>, |
| src_ip: I::Addr, |
| dst_ip: I::Addr, |
| id: u16, |
| seq_num: u16, |
| data: B, |
| ) { |
| self.ctx.receive_icmp_echo_reply(conn, src_ip, dst_ip, id, seq_num, data) |
| } |
| } |
| |
| #[derive(Clone)] |
| /// A netstack context for testing. |
| pub(crate) struct TestContext { |
| ctx: Arc<Mutex<Ctx<TestNonSyncCtx>>>, |
| _interfaces_worker: Arc<super::interfaces_watcher::Worker>, |
| interfaces_sink: super::interfaces_watcher::WorkerInterfaceSink, |
| } |
| |
| impl TestContext { |
| fn new() -> Self { |
| let (worker, _, interfaces_sink) = super::interfaces_watcher::Worker::new(); |
| Self { |
| ctx: Arc::new(Mutex::new(Ctx::default())), |
| _interfaces_worker: Arc::new(worker), |
| interfaces_sink, |
| } |
| } |
| } |
| |
| impl super::InterfaceEventProducerFactory for TestContext { |
| fn create_interface_event_producer( |
| &self, |
| id: super::devices::BindingId, |
| properties: super::interfaces_watcher::InterfaceProperties, |
| ) -> super::interfaces_watcher::InterfaceEventProducer { |
| self.interfaces_sink.add_interface(id, properties).expect("interfaces worker not running") |
| } |
| } |
| |
| impl<'a> Lockable<'a, Ctx<TestNonSyncCtx>> for TestContext { |
| type Guard = futures::lock::MutexGuard<'a, Ctx<TestNonSyncCtx>>; |
| type Fut = futures::lock::MutexLockFuture<'a, Ctx<TestNonSyncCtx>>; |
| fn lock(&'a self) -> Self::Fut { |
| self.ctx.lock() |
| } |
| } |
| |
| impl LockableContext for TestContext { |
| type NonSyncCtx = TestNonSyncCtx; |
| } |
| |
| /// A holder for a [`TestContext`]. |
| /// `TestStack` is obtained from [`TestSetupBuilder`] and offers utility methods |
| /// to connect to the FIDL APIs served by [`TestContext`], as well as keeps |
| /// track of configured interfaces during the setup procedure. |
| pub(crate) struct TestStack { |
| ctx: TestContext, |
| endpoint_ids: HashMap<String, u64>, |
| } |
| |
| struct InterfaceInfo { |
| admin_enabled: bool, |
| phy_up: bool, |
| addresses: Vec<fidl_net::Subnet>, |
| } |
| |
| impl TestStack { |
| /// Connects to the `fuchsia.net.stack.Stack` service. |
| pub(crate) fn connect_stack(&self) -> Result<fidl_fuchsia_net_stack::StackProxy, Error> { |
| let (stack, rs) = |
| fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_stack::StackMarker>()?; |
| fasync::Task::spawn(rs.serve_with(|rs| { |
| crate::bindings::stack_fidl_worker::StackFidlWorker::serve(self.ctx.clone(), rs) |
| })) |
| .detach(); |
| Ok(stack) |
| } |
| |
| /// Connects to the `fuchsia.posix.socket.Provider` service. |
| pub(crate) fn connect_socket_provider( |
| &self, |
| ) -> Result<fidl_fuchsia_posix_socket::ProviderProxy, Error> { |
| let (stack, rs) = fidl::endpoints::create_proxy_and_stream::< |
| fidl_fuchsia_posix_socket::ProviderMarker, |
| >()?; |
| fasync::Task::spawn( |
| rs.serve_with(|rs| crate::bindings::socket::serve(self.ctx.clone(), rs)), |
| ) |
| .detach(); |
| Ok(stack) |
| } |
| |
| fn is_interface_link_up(info: &DeviceInfo) -> bool { |
| match info.info() { |
| DeviceSpecificInfo::Ethernet(EthernetInfo { |
| common_info: CommonInfo { admin_enabled: _, mtu: _, events: _, name: _ }, |
| client: _, |
| mac: _, |
| features: _, |
| phy_up, |
| }) |
| | DeviceSpecificInfo::Netdevice(NetdeviceInfo { |
| common_info: CommonInfo { admin_enabled: _, mtu: _, events: _, name: _ }, |
| handler: _, |
| mac: _, |
| phy_up, |
| }) => *phy_up, |
| DeviceSpecificInfo::Loopback(LoopbackInfo { |
| common_info: CommonInfo { admin_enabled: _, mtu: _, events: _, name: _ }, |
| }) => true, |
| } |
| } |
| |
| /// Waits for interface with given `if_id` to come online. |
| pub(crate) async fn wait_for_interface_online(&mut self, if_id: u64) { |
| self.wait_for_interface_status(if_id, Self::is_interface_link_up).await; |
| } |
| |
| /// Waits for interface with given `if_id` to go offline. |
| pub(crate) async fn wait_for_interface_offline(&mut self, if_id: u64) { |
| self.wait_for_interface_status(if_id, |info| !Self::is_interface_link_up(info)).await; |
| } |
| |
| async fn wait_for_interface_status<F: Fn(&DeviceInfo) -> bool>( |
| &mut self, |
| if_id: u64, |
| check_status: F, |
| ) { |
| loop { |
| let signal = { |
| let mut ctx = self.ctx.lock().await; |
| if check_status( |
| ctx.non_sync_ctx |
| .get_device_info(if_id) |
| .expect("Wait for interface status on unknown device"), |
| ) { |
| return; |
| } |
| let (sender, receiver) = futures::channel::oneshot::channel(); |
| ctx.non_sync_ctx.status_changed_signal = Some(sender); |
| receiver |
| }; |
| let () = signal.await.expect("Stream ended before it was signalled"); |
| } |
| } |
| |
| /// Gets an installed interface identifier from the configuration endpoint |
| /// `index`. |
| pub(crate) fn get_endpoint_id(&self, index: usize) -> u64 { |
| self.get_named_endpoint_id(test_ep_name(index)) |
| } |
| |
| /// Gets an installed interface identifier from the configuration endpoint |
| /// `name`. |
| pub(crate) fn get_named_endpoint_id(&self, name: impl Into<String>) -> u64 { |
| *self.endpoint_ids.get(&name.into()).unwrap() |
| } |
| |
| /// Creates a new `TestStack`. |
| pub(crate) fn new() -> Self { |
| let ctx = TestContext::new(); |
| TestStack { ctx, endpoint_ids: HashMap::new() } |
| } |
| |
| /// Helper function to invoke a closure that provides a locked |
| /// [`Ctx< BindingsContext>`] provided by this `TestStack`. |
| pub(crate) async fn with_ctx<R, F: FnOnce(&mut Ctx<TestNonSyncCtx>) -> R>( |
| &mut self, |
| f: F, |
| ) -> R { |
| let mut ctx = self.ctx.lock().await; |
| f(ctx.deref_mut()) |
| } |
| |
| /// Acquire a lock on this `TestStack`'s context. |
| pub(crate) async fn ctx(&self) -> <TestContext as Lockable<'_, Ctx<TestNonSyncCtx>>>::Guard { |
| self.ctx.lock().await |
| } |
| |
| async fn get_interface_info(&self, id: u64) -> InterfaceInfo { |
| let ctx = self.ctx().await; |
| let Ctx { sync_ctx, non_sync_ctx } = ctx.deref(); |
| let device = non_sync_ctx.get_device_info(id).expect("device"); |
| let addresses = get_all_ip_addr_subnets(sync_ctx, device.core_id()) |
| .map(|addr| addr.try_into_fidl().expect("convert to FIDL")) |
| .collect(); |
| |
| let (admin_enabled, phy_up) = assert_matches::assert_matches!( |
| device.info(), |
| DeviceSpecificInfo::Ethernet(EthernetInfo { |
| common_info: CommonInfo { |
| admin_enabled, |
| mtu: _, |
| events: _, |
| name: _, |
| }, |
| client: _, |
| mac: _, |
| features: _, |
| phy_up |
| }) => (*admin_enabled, *phy_up)); |
| InterfaceInfo { admin_enabled, phy_up, addresses } |
| } |
| } |
| |
| /// A test setup that than contain multiple stack instances networked together. |
| pub(crate) struct TestSetup { |
| // Let connection to sandbox be made lazily, so a netemul sandbox is not |
| // created for tests that don't need it. |
| sandbox: Option<netemul::TestSandbox>, |
| // Keep around the handle to the virtual networks and endpoints we create to |
| // ensure they're not cleaned up before test execution is complete. |
| _network: Option<net::SetupHandleProxy>, |
| stacks: Vec<TestStack>, |
| } |
| |
| impl TestSetup { |
| /// Gets the [`TestStack`] at index `i`. |
| pub(crate) fn get(&mut self, i: usize) -> &mut TestStack { |
| &mut self.stacks[i] |
| } |
| |
| /// Acquires a lock on the [`TestContext`] at index `i`. |
| pub(crate) async fn ctx( |
| &mut self, |
| i: usize, |
| ) -> <TestContext as Lockable<'_, Ctx<TestNonSyncCtx>>>::Guard { |
| self.get(i).ctx.lock().await |
| } |
| |
| async fn get_endpoint( |
| &mut self, |
| ep_name: &str, |
| ) -> Result<fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_ethernet::DeviceMarker>, Error> |
| { |
| let epm = self.sandbox().get_endpoint_manager()?; |
| let ep = match epm.get_endpoint(ep_name).await? { |
| Some(ep) => ep.into_proxy()?, |
| None => { |
| return Err(format_err!("Failed to retrieve endpoint {}", ep_name)); |
| } |
| }; |
| |
| match ep.get_device().await? { |
| fidl_fuchsia_netemul_network::DeviceConnection::Ethernet(e) => Ok(e), |
| fidl_fuchsia_netemul_network::DeviceConnection::NetworkDevice(n) => { |
| todo!("(48853) Support NetworkDevice for integration tests. Got unexpected network device {:?}.", n) |
| } |
| } |
| } |
| |
| /// Changes a named endpoint `ep_name` link status to `up`. |
| pub(crate) async fn set_endpoint_link_up( |
| &mut self, |
| ep_name: &str, |
| up: bool, |
| ) -> Result<(), Error> { |
| let epm = self.sandbox().get_endpoint_manager()?; |
| if let Some(ep) = epm.get_endpoint(ep_name).await? { |
| ep.into_proxy()?.set_link_up(up).await?; |
| Ok(()) |
| } else { |
| Err(format_err!("Failed to retrieve endpoint {}", ep_name)) |
| } |
| } |
| |
| /// Creates a new empty `TestSetup`. |
| fn new() -> Result<Self, Error> { |
| set_logger_for_test(); |
| Ok(Self { sandbox: None, _network: None, stacks: Vec::new() }) |
| } |
| |
| fn sandbox(&mut self) -> &netemul::TestSandbox { |
| self.sandbox |
| .get_or_insert_with(|| netemul::TestSandbox::new().expect("create netemul sandbox")) |
| } |
| |
| async fn configure_network( |
| &mut self, |
| ep_names: impl Iterator<Item = String>, |
| ) -> Result<(), Error> { |
| let handle = self |
| .sandbox() |
| .setup_networks(vec![net::NetworkSetup { |
| name: "test_net".to_owned(), |
| config: net::NetworkConfig::EMPTY, |
| endpoints: ep_names.map(|name| new_endpoint_setup(name)).collect(), |
| }]) |
| .await |
| .context("create network")? |
| .into_proxy(); |
| |
| self._network = Some(handle); |
| Ok(()) |
| } |
| |
| fn add_stack(&mut self, stack: TestStack) { |
| self.stacks.push(stack) |
| } |
| } |
| |
| /// Helper function to retrieve the internal name of an endpoint specified only |
| /// by an index `i`. |
| pub(crate) fn test_ep_name(i: usize) -> String { |
| format!("test-ep{}", i) |
| } |
| |
| fn new_endpoint_setup(name: String) -> net::EndpointSetup { |
| net::EndpointSetup { config: None, link_up: true, name } |
| } |
| |
| /// A builder structure for [`TestSetup`]. |
| pub(crate) struct TestSetupBuilder { |
| endpoints: Vec<String>, |
| stacks: Vec<StackSetupBuilder>, |
| } |
| |
| impl TestSetupBuilder { |
| /// Creates an empty `SetupBuilder`. |
| pub(crate) fn new() -> Self { |
| Self { endpoints: Vec::new(), stacks: Vec::new() } |
| } |
| |
| /// Adds an automatically-named endpoint to the setup builder. The automatic |
| /// names are taken using [`test_ep_name`] with index starting at 1. |
| /// |
| /// Multiple calls to `add_endpoint` will result in the creation of multiple |
| /// endpoints with sequential indices. |
| pub(crate) fn add_endpoint(self) -> Self { |
| let id = self.endpoints.len() + 1; |
| self.add_named_endpoint(test_ep_name(id)) |
| } |
| |
| /// Ads an endpoint with a given `name`. |
| pub(crate) fn add_named_endpoint(mut self, name: impl Into<String>) -> Self { |
| self.endpoints.push(name.into()); |
| self |
| } |
| |
| /// Adds a stack to create upon building. Stack configuration is provided |
| /// by [`StackSetupBuilder`]. |
| pub(crate) fn add_stack(mut self, stack: StackSetupBuilder) -> Self { |
| self.stacks.push(stack); |
| self |
| } |
| |
| /// Adds an empty stack to create upon building. An empty stack contains |
| /// no endpoints. |
| pub(crate) fn add_empty_stack(mut self) -> Self { |
| self.stacks.push(StackSetupBuilder::new()); |
| self |
| } |
| |
| /// Attempts to build a [`TestSetup`] with the provided configuration. |
| pub(crate) async fn build(self) -> Result<TestSetup, Error> { |
| let mut setup = TestSetup::new()?; |
| if !self.endpoints.is_empty() { |
| let () = setup.configure_network(self.endpoints.into_iter()).await?; |
| } |
| |
| // configure all the stacks: |
| for stack_cfg in self.stacks.into_iter() { |
| println!("Adding stack: {:?}", stack_cfg); |
| let mut stack = TestStack::new(); |
| stack |
| .with_ctx(|Ctx { sync_ctx, non_sync_ctx }| { |
| let loopback = |
| netstack3_core::add_loopback_device(sync_ctx, DEFAULT_LOOPBACK_MTU) |
| .expect("add loopback device"); |
| update_ipv4_configuration(sync_ctx, non_sync_ctx, loopback, |config| { |
| config.ip_config.ip_enabled = true; |
| }); |
| update_ipv6_configuration(sync_ctx, non_sync_ctx, loopback, |config| { |
| config.ip_config.ip_enabled = true; |
| }); |
| }) |
| .await; |
| |
| for (ep_name, addr) in stack_cfg.endpoints.into_iter() { |
| // get the endpoint from the sandbox config: |
| let endpoint = setup.get_endpoint(&ep_name).await?; |
| let cli = stack.connect_stack()?; |
| let if_id = add_stack_endpoint(&cli, endpoint).await?; |
| // We'll ALWAYS await for the newly created interface to come up |
| // online before returning, so users of `TestSetupBuilder` can |
| // be 100% sure of the state once the setup is done. |
| stack.wait_for_interface_online(if_id).await; |
| if let Some(addr) = addr { |
| configure_endpoint_address(&cli, if_id, addr).await?; |
| } |
| |
| assert_eq!(stack.endpoint_ids.insert(ep_name, if_id), None); |
| } |
| |
| setup.add_stack(stack) |
| } |
| |
| Ok(setup) |
| } |
| } |
| |
| /// Shorthand function to create an IPv4 [`AddrSubnetEither`]. |
| /// |
| /// # Panics |
| /// |
| /// May panic if `prefix` is longer than the number of bits in this type of IP |
| /// address (32 for IPv4), or if `ip` is not a unicast address in the resulting |
| /// subnet (see [`net_types::ip::IpAddress::is_unicast_in_subnet`]). |
| pub fn new_ipv4_addr_subnet(ip: [u8; 4], prefix: u8) -> AddrSubnetEither { |
| AddrSubnetEither::new(IpAddr::V4(Ipv4Addr::from(ip)), prefix).unwrap() |
| } |
| |
| /// Shorthand function to create an IPv6 [`AddrSubnetEither`]. |
| /// |
| /// # Panics |
| /// |
| /// May panic if `prefix` is longer than the number of bits in this type of IP |
| /// address (128 for IPv6), or if `ip` is not a unicast address in the resulting |
| /// subnet (see [`net_types::ip::IpAddress::is_unicast_in_subnet`]). |
| pub fn new_ipv6_addr_subnet(ip: [u8; 16], prefix: u8) -> AddrSubnetEither { |
| AddrSubnetEither::new(IpAddr::V6(Ipv6Addr::from(ip)), prefix).unwrap() |
| } |
| |
| /// Helper struct to create stack configuration for [`TestSetupBuilder`]. |
| #[derive(Debug)] |
| pub struct StackSetupBuilder { |
| endpoints: Vec<(String, Option<AddrSubnetEither>)>, |
| } |
| |
| impl StackSetupBuilder { |
| /// Creates a new empty stack (no endpoints) configuration. |
| pub(crate) fn new() -> Self { |
| Self { endpoints: Vec::new() } |
| } |
| |
| /// Adds endpoint number `index` with optional address configuration |
| /// `address` to the builder. |
| fn add_endpoint(self, index: usize, address: Option<AddrSubnetEither>) -> Self { |
| self.add_named_endpoint(test_ep_name(index), address) |
| } |
| |
| /// Adds named endpoint `name` with optional address configuration `address` |
| /// to the builder. |
| pub(crate) fn add_named_endpoint( |
| mut self, |
| name: impl Into<String>, |
| address: Option<AddrSubnetEither>, |
| ) -> Self { |
| self.endpoints.push((name.into(), address)); |
| self |
| } |
| } |
| |
| async fn add_stack_endpoint( |
| cli: &fidl_fuchsia_net_stack::StackProxy, |
| endpoint: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_ethernet::DeviceMarker>, |
| ) -> Result<u64, Error> { |
| // add interface: |
| let if_id = cli |
| .add_ethernet_interface("fake_topo_path", endpoint) |
| .await |
| .squash_result() |
| .context("Add ethernet interface")?; |
| Ok(if_id) |
| } |
| |
| async fn configure_endpoint_address( |
| cli: &fidl_fuchsia_net_stack::StackProxy, |
| if_id: u64, |
| addr: AddrSubnetEither, |
| ) -> Result<(), Error> { |
| // add address: |
| let () = cli |
| .add_interface_address_deprecated(if_id, &mut addr.into_fidl()) |
| .await |
| .squash_result() |
| .context("Add interface address")?; |
| |
| // add route to ensure `addr` is valid, the result can be safely discarded |
| let _ = |
| AddrSubnetEither::try_from(addr).expect("Invalid test subnet configuration").addr_subnet(); |
| |
| let () = cli |
| .add_forwarding_entry(&mut fidl_fuchsia_net_stack::ForwardingEntry { |
| subnet: addr.addr_subnet().1.into_fidl(), |
| device_id: if_id, |
| next_hop: None, |
| metric: 0, |
| }) |
| .await |
| .squash_result() |
| .context("Add forwarding entry")?; |
| |
| Ok(()) |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_add_remove_interface() { |
| let mut t = TestSetupBuilder::new().add_endpoint().add_empty_stack().build().await.unwrap(); |
| let ep = t.get_endpoint("test-ep1").await.unwrap(); |
| let test_stack = t.get(0); |
| let stack = test_stack.connect_stack().unwrap(); |
| let if_id = stack |
| .add_ethernet_interface("fake_topo_path", ep) |
| .await |
| .squash_result() |
| .expect("Add interface succeeds"); |
| |
| // remove the interface: |
| let () = stack.del_ethernet_interface(if_id).await.squash_result().expect("Remove interface"); |
| // ensure the interface disappeared from records: |
| assert_matches!(test_stack.ctx.lock().await.non_sync_ctx.get_device_info(if_id), None); |
| |
| // if we try to remove it again, NotFound should be returned: |
| let res = |
| stack.del_ethernet_interface(if_id).await.unwrap().expect_err("Failed to remove twice"); |
| assert_eq!(res, fidl_net_stack::Error::NotFound); |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_ethernet_link_up_down() { |
| let mut t = TestSetupBuilder::new() |
| .add_endpoint() |
| .add_stack(StackSetupBuilder::new().add_endpoint(1, None)) |
| .build() |
| .await |
| .unwrap(); |
| let ep_name = test_ep_name(1); |
| let test_stack = t.get(0); |
| let if_id = test_stack.get_endpoint_id(1); |
| |
| let () = test_stack.wait_for_interface_online(if_id).await; |
| |
| // Get the interface info to confirm status indicators are correct. |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.phy_up); |
| assert!(if_info.admin_enabled); |
| |
| // Ensure that the device has been enabled in the core. |
| let core_id = { |
| let mut ctx = test_stack.ctx().await; |
| let core_id = ctx.non_sync_ctx.get_device_info(if_id).unwrap().core_id(); |
| check_ip_enabled(ctx.deref_mut(), core_id, true); |
| core_id |
| }; |
| |
| // Setting the link down should disable the interface and disable it from |
| // the core. The AdministrativeStatus should remain unchanged. |
| assert!(t.set_endpoint_link_up(&ep_name, false).await.is_ok()); |
| let test_stack = t.get(0); |
| test_stack.wait_for_interface_offline(if_id).await; |
| |
| // Get the interface info to confirm that it is disabled. |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.phy_up); |
| assert!(if_info.admin_enabled); |
| |
| // Ensure that the device has been disabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, false); |
| |
| // Setting the link down again should cause no effect on the device state, |
| // and should be handled gracefully. |
| assert!(t.set_endpoint_link_up(&ep_name, false).await.is_ok()); |
| |
| // Get the interface info to confirm that it is disabled. |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.phy_up); |
| assert!(if_info.admin_enabled); |
| |
| // Ensure that the device has been disabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, false); |
| |
| // Setting the link up should reenable the interface and enable it in |
| // the core. |
| assert!(t.set_endpoint_link_up(&ep_name, true).await.is_ok()); |
| t.get(0).wait_for_interface_online(if_id).await; |
| |
| // Get the interface info to confirm that it is reenabled. |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.phy_up); |
| assert!(if_info.admin_enabled); |
| |
| // Ensure that the device has been enabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, true); |
| |
| // Setting the link up again should cause no effect on the device state, |
| // and should be handled gracefully. |
| assert!(t.set_endpoint_link_up(&ep_name, true).await.is_ok()); |
| |
| // Get the interface info to confirm that there have been no changes. |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.phy_up); |
| assert!(if_info.admin_enabled); |
| |
| // Ensure that the device has been enabled in the core. |
| let core_id = t |
| .get(0) |
| .with_ctx(|ctx| { |
| let core_id = ctx.non_sync_ctx.get_device_info(if_id).unwrap().core_id(); |
| check_ip_enabled(ctx, core_id, true); |
| core_id |
| }) |
| .await; |
| |
| // call directly into core to prove that the device was correctly |
| // initialized (core will panic if we try to use the device and initialize |
| // hasn't been called) |
| let mut ctx = t.ctx(0).await; |
| let Ctx { sync_ctx, non_sync_ctx } = ctx.deref_mut(); |
| netstack3_core::receive_frame(sync_ctx, non_sync_ctx, core_id, Buf::new(&mut [], ..)) |
| .expect("error receiving frame"); |
| } |
| |
| fn check_ip_enabled<NonSyncCtx: NonSyncContext>( |
| Ctx { sync_ctx, non_sync_ctx: _ }: &mut Ctx<NonSyncCtx>, |
| core_id: DeviceId, |
| expected: bool, |
| ) { |
| let ipv4_enabled = get_ipv4_configuration(sync_ctx, core_id).ip_config.ip_enabled; |
| let ipv6_enabled = get_ipv6_configuration(sync_ctx, core_id).ip_config.ip_enabled; |
| |
| assert_eq!((ipv4_enabled, ipv6_enabled), (expected, expected)); |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_disable_enable_interface() { |
| let mut t = TestSetupBuilder::new() |
| .add_endpoint() |
| .add_stack(StackSetupBuilder::new().add_endpoint(1, None)) |
| .build() |
| .await |
| .unwrap(); |
| let test_stack = t.get(0); |
| let stack = test_stack.connect_stack().unwrap(); |
| let if_id = test_stack.get_endpoint_id(1); |
| |
| // Get the interface info to confirm that it is enabled. |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.admin_enabled); |
| assert!(if_info.phy_up); |
| |
| // Disable the interface and test again, physical_status should be |
| // unchanged. |
| let () = stack |
| .disable_interface_deprecated(if_id) |
| .await |
| .squash_result() |
| .expect("Disable interface succeeds"); |
| |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.admin_enabled); |
| assert!(if_info.phy_up); |
| |
| // Ensure that the device has been disabled in the core. |
| let core_id = { |
| let mut ctx = test_stack.ctx().await; |
| let core_id = ctx.non_sync_ctx.get_device_info(if_id).unwrap().core_id(); |
| check_ip_enabled(ctx.deref_mut(), core_id, false); |
| core_id |
| }; |
| |
| // Enable the interface and test again. |
| let () = stack |
| .enable_interface_deprecated(if_id) |
| .await |
| .squash_result() |
| .expect("Enable interface succeeds"); |
| |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.admin_enabled); |
| assert!(if_info.phy_up); |
| |
| // Ensure that the device has been enabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, true); |
| |
| // Check that we get the correct error for a non-existing interface id. |
| assert_eq!( |
| stack.enable_interface_deprecated(12345).await.unwrap().unwrap_err(), |
| fidl_net_stack::Error::NotFound |
| ); |
| |
| // Check that we get the correct error for a non-existing interface id. |
| assert_eq!( |
| stack.disable_interface_deprecated(12345).await.unwrap().unwrap_err(), |
| fidl_net_stack::Error::NotFound |
| ); |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_phy_admin_interface_state_interaction() { |
| let mut t = TestSetupBuilder::new() |
| .add_endpoint() |
| .add_stack(StackSetupBuilder::new().add_endpoint(1, None)) |
| .build() |
| .await |
| .unwrap(); |
| let ep_name = test_ep_name(1); |
| let test_stack = t.get(0); |
| let stack = test_stack.connect_stack().unwrap(); |
| let if_id = test_stack.get_endpoint_id(1); |
| |
| t.get(0).wait_for_interface_online(if_id).await; |
| |
| // Get the interface info to confirm that it is enabled. |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.admin_enabled); |
| assert!(if_info.phy_up); |
| |
| // Disable the interface and test again, physical_status should be |
| // unchanged. |
| let () = stack |
| .disable_interface_deprecated(if_id) |
| .await |
| .squash_result() |
| .expect("Disable interface succeeds"); |
| |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.admin_enabled); |
| assert!(if_info.phy_up); |
| |
| // Ensure that the device has been disabled in the core. |
| let core_id = { |
| let mut ctx = test_stack.ctx().await; |
| let core_id = ctx.non_sync_ctx.get_device_info(if_id).unwrap().core_id(); |
| check_ip_enabled(ctx.deref_mut(), core_id, false); |
| core_id |
| }; |
| |
| // Setting the link down now that the interface is already down should only |
| // change the cached state. Both phy and admin should be down now. |
| assert!(t.set_endpoint_link_up(&ep_name, false).await.is_ok()); |
| t.get(0).wait_for_interface_offline(if_id).await; |
| |
| // Get the interface info to confirm that it is disabled. |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.phy_up); |
| assert!(!if_info.admin_enabled); |
| |
| // Ensure that the device is still disabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, false); |
| |
| // Enable the interface and test again, only cached status should be changed |
| // and core state should still be disabled. |
| let () = stack |
| .enable_interface_deprecated(if_id) |
| .await |
| .squash_result() |
| .expect("Enable interface succeeds"); |
| |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.admin_enabled); |
| assert!(!if_info.phy_up); |
| |
| // Ensure that the device is still disabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, false); |
| |
| // Disable the interface and test again, both should be down now. |
| let () = stack |
| .disable_interface_deprecated(if_id) |
| .await |
| .squash_result() |
| .expect("Disable interface succeeds"); |
| |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.admin_enabled); |
| assert!(!if_info.phy_up); |
| |
| // Ensure that the device is still disabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, false); |
| |
| // Setting the link up should only affect cached state |
| assert!(t.set_endpoint_link_up(&ep_name, true).await.is_ok()); |
| t.get(0).wait_for_interface_online(if_id).await; |
| |
| // Get the interface info to confirm that it is reenabled. |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.admin_enabled); |
| assert!(if_info.phy_up); |
| |
| // Ensure that the device is still disabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, false); |
| |
| // Finally, setting admin status up should update the cached state and |
| // re-add the device to the core. |
| let () = stack |
| .enable_interface_deprecated(if_id) |
| .await |
| .squash_result() |
| .expect("Enable interface succeeds"); |
| |
| // Get the interface info to confirm that it is reenabled. |
| let test_stack = t.get(0); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.phy_up); |
| assert!(if_info.admin_enabled); |
| |
| // Ensure that the device has been enabled in the core. |
| check_ip_enabled(test_stack.ctx().await.deref_mut(), core_id, true); |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_add_del_interface_address_deprecated() { |
| let mut t = TestSetupBuilder::new() |
| .add_endpoint() |
| .add_stack(StackSetupBuilder::new().add_endpoint(1, None)) |
| .build() |
| .await |
| .unwrap(); |
| let test_stack = t.get(0); |
| let stack = test_stack.connect_stack().unwrap(); |
| let if_id = test_stack.get_endpoint_id(1); |
| for addr in [ |
| new_ipv4_addr_subnet([192, 168, 0, 1], 24).into_fidl(), |
| new_ipv6_addr_subnet([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 64) |
| .into_fidl(), |
| ] |
| .iter_mut() |
| { |
| // The first IP address added should succeed. |
| let () = stack |
| .add_interface_address_deprecated(if_id, addr) |
| .await |
| .squash_result() |
| .expect("Add interface address should succeed"); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(if_info.addresses.contains(&addr)); |
| |
| // Adding the same IP address again should fail with already exists. |
| let err = stack |
| .add_interface_address_deprecated(if_id, addr) |
| .await |
| .expect("Add interface address FIDL call should succeed") |
| .expect_err("Adding same address should fail"); |
| assert_eq!(err, fidl_net_stack::Error::AlreadyExists); |
| |
| // Deleting an IP address that exists should succeed. |
| let () = stack |
| .del_interface_address_deprecated(if_id, addr) |
| .await |
| .squash_result() |
| .expect("Delete interface address succeeds"); |
| let if_info = test_stack.get_interface_info(if_id).await; |
| assert!(!if_info.addresses.contains(&addr)); |
| |
| // Deleting an IP address that doesn't exist should fail with not found. |
| let err = stack |
| .del_interface_address_deprecated(if_id, addr) |
| .await |
| .expect("Delete interface address FIDL call should succeed") |
| .expect_err("Deleting non-existent address should fail"); |
| assert_eq!(err, fidl_net_stack::Error::NotFound); |
| } |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_add_device_routes() { |
| // create a stack and add a single endpoint to it so we have the interface |
| // id: |
| let mut t = TestSetupBuilder::new() |
| .add_endpoint() |
| .add_stack(StackSetupBuilder::new().add_endpoint(1, None)) |
| .build() |
| .await |
| .unwrap(); |
| let test_stack = t.get(0); |
| let stack = test_stack.connect_stack().unwrap(); |
| let if_id = test_stack.get_endpoint_id(1); |
| |
| let mut fwd_entry1 = fidl_net_stack::ForwardingEntry { |
| subnet: fidl_net::Subnet { |
| addr: fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { addr: [192, 168, 0, 0] }), |
| prefix_len: 24, |
| }, |
| device_id: if_id, |
| next_hop: None, |
| metric: 0, |
| }; |
| let mut fwd_entry2 = fidl_net_stack::ForwardingEntry { |
| subnet: fidl_net::Subnet { |
| addr: fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { addr: [10, 0, 0, 0] }), |
| prefix_len: 24, |
| }, |
| device_id: if_id, |
| next_hop: None, |
| metric: 0, |
| }; |
| |
| let () = stack |
| .add_forwarding_entry(&mut fwd_entry1) |
| .await |
| .squash_result() |
| .expect("Add forwarding entry succeeds"); |
| let () = stack |
| .add_forwarding_entry(&mut fwd_entry2) |
| .await |
| .squash_result() |
| .expect("Add forwarding entry succeeds"); |
| |
| // finally, check that bad routes will fail: |
| // a duplicate entry should fail with AlreadyExists: |
| let mut bad_entry = fidl_net_stack::ForwardingEntry { |
| subnet: fidl_net::Subnet { |
| addr: fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { addr: [192, 168, 0, 0] }), |
| prefix_len: 24, |
| }, |
| device_id: if_id, |
| next_hop: None, |
| metric: 0, |
| }; |
| assert_eq!( |
| stack.add_forwarding_entry(&mut bad_entry).await.unwrap().unwrap_err(), |
| fidl_net_stack::Error::AlreadyExists |
| ); |
| // an entry with an invalid subnet should fail with Invalidargs: |
| let mut bad_entry = fidl_net_stack::ForwardingEntry { |
| subnet: fidl_net::Subnet { |
| addr: fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { addr: [10, 0, 0, 0] }), |
| prefix_len: 64, |
| }, |
| device_id: if_id, |
| next_hop: None, |
| metric: 0, |
| }; |
| assert_eq!( |
| stack.add_forwarding_entry(&mut bad_entry).await.unwrap().unwrap_err(), |
| fidl_net_stack::Error::InvalidArgs |
| ); |
| // an entry with a bad devidce id should fail with NotFound: |
| let mut bad_entry = fidl_net_stack::ForwardingEntry { |
| subnet: fidl_net::Subnet { |
| addr: fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { addr: [10, 0, 0, 0] }), |
| prefix_len: 24, |
| }, |
| device_id: 10, |
| next_hop: None, |
| metric: 0, |
| }; |
| assert_eq!( |
| stack.add_forwarding_entry(&mut bad_entry).await.unwrap().unwrap_err(), |
| fidl_net_stack::Error::NotFound |
| ); |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_list_del_routes() { |
| // create a stack and add a single endpoint to it so we have the interface |
| // id: |
| let mut t = TestSetupBuilder::new() |
| .add_endpoint() |
| .add_stack(StackSetupBuilder::new().add_endpoint(1, None)) |
| .build() |
| .await |
| .unwrap(); |
| |
| let test_stack = t.get(0); |
| let stack = test_stack.connect_stack().unwrap(); |
| let if_id = test_stack.get_endpoint_id(1); |
| let device = test_stack.ctx().await.non_sync_ctx.get_core_id(if_id); |
| let route1_subnet_bytes = [192, 168, 0, 0]; |
| let route1_subnet_prefix = 24; |
| let route1 = AddableEntryEither::new( |
| SubnetEither::new(Ipv4Addr::from(route1_subnet_bytes).into(), route1_subnet_prefix) |
| .unwrap(), |
| device, |
| None, |
| ) |
| .unwrap(); |
| let sub10 = SubnetEither::new(Ipv4Addr::from([10, 0, 0, 0]).into(), 24).unwrap(); |
| let route2 = AddableEntryEither::new(sub10, device, None).unwrap(); |
| let sub10_gateway = SpecifiedAddr::new(Ipv4Addr::from([10, 0, 0, 1])).map(Into::into); |
| let route3 = AddableEntryEither::new(sub10, None, sub10_gateway).unwrap(); |
| |
| let () = test_stack |
| .with_ctx(|Ctx { sync_ctx, non_sync_ctx }| { |
| // add a couple of routes directly into core: |
| netstack3_core::add_route(sync_ctx, non_sync_ctx, route1).unwrap(); |
| netstack3_core::add_route(sync_ctx, non_sync_ctx, route2).unwrap(); |
| netstack3_core::add_route(sync_ctx, non_sync_ctx, route3).unwrap(); |
| }) |
| .await; |
| |
| let routes = stack.get_forwarding_table().await.expect("Can get forwarding table"); |
| let route3_with_device = AddableEntryEither::new(sub10, device, sub10_gateway).unwrap(); |
| // Link local route is added automatically by core. |
| let link_local_route = |
| AddableEntryEither::new(net_declare::net_subnet_v6!("fe80::/64").into(), device, None) |
| .unwrap(); |
| assert_eq!( |
| test_stack |
| .with_ctx(|ctx| { |
| routes |
| .into_iter() |
| .map(|e| { |
| AddableEntryEither::try_from_fidl_with_ctx(&ctx.non_sync_ctx, e).unwrap() |
| }) |
| .collect::<HashSet<_>>() |
| }) |
| .await, |
| HashSet::from([route1, route2, route3_with_device, link_local_route]) |
| ); |
| |
| // delete route1: |
| let mut fwd_entry = fidl_net_stack::ForwardingEntry { |
| subnet: fidl_net::Subnet { |
| addr: fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { addr: route1_subnet_bytes }), |
| prefix_len: route1_subnet_prefix, |
| }, |
| device_id: 0, |
| next_hop: None, |
| metric: 0, |
| }; |
| let () = stack |
| .del_forwarding_entry(&mut fwd_entry) |
| .await |
| .squash_result() |
| .expect("can delete device forwarding entry"); |
| // can't delete again: |
| assert_eq!( |
| stack.del_forwarding_entry(&mut fwd_entry).await.unwrap().unwrap_err(), |
| fidl_net_stack::Error::NotFound |
| ); |
| |
| // check that route was deleted (should've disappeared from core) |
| let routes = stack.get_forwarding_table().await.expect("Can get forwarding table"); |
| assert_eq!( |
| test_stack |
| .with_ctx(|ctx| { |
| routes |
| .into_iter() |
| .map(|e| { |
| AddableEntryEither::try_from_fidl_with_ctx(&ctx.non_sync_ctx, e).unwrap() |
| }) |
| .collect::<HashSet<_>>() |
| }) |
| .await, |
| HashSet::from([route2, route3_with_device, link_local_route]) |
| ); |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn test_add_remote_routes() { |
| let mut t = TestSetupBuilder::new() |
| .add_endpoint() |
| .add_stack(StackSetupBuilder::new().add_endpoint(1, None)) |
| .build() |
| .await |
| .unwrap(); |
| |
| let test_stack = t.get(0); |
| let stack = test_stack.connect_stack().unwrap(); |
| let device_id = test_stack.get_endpoint_id(1); |
| |
| let subnet = fidl_net::Subnet { |
| addr: fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { addr: [192, 168, 0, 0] }), |
| prefix_len: 24, |
| }; |
| let mut fwd_entry = fidl_net_stack::ForwardingEntry { |
| subnet, |
| device_id: 0, |
| next_hop: Some(Box::new(fidl_net::IpAddress::Ipv4(fidl_net::Ipv4Address { |
| addr: [192, 168, 0, 1], |
| }))), |
| metric: 0, |
| }; |
| |
| // Cannot add gateway route without device set or on-link route to gateway. |
| assert_eq!( |
| stack.add_forwarding_entry(&mut fwd_entry).await.unwrap(), |
| Err(fidl_net_stack::Error::BadState) |
| ); |
| let mut device_fwd_entry = fidl_net_stack::ForwardingEntry { |
| subnet: fwd_entry.subnet, |
| device_id, |
| next_hop: None, |
| metric: 0, |
| }; |
| let () = stack |
| .add_forwarding_entry(&mut device_fwd_entry) |
| .await |
| .squash_result() |
| .expect("add device route"); |
| |
| let () = |
| stack.add_forwarding_entry(&mut fwd_entry).await.squash_result().expect("add device route"); |
| |
| // finally, check that bad routes will fail: |
| // a duplicate entry should fail with AlreadyExists: |
| assert_eq!( |
| stack.add_forwarding_entry(&mut fwd_entry).await.unwrap(), |
| Err(fidl_net_stack::Error::AlreadyExists) |
| ); |
| } |
