| // Copyright 2024 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. | |
| //! This file contains an implementation for storing network information in a file system. | |
| //! | |
| //! Each file within `/sys/fs/fuchsia_network_monitor_fs` represents a network and its properties. | |
| use crate::NetworkManager; | |
| use serde::{Deserialize, Serialize}; | |
| use serde_repr::{Deserialize_repr, Serialize_repr}; | |
| use starnix_core::security::check_task_capable; | |
| use starnix_core::task::{CurrentTask, Kernel}; | |
| use starnix_core::vfs::fs_args::parse; | |
| use starnix_core::vfs::pseudo::simple_file::{BytesFile, BytesFileOps}; | |
| use starnix_core::vfs::{ | |
| CacheMode, FileOps, FileSystem, FileSystemHandle, FileSystemOps, FileSystemOptions, FsNode, | |
| FsNodeHandle, FsNodeInfo, FsNodeOps, FsStr, MemoryDirectoryFile, | |
| }; | |
| use starnix_logging::{log_error, log_warn}; | |
| use starnix_types::vfs::default_statfs; | |
| use starnix_uapi::auth::{CAP_NET_ADMIN, FsCred}; | |
| use starnix_uapi::device_id::DeviceId; | |
| use starnix_uapi::errors::Errno; | |
| use starnix_uapi::file_mode::{FileMode, mode}; | |
| use starnix_uapi::open_flags::OpenFlags; | |
| use starnix_uapi::{errno, error, gid_t, statfs, uid_t}; | |
| use std::borrow::Cow; | |
| use std::net::{Ipv4Addr, Ipv6Addr}; | |
| use std::sync::Arc; | |
| use fidl_fuchsia_net as fnet; | |
| use fidl_fuchsia_net_policy_properties::{self as fnp_properties, ProtoProperties}; | |
| const DEFAULT_NETWORK_FILE_NAME: &str = "default"; | |
| #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)] | |
| pub(crate) enum VersionedProperties { | |
| #[default] | |
| V2, | |
| } | |
| #[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)] | |
| pub(crate) struct NetworkMessage { | |
| pub(crate) version: VersionedProperties, | |
| pub(crate) netid: u32, | |
| pub(crate) mark: u32, | |
| pub(crate) handle: u64, | |
| #[serde(with = "addr_list")] | |
| pub(crate) dnsv4: Vec<Ipv4Addr>, | |
| #[serde(with = "addr_list")] | |
| pub(crate) dnsv6: Vec<Ipv6Addr>, | |
| #[serde(with = "transport_list")] | |
| pub(crate) transports: Vec<TransportType>, | |
| #[serde(with = "capability_list")] | |
| pub(crate) capabilities: Vec<NetworkCapability>, | |
| pub(crate) name: String, | |
| // Whether or not there is a v4/v6 address assigned for | |
| // the underlying link properties. | |
| pub(crate) addrv4: bool, | |
| pub(crate) addrv6: bool, | |
| // Whether or not there is a v4/v6 default route for | |
| // the underlying link properties. | |
| pub(crate) defaultv4: bool, | |
| pub(crate) defaultv6: bool, | |
| } | |
| #[derive(Clone, Copy, Debug, Deserialize_repr, PartialEq, Serialize_repr)] | |
| #[repr(u8)] | |
| pub(crate) enum TransportType { | |
| Cellular = 0, | |
| Wifi = 1, | |
| Bluetooth = 2, | |
| Ethernet = 3, | |
| Vpn = 4, | |
| WifiAware = 5, | |
| Lowpan = 6, | |
| Test = 7, | |
| Usb = 8, | |
| Thread = 9, | |
| Satellite = 10, | |
| } | |
| #[derive(Clone, Copy, Debug, Deserialize_repr, PartialEq, Serialize_repr)] | |
| #[repr(u8)] | |
| pub(crate) enum NetworkCapability { | |
| Mms = 0, | |
| Supl = 1, | |
| Dun = 2, | |
| Fota = 3, | |
| Ims = 4, | |
| Cbs = 5, | |
| WifiP2p = 6, | |
| Ia = 7, | |
| Rcs = 8, | |
| Xcap = 9, | |
| Eims = 10, | |
| NotMetered = 11, | |
| Internet = 12, | |
| NotRestricted = 13, | |
| Trusted = 14, | |
| NotVpn = 15, | |
| Validated = 16, | |
| CaptivePortal = 17, | |
| NotRoaming = 18, | |
| Foreground = 19, | |
| NotCongested = 20, | |
| NotSuspended = 21, | |
| OemPaid = 22, | |
| Mcs = 23, | |
| PartialConnectivity = 24, | |
| TemporarilyNotMetered = 25, | |
| OemPrivate = 26, | |
| VehicleInternal = 27, | |
| NotVcnManaged = 28, | |
| Enterprise = 29, | |
| Vsim = 30, | |
| Bip = 31, | |
| HeadUnit = 32, | |
| Mmtel = 33, | |
| PrioritizeLatency = 34, | |
| PrioritizeBandwidth = 35, | |
| LocalNetwork = 36, | |
| NotBandwidthConstrained = 37, | |
| PrioritizeUnifiedCommunications = 38, | |
| } | |
| pub struct FuchsiaNetworkMonitorFs; | |
| impl FuchsiaNetworkMonitorFs { | |
| pub fn new_fs(kernel: &Kernel, options: FileSystemOptions) -> Result<FileSystemHandle, Errno> { | |
| let mode = if let Some(mode) = options.params.get(b"mode") { | |
| FileMode::from_string(mode.as_ref())?.with_type(FileMode::IFDIR) | |
| } else { | |
| mode!(IFDIR, 0o600) | |
| }; | |
| let uid = options.params.get_as::<uid_t>(b"uid")?.unwrap_or(0); | |
| let gid = options.params.get_as::<gid_t>(b"gid")?.unwrap_or(0); | |
| let fs = FileSystem::new(kernel, CacheMode::Permanent, FuchsiaNetworkMonitorFs, options)?; | |
| let root_ino = fs.allocate_ino(); | |
| let info = FsNodeInfo::new(mode, FsCred { uid, gid }); | |
| fs.create_root_with_info(root_ino, NetworkDirectoryNode::new(), info); | |
| Ok(fs) | |
| } | |
| } | |
| const FUCHSIA_NETWORK_MONITOR_FS_NAME: &[u8; 26] = b"fuchsia_network_monitor_fs"; | |
| const FUCHSIA_NETWORK_MONITOR_FS_MAGIC: u32 = u32::from_be_bytes(*b"nmfs"); | |
| impl FileSystemOps for FuchsiaNetworkMonitorFs { | |
| fn statfs(&self, _fs: &FileSystem, _current_task: &CurrentTask) -> Result<statfs, Errno> { | |
| Ok(default_statfs(FUCHSIA_NETWORK_MONITOR_FS_MAGIC)) | |
| } | |
| fn name(&self) -> &'static FsStr { | |
| FUCHSIA_NETWORK_MONITOR_FS_NAME.into() | |
| } | |
| } | |
| pub fn fuchsia_network_monitor_fs( | |
| current_task: &CurrentTask, | |
| options: FileSystemOptions, | |
| ) -> Result<FileSystemHandle, Errno> { | |
| struct FuchsiaNetworkMonitorFsHandle(FileSystemHandle); | |
| let kernel = current_task.kernel(); | |
| Ok(kernel | |
| .expando | |
| .get_or_try_init(|| { | |
| FuchsiaNetworkMonitorFs::new_fs(kernel, options) | |
| .map(|fs| FuchsiaNetworkMonitorFsHandle(fs)) | |
| })? | |
| .0 | |
| .clone()) | |
| } | |
| // Get the NetworkManager from the Kernel's Expando. | |
| // | |
| // Returns the NetworkManager when available, or EPERM when the NetworkManager | |
| // is absent. | |
| fn try_acquire_network_manager(current_task: &CurrentTask) -> Result<Arc<NetworkManager>, Errno> { | |
| let kernel = current_task.kernel(); | |
| kernel.expando.peek::<NetworkManager>().ok_or_else(|| errno!(EPERM)) | |
| } | |
| pub struct NetworkDirectoryNode; | |
| impl NetworkDirectoryNode { | |
| pub fn new() -> Self { | |
| Self | |
| } | |
| } | |
| impl FsNodeOps for NetworkDirectoryNode { | |
| fn create_file_ops( | |
| &self, | |
| _node: &FsNode, | |
| _current_task: &CurrentTask, | |
| _flags: OpenFlags, | |
| ) -> Result<Box<dyn FileOps>, Errno> { | |
| Ok(Box::new(MemoryDirectoryFile::new())) | |
| } | |
| fn mkdir( | |
| &self, | |
| _node: &FsNode, | |
| _current_task: &CurrentTask, | |
| _name: &FsStr, | |
| _mode: FileMode, | |
| _owner: FsCred, | |
| ) -> Result<FsNodeHandle, Errno> { | |
| error!(EPERM) | |
| } | |
| fn mknod( | |
| &self, | |
| node: &FsNode, | |
| current_task: &CurrentTask, | |
| name: &FsStr, | |
| mode: FileMode, | |
| _dev: DeviceId, | |
| _owner: FsCred, | |
| ) -> Result<FsNodeHandle, Errno> { | |
| check_task_capable(current_task, CAP_NET_ADMIN)?; | |
| if !mode.is_reg() { | |
| return error!(EACCES); | |
| } | |
| let ops: Box<dyn FsNodeOps> = if name == DEFAULT_NETWORK_FILE_NAME { | |
| // The node with DEFAULT_NETWORK_FILE_NAME is special and can | |
| // only be written to with network ids. | |
| Box::new(DefaultNetworkIdFile::new_node()) | |
| } else { | |
| let id: u32 = parse(name).map_err(|_| errno!(EINVAL))?; | |
| // Insert a new network entry, but don't populate any fields. | |
| let network_manager = try_acquire_network_manager(current_task)?; | |
| // This call should only occur on the first node with this name, | |
| // so this call isn't expected to fail. | |
| network_manager.add_empty_network(id)?; | |
| Box::new(NetworkFile::new_node(id)) | |
| }; | |
| let child = node.fs().create_node_and_allocate_node_id( | |
| ops, | |
| FsNodeInfo::new(mode, current_task.current_fscred()), | |
| ); | |
| Ok(child) | |
| } | |
| fn unlink( | |
| &self, | |
| _node: &FsNode, | |
| current_task: &CurrentTask, | |
| name: &FsStr, | |
| _child: &FsNodeHandle, | |
| ) -> Result<(), Errno> { | |
| check_task_capable(current_task, CAP_NET_ADMIN)?; | |
| let network_manager = try_acquire_network_manager(current_task)?; | |
| // Note: direct equality comparisons are easier using FsStr | |
| // than using a match block. | |
| if name == DEFAULT_NETWORK_FILE_NAME { | |
| // Reset the default network when the associated | |
| // network file with the same id is unlinked. | |
| network_manager.set_default_network_id(None); | |
| } else { | |
| let id: u32 = parse(name)?; | |
| network_manager.remove_network(id)?; | |
| } | |
| Ok(()) | |
| } | |
| fn create_symlink( | |
| &self, | |
| _node: &FsNode, | |
| _current_task: &CurrentTask, | |
| _name: &FsStr, | |
| _target: &FsStr, | |
| _owner: FsCred, | |
| ) -> Result<FsNodeHandle, Errno> { | |
| error!(EPERM) | |
| } | |
| } | |
| pub struct NetworkFile { | |
| network_id: u32, | |
| } | |
| impl NetworkFile { | |
| pub fn new_node(network_id: u32) -> impl FsNodeOps { | |
| BytesFile::new_node(Self { network_id }) | |
| } | |
| } | |
| impl BytesFileOps for NetworkFile { | |
| fn write(&self, current_task: &CurrentTask, data: Vec<u8>) -> Result<(), Errno> { | |
| check_task_capable(current_task, CAP_NET_ADMIN)?; | |
| let network: NetworkMessage = serde_json::from_slice(&data).map_err(|e| { | |
| log_error!("failed to deserialize network message: {}", e); | |
| errno!(EINVAL) | |
| })?; | |
| let new_netid = network.netid; | |
| // The network id must be the same as the id listed in the JSON. | |
| if new_netid != self.network_id { | |
| return error!(EINVAL); | |
| } | |
| let network_manager = try_acquire_network_manager(current_task)?; | |
| match network_manager.get_network(&new_netid) { | |
| None | Some(None) => { | |
| network_manager.add_network(network)?; | |
| } | |
| Some(Some(_old_network)) => { | |
| network_manager.update_network(network)?; | |
| } | |
| } | |
| Ok(()) | |
| } | |
| fn read(&self, current_task: &CurrentTask) -> Result<Cow<'_, [u8]>, Errno> { | |
| let network_manager = try_acquire_network_manager(current_task)?; | |
| // Verify whether the network exists before reading. | |
| if let None = network_manager.get_network(&self.network_id) { | |
| return error!(ENOENT); | |
| } | |
| Ok(network_manager.get_network_by_id_as_bytes(self.network_id).to_vec().into()) | |
| } | |
| } | |
| pub struct DefaultNetworkIdFile {} | |
| impl DefaultNetworkIdFile { | |
| pub fn new_node() -> impl FsNodeOps { | |
| BytesFile::new_node(Self {}) | |
| } | |
| } | |
| impl BytesFileOps for DefaultNetworkIdFile { | |
| fn write(&self, current_task: &CurrentTask, data: Vec<u8>) -> Result<(), Errno> { | |
| check_task_capable(current_task, CAP_NET_ADMIN)?; | |
| let id_string = std::str::from_utf8(&data).map_err(|_| errno!(EINVAL))?; | |
| let id: u32 = id_string.parse().map_err(|_| errno!(EINVAL))?; | |
| { | |
| let network_manager = try_acquire_network_manager(current_task)?; | |
| match network_manager.get_network(&id) { | |
| // A network with the provided id must already | |
| // exist to become the default network. | |
| Some(Some(_)) => { | |
| network_manager.set_default_network_id(Some(id)); | |
| } | |
| // The network properties must be provided for | |
| // a network before it can become the default. | |
| Some(None) | None => return error!(ENOENT), | |
| }; | |
| } | |
| Ok(()) | |
| } | |
| fn read(&self, current_task: &CurrentTask) -> Result<Cow<'_, [u8]>, Errno> { | |
| let network_manager = try_acquire_network_manager(current_task)?; | |
| if let None = network_manager.get_default_network_id() { | |
| return error!(ENOENT); | |
| } | |
| Ok(network_manager.get_default_id_as_bytes().to_vec().into()) | |
| } | |
| } | |
| impl From<&NetworkMessage> for fnp_properties::Network { | |
| fn from(message: &NetworkMessage) -> Self { | |
| Self { | |
| network_id: Some(message.netid), | |
| info: Some(fnp_properties::NetworkInfo::Starnix(fnp_properties::StarnixNetworkInfo { | |
| mark: Some(message.mark), | |
| handle: Some(message.handle), | |
| ..Default::default() | |
| })), | |
| dns_servers: Some(fnp_properties::NetworkDnsServers { | |
| v4: Some( | |
| message | |
| .dnsv4 | |
| .clone() | |
| .into_iter() | |
| .map(|a| fnet::Ipv4Address { addr: a.octets() }) | |
| .collect::<Vec<_>>(), | |
| ), | |
| v6: Some( | |
| message | |
| .dnsv6 | |
| .clone() | |
| .into_iter() | |
| .map(|a| fnet::Ipv6Address { addr: a.octets() }) | |
| .collect::<Vec<_>>(), | |
| ), | |
| ..Default::default() | |
| }), | |
| network_type: Some(consolidate_transport_types_to_network_type(&message.transports)), | |
| capabilities: Some(convert_capabilities(&message.capabilities)), | |
| connectivity: Some(convert_connectivity_state(&message.capabilities)), | |
| name: Some(message.name.clone()), | |
| has_address: Some(proto_properties_from_v4_v6(message.addrv4, message.addrv6)), | |
| has_default_route: Some(proto_properties_from_v4_v6( | |
| message.defaultv4, | |
| message.defaultv6, | |
| )), | |
| ..Default::default() | |
| } | |
| } | |
| } | |
| fn proto_properties_from_v4_v6(v4: bool, v6: bool) -> ProtoProperties { | |
| let mut properties = ProtoProperties::empty(); | |
| if v4 { | |
| properties |= ProtoProperties::V4; | |
| } | |
| if v6 { | |
| properties |= ProtoProperties::V6; | |
| } | |
| properties | |
| } | |
| // Given a list of `TransportType`, convert it to a single `NetworkType`. Only a single | |
| // transport is expected, so take the first one if multiple are present. If none are | |
| // present, Unknown is used as a fallback. | |
| fn consolidate_transport_types_to_network_type( | |
| value: &Vec<TransportType>, | |
| ) -> fnp_properties::NetworkType { | |
| value | |
| .iter() | |
| .filter_map(|tt| maybe_network_type_from_transport_type(*tt)) | |
| .next() | |
| .unwrap_or(fnp_properties::NetworkType::Unknown) | |
| } | |
| fn maybe_network_type_from_transport_type( | |
| value: TransportType, | |
| ) -> Option<fnp_properties::NetworkType> { | |
| match value { | |
| TransportType::Ethernet => Some(fnp_properties::NetworkType::Ethernet), | |
| TransportType::Wifi => Some(fnp_properties::NetworkType::Wifi), | |
| TransportType::Bluetooth => Some(fnp_properties::NetworkType::Bluetooth), | |
| TransportType::Cellular => Some(fnp_properties::NetworkType::Cellular), | |
| TransportType::Vpn | |
| | TransportType::WifiAware | |
| | TransportType::Lowpan | |
| | TransportType::Test | |
| | TransportType::Usb | |
| | TransportType::Thread | |
| | TransportType::Satellite => { | |
| log_warn!("Known NetworkType {value:?} is not currently supported"); | |
| None | |
| } | |
| } | |
| } | |
| // Currently, we only check for the following capabilities: NotMetered, NotCongested, | |
| // NotBandwidthConstrained. If we wish to have more knowledge of the offered capabilities, | |
| // we can consider adding fields to the fnp_properties::NetworkRegistry FIDL API. | |
| fn convert_capabilities(value: &Vec<NetworkCapability>) -> Vec<fnp_properties::NetworkCapability> { | |
| value | |
| .iter() | |
| .filter_map(|c| match c { | |
| NetworkCapability::NotMetered => Some(fnp_properties::NetworkCapability::UNMETERED), | |
| NetworkCapability::NotCongested => Some(fnp_properties::NetworkCapability::UNCONGESTED), | |
| NetworkCapability::NotBandwidthConstrained => { | |
| Some(fnp_properties::NetworkCapability::NOT_BANDWIDTH_CONSTRAINED) | |
| } | |
| _ => None, | |
| }) | |
| .collect::<Vec<_>>() | |
| } | |
| fn convert_connectivity_state(value: &Vec<NetworkCapability>) -> fnp_properties::ConnectivityState { | |
| // Validated and Internet capabilities indicate that the network has been | |
| // validated to have internet connectivity (HTTP and DNS). | |
| if value.contains(&NetworkCapability::Validated) && value.contains(&NetworkCapability::Internet) | |
| { | |
| return fnp_properties::ConnectivityState::FullConnectivity; | |
| } | |
| if value.contains(&NetworkCapability::PartialConnectivity) { | |
| return fnp_properties::ConnectivityState::PartialConnectivity; | |
| } | |
| if value.contains(&NetworkCapability::LocalNetwork) { | |
| return fnp_properties::ConnectivityState::LocalConnectivity; | |
| } | |
| return fnp_properties::ConnectivityState::NoConnectivity; | |
| } | |
| mod addr_list { | |
| use serde::{Deserialize, Deserializer, Serialize, Serializer, de}; | |
| pub fn serialize<S, Addr>(addr: &Vec<Addr>, serializer: S) -> Result<S::Ok, S::Error> | |
| where | |
| S: Serializer, | |
| Addr: std::fmt::Display, | |
| { | |
| let strings = addr.iter().map(|x| x.to_string()).collect::<Vec<_>>(); | |
| strings.serialize(serializer) | |
| } | |
| pub fn deserialize<'de, D, Addr>(deserializer: D) -> Result<Vec<Addr>, D::Error> | |
| where | |
| D: Deserializer<'de>, | |
| Addr: std::str::FromStr, | |
| Addr::Err: std::fmt::Display, | |
| { | |
| let s = Vec::<String>::deserialize(deserializer)?; | |
| s.into_iter().map(|s| s.parse().map_err(de::Error::custom)).collect() | |
| } | |
| } | |
| macro_rules! tolerant_repr_serde_impl { | |
| ($module_name:ident, $NewType:path) => { | |
| mod $module_name { | |
| use serde::{Deserialize, Deserializer, Serialize, Serializer}; | |
| use starnix_logging::log_error; | |
| pub fn serialize<S>(items: &Vec<$NewType>, serializer: S) -> Result<S::Ok, S::Error> | |
| where | |
| S: Serializer, | |
| { | |
| let nums = items.iter().map(|item| *item as u8).collect::<Vec<_>>(); | |
| nums.serialize(serializer) | |
| } | |
| pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<$NewType>, D::Error> | |
| where | |
| D: Deserializer<'de>, | |
| { | |
| let vals = Vec::<serde_json::Value>::deserialize(deserializer)?; | |
| Ok(vals | |
| .into_iter() | |
| .filter_map(|val| match serde_json::from_value::<$NewType>(val.clone()) { | |
| Ok(s) => Some(s), | |
| Err(_) => { | |
| log_error!("unknown value: {}", val); | |
| None | |
| } | |
| }) | |
| .collect()) | |
| } | |
| } | |
| }; | |
| } | |
| tolerant_repr_serde_impl!(transport_list, crate::TransportType); | |
| tolerant_repr_serde_impl!(capability_list, crate::NetworkCapability); | |
| #[cfg(test)] | |
| mod tests { | |
| use super::*; | |
| use net_declare::{std_ip_v4, std_ip_v6}; | |
| use starnix_core::testing::spawn_kernel_and_run; | |
| use starnix_core::vfs::fs_args::MountParams; | |
| use test_case::test_case; | |
| #[::fuchsia::test] | |
| fn network_message_serde_version2() { | |
| let network = NetworkMessage { | |
| version: VersionedProperties::V2, | |
| netid: 123, | |
| mark: 456, | |
| handle: 789, | |
| dnsv4: vec![std_ip_v4!("192.168.0.1")], | |
| dnsv6: vec![std_ip_v6!("2001:db8::1")], | |
| transports: vec![ | |
| TransportType::Cellular, | |
| TransportType::Wifi, | |
| TransportType::Bluetooth, | |
| TransportType::Ethernet, | |
| TransportType::Vpn, | |
| TransportType::WifiAware, | |
| TransportType::Lowpan, | |
| TransportType::Test, | |
| TransportType::Usb, | |
| TransportType::Thread, | |
| TransportType::Satellite, | |
| ], | |
| capabilities: vec![ | |
| NetworkCapability::Trusted, | |
| NetworkCapability::Internet, | |
| NetworkCapability::Validated, | |
| ], | |
| name: "test01".to_string(), | |
| addrv4: false, | |
| addrv6: true, | |
| defaultv4: false, | |
| defaultv6: true, | |
| }; | |
| serde_helper(network); | |
| } | |
| #[::fuchsia::test] | |
| fn network_message_serde_missing_version_rejected() { | |
| let json = r#"{ | |
| "netid": 123, | |
| "mark": 456, | |
| "handle": 789, | |
| "dnsv4": ["192.168.0.1"], | |
| "dnsv6": ["2001:db8::1"], | |
| "transports": [], | |
| "capabilities": [], | |
| "name": "test", | |
| "addrv4": false, | |
| "addrv6": false, | |
| "defaultv4": false, | |
| "defaultv6": false | |
| }"#; | |
| assert!(serde_json::from_str::<NetworkMessage>(json).is_err()); | |
| } | |
| #[::fuchsia::test] | |
| fn network_message_serde_v1_rejected() { | |
| let json = r#"{ | |
| "netid": 123, | |
| "mark": 456, | |
| "handle": 789, | |
| "dnsv4": ["192.168.0.1"], | |
| "dnsv6": ["2001:db8::1"], | |
| "version": "V1", | |
| "transports": [], | |
| "capabilities": [], | |
| "name": "test", | |
| "addrv4": false, | |
| "addrv6": false, | |
| "defaultv4": false, | |
| "defaultv6": false | |
| }"#; | |
| assert!(serde_json::from_str::<NetworkMessage>(json).is_err()); | |
| } | |
| #[::fuchsia::test] | |
| fn network_message_serde_invalid_version_rejected() { | |
| let json = r#"{ | |
| "netid": 123, | |
| "mark": 456, | |
| "handle": 789, | |
| "dnsv4": ["192.168.0.1"], | |
| "dnsv6": ["2001:db8::1"], | |
| "version": "V9999", | |
| "transports": [], | |
| "capabilities": [], | |
| "name": "test", | |
| "addrv4": false, | |
| "addrv6": false, | |
| "defaultv4": false, | |
| "defaultv6": false | |
| }"#; | |
| assert!(serde_json::from_str::<NetworkMessage>(json).is_err()); | |
| } | |
| #[::fuchsia::test] | |
| fn network_message_serde_unknown_transports_and_capabilities() { | |
| let json = r#"{ | |
| "netid": 123, | |
| "mark": 456, | |
| "handle": 789, | |
| "dnsv4": ["192.168.0.1"], | |
| "dnsv6": ["2001:db8::1"], | |
| "version": "V2", | |
| "transports": [1, 99, 3], | |
| "capabilities": [11, 99], | |
| "name": "test01", | |
| "addrv4": false, | |
| "addrv6": false, | |
| "defaultv4": false, | |
| "defaultv6": false | |
| }"#; | |
| let expected = NetworkMessage { | |
| version: VersionedProperties::V2, | |
| netid: 123, | |
| mark: 456, | |
| handle: 789, | |
| dnsv4: vec![std_ip_v4!("192.168.0.1")], | |
| dnsv6: vec![std_ip_v6!("2001:db8::1")], | |
| transports: vec![TransportType::Wifi, TransportType::Ethernet], | |
| capabilities: vec![NetworkCapability::NotMetered], | |
| name: "test01".to_string(), | |
| addrv4: false, | |
| addrv6: false, | |
| defaultv4: false, | |
| defaultv6: false, | |
| }; | |
| let deserialized: NetworkMessage = serde_json::from_str(json).unwrap(); | |
| assert_eq!(expected, deserialized); | |
| } | |
| #[::fuchsia::test] | |
| fn network_message_serde_usb_and_extended_transports() { | |
| let json = r#"{ | |
| "netid": 100, | |
| "mark": 65536, | |
| "handle": 432932703437, | |
| "dnsv4": [], | |
| "dnsv6": [], | |
| "version": "V2", | |
| "transports": [7, 8, 9, 10], | |
| "capabilities": [13, 14, 15], | |
| "name": "usb0", | |
| "addrv4": true, | |
| "addrv6": true, | |
| "defaultv4": false, | |
| "defaultv6": false | |
| }"#; | |
| let deserialized: NetworkMessage = serde_json::from_str(json).unwrap(); | |
| assert_eq!( | |
| deserialized, | |
| NetworkMessage { | |
| version: VersionedProperties::V2, | |
| netid: 100, | |
| mark: 65536, | |
| handle: 432932703437, | |
| dnsv4: vec![], | |
| dnsv6: vec![], | |
| transports: vec![ | |
| TransportType::Test, | |
| TransportType::Usb, | |
| TransportType::Thread, | |
| TransportType::Satellite, | |
| ], | |
| capabilities: vec![ | |
| NetworkCapability::NotRestricted, | |
| NetworkCapability::Trusted, | |
| NetworkCapability::NotVpn, | |
| ], | |
| name: "usb0".to_string(), | |
| addrv4: true, | |
| addrv6: true, | |
| defaultv4: false, | |
| defaultv6: false, | |
| } | |
| ); | |
| } | |
| // Ensure that a provided NetworkMessage can be serialized and | |
| // deserialized into the original form. | |
| fn serde_helper(network: NetworkMessage) { | |
| let serialized = serde_json::to_string(&network).unwrap_or_else(|_| "{}".to_string()); | |
| let deserialized = serde_json::from_str(&serialized).unwrap(); | |
| assert_eq!(network, deserialized); | |
| } | |
| #[test_case(vec![TransportType::Cellular], fnp_properties::NetworkType::Cellular; | |
| "cellular")] | |
| #[test_case(vec![TransportType::Wifi], fnp_properties::NetworkType::Wifi; | |
| "wifi")] | |
| #[test_case(vec![TransportType::Bluetooth], fnp_properties::NetworkType::Bluetooth; | |
| "bluetooth")] | |
| #[test_case(vec![TransportType::Ethernet], fnp_properties::NetworkType::Ethernet; | |
| "ethernet")] | |
| #[test_case( | |
| vec![ | |
| TransportType::Wifi, | |
| TransportType::Cellular | |
| ], | |
| fnp_properties::NetworkType::Wifi; "first_transport_prioritized")] | |
| #[test_case(vec![], fnp_properties::NetworkType::Unknown; "empty_fallback")] | |
| #[test_case( | |
| vec![ | |
| TransportType::Lowpan, | |
| TransportType::WifiAware, | |
| TransportType::Vpn, | |
| TransportType::Test, | |
| TransportType::Usb, | |
| TransportType::Thread, | |
| TransportType::Satellite, | |
| ], | |
| fnp_properties::NetworkType::Unknown; "none_applicable")] | |
| #[test_case( | |
| vec![ | |
| TransportType::Usb, | |
| TransportType::Wifi, | |
| ], | |
| fnp_properties::NetworkType::Wifi; "supported_transport_after_usb")] | |
| #[::fuchsia::test] | |
| fn test_consolidate_transport_types_to_network_type( | |
| transports: Vec<TransportType>, | |
| expected: fnp_properties::NetworkType, | |
| ) { | |
| assert_eq!(consolidate_transport_types_to_network_type(&transports), expected); | |
| } | |
| #[test_case( | |
| vec![ | |
| NetworkCapability::NotMetered, | |
| NetworkCapability::NotCongested, | |
| NetworkCapability::NotBandwidthConstrained, | |
| ], | |
| vec![ | |
| fnp_properties::NetworkCapability::UNMETERED, | |
| fnp_properties::NetworkCapability::UNCONGESTED, | |
| fnp_properties::NetworkCapability::NOT_BANDWIDTH_CONSTRAINED, | |
| ]; | |
| "all_capabilities" | |
| )] | |
| #[test_case( | |
| vec![NetworkCapability::NotMetered], | |
| vec![fnp_properties::NetworkCapability::UNMETERED]; | |
| "one_capability" | |
| )] | |
| #[test_case( | |
| vec![], | |
| vec![]; | |
| "no_capabilities" | |
| )] | |
| #[test_case( | |
| vec![ | |
| NetworkCapability::NotMetered, | |
| NetworkCapability::Trusted, // This should be ignored. | |
| ], | |
| vec![fnp_properties::NetworkCapability::UNMETERED]; | |
| "ignore_unrelated" | |
| )] | |
| #[::fuchsia::test] | |
| fn test_convert_capabilities( | |
| capabilities: Vec<NetworkCapability>, | |
| expected: Vec<fnp_properties::NetworkCapability>, | |
| ) { | |
| let mut result = convert_capabilities(&capabilities); | |
| result.sort(); | |
| let mut expected_sorted = expected; | |
| expected_sorted.sort(); | |
| assert_eq!(result, expected_sorted); | |
| } | |
| #[test_case( | |
| vec![ | |
| NetworkCapability::Validated, | |
| NetworkCapability::Internet, | |
| ], | |
| fnp_properties::ConnectivityState::FullConnectivity; | |
| "full_connectivity" | |
| )] | |
| #[test_case( | |
| vec![ | |
| NetworkCapability::Validated, | |
| NetworkCapability::Internet, | |
| NetworkCapability::LocalNetwork, | |
| ], | |
| fnp_properties::ConnectivityState::FullConnectivity; | |
| "full_connectivity_prioritized" | |
| )] | |
| #[test_case( | |
| vec![NetworkCapability::PartialConnectivity], | |
| fnp_properties::ConnectivityState::PartialConnectivity; | |
| "partial_connectivity" | |
| )] | |
| #[test_case( | |
| vec![NetworkCapability::LocalNetwork], | |
| fnp_properties::ConnectivityState::LocalConnectivity; | |
| "local_connectivity" | |
| )] | |
| #[test_case( | |
| vec![], | |
| fnp_properties::ConnectivityState::NoConnectivity; | |
| "no_connectivity" | |
| )] | |
| #[test_case( | |
| vec![NetworkCapability::Trusted], // This should be ignored. | |
| fnp_properties::ConnectivityState::NoConnectivity; | |
| "ignore_unrelated" | |
| )] | |
| #[::fuchsia::test] | |
| fn test_convert_connectivity_state( | |
| capabilities: Vec<NetworkCapability>, | |
| expected: fnp_properties::ConnectivityState, | |
| ) { | |
| assert_eq!(convert_connectivity_state(&capabilities), expected); | |
| } | |
| #[::fuchsia::test] | |
| async fn test_mode_option() { | |
| spawn_kernel_and_run(async |current_task| { | |
| let kernel = current_task.kernel(); | |
| let fs = FuchsiaNetworkMonitorFs::new_fs( | |
| &kernel, | |
| FileSystemOptions { | |
| params: MountParams::parse(b"mode=0123,uid=1000,gid=2000".into()) | |
| .expect("parsed correctly"), | |
| ..Default::default() | |
| }, | |
| ) | |
| .expect("new_fs"); | |
| { | |
| let info = fs.root().node.info(); | |
| assert_eq!(info.mode, mode!(IFDIR, 0o123)); | |
| assert_eq!(info.uid, 1000); | |
| assert_eq!(info.gid, 2000); | |
| } | |
| // Test defaults. | |
| let fs = FuchsiaNetworkMonitorFs::new_fs(&kernel, FileSystemOptions::default()) | |
| .expect("new_fs"); | |
| { | |
| let info = fs.root().node.info(); | |
| assert_eq!(info.mode, mode!(IFDIR, 0o600)); | |
| assert_eq!(info.uid, 0); | |
| assert_eq!(info.gid, 0); | |
| } | |
| }) | |
| .await; | |
| } | |
| } |