| // 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. |
| |
| //! The special-purpose event loop used by the network manager. |
| //! |
| //! This event loop takes in events from Admin and State FIDL, |
| //! and implements handlers for FIDL calls. |
| //! |
| //! This is implemented with a single mpsc queue for all event types - `EventLoop` holds the |
| //! consumer, and any event handling that requires state within `EventLoop` holds a producer, |
| //! allowing it to delegate work to the `EventLoop` by sending a message. In this documentation, we |
| //! call anything that holds a producer a "worker". |
| //! |
| //! Having a single queue for all of the message types is beneficial, since in guarantees a FIFO |
| //! ordering for all messages - whichever messages arrive first, will be handled first. |
| //! |
| //! We'll look at each type of message, to see how each one is handled - starting with FIDL |
| //! messages, since they can be thought of as the entrypoint for the whole loop (as nothing happens |
| //! until a FIDL call is made). |
| //! |
| //! # FIDL Worker |
| //! |
| //! The FIDL part of the event loop implements the fuchsia.router.config Admin and State |
| //! interfaces. The type of the event loop message for a FIDL call is |
| //! simply the generated FIDL type. When the event loop starts up, we use `fuchsia_app` to start a |
| //! FIDL server that simply sends all of the events it receives to the event loop (via the sender |
| //! end of the mpsc queue). When `EventLoop` receives this message, it calls the |
| //! `handle_fidl_router_admin_request` or `handle_fidl_router_state_request` method, which, |
| //! depending on what the request is, either: |
| //! |
| //! * Responds with the requested information. |
| //! * Modifies the router state byt accessinc netcfg. |
| //! * Updates local state. |
| |
| use fidl_fuchsia_net as fnet; |
| use fidl_fuchsia_net_name as fnet_name; |
| use fidl_fuchsia_router_config::{ |
| Id, Lif, Port, RouterAdminRequest, RouterStateGetPortsResponder, RouterStateRequest, |
| SecurityFeatures, |
| }; |
| use fuchsia_component::server::ServiceFs; |
| |
| use anyhow::{Context as _, Error}; |
| use dns_server_watcher::{DnsServers, DnsServersUpdateSource, DEFAULT_DNS_PORT}; |
| use futures::future; |
| use futures::stream::{self, StreamExt as _, TryStreamExt as _}; |
| use network_manager_core::{ |
| hal::NetCfg, lifmgr::LIFType, packet_filter::PacketFilter, portmgr::PortId, DeviceState, |
| }; |
| |
| use crate::fidl_worker::IncomingFidlRequestStream; |
| |
| macro_rules! router_error { |
| ($code:ident, $desc:expr) => { |
| Some(&mut fidl_fuchsia_router_config::Error { |
| code: fidl_fuchsia_router_config::ErrorCode::$code, |
| description: $desc, |
| }) |
| }; |
| } |
| |
| macro_rules! not_supported { |
| () => { |
| router_error!(NotSupported, None) |
| }; |
| } |
| macro_rules! not_found { |
| () => { |
| router_error!(NotFound, None) |
| }; |
| } |
| macro_rules! internal_error { |
| ($s:expr) => { |
| router_error!(Internal, Some($s.to_string())) |
| }; |
| } |
| |
| fn dns_sockaddr_from_ip(ip: fnet::IpAddress) -> fnet::SocketAddress { |
| match ip { |
| fnet::IpAddress::Ipv4(addr) => fnet::SocketAddress::Ipv4(fnet::Ipv4SocketAddress { |
| address: addr, |
| port: DEFAULT_DNS_PORT, |
| }), |
| fnet::IpAddress::Ipv6(addr) => fnet::SocketAddress::Ipv6(fnet::Ipv6SocketAddress { |
| address: addr, |
| port: DEFAULT_DNS_PORT, |
| zone_index: 0, |
| }), |
| } |
| } |
| |
| /// The event loop. |
| pub struct EventLoop { |
| device: DeviceState, |
| dns_servers: DnsServers, |
| } |
| |
| impl EventLoop { |
| pub fn new() -> Result<Self, Error> { |
| let netcfg = NetCfg::new()?; |
| let packet_filter = PacketFilter::start().context("failed to start packet filter")?; |
| let device = DeviceState::new(netcfg, packet_filter); |
| Ok(EventLoop { device, dns_servers: Default::default() }) |
| } |
| |
| pub async fn run(mut self) -> Result<(), Error> { |
| if let Err(e) = self.device.load_config().await { |
| // TODO(cgibson): Kick off some sort of recovery process here: Prompt the user to |
| // download a recovery app, set a static IP on the first interface and set everything |
| // else down, restructure packet filter rules, etc. |
| error!("Failed to load a device config: {}", e); |
| } |
| self.device.setup_services().await.context("setup_services")?; |
| self.device.populate_state().await.context("populate_state")?; |
| |
| let (stack_stream, netstack_stream) = self.device.take_event_streams(); |
| let stack_stream = stack_stream.map(|r| r.context("Stack event stream")).fuse(); |
| let netstack_stream = netstack_stream.map(|r| r.context("Netstack event stream")).fuse(); |
| let netstack_dns_stream = dns_server_watcher::new_dns_server_stream( |
| DnsServersUpdateSource::Netstack, |
| self.device |
| .get_netstack_dns_server_watcher() |
| .context("failed to get DNS server watcher")?, |
| ) |
| .fuse(); |
| let oir_stream = crate::oir_worker::new_stream() |
| .await |
| .context("starting OIR")? |
| .map(|r| r.context("OIR event stream")) |
| .fuse(); |
| let mut fs = ServiceFs::new_local(); |
| let fidl_server_stream = crate::fidl_worker::new_stream(&mut fs) |
| .context("setting up FIDL services")? |
| .then(futures::future::ok::<_, anyhow::Error>); |
| // Make sure errors encountered when setting up overnet services do not cause |
| // NetworkManager to exit as overnet may not be available on all builds. |
| let overnet_stream = match crate::overnet_worker::new_stream().await { |
| Err(e) => { |
| error!("error setting up overnet services: {}", e); |
| // We use a stream that is always pending so that the loop below may |
| // assume that `overnet_stream` is not expected to end (which is the |
| // case when we successfully setup and publish overnet services). |
| future::Either::Left(stream::pending()) |
| } |
| Ok(o) => future::Either::Right(o.map(|r| r.context("overnet service request stream"))), |
| }; |
| let fidl_req_stream = stream::select(fidl_server_stream, overnet_stream).fuse(); |
| let mut router_admin_streams = stream::SelectAll::new(); |
| let mut router_state_streams = stream::SelectAll::new(); |
| |
| futures::pin_mut!( |
| stack_stream, |
| netstack_stream, |
| netstack_dns_stream, |
| oir_stream, |
| fidl_req_stream |
| ); |
| |
| loop { |
| // Currently, if any of the workers encounters an error, the event loop |
| // will return with the worker's error immediately. |
| // TODO(fxbug.dev/52740): Gracefully handle worker errors. |
| let () = futures::select! { |
| stack_res = stack_stream.try_next() => { |
| let event = stack_res?.ok_or(anyhow::anyhow!("Stack event stream unexpectedly ended"))?; |
| self.handle_stack_event(event).await |
| } |
| netstack_res = netstack_stream.try_next() => { |
| let event = netstack_res?.ok_or(anyhow::anyhow!("Netstack event stream unexpectedly ended"))?; |
| self.handle_netstack_event(event).await |
| } |
| netstack_dns_res = netstack_dns_stream.next() => { |
| let (source, res) = netstack_dns_res.ok_or(anyhow::anyhow!("Netstack DNS Server watcher stream unexpectedly ended"))?; |
| self.handle_dns_server_watcher_event(source, res.context("error getting next DNS server event from netstack")?).await |
| } |
| oir_res = oir_stream.try_next() => { |
| let event = oir_res?.ok_or(anyhow::anyhow!("OIR stream unexpectedly ended"))?; |
| self.handle_oir_event(event).await |
| } |
| fidl_req_res = fidl_req_stream.try_next() => { |
| let req = fidl_req_res?.ok_or(anyhow::anyhow!("FIDL service request stream unexpectedly ended"))?; |
| match req { |
| IncomingFidlRequestStream::RouterAdmin(r) => router_admin_streams.push(r), |
| IncomingFidlRequestStream::RouterState(r) => router_state_streams.push(r), |
| } |
| } |
| router_admin_req_res = router_admin_streams.try_next() => { |
| // We may receive `None` just once if there are no longer any active streams |
| // in the `Stream` set. This is expected for the initial state, or after the |
| // streams are run to completion. Note, the `Stream` set will start to yield |
| // values again (as they become available) once a new `Stream` is added. |
| if let Some(req) = router_admin_req_res? { |
| self.handle_fidl_router_admin_request(req).await |
| } |
| } |
| router_state_req_res = router_state_streams.try_next() => { |
| // We may receive `None` just once if there are no longer any active streams |
| // in the `Stream` set. This is expected for the initial state, or after the |
| // streams are run to completion. Note, the `Stream` set will start to yield |
| // values again (as they become available) once a new `Stream` is added. |
| if let Some(req) = router_state_req_res? { |
| self.handle_fidl_router_state_request(req).await |
| } |
| } |
| complete => break, |
| }; |
| } |
| |
| Ok(()) |
| } |
| |
| async fn handle_dns_server_watcher_event( |
| &mut self, |
| source: DnsServersUpdateSource, |
| servers: Vec<fnet_name::DnsServer_>, |
| ) { |
| trace!("got DNS server event from source = {:?} with servers = {:?}", source, servers); |
| let () = self.dns_servers.set_servers_from_source(source, servers); |
| let () = self |
| .device |
| .set_dns_resolvers(self.dns_servers.consolidated()) |
| .await |
| .map(|_: network_manager_core::ElementId| ()) |
| .unwrap_or_else(|err| warn!("error setting dns servers: {:?}", err)); |
| } |
| |
| async fn handle_stack_event(&mut self, event: fidl_fuchsia_net_stack::StackEvent) { |
| self.device |
| .update_state_for_stack_event(event) |
| .await |
| .unwrap_or_else(|err| warn!("error updating state: {:?}", err)); |
| } |
| |
| async fn handle_netstack_event(&mut self, event: fidl_fuchsia_netstack::NetstackEvent) { |
| self.device |
| .update_state_for_netstack_event(event) |
| .await |
| .unwrap_or_else(|err| warn!("error updating state: {:?}", err)); |
| } |
| |
| async fn handle_oir_event(&mut self, event: network_manager_core::oir::OIRInfo) { |
| self.device |
| .oir_event(event) |
| .await |
| .unwrap_or_else(|err| warn!("error processing oir event: {:?}", err)); |
| } |
| |
| async fn handle_fidl_router_admin_request(&mut self, req: RouterAdminRequest) { |
| match req { |
| RouterAdminRequest::CreateWan { name, vlan, ports, responder } => { |
| let r = self |
| .fidl_create_lif( |
| LIFType::WAN, |
| name, |
| vlan, |
| ports.iter().map(|x| PortId::from(u64::from(*x))).collect(), |
| ) |
| .await; |
| match r { |
| Ok(mut id) => responder.send(Some(&mut id), None), |
| Err(mut e) => responder.send(None, Some(&mut e)), |
| } |
| } |
| RouterAdminRequest::CreateLan { name, vlan, ports, responder } => { |
| let r = self |
| .fidl_create_lif( |
| LIFType::LAN, |
| name, |
| vlan, |
| ports.iter().map(|x| PortId::from(u64::from(*x))).collect(), |
| ) |
| .await; |
| match r { |
| Ok(mut id) => responder.send(Some(&mut id), None), |
| Err(mut e) => responder.send(None, Some(&mut e)), |
| } |
| } |
| RouterAdminRequest::RemoveWan { wan_id, responder } => { |
| let mut r = self.fidl_delete_lif(wan_id).await; |
| responder.send(r.as_mut()).or_else(|e| { |
| error!("Error sending response: {:?}", e); |
| Err(e) |
| }) |
| } |
| RouterAdminRequest::RemoveLan { lan_id, responder } => { |
| let mut r = self.fidl_delete_lif(lan_id).await; |
| responder.send(r.as_mut()).or_else(|e| { |
| error!("Error sending response: {:?}", e); |
| Err(e) |
| }) |
| } |
| RouterAdminRequest::SetWanProperties { wan_id, properties, responder } => { |
| let properties = fidl_fuchsia_router_config::LifProperties::Wan(properties); |
| if self |
| .device |
| .update_lif_properties_fidl(u128::from_ne_bytes(wan_id.uuid), &properties) |
| .await |
| .is_err() |
| { |
| warn!("WAN {:?} found but failed to update properties", wan_id); |
| responder.send(not_found!()) |
| } else { |
| info!("WAN properties updated"); |
| responder.send(None) |
| } |
| } |
| RouterAdminRequest::SetLanProperties { lan_id, properties, responder } => { |
| let properties = fidl_fuchsia_router_config::LifProperties::Lan(properties); |
| if self |
| .device |
| .update_lif_properties_fidl(u128::from_ne_bytes(lan_id.uuid), &properties) |
| .await |
| .is_err() |
| { |
| warn!("failed to update LAN properties"); |
| responder.send(not_found!()) |
| } else { |
| info!("LAN properties updated"); |
| responder.send(None) |
| } |
| } |
| RouterAdminRequest::SetDhcpServerOptions { lan_id, options, responder } => { |
| info!("{:?}, {:?}", lan_id, options); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetDhcpAddressPool { lan_id, pool, responder } => { |
| info!("{:?}, {:?}", lan_id, pool); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetDhcpReservation { lan_id, reservation, responder } => { |
| info!("{:?}, {:?}", lan_id, reservation); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::DeleteDhcpReservation { reservation_id, responder } => { |
| info!("{:?}", reservation_id); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetDnsResolver { config, responder } => { |
| info!("{:?}", config); |
| match self |
| .device |
| .set_dns_resolvers( |
| config.search.servers.into_iter().map(dns_sockaddr_from_ip).collect(), |
| ) |
| .await |
| { |
| Ok(i) => responder.send( |
| Some(&mut Id { uuid: i.uuid().to_ne_bytes(), version: i.version() }), |
| None, |
| ), |
| Err(e) => responder.send(None, internal_error!(e.to_string())), |
| } |
| } |
| RouterAdminRequest::SetDnsForwarder { config, responder } => { |
| info!("{:?}", config); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::AddDnsEntry { entry, responder } => { |
| info!("{:?}", entry); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::DeleteDnsEntry { entry_id, responder } => { |
| info!("{:?}", entry_id); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetRoute { route, responder } => { |
| info!("{:?}", route); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::UpdateRouteMetric { route_id, metric, responder } => { |
| info!("{:?} {:?}", route_id, metric); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::DeleteRoute { route_id, responder } => { |
| info!("{:?}", route_id); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetSecurityFeatures { features, responder } => { |
| info!("Updating SecurityFeatures: {:?}", features); |
| match self.update_security_features(&features).await { |
| Ok(_) => responder.send(None), |
| Err(e) => responder.send(internal_error!(e.to_string())), |
| } |
| } |
| RouterAdminRequest::SetPortForward { rule, responder } => { |
| info!("{:?}", rule); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::DeletePortForward { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetPortTrigger { rule, responder } => { |
| info!("{:?}", rule); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::DeletePortTrigger { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetFilter { rule, responder } => { |
| let r = self |
| .device |
| // TODO(fxbug.dev/45024): The Router Config FIDL API doesn't have a way to provide a |
| // specific interface identifier. |
| .set_filter_on_interface(&rule, 0u32) |
| .await |
| .context("Error installing new packet filter on all interfaces"); |
| match r { |
| Ok(()) => responder.send(None, None), |
| Err(e) => responder.send(None, internal_error!(e.to_string())), |
| } |
| } |
| RouterAdminRequest::DeleteFilter { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| let r = self |
| .device |
| .delete_filter(rule_id) |
| .await |
| .context("Error deleting packet filter rule"); |
| match r { |
| Ok(()) => responder.send(None), |
| Err(e) => responder.send(internal_error!(e.to_string())), |
| } |
| } |
| RouterAdminRequest::SetIpv6PinHole { rule, responder } => { |
| info!("{:?}", rule); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::DeleteIpv6PinHole { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetDmzHost { rule, responder } => { |
| info!("{:?}", rule); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::DeleteDmzHost { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(not_supported!()) |
| } |
| RouterAdminRequest::SetSystemConfig { config, responder } => { |
| info!("{:?}", config); |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::CreateWlanNetwork { responder, .. } => { |
| // TODO(guzt): implement |
| responder.send(None, not_supported!()) |
| } |
| RouterAdminRequest::DeleteWlanNetwork { responder, .. } => { |
| // TODO(guzt): implement |
| responder.send(not_supported!()) |
| } |
| } |
| .unwrap_or_else(|e| error!("Error sending response {}", e)) |
| } |
| |
| async fn fidl_create_lif( |
| &mut self, |
| lif_type: LIFType, |
| name: String, |
| vlan: u16, |
| ports: Vec<PortId>, |
| ) -> Result<Id, fidl_fuchsia_router_config::Error> { |
| let lif = self.device.create_lif(lif_type, name, Some(vlan), &ports).await; |
| match lif { |
| Err(e) => { |
| error!("Error creating lif {:?}", e); |
| Err(fidl_fuchsia_router_config::Error { |
| code: fidl_fuchsia_router_config::ErrorCode::AlreadyExists, |
| description: None, |
| }) |
| } |
| Ok(l) => { |
| let i = l.id(); |
| Ok(Id { uuid: i.uuid().to_ne_bytes(), version: i.version() }) |
| } |
| } |
| } |
| |
| async fn fidl_delete_lif(&mut self, id: Id) -> Option<fidl_fuchsia_router_config::Error> { |
| let lif = self.device.delete_lif(u128::from_ne_bytes(id.uuid)).await; |
| match lif { |
| Err(e) => { |
| error!("Error deleting lif {:?}", e); |
| Some(fidl_fuchsia_router_config::Error { |
| code: fidl_fuchsia_router_config::ErrorCode::NotFound, |
| description: None, |
| }) |
| } |
| Ok(()) => None, |
| } |
| } |
| |
| async fn update_security_features( |
| &mut self, |
| security_features: &SecurityFeatures, |
| ) -> Result<(), Error> { |
| if let Some(nat) = security_features.nat { |
| if nat { |
| self.device.enable_nat(); |
| } else { |
| self.device.disable_nat(); |
| } |
| } |
| // TODO(cgibson): Handle additional SecurityFeatures. |
| Ok(()) |
| } |
| |
| async fn handle_fidl_router_state_request(&mut self, req: RouterStateRequest) { |
| match req { |
| RouterStateRequest::GetWanPorts { wan_id, responder } => { |
| let lif = self.device.lif(u128::from_ne_bytes(wan_id.uuid)); |
| match lif { |
| None => { |
| warn!("WAN {:?} not found", wan_id); |
| responder.send(&[], not_found!()) |
| } |
| Some(l) => { |
| responder.send(&l.ports().map(|p| p.to_u32()).collect::<Vec<_>>(), None) |
| } |
| } |
| } |
| RouterStateRequest::GetLanPorts { lan_id, responder } => { |
| let lif = self.device.lif(u128::from_ne_bytes(lan_id.uuid)); |
| match lif { |
| None => { |
| warn!("LAN {:?} not found", lan_id); |
| responder.send(&[], not_found!()) |
| } |
| Some(l) => { |
| responder.send(&l.ports().map(|p| p.to_u32()).collect::<Vec<_>>(), None) |
| } |
| } |
| } |
| RouterStateRequest::GetWan { wan_id, responder } => { |
| let lif = self.device.lif(u128::from_ne_bytes(wan_id.uuid)); |
| info!("lifs {:?}", lif); |
| match lif { |
| None => { |
| warn!("WAN {:?} not found", wan_id); |
| responder.send( |
| fidl_fuchsia_router_config::Lif { |
| element: None, |
| name: None, |
| port_ids: None, |
| properties: None, |
| vlan: None, |
| type_: None, |
| ..fidl_fuchsia_router_config::Lif::EMPTY |
| }, |
| not_found!(), |
| ) |
| } |
| Some(l) => { |
| let ll = l.into(); |
| responder.send(ll, None) |
| } |
| } |
| } |
| RouterStateRequest::GetLan { lan_id, responder } => { |
| let lif = self.device.lif(u128::from_ne_bytes(lan_id.uuid)); |
| match lif { |
| None => { |
| warn!("LAN {:?} not found", lan_id); |
| responder.send( |
| fidl_fuchsia_router_config::Lif { |
| element: None, |
| name: None, |
| port_ids: None, |
| properties: None, |
| vlan: None, |
| type_: None, |
| ..fidl_fuchsia_router_config::Lif::EMPTY |
| }, |
| not_found!(), |
| ) |
| } |
| Some(l) => { |
| let ll = l.into(); |
| responder.send(ll, None) |
| } |
| } |
| } |
| RouterStateRequest::GetWans { responder } => { |
| let lifs: Vec<Lif> = self.device.lifs(LIFType::WAN).map(|l| l.into()).collect(); |
| info!("result: {:?} ", lifs); |
| responder.send(&mut lifs.into_iter()) |
| } |
| RouterStateRequest::GetLans { responder } => { |
| let lifs: Vec<Lif> = self.device.lifs(LIFType::LAN).map(|l| l.into()).collect(); |
| info!("result: {:?} ", lifs); |
| responder.send(&mut lifs.into_iter()) |
| } |
| RouterStateRequest::GetWanProperties { wan_id, responder } => { |
| info!("{:?}", wan_id); |
| let properties = fidl_fuchsia_router_config::WanProperties { |
| connection_type: None, |
| connection_parameters: None, |
| address_method: None, |
| address_v4: None, |
| gateway_v4: None, |
| connection_v6_mode: None, |
| address_v6: None, |
| gateway_v6: None, |
| hostname: None, |
| clone_mac: None, |
| mtu: None, |
| enable: None, |
| metric: None, |
| ..fidl_fuchsia_router_config::WanProperties::EMPTY |
| }; |
| responder.send(properties, not_supported!()) |
| } |
| RouterStateRequest::GetLanProperties { lan_id, responder } => { |
| info!("{:?}", lan_id); |
| let properties = fidl_fuchsia_router_config::LanProperties { |
| address_v4: None, |
| enable_dhcp_server: None, |
| dhcp_config: None, |
| address_v6: None, |
| enable_dns_forwarder: None, |
| enable: None, |
| ..fidl_fuchsia_router_config::LanProperties::EMPTY |
| }; |
| |
| responder.send(properties, not_supported!()) |
| } |
| RouterStateRequest::GetDhcpConfig { lan_id, responder } => { |
| info!("{:?}", lan_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetDnsResolver { responder } => { |
| let mut resolver = self.device.get_dns_resolver().await; |
| responder.send(&mut resolver) |
| } |
| RouterStateRequest::GetDnsForwarder { responder } => { |
| let config = fidl_fuchsia_router_config::DnsForwarderConfig { |
| element: Id { |
| uuid: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], |
| version: 0, |
| }, |
| search: fidl_fuchsia_router_config::DnsSearch { |
| domain_name: None, |
| servers: vec![], |
| }, |
| }; |
| let mut forwarder = fidl_fuchsia_router_config::DnsForwarder { |
| config, |
| interfaces: vec![], |
| resolver: vec![], |
| }; |
| responder.send(&mut forwarder) |
| } |
| RouterStateRequest::GetRoutes { responder } => responder.send(&mut [].iter_mut()), |
| RouterStateRequest::GetRoute { route_id, responder } => { |
| info!("{:?}", route_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetSecurityFeatures { responder } => { |
| let security_features = fidl_fuchsia_router_config::SecurityFeatures { |
| allow_multicast: None, |
| drop_icmp_echo: None, |
| firewall: None, |
| h323_passthru: None, |
| ipsec_passthru: None, |
| l2_tp_passthru: None, |
| nat: Some(self.device.is_nat_enabled()), |
| pptp_passthru: None, |
| rtsp_passthru: None, |
| sip_passthru: None, |
| upnp: None, |
| v6_firewall: None, |
| ..fidl_fuchsia_router_config::SecurityFeatures::EMPTY |
| }; |
| responder.send(security_features) |
| } |
| RouterStateRequest::GetPortForwards { responder } => responder.send(&mut [].iter_mut()), |
| RouterStateRequest::GetPortForward { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetPorts { responder } => { |
| self.fidl_get_ports(responder).await; |
| Ok(()) |
| } |
| RouterStateRequest::GetPort { port_id, responder } => { |
| info!("{:?}", port_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetPortTrigger { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetPortTriggers { responder } => responder.send(&mut [].iter_mut()), |
| RouterStateRequest::GetFilter { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetFilters { responder } => { |
| let result = self.device.get_filters().await.context("Error getting filters"); |
| let mut filter_rules = Vec::new(); |
| match result { |
| Ok(f) => { |
| filter_rules = f.into_iter().collect(); |
| info!("Filter rules returned: {:?}", filter_rules.len()); |
| } |
| Err(e) => error!("Failed parsing filter rules: {}", e), |
| } |
| responder.send(&mut filter_rules.iter_mut()) |
| } |
| RouterStateRequest::GetIpv6PinHole { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetIpv6PinHoles { responder } => responder.send(&mut [].iter_mut()), |
| RouterStateRequest::GetDmzHost { rule_id, responder } => { |
| info!("{:?}", rule_id); |
| responder.send(None, not_supported!()) |
| } |
| RouterStateRequest::GetSystemConfig { responder } => { |
| let config = fidl_fuchsia_router_config::SystemConfig { |
| element: None, |
| timezone: None, |
| daylight_savings_time_enabled: None, |
| leds_enabled: None, |
| hostname: None, |
| ..fidl_fuchsia_router_config::SystemConfig::EMPTY |
| }; |
| responder.send(config) |
| } |
| RouterStateRequest::GetDevice { responder } => { |
| let device = fidl_fuchsia_router_config::Device { |
| version: None, |
| topology: None, |
| config: None, |
| ..fidl_fuchsia_router_config::Device::EMPTY |
| }; |
| responder.send(device) |
| } |
| RouterStateRequest::GetWlanNetworks { responder } => { |
| responder.send(&mut vec![].into_iter()) |
| } |
| RouterStateRequest::GetRadios { responder } => responder.send(&mut vec![].into_iter()), |
| } |
| .unwrap_or_else(|e| error!("Error sending response {}", e)) |
| } |
| |
| async fn fidl_get_ports(&mut self, responder: RouterStateGetPortsResponder) { |
| let ps = self.device.ports(); |
| let mut ports: Vec<Port> = ps |
| .map(|p| Port { |
| element: Id { uuid: p.e_id.uuid().to_ne_bytes(), version: p.e_id.version() }, |
| id: p.port_id.to_u32(), |
| path: p.path.clone(), |
| }) |
| .collect(); |
| responder.send(&mut ports.iter_mut()).context("Error sending a response").unwrap(); |
| } |
| } |
