blob: 327f8910a776845b21cd2f8a618da7f00c3e23ea [file]
// 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;
}
}